MStatus polyModifierCmd::cacheMeshData() { MStatus status = MS::kSuccess; MFnDependencyNode depNodeFn; MFnDagNode dagNodeFn; MObject meshNode = fDagPath.node(); MObject dupMeshNode; MPlug dupMeshNodeOutMeshPlug; // Duplicate the mesh // dagNodeFn.setObject( meshNode ); dupMeshNode = dagNodeFn.duplicate(); MDagPath dupMeshDagPath; MDagPath::getAPathTo( dupMeshNode, dupMeshDagPath ); dupMeshDagPath.extendToShape(); depNodeFn.setObject( dupMeshDagPath.node() ); dupMeshNodeOutMeshPlug = depNodeFn.findPlug( "outMesh", &status ); MCheckStatus( status, "Could not retrieve outMesh" ); // Retrieve the meshData // status = dupMeshNodeOutMeshPlug.getValue( fMeshData ); MCheckStatus( status, "Could not retrieve meshData" ); // Delete the duplicated node // MGlobal::deleteNode( dupMeshNode ); return status; }
//############################################### tima: bool polyModifierCmd::setZeroTweaks() { MFnNumericData numDataFn; MObject nullVector; MFnDependencyNode depNodeFn; numDataFn.create( MFnNumericData::k3Float ); numDataFn.setData( 0, 0, 0 ); nullVector = numDataFn.object(); MObject object = fDagPath.node(); depNodeFn.setObject( object); MPlug meshTweakPlug = depNodeFn.findPlug( "pnts" ); MPlug tweak; unsigned numTweaks = fTweakIndexArray.length(); if( !meshTweakPlug.isNull() ) { for( unsigned i = 0; i < numTweaks; i++ ) { tweak = meshTweakPlug.elementByLogicalIndex( fTweakIndexArray[i] ); tweak.setValue( nullVector ); } } return true; }
bool PxrUsdMayaWriteUtil::ReadMayaAttribute( const MFnDependencyNode& depNode, const MString& name, VtVec3fArray* val) { MStatus status; depNode.attribute(name, &status); if (status == MS::kSuccess) { MPlug plug = depNode.findPlug(name); MObject dataObj; if ( (plug.getValue(dataObj) == MS::kSuccess) && (dataObj.hasFn(MFn::kVectorArrayData)) ) { MFnVectorArrayData dData(dataObj, &status); if (status == MS::kSuccess) { MVectorArray arrayValues = dData.array(); size_t numValues = arrayValues.length(); val->resize(numValues); for (size_t i = 0; i < numValues; ++i) { (*val)[i].Set( arrayValues[i][0], arrayValues[i][1], arrayValues[i][2]); } return true; } } } return false; }
void EntityNode::UnloadArt() { MStatus stat; // remove anything currently imported/referenced MFnDagNode dagFn( thisMObject() ); while( dagFn.childCount() ) { stat = MGlobal::deleteNode( dagFn.child( 0 ) ); MContinueErr( stat, ("Unable to delete" + dagFn.fullPathName() ).asChar() ); } ClearInstances(); MObjectArray forDelete; GetImportNodes( forDelete ); MFnDependencyNode depFn; u32 num = forDelete.length(); for( u32 i = 0; i < num; ++i ) { MObject& node = forDelete[i]; MObjectHandle handle( node ); if( !handle.isValid() ) continue; depFn.setObject( node ); stat = MGlobal::deleteNode( node ); MContinueErr( stat, ("Unable to delete" + depFn.name() ).asChar() ); } forDelete.clear(); }
void ExtractAttribute(MFnDependencyNode& fn, std::string name, SMatAttrib& attrib) { MPlug p; // extract attribute color std::string r = name + "R"; std::string g = name + "G"; std::string b = name + "B"; p = fn.findPlug(r.c_str()); p.getValue(attrib.color[0]); p = fn.findPlug(g.c_str()); p.getValue(attrib.color[1]); p = fn.findPlug(b.c_str()); p.getValue(attrib.color[2]); // extract attribute texture MString texname; p = fn.findPlug(name.c_str()); MPlugArray plugs; p.connectedTo(plugs,true,true); for(int i = 0; i != plugs.length(); ++i) { if (plugs[i].node().apiType() == MFn::kFileTexture) { MFnDependencyNode fnDep(plugs[i].node()); texname = fnDep.name(); break; } } attrib.textureID = GetTextureID( texname ); }
//--------------------------------------------------- bool DagHelper::connectToList ( const MPlug& source, const MObject& destination, const MString& destinationAttribute, int* _index ) { MStatus status; MFnDependencyNode destFn ( destination ); MPlug dest = destFn.findPlug ( destinationAttribute, &status ); if ( status != MStatus::kSuccess ) return false; if ( !dest.isArray() ) return false; int index = ( _index != NULL ) ? *_index : -1; if ( index < 0 ) { index = getNextAvailableIndex ( dest, ( int ) dest.evaluateNumElements() ); if ( _index != NULL ) *_index = index; } MPlug d = dest.elementByLogicalIndex ( index ); MDGModifier modifier; modifier.connect ( source, d ); status = modifier.doIt(); return status == MStatus::kSuccess; }
void AttributeParser::parseAttributes(MFnDependencyNode & fnNode, AttributeParser & parser) { MStatus status; unsigned int attrCount = fnNode.attributeCount(&status); if (!status) return; std::set<String> parsedAttributes; for (unsigned int attrIndex = 0; attrIndex < attrCount; ++attrIndex) { MObject attrObject = fnNode.attribute(attrIndex, &status); if (!status) continue; MFnAttribute fnAttr(attrObject, &status); if (!status) continue; MString attrName = fnAttr.name(&status); if (!status) continue; // Don't parse the same attribute twice. // This can happen with compound attributes. String attrNameStr = attrName.asChar(); if (parsedAttributes.find(attrNameStr) != parsedAttributes.end()) { continue; } parsedAttributes.insert(attrNameStr); parser.parseAttribute(fnNode, attrObject, parsedAttributes); } }
// -------------------------------------------------------------------------------------------- void polyModifierCmd::collectNodeState() // -------------------------------------------------------------------------------------------- { MStatus status; // Collect node state information on the given polyMeshShape // // - HasHistory (Construction History exists) // - HasTweaks // - HasRecordHistory (Construction History is turned on) // fDagPath.extendToShape(); MObject meshNodeShape = fDagPath.node(); MFnDependencyNode depNodeFn; depNodeFn.setObject( meshNodeShape ); MPlug inMeshPlug = depNodeFn.findPlug( "inMesh" ); fHasHistory = inMeshPlug.isConnected(); // Tweaks exist only if the multi "pnts" attribute contains plugs // which contain non-zero tweak values. Use false, until proven true // search algorithm. // fHasTweaks = false; MPlug tweakPlug = depNodeFn.findPlug( "pnts" ); if( !tweakPlug.isNull() ) { // ASSERT: tweakPlug should be an array plug! // MAssert( (tweakPlug.isArray()), "tweakPlug.isArray() -- tweakPlug is not an array plug" ); MPlug tweak; MFloatVector tweakData; int i; int numElements = tweakPlug.numElements(); for( i = 0; i < numElements; i++ ) { tweak = tweakPlug.elementByPhysicalIndex( i, &status ); if( status == MS::kSuccess && !tweak.isNull() ) { getFloat3PlugValue( tweak, tweakData ); if( 0 != tweakData.x || 0 != tweakData.y || 0 != tweakData.z ) { fHasTweaks = true; break; } } } } int result; MGlobal::executeCommand( "constructionHistory -q -tgl", result ); fHasRecordHistory = (0 != result); }
MStatus PRTAttrs::addParameter(MFnDependencyNode & node, MObject & attr, MFnAttribute& tAttr) { if(!(node.hasAttribute(tAttr.shortName()))) { MCHECK(tAttr.setKeyable (true)); MCHECK(tAttr.setHidden(false)); MCHECK(tAttr.setStorable(true)); MCHECK(node.addAttribute(attr)); } return MS::kSuccess; }
//--------------------------- String DocumentExporter::dagPathToColladaName ( const MDagPath& dagPath ) { // Get a COLLADA suitable node name from a DAG path // For import/export symmetry, this should be exactly the // Maya node name. If we include any more of the path, we'll // get viral node names after repeated import/export. MFnDependencyNode node ( dagPath.node() ); return mayaNameToColladaName ( node.name(), true ); }
std::string CMayaNode::GetName() { MStatus status; MFnDependencyNode depNode (m_dagPath.node(), &status); if (status != MS::kSuccess) return ""; return depNode.name ().asChar(); }
void Exporter::extractColor(Color& tempcolor, MFnDependencyNode& fn, MString name) { MPlug p; MString r = name; r += "R"; MString g = name; g += "G"; MString b = name; b += "B"; MString a = name; a += "A"; p = fn.findPlug(r.asChar()); p.getValue(tempcolor.r); p = fn.findPlug(g.asChar()); p.getValue(tempcolor.g); p = fn.findPlug(b.asChar()); p.getValue(tempcolor.b); p = fn.findPlug(a.asChar()); p.getValue(tempcolor.a); p = fn.findPlug(name.asChar()); MPlugArray connections; p.connectedTo(connections, true, false); int debug = connections.length(); for (int i = 0; i != connections.length(); ++i) { // if file texture found if (connections[i].node().apiType() == MFn::kFileTexture) { // bind a function set to it .... MFnDependencyNode fnDep(connections[i].node()); // to get the node name tempcolor.texfileInternal = fnDep.name().asChar(); MPlug filename = fnDep.findPlug("ftn"); //sparar hela s�kv�gen till texturen tempcolor.texfileExternal = filename.asString().asChar(); //kopierar texturfiler std::string base_filename = tempcolor.texfileExternal.substr(tempcolor.texfileExternal.find_last_of("/\\") + 1); CopyFile(tempcolor.texfileExternal.c_str(), base_filename.c_str(), false); // stop looping break; } } }
MStatus polyModifierCmd::processModifierNode( MObject modifierNode, modifyPolyData& data ) { MStatus status = MS::kSuccess; MFnDependencyNode depNodeFn ( modifierNode ); data.modifierNodeSrcAttr = depNodeFn.attribute( "outMesh" ); data.modifierNodeDestAttr = depNodeFn.attribute( "inMesh" ); return status; }
//--------------------------------------------------- MObject DagHelper::createExpression ( const MPlug& plug, const MString& expression ) { MFnDependencyNode expressionFn; MObject expressionObj = expressionFn.create ( "expression" ); DagHelper::setPlugValue ( expressionObj, "expression", expression ); MPlug output = expressionFn.findPlug ( "output" ); MPlug firstOutput = output.elementByLogicalIndex ( 0 ); DagHelper::connect ( firstOutput, plug ); return expressionObj; }
//--------------------------------------------------- bool DagHelper::connectToList ( const MObject& source, const MString& sourceAttribute, const MObject& destination, const MString& destinationAttribute, int* index ) { MStatus status; MFnDependencyNode srcFn ( source ); MPlug src = srcFn.findPlug ( sourceAttribute, &status ); if ( status != MStatus::kSuccess ) return false; return connectToList ( src, destination, destinationAttribute, index ); }
//--------------------------------------- void MaterialExporter::exportCustomHwShaderNode( COLLADASW::InstanceEffect &effectInstance, MObject shader ) { MFnDependencyNode fnNode ( shader ); if ( fnNode.typeId() == cgfxShaderNode::sId ) { // Add the technique hint and the effect attributes to the collada document. exportCgfxShaderNode ( effectInstance, (cgfxShaderNode*) fnNode.userNode () ); } }
MString AppleseedRenderer::defineColor(MFnDependencyNode& shader, MString& attributeName, MString colorSpace = "srgb", float intensity = 1.0f) { MColor col(0,0,0); if(!getColor(attributeName, shader, col)) { logger.error(MString("Unable to get color values from node: ") + shader.name()); return ""; } MString colorName = shader.name() + "_" + attributeName; defineColor(colorName, col, intensity, colorSpace); return colorName; }
//--------------------------------------------------- // set the bind pose for a transform // MStatus DagHelper::setBindPoseInverse ( const MObject& node, const MMatrix& bindPoseInverse ) { MStatus status; MFnDependencyNode dgFn ( node ); MPlug bindPosePlug = dgFn.findPlug ( "bindPose", &status ); if ( status != MS::kSuccess ) { MGlobal::displayWarning ( MString ( "No bindPose found on node " ) + dgFn.name() ); return status; } MFnMatrixData matrixFn; MObject val = matrixFn.create ( bindPoseInverse.inverse(), &status ); MObject invval = matrixFn.create ( bindPoseInverse, &status ); if ( status != MS::kSuccess ) { MGlobal::displayWarning ( MString ( "Error setting bindPose on node " ) + dgFn.name() ); return status; } // set the bind pose on the joint itself bindPosePlug.setValue ( val ); // Now, perhaps more significantly, see if there's a // skinCluster using this bone and update its bind // pose (as the joint bind pose is not connected to // the skin - it's set at bind time from the joint's // current position, and our importer may not want to // disturb the current scene state just to put bones // in a bind position before creating skin clusters) MObject _node ( node ); MItDependencyGraph it ( _node, MFn::kSkinClusterFilter ); while ( !it.isDone() ) { MPlug plug = it.thisPlug(); unsigned int idx = plug.logicalIndex(); MFnDependencyNode skinFn ( plug.node() ); MPlug skinBindPosePlug = skinFn.findPlug ( "bindPreMatrix", &status ); if ( status == MS::kSuccess ) { // The skinCluster stores inverse inclusive matrix // so notice we use invval (the MObject created off // the inverse matrix here) skinBindPosePlug = skinBindPosePlug.elementByLogicalIndex ( idx ); skinBindPosePlug.setValue ( invval ); } it.next(); } return status; }
//--------------------------------------------------- MObject DagHelper::createAnimationCurve ( const MPlug& plug, const char* curveType ) { MStatus rc; MFnDependencyNode curveFn; curveFn.create ( curveType, &rc ); if ( rc == MStatus::kSuccess ) { DagHelper::connect ( curveFn.object(), "output", plug ); } return curveFn.object(); }
// ------------------------------------------- const String& SceneElement::getNodeName() const { if ( mNodeName.empty() ) { const MObject & _node = getNode(); // Attach a function set MFnDependencyNode fn ( _node ); mNodeName = DocumentExporter::mayaNameToColladaName ( fn.name() ); } return mNodeName; }
//--------------------------------------------------- MPlug DagHelper::addAttribute ( const MObject& node, const MObject& attribute ) { MPlug plug; MFnAttribute attributeFn ( attribute ); MFnDependencyNode depFn ( node ); MStatus status = depFn.addAttribute ( attribute, MFnDependencyNode::kLocalDynamicAttr ); if ( status == MStatus::kSuccess ) { plug = depFn.findPlug ( attribute ); } return plug; }
// -------------------------------------------------------- COLLADASW::PrimitivesBase* GeometryPolygonExporter::preparePrimitivesBase( const MFnMesh &fnMesh, const uint numPolygons, const uint exportType ) { // Just create a polylist, if there are polygons to export // If we have holes in the polygon, we have to use <polygons> instead of <polylist>. // If we want to export as triangles, we have to use <triangles>. COLLADASW::PrimitivesBase* primitivesBasePoly = createPrimitivesBase ( exportType ); // Begin to write. primitivesBasePoly->openPrimitiveElement(); // Check if the material should be set uint realShaderCount = ( uint ) mShaders.length(); if ( mShaderPosition < realShaderCount ) { // Add shader-specific parameters (TexCoords sets). // Add symbolic name for the material used on this polygon set. MFnDependencyNode shaderFn ( mShaders[mShaderPosition] ); String shaderName = shaderFn.name().asChar(); String materialName = DocumentExporter::mayaNameToColladaName ( shaderFn.name() ); primitivesBasePoly->appendMaterial ( materialName ); } // Set the number of polygons primitivesBasePoly->appendCount ( numPolygons ); // Get the polygon input list COLLADASW::InputList& inputList = primitivesBasePoly->getInputList(); getPolygonInputAttributes ( inputList ); primitivesBasePoly->appendInputList(); // Set the vertex count list, if we have a POLYLIST if ( exportType == PolygonSource::POLYLIST ) { // Retrieve the vertex count list for the polylist element. primitivesBasePoly->openVertexCountListElement(); writeVertexCountList ( primitivesBasePoly, fnMesh ); primitivesBasePoly->closeElement(); } if ( exportType != PolygonSource::POLYGONS ) { // Prepare the list for add the vertex indexes primitivesBasePoly->openPolylistElement(); } return primitivesBasePoly; }
// ------------------------------------------------------------ SceneElement* SceneGraph::createSceneElement ( const MDagPath &dagPath, SceneElement* parentSceneElement ) { // Create a new scene element SceneElement* sceneElement = new SceneElement ( dagPath ); // Attach a function set MFnDependencyNode fn ( dagPath.node() ); // Check for multiple instances. bool isInstanced = dagPath.isInstanced (); if ( parentSceneElement == 0 ) { // dagPath.getAllPathsTo ( ) () } // Get the node name String nodeName = DocumentExporter::mayaNameToColladaName ( fn.name() ); sceneElement->setNodeName ( nodeName ); // Check if it's a node to export and // tell the scene node to be transformed or not. bool isForced = false; bool isVisible = false; bool isExportNode = getIsExportNode ( dagPath, isForced, isVisible ); sceneElement->setIsForced ( isForced ); sceneElement->setIsVisible ( isVisible ); // Check for a file reference MFnDagNode dagFn ( dagPath ); bool isLocal = !dagFn.isFromReferencedFile(); if ( ExportOptions::exportXRefs() && ExportOptions::dereferenceXRefs()) isLocal = true; if ( !isLocal && !ExportOptions::exportXRefs() ) isExportNode = false; sceneElement->setIsExportNode ( isExportNode ); sceneElement->setIsLocal ( isLocal ); if ( parentSceneElement != NULL ) { if ( !sceneElement->containsParentElement ( parentSceneElement ) ) sceneElement->addParentElement ( parentSceneElement ); if ( !parentSceneElement->containsChildElement ( sceneElement ) ) parentSceneElement->addChildElement ( sceneElement ); } return sceneElement; }
// ------------------------------------------------------------ void EffectTextureExporter::addAngleParameter ( COLLADASW::Texture* colladaTexture, const char* plugName, MFnDependencyNode &placement2d ) { MStatus status; MPlug plug = placement2d.findPlug ( plugName, &status ); if ( status == MStatus::kSuccess ) { float angleRad; plug.getValue ( angleRad ); float angleDeg = COLLADABU::Math::Utils::radToDegF ( angleRad ); // The target id for the animation String targetSid = mAnimationTargetPath + plugName; // Create the animation AnimationExporter* animationExporter = mDocumentExporter->getAnimationExporter(); bool animated = animationExporter->addPlugAnimation ( plug, targetSid, kBoolean ); // Add the parameter String paramSid = EMPTY_STRING; if ( animated ) paramSid = plugName; colladaTexture->addExtraTechniqueParameter ( PROFILE_MAYA, plugName, angleDeg, paramSid ); } }
void ExtractNormalMap(MFnDependencyNode& fn, unsigned int* tex = NULL) { MString texname; MPlug p = fn.findPlug( "normalCamera" ); MPlugArray plugs; p.connectedTo(plugs,true,true); for(int i = 0; i != plugs.length(); ++i) { if (plugs[i].node().apiType() == MFn::kBump) { MFnDependencyNode fnDepBump( plugs[i].node() ); MPlug pp = fnDepBump.findPlug( "bumpValue" ); MPlugArray pplugs; pp.connectedTo(pplugs, true, true); for(int j = 0; j != pplugs.length(); ++j) { if (pplugs[j].node().apiType() == MFn::kFileTexture) { MFnDependencyNode fnDep(pplugs[j].node()); texname = fnDep.name(); break; } } } } *tex = GetTextureID( texname ); }
// -------------------------------------------------------------------------------------------- MStatus polyModifierCmd::processModifierNode( MObject modifierNode, modifyPolyData& data ) // -------------------------------------------------------------------------------------------- { MStatus status = MS::kSuccess; MFnDependencyNode depNodeFn ( modifierNode ); data.modifierNodeSrcAttr = depNodeFn.attribute( "outMesh" , &status); MCheckStatus( status, "Finden des outMesh Attributes" ); data.modifierNodeDestAttr = depNodeFn.attribute( "inMesh" , &status ); return status; }
void ShaderFXShaderExporter::exportSamplerAndSurface(const MFnDependencyNode & node, const MObject & attr) { MStatus status; if (!attr.hasFn(MFn::kTypedAttribute)) return; MFnTypedAttribute fnTypedAttr(attr, &status); if (!status) return; MFnData::Type type = fnTypedAttr.attrType(&status); if (!status) return; if (type != MFnData::kString) return; MPlug plug = node.findPlug(attr, &status); MString value; status = plug.getValue(value); if (!status) return; if (value.length() == 0) return; bool isUsedAsFilename = MFnAttribute(attr).isUsedAsFilename(&status); if (!status) return; // Filename are treated as texture filenames. if (!isUsedAsFilename) return; exportSamplerAndSurfaceInner(value); }
bool getColor(MString& plugName, MFnDependencyNode& dn, MColor& value) { MDGContext ctx = MDGContext::fsNormal; MStatus stat = MS::kSuccess; bool result = false; float r, g, b; // I suppose the attribute is a color and has 3 children MPlug plug = dn.findPlug(plugName, stat); if (!stat) return result; if (plug.numChildren() < 3) return result; r = plug.child(0).asFloat(ctx, &stat); if (!stat) return result; g = plug.child(1).asFloat(ctx, &stat); if (!stat) return result; b = plug.child(2).asFloat(ctx, &stat); if (!stat) return result; value.r = r; value.g = g; value.b = b; return true; }
MStatus PRTAttrs::addColorParameter(MFnDependencyNode & node, MObject & attr, const MString & name, MString & value ) { MStatus stat; MFnNumericAttribute nAttr; const wchar_t* s = value.asWChar(); attr = nAttr.createColor(longName(name), briefName(name), &stat ); MCHECK(stat); double r = 0.0; double g = 0.0; double b = 0.0; if (s[0] == '#' && wcslen(s) >= 7) { r = (double)((prtu::fromHex(s[1]) << 4) + prtu::fromHex(s[2])) / 255.0; g = (double)((prtu::fromHex(s[3]) << 4) + prtu::fromHex(s[4])) / 255.0; b = (double)((prtu::fromHex(s[5]) << 4) + prtu::fromHex(s[6])) / 255.0; nAttr.setDefault(r, g, b); } MCHECK(addParameter(node, attr, nAttr)); MFnNumericData fnData; MObject rgb = fnData.create(MFnNumericData::k3Double, &stat); MCHECK(stat); fnData.setData(r, g, b); MPlug plug(node.object(), attr); MCHECK(plug.setValue(rgb)); return MS::kSuccess; }
ATTR_TYPE getPlugAttrType(const char *plugName, MFnDependencyNode& dn) { MDGContext ctx = MDGContext::fsNormal; MStatus stat = MS::kSuccess; MPlug plug = dn.findPlug(plugName, &stat); if( !stat ) return ATTR_TYPE::ATTR_TYPE_NONE; MObject attObj = plug.attribute(&stat); MFnAttribute att(attObj); if( !stat ) return ATTR_TYPE::ATTR_TYPE_NONE; if(att.isUsedAsColor()) return ATTR_TYPE::ATTR_TYPE_COLOR; if( attObj.apiType() == MFn::kNumericAttribute) { MFnNumericAttribute na(attObj, &stat); if( !stat ) return ATTR_TYPE::ATTR_TYPE_NONE; if( na.unitType() == MFnNumericData::Type::kFloat ) return ATTR_TYPE::ATTR_TYPE_FLOAT; } return ATTR_TYPE::ATTR_TYPE_NONE; }