| OpenSubdiv

Loading...
Searching...
No Matches
loopScheme.h
Go to the documentation of this file.
1//
2// Copyright 2014 DreamWorks Animation LLC.
3//
4// Licensed under the Apache License, Version 2.0 (the "Apache License")
5// with the following modification; you may not use this file except in
6// compliance with the Apache License and the following modification to it:
7// Section 6. Trademarks. is deleted and replaced with:
8//
9// 6. Trademarks. This License does not grant permission to use the trade
10// names, trademarks, service marks, or product names of the Licensor
11// and its affiliates, except as required to comply with Section 4(c) of
12// the License and to reproduce the content of the NOTICE file.
13//
14// You may obtain a copy of the Apache License at
15//
16// http://www.apache.org/licenses/LICENSE-2.0
17//
18// Unless required by applicable law or agreed to in writing, software
19// distributed under the Apache License with the above modification is
20// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
21// KIND, either express or implied. See the Apache License for the specific
22// language governing permissions and limitations under the Apache License.
23//
24#ifndef OPENSUBDIV3_SDC_LOOP_SCHEME_H
25#define OPENSUBDIV3_SDC_LOOP_SCHEME_H
26
27#include "../version.h"
28
29#include "../sdc/scheme.h"
30
31#include <cassert>
32#include <cmath>
33
34 namespace OpenSubdiv {
35 namespace OPENSUBDIV_VERSION {
36 namespace Sdc {
37
38
39//
40// Specializations for Sdc::Scheme<SCHEME_LOOP>:
41//
42//
43
44//
45// Loop traits:
46//
47 template <>
48 inline Split Scheme<SCHEME_LOOP>::GetTopologicalSplitType() { return SPLIT_TO_TRIS; }
49
50 template <>
51 inline int Scheme<SCHEME_LOOP>::GetRegularFaceSize() { return 3; }
52
53 template <>
54 inline int Scheme<SCHEME_LOOP>::GetRegularVertexValence() { return 6; }
55
56 template <>
57 inline int Scheme<SCHEME_LOOP>::GetLocalNeighborhoodSize() { return 1; }
58
59
60//
61// Protected methods to assign the two types of masks for an edge-vertex --
62// Crease and Smooth.
63//
64// The Crease case does not really need to be specialized, though it may be
65// preferable to define all explicitly here.
66//
67 template <>
68 template <typename EDGE, typename MASK>
69 inline void
70 Scheme<SCHEME_LOOP>::assignCreaseMaskForEdge(EDGE const&, MASK& mask) const
71{
72 mask.SetNumVertexWeights(2);
73 mask.SetNumEdgeWeights(0);
74 mask.SetNumFaceWeights(0);
75 mask.SetFaceWeightsForFaceCenters(false);
76
77 mask.VertexWeight(0) = 0.5f;
78 mask.VertexWeight(1) = 0.5f;
79}
80
81 template <>
82 template <typename EDGE, typename MASK>
83 inline void
84 Scheme<SCHEME_LOOP>::assignSmoothMaskForEdge(EDGE const& edge, MASK& mask) const
85{
86 int faceCount = edge.GetNumFaces();
87
88 mask.SetNumVertexWeights(2);
89 mask.SetNumEdgeWeights(0);
90 mask.SetNumFaceWeights(faceCount);
91 mask.SetFaceWeightsForFaceCenters(false);
92
93 //
94 // This is where we run into the issue of "face weights" -- we want to weight the
95 // face-centers for Catmark, but face-centers are not generated for Loop. So do
96 // we make assumptions on how the mask is used, assign some property to the mask
97 // to indicate how they were assigned, or take input from the mask itself?
98 //
99 // Regardless, we have two choices:
100 // - face-weights are for the vertices opposite the edge (as in Hbr):
101 // vertex weights = 0.375f;
102 // face weights = 0.125f;
103 //
104 // - face-weights are for the face centers:
105 // vertex weights = 0.125f;
106 // face weights = 0.375f;
107 //
108 // Coincidentally the coefficients are the same but reversed.
109 //
110 typedef typename MASK::Weight Weight;
111
112 Weight vWeight = mask.AreFaceWeightsForFaceCenters() ? 0.125f : 0.375f;
113 Weight fWeight = mask.AreFaceWeightsForFaceCenters() ? 0.375f : 0.125f;
114
115 mask.VertexWeight(0) = vWeight;
116 mask.VertexWeight(1) = vWeight;
117
118 if (faceCount == 2) {
119 mask.FaceWeight(0) = fWeight;
120 mask.FaceWeight(1) = fWeight;
121 } else {
122 // The non-manifold case is not clearly defined -- we adjust the above
123 // face-weight to preserve the ratio of edge-center and face-centers:
124 fWeight *= 2.0f / (Weight) faceCount;
125 for (int i = 0; i < faceCount; ++i) {
126 mask.FaceWeight(i) = fWeight;
127 }
128 }
129}
130
131
132//
133// Protected methods to assign the three types of masks for a vertex-vertex --
134// Corner, Crease and Smooth (Dart is the same as Smooth).
135//
136// Corner and Crease do not really need to be specialized, though it may be
137// preferable to define all explicitly here.
138//
139 template <>
140 template <typename VERTEX, typename MASK>
141 inline void
142 Scheme<SCHEME_LOOP>::assignCornerMaskForVertex(VERTEX const&, MASK& mask) const
143{
144 mask.SetNumVertexWeights(1);
145 mask.SetNumEdgeWeights(0);
146 mask.SetNumFaceWeights(0);
147 mask.SetFaceWeightsForFaceCenters(false);
148
149 mask.VertexWeight(0) = 1.0f;
150}
151
152 template <>
153 template <typename VERTEX, typename MASK>
154 inline void
155 Scheme<SCHEME_LOOP>::assignCreaseMaskForVertex(VERTEX const& vertex, MASK& mask,
156 int const creaseEnds[2]) const {
157 typedef typename MASK::Weight Weight;
158
159 int valence = vertex.GetNumEdges();
160
161 mask.SetNumVertexWeights(1);
162 mask.SetNumEdgeWeights(valence);
163 mask.SetNumFaceWeights(0);
164 mask.SetFaceWeightsForFaceCenters(false);
165
166 Weight vWeight = 0.75f;
167 Weight eWeight = 0.125f;
168
169 mask.VertexWeight(0) = vWeight;
170 for (int i = 0; i < valence; ++i) {
171 mask.EdgeWeight(i) = 0.0f;
172 }
173 mask.EdgeWeight(creaseEnds[0]) = eWeight;
174 mask.EdgeWeight(creaseEnds[1]) = eWeight;
175}
176
177 template <>
178 template <typename VERTEX, typename MASK>
179 inline void
180 Scheme<SCHEME_LOOP>::assignSmoothMaskForVertex(VERTEX const& vertex, MASK& mask) const
181{
182 typedef typename MASK::Weight Weight;
183
184 int valence = vertex.GetNumFaces();
185
186 mask.SetNumVertexWeights(1);
187 mask.SetNumEdgeWeights(valence);
188 mask.SetNumFaceWeights(0);
189 mask.SetFaceWeightsForFaceCenters(false);
190
191 // Specialize for the regular case: 1/16 per edge-vert, 5/8 for the vert itself:
192 Weight eWeight = (Weight) 0.0625f;
193 Weight vWeight = (Weight) 0.625f;
194
195 if (valence != 6) {
196 // From HbrLoopSubdivision<T>::Subdivide(mesh, vertex):
197 // - could use some lookup tables here for common irregular valence (5, 7, 8)
198 // or all of these cosine calls will be adding up...
199
200 double dValence = (double) valence;
201 double invValence = 1.0f / dValence;
202 double cosTheta = std::cos(M_PI * 2.0f * invValence);
203
204 double beta = 0.25f * cosTheta + 0.375f;
205
206 eWeight = (Weight) ((0.625f - (beta * beta)) * invValence);
207 vWeight = (Weight) (1.0f - (eWeight * dValence));
208 }
209
210 mask.VertexWeight(0) = vWeight;
211 for (int i = 0; i < valence; ++i) {
212 mask.EdgeWeight(i) = eWeight;
213 }
214}
215
216
217//
218// Limit masks for position:
219//
220 template <>
221 template <typename VERTEX, typename MASK>
222 inline void
223 Scheme<SCHEME_LOOP>::assignCornerLimitMask(VERTEX const& /* vertex */, MASK& posMask) const {
224
225 posMask.SetNumVertexWeights(1);
226 posMask.SetNumEdgeWeights(0);
227 posMask.SetNumFaceWeights(0);
228 posMask.SetFaceWeightsForFaceCenters(false);
229
230 posMask.VertexWeight(0) = 1.0f;
231}
232
233 template <>
234 template <typename VERTEX, typename MASK>
235 inline void
236 Scheme<SCHEME_LOOP>::assignCreaseLimitMask(VERTEX const& vertex, MASK& posMask,
237 int const creaseEnds[2]) const {
238
239 typedef typename MASK::Weight Weight;
240
241 int valence = vertex.GetNumEdges();
242
243 posMask.SetNumVertexWeights(1);
244 posMask.SetNumEdgeWeights(valence);
245 posMask.SetNumFaceWeights(0);
246 posMask.SetFaceWeightsForFaceCenters(false);
247
248 //
249 // The refinement mask for a crease vertex is (1/8, 3/4, 1/8) and for a crease
250 // edge is (1/2, 1/2) -- producing a uniform B-spline curve along the crease
251 // (boundary) whether the vertex or its crease is regular or not. The limit
252 // mask is therefore (1/6, 2/3, 1/6) for ALL cases.
253 //
254 // An alternative limit mask (1/5, 3/5, 1/5) is often published for use either
255 // for irregular crease vertices or for all crease/boundary vertices, but this
256 // is based on an alternate refinement mask for the edge -- (3/8, 5/8) versus
257 // the usual (1/2, 1/2) -- and will not produce the B-spline curve desired.
258 //
259 Weight vWeight = (Weight) (4.0 / 6.0);
260 Weight eWeight = (Weight) (1.0 / 6.0);
261
262 posMask.VertexWeight(0) = vWeight;
263 for (int i = 0; i < valence; ++i) {
264 posMask.EdgeWeight(i) = 0.0f;
265 }
266 posMask.EdgeWeight(creaseEnds[0]) = eWeight;
267 posMask.EdgeWeight(creaseEnds[1]) = eWeight;
268}
269
270 template <>
271 template <typename VERTEX, typename MASK>
272 inline void
273 Scheme<SCHEME_LOOP>::assignSmoothLimitMask(VERTEX const& vertex, MASK& posMask) const {
274
275 typedef typename MASK::Weight Weight;
276
277 int valence = vertex.GetNumFaces();
278
279 posMask.SetNumVertexWeights(1);
280 posMask.SetNumEdgeWeights(valence);
281 posMask.SetNumFaceWeights(0);
282 posMask.SetFaceWeightsForFaceCenters(false);
283
284 // Specialize for the regular case: 1/12 per edge-vert, 1/2 for the vert itself:
285 if (valence == 6) {
286 Weight eWeight = (Weight) (1.0 / 12.0);
287 Weight vWeight = 0.5f;
288
289 posMask.VertexWeight(0) = vWeight;
290
291 posMask.EdgeWeight(0) = eWeight;
292 posMask.EdgeWeight(1) = eWeight;
293 posMask.EdgeWeight(2) = eWeight;
294 posMask.EdgeWeight(3) = eWeight;
295 posMask.EdgeWeight(4) = eWeight;
296 posMask.EdgeWeight(5) = eWeight;
297
298 } else {
299 double dValence = (double) valence;
300 double invValence = 1.0f / dValence;
301 double cosTheta = std::cos(M_PI * 2.0f * invValence);
302
303 double beta = 0.25f * cosTheta + 0.375f;
304 double gamma = (0.625f - (beta * beta)) * invValence;
305
306 Weight eWeight = (Weight) (1.0f / (dValence + 3.0f / (8.0f * gamma)));
307 Weight vWeight = (Weight) (1.0f - (eWeight * dValence));
308
309 posMask.VertexWeight(0) = vWeight;
310 for (int i = 0; i < valence; ++i) {
311 posMask.EdgeWeight(i) = eWeight;
312 }
313 }
314}
315
316/*
317// Limit masks for tangents:
318//
319// A note on tangent magnitudes:
320//
321// Several formulae exist for limit tangents at a vertex to accommodate the
322// different topological configurations around the vertex. While these produce
323// the desired direction, there is inconsistency in the resulting magnitudes.
324// Ideally a regular mesh of uniformly shaped triangles with similar edge lengths
325// should produce tangents of similar magnitudes throughout -- including corners
326// and boundaries. So some of the common formulae for these are adjusted with
327// scale factors.
328//
329// For uses where magnitude does not matter, this scaling should be irrelevant.
330// But just as with patches, where the magnitudes of partial derivatives are
331// consistent between similar patches, the magnitudes of limit tangents should
332// also be similar.
333//
334// The reference tangents, in terms of magnitudes, are those produced by the
335// limit tangent mask for smooth interior vertices, for which well established
336// sin/cos formulae apply -- these remain unscaled. Formulae for the other
337// crease/boundary, corner tangents and irregular cases are scaled to be more
338// consistent with these.
339//
340// The crease/boundary tangents for the regular case can be viewed as derived
341// from the smooth interior masks with two "phantom" points extrapolated across
342// the regular boundary:
343//
344// v3 v2
345// X - - - - - X
346// / \ / \
347// / \ / \
348// v4 X - - - - - X - - - - - X v1
349// . . 0 . .
350// . . . .
351// . . . .
352// (v5) (v6)
353//
354// where v5 = v0 + (v4 - v3) and v6 = v0 + v1 - v2.
355//
356// When the standard limit tangent mask is applied, the cosines of increments
357// of pi/3 give us coefficients that are multiples of 1/2, leading to the first
358// tangent T1 = 3/2 * (v1 - v4), rather than the widely used T1 = v1 - v4. So
359// this scale factor of 3/2 is applied to ensure tangents along the boundaries
360// are of similar magnitude as tangents in the immediate interior (which may be
361// parallel).
362//
363// Tangents at corners are essentially a form of boundary tangent, and so its
364// simple difference formula is scaled to be consistent with adjoining boundary
365// tangents -- not just with the 3/2 factor from above, but with an additional
366// 2.0 to compensate for the fact that the difference of only side of the vertex
367// is considered here. The resulting scale factor of 3.0 for the regular corner
368// is what similarly arises by extrapolating an interior region around the
369// vertex and using the interior mask for the first tangent.
370//
371// The cross-tangent formula for the regular crease/boundary is similarly found
372// from the above construction of the boundary, but the commonly used weights of
373// +/- 1 and 2 result from omitting the common factor of sqrt(3)/2 (arising from
374// the sines of increments of pi/3). With that scale factor close to one, it has
375// less impact than the irregular cases, which are analogous to corner tangents
376// in that differences on only one side of the vertex are considered. While a
377// scaling of 3.0 is similarly understandable for the valence 2 and 3 cases, it is
378// less obvious in the irregular formula for valence > 4, but similarly effective.
379//
380// The end result of these adjustments should be a set of limit tangents that are
381// of similar magnitude over a regular mesh including boundaries and corners.
382*/
383 template <>
384 template <typename VERTEX, typename MASK>
385 inline void
386 Scheme<SCHEME_LOOP>::assignCornerLimitTangentMasks(VERTEX const& vertex,
387 MASK& tan1Mask, MASK& tan2Mask) const {
388
389 int valence = vertex.GetNumEdges();
390
391 tan1Mask.SetNumVertexWeights(1);
392 tan1Mask.SetNumEdgeWeights(valence);
393 tan1Mask.SetNumFaceWeights(0);
394 tan1Mask.SetFaceWeightsForFaceCenters(false);
395
396 tan2Mask.SetNumVertexWeights(1);
397 tan2Mask.SetNumEdgeWeights(valence);
398 tan2Mask.SetNumFaceWeights(0);
399 tan2Mask.SetFaceWeightsForFaceCenters(false);
400
401 // See note above regarding scale factor of 3.0:
402 tan1Mask.VertexWeight(0) = -3.0f;
403 tan1Mask.EdgeWeight(0) = 3.0f;
404 tan1Mask.EdgeWeight(1) = 0.0f;
405
406 tan2Mask.VertexWeight(0) = -3.0f;
407 tan2Mask.EdgeWeight(0) = 0.0f;
408 tan2Mask.EdgeWeight(1) = 3.0f;
409
410 // Should be at least 2 edges -- be sure to clear weights for any more:
411 for (int i = 2; i < valence; ++i) {
412 tan1Mask.EdgeWeight(i) = 0.0f;
413 tan2Mask.EdgeWeight(i) = 0.0f;
414 }
415}
416
417 template <>
418 template <typename VERTEX, typename MASK>
419 inline void
420 Scheme<SCHEME_LOOP>::assignCreaseLimitTangentMasks(VERTEX const& vertex,
421 MASK& tan1Mask, MASK& tan2Mask, int const creaseEnds[2]) const {
422
423 typedef typename MASK::Weight Weight;
424
425 //
426 // First, the tangent along the crease:
427 // The first crease edge is considered the "leading" edge of the span
428 // of surface for which we are evaluating tangents and the second edge the
429 // "trailing edge". By convention, the tangent along the crease is oriented
430 // in the direction of the leading edge.
431 //
432 int valence = vertex.GetNumEdges();
433
434 tan1Mask.SetNumVertexWeights(1);
435 tan1Mask.SetNumEdgeWeights(valence);
436 tan1Mask.SetNumFaceWeights(0);
437 tan1Mask.SetFaceWeightsForFaceCenters(false);
438
439 tan1Mask.VertexWeight(0) = 0.0f;
440 for (int i = 0; i < valence; ++i) {
441 tan1Mask.EdgeWeight(i) = 0.0f;
442 }
443
444 // See the note above regarding scale factor of 1.5:
445 tan1Mask.EdgeWeight(creaseEnds[0]) = 1.5f;
446 tan1Mask.EdgeWeight(creaseEnds[1]) = -1.5f;
447
448 //
449 // Second, the tangent across the interior faces:
450 // Note this is ambiguous for an interior vertex. We currently return
451 // the tangent for the surface in the counter-clockwise span between the
452 // leading and trailing edges that form the crease. Given the expected
453 // computation of a surface normal as Tan1 X Tan2, this tangent should be
454 // oriented "inward" from the crease/boundary -- across the surface rather
455 // than outward and away from it.
456 //
457 // There is inconsistency in the orientation of this tangent in commonly
458 // published results: the general formula provided for arbitrary valence
459 // has the tangent pointing across the crease and "outward" from the surface,
460 // while the special cases for regular valence and lower have the tangent
461 // pointing across the surface and "inward" from the crease. So if we are
462 // to consistently orient the first tangent along the crease, regardless of
463 // the interior topology, we have to correct this. With the first tangent
464 // following the direction of the leading crease edge, we want the second
465 // tangent pointing inward/across the surface -- so we flip the result of
466 // the general formula.
467 //
468 tan2Mask.SetNumVertexWeights(1);
469 tan2Mask.SetNumEdgeWeights(valence);
470 tan2Mask.SetNumFaceWeights(0);
471 tan2Mask.SetFaceWeightsForFaceCenters(false);
472
473 for (int i = 0; i < creaseEnds[0]; ++i) {
474 tan2Mask.EdgeWeight(i) = 0.0f;
475 }
476 int interiorEdgeCount = creaseEnds[1] - creaseEnds[0] - 1;
477 if (interiorEdgeCount == 2) {
478 // See note above regarding scale factor of (sin(60 degs) == sqrt(3)/2:
479
480 static Weight const Root3 = (Weight) 1.73205080756887729352;
481 static Weight const Root3by2 = (Weight) (Root3 * 0.5);
482
483 tan2Mask.VertexWeight(0) = -Root3;
484
485 tan2Mask.EdgeWeight(creaseEnds[0]) = -Root3by2;
486 tan2Mask.EdgeWeight(creaseEnds[1]) = -Root3by2;
487
488 tan2Mask.EdgeWeight(creaseEnds[0] + 1) = Root3;
489 tan2Mask.EdgeWeight(creaseEnds[0] + 2) = Root3;
490 } else if (interiorEdgeCount > 2) {
491 // See notes above regarding scale factor of -3.0 (-1 for orientation,
492 // 2.0 for considering the region as a half-disk, and 1.5 in keeping
493 // with the crease tangent):
494
495 double theta = M_PI / (interiorEdgeCount + 1);
496
497 tan2Mask.VertexWeight(0) = 0.0f;
498
499 Weight cWeight = (Weight) (-3.0f * std::sin(theta));
500 tan2Mask.EdgeWeight(creaseEnds[0]) = cWeight;
501 tan2Mask.EdgeWeight(creaseEnds[1]) = cWeight;
502
503 double eCoeff = -3.0f * 2.0f * (std::cos(theta) - 1.0f);
504 for (int i = 1; i <= interiorEdgeCount; ++i) {
505 tan2Mask.EdgeWeight(creaseEnds[0] + i) = (Weight) (eCoeff * std::sin(i * theta));
506 }
507 } else if (interiorEdgeCount == 1) {
508 // See notes above regarding scale factor of 3.0:
509
510 tan2Mask.VertexWeight(0) = -3.0f;
511
512 tan2Mask.EdgeWeight(creaseEnds[0]) = 0.0f;
513 tan2Mask.EdgeWeight(creaseEnds[1]) = 0.0f;
514
515 tan2Mask.EdgeWeight(creaseEnds[0] + 1) = 3.0f;
516 } else {
517 // See notes above regarding scale factor of 3.0:
518
519 tan2Mask.VertexWeight(0) = -6.0f;
520
521 tan2Mask.EdgeWeight(creaseEnds[0]) = 3.0f;
522 tan2Mask.EdgeWeight(creaseEnds[1]) = 3.0f;
523 }
524 for (int i = creaseEnds[1] + 1; i < valence; ++i) {
525 tan2Mask.EdgeWeight(i) = 0.0f;
526 }
527}
528
529 template <>
530 template <typename VERTEX, typename MASK>
531 inline void
532 Scheme<SCHEME_LOOP>::assignSmoothLimitTangentMasks(VERTEX const& vertex,
533 MASK& tan1Mask, MASK& tan2Mask) const {
534
535 typedef typename MASK::Weight Weight;
536
537 int valence = vertex.GetNumFaces();
538
539 tan1Mask.SetNumVertexWeights(1);
540 tan1Mask.SetNumEdgeWeights(valence);
541 tan1Mask.SetNumFaceWeights(0);
542 tan1Mask.SetFaceWeightsForFaceCenters(false);
543
544 tan2Mask.SetNumVertexWeights(1);
545 tan2Mask.SetNumEdgeWeights(valence);
546 tan2Mask.SetNumFaceWeights(0);
547 tan2Mask.SetFaceWeightsForFaceCenters(false);
548
549 tan1Mask.VertexWeight(0) = 0.0f;
550 tan2Mask.VertexWeight(0) = 0.0f;
551
552 if (valence == 6) {
553 static Weight const Root3by2 = (Weight)(0.5 * 1.73205080756887729352);
554
555 tan1Mask.EdgeWeight(0) = 1.0f;
556 tan1Mask.EdgeWeight(1) = 0.5f;
557 tan1Mask.EdgeWeight(2) = -0.5f;
558 tan1Mask.EdgeWeight(3) = -1.0f;
559 tan1Mask.EdgeWeight(4) = -0.5f;
560 tan1Mask.EdgeWeight(5) = 0.5f;
561
562 tan2Mask.EdgeWeight(0) = 0.0f;
563 tan2Mask.EdgeWeight(1) = Root3by2;
564 tan2Mask.EdgeWeight(2) = Root3by2;
565 tan2Mask.EdgeWeight(3) = 0.0f;
566 tan2Mask.EdgeWeight(4) = -Root3by2;
567 tan2Mask.EdgeWeight(5) = -Root3by2;
568 } else {
569 double alpha = 2.0f * M_PI / valence;
570 for (int i = 0; i < valence; ++i) {
571 double alphaI = alpha * i;
572 tan1Mask.EdgeWeight(i) = (Weight) std::cos(alphaI);
573 tan2Mask.EdgeWeight(i) = (Weight) std::sin(alphaI);
574 }
575 }
576}
577
578} // end namespace Sdc
579} // end namespace OPENSUBDIV_VERSION
580 using namespace OPENSUBDIV_VERSION;
581} // end namespace OpenSubdiv
582
583#endif /* OPENSUBDIV3_SDC_LOOP_SCHEME_H */
scheme.h
OpenSubdiv
Definition limits.h:32
OpenSubdiv::OPENSUBDIV_VERSION
Definition limits.h:33
OpenSubdiv::OPENSUBDIV_VERSION::Sdc
Definition bilinearScheme.h:34
OpenSubdiv::OPENSUBDIV_VERSION::Sdc::Split
Split
Enumerated type for all face splitting schemes.
Definition types.h:47
OpenSubdiv::OPENSUBDIV_VERSION::Sdc::SPLIT_TO_TRIS
@ SPLIT_TO_TRIS
Used by Loop.
Definition types.h:49
OpenSubdiv::OPENSUBDIV_VERSION::Sdc::Scheme::assignSmoothMaskForEdge
void assignSmoothMaskForEdge(EDGE const &edge, MASK &mask) const
OpenSubdiv::OPENSUBDIV_VERSION::Sdc::Scheme::GetTopologicalSplitType
static Split GetTopologicalSplitType()
OpenSubdiv::OPENSUBDIV_VERSION::Sdc::Scheme::assignCreaseMaskForVertex
void assignCreaseMaskForVertex(VERTEX const &edge, MASK &mask, int const creaseEnds[2]) const
OpenSubdiv::OPENSUBDIV_VERSION::Sdc::Scheme::assignCreaseLimitTangentMasks
void assignCreaseLimitTangentMasks(VERTEX const &vertex, MASK &tan1, MASK &tan2, int const creaseEnds[2]) const
OpenSubdiv::OPENSUBDIV_VERSION::Sdc::Scheme::GetRegularFaceSize
static int GetRegularFaceSize()
OpenSubdiv::OPENSUBDIV_VERSION::Sdc::Scheme::assignCreaseMaskForEdge
void assignCreaseMaskForEdge(EDGE const &edge, MASK &mask) const
Definition scheme.h:317
OpenSubdiv::OPENSUBDIV_VERSION::Sdc::Scheme::assignSmoothLimitMask
void assignSmoothLimitMask(VERTEX const &vertex, MASK &pos) const
OpenSubdiv::OPENSUBDIV_VERSION::Sdc::Scheme::GetLocalNeighborhoodSize
static int GetLocalNeighborhoodSize()
OpenSubdiv::OPENSUBDIV_VERSION::Sdc::Scheme::assignCornerMaskForVertex
void assignCornerMaskForVertex(VERTEX const &edge, MASK &mask) const
Definition scheme.h:331
OpenSubdiv::OPENSUBDIV_VERSION::Sdc::Scheme::assignCreaseLimitMask
void assignCreaseLimitMask(VERTEX const &vertex, MASK &pos, int const creaseEnds[2]) const
OpenSubdiv::OPENSUBDIV_VERSION::Sdc::Scheme::assignSmoothMaskForVertex
void assignSmoothMaskForVertex(VERTEX const &edge, MASK &mask) const
OpenSubdiv::OPENSUBDIV_VERSION::Sdc::Scheme::GetRegularVertexValence
static int GetRegularVertexValence()
OpenSubdiv::OPENSUBDIV_VERSION::Sdc::Scheme::assignSmoothLimitTangentMasks
void assignSmoothLimitTangentMasks(VERTEX const &vertex, MASK &tan1, MASK &tan2) const
OpenSubdiv::OPENSUBDIV_VERSION::Sdc::Scheme::assignCornerLimitMask
void assignCornerLimitMask(VERTEX const &vertex, MASK &pos) const
OpenSubdiv::OPENSUBDIV_VERSION::Sdc::Scheme::assignCornerLimitTangentMasks
void assignCornerLimitTangentMasks(VERTEX const &vertex, MASK &tan1, MASK &tan2) const