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; }