def _ValidateAllAttributes(self, usdPrim, exportedAttrsDict): """ Validates that USD attributes, primvars, and UsdRi attributes exist, have the correct value, and have the correct type for each attribute prefix in exportedAttrsDict. """ self.assertTrue(usdPrim) gprim = UsdGeom.Gprim(usdPrim) self.assertTrue(gprim) # Do a quick check to see whether we have the right number of attributes # by counting the primvars and UsdRi attributes. # Getting all primvars will also include the built-in displayColor, # displayOpacity, and st, so we add 3 to the length of the # exportedAttrsDict for that check. primvars = gprim.GetPrimvars() self.assertEqual(len(primvars), len(exportedAttrsDict) + 3) riStatements = UsdRi.Statements(usdPrim) self.assertTrue(riStatements) riAttrs = riStatements.GetRiAttributes() self.assertEqual(len(riAttrs), len(exportedAttrsDict)) # UsdRi attributes store vector and point array data as just arrays of # three doubles/floats. riAttrMapping = { Sdf.ValueTypeNames.Vector3dArray: Sdf.ValueTypeNames.Double3Array, Sdf.ValueTypeNames.Vector3fArray: Sdf.ValueTypeNames.Float3Array, Sdf.ValueTypeNames.Point3dArray: Sdf.ValueTypeNames.Double3Array, Sdf.ValueTypeNames.Point3fArray: Sdf.ValueTypeNames.Float3Array } for attrPrefix in exportedAttrsDict: # Test regular USD attributes. usdAttr = usdPrim.GetAttribute('userProperties:%sUsdAttr' % attrPrefix) value = exportedAttrsDict[attrPrefix]['value'] self.assertTrue(usdAttr) self.assertEqual(usdAttr.GetTypeName(), exportedAttrsDict[attrPrefix]['typeName']) self.assertTrue(usdAttr.IsCustom()) self._assertAlmostEqualWithFallback(usdAttr.Get(), value) # Test primvars. primvar = gprim.GetPrimvar('%sPrimvar' % attrPrefix) self.assertTrue(primvar) self.assertTrue(UsdGeom.Primvar.IsPrimvar(primvar)) self._assertAlmostEqualWithFallback(primvar.Get(), value) self.assertEqual(primvar.GetTypeName(), exportedAttrsDict[attrPrefix]['typeName']) # Test UsdRi attributes. riAttr = usdPrim.GetAttribute('ri:attributes:user:%sUsdRiAttr' % attrPrefix) self.assertTrue(riAttr) self.assertTrue(UsdRi.Statements.IsRiAttribute(riAttr)) self._assertAlmostEqualWithFallback(riAttr.Get(), value) riAttrType = exportedAttrsDict[attrPrefix]['typeName'] riAttrType = riAttrMapping.get(riAttrType, riAttrType) self.assertEqual(riAttr.GetTypeName(), riAttrType)
def _AssertDisplayColorEqual(self, prim, expectedColor): # expectedColor should be given as a list, so turn it into the type we'd # expect to get out of the displayColor attribute, namely a VtVec3fArray. expectedColor = Vt.Vec3fArray(1, expectedColor) gprim = UsdGeom.Gprim(prim) self.assertTrue(gprim) displayColorPrimvar = gprim.GetDisplayColorPrimvar() self.assertTrue(displayColorPrimvar) self.assertEqual(displayColorPrimvar.ComputeFlattened(), expectedColor)
def _SetDisplayColor(mesh, color): from pxr import UsdGeom # DisplayColor is actually an array. Here, we just author one color which # applies to the whole mesh. UsdGeom.Gprim(mesh).CreateDisplayColorAttr([color])
def testExportAttributeTypes(self): """ Tests that attributes tagged to be exported as different attribute types (Usd attributes, primvars, UsdRi attributes) are exported correctly. """ stage = self._GetExportedStage() prim = stage.GetPrimAtPath('/UserExportedAttributesTest/Geom/CubeTypedAttrs') self.assertTrue(prim) # Validate Usd attributes. attrName = 'userProperties:myIntArrayAttr' attr = prim.GetAttribute(attrName) self.assertTrue(attr) expectedValue = Vt.IntArray([99, 98, 97, 96, 95, 94, 93, 92, 91, 90]) self.assertEqual(attr.Get(), expectedValue) self.assertEqual(attr.GetTypeName(), Sdf.ValueTypeNames.IntArray) self.assertTrue(attr.IsCustom()) # Validate UsdRi attributes. expectedRiAttrs = { 'ri:attributes:user:myIntRiAttr': {'value': 42, 'typeName': Sdf.ValueTypeNames.Int}, 'ri:attributes:user:myNamespace:myAttr': {'value': 'UsdRi string', 'typeName': Sdf.ValueTypeNames.String}, 'ri:attributes:user:myStringArrayRiAttr': {'value': Vt.StringArray(['the', 'quick', 'brown', 'fox']), 'typeName': Sdf.ValueTypeNames.StringArray}, } expectedRiAttrNames = set(expectedRiAttrs.keys()) riStatements = UsdRi.Statements(prim) self.assertTrue(riStatements) riAttrs = riStatements.GetRiAttributes() self.assertEqual(len(riAttrs), 3) riAttrNames = {attr.GetName() for attr in riAttrs} self.assertEqual(riAttrNames, expectedRiAttrNames) for riAttrName in expectedRiAttrs: riAttr = prim.GetAttribute(riAttrName) self.assertTrue(riAttr) self.assertTrue(UsdRi.Statements.IsRiAttribute(riAttr)) self.assertEqual(riAttr.Get(), expectedRiAttrs[riAttrName]['value']) self.assertEqual(riAttr.GetTypeName(), expectedRiAttrs[riAttrName]['typeName']) # Validate primvars. expectedPrimvars = { 'myConstantIntPrimvar': {'value': 123, 'typeName': Sdf.ValueTypeNames.Int, 'interpolation': UsdGeom.Tokens.constant}, 'myFaceVaryingIntPrimvar': {'value': 999, 'typeName': Sdf.ValueTypeNames.Int, 'interpolation': UsdGeom.Tokens.faceVarying}, 'myFloatArrayPrimvar': {'value': Vt.FloatArray([1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8]), 'typeName': Sdf.ValueTypeNames.FloatArray, 'interpolation': UsdGeom.Tokens.vertex}, 'myStringPrimvar': {'value': 'no interp string', 'typeName': Sdf.ValueTypeNames.String, 'interpolation': None}, 'myUniformDoublePrimvar': {'value': 3.140, 'typeName': Sdf.ValueTypeNames.Double, 'interpolation': UsdGeom.Tokens.uniform}, 'myVertexStringPrimvar': {'value': 'a vertex string', 'typeName': Sdf.ValueTypeNames.String, 'interpolation': UsdGeom.Tokens.vertex}, } expectedPrimvarNames = set(expectedPrimvars.keys()) # Getting all primvars will also include the built-in displayColor, # displayOpacity, and st. expectedPrimvarNames.update(['displayColor', 'displayOpacity', 'st']) gprim = UsdGeom.Gprim(prim) self.assertTrue(gprim) primvars = gprim.GetPrimvars() self.assertEqual(len(primvars), 9) primvarNames = {primvar.GetPrimvarName() for primvar in primvars} self.assertEqual(primvarNames, expectedPrimvarNames) for primvarName in expectedPrimvars: primvar = gprim.GetPrimvar(primvarName) self.assertTrue(primvar) self.assertTrue(UsdGeom.Primvar.IsPrimvar(primvar)) self._assertAlmostEqualWithFallback( primvar.Get(), expectedPrimvars[primvarName]['value']) self.assertEqual(primvar.GetTypeName(), expectedPrimvars[primvarName]['typeName']) expectedInterpolation = expectedPrimvars[primvarName]['interpolation'] if expectedInterpolation is None: self.assertFalse(primvar.HasAuthoredInterpolation()) else: self.assertTrue(primvar.HasAuthoredInterpolation()) self.assertEqual(primvar.GetInterpolation(), expectedInterpolation)
def Main(): s = Usd.Stage.CreateInMemory() # Setup a quad mesh gprim = s.DefinePrim("/Model/Geom/Mesh", "Mesh") gprim.GetAttribute("faceVertexCounts").Set([4]) gprim.GetAttribute("faceVertexIndices").Set([0, 1, 3, 2]) gprim.GetAttribute("points").Set([(-2, -2, -2), (2, -2, -2), (-2, -2, 2), (2, -2, 2)]) UsdGeom.Gprim(gprim).CreatePrimvar( "somePrimvar", Sdf.ValueTypeNames.Color3fArray, UsdGeom.Tokens.constant).Set([1.0, 1.0, 1.0]) UsdGeom.Gprim(gprim).CreatePrimvar("map1", Sdf.ValueTypeNames.Float2Array, UsdGeom.Tokens.faceVarying).Set( [1.0, 1.0]) lookPrim = UsdShade.Look.Define(s, "/Model/Looks/Pbs") lookPrim.Bind(gprim) # Add a Hydra shader and surface relationship from the look to the shader hydraShader = UsdHydra.Shader( UsdShade.Shader.Define(s, "/Model/Looks/Pbs/PolPbs")) hydraShader.CreateIdAttr("PolPbs_1") hydraLook = UsdHydra.LookAPI(lookPrim) hydraLook.CreateBxdfRel().SetTargets([hydraShader.GetPath()]) uv = UsdHydra.Primvar( UsdShade.Shader.Define(s, "/Model/Looks/Pbs/UvPrimvar")) attr = uv.CreateVarnameAttr("map1") faceIndex = UsdHydra.Primvar( UsdShade.Shader.Define(s, "/Model/Looks/Pbs/FaceIndexPrimvar")) attr = uv.CreateVarnameAttr("ptexFaceIndex") faceOffset = UsdHydra.Primvar( UsdShade.Shader.Define(s, "/Model/Looks/Pbs/FaceOffsetPrimvar")) attr = uv.CreateVarnameAttr("ptexFaceOffset") tex = UsdHydra.UvTexture( UsdShade.Shader.Define(s, "/Model/Looks/Pbs/UvTex")) tex.CreateIdAttr("HwUvTexture_1") tex.CreateWrapSAttr(UsdHydra.Tokens.clamp) tex.CreateWrapTAttr(UsdHydra.Tokens.repeat) tex.CreateMinFilterAttr(UsdHydra.Tokens.linearMipmapLinear) tex.CreateMagFilterAttr(UsdHydra.Tokens.linear) tex.CreateTextureMemoryAttr(100.0) tex.CreateFilenameAttr("/foo/bar.jpg") tex.CreateParameter("outputs:color", Sdf.ValueTypeNames.Color3f) param = UsdShade.Parameter(tex.CreateUvAttr()) param.ConnectToSource(uv, "result", False) texturePath = Sdf.AssetPath("/foo.tex") ptex = UsdHydra.PtexTexture( UsdShade.Shader.Define(s, "/Model/Looks/Pbs/Ptex")) ptex.CreateIdAttr("HwPtexTexture_1") ptex.CreateTextureMemoryAttr(100.0) ptex.CreateFilenameAttr("/foo/bar.ptex") ptex.CreateParameter("outputs:color", Sdf.ValueTypeNames.Color3f) param = UsdShade.Parameter(ptex.CreateFaceIndexAttr()) param.ConnectToSource(faceIndex, "result", False) param = UsdShade.Parameter(ptex.CreateFaceOffsetAttr()) param.ConnectToSource(faceOffset, "result", False) # hydraShader.CreateFilenameAttr(Sdf.AssetPath("PbsSurface.glslfx")) # param = hydraShader.CreateParameter("colorFromUv", Sdf.ValueTypeNames.Color3f) param.ConnectToSource(tex, "color", False) # param = hydraShader.CreateParameter("colorFromPtex1", Sdf.ValueTypeNames.Color3f) param.ConnectToSource(ptex, "color", False) # color = UsdHydra.Primvar( UsdShade.Shader.Define(s, "/Model/Looks/Pbs/ColorPrimvar")) attr = uv.CreateVarnameAttr("displayColor") param = hydraShader.CreateParameter("colorFromPrimvar", Sdf.ValueTypeNames.Color3f) param.ConnectToSource(color, "result", False) print hydraShader.GetConnectedPrimvar(param.GetAttr()) print hydraShader.IsConnectedToPrimvar(param.GetAttr()) print s.GetRootLayer().ExportToString()