def test_RmanConversions(self): from pxr import UsdRi # Note that we have the old names as the first elements in # the list, our conversion test relies on this fact. This is only # really relevant in the case of Rman's '1' value, in which we have # some ambiguity(it could be cornersPlus1, cornersPlus2, or cornersOnly) # since we don't currently express the propogateCorners argument through # the system. faceVaryingConversionTable = [ (["all"], 0), (["cornersPlus1", "cornersPlus2", "cornersOnly"], 1), (["none"], 2), (["boundaries"], 3) ] for tokens, rmanValue in faceVaryingConversionTable: # Check all tokens, old and new for token in tokens: # Convert to renderman values self.assertEqual( UsdRi.ConvertToRManFaceVaryingLinearInterpolation(token), rmanValue) # Convert from renderman values # Note that we only map to the new tokens. self.assertEqual( UsdRi.ConvertFromRManFaceVaryingLinearInterpolation(rmanValue), tokens[0])
def test_Basic(self): stage = Usd.Stage.CreateInMemory() # can't use these if not properly initialized bogusSpline = UsdRi.SplineAPI() with self.assertRaises(RuntimeError): bogusSpline.Validate()[0] light = UsdLux.SphereLight.Define(stage, '/Light') rod = stage.DefinePrim("/Light/Rod", "PxrRodLightFilter") light.GetFiltersRel().SetTargets([rod.GetPath()]) # Create SplineAPI for "fallOffRamp" spline for the Rod prim falloffRamp = UsdRi.SplineAPI(rod, "falloffRamp", Sdf.ValueTypeNames.FloatArray, True) # Create SplineAPI for "colorRamp" spline for the Rod prim colorRamp = UsdRi.SplineAPI(rod, "colorRamp", Sdf.ValueTypeNames.Color3fArray, True) # initially invalid since no spline exists assert not IsValid(falloffRamp) assert not IsValid(colorRamp) # set a simple ease-out falloff spline SetEaseOut(falloffRamp) assert IsValid(falloffRamp) # try a mismatch of values & positions falloffRamp.CreateValuesAttr().Set([1.0, 0.8, 0.2]) assert not IsValid(falloffRamp) # try a bogus interpolation value SetEaseOut(falloffRamp) assert IsValid(falloffRamp) falloffRamp.CreateInterpolationAttr().Set('bogus') assert not IsValid(falloffRamp) # check all known interp types for interp in ['linear', 'constant', 'catmull-rom', 'bspline']: falloffRamp.CreateInterpolationAttr().Set(interp) assert IsValid(falloffRamp) # try non-sorted positions falloffRamp.CreatePositionsAttr().Set([1.0, 0.7, 0.3, 0.0]) assert not IsValid(falloffRamp) # set a red->green->blue color ramp colorRamp.CreateInterpolationAttr().Set(UsdRi.Tokens.linear) colorRamp.CreatePositionsAttr().Set([0.0, 0.5, 1.0]) colorRamp.CreateValuesAttr().Set([(1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (0.0, 0.0, 1.0)]) assert IsValid(colorRamp)
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 _ValidateUsdRiPxrEnvDayLight(self): lightPrimPath = '/RfMLightsTest/Lights/EnvDayLight' lightPrim = self._stage.GetPrimAtPath(lightPrimPath) self.assertTrue(lightPrim) envDayLight = UsdRi.PxrEnvDayLight(lightPrim) self.assertTrue(envDayLight) expectedDay = 8 self.assertEqual(envDayLight.GetDayAttr().Get(), expectedDay) expectedHaziness = 1.8 self.assertTrue( Gf.IsClose(envDayLight.GetHazinessAttr().Get(), expectedHaziness, 1e-6)) expectedHour = 8.8 self.assertTrue( Gf.IsClose(envDayLight.GetHourAttr().Get(), expectedHour, 1e-6)) expectedLatitude = 80.0 self.assertTrue( Gf.IsClose(envDayLight.GetLatitudeAttr().Get(), expectedLatitude, 1e-6)) expectedLongitude = -80.0 self.assertTrue( Gf.IsClose(envDayLight.GetLongitudeAttr().Get(), expectedLongitude, 1e-6)) expectedMonth = 8 self.assertEqual(envDayLight.GetMonthAttr().Get(), expectedMonth) expectedSkyTint = Gf.Vec3f(0.8) self.assertTrue( Gf.IsClose(envDayLight.GetSkyTintAttr().Get(), expectedSkyTint, 1e-6)) expectedSunDirection = Gf.Vec3f(0.0, 0.0, 0.8) self.assertTrue( Gf.IsClose(envDayLight.GetSunDirectionAttr().Get(), expectedSunDirection, 1e-6)) expectedSunSize = 0.8 self.assertTrue( Gf.IsClose(envDayLight.GetSunSizeAttr().Get(), expectedSunSize, 1e-6)) expectedSunTint = Gf.Vec3f(0.8) self.assertTrue( Gf.IsClose(envDayLight.GetSunTintAttr().Get(), expectedSunTint, 1e-6)) expectedYear = 2018 self.assertEqual(envDayLight.GetYearAttr().Get(), expectedYear) expectedZone = 8.0 self.assertTrue( Gf.IsClose(envDayLight.GetZoneAttr().Get(), expectedZone, 1e-6))
def _AddShadingToBall(stage): from pxr import Sdf, UsdRi model = stage.OverridePrim('/Ball') texDir = os.path.join(ASSET_BASE, 'Ball/tex') mesh = stage.OverridePrim('/Ball/mesh') ballTextureNode = UsdRi.RisObject( stage.OverridePrim( model.GetPath().AppendPath('Looks/BallMaterial/BallTexture'))) # now we'll show adding some shading variants to the ball as well. shadingVariantsInfo = [ ('Cue', '', _Color(0.996, 0.992, 0.874)), # white ('Ball_1', '', _Color(1.000, 0.929, 0.184)), # yellow ('Ball_2', '', _Color(0.157, 0.243, 0.631)), # blue ('Ball_3', '', _Color(0.976, 0.212, 0.141)), # red ('Ball_4', '', _Color(0.250, 0.156, 0.400)), # purple ('Ball_5', '', _Color(0.980, 0.498, 0.184)), # orange ('Ball_6', '', _Color(0.050, 0.255, 0.239)), # green ('Ball_7', '', _Color(0.607, 0.059, 0.094)), # darkred ('Ball_8', '', _Color(0.122, 0.118, 0.110)), # black ('Ball_9', 'striped', _Color(1.000, 0.929, 0.184)), # yellow ('Ball_10', 'striped', _Color(0.157, 0.243, 0.631)), # blue ('Ball_11', 'striped', _Color(0.976, 0.212, 0.141)), # red ('Ball_12', 'striped', _Color(0.250, 0.156, 0.400)), # purple ('Ball_13', 'striped', _Color(0.980, 0.498, 0.184)), # orange ('Ball_14', 'striped', _Color(0.050, 0.255, 0.239)), # green ('Ball_15', 'striped', _Color(0.607, 0.059, 0.094)), # darkred ] # create the shadingVariant variantSet shadingVariant = model.GetVariantSets().AddVariantSet('shadingVariant') for variantName, decoration, color in shadingVariantsInfo: # creates a variant inside 'shadingVariant' shadingVariant.AddVariant(variantName) # switch to that variant shadingVariant.SetVariantSelection(variantName) # this 'with' construct here tells Usd that authoring operations should # write to the shadingVariant. with shadingVariant.GetVariantEditContext(): whichBall = variantName.split('_')[-1] texPath = os.path.join(texDir, 'ball%s.tex' % whichBall) # in the current variant, modify the color _SetParameters(ballTextureNode, [ ('filename', Sdf.ValueTypeNames.String, texPath), ]) # set the display color for hydra _SetDisplayColor(mesh, color) # currently not doing anything with decoration, but we could maybe # use this to make the solid vs. stripes. # now make the variant selection 'Cue' instead of the last variant that we # created above. shadingVariant.SetVariantSelection('Cue')
def testExportPxrRisShading(self): """ Tests that exporting a Maya mesh with a simple Maya shading setup results in the correct shading on the USD mesh. """ cubePrim = self._stage.GetPrimAtPath('/MarbleCube/Geom/Cube') self.assertTrue(cubePrim) # Validate the Material prim bound to the Mesh prim. material = UsdShade.Material.GetBoundMaterial(cubePrim) self.assertTrue(material) materialPath = material.GetPath().pathString self.assertEqual(materialPath, '/MarbleCube/Looks/MarbleCubeSG') # Validate the surface shader that is connected to the material. # XXX: Note that the expected number of outputs here is two rather than # one, since we are still authoring the UsdRi Bxdf source in addition # to the surface terminal for backwards compatibility. When consumers # are updated to use the surface terminal instead, this test will have # to be updated. materialOutputs = material.GetOutputs() self.assertEqual(len(materialOutputs), 2) materialOutput = material.GetOutput('surface') (connectableAPI, outputName, outputType) = materialOutput.GetConnectedSource() self.assertEqual(outputName, 'out') shader = UsdShade.Shader(connectableAPI) self.assertTrue(shader) # XXX: Validate the UsdRi Bxdf. This must also be removed when we no # longer author it. from pxr import UsdRi usdRiMaterialAPI = UsdRi.MaterialAPI(material.GetPrim()) self.assertTrue(usdRiMaterialAPI) bxdf = usdRiMaterialAPI.GetBxdf() self.assertEqual(bxdf.GetPrim(), shader.GetPrim()) shaderId = shader.GetIdAttr().Get() self.assertEqual(shaderId, 'PxrMayaMarble') # Validate the connected input on the surface shader. shaderInput = shader.GetInput('placementMatrix') self.assertTrue(shaderInput) (connectableAPI, outputName, outputType) = shaderInput.GetConnectedSource() self.assertEqual(outputName, 'worldInverseMatrix') shader = UsdShade.Shader(connectableAPI) self.assertTrue(shader) shaderId = shader.GetIdAttr().Get() self.assertEqual(shaderId, 'PxrMayaPlacement3d')
def test_Basic(self): stage = Usd.Stage.CreateInMemory() # can't use these if not properly initialized bogusSpline = UsdRi.SplineAPI() assert not bogusSpline.Validate()[0] light = UsdLux.SphereLight.Define(stage, '/Light') rod = UsdRi.PxrRodLightFilter.Define(stage, '/Light/Rod') light.GetFiltersRel().SetTargets([rod.GetPath()]) falloffRamp = rod.GetFalloffRampAPI() colorRamp = rod.GetColorRampAPI() # initially invalid since no spline exists assert not IsValid(falloffRamp) assert not IsValid(colorRamp) # set a simple ease-out falloff spline SetEaseOut(falloffRamp) assert IsValid(falloffRamp) # try a mismatch of values & positions falloffRamp.CreateValuesAttr().Set([1.0, 0.8, 0.2]) assert not IsValid(falloffRamp) # try a bogus interpolation value SetEaseOut(falloffRamp) assert IsValid(falloffRamp) falloffRamp.CreateInterpolationAttr().Set('bogus') assert not IsValid(falloffRamp) # check all known interp types for interp in ['linear', 'constant', 'catmullRom', 'bspline']: falloffRamp.CreateInterpolationAttr().Set(interp) assert IsValid(falloffRamp) # try non-sorted positions falloffRamp.CreatePositionsAttr().Set([1.0, 0.7, 0.3, 0.0]) assert not IsValid(falloffRamp) # set a red->green->blue color ramp colorRamp.CreateInterpolationAttr().Set(UsdRi.Tokens.linear) colorRamp.CreatePositionsAttr().Set([0.0, 0.5, 1.0]) colorRamp.CreateValuesAttr().Set([(1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (0.0, 0.0, 1.0)]) assert IsValid(colorRamp)
def _ValidateUsdRiPxrAovLight(self): lightPrimPath = '/RfMLightsTest/Lights/AovLight' lightPrim = self._stage.GetPrimAtPath(lightPrimPath) self.assertTrue(lightPrim) aovLight = UsdRi.PxrAovLight(lightPrim) self.assertTrue(aovLight) expectedAovName = 'testAovName' self.assertEqual(aovLight.GetAovNameAttr().Get(), expectedAovName) expectedInPrimaryHit = False self.assertEqual(aovLight.GetInPrimaryHitAttr().Get(), expectedInPrimaryHit) expectedInReflection = True self.assertEqual(aovLight.GetInReflectionAttr().Get(), expectedInReflection) expectedInRefraction = True self.assertEqual(aovLight.GetInRefractionAttr().Get(), expectedInRefraction) expectedInvert = True self.assertEqual(aovLight.GetInvertAttr().Get(), expectedInvert) expectedOnVolumeBoundaries = False self.assertEqual(aovLight.GetOnVolumeBoundariesAttr().Get(), expectedOnVolumeBoundaries) expectedUseColor = True self.assertEqual(aovLight.GetUseColorAttr().Get(), expectedUseColor) expectedUseThroughput = False self.assertEqual(aovLight.GetUseThroughputAttr().Get(), expectedUseThroughput)
def test_Basic(self): l = Sdf.Layer.CreateAnonymous() stage = Usd.Stage.Open(l.identifier) world = stage.DefinePrim("/World", "Xform") assert world world.SetMetadata('kind', 'group') assert world.IsModel() assert world.IsGroup() group = stage.DefinePrim("/World/Group", "Xform") assert group group.SetMetadata('kind', 'group') assert group.IsModel() assert group.IsGroup() model = stage.DefinePrim("/World/Group/Model", "Xform") assert model model.SetMetadata('kind', 'component') assert model.IsModel() p = stage.DefinePrim("/World/Group/Model/Mesh", "Scope") assert p print("Test Material") material = UsdShade.Material.Define(stage, "/World/Group/Model/Material") assert material assert material.GetPrim() material.Bind(p) print("Test shader") shader = UsdRi.RslShader.Define(stage, '/World/Group/Model/Shader') assert shader assert shader.GetPrim() assert not UsdRi.StatementsAPI.IsRiAttribute(shader.GetSloPathAttr()) shader.GetSloPathAttr().Set('foo') print("Test RiMaterialAPI") riMaterial = UsdRi.MaterialAPI(material) assert riMaterial assert riMaterial.GetPrim() # Test surface output self._TestOutput(riMaterial, UsdRi.MaterialAPI.GetSurfaceOutput, UsdRi.MaterialAPI.SetSurfaceSource, UsdRi.MaterialAPI.GetSurface, shader.GetPath()) # Test displacement output self._TestOutput(riMaterial, UsdRi.MaterialAPI.GetDisplacementOutput, UsdRi.MaterialAPI.SetDisplacementSource, UsdRi.MaterialAPI.GetDisplacement, shader.GetPath()) # Test volume output self._TestOutput(riMaterial, UsdRi.MaterialAPI.GetVolumeOutput, UsdRi.MaterialAPI.SetVolumeSource, UsdRi.MaterialAPI.GetVolume, shader.GetPath()) print("Test pattern") pattern = UsdRi.RisPattern.Define(stage, '/World/Group/Model/Pattern') assert pattern assert pattern.GetPrim() pattern.GetFilePathAttr().Set('foo') self.assertEqual(pattern.GetFilePathAttr().Get(), 'foo') pattern.GetArgsPathAttr().Set('argspath') self.assertEqual(pattern.GetArgsPathAttr().Get(), 'argspath') print("Test oslPattern") oslPattern = UsdRi.RisOslPattern.Define( stage, '/World/Group/Model/OslPattern') assert oslPattern assert oslPattern.GetPrim() self.assertEqual(oslPattern.GetFilePathAttr().Get(), 'PxrOSL') print("Test bxdf") bxdf = UsdRi.RisBxdf.Define(stage, '/World/Group/Model/Bxdf') assert bxdf assert bxdf.GetPrim() bxdf.GetFilePathAttr().Set('foo') bxdf.GetArgsPathAttr().Set('argspath') print("Test RIS Material") risMaterial = UsdRi.MaterialAPI(material.GetPrim()) assert risMaterial assert risMaterial.GetPrim() assert not risMaterial.GetBxdf() # Test the bxdf output self._TestOutput(risMaterial, UsdRi.MaterialAPI.GetBxdfOutput, UsdRi.MaterialAPI.SetBxdfSource, UsdRi.MaterialAPI.GetBxdf, bxdf.GetPath()) print("Test riStatements") riStatements = UsdRi.StatementsAPI(shader.GetPrim()) assert riStatements assert riStatements.GetPrim() attr = riStatements.CreateRiAttribute("ModelName", "string").\ Set('someModelName') assert attr props = riStatements.GetRiAttributes() assert props # this is so convoluted attr = riStatements.GetPrim().GetAttribute(props[0].GetName()) assert attr self.assertEqual(attr.GetName(), 'ri:attributes:user:ModelName') self.assertEqual(attr.Get(), 'someModelName') self.assertEqual(UsdRi.StatementsAPI.GetRiAttributeName(attr), 'ModelName') self.assertEqual(UsdRi.StatementsAPI.GetRiAttributeNameSpace(attr), 'user') assert UsdRi.StatementsAPI.IsRiAttribute(attr) self.assertEqual( UsdRi.StatementsAPI.MakeRiAttributePropertyName('myattr'), 'ri:attributes:user:myattr') self.assertEqual( UsdRi.StatementsAPI.MakeRiAttributePropertyName('dice:myattr'), 'ri:attributes:dice:myattr') self.assertEqual( UsdRi.StatementsAPI.MakeRiAttributePropertyName('dice.myattr'), 'ri:attributes:dice:myattr') self.assertEqual( UsdRi.StatementsAPI.MakeRiAttributePropertyName('dice_myattr'), 'ri:attributes:dice:myattr') # period is stronger separator than underscore, when both are present self.assertEqual( UsdRi.StatementsAPI.MakeRiAttributePropertyName('dice_my.attr'), 'ri:attributes:dice_my:attr') # multiple tokens concatted with underscores self.assertEqual( UsdRi.StatementsAPI.MakeRiAttributePropertyName( 'dice:my1:long:attr'), 'ri:attributes:dice:my1_long_attr') self.assertEqual( UsdRi.StatementsAPI.MakeRiAttributePropertyName( 'dice.my2.long.attr'), 'ri:attributes:dice:my2_long_attr') self.assertEqual( UsdRi.StatementsAPI.MakeRiAttributePropertyName( 'dice_my3_long_attr'), 'ri:attributes:dice:my3_long_attr') self.assertEqual(riStatements.GetCoordinateSystem(), '') self.assertEqual( UsdRi.StatementsAPI(model).GetModelCoordinateSystems(), []) self.assertEqual( UsdRi.StatementsAPI(model).GetModelScopedCoordinateSystems(), []) riStatements.SetCoordinateSystem('LEyeSpace') self.assertEqual(riStatements.GetCoordinateSystem(), 'LEyeSpace') self.assertEqual( UsdRi.StatementsAPI(model).GetModelCoordinateSystems(), [Sdf.Path('/World/Group/Model/Shader')]) riStatements.SetScopedCoordinateSystem('ScopedLEyeSpace') self.assertEqual(riStatements.GetScopedCoordinateSystem(), 'ScopedLEyeSpace') self.assertEqual( UsdRi.StatementsAPI(model).GetModelScopedCoordinateSystems(), [Sdf.Path('/World/Group/Model/Shader')]) self.assertEqual( UsdRi.StatementsAPI(group).GetModelCoordinateSystems(), []) self.assertEqual( UsdRi.StatementsAPI(group).GetModelScopedCoordinateSystems(), []) self.assertEqual( UsdRi.StatementsAPI(world).GetModelCoordinateSystems(), []) self.assertEqual( UsdRi.StatementsAPI(world).GetModelScopedCoordinateSystems(), []) self.assertFalse(riStatements.GetFocusRegionAttr().IsValid()) assert (riStatements.CreateFocusRegionAttr() is not None) assert (riStatements.GetFocusRegionAttr() is not None) self.assertTrue(riStatements.GetFocusRegionAttr().IsValid()) self.assertEqual(riStatements.GetFocusRegionAttr().Get(), None) riStatements.CreateFocusRegionAttr(9.0, True) self.assertEqual(riStatements.GetFocusRegionAttr().Get(), 9.0)
def test_Basic(self): l = Sdf.Layer.CreateAnonymous() stage = Usd.Stage.Open(l.identifier) world = stage.DefinePrim("/World", "Xform") assert world world.SetMetadata('kind', 'group') assert world.IsModel() assert world.IsGroup() group = stage.DefinePrim("/World/Group", "Xform") assert group group.SetMetadata('kind', 'group') assert group.IsModel() assert group.IsGroup() model = stage.DefinePrim("/World/Group/Model", "Xform") assert model model.SetMetadata('kind', 'component') assert model.IsModel() p = stage.DefinePrim("/World/Group/Model/Mesh", "Scope") assert p print("Test Material") material = UsdShade.Material.Define(stage, "/World/Group/Model/Material") assert material assert material.GetPrim() UsdShade.MaterialBindingAPI(p).Bind(material) print("Test shader") shader = UsdRi.RslShader.Define(stage, '/World/Group/Model/Shader') assert shader assert shader.GetPrim() assert not UsdRi.StatementsAPI.IsRiAttribute(shader.GetSloPathAttr()) shader.GetSloPathAttr().Set('foo') print("Test RiMaterialAPI") riMaterial = UsdRi.MaterialAPI.Apply(material.GetPrim()) assert riMaterial assert riMaterial.GetPrim() # Test surface output self._TestOutput(riMaterial, UsdRi.MaterialAPI.GetSurfaceOutput, UsdRi.MaterialAPI.SetSurfaceSource, UsdRi.MaterialAPI.GetSurface, shader.GetPath()) # Test displacement output self._TestOutput(riMaterial, UsdRi.MaterialAPI.GetDisplacementOutput, UsdRi.MaterialAPI.SetDisplacementSource, UsdRi.MaterialAPI.GetDisplacement, shader.GetPath()) # Test volume output self._TestOutput(riMaterial, UsdRi.MaterialAPI.GetVolumeOutput, UsdRi.MaterialAPI.SetVolumeSource, UsdRi.MaterialAPI.GetVolume, shader.GetPath()) print("Test pattern") pattern = UsdRi.RisPattern.Define(stage, '/World/Group/Model/Pattern') assert pattern assert pattern.GetPrim() pattern.GetFilePathAttr().Set('foo') self.assertEqual(pattern.GetFilePathAttr().Get(), 'foo') pattern.GetArgsPathAttr().Set('argspath') self.assertEqual(pattern.GetArgsPathAttr().Get(), 'argspath') print("Test oslPattern") oslPattern = UsdRi.RisOslPattern.Define( stage, '/World/Group/Model/OslPattern') assert oslPattern assert oslPattern.GetPrim() self.assertEqual(oslPattern.GetFilePathAttr().Get(), 'PxrOSL') print("Test bxdf") bxdf = UsdRi.RisBxdf.Define(stage, '/World/Group/Model/Bxdf') assert bxdf assert bxdf.GetPrim() bxdf.GetFilePathAttr().Set('foo') bxdf.GetArgsPathAttr().Set('argspath') print("Test RIS Material") risMaterial = UsdRi.MaterialAPI(material.GetPrim()) assert risMaterial assert risMaterial.GetPrim() print("Test riStatements") riStatements = UsdRi.StatementsAPI.Apply(shader.GetPrim()) assert riStatements assert riStatements.GetPrim() attr = riStatements.CreateRiAttribute("ModelName", "string").\ Set('someModelName') assert attr props = riStatements.GetRiAttributes() assert props # this is so convoluted attr = riStatements.GetPrim().GetAttribute(props[0].GetName()) assert attr prefix = ('primvars:' if Tf.GetEnvSetting('USDRI_STATEMENTS_WRITE_NEW_ATTR_ENCODING') else '') self.assertEqual(attr.GetName(), prefix + 'ri:attributes:user:ModelName') self.assertEqual(attr.Get(), 'someModelName') self.assertEqual(UsdRi.StatementsAPI.GetRiAttributeName(attr), 'ModelName') self.assertEqual(UsdRi.StatementsAPI.GetRiAttributeNameSpace(attr), 'user') assert UsdRi.StatementsAPI.IsRiAttribute(attr) self.assertEqual( UsdRi.StatementsAPI.MakeRiAttributePropertyName('myattr'), prefix + 'ri:attributes:user:myattr') self.assertEqual( UsdRi.StatementsAPI.MakeRiAttributePropertyName('dice:myattr'), prefix + 'ri:attributes:dice:myattr') self.assertEqual( UsdRi.StatementsAPI.MakeRiAttributePropertyName('dice.myattr'), prefix + 'ri:attributes:dice:myattr') self.assertEqual( UsdRi.StatementsAPI.MakeRiAttributePropertyName('dice_myattr'), prefix + 'ri:attributes:dice:myattr') # period is stronger separator than underscore, when both are present self.assertEqual( UsdRi.StatementsAPI.MakeRiAttributePropertyName('dice_my.attr'), prefix + 'ri:attributes:dice_my:attr') # multiple tokens concatted with underscores self.assertEqual( UsdRi.StatementsAPI.MakeRiAttributePropertyName( 'dice:my1:long:attr'), prefix + 'ri:attributes:dice:my1_long_attr') self.assertEqual( UsdRi.StatementsAPI.MakeRiAttributePropertyName( 'dice.my2.long.attr'), prefix + 'ri:attributes:dice:my2_long_attr') self.assertEqual( UsdRi.StatementsAPI.MakeRiAttributePropertyName( 'dice_my3_long_attr'), prefix + 'ri:attributes:dice:my3_long_attr') self.assertEqual(riStatements.GetCoordinateSystem(), '') self.assertEqual( UsdRi.StatementsAPI(model).GetModelCoordinateSystems(), []) self.assertEqual( UsdRi.StatementsAPI(model).GetModelScopedCoordinateSystems(), []) riStatements.SetCoordinateSystem('LEyeSpace') self.assertEqual(riStatements.GetCoordinateSystem(), 'LEyeSpace') self.assertEqual( UsdRi.StatementsAPI(model).GetModelCoordinateSystems(), [Sdf.Path('/World/Group/Model/Shader')]) riStatements.SetScopedCoordinateSystem('ScopedLEyeSpace') self.assertEqual(riStatements.GetScopedCoordinateSystem(), 'ScopedLEyeSpace') self.assertEqual( UsdRi.StatementsAPI(model).GetModelScopedCoordinateSystems(), [Sdf.Path('/World/Group/Model/Shader')]) self.assertEqual( UsdRi.StatementsAPI(group).GetModelCoordinateSystems(), []) self.assertEqual( UsdRi.StatementsAPI(group).GetModelScopedCoordinateSystems(), []) self.assertEqual( UsdRi.StatementsAPI(world).GetModelCoordinateSystems(), []) self.assertEqual( UsdRi.StatementsAPI(world).GetModelScopedCoordinateSystems(), []) # Test mixed old & new style encodings if (Tf.GetEnvSetting('USDRI_STATEMENTS_WRITE_NEW_ATTR_ENCODING') and Tf.GetEnvSetting('USDRI_STATEMENTS_READ_OLD_ATTR_ENCODING')): prim = stage.DefinePrim("/prim") riStatements = UsdRi.StatementsAPI.Apply(prim) self.assertEqual(len(riStatements.GetRiAttributes()), 0) # Add new-style newStyleAttr = riStatements.CreateRiAttribute('newStyle', 'string') newStyleAttr.Set('new') self.assertEqual(len(riStatements.GetRiAttributes()), 1) # Add old-style (note that we can't use UsdRi API for this, # since it doesn't let the caller choose the encoding) oldStyleAttr = prim.CreateAttribute('ri:attributes:user:oldStyle', Sdf.ValueTypeNames.String) oldStyleAttr.Set('old') self.assertEqual(len(riStatements.GetRiAttributes()), 2) # Exercise the case of an Ri attribute encoded in both # old and new styles. ignoredAttr = prim.CreateAttribute('ri:attributes:user:newStyle', Sdf.ValueTypeNames.String) self.assertEqual(len(riStatements.GetRiAttributes()), 2) self.assertFalse(ignoredAttr in riStatements.GetRiAttributes())
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 testExportDisplayColorShading(self): """ Tests that exporting a Maya mesh with a simple Maya shading setup results in the correct shading on the USD mesh. """ # Validate the displayColor on the mesh prim. cubePrim = self._stage.GetPrimAtPath('/RedCube/Geom/Cube') self.assertTrue(cubePrim) cubeMesh = UsdGeom.Mesh(cubePrim) self.assertTrue(cubeMesh) meshDisplayColors = cubeMesh.GetDisplayColorPrimvar().Get() self.assertEqual(len(meshDisplayColors), 1) self.assertTrue(Gf.IsClose(meshDisplayColors[0], self.RED_COLOR, 1e-6)) # Validate the Material prim bound to the Mesh prim. material = UsdShade.Material.GetBoundMaterial(cubePrim) self.assertTrue(material) materialPath = material.GetPath().pathString self.assertEqual(materialPath, '/RedCube/Looks/RedLambertSG') materialInputs = material.GetInputs() self.assertEqual(len(materialInputs), 3) materialInput = material.GetInput('displayColor') matDisplayColor = materialInput.Get() self.assertTrue(Gf.IsClose(matDisplayColor, self.RED_COLOR, 1e-6)) # Just verify that displayOpacity and transparency exist. materialInput = material.GetInput('displayOpacity') self.assertTrue(materialInput) materialInput = material.GetInput('transparency') self.assertTrue(materialInput) # Validate the surface shader that is connected to the material. # XXX: Note that the expected number of outputs here is two rather than # one, since we are still authoring the UsdRi Bxdf source in addition # to the surface terminal for backwards compatibility. When consumers # are updated to use the surface terminal instead, this test will have # to be updated. materialOutputs = material.GetOutputs() self.assertEqual(len(materialOutputs), 2) materialOutput = material.GetOutput('surface') (connectableAPI, outputName, outputType) = materialOutput.GetConnectedSource() self.assertEqual(outputName, 'out') shader = UsdShade.Shader(connectableAPI) self.assertTrue(shader) self.assertEqual(shader.GetPrim().GetName(), 'RedLambertSG_lambert') # XXX: Validate the UsdRi Bxdf. This must also be removed when we no # longer author it. from pxr import UsdRi usdRiMaterialAPI = UsdRi.MaterialAPI(material.GetPrim()) self.assertTrue(usdRiMaterialAPI) bxdf = usdRiMaterialAPI.GetBxdf() self.assertEqual(bxdf.GetPrim(), shader.GetPrim()) shaderId = shader.GetIdAttr().Get() self.assertEqual(shaderId, 'PxrDiffuse') shaderInputs = shader.GetInputs() self.assertEqual(len(shaderInputs), 2) diffuseInput = shader.GetInput('diffuseColor') self.assertTrue(diffuseInput) (connectableAPI, outputName, outputType) = diffuseInput.GetConnectedSource() self.assertEqual(outputName, 'displayColor') self.assertTrue(connectableAPI) self.assertEqual(connectableAPI.GetPath().pathString, materialPath) transmissionInput = shader.GetInput('transmissionColor') self.assertTrue(transmissionInput) (connectableAPI, outputName, outputType) = transmissionInput.GetConnectedSource() self.assertEqual(outputName, 'transparency') self.assertTrue(connectableAPI) self.assertEqual(connectableAPI.GetPath().pathString, materialPath)