//
// Description
//
// Compute the outputSurface attribute.
//
// If there is no history, use cachedSurface as the
// input surface. All tweaks will get written directly
// to it. Output is just a copy of the cached surface
// that can be connected etc.
//
public void computeOutputSurface( MPlug plug, MDataBlock datablock )
{
// Check for an input surface. The input surface, if it
// exists, is copied to the cached surface.
//
computeInputSurface( plug, datablock );
// Get a handle to the cached data
//
MDataHandle cachedHandle = datablock.outputValue( cachedSurface );
apiMeshData cached = cachedHandle.asPluginData as apiMeshData;
if ( null == cached ) {
MGlobal.displayInfo( "NULL cachedSurface data found" );
}
datablock.setClean( plug );
// Apply any vertex offsets.
//
if ( hasHistory() ) {
applyTweaks( datablock, cached.fGeometry );
}
else {
MArrayDataHandle cpHandle = datablock.inputArrayValue( mControlPoints );
cpHandle.setAllClean();
}
// Create some output data
//
MFnPluginData fnDataCreator = new MFnPluginData();
fnDataCreator.create(new MTypeId(apiMeshData.id));
apiMeshData newData = (apiMeshData)fnDataCreator.data();
// Copy the data
//
if ( null != cached ) {
newData.fGeometry = cached.fGeometry;
}
else {
MGlobal.displayInfo( "computeOutputSurface: NULL cachedSurface data" );
}
// Assign the new data to the outputSurface handle
//
MDataHandle outHandle = datablock.outputValue( outputSurface );
outHandle.set( newData );
// Update the bounding box attributes
//
computeBoundingBox( datablock );
}
//
// Description
//
// If the shape has history, apply any tweaks (offsets) made
// to the control points.
//
public void applyTweaks(MDataBlock datablock, apiMeshGeom meshGeom)
{
MArrayDataHandle cpHandle = datablock.inputArrayValue( mControlPoints );
// Loop through the component list and transform each vertex.
//
uint elemCount = cpHandle.elementCount();
for ( uint idx=0; idx<elemCount; idx++ )
{
int elemIndex = (int)cpHandle.elementIndex();
MDataHandle pntHandle = cpHandle.outputValue();
double[] pnt = pntHandle.Double3;
MVector offset = new MVector(pnt[0], pnt[1], pnt[2]);
// Apply the tweaks to the output surface
//
MPoint oldPnt = meshGeom.vertices[elemIndex];
oldPnt = oldPnt.plus( offset );
cpHandle.next();
}
return;
}
public override bool compute( MPlug plug, MDataBlock block)
{
if ( plug.equalEqual(constraintGeometry) )
{
//
block.inputValue(constraintParentInverseMatrix);
//
MArrayDataHandle targetArray = block.inputArrayValue( compoundTarget );
uint targetArrayCount = targetArray.elementCount();
double weight,selectedWeight = 0;
if ( weightType == GeometrySurfaceConstraintCommand.ConstraintType.kSmallestWeight )
selectedWeight = float.MaxValue;
MObject selectedMesh = null;
uint i;
for ( i = 0; i < targetArrayCount; i++ )
{
MDataHandle targetElement = targetArray.inputValue();
weight = targetElement.child(targetWeight).asDouble;
if ( !equivalent(weight,0.0))
{
if ( weightType == GeometrySurfaceConstraintCommand.ConstraintType.kLargestWeight )
{
if ( weight > selectedWeight )
{
MObject mesh = targetElement.child(targetGeometry).asMesh;
if ( !mesh.isNull )
{
selectedMesh = mesh;
selectedWeight = weight;
}
}
}
else
{
if ( weight < selectedWeight )
{
MObject mesh = targetElement.child(targetGeometry).asMesh;
if ( !mesh.isNull )
{
selectedMesh = mesh;
selectedWeight = weight;
}
}
}
}
targetArray.next();
}
//
if( selectedMesh == null )
{
block.setClean(plug);
}
else
{
// The transform node via the geometry attribute will take care of
// updating the location of the constrained geometry.
MDataHandle outputConstraintGeometryHandle = block.outputValue(constraintGeometry);
outputConstraintGeometryHandle.setMObject(selectedMesh);
}
}
else
{
return false;
}
return true;
}
public override bool compute(MPlug plug, MDataBlock dataBlock)
//
// Descriptions:
// compute output force.
//
{
if (plug.notEqual(mOutputForce))
return false;
// get the logical index of the element this plug refers to.
//
uint multiIndex = plug.logicalIndex;
// 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 = dataBlock.outputArrayValue(mInputData);
hInputArray.jumpToElement(multiIndex);
// get children of aInputData.
MDataHandle hCompond = hInputArray.inputValue();
MDataHandle hPosition = hCompond.child(mInputPositions);
MObject dPosition = hPosition.data();
MFnVectorArrayData fnPosition = new MFnVectorArrayData(dPosition);
MVectorArray points = fnPosition.array();
// The attribute mInputPPData contains the attribute in an array form
// prepared 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 = dataBlock.inputArrayValue(mInputPPData);
mhInputPPData.jumpToElement(multiIndex);
MDataHandle hInputPPData = mhInputPPData.inputValue();
MObject dInputPPData = hInputPPData.data();
MFnArrayAttrsData inputPPArray = new MFnArrayAttrsData(dInputPPData);
MDataHandle hOwnerPPData = dataBlock.inputValue(mOwnerPPData);
MObject dOwnerPPData = hOwnerPPData.data();
MFnArrayAttrsData ownerPPArray = new MFnArrayAttrsData(dOwnerPPData);
string magString = "magnitude";
MFnArrayAttrsData.Type doubleType = MFnArrayAttrsData.Type.kDoubleArray;
bool arrayExist;
MDoubleArray magnitudeArray;
arrayExist = inputPPArray.checkArrayExist(magString, out doubleType);
if (arrayExist)
{
magnitudeArray = inputPPArray.getDoubleData(magString);
}
else
{
magnitudeArray = new MDoubleArray();
}
MDoubleArray magnitudeOwnerArray;
arrayExist = ownerPPArray.checkArrayExist(magString, out doubleType);
if (arrayExist)
{
magnitudeOwnerArray = ownerPPArray.getDoubleData(magString);
}
else
{
magnitudeOwnerArray = new MDoubleArray();
}
string dirString = "direction";
MFnArrayAttrsData.Type vectorType = MFnArrayAttrsData.Type.kVectorArray;
MVectorArray directionArray;
arrayExist = inputPPArray.checkArrayExist(dirString, out vectorType);
if (arrayExist)
{
directionArray = inputPPArray.getVectorData(dirString);
}
else
{
directionArray = new MVectorArray();
}
MVectorArray directionOwnerArray;
arrayExist = ownerPPArray.checkArrayExist(dirString, out vectorType);
if (arrayExist)
{
directionOwnerArray = ownerPPArray.getVectorData(dirString);
}
else
{
directionOwnerArray = new MVectorArray();
}
// Compute the output force.
//
MVectorArray forceArray = new MVectorArray();
apply(dataBlock, points.length, magnitudeArray, magnitudeOwnerArray,
directionArray, directionOwnerArray, forceArray);
// get output data handle
//
MArrayDataHandle hOutArray = dataBlock.outputArrayValue(mOutputForce);
MArrayDataBuilder bOutArray = hOutArray.builder();
// get output force array from block.
//
MDataHandle hOut = bOutArray.addElement(multiIndex);
MFnVectorArrayData fnOutputForce = new MFnVectorArrayData();
MObject dOutputForce = fnOutputForce.create(forceArray);
// update data block with new output force data.
//
hOut.set(dOutputForce);
dataBlock.setClean(plug);
return true;
}
public override bool compute(MPlug plug, MDataBlock dataBlock)
//
// Descriptions:
// compute output force.
//
{
if (plug.notEqual(mOutputForce))
{
return(false);
}
// get the logical index of the element this plug refers to.
//
uint multiIndex = plug.logicalIndex;
// 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 = dataBlock.outputArrayValue(mInputData);
hInputArray.jumpToElement(multiIndex);
// get children of aInputData.
MDataHandle hCompond = hInputArray.inputValue();
MDataHandle hPosition = hCompond.child(mInputPositions);
MObject dPosition = hPosition.data();
MFnVectorArrayData fnPosition = new MFnVectorArrayData(dPosition);
MVectorArray points = fnPosition.array();
// The attribute mInputPPData contains the attribute in an array form
// prepared 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 = dataBlock.inputArrayValue(mInputPPData);
mhInputPPData.jumpToElement(multiIndex);
MDataHandle hInputPPData = mhInputPPData.inputValue();
MObject dInputPPData = hInputPPData.data();
MFnArrayAttrsData inputPPArray = new MFnArrayAttrsData(dInputPPData);
MDataHandle hOwnerPPData = dataBlock.inputValue(mOwnerPPData);
MObject dOwnerPPData = hOwnerPPData.data();
MFnArrayAttrsData ownerPPArray = new MFnArrayAttrsData(dOwnerPPData);
string magString = "magnitude";
MFnArrayAttrsData.Type doubleType = MFnArrayAttrsData.Type.kDoubleArray;
bool arrayExist;
MDoubleArray magnitudeArray;
arrayExist = inputPPArray.checkArrayExist(magString, out doubleType);
if (arrayExist)
{
magnitudeArray = inputPPArray.getDoubleData(magString);
}
else
{
magnitudeArray = new MDoubleArray();
}
MDoubleArray magnitudeOwnerArray;
arrayExist = ownerPPArray.checkArrayExist(magString, out doubleType);
if (arrayExist)
{
magnitudeOwnerArray = ownerPPArray.getDoubleData(magString);
}
else
{
magnitudeOwnerArray = new MDoubleArray();
}
string dirString = "direction";
MFnArrayAttrsData.Type vectorType = MFnArrayAttrsData.Type.kVectorArray;
MVectorArray directionArray;
arrayExist = inputPPArray.checkArrayExist(dirString, out vectorType);
if (arrayExist)
{
directionArray = inputPPArray.getVectorData(dirString);
}
else
{
directionArray = new MVectorArray();
}
MVectorArray directionOwnerArray;
arrayExist = ownerPPArray.checkArrayExist(dirString, out vectorType);
if (arrayExist)
{
directionOwnerArray = ownerPPArray.getVectorData(dirString);
}
else
{
directionOwnerArray = new MVectorArray();
}
// Compute the output force.
//
MVectorArray forceArray = new MVectorArray();
apply(dataBlock, points.length, magnitudeArray, magnitudeOwnerArray,
directionArray, directionOwnerArray, forceArray);
// get output data handle
//
MArrayDataHandle hOutArray = dataBlock.outputArrayValue(mOutputForce);
MArrayDataBuilder bOutArray = hOutArray.builder();
// get output force array from block.
//
MDataHandle hOut = bOutArray.addElement(multiIndex);
MFnVectorArrayData fnOutputForce = new MFnVectorArrayData();
MObject dOutputForce = fnOutputForce.create(forceArray);
// update data block with new output force data.
//
hOut.set(dOutputForce);
dataBlock.setClean(plug);
return(true);
}
public override bool compute(MPlug plug, MDataBlock block)
{
if (plug.equalEqual(constraintGeometry))
{
//
block.inputValue(constraintParentInverseMatrix);
//
MArrayDataHandle targetArray = block.inputArrayValue(compoundTarget);
uint targetArrayCount = targetArray.elementCount();
double weight, selectedWeight = 0;
if (weightType == GeometrySurfaceConstraintCommand.ConstraintType.kSmallestWeight)
{
selectedWeight = float.MaxValue;
}
MObject selectedMesh = null;
uint i;
for (i = 0; i < targetArrayCount; i++)
{
MDataHandle targetElement = targetArray.inputValue();
weight = targetElement.child(targetWeight).asDouble;
if (!equivalent(weight, 0.0))
{
if (weightType == GeometrySurfaceConstraintCommand.ConstraintType.kLargestWeight)
{
if (weight > selectedWeight)
{
MObject mesh = targetElement.child(targetGeometry).asMesh;
if (!mesh.isNull)
{
selectedMesh = mesh;
selectedWeight = weight;
}
}
}
else
{
if (weight < selectedWeight)
{
MObject mesh = targetElement.child(targetGeometry).asMesh;
if (!mesh.isNull)
{
selectedMesh = mesh;
selectedWeight = weight;
}
}
}
}
targetArray.next();
}
//
if (selectedMesh == null)
{
block.setClean(plug);
}
else
{
// The transform node via the geometry attribute will take care of
// updating the location of the constrained geometry.
MDataHandle outputConstraintGeometryHandle = block.outputValue(constraintGeometry);
outputConstraintGeometryHandle.setMObject(selectedMesh);
}
}
else
{
return(false);
}
return(true);
}
