def setUp(self): self.stage = Usd.Stage.CreateInMemory() instancer = UsdGeom.PointInstancer.Define(self.stage, '/MyPointInstancer') prototypesPrim = self.stage.DefinePrim(instancer.GetPath().AppendChild('prototypes')) prototypesPrimPath = prototypesPrim.GetPath() # A cube at the origin that is of length 1 in each dimension. originCube = self._AddCubeModel(self.stage, prototypesPrimPath.AppendChild('OriginCube')) # A cube at the origin with a scale xformOp that makes it of length 5 # in each dimension. originScaledCube = self._AddCubeModel(self.stage, prototypesPrimPath.AppendChild('OriginScaledCube')) xformable = UsdGeom.Xformable(originScaledCube) xformable.AddScaleOp().Set(Gf.Vec3f(5.0)) # A cube with a translate xformOp that is of length 1 in each dimension. translatedCube = self._AddCubeModel(self.stage, prototypesPrimPath.AppendChild('TranslatedCube')) xformable = UsdGeom.Xformable(translatedCube) xformable.AddTranslateOp().Set(Gf.Vec3d(3.0, 6.0, 9.0)) # A cube with a rotateZ xformOp that is of length 1 in each dimension. rotatedCube = self._AddCubeModel(self.stage, prototypesPrimPath.AppendChild('RotatedCube')) xformable = UsdGeom.Xformable(rotatedCube) xformable.AddRotateZOp().Set(45.0) instancer.CreatePrototypesRel().SetTargets([ originCube.GetPath(), originScaledCube.GetPath(), translatedCube.GetPath(), rotatedCube.GetPath() ]) self.instancer = instancer
def createSimpleXformScene(): '''Create a simple scene with a trivial hierarchy: A translation (1, 2, 3) |_B translation (7, 8, 9) ''' psPathStr = mayaUsd_createStageWithNewLayer.createStageWithNewLayer() psPath = ufe.PathString.path(psPathStr) ps = ufe.Hierarchy.createItem(psPath) stage = mayaUsd.lib.GetPrim(psPathStr).GetStage() aPrim = stage.DefinePrim('/A', 'Xform') aXformable = UsdGeom.Xformable(aPrim) aXlateOp = aXformable.AddTranslateOp() aXlation = Gf.Vec3d(1, 2, 3) aXlateOp.Set(aXlation) aUsdUfePathStr = psPathStr + ',/A' aUsdUfePath = ufe.PathString.path(aUsdUfePathStr) aUsdItem = ufe.Hierarchy.createItem(aUsdUfePath) bPrim = stage.DefinePrim('/A/B', 'Xform') bXformable = UsdGeom.Xformable(bPrim) bXlateOp = bXformable.AddTranslateOp() bXlation = Gf.Vec3d(7, 8, 9) bXlateOp.Set(bXlation) bUsdUfePathStr = aUsdUfePathStr + '/B' bUsdUfePath = ufe.PathString.path(bUsdUfePathStr) bUsdItem = ufe.Hierarchy.createItem(bUsdUfePath) return (ps, aXlateOp, aXlation, aUsdUfePathStr, aUsdUfePath, aUsdItem, bXlateOp, bXlation, bUsdUfePathStr, bUsdUfePath, bUsdItem)
def createTransformAttributesSection(self, sectionName, attrsToAdd): # Get the xformOp order and add those attributes (in order) # followed by the xformOp order attribute. allAttrs = self.attrS.attributeNames geomX = UsdGeom.Xformable(self.prim) xformOps = geomX.GetOrderedXformOps() xformOpOrderNames = [op.GetOpName() for op in xformOps] xformOpOrderNames.append(UsdGeom.Tokens.xformOpOrder) # Don't use createSection because we want a sub-sections. with ufeAeTemplate.Layout(self, sectionName): with ufeAeTemplate.Layout(self, 'Transform Attributes'): attrsToAdd.remove(UsdGeom.Tokens.xformOpOrder) self.addControls(xformOpOrderNames) # Get the remainder of the xformOps and add them in an Unused section. xformOpUnusedNames = fnmatch.filter(allAttrs, 'xformOp:*') xformOpUnusedNames = [ ele for ele in xformOpUnusedNames if ele not in xformOpOrderNames ] self.createSection('Unused Transform Attributes', xformOpUnusedNames, collapse=True) # Then add any reamining Xformable attributes self.addControls(attrsToAdd) # Add a custom control for UFE attribute changed. t3dObs = UfeAttributesObserver(self.item) self.defineCustom(t3dObs)
def test_mass_rigid_body_cube_compound(self): self.setup_scene() # top level xform - rigid body self.xform = UsdGeom.Xform.Define(self.stage, "/xform") rigidBodyAPI = UsdPhysics.RigidBodyAPI.Apply(self.xform.GetPrim()) # Create test collider cube0 self.cube = UsdGeom.Cube.Define(self.stage, "/xform/cube0") self.cube.GetSizeAttr().Set(1.0) UsdPhysics.CollisionAPI.Apply(self.cube.GetPrim()) self.cube.AddTranslateOp().Set(Gf.Vec3f(0, 0, -2.0)) # Create test colli self.cube2 = UsdGeom.Cube.Define(self.stage, "/xform/cube1") self.cube2.GetSizeAttr().Set(1.0) UsdPhysics.CollisionAPI.Apply(self.cube2.GetPrim()) self.cube2.AddTranslateOp().Set(Gf.Vec3f(0, 0, 2.0)) self.rigidBodyWorldTransform = UsdGeom.Xformable( self.xform.GetPrim()).ComputeLocalToWorldTransform( Usd.TimeCode.Default()) self.rigidBodyPrim = self.xform.GetPrim() self.compare_mass_information(rigidBodyAPI, 1000.0 * 2.0, expectedCoM=Gf.Vec3f(0.0))
def test_mass_rigid_body_cube_rigid_body_principal_axes(self): self.setup_scene() # top level xform - rigid body self.xform = UsdGeom.Xform.Define(self.stage, "/xform") rigidBodyAPI = UsdPhysics.RigidBodyAPI.Apply(self.xform.GetPrim()) massAPI = UsdPhysics.MassAPI.Apply(self.xform.GetPrim()) # custom principal axes massAPI.GetPrincipalAxesAttr().Set(Gf.Quatf(0.707, 0.0, 0.707, 0.0)) # Create test collider cube self.cube = UsdGeom.Cube.Define(self.stage, "/xform/cube") self.cube.GetSizeAttr().Set(1.0) UsdPhysics.CollisionAPI.Apply(self.cube.GetPrim()) self.rigidBodyWorldTransform = UsdGeom.Xformable( self.xform.GetPrim()).ComputeLocalToWorldTransform( Usd.TimeCode.Default()) self.rigidBodyPrim = self.xform.GetPrim() self.compare_mass_information(rigidBodyAPI, 1000.0, expectedPrincipalAxes=Gf.Quatf( 0.707, 0.0, 0.707, 0.0))
def test_mass_rigid_body_cube_inertia_precedence(self): self.setup_scene() # top level xform - rigid body self.xform = UsdGeom.Xform.Define(self.stage, "/xform") rigidBodyAPI = UsdPhysics.RigidBodyAPI.Apply(self.xform.GetPrim()) massAPI = UsdPhysics.MassAPI.Apply(self.xform.GetPrim()) # custom inertia (has precedence) massAPI.GetDiagonalInertiaAttr().Set(Gf.Vec3f(2.0)) # Create test collider cube self.cube = UsdGeom.Cube.Define(self.stage, "/xform/cube") self.cube.GetSizeAttr().Set(1.0) UsdPhysics.CollisionAPI.Apply(self.cube.GetPrim()) massAPI = UsdPhysics.MassAPI.Apply(self.cube.GetPrim()) # custom inertia massAPI.GetDiagonalInertiaAttr().Set(Gf.Vec3f(1.0)) self.rigidBodyWorldTransform = UsdGeom.Xformable( self.xform.GetPrim()).ComputeLocalToWorldTransform( Usd.TimeCode.Default()) self.rigidBodyPrim = self.xform.GetPrim() self.compare_mass_information(rigidBodyAPI, 1000.0, expectedInertia=Gf.Vec3f(2.0))
def test_mass_rigid_body_cube_mass_precedence(self): self.setup_scene() # top level xform - rigid body self.xform = UsdGeom.Xform.Define(self.stage, "/xform") rigidBodyAPI = UsdPhysics.RigidBodyAPI.Apply(self.xform.GetPrim()) massAPI = UsdPhysics.MassAPI.Apply(self.xform.GetPrim()) # increase the mass twice (has a precedence) massAPI.GetMassAttr().Set(2000.0) # Create test collider cube self.cube = UsdGeom.Cube.Define(self.stage, "/xform/cube") self.cube.GetSizeAttr().Set(1.0) UsdPhysics.CollisionAPI.Apply(self.cube.GetPrim()) massAPI = UsdPhysics.MassAPI.Apply(self.cube.GetPrim()) # increase the mass twice massAPI.GetMassAttr().Set(500.0) self.rigidBodyWorldTransform = UsdGeom.Xformable( self.xform.GetPrim()).ComputeLocalToWorldTransform( Usd.TimeCode.Default()) self.rigidBodyPrim = self.xform.GetPrim() self.compare_mass_information(rigidBodyAPI, 2000.0, expectedCoM=Gf.Vec3f(0.0), expectedInertia=Gf.Vec3f(166.667 * 2.0))
def test_mass_rigid_body_cube_material_density(self): self.setup_scene() # top level xform - rigid body self.xform = UsdGeom.Xform.Define(self.stage, "/xform") rigidBodyAPI = UsdPhysics.RigidBodyAPI.Apply(self.xform.GetPrim()) # Create test collider cube self.cube = UsdGeom.Cube.Define(self.stage, "/xform/cube") self.cube.GetSizeAttr().Set(1.0) UsdPhysics.CollisionAPI.Apply(self.cube.GetPrim()) # Create base physics material self.basePhysicsMaterial = UsdShade.Material.Define( self.stage, "/basePhysicsMaterial") materialAPI = UsdPhysics.MaterialAPI.Apply( self.basePhysicsMaterial.GetPrim()) # set half the default gravity materialAPI.GetDensityAttr().Set(500.0) bindingAPI = UsdShade.MaterialBindingAPI.Apply(self.cube.GetPrim()) bindingAPI.Bind(self.basePhysicsMaterial, UsdShade.Tokens.weakerThanDescendants, "physics") self.rigidBodyWorldTransform = UsdGeom.Xformable( self.xform.GetPrim()).ComputeLocalToWorldTransform( Usd.TimeCode.Default()) self.rigidBodyPrim = self.xform.GetPrim() self.compare_mass_information(rigidBodyAPI, 500.0, expectedCoM=Gf.Vec3f(0.0), expectedInertia=Gf.Vec3f(166.667 * 0.5))
def testXformOpsNonIdentity(self): assembly = self._stage.GetPrimAtPath('/XformOpAssembly_NonIdentity') xformable = UsdGeom.Xformable(assembly) self.assertEqual(xformable.GetXformOpOrderAttr().Get(), Vt.TokenArray(["xformOp:translate"])) self.assertEqual(xformable.GetLocalTransformation(), Gf.Matrix4d().SetTranslate(Gf.Vec3d(7.0, 8.0, 9.0)))
def verifyMergeToUsd(): # Edit will re-allocate anything that was under pulled prim due to deactivation # Grab new references for /A/B prim bUsdPrim = mayaUsd.ufe.ufePathToPrim(bUsdUfePathStr) bXlateOp = UsdGeom.Xformable(bUsdPrim).GetOrderedXformOps()[0] # Check that edits have been preserved in USD. for (usdUfePathStr, mayaMatrix, xlateOp) in \ zip([aUsdUfePathStr, bUsdUfePathStr], [aMayaMatrix, bMayaMatrix], [aXlateOp, bXlateOp]): usdMatrix = xlateOp.GetOpTransform( mayaUsd.ufe.getTime(usdUfePathStr)) mayaValues = [v for v in mayaMatrix] usdValues = [v for row in usdMatrix for v in row] assertVectorAlmostEqual(self, mayaValues, usdValues) # There no longer are any Maya to USD path mappings. for mayaPath in [aMayaPath, bMayaPath]: self.assertEqual(len(mayaToUsd.fromHost(mayaPath)), 0) # Hierarchy is restored: USD item is child of proxy shape, Maya item is # not. Be careful to use the Maya path rather than the Maya item, which # should no longer exist. self.assertIn(aUsdItem, psHier.children()) self.assertNotIn(aMayaPath, [child.path() for child in psHier.children()]) # Maya nodes are removed. for mayaPathStr in [aMayaPathStr, bMayaPathStr]: with self.assertRaises(RuntimeError): om.MSelectionList().add(mayaPathStr)
def add_xform(app, params, path_for_objects, create_ref, stage, obj, root_path, is_instance=False): if DEBUG_MODE: imp.reload(utils) # we should create a new stage and reference the old one to this new opt_animation = params.get("animation", None) if create_ref: new_stage_name = obj.FullName + "." + utils.get_extension_from_params(params) stage_asset_path = path_for_objects + new_stage_name new_stage = Usd.Stage.CreateNew(stage_asset_path) utils.add_stage_metadata(new_stage, params) # add dfault root xform node for this new stage usd_xform = UsdGeom.Xform.Define(new_stage, "/" + obj.Name) # reference main stage to this new stage ref = stage.DefinePrim(root_path + "/" + obj.Name) ref.GetReferences().AddReference("./" + utils.get_last_folder(path_for_objects) + "/" + new_stage_name, "/" + obj.Name) if is_instance: ref.SetInstanceable(True) refXform = UsdGeom.Xformable(ref) add_visibility_to_xfo(refXform, obj) else: usd_xform = UsdGeom.Xform.Define(stage, root_path + "/" + obj.Name) add_visibility_to_xfo(usd_xform, obj) if create_ref: add_transform_to_xfo(refXform, obj, opt_animation) else: add_transform_to_xfo(usd_xform, obj, opt_animation) if create_ref: return usd_xform, new_stage, stage_asset_path else: return usd_xform, None, None
def checkParentDone(): # The xform now has the capsule as its child. xformChildren = xformHier.children() self.assertEqual(len(xformChildren), 1) self.assertIn('Capsule1', childrenNames(xformChildren)) # Confirm that the capsule has not moved in world space. Must # re-create the prim and its scene item, as its path has changed. capsulePath = ufe.Path([ proxyShapePathSegment, usdUtils.createUfePathSegment('/Xform1/Capsule1') ]) capsulePrim = mayaUsd.ufe.ufePathToPrim( ufe.PathString.string(capsulePath)) capsuleXformable = UsdGeom.Xformable(capsulePrim) capsuleItem = ufe.Hierarchy.createItem(capsulePath) capsuleT3d = ufe.Transform3d.transform3d(capsuleItem) capsuleWorld = capsuleT3d.inclusiveMatrix() assertVectorAlmostEqual(self, capsuleWorldPre, matrixToList(capsuleWorld), places=6) # Using setMatrixCmd() on a common transform API prim will set # translate, rotate, and scale. self.assertEqual( capsuleXformable.GetXformOpOrderAttr().Get(), Vt.TokenArray(("xformOp:translate", "xformOp:translate:pivot", "xformOp:rotateXYZ", "xformOp:scale", "!invert!xformOp:translate:pivot")))
def checkParentDone(): # The xform now has the capsule as its child. xformChildren = xformHier.children() self.assertEqual(len(xformChildren), 1) self.assertIn('Capsule1', childrenNames(xformChildren)) # Confirm that the capsule has not moved in world space. Must # re-create the prim and its scene item, as its path has changed. capsulePath = ufe.Path([ proxyShapePathSegment, usdUtils.createUfePathSegment('/Xform1/Capsule1') ]) capsulePrim = mayaUsd.ufe.ufePathToPrim( ufe.PathString.string(capsulePath)) capsuleXformable = UsdGeom.Xformable(capsulePrim) capsuleItem = ufe.Hierarchy.createItem(capsulePath) capsuleT3d = ufe.Transform3d.transform3d(capsuleItem) capsuleWorld = capsuleT3d.inclusiveMatrix() assertVectorAlmostEqual(self, capsuleWorldPre, matrixToList(capsuleWorld)) # The capsule's transform ops now have Maya fallback stack ops. A # scale fallback op is added, even though it's uniform unit. self.assertEqual( capsuleXformable.GetXformOpOrderAttr().Get(), Vt.TokenArray( ("xformOp:translate", "xformOp:rotateXYZ", "xformOp:rotateX", "xformOp:translate:maya_fallback", "xformOp:rotateXYZ:maya_fallback", "xformOp:scale:maya_fallback")))
def test_PureOvers(self): s = Usd.Stage.CreateInMemory() # Create a pure over prim and invoke various API. x = s.OverridePrim('/World') xf = UsdGeom.Xformable(x) xf.SetResetXformStack(True) xf.MakeMatrixXform().Set(Gf.Matrix4d(1.0)) xf.SetXformOpOrder(xf.GetOrderedXformOps(), False)
def get_transform(usd_item): usd_xform = UsdGeom.Xformable(usd_item) times_array = usd_xform.GetTimeSamples() # array of time samples, it empty if no animation if len(times_array) == 0: usd_transform = usd_xform.GetLocalTransformation() else: usd_transform = [usd_xform.GetLocalTransformation(t) for t in times_array] return (usd_transform, times_array)
def local_transform_from_usd_node(self, prim, unit_scale=1.0, up_axis='y', extra_rotate=None, frame=Usd.TimeCode.Default()): usd_xform = UsdGeom.Xformable(prim) usd_transform = usd_xform.GetLocalTransformation(frame) return self.transform_from_usd_transform(usd_transform, unit_scale, up_axis, extra_rotate)
def testFallbackCases(self): '''Fallback handler test cases.''' cmds.file(new=True, force=True) import mayaUsd_createStageWithNewLayer proxyShape = mayaUsd_createStageWithNewLayer.createStageWithNewLayer() proxyShapePath = ufe.PathString.path(proxyShape) proxyShapeItem = ufe.Hierarchy.createItem(proxyShapePath) proxyShapeContextOps = ufe.ContextOps.contextOps(proxyShapeItem) proxyShapeContextOps.doOp(['Add New Prim', 'Sphere']) spherePath = ufe.PathString.path('%s,/Sphere1' % proxyShape) sphereItem = ufe.Hierarchy.createItem(spherePath) sphereT3d = ufe.Transform3d.transform3d(sphereItem) spherePrim = mayaUsd.ufe.ufePathToPrim( ufe.PathString.string(spherePath)) sphereXformable = UsdGeom.Xformable(spherePrim) # Add transform ops that do not match either the Maya transform stack, # the USD common API transform stack, or a matrix stack. sphereXformable.AddTranslateOp() sphereXformable.AddTranslateOp(UsdGeom.XformOp.PrecisionFloat, "pivot") sphereXformable.AddRotateZOp() sphereXformable.AddTranslateOp(UsdGeom.XformOp.PrecisionFloat, "pivot", True) self.assertEqual( sphereXformable.GetXformOpOrderAttr().Get(), Vt.TokenArray( ("xformOp:translate", "xformOp:translate:pivot", "xformOp:rotateZ", "!invert!xformOp:translate:pivot"))) self.assertFalse(UsdGeom.XformCommonAPI(sphereXformable)) self.assertFalse(mayaUsd.lib.XformStack.MayaStack().MatchingSubstack( sphereXformable.GetOrderedXformOps())) # Select sphere. sn = ufe.GlobalSelection.get() sn.clear() sn.append(sphereItem) # Rotate sphere around X. cmds.rotate(30, 0, 0, r=True, os=True, fo=True) # Fallback interface will have added a RotXYZ transform op. self.assertEqual( sphereXformable.GetXformOpOrderAttr().Get(), Vt.TokenArray( ("xformOp:translate", "xformOp:translate:pivot", "xformOp:rotateZ", "!invert!xformOp:translate:pivot", "xformOp:rotateXYZ:maya_fallback")))
def test_InvalidXformable(self): xf = UsdGeom.Xformable() # This used to crash before the SchemaBase __getattribute__ method # was overridden to test the validity of the underlying prim. with self.assertRaises(RuntimeError): xf.ClearXformOpOrder() # It should still be safe to get the prim, but the prim will be invalid. p = xf.GetPrim() with self.assertRaises(RuntimeError): p.IsActive() # It should still be safe to get the path, but the path will be empty. self.assertEqual(xf.GetPath(), Sdf.Path())
def _AssertPrototype(self, prim, typeName, numChildren, hasInstancerTranslate): self.assertEqual(prim.GetTypeName(), typeName) self.assertEqual(len(prim.GetChildren()), numChildren) self.assertEqual(Usd.ModelAPI(prim).GetKind(), Kind.Tokens.subcomponent) xformOps = UsdGeom.Xformable(prim).GetOrderedXformOps() foundInstancerTranslate = False for op in xformOps: if op.GetOpName() == "xformOp:translate:instancerTranslate": foundInstancerTranslate = True break self.assertEqual(foundInstancerTranslate, hasInstancerTranslate)
def set_rotate(prim, rot_mat): properties = prim.GetPropertyNames() if "xformOp:rotate" in properties: rotate_attr = prim.GetAttribute("xformOp:rotate") rotate_attr.Set(rot_mat) elif "xformOp:transform" in properties: transform_attr = prim.GetAttribute("xformOp:transform") matrix = prim.GetAttribute("xformOp:transform").Get() matrix.SetRotateOnly(rot_mat.ExtractRotation()) transform_attr.Set(matrix) else: xform = UsdGeom.Xformable(prim) xform_op = xform.AddXformOp(UsdGeom.XformOp.TypeTransform, UsdGeom.XformOp.PrecisionDouble, "") xform_op.Set(Gf.Matrix4d().SetRotate(rot_mat))
def _addGround(stage, width, height): boxPrim = UsdGeom.Cube.Define(stage, '/World/ground') boxPrim.CreateDisplayColorAttr([(0.5, 0.2, 0.0)]) xformable = UsdGeom.Xformable(boxPrim) xformable.AddScaleOp().Set(Gf.Vec3f(width / 2, 0.1, height / 2)) material = UsdShade.Material.Define(stage, '/World/GroundMaterial') pbrShader = UsdShade.Shader.Define(stage, '/World/GroundMaterial/GroundShader') pbrShader.CreateIdAttr("UsdPreviewSurface") pbrShader.CreateInput("diffuseColor", Sdf.ValueTypeNames.Color3f).Set( (0.5, 0.2, 0.0)) pbrShader.CreateInput("roughness", Sdf.ValueTypeNames.Float).Set(0.9) pbrShader.CreateInput("metallic", Sdf.ValueTypeNames.Float).Set(0.0)
def test_InvalidXformOps(self): s = Usd.Stage.CreateInMemory() p = s.DefinePrim('/World', 'Xform') x = UsdGeom.Xformable(p) # Create an attribute that is not in the xformOp namespace. attr1 = p.CreateAttribute("myXformOp:transform", Sdf.ValueTypeNames.Matrix4d) self._TestInvalidXformOp(attr1) # Create an xform op with an invalid optype. attr2 = p.CreateAttribute("xformOp:translateXYZ", Sdf.ValueTypeNames.Double3) self._TestInvalidXformOp(attr2) # Create an xform op with opType=transform and typeName=Matrix4f. with self.assertRaises(RuntimeError): xformOp = x.AddTransformOp(precision=UsdGeom.XformOp.PrecisionFloat)
def spawn(self, location, rotation): stage = self.omni_kit.get_stage() prefix = "/World/Robot/STR" prim_path = omni.kit.utils.get_stage_next_free_path( stage, prefix, False) print(prim_path) self.robot_prim = stage.DefinePrim(prim_path, "Xform") self.robot_prim.GetReferences().AddReference(self.usd_path) xform = UsdGeom.Xformable(self.robot_prim) xform_op = xform.AddXformOp(UsdGeom.XformOp.TypeTransform, UsdGeom.XformOp.PrecisionDouble, "") mat = Gf.Matrix4d().SetTranslate(location) mat.SetRotateOnly(Gf.Rotation(Gf.Vec3d(0, 0, 1), rotation)) xform_op.Set(mat) self.camera_path = prim_path + "/STR/Vehicle/str_camera"
def _addGround(stage): boxPrim = UsdGeom.Cube.Define(stage, '/World/ground') boxPrim.CreateDisplayColorAttr([(0.5, 0.2, 0.0)]) xformable = UsdGeom.Xformable(boxPrim) xformable.AddScaleOp().Set(Gf.Vec3f(280.0, 0.1, 280)) material = UsdShade.Material.Define(stage, '/World/GroundMaterial') pbrShader = UsdShade.Shader.Define(stage, '/World/GroundMaterial/GroundShader') pbrShader.CreateIdAttr("UsdPreviewSurface") pbrShader.CreateInput("diffuseColor", Sdf.ValueTypeNames.Color3f).Set( (0.5, 0.2, 0.0)) pbrShader.CreateInput("roughness", Sdf.ValueTypeNames.Float).Set(0.9) pbrShader.CreateInput("metallic", Sdf.ValueTypeNames.Float).Set(0.0) material.CreateSurfaceOutput().ConnectToSource(pbrShader, "surface") UsdShade.MaterialBindingAPI(boxPrim).Bind(material)
def test_mass_rigid_body_cube(self): self.setup_scene() # Create test collider cube self.cube = UsdGeom.Cube.Define(self.stage, "/cube") self.cube.GetSizeAttr().Set(1.0) UsdPhysics.CollisionAPI.Apply(self.cube.GetPrim()) rigidBodyAPI = UsdPhysics.RigidBodyAPI.Apply(self.cube.GetPrim()) self.rigidBodyWorldTransform = UsdGeom.Xformable( self.cube.GetPrim()).ComputeLocalToWorldTransform( Usd.TimeCode.Default()) self.rigidBodyPrim = self.cube.GetPrim() self.compare_mass_information(rigidBodyAPI, 1000.0, expectedCoM=Gf.Vec3f(0.0), expectedInertia=Gf.Vec3f(166.667))
def set_translate(prim, new_loc): properties = prim.GetPropertyNames() if "xformOp:translate" in properties: translate_attr = prim.GetAttribute("xformOp:translate") translate_attr.Set(new_loc) elif "xformOp:translation" in properties: translation_attr = prim.GetAttribute("xformOp:translate") translation_attr.Set(new_loc) elif "xformOp:transform" in properties: transform_attr = prim.GetAttribute("xformOp:transform") matrix = prim.GetAttribute("xformOp:transform").Get() matrix.SetTranslateOnly(new_loc) transform_attr.Set(matrix) else: xform = UsdGeom.Xformable(prim) xform_op = xform.AddXformOp(UsdGeom.XformOp.TypeTransform, UsdGeom.XformOp.PrecisionDouble, "") xform_op.Set(Gf.Matrix4d().SetTranslate(new_loc))
def mass_information_fn(self, prim): massInfo = UsdPhysics.RigidBodyAPI.MassInformation() if prim.IsA(UsdGeom.Cube): cubeLocalToWorldTransform = UsdGeom.Xformable( prim).ComputeLocalToWorldTransform(Usd.TimeCode.Default()) extents = Gf.Transform(cubeLocalToWorldTransform).GetScale() cube = UsdGeom.Cube(prim) sizeAttr = cube.GetSizeAttr().Get() sizeAttr = abs(sizeAttr) extents = extents * sizeAttr # cube volume massInfo.volume = extents[0] * extents[1] * extents[2] # cube inertia inertia_diagonal = Gf.Vec3f( 1.0 / 12.0 * (extents[1] * extents[1] + extents[2] * extents[2]), 1.0 / 12.0 * (extents[0] * extents[0] + extents[2] * extents[2]), 1.0 / 12.0 * (extents[0] * extents[0] + extents[1] * extents[1])) massInfo.inertia = Gf.Matrix3f(1.0) massInfo.inertia.SetDiagonal(inertia_diagonal) # CoM massInfo.centerOfMass = Gf.Vec3f(0.0) # local pose if prim == self.rigidBodyPrim: massInfo.localPos = Gf.Vec3f(0.0) massInfo.localRot = Gf.Quatf(1.0) else: # massInfo.localPos, massInfo.localRot lp, lr = self.get_collision_shape_local_transfrom( cubeLocalToWorldTransform, self.rigidBodyWorldTransform) massInfo.localPos = Gf.Vec3f(lp) massInfo.localRot = Gf.Quatf(lr) else: print("UsdGeom type not supported.") massInfo.volume = -1.0 return massInfo
def _ValidateXformOps(self, prim, expectedTranslation=None): xformable = UsdGeom.Xformable(prim) self.assertTrue(xformable) xformOps = xformable.GetOrderedXformOps() if expectedTranslation is None: self.assertEqual(len(xformOps), 0) return xformable self.assertEqual(len(xformOps), 1) translateOp = xformOps[0] self.assertEqual(translateOp.GetOpName(), 'xformOp:translate') self.assertEqual(translateOp.GetOpType(), UsdGeom.XformOp.TypeTranslate) self.assertTrue(Gf.IsClose(translateOp.Get(), expectedTranslation, 1e-6)) return xformable
def TestUsd4957(): """ Tests the case in which a prim has an xform directly on it and its bounding box relative to one of its ancestors is computed using ComputeRelativeBound(). """ s = Usd.Stage.Open("testUSD4957.usda") b = s.GetPrimAtPath("/A/B") c = s.GetPrimAtPath("/A/B/C") bc = UsdGeom.BBoxCache(Usd.TimeCode.Default(), ['default', 'render']) # Call the function being tested relativeBbox = bc.ComputeRelativeBound(c, b) # Compare the result with the bbox of C in its local space cExtent = UsdGeom.Boundable(c).GetExtentAttr().Get() cRange = Gf.Range3d(Gf.Vec3d(cExtent[0]), Gf.Vec3d(cExtent[1])) cLocalXform = UsdGeom.Xformable(c).GetLocalTransformation() cBbox = Gf.BBox3d(cRange, cLocalXform) AssertBBoxesClose(relativeBbox, cBbox, "ComputeRelativeBound produced a wrong bbox.")
def createTransformAttributesSection(self): # Get the xformOp order and add those attributes (in order) # followed by the xformOp order attribute. prim = mayaUsd.ufe.getPrimFromRawItem(self.item.getRawAddress()) geomX = UsdGeom.Xformable(prim) xformOps = geomX.GetOrderedXformOps() xformOpOrderNames = [op.GetOpName() for op in xformOps] xformOpOrderNames.append(UsdGeom.Tokens.xformOpOrder) # Don't use createSection because we want a sub-section for Unused. with ufeAeTemplate.Layout(self, 'Transform Attributes'): self.addControls(xformOpOrderNames) # Get the remainder of the xformOps and add them in an Unused section. allAttrs = self.attrS.attributeNames xformOpUnusedNames = fnmatch.filter(allAttrs, 'xformOp:*') xformOpUnusedNames = [ ele for ele in xformOpUnusedNames if ele not in xformOpOrderNames ] self.createSection('Unused Transform Attributes', xformOpUnusedNames, collapse=True)