// alembic by default sets meshes to be poly unless it's explicitly set to be // subdivision. UsdExport makes meshes catmullClark by default. Here, we // implement logic to get set the subdivision scheme so that it matches. static void _SetMeshesSubDivisionScheme( UsdStagePtr stage, const UsdMayaChaserRegistry::FactoryContext::DagToUsdMap& dagToUsd) { for (const auto& p: dagToUsd) { const MDagPath& dag = p.first; const SdfPath& usdPrimPath = p.second; if (!dag.isValid()) { continue; } MStatus status; MFnMesh meshFn(dag, &status); if (!status) { continue; } if (UsdGeomMesh usdMesh = UsdGeomMesh::Get(stage, usdPrimPath)) { MPlug plug = meshFn.findPlug("SubDivisionMesh"); bool isSubDivisionMesh = (!plug.isNull() && plug.asBool()); if (!isSubDivisionMesh) { usdMesh.GetSubdivisionSchemeAttr().Set(UsdGeomTokens->none); } } } }
bool SceneShape::hasSceneShapeLink( const MDagPath &p ) { MDagPath dagPath; SceneShape *sceneShape = findScene( p, true, &dagPath ); if ( !sceneShape ) { return false; } MFnDagNode fnChildDag( dagPath ); MStatus st; MPlug objectOnlyPlug = fnChildDag.findPlug( aObjectOnly, &st ); if( !st ) { throw Exception( "Could not find 'objectOnly' plug in SceneShape!"); } // if we're doing objects only, we just output the object directly, so we don't need link attributes... if( objectOnlyPlug.asBool() ) { return false; } if ( !sceneShape->getSceneInterface() ) { return false; } // so if it's not object only, then we know the scene loads everything and we can create a link to it. return true; }
bool SceneShape::hasSceneShapeObject( const MDagPath &p ) { MDagPath dagPath; SceneShape *sceneShape = findScene( p, true, &dagPath ); if ( !sceneShape ) { return false; } MFnDagNode fnChildDag( dagPath ); MStatus st; MPlug objectOnlyPlug = fnChildDag.findPlug( aObjectOnly, &st ); if( !st ) { throw Exception( "Could not find 'objectOnly' plug in SceneShape!"); } // if we're rendering object and children than it should only be represented as a link to the scene and no objects. if( !objectOnlyPlug.asBool() ) { return false; } IECore::ConstSceneInterfacePtr sceneInterface = sceneShape->getSceneInterface(); if( !sceneInterface ) { return false; } return sceneInterface->hasObject(); }
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 util::isIntermediate(const MObject & object) { MStatus stat; MFnDagNode mFn(object); MPlug plug = mFn.findPlug("intermediateObject", false, &stat); if (stat == MS::kSuccess && plug.asBool()) return true; else return false; }
bool util::isRenderable(const MObject & object) { MStatus stat; MFnDagNode mFn(object); // templated turned on? return false MPlug plug = mFn.findPlug("template", false, &stat); if (stat == MS::kSuccess && plug.asBool()) return false; // visibility or lodVisibility off? return false plug = mFn.findPlug("visibility", false, &stat); if (stat == MS::kSuccess && !plug.asBool()) { // the value is off. let's check if it has any in-connection, // otherwise, it means it is not animated. MPlugArray arrayIn; plug.connectedTo(arrayIn, true, false, &stat); if (stat == MS::kSuccess && arrayIn.length() == 0) { return false; } } plug = mFn.findPlug("lodVisibility", false, &stat); if (stat == MS::kSuccess && !plug.asBool()) { MPlugArray arrayIn; plug.connectedTo(arrayIn, true, false, &stat); if (stat == MS::kSuccess && arrayIn.length() == 0) { return false; } } // this shape is renderable return true; }
bool getBool(MString& plugName, MFnDependencyNode& dn, bool& value) { MDGContext ctx = MDGContext::fsNormal; MStatus stat = MS::kSuccess; bool result = false; MPlug plug = dn.findPlug(plugName, &stat); if( !stat ) return false; value = plug.asBool(ctx, &stat); if(stat) return true; return result; }
MayaTransformWriter::MayaTransformWriter(double iFrame, MayaTransformWriter & iParent, MDagPath & iDag, uint32_t iTimeIndex, bool iWriteVisibility) { if (iDag.hasFn(MFn::kJoint)) { MFnIkJoint joint(iDag); Alembic::AbcGeom::OXform obj(iParent.getObject(), joint.name().asChar(), iTimeIndex); mSchema = obj.getSchema(); Alembic::Abc::OCompoundProperty cp = obj.getProperties(); mAttrs = AttributesWriterPtr(new AttributesWriter(iFrame, cp, joint, iTimeIndex, iWriteVisibility)); pushTransformStack(iFrame, joint); } else { MFnTransform trans(iDag); Alembic::AbcGeom::OXform obj(iParent.getObject(), trans.name().asChar(), iTimeIndex); mSchema = obj.getSchema(); Alembic::Abc::OCompoundProperty cp = obj.getProperties(); mAttrs = AttributesWriterPtr(new AttributesWriter(iFrame, cp, trans, iTimeIndex, iWriteVisibility)); pushTransformStack(iFrame, trans); } // need to look at inheritsTransform MFnDagNode dagNode(iDag); MPlug inheritPlug = dagNode.findPlug("inheritsTransform"); if (!inheritPlug.isNull()) { if (util::getSampledType(inheritPlug) != 0) mInheritsPlug = inheritPlug; mSample.setInheritsXforms(inheritPlug.asBool()); } // everything is default, don't write anything if (mSample.getNumOps() == 0 && mSample.getInheritsXforms()) return; mSchema.set(mSample); }
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(); } }
// 0 dont write, 1 write static 0, 2 write anim 0, 3 write anim -1 int util::getVisibilityType(const MPlug & iPlug) { int type = getSampledType(iPlug); // static case if (type == 0) { // dont write anything if (iPlug.asBool()) return 0; // write static 0 return 1; } else { // anim write -1 if (iPlug.asBool()) return 3; // write anim 0 return 2; } }
/// Returns the arnold shader to assign to the procedural. AtNode *arnoldShader() { bool overrideShaders = false; MPlug plug = FindMayaObjectPlug( "overrideProceduralShaders" ); if( !plug.isNull() ) { // if we've been told explicitly not to override the shaders // in the procedurals, then early out. overrideShaders = plug.asBool(); if( !overrideShaders ) { return 0; } } unsigned instNumber = m_dagPath.isInstanced() ? m_dagPath.instanceNumber() : 0; MPlug shadingGroupPlug = GetNodeShadingGroup(m_dagPath.node(), instNumber); if( !overrideShaders ) { // if we weren't explicitly told to override the shaders, then // decide whether to or not based on whether a non-default // shader has been applied to the shape by the user. MObject shadingGroupNode = shadingGroupPlug.node(); MFnDependencyNode fnShadingGroupNode( shadingGroupNode ); if( fnShadingGroupNode.name() != "initialShadingGroup" ) { overrideShaders = true; } } if( overrideShaders ) { return ExportNode( shadingGroupPlug ); } else { return 0; } }
MayaTransformWriter::MayaTransformWriter(Alembic::AbcGeom::OObject & iParent, MDagPath & iDag, Alembic::Util::uint32_t iTimeIndex, const JobArgs & iArgs) { mVerbose = iArgs.verbose; mFilterEulerRotations = iArgs.filterEulerRotations; mJointOrientOpIndex[0] = mJointOrientOpIndex[1] = mJointOrientOpIndex[2] = mRotateOpIndex[0] = mRotateOpIndex[1] = mRotateOpIndex[2] = mRotateAxisOpIndex[0] = mRotateAxisOpIndex[1] = mRotateAxisOpIndex[2] = ~size_t(0); if (iDag.hasFn(MFn::kJoint)) { MFnIkJoint joint(iDag); MString jointName = joint.name(); mName = util::stripNamespaces(jointName, iArgs.stripNamespace); Alembic::AbcGeom::OXform obj(iParent, mName.asChar(), iTimeIndex); mSchema = obj.getSchema(); Alembic::Abc::OCompoundProperty cp; Alembic::Abc::OCompoundProperty up; if (AttributesWriter::hasAnyAttr(joint, iArgs)) { cp = mSchema.getArbGeomParams(); up = mSchema.getUserProperties(); } mAttrs = AttributesWriterPtr(new AttributesWriter(cp, up, obj, joint, iTimeIndex, iArgs)); if (!iArgs.worldSpace) { pushTransformStack(joint, iTimeIndex == 0); // need to look at inheritsTransform MFnDagNode dagNode(iDag); MPlug inheritPlug = dagNode.findPlug("inheritsTransform"); if (!inheritPlug.isNull()) { if (util::getSampledType(inheritPlug) != 0) mInheritsPlug = inheritPlug; mSample.setInheritsXforms(inheritPlug.asBool()); } // everything is default, don't write anything if (mSample.getNumOps() == 0 && mSample.getInheritsXforms()) return; mSchema.set(mSample); return; } } else { MFnTransform trans(iDag); MString transName = trans.name(); mName = util::stripNamespaces(transName, iArgs.stripNamespace); Alembic::AbcGeom::OXform obj(iParent, mName.asChar(), iTimeIndex); mSchema = obj.getSchema(); Alembic::Abc::OCompoundProperty cp; Alembic::Abc::OCompoundProperty up; if (AttributesWriter::hasAnyAttr(trans, iArgs)) { cp = mSchema.getArbGeomParams(); up = mSchema.getUserProperties(); } mAttrs = AttributesWriterPtr(new AttributesWriter(cp, up, obj, trans, iTimeIndex, iArgs)); if (!iArgs.worldSpace) { pushTransformStack(trans, iTimeIndex == 0); // need to look at inheritsTransform MFnDagNode dagNode(iDag); MPlug inheritPlug = dagNode.findPlug("inheritsTransform"); if (!inheritPlug.isNull()) { if (util::getSampledType(inheritPlug) != 0) mInheritsPlug = inheritPlug; mSample.setInheritsXforms(inheritPlug.asBool()); } // everything is default, don't write anything if (mSample.getNumOps() == 0 && mSample.getInheritsXforms()) return; mSchema.set(mSample); return; } } // if we didn't bail early then we need to add all the transform // information at the current node and above // copy the dag path because we'll be popping from it MDagPath dag(iDag); int i; int numPaths = dag.length(); std::vector< MDagPath > dagList; for (i = numPaths - 1; i > -1; i--, dag.pop()) { dagList.push_back(dag); // inheritsTransform exists on both joints and transforms MFnDagNode dagNode(dag); MPlug inheritPlug = dagNode.findPlug("inheritsTransform"); // if inheritsTransform exists and is set to false, then we // don't need to worry about ancestor nodes above this one if (!inheritPlug.isNull() && !inheritPlug.asBool()) break; } std::vector< MDagPath >::iterator iStart = dagList.begin(); std::vector< MDagPath >::iterator iCur = dagList.end(); iCur--; // now loop backwards over our dagpath list so we push ancestor nodes // first, all the way down to the current node for (; iCur != iStart; iCur--) { // only add it to the stack don't write it yet! if (iCur->hasFn(MFn::kJoint)) { MFnIkJoint joint(*iCur); pushTransformStack(joint, iTimeIndex == 0); } else { MFnTransform trans(*iCur); pushTransformStack(trans, iTimeIndex == 0); } } // finally add any transform info on the final node and write it if (iCur->hasFn(MFn::kJoint)) { MFnIkJoint joint(*iCur); pushTransformStack(joint, iTimeIndex == 0); } else { MFnTransform trans(*iCur); pushTransformStack(trans, iTimeIndex == 0); } // need to look at inheritsTransform MFnDagNode dagNode(iDag); MPlug inheritPlug = dagNode.findPlug("inheritsTransform"); if (!inheritPlug.isNull()) { if (util::getSampledType(inheritPlug) != 0) mInheritsPlug = inheritPlug; mSample.setInheritsXforms(inheritPlug.asBool()); } // everything is default, don't write anything if (mSample.getNumOps() == 0 && mSample.getInheritsXforms()) return; mSchema.set(mSample); }
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() ); } }
MayaCameraWriter::MayaCameraWriter(MDagPath & iDag, Alembic::Abc::OObject & iParent, Alembic::Util::uint32_t iTimeIndex, const JobArgs & iArgs) : mIsAnimated(false), mDagPath(iDag), mUseRenderShutter(false), mShutterOpen(0.0), mShutterClose(0.0) { MStatus status = MS::kSuccess; MFnCamera cam(iDag, &status); if (!status) { MGlobal::displayError( "MFnCamera() failed for MayaCameraWriter" ); } MString name = cam.name(); name = util::stripNamespaces(name, iArgs.stripNamespace); Alembic::AbcGeom::OCamera obj(iParent, name.asChar(), iTimeIndex); mSchema = obj.getSchema(); MObject cameraObj = iDag.node(); if (iTimeIndex != 0 && util::isAnimated(cameraObj)) { mIsAnimated = true; } else { iTimeIndex = 0; } MObject renderObj; MSelectionList sel; sel.add("defaultRenderGlobals"); if (!sel.isEmpty()) { sel.getDependNode(0, renderObj); MFnDependencyNode dep(renderObj); MPlug plug = dep.findPlug("motionBlurUseShutter", true); if (plug.asBool()) { MTime sec(1.0, MTime::kSeconds); double val = sec.as(MTime::uiUnit()); mUseRenderShutter = true; plug = dep.findPlug("motionBlurShutterOpen", true); mShutterOpen = plug.asDouble() / val; plug = dep.findPlug("motionBlurShutterClose", true); mShutterClose = plug.asDouble() / val; } } Alembic::Abc::OCompoundProperty cp; Alembic::Abc::OCompoundProperty up; if (AttributesWriter::hasAnyAttr(cam, iArgs)) { cp = mSchema.getArbGeomParams(); up = mSchema.getUserProperties(); } mAttrs = AttributesWriterPtr(new AttributesWriter(cp, up, obj, cam, iTimeIndex, iArgs, true)); if (!mIsAnimated || iArgs.setFirstAnimShape) { write(); } }
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; }
MayaTransformWriter::MayaTransformWriter(double iFrame, Alembic::AbcGeom::OObject & iParent, MDagPath & iDag, uint32_t iTimeIndex, bool iAddWorld, bool iWriteVisibility) { if (iDag.hasFn(MFn::kJoint)) { MFnIkJoint joint(iDag); Alembic::AbcGeom::OXform obj(iParent, joint.name().asChar(), iTimeIndex); mSchema = obj.getSchema(); Alembic::Abc::OCompoundProperty cp = obj.getProperties(); mAttrs = AttributesWriterPtr(new AttributesWriter(iFrame, cp, joint, iTimeIndex, iWriteVisibility)); if (!iAddWorld) { pushTransformStack(iFrame, joint); // need to look at inheritsTransform MFnDagNode dagNode(iDag); MPlug inheritPlug = dagNode.findPlug("inheritsTransform"); if (!inheritPlug.isNull()) { if (util::getSampledType(inheritPlug) != 0) mInheritsPlug = inheritPlug; mSample.setInheritsXforms(inheritPlug.asBool()); } // everything is default, don't write anything if (mSample.getNumOps() == 0 && mSample.getInheritsXforms()) return; mSchema.set(mSample); return; } } else { MFnTransform trans(iDag); Alembic::AbcGeom::OXform obj(iParent, trans.name().asChar(), iTimeIndex); mSchema = obj.getSchema(); Alembic::Abc::OCompoundProperty cp = obj.getProperties(); mAttrs = AttributesWriterPtr(new AttributesWriter(iFrame, cp, trans, iTimeIndex, iWriteVisibility)); if (!iAddWorld) { pushTransformStack(iFrame, trans); // need to look at inheritsTransform MFnDagNode dagNode(iDag); MPlug inheritPlug = dagNode.findPlug("inheritsTransform"); if (!inheritPlug.isNull()) { if (util::getSampledType(inheritPlug) != 0) mInheritsPlug = inheritPlug; mSample.setInheritsXforms(inheritPlug.asBool()); } // everything is default, don't write anything if (mSample.getNumOps() == 0 && mSample.getInheritsXforms()) return; mSchema.set(mSample); return; } } // if we didn't bail early then we need to add all the transform // information at the current node and above // copy the dag path because we'll be popping from it MDagPath dag(iDag); int i; int numPaths = dag.length(); std::vector< MDagPath > dagList; for (i = numPaths - 1; i > -1; i--, dag.pop()) { dagList.push_back(dag); // inheritsTransform exists on both joints and transforms MFnDagNode dagNode(dag); MPlug inheritPlug = dagNode.findPlug("inheritsTransform"); // if inheritsTransform exists and is set to false, then we // don't need to worry about ancestor nodes above this one if (!inheritPlug.isNull() && !inheritPlug.asBool()) break; } std::vector< MDagPath >::iterator iStart = dagList.begin(); std::vector< MDagPath >::iterator iCur = dagList.end(); iCur--; // now loop backwards over our dagpath list so we push ancestor nodes // first, all the way down to the current node for (; iCur != iStart; iCur--) { // only add it to the stack don't write it yet! if (iCur->hasFn(MFn::kJoint)) { MFnIkJoint joint(*iCur); pushTransformStack(iFrame, joint); } else { MFnTransform trans(*iCur); pushTransformStack(iFrame, trans); } } // finally add any transform info on the final node and write it if (iCur->hasFn(MFn::kJoint)) { MFnIkJoint joint(*iCur); pushTransformStack(iFrame, joint); } else { MFnTransform trans(*iCur); pushTransformStack(iFrame, trans); } // need to look at inheritsTransform MFnDagNode dagNode(iDag); MPlug inheritPlug = dagNode.findPlug("inheritsTransform"); if (!inheritPlug.isNull()) { if (util::getSampledType(inheritPlug) != 0) mInheritsPlug = inheritPlug; mSample.setInheritsXforms(inheritPlug.asBool()); } // everything is default, don't write anything if (mSample.getNumOps() == 0 && mSample.getInheritsXforms()) return; mSchema.set(mSample); }
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()); } } } }
// Populate the AnimationChannel vector with various ops based on the Maya // transformation logic If scale and/or rotate pivot are declared, create // inverse ops in the appropriate order void MayaTransformWriter::pushTransformStack( const MFnTransform& iTrans, const UsdGeomXformable& usdXformable, bool writeAnim) { // NOTE: I think this logic and the logic in MayaTransformReader // should be merged so the concept of "CommonAPI" stays centralized. // // By default we assume that the xform conforms to the common API // (xlate,pivot,rotate,scale,pivotINVERTED) As soon as we encounter any // additional xform (compensation translates for pivots, rotateAxis or // shear) we are not conforming anymore bool conformsToCommonAPI = true; // Keep track of where we have rotate and scale Pivots and their inverse so // that we can combine them later if possible unsigned int rotPivotIdx = -1, rotPivotINVIdx = -1, scalePivotIdx = -1, scalePivotINVIdx = -1; // Check if the Maya prim inheritTransform MPlug inheritPlug = iTrans.findPlug("inheritsTransform"); if (!inheritPlug.isNull()) { if(!inheritPlug.asBool()) { usdXformable.SetResetXformStack(true); } } // inspect the translate, no suffix to be closer compatibility with common API _GatherAnimChannel(TRANSLATE, iTrans, "translate", "X", "Y", "Z", &mAnimChanList, writeAnim, false); // inspect the rotate pivot translate if (_GatherAnimChannel(TRANSLATE, iTrans, "rotatePivotTranslate", "X", "Y", "Z", &mAnimChanList, writeAnim, true)) { conformsToCommonAPI = false; } // inspect the rotate pivot bool hasRotatePivot = _GatherAnimChannel(TRANSLATE, iTrans, "rotatePivot", "X", "Y", "Z", &mAnimChanList, writeAnim, true); if (hasRotatePivot) { rotPivotIdx = mAnimChanList.size()-1; } // inspect the rotate, no suffix to be closer compatibility with common API _GatherAnimChannel(ROTATE, iTrans, "rotate", "X", "Y", "Z", &mAnimChanList, writeAnim, false); // inspect the rotateAxis/orientation if (_GatherAnimChannel(ROTATE, iTrans, "rotateAxis", "X", "Y", "Z", &mAnimChanList, writeAnim, true)) { conformsToCommonAPI = false; } // invert the rotate pivot if (hasRotatePivot) { AnimChannel chan; chan.usdOpType = UsdGeomXformOp::TypeTranslate; chan.precision = UsdGeomXformOp::PrecisionFloat; chan.opName = "rotatePivot"; chan.isInverse = true; mAnimChanList.push_back(chan); rotPivotINVIdx = mAnimChanList.size()-1; } // inspect the scale pivot translation if (_GatherAnimChannel(TRANSLATE, iTrans, "scalePivotTranslate", "X", "Y", "Z", &mAnimChanList, writeAnim, true)) { conformsToCommonAPI = false; } // inspect the scale pivot point bool hasScalePivot = _GatherAnimChannel(TRANSLATE, iTrans, "scalePivot", "X", "Y", "Z", &mAnimChanList, writeAnim, true); if (hasScalePivot) { scalePivotIdx = mAnimChanList.size()-1; } // inspect the shear. Even if we have one xform on the xform list, it represents a share so we should name it if (_GatherAnimChannel(SHEAR, iTrans, "shear", "XY", "XZ", "YZ", &mAnimChanList, writeAnim, true)) { conformsToCommonAPI = false; } // add the scale. no suffix to be closer compatibility with common API _GatherAnimChannel(SCALE, iTrans, "scale", "X", "Y", "Z", &mAnimChanList, writeAnim, false); // inverse the scale pivot point if (hasScalePivot) { AnimChannel chan; chan.usdOpType = UsdGeomXformOp::TypeTranslate; chan.precision = UsdGeomXformOp::PrecisionFloat; chan.opName = "scalePivot"; chan.isInverse = true; mAnimChanList.push_back(chan); scalePivotINVIdx = mAnimChanList.size()-1; } // If still potential common API, check if the pivots are the same and NOT animated/connected if (hasRotatePivot != hasScalePivot) { conformsToCommonAPI = false; } if (conformsToCommonAPI && hasRotatePivot && hasScalePivot) { AnimChannel rotPivChan, scalePivChan; rotPivChan = mAnimChanList[rotPivotIdx]; scalePivChan = mAnimChanList[scalePivotIdx]; // If they have different sampleType or are ANIMATED, does not conformsToCommonAPI anymore for (unsigned int i = 0;i<3;i++) { if (rotPivChan.sampleType[i] != scalePivChan.sampleType[i] || rotPivChan.sampleType[i] == ANIMATED) { conformsToCommonAPI = false; } } // If The defaultValue is not the same, does not conformsToCommonAPI anymore if (!GfIsClose(rotPivChan.defValue, scalePivChan.defValue, 1e-9)) { conformsToCommonAPI = false; } // If opType, usdType or precision are not the same, does not conformsToCommonAPI anymore if (rotPivChan.opType != scalePivChan.opType || rotPivChan.usdOpType != scalePivChan.usdOpType || rotPivChan.precision != scalePivChan.precision) { conformsToCommonAPI = false; } if (conformsToCommonAPI) { // To Merge, we first rename rotatePivot and the scalePivot inverse // to pivot. Then we remove the scalePivot and the inverse of the // rotatePivot. // // This means that pivot and its inverse will wrap rotate and scale // since no other ops have been found // // NOTE: scalePivotIdx > rotPivotINVIdx mAnimChanList[rotPivotIdx].opName = "pivot"; mAnimChanList[scalePivotINVIdx].opName = "pivot"; mAnimChanList.erase(mAnimChanList.begin()+scalePivotIdx); mAnimChanList.erase(mAnimChanList.begin()+rotPivotINVIdx); } } // Loop over anim channel vector and create corresponding XFormOps // including the inverse ones if needed TF_FOR_ALL(iter, mAnimChanList) { AnimChannel& animChan = *iter; animChan.op = usdXformable.AddXformOp( animChan.usdOpType, animChan.precision, TfToken(animChan.opName), animChan.isInverse); }
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); }
// returns 0 if static, 1 if sampled, and 2 if a curve int util::getSampledType(const MPlug& iPlug) { MPlugArray conns; iPlug.connectedTo(conns, true, false); // it's possible that only some element of an array plug or // some component of a compound plus is connected if (conns.length() == 0) { if (iPlug.isArray()) { unsigned int numConnectedElements = iPlug.numConnectedElements(); for (unsigned int e = 0; e < numConnectedElements; e++) { int retVal = getSampledType(iPlug.connectionByPhysicalIndex(e)); if (retVal > 0) return retVal; } } else if (iPlug.isCompound() && iPlug.numConnectedChildren() > 0) { unsigned int numChildren = iPlug.numChildren(); for (unsigned int c = 0; c < numChildren; c++) { int retVal = getSampledType(iPlug.child(c)); if (retVal > 0) return retVal; } } return 0; } MObject ob; MFnDependencyNode nodeFn; for (unsigned i = 0; i < conns.length(); i++) { ob = conns[i].node(); MFn::Type type = ob.apiType(); switch (type) { case MFn::kAnimCurveTimeToAngular: case MFn::kAnimCurveTimeToDistance: case MFn::kAnimCurveTimeToTime: case MFn::kAnimCurveTimeToUnitless: { nodeFn.setObject(ob); MPlug incoming = nodeFn.findPlug("i", true); // sampled if (incoming.isConnected()) return 1; // curve else return 2; } break; case MFn::kMute: { nodeFn.setObject(ob); MPlug mutePlug = nodeFn.findPlug("mute", true); // static if (mutePlug.asBool()) return 0; // curve else return 2; } break; default: break; } } return 1; }
virtual void ExportProcedural( AtNode *node ) { // do basic node export ExportMatrix( node, 0 ); AtNode *shader = arnoldShader(); if( shader ) { AiNodeSetPtr( node, "shader", shader ); } 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() ); } // export any shading groups or displacement shaders which look like they // may be connected to procedural parameters. this ensures that maya shaders // the procedural will expect to find at rendertime will be exported to the // ass file (they otherwise might not be if they're not assigned to any objects). exportShadingInputs(); // now set the procedural-specific parameters MFnDagNode fnDagNode( m_dagPath ); MBoundingBox bound = fnDagNode.boundingBox(); AiNodeSetPnt( node, "min", bound.min().x, bound.min().y, bound.min().z ); AiNodeSetPnt( node, "max", bound.max().x, bound.max().y, bound.max().z ); const char *dsoPath = getenv( "IECOREARNOLD_PROCEDURAL_PATH" ); AiNodeSetStr( node, "dso", dsoPath ? dsoPath : "ieProcedural.so" ); AiNodeDeclare( node, "className", "constant STRING" ); AiNodeDeclare( node, "classVersion", "constant INT" ); AiNodeDeclare( node, "parameterValues", "constant ARRAY STRING" ); // cast should be ok as we're registered to only work on procedural holders IECoreMaya::ProceduralHolder *pHolder = static_cast<IECoreMaya::ProceduralHolder *>( fnDagNode.userNode() ); std::string className; int classVersion; IECore::ParameterisedProceduralPtr procedural = pHolder->getProcedural( &className, &classVersion ); AiNodeSetStr( node, "className", className.c_str() ); AiNodeSetInt( node, "classVersion", classVersion ); IECorePython::ScopedGILLock gilLock; try { boost::python::object parser = IECoreMaya::PythonCmd::globalContext()["IECore"].attr( "ParameterParser" )(); boost::python::object serialised = parser.attr( "serialise" )( procedural->parameters() ); size_t numStrings = IECorePython::len( serialised ); AtArray *stringArray = AiArrayAllocate( numStrings, 1, AI_TYPE_STRING ); for( size_t i=0; i<numStrings; i++ ) { std::string s = boost::python::extract<std::string>( serialised[i] ); // hack to workaround ass parsing errors /// \todo Remove when we get the Arnold version that fixes this for( size_t c = 0; c<s.size(); c++ ) { if( s[c] == '#' ) { s[c] = '@'; } } AiArraySetStr( stringArray, i, s.c_str() ); } AiNodeSetArray( node, "parameterValues", stringArray ); } catch( boost::python::error_already_set ) { PyErr_Print(); } }
void MayaTransformWriter::pushTransformStack(const MFnIkJoint & iJoint, bool iForceStatic) { // check joints that are driven by Maya FBIK // Maya FBIK has no connection to joints' TRS plugs // but TRS of joints are driven by FBIK, they are not static // Maya 2012's new HumanIK has connections to joints. // FBIK is a special case. bool forceAnimated = false; MStatus status = MS::kSuccess; if (iJoint.hikJointName(&status).length() > 0 && status) { forceAnimated = true; } // inspect the translate addTranslate(iJoint, "translate", "translateX", "translateY", "translateZ", Alembic::AbcGeom::kTranslateHint, false, iForceStatic, forceAnimated, mSample, mAnimChanList); // inspect the inverseParent scale // [IS] is ignored when Segment Scale Compensate is false MPlug scaleCompensatePlug = iJoint.findPlug("segmentScaleCompensate"); if (scaleCompensatePlug.asBool()) { addScale(iJoint, "inverseScale", "inverseScaleX", "inverseScaleY", "inverseScaleZ", true, iForceStatic, forceAnimated, mSample, mAnimChanList); } MTransformationMatrix::RotationOrder eJointOrientOrder, eRotOrder, eRotateAxisOrder; double vals[3]; // for reordering rotate names MString rotateNames[3]; unsigned int rotOrder[3]; // now look at the joint orientation rotateNames[0] = "jointOrientX"; rotateNames[1] = "jointOrientY"; rotateNames[2] = "jointOrientZ"; iJoint.getOrientation(vals, eJointOrientOrder); if (util::getRotOrder(eJointOrientOrder, rotOrder[0], rotOrder[1], rotOrder[2])) { addRotate(iJoint, "jointOrient", rotateNames, rotOrder, Alembic::AbcGeom::kRotateHint, iForceStatic, true, mSample, mAnimChanList, mJointOrientOpIndex); } rotateNames[0] = "rotateX"; rotateNames[1] = "rotateY"; rotateNames[2] = "rotateZ"; // if this returns false then the rotation order was kInvalid or kLast eRotOrder = iJoint.rotationOrder(); if (util::getRotOrder(eRotOrder, rotOrder[0], rotOrder[1], rotOrder[2])) { addRotate(iJoint, "rotate", rotateNames, rotOrder, Alembic::AbcGeom::kRotateHint, iForceStatic, true, mSample, mAnimChanList, mRotateOpIndex); } // now look at the rotation orientation, aka rotate axis rotateNames[0] = "rotateAxisX"; rotateNames[1] = "rotateAxisY"; rotateNames[2] = "rotateAxisZ"; iJoint.getScaleOrientation(vals, eRotateAxisOrder); if (util::getRotOrder(eRotateAxisOrder, rotOrder[0], rotOrder[1], rotOrder[2])) { addRotate(iJoint, "rotateAxis", rotateNames, rotOrder, Alembic::AbcGeom::kRotateOrientationHint, iForceStatic, true, mSample, mAnimChanList, mRotateAxisOpIndex); } // inspect the scale addScale(iJoint, "scale", "scaleX", "scaleY", "scaleZ", false, iForceStatic, forceAnimated, mSample, mAnimChanList); // remember current rotation if (mFilterEulerRotations) { double xx(0), yy(0), zz(0); // there are 2 rotation order enum definitions: // MEulerRotation::RotationOrder = MTransformationMatrix::RotationOrder-1 if (getSampledRotation( mSample, mJointOrientOpIndex, xx, yy, zz )) { mPrevJointOrientSolution.setValue(xx, yy, zz, (MEulerRotation::RotationOrder)(eJointOrientOrder-1)); } if (getSampledRotation( mSample, mRotateOpIndex, xx, yy, zz )) { mPrevRotateSolution.setValue(xx, yy, zz, (MEulerRotation::RotationOrder)(eRotOrder-1)); } if (getSampledRotation( mSample, mRotateAxisOpIndex, xx, yy, zz )) { mPrevRotateAxisSolution.setValue(xx, yy, zz, (MEulerRotation::RotationOrder)(eRotateAxisOrder-1)); } } }
MayaMeshWriter::MayaMeshWriter(MDagPath & iDag, Alembic::Abc::OObject & iParent, Alembic::Util::uint32_t iTimeIndex, const JobArgs & iArgs, GetMembersMap& gmMap) : mNoNormals(iArgs.noNormals), mWriteUVs(iArgs.writeUVs), mWriteColorSets(iArgs.writeColorSets), mWriteUVSets(iArgs.writeUVSets), mIsGeometryAnimated(false), mDagPath(iDag) { MStatus status = MS::kSuccess; MFnMesh lMesh( mDagPath, &status ); if ( !status ) { MGlobal::displayError( "MFnMesh() failed for MayaMeshWriter" ); } // intermediate objects aren't translated MObject surface = iDag.node(); if (iTimeIndex != 0 && util::isAnimated(surface)) { mIsGeometryAnimated = true; } else { iTimeIndex = 0; } std::vector<float> uvs; std::vector<Alembic::Util::uint32_t> indices; std::string uvSetName; MString name = lMesh.name(); name = util::stripNamespaces(name, iArgs.stripNamespace); // check to see if this poly has been tagged as a SubD MPlug plug = lMesh.findPlug("SubDivisionMesh"); if ( !plug.isNull() && plug.asBool() ) { Alembic::AbcGeom::OSubD obj(iParent, name.asChar(), iTimeIndex); mSubDSchema = obj.getSchema(); Alembic::AbcGeom::OV2fGeomParam::Sample uvSamp; if (mWriteUVs || mWriteUVSets) { getUVs(uvs, indices, uvSetName); if (!uvs.empty()) { if (!uvSetName.empty()) { mSubDSchema.setUVSourceName(uvSetName); } uvSamp.setScope( Alembic::AbcGeom::kFacevaryingScope ); uvSamp.setVals(Alembic::AbcGeom::V2fArraySample( (const Imath::V2f *) &uvs.front(), uvs.size() / 2)); if (!indices.empty()) { uvSamp.setIndices(Alembic::Abc::UInt32ArraySample( &indices.front(), indices.size())); } } } Alembic::Abc::OCompoundProperty cp; Alembic::Abc::OCompoundProperty up; if (AttributesWriter::hasAnyAttr(lMesh, iArgs)) { cp = mSubDSchema.getArbGeomParams(); up = mSubDSchema.getUserProperties(); } mAttrs = AttributesWriterPtr(new AttributesWriter(cp, up, obj, lMesh, iTimeIndex, iArgs)); writeSubD(uvSamp); } else { Alembic::AbcGeom::OPolyMesh obj(iParent, name.asChar(), iTimeIndex); mPolySchema = obj.getSchema(); Alembic::AbcGeom::OV2fGeomParam::Sample uvSamp; if (mWriteUVs || mWriteUVSets) { getUVs(uvs, indices, uvSetName); if (!uvs.empty()) { if (!uvSetName.empty()) { mPolySchema.setUVSourceName(uvSetName); } uvSamp.setScope( Alembic::AbcGeom::kFacevaryingScope ); uvSamp.setVals(Alembic::AbcGeom::V2fArraySample( (const Imath::V2f *) &uvs.front(), uvs.size() / 2)); if (!indices.empty()) { uvSamp.setIndices(Alembic::Abc::UInt32ArraySample( &indices.front(), indices.size())); } } } Alembic::Abc::OCompoundProperty cp; Alembic::Abc::OCompoundProperty up; if (AttributesWriter::hasAnyAttr(lMesh, iArgs)) { cp = mPolySchema.getArbGeomParams(); up = mPolySchema.getUserProperties(); } // set the rest of the props and write to the writer node mAttrs = AttributesWriterPtr(new AttributesWriter(cp, up, obj, lMesh, iTimeIndex, iArgs)); writePoly(uvSamp); } if (mWriteColorSets) { MStringArray colorSetNames; lMesh.getColorSetNames(colorSetNames); if (colorSetNames.length() > 0) { // Create the color sets compound prop Alembic::Abc::OCompoundProperty arbParams; if (mPolySchema.valid()) { arbParams = mPolySchema.getArbGeomParams(); } else { arbParams = mSubDSchema.getArbGeomParams(); } std::string currentColorSet = lMesh.currentColorSetName().asChar(); for (unsigned int i=0; i < colorSetNames.length(); ++i) { // Create an array property for each color set std::string colorSetPropName = colorSetNames[i].asChar(); Alembic::AbcCoreAbstract::MetaData md; if (currentColorSet == colorSetPropName) { md.set("mayaColorSet", "1"); } else { md.set("mayaColorSet", "0"); } if (lMesh.getColorRepresentation(colorSetNames[i]) == MFnMesh::kRGB) { Alembic::AbcGeom::OC3fGeomParam colorProp(arbParams, colorSetPropName, true, Alembic::AbcGeom::kFacevaryingScope, 1, iTimeIndex, md); mRGBParams.push_back(colorProp); } else { Alembic::AbcGeom::OC4fGeomParam colorProp(arbParams, colorSetPropName, true, Alembic::AbcGeom::kFacevaryingScope, 1, iTimeIndex, md); mRGBAParams.push_back(colorProp); } } writeColor(); } } if (mWriteUVSets) { MStringArray uvSetNames; lMesh.getUVSetNames(uvSetNames); unsigned int uvSetNamesLen = uvSetNames.length(); if (uvSetNamesLen > 1) { // Create the uv sets compound prop Alembic::Abc::OCompoundProperty arbParams; if (mPolySchema.valid()) { arbParams = mPolySchema.getArbGeomParams(); } else { arbParams = mSubDSchema.getArbGeomParams(); } MString currentUV = lMesh.currentUVSetName(); for (unsigned int i = 0; i < uvSetNamesLen; ++i) { // Create an array property for each uv set MString uvSetPropName = uvSetNames[i]; // the current UV set gets mapped to the primary UVs if (currentUV == uvSetPropName) { continue; } if (uvSetPropName.length() > 0 && lMesh.numUVs(uvSetPropName) > 0) { mUVparams.push_back(Alembic::AbcGeom::OV2fGeomParam( arbParams, uvSetPropName.asChar(), true, Alembic::AbcGeom::kFacevaryingScope, 1, iTimeIndex)); } } writeUVSets(); } } // write out facesets if(!iArgs.writeFaceSets) return; // get the connected shading engines MObjectArray connSGObjs (getOutConnectedSG(mDagPath)); const unsigned int sgCount = connSGObjs.length(); for (unsigned int i = 0; i < sgCount; ++i) { MObject connSGObj, compObj; connSGObj = connSGObjs[i]; MFnDependencyNode fnDepNode(connSGObj); MString connSgObjName = fnDepNode.name(); // retrive the component MObject status = getSetComponents(mDagPath, connSGObj, gmMap, compObj); if (status != MS::kSuccess) { // for some reason the shading group doesn't represent a face set continue; } // retrieve the face indices MIntArray indices; MFnSingleIndexedComponent compFn; compFn.setObject(compObj); compFn.getElements(indices); const unsigned int numData = indices.length(); // encountered the whole object mapping. skip it. if (numData == 0) continue; std::vector<Alembic::Util::int32_t> faceIndices(numData); for (unsigned int j = 0; j < numData; ++j) { faceIndices[j] = indices[j]; } connSgObjName = util::stripNamespaces(connSgObjName, iArgs.stripNamespace); Alembic::AbcGeom::OFaceSet faceSet; std::string faceSetName(connSgObjName.asChar()); MPlug abcFacesetNamePlug = fnDepNode.findPlug("AbcFacesetName", true); if (!abcFacesetNamePlug.isNull()) { faceSetName = abcFacesetNamePlug.asString().asChar(); } if (mPolySchema.valid()) { if (mPolySchema.hasFaceSet(faceSetName)) { faceSet = mPolySchema.getFaceSet(faceSetName); } else { faceSet = mPolySchema.createFaceSet(faceSetName); } } else { if (mSubDSchema.hasFaceSet(faceSetName)) { faceSet = mSubDSchema.getFaceSet(faceSetName); } else { faceSet = mSubDSchema.createFaceSet(faceSetName); } } Alembic::AbcGeom::OFaceSetSchema::Sample samp; samp.setFaces(Alembic::Abc::Int32ArraySample(faceIndices)); Alembic::AbcGeom::OFaceSetSchema faceSetSchema = faceSet.getSchema(); faceSetSchema.set(samp); faceSetSchema.setFaceExclusivity(Alembic::AbcGeom::kFaceSetExclusive); MFnDependencyNode iNode(connSGObj); Alembic::Abc::OCompoundProperty cp; Alembic::Abc::OCompoundProperty up; if (AttributesWriter::hasAnyAttr(iNode, iArgs)) { cp = faceSetSchema.getArbGeomParams(); up = faceSetSchema.getUserProperties(); } AttributesWriter attrWriter(cp, up, faceSet, iNode, iTimeIndex, iArgs); attrWriter.write(); } }
MayaTransformWriter::MayaTransformWriter(MayaTransformWriter & iParent, MDagPath & iDag, Alembic::Util::uint32_t iTimeIndex, const JobArgs & iArgs) { mVerbose = iArgs.verbose; mFilterEulerRotations = iArgs.filterEulerRotations; mJointOrientOpIndex[0] = mJointOrientOpIndex[1] = mJointOrientOpIndex[2] = mRotateOpIndex[0] = mRotateOpIndex[1] = mRotateOpIndex[2] = mRotateAxisOpIndex[0] = mRotateAxisOpIndex[1] = mRotateAxisOpIndex[2] = ~size_t(0); if (iDag.hasFn(MFn::kJoint)) { MFnIkJoint joint(iDag); MString jointName = joint.name(); mName = util::stripNamespaces(jointName, iArgs.stripNamespace); Alembic::AbcGeom::OXform obj(iParent.getObject(), mName.asChar(), iTimeIndex); mSchema = obj.getSchema(); Alembic::Abc::OCompoundProperty cp; Alembic::Abc::OCompoundProperty up; if (AttributesWriter::hasAnyAttr(joint, iArgs)) { cp = mSchema.getArbGeomParams(); up = mSchema.getUserProperties(); } mAttrs = AttributesWriterPtr(new AttributesWriter(cp, up, obj, joint, iTimeIndex, iArgs)); pushTransformStack(joint, iTimeIndex == 0); } else { MFnTransform trans(iDag); MString transName = trans.name(); mName = util::stripNamespaces(transName, iArgs.stripNamespace); Alembic::AbcGeom::OXform obj(iParent.getObject(), mName.asChar(), iTimeIndex); mSchema = obj.getSchema(); Alembic::Abc::OCompoundProperty cp; Alembic::Abc::OCompoundProperty up; if (AttributesWriter::hasAnyAttr(trans, iArgs)) { cp = mSchema.getArbGeomParams(); up = mSchema.getUserProperties(); } mAttrs = AttributesWriterPtr(new AttributesWriter(cp, up, obj, trans, iTimeIndex, iArgs)); pushTransformStack(trans, iTimeIndex == 0); } // need to look at inheritsTransform MFnDagNode dagNode(iDag); MPlug inheritPlug = dagNode.findPlug("inheritsTransform"); if (!inheritPlug.isNull()) { if (util::getSampledType(inheritPlug) != 0) mInheritsPlug = inheritPlug; mSample.setInheritsXforms(inheritPlug.asBool()); } // everything is default, don't write anything if (mSample.getNumOps() == 0 && mSample.getInheritsXforms()) return; mSchema.set(mSample); }
void MayaMeshWriter::getPolyNormals(std::vector<float> & oNormals) { MStatus status = MS::kSuccess; MFnMesh lMesh( mDagPath, &status ); if ( !status ) { MGlobal::displayError( "MFnMesh() failed for MayaMeshWriter" ); } // no normals bail early if (mNoNormals) { return; } MPlug plug = lMesh.findPlug("noNormals", true, &status); if (status == MS::kSuccess && plug.asBool() == true) { return; } // we need to check the locked state of the normals else if ( status != MS::kSuccess ) { bool userSetNormals = false; // go through all per face-vertex normals and verify if any of them // has been tweaked by users unsigned int numFaces = lMesh.numPolygons(); for (unsigned int faceIndex = 0; faceIndex < numFaces; faceIndex++) { MIntArray normals; lMesh.getFaceNormalIds(faceIndex, normals); unsigned int numNormals = normals.length(); for (unsigned int n = 0; n < numNormals; n++) { if (lMesh.isNormalLocked(normals[n])) { userSetNormals = true; break; } } } // we looped over all the normals and they were all calculated by Maya // so we just need to check to see if any of the edges are hard // before we decide not to write the normals. if (!userSetNormals) { bool hasHardEdges = false; // go through all edges and verify if any of them is hard edge unsigned int numEdges = lMesh.numEdges(); for (unsigned int edgeIndex = 0; edgeIndex < numEdges; edgeIndex++) { if (!lMesh.isEdgeSmooth(edgeIndex)) { hasHardEdges = true; break; } } // all the edges were smooth, we don't need to write the normals if (!hasHardEdges) { return; } } } bool flipNormals = false; plug = lMesh.findPlug("flipNormals", true, &status); if ( status == MS::kSuccess ) flipNormals = plug.asBool(); // get the per vertex per face normals (aka vertex) unsigned int numFaces = lMesh.numPolygons(); for (unsigned int faceIndex = 0; faceIndex < numFaces; faceIndex++ ) { MIntArray vertexList; lMesh.getPolygonVertices(faceIndex, vertexList); // re-pack the order of normals in this vector before writing into prop // so that Renderman can also use it unsigned int numVertices = vertexList.length(); for ( int v = numVertices-1; v >=0; v-- ) { unsigned int vertexIndex = vertexList[v]; MVector normal; lMesh.getFaceVertexNormal(faceIndex, vertexIndex, normal); if (flipNormals) normal = -normal; oNormals.push_back(static_cast<float>(normal[0])); oNormals.push_back(static_cast<float>(normal[1])); oNormals.push_back(static_cast<float>(normal[2])); } } }
MBoundingBox AbcWriteJob::getBoundingBox(double iFrame, const MMatrix & eMInvMat) { MStatus status; MBoundingBox curBBox; if (iFrame == mFirstFrame) { // Set up bbox shape map in the first frame. // If we have a lot of transforms and shapes, we don't need to // iterate them for each frame. MItDag dagIter; for (dagIter.reset(mCurDag); !dagIter.isDone(); dagIter.next()) { MObject object = dagIter.currentItem(); MDagPath path; dagIter.getPath(path); // short-circuit if the selection flag is on but this node is not in the // active selection // MGlobal::isSelected(ob) doesn't work, because DG node and DAG node is // not the same even if they refer to the same MObject if (mArgs.useSelectionList && !mSList.hasItem(path)) { dagIter.prune(); continue; } MFnDagNode dagNode(path, &status); if (status == MS::kSuccess) { // check for riCurves flag for flattening all curve object to // one curve group MPlug riCurvesPlug = dagNode.findPlug("riCurves", &status); if ( status == MS::kSuccess && riCurvesPlug.asBool() == true) { MBoundingBox box = dagNode.boundingBox(); box.transformUsing(path.exclusiveMatrix()*eMInvMat); curBBox.expand(box); // Prune this curve group dagIter.prune(); // Save children paths std::map< MDagPath, util::ShapeSet, util::cmpDag >::iterator iter = mBBoxShapeMap.insert(std::make_pair(mCurDag, util::ShapeSet())).first; if (iter != mBBoxShapeMap.end()) (*iter).second.insert(path); } else if (object.hasFn(MFn::kParticle) || object.hasFn(MFn::kMesh) || object.hasFn(MFn::kNurbsCurve) || object.hasFn(MFn::kNurbsSurface) ) { if (util::isIntermediate(object)) continue; MBoundingBox box = dagNode.boundingBox(); box.transformUsing(path.exclusiveMatrix()*eMInvMat); curBBox.expand(box); // Save children paths std::map< MDagPath, util::ShapeSet, util::cmpDag >::iterator iter = mBBoxShapeMap.insert(std::make_pair(mCurDag, util::ShapeSet())).first; if (iter != mBBoxShapeMap.end()) (*iter).second.insert(path); } } } } else { // We have already find out all the shapes for the dag path. std::map< MDagPath, util::ShapeSet, util::cmpDag >::iterator iter = mBBoxShapeMap.find(mCurDag); if (iter != mBBoxShapeMap.end()) { // Iterate through the saved paths to calculate the box. util::ShapeSet& paths = (*iter).second; for (util::ShapeSet::iterator pathIter = paths.begin(); pathIter != paths.end(); pathIter++) { MFnDagNode dagNode(*pathIter, &status); if (status == MS::kSuccess) { MBoundingBox box = dagNode.boundingBox(); box.transformUsing((*pathIter).exclusiveMatrix()*eMInvMat); curBBox.expand(box); } } } } return curBBox; }
void AbcWriteJob::setup(double iFrame, MayaTransformWriterPtr iParent, GetMembersMap& gmMap) { MStatus status; // short-circuit if selection flag is on but this node isn't actively // selected if (mArgs.useSelectionList && !mSList.hasItem(mCurDag)) return; MObject ob = mCurDag.node(); // skip all intermediate nodes (and their children) if (util::isIntermediate(ob)) { return; } // skip nodes that aren't renderable (and their children) if (mArgs.excludeInvisible && !util::isRenderable(ob)) { return; } // look for riCurves flag for flattening all curve objects to a curve group MFnDependencyNode fnDepNode(ob, &status); MPlug riCurvesPlug = fnDepNode.findPlug("riCurves", &status); bool riCurvesVal = riCurvesPlug.asBool(); bool writeOutAsGroup = false; if (riCurvesVal) { writeOutAsGroup = checkCurveGrp(); if (writeOutAsGroup == false) { MString msg = "Curves have different degrees or close "; msg += "states, not writing out as curve group"; MGlobal::displayWarning(msg); } } if ( status == MS::kSuccess && riCurvesVal && writeOutAsGroup) { MayaNurbsCurveWriterPtr nurbsCurve; if (iParent == NULL) { Alembic::Abc::OObject obj = mRoot.getTop(); nurbsCurve = MayaNurbsCurveWriterPtr(new MayaNurbsCurveWriter( mCurDag, obj, mShapeTimeIndex, true, mArgs)); } else { Alembic::Abc::OObject obj = iParent->getObject(); nurbsCurve = MayaNurbsCurveWriterPtr(new MayaNurbsCurveWriter( mCurDag, obj, mShapeTimeIndex, true, mArgs)); } if (nurbsCurve->isAnimated() && mShapeTimeIndex != 0) { mCurveList.push_back(nurbsCurve); mStats.mCurveAnimNum++; mStats.mCurveAnimCurves += nurbsCurve->getNumCurves(); mStats.mCurveAnimCVs += nurbsCurve->getNumCVs(); } else { mStats.mCurveStaticNum++; mStats.mCurveStaticCurves += nurbsCurve->getNumCurves(); mStats.mCurveStaticCVs += nurbsCurve->getNumCVs(); } AttributesWriterPtr attrs = nurbsCurve->getAttrs(); if (mShapeTimeIndex != 0 && attrs->isAnimated()) mShapeAttrList.push_back(attrs); } else if (ob.hasFn(MFn::kTransform)) { MFnTransform fnTrans(ob, &status); if (status != MS::kSuccess) { MString msg = "Initialize transform node "; msg += mCurDag.fullPathName(); msg += " failed, skipping."; MGlobal::displayWarning(msg); return; } MayaTransformWriterPtr trans; // parented to the root case if (iParent == NULL) { Alembic::Abc::OObject obj = mRoot.getTop(); trans = MayaTransformWriterPtr(new MayaTransformWriter( obj, mCurDag, mTransTimeIndex, mArgs)); } else { trans = MayaTransformWriterPtr(new MayaTransformWriter( *iParent, mCurDag, mTransTimeIndex, mArgs)); } if (trans->isAnimated() && mTransTimeIndex != 0) { mTransList.push_back(trans); mStats.mTransAnimNum++; } else mStats.mTransStaticNum++; AttributesWriterPtr attrs = trans->getAttrs(); if (mTransTimeIndex != 0 && attrs->isAnimated()) mTransAttrList.push_back(attrs); // loop through the children, making sure to push and pop them // from the MDagPath unsigned int numChild = mCurDag.childCount(); for (unsigned int i = 0; i < numChild; ++i) { if (mCurDag.push(mCurDag.child(i)) == MS::kSuccess) { setup(iFrame, trans, gmMap); mCurDag.pop(); } } } else if (ob.hasFn(MFn::kLocator)) { MFnDependencyNode fnLocator(ob, & status); if (status != MS::kSuccess) { MString msg = "Initialize locator node "; msg += mCurDag.fullPathName(); msg += " failed, skipping."; MGlobal::displayWarning(msg); return; } if (iParent != NULL) { Alembic::Abc::OObject obj = iParent->getObject(); MayaLocatorWriterPtr locator(new MayaLocatorWriter( mCurDag, obj, mShapeTimeIndex, mArgs)); if (locator->isAnimated() && mShapeTimeIndex != 0) { mLocatorList.push_back(locator); mStats.mLocatorAnimNum++; } else { mStats.mLocatorStaticNum++; } AttributesWriterPtr attrs = locator->getAttrs(); if (mShapeTimeIndex != 0 && attrs->isAnimated()) mShapeAttrList.push_back(attrs); } else { MString err = "Can't translate "; err += fnLocator.name() + " since it doesn't have a parent."; MGlobal::displayError(err); } } else if (ob.hasFn(MFn::kParticle)) { MFnParticleSystem mFnParticle(ob, &status); if (status != MS::kSuccess) { MString msg = "Initialize particle system "; msg += mCurDag.fullPathName(); msg += " failed, skipping."; MGlobal::displayWarning(msg); return; } if (iParent != NULL) { Alembic::Abc::OObject obj = iParent->getObject(); MayaPointPrimitiveWriterPtr particle(new MayaPointPrimitiveWriter( iFrame, mCurDag, obj, mShapeTimeIndex, mArgs)); if (particle->isAnimated() && mShapeTimeIndex != 0) { mPointList.push_back(particle); mStats.mPointAnimNum++; mStats.mPointAnimCVs += particle->getNumCVs(); } else { mStats.mPointStaticNum++; mStats.mPointStaticCVs += particle->getNumCVs(); } AttributesWriterPtr attrs = particle->getAttrs(); if (mShapeTimeIndex != 0 && attrs->isAnimated()) mShapeAttrList.push_back(attrs); } else { MString err = "Can't translate "; err += mFnParticle.name() + " since it doesn't have a parent."; MGlobal::displayError(err); } } else if (ob.hasFn(MFn::kMesh)) { MFnMesh fnMesh(ob, &status); if (status != MS::kSuccess) { MString msg = "Initialize mesh node "; msg += mCurDag.fullPathName(); msg += " failed, skipping."; MGlobal::displayWarning(msg); return; } if (iParent != NULL) { Alembic::Abc::OObject obj = iParent->getObject(); MayaMeshWriterPtr mesh(new MayaMeshWriter(mCurDag, obj, mShapeTimeIndex, mArgs, gmMap)); if (mesh->isAnimated() && mShapeTimeIndex != 0) { mMeshList.push_back(mesh); if (mesh->isSubD()) { mStats.mSubDAnimNum++; mStats.mSubDAnimCVs += mesh->getNumCVs(); mStats.mSubDAnimFaces += mesh->getNumFaces(); } else { mStats.mPolyAnimNum++; mStats.mPolyAnimCVs += mesh->getNumCVs(); mStats.mPolyAnimFaces += mesh->getNumFaces(); } } else { if (mesh->isSubD()) { mStats.mSubDStaticNum++; mStats.mSubDStaticCVs += mesh->getNumCVs(); mStats.mSubDStaticFaces += mesh->getNumFaces(); } else { mStats.mPolyStaticNum++; mStats.mPolyStaticCVs += mesh->getNumCVs(); mStats.mPolyStaticFaces += mesh->getNumFaces(); } } AttributesWriterPtr attrs = mesh->getAttrs(); if (mShapeTimeIndex != 0 && attrs->isAnimated()) mShapeAttrList.push_back(attrs); } else { MString err = "Can't translate "; err += fnMesh.name() + " since it doesn't have a parent."; MGlobal::displayError(err); } } else if (ob.hasFn(MFn::kCamera)) { MFnCamera fnCamera(ob, &status); if (status != MS::kSuccess) { MString msg = "Initialize camera node "; msg += mCurDag.fullPathName(); msg += " failed, skipping."; MGlobal::displayWarning(msg); return; } if (iParent != NULL) { Alembic::Abc::OObject obj = iParent->getObject(); MayaCameraWriterPtr camera(new MayaCameraWriter( mCurDag, obj, mShapeTimeIndex, mArgs)); if (camera->isAnimated() && mShapeTimeIndex != 0) { mCameraList.push_back(camera); mStats.mCameraAnimNum++; } else mStats.mCameraStaticNum++; AttributesWriterPtr attrs = camera->getAttrs(); if (mShapeTimeIndex != 0 && attrs->isAnimated()) mShapeAttrList.push_back(attrs); } else { MString err = "Can't translate "; err += fnCamera.name() + " since it doesn't have a parent."; MGlobal::displayError(err); } } else if (ob.hasFn(MFn::kNurbsSurface)) { MFnNurbsSurface fnNurbsSurface(ob, &status); if (status != MS::kSuccess) { MString msg = "Initialize nurbs surface "; msg += mCurDag.fullPathName(); msg += " failed, skipping."; MGlobal::displayWarning(msg); return; } if (iParent != NULL) { Alembic::Abc::OObject obj = iParent->getObject(); MayaNurbsSurfaceWriterPtr nurbsSurface(new MayaNurbsSurfaceWriter( mCurDag, obj, mShapeTimeIndex, mArgs)); if (nurbsSurface->isAnimated() && mShapeTimeIndex != 0) { mNurbsList.push_back(nurbsSurface); mStats.mNurbsAnimNum++; mStats.mNurbsAnimCVs += nurbsSurface->getNumCVs(); } else { mStats.mNurbsStaticNum++; mStats.mNurbsStaticCVs += nurbsSurface->getNumCVs(); } AttributesWriterPtr attrs = nurbsSurface->getAttrs(); if (mShapeTimeIndex != 0 && attrs->isAnimated()) mShapeAttrList.push_back(attrs); } else { MString err = "Can't translate "; err += fnNurbsSurface.name() + " since it doesn't have a parent."; MGlobal::displayError(err); } } else if (ob.hasFn(MFn::kNurbsCurve)) { MFnNurbsCurve fnNurbsCurve(ob, &status); if (status != MS::kSuccess) { MString msg = "Initialize curve node "; msg += mCurDag.fullPathName(); msg += " failed, skipping."; MGlobal::displayWarning(msg); return; } if (iParent != NULL) { Alembic::Abc::OObject obj = iParent->getObject(); MayaNurbsCurveWriterPtr nurbsCurve(new MayaNurbsCurveWriter( mCurDag, obj, mShapeTimeIndex, false, mArgs)); if (nurbsCurve->isAnimated() && mShapeTimeIndex != 0) { mCurveList.push_back(nurbsCurve); mStats.mCurveAnimNum++; mStats.mCurveAnimCurves++; mStats.mCurveAnimCVs += nurbsCurve->getNumCVs(); } else { mStats.mCurveStaticNum++; mStats.mCurveStaticCurves++; mStats.mCurveStaticCVs += nurbsCurve->getNumCVs(); } AttributesWriterPtr attrs = nurbsCurve->getAttrs(); if (mShapeTimeIndex != 0 && attrs->isAnimated()) mShapeAttrList.push_back(attrs); } else { MString err = "Can't translate "; err += fnNurbsCurve.name() + " since it doesn't have a parent."; MGlobal::displayError(err); } } else { MString warn = mCurDag.fullPathName() + " is an unsupported type of "; warn += ob.apiTypeStr(); MGlobal::displayWarning(warn); } }
ConstObjectPtr LiveScene::readAttribute( const Name &name, double time ) const { if ( !m_isRoot && m_dagPath.length() == 0 ) { throw Exception( "IECoreMaya::LiveScene::readAttribute: Dag path no longer exists!" ); } tbb::mutex::scoped_lock l( s_mutex ); if ( !m_isRoot ) { if( name == SceneInterface::visibilityName ) { bool visible = true; MStatus st; MFnDagNode dagFn( m_dagPath ); MPlug visibilityPlug = dagFn.findPlug( MPxTransform::visibility, &st ); if( st ) { visible = visibilityPlug.asBool(); } if( visible ) { MDagPath childDag; // find an object that's either a SceneShape, or has a cortex converter and check its visibility: unsigned int childCount = 0; m_dagPath.numberOfShapesDirectlyBelow(childCount); for ( unsigned int c = 0; c < childCount; c++ ) { MDagPath d = m_dagPath; if( d.extendToShapeDirectlyBelow( c ) ) { MFnDagNode fnChildDag(d); if( fnChildDag.typeId() == SceneShape::id ) { childDag = d; break; } if ( fnChildDag.isIntermediateObject() ) { continue; } FromMayaShapeConverterPtr shapeConverter = FromMayaShapeConverter::create( d ); if( shapeConverter ) { childDag = d; break; } FromMayaDagNodeConverterPtr dagConverter = FromMayaDagNodeConverter::create( d ); if( dagConverter ) { childDag = d; break; } } } if( childDag.isValid() ) { MFnDagNode dagFn( childDag ); MPlug visibilityPlug = dagFn.findPlug( MPxSurfaceShape::visibility, &st ); if( st ) { visible = visibilityPlug.asBool(); } } } return new BoolData( visible ); } } else if( name == SceneInterface::visibilityName ) { return new BoolData( true ); } std::vector< CustomAttributeReader > &attributeReaders = customAttributeReaders(); for ( std::vector< CustomAttributeReader >::const_reverse_iterator it = attributeReaders.rbegin(); it != attributeReaders.rend(); ++it ) { ConstObjectPtr attr = it->m_read( m_dagPath, name ); if( !attr ) { continue; } return attr; } if( strstr( name.c_str(), "user:"******"ieAttr_" + name.string().substr(5) ).c_str(), false, &st ); if( st ) { FromMayaConverterPtr plugConverter = FromMayaPlugConverter::create( attrPlug ); if( !plugConverter ) { return IECore::NullObject::defaultNullObject(); } return plugConverter->convert(); } } return IECore::NullObject::defaultNullObject(); }
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; }