MStatus TCC::compute(const MPlug& plug, MDataBlock& data)
{
MStatus stat;
if (plug == aOutputMesh) {
/* Get time */
int subdivRes = data.inputValue(aRes, &stat).asInt();
int subdivRefRes = data.inputValue(aRefRes, &stat).asInt();
float lineThickness = data.inputValue(aLineThickness, &stat).asFloat();
MDataHandle inMeshHandle = data.inputValue( aInputMesh, &stat ); McheckErr(stat,"ERROR getting attribute");
MObject inMeshObj = inMeshHandle.asMesh();
MFnMesh inMeshFn(inMeshObj);
MIntArray nFV, F;
inMeshFn.getVertices(nFV, F);
MIntArray nFVc = MFnIntArrayData( data.inputValue( anFVc ).data() ).array(&stat); McheckErr(stat,"ERROR getting attr");
MIntArray Fc = MFnIntArrayData( data.inputValue( aFc ).data() ).array(&stat); McheckErr(stat,"ERROR getting attr");
MIntArray pole = MFnIntArrayData( data.inputValue( aPole ).data() ).array(&stat); McheckErr(stat,"ERROR getting attr");
MIntArray corner = MFnIntArrayData( data.inputValue( aCorner ).data() ).array(&stat); McheckErr(stat,"ERROR getting attr");
MIntArray T = MFnIntArrayData( data.inputValue( aT ).data() ).array(&stat); McheckErr(stat,"ERROR getting attr");
MIntArray eqc = MFnIntArrayData( data.inputValue( aEqc ).data() ).array(&stat); McheckErr(stat,"ERROR getting attr");
MDoubleArray itv = MFnDoubleArrayData( data.inputValue( aItv ).data() ).array(&stat); McheckErr(stat,"ERROR getting attr");
MIntArray err = MFnIntArrayData( data.inputValue( aErr ).data() ).array(&stat); McheckErr(stat,"ERROR getting attr");
TCCData tccData(nFV, F, nFVc, Fc, pole, corner, T, eqc, itv, err);
/* Get output object */
MDataHandle outMeshHandle = data.outputValue(aOutputMesh, &stat); McheckErr(stat, "ERROR getting attribute\n");
if (validTopology(tccData))
{
stat = createSubdividedMesh(subdivRes, subdivRefRes, inMeshFn, tccData, outMeshHandle, lineThickness, stat);
}
else
{
outMeshHandle.setMObject(inMeshObj);
MFnMesh outMeshFn(outMeshHandle.asMesh());
stat = setErrorColors(outMeshFn, tccData);
}
data.setClean( plug );
} else
return MS::kUnknownParameter;
return stat;
}
MStatus
MayaPolySmooth::compute( const MPlug& plug, MDataBlock& data ) {
MStatus status;
// Check which output attribute we have been asked to compute. If this
// node doesn't know how to compute it, we must return
// MS::kUnknownParameter.
//
if( plug == a_output ) {
bool createdSubdMesh = false;
int subdivisionLevel = data.inputValue(a_subdivisionLevels).asInt();
short stateH = data.inputValue(state).asShort();
if ((subdivisionLevel > 0) and (stateH !=1)) {
// == Retrieve input mesh ====================================
// Get attr values
MObject inMeshObj = data.inputValue(a_inputPolymesh).asMesh();
short vertBoundaryMethod = data.inputValue(a_vertBoundaryMethod).asShort();
short fvarBoundaryMethod = data.inputValue(a_fvarBoundaryMethod).asShort();
bool fvarPropCorners = data.inputValue(a_fvarPropagateCorners).asBool();
bool smoothTriangles = data.inputValue(a_smoothTriangles).asBool();
short creaseMethodVal = data.inputValue(a_creaseMethod).asShort();
// == Get Mesh Functions and Iterators ==========================
MFnMeshData inMeshDat(inMeshObj);
MFnMesh inMeshFn(inMeshObj, &status);
MCHECKERR(status, "ERROR getting inMeshFn\n");
MItMeshPolygon inMeshItPolygon(inMeshObj, &status);
MCHECKERR(status, "ERROR getting inMeshItPolygon\n");
// Convert attr values to OSD enums
OpenSubdiv::Sdc::SchemeType type = OpenSubdiv::Sdc::SCHEME_CATMARK;
// == Create Far topology ==========================
OpenSubdiv::Sdc::Options options;
options.SetVtxBoundaryInterpolation(ConvertMayaVtxBoundary(vertBoundaryMethod));
options.SetFVarLinearInterpolation(ConvertMayaFVarBoundary(fvarBoundaryMethod, fvarPropCorners));
options.SetCreasingMethod(creaseMethodVal ?
OpenSubdiv::Sdc::Options::CREASE_CHAIKIN : OpenSubdiv::Sdc::Options::CREASE_UNIFORM);
options.SetTriangleSubdivision(smoothTriangles ?
OpenSubdiv::Sdc::Options::TRI_SUB_SMOOTH : OpenSubdiv::Sdc::Options::TRI_SUB_CATMARK);
// Storage for face-varying values (UV sets, vertex colors...)
std::vector<MFloatArray> uvSet_uCoords;
std::vector<MFloatArray> uvSet_vCoords;
std::vector<MColorArray> colorSet_colors;
bool hasUVs = false, hasColors = false;
float maxCreaseSharpness=0.0f;
OpenSubdiv::Far::TopologyRefiner * refiner = gatherTopology(
inMeshFn, inMeshItPolygon, type, options, &hasUVs, &hasColors,
uvSet_uCoords, uvSet_vCoords, colorSet_colors, &maxCreaseSharpness);
assert(refiner);
// == Refine & Interpolate ==========================
refiner->RefineUniform(OpenSubdiv::Far::TopologyRefiner::UniformOptions(subdivisionLevel));
// Prepare vertex information
Vertex const * initialVerts =
reinterpret_cast<Vertex const *>(inMeshFn.getRawPoints(&status));
std::vector<Vertex> refinedVerts(
refiner->GetNumVerticesTotal() - refiner->GetLevel(0).GetNumVertices());
Vertex const * srcVerts = &initialVerts[0];
Vertex * dstVerts = &refinedVerts[0];
// Verify the refiner has the correct number of values
// needed to interpolate the different channels
int numInitialUVs = refiner->GetLevel(0).GetNumFVarValues(CHANNELUV);
int numInitialColors = refiner->GetLevel(0).GetNumFVarValues(CHANNELCOLOR);
if (hasUVs && numInitialUVs <= 0) {
hasUVs = false;
MGlobal::displayError("Model with incorrect data, the UV channel will not be interpolated.");
}
if (hasColors && numInitialColors <= 0) {
hasColors = false;
MGlobal::displayError("Model with incorrect data, the color channel will not be interpolated.");
}
// Prepare UV information if needed
std::vector<FVarVertexUV> initialUVs, refinedUVs;
FVarVertexUV const * srcUV = NULL;
FVarVertexUV * dstUV = NULL;
if(hasUVs) {
initialUVs.resize(numInitialUVs);
refinedUVs.resize(refiner->GetNumFVarValuesTotal(CHANNELUV));
for (int i=0; i<numInitialUVs; ++i) {
initialUVs[i].u = uvSet_uCoords[0][i];
initialUVs[i].v = uvSet_vCoords[0][i];
}
srcUV = &initialUVs[0];
dstUV = &refinedUVs[0];
}
// Prepare color information if needed
std::vector<FVarVertexColor> initialColors, refinedColors;
FVarVertexColor const * srcColor = NULL;
FVarVertexColor * dstColor = NULL;
if(hasColors) {
initialColors.resize(numInitialColors);
refinedColors.resize(refiner->GetNumFVarValuesTotal(CHANNELCOLOR));
for (int i=0; i<numInitialColors; ++i) {
initialColors[i].r = colorSet_colors[0][i].r;
initialColors[i].g = colorSet_colors[0][i].g;
initialColors[i].b = colorSet_colors[0][i].b;
initialColors[i].a = colorSet_colors[0][i].a;
}
srcColor = &initialColors[0];
dstColor = &refinedColors[0];
}
// Interpolate the vertices and the different channels
OpenSubdiv::Far::PrimvarRefiner primvarRefiner(*refiner);
for (int level = 1; level <= subdivisionLevel; ++level) {
// Interpolate vertices
primvarRefiner.Interpolate(level, srcVerts, dstVerts);
srcVerts = dstVerts;
dstVerts += refiner->GetLevel(level).GetNumVertices();
// Interpolate the uv set
if(hasUVs) {
primvarRefiner.InterpolateFaceVarying(level, srcUV, dstUV, CHANNELUV);
srcUV = dstUV;
dstUV += refiner->GetLevel(level).GetNumFVarValues(CHANNELUV);
}
// Interpolate any color set
if(hasColors) {
primvarRefiner.InterpolateFaceVarying(level, srcColor, dstColor, CHANNELCOLOR);
srcColor = dstColor;
dstColor += refiner->GetLevel(level).GetNumFVarValues(CHANNELCOLOR);
}
}
// == Convert subdivided OpenSubdiv mesh to MFnMesh Data outputMesh =============
// Create New Mesh Data Object
MFnMeshData newMeshData;
MObject newMeshDataObj = newMeshData.create(&status);
MCHECKERR(status, "ERROR creating outputData");
// Create out mesh
status = convertToMayaMeshData(*refiner, refinedVerts, hasUVs,
refinedUVs, hasColors, refinedColors, inMeshFn, newMeshDataObj);
MCHECKERR(status, "ERROR convertOsdFarToMayaMesh");
// Propagate objectGroups from inMesh to outMesh (for per-facet shading, etc)
status = createSmoothMesh_objectGroups(inMeshFn, inMeshDat,
newMeshData, subdivisionLevel, refiner->GetLevel(subdivisionLevel).GetNumFaces());
// Write to output plug
MDataHandle outMeshH = data.outputValue(a_output, &status);
MCHECKERR(status, "ERROR getting polygon data handle\n");
outMeshH.set(newMeshDataObj);
int isolation = std::min(10,(int)ceil(maxCreaseSharpness)+1);
data.outputValue(a_recommendedIsolation).set(isolation);
// == Cleanup OSD ============================================
// REVISIT: Re-add these deletes
delete refiner;
// note that the subd mesh was created (see the section below if !createdSubdMesh)
createdSubdMesh = true;
}
// Pass-through inMesh to outMesh if not created the subd mesh
if (!createdSubdMesh) {
MDataHandle outMeshH = data.outputValue(a_output, &status);
status = outMeshH.copy(data.outputValue(a_inputPolymesh, &status));
MCHECKERR(status, "ERROR getting polygon data handle\n");
}
// Clean up Maya Plugs
data.setClean(plug);
} else {
// Unhandled parameter in this compute function, so return MS::kUnknownParameter
// so it is handled in a parent compute() function.
return MS::kUnknownParameter;
}
return MS::kSuccess;
}
// ====================================
// Compute
// ====================================
//
// Description:
// This method computes the value of the given output plug based
// on the values of the input attributes.
//
// Arguments:
// plug - the plug to compute
// data - object that provides access to the attributes for this node
//
MStatus OsdPolySmooth::compute( const MPlug& plug, MDataBlock& data ) {
MStatus returnStatus;
// Check which output attribute we have been asked to compute. If this
// node doesn't know how to compute it, we must return
// MS::kUnknownParameter.
//
if( plug == a_output ) {
bool createdSubdMesh = false;
int subdivisionLevel = data.inputValue(a_subdivisionLevels).asInt();
short stateH = data.inputValue(state).asShort();
if ((subdivisionLevel > 0) and (stateH !=1)) {
// == Retrieve input mesh ====================================
// Get attr values
MObject inMeshObj = data.inputValue(a_inputPolymesh).asMesh();
short vertBoundaryMethod = data.inputValue(a_vertBoundaryMethod).asShort();
short fvarBoundaryMethod = data.inputValue(a_fvarBoundaryMethod).asShort();
bool fvarPropCorners = data.inputValue(a_fvarPropagateCorners).asBool();
bool smoothTriangles = data.inputValue(a_smoothTriangles).asBool();
short creaseMethodVal = data.inputValue(a_creaseMethod).asShort();
// Convert attr values to OSD enums
HMesh::InterpolateBoundaryMethod vertInterpBoundaryMethod =
ConvertMayaBoundaryMethodShortToOsdInterpolateBoundaryMethod(vertBoundaryMethod);
HMesh::InterpolateBoundaryMethod fvarInterpBoundaryMethod =
ConvertMayaBoundaryMethodShortToOsdInterpolateBoundaryMethod(fvarBoundaryMethod);
HCatmark::CreaseSubdivision creaseMethod =
(creaseMethodVal == k_creaseMethod_chaikin) ?
HCatmark::k_CreaseChaikin : HCatmark::k_CreaseNormal;
HCatmark::TriangleSubdivision triangleSubdivision =
smoothTriangles ? HCatmark::k_New : HCatmark::k_Normal;
// == Get Mesh Functions and Iterators ==========================
MFnMeshData inMeshDat(inMeshObj);
MFnMesh inMeshFn(inMeshObj, &returnStatus);
MCHECKERR(returnStatus, "ERROR getting inMeshFn\n");
MItMeshPolygon inMeshItPolygon(inMeshObj, &returnStatus);
MCHECKERR(returnStatus, "ERROR getting inMeshItPolygon\n");
// == Convert MFnMesh to OpenSubdiv =============================
// Create the hbrMesh
// Note: These fvar values only need to be kept alive through the life of the farMesh
std::vector<int> fvarIndices;
std::vector<int> fvarWidths;
HMesh *hbrMesh = createOsdHbrFromPoly(
inMeshFn, inMeshItPolygon, fvarIndices, fvarWidths);
assert(hbrMesh);
// Create the farMesh if successfully created the hbrMesh
if (hbrMesh) {
// Set Boundary methods and other hbr paramters
hbrMesh->SetInterpolateBoundaryMethod( vertInterpBoundaryMethod );
hbrMesh->SetFVarInterpolateBoundaryMethod( fvarInterpBoundaryMethod );
hbrMesh->SetFVarPropagateCorners(fvarPropCorners);
hbrMesh->GetSubdivision()->SetCreaseSubdivisionMethod(creaseMethod);
// Set HBR Catmark Subdivision parameters
HCatmark *catmarkSubdivision = dynamic_cast<HCatmark *>(hbrMesh->GetSubdivision());
if (catmarkSubdivision) {
catmarkSubdivision->SetTriangleSubdivisionMethod(triangleSubdivision);
}
// Finalize subd calculations -- apply boundary interpolation rules and resolves singular verts, etc.
// NOTE: This HAS to be called after all HBR parameters are set
hbrMesh->Finish();
int ncoarseverts = hbrMesh->GetNumVertices();
// Create a FarMesh from the HBR mesh and pass into
// It will be owned by the OsdMesh and deleted in the ~OsdMesh()
FMeshFactory meshFactory(hbrMesh, subdivisionLevel, false);
FMesh *farMesh = meshFactory.Create((hbrMesh->GetTotalFVarWidth() > 0));
// == Setup OSD Data Structures =========================
int numVertexElements = 3; // only track vertex positions
int numVaryingElements = 0; // XXX Future: Revise to include varying ColorSets
int numVertices = inMeshFn.numVertices();
int numFarVerts = farMesh->GetNumVertices();
static OpenSubdiv::OsdCpuComputeController computeController = OpenSubdiv::OsdCpuComputeController();
OpenSubdiv::OsdCpuComputeController::ComputeContext *computeContext =
OpenSubdiv::OsdCpuComputeController::ComputeContext::Create(farMesh);
OpenSubdiv::OsdCpuVertexBuffer *vertexBuffer =
OpenSubdiv::OsdCpuVertexBuffer::Create(numVertexElements, numFarVerts );
OpenSubdiv::OsdCpuVertexBuffer *varyingBuffer =
(numVaryingElements) ? OpenSubdiv::OsdCpuVertexBuffer::Create(numVaryingElements, numFarVerts) : NULL;
// == UPDATE VERTICES (can be done after farMesh generated from topology) ==
float const * vertex3fArray = inMeshFn.getRawPoints(&returnStatus);
vertexBuffer->UpdateData(vertex3fArray, 0, numVertices );
// Hbr dupes singular vertices during Mesh::Finish() - we need
// to duplicate their positions in the vertex buffer.
if (ncoarseverts > numVertices) {
MIntArray polyverts;
for (int i=numVertices; i<ncoarseverts; ++i) {
HVertex const * v = hbrMesh->GetVertex(i);
HFace const * f = v->GetIncidentEdge()->GetFace();
int vidx = -1;
for (int j=0; j<f->GetNumVertices(); ++j) {
if (f->GetVertex(j)==v) {
vidx = j;
break;
}
}
assert(vidx>-1);
inMeshFn.getPolygonVertices(f->GetID(), polyverts);
int vert = polyverts[vidx];
vertexBuffer->UpdateData(&vertex3fArray[0]+vert*numVertexElements, i, 1);
}
}
// == Delete HBR
// Can now delete the hbrMesh as we will only be referencing the farMesh from this point on
delete hbrMesh;
hbrMesh = NULL;
// == Subdivide OpenSubdiv mesh ==========================
computeController.Refine(computeContext, farMesh->GetKernelBatches(), vertexBuffer, varyingBuffer);
computeController.Synchronize();
// == Convert subdivided OpenSubdiv mesh to MFnMesh Data outputMesh =============
// Create New Mesh Data Object
MFnMeshData newMeshData;
MObject newMeshDataObj = newMeshData.create(&returnStatus);
MCHECKERR(returnStatus, "ERROR creating outputData");
// Create out mesh
returnStatus = convertOsdFarToMayaMeshData(farMesh, vertexBuffer, subdivisionLevel, inMeshFn, newMeshDataObj);
MCHECKERR(returnStatus, "ERROR convertOsdFarToMayaMesh");
// Propagate objectGroups from inMesh to outMesh (for per-facet shading, etc)
returnStatus = createSmoothMesh_objectGroups(inMeshDat, subdivisionLevel, newMeshData );
// Write to output plug
MDataHandle outMeshH = data.outputValue(a_output, &returnStatus);
MCHECKERR(returnStatus, "ERROR getting polygon data handle\n");
outMeshH.set(newMeshDataObj);
// == Cleanup OSD ============================================
// REVISIT: Re-add these deletes
delete(vertexBuffer);
delete(varyingBuffer);
delete(computeContext);
delete(farMesh);
// note that the subd mesh was created (see the section below if !createdSubdMesh)
createdSubdMesh = true;
}
}
// Pass-through inMesh to outMesh if not created the subd mesh
if (!createdSubdMesh) {
MDataHandle outMeshH = data.outputValue(a_output, &returnStatus);
returnStatus = outMeshH.copy(data.outputValue(a_inputPolymesh, &returnStatus));
MCHECKERR(returnStatus, "ERROR getting polygon data handle\n");
}
// Clean up Maya Plugs
data.setClean(plug);
}
else {
// Unhandled parameter in this compute function, so return MS::kUnknownParameter
// so it is handled in a parent compute() function.
return MS::kUnknownParameter;
}
return MS::kSuccess;
}
MStatus PtexUVNode::compute( const MPlug &plug, MDataBlock &data )
{
MStatus stat;
bool hasNoEffect = false;
MDataHandle inMeshHnd = data.inputValue( inMesh );
MDataHandle outMeshHnd = data.outputValue( outMesh );
MDataHandle stateHnd = data.inputValue( state );
int state = stateHnd.asInt();
if( state == 1 ) // No Effect/Pass through
hasNoEffect = true;
if( !hasNoEffect && plug == outMesh )
{
MObject inMeshData = inMeshHnd.asMesh();
if( !hasNoEffect )
{
MFnMeshData meshDataFn;
MObject newMeshData = meshDataFn.create();
MFnMesh inMeshFn( inMeshData );
inMeshFn.copy( inMeshData, newMeshData );
MFnMesh meshFn( newMeshData );
MPointArray pts;
meshFn.getPoints( pts );
MStringArray uvSetNames;
meshFn.getUVSetNames( uvSetNames );
unsigned int defaultUvSetCount = (unsigned int)uvSetNames.length();
int num_faces = meshFn.numPolygons();
MIntArray uvCounts;
uvCounts.setLength( num_faces );
for ( int i_f = 0; i_f < num_faces; i_f++ )
{
int deg = meshFn.polygonVertexCount( i_f );
uvCounts[ i_f ] = deg;
if ( deg != 4 )
{
return MS::kFailure;
}
}
MIntArray uvIds;
uvIds.setLength( 4 * num_faces );
if ( defaultUvSetCount == 1 )
{
int currentUVCount = meshFn.numUVs( uvSetNames[0] );
MFloatArray us, vs;
us.setLength( 4 * num_faces );
vs.setLength( 4 * num_faces );
for ( int i_f = 0; i_f < num_faces; i_f++ )
{
float f = (float)i_f;
uvIds[ 4 * i_f + 0 ] = 4 * i_f + 0;
uvIds[ 4 * i_f + 1 ] = 4 * i_f + 1;
uvIds[ 4 * i_f + 2 ] = 4 * i_f + 2;
uvIds[ 4 * i_f + 3 ] = 4 * i_f + 3;
us[ 4 * i_f + 0 ] = (float)i_f; vs[ 4 * i_f + 0 ] = 0.0f;
us[ 4 * i_f + 1 ] = (float)i_f + 1.0f; vs[ 4 * i_f + 1 ] = 0.0f;
us[ 4 * i_f + 2 ] = (float)i_f + 1.0f; vs[ 4 * i_f + 2 ] = 1.0f;
us[ 4 * i_f + 3 ] = (float)i_f; vs[ 4 * i_f + 3 ] = 1.0f;
}
stat = meshFn.setUVs( us, vs, &uvSetNames[0] );
stat = meshFn.assignUVs( uvCounts, uvIds, &uvSetNames[0] );
}
meshFn.updateSurface();
meshFn.syncObject();
outMeshHnd.set( newMeshData );
}
}
else
return MS::kUnknownParameter;
if( hasNoEffect )
outMeshHnd.set( inMeshHnd.asMesh() );
data.setClean( plug );
return stat;
}
MStatus
MayaPolySmooth::compute( const MPlug& plug, MDataBlock& data ) {
MStatus status;
// Check which output attribute we have been asked to compute. If this
// node doesn't know how to compute it, we must return
// MS::kUnknownParameter.
//
if( plug == a_output ) {
bool createdSubdMesh = false;
int subdivisionLevel = data.inputValue(a_subdivisionLevels).asInt();
short stateH = data.inputValue(state).asShort();
if ((subdivisionLevel > 0) and (stateH !=1)) {
// == Retrieve input mesh ====================================
// Get attr values
MObject inMeshObj = data.inputValue(a_inputPolymesh).asMesh();
short vertBoundaryMethod = data.inputValue(a_vertBoundaryMethod).asShort();
short fvarBoundaryMethod = data.inputValue(a_fvarBoundaryMethod).asShort();
bool fvarPropCorners = data.inputValue(a_fvarPropagateCorners).asBool();
bool smoothTriangles = data.inputValue(a_smoothTriangles).asBool();
short creaseMethodVal = data.inputValue(a_creaseMethod).asShort();
// == Get Mesh Functions and Iterators ==========================
MFnMeshData inMeshDat(inMeshObj);
MFnMesh inMeshFn(inMeshObj, &status);
MCHECKERR(status, "ERROR getting inMeshFn\n");
MItMeshPolygon inMeshItPolygon(inMeshObj, &status);
MCHECKERR(status, "ERROR getting inMeshItPolygon\n");
// Convert attr values to OSD enums
OpenSubdiv::Sdc::SchemeType type = OpenSubdiv::Sdc::SCHEME_CATMARK;
//
// Create Far topology
//
OpenSubdiv::Sdc::Options options;
options.SetVtxBoundaryInterpolation(ConvertMayaVtxBoundary(vertBoundaryMethod));
options.SetFVarLinearInterpolation(ConvertMayaFVarBoundary(fvarBoundaryMethod, fvarPropCorners));
options.SetCreasingMethod(creaseMethodVal ?
OpenSubdiv::Sdc::Options::CREASE_CHAIKIN : OpenSubdiv::Sdc::Options::CREASE_UNIFORM);
options.SetTriangleSubdivision(smoothTriangles ?
OpenSubdiv::Sdc::Options::TRI_SUB_SMOOTH : OpenSubdiv::Sdc::Options::TRI_SUB_CATMARK);
float maxCreaseSharpness=0.0f;
OpenSubdiv::Far::TopologyRefiner * refiner =
gatherTopology(inMeshFn, inMeshItPolygon, type, options, &maxCreaseSharpness);
assert(refiner);
// Refine & Interpolate
refiner->RefineUniform(OpenSubdiv::Far::TopologyRefiner::UniformOptions(subdivisionLevel));
Vertex const * controlVerts =
reinterpret_cast<Vertex const *>(inMeshFn.getRawPoints(&status));
std::vector<Vertex> refinedVerts(
refiner->GetNumVerticesTotal() - refiner->GetLevel(0).GetNumVertices());
Vertex const * srcVerts = controlVerts;
Vertex * dstVerts = &refinedVerts[0];
for (int level = 1; level <= subdivisionLevel; ++level) {
OpenSubdiv::Far::PrimvarRefiner(*refiner).Interpolate(level, srcVerts, dstVerts);
srcVerts = dstVerts;
dstVerts += refiner->GetLevel(level).GetNumVertices();
}
// == Convert subdivided OpenSubdiv mesh to MFnMesh Data outputMesh =============
// Create New Mesh Data Object
MFnMeshData newMeshData;
MObject newMeshDataObj = newMeshData.create(&status);
MCHECKERR(status, "ERROR creating outputData");
// Create out mesh
status = convertToMayaMeshData(*refiner, refinedVerts, inMeshFn, newMeshDataObj);
MCHECKERR(status, "ERROR convertOsdFarToMayaMesh");
// Propagate objectGroups from inMesh to outMesh (for per-facet shading, etc)
status = createSmoothMesh_objectGroups(inMeshFn, inMeshDat,
newMeshData, subdivisionLevel, refiner->GetLevel(subdivisionLevel).GetNumFaces());
// Write to output plug
MDataHandle outMeshH = data.outputValue(a_output, &status);
MCHECKERR(status, "ERROR getting polygon data handle\n");
outMeshH.set(newMeshDataObj);
int isolation = std::min(10,(int)ceil(maxCreaseSharpness)+1);
data.outputValue(a_recommendedIsolation).set(isolation);
// == Cleanup OSD ============================================
// REVISIT: Re-add these deletes
delete refiner;
// note that the subd mesh was created (see the section below if !createdSubdMesh)
createdSubdMesh = true;
}
// Pass-through inMesh to outMesh if not created the subd mesh
if (!createdSubdMesh) {
MDataHandle outMeshH = data.outputValue(a_output, &status);
status = outMeshH.copy(data.outputValue(a_inputPolymesh, &status));
MCHECKERR(status, "ERROR getting polygon data handle\n");
}
// Clean up Maya Plugs
data.setClean(plug);
} else {
// Unhandled parameter in this compute function, so return MS::kUnknownParameter
// so it is handled in a parent compute() function.
return MS::kUnknownParameter;
}
return MS::kSuccess;
}
