def main(): """Run the main execution of the current script.""" inner_stage = _make_target() main_stage = Usd.Stage.CreateInMemory() # XXX : In order to use `inner_stage` in an EditContext, it must be # in `main_stage`'s local LayerStack (e.g. it must be a sublayer) # main_stage.GetRootLayer().subLayerPaths.append( inner_stage.GetRootLayer().identifier) print(main_stage.GetRootLayer().ExportToString()) print('Inner stage before context') print(inner_stage.GetRootLayer().ExportToString()) with Usd.EditContext(main_stage, inner_stage.GetRootLayer()): sphere = UsdGeom.Sphere(main_stage.GetPrimAtPath("/root/sphere")) sphere.GetRadiusAttr().Set(10) print('Inner stage after context') print(inner_stage.GetRootLayer().ExportToString()) main_stage.SetEditTarget(Usd.EditTarget(inner_stage.GetRootLayer())) sphere = UsdGeom.Sphere(main_stage.GetPrimAtPath("/root/sphere")) sphere.GetRadiusAttr().Set(5) print('Inner stage after setting') print(inner_stage.GetRootLayer().ExportToString())
def main(): print("Simple Stage:") stage = _create_basic_scene() sphere = UsdGeom.Sphere(stage.GetPrimAtPath("/Some/Prim")) radius = sphere.GetRadiusAttr() print("Testing Get(), normally") timeit(radius.Get, REPEATS) query = Usd.AttributeQuery(radius) print(query.Get()) radius.Set(100) print(query.Get()) print("Testing Get(), using UsdAttributeQuery") timeit(query.Get, REPEATS) print() print("Testing GetTimeSamples(), normally") timeit(radius.GetTimeSamples, REPEATS) function = functools.partial(query.GetUnionedTimeSamples, [query]) function.__name__ = "GetUnionedTimeSamples" print("Testing GetTimeSamples(), using a union") timeit(function, REPEATS) print() visibility = sphere.GetVisibilityAttr() function = functools.partial(_get_time_samples, (radius, visibility)) function.__name__ = "_get_time_samples - with radius and visibility" print("Testing GetTimeSamples() for multiple attributes, normally") timeit(function, REPEATS) function = functools.partial(query.GetUnionedTimeSamples, [query, Usd.AttributeQuery(visibility)]) function.__name__ = "GetUnionedTimeSamples - with radius and visibility" print("Testing GetTimeSamples() for multiple attributes, using a union") timeit(function, REPEATS) print() print("Heavy Stage:") heavier_stage = _create_basic_scene_with_more_values() sphere = UsdGeom.Sphere(heavier_stage.GetPrimAtPath("/Some/Prim")) radius = sphere.GetRadiusAttr() visibility = sphere.GetVisibilityAttr() query = Usd.AttributeQuery(radius) function = functools.partial(_get_time_samples, (radius, visibility)) function.__name__ = "_get_time_samples - with radius and visibility" print("Testing GetTimeSamples() for multiple attributes, normally") timeit(function, REPEATS) function = functools.partial(query.GetUnionedTimeSamples, [query, Usd.AttributeQuery(visibility)]) function.__name__ = "GetUnionedTimeSamples - with radius and visibility" print("Testing GetTimeSamples() for multiple attributes, using a union") timeit(function, REPEATS)
def main(): """Run the main execution of the current script.""" stage = Usd.Stage.CreateInMemory() stage.GetRootLayer().ImportFromString("""\ #usda 1.0 def Scope "root" ( variantSets = ["foo"] ) { variantSet "foo" = { "base" { def Scope "prim1" { def Sphere "a_sphere" { double radius = 3 } } } "another" { def Scope "prim2" ( variantSets = ["bar"] ) { variantSet "bar" = { "one" { def Sphere "sphere" { double radius = 2 } } } } } } } """) variant_sphere = UsdGeom.Sphere( get_prim_at_path(stage, Sdf.Path("/root{foo=base}prim1/a_sphere"))) print('This value should be 3.0: "{}"'.format( variant_sphere.GetRadiusAttr().Get())) nested_variant_sphere = UsdGeom.Sphere( get_prim_at_path(stage, Sdf.Path("/root{foo=another}prim2{bar=one}sphere"))) print('This value should be 2.0: "{}"'.format( nested_variant_sphere.GetRadiusAttr().Get()))
def test_Revert_Bug111239(self): # This used to test a change for Bug111239, but now tests that this # fix has been reverted. We no longer allow the C++ typename be used as # a prim's typename. s = Usd.Stage.CreateInMemory() sphere = s.DefinePrim('/sphere', typeName='Sphere') tfTypeName = UsdGeom.Sphere._GetStaticTfType().typeName self.assertEqual(tfTypeName, 'UsdGeomSphere') usdGeomSphere = s.DefinePrim('/usdGeomSphere', typeName='tfTypeName') self.assertTrue(UsdGeom.Sphere(sphere)) self.assertTrue( 'radius' in [a.GetName() for a in sphere.GetAttributes()]) self.assertFalse(UsdGeom.Sphere(usdGeomSphere)) self.assertFalse( 'radius' in [a.GetName() for a in usdGeomSphere.GetAttributes()])
def _testReloadReopen(appController): from pxr import Usd, UsdGeom # # Frame the front sphere, and color it red # appController._dataModel.selection.setPrimPath("/frontSphere") stage = appController._dataModel.stage sphere = UsdGeom.Sphere(stage.GetPrimAtPath("/frontSphere")) with Usd.EditContext(stage, stage.GetRootLayer()): sphere.CreateDisplayColorAttr([(1, 0, 0)]) _emitFrameAction(appController) # Finally, clear selection so the red really shows appController._dataModel.selection.clear() _takeShot(appController, "coloredAndFramed.png") # # Reloading should set the sphere back to gray (because we authored into # its root layer), but otherwise not change the view # _emitReload_All_LayersAction(appController) _takeShot(appController, "reloaded.png") # # Reopening the stage should completely reset the view # _emitReopen_StageAction(appController) _takeShot(appController, "reopened.png")
def Read(self, context): usdPrim = self._GetArgs().GetUsdPrim() sphere = UsdGeom.Sphere(usdPrim) cmds.polySphere(r=sphere.GetRadiusAttr().Get(), name=usdPrim.GetName()) MayaNode = context.GetMayaNode(usdPrim.GetPath().GetParentPath(), True) print("primReaderTest.Read Ok") return True
def create_shot(sequence): """Get the settings from some `sequence` and modify its assets.""" stage = Usd.Stage.CreateInMemory() stage.GetRootLayer().subLayerPaths.append(sequence) prim = stage.OverridePrim("/SomeSphere") variants = prim.GetVariantSets().GetVariantSet("some_variant_set") variants.AddVariant("variant_name_2") prim.SetMetadata( "comment", textwrap.dedent("""\ SetVariantSelection sets the default variant. Also note that our new variant set, "variant_name_2" adds, not overrides, the "some_variant_set". So we have "variant_name_2" and "variant_name_1" now. """), ) variants.SetVariantSelection("variant_name_2") with variants.GetVariantEditContext(): sphere = UsdGeom.Sphere(prim) sphere.GetDisplayColorAttr().Set([(0, 1, 0)]) stage.Save() return stage
def _create_basic_scene_with_more_values(): stage = _create_basic_scene() override = UsdGeom.Sphere(stage.OverridePrim("/Some/Prim")) for sample in range(10000): override.GetRadiusAttr().Set(sample + 30, sample) return stage
def _run_resolution_test(): referencee = Usd.Stage.CreateInMemory() referencee.GetRootLayer().ImportFromString("""\ #usda 1.0 ( defaultPrim = "root" ) def Scope "root" { def Sphere "sphere" { double radius = 2 double radius.timeSamples = { 10: 10, 40: 40, } } } """) referencer = Usd.Stage.CreateInMemory() root = referencer.DefinePrim("/root") root.GetReferences().AddReference( Sdf.Reference( referencee.GetRootLayer().identifier, layerOffset=Sdf.LayerOffset(offset=5, scale=2), )) sphere = UsdGeom.Sphere(referencer.GetPrimAtPath("/root/sphere")) radius = sphere.GetRadiusAttr() times = [ (10, 10.0, Usd.ResolveInfoSourceTimeSamples), (20, 10.0, Usd.ResolveInfoSourceTimeSamples), (25, 10.0, Usd.ResolveInfoSourceTimeSamples), (30, 12.5, Usd.ResolveInfoSourceTimeSamples), (55, 25.0, Usd.ResolveInfoSourceTimeSamples), (85, 40.0, Usd.ResolveInfoSourceTimeSamples), ] template = textwrap.dedent("""\ Expected Value: "{expected_value}" Actual Value: "{actual_value}" Expected Resolve: "{expected_resolve}", Actual Resolve: "{actual_resolve}",\ """) for time_code, expected_value, expected_resolve in times: print('Time Start: "{time_code}"'.format(time_code=time_code)) print( template.format( expected_value=expected_value, actual_value=radius.Get(time_code), expected_resolve=expected_resolve, actual_resolve=radius.GetResolveInfo(time_code).GetSource(), )) print('Time End: "{time_code}"'.format(time_code=time_code))
def _create_basic_scene(): stage = Usd.Stage.CreateInMemory() sphere = UsdGeom.Sphere.Define(stage, "/Some/Prim") sphere.GetRadiusAttr().Set(10.0) another = Usd.Stage.CreateInMemory() another.GetRootLayer().subLayerPaths.append( stage.GetRootLayer().identifier) override = UsdGeom.Sphere(another.OverridePrim("/Some/Prim")) override.GetRadiusAttr().Set(20.0) return another
def create_override_stage(identifier): stage = Usd.Stage.CreateInMemory() stage.GetPrimAtPath("/SomeSphere") root = stage.GetRootLayer() root.subLayerPaths.append(identifier) sphere = UsdGeom.Sphere(stage.GetPrimAtPath("/SomeSphere")) # Here's an example of adding a completely new variant set sphere.GetPrim().GetVariantSets().AddVariantSet("another") variants = sphere.GetPrim().GetVariantSets().GetVariantSet("some_variant_set") variants.AddVariant("foo") variants.SetVariantSelection("foo") with variants.GetVariantEditContext(): sphere.GetRadiusAttr().Set(100) return stage
def create_sequence(asset): """Create a collection that shots will include and add some character to it.""" stage = Usd.Stage.CreateInMemory() root = stage.GetRootLayer() root.documentation = "A common set of data for an entire sequence." root.subLayerPaths.append(asset) stage.SetMetadata( "comment", "We override the character to make it bigger and add some viewing option.", ) prim = stage.OverridePrim("/SomeSphere") variants = prim.GetVariantSets().AddVariantSet("some_variant_set") variants.AddVariant("variant_name_1") variants.SetVariantSelection("variant_name_1") with variants.GetVariantEditContext(): sphere = UsdGeom.Sphere(prim) sphere.GetDisplayColorAttr().Set([(1, 0, 0)]) return stage
def animate(stage): """The output from Tilt Brush is strokes with a growth velocity. This could be authored per vertex later (e.g. for easing). """ # The current animation time, this will increase monotonicly to generate frames of animation. time = 1 # The maximum number of animated strokes, for performance constraints. maxActive = 30 # Filters dictate when a stroke becomes active, i.e. predicates for activation. activeFilter = isInRadius activeFilterVert = isHigherVert # The target length of the animation. lengthInSeconds = 30 # The playback framerate. framesPerSecond = 30 # The number of frames we will generate based on target time and rate. numFrames = lengthInSeconds * framesPerSecond # Boundaries for activation. minHeight = 0 maxHeight = 20 radius = 17.0 maxRadius = 100. height = minHeight # Compute the actual radius of the world bounds. worldBounds = UsdGeom.Xform(stage.GetPrimAtPath("/")).ComputeWorldBound(0, "default") maxRadius = (worldBounds.GetRange().max - worldBounds.GetRange().min).GetLength() # Compute the centroid of the world. global worldCenter worldCenter = Gf.Vec3f(worldBounds.ComputeCentroid()) # Just for newIntroSketch.tilt if "NewIntroSketch" in stage.GetRootLayer().identifier: worldCenter = Gf.Vec3f(0.73135, 19.92212, 33.2210311) worldCenter[1] = worldBounds.GetRange().min[1] print("World Center:", worldCenter) print("Max Radius:", maxRadius) # Visualize the radius. debugSphere = UsdGeom.Sphere(stage.DefinePrim("/debug", "Sphere")) debugSphere.CreateRadiusAttr(radius) debugSphere.GetPrim().GetAttribute("purpose").Set("guide") attr = debugSphere.GetPrim().GetAttribute("primvars:displayOpacity") attr.Set([0.125]) attr.SetMetadata("interpolation", "constant") UsdGeom.Xform(attr.GetPrim()).AddTranslateOp().Set(worldCenter) # Initialize data structures. # - strokes are Unity meshes (or Tilt Brush batches). # - substrokes are the individual brush strokes within a single mesh. # - activeSubstrokes are sub-strokes currently in-flight. # - completeSubstrokes are sub-strokes that are done animating. strokes = MakeStrokes(stage) substrokes = MakeSubstrokes(strokes) activeStrokes = set() activeSubstrokes = set() completeSubstrokes = set() # Compute step sizes based on target animation length. dRadius = (maxRadius - radius) / float(numFrames) / 1.5 dHeight = (maxHeight - minHeight) / float(numFrames) # Set USD animation start/end times. stage.SetStartTimeCode(time) stage.SetEndTimeCode(numFrames) # Zero out stroke opacities for s in strokes: s.Save(time) # Main animation loop. for time in range(0, numFrames): print() print("Time:", time, height, radius, smoothstep(1.0, float(numFrames), time)) curActive = 0 if len(activeStrokes) < maxActive: # On the final frame, increase activation volumes to "infinity" (and beyond ;) if time == numFrames - 1: height = 10000000 radius = 10000000 # Search for strokes to be activated. didAddStroke = 0 for ss in substrokes: # Already animating, skip. if ss in activeSubstrokes: continue # Done animating, skip. if ss in completeSubstrokes: continue # Overloaded. if len(activeStrokes) >= maxActive: break # If this sub-stroke passes the filter, add it to the animating list. if activeFilter(ss.minPoint, radius): didAddStroke = 1 activeSubstrokes.add(ss) activeStrokes.add(ss.stroke) # Mark the stroke as dirty to save its initial state. ss.stroke.dirty = True ss.SetRadius(radius, time) print("+", end=' ') if not didAddStroke: # We didn't add any strokes, which means the radius needs to increase. # Grow the activation volumes (increase sphere size, raise floor plane height). height += dHeight radius += dRadius * smoothstep(1.0, float(numFrames), time) # Update debug vis. debugSphere.GetRadiusAttr().Set(radius, time) # Call save on everything, but only dirty strokes will actually write data. # Save a key at the previous frame here so that when a stroke starts animating, when linearly # interpolated, it will not start animating from frame zero to the first key frame. #for s in strokes: # s.Save(time - 1) # Update stroke animation. remove = [] for ss in activeSubstrokes: print(".", end=' ') if not ss.Update(dRadius, smoothstep(1.0, float(numFrames), time)): if ss.indicesWritten != ss.indexCount: raise "Fail" remove.append(ss) # Remove all the completed strokes. for ss in remove: activeSubstrokes.remove(ss) completeSubstrokes.add(ss) # Save keyframes for the current time. for s in strokes: s.Save(time) # Rebuild the activeStrokes set. activeStrokes = set() for ss in activeSubstrokes: activeStrokes.add(ss.stroke) # Drainstop: we have leftover strokes that didn't finish animating within the target time, rather # than popping them, we let them finish animating and run over the target time. while len(activeSubstrokes) > 0: remove = [] time += 1 # Since we blew past the initial frame estimate, we also need to update the USD end time. stage.SetEndTimeCode(time) # Loop: update, remove, save, rinse, repeat. for ss in activeSubstrokes: if not ss.Update(dRadius, 2.0): if ss.indicesWritten != ss.indexCount: raise "Fail" remove.append(ss) for ss in remove: activeSubstrokes.remove(ss) completeSubstrokes.add(ss) for s in strokes: s.Save(time)
# section 2 expected = ['proxyPrim', 'purpose', 'visibility', 'xformOpOrder'] assert xform.GetPropertyNames() == expected expected = [ 'doubleSided', 'extent', 'orientation', 'primvars:displayColor', 'primvars:displayOpacity', 'proxyPrim', 'purpose', 'radius', 'visibility', 'xformOpOrder' ] assert sphere.GetPropertyNames() == expected # section 3 extentAttr = sphere.GetAttribute('extent') expected = Vt.Vec3fArray([(-1, -1, -1), (1, 1, 1)]) assert extentAttr.Get() == expected # section 4 radiusAttr = sphere.GetAttribute('radius') radiusAttr.Set(2) extentAttr.Set(extentAttr.Get() * 2) print stage.GetRootLayer().ExportToString() # section 5 from pxr import UsdGeom sphereSchema = UsdGeom.Sphere(sphere) color = sphereSchema.GetDisplayColorAttr() color.Set([(0, 0, 1)]) print stage.GetRootLayer().ExportToString() stage.GetRootLayer().Save()
# language governing permissions and limitations under the Apache License. # from pxr import Usd, UsdGeom # section 1 stage = Usd.Stage.Open("RefExample.usda") assert ([x for x in stage.Traverse()] == [ stage.GetPrimAtPath("/refSphere"), stage.GetPrimAtPath("/refSphere/world"), stage.GetPrimAtPath("/refSphere2"), stage.GetPrimAtPath("/refSphere2/world") ]) # section 2 assert ([x for x in stage.Traverse() if UsdGeom.Sphere(x)] == [ stage.GetPrimAtPath("/refSphere/world"), stage.GetPrimAtPath("/refSphere2/world") ]) # section 3 treeIter = Usd.TreeIterator.PreAndPostVisit(stage.GetPseudoRoot()) treeIterExpectedResults = [(stage.GetPrimAtPath("/"), False), (stage.GetPrimAtPath("/refSphere"), False), (stage.GetPrimAtPath("/refSphere/world"), False), (stage.GetPrimAtPath("/refSphere/world"), True), (stage.GetPrimAtPath("/refSphere"), True), (stage.GetPrimAtPath("/refSphere2"), False), (stage.GetPrimAtPath("/refSphere2/world"), False), (stage.GetPrimAtPath("/refSphere2/world"), True),