def _CheckPackage(self, packagePath):
self._Msg("Checking package <%s>." % packagePath)
# XXX: Should we open the package on a stage to ensure that it is valid
# and entirely self-contained.
from pxr import Ar, Usd
pkgExt = Ar.GetResolver().GetExtension(packagePath)
if self._arkit and pkgExt != "usdz":
self._AddFailedCheck(
"Package at path %s has an invalid extension." % packagePath,
ruleNum=5)
return
# Check the parent package first.
if Ar.IsPackageRelativePath(packagePath):
parentPackagePath = Ar.SplitPackageRelativePathInner(
packagePath)[0]
self._CheckPackage(parentPackagePath)
# Avoid checking the same parent package multiple times.
if packagePath in self._checkedPackages:
return
self._checkedPackages.add(packagePath)
resolvedPath = Ar.GetResolver().Resolve(packagePath)
if len(resolvedPath) == 0:
self._AddError("Failed to resolve package path '%s'." %
packagePath)
return
zipFile = Usd.ZipFile.Open(resolvedPath)
if not zipFile:
self._AddError("Could not open package at path '%s'." %
resolvedPath)
return
fileNames = zipFile.GetFileNames()
for fileName in fileNames:
fileExt = Ar.GetResolver().GetExtension(fileName)
if fileExt not in ComplianceChecker._allowedFileExtensions:
self._AddFailedCheck(
"File '%s' in package '%s' has unknown or "
"unsupported extension '%s'." %
(fileName, packagePath, fileExt),
ruleNum=[4, 5])
fileInfo = zipFile.GetFileInfo(fileName)
offset = fileInfo.dataOffset
if offset % 64 != 0:
self._AddFailedCheck(
"File '%s' in package '%s' has an invalid "
"offset %s." % (fileName, packagePath, offset),
ruleNum=1)
if fileInfo.compressionMethod != 0:
self._AddFailedCheck(
"File '%s' in package '%s' has "
"compression. Compression method is '%s', actual size is "
"%s. Uncompressed size is %s." %
(fileName, packagePath, fileInfo.compressionMethod,
fileInfo.size, fileInfo.uncompressedSize),
ruleNum=2)
def test_ResolveWithDefaultAssetContext(self):
assetFileName = 'test_Asset.txt'
assetFilePath = os.path.abspath(assetFileName)
with open(assetFilePath, 'w') as ofp:
print('Garbage', file=ofp)
testFileName = 'test_SiblingOfAsset.txt'
testFilePath = os.path.abspath(testFileName)
with open(testFilePath, 'w') as ofp:
print('Garbage', file=ofp)
# We use the non-absolute assetFileName to test the
# cwd-anchoring behavior of CreateDefaultContextForAsset()
context = Ar.GetResolver().CreateDefaultContextForAsset(assetFileName)
with Ar.ResolverContextBinder(context):
resolvedPath = Ar.GetResolver().Resolve(testFileName)
self.assertPathsEqual(resolvedPath, testFilePath)
# Make sure we get the same behavior using ConfigureResolverForAsset()
Ar.GetResolver().ConfigureResolverForAsset(assetFileName)
with Ar.ResolverContextBinder(Ar.GetResolver().CreateDefaultContext()):
defaultResolvedPath = Ar.GetResolver().Resolve(testFileName)
self.assertPathsEqual(defaultResolvedPath, testFilePath)
def _CheckPackage(self, packagePath):
self._Msg("Checking package <%s>." % packagePath)
# XXX: Should we open the package on a stage to ensure that it is valid
# and entirely self-contained.
from pxr import Usd
pkgExt = Ar.GetResolver().GetExtension(packagePath)
if pkgExt != "usdz":
self._AddError("Package at path %s has an invalid extension."
% packagePath)
return
# Check the parent package first.
if Ar.IsPackageRelativePath(packagePath):
parentPackagePath = Ar.SplitPackageRelativePathInner(packagePath)[0]
self._CheckPackage(parentPackagePath)
# Avoid checking the same parent package multiple times.
if packagePath in self._checkedPackages:
return
self._checkedPackages.add(packagePath)
resolvedPath = Ar.GetResolver().Resolve(packagePath)
if len(resolvedPath) == 0:
self._AddError("Failed to resolve package path '%s'." % packagePath)
return
zipFile = Usd.ZipFile.Open(resolvedPath)
if not zipFile:
self._AddError("Could not open package at path '%s'." %
resolvedPath)
return
for rule in self._rules:
rule.CheckZipFile(zipFile, packagePath)
def _getFileFormat(path):
from pxr import Sdf, Ar
# Note that python's os.path.splitext retains the '.' portion
# when obtaining an extension, but Sdf's Fileformat API doesn't
# expect one. We also make sure to prune out any version specifiers.
_, ext = os.path.splitext(path)
path = Ar.GetResolver().Resolve(path)
if path is None:
return None
if len(ext) <= 1:
fileFormat = Sdf.FileFormat.FindByExtension('usd')
else:
prunedExtension = ext[1:]
versionSpecifierPos = prunedExtension.rfind('#')
if versionSpecifierPos != -1:
prunedExtension = prunedExtension[:versionSpecifierPos]
fileFormat = Sdf.FileFormat.FindByExtension(prunedExtension)
# Don't check if file exists - this should be handled by resolver (and
# path may not exist / have been fetched yet)
if fileFormat:
return fileFormat.formatId
return None
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 test_ResolveForNewAsset(self):
resolver = Ar.GetResolver()
# ResolveForNewAsset returns the path a new asset would be written
# to for a given asset path. ArDefaultResolver assumes all asset paths
# are filesystem paths, so this is just the absolute path of the
# input.
self.assertPathsEqual(
resolver.ResolveForNewAsset('/test/path/1/newfile'),
os.path.abspath('/test/path/1/newfile'))
self.assertPathsEqual(
resolver.ResolveForNewAsset('test/path/1/newfile'),
os.path.abspath('test/path/1/newfile'))
# This should work even if a file happens to already exist at the
# computed path.
testDir = os.path.abspath('ResolveForNewAsset')
if os.path.isdir(testDir):
shutil.rmtree(testDir)
os.makedirs(testDir)
testFileName = 'test_ResolveForNewAsset.txt'
testFileAbsPath = os.path.join(testDir, testFileName)
with open(testFileAbsPath, 'w') as ofp:
print('Garbage', file=ofp)
self.assertPathsEqual(
resolver.ResolveForNewAsset(testFileAbsPath),
testFileAbsPath)
self.assertPathsEqual(
resolver.ResolveForNewAsset(
'ResolveForNewAsset/test_ResolveForNewAsset.txt'),
testFileAbsPath)
def GetResolverContext(self, usdFile):
"""
Create and return the ArResolverContext that will be used to Open
the Stage for the given usdFile. Base implementation
creates a default asset context for the usdFile asset, but derived
classes can do more sophisticated resolver and context configuration.
Will be called each time a new stage is opened.
It is not necessary to create an ArResolverContext for every UsdStage
one opens, as the Stage will use reasonable fallback behavior if no
context is provided. For usdview, configuring an asset context by
default is reasonable, and allows clients that embed usdview to
achieve different behavior when needed.
"""
from pxr import Ar
r = Ar.GetResolver()
# ConfigureResolverForAsset no longer exists under Ar 2.0; this
# is here for backwards compatibility with Ar 1.0.
if hasattr(r, "ConfigureResolverForAsset"):
r.ConfigureResolverForAsset(usdFile)
return r.CreateDefaultContextForAsset(usdFile)
def test_FindByPartialKey(self):
# Create a cache with multiple stages, try finding by various elements.
cache = Usd.StageCache()
# sameRoot1 and sameRoot2 share root layers.
sameRoot1 = Usd.Stage.CreateInMemory()
sameRoot2 = Usd.Stage.Open(sameRoot1.GetRootLayer())
# same1 and same2 share both root and session layers and have null path
# resolver contexts
same1 = Usd.Stage.CreateInMemory()
same2 = Usd.Stage.Open(same1.GetRootLayer(), same1.GetSessionLayer())
# prDiff1 and prDiff2 share root and session layers, but have different path
# resolver contexts.
prDiff1 = Usd.Stage.CreateInMemory()
assetFile = 'testUsdStageCache/asset.usd'
prDiff2 = Usd.Stage.Open(
prDiff1.GetRootLayer(), prDiff1.GetSessionLayer(),
Ar.GetResolver().CreateDefaultContextForAsset(assetFile))
# Create a cache and insert all the above stages.
allStages = [sameRoot1, sameRoot2, same1, same2, prDiff1, prDiff2]
cache = Usd.StageCache()
assert all(map(cache.Insert, allStages))
# Now check finding them by partial key.
def CheckMatching(args, expected):
def makeIterable(x):
try:
iter(x)
return x
except TypeError:
return (x, )
args = makeIterable(args)
assert sorted(cache.FindAllMatching(*args)) == sorted(expected)
assert cache.FindOneMatching(*args) in expected
CheckMatching(sameRoot1.GetRootLayer(), [sameRoot1, sameRoot2])
CheckMatching((sameRoot1.GetRootLayer(), sameRoot1.GetSessionLayer()),
[sameRoot1])
CheckMatching(
(sameRoot1.GetRootLayer(), sameRoot1.GetPathResolverContext()),
[sameRoot1, sameRoot2])
CheckMatching(same1.GetRootLayer(), [same1, same2])
CheckMatching((same1.GetRootLayer(), same1.GetSessionLayer()),
[same1, same2])
CheckMatching((same1.GetRootLayer(), same1.GetPathResolverContext()),
[same1, same2])
CheckMatching(prDiff1.GetRootLayer(), [prDiff1, prDiff2])
CheckMatching((prDiff1.GetRootLayer(), prDiff1.GetSessionLayer()),
[prDiff1, prDiff2])
CheckMatching(
(prDiff1.GetRootLayer(), prDiff1.GetPathResolverContext()),
[prDiff1])
def test_ResolveWithContext(self):
testDir = os.path.abspath('test3/test4')
if os.path.isdir(testDir):
shutil.rmtree(testDir)
os.makedirs(testDir)
testFileName = 'test_ResolveWithContext.txt'
testFilePath = os.path.join(testDir, testFileName)
with open(testFilePath, 'w') as ofp:
print >> ofp, 'Garbage'
resolver = Ar.GetResolver()
context = Ar.DefaultResolverContext(
[os.path.abspath('test3'),
os.path.abspath('test3/test4')])
self.assertPathsEqual(
'', resolver.Resolve('test4/test_ResolveWithContext.txt'))
with Ar.ResolverContextBinder(context):
self.assertPathsEqual(
os.path.abspath('test3/test4/test_ResolveWithContext.txt'),
resolver.Resolve('test4/test_ResolveWithContext.txt'))
self.assertPathsEqual(
os.path.abspath('test3/test4/test_ResolveWithContext.txt'),
resolver.Resolve('test_ResolveWithContext.txt'))
self.assertPathsEqual(
'', resolver.Resolve('test4/test_ResolveWithContext.txt'))
def test_ResolveForNewAsset(self):
resolver = Ar.GetResolver()
# The test URI resolver handles asset paths of the form "test:..."
# and simply returns the path unchanged. We can use this to
# verify that our test URI resolver is getting invoked.
# These calls to ResolveForNewAsset should hit the default resolver and
# not the URI resolver and return some non-empty path. If this did
# hit the URI resolver it would trip a TF_AXIOM.
self.assertNotEqual(resolver.ResolveForNewAsset("doesnotexist"), "")
self.assertNotEqual(
resolver.ResolveForNewAsset("doesnotexist.package[foo.file]"), "")
# These calls should hit the URI resolver, which should return the
# given paths unchanged.
self.assertEqual(resolver.ResolveForNewAsset("test://foo"),
"test://foo")
self.assertEqual(
resolver.ResolveForNewAsset("test://foo.package[bar.file]"),
"test://foo.package[bar.file]")
# These calls should hit the URI resolver since schemes are
# case-insensitive.
self.assertEqual(resolver.ResolveForNewAsset("TEST://foo"),
"TEST://foo")
self.assertEqual(
resolver.ResolveForNewAsset("TEST://foo.package[bar.file]"),
"TEST://foo.package[bar.file]")
def test_Resolve(self):
resolver = Ar.GetResolver()
# The test URI resolver handles asset paths of the form "test:..."
# and simply returns the path unchanged. We can use this to
# verify that our test URI resolver is getting invoked.
# These calls to Resolve should hit the default resolver and not
# the URI resolver, and since these files don't exist we expect
# Resolve would return ""
self.assertEqual(resolver.Resolve("doesnotexist"), "")
self.assertEqual(resolver.Resolve("doesnotexist.package[foo.file]"),
"")
# These calls should hit the URI resolver, which should return the
# given paths unchanged.
self.assertEqual(resolver.Resolve("test://foo"), "test://foo")
self.assertEqual(resolver.Resolve("test://foo.package[bar.file]"),
"test://foo.package[bar.file]")
# These calls should hit the URI resolver since schemes are
# case-insensitive.
self.assertEqual(resolver.Resolve("TEST://foo"), "TEST://foo")
self.assertEqual(resolver.Resolve("TEST://foo.package[bar.file]"),
"TEST://foo.package[bar.file]")
def BuildAll(self, node, clearExisting=False):
if clearExisting:
self.ClearAll(node)
if node:
self._sessionId = node.sessionId()
self._nameUsdFile = node.parm(TreeModel.parmNameUsdFile).eval()
self._namePrimPaths = node.parm(TreeModel.parmNamePrimPaths).eval()
usdFile = node.parm(self._nameUsdFile).eval()
resolverContext = Ar.GetResolver().GetCurrentContext()
try:
self._stage = Usd.Stage.Open(usdFile, resolverContext,\
Usd.Stage.LoadNone)
except:
if usdFile != '':
print('Error: Tree View failed to open "%s"' % usdFile)
if self._stage:
rootPrim = self._stage.GetPseudoRoot()
primPath = rootPrim.GetPath()
self._primPathToItemMap[primPath] = self._rootItem
self.BuildTree(rootPrim)
# Copy the import state from the node and apply it to the new tree.
self.CopyImportedPrimPathsFromNode(node)
def CheckEmptyCache(cache):
assert cache.IsEmpty() and cache.Size() == 0
assert not cache.Find(Usd.StageCache.Id.FromLongInt(1))
assert len(cache.GetAllStages()) == 0
assert not cache.FindOneMatching(Sdf.Layer.CreateAnonymous())
assert not cache.FindOneMatching(Sdf.Layer.CreateAnonymous(),
Sdf.Layer.CreateAnonymous())
context = Ar.GetResolver().CreateDefaultContext()
assert not cache.FindOneMatching(Sdf.Layer.CreateAnonymous(), context)
assert not cache.FindOneMatching(Sdf.Layer.CreateAnonymous(),
Sdf.Layer.CreateAnonymous(), context)
assert len(cache.FindAllMatching(Sdf.Layer.CreateAnonymous())) == 0
assert len(
cache.FindAllMatching(Sdf.Layer.CreateAnonymous(),
Sdf.Layer.CreateAnonymous())) == 0
assert len(cache.FindAllMatching(Sdf.Layer.CreateAnonymous(),
context)) == 0
assert len(
cache.FindAllMatching(Sdf.Layer.CreateAnonymous(),
Sdf.Layer.CreateAnonymous(), context)) == 0
assert not cache.GetId(None)
assert not cache.Erase(Usd.StageCache.Id())
assert not cache.Erase(None)
assert cache.EraseAll(Sdf.Layer.CreateAnonymous()) == 0
assert cache.EraseAll(Sdf.Layer.CreateAnonymous(),
Sdf.Layer.CreateAnonymous()) == 0
assert cache.EraseAll(Sdf.Layer.CreateAnonymous(),
Sdf.Layer.CreateAnonymous(), context) == 0
def test_CreateContextFromString(self):
resolver = Ar.GetResolver()
# Exercise the CreateContextFromString(s) API in Python.
# Since the _TestURIResolverContext object isn't wrapped to
# Python these tests are a bit limited, but more extensive
# tests are in the C++ version of this test.
# CreateContextFromString with an empty URI scheme should
# be equivalent to CreateContextFromString with no URI scheme.
searchPaths = os.pathsep.join(["/a", "/b"])
self.assertEqual(
resolver.CreateContextFromString(searchPaths),
resolver.CreateContextFromString("", searchPaths))
# CreateContextFromStrings should be equivalent to creating an
# Ar.ResolverContext combining the results of CreateContextFromString.
self.assertEqual(
Ar.ResolverContext(
(resolver.CreateContextFromString("test", "context str"),
resolver.CreateContextFromString("", searchPaths))),
resolver.CreateContextFromStrings([
("", searchPaths),
("test", "context str")
]))
def test_GetAvailableResolvers(self):
"""Tests ArGetAvailableResolvers and ArCreateResolver APIs
via _TestResolver1 and _TestResolver2 subclasses."""
# Register test resolver plugin and verify we have the
# expected ArResolver subclasses.
pr = Plug.Registry()
plugins = pr.RegisterPlugins(testPluginsDsoSearch)
self.assertEqual(len(plugins), 1)
self.assertEqual(
set(pr.GetAllDerivedTypes('ArResolver')),
set([
Tf.Type.FindByName('ArDefaultResolver'),
Tf.Type.FindByName('_TestResolver1'),
Tf.Type.FindByName('_TestResolver2')
]))
# Set _TestResolver2 to be the preferred resolver;
# otherwise, _TestResolver1 would be initially constructed
# by the call to Ar.GetResolver() below since its typename
# comes before _TestResolver2.
Ar.SetPreferredResolver('_TestResolver2')
# Invoke Ar.GetResolver(). This will cause _TestResolver1
# and _TestResolver2 to be created. These classes test
# ArGetAvailableResolvers and ArCreateResolver internally.
resolver = Ar.GetResolver()
def main(usd_file, local_file):
"""Test USD asset resolver"""
# ensure the default context gets set
resolver = Ar.GetResolver() #pylint: disable=no-member
resolver.ConfigureResolverForAsset(usd_file)
print "Open stage"
start = time.time()
stage = Usd.Stage.Open(usd_file) #pylint: disable=no-member
print "Opened stage in", time.time() - start
if local_file:
upload(local_file, usd_file)
print "Reload stage (but not the context cache)"
start = time.time()
stage.Reload()
print "Reloaded stage in", time.time() - start
print "Reload stage (including the context cache)"
start = time.time()
context = resolver.GetCurrentContext()
print 'context:', context
resolver.RefreshContext(context)
stage.Reload()
print "Reloaded stage in", time.time() - start
def test_Resolve(self):
testFileName = 'test_Resolve.txt'
testFilePath = os.path.abspath(testFileName)
with open(testFilePath, 'w') as ofp:
print >> ofp, 'Garbage'
r = Ar.GetResolver()
self.assertEqual(testFilePath, r.Resolve(testFileName))
def _resolve_using_usd(path):
"""str: Try to resolve `path` using Pixar's Python API."""
try:
from pxr import Ar
except ImportError:
return ""
return Ar.GetResolver().Resolve(path)
def CheckZipFile(self, zipFile, packagePath):
fileNames = zipFile.GetFileNames()
for fileName in fileNames:
fileExt = Ar.GetResolver().GetExtension(fileName)
if fileExt not in ARKitFileExtensionChecker._allowedFileExtensions:
self._AddFailedCheck("File '%s' in package '%s' has an "
"unknown or unsupported extension '%s'." %
(fileName, packagePath, fileExt))
def _TextureIs8Bit(self, asset):
# Eventually we hope to leverage HioImage through a plugin system,
# when Imaging is present, to answer this and other image queries
# more definitively
from pxr import Ar
ext = Ar.GetResolver().GetExtension(asset.resolvedPath)
# not an exhaustive list, but ones we typically can read
return ext in ["bmp", "tga", "jpg", "png", "tif"]
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 test_Resolve(self):
resolver = Ar.GetResolver()
self.assertEqual(
resolver.Resolve("asset:Buzz/Buzz.usd"),
Ar.ResolvedPath("asset:Buzz/Buzz.usd"))
self.assertEqual(
resolver.Resolve("asset:DoesntExist/DoesntExist.usd"),
Ar.ResolvedPath())
def CheckZipFile(self, zipFile, packagePath):
fileNames = zipFile.GetFileNames()
for fileName in fileNames:
fileExt = Ar.GetResolver().GetExtension(fileName)
fileInfo = zipFile.GetFileInfo(fileName)
offset = fileInfo.dataOffset
if offset % 64 != 0:
self._AddFailedCheck("File '%s' in package '%s' has an "
"invalid offset %s." %
(fileName, packagePath, offset))
def test_CreateIdentifier(self):
r = Ar.GetResolver()
def _RP(path = None):
return Ar.ResolvedPath(os.path.abspath(path or ""))
self.assertEqual('', r.CreateIdentifier(''))
self.assertEqual('', r.CreateIdentifier('', _RP()))
self.assertEqual('', r.CreateIdentifier('', _RP('AnchorAsset.txt')))
# The identifier for an absolute path will always be that absolute
# path normalized.
self.assertPathsEqual(
'/dir/AbsolutePath.txt',
r.CreateIdentifier('/dir/AbsolutePath.txt'))
self.assertPathsEqual(
'/dir/AbsolutePath.txt',
r.CreateIdentifier('/dir/AbsolutePath.txt', _RP('subdir/A.txt')))
self.assertPathsEqual(
'/dir/AbsolutePath.txt',
r.CreateIdentifier('/dir/.//AbsolutePath.txt', _RP('subdir/A.txt')))
# The identifier for a file-relative path (i.e. a relative path
# starting with "./" or "../" is obtained by anchoring that path
# to the given anchor, or the normalized file-relative path if no
# anchor is given.
self.assertPathsEqual(
'subdir/FileRelative.txt',
r.CreateIdentifier('./subdir/FileRelative.txt'))
self.assertPathsEqual(
os.path.abspath('dir/subdir/FileRelative.txt'),
r.CreateIdentifier('./subdir/FileRelative.txt', _RP('dir/A.txt')))
# Test look-here-first behavior for search-relative paths (i.e.,
# relative paths that do not start with "./" or "../")
#
# If an asset exists at the location obtained by anchoring the
# relative path to the given anchor, the anchored path is used as
# the identifier.
if not os.path.isdir('dir/subdir'):
os.makedirs('dir/subdir')
with open('dir/subdir/Exists.txt', 'w') as f:
pass
self.assertPathsEqual(
os.path.abspath('dir/subdir/Exists.txt'),
r.CreateIdentifier('subdir/Exists.txt', _RP('dir/Anchor.txt')))
# Otherwise, the search path is used as the identifier.
self.assertPathsEqual(
'subdir/Bogus.txt',
r.CreateIdentifier('subdir/Bogus.txt', _RP('dir/Anchor.txt')))
def _CheckTexture(self, texAssetPath):
self._Msg("Checking texture <%s>." % texAssetPath)
texFileExt = Ar.GetResolver().GetExtension(texAssetPath).lower()
if texFileExt in \
TextureChecker._unsupportedImageFormats:
self._AddFailedCheck("Found texture file '%s' with unsupported "
"file format." % texAssetPath)
elif texFileExt not in \
TextureChecker._allowedImageFormats:
self._AddFailedCheck("Found texture file '%s' with unknown file "
"format." % texAssetPath)
def test_Resolve(self):
testFileName = 'test_Resolve.txt'
testFilePath = os.path.abspath(testFileName)
with open(testFilePath, 'w') as ofp:
print >> ofp, 'Garbage'
resolvedPath = Ar.GetResolver().Resolve(testFileName)
# The resolved path should be absolute.
self.assertTrue(os.path.isabs(resolvedPath))
self.assertPathsEqual(testFilePath, resolvedPath)
def GetFlattenedUsdData(filePath, populationMaskPaths):
from pxr import Ar, Usd
Ar.GetResolver().ConfigureResolverForAsset(filePath)
popMask = (None
if populationMaskPaths is None else Usd.StagePopulationMask())
if popMask:
for path in populationMaskPaths:
popMask.Add(path)
return Usd.Stage.OpenMasked(filePath, popMask)
else:
return Usd.Stage.Open(filePath)
def _CheckTexture(self, texAssetPath, inputPath):
self._Msg("Checking texture <%s>." % texAssetPath)
texFileExt = Ar.GetResolver().GetExtension(texAssetPath).lower()
if (self._consumerLevelChecks
and texFileExt in TextureChecker._unsupportedImageFormats):
self._AddFailedCheck(
"Texture <%s> with asset @%s@ has non-portable "
"file format." % (inputPath, texAssetPath))
elif texFileExt not in self._allowedFormats:
self._AddFailedCheck("Texture <%s> with asset @%s@ has unknown "
"file format." % (inputPath, texAssetPath))
def CheckZipFile(self, zipFile, packagePath):
fileNames = zipFile.GetFileNames()
for fileName in fileNames:
fileExt = Ar.GetResolver().GetExtension(fileName)
fileInfo = zipFile.GetFileInfo(fileName)
if fileInfo.compressionMethod != 0:
self._AddFailedCheck("File '%s' in package '%s' has "
"compression. Compression method is '%s', actual size "
"is %s. Uncompressed size is %s." % (
fileName, packagePath, fileInfo.compressionMethod,
fileInfo.size, fileInfo.uncompressedSize))
def SyncModelWithNode(self, node):
# Check if the node's usdFile parameter resolves to a different
# path than that stored in self._stage's rootLayer. If they differ,
# clear and rebuild this model.
paramPath = node.parm(self._nameUsdFile).eval()
storedPath = self._stage.GetRootLayer().realPath if self._stage else ''
if Ar.GetResolver().Resolve(paramPath) != storedPath:
self.BuildAll(node, clearExisting=True)
else:
# The node's usdFile hasn't changed, but its primPaths may
# have, so copy them from the node to the this model.
self.CopyImportedPrimPathsFromNode(node)
