def test_Basic(self):
# Test CopyLayerMetadata()
source = Sdf.Layer.FindOrOpen('layerWithMetadata.usda')
self.assertTrue(source)
keysToCompare = [
x for x in source.pseudoRoot.ListInfoKeys()
if (x not in ['subLayers', 'subLayerOffsets'])
]
cpy = Sdf.Layer.CreateNew("cpy.usda")
self.assertTrue(cpy)
UsdUtils.CopyLayerMetadata(source, cpy)
for key in ['subLayers'] + keysToCompare:
self.assertEqual(source.pseudoRoot.GetInfo(key),
cpy.pseudoRoot.GetInfo(key))
# bug #127687 - can't use GetInfo() for subLayerOffsets
self.assertEqual(source.subLayerOffsets, cpy.subLayerOffsets)
cpyNoSublayers = Sdf.Layer.CreateNew("cpyNoSublayers.usda")
self.assertTrue(cpyNoSublayers)
UsdUtils.CopyLayerMetadata(source, cpyNoSublayers, skipSublayers=True)
self.assertFalse(cpyNoSublayers.pseudoRoot.HasInfo('subLayers'))
self.assertFalse(cpyNoSublayers.pseudoRoot.HasInfo('subLayerOffsets'))
for key in keysToCompare:
self.assertEqual(source.pseudoRoot.GetInfo(key),
cpyNoSublayers.pseudoRoot.GetInfo(key))
def setUp(self):
self.layers = [
Sdf.Layer.CreateAnonymous(),
Sdf.Layer.FindOrOpen('src/Particles_Splash.101.usd'),
Sdf.Layer.FindOrOpen('src/Particles_Splash.103.usd'),
Sdf.Layer.CreateAnonymous(),
Sdf.Layer.FindOrOpen('src/letters_perFrame.101.usda'),
Sdf.Layer.FindOrOpen('src/letters_perFrame.102.usda'),
Sdf.Layer.FindOrOpen('src/letters_perFrame.103.usda')
]
self.rootprims_combined = None
self.rootprims_a = None
self.rootprims_b = None
# stitch layers for basic tests
UsdUtils.StitchLayers(self.layers[0], self.layers[1])
UsdUtils.StitchLayers(self.layers[0], self.layers[2])
self.rootprims_combined = self.layers[0].rootPrims
self.rootprims_a = self.layers[1].rootPrims
self.rootprims_b = self.layers[2].rootPrims
# stitch layers for secondary tests
UsdUtils.StitchLayers(self.layers[3], self.layers[4])
UsdUtils.StitchLayers(self.layers[3], self.layers[5])
UsdUtils.StitchLayers(self.layers[3], self.layers[6])
def test_Basic(self):
# Test CopyLayerMetadata()
source = Sdf.Layer.FindOrOpen('layerWithMetadata.usda')
self.assertTrue(source)
keysToCompare = [x for x in source.pseudoRoot.ListInfoKeys() if
(x not in ['subLayers', 'subLayerOffsets'])]
cpy = Sdf.Layer.CreateNew("cpy.usda")
self.assertTrue(cpy)
UsdUtils.CopyLayerMetadata(source, cpy)
for key in ['subLayers'] + keysToCompare:
self.assertEqual(source.pseudoRoot.GetInfo(key),
cpy.pseudoRoot.GetInfo(key))
# bug #127687 - can't use GetInfo() for subLayerOffsets
self.assertEqual(source.subLayerOffsets, cpy.subLayerOffsets)
cpyNoSublayers = Sdf.Layer.CreateNew("cpyNoSublayers.usda")
self.assertTrue(cpyNoSublayers)
UsdUtils.CopyLayerMetadata(source, cpyNoSublayers, skipSublayers=True,
bakeUnauthoredFallbacks=True)
self.assertFalse(cpyNoSublayers.pseudoRoot.HasInfo('subLayers'))
self.assertFalse(cpyNoSublayers.pseudoRoot.HasInfo('subLayerOffsets'))
for key in keysToCompare:
self.assertEqual(source.pseudoRoot.GetInfo(key),
cpyNoSublayers.pseudoRoot.GetInfo(key))
# Ensure that the color config fallbacks get stamped out when
# bakeUnauthoredFallbacks is set to true.
fallbackKeysToCompare = ['colorConfiguration', 'colorManagementSystem']
colorConfigFallbacks = Usd.Stage.GetColorConfigFallbacks()
self.assertEqual(colorConfigFallbacks,
(cpyNoSublayers.pseudoRoot.GetInfo(Sdf.Layer.ColorConfigurationKey),
cpyNoSublayers.pseudoRoot.GetInfo(Sdf.Layer.ColorManagementSystemKey)))
def CheckCompliance(self, inputFile):
from pxr import Sdf, Usd, UsdUtils
if not Usd.Stage.IsSupportedFile(inputFile):
_AddError("Cannot open file '%s' on a USD stage." % args.inputFile)
return
# Collect all warnings using a diagnostic delegate.
delegate = UsdUtils.CoalescingDiagnosticDelegate()
usdStage = Usd.Stage.Open(inputFile)
stageOpenDiagnostics = delegate.TakeUncoalescedDiagnostics()
for rule in self._rules:
rule.CheckStage(usdStage)
rule.CheckDiagnostics(stageOpenDiagnostics)
with Ar.ResolverContextBinder(usdStage.GetPathResolverContext()):
# This recursively computes all of inputFiles's external
# dependencies.
(allLayers, allAssets, unresolvedPaths) = \
UsdUtils.ComputeAllDependencies(Sdf.AssetPath(inputFile))
for rule in self._rules:
rule.CheckUnresolvedPaths(unresolvedPaths)
rule.CheckDependencies(usdStage, allLayers, allAssets)
if self._rootPackageOnly:
rootLayer = usdStage.GetRootLayer()
if rootLayer.GetFileFormat().IsPackage():
packagePath = Ar.SplitPackageRelativePathInner(
rootLayer.identifier)[0]
self._CheckPackage(packagePath)
else:
self._AddError(
"Root layer of the USD stage (%s) doesn't belong to "
"a package, but 'rootPackageOnly' is True!" %
Usd.Describe(usdStage))
else:
# Process every package just once by storing them all in a set.
packages = set()
for layer in allLayers:
if _IsPackageOrPackagedLayer(layer):
packagePath = Ar.SplitPackageRelativePathInner(
layer.identifier)[0]
packages.add(packagePath)
self._CheckLayer(layer)
for package in packages:
self._CheckPackage(package)
# Traverse the entire stage and check every prim.
from pxr import Usd
# Author all variant switches in the session layer.
usdStage.SetEditTarget(usdStage.GetSessionLayer())
allPrimsIt = iter(
Usd.PrimRange.Stage(usdStage,
Usd.TraverseInstanceProxies()))
self._TraverseRange(allPrimsIt, isStageRoot=True)
def test_StitchTopologyOnly(self):
# Generate a fresh topology
topologyLayer = Sdf.Layer.CreateNew('topologyLayer.usd')
UsdUtils.StitchClipsTopology(topologyLayer, self.layerFileNames[:7])
self.assertTrue(topologyLayer)
self.assertTrue(topologyLayer.GetPrimAtPath(self.clipPath))
# Aggregate into an existing topology
newClipPath = Sdf.Path('/World/fx/points')
UsdUtils.StitchClipsTopology(topologyLayer, self.layerFileNames[8:10])
self.assertTrue(topologyLayer)
self.assertTrue(topologyLayer.GetPrimAtPath(newClipPath))
def delegateSetup(stringIncFilders, codePathIncFilters, stringExcFilters,
codePathExcFilters):
incFilter = UsdUtils.ConditionalAbortDiagnosticDelegateErrorFilters()
excFilter = UsdUtils.ConditionalAbortDiagnosticDelegateErrorFilters()
if stringIncFilders:
incFilter.SetStringFilters(stringIncFilders)
if codePathIncFilters:
incFilter.SetCodePathFilters(codePathIncFilters)
if stringExcFilters:
excFilter.SetStringFilters(stringExcFilters)
if codePathExcFilters:
excFilter.SetCodePathFilters(codePathExcFilters)
return UsdUtils.ConditionalAbortDiagnosticDelegate(incFilter, excFilter)
def test_TopologySublayerAuthoring(self):
resultLayer = Sdf.Layer.CreateNew('sublayerTopology.usd')
UsdUtils.StitchClips(resultLayer, self.layerFileNames[:7], self.clipPath)
self.assertEqual(list(resultLayer.subLayerPaths),
['./sublayerTopology.topology.usd'])
resultLayer = Sdf.Layer.CreateNew('foo.usd')
topLayer = Sdf.Layer.CreateNew('foo.topology.usd')
UsdUtils.StitchClipsTemplate(resultLayer, topLayer, self.clipPath,
'asset.#.usd', 101, 120, 1)
self.assertEqual(list(resultLayer.subLayerPaths),
['./foo.topology.usd'])
def check_usd_compliance(rootLayer, arkit=False):
#An API change in v18.11 changed the sytax for UsdUtils.ComplianceChecker...
if Usd.GetMinorVersion() >= 18 and Usd.GetPatchVersion() >= 11:
checker = UsdUtils.ComplianceChecker(arkit=arkit, skipARKitRootLayerCheck=False)
checker.CheckCompliance(rootLayer)
else:
#Behavior in v18.09
checker = UsdUtils.ComplianceChecker(rootLayer, arkit=arkit, skipARKitRootLayerCheck=False)
errors = checker.GetErrors()
failedChecks = checker.GetFailedChecks()
for msg in errors + failedChecks:
print(msg)
return len(errors) == 0 and len(failedChecks) == 0
def test_Basic(self):
lyr1 = Sdf.Layer.FindOrOpen('BottleMedicalDefaultPrim.usd')
self.assertTrue(lyr1)
self.assertEqual(UsdUtils.GetModelNameFromRootLayer(lyr1),
'BottleMedical')
lyr2 = Sdf.Layer.FindOrOpen('BottleMedicalSameName.usd')
self.assertTrue(lyr2)
self.assertEqual(UsdUtils.GetModelNameFromRootLayer(lyr2),
'BottleMedicalSameName')
lyr3 = Sdf.Layer.FindOrOpen('BottleMedicalRootPrim.usd')
self.assertTrue(lyr3)
self.assertEqual(UsdUtils.GetModelNameFromRootLayer(lyr3),
'BottleMedical')
def test_APISchemaGen(self):
sdrNode = self._GetSdrNode("testSdrNodeAPISchema.usda",
"/TestSchemaAPI")
self.assertTrue(sdrNode)
resultLayer = Sdf.Layer.CreateNew("./resultAPISchema.usda")
UsdUtils.UpdateSchemaWithSdrNode(resultLayer, sdrNode,
"myRenderContext")
def PrintTree(args, path):
if args.flatten:
popMask = (None if args.populationMask is None else
Usd.StagePopulationMask())
if popMask:
for mask in args.populationMask:
popMask.Add(mask)
if popMask:
if args.unloaded:
stage = Usd.Stage.OpenMasked(path, popMask, Usd.Stage.LoadNone)
else:
stage = Usd.Stage.OpenMasked(path, popMask)
else:
if args.unloaded:
stage = Usd.Stage.Open(path, Usd.Stage.LoadNone)
else:
stage = Usd.Stage.Open(path)
PrintStage(args, stage)
elif args.flattenLayerStack:
from pxr import UsdUtils
stage = Usd.Stage.Open(path, Usd.Stage.LoadNone)
layer = UsdUtils.FlattenLayerStack(stage)
PrintLayer(args, layer)
else:
from pxr import Sdf
layer = Sdf.Layer.FindOrOpen(path)
PrintLayer(args, layer)
def testCameraCmdlineArgs(self):
"""
Tests argument parsing when camera-related args are added.
"""
UsdAppUtils.cameraArgs.AddCmdlineArgs(self._parser)
# By default, the camera arg should contain the primary camera name.
args = self._parser.parse_args([])
self.assertEqual(type(args.camera), Sdf.Path)
self.assertEqual(args.camera.pathString,
UsdUtils.GetPrimaryCameraName())
args = self._parser.parse_args(['--camera', 'MainCamera'])
self.assertEqual(type(args.camera), Sdf.Path)
self.assertEqual(args.camera.pathString, 'MainCamera')
args = self._parser.parse_args(['-cam', 'MainCamera'])
self.assertEqual(type(args.camera), Sdf.Path)
self.assertEqual(args.camera.pathString, 'MainCamera')
args = self._parser.parse_args(['--camera', '/Path/To/Some/Camera'])
self.assertEqual(type(args.camera), Sdf.Path)
self.assertEqual(args.camera.pathString, '/Path/To/Some/Camera')
args = self._parser.parse_args(['--camera', ''])
self.assertEqual(type(args.camera), Sdf.Path)
self.assertEqual(args.camera, Sdf.Path.emptyPath)
# Test adding camera args with a different default value.
parser = argparse.ArgumentParser(prog=self._progName)
UsdAppUtils.cameraArgs.AddCmdlineArgs(parser,
defaultValue='MainCamera')
args = parser.parse_args([])
self.assertEqual(type(args.camera), Sdf.Path)
self.assertEqual(args.camera.pathString, 'MainCamera')
def testSkelMissingJointFromDagPose(self):
"""
Check that dagPoses that don't contain all desired joints issue an
appropriate warning
"""
mayaFile = os.path.join(self.inputPath, "UsdExportSkeletonTest", "UsdExportSkeletonBindPoseMissingJoints.ma")
cmds.file(mayaFile, force=True, open=True)
usdFile = os.path.abspath('UsdExportBindPoseMissingJointsTest.usda')
joints = cmds.listRelatives('joint_grp', allDescendents=True, type='joint')
bindMembers = cmds.dagPose('dagPose1', q=1, members=1)
nonBindJoints = [j for j in joints if j not in bindMembers]
self.assertEqual(nonBindJoints, [u'joint4'])
delegate = UsdUtils.CoalescingDiagnosticDelegate()
cmds.select('joint_grp')
cmds.mayaUSDExport(mergeTransformAndShape=True, file=usdFile, shadingMode='none',
exportSkels='auto', selection=True)
messages = delegate.TakeUncoalescedDiagnostics()
warnings = [x.commentary for x in messages if x.diagnosticCode == Tf.TF_DIAGNOSTIC_WARNING_TYPE]
missingJointWarnings = [x for x in warnings if 'is not a member of dagPose' in x]
self.assertEqual(len(missingJointWarnings), 1)
self.assertIn("Node 'joint4' is not a member of dagPose 'dagPose1'",
missingJointWarnings[0])
def dep(usdfile, level=1):
id = '-' * (level)
# print('UsdUtilsExtractExternalReferences'.center(40, '-'))
print(id, usdfile)
sublayers, references, payloads = UsdUtils.ExtractExternalReferences(
usdfile)
if sublayers:
print(id, 'SUBLAYERS')
for sublayer in sublayers:
# print(id, sublayer)
refpath = os.path.normpath(
os.path.join(os.path.dirname(usdfile), sublayer))
dep(refpath, level=level + 1)
if references:
print(id, 'REFERENCES')
for reference in references:
# print(id, reference)
refpath = os.path.normpath(
os.path.join(os.path.dirname(usdfile), reference))
dep(refpath, level=level + 1)
if payloads:
print(id, 'PAYLOADS')
for payload in payloads:
# print(id, payload)
refpath = os.path.normpath(
os.path.join(os.path.dirname(usdfile), payload))
dep(refpath, level=level + 1)
def test_rmanConcreteSchema(self):
sdrNode = self._GetSdrNode("testSdrNodeConcreteSchema.usda",
"/TestSchemaConcrete")
self.assertTrue(sdrNode)
resultLayer = Sdf.Layer.CreateNew("./schemaConcrete.usda")
UsdUtils.UpdateSchemaWithSdrNode(resultLayer, sdrNode,
"myRenderContext")
def test_OmitDuplicatePropertiesTypeMismatch(self):
sdrNode = self._GetSdrNode("testDuplicatePropsTypeMismatch.usda",
"/TestDuplicatePropsAPI")
self.assertTrue(sdrNode)
resultLayer = Sdf.Layer.CreateNew("./duplicatePropTypeMisMatch.usda")
UsdUtils.UpdateSchemaWithSdrNode(resultLayer, sdrNode,
"myRenderContext")
def test_OverrideAPISchemaGen(self):
sdrNode = self._GetSdrNode("testSdrNodeAPISchema.usda",
"/TestSchemaAPI")
self.assertTrue(sdrNode)
resultLayer = Sdf.Layer.FindOrOpen("./result_override.usda")
UsdUtils.UpdateSchemaWithSdrNode(resultLayer, sdrNode,
"myRenderContext")
def test_APIIdentifierMissing(self):
sdrNode = self._GetSdrNode("testAPIIdentifierMissing.usda",
"/APIIdentifierMissing")
self.assertTrue(sdrNode)
resultLayer = Sdf.Layer.CreateNew("./resultAPIIdentifierMissing.usda")
UsdUtils.UpdateSchemaWithSdrNode(resultLayer, sdrNode,
"myRenderContext")
def GetFlattenedLayerStack(filePath):
from pxr import Ar, Sdf, Pcp, Usd, UsdUtils
if hasattr(Ar.Resolver, "ConfigureResolverForAsset"):
Ar.GetResolver().ConfigureResolverForAsset(filePath)
stage = Usd.Stage.Open(filePath, Usd.Stage.LoadNone)
return UsdUtils.FlattenLayerStack(stage)
def setUp(self):
if not hasattr(self, 'setupComplete'):
self.layerFileNames = [
'src/Particles_Splash.101.usd', 'src/Particles_Splash.102.usd',
'src/Particles_Splash.103.usd', 'src/Particles_Splash.104.usd',
'src/Particles_Splash.105.usd', 'src/Particles_Splash.106.usd',
'src/Particles_Splash.107.usd', 'src/Particles_Splash.108.usd',
'src/PTS_dev.1.usd', 'src/PTS_dev.2.usd', 'src/PTS_dev.3.usd',
'src/PTS_dev.4.usd', 'src/PTS_dev.5.usd', 'src/PTS_dev.6.usd',
'src/PTS_dev.7.usd', 'src/PTS_dev.8.usd', 'src/PTS_dev.9.usd',
'src/PTS_dev.10.usd', 'src/PTS_dev.11.usd',
'src/PTS_dev.12.usd', 'src/PTS_dev.13.usd',
'src/PTS_dev.14.usd', 'src/PTS_dev.15.usd',
'src/PTS_dev.16.usd', 'src/PTS_dev.17.usd',
'src/PTS_dev.18.usd', 'src/PTS_dev.19.usd',
'src/PTS_dev.20.usd', 'src/PTS_dev.21.usd',
'src/PTS_dev.22.usd', 'src/PTS_dev.23.usd',
'src/PTS_dev.24.usd'
]
self.clipPath = Sdf.Path('/World/fx/Particles_Splash')
self.baseName = 'testModelClips.usd'
self.startTimeCode = 101
self.endTimeCode = 108
rootLayer = Sdf.Layer.FindOrOpen(self.baseName)
self.rootLayer = rootLayer if rootLayer else Sdf.Layer.CreateNew(
self.baseName)
UsdUtils.StitchClips(self.rootLayer, self.layerFileNames[0:7],
self.clipPath, self.startTimeCode,
self.endTimeCode)
self.setupComplete = True
def test_ClipAssetPaths(self):
src_stage = Usd.Stage.Open('root.usda')
def replaceWithFoo(layer, s):
return 'foo'
layer = UsdUtils.FlattenLayerStack(src_stage,
resolveAssetPathFn=replaceWithFoo)
result_stage = Usd.Stage.Open(layer)
# Confirm offsets have been folded into value clips.
p = layer.GetPrimAtPath('/SphereUsingClip')
self.assertEqual(
p.GetInfo('clips')['default']['active'],
Vt.Vec2dArray(1, [(-9.0, 0)]))
self.assertEqual(
p.GetInfo('clips')['default']['times'],
Vt.Vec2dArray(2, [(-9.0, 1), (0.0, 10)]))
# And confirm clip asset paths have been updated.
self.assertEqual(
p.GetInfo('clips')['default']['manifestAssetPath'],
Sdf.AssetPath('foo'))
self.assertEqual(list(p.GetInfo('clips')['default']['assetPaths']),
[Sdf.AssetPath('foo')])
def test_GenerateTopologyName(self):
names = [("/foo/bar/baz.foo.usd", "/foo/bar/baz.foo.topology.usd"),
("foo.usda", "foo.topology.usda"),
("./mars.usd", "./mars.topology.usd")]
for (original, expected) in names:
self.assertEqual(UsdUtils.GenerateClipTopologyName(original),
expected)
def test_ComputeAllDependenciesInvalidClipTemplate(self):
"""Test that an invalid clip template asset path does not
cause an exception in UsdUtils.ComputeAllDependencies."""
stage = Usd.Stage.CreateNew('testInvalidClipTemplate.usda')
prim = stage.DefinePrim('/clip')
Usd.ClipsAPI(prim).SetClipTemplateAssetPath('bogus')
stage.Save()
UsdUtils.ComputeAllDependencies(stage.GetRootLayer().identifier)
def test_UsdShadeConnectableAPIMetadata2(self):
sdrNode = self._GetSdrNode("testUsdShadeConnectableAPI2.usda",
"/TestUsdShadeConnectableAPIMetadataAPI")
self.assertTrue(sdrNode)
resultLayer = \
Sdf.Layer.CreateNew("./resultUsdShadeConnectableAPIMetadata2.usda")
UsdUtils.UpdateSchemaWithSdrNode(resultLayer, sdrNode,
"myRenderContext")
def __init__(self,
inputFile,
arkit=False,
skipARKitRootLayerCheck=False,
rootPackageOnly=False,
skipVariants=False,
verbose=False):
self._arkit = arkit
self._skipARKitRootLayerCheck = skipARKitRootLayerCheck
self._rootPackageOnly = rootPackageOnly
self._doVariants = not skipVariants
self._verbose = verbose
self._failedChecks = []
self._errors = []
self._violatedRules = set()
self._checkedPackages = set()
from pxr import Ar, Sdf, Usd, UsdUtils
if not Usd.Stage.IsSupportedFile(inputFile):
_AddError("Cannot open file '%s' on a USD stage." % args.inputFile)
return
# Collect all warnings using a diagnostic delegate.
delegate = UsdUtils.CoalescingDiagnosticDelegate()
usdStage = Usd.Stage.Open(inputFile)
allDiagnostics = delegate.TakeUncoalescedDiagnostics()
if self._arkit:
for diag in allDiagnostics:
# "_ReportErrors" is the name of the function that issues
# warnings about unresolved references, sublayers and other
# composition arcs.
if '_ReportErrors' in diag.sourceFunction and \
'usd/stage.cpp' in diag.sourceFileName:
self._AddFailedCheck(diag.commentary, ruleNum=4)
with Ar.ResolverContextBinder(usdStage.GetPathResolverContext()):
# This recursively computes all of inputFiles's external
# dependencies.
(allLayerDeps, allAssetDeps, unresolvedPaths) = \
UsdUtils.ComputeAllDependencies(Sdf.AssetPath(inputFile))
self._CheckDependencies(usdStage, allLayerDeps, allAssetDeps,
unresolvedPaths)
self._CheckStage(usdStage, allLayerDeps)
def test_ExplicitEndCodes(self):
start = 104
end = 105
resultLayer = Sdf.Layer.CreateNew('explicitEndCodes.usd')
UsdUtils.StitchClips(resultLayer, self.layerFileNames[:7],
self.clipPath, start, end)
self.assertEqual(resultLayer.startTimeCode, start)
self.assertEqual(resultLayer.endTimeCode, end)
def convert_to_usd(gltf_file,
usd_file,
fps,
scale,
arkit=False,
verbose=False,
use_euler_rotation=False):
"""Converts a glTF file to USD
Arguments:
gltf_file {str} -- path to glTF file
usd_file {str} -- path to write USD file
Keyword Arguments:
verbose {bool} -- [description] (default: {False})
"""
usd = GLTF2USD(gltf_file=gltf_file,
usd_file=usd_file,
fps=fps,
scale=scale,
verbose=verbose,
use_euler_rotation=use_euler_rotation)
if usd.stage:
asset = usd.stage.GetRootLayer()
usd.logger.info('Conversion complete!')
asset.Save()
usd.logger.info('created {}'.format(asset.realPath))
if usd_file.endswith('.usdz') or usd_file.endswith('.usdc'):
usdc_file = '%s.%s' % (os.path.splitext(usd_file)[0], 'usdc')
asset.Export(usdc_file, args=dict(format='usdc'))
usd.logger.info('created {}'.format(usdc_file))
if usd_file.endswith('.usdz'):
r = Ar.GetResolver()
resolved_asset = r.Resolve(usdc_file)
context = r.CreateDefaultContextForAsset(resolved_asset)
success = check_usd_compliance(resolved_asset, arkit=args.arkit)
with Ar.ResolverContextBinder(context):
if arkit and not success:
usd.logger.warning('USD is not ARKit compliant')
return
success = UsdUtils.CreateNewUsdzPackage(
resolved_asset, usd_file) and success
if success:
usd.logger.info(
'created package {} with contents:'.format(usd_file))
zip_file = Usd.ZipFile.Open(usd_file)
file_names = zip_file.GetFileNames()
for file_name in file_names:
usd.logger.info('\t{}'.format(file_name))
else:
usd.logger.error('could not create {}'.format(usd_file))
def check_usd_compliance(rootLayer, arkit=False):
checker = UsdUtils.ComplianceChecker(rootLayer,
arkit=arkit,
skipARKitRootLayerCheck=False)
errors = checker.GetErrors()
failedChecks = checker.GetFailedChecks()
for msg in errors + failedChecks:
print(msg)
return len(errors) == 0 and len(failedChecks) == 0
def test_NumericalPrecisionLoss(self):
rootLayerFile = 'numericalPrecision.usd'
clipPath = Sdf.Path("/World/fx/points")
rootLayer = Sdf.Layer.CreateNew(rootLayerFile)
UsdUtils.StitchClips(rootLayer, self.layerFileNames[8:], clipPath)
self.assertTrue(rootLayer)
self.assertEqual(rootLayer.startTimeCode, 1.00000)
# previously, the precision error was causing
# us to end up with an end frame of 24.0006
self.assertEqual(rootLayer.endTimeCode, 24.000000)
def GetUsdLayerMetaData(filePath):
"""Return an SdfLayer holding just the layer metadata of the given layer."""
from pxr import Sdf, UsdUtils
srcLayer = Sdf.Layer.OpenAsAnonymous(filePath, metadataOnly=True)
# Not all file format plugins support metadata-only parsing.
# Create a new anonymous layer and copy just the layer metadata.
layer = Sdf.Layer.CreateAnonymous(filePath,
Sdf.FileFormat.FindById('usda'))
UsdUtils.CopyLayerMetadata(srcLayer, layer)
return layer
