bool getInt2(MString& plugName, MFnDependencyNode& dn, int2& value)
{
MDGContext ctx = MDGContext::fsNormal;
MStatus stat = MS::kSuccess;
bool result = false;
MPlug plug = dn.findPlug(plugName + "0", &stat);
if( !stat )
return false;
value[0] = plug.asInt(ctx, &stat);
plug = dn.findPlug(plugName + "1", &stat);
if( !stat )
return false;
value[1] = plug.asInt(ctx, &stat);
if(stat)
return true;
return result;
}
int getIntAttr(const char *plugName, MFnDependencyNode& dn, int defaultValue)
{
MDGContext ctx = MDGContext::fsNormal;
MStatus stat = MS::kSuccess;
MPlug plug = dn.findPlug(plugName, &stat);
if( !stat )
return defaultValue;
return plug.asInt(ctx, &stat);
}
Corona::SharedPtr<Corona::Abstract::Map> getOslTexMap(MString& attributeName, MFnDependencyNode& depFn, ShadingNetwork& sn)
{
MStatus status;
OSL::OSLShadingNetworkRenderer *oslRenderer;
MayaTo::MayaToWorld::WorldRenderType rType = MayaTo::getWorldPtr()->getRenderType();
if ((rType == MayaTo::MayaToWorld::WorldRenderType::SWATCHRENDER))
{
oslRenderer = (OSL::OSLShadingNetworkRenderer *)MayaTo::getObjPtr("oslSwatchRenderer");
}
else{
oslRenderer = (OSL::OSLShadingNetworkRenderer *)MayaTo::getObjPtr("oslRenderer");
}
size_t numNodes = sn.shaderList.size();
MString OSLInterfaceName = depFn.name() + "_" + attributeName + "_OSLInterface";
MString shaderGroupName = depFn.name() + "_" + attributeName + "_OSLShadingGroup";
OSL::ShaderGroupRef shaderGroup = oslRenderer->shadingsys->ShaderGroupBegin(shaderGroupName.asChar());
MObject thisMObject = depFn.object();
MString outPlugName;
MString connectedObjectName = getObjectName(getOtherSideSourceNode(attributeName, thisMObject, true, outPlugName));
Logging::debug(MString("getOslTexMap: ") + connectedObjectName + "." + outPlugName + " is connected with " + depFn.name() + "." + attributeName);
MPlug shaderPlug = depFn.findPlug(attributeName);
MAYATO_OSL::createOSLProjectionNodes(shaderPlug);
for (int shadingNodeId = 0; shadingNodeId < numNodes; shadingNodeId++)
{
ShadingNode snode = sn.shaderList[shadingNodeId];
Logging::debug(MString("ShadingNode Id: ") + shadingNodeId + " ShadingNode name: " + snode.fullName);
MAYATO_OSL::createOSLHelperNodes(sn.shaderList[shadingNodeId]);
MAYATO_OSL::createOSLShadingNode(sn.shaderList[shadingNodeId]);
MAYATO_OSL::connectProjectionNodes(sn.shaderList[shadingNodeId].mobject);
if (snode.fullName == connectedObjectName.asChar())
{
MAYATO_OSL::createOSLHelperNodes(sn.shaderList[sn.shaderList.size() - 1]);
Logging::debug(MString("connected node found: ") + snode.fullName + " search output attr.");
for (size_t outId = 0; outId < snode.outputAttributes.size(); outId++)
{
ShaderAttribute& sa = snode.outputAttributes[outId];
if (MString(sa.name.c_str()) == outPlugName)
{
Logging::debug(MString("connected out attr found: ") + sa.name.c_str() + " ");
MString destParam;
MString sourceParam = outPlugName;
MString sourceNode = connectedObjectName;
if ((sa.type == "color") || (sa.type == "vector"))
{
// lets see if we have a color helper node
MString helperNodeName = MAYATO_OSL::createPlugHelperNodeName(attributeName.asChar(), thisMObject, false);
Logging::debug(MString("Interface connection - color/vector attribute ") + sa.name.c_str() + " search for helper node " + helperNodeName);
if (MAYATO_OSL::doesOSLNodeAlreadyExist(helperNodeName))
{
Logging::debug(MString("Found helper node name."));
sourceParam = "outputValue";
sourceNode = helperNodeName;
}
destParam = "inVector";
}
if (sa.type == "float")
{
destParam = "inFloat";
}
if (sa.type == "int")
{
destParam = "inInt";
}
if (sa.type == "bool")
{
destParam = "inBool";
}
if (sourceParam == "output")
sourceParam = "outOutput";
// if we have a color/vector input, try to find a multiplier attribute
MString multiplierName = attributeName + "Multiplier";
MPlug multiplierAttribute = depFn.findPlug(multiplierName, true, &status);
if (status)
{
Logging::debug(MString("Found multiplier attribute: ") + multiplierName);
float multiplier = multiplierAttribute.asFloat();
float offset = 0.0f;
if ((attributeName == "refractionIndex") || (attributeName == "reflectionIor"))
{
offset = -1.0f;
}
oslRenderer->shadingsys->Parameter("multiplier", OSL::TypeDesc::TypeFloat, &multiplier);
oslRenderer->shadingsys->Parameter("offset", OSL::TypeDesc::TypeFloat, &offset);
}
Logging::debug(MString("creating OSLInterface shader ") + OSLInterfaceName);
bool success = oslRenderer->shadingsys->Shader("surface", "OSLInterface", OSLInterfaceName.asChar());
Logging::debug(MString("connecting ") + sourceNode + "." + sourceParam + " -> " + OSLInterfaceName + "." + destParam);
success = oslRenderer->shadingsys->ConnectShaders(sourceNode.asChar(), sourceParam.asChar(), OSLInterfaceName.asChar(), destParam.asChar());
break;
}
}
break;
}
}
if (!oslRenderer->shadingsys->ShaderGroupEnd())
{
Logging::debug("Problem finishing shader group");
}
std::string serialized;
oslRenderer->shadingsys->getattribute(shaderGroup.get(), "pickle", serialized);
Logging::debug(MString("Serialized: ") + serialized.c_str());
Corona::SharedPtr<Corona::Abstract::Map> oslMapp = new OSLMap;
OSLMap *oslMap = (OSLMap *)oslMapp.getReference();
oslMap->oslRenderer = oslRenderer;
oslMap->shaderGroup = shaderGroup;
if (depFn.object().hasFn(MFn::kLight))
oslMap->isLightMap = true;
if (attributeName == "normalCamera")
{
oslMap->bumpType = OSLMap::NONE;
// we only support direct bumpmap connections
MPlug ncPlug = depFn.findPlug("normalCamera");
if (ncPlug.isConnected())
{
MPlugArray pa;
ncPlug.connectedTo(pa, true, false);
if (pa.length() > 0)
{
for (uint pId = 0; pId < pa.length(); pId++)
{
if (pa[pId].node().hasFn(MFn::kBump) || pa[pId].node().hasFn(MFn::kBump3d))
{
MFnDependencyNode bumpFn(pa[pId].node());
MPlug interpPlug = bumpFn.findPlug("bumpInterp");
if (interpPlug.asInt() == 0)
oslMap->bumpType = OSLMap::BUMP;
if (interpPlug.asInt() == 1)
oslMap->bumpType = OSLMap::NORMALTANGENT;
if (interpPlug.asInt() == 2)
oslMap->bumpType = OSLMap::NORMALOBJECT;
if (pa[pId].node().hasFn(MFn::kBump3d))
oslMap->bumpType = OSLMap::BUMP3D;
}
}
}
}
}
return oslMapp;
}
void 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());
}
}
}
}
void MayaMeshWriter::writeSubD(
const Alembic::AbcGeom::OV2fGeomParam::Sample & iUVs)
{
MStatus status = MS::kSuccess;
MFnMesh lMesh( mDagPath, &status );
if ( !status )
{
MGlobal::displayError( "MFnMesh() failed for MayaMeshWriter" );
}
std::vector<float> points;
std::vector<Alembic::Util::int32_t> facePoints;
std::vector<Alembic::Util::int32_t> pointCounts;
fillTopology(points, facePoints, pointCounts);
Alembic::AbcGeom::OSubDSchema::Sample samp(
Alembic::AbcGeom::V3fArraySample((const Imath::V3f *)&points.front(),
points.size() / 3),
Alembic::Abc::Int32ArraySample(facePoints),
Alembic::Abc::Int32ArraySample(pointCounts));
samp.setUVs( iUVs );
MPlug plug = lMesh.findPlug("faceVaryingInterpolateBoundary");
if (!plug.isNull())
samp.setFaceVaryingInterpolateBoundary(plug.asInt());
plug = lMesh.findPlug("interpolateBoundary");
if (!plug.isNull())
samp.setInterpolateBoundary(plug.asInt());
plug = lMesh.findPlug("faceVaryingPropagateCorners");
if (!plug.isNull())
samp.setFaceVaryingPropagateCorners(plug.asInt());
std::vector <Alembic::Util::int32_t> creaseIndices;
std::vector <Alembic::Util::int32_t> creaseLengths;
std::vector <float> creaseSharpness;
std::vector <Alembic::Util::int32_t> cornerIndices;
std::vector <float> cornerSharpness;
MUintArray edgeIds;
MDoubleArray creaseData;
if (lMesh.getCreaseEdges(edgeIds, creaseData) == MS::kSuccess)
{
unsigned int numCreases = creaseData.length();
creaseIndices.resize(numCreases * 2);
creaseLengths.resize(numCreases, 2);
creaseSharpness.resize(numCreases);
for (unsigned int i = 0; i < numCreases; ++i)
{
int verts[2];
lMesh.getEdgeVertices(edgeIds[i], verts);
creaseIndices[2 * i] = verts[0];
creaseIndices[2 * i + 1] = verts[1];
creaseSharpness[i] = static_cast<float>(creaseData[i]);
}
samp.setCreaseIndices(Alembic::Abc::Int32ArraySample(creaseIndices));
samp.setCreaseLengths(Alembic::Abc::Int32ArraySample(creaseLengths));
samp.setCreaseSharpnesses(
Alembic::Abc::FloatArraySample(creaseSharpness));
}
MUintArray cornerIds;
MDoubleArray cornerData;
if (lMesh.getCreaseVertices(cornerIds, cornerData) == MS::kSuccess)
{
unsigned int numCorners = cornerIds.length();
cornerIndices.resize(numCorners);
cornerSharpness.resize(numCorners);
for (unsigned int i = 0; i < numCorners; ++i)
{
cornerIndices[i] = cornerIds[i];
cornerSharpness[i] = static_cast<float>(cornerData[i]);
}
samp.setCornerSharpnesses(
Alembic::Abc::FloatArraySample(cornerSharpness));
samp.setCornerIndices(
Alembic::Abc::Int32ArraySample(cornerIndices));
}
#if MAYA_API_VERSION >= 201100
MUintArray holes = lMesh.getInvisibleFaces();
unsigned int numHoles = holes.length();
std::vector <Alembic::Util::int32_t> holeIndices(numHoles);
for (unsigned int i = 0; i < numHoles; ++i)
{
holeIndices[i] = holes[i];
}
if (!holeIndices.empty())
{
samp.setHoles(holeIndices);
}
#endif
mSubDSchema.set(samp);
writeColor();
writeUVSets();
}
IECoreScene::PrimitivePtr FromMayaMeshConverter::doPrimitiveConversion( MFnMesh &fnMesh ) const
{
// get basic topology and create a mesh
int numPolygons = fnMesh.numPolygons();
IntVectorDataPtr verticesPerFaceData = new IntVectorData;
verticesPerFaceData->writable().resize( numPolygons );
vector<int>::iterator verticesPerFaceIt = verticesPerFaceData->writable().begin();
IntVectorDataPtr vertexIds = new IntVectorData;
// We are calling fnMesh.numFaceVertices() twice to work around a known bug in Maya. When accessing
// certain MFnMesh API calls, given a mesh with 6 or more UV sets, which has never been evaluated
// before, the first call returns 0 and kFailure, and the second call works as expected.
// See ToMayaMeshConverterTest.testManyUVConversionsFromPlug for an example of how this might occur.
fnMesh.numFaceVertices();
vertexIds->writable().resize( fnMesh.numFaceVertices() );
vector<int>::iterator vertexIdsIt = vertexIds->writable().begin();
MIntArray vertexCounts, polygonVertices;
fnMesh.getVertices( vertexCounts, polygonVertices );
copy( MArrayIter<MIntArray>::begin( vertexCounts ), MArrayIter<MIntArray>::end( vertexCounts ), verticesPerFaceIt );
copy( MArrayIter<MIntArray>::begin( polygonVertices ), MArrayIter<MIntArray>::end( polygonVertices ), vertexIdsIt );
std::string interpolation = interpolationParameter()->getTypedValue();
if ( interpolation == "default" )
{
MStatus st;
MPlug interpolationPlug = fnMesh.findPlug( "ieMeshInterpolation", &st );
if ( st )
{
#if MAYA_API_VERSION >= 201800
unsigned int interpolationIndex;
{
MDGContextGuard ctxGuard( MDGContext::fsNormal );
interpolationIndex = interpolationPlug.asInt(&st);
}
#else
unsigned int interpolationIndex = interpolationPlug.asInt(MDGContext::fsNormal, &st);
#endif
if ( st )
{
if ( interpolationIndex < interpolationParameter()->getPresets().size() - 1 )
{
// convert interpolation index to the preset value
interpolation = boost::static_pointer_cast< StringData >( interpolationParameter()->getPresets()[interpolationIndex].second )->readable();
}
else
{
interpolation = "linear";
}
}
else
{
interpolation = "linear";
}
}
else
{
interpolation = "linear";
}
}
MeshPrimitivePtr result = new MeshPrimitive( verticesPerFaceData, vertexIds, interpolation );
result->variables["P"] = points();
if( normalsParameter()->getTypedValue() && interpolation=="linear" )
{
result->variables["N"] = normals();
}
MString currentUVSet;
fnMesh.getCurrentUVSetName( currentUVSet );
if( uvParameter()->getTypedValue() && currentUVSet.length() )
{
result->variables["uv"] = uvs( currentUVSet, verticesPerFaceData->readable() );
}
MStringArray uvSets;
fnMesh.getUVSetNames( uvSets );
for( unsigned int i=0; i<uvSets.length(); i++ )
{
if( uvSets[i] == currentUVSet )
{
// we've already converted these UVs above
continue;
}
result->variables[ uvSets[i].asChar() ] = uvs( uvSets[i], verticesPerFaceData->readable() );
}
bool convertColors = colorsParameter()->getTypedValue();
bool convertExtraColors = extraColorsParameter()->getTypedValue();
if ( convertColors || convertExtraColors )
{
MString currentColorSet;
fnMesh.getCurrentColorSetName( currentColorSet );
MStringArray colorSets;
fnMesh.getColorSetNames( colorSets );
for( unsigned int i=0; i<colorSets.length(); i++ )
{
if( convertColors && colorSets[i]==currentColorSet )
{
// Cs is always converted to Color3f
result->variables["Cs"] = colors( currentColorSet, true );
}
if( convertExtraColors )
{
MString sName = colorSets[i] + "_Cs";
// Extra color sets are not converted
result->variables[sName.asChar()] = colors( colorSets[i] );
}
}
}
return result;
}
bool
PxrUsdMayaWriteUtil::SetUsdAttr(
const MPlug& attrPlug,
const UsdAttribute& usdAttr,
const UsdTimeCode& usdTime,
const bool translateMayaDoubleToUsdSinglePrecision)
{
if (!usdAttr || attrPlug.isNull()) {
return false;
}
bool isAnimated = attrPlug.isDestination();
if (usdTime.IsDefault() == isAnimated) {
return true;
}
// We perform a similar set of type-infererence acrobatics here as we do up
// above in GetUsdTypeName(). See the comments there for more detail on a
// few type-related oddities.
MObject attrObj(attrPlug.attribute());
if (attrObj.hasFn(MFn::kEnumAttribute)) {
MFnEnumAttribute enumAttrFn(attrObj);
const short enumIndex = attrPlug.asShort();
const TfToken enumToken(enumAttrFn.fieldName(enumIndex).asChar());
return usdAttr.Set(enumToken, usdTime);
}
MFnNumericData::Type numericDataType;
MFnData::Type typedDataType;
MFnUnitAttribute::Type unitDataType;
_GetMayaAttributeNumericTypedAndUnitDataTypes(attrPlug,
numericDataType,
typedDataType,
unitDataType);
if (attrObj.hasFn(MFn::kMatrixAttribute)) {
typedDataType = MFnData::kMatrix;
}
switch (typedDataType) {
case MFnData::kString: {
MFnStringData stringDataFn(attrPlug.asMObject());
const std::string usdVal(stringDataFn.string().asChar());
return usdAttr.Set(usdVal, usdTime);
break;
}
case MFnData::kMatrix: {
MFnMatrixData matrixDataFn(attrPlug.asMObject());
const GfMatrix4d usdVal(matrixDataFn.matrix().matrix);
return usdAttr.Set(usdVal, usdTime);
break;
}
case MFnData::kStringArray: {
MFnStringArrayData stringArrayDataFn(attrPlug.asMObject());
VtStringArray usdVal(stringArrayDataFn.length());
for (unsigned int i = 0; i < stringArrayDataFn.length(); ++i) {
usdVal[i] = std::string(stringArrayDataFn[i].asChar());
}
return usdAttr.Set(usdVal, usdTime);
break;
}
case MFnData::kDoubleArray: {
MFnDoubleArrayData doubleArrayDataFn(attrPlug.asMObject());
if (translateMayaDoubleToUsdSinglePrecision) {
VtFloatArray usdVal(doubleArrayDataFn.length());
for (unsigned int i = 0; i < doubleArrayDataFn.length(); ++i) {
usdVal[i] = (float)doubleArrayDataFn[i];
}
return usdAttr.Set(usdVal, usdTime);
} else {
VtDoubleArray usdVal(doubleArrayDataFn.length());
for (unsigned int i = 0; i < doubleArrayDataFn.length(); ++i) {
usdVal[i] = doubleArrayDataFn[i];
}
return usdAttr.Set(usdVal, usdTime);
}
break;
}
case MFnData::kFloatArray: {
MFnFloatArrayData floatArrayDataFn(attrPlug.asMObject());
VtFloatArray usdVal(floatArrayDataFn.length());
for (unsigned int i = 0; i < floatArrayDataFn.length(); ++i) {
usdVal[i] = floatArrayDataFn[i];
}
return usdAttr.Set(usdVal, usdTime);
break;
}
case MFnData::kIntArray: {
MFnIntArrayData intArrayDataFn(attrPlug.asMObject());
VtIntArray usdVal(intArrayDataFn.length());
for (unsigned int i = 0; i < intArrayDataFn.length(); ++i) {
usdVal[i] = intArrayDataFn[i];
}
return usdAttr.Set(usdVal, usdTime);
break;
}
case MFnData::kPointArray: {
MFnPointArrayData pointArrayDataFn(attrPlug.asMObject());
if (translateMayaDoubleToUsdSinglePrecision) {
VtVec3fArray usdVal(pointArrayDataFn.length());
for (unsigned int i = 0; i < pointArrayDataFn.length(); ++i) {
MPoint tmpMayaVal = pointArrayDataFn[i];
if (tmpMayaVal.w != 0) {
tmpMayaVal.cartesianize();
}
usdVal[i] = GfVec3f((float)tmpMayaVal[0],
(float)tmpMayaVal[1],
(float)tmpMayaVal[2]);
}
return usdAttr.Set(usdVal, usdTime);
} else {
VtVec3dArray usdVal(pointArrayDataFn.length());
for (unsigned int i = 0; i < pointArrayDataFn.length(); ++i) {
MPoint tmpMayaVal = pointArrayDataFn[i];
if (tmpMayaVal.w != 0) {
tmpMayaVal.cartesianize();
}
usdVal[i] = GfVec3d(tmpMayaVal[0],
tmpMayaVal[1],
tmpMayaVal[2]);
}
return usdAttr.Set(usdVal, usdTime);
}
break;
}
case MFnData::kVectorArray: {
MFnVectorArrayData vectorArrayDataFn(attrPlug.asMObject());
if (translateMayaDoubleToUsdSinglePrecision) {
VtVec3fArray usdVal(vectorArrayDataFn.length());
for (unsigned int i = 0; i < vectorArrayDataFn.length(); ++i) {
MVector tmpMayaVal = vectorArrayDataFn[i];
usdVal[i] = GfVec3f((float)tmpMayaVal[0],
(float)tmpMayaVal[1],
(float)tmpMayaVal[2]);
}
return usdAttr.Set(usdVal, usdTime);
} else {
VtVec3dArray usdVal(vectorArrayDataFn.length());
for (unsigned int i = 0; i < vectorArrayDataFn.length(); ++i) {
MVector tmpMayaVal = vectorArrayDataFn[i];
usdVal[i] = GfVec3d(tmpMayaVal[0],
tmpMayaVal[1],
tmpMayaVal[2]);
}
return usdAttr.Set(usdVal, usdTime);
}
break;
}
default:
break;
}
switch (numericDataType) {
case MFnNumericData::kBoolean: {
const bool usdVal(attrPlug.asBool());
return usdAttr.Set(usdVal, usdTime);
break;
}
case MFnNumericData::kByte:
case MFnNumericData::kChar: {
const int usdVal(attrPlug.asChar());
return usdAttr.Set(usdVal, usdTime);
break;
}
case MFnNumericData::kShort: {
const int usdVal(attrPlug.asShort());
return usdAttr.Set(usdVal, usdTime);
break;
}
case MFnNumericData::kInt: {
const int usdVal(attrPlug.asInt());
return usdAttr.Set(usdVal, usdTime);
break;
}
case MFnNumericData::k2Short: {
short tmp1, tmp2;
MFnNumericData numericDataFn(attrPlug.asMObject());
numericDataFn.getData(tmp1, tmp2);
return usdAttr.Set(GfVec2i(tmp1, tmp2), usdTime);
break;
}
case MFnNumericData::k2Int: {
int tmp1, tmp2;
MFnNumericData numericDataFn(attrPlug.asMObject());
numericDataFn.getData(tmp1, tmp2);
return usdAttr.Set(GfVec2i(tmp1, tmp2), usdTime);
break;
}
case MFnNumericData::k3Short: {
short tmp1, tmp2, tmp3;
MFnNumericData numericDataFn(attrPlug.asMObject());
numericDataFn.getData(tmp1, tmp2, tmp3);
return usdAttr.Set(GfVec3i(tmp1, tmp2, tmp3), usdTime);
break;
}
case MFnNumericData::k3Int: {
int tmp1, tmp2, tmp3;
MFnNumericData numericDataFn(attrPlug.asMObject());
numericDataFn.getData(tmp1, tmp2, tmp3);
return usdAttr.Set(GfVec3i(tmp1, tmp2, tmp3), usdTime);
break;
}
case MFnNumericData::kFloat: {
const float usdVal(attrPlug.asFloat());
return usdAttr.Set(usdVal, usdTime);
break;
}
case MFnNumericData::k2Float: {
float tmp1, tmp2;
MFnNumericData numericDataFn(attrPlug.asMObject());
numericDataFn.getData(tmp1, tmp2);
return usdAttr.Set(GfVec2f(tmp1, tmp2), usdTime);
break;
}
case MFnNumericData::k3Float: {
float tmp1, tmp2, tmp3;
MFnNumericData numericDataFn(attrPlug.asMObject());
numericDataFn.getData(tmp1, tmp2, tmp3);
return _SetVec(usdAttr, GfVec3f(tmp1, tmp2, tmp3), usdTime);
break;
}
case MFnNumericData::kDouble: {
const double usdVal(attrPlug.asDouble());
if (translateMayaDoubleToUsdSinglePrecision) {
return usdAttr.Set((float)usdVal, usdTime);
} else {
return usdAttr.Set(usdVal, usdTime);
}
break;
}
case MFnNumericData::k2Double: {
double tmp1, tmp2;
MFnNumericData numericDataFn(attrPlug.asMObject());
numericDataFn.getData(tmp1, tmp2);
if (translateMayaDoubleToUsdSinglePrecision) {
return usdAttr.Set(GfVec2f((float)tmp1, (float)tmp2), usdTime);
} else {
return usdAttr.Set(GfVec2d(tmp1, tmp2), usdTime);
}
break;
}
case MFnNumericData::k3Double: {
double tmp1, tmp2, tmp3;
MFnNumericData numericDataFn(attrPlug.asMObject());
numericDataFn.getData(tmp1, tmp2, tmp3);
if (translateMayaDoubleToUsdSinglePrecision) {
return _SetVec(usdAttr,
GfVec3f((float)tmp1,
(float)tmp2,
(float)tmp3),
usdTime);
} else {
return _SetVec(usdAttr, GfVec3d(tmp1, tmp2, tmp3), usdTime);
}
break;
}
case MFnNumericData::k4Double: {
double tmp1, tmp2, tmp3, tmp4;
MFnNumericData numericDataFn(attrPlug.asMObject());
numericDataFn.getData(tmp1, tmp2, tmp3, tmp4);
if (translateMayaDoubleToUsdSinglePrecision) {
return _SetVec(usdAttr,
GfVec4f((float)tmp1,
(float)tmp2,
(float)tmp3,
(float)tmp4),
usdTime);
} else {
return _SetVec(usdAttr,
GfVec4d(tmp1, tmp2, tmp3, tmp4),
usdTime);
}
break;
}
default:
break;
}
switch (unitDataType) {
case MFnUnitAttribute::kAngle:
case MFnUnitAttribute::kDistance:
if (translateMayaDoubleToUsdSinglePrecision) {
const float usdVal(attrPlug.asFloat());
return usdAttr.Set(usdVal, usdTime);
} else {
const double usdVal(attrPlug.asDouble());
return usdAttr.Set(usdVal, usdTime);
}
break;
default:
break;
}
return false;
}
virtual void ExportUserAttrs( AtNode *node )
{
// Get the optional attributes and export them as user vars
MPlug plug = FindMayaObjectPlug( "shaderAssignation" );
if( !plug.isNull() )
{
AiNodeDeclare( node, "shaderAssignation", "constant STRING" );
AiNodeSetStr( node, "shaderAssignation", plug.asString().asChar() );
}
plug = FindMayaObjectPlug( "displacementAssignation" );
if( !plug.isNull() )
{
AiNodeDeclare( node, "displacementAssignation", "constant STRING" );
AiNodeSetStr( node, "displacementAssignation", plug.asString().asChar() );
}
plug = FindMayaObjectPlug( "shaderAssignmentfile" );
if( !plug.isNull() )
{
AiNodeDeclare( node, "shaderAssignmentfile", "constant STRING" );
AiNodeSetStr( node, "shaderAssignmentfile", plug.asString().asChar() );
}
plug = FindMayaObjectPlug( "overrides" );
if( !plug.isNull() )
{
AiNodeDeclare( node, "overrides", "constant STRING" );
AiNodeSetStr( node, "overrides", plug.asString().asChar() );
}
plug = FindMayaObjectPlug( "overridefile" );
if( !plug.isNull() )
{
AiNodeDeclare( node, "overridefile", "constant STRING" );
AiNodeSetStr( node, "overridefile", plug.asString().asChar() );
}
plug = FindMayaObjectPlug( "userAttributes" );
if( !plug.isNull() )
{
AiNodeDeclare( node, "userAttributes", "constant STRING" );
AiNodeSetStr( node, "userAttributes", plug.asString().asChar() );
}
plug = FindMayaObjectPlug( "userAttributesfile" );
if( !plug.isNull() )
{
AiNodeDeclare( node, "userAttributesfile", "constant STRING" );
AiNodeSetStr( node, "userAttributesfile", plug.asString().asChar() );
}
plug = FindMayaObjectPlug( "skipJson" );
if( !plug.isNull() )
{
AiNodeDeclare( node, "skipJson", "constant BOOL" );
AiNodeSetBool( node, "skipJson", plug.asBool() );
}
plug = FindMayaObjectPlug( "skipShaders" );
if( !plug.isNull() )
{
AiNodeDeclare( node, "skipShaders", "constant BOOL" );
AiNodeSetBool( node, "skipShaders", plug.asBool() );
}
plug = FindMayaObjectPlug( "skipOverrides" );
if( !plug.isNull() )
{
AiNodeDeclare( node, "skipOverrides", "constant BOOL" );
AiNodeSetBool( node, "skipOverrides", plug.asBool() );
}
plug = FindMayaObjectPlug( "skipUserAttributes" );
if( !plug.isNull() )
{
AiNodeDeclare( node, "skipUserAttributes", "constant BOOL" );
AiNodeSetBool( node, "skipUserAttributes", plug.asBool() );
}
plug = FindMayaObjectPlug( "skipDisplacements" );
if( !plug.isNull() )
{
AiNodeDeclare( node, "skipDisplacements", "constant BOOL" );
AiNodeSetBool( node, "skipDisplacements", plug.asBool() );
}
plug = FindMayaObjectPlug( "objectPattern" );
if( !plug.isNull() )
{
AiNodeDeclare( node, "objectPattern", "constant STRING" );
AiNodeSetStr( node, "objectPattern", plug.asString().asChar() );
}
plug = FindMayaObjectPlug( "assShaders" );
if( !plug.isNull() )
{
AiNodeDeclare( node, "assShaders", "constant STRING" );
AiNodeSetStr( node, "assShaders", plug.asString().asChar() );
}
plug = FindMayaObjectPlug( "radiusPoint" );
if( !plug.isNull() )
{
AiNodeDeclare( node, "radiusPoint", "constant FLOAT" );
AiNodeSetFlt( node, "radiusPoint", plug.asFloat() );
}
plug = FindMayaObjectPlug( "radiusCurve" );
if( !plug.isNull() )
{
AiNodeDeclare( node, "radiusCurve", "constant FLOAT" );
AiNodeSetFlt( node, "radiusCurve", plug.asFloat() );
}
plug = FindMayaObjectPlug( "modeCurve" );
if( !plug.isNull() )
{
AiNodeDeclare( node, "modeCurve", "constant STRING" );
int modeCurveInt = plug.asInt();
if (modeCurveInt == 1)
AiNodeSetStr(node, "modeCurve", "thick");
else if (modeCurveInt == 2)
AiNodeSetStr(node, "modeCurve", "oriented");
else
AiNodeSetStr(node, "modeCurve", "ribbon");
}
plug = FindMayaObjectPlug( "scaleVelocity" );
if( !plug.isNull() )
{
AiNodeDeclare( node, "scaleVelocity", "constant FLOAT" );
AiNodeSetFlt( node, "scaleVelocity", plug.asFloat() );
}
}
virtual void ExportProcedural( AtNode *node )
{
// do basic node export
ExportMatrix( node, 0 );
// AiNodeSetPtr( node, "shader", arnoldShader(node) );
AiNodeSetInt( node, "visibility", ComputeVisibility() );
MPlug plug = FindMayaObjectPlug( "receiveShadows" );
if( !plug.isNull() )
{
AiNodeSetBool( node, "receive_shadows", plug.asBool() );
}
plug = FindMayaObjectPlug( "aiSelfShadows" );
if( !plug.isNull() )
{
AiNodeSetBool( node, "self_shadows", plug.asBool() );
}
plug = FindMayaObjectPlug( "aiOpaque" );
if( !plug.isNull() )
{
AiNodeSetBool( node, "opaque", plug.asBool() );
}
// now set the procedural-specific parameters
AiNodeSetBool( node, "load_at_init", true ); // just for now so that it can load the shaders at the right time
MFnDagNode fnDagNode( m_dagPath );
MBoundingBox bound = fnDagNode.boundingBox();
AiNodeSetPnt( node, "min", bound.min().x-m_dispPadding, bound.min().y-m_dispPadding, bound.min().z-m_dispPadding );
AiNodeSetPnt( node, "max", bound.max().x+m_dispPadding, bound.max().y, bound.max().z+m_dispPadding );
const char *dsoPath = getenv( "ALEMBIC_ARNOLD_PROCEDURAL_PATH" );
AiNodeSetStr( node, "dso", dsoPath ? dsoPath : "bb_AlembicArnoldProcedural.so" );
// Set the parameters for the procedural
//abcFile path
MString abcFile = fnDagNode.findPlug("cacheFileName").asString().expandEnvironmentVariablesAndTilde();
//object path
MString objectPath = fnDagNode.findPlug("cacheGeomPath").asString();
//object pattern
MString objectPattern = "*";
plug = FindMayaObjectPlug( "objectPattern" );
if (!plug.isNull() )
{
if (plug.asString() != "")
{
objectPattern = plug.asString();
}
}
//object pattern
MString excludePattern = "";
plug = FindMayaObjectPlug( "excludePattern" );
if (!plug.isNull() )
{
if (plug.asString() != "")
{
excludePattern = plug.asString();
}
}
float shutterOpen = 0.0;
plug = FindMayaObjectPlug( "shutterOpen" );
if (!plug.isNull() )
{
shutterOpen = plug.asFloat();
}
float shutterClose = 0.0;
plug = FindMayaObjectPlug( "shutterClose" );
if (!plug.isNull() )
{
shutterClose = plug.asFloat();
}
float timeOffset = 0.0;
plug = FindMayaObjectPlug( "timeOffset" );
if (!plug.isNull() )
{
timeOffset = plug.asFloat();
}
int subDIterations = 0;
plug = FindMayaObjectPlug( "ai_subDIterations" );
if (!plug.isNull() )
{
subDIterations = plug.asInt();
}
MString nameprefix = "";
plug = FindMayaObjectPlug( "namePrefix" );
if (!plug.isNull() )
{
nameprefix = plug.asString();
}
// bool exportFaceIds = fnDagNode.findPlug("exportFaceIds").asBool();
bool makeInstance = true; // always on for now
plug = FindMayaObjectPlug( "makeInstance" );
if (!plug.isNull() )
{
makeInstance = plug.asBool();
}
bool flipv = false;
plug = FindMayaObjectPlug( "flipv" );
if (!plug.isNull() )
{
flipv = plug.asBool();
}
bool invertNormals = false;
plug = FindMayaObjectPlug( "invertNormals" );
if (!plug.isNull() )
{
invertNormals = plug.asBool();
}
short i_subDUVSmoothing = 1;
plug = FindMayaObjectPlug( "ai_subDUVSmoothing" );
if (!plug.isNull() )
{
i_subDUVSmoothing = plug.asShort();
}
MString subDUVSmoothing;
switch (i_subDUVSmoothing)
{
case 0:
subDUVSmoothing = "pin_corners";
break;
case 1:
subDUVSmoothing = "pin_borders";
break;
case 2:
subDUVSmoothing = "linear";
break;
case 3:
subDUVSmoothing = "smooth";
break;
default :
subDUVSmoothing = "pin_corners";
break;
}
MTime curTime = MAnimControl::currentTime();
// fnDagNode.findPlug("time").getValue( frame );
// MTime frameOffset;
// fnDagNode.findPlug("timeOffset").getValue( frameOffset );
float time = curTime.as(MTime::kFilm)+timeOffset;
MString argsString;
if (objectPath != "|"){
argsString += "-objectpath ";
// convert "|" to "/"
argsString += MString(replace_all(objectPath,"|","/").c_str());
}
if (objectPattern != "*"){
argsString += "-pattern ";
argsString += objectPattern;
}
if (excludePattern != ""){
argsString += "-excludepattern ";
argsString += excludePattern;
}
if (shutterOpen != 0.0){
argsString += " -shutteropen ";
argsString += shutterOpen;
}
if (shutterClose != 0.0){
argsString += " -shutterclose ";
argsString += shutterClose;
}
if (subDIterations != 0){
argsString += " -subditerations ";
argsString += subDIterations;
argsString += " -subduvsmoothing ";
argsString += subDUVSmoothing;
}
if (makeInstance){
argsString += " -makeinstance ";
}
if (nameprefix != ""){
argsString += " -nameprefix ";
argsString += nameprefix;
}
if (flipv){
argsString += " -flipv ";
}
if (invertNormals){
argsString += " -invertNormals ";
}
argsString += " -filename ";
argsString += abcFile;
argsString += " -frame ";
argsString += time;
if (m_displaced){
argsString += " -disp_map ";
argsString += AiNodeGetName(m_dispNode);
}
AiNodeSetStr(node, "data", argsString.asChar());
ExportUserAttrs(node);
// Export light linking per instance
ExportLightLinking(node);
}
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;
}
