opensubdiv/far/topologyRefinerFactory.h Source File

topologyRefinerFactory.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_FAR_TOPOLOGY_REFINER_FACTORY_H
25 #define OPENSUBDIV3_FAR_TOPOLOGY_REFINER_FACTORY_H
26
27 #include "../version.h"
28
29 #include "../far/topologyRefiner.h"
30 #include "../far/error.h"
31
32 #include <cassert>
33
34 namespace OpenSubdiv {
35 namespace OPENSUBDIV_VERSION {
36
37 namespace Far {
38
46 //
47 class TopologyRefinerFactoryBase {
48 protected:
49
50 //
51 // Protected methods invoked by the subclass template to verify and process each
52 // stage of construction implemented by the subclass:
53 //
54 typedef Vtr::internal::Level::ValidationCallback TopologyCallback;
55
56 static bool prepareComponentTopologySizing(TopologyRefiner& refiner);
57 static bool prepareComponentTopologyAssignment(TopologyRefiner& refiner, bool fullValidation,
58 TopologyCallback callback, void const * callbackData);
59 static bool prepareComponentTagsAndSharpness(TopologyRefiner& refiner);
60 static bool prepareFaceVaryingChannels(TopologyRefiner& refiner);
61 };
62
63
77 template <class MESH>
78 class TopologyRefinerFactory : public TopologyRefinerFactoryBase {
79
80 public:
81
84 struct Options {
85
86 Options(Sdc::SchemeType sdcType = Sdc::SCHEME_CATMARK, Sdc::Options sdcOptions = Sdc::Options()) :
87 schemeType(sdcType),
88 schemeOptions(sdcOptions),
89 validateFullTopology(false) { }
90
91 Sdc::SchemeType schemeType;
92 Sdc::Options schemeOptions;
93 unsigned int validateFullTopology : 1;
95 };
98
108 //
113 static TopologyRefiner* Create(MESH const& mesh, Options options = Options());
114
115 protected:
116 typedef Vtr::internal::Level::TopologyError TopologyError;
117
119
136 static bool resizeComponentTopology(TopologyRefiner& newRefiner, MESH const& mesh);
137
140 static bool assignComponentTopology(TopologyRefiner& newRefiner, MESH const& mesh);
141
143 static bool assignComponentTags(TopologyRefiner& newRefiner, MESH const& mesh);
144
146 static bool assignFaceVaryingTopology(TopologyRefiner& newRefiner, MESH const& mesh);
147
149 static void reportInvalidTopology(TopologyError errCode, char const * msg, MESH const& mesh);
150
152
153 protected:
155
174 static void setNumBaseVertices(TopologyRefiner & newRefiner, int count);
175
177 static void setNumBaseFaces(TopologyRefiner & newRefiner, int count);
178
180 static void setNumBaseEdges(TopologyRefiner & newRefiner, int count);
181
183 static void setNumBaseFaceVertices(TopologyRefiner & newRefiner, Index f, int count);
184
186 static void setNumBaseEdgeFaces(TopologyRefiner & newRefiner, Index e, int count);
187
189 static void setNumBaseVertexFaces(TopologyRefiner & newRefiner, Index v, int count);
190
192 static void setNumBaseVertexEdges(TopologyRefiner & newRefiner, Index v, int count);
193
194 static int getNumBaseVertices(TopologyRefiner const & newRefiner);
195 static int getNumBaseFaces(TopologyRefiner const & newRefiner);
196 static int getNumBaseEdges(TopologyRefiner const & newRefiner);
198
200
224 static IndexArray getBaseFaceVertices(TopologyRefiner & newRefiner, Index f);
225
227 static IndexArray getBaseFaceEdges(TopologyRefiner & newRefiner, Index f);
228
230 static IndexArray getBaseEdgeVertices(TopologyRefiner & newRefiner, Index e);
231
233 static IndexArray getBaseEdgeFaces(TopologyRefiner & newRefiner, Index e);
234
236 static IndexArray getBaseVertexFaces(TopologyRefiner & newRefiner, Index v);
237
239 static IndexArray getBaseVertexEdges(TopologyRefiner & newRefiner, Index v);
240
242 static LocalIndexArray getBaseVertexFaceLocalIndices(TopologyRefiner & newRefiner, Index v);
244 static LocalIndexArray getBaseVertexEdgeLocalIndices(TopologyRefiner & newRefiner, Index v);
246 static LocalIndexArray getBaseEdgeFaceLocalIndices(TopologyRefiner & newRefiner, Index e);
247
249 static void populateBaseLocalIndices(TopologyRefiner & newRefiner);
250
252 static void setBaseEdgeNonManifold(TopologyRefiner & newRefiner, Index e, bool b);
253
255 static void setBaseVertexNonManifold(TopologyRefiner & newRefiner, Index v, bool b);
257
259
270 static Index findBaseEdge(TopologyRefiner const & newRefiner, Index v0, Index v1);
271
273 static void setBaseEdgeSharpness(TopologyRefiner & newRefiner, Index e, float sharpness);
274
276 static void setBaseVertexSharpness(TopologyRefiner & newRefiner, Index v, float sharpness);
277
279 static void setBaseFaceHole(TopologyRefiner & newRefiner, Index f, bool isHole);
281
283
295 static int createBaseFVarChannel(TopologyRefiner & newRefiner, int numValues);
296
298 static int createBaseFVarChannel(TopologyRefiner & newRefiner, int numValues, Sdc::Options const& fvarOptions);
299
301 static IndexArray getBaseFaceFVarValues(TopologyRefiner & newRefiner, Index face, int channel = 0);
302
304
305 protected:
306 //
307 // Not to be specialized:
308 //
309 static bool populateBaseLevel(TopologyRefiner& refiner, MESH const& mesh, Options options);
310 };
311
312
313 //
314 // Generic implementations:
315 //
316 template <class MESH>
317 TopologyRefiner*
318 TopologyRefinerFactory<MESH>::Create(MESH const& mesh, Options options) {
319
320 TopologyRefiner * refiner = new TopologyRefiner(options.schemeType, options.schemeOptions);
321
322 if (! populateBaseLevel(*refiner, mesh, options)) {
323 delete refiner;
324 return 0;
325 }
326
327 // Eventually want to move the Refiner's inventory initialization here. Currently it
328 // is handled after topology assignment, but if the inventory is to include additional
329 // features (e.g. holes, etc.) it is better off deferred to here.
330
331 return refiner;
332 }
333
334 template <class MESH>
335 bool
336 TopologyRefinerFactory<MESH>::populateBaseLevel(TopologyRefiner& refiner, MESH const& mesh, Options options) {
337
338 //
339 // Construction of a specialized topology refiner involves four steps, each of which
340 // involves a method specialized for MESH followed by one that takes an action in
341 // response to it or in preparation for the next step.
342 //
343 // Both the specialized methods and those that follow them may find fault in the
344 // construction and trigger failure at any time:
345 //
346
347 //
348 // Sizing of the topology -- this is a required specialization for MESH. This defines
349 // an inventory of all components and their relations that is used to allocate buffers
350 // to be efficiently populated in the subsequent topology assignment step.
351 //
352 if (! resizeComponentTopology(refiner, mesh)) return false;
353 if (! prepareComponentTopologySizing(refiner)) return false;
354
355 //
356 // Assignment of the topology -- this is a required specialization for MESH. If edges
357 // are specified, all other topological relations are expected to be defined for them.
358 // Otherwise edges and remaining topology will be completed from the face-vertices:
359 //
360 bool validate = options.validateFullTopology;
361 TopologyCallback callback = reinterpret_cast<TopologyCallback>(reportInvalidTopology);
362 void const * userData = &mesh;
363
364 if (! assignComponentTopology(refiner, mesh)) return false;
365 if (! prepareComponentTopologyAssignment(refiner, validate, callback, userData)) return false;
366
367 //
368 // User assigned and internal tagging of components -- an optional specialization for
369 // MESH. Allows the specification of sharpness values, holes, etc.
370 //
371 if (! assignComponentTags(refiner, mesh)) return false;
372 if (! prepareComponentTagsAndSharpness(refiner)) return false;
373
374 //
375 // Defining channels of face-varying primvar data -- an optional specialization for MESH.
376 //
377 if (! assignFaceVaryingTopology(refiner, mesh)) return false;
378 if (! prepareFaceVaryingChannels(refiner)) return false;
379
380 return true;
381 }
382
383 template <class MESH>
384 inline void
385 TopologyRefinerFactory<MESH>::setNumBaseFaces(TopologyRefiner & newRefiner, int count) {
386 newRefiner._levels[0]->resizeFaces(count);
387 }
388 template <class MESH>
389 inline void
390 TopologyRefinerFactory<MESH>::setNumBaseEdges(TopologyRefiner & newRefiner, int count) {
391 newRefiner._levels[0]->resizeEdges(count);
392 }
393 template <class MESH>
394 inline void
395 TopologyRefinerFactory<MESH>::setNumBaseVertices(TopologyRefiner & newRefiner, int count) {
396 newRefiner._levels[0]->resizeVertices(count);
397 }
398
399 template <class MESH>
400 inline int
401 TopologyRefinerFactory<MESH>::getNumBaseFaces(TopologyRefiner const & newRefiner) {
402 return newRefiner._levels[0]->getNumFaces();
403 }
404 template <class MESH>
405 inline int
406 TopologyRefinerFactory<MESH>::getNumBaseEdges(TopologyRefiner const & newRefiner) {
407 return newRefiner._levels[0]->getNumEdges();
408 }
409 template <class MESH>
410 inline int
411 TopologyRefinerFactory<MESH>::getNumBaseVertices(TopologyRefiner const & newRefiner) {
412 return newRefiner._levels[0]->getNumVertices();
413 }
414
415 template <class MESH>
416 inline void
417 TopologyRefinerFactory<MESH>::setNumBaseFaceVertices(TopologyRefiner & newRefiner, Index f, int count) {
418 newRefiner._levels[0]->resizeFaceVertices(f, count);
419 }
420 template <class MESH>
421 inline void
422 TopologyRefinerFactory<MESH>::setNumBaseEdgeFaces(TopologyRefiner & newRefiner, Index e, int count) {
423 newRefiner._levels[0]->resizeEdgeFaces(e, count);
424 }
425 template <class MESH>
426 inline void
427 TopologyRefinerFactory<MESH>::setNumBaseVertexFaces(TopologyRefiner & newRefiner, Index v, int count) {
428 newRefiner._levels[0]->resizeVertexFaces(v, count);
429 }
430 template <class MESH>
431 inline void
432 TopologyRefinerFactory<MESH>::setNumBaseVertexEdges(TopologyRefiner & newRefiner, Index v, int count) {
433 newRefiner._levels[0]->resizeVertexEdges(v, count);
434 }
435
436 template <class MESH>
437 inline IndexArray
438 TopologyRefinerFactory<MESH>::getBaseFaceVertices(TopologyRefiner & newRefiner, Index f) {
439 return newRefiner._levels[0]->getFaceVertices(f);
440 }
441 template <class MESH>
442 inline IndexArray
443 TopologyRefinerFactory<MESH>::getBaseFaceEdges(TopologyRefiner & newRefiner, Index f) {
444 return newRefiner._levels[0]->getFaceEdges(f);
445 }
446 template <class MESH>
447 inline IndexArray
448 TopologyRefinerFactory<MESH>::getBaseEdgeVertices(TopologyRefiner & newRefiner, Index e) {
449 return newRefiner._levels[0]->getEdgeVertices(e);
450 }
451 template <class MESH>
452 inline IndexArray
453 TopologyRefinerFactory<MESH>::getBaseEdgeFaces(TopologyRefiner & newRefiner, Index e) {
454 return newRefiner._levels[0]->getEdgeFaces(e);
455 }
456 template <class MESH>
457 inline IndexArray
458 TopologyRefinerFactory<MESH>::getBaseVertexFaces(TopologyRefiner & newRefiner, Index v) {
459 return newRefiner._levels[0]->getVertexFaces(v);
460 }
461 template <class MESH>
462 inline IndexArray
463 TopologyRefinerFactory<MESH>::getBaseVertexEdges(TopologyRefiner & newRefiner, Index v) {
464 return newRefiner._levels[0]->getVertexEdges(v);
465 }
466
467 template <class MESH>
468 inline LocalIndexArray
469 TopologyRefinerFactory<MESH>::getBaseEdgeFaceLocalIndices(TopologyRefiner & newRefiner, Index e) {
470 return newRefiner._levels[0]->getEdgeFaceLocalIndices(e);
471 }
472 template <class MESH>
473 inline LocalIndexArray
474 TopologyRefinerFactory<MESH>::getBaseVertexFaceLocalIndices(TopologyRefiner & newRefiner, Index v) {
475 return newRefiner._levels[0]->getVertexFaceLocalIndices(v);
476 }
477 template <class MESH>
478 inline LocalIndexArray
479 TopologyRefinerFactory<MESH>::getBaseVertexEdgeLocalIndices(TopologyRefiner & newRefiner, Index v) {
480 return newRefiner._levels[0]->getVertexEdgeLocalIndices(v);
481 }
482
483 template <class MESH>
484 inline Index
485 TopologyRefinerFactory<MESH>::findBaseEdge(TopologyRefiner const & newRefiner, Index v0, Index v1) {
486 return newRefiner._levels[0]->findEdge(v0, v1);
487 }
488
489 template <class MESH>
490 inline void
491 TopologyRefinerFactory<MESH>::populateBaseLocalIndices(TopologyRefiner & newRefiner) {
492 newRefiner._levels[0]->populateLocalIndices();
493 }
494
495 template <class MESH>
496 inline void
497 TopologyRefinerFactory<MESH>::setBaseEdgeNonManifold(TopologyRefiner & newRefiner, Index e, bool b) {
498 newRefiner._levels[0]->setEdgeNonManifold(e, b);
499 }
500 template <class MESH>
501 inline void
502 TopologyRefinerFactory<MESH>::setBaseVertexNonManifold(TopologyRefiner & newRefiner, Index v, bool b) {
503 newRefiner._levels[0]->setVertexNonManifold(v, b);
504 }
505
506 template <class MESH>
507 inline void
508 TopologyRefinerFactory<MESH>::setBaseEdgeSharpness(TopologyRefiner & newRefiner, Index e, float s) {
509 newRefiner._levels[0]->getEdgeSharpness(e) = s;
510 }
511 template <class MESH>
512 inline void
513 TopologyRefinerFactory<MESH>::setBaseVertexSharpness(TopologyRefiner & newRefiner, Index v, float s) {
514 newRefiner._levels[0]->getVertexSharpness(v) = s;
515 }
516 template <class MESH>
517 inline void
518 TopologyRefinerFactory<MESH>::setBaseFaceHole(TopologyRefiner & newRefiner, Index f, bool b) {
519 newRefiner._levels[0]->setFaceHole(f, b);
520 newRefiner._hasHoles |= b;
521 }
522
523 template <class MESH>
524 inline int
525 TopologyRefinerFactory<MESH>::createBaseFVarChannel(TopologyRefiner & newRefiner, int numValues) {
526 return newRefiner._levels[0]->createFVarChannel(numValues, newRefiner._subdivOptions);
527 }
528 template <class MESH>
529 inline int
530 TopologyRefinerFactory<MESH>::createBaseFVarChannel(TopologyRefiner & newRefiner, int numValues, Sdc::Options const& fvarOptions) {
531 Sdc::Options newOptions = newRefiner._subdivOptions;
532 newOptions.SetFVarLinearInterpolation(fvarOptions.GetFVarLinearInterpolation());
533 return newRefiner._levels[0]->createFVarChannel(numValues, newOptions);
534 }
535 template <class MESH>
536 inline IndexArray
537 TopologyRefinerFactory<MESH>::getBaseFaceFVarValues(TopologyRefiner & newRefiner, Index face, int channel) {
538 return newRefiner._levels[0]->getFaceFVarValues(face, channel);
539 }
540
541
542 template <class MESH>
543 bool
544 TopologyRefinerFactory<MESH>::resizeComponentTopology(TopologyRefiner& /* refiner */, MESH const& /* mesh */) {
545
546 Error(FAR_RUNTIME_ERROR,
547 "Failure in TopologyRefinerFactory<>::resizeComponentTopology() -- no specialization provided.");
548
549 //
550 // Sizing the topology tables:
551 // This method is for determining the sizes of the various topology tables (and other
552 // data) associated with the mesh. Once completed, appropriate memory will be allocated
553 // and an additional method invoked to populate it accordingly.
554 //
555 // The following methods should be called -- first those to specify the number of faces,
556 // edges and vertices in the mesh:
557 //
558 // void setBaseFaceCount( TopologyRefiner& newRefiner, int count)
559 // void setBaseEdgeCount( TopologyRefiner& newRefiner, int count)
560 // void setBaseVertexCount(TopologyRefiner& newRefiner, int count)
561 //
562 // and then for each face, edge and vertex, the number of its incident components:
563 //
564 // void setBaseFaceVertexCount(TopologyRefiner& newRefiner, Index face, int count)
565 // void setBaseEdgeFaceCount( TopologyRefiner& newRefiner, Index edge, int count)
566 // void setBaseVertexFaceCount(TopologyRefiner& newRefiner, Index vertex, int count)
567 // void setBaseVertexEdgeCount(TopologyRefiner& newRefiner, Index vertex, int count)
568 //
569 // The count/size for a component type must be set before indices associated with that
570 // component type can be used.
571 //
572 // Note that it is only necessary to size 4 of the 6 supported topological relations --
573 // the number of edge-vertices is fixed at two per edge, and the number of face-edges is
574 // the same as the number of face-vertices.
575 //
576 // So a single pass through your mesh to gather up all of this sizing information will
577 // allow the Tables to be allocated appropriately once and avoid any dynamic resizing as
578 // it grows.
579 //
580 return false;
581 }
582
583 template <class MESH>
584 bool
585 TopologyRefinerFactory<MESH>::assignComponentTopology(TopologyRefiner& /* refiner */, MESH const& /* mesh */) {
586
587 Error(FAR_RUNTIME_ERROR,
588 "Failure in TopologyRefinerFactory<>::assignComponentTopology() -- no specialization provided.");
589
590 //
591 // Assigning the topology tables:
592 // Once the topology tables have been allocated, the six required topological
593 // relations can be directly populated using the following methods:
594 //
595 // IndexArray setBaseFaceVertices(TopologyRefiner& newRefiner, Index face)
596 // IndexArray setBaseFaceEdges(TopologyRefiner& newRefiner, Index face)
597 //
598 // IndexArray setBaseEdgeVertices(TopologyRefiner& newRefiner, Index edge)
599 // IndexArray setBaseEdgeFaces(TopologyRefiner& newRefiner, Index edge)
600 //
601 // IndexArray setBaseVertexEdges(TopologyRefiner& newRefiner, Index vertex)
602 // IndexArray setBaseVertexFaces(TopologyRefiner& newRefiner, Index vertex)
603 //
604 // For the last two relations -- the faces and edges incident a vertex -- there are
605 // also "local indices" that must be specified (considering doing this internally),
606 // where the "local index" of each incident face or edge is the index of the vertex
607 // within that face or edge, and so ranging from 0-3 for incident quads and 0-1 for
608 // incident edges. These are assigned through similarly retrieved arrays:
609 //
610 // LocalIndexArray setBaseVertexFaceLocalIndices(TopologyRefiner& newRefiner, Index vertex)
611 // LocalIndexArray setBaseVertexEdgeLocalIndices(TopologyRefiner& newRefiner, Index vertex)
612 // LocalIndexArray setBaseEdgeFaceLocalIndices( TopologyRefiner& newRefiner, Index edge)
613 //
614 // or, if the mesh is manifold, explicit assignment of these can be deferred and
615 // all can be determined by calling:
616 //
617 // void populateBaseLocalIndices(TopologyRefiner& newRefiner)
618 //
619 // All components are assumed to be locally manifold and ordering of components in
620 // the above relations is expected to be counter-clockwise.
621 //
622 // For non-manifold components, no ordering/orientation of incident components is
623 // assumed or required, but be sure to explicitly tag such components (vertices and
624 // edges) as non-manifold:
625 //
626 // void setBaseEdgeNonManifold(TopologyRefiner& newRefiner, Index edge, bool b);
627 //
628 // void setBaseVertexNonManifold(TopologyRefiner& newRefiner, Index vertex, bool b);
629 //
630 // Also consider using TopologyLevel::ValidateTopology() when debugging to ensure
631 // that topology has been completely and correctly specified.
632 //
633 return false;
634 }
635
636 template <class MESH>
637 bool
638 TopologyRefinerFactory<MESH>::assignFaceVaryingTopology(TopologyRefiner& /* refiner */, MESH const& /* mesh */) {
639
640 //
641 // Optional assigning face-varying topology tables:
642 //
643 // Create independent face-varying primitive variable channels:
644 // int createBaseFVarChannel(TopologyRefiner& newRefiner, int numValues)
645 //
646 // For each channel, populate the face-vertex values:
647 // IndexArray setBaseFaceFVarValues(TopologyRefiner& newRefiner, Index face, int channel = 0)
648 //
649 return true;
650 }
651
652 template <class MESH>
653 bool
654 TopologyRefinerFactory<MESH>::assignComponentTags(TopologyRefiner& /* refiner */, MESH const& /* mesh */) {
655
656 //
657 // Optional tagging:
658 // This is where any additional feature tags -- sharpness, holes, etc. -- can be
659 // specified using:
660 //
661 // void setBaseEdgeSharpness(TopologyRefiner& newRefiner, Index edge, float sharpness)
662 // void setBaseVertexSharpness(TopologyRefiner& newRefiner, Index vertex, float sharpness)
663 //
664 // void setBaseFaceHole(TopologyRefiner& newRefiner, Index face, bool hole)
665 //
666 return true;
667 }
668
669 template <class MESH>
670 void
671 TopologyRefinerFactory<MESH>::reportInvalidTopology(
672 TopologyError /* errCode */, char const * /* msg */, MESH const& /* mesh */) {
673
674 //
675 // Optional topology validation error reporting:
676 // This method is called whenever the factory encounters topology validation
677 // errors. By default, nothing is reported
678 //
679 }
680
681 } // end namespace Far
682
683 } // end namespace OPENSUBDIV_VERSION
684 using namespace OPENSUBDIV_VERSION;
685 } // end namespace OpenSubdiv
686
687 #endif /* OPENSUBDIV3_FAR_TOPOLOGY_REFINER_FACTORY_H */
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory::getBaseEdgeVertices
static IndexArray getBaseEdgeVertices(TopologyRefiner &newRefiner, Index e)
Assign the vertices incident each edge.
Definition: topologyRefinerFactory.h:448
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory
Factory for constructing TopologyRefiners from specific mesh classes.
Definition: topologyRefiner.h:45
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactoryBase::prepareComponentTopologySizing
static bool prepareComponentTopologySizing(TopologyRefiner &refiner)
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory::resizeComponentTopology
static bool resizeComponentTopology(TopologyRefiner &newRefiner, MESH const &mesh)
Specify the number of vertices, faces, face-vertices, etc.
Definition: topologyRefinerFactory.h:544
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory::getNumBaseEdges
static int getNumBaseEdges(TopologyRefiner const &newRefiner)
Definition: topologyRefinerFactory.h:406
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory::assignComponentTags
static bool assignComponentTags(TopologyRefiner &newRefiner, MESH const &mesh)
(Optional) Specify edge or vertex sharpness or face holes
Definition: topologyRefinerFactory.h:654
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory::Options
Options related to the construction of each TopologyRefiner.
Definition: topologyRefinerFactory.h:84
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory::getNumBaseVertices
static int getNumBaseVertices(TopologyRefiner const &newRefiner)
Definition: topologyRefinerFactory.h:411
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory::getNumBaseFaces
static int getNumBaseFaces(TopologyRefiner const &newRefiner)
Definition: topologyRefinerFactory.h:401
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory::setNumBaseEdgeFaces
static void setNumBaseEdgeFaces(TopologyRefiner &newRefiner, Index e, int count)
Specify the number of faces incident each edge.
Definition: topologyRefinerFactory.h:422
OpenSubdiv::OPENSUBDIV_VERSION::Sdc::SchemeType
SchemeType
Enumerated type for all subdivision schemes supported by OpenSubdiv.
Definition: types.h:37
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory::setNumBaseFaces
static void setNumBaseFaces(TopologyRefiner &newRefiner, int count)
Specify the number of faces to be accommodated.
Definition: topologyRefinerFactory.h:385
OpenSubdiv::OPENSUBDIV_VERSION::Far::FAR_RUNTIME_ERROR
Issue a generic runtime error, but continue execution.
Definition: error.h:40
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory::setNumBaseEdges
static void setNumBaseEdges(TopologyRefiner &newRefiner, int count)
Specify the number of edges to be accommodated.
Definition: topologyRefinerFactory.h:390
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory::getBaseVertexFaces
static IndexArray getBaseVertexFaces(TopologyRefiner &newRefiner, Index v)
Assign the faces incident each vertex.
Definition: topologyRefinerFactory.h:458
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory::getBaseEdgeFaces
static IndexArray getBaseEdgeFaces(TopologyRefiner &newRefiner, Index e)
Assign the faces incident each edge.
Definition: topologyRefinerFactory.h:453
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory::assignComponentTopology
static bool assignComponentTopology(TopologyRefiner &newRefiner, MESH const &mesh)
Specify the relationships between vertices, faces, etc. ie the face-vertices, vertex-faces, edge-vertices, etc.
Definition: topologyRefinerFactory.h:585
OpenSubdiv::OPENSUBDIV_VERSION::Far::Index
Vtr::Index Index
Definition: types.h:41
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory::getBaseFaceVertices
static IndexArray getBaseFaceVertices(TopologyRefiner &newRefiner, Index f)
Assign the vertices incident each face.
Definition: topologyRefinerFactory.h:438
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory::setNumBaseVertices
static void setNumBaseVertices(TopologyRefiner &newRefiner, int count)
Specify the number of vertices to be accommodated.
Definition: topologyRefinerFactory.h:395
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory::populateBaseLocalIndices
static void populateBaseLocalIndices(TopologyRefiner &newRefiner)
Determine all local indices by inspection (only for pure manifold meshes)
Definition: topologyRefinerFactory.h:491
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory::getBaseVertexFaceLocalIndices
static LocalIndexArray getBaseVertexFaceLocalIndices(TopologyRefiner &newRefiner, Index v)
Assign the local indices of a vertex within each of its incident faces.
Definition: topologyRefinerFactory.h:474
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory::getBaseFaceFVarValues
static IndexArray getBaseFaceFVarValues(TopologyRefiner &newRefiner, Index face, int channel=0)
Assign the face-varying values for the corners of each face.
Definition: topologyRefinerFactory.h:537
OpenSubdiv
Definition: error.h:30
OpenSubdiv::OPENSUBDIV_VERSION::Vtr::internal::Level::TopologyError
TopologyError
Definition: level.h:263
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory::setBaseFaceHole
static void setBaseFaceHole(TopologyRefiner &newRefiner, Index f, bool isHole)
Tag a face as a hole.
Definition: topologyRefinerFactory.h:518
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactoryBase::prepareComponentTagsAndSharpness
static bool prepareComponentTagsAndSharpness(TopologyRefiner &refiner)
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory::Options::Options
Options(Sdc::SchemeType sdcType=Sdc::SCHEME_CATMARK, Sdc::Options sdcOptions=Sdc::Options())
Definition: topologyRefinerFactory.h:86
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactoryBase
Private base class of Factories for constructing TopologyRefiners.
Definition: topologyRefinerFactory.h:47
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactoryBase::prepareFaceVaryingChannels
static bool prepareFaceVaryingChannels(TopologyRefiner &refiner)
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefiner
Stores topology data for a specified set of refinement options.
Definition: topologyRefiner.h:50
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory::setBaseEdgeSharpness
static void setBaseEdgeSharpness(TopologyRefiner &newRefiner, Index e, float sharpness)
Assign a sharpness value to a given edge.
Definition: topologyRefinerFactory.h:508
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory::setBaseVertexSharpness
static void setBaseVertexSharpness(TopologyRefiner &newRefiner, Index v, float sharpness)
Assign a sharpness value to a given vertex.
Definition: topologyRefinerFactory.h:513
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory::setNumBaseVertexFaces
static void setNumBaseVertexFaces(TopologyRefiner &newRefiner, Index v, int count)
Specify the number of faces incident each vertex.
Definition: topologyRefinerFactory.h:427
OpenSubdiv::OPENSUBDIV_VERSION::Far::Error
void Error(ErrorType err, const char *format,...)
Sends an OSD error with a message (internal use only)
OpenSubdiv::OPENSUBDIV_VERSION::Sdc::Options::GetFVarLinearInterpolation
FVarLinearInterpolation GetFVarLinearInterpolation() const
Get face-varying interpolation rule.
Definition: options.h:93
OpenSubdiv::OPENSUBDIV_VERSION::Vtr::internal::Level::ValidationCallback
void(* ValidationCallback)(TopologyError errCode, char const *msg, void const *clientData)
Definition: level.h:288
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory::setBaseVertexNonManifold
static void setBaseVertexNonManifold(TopologyRefiner &newRefiner, Index v, bool b)
Tag a vertex as non-manifold.
Definition: topologyRefinerFactory.h:502
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory::Create
static TopologyRefiner * Create(MESH const &mesh, Options options=Options())
Instantiates a TopologyRefiner from client-provided topological representation.
Definition: topologyRefinerFactory.h:318
OpenSubdiv::OPENSUBDIV_VERSION::Sdc::Options
All supported options applying to subdivision scheme.
Definition: options.h:51
OpenSubdiv::OPENSUBDIV_VERSION::Vtr::Array< Index >
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactoryBase::TopologyCallback
Vtr::internal::Level::ValidationCallback TopologyCallback
Definition: topologyRefinerFactory.h:54
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory::setNumBaseVertexEdges
static void setNumBaseVertexEdges(TopologyRefiner &newRefiner, Index v, int count)
Specify the number of edges incident each vertex.
Definition: topologyRefinerFactory.h:432
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory::getBaseVertexEdges
static IndexArray getBaseVertexEdges(TopologyRefiner &newRefiner, Index v)
Assign the edges incident each vertex.
Definition: topologyRefinerFactory.h:463
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory::getBaseEdgeFaceLocalIndices
static LocalIndexArray getBaseEdgeFaceLocalIndices(TopologyRefiner &newRefiner, Index e)
Assign the local indices of an edge within each of its incident faces.
Definition: topologyRefinerFactory.h:469
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory::setBaseEdgeNonManifold
static void setBaseEdgeNonManifold(TopologyRefiner &newRefiner, Index e, bool b)
Tag an edge as non-manifold.
Definition: topologyRefinerFactory.h:497
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory::findBaseEdge
static Index findBaseEdge(TopologyRefiner const &newRefiner, Index v0, Index v1)
Identify an edge to be assigned a sharpness value given a vertex pair.
Definition: topologyRefinerFactory.h:485
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory::getBaseVertexEdgeLocalIndices
static LocalIndexArray getBaseVertexEdgeLocalIndices(TopologyRefiner &newRefiner, Index v)
Assign the local indices of a vertex within each of its incident edges.
Definition: topologyRefinerFactory.h:479
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory::assignFaceVaryingTopology
static bool assignFaceVaryingTopology(TopologyRefiner &newRefiner, MESH const &mesh)
(Optional) Specify face-varying data per face
Definition: topologyRefinerFactory.h:638
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory::populateBaseLevel
static bool populateBaseLevel(TopologyRefiner &refiner, MESH const &mesh, Options options)
Definition: topologyRefinerFactory.h:336
OpenSubdiv::OPENSUBDIV_VERSION::Sdc::SCHEME_CATMARK
Definition: types.h:39
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory::Options::schemeType
Sdc::SchemeType schemeType
The subdivision scheme type identifier.
Definition: topologyRefinerFactory.h:91
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory::reportInvalidTopology
static void reportInvalidTopology(TopologyError errCode, char const *msg, MESH const &mesh)
(Optional) Control run-time topology validation and error reporting
Definition: topologyRefinerFactory.h:671
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory::createBaseFVarChannel
static int createBaseFVarChannel(TopologyRefiner &newRefiner, int numValues)
Create a new face-varying channel with the given number of values.
Definition: topologyRefinerFactory.h:525
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory::setNumBaseFaceVertices
static void setNumBaseFaceVertices(TopologyRefiner &newRefiner, Index f, int count)
Specify the number of vertices incident each face.
Definition: topologyRefinerFactory.h:417
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory::Options::validateFullTopology
unsigned int validateFullTopology
Definition: topologyRefinerFactory.h:94
OpenSubdiv::OPENSUBDIV_VERSION::Sdc::Options::SetFVarLinearInterpolation
void SetFVarLinearInterpolation(FVarLinearInterpolation b)
Set face-varying interpolation rule.
Definition: options.h:96
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory::TopologyError
Vtr::internal::Level::TopologyError TopologyError
Definition: topologyRefinerFactory.h:116
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactoryBase::prepareComponentTopologyAssignment
static bool prepareComponentTopologyAssignment(TopologyRefiner &refiner, bool fullValidation, TopologyCallback callback, void const *callbackData)
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory::Options::schemeOptions
Sdc::Options schemeOptions
Definition: topologyRefinerFactory.h:92
OpenSubdiv::OPENSUBDIV_VERSION::Far::TopologyRefinerFactory::getBaseFaceEdges
static IndexArray getBaseFaceEdges(TopologyRefiner &newRefiner, Index f)
Assign the edges incident each face.
Definition: topologyRefinerFactory.h:443