MObject fullLoft::loft( MArrayDataHandle &inputArray, MObject &newSurfData,
MStatus &stat )
{
MFnNurbsSurface surfFn;
MPointArray cvs;
MDoubleArray ku, kv;
int i, j;
int numCVs;
int numCurves = inputArray.elementCount ();
// Ensure that we have at least 1 element in the input array
// We must not do an inputValue on an element that does not
// exist.
if ( numCurves < 1 )
return MObject::kNullObj;
// Count the number of CVs
inputArray.jumpToElement(0);
MDataHandle elementHandle = inputArray.inputValue(&stat);
if (!stat) {
stat.perror("fullLoft::loft: inputValue");
return MObject::kNullObj;
}
MObject countCurve (elementHandle.asNurbsCurve());
MFnNurbsCurve countCurveFn (countCurve);
numCVs = countCurveFn.numCVs (&stat);
PERRORnull("fullLoft::loft counting CVs");
// Create knot vectors for U and V
// U dimension contains one CV from each curve, triple knotted
for (i = 0; i < numCurves; i++)
{
ku.append (double (i));
ku.append (double (i));
ku.append (double (i));
}
// V dimension contains all of the CVs from one curve, triple knotted at
// the ends
kv.append( 0.0 );
kv.append( 0.0 );
kv.append( 0.0 );
for ( i = 1; i < numCVs - 3; i ++ )
kv.append( (double) i );
kv.append( numCVs-3 );
kv.append( numCVs-3 );
kv.append( numCVs-3 );
// Build the surface's CV array
for (int curveNum = 0; curveNum < numCurves; curveNum++)
{
MObject curve (inputArray.inputValue ().asNurbsCurve ());
MFnNurbsCurve curveFn (curve);
MPointArray curveCVs;
stat = curveFn.getCVs (curveCVs, MSpace::kWorld);
PERRORnull("fullLoft::loft getting CVs");
if (curveCVs.length() != (unsigned)numCVs)
stat = MS::kFailure;
PERRORnull("fullLoft::loft inconsistent number of CVs - rebuild curves");
// Triple knot for every curve but the first
int repeats = (curveNum == 0) ? 1 : 3;
for (j = 0; j < repeats; j++)
for ( i = 0; i < numCVs; i++ )
cvs.append (curveCVs [i]);
stat = inputArray.next ();
}
MObject surf = surfFn.create(cvs, ku, kv, 3, 3,
MFnNurbsSurface::kOpen,
MFnNurbsSurface::kOpen,
false, newSurfData, &stat );
PERRORnull ("fullLoft::Loft create surface");
return surf;
}
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 closestPointOnCurveNode::compute(const MPlug &plug, MDataBlock &data)
{
// DO THE COMPUTE ONLY FOR THE *OUTPUT* PLUGS THAT ARE DIRTIED:
if ((plug == aPosition) || (plug == aPositionX) || (plug == aPositionY) || (plug == aPositionZ)
|| (plug == aNormal) || (plug == aNormalX) || (plug == aNormalY) || (plug == aNormalZ)
|| (plug == aTangent) || (plug == aTangentX) || (plug == aTangentY) || (plug == aTangentZ)
|| (plug == aParamU) || (plug == aDistance))
{
// READ IN ".inCurve" DATA:
MDataHandle inCurveDataHandle = data.inputValue(aInCurve);
MObject inCurve = inCurveDataHandle.asNurbsCurve();
// READ IN ".inPositionX" DATA:
MDataHandle inPositionXDataHandle = data.inputValue(aInPositionX);
double inPositionX = inPositionXDataHandle.asDouble();
// READ IN ".inPositionY" DATA:
MDataHandle inPositionYDataHandle = data.inputValue(aInPositionY);
double inPositionY = inPositionYDataHandle.asDouble();
// READ IN ".inPositionZ" DATA:
MDataHandle inPositionZDataHandle = data.inputValue(aInPositionZ);
double inPositionZ = inPositionZDataHandle.asDouble();
// GET THE CLOSEST POSITION, NORMAL, TANGENT, PARAMETER-U AND DISTANCE:
MPoint inPosition(inPositionX, inPositionY, inPositionZ), position;
MVector normal, tangent;
double paramU, distance;
MDagPath dummyDagPath;
closestTangentUAndDistance(dummyDagPath, inPosition, position, normal, tangent, paramU, distance, inCurve);
// WRITE OUT ".position" DATA:
MDataHandle positionDataHandle = data.outputValue(aPosition);
positionDataHandle.set(position.x, position.y, position.z);
data.setClean(plug);
// WRITE OUT ".normal" DATA:
MDataHandle normalDataHandle = data.outputValue(aNormal);
normalDataHandle.set(normal.x, normal.y, normal.z);
data.setClean(plug);
// WRITE OUT ".tangent" DATA:
MDataHandle tangentDataHandle = data.outputValue(aTangent);
tangentDataHandle.set(tangent.x, tangent.y, tangent.z);
data.setClean(plug);
// WRITE OUT ".paramU" DATA:
MDataHandle paramUDataHandle = data.outputValue(aParamU);
paramUDataHandle.set(paramU);
data.setClean(plug);
// WRITE OUT ".distance" DATA:
MDataHandle distanceDataHandle = data.outputValue(aDistance);
distanceDataHandle.set(distance);
data.setClean(plug);
}
else
{
return MS::kUnknownParameter;
}
return MS::kSuccess;
}
MStatus sgHair_controlJoint::compute( const MPlug& plug, MDataBlock& data )
{
MStatus status;
MDataHandle hStaticRotation = data.inputValue( aStaticRotation );
m_bStaticRotation = hStaticRotation.asBool();
if( m_isDirtyMatrix )
{
MDataHandle hInputBaseCurveMatrix = data.inputValue( aInputBaseCurveMatrix );
m_mtxBaseCurve = hInputBaseCurveMatrix.asMatrix();
}
if( m_isDirtyParentMatrixBase )
{
MDataHandle hJointParenBasetMatrix = data.inputValue( aJointParentBaseMatrix );
m_mtxJointParentBase = hJointParenBasetMatrix.asMatrix();
}
if( m_isDirtyCurve || m_isDirtyParentMatrixBase )
{
MDataHandle hInputBaseCurve = data.inputValue( aInputBaseCurve );
MFnNurbsCurve fnCurve = hInputBaseCurve.asNurbsCurve();
fnCurve.getCVs( m_cvs );
getJointPositionBaseWorld();
}
if( m_isDirtyGravityOption || m_isDirtyCurve || m_isDirtyParentMatrixBase )
{
MDataHandle hGravityParam = data.inputValue( aGravityParam );
MDataHandle hGravityRange = data.inputValue( aGravityRange );
MDataHandle hGravityWeight = data.inputValue( aGravityWeight );
MDataHandle hGravityOffsetMatrix = data.inputValue( aGravityOffsetMatrix );
m_paramGravity = hGravityParam.asDouble();
m_rangeGravity = hGravityRange.asDouble();
m_weightGravity = hGravityWeight.asDouble();
m_mtxGravityOffset = hGravityOffsetMatrix.asMatrix();
m_mtxGravityOffset( 3,0 ) = 0.0;
m_mtxGravityOffset( 3,1 ) = 0.0;
m_mtxGravityOffset( 3,2 ) = 0.0;
setGravityJointPositionWorld();
}
setOutput();
MArrayDataHandle hArrOutput = data.outputValue( aOutput );
MArrayDataBuilder builderOutput( aOutput, m_cvs.length() );
for( int i=0; i< m_cvs.length(); i++ )
{
MDataHandle hOutput = builderOutput.addElement( i );
MDataHandle hOutTrans = hOutput.child( aOutTrans );
MDataHandle hOutOrient = hOutput.child( aOutOrient );
hOutTrans.set( m_vectorArrTransJoint[i] );
hOutOrient.set( m_vectorArrRotateJoint[i] );
}
hArrOutput.set( builderOutput );
hArrOutput.setAllClean();
data.setClean( plug );
m_isDirtyMatrix = false;
m_isDirtyCurve = false;
m_isDirtyGravityOption = false;
m_isDirtyParentMatrixBase = false;
return MS::kSuccess;
}
