MObject getOtherSideSourceNode(MString& plugName, MObject& thisObject, bool checkChildren, MString& outPlugName)
{
MStatus stat;
MObject result = MObject::kNullObj;
MFnDependencyNode depFn(thisObject, &stat); if (stat != MStatus::kSuccess) return result;
MPlugArray pa;
depFn.getConnections(pa);
MPlug connectedPlug;
for (uint pId = 0; pId < pa.length(); pId++)
{
MPlug plug = pa[pId];
if (!plug.isDestination())
continue;
while (plug.isChild())
{
plug = plug.parent();
}
if (getAttributeNameFromPlug(plug) == plugName)
{
connectedPlug = pa[pId];
}
}
if (connectedPlug.isNull())
return result;
connectedPlug.connectedTo(pa, true, false, &stat); if (stat != MStatus::kSuccess) return result;
if (pa.length() == 0)
return result;
MPlug otherSidePlug = pa[0];
result = otherSidePlug.node();
outPlugName = getAttributeNameFromPlug(otherSidePlug);
if (otherSidePlug.isChild())
outPlugName = getAttributeNameFromPlug(otherSidePlug.parent());
return result;
}
//
// DESCRIPTION:
///////////////////////////////////////////////////////
MStatus ShadowMatte::compute(
const MPlug& plug,
MDataBlock& block )
{
if ((plug != aOutColor) && (plug.parent() != aOutColor) &&
(plug != aOutTransparency) && (plug.parent() != aOutTransparency))
return MS::kUnknownParameter;
MFloatVector shadowColor(0.0,0.0,0.0);
bool ViewFlag = block.inputValue( aViewColor ).asBool();
// get light list
MArrayDataHandle lightData = block.inputArrayValue( aLightData );
int numLights = lightData.elementCount();
// iterate through light list and get ambient/diffuse values
for( int count=1; count <= numLights; count++ )
{
MDataHandle currentLight = lightData.inputValue();
float lightShadow = currentLight.child(aLightShadowFraction).asFloat();
// shadow fraction tells how much an object is in shadow:
// (1) totally in shadow
// (0-1) partially in shadow
// (0) not in shadow
shadowColor[0] += lightShadow;
shadowColor[1] += lightShadow;
shadowColor[2] += lightShadow;
if( !lightData.next() ) break;
}
// set ouput color attribute
MFloatVector ghostColor(0.0,0.0,0.0);
MDataHandle outColorHandle = block.outputValue( aOutColor );
MFloatVector& outColor = outColorHandle.asFloatVector();
if (ViewFlag)
outColor = shadowColor;
else
outColor = ghostColor;
outColorHandle.setClean();
// set ouput transparency
MDataHandle outTransHandle = block.outputValue( aOutTransparency );
MFloatVector& outTrans = outTransHandle.asFloatVector();
outTrans = shadowColor;
outTransHandle.setClean();
return MS::kSuccess;
}
MStatus blendCurve::setDependentsDirty( const MPlug& plug, MPlugArray& plugArr )
{
MStatus status;
if( plug == inputGeom )
{
m_isInputGeomDirty = true;
}
else if( plug == aInputCurve )
{
unsigned int logicalIndex = plug.parent().logicalIndex();
if( !m_inputInfoArray.length < logicalIndex +1 )
{
m_inputInfoArray.setLength( logicalIndex+1 );
m_lengthDirty = true;
}
m_inputInfoArray[ logicalIndex ].isCurveDirty = true;
}
else if( plug == aWeight )
{
unsigned int logicalIndex = plug.parent().logicalIndex();
if( !m_inputInfoArray.length < logicalIndex +1 )
{
m_inputInfoArray.setLength( logicalIndex+1 );
m_lengthDirty = true;
}
m_inputInfoArray[ logicalIndex ].isValuesDirty = true;
}
else if( plug == aBlendPosition )
{
unsigned int logicalIndex = plug.parent().logicalIndex();
if( !m_inputInfoArray.length < logicalIndex +1 )
{
m_inputInfoArray.setLength( logicalIndex+1 );
m_lengthDirty = true;
}
m_inputInfoArray[ logicalIndex ].isValuesDirty = true;
}
else if( plug == aBlendArea )
{
unsigned int logicalIndex = plug.parent().logicalIndex();
if( !m_inputInfoArray.length < logicalIndex +1 )
{
m_inputInfoArray.setLength( logicalIndex+1 );
m_lengthDirty = true;
}
m_inputInfoArray[ logicalIndex ].isValuesDirty = true;
}
return status;
}
bool isConnected(const char *attrName, MFnDependencyNode& depFn, bool dest, bool primaryChild = false)
{
MStatus stat;
MPlugArray pa;
depFn.getConnections(pa);
for (uint pId = 0; pId < pa.length(); pId++)
{
if (dest)
{
if (!pa[pId].isDestination())
continue;
}
else{
if (!pa[pId].isSource())
continue;
}
MPlug plug = pa[pId];
if (primaryChild)
while (plug.isChild())
plug = plug.parent();
if (plug.isElement())
plug = plug.array();
if ((getAttributeNameFromPlug(plug) == attrName))
return true;
}
return false;
}
//
// 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;
}
MPlug getParentPlug(MPlug& p)
{
MPlug tmp = p;
while (tmp.isChild())
tmp = tmp.parent();
return tmp;
}
void ShadingNode::getConnectedInputObjects(MObjectArray& objectArray)
{
MStatus stat;
MFnDependencyNode depFn(this->mobject);
MStringArray aliasArray;
depFn.getAliasList(aliasArray);
MObjectArray objectList;
MPlugArray connections;
depFn.getConnections(connections);
for (uint connId = 0; connId < connections.length(); connId++)
{
MPlug p = connections[connId];
if (!p.isDestination())
continue;
// a connection can be a direct connection or a child connection e.g. colorR, colorG...
// but in a shader description file only the main attribute is listed so we go up until we have the main plug
MPlug mainPlug = p;
while (mainPlug.isChild())
mainPlug = mainPlug.parent();
if (mainPlug.isElement())
mainPlug = mainPlug.array();
MStringArray stringArray;
// name contains node.attributeName, so we have to get rid of the nodeName
mainPlug.name().split('.', stringArray);
MString plugName = stringArray[stringArray.length() - 1];
if (!this->isAttributeValid(plugName))
continue;
getConnectedInNodes(p, objectList);
makeUniqueArray(objectList);
}
objectArray = objectList;
}
bool ShadingNode::isAttributeValid(MString attributeName)
{
MStatus stat;
MFnDependencyNode depFn(this->mobject);
MPlugArray pa;
depFn.getConnections(pa);
for (uint pId = 0; pId < pa.length(); pId++)
{
if (pa[pId].isDestination())
{
MPlug parentPlug = pa[pId];
while (parentPlug.isChild())
parentPlug = parentPlug.parent();
MString plugName = getAttributeNameFromPlug(parentPlug);
if (plugName == attributeName)
{
for (size_t inattrId = 0; inattrId < this->inputAttributes.size(); inattrId++)
{
if (attributeName == inputAttributes[inattrId].name.c_str())
return true;
}
}
}
}
return false;
}
//
// 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 SargassoNode::compute( const MPlug& plug, MDataBlock& block )
{
MStatus stat;
if(!m_isInitd) return stat;
if(plug == constraintRotateX ||
plug == constraintRotateY ||
plug == constraintRotateZ ||
plug == constraintTranslateX ||
plug == constraintTranslateY ||
plug == constraintTranslateZ) {
// AHelper::Info<MString>("ov child", plug.name());
// AHelper::Info<unsigned>("ov id", plug.parent().logicalIndex());
unsigned iobject = plug.parent().logicalIndex();
if(iobject > m_numObjects-1) {
MGlobal::displayInfo("n constraint is out of bound");
return MS::kSuccess;
}
if(iobject == 0 && plug == constraintRotateX) {
MDataHandle hm = block.inputValue(atargetMesh);
updateShape(hm.asMesh());
}
if(plug == constraintRotateX)
updateSpace(block, iobject);
MDataHandle hout = block.outputValue(plug, &stat);
if(plug == constraintTranslateX) {
hout.set(m_solvedT.x);
}
else if(plug == constraintTranslateY) {
hout.set(m_solvedT.y);
}
else if(plug == constraintTranslateZ) {
hout.set(m_solvedT.z);
}
else if(plug == constraintRotateX) {
hout.set(m_rot[0]);
}
else if(plug == constraintRotateY) {
hout.set(m_rot[1]);
}
else if(plug == constraintRotateZ) {
hout.set(m_rot[2]);
}
block.setClean( plug );
}
else
return MS::kUnknownParameter;
return MS::kSuccess;
}
MStatus 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;
}
int getChildId(MPlug& plug)
{
if (!plug.isChild())
return -1;
MPlug parentPlug = plug.parent();
for (uint chId = 0; chId < parentPlug.numChildren(); chId++)
{
if (parentPlug.child(chId) == plug)
return chId;
}
return -1;
}
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;
}
MStatus sgBulgeDeformer::setDependentsDirty(const MPlug& plug, MPlugArray& plugs)
{
MStatus status;
if( plug == aMesh || plug == aMatrix )
{
unsigned int logicalIndex = plug.parent().logicalIndex();
if (logicalIndex > mem_maxLogicalIndex)
{
mem_maxLogicalIndex = logicalIndex;
mem_resetElements = true;
}
}
return status;
}
MStatus Cell3D::compute(const MPlug& plug, MDataBlock& block)
{
if ( (plug != aOutColor) && (plug.parent() != aOutColor) &&
(plug != aOutAlpha) &&
(plug != aOutBorderDist) &&
(plug != aOutF0) && (plug != aOutF1) && (plug != aOutN0)
)
return MS::kUnknownParameter;
const float3& worldPos = block.inputValue(aPointWorld).asFloat3();
const MFloatMatrix& m = block.inputValue(aPlaceMat).asFloatMatrix();
const MFloatVector& cGain = block.inputValue(aColorGain).asFloatVector();
const MFloatVector& cOff = block.inputValue(aColorOffset).asFloatVector();
MFloatPoint q(worldPos[0], worldPos[1], worldPos[2]);
q *= m; // Convert into solid space
float n0, f0, f1;
cellFunc(R3(q.x, q.y, q.z), n0, f0, f1);
MDataHandle outHandle = block.outputValue(aOutF0);
outHandle.asFloat() = f0;
outHandle.setClean();
outHandle = block.outputValue(aOutF1);
outHandle.asFloat() = f1;
outHandle.setClean();
outHandle = block.outputValue(aOutN0);
outHandle.asFloat() = n0;
outHandle.setClean();
outHandle = block.outputValue(aOutBorderDist);
outHandle.asFloat() = 0.5f*(f1 - f0);
outHandle.setClean();
outHandle = block.outputValue( aOutColor );
MFloatVector & outColor = outHandle.asFloatVector();
outColor = cGain * f0 + cOff;
outHandle.setClean();
outHandle = block.outputValue(aOutAlpha);
outHandle.asFloat() = f0;
outHandle.setClean();
return MS::kSuccess;
}
//
// 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 ParameterisedHolder<B>::setDependentsDirty( const MPlug &plug, MPlugArray &plugArray )
{
if( plug==aParameterisedClassName || plug==aParameterisedVersion || plug==aParameterisedSearchPathEnvVar )
{
// if the held class changes in any way then we ditch it so we're forced to reload
// in getParameterised().
m_parameterised = 0;
m_failedToLoad = false;
}
else
{
// if the plug represents a parameter then we add that parameter to a list
// of dirty parameters. this lets us optimise setParameterisedValues so we only
// set the values of parameters whose plugs have changed since last time.
// we only bother doing this if we've loaded the class already, as calling plugParameter()
// would otherwise cause a premature loading of the class. when we load the class all parameters
// are marked as dirty anyway so there's no point worrying about it here.
if( m_parameterised )
{
MPlug p = plug;
ParameterPtr parameter = 0;
do
{
parameter = plugParameter( p );
if( p.isChild() )
{
p = p.parent();
}
else if( p.isElement() )
{
p = p.array();
}
else
{
p = MPlug();
}
} while( !parameter && !p.isNull() );
if( parameter )
{
m_dirtyParameters.insert( parameter );
}
}
}
return B::setDependentsDirty( plug, plugArray );
}
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 woodTexNode::compute(const MPlug &plug, MDataBlock &data)
{
MStatus stat=MStatus::kSuccess;
if ((plug !=Output)&&(plug.parent() != Output))
{
return MStatus::kUnknownParameter;
}
MDataHandle indexColor=data.inputValue(textureColor);
const MFloatVector & iColor=indexColor.asFloatVector();
MDataHandle outColorHandle=data.outputValue(Output);
MFloatVector & outColor=outColorHandle.asFloatVector();
outColor=iColor;
outColorHandle.setClean();
return stat;
}
// 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;
}
MStatus roughGlassNode::compute(const MPlug &plug, MDataBlock &data)
{
MStatus stat=MStatus::kSuccess;
if ((plug !=outRoughGlass)&&(plug.parent() != outRoughGlass))
{
return MStatus::kUnknownParameter;
}
MDataHandle indexColor=data.inputValue(absorbColor);
const MFloatVector & color=indexColor.asFloatVector();
MDataHandle outColorHandle=data.outputValue(outRoughGlass);
MFloatVector & outColor=outColorHandle.asFloatVector();
outColor=color;
outColorHandle.setClean();
return stat;
}
MStatus texLayerNode::compute(const MPlug &plug, MDataBlock &data)
{
MStatus stat;
if ((plug !=layerOutput)&&(plug.parent() != layerOutput))
{
return MStatus::kUnknownParameter;
}
MDataHandle indexColor=data.inputValue(layerInput1);
const MFloatVector & color=indexColor.asFloatVector();
MDataHandle outColorHandle=data.outputValue(layerOutput);
MFloatVector & outColor=outColorHandle.asFloatVector();
outColor=color;
outColorHandle.setClean();
return stat;
}
bool isConnected(const char *attrName, MFnDependencyNode& depFn, bool dest, bool primaryChild = false)
{
MStatus stat;
MPlugArray pa;
depFn.getConnections(pa);
std::vector<std::string> stringParts;
pystring::split(attrName, stringParts, ".");
MString attName = attrName;
if (stringParts.size() > 1)
attName = stringParts.back().c_str();
if (pystring::endswith(attrName, "]"))
{
int found = attName.rindex('[');
if (found >= 0)
attName = attName.substring(0, found-1);
}
for (uint pId = 0; pId < pa.length(); pId++)
{
if (dest)
{
if (!pa[pId].isDestination())
continue;
}
else
{
if (!pa[pId].isSource())
continue;
}
MPlug plug = pa[pId];
if (primaryChild)
while (plug.isChild())
plug = plug.parent();
MString plugName = plug.name();
if (plug.isElement())
plug = plug.array();
MString attNameFromPlug = getAttributeNameFromPlug(plug);
if ((attNameFromPlug == attName))
return true;
}
return false;
}
int physicalIndex(MPlug& p)
{
MPlug parent = p;
while (parent.isChild())
parent = parent.parent();
if (!parent.isElement())
return -1;
if (!parent.array())
return - 1;
MPlug arrayPlug = parent.array();
for (uint i = 0; i < arrayPlug.numElements(); i++)
if (arrayPlug[i].logicalIndex() == parent.logicalIndex())
return i;
return -1;
}
//
// 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 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;
}
//
// 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;
}
bool ShadingNode::isOutPlugValid(MPlug plug)
{
MPlug tmpPlug = plug;
if (!tmpPlug.isSource())
return false;
while (tmpPlug.isChild())
tmpPlug = tmpPlug.parent();
// if we have an array, check the main plug
if (tmpPlug.isElement())
tmpPlug = tmpPlug.array();
MString plugName = getAttributeNameFromPlug(tmpPlug);
for (size_t attrId = 0; attrId < this->outputAttributes.size(); attrId++)
{
if (plugName == outputAttributes[attrId].name.c_str())
return true;
}
return false;
}
