MStatus animCube::compute(const MPlug& plug, MDataBlock& data)
{
MStatus returnStatus;
if (plug == outputMesh) {
/* Get time */
MDataHandle timeData = data.inputValue( time, &returnStatus );
McheckErr(returnStatus, "Error getting time data handle\n");
MTime time = timeData.asTime();
/* Get output object */
MDataHandle outputHandle = data.outputValue(outputMesh, &returnStatus);
McheckErr(returnStatus, "ERROR getting polygon data handle\n");
MFnMeshData dataCreator;
MObject newOutputData = dataCreator.create(&returnStatus);
McheckErr(returnStatus, "ERROR creating outputData");
createMesh(time, newOutputData, returnStatus);
McheckErr(returnStatus, "ERROR creating new Cube");
outputHandle.set(newOutputData);
data.setClean( plug );
} else
return MS::kUnknownParameter;
return MS::kSuccess;
}
// The compute() method does the actual work of the node using the inputs
// of the node to generate its output.
//
// Compute takes two parameters: plug and data.
// - Plug is the the data value that needs to be recomputed
// - Data provides handles to all of the nodes attributes, only these
// handles should be used when performing computations.
//
MStatus affects::compute( const MPlug& plug, MDataBlock& data )
{
MStatus status;
MObject thisNode = thisMObject();
MFnDependencyNode fnThisNode( thisNode );
fprintf(stderr,"affects::compute(), plug being computed is \"%s\"\n",
plug.name().asChar());
if ( plug.partialName() == "B" ) {
// Plug "B" is being computed. Assign it the value on plug "A"
// if "A" exists.
//
MPlug pA = fnThisNode.findPlug( "A", &status );
if ( MStatus::kSuccess == status ) {
fprintf(stderr,"\t\t... found dynamic attribute \"A\", copying its value to \"B\"\n");
MDataHandle inputData = data.inputValue( pA, &status );
CHECK_MSTATUS( status );
int value = inputData.asInt();
MDataHandle outputHandle = data.outputValue( plug );
outputHandle.set( value );
data.setClean(plug);
}
} else {
return MS::kUnknownParameter;
}
return( MS::kSuccess );
}
MStatus transCircle::compute( const MPlug& plug, MDataBlock& data )
{
MStatus stat;
bool k = ( plug == outputTranslateX ) |
( plug == outputTranslateY ) |
( plug == outputTranslateZ ) |
( plug == outputTranslate );
if (!k) return MS::kUnknownParameter;
MDataHandle inputData = data.inputValue( input, &stat );
MDataHandle scaleData = data.inputValue( scale, &stat );
MDataHandle framesData = data.inputValue( frames, &stat );
MDataHandle transData = data.inputValue( inputTranslate, &stat );
double3& iTranslate = transData.asDouble3();
double currentFrame = inputData.asDouble();
double scaleFactor = scaleData.asDouble();
double framesPerCircle = framesData.asDouble();
double angle = 6.2831853 * ( currentFrame/framesPerCircle );
double3 oTranslate;
oTranslate[0] = iTranslate[0] + (sin( angle ) * scaleFactor);
oTranslate[1] = iTranslate[1] + 1.0;
oTranslate[2] = iTranslate[2] + (cos( angle ) * scaleFactor);
MDataHandle otHandle = data.outputValue( outputTranslate );
otHandle.set( oTranslate[0], oTranslate[1], oTranslate[2] );
data.setClean(plug);
return MS::kSuccess;
}
bool ProxyViz::loadInternal(MDataBlock& block)
{
MDataHandle tmH = block.inputValue(aplantTransformCache);
MFnPointArrayData tmFn(tmH.data());
MPointArray plantTms = tmFn.array();
if(plantTms.length() < 1) return false;
MDataHandle idH = block.inputValue(aplantIdCache);
MFnIntArrayData idFn(idH.data());
MIntArray plantIds = idFn.array();
if(plantIds.length() < 1) return false;
MDataHandle triH = block.inputValue(aplantTriangleIdCache);
MFnIntArrayData triFn(triH.data());
MIntArray plantTris = triFn.array();
if(plantTris.length() < 1) return false;
MDataHandle crdH = block.inputValue(aplantTriangleCoordCache);
MFnVectorArrayData crdFn(crdH.data());
MVectorArray plantCoords = crdFn.array();
if(plantCoords.length() < 1) return false;
MDataHandle cotH = block.inputValue(aplantOffsetCache);
MFnVectorArrayData cotFn(cotH.data());
MVectorArray plantOffsets = cotFn.array();
return loadPlants(plantTms, plantIds, plantTris, plantCoords, plantOffsets);
}
MStatus arcLen::compute( const MPlug& plug, MDataBlock& data )
{
MStatus status;
if( plug == output )
{
MDataHandle inputData = data.inputValue( inputCurve, &status );
if( !status ) {
status.perror("ERROR getting data");
} else {
MObject curve = inputData.asNurbsCurveTransformed();
MFnNurbsCurve curveFn( curve, &status );
if( !status ) {
status.perror("ERROR creating curve function set");
} else {
double result = curveFn.length();
MDataHandle outputHandle = data.outputValue( arcLen::output );
outputHandle.set( result );
data.setClean(plug);
}
}
} else {
return MS::kUnknownParameter;
}
return MS::kSuccess;
}
//-----------------------------------------------------------------------------
MStatus [!output CLASS_NAME]::compute (const MPlug &plug, MDataBlock &data) {
//- This method computes the value of the given output plug based
//- on the values of the input attributes.
//- plug - the plug to compute
//- data - object that provides access to the attributes for this node
//- 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
MStatus returnStatus =MStatus::kUnknownParameter ;
if ( plug == attr2 ) {
//- Get a handle to the input attribute that we will need for the
//- computation. If the value is being supplied via a connection
//- in the dependency graph, then this call will cause all upstream
//- connections to be evaluated so that the correct value is supplied.
MDataHandle attr1Data =data.inputValue (attr1, &returnStatus) ;
if ( returnStatus == MStatus::kSuccess ) {
//- Read the input value from the handle.
float result =attr1Data.asFloat () ;
//- Get a handle to the output attribute. This is similar to the
//- "inputValue" call above except that no dependency graph
//- computation will be done as a result of this call.
MDataHandle attr2Handle =data.outputValue (attr2) ;
//- This sample just copies the input value through to the output.
attr2Handle.set (result) ;
//- Mark the destination plug as being clean. This will prevent the
//- dependency graph from repeating this calculation until an input
//- of this node changes.
data.setClean (plug) ;
}
}
return (returnStatus) ;
}
void rigidBodyNode::updateShape(const MPlug& plug, MDataBlock& data, float& collisionMarginOffset)
{
MObject thisObject(thisMObject());
MPlug plgCollisionShape(thisObject, ia_collisionShape);
MObject update;
//force evaluation of the shape
plgCollisionShape.getValue(update);
/* vec3f prevCenter(0, 0, 0);
quatf prevRotation(qidentity<float>());
if(m_rigid_body) {
prevCenter = m_rigid_body->collision_shape()->center();
prevRotation = m_rigid_body->collision_shape()->rotation();
}*/
collision_shape_t::pointer collision_shape;
if(plgCollisionShape.isConnected()) {
MPlugArray connections;
plgCollisionShape.connectedTo(connections, true, true);
if(connections.length() != 0) {
MFnDependencyNode fnNode(connections[0].node());
if(fnNode.typeId() == collisionShapeNode::typeId) {
collisionShapeNode *pCollisionShapeNode = static_cast<collisionShapeNode*>(fnNode.userNode());
pCollisionShapeNode->setCollisionMarginOffset(collisionMarginOffset); //mb
collision_shape = pCollisionShapeNode->collisionShape();
} else {
std::cout << "rigidBodyNode connected to a non-collision shape node!" << std::endl;
}
}
}
data.outputValue(ca_rigidBody).set(true);
data.setClean(plug);
}
void SurfaceAttach::setOutPlugs(MDataBlock dataBlock, const MFnNurbsSurface &fnSurface,
const double dataOffset, const bool dataReverse, const short dataGenus, const double dataStaticLength,
const MMatrix &dataParentInverse, const short dataDirection) {
MTransformationMatrix tfm;
MVector t;
MEulerRotation r;
MArrayDataHandle outputHandle = dataBlock.outputArrayValue(SurfaceAttach::out);
std::int32_t count = outputHandle.elementCount();
MDataHandle o;
for (unsigned int k = 0; k < count; ++k) {
outputHandle.jumpToElement(k);
// Get Transformations
tfm = this->matrix(fnSurface, outputHandle.elementIndex(), dataOffset, dataReverse, dataGenus,
dataStaticLength, dataParentInverse, dataDirection);
t = tfm.translation(MSpace::Space::kWorld);
r = tfm.eulerRotation();
o = outputHandle.outputValue();
o.child(SurfaceAttach::translate).set(t);
o.child(SurfaceAttach::rotate).set(r.x, r.y, r.z);
}
// Mark Clean
dataBlock.setClean(SurfaceAttach::translate);
dataBlock.setClean(SurfaceAttach::rotate);
dataBlock.setClean(SurfaceAttach::out);
}
MStatus VoxelShape::compute( const MPlug& plug, MDataBlock& data ) {
MStatus stat;
// 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 == outData )
{
// Get a handle to the input attribute that we will need for the
// computation. If the value is being supplied via a connection
// in the dependency graph, then this call will cause all upstream
// connections to be evaluated so that the correct value is supplied.
//
MDataHandle inputDataHandle = data.inputValue( voxelData, &stat );
MObject inputDataObj = inputDataHandle.data();
MFnPluginData fnDataCreator;
MTypeId tmpid( VoxelPreviewDataWrapper::id );
VoxelPreviewDataWrapper * newData = NULL;
MDataHandle outHandle = data.outputValue( outData );
newData = (VoxelPreviewDataWrapper*)outHandle.asPluginData();
if ( newData == NULL ) {
// Create some output data
fnDataCreator.create( tmpid, &stat );
MCHECKERROR( stat, "compute : error creating VoxelPreviewDataWrapper")
newData = (VoxelPreviewDataWrapper*)fnDataCreator.data( &stat );
MCHECKERROR( stat, "compute : error getting proxy VoxelPreviewDataWrapper object")
}
//-----------------------------------------------------------------------
MStatus visualizeMeshNode::compute( const MPlug& plug, MDataBlock& data )
//-----------------------------------------------------------------------
{
MStatus stat;
// cout << "cvColor::compute\n";
if ( plug == vtxLocations ) {
MObject weightObj = data.inputValue(vtxWeights).data();
MFnDoubleArrayData weightData(weightObj);
vtxWeightArray = weightData.array();
//die displayList muss jetzt auf jeden Fall neu erstellt werden
listNeedsUpdate = wasInCompute = true;
stat = data.setClean ( plug );
if (!stat) {
stat.perror("visualizeMeshNoder::compute setClean");
return stat;
}
} else {
return MS::kUnknownParameter;
}
return MS::kSuccess;
}
MStatus ClothSimMayaPlugin::compute(const MPlug& plug, MDataBlock& data)
{
MStatus returnStatus;
if (plug == g_aOutputMesh)
{
MDataHandle timeData = data.inputValue(g_aTime, &returnStatus);
McheckErr(returnStatus, "Error getting time data handle\n");
MTime time = timeData.asTime();
/* Get output object */
MDataHandle outputHandle = data.outputValue(g_aOutputMesh, &returnStatus);
McheckErr(returnStatus, "ERROR getting polygon data handle\n");
MFnMeshData dataCreator;
MObject newOutputData = dataCreator.create(&returnStatus);
McheckErr(returnStatus, "ERROR creating outputData");
createMesh(time, newOutputData, returnStatus);
if (!returnStatus)
{
std::cerr << "ERROR creating new Cube: " << returnStatus.errorString() << std::endl;
return returnStatus;
}
outputHandle.set(newOutputData);
data.setClean(plug);
}
else
return MS::kUnknownParameter;
return MS::kSuccess;
}
MStatus SwirlDeformer::deform( MDataBlock& block, MItGeometry &iter,
const MMatrix &localToWorld, unsigned int geomIndex )
{
MStatus stat;
MDataHandle envData = block.inputValue( envelope );
float env = envData.asFloat();
if( env == 0.0 ) // Deformer has no effect
return MS::kSuccess;
MDataHandle matData = block.inputValue( deformSpace );
MMatrix mat = matData.asMatrix();
MMatrix invMat = mat.inverse();
MDataHandle startDistHnd = block.inputValue( startDist );
double startDist = startDistHnd.asDouble();
MDataHandle endDistHnd = block.inputValue( endDist );
double endDist = endDistHnd.asDouble();
MPoint pt;
float weight;
double dist;
double ang;
double cosAng;
double sinAng;
double x;
double distFactor;
for( iter.reset(); !iter.isDone(); iter.next() )
{
weight = weightValue( block, geomIndex, iter.index() );
if( weight == 0.0f )
continue;
pt = iter.position();
pt *= invMat;
dist = sqrt( pt.x * pt.x + pt.z * pt.z );
if( dist < startDist || dist > endDist )
continue;
distFactor = 1 - ((dist - startDist) / (endDist - startDist));
ang = distFactor * M_PI * 2.0 * env * weight;
if( ang == 0.0 )
continue;
cosAng = cos( ang );
sinAng = sin( ang );
x = pt.x * cosAng - pt.z * sinAng;
pt.z = pt.x * sinAng + pt.z * cosAng;
pt.x = x;
pt *= mat;
iter.setPosition( pt );
}
return stat;
}
MStatus Trimmer::compute( const MPlug& plug, MDataBlock& data )
//
// 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
//
{
if ( plug == outputData ) {
MStatus stat;
MDataHandle inDataHandle = data.inputValue( Trimmer::inputData, &stat );
MDataHandle outDataHandle = data.outputValue( Trimmer::outputData, &stat );
GrowerData* growerData = static_cast< GrowerData* >( inDataHandle.asPluginData() );
if ( growerData == NULL ) {
cerr << "Trimmer: error retrieving data" << endl;
return MS::kFailure;
}
int maxDepth = GetMaxDepth( growerData->nodes );
int length = (int)ceilf( (float)maxDepth * data.inputValue( Trimmer::maxLength ).asFloat() ) + 1;
Trim( growerData->nodes, length );
outDataHandle.setMPxData( growerData );
data.setClean( plug );
return MS::kSuccess;
}
return MS::kUnknownParameter;
}
MStatus transRotateCombineMatrix::compute( const MPlug& plug, MDataBlock& data )
{
MStatus status;
MDataHandle hOutputMatrix = data.outputValue( aOutputMatrix, &status );
CHECK_MSTATUS_AND_RETURN_IT( status );
MDataHandle hOutputInverseMatrix = data.outputValue( aOutputInverseMatrix, &status );
CHECK_MSTATUS_AND_RETURN_IT( status );
MDataHandle hTransMatrix = data.inputValue( aInputTransMatrix, &status );
CHECK_MSTATUS_AND_RETURN_IT( status );
MDataHandle hRotateMatrix = data.inputValue( aInputRotateMatrix, &status );
CHECK_MSTATUS_AND_RETURN_IT( status );
MMatrix transMatrix = hTransMatrix.asMatrix();
MMatrix rotateMatrix = hRotateMatrix.asMatrix();
double buildMatrix[4][4] = { rotateMatrix( 0,0 ), rotateMatrix( 0,1 ), rotateMatrix( 0,2 ), 0,
rotateMatrix( 1,0 ), rotateMatrix( 1,1 ), rotateMatrix( 1,2 ), 0,
rotateMatrix( 2,0 ), rotateMatrix( 2,1 ), rotateMatrix( 2,2 ), 0,
transMatrix( 3,0 ), transMatrix( 3,1 ), transMatrix( 3,2 ), 1 };
MMatrix buildMtx = buildMatrix;
if( plug == aOutputMatrix )
hOutputMatrix.set( buildMtx );
if( plug == aOutputInverseMatrix )
hOutputInverseMatrix.set( buildMtx.inverse() );
data.setClean( plug );
return status;
}
MStatus RemapArrayValuesNode::compute(const MPlug& plug, MDataBlock& data)
{
if (plug != aOutput)
return MS::kUnknownParameter;
MStatus status;
MFnDoubleArrayData input(data.inputValue(aInput).data());
float inputMin = float(data.inputValue(aInputMin).asDouble());
float inputMax = float(data.inputValue(aInputMax).asDouble());
float outputMin = float(data.inputValue(aOutputMin).asDouble());
float outputMax = float(data.inputValue(aOutputMax).asDouble());
int size = input.length();
MDoubleArray outputArray(size);
MRampAttribute ramp(thisMObject(), aRamp, &status);
CHECK_MSTATUS_AND_RETURN_IT(status);
MFloatArray positions;
MFloatArray values;
MIntArray interps;
MIntArray indices;
ramp.getEntries(indices, positions, values, interps);
int numIndices = indices.length();
float inValue = 0.0;
float outValue = 0.0;
for (int i = 0; i < size; i++)
{
inValue = float(input[i]);
inValue = remapValue(inValue, inputMin, inputMax);
if (numIndices > 0)
{
ramp.getValueAtPosition(inValue, outValue, &status);
CHECK_MSTATUS_AND_RETURN_IT(status);
} else {
outValue = inValue;
}
outValue = remapValue(outValue, 0.0, 1.0, outputMin, outputMax);
outputArray.set(double(outValue), i);
}
MDataHandle outputHandle = data.outputValue(aOutput);
MFnDoubleArrayData output;
MObject outputData = output.create(outputArray);
outputHandle.setMObject(outputData);
outputHandle.setClean();
return MS::kSuccess;
}
MStatus cvColor::compute( const MPlug& plug, MDataBlock& data )
{
MStatus stat;
// cout << "cvColor::compute\n";
if ( plug == cvLocations ) {
MDataHandle inputData = data.inputValue ( inputSurface, &stat );
if (!stat) {
stat.perror("cvColor::compute get inputSurface");
return stat;
}
MObject surf = inputData.asNurbsSurface();
MFnNurbsSurface surfFn (surf, &stat);
if (!stat) {
stat.perror("cvColor::compute surface creator");
return stat;
}
MDataHandle outputData = data.outputValue ( cvLocations, &stat );
if (!stat) {
stat.perror("cvColor::compute get cvLocations");
return stat;
}
MObject cvs = outputData.data();
MFnPointArrayData cvData(cvs, &stat);
if (!stat) {
stat.perror("cvColor::compute point array data creator");
return stat;
}
MPointArray cvArray;
stat = surfFn.getCVs( cvArray, MSpace::kObject);
if (!stat) {
stat.perror("cvColor::compute getCVs");
return stat;
}
stat = cvData.set ( cvArray );
if (!stat) {
stat.perror("cvColor::compute setCVs");
return stat;
}
outputData.set ( cvs );
stat = data.setClean ( plug );
if (!stat) {
stat.perror("cvColor::compute setClean");
return stat;
}
} else {
return MS::kUnknownParameter;
}
return MS::kSuccess;
}
MStatus connectingNode::compute(const MPlug &plug,MDataBlock &data){
MStatus status=MStatus::kSuccess;
bool tri=data.inputValue(trigger,&status).asBool();
if(plug==tmp&&tri){
//4.3 compute F-domain graph
if(state==0)
{
//jason
//fdg.beforeInit();
fdg.InitAnchorPoints();
fdg.compute();
extractBlockNum();
state=1;
std::string fdNum=std::to_string((long double)fdomain_list.size());
MGlobal::executeCommand("$FDomainNum="+MString(fdNum.c_str())+";");
//pass F Domain numbers to mel
std::string preferredRoot=std::to_string((long double)fdg.GetInitialRootDomain());
MGlobal::executeCommand("$preferredDomainIndex="+MString(preferredRoot.c_str())+";");
//pass preferred root index to mel
MGlobal::executeCommand("button -edit -enable true $connectingNextButton;");
turnOffTrigger(data);
}
else if(state==1){//compute new blocks num and highlight blocks
MGlobal::executeCommand("clear($connectingBlock)");//clear the last data
hideOtherMesh();
setBlockGroup();
MGlobal::executeCommand("highlightBlocks();");
if(fdomain_components.size()>1)
state=2;
else
state=3;
turnOffTrigger(data);
}
else if(state==2){//connect edge
int in1=data.inputValue(index1,&status).asInt();
int in2=data.inputValue(index2,&status).asInt();
in1=domain_list[in1]->index;
in2=domain_list[in2]->index;
fdg.ConnectFdomain(in1,in2);
extractBlockNum();
state=1;
turnOffTrigger(data);
}
else if(state==3){//select root domain
int rootIndex=data.inputValue(rootNumber,&status).asInt();
std::string s=std::to_string((long double)rootIndex);
MGlobal::displayInfo(MString(s.c_str()));
fdg.SetRootDomain(rootIndex);
MGlobal::displayInfo("successful!");
turnOffTrigger(data);
}
}
return MS::kSuccess;
}
//
// DESCRIPTION:
///////////////////////////////////////////////////////
MStatus mtmEnvLight::compute(
const MPlug& plug,
MDataBlock& block )
{
if ((plug != aLightData) && (plug.parent() != aLightData))
return MS::kUnknownParameter;
MFloatVector resultColor;
// Real user input
MFloatVector LColor(1,0,0);
//MFloatVector& LColor = block.inputValue( aColor ).asFloatVector();
// MFloatVector& Position = block.inputValue( aPosition ).asFloatVector();
float LIntensity = block.inputValue( aIntensity ).asFloat();
// Components to build LightData
MFloatVector& LDirection = block.inputValue( aInputDirection ).asFloatVector();
bool LAmbient = block.inputValue( aInputAmbient ).asBool();
bool LDiffuse = block.inputValue( aInputDiffuse ).asBool();
bool LSpecular = block.inputValue( aInputSpecular ).asBool();
resultColor = LColor * LIntensity;
// set ouput color attribute
MDataHandle outLightDataHandle = block.outputValue( aLightData );
MFloatVector& outIntensity = outLightDataHandle.child(aLightIntensity).asFloatVector();
outIntensity = resultColor;
MFloatVector& outDirection = outLightDataHandle.child(aLightDirection).asFloatVector();
outDirection = LDirection;
bool& outAmbient = outLightDataHandle.child(aLightAmbient).asBool();
outAmbient = LAmbient;
bool& outDiffuse = outLightDataHandle.child(aLightDiffuse).asBool();
outDiffuse = LDiffuse;
bool& outSpecular = outLightDataHandle.child(aLightSpecular).asBool();
outSpecular = LSpecular;
float& outSFraction = outLightDataHandle.child(aLightShadowFraction).asFloat();
outSFraction = 1.0f;
float& outPSIntensity = outLightDataHandle.child(aPreShadowIntensity).asFloat();
outPSIntensity = (resultColor[0] + resultColor[1] + resultColor[2]) / 3.0f;
void*& outBlindData = outLightDataHandle.child(aLightBlindData).asAddr();
outBlindData = NULL;
outLightDataHandle.setClean();
return MS::kSuccess;
}
MStatus AimNode::compute(const MPlug& plug, MDataBlock& dataBlock)
{
MStatus status;
if ((plug == aOutputRotate) || (plug == aOutputRotateX) ||
(plug == aOutputRotateY) || (plug == aOutputRotateZ))
{
// the matrix to aim at
MMatrix driverMatrix = dataBlock.inputValue(aDriverMatrix).asMatrix();
// the matrix to use as the upVector
MMatrix upVectorMatrix = dataBlock.inputValue(aUpVectorMatrix).asMatrix();
MVector inputTranslate = dataBlock.inputValue(aInputTranslate).asVector();
MMatrix parentInverse = dataBlock.inputValue(aParentInverseMatrix).asMatrix();
driverMatrix *= parentInverse;
upVectorMatrix *= parentInverse;
//extract the translation from the matrices
MVector driverMatrixPos(driverMatrix[3][0],
driverMatrix[3][1],
driverMatrix[3][2]);
MVector upVectorMatrixPos(upVectorMatrix[3][0],
upVectorMatrix[3][1],
upVectorMatrix[3][2]);
//get the vectors
MVector aimVector = driverMatrixPos - inputTranslate;
MVector upVector = upVectorMatrixPos - inputTranslate;
//upVector *= parentInverse;
aimVector.normalize();
upVector.normalize();
//perpendicter vector
MVector cross = aimVector ^ upVector;
upVector = cross ^ aimVector;
//build rotationMatrix
double tmpMatrix[4][4]{{aimVector.x, aimVector.y, aimVector.z, 0},
{upVector.x, upVector.y, upVector.z, 0},
{cross.x, cross.y, cross.z, 0},
{inputTranslate[0], inputTranslate[1], inputTranslate[2], 1}};
//eulerRotations
MMatrix rotationMatrix(tmpMatrix);
MTransformationMatrix matrixfn(rotationMatrix);
MEulerRotation eular = matrixfn.eulerRotation();
dataBlock.outputValue(aOutputRotate).set(eular.x, eular.y, eular.z);
dataBlock.outputValue(aOutputRotate).setClean();
}
return MS::kSuccess;
}
MStatus MG_curve::compute(const MPlug& plug,MDataBlock& dataBlock)
{
if (plug==output)
{
//MStatus
MStatus stat;
//Point array for the curve
MPointArray pointArray ;
//Get data from inputs
MDataHandle degreeH = dataBlock.inputValue(degree);
int degreeValue = degreeH.asInt();
MDataHandle tmH = dataBlock.inputValue(transformMatrix);
MMatrix tm = tmH.asMatrix();
MArrayDataHandle inputMatrixH = dataBlock.inputArrayValue(inputMatrix);
inputMatrixH.jumpToArrayElement(0);
//Loop to get matrix data and convert in points
for (int unsigned i=0;i<inputMatrixH.elementCount();i++,inputMatrixH.next())
{
MMatrix currentMatrix = inputMatrixH.inputValue(&stat).asMatrix() ;
//Compensate the locator matrix
MMatrix fixedMatrix = currentMatrix*tm.inverse();
MPoint matrixP (fixedMatrix[3][0],fixedMatrix[3][1],fixedMatrix[3][2]);
pointArray.append(matrixP);
}
MFnNurbsCurve curveFn;
MFnNurbsCurveData curveDataFn;
MObject curveData= curveDataFn.create();
curveFn.createWithEditPoints(pointArray,degreeValue,MFnNurbsCurve::kOpen,0,0,0,curveData,&stat);
MDataHandle outputH = dataBlock.outputValue(output);
outputH.set(curveData);
outputH.setClean();
}
return MS::kSuccess;
}
//standard attributes
void sixdofConstraintNode::computeConstraint(const MPlug& plug, MDataBlock& data)
{
// std::cout << "sixdofConstraintNode::computeConstraint" << std::endl;
MObject thisObject(thisMObject());
MPlug plgRigidBodyA(thisObject, ia_rigidBodyA);
MPlug plgRigidBodyB(thisObject, ia_rigidBodyB);
MObject update;
//force evaluation of the rigidBody
plgRigidBodyA.getValue(update);
plgRigidBodyB.getValue(update);
rigid_body_t::pointer rigid_bodyA;
if(plgRigidBodyA.isConnected()) {
MPlugArray connections;
plgRigidBodyA.connectedTo(connections, true, true);
if(connections.length() != 0) {
MFnDependencyNode fnNodeA(connections[0].node());
if(fnNodeA.typeId() == rigidBodyNode::typeId) {
rigidBodyNode *pRigidBodyNodeA = static_cast<rigidBodyNode*>(fnNodeA.userNode());
rigid_bodyA = pRigidBodyNodeA->rigid_body();
} else {
std::cout << "sixdofConstraintNode connected to a non-rigidbody node!" << std::endl;
}
}
}
rigid_body_t::pointer rigid_bodyB;
if(plgRigidBodyB.isConnected()) {
MPlugArray connections;
plgRigidBodyB.connectedTo(connections, true, true);
if(connections.length() != 0) {
MFnDependencyNode fnNodeB(connections[0].node());
if(fnNodeB.typeId() == rigidBodyNode::typeId) {
rigidBodyNode *pRigidBodyNodeB = static_cast<rigidBodyNode*>(fnNodeB.userNode());
rigid_bodyB = pRigidBodyNodeB->rigid_body();
} else {
std::cout << "sixdofConstraintNode connected to a non-rigidbody node!" << std::endl;
}
}
}
if(rigid_bodyA && rigid_bodyB) {
//not connected to a rigid body, put a default one
constraint_t::pointer constraint = static_cast<constraint_t::pointer>(m_constraint);
solver_t::remove_constraint(constraint);
m_constraint = solver_t::create_sixdof_constraint(rigid_bodyA, vec3f(), rigid_bodyB, vec3f());
constraint = static_cast<constraint_t::pointer>(m_constraint);
solver_t::add_constraint(constraint);
}
data.outputValue(ca_constraint).set(true);
data.setClean(plug);
}
//
// DESCRIPTION:
///////////////////////////////////////////////////////
MStatus ShadowMatte::compute(
const MPlug& plug,
MDataBlock& block )
{
if ((plug != aOutColor) && (plug.parent() != aOutColor) &&
(plug != aOutTransparency) && (plug.parent() != aOutTransparency))
return MS::kUnknownParameter;
MFloatVector shadowColor(0.0,0.0,0.0);
bool ViewFlag = block.inputValue( aViewColor ).asBool();
// get light list
MArrayDataHandle lightData = block.inputArrayValue( aLightData );
int numLights = lightData.elementCount();
// iterate through light list and get ambient/diffuse values
for( int count=1; count <= numLights; count++ )
{
MDataHandle currentLight = lightData.inputValue();
float lightShadow = currentLight.child(aLightShadowFraction).asFloat();
// shadow fraction tells how much an object is in shadow:
// (1) totally in shadow
// (0-1) partially in shadow
// (0) not in shadow
shadowColor[0] += lightShadow;
shadowColor[1] += lightShadow;
shadowColor[2] += lightShadow;
if( !lightData.next() ) break;
}
// set ouput color attribute
MFloatVector ghostColor(0.0,0.0,0.0);
MDataHandle outColorHandle = block.outputValue( aOutColor );
MFloatVector& outColor = outColorHandle.asFloatVector();
if (ViewFlag)
outColor = shadowColor;
else
outColor = ghostColor;
outColorHandle.setClean();
// set ouput transparency
MDataHandle outTransHandle = block.outputValue( aOutTransparency );
MFloatVector& outTrans = outTransHandle.asFloatVector();
outTrans = shadowColor;
outTransHandle.setClean();
return MS::kSuccess;
}
MStatus SargassoNode::compute( const MPlug& plug, MDataBlock& block )
{
MStatus stat;
if(!m_isInitd) return stat;
if(plug == constraintRotateX ||
plug == constraintRotateY ||
plug == constraintRotateZ ||
plug == constraintTranslateX ||
plug == constraintTranslateY ||
plug == constraintTranslateZ) {
// AHelper::Info<MString>("ov child", plug.name());
// AHelper::Info<unsigned>("ov id", plug.parent().logicalIndex());
unsigned iobject = plug.parent().logicalIndex();
if(iobject > m_numObjects-1) {
MGlobal::displayInfo("n constraint is out of bound");
return MS::kSuccess;
}
if(iobject == 0 && plug == constraintRotateX) {
MDataHandle hm = block.inputValue(atargetMesh);
updateShape(hm.asMesh());
}
if(plug == constraintRotateX)
updateSpace(block, iobject);
MDataHandle hout = block.outputValue(plug, &stat);
if(plug == constraintTranslateX) {
hout.set(m_solvedT.x);
}
else if(plug == constraintTranslateY) {
hout.set(m_solvedT.y);
}
else if(plug == constraintTranslateZ) {
hout.set(m_solvedT.z);
}
else if(plug == constraintRotateX) {
hout.set(m_rot[0]);
}
else if(plug == constraintRotateY) {
hout.set(m_rot[1]);
}
else if(plug == constraintRotateZ) {
hout.set(m_rot[2]);
}
block.setClean( plug );
}
else
return MS::kUnknownParameter;
return MS::kSuccess;
}
MStatus
offset::deform( MDataBlock& block,
MItGeometry& iter,
const MMatrix& /*m*/,
unsigned int multiIndex)
//
// Method: deform
//
// Description: Deform the point with a squash algorithm
//
// Arguments:
// block : the datablock of the node
// iter : an iterator for the geometry to be deformed
// m : matrix to transform the point into world space
// multiIndex : the index of the geometry that we are deforming
//
//
{
MStatus returnStatus;
// Envelope data from the base class.
// The envelope is simply a scale factor.
//
MDataHandle envData = block.inputValue(envelope, &returnStatus);
if (MS::kSuccess != returnStatus) return returnStatus;
float env = envData.asFloat();
// Get the matrix which is used to define the direction and scale
// of the offset.
//
MDataHandle matData = block.inputValue(offsetMatrix, &returnStatus );
if (MS::kSuccess != returnStatus) return returnStatus;
MMatrix omat = matData.asMatrix();
MMatrix omatinv = omat.inverse();
// iterate through each point in the geometry
//
for ( ; !iter.isDone(); iter.next()) {
MPoint pt = iter.position();
pt *= omatinv;
float weight = weightValue(block,multiIndex,iter.index());
// offset algorithm
//
pt.y = pt.y + env*weight;
//
// end of offset algorithm
pt *= omat;
iter.setPosition(pt);
}
return returnStatus;
}
MStatus RippleDeformer::deform(MDataBlock& dataBlock,
MItGeometry& itGeo,
const MMatrix& localToWorldMatrix,
unsigned int geomIndex)
{
MStatus status;
//get attriubtes as a datahandle
float env = dataBlock.inputValue(envelope).asFloat();
float amplitude = dataBlock.inputValue(aAmplitude).asFloat();
float displace = dataBlock.inputValue(aDisplace).asFloat();
//get the mesh
//retrieve the handle to the input attribute
MArrayDataHandle hInput = dataBlock.outputArrayValue(input, &status);
CHECK_MSTATUS_AND_RETURN_IT(status);
//get the input array index handle
status = hInput.jumpToElement(geomIndex);
//get the handle of geomIndex attribute
MDataHandle hInputElement = hInput.outputValue(&status);
//Get the MObject of the input geometry of geomindex
MObject oInputGeom = hInputElement.child(inputGeom).asMesh();
MFnMesh fnMesh(oInputGeom, &status);
CHECK_MSTATUS_AND_RETURN_IT(status);
if (oInputGeom.isNull())
{
return MS::kSuccess;
}
MFloatVectorArray normals;
fnMesh.getVertexNormals(false, normals);
MPoint pointPos;
float weight;
for (; !itGeo.isDone(); itGeo.next())
{
//get current point position
pointPos = itGeo.position();
weight = weightValue(dataBlock, geomIndex, itGeo.index());
pointPos.x = pointPos.x + sin(itGeo.index() + displace) * amplitude * normals[itGeo.index()].x * weight * env;
pointPos.y = pointPos.y + sin(itGeo.index() + displace) * amplitude * normals[itGeo.index()].y * weight * env;
pointPos.z = pointPos.z + sin(itGeo.index() + displace) * amplitude * normals[itGeo.index()].z * weight * env;
//setPosition
itGeo.setPosition(pointPos);
}
return MS::kSuccess;
}
MStatus VolumePushCollider::compute(const MPlug& plug, MDataBlock& dataBlock)
{
MStatus status;
if (plug == aOutput)
{
// inCollider
MArrayDataHandle hInCollider = dataBlock.inputArrayValue(aInCollider);
// inVolume
MArrayDataHandle hInVolume = dataBlock.inputArrayValue(aInVolume);
// output
MArrayDataHandle hOutput = dataBlock.inputArrayValue(aOutput);
MDoubleArray daValues(hInVolume.elementCount());
for (unsigned int c=0; c<hInCollider.elementCount(); c++)
{
// Calculate the total of every collider value for each volume
status = hInCollider.jumpToArrayElement(c);
CHECK_MSTATUS_AND_RETURN_IT(status);
MMatrix mInCollider = hInCollider.inputValue().asMatrix();
MTransformationMatrix tmInCollider(mInCollider);
MPoint pInCollider = tmInCollider.getTranslation(MSpace::kWorld, &status);
CHECK_MSTATUS_AND_RETURN_IT(status);
for (unsigned int v=0; v<hInVolume.elementCount(); v++)
{
// pointMatrixMult
status = hInVolume.jumpToArrayElement(v);
CHECK_MSTATUS_AND_RETURN_IT(status);
MMatrix mInVolume = hInVolume.inputValue().asMatrix();
MVector vVolCollider = pInCollider * mInVolume;
// condition
if (vVolCollider.length() <= 1.0)
{
// reverse
daValues[v] += abs(1.0 - vVolCollider.length());
}
}
}
for (unsigned int i=0; i<hInVolume.elementCount(); i++)
{
// set outputs
status = hOutput.jumpToArrayElement(i);
CHECK_MSTATUS_AND_RETURN_IT(status);
hOutput.outputValue().set(daValues[i]);
}
dataBlock.setClean(plug);
}
return MS::kSuccess;
}
void nailConstraintNode::computeConstraintParam(const MPlug& plug, MDataBlock& data)
{
// std::cout << "nailConstraintNode::computeRigidBodyParam" << std::endl;
MObject thisObject(thisMObject());
MObject update;
MPlug(thisObject, ca_constraint).getValue(update);
if(m_constraint) {
m_constraint->set_damping((float) data.inputValue(ia_damping).asDouble());
}
data.outputValue(ca_constraintParam).set(true);
data.setClean(plug);
}
void collisionShapeNode::computeCollisionShapeParam(const MPlug& plug, MDataBlock& data)
{
// std::cout << "collisionShapeNode::computeCollisionShapeParam" << std::endl;
MObject thisObject(thisMObject());
MObject update;
MPlug(thisObject, ia_shape).getValue(update);
MPlug(thisObject, ia_type).getValue(update);
float3& scale = data.inputValue(ia_scale).asFloat3();
m_collision_shape->set_scale(vec3f(scale[0], scale[1], scale[2]));
data.setClean(plug);
}
MStatus ffdPlanar::getBoundingBox( MDataBlock& block,
unsigned int multiIndex,
MBoundingBox &boundingBoxOut )
{
MStatus status = MS::kSuccess;
MArrayDataHandle inputHandle = block.outputArrayValue( input );
inputHandle.jumpToElement( multiIndex );
MObject mesh = inputHandle.outputValue().child( inputGeom ).asMesh();
MBoundingBox boundingBox = MBoundingBox();
MFnMesh meshFn( mesh, &status );
MCheckErr( status, "Error getting mesh from mesh object\n" );
MPointArray pointArray = MPointArray();
meshFn.getPoints( pointArray, MSpace::kTransform );
for ( int i = 0; i < pointArray.length(); i++ )
{
boundingBox.expand( pointArray[i] );
}
boundingBoxOut = boundingBox;
return status;
}
MStatus Cell3D::compute(const MPlug& plug, MDataBlock& block)
{
if ( (plug != aOutColor) && (plug.parent() != aOutColor) &&
(plug != aOutAlpha) &&
(plug != aOutBorderDist) &&
(plug != aOutF0) && (plug != aOutF1) && (plug != aOutN0)
)
return MS::kUnknownParameter;
const float3& worldPos = block.inputValue(aPointWorld).asFloat3();
const MFloatMatrix& m = block.inputValue(aPlaceMat).asFloatMatrix();
const MFloatVector& cGain = block.inputValue(aColorGain).asFloatVector();
const MFloatVector& cOff = block.inputValue(aColorOffset).asFloatVector();
MFloatPoint q(worldPos[0], worldPos[1], worldPos[2]);
q *= m; // Convert into solid space
float n0, f0, f1;
cellFunc(R3(q.x, q.y, q.z), n0, f0, f1);
MDataHandle outHandle = block.outputValue(aOutF0);
outHandle.asFloat() = f0;
outHandle.setClean();
outHandle = block.outputValue(aOutF1);
outHandle.asFloat() = f1;
outHandle.setClean();
outHandle = block.outputValue(aOutN0);
outHandle.asFloat() = n0;
outHandle.setClean();
outHandle = block.outputValue(aOutBorderDist);
outHandle.asFloat() = 0.5f*(f1 - f0);
outHandle.setClean();
outHandle = block.outputValue( aOutColor );
MFloatVector & outColor = outHandle.asFloatVector();
outColor = cGain * f0 + cOff;
outHandle.setClean();
outHandle = block.outputValue(aOutAlpha);
outHandle.asFloat() = f0;
outHandle.setClean();
return MS::kSuccess;
}
