file_path
stringlengths 21
207
| content
stringlengths 5
1.02M
| size
int64 5
1.02M
| lang
stringclasses 9
values | avg_line_length
float64 1.33
100
| max_line_length
int64 4
993
| alphanum_fraction
float64 0.27
0.93
|
|---|---|---|---|---|---|---|
USwampertor/OmniverseJS/ov/python/pxr/UsdVol/__init__.py | #
# Copyright 2018 Pixar
#
# Licensed under the Apache License, Version 2.0 (the "Apache License")
# with the following modification; you may not use this file except in
# compliance with the Apache License and the following modification to it:
# Section 6. Trademarks. is deleted and replaced with:
#
# 6. Trademarks. This License does not grant permission to use the trade
# names, trademarks, service marks, or product names of the Licensor
# and its affiliates, except as required to comply with Section 4(c) of
# the License and to reproduce the content of the NOTICE file.
#
# You may obtain a copy of the Apache License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the Apache License with the above modification is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the Apache License for the specific
# language governing permissions and limitations under the Apache License.
#
from . import _usdVol
from pxr import Tf
Tf.PrepareModule(_usdVol, locals())
del Tf
try:
from . import __DOC
__DOC.Execute(locals())
del __DOC
except Exception:
pass
| 1,242 | Python | 34.514285 | 74 | 0.748792 |
USwampertor/OmniverseJS/ov/python/pxr/Ndr/__init__.py | #
# Copyright 2018 Pixar
#
# Licensed under the Apache License, Version 2.0 (the "Apache License")
# with the following modification; you may not use this file except in
# compliance with the Apache License and the following modification to it:
# Section 6. Trademarks. is deleted and replaced with:
#
# 6. Trademarks. This License does not grant permission to use the trade
# names, trademarks, service marks, or product names of the Licensor
# and its affiliates, except as required to comply with Section 4(c) of
# the License and to reproduce the content of the NOTICE file.
#
# You may obtain a copy of the Apache License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the Apache License with the above modification is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the Apache License for the specific
# language governing permissions and limitations under the Apache License.
#
"""Python bindings for libNdr"""
from . import _ndr
from pxr import Tf
Tf.PrepareModule(_ndr, locals())
del _ndr, Tf
try:
from . import __DOC
__DOC.Execute(locals())
del __DOC
except Exception:
pass
| 1,277 | Python | 32.631578 | 74 | 0.743931 |
USwampertor/OmniverseJS/ov/python/pxr/UsdRender/__init__.py | #
# Copyright 2016 Pixar
#
# Licensed under the Apache License, Version 2.0 (the "Apache License")
# with the following modification; you may not use this file except in
# compliance with the Apache License and the following modification to it:
# Section 6. Trademarks. is deleted and replaced with:
#
# 6. Trademarks. This License does not grant permission to use the trade
# names, trademarks, service marks, or product names of the Licensor
# and its affiliates, except as required to comply with Section 4(c) of
# the License and to reproduce the content of the NOTICE file.
#
# You may obtain a copy of the Apache License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the Apache License with the above modification is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the Apache License for the specific
# language governing permissions and limitations under the Apache License.
#
from . import _usdRender
from pxr import Tf
Tf.PrepareModule(_usdRender, locals())
del Tf
try:
import __DOC
__DOC.Execute(locals())
del __DOC
except Exception:
try:
import __tmpDoc
__tmpDoc.Execute(locals())
del __tmpDoc
except:
pass
| 1,347 | Python | 31.878048 | 74 | 0.728285 |
USwampertor/OmniverseJS/ov/python/pxr/UsdRi/__init__.py | #
# Copyright 2016 Pixar
#
# Licensed under the Apache License, Version 2.0 (the "Apache License")
# with the following modification; you may not use this file except in
# compliance with the Apache License and the following modification to it:
# Section 6. Trademarks. is deleted and replaced with:
#
# 6. Trademarks. This License does not grant permission to use the trade
# names, trademarks, service marks, or product names of the Licensor
# and its affiliates, except as required to comply with Section 4(c) of
# the License and to reproduce the content of the NOTICE file.
#
# You may obtain a copy of the Apache License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the Apache License with the above modification is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the Apache License for the specific
# language governing permissions and limitations under the Apache License.
#
from . import _usdRi
from pxr import Tf
Tf.PrepareModule(_usdRi, locals())
del Tf
try:
from . import __DOC
__DOC.Execute(locals())
del __DOC
except Exception:
pass
| 1,240 | Python | 34.457142 | 74 | 0.748387 |
USwampertor/OmniverseJS/ov/python/pxr/SdrGlslfx/__init__.py | #
# Copyright 2019 Pixar
#
# Licensed under the Apache License, Version 2.0 (the "Apache License")
# with the following modification; you may not use this file except in
# compliance with the Apache License and the following modification to it:
# Section 6. Trademarks. is deleted and replaced with:
#
# 6. Trademarks. This License does not grant permission to use the trade
# names, trademarks, service marks, or product names of the Licensor
# and its affiliates, except as required to comply with Section 4(c) of
# the License and to reproduce the content of the NOTICE file.
#
# You may obtain a copy of the Apache License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the Apache License with the above modification is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the Apache License for the specific
# language governing permissions and limitations under the Apache License.
#
# This file makes this module importable from python, which avoids a warning
# when initializing the SdrRegistry.
| 1,176 | Python | 41.035713 | 77 | 0.767007 |
USwampertor/OmniverseJS/ov/python/pxr/PxOsd/__init__.py | #
# Copyright 2019 Pixar
#
# Licensed under the Apache License, Version 2.0 (the "Apache License")
# with the following modification; you may not use this file except in
# compliance with the Apache License and the following modification to it:
# Section 6. Trademarks. is deleted and replaced with:
#
# 6. Trademarks. This License does not grant permission to use the trade
# names, trademarks, service marks, or product names of the Licensor
# and its affiliates, except as required to comply with Section 4(c) of
# the License and to reproduce the content of the NOTICE file.
#
# You may obtain a copy of the Apache License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the Apache License with the above modification is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the Apache License for the specific
# language governing permissions and limitations under the Apache License.
#
"""
Pixar OSD implementation.
"""
from . import _pxOsd
from pxr import Tf
Tf.PrepareModule(_pxOsd, locals())
del _pxOsd, Tf
try:
import __DOC
__DOC.Execute(locals())
del __DOC
except Exception:
pass
| 1,277 | Python | 30.949999 | 74 | 0.744714 |
USwampertor/OmniverseJS/ov/python/pxr/UsdLux/__init__.py | #
# Copyright 2016 Pixar
#
# Licensed under the Apache License, Version 2.0 (the "Apache License")
# with the following modification; you may not use this file except in
# compliance with the Apache License and the following modification to it:
# Section 6. Trademarks. is deleted and replaced with:
#
# 6. Trademarks. This License does not grant permission to use the trade
# names, trademarks, service marks, or product names of the Licensor
# and its affiliates, except as required to comply with Section 4(c) of
# the License and to reproduce the content of the NOTICE file.
#
# You may obtain a copy of the Apache License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the Apache License with the above modification is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the Apache License for the specific
# language governing permissions and limitations under the Apache License.
#
from . import _usdLux
from pxr import Tf
Tf.PrepareModule(_usdLux, locals())
del Tf
try:
from . import __DOC
__DOC.Execute(locals())
del __DOC
except Exception:
pass
| 1,243 | Python | 33.555555 | 74 | 0.74819 |
USwampertor/OmniverseJS/ov/python/pxr/CameraUtil/__init__.py | #
# Copyright 2016 Pixar
#
# Licensed under the Apache License, Version 2.0 (the "Apache License")
# with the following modification; you may not use this file except in
# compliance with the Apache License and the following modification to it:
# Section 6. Trademarks. is deleted and replaced with:
#
# 6. Trademarks. This License does not grant permission to use the trade
# names, trademarks, service marks, or product names of the Licensor
# and its affiliates, except as required to comply with Section 4(c) of
# the License and to reproduce the content of the NOTICE file.
#
# You may obtain a copy of the Apache License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the Apache License with the above modification is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the Apache License for the specific
# language governing permissions and limitations under the Apache License.
#
"""
Camera utilities.
"""
from . import _cameraUtil
from pxr import Tf
Tf.PrepareModule(_cameraUtil, locals())
del _cameraUtil, Tf
try:
import __DOC
__DOC.Execute(locals())
del __DOC
except Exception:
pass
| 1,285 | Python | 30.365853 | 74 | 0.746304 |
USwampertor/OmniverseJS/ov/python/pxr/Gf/__init__.py | #
# Copyright 2016 Pixar
#
# Licensed under the Apache License, Version 2.0 (the "Apache License")
# with the following modification; you may not use this file except in
# compliance with the Apache License and the following modification to it:
# Section 6. Trademarks. is deleted and replaced with:
#
# 6. Trademarks. This License does not grant permission to use the trade
# names, trademarks, service marks, or product names of the Licensor
# and its affiliates, except as required to comply with Section 4(c) of
# the License and to reproduce the content of the NOTICE file.
#
# You may obtain a copy of the Apache License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the Apache License with the above modification is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the Apache License for the specific
# language governing permissions and limitations under the Apache License.
#
"""
Graphics Foundation
This package defines classes for fundamental graphics types and operations.
"""
import sys
if 'pxr.Gf._gf' not in sys.modules:
from pxr import Tf
from . import _gf
Tf.PrepareModule(_gf, locals())
del _gf, Tf
del sys
try:
from . import __DOC
__DOC.Execute(locals())
del __DOC
except Exception:
pass
| 1,415 | Python | 31.930232 | 75 | 0.739223 |
USwampertor/OmniverseJS/ov/python/pxr/Garch/__init__.py | #
# Copyright 2016 Pixar
#
# Licensed under the Apache License, Version 2.0 (the "Apache License")
# with the following modification; you may not use this file except in
# compliance with the Apache License and the following modification to it:
# Section 6. Trademarks. is deleted and replaced with:
#
# 6. Trademarks. This License does not grant permission to use the trade
# names, trademarks, service marks, or product names of the Licensor
# and its affiliates, except as required to comply with Section 4(c) of
# the License and to reproduce the content of the NOTICE file.
#
# You may obtain a copy of the Apache License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the Apache License with the above modification is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the Apache License for the specific
# language governing permissions and limitations under the Apache License.
#
"""
garch
"""
from . import _garch
from pxr import Tf
Tf.PrepareModule(_garch, locals())
del _garch, Tf
try:
from . import __DOC
__DOC.Execute(locals())
del __DOC
except Exception:
pass
| 1,265 | Python | 29.878048 | 74 | 0.741502 |
USwampertor/OmniverseJS/ov/python/pxr/Usd/__init__.py | #
# Copyright 2016 Pixar
#
# Licensed under the Apache License, Version 2.0 (the "Apache License")
# with the following modification; you may not use this file except in
# compliance with the Apache License and the following modification to it:
# Section 6. Trademarks. is deleted and replaced with:
#
# 6. Trademarks. This License does not grant permission to use the trade
# names, trademarks, service marks, or product names of the Licensor
# and its affiliates, except as required to comply with Section 4(c) of
# the License and to reproduce the content of the NOTICE file.
#
# You may obtain a copy of the Apache License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the Apache License with the above modification is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the Apache License for the specific
# language governing permissions and limitations under the Apache License.
#
from . import _usd
from pxr import Tf
Tf.PrepareModule(_usd, locals())
del Tf
try:
from . import __DOC
__DOC.Execute(locals())
del __DOC
except Exception:
pass
| 1,236 | Python | 34.342856 | 74 | 0.747573 |
USwampertor/OmniverseJS/ov/python/pxr/Pcp/__init__.py | #
# Copyright 2016 Pixar
#
# Licensed under the Apache License, Version 2.0 (the "Apache License")
# with the following modification; you may not use this file except in
# compliance with the Apache License and the following modification to it:
# Section 6. Trademarks. is deleted and replaced with:
#
# 6. Trademarks. This License does not grant permission to use the trade
# names, trademarks, service marks, or product names of the Licensor
# and its affiliates, except as required to comply with Section 4(c) of
# the License and to reproduce the content of the NOTICE file.
#
# You may obtain a copy of the Apache License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the Apache License with the above modification is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the Apache License for the specific
# language governing permissions and limitations under the Apache License.
#
from . import _pcp
from pxr import Tf
Tf.PrepareModule(_pcp, locals())
del _pcp, Tf
try:
import __DOC
__DOC.Execute(locals())
del __DOC
except Exception:
pass
| 1,235 | Python | 34.314285 | 74 | 0.747368 |
USwampertor/OmniverseJS/ov/python/pxr/Plug/__init__.py | #
# Copyright 2016 Pixar
#
# Licensed under the Apache License, Version 2.0 (the "Apache License")
# with the following modification; you may not use this file except in
# compliance with the Apache License and the following modification to it:
# Section 6. Trademarks. is deleted and replaced with:
#
# 6. Trademarks. This License does not grant permission to use the trade
# names, trademarks, service marks, or product names of the Licensor
# and its affiliates, except as required to comply with Section 4(c) of
# the License and to reproduce the content of the NOTICE file.
#
# You may obtain a copy of the Apache License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the Apache License with the above modification is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the Apache License for the specific
# language governing permissions and limitations under the Apache License.
#
"""
This package defines facilities for dealing with plugins.
"""
from . import _plug
from pxr import Tf
Tf.PrepareModule(_plug, locals())
del _plug, Tf
try:
from . import __DOC
__DOC.Execute(locals())
del __DOC
except Exception:
pass
| 1,313 | Python | 31.849999 | 74 | 0.745621 |
USwampertor/OmniverseJS/ov/python/pxr/UsdShade/__init__.py | #
# Copyright 2016 Pixar
#
# Licensed under the Apache License, Version 2.0 (the "Apache License")
# with the following modification; you may not use this file except in
# compliance with the Apache License and the following modification to it:
# Section 6. Trademarks. is deleted and replaced with:
#
# 6. Trademarks. This License does not grant permission to use the trade
# names, trademarks, service marks, or product names of the Licensor
# and its affiliates, except as required to comply with Section 4(c) of
# the License and to reproduce the content of the NOTICE file.
#
# You may obtain a copy of the Apache License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the Apache License with the above modification is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the Apache License for the specific
# language governing permissions and limitations under the Apache License.
#
from . import _usdShade
from pxr import Tf
Tf.PrepareModule(_usdShade, locals())
del Tf
try:
from . import __DOC
__DOC.Execute(locals())
del __DOC
except Exception:
pass
| 1,246 | Python | 34.62857 | 74 | 0.749599 |
USwampertor/OmniverseJS/ov/python/pxr/UsdUtils/complianceChecker.py | #
# Copyright 2018 Pixar
#
# Licensed under the Apache License, Version 2.0 (the "Apache License")
# with the following modification; you may not use this file except in
# compliance with the Apache License and the following modification to it:
# Section 6. Trademarks. is deleted and replaced with:
#
# 6. Trademarks. This License does not grant permission to use the trade
# names, trademarks, service marks, or product names of the Licensor
# and its affiliates, except as required to comply with Section 4(c) of
# the License and to reproduce the content of the NOTICE file.
#
# You may obtain a copy of the Apache License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the Apache License with the above modification is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the Apache License for the specific
# language governing permissions and limitations under the Apache License.
#
from __future__ import print_function
from pxr import Ar
def _IsPackageOrPackagedLayer(layer):
return layer.GetFileFormat().IsPackage() or \
Ar.IsPackageRelativePath(layer.identifier)
class BaseRuleChecker(object):
"""This is Base class for all the rule-checkers."""
def __init__(self, verbose):
self._verbose = verbose
self._failedChecks = []
self._errors = []
def _AddFailedCheck(self, msg):
self._failedChecks.append(msg)
def _AddError(self, msg):
self._errors.append(msg)
def _Msg(self, msg):
if self._verbose:
print(msg)
def GetFailedChecks(self):
return self._failedChecks
def GetErrors(self):
return self._errors
# -------------------------------------------------------------------------
# Virtual methods that any derived rule-checker may want to override.
# Default implementations do nothing.
#
# A rule-checker may choose to override one or more of the virtual methods.
# The callbacks are invoked in the order they are defined here (i.e.
# CheckStage is invoked first, followed by CheckDiagnostics, followed by
# CheckUnresolvedPaths and so on until CheckPrim). Some of the callbacks may
# be invoked multiple times per-rule with different parameters, for example,
# CheckLayer, CheckPrim and CheckZipFile.
def CheckStage(self, usdStage):
""" Check the given usdStage. """
pass
def CheckDiagnostics(self, diagnostics):
""" Check the diagnostic messages that were generated when opening the
USD stage. The diagnostic messages are collected using a
UsdUtilsCoalescingDiagnosticDelegate.
"""
pass
def CheckUnresolvedPaths(self, unresolvedPaths):
""" Check or process any unresolved asset paths that were found when
analysing the dependencies.
"""
pass
def CheckDependencies(self, usdStage, layerDeps, assetDeps):
""" Check usdStage's layer and asset dependencies that were gathered
using UsdUtils.ComputeAllDependencies().
"""
pass
def CheckLayer(self, layer):
""" Check the given SdfLayer. """
pass
def CheckZipFile(self, zipFile, packagePath):
""" Check the zipFile object created by opening the package at path
packagePath.
"""
pass
def CheckPrim(self, prim):
""" Check the given prim, which may only exist is a specific combination
of variant selections on the UsdStage.
"""
pass
# -------------------------------------------------------------------------
class ByteAlignmentChecker(BaseRuleChecker):
@staticmethod
def GetDescription():
return "Files within a usdz package must be laid out properly, "\
"i.e. they should be aligned to 64 bytes."
def __init__(self, verbose):
super(ByteAlignmentChecker, self).__init__(verbose)
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))
class CompressionChecker(BaseRuleChecker):
@staticmethod
def GetDescription():
return "Files withing a usdz package should not be compressed or "\
"encrypted."
def __init__(self, verbose):
super(CompressionChecker, self).__init__(verbose)
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))
class MissingReferenceChecker(BaseRuleChecker):
@staticmethod
def GetDescription():
return "The composed USD stage should not contain any unresolvable"\
" asset dependencies (in every possible variation of the "\
"asset), when using the default asset resolver. "
def __init__(self, verbose):
super(MissingReferenceChecker, self).__init__(verbose)
def CheckDiagnostics(self, diagnostics):
for diag in diagnostics:
# "_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)
def CheckUnresolvedPaths(self, unresolvedPaths):
for unresolvedPath in unresolvedPaths:
self._AddFailedCheck("Found unresolvable external dependency "
"'%s'." % unresolvedPath)
class TextureChecker(BaseRuleChecker):
# Allow just png and jpg for now.
_allowedImageFormats = ("jpg", "png")
# Include a list of "unsupported" image formats to provide better error
# messages whwn we find one of these.
_unsupportedImageFormats = ["bmp", "tga", "hdr", "exr", "tif", "zfile",
"tx"]
@staticmethod
def GetDescription():
return "Texture files should be .jpg or .png."
def __init__(self, verbose):
# Check if the prim has an allowed type.
super(TextureChecker, self).__init__(verbose)
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 CheckPrim(self, prim):
# Right now, we find texture referenced by looking at the asset-valued
# shader inputs. However, it is entirely legal to feed the "fileName"
# input of a UsdUVTexture shader from a UsdPrimvarReader_string.
# Hence, ideally we would also check "the right" primvars on
# geometry prims here. However, identifying the right primvars is
# non-trivial. We probably need to pre-analyze all the materials.
# Not going to try to do this yet, but it raises an interesting
# validation pattern -
from pxr import Sdf, UsdShade
# Check if the prim is a shader.
if not prim.IsA(UsdShade.Shader):
return
shader = UsdShade.Shader(prim)
shaderInputs = shader.GetInputs()
for ip in shaderInputs:
if ip.GetTypeName() == Sdf.ValueTypeNames.Asset:
texFilePath = str(ip.Get()).strip('@')
self._CheckTexture(texFilePath)
elif ip.GetTypeName() == Sdf.ValueTypeNames.AssetArray:
texPathArray = ip.Get()
texPathArray = [str(i).strip('@') for i in texPathArray]
for texPath in texPathArray:
self._CheckTexture(texFilePath)
class ARKitPackageEncapsulationChecker(BaseRuleChecker):
@staticmethod
def GetDescription():
return "If the root layer is a package, then the composed stage "\
"should not contain references to files outside the package. "\
"In other words, the package should be entirely self-contained."
def __init__(self, verbose):
super(ARKitPackageEncapsulationChecker, self).__init__(verbose)
def CheckDependencies(self, usdStage, layerDeps, assetDeps):
rootLayer = usdStage.GetRootLayer()
if not _IsPackageOrPackagedLayer(rootLayer):
return
packagePath = usdStage.GetRootLayer().realPath
if packagePath:
if Ar.IsPackageRelativePath(packagePath):
packagePath = Ar.SplitPackageRelativePathOuter(
packagePath)[0]
for layer in layerDeps:
# In-memory layers like session layers (which we must skip when
# doing this check) won't have a real path.
if layer.realPath:
if not layer.realPath.startswith(packagePath):
self._AddFailedCheck("Found loaded layer '%s' that "
"does not belong to the package '%s'." %
(layer.identifier, packagePath))
for asset in assetDeps:
if not asset.startswith(packagePath):
self._AddFailedCheck("Found asset reference '%s' that "
"does not belong to the package '%s'." %
(asset, packagePath))
class ARKitLayerChecker(BaseRuleChecker):
# Only core USD file formats are allowed.
_allowedLayerFormatIds = ('usd', 'usda', 'usdc', 'usdz')
@staticmethod
def GetDescription():
return "All included layers that participate in composition should"\
" have one of the core supported file formats."
def __init__(self, verbose):
# Check if the prim has an allowed type.
super(ARKitLayerChecker, self).__init__(verbose)
def CheckLayer(self, layer):
self._Msg("Checking layer <%s>." % layer.identifier)
formatId = layer.GetFileFormat().formatId
if not formatId in \
ARKitLayerChecker._allowedLayerFormatIds:
self._AddFailedCheck("Layer '%s' has unsupported formatId "
"'%s'." % (layer.identifier, formatId))
class ARKitPrimTypeChecker(BaseRuleChecker):
# All core prim types other than UsdGeomPointInstancers, Curve types, Nurbs,
# and the types in UsdLux are allowed.
_allowedPrimTypeNames = ('', 'Scope', 'Xform', 'Camera',
'Shader', 'Material',
'Mesh', 'Sphere', 'Cube', 'Cylinder', 'Cone',
'Capsule', 'GeomSubset', 'Points',
'SkelRoot', 'Skeleton', 'SkelAnimation',
'BlendShape', 'SpatialAudio')
@staticmethod
def GetDescription():
return "UsdGeomPointInstancers and custom schemas not provided by "\
"core USD are not allowed."
def __init__(self, verbose):
# Check if the prim has an allowed type.
super(ARKitPrimTypeChecker, self).__init__(verbose)
def CheckPrim(self, prim):
self._Msg("Checking prim <%s>." % prim.GetPath())
if prim.GetTypeName() not in \
ARKitPrimTypeChecker._allowedPrimTypeNames:
self._AddFailedCheck("Prim <%s> has unsupported type '%s'." %
(prim.GetPath(), prim.GetTypeName()))
class ARKitStageYupChecker(BaseRuleChecker):
@staticmethod
def GetDescription():
return "The stage and all fo the assets referenced within it "\
"should be Y-up.",
def __init__(self, verbose):
# Check if the prim has an allowed type.
super(ARKitStageYupChecker, self).__init__(verbose)
def CheckStage(self, usdStage):
from pxr import UsdGeom
upAxis = UsdGeom.GetStageUpAxis(usdStage)
if upAxis != UsdGeom.Tokens.y:
self._AddFailedCheck("Stage has upAxis '%s'. upAxis should be "
"'%s'." % (upAxis, UsdGeom.Tokens.y))
class ARKitShaderChecker(BaseRuleChecker):
@staticmethod
def GetDescription():
return "Shader nodes must have \"id\" as the implementationSource, " \
"with id values that begin with \"Usd*\". Also, shader inputs "\
"with connections must each have a single, valid connection " \
"source."
def __init__(self, verbose):
super(ARKitShaderChecker, self).__init__(verbose)
def CheckPrim(self, prim):
from pxr import UsdShade
if not prim.IsA(UsdShade.Shader):
return
shader = UsdShade.Shader(prim)
if not shader:
self._AddError("Invalid shader prim <%s>." % prim.GetPath())
return
self._Msg("Checking shader <%s>." % prim.GetPath())
implSource = shader.GetImplementationSource()
if implSource != UsdShade.Tokens.id:
self._AddFailedCheck("Shader <%s> has non-id implementation "
"source '%s'." % (prim.GetPath(), implSource))
shaderId = shader.GetShaderId()
if not shaderId or \
not (shaderId in ['UsdPreviewSurface', 'UsdUVTexture'] or
shaderId.startswith('UsdPrimvarReader')) :
self._AddFailedCheck("Shader <%s> has unsupported info:id '%s'."
% (prim.GetPath(), shaderId))
# Check shader input connections
shaderInputs = shader.GetInputs()
for shdInput in shaderInputs:
connections = shdInput.GetAttr().GetConnections()
# If an input has one or more connections, ensure that the
# connections are valid.
if len(connections) > 0:
if len(connections) > 1:
self._AddFailedCheck("Shader input <%s> has %s connection "
"sources, but only one is allowed." %
(shdInput.GetAttr.GetPath(), len(connections)))
connectedSource = shdInput.GetConnectedSource()
if connectedSource is None:
self._AddFailedCheck("Connection source <%s> for shader "
"input <%s> is missing." % (connections[0],
shdInput.GetAttr().GetPath()))
else:
# The source must be a valid shader or material prim.
source = connectedSource[0]
if not source.GetPrim().IsA(UsdShade.Shader) and \
not source.GetPrim().IsA(UsdShade.Material):
self._AddFailedCheck("Shader input <%s> has an invalid "
"connection source prim of type '%s'." %
(shdInput.GetAttr().GetPath(),
source.GetPrim().GetTypeName()))
class ARKitMaterialBindingChecker(BaseRuleChecker):
@staticmethod
def GetDescription():
return "All material binding relationships must have valid targets."
def __init__(self, verbose):
super(ARKitMaterialBindingChecker, self).__init__(verbose)
def CheckPrim(self, prim):
from pxr import UsdShade
relationships = prim.GetRelationships()
bindingRels = [rel for rel in relationships if
rel.GetName().startswith(UsdShade.Tokens.materialBinding)]
for bindingRel in bindingRels:
targets = bindingRel.GetTargets()
if len(targets) == 1:
directBinding = UsdShade.MaterialBindingAPI.DirectBinding(
bindingRel)
if not directBinding.GetMaterial():
self._AddFailedCheck("Direct material binding <%s> targets "
"an invalid material <%s>." % (bindingRel.GetPath(),
directBinding.GetMaterialPath()))
elif len(targets) == 2:
collBinding = UsdShade.MaterialBindingAPI.CollectionBinding(
bindingRel)
if not collBinding.GetMaterial():
self._AddFailedCheck("Collection-based material binding "
"<%s> targets an invalid material <%s>." %
(bindingRel.GetPath(), collBinding.GetMaterialPath()))
if not collBinding.GetCollection():
self._AddFailedCheck("Collection-based material binding "
"<%s> targets an invalid collection <%s>." %
(bindingRel.GetPath(), collBinding.GetCollectionPath()))
class ARKitFileExtensionChecker(BaseRuleChecker):
_allowedFileExtensions = \
ARKitLayerChecker._allowedLayerFormatIds + \
TextureChecker._allowedImageFormats
@staticmethod
def GetDescription():
return "Only layer files and textures are allowed in a package."
def __init__(self, verbose):
super(ARKitFileExtensionChecker, self).__init__(verbose)
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))
class ARKitRootLayerChecker(BaseRuleChecker):
@staticmethod
def GetDescription():
return "The root layer of the package must be a usdc file and " \
"must not include any external dependencies that participate in "\
"stage composition."
def __init__(self, verbose):
super(ARKitRootLayerChecker, self).__init__(verbose=verbose)
def CheckStage(self, usdStage):
usedLayers = usdStage.GetUsedLayers()
# This list excludes any session layers.
usedLayersOnDisk = [i for i in usedLayers if i.realPath]
if len(usedLayersOnDisk) > 1:
self._AddFailedCheck("The stage uses %s layers. It should "
"contain a single usdc layer to be compatible with ARKit's "
"implementation of usdz." % len(usedLayersOnDisk))
rootLayerRealPath = usdStage.GetRootLayer().realPath
if rootLayerRealPath.endswith(".usdz"):
# Check if the root layer in the package is a usdc.
from pxr import Usd
zipFile = Usd.ZipFile.Open(rootLayerRealPath)
if not zipFile:
self._AddError("Could not open package at path '%s'." %
resolvedPath)
return
fileNames = zipFile.GetFileNames()
if not fileNames[0].endswith(".usdc"):
self._AddFailedCheck("First file (%s) in usdz package '%s' "
"does not have the .usdc extension." % (fileNames[0],
rootLayerRealPath))
elif not rootLayerRealPath.endswith(".usdc"):
self._AddFailedCheck("Root layer of the stage '%s' does not "
"have the '.usdc' extension." % (rootLayerRealPath))
class ComplianceChecker(object):
""" A utility class for checking compliance of a given USD asset or a USDZ
package.
Since usdz files are zip files, someone could use generic zip tools to
create an archive and just change the extension, producing a .usdz file that
does not honor the additional constraints that usdz files require. Even if
someone does use our official archive creation tools, though, we
intentionally allow creation of usdz files that can be very "permissive" in
their contents for internal studio uses, where portability outside the
studio is not a concern. For content meant to be delivered over the web
(eg. ARKit assets), however, we must be much more restrictive.
This class provides two levels of compliance checking:
* "structural" validation that is represented by a set of base rules.
* "ARKit" compatibility validation, which includes many more restrictions.
Calling ComplianceChecker.DumpAllRules() will print an enumeration of the
various rules in the two categories of compliance checking.
"""
@staticmethod
def GetBaseRules():
return [ByteAlignmentChecker, CompressionChecker,
MissingReferenceChecker, TextureChecker]
@staticmethod
def GetARKitRules(skipARKitRootLayerCheck=False):
arkitRules = [ARKitLayerChecker, ARKitPrimTypeChecker,
ARKitStageYupChecker, ARKitShaderChecker,
ARKitMaterialBindingChecker,
ARKitFileExtensionChecker,
ARKitPackageEncapsulationChecker]
if not skipARKitRootLayerCheck:
arkitRules.append(ARKitRootLayerChecker)
return arkitRules
@staticmethod
def GetRules(arkit=False, skipARKitRootLayerCheck=False):
allRules = ComplianceChecker.GetBaseRules()
if arkit:
arkitRules = ComplianceChecker.GetARKitRules(
skipARKitRootLayerCheck=skipARKitRootLayerCheck)
allRules += arkitRules
return allRules
@staticmethod
def DumpAllRules():
print('Base rules:')
for ruleNum, rule in enumerate(GetBaseRules()):
print('[%s] %s' % (ruleNum + 1, rule.GetDescription()))
print('-' * 30)
print('ARKit rules: ')
for ruleNum, rule in enumerate(GetBaseRules()):
print('[%s] %s' % (ruleNum + 1, rule.GetDescription()))
print('-' * 30)
def __init__(self, arkit=False, skipARKitRootLayerCheck=False,
rootPackageOnly=False, skipVariants=False, verbose=False):
self._rootPackageOnly = rootPackageOnly
self._doVariants = not skipVariants
self._verbose = verbose
self._errors = []
# Once a package has been checked, it goes into this set.
self._checkedPackages = set()
# Instantiate an instance of every rule checker and store in a list.
self._rules = [Rule(self._verbose) for Rule in
ComplianceChecker.GetRules(arkit, skipARKitRootLayerCheck)]
def _Msg(self, msg):
if self._verbose:
print(msg)
def _AddError(self, errMsg):
self._errors.append(errMsg)
def GetErrors(self):
errors = self._errors
for rule in self._rules:
errs = rule.GetErrors()
for err in errs:
errors.append("Error checking rule '%s': %s" %
(type(rule).__name__, err))
return errors
def DumpRules(self):
descriptions = [rule.GetDescription() for rule in self._rules]
print('Checking rules: ')
for ruleNum, rule in enumerate(descriptions):
print('[%s] %s' % (ruleNum + 1, rule))
print('-' * 30)
def GetFailedChecks(self):
failedChecks = []
for rule in self._rules:
fcs = rule.GetFailedChecks()
for fc in fcs:
failedChecks.append("%s (fails '%s')" % (fc,
type(rule).__name__))
return failedChecks
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 _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 _CheckLayer(self, layer):
for rule in self._rules:
rule.CheckLayer(layer)
def _CheckPrim(self, prim):
for rule in self._rules:
rule.CheckPrim(prim)
def _TraverseRange(self, primRangeIt, isStageRoot):
primsWithVariants = []
rootPrim = primRangeIt.GetCurrentPrim()
for prim in primRangeIt:
# Skip variant set check on the root prim if it is the stage'.
if not self._doVariants or (not isStageRoot and prim == rootPrim):
self._CheckPrim(prim)
continue
vSets = prim.GetVariantSets()
vSetNames = vSets.GetNames()
if len(vSetNames) == 0:
self._CheckPrim(prim)
else:
primsWithVariants.append(prim)
primRangeIt.PruneChildren()
for prim in primsWithVariants:
self._TraverseVariants(prim)
def _TraverseVariants(self, prim):
from pxr import Usd
if prim.IsInstanceProxy():
return True
vSets = prim.GetVariantSets()
vSetNames = vSets.GetNames()
allVariantNames = []
for vSetName in vSetNames:
vSet = vSets.GetVariantSet(vSetName)
vNames = vSet.GetVariantNames()
allVariantNames.append(vNames)
import itertools
allVariations = itertools.product(*allVariantNames)
for variation in allVariations:
self._Msg("Testing variation %s of prim <%s>" %
(variation, prim.GetPath()))
for (idx, sel) in enumerate(variation):
vSets.SetSelection(vSetNames[idx], sel)
primRangeIt = iter(Usd.PrimRange(prim,
Usd.TraverseInstanceProxies()))
self._TraverseRange(primRangeIt, isStageRoot=False)
| 30,368 | Python | 40.715659 | 88 | 0.600797 |
USwampertor/OmniverseJS/ov/python/pxr/UsdUtils/__init__.py | #
# Copyright 2016 Pixar
#
# Licensed under the Apache License, Version 2.0 (the "Apache License")
# with the following modification; you may not use this file except in
# compliance with the Apache License and the following modification to it:
# Section 6. Trademarks. is deleted and replaced with:
#
# 6. Trademarks. This License does not grant permission to use the trade
# names, trademarks, service marks, or product names of the Licensor
# and its affiliates, except as required to comply with Section 4(c) of
# the License and to reproduce the content of the NOTICE file.
#
# You may obtain a copy of the Apache License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the Apache License with the above modification is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the Apache License for the specific
# language governing permissions and limitations under the Apache License.
#
from . import _usdUtils
from pxr import Tf
Tf.PrepareModule(_usdUtils, locals())
del _usdUtils, Tf
try:
from . import __DOC
__DOC.Execute(locals())
del __DOC
except Exception:
pass
from .complianceChecker import ComplianceChecker
| 1,308 | Python | 33.447368 | 74 | 0.753823 |
USwampertor/OmniverseJS/ov/python/pxr/Sdr/__init__.py | #
# Copyright 2018 Pixar
#
# Licensed under the Apache License, Version 2.0 (the "Apache License")
# with the following modification; you may not use this file except in
# compliance with the Apache License and the following modification to it:
# Section 6. Trademarks. is deleted and replaced with:
#
# 6. Trademarks. This License does not grant permission to use the trade
# names, trademarks, service marks, or product names of the Licensor
# and its affiliates, except as required to comply with Section 4(c) of
# the License and to reproduce the content of the NOTICE file.
#
# You may obtain a copy of the Apache License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the Apache License with the above modification is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the Apache License for the specific
# language governing permissions and limitations under the Apache License.
#
"""Python bindings for libSdr"""
from . import _sdr
from pxr import Tf
Tf.PrepareModule(_sdr, locals())
del _sdr, Tf
try:
from . import __DOC
__DOC.Execute(locals())
del __DOC
except Exception:
pass
| 1,277 | Python | 32.631578 | 74 | 0.743931 |
USwampertor/OmniverseJS/ov/python/pxr/Sdr/shaderParserTestUtils.py | #!/pxrpythonsubst
#
# Copyright 2018 Pixar
#
# Licensed under the Apache License, Version 2.0 (the "Apache License")
# with the following modification; you may not use this file except in
# compliance with the Apache License and the following modification to it:
# Section 6. Trademarks. is deleted and replaced with:
#
# 6. Trademarks. This License does not grant permission to use the trade
# names, trademarks, service marks, or product names of the Licensor
# and its affiliates, except as required to comply with Section 4(c) of
# the License and to reproduce the content of the NOTICE file.
#
# You may obtain a copy of the Apache License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the Apache License with the above modification is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the Apache License for the specific
# language governing permissions and limitations under the Apache License.
"""
Common utilities that shader-based parser plugins can use in their tests.
This is mostly focused on dealing with OSL and Args files. This may need to be
expanded/generalized to accommodate other types in the future.
"""
from __future__ import print_function
from pxr import Ndr
from pxr import Sdr
from pxr.Sdf import ValueTypeNames as SdfTypes
from pxr import Tf
def IsNodeOSL(node):
"""
Determines if the given node has an OSL source type.
"""
return node.GetSourceType() == "OSL"
# XXX Maybe rename this to GetSdfType (as opposed to the Sdr type)
def GetType(property):
"""
Given a property (SdrShaderProperty), return the SdfValueTypeName type.
"""
sdfTypeIndicator = property.GetTypeAsSdfType()
sdfValueTypeName = sdfTypeIndicator[0]
tfType = sdfValueTypeName.type
return tfType
def TestBasicProperties(node):
"""
Test the correctness of the properties on the specified node (only the
non-shading-specific aspects).
"""
isOSL = IsNodeOSL(node)
# Data that varies between OSL/Args
# --------------------------------------------------------------------------
metadata = {
"widget": "number",
"label": "inputA label",
"page": "inputs1",
"help": "inputA help message",
"uncategorized": "1"
}
if not isOSL:
metadata["name"] = "inputA"
metadata["default"] = "0.0"
metadata["type"] = "float"
# --------------------------------------------------------------------------
properties = {
"inputA": node.GetInput("inputA"),
"inputB": node.GetInput("inputB"),
"inputC": node.GetInput("inputC"),
"inputD": node.GetInput("inputD"),
"inputF2": node.GetInput("inputF2"),
"inputStrArray": node.GetInput("inputStrArray"),
"resultF": node.GetOutput("resultF"),
"resultI": node.GetOutput("resultI"),
}
assert properties["inputA"].GetName() == "inputA"
assert properties["inputA"].GetType() == "float"
assert properties["inputA"].GetDefaultValue() == 0.0
assert not properties["inputA"].IsOutput()
assert not properties["inputA"].IsArray()
assert not properties["inputA"].IsDynamicArray()
assert properties["inputA"].GetArraySize() == 0
assert properties["inputA"].GetInfoString() == "inputA (type: 'float'); input"
assert properties["inputA"].IsConnectable()
assert properties["inputA"].CanConnectTo(properties["resultF"])
assert not properties["inputA"].CanConnectTo(properties["resultI"])
assert properties["inputA"].GetMetadata() == metadata
# --------------------------------------------------------------------------
# Check some array variations
# --------------------------------------------------------------------------
assert properties["inputD"].IsDynamicArray()
assert properties["inputD"].GetArraySize() == 1 if isOSL else -1
assert properties["inputD"].IsArray()
assert list(properties["inputD"].GetDefaultValue()) == [1]
assert not properties["inputF2"].IsDynamicArray()
assert properties["inputF2"].GetArraySize() == 2
assert properties["inputF2"].IsArray()
assert not properties["inputF2"].IsConnectable()
assert list(properties["inputF2"].GetDefaultValue()) == [1.0, 2.0]
assert properties["inputStrArray"].GetArraySize() == 4
assert list(properties["inputStrArray"].GetDefaultValue()) == \
["test", "string", "array", "values"]
def TestShadingProperties(node):
"""
Test the correctness of the properties on the specified node (only the
shading-specific aspects).
"""
isOSL = IsNodeOSL(node)
properties = {
"inputA": node.GetShaderInput("inputA"),
"inputB": node.GetShaderInput("inputB"),
"inputC": node.GetShaderInput("inputC"),
"inputD": node.GetShaderInput("inputD"),
"inputF2": node.GetShaderInput("inputF2"),
"inputF3": node.GetShaderInput("inputF3"),
"inputF4": node.GetShaderInput("inputF4"),
"inputF5": node.GetShaderInput("inputF5"),
"inputInterp": node.GetShaderInput("inputInterp"),
"inputOptions": node.GetShaderInput("inputOptions"),
"inputPoint": node.GetShaderInput("inputPoint"),
"inputNormal": node.GetShaderInput("inputNormal"),
"inputStruct": node.GetShaderInput("inputStruct"),
"inputAssetIdentifier": node.GetShaderInput("inputAssetIdentifier"),
"resultF": node.GetShaderOutput("resultF"),
"resultF2": node.GetShaderOutput("resultF2"),
"resultF3": node.GetShaderOutput("resultF3"),
"resultI": node.GetShaderOutput("resultI"),
"vstruct1": node.GetShaderOutput("vstruct1"),
"vstruct1_bump": node.GetShaderOutput("vstruct1_bump"),
"outputPoint": node.GetShaderOutput("outputPoint"),
"outputNormal": node.GetShaderOutput("outputNormal"),
"outputColor": node.GetShaderOutput("outputColor"),
"outputVector": node.GetShaderOutput("outputVector"),
}
assert properties["inputA"].GetLabel() == "inputA label"
assert properties["inputA"].GetHelp() == "inputA help message"
assert properties["inputA"].GetPage() == "inputs1"
assert properties["inputA"].GetWidget() == "number"
assert properties["inputA"].GetHints() == {
"uncategorized": "1"
}
assert properties["inputA"].GetOptions() == []
assert properties["inputA"].GetVStructMemberOf() == ""
assert properties["inputA"].GetVStructMemberName() == ""
assert not properties["inputA"].IsVStructMember()
assert not properties["inputA"].IsVStruct()
assert properties["inputA"].IsConnectable()
assert properties["inputA"].GetValidConnectionTypes() == []
assert properties["inputA"].CanConnectTo(properties["resultF"])
assert not properties["inputA"].CanConnectTo(properties["resultI"])
# --------------------------------------------------------------------------
# Check correct options parsing
# --------------------------------------------------------------------------
assert set(properties["inputOptions"].GetOptions()) == {
("opt1", "opt1val"),
("opt2", "opt2val")
}
assert set(properties["inputInterp"].GetOptions()) == {
("linear", ""),
("catmull-rom", ""),
("bspline", ""),
("constant", ""),
}
# --------------------------------------------------------------------------
# Check cross-type connection allowances
# --------------------------------------------------------------------------
assert properties["inputPoint"].CanConnectTo(properties["outputNormal"])
assert properties["inputNormal"].CanConnectTo(properties["outputPoint"])
assert properties["inputNormal"].CanConnectTo(properties["outputColor"])
assert properties["inputNormal"].CanConnectTo(properties["outputVector"])
assert properties["inputNormal"].CanConnectTo(properties["resultF3"])
assert properties["inputF2"].CanConnectTo(properties["resultF2"])
assert properties["inputD"].CanConnectTo(properties["resultI"])
assert not properties["inputNormal"].CanConnectTo(properties["resultF2"])
assert not properties["inputF4"].CanConnectTo(properties["resultF2"])
assert not properties["inputF2"].CanConnectTo(properties["resultF3"])
# --------------------------------------------------------------------------
# Check clean and unclean mappings to Sdf types
# --------------------------------------------------------------------------
assert properties["inputB"].GetTypeAsSdfType() == (SdfTypes.Int, "")
assert properties["inputF2"].GetTypeAsSdfType() == (SdfTypes.Float2, "")
assert properties["inputF3"].GetTypeAsSdfType() == (SdfTypes.Float3, "")
assert properties["inputF4"].GetTypeAsSdfType() == (SdfTypes.Float4, "")
assert properties["inputF5"].GetTypeAsSdfType() == (SdfTypes.FloatArray, "")
assert properties["inputStruct"].GetTypeAsSdfType() == \
(SdfTypes.Token, Sdr.PropertyTypes.Struct)
# --------------------------------------------------------------------------
# Ensure asset identifiers are detected correctly
# --------------------------------------------------------------------------
assert properties["inputAssetIdentifier"].IsAssetIdentifier()
assert not properties["inputOptions"].IsAssetIdentifier()
assert properties["inputAssetIdentifier"].GetTypeAsSdfType() == \
(SdfTypes.Asset, "")
# Nested pages and VStructs are only possible in args files
if not isOSL:
# ----------------------------------------------------------------------
# Check nested page correctness
# ----------------------------------------------------------------------
assert properties["vstruct1"].GetPage() == "VStructs.Nested"
assert properties["vstruct1_bump"].GetPage() == "VStructs.Nested.More"
# ----------------------------------------------------------------------
# Check VStruct correctness
# ----------------------------------------------------------------------
assert properties["vstruct1"].IsVStruct()
assert properties["vstruct1"].GetVStructMemberOf() == ""
assert properties["vstruct1"].GetVStructMemberName() == ""
assert not properties["vstruct1"].IsVStructMember()
assert not properties["vstruct1_bump"].IsVStruct()
assert properties["vstruct1_bump"].GetVStructMemberOf() == "vstruct1"
assert properties["vstruct1_bump"].GetVStructMemberName() == "bump"
assert properties["vstruct1_bump"].IsVStructMember()
def TestBasicNode(node, nodeSourceType, nodeDefinitionURI, nodeImplementationURI):
"""
Test basic, non-shader-specific correctness on the specified node.
"""
# Implementation notes:
# ---
# The source type needs to be passed manually in order to ensure the utils
# do not have a dependency on the plugin (where the source type resides).
# The URIs are manually specified because the utils cannot know ahead of
# time where the node originated.
isOSL = IsNodeOSL(node)
nodeContext = "OSL" if isOSL else "pattern"
# Data that varies between OSL/Args
# --------------------------------------------------------------------------
nodeName = "TestNodeOSL" if isOSL else "TestNodeARGS"
numOutputs = 8 if isOSL else 10
outputNames = {
"resultF", "resultF2", "resultF3", "resultI", "outputPoint",
"outputNormal", "outputColor", "outputVector"
}
metadata = {
"category": "testing",
"departments": "testDept",
"help": "This is the test node",
"label": "TestNodeLabel",
"primvars": "primvar1|primvar2|primvar3|$primvarNamingProperty|"
"$invalidPrimvarNamingProperty",
"uncategorizedMetadata": "uncategorized"
}
if not isOSL:
metadata.pop("category")
metadata.pop("label")
metadata.pop("uncategorizedMetadata")
outputNames.add("vstruct1")
outputNames.add("vstruct1_bump")
# --------------------------------------------------------------------------
nodeInputs = {propertyName: node.GetShaderInput(propertyName)
for propertyName in node.GetInputNames()}
nodeOutputs = {propertyName: node.GetShaderOutput(propertyName)
for propertyName in node.GetOutputNames()}
assert node.GetName() == nodeName
assert node.GetContext() == nodeContext
assert node.GetSourceType() == nodeSourceType
assert node.GetFamily() == ""
assert node.GetResolvedDefinitionURI() == nodeDefinitionURI
assert node.GetResolvedImplementationURI() == nodeImplementationURI
assert node.IsValid()
assert len(nodeInputs) == 17
assert len(nodeOutputs) == numOutputs
assert nodeInputs["inputA"] is not None
assert nodeInputs["inputB"] is not None
assert nodeInputs["inputC"] is not None
assert nodeInputs["inputD"] is not None
assert nodeInputs["inputF2"] is not None
assert nodeInputs["inputF3"] is not None
assert nodeInputs["inputF4"] is not None
assert nodeInputs["inputF5"] is not None
assert nodeInputs["inputInterp"] is not None
assert nodeInputs["inputOptions"] is not None
assert nodeInputs["inputPoint"] is not None
assert nodeInputs["inputNormal"] is not None
assert nodeOutputs["resultF2"] is not None
assert nodeOutputs["resultI"] is not None
assert nodeOutputs["outputPoint"] is not None
assert nodeOutputs["outputNormal"] is not None
assert nodeOutputs["outputColor"] is not None
assert nodeOutputs["outputVector"] is not None
print(set(node.GetInputNames()))
assert set(node.GetInputNames()) == {
"inputA", "inputB", "inputC", "inputD", "inputF2", "inputF3", "inputF4",
"inputF5", "inputInterp", "inputOptions", "inputPoint", "inputNormal",
"inputStruct", "inputAssetIdentifier", "primvarNamingProperty",
"invalidPrimvarNamingProperty", "inputStrArray"
}
assert set(node.GetOutputNames()) == outputNames
# There may be additional metadata passed in via the NdrNodeDiscoveryResult.
# So, ensure that the bits we expect to see are there instead of doing
# an equality check.
nodeMetadata = node.GetMetadata()
for i,j in metadata.items():
assert i in nodeMetadata
assert nodeMetadata[i] == metadata[i]
# Test basic property correctness
TestBasicProperties(node)
def TestShaderSpecificNode(node):
"""
Test shader-specific correctness on the specified node.
"""
isOSL = IsNodeOSL(node)
# Data that varies between OSL/Args
# --------------------------------------------------------------------------
numOutputs = 8 if isOSL else 10
label = "TestNodeLabel" if isOSL else ""
category = "testing" if isOSL else ""
vstructNames = [] if isOSL else ["vstruct1"]
pages = {"", "inputs1", "inputs2", "results"} if isOSL else \
{"", "inputs1", "inputs2", "results", "VStructs.Nested",
"VStructs.Nested.More"}
# --------------------------------------------------------------------------
shaderInputs = {propertyName: node.GetShaderInput(propertyName)
for propertyName in node.GetInputNames()}
shaderOutputs = {propertyName: node.GetShaderOutput(propertyName)
for propertyName in node.GetOutputNames()}
assert len(shaderInputs) == 17
assert len(shaderOutputs) == numOutputs
assert shaderInputs["inputA"] is not None
assert shaderInputs["inputB"] is not None
assert shaderInputs["inputC"] is not None
assert shaderInputs["inputD"] is not None
assert shaderInputs["inputF2"] is not None
assert shaderInputs["inputF3"] is not None
assert shaderInputs["inputF4"] is not None
assert shaderInputs["inputF5"] is not None
assert shaderInputs["inputInterp"] is not None
assert shaderInputs["inputOptions"] is not None
assert shaderInputs["inputPoint"] is not None
assert shaderInputs["inputNormal"] is not None
assert shaderOutputs["resultF"] is not None
assert shaderOutputs["resultF2"] is not None
assert shaderOutputs["resultF3"] is not None
assert shaderOutputs["resultI"] is not None
assert shaderOutputs["outputPoint"] is not None
assert shaderOutputs["outputNormal"] is not None
assert shaderOutputs["outputColor"] is not None
assert shaderOutputs["outputVector"] is not None
assert node.GetLabel() == label
assert node.GetCategory() == category
assert node.GetHelp() == "This is the test node"
assert node.GetDepartments() == ["testDept"]
assert set(node.GetPages()) == pages
assert set(node.GetPrimvars()) == {"primvar1", "primvar2", "primvar3"}
assert set(node.GetAdditionalPrimvarProperties()) == {"primvarNamingProperty"}
assert set(node.GetPropertyNamesForPage("results")) == {
"resultF", "resultF2", "resultF3", "resultI"
}
assert set(node.GetPropertyNamesForPage("")) == {
"outputPoint", "outputNormal", "outputColor", "outputVector"
}
assert set(node.GetPropertyNamesForPage("inputs1")) == {"inputA"}
assert set(node.GetPropertyNamesForPage("inputs2")) == {
"inputB", "inputC", "inputD", "inputF2", "inputF3", "inputF4", "inputF5",
"inputInterp", "inputOptions", "inputPoint", "inputNormal",
"inputStruct", "inputAssetIdentifier", "primvarNamingProperty",
"invalidPrimvarNamingProperty", "inputStrArray"
}
assert node.GetAllVstructNames() == vstructNames
# Test shading-specific property correctness
TestShadingProperties(node)
def TestShaderPropertiesNode(node):
"""
Tests property correctness on the specified shader node, which must be
one of the following pre-defined nodes:
* 'TestShaderPropertiesNodeOSL'
* 'TestShaderPropertiesNodeARGS'
* 'TestShaderPropertiesNodeUSD'
These pre-defined nodes have a property of every type that Sdr supports.
Property correctness is defined as:
* The shader property has the expected SdrPropertyType
* The shader property has the expected SdfValueTypeName
* If the shader property has a default value, the default value's type
matches the shader property's type
"""
# This test should only be run on the following allowed node names
# --------------------------------------------------------------------------
allowedNodeNames = ["TestShaderPropertiesNodeOSL",
"TestShaderPropertiesNodeARGS",
"TestShaderPropertiesNodeUSD"]
# If this assertion on the name fails, then this test was called with the
# wrong node.
assert node.GetName() in allowedNodeNames
# If we have the correct node name, double check that the source type is
# also correct
if node.GetName() == "TestShaderPropertiesNodeOSL":
assert node.GetSourceType() == "OSL"
elif node.GetName() == "TestShaderPropertiesNodeARGS":
assert node.GetSourceType() == "RmanCpp"
elif node.GetName() == "TestShaderPropertiesNodeUSD":
assert node.GetSourceType() == "glslfx"
nodeInputs = {propertyName: node.GetShaderInput(propertyName)
for propertyName in node.GetInputNames()}
nodeOutputs = {propertyName: node.GetShaderOutput(propertyName)
for propertyName in node.GetOutputNames()}
# For each property, we test that:
# * The property has the expected SdrPropertyType
# * The property has the expected TfType (from SdfValueTypeName)
# * The property's type and default value's type match
property = nodeInputs["inputInt"]
assert property.GetType() == Sdr.PropertyTypes.Int
assert GetType(property) == Tf.Type.FindByName("int")
assert Ndr._ValidateProperty(node, property)
property = nodeInputs["inputString"]
assert property.GetType() == Sdr.PropertyTypes.String
assert GetType(property) == Tf.Type.FindByName("string")
assert Ndr._ValidateProperty(node, property)
property = nodeInputs["inputFloat"]
assert property.GetType() == Sdr.PropertyTypes.Float
assert GetType(property) == Tf.Type.FindByName("float")
assert Ndr._ValidateProperty(node, property)
property = nodeInputs["inputColor"]
assert property.GetType() == Sdr.PropertyTypes.Color
assert GetType(property) == Tf.Type.FindByName("GfVec3f")
assert Ndr._ValidateProperty(node, property)
property = nodeInputs["inputPoint"]
assert property.GetType() == Sdr.PropertyTypes.Point
assert GetType(property) == Tf.Type.FindByName("GfVec3f")
assert Ndr._ValidateProperty(node, property)
property = nodeInputs["inputNormal"]
assert property.GetType() == Sdr.PropertyTypes.Normal
assert GetType(property) == Tf.Type.FindByName("GfVec3f")
assert Ndr._ValidateProperty(node, property)
property = nodeInputs["inputVector"]
assert property.GetType() == Sdr.PropertyTypes.Vector
assert GetType(property) == Tf.Type.FindByName("GfVec3f")
assert Ndr._ValidateProperty(node, property)
property = nodeInputs["inputMatrix"]
assert property.GetType() == Sdr.PropertyTypes.Matrix
assert GetType(property) == Tf.Type.FindByName("GfMatrix4d")
assert Ndr._ValidateProperty(node, property)
if node.GetName() != "TestShaderPropertiesNodeUSD":
# XXX Note that 'struct' and 'vstruct' types are currently unsupported
# by the UsdShadeShaderDefParserPlugin, which parses shaders defined in
# usd files. Please see UsdShadeShaderDefParserPlugin implementation for
# details.
property = nodeInputs["inputStruct"]
assert property.GetType() == Sdr.PropertyTypes.Struct
assert GetType(property) == Tf.Type.FindByName("TfToken")
assert Ndr._ValidateProperty(node, property)
property = nodeInputs["inputVstruct"]
assert property.GetType() == Sdr.PropertyTypes.Vstruct
assert GetType(property) == Tf.Type.FindByName("TfToken")
assert Ndr._ValidateProperty(node, property)
property = nodeInputs["inputIntArray"]
assert property.GetType() == Sdr.PropertyTypes.Int
assert GetType(property) == Tf.Type.FindByName("VtArray<int>")
assert Ndr._ValidateProperty(node, property)
property = nodeInputs["inputStringArray"]
assert property.GetType() == Sdr.PropertyTypes.String
assert GetType(property) == Tf.Type.FindByName("VtArray<string>")
assert Ndr._ValidateProperty(node, property)
property = nodeInputs["inputFloatArray"]
assert property.GetType() == Sdr.PropertyTypes.Float
assert GetType(property) == Tf.Type.FindByName("VtArray<float>")
assert Ndr._ValidateProperty(node, property)
property = nodeInputs["inputColorArray"]
assert property.GetType() == Sdr.PropertyTypes.Color
assert GetType(property) == Tf.Type.FindByName("VtArray<GfVec3f>")
assert Ndr._ValidateProperty(node, property)
property = nodeInputs["inputPointArray"]
assert property.GetType() == Sdr.PropertyTypes.Point
assert GetType(property) == Tf.Type.FindByName("VtArray<GfVec3f>")
assert Ndr._ValidateProperty(node, property)
property = nodeInputs["inputNormalArray"]
assert property.GetType() == Sdr.PropertyTypes.Normal
assert GetType(property) == Tf.Type.FindByName("VtArray<GfVec3f>")
assert Ndr._ValidateProperty(node, property)
property = nodeInputs["inputVectorArray"]
assert property.GetType() == Sdr.PropertyTypes.Vector
assert GetType(property) == Tf.Type.FindByName("VtArray<GfVec3f>")
assert Ndr._ValidateProperty(node, property)
property = nodeInputs["inputMatrixArray"]
assert property.GetType() == Sdr.PropertyTypes.Matrix
assert GetType(property) == Tf.Type.FindByName("VtArray<GfMatrix4d>")
assert Ndr._ValidateProperty(node, property)
property = nodeInputs["inputFloat2"]
assert property.GetType() == Sdr.PropertyTypes.Float
assert GetType(property) == Tf.Type.FindByName("GfVec2f")
assert Ndr._ValidateProperty(node, property)
property = nodeInputs["inputFloat3"]
assert property.GetType() == Sdr.PropertyTypes.Float
assert GetType(property) == Tf.Type.FindByName("GfVec3f")
assert Ndr._ValidateProperty(node, property)
property = nodeInputs["inputFloat4"]
assert property.GetType() == Sdr.PropertyTypes.Float
assert GetType(property) == Tf.Type.FindByName("GfVec4f")
assert Ndr._ValidateProperty(node, property)
property = nodeInputs["inputAsset"]
assert property.GetType() == Sdr.PropertyTypes.String
assert GetType(property) == Tf.Type.FindByName("SdfAssetPath")
assert Ndr._ValidateProperty(node, property)
property = nodeInputs["inputAssetArray"]
assert property.GetType() == Sdr.PropertyTypes.String
assert GetType(property) == Tf.Type.FindByName("VtArray<SdfAssetPath>")
assert Ndr._ValidateProperty(node, property)
property = nodeInputs["inputColorRoleNone"]
assert property.GetType() == Sdr.PropertyTypes.Float
assert GetType(property) == Tf.Type.FindByName("GfVec3f")
assert Ndr._ValidateProperty(node, property)
property = nodeInputs["inputPointRoleNone"]
assert property.GetType() == Sdr.PropertyTypes.Float
assert GetType(property) == Tf.Type.FindByName("GfVec3f")
assert Ndr._ValidateProperty(node, property)
property = nodeInputs["inputNormalRoleNone"]
assert property.GetType() == Sdr.PropertyTypes.Float
assert GetType(property) == Tf.Type.FindByName("GfVec3f")
assert Ndr._ValidateProperty(node, property)
property = nodeInputs["inputVectorRoleNone"]
assert property.GetType() == Sdr.PropertyTypes.Float
assert GetType(property) == Tf.Type.FindByName("GfVec3f")
assert Ndr._ValidateProperty(node, property)
property = nodeOutputs["outputSurface"]
assert property.GetType() == Sdr.PropertyTypes.Terminal
assert GetType(property) == Tf.Type.FindByName("TfToken")
assert Ndr._ValidateProperty(node, property)
# Specific test of implementationName feature, we can skip type-tests
property = nodeInputs["normal"]
assert property.GetImplementationName() == "aliasedNormalInput"
assert Ndr._ValidateProperty(node, property)
| 26,416 | Python | 42.165033 | 82 | 0.649758 |
USwampertor/OmniverseJS/ov/python/pxr/UsdSkel/__init__.py | #
# Copyright 2016 Pixar
#
# Licensed under the Apache License, Version 2.0 (the "Apache License")
# with the following modification; you may not use this file except in
# compliance with the Apache License and the following modification to it:
# Section 6. Trademarks. is deleted and replaced with:
#
# 6. Trademarks. This License does not grant permission to use the trade
# names, trademarks, service marks, or product names of the Licensor
# and its affiliates, except as required to comply with Section 4(c) of
# the License and to reproduce the content of the NOTICE file.
#
# You may obtain a copy of the Apache License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the Apache License with the above modification is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the Apache License for the specific
# language governing permissions and limitations under the Apache License.
#
from . import _usdSkel
from pxr import Tf
Tf.PrepareModule(_usdSkel, locals())
del Tf
try:
from . import __DOC
__DOC.Execute(locals())
del __DOC
except Exception:
pass
| 1,244 | Python | 34.571428 | 74 | 0.749196 |
USwampertor/OmniverseJS/ov/python/pxr/UsdHydra/__init__.py | #
# Copyright 2016 Pixar
#
# Licensed under the Apache License, Version 2.0 (the "Apache License")
# with the following modification; you may not use this file except in
# compliance with the Apache License and the following modification to it:
# Section 6. Trademarks. is deleted and replaced with:
#
# 6. Trademarks. This License does not grant permission to use the trade
# names, trademarks, service marks, or product names of the Licensor
# and its affiliates, except as required to comply with Section 4(c) of
# the License and to reproduce the content of the NOTICE file.
#
# You may obtain a copy of the Apache License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the Apache License with the above modification is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the Apache License for the specific
# language governing permissions and limitations under the Apache License.
#
from . import _usdHydra
from pxr import Tf
Tf.PrepareModule(_usdHydra, locals())
del Tf
try:
from . import __DOC
__DOC.Execute(locals())
del __DOC
except Exception:
pass
| 1,247 | Python | 33.666666 | 74 | 0.748998 |
USwampertor/OmniverseJS/ov/python/pxr/UsdSchemaExamples/__init__.py | #
# Copyright 2016 Pixar
#
# Licensed under the Apache License, Version 2.0 (the "Apache License")
# with the following modification; you may not use this file except in
# compliance with the Apache License and the following modification to it:
# Section 6. Trademarks. is deleted and replaced with:
#
# 6. Trademarks. This License does not grant permission to use the trade
# names, trademarks, service marks, or product names of the Licensor
# and its affiliates, except as required to comply with Section 4(c) of
# the License and to reproduce the content of the NOTICE file.
#
# You may obtain a copy of the Apache License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the Apache License with the above modification is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the Apache License for the specific
# language governing permissions and limitations under the Apache License.
#
from . import _usdSchemaExamples
from pxr import Tf
Tf.PrepareModule(_usdSchemaExamples, locals())
del Tf
try:
from . import __DOC
__DOC.Execute(locals())
del __DOC
except Exception:
pass
| 1,264 | Python | 35.142856 | 74 | 0.753165 |
USwampertor/OmniverseJS/ov/python/pxr/Vt/__init__.py | #
# Copyright 2016 Pixar
#
# Licensed under the Apache License, Version 2.0 (the "Apache License")
# with the following modification; you may not use this file except in
# compliance with the Apache License and the following modification to it:
# Section 6. Trademarks. is deleted and replaced with:
#
# 6. Trademarks. This License does not grant permission to use the trade
# names, trademarks, service marks, or product names of the Licensor
# and its affiliates, except as required to comply with Section 4(c) of
# the License and to reproduce the content of the NOTICE file.
#
# You may obtain a copy of the Apache License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the Apache License with the above modification is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the Apache License for the specific
# language governing permissions and limitations under the Apache License.
#
"""Vt Value Types library
This package defines classes for creating objects that behave like value
types. It contains facilities for creating simple copy-on-write
implicitly shared types.
"""
from . import _vt
from pxr import Tf
Tf.PrepareModule(_vt, locals())
del _vt, Tf
try:
from . import __DOC
__DOC.Execute(locals())
del __DOC
except Exception:
pass
# For ease-of-use, put each XXXArrayFromBuffer method on its corresponding array
# wrapper class, also alias it as 'FromNumpy' for compatibility.
def _CopyArrayFromBufferFuncs(moduleContents):
funcs = dict([(key, val) for (key, val) in moduleContents.items()
if key.endswith('FromBuffer')])
classes = dict([(key, val) for (key, val) in moduleContents.items()
if key.endswith('Array') and isinstance(val, type)])
for funcName, func in funcs.items():
className = funcName[:-len('FromBuffer')]
cls = classes.get(className)
if cls:
setattr(cls, 'FromBuffer', staticmethod(func))
setattr(cls, 'FromNumpy', staticmethod(func))
_CopyArrayFromBufferFuncs(dict(vars()))
del _CopyArrayFromBufferFuncs
| 2,226 | Python | 36.116666 | 80 | 0.720126 |
USwampertor/OmniverseJS/ov/python/pxr/UsdMdl/__init__.py | #******************************************************************************
# * Copyright 2019 NVIDIA Corporation. All rights reserved.
# *****************************************************************************
#
# NVIDIA Material Definition Language (MDL) USD plugins.
#
# MDL Search Paths
# ================
# At startup (i.e. when the MDL SDK is loaded) MDL search path is set in this order:
# 1/ Dedicated environement variable
# If it is set, PXR_USDMDL_PLUGIN_SEARCH_PATHS overwrites any MDL search path.
# PXR_USDMDL_PLUGIN_SEARCH_PATHS can be set to a list of paths.
# 2/ System and User Path
# if PXR_USDMDL_PLUGIN_SEARCH_PATHS is not set:
# a/ If set, add MDL_SYSTEM_PATH to the MDL search path
# b/ If set, add MDL_USER_PATH to the MDL search path
#
# Discovery plugin
# ================
# MDL discovery plugin is derived from NdrDiscoveryPlugin interface.
# This plugin finds MDL functions and materials from all the modules found in the
# MDL search paths.
# This discovery plugin is executed as soon as the registry is instantiated,
# for example in Python:
#
# >>> from pxr import Sdr
# >>> reg = Sdr.Registry()
#
# MDL discovery plugin creates a discovery result (NdrNodeDiscoveryResult)
# for each material and each function that is found.
#
# Parser plugin
# ================
# MDL parser plugin is derived from NdrParserPlugin interface.
# This plugin is responsible to parse a given MDL function or material and
# create an NdrNode instance.
# The parser plugin which is run is decided based on the discovery result discoveryType.
# The parser plugin is invoked whenever a shader node is requested, for example in Python:
#
# >>> from pxr import Sdr
# >>> MDLQualifiedName = "::material_examples::architectural::architectural"
# >>> Sdr.Registry().GetShaderNodeByIdentifierAndType(MDLQualifiedName, "mdl")
#
# NdrNodes which is created contains a list of properties which are translated
# from MDL parameters.
#
from . import _usdMdl
from pxr import Tf
Tf.PrepareModule(_usdMdl, locals())
del Tf
try:
import __DOC
__DOC.Execute(locals())
del __DOC
except Exception:
try:
import __tmpDoc
__tmpDoc.Execute(locals())
del __tmpDoc
except:
pass
| 2,253 | Python | 34.777777 | 90 | 0.656458 |
USwampertor/OmniverseJS/ov/python/pxr/UsdGeom/__init__.py | #
# Copyright 2016 Pixar
#
# Licensed under the Apache License, Version 2.0 (the "Apache License")
# with the following modification; you may not use this file except in
# compliance with the Apache License and the following modification to it:
# Section 6. Trademarks. is deleted and replaced with:
#
# 6. Trademarks. This License does not grant permission to use the trade
# names, trademarks, service marks, or product names of the Licensor
# and its affiliates, except as required to comply with Section 4(c) of
# the License and to reproduce the content of the NOTICE file.
#
# You may obtain a copy of the Apache License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the Apache License with the above modification is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the Apache License for the specific
# language governing permissions and limitations under the Apache License.
#
from . import _usdGeom
from pxr import Tf
Tf.PrepareModule(_usdGeom, locals())
del Tf
try:
from . import __DOC
__DOC.Execute(locals())
del __DOC
except Exception:
pass
| 1,244 | Python | 34.571428 | 74 | 0.749196 |
USwampertor/OmniverseJS/ov/python/pxr/UsdMedia/__init__.py | #
# Copyright 2019 Pixar
#
# Licensed under the Apache License, Version 2.0 (the "Apache License")
# with the following modification; you may not use this file except in
# compliance with the Apache License and the following modification to it:
# Section 6. Trademarks. is deleted and replaced with:
#
# 6. Trademarks. This License does not grant permission to use the trade
# names, trademarks, service marks, or product names of the Licensor
# and its affiliates, except as required to comply with Section 4(c) of
# the License and to reproduce the content of the NOTICE file.
#
# You may obtain a copy of the Apache License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the Apache License with the above modification is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the Apache License for the specific
# language governing permissions and limitations under the Apache License.
#
from . import _usdMedia
from pxr import Tf
Tf.PrepareModule(_usdMedia, locals())
del Tf
try:
from . import __DOC
__DOC.Execute(locals())
del __DOC
except Exception:
pass
| 1,247 | Python | 33.666666 | 74 | 0.748998 |
USwampertor/OmniverseJS/ov/python/pxr/Glf/__init__.py | #
# Copyright 2016 Pixar
#
# Licensed under the Apache License, Version 2.0 (the "Apache License")
# with the following modification; you may not use this file except in
# compliance with the Apache License and the following modification to it:
# Section 6. Trademarks. is deleted and replaced with:
#
# 6. Trademarks. This License does not grant permission to use the trade
# names, trademarks, service marks, or product names of the Licensor
# and its affiliates, except as required to comply with Section 4(c) of
# the License and to reproduce the content of the NOTICE file.
#
# You may obtain a copy of the Apache License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the Apache License with the above modification is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the Apache License for the specific
# language governing permissions and limitations under the Apache License.
#
"""
glf
"""
from . import _glf
from pxr import Tf
Tf.PrepareModule(_glf, locals())
del _glf, Tf
try:
from . import __DOC
__DOC.Execute(locals())
del __DOC
except Exception:
pass
| 1,257 | Python | 29.682926 | 74 | 0.739857 |
USwampertor/OmniverseJS/ov/python/pxr/Trace/__init__.py | #
# Copyright 2018 Pixar
#
# Licensed under the Apache License, Version 2.0 (the "Apache License")
# with the following modification; you may not use this file except in
# compliance with the Apache License and the following modification to it:
# Section 6. Trademarks. is deleted and replaced with:
#
# 6. Trademarks. This License does not grant permission to use the trade
# names, trademarks, service marks, or product names of the Licensor
# and its affiliates, except as required to comply with Section 4(c) of
# the License and to reproduce the content of the NOTICE file.
#
# You may obtain a copy of the Apache License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the Apache License with the above modification is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the Apache License for the specific
# language governing permissions and limitations under the Apache License.
#
"""
Trace -- Utilities for counting and recording events.
"""
from . import _trace
from pxr import Tf
Tf.PrepareModule(_trace, locals())
del _trace, Tf
import contextlib
@contextlib.contextmanager
def TraceScope(label):
"""A context manager that calls BeginEvent on the global collector on enter
and EndEvent on exit."""
try:
collector = Collector()
eventId = collector.BeginEvent(label)
yield
finally:
collector.EndEvent(label)
del contextlib
def TraceFunction(obj):
"""A decorator that enables tracing the function that it decorates.
If you decorate with 'TraceFunction' the function will be traced in the
global collector."""
collector = Collector()
def decorate(func):
import inspect
if inspect.ismethod(func):
callableTypeLabel = 'method'
classLabel = func.__self__.__class__.__name__+'.'
else:
callableTypeLabel = 'func'
classLabel = ''
module = inspect.getmodule(func)
if module is not None:
moduleLabel = module.__name__+'.'
else:
moduleLabel = ''
label = 'Python {0}: {1}{2}{3}'.format(
callableTypeLabel,
moduleLabel,
classLabel,
func.__name__)
def invoke(*args, **kwargs):
with TraceScope(label):
return func(*args, **kwargs)
invoke.__name__ = func.__name__
# Make sure wrapper function gets attributes of wrapped function.
import functools
return functools.update_wrapper(invoke, func)
return decorate(obj)
def TraceMethod(obj):
"""A convenience. Same as TraceFunction but changes the recorded
label to use the term 'method' rather than 'function'."""
return TraceFunction(obj)
# Remove any private stuff, like test classes, if we are not being
# imported from a test.
try:
from . import __DOC
__DOC.Execute(locals())
del __DOC
except Exception:
pass
| 3,092 | Python | 29.323529 | 80 | 0.664618 |
USwampertor/OmniverseJS/ov/python/pxr/Trace/__main__.py | #
# Copyright 2018 Pixar
#
# Licensed under the Apache License, Version 2.0 (the "Apache License")
# with the following modification; you may not use this file except in
# compliance with the Apache License and the following modification to it:
# Section 6. Trademarks. is deleted and replaced with:
#
# 6. Trademarks. This License does not grant permission to use the trade
# names, trademarks, service marks, or product names of the Licensor
# and its affiliates, except as required to comply with Section 4(c) of
# the License and to reproduce the content of the NOTICE file.
#
# You may obtain a copy of the Apache License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the Apache License with the above modification is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the Apache License for the specific
# language governing permissions and limitations under the Apache License.
#
# Execute a script with tracing enabled.
# Usage: python -m pxr.Trace [-o OUTPUT] [-c "command" | FILE]
from __future__ import print_function
import argparse, sys
parser = argparse.ArgumentParser(description='Trace script execution.')
parser.add_argument('-o', dest='output', metavar='OUTPUT',
type=str, default=None,
help='trace output; defaults to stdout')
parser.add_argument('-c', dest='cmd',
type=str,
help='trace <cmd> as a Python script')
parser.add_argument('file', metavar="FILE",
nargs='?',
default=None,
help='script to trace')
args = parser.parse_args()
if not args.cmd and not args.file:
print("Must specify a command or script to trace", file=sys.stderr)
sys.exit(1)
if args.cmd and args.file:
print("Only one of -c or FILE may be specified", file=sys.stderr)
sys.exit(1)
from pxr import Trace
env = {}
# Create a Main function that is traced so we always capture a useful
# top-level scope.
if args.file:
@Trace.TraceFunction
def Main():
exec(compile(open(args.file).read(), args.file, 'exec'), env)
else:
@Trace.TraceFunction
def Main():
exec(args.cmd, env)
try:
Trace.Collector().enabled = True
Main()
finally:
Trace.Collector().enabled = False
if args.output is not None:
Trace.Reporter.globalReporter.Report(args.output)
else:
Trace.Reporter.globalReporter.Report()
| 2,580 | Python | 31.670886 | 74 | 0.68062 |
USwampertor/OmniverseJS/ov/python/pxr/UsdAppUtils/cameraArgs.py | #
# Copyright 2019 Pixar
#
# Licensed under the Apache License, Version 2.0 (the "Apache License")
# with the following modification; you may not use this file except in
# compliance with the Apache License and the following modification to it:
# Section 6. Trademarks. is deleted and replaced with:
#
# 6. Trademarks. This License does not grant permission to use the trade
# names, trademarks, service marks, or product names of the Licensor
# and its affiliates, except as required to comply with Section 4(c) of
# the License and to reproduce the content of the NOTICE file.
#
# You may obtain a copy of the Apache License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the Apache License with the above modification is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the Apache License for the specific
# language governing permissions and limitations under the Apache License.
#
def AddCmdlineArgs(argsParser, defaultValue=None, altHelpText=''):
"""
Adds camera-related command line arguments to argsParser.
The resulting 'camera' argument will be an Sdf.Path. If no value is given
and defaultValue is not overridden, 'camera' will be a single-element path
containing the primary camera name.
"""
from pxr import Sdf
from pxr import UsdUtils
if defaultValue is None:
defaultValue = UsdUtils.GetPrimaryCameraName()
helpText = altHelpText
if not helpText:
helpText = (
'Which camera to use - may be given as either just the '
'camera\'s prim name (i.e. just the last element in the prim '
'path), or as a full prim path. Note that if only the prim name '
'is used and more than one camera exists with that name, which '
'one is used will effectively be random (default=%(default)s)')
# This avoids an Sdf warning if an empty string is given, which someone
# might do for example with usdview to open the app using the 'Free' camera
# instead of the primary camera.
def _ToSdfPath(inputArg):
if not inputArg:
return Sdf.Path.emptyPath
return Sdf.Path(inputArg)
argsParser.add_argument('--camera', '-cam', action='store',
type=_ToSdfPath, default=defaultValue, help=helpText)
| 2,434 | Python | 40.982758 | 79 | 0.708299 |
USwampertor/OmniverseJS/ov/python/pxr/UsdAppUtils/colorArgs.py | #
# Copyright 2019 Pixar
#
# Licensed under the Apache License, Version 2.0 (the "Apache License")
# with the following modification; you may not use this file except in
# compliance with the Apache License and the following modification to it:
# Section 6. Trademarks. is deleted and replaced with:
#
# 6. Trademarks. This License does not grant permission to use the trade
# names, trademarks, service marks, or product names of the Licensor
# and its affiliates, except as required to comply with Section 4(c) of
# the License and to reproduce the content of the NOTICE file.
#
# You may obtain a copy of the Apache License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the Apache License with the above modification is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the Apache License for the specific
# language governing permissions and limitations under the Apache License.
#
def AddCmdlineArgs(argsParser, defaultValue='sRGB', altHelpText=''):
"""
Adds color-related command line arguments to argsParser.
The resulting 'colorCorrectionMode' argument will be a Python string.
"""
helpText = altHelpText
if not helpText:
helpText = (
'the color correction mode to use (default=%(default)s)')
argsParser.add_argument('--colorCorrectionMode', '-color', action='store',
type=str, default=defaultValue,
choices=['disabled', 'sRGB', 'openColorIO'], help=helpText)
| 1,608 | Python | 40.256409 | 78 | 0.731343 |
USwampertor/OmniverseJS/ov/python/pxr/UsdAppUtils/complexityArgs.py | #
# Copyright 2019 Pixar
#
# Licensed under the Apache License, Version 2.0 (the "Apache License")
# with the following modification; you may not use this file except in
# compliance with the Apache License and the following modification to it:
# Section 6. Trademarks. is deleted and replaced with:
#
# 6. Trademarks. This License does not grant permission to use the trade
# names, trademarks, service marks, or product names of the Licensor
# and its affiliates, except as required to comply with Section 4(c) of
# the License and to reproduce the content of the NOTICE file.
#
# You may obtain a copy of the Apache License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the Apache License with the above modification is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the Apache License for the specific
# language governing permissions and limitations under the Apache License.
#
class RefinementComplexities(object):
"""
An enum-like container of standard complexity settings.
"""
class _RefinementComplexity(object):
"""
Class which represents a level of mesh refinement complexity. Each
level has a string identifier, a display name, and a float complexity
value.
"""
def __init__(self, compId, name, value):
self._id = compId
self._name = name
self._value = value
def __repr__(self):
return self.id
@property
def id(self):
return self._id
@property
def name(self):
return self._name
@property
def value(self):
return self._value
LOW = _RefinementComplexity("low", "Low", 1.0)
MEDIUM = _RefinementComplexity("medium", "Medium", 1.1)
HIGH = _RefinementComplexity("high", "High", 1.2)
VERY_HIGH = _RefinementComplexity("veryhigh", "Very High", 1.3)
_ordered = (LOW, MEDIUM, HIGH, VERY_HIGH)
@classmethod
def ordered(cls):
"""
Get a tuple of all complexity levels in order.
"""
return cls._ordered
@classmethod
def fromId(cls, compId):
"""
Get a complexity from its identifier.
"""
matches = [comp for comp in cls._ordered if comp.id == compId]
if len(matches) == 0:
raise ValueError("No complexity with id '{}'".format(compId))
return matches[0]
@classmethod
def fromName(cls, name):
"""
Get a complexity from its display name.
"""
matches = [comp for comp in cls._ordered if comp.name == name]
if len(matches) == 0:
raise ValueError("No complexity with name '{}'".format(name))
return matches[0]
@classmethod
def next(cls, comp):
"""
Get the next highest level of complexity. If already at the highest
level, return it.
"""
if comp not in cls._ordered:
raise ValueError("Invalid complexity: {}".format(comp))
nextIndex = min(
len(cls._ordered) - 1,
cls._ordered.index(comp) + 1)
return cls._ordered[nextIndex]
@classmethod
def prev(cls, comp):
"""
Get the next lowest level of complexity. If already at the lowest
level, return it.
"""
if comp not in cls._ordered:
raise ValueError("Invalid complexity: {}".format(comp))
prevIndex = max(0, cls._ordered.index(comp) - 1)
return cls._ordered[prevIndex]
def AddCmdlineArgs(argsParser, defaultValue=RefinementComplexities.LOW,
altHelpText=''):
"""
Adds complexity-related command line arguments to argsParser.
The resulting 'complexity' argument will be one of the standard
RefinementComplexities.
"""
helpText = altHelpText
if not helpText:
helpText = ('level of refinement to use (default=%(default)s)')
argsParser.add_argument('--complexity', '-c', action='store',
type=RefinementComplexities.fromId,
default=defaultValue,
choices=[c for c in RefinementComplexities.ordered()],
help=helpText)
| 4,297 | Python | 31.315789 | 77 | 0.62788 |
USwampertor/OmniverseJS/ov/python/pxr/UsdAppUtils/__init__.py | #
# Copyright 2019 Pixar
#
# Licensed under the Apache License, Version 2.0 (the "Apache License")
# with the following modification; you may not use this file except in
# compliance with the Apache License and the following modification to it:
# Section 6. Trademarks. is deleted and replaced with:
#
# 6. Trademarks. This License does not grant permission to use the trade
# names, trademarks, service marks, or product names of the Licensor
# and its affiliates, except as required to comply with Section 4(c) of
# the License and to reproduce the content of the NOTICE file.
#
# You may obtain a copy of the Apache License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the Apache License with the above modification is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the Apache License for the specific
# language governing permissions and limitations under the Apache License.
#
from . import _usdAppUtils
from pxr import Tf
Tf.PrepareModule(_usdAppUtils, locals())
del _usdAppUtils, Tf
try:
from . import __DOC
__DOC.Execute(locals())
del __DOC
except Exception:
pass
from . import cameraArgs
from . import colorArgs
from . import complexityArgs
from . import framesArgs
from . import rendererArgs
| 1,399 | Python | 31.558139 | 74 | 0.754825 |
USwampertor/OmniverseJS/ov/python/pxr/UsdAppUtils/framesArgs.py | #
# Copyright 2019 Pixar
#
# Licensed under the Apache License, Version 2.0 (the "Apache License")
# with the following modification; you may not use this file except in
# compliance with the Apache License and the following modification to it:
# Section 6. Trademarks. is deleted and replaced with:
#
# 6. Trademarks. This License does not grant permission to use the trade
# names, trademarks, service marks, or product names of the Licensor
# and its affiliates, except as required to comply with Section 4(c) of
# the License and to reproduce the content of the NOTICE file.
#
# You may obtain a copy of the Apache License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the Apache License with the above modification is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the Apache License for the specific
# language governing permissions and limitations under the Apache License.
#
def _GetFloatStringPrecision(floatString):
"""
Gets the floating point precision specified by floatString.
floatString can either contain an actual float in string form, or it can be
a frame placeholder. We simply split the string on the dot (.) and return
the length of the part after the dot, if any.
If there is no dot in the string, a precision of zero is assumed.
"""
floatPrecision = 0
if not floatString:
return floatPrecision
floatStringParts = floatString.split('.')
if len(floatStringParts) > 1:
floatPrecision = len(floatStringParts[1])
return floatPrecision
class FrameSpecIterator(object):
"""
A simple iterator object that handles splitting multiple comma-separated
FrameSpecs into their equivalent UsdUtils.TimeCodeRanges, and then yields
all of the time codes in all of those ranges sequentially when iterated.
This object also stores the minimum floating point precision required to
disambiguate any neighboring time codes in the FrameSpecs given. This can
be used to validate that the frame placeholder in a frame format string has
enough precision to uniquely identify every frame without collisions.
"""
from pxr import UsdUtils
FRAMESPEC_SEPARATOR = ','
def __init__(self, frameSpec):
from pxr import UsdUtils
# Assume all frames are integral until we find a frame spec with a
# non-integral stride.
self._minFloatPrecision = 0
self._timeCodeRanges = []
subFrameSpecs = frameSpec.split(self.FRAMESPEC_SEPARATOR)
for subFrameSpec in subFrameSpecs:
timeCodeRange = UsdUtils.TimeCodeRange.CreateFromFrameSpec(
subFrameSpec)
self._timeCodeRanges.append(timeCodeRange)
specParts = subFrameSpec.split(
UsdUtils.TimeCodeRange.Tokens.StrideSeparator)
if len(specParts) == 2:
stride = specParts[1]
stridePrecision = _GetFloatStringPrecision(stride)
self._minFloatPrecision = max(self._minFloatPrecision,
stridePrecision)
def __iter__(self):
for timeCodeRange in self._timeCodeRanges:
for timeCode in timeCodeRange:
yield timeCode
@property
def minFloatPrecision(self):
return self._minFloatPrecision
def AddCmdlineArgs(argsParser, altDefaultTimeHelpText='', altFramesHelpText=''):
"""
Adds frame-related command line arguments to argsParser.
The resulting 'frames' argument will be an iterable of UsdTimeCodes.
If no command-line arguments are given, 'frames' will be a list containing
only Usd.TimeCode.EarliestTime(). If '--defaultTime' is given, 'frames'
will be a list containing only Usd.TimeCode.Default(). Otherwise,
'--frames' must be given a FrameSpec (or a comma-separated list of
multiple FrameSpecs), and 'frames' will be a FrameSpecIterator which when
iterated will yield the time codes specified by the FrameSpec(s).
"""
timeGroup = argsParser.add_mutually_exclusive_group()
helpText = altDefaultTimeHelpText
if not helpText:
helpText = (
'explicitly operate at the Default time code (the default '
'behavior is to operate at the Earliest time code)')
timeGroup.add_argument('--defaultTime', '-d', action='store_true',
dest='defaultTime', help=helpText)
helpText = altFramesHelpText
if not helpText:
helpText = (
'specify FrameSpec(s) of the time codes to operate on - A '
'FrameSpec consists of up to three floating point values for the '
'start time code, end time code, and stride of a time code range. '
'A single time code can be specified, or a start and end time '
'code can be specified separated by a colon (:). When a start '
'and end time code are specified, the stride may optionally be '
'specified as well, separating it from the start and end time '
'codes with (x). Multiple FrameSpecs can be combined as a '
'comma-separated list. The following are examples of valid '
'FrameSpecs: 123 - 101:105 - 105:101 - 101:109x2 - 101:110x2 - '
'101:104x0.5')
timeGroup.add_argument('--frames', '-f', action='store', type=str,
dest='frames', metavar='FRAMESPEC[,FRAMESPEC...]',
help=helpText)
def GetFramePlaceholder(frameFormat):
"""
Gets the frame placeholder in a frame format string.
This function expects the input frameFormat string to contain exactly one
frame placeholder. The placeholder must be composed of exactly one or two
groups of one or more hashes ('#'), and if there are two, they must be
separated by a dot ('.').
If no such placeholder exists in the frame format string, None is returned.
"""
if not frameFormat:
return None
import re
PLACEHOLDER_PATTERN = r'^[^#]*(?P<placeholder>#+(\.#+)?)[^#]*$'
matches = re.search(PLACEHOLDER_PATTERN, frameFormat)
if not matches:
return None
placeholder = matches.group(1)
return placeholder
def ConvertFramePlaceholderToFloatSpec(frameFormat):
"""
Converts the frame placeholder in a frame format string to a Python
{}-style float specifier for use with string.format().
This function expects the input frameFormat string to contain exactly one
frame placeholder. The placeholder must be composed of exactly one or two
groups of one or more hashes ('#'), and if there are two, they must be
separated by a dot ('.').
The hashes after the dot indicate the floating point precision to use in
the frame numbers inserted into the frame format string. If there is only
a single group of hashes, the precision is zero and the inserted frame
numbers will be integer values.
The overall width of the frame placeholder specifies the minimum width to
use when inserting frame numbers into the frame format string. Formatted
frame numbers smaller than the minimum width will be zero-padded on the
left until they reach the minimum width.
If the input frame format string does not contain exactly one frame
placeholder, this function will return None, indicating that this frame
format string cannot be used when operating with a frame range.
"""
placeholder = GetFramePlaceholder(frameFormat)
if not placeholder:
return None
# Frame numbers are zero-padded up to the field width.
specFill = 0
# The full width of the placeholder determines the minimum field width.
specWidth = len(placeholder)
# The hashes after the dot, if any, determine the precision. If there are
# none, integer frame numbers are used.
specPrecision = 0
parts = placeholder.split('.')
if len(parts) > 1:
specPrecision = len(parts[1])
floatSpec = ('{frame:' +
'{fill}{width}.{precision}f'.format(fill=specFill,
width=specWidth, precision=specPrecision) +
'}')
return frameFormat.replace(placeholder, floatSpec)
def ValidateCmdlineArgs(argsParser, args, frameFormatArgName=None):
"""
Validates the frame-related arguments in args parsed by argsParser.
This populates 'frames' with the appropriate iterable based on the
command-line arguments given, so it should be called after parse_args() is
called on argsParser.
When working with frame ranges, particularly when writing out images for
each frame, it is common to also have command-line arguments such as an
output image path for specifying where those images should be written. The
value given to this argument should include a frame placeholder so that it
can have the appropriate time code inserted. If the application has such an
argument, its name can be specified using frameFormatArgName. That arg will
be checked to ensure that it has a frame placeholder and it will be given
a value with that placeholder replaced with a Python format specifier so
that the value is ready to use with the str.format(frame=<timeCode>)
method. If a frame range is not provided as an argument, then it is an
error to include a frame placeholder in the frame format string.
"""
from pxr import Usd
framePlaceholder = None
frameFormat = None
if frameFormatArgName is not None:
frameFormat = getattr(args, frameFormatArgName)
framePlaceholder = GetFramePlaceholder(frameFormat)
frameFormat = ConvertFramePlaceholderToFloatSpec(frameFormat)
if args.frames:
args.frames = FrameSpecIterator(args.frames)
if frameFormatArgName is not None:
if not frameFormat:
argsParser.error('%s must contain exactly one frame number '
'placeholder of the form "###"" or "###.###". Note that '
'the number of hash marks is variable in each group.' %
frameFormatArgName)
placeholderPrecision = _GetFloatStringPrecision(framePlaceholder)
if placeholderPrecision < args.frames.minFloatPrecision:
argsParser.error('The given FrameSpecs require a minimum '
'floating point precision of %d, but the frame '
'placeholder in %s only specified a precision of %d (%s). '
'The precision of the frame placeholder must be equal to '
'or greater than %d.' % (args.frames.minFloatPrecision,
frameFormatArgName, placeholderPrecision,
framePlaceholder,args.frames.minFloatPrecision))
setattr(args, frameFormatArgName, frameFormat)
else:
if frameFormat:
argsParser.error('%s cannot contain a frame number placeholder '
'when not operating on a frame range.' % frameFormatArgName)
if args.defaultTime:
args.frames = [Usd.TimeCode.Default()]
else:
args.frames = [Usd.TimeCode.EarliestTime()]
return args
| 11,231 | Python | 40.6 | 80 | 0.685691 |
USwampertor/OmniverseJS/ov/python/pxr/UsdAppUtils/rendererArgs.py | #
# Copyright 2019 Pixar
#
# Licensed under the Apache License, Version 2.0 (the "Apache License")
# with the following modification; you may not use this file except in
# compliance with the Apache License and the following modification to it:
# Section 6. Trademarks. is deleted and replaced with:
#
# 6. Trademarks. This License does not grant permission to use the trade
# names, trademarks, service marks, or product names of the Licensor
# and its affiliates, except as required to comply with Section 4(c) of
# the License and to reproduce the content of the NOTICE file.
#
# You may obtain a copy of the Apache License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the Apache License with the above modification is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the Apache License for the specific
# language governing permissions and limitations under the Apache License.
#
class RendererPlugins(object):
"""
An enum-like container of the available Hydra renderer plugins.
"""
class _RendererPlugin(object):
"""
Class which represents a Hydra renderer plugin. Each one has a plugin
identifier and a display name.
"""
def __init__(self, pluginId, displayName):
self._pluginId = pluginId
self._displayName = displayName
def __repr__(self):
return self.displayName
@property
def id(self):
return self._pluginId
@property
def displayName(self):
return self._displayName
@classmethod
def allPlugins(cls):
"""
Get a tuple of all available renderer plugins.
"""
if not hasattr(cls, '_allPlugins'):
from pxr import UsdImagingGL
cls._allPlugins = tuple(cls._RendererPlugin(pluginId,
UsdImagingGL.Engine.GetRendererDisplayName(pluginId))
for pluginId in UsdImagingGL.Engine.GetRendererPlugins())
return cls._allPlugins
@classmethod
def fromId(cls, pluginId):
"""
Get a renderer plugin from its identifier.
"""
matches = [plugin for plugin in cls.allPlugins() if plugin.id == pluginId]
if len(matches) == 0:
raise ValueError("No renderer plugin with id '{}'".format(pluginId))
return matches[0]
@classmethod
def fromDisplayName(cls, displayName):
"""
Get a renderer plugin from its display name.
"""
matches = [plugin for plugin in cls.allPlugins() if plugin.displayName == displayName]
if len(matches) == 0:
raise ValueError("No renderer plugin with display name '{}'".format(displayName))
return matches[0]
def AddCmdlineArgs(argsParser, altHelpText=''):
"""
Adds Hydra renderer-related command line arguments to argsParser.
The resulting 'rendererPlugin' argument will be a _RendererPlugin instance
representing one of the available Hydra renderer plugins.
"""
from pxr import UsdImagingGL
helpText = altHelpText
if not helpText:
helpText = (
'Hydra renderer plugin to use when generating images')
argsParser.add_argument('--renderer', '-r', action='store',
type=RendererPlugins.fromDisplayName,
dest='rendererPlugin',
choices=[p for p in RendererPlugins.allPlugins()],
help=helpText)
| 3,564 | Python | 33.61165 | 94 | 0.660494 |
USwampertor/OmniverseJS/ov/python/pxr/UsdDraco/__init__.py | #
# Copyright 2019 Pixar
#
# Licensed under the Apache License, Version 2.0 (the "Apache License")
# with the following modification; you may not use this file except in
# compliance with the Apache License and the following modification to it:
# Section 6. Trademarks. is deleted and replaced with:
#
# 6. Trademarks. This License does not grant permission to use the trade
# names, trademarks, service marks, or product names of the Licensor
# and its affiliates, except as required to comply with Section 4(c) of
# the License and to reproduce the content of the NOTICE file.
#
# You may obtain a copy of the Apache License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the Apache License with the above modification is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the Apache License for the specific
# language governing permissions and limitations under the Apache License.
#
from . import _usdDraco
from pxr import Tf
Tf.PrepareModule(_usdDraco, locals())
del Tf
try:
import __DOC
__DOC.Execute(locals())
del __DOC
except Exception:
try:
import __tmpDoc
__tmpDoc.Execute(locals())
del __tmpDoc
except:
pass
| 1,345 | Python | 31.829268 | 74 | 0.727881 |
USwampertor/OmniverseJS/ov/python/pxr/UsdAbc/__init__.py | #
# Copyright 2016 Pixar
#
# Licensed under the Apache License, Version 2.0 (the "Apache License")
# with the following modification; you may not use this file except in
# compliance with the Apache License and the following modification to it:
# Section 6. Trademarks. is deleted and replaced with:
#
# 6. Trademarks. This License does not grant permission to use the trade
# names, trademarks, service marks, or product names of the Licensor
# and its affiliates, except as required to comply with Section 4(c) of
# the License and to reproduce the content of the NOTICE file.
#
# You may obtain a copy of the Apache License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the Apache License with the above modification is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the Apache License for the specific
# language governing permissions and limitations under the Apache License.
#
from . import _usdAbc
from pxr import Tf
Tf.PrepareModule(_usdAbc, locals())
del Tf
try:
from . import __DOC
__DOC.Execute(locals())
del __DOC
except Exception:
pass
| 1,242 | Python | 34.514285 | 74 | 0.748792 |
USwampertor/OmniverseJS/ov/python/pxr/UsdImagingGL/__init__.py | #
# Copyright 2016 Pixar
#
# Licensed under the Apache License, Version 2.0 (the "Apache License")
# with the following modification; you may not use this file except in
# compliance with the Apache License and the following modification to it:
# Section 6. Trademarks. is deleted and replaced with:
#
# 6. Trademarks. This License does not grant permission to use the trade
# names, trademarks, service marks, or product names of the Licensor
# and its affiliates, except as required to comply with Section 4(c) of
# the License and to reproduce the content of the NOTICE file.
#
# You may obtain a copy of the Apache License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the Apache License with the above modification is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the Apache License for the specific
# language governing permissions and limitations under the Apache License.
#
from . import _usdImagingGL
from pxr import Tf
Tf.PrepareModule(_usdImagingGL, locals())
del _usdImagingGL, Tf
try:
from . import __DOC
__DOC.Execute(locals())
del __DOC
except Exception:
pass
| 1,270 | Python | 34.305555 | 74 | 0.751181 |
USwampertor/OmniverseJS/ov/usd/usd/resources/codegenTemplates/api.h | //
// Copyright 2017 Pixar
//
// Licensed under the Apache License, Version 2.0 (the "Apache License")
// with the following modification; you may not use this file except in
// compliance with the Apache License and the following modification to it:
// Section 6. Trademarks. is deleted and replaced with:
//
// 6. Trademarks. This License does not grant permission to use the trade
// names, trademarks, service marks, or product names of the Licensor
// and its affiliates, except as required to comply with Section 4(c) of
// the License and to reproduce the content of the NOTICE file.
//
// You may obtain a copy of the Apache License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the Apache License with the above modification is
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the Apache License for the specific
// language governing permissions and limitations under the Apache License.
//
#ifndef {{ Upper(libraryName) }}_API_H
#define {{ Upper(libraryName) }}_API_H
#include "pxr/base/arch/export.h"
#if defined(PXR_STATIC)
# define {{ Upper(libraryName) }}_API
# define {{ Upper(libraryName) }}_API_TEMPLATE_CLASS(...)
# define {{ Upper(libraryName) }}_API_TEMPLATE_STRUCT(...)
# define {{ Upper(libraryName) }}_LOCAL
#else
# if defined({{ Upper(libraryName) }}_EXPORTS)
# define {{ Upper(libraryName) }}_API ARCH_EXPORT
# define {{ Upper(libraryName) }}_API_TEMPLATE_CLASS(...) ARCH_EXPORT_TEMPLATE(class, __VA_ARGS__)
# define {{ Upper(libraryName) }}_API_TEMPLATE_STRUCT(...) ARCH_EXPORT_TEMPLATE(struct, __VA_ARGS__)
# else
# define {{ Upper(libraryName) }}_API ARCH_IMPORT
# define {{ Upper(libraryName) }}_API_TEMPLATE_CLASS(...) ARCH_IMPORT_TEMPLATE(class, __VA_ARGS__)
# define {{ Upper(libraryName) }}_API_TEMPLATE_STRUCT(...) ARCH_IMPORT_TEMPLATE(struct, __VA_ARGS__)
# endif
# define {{ Upper(libraryName) }}_LOCAL ARCH_HIDDEN
#endif
#endif
| 2,102 | C | 42.812499 | 106 | 0.698382 |
USwampertor/OmniverseJS/ov/usd/usd/resources/codegenTemplates/schemaClass.cpp | //
// Copyright 2016 Pixar
//
// Licensed under the Apache License, Version 2.0 (the "Apache License")
// with the following modification; you may not use this file except in
// compliance with the Apache License and the following modification to it:
// Section 6. Trademarks. is deleted and replaced with:
//
// 6. Trademarks. This License does not grant permission to use the trade
// names, trademarks, service marks, or product names of the Licensor
// and its affiliates, except as required to comply with Section 4(c) of
// the License and to reproduce the content of the NOTICE file.
//
// You may obtain a copy of the Apache License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the Apache License with the above modification is
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the Apache License for the specific
// language governing permissions and limitations under the Apache License.
//
#include "{{ libraryPath }}/{{ cls.GetHeaderFile() }}"
#include "pxr/usd/usd/schemaRegistry.h"
#include "pxr/usd/usd/typed.h"
{% if cls.isApi %}
#include "pxr/usd/usd/tokens.h"
{% endif %}
#include "pxr/usd/sdf/types.h"
#include "pxr/usd/sdf/assetPath.h"
{% if useExportAPI %}
{{ namespaceOpen }}
{% endif %}
// Register the schema with the TfType system.
TF_REGISTRY_FUNCTION(TfType)
{
TfType::Define<{{ cls.cppClassName }},
TfType::Bases< {{ cls.parentCppClassName }} > >();
{% if cls.isConcrete %}
// Register the usd prim typename as an alias under UsdSchemaBase. This
// enables one to call
// TfType::Find<UsdSchemaBase>().FindDerivedByName("{{ cls.usdPrimTypeName }}")
// to find TfType<{{ cls.cppClassName }}>, which is how IsA queries are
// answered.
TfType::AddAlias<UsdSchemaBase, {{ cls.cppClassName }}>("{{ cls.usdPrimTypeName }}");
{% endif %}
}
{% if cls.isApi %}
TF_DEFINE_PRIVATE_TOKENS(
_schemaTokens,
({{ cls.primName }})
{% if cls.isMultipleApply and cls.propertyNamespacePrefix %}
({{ cls.propertyNamespacePrefix }})
{% endif %}
);
{% endif %}
/* virtual */
{{ cls.cppClassName }}::~{{ cls.cppClassName }}()
{
}
{% if not cls.isAPISchemaBase %}
/* static */
{{ cls.cppClassName }}
{{ cls.cppClassName }}::Get(const UsdStagePtr &stage, const SdfPath &path)
{
if (!stage) {
TF_CODING_ERROR("Invalid stage");
return {{ cls.cppClassName }}();
}
{% if cls.isMultipleApply and cls.propertyNamespacePrefix %}
TfToken name;
if (!Is{{ cls.usdPrimTypeName }}Path(path, &name)) {
TF_CODING_ERROR("Invalid {{ cls.propertyNamespacePrefix }} path <%s>.", path.GetText());
return {{ cls.cppClassName }}();
}
return {{ cls.cppClassName }}(stage->GetPrimAtPath(path.GetPrimPath()), name);
{% else %}
return {{ cls.cppClassName }}(stage->GetPrimAtPath(path));
{% endif %}
}
{% if cls.isMultipleApply %}
{{ cls.cppClassName }}
{{ cls.cppClassName }}::Get(const UsdPrim &prim, const TfToken &name)
{
return {{ cls.cppClassName }}(prim, name);
}
{% endif %}
{% endif %}
{% if cls.isConcrete %}
/* static */
{{ cls.cppClassName }}
{{ cls.cppClassName }}::Define(
const UsdStagePtr &stage, const SdfPath &path)
{
static TfToken usdPrimTypeName("{{ cls.usdPrimTypeName }}");
if (!stage) {
TF_CODING_ERROR("Invalid stage");
return {{ cls.cppClassName }}();
}
return {{ cls.cppClassName }}(
stage->DefinePrim(path, usdPrimTypeName));
}
{% endif %}
{% if cls.isMultipleApply and cls.propertyNamespacePrefix %}
/* static */
bool
{{ cls.cppClassName }}::IsSchemaPropertyBaseName(const TfToken &baseName)
{
static TfTokenVector attrsAndRels = {
{% for attrName in cls.attrOrder %}
{% set attr = cls.attrs[attrName] %}
{{ tokensPrefix }}Tokens->{{ attr.name }},
{% endfor %}
{% for relName in cls.relOrder %}
{% set rel = cls.rels[relName] %}
{{ tokensPrefix }}Tokens->{{ rel.name }},
{% endfor %}
};
return find(attrsAndRels.begin(), attrsAndRels.end(), baseName)
!= attrsAndRels.end();
}
/* static */
bool
{{ cls.cppClassName }}::Is{{ cls.usdPrimTypeName }}Path(
const SdfPath &path, TfToken *name)
{
if (!path.IsPropertyPath()) {
return false;
}
std::string propertyName = path.GetName();
TfTokenVector tokens = SdfPath::TokenizeIdentifierAsTokens(propertyName);
// The baseName of the {{ cls.usdPrimTypename }} path can't be one of the
// schema properties. We should validate this in the creation (or apply)
// API.
TfToken baseName = *tokens.rbegin();
if (IsSchemaPropertyBaseName(baseName)) {
return false;
}
if (tokens.size() >= 2
&& tokens[0] == _schemaTokens->{{ cls.propertyNamespacePrefix }}) {
*name = TfToken(propertyName.substr(
_schemaTokens->{{ cls.propertyNamespacePrefix }}.GetString().size() + 1));
return true;
}
return false;
}
{% endif %}
/* virtual */
UsdSchemaType {{ cls.cppClassName }}::_GetSchemaType() const {
return {{ cls.cppClassName }}::schemaType;
}
{% if cls.isAppliedAPISchema %}
/* static */
{{ cls.cppClassName }}
{% if cls.isPrivateApply %}
{% if not cls.isMultipleApply %}
{{ cls.cppClassName }}::_Apply(const UsdPrim &prim)
{% else %}
{{ cls.cppClassName }}::_Apply(const UsdPrim &prim, const TfToken &name)
{% endif %}
{% else %}
{% if not cls.isMultipleApply %}
{{ cls.cppClassName }}::Apply(const UsdPrim &prim)
{% else %}
{{ cls.cppClassName }}::Apply(const UsdPrim &prim, const TfToken &name)
{% endif %}
{% endif %}
{
{% if cls.isMultipleApply %}
if (prim.ApplyAPI<{{ cls.cppClassName }}>(name)) {
return {{ cls.cppClassName }}(prim, name);
}
{% else %}
if (prim.ApplyAPI<{{ cls.cppClassName }}>()) {
return {{ cls.cppClassName }}(prim);
}
{% endif %}
return {{ cls.cppClassName }}();
}
{% endif %}
/* static */
const TfType &
{{ cls.cppClassName }}::_GetStaticTfType()
{
static TfType tfType = TfType::Find<{{ cls.cppClassName }}>();
return tfType;
}
/* static */
bool
{{ cls.cppClassName }}::_IsTypedSchema()
{
static bool isTyped = _GetStaticTfType().IsA<UsdTyped>();
return isTyped;
}
/* virtual */
const TfType &
{{ cls.cppClassName }}::_GetTfType() const
{
return _GetStaticTfType();
}
{% if cls.isMultipleApply and cls.propertyNamespacePrefix %}
/// Returns the property name prefixed with the correct namespace prefix, which
/// is composed of the the API's propertyNamespacePrefix metadata and the
/// instance name of the API.
static inline
TfToken
_GetNamespacedPropertyName(const TfToken instanceName, const TfToken propName)
{
TfTokenVector identifiers =
{_schemaTokens->{{ cls.propertyNamespacePrefix }}, instanceName, propName};
return TfToken(SdfPath::JoinIdentifier(identifiers));
}
{% endif %}
{% for attrName in cls.attrOrder %}
{% set attr = cls.attrs[attrName] %}
{# Only emit Create/Get API and doxygen if apiName is not empty string. #}
{% if attr.apiName != '' %}
{% if attr.apiGet != "custom" %}
UsdAttribute
{{ cls.cppClassName }}::Get{{ Proper(attr.apiName) }}Attr() const
{
{% if cls.isMultipleApply and cls.propertyNamespacePrefix %}
return GetPrim().GetAttribute(
_GetNamespacedPropertyName(
GetName(),
{{ tokensPrefix }}Tokens->{{ attr.name }}));
{% else %}
return GetPrim().GetAttribute({{ tokensPrefix }}Tokens->{{ attr.name }});
{% endif %}
}
{% endif %}
UsdAttribute
{{ cls.cppClassName }}::Create{{ Proper(attr.apiName) }}Attr(VtValue const &defaultValue, bool writeSparsely) const
{
{% if cls.isMultipleApply and cls.propertyNamespacePrefix %}
return UsdSchemaBase::_CreateAttr(
_GetNamespacedPropertyName(
GetName(),
{{ tokensPrefix }}Tokens->{{ attr.name }}),
{% else %}
return UsdSchemaBase::_CreateAttr({{ tokensPrefix }}Tokens->{{ attr.name }},
{% endif %}
{{ attr.usdType }},
/* custom = */ {{ "true" if attr.custom else "false" }},
{{ attr.variability }},
defaultValue,
writeSparsely);
}
{% endif %}
{% endfor %}
{% for relName in cls.relOrder %}
{% set rel = cls.rels[relName] %}
{# Only emit Create/Get API and doxygen if apiName is not empty string. #}
{% if rel.apiName != '' %}
{% if rel.apiGet != "custom" %}
UsdRelationship
{{ cls.cppClassName }}::Get{{ Proper(rel.apiName) }}Rel() const
{
{% if cls.isMultipleApply and cls.propertyNamespacePrefix %}
return GetPrim().GetRelationship(
_GetNamespacedPropertyName(
GetName(),
{{ tokensPrefix }}Tokens->{{ rel.name }}));
{% else %}
return GetPrim().GetRelationship({{ tokensPrefix }}Tokens->{{ rel.name }});
{% endif %}
}
{% endif %}
UsdRelationship
{{ cls.cppClassName }}::Create{{ Proper(rel.apiName) }}Rel() const
{
{% if cls.isMultipleApply and cls.propertyNamespacePrefix %}
return GetPrim().CreateRelationship(
_GetNamespacedPropertyName(
GetName(),
{{ tokensPrefix }}Tokens->{{ rel.name }}),
{% else %}
return GetPrim().CreateRelationship({{ tokensPrefix }}Tokens->{{rel.name}},
{% endif %}
/* custom = */ {{ "true" if rel.custom else "false" }});
}
{% endif %}
{% endfor %}
{% if cls.attrOrder|length > 0 %}
namespace {
static inline TfTokenVector
{% if cls.isMultipleApply %}
_ConcatenateAttributeNames(
const TfToken instanceName,
const TfTokenVector& left,
const TfTokenVector& right)
{% else %}
_ConcatenateAttributeNames(const TfTokenVector& left,const TfTokenVector& right)
{% endif %}
{
TfTokenVector result;
result.reserve(left.size() + right.size());
result.insert(result.end(), left.begin(), left.end());
{% if cls.isMultipleApply %}
for (const TfToken attrName : right) {
result.push_back(
_GetNamespacedPropertyName(instanceName, attrName));
}
{% endif %}
result.insert(result.end(), right.begin(), right.end());
return result;
}
}
{% endif %}
/*static*/
const TfTokenVector&
{% if cls.isMultipleApply %}
{{ cls.cppClassName }}::GetSchemaAttributeNames(
bool includeInherited, const TfToken instanceName)
{% else %}
{{ cls.cppClassName }}::GetSchemaAttributeNames(bool includeInherited)
{% endif %}
{
{% if cls.attrOrder|length > 0 %}
static TfTokenVector localNames = {
{% for attrName in cls.attrOrder %}
{% set attr = cls.attrs[attrName] %}
{{ tokensPrefix }}Tokens->{{ attr.name }},
{% endfor %}
};
{% if cls.isMultipleApply %}
static TfTokenVector allNames =
_ConcatenateAttributeNames(
instanceName,
{# The schema generator has already validated whether our parent is #}
{# a multiple apply schema or UsdSchemaBaseAPI, choose the correct function #}
{# depending on the situation #}
{% if cls.parentCppClassName == "UsdAPISchemaBase" %}
{{ cls.parentCppClassName }}::GetSchemaAttributeNames(true),
{% else %}
{{ cls.parentCppClassName }}::GetSchemaAttributeNames(true, instanceName),
{% endif %}
localNames);
{% else %}
static TfTokenVector allNames =
_ConcatenateAttributeNames(
{{ cls.parentCppClassName }}::GetSchemaAttributeNames(true),
localNames);
{% endif %}
{% else %}
static TfTokenVector localNames;
static TfTokenVector allNames =
{{ cls.parentCppClassName }}::GetSchemaAttributeNames(true);
{% endif %}
if (includeInherited)
return allNames;
else
return localNames;
}
{% if useExportAPI %}
{{ namespaceClose }}
{% endif %}
// ===================================================================== //
// Feel free to add custom code below this line. It will be preserved by
// the code generator.
{% if useExportAPI %}
//
// Just remember to wrap code in the appropriate delimiters:
// '{{ namespaceOpen }}', '{{ namespaceClose }}'.
{% endif %}
// ===================================================================== //
// --(BEGIN CUSTOM CODE)--
| 12,227 | C++ | 29.41791 | 115 | 0.63278 |
USwampertor/OmniverseJS/ov/usd/usd/resources/codegenTemplates/tokens.h | //
// Copyright 2016 Pixar
//
// Licensed under the Apache License, Version 2.0 (the "Apache License")
// with the following modification; you may not use this file except in
// compliance with the Apache License and the following modification to it:
// Section 6. Trademarks. is deleted and replaced with:
//
// 6. Trademarks. This License does not grant permission to use the trade
// names, trademarks, service marks, or product names of the Licensor
// and its affiliates, except as required to comply with Section 4(c) of
// the License and to reproduce the content of the NOTICE file.
//
// You may obtain a copy of the Apache License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the Apache License with the above modification is
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the Apache License for the specific
// language governing permissions and limitations under the Apache License.
//
#ifndef {{ Upper(tokensPrefix) }}_TOKENS_H
#define {{ Upper(tokensPrefix) }}_TOKENS_H
/// \file {{ libraryName }}/tokens.h
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
//
// This is an automatically generated file (by usdGenSchema.py).
// Do not hand-edit!
//
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
{% if useExportAPI %}
#include "pxr/pxr.h"
#include "{{ libraryPath }}/api.h"
{% endif %}
#include "pxr/base/tf/staticData.h"
#include "pxr/base/tf/token.h"
#include <vector>
{% if useExportAPI %}
{{ namespaceOpen }}
{% endif %}
/// \class {{ tokensPrefix }}TokensType
///
/// \link {{ tokensPrefix }}Tokens \endlink provides static, efficient
/// \link TfToken TfTokens\endlink for use in all public USD API.
///
/// These tokens are auto-generated from the module's schema, representing
/// property names, for when you need to fetch an attribute or relationship
/// directly by name, e.g. UsdPrim::GetAttribute(), in the most efficient
/// manner, and allow the compiler to verify that you spelled the name
/// correctly.
///
/// {{ tokensPrefix }}Tokens also contains all of the \em allowedTokens values
/// declared for schema builtin attributes of 'token' scene description type.
{% if tokens %}
/// Use {{ tokensPrefix }}Tokens like so:
///
/// \code
/// gprim.GetMyTokenValuedAttr().Set({{ tokensPrefix }}Tokens->{{ tokens[0].id }});
/// \endcode
{% endif %}
struct {{ tokensPrefix }}TokensType {
{% if useExportAPI %}{{ Upper(libraryName) }}_API {% endif %}{{ tokensPrefix }}TokensType();
{% for token in tokens %}
/// \brief "{{ token.value }}"
///
/// {{ token.desc }}
const TfToken {{ token.id }};
{% endfor %}
/// A vector of all of the tokens listed above.
const std::vector<TfToken> allTokens;
};
/// \var {{ tokensPrefix }}Tokens
///
/// A global variable with static, efficient \link TfToken TfTokens\endlink
/// for use in all public USD API. \sa {{ tokensPrefix }}TokensType
extern{% if useExportAPI %} {{ Upper(libraryName) }}_API{% endif %} TfStaticData<{{ tokensPrefix }}TokensType> {{ tokensPrefix }}Tokens;
{% if useExportAPI %}
{{ namespaceClose }}
{% endif %}
#endif
| 3,255 | C | 34.391304 | 136 | 0.701382 |
USwampertor/OmniverseJS/ov/usd/usd/resources/codegenTemplates/wrapSchemaClass.cpp | //
// Copyright 2016 Pixar
//
// Licensed under the Apache License, Version 2.0 (the "Apache License")
// with the following modification; you may not use this file except in
// compliance with the Apache License and the following modification to it:
// Section 6. Trademarks. is deleted and replaced with:
//
// 6. Trademarks. This License does not grant permission to use the trade
// names, trademarks, service marks, or product names of the Licensor
// and its affiliates, except as required to comply with Section 4(c) of
// the License and to reproduce the content of the NOTICE file.
//
// You may obtain a copy of the Apache License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the Apache License with the above modification is
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the Apache License for the specific
// language governing permissions and limitations under the Apache License.
//
#include "{{ libraryPath }}/{{ cls.GetHeaderFile() }}"
#include "pxr/usd/usd/schemaBase.h"
#include "pxr/usd/sdf/primSpec.h"
#include "pxr/usd/usd/pyConversions.h"
#include "pxr/base/tf/pyContainerConversions.h"
#include "pxr/base/tf/pyResultConversions.h"
#include "pxr/base/tf/pyUtils.h"
#include "pxr/base/tf/wrapTypeHelpers.h"
#include <boost/python.hpp>
#include <string>
using namespace boost::python;
{% if useExportAPI %}
{{ namespaceUsing }}
namespace {
{% endif %}
#define WRAP_CUSTOM \
template <class Cls> static void _CustomWrapCode(Cls &_class)
// fwd decl.
WRAP_CUSTOM;
{% for attrName in cls.attrOrder -%}
{% set attr = cls.attrs[attrName] %}
{# Only emit Create/Get API if apiName is not empty string. #}
{% if attr.apiName != '' %}
static UsdAttribute
_Create{{ Proper(attr.apiName) }}Attr({{ cls.cppClassName }} &self,
object defaultVal, bool writeSparsely) {
return self.Create{{ Proper(attr.apiName) }}Attr(
UsdPythonToSdfType(defaultVal, {{ attr.usdType }}), writeSparsely);
}
{% endif %}
{% endfor %}
{% if cls.isMultipleApply and cls.propertyNamespacePrefix %}
static bool _WrapIs{{ cls.usdPrimTypeName }}Path(const SdfPath &path) {
TfToken collectionName;
return {{ cls.cppClassName }}::Is{{ cls.usdPrimTypeName }}Path(
path, &collectionName);
}
{% endif %}
{% if not cls.isAPISchemaBase %}
static std::string
_Repr(const {{ cls.cppClassName }} &self)
{
std::string primRepr = TfPyRepr(self.GetPrim());
{% if cls.isMultipleApply %}
std::string instanceName = self.GetName();
return TfStringPrintf(
"{{ libraryName[0]|upper }}{{ libraryName[1:] }}.{{ cls.className }}(%s, '%s')",
primRepr.c_str(), instanceName.c_str());
{% else %}
return TfStringPrintf(
"{{ libraryName[0]|upper }}{{ libraryName[1:] }}.{{ cls.className }}(%s)",
primRepr.c_str());
{% endif %}
}
{% endif %}
{% if useExportAPI %}
} // anonymous namespace
{% endif %}
void wrap{{ cls.cppClassName }}()
{
typedef {{ cls.cppClassName }} This;
{% if cls.isAPISchemaBase %}
class_< This , bases<{{ cls.parentCppClassName }}>, boost::noncopyable> cls ("APISchemaBase", "", no_init);
{% else %}
class_<This, bases<{{ cls.parentCppClassName }}> >
cls("{{ cls.className }}");
{% endif %}
cls
{% if not cls.isAPISchemaBase %}
{% if cls.isMultipleApply %}
.def(init<UsdPrim, TfToken>())
.def(init<UsdSchemaBase const&, TfToken>())
{% else %}
.def(init<UsdPrim>(arg("prim")))
.def(init<UsdSchemaBase const&>(arg("schemaObj")))
{% endif %}
{% endif %}
.def(TfTypePythonClass())
{% if not cls.isAPISchemaBase %}
{% if cls.isMultipleApply %}
.def("Get",
({{ cls.cppClassName }}(*)(const UsdStagePtr &stage,
const SdfPath &path))
&This::Get,
(arg("stage"), arg("path")))
.def("Get",
({{ cls.cppClassName }}(*)(const UsdPrim &prim,
const TfToken &name))
&This::Get,
(arg("prim"), arg("name")))
{% else %}
.def("Get", &This::Get, (arg("stage"), arg("path")))
{% endif %}
.staticmethod("Get")
{% endif %}
{% if cls.isConcrete %}
.def("Define", &This::Define, (arg("stage"), arg("path")))
.staticmethod("Define")
{% endif %}
{% if cls.isAppliedAPISchema and not cls.isMultipleApply and not cls.isPrivateApply %}
.def("Apply", &This::Apply, (arg("prim")))
.staticmethod("Apply")
{% endif %}
{% if cls.isAppliedAPISchema and cls.isMultipleApply and not cls.isPrivateApply %}
.def("Apply", &This::Apply, (arg("prim"), arg("name")))
.staticmethod("Apply")
{% endif %}
.def("GetSchemaAttributeNames",
&This::GetSchemaAttributeNames,
arg("includeInherited")=true,
{% if cls.isMultipleApply %}
arg("instanceName")=TfToken(),
{% endif %}
return_value_policy<TfPySequenceToList>())
.staticmethod("GetSchemaAttributeNames")
.def("_GetStaticTfType", (TfType const &(*)()) TfType::Find<This>,
return_value_policy<return_by_value>())
.staticmethod("_GetStaticTfType")
.def(!self)
{% for attrName in cls.attrOrder -%}
{% set attr = cls.attrs[attrName] %}
{# Only emit Create/Get API if apiName is not empty string. #}
{% if attr.apiName != '' %}
.def("Get{{ Proper(attr.apiName) }}Attr",
&This::Get{{ Proper(attr.apiName) }}Attr)
.def("Create{{ Proper(attr.apiName) }}Attr",
&_Create{{ Proper(attr.apiName) }}Attr,
(arg("defaultValue")=object(),
arg("writeSparsely")=false))
{% endif %}
{% endfor %}
{% for relName in cls.relOrder -%}
{# Only emit Create/Get API and doxygen if apiName is not empty string. #}
{% set rel = cls.rels[relName] %}
{% if rel.apiName != '' %}
.def("Get{{ Proper(rel.apiName) }}Rel",
&This::Get{{ Proper(rel.apiName) }}Rel)
.def("Create{{ Proper(rel.apiName) }}Rel",
&This::Create{{ Proper(rel.apiName) }}Rel)
{% endif %}
{% endfor %}
{% if cls.isMultipleApply and cls.propertyNamespacePrefix %}
.def("Is{{ cls.usdPrimTypeName }}Path", _WrapIs{{ cls.usdPrimTypeName }}Path)
.staticmethod("Is{{ cls.usdPrimTypeName }}Path")
{% endif %}
{% if not cls.isAPISchemaBase %}
.def("__repr__", ::_Repr)
{% endif %}
;
_CustomWrapCode(cls);
}
// ===================================================================== //
// Feel free to add custom code below this line, it will be preserved by
// the code generator. The entry point for your custom code should look
// minimally like the following:
//
// WRAP_CUSTOM {
// _class
// .def("MyCustomMethod", ...)
// ;
// }
//
// Of course any other ancillary or support code may be provided.
{% if useExportAPI %}
//
// Just remember to wrap code in the appropriate delimiters:
// 'namespace {', '}'.
//
{% endif %}
// ===================================================================== //
// --(BEGIN CUSTOM CODE)--
| 7,316 | C++ | 31.376106 | 111 | 0.597184 |
USwampertor/OmniverseJS/ov/usd/usd/resources/codegenTemplates/wrapTokens.cpp | //
// Copyright 2016 Pixar
//
// Licensed under the Apache License, Version 2.0 (the "Apache License")
// with the following modification; you may not use this file except in
// compliance with the Apache License and the following modification to it:
// Section 6. Trademarks. is deleted and replaced with:
//
// 6. Trademarks. This License does not grant permission to use the trade
// names, trademarks, service marks, or product names of the Licensor
// and its affiliates, except as required to comply with Section 4(c) of
// the License and to reproduce the content of the NOTICE file.
//
// You may obtain a copy of the Apache License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the Apache License with the above modification is
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the Apache License for the specific
// language governing permissions and limitations under the Apache License.
//
// GENERATED FILE. DO NOT EDIT.
#include <boost/python/class.hpp>
#include "{{ libraryPath }}/tokens.h"
{% if useExportAPI %}
{{ namespaceUsing }}
{% endif %}
namespace {
// Helper to return a static token as a string. We wrap tokens as Python
// strings and for some reason simply wrapping the token using def_readonly
// bypasses to-Python conversion, leading to the error that there's no
// Python type for the C++ TfToken type. So we wrap this functor instead.
class _WrapStaticToken {
public:
_WrapStaticToken(const TfToken* token) : _token(token) { }
std::string operator()() const
{
return _token->GetString();
}
private:
const TfToken* _token;
};
template <typename T>
void
_AddToken(T& cls, const char* name, const TfToken& token)
{
cls.add_static_property(name,
boost::python::make_function(
_WrapStaticToken(&token),
boost::python::return_value_policy<
boost::python::return_by_value>(),
boost::mpl::vector1<std::string>()));
}
} // anonymous
void wrap{{ tokensPrefix }}Tokens()
{
boost::python::class_<{{ tokensPrefix }}TokensType, boost::noncopyable>
cls("Tokens", boost::python::no_init);
{% for token in tokens %}
_AddToken(cls, "{{ token.id }}", {{ tokensPrefix }}Tokens->{{ token.id }});
{% endfor %}
}
| 2,521 | C++ | 33.547945 | 79 | 0.662436 |
USwampertor/OmniverseJS/ov/usd/usd/resources/codegenTemplates/schemaClass.h | //
// Copyright 2016 Pixar
//
// Licensed under the Apache License, Version 2.0 (the "Apache License")
// with the following modification; you may not use this file except in
// compliance with the Apache License and the following modification to it:
// Section 6. Trademarks. is deleted and replaced with:
//
// 6. Trademarks. This License does not grant permission to use the trade
// names, trademarks, service marks, or product names of the Licensor
// and its affiliates, except as required to comply with Section 4(c) of
// the License and to reproduce the content of the NOTICE file.
//
// You may obtain a copy of the Apache License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the Apache License with the above modification is
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the Apache License for the specific
// language governing permissions and limitations under the Apache License.
//
#ifndef {{ Upper(libraryName) }}_GENERATED_{{ Upper(cls.className) }}_H
#define {{ Upper(libraryName) }}_GENERATED_{{ Upper(cls.className) }}_H
/// \file {{ libraryName }}/{{ cls.GetHeaderFile() }}
{% if useExportAPI %}
#include "pxr/pxr.h"
#include "{{ libraryPath }}/api.h"
{% endif %}
#include "{{ cls.parentLibPath }}/{{ cls.GetParentHeaderFile() }}"
#include "pxr/usd/usd/prim.h"
#include "pxr/usd/usd/stage.h"
{% if cls.tokens -%}
#include "{{ libraryPath }}/tokens.h"
{% endif %}
{% if cls.extraIncludes -%}
{{ cls.extraIncludes }}
{% endif %}
#include "pxr/base/vt/value.h"
#include "pxr/base/gf/vec3d.h"
#include "pxr/base/gf/vec3f.h"
#include "pxr/base/gf/matrix4d.h"
#include "pxr/base/tf/token.h"
#include "pxr/base/tf/type.h"
{% if useExportAPI %}
{{ namespaceOpen }}
{% endif %}
class SdfAssetPath;
// -------------------------------------------------------------------------- //
// {{ Upper(cls.usdPrimTypeName) }}{{' ' * (74 - cls.usdPrimTypeName|count)}} //
// -------------------------------------------------------------------------- //
/// \class {{ cls.cppClassName }}
///
{% if cls.doc -%}
/// {{ cls.doc }}
{% endif %}
{% if cls.doc and hasTokenAttrs -%}
///
{%endif%}
{% if hasTokenAttrs -%}
/// For any described attribute \em Fallback \em Value or \em Allowed \em Values below
/// that are text/tokens, the actual token is published and defined in \ref {{ tokensPrefix }}Tokens.
/// So to set an attribute to the value "rightHanded", use {{ tokensPrefix }}Tokens->rightHanded
/// as the value.
{% endif %}
///
class {{ cls.cppClassName }} : public {{ cls.parentCppClassName }}
{
public:
/// Compile time constant representing what kind of schema this class is.
///
/// \sa UsdSchemaType
static const UsdSchemaType schemaType = {{cls.schemaType }};
{% if cls.isMultipleApply %}
/// Construct a {{ cls.cppClassName }} on UsdPrim \p prim with
/// name \p name . Equivalent to
/// {{ cls.cppClassName }}::Get(
/// prim.GetStage(),
/// prim.GetPath().AppendProperty(
/// "{{ cls.propertyNamespacePrefix }}:name"));
///
/// for a \em valid \p prim, but will not immediately throw an error for
/// an invalid \p prim
explicit {{ cls.cppClassName }}(
const UsdPrim& prim=UsdPrim(), const TfToken &name=TfToken())
: {{ cls.parentCppClassName }}(prim, /*instanceName*/ name)
{ }
/// Construct a {{ cls.cppClassName }} on the prim held by \p schemaObj with
/// name \p name. Should be preferred over
/// {{ cls.cppClassName }}(schemaObj.GetPrim(), name), as it preserves
/// SchemaBase state.
explicit {{ cls.cppClassName }}(
const UsdSchemaBase& schemaObj, const TfToken &name)
: {{ cls.parentCppClassName }}(schemaObj, /*instanceName*/ name)
{ }
{% else %}
/// Construct a {{ cls.cppClassName }} on UsdPrim \p prim .
/// Equivalent to {{ cls.cppClassName }}::Get(prim.GetStage(), prim.GetPath())
/// for a \em valid \p prim, but will not immediately throw an error for
/// an invalid \p prim
explicit {{ cls.cppClassName }}(const UsdPrim& prim=UsdPrim())
: {{ cls.parentCppClassName }}(prim)
{
}
/// Construct a {{ cls.cppClassName }} on the prim held by \p schemaObj .
/// Should be preferred over {{ cls.cppClassName }}(schemaObj.GetPrim()),
/// as it preserves SchemaBase state.
explicit {{ cls.cppClassName }}(const UsdSchemaBase& schemaObj)
: {{ cls.parentCppClassName }}(schemaObj)
{
}
{% endif %}
/// Destructor.
{% if useExportAPI -%}
{{ Upper(libraryName) }}_API
{% endif -%}
virtual ~{{ cls.cppClassName }}() {%- if cls.isAPISchemaBase %} = 0{% endif %};
{% if cls.isMultipleApply %}
/// Return a vector of names of all pre-declared attributes for this schema
/// class and all its ancestor classes for a given instance name. Does not
/// include attributes that may be authored by custom/extended methods of
/// the schemas involved. The names returned will have the proper namespace
/// prefix.
{% else %}
/// Return a vector of names of all pre-declared attributes for this schema
/// class and all its ancestor classes. Does not include attributes that
/// may be authored by custom/extended methods of the schemas involved.
{% endif %}
{% if useExportAPI -%}
{{ Upper(libraryName) }}_API
{% endif -%}
static const TfTokenVector &
{% if cls.isMultipleApply %}
GetSchemaAttributeNames(
bool includeInherited=true, const TfToken instanceName=TfToken());
{% else %}
GetSchemaAttributeNames(bool includeInherited=true);
{% endif %}
{% if cls.isMultipleApply %}
/// Returns the name of this multiple-apply schema instance
TfToken GetName() const {
return _GetInstanceName();
}
{% endif %}
{% if not cls.isAPISchemaBase %}
/// Return a {{ cls.cppClassName }} holding the prim adhering to this
/// schema at \p path on \p stage. If no prim exists at \p path on
/// \p stage, or if the prim at that path does not adhere to this schema,
{% if cls.isMultipleApply and cls.propertyNamespacePrefix %}
/// return an invalid schema object. \p path must be of the format
/// <path>.{{ cls.propertyNamespacePrefix }}:name .
///
/// This is shorthand for the following:
///
/// \code
/// TfToken name = SdfPath::StripNamespace(path.GetToken());
/// {{ cls.cppClassName }}(
/// stage->GetPrimAtPath(path.GetPrimPath()), name);
/// \endcode
{% else %}
/// return an invalid schema object. This is shorthand for the following:
///
/// \code
/// {{ cls.cppClassName }}(stage->GetPrimAtPath(path));
/// \endcode
{% endif %}
///
{% if useExportAPI -%}
{{ Upper(libraryName) }}_API
{% endif -%}
static {{ cls.cppClassName }}
Get(const UsdStagePtr &stage, const SdfPath &path);
{% if cls.isMultipleApply %}
/// Return a {{ cls.cppClassName }} with name \p name holding the
/// prim \p prim. Shorthand for {{ cls.cppClassName }}(prim, name);
{% if useExportAPI -%}
{{ Upper(libraryName) }}_API
{% endif -%}
static {{ cls.cppClassName }}
Get(const UsdPrim &prim, const TfToken &name);
{% endif %}
{% endif %}
{% if cls.isConcrete %}
/// Attempt to ensure a \a UsdPrim adhering to this schema at \p path
/// is defined (according to UsdPrim::IsDefined()) on this stage.
///
/// If a prim adhering to this schema at \p path is already defined on this
/// stage, return that prim. Otherwise author an \a SdfPrimSpec with
/// \a specifier == \a SdfSpecifierDef and this schema's prim type name for
/// the prim at \p path at the current EditTarget. Author \a SdfPrimSpec s
/// with \p specifier == \a SdfSpecifierDef and empty typeName at the
/// current EditTarget for any nonexistent, or existing but not \a Defined
/// ancestors.
///
/// The given \a path must be an absolute prim path that does not contain
/// any variant selections.
///
/// If it is impossible to author any of the necessary PrimSpecs, (for
/// example, in case \a path cannot map to the current UsdEditTarget's
/// namespace) issue an error and return an invalid \a UsdPrim.
///
/// Note that this method may return a defined prim whose typeName does not
/// specify this schema class, in case a stronger typeName opinion overrides
/// the opinion at the current EditTarget.
///
{% if useExportAPI -%}
{{ Upper(libraryName) }}_API
{% endif -%}
static {{ cls.cppClassName }}
Define(const UsdStagePtr &stage, const SdfPath &path);
{% endif %}
{% if cls.isMultipleApply and cls.propertyNamespacePrefix %}
/// Checks if the given name \p baseName is the base name of a property
/// of {{ cls.usdPrimTypeName }}.
{% if useExportAPI -%}
{{ Upper(libraryName) }}_API
{% endif -%}
static bool
IsSchemaPropertyBaseName(const TfToken &baseName);
/// Checks if the given path \p path is of an API schema of type
/// {{ cls.usdPrimTypeName }}. If so, it stores the instance name of
/// the schema in \p name and returns true. Otherwise, it returns false.
{% if useExportAPI -%}
{{ Upper(libraryName) }}_API
{% endif -%}
static bool
Is{{ cls.usdPrimTypeName }}Path(const SdfPath &path, TfToken *name);
{% endif %}
{% if cls.isPrivateApply %}
private:
{% endif %}
{% if cls.isAppliedAPISchema and not cls.isMultipleApply %}
/// Applies this <b>single-apply</b> API schema to the given \p prim.
/// This information is stored by adding "{{ cls.primName }}" to the
/// token-valued, listOp metadata \em apiSchemas on the prim.
///
/// \return A valid {{ cls.cppClassName }} object is returned upon success.
/// An invalid (or empty) {{ cls.cppClassName }} object is returned upon
/// failure. See \ref UsdPrim::ApplyAPI() for conditions
/// resulting in failure.
///
/// \sa UsdPrim::GetAppliedSchemas()
/// \sa UsdPrim::HasAPI()
/// \sa UsdPrim::ApplyAPI()
/// \sa UsdPrim::RemoveAPI()
///
{% if useExportAPI and not cls.isPrivateApply -%}
{{ Upper(libraryName) }}_API
{% endif -%}
static {{ cls.cppClassName }}
{% if cls.isPrivateApply %}
_Apply(const UsdPrim &prim);
{% else %}
Apply(const UsdPrim &prim);
{% endif %}
{% endif %}
{% if cls.isAppliedAPISchema and cls.isMultipleApply %}
/// Applies this <b>multiple-apply</b> API schema to the given \p prim
/// along with the given instance name, \p name.
///
/// This information is stored by adding "{{ cls.primName }}:<i>name</i>"
/// to the token-valued, listOp metadata \em apiSchemas on the prim.
/// For example, if \p name is 'instance1', the token
/// '{{ cls.primName }}:instance1' is added to 'apiSchemas'.
///
/// \return A valid {{ cls.cppClassName }} object is returned upon success.
/// An invalid (or empty) {{ cls.cppClassName }} object is returned upon
/// failure. See \ref UsdPrim::ApplyAPI() for
/// conditions resulting in failure.
///
/// \sa UsdPrim::GetAppliedSchemas()
/// \sa UsdPrim::HasAPI()
/// \sa UsdPrim::ApplyAPI()
/// \sa UsdPrim::RemoveAPI()
///
{% if useExportAPI and not cls.isPrivateApply -%}
{{ Upper(libraryName) }}_API
{% endif -%}
static {{ cls.cppClassName }}
{% if cls.isPrivateApply %}
_Apply(const UsdPrim &prim, const TfToken &name);
{% else %}
Apply(const UsdPrim &prim, const TfToken &name);
{% endif %}
{% endif %}
protected:
/// Returns the type of schema this class belongs to.
///
/// \sa UsdSchemaType
{% if useExportAPI -%}
{{ Upper(libraryName) }}_API
{% endif -%}
UsdSchemaType _GetSchemaType() const override;
private:
// needs to invoke _GetStaticTfType.
friend class UsdSchemaRegistry;
{% if useExportAPI -%}
{{ Upper(libraryName) }}_API
{% endif -%}
static const TfType &_GetStaticTfType();
static bool _IsTypedSchema();
// override SchemaBase virtuals.
{% if useExportAPI -%}
{{ Upper(libraryName) }}_API
{% endif -%}
const TfType &_GetTfType() const override;
{% for attrName in cls.attrOrder %}
{% set attr = cls.attrs[attrName]%}
{# Only emit Create/Get API and doxygen if apiName is not empty string. #}
{% if attr.apiName != '' %}
public:
// --------------------------------------------------------------------- //
// {{ Upper(attr.apiName) }}
// --------------------------------------------------------------------- //
/// {{ attr.doc }}
///
{% if attr.details %}
/// | ||
/// | -- | -- |
{% for detail in attr.details %}
/// | {{ detail[0] }} | {{ detail[1] }} |
{% endfor %}
{% endif %}
{% if useExportAPI -%}
{{ Upper(libraryName) }}_API
{% endif -%}
UsdAttribute Get{{ Proper(attr.apiName) }}Attr() const;
/// See Get{{ Proper(attr.apiName) }}Attr(), and also
/// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
/// If specified, author \p defaultValue as the attribute's default,
/// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
/// the default for \p writeSparsely is \c false.
{% if useExportAPI -%}
{{ Upper(libraryName) }}_API
{% endif -%}
UsdAttribute Create{{ Proper(attr.apiName) }}Attr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
{% endif %}
{% endfor %}
{% for relName in cls.relOrder %}
{% set rel = cls.rels[relName]%}
{# Only emit Create/Get API and doxygen if apiName is not empty string. #}
{% if rel.apiName != '' %}
public:
// --------------------------------------------------------------------- //
// {{ Upper(rel.apiName) }}
// --------------------------------------------------------------------- //
/// {{ rel.doc }}
///
{% for detail in rel.details %}
/// \n {{ detail[0] }}: {{ detail[1] }}
{% endfor %}
{% if useExportAPI -%}
{{ Upper(libraryName) }}_API
{% endif -%}
UsdRelationship Get{{ Proper(rel.apiName) }}Rel() const;
/// See Get{{ Proper(rel.apiName) }}Rel(), and also
/// \ref Usd_Create_Or_Get_Property for when to use Get vs Create
{% if useExportAPI -%}
{{ Upper(libraryName) }}_API
{% endif -%}
UsdRelationship Create{{ Proper(rel.apiName) }}Rel() const;
{% endif %}
{% endfor %}
public:
// ===================================================================== //
// Feel free to add custom code below this line, it will be preserved by
// the code generator.
//
// Just remember to:
// - Close the class declaration with };
{% if useExportAPI %}
// - Close the namespace with {{ namespaceClose }}
{% endif %}
// - Close the include guard with #endif
// ===================================================================== //
// --(BEGIN CUSTOM CODE)--
| 15,039 | C | 35.772616 | 127 | 0.605093 |
USwampertor/OmniverseJS/ov/usd/usd/resources/codegenTemplates/tokens.cpp | //
// Copyright 2016 Pixar
//
// Licensed under the Apache License, Version 2.0 (the "Apache License")
// with the following modification; you may not use this file except in
// compliance with the Apache License and the following modification to it:
// Section 6. Trademarks. is deleted and replaced with:
//
// 6. Trademarks. This License does not grant permission to use the trade
// names, trademarks, service marks, or product names of the Licensor
// and its affiliates, except as required to comply with Section 4(c) of
// the License and to reproduce the content of the NOTICE file.
//
// You may obtain a copy of the Apache License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the Apache License with the above modification is
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the Apache License for the specific
// language governing permissions and limitations under the Apache License.
//
#include "{{ libraryPath }}/tokens.h"
{% if useExportAPI %}
{{ namespaceOpen }}
{% endif %}
{{ tokensPrefix }}TokensType::{{ tokensPrefix }}TokensType() :
{% for token in tokens %}
{{ token.id }}("{{ token.value }}", TfToken::Immortal),
{% endfor %}
allTokens({
{% for token in tokens %}
{{ token.id }}{% if not loop.last %},{% endif %}
{% endfor %}
})
{
}
TfStaticData<{{ tokensPrefix }}TokensType> {{ tokensPrefix }}Tokens;
{% if useExportAPI %}
{{ namespaceClose }}
{% endif %}
| 1,588 | C++ | 32.104166 | 75 | 0.696474 |
Motionverse/MV-omniverse-extension/README.md | # Extension Project Template
This project was automatically generated.
- `app` - It is a folder link to the location of your *Omniverse Kit* based app.
- `exts` - It is a folder where you can add new extensions. It was automatically added to extension search path. (Extension Manager -> Gear Icon -> Extension Search Path).
Open this folder using Visual Studio Code. It will suggest you to install few extensions that will make python experience better.
Look for "motionverse.engine.decoder" extension in extension manager and enable it. Try applying changes to any python files, it will hot-reload and you can observe results immediately.
Alternatively, you can launch your app from console with this folder added to search path and your extension enabled, e.g.:
```
> app\omni.code.bat --ext-folder exts --enable company.hello.world
```
# App Link Setup
If `app` folder link doesn't exist or broken it can be created again. For better developer experience it is recommended to create a folder link named `app` to the *Omniverse Kit* app installed from *Omniverse Launcher*. Convenience script to use is included.
Run:
```
> link_app.bat
```
If successful you should see `app` folder link in the root of this repo.
If multiple Omniverse apps is installed script will select recommended one. Or you can explicitly pass an app:
```
> link_app.bat --app create
```
You can also just pass a path to create link to:
```
> link_app.bat --path "C:/Users/bob/AppData/Local/ov/pkg/create-2021.3.4"
```
# Sharing Your Extensions
This folder is ready to be pushed to any git repository. Once pushed direct link to a git repository can be added to *Omniverse Kit* extension search paths.
Link might look like this: `git://github.com/[user]/[your_repo].git?branch=main&dir=exts`
Notice `exts` is repo subfolder with extensions. More information can be found in "Git URL as Extension Search Paths" section of developers manual.
To add a link to your *Omniverse Kit* based app go into: Extension Manager -> Gear Icon -> Extension Search Path
| 2,050 | Markdown | 37.698112 | 258 | 0.758049 |
Motionverse/MV-omniverse-extension/tools/scripts/link_app.py | import os
import argparse
import sys
import json
import packmanapi
import urllib3
def find_omniverse_apps():
http = urllib3.PoolManager()
try:
r = http.request("GET", "http://127.0.0.1:33480/components")
except Exception as e:
print(f"Failed retrieving apps from an Omniverse Launcher, maybe it is not installed?\nError: {e}")
sys.exit(1)
apps = {}
for x in json.loads(r.data.decode("utf-8")):
latest = x.get("installedVersions", {}).get("latest", "")
if latest:
for s in x.get("settings", []):
if s.get("version", "") == latest:
root = s.get("launch", {}).get("root", "")
apps[x["slug"]] = (x["name"], root)
break
return apps
def create_link(src, dst):
print(f"Creating a link '{src}' -> '{dst}'")
packmanapi.link(src, dst)
APP_PRIORITIES = ["code", "create", "view"]
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="Create folder link to Kit App installed from Omniverse Launcher")
parser.add_argument(
"--path",
help="Path to Kit App installed from Omniverse Launcher, e.g.: 'C:/Users/bob/AppData/Local/ov/pkg/create-2021.3.4'",
required=False,
)
parser.add_argument(
"--app", help="Name of Kit App installed from Omniverse Launcher, e.g.: 'code', 'create'", required=False
)
args = parser.parse_args()
path = args.path
if not path:
print("Path is not specified, looking for Omniverse Apps...")
apps = find_omniverse_apps()
if len(apps) == 0:
print(
"Can't find any Omniverse Apps. Use Omniverse Launcher to install one. 'Code' is the recommended app for developers."
)
sys.exit(0)
print("\nFound following Omniverse Apps:")
for i, slug in enumerate(apps):
name, root = apps[slug]
print(f"{i}: {name} ({slug}) at: '{root}'")
if args.app:
selected_app = args.app.lower()
if selected_app not in apps:
choices = ", ".join(apps.keys())
print(f"Passed app: '{selected_app}' is not found. Specify one of the following found Apps: {choices}")
sys.exit(0)
else:
selected_app = next((x for x in APP_PRIORITIES if x in apps), None)
if not selected_app:
selected_app = next(iter(apps))
print(f"\nSelected app: {selected_app}")
_, path = apps[selected_app]
if not os.path.exists(path):
print(f"Provided path doesn't exist: {path}")
else:
SCRIPT_ROOT = os.path.dirname(os.path.realpath(__file__))
create_link(f"{SCRIPT_ROOT}/../../app", path)
print("Success!")
| 2,813 | Python | 32.5 | 133 | 0.562389 |
Motionverse/MV-omniverse-extension/tools/packman/config.packman.xml | <config remotes="cloudfront">
<remote2 name="cloudfront">
<transport actions="download" protocol="https" packageLocation="d4i3qtqj3r0z5.cloudfront.net/${name}@${version}" />
</remote2>
</config>
| 211 | XML | 34.333328 | 123 | 0.691943 |
Motionverse/MV-omniverse-extension/tools/packman/bootstrap/install_package.py | # Copyright 2019 NVIDIA CORPORATION
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import logging
import zipfile
import tempfile
import sys
import shutil
__author__ = "hfannar"
logging.basicConfig(level=logging.WARNING, format="%(message)s")
logger = logging.getLogger("install_package")
class TemporaryDirectory:
def __init__(self):
self.path = None
def __enter__(self):
self.path = tempfile.mkdtemp()
return self.path
def __exit__(self, type, value, traceback):
# Remove temporary data created
shutil.rmtree(self.path)
def install_package(package_src_path, package_dst_path):
with zipfile.ZipFile(
package_src_path, allowZip64=True
) as zip_file, TemporaryDirectory() as temp_dir:
zip_file.extractall(temp_dir)
# Recursively copy (temp_dir will be automatically cleaned up on exit)
try:
# Recursive copy is needed because both package name and version folder could be missing in
# target directory:
shutil.copytree(temp_dir, package_dst_path)
except OSError as exc:
logger.warning(
"Directory %s already present, packaged installation aborted" % package_dst_path
)
else:
logger.info("Package successfully installed to %s" % package_dst_path)
install_package(sys.argv[1], sys.argv[2])
| 1,888 | Python | 31.568965 | 103 | 0.68697 |
Motionverse/MV-omniverse-extension/exts/motionverse.engine.coder/config/extension.toml | [package]
version = "1.0.0"
authors = ["Guowei Zhou <[email protected]>"]
title = "Motionverse"
description = "#"
readme = "docs/README.md"
# URL of the extension source repository.
repository = "https://github.com/Motionverse/MV-omniverse-extension.git"
# One of categories for UI.
category = "Animation"
# Keywords for the extension
keywords = ["Ai", "Text","Audio","Animation"]
# Icon to show in the extension manager
icon = "data/logo.png"
# Preview to show in the extension manager
preview_image = "data/preview.png"
# Use omni.ui to build simple UI
[dependencies]
"omni.kit.uiapp" = {}
# Main python module this extension provides, it will be publicly available as "import motionverse.engine.coder".
[[python.module]]
name = "motionverse.engine.coder"
| 777 | TOML | 22.575757 | 113 | 0.727156 |
Motionverse/MV-omniverse-extension/exts/motionverse.engine.coder/docs/CHANGELOG.md | # Changelog
Motionverse Extension changelog
===========================================
## [1.0.0] - 2022-07-15 | 113 | Markdown | 21.799996 | 43 | 0.433628 |
Motionverse/MV-omniverse-extension/exts/motionverse.engine.coder/docs/README.md | # Motionverse Extension
| 24 | Markdown | 11.499994 | 23 | 0.833333 |
Motionverse/MV-omniverse-extension/exts/motionverse.engine.coder/motionverse/engine/coder/constants.py | # Copyright (c) 2022 Motionverse Inc. All rights reserved.
# UI constants
WINDOW_NAME = "Motionverse"
CS_HOSTNAME_TEXT = "Host/IP"
CS_PORT_TEXT = "PORT"
CS_GOTO_BTN_TEXT = "Contact us"
CS_START_BTN_TEXT = "Start streaming"
CS_STOP_BTN_TEXT = "Stop streaming"
CS_URL = "http://motionverse.io/omniverse"
SKEL_SOURCE_EDIT_TEXT = "Target skeleton"
SKEL_SOURCE_BTN_TEXT = "Use highlighted skeleton"
SKEL_INVALID_TEXT = "No skeleton selected"
RIG_DROPDOWN_TEXT = "Rig Type"
RIG_UNSUPPORTED_TEXT = "Unsupported rig"
# UI image filepaths
LOGO_FILEPATH = "/data/logo-white.png"
# UI widget spacing
CS_H_SPACING = 5
# general constants
DEFAULT_PORT = 4188 | 648 | Python | 27.21739 | 58 | 0.736111 |
Motionverse/MV-omniverse-extension/exts/motionverse.engine.coder/motionverse/engine/coder/extension.py | from email import message
from operator import le
import carb
import omni.ext
import omni.ui as ui
import omni.timeline
import omni.usd
import omni.kit.window.file
from pxr import Vt, Gf, UsdSkel, Usd, Sdf, UsdGeom
import struct
import asyncio
import pathlib
from typing import cast, Union, List
import traceback
import webbrowser
from .constants import *
import json
import glob
import numpy as np
def get_rig_index(model_joint_names, rig_mappings):
candidates = [mapping["joint_mappings"].keys() for mapping in rig_mappings]
index = None
for i in range(len(candidates)):
if all([(joint in model_joint_names) for joint in candidates[i]]):
index = i
return index
def get_all_descendents(prim: Usd.Prim, result: List[Usd.Prim] = []):
if len(result) == 0:
result.append(prim)
children = prim.GetChildren()
result.extend(list(children))
for child in children:
get_all_descendents(child, result)
def find_skeleton(path):
stage = omni.usd.get_context().get_stage()
prim = stage.GetPrimAtPath(path)
descendants = []
get_all_descendents(prim, descendants)
skeleton = next(filter(lambda x: x.IsA(UsdSkel.Skeleton), descendants), None)
assert skeleton is not None, "Could not find skeleton"
print(UsdSkel.Skeleton(skeleton))
return UsdSkel.Skeleton(skeleton)
def find_blendShapes(path):
stage = omni.usd.get_context().get_stage()
prim = stage.GetPrimAtPath(path)
descendants = []
get_all_descendents(prim, descendants)
blendShapePrims = list(filter(lambda x: x.IsA(UsdSkel.BlendShape), descendants))
blendShapes = [UsdSkel.BlendShape(blendShape) for blendShape in blendShapePrims]
return blendShapes
def get_this_files_path():
return pathlib.Path(__file__).parent.absolute().as_posix()
#
# styles for UIController class
#
style_btn_enabled = {
"Button": {"border_radius": 5.0,"margin": 5.0,"padding": 10.0,"background_color": 0xFFFF7E09,"border_color": 0xFFFD761D},
"Button:hovered": {"background_color": 0xFFFF4F00},
"Button:pressed": {"background_color": 0xFFFAE26F},
"Button.Label": {"color": 0xFFFFFFFF},
}
style_btn_disabled = {
"Button": {"border_radius": 3.0,"margin": 5.0,"padding": 10.0,"background_color": 0xFFC0E0C0,"border_color": 0xFFFD7F1D},
"Button:hovered": {"background_color": 0xFFC0C0C0, "background_gradient_color": 0xFFFFAE5A},
"Button:pressed": {"background_color": 0xFFC0C0C0, "background_gradient_color": 0xFFFAB26D},
"Button.Label": {"color": 0xFF808080},
}
style_status_circle_green = {"background_color": 0xFF00FF00, "border_width": 0}
style_status_circle_red = {"background_color": 0xFF0000FF, "border_width": 0}
style_btn_goto_motionverse = {"Button": {"border_width": 0.0, "border_radius": 3.0, "margin": 5.0, "padding": 10.0}}
#
# UIController class
#
class UIController:
def __init__(self, ext):
self.ext = ext
self.extension_path = omni.kit.app.get_app().get_extension_manager().get_extension_path(ext.ext_id)
self._streaming_active = False
self._window = ui.Window(WINDOW_NAME,width=600, height=260)
self.build_ui()
def build_ui(self):
with self._window.frame:
with ui.VStack(height=0):
with ui.HStack():
#logo
logo_path = f"{self.extension_path}{LOGO_FILEPATH}"
ui.Image(logo_path, width=50,height=50,fill_policy=ui.FillPolicy.PRESERVE_ASPECT_FIT,alignment=ui.Alignment.CENTER)
ui.Spacer()
ui.Button(
CS_GOTO_BTN_TEXT,width=ui.Percent(10), style=style_btn_goto_motionverse,alignment=ui.Alignment.RIGHT_CENTER, clicked_fn=self.launch_motionverse_website)
with ui.HStack():
# green/red status
with ui.VStack(width=50, alignment=ui.Alignment.TOP):
self._status_circle = ui.Circle(
radius = 8,size_policy=ui.CircleSizePolicy.FIXED, style=style_status_circle_red
)
ui.Spacer()
with ui.VStack():
# CaptureStream device selection drop-down
with ui.HStack():
ui.Label(
CS_HOSTNAME_TEXT, width=ui.Percent(20), alignment=ui.Alignment.RIGHT_CENTER
)
ui.Spacer(width=CS_H_SPACING)
with ui.VStack(width=ui.Percent(50)):
ui.Spacer()
self.source_ip_field = ui.StringField(
model=ui.SimpleStringModel("192.168.10.113"), height=0, visible=True
)
ui.Spacer()
ui.Label(
CS_PORT_TEXT, width=ui.Percent(10), alignment=ui.Alignment.RIGHT_CENTER
)
with ui.VStack(width=ui.Percent(10)):
ui.Spacer()
self.source_port_field = ui.StringField(
model=ui.SimpleStringModel("4188"), height=0, visible=True
)
ui.Spacer()
# skeleton selection
with ui.HStack():
ui.Label(
SKEL_SOURCE_EDIT_TEXT, width=ui.Percent(20), alignment=ui.Alignment.RIGHT_CENTER
)
ui.Spacer(width=CS_H_SPACING)
with ui.VStack(width=ui.Percent(50)):
ui.Spacer()
self._skeleton_to_drive_stringfield = ui.StringField(
model=ui.SimpleStringModel(SKEL_INVALID_TEXT), height=0, enabled=False
)
ui.Spacer()
ui.Spacer(width=CS_H_SPACING)
self._skel_select_button = ui.Button(
SKEL_SOURCE_BTN_TEXT, width=0, clicked_fn=self.select_skeleton
)
# rig selection
with ui.HStack():
ui.Label(RIG_DROPDOWN_TEXT, width=ui.Percent(20), alignment=ui.Alignment.RIGHT_CENTER)
ui.Spacer(width=CS_H_SPACING)
with ui.VStack(width=ui.Percent(75)):
ui.Spacer()
self._selected_rig_label = ui.Label("")
ui.Spacer()
# start/stop stream buttons
with ui.HStack():
ui.Spacer(width=ui.Percent(20))
self._start_button = ui.Button(
CS_START_BTN_TEXT,
width=0,
clicked_fn=self.start_streaming,
enabled=not self.streaming_active,
style=style_btn_disabled if self.streaming_active else style_btn_enabled,
)
ui.Spacer(width=CS_H_SPACING)
self._stop_button = ui.Button(
CS_STOP_BTN_TEXT,
width=0,
clicked_fn=self.stop_streaming,
enabled=self.streaming_active,
style=style_btn_enabled if self.streaming_active else style_btn_disabled,
)
ui.Spacer(height=5)
def select_skeleton(self):
paths = omni.usd.get_context().get_selection().get_selected_prim_paths()
if paths:
path = paths[0]
try:
self.ext.init_skeletons(path)
except Exception as ex:
self._skeleton_to_drive_stringfield.model.set_value(SKEL_INVALID_TEXT)
self._selected_rig_label.text = self.ext.selected_rig_name or RIG_UNSUPPORTED_TEXT
def launch_motionverse_website(self):
webbrowser.open_new_tab(CS_URL)
def update_ui(self):
if self.streaming_active:
self._start_button.enabled = False
self._start_button.set_style(style_btn_disabled)
self._stop_button.enabled = True
self._stop_button.set_style(style_btn_enabled)
else:
self._start_button.enabled = self.ext.ready_to_stream
self._start_button.set_style(
style_btn_enabled if self.ext.ready_to_stream else style_btn_disabled
)
self._stop_button.enabled = False
self._stop_button.set_style(style_btn_disabled)
if self.streaming_active:
self._status_circle.set_style(style_status_circle_green)
else:
self._status_circle.set_style(style_status_circle_red)
self._skeleton_to_drive_stringfield.model.set_value(self.ext.target_skeleton_path)
def start_streaming(self):
self.ext.connect()
def stop_streaming(self):
self.ext.disconnect("User cancelled")
@property
def streaming_active(self):
return self._streaming_active
@streaming_active.setter
def streaming_active(self, value):
self._streaming_active = value
class MotionverseExtension(omni.ext.IExt):
def __init__(self):
self._net_io_task = None
self._update_skeleton_task = None
self.target_skeleton = None
self.skel_cache = UsdSkel.Cache()
def on_startup(self, ext_id):
self.import_rig_mappings_from_json_files()
self.ext_id = ext_id
stream = omni.kit.app.get_app().get_update_event_stream()
self.update_sub = stream.create_subscription_to_pop(self.update_ui, name="update frame")
self.ui_controller = UIController(self)
def connect(self):
self.disconnect("Resetting connection")
host = self.ui_controller.source_ip_field.model.as_string
port = self.ui_controller.source_port_field.model.as_int
loop = asyncio.get_event_loop()
queue = asyncio.Queue(maxsize=10, loop=loop)
if self._net_io_task:
loop.run_until_complete(asyncio.wait({self._net_io_task}, timeout=1.0))
if self._update_skeleton_task:
loop.run_until_complete(asyncio.wait({self._update_skeleton_task}, timeout=1.0))
self._net_io_task = loop.create_task(self._do_net_io(host, port, queue))
self._update_skeleton_task = loop.create_task(self._update_skeleton_loop(queue))
self._net_io_task.add_done_callback(self.on_task_complete)
self._update_skeleton_task.add_done_callback(self.on_task_complete)
def on_task_complete(self, fut=None):
if fut is self._net_io_task:
self._update_skeleton_task.cancel()
elif fut is self._update_skeleton_task:
self._net_io_task.cancel()
self.ui_controller.streaming_active = False
async def _do_net_io(self, host, port, queue):
self.ui_controller.streaming_active = True
writer = None
try:
reader, writer = await asyncio.open_connection(host, port)
writer.write(b"ov")
await self._read_client(reader, queue)
except asyncio.CancelledError:
print("Network streaming cancelled")
except:
carb.log_error(traceback.format_exc())
finally:
if writer is not None:
writer.close()
await writer.wait_closed()
print("TCP connection closed")
print("Net I/O task stopped")
async def _read_client(self, reader, queue):
while True:
message_data = await reader.readexactly(1660)
await queue.put(message_data)
async def _update_skeleton_loop(self, queue):
try:
while True:
message = await queue.get()
fd = FrameDetections()
fd.ParseFromString(message)
self.update_skeleton(fd)
except asyncio.CancelledError:
print("Skeleton update task cancelled")
except:
carb.log_error(traceback.format_exc())
def disconnect(self, reason=str()):
streaming_active = False
if self._net_io_task is not None:
self._net_io_task.cancel()
def import_rig_mappings_from_json_files(self):
self.rig_mappings = []
rig_filenames = glob.glob(get_this_files_path() + "/xform_*.json")
if rig_filenames is not None:
for filename in rig_filenames:
rig_mapfile = open(filename, "r")
if rig_mapfile is not None:
self.rig_mappings.append(json.load(rig_mapfile))
else:
print("error - could not load file %s" % filename)
def init_skeletons(self, skel_root_path):
self.selected_rig_index = None
self.motion_skel_anim = None
self.selected_joints = None
stage = omni.usd.get_context().get_stage()
selected_skeleton = find_skeleton(skel_root_path)
blendShapes = find_blendShapes(skel_root_path)
print("skel_cache =====",self.skel_cache)
skel_query = self.skel_cache.GetSkelQuery(selected_skeleton)
print("selected_skeleton ====",selected_skeleton)
print("blendShapes[0] ====",blendShapes[0])
# blendShape_query = UsdSkel.BlendShapeQuery(blendShapes[0])
# print("blendShape_query",blendShape_query)
joint_tokens = skel_query.GetJointOrder()
jointPaths = [Sdf.Path(jointToken) for jointToken in joint_tokens]
all_joint_names = [jointPath.name for jointPath in jointPaths]
# all_blendshape_names = [blendShapePath.name for blendShapePath in blendShapePaths]
self.selected_rig_index = get_rig_index(all_joint_names, self.rig_mappings)
assert self.selected_rig_index is not None, "Unsupported rig"
self.target_skeleton = selected_skeleton
self.target_skel_root = UsdSkel.Root.Find(self.target_skeleton.GetPrim())
# print("target_skeleton = ",self.target_skeleton.GetPrim())
# skel_root_rotate_xyz is a set of rotations in XYZ order used to align the rest pose
# with wrnch's axes (+Y up, +Z forward)
skel_root_rotate_xyz = self.rig_mappings[self.selected_rig_index]["skel_root_rotate_xyz"]
rot_x = Gf.Rotation(Gf.Vec3d(1, 0, 0), skel_root_rotate_xyz[0])
rot_y = Gf.Rotation(Gf.Vec3d(0, 1, 0), skel_root_rotate_xyz[1])
rot_z = Gf.Rotation(Gf.Vec3d(0, 0, 1), skel_root_rotate_xyz[2])
self.rest_xform_adjust = Gf.Matrix4d()
self.rest_xform_adjust.SetRotate(rot_x * rot_y * rot_z)
self.rest_xform_adjust_inverse = self.rest_xform_adjust.GetInverse()
if not skel_query.HasRestPose():
xforms = skel_query.ComputeJointLocalTransforms()
self.target_skeleton.GetRestTransformsAttr().Set(xforms)
self.skel_cache.Clear()
def update_skeleton(self, fd):
if self.selected_joints is None:
self._init_animation(fd.body_pose_names)
num_joints = len(self.rest_xforms_anim_global)
root_index = self.motion_to_anim_index["Hips"]
motion_xforms_global = Vt.Matrix4dArray(num_joints)
for i, pose in enumerate(fd.body_poses):
name = fd.body_pose_names[i]
if name in self.motion_to_anim_index:
anim_index = self.motion_to_anim_index[name]
q = pose['rotation']
t = pose['position']
rot = Gf.Rotation(Gf.Quatd(q[3], q[0], q[1], q[2]))
trans = Gf.Vec3d(t[0], t[1], t[2])
xform = Gf.Matrix4d()
xform.SetTransform(rot, trans)
motion_xforms_global[anim_index] = xform
target_pose_xforms_global = Vt.Matrix4dArray(
[
base_xform * motion_xform
for motion_xform, base_xform in zip(motion_xforms_global, self.rest_xforms_anim_global)
]
)
root_xform = self.rest_xform_adjust_inverse
target_xforms_local = UsdSkel.ComputeJointLocalTransforms(
self.anim_topology, target_pose_xforms_global, root_xform
)
anim_rotations = Vt.QuatfArray([Gf.Quatf(xform.ExtractRotationQuat()) for xform in target_xforms_local])
height_offset = 0
# Apply root motion to the animation attr
local_translations_attr = self.motion_skel_anim.GetTranslationsAttr()
local_translations = local_translations_attr.Get(0)
local_translations[root_index] = Gf.Vec3f(
root_xform.Transform(
Gf.Vec3d(0, 1, 0) * height_offset + motion_xforms_global[root_index].ExtractTranslation()
)
)
local_translations_attr.Set(local_translations, 0)
# Apply joint rotations to animation attr
self.motion_skel_anim.GetRotationsAttr().Set(anim_rotations, 0)
def _init_animation(self,selected_joints):
stage = omni.usd.get_context().get_stage()
rig_mapping = self.rig_mappings[self.selected_rig_index]["joint_mappings"]
skel_query = self.skel_cache.GetSkelQuery(self.target_skeleton)
joint_tokens = skel_query.GetJointOrder()
joint_names = {Sdf.Path(token).name: token for token in joint_tokens}
print(joint_names)
# Lookup index of joint by token
joint_token_indices = {token: index for index, token in enumerate(joint_tokens)}
motion_to_token = {
value: joint_names[key] for key, value in rig_mapping.items() if value in selected_joints
}
anim_tokens = Vt.TokenArray(motion_to_token.values())
assert len(anim_tokens) > 0
anim_token_indices = {token: index for index, token in enumerate(anim_tokens)}
active_token_indices = [joint_token_indices[token] for token in anim_tokens]
self.motion_to_anim_index = {
motion_name: anim_token_indices[token] for motion_name, token in motion_to_token.items()
}
self.anim_topology = UsdSkel.Topology([Sdf.Path(token) for token in anim_tokens])
assert self.anim_topology.Validate()
anim_path = self.target_skeleton.GetPath().AppendChild("SkelRoot")
self.motion_skel_anim = UsdSkel.Animation.Define(stage, anim_path)
print("anim_tokens=",anim_tokens)
self.motion_skel_anim.GetJointsAttr().Set(anim_tokens)
self.motion_skel_anim.GetBlendShapesAttr().Set(anim_tokens)
# Set our UsdSkelAnimation as the animationSource of the UsdSkelSkeleton
binding = UsdSkel.BindingAPI.Apply(self.target_skeleton.GetPrim())
binding.CreateAnimationSourceRel().SetTargets([self.motion_skel_anim.GetPrim().GetPath()])
# Set initial the scale, translation, and rotation attributes for the UsdSkelAnimation.
# Note that these attributes need to be in the UsdSkelSkeleton's Local Space.
root_xform = Gf.Matrix4d()
root_xform.SetIdentity()
root_xform = self.rest_xform_adjust
identity_xform = Gf.Matrix4d()
identity_xform.SetIdentity()
rest_xforms_local = self.target_skeleton.GetRestTransformsAttr().Get()
assert rest_xforms_local, "Skeleton has no restTransforms"
skel_topology = skel_query.GetTopology()
anim_start_index = active_token_indices[0]
xform_accum = Gf.Matrix4d()
xform_accum.SetIdentity()
index = skel_topology.GetParent(anim_start_index)
while index >= 0:
xform_accum = rest_xforms_local[index] * xform_accum
rest_xforms_local[index] = identity_xform
index = skel_topology.GetParent(index)
rest_xforms_local[anim_start_index] = xform_accum * rest_xforms_local[anim_start_index]
# Set the rest pose transforms
self.target_skeleton.GetRestTransformsAttr().Set(rest_xforms_local)
# Joint transforms in world coordinates such that the t-pose is aligned with wrnch's
# base t-pose (+Y up, +Z forward)
rest_xforms_global = UsdSkel.ConcatJointTransforms(skel_topology, rest_xforms_local, root_xform)
# Get the subset of the rest transforms that correspond to our UsdSkelAnimation attrs.
# We're going to concatenate these to the wrx transforms to get the desired
# pose
self.rest_xforms_anim_global = Vt.Matrix4dArray([rest_xforms_global[i] for i in active_token_indices])
base_xforms_anim_local = UsdSkel.ComputeJointLocalTransforms(
self.anim_topology, self.rest_xforms_anim_global, identity_xform
)
self.motion_skel_anim.SetTransforms(base_xforms_anim_local, 0)
self.selected_joints = set(selected_joints)
def update_ui(self, dt):
try:
self.ui_controller.update_ui()
except:
self.disconnect("Error updating UI")
raise
def on_shutdown(self):
self.ext = None
self._window = None
@property
def ready_to_stream(self):
has_skeleton_target = self.target_skeleton is not None and self.target_skeleton.GetPrim()
return has_skeleton_target
@property
def target_skeleton_path(self):
if not self.target_skeleton or not self.target_skeleton.GetPrim():
return ""
else:
return str(self.target_skeleton.GetPath())
@property
def selected_rig_name(self):
if self.selected_rig_index is not None:
return self.rig_mappings[self.selected_rig_index]["display_name"]
else:
return None
class FrameDetections():
def __init__(self):
self.body_poses = None
self.faces = None
self.body_pose_names = ("Hips","LeftUpLeg","RightUpLeg","LeftLeg","RightLeg","LeftFoot","RightFoot","Spine","Spine1","Neck","Head","LeftShoulder","RightShoulder","LeftArm",
"RightArm","LeftForeArm","RightForeArm","LeftHand","RightHand","LeftToeBase","RightToeBase","LeftHandThumb1","LeftHandThumb2","LeftHandThumb3",
"LeftHandIndex1","LeftHandIndex2","LeftHandIndex3","LeftHandMiddle1","LeftHandMiddle2","LeftHandMiddle3","LeftHandRing1","LeftHandRing2","LeftHandRing3","LeftHandPinky1",
"LeftHandPinky2","LeftHandPinky3","RightHandThumb1","RightHandThumb2","RightHandThumb3","RightHandIndex1","RightHandIndex2","RightHandIndex3","RightHandMiddle1",
"RightHandMiddle2","RightHandMiddle3","RightHandRing1","RightHandRing2","RightHandRing3","RightHandPinky1","RightHandPinky2","RightHandPinky3")
def ParseFromString(self,value):
message_list=struct.unpack("415f",value)
self.faces = message_list[:51]
body_data = np.array(message_list[51:]).reshape(-1, 7) #joints num, 4+3
self.body_poses = [{'rotation': body_data[idx][:4], 'position': body_data[idx][4:]}
for idx in range(len(self.body_pose_names))]
| 23,616 | Python | 39.302048 | 180 | 0.588626 |
Motionverse/MV-omniverse-extension/exts/motionverse.engine.coder/motionverse/engine/coder/__init__.py | from .scripts.extension import *
| 33 | Python | 15.999992 | 32 | 0.787879 |
Motionverse/MV-omniverse-extension/exts/motionverse.engine.coder/motionverse/engine/coder/scripts/styles.py | #
# styles
#
style_btn_enabled = {
"Button": {"border_radius": 5.0,"margin": 5.0,"padding": 10.0,"background_color": 0xFFFF7E09,"border_color": 0xFFFD761D},
"Button:hovered": {"background_color": 0xFFFF4F00},
"Button:pressed": {"background_color": 0xFFFAE26F},
"Button.Label": {"color": 0xFFFFFFFF},
}
style_btn_disabled = {
"Button": {"border_radius": 3.0,"margin": 5.0,"padding": 10.0,"background_color": 0xFFC0E0C0,"border_color": 0xFFFD7F1D},
"Button:hovered": {"background_color": 0xFFC0C0C0, "background_gradient_color": 0xFFFFAE5A},
"Button:pressed": {"background_color": 0xFFC0C0C0, "background_gradient_color": 0xFFFAB26D},
"Button.Label": {"color": 0xFF808080},
}
style_status_circle_green = {"background_color": 0xFF00FF00, "border_width": 0}
style_status_circle_red = {"background_color": 0xFF0000FF, "border_width": 0}
style_btn_goto_motionverse = {"Button": {"border_width": 0.0, "border_radius": 3.0, "margin": 5.0, "padding": 10.0}} | 982 | Python | 53.611108 | 125 | 0.677189 |
Motionverse/MV-omniverse-extension/exts/motionverse.engine.coder/motionverse/engine/coder/scripts/constants.py | # Copyright (c) 2022 Motionverse Inc. All rights reserved.
WINDOW_NAME = "Motionverse"
CS_HOSTNAME_TEXT = "Host/IP"
CS_PORT_TEXT = "PORT"
CS_GOTO_BTN_TEXT = "Contact us"
CS_START_BTN_TEXT = "Start streaming"
CS_STOP_BTN_TEXT = "Stop streaming"
CS_URL = "http://motionverse.io/omniverse"
SKEL_SOURCE_EDIT_TEXT = "Target skeleton"
SKEL_SOURCE_BTN_TEXT = "Use highlighted skeleton"
SKEL_INVALID_TEXT = "No skeleton selected"
RIG_DROPDOWN_TEXT = "Rig Type"
RIG_UNSUPPORTED_TEXT = "Unsupported rig"
# UI image filepaths
LOGO_FILEPATH = "/data/logo-white.png"
# UI widget spacing
CS_H_SPACING = 5
# general constants
DEFAULT_PORT = "4188"
DEFAULT_IP = "192.168.10.105"
| 667 | Python | 25.719999 | 58 | 0.728636 |
Motionverse/MV-omniverse-extension/exts/motionverse.engine.coder/motionverse/engine/coder/scripts/extension.py | import carb
import omni.ext
import omni.timeline
import omni.usd
import omni.kit.window.file
import traceback
import json
import glob
import asyncio
from email import message
from operator import le
from pxr import Vt, Gf, UsdSkel, Usd, Sdf, UsdGeom
from typing import cast, Union, List
from .constants import *
from .ui import *
from .styles import *
from .utils import *
class MotionverseExtension(omni.ext.IExt):
def __init__(self):
self._net_io_task = None
self._update_skeleton_task = None
self.target_skeleton = None
self.skel_root_path = None
self.skel_cache = UsdSkel.Cache()
def on_startup(self, ext_id):
self.import_rig_mappings_from_json_files()
self.ext_id = ext_id
stream = omni.kit.app.get_app().get_update_event_stream()
self.update_sub = stream.create_subscription_to_pop(self.update_ui, name="update frame")
self.ui_controller = UIController(self)
def connect(self):
self.disconnect("Resetting connection")
host = self.ui_controller.source_ip_field.model.as_string
port = self.ui_controller.source_port_field.model.as_int
loop = asyncio.get_event_loop()
queue = asyncio.Queue(maxsize=10, loop=loop)
if self._net_io_task:
loop.run_until_complete(asyncio.wait({self._net_io_task}, timeout=1.0))
if self._update_skeleton_task:
loop.run_until_complete(asyncio.wait({self._update_skeleton_task}, timeout=1.0))
self._net_io_task = loop.create_task(self._do_net_io(host, port, queue))
self._update_skeleton_task = loop.create_task(self._update_skeleton_loop(queue))
self._net_io_task.add_done_callback(self.on_task_complete)
self._update_skeleton_task.add_done_callback(self.on_task_complete)
def on_task_complete(self, fut=None):
if fut is self._net_io_task:
self._update_skeleton_task.cancel()
elif fut is self._update_skeleton_task:
self._net_io_task.cancel()
self.ui_controller.streaming_active = False
async def _do_net_io(self, host, port, queue):
self.ui_controller.streaming_active = True
writer = None
try:
reader, writer = await asyncio.open_connection(host, port)
writer.write(b"ov")
await self._read_client(reader, queue)
except asyncio.CancelledError:
log_info("Network streaming cancelled")
except:
carb.log_error(traceback.format_exc())
finally:
if writer is not None:
writer.close()
await writer.wait_closed()
log_info("TCP connection closed")
log_info("Net I/O task stopped")
async def _read_client(self, reader, queue):
while True:
message_data = await reader.readexactly(1660)
await queue.put(message_data)
async def _update_skeleton_loop(self, queue):
try:
while True:
message = await queue.get()
fd = FrameDetections()
fd.ParseFromString(message)
self.update_skeleton(fd)
except asyncio.CancelledError:
log_info("Skeleton update task cancelled")
except:
carb.log_error(traceback.format_exc())
def disconnect(self, reason=str()):
streaming_active = False
if self._net_io_task is not None:
self._net_io_task.cancel()
def import_rig_mappings_from_json_files(self):
self.rig_mappings = []
rig_filenames = glob.glob(get_this_files_path() + "/xform_*.json")
if rig_filenames is not None:
for filename in rig_filenames:
rig_mapfile = open(filename, "r")
if rig_mapfile is not None:
self.rig_mappings.append(json.load(rig_mapfile))
else:
log_info("error - could not load file %s" % filename)
def init_skeletons(self, skel_root_path):
self.selected_rig_index = None
self.motion_skel_anim = None
self.selected_joints = None
self.skel_root_path = skel_root_path
selected_skeleton = find_skeleton(skel_root_path)
skel_query = self.skel_cache.GetSkelQuery(selected_skeleton)
joint_tokens = skel_query.GetJointOrder()
jointPaths = [Sdf.Path(jointToken) for jointToken in joint_tokens]
all_joint_names = [jointPath.name for jointPath in jointPaths]
self.selected_rig_index = get_rig_index(all_joint_names, self.rig_mappings)
assert self.selected_rig_index is not None, "Unsupported rig"
self.target_skeleton = selected_skeleton
self.target_skel_root = UsdSkel.Root.Find(self.target_skeleton.GetPrim())
skel_root_rotate_xyz = self.rig_mappings[self.selected_rig_index]["skel_root_rotate_xyz"]
rot_x = Gf.Rotation(Gf.Vec3d(1, 0, 0), skel_root_rotate_xyz[0])
rot_y = Gf.Rotation(Gf.Vec3d(0, 1, 0), skel_root_rotate_xyz[1])
rot_z = Gf.Rotation(Gf.Vec3d(0, 0, 1), skel_root_rotate_xyz[2])
self.rest_xform_adjust = Gf.Matrix4d()
self.rest_xform_adjust.SetRotate(rot_x * rot_y * rot_z)
self.rest_xform_adjust_inverse = self.rest_xform_adjust.GetInverse()
if not skel_query.HasRestPose():
xforms = skel_query.ComputeJointLocalTransforms()
self.target_skeleton.GetRestTransformsAttr().Set(xforms)
self.skel_cache.Clear()
def update_skeleton(self, fd):
if self.selected_joints is None:
self._init_animation(fd.body_pose_names)
num_joints = len(self.rest_xforms_anim_global)
root_index = self.motion_to_anim_index["Hips"]
motion_xforms_global = Vt.Matrix4dArray(num_joints)
for i, pose in enumerate(fd.body_poses):
name = fd.body_pose_names[i]
if name in self.motion_to_anim_index:
anim_index = self.motion_to_anim_index[name]
q = pose['rotation']
t = pose['position']
rot = Gf.Rotation(Gf.Quatd(q[3], q[0], q[1], q[2]))
trans = Gf.Vec3d(t[0], t[1], t[2])
xform = Gf.Matrix4d()
xform.SetTransform(rot, trans)
motion_xforms_global[anim_index] = xform
target_pose_xforms_global = Vt.Matrix4dArray(
[
base_xform * motion_xform
for motion_xform, base_xform in zip(motion_xforms_global, self.rest_xforms_anim_global)
]
)
root_xform = self.rest_xform_adjust_inverse
target_xforms_local = UsdSkel.ComputeJointLocalTransforms(
self.anim_topology, target_pose_xforms_global, root_xform
)
anim_rotations = Vt.QuatfArray([Gf.Quatf(xform.ExtractRotationQuat()) for xform in target_xforms_local])
height_offset = 0
local_translations_attr = self.motion_skel_anim.GetTranslationsAttr()
local_translations = local_translations_attr.Get(0)
local_translations[root_index] = Gf.Vec3f(
root_xform.Transform(
Gf.Vec3d(0, 1, 0) * height_offset + motion_xforms_global[root_index].ExtractTranslation()
)
)
local_translations_attr.Set(local_translations, 0)
self.motion_skel_anim.GetRotationsAttr().Set(anim_rotations, 0)
# self.motion_skel_anim.GetBlendShapeWeightsAttr().Set(fd.faces,0)
def _init_animation(self,selected_joints):
stage = omni.usd.get_context().get_stage()
rig_mapping = self.rig_mappings[self.selected_rig_index]["joint_mappings"]
skel_query = self.skel_cache.GetSkelQuery(self.target_skeleton)
joint_tokens = skel_query.GetJointOrder()
joint_names = {Sdf.Path(token).name: token for token in joint_tokens}
joint_token_indices = {token: index for index, token in enumerate(joint_tokens)}
motion_to_token = {
value: joint_names[key] for key, value in rig_mapping.items() if value in selected_joints
}
anim_tokens = Vt.TokenArray(motion_to_token.values())
assert len(anim_tokens) > 0
anim_token_indices = {token: index for index, token in enumerate(anim_tokens)}
active_token_indices = [joint_token_indices[token] for token in anim_tokens]
self.motion_to_anim_index = {
motion_name: anim_token_indices[token] for motion_name, token in motion_to_token.items()
}
self.anim_topology = UsdSkel.Topology([Sdf.Path(token) for token in anim_tokens])
assert self.anim_topology.Validate()
anim_path = self.target_skeleton.GetPath().AppendChild("SkelRoot")
self.motion_skel_anim = UsdSkel.Animation.Define(stage, anim_path)
self.motion_skel_anim.GetJointsAttr().Set(anim_tokens)
# self.motion_skel_anim.GetBlendShapesAttr().Set(anim_tokens)
binding = UsdSkel.BindingAPI.Apply(self.target_skeleton.GetPrim())
binding.CreateAnimationSourceRel().SetTargets([self.motion_skel_anim.GetPrim().GetPath()])
root_xform = Gf.Matrix4d()
root_xform.SetIdentity()
root_xform = self.rest_xform_adjust
identity_xform = Gf.Matrix4d()
identity_xform.SetIdentity()
rest_xforms_local = self.target_skeleton.GetRestTransformsAttr().Get()
assert rest_xforms_local, "Skeleton has no restTransforms"
skel_topology = skel_query.GetTopology()
anim_start_index = active_token_indices[0]
xform_accum = Gf.Matrix4d()
xform_accum.SetIdentity()
index = skel_topology.GetParent(anim_start_index)
while index >= 0:
xform_accum = rest_xforms_local[index] * xform_accum
rest_xforms_local[index] = identity_xform
index = skel_topology.GetParent(index)
rest_xforms_local[anim_start_index] = xform_accum * rest_xforms_local[anim_start_index]
self.target_skeleton.GetRestTransformsAttr().Set(rest_xforms_local)
rest_xforms_global = UsdSkel.ConcatJointTransforms(skel_topology, rest_xforms_local, root_xform)
self.rest_xforms_anim_global = Vt.Matrix4dArray([rest_xforms_global[i] for i in active_token_indices])
base_xforms_anim_local = UsdSkel.ComputeJointLocalTransforms(
self.anim_topology, self.rest_xforms_anim_global, identity_xform
)
self.motion_skel_anim.SetTransforms(base_xforms_anim_local, 0)
self.selected_joints = set(selected_joints)
def update_ui(self, dt):
try:
self.ui_controller.update_ui()
except:
self.disconnect("Error updating UI")
raise
def on_shutdown(self):
log_info("on_shutdown")
self.ui_controller.shutdown()
self.ui_controller = None
self.disconnect("Extension is shutting down")
@property
def ready_to_stream(self):
has_skeleton_target = self.target_skeleton is not None and self.target_skeleton.GetPrim()
return has_skeleton_target
@property
def target_skeleton_path(self):
if not self.target_skeleton or not self.target_skeleton.GetPrim():
return ""
else:
return str(self.target_skeleton.GetPath())
@property
def selected_rig_name(self):
if self.selected_rig_index is not None:
return self.rig_mappings[self.selected_rig_index]["display_name"]
else:
return None | 11,565 | Python | 39.725352 | 112 | 0.626891 |
Motionverse/MV-omniverse-extension/exts/motionverse.engine.coder/motionverse/engine/coder/scripts/utils.py | import pathlib
from typing import cast, Union, List
import carb
from pxr import Vt, Gf, UsdSkel, Usd, Sdf, UsdGeom
import omni.timeline
import omni.usd
import omni.kit.window.file
import struct
import numpy as np
def log_info(msg):
carb.log_info("{}".format(msg))
def log_warn(msg):
carb.log_warn("{}".format(msg))
def log_error(msg):
carb.log_error("{}".format(msg))
def get_rig_index(model_joint_names, rig_mappings):
candidates = [mapping["joint_mappings"].keys() for mapping in rig_mappings]
index = None
for i in range(len(candidates)):
if all([(joint in model_joint_names) for joint in candidates[i]]):
index = i
return index
def get_all_descendents(prim: Usd.Prim, result: List[Usd.Prim] = []):
if len(result) == 0:
result.append(prim)
children = prim.GetChildren()
result.extend(list(children))
for child in children:
get_all_descendents(child, result)
def find_skeleton(path):
stage = omni.usd.get_context().get_stage()
prim = stage.GetPrimAtPath(path)
descendants = []
get_all_descendents(prim, descendants)
skeleton = next(filter(lambda x: x.IsA(UsdSkel.Skeleton), descendants), None)
assert skeleton is not None, "Could not find skeleton"
return UsdSkel.Skeleton(skeleton)
def find_blendShapes(path):
stage = omni.usd.get_context().get_stage()
prim = stage.GetPrimAtPath(path)
descendants = []
get_all_descendents(prim, descendants)
blendShapePrims = list(filter(lambda x: x.IsA(UsdSkel.BlendShape), descendants))
blendShapes = [UsdSkel.BlendShape(blendShape) for blendShape in blendShapePrims]
return blendShapes
def get_this_files_path():
return pathlib.Path(__file__).parent.absolute().as_posix()
class FrameDetections():
def __init__(self):
self.body_poses = None
self.faces = None
self.body_pose_names = ("Hips","LeftUpLeg","RightUpLeg","LeftLeg","RightLeg","LeftFoot","RightFoot","Spine","Spine1","Neck","Head","LeftShoulder","RightShoulder","LeftArm",
"RightArm","LeftForeArm","RightForeArm","LeftHand","RightHand","LeftToeBase","RightToeBase","LeftHandThumb1","LeftHandThumb2","LeftHandThumb3",
"LeftHandIndex1","LeftHandIndex2","LeftHandIndex3","LeftHandMiddle1","LeftHandMiddle2","LeftHandMiddle3","LeftHandRing1","LeftHandRing2","LeftHandRing3","LeftHandPinky1",
"LeftHandPinky2","LeftHandPinky3","RightHandThumb1","RightHandThumb2","RightHandThumb3","RightHandIndex1","RightHandIndex2","RightHandIndex3","RightHandMiddle1",
"RightHandMiddle2","RightHandMiddle3","RightHandRing1","RightHandRing2","RightHandRing3","RightHandPinky1","RightHandPinky2","RightHandPinky3")
def ParseFromString(self,value):
message_list=struct.unpack("415f",value)
self.faces = message_list[:51]
body_data = np.array(message_list[51:]).reshape(-1, 7) #joints num, 4+3
self.body_poses = [{'rotation': body_data[idx][:4], 'position': body_data[idx][4:]}
for idx in range(len(self.body_pose_names))] | 3,083 | Python | 42.436619 | 180 | 0.687642 |
Motionverse/MV-omniverse-extension/exts/motionverse.engine.coder/motionverse/engine/coder/scripts/ui.py | import omni.ui as ui
import omni.kit.ui
import omni.kit.app
import omni.kit.window.filepicker
import webbrowser
from .styles import *
from .constants import *
#
# UIController class
#
class UIController:
def __init__(self, ext):
self.ext = ext
self.extension_path = omni.kit.app.get_app().get_extension_manager().get_extension_path(ext.ext_id)
self._streaming_active = False
self._window = ui.Window(WINDOW_NAME,width=600, height=260)
self.build_ui()
def build_ui(self):
with self._window.frame:
with ui.VStack(height=0):
with ui.HStack():
#logo
logo_path = f"{self.extension_path}{LOGO_FILEPATH}"
ui.Image(logo_path, width=50,height=50,fill_policy=ui.FillPolicy.PRESERVE_ASPECT_FIT,alignment=ui.Alignment.CENTER)
ui.Spacer()
ui.Button(
CS_GOTO_BTN_TEXT,width=ui.Percent(10), style=style_btn_goto_motionverse,alignment=ui.Alignment.RIGHT_CENTER, clicked_fn=self.launch_motionverse_website)
with ui.HStack():
# green/red status
with ui.VStack(width=50, alignment=ui.Alignment.TOP):
self._status_circle = ui.Circle(
radius = 8,size_policy=ui.CircleSizePolicy.FIXED, style=style_status_circle_red
)
ui.Spacer()
with ui.VStack():
# CaptureStream device selection drop-down
with ui.HStack():
ui.Label(
CS_HOSTNAME_TEXT, width=ui.Percent(20), alignment=ui.Alignment.RIGHT_CENTER
)
ui.Spacer(width=CS_H_SPACING)
with ui.VStack(width=ui.Percent(50)):
ui.Spacer()
self.source_ip_field = ui.StringField(
model=ui.SimpleStringModel(DEFAULT_IP), height=0, visible=True
)
ui.Spacer()
ui.Label(
CS_PORT_TEXT, width=ui.Percent(10), alignment=ui.Alignment.RIGHT_CENTER
)
with ui.VStack(width=ui.Percent(10)):
ui.Spacer()
self.source_port_field = ui.StringField(
model=ui.SimpleStringModel(DEFAULT_PORT), height=0, visible=True
)
ui.Spacer()
# skeleton selection
with ui.HStack():
ui.Label(
SKEL_SOURCE_EDIT_TEXT, width=ui.Percent(20), alignment=ui.Alignment.RIGHT_CENTER
)
ui.Spacer(width=CS_H_SPACING)
with ui.VStack(width=ui.Percent(50)):
ui.Spacer()
self._skeleton_to_drive_stringfield = ui.StringField(
model=ui.SimpleStringModel(SKEL_INVALID_TEXT), height=0, enabled=False
)
ui.Spacer()
ui.Spacer(width=CS_H_SPACING)
self._skel_select_button = ui.Button(
SKEL_SOURCE_BTN_TEXT, width=0, clicked_fn=self.select_skeleton
)
# rig selection
with ui.HStack():
ui.Label(RIG_DROPDOWN_TEXT, width=ui.Percent(20), alignment=ui.Alignment.RIGHT_CENTER)
ui.Spacer(width=CS_H_SPACING)
with ui.VStack(width=ui.Percent(75)):
ui.Spacer()
self._selected_rig_label = ui.Label("")
ui.Spacer()
# start/stop stream buttons
with ui.HStack():
ui.Spacer(width=ui.Percent(20))
self._start_button = ui.Button(
CS_START_BTN_TEXT,
width=0,
clicked_fn=self.start_streaming,
enabled=not self.streaming_active,
style=style_btn_disabled if self.streaming_active else style_btn_enabled,
)
ui.Spacer(width=CS_H_SPACING)
self._stop_button = ui.Button(
CS_STOP_BTN_TEXT,
width=0,
clicked_fn=self.stop_streaming,
enabled=self.streaming_active,
style=style_btn_enabled if self.streaming_active else style_btn_disabled,
)
ui.Spacer(height=5)
def shutdown(self):
self._window.frame.clear()
self._window = None
def select_skeleton(self):
paths = omni.usd.get_context().get_selection().get_selected_prim_paths()
if paths:
path = paths[0]
try:
self.ext.init_skeletons(path)
except Exception as ex:
self._skeleton_to_drive_stringfield.model.set_value(SKEL_INVALID_TEXT)
self._selected_rig_label.text = self.ext.selected_rig_name or RIG_UNSUPPORTED_TEXT
def launch_motionverse_website(self):
webbrowser.open_new_tab(CS_URL)
def update_ui(self):
if self.streaming_active:
self._start_button.enabled = False
self._start_button.set_style(style_btn_disabled)
self._stop_button.enabled = True
self._stop_button.set_style(style_btn_enabled)
else:
self._start_button.enabled = self.ext.ready_to_stream
self._start_button.set_style(
style_btn_enabled if self.ext.ready_to_stream else style_btn_disabled
)
self._stop_button.enabled = False
self._stop_button.set_style(style_btn_disabled)
if self.streaming_active:
self._status_circle.set_style(style_status_circle_green)
else:
self._status_circle.set_style(style_status_circle_red)
self._skeleton_to_drive_stringfield.model.set_value(self.ext.target_skeleton_path)
def start_streaming(self):
self.ext.connect()
def stop_streaming(self):
self.ext.disconnect("User cancelled")
@property
def streaming_active(self):
return self._streaming_active
@streaming_active.setter
def streaming_active(self, value):
self._streaming_active = value | 7,135 | Python | 40.730994 | 177 | 0.476524 |
matiascodesal/omni-camera-reticle/README.md | # Camera Reticle Omniverse Extension
The Camera Reticle extension adds a new menu button to all viewports. From this menu, users can enable and configure:
1. Composition Guidelines
2. Safe Area Guidelines
3. Letterbox
I created this to learn and test the Kit SDK. To have a clear design target, I designed the UI as a look-alike of
the similar Unreal Engine Cinematic Viewport control. Even though this was just a test, feel free to use this
extension to help compose your shots or as an example to learn from.
## Adding This Extension
To add a this extension to your Omniverse app:
1. Go into: Extension Manager -> Gear Icon -> Extension Search Path
2. Add this as a search path: `git://github.com/matiascodesal/omni-camera-reticle.git?branch=main&dir=exts` | 910 | Markdown | 46.947366 | 117 | 0.785714 |
matiascodesal/omni-camera-reticle/tools/scripts/link_app.py | import os
import argparse
import sys
import json
import packmanapi
import urllib3
def find_omniverse_apps():
http = urllib3.PoolManager()
try:
r = http.request("GET", "http://127.0.0.1:33480/components")
except Exception as e:
print(f"Failed retrieving apps from an Omniverse Launcher, maybe it is not installed?\nError: {e}")
sys.exit(1)
apps = {}
for x in json.loads(r.data.decode("utf-8")):
latest = x.get("installedVersions", {}).get("latest", "")
if latest:
for s in x.get("settings", []):
if s.get("version", "") == latest:
root = s.get("launch", {}).get("root", "")
apps[x["slug"]] = (x["name"], root)
break
return apps
def create_link(src, dst):
print(f"Creating a link '{src}' -> '{dst}'")
packmanapi.link(src, dst)
APP_PRIORITIES = ["code", "create", "view"]
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="Create folder link to Kit App installed from Omniverse Launcher")
parser.add_argument(
"--path",
help="Path to Kit App installed from Omniverse Launcher, e.g.: 'C:/Users/bob/AppData/Local/ov/pkg/create-2021.3.4'",
required=False,
)
parser.add_argument(
"--app", help="Name of Kit App installed from Omniverse Launcher, e.g.: 'code', 'create'", required=False
)
args = parser.parse_args()
path = args.path
if not path:
print("Path is not specified, looking for Omniverse Apps...")
apps = find_omniverse_apps()
if len(apps) == 0:
print(
"Can't find any Omniverse Apps. Use Omniverse Launcher to install one. 'Code' is the recommended app for developers."
)
sys.exit(0)
print("\nFound following Omniverse Apps:")
for i, slug in enumerate(apps):
name, root = apps[slug]
print(f"{i}: {name} ({slug}) at: '{root}'")
if args.app:
selected_app = args.app.lower()
if selected_app not in apps:
choices = ", ".join(apps.keys())
print(f"Passed app: '{selected_app}' is not found. Specify one of the following found Apps: {choices}")
sys.exit(0)
else:
selected_app = next((x for x in APP_PRIORITIES if x in apps), None)
if not selected_app:
selected_app = next(iter(apps))
print(f"\nSelected app: {selected_app}")
_, path = apps[selected_app]
if not os.path.exists(path):
print(f"Provided path doesn't exist: {path}")
else:
SCRIPT_ROOT = os.path.dirname(os.path.realpath(__file__))
create_link(f"{SCRIPT_ROOT}/../../app", path)
print("Success!")
| 2,813 | Python | 32.5 | 133 | 0.562389 |
matiascodesal/omni-camera-reticle/tools/packman/config.packman.xml | <config remotes="cloudfront">
<remote2 name="cloudfront">
<transport actions="download" protocol="https" packageLocation="d4i3qtqj3r0z5.cloudfront.net/${name}@${version}" />
</remote2>
</config>
| 211 | XML | 34.333328 | 123 | 0.691943 |
matiascodesal/omni-camera-reticle/tools/packman/bootstrap/install_package.py | # Copyright 2019 NVIDIA CORPORATION
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import logging
import zipfile
import tempfile
import sys
import shutil
__author__ = "hfannar"
logging.basicConfig(level=logging.WARNING, format="%(message)s")
logger = logging.getLogger("install_package")
class TemporaryDirectory:
def __init__(self):
self.path = None
def __enter__(self):
self.path = tempfile.mkdtemp()
return self.path
def __exit__(self, type, value, traceback):
# Remove temporary data created
shutil.rmtree(self.path)
def install_package(package_src_path, package_dst_path):
with zipfile.ZipFile(
package_src_path, allowZip64=True
) as zip_file, TemporaryDirectory() as temp_dir:
zip_file.extractall(temp_dir)
# Recursively copy (temp_dir will be automatically cleaned up on exit)
try:
# Recursive copy is needed because both package name and version folder could be missing in
# target directory:
shutil.copytree(temp_dir, package_dst_path)
except OSError as exc:
logger.warning(
"Directory %s already present, packaged installation aborted" % package_dst_path
)
else:
logger.info("Package successfully installed to %s" % package_dst_path)
install_package(sys.argv[1], sys.argv[2])
| 1,888 | Python | 31.568965 | 103 | 0.68697 |
matiascodesal/omni-camera-reticle/exts/maticodes.viewport.reticle/maticodes/viewport/reticle/styles.py | from pathlib import Path
import omni.ui as ui
from omni.ui import color as cl
CURRENT_PATH = Path(__file__).parent.absolute()
ICON_PATH = CURRENT_PATH.parent.parent.parent.joinpath("icons")
cl.action_safe_default = cl(1.0, 0.0, 0.0)
cl.title_safe_default = cl(1.0, 1.0, 0.0)
cl.custom_safe_default = cl(0.0, 1.0, 0.0)
cl.letterbox_default = cl(0.0, 0.0, 0.0, 0.75)
cl.comp_lines_default = cl(1.0, 1.0, 1.0, 0.6)
safe_areas_group_style = {
"Label:disabled": {
"color": cl(1.0, 1.0, 1.0, 0.2)
},
"FloatSlider:enabled": {
"draw_mode": ui.SliderDrawMode.HANDLE,
"background_color": cl(0.75, 0.75, 0.75, 1),
"color": cl.black
},
"FloatSlider:disabled": {
"draw_mode": ui.SliderDrawMode.HANDLE,
"background_color": cl(0.75, 0.75, 0.75, 0.2),
"color": cl(0.0, 0.0, 1.0, 0.2)
},
"CheckBox": {
"background_color": cl(0.75, 0.75, 0.75, 1),
"color": cl.black
},
"Rectangle::ActionSwatch": {
"background_color": cl.action_safe_default
},
"Rectangle::TitleSwatch": {
"background_color": cl.title_safe_default
},
"Rectangle::CustomSwatch": {
"background_color": cl.custom_safe_default
}
}
comp_group_style = {
"Button.Image::Off": {
"image_url": str(ICON_PATH / "off.png")
},
"Button.Image::Thirds": {
"image_url": str(ICON_PATH / "thirds.png")
},
"Button.Image::Quad": {
"image_url": str(ICON_PATH / "quad.png")
},
"Button.Image::Crosshair": {
"image_url": str(ICON_PATH / "crosshair.png")
},
"Button:checked": {
"background_color": cl(1.0, 1.0, 1.0, 0.2)
}
}
| 1,688 | Python | 26.688524 | 63 | 0.560427 |
matiascodesal/omni-camera-reticle/exts/maticodes.viewport.reticle/maticodes/viewport/reticle/constants.py | """Constants used by the CameraReticleExtension"""
import enum
class CompositionGuidelines(enum.IntEnum):
"""Enum representing all of the composition modes."""
OFF = 0
THIRDS = 1
QUAD = 2
CROSSHAIR = 3
DEFAULT_ACTION_SAFE_PERCENTAGE = 93
DEFAULT_TITLE_SAFE_PERCENTAGE = 90
DEFAULT_CUSTOM_SAFE_PERCENTAGE = 85
DEFAULT_LETTERBOX_RATIO = 2.35
DEFAULT_COMPOSITION_MODE = CompositionGuidelines.OFF
SETTING_RESOLUTION_WIDTH = "/app/renderer/resolution/width"
SETTING_RESOLUTION_HEIGHT = "/app/renderer/resolution/height"
SETTING_RESOLUTION_FILL = "/app/runLoops/rendering_0/fillResolution"
| 609 | Python | 26.727272 | 68 | 0.760263 |
matiascodesal/omni-camera-reticle/exts/maticodes.viewport.reticle/maticodes/viewport/reticle/extension.py | import carb
import omni.ext
from omni.kit.viewport.utility import get_active_viewport_window
from . import constants
from .models import ReticleModel
from .views import ReticleOverlay
class CameraReticleExtension(omni.ext.IExt):
def on_startup(self, ext_id):
carb.log_info("[maticodes.viewport.reticle] CameraReticleExtension startup")
# Reticle should ideally be used with "Fill Viewport" turned off.
settings = carb.settings.get_settings()
settings.set(constants.SETTING_RESOLUTION_FILL, False)
viewport_window = get_active_viewport_window()
if viewport_window is not None:
reticle_model = ReticleModel()
self.reticle = ReticleOverlay(reticle_model, viewport_window, ext_id)
self.reticle.build_viewport_overlay()
def on_shutdown(self):
""" Executed when the extension is disabled."""
carb.log_info("[maticodes.viewport.reticle] CameraReticleExtension shutdown")
self.reticle.destroy()
| 1,010 | Python | 33.862068 | 85 | 0.70495 |
matiascodesal/omni-camera-reticle/exts/maticodes.viewport.reticle/maticodes/viewport/reticle/__init__.py | from .extension import CameraReticleExtension
| 46 | Python | 22.499989 | 45 | 0.891304 |
matiascodesal/omni-camera-reticle/exts/maticodes.viewport.reticle/maticodes/viewport/reticle/models.py | """Models used by the CameraReticleExtension"""
import omni.ui as ui
from . import constants
class ReticleModel:
"""Model containing all of the data used by the ReticleOverlay and ReticleMenu
The ReticleOverlay and ReticleMenu classes need to share the same data and stay
in sync with updates from user input. This is achieve by passing the same
ReticleModel object to both classes.
"""
def __init__(self):
self.composition_mode = ui.SimpleIntModel(constants.DEFAULT_COMPOSITION_MODE)
self.action_safe_enabled = ui.SimpleBoolModel(False)
self.action_safe_percentage = ui.SimpleFloatModel(constants.DEFAULT_ACTION_SAFE_PERCENTAGE, min=0, max=100)
self.title_safe_enabled = ui.SimpleBoolModel(False)
self.title_safe_percentage = ui.SimpleFloatModel(constants.DEFAULT_TITLE_SAFE_PERCENTAGE, min=0, max=100)
self.custom_safe_enabled = ui.SimpleBoolModel(False)
self.custom_safe_percentage = ui.SimpleFloatModel(constants.DEFAULT_CUSTOM_SAFE_PERCENTAGE, min=0, max=100)
self.letterbox_enabled = ui.SimpleBoolModel(False)
self.letterbox_ratio = ui.SimpleFloatModel(constants.DEFAULT_LETTERBOX_RATIO, min=0.001)
self._register_submodel_callbacks()
self._callbacks = []
def _register_submodel_callbacks(self):
"""Register to listen to when any submodel values change."""
self.composition_mode.add_value_changed_fn(self._reticle_changed)
self.action_safe_enabled.add_value_changed_fn(self._reticle_changed)
self.action_safe_percentage.add_value_changed_fn(self._reticle_changed)
self.title_safe_enabled.add_value_changed_fn(self._reticle_changed)
self.title_safe_percentage.add_value_changed_fn(self._reticle_changed)
self.custom_safe_enabled.add_value_changed_fn(self._reticle_changed)
self.custom_safe_percentage.add_value_changed_fn(self._reticle_changed)
self.letterbox_enabled.add_value_changed_fn(self._reticle_changed)
self.letterbox_ratio.add_value_changed_fn(self._reticle_changed)
def _reticle_changed(self, model):
"""Executes all registered callbacks of this model.
Args:
model (Any): The submodel that has changed. [Unused]
"""
for callback in self._callbacks:
callback()
def add_reticle_changed_fn(self, callback):
"""Add a callback to be executed whenever any ReticleModel submodel data changes.
This is useful for rebuilding the overlay whenever any data changes.
Args:
callback (function): The function to call when the reticle model changes.
"""
self._callbacks.append(callback)
| 2,712 | Python | 44.98305 | 115 | 0.703171 |
matiascodesal/omni-camera-reticle/exts/maticodes.viewport.reticle/maticodes/viewport/reticle/views.py | from functools import partial
import carb
import omni.ui as ui
from omni.ui import color as cl
from omni.ui import scene
from . import constants
from .constants import CompositionGuidelines
from .models import ReticleModel
from . import styles
class ReticleOverlay:
"""The reticle viewport overlay.
Build the reticle graphics and ReticleMenu button on the given viewport window.
"""
_instances = []
def __init__(self, model: ReticleModel, vp_win: ui.Window, ext_id: str):
"""ReticleOverlay constructor
Args:
model (ReticleModel): The reticle model
vp_win (Window): The viewport window to build the overlay on.
ext_id (str): The extension id.
"""
self.model = model
self.vp_win = vp_win
self.ext_id = ext_id
# Rebuild the overlay whenever the viewport window changes
self.vp_win.set_height_changed_fn(self.on_window_changed)
self.vp_win.set_width_changed_fn(self.on_window_changed)
self._view_change_sub = None
try:
# VP2 resolution change sub
self._view_change_sub = self.vp_win.viewport_api.subscribe_to_view_change(self.on_window_changed)
except AttributeError:
carb.log_info("Using Viewport Legacy: Reticle will not automatically update on resolution changes.")
# Rebuild the overlay whenever the model changes
self.model.add_reticle_changed_fn(self.build_viewport_overlay)
ReticleOverlay._instances.append(self)
resolution = self.vp_win.viewport_api.get_texture_resolution()
self._aspect_ratio = resolution[0] / resolution[1]
@classmethod
def get_instances(cls):
"""Get all created instances of ReticleOverlay"""
return cls._instances
def __del__(self):
self.destroy()
def destroy(self):
self._view_change_sub = None
self.scene_view.scene.clear()
self.scene_view = None
self.reticle_menu.destroy()
self.reticle_menu = None
self.vp_win = None
def on_window_changed(self, *args):
"""Update aspect ratio and rebuild overlay when viewport window changes."""
if self.vp_win is None:
return
settings = carb.settings.get_settings()
if type(self.vp_win).__name__ == "LegacyViewportWindow":
fill = settings.get(constants.SETTING_RESOLUTION_FILL)
else:
fill = self.vp_win.viewport_api.fill_frame
if fill:
width = self.vp_win.frame.computed_width + 8
height = self.vp_win.height
else:
width, height = self.vp_win.viewport_api.resolution
self._aspect_ratio = width / height
self.build_viewport_overlay()
def get_aspect_ratio_flip_threshold(self):
"""Get magic number for aspect ratio policy.
Aspect ratio policy doesn't seem to swap exactly when window_aspect_ratio == window_texture_aspect_ratio.
This is a hack that approximates where the policy changes.
"""
return self.get_aspect_ratio() - self.get_aspect_ratio() * 0.05
def build_viewport_overlay(self, *args):
"""Build all viewport graphics and ReticleMenu button."""
if self.vp_win is not None:
with self.vp_win.get_frame(self.ext_id):
with ui.ZStack():
# Set the aspect ratio policy depending if the viewport is wider than it is taller or vice versa.
if self.vp_win.width / self.vp_win.height > self.get_aspect_ratio_flip_threshold():
self.scene_view = scene.SceneView(aspect_ratio_policy=scene.AspectRatioPolicy.PRESERVE_ASPECT_VERTICAL)
else:
self.scene_view = scene.SceneView(aspect_ratio_policy=scene.AspectRatioPolicy.PRESERVE_ASPECT_HORIZONTAL)
# Build all the scene view guidelines
with self.scene_view.scene:
if self.model.composition_mode.as_int == CompositionGuidelines.THIRDS:
self._build_thirds()
elif self.model.composition_mode.as_int == CompositionGuidelines.QUAD:
self._build_quad()
elif self.model.composition_mode.as_int == CompositionGuidelines.CROSSHAIR:
self._build_crosshair()
if self.model.action_safe_enabled.as_bool:
self._build_safe_rect(self.model.action_safe_percentage.as_float / 100.0,
color=cl.action_safe_default)
if self.model.title_safe_enabled.as_bool:
self._build_safe_rect(self.model.title_safe_percentage.as_float / 100.0,
color=cl.title_safe_default)
if self.model.custom_safe_enabled.as_bool:
self._build_safe_rect(self.model.custom_safe_percentage.as_float / 100.0,
color=cl.custom_safe_default)
if self.model.letterbox_enabled.as_bool:
self._build_letterbox()
# Build ReticleMenu button
with ui.VStack():
ui.Spacer()
with ui.HStack(height=0):
ui.Spacer()
self.reticle_menu = ReticleMenu(self.model)
def _build_thirds(self):
"""Build the scene ui graphics for the Thirds composition mode."""
aspect_ratio = self.get_aspect_ratio()
line_color = cl.comp_lines_default
inverse_ratio = 1 / aspect_ratio
if self.scene_view.aspect_ratio_policy == scene.AspectRatioPolicy.PRESERVE_ASPECT_VERTICAL:
scene.Line([-0.333 * aspect_ratio, -1, 0], [-0.333 * aspect_ratio, 1, 0], color=line_color)
scene.Line([0.333 * aspect_ratio, -1, 0], [0.333 * aspect_ratio, 1, 0], color=line_color)
scene.Line([-aspect_ratio, -0.333, 0], [aspect_ratio, -0.333, 0], color=line_color)
scene.Line([-aspect_ratio, 0.333, 0], [aspect_ratio, 0.333, 0], color=line_color)
else:
scene.Line([-1, -0.333 * inverse_ratio, 0], [1, -0.333 * inverse_ratio, 0], color=line_color)
scene.Line([-1, 0.333 * inverse_ratio, 0], [1, 0.333 * inverse_ratio, 0], color=line_color)
scene.Line([-0.333, -inverse_ratio, 0], [-0.333, inverse_ratio, 0], color=line_color)
scene.Line([0.333, -inverse_ratio, 0], [0.333, inverse_ratio, 0], color=line_color)
def _build_quad(self):
"""Build the scene ui graphics for the Quad composition mode."""
aspect_ratio = self.get_aspect_ratio()
line_color = cl.comp_lines_default
inverse_ratio = 1 / aspect_ratio
if self.scene_view.aspect_ratio_policy == scene.AspectRatioPolicy.PRESERVE_ASPECT_VERTICAL:
scene.Line([0, -1, 0], [0, 1, 0], color=line_color)
scene.Line([-aspect_ratio, 0, 0], [aspect_ratio, 0, 0], color=line_color)
else:
scene.Line([0, -inverse_ratio, 0], [0, inverse_ratio, 0], color=line_color)
scene.Line([-1, 0, 0], [1, 0, 0], color=line_color)
def _build_crosshair(self):
"""Build the scene ui graphics for the Crosshair composition mode."""
aspect_ratio = self.get_aspect_ratio()
line_color = cl.comp_lines_default
if self.scene_view.aspect_ratio_policy == scene.AspectRatioPolicy.PRESERVE_ASPECT_VERTICAL:
scene.Line([0, 0.05 * aspect_ratio, 0], [0, 0.1 * aspect_ratio, 0], color=line_color)
scene.Line([0, -0.05 * aspect_ratio, 0], [0, -0.1 * aspect_ratio, 0], color=line_color)
scene.Line([0.05 * aspect_ratio, 0, 0], [0.1 * aspect_ratio, 0, 0], color=line_color)
scene.Line([-0.05 * aspect_ratio, 0, 0], [-0.1 * aspect_ratio, 0, 0], color=line_color)
else:
scene.Line([0, 0.05 * 1, 0], [0, 0.1 * 1, 0], color=line_color)
scene.Line([0, -0.05 * 1, 0], [0, -0.1 * 1, 0], color=line_color)
scene.Line([0.05 * 1, 0, 0], [0.1 * 1, 0, 0], color=line_color)
scene.Line([-0.05 * 1, 0, 0], [-0.1 * 1, 0, 0], color=line_color)
scene.Points([[0.00005, 0, 0]], sizes=[2], colors=[line_color])
def _build_safe_rect(self, percentage, color):
"""Build the scene ui graphics for the safe area rectangle
Args:
percentage (float): The 0-1 percentage the render target that the rectangle should fill.
color: The color to draw the rectangle wireframe with.
"""
aspect_ratio = self.get_aspect_ratio()
inverse_ratio = 1 / aspect_ratio
if self.scene_view.aspect_ratio_policy == scene.AspectRatioPolicy.PRESERVE_ASPECT_VERTICAL:
scene.Rectangle(aspect_ratio*2*percentage, 1*2*percentage, thickness=1, wireframe=True, color=color)
else:
scene.Rectangle(1*2*percentage, inverse_ratio*2*percentage, thickness=1, wireframe=True, color=color)
def _build_letterbox(self):
"""Build the scene ui graphics for the letterbox."""
aspect_ratio = self.get_aspect_ratio()
letterbox_color = cl.letterbox_default
letterbox_ratio = self.model.letterbox_ratio.as_float
def build_letterbox_helper(width, height, x_offset, y_offset):
move = scene.Matrix44.get_translation_matrix(x_offset, y_offset, 0)
with scene.Transform(transform=move):
scene.Rectangle(width * 2, height * 2, thickness=0, wireframe=False, color=letterbox_color)
move = scene.Matrix44.get_translation_matrix(-x_offset, -y_offset, 0)
with scene.Transform(transform=move):
scene.Rectangle(width * 2, height * 2, thickness=0, wireframe=False, color=letterbox_color)
if self.scene_view.aspect_ratio_policy == scene.AspectRatioPolicy.PRESERVE_ASPECT_VERTICAL:
if letterbox_ratio >= aspect_ratio:
height = 1 - aspect_ratio / letterbox_ratio
rect_height = height / 2
rect_offset = 1 - rect_height
build_letterbox_helper(aspect_ratio, rect_height, 0, rect_offset)
else:
width = aspect_ratio - letterbox_ratio
rect_width = width / 2
rect_offset = aspect_ratio - rect_width
build_letterbox_helper(rect_width, 1, rect_offset, 0)
else:
inverse_ratio = 1 / aspect_ratio
if letterbox_ratio >= aspect_ratio:
height = inverse_ratio - 1 / letterbox_ratio
rect_height = height / 2
rect_offset = inverse_ratio - rect_height
build_letterbox_helper(1, rect_height, 0, rect_offset)
else:
width = (aspect_ratio - letterbox_ratio) * inverse_ratio
rect_width = width / 2
rect_offset = 1 - rect_width
build_letterbox_helper(rect_width, inverse_ratio, rect_offset, 0)
def get_aspect_ratio(self):
"""Get the aspect ratio of the viewport.
Returns:
float: The viewport aspect ratio.
"""
return self._aspect_ratio
class ReticleMenu:
"""The popup reticle menu"""
def __init__(self, model: ReticleModel):
"""ReticleMenu constructor
Stores the model and builds the Reticle button.
Args:
model (ReticleModel): The reticle model
"""
self.model = model
self.button = ui.Button("Reticle", width=0, height=0, mouse_pressed_fn=self.show_reticle_menu,
style={"margin": 10, "padding": 5, "color": cl.white})
self.reticle_menu = None
def destroy(self):
self.button.destroy()
self.button = None
self.reticle_menu = None
def on_group_check_changed(self, safe_area_group, model):
"""Enables/disables safe area groups
When a safe area checkbox state changes, all the widgets of the respective
group should be enabled/disabled.
Args:
safe_area_group (HStack): The safe area group to enable/disable
model (SimpleBoolModel): The safe group checkbox model.
"""
safe_area_group.enabled = model.as_bool
def on_composition_mode_changed(self, guideline_type):
"""Sets the selected composition mode.
When a composition button is clicked, it should be checked on and the other
buttons should be checked off. Sets the composition mode on the ReticleModel too.
Args:
guideline_type (_type_): _description_
"""
self.model.composition_mode.set_value(guideline_type)
self.comp_off_button.checked = guideline_type == CompositionGuidelines.OFF
self.comp_thirds_button.checked = guideline_type == CompositionGuidelines.THIRDS
self.comp_quad_button.checked = guideline_type == CompositionGuidelines.QUAD
self.comp_crosshair_button.checked = guideline_type == CompositionGuidelines.CROSSHAIR
def show_reticle_menu(self, x, y, button, modifier):
"""Build and show the reticle menu popup."""
self.reticle_menu = ui.Menu("Reticle", width=400, height=200)
self.reticle_menu.clear()
with self.reticle_menu:
with ui.Frame(width=0, height=100):
with ui.HStack():
with ui.VStack():
ui.Label("Composition", alignment=ui.Alignment.LEFT, height=30)
with ui.VGrid(style=styles.comp_group_style, width=150, height=0,
column_count=2, row_height=75):
current_comp_mode = self.model.composition_mode.as_int
with ui.HStack():
off_checked = current_comp_mode == CompositionGuidelines.OFF
callback = partial(self.on_composition_mode_changed, CompositionGuidelines.OFF)
self.comp_off_button = ui.Button("Off", name="Off", checked=off_checked,
width=70, height=70, clicked_fn=callback)
with ui.HStack():
thirds_checked = current_comp_mode == CompositionGuidelines.THIRDS
callback = partial(self.on_composition_mode_changed, CompositionGuidelines.THIRDS)
self.comp_thirds_button = ui.Button("Thirds", name="Thirds", checked=thirds_checked,
width=70, height=70, clicked_fn=callback)
with ui.HStack():
quad_checked = current_comp_mode == CompositionGuidelines.QUAD
callback = partial(self.on_composition_mode_changed, CompositionGuidelines.QUAD)
self.comp_quad_button = ui.Button("Quad", name="Quad", checked=quad_checked,
width=70, height=70, clicked_fn=callback)
with ui.HStack():
crosshair_checked = current_comp_mode == CompositionGuidelines.CROSSHAIR
callback = partial(self.on_composition_mode_changed,
CompositionGuidelines.CROSSHAIR)
self.comp_crosshair_button = ui.Button("Crosshair", name="Crosshair",
checked=crosshair_checked, width=70, height=70,
clicked_fn=callback)
ui.Spacer(width=10)
with ui.VStack(style=styles.safe_areas_group_style):
ui.Label("Safe Areas", alignment=ui.Alignment.LEFT, height=30)
with ui.HStack(width=0):
ui.Spacer(width=20)
cb = ui.CheckBox(model=self.model.action_safe_enabled)
action_safe_group = ui.HStack(enabled=self.model.action_safe_enabled.as_bool)
callback = partial(self.on_group_check_changed, action_safe_group)
cb.model.add_value_changed_fn(callback)
with action_safe_group:
ui.Spacer(width=10)
ui.Label("Action Safe", alignment=ui.Alignment.TOP)
ui.Spacer(width=14)
with ui.VStack():
ui.FloatSlider(self.model.action_safe_percentage, width=100,
format="%.0f%%", min=0, max=100, step=1)
ui.Rectangle(name="ActionSwatch", height=5)
ui.Spacer()
with ui.HStack(width=0):
ui.Spacer(width=20)
cb = ui.CheckBox(model=self.model.title_safe_enabled)
title_safe_group = ui.HStack(enabled=self.model.title_safe_enabled.as_bool)
callback = partial(self.on_group_check_changed, title_safe_group)
cb.model.add_value_changed_fn(callback)
with title_safe_group:
ui.Spacer(width=10)
ui.Label("Title Safe", alignment=ui.Alignment.TOP)
ui.Spacer(width=25)
with ui.VStack():
ui.FloatSlider(self.model.title_safe_percentage, width=100,
format="%.0f%%", min=0, max=100, step=1)
ui.Rectangle(name="TitleSwatch", height=5)
ui.Spacer()
with ui.HStack(width=0):
ui.Spacer(width=20)
cb = ui.CheckBox(model=self.model.custom_safe_enabled)
custom_safe_group = ui.HStack(enabled=self.model.custom_safe_enabled.as_bool)
callback = partial(self.on_group_check_changed, custom_safe_group)
cb.model.add_value_changed_fn(callback)
with custom_safe_group:
ui.Spacer(width=10)
ui.Label("Custom Safe", alignment=ui.Alignment.TOP)
ui.Spacer(width=5)
with ui.VStack():
ui.FloatSlider(self.model.custom_safe_percentage, width=100,
format="%.0f%%", min=0, max=100, step=1)
ui.Rectangle(name="CustomSwatch", height=5)
ui.Spacer()
ui.Label("Letterbox", alignment=ui.Alignment.LEFT, height=30)
with ui.HStack(width=0):
ui.Spacer(width=20)
cb = ui.CheckBox(model=self.model.letterbox_enabled)
letterbox_group = ui.HStack(enabled=self.model.letterbox_enabled.as_bool)
callback = partial(self.on_group_check_changed, letterbox_group)
cb.model.add_value_changed_fn(callback)
with letterbox_group:
ui.Spacer(width=10)
ui.Label("Letterbox Ratio", alignment=ui.Alignment.TOP)
ui.Spacer(width=5)
ui.FloatDrag(self.model.letterbox_ratio, width=35, min=0.001, step=0.01)
self.reticle_menu.show_at(x - self.reticle_menu.width, y - self.reticle_menu.height)
| 20,348 | Python | 52.691293 | 129 | 0.543886 |
matiascodesal/omni-camera-reticle/exts/maticodes.viewport.reticle/maticodes/viewport/reticle/tests/reticle_tests.py | """ Tests Module
TODO:
* Write actual tests.
"""
from pathlib import Path
from typing import Optional
import carb
import omni.kit
import omni.ui as ui
from omni.ui.tests.test_base import OmniUiTest
from maticodes.viewport.reticle.extension import CameraReticleExtension
CURRENT_PATH = Path(__file__).parent.joinpath("../../../../data")
class TestReticle(OmniUiTest):
# Before running each test
async def setUp(self):
await super().setUp()
self._golden_img_dir = CURRENT_PATH.absolute().resolve().joinpath("tests")
self._all_widgets = []
self._settings = carb.settings.get_settings()
self._original_value = self._settings.get_as_int("/persistent/app/viewport/displayOptions")
self._settings.set_int("/persistent/app/viewport/displayOptions", 0)
# Create test area
await self.create_test_area(256, 256)
window_flags = ui.WINDOW_FLAGS_NO_SCROLLBAR | ui.WINDOW_FLAGS_NO_TITLE_BAR | ui.WINDOW_FLAGS_NO_RESIZE
self._test_window = ui.Window(
"Viewport",
dockPreference=ui.DockPreference.DISABLED,
flags=window_flags,
width=256,
height=256,
position_x=0,
position_y=0,
)
# Override default background
self._test_window.frame.set_style({"Window": {"background_color": 0xFF000000, "border_color": 0x0, "border_radius": 0}})
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
# After running each test
async def tearDown(self):
self._golden_img_dir = None
self._test_window = None
self._settings.set_int("/persistent/app/viewport/displayOptions", self._original_value)
await super().tearDown()
async def test_reticle_menu_button(self):
await self.finalize_test(golden_img_dir=self._golden_img_dir, golden_img_name="test_reticle_menu_button.png")
| 1,962 | Python | 32.844827 | 128 | 0.649847 |
matiascodesal/omni-camera-reticle/exts/maticodes.viewport.reticle/maticodes/viewport/reticle/tests/__init__.py | from maticodes.viewport.reticle.tests.reticle_tests import TestReticle | 70 | Python | 69.99993 | 70 | 0.885714 |
matiascodesal/omni-camera-reticle/exts/maticodes.viewport.reticle/config/extension.toml | [package]
version = "1.4.0"
title = "Camera Reticle"
description="Adds a camera reticle featuring composition guidelines, safe area guidelines, and letterbox."
authors=["Matias Codesal <[email protected]>"]
readme = "docs/README.md"
changelog="docs/CHANGELOG.md"
repository = ""
category = "Rendering"
keywords = ["camera", "reticle", "viewport"]
preview_image = "data/preview.png"
icon = "icons/icon.png"
# Use omni.ui to build simple UI
[dependencies]
"omni.ui.scene" = {}
"omni.kit.viewport.utility" = {}
# Main python module this extension provides, it will be publicly available as "import omni.hello.world".
[[python.module]]
name = "maticodes.viewport.reticle"
| 677 | TOML | 28.47826 | 106 | 0.734121 |
matiascodesal/omni-camera-reticle/exts/maticodes.viewport.reticle/docs/CHANGELOG.md | # Changelog
All notable changes to this project will be documented in this file.
## [Unreleased]
## [1.4.0] - 2022-09-09
### Added
- Fixed bad use of viewport window frame for VP Next
- Now use ViewportAPI.subscribe_to_view_change() on VP Next
## [1.3.0] - 2022-07-10
### Added
- `omni.kit.viewport.utility` dependency.
### Changed
- Refactored to use `omni.kit.viewport.utility`. (Only works with Kit 103.1.2+ now.)
- Renamed `reticle.py` to `views.py`
- Moved **Reticle** button to the bottom right of the viewport instead of bottom left.
## [1.2.0] - 2022-05-24
### Changed
- Refactored to use VP1 instead of hybrid VP1/2
- Renamed "draw" functions to "build"
- Moved color constants to omni.ui.color
## [1.1.0] - 2022-03-31
### Changed
- Improved the cleanup code when the extension is shutdown.
## [1.0.0] - 2022-03-28
### Added
- Added extension icon
- Applies overlay to all existing viewports on extension startup
- Added docstrings
- Refactored to use Model-View pattern
- Now supports when viewport is narrower than the render resolution aspect ratio.
## [0.1.0] - 2022-03-25
### Added
- Initial add of the Camera Reticle extension. | 1,150 | Markdown | 27.774999 | 86 | 0.712174 |
matiascodesal/omni-camera-reticle/exts/maticodes.viewport.reticle/docs/README.md | # Camera Reticle Omniverse Extension
The Camera Reticle extension adds a new menu button to all viewports. From this menu, users can enable and configure:
1. Composition Guidelines
2. Safe Area Guidelines
3. Letterbox
I created this to learn and test the Kit SDK. To have a clear design target, I designed the UI as a look-alike of
the similar Unreal Engine Cinematic Viewport control. Even though this was just a test, feel free to use this
extension to help compose your shots or as an example to learn from.
## Adding This Extension
To add a this extension to your Omniverse app:
1. Go into: Extension Manager -> Gear Icon -> Extension Search Path
2. Add this as a search path: `git://github.com/matiascodesal/omni-camera-reticle.git?branch=main&dir=exts` | 910 | Markdown | 46.947366 | 117 | 0.785714 |
heavyai/omni-component/README.md | # HEAVY.AI | Omni.Ui Component System
This component system was first presented during a NVIDIA Partner Spotlight with HEAVY.AI and can be found [here on YouTube](https://youtu.be/QhBMgx2G86g?t=1640)
## Goals
1. Provide a means to encapsulate functions and `omni.ui` widgets to modularize UI code by its purpose to enforce boundaries using separation of concerns
2. Standardize the creation and implementation of UI components in a manner that enforces self-documentation and a homogenous UI codebase
3. Provide the utility of updating and re-rendering specific components without re-rendering components that have not changed
## Examples
### Hello World
```python
from heavyai.ui.component import Component
class SimpleLabel(Component):
def render(self):
ui.Label("Hello World")
# USAGE
SimpleLabel()
class CustomLabel(Component):
value: str = "Hello World"
def render(self):
ui.Label(self.value)
# USAGE
CustomLabel(value="Hello There")
```
### Internal State
```python
from heavyai.ui.component import Component
class ButtonCounter(Component):
value: int = 0
on_change: Optional[Callable[[int], None]]
def _handle_click(self):
self.value += 1
if self.on_change:
self.on_change(self.value)
self.update()
def render(self):
with self.get_root(ui.HStack):
ui.Label(str(self.value))
ui.Button("Increment", clicked_fn=self._handle_click()
# USAGE
ButtonCounter(on_change=lambda val: print(val))
```
### Subscribing Components
```python
from heavyai.ui.component import Component
class UsdSubscribingComponent(Component):
prim: pxr.Usd.Prim
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.subscription: carb.Subscription = (
usd.get_watcher().subscribe_to_change_info_path(
path=self.prim.GetPath(), on_change=self._handle_prim_change
)
)
def _handle_prim_change(self, prim_attr_path):
self.update()
def render(self):
with self.get_root(ui.VStack):
pass
def destroy(self):
self.subscription.unsubscribe()
class AbstractModelSubscribingComponent(Component):
model: sc.AbstractManipulatorModel
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.subscription: carb.Subscription = (
self.model.subscribe_item_changed_fn(
self._handle_model_item_changed
)
)
def _handle_model_item_changed(self, model, item):
self.update()
def render(self):
with self.get_root(ui.VStack):
pass
def destroy(self):
self.subscription.unsubscribe()
```
## Re-rendering “In Place”
Similar to the ability to update the `style` property of any `ui.Widget` element or the `text` property of `ui.Label` and `ui.Button` elements, `Components` can also be updated after they are created. Components can update themselves in response to subscribed events or user interactions, or components can be updated elsewhere via reference. This *drastically* increases the composability of UI elements.
### Using Setters
```python
class CustomLabel(Component):
value: str = "Hello World"
def set_value(self, value: str):
self.value = value
self.update()
def render(self):
ui.Label(self.value)
hello_world_label = CustomLabel()
hello_world_label.set_value(
"Goodbye, and see you later"
)
```
### Using a Reference
```python
hello_world_label = CustomLabel()
hello_world_label.value = "Goodbye, and see you later"
hello_world_label.update()
```
## Caveat: Destroying a Component
Components are not automatically deleted when cleared from a container (or should otherwise be destroyed), so if a `destroy()` method is provided, a reference to that component must be stored and destroyed by the component’s “parent” when appropriate, resulting in a chain of saved references and destroy calls. This is often the case when a component sets up a subscription; the subscription must be unsubscribed when the component is removed. See 'Subscribing Components' above for examples of components that require a `destroy` method.
```python
class ParentComponent(Component):
def render(self):
prim = # get prim reference
with self.get_root(ui.VStack):
self.child = UsdSubscribingComponent(prim=prim)
def destroy(self):
self.child.destroy()
```
| 4,626 | Markdown | 27.73913 | 539 | 0.689148 |
heavyai/omni-component/exts/heavyai.ui.component/heavyai/ui/component/extension.py | from __future__ import annotations
import asyncio
import contextlib
from typing import Dict, Optional, TYPE_CHECKING
import omni.kit.app
if TYPE_CHECKING:
import omni.ui as ui
class Component:
"""
The base class that UI elements should be subclassed from
Attributes
----------
name : Optional[str]
The name of the root container.
style : Optional[Dict]
The local style of the root container.
height : Optional[int]
The height of the root container.
width : Optional[int]
The width of the root container
style_type_name_override : Optional[str]
By default, we use typeName to look up the style.
But sometimes it's necessary to use a custom name.
For example, when a widget as a part of another widget.(Label is a part of Button)
This property can override the name to use in style.
"""
style: Optional[Dict] = None
height: Optional[int] = None
width: Optional[int] = None
name: Optional[str] = None
style_type_name_override: Optional[str] = None
def __init__(self, render_on_init=True, **kwargs):
"""
Parameters
----------
render_on_init : bool
If the render method should be called upon component creation
"""
# ui.Container is ui.VStack/HStack/ZStack/etc
self._root: ui.Container = None
self._debounce_task: asyncio.Future = None
props = self.get_props() # grab declared component props
for k, v in kwargs.items():
try:
assert k in props # ensure the prop has been declared
setattr(self, k, v) # set props
except AssertionError:
raise AssertionError(f"Prop '{k}' must be annotated") from None
# in rare situations you may need to choose when the component initially renders
if render_on_init:
self.render()
@classmethod
def get_props(cls):
d = {}
for c in cls.mro():
try:
d.update(**c.__annotations__)
except AttributeError:
pass
return d
@property
def visible(self):
if self._root:
return self._root.visible
return False
@visible.setter
def visible(self, new_visible):
if not self._root:
raise Exception("Component has not been rendered") from None
self._root.visible = new_visible
@property
def enabled(self):
if self._root:
return self._root.enabled
@enabled.setter
def enabled(self, value):
if self._root:
self._root.enabled = value
def get_root(self, Container: ui.Container, default_visible=True, **kwargs):
"""
Creates and returns a new container upon initial call.
Clears the container and returns reference upon subsequent calls.
This allows a component to be re-rendered without losing its positioning
"""
if self._root:
self._root.clear()
else:
if self.height is not None:
kwargs.update(height=self.height)
if self.width is not None:
kwargs.update(width=self.width)
if self.style is not None:
kwargs.update(style=self.style)
if self.name is not None:
kwargs.update(name=self.name)
if self.style_type_name_override is not None:
kwargs.update(style_type_name_override=self.style_type_name_override)
self._root = Container(**kwargs)
self._root.visible = default_visible
return self._root
async def render_async(self):
"""Waits for next frame before re-rendering"""
await omni.kit.app.get_app().next_update_async()
self.render()
def update(self, loop=asyncio.get_event_loop()):
"""Used to re-render the component"""
asyncio.ensure_future(self.render_async(), loop=loop)
def update_debounce(self, delay=0.2):
"""
Queues re-render after a delay and resets the timer on subsequent calls if timer has not completed
"""
async def run_after_delay():
await asyncio.sleep(delay)
await self.render_async()
with contextlib.suppress(Exception):
self._debounce_task.cancel()
self._debounce_task = asyncio.ensure_future(run_after_delay())
def render(self):
raise NotImplementedError()
def __del__(self):
"""
Note: `__del__` is not reliably called when parent component is destroyed or re-rendered
If a component requires clean-up (such as subscriptions, windows, frames, or event listeners),
the parent component/class must manually call destroy when appropriate.
"""
self.destroy()
def destroy(self):
"""
If a component requires clean-up (such as subscriptions, windows, frames, or event listeners),
the parent component/class must manually call destroy when appropriate.
"""
pass
| 5,135 | Python | 31.506329 | 106 | 0.601558 |
heavyai/omni-component/exts/heavyai.ui.component/heavyai/ui/component/__init__.py | from .extension import *
| 25 | Python | 11.999994 | 24 | 0.76 |
heavyai/omni-component/exts/heavyai.ui.component/config/extension.toml | [package]
# Semantic Versionning is used: https://semver.org/
version = "1.0.0"
# Lists people or organizations that are considered the "authors" of the package.
authors = ["HEAVY.AI", "Brendan Turner", "Chris Matzenbach"]
# The title and description fields are primarily for displaying extension info in UI
title = "Heavy Omni.UI Component System"
description="Component class for UI organization and encapsulation"
# Path (relative to the root) or content of readme markdown file for UI.
readme = "./docs/README.md"
# URL of the extension source repository.
repository = "https://github.com/heavyai/omni-component"
# One of categories for UI.
category = "other"
# Keywords for the extension
keywords = ["heavyai", "component", "react"]
# Preview image is shown in "Overview" of Extensions window. Screenshot of an extension might be a good preview image.
preview_image = "resources/partner-spotlight-slide.png"
# Icon is shown in Extensions window, it is recommended to be square, of size 256x256.
icon = "resources/logo_black.png"
# Use omni.ui to build simple UI
[dependencies]
"omni.ui" = {}
# Main python module this extension provides, it will be publicly available as "import omni.hello.world".
[[python.module]]
name = "heavyai.ui.component"
| 1,262 | TOML | 33.135134 | 118 | 0.751189 |
heavyai/omni-component/exts/heavyai.ui.component/docs/README.md | # HEAVY.AI | Omni.Ui Component System
This component system was first presented during a NVIDIA Partner Spotlight with HEAVY.AI and can be found [here on YouTube](https://youtu.be/QhBMgx2G86g?t=1640)
## Goals
1. Provide a means to encapsulate functions and `omni.ui` widgets to modularize UI code by its purpose to enforce boundaries using separation of concerns
2. Standardize the creation and implementation of UI components in a manner that enforces self-documentation and a homogenous UI codebase
3. Provide the utility of updating and re-rendering specific components without re-rendering components that have not changed
## Examples
### Hello World
```python
from heavyai.ui.component import Component
class SimpleLabel(Component):
def render(self):
ui.Label("Hello World")
# USAGE
SimpleLabel()
class CustomLabel(Component):
value: str = "Hello World"
def render(self):
ui.Label(self.value)
# USAGE
CustomLabel(value="Hello There")
```
### Internal State
```python
from heavyai.ui.component import Component
class ButtonCounter(Component):
value: int = 0
on_change: Optional[Callable[[int], None]]
def _handle_click(self):
self.value += 1
if self.on_change:
self.on_change(self.value)
self.update()
def render(self):
with self.get_root(ui.HStack):
ui.Label(str(self.value))
ui.Button("Increment", clicked_fn=self._handle_click()
# USAGE
ButtonCounter(on_change=lambda val: print(val))
```
### Subscribing Components
```python
from heavyai.ui.component import Component
class UsdSubscribingComponent(Component):
prim: pxr.Usd.Prim
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.subscription: carb.Subscription = (
usd.get_watcher().subscribe_to_change_info_path(
path=self.prim.GetPath(), on_change=self._handle_prim_change
)
)
def _handle_prim_change(self, prim_attr_path):
self.update()
def render(self):
with self.get_root(ui.VStack):
pass
def destroy(self):
self.subscription.unsubscribe()
class AbstractModelSubscribingComponent(Component):
model: sc.AbstractManipulatorModel
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.subscription: carb.Subscription = (
self.model.subscribe_item_changed_fn(
self._handle_model_item_changed
)
)
def _handle_model_item_changed(self, model, item):
self.update()
def render(self):
with self.get_root(ui.VStack):
pass
def destroy(self):
self.subscription.unsubscribe()
```
## Re-rendering “In Place”
Similar to the ability to update the `style` property of any `ui.Widget` element or the `text` property of `ui.Label` and `ui.Button` elements, `Components` can also be updated after they are created. Components can update themselves in response to subscribed events or user interactions, or components can be updated elsewhere via reference. This *drastically* increases the composability of UI elements.
### Using Setters
```python
class CustomLabel(Component):
value: str = "Hello World"
def set_value(self, value: str):
self.value = value
self.update()
def render(self):
ui.Label(self.value)
hello_world_label = CustomLabel()
hello_world_label.set_value(
"Goodbye, and see you later"
)
```
### Using a Reference
```python
hello_world_label = CustomLabel()
hello_world_label.value = "Goodbye, and see you later"
hello_world_label.update()
```
## Caveat: Destroying a Component
Components are not automatically deleted when cleared from a container (or should otherwise be destroyed), so if a `destroy()` method is provided, a reference to that component must be stored and destroyed by the component’s “parent” when appropriate, resulting in a chain of saved references and destroy calls. This is often the case when a component sets up a subscription; the subscription must be unsubscribed when the component is removed. See 'Subscribing Components' above for examples of components that require a `destroy` method.
```python
class ParentComponent(Component):
def render(self):
prim = # get prim reference
with self.get_root(ui.VStack):
self.child = UsdSubscribingComponent(
prim=prim
)
def destroy(self):
self.child.destroy()
```
| 4,631 | Markdown | 27.417178 | 539 | 0.683654 |
syntway/model_exploder/README.md | # Model Exploder Tool
Model Exploder separates a 3D model into its component parts for a better view of their relationship and how they fit together.
Model separation happens as if by a small controlled explosion, emanating from its center. This is often known as an [exploded-view](https://en.wikipedia.org/wiki/Exploded-view_drawing) of the model.
Exploded-views can be used to understand a model from its components and can also be used to create drawings for parts catalogs or assembly/maintenance/instruction information. Or in general, just to blow-up a 3D model.
## Quick Links
* [Features](#features)
* [Installation](#installation)
* [How to Use](#how-to-use)
* [Credits](#credits)
* [Examples](#examples)
## Features
- Easy to use: select a model, click the Use button and move the Distance slider.
- Includes several ways to explode the model around a central point, axis or plane.
- Interactive editing of the explosion center: just drag the "Center" manipulator in the viewport.
- Works with meshes, USD Shapes, references/payloads. Point instances and skeletons are moved as a whole.
- Adds Undo-Redo state when applying changes.
- Works with NVIDIA's Omniverse Create, Code 2022+ or any other Kit-based apps. Compatible with multiple viewports and with the legacy viewport of older Omniverse versions.
## Installation
This tool is a plain Omniverse extension that can be installed like any other.
1. Download the latest [release](https://github.com/syntway/model_exploder/releases) or clone the [repository](https://github.com/syntway/model_exploder) into your computer.
2. In the Omniverse App (Create, Code, etc.), open the Extensions window from: Window menu > Extensions.
3. In the Extensions window, open the Settings page, by clicking the small gear button at the top of the left bar.
4. In the Settings page that appears at the right, you'll see a list of Extension Search Paths. Add the path location of the exts/ subfolder. This subfolder is inside the location to where you installed in step 1.
5. In the search field at the top left bar, next to the gear button, type model exploder - the tool should appear listed - click it.
6. Information about the Model Exploder tool will appear at the right side: check the Enabled and the Autoload checkboxes. The tool is now installed in your Omniverse app.
## How to Use
Select Model Exploder from the Window menu - the Model Exploder tool window appears:
Select models to explode: at least two parts must be selected (meshes, USD Shapes, etc).
The top button changes to "Click to use...". Click it to explode the selected parts.
Move the Distance slider and the parts are exploded from their shared center:
The Center combo box chooses the type of explosion movement: from a central point, around an axis or expanding from a plane.
Move the center point/axis/plane by dragging the Center manipulator in the viewport. Click the Recenter button to bring it back to the default middle position:
The Options section allows customization of the tool's behavior:
The available options are:
- Acceleration from Center: exploded parts accelerate based on their initial distance from Center.
This setting controls how farthest parts accelerate more than nearest ones.
- Distance Multiplier: multiply the explosion distance selected in the above slider.
For smaller or larger explosion scales.
- Initial Bounds Visibility: the visibility of the initial bounding box for the used shapes, from transparent to fully visible.
- Unselect Parts on Use: when starting to use a group of selected parts, should they be unselected for simpler visuals?
Finally, click the Apply button to add an Undo-Redo state. Or Cancel to return to the initial parts positions.
### Tips
- Click the ( i ) button for help and more information (opens this page).
- On complex models, the first interaction with the Distance slider might take a few seconds - next ones are much faster.
- If model parts do not separate and remain joined to each other:
- Make sure model is divided in parts (meshes, USD shapes, etc), as this tools works by moving those parts.
- With the Distance slider away from its leftmost position, move the Center manipulator in the viewport into the middle of the parts group.
- Separate the group of "stuck" parts before separating the rest of the model.
- The initial bounds preview and center manipulator work in the active (last used) viewport. To change viewports, close the Model Exploder window and open again after using the new viewport.
## Credits
This tool is developed by [Syntway](https://www.syntway.com), the VR/Metaverse tools division of FaronStudio.
The tool uses SVG icons from [SVG Repo](https://www.svgrepo.com/).
3D models used in examples are from: [Bastien Genbrugge](https://sketchfab.com/3d-models/spherebot-17baf2bd295f460a924e62854ced1427), [mdesigns100](https://3dexport.com/free-3dmodel-residential-building-model-296192.htm), [dap](https://3dexport.com/free-3dmodel-ym-house-185521.htm), [KatSy](https://3dsky.org/3dmodels/show/chastnyi_dom_3) and Pixar's [Kitchen Set](https://graphics.pixar.com/usd/release/dl_downloads.html).
## Examples
| 5,622 | Markdown | 50.587155 | 424 | 0.777303 |
syntway/model_exploder/exts/syntway.model_exploder/syntway/model_exploder/style.py | from pathlib import Path
import omni.ui as ui
from omni.ui import color as cl
from .libs.ui_utils import UiPal
THIS_FOLDER_PATH = Path(__file__).parent.absolute()
EXT_ROOT_FOLDER_PATH = THIS_FOLDER_PATH.parent.parent
ICONS_PATH = EXT_ROOT_FOLDER_PATH.joinpath("data").joinpath("icons")
# window frame cascade
WINDOW_FRAME = {
"ComboBox": {
"border_radius": 6,
"margin": 0,
},
"ComboBox:disabled": {
"color": UiPal.TEXT_DISABLED,
},
"Slider": {
"draw_mode": ui.SliderDrawMode.HANDLE,
"color": UiPal.TRANSP_NOT_0,
"border_radius": 6,
},
"Slider:disabled": {
"secondary_color": UiPal.TEXT_DISABLED,
},
"CheckBox:disabled": {
"background_color": UiPal.TEXT_DISABLED,
},
"Button.Label:disabled": {
"color": UiPal.TEXT_DISABLED,
},
"Button.Label::ever_bright": {
"color": cl.white,
},
"Button.Label::ever_bright:disabled": {
"color": cl.white,
},
"Image::info": {
"image_url": str(ICONS_PATH / "info.svg"),
"color": UiPal.TEXT,
},
"Image::info:hovered": {
"image_url": str(ICONS_PATH / "info.svg"),
"color": cl.white,
},
"Line": {
"color": UiPal.TEXT_DISABLED
},
"CollapsableFrame": {
"border_radius": 4,
},
}
| 1,358 | Python | 18.985294 | 68 | 0.552283 |
syntway/model_exploder/exts/syntway.model_exploder/syntway/model_exploder/extension.py | from functools import partial
import asyncio
import omni.ext
import omni.ui as ui
import omni.kit.commands
import carb.settings
from .libs.app_utils import call_on_parts_ready, call_after_update, get_setting_or
from .window import Window
from .engine import Engine
from . import const
class Extension(omni.ext.IExt):
def on_startup(self, ext_id):
# print("ext.on_startup", ext_id)
self._window = None
self._ext_id = ext_id
def build():
ui.Workspace.set_show_window_fn(const.WINDOW_NAME, partial(self.show_window, None))
# carb.settings.get_settings().set("persistent/exts/syntway.model_exploder/windowShowOnStartup", True)
show = get_setting_or(const.SETTINGS_PATH + "windowShowOnStartup", False)
ed_menu = omni.kit.ui.get_editor_menu()
if ed_menu:
self._menu = ed_menu.add_item(const.MENU_PATH, self.show_window, toggle=True, value=show)
if show:
self.show_window(None, True) # ui.Workspace.show_window(WINDOW_NAME)
call_on_parts_ready(build, 1) # stage ready
def on_shutdown(self):
# print("ext.on_shutdown")
ui.Workspace.set_show_window_fn(const.WINDOW_NAME, None)
ed_menu = omni.kit.ui.get_editor_menu()
if ed_menu and omni.kit.ui.editor_menu.EditorMenu.has_item(const.MENU_PATH):
ed_menu.remove_item(const.MENU_PATH)
self._menu = None
if self._window:
self._window.destroy(True)
self._window = None
def show_window(self, menu, value):
# print("ext.show_window", value, self._window)
if value: # show
if self._window is None:
self._window = Window(const.WINDOW_NAME, self._ext_id)
self._window.set_visibility_changed_fn(self._visibility_changed_fn)
else:
self._window.show()
elif self._window:
self._window.visible = False # will destroy in _visibility_changed_fn
def _set_menu(self, value):
# print("ext._set_menu", value)
ed_menu = omni.kit.ui.get_editor_menu()
if ed_menu:
ed_menu.set_value(const.MENU_PATH, value)
def _visibility_changed_fn(self, visible):
# print("ext._visibility_changed_fn", visible)
self._set_menu(visible)
if not visible: # destroy window
def destroy_window():
# print("ext.destroy_window", self._window)
if self._window:
self._window.destroy(False)
self._window = None
call_after_update(destroy_window)
class ExplodeEngineApplyCommand(omni.kit.commands.Command):
"""
Undo/redoable command used by engine to apply final and initial position lists
Don't use outside this extension.
States are a tuple of (dist, change_list, time_code)
"""
def __init__(self, initial_state, final_state, stage):
super().__init__()
self._initial_state = initial_state
self._final_state = final_state
self._stage = stage
def do(self):
Engine.apply_state(self._final_state, self._stage, None)
def undo(self):
Engine.apply_state(self._initial_state, self._stage, None)
omni.kit.commands.register_all_commands_in_module(__name__)
| 3,380 | Python | 26.266129 | 114 | 0.606805 |
syntway/model_exploder/exts/syntway.model_exploder/syntway/model_exploder/__init__.py | from .extension import *
| 25 | Python | 11.999994 | 24 | 0.76 |
syntway/model_exploder/exts/syntway.model_exploder/syntway/model_exploder/engine.py | import asyncio, copy
import carb
import omni.ext
import omni.ui as ui
from omni.ui import scene as sc
from omni.ui import color as cl
import omni.kit.commands
import omni.usd
import omni.timeline
from pxr import Usd, UsdGeom, UsdSkel, Sdf, Tf
import pxr.Gf as Gf
import omni.kit.notification_manager as nm
from omni.usd.commands import TransformPrimCommand, TransformPrimSRTCommand
from .libs.usd_helper import UsdHelper
from .libs.usd_utils import (set_prim_translation, set_prim_translation_fast,
set_prim_transform, get_prim_transform,
get_prim_translation, create_edit_context)
from .libs.viewport_helper import ViewportHelper
from .libs.app_helper import AppHelper
from .libs.app_utils import get_setting_or, set_setting, call_after_update
from . import const
APPLY_ASYNC = True
class Engine():
def __init__(self):
self.meshes_base_aabb = Gf.Range3d()
self._meshes = []
self._dist = 0
self._center_mode = get_setting_or(const.SETTINGS_PATH + const.CENTER_MODE_SETTING, const.DEFAULT_CENTER_MODE)
self._dist_mult = get_setting_or(const.SETTINGS_PATH + const.DIST_MULT_SETTING, const.DEFAULT_DIST_MULT)
self._order_accel = get_setting_or(const.SETTINGS_PATH + const.ACCEL_SETTING, const.ACCEL_DEFAULT)
self._explo_center = Gf.Vec3d(0)
self._last_explo_center = Gf.Vec3d(0)
self._apply_needed = False
self._apply_task = None
self._recalc_changed_needed = set()
self._ignore_next_objects_changed = 0 # 0=no, 1=only next, 2:all until reset
self._dist_base_size = 100
self.usd = UsdHelper()
self._app = AppHelper()
self._app.add_update_event_fn(self._on_update)
stream = omni.timeline.get_timeline_interface().get_timeline_event_stream()
self._timeline_sub = stream.create_subscription_to_pop(self._on_timeline_event)
def destroy(self):
self._apply_cancel()
self._timeline_sub = None
self._recalc_changed_needed.clear()
if self.usd:
self.usd.remove_stage_objects_changed_fn(self._on_stage_objects_changed)
self.usd.detach()
self.usd = None
if self._app:
self._app.detach()
self._app = None
Engine._instance = None
def reset(self, set_to_initial):
self._apply_cancel()
if set_to_initial and self.dist > 0: # if dist is 0, nothing to do
self._apply(-2, self._explo_center, self._meshes) # returns prims to initial's
self._meshes.clear()
self._dist = 0
self.usd.remove_stage_objects_changed_fn(self._on_stage_objects_changed)
def _on_update(self, _):
if self._recalc_changed_needed:
self._recalc_changed(self._recalc_changed_needed)
self._recalc_changed_needed.clear()
if self._apply_needed:
if APPLY_ASYNC:
if not self._apply_task or self._apply_task.done():
self._apply_needed = False
dist = self._dist
explo_center = Gf.Vec3d(self._explo_center)
meshes = copy.copy(self._meshes)
self._apply_task = asyncio.ensure_future(self._async_apply(dist, explo_center, meshes))
# else still applying last
else:
self._apply_needed = False
self._apply(-1, self._explo_center, self._meshes) # returns prims to initial's
def _on_stage_objects_changed(self, notice):
if self._ignore_next_objects_changed:
if self._ignore_next_objects_changed == 1:
self._ignore_next_objects_changed = 0
return
if not self._meshes: # should never happen?
return
# set filters out duplicate path property changes
changed_paths = set(Sdf.Path.GetAbsoluteRootOrPrimPath(i) for i in notice.GetChangedInfoOnlyPaths())
# print("_on_stage_objects_changed", changed_paths)
for n in changed_paths:
ch_path = n.GetPrimPath().pathString
# avoid camera changes
if ch_path.startswith("/OmniverseKit_") or ch_path.endswith("/animationData"):
continue
for p in self._meshes:
path = p["path"]
if path.startswith(ch_path):
self._recalc_changed_needed.add(path)
def _on_timeline_event(self, e):
# print("engine:_on_timeline_event", e.type)
if self.has_meshes:
if e.type == int(omni.timeline.TimelineEventType.CURRENT_TIME_CHANGED):
self._ignore_next_objects_changed = 1
AVOID_CHILDREN_PRIM_TYPES = ["Camera"] # avoid recursion on these
@staticmethod
def _traverse_add_prim(list, prim):
"""Recursively traverse the hierarchy"""
if not prim.IsValid(): # might not exist anymore
return
prim_t = prim.GetTypeName()
if prim.HasAuthoredReferences(): # refs: check if any children
ref_list = []
children = prim.GetChildren()
for c in children:
Engine._traverse_add_prim(ref_list, c)
if ref_list: # add children but not itself
list += ref_list
else: # no children, add itself
list.append(prim)
return
if prim.IsA(UsdGeom.PointInstancer) or prim.IsA(UsdSkel.Root): # instance, SkelRoot: add but don't recurse inside
list.append(prim)
return
if prim.IsA(UsdGeom.Gprim):
list.append(prim)
if not prim_t in Engine.AVOID_CHILDREN_PRIM_TYPES:
children = prim.GetChildren()
for c in children:
Engine._traverse_add_prim(list, c)
def _sel_get_prim_paths_parent_first_order(self, paths):
stage = self.usd.stage
prims = []
for path in paths:
prim = stage.GetPrimAtPath(path)
prims.append(prim)
u_prims = []
for p in prims:
Engine._traverse_add_prim(u_prims, p)
return u_prims
def sel_capture(self, paths=None):
# print("sel_capture")
if paths is None:
paths = self.usd.get_selected_prim_paths()
# print("_sel_capture", paths)
u_prims = self._sel_get_prim_paths_parent_first_order(paths)
self._meshes = []
self._dist = 0
if len(u_prims) < 2:
return False
time_code = self.usd.timecode
xform_cache = UsdGeom.XformCache(time_code)
bbox_cache = UsdGeom.BBoxCache(time_code, [UsdGeom.Tokens.default_])
self._explo_center = Gf.Vec3d(0) # average of prim centroids
aa_bounds = Gf.Range3d()
# world positions
for prim in u_prims:
path = prim.GetPath().pathString
lbb = bbox_cache.ComputeLocalBound(prim)
lcent = lbb.ComputeCentroid()
ltrans = get_prim_translation(prim, time_code)
ldelta = ltrans - lcent # translation from centroid to the placing pos
wbb = bbox_cache.ComputeWorldBound(prim)
wbb_aa = wbb.ComputeAlignedRange()
aa_bounds.UnionWith(wbb_aa)
wtrans = wbb.ComputeCentroid()
lmat = get_prim_transform(prim, False, xform_cache, time_code)
# print(path, "local", lbb, lcent, ltrans, "world", wbb, wbb_aa, wtrans, lmat)
# prim, prim_path, untransformed/local mid, world_mid, initial_local_translation
entry = {"prim": prim, "path": path, "ini_wtrans": wtrans, "ldelta": ldelta, "ini_lmat": lmat}
self._meshes.append(entry)
# print(entry)
self._explo_center += wtrans
# centroid and base AA bounds
self._explo_center /= len(u_prims)
self._last_explo_center = self._explo_center
self.meshes_base_aabb = aa_bounds
# _dist_base_size size scale
size = aa_bounds.GetSize()
self._dist_base_size = max(size[0], size[1], size[2]) * 0.5
self._calc_dist_order()
# print(time_code, self._explo_center, self._dist_base_size)
self._ignore_next_objects_changed = 0
self.usd.add_stage_objects_changed_fn(self._on_stage_objects_changed)
# print("sel_capture end")
return True
def _recalc_changed(self, ch_paths):
time_code = self.usd.timecode
bbox_cache = UsdGeom.BBoxCache(time_code, [UsdGeom.Tokens.default_])
dist = self._dist
dist = self._calc_dist(dist)
for p in self._meshes:
path = p["path"]
if path in ch_paths: # only if changed
prim = p["prim"]
lbb = bbox_cache.ComputeLocalBound(prim)
lcent = lbb.ComputeCentroid()
ltrans = get_prim_translation(prim, time_code)
ldelta = ltrans - lcent
wbb = bbox_cache.ComputeWorldBound(prim)
new_wtrans = wbb.ComputeCentroid()
# calc dir
w_dir = new_wtrans - self._explo_center
w_dir = self._calc_normalized_dir(w_dir)
new_ini_wtrans = new_wtrans - w_dir * dist
p["ini_wtrans"] = new_ini_wtrans
p["ldelta"] = ldelta
# print("changed", path, new_wtrans, ldelta)
# not needed and conflicts with translate manipulator's dragging: self.apply_asap()
self._calc_dist_order()
def apply_asap(self):
self._apply_needed = True
def _apply_cancel(self):
if APPLY_ASYNC:
if self._apply_task:
if self._apply_task.done():
return
self._apply_task.cancel()
async def _async_apply(self, dist_value, explo_center, meshes):
self._apply(dist_value, explo_center, meshes)
self._apply_task = None
def _apply(self, dist, explo_center, meshes):
"""dist: -2: reset to stored initial pos, -1: use current self._dist, >=0: 0..1"""
if not meshes:
return
# print("_apply", dist)
time_code = self.usd.timecode
changes = self._prepare_apply_state(dist, explo_center, meshes, time_code, True)
is_reset = dist == -2
state = (is_reset, changes, time_code)
Engine.apply_state(state, self.usd.stage, self)
# print("_apply end")
def _prepare_apply_state(self, dist, explo_center, meshes, time_code, with_prims):
"""dist: -2: reset to stored initial pos, -1: use current self._dist, >=0: 0..1"""
if dist == -1:
dist = self._dist
# dist can now be [0..1] or -2 for reset to initial
if dist >= 0:
dist_factor = self._calc_dist(dist)
else:
dist_factor = dist
time_code = self.usd.timecode
xform_cache = UsdGeom.XformCache(time_code)
changes = []
for mp in meshes:
prim = mp["prim"]
if not prim.IsValid(): # avoid any invalidated prims, deleted for example
# print("skipping", prim)
continue
path = mp["path"]
ini_wtrans = mp["ini_wtrans"]
ldelta = mp["ldelta"]
prim = mp["prim"]
dist_order = mp["dist_order"]
if dist_factor >= 0:
# calc world pos
# calc dir
w_ini_vec = ini_wtrans - explo_center
w_ini_len = w_ini_vec.GetLength()
w_ini_len = max(w_ini_len, 1e-5)
w_dir = self._calc_normalized_dir(w_ini_vec)
order_factor = 1.0 + dist_order * self._order_accel
w_vec = w_dir * dist_factor * order_factor
dest_w_trans = ini_wtrans + w_vec
# get local->parent->world transforms
p2w = xform_cache.GetParentToWorldTransform(prim)
# transform back from world to local coords
w2p = p2w.GetInverse()
dest_ptrans = w2p.Transform(dest_w_trans)
# calc delta in mesh local/untransformed space
dest_ltrans = dest_ptrans + ldelta
# local trans, in parent space coords
ltrans = (dest_ltrans[0], dest_ltrans[1], dest_ltrans[2])
#print(prim, dest_w_trans, ltrans)
else:
ltrans = mp["ini_lmat"]
if with_prims:
changes.append((prim, path, ltrans))
else:
changes.append((None, path, ltrans))
return changes
@staticmethod
def apply_state(state, stage, instance):
# print("apply_state", state, instance)
is_reset, changes, time_code = state
if instance:
instance._ignore_next_objects_changed = 2
if not is_reset:
""" Slower alternative:
for ch in changes:
prim, path, ltrans = ch
# print(path,ltrans, type(ltrans))
cmd = TransformPrimSRTCommand(path=path,
new_translation=ltrans,
time_code=time_code)
cmd.do()
"""
stage = stage
sdf_change_block = 2
with Sdf.ChangeBlock():
for ch in changes:
prim, path, lmat = ch
if prim is None:
prim = stage.GetPrimAtPath(path)
# print(prim, ltrans)
with create_edit_context(path, stage):
set_prim_translation(prim, lmat, sdf_change_block=sdf_change_block, time_code=time_code)
#set_prim_translation_fast(prim, lmat, sdf_change_block=sdf_change_block, time_code=time_code)
else:
for ch in changes:
prim, path, ltrans = ch
# print(path,ltrans, type(ltrans))
cmd = TransformPrimCommand(path=path,
new_transform_matrix=ltrans,
time_code=time_code)
cmd.do()
if instance:
instance._ignore_next_objects_changed = 0
# print("apply_state end")
def commit(self):
time_code = self.usd.timecode
dist = -2
changes = self._prepare_apply_state(dist, self._explo_center, self._meshes, time_code, False)
is_reset = dist == -2
initial_state = (is_reset, changes, time_code)
dist = -1
changes = self._prepare_apply_state(dist, self._explo_center, self._meshes, time_code, False)
is_reset = dist == -2
final_state = (is_reset, changes, time_code)
self._ignore_next_objects_changed = 2
stage = self.usd.stage
omni.kit.commands.execute("ExplodeEngineApplyCommand",
initial_state=initial_state,
final_state=final_state,
stage=stage)
self._ignore_next_objects_changed = 0
self.reset(False)
"""
# compile transform list for undo
time_code = self.usd.timecode
xform_cache = UsdGeom.XformCache(time_code)
self._ignore_next_objects_changed = 2
xforms=[]
for mp in self._meshes:
p = mp["prim"]
path = mp["path"]
ini_mat = mp["ini_lmat"]
new_mat = get_prim_transform(p, False, xform_cache, time_code)
xforms.append((path, new_mat, ini_mat, time_code, False))
self.reset(False)
if xforms:
if True:
omni.kit.undo.begin_group()
for x in xforms:
omni.kit.commands.execute("TransformPrim",
path=x[0],
new_transform_matrix=x[1],
old_transform_matrix=x[2]
)
omni.kit.undo.end_group()
else:
omni.kit.commands.execute(
"TransformPrims", prims_to_transform=xforms
)
self._ignore_next_objects_changed = 0
"""
def _calc_dist(self, dist):
dist = dist ** const.DIST_EXP
dist = dist * self._dist_base_size * self._dist_mult
return dist
def _calc_dir(self, dir):
if self._center_mode >= 1 and self._center_mode <= 3: # around axis: zero axis displacement
dir[self._center_mode - 1] = 0.
elif self._center_mode >= 4: # from a plane
i = self._center_mode - 4
dir[i] = 0.
dir[(i + 1) % 3] = 0.
def _calc_normalized_dir(self, dir):
self._calc_dir(dir)
if dir.GetLength() > 1e-6:
dir.Normalize()
return dir
def _calc_dist_order(self):
"""dist_order is the 0..1 position of the mesh with regard to _explo_center"""
min_len = float("inf")
max_len = -1
len_list = []
for mp in self._meshes:
vec = mp["ini_wtrans"] - self._explo_center
self._calc_dir(vec)
len = vec.GetLength()
len = max(len, 1e-5)
len_list.append(len)
min_len = min(len, min_len)
max_len = max(len, max_len)
max_min_range = max_len - min_len
max_min_range = max(max_min_range, 1e-5)
index = 0
for mp in self._meshes:
order = (len_list[index] - min_len) / max_min_range
mp["dist_order"] = order
index+=1
@property
def has_meshes(self):
return self.meshes_count >= 2
@property
def meshes_count(self):
return len(self._meshes)
@property
def stage_selection_meshes_count(self):
paths = self.usd.get_selected_prim_paths()
u_prims = self._sel_get_prim_paths_parent_first_order(paths)
return len(u_prims)
@property
def center(self):
return self._explo_center
@center.setter
def center(self, center):
self._explo_center = center
self._calc_dist_order()
self.apply_asap()
@property
def dist(self):
return self._dist
@dist.setter
def dist(self, d):
self._dist = d
self.apply_asap()
@property
def center_mode(self):
return self._center_mode
@center_mode.setter
def center_mode(self, c):
self._center_mode = c
set_setting(const.SETTINGS_PATH + const.CENTER_MODE_SETTING, self._center_mode)
self.apply_asap()
@property
def order_accel(self):
return self._order_accel
@order_accel.setter
def order_accel(self, v):
self._order_accel = v
set_setting(const.SETTINGS_PATH + const.ACCEL_SETTING, self._order_accel)
self.apply_asap()
@property
def dist_mult(self):
return self._dist_mult
@dist_mult.setter
def dist_mult(self, m):
self._dist_mult = m
set_setting(const.SETTINGS_PATH + const.DIST_MULT_SETTING, self._dist_mult)
self.apply_asap()
def recenter(self):
self._explo_center = self._last_explo_center
self.apply_asap()
def is_centered(self):
return Gf.IsClose(self._explo_center, self._last_explo_center, 1e-6)
| 19,891 | Python | 26.437241 | 126 | 0.539641 |
syntway/model_exploder/exts/syntway.model_exploder/syntway/model_exploder/const.py | from omni.ui import color as cl
DEV_MODE = 0
# extension/window
WINDOW_NAME = "Model Exploder"
MENU_PATH = f"Window/{WINDOW_NAME}"
SETTINGS_PATH = "persistent/exts/syntway.model_exploder/"
INFO_URL = "https://www.syntway.com/model_exploder/?info#how-to-use"
# ui
DISTANCE_LABEL = "Distance"
CENTER_LABEL = "Center"
SELECT_TO_EXPLODE_TEXT = "Start by selecting what to explode..."
SELECT_TO_USE_TEXT = "Click to use the {0} selected parts"
SELECTED_TEXT = "Exploding {0} parts"
DONE_TEXT = "Apply"
RESET_TEXT = "Cancel"
CENTER_TEXT = "Center"
RECENTER_TEXT = "Recenter"
OPTIONS_TITLE = "Options"
OPTIONS_DIST_MULT_LABEL = "Distance Multiplier"
OPTIONS_DIST_MULT_COMBO_VALUES = [
("1x", 1.),
("5x ", 5.),
("10x", 10.),
("100x", 100.)
]
OPTIONS_ACCEL_LABEL = "Acceleration from Center"
OPTIONS_ACCEL_MAX = 5.
OPTIONS_BOUNDS_ALPHA_LABEL = "Initial Bounds Visibility"
OPTIONS_BOUNDS_ALPHA_SETTING = "boundsAlpha"
OPTIONS_BOUNDS_ALPHA_DEFAULT = 0.5
OPTIONS_UNSELECT_ON_USE_LABEL = "Unselect Parts on Use"
OPTIONS_UNSELECT_ON_USE_SETTING = "unselectOnUse"
OPTIONS_UNSELECT_ON_USE_DEFAULT = True
TIMELINE_RESET_TEXT = "Timeline has changed: resetting exploded meshes..."
CENTER_COMBO_LABELS = [
"Point",
"X Axis",
"Y Axis", # up
"Z Axis", # up
"XY Plane", # ground
"YZ Plane",
"ZX Plane" # ground
]
CENTER_COMBO_AXIS_FIRST = 1
CENTER_COMBO_AXIS_SUFFIX = " (Vertical)"
CENTER_COMBO_PLANE_FIRST = 4
CENTER_COMBO_PLANE_SUFFIX = " (Ground)"
# engine
CENTER_MANIP_LABEL_OFFSET = -11
CENTER_MANIP_LABEL_SIZE = 15
DEFAULT_CENTER_MODE = 0
CENTER_MODE_SETTING = "centerMode"
DEFAULT_DIST_MULT = 5.
DIST_MULT_SETTING = "distMult"
ACCEL_DEFAULT = 1.68
ACCEL_SETTING = "orderAccel"
DIST_EXP = 1.3
BOUNDS_BASE_AABB_COLOR = cl("#808080ff") # rgba order
# tooltips
TOOLTIP_USE = "First select the models to explode, then click this button to use."
TOOLTIP_INFO = "Help and more info on this tool."
TOOLTIP_DIST = "Select the explosion distance. For larger distances, see Options - Distance Multiplier."
TOOLTIP_CENTER_MODE = """Select the explosion center type, which can be a point, an axis or a plane.
You can drag the Center manipulator directly in the viewport to change its position."""
TOOLTIP_RECENTER = "Toggle the Center manipulator in the viewport back to the centroid of the used shapes."
TOOLTIP_OPTIONS_ACCEL = """Exploded parts accelerate based on their initial distance from Center.
This setting controls how farthest parts accelerate more than nearest ones."""
TOOLTIP_OPTIONS_DIST = """Multiply the explosion distance selected in the above slider.
For smaller or larger explosion scales."""
TOOLTIP_OPTIONS_BOUNDS = """Visibility of the initial bounding box for the used shapes,
from transparent to fully visible."""
TOOLTIP_OPTIONS_UNSELECT = """When starting to use a group of selected parts,
should they be unselected for simpler visuals?"""
TOOLTIP_CANCEL = "Cancel the tool and leave parts in their initial positions."
TOOLTIP_APPLY = "Applies the current parts positions and adds an Undo-Redo state." | 3,079 | Python | 28.333333 | 107 | 0.725885 |
syntway/model_exploder/exts/syntway.model_exploder/syntway/model_exploder/window.py | import asyncio, copy, webbrowser
import carb
import omni.ui as ui
from omni.ui import scene as sc
from omni.ui import color as cl
import omni.kit.commands
import omni.usd
import omni.timeline
from pxr import Usd, UsdGeom, UsdSkel, Sdf, Tf
import pxr.Gf as Gf
import omni.kit.notification_manager as nm
from .libs.viewport_helper import ViewportHelper
from .libs.app_utils import get_setting_or, set_setting, call_after_update
from .libs.ui_utils import create_reset_button, create_tooltip_fn, UiPal, UiPal_refresh
from .libs.manipulators import TranslateManipulator
from .engine import Engine
from . import const
from . import style
class Window(ui.Window):
def __init__(self, title: str, ext_id: str, **kwargs):
# print("win.__init__")
self._ext_id = ext_id
self._engine = Engine()
self._scene_reg = None
self._center_manip = None
self._center_label = None
self._center_label_transform = None
self._base_aabb_lines = []
self._options_bounds_alpha = get_setting_or(const.SETTINGS_PATH + const.OPTIONS_BOUNDS_ALPHA_SETTING,
const.OPTIONS_BOUNDS_ALPHA_DEFAULT)
self._options_unselect_on_use = get_setting_or(const.SETTINGS_PATH + const.OPTIONS_UNSELECT_ON_USE_SETTING,
const.OPTIONS_UNSELECT_ON_USE_DEFAULT)
kwargs["auto_resize"] = True
super().__init__(title, **kwargs)
self.auto_resize = True
self._ui_built = False
self.frame.set_build_fn(self._build_fn)
self._vp = ViewportHelper()
# print(self._vp.info())
# create manipulator scene
self._scene_reg = self._vp.register_scene_proxy(self._scene_create, self._scene_destroy,
self._scene_get_visible, self._scene_set_visible,
self._ext_id)
self._engine.usd.add_stage_event_fn(self._on_stage_event)
def destroy(self, is_ext_shutdown):
# print("win.destroy", is_ext_shutdown)
self._dist_slider = None
self._use_button = None
self._center_mode_combo = None
self._recenter_button = None
self._options = None
self._options_dist_mult_combo = None
self._options_accel_slider = None
self._options_bounds_slider = None
self._options_unselect_on_use_check = None
self._done_button = None
self._reset_button = None
if self._center_manip:
self._center_manip.destroy()
self._center_manip = None
self._center_label = None
self._center_label_transform = None
self._base_aabb_lines.clear()
if self._scene_reg:
self._vp.unregister_scene(self._scene_reg)
self._scene_reg = None
if self._vp:
self._vp.detach()
self._vp = None
if self._engine:
if self._engine.usd:
self._engine.usd.remove_stage_event_fn(self._on_stage_event)
if not is_ext_shutdown and self._engine.has_meshes and self._engine.dist != 0:
self._engine.reset(True) # cancel current to intial positions
self._engine.destroy()
self._engine = None
super().destroy()
def _build_fn(self):
"""Called to build the UI once the window is visible"""
# print(f"win._build_fn {self.visible}")
UiPal_refresh()
self.frame.style = style.WINDOW_FRAME
with ui.VStack(width=386, style={"margin": 7}): # spacing=9, style={"margin": 7}
with ui.VStack(height=0, spacing=11, style={"margin": 0}): # spacing=9, style={"margin": 7}
with ui.HStack(skip_draw_when_clipped=True, spacing=5):
self._use_button = ui.Button(const.SELECT_TO_EXPLODE_TEXT,
name="ever_bright",
height=24,
clicked_fn=self._on_use_clicked,
tooltip_fn=create_tooltip_fn(const.TOOLTIP_USE))
ui.Image(name="info",
fill_policy=ui.FillPolicy.PRESERVE_ASPECT_FIT, width=18, height=24,
mouse_pressed_fn=lambda *p: self._on_info(),
tooltip_fn=create_tooltip_fn(const.TOOLTIP_INFO))
with ui.HStack(skip_draw_when_clipped=True, spacing=6):
ui.Label(const.DISTANCE_LABEL, width=50,
mouse_pressed_fn=lambda *p: self._on_dist_set_zero(),
tooltip_fn=create_tooltip_fn(const.TOOLTIP_DIST))
self._dist_slider = ui.FloatSlider(min=0, max=1,
# tooltip_fn=create_tooltip_fn(const.TOOLTIP_DIST)
)
self._dist_slider.model.add_value_changed_fn(self._on_dist_slider_changed)
with ui.HStack(skip_draw_when_clipped=True, spacing=6):
ui.Label(const.CENTER_LABEL, width=50,
tooltip_fn=create_tooltip_fn(const.TOOLTIP_CENTER_MODE))
self._center_mode_combo = ui.ComboBox(self._engine.center_mode,
*const.CENTER_COMBO_LABELS,
width=145,
tooltip_fn=create_tooltip_fn(const.TOOLTIP_CENTER_MODE))
self._center_mode_combo.model.add_item_changed_fn(self._on_center_mode_changed)
self._setup_center_combo_labels()
self._recenter_button = ui.Button(const.RECENTER_TEXT, width=60,
clicked_fn=self._on_recenter_clicked,
tooltip_fn=create_tooltip_fn(const.TOOLTIP_RECENTER))
ui.Spacer(height=1)
self._options = ui.CollapsableFrame(const.OPTIONS_TITLE,
collapsed=not bool(const.DEV_MODE))
with self._options:
with ui.VStack(spacing=0, style={"margin": 3}):
with ui.HStack(spacing=6):
ui.Label(const.OPTIONS_ACCEL_LABEL,
tooltip_fn=create_tooltip_fn(const.TOOLTIP_OPTIONS_ACCEL))
with ui.HStack():
self._options_accel_slider = ui.FloatSlider(min=0, max=const.OPTIONS_ACCEL_MAX)
self._options_accel_slider.model.set_value(self._engine._order_accel)
self._options_accel_slider.model.add_value_changed_fn(self._on_options_accel_changed)
create_reset_button(const.ACCEL_DEFAULT,
self._options_accel_slider.model,
self._options_accel_slider.model.set_value,
self._options_accel_slider.model.add_value_changed_fn)
with ui.HStack(spacing=6):
ui.Label(const.OPTIONS_DIST_MULT_LABEL,
tooltip_fn=create_tooltip_fn(const.TOOLTIP_OPTIONS_DIST))
with ui.HStack():
# locate dist_mult label index from self._engine.dist_mult
def get_dist_mult_index(dist_mult):
index = 0
for i in range(len(const.OPTIONS_DIST_MULT_COMBO_VALUES)):
entry = const.OPTIONS_DIST_MULT_COMBO_VALUES[i]
if dist_mult == entry[1]:
index = i
break
return index
self._options_dist_mult_combo = ui.ComboBox(
get_dist_mult_index(self._engine.dist_mult),
*[a[0] for a in const.OPTIONS_DIST_MULT_COMBO_VALUES],
tooltip_fn=create_tooltip_fn(const.TOOLTIP_OPTIONS_DIST)
)
self._options_dist_mult_combo.model.add_item_changed_fn(self._on_options_dist_mult_changed)
create_reset_button(get_dist_mult_index(const.DEFAULT_DIST_MULT),
self._options_dist_mult_combo.model.get_item_value_model(),
self._options_dist_mult_combo.model.get_item_value_model().set_value,
self._options_dist_mult_combo.model.add_item_changed_fn)
with ui.HStack(spacing=6):
ui.Label(const.OPTIONS_BOUNDS_ALPHA_LABEL,
tooltip_fn=create_tooltip_fn(const.TOOLTIP_OPTIONS_BOUNDS))
with ui.HStack():
self._options_bounds_slider = ui.FloatSlider(min=0, max=1,
#tooltip_fn=create_tooltip_fn(const.TOOLTIP_OPTIONS_BOUNDS)
)
self._options_bounds_slider.model.set_value(self._options_bounds_alpha)
self._options_bounds_slider.model.add_value_changed_fn(self._on_options_bounds_changed)
create_reset_button(const.OPTIONS_BOUNDS_ALPHA_DEFAULT,
self._options_bounds_slider.model,
self._options_bounds_slider.model.set_value,
self._options_bounds_slider.model.add_value_changed_fn)
with ui.HStack(spacing=6):
ui.Label(const.OPTIONS_UNSELECT_ON_USE_LABEL,
tooltip_fn=create_tooltip_fn(const.TOOLTIP_OPTIONS_UNSELECT))
with ui.HStack():
self._options_unselect_on_use_check = ui.CheckBox(width=12,
tooltip_fn=create_tooltip_fn(const.TOOLTIP_OPTIONS_UNSELECT))
self._options_unselect_on_use_check.model.set_value(self._options_unselect_on_use)
self._options_unselect_on_use_check.model.add_value_changed_fn(self._on_options_unselect_changed)
# ui.Spacer(width=1)
ui.Line()
create_reset_button(const.OPTIONS_UNSELECT_ON_USE_DEFAULT,
self._options_unselect_on_use_check.model,
self._options_unselect_on_use_check.model.set_value,
self._options_unselect_on_use_check.model.add_value_changed_fn)
ui.Spacer(height=1)
with ui.HStack(skip_draw_when_clipped=True, spacing=9):
self._reset_button = ui.Button(const.RESET_TEXT, clicked_fn=self._on_reset_clicked,
tooltip_fn=create_tooltip_fn(const.TOOLTIP_CANCEL))
ui.Spacer()
self._done_button = ui.Button(const.DONE_TEXT, clicked_fn=self._on_done_clicked,
tooltip_fn=create_tooltip_fn(const.TOOLTIP_APPLY))
#ui.Button("Test", clicked_fn=self._on_test)
self._ui_built = True
self._refresh_ui()
def _on_stage_event(self, ev: carb.events.IEvent):
# print("Window._on_stage_event", ev.type)
if not self._ui_built: # a stage event can call us before _build_fn()
return
if ev.type == int(omni.usd.StageEventType.SELECTION_CHANGED):
if not self._engine.has_meshes:
self._refresh_ui()
elif ev.type == int(omni.usd.StageEventType.CLOSING):
# print("Window.CLOSING")
self._reset(False) # calls engine.reset
#self._engine.usd.detach()
elif ev.type == int(omni.usd.StageEventType.OPENED):
# print("Window.OPENED")
self._setup_center_combo_labels()
def _refresh_ui(self):
if not self._engine.has_meshes: # nothing selected
self._dist_slider.enabled = False
self._center_mode_combo.enabled = False
self._recenter_button.enabled = False
self._done_button.enabled = False
self._reset_button.enabled = False
sel_mesh_count = self._engine.stage_selection_meshes_count
if sel_mesh_count >= 2:
self._use_button.text = const.SELECT_TO_USE_TEXT.format(sel_mesh_count)
self._use_button.enabled = True
else:
self._use_button.text = const.SELECT_TO_EXPLODE_TEXT
self._use_button.enabled = False
else:
mesh_count = self._engine.meshes_count
self._use_button.text = const.SELECTED_TEXT.format(mesh_count)
self._use_button.enabled = False
self._dist_slider.enabled = True
self._center_mode_combo.enabled = True
self._recenter_button.enabled = not self._engine.is_centered()
self._done_button.enabled = True
self._reset_button.enabled = True
def _setup_center_combo_labels(self):
model = self._center_mode_combo.model
ch = model.get_item_children()
up = self._engine.usd.stage_up_index
if up == 1: # y up
mark = [const.CENTER_COMBO_AXIS_FIRST + 1, const.CENTER_COMBO_PLANE_FIRST + 2]
else: # z up
mark = [const.CENTER_COMBO_AXIS_FIRST + 2, const.CENTER_COMBO_PLANE_FIRST + 0]
for l in range(len(const.CENTER_COMBO_LABELS)):
label = const.CENTER_COMBO_LABELS[l]
if l in mark:
if l < const.CENTER_COMBO_PLANE_FIRST:
label += const.CENTER_COMBO_AXIS_SUFFIX
else:
label += const.CENTER_COMBO_PLANE_SUFFIX
m = model.get_item_value_model(ch[l])
m.set_value(label)
def _reset(self, set_to_initial):
self._engine.reset(set_to_initial)
self._enable_center_controls(False)
self._enable_base_aabb(False)
self._dist_slider.model.set_value(0)
self._refresh_ui()
def _on_use_clicked(self):
if not self._engine.sel_capture():
self._reset(False)
return
self._sync_base_aabb()
self._enable_base_aabb(True)
self._enable_center_controls(True)
if self._center_manip:
self._set_center_manip_point(self._engine.center)
if self._options_unselect_on_use:
self._engine.usd.set_selected_prim_paths([])
self._refresh_ui()
def _on_dist_set_zero(self):
self._dist_slider.model.set_value(0)
def _on_dist_slider_changed(self, model):
self._engine.dist = model.as_float
def _on_center_mode_changed(self, m, *args):
self._engine.center_mode = m.get_item_value_model().get_value_as_int()
def _on_recenter_clicked(self):
self._engine.recenter()
self._set_center_manip_point(self._engine.center)
self._recenter_button.enabled = not self._engine.is_centered()
def _on_done_clicked(self):
self._engine.commit()
self._reset(False)
def _on_reset_clicked(self):
self._reset(True)
def _scene_create(self, vp_args):
vp_api = vp_args["viewport_api"]
if not self._vp.same_api(vp_api): # ensure scene is created in same viewport we're attached to
return
# print("_scene_create", vp_args, self._vp._api)
self._center_manip = TranslateManipulator(viewport=self._vp,
enabled=False,
changed_fn=self._on_center_manip_changed
)
self._center_label_transform = sc.Transform() # before next _sync
self._sync_scene_label()
with self._center_label_transform:
with sc.Transform(look_at=sc.Transform.LookAt.CAMERA, scale_to=sc.Space.SCREEN):
with sc.Transform(transform=sc.Matrix44.get_scale_matrix(2, 2, 1)):
wup = self._engine.usd.stage_up
wup *= const.CENTER_MANIP_LABEL_OFFSET
with sc.Transform(transform=sc.Matrix44.get_translation_matrix(*wup)):
self._center_label = sc.Label(const.CENTER_TEXT, alignment=ui.Alignment.CENTER,
size=const.CENTER_MANIP_LABEL_SIZE, visible=False)
self._create_base_aabb()
def _scene_destroy(self):
if self._center_manip:
self._center_manip.destroy()
self._center_manip = None
def _scene_get_visible(self):
return True
def _scene_set_visible(self, value):
if self._center_manip.enabled: # only set if manip is enabled
self._center_manip.enabled = value
def _on_center_manip_changed(self, action, manip):
# print("_on_center_manip_changed")
assert self._engine.has_meshes
self._sync_scene_label()
self._engine.center = manip.point
self._recenter_button.enabled = not self._engine.is_centered()
def _enable_center_controls(self, ena):
if self._center_manip:
self._center_manip.enabled = ena
if self._center_label:
self._center_label.visible = ena
def _set_center_manip_point(self, wpt):
self._center_manip.point = wpt
self._sync_scene_label()
def _sync_scene_label(self):
wpt = Gf.Vec3d(self._center_manip.point)
self._center_label_transform.transform = sc.Matrix44.get_translation_matrix(*wpt)
def prepare_base_aabb_color(self):
color = const.BOUNDS_BASE_AABB_COLOR
color = (color & 0x00ffffff) | (int(self._options_bounds_alpha * 255) << 24)
return color
def _create_base_aabb(self):
self._base_aabb_lines.clear()
color = self.prepare_base_aabb_color()
self._base_aabb_lines.append(sc.Line([0, 0, 0], [0, 0, 0], color=color, visible=False))
self._base_aabb_lines.append(sc.Line([0, 0, 0], [0, 0, 0], color=color, visible=False))
self._base_aabb_lines.append(sc.Line([0, 0, 0], [0, 0, 0], color=color, visible=False))
self._base_aabb_lines.append(sc.Line([0, 0, 0], [0, 0, 0], color=color, visible=False))
self._base_aabb_lines.append(sc.Line([0, 0, 0], [0, 0, 0], color=color, visible=False))
self._base_aabb_lines.append(sc.Line([0, 0, 0], [0, 0, 0], color=color, visible=False))
self._base_aabb_lines.append(sc.Line([0, 0, 0], [0, 0, 0], color=color, visible=False))
self._base_aabb_lines.append(sc.Line([0, 0, 0], [0, 0, 0], color=color, visible=False))
self._base_aabb_lines.append(sc.Line([0, 0, 0], [0, 0, 0], color=color, visible=False))
self._base_aabb_lines.append(sc.Line([0, 0, 0], [0, 0, 0], color=color, visible=False))
self._base_aabb_lines.append(sc.Line([0, 0, 0], [0, 0, 0], color=color, visible=False))
self._base_aabb_lines.append(sc.Line([0, 0, 0], [0, 0, 0], color=color, visible=False))
def _sync_base_aabb(self):
"""
points p#
4 5
6 7
0 1
2 3
lines
8| |9
10| |11
_4_
5/ /6
-7-
_0_
1/ /2
-3-
"""
if self._engine.meshes_base_aabb.IsEmpty():
return
mi, ma = self._engine.meshes_base_aabb.min, self._engine.meshes_base_aabb.max
p0=[mi[0],mi[1],mi[2]]
p1=[ma[0],mi[1],mi[2]]
p2=[mi[0],mi[1],ma[2]]
p3=[ma[0],mi[1],ma[2]]
p4=[mi[0],ma[1],mi[2]]
p5=[ma[0],ma[1],mi[2]]
p6=[mi[0],ma[1],ma[2]]
p7=[ma[0],ma[1],ma[2]]
self._base_aabb_lines[0].start,self._base_aabb_lines[0].end, = p0,p1
self._base_aabb_lines[1].start,self._base_aabb_lines[1].end, = p0,p2
self._base_aabb_lines[2].start,self._base_aabb_lines[2].end, = p1,p3
self._base_aabb_lines[3].start,self._base_aabb_lines[3].end, = p2,p3
self._base_aabb_lines[4].start,self._base_aabb_lines[4].end, = p4,p5
self._base_aabb_lines[5].start,self._base_aabb_lines[5].end, = p4,p6
self._base_aabb_lines[6].start,self._base_aabb_lines[6].end, = p5,p7
self._base_aabb_lines[7].start,self._base_aabb_lines[7].end, = p6,p7
self._base_aabb_lines[8].start,self._base_aabb_lines[8].end, = p0,p4
self._base_aabb_lines[9].start,self._base_aabb_lines[9].end, = p1,p5
self._base_aabb_lines[10].start,self._base_aabb_lines[10].end, = p2,p6
self._base_aabb_lines[11].start,self._base_aabb_lines[11].end, = p3,p7
def _enable_base_aabb(self, ena):
if self._engine.meshes_base_aabb.IsEmpty():
ena = False
for l in self._base_aabb_lines:
l.visible = ena
def _on_options_dist_mult_changed(self, m, *args):
index = m.get_item_value_model().get_value_as_int()
mult = const.OPTIONS_DIST_MULT_COMBO_VALUES[index][1]
self._engine.dist_mult = mult
def _on_options_accel_changed(self, model):
self._engine.order_accel = model.as_float
def _on_options_bounds_changed(self, model):
self._options_bounds_alpha = model.as_float
set_setting(const.SETTINGS_PATH + const.OPTIONS_BOUNDS_ALPHA_SETTING, self._options_bounds_alpha)
color = self.prepare_base_aabb_color()
for l in self._base_aabb_lines:
l.color = color
def _on_options_unselect_changed(self, m):
self._options_unselect_on_use = m.as_float
set_setting(const.SETTINGS_PATH + const.OPTIONS_UNSELECT_ON_USE_SETTING, self._options_unselect_on_use)
def _on_info(self):
res = webbrowser.open(const.INFO_URL)
| 23,446 | Python | 37.063312 | 143 | 0.514416 |
syntway/model_exploder/exts/syntway.model_exploder/syntway/model_exploder/libs/app_utils.py | """"""
import asyncio, functools, sys
import os.path
import carb
import omni.kit
import omni.kit.viewport.utility as vut
import omni.ui as ui
import omni.usd
from pxr import Gf, Tf, Sdf, Usd, UsdGeom, CameraUtil
VERSION = 11
def call_after_update(fn, update_count=1):
async def wait_for_update(count):
while count:
await omni.kit.app.get_app().next_update_async()
count -= 1
fn()
asyncio.ensure_future(wait_for_update(update_count))
def call_on_ready(is_ready_fn, on_ready_fn, max_tries=sys.maxsize):
async def wait_for():
nonlocal max_tries
while max_tries:
await omni.kit.app.get_app().next_update_async()
if is_ready_fn():
on_ready_fn()
return
max_tries -= 1
if is_ready_fn(): # straight away?
on_ready_fn()
return
else:
asyncio.ensure_future(wait_for())
def call_on_parts_ready(on_ready_fn, part_flags=1 | 2 | 4,
max_tries=sys.maxsize,
usd_context=None, usd_context_name='',
window_name: str = None,
):
"""Call back when all parts in part_flags are ready:
part_flags:
Stage ready=1
Stage camera ready=2 -> implies stage ready
Viewport non-zero frame size=4
"""
def are_parts_ready():
ready_mask = 0
if part_flags & (1 | 2 | 4):
api, win = vut.get_active_viewport_and_window(usd_context_name=usd_context_name,
window_name=window_name)
if part_flags & (1 | 2):
if usd_context is None:
ctx = omni.usd.get_context()
else:
ctx = usd_context
if not ctx:
return False
stage = ctx.get_stage()
if not stage:
return False
cam_prim = stage.GetPrimAtPath(api.camera_path)
ready_mask = 1 | (2 if cam_prim.IsValid() else 0)
if part_flags & 4:
if not win:
return False
ws_win = ui.Workspace.get_window(win.name)
if not ws_win:
return False
if not hasattr(ws_win, 'frame'):
return False
ws_win_frame = ws_win.frame
if ws_win_frame.computed_width > 0 and ws_win_frame.computed_height > 0:
ready_mask |= 4
return part_flags & ready_mask == part_flags
call_on_ready(are_parts_ready, on_ready_fn, max_tries)
# convenience calls
def call_on_stage_ready(on_ready_fn, usd_context=None, max_tries=sys.maxsize):
call_on_parts_ready(on_ready_fn, 1, usd_context=usd_context, max_tries=max_tries)
def call_on_stage_camera_ready(on_ready_fn,
usd_context=None, usd_context_name='',
window_name: str = None,
max_tries=sys.maxsize):
call_on_parts_ready(on_ready_fn, 1 | 2,
usd_context=usd_context, usd_context_name=usd_context_name,
window_name=window_name, max_tries=max_tries)
def get_setting_or(path, not_found_value):
value = carb.settings.get_settings().get(path)
if value is not None:
return value
else:
return not_found_value
def set_setting(path, value):
carb.settings.get_settings().set(path, value)
def delete_setting(path):
carb.settings.get_settings().destroy_item(path)
def get_extension_path(ext_id, sub_path=None):
ext_path = omni.kit.app.get_app().get_extension_manager().get_extension_path(ext_id)
if sub_path is not None:
return os.path.join(ext_path, sub_path)
else:
return ext_path
def matrix44_flatten(mat):
"""Get a omni.ui.scene.Matrix44 (an array[16]) from a pxr.Gf.Matrix4d or array[4][4]."""
return [mat[0][0], mat[0][1], mat[0][2], mat[0][3],
mat[1][0], mat[1][1], mat[1][2], mat[1][3],
mat[2][0], mat[2][1], mat[2][2], mat[2][3],
mat[3][0], mat[3][1], mat[3][2], mat[3][3]]
| 4,241 | Python | 25.185185 | 93 | 0.537373 |
syntway/model_exploder/exts/syntway.model_exploder/syntway/model_exploder/libs/manipulators.py | """
If you're getting Kit launch time errors related with omni.ui.scene,
add omni.ui.scene to your extension dependencies in extension.toml:
[dependencies]
"omni.ui.scene" = {}
"""
from typing import Dict
import carb
import omni.kit, omni.usd
from pxr import Gf, Sdf, Tf, Usd, UsdGeom
from omni.kit.manipulator.viewport import ManipulatorFactory
from omni.kit.manipulator.transform import AbstractTransformManipulatorModel, Operation
from omni.kit.manipulator.transform.manipulator import TransformManipulator, Axis
from omni.kit.manipulator.transform.simple_transform_model import SimpleTransformModel
from omni.kit.manipulator.transform.gestures import TranslateChangedGesture, TranslateDragGesturePayload
from .viewport_helper import ViewportHelper
class TranslateManipulator():
VERSION = 9
def __init__(self, viewport: ViewportHelper,
point=Gf.Vec3d(0, 0, 0),
size=1.,
enabled=False,
axes: Axis = Axis.ALL,
style: Dict = {},
changed_fn=None):
""" style: all colors in 0xAABBGGRR
{
"Translate.Axis::x": {"color": 0xAABBGGRR},
"Translate.Axis::y": {"color": },
"Translate.Axis::z": {"color": },
"Translate.Plane::x_y": {"color": },
"Translate.Plane::y_z": {"color": },
"Translate.Plane::z_x": {"color": },
"Translate.Point": {"color": 0xAABBGGRR, "type": "point"/"notpoint"},
}
"""
self._manip = None
self._gesture = None
self._changed_fn = None
#if not viewport.is_attached:
# raise AssertionError("Viewport not attached")
self._is_legacy = viewport.is_legacy
model = SimpleTransformModel()
model.set_operation(Operation.TRANSLATE)
model.set_floats(model.get_item("translate"), point)
self._changed_fn = changed_fn
self._gesture = TranslateGesture(viewport=viewport, changed_fn=self._on_changed_fn)
if self._is_legacy:
self._manip = ManipulatorFactory.create_manipulator(TransformManipulator,
model=model,
size=size,
enabled=enabled,
axes=axes,
style=style,
gestures=[self._gesture])
else:
#self._manip = None
#raise AssertionError("TranslateManipulator not currently usable on VP2")
self._manip = TransformManipulator(model=model,
size=size,
enabled=enabled,
axes=axes,
style=style,
gestures=[self._gesture])
def __del__(self):
self.destroy()
def destroy(self):
if self._gesture:
self._gesture.destroy()
self._gesture = None
if self._manip:
if self._is_legacy:
ManipulatorFactory.destroy_manipulator(self._manip)
else:
self._manip.destroy()
self._manip = None
if self._changed_fn:
self._changed_fn = None
@property
def enabled(self):
return self._manip.enabled
@enabled.setter
def enabled(self, ena):
self._manip.enabled = ena
@property
def point(self):
return self._manip.model.get_as_floats(self._manip.model.get_item("translate"))
@point.setter
def point(self, point):
self._manip.model.set_floats(self._manip.model.get_item("translate"),
[point[0], point[1], point[2]])
def set_changed_fn(self, fn):
""" fn(action, manip)
action: began=0,changed=1,ended=2,canceled=3
"""
self._changed_fn = fn
def _on_changed_fn(self, action, point):
if self._changed_fn:
self._changed_fn(action, self)
"""
class PointTranslateModel(SimpleTransformModel):
def __init__(self, point):
super().__init__()
self.set_operation(Operation.TRANSLATE)
self.set_floats(self.get_item("translate"), point)
"""
class TranslateGesture(TranslateChangedGesture):
def __init__(self, viewport, changed_fn=None, **kwargs):
TranslateChangedGesture.__init__(self)
self._vp = viewport
self.changed_fn = changed_fn
def destroy(self):
self._vp = None
self.changed_fn = None
def __del__(self):
self.destroy()
def on_began(self):
# print("TranslateGesture.on_began", self._vp.window_name)
if not self.gesture_payload or not self.sender or not isinstance(self.gesture_payload, TranslateDragGesturePayload):
return
model = self.sender.model
if not model:
return
pt = model.get_as_floats(model.get_item("translate"))
self._begin_point = Gf.Vec3d(*pt)
if self._vp.is_legacy:
self._vp.temp_select_enabled(False)
if self.changed_fn:
self.changed_fn(0, self._begin_point)
def on_ended(self):
# print("TranslateGesture.on_ended")
if not self.gesture_payload or not self.sender or not isinstance(self.gesture_payload, TranslateDragGesturePayload):
return
model = self.sender.model
if not model:
return
if self.changed_fn:
pt = model.get_as_floats(model.get_item("translate"))
self.changed_fn(2, Gf.Vec3d(*pt))
def on_canceled(self):
# print("TranslateGesture.on_canceled")
if not self.gesture_payload or not self.sender or not isinstance(self.gesture_payload, TranslateDragGesturePayload):
return
model = self.sender.model
if not model:
return
if self.changed_fn:
pt = model.get_as_floats(model.get_item("translate"))
self.changed_fn(3, Gf.Vec3d(*pt))
def on_changed(self):
# print("TranslateGesture.on_changed")
if not self.gesture_payload or not self.sender or not isinstance(self.gesture_payload, TranslateDragGesturePayload):
return
model = self.sender.model
if not model:
return
translate = Gf.Vec3d(*self.gesture_payload.moved)
point = self._begin_point + translate
model.set_floats(model.get_item("translate"), [point[0], point[1], point[2]])
if self.changed_fn:
self.changed_fn(1, point)
| 6,989 | Python | 25.477273 | 124 | 0.546001 |
syntway/model_exploder/exts/syntway.model_exploder/syntway/model_exploder/libs/usd_utils.py | """
Notes:
"""
import omni.kit
import omni.usd
from pxr import Gf, Sdf, Usd, UsdGeom
VERSION = 15
XFORM_OP_TRANSLATE_TYPE_TOKEN = UsdGeom.XformOp.GetOpTypeToken(UsdGeom.XformOp.TypeTranslate)
XFORM_OP_TRANSLATE_ATTR_NAME = "xformOp:" + XFORM_OP_TRANSLATE_TYPE_TOKEN
def get_prim_transform(prim,
with_pivot,
xform_cache=None,
time_code=Usd.TimeCode.Default()):
"""Returns a prim's local transformation, converting mesh points into parent-space coords.
with_pivot=True: returns GetLocalTransformation, where pivot and pivot^-1 are included into the translation.
with_pivot=False will set translation to the actual translate XformOp.
If no pivot is set, returns GetLocalTransformation()
"""
if xform_cache is None:
xform_cache = UsdGeom.XformCache(time_code)
mat, _ = xform_cache.GetLocalTransformation(prim)
if with_pivot:
return mat
# remove pivot from local transform
attr_name = XFORM_OP_TRANSLATE_ATTR_NAME
op_attr = prim.GetAttribute(attr_name + ":pivot")
if not op_attr: # no pivot, return mat
return mat
op_attr = prim.GetAttribute(attr_name)
if op_attr:
op = UsdGeom.XformOp(op_attr)
if op:
trans = op.Get(time_code)
if trans is not None:
mat.SetTranslateOnly(make_vec3_for_matrix4(mat, trans))
return mat
# translation not found: set to identity translate
mat.SetTranslateOnly(make_vec3_for_matrix4(mat, 0, 0, 0))
return mat
def set_prim_transform(prim, mat,
sdf_change_block=1,
time_code=Usd.TimeCode.Default()):
"""sdf_change_block: 0: don't use, 1: use locally, 2: assume already began"""
sdf_change_block = 0
stage = prim.GetStage()
if sdf_change_block == 1:
Sdf.BeginChangeBlock()
xform = UsdGeom.Xformable(prim)
ops = xform.GetOrderedXformOps()
for op in ops:
if op.GetOpType() == UsdGeom.XformOp.TypeTransform:
_set_xform_op_time_code(op, mat, time_code, stage)
if sdf_change_block == 1:
Sdf.EndChangeBlock()
return
def get_or_add(op_type, prec):
type_token = UsdGeom.XformOp.GetOpTypeToken(op_type)
attr_name = "xformOp:" + type_token
op_attr = prim.GetAttribute(attr_name)
if op_attr:
op = UsdGeom.XformOp(op_attr)
if op:
return op
if sdf_change_block >= 1:
Sdf.EndChangeBlock()
op = xform.AddXformOp(op_type, prec)
if sdf_change_block >= 1:
Sdf.BeginChangeBlock()
return op
# not a transform: decompose matrix and set various S,R,T as needed
_, _, scale, rot_mat, trans, _ = mat.Factor()
rot_mat.Orthonormalize(False)
rot = rot_mat.ExtractRotation()
new_ops = []
# translation
op = get_or_add(UsdGeom.XformOp.TypeTranslate, UsdGeom.XformOp.PrecisionDouble)
if op:
_set_xform_op_time_code(op, trans, time_code, stage)
new_ops.append(op)
# scale/rotate pivot (a translate)
pivot_op = None
attr_name = XFORM_OP_TRANSLATE_ATTR_NAME + ":pivot"
op_attr = prim.GetAttribute(attr_name)
if op_attr:
pivot_op = UsdGeom.XformOp(op_attr)
if pivot_op:
new_ops.append(pivot_op)
# rotation: pick first type
rot_type, rot_prec = UsdGeom.XformOp.TypeRotateXYZ, UsdGeom.XformOp.PrecisionFloat
for op in ops:
op_type = op.GetOpType()
if op_type >= UsdGeom.XformOp.TypeRotateX and op_type <= UsdGeom.XformOp.TypeOrient:
rot_type, rot_prec = op_type, op.GetPrecision()
break
def rot_get_or_add(rot_type,
axis_0, axis_1, axis_2,
x, y, z,
rot_prec
):
angles = rot.Decompose(axis_0, axis_1, axis_2)
rot_vals = Gf.Vec3f(angles[x], angles[y], angles[z]) # unscramble to x,y,z order that op.Set() needs
op = get_or_add(rot_type, rot_prec)
if op:
_set_xform_op_time_code(op, rot_vals, time_code, stage)
new_ops.append(op)
# single rotation?
if rot_type >= UsdGeom.XformOp.TypeRotateX and rot_type <= UsdGeom.XformOp.TypeRotateZ:
angles = rot.Decompose(Gf.Vec3d.ZAxis(), Gf.Vec3d.YAxis(), Gf.Vec3d.XAxis())
op = get_or_add(UsdGeom.XformOp.TypeRotateX, rot_prec)
if op:
_set_xform_op_time_code(op, angles[2], time_code, stage)
new_ops.append(op)
op = get_or_add(UsdGeom.XformOp.TypeRotateY, rot_prec)
if op:
_set_xform_op_time_code(op, angles[1], time_code, stage)
new_ops.append(op)
op = get_or_add(UsdGeom.XformOp.TypeRotateZ, rot_prec)
if op:
_set_xform_op_time_code(op, angles[0], time_code, stage)
new_ops.append(op)
# quaternion?
elif rot_type == UsdGeom.XformOp.TypeOrient:
type_token = UsdGeom.XformOp.GetOpTypeToken(rot_type)
attr_name = "xformOp:" + type_token
op_attr = prim.GetAttribute(attr_name)
if op_attr:
op = UsdGeom.XformOp(op_attr)
if op:
_set_xform_op_time_code(op, rot.GetQuat(), time_code, stage)
new_ops.append(op)
# triple rotation?
elif rot_type == UsdGeom.XformOp.TypeRotateXZY:
rot_get_or_add(rot_type,
Gf.Vec3d.YAxis(), Gf.Vec3d.ZAxis(), Gf.Vec3d.XAxis(),
2, 0, 1,
rot_prec)
elif rot_type == UsdGeom.XformOp.TypeRotateYXZ:
rot_get_or_add(rot_type,
Gf.Vec3d.ZAxis(), Gf.Vec3d.XAxis(), Gf.Vec3d.YAxis(),
1, 2, 0,
rot_prec)
elif rot_type == UsdGeom.XformOp.TypeRotateYZX:
rot_get_or_add(rot_type,
Gf.Vec3d.XAxis(), Gf.Vec3d.ZAxis(), Gf.Vec3d.YAxis(),
0, 2, 1,
rot_prec)
elif rot_type == UsdGeom.XformOp.TypeRotateZXY:
rot_get_or_add(rot_type,
Gf.Vec3d.YAxis(), Gf.Vec3d.XAxis(), Gf.Vec3d.ZAxis(),
1, 0, 2,
rot_prec)
elif rot_type == UsdGeom.XformOp.TypeRotateZYX:
rot_get_or_add(rot_type,
Gf.Vec3d.XAxis(), Gf.Vec3d.YAxis(), Gf.Vec3d.ZAxis(),
0, 1, 2,
rot_prec)
else: # just assume TypeRotateXYZ for any other
rot_get_or_add(rot_type,
Gf.Vec3d.ZAxis(), Gf.Vec3d.YAxis(), Gf.Vec3d.XAxis(),
2, 1, 0,
rot_prec)
# scale
op = get_or_add(UsdGeom.XformOp.TypeScale, UsdGeom.XformOp.PrecisionFloat)
if op:
_set_xform_op_time_code(op, scale, time_code, stage)
new_ops.append(op)
# pivot_op^-1
if pivot_op is not None:
for op in ops:
if op.IsInverseOp() and \
op.GetOpType() == UsdGeom.XformOp.TypeTranslate and \
is_pivot_xform_op_name_suffix(op.GetOpName()):
new_ops.append(op)
break
# and finally set new ops into xform
xform.SetXformOpOrder(new_ops, xform.GetResetXformStack())
if sdf_change_block == 1:
Sdf.EndChangeBlock()
"""
Note: touch_prim_xform() doesn't work, probably because the value is equal and caches are not rebuilt.
But this does:
lmat = get_prim_transform(prim, False, xform_cache, time_code)
cmd = TransformPrimCommand(path=path, new_transform_matrix=lmat, time_code=time_code)
#slower: cmd = TransformPrimSRTCommand(path=path, time_code=time_code)
cmd.do()
--------------------
def touch_prim_xform(prim,
sdf_change_block=1,
time_code=Usd.TimeCode.Default()):
#sdf_change_block: 0: don't use, 1: use locally, 2: assume already began
if sdf_change_block == 1:
Sdf.BeginChangeBlock()
xform = UsdGeom.Xformable(prim)
ops = xform.GetOrderedXformOps()
for op in ops:
if not op.IsInverseOp():
op.Set(op.Get(time_code), time_code)
break
if sdf_change_block == 1:
Sdf.EndChangeBlock()
"""
def get_prim_translation(prim,
time_code=Usd.TimeCode.Default()):
# remove pivot from local transform
op_attr = prim.GetAttribute(XFORM_OP_TRANSLATE_ATTR_NAME)
if op_attr:
op = UsdGeom.XformOp(op_attr)
if op:
trans = op.Get(time_code)
if trans is not None:
return Gf.Vec3d(trans)
# translation not found: return identity
return Gf.Vec3d(0.)
def set_prim_translation(prim, trans,
sdf_change_block=1,
time_code=Usd.TimeCode.Default()):
"""sdf_change_block: 0: don't use, 1: use locally, 2: assume already began"""
# print(prim.GetPath().pathString)
sdf_change_block = 0
mat_op = trans_op = None
xform = UsdGeom.Xformable(prim)
for op in xform.GetOrderedXformOps():
op_type = op.GetOpType()
if op_type == UsdGeom.XformOp.TypeTransform:
mat_op = op
break
elif op_type == UsdGeom.XformOp.TypeTranslate and not is_pivot_xform_op_name_suffix(op.GetOpName()): # op.SplitName()
# simple translation, not pivot/invert
trans_op = op
break
if mat_op: # has matrix op
if sdf_change_block == 1:
Sdf.BeginChangeBlock()
mat = Gf.Matrix4d()
mat.SetTranslate(trans)
stage = prim.GetStage()
_set_xform_op_time_code(mat_op, mat, time_code, stage)
else: # set or add a translation xform op
stage = prim.GetStage()
# can't just set attr as order might not have been set
if not trans_op:
if sdf_change_block == 2:
Sdf.EndChangeBlock()
trans_op = _prepend_xform_op(xform,
UsdGeom.XformOp.TypeTranslate,
get_xform_op_precision(trans),
time_code, stage)
if sdf_change_block == 2:
Sdf.BeginChangeBlock()
if sdf_change_block == 1:
Sdf.BeginChangeBlock()
_set_xform_op_time_code(trans_op, trans, time_code, stage)
if sdf_change_block == 1:
Sdf.EndChangeBlock()
def set_prim_translation_fast(prim, trans,
sdf_change_block=1,
time_code=Usd.TimeCode.Default()):
"""
As set_translation() but won't copy time samples from weaker layers.
sdf_change_block: 0: don't use, 1: use locally, 2: assume already began
see: https://graphics.pixar.com/usd/release/api/class_sdf_change_block.html
"""
sdf_change_block = 0
if prim.HasAttribute("xformOp:mat"): # has matrix op
if sdf_change_block == 1:
Sdf.BeginChangeBlock()
at = prim.GetAttribute("xformOp:mat")
if not at.GetNumTimeSamples():
time_code = Usd.TimeCode.Default()
mat = at.Get(time_code)
mat.SetTranslateOnly(trans)
at.Set(mat, time_code)
else: # set or add a translation xform op
# can't just set attr as order might not have been set
attr = prim.GetAttribute("xformOp:translate")
op = UsdGeom.XformOp(attr)
if not op:
if sdf_change_block == 2:
Sdf.EndChangeBlock()
stage = prim.GetStage()
xform = UsdGeom.Xformable(prim)
op = _prepend_xform_op(xform,
UsdGeom.XformOp.TypeTranslate,
get_xform_op_precision(trans),
time_code, stage)
if sdf_change_block == 2:
Sdf.BeginChangeBlock()
if sdf_change_block == 1:
Sdf.BeginChangeBlock()
if not op.GetNumTimeSamples():
time_code = Usd.TimeCode.Default()
op.Set(trans, time_code) # Gf.Vec3d()
if sdf_change_block == 1:
Sdf.EndChangeBlock()
def _set_xform_op_time_code(xform_op, value, time_code, stage):
prev = xform_op.Get(time_code)
if not xform_op.GetNumTimeSamples(): # no time samples
time_code = Usd.TimeCode.Default()
if prev is None:
if not time_code.IsDefault():
omni.usd.copy_timesamples_from_weaker_layer(stage, xform_op.GetAttr())
xform_op.Set(value, time_code)
else:
value_type = type(prev) # to preserve existing value type
if not time_code.IsDefault():
omni.usd.copy_timesamples_from_weaker_layer(stage, xform_op.GetAttr())
xform_op.Set(value_type(value), time_code)
def _prepend_xform_op(xform, op_type, prec, time_code, stage):
# print("pre", _get_xform_op_order(xform))
prev_ops = xform.GetOrderedXformOps()
xform.SetXformOpOrder([])
# print("mid", _get_xform_op_order(xform))
new_op = xform.AddXformOp(op_type, prec)
for op in prev_ops:
suffix = get_xform_op_name_suffix(op.GetOpName())
inverse = op.IsInverseOp()
new = xform.AddXformOp(op.GetOpType(), op.GetPrecision(),
suffix,
inverse)
if not inverse:
value = op.Get(time_code)
if value is not None:
_set_xform_op_time_code(new, value, time_code, stage)
# print("post", _get_xform_op_order(xform))
return new_op
def get_xform_op_precision(t):
if isinstance(t, Gf.Matrix4d) or isinstance(t, Gf.Vec3d):
return UsdGeom.XformOp.PrecisionDouble
else:
return UsdGeom.XformOp.PrecisionFloat
def get_vec3_type_for_matrix4(mat):
if isinstance(mat, Gf.Matrix4d):
return Gf.Vec3d
else:
return Gf.Vec3f
def make_vec3_for_matrix4(mat, x, y=None, z=None):
t = get_vec3_type_for_matrix4(mat)
if y is None:
return t(x[0], x[1], x[2])
else:
return t(x, y, z)
def _get_xform_op_order(xform):
out = ""
for op in xform.GetOrderedXformOps():
out += op.GetOpName() + ","
return out
XFORM_OP_INVERSE_PREFIX = "!invert!"
def is_xform_op_name_inverse(op_name):
return op_name.startswith(XFORM_OP_INVERSE_PREFIX)
def get_xform_op_name_suffix(op_name):
# or
if is_xform_op_name_inverse(op_name):
op_name = op_name.split(XFORM_OP_INVERSE_PREFIX, 1)[1]
if op_name.startswith("xformOp:"):
tags = op_name.split(":", 2)
if len(tags) >= 3:
return tags[2]
return ""
def is_pivot_xform_op_name_suffix(op_name):
"""or faster:
"xformOp:" in op_name and "pivot" in op_name
"""
suffix = get_xform_op_name_suffix(op_name)
if suffix != "":
return suffix == "pivot"
else:
return False
def create_edit_context(path, stage):
"""Unsafe from threading? No issues so far:
https://graphics.pixar.com/usd/release/api/class_usd_edit_context.html#details
"""
layer, prim = omni.usd.find_spec_on_session_or_its_sublayers(stage, path)
if not prim or not layer:
return Usd.EditContext(stage)
if prim.specifier == Sdf.SpecifierDef:
return Usd.EditContext(stage, Usd.EditTarget(layer))
else:
return Usd.EditContext(stage)
| 15,617 | Python | 27.14054 | 126 | 0.570212 |
syntway/model_exploder/exts/syntway.model_exploder/syntway/model_exploder/libs/ui_utils.py | """
Utility UI functions.
"""
from enum import IntEnum
import omni.ui as ui
VERSION = 4
class UiPaletteDark(IntEnum):
"""Colors in 0xAABBGGRR format. All colors with ff alpha if possible"""
BACK = 0xff23211f # darker than WINDOW_BACK: general widget background, window title bar
BACK_SELECTED = 0xff6e6e6e
BACK_HOVERED = BACK_SELECTED
TEXT = 0xffcccccc
TEXT_SELECTED = 0xff8b8a8a
TEXT_DISABLED = 0xff505050
WINDOW_BACK = 0xff454545 # lighter than BACK: window base color where darker controls are placed
TOOLTIP_TEXT = 0xff303030
TOOLTIP_BACK = 0xffaadddd
RESET = 0xffa07d4f # field reset button
TRANSP = 0x00000000
TRANSP_NOT_0 = 0x00ffffff # some widgets collapse width if 0 is passed as a color
UiPal = UiPaletteDark
def UiPal_refresh():
global UiPal
UiPal = UiPaletteDark
def create_tooltip(text: str,
tooltip_style=None,
tooltip_text_style=None):
if tooltip_style is None:
tooltip_style = {
"color": UiPal.TOOLTIP_TEXT,
"background_color": UiPal.TOOLTIP_BACK,
"margin": -1,
"border_width": 0,
}
if tooltip_text_style is None:
tooltip_text_style = {"margin": 3}
with ui.ZStack(style=tooltip_style):
ui.Rectangle()
ui.Label(text, style=tooltip_text_style)
def create_tooltip_fn(text: str,
tooltip_style=None,
tooltip_text_style=None):
return lambda: create_tooltip(text, tooltip_style, tooltip_text_style)
def create_reset_button(reset_value,
widget_model,
widget_set_value_fn,
widget_add_value_changed_fn,
style_on=None,
style_off=None,
on_tooltip_text=True, # True: use default, None: no tooltip
) -> ui.Rectangle:
if style_on is None:
style_on = {
"background_color": UiPal.RESET,
"border_radius": 2,
"color": 0xffffffff
}
if style_off is None:
style_off = {"background_color": UiPal.TEXT_DISABLED}
if on_tooltip_text is True:
on_tooltip_text = "Click to reset to default value"
def update_rect(new_value, *_):
if type(new_value) is ui.AbstractItemModel:
new_value = new_value.get_item_value_model()
if type(reset_value) is bool:
new_value = new_value.as_bool
elif type(reset_value) is int:
new_value = new_value.as_int
elif type(reset_value) is float:
new_value = new_value.as_float
# value changed? display reset button
rect.visible = new_value != reset_value
SIZE = 12
OFF_LEFT_PAD = 3
OFF_SIZE = 5
with ui.VStack(width=0, style={"margin": 0}):
ui.Spacer()
with ui.ZStack(width=SIZE, height=SIZE):
# disabled reset button
with ui.HStack(width=SIZE, height=SIZE):
ui.Spacer(width=OFF_LEFT_PAD)
with ui.VStack(width=SIZE, height=SIZE):
ui.Spacer()
ui.Rectangle(width=OFF_SIZE, height=OFF_SIZE, name="reset_off",
style=style_off)
ui.Spacer()
# actionable reset button
rect = ui.Rectangle(
width=SIZE,
height=SIZE,
name="reset",
alignment=ui.Alignment.V_CENTER,
style=style_on,
margin=0)
if on_tooltip_text is not None:
rect.set_tooltip_fn(create_tooltip_fn(on_tooltip_text))
rect.set_mouse_pressed_fn(lambda x, y, b, m: widget_set_value_fn(reset_value))
# initial rect visibility
update_rect(widget_model)
ui.Spacer()
widget_add_value_changed_fn(update_rect)
return rect
| 4,015 | Python | 25.077922 | 101 | 0.558655 |
syntway/model_exploder/exts/syntway.model_exploder/syntway/model_exploder/libs/viewport_helper.py | """
+ Coordinate spaces:
- 2D screen coordinate spaces
ui: whole frame area float UI units, only equal to px units when omni.ui.Workspace.get_dpi_scale() is 1. ui = px_units / dpi_scale.
Origin is left-top corner of the frame, 0..ui_size().
(app_ui = ui coordinates in Kit's app coordinates, window left-top is the origin.)
(px: whole frame area integer screen monitor pixels, 0..px_size(). Use ui coords instead for units to scale in high density displays)
01: float 0..1 coordinates covering whole frame area. Origin is left-top corner.
ndc: float -1..+1 Normalized Device Coordinates covering whole frame area. Origin is center, 1,1 is top-right corner of frame.
iscene: coordinates in a SceneView with view and projection transforms both set to identity matrices.
Origin is center, +x,+y is right-top corner. Can span -xy..+xy, where xy=iscene_half().
Fixed aspect ratio: a size displays at the same length in x and y.
render: area where rendering displays with size fitted to frame area, which can occupy whole or only a part.
NDC coords always extend -1..+1, origin is the center, 1,1 is top-right corner of frame.
- 3D world space
world: world space 3D coordinates
+ Coordinate/size conversions:
- 2D screen spaces
conv_iscene_from_render
conv_iscene_from_ndc
conv_iscene_from_01
conv_iscene_from_ui
size_iscene_from_ui
conv_render_from_ndc <-> conv_ndc_from_render
conv_01_from_ui <-> conv_ui_from_01
conv_ndc_from_ui <-> conv_ui_from_ndc
conv_01_from_app_ui, conv_ndc_from_app_ui, conv_ui_from_app_ui
conv_ndc_from_01 <-> conv_01_from_ndc
- 3D <-> 2D spaces
conv_render_from_world
conv_iscene_from_world
pick_ray_from_render
All conv_* methods accept points in Gf.Vec2*/Gf.Vec3* or tuple, but always return Gf.Vec2d/Gf.Vec3d points.
+ SceneView transformations
get_transform_iscene_from_ui
get_transform_iscene_from_render
+ Legacy Viewport:
Extension omni.kit.viewport_legacy (was omni.kit.window.viewport)
_win -> class omni.kit.viewport.utility.legacy_viewport_window.LegacyViewportWindow -> omni.ui.Window
_api -> class omni.kit.viewport.utility.legacy_viewport_api.LegacyViewportAPI
Use _win.legacy_window to get the actual IViewportWindow ->
class omni.kit.viewport_legacy._viewport_legacy.IViewportWindow
set_enabled_picking(), get_mouse_event_stream(), etc
+ Viewport Next
Partially supported. Extensions omni.kit.viewport.window, omni.kit.widget.viewport
+ Notes
- Don't store and always access ViewportHelper's frame or render area sizes as they may change due to user interactions,
even when changing Kit between display monitors.
"""
import asyncio, functools
import carb
import omni.kit
import omni.kit.viewport.utility as vut
import omni.ui as ui
""" Since omni.ui.scene may not not available on Kit's early launch,
if you're launch time errors related with omni.ui.scene, add omni.ui.scene
to your extension dependencies in extension.toml:
[dependencies]
"omni.ui.scene" = {} """
from omni.ui import scene as sc
from pxr import Gf, Tf, Sdf, Usd, UsdGeom, CameraUtil
SETTING_RENDER_WIDTH = "/app/renderer/resolution/width"
SETTING_RENDER_HEIGHT = "/app/renderer/resolution/height"
SETTING_CONFORM_POLICY = "/app/hydra/aperture/conform"
SETTING_RENDER_FILL_LEGACY = "/app/runLoops/rendering_0/fillResolution"
SETTING_RENDER_FILL = "/persistent/app/viewport/{api_id}/fillViewport"
SETTING_DEFAULT_WINDOW_NAME = "/exts/omni.kit.viewport.window/startup/windowName"
class ViewportHelper():
LIB_VERSION = 45
def __init__(self, window_name=None, attach: bool = True):
self._win = None
self._api = None
self._ws_win_frame = None
self._sub_render_width = None
self._sub_render_height = None
self._sub_render_fill = None
self._is_legacy = True
self._frame_mouse_fns = {} # frame: set(fn,fn,...)
self._frame_size_changed_fns = {} # frame: set(fn,fn,...)
self._render_changed_fns = set() # set(fn,fn,...)
self._stage_objects_changed = None # [listener, set(fn,fn,...)]
self._changed_fns = {} # fn: sub_flags
if attach:
res = self.attach(window_name=window_name)
if not res:
raise AssertionError("Could not attach")
def __del__(self):
self.detach()
def attach(self, window_name=None, usd_context_name: str = '') -> bool:
""" window_name:
str: actual window name/title, like "Viewport"
None: current/last active viewport
int: index into ViewportHelper.get_window_names()
Window selection order: .get_active_viewport_and_window() vut tries to attach "Viewport Next" first,
then legacy "Viewport" windows."""
self.detach()
if window_name is not None:
if type(window_name) is int:
wn_list = ViewportHelper.get_window_names()
if window_name < len(wn_list):
window_name = wn_list[window_name]
else:
raise AssertionError("Non-existent window_name")
else:
raise AssertionError("Bad window_name index")
self._api,self._win = vut.get_active_viewport_and_window(usd_context_name=usd_context_name,
window_name=window_name)
if self._win is None or self._api is None:
self._win = None
self._api = None
self._ws_win = None
self._ws_win_frame = None
return False
if self.stage is None:
raise AssertionError("Stage not available")
self._is_legacy = hasattr(self._api, "legacy_window")
self._ws_win = ui.Workspace.get_window(self._win.name)
if self._ws_win is None:
raise AssertionError("Workspace window not available")
"""
if not self._ws_win.visible:
print("Viewport Window is not visible: can't attach")
self.detach()
return False
"""
if not hasattr(self._ws_win, 'frame'):
self._ws_win_frame = None
raise AssertionError("Workspace window frame not available")
self._ws_win_frame = self._ws_win.frame
return True
def detach(self):
settings = carb.settings.get_settings()
if self._sub_render_width:
settings.unsubscribe_to_change_events(self._sub_render_width)
self._sub_render_width = None
if self._sub_render_height:
settings.unsubscribe_to_change_events(self._sub_render_height)
self._sub_render_height = None
if self._sub_render_fill:
settings.unsubscribe_to_change_events(self._sub_render_fill)
self._sub_render_fill = None
if self._win is not None:
if self._is_legacy:
self._win.destroy()
self._win = None
self._api = None
self._ws_win = None
self._ws_win_frame = None
self._frame_mouse_fns.clear()
self._frame_size_changed_fns.clear()
self._render_changed_fns.clear()
self._changed_fns.clear()
if self._stage_objects_changed is not None:
if len(self._stage_objects_changed):
self._stage_objects_changed[0].Revoke()
self._stage_objects_changed = None
@property
def is_attached(self):
return self._win is not None
@property
def window_name(self) -> str:
return self._win.name
@staticmethod
def get_default_window_name():
return carb.settings.get_settings().get(SETTING_DEFAULT_WINDOW_NAME) or 'Viewport'
@staticmethod
def get_window_names():
try:
from omni.kit.viewport.window import get_viewport_window_instances
return [w.title for w in get_viewport_window_instances()]
except ImportError:
return [ViewportHelper.get_default_window_name()]
@property
def is_legacy(self):
return self._is_legacy
@property
def camera_path(self) -> Sdf.Path:
return self._api.camera_path
@camera_path.setter
def camera_path(self, camera_path):
self._api.camera_path = camera_path
def get_camera_view_proj(self):
frustum = self.get_conformed_frustum()
if frustum is None:
return None
return frustum.ComputeViewMatrix(), frustum.ComputeProjectionMatrix()
def same_api(self, api) -> bool:
return id(api) == id(self._api)
def get_gf_camera(self):
"""Returns None if no valid prim found."""
cam = self._api.camera_path
stage = self.stage
if stage is None:
raise AssertionError("Stage not available")
cam_prim = stage.GetPrimAtPath( self.camera_path )
if cam_prim and cam_prim.IsValid():
usd_cam = UsdGeom.Camera(cam_prim)
if usd_cam:
return usd_cam.GetCamera()
# fall over
return None
@property
def fps(self) -> float:
return self._api.fps
@property
def usd_context_name(self) -> str:
return self._api.usd_context_name
@property
def usd_context(self):
return self._api.usd_context
@property
def stage(self):
return self.usd_context.get_stage()
def get_frame(self, frame_id: str):
return self._win.get_frame(frame_id)
@property
def ui_size(self):
""" Due to DPI pixel multiplier, can return fractional.
In DPI > 1 displays, this is UI units. Actual display pixels = UI units * omni.ui.Workspace.get_dpi_scale() """
if self._ws_win_frame is not None:
return self._ws_win_frame.computed_width, self._ws_win_frame.computed_height
else:
return 1.,1.
@property
def px_size(self):
""" Returns int size """
ui_size = self.ui_size
dpi_mult = ui.Workspace.get_dpi_scale()
return int(round(ui_size[0] * dpi_mult)), int(round(ui_size[1] * dpi_mult))
@property
def ui_size_ratio(self):
size = self.ui_size
return size[0] / size[1] if size[1] else 1.
@property
def render_size_px(self):
size = self._api.resolution
return (int(size[0]), int(size[1]))
@render_size_px.setter
def render_size_px(self, size):
self._api.resolution = (int(size[0]), int(size[1]))
# render_size width/height ratio
@property
def render_size_ratio(self):
size = self.render_size_px
return size[0] / size[1] if size[1] else 1.
""" ?Also render_rect_px, render_left_top_px """
"""
Kit-103.1.2/3: render_fill_frame get/set does not work coherently
Legacy Viewport: setting fill_frame makes viewport settings "Fill Viewport" disappear
Viewport 2: only works setting to True
Kit 104.0:
Viewport 2: api is not initialized to setting: so we use setting
@property
def render_fill_frame(self):
return self._api.fill_frame
@render_fill_frame.setter
def render_fill_frame(self, value: bool):
self._api.fill_frame = value
"""
@property
def render_fill_frame(self):
if self._is_legacy:
name = SETTING_RENDER_FILL_LEGACY
else:
name = SETTING_RENDER_FILL.format(api_id=self._api.id)
return bool(carb.settings.get_settings().get(name))
@render_fill_frame.setter
def render_fill_frame(self, value: bool):
if self._is_legacy:
name = SETTING_RENDER_FILL_LEGACY
else:
name = SETTING_RENDER_FILL.format(api_id=self._api.id)
carb.settings.get_settings().set(name, value)
def get_conformed_frustum(self):
cam = self.get_gf_camera()
if cam is None:
raise AssertionError("Camera not available")
frustum = cam.frustum
conform_policy = ViewportHelper.get_conform_policy()
CameraUtil.ConformWindow(frustum, conform_policy, self.render_size_ratio)
return frustum
@staticmethod
def get_conform_policy():
"""conform_policy: how is the render area fit into the frame area"""
policy = carb.settings.get_settings().get(SETTING_CONFORM_POLICY)
if policy is None or policy < 0 or policy > 5:
return CameraUtil.MatchHorizontally
else:
policies = [
CameraUtil.MatchVertically,
CameraUtil.MatchHorizontally,
CameraUtil.Fit,
CameraUtil.Crop,
CameraUtil.DontConform,
CameraUtil.DontConform,
]
return policies[policy]
def sync_scene_view(self, scene_view):
"""Must be called after viewport changes or before using a SceneView.
A SceneView's "screen_aspect_ratio" is the ratio of what we call the render space"""
frame_ratio = self.ui_size_ratio
render_ratio = self.render_size_ratio
if False and abs(frame_ratio - render_ratio) < 1e-6: # render equal to frame area: set to 0
ratio = 0
else:
ratio = render_ratio
if scene_view.screen_aspect_ratio != ratio:
scene_view.screen_aspect_ratio = ratio
# print("setup_scene_view asp_rat", scene_view.screen_aspect_ratio)
#====================================================================== coord space conversion
# generic NDC <-> 0..1 conversion
@staticmethod
def conv_ndc_from_01(coord):
return Gf.Vec2d( coord[0]*2. - 1., -(coord[1]*2. - 1.) )
@staticmethod
def conv_01_from_ndc(coord):
return Gf.Vec2d( (coord[0] + 1.) * 0.5, (-coord[1] + 1.) * 0.5)
def conv_01_from_ui(self, coord):
width,height = self.ui_size
return Gf.Vec2d(coord[0] / width, coord[1] / height)
def conv_ui_from_01(self, coord):
width,height = self.ui_size
return Gf.Vec2d(coord[0] * width, coord[1] * height)
def conv_ui_from_app_ui(self, coord):
frame = self._win.frame
return Gf.Vec2d(coord[0] - frame.screen_position_x, coord[1] - frame.screen_position_y)
def conv_01_from_app_ui(self, coord):
frame = self._win.frame
return self.conv_01_from_ui( (coord[0] - frame.screen_position_x, coord[1] - frame.screen_position_y) )
def conv_ndc_from_ui(self, coord):
xy = self.conv_01_from_ui(coord)
return ViewportHelper.conv_ndc_from_01(xy)
def conv_ui_from_ndc(self, coord):
xy = ViewportHelper.conv_01_from_ndc(xy)
return ViewportHelper.conv_ui_from_01(xy)
def conv_ndc_from_app_ui(self, coord):
xy = self.conv_01_from_app_ui(coord)
return ViewportHelper.conv_ndc_from_01(xy)
@property
def _render_from_size_ratios(self):
fr = self.ui_size
frame_ratio = fr[0] / fr[1] if fr[1] else 1.
render_ratio = self.render_size_ratio
if frame_ratio >= render_ratio: # tex vertical -1..+1
return (frame_ratio / render_ratio, 1.)
else: #
return (1., render_ratio / frame_ratio)
# coordinate conversion between frame-NDC and render(NDC) spaces
def conv_render_from_ndc(self, frame_ndc):
mx = frame_ndc[0]
my = frame_ndc[1]
ratios = self._render_from_size_ratios
mx *= ratios[0]
my *= ratios[1]
return Gf.Vec2d(mx, my)
def conv_ndc_from_render(self, render_ndc):
mx,my = self.conv_render_from_ndc(render_ndc)
return Gf.Vec2d(1./mx, 1./my)
def iscene_size(self, scene_view):
w,h = self.iscene_half(scene_view)
return w*2.,h*2.
def iscene_half(self, scene_view):
frame_ratio = self.ui_size_ratio
render_ratio = self.render_size_ratio
fills = abs(frame_ratio - render_ratio) < 1e-6
lands = frame_ratio >= render_ratio
asp_rat = scene_view.aspect_ratio_policy
# print("fills,lands", fills, lands, frame_ratio, render_ratio)
if asp_rat == sc.AspectRatioPolicy.PRESERVE_ASPECT_FIT:
if fills and frame_ratio < 1:
mul = 1.,1./frame_ratio
elif lands:
mul = frame_ratio,1.
else:
mul = render_ratio,render_ratio/frame_ratio
elif asp_rat == sc.AspectRatioPolicy.PRESERVE_ASPECT_HORIZONTAL:
if lands:
mul = frame_ratio/render_ratio,1./render_ratio
else:
mul = 1.,1./frame_ratio
elif asp_rat == sc.AspectRatioPolicy.PRESERVE_ASPECT_VERTICAL:
if lands:
mul = frame_ratio,1.
else:
mul = render_ratio,render_ratio/frame_ratio
elif asp_rat == sc.AspectRatioPolicy.PRESERVE_ASPECT_CROP:
if fills and frame_ratio < 1:
mul=frame_ratio,1.
elif lands:
mul = frame_ratio/render_ratio,1./render_ratio
elif frame_ratio >= 1:
mul = 1.,1./frame_ratio
else:
mul = 1,1./frame_ratio
elif asp_rat == sc.AspectRatioPolicy.STRETCH:
if frame_ratio >= 1:
mul = frame_ratio,1.
else:
mul = 1,1./frame_ratio
else:
mul = 1.,1.
return mul
def iscene_render_half(self, scene_view):
"""Render half size expressed in iscene coords"""
frame_ratio = self.ui_size_ratio
render_ratio = self.render_size_ratio
fills = abs(frame_ratio - render_ratio) < 1e-6
lands = frame_ratio >= render_ratio
asp_rat = scene_view.aspect_ratio_policy
if asp_rat == sc.AspectRatioPolicy.PRESERVE_ASPECT_FIT:
if fills and frame_ratio < 1:
mul = 1.,1./frame_ratio
else:
mul = render_ratio,1.
elif asp_rat == sc.AspectRatioPolicy.PRESERVE_ASPECT_HORIZONTAL:
mul = 1.,1./render_ratio
elif asp_rat == sc.AspectRatioPolicy.PRESERVE_ASPECT_VERTICAL:
mul = render_ratio,1.
elif asp_rat == sc.AspectRatioPolicy.PRESERVE_ASPECT_CROP:
if fills and frame_ratio < 1:
mul=frame_ratio,1.
else:
mul = 1.,1./render_ratio
elif asp_rat == sc.AspectRatioPolicy.STRETCH:
if fills and frame_ratio < 1:
mul = 1.,1./render_ratio
elif lands:
mul = render_ratio,1.
elif frame_ratio >= 1:
mul = frame_ratio,frame_ratio/render_ratio
else:
mul = 1.,1./render_ratio
else:
mul = 1.,1.
return mul
def conv_iscene_from_render(self, render_pt, scene_view):
mul = self.iscene_render_half(scene_view)
return Gf.Vec2d(render_pt[0] * mul[0], render_pt[1] * mul[1])
def conv_iscene_from_01(self, ui01, scene_view):
size = self.ui_size
pt = ViewportHelper.conv_ndc_from_01(ui01)
mul = self.iscene_half(scene_view)
return Gf.Vec2d(pt[0] * mul[0], pt[1] * mul[1])
def conv_iscene_from_ndc(self, ndc, scene_view):
mul = self.iscene_half(scene_view)
return Gf.Vec2d(ndc[0] * mul[0], ndc[1] * mul[1])
def conv_iscene_from_ui(self, ui_pt, scene_view):
size = self.ui_size
pt = ui_pt[0] / size[0] * 2. - 1., ui_pt[1] / size[1] * 2. - 1. # pt now in NDC
mul = self.iscene_half(scene_view)
return Gf.Vec2d(pt[0] * mul[0], pt[1] * mul[1])
def size_iscene_from_ui(self, ui_size, scene_view):
size = self.ui_size
ui_sz = 2. * ui_size / size[0]
mul = self.iscene_half(scene_view)
return ui_sz * mul[0]
def get_transform_iscene_from_ui(self, scene_view):
size_ui = self.ui_size
iscene_half = self.iscene_half(scene_view)
return sc.Matrix44.get_scale_matrix(iscene_half[0], iscene_half[1], 1.) * \
sc.Matrix44.get_translation_matrix(-1., +1., 0) * \
sc.Matrix44.get_scale_matrix(2./size_ui[0], -2./size_ui[1], 1.)
def get_transform_iscene_from_render(self, scene_view):
iscene_render_half = self.iscene_render_half(scene_view)
return sc.Matrix44.get_scale_matrix(iscene_render_half[0], iscene_render_half[1], 1.)
#====================================================================== 3D world <-> 2D screen conversion
def pick_ray_from_render(self, render_ndc, frustum=None):
if frustum is None:
frustum = self.get_conformed_frustum()
pos = Gf.Vec2d(render_ndc[0],render_ndc[1])
return frustum.ComputePickRay(pos)
"""
From frame space NDC coords example:
x,y = self.conv_render_from_ndc(frame_ndc)
if x is None or x < -1.0 or x > 1.0 or y < -1.0 or y > 1.0:
return None
return get_pick_ray((x,y))
"""
def conv_render_from_world(self, wpt):
""" wpt can be Gd.Vec3*, (x,y,z), single value or list
returns Gf.Vec2d, single value or list NDC coords
"""
view,proj = self.get_camera_view_proj()
mat = view*proj
if isinstance(wpt, list):
wpt_list=wpt
else:
wpt_list=[wpt]
rpt = []
for pt in wpt_list:
r = mat.Transform( Gf.Vec3d(pt[0],pt[1],pt[2]) )
rpt.append(r)
if isinstance(wpt, list):
return rpt
else:
return rpt[0]
def conv_iscene_from_world(self, wpt, scene_view):
""" wpt can be Gd.Vec3*, (x,y,z) or list. Not single value.
returns Gf.Vec2d, single value or list NDC coords
"""
view,proj = self.get_camera_view_proj()
mat = view*proj
if isinstance(wpt, list):
wpt_list=wpt
else:
wpt_list=[wpt]
mul = self.iscene_render_half(scene_view)
spt = []
for pt in wpt_list:
r = mat.Transform( Gf.Vec3d(pt[0],pt[1],pt[2]) )
s = Gf.Vec2d(r[0] * mul[0], r[1] * mul[1])
spt.append(s)
if isinstance(wpt, list):
return spt
else:
return spt[0]
def add_frame_mouse_fn(self, frame, fn, coord_space=0):
"""Called function params:
op:
0=press
1=move
2=release
3=double click
4=mouse wheel
5=mouse hovered (entered) frame
x,y: coordinates inside frame, depending on coord_space:
0=01 space
1=ui space
2=ndc space
3=render space
button:
0=left
1=right
2=middle
mod flags:
1=shift
2=ctrl
4=alt
(6=altGr = ctrl + alt)
0x40000000=unknown during move and release
"""
if not frame in self._frame_mouse_fns:
self._frame_mouse_fns[frame] = set()
fnlist = self._frame_mouse_fns[frame]
if fn in fnlist:
return
fnlist.add(fn)
last_button_pressed = None
def dispatch(op, x,y, button, mod):
for fn in fnlist:
fn(op, x,y, button, mod)
def to_space(x,y):
if coord_space <= 1:
p01 = self.conv_01_from_app_ui((x,y))
if coord_space == 0:
return p01
else:
return self.conv_ui_from_01(p01)
else:
pndc = self.conv_ndc_from_app_ui((x,y))
if coord_space == 2:
return pndc
else:
return self.conv_render_from_ndc(pndc)
def on_mouse_pressed(x,y, button, mod):
nonlocal last_button_pressed
x,y = to_space(x,y)
dispatch(0, x,y, button, mod)
last_button_pressed = button
def on_mouse_moved(x,y, mod, unknown_always_true): #on move: x,y can go outside 0,1
x,y = to_space(x,y)
dispatch(1, x,y, last_button_pressed, mod)
def on_mouse_released(x,y, button, mod):
nonlocal last_button_pressed
x,y = to_space(x,y)
dispatch(2, x,y, button, mod)
last_button_pressed = None
def on_mouse_double_clicked(x,y, button, mod):
x,y = to_space(x,y)
dispatch(3, x,y, button, mod)
def on_mouse_wheel(x,y, mod):
dispatch(4, x,y, None, mod)
def on_mouse_hovered(entered): # x=entered info
dispatch(5, entered, None, None, None)
frame.set_mouse_pressed_fn(on_mouse_pressed)
frame.set_mouse_moved_fn(on_mouse_moved)
frame.set_mouse_released_fn(on_mouse_released)
frame.set_mouse_double_clicked_fn(on_mouse_double_clicked)
frame.set_mouse_wheel_fn(on_mouse_wheel)
frame.set_mouse_hovered_fn(on_mouse_hovered)
def add_frame_size_changed_fn(self, frame, fn):
if not frame in self._frame_size_changed_fns:
def on_frame_size_changed():
if not frame in self._frame_size_changed_fns:
return
for fn in self._frame_size_changed_fns[frame]:
fn()
frame.set_computed_content_size_changed_fn( on_frame_size_changed )
self._frame_size_changed_fns[frame] = set()
fnlist = self._frame_size_changed_fns[frame]
fnlist.add( fn )
def remove_frame_size_changed_fn(self, frame, fn):
if frame in self._frame_size_changed_fns:
fnlist = self._frame_size_changed_fns[frame]
fnlist.discard( fn )
def add_render_changed_fn(self, fn):
"""Call fn handler on render resolution or fill mode changed"""
if self._sub_render_width is None:
def on_render_changed(*args):
""" will render resolution/frame_fill take a frame to reflect """
async def async_func():
await omni.kit.app.get_app().next_update_async()
for fn in self._render_changed_fns:
fn()
asyncio.ensure_future( async_func() )
settings = carb.settings.get_settings()
self._sub_render_width = settings.subscribe_to_node_change_events(SETTING_RENDER_WIDTH, on_render_changed)
self._sub_render_height = settings.subscribe_to_node_change_events(SETTING_RENDER_HEIGHT, on_render_changed)
self._sub_render_fill = settings.subscribe_to_node_change_events(SETTING_RENDER_FILL, on_render_changed)
self._render_changed_fns.add(fn)
def remove_render_changed_fn(self, fn):
if self._sub_render_width is not None:
self._render_changed_fns.discard(fn)
def add_camera_changed_fn(self, fn):
"""Call fn handler when USD camera changes"""
if self._stage_objects_changed is None:
# handler needs to be a method as Register won't hold reference to a local function
listener = Tf.Notice.Register( Usd.Notice.ObjectsChanged, self._on_stage_objects_changed, self.stage)
self._stage_objects_changed = [listener, set()]
val = self._stage_objects_changed
val[1].add(fn)
def _on_stage_objects_changed(self, notice, stage):
if stage != self.stage or self._stage_objects_changed is None:
return
# did active camera change?
cam_path = self.camera_path
for n in notice.GetChangedInfoOnlyPaths():
if n.GetPrimPath() == cam_path: # found camera
for fn in self._stage_objects_changed[1]:
fn()
return
def remove_camera_changed_fn(self, fn):
if self._stage_objects_changed is not None:
val = self._stage_objects_changed
val[1].discard(fn)
def add_changed_fn(self, fn, sub_flags = 1|2|4, frame = None):
"""Call handler on frame, render or camera changes, depending on sub_flags mask.
sub_flags: 1=frame size changed (requires frame param), 2=render changed, 4=camera changed
fn(changed_flag)
"""
self._changed_fns[fn] = sub_flags #overwrite any existing for fn
# add everytime because functions avoid duplicates: but only if not using lambdas!
if sub_flags & 1:
if frame is None:
raise AssertionError("Frame size changed: frame parameter cannot be None")
self.add_frame_size_changed_fn(frame, self._on_frame_changed)
if sub_flags & 2:
self.add_render_changed_fn(self._on_render_changed)
if sub_flags & 4:
self.add_camera_changed_fn(self._on_camera_changed)
def _on_frame_changed(self):
self._on_changed(1)
def _on_render_changed(self):
self._on_changed(2)
def _on_camera_changed(self):
self._on_changed(4)
def _on_changed(self, changed_flag):
for fn, mask in self._changed_fns.items():
if mask & changed_flag:
fn(changed_flag)
def remove_changed_fn(self, fn, frame):
if fn in self._changed_fns:
if self._changed_fns[fn] & 1 and frame is None:
raise AssertionError("Frame size changed: frame parameter cannot be None")
del self._changed_fns[fn]
if not len(self._changed_fns):
if frame is not None:
self.remove_frame_size_changed_fn(frame, self._on_frame_changed)
self.remove_render_changed_fn(self._on_render_changed)
self.remove_camera_changed_fn(self._on_camera_changed)
def add_scene_view_update(self, scene_view):
self._api.add_scene_view(scene_view)
def remove_scene_view_update(self, scene_view):
self._api.remove_scene_view(scene_view)
def register_scene(self, scene_creator,
ext_id_or_name: str):
"""Registers a scene creator into:
VP1: a viewport window, where scene is immediately created
VP2: calls RegisterScene with omni.kit.viewport.registry, to create scene in
current (full window) viewports and any new ones.
scene_creator object created with: scene_creator_class(dict)
VP1 dict = {viewport_api}
VP2 dict = {viewport_api: omni.kit.viewport.window.ViewportAPI,
layer_provider: omni.kit.viewport.window.ViewportLayers,
usd_context_name: str}
"""
if self.is_legacy:
with self._win.get_frame(ext_id_or_name):
scene_view = sc.SceneView()
with scene_view.scene:
sce = scene_creator({"viewport_api": self._api})
# have viewport update our SceneView
self.add_scene_view_update(scene_view)
return [scene_view, sce]
else:
try:
from omni.kit.viewport.registry import RegisterScene
scene_reg = RegisterScene(scene_creator, ext_id_or_name)
return [scene_reg]
except ImportError:
return None
def register_scene_proxy(self, create_fn, destroy_fn, get_visible_fn, set_visible_fn,
ext_id_or_name: str):
lamb = ViewportHelper.SceneCreatorProxy.make_lambda(create_fn, destroy_fn, get_visible_fn, set_visible_fn)
return self.register_scene(lamb, ext_id_or_name)
def unregister_scene(self, scene_reg):
if scene_reg is None or not len(scene_reg):
return
if self.is_legacy:
scene_view = scene_reg[0]
self.remove_scene_view_update(scene_view)
scene_view.destroy()
scene_reg.clear()
class SceneCreatorProxy:
@staticmethod
def make_lambda(create_fn, destroy_fn, get_visible_fn, set_visible_fn):
return lambda vp_args: ViewportHelper.SceneCreatorProxy(vp_args, create_fn, destroy_fn, get_visible_fn, set_visible_fn)
def __init__(self, vp_args: dict,
create_fn, destroy_fn, get_visible_fn, set_visible_fn):
# print("SceneCreatorProxy.__init__", vp_args)
# dict_keys(['usd_context_name', 'layer_provider', 'viewport_api'])
"""@ATTN: a scene may be created in multiple viewports. It's up to the _create_fn() callee to make sure it's
being called in the intended viewport by checking vp_args['viewport_api']"""
self._create_fn = create_fn
self._destroy_fn = destroy_fn
self._get_visible_fn = get_visible_fn
self._set_visible_fn = set_visible_fn
self._create_fn(vp_args)
def destroy(self):
# print("SceneCreatorProxy.destroy")
if self._destroy_fn:
self._destroy_fn()
self._create_fn = None
self._destroy_fn = None
self._get_visible_fn = None
self._set_visible_fn = None
def __del__(self):
self.destroy()
# called from viewport registry
@property
def visible(self):
# print("SceneCreatorProxy.get_visible")
if self._get_visible_fn:
return self._get_visible_fn()
else:
return True
@visible.setter
def visible(self, value: bool):
# print("SceneCreatorProxy.set_visible", value)
if self._set_visible_fn:
return self._set_visible_fn(value)
@property
def picking_enabled(self):
"""Object picking and selection rect."""
if self._is_legacy:
self._win.legacy_window.is_enabled_picking()
else:
# print("picking_enabled only supported for legacy viewport")
return True
@picking_enabled.setter
def picking_enabled(self, enabled):
"""Disables object picking and selection rect."""
if self._is_legacy:
self._win.legacy_window.set_enabled_picking(enabled)
else:
# print("picking_enabled only supported for legacy viewport")
pass
def temp_select_enabled(self, enable_picking):
"""Disables object picking and selection rect until next mouse up.
enable_picking: enable picking for surface snap
"""
if self._is_legacy:
self._win.legacy_window.disable_selection_rect(enable_picking)
else:
# print("temp_select_enabled only supported for legacy viewport")
pass
@property
def manipulating_camera(self):
if self._is_legacy:
return self._win.legacy_window.is_manipulating_camera()
else:
# print("is_manipulating_camera only supported for legacy viewport")
return False
def save_render(self, file_path: str, render_product_path: str = None):
"""Doesn't save any overlaid SceneView drawing"""
vut.capture_viewport_to_file(self._api,
file_path=file_path,
is_hdr=False,
render_product_path=render_product_path)
def info(self, scene_view=None):
out = f"window_name='{self.window_name}' is_legacy={self.is_legacy} usd_context_name='{self.usd_context_name} api_id='{self._api.id}'\n"
out += f"ui_size={self.ui_size} dpi={omni.ui.Workspace.get_dpi_scale()} px_size={self.px_size} ui_size_ratio={self.ui_size_ratio}\n"
out += f"render_size_px={self.render_size_px} render_fill_frame={self.render_fill_frame} render_ratio={self.render_size_ratio}\n"
if scene_view is not None:
out += f"iscene_half={self.iscene_half(scene_view)} iscene_size={self.iscene_size(scene_view)} iscene_render_half={self.iscene_render_half(scene_view)}\n"
out += f"camera_path='{self.camera_path}'\n"
out += f"camera frustrum={self.get_conformed_frustum()}\n"
view,proj = self.get_camera_view_proj()
out += f"camera matrixes: view={view} proj={proj}\n"
out += f"conform_policy={self.get_conform_policy()}\n"
if scene_view is not None:
out += f"scene_view aspect_ratio={scene_view.aspect_ratio_policy}\n"
out += f"fps={self.fps}\n"
return out
"""Examples:
vp = ViewportHelper()
res = vp.attach() # "Viewport" "Viewport Next"
print(f"attach res={res}")
frame = vp.get_frame("id")
#frame.clear()
#with frame:
# with ui.VStack():
# ui.Spacer()
# ui.Label("LABEL", alignment=ui.Alignment.CENTER, style={"font_size": 72})
# ui.Button("TO")
# ui.Spacer()
print (vp.info())
#vp.camera_path = "OmniverseKit_Top" # OmniverseKit_Persp
vp.save_render("c:/tmp/vp.png")
""" | 37,345 | Python | 29.045052 | 166 | 0.578525 |
syntway/model_exploder/exts/syntway.model_exploder/syntway/model_exploder/libs/app_helper.py | """"""
import asyncio, functools, sys
import os.path
import carb
import omni.kit
class AppHelper():
VERSION = 10
SETTING_TRANSFORM_OP = "/app/transform/operation"
def __init__(self, attach=True):
self._app = None
self._settings = None
self._setting_changed = {} # {"setting_path": [subs, set(fn0,fn1,...)], }
self._input = None
self._update_event_sub = None
self._update_event_fns = set()
self._key_action_subs = {} # {"action_name": [sub, [(fn0,fn1), (fn1,fn2), ...]] }
if attach:
res = self.attach()
if not res:
raise AssertionError("Could not attach")
def __del__(self):
self.detach()
def attach(self) -> bool:
self.detach()
self._app = omni.kit.app.get_app() # omni.kit.app
self._app_win = omni.appwindow.get_default_app_window() # omni.appwindow
self._settings = carb.settings.get_settings()
return True
def detach(self):
self._update_event_sub = None
self._update_event_fns.clear()
for v in self._setting_changed.values():
self._settings.unsubscribe_to_change_events(v[0])
self._setting_changed = {}
self._settings = None
if self._input is not None:
for v in self._key_action_subs.values():
self._input.unsubscribe_to_action_events(v[0])
self._key_action_subs = {}
self._input = None
if self._app is not None:
self._app = None
def add_update_event_fn(self, fn, order=0, subscription_name=None):
""" 0=NEW_FRAME """
if self._update_event_sub is None:
def on_update(ev):
for fn in self._update_event_fns:
fn(ev)
self._update_event_sub = self._app.get_update_event_stream().create_subscription_to_pop(on_update,
order=order,
name=subscription_name)
self._update_event_fns.clear()
self._update_event_fns.add(fn)
def remove_update_event_fn(self, fn, event_type=-1):
if self._update_event_sub:
self._update_event_fns.discard(fn)
def add_setting_changed_fn(self, setting_path, fn):
""" fn(value, event_type) """
if not setting_path in self._setting_changed:
def on_changed(item, event_type):
fns = self._setting_changed[setting_path][1]
for fn in fns:
fn(str(item), event_type)
self._setting_changed[setting_path] = [None, set()]
self._setting_changed[setting_path][0] = self._settings.subscribe_to_node_change_events(setting_path, on_changed)
s = self._setting_changed[setting_path][1]
s.add(fn)
def get_setting(self, setting_path):
return str( self._settings.get(setting_path) )
def set_setting(self, setting_path, value):
self._settings.set(setting_path, value)
def add_key_action_fn(self, action_name, key, key_modifiers, on_key_fn, is_key_enabled_fn=None):
""" key_modifiers: 1=shift, 2=ctrl, alt=4"""
if action_name in self._key_action_subs:
sub = self._key_action_subs[action_name]
if not (on_key_fn, is_key_enabled_fn) in sub[1]: # fn pair already there
sub[1].append((on_key_fn, is_key_enabled_fn))
return
if self._input is None:
self._input = carb.input.acquire_input_interface()
set_path = self._app_win.get_action_mapping_set_path()
set = self._input.get_action_mapping_set_by_path(set_path)
string = carb.input.get_string_from_action_mapping_desc(key, key_modifiers)
path = set_path + "/" + action_name + "/0"
self._settings.set_default_string(path, string)
def on_action(action_name, event, *_):
if not event.flags & carb.input.BUTTON_FLAG_PRESSED:
return
if not action_name in self._key_action_subs:
return
try: # avoid keys pressed during camera manipulation
import omni.kit.viewport_legacy
vp = omni.kit.viewport_legacy.get_viewport_interface().get_viewport_window()
if vp.is_manipulating_camera():
return
except Exception:
pass
sub = self._key_action_subs[action_name]
for on_key_fn,is_key_enabled_fn in sub[1]:
if is_key_enabled_fn is not None:
if not is_key_enabled_fn():
continue
on_key_fn()
sub = [self._input.subscribe_to_action_events(set, action_name, functools.partial(on_action, action_name)),
[(on_key_fn, is_key_enabled_fn)]]
self._key_action_subs[action_name] = sub
| 5,108 | Python | 26.320855 | 125 | 0.536022 |
syntway/model_exploder/exts/syntway.model_exploder/syntway/model_exploder/libs/usd_helper.py | """
Notes:
"""
import omni.kit
import omni.usd
from pxr import Gf, Tf, Sdf, Usd, UsdGeom, CameraUtil
from .app_utils import call_after_update
class UsdHelper():
VERSION = 17
STAGE_CHANGED_SUB_PREFIX = "UsdHelper-stage-changed-ev"
def __init__(self, attach=True, stage_opened_refresh=1 | 2):
"""
stage_opened_refresh: resubscribe events when a new stage finishes opening. A mask of:
1: resubscribe add_stage_event_fn handlers
2: resubscribe add_stage_objects_changed_fn handlers
"""
self._ctx = None
self._stage_changed = {} # event_type: [sub, set(fn,fn,...)]
self._stage_objects_changed = None # [listener, set(fn,fn,...)]
self._stage_opened_refresh = stage_opened_refresh
self._stage_opened_refresh_sub = None
if attach:
res = self.attach()
if not res:
raise AssertionError("Could not attach")
def __del__(self):
self.detach()
def attach(self, usd_ctx=None) -> bool:
"""usd_ctx can be a string for context name, or an existing UsdContext."""
self.detach()
if usd_ctx is None:
usd_ctx = ''
if isinstance(usd_ctx, str):
self._ctx = omni.usd.get_context(usd_ctx)
else:
self._ctx = usd_ctx
if self._stage_opened_refresh:
self.add_stage_event_fn(self._on_stage_opened_refresh,
omni.usd.StageEventType.OPENED)
return True
def detach(self):
if self._ctx is not None:
self._ctx = None
if self._stage_objects_changed is not None:
if len(self._stage_objects_changed):
self._stage_objects_changed[0].Revoke()
self._stage_objects_changed = None
self._stage_changed.clear()
self._stage_opened_refresh_sub = None
@property
def context(self):
return self._ctx
@property
def stage(self):
return self._ctx.get_stage()
@property
def stage_state(self) -> omni.usd.StageState:
return self._ctx.get_stage_state()
def is_stage_opened(self) -> bool:
return self.stage_state == omni.usd.StageState.OPENED
@property
def stage_up(self):
up = UsdGeom.GetStageUpAxis(self.stage)
if up == UsdGeom.Tokens.y:
return Gf.Vec3d(0, 1, 0)
elif up == UsdGeom.Tokens.z:
return Gf.Vec3d(0, 0, 1)
else: # UsdGeom.Tokens.x
return Gf.Vec3d(1, 0, 0)
@property
def stage_up_index(self):
up = UsdGeom.GetStageUpAxis(self.stage)
if up == UsdGeom.Tokens.y:
return 1
elif up == UsdGeom.Tokens.z:
return 2
else: # UsdGeom.Tokens.x: illegal
return 0
@property
def timecode(self) -> Usd.TimeCode:
stage = self.stage
"""
if stage.HasAuthoredTimeCodeRange(): -> wrong: a stage might not have timeCodes authored,
but its references may have.
Using Usd.TimeCode.Default() in xform_cache.GetLocalTransformation(prim) won't fetch correct matrices
for time_coded prims
"""
time = omni.timeline.get_timeline_interface().get_current_time()
ret = Usd.TimeCode(omni.usd.get_frame_time_code(time, stage.GetTimeCodesPerSecond()))
# or ret = Usd.TimeCode( time * stage.GetTimeCodesPerSecond() )
return ret
def add_stage_event_fn(self, fn, event_type=-1):
"""
Doesn't depend on open stage and remains after closing-opening.
Arg event_type = -1 to accept all, otherwise a single event of type omni.usd.StageEventType.*: (@Kit103)
0=SAVED
1=SAVE_FAILED
2=OPENING
3=OPENED
4=OPEN_FAILED
5=CLOSING
6=CLOSED
7=SELECTION_CHANGED
8=ASSETS_LOADED
9=ASSETS_LOAD_ABORTED
10=GIZMO_TRACKING_CHANGED
11=MDL_PARAM_LOADED
12=SETTINGS_LOADED
13=SETTINGS_SAVING
14=OMNIGRAPH_START_PLAY
15=OMNIGRAPH_STOP_PLAY
16=SIMULATION_START_PLAY
17=SIMULATION_STOP_PLAY
18=ANIMATION_START_PLAY
19=ANIMATION_STOP_PLAY
20=DIRTY_STATE_CHANGED
"""
event_type = int(event_type)
if event_type not in self._stage_changed:
sub = self._sub_stage_event(event_type)
self._stage_changed[event_type] = [sub, set()]
ch = self._stage_changed[event_type]
ch[1].add(fn)
def _sub_stage_event(self, event_type):
sub_name = UsdHelper.STAGE_CHANGED_SUB_PREFIX + str(event_type)
lamb = lambda ev: self._on_stage_event(ev, event_type)
if event_type == -1:
sub = self._ctx.get_stage_event_stream().create_subscription_to_pop(lamb,
name=sub_name)
else:
sub = self._ctx.get_stage_event_stream().create_subscription_to_pop_by_type(event_type,
lamb,
name=sub_name)
return sub
def _on_stage_event(self, ev, target_event_type):
# print("_on_stage_event", ev.type, target_event_type)
if target_event_type in self._stage_changed:
for fn in self._stage_changed[target_event_type][1]:
fn(ev)
def remove_stage_event_fn(self, fn, event_type=-1):
"""
Don't call from fn or will get:
RuntimeError: Set changed size during iteration
"""
if event_type in self._stage_changed:
ch = self._stage_changed[event_type]
ch[1].discard(fn)
def _on_stage_opened_refresh(self, ev):
# print("_on_stage_opened_refresh", ev.type)
def resub():
if self._stage_opened_refresh & 1:
# print("resub _stage_changed")
for event_type in self._stage_changed:
ch = self._stage_changed[event_type]
ch[0] = self._sub_stage_event(event_type)
if self._stage_opened_refresh & 2 and self._stage_objects_changed is not None:
# print("resub _stage_objects_changed")
self._stage_objects_changed[0] = self._sub_stage_objects_changed()
call_after_update(resub)
def add_stage_objects_changed_fn(self, fn):
# print("add_stage_objects_changed_fn")
"""
Depends on stage: if closed must call remove_stage_objects_changed_fn(), then on stage opened call add_stage_objects_changed_fn again.
From https://graphics.pixar.com/usd/dev/api/class_usd_notice_1_1_objects_changed.html:
Usd.Notice.ObjectsChanged: Object changes, either "resync" or "changed-info".
"Resyncs" are potentially structural changes that invalidate entire subtrees of UsdObjects (including prims and properties).
For example, if the path "/foo" is resynced, then all subpaths like "/foo/bar" and "/foo/bar.baz" may be arbitrarily changed.
When a prim is resynced, say "/foo/bar", it might have been created or destroyed. In that case "/foo"'s list of children will have changed, but we do not consider "/foo" to be resynced. If we did, it would mean clients would have to consider all of "/foo/bar"'s siblings (and their descendants) to be resynced which might be egregious overinvalidation.
In contrast, "changed-info" means that a nonstructural change has occurred, like an attribute value change or a value change to a metadata field not related to composition.
This notice provides API for two client use-cases. Clients interested in testing whether specific objects are affected by the changes should use the AffectedObject()
method (and the ResyncedObject() and ChangedInfoOnly() methods).
Clients that wish to reason about all changes as a whole should use the GetResyncedPaths() and GetChangedInfoOnlyPaths() methods.
fn(notice: Tf.notice) can call notice.GetChangedInfoOnlyPaths()
"""
if self._stage_objects_changed is None:
# handler needs to be a method as Register won't hold reference to a local function
listener = self._sub_stage_objects_changed()
self._stage_objects_changed = [listener, set()]
val = self._stage_objects_changed
val[1].add(fn)
# print("add")
def _sub_stage_objects_changed(self):
return Tf.Notice.Register(Usd.Notice.ObjectsChanged, self._on_stage_objects_changed, self.stage)
def _on_stage_objects_changed(self, notice, stage):
if stage != self.stage or self._stage_objects_changed is None:
return
for fn in self._stage_objects_changed[1]:
fn(notice)
def remove_stage_objects_changed_fn(self, fn):
# print("remove_stage_objects_changed_fn")
if self._stage_objects_changed is not None:
val = self._stage_objects_changed
val[1].discard(fn)
# print("discard")
def get_selected_prim_paths(self):
sel = self.get_selection()
return sel.get_selected_prim_paths()
def set_selected_prim_paths(self, paths, expand_in_stage=False):
sel = self.get_selection()
sel.set_selected_prim_paths(paths, expand_in_stage)
def get_selection(self):
return self._ctx.get_selection()
def set_pickable(self, enabled, prim_path="/"):
"""If disabled, Kit will still display selection rects but nothing will be selected."""
self._ctx.set_pickable(prim_path, enabled)
"""
Timeline events
stream = omni.timeline.get_timeline_interface().get_timeline_event_stream()
self._timeline_sub = stream.create_subscription_to_pop(self._on_timeline_event)
0=PLAY
1=PAUSE
2=STOP
3=CURRENT_TIME_CHANGED
4=CURRENT_TIME_TICKED
5=LOOP_MODE_CHANGED
6=START_TIME_CHANGED
7=END_TIME_CHANGED
8=TIME_CODE_PER_SECOND_CHANGED
9=AUTO_UPDATE_CHANGED
10=PREROLLING_CHANGED
""" | 10,223 | Python | 28.80758 | 360 | 0.60002 |
syntway/model_exploder/exts/syntway.model_exploder/config/extension.toml | [package]
# Semantic versioning: https://semver.org/
version = "0.9.5"
title = "Model Exploder"
description="Separate model parts to view their relationship and how they fit together."
authors = ["Syntway"]
category = "Tools"
keywords = ["kit", "tool", "tools", "util", "utils", "explode model", "exploded view"]
# repository = "https://github.com/syntway/model_exploder"
icon = "data/icons/ext.png"
preview_image = "data/preview.png"
readme = "docs/README.md"
changelog = "docs/CHANGELOG.md"
[dependencies]
"omni.kit.uiapp" = {}
"omni.kit.viewport.utility" = {}
"omni.ui.scene" = {}
"omni.usd" = {}
[[python.module]]
name = "syntway.model_exploder"
| 659 | TOML | 20.999999 | 88 | 0.68437 |
syntway/model_exploder/exts/syntway.model_exploder/docs/CHANGELOG.md | # Changelog
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
## [0.9.5] - 2024-04-12
### Changed
- Fix deprecated SDF.Begin/EndChangeBlock() reference.
- Bump version.
## [0.9.4] - 2022-12-07
### Changed
- Moved menu entry to the Window top-level menu, because some apps hide the Tools menu, like Code.
## [0.9.3] - 2022-12-04
### Changed
- New UiPal for simpler color handling. Changed styles and supporting code to use it.
- ReadMe doc updated.
## [0.9.2] - 2022-11-12
### Changed
- Compatible with the multiple viewports of Create 2022.3. The initial bounds and center manipulator work in the viewport which is active when the tool window opens.
- Initial Bounds Visibility displays in mid-grey to be visible in bright backgrounds.
- Info button link changed to Syntway's website.
## [0.9.1] - 2022-10-29
### Added
- First public release.
| 968 | Markdown | 32.413792 | 165 | 0.722107 |
syntway/model_exploder/exts/syntway.model_exploder/docs/README.md | # Model Exploder Tool
Model Exploder separates a 3D model into its parts for a better view of their relationship and how they fit together.
Model separation is done as if by a small controlled explosion emanating from its center. This is often known as an exploded-view of the model.
Exploded-views can be used to understand a model from its components and can also be used to create drawings for parts catalogs or assembly/maintenance/instruction information.
## Features
- Easy to use: select a model, click the Use button and move the Distance slider.
- Includes several ways to explode the model around a central point, axis or plane.
- Interactive editing of the explosion center: just drag the "Center" manipulator in the viewport.
- Works with meshes, USD Shapes, references/payloads. Point instances and skeletons are moved as a whole.
- Adds Undo-Redo state when applying changes.
- Works with NVIDIA's Omniverse Create, Code 2022+ or any other Kit-based apps. Compatible with multiple viewports and with the legacy viewport of older Omniverse versions.
### Tips
- Model Exploder is available in the Window menu.
- Click the ( i ) button for help and more information.
- On complex models, the first interaction with the Distance slider might take a few seconds - next ones are much faster.
- If model parts do not separate and remain joined to each other:
- Make sure model is divided in parts (meshes, USD shapes, etc), as this tools works by moving those parts.
- With the Distance slider away from its leftmost position, move the Center manipulator in the viewport into the middle of the parts group.
- Separate the group of "stuck" parts before separating the rest of the model.
- The initial bounds preview and center manipulator work in the active (last used) viewport. To change viewports, close the Model Exploder window and open again after using the new viewport.
## Credits
This tool is developed by Syntway, the VR/Metaverse tools division of FaronStudio: www.syntway.com
Uses icons from SVG Repo: www.svgrepo.com
3D model used in the preview snapshot is from mdesigns100: 3dexport.com/free-3dmodel-residential-building-model-296192.htm
| 2,175 | Markdown | 61.171427 | 190 | 0.788506 |
NVIDIA-Omniverse/OmniIsaacGymEnvs/setup.py | # Copyright (c) 2018-2022, NVIDIA Corporation
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# 1. Redistributions of source code must retain the above copyright notice, this
# list of conditions and the following disclaimer.
#
# 2. Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions and the following disclaimer in the documentation
# and/or other materials provided with the distribution.
#
# 3. Neither the name of the copyright holder nor the names of its
# contributors may be used to endorse or promote products derived from
# this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
"""Installation script for the 'isaacgymenvs' python package."""
from __future__ import absolute_import
from __future__ import print_function
from __future__ import division
from setuptools import setup, find_packages
import os
# Minimum dependencies required prior to installation
INSTALL_REQUIRES = [
"numpy==1.23.5",
"protobuf==3.20.2",
"omegaconf==2.3.0",
"hydra-core==1.3.2",
"urllib3==1.26.16",
"rl-games==1.6.1",
"moviepy==1.0.3"
]
# Installation operation
setup(
name="omniisaacgymenvs",
author="NVIDIA",
version="2023.1.1a",
description="RL environments for robot learning in NVIDIA Isaac Sim.",
keywords=["robotics", "rl"],
include_package_data=True,
install_requires=INSTALL_REQUIRES,
packages=find_packages("."),
classifiers=["Natural Language :: English", "Programming Language :: Python :: 3.7, 3.8"],
zip_safe=False,
)
# EOF
| 2,474 | Python | 36.499999 | 94 | 0.740905 |
NVIDIA-Omniverse/OmniIsaacGymEnvs/README.md | # Omniverse Isaac Gym Reinforcement Learning Environments for Isaac Sim
## About this repository
This repository contains Reinforcement Learning examples that can be run with the latest release of [Isaac Sim](https://docs.omniverse.nvidia.com/app_isaacsim/app_isaacsim/overview.html). RL examples are trained using PPO from [rl_games](https://github.com/Denys88/rl_games) library and examples are built on top of Isaac Sim's `omni.isaac.core` and `omni.isaac.gym` frameworks.
Please see [release notes](docs/release_notes.md) for the latest updates.
<img src="https://user-images.githubusercontent.com/34286328/171454189-6afafbff-bb61-4aac-b518-24646007cb9f.gif" width="300" height="150"/> <img src="https://user-images.githubusercontent.com/34286328/184172037-cdad9ee8-f705-466f-bbde-3caa6c7dea37.gif" width="300" height="150"/>
<img src="https://user-images.githubusercontent.com/34286328/171454182-0be1b830-bceb-4cfd-93fb-e1eb8871ec68.gif" width="300" height="150"/> <img src="https://user-images.githubusercontent.com/34286328/171454193-e027885d-1510-4ef4-b838-06b37f70c1c7.gif" width="300" height="150"/>
<img src="https://user-images.githubusercontent.com/34286328/184174894-03767aa0-936c-4bfe-bbe9-a6865f539bb4.gif" width="300" height="150"/> <img src="https://user-images.githubusercontent.com/34286328/184168200-152567a8-3354-4947-9ae0-9443a56fee4c.gif" width="300" height="150"/>
<img src="https://user-images.githubusercontent.com/34286328/184176312-df7d2727-f043-46e3-b537-48a583d321b9.gif" width="300" height="150"/> <img src="https://user-images.githubusercontent.com/34286328/184178817-9c4b6b3c-c8a2-41fb-94be-cfc8ece51d5d.gif" width="300" height="150"/>
<img src="https://user-images.githubusercontent.com/34286328/171454160-8cb6739d-162a-4c84-922d-cda04382633f.gif" width="300" height="150"/> <img src="https://user-images.githubusercontent.com/34286328/171454176-ce08f6d0-3087-4ecc-9273-7d30d8f73f6d.gif" width="300" height="150"/>
<img src="https://user-images.githubusercontent.com/34286328/184170040-3f76f761-e748-452e-b8c8-3cc1c7c8cb98.gif" width="614" height="307"/>
## System Requirements
It is recommended to have at least 32GB RAM and a GPU with at least 12GB VRAM. For detailed system requirements, please visit the [Isaac Sim System Requirements](https://docs.omniverse.nvidia.com/isaacsim/latest/installation/requirements.html#system-requirements) page. Please refer to the [Troubleshooting](docs/troubleshoot.md#memory-consumption) page for a detailed breakdown of memory consumption.
## Installation
Follow the Isaac Sim [documentation](https://docs.omniverse.nvidia.com/isaacsim/latest/installation/install_workstation.html) to install the latest Isaac Sim release.
*Examples in this repository rely on features from the most recent Isaac Sim release. Please make sure to update any existing Isaac Sim build to the latest release version, 2023.1.1, to ensure examples work as expected.*
Once installed, this repository can be used as a python module, `omniisaacgymenvs`, with the python executable provided in Isaac Sim.
To install `omniisaacgymenvs`, first clone this repository:
```bash
git clone https://github.com/NVIDIA-Omniverse/OmniIsaacGymEnvs.git
```
Once cloned, locate the [python executable in Isaac Sim](https://docs.omniverse.nvidia.com/isaacsim/latest/installation/install_python.html). By default, this should be `python.sh`. We will refer to this path as `PYTHON_PATH`.
To set a `PYTHON_PATH` variable in the terminal that links to the python executable, we can run a command that resembles the following. Make sure to update the paths to your local path.
```
For Linux: alias PYTHON_PATH=~/.local/share/ov/pkg/isaac_sim-*/python.sh
For Windows: doskey PYTHON_PATH=C:\Users\user\AppData\Local\ov\pkg\isaac_sim-*\python.bat $*
For IsaacSim Docker: alias PYTHON_PATH=/isaac-sim/python.sh
```
Install `omniisaacgymenvs` as a python module for `PYTHON_PATH`:
```bash
PYTHON_PATH -m pip install -e .
```
The following error may appear during the initial installation. This error is harmless and can be ignored.
```
ERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.
```
### Running the examples
*Note: All commands should be executed from `OmniIsaacGymEnvs/omniisaacgymenvs`.*
To train your first policy, run:
```bash
PYTHON_PATH scripts/rlgames_train.py task=Cartpole
```
An Isaac Sim app window should be launched. Once Isaac Sim initialization completes, the Cartpole scene will be constructed and simulation will start running automatically. The process will terminate once training finishes.
Note that by default, we show a Viewport window with rendering, which slows down training. You can choose to close the Viewport window during training for better performance. The Viewport window can be re-enabled by selecting `Window > Viewport` from the top menu bar.
To achieve maximum performance, launch training in `headless` mode as follows:
```bash
PYTHON_PATH scripts/rlgames_train.py task=Ant headless=True
```
#### A Note on the Startup Time of the Simulation
Some of the examples could take a few minutes to load because the startup time scales based on the number of environments. The startup time will continually
be optimized in future releases.
### Extension Workflow
The extension workflow provides a simple user interface for creating and launching RL tasks. To launch Isaac Sim for the extension workflow, run:
```bash
./<isaac_sim_root>/isaac-sim.gym.sh --ext-folder </parent/directory/to/OIGE>
```
Note: `isaac_sim_root` should be located in the same directory as `python.sh`.
The UI window can be activated from `Isaac Examples > RL Examples` by navigating the top menu bar.
For more details on the extension workflow, please refer to the [documentation](docs/framework/extension_workflow.md).
### Loading trained models // Checkpoints
Checkpoints are saved in the folder `runs/EXPERIMENT_NAME/nn` where `EXPERIMENT_NAME`
defaults to the task name, but can also be overridden via the `experiment` argument.
To load a trained checkpoint and continue training, use the `checkpoint` argument:
```bash
PYTHON_PATH scripts/rlgames_train.py task=Ant checkpoint=runs/Ant/nn/Ant.pth
```
To load a trained checkpoint and only perform inference (no training), pass `test=True`
as an argument, along with the checkpoint name. To avoid rendering overhead, you may
also want to run with fewer environments using `num_envs=64`:
```bash
PYTHON_PATH scripts/rlgames_train.py task=Ant checkpoint=runs/Ant/nn/Ant.pth test=True num_envs=64
```
Note that if there are special characters such as `[` or `=` in the checkpoint names,
you will need to escape them and put quotes around the string. For example,
`checkpoint="runs/Ant/nn/last_Antep\=501rew\[5981.31\].pth"`
We provide pre-trained checkpoints on the [Nucleus](https://docs.omniverse.nvidia.com/nucleus/latest/index.html) server under `Assets/Isaac/2023.1.1/Isaac/Samples/OmniIsaacGymEnvs/Checkpoints`. Run the following command
to launch inference with pre-trained checkpoint:
Localhost (To set up localhost, please refer to the [Isaac Sim installation guide](https://docs.omniverse.nvidia.com/isaacsim/latest/installation/install_workstation.html)):
```bash
PYTHON_PATH scripts/rlgames_train.py task=Ant checkpoint=omniverse://localhost/NVIDIA/Assets/Isaac/2023.1.1/Isaac/Samples/OmniIsaacGymEnvs/Checkpoints/ant.pth test=True num_envs=64
```
Production server:
```bash
PYTHON_PATH scripts/rlgames_train.py task=Ant checkpoint=http://omniverse-content-production.s3-us-west-2.amazonaws.com/Assets/Isaac/2023.1.1/Isaac/Samples/OmniIsaacGymEnvs/Checkpoints/ant.pth test=True num_envs=64
```
When running with a pre-trained checkpoint for the first time, we will automatically download the checkpoint file to `omniisaacgymenvs/checkpoints`. For subsequent runs, we will re-use the file that has already been downloaded, and will not overwrite existing checkpoints with the same name in the `checkpoints` folder.
## Runing from Docker
Latest Isaac Sim Docker image can be found on [NGC](https://catalog.ngc.nvidia.com/orgs/nvidia/containers/isaac-sim). A utility script is provided at `docker/run_docker.sh` to help initialize this repository and launch the Isaac Sim docker container. The script can be run with:
```bash
./docker/run_docker.sh
```
Then, training can be launched from the container with:
```bash
/isaac-sim/python.sh scripts/rlgames_train.py headless=True task=Ant
```
To run the Isaac Sim docker with UI, use the following script:
```bash
./docker/run_docker_viewer.sh
```
Then, training can be launched from the container with:
```bash
/isaac-sim/python.sh scripts/rlgames_train.py task=Ant
```
To avoid re-installing OIGE each time a container is launched, we also provide a dockerfile that can be used to build an image with OIGE installed. To build the image, run:
```bash
docker build -t isaac-sim-oige -f docker/dockerfile .
```
Then, start a container with the built image:
```bash
./docker/run_dockerfile.sh
```
Then, training can be launched from the container with:
```bash
/isaac-sim/python.sh scripts/rlgames_train.py task=Ant headless=True
```
### Isaac Sim Automator
Cloud instances for AWS, Azure, or GCP can be setup using [IsaacSim Automator](https://github.com/NVIDIA-Omniverse/IsaacSim-Automator/tree/main#omniverse-isaac-gym).
## Livestream
OmniIsaacGymEnvs supports livestream through the [Omniverse Streaming Client](https://docs.omniverse.nvidia.com/app_streaming-client/app_streaming-client/overview.html). To enable this feature, add the commandline argument `enable_livestream=True`:
```bash
PYTHON_PATH scripts/rlgames_train.py task=Ant headless=True enable_livestream=True
```
Connect from the Omniverse Streaming Client once the SimulationApp has been created. Note that enabling livestream is equivalent to training with the viewer enabled, thus the speed of training/inferencing will decrease compared to running in headless mode.
## Training Scripts
All scripts provided in `omniisaacgymenvs/scripts` can be launched directly with `PYTHON_PATH`.
To test out a task without RL in the loop, run the random policy script with:
```bash
PYTHON_PATH scripts/random_policy.py task=Cartpole
```
This script will sample random actions from the action space and apply these actions to your task without running any RL policies. Simulation should start automatically after launching the script, and will run indefinitely until terminated.
To run a simple form of PPO from `rl_games`, use the single-threaded training script:
```bash
PYTHON_PATH scripts/rlgames_train.py task=Cartpole
```
This script creates an instance of the PPO runner in `rl_games` and automatically launches training and simulation. Once training completes (the total number of iterations have been reached), the script will exit. If running inference with `test=True checkpoint=<path/to/checkpoint>`, the script will run indefinitely until terminated. Note that this script will have limitations on interaction with the UI.
### Configuration and command line arguments
We use [Hydra](https://hydra.cc/docs/intro/) to manage the config.
Common arguments for the training scripts are:
* `task=TASK` - Selects which task to use. Any of `AllegroHand`, `Ant`, `Anymal`, `AnymalTerrain`, `BallBalance`, `Cartpole`, `CartpoleCamera`, `Crazyflie`, `FactoryTaskNutBoltPick`, `FactoryTaskNutBoltPlace`, `FactoryTaskNutBoltScrew`, `FrankaCabinet`, `FrankaDeformable`, `Humanoid`, `Ingenuity`, `Quadcopter`, `ShadowHand`, `ShadowHandOpenAI_FF`, `ShadowHandOpenAI_LSTM` (these correspond to the config for each environment in the folder `omniisaacgymenvs/cfg/task`)
* `train=TRAIN` - Selects which training config to use. Will automatically default to the correct config for the environment (ie. `<TASK>PPO`).
* `num_envs=NUM_ENVS` - Selects the number of environments to use (overriding the default number of environments set in the task config).
* `seed=SEED` - Sets a seed value for randomization, and overrides the default seed in the task config
* `pipeline=PIPELINE` - Which API pipeline to use. Defaults to `gpu`, can also set to `cpu`. When using the `gpu` pipeline, all data stays on the GPU. When using the `cpu` pipeline, simulation can run on either CPU or GPU, depending on the `sim_device` setting, but a copy of the data is always made on the CPU at every step.
* `sim_device=SIM_DEVICE` - Device used for physics simulation. Set to `gpu` (default) to use GPU and to `cpu` for CPU.
* `device_id=DEVICE_ID` - Device ID for GPU to use for simulation and task. Defaults to `0`. This parameter will only be used if simulation runs on GPU.
* `rl_device=RL_DEVICE` - Which device / ID to use for the RL algorithm. Defaults to `cuda:0`, and follows PyTorch-like device syntax.
* `multi_gpu=MULTI_GPU` - Whether to train using multiple GPUs. Defaults to `False`. Note that this option is only available with `rlgames_train.py`.
* `test=TEST`- If set to `True`, only runs inference on the policy and does not do any training.
* `checkpoint=CHECKPOINT_PATH` - Path to the checkpoint to load for training or testing.
* `headless=HEADLESS` - Whether to run in headless mode.
* `enable_livestream=ENABLE_LIVESTREAM` - Whether to enable Omniverse streaming.
* `experiment=EXPERIMENT` - Sets the name of the experiment.
* `max_iterations=MAX_ITERATIONS` - Sets how many iterations to run for. Reasonable defaults are provided for the provided environments.
* `warp=WARP` - If set to True, launch the task implemented with Warp backend (Note: not all tasks have a Warp implementation).
* `kit_app=KIT_APP` - Specifies the absolute path to the kit app file to be used.
Hydra also allows setting variables inside config files directly as command line arguments. As an example, to set the minibatch size for a rl_games training run, you can use `train.params.config.minibatch_size=64`. Similarly, variables in task configs can also be set. For example, `task.env.episodeLength=100`.
#### Hydra Notes
Default values for each of these are found in the `omniisaacgymenvs/cfg/config.yaml` file.
The way that the `task` and `train` portions of the config works are through the use of config groups.
You can learn more about how these work [here](https://hydra.cc/docs/tutorials/structured_config/config_groups/)
The actual configs for `task` are in `omniisaacgymenvs/cfg/task/<TASK>.yaml` and for `train` in `omniisaacgymenvs/cfg/train/<TASK>PPO.yaml`.
In some places in the config you will find other variables referenced (for example,
`num_actors: ${....task.env.numEnvs}`). Each `.` represents going one level up in the config hierarchy.
This is documented fully [here](https://omegaconf.readthedocs.io/en/latest/usage.html#variable-interpolation).
### Tensorboard
Tensorboard can be launched during training via the following command:
```bash
PYTHON_PATH -m tensorboard.main --logdir runs/EXPERIMENT_NAME/summaries
```
## WandB support
You can run (WandB)[https://wandb.ai/] with OmniIsaacGymEnvs by setting `wandb_activate=True` flag from the command line. You can set the group, name, entity, and project for the run by setting the `wandb_group`, `wandb_name`, `wandb_entity` and `wandb_project` arguments. Make sure you have WandB installed in the Isaac Sim Python executable with `PYTHON_PATH -m pip install wandb` before activating.
## Training with Multiple GPUs
To train with multiple GPUs, use the following command, where `--proc_per_node` represents the number of available GPUs:
```bash
PYTHON_PATH -m torch.distributed.run --nnodes=1 --nproc_per_node=2 scripts/rlgames_train.py headless=True task=Ant multi_gpu=True
```
## Multi-Node Training
To train across multiple nodes/machines, it is required to launch an individual process on each node.
For the master node, use the following command, where `--proc_per_node` represents the number of available GPUs, and `--nnodes` represents the number of nodes:
```bash
PYTHON_PATH -m torch.distributed.run --nproc_per_node=2 --nnodes=2 --node_rank=0 --rdzv_id=123 --rdzv_backend=c10d --rdzv_endpoint=localhost:5555 scripts/rlgames_train.py headless=True task=Ant multi_gpu=True
```
Note that the port (`5555`) can be replaced with any other available port.
For non-master nodes, use the following command, replacing `--node_rank` with the index of each machine:
```bash
PYTHON_PATH -m torch.distributed.run --nproc_per_node=2 --nnodes=2 --node_rank=1 --rdzv_id=123 --rdzv_backend=c10d --rdzv_endpoint=ip_of_master_machine:5555 scripts/rlgames_train.py headless=True task=Ant multi_gpu=True
```
For more details on multi-node training with PyTorch, please visit [here](https://pytorch.org/tutorials/intermediate/ddp_series_multinode.html). As mentioned in the PyTorch documentation, "multinode training is bottlenecked by inter-node communication latencies". When this latency is high, it is possible multi-node training will perform worse than running on a single node instance.
## Tasks
Source code for tasks can be found in `omniisaacgymenvs/tasks`.
Each task follows the frameworks provided in `omni.isaac.core` and `omni.isaac.gym` in Isaac Sim.
Refer to [docs/framework/framework.md](docs/framework/framework.md) for how to create your own tasks.
Full details on each of the tasks available can be found in the [RL examples documentation](docs/examples/rl_examples.md).
## Demo
We provide an interactable demo based on the `AnymalTerrain` RL example. In this demo, you can click on any of
the ANYmals in the scene to go into third-person mode and manually control the robot with your keyboard as follows:
- `Up Arrow`: Forward linear velocity command
- `Down Arrow`: Backward linear velocity command
- `Left Arrow`: Leftward linear velocity command
- `Right Arrow`: Rightward linear velocity command
- `Z`: Counterclockwise yaw angular velocity command
- `X`: Clockwise yaw angular velocity command
- `C`: Toggles camera view between third-person and scene view while maintaining manual control
- `ESC`: Unselect a selected ANYmal and yields manual control
Launch this demo with the following command. Note that this demo limits the maximum number of ANYmals in the scene to 128.
```
PYTHON_PATH scripts/rlgames_demo.py task=AnymalTerrain num_envs=64 checkpoint=omniverse://localhost/NVIDIA/Assets/Isaac/2023.1.1/Isaac/Samples/OmniIsaacGymEnvs/Checkpoints/anymal_terrain.pth
```
<img src="https://user-images.githubusercontent.com/34286328/184688654-6e7899b2-5847-4184-8944-2a96b129b1ff.gif" width="600" height="300"/>
| 18,653 | Markdown | 55.871951 | 469 | 0.777408 |
NVIDIA-Omniverse/OmniIsaacGymEnvs/config/extension.toml | [gym]
reloadable = true
[package]
version = "0.0.0"
category = "Simulation"
title = "Isaac Gym Envs"
description = "RL environments"
authors = ["Isaac Sim Team"]
repository = "https://gitlab-master.nvidia.com/carbon-gym/omniisaacgymenvs"
keywords = ["isaac"]
changelog = "docs/CHANGELOG.md"
readme = "docs/README.md"
icon = "data/icon.png"
writeTarget.kit = true
[dependencies]
"omni.isaac.gym" = {}
"omni.isaac.core" = {}
"omni.isaac.cloner" = {}
"omni.isaac.ml_archive" = {} # torch
[[python.module]]
name = "omniisaacgymenvs"
| 532 | TOML | 20.319999 | 75 | 0.693609 |
NVIDIA-Omniverse/OmniIsaacGymEnvs/omniisaacgymenvs/extension.py | # Copyright (c) 2018-2023, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
import asyncio
import inspect
import os
import traceback
import weakref
from abc import abstractmethod
import gym
import hydra
import omni.ext
import omni.timeline
import omni.ui as ui
import omni.usd
from hydra import compose, initialize
from omegaconf import OmegaConf
from omni.isaac.cloner import GridCloner
from omni.isaac.core.utils.extensions import disable_extension, enable_extension
from omni.isaac.core.utils.torch.maths import set_seed
from omni.isaac.core.utils.viewports import set_camera_view
from omni.isaac.core.world import World
import omniisaacgymenvs
from omniisaacgymenvs.envs.vec_env_rlgames_mt import VecEnvRLGamesMT
from omniisaacgymenvs.utils.config_utils.sim_config import SimConfig
from omniisaacgymenvs.utils.hydra_cfg.reformat import omegaconf_to_dict, print_dict
from omniisaacgymenvs.utils.rlgames.rlgames_train_mt import RLGTrainer, Trainer
from omniisaacgymenvs.utils.task_util import import_tasks, initialize_task
from omni.isaac.ui.callbacks import on_open_folder_clicked, on_open_IDE_clicked
from omni.isaac.ui.menu import make_menu_item_description
from omni.isaac.ui.ui_utils import (
btn_builder,
dropdown_builder,
get_style,
int_builder,
multi_btn_builder,
multi_cb_builder,
scrolling_frame_builder,
setup_ui_headers,
str_builder,
)
from omni.kit.menu.utils import MenuItemDescription, add_menu_items, remove_menu_items
from omni.kit.viewport.utility import get_active_viewport, get_viewport_from_window_name
from omni.kit.viewport.utility.camera_state import ViewportCameraState
from pxr import Gf
ext_instance = None
class RLExtension(omni.ext.IExt):
def on_startup(self, ext_id: str):
self._render_modes = ["Full render", "UI only", "None"]
self._env = None
self._task = None
self._ext_id = ext_id
ext_manager = omni.kit.app.get_app().get_extension_manager()
extension_path = ext_manager.get_extension_path(ext_id)
self._ext_path = os.path.dirname(extension_path) if os.path.isfile(extension_path) else extension_path
self._ext_file_path = os.path.abspath(__file__)
self._initialize_task_list()
self.start_extension(
"",
"",
"RL Examples",
"RL Examples",
"",
"A set of reinforcement learning examples.",
self._ext_file_path,
)
self._task_initialized = False
self._task_changed = False
self._is_training = False
self._render = True
self._resume = False
self._test = False
self._evaluate = False
self._checkpoint_path = ""
self._timeline = omni.timeline.get_timeline_interface()
self._viewport = get_active_viewport()
self._viewport.updates_enabled = True
global ext_instance
ext_instance = self
def _initialize_task_list(self):
self._task_map, _ = import_tasks()
self._task_list = list(self._task_map.keys())
self._task_list.sort()
self._task_list.remove("CartpoleCamera") # we cannot run camera-based training from extension workflow for now. it requires a specialized app file.
self._task_name = self._task_list[0]
self._parse_config(self._task_name)
self._update_task_file_paths(self._task_name)
def _update_task_file_paths(self, task):
self._task_file_path = os.path.abspath(inspect.getfile(self._task_map[task]))
self._task_cfg_file_path = os.path.join(os.path.dirname(self._ext_file_path), f"cfg/task/{task}.yaml")
self._train_cfg_file_path = os.path.join(os.path.dirname(self._ext_file_path), f"cfg/train/{task}PPO.yaml")
def _parse_config(self, task, num_envs=None, overrides=None):
hydra.core.global_hydra.GlobalHydra.instance().clear()
initialize(version_base=None, config_path="cfg")
overrides_list = [f"task={task}"]
if overrides is not None:
overrides_list += overrides
if num_envs is None:
self._cfg = compose(config_name="config", overrides=overrides_list)
else:
self._cfg = compose(config_name="config", overrides=overrides_list + [f"num_envs={num_envs}"])
self._cfg_dict = omegaconf_to_dict(self._cfg)
self._sim_config = SimConfig(self._cfg_dict)
def start_extension(
self,
menu_name: str,
submenu_name: str,
name: str,
title: str,
doc_link: str,
overview: str,
file_path: str,
number_of_extra_frames=1,
window_width=550,
keep_window_open=False,
):
window = ui.Workspace.get_window("Property")
if window:
window.visible = False
window = ui.Workspace.get_window("Render Settings")
if window:
window.visible = False
menu_items = [make_menu_item_description(self._ext_id, name, lambda a=weakref.proxy(self): a._menu_callback())]
if menu_name == "" or menu_name is None:
self._menu_items = menu_items
elif submenu_name == "" or submenu_name is None:
self._menu_items = [MenuItemDescription(name=menu_name, sub_menu=menu_items)]
else:
self._menu_items = [
MenuItemDescription(
name=menu_name, sub_menu=[MenuItemDescription(name=submenu_name, sub_menu=menu_items)]
)
]
add_menu_items(self._menu_items, "Isaac Examples")
self._task_dropdown = None
self._cbs = None
self._build_ui(
name=name,
title=title,
doc_link=doc_link,
overview=overview,
file_path=file_path,
number_of_extra_frames=number_of_extra_frames,
window_width=window_width,
keep_window_open=keep_window_open,
)
return
def _build_ui(
self, name, title, doc_link, overview, file_path, number_of_extra_frames, window_width, keep_window_open
):
self._window = omni.ui.Window(
name, width=window_width, height=0, visible=keep_window_open, dockPreference=ui.DockPreference.LEFT_BOTTOM
)
with self._window.frame:
self._main_stack = ui.VStack(spacing=5, height=0)
with self._main_stack:
setup_ui_headers(self._ext_id, file_path, title, doc_link, overview)
self._controls_frame = ui.CollapsableFrame(
title="World Controls",
width=ui.Fraction(1),
height=0,
collapsed=False,
style=get_style(),
horizontal_scrollbar_policy=ui.ScrollBarPolicy.SCROLLBAR_AS_NEEDED,
vertical_scrollbar_policy=ui.ScrollBarPolicy.SCROLLBAR_ALWAYS_ON,
)
with self._controls_frame:
with ui.VStack(style=get_style(), spacing=5, height=0):
with ui.HStack(style=get_style()):
with ui.VStack(style=get_style(), width=ui.Fraction(20)):
dict = {
"label": "Select Task",
"type": "dropdown",
"default_val": 0,
"items": self._task_list,
"tooltip": "Select a task",
"on_clicked_fn": self._on_task_select,
}
self._task_dropdown = dropdown_builder(**dict)
with ui.Frame(tooltip="Open Source Code"):
ui.Button(
name="IconButton",
width=20,
height=20,
clicked_fn=lambda: on_open_IDE_clicked(self._ext_path, self._task_file_path),
style=get_style()["IconButton.Image::OpenConfig"],
alignment=ui.Alignment.LEFT_CENTER,
tooltip="Open in IDE",
)
with ui.Frame(tooltip="Open Task Config"):
ui.Button(
name="IconButton",
width=20,
height=20,
clicked_fn=lambda: on_open_IDE_clicked(self._ext_path, self._task_cfg_file_path),
style=get_style()["IconButton.Image::OpenConfig"],
alignment=ui.Alignment.LEFT_CENTER,
tooltip="Open in IDE",
)
with ui.Frame(tooltip="Open Training Config"):
ui.Button(
name="IconButton",
width=20,
height=20,
clicked_fn=lambda: on_open_IDE_clicked(self._ext_path, self._train_cfg_file_path),
style=get_style()["IconButton.Image::OpenConfig"],
alignment=ui.Alignment.LEFT_CENTER,
tooltip="Open in IDE",
)
dict = {
"label": "Number of environments",
"tooltip": "Enter the number of environments to construct",
"min": 0,
"max": 8192,
"default_val": self._cfg.task.env.numEnvs,
}
self._num_envs_int = int_builder(**dict)
dict = {
"label": "Load Environment",
"type": "button",
"text": "Load",
"tooltip": "Load Environment and Task",
"on_clicked_fn": self._on_load_world,
}
self._load_env_button = btn_builder(**dict)
dict = {
"label": "Rendering Mode",
"type": "dropdown",
"default_val": 0,
"items": self._render_modes,
"tooltip": "Select a rendering mode",
"on_clicked_fn": self._on_render_mode_select,
}
self._render_dropdown = dropdown_builder(**dict)
dict = {
"label": "Configure Training",
"count": 3,
"text": ["Resume from Checkpoint", "Test", "Evaluate"],
"default_val": [False, False, False],
"tooltip": [
"",
"Resume training from checkpoint",
"Play a trained policy",
"Evaluate a policy during training",
],
"on_clicked_fn": [
self._on_resume_cb_update,
self._on_test_cb_update,
self._on_evaluate_cb_update,
],
}
self._cbs = multi_cb_builder(**dict)
dict = {
"label": "Load Checkpoint",
"tooltip": "Enter path to checkpoint file",
"on_clicked_fn": self._on_checkpoint_update,
}
self._checkpoint_str = str_builder(**dict)
dict = {
"label": "Train/Test",
"count": 2,
"text": ["Start", "Stop"],
"tooltip": [
"",
"Launch new training/inference run",
"Terminate current training/inference run",
],
"on_clicked_fn": [self._on_train, self._on_train_stop],
}
self._buttons = multi_btn_builder(**dict)
return
def create_task(self):
headless = self._cfg.headless
enable_viewport = "enable_cameras" in self._cfg.task.sim and self._cfg.task.sim.enable_cameras
self._env = VecEnvRLGamesMT(
headless=headless,
sim_device=self._cfg.device_id,
enable_livestream=self._cfg.enable_livestream,
enable_viewport=enable_viewport or self._cfg.enable_recording,
launch_simulation_app=False,
)
# parse experiment directory
module_path = os.path.abspath(os.path.join(os.path.dirname(omniisaacgymenvs.__file__)))
experiment_dir = os.path.join(module_path, "runs", self._cfg.train.params.config.name)
# use gym RecordVideo wrapper for viewport recording
if self._cfg.enable_recording:
if self._cfg.recording_dir == '':
videos_dir = os.path.join(experiment_dir, "videos")
else:
videos_dir = self._cfg.recording_dir
video_interval = lambda step: step % self._cfg.recording_interval == 0
video_length = self._cfg.recording_length
self._env.is_vector_env = True
if self._env.metadata is None:
self._env.metadata = {"render_modes": ["rgb_array"], "render_fps": self._cfg.recording_fps}
else:
self._env.metadata["render_modes"] = ["rgb_array"]
self._env.metadata["render_fps"] = self._cfg.recording_fps
self._env = gym.wrappers.RecordVideo(
self._env, video_folder=videos_dir, step_trigger=video_interval, video_length=video_length
)
self._task = initialize_task(self._cfg_dict, self._env, init_sim=False)
self._task_initialized = True
self._task.set_is_extension(True)
def _on_task_select(self, value):
if self._task_initialized and value != self._task_name:
self._task_changed = True
self._task_initialized = False
self._task_name = value
self._parse_config(self._task_name)
self._num_envs_int.set_value(self._cfg.task.env.numEnvs)
self._update_task_file_paths(self._task_name)
def _on_render_mode_select(self, value):
if value == self._render_modes[0]:
self._viewport.updates_enabled = True
window = ui.Workspace.get_window("Viewport")
window.visible = True
if self._env:
self._env.update_viewport = True
self._env.set_render_mode(0)
elif value == self._render_modes[1]:
self._viewport.updates_enabled = False
window = ui.Workspace.get_window("Viewport")
window.visible = False
if self._env:
self._env.update_viewport = False
self._env.set_render_mode(1)
elif value == self._render_modes[2]:
self._viewport.updates_enabled = False
window = ui.Workspace.get_window("Viewport")
window.visible = False
if self._env:
self._env.update_viewport = False
self._env.set_render_mode(2)
def _on_render_cb_update(self, value):
self._render = value
print("updates enabled", value)
self._viewport.updates_enabled = value
if self._env:
self._env.update_viewport = value
if value:
window = ui.Workspace.get_window("Viewport")
window.visible = True
else:
window = ui.Workspace.get_window("Viewport")
window.visible = False
def _on_single_env_cb_update(self, value):
visibility = "invisible" if value else "inherited"
stage = omni.usd.get_context().get_stage()
env_root = stage.GetPrimAtPath("/World/envs")
if env_root.IsValid():
for i, p in enumerate(env_root.GetChildren()):
p.GetAttribute("visibility").Set(visibility)
if value:
stage.GetPrimAtPath("/World/envs/env_0").GetAttribute("visibility").Set("inherited")
env_pos = self._task._env_pos[0].cpu().numpy().tolist()
camera_pos = [env_pos[0] + 10, env_pos[1] + 10, 3]
camera_target = [env_pos[0], env_pos[1], env_pos[2]]
else:
camera_pos = [10, 10, 3]
camera_target = [0, 0, 0]
camera_state = ViewportCameraState("/OmniverseKit_Persp", get_active_viewport())
camera_state.set_position_world(Gf.Vec3d(*camera_pos), True)
camera_state.set_target_world(Gf.Vec3d(*camera_target), True)
def _on_test_cb_update(self, value):
self._test = value
if value is True and self._checkpoint_path.strip() == "":
module_path = os.path.abspath(os.path.join(os.path.dirname(omniisaacgymenvs.__file__)))
self._checkpoint_str.set_value(os.path.join(module_path, f"runs/{self._task_name}/nn/{self._task_name}.pth"))
def _on_resume_cb_update(self, value):
self._resume = value
if value is True and self._checkpoint_path.strip() == "":
module_path = os.path.abspath(os.path.join(os.path.dirname(omniisaacgymenvs.__file__)))
self._checkpoint_str.set_value(os.path.join(module_path, f"runs/{self._task_name}/nn/{self._task_name}.pth"))
def _on_evaluate_cb_update(self, value):
self._evaluate = value
def _on_checkpoint_update(self, value):
self._checkpoint_path = value.get_value_as_string()
async def _on_load_world_async(self, use_existing_stage):
# initialize task if not initialized
if not self._task_initialized or not omni.usd.get_context().get_stage().GetPrimAtPath("/World/envs").IsValid():
self._parse_config(task=self._task_name, num_envs=self._num_envs_int.get_value_as_int())
self.create_task()
else:
# update config
self._parse_config(task=self._task_name, num_envs=self._num_envs_int.get_value_as_int())
self._task.update_config(self._sim_config)
# clear scene
# self._env.world.scene.clear()
self._env.world._sim_params = self._sim_config.get_physics_params()
await self._env.world.initialize_simulation_context_async()
set_camera_view(eye=[10, 10, 3], target=[0, 0, 0], camera_prim_path="/OmniverseKit_Persp")
if not use_existing_stage:
# clear scene
self._env.world.scene.clear()
# clear environments added to world
omni.usd.get_context().get_stage().RemovePrim("/World/collisions")
omni.usd.get_context().get_stage().RemovePrim("/World/envs")
# create scene
await self._env.world.reset_async_set_up_scene()
# update num_envs in envs
self._env.update_task_params()
else:
self._task.initialize_views(self._env.world.scene)
def _on_load_world(self):
# stop simulation before updating stage
self._timeline.stop()
asyncio.ensure_future(self._on_load_world_async(use_existing_stage=False))
def _on_train_stop(self):
if self._task_initialized:
asyncio.ensure_future(self._env.world.stop_async())
async def _on_train_async(self, overrides=None):
try:
# initialize task if not initialized
print("task initialized:", self._task_initialized)
if not self._task_initialized:
# if this is the first launch of the extension, we do not want to re-create stage if stage already exists
use_existing_stage = False
if omni.usd.get_context().get_stage().GetPrimAtPath("/World/envs").IsValid():
use_existing_stage = True
print(use_existing_stage)
await self._on_load_world_async(use_existing_stage)
# update config
self._parse_config(task=self._task_name, num_envs=self._num_envs_int.get_value_as_int(), overrides=overrides)
sim_config = SimConfig(self._cfg_dict)
self._task.update_config(sim_config)
cfg_dict = omegaconf_to_dict(self._cfg)
# sets seed. if seed is -1 will pick a random one
self._cfg.seed = set_seed(self._cfg.seed, torch_deterministic=self._cfg.torch_deterministic)
cfg_dict["seed"] = self._cfg.seed
self._checkpoint_path = self._checkpoint_str.get_value_as_string()
if self._resume or self._test:
self._cfg.checkpoint = self._checkpoint_path
self._cfg.test = self._test
self._cfg.evaluation = self._evaluate
cfg_dict["checkpoint"] = self._cfg.checkpoint
cfg_dict["test"] = self._cfg.test
cfg_dict["evaluation"] = self._cfg.evaluation
rlg_trainer = RLGTrainer(self._cfg, cfg_dict)
if not rlg_trainer._bad_checkpoint:
trainer = Trainer(rlg_trainer, self._env)
await self._env.world.reset_async_no_set_up_scene()
# this is needed to enable rendering for viewport recording
for _ in range(5):
await self._env.world.render_async()
self._env.set_render_mode(self._render_dropdown.get_item_value_model().as_int)
await self._env.run(trainer)
await omni.kit.app.get_app().next_update_async()
except Exception as e:
print(traceback.format_exc())
finally:
self._is_training = False
if self._task._dr_randomizer.randomize:
await self._task._dr_randomizer.rep.orchestrator.stop_async()
self._task._dr_randomizer.rep.orchestrator._orchestrator.shutdown()
def _on_train(self):
# stop simulation if still running
self._timeline.stop()
self._on_render_mode_select(self._render_modes[self._render_dropdown.get_item_value_model().as_int])
if not self._is_training:
self._is_training = True
asyncio.ensure_future(self._on_train_async())
return
def _menu_callback(self):
self._window.visible = not self._window.visible
return
def _on_window(self, status):
return
def on_shutdown(self):
self._extra_frames = []
if self._menu_items is not None:
self._sample_window_cleanup()
self.shutdown_cleanup()
global ext_instance
ext_instance = None
return
def shutdown_cleanup(self):
return
def _sample_window_cleanup(self):
remove_menu_items(self._menu_items, "Isaac Examples")
self._window = None
self._menu_items = None
self._buttons = None
self._load_env_button = None
self._task_dropdown = None
self._cbs = None
self._checkpoint_str = None
return
def get_instance():
return ext_instance
| 24,151 | Python | 43.234432 | 155 | 0.539646 |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.