void rigidBodyNode::clearContactInfo()
{
MObject thisObject(thisMObject());
// contactCount
m_contactCount = 0;
MPlug plugContactCount(thisObject, rigidBodyNode::oa_contactCount);
plugContactCount.setValue(m_contactCount);
// contactName
MStringArray stringArray;
stringArray.clear();
MFnStringArrayData stringArrayData;
MObject strArrObject = stringArrayData.create(stringArray);
MPlug plugContactName(thisObject, rigidBodyNode::oa_contactName);
if ( !plugContactName.isNull() )
plugContactName.setValue(strArrObject);
// contactPosition
MPlug plugContactPosition(thisObject, rigidBodyNode::oa_contactPosition);
bool isArray = plugContactPosition.isArray();
MVectorArray vectorArray;
vectorArray.clear();
MFnVectorArrayData vectorArrayData;
MObject arrObject = vectorArrayData.create(vectorArray);
if ( !plugContactPosition.isNull() )
plugContactPosition.setValue(arrObject);
}
void rigidBodyNode::addContactInfo(const MString& contactObjectName, const MVector& point)
{
MObject thisObject(thisMObject());
// contactCount
m_contactCount++;
MPlug plugContactCount(thisObject, rigidBodyNode::oa_contactCount);
plugContactCount.setValue(m_contactCount);
// contactName
MPlug plugContactName(thisObject, rigidBodyNode::oa_contactName);
if ( !plugContactName.isNull() )
{
MObject strArrObject;
plugContactName.getValue(strArrObject);
MFnStringArrayData stringArrayData(strArrObject);
MStringArray stringArray = stringArrayData.array();
stringArray.append(contactObjectName);
MFnStringArrayData newStringArrayData;
MObject newStrArrObject = newStringArrayData.create(stringArray);
plugContactName.setValue(newStrArrObject);
}
// contactPosition
MPlug plugContactPosition(thisObject, rigidBodyNode::oa_contactPosition);
if ( !plugContactPosition.isNull() )
{
MObject arrObject;
plugContactPosition.getValue(arrObject);
MFnVectorArrayData vectorArrayData(arrObject);
MVectorArray vectorArray = vectorArrayData.array();
vectorArray.append(point);
MFnVectorArrayData newVectorArrayData;
MObject newArrObject = newVectorArrayData.create(vectorArray);
plugContactPosition.setValue(newArrObject);
}
}
void ProxyViz::saveInternal()
{
AHelper::Info<MString>("prxnode save internal", MFnDependencyNode(thisMObject()).name() );
updateNumPlants();
const unsigned n = numPlants();
AHelper::Info<unsigned>("num plants", n );
if(n<1) return;
MPointArray plantTms;
MIntArray plantIds;
MIntArray plantTris;
MVectorArray plantCoords;
MVectorArray plantOffsets;
savePlants(plantTms, plantIds, plantTris, plantCoords, plantOffsets);
MFnPointArrayData tmFn;
MObject otm = tmFn.create(plantTms);
MPlug tmPlug(thisMObject(), aplantTransformCache);
tmPlug.setValue(otm);
MFnIntArrayData idFn;
MObject oid = idFn.create(plantIds);
MPlug idPlug(thisMObject(), aplantIdCache);
idPlug.setValue(oid);
MFnIntArrayData triFn;
MObject otri = idFn.create(plantTris);
MPlug triPlug(thisMObject(), aplantTriangleIdCache);
triPlug.setValue(otri);
MFnVectorArrayData crdFn;
MObject ocrd = crdFn.create(plantCoords);
MPlug crdPlug(thisMObject(), aplantTriangleCoordCache);
crdPlug.setValue(ocrd);
MFnVectorArrayData cotFn;
MObject ocot = cotFn.create(plantOffsets);
MPlug cotPlug(thisMObject(), aplantOffsetCache);
cotPlug.setValue(ocot);
}
MStatus dynExprField::compute(const MPlug& plug, MDataBlock& block)
//
// Descriptions:
// compute output force.
//
{
MStatus status;
if( !(plug == mOutputForce) )
return( MS::kUnknownParameter );
// get the logical index of the element this plug refers to.
//
int multiIndex = plug.logicalIndex( &status );
McheckErr(status, "ERROR in plug.logicalIndex.\n");
// Get input data handle, use outputArrayValue since we do not
// want to evaluate both inputs, only the one related to the
// requested multiIndex. Evaluating both inputs at once would cause
// a dependency graph loop.
MArrayDataHandle hInputArray = block.outputArrayValue( mInputData, &status );
McheckErr(status,"ERROR in hInputArray = block.outputArrayValue().\n");
status = hInputArray.jumpToElement( multiIndex );
McheckErr(status, "ERROR: hInputArray.jumpToElement failed.\n");
// get children of aInputData.
MDataHandle hCompond = hInputArray.inputValue( &status );
McheckErr(status, "ERROR in hCompond=hInputArray.inputValue\n");
MDataHandle hPosition = hCompond.child( mInputPositions );
MObject dPosition = hPosition.data();
MFnVectorArrayData fnPosition( dPosition );
MVectorArray points = fnPosition.array( &status );
McheckErr(status, "ERROR in fnPosition.array(), not find points.\n");
// Comment out the following since velocity, and mass are
// not needed in this field.
//
// MDataHandle hVelocity = hCompond.child( mInputVelocities );
// MObject dVelocity = hVelocity.data();
// MFnVectorArrayData fnVelocity( dVelocity );
// MVectorArray velocities = fnVelocity.array( &status );
// McheckErr(status, "ERROR in fnVelocity.array(), not find velocities.\n");
//
// MDataHandle hMass = hCompond.child( mInputMass );
// MObject dMass = hMass.data();
// MFnDoubleArrayData fnMass( dMass );
// MDoubleArray masses = fnMass.array( &status );
// McheckErr(status, "ERROR in fnMass.array(), not find masses.\n");
// The attribute mInputPPData contains the attribute in an array form
// parpared by the particleShape if the particleShape has per particle
// attribute fieldName_attrName.
//
// Suppose a field with the name dynExprField1 is connecting to
// particleShape1, and the particleShape1 has per particle float attribute
// dynExprField1_magnitude and vector attribute dynExprField1_direction,
// then hInputPPArray will contains a MdoubleArray with the corresponding
// name "magnitude" and a MvectorArray with the name "direction". This
// is a mechanism to allow the field attributes being driven by dynamic
// expression.
MArrayDataHandle mhInputPPData = block.inputArrayValue( mInputPPData, &status );
McheckErr(status,"ERROR in mhInputPPData = block.inputArrayValue().\n");
status = mhInputPPData.jumpToElement( multiIndex );
McheckErr(status, "ERROR: mhInputPPArray.jumpToElement failed.\n");
MDataHandle hInputPPData = mhInputPPData.inputValue( &status );
McheckErr(status, "ERROR in hInputPPData = mhInputPPData.inputValue\n");
MObject dInputPPData = hInputPPData.data();
MFnArrayAttrsData inputPPArray( dInputPPData );
MDataHandle hOwnerPPData = block.inputValue( mOwnerPPData, &status );
McheckErr(status, "ERROR in hOwnerPPData = block.inputValue\n");
MObject dOwnerPPData = hOwnerPPData.data();
MFnArrayAttrsData ownerPPArray( dOwnerPPData );
const MString magString("magnitude");
MFnArrayAttrsData::Type doubleType(MFnArrayAttrsData::kDoubleArray);
bool arrayExist;
MDoubleArray magnitudeArray;
arrayExist = inputPPArray.checkArrayExist(magString, doubleType, &status);
// McheckErr(status, "ERROR in checkArrayExist(magnitude)\n");
if(arrayExist) {
magnitudeArray = inputPPArray.getDoubleData(magString, &status);
// McheckErr(status, "ERROR in inputPPArray.doubleArray(magnitude)\n");
}
MDoubleArray magnitudeOwnerArray;
arrayExist = ownerPPArray.checkArrayExist(magString, doubleType, &status);
// McheckErr(status, "ERROR in checkArrayExist(magnitude)\n");
if(arrayExist) {
magnitudeOwnerArray = ownerPPArray.getDoubleData(magString, &status);
// McheckErr(status, "ERROR in ownerPPArray.doubleArray(magnitude)\n");
}
const MString dirString("direction");
MFnArrayAttrsData::Type vectorType(MFnArrayAttrsData::kVectorArray);
arrayExist = inputPPArray.checkArrayExist(dirString, vectorType, &status);
MVectorArray directionArray;
// McheckErr(status, "ERROR in checkArrayExist(direction)\n");
if(arrayExist) {
directionArray = inputPPArray.getVectorData(dirString, &status);
// McheckErr(status, "ERROR in inputPPArray.vectorArray(direction)\n");
}
arrayExist = ownerPPArray.checkArrayExist(dirString, vectorType, &status);
MVectorArray directionOwnerArray;
// McheckErr(status, "ERROR in checkArrayExist(direction)\n");
if(arrayExist) {
directionOwnerArray = ownerPPArray.getVectorData(dirString, &status);
// McheckErr(status, "ERROR in ownerPPArray.vectorArray(direction)\n");
}
// Compute the output force.
//
MVectorArray forceArray;
apply( block, points.length(), magnitudeArray, magnitudeOwnerArray,
directionArray, directionOwnerArray, forceArray );
// get output data handle
//
MArrayDataHandle hOutArray = block.outputArrayValue( mOutputForce, &status);
McheckErr(status, "ERROR in hOutArray = block.outputArrayValue.\n");
MArrayDataBuilder bOutArray = hOutArray.builder( &status );
McheckErr(status, "ERROR in bOutArray = hOutArray.builder.\n");
// get output force array from block.
//
MDataHandle hOut = bOutArray.addElement(multiIndex, &status);
McheckErr(status, "ERROR in hOut = bOutArray.addElement.\n");
MFnVectorArrayData fnOutputForce;
MObject dOutputForce = fnOutputForce.create( forceArray, &status );
McheckErr(status, "ERROR in dOutputForce = fnOutputForce.create\n");
// update data block with new output force data.
//
hOut.set( dOutputForce );
block.setClean( plug );
return( MS::kSuccess );
}
MString CBPoseSpaceCmd::cacheResult(const MPointArray& bindPoints, const MPointArray& posePoints, const MVectorArray& dx, const MVectorArray& dy, const MVectorArray& dz)
{
MDGModifier modif;
MObject opose = modif.createNode("sculptSpaceRecord");
modif.doIt();
unsigned count = dx.length();
MVectorArray row0Array;
row0Array.setLength(count);
MVectorArray row1Array;
row1Array.setLength(count);
MVectorArray row2Array;
row2Array.setLength(count);
MVectorArray row3Array;
row3Array.setLength(count);
MVectorArray bndArray;
bndArray.setLength(count);
MVectorArray posArray;
posArray.setLength(count);
float m[4][4];
for(unsigned i=0; i < count; i++) {
m[0][0] = dx[i].x;
m[0][1] = dx[i].y;
m[0][2] = dx[i].z;
m[0][3] = 0.f;
m[1][0] = dy[i].x;
m[1][1] = dy[i].y;
m[1][2] = dy[i].z;
m[1][3] = 0.f;
m[2][0] = dz[i].x;
m[2][1] = dz[i].y;
m[2][2] = dz[i].z;
m[2][3] = 0.f;
m[3][0] = 0.f;
m[3][1] = 0.f;
m[3][2] = 0.f;
m[3][3] = 1.f;
MMatrix tm(m);
tm = tm.inverse();
tm.get(m);
row0Array[i].x = m[0][0];
row0Array[i].y = m[0][1];
row0Array[i].z = m[0][2];
row1Array[i].x = m[1][0];
row1Array[i].y = m[1][1];
row1Array[i].z = m[1][2];
row2Array[i].x = m[2][0];
row2Array[i].y = m[2][1];
row2Array[i].z = m[2][2];
row3Array[i].x = m[3][0];
row3Array[i].y = m[3][1];
row3Array[i].z = m[3][2];
bndArray[i] = bindPoints[i];
posArray[i] = posePoints[i];
}
MFnDependencyNode fposec(opose);
MStatus stat;
MPlug pspacerow0 = fposec.findPlug("poseSpaceRow0", false, &stat);
MPlug pspacerow1 = fposec.findPlug("poseSpaceRow1", false, &stat);
MPlug pspacerow2 = fposec.findPlug("poseSpaceRow2", false, &stat);
MPlug pspacerow3 = fposec.findPlug("poseSpaceRow3", false, &stat);
MPlug pbind = fposec.findPlug("bpnt", false, &stat);
MPlug ppose = fposec.findPlug("ppnt", false, &stat);
MFnVectorArrayData frow0;
MObject orow0 = frow0.create(row0Array);
pspacerow0.setMObject(orow0);
MFnVectorArrayData frow1;
MObject orow1 = frow1.create(row1Array);
pspacerow1.setMObject(orow1);
MFnVectorArrayData frow2;
MObject orow2 = frow2.create(row2Array);
pspacerow2.setMObject(orow2);
MFnVectorArrayData frow3;
MObject orow3 = frow3.create(row3Array);
pspacerow3.setMObject(orow3);
MFnVectorArrayData fbind;
MObject obind = fbind.create(bndArray);
pbind.setMObject(obind);
MFnVectorArrayData fpose;
MObject oposed = fpose.create(posArray);
ppose.setMObject(oposed);
return fposec.name();
}
MStatus liqAttachPrefAttribute::redoIt()
{
MFnTypedAttribute tAttr;
MStatus status;
for ( unsigned i( 0 ); i < objectNames.length(); i++ )
{
MSelectionList nodeList;
nodeList.add( objectNames[i] );
MObject depNodeObj;
nodeList.getDependNode( 0, depNodeObj );
MDagPath dagNode;
nodeList.getDagPath( 0, dagNode );
MFnDependencyNode depNode( depNodeObj );
MObject prefAttr;
MString attrName, varName;
// make sure the renderer description is up to date
liqglo.liquidRenderer.setRenderer();
// build the name of the attribute
varName = ( ( exportN && depNodeObj.hasFn( MFn::kMesh ) )? "N":"P" );
attrName = "rman";
attrName += varName;
attrName += ( ( liqglo.liquidRenderer.requires__PREF )? "__":"" );
attrName += varName + "ref";
// create the attribute
prefAttr = tAttr.create( attrName, attrName, MFnData::kPointArray );
if ( depNodeObj.hasFn( MFn::kNurbsSurface ) )
{
MFnNurbsSurface nodeFn( depNodeObj );
MPointArray nodePArray;
MItSurfaceCV cvs( dagNode, MObject::kNullObj, liqglo.liquidRenderer.requires_SWAPPED_UVS == false, &status );
while( !cvs.isDone() )
{
while( !cvs.isRowDone() )
{
MPoint pt = (worldSpace)? cvs.position( MSpace::kWorld ) : cvs.position( MSpace::kObject );
nodePArray.append( pt );
cvs.next();
}
cvs.nextRow();
}
nodeFn.addAttribute( prefAttr );
MFnPointArrayData pArrayData;
MObject prefDefault = pArrayData.create( nodePArray );
MPlug nodePlug( depNodeObj, prefAttr );
nodePlug.setValue( prefDefault );
}
else if ( depNodeObj.hasFn( MFn::kNurbsCurve ) )
{
// Carsten: added support for PREF on nurbs curves
//
MFnNurbsCurve nodeFn( depNodeObj );
MPointArray nodePArray;
nodeFn.getCVs( nodePArray );
nodeFn.addAttribute( prefAttr );
MFnPointArrayData pArrayData;
MObject prefDefault = pArrayData.create( nodePArray );
MPlug nodePlug( depNodeObj, prefAttr );
nodePlug.setValue( prefDefault );
}
else if ( depNodeObj.hasFn( MFn::kMesh ) )
{
MFnMesh nodeFn( depNodeObj );
// Moritz: modified this line to dim nodePArray -- otherwise
// nodePArray.set() in the wile loop below throws an exception
// which was why __Pref didn't work
MPointArray nodePArray( MFnMesh( depNodeObj ).numVertices() );
unsigned count;
nodeFn.addAttribute( prefAttr );
if ( exportN )
{
// export Nref
unsigned vertex;
unsigned normal;
unsigned face = 0;
unsigned faceVertex = 0;
unsigned int numNormals = nodeFn.numNormals();
unsigned int numPoints = nodeFn.numVertices();
MFloatVectorArray normals;
MVectorArray normalAttArray;
nodeFn.getNormals( normals );
if ( numNormals > numPoints )
{
// if we get more than 1 normal per vertex,
// force the arraysize to the full facevarying size
unsigned faceVaryingCount( 0 );
for ( unsigned pOn( 0 ); pOn < nodeFn.numPolygons(); pOn++ )
faceVaryingCount += nodeFn.polygonVertexCount( pOn );
normalAttArray.setLength( faceVaryingCount );
}
else
normalAttArray.setLength(normals.length());
for ( MItMeshPolygon polyIt ( depNodeObj ); polyIt.isDone() == false; polyIt.next() )
{
count = polyIt.polygonVertexCount();
while ( count > 0 )
{
--count;
normal = polyIt.normalIndex( count );
vertex = polyIt.vertexIndex( count );
if( numNormals == numPoints )
normalAttArray.set(normals[normal], vertex);
else
normalAttArray.set(normals[normal], faceVertex);
++faceVertex;
}
++face;
}
MFnVectorArrayData pArrayData;
MObject prefDefault = pArrayData.create( normalAttArray );
MPlug nodePlug( depNodeObj, prefAttr );
nodePlug.setValue( prefDefault );
}
else
{
// TODO: do we need to account for the altMeshExport algo that's
// used in liquidRibMeshData?
// Moritz: no, it's basically the same as the algo below
for ( MItMeshPolygon polyIt( dagNode, MObject::kNullObj ); !polyIt.isDone(); polyIt.next())
{
count = polyIt.polygonVertexCount();
while ( count > 0 )
{
--count;
unsigned vertexIndex = polyIt.vertexIndex( count );
MPoint nodePoint = (worldSpace)? polyIt.point( count, MSpace::kWorld ) : polyIt.point( count, MSpace::kObject );
// Moritz: this returns MS::kFailure but seems to work?!
nodePArray.set( nodePoint, vertexIndex );
}
}
MFnPointArrayData pArrayData;
MObject prefDefault = pArrayData.create( nodePArray );
MPlug nodePlug( depNodeObj, prefAttr );
nodePlug.setValue( prefDefault );
}
} else cerr << "Neither a Nurbs nor a Mesh !!" << endl;
}
return MS::kSuccess;
}
MStatus ProxyViz::initialize()
{
MFnNumericAttribute numFn;
MStatus stat;
alodgatehigh = numFn.create( "lodGateMax", "ldmx", MFnNumericData::kFloat, 1.f);
numFn.setKeyable(true);
numFn.setStorable(true);
numFn.setMin(0.001f);
numFn.setMax(2.f);
addAttribute(alodgatehigh);
alodgatelow = numFn.create( "lodGateMin", "ldmin", MFnNumericData::kFloat, 0.f);
numFn.setKeyable(true);
numFn.setStorable(true);
numFn.setMin(0.f);
numFn.setMax(0.999f);
addAttribute(alodgatelow);
abboxminx = numFn.create( "bBoxMinX", "bbmnx", MFnNumericData::kFloat, -1.f );
numFn.setKeyable(true);
numFn.setStorable(true);
addAttribute(abboxminx);
abboxminy = numFn.create( "bBoxMinY", "bbmny", MFnNumericData::kFloat, -1.f );
numFn.setKeyable(true);
numFn.setStorable(true);
addAttribute(abboxminy);
abboxminz = numFn.create( "bBoxMinZ", "bbmnz", MFnNumericData::kFloat, -1.f );
numFn.setKeyable(true);
numFn.setStorable(true);
addAttribute(abboxminz);
abboxmaxx = numFn.create( "bBoxMaxX", "bbmxx", MFnNumericData::kFloat, 1.f );
numFn.setKeyable(true);
numFn.setStorable(true);
addAttribute(abboxmaxx);
abboxmaxy = numFn.create( "bBoxMaxY", "bbmxy", MFnNumericData::kFloat, 1.f);
numFn.setKeyable(true);
numFn.setStorable(true);
addAttribute(abboxmaxy);
abboxmaxz = numFn.create( "bBoxMaxZ", "bbmxz", MFnNumericData::kFloat, 1.f);
numFn.setKeyable(true);
numFn.setStorable(true);
addAttribute(abboxmaxz);
aradiusMult = numFn.create( "radiusMultiplier", "rml", MFnNumericData::kFloat);
numFn.setStorable(true);
numFn.setKeyable(true);
numFn.setDefault(1.f);
numFn.setMin(.05f);
addAttribute(aradiusMult);
axmultiplier = numFn.create( "visualMultiplierX", "vmx", MFnNumericData::kFloat, 1.f);
numFn.setKeyable(true);
numFn.setStorable(true);
numFn.setMin(0.001f);
addAttribute(axmultiplier);
aymultiplier = numFn.create( "visualMultiplierY", "vmy", MFnNumericData::kFloat, 1.f);
numFn.setKeyable(true);
numFn.setStorable(true);
numFn.setMin(0.001f);
addAttribute(aymultiplier);
azmultiplier = numFn.create( "visualMultiplierZ", "vmz", MFnNumericData::kFloat, 1.f);
numFn.setKeyable(true);
numFn.setStorable(true);
numFn.setMin(0.001f);
addAttribute(azmultiplier);
agroupcount = numFn.create( "numberInstances", "nis", MFnNumericData::kInt, 1);
numFn.setKeyable(false);
numFn.setStorable(true);
numFn.setMin(1);
addAttribute(agroupcount);
ainstanceId = numFn.create( "instanceId", "iis", MFnNumericData::kInt, 0);
numFn.setKeyable(false);
numFn.setStorable(true);
numFn.setMin(0);
addAttribute(ainstanceId);
MFnTypedAttribute typedAttrFn;
MVectorArray defaultVectArray;
MFnVectorArrayData vectArrayDataFn;
vectArrayDataFn.create( defaultVectArray );
outPositionPP = typedAttrFn.create( "outPosition",
"opos",
MFnData::kVectorArray,
vectArrayDataFn.object(),
&stat );
if(!stat) MGlobal::displayWarning("failed create pospp");
typedAttrFn.setStorable(false);
if(addAttribute( outPositionPP ) != MS::kSuccess) MGlobal::displayWarning("failed add pospp");
outScalePP = typedAttrFn.create( "outScale",
"oscl",
MFnData::kVectorArray,
vectArrayDataFn.object(),
&stat );
if(!stat) MGlobal::displayWarning("failed create sclpp");
typedAttrFn.setStorable(false);
if(addAttribute(outScalePP) != MS::kSuccess) MGlobal::displayWarning("failed add sclpp");
outRotationPP = typedAttrFn.create( "outRotation",
"orot",
MFnData::kVectorArray,
vectArrayDataFn.object(),
&stat );
if(!stat) MGlobal::displayWarning("failed create rotpp");
typedAttrFn.setStorable(false);
if(addAttribute(outRotationPP) != MS::kSuccess) MGlobal::displayWarning("failed add rotpp");
MDoubleArray defaultDArray;
MFnDoubleArrayData dArrayDataFn;
dArrayDataFn.create( defaultDArray );
outReplacePP = typedAttrFn.create( "outReplace", "orpl",
MFnData::kDoubleArray, dArrayDataFn.object(),
&stat );
if(stat != MS::kSuccess) {
MGlobal::displayWarning("failed create outReplace");
}
typedAttrFn.setStorable(false);
stat = addAttribute(outReplacePP);
if(stat != MS::kSuccess) {
MGlobal::displayWarning("failed add outReplace");
}
outValue = numFn.create( "outValue", "ov", MFnNumericData::kFloat );
numFn.setStorable(false);
numFn.setWritable(false);
addAttribute(outValue);
outValue1 = numFn.create( "outValue1", "ov1", MFnNumericData::kFloat );
numFn.setStorable(false);
numFn.setWritable(false);
addAttribute(outValue1);
MFnTypedAttribute stringAttr;
acachename = stringAttr.create( "cachePath", "cp", MFnData::kString );
stringAttr.setStorable(true);
addAttribute( acachename );
astandinNames = stringAttr.create( "standinNames", "sdn", MFnData::kString );
stringAttr.setStorable(true);
stringAttr.setArray(true);
addAttribute(astandinNames);
MFnMatrixAttribute matAttr;
acameraspace = matAttr.create( "cameraSpace", "cspc", MFnMatrixAttribute::kDouble );
matAttr.setStorable(false);
matAttr.setWritable(true);
matAttr.setConnectable(true);
addAttribute(acameraspace);
ahapeture = numFn.create( "horizontalFilmAperture", "hfa", MFnNumericData::kDouble, 1.0 );
numFn.setStorable(false);
numFn.setConnectable(true);
addAttribute( ahapeture );
avapeture = numFn.create( "verticalFilmAperture", "vfa", MFnNumericData::kDouble, 1.0 );
numFn.setStorable(false);
numFn.setConnectable(true);
addAttribute( avapeture );
afocallength = numFn.create( "focalLength", "fl", MFnNumericData::kDouble );
numFn.setStorable(false);
numFn.setConnectable(true);
addAttribute( afocallength );
aconvertPercentage = numFn.create( "convertPercentage", "cvp", MFnNumericData::kDouble );
numFn.setStorable(false);
numFn.setConnectable(true);
numFn.setDefault(1.0);
numFn.setMax(1.0);
numFn.setMin(0.01);
addAttribute(aconvertPercentage);
agroundMesh = typedAttrFn.create("groundMesh", "grdm", MFnMeshData::kMesh);
typedAttrFn.setStorable(false);
typedAttrFn.setWritable(true);
typedAttrFn.setConnectable(true);
typedAttrFn.setArray(true);
typedAttrFn.setDisconnectBehavior(MFnAttribute::kDelete);
addAttribute( agroundMesh );
attributeAffects(agroundMesh, outValue);
agroundSpace = matAttr.create("groundSpace", "grdsp", MFnMatrixAttribute::kDouble);
matAttr.setStorable(false);
matAttr.setWritable(true);
matAttr.setConnectable(true);
matAttr.setArray(true);
matAttr.setDisconnectBehavior(MFnAttribute::kDelete);
addAttribute( agroundSpace );
attributeAffects(agroundSpace, outValue);
MPointArray defaultPntArray;
MFnPointArrayData pntArrayDataFn;
pntArrayDataFn.create( defaultPntArray );
aplantTransformCache = typedAttrFn.create( "transformCachePlant",
"tmcpl",
MFnData::kPointArray,
pntArrayDataFn.object(),
&stat );
typedAttrFn.setStorable(true);
addAttribute(aplantTransformCache);
MIntArray defaultIntArray;
MFnIntArrayData intArrayDataFn;
intArrayDataFn.create( defaultIntArray );
aplantIdCache = typedAttrFn.create( "idCachePlant",
"idcpl",
MFnData::kIntArray,
intArrayDataFn.object(),
&stat );
typedAttrFn.setStorable(true);
addAttribute(aplantIdCache);
aplantTriangleIdCache = typedAttrFn.create( "triCachePlant",
"trcpl",
MFnData::kIntArray,
intArrayDataFn.object(),
&stat );
typedAttrFn.setStorable(true);
addAttribute(aplantTriangleIdCache);
aplantTriangleCoordCache = typedAttrFn.create( "coordCachePlant",
"crcpl",
MFnData::kVectorArray,
vectArrayDataFn.object(),
&stat );
typedAttrFn.setStorable(true);
addAttribute(aplantTriangleCoordCache);
aplantOffsetCache = typedAttrFn.create( "offsetCachePlant",
"otcpl",
MFnData::kVectorArray,
vectArrayDataFn.object(),
&stat );
typedAttrFn.setStorable(true);
addAttribute(aplantOffsetCache);
ainexamp = typedAttrFn.create("inExample", "ixmp", MFnData::kPlugin);
typedAttrFn.setStorable(false);
typedAttrFn.setConnectable(true);
typedAttrFn.setArray(true);
addAttribute(ainexamp);
adisplayVox = numFn.create( "showVoxelThreshold", "svt", MFnNumericData::kFloat );
numFn.setDefault(1.0);
numFn.setMin(.7);
numFn.setMax(1.0);
numFn.setStorable(true);
numFn.setKeyable(true);
addAttribute(adisplayVox);
acheckDepth = numFn.create( "checkDepth", "cdp", MFnNumericData::kBoolean );
numFn.setDefault(0);
numFn.setStorable(false);
addAttribute(acheckDepth);
ainoverscan = numFn.create( "cameraOverscan", "cos", MFnNumericData::kDouble );
numFn.setDefault(1.33);
numFn.setStorable(false);
addAttribute(ainoverscan);
aactivated = numFn.create( "activated", "act", MFnNumericData::kBoolean );
numFn.setDefault(0);
numFn.setStorable(false);
addAttribute(aactivated);
attributeAffects(ainexamp, outValue1);
attributeAffects(aradiusMult, outValue1);
attributeAffects(abboxminx, outValue);
attributeAffects(abboxmaxx, outValue);
attributeAffects(abboxminy, outValue);
attributeAffects(abboxmaxy, outValue);
attributeAffects(abboxminz, outValue);
attributeAffects(abboxmaxz, outValue);
attributeAffects(outPositionPP, outValue);
return MS::kSuccess;
}
MStatus puttyNode::deform( MDataBlock& block, MItGeometry& iter, const MMatrix& worldMatrix, unsigned int multiIndex)
{
// MGlobal::displayInfo("deform");
MStatus status = MS::kSuccess;
/////////////////////////////////////////////////////////////////////////////////////////////////
//
// get inputs
//
// get the node ready flag
MDataHandle dh = block.inputValue(aScriptSourced,&status);
SYS_ERROR_CHECK(status, "Error getting aScriptSourced data handle\n");
bool scriptSourced = dh.asBool();
if (!scriptSourced)
return MS::kSuccess;
dh = block.inputValue(aNodeReady,&status);
SYS_ERROR_CHECK(status, "Error getting node ready data handle\n");
bool nodeReady = dh.asBool();
// if it's not ready, don't do anything
if (!nodeReady)
return MS::kSuccess;
dh = block.inputValue(aDefSpace,&status);
SYS_ERROR_CHECK(status, "Error getting defSpace data handle\n");
short defSpace = dh.asShort();
dh = block.inputValue(aDefWeights,&status);
SYS_ERROR_CHECK(status, "Error getting defWeights data handle\n");
short defWeights = dh.asShort();
dh = block.inputValue(aDefEnvelope,&status);
SYS_ERROR_CHECK(status, "Error getting defEnvelope data handle\n");
short defEnvelope = dh.asShort();
// get the command
dh = block.inputValue(aCmdBaseName,&status);
SYS_ERROR_CHECK(status, "Error getting aCmdBaseName handle\n");
MString script = dh.asString();
/* if (script == "")
{
status = MS::kFailure;
USER_ERROR_CHECK(status, "no script provided!\n");
}
*/
/////////////////////////////////////////////////////////////////////////////////////////////////
//
// build mel cmd string
//
// check if it's a valid cmd
// get the envelope
//
double env = 1;
if (defEnvelope == MSD_ENVELOPE_AUTO)
{
dh = block.inputValue(envelope,&status);
SYS_ERROR_CHECK(status, "Error getting envelope data handle\n");
env = double(dh.asFloat());
// early stop 'cause there is nothing more to do
if (env == 0.0)
return MS::kSuccess;
}
// get the points, transform them into the right space if needed
//
int count = iter.count();
MVectorArray points(count);
for ( ; !iter.isDone(); iter.next())
points[iter.index()] = iter.position();
if ( defSpace == MSD_SPACE_WORLD )
{
for (int i = 0;i<count;i++)
points[i] = MPoint(points[i]) * worldMatrix;
}
// get the weights
//
MDoubleArray weights;
if ( defWeights == MSD_WEIGHTS_AUTO)
{
weights.setLength(count);
for (int i = 0;i<count;i++)
weights[i] = weightValue(block,multiIndex,i);
}
// get the object name and type
// get the input geometry, traverse through the data handles
MArrayDataHandle adh = block.outputArrayValue( input, &status );
SYS_ERROR_CHECK(status,"error getting input array data handle.\n");
status = adh.jumpToElement( multiIndex );
SYS_ERROR_CHECK(status, "input jumpToElement failed.\n");
// compound data
MDataHandle cdh = adh.inputValue( &status );
SYS_ERROR_CHECK(status, "error getting input inputValue\n");
// input geometry child
dh = cdh.child( inputGeom );
MObject dInputGeometry = dh.data();
// get the type
MString geometryType = dInputGeometry.apiTypeStr();
// get the name
// MFnDagNode dagFn( dInputGeometry, &status);
// SYS_ERROR_CHECK(status, "error converting geometry obj to dag node\n");
// MString geometryName = dagFn.fullPathName(&status);
// SYS_ERROR_CHECK(status, "error getting full path name \n");
// MString geometryType = "";
// MString geometryName = "";
/////////////////////////////////////////////////////////////////////////////////////////////////
//
// set the current values on the temp plugs for the script to be picked up
//
// the position
MObject thisNode = thisMObject();
MPlug currPlug(thisNode,aCurrPosition);
MFnVectorArrayData vecD;
MObject currObj = vecD.create(points,&status);
currPlug.setValue(currObj);
SYS_ERROR_CHECK(status, "error setting currPosPlug value\n");
// the weights
currPlug =MPlug(thisNode,aCurrWeight);
MFnDoubleArrayData dblD;
currObj = dblD.create(weights,&status);
currPlug.setValue(currObj);
SYS_ERROR_CHECK(status, "error setting currWeightsPlug value\n");
// world matrix
currPlug =MPlug(thisNode,aCurrWorldMatrix);
MFnMatrixData matD;
currObj = matD.create(worldMatrix,&status);
currPlug.setValue(currObj);
SYS_ERROR_CHECK(status, "error setting currWorldMatrixPlug value\n");
// the multi index
currPlug =MPlug(thisNode,aCurrMultiIndex);
currPlug.setValue(int(multiIndex));
SYS_ERROR_CHECK(status, "error setting currMultiIndexPlug value\n");
// geometry name/type
// currPlug =MPlug(thisNode,aCurrGeometryName);
// currPlug.setValue(geometryName);
// SYS_ERROR_CHECK(status, "error setting aCurrGeometryName value\n");
currPlug =MPlug(thisNode,aCurrGeometryType);
currPlug.setValue(geometryType);
SYS_ERROR_CHECK(status, "error setting aCurrGeometryType value\n");
/////////////////////////////////////////////////////////////////////////////////////////////////
//
// execute the mel script
//
MString melCmd = script+"(\"" +name()+"\","+count+")";
MCommandResult melResult;
status = MGlobal::executeCommand(melCmd,melResult);
// if the command did not work, then try to resource the script
// (might have been that we were in a fresh scene and nothing was ready yet
if (status != MS::kSuccess)
{
dh = block.inputValue(aScript,&status);
SYS_ERROR_CHECK(status, "Error getting aCmdBaseName handle\n");
MString scriptFile = dh.asString();
// try to source the script
MString cmd = "source \"" + scriptFile+"\"";
MCommandResult melResult;
status = MGlobal::executeCommand(cmd,melResult);
// if successfull, retry the command
if (!status.error())
{
status = MGlobal::executeCommand(melCmd,melResult);
}
}
USER_ERROR_CHECK(status, "Error executing mel command, please check the function you provided is valid, error free and has the appropriate parameters!");
// check the result type
if ((melResult.resultType()) != (MCommandResult::kDoubleArray))
{
USER_ERROR_CHECK(MS::kFailure, "result of mel command has wrong type, should be doubleArray (which will be interpreted as vectorArray)!");
}
// get the result as a double array
MDoubleArray newP;
status = melResult.getResult(newP);
USER_ERROR_CHECK(status, "Error getting result of mel command!");
int newCount = newP.length()/3;
// size check
if (newCount != count)
{
USER_ERROR_CHECK(MS::kFailure, "the size of the result does not match the size of the input!");
}
// convert the double array into a vector array
MPointArray newPoints(newCount);
for(int i=0;i<newCount;i++)
newPoints[i]=MPoint(newP[i*3],newP[i*3+1],newP[i*3+2]);
/////////////////////////////////////////////////////////////////////////////////////////////////
//
// interprete and apply the result
//
// do the envelope and weights
if ((defEnvelope == MSD_ENVELOPE_AUTO)||((defWeights == MSD_WEIGHTS_AUTO)))
{
MDoubleArray envPP(count, env);
if (defWeights == MSD_WEIGHTS_AUTO)
{
for (int i = 0;i<count;i++)
envPP[i] *= weights[i];
}
// linear interpolation between old and new points
for (int i = 0;i<count;i++)
newPoints[i] = (points[i] * (1-envPP[i])) + (newPoints[i] * envPP[i]);
}
// retransform the result if it was in world space
if ( defSpace == MSD_SPACE_WORLD )
{
MMatrix worldMatrixInv = worldMatrix.inverse();
for (int i = 0;i<count;i++)
newPoints[i] *= worldMatrixInv;
}
// set the points
iter.reset();
for ( ; !iter.isDone(); iter.next())
iter.setPosition(newPoints[iter.index()]);
return status;
}
MStatus SargassoNode::initialize()
{
MFnNumericAttribute nAttr;
MStatus status;
MFnTypedAttribute typedAttr;
MFnMatrixAttribute pimAttr;
aconstraintParentInverseMatrix = pimAttr.create( "constraintParentInvMat", "cpim", MFnMatrixAttribute::kDouble, &status );
pimAttr.setArray(true);
pimAttr.setStorable(false);
pimAttr.setDisconnectBehavior(MFnAttribute::kDelete);
status = addAttribute(aconstraintParentInverseMatrix);
if (!status) { status.perror("addAttribute parent inverse matrix"); return status;}
MFnNumericAttribute numAttr;
constraintTranslateX = numAttr.create( "constraintTranslateX", "ctx", MFnNumericData::kDouble, 0.0, &status );
if(!status) {
MGlobal::displayInfo("failed to create attrib constraintTranslateX");
return status;
}
constraintTranslateY = numAttr.create( "constraintTranslateY", "cty", MFnNumericData::kDouble, 0.0, &status );
if(!status) {
MGlobal::displayInfo("failed to create attrib constraintTranslateY");
return status;
}
constraintTranslateZ = numAttr.create( "constraintTranslateZ", "ctz", MFnNumericData::kDouble, 0.0, &status );
if(!status) {
MGlobal::displayInfo("failed to create attrib constraintTranslateY");
return status;
}
MFnUnitAttribute angleAttr;
constraintRotateX = angleAttr.create( "constraintRotateX", "crx", MFnUnitAttribute::kAngle , 0.0, &status );
if(!status) {
MGlobal::displayInfo("failed to create attrib constraintRotateX");
return status;
}
constraintRotateY = angleAttr.create( "constraintRotateY", "cry", MFnUnitAttribute::kAngle , 0.0, &status );
if(!status) {
MGlobal::displayInfo("failed to create attrib constraintRotateY");
return status;
}
constraintRotateZ = angleAttr.create( "constraintRotateZ", "crz", MFnUnitAttribute::kAngle , 0.0, &status );
if(!status) {
MGlobal::displayInfo("failed to create attrib constraintRotateY");
return status;
}
{ // Compound target(geometry,weight): array, delete on disconnect
MFnCompoundAttribute compoundAttr;
compoundOutput = compoundAttr.create( "outValue", "otv",&status );
if (!status) { status.perror("compoundAttr.create"); return status;}
status = compoundAttr.addChild( constraintTranslateX );
if (!status) { status.perror("compoundAttr.addChild tx"); return status;}
status = compoundAttr.addChild( constraintTranslateY );
if (!status) { status.perror("compoundAttr.addChild ty"); return status;}
status = compoundAttr.addChild( constraintTranslateZ );
if (!status) { status.perror("compoundAttr.addChild tz"); return status;}
compoundAttr.addChild( constraintRotateX );
compoundAttr.addChild( constraintRotateY );
compoundAttr.addChild( constraintRotateZ );
compoundAttr.setArray( true );
//status = compoundAttr.setDisconnectBehavior(MFnAttribute::kDelete);
//if (!status) { status.perror("typedAttrKeyable.setDisconnectBehavior:cgeom"); return status;}
}
status = addAttribute( compoundOutput );
if (!status) { status.perror("addAttribute"); return status;}
MPointArray defaultPntArray;
MFnPointArrayData pntArrayDataFn;
pntArrayDataFn.create( defaultPntArray );
atargetRestP = typedAttr.create( "targetRestP", "tgrp", MFnData::kPointArray, pntArrayDataFn.object());
typedAttr.setStorable(true);
addAttribute(atargetRestP);
MIntArray defaultIntArray;
MFnIntArrayData intArrayDataFn;
intArrayDataFn.create( defaultIntArray );
atargetTri = typedAttr.create( "targetTriangle", "tgtri", MFnData::kIntArray, intArrayDataFn.object());
typedAttr.setStorable(true);
addAttribute(atargetTri);
atargetBind = typedAttr.create( "targetBindId", "tgbdi", MFnData::kIntArray, intArrayDataFn.object());
typedAttr.setStorable(true);
addAttribute(atargetBind);
aobjTri = typedAttr.create( "objectTriId", "obti", MFnData::kIntArray, intArrayDataFn.object());
typedAttr.setStorable(true);
addAttribute(aobjTri);
atargetNv = numAttr.create( "targetNumV", "tgnv", MFnNumericData::kInt, 0, &status );
addAttribute(atargetNv);
atargetNt = numAttr.create( "targetNumTri", "tgnt", MFnNumericData::kInt, 0, &status );
addAttribute(atargetNt);
MVectorArray defaultVectArray;
MFnVectorArrayData vectArrayDataFn;
vectArrayDataFn.create( defaultVectArray );
aobjLocal = typedAttr.create( "objectLocalP", "oblp", MFnData::kVectorArray, vectArrayDataFn.object());
typedAttr.setStorable(true);
addAttribute(aobjLocal);
aobjN = numAttr.create( "objectCount", "obct", MFnNumericData::kInt, 0, &status );
addAttribute(aobjN);
atargetMesh = typedAttr.create("targetMesh", "tgms", MFnMeshData::kMesh, &status);
typedAttr.setStorable(false);
addAttribute(atargetMesh);
attributeAffects(atargetMesh, compoundOutput);
// attributeAffects(aconstraintParentInverseMatrix, compoundOutput);
return MS::kSuccess;
}
