def TestExtentCalculation():
stage = Usd.Stage.Open("pointsAndCurves.usda")
bboxCache = UsdGeom.BBoxCache(Usd.TimeCode(0.0),
includedPurposes=[UsdGeom.Tokens.default_])
print("-" * 80)
print("Testing extent calculations on prims")
print("-" * 80)
print()
validPrims = stage.GetPrimAtPath("/ValidPrims")
warningPrims = stage.GetPrimAtPath("/WarningPrims")
errorPrims = stage.GetPrimAtPath("/ErrorPrims")
print("Visit Extent: " + str(validPrims))
for prim in validPrims.GetChildren():
print(str(prim) + ": " + \
str(bboxCache.ComputeWorldBound(prim).GetRange()))
print()
print("Visit Extent: " + str(warningPrims))
for prim in warningPrims.GetChildren():
print(str(prim) + ": " + \
str(bboxCache.ComputeWorldBound(prim).GetRange()))
print()
print("Visit Extent: " + str(errorPrims))
for prim in errorPrims.GetChildren():
bboxRange = bboxCache.ComputeWorldBound(prim).GetRange()
print(str(prim) + ": " + \
str(bboxCache.ComputeWorldBound(prim).GetRange()))
def set_radius(usd_light, xsi_param, anim_opt):
attr = usd_light.CreateRadiusAttr()
if anim_opt is None:
attr.Set(xsi_param.Value)
else:
for frame in range(anim_opt[0], anim_opt[1] + 1):
attr.Set(xsi_param.GetValue(frame), Usd.TimeCode(frame))
def test_TimeSampled(self):
extents = {
'/capsule':
Vt.Vec3fArray(
2, (Gf.Vec3f(-4.0, -4.0, -6.0), Gf.Vec3f(4.0, 4.0, 6.0))),
'/cone':
Vt.Vec3fArray(
2, (Gf.Vec3f(-4.0, -4.0, -3.0), Gf.Vec3f(4.0, 4.0, 3.0))),
'/cube':
Vt.Vec3fArray(
2, (Gf.Vec3f(-3.0, -3.0, -3.0), Gf.Vec3f(3.0, 3.0, 3.0))),
'/cylinder':
Vt.Vec3fArray(
2, (Gf.Vec3f(-4.0, -4.0, -3.0), Gf.Vec3f(4.0, 4.0, 3.0))),
'/sphere':
Vt.Vec3fArray(
2, (Gf.Vec3f(-4.0, -4.0, -4.0), Gf.Vec3f(4.0, 4.0, 4.0)))
}
testFile = "test.usda"
s = Usd.Stage.Open(testFile)
for primpath in self.primpaths:
p = s.GetPrimAtPath(primpath)
b = UsdGeom.Boundable(p)
tc = Usd.TimeCode(2.0)
e = UsdGeom.Boundable.ComputeExtentFromPlugins(b, tc)
print primpath, e
self.assertEqual(extents[primpath], e)
def testNumericTimeRepr(self):
"""
Validates the string representation of a numeric time code.
"""
timeCode = Usd.TimeCode(123.0)
timeRepr = repr(timeCode)
self.assertEqual(timeRepr, 'Usd.TimeCode(123.0)')
def _create_usd_animation2(self, usd_node, gltf_node, animation_channels):
"""Converts a glTF animation to a USD animation
Arguments:
usd_node {[type]} -- usd node
gltf_node {[type]} -- glTF node
animation_channel {AnimationMap} -- map of animation target path and animation sampler indices
Returns:
[type] -- [description]
"""
max_time = -999
min_time = 999
for channel in animation_channels:
max_time = max(max_time, int(round(channel.sampler.get_input_max()[0])))
min_time = min(min_time, int(round(channel.sampler.get_input_min()[0])))
transform = usd_node.AddTransformOp(opSuffix='transform')
for i, keyframe in enumerate(numpy.arange(min_time, max_time, 1./self.fps)):
transform_node = self._create_keyframe_transform_node(gltf_node, animation_channels, keyframe)
transform.Set(transform_node, Usd.TimeCode(i))
MinMaxTime = collections.namedtuple('MinMaxTime', ('max', 'min'))
return MinMaxTime(max=max_time, min=min_time)
def sync_update(self, context, depsgraph):
""" sync just the updated things """
if not self.is_synced:
return
settings = self.get_settings(depsgraph.scene)
self.render_params.frame = Usd.TimeCode(depsgraph.scene.frame_current)
if self.renderer.IsPauseRendererSupported():
self.renderer.PauseRenderer()
if self._check_restart_renderer(depsgraph.scene):
self.renderer = None # explicit renderer deletion
self.renderer = UsdImagingGL.Engine()
gl_delegate_changed = self.is_gl_delegate != settings.is_gl_delegate
self._sync_update(context, depsgraph)
if gl_delegate_changed:
usd_utils.set_delegate_variant_stage(self.cached_stage(),
settings.delegate_name)
if self.renderer.IsPauseRendererSupported():
self.renderer.ResumeRenderer()
self.render_engine.tag_redraw()
def _CheckValues(self,
camera,
schema,
time,
skipTransformAndClippingPlanes=False):
if not skipTransformAndClippingPlanes:
self.assertEqual(camera.transform,
schema.GetLocalTransformation(Usd.TimeCode(time)))
self.assertEqual(camera.projection,
self._GetSchemaProjection(schema, time))
self.assertEqual(camera.horizontalAperture,
schema.GetHorizontalApertureAttr().Get(time))
self.assertEqual(camera.verticalAperture,
schema.GetVerticalApertureAttr().Get(time))
self.assertEqual(camera.horizontalApertureOffset,
schema.GetHorizontalApertureOffsetAttr().Get(time))
self.assertEqual(camera.verticalApertureOffset,
schema.GetVerticalApertureOffsetAttr().Get(time))
self.assertEqual(camera.focalLength,
schema.GetFocalLengthAttr().Get(time))
self.assertEqual(camera.clippingRange,
self._GetSchemaClippingRange(schema, time))
if not skipTransformAndClippingPlanes:
self.assertEqual(camera.clippingPlanes,
self._GetSchemaClippingPlanes(schema, time))
self.assertTrue(
Gf.IsClose(camera.fStop,
schema.GetFStopAttr().Get(time), 1e-6))
self.assertEqual(camera.focusDistance,
schema.GetFocusDistanceAttr().Get(time))
def GetAttributeStatus(attribute,
frame,
hasValue=None,
hasAuthoredValue=None,
valueIsDefault=None):
if not isinstance(frame, Usd.TimeCode):
frame = Usd.TimeCode(frame)
# Save time if someone has already made the queries
if hasValue == False:
return AttributeStatus.NOVALUE
elif hasValue is not None and hasAuthoredValue == False:
return AttributeStatus.FALLBACK
if not attribute.HasValue():
return AttributeStatus.NOVALUE
# no authored value? it's using fallback
if not attribute.HasAuthoredValueOpinion():
return AttributeStatus.FALLBACK
if frame.IsDefault() or valueIsDefault:
return AttributeStatus.DEFAULT
bracketingTS = attribute.GetBracketingTimeSamples(frame.GetValue())
if len(bracketingTS) == 0:
return AttributeStatus.DEFAULT
return (AttributeStatus.KEYFRAME if bracketingTS[0] == frame.GetValue()
else AttributeStatus.CLAMPED)
def test_Layers(self):
layeredFile = 'testUsdAbcSDFArguments.usda'
topologyFile = 'testUsdAbcSDFArgumentsMesh.abc'
flatFile = 'testUsdAbcSDFArgumentsFlat.abc'
time = Usd.TimeCode()
xformCache = UsdGeom.XformCache(time)
stage = Usd.Stage.Open(layeredFile)
self.assertTrue(stage)
pCubeShape1 = UsdGeom.Mesh.Get(stage, '/AlembicRoot/pCubeShape1')
pCubeShape2 = UsdGeom.Mesh.Get(stage, '/AlembicRoot/pCubeShape2')
self.assertTrue(pCubeShape1)
self.assertTrue(pCubeShape2)
topoABC = Usd.Stage.Open(topologyFile)
self.assertTrue(topoABC)
pCubeShape1ABCPure = UsdGeom.Mesh.Get(topoABC, '/pCubeShape1')
pCubeShape2ABCPure = UsdGeom.Mesh.Get(topoABC, '/pCubeShape2')
self.assertTrue(pCubeShape1ABCPure)
self.assertTrue(pCubeShape2ABCPure)
# Test the Xforms got layered in properly
#
self.assertEqual(xformCache.GetLocalToWorldTransform(pCubeShape1.GetPrim()),
xformCache.GetLocalToWorldTransform(pCubeShape1ABCPure.GetPrim()))
self.assertEqual(xformCache.GetLocalToWorldTransform(pCubeShape2.GetPrim()),
xformCache.GetLocalToWorldTransform(pCubeShape2ABCPure.GetPrim()))
# Test various attributes & primavars came through
#
self.assertEqual(len(pCubeShape1.GetPointsAttr().Get(time)),
len(pCubeShape2.GetPointsAttr().Get(time)))
self.assertEqual(len(pCubeShape1.GetNormalsAttr().Get(time)), 8)
self.assertEqual(len(pCubeShape2.GetNormalsAttr().Get(time)), 24)
pCubeShape1UV = pCubeShape1.GetPrimvar('uv')
pCubeShape2UV = pCubeShape2.GetPrimvar('uv')
self.assertEqual(pCubeShape1UV.GetTypeName(), 'float2[]')
self.assertEqual(pCubeShape2UV.GetTypeName(), 'float2[]')
self.assertEqual(pCubeShape1UV.GetInterpolation() , 'varying')
self.assertEqual(len(pCubeShape1UV.Get(time)), 8)
self.assertEqual(pCubeShape2UV.GetInterpolation(), 'faceVarying')
self.assertEqual(len(pCubeShape2UV.Get(time)), 14)
self.assertEqual(len(pCubeShape2UV.GetIndices(time)), 24)
# Test against the known flattened version
#
flatABC = Usd.Stage.Open(flatFile)
self.assertTrue(flatABC)
self.assertEqual(UsdGeom.Mesh.Get(flatABC, '/pCubeShape1').GetPrimvar('uv').Get(time), pCubeShape1UV.Get(time))
self.assertEqual(UsdGeom.Mesh.Get(flatABC, '/pCubeShape2').GetPrimvar('uv').Get(time), pCubeShape2UV.Get(time))
def testDefaultConstructedTimeRepr(self):
"""
Validates the string representation of a time code created using
the default constructor.
"""
timeCode = Usd.TimeCode()
timeRepr = repr(timeCode)
self.assertEqual(timeRepr, 'Usd.TimeCode()')
def TestIgnoreVisibility():
stage = Usd.Stage.Open("animVis.usda")
bboxCache = UsdGeom.BBoxCache(Usd.TimeCode(0.0),
includedPurposes=[UsdGeom.Tokens.default_],
useExtentsHint=True,
ignoreVisibility=True)
pseudoRoot = stage.GetPrimAtPath("/")
assert not bboxCache.ComputeWorldBound(pseudoRoot).GetRange().IsEmpty()
def set_diffuse(usd_light, parameter, anim_opt, value=None): # value used for background light
if value is not None:
usd_light.CreateDiffuseAttr().Set(value)
else:
attr = usd_light.CreateDiffuseAttr()
if anim_opt is None or utils.is_param_animated(parameter, anim_opt):
for frame in range(anim_opt[0], anim_opt[1] + 1):
attr.Set(1.0 if parameter.GetValue(frame) else 0.0, Usd.TimeCode(frame))
else:
attr.Set(1.0 if parameter.Value else 0.0)
def set_specular(usd_light, parameter, anim_opt, value=None):
if value is not None:
usd_light.CreateSpecularAttr().Set(value)
else:
attr = usd_light.CreateSpecularAttr()
if anim_opt is None or utils.is_param_animated(parameter, anim_opt):
for frame in range(anim_opt[0], anim_opt[1] + 1):
attr.Set(1.0 if parameter.GetValue(frame) else 0.0, Usd.TimeCode(frame))
else:
attr.Set(1.0 if parameter.Value else 0.0)
def set_camera_at_frame(xsi_camera, usd_camera, frame=None):
xsi_interest = xsi_camera.Interest
# get global position of the camera and the interest
xsi_camera_position = xsi_camera.Kinematics.Global.Transform.Translation if frame is None else xsi_camera.Kinematics.Local.GetTransform2(
frame).Translation
xsi_interest_position = xsi_interest.Kinematics.Global.Transform.Translation if frame is None else xsi_interest.Kinematics.Local.GetTransform2(
frame).Translation
xsi_focal_length = (
xsi_camera.Parameters("projplanedist").Value if frame is None else
xsi_camera.Parameters("projplanedist").GetValue2(frame))
if frame is None:
usd_camera.CreateFocalLengthAttr().Set(xsi_focal_length)
usd_camera.CreateFocusDistanceAttr().Set(
get_distance(xsi_camera_position, xsi_interest_position))
else:
usd_camera.CreateFocalLengthAttr().Set(xsi_focal_length,
Usd.TimeCode(frame))
usd_camera.CreateFocusDistanceAttr().Set(
get_distance(xsi_camera_position, xsi_interest_position),
Usd.TimeCode(frame))
def test_TimeSampledAssets(self):
src_stage = Usd.Stage.Open('time_sampled_assets.usda')
layer = UsdUtils.FlattenLayerStack(src_stage)
result_stage = Usd.Stage.Open(layer)
prim = result_stage.GetPrimAtPath(
'/materials/usdpreviewsurface1/usduvtexture1')
attr = prim.GetAttribute('inputs:file')
time_samples = attr.GetTimeSamples()
for time_sample in time_samples:
time_sample_array_value = attr.Get(Usd.TimeCode(time_sample))
for time_sample_value in time_sample_array_value:
self.assertTrue(os.path.isabs(time_sample_value.path))
prim = result_stage.GetPrimAtPath('/volume/density')
attr = prim.GetAttribute('filePath')
time_samples = attr.GetTimeSamples()
for time_sample in time_samples:
time_sample_value = attr.Get(Usd.TimeCode(time_sample))
self.assertTrue(os.path.isabs(time_sample_value.path))
def TestUnloadedExtentsHints():
stage = Usd.Stage.Open(
"unloadedCubeModel.usda",
load = Usd.Stage.LoadNone)
bboxCacheNo = UsdGeom.BBoxCache(Usd.TimeCode(0.0),
includedPurposes=[UsdGeom.Tokens.default_], useExtentsHint=False)
bboxCacheYes = UsdGeom.BBoxCache(Usd.TimeCode(0.0),
includedPurposes=[UsdGeom.Tokens.default_], useExtentsHint=True)
print "-"*80
print "Testing aggregate bounds with unloaded child prims"
print "-"*80
print
prim = stage.GetPseudoRoot()
bboxNo = bboxCacheNo.ComputeWorldBound(prim)
bboxYes = bboxCacheYes.ComputeWorldBound(prim)
assert bboxNo.GetRange().IsEmpty()
assert not bboxYes.GetRange().IsEmpty()
def test_AppendFaceGroupAnimated(self):
animatedFaceSet = UsdGeom.FaceSetAPI(sphere, "animated")
# Test appending at default time.
animatedFaceSet.AppendFaceGroup(faceIndices=[0],
time=Usd.TimeCode.Default())
animatedFaceSet.AppendFaceGroup(faceIndices=[1],
time=Usd.TimeCode.Default())
faceCounts = animatedFaceSet.GetFaceCounts(Usd.TimeCode.Default())
self.assertEqual(len(faceCounts), 2)
# Test appending at the same time ordinate.
animatedFaceSet.AppendFaceGroup(faceIndices=[2], time=Usd.TimeCode(1))
animatedFaceSet.AppendFaceGroup(faceIndices=[3], time=Usd.TimeCode(1))
faceCounts = animatedFaceSet.GetFaceCounts(Usd.TimeCode(1))
self.assertEqual(len(faceCounts), 2)
# Test appending at a new time ordinate.
animatedFaceSet.AppendFaceGroup(faceIndices=[4], time=Usd.TimeCode(2))
faceCounts = animatedFaceSet.GetFaceCounts(Usd.TimeCode.Default())
self.assertEqual(len(faceCounts), 2)
faceCounts = animatedFaceSet.GetFaceCounts(Usd.TimeCode(1))
self.assertEqual(len(faceCounts), 2)
faceCounts = animatedFaceSet.GetFaceCounts(Usd.TimeCode(2))
self.assertEqual(len(faceCounts), 1)
def test_AppendTarget(self):
appendTestCollection = UsdGeom.CollectionAPI.Create(root, "AppendTest")
# Appending an empty target should result in a coding error.
with self.assertRaises(RuntimeError):
appendTestCollection.AppendTarget(Sdf.Path())
appendTestCollection.AppendTarget(sphere.GetPath(), [],
Usd.TimeCode(1))
appendTestCollection.AppendTarget(cube.GetPath(), [0, 1, 2, 3, 4],
Usd.TimeCode(1))
appendTestCollection.AppendTarget(cone.GetPath(), [], Usd.TimeCode(1))
appendTestCollection.AppendTarget(cylinder.GetPath(), [5, 6, 7, 8],
Usd.TimeCode(1))
self.assertEqual(appendTestCollection.GetTargets(), [
sphere.GetPath(),
cube.GetPath(),
cone.GetPath(),
cylinder.GetPath()
])
self.assertEqual(
list(appendTestCollection.GetTargetFaceCounts(Usd.TimeCode(1))),
[0, 5, 0, 4])
self.assertEqual(
list(appendTestCollection.GetTargetFaceIndices(Usd.TimeCode(1))),
[0, 1, 2, 3, 4, 5, 6, 7, 8])
def test_GetTimeSamples(self):
s = Usd.Stage.CreateInMemory()
x = UsdGeom.Xform.Define(s, '/World')
xlateOp = x.AddTranslateOp()
scaleOp = x.AddScaleOp()
self.assertEqual([], xlateOp.GetTimeSamples())
self.assertEqual([], scaleOp.GetTimeSamples())
xlate1 = Gf.Vec3d(10., 20., 30.)
scale2 = Gf.Vec3f(1., 2., 3.)
xlate3 = Gf.Vec3d(10., 20., 30.)
scale4 = Gf.Vec3f(1., 2., 3.)
self.assertEqual(x.GetTimeSamples(), [])
xlateOp.Set(xlate1, Usd.TimeCode(1))
self.assertEqual(x.GetTimeSamples(), [1.0])
xlateOp.Set(xlate3, Usd.TimeCode(3))
self.assertEqual(x.GetTimeSamples(), [1.0, 3.0])
scaleOp.Set(scale2, Usd.TimeCode(2))
self.assertEqual(x.GetTimeSamples(), [1.0, 2.0, 3.0])
scaleOp.Set(scale4, Usd.TimeCode(4))
self.assertEqual(x.GetTimeSamples(), [1.0, 2.0, 3.0, 4.0])
self.assertEqual([1.0, 3.0], xlateOp.GetTimeSamples())
self.assertEqual([2.0, 4.0], scaleOp.GetTimeSamples())
self.assertEqual([3.0],
xlateOp.GetTimeSamplesInInterval(Gf.Interval(2, 4)))
self.assertEqual([2.0],
scaleOp.GetTimeSamplesInInterval(Gf.Interval(0, 3)))
self.assertEqual(x.GetTimeSamplesInInterval(Gf.Interval(1.5, 3.2)),
[2.0, 3.0])
def test_CurrentFrame(self):
rootDataModel = RootDataModel()
# Default currentFrame should be TimeCode.Default()
self.assertEqual(rootDataModel.currentFrame, Usd.TimeCode.Default())
# Setting a numeric TimeCode works properly.
rootDataModel.currentFrame = Usd.TimeCode(1)
self.assertEqual(rootDataModel.currentFrame, Usd.TimeCode(1))
# Setting back to TimeCode.Default() works properly.
rootDataModel.currentFrame = Usd.TimeCode.Default()
self.assertEqual(rootDataModel.currentFrame, Usd.TimeCode.Default())
# currentFrame cannot be a number.
with self.assertRaises(ValueError):
rootDataModel.currentFrame = 1.0
# currentFrame cannot be None.
with self.assertRaises(ValueError):
rootDataModel.currentFrame = None
def test_SingularTransformOp(self):
s = Usd.Stage.CreateInMemory()
x = UsdGeom.Xform.Define(s, '/World')
transformOp = x.AddTransformOp()
singularMat = Gf.Matrix4d(32, 8, 11, 17, 8, 20, 17, 23, 11, 17, 14, 26,
17, 23, 26, 2)
transformOp.Set(singularMat, Usd.TimeCode(1.0))
# Insert a translate op in the middle , as two consecutive inverse
# ops are simply skipped when computing local transform value.
x.AddTranslateOp().Set(Gf.Vec3d(1, 1, 1))
x.AddTransformOp(isInverseOp=True)
with self.assertRaises(RuntimeError):
xform = x.GetLocalTransformation(Usd.TimeCode(1.))
# If the translateOp in the middle is removed from xformOpOrder, then
# calling GetLocalTransformation() should not result in an error as the pair
# of consecutive inverse xformOps will get skipped.
x.GetXformOpOrderAttr().Set(
Vt.TokenArray(('xformOp:transform', '!invert!xformOp:transform')))
self.assertEqual(x.GetLocalTransformation(1.0), Gf.Matrix4d(1))
def _render(self, scene):
# creating renderer
renderer = UsdImagingLite.Engine()
if not self._sync_render_settings(renderer, scene):
renderer = None
return
renderer.SetRenderViewport((0, 0, self.width, self.height))
renderer.SetRendererAov('color')
# setting camera
self._set_scene_camera(renderer, scene)
params = UsdImagingLite.RenderParams()
params.frame = Usd.TimeCode(scene.frame_current)
render_images = {
'Combined': np.empty((self.width, self.height, 4), dtype=np.float32)
}
time_begin = time.perf_counter()
while True:
if self.render_engine.test_break():
break
try:
renderer.Render(self.stage.GetPseudoRoot(), params)
except Exception as e:
# known RenderMan issue https://github.com/PixarAnimationStudios/USD/issues/1415
if isinstance(e, Tf.ErrorException) and "Failed to load plugin 'rmanOslParser'" in str(e):
pass # we won't log error "GL error: invalid operation"
else:
log.error(e)
percent_done = usd_utils.get_renderer_percent_done(renderer)
self.notify_status(percent_done / 100,
f"Render Time: {time_str(time.perf_counter() - time_begin)} | "
f"Done: {int(percent_done)}%")
if renderer.IsConverged():
break
renderer.GetRendererAov('color', render_images['Combined'].ctypes.data)
self.update_render_result(render_images)
renderer.GetRendererAov('color', render_images['Combined'].ctypes.data)
self.update_render_result(render_images)
# explicit renderer deletion
renderer = None
def main():
"""Run the main execution of the current script."""
stage = Usd.Stage.CreateInMemory()
sphere = UsdGeom.Sphere.Define(stage, "/SomeSphere")
sphere.AddTranslateOp().Set(Gf.Vec3d(20, 30, 40))
# Method #1: Compute at a certain time
print(
UsdGeom.Imageable(sphere).ComputeWorldBound(Usd.TimeCode(1),
purpose1="default"))
# Method #2: Compute using a cache
cache = UsdGeom.BBoxCache(Usd.TimeCode.Default(), ["default", "render"])
print(cache.ComputeWorldBound(sphere.GetPrim()))
def set_pointcloud_at_frame(pointcloud_geometry,
usd_pointcloud,
usd_points_prim,
frame=None):
xsi_pp = pointcloud_geometry.GetICEAttributeFromName("PointPosition")
xsi_size = pointcloud_geometry.GetICEAttributeFromName("Size")
xsi_pp_data = xsi_pp.DataArray
xsi_size_data = xsi_size.DataArray
usd_points = usd_pointcloud.CreatePointsAttr()
usd_width = usd_pointcloud.CreateWidthsAttr()
data_points = []
data_width = []
for index in range(len(xsi_pp_data)):
data_points.append(utils.vector_to_tuple(xsi_pp_data[index]))
data_width.append(
xsi_size_data[index] if index < len(xsi_size_data) else 0.0)
if frame is None:
usd_points.Set(data_points)
usd_width.Set(data_width)
else:
usd_points.Set(data_points, Usd.TimeCode(frame))
usd_width.Set(data_width, Usd.TimeCode(frame))
# set bounding box
usd_extent = usd_points_prim.CreateAttribute(
"extent", Sdf.ValueTypeNames.Float3Array)
if frame is None:
usd_extent.Set(utils.get_bounding_box(data_points))
else:
usd_extent.Set(utils.get_bounding_box(data_points),
Usd.TimeCode(frame))
def GetAttributeTextFont(attribute, frame):
if isinstance(attribute, CustomAttribute):
return None
if not isinstance(frame, Usd.TimeCode):
frame = Usd.TimeCode(frame)
frameVal = frame.GetValue()
bracketing = attribute.GetBracketingTimeSamples(frameVal)
# Note that some attributes return an empty tuple, some None, from
# GetBracketingTimeSamples(), but all will be fed into this function.
if bracketing and (len(bracketing) == 2) and (bracketing[0] != frameVal):
return ItalicFont
return None
def _render_gl(self, scene):
CLEAR_DEPTH = 1.0
# creating draw_target
draw_target = Glf.DrawTarget(self.width, self.height)
draw_target.Bind()
draw_target.AddAttachment("color", bgl.GL_RGBA, bgl.GL_FLOAT, bgl.GL_RGBA)
# creating renderer
renderer = UsdImagingGL.Engine()
if not self._sync_render_settings(renderer, scene):
renderer = None
return
# setting camera
self._set_scene_camera(renderer, scene)
renderer.SetRenderViewport((0, 0, self.width, self.height))
renderer.SetRendererAov('color')
root = self.stage.GetPseudoRoot()
params = UsdImagingGL.RenderParams()
params.renderResolution = (self.width, self.height)
params.frame = Usd.TimeCode(scene.frame_current)
if scene.hdusd.final.data_source:
world_data = world.WorldData.init_from_stage(self.stage)
else:
world_data = world.WorldData.init_from_world(scene.world)
params.clearColor = world_data.clear_color
try:
renderer.Render(root, params)
except Exception as e:
log.error(e)
self.update_render_result({
'Combined': gl.get_framebuffer_data(self.width, self.height)
})
draw_target.Unbind()
# it's important to clear data explicitly
draw_target = None
renderer = None
def _set_blendshape_weights(self, skel_anim, usd_node, gltf_node):
animations = self.gltf_loader.get_animations()
if (len(animations) > 0): # only support first animation group
animation = animations[0]
animation_channels = animation.get_animation_channels_for_node(gltf_node)
for animation_channel in animation_channels:
if animation_channel.target.path == 'weights':
output_data = animation_channel.sampler.get_output_data()
input_data = animation_channel.sampler.get_input_data()
output_data_entries = []
for index in range(0, len(output_data)/2):
output_data_entries.append([output_data[index * 2], output_data[index * 2 + 1]])
usd_blend_shape_weights = skel_anim.CreateBlendShapeWeightsAttr()
for entry in zip(output_data_entries, input_data):
usd_blend_shape_weights.Set(Vt.FloatArray(entry[0]), Usd.TimeCode(entry[1] * self.fps))
def TestBug113044():
stage = Usd.Stage.Open("animVis.usda")
bboxCache = UsdGeom.BBoxCache(Usd.TimeCode(0.0),
includedPurposes=[UsdGeom.Tokens.default_])
pseudoRoot = stage.GetPrimAtPath("/")
assert bboxCache.ComputeWorldBound(pseudoRoot).GetRange().IsEmpty()
# The cube is visible at frame 1. This should invalidate the bounds at '/'
# and cause the bbox to be non-empty.
bboxCache.SetTime(1.0)
assert not bboxCache.ComputeWorldBound(pseudoRoot).GetRange().IsEmpty()
bboxCache.SetTime(2.0)
assert bboxCache.ComputeWorldBound(pseudoRoot).GetRange().IsEmpty()
bboxCache.SetTime(3.0)
assert not bboxCache.ComputeWorldBound(pseudoRoot).GetRange().IsEmpty()
def test_SetFromCamera(self):
camera = Gf.Camera()
usdStage = Usd.Stage.CreateInMemory()
usdCamera = UsdGeom.Camera.Define(usdStage, '/camera')
usdCameraProj = usdCamera.GetProjectionAttr()
# test fall-back values
self._CheckValues(camera, usdCamera, 1.0)
self.assertEqual(usdCameraProj.GetResolveInfo().GetSource(),
Usd.ResolveInfoSourceFallback)
camera.transform = (
Gf.Matrix4d().SetRotate(Gf.Rotation(Gf.Vec3d(1.0, 2.0, 3.0), 10.0))
* Gf.Matrix4d().SetTranslate(Gf.Vec3d(4.0, 5.0, 6.0)))
camera.projection = Gf.Camera.Orthographic
camera.horizontalAperture = 5.1
camera.verticalAperture = 2.0
camera.horizontalApertureOffset = 0.13
camera.verticalApertureOffset = -0.14
camera.focalLength = 28
camera.clippingRange = Gf.Range1f(5, 15)
camera.clippingPlanes = [[1, 2, 3, 4], [8, 7, 6, 5]]
camera.fStop = 1.2
camera.focusDistance = 300
usdCamera.SetFromCamera(camera, 1.0)
# test assigned values
self._CheckValues(camera, usdCamera, 1.0)
self.assertEqual(usdCameraProj.GetResolveInfo().GetSource(),
Usd.ResolveInfoSourceTimeSamples)
usdCamera.SetFromCamera(camera, 1.0)
actual = usdCamera.GetLocalTransformation(Usd.TimeCode(1.0))
expected = Gf.Matrix4d(0.9858929135, 0.14139860385, -0.089563373740,
0.0, -0.1370579618, 0.98914839500,
0.052920390613, 0.0, 0.0960743367,
-0.03989846462, 0.994574197504, 0.0, 4.0, 5.0,
6.0, 1.0)
for a, e in zip(actual, expected):
self.assertTrue(Gf.IsClose(a, e, 1e-2))
def sync(self, context, depsgraph):
log('Start sync')
scene = depsgraph.scene
settings = self.get_settings(scene)
self.is_gl_delegate = settings.is_gl_delegate
self.space_data = context.space_data
self.shading_data = world.ShadingData(context, depsgraph.scene.world)
self.render_params = UsdImagingGL.RenderParams()
self.render_params.frame = Usd.TimeCode(scene.frame_current)
self.renderer = UsdImagingGL.Engine()
self._sync(context, depsgraph)
usd_utils.set_delegate_variant_stage(self.stage,
settings.delegate_name)
self.is_synced = True
log('Finish sync')
