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