AuroraMiddleware/OpenSubdiv
1
0
Fork 0
mirror of https://github.com/PixarAnimationStudios/OpenSubdiv synced 2024-09-19 14:20:00 +00:00
Code Issues Releases Wiki Activity

Re-protected members of all major Vtr classes:

Browse Source 
- 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
This commit is contained in:
barfowl 2015-06-01 17:38:11 -07:00
parent 66ea8ab970
commit 13e0850ac6
9 changed files with 104 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
opensubdiv/vtr/CMakeLists.txt
View File

@ -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}")

40
opensubdiv/vtr/fvarLevel.cpp
View File

@ -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<VertTagSize *>(&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<FaceETagSize *>(&srcETag));
srcETag = _level._edgeTags[faceEdges[i]];
srcETag = _level.getEdgeTag(faceEdges[i]);
FVarLevel::ETag const & fvarETag = _edgeTags[faceEdges[i]];
if (fvarETag._mismatch) {

22
opensubdiv/vtr/fvarLevel.h
View File

@ -234,8 +234,10 @@ public:
void print() const;
void buildFaceVertexSiblingsFromVertexFaceSiblings(std::vector<Sibling>& 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);
}

52
opensubdiv/vtr/fvarRefinement.cpp
View File

@ -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<Index,16> cVertEdgeBuffer(_childLevel._maxValence);
internal::StackBuffer<Index,16> 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);
}

3
opensubdiv/vtr/fvarRefinement.h
View File

@ -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:

2
opensubdiv/vtr/level.cpp
View File

@ -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

17
opensubdiv/vtr/level.h
View File

@ -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:
//

22
opensubdiv/vtr/refinement.h
View File

@ -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...

15
opensubdiv/vtr/sparseSelector.h
View File

@ -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();