mirror of
https://github.com/PixarAnimationStudios/OpenSubdiv
synced 2024-11-25 13:00:07 +00:00
21adceb4ec
* added public functions to `FarMeshFactory` that duplicate, rearrange, and split vertices * added supporting protected functions to `FarCatmarkSubdivisionTablesFactory` and `FarPatchTablesFactory`
1092 lines
45 KiB
C++
1092 lines
45 KiB
C++
//
|
|
// Copyright 2013 Pixar
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "Apache License")
|
|
// with the following modification; you may not use this file except in
|
|
// compliance with the Apache License and the following modification to it:
|
|
// Section 6. Trademarks. is 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 to comply with Section 4(c) of
|
|
// the License and to reproduce the content of the NOTICE file.
|
|
//
|
|
// You may obtain a copy of the Apache License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the Apache License with the above modification is
|
|
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
// KIND, either express or implied. See the Apache License for the specific
|
|
// language governing permissions and limitations under the Apache License.
|
|
//
|
|
|
|
#ifndef FAR_CATMARK_SUBDIVISION_TABLES_FACTORY_H
|
|
#define FAR_CATMARK_SUBDIVISION_TABLES_FACTORY_H
|
|
|
|
#include <cassert>
|
|
#include <map>
|
|
#include <vector>
|
|
|
|
#include "../version.h"
|
|
|
|
#include "../far/subdivisionTables.h"
|
|
#include "../far/meshFactory.h"
|
|
#include "../far/kernelBatchFactory.h"
|
|
#include "../far/subdivisionTablesFactory.h"
|
|
|
|
namespace OpenSubdiv {
|
|
namespace OPENSUBDIV_VERSION {
|
|
|
|
template <class T, class U> class FarMeshFactory;
|
|
|
|
/// \brief A specialized factory for catmark FarSubdivisionTables
|
|
///
|
|
/// Separating the factory allows us to isolate Far data structures from Hbr dependencies.
|
|
///
|
|
template <class T, class U> class FarCatmarkSubdivisionTablesFactory {
|
|
protected:
|
|
template <class X, class Y> friend class FarMeshFactory;
|
|
|
|
typedef std::vector<unsigned int> VertexList;
|
|
typedef std::map<unsigned int, unsigned int> VertexPermutation;
|
|
|
|
/// \brief Creates a FarSubdivisiontables instance with Catmark scheme.
|
|
///
|
|
/// @param meshFactory a valid FarMeshFactory instance
|
|
///
|
|
/// @param batches a vector of Kernel refinement batches : the factory
|
|
/// will reserve and append refinement tasks
|
|
///
|
|
static FarSubdivisionTables * Create( FarMeshFactory<T,U> * meshFactory, FarKernelBatchVector *batches );
|
|
|
|
// Compares vertices based on their topological configuration
|
|
// (see subdivisionTables::GetMaskRanking for more details)
|
|
static bool CompareVertices( HbrVertex<T> const *x, HbrVertex<T> const *y );
|
|
|
|
/// \brief Duplicates vertices in a kernel batch
|
|
///
|
|
/// @param subdivisionTables the subdivision tables to modify
|
|
///
|
|
/// @param kernelBatch kernel batch at the finest subdivision level
|
|
///
|
|
/// @param vertexList the list of vertices to duplicate
|
|
///
|
|
static void DuplicateVertices( FarSubdivisionTables * subdivisionTables,
|
|
FarKernelBatch &kernelBatch,
|
|
VertexList const &vertexList );
|
|
|
|
/// \brief Rearranges vertices in a kernel batch to process them in a
|
|
/// \brief specific order
|
|
///
|
|
/// @param subdivisionTables the subdivision tables to modify
|
|
///
|
|
/// @param kernelBatch the kernel batch
|
|
///
|
|
/// @param vertexPermutation permutation of the vertices
|
|
///
|
|
static bool PermuteVertices( FarSubdivisionTables * subdivisionTables,
|
|
FarKernelBatch const &kernelBatch,
|
|
VertexPermutation const &vertexPermutation );
|
|
|
|
/// \brief Remaps the vertices in a kernel batch
|
|
///
|
|
/// @param subdivisionTables the subdivision tables to modify
|
|
///
|
|
/// @param kernelBatch the kernel batch
|
|
///
|
|
/// @param vertexPermutation permutation of the vertices
|
|
///
|
|
static void RemapVertices( FarSubdivisionTables * subdivisionTables,
|
|
FarKernelBatch const &kernelBatch,
|
|
VertexPermutation const& vertexPermutation);
|
|
|
|
/// \brief Shifts the vertices in a kernel batch
|
|
///
|
|
/// @param subdivisionTables the subdivision tables to modify
|
|
///
|
|
/// @param kernelBatch the kernel batch
|
|
///
|
|
/// @param expandedKernelBatch the kernel batch whose range was expanded
|
|
///
|
|
/// @param numVertices the number of vertices to shift
|
|
///
|
|
static void ShiftVertices( FarSubdivisionTables * subdivisionTables,
|
|
FarKernelBatch &kernelBatch,
|
|
FarKernelBatch const &expandedKernelBatch,
|
|
int numVertices );
|
|
|
|
private:
|
|
/// \brief Duplicates vertices in an edge-vertex kernel batch
|
|
static void duplicateEdgeVertexKernelBatch( FarSubdivisionTables * subdivisionTables,
|
|
FarKernelBatch &kernelBatch,
|
|
VertexList const &vertexList );
|
|
|
|
/// \brief Duplicates vertices in a vertex-vertex kernel batch
|
|
static void duplicateVertexVertexKernelBatch( FarSubdivisionTables * subdivisionTables,
|
|
FarKernelBatch &kernelBatch,
|
|
VertexList const &vertexList );
|
|
|
|
/// \brief Rearranges vertices in an edge-vertex kernel batch
|
|
static void permuteEdgeVertexKernelBatch( FarSubdivisionTables * subdivisionTables,
|
|
FarKernelBatch const &kernelBatch,
|
|
VertexPermutation const &inversePermutation );
|
|
|
|
/// \brief Rearranges vertices in a face-vertex kernel batch
|
|
static void permuteFaceVertexKernelBatch( FarSubdivisionTables * subdivisionTables,
|
|
FarKernelBatch const &kernelBatch,
|
|
VertexPermutation const &inversePermutation );
|
|
|
|
/// \brief Rearranges vertices in a vertex-vertex kernel batch
|
|
static void permuteVertexVertexKernelBatch( FarSubdivisionTables * subdivisionTables,
|
|
FarKernelBatch const &kernelBatch,
|
|
VertexPermutation const &inversePermutation );
|
|
|
|
/// \brief Remaps a vertex index
|
|
static void remapVertex( VertexPermutation const& vertexPermutation, int& vertex );
|
|
|
|
/// \brief Remaps a vertex index
|
|
static void remapVertex( VertexPermutation const& vertexPermutation, unsigned int& vertex );
|
|
};
|
|
|
|
// This factory walks the Hbr vertices and accumulates the weights and adjacency
|
|
// (valance) information specific to the catmark subdivision scheme. The results
|
|
// are stored in a FarSubdivisionTable.
|
|
template <class T, class U> FarSubdivisionTables *
|
|
FarCatmarkSubdivisionTablesFactory<T,U>::Create( FarMeshFactory<T,U> * meshFactory, FarKernelBatchVector *batches ) {
|
|
|
|
assert( meshFactory );
|
|
|
|
int maxlevel = meshFactory->GetMaxLevel();
|
|
|
|
std::vector<int> & remap = meshFactory->getRemappingTable();
|
|
|
|
FarSubdivisionTablesFactory<T,U> tablesFactory( meshFactory->GetHbrMesh(), maxlevel, remap, CompareVertices );
|
|
|
|
FarSubdivisionTables * result = new FarSubdivisionTables(maxlevel, FarSubdivisionTables::CATMARK);
|
|
|
|
// Calculate the size of the face-vertex indexing tables
|
|
int minCoarseFaceValence = tablesFactory.GetMinCoarseFaceValence();
|
|
int maxCoarseFaceValence = tablesFactory.GetMaxCoarseFaceValence();
|
|
bool coarseMeshAllQuadFaces = minCoarseFaceValence == 4 and maxCoarseFaceValence == 4;
|
|
bool coarseMeshAllTriQuadFaces = minCoarseFaceValence >= 3 and maxCoarseFaceValence <= 4;
|
|
bool hasQuadFaceVertexKernel = meshFactory->IsKernelTypeSupported(FarKernelBatch::CATMARK_QUAD_FACE_VERTEX);
|
|
bool hasTriQuadFaceVertexKernel = meshFactory->IsKernelTypeSupported(FarKernelBatch::CATMARK_TRI_QUAD_FACE_VERTEX);
|
|
|
|
int F_ITa_size = 0;
|
|
if (not hasQuadFaceVertexKernel and not hasTriQuadFaceVertexKernel)
|
|
F_ITa_size = tablesFactory.GetNumFaceVerticesTotal(maxlevel) * 2;
|
|
else if (not coarseMeshAllTriQuadFaces or not hasTriQuadFaceVertexKernel)
|
|
F_ITa_size = tablesFactory.GetNumFaceVerticesTotal(1) * 2;
|
|
|
|
int F_IT_size = tablesFactory.GetFaceVertsValenceSum();
|
|
if (coarseMeshAllTriQuadFaces and hasTriQuadFaceVertexKernel)
|
|
F_IT_size += tablesFactory.GetNumCoarseTriangleFaces(); // add padding for tri faces
|
|
|
|
// Triangular interpolation mode :
|
|
// see "smoothtriangle" tag introduced in prman 3.9 and HbrCatmarkSubdivision<T>
|
|
typename HbrCatmarkSubdivision<T>::TriangleSubdivision triangleMethod =
|
|
dynamic_cast<HbrCatmarkSubdivision<T> *>(meshFactory->GetHbrMesh()->GetSubdivision())->GetTriangleSubdivisionMethod();
|
|
bool hasFractionalEdgeSharpness = tablesFactory.HasFractionalEdgeSharpness();
|
|
bool useRestrictedEdgeVertexKernel = meshFactory->IsKernelTypeSupported(FarKernelBatch::CATMARK_RESTRICTED_EDGE_VERTEX);
|
|
useRestrictedEdgeVertexKernel &= not hasFractionalEdgeSharpness and triangleMethod != HbrCatmarkSubdivision<T>::k_New;
|
|
|
|
bool hasFractionalVertexSharpness = tablesFactory.HasFractionalVertexSharpness();
|
|
bool hasStandardVertexVertexKernels = meshFactory->IsKernelTypeSupported(FarKernelBatch::CATMARK_VERT_VERTEX_A1) and
|
|
meshFactory->IsKernelTypeSupported(FarKernelBatch::CATMARK_VERT_VERTEX_A2) and
|
|
meshFactory->IsKernelTypeSupported(FarKernelBatch::CATMARK_VERT_VERTEX_B);
|
|
bool useRestrictedVertexVertexKernels = meshFactory->IsKernelTypeSupported(FarKernelBatch::CATMARK_RESTRICTED_VERT_VERTEX_A) and
|
|
meshFactory->IsKernelTypeSupported(FarKernelBatch::CATMARK_RESTRICTED_VERT_VERTEX_B1) and
|
|
meshFactory->IsKernelTypeSupported(FarKernelBatch::CATMARK_RESTRICTED_VERT_VERTEX_B2);
|
|
useRestrictedVertexVertexKernels &= not hasFractionalVertexSharpness and not hasFractionalEdgeSharpness;
|
|
|
|
// Allocate memory for the indexing tables
|
|
result->_F_ITa.resize(F_ITa_size);
|
|
result->_F_IT.resize(F_IT_size);
|
|
|
|
result->_E_IT.resize(tablesFactory.GetNumEdgeVerticesTotal(maxlevel)*4);
|
|
if (not useRestrictedEdgeVertexKernel)
|
|
result->_E_W.resize(tablesFactory.GetNumEdgeVerticesTotal(maxlevel)*2);
|
|
|
|
result->_V_ITa.resize((tablesFactory.GetNumVertexVerticesTotal(maxlevel)
|
|
- tablesFactory.GetNumVertexVerticesTotal(0))*5); // subtract coarse cage vertices
|
|
result->_V_IT.resize(tablesFactory.GetVertVertsValenceSum()*2);
|
|
if (not useRestrictedVertexVertexKernels)
|
|
result->_V_W.resize(tablesFactory.GetNumVertexVerticesTotal(maxlevel)
|
|
- tablesFactory.GetNumVertexVerticesTotal(0));
|
|
|
|
// Prepare batch table
|
|
batches->reserve(maxlevel*5);
|
|
|
|
int vertexOffset = 0;
|
|
int F_IT_offset = 0;
|
|
int V_IT_offset = 0;
|
|
int faceTableOffset = 0;
|
|
int edgeTableOffset = 0;
|
|
int vertTableOffset = 0;
|
|
|
|
unsigned int * F_IT = result->_F_IT.empty() ? 0 : &result->_F_IT[0];
|
|
int * F_ITa = result->_F_ITa.empty() ? 0 : &result->_F_ITa[0];
|
|
int * E_IT = result->_E_IT.empty() ? 0 : &result->_E_IT[0];
|
|
float * E_W = result->_E_W.empty() ? 0 : &result->_E_W[0];
|
|
int * V_ITa = result->_V_ITa.empty() ? 0 : &result->_V_ITa[0];
|
|
unsigned int * V_IT = result->_V_IT.empty() ? 0 : &result->_V_IT[0];
|
|
float * V_W = result->_V_W.empty() ? 0 : &result->_V_W[0];
|
|
|
|
for (int level=1; level<=maxlevel; ++level) {
|
|
|
|
// pointer to the first vertex corresponding to this level
|
|
vertexOffset = tablesFactory._faceVertIdx[level];
|
|
result->_vertsOffsets[level] = vertexOffset;
|
|
|
|
// Face vertices
|
|
// "For each vertex, gather all the vertices from the parent face."
|
|
int nFaceVertices = (int)tablesFactory._faceVertsList[level].size();
|
|
|
|
// choose the kernel type that best fits the face topology
|
|
int kernelType = FarKernelBatch::CATMARK_FACE_VERTEX;
|
|
if (level == 1) {
|
|
if (coarseMeshAllQuadFaces and hasQuadFaceVertexKernel)
|
|
kernelType = FarKernelBatch::CATMARK_QUAD_FACE_VERTEX;
|
|
else if (coarseMeshAllTriQuadFaces and hasTriQuadFaceVertexKernel)
|
|
kernelType = FarKernelBatch::CATMARK_TRI_QUAD_FACE_VERTEX;
|
|
} else {
|
|
if (hasQuadFaceVertexKernel)
|
|
kernelType = FarKernelBatch::CATMARK_QUAD_FACE_VERTEX;
|
|
if (hasTriQuadFaceVertexKernel)
|
|
kernelType = FarKernelBatch::CATMARK_TRI_QUAD_FACE_VERTEX;
|
|
}
|
|
|
|
// add a batch for face vertices
|
|
if (nFaceVertices > 0) { // in torus case, nfacevertices could be zero
|
|
assert(meshFactory->IsKernelTypeSupported(kernelType));
|
|
if (kernelType == FarKernelBatch::CATMARK_FACE_VERTEX) {
|
|
batches->push_back(FarKernelBatch( kernelType,
|
|
level,
|
|
0,
|
|
0,
|
|
nFaceVertices,
|
|
faceTableOffset,
|
|
vertexOffset) );
|
|
} else {
|
|
// quad and tri-quad kernels store the offset of the first vertex in the table offset
|
|
batches->push_back(FarKernelBatch( kernelType,
|
|
level,
|
|
0,
|
|
0,
|
|
nFaceVertices,
|
|
F_IT_offset,
|
|
vertexOffset) );
|
|
}
|
|
}
|
|
|
|
vertexOffset += nFaceVertices;
|
|
if (kernelType == FarKernelBatch::CATMARK_FACE_VERTEX)
|
|
faceTableOffset += nFaceVertices;
|
|
|
|
for (int i=0; i < nFaceVertices; ++i) {
|
|
|
|
HbrVertex<T> * v = tablesFactory._faceVertsList[level][i];
|
|
assert(v);
|
|
|
|
HbrFace<T> * f=v->GetParentFace();
|
|
assert(f);
|
|
|
|
int valence = f->GetNumVertices();
|
|
|
|
if (kernelType == FarKernelBatch::CATMARK_FACE_VERTEX) {
|
|
*F_ITa++ = F_IT_offset;
|
|
*F_ITa++ = valence;
|
|
}
|
|
|
|
for (int j=0; j<valence; ++j)
|
|
F_IT[F_IT_offset++] = remap[f->GetVertex(j)->GetID()];
|
|
|
|
if (kernelType == FarKernelBatch::CATMARK_TRI_QUAD_FACE_VERTEX and valence == 3)
|
|
F_IT[F_IT_offset++] = remap[f->GetVertex(2)->GetID()]; // repeat last index
|
|
}
|
|
|
|
// Edge vertices
|
|
|
|
// "For each vertex, gather the 2 vertices from the parent edege and the
|
|
// 2 child vertices from the faces to the left and right of that edge.
|
|
// Adjust if edge has a crease or is on a boundary."
|
|
int nEdgeVertices = (int)tablesFactory._edgeVertsList[level].size();
|
|
|
|
// add a batch for edge vertices
|
|
kernelType = (useRestrictedEdgeVertexKernel ?
|
|
FarKernelBatch::CATMARK_RESTRICTED_EDGE_VERTEX :
|
|
FarKernelBatch::CATMARK_EDGE_VERTEX);
|
|
|
|
if (nEdgeVertices > 0) {
|
|
assert(meshFactory->IsKernelTypeSupported(kernelType));
|
|
batches->push_back(FarKernelBatch( kernelType,
|
|
level,
|
|
0,
|
|
0,
|
|
nEdgeVertices,
|
|
edgeTableOffset,
|
|
vertexOffset) );
|
|
}
|
|
|
|
vertexOffset += nEdgeVertices;
|
|
edgeTableOffset += nEdgeVertices;
|
|
|
|
for (int i=0; i < nEdgeVertices; ++i) {
|
|
|
|
HbrVertex<T> * v = tablesFactory._edgeVertsList[level][i];
|
|
assert(v);
|
|
HbrHalfedge<T> * e = v->GetParentEdge();
|
|
assert(e);
|
|
|
|
float esharp = e->GetSharpness();
|
|
|
|
// get the indices 2 vertices from the parent edge
|
|
E_IT[4*i+0] = remap[e->GetOrgVertex()->GetID()];
|
|
E_IT[4*i+1] = remap[e->GetDestVertex()->GetID()];
|
|
|
|
float faceWeight=0.5f, vertWeight=0.5f;
|
|
|
|
if (kernelType == FarKernelBatch::CATMARK_RESTRICTED_EDGE_VERTEX) {
|
|
// in the case of a sharp edge, repeat the endpoint vertices
|
|
if (not e->IsBoundary() and esharp == HbrHalfedge<T>::k_Smooth) {
|
|
HbrFace<T>* rf = e->GetRightFace();
|
|
HbrFace<T>* lf = e->GetLeftFace();
|
|
|
|
E_IT[4*i+2] = remap[lf->Subdivide()->GetID()];
|
|
E_IT[4*i+3] = remap[rf->Subdivide()->GetID()];
|
|
} else {
|
|
E_IT[4*i+2] = E_IT[4*i+0];
|
|
E_IT[4*i+3] = E_IT[4*i+1];
|
|
}
|
|
} else if (not e->IsBoundary() and esharp <= HbrHalfedge<T>::k_Sharp) {
|
|
// in the case of a fractional sharpness, set the adjacent faces vertices
|
|
|
|
float leftWeight, rightWeight;
|
|
HbrFace<T>* rf = e->GetRightFace();
|
|
HbrFace<T>* lf = e->GetLeftFace();
|
|
|
|
leftWeight = ( triangleMethod == HbrCatmarkSubdivision<T>::k_New && lf->GetNumVertices() == 3) ? HBR_SMOOTH_TRI_EDGE_WEIGHT : 0.25f;
|
|
rightWeight = ( triangleMethod == HbrCatmarkSubdivision<T>::k_New && rf->GetNumVertices() == 3) ? HBR_SMOOTH_TRI_EDGE_WEIGHT : 0.25f;
|
|
|
|
faceWeight = 0.5f * (leftWeight + rightWeight);
|
|
vertWeight = 0.5f * (1.0f - 2.0f * faceWeight);
|
|
|
|
faceWeight *= (1.0f - esharp);
|
|
|
|
vertWeight = 0.5f * esharp + (1.0f - esharp) * vertWeight;
|
|
|
|
E_IT[4*i+2] = remap[lf->Subdivide()->GetID()];
|
|
E_IT[4*i+3] = remap[rf->Subdivide()->GetID()];
|
|
} else {
|
|
E_IT[4*i+2] = -1;
|
|
E_IT[4*i+3] = -1;
|
|
}
|
|
if (kernelType == FarKernelBatch::CATMARK_EDGE_VERTEX) {
|
|
E_W[2*i+0] = vertWeight;
|
|
E_W[2*i+1] = faceWeight;
|
|
}
|
|
}
|
|
E_IT += 4 * nEdgeVertices;
|
|
if (kernelType == FarKernelBatch::CATMARK_EDGE_VERTEX)
|
|
E_W += 2 * nEdgeVertices;
|
|
|
|
// Vertex vertices
|
|
|
|
FarVertexKernelBatchFactory batchFactory((int)tablesFactory._vertVertsList[level].size(), 0);
|
|
|
|
int nVertVertices = (int)tablesFactory._vertVertsList[level].size();
|
|
for (int i=0; i < nVertVertices; ++i) {
|
|
|
|
HbrVertex<T> * v = tablesFactory._vertVertsList[level][i],
|
|
* pv = v->GetParentVertex();
|
|
assert(v and pv);
|
|
|
|
// Look at HbrCatmarkSubdivision<T>::Subdivide for more details about
|
|
// the multi-pass interpolation
|
|
unsigned char masks[2];
|
|
int npasses;
|
|
float weights[2];
|
|
masks[0] = pv->GetMask(false);
|
|
masks[1] = pv->GetMask(true);
|
|
|
|
// If the masks are identical, only a single pass is necessary. If the
|
|
// vertex is transitioning to another rule, two passes are necessary,
|
|
// except when transitioning from k_Dart to k_Smooth : the same
|
|
// compute kernel is applied twice. Combining this special case allows
|
|
// to batch the compute kernels into fewer calls.
|
|
if (masks[0] != masks[1] and (
|
|
not (masks[0]==HbrVertex<T>::k_Smooth and
|
|
masks[1]==HbrVertex<T>::k_Dart))) {
|
|
weights[1] = pv->GetFractionalMask();
|
|
weights[0] = 1.0f - weights[1];
|
|
npasses = 2;
|
|
} else {
|
|
weights[0] = 1.0f;
|
|
weights[1] = 0.0f;
|
|
npasses = 1;
|
|
}
|
|
|
|
int rank = FarSubdivisionTablesFactory<T,U>::GetMaskRanking(masks[0], masks[1]);
|
|
|
|
V_ITa[5*i+0] = V_IT_offset;
|
|
V_ITa[5*i+1] = 0;
|
|
V_ITa[5*i+2] = remap[ pv->GetID() ];
|
|
V_ITa[5*i+3] = -1;
|
|
V_ITa[5*i+4] = -1;
|
|
|
|
for (int p=0; p<npasses; ++p)
|
|
switch (masks[p]) {
|
|
case HbrVertex<T>::k_Smooth :
|
|
case HbrVertex<T>::k_Dart : {
|
|
HbrHalfedge<T> *e = pv->GetIncidentEdge(),
|
|
*start = e;
|
|
while (e) {
|
|
V_ITa[5*i+1]++;
|
|
|
|
V_IT[V_IT_offset++] = remap[ e->GetDestVertex()->GetID() ];
|
|
|
|
V_IT[V_IT_offset++] = remap[ e->GetLeftFace()->Subdivide()->GetID() ];
|
|
|
|
e = e->GetPrev()->GetOpposite();
|
|
|
|
if (e==start) break;
|
|
}
|
|
break;
|
|
}
|
|
case HbrVertex<T>::k_Crease : {
|
|
|
|
class GatherCreaseEdgesOperator : public HbrHalfedgeOperator<T> {
|
|
public:
|
|
HbrVertex<T> * vertex; int eidx[2]; int count; bool next;
|
|
|
|
GatherCreaseEdgesOperator(HbrVertex<T> * vtx, bool n) : vertex(vtx), count(0), next(n) { eidx[0]=-1; eidx[1]=-1; }
|
|
|
|
~GatherCreaseEdgesOperator() { }
|
|
|
|
virtual void operator() (HbrHalfedge<T> &e) {
|
|
if (e.IsSharp(next) and count < 2) {
|
|
HbrVertex<T> * a = e.GetDestVertex();
|
|
if (a==vertex)
|
|
a = e.GetOrgVertex();
|
|
eidx[count++]=a->GetID();
|
|
}
|
|
}
|
|
};
|
|
|
|
GatherCreaseEdgesOperator op( pv, p==1 );
|
|
pv->ApplyOperatorSurroundingEdges( op );
|
|
|
|
assert(V_ITa[5*i+3]==-1 and V_ITa[5*i+4]==-1);
|
|
assert(op.eidx[0]!=-1 and op.eidx[1]!=-1);
|
|
V_ITa[5*i+3] = remap[op.eidx[0]];
|
|
V_ITa[5*i+4] = remap[op.eidx[1]];
|
|
break;
|
|
}
|
|
case HbrVertex<T>::k_Corner :
|
|
if (not useRestrictedVertexVertexKernels) {
|
|
// in the case of a k_Crease / k_Corner pass combination, we
|
|
// need to set the valence to -1 to tell the "B" Kernel to
|
|
// switch to k_Corner rule (as edge indices won't be -1)
|
|
if (V_ITa[5*i+1]==0)
|
|
V_ITa[5*i+1] = -1;
|
|
} else {
|
|
// in the case of a k_Corner, repeat the vertex
|
|
V_ITa[5*i+3] = V_ITa[5*i+2];
|
|
V_ITa[5*i+4] = V_ITa[5*i+2];
|
|
}
|
|
|
|
default : break;
|
|
}
|
|
|
|
if (not useRestrictedVertexVertexKernels) {
|
|
if (rank>7)
|
|
// the k_Corner and k_Crease single-pass cases apply a weight of 1.0
|
|
// but this value is inverted in the kernel
|
|
V_W[i] = 0.0;
|
|
else
|
|
V_W[i] = weights[0];
|
|
}
|
|
|
|
if (not useRestrictedVertexVertexKernels)
|
|
batchFactory.AddVertex( i, rank );
|
|
else
|
|
batchFactory.AddCatmarkRestrictedVertex( i, rank, V_ITa[5*i+1] );
|
|
}
|
|
V_ITa += nVertVertices*5;
|
|
if (not useRestrictedVertexVertexKernels)
|
|
V_W += nVertVertices;
|
|
|
|
// add batches for vert vertices
|
|
if (nVertVertices > 0) {
|
|
if (not useRestrictedVertexVertexKernels) {
|
|
assert(hasStandardVertexVertexKernels);
|
|
batchFactory.AppendCatmarkBatches(level, vertTableOffset, vertexOffset, batches);
|
|
} else {
|
|
batchFactory.AppendCatmarkRestrictedBatches(level, vertTableOffset, vertexOffset, batches);
|
|
}
|
|
}
|
|
|
|
vertexOffset += nVertVertices;
|
|
vertTableOffset += nVertVertices;
|
|
}
|
|
result->_vertsOffsets[maxlevel+1] = vertexOffset;
|
|
return result;
|
|
}
|
|
|
|
template <class T, class U> bool
|
|
FarCatmarkSubdivisionTablesFactory<T,U>::CompareVertices( HbrVertex<T> const * x, HbrVertex<T> const * y ) {
|
|
|
|
// Masks of the parent vertex decide for the current vertex.
|
|
HbrVertex<T> * px=x->GetParentVertex(),
|
|
* py=y->GetParentVertex();
|
|
|
|
int rankx = FarSubdivisionTablesFactory<T,U>::GetMaskRanking(px->GetMask(false), px->GetMask(true) );
|
|
int ranky = FarSubdivisionTablesFactory<T,U>::GetMaskRanking(py->GetMask(false), py->GetMask(true) );
|
|
|
|
assert( rankx!=0xFF and ranky!=0xFF );
|
|
|
|
// Arrange regular vertices before irregular vertices within the same kernel
|
|
if ((rankx <= 2 and ranky <= 2) or (rankx >= 3 and rankx <= 7 and ranky >= 3 and ranky <= 7) or (rankx >= 8 and ranky >= 8))
|
|
return x->GetValence() == 4 and y->GetValence() != 4;
|
|
else
|
|
return rankx < ranky;
|
|
}
|
|
|
|
template <class T, class U> void
|
|
FarCatmarkSubdivisionTablesFactory<T, U>::DuplicateVertices(
|
|
FarSubdivisionTables * subdivisionTables,
|
|
FarKernelBatch &kernelBatch, VertexList const &vertexList )
|
|
{
|
|
switch (kernelBatch.GetKernelType()) {
|
|
case FarKernelBatch::CATMARK_EDGE_VERTEX:
|
|
case FarKernelBatch::CATMARK_RESTRICTED_EDGE_VERTEX:
|
|
duplicateEdgeVertexKernelBatch(subdivisionTables, kernelBatch,
|
|
vertexList);
|
|
break;
|
|
|
|
case FarKernelBatch::CATMARK_VERT_VERTEX_A1:
|
|
case FarKernelBatch::CATMARK_VERT_VERTEX_B:
|
|
case FarKernelBatch::CATMARK_RESTRICTED_VERT_VERTEX_A:
|
|
case FarKernelBatch::CATMARK_RESTRICTED_VERT_VERTEX_B1:
|
|
case FarKernelBatch::CATMARK_RESTRICTED_VERT_VERTEX_B2:
|
|
duplicateVertexVertexKernelBatch(subdivisionTables, kernelBatch,
|
|
vertexList);
|
|
break;
|
|
}
|
|
|
|
// Update the number of vertices in the subdivision tables.
|
|
subdivisionTables->_vertsOffsets.back() += (int)vertexList.size();
|
|
}
|
|
|
|
template <class T, class U> void
|
|
FarCatmarkSubdivisionTablesFactory<T, U>::duplicateEdgeVertexKernelBatch(
|
|
FarSubdivisionTables * subdivisionTables,
|
|
FarKernelBatch &kernelBatch, VertexList const &vertexList )
|
|
{
|
|
// Duplicate vertices in the edge vertices tables.
|
|
std::vector<int>& srcE_IT = subdivisionTables->_E_IT;
|
|
std::vector<float>& srcE_W = subdivisionTables->_E_W;
|
|
std::vector<int> dstE_IT;
|
|
std::vector<float> dstE_W;
|
|
|
|
int kernelBatchSize = kernelBatch.GetEnd() - kernelBatch.GetStart();
|
|
int tableOffset = kernelBatch.GetTableOffset();
|
|
int vertexOffset = kernelBatch.GetVertexOffset();
|
|
for (int i = 0; i < (int)vertexList.size(); ++i) {
|
|
int srcVertex = vertexList[i];
|
|
int srcTableOffset = tableOffset + srcVertex - vertexOffset;
|
|
|
|
for (int j = 0; j < 4; ++j) {
|
|
dstE_IT.push_back(srcE_IT[srcTableOffset * 4 + j]);
|
|
}
|
|
|
|
if ((int)srcE_W.size() > srcTableOffset) {
|
|
for (int j = 0; j < 2; ++j) {
|
|
dstE_W.push_back(srcE_W[srcTableOffset * 2 + j]);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Rewrite the edge-vertices tables.
|
|
srcE_IT.insert(srcE_IT.begin() + (tableOffset + kernelBatchSize) * 4,
|
|
dstE_IT.begin(), dstE_IT.end());
|
|
if (!dstE_W.empty()) {
|
|
srcE_W.insert(srcE_W.begin() + (tableOffset + kernelBatchSize) * 2,
|
|
dstE_W.begin(), dstE_W.end());
|
|
}
|
|
|
|
// Replace the kernel batch.
|
|
int numDuplicates = (int)vertexList.size();
|
|
kernelBatch = FarKernelBatch(kernelBatch.GetKernelType(),
|
|
kernelBatch.GetLevel(), kernelBatch.GetTableIndex(),
|
|
kernelBatch.GetStart(), kernelBatch.GetEnd() + numDuplicates,
|
|
kernelBatch.GetTableOffset(), kernelBatch.GetVertexOffset(),
|
|
kernelBatch.GetMeshIndex());
|
|
}
|
|
|
|
template <class T, class U> void
|
|
FarCatmarkSubdivisionTablesFactory<T, U>::duplicateVertexVertexKernelBatch(
|
|
FarSubdivisionTables * subdivisionTables,
|
|
FarKernelBatch &kernelBatch, VertexList const &vertexList )
|
|
{
|
|
// Duplicate vertices in the vertex-vertices tables.
|
|
std::vector<int>& srcV_ITa = subdivisionTables->_V_ITa;
|
|
std::vector<unsigned int>& srcV_IT = subdivisionTables->_V_IT;
|
|
std::vector<float>& srcV_W = subdivisionTables->_V_W;
|
|
std::vector<int> dstV_ITa;
|
|
std::vector<unsigned int> dstV_IT;
|
|
std::vector<float> dstV_W;
|
|
|
|
int kernelBatchEnd = kernelBatch.GetEnd();
|
|
int tableOffset = kernelBatch.GetTableOffset();
|
|
int vertexOffset = kernelBatch.GetVertexOffset();
|
|
int lastVertexOffset = srcV_ITa[(tableOffset + kernelBatchEnd - 1) * 5 + 0];
|
|
int lastValence = srcV_ITa[(tableOffset + kernelBatchEnd - 1) * 5 + 1];
|
|
int dstVertexOffset = lastVertexOffset + lastValence * 2;
|
|
for (int i = 0; i < (int)vertexList.size(); ++i) {
|
|
int srcVertex = vertexList[i];
|
|
int srcTableOffset = tableOffset + srcVertex - vertexOffset;
|
|
int srcVertexOffset = srcV_ITa[srcTableOffset * 5 + 0];
|
|
int valence = srcV_ITa[srcTableOffset * 5 + 1];
|
|
int parentVertex = srcV_ITa[srcTableOffset * 5 + 2];
|
|
int edgeVertex1 = srcV_ITa[srcTableOffset * 5 + 3];
|
|
int edgeVertex2 = srcV_ITa[srcTableOffset * 5 + 4];
|
|
|
|
dstV_ITa.push_back(dstVertexOffset);
|
|
dstV_ITa.push_back(valence);
|
|
dstV_ITa.push_back(parentVertex);
|
|
dstV_ITa.push_back(edgeVertex1);
|
|
dstV_ITa.push_back(edgeVertex2);
|
|
dstVertexOffset += valence * 2;
|
|
|
|
for (int j = 0; j < valence * 2; ++j) {
|
|
dstV_IT.push_back(srcV_IT[srcVertexOffset + j]);
|
|
}
|
|
|
|
if ((int)srcV_W.size() > srcTableOffset) {
|
|
dstV_W.push_back(srcV_W[srcTableOffset]);
|
|
}
|
|
}
|
|
|
|
// Rewrite the vertex-vertices tables.
|
|
srcV_ITa.insert(srcV_ITa.begin() + (tableOffset + kernelBatchEnd) * 5,
|
|
dstV_ITa.begin(), dstV_ITa.end());
|
|
srcV_IT.insert(srcV_IT.begin() + lastVertexOffset + lastValence * 2,
|
|
dstV_IT.begin(), dstV_IT.end());
|
|
if (!dstV_W.empty()) {
|
|
srcV_W.insert(srcV_W.begin() + tableOffset + kernelBatchEnd,
|
|
dstV_W.begin(), dstV_W.end());
|
|
}
|
|
|
|
// Replace the kernel batch.
|
|
int numDuplicates = (int)vertexList.size();
|
|
kernelBatch = FarKernelBatch(kernelBatch.GetKernelType(),
|
|
kernelBatch.GetLevel(), kernelBatch.GetTableIndex(),
|
|
kernelBatch.GetStart(), kernelBatch.GetEnd() + numDuplicates,
|
|
kernelBatch.GetTableOffset(), kernelBatch.GetVertexOffset(),
|
|
kernelBatch.GetMeshIndex());
|
|
}
|
|
|
|
template <class T, class U> bool
|
|
FarCatmarkSubdivisionTablesFactory<T, U>::PermuteVertices(
|
|
FarSubdivisionTables * subdivisionTables,
|
|
FarKernelBatch const &kernelBatch,
|
|
VertexPermutation const &vertexPermutation )
|
|
{
|
|
// Create the inverse permutation.
|
|
VertexPermutation inversePermutation;
|
|
int kernelBatchSize = kernelBatch.GetEnd() - kernelBatch.GetStart();
|
|
int vertexOffset = kernelBatch.GetVertexOffset();
|
|
int firstVertex = vertexOffset + kernelBatch.GetStart();
|
|
int lastVertex = vertexOffset + kernelBatch.GetEnd();
|
|
for (int i = 0; i < kernelBatchSize; ++i) {
|
|
unsigned int oldVertex = firstVertex + i;
|
|
VertexPermutation::const_iterator j = vertexPermutation.find(oldVertex);
|
|
if (j == vertexPermutation.end())
|
|
continue;
|
|
|
|
int newVertex = j->second;
|
|
|
|
// Guarantee that the inverse map is a permutation.
|
|
assert(newVertex >= firstVertex && newVertex < lastVertex);
|
|
assert(inversePermutation.count(newVertex) == 0);
|
|
|
|
inversePermutation[newVertex] = oldVertex;
|
|
}
|
|
|
|
if (inversePermutation.empty())
|
|
return false; // the vertices of the kernel batch are not permuted
|
|
|
|
// Guarantee that the inverse map is a bijection.
|
|
assert((int)inversePermutation.size() == kernelBatchSize);
|
|
|
|
switch (kernelBatch.GetKernelType()) {
|
|
case FarKernelBatch::CATMARK_EDGE_VERTEX:
|
|
case FarKernelBatch::CATMARK_RESTRICTED_EDGE_VERTEX:
|
|
permuteEdgeVertexKernelBatch(subdivisionTables, kernelBatch,
|
|
inversePermutation);
|
|
break;
|
|
|
|
case FarKernelBatch::CATMARK_FACE_VERTEX:
|
|
case FarKernelBatch::CATMARK_QUAD_FACE_VERTEX:
|
|
case FarKernelBatch::CATMARK_TRI_QUAD_FACE_VERTEX:
|
|
permuteFaceVertexKernelBatch(subdivisionTables, kernelBatch,
|
|
inversePermutation);
|
|
break;
|
|
|
|
case FarKernelBatch::CATMARK_VERT_VERTEX_A1:
|
|
case FarKernelBatch::CATMARK_VERT_VERTEX_B:
|
|
case FarKernelBatch::CATMARK_RESTRICTED_VERT_VERTEX_A:
|
|
case FarKernelBatch::CATMARK_RESTRICTED_VERT_VERTEX_B1:
|
|
case FarKernelBatch::CATMARK_RESTRICTED_VERT_VERTEX_B2:
|
|
permuteVertexVertexKernelBatch(subdivisionTables, kernelBatch,
|
|
inversePermutation);
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
template <class T, class U> void
|
|
FarCatmarkSubdivisionTablesFactory<T, U>::permuteEdgeVertexKernelBatch(
|
|
FarSubdivisionTables * subdivisionTables,
|
|
FarKernelBatch const &kernelBatch,
|
|
VertexPermutation const &inversePermutation )
|
|
{
|
|
std::vector<int>& oldE_IT = subdivisionTables->_E_IT;
|
|
std::vector<float>& oldE_W = subdivisionTables->_E_W;
|
|
std::vector<int> newE_IT;
|
|
std::vector<float> newE_W;
|
|
|
|
// Rearrange the edge-vertices tables.
|
|
int tableOffset = kernelBatch.GetTableOffset();
|
|
int vertexOffset = kernelBatch.GetVertexOffset();
|
|
for (int i = kernelBatch.GetStart(); i < kernelBatch.GetEnd(); ++i) {
|
|
int newVertex = i + vertexOffset;
|
|
int oldVertex = inversePermutation.find(newVertex)->second;
|
|
int oldTableOffset = tableOffset + oldVertex - vertexOffset;
|
|
|
|
for (int j = 0; j < 4; ++j) {
|
|
newE_IT.push_back(oldE_IT[oldTableOffset * 4 + j]);
|
|
}
|
|
|
|
if ((int)oldE_W.size() > oldTableOffset) {
|
|
for (int j = 0; j < 2; ++j) {
|
|
newE_W.push_back(oldE_W[oldTableOffset * 2 + j]);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Rewrite the edge-vertices tables.
|
|
std::copy(newE_IT.begin(), newE_IT.end(), oldE_IT.begin() +
|
|
tableOffset * 4);
|
|
if (!newE_W.empty()) {
|
|
std::copy(newE_W.begin(), newE_W.end(),
|
|
oldE_W.begin() + tableOffset * 2);
|
|
}
|
|
}
|
|
|
|
template <class T, class U> void
|
|
FarCatmarkSubdivisionTablesFactory<T, U>::permuteFaceVertexKernelBatch(
|
|
FarSubdivisionTables * subdivisionTables,
|
|
FarKernelBatch const &kernelBatch,
|
|
VertexPermutation const &inversePermutation )
|
|
{
|
|
bool isCatmarkFaceVertex = kernelBatch.GetKernelType() ==
|
|
FarKernelBatch::CATMARK_FACE_VERTEX;
|
|
|
|
std::vector<int>& oldF_ITa = subdivisionTables->_F_ITa;
|
|
std::vector<unsigned int>& oldF_IT = subdivisionTables->_F_IT;
|
|
std::vector<int> newF_ITa;
|
|
std::vector<unsigned int> newF_IT;
|
|
|
|
// Rearrange the face-vertices tables.
|
|
int tableOffset = kernelBatch.GetTableOffset();
|
|
int vertexOffset = kernelBatch.GetVertexOffset();
|
|
int firstVertexOffset, newVertexOffset;
|
|
|
|
if (isCatmarkFaceVertex) {
|
|
firstVertexOffset = oldF_ITa[tableOffset * 2];
|
|
newVertexOffset = firstVertexOffset;
|
|
} else {
|
|
firstVertexOffset = tableOffset;
|
|
}
|
|
|
|
newVertexOffset = firstVertexOffset;
|
|
for (int i = kernelBatch.GetStart(); i < kernelBatch.GetEnd(); ++i) {
|
|
int newVertex = i + vertexOffset;
|
|
int oldVertex = inversePermutation.find(newVertex)->second;
|
|
int oldVertexOffset, valence;
|
|
|
|
if (isCatmarkFaceVertex) {
|
|
int oldTableOffset = tableOffset + oldVertex - vertexOffset;
|
|
oldVertexOffset = oldF_ITa[oldTableOffset * 2 + 0];
|
|
valence = oldF_ITa[oldTableOffset * 2 + 1];
|
|
|
|
newF_ITa.push_back(newVertexOffset);
|
|
newF_ITa.push_back(valence);
|
|
newVertexOffset += valence;
|
|
} else {
|
|
oldVertexOffset = tableOffset + 4 * (oldVertex - vertexOffset);
|
|
valence = 4;
|
|
}
|
|
|
|
for (int j = 0; j < valence; ++j) {
|
|
newF_IT.push_back(oldF_IT[oldVertexOffset + j]);
|
|
}
|
|
}
|
|
|
|
// Rewrite the face-vertices tables.
|
|
std::copy(newF_IT.begin(), newF_IT.end(), oldF_IT.begin() +
|
|
firstVertexOffset);
|
|
if (!newF_ITa.empty()) {
|
|
std::copy(newF_ITa.begin(), newF_ITa.end(), oldF_ITa.begin() +
|
|
tableOffset * 2);
|
|
}
|
|
}
|
|
|
|
template <class T, class U> void
|
|
FarCatmarkSubdivisionTablesFactory<T, U>::permuteVertexVertexKernelBatch(
|
|
FarSubdivisionTables * subdivisionTables,
|
|
FarKernelBatch const &kernelBatch,
|
|
VertexPermutation const &inversePermutation )
|
|
{
|
|
std::vector<int>& oldV_ITa = subdivisionTables->_V_ITa;
|
|
std::vector<unsigned int>& oldV_IT = subdivisionTables->_V_IT;
|
|
std::vector<float>& oldV_W = subdivisionTables->_V_W;
|
|
std::vector<int> newV_ITa;
|
|
std::vector<unsigned int> newV_IT;
|
|
std::vector<float> newV_W;
|
|
|
|
// Rearrange the vertex-vertices tables.
|
|
int kernelBatchStart = kernelBatch.GetStart();
|
|
int kernelBatchEnd = kernelBatch.GetEnd();
|
|
int tableOffset = kernelBatch.GetTableOffset();
|
|
int vertexOffset = kernelBatch.GetVertexOffset();
|
|
int firstVertexOffset = oldV_ITa[(tableOffset + kernelBatchStart) * 5 + 0];
|
|
int newVertexOffset = firstVertexOffset;
|
|
for (int i = kernelBatchStart; i < kernelBatchEnd; ++i) {
|
|
int newVertex = i + vertexOffset;
|
|
int oldVertex = inversePermutation.find(newVertex)->second;
|
|
int oldTableOffset = tableOffset + oldVertex - vertexOffset;
|
|
int oldVertexOffset = oldV_ITa[oldTableOffset * 5 + 0];
|
|
int valence = oldV_ITa[oldTableOffset * 5 + 1];
|
|
int parentVertex = oldV_ITa[oldTableOffset * 5 + 2];
|
|
int edgeVertex1 = oldV_ITa[oldTableOffset * 5 + 3];
|
|
int edgeVertex2 = oldV_ITa[oldTableOffset * 5 + 4];
|
|
|
|
newV_ITa.push_back(newVertexOffset);
|
|
newV_ITa.push_back(valence);
|
|
newV_ITa.push_back(parentVertex);
|
|
newV_ITa.push_back(edgeVertex1);
|
|
newV_ITa.push_back(edgeVertex2);
|
|
newVertexOffset += valence * 2;
|
|
|
|
for (int j = 0; j < valence * 2; ++j) {
|
|
newV_IT.push_back(oldV_IT[oldVertexOffset + j]);
|
|
}
|
|
|
|
if ((int)oldV_W.size() > oldTableOffset) {
|
|
newV_W.push_back(oldV_W[oldTableOffset]);
|
|
}
|
|
}
|
|
|
|
// Rewrite the vertex-vertices tables.
|
|
std::copy(newV_ITa.begin(), newV_ITa.end(), oldV_ITa.begin() +
|
|
(tableOffset + kernelBatchStart) * 5);
|
|
std::copy(newV_IT.begin(), newV_IT.end(), oldV_IT.begin() +
|
|
firstVertexOffset);
|
|
if (!newV_W.empty()) {
|
|
std::copy(newV_W.begin(), newV_W.end(), oldV_W.begin() + tableOffset +
|
|
kernelBatchStart);
|
|
}
|
|
}
|
|
|
|
template <class T, class U> void
|
|
FarCatmarkSubdivisionTablesFactory<T, U>::RemapVertices(
|
|
FarSubdivisionTables * subdivisionTables,
|
|
FarKernelBatch const &kernelBatch,
|
|
VertexPermutation const& vertexPermutation )
|
|
{
|
|
switch (kernelBatch.GetKernelType()) {
|
|
case FarKernelBatch::CATMARK_FACE_VERTEX:
|
|
{
|
|
// Remap the face-vertices tables.
|
|
const std::vector<int>& F_ITa = subdivisionTables->_F_ITa;
|
|
std::vector<unsigned int>& F_IT = subdivisionTables->_F_IT;
|
|
int tableOffset = kernelBatch.GetTableOffset();
|
|
for (int i = kernelBatch.GetStart(); i < kernelBatch.GetEnd(); ++i)
|
|
{
|
|
int vertexOffset = F_ITa[(tableOffset + i) * 2];
|
|
int valence = F_ITa[(tableOffset + i) * 2 + 1];
|
|
for (int j = 0; j < valence; ++j) {
|
|
remapVertex(vertexPermutation, F_IT[vertexOffset + j]);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case FarKernelBatch::CATMARK_QUAD_FACE_VERTEX:
|
|
case FarKernelBatch::CATMARK_TRI_QUAD_FACE_VERTEX:
|
|
{
|
|
// Remap the face-vertices tables.
|
|
std::vector<unsigned int>& F_IT = subdivisionTables->_F_IT;
|
|
int tableOffset = kernelBatch.GetTableOffset();
|
|
for (int i = kernelBatch.GetStart(); i < kernelBatch.GetEnd(); ++i)
|
|
{
|
|
for (int j = 0; j < 4; ++j) {
|
|
remapVertex(vertexPermutation,
|
|
F_IT[tableOffset + 4 * i + j]);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case FarKernelBatch::CATMARK_EDGE_VERTEX:
|
|
case FarKernelBatch::CATMARK_RESTRICTED_EDGE_VERTEX:
|
|
{
|
|
// Remap the edge-vertices indexing table.
|
|
std::vector<int>& E_IT = subdivisionTables->_E_IT;
|
|
int tableOffset = kernelBatch.GetTableOffset();
|
|
for (int i = kernelBatch.GetStart(); i < kernelBatch.GetEnd(); ++i)
|
|
{
|
|
int vertexOffset = (tableOffset + i) * 4;
|
|
for (int j = 0; j < 4; ++j) {
|
|
remapVertex(vertexPermutation, E_IT[vertexOffset + j]);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case FarKernelBatch::CATMARK_VERT_VERTEX_A1:
|
|
case FarKernelBatch::CATMARK_VERT_VERTEX_B:
|
|
case FarKernelBatch::CATMARK_RESTRICTED_VERT_VERTEX_A:
|
|
case FarKernelBatch::CATMARK_RESTRICTED_VERT_VERTEX_B1:
|
|
case FarKernelBatch::CATMARK_RESTRICTED_VERT_VERTEX_B2:
|
|
{
|
|
// Remap the vertex-vertices tables.
|
|
std::vector<int>& V_ITa = subdivisionTables->_V_ITa;
|
|
std::vector<unsigned int>& V_IT = subdivisionTables->_V_IT;
|
|
int tableOffset = kernelBatch.GetTableOffset();
|
|
for (int i = kernelBatch.GetStart(); i < kernelBatch.GetEnd(); ++i)
|
|
{
|
|
int vertexOffset = V_ITa[(tableOffset + i) * 5];
|
|
int valence = V_ITa[(tableOffset + i) * 5 + 1];
|
|
int& parentVertex = V_ITa[(tableOffset + i) * 5 + 2];
|
|
int& edgeVertex1 = V_ITa[(tableOffset + i) * 5 + 3];
|
|
int& edgeVertex2 = V_ITa[(tableOffset + i) * 5 + 4];
|
|
remapVertex(vertexPermutation, parentVertex);
|
|
remapVertex(vertexPermutation, edgeVertex1);
|
|
remapVertex(vertexPermutation, edgeVertex2);
|
|
|
|
for (int j = 0; j < valence; ++j) {
|
|
remapVertex(vertexPermutation, V_IT[vertexOffset + j * 2]);
|
|
remapVertex(vertexPermutation, V_IT[vertexOffset + j * 2 + 1]);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
template <class T, class U> inline void
|
|
FarCatmarkSubdivisionTablesFactory<T, U>::remapVertex(
|
|
VertexPermutation const& vertexPermutation, int& vertex )
|
|
{
|
|
if (vertex < 0)
|
|
return; // do not remap negative indices
|
|
|
|
VertexPermutation::const_iterator i = vertexPermutation.find(vertex);
|
|
if (i != vertexPermutation.end())
|
|
vertex = i->second;
|
|
}
|
|
|
|
template <class T, class U> inline void
|
|
FarCatmarkSubdivisionTablesFactory<T, U>::remapVertex(
|
|
VertexPermutation const& vertexPermutation, unsigned int& vertex )
|
|
{
|
|
VertexPermutation::const_iterator i = vertexPermutation.find(vertex);
|
|
if (i != vertexPermutation.end())
|
|
vertex = i->second;
|
|
}
|
|
|
|
template <class T, class U> void
|
|
FarCatmarkSubdivisionTablesFactory<T, U>::ShiftVertices(
|
|
FarSubdivisionTables * subdivisionTables, FarKernelBatch &kernelBatch,
|
|
FarKernelBatch const &expandedKernelBatch,
|
|
int numVertices )
|
|
{
|
|
int start = kernelBatch.GetStart();
|
|
int end = kernelBatch.GetEnd();
|
|
int tableOffset = kernelBatch.GetTableOffset();
|
|
int vertexOffset = kernelBatch.GetVertexOffset();
|
|
int expandedKernelType = expandedKernelBatch.GetKernelType();
|
|
|
|
switch (kernelBatch.GetKernelType()) {
|
|
case FarKernelBatch::CATMARK_EDGE_VERTEX:
|
|
case FarKernelBatch::CATMARK_RESTRICTED_EDGE_VERTEX:
|
|
if (expandedKernelType == FarKernelBatch::CATMARK_EDGE_VERTEX ||
|
|
expandedKernelType ==
|
|
FarKernelBatch::CATMARK_RESTRICTED_EDGE_VERTEX)
|
|
{
|
|
tableOffset += numVertices;
|
|
vertexOffset += numVertices;
|
|
}
|
|
break;
|
|
|
|
case FarKernelBatch::CATMARK_VERT_VERTEX_A1:
|
|
case FarKernelBatch::CATMARK_VERT_VERTEX_B:
|
|
case FarKernelBatch::CATMARK_RESTRICTED_VERT_VERTEX_A:
|
|
case FarKernelBatch::CATMARK_RESTRICTED_VERT_VERTEX_B1:
|
|
case FarKernelBatch::CATMARK_RESTRICTED_VERT_VERTEX_B2:
|
|
if (expandedKernelType == FarKernelBatch::CATMARK_EDGE_VERTEX ||
|
|
expandedKernelType ==
|
|
FarKernelBatch::CATMARK_RESTRICTED_EDGE_VERTEX)
|
|
{
|
|
vertexOffset += numVertices;
|
|
} else if (expandedKernelType ==
|
|
FarKernelBatch::CATMARK_VERT_VERTEX_A1 ||
|
|
expandedKernelType == FarKernelBatch::CATMARK_VERT_VERTEX_B ||
|
|
expandedKernelType ==
|
|
FarKernelBatch::CATMARK_RESTRICTED_VERT_VERTEX_A ||
|
|
expandedKernelType ==
|
|
FarKernelBatch::CATMARK_RESTRICTED_VERT_VERTEX_B1 ||
|
|
expandedKernelType ==
|
|
FarKernelBatch::CATMARK_RESTRICTED_VERT_VERTEX_B2)
|
|
{
|
|
start += numVertices;
|
|
end += numVertices;
|
|
|
|
// Remap the vertex-vertices tables.
|
|
std::vector<int>& V_ITa = subdivisionTables->_V_ITa;
|
|
int lastVertexOffset = V_ITa[(tableOffset + start - 1) * 5 + 0];
|
|
int lastValence = V_ITa[(tableOffset + start - 1) * 5 + 1];
|
|
int oldVertexOffset = V_ITa[(tableOffset + start) * 5 + 0];
|
|
int newVertexOffset = lastVertexOffset + lastValence * 2;
|
|
for (int i = start; i < end; ++i) {
|
|
int& vertexOffset = V_ITa[(tableOffset + i) * 5 + 0];
|
|
vertexOffset += newVertexOffset - oldVertexOffset;
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
assert(!"kernel type is not supported");
|
|
break;
|
|
}
|
|
|
|
// Replace the kernel batch.
|
|
kernelBatch = FarKernelBatch(kernelBatch.GetKernelType(),
|
|
kernelBatch.GetLevel(), kernelBatch.GetTableIndex(), start, end,
|
|
tableOffset, vertexOffset, kernelBatch.GetMeshIndex());
|
|
}
|
|
|
|
} // end namespace OPENSUBDIV_VERSION
|
|
using namespace OPENSUBDIV_VERSION;
|
|
|
|
} // end namespace OpenSubdiv
|
|
|
|
#endif /* FAR_CATMARK_SUBDIVISION_TABLES_FACTORY_H */
|