/* static */
bool
PxrUsdMayaTranslatorCurves::Create(
const UsdGeomCurves& curves,
MObject parentNode,
const PxrUsdMayaPrimReaderArgs& args,
PxrUsdMayaPrimReaderContext* context)
{
if (not curves) {
return false;
}
const UsdPrim& prim = curves.GetPrim();
MStatus status;
// Create node (transform)
MObject mayaNodeTransformObj;
if (not PxrUsdMayaTranslatorUtil::CreateTransformNode(prim,
parentNode,
args,
context,
&status,
&mayaNodeTransformObj)) {
return false;
}
VtArray<GfVec3f> points;
VtArray<int> curveOrder;
VtArray<int> curveVertexCounts;
VtArray<float> curveWidths;
VtArray<GfVec2d> curveRanges;
VtArray<double> curveKnots;
// LIMITATION: xxx REVISIT xxx
// Non-animated Attrs
// Assuming that a number of these USD attributes are assumed to not be animated
// Some we may want to expose as animatable later.
//
curves.GetCurveVertexCountsAttr().Get(&curveVertexCounts); // not animatable
// XXX:
// Only supporting single curve for now.
// Sanity Checks
if (curveVertexCounts.size() == 0) {
MGlobal::displayError(
TfStringPrintf("VertexCount arrays is empty on NURBS curves <%s>. Skipping...",
prim.GetPath().GetText()).c_str());
return false; // No verts for the curve, so exit
} else if (curveVertexCounts.size() > 1) {
MGlobal::displayWarning(
TfStringPrintf("Multiple curves in <%s>. Reading first one...",
prim.GetPath().GetText()).c_str());
}
int curveIndex = 0;
curves.GetWidthsAttr().Get(&curveWidths); // not animatable
// Gather points. If args.GetReadAnimData() is TRUE,
// pick the first avaiable sample or default
UsdTimeCode pointsTimeSample=UsdTimeCode::EarliestTime();
std::vector<double> pointsTimeSamples;
size_t numTimeSamples = 0;
if (args.GetReadAnimData()) {
curves.GetPointsAttr().GetTimeSamples(&pointsTimeSamples);
numTimeSamples = pointsTimeSamples.size();
if (numTimeSamples>0) {
pointsTimeSample = pointsTimeSamples[0];
}
}
curves.GetPointsAttr().Get(&points, pointsTimeSample);
if (points.size() == 0) {
MGlobal::displayError(
TfStringPrintf("Points arrays is empty on NURBS curves <%s>. Skipping...",
prim.GetPath().GetText()).c_str());
return false; // invalid nurbscurves, so exit
}
if (UsdGeomNurbsCurves nurbsSchema = UsdGeomNurbsCurves(prim)) {
nurbsSchema.GetOrderAttr().Get(&curveOrder); // not animatable
nurbsSchema.GetKnotsAttr().Get(&curveKnots); // not animatable
nurbsSchema.GetRangesAttr().Get(&curveRanges); // not animatable
} else {
// Handle basis curves originally modelled in Maya as nurbs.
curveOrder.resize(1);
UsdGeomBasisCurves basisSchema = UsdGeomBasisCurves(prim);
TfToken typeToken;
basisSchema.GetTypeAttr().Get(&typeToken);
if (typeToken == UsdGeomTokens->linear) {
curveOrder[0] = 2;
curveKnots.resize(points.size());
for (size_t i=0; i < curveKnots.size(); ++i) {
curveKnots[i] = i;
}
} else {
curveOrder[0] = 4;
// Strip off extra end points; assuming this is non-periodic.
VtArray<GfVec3f> tmpPts(points.size() - 2);
std::copy(points.begin() + 1, points.end() - 1, tmpPts.begin());
points.swap(tmpPts);
// Cubic curves in Maya have numSpans + 2*3 - 1, and for geometry
// that came in as basis curves, we have numCV's - 3 spans. See the
// MFnNurbsCurve documentation and the nurbs curve export
// implementation in mojitoplugmaya for more details.
curveKnots.resize(points.size() -3 + 5);
int knotIdx = 0;
for (size_t i=0; i < curveKnots.size(); ++i) {
if (i < 3) {
curveKnots[i] = 0.0;
} else {
if (i <= curveKnots.size() - 3) {
++knotIdx;
}
curveKnots[i] = double(knotIdx);
}
}
}
}
// == Convert data
size_t mayaNumVertices = points.size();
MPointArray mayaPoints(mayaNumVertices);
for (size_t i=0; i < mayaNumVertices; i++) {
mayaPoints.set( i, points[i][0], points[i][1], points[i][2] );
}
double *knots=curveKnots.data();
MDoubleArray mayaKnots( knots, curveKnots.size());
int mayaDegree = curveOrder[curveIndex] - 1;
MFnNurbsCurve::Form mayaCurveForm = MFnNurbsCurve::kOpen; // HARDCODED
bool mayaCurveCreate2D = false;
bool mayaCurveCreateRational = true;
// == Create NurbsCurve Shape Node
MFnNurbsCurve curveFn;
MObject curveObj = curveFn.create(mayaPoints,
mayaKnots,
mayaDegree,
mayaCurveForm,
mayaCurveCreate2D,
mayaCurveCreateRational,
mayaNodeTransformObj,
&status
);
if (status != MS::kSuccess) {
return false;
}
MString nodeName( prim.GetName().GetText() );
nodeName += "Shape";
curveFn.setName(nodeName, false, &status);
std::string nodePath( prim.GetPath().GetText() );
nodePath += "/";
nodePath += nodeName.asChar();
if (context) {
context->RegisterNewMayaNode( nodePath, curveObj ); // used for undo/redo
}
// == Animate points ==
// Use blendShapeDeformer so that all the points for a frame are contained in a single node
// Almost identical code as used with MayaMeshReader.cpp
//
if (numTimeSamples > 0) {
MPointArray mayaPoints(mayaNumVertices);
MObject curveAnimObj;
MFnBlendShapeDeformer blendFn;
MObject blendObj = blendFn.create(curveObj);
if (context) {
context->RegisterNewMayaNode(blendFn.name().asChar(), blendObj ); // used for undo/redo
}
for (unsigned int ti=0; ti < numTimeSamples; ++ti) {
curves.GetPointsAttr().Get(&points, pointsTimeSamples[ti]);
for (unsigned int i=0; i < mayaNumVertices; i++) {
mayaPoints.set( i, points[i][0], points[i][1], points[i][2] );
}
// == Create NurbsCurve Shape Node
MFnNurbsCurve curveFn;
if ( curveAnimObj.isNull() ) {
curveAnimObj = curveFn.create(mayaPoints,
mayaKnots,
mayaDegree,
mayaCurveForm,
mayaCurveCreate2D,
mayaCurveCreateRational,
mayaNodeTransformObj,
&status
);
if (status != MS::kSuccess) {
continue;
}
}
else {
// Reuse the already created curve by copying it and then setting the points
curveAnimObj = curveFn.copy(curveAnimObj, mayaNodeTransformObj, &status);
curveFn.setCVs(mayaPoints);
}
blendFn.addTarget(curveObj, ti, curveAnimObj, 1.0);
curveFn.setIntermediateObject(true);
if (context) {
context->RegisterNewMayaNode( curveFn.fullPathName().asChar(), curveAnimObj ); // used for undo/redo
}
}
// Animate the weights so that curve0 has a weight of 1 at frame 0, etc.
MFnAnimCurve animFn;
// Construct the time array to be used for all the keys
MTimeArray timeArray;
timeArray.setLength(numTimeSamples);
for (unsigned int ti=0; ti < numTimeSamples; ++ti) {
timeArray.set( MTime(pointsTimeSamples[ti]), ti);
}
// Key/Animate the weights
MPlug plgAry = blendFn.findPlug( "weight" );
if ( !plgAry.isNull() && plgAry.isArray() ) {
for (unsigned int ti=0; ti < numTimeSamples; ++ti) {
MPlug plg = plgAry.elementByLogicalIndex(ti, &status);
MDoubleArray valueArray(numTimeSamples, 0.0);
valueArray[ti] = 1.0; // Set the time value where this curve's weight should be 1.0
MObject animObj = animFn.create(plg, NULL, &status);
animFn.addKeys(&timeArray, &valueArray);
if (context) {
context->RegisterNewMayaNode(animFn.name().asChar(), animObj ); // used for undo/redo
}
}
}
}
return true;
}
MStatus clusterControledCurve::compute( const MPlug& plug, MDataBlock& data )
{
//MFnDependencyNode thisNode( thisMObject() );
//cout << thisNode.name() << ", start" << endl;
MStatus status;
MDataHandle hInputCurve = data.inputValue( aInputCurve, &status );
CHECK_MSTATUS_AND_RETURN_IT( status );
MDataHandle hInputCurveMatrix = data.inputValue( aInputCurveMatrix, &status );
CHECK_MSTATUS_AND_RETURN_IT( status );
MDataHandle hOutputCurve = data.outputValue( aOutputCurve, &status );
CHECK_MSTATUS_AND_RETURN_IT( status );
MArrayDataHandle hArrBindPreMatrix = data.inputArrayValue( aBindPreMatrix, &status );
CHECK_MSTATUS_AND_RETURN_IT( status );
MArrayDataHandle hArrMatrix = data.inputArrayValue( aMatrix, &status );
CHECK_MSTATUS_AND_RETURN_IT( status );
MArrayDataHandle hArrWeightList = data.inputArrayValue( aWeightList, &status );
CHECK_MSTATUS_AND_RETURN_IT( status );
MDataHandle hUpdate = data.inputValue( aUpdate, &status );
CHECK_MSTATUS_AND_RETURN_IT( status );
MObject oInputCurve = hInputCurve.asNurbsCurve();
int bindPreMatrixLength = hArrBindPreMatrix.elementCount();
int matrixLength = hArrMatrix.elementCount();
MFnNurbsCurve fnInputCurve = oInputCurve;
int numCVs = fnInputCurve.numCVs();
int weightListLength = hArrWeightList.elementCount();
if( weightListLength > 100 )
{
cout << "WeightList Count Error : " << weightListLength << endl;
return MS::kFailure;
}
MPointArray inputCvPoints;
MPointArray outputCvPoints;
fnInputCurve.getCVs( inputCvPoints );
outputCvPoints.setLength( numCVs );
MMatrix matrix;
MMatrix inputCurveMatrix = hInputCurveMatrix.asMatrix();
MMatrix inputCurveMatrixInverse = inputCurveMatrix.inverse();
if( requireUpdate )
CHECK_MSTATUS_AND_RETURN_IT( updateBindPreMatrix( oInputCurve, inputCurveMatrixInverse,
hArrMatrix, hArrBindPreMatrix, hUpdate.asBool() ) );
for( int i=0; i< numCVs; i++ )
{
inputCvPoints[i] *= inputCurveMatrix;
}
for( int i=0; i< numCVs; i++ )
{
outputCvPoints[i] = MPoint( 0,0,0 );
double weight;
for( int j=0; j< matrixLength; j++ )
{
weight = setWeights[i][j];
hArrMatrix.jumpToElement( j );
matrix = hArrMatrix.inputValue().asMatrix();
outputCvPoints[i] += inputCvPoints[i]*bindPreMatrix[j]*matrix*weight;
}
}
for( int i=0; i< numCVs; i++ )
{
outputCvPoints[i] *= inputCurveMatrixInverse;
}
MFnNurbsCurveData outputCurveData;
MObject oOutputCurve = outputCurveData.create();
fnInputCurve.copy( oInputCurve, oOutputCurve );
MFnNurbsCurve fnOutputCurve( oOutputCurve, &status );
CHECK_MSTATUS_AND_RETURN_IT( status );
fnOutputCurve.setCVs( outputCvPoints );
hOutputCurve.set( oOutputCurve );
data.setClean( plug );
//cout << thisNode.name() << ", end" << endl;
return status;
}
MStatus multiCurve::compute( const MPlug& plug, MDataBlock& data )
{
MStatus stat;
if ( plug == outputCurves )
{
MDataHandle numCurvesHandle = data.inputValue(numCurves, &stat);
PERRORfail(stat, "multiCurve::compute getting numCurves");
int num = numCurvesHandle.asLong();
MDataHandle curveOffsetHandle = data.inputValue(curveOffset, &stat);
PERRORfail(stat, "multiCurve::compute getting curveOffset");
double baseOffset = curveOffsetHandle.asDouble();
MDataHandle inputCurveHandle = data.inputValue(inputCurve, &stat);
PERRORfail(stat, "multiCurve::compute getting inputCurve");
MObject inputCurveObject ( inputCurveHandle.asNurbsCurveTransformed() );
MFnNurbsCurve inCurveFS ( inputCurveObject );
MArrayDataHandle outputArray = data.outputArrayValue(outputCurves,
&stat);
PERRORfail(stat, "multiCurve::compute getting output data handle");
// Create an array data build that is preallocated to hold just
// the number of curves we plan on creating. When this builder
// is set in to the MArrayDataHandle at the end of the compute
// method, the new array will replace the existing array in the
// scene.
//
// If the number of elements of the multi does not change between
// compute cycles, then one can reuse the space allocated on a
// previous cycle by extracting the existing builder from the
// MArrayDataHandle:
// MArrayDataBuilder builder( outputArray.builder(&stat) );
// this later form of the builder will allow you to rewrite elements
// of the array, and to grow it, but the array can only be shrunk by
// explicitly removing elements with the method
// MArrayDataBuilder::removeElement(unsigned index);
//
MArrayDataBuilder builder(outputCurves, num, &stat);
PERRORfail(stat, "multiCurve::compute creating builder");
for (int curveNum = 0; curveNum < num; curveNum++) {
MDataHandle outHandle = builder.addElement(curveNum);
MFnNurbsCurveData dataCreator;
MObject outCurveData = dataCreator.create();
MObject outputCurve = inCurveFS.copy(inputCurveObject,
outCurveData, &stat);
PERRORfail(stat, "multiCurve::compute copying curve");
MFnNurbsCurve outCurveFS ( outputCurve );
MPointArray cvs;
double offset = baseOffset * (curveNum+1);
outCurveFS.getCVs ( cvs, MSpace::kWorld );
int numCVs = cvs.length();
for (int i = 0; i < numCVs; i++) {
cvs[i].x += offset;
}
outCurveFS.setCVs ( cvs );
outHandle.set(outCurveData);
}
// Set the builder back into the output array. This statement
// is always required, no matter what constructor was used to
// create the builder.
stat = outputArray.set(builder);
PERRORfail(stat, "multiCurve::compute setting the builder");
// Since we compute all the elements of the array, instead of
// just marking the plug we were asked to compute as clean, mark
// every element of the array as clean to prevent further calls
// to this compute method during this DG evaluation cycle.
stat = outputArray.setAllClean();
PERRORfail(stat, "multiCurve::compute cleaning outputCurves");
} else {
return MS::kUnknownParameter;
}
return stat;
}
