void rigidBodyNode::computeRigidBodyParam(const MPlug& plug, MDataBlock& data)
{
// std::cout << "(rigidBodyNode::computeRigidBodyParam) | " << std::endl;
if (!m_rigid_body)
return;
MObject thisObject(thisMObject());
MObject update;
MPlug(thisObject, ca_rigidBody).getValue(update);
double mass = data.inputValue(ia_mass).asDouble();
bool changedMassStatus= false;
float curMass = m_rigid_body->get_mass();
if ((curMass > 0.f) != (mass > 0.f))
{
changedMassStatus = true;
}
if (changedMassStatus)
solver_t::remove_rigid_body(m_rigid_body);
m_rigid_body->set_mass((float)mass);
m_rigid_body->set_inertia((float)mass * m_rigid_body->collision_shape()->local_inertia());
if (changedMassStatus)
solver_t::add_rigid_body(m_rigid_body,name().asChar());
m_rigid_body->set_restitution((float)data.inputValue(ia_restitution).asDouble());
m_rigid_body->set_friction((float)data.inputValue(ia_friction).asDouble());
m_rigid_body->set_linear_damping((float)data.inputValue(ia_linearDamping).asDouble());
m_rigid_body->set_angular_damping((float)data.inputValue(ia_angularDamping).asDouble());
data.outputValue(ca_rigidBodyParam).set(true);
data.setClean(plug);
}
MStatus blendTwoMatrixDecompose::compute( const MPlug& plug, MDataBlock& block )
{
MStatus stat;
MDataHandle hMatrix1 = block.inputValue( aMatrix1, &stat );
MDataHandle hMatrix2 = block.inputValue( aMatrix2, &stat );
MDataHandle hBlender = block.inputValue( aBlender );
MMatrix matrix = hMatrix1.asMatrix()*( 1-hBlender.asFloat() ) + hMatrix2.asMatrix()*hBlender.asFloat();
MPxTransformationMatrix trMtx( matrix );
MDataHandle hOutputTranslate = block.outputValue( aOutputTranslate );
MDataHandle hOutputRotate = block.outputValue( aOutputRotate );
MDataHandle hOutputScale = block.outputValue( aOutputScale );
MDataHandle hOutputShear = block.outputValue( aOutputShear );
MVector translate = trMtx.translation();
hOutputTranslate.set( translate );
MVector rotate = trMtx.eulerRotation().asVector();
hOutputRotate.set( rotate );
MVector scale = trMtx.scale();
hOutputScale.set( scale );
MVector shear = trMtx.shear();
hOutputShear.set( shear );
block.setClean( plug );
return MS::kSuccess;
}
//
// DESCRIPTION:
///////////////////////////////////////////////////////
MStatus depthShader::compute(
const MPlug& plug,
MDataBlock& block )
{
// outColor or individial R, G, B channel
if((plug != aOutColor) && (plug.parent() != aOutColor))
return MS::kUnknownParameter;
MFloatVector resultColor;
// get sample surface shading parameters
MFloatVector& pCamera = block.inputValue(aPointCamera).asFloatVector();
MFloatVector& cNear = block.inputValue(aColorNear).asFloatVector();
MFloatVector& cFar = block.inputValue(aColorFar).asFloatVector();
float nearClip = block.inputValue(aNear).asFloat();
float farClip = block.inputValue(aFar).asFloat();
// pCamera.z is negative
float ratio = (farClip + pCamera.z) / ( farClip - nearClip);
resultColor = cNear * ratio + cFar*(1.f - ratio);
// set ouput color attribute
MDataHandle outColorHandle = block.outputValue( aOutColor );
MFloatVector& outColor = outColorHandle.asFloatVector();
outColor = resultColor;
outColorHandle.setClean();
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;
}
void SoftBodyNode::computeSoftBodyParam(const MPlug &plug, MDataBlock &data)
{
MObject thisObject(thisMObject());
MObject update;
// update mass
MPlug(thisObject, ca_softBody).getValue(update);
float mass = static_cast<float>( data.inputValue(ia_mass).asDouble() );
this->m_soft_body->set_mass(mass);
// update dynamic friction coefficient
float dynFrictionCoeff = static_cast<float>( data.inputValue(ia_dynamicFrictionCoeff).asDouble() );
this->m_soft_body->set_dynamic_friction_coeff(dynFrictionCoeff);
data.outputValue(ca_softBodyParam).set(true);
// update collision margin
float collisionMargin = data.inputValue(ia_collisionMargin).asFloat();
this->m_soft_body->set_collision_margin(collisionMargin);
data.setClean(plug);
// number of collision clusters
int numClust = data.inputValue(ia_numClusters).asInt();
// this->m_soft_body->set_
}
void sixdofConstraintNode::computeConstraintParam(const MPlug& plug, MDataBlock& data)
{
// std::cout << "sixdofConstraintNode::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());
m_constraint->set_breakThreshold((float) data.inputValue(ia_breakThreshold).asDouble());
vec3f lowLin, uppLin, lowAng, uppAng;
float3& mLowLin = data.inputValue(ia_lowerLinLimit).asFloat3();
float3& mUppLin = data.inputValue(ia_upperLinLimit).asFloat3();
float3& mLowAng = data.inputValue(ia_lowerAngLimit).asFloat3();
float3& mUppAng = data.inputValue(ia_upperAngLimit).asFloat3();
for(int j = 0; j < 3; j++)
{
lowLin[j] = mLowLin[j];
uppLin[j] = mUppLin[j];
lowAng[j] = deg2rad(mLowAng[j]);
uppAng[j] = deg2rad(mUppAng[j]);
}
m_constraint->set_LinLimit(lowLin, uppLin);
m_constraint->set_AngLimit(lowAng, uppAng);
}
data.outputValue(ca_constraintParam).set(true);
data.setClean(plug);
}
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 squash::compute( const MPlug& plug, MDataBlock& data )
{
MStatus returnStatus;
if( plug == output )
{
MDataHandle lengthOrigHandle = data.inputValue( lengthOriginal, &returnStatus );
MDataHandle lengthModiHandle = data.inputValue( lengthModify, &returnStatus );
MDataHandle rateHandle = data.inputValue( squashRate, &returnStatus );
MDataHandle forceHandle = data.inputValue( forceValue, &returnStatus );
if( returnStatus != MS::kSuccess )
MGlobal::displayError( "Node squash cannot get value\n" );
else
{
double lengthOrig = lengthOrigHandle.asDouble();
double lengthModi = lengthModiHandle.asDouble();
double rate = rateHandle.asDouble();
double force = forceHandle.asDouble();
double result = pow( lengthOrig/lengthModi, 0.5*rate )*(1+force);
MDataHandle outputHandle = data.outputValue( squash::output );
outputHandle.set( result );
data.setClean(plug);
}
} else {
return MS::kUnknownParameter;
}
return MS::kSuccess;
}
MStatus matrixFromPolygon::compute( const MPlug& plug, MDataBlock& data )
{
MStatus status;
//MFnDependencyNode thisNode( thisMObject() );
//cout << thisNode.name() << ", start" << endl;
if( plug == aOutputMatrix )
{
MDataHandle hInputMesh = data.inputValue( aInputMesh, &status );
CHECK_MSTATUS_AND_RETURN_IT( status );
MDataHandle hInputMeshMatrix = data.inputValue( aInputMeshMatrix, &status );
CHECK_MSTATUS_AND_RETURN_IT( status );
MDataHandle hPolygonIndex = data.inputValue( aPolygonIndex, &status );
CHECK_MSTATUS_AND_RETURN_IT( status );
MDataHandle hU = data.inputValue( aU, &status );
CHECK_MSTATUS_AND_RETURN_IT( status );
MDataHandle hV = data.inputValue( aV, &status );
CHECK_MSTATUS_AND_RETURN_IT( status );
MDataHandle hOutputMatrix = data.outputValue( aOutputMatrix, &status );
CHECK_MSTATUS_AND_RETURN_IT( status );
MMatrix outMatrix;
getMatrixByPoints( outMatrix, hPolygonIndex.asInt(), hU.asDouble(), hV.asDouble(), hInputMesh.asMesh() );
outMatrix *= hInputMeshMatrix.asMatrix();
hOutputMatrix.set( outMatrix );
data.setClean( plug );
}
//cout << thisNode.name() << ", end" << endl;
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 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 sgLockAngleMatrix::compute( const MPlug& plug, MDataBlock& data )
{
MStatus status;
MDataHandle hBaseMatrix = data.inputValue( aBaseMatrix );
m_baseMatrix = hBaseMatrix.asMatrix();
MDataHandle hInputMatrix = data.inputValue( aInputMatrix );
m_inputMatrix = hInputMatrix.asMatrix();
MDataHandle hAngleAxis = data.inputValue( aAngleAxis );
m_angleAxis = hAngleAxis.asUChar();
MDataHandle hInputAngle = data.inputValue( aInputAngle );
m_inputAngle = hInputAngle.asDouble();
m_mtxResult = getsgLockAngleMatrix( m_inputMatrix*m_baseMatrix.inverse(), m_angleAxis, m_inputAngle );
MDataHandle hOutputMatrix = data.outputValue( aOutputMatrix );
hOutputMatrix.set( m_mtxResult * m_baseMatrix );
data.setClean( plug );
return MS::kSuccess;
}
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 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;
}
// COMPUTE ======================================
MStatus gear_uToPercentage::compute(const MPlug& plug, MDataBlock& data)
{
MStatus returnStatus;
// Error check
if (plug != percentage)
return MS::kUnknownParameter;
// Curve
MFnNurbsCurve crv( data.inputValue( curve ).asNurbsCurve() );
// Sliders
bool in_normU = data.inputValue( normalizedU ).asBool();
double in_u = (double)data.inputValue( u ).asFloat();
unsigned in_steps = data.inputValue( steps ).asShort();
// Process
if (in_normU)
in_u = normalizedUToU(in_u, crv.numCVs());
// Get length
MVectorArray u_subpos(in_steps);
MVectorArray t_subpos(in_steps);
MPoint pt;
double step;
for (unsigned i = 0; i < in_steps ; i++){
step = i * in_u / (in_steps - 1.0);
crv.getPointAtParam(step, pt, MSpace::kWorld);
u_subpos[i] = MVector(pt);
step = i/(in_steps - 1.0);
crv.getPointAtParam(step, pt, MSpace::kWorld);
t_subpos[i] = MVector(pt);
}
double u_length = 0;
double t_length = 0;
MVector v;
for (unsigned i = 0; i < in_steps ; i++){
if (i>0){
v = u_subpos[i] - u_subpos[i-1];
u_length += v.length();
v = t_subpos[i] - t_subpos[i-1];
t_length += v.length();
}
}
double out_perc = (u_length / t_length) * 100;
// Output
MDataHandle h = data.outputValue( percentage );
h.setDouble( out_perc );
data.setClean( plug );
return MS::kSuccess;
}
void hingeConstraintNode::computeConstraintParam(const MPlug& plug, MDataBlock& data)
{
//std::cout << "hingeConstraintNode::computeRigidBodyParam data.className=" << std::endl;
MObject thisObject(thisMObject());
MObject update;
MPlug(thisObject, ca_constraint).getValue(update);
if(m_constraint) {
float damping = (float) data.inputValue(ia_damping).asDouble();
m_constraint->set_damping(damping);
float lower = (float) data.inputValue(ia_lowerLimit).asDouble();
float upper = (float) data.inputValue(ia_upperLimit).asDouble();
float limit_softness = (float) data.inputValue(ia_limitSoftness).asDouble();
float bias_factor = (float) data.inputValue(ia_biasFactor).asDouble();
float relaxation_factor = (float) data.inputValue(ia_relaxationFactor).asDouble();
m_constraint->set_limit(lower, upper, limit_softness, bias_factor, relaxation_factor);
float* axis = data.inputValue(ia_hingeAxis).asFloat3();
m_constraint->set_axis(vec3f(axis[0], axis[1], axis[2]));
bool enable_motor = data.inputValue(ia_enableAngularMotor).asBool();
float motorTargetVelocity = (float) data.inputValue(ia_motorTargetVelocity).asDouble();
float maxMotorImpulse = (float) data.inputValue(ia_maxMotorImpulse).asDouble();
m_constraint->enable_motor(enable_motor, motorTargetVelocity, maxMotorImpulse);
}
data.outputValue(ca_constraintParam).set(true);
data.setClean(plug);
}
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;
}
//
// 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
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 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;
}
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 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 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 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;
}
//-----------------------------------------------------------------------------
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) ;
}
// 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 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 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 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;
}
