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; }
float getFloatAttr(const char* plugName, MFnDependencyNode& dn, float defaultValue) { MDGContext ctx = MDGContext::fsNormal; MStatus stat = MS::kSuccess; bool result = false; MPlug plug = dn.findPlug(plugName, &stat); if( !stat ) return defaultValue; return plug.asFloat(ctx, &stat); }
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; }
void ovalLocator::myShadedDraw () { MPlug plug (thisMObject (), ovalLocator::size) ; float multiplier =plug.asFloat () ; MPointArray vertices =ovalLocator::vertices () ; glBegin (GL_TRIANGLE_FAN) ; glVertex3f (0, 0, 0) ; for ( int i =0 ; i < vertices.length () ; i++ ) glVertex3f (vertices [i].x * multiplier, vertices [i].y * multiplier, vertices [i].z * multiplier) ; glEnd () ; }
void ovalLocator::myWireFrameDraw () { MPlug plug (thisMObject (), ovalLocator::size) ; float multiplier =plug.asFloat () ; MPointArray vertices =ovalLocator::vertices () ; glBegin (GL_LINES) ; for ( int i =0 ; i < vertices.length () - 1 ; i++ ) { glVertex3f (vertices [i].x * multiplier, vertices [i].y * multiplier, vertices [i].z * multiplier) ; glVertex3f (vertices [i + 1].x * multiplier, vertices [i + 1].y * multiplier, vertices [i + 1].z * multiplier) ; } glEnd () ; }
void cubeLocator::myShadedDraw () { MPlug plug (thisMObject (), cubeLocator::size) ; float multiplier =plug.asFloat () ; MPointArray vertices =cubeLocator::vertices () ; glBegin (GL_QUADS) ; for ( int i =0 ; i < vertices.length () - 3 ; i +=4 ) { glVertex3f (vertices [i].x * multiplier, vertices [i].y * multiplier, vertices [i].z * multiplier) ; glVertex3f (vertices [i + 1].x * multiplier, vertices [i + 1].y * multiplier, vertices [i + 1].z * multiplier) ; glVertex3f (vertices [i + 2].x * multiplier, vertices [i + 2].y * multiplier, vertices [i + 2].z * multiplier) ; glVertex3f (vertices [i + 3].x * multiplier, vertices [i + 3].y * multiplier, vertices [i + 3].z * multiplier) ; } glEnd () ; }
bool getFloat2(MString& plugName, MFnDependencyNode& dn, float2& value) { MDGContext ctx = MDGContext::fsNormal; MStatus stat = MS::kSuccess; bool result = false; MString pName0 = plugName + "0"; MString pName1 = plugName + "1"; if( plugName == "repeatUV") { pName0 = "repeatU"; pName0 = "repeatV"; } MPlug plug = dn.findPlug(pName0, &stat); if( !stat ) return false; value[0] = plug.asFloat(ctx, &stat); plug = dn.findPlug(pName0, &stat); if( !stat ) return false; value[1] = plug.asFloat(ctx, &stat); if(stat) return true; return result; }
void GetDisplacement(MObject& obj, float& dispPadding, bool& enableAutoBump) { MFnDependencyNode dNode(obj); MPlug plug = dNode.findPlug("aiDisplacementPadding"); if (!plug.isNull()) dispPadding = MAX(dispPadding, plug.asFloat()); if (!enableAutoBump) { plug = dNode.findPlug("aiDisplacementAutoBump"); if (!plug.isNull()) enableAutoBump = enableAutoBump || plug.asBool(); } }
Corona::SharedPtr<Corona::Abstract::Map> getOslTexMap(MString& attributeName, MFnDependencyNode& depFn, ShadingNetwork& sn) { MStatus status; OSL::OSLShadingNetworkRenderer *oslRenderer; MayaTo::MayaToWorld::WorldRenderType rType = MayaTo::getWorldPtr()->getRenderType(); if ((rType == MayaTo::MayaToWorld::WorldRenderType::SWATCHRENDER)) { oslRenderer = (OSL::OSLShadingNetworkRenderer *)MayaTo::getObjPtr("oslSwatchRenderer"); } else{ oslRenderer = (OSL::OSLShadingNetworkRenderer *)MayaTo::getObjPtr("oslRenderer"); } size_t numNodes = sn.shaderList.size(); MString OSLInterfaceName = depFn.name() + "_" + attributeName + "_OSLInterface"; MString shaderGroupName = depFn.name() + "_" + attributeName + "_OSLShadingGroup"; OSL::ShaderGroupRef shaderGroup = oslRenderer->shadingsys->ShaderGroupBegin(shaderGroupName.asChar()); MObject thisMObject = depFn.object(); MString outPlugName; MString connectedObjectName = getObjectName(getOtherSideSourceNode(attributeName, thisMObject, true, outPlugName)); Logging::debug(MString("getOslTexMap: ") + connectedObjectName + "." + outPlugName + " is connected with " + depFn.name() + "." + attributeName); MPlug shaderPlug = depFn.findPlug(attributeName); MAYATO_OSL::createOSLProjectionNodes(shaderPlug); for (int shadingNodeId = 0; shadingNodeId < numNodes; shadingNodeId++) { ShadingNode snode = sn.shaderList[shadingNodeId]; Logging::debug(MString("ShadingNode Id: ") + shadingNodeId + " ShadingNode name: " + snode.fullName); MAYATO_OSL::createOSLHelperNodes(sn.shaderList[shadingNodeId]); MAYATO_OSL::createOSLShadingNode(sn.shaderList[shadingNodeId]); MAYATO_OSL::connectProjectionNodes(sn.shaderList[shadingNodeId].mobject); if (snode.fullName == connectedObjectName.asChar()) { MAYATO_OSL::createOSLHelperNodes(sn.shaderList[sn.shaderList.size() - 1]); Logging::debug(MString("connected node found: ") + snode.fullName + " search output attr."); for (size_t outId = 0; outId < snode.outputAttributes.size(); outId++) { ShaderAttribute& sa = snode.outputAttributes[outId]; if (MString(sa.name.c_str()) == outPlugName) { Logging::debug(MString("connected out attr found: ") + sa.name.c_str() + " "); MString destParam; MString sourceParam = outPlugName; MString sourceNode = connectedObjectName; if ((sa.type == "color") || (sa.type == "vector")) { // lets see if we have a color helper node MString helperNodeName = MAYATO_OSL::createPlugHelperNodeName(attributeName.asChar(), thisMObject, false); Logging::debug(MString("Interface connection - color/vector attribute ") + sa.name.c_str() + " search for helper node " + helperNodeName); if (MAYATO_OSL::doesOSLNodeAlreadyExist(helperNodeName)) { Logging::debug(MString("Found helper node name.")); sourceParam = "outputValue"; sourceNode = helperNodeName; } destParam = "inVector"; } if (sa.type == "float") { destParam = "inFloat"; } if (sa.type == "int") { destParam = "inInt"; } if (sa.type == "bool") { destParam = "inBool"; } if (sourceParam == "output") sourceParam = "outOutput"; // if we have a color/vector input, try to find a multiplier attribute MString multiplierName = attributeName + "Multiplier"; MPlug multiplierAttribute = depFn.findPlug(multiplierName, true, &status); if (status) { Logging::debug(MString("Found multiplier attribute: ") + multiplierName); float multiplier = multiplierAttribute.asFloat(); float offset = 0.0f; if ((attributeName == "refractionIndex") || (attributeName == "reflectionIor")) { offset = -1.0f; } oslRenderer->shadingsys->Parameter("multiplier", OSL::TypeDesc::TypeFloat, &multiplier); oslRenderer->shadingsys->Parameter("offset", OSL::TypeDesc::TypeFloat, &offset); } Logging::debug(MString("creating OSLInterface shader ") + OSLInterfaceName); bool success = oslRenderer->shadingsys->Shader("surface", "OSLInterface", OSLInterfaceName.asChar()); Logging::debug(MString("connecting ") + sourceNode + "." + sourceParam + " -> " + OSLInterfaceName + "." + destParam); success = oslRenderer->shadingsys->ConnectShaders(sourceNode.asChar(), sourceParam.asChar(), OSLInterfaceName.asChar(), destParam.asChar()); break; } } break; } } if (!oslRenderer->shadingsys->ShaderGroupEnd()) { Logging::debug("Problem finishing shader group"); } std::string serialized; oslRenderer->shadingsys->getattribute(shaderGroup.get(), "pickle", serialized); Logging::debug(MString("Serialized: ") + serialized.c_str()); Corona::SharedPtr<Corona::Abstract::Map> oslMapp = new OSLMap; OSLMap *oslMap = (OSLMap *)oslMapp.getReference(); oslMap->oslRenderer = oslRenderer; oslMap->shaderGroup = shaderGroup; if (depFn.object().hasFn(MFn::kLight)) oslMap->isLightMap = true; if (attributeName == "normalCamera") { oslMap->bumpType = OSLMap::NONE; // we only support direct bumpmap connections MPlug ncPlug = depFn.findPlug("normalCamera"); if (ncPlug.isConnected()) { MPlugArray pa; ncPlug.connectedTo(pa, true, false); if (pa.length() > 0) { for (uint pId = 0; pId < pa.length(); pId++) { if (pa[pId].node().hasFn(MFn::kBump) || pa[pId].node().hasFn(MFn::kBump3d)) { MFnDependencyNode bumpFn(pa[pId].node()); MPlug interpPlug = bumpFn.findPlug("bumpInterp"); if (interpPlug.asInt() == 0) oslMap->bumpType = OSLMap::BUMP; if (interpPlug.asInt() == 1) oslMap->bumpType = OSLMap::NORMALTANGENT; if (interpPlug.asInt() == 2) oslMap->bumpType = OSLMap::NORMALOBJECT; if (pa[pId].node().hasFn(MFn::kBump3d)) oslMap->bumpType = OSLMap::BUMP3D; } } } } } return oslMapp; }
void AttributeParser::parseNumeric(MPlug plug, MFnNumericData::Type type) { MStatus status; MObject attrObj = plug.attribute(&status); if (!status) return; MFnAttribute attr(attrObj, &status); if (!status) return; MString name = attr.name(&status); if (!status) return; switch (type) { case MFnNumericData::kInvalid: //!< Invalid data. break; case MFnNumericData::kBoolean: //!< Boolean. { bool value; status = plug.getValue(value); if (!status) return; onBoolean(plug, name, value); } break; case MFnNumericData::kByte: //!< One byte. { char value; status = plug.getValue(value); if (!status) return; onByte(plug, name, value); } break; case MFnNumericData::kChar: //!< One character. { char value; status = plug.getValue(value); if (!status) return; onChar(plug, name, value); } break; case MFnNumericData::kShort: //!< One short. { short value; status = plug.getValue(value); if (!status) return; onShort(plug, name, value); } break; case MFnNumericData::k2Short: //!< Two shorts. { MObject object; status = plug.getValue(object); if (!status) return; MFnNumericData fnNumericData(object, &status); if (!status) return; short value[2]; status = fnNumericData.getData(value[0], value[1]); if (!status) return; onShort2(plug, name, value); } break; case MFnNumericData::k3Short: //!< Three shorts. { MObject object; status = plug.getValue(object); if (!status) return; MFnNumericData fnNumericData(object, &status); if (!status) return; short value[3]; status = fnNumericData.getData(value[0], value[1], value[2]); if (!status) return; onShort3(plug, name, value); } break; case MFnNumericData::kInt: //!< One long. Same as int since "long" is not platform-consistent. { int value; status = plug.getValue(value); if (!status) return; onInteger(plug, name, value); } break; case MFnNumericData::k2Int: //!< Two longs. Same as 2 ints since "long" is not platform-consistent. { MObject object; status = plug.getValue(object); if (!status) return; MFnNumericData fnNumericData(object, &status); if (!status) return; int value[2]; status = fnNumericData.getData(value[0], value[1]); if (!status) return; onInteger2(plug, name, value); } break; case MFnNumericData::k3Int: //!< Three longs. Same as 3 ints since "long" is not platform-consistent. { MObject object; status = plug.getValue(object); if (!status) return; MFnNumericData fnNumericData(object, &status); if (!status) return; int value[3]; status = fnNumericData.getData(value[0], value[1], value[2]); if (!status) return; onInteger3(plug, name, value); } break; case MFnNumericData::kFloat: //!< One float. { MFn::Type apiType = attrObj.apiType(); switch (apiType) { case MFn::kFloatAngleAttribute: { MAngle angle = plug.asMAngle(MDGContext::fsNormal, &status); if (!status) return; onAngle(plug, name, angle); } break; case MFn::kFloatLinearAttribute: { MDistance distance = plug.asMDistance(MDGContext::fsNormal, &status); if (!status) return; onDistance(plug, name, distance); } break; default: { float value = plug.asFloat(MDGContext::fsNormal, &status); if (!status) return; onFloat(plug, name, value); } break; } } break; case MFnNumericData::k2Float: //!< Two floats. { const unsigned int numChildren = 2; MPlug childPlugs[numChildren]; for (unsigned int i = 0; i < numChildren; ++i) { childPlugs[i] = plug.child(i, &status); if (!status) return; } MObject childAttr[numChildren]; for (unsigned int i = 0; i < numChildren; ++i) { childAttr[i] = childPlugs[i].attribute(&status); if (!status) return; } MFn::Type apiType = childAttr[0].apiType(); switch (apiType) { case MFn::kFloatAngleAttribute: { MAngle angles[numChildren]; for (unsigned int i = 0; i < numChildren; ++i) { angles[i] = childPlugs[i].asMAngle(MDGContext::fsNormal, &status); if (!status) return; } onAngle2(plug, name, angles); } break; case MFn::kFloatLinearAttribute: { MDistance distances[numChildren]; for (unsigned int i = 0; i < numChildren; ++i) { distances[i] = childPlugs[i].asMDistance(MDGContext::fsNormal, &status); if (!status) return; } onDistance2(plug, name, distances); } break; default: { float values[numChildren]; for (unsigned int i = 0; i < numChildren; ++i) { values[i] = childPlugs[i].asFloat(MDGContext::fsNormal, &status); if (!status) return; } onFloat2(plug, name, values); } break; } } break; case MFnNumericData::k3Float: //!< Three floats. { const unsigned int numChildren = 3; MPlug childPlugs[numChildren]; for (unsigned int i = 0; i < numChildren; ++i) { childPlugs[i] = plug.child(i, &status); if (!status) return; } MObject childAttr[numChildren]; for (unsigned int i = 0; i < numChildren; ++i) { childAttr[i] = childPlugs[i].attribute(&status); if (!status) return; } MFn::Type apiType = childAttr[0].apiType(); switch (apiType) { case MFn::kFloatAngleAttribute: { MAngle angles[numChildren]; for (unsigned int i = 0; i < numChildren; ++i) { angles[i] = childPlugs[i].asMAngle(MDGContext::fsNormal, &status); if (!status) return; } onAngle3(plug, name, angles); } break; case MFn::kFloatLinearAttribute: { MDistance distances[numChildren]; for (unsigned int i = 0; i < numChildren; ++i) { distances[i] = childPlugs[i].asMDistance(MDGContext::fsNormal, &status); if (!status) return; } onDistance3(plug, name, distances); } break; default: { float values[numChildren]; for (unsigned int i = 0; i < numChildren; ++i) { values[i] = childPlugs[i].asFloat(MDGContext::fsNormal, &status); if (!status) return; } onFloat3(plug, name, values); } break; } } break; case MFnNumericData::kDouble: //!< One double. { MFn::Type apiType = attrObj.apiType(); switch (apiType) { case MFn::kDoubleAngleAttribute: { MAngle angle = plug.asMAngle(MDGContext::fsNormal, &status); if (!status) return; onAngle(plug, name, angle); } break; case MFn::kDoubleLinearAttribute: { MDistance distance = plug.asMDistance(MDGContext::fsNormal, &status); if (!status) return; onDistance(plug, name, distance); } break; default: { double value = plug.asDouble(MDGContext::fsNormal, &status); if (!status) return; onDouble(plug, name, value); } break; } } break; case MFnNumericData::k2Double: //!< Two doubles. { const unsigned int numChildren = 2; MPlug childPlugs[numChildren]; for (unsigned int i = 0; i < numChildren; ++i) { childPlugs[i] = plug.child(i, &status); if (!status) return; } MObject childAttr[numChildren]; for (unsigned int i = 0; i < numChildren; ++i) { childAttr[i] = childPlugs[i].attribute(&status); if (!status) return; } MFn::Type apiType = childAttr[0].apiType(); switch (apiType) { case MFn::kDoubleAngleAttribute: { MAngle angles[numChildren]; for (unsigned int i = 0; i < numChildren; ++i) { angles[i] = childPlugs[i].asMAngle(MDGContext::fsNormal, &status); if (!status) return; } onAngle2(plug, name, angles); } break; case MFn::kDoubleLinearAttribute: { MDistance distances[numChildren]; for (unsigned int i = 0; i < numChildren; ++i) { distances[i] = childPlugs[i].asMDistance(MDGContext::fsNormal, &status); if (!status) return; } onDistance2(plug, name, distances); } break; default: { double values[numChildren]; for (unsigned int i = 0; i < numChildren; ++i) { values[i] = childPlugs[i].asDouble(MDGContext::fsNormal, &status); if (!status) return; } onDouble2(plug, name, values); } break; } } break; case MFnNumericData::k3Double: //!< Three doubles. { const unsigned int numChildren = 3; MPlug childPlugs[numChildren]; for (unsigned int i = 0; i < numChildren; ++i) { childPlugs[i] = plug.child(i, &status); if (!status) return; } MObject childAttr[numChildren]; for (unsigned int i = 0; i < numChildren; ++i) { childAttr[i] = childPlugs[i].attribute(&status); if (!status) return; } MFn::Type apiType = childAttr[0].apiType(); switch (apiType) { case MFn::kDoubleAngleAttribute: { MAngle angles[numChildren]; for (unsigned int i = 0; i < numChildren; ++i) { angles[i] = childPlugs[i].asMAngle(MDGContext::fsNormal, &status); if (!status) return; } onAngle3(plug, name, angles); } break; case MFn::kDoubleLinearAttribute: { MDistance distances[numChildren]; for (unsigned int i = 0; i < numChildren; ++i) { distances[i] = childPlugs[i].asMDistance(MDGContext::fsNormal, &status); if (!status) return; } onDistance3(plug, name, distances); } break; default: { double values[numChildren]; for (unsigned int i = 0; i < numChildren; ++i) { values[i] = childPlugs[i].asDouble(MDGContext::fsNormal, &status); if (!status) return; } onDouble3(plug, name, values); } break; } } break; case MFnNumericData::k4Double: //!< Four doubles. { const unsigned int numChildren = 4; MPlug childPlugs[numChildren]; for (unsigned int i = 0; i < numChildren; ++i) { childPlugs[i] = plug.child(i, &status); if (!status) return; } MObject childAttr[numChildren]; for (unsigned int i = 0; i < numChildren; ++i) { childAttr[i] = childPlugs[i].attribute(&status); if (!status) return; } MFn::Type apiType = childAttr[0].apiType(); switch (apiType) { case MFn::kDoubleAngleAttribute: { MAngle angles[numChildren]; for (unsigned int i = 0; i < numChildren; ++i) { angles[i] = childPlugs[i].asMAngle(MDGContext::fsNormal, &status); if (!status) return; } onAngle4(plug, name, angles); } break; case MFn::kDoubleLinearAttribute: { MDistance distances[numChildren]; for (unsigned int i = 0; i < numChildren; ++i) { distances[i] = childPlugs[i].asMDistance(MDGContext::fsNormal, &status); if (!status) return; } onDistance4(plug, name, distances); } break; default: { double values[numChildren]; for (unsigned int i = 0; i < numChildren; ++i) { values[i] = childPlugs[i].asDouble(MDGContext::fsNormal, &status); if (!status) return; } onDouble4(plug, name, values); } break; } } break; case MFnNumericData::kAddr: //!< An address. // TODO break; default: break; } }
MStatus AlembicCurves::Save(double time, unsigned int timeIndex, bool isFirstFrame) { ESS_PROFILE_SCOPE("AlembicCurves::Save"); if (this->accumRef.get() != 0) { accumRef->save(GetRef(), time); ++mNumSamples; return MStatus::kSuccess; } // access the geometry MFnNurbsCurve node(GetRef()); // save the metadata SaveMetaData(this); // save the attributes if (isFirstFrame) { Abc::OCompoundProperty cp; Abc::OCompoundProperty up; if (AttributesWriter::hasAnyAttr(node, *GetJob())) { cp = mSchema.getArbGeomParams(); up = mSchema.getUserProperties(); } mAttrs = AttributesWriterPtr( new AttributesWriter(cp, up, GetMyParent(), node, timeIndex, *GetJob()) ); } else { mAttrs->write(); } // prepare the bounding box Abc::Box3d bbox; // check if we have the global cache option const bool globalCache = GetJob()->GetOption(L"exportInGlobalSpace").asInt() > 0; Abc::M44f globalXfo; if (globalCache) { globalXfo = GetGlobalMatrix(GetRef()); } MPointArray positions; node.getCVs(positions); mPosVec.resize(positions.length()); for (unsigned int i = 0; i < positions.length(); i++) { const MPoint &outPos = positions[i]; Imath::V3f &inPos = mPosVec[i]; inPos.x = (float)outPos.x; inPos.y = (float)outPos.y; inPos.z = (float)outPos.z; if (globalCache) { globalXfo.multVecMatrix(inPos, inPos); } bbox.extendBy(inPos); } // store the positions to the samples mSample.setPositions(Abc::P3fArraySample(&mPosVec.front(), mPosVec.size())); mSample.setSelfBounds(bbox); if (mNumSamples == 0) { // knot vector! MDoubleArray knots; node.getKnots(knots); mKnotVec.resize(knots.length()); for (unsigned int i = 0; i < knots.length(); ++i) { mKnotVec[i] = (float)knots[i]; } mKnotVectorProperty.set(Abc::FloatArraySample(mKnotVec)); mNbVertices.push_back(node.numCVs()); mSample.setCurvesNumVertices(Abc::Int32ArraySample(mNbVertices)); if (node.form() == MFnNurbsCurve::kOpen) { mSample.setWrap(AbcG::kNonPeriodic); } else { mSample.setWrap(AbcG::kPeriodic); } if (node.degree() == 3) { mSample.setType(AbcG::kCubic); } else { mSample.setType(AbcG::kLinear); } MPlug widthPlug = node.findPlug("width"); if (!widthPlug.isNull()) { mRadiusVec.push_back(widthPlug.asFloat()); } else { mRadiusVec.push_back(1.0); } mRadiusProperty.set( Abc::FloatArraySample(&mRadiusVec.front(), mRadiusVec.size())); } // save the sample mSchema.set(mSample); mNumSamples++; return MStatus::kSuccess; }
void CScriptedShapeTranslator::RunScripts(AtNode *atNode, unsigned int step, bool update) { std::map<std::string, CScriptedTranslator>::iterator translatorIt; MFnDependencyNode fnNode(GetMayaObject()); translatorIt = gTranslators.find(fnNode.typeName().asChar()); if (translatorIt == gTranslators.end()) { AiMsgError("[mtoa.scriptedTranslators] No command to export node \"%s\" of type %s.", fnNode.name().asChar(), fnNode.typeName().asChar()); return; } MString exportCmd = translatorIt->second.exportCmd; MString cleanupCmd = translatorIt->second.cleanupCmd; MFnDagNode node(m_dagPath.node()); bool isMasterDag = false; bool transformBlur = IsMotionBlurEnabled(MTOA_MBLUR_OBJECT) && IsLocalMotionBlurEnabled(); bool deformBlur = IsMotionBlurEnabled(MTOA_MBLUR_DEFORM) && IsLocalMotionBlurEnabled(); char buffer[64]; MString command = exportCmd; command += "("; sprintf(buffer, "%f", GetExportFrame()); command += buffer; command += ", "; sprintf(buffer, "%d", step); command += buffer; command += ", "; // current sample frame sprintf(buffer, "%f", GetSampleFrame(m_session, step)); command += buffer; command += ", "; // List of arnold attributes the custom shape export command has overriden MStringArray attrs; if (!m_masterNode) { command += "(\"" + m_dagPath.partialPathName() + "\", \""; command += AiNodeGetName(atNode); command += "\"), None)"; isMasterDag = true; } else { command += "(\"" + m_dagPath.partialPathName() + "\", \""; command += AiNodeGetName(atNode); command += "\"), (\"" + GetMasterInstance().partialPathName() + "\", \""; command += AiNodeGetName(m_masterNode); command += "\"))"; } MStatus status = MGlobal::executePythonCommand(command, attrs); if (!status) { AiMsgError("[mtoa.scriptedTranslators] Failed to export node \"%s\".", node.name().asChar()); return; } // Build set of attributes already processed std::set<std::string> attrsSet; for (unsigned int i=0; i<attrs.length(); ++i) { attrsSet.insert(attrs[i].asChar()); } std::set<std::string>::iterator attrsEnd = attrsSet.end(); // Should be getting displacement shader from master instance only // as arnold do not support displacement shader overrides for ginstance MFnDependencyNode masterShadingEngine; MFnDependencyNode shadingEngine; float dispPadding = -AI_BIG; float dispHeight = 1.0f; float dispZeroValue = 0.0f; bool dispAutobump = false; bool outputDispPadding = false; bool outputDispHeight = false; bool outputDispZeroValue = false; bool outputDispAutobump = false; const AtNodeEntry *anodeEntry = AiNodeGetNodeEntry(atNode); GetShapeInstanceShader(m_dagPath, shadingEngine); if (!IsMasterInstance()) { GetShapeInstanceShader(GetMasterInstance(), masterShadingEngine); } else { masterShadingEngine.setObject(shadingEngine.object()); } AtMatrix matrix; MMatrix mmatrix = m_dagPath.inclusiveMatrix(); ConvertMatrix(matrix, mmatrix); // Set transformation matrix if (attrsSet.find("matrix") == attrsEnd) { if (HasParameter(anodeEntry, "matrix")) { if (transformBlur) { if (step == 0) { AtArray* matrices = AiArrayAllocate(1, GetNumMotionSteps(), AI_TYPE_MATRIX); AiArraySetMtx(matrices, step, matrix); AiNodeSetArray(atNode, "matrix", matrices); } else { AtArray* matrices = AiNodeGetArray(atNode, "matrix"); AiArraySetMtx(matrices, step, matrix); } } else { AiNodeSetMatrix(atNode, "matrix", matrix); } } } // Set bounding box if (attrsSet.find("min") == attrsEnd && attrsSet.find("max") == attrsEnd) { // Now check if min and max parameters are valid parameter names on arnold node if (HasParameter(anodeEntry, "min") != 0 && HasParameter(anodeEntry, "max") != 0) { if (step == 0) { MBoundingBox bbox = node.boundingBox(); MPoint bmin = bbox.min(); MPoint bmax = bbox.max(); AiNodeSetPnt(atNode, "min", static_cast<float>(bmin.x), static_cast<float>(bmin.y), static_cast<float>(bmin.z)); AiNodeSetPnt(atNode, "max", static_cast<float>(bmax.x), static_cast<float>(bmax.y), static_cast<float>(bmax.z)); } else { if (transformBlur || deformBlur) { AtPoint cmin = AiNodeGetPnt(atNode, "min"); AtPoint cmax = AiNodeGetPnt(atNode, "max"); MBoundingBox bbox = node.boundingBox(); MPoint bmin = bbox.min(); MPoint bmax = bbox.max(); if (bmin.x < cmin.x) cmin.x = static_cast<float>(bmin.x); if (bmin.y < cmin.y) cmin.y = static_cast<float>(bmin.y); if (bmin.z < cmin.z) cmin.z = static_cast<float>(bmin.z); if (bmax.x > cmax.x) cmax.x = static_cast<float>(bmax.x); if (bmax.y > cmax.y) cmax.y = static_cast<float>(bmax.y); if (bmax.z > cmax.z) cmax.z = static_cast<float>(bmax.z); AiNodeSetPnt(atNode, "min", cmin.x, cmin.y, cmin.z); AiNodeSetPnt(atNode, "max", cmax.x, cmax.y, cmax.z); } } } } if (step == 0) { // Set common attributes MPlug plug; if (AiNodeIs(atNode, "procedural")) { // Note: it is up to the procedural to properly forward (or not) those parameters to the node // it creates if (attrsSet.find("subdiv_type") == attrsEnd) { plug = FindMayaPlug("subdiv_type"); if (plug.isNull()) { plug = FindMayaPlug("aiSubdivType"); } if (!plug.isNull() && HasParameter(anodeEntry, "subdiv_type", atNode, "constant INT")) { AiNodeSetInt(atNode, "subdiv_type", plug.asInt()); } } if (attrsSet.find("subdiv_iterations") == attrsEnd) { plug = FindMayaPlug("subdiv_iterations"); if (plug.isNull()) { plug = FindMayaPlug("aiSubdivIterations"); } if (!plug.isNull() && HasParameter(anodeEntry, "subdiv_iterations", atNode, "constant BYTE")) { AiNodeSetByte(atNode, "subdiv_iterations", plug.asInt()); } } if (attrsSet.find("subdiv_adaptive_metric") == attrsEnd) { plug = FindMayaPlug("subdiv_adaptive_metric"); if (plug.isNull()) { plug = FindMayaPlug("aiSubdivAdaptiveMetric"); } if (!plug.isNull() && HasParameter(anodeEntry, "subdiv_adaptive_metric", atNode, "constant INT")) { AiNodeSetInt(atNode, "subdiv_adaptive_metric", plug.asInt()); } } if (attrsSet.find("subdiv_pixel_error") == attrsEnd) { plug = FindMayaPlug("subdiv_pixel_error"); if (plug.isNull()) { plug = FindMayaPlug("aiSubdivPixelError"); } if (!plug.isNull() && HasParameter(anodeEntry, "subdiv_pixel_error", atNode, "constant FLOAT")) { AiNodeSetFlt(atNode, "subdiv_pixel_error", plug.asFloat()); } } if (attrsSet.find("subdiv_dicing_camera") == attrsEnd) { plug = FindMayaPlug("subdiv_dicing_camera"); if (plug.isNull()) { plug = FindMayaPlug("aiSubdivDicingCamera"); } if (!plug.isNull() && HasParameter(anodeEntry, "subdiv_dicing_camera", atNode, "constant NODE")) { AtNode *cameraNode = NULL; MPlugArray plugs; plug.connectedTo(plugs, true, false); if (plugs.length() == 1) { MFnDagNode camDag(plugs[0].node()); MDagPath camPath; if (camDag.getPath(camPath) == MS::kSuccess) { cameraNode = ExportDagPath(camPath); } } AiNodeSetPtr(atNode, "subdiv_dicing_camera", cameraNode); } } if (attrsSet.find("subdiv_uv_smoothing") == attrsEnd) { plug = FindMayaPlug("subdiv_uv_smoothing"); if (plug.isNull()) { plug = FindMayaPlug("aiSubdivUvSmoothing"); } if (!plug.isNull() && HasParameter(anodeEntry, "subdiv_uv_smoothing", atNode, "constant INT")) { AiNodeSetInt(atNode, "subdiv_uv_smoothing", plug.asInt()); } } if (attrsSet.find("subdiv_smooth_derivs") == attrsEnd) { plug = FindMayaPlug("aiSubdivSmoothDerivs"); if (!plug.isNull() && HasParameter(anodeEntry, "subdiv_smooth_derivs", atNode, "constant BOOL")) { AiNodeSetBool(atNode, "subdiv_smooth_derivs", plug.asBool()); } } if (attrsSet.find("smoothing") == attrsEnd) { // Use maya shape built-in attribute plug = FindMayaPlug("smoothShading"); if (!plug.isNull() && HasParameter(anodeEntry, "smoothing", atNode, "constant BOOL")) { AiNodeSetBool(atNode, "smoothing", plug.asBool()); } } if (attrsSet.find("disp_height") == attrsEnd) { plug = FindMayaPlug("aiDispHeight"); if (!plug.isNull()) { outputDispHeight = true; dispHeight = plug.asFloat(); } } if (attrsSet.find("disp_zero_value") == attrsEnd) { plug = FindMayaPlug("aiDispZeroValue"); if (!plug.isNull()) { outputDispZeroValue = true; dispZeroValue = plug.asFloat(); } } if (attrsSet.find("disp_autobump") == attrsEnd) { plug = FindMayaPlug("aiDispAutobump"); if (!plug.isNull()) { outputDispAutobump = true; dispAutobump = plug.asBool(); } } if (attrsSet.find("disp_padding") == attrsEnd) { plug = FindMayaPlug("aiDispPadding"); if (!plug.isNull()) { outputDispPadding = true; dispPadding = MAX(dispPadding, plug.asFloat()); } } // Set diplacement shader if (attrsSet.find("disp_map") == attrsEnd) { if (masterShadingEngine.object() != MObject::kNullObj) { MPlugArray shaderConns; MPlug shaderPlug = masterShadingEngine.findPlug("displacementShader"); shaderPlug.connectedTo(shaderConns, true, false); if (shaderConns.length() > 0) { MFnDependencyNode dispNode(shaderConns[0].node()); plug = dispNode.findPlug("aiDisplacementPadding"); if (!plug.isNull()) { outputDispPadding = true; dispPadding = MAX(dispPadding, plug.asFloat()); } plug = dispNode.findPlug("aiDisplacementAutoBump"); if (!plug.isNull()) { outputDispAutobump = true; dispAutobump = dispAutobump || plug.asBool(); } if (HasParameter(anodeEntry, "disp_map", atNode, "constant ARRAY NODE")) { AtNode *dispImage = ExportNode(shaderConns[0]); AiNodeSetArray(atNode, "disp_map", AiArrayConvert(1, 1, AI_TYPE_NODE, &dispImage)); } } } } if (outputDispHeight && HasParameter(anodeEntry, "disp_height", atNode, "constant FLOAT")) { AiNodeSetFlt(atNode, "disp_height", dispHeight); } if (outputDispZeroValue && HasParameter(anodeEntry, "disp_zero_value", atNode, "constant FLOAT")) { AiNodeSetFlt(atNode, "disp_zero_value", dispZeroValue); } if (outputDispPadding && HasParameter(anodeEntry, "disp_padding", atNode, "constant FLOAT")) { AiNodeSetFlt(atNode, "disp_padding", dispPadding); } if (outputDispAutobump && HasParameter(anodeEntry, "disp_autobump", atNode, "constant BOOL")) { AiNodeSetBool(atNode, "disp_autobump", dispAutobump); } // Old point based SSS parameter if (attrsSet.find("sss_sample_distribution") == attrsEnd) { plug = FindMayaPlug("sss_sample_distribution"); if (plug.isNull()) { plug = FindMayaPlug("aiSssSampleDistribution"); } if (!plug.isNull() && HasParameter(anodeEntry, "sss_sample_distribution", atNode, "constant INT")) { AiNodeSetInt(atNode, "sss_sample_distribution", plug.asInt()); } } // Old point based SSS parameter if (attrsSet.find("sss_sample_spacing") == attrsEnd) { plug = FindMayaPlug("sss_sample_spacing"); if (plug.isNull()) { plug = FindMayaPlug("aiSssSampleSpacing"); } if (!plug.isNull() && HasParameter(anodeEntry, "sss_sample_spacing", atNode, "constant FLOAT")) { AiNodeSetFlt(atNode, "sss_sample_spacing", plug.asFloat()); } } if (attrsSet.find("min_pixel_width") == attrsEnd) { plug = FindMayaPlug("aiMinPixelWidth"); if (!plug.isNull() && HasParameter(anodeEntry, "min_pixel_width", atNode, "constant FLOAT")) { AiNodeSetFlt(atNode, "min_pixel_width", plug.asFloat()); } } if (attrsSet.find("mode") == attrsEnd) { plug = FindMayaPlug("aiMode"); if (!plug.isNull() && HasParameter(anodeEntry, "mode", atNode, "constant INT")) { AiNodeSetInt(atNode, "mode", plug.asShort()); } } if (attrsSet.find("basis") == attrsEnd) { plug = FindMayaPlug("aiBasis"); if (!plug.isNull() && HasParameter(anodeEntry, "basis", atNode, "constant INT")) { AiNodeSetInt(atNode, "basis", plug.asShort()); } } } if (AiNodeIs(atNode, "ginstance")) { if (attrsSet.find("node") == attrsEnd) { AiNodeSetPtr(atNode, "node", m_masterNode); } if (attrsSet.find("inherit_xform") == attrsEnd) { AiNodeSetBool(atNode, "inherit_xform", false); } } else { // box or procedural if (attrsSet.find("step_size") == attrsEnd) { plug = FindMayaPlug("step_size"); if (plug.isNull()) { plug = FindMayaPlug("aiStepSize"); } if (!plug.isNull() && HasParameter(anodeEntry, "step_size", atNode, "constant FLOAT")) { AiNodeSetFlt(atNode, "step_size", plug.asFloat()); } } } if (attrsSet.find("sidedness") == attrsEnd) { // Use maya shape built-in attribute plug = FindMayaPlug("doubleSided"); if (!plug.isNull() && HasParameter(anodeEntry, "sidedness", atNode, "constant BYTE")) { AiNodeSetByte(atNode, "sidedness", plug.asBool() ? AI_RAY_ALL : 0); // Only set invert_normals if doubleSided attribute could be found if (!plug.asBool() && attrsSet.find("invert_normals") == attrsEnd) { // Use maya shape built-in attribute plug = FindMayaPlug("opposite"); if (!plug.isNull() && HasParameter(anodeEntry, "invert_normals", atNode, "constant BOOL")) { AiNodeSetBool(atNode, "invert_normals", plug.asBool()); } } } } if (attrsSet.find("receive_shadows") == attrsEnd) { // Use maya shape built-in attribute plug = FindMayaPlug("receiveShadows"); if (!plug.isNull() && HasParameter(anodeEntry, "receive_shadows", atNode, "constant BOOL")) { AiNodeSetBool(atNode, "receive_shadows", plug.asBool()); } } if (attrsSet.find("self_shadows") == attrsEnd) { plug = FindMayaPlug("self_shadows"); if (plug.isNull()) { plug = FindMayaPlug("aiSelfShadows"); } if (!plug.isNull() && HasParameter(anodeEntry, "self_shadows", atNode, "constant BOOL")) { AiNodeSetBool(atNode, "self_shadows", plug.asBool()); } } if (attrsSet.find("opaque") == attrsEnd) { plug = FindMayaPlug("opaque"); if (plug.isNull()) { plug = FindMayaPlug("aiOpaque"); } if (!plug.isNull() && HasParameter(anodeEntry, "opaque", atNode, "constant BOOL")) { AiNodeSetBool(atNode, "opaque", plug.asBool()); } } if (attrsSet.find("visibility") == attrsEnd) { if (HasParameter(anodeEntry, "visibility", atNode, "constant BYTE")) { int visibility = AI_RAY_ALL; // Use maya shape built-in attribute plug = FindMayaPlug("castsShadows"); if (!plug.isNull() && !plug.asBool()) { visibility &= ~AI_RAY_SHADOW; } // Use maya shape built-in attribute plug = FindMayaPlug("primaryVisibility"); if (!plug.isNull() && !plug.asBool()) { visibility &= ~AI_RAY_CAMERA; } // Use maya shape built-in attribute plug = FindMayaPlug("visibleInReflections"); if (!plug.isNull() && !plug.asBool()) { visibility &= ~AI_RAY_REFLECTED; } // Use maya shape built-in attribute plug = FindMayaPlug("visibleInRefractions"); if (!plug.isNull() && !plug.asBool()) { visibility &= ~AI_RAY_REFRACTED; } plug = FindMayaPlug("diffuse_visibility"); if (plug.isNull()) { plug = FindMayaPlug("aiVisibleInDiffuse"); } if (!plug.isNull() && !plug.asBool()) { visibility &= ~AI_RAY_DIFFUSE; } plug = FindMayaPlug("glossy_visibility"); if (plug.isNull()) { plug = FindMayaPlug("aiVisibleInGlossy"); } if (!plug.isNull() && !plug.asBool()) { visibility &= ~AI_RAY_GLOSSY; } AiNodeSetByte(atNode, "visibility", visibility & 0xFF); } } if (attrsSet.find("sss_setname") == attrsEnd) { plug = FindMayaPlug("aiSssSetname"); if (!plug.isNull() && plug.asString().length() > 0) { if (HasParameter(anodeEntry, "sss_setname", atNode, "constant STRING")) { AiNodeSetStr(atNode, "sss_setname", plug.asString().asChar()); } } } // Set surface shader if (HasParameter(anodeEntry, "shader", atNode, "constant NODE")) { if (attrsSet.find("shader") == attrsEnd) { if (shadingEngine.object() != MObject::kNullObj) { AtNode *shader = ExportNode(shadingEngine.findPlug("message")); if (shader != NULL) { const AtNodeEntry *entry = AiNodeGetNodeEntry(shader); if (AiNodeEntryGetType(entry) != AI_NODE_SHADER) { MGlobal::displayWarning("[mtoaScriptedTranslators] Node generated from \"" + shadingEngine.name() + "\" of type " + shadingEngine.typeName() + " for shader is not a shader but a " + MString(AiNodeEntryGetTypeName(entry))); } else { AiNodeSetPtr(atNode, "shader", shader); if (AiNodeLookUpUserParameter(atNode, "mtoa_shading_groups") == 0) { AiNodeDeclare(atNode, "mtoa_shading_groups", "constant ARRAY NODE"); AiNodeSetArray(atNode, "mtoa_shading_groups", AiArrayConvert(1, 1, AI_TYPE_NODE, &shader)); } } } } } } } ExportLightLinking(atNode); MPlug plug = FindMayaPlug("aiTraceSets"); if (!plug.isNull()) { ExportTraceSets(atNode, plug); } // Call cleanup command on last export step if (!IsMotionBlurEnabled() || !IsLocalMotionBlurEnabled() || int(step) >= (int(GetNumMotionSteps()) - 1)) { if (HasParameter(anodeEntry, "disp_padding", atNode)) { float padding = AiNodeGetFlt(atNode, "disp_padding"); AtPoint cmin = AiNodeGetPnt(atNode, "min"); AtPoint cmax = AiNodeGetPnt(atNode, "max"); cmin.x -= padding; cmin.y -= padding; cmin.z -= padding; cmax.x += padding; cmax.y += padding; cmax.z += padding; AiNodeSetPnt(atNode, "min", cmin.x, cmin.y, cmin.z); AiNodeSetPnt(atNode, "max", cmax.x, cmax.y, cmax.z); } if (cleanupCmd != "") { command = cleanupCmd += "((\"" + m_dagPath.partialPathName() + "\", \""; command += AiNodeGetName(atNode); command += "\"), "; if (!m_masterNode) { command += "None)"; } else { command += "(\"" + GetMasterInstance().partialPathName() + "\", \""; command += AiNodeGetName(m_masterNode); command += "\"))"; } status = MGlobal::executePythonCommand(command); if (!status) { AiMsgError("[mtoa.scriptedTranslators] Failed to cleanup node \"%s\".", node.name().asChar()); } } } }
bool PxrUsdMayaWriteUtil::SetUsdAttr( const MPlug& attrPlug, const UsdAttribute& usdAttr, const UsdTimeCode& usdTime, const bool translateMayaDoubleToUsdSinglePrecision) { if (!usdAttr || attrPlug.isNull()) { return false; } bool isAnimated = attrPlug.isDestination(); if (usdTime.IsDefault() == isAnimated) { return true; } // We perform a similar set of type-infererence acrobatics here as we do up // above in GetUsdTypeName(). See the comments there for more detail on a // few type-related oddities. MObject attrObj(attrPlug.attribute()); if (attrObj.hasFn(MFn::kEnumAttribute)) { MFnEnumAttribute enumAttrFn(attrObj); const short enumIndex = attrPlug.asShort(); const TfToken enumToken(enumAttrFn.fieldName(enumIndex).asChar()); return usdAttr.Set(enumToken, usdTime); } MFnNumericData::Type numericDataType; MFnData::Type typedDataType; MFnUnitAttribute::Type unitDataType; _GetMayaAttributeNumericTypedAndUnitDataTypes(attrPlug, numericDataType, typedDataType, unitDataType); if (attrObj.hasFn(MFn::kMatrixAttribute)) { typedDataType = MFnData::kMatrix; } switch (typedDataType) { case MFnData::kString: { MFnStringData stringDataFn(attrPlug.asMObject()); const std::string usdVal(stringDataFn.string().asChar()); return usdAttr.Set(usdVal, usdTime); break; } case MFnData::kMatrix: { MFnMatrixData matrixDataFn(attrPlug.asMObject()); const GfMatrix4d usdVal(matrixDataFn.matrix().matrix); return usdAttr.Set(usdVal, usdTime); break; } case MFnData::kStringArray: { MFnStringArrayData stringArrayDataFn(attrPlug.asMObject()); VtStringArray usdVal(stringArrayDataFn.length()); for (unsigned int i = 0; i < stringArrayDataFn.length(); ++i) { usdVal[i] = std::string(stringArrayDataFn[i].asChar()); } return usdAttr.Set(usdVal, usdTime); break; } case MFnData::kDoubleArray: { MFnDoubleArrayData doubleArrayDataFn(attrPlug.asMObject()); if (translateMayaDoubleToUsdSinglePrecision) { VtFloatArray usdVal(doubleArrayDataFn.length()); for (unsigned int i = 0; i < doubleArrayDataFn.length(); ++i) { usdVal[i] = (float)doubleArrayDataFn[i]; } return usdAttr.Set(usdVal, usdTime); } else { VtDoubleArray usdVal(doubleArrayDataFn.length()); for (unsigned int i = 0; i < doubleArrayDataFn.length(); ++i) { usdVal[i] = doubleArrayDataFn[i]; } return usdAttr.Set(usdVal, usdTime); } break; } case MFnData::kFloatArray: { MFnFloatArrayData floatArrayDataFn(attrPlug.asMObject()); VtFloatArray usdVal(floatArrayDataFn.length()); for (unsigned int i = 0; i < floatArrayDataFn.length(); ++i) { usdVal[i] = floatArrayDataFn[i]; } return usdAttr.Set(usdVal, usdTime); break; } case MFnData::kIntArray: { MFnIntArrayData intArrayDataFn(attrPlug.asMObject()); VtIntArray usdVal(intArrayDataFn.length()); for (unsigned int i = 0; i < intArrayDataFn.length(); ++i) { usdVal[i] = intArrayDataFn[i]; } return usdAttr.Set(usdVal, usdTime); break; } case MFnData::kPointArray: { MFnPointArrayData pointArrayDataFn(attrPlug.asMObject()); if (translateMayaDoubleToUsdSinglePrecision) { VtVec3fArray usdVal(pointArrayDataFn.length()); for (unsigned int i = 0; i < pointArrayDataFn.length(); ++i) { MPoint tmpMayaVal = pointArrayDataFn[i]; if (tmpMayaVal.w != 0) { tmpMayaVal.cartesianize(); } usdVal[i] = GfVec3f((float)tmpMayaVal[0], (float)tmpMayaVal[1], (float)tmpMayaVal[2]); } return usdAttr.Set(usdVal, usdTime); } else { VtVec3dArray usdVal(pointArrayDataFn.length()); for (unsigned int i = 0; i < pointArrayDataFn.length(); ++i) { MPoint tmpMayaVal = pointArrayDataFn[i]; if (tmpMayaVal.w != 0) { tmpMayaVal.cartesianize(); } usdVal[i] = GfVec3d(tmpMayaVal[0], tmpMayaVal[1], tmpMayaVal[2]); } return usdAttr.Set(usdVal, usdTime); } break; } case MFnData::kVectorArray: { MFnVectorArrayData vectorArrayDataFn(attrPlug.asMObject()); if (translateMayaDoubleToUsdSinglePrecision) { VtVec3fArray usdVal(vectorArrayDataFn.length()); for (unsigned int i = 0; i < vectorArrayDataFn.length(); ++i) { MVector tmpMayaVal = vectorArrayDataFn[i]; usdVal[i] = GfVec3f((float)tmpMayaVal[0], (float)tmpMayaVal[1], (float)tmpMayaVal[2]); } return usdAttr.Set(usdVal, usdTime); } else { VtVec3dArray usdVal(vectorArrayDataFn.length()); for (unsigned int i = 0; i < vectorArrayDataFn.length(); ++i) { MVector tmpMayaVal = vectorArrayDataFn[i]; usdVal[i] = GfVec3d(tmpMayaVal[0], tmpMayaVal[1], tmpMayaVal[2]); } return usdAttr.Set(usdVal, usdTime); } break; } default: break; } switch (numericDataType) { case MFnNumericData::kBoolean: { const bool usdVal(attrPlug.asBool()); return usdAttr.Set(usdVal, usdTime); break; } case MFnNumericData::kByte: case MFnNumericData::kChar: { const int usdVal(attrPlug.asChar()); return usdAttr.Set(usdVal, usdTime); break; } case MFnNumericData::kShort: { const int usdVal(attrPlug.asShort()); return usdAttr.Set(usdVal, usdTime); break; } case MFnNumericData::kInt: { const int usdVal(attrPlug.asInt()); return usdAttr.Set(usdVal, usdTime); break; } case MFnNumericData::k2Short: { short tmp1, tmp2; MFnNumericData numericDataFn(attrPlug.asMObject()); numericDataFn.getData(tmp1, tmp2); return usdAttr.Set(GfVec2i(tmp1, tmp2), usdTime); break; } case MFnNumericData::k2Int: { int tmp1, tmp2; MFnNumericData numericDataFn(attrPlug.asMObject()); numericDataFn.getData(tmp1, tmp2); return usdAttr.Set(GfVec2i(tmp1, tmp2), usdTime); break; } case MFnNumericData::k3Short: { short tmp1, tmp2, tmp3; MFnNumericData numericDataFn(attrPlug.asMObject()); numericDataFn.getData(tmp1, tmp2, tmp3); return usdAttr.Set(GfVec3i(tmp1, tmp2, tmp3), usdTime); break; } case MFnNumericData::k3Int: { int tmp1, tmp2, tmp3; MFnNumericData numericDataFn(attrPlug.asMObject()); numericDataFn.getData(tmp1, tmp2, tmp3); return usdAttr.Set(GfVec3i(tmp1, tmp2, tmp3), usdTime); break; } case MFnNumericData::kFloat: { const float usdVal(attrPlug.asFloat()); return usdAttr.Set(usdVal, usdTime); break; } case MFnNumericData::k2Float: { float tmp1, tmp2; MFnNumericData numericDataFn(attrPlug.asMObject()); numericDataFn.getData(tmp1, tmp2); return usdAttr.Set(GfVec2f(tmp1, tmp2), usdTime); break; } case MFnNumericData::k3Float: { float tmp1, tmp2, tmp3; MFnNumericData numericDataFn(attrPlug.asMObject()); numericDataFn.getData(tmp1, tmp2, tmp3); return _SetVec(usdAttr, GfVec3f(tmp1, tmp2, tmp3), usdTime); break; } case MFnNumericData::kDouble: { const double usdVal(attrPlug.asDouble()); if (translateMayaDoubleToUsdSinglePrecision) { return usdAttr.Set((float)usdVal, usdTime); } else { return usdAttr.Set(usdVal, usdTime); } break; } case MFnNumericData::k2Double: { double tmp1, tmp2; MFnNumericData numericDataFn(attrPlug.asMObject()); numericDataFn.getData(tmp1, tmp2); if (translateMayaDoubleToUsdSinglePrecision) { return usdAttr.Set(GfVec2f((float)tmp1, (float)tmp2), usdTime); } else { return usdAttr.Set(GfVec2d(tmp1, tmp2), usdTime); } break; } case MFnNumericData::k3Double: { double tmp1, tmp2, tmp3; MFnNumericData numericDataFn(attrPlug.asMObject()); numericDataFn.getData(tmp1, tmp2, tmp3); if (translateMayaDoubleToUsdSinglePrecision) { return _SetVec(usdAttr, GfVec3f((float)tmp1, (float)tmp2, (float)tmp3), usdTime); } else { return _SetVec(usdAttr, GfVec3d(tmp1, tmp2, tmp3), usdTime); } break; } case MFnNumericData::k4Double: { double tmp1, tmp2, tmp3, tmp4; MFnNumericData numericDataFn(attrPlug.asMObject()); numericDataFn.getData(tmp1, tmp2, tmp3, tmp4); if (translateMayaDoubleToUsdSinglePrecision) { return _SetVec(usdAttr, GfVec4f((float)tmp1, (float)tmp2, (float)tmp3, (float)tmp4), usdTime); } else { return _SetVec(usdAttr, GfVec4d(tmp1, tmp2, tmp3, tmp4), usdTime); } break; } default: break; } switch (unitDataType) { case MFnUnitAttribute::kAngle: case MFnUnitAttribute::kDistance: if (translateMayaDoubleToUsdSinglePrecision) { const float usdVal(attrPlug.asFloat()); return usdAttr.Set(usdVal, usdTime); } else { const double usdVal(attrPlug.asDouble()); return usdAttr.Set(usdVal, usdTime); } break; default: break; } return false; }
virtual void ExportUserAttrs( AtNode *node ) { // Get the optional attributes and export them as user vars MPlug plug = FindMayaObjectPlug( "shaderAssignation" ); if( !plug.isNull() ) { AiNodeDeclare( node, "shaderAssignation", "constant STRING" ); AiNodeSetStr( node, "shaderAssignation", plug.asString().asChar() ); } plug = FindMayaObjectPlug( "displacementAssignation" ); if( !plug.isNull() ) { AiNodeDeclare( node, "displacementAssignation", "constant STRING" ); AiNodeSetStr( node, "displacementAssignation", plug.asString().asChar() ); } plug = FindMayaObjectPlug( "shaderAssignmentfile" ); if( !plug.isNull() ) { AiNodeDeclare( node, "shaderAssignmentfile", "constant STRING" ); AiNodeSetStr( node, "shaderAssignmentfile", plug.asString().asChar() ); } plug = FindMayaObjectPlug( "overrides" ); if( !plug.isNull() ) { AiNodeDeclare( node, "overrides", "constant STRING" ); AiNodeSetStr( node, "overrides", plug.asString().asChar() ); } plug = FindMayaObjectPlug( "overridefile" ); if( !plug.isNull() ) { AiNodeDeclare( node, "overridefile", "constant STRING" ); AiNodeSetStr( node, "overridefile", plug.asString().asChar() ); } plug = FindMayaObjectPlug( "userAttributes" ); if( !plug.isNull() ) { AiNodeDeclare( node, "userAttributes", "constant STRING" ); AiNodeSetStr( node, "userAttributes", plug.asString().asChar() ); } plug = FindMayaObjectPlug( "userAttributesfile" ); if( !plug.isNull() ) { AiNodeDeclare( node, "userAttributesfile", "constant STRING" ); AiNodeSetStr( node, "userAttributesfile", plug.asString().asChar() ); } plug = FindMayaObjectPlug( "skipJson" ); if( !plug.isNull() ) { AiNodeDeclare( node, "skipJson", "constant BOOL" ); AiNodeSetBool( node, "skipJson", plug.asBool() ); } plug = FindMayaObjectPlug( "skipShaders" ); if( !plug.isNull() ) { AiNodeDeclare( node, "skipShaders", "constant BOOL" ); AiNodeSetBool( node, "skipShaders", plug.asBool() ); } plug = FindMayaObjectPlug( "skipOverrides" ); if( !plug.isNull() ) { AiNodeDeclare( node, "skipOverrides", "constant BOOL" ); AiNodeSetBool( node, "skipOverrides", plug.asBool() ); } plug = FindMayaObjectPlug( "skipUserAttributes" ); if( !plug.isNull() ) { AiNodeDeclare( node, "skipUserAttributes", "constant BOOL" ); AiNodeSetBool( node, "skipUserAttributes", plug.asBool() ); } plug = FindMayaObjectPlug( "skipDisplacements" ); if( !plug.isNull() ) { AiNodeDeclare( node, "skipDisplacements", "constant BOOL" ); AiNodeSetBool( node, "skipDisplacements", plug.asBool() ); } plug = FindMayaObjectPlug( "objectPattern" ); if( !plug.isNull() ) { AiNodeDeclare( node, "objectPattern", "constant STRING" ); AiNodeSetStr( node, "objectPattern", plug.asString().asChar() ); } plug = FindMayaObjectPlug( "assShaders" ); if( !plug.isNull() ) { AiNodeDeclare( node, "assShaders", "constant STRING" ); AiNodeSetStr( node, "assShaders", plug.asString().asChar() ); } plug = FindMayaObjectPlug( "radiusPoint" ); if( !plug.isNull() ) { AiNodeDeclare( node, "radiusPoint", "constant FLOAT" ); AiNodeSetFlt( node, "radiusPoint", plug.asFloat() ); } plug = FindMayaObjectPlug( "radiusCurve" ); if( !plug.isNull() ) { AiNodeDeclare( node, "radiusCurve", "constant FLOAT" ); AiNodeSetFlt( node, "radiusCurve", plug.asFloat() ); } plug = FindMayaObjectPlug( "modeCurve" ); if( !plug.isNull() ) { AiNodeDeclare( node, "modeCurve", "constant STRING" ); int modeCurveInt = plug.asInt(); if (modeCurveInt == 1) AiNodeSetStr(node, "modeCurve", "thick"); else if (modeCurveInt == 2) AiNodeSetStr(node, "modeCurve", "oriented"); else AiNodeSetStr(node, "modeCurve", "ribbon"); } plug = FindMayaObjectPlug( "scaleVelocity" ); if( !plug.isNull() ) { AiNodeDeclare( node, "scaleVelocity", "constant FLOAT" ); AiNodeSetFlt( node, "scaleVelocity", plug.asFloat() ); } }
virtual void ExportProcedural( AtNode *node ) { // do basic node export ExportMatrix( node, 0 ); // AiNodeSetPtr( node, "shader", arnoldShader(node) ); AiNodeSetInt( node, "visibility", ComputeVisibility() ); MPlug plug = FindMayaObjectPlug( "receiveShadows" ); if( !plug.isNull() ) { AiNodeSetBool( node, "receive_shadows", plug.asBool() ); } plug = FindMayaObjectPlug( "aiSelfShadows" ); if( !plug.isNull() ) { AiNodeSetBool( node, "self_shadows", plug.asBool() ); } plug = FindMayaObjectPlug( "aiOpaque" ); if( !plug.isNull() ) { AiNodeSetBool( node, "opaque", plug.asBool() ); } // now set the procedural-specific parameters AiNodeSetBool( node, "load_at_init", true ); // just for now so that it can load the shaders at the right time MFnDagNode fnDagNode( m_dagPath ); MBoundingBox bound = fnDagNode.boundingBox(); AiNodeSetPnt( node, "min", bound.min().x-m_dispPadding, bound.min().y-m_dispPadding, bound.min().z-m_dispPadding ); AiNodeSetPnt( node, "max", bound.max().x+m_dispPadding, bound.max().y, bound.max().z+m_dispPadding ); const char *dsoPath = getenv( "ALEMBIC_ARNOLD_PROCEDURAL_PATH" ); AiNodeSetStr( node, "dso", dsoPath ? dsoPath : "bb_AlembicArnoldProcedural.so" ); // Set the parameters for the procedural //abcFile path MString abcFile = fnDagNode.findPlug("cacheFileName").asString().expandEnvironmentVariablesAndTilde(); //object path MString objectPath = fnDagNode.findPlug("cacheGeomPath").asString(); //object pattern MString objectPattern = "*"; plug = FindMayaObjectPlug( "objectPattern" ); if (!plug.isNull() ) { if (plug.asString() != "") { objectPattern = plug.asString(); } } //object pattern MString excludePattern = ""; plug = FindMayaObjectPlug( "excludePattern" ); if (!plug.isNull() ) { if (plug.asString() != "") { excludePattern = plug.asString(); } } float shutterOpen = 0.0; plug = FindMayaObjectPlug( "shutterOpen" ); if (!plug.isNull() ) { shutterOpen = plug.asFloat(); } float shutterClose = 0.0; plug = FindMayaObjectPlug( "shutterClose" ); if (!plug.isNull() ) { shutterClose = plug.asFloat(); } float timeOffset = 0.0; plug = FindMayaObjectPlug( "timeOffset" ); if (!plug.isNull() ) { timeOffset = plug.asFloat(); } int subDIterations = 0; plug = FindMayaObjectPlug( "ai_subDIterations" ); if (!plug.isNull() ) { subDIterations = plug.asInt(); } MString nameprefix = ""; plug = FindMayaObjectPlug( "namePrefix" ); if (!plug.isNull() ) { nameprefix = plug.asString(); } // bool exportFaceIds = fnDagNode.findPlug("exportFaceIds").asBool(); bool makeInstance = true; // always on for now plug = FindMayaObjectPlug( "makeInstance" ); if (!plug.isNull() ) { makeInstance = plug.asBool(); } bool flipv = false; plug = FindMayaObjectPlug( "flipv" ); if (!plug.isNull() ) { flipv = plug.asBool(); } bool invertNormals = false; plug = FindMayaObjectPlug( "invertNormals" ); if (!plug.isNull() ) { invertNormals = plug.asBool(); } short i_subDUVSmoothing = 1; plug = FindMayaObjectPlug( "ai_subDUVSmoothing" ); if (!plug.isNull() ) { i_subDUVSmoothing = plug.asShort(); } MString subDUVSmoothing; switch (i_subDUVSmoothing) { case 0: subDUVSmoothing = "pin_corners"; break; case 1: subDUVSmoothing = "pin_borders"; break; case 2: subDUVSmoothing = "linear"; break; case 3: subDUVSmoothing = "smooth"; break; default : subDUVSmoothing = "pin_corners"; break; } MTime curTime = MAnimControl::currentTime(); // fnDagNode.findPlug("time").getValue( frame ); // MTime frameOffset; // fnDagNode.findPlug("timeOffset").getValue( frameOffset ); float time = curTime.as(MTime::kFilm)+timeOffset; MString argsString; if (objectPath != "|"){ argsString += "-objectpath "; // convert "|" to "/" argsString += MString(replace_all(objectPath,"|","/").c_str()); } if (objectPattern != "*"){ argsString += "-pattern "; argsString += objectPattern; } if (excludePattern != ""){ argsString += "-excludepattern "; argsString += excludePattern; } if (shutterOpen != 0.0){ argsString += " -shutteropen "; argsString += shutterOpen; } if (shutterClose != 0.0){ argsString += " -shutterclose "; argsString += shutterClose; } if (subDIterations != 0){ argsString += " -subditerations "; argsString += subDIterations; argsString += " -subduvsmoothing "; argsString += subDUVSmoothing; } if (makeInstance){ argsString += " -makeinstance "; } if (nameprefix != ""){ argsString += " -nameprefix "; argsString += nameprefix; } if (flipv){ argsString += " -flipv "; } if (invertNormals){ argsString += " -invertNormals "; } argsString += " -filename "; argsString += abcFile; argsString += " -frame "; argsString += time; if (m_displaced){ argsString += " -disp_map "; argsString += AiNodeGetName(m_dispNode); } AiNodeSetStr(node, "data", argsString.asChar()); ExportUserAttrs(node); // Export light linking per instance ExportLightLinking(node); }
MBoundingBox ovalLocator::boundingBox () const { MPlug plug (thisMObject (), ovalLocator::size) ; float multiplier =plug.asFloat () ; return (ovalLocator::boundingbox (multiplier)) ; }
void MayaNurbsCurveWriter::write() { Alembic::AbcGeom::OCurvesSchema::Sample samp; samp.setBasis(Alembic::AbcGeom::kBsplineBasis); MStatus stat; mCVCount = 0; // if inheritTransform is on and the curve group is animated, // bake the cv positions in the world space MMatrix exclusiveMatrixInv = mRootDagPath.exclusiveMatrixInverse(&stat); std::size_t numCurves = 1; if (mIsCurveGrp) numCurves = mNurbsCurves.length(); std::vector<Alembic::Util::int32_t> nVertices(numCurves); std::vector<float> points; std::vector<float> width; std::vector<float> knots; std::vector<Alembic::Util::uint8_t> orders(numCurves); MMatrix transformMatrix; bool useConstWidth = false; MFnDependencyNode dep(mRootDagPath.transform()); MPlug constWidthPlug = dep.findPlug("width"); if (!constWidthPlug.isNull()) { useConstWidth = true; width.push_back(constWidthPlug.asFloat()); } for (unsigned int i = 0; i < numCurves; i++) { MFnNurbsCurve curve; if (mIsCurveGrp) { curve.setObject(mNurbsCurves[i]); MMatrix inclusiveMatrix = mNurbsCurves[i].inclusiveMatrix(&stat); transformMatrix = inclusiveMatrix*exclusiveMatrixInv; } else { curve.setObject(mRootDagPath.node()); } if (i == 0) { if (curve.form() == MFnNurbsCurve::kOpen) { samp.setWrap(Alembic::AbcGeom::kNonPeriodic); } else { samp.setWrap(Alembic::AbcGeom::kPeriodic); } if (curve.degree() == 3) { samp.setType(Alembic::AbcGeom::kCubic); } else if (curve.degree() == 1) { samp.setType(Alembic::AbcGeom::kLinear); } else { samp.setType(Alembic::AbcGeom::kVariableOrder); } } else { if (curve.form() == MFnNurbsCurve::kOpen) { samp.setWrap(Alembic::AbcGeom::kNonPeriodic); } if ((samp.getType() == Alembic::AbcGeom::kCubic && curve.degree() != 3) || (samp.getType() == Alembic::AbcGeom::kLinear && curve.degree() != 1)) { samp.setType(Alembic::AbcGeom::kVariableOrder); } } orders[i] = static_cast<Alembic::Util::uint8_t>(curve.degree() + 1); Alembic::Util::int32_t numCVs = curve.numCVs(&stat); MPointArray cvArray; stat = curve.getCVs(cvArray, MSpace::kObject); mCVCount += numCVs; nVertices[i] = numCVs; for (Alembic::Util::int32_t j = 0; j < numCVs; j++) { MPoint transformdPt; if (mIsCurveGrp) { transformdPt = cvArray[j]*transformMatrix; } else { transformdPt = cvArray[j]; } points.push_back(static_cast<float>(transformdPt.x)); points.push_back(static_cast<float>(transformdPt.y)); points.push_back(static_cast<float>(transformdPt.z)); } MDoubleArray knotsArray; curve.getKnots(knotsArray); knots.reserve(knotsArray.length() + 2); // need to add a knot to the start and end (M + 2N + 1) if (knotsArray.length() > 1) { unsigned int knotsLength = knotsArray.length(); if (knotsArray[0] == knotsArray[knotsLength - 1] || knotsArray[0] == knotsArray[1]) { knots.push_back(knotsArray[0]); } else { knots.push_back(2 * knotsArray[0] - knotsArray[1]); } for (unsigned int j = 0; j < knotsLength; ++j) { knots.push_back(knotsArray[j]); } if (knotsArray[0] == knotsArray[knotsLength - 1] || knotsArray[knotsLength - 1] == knotsArray[knotsLength - 2]) { knots.push_back(knotsArray[knotsLength - 1]); } else { knots.push_back(2 * knotsArray[knotsLength - 1] - knotsArray[knotsLength - 2]); } } // width MPlug widthPlug = curve.findPlug("width"); if (!useConstWidth && !widthPlug.isNull()) { MObject widthObj; MStatus status = widthPlug.getValue(widthObj); MFnDoubleArrayData fnDoubleArrayData(widthObj, &status); MDoubleArray doubleArrayData = fnDoubleArrayData.array(); Alembic::Util::int32_t arraySum = doubleArrayData.length(); if (arraySum == numCVs) { for (Alembic::Util::int32_t i = 0; i < arraySum; i++) { width.push_back(static_cast<float>(doubleArrayData[i])); } } else if (status == MS::kSuccess) { MString msg = "Curve "; msg += curve.partialPathName(); msg += " has incorrect size for the width vector."; msg += "\nUsing default constant width of 0.1."; MGlobal::displayWarning(msg); width.clear(); width.push_back(0.1f); useConstWidth = true; } else { width.push_back(widthPlug.asFloat()); useConstWidth = true; } } else if (!useConstWidth) { // pick a default value width.clear(); width.push_back(0.1f); useConstWidth = true; } } Alembic::AbcGeom::GeometryScope scope = Alembic::AbcGeom::kVertexScope; if (useConstWidth) scope = Alembic::AbcGeom::kConstantScope; samp.setCurvesNumVertices(Alembic::Abc::Int32ArraySample(nVertices)); samp.setPositions(Alembic::Abc::V3fArraySample( (const Imath::V3f *)&points.front(), points.size() / 3 )); samp.setWidths(Alembic::AbcGeom::OFloatGeomParam::Sample( Alembic::Abc::FloatArraySample(width), scope) ); if (samp.getType() == Alembic::AbcGeom::kVariableOrder) { samp.setOrders(Alembic::Abc::UcharArraySample(orders)); } if (!knots.empty()) { samp.setKnots(Alembic::Abc::FloatArraySample(knots)); } mSchema.set(samp); }
bool PxrUsdMayaWriteUtil::SetUsdAttr( const MPlug &plg, const UsdAttribute& usdAttr, const UsdTimeCode &usdTime) { MStatus status; if (!usdAttr || plg.isNull() ) { return false; } bool isAnimated = plg.isDestination(); if (usdTime.IsDefault() == isAnimated ) { return true; } // Set UsdAttr MObject attrObj = plg.attribute(); if (attrObj.hasFn(MFn::kNumericAttribute)) { MFnNumericAttribute attrNumericFn(attrObj); switch (attrNumericFn.unitType()) { case MFnNumericData::kBoolean: usdAttr.Set(plg.asBool(), usdTime); break; case MFnNumericData::kByte: case MFnNumericData::kChar: usdAttr.Set((int)plg.asChar(), usdTime); break; case MFnNumericData::kShort: usdAttr.Set(int(plg.asShort()), usdTime); break; case MFnNumericData::kInt: usdAttr.Set(int(plg.asInt()), usdTime); break; //case MFnNumericData::kLong: //case MFnNumericData::kAddr: // usdAttr.Set(plg.asInt(), usdTime); // break; case MFnNumericData::kFloat: usdAttr.Set(plg.asFloat(), usdTime); break; case MFnNumericData::kDouble: usdAttr.Set(plg.asDouble(), usdTime); break; case MFnNumericData::k2Short: { short tmp1, tmp2; MFnNumericData attrNumericDataFn(plg.asMObject()); attrNumericDataFn.getData(tmp1, tmp2); usdAttr.Set(GfVec2i(tmp1, tmp2), usdTime); break; } case MFnNumericData::k2Int: { int tmp1, tmp2; MFnNumericData attrNumericDataFn(plg.asMObject()); attrNumericDataFn.getData(tmp1, tmp2); usdAttr.Set(GfVec2i(tmp1, tmp2), usdTime); break; } //case MFnNumericData::k2Long: case MFnNumericData::k3Short: { short tmp1, tmp2, tmp3; MFnNumericData attrNumericDataFn(plg.asMObject()); attrNumericDataFn.getData(tmp1, tmp2, tmp3); usdAttr.Set(GfVec3i(tmp1, tmp2, tmp3), usdTime); break; } case MFnNumericData::k3Int: { int tmp1, tmp2, tmp3; MFnNumericData attrNumericDataFn(plg.asMObject()); attrNumericDataFn.getData(tmp1, tmp2, tmp3); usdAttr.Set(GfVec3i(tmp1, tmp2, tmp3), usdTime); break; } //case MFnNumericData::k3Long: case MFnNumericData::k2Float: { float tmp1, tmp2; MFnNumericData attrNumericDataFn(plg.asMObject()); attrNumericDataFn.getData(tmp1, tmp2); usdAttr.Set(GfVec2f(tmp1, tmp2), usdTime); break; } case MFnNumericData::k3Float: { float tmp1, tmp2, tmp3; MFnNumericData attrNumericDataFn(plg.asMObject()); attrNumericDataFn.getData(tmp1, tmp2, tmp3); _SetVec(usdAttr, GfVec3f(tmp1, tmp2, tmp3), usdTime); break; } case MFnNumericData::k2Double: { double tmp1, tmp2; MFnNumericData attrNumericDataFn(plg.asMObject()); attrNumericDataFn.getData(tmp1, tmp2); usdAttr.Set(GfVec2d(tmp1, tmp2), usdTime); break; } case MFnNumericData::k3Double: { double tmp1, tmp2, tmp3; MFnNumericData attrNumericDataFn(plg.asMObject()); attrNumericDataFn.getData(tmp1, tmp2, tmp3); _SetVec(usdAttr, GfVec3d(tmp1, tmp2, tmp3), usdTime); break; } case MFnNumericData::k4Double: { double tmp1, tmp2, tmp3, tmp4; MFnNumericData attrNumericDataFn(plg.asMObject()); attrNumericDataFn.getData(tmp1, tmp2, tmp3, tmp4); _SetVec(usdAttr, GfVec4d(tmp1, tmp2, tmp3, tmp4), usdTime); break; } default: return false; } } else if (attrObj.hasFn(MFn::kTypedAttribute)) { MFnTypedAttribute attrTypedFn(attrObj); switch (attrTypedFn.attrType()) { case MFnData::kString: usdAttr.Set(std::string(plg.asString().asChar()), usdTime); break; case MFnData::kMatrix: { MFnMatrixData attrMatrixDataFn(plg.asMObject()); MMatrix mat1 = attrMatrixDataFn.matrix(); usdAttr.Set(GfMatrix4d(mat1.matrix), usdTime); break; } case MFnData::kStringArray: { MFnStringArrayData attrDataFn(plg.asMObject()); VtArray<std::string> usdVal(attrDataFn.length()); for (unsigned int i=0; i < attrDataFn.length(); i++) { usdVal[i] = std::string(attrDataFn[i].asChar()); } usdAttr.Set(usdVal, usdTime); break; } case MFnData::kIntArray: { MFnIntArrayData attrDataFn(plg.asMObject()); VtArray<int> usdVal(attrDataFn.length()); for (unsigned int i=0; i < attrDataFn.length(); i++) { usdVal[i] = attrDataFn[i]; } usdAttr.Set(usdVal, usdTime); break; } case MFnData::kFloatArray: { MFnFloatArrayData attrDataFn(plg.asMObject()); VtArray<float> usdVal(attrDataFn.length()); for (unsigned int i=0; i < attrDataFn.length(); i++) { usdVal[i] = attrDataFn[i]; } usdAttr.Set(usdVal, usdTime); break; } case MFnData::kDoubleArray: { MFnDoubleArrayData attrDataFn(plg.asMObject()); VtArray<double> usdVal(attrDataFn.length()); for (unsigned int i=0; i < attrDataFn.length(); i++) { usdVal[i] = attrDataFn[i]; } usdAttr.Set(usdVal, usdTime); break; } case MFnData::kVectorArray: { MFnVectorArrayData attrDataFn(plg.asMObject()); VtArray<GfVec3d> usdVal(attrDataFn.length()); for (unsigned int i=0; i < attrDataFn.length(); i++) { MVector tmpMayaVal = attrDataFn[i]; usdVal[i] = GfVec3d(tmpMayaVal[0], tmpMayaVal[1], tmpMayaVal[2]); } usdAttr.Set(usdVal, usdTime); break; } case MFnData::kPointArray: { MFnPointArrayData attrDataFn(plg.asMObject()); VtArray<GfVec4d> usdVal(attrDataFn.length()); for (unsigned int i=0; i < attrDataFn.length(); i++) { MPoint tmpMayaVal = attrDataFn[i]; usdVal[i] = GfVec4d(tmpMayaVal[0], tmpMayaVal[1], tmpMayaVal[2], tmpMayaVal[3]); } usdAttr.Set(usdVal, usdTime); break; } default: return false; } } else if (attrObj.hasFn(MFn::kUnitAttribute)) { //MFnUnitAttribute attrUnitFn(attrObj); return false; } else if (attrObj.hasFn(MFn::kEnumAttribute)) { MFnEnumAttribute attrEnumFn(attrObj); short enumIndex = plg.asShort(); TfToken enumToken( std::string(attrEnumFn.fieldName(enumIndex, &status).asChar()) ); usdAttr.Set(enumToken, usdTime); return false; } return true; }