void ShaderFXShaderExporter::exportSamplerAndSurface(const MFnDependencyNode & node, const MObject & attr)
{
MStatus status;
if (!attr.hasFn(MFn::kTypedAttribute))
return;
MFnTypedAttribute fnTypedAttr(attr, &status);
if (!status) return;
MFnData::Type type = fnTypedAttr.attrType(&status);
if (!status) return;
if (type != MFnData::kString)
return;
MPlug plug = node.findPlug(attr, &status);
MString value;
status = plug.getValue(value);
if (!status) return;
if (value.length() == 0)
return;
bool isUsedAsFilename = MFnAttribute(attr).isUsedAsFilename(&status);
if (!status) return;
// Filename are treated as texture filenames.
if (!isUsedAsFilename)
return;
exportSamplerAndSurfaceInner(value);
}
virtual void onString(MPlug & plug, const MString & name, const MString & value) override
{
MStatus status;
MObject attr = plug.attribute(&status);
if (!status) return;
if (value.length() == 0)
return;
bool isUsedAsFilename = MFnAttribute(attr).isUsedAsFilename(&status);
if (!status) return;
// Filename are treated as texture filenames.
if (isUsedAsFilename)
{
// Export texture
mShaderFXExporter.exportTexture(value);
}
else
{
// Export string
ScopedElement string(mShaderFXExporter.mStreamWriter, PARAM_TYPE_STRING);
mShaderFXExporter.mStreamWriter.appendText(value.asChar());
}
}
virtual void onString(MPlug & plug, const MString & name, const MString & value) override
{
MStatus status;
if (value.length() == 0)
return;
MObject attr = plug.attribute(&status);
if (!status) return;
bool isUsedAsFilename = MFnAttribute(attr).isUsedAsFilename(&status);
if (!status) return;
// Filename are treated as texture filenames.
if (!isUsedAsFilename)
return;
mShaderFXExporter.exportSamplerAndSurfaceInner(value);
}
MStatus sgBDataCmd_key::setObjectKeyDataDefault( sgObject_keyData& objectKeyData, const MDagPath& dagPathTarget, bool bMatrixType )
{
MStatus status;
objectKeyData.oTargetNode = dagPathTarget.node();
objectKeyData.numAttr = 0;
objectKeyData.namesAttribute.clear();
objectKeyData.lengthTime = 0;
objectKeyData.dArrTime.clear();
objectKeyData.dArrValuesArray.clear();
MFnDagNode fnDagNode = dagPathTarget;
MPlugArray plugArrTransform;
MPlugArray plugArrVis;
plugArrTransform.append( fnDagNode.findPlug( "tx" ) );
plugArrTransform.append( fnDagNode.findPlug( "ty" ) );
plugArrTransform.append( fnDagNode.findPlug( "tz" ) );
plugArrTransform.append( fnDagNode.findPlug( "rx" ) );
plugArrTransform.append( fnDagNode.findPlug( "ry" ) );
plugArrTransform.append( fnDagNode.findPlug( "rz" ) );
plugArrTransform.append( fnDagNode.findPlug( "sx" ) );
plugArrTransform.append( fnDagNode.findPlug( "sy" ) );
plugArrTransform.append( fnDagNode.findPlug( "sz" ) );
plugArrVis.append( fnDagNode.findPlug( "v" ) );
if( bMatrixType )
{
if( plugsHasConnection( plugArrVis ) )
{
objectKeyData.numAttr++;
objectKeyData.namesAttribute.append( "visibility" );
}
if( plugsHasConnection( plugArrTransform ) )
{
objectKeyData.numAttr += 9;
objectKeyData.namesAttribute.append( "translateX" );
objectKeyData.namesAttribute.append( "translateY" );
objectKeyData.namesAttribute.append( "translateZ" );
objectKeyData.namesAttribute.append( "rotateX" );
objectKeyData.namesAttribute.append( "rotateY" );
objectKeyData.namesAttribute.append( "rotateZ" );
objectKeyData.namesAttribute.append( "scaleX" );
objectKeyData.namesAttribute.append( "scaleY" );
objectKeyData.namesAttribute.append( "scaleZ" );
}
}
else
{
MPlugArray plugArr;
for( unsigned int j=0; j< plugArrTransform.length(); j++ )
{
MPlug& plug = plugArrTransform[j];
plug.connectedTo( plugArr, true, false );
if( !plugArr.length() )
{
MPlug plugParent = plug.parent( &status );
if( !status ) continue;
plugParent.connectedTo( plugArr, true, false );
if( !plugArr.length() ) continue;
}
objectKeyData.numAttr++;
objectKeyData.namesAttribute.append( MFnAttribute( plug.attribute() ).name() );
}
plugArrVis[0].connectedTo( plugArr, true, false );
if( plugArr.length() )
{
objectKeyData.numAttr++;
objectKeyData.namesAttribute.append( MFnAttribute( plugArrVis[0].attribute() ).name() );
}
}
objectKeyData.dArrValuesArray.clear();
return MS::kSuccess;
}
SdfValueTypeName
PxrUsdMayaWriteUtil::GetUsdTypeName(
const MPlug& attrPlug,
const bool translateMayaDoubleToUsdSinglePrecision)
{
// The various types of Maya attributes that can be created are spread
// across a handful of MFn function sets. Some are a straightforward
// translation such as MFnEnumAttributes or MFnMatrixAttributes, but others
// are interesting mixes of function sets. For example, an attribute created
// with addAttr and 'double' as the type results in an MFnNumericAttribute
// while 'double2' as the type results in an MFnTypedAttribute that has
// MFnData::Type kNumeric.
MObject attrObj(attrPlug.attribute());
if (attrObj.isNull()) {
return SdfValueTypeName();
}
if (attrObj.hasFn(MFn::kEnumAttribute)) {
return SdfValueTypeNames->Token;
}
MFnNumericData::Type numericDataType;
MFnData::Type typedDataType;
MFnUnitAttribute::Type unitDataType;
_GetMayaAttributeNumericTypedAndUnitDataTypes(attrPlug,
numericDataType,
typedDataType,
unitDataType);
if (attrObj.hasFn(MFn::kMatrixAttribute)) {
// Using type "fltMatrix" with addAttr results in an MFnMatrixAttribute
// while using type "matrix" results in an MFnTypedAttribute with type
// kMatrix, but the data is extracted the same way for both.
typedDataType = MFnData::kMatrix;
}
// Deal with the MFnTypedAttribute attributes first. If it is numeric, it
// will fall through to the numericDataType switch below.
switch (typedDataType) {
case MFnData::kString:
return SdfValueTypeNames->String;
break;
case MFnData::kMatrix:
// This must be a Matrix4d even if
// translateMayaDoubleToUsdSinglePrecision is true, since Matrix4f
// is not supported in Sdf.
return SdfValueTypeNames->Matrix4d;
break;
case MFnData::kStringArray:
return SdfValueTypeNames->StringArray;
break;
case MFnData::kDoubleArray:
if (translateMayaDoubleToUsdSinglePrecision) {
return SdfValueTypeNames->FloatArray;
} else {
return SdfValueTypeNames->DoubleArray;
}
break;
case MFnData::kFloatArray:
return SdfValueTypeNames->FloatArray;
break;
case MFnData::kIntArray:
return SdfValueTypeNames->IntArray;
break;
case MFnData::kPointArray:
// Sdf does not have a 4-float point type, so we'll divide out W
// and export the points as 3 floats.
if (translateMayaDoubleToUsdSinglePrecision) {
return SdfValueTypeNames->Point3fArray;
} else {
return SdfValueTypeNames->Point3dArray;
}
break;
case MFnData::kVectorArray:
if (translateMayaDoubleToUsdSinglePrecision) {
return SdfValueTypeNames->Vector3fArray;
} else {
return SdfValueTypeNames->Vector3dArray;
}
break;
default:
break;
}
switch (numericDataType) {
case MFnNumericData::kBoolean:
return SdfValueTypeNames->Bool;
break;
case MFnNumericData::kByte:
case MFnNumericData::kChar:
case MFnNumericData::kShort:
// Maya treats longs the same as ints, since long is not
// platform-consistent. The Maya constants MFnNumericData::kInt and
// MFnNumericData::kLong have the same value. The same is true of
// k2Int/k2Long and k3Int/k3Long.
case MFnNumericData::kInt:
return SdfValueTypeNames->Int;
break;
case MFnNumericData::k2Short:
case MFnNumericData::k2Int:
return SdfValueTypeNames->Int2;
break;
case MFnNumericData::k3Short:
case MFnNumericData::k3Int:
return SdfValueTypeNames->Int3;
break;
case MFnNumericData::kFloat:
return SdfValueTypeNames->Float;
break;
case MFnNumericData::k2Float:
return SdfValueTypeNames->Float2;
break;
case MFnNumericData::k3Float:
if (MFnAttribute(attrObj).isUsedAsColor()) {
return SdfValueTypeNames->Color3f;
} else {
return SdfValueTypeNames->Float3;
}
break;
case MFnNumericData::kDouble:
if (translateMayaDoubleToUsdSinglePrecision) {
return SdfValueTypeNames->Float;
} else {
return SdfValueTypeNames->Double;
}
break;
case MFnNumericData::k2Double:
if (translateMayaDoubleToUsdSinglePrecision) {
return SdfValueTypeNames->Float2;
} else {
return SdfValueTypeNames->Double2;
}
break;
case MFnNumericData::k3Double:
if (MFnAttribute(attrObj).isUsedAsColor()) {
if (translateMayaDoubleToUsdSinglePrecision) {
return SdfValueTypeNames->Color3f;
} else {
return SdfValueTypeNames->Color3d;
}
} else {
if (translateMayaDoubleToUsdSinglePrecision) {
return SdfValueTypeNames->Float3;
} else {
return SdfValueTypeNames->Double3;
}
}
break;
case MFnNumericData::k4Double:
if (translateMayaDoubleToUsdSinglePrecision) {
return SdfValueTypeNames->Float4;
} else {
return SdfValueTypeNames->Double4;
}
break;
default:
break;
}
switch (unitDataType) {
case MFnUnitAttribute::kAngle:
case MFnUnitAttribute::kDistance:
if (translateMayaDoubleToUsdSinglePrecision) {
return SdfValueTypeNames->Float;
} else {
return SdfValueTypeNames->Double;
}
break;
default:
break;
}
return SdfValueTypeName();
}
SdfValueTypeName
PxrUsdMayaWriteUtil::GetUsdTypeName( const MPlug& plg)
{
MObject attrObj(plg.attribute());
SdfValueTypeName attrType;
if (attrObj.hasFn(MFn::kNumericAttribute)) {
MFnNumericAttribute attrNumericFn(attrObj);
switch (attrNumericFn.unitType())
{
case MFnNumericData::kBoolean:
attrType = SdfValueTypeNames->Bool;
break;
case MFnNumericData::kByte:
case MFnNumericData::kChar:
case MFnNumericData::kShort:
case MFnNumericData::kInt:
attrType = SdfValueTypeNames->Int;
break;
/* We could do these, but there doesn't seem to be a good way of extracting
the data later on. For a Maya expert to solve...
case MFnNumericData::kLong:
attrType = SdfValueTypeNames->Int64;
break;
case MFnNumericData::kAddr:
attrType = SdfValueTypeNames->UInt64;
break;
*/
case MFnNumericData::kFloat:
attrType = SdfValueTypeNames->Float;
break;
case MFnNumericData::kDouble:
attrType = SdfValueTypeNames->Double;
break;
case MFnNumericData::k2Short:
case MFnNumericData::k2Int:
//case MFnNumericData::k2Long:
attrType = SdfValueTypeNames->Int2;
break;
case MFnNumericData::k3Short:
case MFnNumericData::k3Int:
//case MFnNumericData::k3Long:
attrType = SdfValueTypeNames->Int3;
break;
case MFnNumericData::k2Float:
attrType = SdfValueTypeNames->Float2;
break;
case MFnNumericData::k3Float:
if (MFnAttribute(attrObj).isUsedAsColor()) {
attrType = SdfValueTypeNames->Color3f;
}
else {
attrType = SdfValueTypeNames->Float3;
}
break;
case MFnNumericData::k2Double:
attrType = SdfValueTypeNames->Double2;
break;
case MFnNumericData::k3Double:
if (MFnAttribute(attrObj).isUsedAsColor()) {
attrType = SdfValueTypeNames->Color3d;
}
else {
attrType = SdfValueTypeNames->Double3;
}
break;
case MFnNumericData::k4Double:
attrType = SdfValueTypeNames->Double4;
break;
default:
break;
}
}
else if (attrObj.hasFn(MFn::kTypedAttribute)) {
MFnTypedAttribute attrTypedFn(attrObj);
switch (attrTypedFn.attrType())
{
case MFnData::kString:
attrType = SdfValueTypeNames->String;
break;
case MFnData::kMatrix:
attrType = SdfValueTypeNames->Matrix4d;
break;
case MFnData::kStringArray:
attrType = SdfValueTypeNames->StringArray;
break;
case MFnData::kIntArray:
attrType = SdfValueTypeNames->IntArray;
break;
case MFnData::kFloatArray:
attrType = SdfValueTypeNames->FloatArray;
break;
case MFnData::kDoubleArray:
attrType = SdfValueTypeNames->DoubleArray;
break;
case MFnData::kVectorArray:
attrType = SdfValueTypeNames->Vector3dArray;
break;
case MFnData::kPointArray:
attrType = SdfValueTypeNames->Point3dArray;
break;
default:
break;
}
}
else if (attrObj.hasFn(MFn::kUnitAttribute)) {
//MFnUnitAttribute attrUnitFn(attrObj);
}
else if (attrObj.hasFn(MFn::kEnumAttribute)) {
attrType = SdfValueTypeNames->Token;
}
return attrType;
}
