From 13e0850ac64577013f399d54055c4bc45773a309 Mon Sep 17 00:00:00 2001 From: barfowl Date: Mon, 1 Jun 2015 17:38:11 -0700 Subject: [PATCH] Re-protected members of all major Vtr classes: - change public status of members back to protected/private - mimized friends (primarily Refinements as builders for Levels) - added any missing accessors to prevent member access (mainly Tags) - added the Tri/Quad refinement subclasses to private header list --- opensubdiv/vtr/CMakeLists.txt | 9 +++--- opensubdiv/vtr/fvarLevel.cpp | 40 ++++++++++++------------ opensubdiv/vtr/fvarLevel.h | 22 +++++++------ opensubdiv/vtr/fvarRefinement.cpp | 52 +++++++++++++++---------------- opensubdiv/vtr/fvarRefinement.h | 3 +- opensubdiv/vtr/level.cpp | 2 +- opensubdiv/vtr/level.h | 17 ++++++++-- opensubdiv/vtr/refinement.h | 22 ++++++++++--- opensubdiv/vtr/sparseSelector.h | 15 ++++----- 9 files changed, 104 insertions(+), 78 deletions(-) diff --git a/opensubdiv/vtr/CMakeLists.txt b/opensubdiv/vtr/CMakeLists.txt index 397d5f70..4a1edb35 100644 --- a/opensubdiv/vtr/CMakeLists.txt +++ b/opensubdiv/vtr/CMakeLists.txt @@ -36,22 +36,23 @@ set(SOURCE_FILES triRefinement.cpp ) +set(PRIVATE_HEADER_FILES + quadRefinement.h + triRefinement.h +) + set(PUBLIC_HEADER_FILES array.h componentInterfaces.h fvarLevel.h fvarRefinement.h level.h - quadRefinement.h refinement.h sparseSelector.h stackBuffer.h - triRefinement.h types.h ) -set(PRIVATE_HEADER_FILES ) - set(DOXY_HEADER_FILES ${PUBLIC_HEADER_FILES}) include_directories("${CMAKE_CURRENT_BINARY_DIR}") diff --git a/opensubdiv/vtr/fvarLevel.cpp b/opensubdiv/vtr/fvarLevel.cpp index f59e8fc6..82386ab6 100644 --- a/opensubdiv/vtr/fvarLevel.cpp +++ b/opensubdiv/vtr/fvarLevel.cpp @@ -219,8 +219,8 @@ FVarLevel::completeTopologyFromFaceValues(int regularBoundaryValence) { ConstIndexArray vEdges = _level.getVertexEdges(vIndex); ConstLocalIndexArray vInEdge = _level.getVertexEdgeLocalIndices(vIndex); - bool vIsManifold = !_level._vertTags[vIndex]._nonManifold; - bool vIsBoundary = _level._vertTags[vIndex]._boundary; + bool vIsManifold = !_level.getVertexTag(vIndex)._nonManifold; + bool vIsBoundary = _level.getVertexTag(vIndex)._boundary; if (vIsManifold) { // @@ -316,7 +316,7 @@ FVarLevel::completeTopologyFromFaceValues(int regularBoundaryValence) { _edgeTags[vEdges[vEdges.size()-1]]._linear = true; } else { for (int i = 0; i < vEdges.size(); ++i) { - if (_level._edgeTags[vEdges[i]]._boundary) { + if (_level.getEdgeTag(vEdges[i])._boundary) { _edgeTags[vEdges[i]]._linear = true; } } @@ -457,7 +457,7 @@ FVarLevel::completeTopologyFromFaceValues(int regularBoundaryValence) { // ValueTagArray vValueTags = getVertexValueTags(vIndex); - Level::VTag const vTag = _level._vertTags[vIndex]; + Level::VTag const vTag = _level.getVertexTag(vIndex); bool allCornersAreSharp = _hasLinearBoundaries || vTag._infSharp || vTag._nonManifold || (_hasDependentSharpness && (vValues.size() > 2)) || @@ -747,10 +747,10 @@ FVarLevel::print() const { void FVarLevel::initializeFaceValuesFromFaceVertices() { - Index const* srcFaceVerts = &_level._faceVertIndices[0]; - Index * dstFaceValues = &_faceVertValues[0]; + ConstIndexArray srcFaceVerts = _level.getFaceVertices(); + Index * dstFaceValues = &_faceVertValues[0]; - std::memcpy(dstFaceValues, srcFaceVerts, getNumFaceValuesTotal() * sizeof(Index)); + std::memcpy(dstFaceValues, &srcFaceVerts[0], srcFaceVerts.size() * sizeof(Index)); } @@ -763,9 +763,9 @@ FVarLevel::initializeFaceValuesFromVertexFaceSiblings() { // more efficient than a single iteration through the vertex-faces since the first // pass is much more memory coherent. // - int fvCount = (int) _level._faceVertIndices.size(); - for (int i = 0; i < fvCount; ++i) { - _faceVertValues[i] = getVertexValueOffset(_level._faceVertIndices[i]); + ConstIndexArray fvIndices = _level.getFaceVertices(); + for (int i = 0; i < fvIndices.size(); ++i) { + _faceVertValues[i] = getVertexValueOffset(fvIndices[i]); } // @@ -856,8 +856,8 @@ FVarLevel::getVertexEdgeValues(Index vIndex, Index valuesPerEdge[]) const { ConstIndexArray vFaces = _level.getVertexFaces(vIndex); ConstLocalIndexArray vInFace = _level.getVertexFaceLocalIndices(vIndex); - bool vIsBoundary = _level._vertTags[vIndex]._boundary; - bool vIsManifold = not _level._vertTags[vIndex]._nonManifold; + bool vIsBoundary = _level.getVertexTag(vIndex)._boundary; + bool vIsManifold = not _level.getVertexTag(vIndex)._nonManifold; bool isBaseLevel = (_level.getDepth() == 0); @@ -933,10 +933,10 @@ FVarLevel::gatherValueSpans(Index vIndex, ValueSpan * vValueSpans) const { vValueSpans[0]._size = (LocalIndex) vFaces.size(); vValueSpans[0]._start = (LocalIndex) i; } - } else if (_level._edgeTags[vEdges[i]]._infSharp) { + } else if (_level.getEdgeTag(vEdges[i])._infSharp) { vValueSpans[0]._disjoint = true; break; - } else if (_level._edgeTags[vEdges[i]]._semiSharp) { + } else if (_level.getEdgeTag(vEdges[i])._semiSharp) { ++ vValueSpans[0]._semiSharp; } } @@ -948,9 +948,9 @@ FVarLevel::gatherValueSpans(Index vIndex, ValueSpan * vValueSpans) const { if (!vIsBoundary && (vFaceSiblings[vFaces.size() - 1] == 0)) { if (_edgeTags[vEdges[0]]._mismatch) { vValueSpans[0]._disjoint = true; - } else if (_level._edgeTags[vEdges[0]]._infSharp) { + } else if (_level.getEdgeTag(vEdges[0])._infSharp) { vValueSpans[0]._disjoint = true; - } else if (_level._edgeTags[vEdges[0]]._semiSharp) { + } else if (_level.getEdgeTag(vEdges[0])._semiSharp) { ++ vValueSpans[0]._semiSharp; } } @@ -958,9 +958,9 @@ FVarLevel::gatherValueSpans(Index vIndex, ValueSpan * vValueSpans) const { if (vFaceSiblings[i] == vFaceSiblings[i-1]) { if (_edgeTags[vEdges[i]]._mismatch) { ++ vValueSpans[vFaceSiblings[i]]._disjoint; - } else if (_level._edgeTags[vEdges[i]]._infSharp) { + } else if (_level.getEdgeTag(vEdges[i])._infSharp) { vValueSpans[vFaceSiblings[i]]._disjoint = true; - } else if (_level._edgeTags[vEdges[i]]._semiSharp) { + } else if (_level.getEdgeTag(vEdges[i])._semiSharp) { ++ vValueSpans[vFaceSiblings[i]]._semiSharp; } } else { @@ -1026,7 +1026,7 @@ FVarLevel::getFaceCompositeValueAndVTag(ConstIndexArray & faceValues, VertTag & srcVTag = fvarVTags[i]; VertTagSize & srcInt = *(reinterpret_cast(&srcVTag)); - srcVTag = _level._vertTags[faceVerts[i]]; + srcVTag = _level.getVertexTag(faceVerts[i]); Index srcValueIndex = findVertexValueIndex(faceVerts[i], faceValues[i]); assert(_vertValueIndices[srcValueIndex] == faceValues[i]); @@ -1069,7 +1069,7 @@ FVarLevel::getFaceCompositeCombinedEdgeTag(ConstIndexArray & faceEdges, FaceETag & srcETag = fvarETags[i]; FaceETagSize & srcInt = *(reinterpret_cast(&srcETag)); - srcETag = _level._edgeTags[faceEdges[i]]; + srcETag = _level.getEdgeTag(faceEdges[i]); FVarLevel::ETag const & fvarETag = _edgeTags[faceEdges[i]]; if (fvarETag._mismatch) { diff --git a/opensubdiv/vtr/fvarLevel.h b/opensubdiv/vtr/fvarLevel.h index 34b61244..8627572f 100644 --- a/opensubdiv/vtr/fvarLevel.h +++ b/opensubdiv/vtr/fvarLevel.h @@ -234,8 +234,10 @@ public: void print() const; void buildFaceVertexSiblingsFromVertexFaceSiblings(std::vector& fvSiblings) const; -// Members temporarily public pending re-assessment of friends: -public: +private: + // Just as Refinements build Levels, FVarRefinements build FVarLevels... + friend class FVarRefinement; + Level const & _level; // Linear interpolation options vary between channels: @@ -280,30 +282,30 @@ public: inline ConstIndexArray FVarLevel::getFaceValues(Index fIndex) const { - int vCount = _level._faceVertCountsAndOffsets[fIndex*2]; - int vOffset = _level._faceVertCountsAndOffsets[fIndex*2+1]; + int vCount = _level.getNumFaceVertices(fIndex); + int vOffset = _level.getOffsetOfFaceVertices(fIndex); return ConstIndexArray(&_faceVertValues[vOffset], vCount); } inline IndexArray FVarLevel::getFaceValues(Index fIndex) { - int vCount = _level._faceVertCountsAndOffsets[fIndex*2]; - int vOffset = _level._faceVertCountsAndOffsets[fIndex*2+1]; + int vCount = _level.getNumFaceVertices(fIndex); + int vOffset = _level.getOffsetOfFaceVertices(fIndex); return IndexArray(&_faceVertValues[vOffset], vCount); } inline FVarLevel::ConstSiblingArray FVarLevel::getVertexFaceSiblings(Index vIndex) const { - int vCount = _level._vertFaceCountsAndOffsets[vIndex*2]; - int vOffset = _level._vertFaceCountsAndOffsets[vIndex*2+1]; + int vCount = _level.getNumVertexFaces(vIndex); + int vOffset = _level.getOffsetOfVertexFaces(vIndex); return ConstSiblingArray(&_vertFaceSiblings[vOffset], vCount); } inline FVarLevel::SiblingArray FVarLevel::getVertexFaceSiblings(Index vIndex) { - int vCount = _level._vertFaceCountsAndOffsets[vIndex*2]; - int vOffset = _level._vertFaceCountsAndOffsets[vIndex*2+1]; + int vCount = _level.getNumVertexFaces(vIndex); + int vOffset = _level.getOffsetOfVertexFaces(vIndex); return SiblingArray(&_vertFaceSiblings[vOffset], vCount); } diff --git a/opensubdiv/vtr/fvarRefinement.cpp b/opensubdiv/vtr/fvarRefinement.cpp index ce30253a..0982baae 100644 --- a/opensubdiv/vtr/fvarRefinement.cpp +++ b/opensubdiv/vtr/fvarRefinement.cpp @@ -54,9 +54,9 @@ FVarRefinement::FVarRefinement(Refinement const& refinement, FVarLevel& parentFVarLevel, FVarLevel& childFVarLevel) : _refinement(refinement), - _parentLevel(*refinement._parent), + _parentLevel(refinement.parent()), _parentFVar(parentFVarLevel), - _childLevel(*refinement._child), + _childLevel(refinement.child()), _childFVar(childFVarLevel) { } @@ -139,7 +139,7 @@ FVarRefinement::estimateAndAllocateChildValues() { cVert = _refinement.getFirstChildVertexFromVertices(); cVertEnd = cVert + _refinement.getNumChildVerticesFromVertices(); for ( ; cVert < cVertEnd; ++cVert) { - assert(!_refinement._childVertexTag[cVert]._incomplete); + assert(_refinement.isChildVertexComplete(cVert)); Index pVert = _refinement.getChildVertexParentIndex(cVert); maxVertexValueCount += _parentFVar.getNumVertexValues(pVert); @@ -248,7 +248,7 @@ FVarRefinement::populateChildValuesForVertexVertex(Index cVert, Index pVert) { // This will get messy when we do (i.e. sparse refinement of Bilinear or more // flexible and specific sparse refinement of Catmark) but for now assume 1-to-1. // - assert(!_refinement._childVertexTag[cVert]._incomplete); + assert(_refinement.isChildVertexComplete(cVert)); // Number of child values is same as number of parent values since complete: int cValueCount = _parentFVar.getNumVertexValues(pVert); @@ -283,7 +283,7 @@ FVarRefinement::populateChildValues() { // _childFVar._valueCount = 0; - if (_refinement._faceVertsFirst) { + if (_refinement.hasFaceVerticesFirst()) { populateChildValuesFromFaceVertices(); populateChildValuesFromEdgeVertices(); populateChildValuesFromVertexVertices(); @@ -362,10 +362,10 @@ FVarRefinement::propagateEdgeTags() { eTagMatch.clear(); eTagMatch._mismatch = false; - for (int eIndex = 0; eIndex < _refinement._childEdgeFromFaceCount; ++eIndex) { + for (int eIndex = 0; eIndex < _refinement.getNumChildEdgesFromFaces(); ++eIndex) { _childFVar._edgeTags[eIndex] = eTagMatch; } - for (int eIndex = _refinement._childEdgeFromFaceCount; eIndex < _childLevel.getNumEdges(); ++eIndex) { + for (int eIndex = _refinement.getNumChildEdgesFromFaces(); eIndex < _childLevel.getNumEdges(); ++eIndex) { Index pEdge = _refinement.getChildEdgeParentIndex(eIndex); _childFVar._edgeTags[eIndex] = _parentFVar._edgeTags[pEdge]; @@ -435,7 +435,7 @@ FVarRefinement::propagateValueTags() { cVertEnd = cVert + _refinement.getNumChildVerticesFromVertices(); for ( ; cVert < cVertEnd; ++cVert) { Index pVert = _refinement.getChildVertexParentIndex(cVert); - assert(!_refinement._childVertexTag[cVert]._incomplete); + assert(_refinement.isChildVertexComplete(cVert)); FVarLevel::ConstValueTagArray pValueTags = _parentFVar.getVertexValueTags(pVert); FVarLevel::ValueTagArray cValueTags = _childFVar.getVertexValueTags(cVert); @@ -460,7 +460,7 @@ FVarRefinement::propagateValueCreases() { // child faces are incident the new child vertex for each face that becomes a crease, // so identify constants to be used in each iteration first: // - int incChildFacesPerEdge = (_refinement._regFaceSize == 4) ? 2 : 3; + int incChildFacesPerEdge = (_refinement.getRegularFaceSize() == 4) ? 2 : 3; Index cVert = _refinement.getFirstChildVertexFromEdges(); Index cVertEnd = cVert + _refinement.getNumChildVerticesFromEdges(); @@ -468,7 +468,7 @@ FVarRefinement::propagateValueCreases() { FVarLevel::ValueTagArray cValueTags = _childFVar.getVertexValueTags(cVert); if (!cValueTags[0].isMismatch()) continue; - if (_refinement._childVertexTag[cVert]._incomplete) continue; + if (!_refinement.isChildVertexComplete(cVert)) continue; FVarLevel::CreaseEndPairArray cValueCreaseEnds = _childFVar.getVertexValueCreaseEnds(cVert); @@ -496,7 +496,7 @@ FVarRefinement::propagateValueCreases() { FVarLevel::ValueTagArray cValueTags = _childFVar.getVertexValueTags(cVert); if (!cValueTags[0].isMismatch()) continue; - if (_refinement._childVertexTag[cVert]._incomplete) continue; + if (!_refinement.isChildVertexComplete(cVert)) continue; Index pVert = _refinement.getChildVertexParentIndex(cVert); @@ -529,7 +529,7 @@ FVarRefinement::reclassifySemisharpValues() { // bool hasDependentSharpness = _parentFVar._hasDependentSharpness; - internal::StackBuffer cVertEdgeBuffer(_childLevel._maxValence); + internal::StackBuffer cVertEdgeBuffer(_childLevel.getMaxValence()); FVarLevel::ValueTag valTagCrease; valTagCrease.clear(); @@ -548,16 +548,16 @@ FVarRefinement::reclassifySemisharpValues() { FVarLevel::ValueTagArray cValueTags = _childFVar.getVertexValueTags(cVert); if (!cValueTags[0].isMismatch()) continue; - if (_refinement._childVertexTag[cVert]._incomplete) continue; + if (!_refinement.isChildVertexComplete(cVert)) continue; // If the parent vertex wasn't semi-sharp, the child vertex and values can't be: Index pVert = _refinement.getChildVertexParentIndex(cVert); - Level::VTag pVertTags = _parentLevel._vertTags[pVert]; + Level::VTag pVertTags = _parentLevel.getVertexTag(pVert); if (!pVertTags._semiSharp && !pVertTags._semiSharpEdges) continue; // If the child vertex is still sharp, all values remain unaffected: - Level::VTag cVertTags = _childLevel._vertTags[cVert]; + Level::VTag cVertTags = _childLevel.getVertexTag(cVert); if (cVertTags._semiSharp || cVertTags._infSharp) continue; @@ -601,14 +601,14 @@ FVarRefinement::reclassifySemisharpValues() { bool isStillSemiSharp = false; if (vEndFace > vStartFace) { for (int k = vStartFace + 1; !isStillSemiSharp && (k <= vEndFace); ++k) { - isStillSemiSharp = _childLevel._edgeTags[cVertEdges[k]]._semiSharp; + isStillSemiSharp = _childLevel.getEdgeTag(cVertEdges[k])._semiSharp; } } else if (vStartFace > vEndFace) { for (int k = vStartFace + 1; !isStillSemiSharp && (k < cVertEdges.size()); ++k) { - isStillSemiSharp = _childLevel._edgeTags[cVertEdges[k]]._semiSharp; + isStillSemiSharp = _childLevel.getEdgeTag(cVertEdges[k])._semiSharp; } for (int k = 0; !isStillSemiSharp && (k <= vEndFace); ++k) { - isStillSemiSharp = _childLevel._edgeTags[cVertEdges[k]]._semiSharp; + isStillSemiSharp = _childLevel.getEdgeTag(cVertEdges[k])._semiSharp; } } if (!isStillSemiSharp) { @@ -676,21 +676,21 @@ FVarRefinement::getFractionalWeight(Index pVert, LocalIndex pSibling, int interiorEdgeCount = 0; if (pEndFace > pStartFace) { for (int i = pStartFace + 1; i <= pEndFace; ++i, ++interiorEdgeCount) { - pEdgeSharpness[interiorEdgeCount] = _parentLevel._edgeSharpness[pVertEdges[i]]; - cEdgeSharpness[interiorEdgeCount] = _childLevel._edgeSharpness[cVertEdges[i]]; + pEdgeSharpness[interiorEdgeCount] = _parentLevel.getEdgeSharpness(pVertEdges[i]); + cEdgeSharpness[interiorEdgeCount] = _childLevel.getEdgeSharpness(cVertEdges[i]); } } else if (pStartFace > pEndFace) { for (int i = pStartFace + 1; i < pVertEdges.size(); ++i, ++interiorEdgeCount) { - pEdgeSharpness[interiorEdgeCount] = _parentLevel._edgeSharpness[pVertEdges[i]]; - cEdgeSharpness[interiorEdgeCount] = _childLevel._edgeSharpness[cVertEdges[i]]; + pEdgeSharpness[interiorEdgeCount] = _parentLevel.getEdgeSharpness(pVertEdges[i]); + cEdgeSharpness[interiorEdgeCount] = _childLevel.getEdgeSharpness(cVertEdges[i]); } for (int i = 0; i <= pEndFace; ++i, ++interiorEdgeCount) { - pEdgeSharpness[interiorEdgeCount] = _parentLevel._edgeSharpness[pVertEdges[i]]; - cEdgeSharpness[interiorEdgeCount] = _childLevel._edgeSharpness[cVertEdges[i]]; + pEdgeSharpness[interiorEdgeCount] = _parentLevel.getEdgeSharpness(pVertEdges[i]); + cEdgeSharpness[interiorEdgeCount] = _childLevel.getEdgeSharpness(cVertEdges[i]); } } - return Sdc::Crease(_refinement._options).ComputeFractionalWeightAtVertex( - _parentLevel._vertSharpness[pVert], _childLevel._vertSharpness[cVert], + return Sdc::Crease(_refinement.getOptions()).ComputeFractionalWeightAtVertex( + _parentLevel.getVertexSharpness(pVert), _childLevel.getVertexSharpness(cVert), interiorEdgeCount, pEdgeSharpness, cEdgeSharpness); } diff --git a/opensubdiv/vtr/fvarRefinement.h b/opensubdiv/vtr/fvarRefinement.h index 9824b3d6..90c910e7 100644 --- a/opensubdiv/vtr/fvarRefinement.h +++ b/opensubdiv/vtr/fvarRefinement.h @@ -86,8 +86,7 @@ public: void propagateValueCreases(); void reclassifySemisharpValues(); -// Members temporarily public pending re-assessment of friends: -public: +private: // // Identify the Refinement, its Levels and assigned FVarLevels for more // immediate access -- child FVarLevel is non-const as it is to be assigned: diff --git a/opensubdiv/vtr/level.cpp b/opensubdiv/vtr/level.cpp index c8397214..a54fb881 100644 --- a/opensubdiv/vtr/level.cpp +++ b/opensubdiv/vtr/level.cpp @@ -1947,7 +1947,7 @@ Level::getNumFVarValues(int channel) const { Sdc::Options Level::getFVarOptions(int channel) const { - return _fvarChannels[channel]->_options; + return _fvarChannels[channel]->getOptions(); } ConstIndexArray diff --git a/opensubdiv/vtr/level.h b/opensubdiv/vtr/level.h index 5b3ded80..4bbf90cb 100644 --- a/opensubdiv/vtr/level.h +++ b/opensubdiv/vtr/level.h @@ -44,6 +44,9 @@ namespace Vtr { namespace internal { class Refinement; +class TriRefinement; +class QuadRefinement; +class FVarRefinement; class FVarLevel; // @@ -350,6 +353,7 @@ public: int getNumVertexEdges( Index vertIndex) const { return _vertEdgeCountsAndOffsets[2*vertIndex]; } int getOffsetOfVertexEdges(Index vertIndex) const { return _vertEdgeCountsAndOffsets[2*vertIndex + 1]; } + ConstIndexArray getFaceVertices() const; // // Note that for some relations, the size of the relations for a child component @@ -391,8 +395,12 @@ public: IndexArray shareFaceVertCountsAndOffsets() const; -// Members temporarily public pending re-assessment of friends: -public: +private: + // Refinement classes (including all subclasses) build a Level: + friend class Refinement; + friend class TriRefinement; + friend class QuadRefinement; + // // A Level is independent of subdivision scheme or options. While it may have been // affected by them in its construction, they are not associated with it -- a Level @@ -489,6 +497,11 @@ Level::resizeFaceVertices(Index faceIndex, int count) { _maxValence = std::max(_maxValence, count); } +inline ConstIndexArray +Level::getFaceVertices() const { + return ConstIndexArray(&_faceVertIndices[0], (int)_faceVertIndices.size()); +} + // // Access/modify the edges indicent a given face: // diff --git a/opensubdiv/vtr/refinement.h b/opensubdiv/vtr/refinement.h index 8e1a69bb..072480b0 100644 --- a/opensubdiv/vtr/refinement.h +++ b/opensubdiv/vtr/refinement.h @@ -78,6 +78,7 @@ public: Sdc::Split getSplitType() const { return _splitType; } int getRegularFaceSize() const { return _regFaceSize; } + Sdc::Options getOptions() const { return _options; } // Face-varying: int getNumFVarChannels() const { return (int) _fvarChannels.size(); } @@ -119,6 +120,8 @@ public: void refine(Options options = Options()); + bool hasFaceVerticesFirst() const { return _faceVertsFirst; } + public: // // Access to members -- some testing classes (involving vertex interpolation) @@ -146,8 +149,9 @@ public: ConstIndexArray getFaceChildEdges(Index parentFace) const; ConstIndexArray getEdgeChildEdges(Index parentEdge) const; - // Child-to-parent relationships (not yet complete -- unclear how we will define the - // "type" of the parent component, e.g. vertex, edge or face): + // Child-to-parent relationships + bool isChildVertexComplete(Index v) const { return not _childVertexTag[v]._incomplete; } + Index getChildFaceParentFace(Index f) const { return _childFaceParentIndex[f]; } int getChildFaceInParentFace(Index f) const { return _childFaceTag[f]._indexInParent; } @@ -206,6 +210,14 @@ public: SparseTag & getParentEdgeSparseTag( Index e) { return _parentEdgeTag[e]; } SparseTag & getParentVertexSparseTag(Index v) { return _parentVertexTag[v]; } + ChildTag const & getChildFaceTag( Index f) const { return _childFaceTag[f]; } + ChildTag const & getChildEdgeTag( Index e) const { return _childEdgeTag[e]; } + ChildTag const & getChildVertexTag(Index v) const { return _childVertexTag[v]; } + + ChildTag & getChildFaceTag( Index f) { return _childFaceTag[f]; } + ChildTag & getChildEdgeTag( Index e) { return _childEdgeTag[e]; } + ChildTag & getChildVertexTag(Index v) { return _childVertexTag[v]; } + // Remaining methods should really be protected -- for use by subclasses... public: // @@ -307,8 +319,10 @@ public: // void subdivideFVarChannels(); -// Members temporarily public pending re-assessment of friends: -public: +protected: + // A debug method of Level prints a Refinement (should really change this) + friend void Level::print(const Refinement *) const; + // // Data members -- the logical grouping of some of these (and methods that make use // of them) may lead to grouping them into a few utility classes or structs... diff --git a/opensubdiv/vtr/sparseSelector.h b/opensubdiv/vtr/sparseSelector.h index dfec3040..6dc4a907 100644 --- a/opensubdiv/vtr/sparseSelector.h +++ b/opensubdiv/vtr/sparseSelector.h @@ -35,9 +35,6 @@ namespace OpenSubdiv { namespace OPENSUBDIV_VERSION { namespace Vtr { - -class Refinement; - namespace internal { // @@ -79,13 +76,13 @@ public: private: SparseSelector() : _refine(0), _selected(false) { } - bool wasVertexSelected(Index pVertex) const { return _refine->_parentVertexTag[pVertex]._selected; } - bool wasEdgeSelected( Index pEdge) const { return _refine->_parentEdgeTag[pEdge]._selected; } - bool wasFaceSelected( Index pFace) const { return _refine->_parentFaceTag[pFace]._selected; } + bool wasVertexSelected(Index pVertex) const { return _refine->getParentVertexSparseTag(pVertex)._selected; } + bool wasEdgeSelected( Index pEdge) const { return _refine->getParentEdgeSparseTag(pEdge)._selected; } + bool wasFaceSelected( Index pFace) const { return _refine->getParentFaceSparseTag(pFace)._selected; } - void markVertexSelected(Index pVertex) const { _refine->_parentVertexTag[pVertex]._selected = true; } - void markEdgeSelected( Index pEdge) const { _refine->_parentEdgeTag[pEdge]._selected = true; } - void markFaceSelected( Index pFace) const { _refine->_parentFaceTag[pFace]._selected = true; } + void markVertexSelected(Index pVertex) const { _refine->getParentVertexSparseTag(pVertex)._selected = true; } + void markEdgeSelected( Index pEdge) const { _refine->getParentEdgeSparseTag(pEdge)._selected = true; } + void markFaceSelected( Index pFace) const { _refine->getParentFaceSparseTag(pFace)._selected = true; } void initializeSelection();