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 ); }
// -------------------------------------------------------------------------------------------- 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); }
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; } } }
//--------------------------------------------------------------- String EffectTextureExporter::exportImage ( const MObject &texture ) { // Retrieve the texture filename MFnDependencyNode textureNode ( texture ); MString mayaName = textureNode.name(); MPlug filenamePlug = textureNode.findPlug ( ATTR_FILE_TEXTURE_NAME ); // Get the maya image id. String mayaImageId = DocumentExporter::mayaNameToColladaName ( textureNode.name() ); // Generate a COLLADA id for the new light object String colladaImageId; // Check if there is an extra attribute "colladaId" and use this as export id. MString attributeValue; DagHelper::getPlugValue ( texture, COLLADA_ID_ATTRIBUTE_NAME, attributeValue ); if ( attributeValue != EMPTY_CSTRING ) { // Generate a valid collada name, if necessary. colladaImageId = mDocumentExporter->mayaNameToColladaName ( attributeValue, false ); } else { // Generate a COLLADA id for the new light object colladaImageId = DocumentExporter::mayaNameToColladaName ( textureNode.name() ); } // Make the id unique and store it in a map for refernences. colladaImageId = mImageIdList.addId ( colladaImageId ); mMayaIdColladaImageId [mayaImageId] = colladaImageId; // Get the maya filename with the path to the file. MString mayaFileName; filenamePlug.getValue ( mayaFileName ); if ( mayaFileName.length () == 0 ) return NULL; String sourceFile = mayaFileName.asChar (); COLLADASW::URI sourceFileUri ( COLLADASW::URI::nativePathToUri ( sourceFile ) ); if ( sourceFileUri.getScheme ().empty () ) sourceFileUri.setScheme ( COLLADASW::URI::SCHEME_FILE ); COLLADASW::Image* colladaImage = exportImage ( mayaImageId, colladaImageId, sourceFileUri ); if ( colladaImage == NULL ) return NULL; // Export the node type, because PSD textures don't behave the same as File textures. String nodeType = texture.hasFn ( MFn::kPsdFileTexture ) ? MAYA_TEXTURE_PSDTEXTURE : MAYA_TEXTURE_FILETEXTURE; colladaImage->addExtraTechniqueParameter ( PROFILE_MAYA, MAYA_TEXTURE_NODETYPE, nodeType ); // Export whether this image is in fact an image sequence MPlug imgSeqPlug = textureNode.findPlug ( ATTR_IMAGE_SEQUENCE ); bool isImgSeq = false; imgSeqPlug.getValue ( isImgSeq ); colladaImage->addExtraTechniqueParameter ( PROFILE_MAYA, MAYA_TEXTURE_IMAGE_SEQUENCE, isImgSeq ); return colladaImage->getImageId(); }
//--------------------------------------------------- // 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; }
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 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 ); }
MString getConnectedFileTexturePath(const MString& plugName, MFnDependencyNode& depFn) { MStatus stat; MString path = ""; MPlug plug = depFn.findPlug(plugName, &stat); if (!stat) return path; if (plug.isConnected()) { MPlugArray parray; plug.connectedTo(parray, true, false, &stat); if (!stat) return path; if (parray.length() == 0) return path; MPlug destPlug = parray[0]; MObject fileNode = destPlug.node(); if (!fileNode.hasFn(MFn::kFileTexture)) { return path; } MFnDependencyNode fileDepFn(fileNode); MPlug ftn = fileDepFn.findPlug("fileTextureName", &stat); if (!stat) { return path; } path = ftn.asString(); } return path; }
void getConnectedChildPlugs(const char *attrName, MFnDependencyNode& depFn, bool dest, MPlugArray& thisNodePlugs, MPlugArray& otherSidePlugs) { MPlug p = depFn.findPlug(attrName); if (p.isCompound() && !p.isArray()) { getConnectedChildPlugs(p, dest, thisNodePlugs, otherSidePlugs); return; } if (p.isArray()) { for (uint i = 0; i < p.numElements(); i++) { if (p[i].numConnectedChildren() == 0) continue; if (!p[i].isCompound()) getConnectedChildPlugs(p[i], dest, thisNodePlugs, otherSidePlugs); else { if (getAttributeNameFromPlug(p) == MString("colorEntryList")) { getConnectedChildPlugs(p[i].child(1), dest, thisNodePlugs, otherSidePlugs); } } } } }
static bool _GetMetadataUnchecked( const MFnDependencyNode& node, const TfToken& key, VtValue* value) { VtValue fallback = SdfSchema::GetInstance().GetFallback(key); if (fallback.IsEmpty()) { return false; } std::string mayaAttrName = _GetMayaAttrNameForMetadataKey(key); MPlug plug = node.findPlug(mayaAttrName.c_str()); if (plug.isNull()) { return false; } TfType ty = fallback.GetType(); VtValue result = UsdMayaWriteUtil::GetVtValue(plug, ty, TfToken()); if (result.IsEmpty()) { TF_RUNTIME_ERROR( "Cannot convert plug '%s' into metadata '%s' (%s)", plug.name().asChar(), key.GetText(), ty.GetTypeName().c_str()); return false; } *value = result; return true; }
MObject getConnectedFileTextureObject(MString& plugName, MFnDependencyNode& depFn) { MStatus stat; MString path = ""; MPlug plug = depFn.findPlug(plugName, &stat); if( !stat ) return MObject::kNullObj; if( plug.isConnected()) { MPlugArray parray; plug.connectedTo(parray, true, false, &stat); if( !stat ) return MObject::kNullObj; if( parray.length() == 0 ) return MObject::kNullObj; MPlug destPlug = parray[0]; MObject fileNode = destPlug.node(); if( !fileNode.hasFn(MFn::kFileTexture) ) { return MObject::kNullObj; }else{ return fileNode; } } return MObject::kNullObj; }
// ------------------------------------------------------------ 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 AttributeParser::parseMatrixAttribute(MFnDependencyNode & node, MObject & attribute) { MStatus status; MFnMatrixAttribute fnMatrixAttribute(attribute, &status); if (!status) return; MPlug plug = node.findPlug(attribute, &status); if (!status) return; MPlugArray plugArray; bool hasConnection = plug.connectedTo(plugArray, true, false, &status); if (!status) return; if (hasConnection) { MPlug externalPlug = plugArray[0]; bool externalPlugNull = externalPlug.isNull(&status); if (!status) return; if (!externalPlugNull) { MFnAttribute fnAttribute(attribute, &status); if (!status) return; MString name = fnAttribute.name(&status); if (!status) return; //MObject pluggedObject = externalPlug.node(&status); //if (!status) return; // TODO pass matrix to callback? onMatrix(...) instead of onConnection(...)? onConnection(plug, name, externalPlug); } } }
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; }
//--------------------------------------------------- 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 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; }
void AttributeParser::parseCompoundAttribute(MFnDependencyNode & node, MObject & attr, std::set<String>& parsedAttributes) { MStatus status; MFnCompoundAttribute fnCompoundAttribute(attr, &status); if (!status) return; unsigned int numChildren = fnCompoundAttribute.numChildren(&status); if (!status) return; MPlug plug = node.findPlug(attr, &status); if (!status) return; MFnAttribute fnAttr(attr, &status); if (!status) return; MString name = fnAttr.name(&status); if (!status) return; onCompoundAttribute(plug, name); // Recurse children for (unsigned int i = 0; i < fnCompoundAttribute.numChildren(); ++i) { MObject child = fnCompoundAttribute.child(i, &status); if (!status) return; MFnAttribute childFnAttr(child); parsedAttributes.insert(childFnAttr.name().asChar()); parseAttribute(node, child, parsedAttributes); } }
bool getFloat2(MString& plugName, MFnDependencyNode& dn, MVector& value) { MDGContext ctx = MDGContext::fsNormal; MStatus stat = MS::kSuccess; bool result = false; MPlug plug = dn.findPlug(plugName + "0", &stat); if( !stat ) return false; value.x = plug.asFloat(ctx, &stat); plug = dn.findPlug(plugName + "1", &stat); if( !stat ) return false; value.y = plug.asFloat(ctx, &stat); if(stat) return true; return result; }
int getIntAttr(const char *plugName, MFnDependencyNode& dn, int defaultValue) { MDGContext ctx = MDGContext::fsNormal; MStatus stat = MS::kSuccess; MPlug plug = dn.findPlug(plugName, &stat); if( !stat ) return defaultValue; return plug.asInt(ctx, &stat); }
MString getString(const char *plugName, MFnDependencyNode& dn) { MDGContext ctx = MDGContext::fsNormal; MStatus stat = MS::kSuccess; MPlug plug = dn.findPlug(plugName, &stat); if( !stat ) return ""; return plug.asString(ctx, &stat); }
void NifTextureConnector::ConnectTexture( MDagPath mesh_path ) { MDGModifier dgModifier; MFnDependencyNode chooserFn; chooserFn.create( "uvChooser", "uvChooser" ); //Connection between the mesh and the uvChooser MFnMesh meshFn; meshFn.setObject(mesh_path); dgModifier.connect( meshFn.findPlug("uvSet")[uvSet].child(0), chooserFn.findPlug("uvSets").elementByLogicalIndex(0) ); //Connections between the uvChooser and the place2dTexture dgModifier.connect( chooserFn.findPlug("outUv"), texturePlacement.findPlug("uvCoord") ); dgModifier.connect( chooserFn.findPlug("outVertexCameraOne"), texturePlacement.findPlug("vertexCameraOne") ); dgModifier.connect( chooserFn.findPlug("outVertexUvOne"), texturePlacement.findPlug("vertexUvOne") ); dgModifier.connect( chooserFn.findPlug("outVertexUvTwo"), texturePlacement.findPlug("vertexUvTwo") ); dgModifier.connect( chooserFn.findPlug("outVertexUvThree"), texturePlacement.findPlug("vertexUvThree") ); dgModifier.doIt(); }
bool getColor(MString& plugName, MFnDependencyNode& dn, MString& value) { MDGContext ctx = MDGContext::fsNormal; MStatus stat = MS::kSuccess; bool result = false; float r, g, b; MPlug plug = dn.findPlug(plugName + "R", &stat); if( !stat ) return false; r = plug.asFloat(ctx, &stat); plug = dn.findPlug(plugName + "G", &stat); if( !stat ) return false; g = plug.asFloat(ctx, &stat); plug = dn.findPlug(plugName + "B", &stat); if( !stat ) return false; b = plug.asFloat(ctx, &stat); value = MString("") + r + " " + g + " " + b; result = true; return result; }
bool getBoolAttr(const char *plugName, MFnDependencyNode& dn, bool defaultValue) { MDGContext ctx = MDGContext::fsNormal; MStatus stat = MS::kSuccess; bool result = false; MPlug plug = dn.findPlug(plugName, &stat); if( !stat ) return false; return plug.asBool(ctx, &stat); }
//--------------------------------------------------- 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 ); }
//--------------------------------------------------- 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 getPoint(MString& plugName, MFnDependencyNode& dn, MVector& value) { MDGContext ctx = MDGContext::fsNormal; MStatus stat = MS::kSuccess; bool result = false; MPlug plug = dn.findPlug(plugName, &stat); if( !stat ) return false; MPlug Xplug = dn.findPlug(plugName + "X", &stat); MPlug Yplug = dn.findPlug(plugName + "Y", &stat); MPlug Zplug = dn.findPlug(plugName + "Z", &stat); if( !stat ) return false; value.x = Xplug.asDouble(ctx, &stat); value.y = Yplug.asDouble(ctx, &stat); value.z = Zplug.asDouble(ctx, &stat); if( !stat ) return false; return true; }
void liqRibData::parseVectorAttributes( MFnDependencyNode & nodeFn, MStringArray & strArray, ParameterType pType ) { int i; MStatus status; if ( strArray.length() > 0 ) { for ( i = 0; i < strArray.length(); i++ ) { liqTokenPointer tokenPointerPair; MString cutString = strArray[i].substring(5, strArray[i].length()); MPlug vPlug = nodeFn.findPlug( strArray[i] ); MObject plugObj; status = vPlug.getValue( plugObj ); if ( plugObj.apiType() == MFn::kVectorArrayData ) { MFnVectorArrayData fnVectorArrayData( plugObj ); MVectorArray vectorArrayData = fnVectorArrayData.array( &status ); tokenPointerPair.set( cutString.asChar(), pType, ( type() == MRT_Nurbs || type() == MRT_NuCurve ) ? true : false, true, false, vectorArrayData.length() ); for ( int kk = 0; kk < vectorArrayData.length(); kk++ ) { tokenPointerPair.setTokenFloat( kk, vectorArrayData[kk].x, vectorArrayData[kk].y, vectorArrayData[kk].z ); } // should it be per vertex or face-varying if ( ( ( type() == MRT_Mesh ) || ( type() == MRT_Subdivision ) ) && ( vectorArrayData.length() == faceVaryingCount ) ) { tokenPointerPair.setDetailType( rFaceVarying); } else { tokenPointerPair.setDetailType( rVertex ); } // store it all tokenPointerArray.push_back( tokenPointerPair ); } else { // Hmmmm float ? double ? float x, y, z; tokenPointerPair.set( cutString.asChar(), pType, ( type() == MRT_Nurbs || type() == MRT_NuCurve ) ? true : false, false, false, 0 ); vPlug.child(0).getValue( x ); vPlug.child(1).getValue( y ); vPlug.child(2).getValue( z ); tokenPointerPair.setTokenFloat( 0, x, y, z ); tokenPointerPair.setDetailType( rConstant ); tokenPointerArray.push_back( tokenPointerPair ); } } } }