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; }