void NurbsCurveEmitter::Fill(const FieldRef& field)
{
MFnNurbsCurve curve(mObject);
// Get the range for U and V.
MPlug minValuePlug = curve.findPlug("minValue");
MPlug maxValuePlug = curve.findPlug("maxValue");
const Double minValue = minValuePlug.asDouble();
const Double maxValue = maxValuePlug.asDouble();
const Double valueRange = maxValue - minValue;
int i = 0;
for (i = 0; i < static_cast<int>(mSample); ++ i)
{
double u = Stokes::Random::NextAsDouble();
double v = Stokes::Random::NextAsDouble();
double w = Stokes::Random::NextAsDouble();
double param = u * valueRange + minValue;
MPoint p;
curve.getPointAtParam(param, p, MSpace::kWorld);
MVector t = curve.tangent(param, MSpace::kWorld);
t.normalize();
MVector n = curve.normal(param, MSpace::kWorld);
n.normalize();
MVector b = n ^ t;
double r = sqrt(v);
double phi = w * 2.0 * M_PI;
double x = r * cos(phi);
double y = r * sin(phi);
// TODO: No radius here.
MPoint newP = p + n * x + b * y;
MVector radialDirection = newP - p;
radialDirection.normalize();
Stokes::Vectorf noisedPoint(Random::NextAsFloat() * mScale.x - mOffset.x, Random::NextAsFloat() * mScale.y - mOffset.y, static_cast<Float>(u) * mScale.z - mOffset.z);
Float displacement = Stokes::Noiser::FractalBrownianMotion(noisedPoint, mDisplacedH, mDisplacedLacunarity, mDisplacedOctave) * mDisplacedAmplitude;
MPoint displacedP = newP + radialDirection * displacement;
Stokes::Vectorf worldPoint(static_cast<Stokes::Float>(displacedP.x), static_cast<Stokes::Float>(displacedP.y), static_cast<Stokes::Float>(displacedP.z));
Stokes::Vectoriu index;
if (field->CalculateIndexFromWorldPoint(worldPoint, index))
{
Float density = Stokes::Noiser::FractalBrownianMotion(noisedPoint, mH, mLacunarity, mOctave) * mAmplitude;
if (density > 0)
{
field->Access(index)[0] += density;
}
}
}
}
void splineSolverNode::evaluateDG()
{
//Use the Force!
for (int i = 0; i < joints.size(); i++)
{
MFnIkJoint j( joints[i]);
MPlug sxPlug = j.findPlug("sx");
MPlug syPlug = j.findPlug("sy");
MPlug szPlug = j.findPlug("sz");
double sxValue = sxPlug.asDouble();
sxPlug.setDouble(sxValue);
double syValue = syPlug.asDouble();
syPlug.setDouble(syValue);
double szValue = szPlug.asDouble();
szPlug.setDouble(szValue);
}
}
bool getPoint(MString& plugName, MFnDependencyNode& dn, MVector& value)
{
MDGContext ctx = MDGContext::fsNormal;
MStatus stat = MS::kSuccess;
bool result = false;
MPlug plug = dn.findPlug(plugName, &stat);
if( !stat )
return false;
MPlug Xplug = dn.findPlug(plugName + "X", &stat);
MPlug Yplug = dn.findPlug(plugName + "Y", &stat);
MPlug Zplug = dn.findPlug(plugName + "Z", &stat);
if( !stat )
return false;
value.x = Xplug.asDouble(ctx, &stat);
value.y = Yplug.asDouble(ctx, &stat);
value.z = Zplug.asDouble(ctx, &stat);
if( !stat )
return false;
return true;
}
void V3Manipulator::getPlugValues( MPlug &plug, double *values )
{
if( plug.numChildren() == 3 )
{
for( unsigned i = 0; i<3; i++ )
{
MPlug child = plug.child( i );
*values = child.asDouble();
values++;
}
}
else
{
for( unsigned i = 0; i<3; i++ )
{
MPlug element = plug.elementByLogicalIndex( i );
*values = element.asDouble();
values++;
}
}
}
bool getDouble(MString& plugName, MFnDependencyNode& dn, double& value)
{
MDGContext ctx = MDGContext::fsNormal;
MStatus stat = MS::kSuccess;
bool result = false;
MPlug plug = dn.findPlug(plugName, &stat);
if( !stat )
return false;
value = plug.asDouble(ctx, &stat);
if(stat)
return true;
return result;
}
void addTranslate(const MFnDependencyNode & iTrans,
MString parentName, MString xName, MString yName, MString zName,
Alembic::Util::uint8_t iHint, bool inverse, bool forceStatic,
bool forceAnimated, Alembic::AbcGeom::XformSample & oSample,
std::vector < AnimChan > & oAnimChanList)
{
Alembic::AbcGeom::XformOp op(Alembic::AbcGeom::kTranslateOperation, iHint);
MPlug xPlug = iTrans.findPlug(xName);
int xSamp = 0;
if (!forceStatic)
{
if (!forceAnimated)
xSamp = util::getSampledType(xPlug);
else
xSamp = 1;
}
double xVal = xPlug.asDouble();
MPlug yPlug = iTrans.findPlug(yName);
int ySamp = 0;
if (!forceStatic)
{
if (!forceAnimated)
ySamp = util::getSampledType(yPlug);
else
ySamp = 1;
}
double yVal = yPlug.asDouble();
MPlug zPlug = iTrans.findPlug(zName);
int zSamp = 0;
if (!forceStatic)
{
if (!forceAnimated)
zSamp = util::getSampledType(zPlug);
else
zSamp = 1;
}
double zVal = zPlug.asDouble();
// this is to handle the case where there is a connection to the parent
// plug but not to the child plugs, if the connection is there then all
// of the children are considered animated
MPlug parentPlug = iTrans.findPlug(parentName);
int parentSamp = 0;
if (!forceStatic)
{
if (!forceAnimated)
parentSamp = util::getSampledType(parentPlug);
else
parentSamp = 1;
}
if (parentSamp != 0)
{
xSamp = 1;
ySamp = 1;
zSamp = 1;
}
// something is sampled or not identity, add it to the stack
if (xSamp != 0 || ySamp != 0 || zSamp != 0 || xVal != 0.0 || yVal != 0.0 ||
zVal != 0.0)
{
if (inverse)
{
xVal = -xVal;
yVal = -yVal;
zVal = -zVal;
}
op.setChannelValue(0, xVal);
op.setChannelValue(1, yVal);
op.setChannelValue(2, zVal);
if (xSamp != 0)
{
AnimChan chan;
chan.plug = xPlug;
chan.scale = 1.0;
if (inverse)
chan.scale = -1.0;
chan.opNum = oSample.getNumOps();
chan.channelNum = 0;
oAnimChanList.push_back(chan);
}
if (ySamp != 0)
{
AnimChan chan;
chan.plug = yPlug;
chan.scale = 1.0;
if (inverse)
chan.scale = -1.0;
chan.opNum = oSample.getNumOps();
chan.channelNum = 1;
oAnimChanList.push_back(chan);
}
if (zSamp != 0)
{
AnimChan chan;
chan.plug = zPlug;
chan.scale = 1.0;
if (inverse)
chan.scale = -1.0;
chan.opNum = oSample.getNumOps();
chan.channelNum = 2;
oAnimChanList.push_back(chan);
}
oSample.addOp(op);
}
}
// the test on whether or not to add it is very similiar to addTranslate
// but the operation it creates is very different
void addShear(const MFnDependencyNode & iTrans, bool forceStatic,
Alembic::AbcGeom::XformSample & oSample,
std::vector < AnimChan > & oAnimChanList)
{
Alembic::AbcGeom::XformOp op(Alembic::AbcGeom::kMatrixOperation,
Alembic::AbcGeom::kMayaShearHint);
MString str = "shearXY";
MPlug xyPlug = iTrans.findPlug(str);
int xySamp = 0;
if (!forceStatic)
{
xySamp = util::getSampledType(xyPlug);
}
double xyVal = xyPlug.asDouble();
str = "shearXZ";
MPlug xzPlug = iTrans.findPlug(str);
int xzSamp = 0;
if (!forceStatic)
{
xzSamp = util::getSampledType(xzPlug);
}
double xzVal = xzPlug.asDouble();
str = "shearYZ";
MPlug yzPlug = iTrans.findPlug(str);
int yzSamp = 0;
if (!forceStatic)
{
yzSamp = util::getSampledType(yzPlug);
}
double yzVal = yzPlug.asDouble();
// this is to handle the case where there is a connection to the parent
// plug but not to the child plugs, if the connection is there then all
// of the children are considered animated
str = "shear";
MPlug parentPlug = iTrans.findPlug(str);
if (!forceStatic && util::getSampledType(parentPlug) != 0)
{
xySamp = 1;
xzSamp = 1;
yzSamp = 1;
}
// something is sampled or not identity, add it to the stack
if (xySamp != 0 || xzSamp != 0 || yzSamp != 0 ||
xyVal != 0.0 || xzVal != 0.0 || yzVal != 0.0)
{
Alembic::Abc::M44d m;
m.makeIdentity();
op.setMatrix(m);
op.setChannelValue(4, xyVal);
op.setChannelValue(8, xzVal);
op.setChannelValue(9, yzVal);
if (xySamp != 0)
{
AnimChan chan;
chan.plug = xyPlug;
chan.scale = 1.0;
chan.opNum = oSample.getNumOps();
chan.channelNum = 4;
oAnimChanList.push_back(chan);
}
if (xzSamp != 0)
{
AnimChan chan;
chan.plug = xzPlug;
chan.scale = 1.0;
chan.opNum = oSample.getNumOps();
chan.channelNum = 8;
oAnimChanList.push_back(chan);
}
if (yzSamp != 0)
{
AnimChan chan;
chan.plug = yzPlug;
chan.scale = 1.0;
chan.opNum = oSample.getNumOps();
chan.channelNum = 9;
oAnimChanList.push_back(chan);
}
oSample.addOp(op);
}
}
// names need to be passed in x,y,z order, iOrder is the order to
// use these indices
void addRotate(const MFnDependencyNode & iTrans,
MString parentName, const MString* iNames, const unsigned int* iOrder,
Alembic::Util::uint8_t iHint, bool forceStatic, bool forceAnimated,
Alembic::AbcGeom::XformSample & oSample,
std::vector < AnimChan > & oAnimChanList,
size_t oOpIndex[3])
{
// for each possible rotation axis
static const Alembic::AbcGeom::XformOperationType rots[3] = {
Alembic::AbcGeom::kRotateXOperation,
Alembic::AbcGeom::kRotateYOperation,
Alembic::AbcGeom::kRotateZOperation
};
// this is to handle the case where there is a connection to the parent
// plug but not to the child plugs, if the connection is there then all
// of the children are considered animated
MPlug parentPlug = iTrans.findPlug(parentName);
int parentSamp = 0;
if (!forceStatic)
{
if (!forceAnimated)
parentSamp = util::getSampledType(parentPlug);
else
parentSamp = 1;
}
// whether we are using the XYZ rotation order
bool isXYZ = ((iOrder[0] == 0) && (iOrder[1] == 1) && (iOrder[2] == 2));
// add them in backwards since we are dealing with a stack
int i = 2;
for (; i > -1; i--)
{
unsigned int index = iOrder[i];
MPlug plug = iTrans.findPlug(iNames[index]);
int samp = 0;
if (!forceStatic)
{
if (!forceAnimated)
samp = util::getSampledType(plug);
else
samp = 1;
if (samp == 0)
samp = parentSamp;
}
double plugVal = plug.asDouble();
Alembic::AbcGeom::XformOp op(rots[index], iHint);
op.setChannelValue(0, Alembic::AbcGeom::RadiansToDegrees(plugVal));
// the sampled case
if (samp != 0)
{
AnimChan chan;
chan.plug = plug;
chan.scale = Alembic::AbcGeom::RadiansToDegrees(1.0);
chan.opNum = oSample.getNumOps();
chan.channelNum = 0;
oAnimChanList.push_back(chan);
}
// non sampled, XYZ axis and the angle is 0, do not add to the stack
else if (isXYZ && plugVal == 0.0)
continue;
oOpIndex[index] = oSample.addOp(op);
}
}
MayaCameraWriter::MayaCameraWriter(MDagPath & iDag,
Alembic::Abc::OObject & iParent, Alembic::Util::uint32_t iTimeIndex,
const JobArgs & iArgs) :
mIsAnimated(false),
mDagPath(iDag),
mUseRenderShutter(false),
mShutterOpen(0.0),
mShutterClose(0.0)
{
MStatus status = MS::kSuccess;
MFnCamera cam(iDag, &status);
if (!status)
{
MGlobal::displayError( "MFnCamera() failed for MayaCameraWriter" );
}
MString name = cam.name();
name = util::stripNamespaces(name, iArgs.stripNamespace);
Alembic::AbcGeom::OCamera obj(iParent, name.asChar(), iTimeIndex);
mSchema = obj.getSchema();
MObject cameraObj = iDag.node();
if (iTimeIndex != 0 && util::isAnimated(cameraObj))
{
mIsAnimated = true;
}
else
{
iTimeIndex = 0;
}
MObject renderObj;
MSelectionList sel;
sel.add("defaultRenderGlobals");
if (!sel.isEmpty())
{
sel.getDependNode(0, renderObj);
MFnDependencyNode dep(renderObj);
MPlug plug = dep.findPlug("motionBlurUseShutter", true);
if (plug.asBool())
{
MTime sec(1.0, MTime::kSeconds);
double val = sec.as(MTime::uiUnit());
mUseRenderShutter = true;
plug = dep.findPlug("motionBlurShutterOpen", true);
mShutterOpen = plug.asDouble() / val;
plug = dep.findPlug("motionBlurShutterClose", true);
mShutterClose = plug.asDouble() / val;
}
}
Alembic::Abc::OCompoundProperty cp;
Alembic::Abc::OCompoundProperty up;
if (AttributesWriter::hasAnyAttr(cam, iArgs))
{
cp = mSchema.getArbGeomParams();
up = mSchema.getUserProperties();
}
mAttrs = AttributesWriterPtr(new AttributesWriter(cp, up, obj, cam,
iTimeIndex, iArgs, true));
if (!mIsAnimated || iArgs.setFirstAnimShape)
{
write();
}
}
MStatus sgBDataCmd_key::writeData( bool exportByMatrix )
{
MStatus status;
double dTime = MAnimControl::currentTime().value();
if( exportByMatrix )
{
for( unsigned int i=0; i<m_pathArrExport.length(); i++ )
{
m_objectKeyDatasExport[i].lengthTime++;
m_objectKeyDatasExport[i].dArrTime.append( dTime );
MFnDependencyNode fnNode( m_objectKeyDatasExport[i].oTargetNode );
if( m_objectKeyDatasExport[i].numAttr == 0 )
{
continue;
}
if( m_objectKeyDatasExport[i].numAttr == 1 )
{
MPlug plug = fnNode.findPlug( m_objectKeyDatasExport[i].namesAttribute[0] );
m_objectKeyDatasExport[i].dArrValuesArray.append( plug.asDouble() );
}
else
{
if( m_objectKeyDatasExport[i].numAttr == 10 )
{
MPlug plug = fnNode.findPlug( m_objectKeyDatasExport[i].namesAttribute[0] );
m_objectKeyDatasExport[i].dArrValuesArray.append( plug.asDouble() );
}
MDagPath dagPath;
dagPath.getAPathTo( m_objectKeyDatasExport[i].oTargetNode, dagPath );
MTransformationMatrix trMtx = dagPath.inclusiveMatrix() * dagPath.exclusiveMatrixInverse();
MVector trans = trMtx.translation( MSpace::kTransform );
double rotValues[3] ={0,0,0};
MTransformationMatrix::RotationOrder order = MTransformationMatrix::kZXY;
trMtx.getRotation( rotValues, order, MSpace::kTransform );
double scales[3];
trMtx.getScale( scales, MSpace::kTransform );
m_objectKeyDatasExport[i].dArrValuesArray.append( trans.x );
m_objectKeyDatasExport[i].dArrValuesArray.append( trans.y );
m_objectKeyDatasExport[i].dArrValuesArray.append( trans.z );
m_objectKeyDatasExport[i].dArrValuesArray.append( rotValues[0] );
m_objectKeyDatasExport[i].dArrValuesArray.append( rotValues[1] );
m_objectKeyDatasExport[i].dArrValuesArray.append( rotValues[2] );
m_objectKeyDatasExport[i].dArrValuesArray.append( scales[0] );
m_objectKeyDatasExport[i].dArrValuesArray.append( scales[1] );
m_objectKeyDatasExport[i].dArrValuesArray.append( scales[2] );
}
}
}
else
{
for( unsigned int i=0; i<m_pathArrExport.length(); i++ )
{
m_objectKeyDatasExport[i].lengthTime++;
m_objectKeyDatasExport[i].dArrTime.append( dTime );
MFnDependencyNode fnNode( m_objectKeyDatasExport[i].oTargetNode );
for( unsigned int j=0; j< m_objectKeyDatasExport[i].numAttr; j++ )
{
MPlug plug = fnNode.findPlug( m_objectKeyDatasExport[i].namesAttribute[j] );
m_objectKeyDatasExport[i].dArrValuesArray.append( plug.asDouble() );
}
}
}
return MS::kSuccess;
}
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;
}
MStatus splineSolverNode::doSimpleSolver()
//
// Solve single joint in the x-y plane
//
// - first it calculates the angle between the handle and the end-effector.
// - then it determines which way to rotate the joint.
//
{
//Do Real Solve
//
MStatus stat;
float curCurveLength = curveFn.length();
MPlug crvLengPlug = fnHandle.findPlug("cvLen");
double initCurveLength = crvLengPlug.asDouble();
//Twist
MPlug twistRamp = fnHandle.findPlug("twistRamp");
MRampAttribute curveAttribute( twistRamp, &stat );
MPlug startTwistPlug = fnHandle.findPlug("strtw");
double startTwist = startTwistPlug.asDouble();
MPlug endTwistPlug = fnHandle.findPlug("endtw");
double endTwist = endTwistPlug.asDouble();
//Scale Ramp
MPlug scaleRamp = fnHandle.findPlug("scaleRamp");
MRampAttribute curveScaleAttribute( scaleRamp, &stat );
//Roll
MPlug rollPlug = fnHandle.findPlug("roll");
double roll = rollPlug.asDouble();
MPlug strPlug = fnHandle.findPlug("str");
float stretchRatio = strPlug.asDouble();
float normCrvLength = curCurveLength / initCurveLength;
double scale[3] = {1 +stretchRatio*(normCrvLength -1), 1, 1};
//Get Anchor Position
MPlug ancPosPlug = fnHandle.findPlug("ancp");
double anchorPos = ancPosPlug.asDouble();
MPlug jointsTotLengthPlug = fnHandle.findPlug("jsLen");
double jointsTotalLength = jointsTotLengthPlug.asDouble();
double difLengthCurveJoints = curCurveLength - (jointsTotalLength * scale[0]);
float startLength = 0.0 + anchorPos*( difLengthCurveJoints );
float parm = curveFn.findParamFromLength( startLength );
MPoint pBaseJoint, pEndJoint;
curveFn.getPointAtParam( parm, pBaseJoint );
//get Init normal
MPlug initNormalPlug = fnHandle.findPlug("norm");
double nx = initNormalPlug.child(0).asDouble();
double ny = initNormalPlug.child(1).asDouble();
double nz = initNormalPlug.child(2).asDouble();
MVector eyeUp( nx, ny, nz );
//get Init Tangent
MPlug initTangentPlug = fnHandle.findPlug("tang");
double tx = initTangentPlug.child(0).asDouble();
double ty = initTangentPlug.child(1).asDouble();
double tz = initTangentPlug.child(2).asDouble();
MVector eyeV( tx, ty, tz );
MFnIkJoint j( joints[0] );
j.setTranslation( MVector( pBaseJoint ), MSpace::kWorld );
float jointRotPercent = 1.0/joints.size();
float currJointRot = 0;
float prevTwist = 0;
double angle;
//j.setScale(scale);
for (int i = 0; i < joints.size(); i++)
{
MFnIkJoint j( joints[i]);
pBaseJoint = j.rotatePivot(MSpace::kWorld);
//Calculate Scale
float scaleValue;
curveScaleAttribute.getValueAtPosition(currJointRot, scaleValue, &stat);
//if ( scale[0] >= 1 ) // Stretch
scale[1] = 1 + scaleValue * ( 1 - scale[0] );
/*
else //Squash
scale[1] = 1 + scaleValue * ( 1.0 - scale[0] );
*/
if (scale[1] < 0)
scale[1] = 0;
scale[2] = scale[1];
j.setScale(scale);
//j.setRotation( rot, j.rotationOrder() );
if( i == joints.size() - 1)
//Effector Position
pEndJoint = tran.rotatePivot(MSpace::kWorld);
else
{
//get position of next joint
MFnIkJoint j2( joints[i + 1]);
pEndJoint = j2.rotatePivot(MSpace::kWorld);
}
MVector vBaseJoint(pBaseJoint[0]-pEndJoint[0], pBaseJoint[1]-pEndJoint[1], pBaseJoint[2]-pEndJoint[2]);
startLength += vBaseJoint.length();
MVector eyeAim(1.0,0.0,0.0);
MPoint pFinalPos;
float parm = curveFn.findParamFromLength( startLength );
//Aim to final Pos
curveFn.getPointAtParam( parm, pFinalPos, MSpace::kWorld );
MVector eyeU(pBaseJoint[0]-pFinalPos[0], pBaseJoint[1]-pFinalPos[1], pBaseJoint[2]-pFinalPos[2]);
eyeU.normalize();
MVector eyeW( eyeU ^ eyeV );
eyeW.normalize();
eyeV = eyeW ^ eyeU;
MQuaternion qU( -eyeAim, eyeU );
MVector upRotated( eyeUp.rotateBy( qU ));
angle = acos( upRotated*eyeV );
//Calculate Twist
{
float twistValue;
curveAttribute.getValueAtPosition(currJointRot, twistValue, &stat);
double rotVal = (1-twistValue)*startTwist + twistValue*endTwist;
angle += MAngle(rotVal, MAngle::kDegrees).asRadians();
currJointRot += jointRotPercent;
}
//Calculate Roll
angle += roll;
MQuaternion qV(angle, eyeU);
MQuaternion q(qU*qV);
j.setRotation( q, MSpace::kWorld );
}
return MS::kSuccess;
}
MStatus splineSolverNode::preSolve()
{
MStatus stat;
setRotatePlane(false);
setSingleChainOnly(true);
setPositionOnly(false);
//Get Handle
MIkHandleGroup * handle_group = handleGroup();
if (NULL == handle_group) {
return MS::kFailure;
}
MObject handle = handle_group->handle( 0 );
MDagPath handlePath = MDagPath::getAPathTo( handle );
fnHandle.setObject( handlePath );
//Get Curve
MPlug inCurvePlug = fnHandle.findPlug( "inCurve" );
MDataHandle curveHandle = inCurvePlug.asMDataHandle();
MObject inputCurveObject = curveHandle.asNurbsCurveTransformed();
curveFn.setObject( inputCurveObject );
float initCurveLength = curveFn.length();
MVector initNormal = curveFn.normal(0);
MVector initTangent = curveFn.tangent(0);
float stretchRatio = 1;
// Get the position of the end_effector
//
MDagPath effectorPath;
fnHandle.getEffector(effectorPath);
tran.setObject( effectorPath );
// Get the start joint position
//
MDagPath startJointPath;
fnHandle.getStartJoint( startJointPath );
joints.clear();
//Get Joints
while (true)
{
effectorPath.pop();
joints.push_back( effectorPath );
if (effectorPath == startJointPath)
break;
}
std::reverse(joints.begin(), joints.end());
if (!fnHandle.hasAttribute("str"))
{
//Add Custom Attributes to Handle
MFnNumericAttribute fnAttr;
MObject attr = fnAttr.create("stretchRatio", "str", MFnNumericData::kDouble, stretchRatio);
fnAttr.setKeyable(1);
fnAttr.setWritable(1);
fnAttr.setMin(0);
fnAttr.setMax(1);
fnAttr.setHidden(0);
fnAttr.setStorable(1);
fnAttr.setReadable(1);
fnHandle.addAttribute(attr, MFnDependencyNode::kLocalDynamicAttr);
attr = fnAttr.create("anchorPosition", "ancp", MFnNumericData::kDouble, 0.0);
fnAttr.setKeyable(1);
fnAttr.setWritable(1);
fnAttr.setMin(0);
fnAttr.setMax(1);
fnAttr.setHidden(0);
fnAttr.setStorable(1);
fnAttr.setReadable(1);
fnHandle.addAttribute(attr, MFnDependencyNode::kLocalDynamicAttr);
attr = fnAttr.create("curveLength", "cvLen", MFnNumericData::kDouble, initCurveLength);
fnAttr.setKeyable(0);
fnAttr.setWritable(1);
fnAttr.setHidden(1);
fnAttr.setStorable(1);
fnAttr.setReadable(1);
fnHandle.addAttribute(attr, MFnDependencyNode::kLocalDynamicAttr);
attr = fnAttr.create("initNormal", "norm", MFnNumericData::k3Double);
fnAttr.setDefault(initNormal.x, initNormal.y, initNormal.z);
fnAttr.setKeyable(0);
fnAttr.setWritable(1);
fnAttr.setHidden(1);
fnAttr.setStorable(1);
fnAttr.setReadable(1);
fnHandle.addAttribute(attr, MFnDependencyNode::kLocalDynamicAttr);
attr = fnAttr.create("initTangent", "tang", MFnNumericData::k3Double);
fnAttr.setDefault(initTangent.x, initTangent.y, initTangent.z);
fnAttr.setKeyable(0);
fnAttr.setWritable(1);
fnAttr.setHidden(1);
fnAttr.setStorable(1);
fnAttr.setReadable(1);
fnHandle.addAttribute(attr, MFnDependencyNode::kLocalDynamicAttr);
attr = fnAttr.create("jointsLength", "jsLen", MFnNumericData::kDouble, getJointsTotalLenght());
fnAttr.setKeyable(0);
fnAttr.setWritable(1);
fnAttr.setHidden(1);
fnAttr.setStorable(1);
fnAttr.setReadable(1);
fnHandle.addAttribute(attr, MFnDependencyNode::kLocalDynamicAttr);
attr = fnAttr.create("startTwist", "strtw", MFnNumericData::kDouble, 0.0);
fnAttr.setKeyable(1);
fnAttr.setWritable(1);
fnAttr.setHidden(0);
fnAttr.setStorable(1);
fnAttr.setReadable(1);
fnHandle.addAttribute(attr, MFnDependencyNode::kLocalDynamicAttr);
attr = fnAttr.create("endTwist", "endtw", MFnNumericData::kDouble, 0.0);
fnAttr.setKeyable(1);
fnAttr.setWritable(1);
fnAttr.setHidden(0);
fnAttr.setStorable(1);
fnAttr.setReadable(1);
fnHandle.addAttribute(attr, MFnDependencyNode::kLocalDynamicAttr);
MObject twistRamp = MRampAttribute::createCurveRamp("twistRamp", "twr");
fnHandle.addAttribute(twistRamp, MFnDependencyNode::kLocalDynamicAttr);
MObject scaleRamp = MRampAttribute::createCurveRamp("scaleRamp", "scr");
fnHandle.addAttribute(scaleRamp, MFnDependencyNode::kLocalDynamicAttr);
} else
{
MPlug strPlug = fnHandle.findPlug("str");
stretchRatio = strPlug.asDouble();
}
return MS::kSuccess;
}
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;
}
}
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;
}
