bool PxrUsdMayaTranslatorXformable::ConvertUsdMatrixToComponents(
const GfMatrix4d &usdMatrix,
GfVec3d *trans,
GfVec3d *rot,
GfVec3d *scale)
{
GfVec3d rotation, scaleVec, scaleOrientation;
_MatrixToVectorsWithPivotInvariant(
usdMatrix,
//const TransformRotationOrder rotationOrder, XYZ
GfVec3d(0,0,0), // const GfVec3d pivotPosition
GfVec3d(0,0,0), // const GfVec3d pivotOrientation
trans,
&rotation,
&scaleVec,
&scaleOrientation);
for (int i=0; i<3; ++i) {
// Note that setting rotation via Maya API takes radians, even though
// the MEL attribute itself is encoded in degrees. #wtf
(*rot)[i] = GfDegreesToRadians(rotation[i]);
(*scale)[i] = scaleVec[i];
}
return true;
}
GfVec4d GfHomogeneousCross(const GfVec4d &a, const GfVec4d &b)
{
GfVec4d ah(GfGetHomogenized(a));
GfVec4d bh(GfGetHomogenized(b));
GfVec3d prod =
GfCross(GfVec3d(ah[0], ah[1], ah[2]), GfVec3d(bh[0], bh[1], bh[2]));
return GfVec4d(prod[0], prod[1], prod[2], 1);
}
GfMatrix4d
Hdx_UnitTestGLDrawing::GetViewMatrix() const
{
GfMatrix4d viewMatrix;
viewMatrix.SetIdentity();
// rotate from z-up to y-up
viewMatrix *= GfMatrix4d().SetRotate(GfRotation(GfVec3d(1.0,0.0,0.0), -90.0));
viewMatrix *= GfMatrix4d().SetRotate(GfRotation(GfVec3d(0, 1, 0), _rotate[1]));
viewMatrix *= GfMatrix4d().SetRotate(GfRotation(GfVec3d(1, 0, 0), _rotate[0]));
viewMatrix *= GfMatrix4d().SetTranslate(GfVec3d(_translate[0], _translate[1], _translate[2]));
return viewMatrix;
}
GfRange3d
GfRange3d::GetOctant(size_t i) const
{
if (i > 7) {
TF_CODING_ERROR("Invalid octant %zu > 7.", i);
return GfRange3d();
}
GfVec3d a = GetCorner(i);
GfVec3d b = .5 * (_min + _max);
return GfRange3d(
GfVec3d(GfMin(a[0], b[0]), GfMin(a[1], b[1]), GfMin(a[2], b[2])),
GfVec3d(GfMax(a[0], b[0]), GfMax(a[1], b[1]), GfMax(a[2], b[2])));
}
/// Returns STATIC or ANIMATED if an extra translate is needed to compensate for
/// Maya's instancer translation behavior on the given prototype DAG node.
/// (This function may return false positives, which are OK but will simply
/// contribute extra data. It should never return false negatives, which
/// would cause correctness problems.)
bool
PxrUsdTranslators_InstancerWriter::_NeedsExtraInstancerTranslate(
const MDagPath& prototypeDagPath,
bool* instancerTranslateAnimated) const
{
// XXX: Maybe we could be smarter here and figure out if the animation
// affects instancerTranslate?
bool animated = !_GetExportArgs().timeSamples.empty() &&
MAnimUtil::isAnimated(prototypeDagPath.node(), false);
if (animated) {
*instancerTranslateAnimated = true;
return true;
}
GfVec3d origin;
bool translated =
_GetTransformedOriginInLocalSpace(prototypeDagPath, &origin) &&
!GfIsClose(origin, GfVec3d(0.0), _EPSILON);
if (translated) {
*instancerTranslateAnimated = false;
return true;
}
return false;
}
GfVec3d
GfRange3d::GetCorner(size_t i) const
{
if (i > 7) {
TF_CODING_ERROR("Invalid corner %zu > 7.", i);
return _min;
}
return GfVec3d(
(i & 1 ? _max : _min)[0],
(i & 2 ? _max : _min)[1],
(i & 4 ? _max : _min)[2]);
}
void
Hd_TestDriver::_Init(HdReprSelector const &reprSelector)
{
_renderIndex = HdRenderIndex::New(&_renderDelegate);
TF_VERIFY(_renderIndex != nullptr);
_sceneDelegate = new HdUnitTestDelegate(_renderIndex,
SdfPath::AbsoluteRootPath());
_reprSelector = reprSelector;
GfMatrix4d viewMatrix = GfMatrix4d().SetIdentity();
viewMatrix *= GfMatrix4d().SetTranslate(GfVec3d(0.0, 1000.0, 0.0));
viewMatrix *= GfMatrix4d().SetRotate(GfRotation(GfVec3d(1.0, 0.0, 0.0), -90.0));
GfFrustum frustum;
frustum.SetPerspective(45, true, 1, 1.0, 10000.0);
GfMatrix4d projMatrix = frustum.ComputeProjectionMatrix();
SetCamera(viewMatrix, projMatrix, GfVec4d(0, 0, 512, 512));
// set depthfunc to default
_renderPassState->SetDepthFunc(HdCmpFuncLess);
}
GfVec3d
GfRange3d::GetCorner(size_t i) const
{
if (i > 7) {
TF_CODING_ERROR("Invalid corner %zu > 7.", i);
return _min;
}
return GfVec3d(
(i & 1 ? _max : _min)[0],
(i & 2 ? _max : _min)[1],
(i & 4 ? _max : _min)[2]);
}
GfRange3d
GfRange3d::GetOctant(size_t i) const
{
if (i > 7) {
TF_CODING_ERROR("Invalid octant %zu > 7.", i);
return GfRange3d();
}
GfVec3d a = GetCorner(i);
GfVec3d b = .5 * (_min + _max);
return GfRange3d(
GfVec3d(GfMin(a[0], b[0]), GfMin(a[1], b[1]), GfMin(a[2], b[2])),
GfVec3d(GfMax(a[0], b[0]), GfMax(a[1], b[1]), GfMax(a[2], b[2])));
}
const GfRange3d GfRange3d::UnitCube(GfVec3d(0,0,0), GfVec3d(1,1,1));
/* static */
GfMatrix4d
UsdGeomXformOp::GetOpTransform(UsdGeomXformOp::Type const opType,
VtValue const &opVal,
bool isInverseOp)
{
// This will be the most common case.
if (opType == TypeTransform) {
GfMatrix4d mat(1.);
bool isMatrixVal = true;
if (opVal.IsHolding<GfMatrix4d>()) {
mat = opVal.UncheckedGet<GfMatrix4d>();
} else if (opVal.IsHolding<GfMatrix4f>()) {
mat = GfMatrix4d(opVal.UncheckedGet<GfMatrix4f>());
} else {
isMatrixVal = false;
TF_CODING_ERROR("Invalid combination of opType (%s) "
"and opVal (%s). Returning identity matrix.",
TfEnum::GetName(opType).c_str(),
TfStringify(opVal).c_str());
return GfMatrix4d(1.);
}
if (isMatrixVal && isInverseOp) {
double determinant=0;
mat = mat.GetInverse(&determinant);
if (GfIsClose(determinant, 0.0, 1e-9)) {
TF_CODING_ERROR("Cannot invert singular transform op with "
"value %s.", TfStringify(opVal).c_str());
}
}
return mat;
}
double doubleVal = 0.;
bool isScalarVal = true;
if (opVal.IsHolding<double>()) {
doubleVal = opVal.UncheckedGet<double>();
} else if (opVal.IsHolding<float>()) {
doubleVal = opVal.UncheckedGet<float>();
} else if (opVal.IsHolding<GfHalf>()) {
doubleVal = opVal.UncheckedGet<GfHalf>();
} else {
isScalarVal = false;
}
if (isScalarVal) {
if (isInverseOp)
doubleVal = -doubleVal;
if (opType == TypeRotateX) {
return GfMatrix4d(1.).SetRotate(GfRotation(GfVec3d::XAxis(), doubleVal));
} else if (opType == TypeRotateY) {
return GfMatrix4d(1.).SetRotate(GfRotation(GfVec3d::YAxis(), doubleVal));
} else if (opType == TypeRotateZ) {
return GfMatrix4d(1.).SetRotate(GfRotation(GfVec3d::ZAxis(), doubleVal));
}
}
GfVec3d vec3dVal = GfVec3d(0.);
bool isVecVal = true;
if (opVal.IsHolding<GfVec3f>()) {
vec3dVal = opVal.UncheckedGet<GfVec3f>();
} else if (opVal.IsHolding<GfVec3d>()) {
vec3dVal = opVal.UncheckedGet<GfVec3d>();
} else if (opVal.IsHolding<GfVec3h>()) {
vec3dVal = opVal.UncheckedGet<GfVec3h>();
} else {
isVecVal = false;
}
if (isVecVal) {
switch(opType) {
case TypeTranslate:
if (isInverseOp)
vec3dVal = -vec3dVal;
return GfMatrix4d(1.).SetTranslate(vec3dVal);
case TypeScale:
if (isInverseOp) {
vec3dVal = GfVec3d(1/vec3dVal[0],
1/vec3dVal[1],
1/vec3dVal[2]);
}
return GfMatrix4d(1.).SetScale(vec3dVal);
default: {
if (isInverseOp)
vec3dVal = -vec3dVal;
// Must be one of the 3-axis rotates.
GfMatrix3d xRot(GfRotation(GfVec3d::XAxis(), vec3dVal[0]));
GfMatrix3d yRot(GfRotation(GfVec3d::YAxis(), vec3dVal[1]));
GfMatrix3d zRot(GfRotation(GfVec3d::ZAxis(), vec3dVal[2]));
GfMatrix3d rotationMat(1.);
switch (opType) {
case TypeRotateXYZ:
// Inv(ABC) = Inv(C) * Inv(B) * Inv(A)
rotationMat = !isInverseOp ? (xRot * yRot * zRot)
: (zRot * yRot * xRot);
break;
case TypeRotateXZY:
rotationMat = !isInverseOp ? (xRot * zRot * yRot)
: (yRot * zRot * xRot);
break;
case TypeRotateYXZ:
rotationMat = !isInverseOp ? (yRot * xRot * zRot)
: (zRot * xRot * yRot);
break;
case TypeRotateYZX:
rotationMat = !isInverseOp ? (yRot * zRot * xRot)
: (xRot * zRot * yRot);
break;
case TypeRotateZXY:
rotationMat = !isInverseOp ? (zRot * xRot * yRot)
: (yRot * xRot * zRot);
break;
case TypeRotateZYX:
rotationMat = !isInverseOp ? (zRot * yRot * xRot)
: (xRot * yRot * zRot);
break;
default:
TF_CODING_ERROR("Invalid combination of opType (%s) "
"and opVal (%s). Returning identity matrix.",
TfEnum::GetName(opType).c_str(),
TfStringify(opVal).c_str());
return GfMatrix4d(1.);
}
return GfMatrix4d(1.).SetRotate(rotationMat);
}
}
}
if (opType == TypeOrient) {
GfQuatd quatVal(0);
if (opVal.IsHolding<GfQuatd>())
quatVal = opVal.UncheckedGet<GfQuatd>();
else if (opVal.IsHolding<GfQuatf>()) {
const GfQuatf &quatf = opVal.UncheckedGet<GfQuatf>();
quatVal = GfQuatd(quatf.GetReal(), quatf.GetImaginary());
} else if (opVal.IsHolding<GfQuath>()) {
const GfQuath &quath = opVal.UncheckedGet<GfQuath>();
quatVal = GfQuatd(quath.GetReal(), quath.GetImaginary());
}
GfRotation quatRotation(quatVal);
if (isInverseOp)
quatRotation = quatRotation.GetInverse();
return GfMatrix4d(quatRotation, GfVec3d(0.));
}
TF_CODING_ERROR("Invalid combination of opType (%s) and opVal (%s). "
"Returning identity matrix.", TfEnum::GetName(opType).c_str(),
TfStringify(opVal).c_str());
return GfMatrix4d(1.);
}
PXR_NAMESPACE_USING_DIRECTIVE
void
TestTemplates()
{
// --------------------------------------------------------------------- //
// This test operates on /RootPrim.foo
// and /RootPrim.foo:hidden
// --------------------------------------------------------------------- //
SdfPath primPath("/RootPrim");
TfToken prop("foo");
TfToken metaField("hidden");
std::string propPath(primPath.GetString() + "." + prop.GetString());
// --------------------------------------------------------------------- //
// Author scene and compose the Stage
// --------------------------------------------------------------------- //
SdfLayerRefPtr layer = SdfLayer::CreateAnonymous();
UsdStageRefPtr stage = UsdStage::Open(layer->GetIdentifier());
TF_VERIFY(stage->OverridePrim(primPath),
"Failed to create prim at %s",
primPath.GetText());
UsdPrim prim(stage->GetPrimAtPath(primPath));
TF_VERIFY(prim, "Failed to get Prim from %s", primPath.GetText());
// Grab the attribute we will be testing with.
UsdAttribute attr =
prim.CreateAttribute(prop, SdfValueTypeNames->Double3Array);
TF_VERIFY(attr, "Failed to create property at %s", propPath.c_str());
// --------------------------------------------------------------------- //
// Setup some test data
// --------------------------------------------------------------------- //
VtVec3dArray vtVecOut(1);
VtVec3dArray vtVecIn;
std::string tmp;
VtValue value;
// ===================================================================== //
// TEST READING METADATA
// ===================================================================== //
// --------------------------------------------------------------------- //
// GetMetadata & SetMetadata the value as a VtValue
// --------------------------------------------------------------------- //
TF_VERIFY(attr.SetMetadata(metaField, VtValue(true)),
"VtValue: Failed to set hidden metadata at %s",
propPath.c_str());
// Print the layer for debugging.
layer->ExportToString(&tmp);
std::cout << "-----------------------------------------" << std::endl;
std::cout << "Metadata -- VtValue:" << std::endl;
std::cout << tmp << std::endl;
// Verify the result.
TF_VERIFY(attr.GetMetadata(metaField, &value),
"Metadata -- VtValue: Failed to get property value at %s",
propPath.c_str());
TF_VERIFY(value.IsHolding<bool>(),
"Metadata -- VtValue: not holding bool%s",
propPath.c_str());
TF_VERIFY(value.Get<bool>(),
"Metadata -- VtValue: value was not true %s",
propPath.c_str());
// --------------------------------------------------------------------- //
// GetMetadata & SetMetadata the value as bool
// --------------------------------------------------------------------- //
bool valueIn = false;
TF_VERIFY(attr.SetMetadata(metaField, true),
"Metadata -- bool: Failed to set property at %s",
propPath.c_str());
// Print the layer for debugging.
tmp = "";
layer->ExportToString(&tmp);
std::cout << "-----------------------------------------" << std::endl;
std::cout << "Metadata -- bool:" << std::endl;
std::cout << tmp << std::endl;
// Verify Result.
TF_VERIFY(attr.GetMetadata(metaField, &valueIn),
"Metadata -- bool: Failed to get property value at %s",
propPath.c_str());
TF_VERIFY(valueIn,
"Metadata -- bool: value was not true %s",
propPath.c_str());
// ===================================================================== //
// TEST READING VALUES
// ===================================================================== //
// --------------------------------------------------------------------- //
// Get & Set the value as a VtValue
// --------------------------------------------------------------------- //
vtVecOut[0] = GfVec3d(9,8,7);
TF_VERIFY(attr.Set(VtValue(vtVecOut)),
"VtValue: Failed to set property at %s",
propPath.c_str());
// Print the layer for debugging.
layer->ExportToString(&tmp);
std::cout << "-----------------------------------------" << std::endl;
std::cout << "VtValue:" << std::endl;
std::cout << tmp << std::endl;
// Verify the result.
TF_VERIFY(attr.Get(&value),
"VtValue: Failed to get property value at %s",
propPath.c_str());
TF_VERIFY(value.IsHolding<VtVec3dArray>(),
"VtValue: not holding VtVec3dArray %s",
propPath.c_str());
TF_VERIFY(value.Get<VtVec3dArray>()[0] == vtVecOut[0],
"VtValue: VtVec3d[0] does not match %s",
propPath.c_str());
// --------------------------------------------------------------------- //
// Get & Set the value as a VtArray
// --------------------------------------------------------------------- //
vtVecOut[0] = GfVec3d(6,5,4);
TF_VERIFY(attr.Set(vtVecOut),
"Failed to set property at %s",
propPath.c_str());
// Print the layer for debugging.
tmp = "";
layer->ExportToString(&tmp);
std::cout << "-----------------------------------------" << std::endl;
std::cout << "VtArray:" << std::endl;
std::cout << tmp << std::endl;
// Verify Result.
TF_VERIFY(attr.Get(&vtVecIn),
"VtArray: Failed to get property value at %s",
propPath.c_str());
TF_VERIFY(vtVecIn[0] == vtVecOut[0],
"VtArray: VtVec3d[0] does not match %s",
propPath.c_str());
// --------------------------------------------------------------------- //
// Get & Set the value as a VtDictionary (Dictionary composition semantics
// are exercised in testUsdMetadata).
// --------------------------------------------------------------------- //
VtDictionary inDict;
inDict["$Side"] = "R";
TF_VERIFY(!prim.HasAuthoredMetadata(SdfFieldKeys->PrefixSubstitutions));
TF_VERIFY(prim.SetMetadata(SdfFieldKeys->PrefixSubstitutions, inDict));
VtDictionary outDict;
TF_VERIFY(prim.HasAuthoredMetadata(SdfFieldKeys->PrefixSubstitutions));
// Verify bug 97783 - GetMetadata should return true if Usd was able to
// retrieve/compose a VtDictionary.
TF_VERIFY(prim.GetMetadata(SdfFieldKeys->PrefixSubstitutions,&outDict));
TF_VERIFY(inDict == outDict);
std::cout << "-----------------------------------------" << std::endl;
std::cout << "VtDictionary:" << std::endl;
tmp = "";
layer->ExportToString(&tmp);
std::cout << tmp << std::endl;
}
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;
}
GfVec3d GfApplyGamma(const GfVec3d &v, double g) {
return GfVec3d(pow(v[0],g),pow(v[1],g),pow(v[2],g));
}
void
My_TestGLDrawing::DrawTest(bool offscreen)
{
std::cout << "My_TestGLDrawing::DrawTest()\n";
HdPerfLog& perfLog = HdPerfLog::GetInstance();
perfLog.Enable();
// Reset all counters we care about.
perfLog.ResetCache(HdTokens->extent);
perfLog.ResetCache(HdTokens->points);
perfLog.ResetCache(HdTokens->topology);
perfLog.ResetCache(HdTokens->transform);
perfLog.SetCounter(UsdImagingTokens->usdVaryingExtent, 0);
perfLog.SetCounter(UsdImagingTokens->usdVaryingPrimvar, 0);
perfLog.SetCounter(UsdImagingTokens->usdVaryingTopology, 0);
perfLog.SetCounter(UsdImagingTokens->usdVaryingVisibility, 0);
perfLog.SetCounter(UsdImagingTokens->usdVaryingXform, 0);
int width = GetWidth(), height = GetHeight();
double aspectRatio = double(width)/height;
GfFrustum frustum;
frustum.SetPerspective(60.0, aspectRatio, 1, 100000.0);
GfMatrix4d viewMatrix;
viewMatrix.SetIdentity();
viewMatrix *= GfMatrix4d().SetRotate(GfRotation(GfVec3d(0, 1, 0), _rotate[0]));
viewMatrix *= GfMatrix4d().SetRotate(GfRotation(GfVec3d(1, 0, 0), _rotate[1]));
viewMatrix *= GfMatrix4d().SetTranslate(GfVec3d(_translate[0], _translate[1], _translate[2]));
GfMatrix4d projMatrix = frustum.ComputeProjectionMatrix();
GfMatrix4d modelViewMatrix = viewMatrix;
if (UsdGeomGetStageUpAxis(_stage) == UsdGeomTokens->z) {
// rotate from z-up to y-up
modelViewMatrix =
GfMatrix4d().SetRotate(GfRotation(GfVec3d(1.0,0.0,0.0), -90.0)) *
modelViewMatrix;
}
GfVec4d viewport(0, 0, width, height);
_engine->SetCameraState(modelViewMatrix, projMatrix, viewport);
size_t i = 0;
TF_FOR_ALL(timeIt, GetTimes()) {
UsdTimeCode time = *timeIt;
if (*timeIt == -999) {
time = UsdTimeCode::Default();
}
UsdImagingGLRenderParams params;
params.drawMode = GetDrawMode();
params.enableLighting = IsEnabledTestLighting();
params.enableIdRender = IsEnabledIdRender();
params.frame = time;
params.complexity = _GetComplexity();
params.cullStyle = IsEnabledCullBackfaces() ?
UsdImagingGLCullStyle::CULL_STYLE_BACK :
UsdImagingGLCullStyle::CULL_STYLE_NOTHING;
glViewport(0, 0, width, height);
glEnable(GL_DEPTH_TEST);
if(IsEnabledTestLighting()) {
if(UsdImagingGLEngine::IsHydraEnabled()) {
_engine->SetLightingState(_lightingContext);
} else {
_engine->SetLightingStateFromOpenGL();
}
}
if (!GetClipPlanes().empty()) {
params.clipPlanes = GetClipPlanes();
for (size_t i=0; i<GetClipPlanes().size(); ++i) {
glEnable(GL_CLIP_PLANE0 + i);
}
}
GfVec4f const &clearColor = GetClearColor();
GLfloat clearDepth[1] = { 1.0f };
// Make sure we render to convergence.
TfErrorMark mark;
do {
glClearBufferfv(GL_COLOR, 0, clearColor.data());
glClearBufferfv(GL_DEPTH, 0, clearDepth);
_engine->Render(_stage->GetPseudoRoot(), params);
} while (!_engine->IsConverged());
TF_VERIFY(mark.IsClean(), "Errors occurred while rendering!");
std::cout << "itemsDrawn " << perfLog.GetCounter(HdTokens->itemsDrawn) << std::endl;
std::cout << "totalItemCount " << perfLog.GetCounter(HdTokens->totalItemCount) << std::endl;
std::string imageFilePath = GetOutputFilePath();
if (!imageFilePath.empty()) {
if (time != UsdTimeCode::Default()) {
std::stringstream suffix;
suffix << "_" << std::setw(3) << std::setfill('0') << params.frame << ".png";
imageFilePath = TfStringReplace(imageFilePath, ".png", suffix.str());
}
std::cout << imageFilePath << "\n";
WriteToFile("color", imageFilePath);
}
i++;
}
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;
}
