file_path
stringlengths 21
224
| content
stringlengths 0
80.8M
|
|---|---|
omniverse-code/kit/exts/omni.rtx.index_composite/omni/rtx/index_composite/tests/__init__.py | from .nvindex_rtx_composite_render_test import *
|
omniverse-code/kit/exts/omni.kit.usd_undo/omni/kit/usd_undo/__init__.py | from .layer_undo import *
|
omniverse-code/kit/exts/omni.kit.usd_undo/omni/kit/usd_undo/layer_undo.py | from pxr import Sdf, Usd
class UsdLayerUndo:
class Key:
def __init__(self, path, info):
self.path = path
self.info = info
def __init__(self, layer: Sdf.Layer):
self._layer = layer
self.reset()
def reserve(self, path: Sdf.Path, info=None):
# Check if it's included by any added paths
path = Sdf.Path(path)
for added_key in self._paths:
if path.HasPrefix(added_key.path) and added_key.info is None:
return
# Check if it includes any added paths
if info is None:
for added_key in self._paths:
if added_key.path.HasPrefix(path):
self._paths.pop(added_key)
# If it doesn't exist, it's new spec. No need to reserve anything.
key = self.Key(path, info)
if not self._layer.GetObjectAtPath(path):
self._paths[key] = True
return
else:
self._paths[key] = False
# Reserve existing data
if info is None:
Sdf.CreatePrimInLayer(self._reserve_layer, path.GetParentPath())
Sdf.CopySpec(self._layer, path, self._reserve_layer, path)
else:
# We must know attribute type to create it in layer. So we don't handle it here.
if path.IsPropertyPath():
raise Exception("Property info is not supported.")
spec = self._layer.GetObjectAtPath(path)
Sdf.CreatePrimInLayer(self._reserve_layer, path)
reserve_spec = self._reserve_layer.GetObjectAtPath(path)
reserve_spec.SetInfo(info, spec.GetInfo(info))
def undo(self):
batch_edit = Sdf.BatchNamespaceEdit()
for key, new_spec in self._paths.items():
spec = self._layer.GetObjectAtPath(key.path)
reserve_spec = self._reserve_layer.GetObjectAtPath(key.path)
if new_spec:
# Remove new added spec
if spec:
batch_edit.Add(Sdf.NamespaceEdit.Remove(key.path))
elif key.info is None:
# Restore spec
Sdf.CopySpec(self._reserve_layer, key.path, self._layer, key.path)
else:
# Restore spec info
spec.SetInfo(key.info, reserve_spec.GetInfo(key.info))
self._layer.Apply(batch_edit)
def reset(self):
self._reserve_layer = Sdf.Layer.CreateAnonymous()
self._paths = {}
class UsdEditTargetUndo:
def __init__(self, edit_target: Usd.EditTarget):
self._edit_target = edit_target
self._layer_undo = UsdLayerUndo(self._edit_target.GetLayer())
def reserve(self, path: Sdf.Path, info=None):
self._layer_undo.reserve(path, info)
def undo(self):
self._layer_undo.undo()
def reset(self):
self._layer_undo.reset()
|
omniverse-code/kit/exts/omni.kit.usd_undo/omni/kit/usd_undo/tests/__init__.py | from .test import *
|
omniverse-code/kit/exts/omni.kit.usd_undo/omni/kit/usd_undo/tests/test.py | import omni.kit.test
from ..layer_undo import *
from pxr import Sdf, Usd, UsdGeom, Kind, Gf
class TestUsdUndo(omni.kit.test.AsyncTestCase):
async def test_layer_undo(self):
stage = Usd.Stage.CreateInMemory()
usd_undo = UsdEditTargetUndo(stage.GetEditTarget())
mesh = UsdGeom.Mesh.Define(stage, "/root")
mesh.CreateNormalsAttr().Set([Gf.Vec3f(1, 0, 0)])
mesh.SetNormalsInterpolation("constant")
model = Usd.ModelAPI(mesh)
model.SetKind(Kind.Tokens.group)
org_stage_str = stage.ExportToString()
print("Original stage:")
print(org_stage_str)
usd_undo.reserve("/root.normals")
mesh.GetNormalsAttr().Set([Gf.Vec3f(0, 1, 0)])
mesh.SetNormalsInterpolation("faceVarying")
usd_undo.reserve("/root", "kind")
model.SetKind(Kind.Tokens.component)
usd_undo.reserve("/root/newPrim")
stage.DefinePrim("/root/newPrim")
modified_stage_str = stage.ExportToString()
print("Modified stage:")
print(modified_stage_str)
assert org_stage_str != modified_stage_str
usd_undo.undo()
undone_stage_str = stage.ExportToString()
print("Undone stage:")
print(undone_stage_str)
assert org_stage_str == undone_stage_str
|
omniverse-code/kit/exts/omni.kit.usd_undo/docs/index.rst | omni.kit.usd_undo
###########################
Utitlity to implement undo for USD layer.
``UsdLayerUndo`` class is the utility to help you to implement USD undo. It reserves the state of a path, which could be a prim path or a property path. And when you call ``UsdLayerUndo.undo()``, those paths will be restored to their reserved state.
Example:
.. code:: python
import omni.kit.usd_undo
usd_undo = omni.kit.usd_undo.UsdLayerUndo(stage.GetEditTarget().GetLayer())
usd_undo.reserve("/root/prim")
'''Do anything to prim /root/prim here, including creating/deleting prim,
modifying/creating/deleting meta data or fields, modifying/creating/deleting
any attributes, modifying/creating/deleting any descendants, etc.'''
usd_undo.reserve("root/prim2.prop")
'''Do anything to property root/prim2.prop here, including creating, deleting,
modifying, etc.'''
usd_undo.reserve("root/prim2", Usd.Tokens.apiSchemas)
'''Do anything to apiSchemas field of prim root/prim2 here.'''
# Call UsdLayerUndo.undo() to revert all changes of those paths.
usd_undo.undo()
|
omniverse-code/kit/exts/omni.kit.manipulator.selection/omni/kit/manipulator/selection/__init__.py | # Expose these for easier import via from omni.kit.manipulator.selection import XXX
from .manipulator import SelectionManipulator, SelectionMode
|
omniverse-code/kit/exts/omni.kit.manipulator.selection/omni/kit/manipulator/selection/model.py | # Copyright (c) 2021-2022, 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.
#
from omni.ui import scene as sc
from typing import List, Sequence, Union
class SelectionShapeModel(sc.AbstractManipulatorModel):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.__items = {
"ndc_start": (sc.AbstractManipulatorItem(), 2),
"ndc_current": (sc.AbstractManipulatorItem(), 2),
"ndc_rect": (sc.AbstractManipulatorItem(), 4),
"mode": (sc.AbstractManipulatorItem(), 1),
"live_update": (sc.AbstractManipulatorItem(), 1)
}
self.__ndc_ret_item = self.__items.get('ndc_rect')[0]
self.__values = {item: [] for item, _ in self.__items.values()}
def __validate_arguments(self, name: Union[str, sc.AbstractManipulatorItem], values: Sequence[Union[int, float]] = None) -> sc.AbstractManipulatorItem:
if isinstance(name, sc.AbstractManipulatorItem):
return name
item, expected_len = self.__items.get(name, (None, None))
if item is None:
raise KeyError(f"SelectionShapeModel doesn't understand values of {name}")
if values and len(values) != expected_len:
raise ValueError(f"SelectionShapeModel {name} takes {expected_len} values, got {len(values)}")
return item
def get_item(self, name: str) -> sc.AbstractManipulatorItem():
return self.__items.get(name, (None, None))[0]
def set_ints(self, name: str, values: Sequence[int]):
item = self.__validate_arguments(name, values)
self.__values[item] = values
def set_floats(self, name: str, values: Sequence[int]):
item = self.__validate_arguments(name, values)
self.__values[item] = values
def get_as_ints(self, name: str) -> List[int]:
item = self.__validate_arguments(name)
return self.__values[item]
def get_as_floats(self, name: str) -> List[float]:
item = self.__validate_arguments(name)
if item == self.__ndc_ret_item:
ndc_start, ndc_end = self.__values[self.get_item('ndc_start')], self.__values[self.get_item('ndc_current')]
if not ndc_start:
return []
if not ndc_end:
ndc_end = ndc_start
min_x = min(ndc_start[0], ndc_end[0])
max_x = max(ndc_start[0], ndc_end[0])
min_y = min(ndc_start[1], ndc_end[1])
max_y = max(ndc_start[1], ndc_end[1])
return [min_x, min_y, max_x, max_y]
return self.__values[item]
|
omniverse-code/kit/exts/omni.kit.manipulator.selection/omni/kit/manipulator/selection/manipulator.py | # Copyright (c) 2021-2022, 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.
#
__all__ = ['SelectionManipulator', 'SelectionMode']
import carb.input
from omni.ui import scene as sc
from .model import SelectionShapeModel
from pxr import Gf
from typing import List
import weakref
class SelectionMode:
REPLACE = 0
APPEND = 1
REMOVE = 2
def _optional_bool(model: sc.AbstractManipulatorModel, item: str, default_value: bool = False):
values = model.get_as_ints(item)
return values[0] if values else default_value
class _KeyDown:
def __init__(self):
self.__input = carb.input.acquire_input_interface()
def test(self, key_a, key_b):
if self.__input.get_keyboard_button_flags(None, key_a) & carb.input.BUTTON_FLAG_DOWN:
return True
if self.__input.get_keyboard_button_flags(None, key_b) & carb.input.BUTTON_FLAG_DOWN:
return True
return False
class _SelectionPreventer(sc.GestureManager):
'''Class to explicitly block selection in favor of alt-orbit when alt-dragging'''
def can_be_prevented(self, gesture):
alt_down = _KeyDown().test(carb.input.KeyboardInput.LEFT_ALT, carb.input.KeyboardInput.RIGHT_ALT)
if alt_down:
if getattr(gesture, 'name', None) == "SelectionDrag":
return True
# Never prevent in the middle or at the end of drag
return (
gesture.state != sc.GestureState.CHANGED
and gesture.state != sc.GestureState.ENDED
and gesture.state != sc.GestureState.CANCELED
)
def should_prevent(self, gesture, preventer):
alt_down = _KeyDown().test(carb.input.KeyboardInput.LEFT_ALT, carb.input.KeyboardInput.RIGHT_ALT)
if alt_down:
name = getattr(gesture, 'name', None)
if name == "TumbleGesture":
return False
if name == "SelectionDrag":
return True
return super().should_prevent(gesture, preventer)
class _SelectionGesture:
@classmethod
def __get_selection_mode(self):
key_down = _KeyDown()
shift_down = key_down.test(carb.input.KeyboardInput.LEFT_SHIFT, carb.input.KeyboardInput.RIGHT_SHIFT)
if shift_down:
return SelectionMode.APPEND
ctrl_down = key_down.test(carb.input.KeyboardInput.LEFT_CONTROL, carb.input.KeyboardInput.RIGHT_CONTROL)
if ctrl_down:
return SelectionMode.REMOVE
# alt_down = key_down.test(carb.input.KeyboardInput.LEFT_ALT, carb.input.KeyboardInput.RIGHT_ALT)
return SelectionMode.REPLACE
@classmethod
def _set_mouse(self, model: sc.AbstractManipulatorModel, ndc_mouse: List[float], is_start: bool = False):
if is_start:
model.set_floats('ndc_start', ndc_mouse)
model.set_ints('mode', [self.__get_selection_mode()])
elif _optional_bool(model, 'live_update'):
model.set_ints('mode', [self.__get_selection_mode()])
model.set_floats('ndc_current', ndc_mouse)
@classmethod
def _on_ended(self, manipulator: sc.Manipulator):
# This is needed to not fight with alt+left-mouse camera orbit when not blocking alt explicitly
# manipulator.invalidate()
model = manipulator.model
model.set_floats('ndc_start', [])
model.set_floats('ndc_current', [])
model.set_ints('mode', [])
model._item_changed(model.get_item('ndc_rect'))
class _DragGesture(sc.DragGesture):
def __init__(self, manipulator: sc.Manipulator, *args, **kwargs):
super().__init__(*args, **kwargs)
self.__manipulator = manipulator
def on_began(self):
_SelectionGesture._set_mouse(self.__manipulator.model, self.sender.gesture_payload.mouse, True)
def on_changed(self):
model = self.__manipulator.model
_SelectionGesture._set_mouse(model, self.sender.gesture_payload.mouse)
model._item_changed(model.get_item('ndc_rect'))
def on_ended(self):
# Track whether on_changed has been called.
# When it has: this drag is a drag.
# When it hasn't: this drag is actually a click.
if self.state != sc.GestureState.ENDED:
return
_SelectionGesture._on_ended(self.__manipulator)
class _ClickGesture(sc.ClickGesture):
def __init__(self, manipulator: sc.Manipulator, *args, **kwargs):
super().__init__(*args, **kwargs)
self.__manipulator = manipulator
def on_ended(self):
model = self.__manipulator.model
_SelectionGesture._set_mouse(model, self.sender.gesture_payload.mouse, True)
model._item_changed(model.get_item('ndc_rect'))
_SelectionGesture._on_ended(self.__manipulator)
class SelectionManipulator(sc.Manipulator):
def __init__(self, style: dict = None, *args, **kwargs):
applied_style = {
'as_rect': True,
'thickness': 2.0,
'color': (1.0, 1.0, 1.0, 0.2),
'inner_color': (1.0, 1.0, 1.0, 0.2)
}
if style:
applied_style.update(style)
super().__init__(*args, **kwargs)
self.__as_rect = applied_style['as_rect']
self.__outline_color = applied_style['color']
self.__inner_color = applied_style['inner_color']
self.__thickness = applied_style['thickness']
self.__polygons, self.__transform = [], None
# Provide some defaults
if not self.model:
self.model = SelectionShapeModel()
self.gestures = []
def on_build(self):
if self.__transform:
self.__transform.clear()
self.__polygons = []
sc.Screen(gestures=self.gestures or [
_DragGesture(weakref.proxy(self), manager=_SelectionPreventer(), name='SelectionDrag'),
_ClickGesture(weakref.proxy(self), name='SelectionClick'),
])
self.__transform = sc.Transform(look_at=sc.Transform.LookAt.CAMERA)
def __draw_shape(self, start, end, as_rect):
if as_rect:
avg_z = (start[2] + end[2]) * 0.5
points = ((start[0], start[1], avg_z),
(end[0], start[1], avg_z),
(end[0], end[1], avg_z),
(start[0], end[1], avg_z))
else:
if self.__polygons:
points = self.__polygons[0].positions + [end]
else:
points = start, end
# FIXME: scene.ui needs a full rebuild on this case
self.__transform.clear()
self.__polygons = []
npoints = len(points)
visible = npoints >= 3
if not self.__polygons:
with self.__transform:
faces = [x for x in range(npoints)]
# TODO: omni.ui.scene Shouldn't requires redundant color & thickness for constant color
if self.__inner_color:
self.__polygons.append(
sc.PolygonMesh(points, [self.__inner_color]*npoints, [npoints], faces, wireframe=False, visible=visible)
)
if self.__thickness and self.__outline_color:
self.__polygons.append(
sc.PolygonMesh(points, [self.__outline_color]*npoints, [npoints], faces, wireframe=True, thicknesses=[self.__thickness]*npoints, visible=visible)
)
else:
for poly in self.__polygons:
poly.positions = points
poly.visible = visible
def on_model_updated(self, item):
model = self.model
if item != model.get_item('ndc_rect'):
return
ndc_rect = model.get_as_floats('ndc_rect')
if ndc_rect:
ndc_depth = 1
start = self.__transform.transform_space(sc.Space.NDC, sc.Space.OBJECT, (ndc_rect[0], ndc_rect[1], ndc_depth))
end = self.__transform.transform_space(sc.Space.NDC, sc.Space.OBJECT, (ndc_rect[2], ndc_rect[3], ndc_depth))
self.__draw_shape(start, end, self.__as_rect)
else:
self.__transform.clear()
self.__polygons = []
|
omniverse-code/kit/exts/omni.kit.manipulator.selection/omni/kit/manipulator/selection/tests/test_selection_manipulator.py | ## Copyright (c) top_left[0]22, 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.
##
__all__ = ['TestSelectionManipulator']
import omni.kit.test
from ..manipulator import SelectionManipulator
from .test_scene_ui_base import TestOmniUiScene
from omni.ui import scene as sc
class TestSelectionManipulator(TestOmniUiScene):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.__ndc_rects = []
self.__last_rect = None
def on_item_changed(self, model, item):
# ndc_rect should be part of the model, always
ndc_rect_item = model.get_item('ndc_rect')
self.assertIsNotNone(ndc_rect_item)
# Ignore other signals
if item != ndc_rect_item:
return
# Get the values
ndc_rect = model.get_as_floats(ndc_rect_item)
self.assertIsNotNone(ndc_rect)
# NDC rect cannot be none, but it can be empty (on mouse-up)
if ndc_rect != []:
# ndc_rect should be totally ordered: top-left, bottom-right
self.assertLess(ndc_rect[0], ndc_rect[2])
self.assertLess(ndc_rect[1], ndc_rect[3])
# Save the lat mouse for a test later
self.__last_rect = ndc_rect
def ndc_rects_match(self):
self.assertIsNotNone(self.__last_rect)
self.__ndc_rects.append(self.__last_rect)
self.__last_rect = None
if len(self.__ndc_rects) > 1:
self.assertEqual(self.__ndc_rects[0], self.__ndc_rects[-1])
async def test_ortho_selection(self):
window, scene_view = await self.create_ortho_scene_view('test_ortho_selection')
with scene_view.scene:
manipulator = SelectionManipulator()
sc.Arc(radius=25, wireframe=True, tesselation = 36 * 3, thickness = 2)
manip_sub = manipulator.model.subscribe_item_changed_fn(self.on_item_changed)
top_left = (20, 40)
bottom_right = (window.width-top_left[0], window.height-60)
# Test dragging top-left to bottom-right
await self.wait_frames()
await self.mouse_dragging_test('test_ortho_selection', (top_left[0], top_left[1]), (bottom_right[0], bottom_right[1]))
await self.wait_frames()
# Ortho and Perspective should stil have same selection box
self.ndc_rects_match()
# Test dragging bottom-right to top-left
await self.wait_frames()
await self.mouse_dragging_test('test_ortho_selection', (bottom_right[0], bottom_right[1]), (top_left[0], top_left[1]))
await self.wait_frames()
# Ortho and Perspective should stil have same selection box
self.ndc_rects_match()
# Test dragging top-right to bottom-left
await self.wait_frames()
await self.mouse_dragging_test('test_ortho_selection', (bottom_right[0], top_left[1]), (top_left[0], bottom_right[1]))
await self.wait_frames()
# Should stil have same selection box
self.ndc_rects_match()
# Test dragging bottom-left to top-right
await self.wait_frames()
await self.mouse_dragging_test('test_ortho_selection', (top_left[0], bottom_right[1]), (bottom_right[0], top_left[1]))
await self.wait_frames()
async def test_persepctive_selection(self):
window, scene_view = await self.create_perspective_scene_view('test_persepctive_selection')
with scene_view.scene:
manipulator = SelectionManipulator({
'thickness': 5.0,
'color': (0.2, 0.2, 0.8, 0.8),
'inner_color': (0.2, 0.6, 0.8, 0.4)
})
sc.Arc(radius=25, wireframe=True, tesselation = 36 * 3, thickness = 2)
manip_sub = manipulator.model.subscribe_item_changed_fn(self.on_item_changed)
top_left = (20, 40)
bottom_right = (window.width-top_left[0], window.height-60)
# Test dragging bottom-left to top-right
await self.wait_frames()
await self.mouse_dragging_test('test_persepctive_selection', (top_left[0], bottom_right[1]), (bottom_right[0], top_left[1]))
await self.wait_frames()
# Should stil have same selection box
self.ndc_rects_match()
# Test dragging top-right to bottom-left
await self.wait_frames()
await self.mouse_dragging_test('test_persepctive_selection', (bottom_right[0], top_left[1]), (top_left[0], bottom_right[1]))
await self.wait_frames()
# Should stil have same selection box
self.ndc_rects_match()
# Test dragging bottom-right to top-left
await self.wait_frames()
await self.mouse_dragging_test('test_persepctive_selection', (bottom_right[0], bottom_right[1]), (top_left[0], top_left[1]))
await self.wait_frames()
# Ortho and Perspective should stil have same selection box
self.ndc_rects_match()
# Test dragging top-left to bottom-right
await self.wait_frames()
await self.mouse_dragging_test('test_persepctive_selection', (top_left[0], top_left[1]), (bottom_right[0], bottom_right[1]))
await self.wait_frames()
# Ortho and Perspective should stil have same selection box
self.ndc_rects_match()
|
omniverse-code/kit/exts/omni.kit.manipulator.selection/omni/kit/manipulator/selection/tests/__init__.py | from .test_selection_model import TestSelectionModel
from .test_selection_manipulator import TestSelectionManipulator
|
omniverse-code/kit/exts/omni.kit.manipulator.selection/omni/kit/manipulator/selection/tests/test_scene_ui_base.py | ## Copyright (c) 2022, 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.
##
from omni.ui.tests.test_base import OmniUiTest
from omni.ui.tests.compare_utils import capture_and_compare
from omni.kit.ui_test.input import emulate_mouse, emulate_mouse_slow_move, human_delay
from omni.kit.ui_test import Vec2
from omni.ui import scene as sc
import omni.ui as ui
import omni.appwindow
import omni.kit.app
import carb
from carb.input import MouseEventType
from pxr import Gf
from pathlib import Path
async def emulate_mouse_drag_and_drop(start_pos, end_pos, right_click=False, human_delay_speed: int = 4, end_with_up: bool = True):
"""Emulate Mouse Drag & Drop. Click at start position and slowly move to end position."""
await emulate_mouse(MouseEventType.MOVE, start_pos)
await emulate_mouse(MouseEventType.RIGHT_BUTTON_DOWN if right_click else MouseEventType.LEFT_BUTTON_DOWN)
await human_delay(human_delay_speed)
await emulate_mouse_slow_move(start_pos, end_pos, human_delay_speed=human_delay_speed)
if end_with_up:
await emulate_mouse(MouseEventType.RIGHT_BUTTON_UP if right_click else MouseEventType.LEFT_BUTTON_UP)
await human_delay(human_delay_speed)
def _flatten_matrix(matrix: Gf.Matrix4d):
return [matrix[0][0], matrix[0][1], matrix[0][2], matrix[0][3],
matrix[1][0], matrix[1][1], matrix[1][2], matrix[1][3],
matrix[2][0], matrix[2][1], matrix[2][2], matrix[2][3],
matrix[3][0], matrix[3][1], matrix[3][2], matrix[3][3]]
class TestOmniUiScene(OmniUiTest):
DATA_PATH = None
async def setUp(self, ext_id: str = None):
await super().setUp()
self.__width, self.__height = None, None
# If no extension-id, assume standard xxx.xxx.xxx.tests.current_test
if ext_id is None:
ext_id = '.'.join(self.__module__.split('.')[0:-2])
TestOmniUiScene.DATA_PATH = Path(carb.tokens.get_tokens_interface().resolve("${" + ext_id + "}")).absolute().resolve()
self.__golden_img_dir = TestOmniUiScene.DATA_PATH.joinpath("data", "tests")
# After running each test
async def tearDown(self):
self.__golden_img_dir = None
await super().tearDown()
async def setup_test_area_and_input(self, title: str, width: int = 256, height: int = 256):
self.__width, self.__height = width, height
await self.create_test_area(width=width, height=height)
app_window = omni.appwindow.get_default_app_window()
app_window.set_input_blocking_state(carb.input.DeviceType.MOUSE, False)
return ui.Window(title=title, width=width, height=height,
flags=ui.WINDOW_FLAGS_NO_SCROLLBAR | ui.WINDOW_FLAGS_NO_TITLE_BAR | ui.WINDOW_FLAGS_NO_RESIZE | ui.WINDOW_FLAGS_NO_MOVE)
async def create_ortho_scene_view(self, title='test', width = 256, height = 256, ortho_size = 100, z_pos = -5):
window = await self.setup_test_area_and_input(title, width, height)
with window.frame:
# Camera matrices
projection = self.ortho_projection()
view = sc.Matrix44.get_translation_matrix(0, 0, z_pos)
scene_view = sc.SceneView(aspect_ratio_policy=sc.AspectRatioPolicy.STRETCH, model=sc.CameraModel(projection, view))
return window, scene_view
async def create_perspective_scene_view(self, title='test', width = 256, height = 256, field_of_view = 25, distance = 100):
window = await self.setup_test_area_and_input(title, width, height)
with window.frame:
# Camera matrices
projection = self.perspective_projection(field_of_view)
eye = Gf.Vec3d(distance, distance, distance)
target = Gf.Vec3d(0, 0, 0)
forward = (target - eye).GetNormalized()
up = Gf.Vec3d(0, 0, 1).GetComplement(forward)
view = _flatten_matrix(Gf.Matrix4d().SetLookAt(eye, target, up))
scene_view = sc.SceneView(aspect_ratio_policy=sc.AspectRatioPolicy.STRETCH, model=sc.CameraModel(projection, view))
return window, scene_view
async def finish_scene_ui_test(self, wait_frames = 15):
for _ in range(wait_frames):
await omni.kit.app.get_app().next_update_async()
return await self.finalize_test(golden_img_dir=self.__golden_img_dir)
def ortho_projection(self, ortho_size: float = 100, aspect_ratio: float = None, near: float = 0.001, far: float = 10000):
if aspect_ratio is None:
aspect_ratio = self.__width / self.__height
if aspect_ratio > 1:
ortho_half_height = ortho_size * 0.5
ortho_half_width = ortho_half_height * aspect_ratio
else:
ortho_half_width = ortho_size * 0.5
ortho_half_height = ortho_half_width * aspect_ratio
frustum = Gf.Frustum()
frustum.SetOrthographic(-ortho_half_width, ortho_half_width, -ortho_half_height, ortho_half_height, near, far)
return _flatten_matrix(frustum.ComputeProjectionMatrix())
def perspective_projection(self, field_of_view: float = 20, aspect_ratio: float = None, near: float = 0.001, far: float = 10000):
if aspect_ratio is None:
aspect_ratio = self.__width / self.__height
frustum = Gf.Frustum()
frustum.SetPerspective(field_of_view / aspect_ratio, aspect_ratio, near, far)
return _flatten_matrix(frustum.ComputeProjectionMatrix())
@property
def golden_img_dir(self):
return self.__golden_img_dir
@property
def human_delay(self):
return 4
async def wait_frames(self, frames: int = 15):
for _ in range(10):
await omni.kit.app.get_app().next_update_async()
async def end_mouse(self):
await emulate_mouse(MouseEventType.LEFT_BUTTON_UP)
await human_delay(self.human_delay)
async def mouse_dragging_test(self, test_name, start_pos, end_pos):
threshold = 10
start_pos = Vec2(start_pos[0], start_pos[1])
end_pos = Vec2(end_pos[0], end_pos[1])
# Do a drag operation
await emulate_mouse_drag_and_drop(start_pos, end_pos, human_delay_speed = self.human_delay, end_with_up=False)
# Capture while mouse is down
diff1 = await capture_and_compare(f'{test_name}_drag.png', threshold, self.golden_img_dir)
# End the drag
await self.end_mouse()
# And cature again with mouse up
diff2 = await capture_and_compare(f'{test_name}_done.png', threshold, self.golden_img_dir)
if diff1 != 0:
carb.log_warn(f"[{test_name}_drag.png] the generated image has difference {diff1}")
if diff2 != 0:
carb.log_warn(f"[{test_name}_done.png] the generated image has difference {diff2}")
self.assertTrue(
(diff1 is not None and diff1 < threshold),
msg=f"The image for test '{test_name}_drag.png' doesn't match the golden one. Difference of {diff1} is is not less than threshold of {threshold}.",
)
self.assertTrue(
(diff2 is not None and diff2 < threshold),
msg=f"The image for test '{test_name}_done.png' doesn't match the golden one. Difference of {diff2} is is not less than threshold of {threshold}.",
) |
omniverse-code/kit/exts/omni.kit.manipulator.selection/omni/kit/manipulator/selection/tests/test_selection_model.py | ## Copyright (c) 2022, 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.
##
__all__ = ['TestSelectionModel']
import omni.kit.test
from ..model import SelectionShapeModel
class TestSelectionModel(omni.kit.test.AsyncTestCase):
async def test_ortho_selection(self):
model = SelectionShapeModel()
# Standard item should exist
ndc_start_item = model.get_item('ndc_start')
self.assertIsNotNone(ndc_start_item)
# Standard item should exist
ndc_current_item = model.get_item('ndc_current')
self.assertIsNotNone(ndc_current_item)
# Standard item should exist
ndc_rect_item = model.get_item('ndc_rect')
self.assertIsNotNone(ndc_rect_item)
# Test setting only a start result in no rect
model.set_floats(ndc_start_item, [1, 2])
ndc_rect = model.get_as_floats(ndc_rect_item)
self.assertEqual(ndc_rect, [1, 2, 1, 2])
# Test setting a start and current results in a rect
model.set_floats(ndc_start_item, [1, 2])
model.set_floats(ndc_current_item, [3, 4])
ndc_rect = model.get_as_floats(ndc_rect_item)
self.assertEqual(ndc_rect, [1, 2, 3, 4])
# Changing the order should result in the same sorted top-left, bottom-right rect
model.set_floats(ndc_start_item, [3, 4])
model.set_floats(ndc_current_item, [1, 2])
ndc_rect = model.get_as_floats(ndc_rect_item)
self.assertEqual(ndc_rect, [1, 2, 3, 4])
|
omniverse-code/kit/exts/omni.kit.manipulator.selection/docs/index.rst | omni.kit.manipulator.selection
###########################
Selection Shape/Box for omni.ui.scene
.. toctree::
:maxdepth: 1
README
CHANGELOG
.. automodule:: omni.kit.manipulator.selection
:platform: Windows-x86_64, Linux-x86_64
:members:
:undoc-members:
:show-inheritance:
:imported-members:
|
omniverse-code/kit/exts/omni.kit.filebrowser_column.tags/omni/kit/filebrowser_column/tags/__init__.py | from .tags_extension import TagsExtension
|
omniverse-code/kit/exts/omni.kit.filebrowser_column.tags/omni/kit/filebrowser_column/tags/tags_extension.py | # Copyright (c) 2018-2020, 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.
#
from .tags_delegate import TagsDelegate
from omni.kit.widget.filebrowser import ColumnDelegateRegistry
import omni.ext
import carb
class TagsExtension(omni.ext.IExt):
def on_startup(self, ext_id):
self._subscription = ColumnDelegateRegistry().register_column_delegate("Tags", TagsDelegate)
def on_shutdown(self):
self._subscription = None
|
omniverse-code/kit/exts/omni.kit.filebrowser_column.tags/omni/kit/filebrowser_column/tags/tags_delegate.py | # Copyright (c) 2018-2020, 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.
#
from omni.kit.tagging import OmniKitTaggingDelegate, get_tagging_instance
from omni.kit.widget.filebrowser import ColumnItem
from omni.kit.widget.filebrowser import AbstractColumnDelegate
import asyncio
import carb
import functools
import omni.client
import omni.ui as ui
import traceback
def handle_exception(func):
"""
Decorator to print exception in async functions
"""
@functools.wraps(func)
async def wrapper(*args, **kwargs):
try:
return await func(*args, **kwargs)
except asyncio.CancelledError:
pass
except Exception as e:
carb.log_error(f"Exception when async '{func}'")
carb.log_error(f"{e}")
carb.log_error(f"{traceback.format_exc()}")
return wrapper
class TagsDelegate(AbstractColumnDelegate):
"""
The object that adds the new column "Access" to fileblowser. The columns
displays access flags.
"""
@property
def initial_width(self):
"""The width of the column"""
return ui.Pixel(40)
def build_header(self):
"""Build the header"""
ui.Label("Tags", style_type_name_override="TreeView.Header")
@handle_exception
async def build_widget(self, item: ColumnItem):
"""
Build the widget for the given item. Works inside Frame in async
mode. Once the widget is created, it will replace the content of the
frame. It allow to await something for a while and create the widget
when the result is available.
"""
tagging = get_tagging_instance()
if tagging is None:
carb.log_warn("Tagging client not found")
return
# sanitize relative item paths
path = item.path.replace("/./", "/")
results = await tagging.get_tags_async([path])
if results is None:
results = []
ordered_tags = tagging.ordered_tag_list(results)
tag_string = ", ".join(ordered_tags)
tooltip_string = "\n".join(ordered_tags)
ui.Label(tag_string, style_type_name_override="TreeView.Item", tooltip=tooltip_string)
|
omniverse-code/kit/exts/omni.kit.property.layer/PACKAGE-LICENSES/omni.kit.property.layer-LICENSE.md | Copyright (c) 2020, 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. |
omniverse-code/kit/exts/omni.kit.property.layer/config/extension.toml | [package]
# Semantic Versioning is used: https://semver.org/
version = "1.1.4"
category = "Internal"
feature = true
# Lists people or organizations that are considered the "authors" of the package.
authors = ["NVIDIA"]
# The title and description fields are primarly for displaying extension info in UI
title = "Layer Property Window Widgets"
description="Property Window widgets that displays Layer related information."
# URL of the extension source repository.
repository = ""
# Keywords for the extension
keywords = ["kit", "usd", "property", "Layer"]
# Location of change log file in target (final) folder of extension, relative to the root.
# More info on writing changelog: https://keepachangelog.com/en/1.0.0/
changelog="docs/CHANGELOG.md"
# Preview image displayed in extension manager
preview_image = "data/preview.png"
# Icon is shown in Extensions window, it is recommended to be square, of size 256x256.
icon = "data/icon.png"
[dependencies]
"omni.kit.commands" = {}
"omni.usd" = {}
"omni.ui" = {}
"omni.client" = {}
"omni.kit.window.filepicker" = {}
"omni.kit.window.content_browser" = {}
"omni.kit.window.property" = {}
"omni.kit.widget.layers" = {}
"omni.kit.usd.layers" = {}
"omni.kit.widget.versioning" = { optional=true }
# Main python module this extension provides, it will be publicly available as "import omni.example.hello".
[[python.module]]
name = "omni.kit.property.layer"
[[test]]
args = ["--/app/file/ignoreUnsavedOnExit=true"]
|
omniverse-code/kit/exts/omni.kit.property.layer/omni/kit/property/layer/layer_property_models.py | # Copyright (c) 2020, 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 omni.kit.commands
import omni.timeline
import omni.ui as ui
import omni.usd
import weakref
import omni.kit.widget.layers
from pxr import Usd, Sdf, UsdGeom, UsdPhysics
from omni.kit.widget.layers import LayerUtils
from .types import LayerMetaType
class LayerPathModel(ui.SimpleStringModel):
def __init__(self, layer_item: weakref):
super().__init__()
self._layer_item = layer_item
if self._layer_item and self._layer_item():
self._identifier = self._layer_item().identifier
else:
self._identifier = None
def get_value_as_string(self):
return self._identifier
def set_value(self, value):
if value != self._identifier:
self._identifier = value
self._value_changed()
def begin_edit(self):
pass
def end_edit(self):
if not self._layer_item or not self._layer_item():
return
value = self.get_value_as_string()
layer_item = self._layer_item()
if not layer_item.reserved:
sublayer_position = LayerUtils.get_sublayer_position_in_parent(
layer_item.parent.identifier, layer_item.identifier
)
omni.kit.commands.execute(
"ReplaceSublayer",
layer_identifier=layer_item.parent.identifier,
sublayer_position=sublayer_position,
new_layer_path=value,
)
# OM-76598: Delay frames until layer item is initialized.
async def focus_on_layer_item(path):
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
layer_instance = omni.kit.widget.layers.get_instance()
layer_instance.set_current_focused_layer_item(path)
asyncio.ensure_future(focus_on_layer_item(value))
def replace_layer(self, value):
self.set_value(value)
self.end_edit()
def is_reserved_layer(self):
if not self._layer_item or not self._layer_item():
return True
return self._layer_item().reserved
def anonymous(self):
if not self._layer_item or not self._layer_item() or not self._layer_item().layer:
return True
return self._layer_item().anonymous
class LayerWorldAxisItem(ui.AbstractItem):
def __init__(self, text):
super().__init__()
self.model = ui.SimpleStringModel(text)
class LayerWorldAxisModel(ui.AbstractItemModel):
def __init__(self, layer_item: weakref):
super().__init__()
self._layer_item = layer_item
self._items = [LayerWorldAxisItem(text) for text in [UsdGeom.Tokens.y, UsdGeom.Tokens.z]]
self._current_index = ui.SimpleIntModel()
self.on_value_changed()
self._current_index.add_value_changed_fn(self._current_index_changed)
def get_item_children(self, item):
return self._items
def get_item_value_model(self, item, column_id):
if item is None:
return self._current_index
return item.model
def _current_index_changed(self, model):
if not self._layer_item or not self._layer_item():
return
stage = Usd.Stage.Open(self._layer_item().layer)
index = model.as_int
if index == 0:
omni.kit.commands.execute("ModifyStageAxis", stage=stage, axis=UsdGeom.Tokens.y)
elif index == 1:
omni.kit.commands.execute("ModifyStageAxis", stage=stage, axis=UsdGeom.Tokens.z)
UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.z)
self._item_changed(None)
def get_usd_token_name(self):
return UsdGeom.Tokens.upAxis
def on_value_changed(self):
if self._layer_item and self._layer_item():
layer = self._layer_item().layer
stage = Usd.Stage.Open(layer)
up_axis = UsdGeom.GetStageUpAxis(stage)
index = 0 if up_axis == UsdGeom.Tokens.y else 1
self._current_index.set_value(index)
class LayerMetaModel(ui.AbstractValueModel):
def __init__(self, layer_item: weakref, meta_type: LayerMetaType):
super().__init__()
self._layer_item = layer_item
self._meta_type = meta_type
self._value = self._get_value_as_string()
def get_value_as_string(self):
return self._value
def _get_value_as_string(self):
if not self._layer_item or not self._layer_item():
return None
layer = self._layer_item().layer
if not layer:
return None
if self._meta_type == LayerMetaType.COMMENT:
return str(layer.comment)
elif self._meta_type == LayerMetaType.DOC:
return str(layer.documentation)
elif self._meta_type == LayerMetaType.START_TIME:
return str(layer.startTimeCode)
elif self._meta_type == LayerMetaType.END_TIME:
return str(layer.endTimeCode)
elif self._meta_type == LayerMetaType.TIMECODES_PER_SECOND:
return str(layer.timeCodesPerSecond)
elif layer.HasFramesPerSecond() and self._meta_type == LayerMetaType.FPS_PER_SECOND:
return str(layer.framesPerSecond)
elif self._meta_type == LayerMetaType.UNITS:
stage = Usd.Stage.Open(layer, None, None, Usd.Stage.LoadNone)
meters = UsdGeom.GetStageMetersPerUnit(stage)
return str(meters)
elif self._meta_type == LayerMetaType.KG_PER_UNIT:
stage = Usd.Stage.Open(layer, None, None, Usd.Stage.LoadNone)
kilograms = UsdPhysics.GetStageKilogramsPerUnit(stage)
return str(kilograms)
elif (
self._layer_item().parent and self._meta_type == LayerMetaType.LAYER_OFFSET
):
parent = self._layer_item().parent
layer_index = LayerUtils.get_sublayer_position_in_parent(parent.identifier, layer.identifier)
offset = parent.layer.subLayerOffsets[layer_index]
return str(offset.offset)
elif self._layer_item().parent and self._meta_type == LayerMetaType.LAYER_SCALE:
parent = self._layer_item().parent
layer_index = LayerUtils.get_sublayer_position_in_parent(parent.identifier, layer.identifier)
offset = parent.layer.subLayerOffsets[layer_index]
return str(offset.scale)
return None
def set_value(self, value):
if value != self._value:
self._value = value
self._value_changed()
def end_edit(self):
if not self._layer_item or not self._layer_item():
return
layer = self._layer_item().layer
if not layer:
return
if self._layer_item().parent:
parent_layer_identifier = self._layer_item().parent.identifier
else:
parent_layer_identifier = None
layer_identifier = layer.identifier
omni.kit.commands.execute(
"ModifyLayerMetadata",
layer_identifier=layer_identifier,
parent_layer_identifier=parent_layer_identifier,
meta_index=self._meta_type,
value=self._value,
)
def begin_edit(self):
pass
def get_usd_token_name(self):
if self._meta_type == LayerMetaType.COMMENT:
return Sdf.Layer.CommentKey
elif self._meta_type == LayerMetaType.DOC:
return Sdf.Layer.DocumentationKey
elif self._meta_type == LayerMetaType.START_TIME:
return Sdf.Layer.StartTimeCodeKey
elif self._meta_type == LayerMetaType.END_TIME:
return Sdf.Layer.EndTimeCodeKey
elif self._meta_type == LayerMetaType.TIMECODES_PER_SECOND:
return Sdf.Layer.TimeCodesPerSecondKey
elif self._meta_type == LayerMetaType.FPS_PER_SECOND:
return Sdf.Layer.FramesPerSecondKey
elif self._meta_type == LayerMetaType.UNITS:
return UsdGeom.Tokens.metersPerUnit
elif self._meta_type == LayerMetaType.KG_PER_UNIT:
return UsdPhysics.Tokens.kilogramsPerUnit
elif self._meta_type == LayerMetaType.LAYER_OFFSET:
return "subLayerOffsets_offset" # USD has no python bindings for this key
elif self._meta_type == LayerMetaType.LAYER_SCALE:
return "subLayerOffsets_scale" # USD has no python bindings for this key
return ""
def on_value_changed(self):
self.set_value(self._get_value_as_string())
|
omniverse-code/kit/exts/omni.kit.property.layer/omni/kit/property/layer/widgets.py | # Copyright (c) 2020, 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 carb
import omni.ext
import omni.kit.app
import omni.usd
import weakref
from pathlib import Path
from pxr import Sdf, UsdGeom
from typing import List
from .layer_property_widgets import LayerPathWidget, LayerMetaWiget
ICON_PATH = ""
_instance = None
def get_instance():
global _instance
return _instance
class LayerPropertyWidgets(omni.ext.IExt):
def __init__(self):
self._registered = False
self._examples = None
self._selection_notifiers = []
super().__init__()
def on_startup(self, ext_id):
global _instance
_instance = self
manager = omni.kit.app.get_app().get_extension_manager()
extension_path = manager.get_extension_path(ext_id)
global ICON_PATH
ICON_PATH = Path(extension_path).joinpath("data").joinpath("icons")
self._selection_notifiers.append(SelectionNotifier()) # default context
self._hooks = manager.subscribe_to_extension_enable(
lambda _: self._register_widget(),
lambda _: self._unregister_widget(),
ext_name="omni.kit.window.property",
hook_name="omni.kit.property.layer listener",
)
def on_shutdown(self):
global _instance
if _instance:
_instance = None
for notifier in self._selection_notifiers:
notifier.stop()
self._selection_notifiers.clear()
self._hooks = None
if self._registered:
self._unregister_widget()
def _register_widget(self):
try:
import omni.kit.window.property as p
from .layer_property_widgets import LayerPathWidget, LayerMetaWiget
w = p.get_window()
self._layer_path_widget = LayerPathWidget(ICON_PATH)
self._meta_widget = LayerMetaWiget(ICON_PATH)
if w:
w.register_widget("layers", "path", self._layer_path_widget)
w.register_widget("layers", "metadata", self._meta_widget)
for notifier in self._selection_notifiers:
notifier.start()
# notifier._notify_layer_selection_changed(None) # force a refresh
self._registered = True
except Exception as exc:
carb.log_warn(f"error {exc}")
def _unregister_widget(self):
try:
import omni.kit.window.property as p
w = p.get_window()
if w:
for notifier in self._selection_notifiers:
notifier.stop()
w.unregister_widget("layers", "metadata")
w.unregister_widget("layers", "path")
self._registered = False
if self._layer_path_widget:
self._layer_path_widget.destroy()
self._layer_path_widget = None
self._meta_widget = None
except Exception as e:
carb.log_warn(f"Unable to unregister omni.kit.property.layer.widgets: {e}")
class SelectionNotifier:
def __init__(self, property_window_context_id=""):
self._property_window_context_id = property_window_context_id
def start(self):
layers_widget = self.get_layers_widget()
if layers_widget:
layers_widget.add_layer_selection_changed_fn(self._notify_layer_selection_changed)
def get_layers_widget(self):
return omni.kit.widget.layers.get_instance()
def stop(self):
layers_widget = self.get_layers_widget()
if layers_widget:
layers_widget.remove_layer_selection_changed_fn(self._notify_layer_selection_changed)
def _notify_layer_selection_changed(self, item):
import omni.kit.window.property as p
# TODO _property_window_context_id
w = p.get_window()
if w and self.get_layers_widget():
layer_item = self.get_layers_widget().get_current_focused_layer_item()
if layer_item:
w.notify("layers", weakref.ref(layer_item))
else:
w.notify("layers", None)
|
omniverse-code/kit/exts/omni.kit.property.layer/omni/kit/property/layer/commands.py | import weakref
import carb
import omni.kit.commands
from pxr import Sdf, Usd, UsdGeom, UsdPhysics
from .types import LayerMetaType
from omni.kit.widget.layers import LayerUtils
class ModifyStageAxisCommand(omni.kit.commands.Command):
"""Modify stage up axis undoable **Command**."""
def __init__(self, stage, axis):
if stage:
self._stage = weakref.ref(stage)
else:
self._stage = None
self._new_axis = axis
self._old_axis = None
def do(self):
if self._stage and self._stage():
self._old_axis = UsdGeom.GetStageUpAxis(self._stage())
UsdGeom.SetStageUpAxis(self._stage(), self._new_axis)
def undo(self):
if self._stage and self._stage() and self._old_axis:
UsdGeom.SetStageUpAxis(self._stage(), self._old_axis)
class ModifyLayerMetadataCommand(omni.kit.commands.Command):
"""Modify layer metadata undoable **Command**."""
def __init__(self, layer_identifier, parent_layer_identifier, meta_index, value):
"""Constructor.
Keyword Arguments:
layer_identifier (str): Layer identifier to operate.
parent_identifier (str): Parent identifier that layer_identifier resides in as sublayer.
It's None if it's root layer.
meta_index (omni.kit.property.layer.types.LayerMetaType): Metadata type.
"""
super().__init__()
self._layer_identifer = layer_identifier
self._parent_layer_identifier = parent_layer_identifier
self._meta_index = meta_index
self._new_value = value
self._old_value = None
def _set_value(self, meta_type, value):
layer = Sdf.Find(self._layer_identifer)
if not layer:
return
if self._parent_layer_identifier:
parent_layer = Sdf.Find(self._parent_layer_identifier)
else:
parent_layer = None
try:
if meta_type == LayerMetaType.COMMENT:
self._old_value = layer.comment
layer.comment = str(value)
elif meta_type == LayerMetaType.DOC:
self._old_value = layer.documentation
layer.documentation = str(value)
elif meta_type == LayerMetaType.START_TIME:
self._old_value = layer.startTimeCode
layer.startTimeCode = float(value)
elif meta_type == LayerMetaType.END_TIME:
self._old_value = layer.endTimeCode
layer.endTimeCode = float(value)
elif meta_type == LayerMetaType.TIMECODES_PER_SECOND:
self._old_value = layer.timeCodesPerSecond
layer.timeCodesPerSecond = float(value)
elif meta_type == LayerMetaType.FPS_PER_SECOND:
self._old_value = layer.framesPerSecond
layer.framesPerSecond = float(value)
elif meta_type == LayerMetaType.UNITS:
stage = Usd.Stage.Open(layer, None, None, Usd.Stage.LoadNone)
meters = UsdGeom.GetStageMetersPerUnit(stage)
self._old_value = meters
UsdGeom.SetStageMetersPerUnit(stage, float(value))
elif meta_type == LayerMetaType.KG_PER_UNIT:
stage = Usd.Stage.Open(layer, None, None, Usd.Stage.LoadNone)
kilograms = UsdPhysics.GetStageKilogramsPerUnit(stage)
self._old_value = kilograms
UsdPhysics.SetStageKilogramsPerUnit(stage, float(value))
elif parent_layer and meta_type == LayerMetaType.LAYER_OFFSET:
layer_index = LayerUtils.get_sublayer_position_in_parent(
self._parent_layer_identifier, layer.identifier
)
offset = parent_layer.subLayerOffsets[layer_index]
self._old_value = offset.offset
parent_layer.subLayerOffsets[layer_index] = Sdf.LayerOffset(float(value), offset.scale)
elif parent_layer and meta_type == LayerMetaType.LAYER_SCALE:
layer_index = LayerUtils.get_sublayer_position_in_parent(
self._parent_layer_identifier, layer.identifier
)
offset = parent_layer.subLayerOffsets[layer_index]
self._old_value = offset.scale
parent_layer.subLayerOffsets[layer_index] = Sdf.LayerOffset(offset.offset, float(value))
except Exception as e:
pass
def do(self):
self._set_value(self._meta_index, self._new_value)
def undo(self):
self._set_value(self._meta_index, self._old_value)
|
omniverse-code/kit/exts/omni.kit.property.layer/omni/kit/property/layer/layer_property_widgets.py | # Copyright (c) 2020, 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 os
import carb
import omni.client
import omni.kit.window.content_browser as content
import omni.ui as ui
import omni.usd
from omni.kit.usd.layers import get_layers, LayerEventType, get_layer_event_payload
from omni.kit.window.property.templates import HORIZONTAL_SPACING, LABEL_HEIGHT, LABEL_WIDTH, SimplePropertyWidget
from .file_picker import FileBrowserSelectionType, FilePicker
from .layer_property_models import LayerMetaModel, LayerPathModel, LayerWorldAxisModel
from .types import LayerMetaName, LayerMetaType
class LayerPathWidget(SimplePropertyWidget):
def __init__(self, icon_path):
super().__init__(title="Layer Path", collapsed=False)
self._icon_path = icon_path
self._file_picker = None
self._layer_path_field = False
self._layer_path_model = None
def destroy(self):
if self._file_picker:
self._file_picker.destroy()
def _show_file_picker(self):
if not self._file_picker:
self._file_picker = FilePicker(
"Select File",
"Select",
FileBrowserSelectionType.FILE_ONLY,
[(omni.usd.writable_usd_re(),
omni.usd.writable_usd_files_desc())],
)
self._file_picker.set_custom_fn(self._on_file_selected, None)
if self._layer_path_field:
value = self._layer_path_field.model.get_value_as_string()
current_dir = os.path.dirname(value)
self._file_picker.set_current_directory(current_dir)
self._file_picker.show_dialog()
def _on_file_selected(self, path):
self._layer_path_field.model.replace_layer(path)
def on_new_payload(self, payload):
if not super().on_new_payload(payload, ignore_large_selection=True):
return False
return payload is not None
def build_items(self):
layer_item = self._payload
if layer_item and layer_item():
with ui.VStack(height=0, spacing=5):
with ui.HStack():
self._layer_path_model = LayerPathModel(layer_item)
if self._layer_path_model.is_reserved_layer():
read_only = True
else:
read_only = False
self._layer_path_field = ui.StringField(
name="models", model=self._layer_path_model, read_only=read_only
)
if layer_item().missing:
self._layer_path_field.set_style({"color" : 0xFF6F72FF})
style = {"image_url": str(self._icon_path.joinpath("small_folder.png"))}
if not read_only:
ui.Spacer(width=3)
open_button = ui.Button(style=style, width=20, tooltip="Open")
open_button.set_clicked_fn(self._show_file_picker)
if not self._layer_path_model.anonymous():
ui.Spacer(width=3)
style["image_url"] = str(self._icon_path.joinpath("find.png"))
find_button = ui.Button(style=style, width=20, tooltip="Find")
def find_button_fn():
path = self._layer_path_field.model.get_value_as_string()
# Remove checkpoint and branch so navigate_to works
client_url = omni.client.break_url(path)
path = omni.client.make_url(
scheme=client_url.scheme,
user=client_url.user,
host=client_url.host,
port=client_url.port,
path=client_url.path,
query=None,
fragment=client_url.fragment,
)
content.get_content_window().navigate_to(path)
find_button.set_clicked_fn(find_button_fn)
if not self._layer_path_model.anonymous():
if self._filter.matches("Checkpoint"):
self._build_checkpoint_ui(layer_item().identifier)
self._any_item_visible = True
else:
selected_info_name = "(nothing selected)"
ui.StringField(name="layer_path", height=LABEL_HEIGHT, enabled=False).model.set_value(selected_info_name)
def _build_checkpoint_ui(self, absolute_layer_path):
try:
# Use checkpoint widget in the drop down menu for more detailed information
from omni.kit.widget.versioning.checkpoint_combobox import CheckpointCombobox
with ui.HStack(spacing=HORIZONTAL_SPACING):
self.add_label("Checkpoint")
def on_selection_changed(selection):
if selection:
self._layer_path_model.replace_layer(selection.get_full_url())
self._checkpoint_combobox = CheckpointCombobox(absolute_layer_path, on_selection_changed)
return None
except ImportError as e:
# If the widget is not available, create a simple combo box instead
carb.log_warn(f"Checkpoint widget in Layer Path widget is not availbale due to: {e}")
class LayerMetaWiget(SimplePropertyWidget):
def __init__(self, icon_path):
super().__init__(title="Layer Metadata", collapsed=False)
self._icon_path = icon_path
self._models = {}
self._meta_change_listener = None
def on_new_payload(self, payload):
if not super().on_new_payload(payload):
return False
return payload is not None
def reset(self):
super().reset()
self._meta_change_listener = None
self._models = {}
def _on_meta_changed(self, event: carb.events.IEvent):
payload = get_layer_event_payload(event)
if payload and payload.event_type == LayerEventType.INFO_CHANGED:
layer_item = self._payload
if layer_item and layer_item() and layer_item().layer:
layer_item = layer_item()
if layer_item.identifier in payload.layer_info_data:
info_tokens = payload.layer_info_data.get(layer_item.identifier, [])
for token in info_tokens:
model = self._models.get(token, None)
if model:
model.on_value_changed()
def build_items(self):
layer_item = self._payload
if layer_item and layer_item() and layer_item().layer:
usd_context = layer_item().usd_context
layers = get_layers(usd_context)
event_stream = layers.get_event_stream()
self._meta_change_listener = event_stream.create_subscription_to_pop(self._on_meta_changed, name="Layers Property Window")
model = LayerWorldAxisModel(layer_item)
self._models[model.get_usd_token_name()] = model
if self._filter.matches("World Axis"):
with ui.HStack(spacing=HORIZONTAL_SPACING):
self.add_label("World Axis")
ui.ComboBox(model, name="choices")
self._any_item_visible = True
for index in range(LayerMetaType.NUM_PROPERTIES):
model = LayerMetaModel(layer_item, index)
if model.get_value_as_string() is not None:
self.add_item_with_model(LayerMetaName[index], model, True)
self._models[model.get_usd_token_name()] = model
|
omniverse-code/kit/exts/omni.kit.property.layer/omni/kit/property/layer/__init__.py | # Copyright (c) 2018-2020, 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.
#
from .widgets import LayerPropertyWidgets, get_instance
from .commands import ModifyStageAxisCommand, ModifyLayerMetadataCommand
|
omniverse-code/kit/exts/omni.kit.property.layer/omni/kit/property/layer/file_picker.py | import asyncio
import os
import re
import psutil
import carb
import omni.ui
import omni.client
from typing import Callable, Iterable, Tuple, Union
from omni.kit.window.filepicker import FilePickerDialog
from omni.kit.widget.filebrowser import FileBrowserItem
class FileBrowserSelectionType:
FILE_ONLY = 0
DIRECTORY_ONLY = 1
ALL = 2
class FilePicker:
"""
Args:
title (str): Title of the window.
apply_button_name (str): Name of the confirm button.
selection_type (FileBrowserSelectionType): The file type that confirm event will respond to.
item_filter_options (Iterable[Tuple[Union[re.Pattern, str], str]]):
Array of filter options. Element of array is a tuple that first
element of this tuple is the regex for filtering (string or compiled
re.Pattern), and second element of this tuple is the descriptions,
like (".*", "All Files"). By default, it will list all files.
"""
def __init__(
self,
title: str,
apply_button_name: str,
selection_type: FileBrowserSelectionType = FileBrowserSelectionType.ALL,
item_filter_options: Iterable[Tuple[Union[re.Pattern, str], str]] = ((
re.compile(".*"), "All Files (*.*)")),
):
self._title = title
self._filepicker = None
self._selection_type = selection_type
self._custom_select_fn = None
self._custom_cancel_fn = None
self._apply_button_name = apply_button_name
self._filter_regexes = []
self._filter_descriptions = []
self._current_directory = None
for regex, desc in item_filter_options:
if not isinstance(regex, re.Pattern):
regex = re.compile(regex, re.IGNORECASE)
self._filter_regexes.append(regex)
self._filter_descriptions.append(desc)
self._build_ui()
def destroy(self):
self.set_custom_fn(None, None)
if self._filepicker:
self._filepicker.destroy()
def set_custom_fn(self, select_fn, cancel_fn):
self._custom_select_fn = select_fn
self._custom_cancel_fn = cancel_fn
def show_dialog(self):
self._filepicker.show(self._current_directory)
self._current_directory = None
def hide_dialog(self):
self._filepicker.hide()
def set_current_directory(self, dir: str):
self._current_directory = dir
def set_current_filename(self, filename: str):
self._filepicker.set_filename(filename)
def _build_ui(self):
on_click_open = lambda f, d: asyncio.ensure_future(self._on_click_open(f, d))
on_click_cancel = lambda f, d: asyncio.ensure_future(self._on_click_cancel(f, d))
# Create the dialog
self._filepicker = FilePickerDialog(
self._title,
allow_multi_selection=False,
apply_button_label=self._apply_button_name,
click_apply_handler=on_click_open,
click_cancel_handler=on_click_cancel,
item_filter_options=self._filter_descriptions,
item_filter_fn=lambda item: self._on_filter_item(item),
error_handler=lambda m: self._on_error(m),
)
# Start off hidden
self.hide_dialog()
def _on_filter_item(self, item: FileBrowserItem) -> bool:
if not item or item.is_folder:
return True
if self._filepicker.current_filter_option >= len(self._filter_regexes):
return False
regex = self._filter_regexes[self._filepicker.current_filter_option]
if regex.match(item.path):
return True
else:
return False
def _on_error(self, msg: str):
"""
Demonstrates error handling. Instead of just printing to the shell, the App can
display the error message to a console window.
"""
print(msg)
async def _on_click_open(self, filename: str, dirname: str):
"""
The meat of the App is done in this callback when the user clicks 'Accept'. This is
a potentially costly operation so we implement it as an async operation. The inputs
are the filename and directory name. Together they form the fullpath to the selected
file.
"""
dirname = dirname.strip()
if dirname and not dirname.endswith("/"):
dirname += "/"
fullpath = f"{dirname}{filename}"
result, entry = omni.client.stat(fullpath)
if result == omni.client.Result.OK and entry.flags & omni.client.ItemFlags.CAN_HAVE_CHILDREN:
is_folder = True
else:
is_folder = False
if (is_folder and self._selection_type == FileBrowserSelectionType.FILE_ONLY) or (
not is_folder and self._selection_type == FileBrowserSelectionType.DIRECTORY_ONLY
):
return
self.hide_dialog()
await omni.kit.app.get_app().next_update_async()
if self._custom_select_fn:
self._custom_select_fn(fullpath)
async def _on_click_cancel(self, filename: str, dirname: str):
"""
This function is called when the user clicks 'Cancel'.
"""
self.hide_dialog()
await omni.kit.app.get_app().next_update_async()
if self._custom_cancel_fn:
self._custom_cancel_fn()
|
omniverse-code/kit/exts/omni.kit.property.layer/omni/kit/property/layer/types.py | class LayerMetaType:
START_TIME = 0
END_TIME = 1
TIMECODES_PER_SECOND = 2
FPS_PER_SECOND = 3
UNITS = 4
LAYER_OFFSET = 5
LAYER_SCALE = 6
KG_PER_UNIT = 7
COMMENT = 8
DOC = 9
NUM_PROPERTIES = 10
LayerMetaName = [
"Start Time Code",
"End Time Code",
"Time Codes Per Second",
"Frames Per Second",
"Meters Per Unit",
"Layer Offset",
"Layer Scale",
"Kgs Per Unit",
"Comment",
"Documentation"
]
|
omniverse-code/kit/exts/omni.kit.property.layer/omni/kit/property/layer/tests/test_property_window.py | ## Copyright (c) 2021, 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 tempfile
import os
import omni.kit.app
import omni.kit.commands
import omni.kit.test
import omni.ui as ui
import omni.kit.widget.layers as layers_widget
import omni.kit.property.layer as layers_property
from omni.kit.property.layer.layer_property_models import LayerMetaModel, LayerWorldAxisModel
from omni.kit.property.layer.types import LayerMetaType
from omni.ui.tests.test_base import OmniUiTest
from pxr import Kind, Sdf, Gf, UsdGeom, UsdPhysics
class TestLayerPropertyUI(OmniUiTest):
# Before running each test
async def setUp(self):
await super().setUp()
self._usd_context = omni.usd.get_context()
await self._usd_context.new_stage_async()
# After running each test
async def tearDown(self):
await self._usd_context.close_stage_async()
await super().tearDown()
async def wait_for_update(self, usd_context=omni.usd.get_context(), wait_frames=10):
max_loops = 0
while max_loops < wait_frames:
_, files_loaded, total_files = usd_context.get_stage_loading_status()
await omni.kit.app.get_app().next_update_async()
if files_loaded or total_files:
continue
max_loops = max_loops + 1
async def test_layer_replacement(self):
omni.usd.get_context().set_pending_edit(False)
stage = self._usd_context.get_stage()
root_layer = stage.GetRootLayer()
sublayer = Sdf.Layer.CreateAnonymous()
sublayer_replace = Sdf.Layer.CreateAnonymous()
root_layer.subLayerPaths.append(sublayer.identifier)
missing_identifier = "non_existed_sublayer_identifier.usd"
root_layer.subLayerPaths.append(missing_identifier)
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
layers_widget.get_instance().set_current_focused_layer_item(sublayer.identifier)
# Wait several frames to make sure it's focused
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
# Make sure it's changed
focused_item = layers_widget.get_instance().get_current_focused_layer_item()
self.assertTrue(focused_item)
self.assertEqual(focused_item.identifier, sublayer.identifier)
layer_path_widget = layers_property.get_instance()._layer_path_widget
layer_path_widget._show_file_picker()
await self.wait_for_update()
layer_path_widget._on_file_selected(sublayer_replace.identifier)
await self.wait_for_update()
# Make sure it's replaced
self.assertTrue(root_layer.subLayerPaths[0], sublayer_replace.identifier)
omni.kit.undo.undo()
self.assertTrue(root_layer.subLayerPaths[0], sublayer.identifier)
# Focus and replace missing layer
layers_widget.get_instance().set_current_focused_layer_item(missing_identifier)
# Wait several frames to make sure it's focused
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
# Make sure it's changed
focused_item = layers_widget.get_instance().get_current_focused_layer_item()
self.assertTrue(focused_item and focused_item.missing)
self.assertEqual(focused_item.identifier, missing_identifier)
layer_path_widget = layers_property.get_instance()._layer_path_widget
layer_path_widget._show_file_picker()
await self.wait_for_update()
layer_path_widget._on_file_selected(sublayer_replace.identifier)
await self.wait_for_update()
# Make sure it's replaced
self.assertTrue(root_layer.subLayerPaths[0], sublayer_replace.identifier)
async def test_commands(self):
test_comment = "test comment"
test_doc = "test document"
test_start_time = "0.0"
test_end_time = "96.0"
test_timecodes_per_second = "24.0"
test_fps_per_second = "24.0"
test_units = "10.0"
test_kg_per_units = "10.0"
test_layer_offset = "1.0"
test_layer_scale = "10.0"
omni.usd.get_context().set_pending_edit(False)
stage = self._usd_context.get_stage()
root_layer = stage.GetRootLayer()
layers_widget.get_instance().set_current_focused_layer_item(root_layer.identifier)
await self.wait_for_update()
meta_models = layers_property.get_instance()._meta_widget._models
modified_metadata = {}
old_up_index = new_up_index = None
for token, model in meta_models.items():
if isinstance(model, LayerMetaModel):
new_value = None
if model._meta_type == LayerMetaType.COMMENT:
new_value = test_comment
elif model._meta_type == LayerMetaType.DOC:
new_value = test_doc
elif model._meta_type == LayerMetaType.START_TIME:
new_value = test_start_time
elif model._meta_type == LayerMetaType.END_TIME:
new_value = test_end_time
elif model._meta_type == LayerMetaType.TIMECODES_PER_SECOND:
new_value = test_timecodes_per_second
elif model._meta_type == LayerMetaType.UNITS:
new_value = test_units
elif model._meta_type == LayerMetaType.KG_PER_UNIT:
new_value = test_kg_per_units
elif model._meta_type == LayerMetaType.FPS_PER_SECOND and root_layer.HasFramesPerSecond():
new_value = test_fps_per_second
if new_value:
model.set_value(new_value)
model.end_edit()
modified_metadata[model._meta_type] = model
elif isinstance(model, LayerWorldAxisModel):
old_up_index = model._current_index.get_value_as_int()
if old_up_index == 0: # up_axis is UsdGeom.Tokens.y
new_up_index = 1
else: # up_axis is UsdGeom.Tokens.z
new_up_index = 0
model._current_index.set_value(new_up_index)
# Wait several frames to make sure it's focused
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
# Check if the metadata is set correctly
for meta_type, model in modified_metadata.items():
if meta_type == LayerMetaType.COMMENT:
self.assertEqual(test_comment, str(root_layer.comment))
elif meta_type == LayerMetaType.DOC:
self.assertEqual(test_doc, str(root_layer.documentation))
elif meta_type == LayerMetaType.START_TIME:
self.assertEqual(test_start_time, str(root_layer.startTimeCode))
elif meta_type == LayerMetaType.END_TIME:
self.assertEqual(test_end_time, str(root_layer.endTimeCode))
elif meta_type == LayerMetaType.TIMECODES_PER_SECOND:
self.assertEqual(test_timecodes_per_second, str(root_layer.timeCodesPerSecond))
elif meta_type == LayerMetaType.UNITS:
meters = UsdGeom.GetStageMetersPerUnit(stage)
self.assertEqual(test_units, str(meters))
elif meta_type == LayerMetaType.KG_PER_UNIT:
kilograms = UsdPhysics.GetStageKilogramsPerUnit(stage)
self.assertEqual(test_kg_per_units, str(kilograms))
elif meta_type == LayerMetaType.FPS_PER_SECOND and root_layer.HasFramesPerSecond():
self.assertEqual(test_fps_per_second, str(root_layer.framesPerSecond))
if new_up_index is not None:
up_axis = UsdGeom.GetStageUpAxis(stage)
if new_up_index == 0:
self.assertEqual(up_axis, UsdGeom.Tokens.y)
elif new_up_index == 1:
self.assertEqual(up_axis, UsdGeom.Tokens.z)
# Testing metadata for sublayers
sublayer = Sdf.Layer.CreateAnonymous()
root_layer.subLayerPaths.append(sublayer.identifier)
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
layers_widget.get_instance().set_current_focused_layer_item(sublayer.identifier)
# Wait several frames to make sure it's focused
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
# Make sure it's changed
focused_item = layers_widget.get_instance().get_current_focused_layer_item()
self.assertTrue(focused_item)
self.assertEqual(focused_item.identifier, sublayer.identifier)
meta_models = layers_property.get_instance()._meta_widget._models
modified_metadata = {}
for token, model in meta_models.items():
if isinstance(model, LayerMetaModel):
new_value = None
if model._meta_type == LayerMetaType.LAYER_OFFSET and model._layer_item().parent:
new_value = test_layer_offset
elif model._meta_type == LayerMetaType.LAYER_SCALE and model._layer_item().parent:
new_value = test_layer_scale
if new_value:
model.set_value(new_value)
model.end_edit()
modified_metadata[model._meta_type] = model
# Check if the metadata is set correctly
for meta_type, model in modified_metadata.items():
parent = model._layer_item().parent
layer = model._layer_item().layer
layer_index = layers_widget.LayerUtils.get_sublayer_position_in_parent(parent.identifier, layer.identifier)
offset = parent.layer.subLayerOffsets[layer_index]
if meta_type == LayerMetaType.LAYER_OFFSET:
self.assertEqual(test_layer_offset, str(offset.offset))
elif meta_type == LayerMetaType.LAYER_SCALE and model._layer_item().parent:
self.assertEqual(test_layer_scale, str(offset.scale))
async def test_shut_down(self):
manager = omni.kit.app.get_app().get_extension_manager()
ext_id = "omni.kit.property.layer"
self.assertTrue(ext_id)
self.assertTrue(manager.is_extension_enabled(ext_id))
manager.set_extension_enabled(ext_id, False)
await self.wait_for_update()
self.assertTrue(not manager.is_extension_enabled(ext_id))
manager.set_extension_enabled(ext_id, True)
await self.wait_for_update()
self.assertTrue(manager.is_extension_enabled(ext_id))
|
omniverse-code/kit/exts/omni.kit.property.layer/omni/kit/property/layer/tests/__init__.py | from .test_property_window import * |
omniverse-code/kit/exts/omni.kit.property.layer/docs/CHANGELOG.md | # Changelog
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
## [1.1.4] - 2023-01-17
### Changes
- Delay frames until layer item is initialized after replacing.
## [1.1.3] - 2022-03-31
### Changes
- Integrate new omni.kit.usd.layers interfaces to replace layers interfaces from omni.usd.
## [1.1.2] - 2021-06-11
### Fixes
- Fix regression to replace missing layer.
## [1.1.1] - 2021-04-23
### Changes
- Disabled large selection optimization
## [1.1.0] - 2021-03-25
### Added
- Added checkpoint dropdown to Layer Path Widget. Requires `omni.kit.widget.versioning` to be enabled.
## [1.0.1] - 2020-12-09
### Changes
- Added extension icon
- Updated preview image
## [1.0.0] - 2020-10-07
### Added
- Layer Widgets Released.
|
omniverse-code/kit/exts/omni.kit.property.layer/docs/index.rst | omni.kit.property.layer
###########################
Layer Property Window Widgets
.. toctree::
:maxdepth: 1
CHANGELOG
|
omniverse-code/kit/exts/omni.graph.io/ogn/nodes.json | {
"nodes": {
"omni.graph.BundleToUSDA": {
"description": "Outputs a represention of the content of a bundle as usda text",
"version": 1,
"extension": "omni.graph.io",
"language": "C++"
},
"omni.graph.ExportUSDPrim": {
"description": "Exports data from an input bundle into a USD prim",
"version": 1,
"extension": "omni.graph.io",
"language": "C++"
},
"omni.graph.ImportUSDPrim": {
"description": "Imports data from a USD prim into attributes in an output bundle",
"version": 1,
"extension": "omni.graph.io",
"language": "C++"
},
"omni.graph.TransformBundle": {
"description": "Applies a transform to an input bundle, storing the result in an output bundle",
"version": 1,
"extension": "omni.graph.io",
"language": "C++"
}
}
}
|
omniverse-code/kit/exts/omni.graph.io/ogn/docs/OgnImportUSDPrim.rst | .. _omni_graph_ImportUSDPrim_1:
.. _omni_graph_ImportUSDPrim:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: import USD prim data
:keywords: lang-en omnigraph node graph import-u-s-d-prim
import USD prim data
====================
.. <description>
Imports data from a USD prim into attributes in an output bundle
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.io<ext_omni_graph_io>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"inputs:applySkelBinding", "``bool``", "If the input USD prim is a Mesh, and has SkelBindingAPI schema applied, compute skinned points and normals.", "True"
"", "*displayGroup*", "parameters", ""
"inputs:applyTransform", "``bool``", "If importAttributes is true, apply the transform necessary to transform any transforming attributes into the space of this node.", "False"
"", "*displayGroup*", "parameters", ""
"Attributes To Import (*inputs:attrNamesToImport*)", "``token``", "Comma or space separated text, listing the names of attributes in the input data to be imported or empty to import all attributes.", ""
"", "*displayGroup*", "parameters", ""
"inputs:computeBoundingBox", "``bool``", "Compute and store local bounding box of a prim and its children.", "False"
"", "*displayGroup*", "parameters", ""
"inputs:importAttributes", "``bool``", "Import attribute data from the USD prim.", "True"
"", "*displayGroup*", "parameters", ""
"inputs:importPath", "``bool``", "Record the input USD prim's path into the output bundle in an attribute named ""primPath"".", "True"
"", "*displayGroup*", "parameters", ""
"inputs:importPrimvarMetadata", "``bool``", "Import metadata like the interpolation type for primvars, and store it as attributes in the output bundle.", "True"
"", "*displayGroup*", "parameters", ""
"inputs:importTime", "``bool``", "Record the usdTimecode above into the output bundle in an attribute named ""primTime"".", "True"
"", "*displayGroup*", "parameters", ""
"inputs:importTransform", "``bool``", "Record the transform required to take any attributes of the input USD prim into the space of this node, i.e. the world transform of the input prim times the inverse world transform of this node, into the output bundle in an attribute named ""transform"".", "True"
"", "*displayGroup*", "parameters", ""
"inputs:importType", "``bool``", "Deprecated, prim type is always imported", "True"
"", "*hidden*", "true", ""
"", "*displayGroup*", "parameters", ""
"Attributes To Rename (*inputs:inputAttrNames*)", "``token``", "Comma or space separated text, listing the names of attributes in the input data to be renamed", ""
"inputs:keepPrimsSeparate", "``bool``", "Prefix output attribute names with ""prim"" followed by a unique number and a colon, to keep the attributes for separate input prims separate. The prim paths will be in the ""primPaths"" token array attribute.", "True"
"", "*displayGroup*", "parameters", ""
"New Attribute Names (*inputs:outputAttrNames*)", "``token``", "Comma or space separated text, listing the new names for the attributes listed in inputAttrNames", ""
"inputs:prim", "``bundle``", "The USD prim from which to import data.", "None"
"inputs:renameAttributes", "``bool``", "If true, attributes listed in ""inputAttrNames"" will be imported to attributes with the names specified in ""outputAttrNames"".", "False"
"", "*displayGroup*", "parameters", ""
"inputs:timeVaryingAttributes", "``bool``", "Check whether the USD attributes are time-varying and if so, import their data at the time ""usdTimecode"".", "True"
"", "*displayGroup*", "parameters", ""
"inputs:usdTimecode", "``double``", "The time at which to evaluate the transform of the USD prim.", "0"
"", "*displayGroup*", "parameters", ""
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"outputs:output", "``bundle``", "Output bundle containing all of the imported data.", "None"
State
-----
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"state:prevApplySkelBinding", "``bool``", "Value of ""applySkelBinding"" input from previous run", "None"
"state:prevApplyTransform", "``bool``", "Value of ""applyTransform"" input from previous run", "None"
"state:prevAttrNamesToImport", "``token``", "Value of ""attrNamesToImport"" input from previous run", "None"
"state:prevComputeBoundingBox", "``bool``", "Value of ""computeBoundingBox"" input from previous run", "None"
"state:prevImportAttributes", "``bool``", "Value of ""importAttributes"" input from previous run", "None"
"state:prevImportPath", "``bool``", "Value of ""importPath"" input from previous run", "None"
"state:prevImportPrimvarMetadata", "``bool``", "Value of ""importPrimvarMetadata"" input from previous run", "None"
"state:prevImportTime", "``bool``", "Value of ""importTime"" input from previous run", "None"
"state:prevImportTransform", "``bool``", "Value of ""importTransform"" input from previous run", "None"
"state:prevImportType", "``bool``", "Value of ""importType"" input from previous run", "None"
"state:prevInputAttrNames", "``token``", "Value of ""inputAttrNames"" input from previous run", "None"
"state:prevInvNodeTransform", "``matrixd[4]``", "Inverse transform of the node prim from the previous run.", "None"
"state:prevKeepPrimsSeparate", "``bool``", "Value of ""keepPrimsSeparate"" input from previous run", "None"
"state:prevOnlyImportSpecified", "``bool``", "Value of ""onlyImportSpecified"" input from previous run", "None"
"state:prevOutputAttrNames", "``token``", "Value of ""outputAttrNames"" input from previous run", "None"
"state:prevPaths", "``token[]``", "Array of paths from the previous run.", "None"
"state:prevRenameAttributes", "``bool``", "Value of ""renameAttributes"" input from previous run", "None"
"state:prevTimeVaryingAttributes", "``bool``", "Value of ""timeVaryingAttributes"" input from previous run", "None"
"state:prevTransforms", "``matrixd[4][]``", "Array of transforms from the previous run.", "None"
"state:prevUsdTimecode", "``double``", "Value of ""usdTimecode"" input from previous run", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ImportUSDPrim"
"Version", "1"
"Extension", "omni.graph.io"
"Icon", "ogn/icons/omni.graph.ImportUSDPrim.svg"
"Has State?", "True"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "None"
"uiName", "import USD prim data"
"Generated Class Name", "OgnImportUSDPrimDatabase"
"Python Module", "omni.graph.io"
|
omniverse-code/kit/exts/omni.graph.io/ogn/docs/OgnTransformBundle.rst | .. _omni_graph_TransformBundle_1:
.. _omni_graph_TransformBundle:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: transform bundle
:keywords: lang-en omnigraph node graph transform-bundle
transform bundle
================
.. <description>
Applies a transform to an input bundle, storing the result in an output bundle
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.io<ext_omni_graph_io>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"inputs:input", "``bundle``", "Input bundle containing the attributes to be transformed.", "None"
"inputs:transform", "``matrixd[4]``", "The transform to apply to the bundle", "[[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0]]"
"", "*displayGroup*", "parameters", ""
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"outputs:output", "``bundle``", "Output bundle containing all of the transformed attributes", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.TransformBundle"
"Version", "1"
"Extension", "omni.graph.io"
"Icon", "ogn/icons/omni.graph.TransformBundle.svg"
"Has State?", "False"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "None"
"uiName", "transform bundle"
"Generated Class Name", "OgnTransformBundleDatabase"
"Python Module", "omni.graph.io"
|
omniverse-code/kit/exts/omni.graph.io/ogn/docs/OgnBundleToUSDA.rst | .. _omni_graph_BundleToUSDA_1:
.. _omni_graph_BundleToUSDA:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Bundle to usda text
:keywords: lang-en omnigraph node threadsafe graph bundle-to-u-s-d-a
Bundle to usda text
===================
.. <description>
Outputs a represention of the content of a bundle as usda text
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.io<ext_omni_graph_io>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"inputs:bundle", "``bundle``", "The bundle to convert to usda text.", "None"
"inputs:outputAncestors", "``bool``", "If usePath is true and this is also true, ancestor ""primPath"" entries will be output.", "False"
"", "*displayGroup*", "parameters", ""
"inputs:outputValues", "``bool``", "If true, the values of attributes will be output, else values will be omitted.", "True"
"", "*displayGroup*", "parameters", ""
"inputs:usePrimPath", "``bool``", "Use the attribute named ""primPath"" for the usda prim path.", "True"
"", "*displayGroup*", "parameters", ""
"inputs:usePrimType", "``bool``", "Use the attribute named ""primType"" for the usda prim type name.", "True"
"", "*displayGroup*", "parameters", ""
"inputs:usePrimvarMetadata", "``bool``", "Identify attributes representing metadata like the interpolation type for primvars, and include them as usda metadata in the output text.", "True"
"", "*displayGroup*", "parameters", ""
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"outputs:text", "``token``", "Output usda text representing the bundle contents.", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.BundleToUSDA"
"Version", "1"
"Extension", "omni.graph.io"
"Icon", "ogn/icons/omni.graph.BundleToUSDA.svg"
"Has State?", "False"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "None"
"uiName", "Bundle to usda text"
"Generated Class Name", "OgnBundleToUSDADatabase"
"Python Module", "omni.graph.io"
|
omniverse-code/kit/exts/omni.graph.io/ogn/docs/OgnExportUSDPrim.rst | .. _omni_graph_ExportUSDPrim_1:
.. _omni_graph_ExportUSDPrim:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: export USD prim data
:keywords: lang-en omnigraph node WriteOnly graph export-u-s-d-prim
export USD prim data
====================
.. <description>
Exports data from an input bundle into a USD prim
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.io<ext_omni_graph_io>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"inputs:applyTransform", "``bool``", "If true, apply the transform necessary to transform any transforming attributes from the space of the node into the space of the specified prim.", "False"
"", "*displayGroup*", "parameters", ""
"Attributes To Export (*inputs:attrNamesToExport*)", "``token``", "Comma or space separated text, listing the names of attributes in the input data to be exported or empty to import all attributes.", ""
"", "*displayGroup*", "parameters", ""
"inputs:bundle", "``bundle``", "The bundle from which data should be exported.", "None"
"Attributes To Exclude (*inputs:excludedAttrNames*)", "``token``", "Attributes to be excluded from being exported", ""
"Export to Root Layer (*inputs:exportToRootLayer*)", "``bool``", "If true, prims are exported in the root layer, otherwise the layer specified by ""layerName"" is used.", "True"
"Attributes To Rename (*inputs:inputAttrNames*)", "``token``", "Comma or space separated text, listing the names of attributes in the input data to be renamed", ""
"Layer Name (*inputs:layerName*)", "``token``", "Identifier of the layer to export to if ""exportToRootLayer"" is false, or leave this blank to export to the session layer", ""
"inputs:onlyExportToExisting", "``bool``", "If true, only attributes that already exist in the specified output prim will have data transferred to them from the input bundle.", "False"
"", "*displayGroup*", "parameters", ""
"New Attribute Names (*inputs:outputAttrNames*)", "``token``", "Comma or space separated text, listing the new names for the attributes listed in inputAttrNames", ""
"inputs:primPathFromBundle", "``bool``", "When true, if there is a ""primPath"" token attribute inside the bundle, that will be the path of the USD prim to write to, else the ""outputs:prim"" attribute below will be used for the USD prim path.", "False"
"", "*displayGroup*", "parameters", ""
"Export to Root Layer (*inputs:removeMissingAttrs*)", "``bool``", "If true, any attributes on the USD prim(s) being written to, that aren't in the input data, will be removed from the USD prim(s).", "False"
"inputs:renameAttributes", "``bool``", "If true, attributes listed in ""inputAttrNames"" will be exported to attributes with the names specified in ""outputAttrNames"". Note: to avoid potential issues with redundant attributes being created while typing, keep this off until after specifying all input and output attribute names.", "False"
"", "*displayGroup*", "parameters", ""
"inputs:timeVaryingAttributes", "``bool``", "Check whether the USD attributes should be time-varying and if so, export their data to a time sample at the time ""usdTimecode"".", "False"
"", "*displayGroup*", "parameters", ""
"inputs:usdTimecode", "``double``", "The time at which to evaluate the transform of the USD prim for applyTransform.", "0"
"", "*displayGroup*", "parameters", ""
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"outputs:prim", "``bundle``", "The USD prim(s) to which data should be exported if primPathFromBundle is false or if the bundle doesn't have a ""primPath"" token attribute. Note: this is really an input, since the node just receives the path to the prim. The node does not contain the prim.", "None"
"", "*hidden*", "true", ""
State
-----
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"state:prevApplyTransform", "``bool``", "Value of ""applyTransform"" input from previous run", "None"
"state:prevAttrNamesToExport", "``token``", "Value of ""attrNamesToExport"" input from previous run", "None"
"state:prevBundleDirtyID", "``uint64``", "Dirty ID of input bundle from previous run", "None"
"state:prevExcludedAttrNames", "``token``", "Value of ""excludedAttrNames"" input from previous run", "None"
"state:prevExportToRootLayer", "``bool``", "Value of ""exportToRootLayer"" input from previous run", "None"
"state:prevInputAttrNames", "``token``", "Value of ""inputAttrNames"" input from previous run", "None"
"state:prevLayerName", "``token``", "Value of ""layerName"" input from previous run", "None"
"state:prevOnlyExportToExisting", "``bool``", "Value of ""onlyExportToExisting"" input from previous run", "None"
"state:prevOutputAttrNames", "``token``", "Value of ""outputAttrNames"" input from previous run", "None"
"state:prevPrimDirtyIDs", "``uint64[]``", "Dirty IDs of input prims from previous run", "None"
"state:prevPrimPathFromBundle", "``bool``", "Value of ""primPathFromBundle"" input from previous run", "None"
"state:prevRemoveMissingAttrs", "``bool``", "Value of ""removeMissingAttrs"" input from previous run", "None"
"state:prevRenameAttributes", "``bool``", "Value of ""renameAttributes"" input from previous run", "None"
"state:prevTimeVaryingAttributes", "``bool``", "Value of ""timeVaryingAttributes"" input from previous run", "None"
"state:prevUsdTimecode", "``double``", "Value of ""usdTimecode"" input from previous run", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ExportUSDPrim"
"Version", "1"
"Extension", "omni.graph.io"
"Icon", "ogn/icons/omni.graph.ExportUSDPrim.svg"
"Has State?", "True"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "None"
"uiName", "export USD prim data"
"__tokens", "{""primPath"": ""primPath"", ""primType"": ""primType"", ""primTime"": ""primTime"", ""primCount"": ""primCount"", ""transform"": ""transform""}"
"Generated Class Name", "OgnExportUSDPrimDatabase"
"Python Module", "omni.graph.io"
|
omniverse-code/kit/exts/omni.graph.io/PACKAGE-LICENSES/omni.graph.io-LICENSE.md | Copyright (c) 2020, 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. |
omniverse-code/kit/exts/omni.graph.io/config/extension.toml | [package]
# Semantic Versioning is used: https://semver.org/
version = "1.2.5"
# Lists people or organizations that are considered the "authors" of the package.
authors = ["NVIDIA"]
# The title and description fields are primarily for displaying extension info in UI
title = "OmniGraph IO"
description="Input/output node types for OmniGraph"
# Path (relative to the root) or content of readme markdown file for UI.
readme = "docs/README.md"
# URL of the extension source repository.
repository = ""
# One of categories for UI.
category = "Graph"
# Keywords for the extension
keywords = ["graph, input, output, io"]
# Location of change log file in target (final) folder of extension, relative to the root. Can also be just a content
# of it instead of file path. More info on writing changelog: https://keepachangelog.com/en/1.0.0/
changelog="docs/CHANGELOG.md"
# Preview image and icon. Folder named "data" automatically goes in git lfs (see .gitattributes file).
# Preview image is shown in "Overview" of Extensions window. Screenshot of an extension might be a good preview image.
preview_image = "data/preview.png"
# Icon is shown in Extensions window, it is recommended to be square, of size 256x256.
icon = "data/icon.png"
# Main module for the Python interface
[[python.module]]
name = "omni.graph.io"
# Additional module used to make .ogn test files auto-discoverable
[[python.module]]
name = "omni.graph.io.ogn.tests"
# Watch the .ogn files for hot reloading (only works for Python files)
[fswatcher.patterns]
include = ["*.ogn", "*.py"]
exclude = ["Ogn*Database.py"]
# Extensions required to load before this one
[dependencies]
"omni.graph" = {}
"omni.graph.ui" = {optional = true}
"omni.usd" = {}
[[native.plugin]]
path = "bin/*.plugin"
recursive = false
[[test]]
# RTX regression OM-51983
timeout = 600
dependencies = [
"omni.graph.ui" #force load dependency to test the functionality
]
[documentation]
pages = [
"docs/Overview.md",
"docs/CHANGELOG.md",
]
|
omniverse-code/kit/exts/omni.graph.io/omni/graph/io/__init__.py | """There is no public API to this module."""
__all__ = []
|
omniverse-code/kit/exts/omni.graph.io/omni/graph/io/ogn/OgnBundleToUSDADatabase.py | """Support for simplified access to data on nodes of type omni.graph.BundleToUSDA
Outputs a represention of the content of a bundle as usda text
"""
import carb
import carb
import omni.graph.core as og
import omni.graph.core._omni_graph_core as _og
import omni.graph.tools.ogn as ogn
class OgnBundleToUSDADatabase(og.Database):
"""Helper class providing simplified access to data on nodes of type omni.graph.BundleToUSDA
Class Members:
node: Node being evaluated
Attribute Value Properties:
Inputs:
inputs.bundle
inputs.outputAncestors
inputs.outputValues
inputs.usePrimPath
inputs.usePrimType
inputs.usePrimvarMetadata
Outputs:
outputs.text
"""
# Imprint the generator and target ABI versions in the file for JIT generation
GENERATOR_VERSION = (1, 41, 3)
TARGET_VERSION = (2, 139, 12)
# This is an internal object that provides per-class storage of a per-node data dictionary
PER_NODE_DATA = {}
# This is an internal object that describes unchanging attributes in a generic way
# The values in this list are in no particular order, as a per-attribute tuple
# Name, Type, ExtendedTypeIndex, UiName, Description, Metadata,
# Is_Required, DefaultValue, Is_Deprecated, DeprecationMsg
# You should not need to access any of this data directly, use the defined database interfaces
INTERFACE = og.Database._get_interface([
('inputs:bundle', 'bundle', 0, None, 'The bundle to convert to usda text.', {}, True, None, False, ''),
('inputs:outputAncestors', 'bool', 0, None, 'If usePath is true and this is also true, ancestor "primPath" entries will be output.', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'false'}, True, False, False, ''),
('inputs:outputValues', 'bool', 0, None, 'If true, the values of attributes will be output, else values will be omitted.', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('inputs:usePrimPath', 'bool', 0, None, 'Use the attribute named "primPath" for the usda prim path.', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('inputs:usePrimType', 'bool', 0, None, 'Use the attribute named "primType" for the usda prim type name.', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('inputs:usePrimvarMetadata', 'bool', 0, None, 'Identify attributes representing metadata like the interpolation type for primvars, and include them as usda metadata in the output text.', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('outputs:text', 'token', 0, None, 'Output usda text representing the bundle contents.', {}, True, None, False, ''),
])
@classmethod
def _populate_role_data(cls):
"""Populate a role structure with the non-default roles on this node type"""
role_data = super()._populate_role_data()
role_data.inputs.bundle = og.AttributeRole.BUNDLE
return role_data
class ValuesForInputs(og.DynamicAttributeAccess):
LOCAL_PROPERTY_NAMES = { }
"""Helper class that creates natural hierarchical access to input attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
self.__bundles = og.BundleContainer(context, node, attributes, [], read_only=True, gpu_ptr_kinds={})
self._batchedReadAttributes = []
self._batchedReadValues = []
@property
def bundle(self) -> og.BundleContents:
"""Get the bundle wrapper class for the attribute inputs.bundle"""
return self.__bundles.bundle
@property
def outputAncestors(self):
data_view = og.AttributeValueHelper(self._attributes.outputAncestors)
return data_view.get()
@outputAncestors.setter
def outputAncestors(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.outputAncestors)
data_view = og.AttributeValueHelper(self._attributes.outputAncestors)
data_view.set(value)
@property
def outputValues(self):
data_view = og.AttributeValueHelper(self._attributes.outputValues)
return data_view.get()
@outputValues.setter
def outputValues(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.outputValues)
data_view = og.AttributeValueHelper(self._attributes.outputValues)
data_view.set(value)
@property
def usePrimPath(self):
data_view = og.AttributeValueHelper(self._attributes.usePrimPath)
return data_view.get()
@usePrimPath.setter
def usePrimPath(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.usePrimPath)
data_view = og.AttributeValueHelper(self._attributes.usePrimPath)
data_view.set(value)
@property
def usePrimType(self):
data_view = og.AttributeValueHelper(self._attributes.usePrimType)
return data_view.get()
@usePrimType.setter
def usePrimType(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.usePrimType)
data_view = og.AttributeValueHelper(self._attributes.usePrimType)
data_view.set(value)
@property
def usePrimvarMetadata(self):
data_view = og.AttributeValueHelper(self._attributes.usePrimvarMetadata)
return data_view.get()
@usePrimvarMetadata.setter
def usePrimvarMetadata(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.usePrimvarMetadata)
data_view = og.AttributeValueHelper(self._attributes.usePrimvarMetadata)
data_view.set(value)
def _prefetch(self):
readAttributes = self._batchedReadAttributes
newValues = _og._prefetch_input_attributes_data(readAttributes)
if len(readAttributes) == len(newValues):
self._batchedReadValues = newValues
class ValuesForOutputs(og.DynamicAttributeAccess):
LOCAL_PROPERTY_NAMES = { }
"""Helper class that creates natural hierarchical access to output attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
self._batchedWriteValues = { }
@property
def text(self):
data_view = og.AttributeValueHelper(self._attributes.text)
return data_view.get()
@text.setter
def text(self, value):
data_view = og.AttributeValueHelper(self._attributes.text)
data_view.set(value)
def _commit(self):
_og._commit_output_attributes_data(self._batchedWriteValues)
self._batchedWriteValues = { }
class ValuesForState(og.DynamicAttributeAccess):
"""Helper class that creates natural hierarchical access to state attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
def __init__(self, node):
super().__init__(node)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_INPUT)
self.inputs = OgnBundleToUSDADatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
self.outputs = OgnBundleToUSDADatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
self.state = OgnBundleToUSDADatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
|
omniverse-code/kit/exts/omni.graph.io/omni/graph/io/ogn/OgnTransformBundleDatabase.py | """Support for simplified access to data on nodes of type omni.graph.TransformBundle
Applies a transform to an input bundle, storing the result in an output bundle
"""
import carb
import numpy
import carb
import omni.graph.core as og
import omni.graph.core._omni_graph_core as _og
import omni.graph.tools.ogn as ogn
class OgnTransformBundleDatabase(og.Database):
"""Helper class providing simplified access to data on nodes of type omni.graph.TransformBundle
Class Members:
node: Node being evaluated
Attribute Value Properties:
Inputs:
inputs.input
inputs.transform
Outputs:
outputs.output
"""
# Imprint the generator and target ABI versions in the file for JIT generation
GENERATOR_VERSION = (1, 41, 3)
TARGET_VERSION = (2, 139, 12)
# This is an internal object that provides per-class storage of a per-node data dictionary
PER_NODE_DATA = {}
# This is an internal object that describes unchanging attributes in a generic way
# The values in this list are in no particular order, as a per-attribute tuple
# Name, Type, ExtendedTypeIndex, UiName, Description, Metadata,
# Is_Required, DefaultValue, Is_Deprecated, DeprecationMsg
# You should not need to access any of this data directly, use the defined database interfaces
INTERFACE = og.Database._get_interface([
('inputs:input', 'bundle', 0, None, 'Input bundle containing the attributes to be transformed.', {}, True, None, False, ''),
('inputs:transform', 'matrix4d', 0, None, 'The transform to apply to the bundle', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: '[[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0]]'}, True, [[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0]], False, ''),
('outputs:output', 'bundle', 0, None, 'Output bundle containing all of the transformed attributes', {}, True, None, False, ''),
])
@classmethod
def _populate_role_data(cls):
"""Populate a role structure with the non-default roles on this node type"""
role_data = super()._populate_role_data()
role_data.inputs.input = og.AttributeRole.BUNDLE
role_data.inputs.transform = og.AttributeRole.MATRIX
role_data.outputs.output = og.AttributeRole.BUNDLE
return role_data
class ValuesForInputs(og.DynamicAttributeAccess):
LOCAL_PROPERTY_NAMES = { }
"""Helper class that creates natural hierarchical access to input attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
self.__bundles = og.BundleContainer(context, node, attributes, [], read_only=True, gpu_ptr_kinds={})
self._batchedReadAttributes = []
self._batchedReadValues = []
@property
def input(self) -> og.BundleContents:
"""Get the bundle wrapper class for the attribute inputs.input"""
return self.__bundles.input
@property
def transform(self):
data_view = og.AttributeValueHelper(self._attributes.transform)
return data_view.get()
@transform.setter
def transform(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.transform)
data_view = og.AttributeValueHelper(self._attributes.transform)
data_view.set(value)
def _prefetch(self):
readAttributes = self._batchedReadAttributes
newValues = _og._prefetch_input_attributes_data(readAttributes)
if len(readAttributes) == len(newValues):
self._batchedReadValues = newValues
class ValuesForOutputs(og.DynamicAttributeAccess):
LOCAL_PROPERTY_NAMES = { }
"""Helper class that creates natural hierarchical access to output attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
self.__bundles = og.BundleContainer(context, node, attributes, [], read_only=False, gpu_ptr_kinds={})
self._batchedWriteValues = { }
@property
def output(self) -> og.BundleContents:
"""Get the bundle wrapper class for the attribute outputs.output"""
return self.__bundles.output
@output.setter
def output(self, bundle: og.BundleContents):
"""Overwrite the bundle attribute outputs.output with a new bundle"""
if not isinstance(bundle, og.BundleContents):
carb.log_error("Only bundle attributes can be assigned to another bundle attribute")
self.__bundles.output.bundle = bundle
def _commit(self):
_og._commit_output_attributes_data(self._batchedWriteValues)
self._batchedWriteValues = { }
class ValuesForState(og.DynamicAttributeAccess):
"""Helper class that creates natural hierarchical access to state attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
def __init__(self, node):
super().__init__(node)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_INPUT)
self.inputs = OgnTransformBundleDatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
self.outputs = OgnTransformBundleDatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
self.state = OgnTransformBundleDatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
|
omniverse-code/kit/exts/omni.graph.io/omni/graph/io/ogn/OgnImportUSDPrimDatabase.py | """Support for simplified access to data on nodes of type omni.graph.ImportUSDPrim
Imports data from a USD prim into attributes in an output bundle
"""
import carb
import numpy
import carb
import omni.graph.core as og
import omni.graph.core._omni_graph_core as _og
import omni.graph.tools.ogn as ogn
class OgnImportUSDPrimDatabase(og.Database):
"""Helper class providing simplified access to data on nodes of type omni.graph.ImportUSDPrim
Class Members:
node: Node being evaluated
Attribute Value Properties:
Inputs:
inputs.applySkelBinding
inputs.applyTransform
inputs.attrNamesToImport
inputs.computeBoundingBox
inputs.importAttributes
inputs.importPath
inputs.importPrimvarMetadata
inputs.importTime
inputs.importTransform
inputs.importType
inputs.inputAttrNames
inputs.keepPrimsSeparate
inputs.outputAttrNames
inputs.prim
inputs.renameAttributes
inputs.timeVaryingAttributes
inputs.usdTimecode
Outputs:
outputs.output
State:
state.prevApplySkelBinding
state.prevApplyTransform
state.prevAttrNamesToImport
state.prevComputeBoundingBox
state.prevImportAttributes
state.prevImportPath
state.prevImportPrimvarMetadata
state.prevImportTime
state.prevImportTransform
state.prevImportType
state.prevInputAttrNames
state.prevInvNodeTransform
state.prevKeepPrimsSeparate
state.prevOnlyImportSpecified
state.prevOutputAttrNames
state.prevPaths
state.prevRenameAttributes
state.prevTimeVaryingAttributes
state.prevTransforms
state.prevUsdTimecode
"""
# Imprint the generator and target ABI versions in the file for JIT generation
GENERATOR_VERSION = (1, 41, 3)
TARGET_VERSION = (2, 139, 12)
# This is an internal object that provides per-class storage of a per-node data dictionary
PER_NODE_DATA = {}
# This is an internal object that describes unchanging attributes in a generic way
# The values in this list are in no particular order, as a per-attribute tuple
# Name, Type, ExtendedTypeIndex, UiName, Description, Metadata,
# Is_Required, DefaultValue, Is_Deprecated, DeprecationMsg
# You should not need to access any of this data directly, use the defined database interfaces
INTERFACE = og.Database._get_interface([
('inputs:applySkelBinding', 'bool', 0, None, 'If the input USD prim is a Mesh, and has SkelBindingAPI schema applied, compute skinned points and normals.', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('inputs:applyTransform', 'bool', 0, None, 'If importAttributes is true, apply the transform necessary to transform any transforming attributes into the space of this node.', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'false'}, True, False, False, ''),
('inputs:attrNamesToImport', 'token', 0, 'Attributes To Import', 'Comma or space separated text, listing the names of attributes in the input data to be imported \nor empty to import all attributes.', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: '""'}, True, "", False, ''),
('inputs:computeBoundingBox', 'bool', 0, None, 'Compute and store local bounding box of a prim and its children.', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'false'}, True, False, False, ''),
('inputs:importAttributes', 'bool', 0, None, 'Import attribute data from the USD prim.', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('inputs:importPath', 'bool', 0, None, 'Record the input USD prim\'s path into the output bundle in an attribute named "primPath".', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('inputs:importPrimvarMetadata', 'bool', 0, None, 'Import metadata like the interpolation type for primvars, and store it as attributes in the output bundle.', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('inputs:importTime', 'bool', 0, None, 'Record the usdTimecode above into the output bundle in an attribute named "primTime".', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('inputs:importTransform', 'bool', 0, None, 'Record the transform required to take any attributes of the input USD prim \ninto the space of this node, i.e. the world transform of the input prim times the \ninverse world transform of this node, into the output bundle in an attribute named "transform".', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('inputs:importType', 'bool', 0, None, 'Deprecated, prim type is always imported', {ogn.MetadataKeys.HIDDEN: 'true', 'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('inputs:inputAttrNames', 'token', 0, 'Attributes To Rename', 'Comma or space separated text, listing the names of attributes in the input data to be renamed', {ogn.MetadataKeys.DEFAULT: '""'}, True, "", False, ''),
('inputs:keepPrimsSeparate', 'bool', 0, None, 'Prefix output attribute names with "prim" followed by a unique number and a colon, \nto keep the attributes for separate input prims separate. The prim paths will \nbe in the "primPaths" token array attribute.', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('inputs:outputAttrNames', 'token', 0, 'New Attribute Names', 'Comma or space separated text, listing the new names for the attributes listed in inputAttrNames', {ogn.MetadataKeys.DEFAULT: '""'}, True, "", False, ''),
('inputs:prim', 'bundle', 0, None, 'The USD prim from which to import data.', {}, False, None, False, ''),
('inputs:renameAttributes', 'bool', 0, None, 'If true, attributes listed in "inputAttrNames" will be imported to attributes with the names specified in "outputAttrNames".', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'false'}, True, False, False, ''),
('inputs:timeVaryingAttributes', 'bool', 0, None, 'Check whether the USD attributes are time-varying and if so, import their data at the time "usdTimecode".', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('inputs:usdTimecode', 'double', 0, None, 'The time at which to evaluate the transform of the USD prim.', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: '0'}, True, 0, False, ''),
('outputs:output', 'bundle', 0, None, 'Output bundle containing all of the imported data.', {}, True, None, False, ''),
('state:prevApplySkelBinding', 'bool', 0, None, 'Value of "applySkelBinding" input from previous run', {}, True, None, False, ''),
('state:prevApplyTransform', 'bool', 0, None, 'Value of "applyTransform" input from previous run', {}, True, None, False, ''),
('state:prevAttrNamesToImport', 'token', 0, None, 'Value of "attrNamesToImport" input from previous run', {}, True, None, False, ''),
('state:prevComputeBoundingBox', 'bool', 0, None, 'Value of "computeBoundingBox" input from previous run', {}, True, None, False, ''),
('state:prevImportAttributes', 'bool', 0, None, 'Value of "importAttributes" input from previous run', {}, True, None, False, ''),
('state:prevImportPath', 'bool', 0, None, 'Value of "importPath" input from previous run', {}, True, None, False, ''),
('state:prevImportPrimvarMetadata', 'bool', 0, None, 'Value of "importPrimvarMetadata" input from previous run', {}, True, None, False, ''),
('state:prevImportTime', 'bool', 0, None, 'Value of "importTime" input from previous run', {}, True, None, False, ''),
('state:prevImportTransform', 'bool', 0, None, 'Value of "importTransform" input from previous run', {}, True, None, False, ''),
('state:prevImportType', 'bool', 0, None, 'Value of "importType" input from previous run', {}, True, None, False, ''),
('state:prevInputAttrNames', 'token', 0, None, 'Value of "inputAttrNames" input from previous run', {}, True, None, False, ''),
('state:prevInvNodeTransform', 'matrix4d', 0, None, 'Inverse transform of the node prim from the previous run.', {}, True, None, False, ''),
('state:prevKeepPrimsSeparate', 'bool', 0, None, 'Value of "keepPrimsSeparate" input from previous run', {}, True, None, False, ''),
('state:prevOnlyImportSpecified', 'bool', 0, None, 'Value of "onlyImportSpecified" input from previous run', {}, True, None, False, ''),
('state:prevOutputAttrNames', 'token', 0, None, 'Value of "outputAttrNames" input from previous run', {}, True, None, False, ''),
('state:prevPaths', 'token[]', 0, None, 'Array of paths from the previous run.', {}, True, None, False, ''),
('state:prevRenameAttributes', 'bool', 0, None, 'Value of "renameAttributes" input from previous run', {}, True, None, False, ''),
('state:prevTimeVaryingAttributes', 'bool', 0, None, 'Value of "timeVaryingAttributes" input from previous run', {}, True, None, False, ''),
('state:prevTransforms', 'matrix4d[]', 0, None, 'Array of transforms from the previous run.', {}, True, None, False, ''),
('state:prevUsdTimecode', 'double', 0, None, 'Value of "usdTimecode" input from previous run', {}, True, None, False, ''),
])
@classmethod
def _populate_role_data(cls):
"""Populate a role structure with the non-default roles on this node type"""
role_data = super()._populate_role_data()
role_data.inputs.prim = og.AttributeRole.BUNDLE
role_data.outputs.output = og.AttributeRole.BUNDLE
role_data.state.prevInvNodeTransform = og.AttributeRole.MATRIX
role_data.state.prevTransforms = og.AttributeRole.MATRIX
return role_data
class ValuesForInputs(og.DynamicAttributeAccess):
LOCAL_PROPERTY_NAMES = { }
"""Helper class that creates natural hierarchical access to input attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
self.__bundles = og.BundleContainer(context, node, attributes, [], read_only=True, gpu_ptr_kinds={})
self._batchedReadAttributes = []
self._batchedReadValues = []
@property
def applySkelBinding(self):
data_view = og.AttributeValueHelper(self._attributes.applySkelBinding)
return data_view.get()
@applySkelBinding.setter
def applySkelBinding(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.applySkelBinding)
data_view = og.AttributeValueHelper(self._attributes.applySkelBinding)
data_view.set(value)
@property
def applyTransform(self):
data_view = og.AttributeValueHelper(self._attributes.applyTransform)
return data_view.get()
@applyTransform.setter
def applyTransform(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.applyTransform)
data_view = og.AttributeValueHelper(self._attributes.applyTransform)
data_view.set(value)
@property
def attrNamesToImport(self):
data_view = og.AttributeValueHelper(self._attributes.attrNamesToImport)
return data_view.get()
@attrNamesToImport.setter
def attrNamesToImport(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.attrNamesToImport)
data_view = og.AttributeValueHelper(self._attributes.attrNamesToImport)
data_view.set(value)
@property
def computeBoundingBox(self):
data_view = og.AttributeValueHelper(self._attributes.computeBoundingBox)
return data_view.get()
@computeBoundingBox.setter
def computeBoundingBox(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.computeBoundingBox)
data_view = og.AttributeValueHelper(self._attributes.computeBoundingBox)
data_view.set(value)
@property
def importAttributes(self):
data_view = og.AttributeValueHelper(self._attributes.importAttributes)
return data_view.get()
@importAttributes.setter
def importAttributes(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.importAttributes)
data_view = og.AttributeValueHelper(self._attributes.importAttributes)
data_view.set(value)
@property
def importPath(self):
data_view = og.AttributeValueHelper(self._attributes.importPath)
return data_view.get()
@importPath.setter
def importPath(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.importPath)
data_view = og.AttributeValueHelper(self._attributes.importPath)
data_view.set(value)
@property
def importPrimvarMetadata(self):
data_view = og.AttributeValueHelper(self._attributes.importPrimvarMetadata)
return data_view.get()
@importPrimvarMetadata.setter
def importPrimvarMetadata(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.importPrimvarMetadata)
data_view = og.AttributeValueHelper(self._attributes.importPrimvarMetadata)
data_view.set(value)
@property
def importTime(self):
data_view = og.AttributeValueHelper(self._attributes.importTime)
return data_view.get()
@importTime.setter
def importTime(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.importTime)
data_view = og.AttributeValueHelper(self._attributes.importTime)
data_view.set(value)
@property
def importTransform(self):
data_view = og.AttributeValueHelper(self._attributes.importTransform)
return data_view.get()
@importTransform.setter
def importTransform(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.importTransform)
data_view = og.AttributeValueHelper(self._attributes.importTransform)
data_view.set(value)
@property
def importType(self):
data_view = og.AttributeValueHelper(self._attributes.importType)
return data_view.get()
@importType.setter
def importType(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.importType)
data_view = og.AttributeValueHelper(self._attributes.importType)
data_view.set(value)
@property
def inputAttrNames(self):
data_view = og.AttributeValueHelper(self._attributes.inputAttrNames)
return data_view.get()
@inputAttrNames.setter
def inputAttrNames(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.inputAttrNames)
data_view = og.AttributeValueHelper(self._attributes.inputAttrNames)
data_view.set(value)
@property
def keepPrimsSeparate(self):
data_view = og.AttributeValueHelper(self._attributes.keepPrimsSeparate)
return data_view.get()
@keepPrimsSeparate.setter
def keepPrimsSeparate(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.keepPrimsSeparate)
data_view = og.AttributeValueHelper(self._attributes.keepPrimsSeparate)
data_view.set(value)
@property
def outputAttrNames(self):
data_view = og.AttributeValueHelper(self._attributes.outputAttrNames)
return data_view.get()
@outputAttrNames.setter
def outputAttrNames(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.outputAttrNames)
data_view = og.AttributeValueHelper(self._attributes.outputAttrNames)
data_view.set(value)
@property
def prim(self) -> og.BundleContents:
"""Get the bundle wrapper class for the attribute inputs.prim"""
return self.__bundles.prim
@property
def renameAttributes(self):
data_view = og.AttributeValueHelper(self._attributes.renameAttributes)
return data_view.get()
@renameAttributes.setter
def renameAttributes(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.renameAttributes)
data_view = og.AttributeValueHelper(self._attributes.renameAttributes)
data_view.set(value)
@property
def timeVaryingAttributes(self):
data_view = og.AttributeValueHelper(self._attributes.timeVaryingAttributes)
return data_view.get()
@timeVaryingAttributes.setter
def timeVaryingAttributes(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.timeVaryingAttributes)
data_view = og.AttributeValueHelper(self._attributes.timeVaryingAttributes)
data_view.set(value)
@property
def usdTimecode(self):
data_view = og.AttributeValueHelper(self._attributes.usdTimecode)
return data_view.get()
@usdTimecode.setter
def usdTimecode(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.usdTimecode)
data_view = og.AttributeValueHelper(self._attributes.usdTimecode)
data_view.set(value)
def _prefetch(self):
readAttributes = self._batchedReadAttributes
newValues = _og._prefetch_input_attributes_data(readAttributes)
if len(readAttributes) == len(newValues):
self._batchedReadValues = newValues
class ValuesForOutputs(og.DynamicAttributeAccess):
LOCAL_PROPERTY_NAMES = { }
"""Helper class that creates natural hierarchical access to output attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
self.__bundles = og.BundleContainer(context, node, attributes, [], read_only=False, gpu_ptr_kinds={})
self._batchedWriteValues = { }
@property
def output(self) -> og.BundleContents:
"""Get the bundle wrapper class for the attribute outputs.output"""
return self.__bundles.output
@output.setter
def output(self, bundle: og.BundleContents):
"""Overwrite the bundle attribute outputs.output with a new bundle"""
if not isinstance(bundle, og.BundleContents):
carb.log_error("Only bundle attributes can be assigned to another bundle attribute")
self.__bundles.output.bundle = bundle
def _commit(self):
_og._commit_output_attributes_data(self._batchedWriteValues)
self._batchedWriteValues = { }
class ValuesForState(og.DynamicAttributeAccess):
"""Helper class that creates natural hierarchical access to state attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
self.prevPaths_size = None
self.prevTransforms_size = None
@property
def prevApplySkelBinding(self):
data_view = og.AttributeValueHelper(self._attributes.prevApplySkelBinding)
return data_view.get()
@prevApplySkelBinding.setter
def prevApplySkelBinding(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevApplySkelBinding)
data_view.set(value)
@property
def prevApplyTransform(self):
data_view = og.AttributeValueHelper(self._attributes.prevApplyTransform)
return data_view.get()
@prevApplyTransform.setter
def prevApplyTransform(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevApplyTransform)
data_view.set(value)
@property
def prevAttrNamesToImport(self):
data_view = og.AttributeValueHelper(self._attributes.prevAttrNamesToImport)
return data_view.get()
@prevAttrNamesToImport.setter
def prevAttrNamesToImport(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevAttrNamesToImport)
data_view.set(value)
@property
def prevComputeBoundingBox(self):
data_view = og.AttributeValueHelper(self._attributes.prevComputeBoundingBox)
return data_view.get()
@prevComputeBoundingBox.setter
def prevComputeBoundingBox(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevComputeBoundingBox)
data_view.set(value)
@property
def prevImportAttributes(self):
data_view = og.AttributeValueHelper(self._attributes.prevImportAttributes)
return data_view.get()
@prevImportAttributes.setter
def prevImportAttributes(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevImportAttributes)
data_view.set(value)
@property
def prevImportPath(self):
data_view = og.AttributeValueHelper(self._attributes.prevImportPath)
return data_view.get()
@prevImportPath.setter
def prevImportPath(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevImportPath)
data_view.set(value)
@property
def prevImportPrimvarMetadata(self):
data_view = og.AttributeValueHelper(self._attributes.prevImportPrimvarMetadata)
return data_view.get()
@prevImportPrimvarMetadata.setter
def prevImportPrimvarMetadata(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevImportPrimvarMetadata)
data_view.set(value)
@property
def prevImportTime(self):
data_view = og.AttributeValueHelper(self._attributes.prevImportTime)
return data_view.get()
@prevImportTime.setter
def prevImportTime(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevImportTime)
data_view.set(value)
@property
def prevImportTransform(self):
data_view = og.AttributeValueHelper(self._attributes.prevImportTransform)
return data_view.get()
@prevImportTransform.setter
def prevImportTransform(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevImportTransform)
data_view.set(value)
@property
def prevImportType(self):
data_view = og.AttributeValueHelper(self._attributes.prevImportType)
return data_view.get()
@prevImportType.setter
def prevImportType(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevImportType)
data_view.set(value)
@property
def prevInputAttrNames(self):
data_view = og.AttributeValueHelper(self._attributes.prevInputAttrNames)
return data_view.get()
@prevInputAttrNames.setter
def prevInputAttrNames(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevInputAttrNames)
data_view.set(value)
@property
def prevInvNodeTransform(self):
data_view = og.AttributeValueHelper(self._attributes.prevInvNodeTransform)
return data_view.get()
@prevInvNodeTransform.setter
def prevInvNodeTransform(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevInvNodeTransform)
data_view.set(value)
@property
def prevKeepPrimsSeparate(self):
data_view = og.AttributeValueHelper(self._attributes.prevKeepPrimsSeparate)
return data_view.get()
@prevKeepPrimsSeparate.setter
def prevKeepPrimsSeparate(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevKeepPrimsSeparate)
data_view.set(value)
@property
def prevOnlyImportSpecified(self):
data_view = og.AttributeValueHelper(self._attributes.prevOnlyImportSpecified)
return data_view.get()
@prevOnlyImportSpecified.setter
def prevOnlyImportSpecified(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevOnlyImportSpecified)
data_view.set(value)
@property
def prevOutputAttrNames(self):
data_view = og.AttributeValueHelper(self._attributes.prevOutputAttrNames)
return data_view.get()
@prevOutputAttrNames.setter
def prevOutputAttrNames(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevOutputAttrNames)
data_view.set(value)
@property
def prevPaths(self):
data_view = og.AttributeValueHelper(self._attributes.prevPaths)
self.prevPaths_size = data_view.get_array_size()
return data_view.get()
@prevPaths.setter
def prevPaths(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevPaths)
data_view.set(value)
self.prevPaths_size = data_view.get_array_size()
@property
def prevRenameAttributes(self):
data_view = og.AttributeValueHelper(self._attributes.prevRenameAttributes)
return data_view.get()
@prevRenameAttributes.setter
def prevRenameAttributes(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevRenameAttributes)
data_view.set(value)
@property
def prevTimeVaryingAttributes(self):
data_view = og.AttributeValueHelper(self._attributes.prevTimeVaryingAttributes)
return data_view.get()
@prevTimeVaryingAttributes.setter
def prevTimeVaryingAttributes(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevTimeVaryingAttributes)
data_view.set(value)
@property
def prevTransforms(self):
data_view = og.AttributeValueHelper(self._attributes.prevTransforms)
self.prevTransforms_size = data_view.get_array_size()
return data_view.get()
@prevTransforms.setter
def prevTransforms(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevTransforms)
data_view.set(value)
self.prevTransforms_size = data_view.get_array_size()
@property
def prevUsdTimecode(self):
data_view = og.AttributeValueHelper(self._attributes.prevUsdTimecode)
return data_view.get()
@prevUsdTimecode.setter
def prevUsdTimecode(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevUsdTimecode)
data_view.set(value)
def __init__(self, node):
super().__init__(node)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_INPUT)
self.inputs = OgnImportUSDPrimDatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
self.outputs = OgnImportUSDPrimDatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
self.state = OgnImportUSDPrimDatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
|
omniverse-code/kit/exts/omni.graph.io/omni/graph/io/ogn/OgnExportUSDPrimDatabase.py | """Support for simplified access to data on nodes of type omni.graph.ExportUSDPrim
Exports data from an input bundle into a USD prim
"""
import carb
import numpy
import carb
import omni.graph.core as og
import omni.graph.core._omni_graph_core as _og
import omni.graph.tools.ogn as ogn
class OgnExportUSDPrimDatabase(og.Database):
"""Helper class providing simplified access to data on nodes of type omni.graph.ExportUSDPrim
Class Members:
node: Node being evaluated
Attribute Value Properties:
Inputs:
inputs.applyTransform
inputs.attrNamesToExport
inputs.bundle
inputs.excludedAttrNames
inputs.exportToRootLayer
inputs.inputAttrNames
inputs.layerName
inputs.onlyExportToExisting
inputs.outputAttrNames
inputs.primPathFromBundle
inputs.removeMissingAttrs
inputs.renameAttributes
inputs.timeVaryingAttributes
inputs.usdTimecode
Outputs:
outputs.prim
State:
state.prevApplyTransform
state.prevAttrNamesToExport
state.prevBundleDirtyID
state.prevExcludedAttrNames
state.prevExportToRootLayer
state.prevInputAttrNames
state.prevLayerName
state.prevOnlyExportToExisting
state.prevOutputAttrNames
state.prevPrimDirtyIDs
state.prevPrimPathFromBundle
state.prevRemoveMissingAttrs
state.prevRenameAttributes
state.prevTimeVaryingAttributes
state.prevUsdTimecode
Predefined Tokens:
tokens.primPath
tokens.primType
tokens.primTime
tokens.primCount
tokens.transform
"""
# Imprint the generator and target ABI versions in the file for JIT generation
GENERATOR_VERSION = (1, 41, 3)
TARGET_VERSION = (2, 139, 12)
# This is an internal object that provides per-class storage of a per-node data dictionary
PER_NODE_DATA = {}
# This is an internal object that describes unchanging attributes in a generic way
# The values in this list are in no particular order, as a per-attribute tuple
# Name, Type, ExtendedTypeIndex, UiName, Description, Metadata,
# Is_Required, DefaultValue, Is_Deprecated, DeprecationMsg
# You should not need to access any of this data directly, use the defined database interfaces
INTERFACE = og.Database._get_interface([
('inputs:applyTransform', 'bool', 0, None, 'If true, apply the transform necessary to transform any transforming attributes from the space of the node into the space of the specified prim.', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'false'}, True, False, False, ''),
('inputs:attrNamesToExport', 'token', 0, 'Attributes To Export', 'Comma or space separated text, listing the names of attributes in the input data to be exported \nor empty to import all attributes.', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: '""'}, True, "", False, ''),
('inputs:bundle', 'bundle', 0, None, 'The bundle from which data should be exported.', {}, True, None, False, ''),
('inputs:excludedAttrNames', 'token', 0, 'Attributes To Exclude', 'Attributes to be excluded from being exported', {ogn.MetadataKeys.DEFAULT: '""'}, True, "", False, ''),
('inputs:exportToRootLayer', 'bool', 0, 'Export to Root Layer', 'If true, prims are exported in the root layer, otherwise the layer specified by "layerName" is used.', {ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('inputs:inputAttrNames', 'token', 0, 'Attributes To Rename', 'Comma or space separated text, listing the names of attributes in the input data to be renamed', {ogn.MetadataKeys.DEFAULT: '""'}, True, "", False, ''),
('inputs:layerName', 'token', 0, 'Layer Name', 'Identifier of the layer to export to if "exportToRootLayer" is false, or leave this blank to export to the session layer', {ogn.MetadataKeys.DEFAULT: '""'}, True, "", False, ''),
('inputs:onlyExportToExisting', 'bool', 0, None, 'If true, only attributes that already exist in the specified output prim will have data transferred to them from the input bundle.', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'false'}, True, False, False, ''),
('inputs:outputAttrNames', 'token', 0, 'New Attribute Names', 'Comma or space separated text, listing the new names for the attributes listed in inputAttrNames', {ogn.MetadataKeys.DEFAULT: '""'}, True, "", False, ''),
('inputs:primPathFromBundle', 'bool', 0, None, 'When true, if there is a "primPath" token attribute inside the bundle, that will be the path of the USD prim to write to, \nelse the "outputs:prim" attribute below will be used for the USD prim path.', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'false'}, True, False, False, ''),
('inputs:removeMissingAttrs', 'bool', 0, 'Export to Root Layer', "If true, any attributes on the USD prim(s) being written to, that aren't in the input data, \nwill be removed from the USD prim(s).", {ogn.MetadataKeys.DEFAULT: 'false'}, True, False, False, ''),
('inputs:renameAttributes', 'bool', 0, None, 'If true, attributes listed in "inputAttrNames" will be exported to attributes with the names specified in "outputAttrNames". \nNote: to avoid potential issues with redundant attributes being created while typing, keep this off until after \nspecifying all input and output attribute names.', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'false'}, True, False, False, ''),
('inputs:timeVaryingAttributes', 'bool', 0, None, 'Check whether the USD attributes should be time-varying and if so, export their data to a time sample at the time "usdTimecode".', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'false'}, True, False, False, ''),
('inputs:usdTimecode', 'double', 0, None, 'The time at which to evaluate the transform of the USD prim for applyTransform.', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: '0'}, True, 0, False, ''),
('outputs:prim', 'bundle', 0, None, 'The USD prim(s) to which data should be exported if primPathFromBundle is false or if the bundle doesn\'t have a "primPath" token attribute. \nNote: this is really an input, since the node just receives the path to the prim. The node does not contain the prim.', {ogn.MetadataKeys.HIDDEN: 'true'}, False, None, False, ''),
('state:prevApplyTransform', 'bool', 0, None, 'Value of "applyTransform" input from previous run', {}, True, None, False, ''),
('state:prevAttrNamesToExport', 'token', 0, None, 'Value of "attrNamesToExport" input from previous run', {}, True, None, False, ''),
('state:prevBundleDirtyID', 'uint64', 0, None, 'Dirty ID of input bundle from previous run', {}, True, None, False, ''),
('state:prevExcludedAttrNames', 'token', 0, None, 'Value of "excludedAttrNames" input from previous run', {}, True, None, False, ''),
('state:prevExportToRootLayer', 'bool', 0, None, 'Value of "exportToRootLayer" input from previous run', {}, True, None, False, ''),
('state:prevInputAttrNames', 'token', 0, None, 'Value of "inputAttrNames" input from previous run', {}, True, None, False, ''),
('state:prevLayerName', 'token', 0, None, 'Value of "layerName" input from previous run', {}, True, None, False, ''),
('state:prevOnlyExportToExisting', 'bool', 0, None, 'Value of "onlyExportToExisting" input from previous run', {}, True, None, False, ''),
('state:prevOutputAttrNames', 'token', 0, None, 'Value of "outputAttrNames" input from previous run', {}, True, None, False, ''),
('state:prevPrimDirtyIDs', 'uint64[]', 0, None, 'Dirty IDs of input prims from previous run', {}, True, None, False, ''),
('state:prevPrimPathFromBundle', 'bool', 0, None, 'Value of "primPathFromBundle" input from previous run', {}, True, None, False, ''),
('state:prevRemoveMissingAttrs', 'bool', 0, None, 'Value of "removeMissingAttrs" input from previous run', {}, True, None, False, ''),
('state:prevRenameAttributes', 'bool', 0, None, 'Value of "renameAttributes" input from previous run', {}, True, None, False, ''),
('state:prevTimeVaryingAttributes', 'bool', 0, None, 'Value of "timeVaryingAttributes" input from previous run', {}, True, None, False, ''),
('state:prevUsdTimecode', 'double', 0, None, 'Value of "usdTimecode" input from previous run', {}, True, None, False, ''),
])
class tokens:
primPath = "primPath"
primType = "primType"
primTime = "primTime"
primCount = "primCount"
transform = "transform"
@classmethod
def _populate_role_data(cls):
"""Populate a role structure with the non-default roles on this node type"""
role_data = super()._populate_role_data()
role_data.inputs.bundle = og.AttributeRole.BUNDLE
role_data.outputs.prim = og.AttributeRole.BUNDLE
return role_data
class ValuesForInputs(og.DynamicAttributeAccess):
LOCAL_PROPERTY_NAMES = { }
"""Helper class that creates natural hierarchical access to input attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
self.__bundles = og.BundleContainer(context, node, attributes, [], read_only=True, gpu_ptr_kinds={})
self._batchedReadAttributes = []
self._batchedReadValues = []
@property
def applyTransform(self):
data_view = og.AttributeValueHelper(self._attributes.applyTransform)
return data_view.get()
@applyTransform.setter
def applyTransform(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.applyTransform)
data_view = og.AttributeValueHelper(self._attributes.applyTransform)
data_view.set(value)
@property
def attrNamesToExport(self):
data_view = og.AttributeValueHelper(self._attributes.attrNamesToExport)
return data_view.get()
@attrNamesToExport.setter
def attrNamesToExport(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.attrNamesToExport)
data_view = og.AttributeValueHelper(self._attributes.attrNamesToExport)
data_view.set(value)
@property
def bundle(self) -> og.BundleContents:
"""Get the bundle wrapper class for the attribute inputs.bundle"""
return self.__bundles.bundle
@property
def excludedAttrNames(self):
data_view = og.AttributeValueHelper(self._attributes.excludedAttrNames)
return data_view.get()
@excludedAttrNames.setter
def excludedAttrNames(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.excludedAttrNames)
data_view = og.AttributeValueHelper(self._attributes.excludedAttrNames)
data_view.set(value)
@property
def exportToRootLayer(self):
data_view = og.AttributeValueHelper(self._attributes.exportToRootLayer)
return data_view.get()
@exportToRootLayer.setter
def exportToRootLayer(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.exportToRootLayer)
data_view = og.AttributeValueHelper(self._attributes.exportToRootLayer)
data_view.set(value)
@property
def inputAttrNames(self):
data_view = og.AttributeValueHelper(self._attributes.inputAttrNames)
return data_view.get()
@inputAttrNames.setter
def inputAttrNames(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.inputAttrNames)
data_view = og.AttributeValueHelper(self._attributes.inputAttrNames)
data_view.set(value)
@property
def layerName(self):
data_view = og.AttributeValueHelper(self._attributes.layerName)
return data_view.get()
@layerName.setter
def layerName(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.layerName)
data_view = og.AttributeValueHelper(self._attributes.layerName)
data_view.set(value)
@property
def onlyExportToExisting(self):
data_view = og.AttributeValueHelper(self._attributes.onlyExportToExisting)
return data_view.get()
@onlyExportToExisting.setter
def onlyExportToExisting(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.onlyExportToExisting)
data_view = og.AttributeValueHelper(self._attributes.onlyExportToExisting)
data_view.set(value)
@property
def outputAttrNames(self):
data_view = og.AttributeValueHelper(self._attributes.outputAttrNames)
return data_view.get()
@outputAttrNames.setter
def outputAttrNames(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.outputAttrNames)
data_view = og.AttributeValueHelper(self._attributes.outputAttrNames)
data_view.set(value)
@property
def primPathFromBundle(self):
data_view = og.AttributeValueHelper(self._attributes.primPathFromBundle)
return data_view.get()
@primPathFromBundle.setter
def primPathFromBundle(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.primPathFromBundle)
data_view = og.AttributeValueHelper(self._attributes.primPathFromBundle)
data_view.set(value)
@property
def removeMissingAttrs(self):
data_view = og.AttributeValueHelper(self._attributes.removeMissingAttrs)
return data_view.get()
@removeMissingAttrs.setter
def removeMissingAttrs(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.removeMissingAttrs)
data_view = og.AttributeValueHelper(self._attributes.removeMissingAttrs)
data_view.set(value)
@property
def renameAttributes(self):
data_view = og.AttributeValueHelper(self._attributes.renameAttributes)
return data_view.get()
@renameAttributes.setter
def renameAttributes(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.renameAttributes)
data_view = og.AttributeValueHelper(self._attributes.renameAttributes)
data_view.set(value)
@property
def timeVaryingAttributes(self):
data_view = og.AttributeValueHelper(self._attributes.timeVaryingAttributes)
return data_view.get()
@timeVaryingAttributes.setter
def timeVaryingAttributes(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.timeVaryingAttributes)
data_view = og.AttributeValueHelper(self._attributes.timeVaryingAttributes)
data_view.set(value)
@property
def usdTimecode(self):
data_view = og.AttributeValueHelper(self._attributes.usdTimecode)
return data_view.get()
@usdTimecode.setter
def usdTimecode(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.usdTimecode)
data_view = og.AttributeValueHelper(self._attributes.usdTimecode)
data_view.set(value)
def _prefetch(self):
readAttributes = self._batchedReadAttributes
newValues = _og._prefetch_input_attributes_data(readAttributes)
if len(readAttributes) == len(newValues):
self._batchedReadValues = newValues
class ValuesForOutputs(og.DynamicAttributeAccess):
LOCAL_PROPERTY_NAMES = { }
"""Helper class that creates natural hierarchical access to output attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
self.__bundles = og.BundleContainer(context, node, attributes, [], read_only=False, gpu_ptr_kinds={})
self._batchedWriteValues = { }
@property
def prim(self) -> og.BundleContents:
"""Get the bundle wrapper class for the attribute outputs.prim"""
return self.__bundles.prim
@prim.setter
def prim(self, bundle: og.BundleContents):
"""Overwrite the bundle attribute outputs.prim with a new bundle"""
if not isinstance(bundle, og.BundleContents):
carb.log_error("Only bundle attributes can be assigned to another bundle attribute")
self.__bundles.prim.bundle = bundle
def _commit(self):
_og._commit_output_attributes_data(self._batchedWriteValues)
self._batchedWriteValues = { }
class ValuesForState(og.DynamicAttributeAccess):
"""Helper class that creates natural hierarchical access to state attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
self.prevPrimDirtyIDs_size = None
@property
def prevApplyTransform(self):
data_view = og.AttributeValueHelper(self._attributes.prevApplyTransform)
return data_view.get()
@prevApplyTransform.setter
def prevApplyTransform(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevApplyTransform)
data_view.set(value)
@property
def prevAttrNamesToExport(self):
data_view = og.AttributeValueHelper(self._attributes.prevAttrNamesToExport)
return data_view.get()
@prevAttrNamesToExport.setter
def prevAttrNamesToExport(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevAttrNamesToExport)
data_view.set(value)
@property
def prevBundleDirtyID(self):
data_view = og.AttributeValueHelper(self._attributes.prevBundleDirtyID)
return data_view.get()
@prevBundleDirtyID.setter
def prevBundleDirtyID(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevBundleDirtyID)
data_view.set(value)
@property
def prevExcludedAttrNames(self):
data_view = og.AttributeValueHelper(self._attributes.prevExcludedAttrNames)
return data_view.get()
@prevExcludedAttrNames.setter
def prevExcludedAttrNames(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevExcludedAttrNames)
data_view.set(value)
@property
def prevExportToRootLayer(self):
data_view = og.AttributeValueHelper(self._attributes.prevExportToRootLayer)
return data_view.get()
@prevExportToRootLayer.setter
def prevExportToRootLayer(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevExportToRootLayer)
data_view.set(value)
@property
def prevInputAttrNames(self):
data_view = og.AttributeValueHelper(self._attributes.prevInputAttrNames)
return data_view.get()
@prevInputAttrNames.setter
def prevInputAttrNames(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevInputAttrNames)
data_view.set(value)
@property
def prevLayerName(self):
data_view = og.AttributeValueHelper(self._attributes.prevLayerName)
return data_view.get()
@prevLayerName.setter
def prevLayerName(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevLayerName)
data_view.set(value)
@property
def prevOnlyExportToExisting(self):
data_view = og.AttributeValueHelper(self._attributes.prevOnlyExportToExisting)
return data_view.get()
@prevOnlyExportToExisting.setter
def prevOnlyExportToExisting(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevOnlyExportToExisting)
data_view.set(value)
@property
def prevOutputAttrNames(self):
data_view = og.AttributeValueHelper(self._attributes.prevOutputAttrNames)
return data_view.get()
@prevOutputAttrNames.setter
def prevOutputAttrNames(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevOutputAttrNames)
data_view.set(value)
@property
def prevPrimDirtyIDs(self):
data_view = og.AttributeValueHelper(self._attributes.prevPrimDirtyIDs)
self.prevPrimDirtyIDs_size = data_view.get_array_size()
return data_view.get()
@prevPrimDirtyIDs.setter
def prevPrimDirtyIDs(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevPrimDirtyIDs)
data_view.set(value)
self.prevPrimDirtyIDs_size = data_view.get_array_size()
@property
def prevPrimPathFromBundle(self):
data_view = og.AttributeValueHelper(self._attributes.prevPrimPathFromBundle)
return data_view.get()
@prevPrimPathFromBundle.setter
def prevPrimPathFromBundle(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevPrimPathFromBundle)
data_view.set(value)
@property
def prevRemoveMissingAttrs(self):
data_view = og.AttributeValueHelper(self._attributes.prevRemoveMissingAttrs)
return data_view.get()
@prevRemoveMissingAttrs.setter
def prevRemoveMissingAttrs(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevRemoveMissingAttrs)
data_view.set(value)
@property
def prevRenameAttributes(self):
data_view = og.AttributeValueHelper(self._attributes.prevRenameAttributes)
return data_view.get()
@prevRenameAttributes.setter
def prevRenameAttributes(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevRenameAttributes)
data_view.set(value)
@property
def prevTimeVaryingAttributes(self):
data_view = og.AttributeValueHelper(self._attributes.prevTimeVaryingAttributes)
return data_view.get()
@prevTimeVaryingAttributes.setter
def prevTimeVaryingAttributes(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevTimeVaryingAttributes)
data_view.set(value)
@property
def prevUsdTimecode(self):
data_view = og.AttributeValueHelper(self._attributes.prevUsdTimecode)
return data_view.get()
@prevUsdTimecode.setter
def prevUsdTimecode(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevUsdTimecode)
data_view.set(value)
def __init__(self, node):
super().__init__(node)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_INPUT)
self.inputs = OgnExportUSDPrimDatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
self.outputs = OgnExportUSDPrimDatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
self.state = OgnExportUSDPrimDatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
|
omniverse-code/kit/exts/omni.graph.io/omni/graph/io/ogn/tests/TestOgnImportUSDPrim.py | import os
import omni.kit.test
import omni.graph.core as og
import omni.graph.core.tests as ogts
from omni.graph.core.tests.omnigraph_test_utils import _TestGraphAndNode
from omni.graph.core.tests.omnigraph_test_utils import _test_clear_scene
from omni.graph.core.tests.omnigraph_test_utils import _test_setup_scene
from omni.graph.core.tests.omnigraph_test_utils import _test_verify_scene
class TestOgn(ogts.OmniGraphTestCase):
async def test_data_access(self):
from omni.graph.io.ogn.OgnImportUSDPrimDatabase import OgnImportUSDPrimDatabase
test_file_name = "OgnImportUSDPrimTemplate.usda"
usd_path = os.path.join(os.path.dirname(__file__), "usd", test_file_name)
if not os.path.exists(usd_path):
self.assertTrue(False, f"{usd_path} not found for loading test")
(result, error) = await ogts.load_test_file(usd_path)
self.assertTrue(result, f'{error} on {usd_path}')
test_node = og.Controller.node("/TestGraph/Template_omni_graph_ImportUSDPrim")
database = OgnImportUSDPrimDatabase(test_node)
self.assertTrue(test_node.is_valid())
node_type_name = test_node.get_type_name()
self.assertEqual(og.GraphRegistry().get_node_type_version(node_type_name), 1)
def _attr_error(attribute: og.Attribute, usd_test: bool) -> str:
test_type = "USD Load" if usd_test else "Database Access"
return f"{node_type_name} {test_type} Test - {attribute.get_name()} value error"
self.assertTrue(test_node.get_attribute_exists("inputs:applySkelBinding"))
attribute = test_node.get_attribute("inputs:applySkelBinding")
db_value = database.inputs.applySkelBinding
expected_value = True
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:applyTransform"))
attribute = test_node.get_attribute("inputs:applyTransform")
db_value = database.inputs.applyTransform
expected_value = False
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:attrNamesToImport"))
attribute = test_node.get_attribute("inputs:attrNamesToImport")
db_value = database.inputs.attrNamesToImport
expected_value = ""
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:computeBoundingBox"))
attribute = test_node.get_attribute("inputs:computeBoundingBox")
db_value = database.inputs.computeBoundingBox
expected_value = False
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:importAttributes"))
attribute = test_node.get_attribute("inputs:importAttributes")
db_value = database.inputs.importAttributes
expected_value = True
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:importPath"))
attribute = test_node.get_attribute("inputs:importPath")
db_value = database.inputs.importPath
expected_value = True
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:importPrimvarMetadata"))
attribute = test_node.get_attribute("inputs:importPrimvarMetadata")
db_value = database.inputs.importPrimvarMetadata
expected_value = True
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:importTime"))
attribute = test_node.get_attribute("inputs:importTime")
db_value = database.inputs.importTime
expected_value = True
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:importTransform"))
attribute = test_node.get_attribute("inputs:importTransform")
db_value = database.inputs.importTransform
expected_value = True
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:importType"))
attribute = test_node.get_attribute("inputs:importType")
db_value = database.inputs.importType
expected_value = True
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:inputAttrNames"))
attribute = test_node.get_attribute("inputs:inputAttrNames")
db_value = database.inputs.inputAttrNames
expected_value = ""
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:keepPrimsSeparate"))
attribute = test_node.get_attribute("inputs:keepPrimsSeparate")
db_value = database.inputs.keepPrimsSeparate
expected_value = True
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:outputAttrNames"))
attribute = test_node.get_attribute("inputs:outputAttrNames")
db_value = database.inputs.outputAttrNames
expected_value = ""
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:renameAttributes"))
attribute = test_node.get_attribute("inputs:renameAttributes")
db_value = database.inputs.renameAttributes
expected_value = False
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:timeVaryingAttributes"))
attribute = test_node.get_attribute("inputs:timeVaryingAttributes")
db_value = database.inputs.timeVaryingAttributes
expected_value = True
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:usdTimecode"))
attribute = test_node.get_attribute("inputs:usdTimecode")
db_value = database.inputs.usdTimecode
expected_value = 0
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("outputs_output"))
attribute = test_node.get_attribute("outputs_output")
db_value = database.outputs.output
self.assertTrue(test_node.get_attribute_exists("state:prevApplySkelBinding"))
attribute = test_node.get_attribute("state:prevApplySkelBinding")
db_value = database.state.prevApplySkelBinding
self.assertTrue(test_node.get_attribute_exists("state:prevApplyTransform"))
attribute = test_node.get_attribute("state:prevApplyTransform")
db_value = database.state.prevApplyTransform
self.assertTrue(test_node.get_attribute_exists("state:prevAttrNamesToImport"))
attribute = test_node.get_attribute("state:prevAttrNamesToImport")
db_value = database.state.prevAttrNamesToImport
self.assertTrue(test_node.get_attribute_exists("state:prevComputeBoundingBox"))
attribute = test_node.get_attribute("state:prevComputeBoundingBox")
db_value = database.state.prevComputeBoundingBox
self.assertTrue(test_node.get_attribute_exists("state:prevImportAttributes"))
attribute = test_node.get_attribute("state:prevImportAttributes")
db_value = database.state.prevImportAttributes
self.assertTrue(test_node.get_attribute_exists("state:prevImportPath"))
attribute = test_node.get_attribute("state:prevImportPath")
db_value = database.state.prevImportPath
self.assertTrue(test_node.get_attribute_exists("state:prevImportPrimvarMetadata"))
attribute = test_node.get_attribute("state:prevImportPrimvarMetadata")
db_value = database.state.prevImportPrimvarMetadata
self.assertTrue(test_node.get_attribute_exists("state:prevImportTime"))
attribute = test_node.get_attribute("state:prevImportTime")
db_value = database.state.prevImportTime
self.assertTrue(test_node.get_attribute_exists("state:prevImportTransform"))
attribute = test_node.get_attribute("state:prevImportTransform")
db_value = database.state.prevImportTransform
self.assertTrue(test_node.get_attribute_exists("state:prevImportType"))
attribute = test_node.get_attribute("state:prevImportType")
db_value = database.state.prevImportType
self.assertTrue(test_node.get_attribute_exists("state:prevInputAttrNames"))
attribute = test_node.get_attribute("state:prevInputAttrNames")
db_value = database.state.prevInputAttrNames
self.assertTrue(test_node.get_attribute_exists("state:prevInvNodeTransform"))
attribute = test_node.get_attribute("state:prevInvNodeTransform")
db_value = database.state.prevInvNodeTransform
self.assertTrue(test_node.get_attribute_exists("state:prevKeepPrimsSeparate"))
attribute = test_node.get_attribute("state:prevKeepPrimsSeparate")
db_value = database.state.prevKeepPrimsSeparate
self.assertTrue(test_node.get_attribute_exists("state:prevOnlyImportSpecified"))
attribute = test_node.get_attribute("state:prevOnlyImportSpecified")
db_value = database.state.prevOnlyImportSpecified
self.assertTrue(test_node.get_attribute_exists("state:prevOutputAttrNames"))
attribute = test_node.get_attribute("state:prevOutputAttrNames")
db_value = database.state.prevOutputAttrNames
self.assertTrue(test_node.get_attribute_exists("state:prevPaths"))
attribute = test_node.get_attribute("state:prevPaths")
db_value = database.state.prevPaths
self.assertTrue(test_node.get_attribute_exists("state:prevRenameAttributes"))
attribute = test_node.get_attribute("state:prevRenameAttributes")
db_value = database.state.prevRenameAttributes
self.assertTrue(test_node.get_attribute_exists("state:prevTimeVaryingAttributes"))
attribute = test_node.get_attribute("state:prevTimeVaryingAttributes")
db_value = database.state.prevTimeVaryingAttributes
self.assertTrue(test_node.get_attribute_exists("state:prevTransforms"))
attribute = test_node.get_attribute("state:prevTransforms")
db_value = database.state.prevTransforms
self.assertTrue(test_node.get_attribute_exists("state:prevUsdTimecode"))
attribute = test_node.get_attribute("state:prevUsdTimecode")
db_value = database.state.prevUsdTimecode
|
omniverse-code/kit/exts/omni.graph.io/omni/graph/io/ogn/tests/__init__.py | """====== GENERATED BY omni.graph.tools - DO NOT EDIT ======"""
import omni.graph.tools._internal as ogi
ogi.import_tests_in_directory(__file__, __name__)
|
omniverse-code/kit/exts/omni.graph.io/omni/graph/io/ogn/tests/TestOgnBundleToUSDA.py | import os
import omni.kit.test
import omni.graph.core as og
import omni.graph.core.tests as ogts
from omni.graph.core.tests.omnigraph_test_utils import _TestGraphAndNode
from omni.graph.core.tests.omnigraph_test_utils import _test_clear_scene
from omni.graph.core.tests.omnigraph_test_utils import _test_setup_scene
from omni.graph.core.tests.omnigraph_test_utils import _test_verify_scene
class TestOgn(ogts.OmniGraphTestCase):
async def test_data_access(self):
from omni.graph.io.ogn.OgnBundleToUSDADatabase import OgnBundleToUSDADatabase
test_file_name = "OgnBundleToUSDATemplate.usda"
usd_path = os.path.join(os.path.dirname(__file__), "usd", test_file_name)
if not os.path.exists(usd_path):
self.assertTrue(False, f"{usd_path} not found for loading test")
(result, error) = await ogts.load_test_file(usd_path)
self.assertTrue(result, f'{error} on {usd_path}')
test_node = og.Controller.node("/TestGraph/Template_omni_graph_BundleToUSDA")
database = OgnBundleToUSDADatabase(test_node)
self.assertTrue(test_node.is_valid())
node_type_name = test_node.get_type_name()
self.assertEqual(og.GraphRegistry().get_node_type_version(node_type_name), 1)
def _attr_error(attribute: og.Attribute, usd_test: bool) -> str:
test_type = "USD Load" if usd_test else "Database Access"
return f"{node_type_name} {test_type} Test - {attribute.get_name()} value error"
self.assertTrue(test_node.get_attribute_exists("inputs:bundle"))
attribute = test_node.get_attribute("inputs:bundle")
db_value = database.inputs.bundle
self.assertTrue(test_node.get_attribute_exists("inputs:outputAncestors"))
attribute = test_node.get_attribute("inputs:outputAncestors")
db_value = database.inputs.outputAncestors
expected_value = False
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:outputValues"))
attribute = test_node.get_attribute("inputs:outputValues")
db_value = database.inputs.outputValues
expected_value = True
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:usePrimPath"))
attribute = test_node.get_attribute("inputs:usePrimPath")
db_value = database.inputs.usePrimPath
expected_value = True
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:usePrimType"))
attribute = test_node.get_attribute("inputs:usePrimType")
db_value = database.inputs.usePrimType
expected_value = True
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:usePrimvarMetadata"))
attribute = test_node.get_attribute("inputs:usePrimvarMetadata")
db_value = database.inputs.usePrimvarMetadata
expected_value = True
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("outputs:text"))
attribute = test_node.get_attribute("outputs:text")
db_value = database.outputs.text
|
omniverse-code/kit/exts/omni.graph.io/omni/graph/io/ogn/tests/TestOgnTransformBundle.py | import os
import omni.kit.test
import omni.graph.core as og
import omni.graph.core.tests as ogts
from omni.graph.core.tests.omnigraph_test_utils import _TestGraphAndNode
from omni.graph.core.tests.omnigraph_test_utils import _test_clear_scene
from omni.graph.core.tests.omnigraph_test_utils import _test_setup_scene
from omni.graph.core.tests.omnigraph_test_utils import _test_verify_scene
class TestOgn(ogts.OmniGraphTestCase):
async def test_data_access(self):
from omni.graph.io.ogn.OgnTransformBundleDatabase import OgnTransformBundleDatabase
test_file_name = "OgnTransformBundleTemplate.usda"
usd_path = os.path.join(os.path.dirname(__file__), "usd", test_file_name)
if not os.path.exists(usd_path):
self.assertTrue(False, f"{usd_path} not found for loading test")
(result, error) = await ogts.load_test_file(usd_path)
self.assertTrue(result, f'{error} on {usd_path}')
test_node = og.Controller.node("/TestGraph/Template_omni_graph_TransformBundle")
database = OgnTransformBundleDatabase(test_node)
self.assertTrue(test_node.is_valid())
node_type_name = test_node.get_type_name()
self.assertEqual(og.GraphRegistry().get_node_type_version(node_type_name), 1)
def _attr_error(attribute: og.Attribute, usd_test: bool) -> str:
test_type = "USD Load" if usd_test else "Database Access"
return f"{node_type_name} {test_type} Test - {attribute.get_name()} value error"
self.assertTrue(test_node.get_attribute_exists("inputs:input"))
attribute = test_node.get_attribute("inputs:input")
db_value = database.inputs.input
self.assertTrue(test_node.get_attribute_exists("inputs:transform"))
attribute = test_node.get_attribute("inputs:transform")
db_value = database.inputs.transform
expected_value = [[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0]]
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("outputs_output"))
attribute = test_node.get_attribute("outputs_output")
db_value = database.outputs.output
|
omniverse-code/kit/exts/omni.graph.io/omni/graph/io/ogn/tests/TestOgnExportUSDPrim.py | import os
import omni.kit.test
import omni.graph.core as og
import omni.graph.core.tests as ogts
from omni.graph.core.tests.omnigraph_test_utils import _TestGraphAndNode
from omni.graph.core.tests.omnigraph_test_utils import _test_clear_scene
from omni.graph.core.tests.omnigraph_test_utils import _test_setup_scene
from omni.graph.core.tests.omnigraph_test_utils import _test_verify_scene
class TestOgn(ogts.OmniGraphTestCase):
async def test_data_access(self):
from omni.graph.io.ogn.OgnExportUSDPrimDatabase import OgnExportUSDPrimDatabase
test_file_name = "OgnExportUSDPrimTemplate.usda"
usd_path = os.path.join(os.path.dirname(__file__), "usd", test_file_name)
if not os.path.exists(usd_path):
self.assertTrue(False, f"{usd_path} not found for loading test")
(result, error) = await ogts.load_test_file(usd_path)
self.assertTrue(result, f'{error} on {usd_path}')
test_node = og.Controller.node("/TestGraph/Template_omni_graph_ExportUSDPrim")
database = OgnExportUSDPrimDatabase(test_node)
self.assertTrue(test_node.is_valid())
node_type_name = test_node.get_type_name()
self.assertEqual(og.GraphRegistry().get_node_type_version(node_type_name), 1)
def _attr_error(attribute: og.Attribute, usd_test: bool) -> str:
test_type = "USD Load" if usd_test else "Database Access"
return f"{node_type_name} {test_type} Test - {attribute.get_name()} value error"
self.assertTrue(test_node.get_attribute_exists("inputs:applyTransform"))
attribute = test_node.get_attribute("inputs:applyTransform")
db_value = database.inputs.applyTransform
expected_value = False
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:attrNamesToExport"))
attribute = test_node.get_attribute("inputs:attrNamesToExport")
db_value = database.inputs.attrNamesToExport
expected_value = ""
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:bundle"))
attribute = test_node.get_attribute("inputs:bundle")
db_value = database.inputs.bundle
self.assertTrue(test_node.get_attribute_exists("inputs:excludedAttrNames"))
attribute = test_node.get_attribute("inputs:excludedAttrNames")
db_value = database.inputs.excludedAttrNames
expected_value = ""
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:exportToRootLayer"))
attribute = test_node.get_attribute("inputs:exportToRootLayer")
db_value = database.inputs.exportToRootLayer
expected_value = True
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:inputAttrNames"))
attribute = test_node.get_attribute("inputs:inputAttrNames")
db_value = database.inputs.inputAttrNames
expected_value = ""
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:layerName"))
attribute = test_node.get_attribute("inputs:layerName")
db_value = database.inputs.layerName
expected_value = ""
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:onlyExportToExisting"))
attribute = test_node.get_attribute("inputs:onlyExportToExisting")
db_value = database.inputs.onlyExportToExisting
expected_value = False
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:outputAttrNames"))
attribute = test_node.get_attribute("inputs:outputAttrNames")
db_value = database.inputs.outputAttrNames
expected_value = ""
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:primPathFromBundle"))
attribute = test_node.get_attribute("inputs:primPathFromBundle")
db_value = database.inputs.primPathFromBundle
expected_value = False
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:removeMissingAttrs"))
attribute = test_node.get_attribute("inputs:removeMissingAttrs")
db_value = database.inputs.removeMissingAttrs
expected_value = False
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:renameAttributes"))
attribute = test_node.get_attribute("inputs:renameAttributes")
db_value = database.inputs.renameAttributes
expected_value = False
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:timeVaryingAttributes"))
attribute = test_node.get_attribute("inputs:timeVaryingAttributes")
db_value = database.inputs.timeVaryingAttributes
expected_value = False
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:usdTimecode"))
attribute = test_node.get_attribute("inputs:usdTimecode")
db_value = database.inputs.usdTimecode
expected_value = 0
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("state:prevApplyTransform"))
attribute = test_node.get_attribute("state:prevApplyTransform")
db_value = database.state.prevApplyTransform
self.assertTrue(test_node.get_attribute_exists("state:prevAttrNamesToExport"))
attribute = test_node.get_attribute("state:prevAttrNamesToExport")
db_value = database.state.prevAttrNamesToExport
self.assertTrue(test_node.get_attribute_exists("state:prevBundleDirtyID"))
attribute = test_node.get_attribute("state:prevBundleDirtyID")
db_value = database.state.prevBundleDirtyID
self.assertTrue(test_node.get_attribute_exists("state:prevExcludedAttrNames"))
attribute = test_node.get_attribute("state:prevExcludedAttrNames")
db_value = database.state.prevExcludedAttrNames
self.assertTrue(test_node.get_attribute_exists("state:prevExportToRootLayer"))
attribute = test_node.get_attribute("state:prevExportToRootLayer")
db_value = database.state.prevExportToRootLayer
self.assertTrue(test_node.get_attribute_exists("state:prevInputAttrNames"))
attribute = test_node.get_attribute("state:prevInputAttrNames")
db_value = database.state.prevInputAttrNames
self.assertTrue(test_node.get_attribute_exists("state:prevLayerName"))
attribute = test_node.get_attribute("state:prevLayerName")
db_value = database.state.prevLayerName
self.assertTrue(test_node.get_attribute_exists("state:prevOnlyExportToExisting"))
attribute = test_node.get_attribute("state:prevOnlyExportToExisting")
db_value = database.state.prevOnlyExportToExisting
self.assertTrue(test_node.get_attribute_exists("state:prevOutputAttrNames"))
attribute = test_node.get_attribute("state:prevOutputAttrNames")
db_value = database.state.prevOutputAttrNames
self.assertTrue(test_node.get_attribute_exists("state:prevPrimDirtyIDs"))
attribute = test_node.get_attribute("state:prevPrimDirtyIDs")
db_value = database.state.prevPrimDirtyIDs
self.assertTrue(test_node.get_attribute_exists("state:prevPrimPathFromBundle"))
attribute = test_node.get_attribute("state:prevPrimPathFromBundle")
db_value = database.state.prevPrimPathFromBundle
self.assertTrue(test_node.get_attribute_exists("state:prevRemoveMissingAttrs"))
attribute = test_node.get_attribute("state:prevRemoveMissingAttrs")
db_value = database.state.prevRemoveMissingAttrs
self.assertTrue(test_node.get_attribute_exists("state:prevRenameAttributes"))
attribute = test_node.get_attribute("state:prevRenameAttributes")
db_value = database.state.prevRenameAttributes
self.assertTrue(test_node.get_attribute_exists("state:prevTimeVaryingAttributes"))
attribute = test_node.get_attribute("state:prevTimeVaryingAttributes")
db_value = database.state.prevTimeVaryingAttributes
self.assertTrue(test_node.get_attribute_exists("state:prevUsdTimecode"))
attribute = test_node.get_attribute("state:prevUsdTimecode")
db_value = database.state.prevUsdTimecode
|
omniverse-code/kit/exts/omni.graph.io/omni/graph/io/ogn/tests/usd/OgnExportUSDPrimTemplate.usda | #usda 1.0
(
doc ="""Generated from node description file OgnExportUSDPrim.ogn
Contains templates for node types found in that file."""
)
def OmniGraph "TestGraph"
{
token evaluator:type = "push"
int2 fileFormatVersion = (1, 3)
token flatCacheBacking = "Shared"
token pipelineStage = "pipelineStageSimulation"
def OmniGraphNode "Template_omni_graph_ExportUSDPrim" (
docs="""Exports data from an input bundle into a USD prim"""
)
{
token node:type = "omni.graph.ExportUSDPrim"
int node:typeVersion = 1
# 14 attributes
custom bool inputs:applyTransform = false (
docs="""If true, apply the transform necessary to transform any transforming attributes from the space of the node into the space of the specified prim."""
)
custom token inputs:attrNamesToExport = "" (
docs="""Comma or space separated text, listing the names of attributes in the input data to be exported
or empty to import all attributes."""
)
custom rel inputs:bundle (
docs="""The bundle from which data should be exported."""
)
custom token inputs:excludedAttrNames = "" (
docs="""Attributes to be excluded from being exported"""
)
custom bool inputs:exportToRootLayer = true (
docs="""If true, prims are exported in the root layer, otherwise the layer specified by "layerName" is used."""
)
custom token inputs:inputAttrNames = "" (
docs="""Comma or space separated text, listing the names of attributes in the input data to be renamed"""
)
custom token inputs:layerName = "" (
docs="""Identifier of the layer to export to if "exportToRootLayer" is false, or leave this blank to export to the session layer"""
)
custom bool inputs:onlyExportToExisting = false (
docs="""If true, only attributes that already exist in the specified output prim will have data transferred to them from the input bundle."""
)
custom token inputs:outputAttrNames = "" (
docs="""Comma or space separated text, listing the new names for the attributes listed in inputAttrNames"""
)
custom bool inputs:primPathFromBundle = false (
docs="""When true, if there is a "primPath" token attribute inside the bundle, that will be the path of the USD prim to write to,
else the "outputs:prim" attribute below will be used for the USD prim path."""
)
custom bool inputs:removeMissingAttrs = false (
docs="""If true, any attributes on the USD prim(s) being written to, that aren't in the input data,
will be removed from the USD prim(s)."""
)
custom bool inputs:renameAttributes = false (
docs="""If true, attributes listed in "inputAttrNames" will be exported to attributes with the names specified in "outputAttrNames".
Note: to avoid potential issues with redundant attributes being created while typing, keep this off until after
specifying all input and output attribute names."""
)
custom bool inputs:timeVaryingAttributes = false (
docs="""Check whether the USD attributes should be time-varying and if so, export their data to a time sample at the time "usdTimecode"."""
)
custom double inputs:usdTimecode = 0 (
docs="""The time at which to evaluate the transform of the USD prim for applyTransform."""
)
# 1 attribute
def Output "outputs_prim" (
docs="""The USD prim(s) to which data should be exported if primPathFromBundle is false or if the bundle doesn't have a "primPath" token attribute.
Note: this is really an input, since the node just receives the path to the prim. The node does not contain the prim."""
)
{
}
# 15 attributes
custom bool state:prevApplyTransform (
docs="""Value of "applyTransform" input from previous run"""
)
custom token state:prevAttrNamesToExport (
docs="""Value of "attrNamesToExport" input from previous run"""
)
custom uint64 state:prevBundleDirtyID (
docs="""Dirty ID of input bundle from previous run"""
)
custom token state:prevExcludedAttrNames (
docs="""Value of "excludedAttrNames" input from previous run"""
)
custom bool state:prevExportToRootLayer (
docs="""Value of "exportToRootLayer" input from previous run"""
)
custom token state:prevInputAttrNames (
docs="""Value of "inputAttrNames" input from previous run"""
)
custom token state:prevLayerName (
docs="""Value of "layerName" input from previous run"""
)
custom bool state:prevOnlyExportToExisting (
docs="""Value of "onlyExportToExisting" input from previous run"""
)
custom token state:prevOutputAttrNames (
docs="""Value of "outputAttrNames" input from previous run"""
)
custom uint64[] state:prevPrimDirtyIDs (
docs="""Dirty IDs of input prims from previous run"""
)
custom bool state:prevPrimPathFromBundle (
docs="""Value of "primPathFromBundle" input from previous run"""
)
custom bool state:prevRemoveMissingAttrs (
docs="""Value of "removeMissingAttrs" input from previous run"""
)
custom bool state:prevRenameAttributes (
docs="""Value of "renameAttributes" input from previous run"""
)
custom bool state:prevTimeVaryingAttributes (
docs="""Value of "timeVaryingAttributes" input from previous run"""
)
custom double state:prevUsdTimecode (
docs="""Value of "usdTimecode" input from previous run"""
)
}
}
|
omniverse-code/kit/exts/omni.graph.io/omni/graph/io/ogn/tests/usd/OgnImportUSDPrimTemplate.usda | #usda 1.0
(
doc ="""Generated from node description file OgnImportUSDPrim.ogn
Contains templates for node types found in that file."""
)
def OmniGraph "TestGraph"
{
token evaluator:type = "push"
int2 fileFormatVersion = (1, 3)
token flatCacheBacking = "Shared"
token pipelineStage = "pipelineStageSimulation"
def OmniGraphNode "Template_omni_graph_ImportUSDPrim" (
docs="""Imports data from a USD prim into attributes in an output bundle"""
)
{
token node:type = "omni.graph.ImportUSDPrim"
int node:typeVersion = 1
# 17 attributes
custom bool inputs:applySkelBinding = true (
docs="""If the input USD prim is a Mesh, and has SkelBindingAPI schema applied, compute skinned points and normals."""
)
custom bool inputs:applyTransform = false (
docs="""If importAttributes is true, apply the transform necessary to transform any transforming attributes into the space of this node."""
)
custom token inputs:attrNamesToImport = "" (
docs="""Comma or space separated text, listing the names of attributes in the input data to be imported
or empty to import all attributes."""
)
custom bool inputs:computeBoundingBox = false (
docs="""Compute and store local bounding box of a prim and its children."""
)
custom bool inputs:importAttributes = true (
docs="""Import attribute data from the USD prim."""
)
custom bool inputs:importPath = true (
docs="""Record the input USD prim's path into the output bundle in an attribute named "primPath"."""
)
custom bool inputs:importPrimvarMetadata = true (
docs="""Import metadata like the interpolation type for primvars, and store it as attributes in the output bundle."""
)
custom bool inputs:importTime = true (
docs="""Record the usdTimecode above into the output bundle in an attribute named "primTime"."""
)
custom bool inputs:importTransform = true (
docs="""Record the transform required to take any attributes of the input USD prim
into the space of this node, i.e. the world transform of the input prim times the
inverse world transform of this node, into the output bundle in an attribute named "transform"."""
)
custom bool inputs:importType = true (
docs="""Record the input USD prim's type name into the output bundle in an attribute named "primType"."""
)
custom token inputs:inputAttrNames = "" (
docs="""Comma or space separated text, listing the names of attributes in the input data to be renamed"""
)
custom bool inputs:keepPrimsSeparate = true (
docs="""Prefix output attribute names with "prim" followed by a unique number and a colon,
to keep the attributes for separate input prims separate. The prim paths will
be in the "primPaths" token array attribute."""
)
custom token inputs:outputAttrNames = "" (
docs="""Comma or space separated text, listing the new names for the attributes listed in inputAttrNames"""
)
custom rel inputs:prim (
docs="""The USD prim from which to import data."""
)
custom bool inputs:renameAttributes = false (
docs="""If true, attributes listed in "inputAttrNames" will be imported to attributes with the names specified in "outputAttrNames"."""
)
custom bool inputs:timeVaryingAttributes = true (
docs="""Check whether the USD attributes are time-varying and if so, import their data at the time "usdTimecode"."""
)
custom double inputs:usdTimecode = 0 (
docs="""The time at which to evaluate the transform of the USD prim."""
)
# 1 attribute
def Output "outputs_output" (
docs="""Output bundle containing all of the imported data."""
)
{
}
# 20 attributes
custom bool state:prevApplySkelBinding (
docs="""Value of "applySkelBinding" input from previous run"""
)
custom bool state:prevApplyTransform (
docs="""Value of "applyTransform" input from previous run"""
)
custom token state:prevAttrNamesToImport (
docs="""Value of "attrNamesToImport" input from previous run"""
)
custom bool state:prevComputeBoundingBox (
docs="""Value of "computeBoundingBox" input from previous run"""
)
custom bool state:prevImportAttributes (
docs="""Value of "importAttributes" input from previous run"""
)
custom bool state:prevImportPath (
docs="""Value of "importPath" input from previous run"""
)
custom bool state:prevImportPrimvarMetadata (
docs="""Value of "importPrimvarMetadata" input from previous run"""
)
custom bool state:prevImportTime (
docs="""Value of "importTime" input from previous run"""
)
custom bool state:prevImportTransform (
docs="""Value of "importTransform" input from previous run"""
)
custom bool state:prevImportType (
docs="""Value of "importType" input from previous run"""
)
custom token state:prevInputAttrNames (
docs="""Value of "inputAttrNames" input from previous run"""
)
custom matrix4d state:prevInvNodeTransform (
docs="""Inverse transform of the node prim from the previous run."""
)
custom bool state:prevKeepPrimsSeparate (
docs="""Value of "keepPrimsSeparate" input from previous run"""
)
custom bool state:prevOnlyImportSpecified (
docs="""Value of "onlyImportSpecified" input from previous run"""
)
custom token state:prevOutputAttrNames (
docs="""Value of "outputAttrNames" input from previous run"""
)
custom token[] state:prevPaths (
docs="""Array of paths from the previous run."""
)
custom bool state:prevRenameAttributes (
docs="""Value of "renameAttributes" input from previous run"""
)
custom bool state:prevTimeVaryingAttributes (
docs="""Value of "timeVaryingAttributes" input from previous run"""
)
custom matrix4d[] state:prevTransforms (
docs="""Array of transforms from the previous run."""
)
custom double state:prevUsdTimecode (
docs="""Value of "usdTimecode" input from previous run"""
)
}
}
|
omniverse-code/kit/exts/omni.graph.io/omni/graph/io/ogn/tests/usd/OgnBundleToUSDATemplate.usda | #usda 1.0
(
doc ="""Generated from node description file OgnBundleToUSDA.ogn
Contains templates for node types found in that file."""
)
def OmniGraph "TestGraph"
{
token evaluator:type = "push"
int2 fileFormatVersion = (1, 3)
token flatCacheBacking = "Shared"
token pipelineStage = "pipelineStageSimulation"
def OmniGraphNode "Template_omni_graph_BundleToUSDA" (
docs="""Outputs a represention of the content of a bundle as usda text"""
)
{
token node:type = "omni.graph.BundleToUSDA"
int node:typeVersion = 1
# 6 attributes
custom rel inputs:bundle (
docs="""The bundle to convert to usda text."""
)
custom bool inputs:outputAncestors = false (
docs="""If usePath is true and this is also true, ancestor "primPath" entries will be output."""
)
custom bool inputs:outputValues = true (
docs="""If true, the values of attributes will be output, else values will be omitted."""
)
custom bool inputs:usePrimPath = true (
docs="""Use the attribute named "primPath" for the usda prim path."""
)
custom bool inputs:usePrimType = true (
docs="""Use the attribute named "primType" for the usda prim type name."""
)
custom bool inputs:usePrimvarMetadata = true (
docs="""Identify attributes representing metadata like the interpolation type for primvars, and include them as usda metadata in the output text."""
)
# 1 attribute
custom token outputs:text (
docs="""Output usda text representing the bundle contents."""
)
}
}
|
omniverse-code/kit/exts/omni.graph.io/omni/graph/io/ogn/tests/usd/OgnTransformBundleTemplate.usda | #usda 1.0
(
doc ="""Generated from node description file OgnTransformBundle.ogn
Contains templates for node types found in that file."""
)
def OmniGraph "TestGraph"
{
token evaluator:type = "push"
int2 fileFormatVersion = (1, 3)
token flatCacheBacking = "Shared"
token pipelineStage = "pipelineStageSimulation"
def OmniGraphNode "Template_omni_graph_TransformBundle" (
docs="""Applies a transform to an input bundle, storing the result in an output bundle"""
)
{
token node:type = "omni.graph.TransformBundle"
int node:typeVersion = 1
# 2 attributes
custom rel inputs:input (
docs="""Input bundle containing the attributes to be transformed."""
)
custom matrix4d inputs:transform = ((1.0, 0.0, 0.0, 0.0), (0.0, 1.0, 0.0, 0.0), (0.0, 0.0, 1.0, 0.0), (0.0, 0.0, 0.0, 1.0)) (
docs="""The transform to apply to the bundle"""
)
# 1 attribute
def Output "outputs_output" (
docs="""Output bundle containing all of the transformed attributes"""
)
{
}
}
}
|
omniverse-code/kit/exts/omni.graph.io/omni/graph/io/_impl/extension.py | """Support required by the Carbonite extension loader"""
import omni.ext
from ..bindings._omni_graph_io import acquire_interface as _acquire_interface # noqa: PLE0402
from ..bindings._omni_graph_io import release_interface as _release_interface # noqa: PLE0402
class _PublicExtension(omni.ext.IExt):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.__interface = None
try:
import omni.graph.ui as ogu
ogu.ComputeNodeWidget.get_instance().add_template_path(__file__)
except ImportError:
pass
def on_startup(self, ext_id):
self.__interface = _acquire_interface()
def on_shutdown(self):
if self.__interface is not None:
_release_interface(self.__interface)
self.__interface = None
|
omniverse-code/kit/exts/omni.graph.io/omni/graph/io/_impl/templates/template_omni.graph.ImportUSDPrim.py | from omni.kit.property.usd.custom_layout_helper import CustomLayoutFrame, CustomLayoutGroup, CustomLayoutProperty
class CustomLayout:
def __init__(self, compute_node_widget):
# print("\nInside template_omni.genproc.ImportUSDPrim.py, CustomLayout:__init__\n");
# Enable template
self.enable = True
self.compute_node_widget = compute_node_widget
self.compute_node_widget.get_bundles()
bundle_items_iter = iter(self.compute_node_widget.bundles.items())
_ = next(bundle_items_iter)[1][0].get_attribute_names_and_types()
def apply(self, props):
frame = CustomLayoutFrame(hide_extra=True)
with frame:
with CustomLayoutGroup("Import Parameters"):
CustomLayoutProperty("inputs:prim", "Prim(s) to Import")
CustomLayoutProperty("inputs:usdTimecode", "Timecode")
CustomLayoutProperty("inputs:keepPrimsSeparate", "Allow Multiple Prims")
CustomLayoutProperty("inputs:importTransform", "Import Transforms")
CustomLayoutProperty("inputs:computeBoundingBox", "Compute Bounding Boxes")
CustomLayoutProperty("inputs:importType", "Import Types")
CustomLayoutProperty("inputs:importPath", "Import Paths")
CustomLayoutProperty("inputs:importTime", "Import Time")
with CustomLayoutGroup("Attributes"):
CustomLayoutProperty("inputs:importAttributes", "Import Attributes")
CustomLayoutProperty("inputs:attrNamesToImport", "Attributes to Import")
CustomLayoutProperty("inputs:renameAttributes", "Rename Attributes")
CustomLayoutProperty("inputs:inputAttrNames", "Attributes to Rename")
CustomLayoutProperty("inputs:outputAttrNames", "New Attribute Names")
CustomLayoutProperty("inputs:applyTransform", "Transform Attributes")
CustomLayoutProperty("inputs:timeVaryingAttributes", "Time Varying Attributes")
CustomLayoutProperty("inputs:importPrimvarMetadata", "Import Metadata")
CustomLayoutProperty("inputs:applySkelBinding", "Apply SkelBinding")
return frame.apply(props)
# print("\nIn template_omni.graph.ImportUSDPrim.py\n")
|
omniverse-code/kit/exts/omni.graph.io/omni/graph/io/_impl/templates/template_omni.graph.ExportUSDPrim.py | from omni.kit.property.usd.custom_layout_helper import CustomLayoutFrame, CustomLayoutGroup, CustomLayoutProperty
class CustomLayout:
def __init__(self, compute_node_widget):
# print("\nInside template_omni.genproc.ExportUSDPrim.py, CustomLayout:__init__\n");
# Enable template
self.enable = True
self.compute_node_widget = compute_node_widget
self.compute_node_widget.get_bundles()
bundle_items_iter = iter(self.compute_node_widget.bundles.items())
_ = next(bundle_items_iter)[1][0].get_attribute_names_and_types()
def apply(self, props):
frame = CustomLayoutFrame(hide_extra=True)
with frame:
with CustomLayoutGroup("Export Parameters"):
CustomLayoutProperty("outputs:prim", "Prim(s) to Export to")
CustomLayoutProperty("inputs:bundle", "Source Data")
CustomLayoutProperty("inputs:primPathFromBundle", "Export to primPath from Source")
CustomLayoutProperty("inputs:exportToRootLayer", "Export to Root Layer")
CustomLayoutProperty("inputs:layerName", "Layer Name")
with CustomLayoutGroup("Attributes"):
CustomLayoutProperty("inputs:attrNamesToExport", "Attributes to Export")
CustomLayoutProperty("inputs:onlyExportToExisting", "Only Export Existing")
CustomLayoutProperty("inputs:removeMissingAttrs", "Remove Missing")
CustomLayoutProperty("inputs:renameAttributes", "Rename Attributes")
CustomLayoutProperty("inputs:inputAttrNames", "Attributes to Rename")
CustomLayoutProperty("inputs:outputAttrNames", "New Attribute Names")
CustomLayoutProperty("inputs:excludedAttrNames", "Attributes to Exclude")
CustomLayoutProperty("inputs:applyTransform", "Transform Attributes")
CustomLayoutProperty("inputs:timeVaryingAttributes", "Time-varying Attributes")
CustomLayoutProperty("inputs:usdTimecode", "USD Time")
return frame.apply(props)
# print("\nIn template_omni.graph.ExportUSDPrim.py\n")
|
omniverse-code/kit/exts/omni.graph.io/omni/graph/io/tests/test_api.py | """Testing the stability of the API in this module"""
import omni.graph.core.tests as ogts
import omni.graph.io as ogio
from omni.graph.tools.tests.internal_utils import _check_module_api_consistency, _check_public_api_contents
# ======================================================================
class _TestOmniGraphIoApi(ogts.OmniGraphTestCase):
_UNPUBLISHED = ["bindings", "ogn", "tests"]
async def test_api(self):
_check_module_api_consistency(ogio, self._UNPUBLISHED) # noqa: PLW0212
_check_module_api_consistency(ogio.tests, is_test_module=True) # noqa: PLW0212
async def test_api_features(self):
"""Test that the known public API features continue to exist"""
_check_public_api_contents(ogio, [], self._UNPUBLISHED, only_expected_allowed=True) # noqa: PLW0212
_check_public_api_contents(ogio.tests, [], [], only_expected_allowed=True) # noqa: PLW0212
|
omniverse-code/kit/exts/omni.graph.io/omni/graph/io/tests/__init__.py | """There is no public API to this module."""
__all__ = []
scan_for_test_modules = True
"""The presence of this object causes the test runner to automatically scan the directory for unit test cases"""
|
omniverse-code/kit/exts/omni.graph.io/omni/graph/io/tests/test_prim_data_import_export.py | import omni.graph.core as ogc
import omni.kit.test
class TestPrimDataImportExport(ogc.tests.OmniGraphTestCase):
"""Run a unit test to validate data flow through bundles."""
TEST_GRAPH_PATH = "/TestGraph"
TRANSLATE = (10.0, 20.0, 30.0)
ROTATE = (90.0, 180.0, 270.0)
SCALE = (400.0, 500.0, 600.0)
async def setUp(self):
"""Set up test environment, to be torn down when done"""
await super().setUp()
self.controller = ogc.Controller()
self.graph = self.controller.create_graph(self.TEST_GRAPH_PATH)
self.context = self.graph.get_default_graph_context()
# Create ImportUSDPrim and ExportUSDPrim and connect them together.
(self.graph, (self.importNode, self.exportNode), _, _,) = self.controller.edit(
self.TEST_GRAPH_PATH,
{
ogc.Controller.Keys.CREATE_NODES: [
("import_usd_prim_data", "omni.graph.ImportUSDPrim"),
("export_usd_prim_data", "omni.graph.ExportUSDPrim"),
],
ogc.Controller.Keys.CONNECT: [
(
"import_usd_prim_data.outputs_output",
"export_usd_prim_data.inputs:bundle",
)
],
},
)
stage = omni.usd.get_context().get_stage()
# Create two Xform nodes, one as input, the other as output.
self.input_prim = ogc.Controller.create_prim("/input_prim", {}, "Xform")
self.output_prim = ogc.Controller.create_prim("/output_prim", {}, "Xform")
omni.kit.commands.execute(
"AddRelationshipTarget",
relationship=stage.GetPropertyAtPath(self.TEST_GRAPH_PATH + "/import_usd_prim_data.inputs:prim"),
target=self.input_prim.GetPath(),
)
omni.kit.commands.execute(
"AddRelationshipTarget",
relationship=stage.GetPropertyAtPath(self.TEST_GRAPH_PATH + "/export_usd_prim_data.outputs:prim"),
target=self.output_prim.GetPath(),
)
async def test_set_attributes(self):
"""Test whether attribute value changes of the input prim will be synced to the output prim."""
# Assign new TRS values to the input prim.
self.input_prim.GetAttribute("xformOp:translate").Set(self.TRANSLATE)
self.input_prim.GetAttribute("xformOp:rotateXYZ").Set(self.ROTATE)
self.input_prim.GetAttribute("xformOp:scale").Set(self.SCALE)
# Before graph evaluation, the output prim is still with its default attribute values.
self.assertFalse(self.output_prim.GetAttribute("xformOp:translate").Get() == self.TRANSLATE)
self.assertFalse(self.output_prim.GetAttribute("xformOp:rotateXYZ").Get() == self.ROTATE)
self.assertFalse(self.output_prim.GetAttribute("xformOp:scale").Get() == self.SCALE)
# Trigger graph evaluation and wait for completion.
await ogc.Controller.evaluate(self.graph)
# After graph evaluation, the output prim has been fed with data from the input prim.
self.assertTrue(self.output_prim.GetAttribute("xformOp:translate").Get() == self.TRANSLATE)
self.assertTrue(self.output_prim.GetAttribute("xformOp:rotateXYZ").Get() == self.ROTATE)
self.assertTrue(self.output_prim.GetAttribute("xformOp:scale").Get() == self.SCALE)
async def test_bundle_attributes_and_metadata(self):
"""Test bundle attributes and metadata"""
# Get the bundle from the import node.
bundle = self.context.get_output_bundle(self.importNode, "outputs_output")
self.assertTrue(bundle.is_valid())
# Attribute names and types before evaluation.
attr_names, attr_types = bundle.get_attribute_names_and_types()
self.assertTrue(len(attr_names) == 0)
self.assertTrue(len(attr_types) == 0)
# Assign new TRS values to the input prim.
self.input_prim.GetAttribute("xformOp:translate").Set(self.TRANSLATE)
self.input_prim.GetAttribute("xformOp:rotateXYZ").Set(self.ROTATE)
self.input_prim.GetAttribute("xformOp:scale").Set(self.SCALE)
# Trigger graph evaluation and wait for completion.
await ogc.Controller.evaluate(self.graph)
# Attribute names and types after evaluation.
attr_names, attr_types = bundle.get_attribute_names_and_types()
self.assertTrue(len(attr_names) != 0)
self.assertTrue(len(attr_types) != 0)
# Internal attributes shouldn't be exposed.
metadata_names = {
"interpolation",
"source",
"bundlePrimIndexOffset",
}
self.assertTrue(metadata_names.isdisjoint(set(attr_names)))
# Convert bundle to IBundle2 for metadata access.
factory = ogc.IBundleFactory.create()
bundle = factory.get_bundle(self.context, bundle)
# Test metadata names.
self.assertEqual(
set(bundle.get_bundle_metadata_names()),
{"bundlePrimIndexOffset"},
)
async def test_bundle_dirty_id(self):
"""Test whether bundleDirtyID bumps after graph evaluation."""
factory = ogc.IBundleFactory.create()
# Get the output bundle from the importer and convert to IBundle2.
output_bundle = self.context.get_output_bundle(self.importNode, "outputs_output")
output_bundle = factory.get_bundle(self.context, output_bundle)
# Get the input bundle from the exporter and convert to IBundle2.
input_bundle = self.context.get_input_bundle(self.exportNode, "inputs:bundle")
input_bundle = factory.get_bundle(self.context, input_bundle)
# Trigger graph evaluation and wait for completion.
await ogc.Controller.evaluate(self.graph)
dirty_id = ogc._og_unstable.IDirtyID2.create(self.context) # noqa: PLW0212
# Get dirty id.
output_dirty_id = dirty_id.get([output_bundle])[0]
input_dirty_id = dirty_id.get([input_bundle])[0]
# Trigger graph evaluation and wait for completion.
await ogc.Controller.evaluate(self.graph)
# The dirty id doesn't bump because nothing gets changed.
self.assertEqual(output_dirty_id, dirty_id.get([output_bundle])[0])
self.assertEqual(input_dirty_id, dirty_id.get([input_bundle])[0])
# Assign new TRS values to the input prim.
self.input_prim.GetAttribute("xformOp:translate").Set(self.TRANSLATE)
self.input_prim.GetAttribute("xformOp:rotateXYZ").Set(self.ROTATE)
self.input_prim.GetAttribute("xformOp:scale").Set(self.SCALE)
# Trigger graph evaluation and wait for completion.
await ogc.Controller.evaluate(self.graph)
# The dirty id bumps because of TRS value changes.
self.assertNotEqual(output_dirty_id, dirty_id.get([output_bundle])[0])
self.assertNotEqual(input_dirty_id, dirty_id.get([input_bundle])[0])
async def test_child_bundle_order(self):
"""Test whether the order of child bundles extracted from the output bundle is consistent with that of target prims."""
graph_path = "/TestGraph2"
cubes = [("/cube_1", 1.0), ("/cube_2", 2.0), ("/cube_3", 3.0), ("/cube_4", 4.0)]
attr_name = "size"
controller = ogc.Controller()
keys = ogc.Controller.Keys
(graph, (_, output_node), _, _,) = controller.edit(
graph_path,
{
keys.CREATE_NODES: [
("import_usd_prim_data", "omni.graph.ImportUSDPrim"),
("bundle_to_usda_text", "omni.graph.BundleToUSDA"),
],
keys.CONNECT: [
("import_usd_prim_data.outputs_output", "bundle_to_usda_text.inputs:bundle"),
],
keys.SET_VALUES: ("import_usd_prim_data.inputs:attrNamesToImport", attr_name),
},
)
# Create target prims and assign the size attribute with different values.
for cube_path, cube_size in cubes:
prim = ogc.Controller.create_prim(cube_path, {}, "Cube")
prim.GetAttribute(attr_name).Set(cube_size)
# Assign the target prims to the import node.
stage = omni.usd.get_context().get_stage()
omni.kit.commands.execute(
"SetRelationshipTargets",
relationship=stage.GetPropertyAtPath(graph_path + "/import_usd_prim_data.inputs:prim"),
targets=[cube_path for cube_path, _ in cubes],
)
await ogc.Controller.evaluate(graph)
expected_result = (
'def Cube "cube_1"\n'
"{\n"
" double size = 1.00000000000000000e+00\n"
' token sourcePrimPath = "/cube_1"\n'
' token sourcePrimType = "Cube"\n'
"}\n"
'def Cube "cube_2"\n'
"{\n"
" double size = 2.00000000000000000e+00\n"
' token sourcePrimPath = "/cube_2"\n'
' token sourcePrimType = "Cube"\n'
"}\n"
'def Cube "cube_3"\n'
"{\n"
" double size = 3.00000000000000000e+00\n"
' token sourcePrimPath = "/cube_3"\n'
' token sourcePrimType = "Cube"\n'
"}\n"
'def Cube "cube_4"\n'
"{\n"
" double size = 4.00000000000000000e+00\n"
' token sourcePrimPath = "/cube_4"\n'
' token sourcePrimType = "Cube"\n'
"}\n"
)
# Change timecode to trigger recompute. Run 60 times to eliminate random factor.
for timecode in range(60):
self.controller.edit(
self.TEST_GRAPH_PATH,
{ogc.Controller.Keys.SET_VALUES: ("import_usd_prim_data.inputs:usdTimecode", timecode)},
)
await ogc.Controller.evaluate(self.graph)
output_attr = output_node.get_attribute("outputs:text")
self.assertTrue(output_attr is not None and output_attr.is_valid())
self.assertEqual(output_attr.get(), expected_result)
|
omniverse-code/kit/exts/omni.graph.io/docs/CHANGELOG.md | # CHANGELOG
This document records all notable changes to ``omni.graph.io`` extension.
This project adheres to `Semantic Versioning <https://semver.org/>`_.
<<<<<<< HEAD
=======
## [1.2.5] - 2022-11-18
### Changed
- Allow to be used in headless mode
## [1.2.3] - 2022-08-09
### Fixed
- Applied formatting to all of the Python files
## [1.2.2] - 2022-08-09
### Fixed
- Fixed backward compatibility break for the deprecated `IDirtyID` interface.
## [1.2.1] - 2022-08-03
### Fixed
- Compilation errors related to deprecation of methods in ogn bundle.
## [1.2.0] - 2022-07-28
### Deprecated
- Deprecated `IDirtyID` interface
- Deprecated `BundleAttrib` class and `BundleAttribSource` enumeration
- Deprecated `BundlePrim`, `BundlePrims`, `BundlePrimIterator` and `BundlePrimAttrIterator`
- Deprecated `ConstBundlePrim`, `ConstBundlePrims`, `ConstBundlePrimIterator` and `ConstBundlePrimAttrIterator`
## [1.1.0] - 2022-07-07
### Added
- Test for public API consistency
- Added build handling for tests module
## [1.0.10] - 2021-11-19
- Added option on ImportUsdPrim to include local bounding box of imported prims as a common attribute.
- Fixed case where Import is not re-computed when a transform is needed and an ancestor prim's transform has changed.
## [1.0.9] - 2021-11-10
- Added option on ExportUSDPrim node type to remove, from output prims, any authored attributes that aren't being exported
## [1.0.8] - 2021-10-22
- Should be identical to 1.0.7, but incrementing the version number just in case, for logistical reasons
## [1.0.7] - 2021-10-14
- Added option to export time sampled data to specified time in ExportUSDPrim node type
## [1.0.6] - 2021-10-05
- Fixed re-importing of transforming attributes in ImportUSDPrim node type when transforms change
## [1.0.5] - 2021-09-24
- Added attribute-level change tracking to ImportUSDPrim node type
## [1.0.4] - 2021-09-16
- Added "Attributes to Import" and "Attributes to Export" to corresponding nodes to reduce confusion about how to import/export a subset of attributes
- Added support for importing/exporting "widths" interpolation from USD
## [1.0.3] - 2021-08-18
- Updated for an ABI break in Kit
## [1.0.2] - 2021-08-17
- Fixed crash related to ImportUSDPrim node type and breaking change in Kit from eTransform being deprecated in favour of eMatrix
## [1.0.1] - 2021-08-13
- Fixed crash related to ImportUSDPrim node type
## [1.0.0] - 2021-07-27
### Added
- Initial version. Added ImportUSDPrim, ExportUSDPrim, TransformBundle, and BundleToUSDA node types.
|
omniverse-code/kit/exts/omni.graph.io/docs/README.md | # OmniGraph I/O [omni.graph.io]
The OmniGraph I/O extension provides OmniGraph node types for dealing with collections of USD prims. ImportUSDPrim imports data from one or more USD prims, representing the collection as a single output bundle. ExportUSDPrim takes data from such a bundle as input and exports it to one or more USD prims. TransformBundle transforms transforming attributes in a bundle. BundleToUSDA outputs text representing the input bundle in a format similar to that of usda files.
|
omniverse-code/kit/exts/omni.graph.io/docs/index.rst | OmniGraph I/O
#############
.. tabularcolumns:: |L|R|
.. csv-table::
:width: 100%
**Extension**: omni.graph.io,**Documentation Generated**: |today|
.. toctree::
:maxdepth: 1
CHANGELOG
|
omniverse-code/kit/exts/omni.graph.io/docs/Overview.md | # OmniGraph I/O
```{csv-table}
**Extension**: omni.graph.io,**Documentation Generated**: {sub-ref}`today`
```
|
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnGetCameraTarget.rst | .. _omni_graph_ui_nodes_GetCameraTarget_2:
.. _omni_graph_ui_nodes_GetCameraTarget:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Get Camera Target
:keywords: lang-en omnigraph node sceneGraph:camera threadsafe ui_nodes get-camera-target
Get Camera Target
=================
.. <description>
Gets a viewport camera's target point.
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"inputs:prim", "``target``", "The camera prim, when 'usePath' is false", "None"
"Camera Path (*inputs:primPath*)", "``token``", "Path of the camera, used when 'usePath' is true", ""
"inputs:usePath", "``bool``", "When true, the 'primPath' attribute is used as the path to the prim being read, otherwise it will read the connection at the 'prim' attribute", "True"
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Target (*outputs:target*)", "``pointd[3]``", "The target point", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.GetCameraTarget"
"Version", "2"
"Extension", "omni.graph.ui_nodes"
"Has State?", "False"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "Get Camera Target"
"Categories", "sceneGraph:camera"
"Generated Class Name", "OgnGetCameraTargetDatabase"
"Python Module", "omni.graph.ui_nodes"
|
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnReadWindowSize.rst | .. _omni_graph_ui_nodes_ReadWindowSize_1:
.. _omni_graph_ui_nodes_ReadWindowSize:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Read Window Size (BETA)
:keywords: lang-en omnigraph node ui ReadOnly ui_nodes read-window-size
Read Window Size (BETA)
=======================
.. <description>
Outputs the size of a UI window.
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Is Viewport? (*inputs:isViewport*)", "``bool``", "If true then only viewport windows will be considered.", "False"
"Name (*inputs:name*)", "``token``", "Name of the window. If there are multiple windows with the same name the first one found will be used.", "None"
"Widget Path (*inputs:widgetPath*)", "``token``", "Full path to a widget in the window. If specified then 'name' will be ignored and the window containing the widget will be used.", "None"
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Height (*outputs:height*)", "``float``", "Height of the window in pixels.", "None"
"Width (*outputs:width*)", "``float``", "Width of the window in pixels.", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.ReadWindowSize"
"Version", "1"
"Extension", "omni.graph.ui_nodes"
"Has State?", "False"
"Implementation Language", "Python"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "Read Window Size (BETA)"
"Categories", "ui"
"Generated Class Name", "OgnReadWindowSizeDatabase"
"Python Module", "omni.graph.ui_nodes"
|
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnOnNewFrame.rst | .. _omni_graph_ui_nodes_OnNewFrame_1:
.. _omni_graph_ui_nodes_OnNewFrame:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: On New Frame
:keywords: lang-en omnigraph node graph:action,event compute-on-request ui_nodes on-new-frame
On New Frame
============
.. <description>
Triggers when there is a new frame available for the given viewport. Note that the graph will run asynchronously to the new frame event
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"inputs:viewport", "``token``", "Name of the viewport, or empty for the default viewport", ""
"", "*displayGroup*", "parameters", ""
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"outputs:execOut", "``execution``", "Output Execution", "None"
"outputs:frameNumber", "``int``", "The number of the frame which is available", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.OnNewFrame"
"Version", "1"
"Extension", "omni.graph.ui_nodes"
"Has State?", "True"
"Implementation Language", "Python"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "On New Frame"
"Categories", "graph:action,event"
"Generated Class Name", "OgnOnNewFrameDatabase"
"Python Module", "omni.graph.ui_nodes"
|
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnOnWidgetValueChanged.rst | .. _omni_graph_ui_nodes_OnWidgetValueChanged_1:
.. _omni_graph_ui_nodes_OnWidgetValueChanged:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: On Widget Value Changed (BETA)
:keywords: lang-en omnigraph node graph:action,ui compute-on-request ui_nodes on-widget-value-changed
On Widget Value Changed (BETA)
==============================
.. <description>
Event node which fires when a UI widget with the specified identifier has its value changed. This node should be used in combination with UI creation nodes such as OgnSlider.
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Widget Identifier (*inputs:widgetIdentifier*)", "``token``", "A unique identifier identifying the widget. This should be specified in the UI creation node such as OgnSlider.", ""
"", "*literalOnly*", "1", ""
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"New Value (*outputs:newValue*)", "``['bool', 'float', 'int', 'string']``", "The new value of the widget", "None"
"Value Changed (*outputs:valueChanged*)", "``execution``", "Executed when the value of the widget is changed", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.OnWidgetValueChanged"
"Version", "1"
"Extension", "omni.graph.ui_nodes"
"Has State?", "True"
"Implementation Language", "Python"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "On Widget Value Changed (BETA)"
"Categories", "graph:action,ui"
"Generated Class Name", "OgnOnWidgetValueChangedDatabase"
"Python Module", "omni.graph.ui_nodes"
|
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnOnViewportDragged.rst | .. _omni_graph_ui_nodes_OnViewportDragged_1:
.. _omni_graph_ui_nodes_OnViewportDragged:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: On Viewport Dragged (BETA)
:keywords: lang-en omnigraph node graph:action,ui threadsafe compute-on-request ui_nodes on-viewport-dragged
On Viewport Dragged (BETA)
==========================
.. <description>
Event node which fires when a viewport drag event occurs in the specified viewport. Note that viewport mouse events must be enabled on the specified viewport using a SetViewportMode node.
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Gesture (*inputs:gesture*)", "``token``", "The input gesture to trigger viewport drag events", "Left Mouse Drag"
"", "*displayGroup*", "parameters", ""
"", "*literalOnly*", "1", ""
"", "*allowedTokens*", "Left Mouse Drag,Right Mouse Drag,Middle Mouse Drag", ""
"Only Simulate On Play (*inputs:onlyPlayback*)", "``bool``", "When true, the node is only computed while Stage is being played", "True"
"", "*literalOnly*", "1", ""
"Use Normalized Coords (*inputs:useNormalizedCoords*)", "``bool``", "When true, the components of 2D position outputs are scaled to between 0 and 1, where 0 is top/left and 1 is bottom/right. When false, components are in viewport render resolution pixels.", "False"
"", "*literalOnly*", "1", ""
"Viewport (*inputs:viewport*)", "``token``", "Name of the viewport window to watch for drag events", "Viewport"
"", "*literalOnly*", "1", ""
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Began (*outputs:began*)", "``execution``", "Enabled when the drag begins, populating 'Initial Position' with the current mouse position", "None"
"Ended (*outputs:ended*)", "``execution``", "Enabled when the drag ends, populating 'Final Position' with the current mouse position", "None"
"Final Position (*outputs:finalPosition*)", "``double[2]``", "The mouse position at which the drag ended (valid when 'Ended' is enabled)", "None"
"Initial Position (*outputs:initialPosition*)", "``double[2]``", "The mouse position at which the drag began (valid when either 'Began' or 'Ended' is enabled)", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.OnViewportDragged"
"Version", "1"
"Extension", "omni.graph.ui_nodes"
"Has State?", "False"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "On Viewport Dragged (BETA)"
"Categories", "graph:action,ui"
"Generated Class Name", "OgnOnViewportDraggedDatabase"
"Python Module", "omni.graph.ui_nodes"
|
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnPlacer.rst | .. _omni_graph_ui_nodes_Placer_1:
.. _omni_graph_ui_nodes_Placer:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Placer (BETA)
:keywords: lang-en omnigraph node graph:action,ui ui_nodes placer
Placer (BETA)
=============
.. <description>
Contruct a Placer widget. The Placer takes a single child and places it at a given position within it.
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Create (*inputs:create*)", "``execution``", "Input execution to create and show the widget", "None"
"Parent Widget Path (*inputs:parentWidgetPath*)", "``token``", "The absolute path to the parent widget.", ""
"Position (*inputs:position*)", "``double[2]``", "Where to position the child widget within the Placer.", "[0.0, 0.0]"
"inputs:style", "``string``", "Style to be applied to the Placer and its child. This can later be changed with the WriteWidgetStyle node.", "None"
"Widget Identifier (*inputs:widgetIdentifier*)", "``token``", "An optional unique identifier for the widget. Can be used to refer to this widget in other places such as the OnWidgetClicked node.", "None"
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Created (*outputs:created*)", "``execution``", "Executed when the widget is created", "None"
"Widget Path (*outputs:widgetPath*)", "``token``", "The absolute path to the created Placer widget", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.Placer"
"Version", "1"
"Extension", "omni.graph.ui_nodes"
"Has State?", "False"
"Implementation Language", "Python"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "Placer (BETA)"
"Categories", "graph:action,ui"
"Generated Class Name", "OgnPlacerDatabase"
"Python Module", "omni.graph.ui_nodes"
|
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnSetActiveViewportCamera.rst | .. _omni_graph_ui_nodes_SetActiveViewportCamera_1:
.. _omni_graph_ui_nodes_SetActiveViewportCamera:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Set Active Camera
:keywords: lang-en omnigraph node sceneGraph:camera ReadOnly ui_nodes set-active-viewport-camera
Set Active Camera
=================
.. <description>
Sets Viewport's actively bound camera to given camera at give path
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"In (*inputs:execIn*)", "``execution``", "Execution input", "None"
"Camera Path (*inputs:primPath*)", "``token``", "Path of the camera to bind", ""
"Viewport (*inputs:viewport*)", "``token``", "Name of the viewport, or empty for the default viewport", ""
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Out (*outputs:execOut*)", "``execution``", "Execution Output", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.SetActiveViewportCamera"
"Version", "1"
"Extension", "omni.graph.ui_nodes"
"Has State?", "False"
"Implementation Language", "Python"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "Set Active Camera"
"Categories", "sceneGraph:camera"
"Generated Class Name", "OgnSetActiveViewportCameraDatabase"
"Python Module", "omni.graph.ui_nodes"
|
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnOnPicked.rst | .. _omni_graph_ui_nodes_OnPicked_3:
.. _omni_graph_ui_nodes_OnPicked:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: On Picked (BETA)
:keywords: lang-en omnigraph node graph:action,ui threadsafe compute-on-request ui_nodes on-picked
On Picked (BETA)
================
.. <description>
Event node which fires when a picking event occurs in the specified viewport. Note that picking events must be enabled on the specified viewport using a SetViewportMode node.
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Gesture (*inputs:gesture*)", "``token``", "The input gesture to trigger a picking event", "Left Mouse Click"
"", "*displayGroup*", "parameters", ""
"", "*literalOnly*", "1", ""
"", "*allowedTokens*", "Left Mouse Click,Right Mouse Click,Middle Mouse Click,Left Mouse Press,Right Mouse Press,Middle Mouse Press", ""
"Only Simulate On Play (*inputs:onlyPlayback*)", "``bool``", "When true, the node is only computed while Stage is being played.", "True"
"", "*literalOnly*", "1", ""
"Tracked Prims (*inputs:trackedPrims*)", "``target``", "Optionally specify a set of tracked prims that will cause 'Picked' to fire when picked", "None"
"", "*literalOnly*", "1", ""
"", "*allowMultiInputs*", "1", ""
"Viewport (*inputs:viewport*)", "``token``", "Name of the viewport window to watch for picking events", "Viewport"
"", "*literalOnly*", "1", ""
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Is Tracked Prim Picked (*outputs:isTrackedPrimPicked*)", "``bool``", "True if a tracked prim got picked, or if any prim got picked if no tracked prims are specified (will always be true when 'Picked' fires, and false when 'Missed' fires)", "None"
"Missed (*outputs:missed*)", "``execution``", "Enabled when an attempted picking did not pick a tracked prim, or when nothing gets picked if no tracked prims are specified", "None"
"Picked (*outputs:picked*)", "``execution``", "Enabled when a tracked prim is picked, or when any prim is picked if no tracked prims are specified", "None"
"Picked Prim (*outputs:pickedPrim*)", "``target``", "The picked prim, or an empty target if nothing got picked", "None"
"Picked Prim Path (*outputs:pickedPrimPath*)", "``token``", "The path of the picked prim, or an empty string if nothing got picked", "None"
"Picked World Position (*outputs:pickedWorldPos*)", "``pointd[3]``", "The XYZ-coordinates of the point in world space at which the prim got picked, or (0,0,0) if nothing got picked", "None"
"Tracked Prim Paths (*outputs:trackedPrimPaths*)", "``token[]``", "A list of the paths of the prims specified in 'Tracked Prims'", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.OnPicked"
"Version", "3"
"Extension", "omni.graph.ui_nodes"
"Has State?", "False"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "On Picked (BETA)"
"Categories", "graph:action,ui"
"Generated Class Name", "OgnOnPickedDatabase"
"Python Module", "omni.graph.ui_nodes"
|
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnGetCameraPosition.rst | .. _omni_graph_ui_nodes_GetCameraPosition_2:
.. _omni_graph_ui_nodes_GetCameraPosition:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Get Camera Position
:keywords: lang-en omnigraph node sceneGraph:camera threadsafe ui_nodes get-camera-position
Get Camera Position
===================
.. <description>
Gets a viewport camera position
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"inputs:prim", "``target``", "The camera prim, when 'usePath' is false", "None"
"Camera Path (*inputs:primPath*)", "``token``", "Path of the camera, used when 'usePath' is true", ""
"inputs:usePath", "``bool``", "When true, the 'primPath' attribute is used as the path to the prim being read, otherwise it will read the connection at the 'prim' attribute", "True"
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Position (*outputs:position*)", "``pointd[3]``", "The position of the camera in world space", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.GetCameraPosition"
"Version", "2"
"Extension", "omni.graph.ui_nodes"
"Has State?", "False"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "Get Camera Position"
"Categories", "sceneGraph:camera"
"Generated Class Name", "OgnGetCameraPositionDatabase"
"Python Module", "omni.graph.ui_nodes"
|
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnDrawDebugCurve.rst | .. _omni_graph_ui_nodes_DrawDebugCurve_1:
.. _omni_graph_ui_nodes_DrawDebugCurve:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Draw Debug Curve
:keywords: lang-en omnigraph node debug ui_nodes draw-debug-curve
Draw Debug Curve
================
.. <description>
Given a set of curve points, draw a curve in the viewport
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Closed (*inputs:closed*)", "``bool``", "When true, connect the last point to the first", "False"
"Color (*inputs:color*)", "``colorf[3]``", "The color of the curve", "[0.0, 0.0, 0.0]"
"Curve Points (*inputs:curvepoints*)", "``double[3][]``", "The curve to be drawn", "[]"
"In (*inputs:execIn*)", "``execution``", "Execution input", "None"
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Out (*outputs:execOut*)", "``execution``", "Execution Output", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.DrawDebugCurve"
"Version", "1"
"Extension", "omni.graph.ui_nodes"
"Has State?", "False"
"Implementation Language", "Python"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "Draw Debug Curve"
"Categories", "debug"
"Generated Class Name", "OgnDrawDebugCurveDatabase"
"Python Module", "omni.graph.ui_nodes"
|
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnOnViewportClicked.rst | .. _omni_graph_ui_nodes_OnViewportClicked_1:
.. _omni_graph_ui_nodes_OnViewportClicked:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: On Viewport Clicked (BETA)
:keywords: lang-en omnigraph node graph:action,ui threadsafe compute-on-request ui_nodes on-viewport-clicked
On Viewport Clicked (BETA)
==========================
.. <description>
Event node which fires when a viewport click event occurs in the specified viewport. Note that viewport mouse events must be enabled on the specified viewport using a SetViewportMode node.
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Gesture (*inputs:gesture*)", "``token``", "The input gesture to trigger viewport click events", "Left Mouse Click"
"", "*displayGroup*", "parameters", ""
"", "*literalOnly*", "1", ""
"", "*allowedTokens*", "Left Mouse Click,Right Mouse Click,Middle Mouse Click", ""
"Only Simulate On Play (*inputs:onlyPlayback*)", "``bool``", "When true, the node is only computed while Stage is being played", "True"
"", "*literalOnly*", "1", ""
"Use Normalized Coords (*inputs:useNormalizedCoords*)", "``bool``", "When true, the components of the 2D position output are scaled to between 0 and 1, where 0 is top/left and 1 is bottom/right. When false, components are in viewport render resolution pixels.", "False"
"", "*literalOnly*", "1", ""
"Viewport (*inputs:viewport*)", "``token``", "Name of the viewport window to watch for click events", "Viewport"
"", "*literalOnly*", "1", ""
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Clicked (*outputs:clicked*)", "``execution``", "Enabled when the specified input gesture triggers a viewport click event in the specified viewport", "None"
"Position (*outputs:position*)", "``double[2]``", "The position at which the viewport click event occurred", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.OnViewportClicked"
"Version", "1"
"Extension", "omni.graph.ui_nodes"
"Has State?", "False"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "On Viewport Clicked (BETA)"
"Categories", "graph:action,ui"
"Generated Class Name", "OgnOnViewportClickedDatabase"
"Python Module", "omni.graph.ui_nodes"
|
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnReadViewportPressState.rst | .. _omni_graph_ui_nodes_ReadViewportPressState_1:
.. _omni_graph_ui_nodes_ReadViewportPressState:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Read Viewport Press State (BETA)
:keywords: lang-en omnigraph node ui threadsafe ui_nodes read-viewport-press-state
Read Viewport Press State (BETA)
================================
.. <description>
Read the state of the last viewport press event from the specified viewport. Note that viewport mouse events must be enabled on the specified viewport using a SetViewportMode node.
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Gesture (*inputs:gesture*)", "``token``", "The input gesture to trigger viewport press events", "Left Mouse Press"
"", "*displayGroup*", "parameters", ""
"", "*allowedTokens*", "Left Mouse Press,Right Mouse Press,Middle Mouse Press", ""
"Use Normalized Coords (*inputs:useNormalizedCoords*)", "``bool``", "When true, the components of 2D position outputs are scaled to between 0 and 1, where 0 is top/left and 1 is bottom/right. When false, components are in viewport render resolution pixels.", "False"
"Viewport (*inputs:viewport*)", "``token``", "Name of the viewport window to watch for press events", "Viewport"
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Is Pressed (*outputs:isPressed*)", "``bool``", "True if the specified viewport is currently pressed", "None"
"Is Release Position Valid (*outputs:isReleasePositionValid*)", "``bool``", "True if the press was released inside of the viewport, and false otherwise", "None"
"Is Valid (*outputs:isValid*)", "``bool``", "True if a valid event state was detected and the outputs of this node are valid, and false otherwise", "None"
"Press Position (*outputs:pressPosition*)", "``double[2]``", "The position at which the specified viewport was last pressed", "None"
"Release Position (*outputs:releasePosition*)", "``double[2]``", "The position at which the last press on the specified viewport was released, or (0,0) if the press was released outside of the viewport or the viewport is currently pressed", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.ReadViewportPressState"
"Version", "1"
"Extension", "omni.graph.ui_nodes"
"Has State?", "False"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "Read Viewport Press State (BETA)"
"Categories", "ui"
"Generated Class Name", "OgnReadViewportPressStateDatabase"
"Python Module", "omni.graph.ui_nodes"
|
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnGetViewportResolution.rst | .. _omni_graph_ui_nodes_GetViewportResolution_1:
.. _omni_graph_ui_nodes_GetViewportResolution:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Get Viewport Resolution
:keywords: lang-en omnigraph node viewport ui_nodes get-viewport-resolution
Get Viewport Resolution
=======================
.. <description>
Gets the resolution of the target viewport.
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Viewport (*inputs:viewport*)", "``token``", "Name of the viewport, or empty for the default viewport", "Viewport"
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Resolution (*outputs:resolution*)", "``int[2]``", "The resolution of the target viewport", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.GetViewportResolution"
"Version", "1"
"Extension", "omni.graph.ui_nodes"
"Has State?", "False"
"Implementation Language", "Python"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "Get Viewport Resolution"
"Categories", "viewport"
"Generated Class Name", "OgnGetViewportResolutionDatabase"
"Python Module", "omni.graph.ui_nodes"
|
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnSetCameraPosition.rst | .. _omni_graph_ui_nodes_SetCameraPosition_2:
.. _omni_graph_ui_nodes_SetCameraPosition:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Set Camera Position
:keywords: lang-en omnigraph node sceneGraph:camera WriteOnly ui_nodes set-camera-position
Set Camera Position
===================
.. <description>
Sets the camera's position
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"In (*inputs:execIn*)", "``execution``", "Execution input", "None"
"Position (*inputs:position*)", "``pointd[3]``", "The new position", "[0.0, 0.0, 0.0]"
"inputs:prim", "``target``", "The camera prim, when 'usePath' is false", "None"
"Camera Path (*inputs:primPath*)", "``token``", "Path of the camera, used when 'usePath' is true", ""
"Rotate (*inputs:rotate*)", "``bool``", "True to keep position but change orientation and radius (camera moves to new position while still looking at the same target). False to keep orientation and radius but change position (camera moves to look at new target).", "True"
"inputs:usePath", "``bool``", "When true, the 'primPath' attribute is used as the path to the prim being read, otherwise it will read the connection at the 'prim' attribute", "True"
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Out (*outputs:execOut*)", "``execution``", "Execution Output", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.SetCameraPosition"
"Version", "2"
"Extension", "omni.graph.ui_nodes"
"Has State?", "False"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "Set Camera Position"
"Categories", "sceneGraph:camera"
"Generated Class Name", "OgnSetCameraPositionDatabase"
"Python Module", "omni.graph.ui_nodes"
|
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnSetViewportFullscreen.rst | .. _omni_graph_ui_nodes_SetViewportFullscreen_1:
.. _omni_graph_ui_nodes_SetViewportFullscreen:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Set Viewport Fullscreen
:keywords: lang-en omnigraph node graph:action,viewport WriteOnly ui_nodes set-viewport-fullscreen
Set Viewport Fullscreen
=======================
.. <description>
Toggles fullscreen on/off for viewport(s) and visibility on/off for all other panes.
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"inputs:exec", "``execution``", "The input execution", "None"
"Mode (*inputs:mode*)", "``token``", "The mode to toggle fullscreen on/off for viewport(s) and visibility on/off for all other panes: ""Default"" - Windowed viewport(s) with all other panes shown. ""Fullscreen"" - Fullscreen viewport(s) with all other panes hidden. ""Hide UI"" - Windowed viewport(s) with all other panes hidden.", "Default"
"", "*allowedTokens*", "Default,Fullscreen,Hide UI", ""
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"outputs:exec", "``execution``", "The output execution", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.SetViewportFullscreen"
"Version", "1"
"Extension", "omni.graph.ui_nodes"
"Has State?", "False"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "Set Viewport Fullscreen"
"Categories", "graph:action,viewport"
"Generated Class Name", "OgnSetViewportFullscreenDatabase"
"Python Module", "omni.graph.ui_nodes"
|
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnSlider.rst | .. _omni_graph_ui_nodes_Slider_1:
.. _omni_graph_ui_nodes_Slider:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Slider (BETA)
:keywords: lang-en omnigraph node graph:action,ui ui_nodes slider
Slider (BETA)
=============
.. <description>
Create a slider widget on the Viewport
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Create (*inputs:create*)", "``execution``", "Input execution to create and show the widget", "None"
"Disable (*inputs:disable*)", "``execution``", "Disable this button so that it cannot be pressed", "None"
"Enable (*inputs:enable*)", "``execution``", "Enable this button after it has been disabled", "None"
"Hide (*inputs:hide*)", "``execution``", "Input execution to hide the widget and all its child widgets", "None"
"Max (*inputs:max*)", "``float``", "The maximum value of the slider", "0.0"
"Min (*inputs:min*)", "``float``", "The minimum value of the slider", "0.0"
"Parent Widget Path (*inputs:parentWidgetPath*)", "``token``", "The absolute path to the parent widget. If empty, this widget will be created as a direct child of Viewport.", "None"
"Show (*inputs:show*)", "``execution``", "Input execution to show the widget and all its child widgets after they become hidden", "None"
"Step (*inputs:step*)", "``float``", "The step size of the slider", "0.01"
"Tear Down (*inputs:tearDown*)", "``execution``", "Input execution to tear down the widget and all its child widgets", "None"
"Widget Identifier (*inputs:widgetIdentifier*)", "``token``", "An optional unique identifier for the widget. Can be used to refer to this widget in other places such as the OnWidgetClicked node.", "None"
"Width (*inputs:width*)", "``double``", "The width of the created slider", "100.0"
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Created (*outputs:created*)", "``execution``", "Executed when the widget is created", "None"
"Widget Path (*outputs:widgetPath*)", "``token``", "The absolute path to the created widget", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.Slider"
"Version", "1"
"Extension", "omni.graph.ui_nodes"
"Has State?", "False"
"Implementation Language", "Python"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"hidden", "True"
"uiName", "Slider (BETA)"
"Categories", "graph:action,ui"
"Generated Class Name", "OgnSliderDatabase"
"Python Module", "omni.graph.ui_nodes"
|
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnReadMouseState.rst | .. _omni_graph_ui_nodes_ReadMouseState_1:
.. _omni_graph_ui_nodes_ReadMouseState:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Read Mouse State
:keywords: lang-en omnigraph node input:mouse threadsafe ui_nodes read-mouse-state
Read Mouse State
================
.. <description>
Reads the current state of the mouse. You can choose which mouse element this node is associated with. When mouse element is chosen to be a button, only outputs:isPressed is meaningful. When coordinates are chosen, only outputs:coords and outputs:window are meaningful.
Pixel coordinates are the position of the mouse cursor in screen pixel units with (0,0) top left. Normalized coordinates are values between 0-1 where 0 is top/left and 1 is bottom/right. By default, coordinates are relative to the application window, but if 'Use Relative Coords' is set to true, then coordinates are relative to the workspace window containing the mouse pointer.
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Mouse Element (*inputs:mouseElement*)", "``token``", "The mouse input to check the state of", "Left Button"
"", "*displayGroup*", "parameters", ""
"", "*allowedTokens*", "Left Button,Right Button,Middle Button,Forward Button,Back Button,Normalized Mouse Coordinates,Pixel Mouse Coordinates", ""
"Use Relative Coords (*inputs:useRelativeCoords*)", "``bool``", "When true, the output 'coords' is made relative to the workspace window containing the mouse pointer instead of the entire application window", "False"
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"outputs:coords", "``float[2]``", "The coordinates of the mouse. If the mouse element selected is a button, this will output a zero vector.", "None"
"outputs:isPressed", "``bool``", "True if the button is currently pressed, false otherwise. If the mouse element selected is a coordinate, this will output false.", "None"
"outputs:window", "``token``", "The name of the workspace window containing the mouse pointer if 'Use Relative Coords' is true and the mouse element selected is a coordinate", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.ReadMouseState"
"Version", "1"
"Extension", "omni.graph.ui_nodes"
"Has State?", "False"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "Read Mouse State"
"Categories", "input:mouse"
"Generated Class Name", "OgnReadMouseStateDatabase"
"Python Module", "omni.graph.ui_nodes"
|
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnSetCameraTarget.rst | .. _omni_graph_ui_nodes_SetCameraTarget_2:
.. _omni_graph_ui_nodes_SetCameraTarget:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Set Camera Target
:keywords: lang-en omnigraph node sceneGraph:camera WriteOnly ui_nodes set-camera-target
Set Camera Target
=================
.. <description>
Sets the camera's target
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"In (*inputs:execIn*)", "``execution``", "Execution input", "None"
"inputs:prim", "``target``", "The camera prim, when 'usePath' is false", "None"
"Camera Path (*inputs:primPath*)", "``token``", "Path of the camera, used when 'usePath' is true", ""
"Rotate (*inputs:rotate*)", "``bool``", "True to keep position but change orientation and radius (camera rotates to look at new target). False to keep orientation and radius but change position (camera moves to look at new target).", "True"
"Target (*inputs:target*)", "``pointd[3]``", "The target point", "[0.0, 0.0, 0.0]"
"inputs:usePath", "``bool``", "When true, the 'primPath' attribute is used as the path to the prim being read, otherwise it will read the connection at the 'prim' attribute", "True"
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Out (*outputs:execOut*)", "``execution``", "Execution Output", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.SetCameraTarget"
"Version", "2"
"Extension", "omni.graph.ui_nodes"
"Has State?", "False"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "Set Camera Target"
"Categories", "sceneGraph:camera"
"Generated Class Name", "OgnSetCameraTargetDatabase"
"Python Module", "omni.graph.ui_nodes"
|
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnSetViewportMode.rst | .. _omni_graph_ui_nodes_SetViewportMode_1:
.. _omni_graph_ui_nodes_SetViewportMode:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Set Viewport Mode (BETA)
:keywords: lang-en omnigraph node graph:action,ui ui_nodes set-viewport-mode
Set Viewport Mode (BETA)
========================
.. <description>
Sets the mode of a specified viewport window to 'Scripted' mode or 'Default' mode when executed.
'Scripted' mode disables default viewport interaction and enables placing UI elements over the viewport. 'Default' mode is the default state of the viewport, and entering it will destroy any UI elements on the viewport.
Executing with 'Enable Viewport Mouse Events' set to true in 'Scripted' mode is required to allow the specified viewport to be targeted by viewport mouse event nodes, including 'On Viewport Dragged' and 'Read Viewport Drag State'.
Executing with 'Enable Picking' set to true in 'Scripted' mode is required to allow the specified viewport to be targeted by the 'On Picked' and 'Read Pick State' nodes.
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Enable Picking (*inputs:enablePicking*)", "``bool``", "Enable/Disable picking prims in the specified viewport when in 'Scripted' mode", "False"
"Enable Viewport Mouse Events (*inputs:enableViewportMouseEvents*)", "``bool``", "Enable/Disable viewport mouse events on the specified viewport when in 'Scripted' mode", "False"
"inputs:execIn", "``execution``", "Input execution", "None"
"Mode (*inputs:mode*)", "``int``", "The mode to set the specified viewport to when this node is executed (0: 'Default', 1: 'Scripted')", "0"
"Pass Clicks Thru (*inputs:passClicksThru*)", "``bool``", "Allow mouse clicks to affect the viewport while in 'Scripted' mode. In 'Scripted' mode mouse clicks are prevented from reaching the viewport to avoid accidentally selecting prims or interacting with the viewport's own UI. Setting this attribute true will allow clicks to reach the viewport. This is in addition to interacting with the widgets created by UI nodes so if a button widget appears on top of some geometry in the viewport, clicking on the button will not only trigger the button but could also select the geometry. To avoid this, put the button inside a Stack widget and use a WriteWidgetProperty node to set the Stack's 'content_clipping' property to 1.", "False"
"Viewport (*inputs:viewport*)", "``token``", "Name of the viewport window to set the mode of", "Viewport"
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Default Mode (*outputs:defaultMode*)", "``execution``", "Fires when this node is successfully executed with 'Mode' set to 'Default'", "None"
"Scripted Mode (*outputs:scriptedMode*)", "``execution``", "Fires when this node is successfully executed with 'Mode' set to 'Scripted'", "None"
"Widget Path (*outputs:widgetPath*)", "``token``", "When the viewport enters 'Scripted' mode, a container widget is created under which other UI may be parented. This attribute provides the absolute path to that widget, which can be used as the 'parentWidgetPath' input to various UI nodes, such as Button. When the viewport exits 'Scripted' mode, the container widget and all the UI within it will be destroyed.", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.SetViewportMode"
"Version", "1"
"Extension", "omni.graph.ui_nodes"
"Has State?", "False"
"Implementation Language", "Python"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "Set Viewport Mode (BETA)"
"Categories", "graph:action,ui"
"Generated Class Name", "OgnSetViewportModeDatabase"
"Python Module", "omni.graph.ui_nodes"
|
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnReadViewportDragState.rst | .. _omni_graph_ui_nodes_ReadViewportDragState_1:
.. _omni_graph_ui_nodes_ReadViewportDragState:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Read Viewport Drag State (BETA)
:keywords: lang-en omnigraph node ui threadsafe ui_nodes read-viewport-drag-state
Read Viewport Drag State (BETA)
===============================
.. <description>
Read the state of the last viewport drag event from the specified viewport. Note that viewport mouse events must be enabled on the specified viewport using a SetViewportMode node.
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Gesture (*inputs:gesture*)", "``token``", "The input gesture to trigger viewport drag events", "Left Mouse Drag"
"", "*displayGroup*", "parameters", ""
"", "*allowedTokens*", "Left Mouse Drag,Right Mouse Drag,Middle Mouse Drag", ""
"Use Normalized Coords (*inputs:useNormalizedCoords*)", "``bool``", "When true, the components of 2D position and velocity outputs are scaled to between 0 and 1, where 0 is top/left and 1 is bottom/right. When false, components are in viewport render resolution pixels.", "False"
"Viewport (*inputs:viewport*)", "``token``", "Name of the viewport window to watch for drag events", "Viewport"
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Current Position (*outputs:currentPosition*)", "``double[2]``", "The current mouse position if a drag is in progress, or the final mouse position of the most recent drag if a drag is not in progress", "None"
"Initial Position (*outputs:initialPosition*)", "``double[2]``", "The mouse position at which the most recent drag began", "None"
"Is Drag In Progress (*outputs:isDragInProgress*)", "``bool``", "True if a viewport drag event is currently in progress in the specified viewport", "None"
"Is Valid (*outputs:isValid*)", "``bool``", "True if a valid event state was detected and the outputs of this node are valid, and false otherwise", "None"
"Velocity (*outputs:velocity*)", "``double[2]``", "A vector representing the change in position of the mouse since the previous frame if a drag is in progress, otherwise (0,0)", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.ReadViewportDragState"
"Version", "1"
"Extension", "omni.graph.ui_nodes"
"Has State?", "False"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "Read Viewport Drag State (BETA)"
"Categories", "ui"
"Generated Class Name", "OgnReadViewportDragStateDatabase"
"Python Module", "omni.graph.ui_nodes"
|
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnSetViewportRenderer.rst | .. _omni_graph_ui_nodes_SetViewportRenderer_1:
.. _omni_graph_ui_nodes_SetViewportRenderer:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Set Viewport Renderer
:keywords: lang-en omnigraph node graph:action,viewport ui_nodes set-viewport-renderer
Set Viewport Renderer
=====================
.. <description>
Sets renderer for the target viewport.
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"inputs:exec", "``execution``", "The input execution", "None"
"Renderer (*inputs:renderer*)", "``token``", "Renderer to be assigned to the target viewport", ""
"Viewport (*inputs:viewport*)", "``token``", "Name of the viewport, or empty for the default viewport", "Viewport"
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"outputs:exec", "``execution``", "The output execution", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.SetViewportRenderer"
"Version", "1"
"Extension", "omni.graph.ui_nodes"
"Has State?", "False"
"Implementation Language", "Python"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "Set Viewport Renderer"
"Categories", "graph:action,viewport"
"Generated Class Name", "OgnSetViewportRendererDatabase"
"Python Module", "omni.graph.ui_nodes"
|
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnComboBox.rst | .. _omni_graph_ui_nodes_ComboBox_1:
.. _omni_graph_ui_nodes_ComboBox:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Combo Box (BETA)
:keywords: lang-en omnigraph node graph:action,ui ui_nodes combo-box
Combo Box (BETA)
================
.. <description>
Create a combo box widget on the Viewport
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Create (*inputs:create*)", "``execution``", "Input execution to create and show the widget", "None"
"Disable (*inputs:disable*)", "``execution``", "Disable this button so that it cannot be pressed", "None"
"Enable (*inputs:enable*)", "``execution``", "Enable this button after it has been disabled", "None"
"Hide (*inputs:hide*)", "``execution``", "Input execution to hide the widget and all its child widgets", "None"
"Item List (*inputs:itemList*)", "``token[]``", "A list of items that appears in the drop-down list", "[]"
"Parent Widget Path (*inputs:parentWidgetPath*)", "``token``", "The absolute path to the parent widget. If empty, this widget will be created as a direct child of Viewport.", "None"
"Show (*inputs:show*)", "``execution``", "Input execution to show the widget and all its child widgets after they become hidden", "None"
"Tear Down (*inputs:tearDown*)", "``execution``", "Input execution to tear down the widget and all its child widgets", "None"
"Widget Identifier (*inputs:widgetIdentifier*)", "``token``", "An optional unique identifier for the widget. Can be used to refer to this widget in other places such as the OnWidgetClicked node.", "None"
"Width (*inputs:width*)", "``double``", "The width of the created combo box", "100.0"
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Created (*outputs:created*)", "``execution``", "Executed when the widget is created", "None"
"Widget Path (*outputs:widgetPath*)", "``token``", "The absolute path to the created widget", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.ComboBox"
"Version", "1"
"Extension", "omni.graph.ui_nodes"
"Has State?", "False"
"Implementation Language", "Python"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"hidden", "True"
"uiName", "Combo Box (BETA)"
"Categories", "graph:action,ui"
"Generated Class Name", "OgnComboBoxDatabase"
"Python Module", "omni.graph.ui_nodes"
|
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnSetViewportResolution.rst | .. _omni_graph_ui_nodes_SetViewportResolution_1:
.. _omni_graph_ui_nodes_SetViewportResolution:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Set Viewport Resolution
:keywords: lang-en omnigraph node graph:action,viewport ui_nodes set-viewport-resolution
Set Viewport Resolution
=======================
.. <description>
Sets the resolution of the target viewport.
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"inputs:exec", "``execution``", "The input execution", "None"
"Resolution (*inputs:resolution*)", "``int[2]``", "The new resolution of the target viewport", "[512, 512]"
"Viewport (*inputs:viewport*)", "``token``", "Name of the viewport, or empty for the default viewport", "Viewport"
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"outputs:exec", "``execution``", "The output execution", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.SetViewportResolution"
"Version", "1"
"Extension", "omni.graph.ui_nodes"
"Has State?", "False"
"Implementation Language", "Python"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "Set Viewport Resolution"
"Categories", "graph:action,viewport"
"Generated Class Name", "OgnSetViewportResolutionDatabase"
"Python Module", "omni.graph.ui_nodes"
|
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnGetActiveViewportCamera.rst | .. _omni_graph_ui_nodes_GetActiveViewportCamera_2:
.. _omni_graph_ui_nodes_GetActiveViewportCamera:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Get Active Camera
:keywords: lang-en omnigraph node sceneGraph:camera ui_nodes get-active-viewport-camera
Get Active Camera
=================
.. <description>
Gets the path of the camera bound to a viewport
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Viewport (*inputs:viewport*)", "``token``", "Name of the viewport, or empty for the default viewport", ""
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Camera (*outputs:camera*)", "``token``", "Path of the active camera", "None"
"Camera Prim (*outputs:cameraPrim*)", "``target``", "The prim of the active camera", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.GetActiveViewportCamera"
"Version", "2"
"Extension", "omni.graph.ui_nodes"
"Has State?", "False"
"Implementation Language", "Python"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "Get Active Camera"
"Categories", "sceneGraph:camera"
"Generated Class Name", "OgnGetActiveViewportCameraDatabase"
"Python Module", "omni.graph.ui_nodes"
|
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnSpacer.rst | .. _omni_graph_ui_nodes_Spacer_1:
.. _omni_graph_ui_nodes_Spacer:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Spacer (BETA)
:keywords: lang-en omnigraph node graph:action,ui ui_nodes spacer
Spacer (BETA)
=============
.. <description>
A widget that leaves empty space.
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Create (*inputs:create*)", "``execution``", "Input execution to create and show the widget", "None"
"Height (*inputs:height*)", "``int``", "The amount of vertical space to leave, in pixels.", "0"
"Parent Widget Path (*inputs:parentWidgetPath*)", "``token``", "The absolute path to the parent widget.", ""
"inputs:style", "``string``", "Style to be applied to the spacer. This can later be changed with the WriteWidgetStyle node.", "None"
"Widget Identifier (*inputs:widgetIdentifier*)", "``token``", "An optional unique identifier for the widget. Can be used to refer to this widget in other places such as the OnWidgetClicked node.", "None"
"Width (*inputs:width*)", "``int``", "The amount of horizontal space to leave, in pixels.", "0"
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Created (*outputs:created*)", "``execution``", "Executed when the widget is created", "None"
"Widget Path (*outputs:widgetPath*)", "``token``", "The absolute path to the created widget", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.Spacer"
"Version", "1"
"Extension", "omni.graph.ui_nodes"
"Has State?", "False"
"Implementation Language", "Python"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "Spacer (BETA)"
"Categories", "graph:action,ui"
"Generated Class Name", "OgnSpacerDatabase"
"Python Module", "omni.graph.ui_nodes"
|
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnReadPickState.rst | .. _omni_graph_ui_nodes_ReadPickState_2:
.. _omni_graph_ui_nodes_ReadPickState:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Read Pick State (BETA)
:keywords: lang-en omnigraph node ui threadsafe ui_nodes read-pick-state
Read Pick State (BETA)
======================
.. <description>
Read the state of the last picking event from the specified viewport. Note that picking events must be enabled on the specified viewport using a SetViewportMode node.
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Gesture (*inputs:gesture*)", "``token``", "The input gesture to trigger a picking event", "Left Mouse Click"
"", "*displayGroup*", "parameters", ""
"", "*allowedTokens*", "Left Mouse Click,Right Mouse Click,Middle Mouse Click,Left Mouse Press,Right Mouse Press,Middle Mouse Press", ""
"Tracked Prim Paths (*inputs:trackedPrimPaths*)", "``token[]``", "Optionally specify a set of prims (by paths) to track whether or not they got picked (only affects the value of 'Is Tracked Prim Picked')", "None"
"Tracked Prims (*inputs:trackedPrims*)", "``target``", "Optionally specify a set of prims to track whether or not they got picked (only affects the value of 'Is Tracked Prim Picked')", "None"
"", "*allowMultiInputs*", "1", ""
"Use Paths (*inputs:usePaths*)", "``bool``", "When true, 'Tracked Prim Paths' is used, otherwise 'Tracked Prims' is used", "False"
"Viewport (*inputs:viewport*)", "``token``", "Name of the viewport window to watch for picking events", "Viewport"
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Is Tracked Prim Picked (*outputs:isTrackedPrimPicked*)", "``bool``", "True if a tracked prim got picked in the last picking event, or if any prim got picked if no tracked prims are specified", "None"
"Is Valid (*outputs:isValid*)", "``bool``", "True if a valid event state was detected and the outputs of this node are valid, and false otherwise", "None"
"Picked Prim (*outputs:pickedPrim*)", "``target``", "The picked prim, or an empty target if nothing got picked", "None"
"Picked Prim Path (*outputs:pickedPrimPath*)", "``token``", "The path of the prim picked in the last picking event, or an empty string if nothing got picked", "None"
"Picked World Position (*outputs:pickedWorldPos*)", "``pointd[3]``", "The XYZ-coordinates of the point in world space at which the prim got picked, or (0,0,0) if nothing got picked", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.ReadPickState"
"Version", "2"
"Extension", "omni.graph.ui_nodes"
"Has State?", "False"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "Read Pick State (BETA)"
"Categories", "ui"
"Generated Class Name", "OgnReadPickStateDatabase"
"Python Module", "omni.graph.ui_nodes"
|
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnButton.rst | .. _omni_graph_ui_nodes_Button_1:
.. _omni_graph_ui_nodes_Button:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Button (BETA)
:keywords: lang-en omnigraph node graph:action,ui ui_nodes button
Button (BETA)
=============
.. <description>
Create a button widget on the Viewport
.. </description>
Here is an example of a button that was created using the text ``Press Me``:
.. image:: ../../../../../source/extensions/omni.graph.ui_nodes/docs/PressMe.png
:alt: "Press Me" Button
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Create (*inputs:create*)", "``execution``", "Input execution to create and show the widget", "None"
"Parent Widget Path (*inputs:parentWidgetPath*)", "``token``", "The absolute path to the parent widget.", ""
"Size (*inputs:size*)", "``double[2]``", "The width and height of the created widget. Value of 0 means the created widget will be just large enough to fit everything.", "[0.0, 0.0]"
"Start Hidden (*inputs:startHidden*)", "``bool``", "Determines whether the button will initially be visible (False) or not (True).", "False"
"inputs:style", "``string``", "Style to be applied to the button. This can later be changed with the WriteWidgetStyle node.", "None"
"Text (*inputs:text*)", "``string``", "The text that is displayed on the button", "None"
"Widget Identifier (*inputs:widgetIdentifier*)", "``token``", "An optional unique identifier for the widget. Can be used to refer to this widget in other places such as the OnWidgetClicked node.", "None"
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Created (*outputs:created*)", "``execution``", "Executed when the widget is created", "None"
"Widget Path (*outputs:widgetPath*)", "``token``", "The absolute path to the created widget", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.Button"
"Version", "1"
"Extension", "omni.graph.ui_nodes"
"Has State?", "False"
"Implementation Language", "Python"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "Button (BETA)"
"Categories", "graph:action,ui"
"Generated Class Name", "OgnButtonDatabase"
"Python Module", "omni.graph.ui_nodes"
Further information on the button operation can be found in the documentation of :py:class:`omni.ui.Button`.
|
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnWriteWidgetProperty.rst | .. _omni_graph_ui_nodes_WriteWidgetProperty_1:
.. _omni_graph_ui_nodes_WriteWidgetProperty:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Write Widget Property (BETA)
:keywords: lang-en omnigraph node graph:action,ui ui_nodes write-widget-property
Write Widget Property (BETA)
============================
.. <description>
Set the value of a widget's property (height, tooltip, etc).
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Property Name (*inputs:propertyName*)", "``token``", "Name of the property to write to.", ""
"Value (*inputs:value*)", "``any``", "The value to write to the property.", "None"
"Widget Identifier (*inputs:widgetIdentifier*)", "``token``", "Unique identifier for the widget. This is only valid within the current graph.", ""
"Widget Path (*inputs:widgetPath*)", "``token``", "Full path to the widget. If present this will be used insted of 'widgetIdentifier'. Unlike 'widgetIdentifier' this is valid across all graphs.", ""
"Write (*inputs:write*)", "``execution``", "Input execution to write the value to the widget's property.", "None"
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"outputs:written", "``execution``", "Executed when the value has been successfully written.", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.WriteWidgetProperty"
"Version", "1"
"Extension", "omni.graph.ui_nodes"
"Has State?", "False"
"Implementation Language", "Python"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "Write Widget Property (BETA)"
"Categories", "graph:action,ui"
"Generated Class Name", "OgnWriteWidgetPropertyDatabase"
"Python Module", "omni.graph.ui_nodes"
|
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnPrintText.rst | .. _omni_graph_ui_nodes_PrintText_1:
.. _omni_graph_ui_nodes_PrintText:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Print Text
:keywords: lang-en omnigraph node debug ui_nodes print-text
Print Text
==========
.. <description>
Prints some text to the system log or to the screen
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"In (*inputs:execIn*)", "``execution``", "Execution input", "None"
"Log Level (*inputs:logLevel*)", "``token``", "The logging level for the message [Info, Warning, Error]", "Info"
"", "*allowedTokens*", "Info,Warning,Error", ""
"Text (*inputs:text*)", "``string``", "The text to print", ""
"To Screen (*inputs:toScreen*)", "``bool``", "When true, displays the text on the viewport for a few seconds, as well as the log", "False"
"Viewport (*inputs:viewport*)", "``token``", "Name of the viewport if printing to screen, or empty for the default viewport", ""
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Out (*outputs:execOut*)", "``execution``", "Execution Output", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.PrintText"
"Version", "1"
"Extension", "omni.graph.ui_nodes"
"Has State?", "False"
"Implementation Language", "Python"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"tags", "logging,toast,debug"
"uiName", "Print Text"
"Categories", "debug"
"Generated Class Name", "OgnPrintTextDatabase"
"Python Module", "omni.graph.ui_nodes"
|
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnOnWidgetClicked.rst | .. _omni_graph_ui_nodes_OnWidgetClicked_1:
.. _omni_graph_ui_nodes_OnWidgetClicked:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: On Widget Clicked (BETA)
:keywords: lang-en omnigraph node graph:action,ui compute-on-request ui_nodes on-widget-clicked
On Widget Clicked (BETA)
========================
.. <description>
Event node which fires when a UI widget with the specified identifier is clicked. This node should be used in combination with UI creation nodes such as OgnButton.
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Widget Identifier (*inputs:widgetIdentifier*)", "``token``", "A unique identifier identifying the widget. This should be specified in the UI creation node such as OgnButton.", ""
"", "*literalOnly*", "1", ""
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Clicked (*outputs:clicked*)", "``execution``", "Executed when the widget is clicked", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.OnWidgetClicked"
"Version", "1"
"Extension", "omni.graph.ui_nodes"
"Has State?", "True"
"Implementation Language", "Python"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "On Widget Clicked (BETA)"
"Categories", "graph:action,ui"
"Generated Class Name", "OgnOnWidgetClickedDatabase"
"Python Module", "omni.graph.ui_nodes"
|
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnVStack.rst | .. _omni_graph_ui_nodes_VStack_1:
.. _omni_graph_ui_nodes_VStack:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Stack (BETA)
:keywords: lang-en omnigraph node graph:action,ui ui_nodes v-stack
Stack (BETA)
============
.. <description>
Contruct a Stack on the Viewport. All child widgets of Stack will be placed in a row, column or layer based on the direction input.
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Create (*inputs:create*)", "``execution``", "Input execution to create and show the widget", "None"
"Direction (*inputs:direction*)", "``token``", "The direction the widgets will be stacked.", "TOP_TO_BOTTOM"
"", "*allowedTokens*", "BACK_TO_FRONT,BOTTOM_TO_TOP,FRONT_TO_BACK,LEFT_TO_RIGHT,RIGHT_TO_LEFT,TOP_TO_BOTTOM", ""
"Parent Widget Path (*inputs:parentWidgetPath*)", "``token``", "The absolute path to the parent widget.", ""
"inputs:style", "``string``", "Style to be applied to the stack and its children. This can later be changed with the WriteWidgetStyle node.", "None"
"Widget Identifier (*inputs:widgetIdentifier*)", "``token``", "An optional unique identifier for the widget. Can be used to refer to this widget in other places such as the OnWidgetClicked node.", "None"
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Created (*outputs:created*)", "``execution``", "Executed when the widget is created", "None"
"Widget Path (*outputs:widgetPath*)", "``token``", "The absolute path to the created widget", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.VStack"
"Version", "1"
"Extension", "omni.graph.ui_nodes"
"Has State?", "False"
"Implementation Language", "Python"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "Stack (BETA)"
"Categories", "graph:action,ui"
"Generated Class Name", "OgnVStackDatabase"
"Python Module", "omni.graph.ui_nodes"
|
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnReadViewportHoverState.rst | .. _omni_graph_ui_nodes_ReadViewportHoverState_1:
.. _omni_graph_ui_nodes_ReadViewportHoverState:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Read Viewport Hover State (BETA)
:keywords: lang-en omnigraph node ui threadsafe ui_nodes read-viewport-hover-state
Read Viewport Hover State (BETA)
================================
.. <description>
Read the state of the last viewport hover event from the specified viewport. Note that viewport mouse events must be enabled on the specified viewport using a SetViewportMode node.
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Use Normalized Coords (*inputs:useNormalizedCoords*)", "``bool``", "When true, the components of 2D position and velocity outputs are scaled to between 0 and 1, where 0 is top/left and 1 is bottom/right. When false, components are in viewport render resolution pixels.", "False"
"Viewport (*inputs:viewport*)", "``token``", "Name of the viewport window to watch for hover events", "Viewport"
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Is Hovered (*outputs:isHovered*)", "``bool``", "True if the specified viewport is currently hovered", "None"
"Is Valid (*outputs:isValid*)", "``bool``", "True if a valid event state was detected and the outputs of this node are valid, and false otherwise", "None"
"Position (*outputs:position*)", "``double[2]``", "The current mouse position if the specified viewport is currently hovered, otherwise (0,0)", "None"
"Velocity (*outputs:velocity*)", "``double[2]``", "A vector representing the change in position of the mouse since the previous frame if the specified viewport is currently hovered, otherwise (0,0)", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.ReadViewportHoverState"
"Version", "1"
"Extension", "omni.graph.ui_nodes"
"Has State?", "False"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "Read Viewport Hover State (BETA)"
"Categories", "ui"
"Generated Class Name", "OgnReadViewportHoverStateDatabase"
"Python Module", "omni.graph.ui_nodes"
|
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnReadViewportClickState.rst | .. _omni_graph_ui_nodes_ReadViewportClickState_1:
.. _omni_graph_ui_nodes_ReadViewportClickState:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Read Viewport Click State (BETA)
:keywords: lang-en omnigraph node ui threadsafe ui_nodes read-viewport-click-state
Read Viewport Click State (BETA)
================================
.. <description>
Read the state of the last viewport click event from the specified viewport. Note that viewport mouse events must be enabled on the specified viewport using a SetViewportMode node.
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Gesture (*inputs:gesture*)", "``token``", "The input gesture to trigger viewport click events", "Left Mouse Click"
"", "*displayGroup*", "parameters", ""
"", "*allowedTokens*", "Left Mouse Click,Right Mouse Click,Middle Mouse Click", ""
"Use Normalized Coords (*inputs:useNormalizedCoords*)", "``bool``", "When true, the components of the 2D position output are scaled to between 0 and 1, where 0 is top/left and 1 is bottom/right. When false, components are in viewport render resolution pixels.", "False"
"Viewport (*inputs:viewport*)", "``token``", "Name of the viewport window to watch for click events", "Viewport"
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Is Valid (*outputs:isValid*)", "``bool``", "True if a valid event state was detected and the outputs of this node are valid, and false otherwise", "None"
"Position (*outputs:position*)", "``double[2]``", "The position at which the specified input gesture last triggered a viewport click event in the specified viewport", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.ReadViewportClickState"
"Version", "1"
"Extension", "omni.graph.ui_nodes"
"Has State?", "False"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "Read Viewport Click State (BETA)"
"Categories", "ui"
"Generated Class Name", "OgnReadViewportClickStateDatabase"
"Python Module", "omni.graph.ui_nodes"
|
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnGetViewportRenderer.rst | .. _omni_graph_ui_nodes_GetViewportRenderer_1:
.. _omni_graph_ui_nodes_GetViewportRenderer:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Get Viewport Renderer
:keywords: lang-en omnigraph node viewport ui_nodes get-viewport-renderer
Get Viewport Renderer
=====================
.. <description>
Gets the renderer being used by the target viewport.
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Viewport (*inputs:viewport*)", "``token``", "Name of the viewport, or empty for the default viewport", "Viewport"
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Renderer (*outputs:renderer*)", "``token``", "The renderer being used by the target viewport", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.GetViewportRenderer"
"Version", "1"
"Extension", "omni.graph.ui_nodes"
"Has State?", "False"
"Implementation Language", "Python"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "Get Viewport Renderer"
"Categories", "viewport"
"Generated Class Name", "OgnGetViewportRendererDatabase"
"Python Module", "omni.graph.ui_nodes"
|
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnWriteWidgetStyle.rst | .. _omni_graph_ui_nodes_WriteWidgetStyle_1:
.. _omni_graph_ui_nodes_WriteWidgetStyle:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Write Widget Style (BETA)
:keywords: lang-en omnigraph node graph:action,ui ReadOnly ui_nodes write-widget-style
Write Widget Style (BETA)
=========================
.. <description>
Sets a widget's style properties. This node should be used in combination with UI creation nodes such as Button.
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"inputs:style", "``string``", "The style to set the widget to.", ""
"Widget Identifier (*inputs:widgetIdentifier*)", "``token``", "A unique identifier identifying the widget. This is only valid within the current graph. This should be specified in the UI creation node such as OgnButton.", ""
"Widget Path (*inputs:widgetPath*)", "``token``", "Full path to the widget. If present this will be used insted of 'widgetIdentifier'. Unlike 'widgetIdentifier' this is valid across all graphs.", ""
"inputs:write", "``execution``", "Input execution", "None"
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"outputs:written", "``execution``", "Output execution", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.WriteWidgetStyle"
"Version", "1"
"Extension", "omni.graph.ui_nodes"
"Has State?", "False"
"Implementation Language", "Python"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "Write Widget Style (BETA)"
"Categories", "graph:action,ui"
"Generated Class Name", "OgnWriteWidgetStyleDatabase"
"Python Module", "omni.graph.ui_nodes"
|
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnOnViewportHovered.rst | .. _omni_graph_ui_nodes_OnViewportHovered_1:
.. _omni_graph_ui_nodes_OnViewportHovered:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: On Viewport Hovered (BETA)
:keywords: lang-en omnigraph node graph:action,ui threadsafe compute-on-request ui_nodes on-viewport-hovered
On Viewport Hovered (BETA)
==========================
.. <description>
Event node which fires when the specified viewport is hovered over. Note that viewport mouse events must be enabled on the specified viewport using a SetViewportMode node.
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Only Simulate On Play (*inputs:onlyPlayback*)", "``bool``", "When true, the node is only computed while Stage is being played", "True"
"", "*literalOnly*", "1", ""
"Viewport (*inputs:viewport*)", "``token``", "Name of the viewport window to watch for hover events", "Viewport"
"", "*literalOnly*", "1", ""
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Began (*outputs:began*)", "``execution``", "Enabled when the hover begins", "None"
"Ended (*outputs:ended*)", "``execution``", "Enabled when the hover ends", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.OnViewportHovered"
"Version", "1"
"Extension", "omni.graph.ui_nodes"
"Has State?", "False"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "On Viewport Hovered (BETA)"
"Categories", "graph:action,ui"
"Generated Class Name", "OgnOnViewportHoveredDatabase"
"Python Module", "omni.graph.ui_nodes"
|
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnOnViewportScrolled.rst | .. _omni_graph_ui_nodes_OnViewportScrolled_1:
.. _omni_graph_ui_nodes_OnViewportScrolled:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: On Viewport Scrolled (BETA)
:keywords: lang-en omnigraph node graph:action,ui threadsafe compute-on-request ui_nodes on-viewport-scrolled
On Viewport Scrolled (BETA)
===========================
.. <description>
Event node which fires when a viewport scroll event occurs in the specified viewport. Note that viewport mouse events must be enabled on the specified viewport using a SetViewportMode node.
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Only Simulate On Play (*inputs:onlyPlayback*)", "``bool``", "When true, the node is only computed while Stage is being played", "True"
"", "*literalOnly*", "1", ""
"Use Normalized Coords (*inputs:useNormalizedCoords*)", "``bool``", "When true, the components of the 2D position output are scaled to between 0 and 1, where 0 is top/left and 1 is bottom/right. When false, components are in viewport render resolution pixels.", "False"
"", "*literalOnly*", "1", ""
"Viewport (*inputs:viewport*)", "``token``", "Name of the viewport window to watch for scroll events", "Viewport"
"", "*literalOnly*", "1", ""
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Position (*outputs:position*)", "``double[2]``", "The position at which the viewport scroll event occurred", "None"
"Scroll Value (*outputs:scrollValue*)", "``float``", "The number of mouse wheel clicks scrolled up if positive, or scrolled down if negative", "None"
"Scrolled (*outputs:scrolled*)", "``execution``", "Enabled when a viewport scroll event occurs in the specified viewport", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.OnViewportScrolled"
"Version", "1"
"Extension", "omni.graph.ui_nodes"
"Has State?", "False"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "On Viewport Scrolled (BETA)"
"Categories", "graph:action,ui"
"Generated Class Name", "OgnOnViewportScrolledDatabase"
"Python Module", "omni.graph.ui_nodes"
|
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnOnViewportPressed.rst | .. _omni_graph_ui_nodes_OnViewportPressed_1:
.. _omni_graph_ui_nodes_OnViewportPressed:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: On Viewport Pressed (BETA)
:keywords: lang-en omnigraph node graph:action,ui threadsafe compute-on-request ui_nodes on-viewport-pressed
On Viewport Pressed (BETA)
==========================
.. <description>
Event node which fires when the specified viewport is pressed, and when that press is released. Note that viewport mouse events must be enabled on the specified viewport using a SetViewportMode node.
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Gesture (*inputs:gesture*)", "``token``", "The input gesture to trigger viewport press events", "Left Mouse Press"
"", "*displayGroup*", "parameters", ""
"", "*literalOnly*", "1", ""
"", "*allowedTokens*", "Left Mouse Press,Right Mouse Press,Middle Mouse Press", ""
"Only Simulate On Play (*inputs:onlyPlayback*)", "``bool``", "When true, the node is only computed while Stage is being played", "True"
"", "*literalOnly*", "1", ""
"Use Normalized Coords (*inputs:useNormalizedCoords*)", "``bool``", "When true, the components of 2D position outputs are scaled to between 0 and 1, where 0 is top/left and 1 is bottom/right. When false, components are in viewport render resolution pixels.", "False"
"", "*literalOnly*", "1", ""
"Viewport (*inputs:viewport*)", "``token``", "Name of the viewport window to watch for press events", "Viewport"
"", "*literalOnly*", "1", ""
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Is Release Position Valid (*outputs:isReleasePositionValid*)", "``bool``", "True if the press was released inside of the viewport, and false otherwise", "None"
"Press Position (*outputs:pressPosition*)", "``double[2]``", "The position at which the viewport was pressed (valid when either 'Pressed' or 'Released' is enabled)", "None"
"Pressed (*outputs:pressed*)", "``execution``", "Enabled when the specified viewport is pressed, populating 'Press Position' with the current mouse position", "None"
"Release Position (*outputs:releasePosition*)", "``double[2]``", "The position at which the press was released, or (0,0) if the press was released outside of the viewport or the viewport is currently pressed (valid when 'Ended' is enabled and 'Is Release Position Valid' is true)", "None"
"Released (*outputs:released*)", "``execution``", "Enabled when the press is released, populating 'Release Position' with the current mouse position and setting 'Is Release Position Valid' to true if the press is released inside of the viewport. If the press is released outside of the viewport, 'Is Release Position Valid' is set to false and 'Release Position' is set to (0,0).", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.OnViewportPressed"
"Version", "1"
"Extension", "omni.graph.ui_nodes"
"Has State?", "False"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "On Viewport Pressed (BETA)"
"Categories", "graph:action,ui"
"Generated Class Name", "OgnOnViewportPressedDatabase"
"Python Module", "omni.graph.ui_nodes"
|
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnReadViewportScrollState.rst | .. _omni_graph_ui_nodes_ReadViewportScrollState_1:
.. _omni_graph_ui_nodes_ReadViewportScrollState:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Read Viewport Scroll State (BETA)
:keywords: lang-en omnigraph node ui threadsafe ui_nodes read-viewport-scroll-state
Read Viewport Scroll State (BETA)
=================================
.. <description>
Read the state of the last viewport scroll event from the specified viewport. Note that viewport mouse events must be enabled on the specified viewport using a SetViewportMode node.
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Use Normalized Coords (*inputs:useNormalizedCoords*)", "``bool``", "When true, the components of the 2D position output are scaled to between 0 and 1, where 0 is top/left and 1 is bottom/right. When false, components are in viewport render resolution pixels.", "False"
"Viewport (*inputs:viewport*)", "``token``", "Name of the viewport window to watch for scroll events", "Viewport"
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Is Valid (*outputs:isValid*)", "``bool``", "True if a valid event state was detected and the outputs of this node are valid, and false otherwise", "None"
"Position (*outputs:position*)", "``double[2]``", "The last position at which a viewport scroll event occurred in the specified viewport", "None"
"Scroll Value (*outputs:scrollValue*)", "``float``", "The number of mouse wheel clicks scrolled up if positive, or scrolled down if negative", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.ReadViewportScrollState"
"Version", "1"
"Extension", "omni.graph.ui_nodes"
"Has State?", "False"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "Read Viewport Scroll State (BETA)"
"Categories", "ui"
"Generated Class Name", "OgnReadViewportScrollStateDatabase"
"Python Module", "omni.graph.ui_nodes"
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.