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