// // 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; }
void TestDeformer::_initVertMapping_on_one_mesh( MObject &driver_mesh, MArrayDataBuilder &vertMapOutArrayBuilder, const MPointArray& allPts) { MStatus status; // use vertIter to walk through the vertex of a driver mesh MItMeshVertex vertIter( driver_mesh, &status ); CHECK_MSTATUS(status); CHECK_MSTATUS(vertIter.reset()); // for each vertex of the driver mesh while( !vertIter.isDone(&status) ) { CHECK_MSTATUS(status); // get vertex position MPoint driver_pt; driver_pt = vertIter.position( MSpace::kWorld, &status ); CHECK_MSTATUS(status); //get the closest driven point int closest_pt_index = getClosestPt( driver_pt, allPts );//which one is the closest point(in allPts array) to driver_pt //add the closest driven point MDataHandle snapDataHnd = vertMapOutArrayBuilder.addElement( closest_pt_index, &status ); CHECK_MSTATUS( status ); snapDataHnd.setInt( vertIter.index() ); snapDataHnd.setClean(); CHECK_MSTATUS(vertIter.next()); } }
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; }
// // DESCRIPTION: /////////////////////////////////////////////////////// MStatus DispNode::compute( const MPlug& plug, MDataBlock& block ) { if ((plug == aOutColor) || (plug.parent() == aOutColor) || (plug == aOutDisplacement)) { MFloatVector resultColor(0.0,0.0,0.0); MFloatVector& InputColor = block.inputValue( aColor ).asFloatVector(); float MultValue = block.inputValue( aInputValue ).asFloat(); resultColor = InputColor; float scalar = resultColor[0] + resultColor[1] + resultColor[2]; if (scalar != 0.0) { scalar /= 3.0; scalar *= MultValue; } // set ouput color attribute MDataHandle outColorHandle = block.outputValue( aOutColor ); MFloatVector& outColor = outColorHandle.asFloatVector(); outColor = resultColor; outColorHandle.setClean(); MDataHandle outDispHandle = block.outputValue( aOutDisplacement ); float& outDisp = outDispHandle.asFloat(); outDisp = scalar; outDispHandle.setClean( ); } else if ((plug == aOutTransparency) || (plug.parent() == aOutTransparency)) { // set output transparency to be opaque MFloatVector transparency(0.0,0.0,0.0); MDataHandle outTransHandle = block.outputValue( aOutTransparency ); MFloatVector& outTrans = outTransHandle.asFloatVector(); outTrans = transparency; outTransHandle.setClean( ); } else return MS::kUnknownParameter; 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 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 myComp::compute(const MPlug& plug, MDataBlock& block) { // outColor or individial R, G, B channel if((plug != aOutColor) && (plug.parent() != aOutColor) && (plug != aOutAlpha)) return MS::kUnknownParameter; MFloatVector resultColor; MFloatVector& fore = block.inputValue( aForegroundColor ).asFloatVector(); MFloatVector& back = block.inputValue( aBackgroundColor ).asFloatVector(); MFloatVector& bclr = block.inputValue( aBackColor ).asFloatVector(); float& alpha = block.inputValue( aMask ).asFloat(); if ( alpha > 0.99999f ) alpha = 1.f; else if ( alpha < 0.00001 ) alpha = 0.f; resultColor = fore + ((bclr - back) * (1.0f - alpha)); // normalize output color if (resultColor[0] < 0.f ) resultColor[0] = 0.f; if (resultColor[1] < 0.f ) resultColor[1] = 0.f; if (resultColor[2] < 0.f ) resultColor[2] = 0.f; if (resultColor[0] > 1.f ) resultColor[0] = 1.f; if (resultColor[1] > 1.f ) resultColor[1] = 1.f; if (resultColor[2] > 1.f ) resultColor[2] = 1.f; // set ouput color attribute MDataHandle outColorHandle = block.outputValue( aOutColor ); MFloatVector& outColor = outColorHandle.asFloatVector(); outColor = resultColor; outColorHandle.setClean(); MDataHandle outAlphaHandle = block.outputValue( aOutAlpha ); float& outAlpha = outAlphaHandle.asFloat(); outAlpha = ( resultColor.x + resultColor.y + resultColor.z ) / 3.0f; outAlphaHandle.setClean(); return MS::kSuccess; }
// // This function gets called by Maya to evaluate the texture. // MStatus mySChecker::compute(const MPlug& plug, MDataBlock& block) { // outColor or individial R, G, B channel, or alpha if((plug != aOutColor) && (plug.parent() != aOutColor) && (plug != aOutAlpha)) return MS::kUnknownParameter; MFloatVector resultColor; float3 & worldPos = block.inputValue(aPointWorld).asFloat3(); MFloatMatrix& mat = block.inputValue(aPlaceMat).asFloatMatrix(); float3 & bias = block.inputValue(aBias).asFloat3(); MFloatPoint pos(worldPos[0], worldPos[1], worldPos[2]); pos *= mat; // Convert into solid space // normalize the point int count = 0; if (pos.x - floor(pos.x) < bias[0]) count++; if (pos.y - floor(pos.y) < bias[1]) count++; if (pos.z - floor(pos.z) < bias[2]) count++; if (count & 1) resultColor = block.inputValue(aColor2).asFloatVector(); else resultColor = block.inputValue(aColor1).asFloatVector(); // Set ouput color attribute MDataHandle outColorHandle = block.outputValue( aOutColor ); MFloatVector& outColor = outColorHandle.asFloatVector(); outColor = resultColor; outColorHandle.setClean(); // Set ouput alpha attribute MDataHandle outAlphaHandle = block.outputValue( aOutAlpha ); float& outAlpha = outAlphaHandle.asFloat(); outAlpha = ( count & 1) ? 1.0f : 0.0f; outAlphaHandle.setClean(); return MS::kSuccess; }
MStatus liqDisplacementNode::compute( const MPlug& plug, MDataBlock& block ) { if( (plug == aDisplacement) || (plug.parent() == aDisplacement) ) { MDataHandle outDispHandle = block.outputValue( aDisplacement ); outDispHandle.set( 0.0f ); outDispHandle.setClean(); } else return MS::kUnknownParameter; return MS::kSuccess; }
MStatus TestLightNode::compute( const MPlug& plug, MDataBlock& block ) { //CM_TRACE_FUNC("SkyLightNode::compute(job="<<plug.name()<<",block)"); // outColor or individual R, G, B channel if( (plug == aOutColor) || (plug.parent() == aOutColor) || (plug == aOutTransparency) || (plug.parent() == aOutTransparency) ) { // init shader MStatus status; MFloatVector& lightcolor = block.inputValue(alightcolor).asFloatVector(); //rendering begin (maya software) MFloatVector resultColor; resultColor = lightcolor; //rendering end // set ouput color attribute MDataHandle outColorHandle = block.outputValue( aOutColor, &status ); IfMErrorWarn(status); outColorHandle.asFloatVector() = resultColor; outColorHandle.setClean(); MDataHandle outTransHandle = block.outputValue( aOutTransparency, &status ); IfMErrorWarn(status); outTransHandle.asFloatVector() = MFloatVector(0.0, 0.0, 0.0); outTransHandle.setClean(); } else { return MS::kUnknownParameter; } return MS::kSuccess; }
// // This function gets called by Maya to evaluate the texture. // MStatus noise3::compute(const MPlug& plug, MDataBlock& block) { // outColor or individial R, G, B channel, or alpha if((plug != aOutColor) && (plug.parent() != aOutColor) && (plug != aOutAlpha)) return MS::kUnknownParameter; MFloatVector resultColor; MFloatVector & col1 = block.inputValue(aColor1).asFloatVector(); MFloatVector & col2 = block.inputValue(aColor2).asFloatVector(); float3 & worldPos = block.inputValue( aPointWorld ).asFloat3(); MFloatMatrix& mat = block.inputValue( aPlaceMat ).asFloatMatrix(); float& sc = block.inputValue( aScale ).asFloat(); float& bi = block.inputValue( aBias ).asFloat(); MFloatPoint solidPos(worldPos[0], worldPos[1], worldPos[2]); solidPos *= mat; // Convert into solid space float val = fabsf( pnoise3( solidPos ) * sc + bi ); if (val < 0.) val = 0.; if (val > 1.) val = 1.; resultColor = col1 * val + col2*(1-val); // Set output color attribute MDataHandle outColorHandle = block.outputValue( aOutColor ); MFloatVector& outColor = outColorHandle.asFloatVector(); outColor = resultColor; outColorHandle.setClean(); MDataHandle outAlphaHandle = block.outputValue( aOutAlpha ); float& outAlpha = outAlphaHandle.asFloat(); outAlpha = val; outAlphaHandle.setClean(); return MS::kSuccess; }
MStatus CheckerNode::compute( const MPlug& plug, MDataBlock& block ) { // outColor or individial R, G, B channel, or alpha if((plug != aOutColor) && (plug.parent() != aOutColor) && (plug != aOutAlpha)) return MS::kUnknownParameter; MFloatVector resultColor; float2 & uv = block.inputValue( aUVCoord ).asFloat2(); float2 & bias = block.inputValue( aBias ).asFloat2(); int count = 0; if (uv[0] - floorf(uv[0]) < bias[0]) count++; if (uv[1] - floorf(uv[1]) < bias[1]) count++; if (count & 1) resultColor = block.inputValue( aColor2 ).asFloatVector(); else resultColor = block.inputValue( aColor1 ).asFloatVector(); // Set ouput color attribute MDataHandle outColorHandle = block.outputValue( aOutColor ); MFloatVector& outColor = outColorHandle.asFloatVector(); outColor = resultColor; outColorHandle.setClean(); // Set ouput alpha attribute MDataHandle outAlphaHandle = block.outputValue( aOutAlpha ); float& outAlpha = outAlphaHandle.asFloat(); outAlpha = (count & 1) ? 1.f : 0.f; outAlphaHandle.setClean(); return MS::kSuccess; }
// // DESCRIPTION: /////////////////////////////////////////////////////// MStatus InterpNode::compute( const MPlug& plug, MDataBlock& block ) { if ((plug != aOutColor) && (plug.parent() != aOutColor)) return MS::kUnknownParameter; MFloatVector resultColor; MFloatVector& Side = block.inputValue( aColor1 ).asFloatVector(); MFloatVector& Face = block.inputValue( aColor2 ).asFloatVector(); MFloatVector& surfNorm = block.inputValue( aNormalCamera ).asFloatVector(); MFloatVector& viewVector = block.inputValue(aPointCamera).asFloatVector(); float power = block.inputValue( aInputValue ).asFloat(); // Normalize the view vector CHECK_MSTATUS ( viewVector.normalize() ); // find dot product float scalarNormal = (viewVector.x * surfNorm.x) + (viewVector.y * surfNorm.y) + (viewVector.z * surfNorm.z); // take the absolute value if (scalarNormal < 0.0) scalarNormal = -scalarNormal; // Use InputValue to change interpolation // power == 1.0 linear // power >= 0.0 use gamma function // float scalar; if (power > 0.0) { scalar = powf(scalarNormal, 1.0f / power); } else { scalar = 0.0; } // Interpolate the colors resultColor = Side + ((Face - Side) * scalar); // set ouput color attribute MDataHandle outColorHandle = block.outputValue( aOutColor ); MFloatVector& outColor = outColorHandle.asFloatVector(); outColor = resultColor; outColorHandle.setClean(); return MS::kSuccess; }
// // DESCRIPTION: /////////////////////////////////////////////////////// MStatus Gamma::compute(const MPlug &plug, MDataBlock &block) { if ((plug != aOutColor) && (plug.parent() != aOutColor)) return MS::kUnknownParameter; MFloatVector & icol = block.inputValue( aColor ).asFloatVector(); MFloatVector & igam = block.inputValue( aGamma ).asFloatVector(); MDataHandle och = block.outputValue( aOutColor ); MFloatVector & ocol = och.asFloatVector(); ocol[0]= powf(icol[0], 1.f/igam[0]); ocol[1]= powf(icol[1], 1.f/igam[1]); ocol[2]= powf(icol[2], 1.f/igam[2]); och.setClean(); return MS::kSuccess; }
MStatus slopeShaderNode::compute(const MPlug & plug, MDataBlock & block ) // // Description: // Computes a color value // from a surface noraml angle. // { if ((plug != aOutColor) && (plug.parent() != aOutColor)) return MS::kUnknownParameter; MFloatVector resultColor; MFloatVector& walkable = block.inputValue( aColor1 ).asFloatVector(); MFloatVector& nonWalkable = block.inputValue( aColor2 ).asFloatVector(); MFloatVector& surfaceNormal = block.inputValue( aTriangleNormalCamera ).asFloatVector(); MFloatMatrix& viewMatrix = block.inputValue( aMatrixEyeToWorld ).asFloatMatrix(); float angle = block.inputValue( aAngle ).asFloat(); // Normalize the view vector // surfaceNormal.normalize(); MFloatVector WSVector = surfaceNormal * viewMatrix; // find dot product // float scalarNormal = WSVector * MFloatVector(0, 1, 0); // take the absolute value // if (scalarNormal < 0.0) scalarNormal *= -1.0; if(cos(angle*AWdegreesToRadians) < scalarNormal) resultColor = walkable; else resultColor = nonWalkable; // set ouput color attribute // MDataHandle outColorHandle = block.outputValue( aOutColor ); MFloatVector& outColor = outColorHandle.asFloatVector(); outColor = resultColor; outColorHandle.setClean(); return MS::kSuccess; }
MStatus ArrayAngleConstructorNode::compute(const MPlug& plug, MDataBlock& data) { if (plug != aOutput) return MS::kUnknownParameter; MStatus status; int index; MArrayDataHandle inputArrayHandle = data.inputArrayValue(aInput); int inputSize = inputArrayHandle.elementCount(); int outputSize = data.inputValue(aSize).asInt(); MDoubleArray outputArray(outputSize); MAngle::Unit uiUnit = MAngle::uiUnit(); for (int i = 0; i < inputSize; i++) { index = inputArrayHandle.elementIndex(); if (index >= outputSize) break; if (uiUnit == MAngle::kRadians) { outputArray[index] = inputArrayHandle.inputValue().asAngle().asRadians(); } else { outputArray[index] = inputArrayHandle.inputValue().asAngle().asDegrees(); } if (!inputArrayHandle.next()) break; } MFnDoubleArrayData outputArrayData; MObject outputData = outputArrayData.create(outputArray, &status); CHECK_MSTATUS_AND_RETURN_IT(status); MDataHandle outputHandle = data.outputValue(aOutput); outputHandle.setMObject(outputData); outputHandle.setClean(); return MS::kSuccess; }
// DESCRIPTION: // MStatus hwPhongShader::compute( const MPlug& plug, MDataBlock& block ) { TRACE_API_CALLS("compute"); if ((plug != outColor) && (plug.parent() != outColor)) return MS::kUnknownParameter; MFloatVector & color = block.inputValue( aDiffuseColor ).asFloatVector(); // set output color attribute MDataHandle outColorHandle = block.outputValue( outColor ); MFloatVector& outColor = outColorHandle.asFloatVector(); outColor = color; outColorHandle.setClean(); return MS::kSuccess; }
// This function gets called by Maya to evaluate the shader. // See "Writing a shading node plug-in" in the documentation // for more information. // // MStatus hwDecalBumpShader_NV20::compute( const MPlug& plug, MDataBlock& block ) { bool k; k = (plug == outColor) || (plug == outColorR) || (plug == outColorG) || (plug == outColorB); if( !k ) return MS::kUnknownParameter; // set output color attribute MDataHandle outColorHandle = block.outputValue( outColor ); MFloatVector& outColor = outColorHandle.asFloatVector(); outColor.x = 1.0; outColor.y = 0.5; outColor.z = 0.5; outColorHandle.setClean(); return MS::kSuccess; }
MStatus ReduceArrayNode::compute(const MPlug& plug, MDataBlock& data) { if (plug != aOutput) return MS::kUnknownParameter; MStatus status; MDataHandle inputHandle = data.inputValue(aInput, &status); CHECK_MSTATUS_AND_RETURN_IT(status); MFnDoubleArrayData inputArrayData(inputHandle.data()); MDoubleArray inputArray = inputArrayData.array(); int numInputs = inputArray.length(); short operation = data.inputValue(aOperation).asShort(); double output = numInputs > 0 ? inputArray[0] : 0.0; if (operation == kLENGTH) { output = double(numInputs); } else { for (int i = 1; i < numInputs; i++) { output = computeOutput(output, inputArray[i], operation, status); if (!status) { reportComputeError(this, operation); break; } } } MDataHandle outputHandle = data.outputValue(this->aOutput); outputHandle.setDouble(output); outputHandle.setClean(); 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; }
// // DESCRIPTION: /////////////////////////////////////////////////////// MStatus MixtureNode::compute(const MPlug& plug, MDataBlock& block ) { if ((plug != aOutColor) && (plug.parent() != aOutColor)) return MS::kUnknownParameter; MFloatVector color1 = block.inputValue( aColor1 ).asFloatVector(); MFloatVector color2 = block.inputValue( aColor2 ).asFloatVector(); MFloatVector mask1 = block.inputValue( aAlphaInput1 ).asFloatVector(); MFloatVector mask2 = block.inputValue( aAlphaInput2 ).asFloatVector(); // Mask1 applied to color1, mask2 applied to color2 color1[0] *= mask1[0]; color1[1] *= mask1[1]; color1[2] *= mask1[2]; color2[0] *= mask2[0]; color2[1] *= mask2[1]; color2[2] *= mask2[2]; // set ouput color attribute MDataHandle outColorHandle = block.outputValue( aOutColor ); MFloatVector& outColor = outColorHandle.asFloatVector(); outColor = color1 + color2; outColorHandle.setClean(); return MS::kSuccess; }
MStatus hwUnlitShader::compute( const MPlug& plug, MDataBlock& block ) { bool k = false; k |= (plug==outColor); k |= (plug==outColorR); k |= (plug==outColorG); k |= (plug==outColorB); if( !k ) return MS::kUnknownParameter; // Always return black for now. MFloatVector resultColor(0.0,0.0,0.0); // set ouput color attribute MDataHandle outColorHandle = block.outputValue( outColor ); MFloatVector& outColor = outColorHandle.asFloatVector(); outColor = resultColor; outColorHandle.setClean(); return MS::kSuccess; }
//---------------------------------------------------------------------------- MStatus BPT_InsertVtx::compute(const MPlug& plug, MDataBlock& data) //---------------------------------------------------------------------------- { // FactoryWerte setzen // (hier ueueberall eventuell noch MCheck nutzen fueuer Debug wenn nueuetig) MStatus status; MDataHandle stateHandle = data.outputValue(state); if(stateHandle.asShort() == 1) { MDataHandle inMeshHandle = data.inputValue(IVinMesh); MDataHandle outMeshHandle = data.outputValue(IVoutMesh); // inMesh direkt an outMesh und MObject mesh an factory geben outMeshHandle.set(inMeshHandle.asMesh()); outMeshHandle.setClean(); } else { if( (plug == IVoutMesh) ) { if(meshDirty) { MPRINT("COMPLETE COMPUTE!!!!!!!!!!!!!!!!!!!!!!!!!!!") status = doCompleteCompute(data); INVIS(cout<<"MeshDirty ist "<<meshDirty<<endl;) meshDirty = false; INVIS(cout<<"--------------------------------"<<endl;) MFnDependencyNode depNodeFn(thisMObject()); INVIS(cout<<"---------------"<<endl;) INVIS(cout<<depNodeFn.name().asChar()<<endl;)
// This function gets called by Maya to evaluate the texture. // See "Writing a shading node plug-in" in the documentation // for more information. // // CAVEAT: This part of the HW shader plug-in is meant to allow // seamless transition from HW to SW rendering. // Unfortunately, as of 4.0.1 it's somewhat flaky. // Meanwhile, it is recommended to build two shading networks // in parallel (one for SW, one for HW) and use MEL scripts // to switch from one to the other. // MStatus hwRefractReflectShader_NV20::compute( const MPlug& plug, MDataBlock& block ) { // Get color and lightModel from the input block. // Get UV coordinates from the input block. bool k = false; k |= (plug==outColor); k |= (plug==outColorR); k |= (plug==outColorG); k |= (plug==outColorB); if( !k ) return MS::kUnknownParameter; MFloatVector resultColor(0.0,0.0,0.0); // set ouput color attribute MDataHandle outColorHandle = block.outputValue( outColor ); MFloatVector& outColor = outColorHandle.asFloatVector(); outColor = resultColor; outColorHandle.setClean(); return MS::kSuccess; }
// // DESCRIPTION: /////////////////////////////////////////////////////// MStatus clearcoat::compute( const MPlug& plug, MDataBlock& block ) { if( plug == aOutValue ) { MFloatVector& surfaceNormal = block.inputValue( aNormalCamera ).asFloatVector(); MFloatVector& rayDirection = block.inputValue( aRayDirection ).asFloatVector(); float index = block.inputValue(aIndex).asFloat(); float scale = block.inputValue(aScale).asFloat(); float bias = block.inputValue(aBias).asFloat(); // This is Jim Craighead's code. Ripped straight from Studio... /* This basically computes a fresnel reflection coeficient. */ /* It could probably use some optimization, but the trig */ /* identities are left as an exercise for the masochistic. */ /* Also note that this is reasonably accurate for refractive */ /* indices greater than 1, but a complete hack for smaller */ /* values. There are still problems with values below 0.6 */ /* such as Gold and Silver. */ float origCosne = - (rayDirection * surfaceNormal); float ninety = (float) kPi * 0.5f; float I = (float) acos( origCosne ); float transSin = (float) sin(I) / (float)(index); float ccFresnel = 1.0; float ccBlend = 0.0; float sum = 0.0; float difference = 0.0; if( transSin > 1.0 ) { float limit = (float) asin( (float)(index)); sum = limit + ninety; difference = limit - ninety; } else { float T = (float) asin( transSin ); sum = I + T; difference = I - T; } if( ! (fabs(difference) < kFloatEpsilon ) ) { float fudgedScale = (float)(scale) * 2.0f; float fudgedBias = (float)(bias) * 1.0f; if( sum < ninety ) { float parallel = (float) (tan(difference) / tan(sum)); float perpendicular = (float) (sin(difference) / sin(sum)); ccFresnel = 0.5f * ( perpendicular * perpendicular + parallel * parallel ); } else { float perpendicular = (float) sin(difference); ccFresnel = 0.5f * ( perpendicular * perpendicular ); } ccBlend = ccFresnel * fudgedScale + fudgedBias; if( ccBlend > 1.0 ) ccBlend = 1.0; else if( ccBlend < 0.0 ) ccBlend = 0.0; } // set ouput color attribute MDataHandle outHandle = block.outputValue( aOutValue ); float& outV = outHandle.asFloat(); outV = ccBlend; outHandle.setClean(); } else return MS::kUnknownParameter; return MS::kSuccess; }
// // DESCRIPTION: /////////////////////////////////////////////////////// MStatus PhongNode::compute( const MPlug& plug, MDataBlock& block ) { if ((plug != aOutColor) && (plug.parent() != aOutColor)) return MS::kUnknownParameter; MFloatVector resultColor(0.0,0.0,0.0); // get sample surface shading parameters MFloatVector& surfaceNormal = block.inputValue( aNormalCamera ).asFloatVector(); MFloatVector& cameraPosition = block.inputValue( aPointCamera ).asFloatVector(); // use for raytracing api enhancement below MFloatVector point = cameraPosition; MFloatVector normal = surfaceNormal; MFloatVector& surfaceColor = block.inputValue( aColor ).asFloatVector(); MFloatVector& incandescence = block.inputValue( aIncandescence ).asFloatVector(); float diffuseReflectivity = block.inputValue( aDiffuseReflectivity ).asFloat(); // float translucenceCoeff = block.inputValue( aTranslucenceCoeff ).asFloat(); // User-defined Reflection Color Gain float reflectGain = block.inputValue( aReflectGain ).asFloat(); // Phong shading attributes float power = block.inputValue( aPower ).asFloat(); float spec = block.inputValue( aSpecularity ).asFloat(); float specularR, specularG, specularB; float diffuseR, diffuseG, diffuseB; diffuseR = diffuseG = diffuseB = specularR = specularG = specularB = 0.0; // 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(); MFloatVector& lightIntensity = currentLight.child(aLightIntensity).asFloatVector(); // Find the blind data void*& blindData = currentLight.child( aLightBlindData ).asAddr(); // find ambient component if( currentLight.child(aLightAmbient).asBool() ) { diffuseR += lightIntensity[0]; diffuseG += lightIntensity[1]; diffuseB += lightIntensity[2]; } MFloatVector& lightDirection = currentLight.child(aLightDirection).asFloatVector(); if ( blindData == NULL ) { // find diffuse and specular component if( currentLight.child(aLightDiffuse).asBool() ) { float cosln = lightDirection * surfaceNormal;; if( cosln > 0.0f ) // calculate only if facing light { diffuseR += lightIntensity[0] * ( cosln * diffuseReflectivity ); diffuseG += lightIntensity[1] * ( cosln * diffuseReflectivity ); diffuseB += lightIntensity[2] * ( cosln * diffuseReflectivity ); } CHECK_MSTATUS( cameraPosition.normalize() ); if( cosln > 0.0f ) // calculate only if facing light { float RV = ( ( (2*surfaceNormal) * cosln ) - lightDirection ) * cameraPosition; if( RV > 0.0 ) RV = 0.0; if( RV < 0.0 ) RV = -RV; if ( power < 0 ) power = -power; float s = spec * powf( RV, power ); specularR += lightIntensity[0] * s; specularG += lightIntensity[1] * s; specularB += lightIntensity[2] * s; } } } else { float cosln = MRenderUtil::diffuseReflectance( blindData, lightDirection, point, surfaceNormal, true ); if( cosln > 0.0f ) // calculate only if facing light { diffuseR += lightIntensity[0] * ( cosln * diffuseReflectivity ); diffuseG += lightIntensity[1] * ( cosln * diffuseReflectivity ); diffuseB += lightIntensity[2] * ( cosln * diffuseReflectivity ); } CHECK_MSTATUS ( cameraPosition.normalize() ); if ( currentLight.child(aLightSpecular).asBool() ) { MFloatVector specLightDirection = lightDirection; MDataHandle directionH = block.inputValue( aRayDirection ); MFloatVector direction = directionH.asFloatVector(); float lightAttenuation = 1.0; specLightDirection = MRenderUtil::maximumSpecularReflection( blindData, lightDirection, point, surfaceNormal, direction ); lightAttenuation = MRenderUtil::lightAttenuation( blindData, point, surfaceNormal, false ); // Are we facing the light if ( specLightDirection * surfaceNormal > 0.0f ) { float power2 = block.inputValue( aPower ).asFloat(); MFloatVector rv = 2 * surfaceNormal * ( surfaceNormal * direction ) - direction; float s = spec * powf( rv * specLightDirection, power2 ); specularR += lightIntensity[0] * s * lightAttenuation; specularG += lightIntensity[1] * s * lightAttenuation; specularB += lightIntensity[2] * s * lightAttenuation; } } } if( !lightData.next() ) break; } // factor incident light with surface color and add incandescence resultColor[0] = ( diffuseR * surfaceColor[0] ) + specularR + incandescence[0]; resultColor[1] = ( diffuseG * surfaceColor[1] ) + specularG + incandescence[1]; resultColor[2] = ( diffuseB * surfaceColor[2] ) + specularB + incandescence[2]; // add the reflection color if (reflectGain > 0.0) { MStatus status; // required attributes for using raytracer // origin, direction, sampler, depth, and object id. // MDataHandle originH = block.inputValue( aRayOrigin, &status); MFloatVector origin = originH.asFloatVector(); MDataHandle directionH = block.inputValue( aRayDirection, &status); MFloatVector direction = directionH.asFloatVector(); MDataHandle samplerH = block.inputValue( aRaySampler, &status); void*& samplerPtr = samplerH.asAddr(); MDataHandle depthH = block.inputValue( aRayDepth, &status); short depth = depthH.asShort(); MDataHandle objH = block.inputValue( aObjectId, &status); void*& objId = objH.asAddr(); MFloatVector reflectColor; MFloatVector reflectTransparency; MFloatVector& triangleNormal = block.inputValue( aTriangleNormalCamera ).asFloatVector(); // compute reflected ray MFloatVector l = -direction; float dot = l * normal; if( dot < 0.0 ) dot = -dot; MFloatVector refVector = 2 * normal * dot - l; // reflection ray float dotRef = refVector * triangleNormal; if( dotRef < 0.0 ) { const float s = 0.01f; MFloatVector mVec = refVector - dotRef * triangleNormal; mVec.normalize(); refVector = mVec + s * triangleNormal; } CHECK_MSTATUS ( refVector.normalize() ); status = MRenderUtil::raytrace( point, // origin refVector, // direction objId, // object id samplerPtr, // sampler info depth, // ray depth reflectColor, // output color and transp reflectTransparency); // add in the reflection color resultColor[0] += reflectGain * (reflectColor[0]); resultColor[1] += reflectGain * (reflectColor[1]); resultColor[2] += reflectGain * (reflectColor[2]); } // set ouput color attribute MDataHandle outColorHandle = block.outputValue( aOutColor ); MFloatVector& outColor = outColorHandle.asFloatVector(); outColor = resultColor; outColorHandle.setClean(); return MS::kSuccess; }
MStatus anisotropicShaderNode::compute( const MPlug& plug, MDataBlock& block ) { if ((plug == aOutColor) || (plug.parent() == aOutColor)) { MFloatVector resultColor(0.0,0.0,0.0); MFloatVector diffuseColor( 0.0,0.0,0.0 ); MFloatVector specularColor( 0.0,0.0,0.0 ); MFloatVector ambientColor( 0.0,0.0,0.0 ); // get matrix MFloatMatrix& matrixOToW = block.inputValue( aMatrixOToW ).asFloatMatrix(); MFloatMatrix& matrixWToC = block.inputValue( aMatrixWToC ).asFloatMatrix(); // spin scratch around this vector (in object space ) MFloatVector& A = block.inputValue( aAxesVector ).asFloatVector(); A.normalize(); // spin scratch around this vector (in world space ) MFloatVector wa = A * matrixOToW; wa.normalize(); // spin scratch around this vector (in camera space ) MFloatVector ca = wa * matrixWToC; ca.normalize(); MFloatVector& surfacePoint = block.inputValue( aPointCamera ).asFloatVector(); // get sample surface shading parameters MFloatVector& N = block.inputValue( aNormalCamera ).asFloatVector(); MFloatVector& surfaceColor = block.inputValue( aColor ).asFloatVector(); float diffuseReflectivity = block.inputValue( aDiffuseReflectivity ).asFloat(); float specularCoeff = block.inputValue( aSpecularCoeff ).asFloat(); // get light list MArrayDataHandle lightData = block.inputArrayValue( aLightData ); int numLights = lightData.elementCount(); // iterate through light list and get ambient/diffuse values for( int count=0; count < numLights; count++ ) { MDataHandle currentLight = lightData.inputValue(); MFloatVector& lightIntensity = currentLight.child( aLightIntensity ).asFloatVector(); MFloatVector& lightDirection = currentLight.child( aLightDirection ).asFloatVector(); // find ambient component if( currentLight.child(aLightAmbient).asBool()) { ambientColor[0] += lightIntensity[0] * surfaceColor[0]; ambientColor[1] += lightIntensity[1] * surfaceColor[1]; ambientColor[2] += lightIntensity[2] * surfaceColor[2]; } float cosln = lightDirection * N; if( cosln > 0.0f ){ // illuminated! // find diffuse component if( currentLight.child(aLightDiffuse).asBool()) { float cosDif = cosln * diffuseReflectivity; diffuseColor[0] += lightIntensity[0] * cosDif * surfaceColor[0]; diffuseColor[1] += lightIntensity[1] * cosDif * surfaceColor[1]; diffuseColor[2] += lightIntensity[2] * cosDif * surfaceColor[2]; } // find specular component if( currentLight.child( aLightSpecular).asBool()){ MFloatVector& rayDirection = block.inputValue( aRayDirection ).asFloatVector(); MFloatVector viewDirection = -rayDirection; MFloatVector half = calcHalfVector( viewDirection, lightDirection ); // Beckmann function MFloatVector nA; if( fabs(1.0-fabs(N*ca)) <= 0.0001f ){ MFloatPoint oo( 0.0,0.0,0.0 ); MFloatPoint ow = oo * matrixOToW; MFloatPoint oc = ow * matrixWToC; MFloatVector origin( oc[0], oc[1], oc[2] ); nA = origin - surfacePoint; nA.normalize(); }else{ nA = ca; } MFloatVector x = N ^ nA; x.normalize(); MFloatVector y = N ^ x; y.normalize(); MFloatVector azimuthH = N ^ half; azimuthH = N ^ azimuthH; azimuthH.normalize(); float cos_phai = x * azimuthH; float sin_phai = 0.0; if( fabs(1 - cos_phai*cos_phai) < 0.0001 ){ sin_phai = 0.0; }else{ sin_phai = sqrtf( 1.0f - cos_phai*cos_phai ); } double co = pow( (half * N), 4.0f ); double t = tan( acos(half*N) ); t *= -t; float rough1 = block.inputValue( aRoughness1 ).asFloat(); float rough2 = block.inputValue( aRoughness2 ).asFloat(); double aaa = cos_phai / rough1; double bbb = sin_phai / rough2; t = t * ( aaa*aaa + bbb*bbb ); double D = pow( (1.0/((double)rough1*(double)rough2 * co)), t ); double aa = (2.0 * (N*half) * (N*viewDirection) ) / (viewDirection*half); double bb = (2.0 * (N*half) * (N*lightDirection) ) / (viewDirection*half); double cc = 1.0; double G = 0.0; G = MIN( aa, bb ); G = MIN( G, cc ); float s = (float) (D * G / (double)((N*lightDirection) * (N*viewDirection))); MFloatVector& specColor = block.inputValue( aSpecColor ).asFloatVector(); specularColor[0] += lightIntensity[0] * specColor[0] * s * specularCoeff; specularColor[1] += lightIntensity[1] * specColor[1] * s * specularCoeff; specularColor[2] += lightIntensity[2] * specColor[2] * s * specularCoeff; } } if( !lightData.next() ){ break; } } // result = specular + diffuse + ambient; resultColor = diffuseColor + specularColor + ambientColor; MFloatVector& transparency = block.inputValue( aInTransparency ).asFloatVector(); resultColor[0] *= ( 1.0f - transparency[0] ); resultColor[1] *= ( 1.0f - transparency[1] ); resultColor[2] *= ( 1.0f - transparency[2] ); // set ouput color attribute MDataHandle outColorHandle = block.outputValue( aOutColor ); MFloatVector& outColor = outColorHandle.asFloatVector(); outColor = resultColor; outColorHandle.setClean(); block.setClean( plug ); } else if ((plug == aOutTransparency) || (plug.parent() == aOutTransparency)) { MFloatVector& tr = block.inputValue( aInTransparency ).asFloatVector(); // set ouput color attribute MDataHandle outTransHandle = block.outputValue( aOutTransparency ); MFloatVector& outTrans = outTransHandle.asFloatVector(); outTrans = tr; block.setClean( plug ); } else return MS::kUnknownParameter; return MS::kSuccess; }
void TestDeformer::initVertMapping(MDataBlock& data, MItGeometry& iter, const MMatrix& localToWorldMatrix, unsigned int mIndex) { MStatus status; MArrayDataHandle vertMapOutArrayData = data.outputArrayValue( vert_map, &status ); CHECK_MSTATUS( status ); // use vertMapOutArrayBuilder to modify vertMapOutArrayData iter.reset(); int count = iter.count(); MArrayDataBuilder vertMapOutArrayBuilder( vert_map, count, &status ); CHECK_MSTATUS( status ); MPointArray allPts;// world vertex position of the driven mesh allPts.clear(); // walk through the driven mesh /// copy MItGeometry's vertex to vertMapOutArrayData int i = 0; while( !iter.isDone(&status) ) { CHECK_MSTATUS( status ); MDataHandle initIndexDataHnd = vertMapOutArrayBuilder.addElement( i, &status ); CHECK_MSTATUS( status ); int negIndex = -1; initIndexDataHnd.setInt( negIndex ); initIndexDataHnd.setClean(); // append a vertex position(world coordination) to allPts CHECK_MSTATUS(allPts.append( iter.position() * localToWorldMatrix )); i = i+1; iter.next(); } CHECK_MSTATUS(vertMapOutArrayData.set( vertMapOutArrayBuilder )); /// Append more vertex from each driver mesh to vertMapOutArrayData MArrayDataHandle meshAttrHandle = data.inputArrayValue( driver_mesh, &status ); CHECK_MSTATUS( status ); int numMeshes = meshAttrHandle.elementCount(); __debug("%s(), numMeshes=%d", __FUNCTION__, numMeshes); CHECK_MSTATUS(meshAttrHandle.jumpToElement(0)); for( int meshIndex=0; meshIndex < numMeshes; ++meshIndex ) { __debug("%s(), meshIndex=%d", __FUNCTION__, meshIndex); MDataHandle currentMesh = meshAttrHandle.inputValue(&status); CHECK_MSTATUS(status); MObject meshMobj = currentMesh.asMesh(); __debug("%s(), meshMobj.apiTypeStr()=%s", __FUNCTION__, meshMobj.apiTypeStr()); __debugMeshInfo(__FUNCTION__, meshMobj); { _initVertMapping_on_one_mesh(meshMobj, vertMapOutArrayBuilder, allPts);// Note: vertMapOutArrayBuilder is updated in this function! //CHECK_MSTATUS(vertMapOutArrayData.set( vertMapOutArrayBuilder )); } if( !meshAttrHandle.next() ) { break; } }// for (mesh CHECK_MSTATUS(vertMapOutArrayData.set( vertMapOutArrayBuilder )); }
// 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 asMicrofacet_brdf::compute( const MPlug& plug, MDataBlock& block ) { // The plug parameter will allow us to determine which output attribute // needs to be calculated. // if( plug == aOutColor || plug == aOutTransparency || plug.parent() == aOutColor || plug.parent() == aOutTransparency ) { MStatus status; MFloatVector resultColor( 0.0, 0.0, 0.0 ); // Get surface shading parameters from input block // MFloatVector& surfaceNormal = block.inputValue( aNormalCamera, &status ).asFloatVector(); CHECK_MSTATUS( status ); MFloatVector& surfaceColor = block.inputValue( aColor, &status ).asFloatVector(); CHECK_MSTATUS( status ); MFloatVector& incandescence = block.inputValue( aIncandescence, &status ).asFloatVector(); CHECK_MSTATUS( status ); float diffuseReflectivity = block.inputValue( aDiffuseReflectivity, &status ).asFloat(); CHECK_MSTATUS( status ); // float translucenceCoeff = block.inputValue( aTranslucenceCoeff, // &status ).asFloat(); // CHECK_MSTATUS( status ); // Get light list // MArrayDataHandle lightData = block.inputArrayValue( aLightData, &status ); CHECK_MSTATUS( status ); int numLights = lightData.elementCount( &status ); CHECK_MSTATUS( status ); // Calculate the effect of the lights in the scene on the color // // Iterate through light list and get ambient/diffuse values // for( int count=1; count <= numLights; count++ ) { // Get the current light out of the array // MDataHandle currentLight = lightData.inputValue( &status ); CHECK_MSTATUS( status ); // Get the intensity of that light // MFloatVector& lightIntensity = currentLight.child( aLightIntensity ).asFloatVector(); // Find ambient component // if ( currentLight.child( aLightAmbient ).asBool() ) { resultColor += lightIntensity; } // Find diffuse component // if ( currentLight.child( aLightDiffuse ).asBool() ) { MFloatVector& lightDirection = currentLight.child( aLightDirection ).asFloatVector(); float cosln = lightDirection * surfaceNormal; if ( cosln > 0.0f ) { resultColor += lightIntensity * ( cosln * diffuseReflectivity ); } } // Advance to the next light. // if ( count < numLights ) { status = lightData.next(); CHECK_MSTATUS( status ); } } // Factor incident light with surface color and add incandescence // resultColor[0] = resultColor[0] * surfaceColor[0] + incandescence[0]; resultColor[1] = resultColor[1] * surfaceColor[1] + incandescence[1]; resultColor[2] = resultColor[2] * surfaceColor[2] + incandescence[2]; // Set ouput color attribute // if ( plug == aOutColor || plug.parent() == aOutColor ) { // Get the handle to the attribute // MDataHandle outColorHandle = block.outputValue( aOutColor, &status ); CHECK_MSTATUS( status ); MFloatVector& outColor = outColorHandle.asFloatVector(); outColor = resultColor; // Set the output value outColorHandle.setClean(); // Mark the output value as clean } // Set ouput transparency // if ( plug == aOutTransparency || plug.parent() == aOutTransparency ) { MFloatVector& transparency = block.inputValue( aInTransparency, &status ).asFloatVector(); CHECK_MSTATUS( status ); // Get the handle to the attribute // MDataHandle outTransHandle = block.outputValue( aOutTransparency, &status ); CHECK_MSTATUS( status ); MFloatVector& outTrans = outTransHandle.asFloatVector(); outTrans = transparency; // Set the output value outTransHandle.setClean(); // Mark the output value as clean } } else { return( MS::kUnknownParameter ); // We got an unexpected plug } return( MS::kSuccess ); }
MStatus updateTCCDataNode::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 // { MStatus status = MS::kSuccess; MDataHandle stateData = data.outputValue( state, &status ); MCheckStatus( status, "ERROR getting state" ); // Check for the HasNoEffect/PassThrough flag on the node. // // (stateData is an enumeration standard in all depend nodes - stored as short) // // (0 = Normal) // (1 = HasNoEffect/PassThrough) // (2 = Blocking) // ... // if( stateData.asShort() == 1 ) { MDataHandle inputData = data.inputValue( inMesh, &status ); MCheckStatus(status,"ERROR getting inMesh"); MDataHandle outputData = data.outputValue( outMesh, &status ); MCheckStatus(status,"ERROR getting outMesh"); // Simply redirect the inMesh to the outMesh for the PassThrough effect // outputData.set(inputData.asMesh()); } else { // 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 == outMesh) { MDataHandle inputData = data.inputValue( inMesh, &status ); MCheckStatus(status,"ERROR getting inMesh"); MDataHandle outputData = data.outputValue( outMesh, &status ); MCheckStatus(status,"ERROR getting outMesh"); MIntArray vR = MFnIntArrayData( data.inputValue( vtxRemap ).data() ).array(&status); MCheckStatus(status,"ERROR getting vtxRemap"); MIntArray pO = MFnIntArrayData( data.inputValue( polyOrder ).data() ).array(&status); MCheckStatus(status,"ERROR getting polyOrder"); MIntArray cS = MFnIntArrayData( data.inputValue( cShift ).data() ).array(&status); MCheckStatus(status,"ERROR getting cShift"); MIntArray dnFV = MFnIntArrayData( data.inputValue( delta_nFV ).data() ).array(&status); MCheckStatus(status,"ERROR getting deltanFV"); MIntArray dF = MFnIntArrayData( data.inputValue( delta_F ).data() ).array(&status); MCheckStatus(status,"ERROR getting deltaF"); int nVtx = data.inputValue( nV ).asInt(); MCheckStatus(status,"ERROR getting nV"); // Copy the inMesh to the outMesh, and now you can // perform operations in-place on the outMesh // outputData.set(inputData.asMesh()); MObject mesh = outputData.asMesh(); fupdateTCCDataFactory.setMesh( mesh ); fupdateTCCDataFactory.setVtxRemap( vR ); fupdateTCCDataFactory.setPolyOrder( pO ); fupdateTCCDataFactory.setCShift( cS ); fupdateTCCDataFactory.setDelta_nFV( dnFV ); fupdateTCCDataFactory.setDelta_F( dF ); fupdateTCCDataFactory.setnV( nVtx ); // Now, perform the updateTCCData // status = fupdateTCCDataFactory.doIt(); // Mark the output mesh as clean // outputData.setClean(); } else { status = MS::kUnknownParameter; } } return status; }