AuroraMiddleware/OpenSubdiv
1
0
Fork 0
mirror of https://github.com/PixarAnimationStudios/OpenSubdiv synced 2024-12-13 04:20:10 +00:00
Code Issues Releases Wiki Activity
a907450229
OpenSubdiv/opensubdiv/far/patchTablesFactory.h
Takahito Tejima 51a45b598d Updating EULA
2013-07-18 14:19:50 -07:00

1096 lines
41 KiB
C++
Raw Blame History

//
// Copyright 2013 Pixar
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License
// and the following modification to it: Section 6 Trademarks.
// deleted and replaced with:
//
// 6. Trademarks. This License does not grant permission to use the
// trade names, trademarks, service marks, or product names of the
// Licensor and its affiliates, except as required for reproducing
// the content of the NOTICE file.
//
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
// either express or implied. See the License for the specific
// language governing permissions and limitations under the
// License.
//
#ifndef FAR_PATCH_TABLES_FACTORY_H
#define FAR_PATCH_TABLES_FACTORY_H
#include "../version.h"
#include "../far/patchTables.h"
namespace OpenSubdiv {
namespace OPENSUBDIV_VERSION {
/// \brief A specialized factory for feature adaptive FarPatchTables
///
/// FarPatchTables contain the lists of vertices for each patch of an adaptive
/// mesh representation. This specialized factory is a private helper for FarMeshFactory.
///
/// Separating the factory allows us to isolate Far data structures from Hbr dependencies.
///
template <class T> class FarPatchTablesFactory {
protected:
template <class X, class Y> friend class FarMeshFactory;
/// \brief Factory constructor for feature-adaptive meshes
///
/// @param mesh Hbr mesh to generate tables for
///
/// @param nfaces Number of faces in the mesh (cached for speed)
///
/// @param remapTable Vertex remapping table generated by FarMeshFactory
///
FarPatchTablesFactory( HbrMesh<T> const * mesh, int nfaces, std::vector<int> const & remapTable );
/// \brief Returns a feature-adaptive FarPatchTables instance
///
/// @param maxlevel Highest level of refinement processed
///
/// @param maxvalence Maximum vertex valence in the mesh
///
/// @param requireFVarData Flag for generating face-varying data
///
/// @return A new instance of FarPatchTables
///
FarPatchTables * Create( int maxlevel, int maxvalence, bool requireFVarData=false );
typedef std::vector<std::vector< HbrFace<T> *> > FacesList;
/// \brief Factory constructor for uniform meshes
///
/// @param mesh Hbr mesh to generate tables for
///
/// @param flist Vectors of pointers to HbrFace<T> for each level
/// of subdivision
///
/// @param requireFVarData Flag for generating face-varying data
///
/// @param firstLevel First level of subdivision to use when building the
/// PatchArrayVector (default -1 means only generate
/// a single patch array for the highest level of
/// subdivision)
///
/// @param remapTable Vertex remapping table generated by FarMeshFactory
///
/// @return A new instance of FarPatchTables
///
static FarPatchTables * Create( HbrMesh<T> const * mesh,
FacesList const & flist,
std::vector<int> const & remapTable,
int firstLevel=-1,
bool requireFVarData=false );
private:
typedef FarPatchTables::Descriptor Descriptor;
// Returns true if one of v's neighboring faces has vertices carrying the tag "wasTagged"
static bool vertexHasTaggedNeighbors(HbrVertex<T> * v);
// Returns the rotation for a boundary patch
static unsigned char computeBoundaryPatchRotation( HbrFace<T> * f );
// Returns the rotation for a corner patch
static unsigned char computeCornerPatchRotation( HbrFace<T> * f );
// Populates an array of indices with the "one-ring" vertices for the given face
void getOneRing( HbrFace<T> * f, int ringsize, unsigned int const * remap, unsigned int * result );
// Populates the Gregory patch quad offsets table
static void getQuadOffsets( HbrFace<T> * f, unsigned int * result );
// Iterates through the faces of an HbrMesh and tags the _adaptiveFlags on faces and vertices
void tagAdaptivePatches( HbrMesh<T> const * mesh, int nfaces );
// Hbr mesh accessor
HbrMesh<T> const * getMesh() const { return _mesh; }
// Number of faces in the Hbr mesh (cached for speed)
int getNumFaces() const { return _nfaces; }
// The number of patch arrays in the mesh
int getNumPatchArrays() const;
// The number of patches in the mesh
static int getNumPatches( FarPatchTables::PatchArrayVector const & parrays );
// Reserves tables based on the contents of the PatchArrayVector
static void allocateTables( FarPatchTables * tables, int fvarwidth );
// A convenience container for the different types of feature adaptive patches
template<class TYPE> struct PatchTypes {
TYPE R, // regular patch
B[4], // boundary patch (4 rotations)
C[4], // corner patch (4 rotations)
G[2]; // gregory patch (boundary & corner)
PatchTypes() { memset(this, 0, sizeof(PatchTypes<TYPE>)); }
// Returns the number of patches based on the patch type in the descriptor
TYPE & getValue( FarPatchTables::Descriptor desc );
// Counts the number of arrays required to store each type of patch used
// in the primitive
int getNumPatchArrays() const;
};
typedef PatchTypes<unsigned int*> CVPointers;
typedef PatchTypes<FarPatchParam *> ParamPointers;
typedef PatchTypes<float *> FVarPointers;
typedef PatchTypes<int> Counter;
// Creates a PatchArray and appends it to a vector and keeps track of both
// vertex and patch offsets
void pushPatchArray( FarPatchTables::Descriptor desc,
FarPatchTables::PatchArrayVector & parray,
Counter & counter,
int * voffset, int * poffset, int * qoffset );
Counter _patchCtr[6]; // counters for full and transition patches
HbrMesh<T> const * _mesh;
// Reference to the vertex remapping table generated by FarMeshFactory
std::vector<int> const &_remapTable;
int _nfaces;
};
// True if the surrounding faces are "tagged" (unsupported feature : watertight
// critical patches)
template <class T> bool
FarPatchTablesFactory<T>::vertexHasTaggedNeighbors(HbrVertex<T> * v) {
assert(v);
HbrHalfedge<T> * start = v->GetIncidentEdge(),
* next=start;
do {
HbrFace<T> * right = next->GetRightFace(),
* left = next->GetLeftFace();
if (right and (not right->hasTaggedVertices()))
return true;
if (left and (not left->hasTaggedVertices()))
return true;
next = v->GetNextEdge(next);
} while (next and next!=start);
return false;
}
// Returns a rotation index for boundary patches (range [0-3])
template <class T> unsigned char
FarPatchTablesFactory<T>::computeBoundaryPatchRotation( HbrFace<T> * f ) {
unsigned char rot=0;
for (unsigned char i=0; i<4;++i) {
if (f->GetVertex(i)->OnBoundary() and
f->GetVertex((i+1)%4)->OnBoundary())
break;
++rot;
}
return rot;
}
// Returns a rotation index for corner patches (range [0-3])
template <class T> unsigned char
FarPatchTablesFactory<T>::computeCornerPatchRotation( HbrFace<T> * f ) {
unsigned char rot=0;
for (unsigned char i=0; i<4; ++i) {
if (not f->GetVertex((i+3)%4)->OnBoundary())
break;
++rot;
}
return rot;
}
// Reserves tables based on the contents of the PatchArrayVector
template <class T> void
FarPatchTablesFactory<T>::allocateTables( FarPatchTables * tables, int fvarwidth ) {
int nverts = tables->GetNumControlVertices(),
npatches = getNumPatches(tables->GetPatchArrayVector());
if (nverts==0 or npatches==0)
return;
tables->_patches.resize( nverts );
tables->_paramTable.resize( npatches );
if (fvarwidth>0) {
tables->_fvarTable.resize( npatches * 4 * fvarwidth );
}
}
// Uniform mesh factory (static function because it requires no cached state)
template <class T> FarPatchTables *
FarPatchTablesFactory<T>::Create( HbrMesh<T> const * mesh, FacesList const & flist, std::vector<int> const & remapTable, int firstLevel, bool requireFVarData ) {
if (flist.size()<2)
return 0;
FarPatchTables * result = new FarPatchTables(0);
bool isLoop = FarMeshFactory<T,T>::isLoop(mesh);
int nv = isLoop ? 3 : 4;
int firstArray = firstLevel > -1 ? firstLevel : (int)flist.size()-1;
// Populate the patch array descriptors
FarPatchTables::PatchArrayVector & parray = result->_patchArrays;
parray.reserve( (int)flist.size() - firstArray );
Descriptor desc( isLoop ? FarPatchTables::TRIANGLES : FarPatchTables::QUADS, FarPatchTables::NON_TRANSITION, 0 );
for (int i=1, poffset=0, voffset=0; i<(int)flist.size(); ++i) {
int nfaces = (int)flist[i].size();
if (i>=firstArray) {
parray.push_back( FarPatchTables::PatchArray(desc, voffset, poffset, nfaces, 0 ) );
voffset += nfaces * nv;
poffset += nfaces;
}
}
int fvarwidth = requireFVarData ? mesh->GetTotalFVarWidth() : 0;
// Populate the patch / param / fvar tables
allocateTables( result, fvarwidth );
unsigned int * iptr = &result->_patches[0];
FarPatchParam * pptr = &result->_paramTable[0];
float * fptr = fvarwidth>0 ? &result->_fvarTable[0] : 0;
for (int level=firstArray; level<(int)flist.size(); ++level) {
for (int i=0; i<(int)flist[level].size(); ++i) {
HbrFace<T> * f = flist[level][i];
assert( f and f->GetNumVertices()==nv);
for (int j=0; j<f->GetNumVertices(); ++j) {
*iptr++ = remapTable[f->GetVertex(j)->GetID()];
}
pptr = computePatchParam(f, pptr);
if (fvarwidth>0)
fptr = computeFVarData(f, fvarwidth, fptr, /*isAdaptive=*/false);
}
}
return result;
}
// Feature adaptive mesh factory
template <class T>
FarPatchTablesFactory<T>::FarPatchTablesFactory( HbrMesh<T> const * mesh, int nfaces, std::vector<int> const & remapTable ) :
_mesh(mesh),
_remapTable(remapTable),
_nfaces(nfaces)
{
assert(mesh and nfaces>0);
// First pass : identify transition / watertight-critical
for (int i=0; i<nfaces; ++i) {
HbrFace<T> * f = mesh->GetFace(i);
if (f->_adaptiveFlags.isTagged and (not f->IsHole())) {
HbrVertex<T> * v = f->Subdivide();
assert(v);
v->_adaptiveFlags.wasTagged=true;
}
int nv = f->GetNumVertices();
for (int j=0; j<nv; ++j) {
if (f->IsCoarse())
f->GetVertex(j)->_adaptiveFlags.wasTagged=true;
HbrHalfedge<T> * e = f->GetEdge(j);
// Flag transition edge that require a triangulated transition
if (f->_adaptiveFlags.isTagged) {
e->_adaptiveFlags.isTriangleHead=true;
// Both half-edges need to be tagged if an opposite exists
if (e->GetOpposite())
e->GetOpposite()->_adaptiveFlags.isTriangleHead=true;
}
HbrFace<T> * left = e->GetLeftFace(),
* right = e->GetRightFace();
if (not (left and right))
continue;
// a tagged edge w/ no children is inside a hole
if (e->HasChild() and (left->_adaptiveFlags.isTagged ^ right->_adaptiveFlags.isTagged)) {
e->_adaptiveFlags.isTransition = true;
HbrVertex<T> * child = e->Subdivide();
assert(child);
// These edges will require extra rows of CVs to maintain water-tightness
// Note : vertices inside holes have no children
if (e->GetOrgVertex()->HasChild()) {
HbrHalfedge<T> * org = child->GetEdge(e->GetOrgVertex()->Subdivide());
if (org)
org->_adaptiveFlags.isWatertightCritical=true;
}
if (e->GetDestVertex()->HasChild()) {
HbrHalfedge<T> * dst = child->GetEdge(e->GetDestVertex()->Subdivide());
if (dst)
dst->_adaptiveFlags.isWatertightCritical=true;
}
}
}
}
// Second pass : count boundaries / identify transition constellation
for (int i=0; i<nfaces; ++i) {
HbrFace<T> * f = mesh->GetFace(i);
if (mesh->GetSubdivision()->FaceIsExtraordinary(mesh,f))
continue;
if (f->IsHole())
continue;
bool isTagged=0, wasTagged=0, isConnected=0, isWatertightCritical=0, isExtraordinary=0;
int triangleHeads=0, boundaryVerts=0;
int nv = f->GetNumVertices();
for (int j=0; j<nv; ++j) {
HbrVertex<T> * v = f->GetVertex(j);
if (v->OnBoundary()) {
boundaryVerts++;
// Boundary vertices with valence higher than 3 aren't Full Boundary
// patches, they are Gregory Boundary patches.
if (v->IsSingular() or v->GetValence()>3)
isExtraordinary=true;
} else if (v->IsExtraordinary())
isExtraordinary=true;
if (f->GetParent() and (not isWatertightCritical))
isWatertightCritical = vertexHasTaggedNeighbors(v);
if (v->_adaptiveFlags.isTagged)
isTagged=1;
if (v->_adaptiveFlags.wasTagged)
wasTagged=1;
// Count the number of triangle heads to find which transition
// pattern to use.
HbrHalfedge<T> * e = f->GetEdge(j);
if (e->_adaptiveFlags.isTriangleHead) {
++triangleHeads;
if (f->GetEdge((j+1)%4)->_adaptiveFlags.isTriangleHead)
isConnected=true;
}
}
f->_adaptiveFlags.bverts=boundaryVerts;
f->_adaptiveFlags.isCritical=isWatertightCritical;
// Regular Boundary Patch
if (wasTagged)
// XXXX manuelk - need to implement end patches
f->_adaptiveFlags.patchType = HbrFace<T>::kEnd;
if (f->_adaptiveFlags.isTagged)
continue;
assert(f->_adaptiveFlags.rots==0 and nv==4);
if (not isTagged and wasTagged) {
if (triangleHeads==0) {
if (not isExtraordinary and boundaryVerts!=1) {
// Full Patches
f->_adaptiveFlags.patchType = HbrFace<T>::kFull;
switch (boundaryVerts) {
case 0 : { // Regular patch
_patchCtr[0].R++;
} break;
case 2 : { // Boundary patch
f->_adaptiveFlags.rots=computeBoundaryPatchRotation(f);
_patchCtr[0].B[0]++;
} break;
case 3 : { // Corner patch
f->_adaptiveFlags.rots=computeCornerPatchRotation(f);
_patchCtr[0].C[0]++;
} break;
default : break;
}
} else {
// Default to Gregory Patch
f->_adaptiveFlags.patchType = HbrFace<T>::kGregory;
switch (boundaryVerts) {
case 0 : { // Regular Gregory patch
_patchCtr[0].G[0]++;
} break;
default : { // Boundary Gregory patch
_patchCtr[0].G[1]++;
} break;
}
}
} else {
// Transition Patch
// Resolve transition constellation : 5 types (see p.5 fig. 7)
switch (triangleHeads) {
case 1 : { for (unsigned char j=0; j<4; ++j) {
if (f->GetEdge(j)->IsTriangleHead())
break;
f->_adaptiveFlags.rots++;
}
f->_adaptiveFlags.transitionType = HbrFace<T>::kTransition0;
} break;
case 2 : { for (unsigned char j=0; j<4; ++j) {
if (isConnected) {
if (f->GetEdge(j)->IsTriangleHead() and
f->GetEdge((j+3)%4)->IsTriangleHead())
break;
} else {
if (f->GetEdge(j)->IsTriangleHead())
break;
}
f->_adaptiveFlags.rots++;
}
if (isConnected)
f->_adaptiveFlags.transitionType = HbrFace<T>::kTransition1;
else
f->_adaptiveFlags.transitionType = HbrFace<T>::kTransition4;
} break;
case 3 : { for (unsigned char j=0; j<4; ++j) {
if (not f->GetEdge(j)->IsTriangleHead())
break;
f->_adaptiveFlags.rots++;
}
f->_adaptiveFlags.transitionType = HbrFace<T>::kTransition2;
} break;
case 4 : f->_adaptiveFlags.transitionType = HbrFace<T>::kTransition3;
break;
default: break;
}
int tidx = f->_adaptiveFlags.transitionType;
assert(tidx>=0);
// Correct rotations for corners & boundaries
if (not isExtraordinary and boundaryVerts!=1) {
switch (boundaryVerts) {
case 0 : { // regular patch
_patchCtr[tidx+1].R++;
} break;
case 2 : { // boundary patch
unsigned char rot=computeBoundaryPatchRotation(f);
f->_adaptiveFlags.brots=(4-f->_adaptiveFlags.rots+rot)%4;
f->_adaptiveFlags.rots=rot; // override the transition rotation
_patchCtr[tidx+1].B[f->_adaptiveFlags.brots]++;
} break;
case 3 : { // corner patch
unsigned char rot=computeCornerPatchRotation(f);
f->_adaptiveFlags.brots=(4-f->_adaptiveFlags.rots+rot)%4;
f->_adaptiveFlags.rots=rot; // override the transition rotation
_patchCtr[tidx+1].C[f->_adaptiveFlags.brots]++;
} break;
default : assert(0); break;
}
} else {
// Use Gregory Patch transition ?
}
}
}
}
}
template <class T>
template <class TYPE> TYPE &
FarPatchTablesFactory<T>::PatchTypes<TYPE>::getValue( FarPatchTables::Descriptor desc ) {
switch (desc.GetType()) {
case FarPatchTables::REGULAR : return R;
case FarPatchTables::BOUNDARY : return B[desc.GetRotation()];
case FarPatchTables::CORNER : return C[desc.GetRotation()];
case FarPatchTables::GREGORY : return G[0];
case FarPatchTables::GREGORY_BOUNDARY : return G[1];
default : assert(0);
}
// can't be reached (suppress compiler warning)
return R;
}
template <class T>
template <class TYPE> int
FarPatchTablesFactory<T>::PatchTypes<TYPE>::getNumPatchArrays() const {
int result=0;
if (R) ++result;
for (int i=0; i<4; ++i) {
if (B[i]) ++result;
if (C[i]) ++result;
if ((i<2) and G[i]) ++result;
}
return result;
}
template <class T> int
FarPatchTablesFactory<T>::getNumPatchArrays() const {
int result = 0;
for (int i=0; i<6; ++i)
result += _patchCtr[i].getNumPatchArrays();
return result;
}
template <class T> int
FarPatchTablesFactory<T>::getNumPatches( FarPatchTables::PatchArrayVector const & parrays ) {
int result=0;
for (int i=0; i<(int)parrays.size(); ++i) {
result += parrays[i].GetNumPatches();
}
return result;
}
template <class T> void
FarPatchTablesFactory<T>::pushPatchArray( FarPatchTables::Descriptor desc,
FarPatchTables::PatchArrayVector & parray,
typename FarPatchTablesFactory<T>::Counter & counter,
int * voffset, int * poffset, int * qoffset ) {
int npatches = counter.getValue( desc );
if (npatches>0) {
parray.push_back( FarPatchTables::PatchArray(desc, *voffset, *poffset, npatches, *qoffset) );
*voffset += npatches * desc.GetNumControlVertices();
*poffset += npatches;
*qoffset += (desc.GetType() == FarPatchTables::GREGORY) ? npatches * desc.GetNumControlVertices() : 0;
}
}
template <class T> FarPatchTables *
FarPatchTablesFactory<T>::Create( int maxlevel, int maxvalence, bool requireFVarData ) {
static const unsigned int remapRegular [16] = {5,6,10,9,4,0,1,2,3,7,11,15,14,13,12,8};
static const unsigned int remapRegularBoundary[12] = {1,2,6,5,0,3,7,11,10,9,8,4};
static const unsigned int remapRegularCorner [ 9] = {1,2,5,4,0,8,7,6,3};
assert(getMesh() and getNumFaces()>0);
FarPatchTables * result = new FarPatchTables(maxvalence);
// Populate the patch array descriptors
FarPatchTables::PatchArrayVector & parray = result->_patchArrays;
parray.reserve( getNumPatchArrays() );
int voffset=0, poffset=0, qoffset=0;
for (Descriptor::iterator it=Descriptor::begin(); it!=Descriptor::end(); ++it) {
pushPatchArray( *it, parray, _patchCtr[it->GetPattern()], &voffset, &poffset, &qoffset );
}
int fvarwidth = requireFVarData ? getMesh()->GetTotalFVarWidth() : 0;
allocateTables( result, fvarwidth );
FarPatchTables::QuadOffsetTable quad_G_C0; // Quad-offsets tables (for Gregory patches)
quad_G_C0.resize(_patchCtr[0].G[0]*4);
FarPatchTables::QuadOffsetTable quad_G_C1;
quad_G_C1.resize(_patchCtr[0].G[1]*4);
FarPatchTables::QuadOffsetTable::value_type *quad_G_C0_P = quad_G_C0.empty() ? 0 : &quad_G_C0[0];
FarPatchTables::QuadOffsetTable::value_type *quad_G_C1_P = quad_G_C1.empty() ? 0 : &quad_G_C1[0];
// Setup convenience pointers at the beginning of each patch array for each
// table (patches, ptex, fvar)
CVPointers iptrs[6];
ParamPointers pptrs[6];
FVarPointers fptrs[6];
for (Descriptor::iterator it=Descriptor::begin(); it!=Descriptor::end(); ++it) {
FarPatchTables::PatchArray * pa = result->findPatchArray(*it);
if (not pa)
continue;
iptrs[(int)pa->GetDescriptor().GetPattern()].getValue( *it ) = &result->_patches[pa->GetVertIndex()];
pptrs[(int)pa->GetDescriptor().GetPattern()].getValue( *it ) = &result->_paramTable[pa->GetPatchIndex()];
if (fvarwidth>0)
fptrs[(int)pa->GetDescriptor().GetPattern()].getValue( *it ) = &result->_fvarTable[pa->GetPatchIndex() * 4 * fvarwidth];
}
// Populate patch index tables with vertex indices
for (int i=0; i<getNumFaces(); ++i) {
HbrFace<T> * f = getMesh()->GetFace(i);
if (not f->isTransitionPatch() ) {
// Full / End patches
if (f->_adaptiveFlags.patchType==HbrFace<T>::kFull) {
if (not f->_adaptiveFlags.isExtraordinary and f->_adaptiveFlags.bverts!=1) {
switch (f->_adaptiveFlags.bverts) {
case 0 : { // Regular Patch (16 CVs)
getOneRing(f, 16, remapRegular, iptrs[0].R);
iptrs[0].R+=16;
pptrs[0].R = computePatchParam(f, pptrs[0].R);
fptrs[0].R = computeFVarData(f, fvarwidth, fptrs[0].R, /*isAdaptive=*/true);
} break;
case 2 : { // Boundary Patch (12 CVs)
f->_adaptiveFlags.brots = (f->_adaptiveFlags.rots+1)%4;
getOneRing(f, 12, remapRegularBoundary, iptrs[0].B[0]);
iptrs[0].B[0]+=12;
pptrs[0].B[0] = computePatchParam(f, pptrs[0].B[0]);
fptrs[0].B[0] = computeFVarData(f, fvarwidth, fptrs[0].B[0], /*isAdaptive=*/true);
} break;
case 3 : { // Corner Patch (9 CVs)
f->_adaptiveFlags.brots = (f->_adaptiveFlags.rots+1)%4;
getOneRing(f, 9, remapRegularCorner, iptrs[0].C[0]);
iptrs[0].C[0]+=9;
pptrs[0].C[0] = computePatchParam(f, pptrs[0].C[0]);
fptrs[0].C[0] = computeFVarData(f, fvarwidth, fptrs[0].C[0], /*isAdaptive=*/true);
} break;
default : assert(0);
}
}
} else if (f->_adaptiveFlags.patchType==HbrFace<T>::kGregory) {
if (f->_adaptiveFlags.bverts==0) {
// Gregory Regular Patch (4 CVs + quad-offsets / valence tables)
for (int j=0; j<4; ++j)
iptrs[0].G[0][j] = _remapTable[f->GetVertex(j)->GetID()];
iptrs[0].G[0]+=4;
getQuadOffsets(f, quad_G_C0_P);
quad_G_C0_P += 4;
pptrs[0].G[0] = computePatchParam(f, pptrs[0].G[0]);
fptrs[0].G[0] = computeFVarData(f, fvarwidth, fptrs[0].G[0], /*isAdaptive=*/true);
} else {
// Gregory Boundary Patch (4 CVs + quad-offsets / valence tables)
for (int j=0; j<4; ++j)
iptrs[0].G[1][j] = _remapTable[f->GetVertex(j)->GetID()];
iptrs[0].G[1]+=4;
getQuadOffsets(f, quad_G_C1_P);
quad_G_C1_P += 4;
pptrs[0].G[1] = computePatchParam(f, pptrs[0].G[1]);
fptrs[0].G[1] = computeFVarData(f, fvarwidth, fptrs[0].G[1], /*isAdaptive=*/true);
}
} else {
// XXXX manuelk - end patches here
}
} else {
// Transition patches
int tcase = f->_adaptiveFlags.transitionType;
assert( tcase>=HbrFace<T>::kTransition0 and tcase<=HbrFace<T>::kTransition4 );
++tcase; // TransitionPattern begin with NON_TRANSITION
if (not f->_adaptiveFlags.isExtraordinary and f->_adaptiveFlags.bverts!=1) {
switch (f->_adaptiveFlags.bverts) {
case 0 : { // Regular Transition Patch (16 CVs)
getOneRing(f, 16, remapRegular, iptrs[tcase].R);
iptrs[tcase].R+=16;
pptrs[tcase].R = computePatchParam(f, pptrs[tcase].R);
fptrs[tcase].R = computeFVarData(f, fvarwidth, fptrs[tcase].R, /*isAdaptive=*/true);
} break;
case 2 : { // Boundary Transition Patch (12 CVs)
unsigned rot = f->_adaptiveFlags.brots;
getOneRing(f, 12, remapRegularBoundary, iptrs[tcase].B[rot]);
iptrs[tcase].B[rot]+=12;
pptrs[tcase].B[rot] = computePatchParam(f, pptrs[tcase].B[rot]);
fptrs[tcase].B[rot] = computeFVarData(f, fvarwidth, fptrs[tcase].B[rot], /*isAdaptive=*/true);
} break;
case 3 : { // Corner Transition Patch (9 CVs)
unsigned rot = f->_adaptiveFlags.brots;
getOneRing(f, 9, remapRegularCorner, iptrs[tcase].C[rot]);
iptrs[tcase].C[rot]+=9;
pptrs[tcase].C[rot] = computePatchParam(f, pptrs[tcase].C[rot]);
fptrs[tcase].C[rot] = computeFVarData(f, fvarwidth, fptrs[tcase].C[rot], /*isAdaptive=*/true);
} break;
}
} else
// No transition Gregory patches
assert(false);
}
}
// Build Gregory patches vertex valence indices table
if ((_patchCtr[0].G[0] > 0) or (_patchCtr[0].G[1] > 0)) {
// MAX_VALENCE is a property of hardware shaders and needs to be matched in OSD
const int perVertexValenceSize = 2*maxvalence + 1;
const int nverts = getMesh()->GetNumVertices();
FarPatchTables::VertexValenceTable & table = result->_vertexValenceTable;
table.resize(nverts * perVertexValenceSize);
class GatherNeighborsOperator : public HbrVertexOperator<T> {
public:
HbrVertex<T> * center;
FarPatchTables::VertexValenceTable & table;
int offset, valence;
std::vector<int> const & remap;
GatherNeighborsOperator(FarPatchTables::VertexValenceTable & itable, int ioffset, HbrVertex<T> * v, std::vector<int> const & iremap) :
center(v), table(itable), offset(ioffset), valence(0), remap(iremap) { }
// Operator iterates over neighbor vertices of v and accumulates
// pairs of indices the neighbor and diagonal vertices
//
// Regular case
// Boundary case
// o ------- o D3 o
// D0 N0 | |
// | | o ------- o D2 o
// | | D0 N0 | |
// | | | |
// o ------- o ------- o | |
// N1 | V | N3 | |
// | | o ------- o ------- o
// | | N1 V N2
// | |
// o o ------- o
// D1 N2 D2
//
virtual void operator() (HbrVertex<T> &v) {
table[offset++] = remap[v.GetID()];
HbrVertex<T> * diagonal=&v;
HbrHalfedge<T> * e = center->GetEdge(&v);
if ( e ) {
// If v is on a boundary, there may not be a diagonal vertex
diagonal = e->GetNext()->GetDestVertex();
}
//else {
// diagonal = v.GetQEONext( center );
//}
table[offset++] = remap[diagonal->GetID()];
++valence;
}
};
for (int i=0; i<nverts; ++i) {
HbrVertex<T> * v = getMesh()->GetVertex(i);
int outputVertexID = _remapTable[v->GetID()];
int offset = outputVertexID * perVertexValenceSize;
// feature adaptive refinement can generate un-connected face-vertices
// that have a valence of 0
if (not v->IsConnected()) {
assert( v->GetParentFace() );
table[offset] = 0;
continue;
}
// "offset+1" : the first table entry is the vertex valence, which
// is gathered by the operator (see note below)
GatherNeighborsOperator op( table, offset+1, v, _remapTable );
v->ApplyOperatorSurroundingVertices( op );
// Valence sign bit used to mark boundary vertices
table[offset] = v->OnBoundary() ? -op.valence : op.valence;
// Note : some topologies can cause v to be singular at certain
// levels of adaptive refinement, which prevents us from using
// the GetValence() function. Fortunately, the GatherNeighbors
// operator above just performed a similar traversal, so it is
// very convenient to use it to accumulate the actionable valence.
}
} else {
result->_vertexValenceTable.clear();
}
// Combine quad offset buffers
result->_quadOffsetTable.resize((_patchCtr[0].G[0]+_patchCtr[0].G[1])*4);
std::copy(quad_G_C0.begin(), quad_G_C0.end(), result->_quadOffsetTable.begin());
std::copy(quad_G_C1.begin(), quad_G_C1.end(), result->_quadOffsetTable.begin()+_patchCtr[0].G[0]*4);
return result;
}
// The One Ring vertices to rule them all !
template <class T> void
FarPatchTablesFactory<T>::getOneRing( HbrFace<T> * f, int ringsize, unsigned int const * remap, unsigned int * result) {
assert( f and f->GetNumVertices()==4 and ringsize >=4 );
int idx=0;
for (unsigned char i=0; i<4; ++i)
result[remap[idx++ % ringsize]] = _remapTable[f->GetVertex( (i+f->_adaptiveFlags.rots)%4 )->GetID()];
if (ringsize==16) {
// Regular case
//
// | | | |
// | 4 | 15 | 14 | 13
// ---- o ---- o ---- o ---- o ----
// | | | |
// | 5 | 0 | 3 | 12
// ---- o ---- o ---- o ---- o ----
// | | | |
// | 6 | 1 | 2 | 11
// ---- o ---- o ---- o ---- o ----
// | | | |
// | 7 | 8 | 9 | 10
// ---- o ---- o ---- o ---- o ----
// | | | |
// | | | |
for (int i=0; i<4; ++i) {
int rot = i+f->_adaptiveFlags.rots;
HbrVertex<T> * v0 = f->GetVertex( rot % 4 ),
* v1 = f->GetVertex( (rot+1) % 4 );
HbrHalfedge<T> * e = v0->GetNextEdge( v0->GetNextEdge( v0->GetEdge(v1) ) );
for (int j=0; j<3; ++j) {
e = e->GetNext();
result[remap[idx++ % ringsize]] = _remapTable[e->GetOrgVertex()->GetID()];
}
}
} else if (ringsize==12) {
// Boundary case
//
// 4 0 3 5
// ---- o ---- o ---- o ---- o ----
// | | | |
// | 11 | 1 | 2 | 6
// ---- o ---- o ---- o ---- o ----
// | | | |
// | 10 | 9 | 8 | 7
// ---- o ---- o ---- o ---- o ----
// | | | |
// | | | |
HbrVertex<T> * v[4];
for (int i=0; i<4; ++i)
v[i] = f->GetVertex( (i+f->_adaptiveFlags.rots)%4 );
HbrHalfedge<T> * e;
e = v[0]->GetIncidentEdge()->GetPrev()->GetOpposite()->GetPrev();
result[remap[idx++ % ringsize]] = _remapTable[e->GetOrgVertex()->GetID()];
e = v[1]->GetIncidentEdge();
result[remap[idx++ % ringsize]] = _remapTable[e->GetDestVertex()->GetID()];
e = v[2]->GetNextEdge( v[2]->GetEdge(v[1]) );
for (int i=0; i<3; ++i) {
e = e->GetNext();
result[remap[idx++ % ringsize]] = _remapTable[e->GetOrgVertex()->GetID()];
}
e = v[3]->GetNextEdge( v[3]->GetEdge(v[2]) );
for (int i=0; i<3; ++i) {
e = e->GetNext();
result[remap[idx++ % ringsize]] = _remapTable[e->GetOrgVertex()->GetID()];
}
} else if (ringsize==9) {
// Corner case
//
// 0 1 4
// o ---- o ---- o ----
// | | |
// | 3 | 2 | 5
// o ---- o ---- o ----
// | | |
// | 8 | 7 | 6
// o ---- o ---- o ----
// | | |
// | | |
HbrVertex<T> * v0 = f->GetVertex( (0+f->_adaptiveFlags.rots)%4 ),
* v2 = f->GetVertex( (2+f->_adaptiveFlags.rots)%4 ),
* v3 = f->GetVertex( (3+f->_adaptiveFlags.rots)%4 );
HbrHalfedge<T> * e;
e = v0->GetIncidentEdge()->GetPrev()->GetOpposite()->GetPrev();
result[remap[idx++ % ringsize]] = _remapTable[e->GetOrgVertex()->GetID()];
e = v2->GetIncidentEdge();
result[remap[idx++ % ringsize]] = _remapTable[e->GetDestVertex()->GetID()];
e = v3->GetNextEdge( v3->GetEdge(v2) );
for (int i=0; i<3; ++i) {
e = e->GetNext();
result[remap[idx++ % ringsize]] = _remapTable[e->GetOrgVertex()->GetID()];
}
}
assert(idx==ringsize);
}
// Populate the quad-offsets table used by Gregory patches
template <class T> void
FarPatchTablesFactory<T>::getQuadOffsets( HbrFace<T> * f, unsigned int * result ) {
assert( f and f->GetNumVertices()==4 );
// Builds a table of value pairs for each vertex of the patch.
//
// o
// N0 |
// |
// |
// o ------ o ------ o
// N1 V | .... M3
// | .......
// | .......
// o .......
// N2
//
// [...] [N2 - N3] [...]
//
// Each value pair is composed of 2 index values in range [0-4[ pointing
// to the 2 neighbor vertices to the vertex that belong to the Gregory patch.
// Neighbor ordering is valence counter-clockwise and must match the winding
// used to build the vertexValenceTable.
//
class GatherOffsetsOperator : public HbrVertexOperator<T> {
public:
HbrVertex<T> ** verts; int offsets[2]; int index; int count;
GatherOffsetsOperator(HbrVertex<T> ** iverts) : verts(iverts) { }
void reset() {
index=count=offsets[0]=offsets[1]=0;
}
virtual void operator() (HbrVertex<T> &v) {
// Resolve which 2 neighbor vertices of v belong to the Gregory patch
for (unsigned char i=0; i<4; ++i)
if (&v==verts[i]) {
assert(count<3);
offsets[count++]=index;
break;
}
++index;
}
};
// 4 central CVs of the Gregory patch
HbrVertex<T> * fvs[4] = { f->GetVertex(0),
f->GetVertex(1),
f->GetVertex(2),
f->GetVertex(3) };
// Hbr vertex operator that iterates over neighbor vertices
GatherOffsetsOperator op( fvs );
for (unsigned char i=0; i<4; ++i) {
op.reset();
fvs[i]->ApplyOperatorSurroundingVertices( op );
if (op.offsets[1] - op.offsets[0] != 1)
std::swap(op.offsets[0], op.offsets[1]);
// Pack the 2 indices in 16 bits
result[i] = (op.offsets[0] | (op.offsets[1] << 8));
}
}
} // end namespace OPENSUBDIV_VERSION
using namespace OPENSUBDIV_VERSION;
} // end namespace OpenSubdiv
#endif /* FAR_PATCH_TABLES_FACTORY_H */
Reference in New Issue View Git Blame Copy Permalink