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