file_path
stringlengths 21
202
| content
stringlengths 19
1.02M
| size
int64 19
1.02M
| lang
stringclasses 8
values | avg_line_length
float64 5.88
100
| max_line_length
int64 12
993
| alphanum_fraction
float64 0.27
0.93
|
|---|---|---|---|---|---|---|
omniverse-code/kit/exts/omni.kit.telemetry/omni.telemetry.transmitter/omni.telemetry.transmitter.config.toml | pluginsLoaded = [
"carb.dictionary.plugin",
"carb.settings.plugin",
"carb.dictionary.serializer-json.plugin"
]
[log]
level = "warn"
flushStandardStreamOutput = true
includeSource = true
setElapsedTimeUnits = "us"
includeThreadId = true
includeProcessId = true
includeTimeStamp = true
outputStream = "stderr"
[plugins]
[plugins."carb.scripting-python.plugin"]
"pythonHome" = "../../target-deps/python"
| 461 | TOML | 20.999999 | 50 | 0.663774 |
omniverse-code/kit/exts/omni.kit.telemetry/config/extension.toml | [package]
title = "Kit Telemetry"
category = "Telemetry"
version = "0.1.0"
description = "Telemetry for Omniverse Kit."
authors = ["NVIDIA"]
keywords = ["telemetry", "structured logging"]
[core]
order = -1000
[[python.module]]
name = "omni.kit.telemetry"
[[native.plugin]]
path = "bin/*.plugin"
[dependencies]
"omni.kit.pip_archive" = {}
[settings]
telemetry.logging.warnFilter = [ "*" ]
telemetry.enableNVDF = true
# enable this following option to send to the 'test' NVDF endpoint instead.
# telemetry.nvdfTestEndpoint = true
# Enable sending stack traces to Sentry
telemetry.enableSentry = false
[[test]]
# in the tests we'll be intentionally emitting error and fatal messages that will need to be
# ignored. List their patterns here.
stdoutFailPatterns.exclude = [
"*error log message*",
"*error apple muffin*",
"*fatal log message*",
"*fatal apple muffin*"
]
# the privacy settings for internal builds needs to be overridden so we can more reliably
# retrieve the session ID for some of the tests.
args = [
"--/privacy/externalBuild=false",
"--/exts/omni.kit.telemetry/skipDeferredStartup=true",
]
pyCoverageEnabled = false
pythonTests.unreliable = [
"*test_sysinfo_messages" # OM-52280
]
| 1,233 | TOML | 22.730769 | 92 | 0.712895 |
omniverse-code/kit/exts/omni.kit.telemetry/omni/kit/telemetry/__init__.py | """
Provides a helper interface to abstract and simplify some common telemetry related
tasks.
"""
import omni.core
from ._telemetry import *
from .impl import *
| 170 | Python | 17.999998 | 86 | 0.723529 |
omniverse-code/kit/exts/omni.kit.telemetry/omni/kit/telemetry/_telemetry.pyi | from __future__ import annotations
import omni.kit.telemetry._telemetry
import typing
import omni.core._core
__all__ = [
"ITelemetry",
"ITelemetry2",
"RunEnvironment"
]
class ITelemetry(_ITelemetry, omni.core._core.IObject):
"""
Interface to handle performing telemetry related tasks.
This provides an abstraction over the lower level telemetry and structured logging systems
and allows control over some common features of it.
"""
@typing.overload
def __init__(self, arg0: omni.core._core.IObject) -> None: ...
@typing.overload
def __init__(self) -> None: ...
def send_custom_event(self, eventType: str, duration: float = 0.0, data1: str = None, data2: str = None, value1: float = 0.0, value2: float = 0.0) -> None: ...
def send_generic_event(self, event_type: str, duration: float, data1: str, data2: str, value1: float, value2: float) -> None:
"""
Sends a generic structured log event with caller specified data.
@param[in] eventType A string describing the event that occurred. There is no
restriction on the content or formatting of this value.
This should neither be `nullptr` nor an empty string.
@param[in] duration A generic duration value that can be optionally included
with the event. It is the caller's respsonsibility to
decide on the usage and semantics of this value depending
on the @p eventType value. This may be 0.0 if no duration
value is needed for the event.
@param[in] data1 A string data value to be sent with the event. The contents
and interpretation of this string depend on the @p eventTyoe
value.
@param[in] data2 A string data value to be sent with the event. The contents
and interpretation of this string depend on the @p eventTyoe
value.
@param[in] value1 A floating point value to be sent with the event. This value
will be interpreted according to the @p eventType value.
@param[in] value2 A floating point value to be sent with the event. This value
will be interpreted according to the @p eventType value.
@returns No return value.
@remarks This sends a generic event to the structured logging log file. The contents,
semantics, and interpretation of this event are left entirely up to the caller.
This will be a no-op if telemetry is disabled (ie: the telemetry module either
intentionally was not loaded or failed to load).
"""
pass
class ITelemetry2(_ITelemetry2, omni.core._core.IObject):
"""
Interface to handle performing telemetry related tasks.
This provides an abstraction over the lower level telemetry and structured logging systems
and allows control over some common features of it.
"""
@typing.overload
def __init__(self, arg0: omni.core._core.IObject) -> None: ...
@typing.overload
def __init__(self) -> None: ...
def send_custom_event(self, eventType: str, duration: float = 0.0, data1: str = None, data2: str = None, value1: float = 0.0, value2: float = 0.0) -> None: ...
@property
def cloud_session(self) -> bool:
"""
:type: bool
"""
@property
def cloud_session_id(self) -> str:
"""
:type: str
"""
@property
def customer_id(self) -> str:
"""
:type: str
"""
@property
def run_environment(self) -> omni::telemetry::RunEnvironment:
"""
:type: omni::telemetry::RunEnvironment
"""
pass
class RunEnvironment():
"""
Names for the current Run environment used for telemetry.
Identifiers used to outline what kind of environment this process is currently running
in. This may be individual (OVI), cloud (OVC), or enterprise (OVE).
Members:
UNDETERMINED : The run environment has not been determined yet.
This indicates that the required startup events have not occurred yet or the run
environment could not be determined yet. An attempt to retrieve the run environment
should be made again at a later time.
INDIVIDUAL : Omniverse individual (OVI) desktop session.
This is typically installed and run through the Omniverse desktop launcher app.
Telemetry is enabled through this environment using the public Kratos authenticated
endpoint.
CLOUD : Omniverse Cloud (OVC) session.
This type of session is launched through the OVC services portal and the visual output
streamed over the network. Telemetry is enabled through this environment using a Kratos
authenticated endpoint specific to cloud deployments.
ENTERPRISE : Omniverse Enterprise (OVE) session.
This type of session is typically installed and run through the Omniverse enterprise
launcher app. Telemetry is enabled through this environment using the Kratos open
endpoint for enterprise.
"""
def __eq__(self, other: object) -> bool: ...
def __getstate__(self) -> int: ...
def __hash__(self) -> int: ...
def __index__(self) -> int: ...
def __init__(self, value: int) -> None: ...
def __int__(self) -> int: ...
def __ne__(self, other: object) -> bool: ...
def __repr__(self) -> str: ...
def __setstate__(self, state: int) -> None: ...
@property
def name(self) -> str:
"""
:type: str
"""
@property
def value(self) -> int:
"""
:type: int
"""
CLOUD: omni.kit.telemetry._telemetry.RunEnvironment # value = <RunEnvironment.CLOUD: 2>
ENTERPRISE: omni.kit.telemetry._telemetry.RunEnvironment # value = <RunEnvironment.ENTERPRISE: 3>
INDIVIDUAL: omni.kit.telemetry._telemetry.RunEnvironment # value = <RunEnvironment.INDIVIDUAL: 1>
UNDETERMINED: omni.kit.telemetry._telemetry.RunEnvironment # value = <RunEnvironment.UNDETERMINED: 0>
__members__: dict # value = {'UNDETERMINED': <RunEnvironment.UNDETERMINED: 0>, 'INDIVIDUAL': <RunEnvironment.INDIVIDUAL: 1>, 'CLOUD': <RunEnvironment.CLOUD: 2>, 'ENTERPRISE': <RunEnvironment.ENTERPRISE: 3>}
pass
class _ITelemetry(omni.core._core.IObject):
pass
class _ITelemetry2(omni.core._core.IObject):
pass
| 6,629 | unknown | 42.907284 | 210 | 0.62483 |
omniverse-code/kit/exts/omni.kit.telemetry/omni/kit/telemetry/tests/test_telemetry.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.
import omni.kit.test
import omni.kit.test.teamcity
import omni.kit.telemetry
import omni.structuredlog
import omni.kit.app
import carb.settings
import tempfile
import pathlib
import time
import io
import os
import sys
import json
import datetime
import psutil
import carb
import carb.tokens
class TestITelemetry(omni.kit.test.AsyncTestCase): # pragma: no cover
def setUp(self):
self._structured_log_settings = omni.structuredlog.IStructuredLogSettings()
self._control = omni.structuredlog.IStructuredLogControl()
self._settings = carb.settings.get_settings_interface()
self.assertIsNotNone(self._control)
self.assertIsNotNone(self._settings)
self.assertIsNotNone(self._structured_log_settings)
# failed to retrieve the IStructuredLogSettings object => fail
if self._structured_log_settings == None or self._control == None:
return
# print out the current timestamps and session ID to help with debugging test failures
# post mortem.
print("local time at test start is " + str(datetime.datetime.now()) + ", UTC time is " + str(datetime.datetime.now(datetime.timezone.utc)) + ".")
print("current session ID is " + str(self._structured_log_settings.session_id) + ".")
# make sure to flush the structured log queue now since we're going to be changing the
# log output path and default log name for this test. This will ensure that any pending
# events are flushed to their appropriate log files first.
self._control.stop()
# set the log directory and name.
self._temp_dir = tempfile.TemporaryDirectory()
self._log_file_name = "omni.kit.telemetry.test.log"
self._old_log_name = self._structured_log_settings.log_default_name
self._old_log_path = self._structured_log_settings.log_output_path
self._structured_log_settings.log_default_name = self._log_file_name
self._structured_log_settings.log_output_path = self._temp_dir.name
# piece together the expected name of the log and privacy files we'll be watching.
self._log_path = pathlib.Path(self._temp_dir.name).joinpath(self._log_file_name)
self._privacy_path = pathlib.Path(self._temp_dir.name).joinpath("privacy.toml")
# put together the expected location for the system info logs. Unfortunately these
# logs are created and events added to them before this script gets a chance to modify
# the log directory and log name. We'll have to look at the original log location to
# make sure that it output the system info events as expected. Also, if the system
# info logs are accumulating on the system, they may be rotated out over time. If this
# happens during the launch of the app on this run, it could split the messages belonging
# to this session over two log files (presumably we won't be outputting more than 50MiB
# of system info logs in a single run). We'll make sure to run over each of the default
# rotated log names to pull in as much information as possible.
self._sysinfo_log_paths = [pathlib.Path(self._old_log_path).joinpath("omni.kit.sysinfo.2.log"),
pathlib.Path(self._old_log_path).joinpath("omni.kit.sysinfo.1.log"),
pathlib.Path(self._old_log_path).joinpath("omni.kit.sysinfo.log")]
self._write_privacy_settings(self._privacy_path)
self._settings.set_string("/structuredLog/privacySettingsFile", str(self._privacy_path))
self._structured_log_settings.load_privacy_settings()
self.assertEqual(pathlib.Path(self._structured_log_settings.log_default_name), self._log_path)
self.assertEqual(pathlib.Path(self._structured_log_settings.log_output_path), pathlib.Path(self._temp_dir.name))
def tearDown(self):
# nothing to clean up => fail.
if self._structured_log_settings == None:
return;
self._structured_log_settings.log_output_path = self._old_log_path
self._structured_log_settings.log_default_name = self._old_log_name
# restore the original privacy settings.
self._settings.set_string("/structuredLog/privacySettingsFile", "")
self._structured_log_settings.load_privacy_settings()
# explicitly clean up the temporary dir. Note that we need to explicitly clean it up
# since it can throw an exception on Windows if a file or folder is still locked. The
# support for internally ignoring these exceptions isn't added until `tempfile` v3.10
# and we're using an older version of the package here.
try:
self._temp_dir.cleanup()
except:
pass
# explicitly clean up all of our objects so we're not relying on the python GC.
self._structured_log_settings = None
self._control = None
self._settings = None
self._temp_dir = None
self._log_file_name = None
self._old_log_name = None
self._old_log_path = None
self._log_path = None
self._privacy_path = None
self._sysinfo_log_paths = None
print("local time at test end is " + str(datetime.datetime.now()) + ", UTC time is " + str(datetime.datetime.now(datetime.timezone.utc)) + ".")
def _write_privacy_settings(self, filename):
with io.open(filename, "w") as fp:
fp.write("[privacy]\n")
fp.write("performance = true\n")
fp.write("personalization = true\n")
fp.write("usage = true\n")
fp.write("userId = \"[email protected]\"\n")
fp.write("extraDiagnosticDataOptIn = \"externalBuilds\"\n")
def _read_log_lines(self, filename, expected_types, session = None, time_delta = -1, log_time_range = 900):
"""
Reads the events from the expected log file location. Each log message line is parsed as
a JSON blob. The 'data' property of each message is parsed into a dictionary and a list
of these parsed dictionaries are returned. The log's header JSON object will also be
parsed and verified. The verification includes checking that the log's creation timestamp
is recent.
Parameters:
filename: The name of the log file to process for events. This may not be
`None`.
expected_types: A list of event type names that are to be expected in the log file.
If an event is found that does not match one of the events in this
list, a test will fail.
session: An optional session ID string to match to each event. An event will
only be included in the output if its session ID matches this one.
This may be `None` or "0" to ignore the session ID matching. If this
is set to "0", the session ID from each event will be added to each
event in the output list so that further filtering can occur.
time_delta: An optional time delta in seconds used to further filter events from
the log file. Only events that were logged after a point that is
this many seconds earlier than the call time will be included in the
output. This may be negative to disable filtering out older events.
log_time_range: The maximum number of seconds old that the log's creation timestamp
in its header may be. This test may be disabled by settings this
value to 0. If non-zero, this should be set to an absurd range
versus the ideal case so that running on slow machines doesn't cause
this test to unexpectedly fail. This defaults to 900s (15m).
Returns:
A list of parsed events. Each event in the list will be a dictionary of the
properties parsed from that event's 'data' property. Note that each returned
event in this list will have had its 'type' and 'session' properties copied
into it under the property names 'cloudEventsEventType' and 'cloudEventsSessionId'.
These can be used by the caller to further filter and categorize the events.
"""
if not os.path.isfile(filename):
print("failed to find the log file '" + str(filename) + "'.")
return []
events = []
lines = []
header = {}
with open(filename, "r") as f:
lines = f.readlines()
if time_delta >= 0:
timestamp = datetime.datetime.now(datetime.timezone.utc) - datetime.timedelta(seconds = time_delta)
# walk through all the lines in the file except the first one (the log header).
for i in range(1, len(lines)):
line = lines[i]
try:
event = json.loads(line)
self.assertTrue(event["type"] in expected_types)
msg_time = datetime.datetime.strptime(event["time"], "%Y-%m-%dT%H:%M:%S.%f%z")
# always add the 'type' and 'session' properties to the output event. Since the
# "type" and "session" property names are rather generic and could legitimately
# be part of the "data" property, we'll rename them to something less generic
# that the caller can consume.
event["data"]["cloudEventsEventType"] = event["type"]
event["data"]["cloudEventsSessionId"] = event["session"]
if (session == None or session == "0" or event["session"] == session) and (time_delta < 0 or msg_time >= timestamp):
events.append(event["data"])
except json.decoder.JSONDecodeError as e:
print("failed to parse the line '" + line + "' as JSON {reason = '" + str(e) + "'}")
pass
except Exception as e:
print("error processing the line '" + line + "' as JSON {error = '" + str(e) + "'}")
raise
# ****** parse and verify the header line ******
try:
header = json.loads(lines[0])
except json.decoder.JSONDecodeError as e:
print("failed to parse the header '" + lines[0] + "' as JSON {reason = '" + str(e) + "'}")
self.assertFalse(True)
except Exception as e:
print("error processing the header '" + lines[0] + "' as JSON {error = '" + str(e) + "'}")
self.assertFalse(True)
self.assertEqual(header["source"], "omni.structuredlog")
self.assertIsNotNone(header["version"])
# make sure the log was created recently.
if log_time_range > 0:
timestamp = datetime.datetime.strptime(header["time"], "%Y-%m-%dT%H:%M:%S.%f%z")
time_diff = datetime.datetime.now(datetime.timezone.utc) - timestamp
self.assertLess(time_diff.total_seconds(), log_time_range)
return events
def _is_event_present(self, events, properties):
"""
Verifies that all keys in `properties` both exist and have the same values in a
single event in `events`.
Parameters:
events: The set of events that were read from the log file. These are
expected to have been parsed into dictionary objects from the
original JSON 'data' property of each event.
properties: The set of properties to verify are present and match at least
one of the events in the log. All properties must match to a single
event in order for this to succeed.
Returns:
`True` if all the requested keys match in a single event.
`False` if no event containing all properties is found.
"""
# go through each event in the log file and check if it has all the required properties.
for i in range(len(events)):
event = events[i]
matches = True
# go through each of the required properties and verify they are all present and
# have the expected value.
for key, value in properties.items():
if not key in event:
continue
if event[key] != value:
matches = False
break
if matches:
return True
return False
def test_itelemetry_generic_events(self):
"""
Tests sending telemetry events with ITelemetry.send_generic_event(). This version of the
helper function does not provide default values for the parameters.
"""
# retrieve the ITelemetry object.
self._telemetry = omni.kit.telemetry.ITelemetry()
self.assertIsNotNone(self._telemetry)
# send some test events with default ordered parameters.
self._telemetry.send_generic_event("itelemetry_event3_1", 1.025, "apple", None, -1.1275, 5.5)
self._telemetry.send_generic_event("itelemetry_event3_2", 4.25, None, "boo", 8.75, 14.12875)
self._telemetry.send_generic_event("itelemetry_event3_3", 17.625, None, None, 1.25, 2.25)
self._telemetry.send_generic_event("itelemetry_event3_4", 6.75, "orange", "muffin", 76.25, -83.25)
# send some test events with default named parameters.
# FIXME!! once python bindings from 'omni.bind' generate parameter names, these tests
# should be enabled to get some extra test coverage. Currently python is
# expecting the parameters to be named "arg0", "arg1", etc.
#self._telemetry.send_generic_event(eventType = "itelemetry_event4_1", duration = 11.025, data1 = "pear", data2 = None, value1 = -3.1275, value2 = 50.5)
#self._telemetry.send_generic_event(value2 = 23.12875, data2 = "peach", data1 = None, value1 = 10.75, eventType = "itelemetry_event4_2", duration = 14.25)
# make sure all the messages are flushed to disk.
self._control.stop()
# read the log and verify that all the expected messages are present.
events = self._read_log_lines(self._log_path,
[
"com.nvidia.omni.kit.internal.generic",
"com.nvidia.omni.kit.telemetry.startup",
"com.nvidia.omni.kit.extension.startup"
])
# verify the ordered parameters events.
self.assertTrue(self._is_event_present(events, {"eventType" : "itelemetry_event3_1", "duration" : 1.025, "data1" : "apple", "data2" : "", "value1" : -1.1275, "value2" : 5.5}))
self.assertTrue(self._is_event_present(events, {"eventType" : "itelemetry_event3_2", "duration" : 4.25, "data1" : "", "data2" : "boo", "value1" : 8.75, "value2" : 14.12875}))
self.assertTrue(self._is_event_present(events, {"eventType" : "itelemetry_event3_3", "duration" : 17.625, "data1" : "", "data2" : "", "value1" : 1.25, "value2" : 2.25}))
self.assertTrue(self._is_event_present(events, {"eventType" : "itelemetry_event3_4", "duration" : 6.75, "data1" : "orange", "data2" : "muffin", "value1" : 76.25, "value2" : -83.25}))
# verify the named parameters events.
# FIXME!! once python bindings from 'omni.bind' generate parameter names, these tests
# should be enabled to get some extra test coverage.
#self.assertTrue(self._is_event_present(events, {"eventType" : "itelemetry_event4_1", "duration" : 11.025, "data1" : "pear", "data2" : "", "value1" : -3.1275, "value2" : 50.5}))
#self.assertTrue(self._is_event_present(events, {"eventType" : "itelemetry_event4_2", "duration" : 14.25, "data1" : "", "data2" : "peach", "value1" : 10.75, "value2" : 23.12875}))
# clean up.
self._telemetry = None
def test_itelemetry_custom_events(self):
"""
Tests sending telemetry events with ITelemetry.send_custom_event(). This version of the
helper function provides default values for all parameters except the first 'eventType'.
"""
# retrieve the ITelemetry object.
self._telemetry = omni.kit.telemetry.ITelemetry()
self.assertIsNotNone(self._telemetry)
# send some test events with default ordered parameters.
self._telemetry.send_custom_event("itelemetry_event")
self._telemetry.send_custom_event("itelemetry_event_duration", 1.25)
self._telemetry.send_custom_event("itelemetry_event_data1", 0, "some data1")
self._telemetry.send_custom_event("itelemetry_event_data2", 0, None, "some data2")
self._telemetry.send_custom_event("itelemetry_event_value1", 0, None, None, 3.14159)
self._telemetry.send_custom_event("itelemetry_event_value2", 0, None, None, 0, 2.71828)
# send some test events with default named parameters.
self._telemetry.send_custom_event("itelemetry_event2")
self._telemetry.send_custom_event("itelemetry_event2_duration", duration = 5.05)
self._telemetry.send_custom_event("itelemetry_event2_data1", data1 = "some data1_2")
self._telemetry.send_custom_event("itelemetry_event2_data2", data2 = "some data2_2")
self._telemetry.send_custom_event("itelemetry_event2_value1", value1 = 1.75)
self._telemetry.send_custom_event("itelemetry_event2_value2", value2 = -14.28)
# make sure all the messages are flushed to disk.
self._control.stop()
# read the log and verify that all the expected messages are present.
events = self._read_log_lines(self._log_path,
[
"com.nvidia.omni.kit.internal.generic",
"com.nvidia.omni.kit.telemetry.startup",
"com.nvidia.omni.kit.extension.startup"
])
# verify the ordered parameters events.
self.assertTrue(self._is_event_present(events, {"eventType" : "itelemetry_event", "duration" : 0, "data1" : "", "data2" : "", "value1" : 0, "value2" : 0}))
self.assertTrue(self._is_event_present(events, {"eventType" : "itelemetry_event_duration", "duration" : 1.25, "data1" : "", "data2" : "", "value1" : 0, "value2" : 0}))
self.assertTrue(self._is_event_present(events, {"eventType" : "itelemetry_event_data1", "duration" : 0, "data1" : "some data1", "data2" : "", "value1" : 0, "value2" : 0}))
self.assertTrue(self._is_event_present(events, {"eventType" : "itelemetry_event_data2", "duration" : 0, "data1" : "", "data2" : "some data2", "value1" : 0, "value2" : 0}))
self.assertTrue(self._is_event_present(events, {"eventType" : "itelemetry_event_value1", "duration" : 0, "data1" : "", "data2" : "", "value1" : 3.14159, "value2" : 0}))
self.assertTrue(self._is_event_present(events, {"eventType" : "itelemetry_event_value2", "duration" : 0, "data1" : "", "data2" : "", "value1" : 0, "value2" : 2.71828}))
# verify the named parameters events.
self.assertTrue(self._is_event_present(events, {"eventType" : "itelemetry_event2", "duration" : 0, "data1" : "", "data2" : "", "value1" : 0, "value2" : 0}))
self.assertTrue(self._is_event_present(events, {"eventType" : "itelemetry_event2_duration", "duration" : 5.05, "data1" : "", "data2" : "", "value1" : 0, "value2" : 0}))
self.assertTrue(self._is_event_present(events, {"eventType" : "itelemetry_event2_data1", "duration" : 0, "data1" : "some data1_2", "data2" : "", "value1" : 0, "value2" : 0}))
self.assertTrue(self._is_event_present(events, {"eventType" : "itelemetry_event2_data2", "duration" : 0, "data1" : "", "data2" : "some data2_2", "value1" : 0, "value2" : 0}))
self.assertTrue(self._is_event_present(events, {"eventType" : "itelemetry_event2_value1", "duration" : 0, "data1" : "", "data2" : "", "value1" : 1.75, "value2" : 0}))
self.assertTrue(self._is_event_present(events, {"eventType" : "itelemetry_event2_value2", "duration" : 0, "data1" : "", "data2" : "", "value1" : 0, "value2" : -14.28}))
# clean up.
self._telemetry = None
def test_iapp_events(self):
"""
Tests sending telemetry events with omni.kit.app.send_telemetry_event(). This version
provides access to generic telemetry events to all systems through IApp. These events
will be a no-op if the `omni.kit.telemetry` extension is not loaded.
"""
# send some test events with default ordered parameters.
omni.kit.app.send_telemetry_event("iapp_event")
omni.kit.app.send_telemetry_event("iapp_event_duration", -2.25)
omni.kit.app.send_telemetry_event("iapp_event_data1", 0, "some app_data1")
omni.kit.app.send_telemetry_event("iapp_event_data2", 0, None, "some app_data2")
omni.kit.app.send_telemetry_event("iapp_event_value1", 0, None, None, 1.5)
omni.kit.app.send_telemetry_event("iapp_event_value2", 0, None, None, 0, 75.5)
# send some test events with default named parameters.
omni.kit.app.send_telemetry_event("iapp_event2")
omni.kit.app.send_telemetry_event("iapp_event2_duration", duration = 81.75)
omni.kit.app.send_telemetry_event("iapp_event2_data1", data1 = "some app_data1_2")
omni.kit.app.send_telemetry_event("iapp_event2_data2", data2 = "some app_data2_2")
omni.kit.app.send_telemetry_event("iapp_event2_value1", value1 = -4.75)
omni.kit.app.send_telemetry_event("iapp_event2_value2", value2 = 214.5)
# make sure all the messages are flushed to disk.
self._control.stop()
# read the log and verify that all the expected messages are present.
events = self._read_log_lines(self._log_path,
[
"com.nvidia.omni.kit.internal.generic",
"com.nvidia.omni.kit.telemetry.startup",
"com.nvidia.omni.kit.extension.startup"
])
# verify the ordered parameters events.
self.assertTrue(self._is_event_present(events, {"eventType" : "iapp_event", "duration" : 0, "data1" : "", "data2" : "", "value1" : 0, "value2" : 0}))
self.assertTrue(self._is_event_present(events, {"eventType" : "iapp_event_duration", "duration" : -2.25, "data1" : "", "data2" : "", "value1" : 0, "value2" : 0}))
self.assertTrue(self._is_event_present(events, {"eventType" : "iapp_event_data1", "duration" : 0, "data1" : "some app_data1", "data2" : "", "value1" : 0, "value2" : 0}))
self.assertTrue(self._is_event_present(events, {"eventType" : "iapp_event_data2", "duration" : 0, "data1" : "", "data2" : "some app_data2", "value1" : 0, "value2" : 0}))
self.assertTrue(self._is_event_present(events, {"eventType" : "iapp_event_value1", "duration" : 0, "data1" : "", "data2" : "", "value1" : 1.5, "value2" : 0}))
self.assertTrue(self._is_event_present(events, {"eventType" : "iapp_event_value2", "duration" : 0, "data1" : "", "data2" : "", "value1" : 0, "value2" : 75.5}))
# verify the named parameters events.
self.assertTrue(self._is_event_present(events, {"eventType" : "iapp_event2", "duration" : 0, "data1" : "", "data2" : "", "value1" : 0, "value2" : 0}))
self.assertTrue(self._is_event_present(events, {"eventType" : "iapp_event2_duration", "duration" : 81.75, "data1" : "", "data2" : "", "value1" : 0, "value2" : 0}))
self.assertTrue(self._is_event_present(events, {"eventType" : "iapp_event2_data1", "duration" : 0, "data1" : "some app_data1_2", "data2" : "", "value1" : 0, "value2" : 0}))
self.assertTrue(self._is_event_present(events, {"eventType" : "iapp_event2_data2", "duration" : 0, "data1" : "", "data2" : "some app_data2_2", "value1" : 0, "value2" : 0}))
self.assertTrue(self._is_event_present(events, {"eventType" : "iapp_event2_value1", "duration" : 0, "data1" : "", "data2" : "", "value1" : -4.75, "value2" : 0}))
self.assertTrue(self._is_event_present(events, {"eventType" : "iapp_event2_value2", "duration" : 0, "data1" : "", "data2" : "", "value1" : 0, "value2" : 214.5}))
def test_transmitter_launch(self):
"""
Tests that the telemetry transmitter app was successfully launched and is still running.
This should always be the case in the default configuration.
"""
transmitter_log = carb.tokens.get_tokens_interface().resolve("${omni_logs}/omni.telemetry.transmitter.log")
transmitter_exited = False
transmitter_old_log = False
# wait for a little bit to allow the transmitter process to fully start up. This usually
# takes up to 1s. We'll wait longer to account for slow machines. Without waiting, this
# test will only catch the first few lines of the transmitter's log and it may not have
# exited yet. Without checking for the log's early exit message first, this test could
# get into a race condition with checking for the process still running versus the
# transmitter process exiting.
time.sleep(5)
self.assertIsNotNone(transmitter_log)
# wait for the log to appear for up to a minute. This will also account for cases where
# the transmitter takes a long time to download the schemas package or time out while
# attempting to download the authentication token from the OV launcher (this failure is
# expected but normally takes ~1s).
for i in range(60):
if os.path.isfile(transmitter_log):
break
time.sleep(1)
# check the transmitter's test log first to see if it ran. If it did run, it is possible
# that it shutdown early if the local user hasn't given data consent or the 'privacy.toml'
# file doesn't exist. In this case we can check for the shutdown message and avoid
# testing for the existence of the process later on. For this test, all we're really
# interested in is whether we can verify that this process at least attempted to launch
# the transmitter process.
self.assertTrue(os.path.isfile(transmitter_log))
# get the log's modification time and make sure it's very recent. If it's not recent,
# that means the transmitter didn't run or wasn't launched by this process. We'll
# consider a modification time in the last 60s as being recent.
log_mtime = datetime.datetime.fromtimestamp(os.path.getmtime(transmitter_log))
self.assertGreaterEqual(log_mtime, datetime.datetime.now() - datetime.timedelta(seconds = 60))
lines = []
with io.open(transmitter_log, "r") as f:
lines = f.readlines()
for line in lines:
# check if the disabled consent message was printed to the log. This means that the
# transmitter exited early because either the user did not give consent to any of
# the data categories or the 'privacy.toml' file is missing. However, in this case
# we did verify that the transmitter process did actually run.
if "consent was disabled for all categories - exiting" in line:
transmitter_exited = True
# check if the transmitter exited naturally on its own. This means that this log
# belonged to an older instance of the transmitter that was launched by another
# process. This message should not be present in the log belonging to the transmitter
# process that was launched by this process since the existence of this process itself
# will keep the transmitter alive.
if "all clients have exited - shutting down" in line:
transmitter_old_log = True
# make sure there wasn't a natural shutdown present in the log. If this is found, that
# means that log was created by a previous instances of the transmitter, not the one
# that was launched by this process (since this process would hold the transmitter
# open).
self.assertFalse(transmitter_old_log)
# the transmitter process has not exited yet according to its log => scan the running
# processes to make sure it's actually running. Note that this is safe to do since
# this process itself will be keeping the transmitter from exiting now that we know
# it didn't exit early during its startup.
if not transmitter_exited:
transmitter_count = 0
# walk the process list in the table and count how many transmitter processes are running.
for proc in psutil.process_iter():
try:
if "omni.telemetry.transmitter" in proc.name().lower():
print("found the running process '" + proc.name() + "' (" + str(proc.pid) + ").")
transmitter_count = transmitter_count + 1
except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess) as e:
print("invalid process found {e = '" + str(e) + "'}")
pass
# make sure only a single telemetry transmitter is running.
self.assertEqual(transmitter_count, 1)
def test_log_redirection(self):
"""
Tests that the log message redirection works as expected.
"""
# save the original settings for all the log channels locally so we can restore
# them later.
logging_settings = self._settings.create_dictionary_from_settings("/telemetry/logging")
def log_fatal(msg):
"""
Helper function to provide functionality to the 'CARB_LOG_FATAL()' operation from
python. This isn't provided in the carb logging bindings because in theory we
should never get into a situation where a fatal operation can be performed from
the python side. However, for the purposes of this test, we need to be able to
produce fatal log messages.
"""
file, lno, func, mod = carb._get_caller_info()
carb.log(mod, carb.logging.LEVEL_FATAL, file, func, lno, msg)
def get_function_name():
"""
Retrieves the name of the calling function.
"""
f = sys._getframe(1)
if f is None or not hasattr(f, "f_code"):
return "(unknown function)"
return f.f_code.co_name
# write some test log messages.
carb.log_verbose("verbose log message 1") # should be missing in the log.
carb.log_info("info log message 2") # should be missing in the log.
carb.log_warn("warn log message 3") # should be missing in the log.
carb.log_error("error log message 4") # should be found in the log.
log_fatal("fatal log message 5") # should be found in the log.
# adjust the settings and write more log messages.
self._settings.destroy_item("/telemetry/logging/warnFilter")
self._settings.destroy_item("/telemetry/logging/errorFilter")
self._settings.destroy_item("/telemetry/logging/fatalFilter")
carb.log_verbose("verbose log message 6") # should be missing in the log.
carb.log_info("info log message 7") # should be missing in the log.
carb.log_warn("warn log message 8") # should be found in the log.
carb.log_error("error log message 9") # should be found in the log.
log_fatal("fatal log message 10") # should be found in the log.
# adjust the settings again and write more log messages.
self._settings.set_string_array("/telemetry/logging/warnFilter", [".* message .*"])
self._settings.set_string_array("/telemetry/logging/errorFilter", [".* log .*"])
self._settings.set_string_array("/telemetry/logging/fatalFilter", [".*"])
carb.log_verbose("verbose log message 11") # should be missing in the log.
carb.log_verbose("verbose apple muffin 11b") # should be missing in the log.
carb.log_info("info log message 12") # should be missing in the log.
carb.log_info("info apple muffin 12b") # should be missing in the log.
carb.log_warn("warn log message 13") # should be missing in the log.
carb.log_warn("warn apple muffin 13b") # should be found in the log.
carb.log_error("error log message 14") # should be missing in the log.
carb.log_error("error apple muffin 14b") # should be found in the log.
log_fatal("fatal log message 15") # should be missing in the log.
log_fatal("fatal apple muffin 15b") # should be missing in the log.
# flush the log queue and read the log file.
self._control.stop()
events = self._read_log_lines(self._log_path,
[
"omni.kit.logging.message",
"com.nvidia.omni.kit.telemetry.startup",
"com.nvidia.omni.kit.extension.startup"
])
func_name = get_function_name()
# verify that the expected log messages show up in the log.
self.assertFalse(self._is_event_present(events, {"functionName" : func_name, "level" : "verbose", "message" : "verbose log message 1"}))
self.assertFalse(self._is_event_present(events, {"functionName" : func_name, "level" : "info", "message" : "info log message 2"}))
self.assertFalse(self._is_event_present(events, {"functionName" : func_name, "level" : "warn", "message" : "warn log message 3"}))
self.assertTrue(self._is_event_present(events, {"functionName" : func_name, "level" : "error", "message" : "error log message 4"}))
self.assertTrue(self._is_event_present(events, {"functionName" : func_name, "level" : "fatal", "message" : "fatal log message 5"}))
self.assertFalse(self._is_event_present(events, {"functionName" : func_name, "level" : "verbose", "message" : "verbose log message 6"}))
self.assertFalse(self._is_event_present(events, {"functionName" : func_name, "level" : "info", "message" : "info log message 7"}))
self.assertTrue(self._is_event_present(events, {"functionName" : func_name, "level" : "warn", "message" : "warn log message 8"}))
self.assertTrue(self._is_event_present(events, {"functionName" : func_name, "level" : "error", "message" : "error log message 9"}))
self.assertTrue(self._is_event_present(events, {"functionName" : func_name, "level" : "fatal", "message" : "fatal log message 10"}))
self.assertFalse(self._is_event_present(events, {"functionName" : func_name, "level" : "verbose", "message" : "verbose log message 11"}))
self.assertFalse(self._is_event_present(events, {"functionName" : func_name, "level" : "verbose", "message" : "verbose apple muffin 11b"}))
self.assertFalse(self._is_event_present(events, {"functionName" : func_name, "level" : "info", "message" : "info log message 12"}))
self.assertFalse(self._is_event_present(events, {"functionName" : func_name, "level" : "info", "message" : "info apple muffin 12b"}))
self.assertFalse(self._is_event_present(events, {"functionName" : func_name, "level" : "warn", "message" : "warn log message 13"}))
self.assertTrue(self._is_event_present(events, {"functionName" : func_name, "level" : "warn", "message" : "warn apple muffin 13b"}))
self.assertFalse(self._is_event_present(events, {"functionName" : func_name, "level" : "error", "message" : "error log message 14"}))
self.assertTrue(self._is_event_present(events, {"functionName" : func_name, "level" : "error", "message" : "error apple muffin 14b"}))
self.assertFalse(self._is_event_present(events, {"functionName" : func_name, "level" : "fatal", "message" : "fatal log message 15"}))
self.assertFalse(self._is_event_present(events, {"functionName" : func_name, "level" : "fatal", "message" : "fatal apple muffin 15b"}))
# restore the original logging redirection settings. Note that calling update() with
# OVERWRITE doesn't actually overwrite array values. It instead only replaces the items
# in the array that are also present in the new array. If the old array was longer, the
# additional array items from the old value still exist after the update. To work around
# this and have 'replace' behaviour instead of just 'overwrite', we need to delete the
# old array first.
self._settings.destroy_item("/telemetry/logging/warnFilter")
self._settings.destroy_item("/telemetry/logging/errorFilter")
self._settings.destroy_item("/telemetry/logging/fatalFilter")
self._settings.update("/telemetry/logging", logging_settings, "", carb.dictionary.UpdateAction.OVERWRITE)
def test_sysinfo_messages(self):
"""
Test whether the system info messages were written out when the 'omni.kit.telemetry'
extension was loaded. Note that this happens when the `omni.kit.telemetry` extension
loads and would have happened long before this script started running so we unfortunately
can't redirect its output to a new log or log directory. However, we can find the log
it did go to (in its original location) and verify that some new system info events
were written into it in the last few seconds or minutes.
"""
# on a system with attached (active) displays, we should expect 4 events - 'cpu', 'os',
# 'display', and 'displayOverview'. However, on headless systems (like some TC agents)
# there may not be displays to speak of so we'll just ignore them.
expected_count = 2
# stop the queue to ensure all events are flushed to disk.
self._control.stop()
# make sure that at least one log message from a recent session was written to the
# system info log. Note that if the local user doesn't have its 'privacy.toml' file
# present on disk or the user hasn't given consent for 'usage' data, the retrieved
# session ID will be 0 and we won't be able to filter based on session ID. This will
# be the case on most or all test agent machines. To work around this, we'll also
# make sure to only grab the events from a recent period (several minutes in this case).
for sysinfo_log_path in self._sysinfo_log_paths:
# numbered log file doesn't exist => skip it.
if not os.path.isfile(sysinfo_log_path):
print("the log file '" + str(sysinfo_log_path) + "' doesn't exist. Skipping it.")
continue
# publish the full log file to the TC artifacts.
omni.kit.test.teamcity.teamcity_publish_image_artifact(sysinfo_log_path, "logs")
events = self._read_log_lines(sysinfo_log_path,
[
"com.nvidia.omni.kit.sysinfo.cpu",
"com.nvidia.omni.kit.sysinfo.os",
"com.nvidia.omni.kit.sysinfo.display",
"com.nvidia.omni.kit.sysinfo.displayOverview",
"com.nvidia.omni.kit.sysinfo.gpu",
"com.nvidia.omni.kit.sysinfo.gpuOverview"
],
str(self._structured_log_settings.session_id),
30 * 60, 0)
# make sure at least one event was found.
self.assertGreater(len(events), 0)
# this local user is either missing their 'privacy.toml' file or did not give consent
# for 'usage' data => count how many events appeared for each session ID in the list
# of recent events. There should be at least four events for each run - 'cpu', 'os',
# 'display', and 'displayOverview'. Note that in render-less cases like these tests
# the GPU info will never be collected because the `gpu.foundation` plugin is never
# loaded.
if "cloudEventsSessionId" in events[0]:
session_counts = {}
for event in events:
if not event["cloudEventsSessionId"] in session_counts:
session_counts[event["cloudEventsSessionId"]] = 1
else:
session_counts[event["cloudEventsSessionId"]] = session_counts[event["cloudEventsSessionId"]] + 1
# make sure at least one group of events from sessions have matching messages for the
# main events that always print (cpu, os, display, displayOverview).
found = False
for key, value in session_counts.items():
if value >= expected_count:
found = True
break
else:
print(f"only found {value} events from session {key}.")
self.assertTrue(found)
# make sure at least one matching message was found for the main events that always print
# (cpu, os, display, displayOverview).
else:
self.assertGreaterEqual(len(events), expected_count)
# verify that at least the 'cpu' and 'os' events are present for each session ID returned
# in the event list.
cpu_counts = {}
os_counts = {}
sessions = []
for event in events:
# the event name wasn't present (?!) => fail.
self.assertTrue("cloudEventsEventType" in event)
self.assertTrue("cloudEventsSessionId" in event)
# add the session ID to a list so we can ensure each one had a CPU and OS entry. Note
# that if multiple sessions are found in the list, we'll reject the counts for the
# first session since one or more of its events could have been filtered out by the
# time delta check in _read_log_lines().
if not event["cloudEventsSessionId"] in sessions:
sessions.append(event["cloudEventsSessionId"])
session_id = event["cloudEventsSessionId"]
if event["cloudEventsEventType"] == "com.nvidia.omni.kit.sysinfo.cpu":
if not session_id in cpu_counts:
cpu_counts[session_id] = 1
else:
cpu_counts[session_id] = cpu_counts[session_id] + 1
elif event["cloudEventsEventType"] == "com.nvidia.omni.kit.sysinfo.os":
if not session_id in os_counts:
os_counts[session_id] = 1
else:
os_counts[session_id] = os_counts[session_id] + 1
# make sure at least one session ID was found.
self.assertGreater(len(sessions), 0)
# events from multiple sessions were found => reject the counts from the first session
# since some of its events may have been filtered by the time delta check.
if len(sessions) > 1:
print("trimming partial sessions.")
for id in sessions:
print(" {session = '" + str(id) +
"', cpu_counts = " + str(cpu_counts[id]) +
", os_counts = " + str(os_counts[id]) + "}")
session_id = sessions[0]
self.assertTrue(session_id in cpu_counts)
self.assertTrue(session_id in os_counts)
sessions.pop(0)
cpu_counts.pop(session_id)
os_counts.pop(session_id)
self.assertGreater(len(cpu_counts), 0)
self.assertGreater(len(os_counts), 0)
# make sure no mysterious extra sessions got into the counts somehow.
self.assertEqual(len(sessions), len(cpu_counts))
self.assertEqual(len(sessions), len(os_counts))
# check that each known session has at least one 'cpu' and one 'os' event found for it.
for session in sessions:
self.assertTrue(session in cpu_counts)
self.assertTrue(session in os_counts)
self.assertGreater(cpu_counts[session], 0)
self.assertGreater(os_counts[session], 0)
def test_itelemetry2(self):
"""
Tests the methods of the with ITelemetry2 interface. This version of the
helper function provides default values for all parameters except the first 'eventType'.
"""
# retrieve the ITelemetry object.
self._telemetry2 = omni.kit.telemetry.ITelemetry2()
self.assertIsNotNone(self._telemetry2)
# send some test events with default ordered parameters.
self._telemetry2.send_custom_event("itelemetry2_event")
self._telemetry2.send_custom_event("itelemetry2_event_duration", 1.25)
self._telemetry2.send_custom_event("itelemetry2_event_data1", 0, "some data1")
self._telemetry2.send_custom_event("itelemetry2_event_data2", 0, None, "some data2")
self._telemetry2.send_custom_event("itelemetry2_event_value1", 0, None, None, 3.14159)
self._telemetry2.send_custom_event("itelemetry2_event_value2", 0, None, None, 0, 2.71828)
# send some test events with default named parameters.
self._telemetry2.send_custom_event("itelemetry2_event2")
self._telemetry2.send_custom_event("itelemetry2_event2_duration", duration = 5.05)
self._telemetry2.send_custom_event("itelemetry2_event2_data1", data1 = "some data1_2")
self._telemetry2.send_custom_event("itelemetry2_event2_data2", data2 = "some data2_2")
self._telemetry2.send_custom_event("itelemetry2_event2_value1", value1 = 1.75)
self._telemetry2.send_custom_event("itelemetry2_event2_value2", value2 = -14.28)
# make sure all the messages are flushed to disk.
self._control.stop()
# read the log and verify that all the expected messages are present.
events = self._read_log_lines(self._log_path,
[
"com.nvidia.omni.kit.internal.generic",
"com.nvidia.omni.kit.telemetry.startup",
"com.nvidia.omni.kit.extension.startup"
])
# verify the ordered parameters events.
self.assertTrue(self._is_event_present(events, {"eventType" : "itelemetry2_event", "duration" : 0, "data1" : "", "data2" : "", "value1" : 0, "value2" : 0}))
self.assertTrue(self._is_event_present(events, {"eventType" : "itelemetry2_event_duration", "duration" : 1.25, "data1" : "", "data2" : "", "value1" : 0, "value2" : 0}))
self.assertTrue(self._is_event_present(events, {"eventType" : "itelemetry2_event_data1", "duration" : 0, "data1" : "some data1", "data2" : "", "value1" : 0, "value2" : 0}))
self.assertTrue(self._is_event_present(events, {"eventType" : "itelemetry2_event_data2", "duration" : 0, "data1" : "", "data2" : "some data2", "value1" : 0, "value2" : 0}))
self.assertTrue(self._is_event_present(events, {"eventType" : "itelemetry2_event_value1", "duration" : 0, "data1" : "", "data2" : "", "value1" : 3.14159, "value2" : 0}))
self.assertTrue(self._is_event_present(events, {"eventType" : "itelemetry2_event_value2", "duration" : 0, "data1" : "", "data2" : "", "value1" : 0, "value2" : 2.71828}))
# verify the named parameters events.
self.assertTrue(self._is_event_present(events, {"eventType" : "itelemetry2_event2", "duration" : 0, "data1" : "", "data2" : "", "value1" : 0, "value2" : 0}))
self.assertTrue(self._is_event_present(events, {"eventType" : "itelemetry2_event2_duration", "duration" : 5.05, "data1" : "", "data2" : "", "value1" : 0, "value2" : 0}))
self.assertTrue(self._is_event_present(events, {"eventType" : "itelemetry2_event2_data1", "duration" : 0, "data1" : "some data1_2", "data2" : "", "value1" : 0, "value2" : 0}))
self.assertTrue(self._is_event_present(events, {"eventType" : "itelemetry2_event2_data2", "duration" : 0, "data1" : "", "data2" : "some data2_2", "value1" : 0, "value2" : 0}))
self.assertTrue(self._is_event_present(events, {"eventType" : "itelemetry2_event2_value1", "duration" : 0, "data1" : "", "data2" : "", "value1" : 1.75, "value2" : 0}))
self.assertTrue(self._is_event_present(events, {"eventType" : "itelemetry2_event2_value2", "duration" : 0, "data1" : "", "data2" : "", "value1" : 0, "value2" : -14.28}))
# make sure the other methods and accessors can be called.
if self._telemetry2.cloud_session:
self.assertNotNone(self._telemetry2.cloud_session_id)
self.assertEqual(self._telemetry2.run_environment, omni.kit.telemetry.RunEnvironment.CLOUD)
# make sure the 'cloud_session_id' property is read-only.
try:
self._telemetry2.cloud_session_id = "This donut is purple. Purple is a fruit!"
self.assertFalse(True, "unexpectedly able to write to the `omni.kit.telemetry.ITelemetry2().cloud_session_id` property.")
except:
pass
# make sure the 'run_environment' property is read-only.
try:
self._telemetry2.run_environment = "The camembert is a little runny today"
self.assertFalse(True, "unexpectedly able to write to the `omni.kit.telemetry.ITelemetry2().run_environment` property.")
except:
pass
run_environment = self._telemetry2.run_environment;
self.assertTrue(run_environment == omni.kit.telemetry.RunEnvironment.CLOUD or
run_environment == omni.kit.telemetry.RunEnvironment.INDIVIDUAL or
run_environment == omni.kit.telemetry.RunEnvironment.ENTERPRISE)
try:
self._telemetry2.customer_id = "Bachelor Chow Incorporated"
self.assertFalse(True, "unexpectedly able to write to the `omni.kit.telemetry.ITelemetry2().customer_id` property.")
except:
pass
# clean up.
self._telemetry2 = None
| 51,322 | Python | 59.809242 | 190 | 0.612057 |
omniverse-code/kit/exts/omni.kit.telemetry/omni/kit/telemetry/tests/__init__.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 .test_telemetry import * # pragma: no cover
from .test_sentry import *
| 502 | Python | 49.299995 | 76 | 0.800797 |
omniverse-code/kit/exts/omni.kit.telemetry/omni/kit/telemetry/tests/test_sentry.py | from unittest.mock import patch
import omni.kit.test
from omni.kit.telemetry import should_enable_sentry, start_sentry, remove_sentry_pii_data
class MockApp():
def __init__(self, is_external=False):
self.is_external = is_external
def is_app_external(self):
return self.is_external
def get_app_name(self):
return "test-app"
def get_app_version(self):
return "0.1.1"
def get_app_environment(self):
return "test"
def get_kit_version(self):
return "105.1"
class TestSentryExt(omni.kit.test.AsyncTestCase):
def test_remove_pii_data(self):
mock_event = {
"breadcrumbs": {
"values": [
{
"timestamp": 1693940484.77857,
"type": "subprocess",
"category": "subprocess",
"level": "info",
"message": "'mklink /J \"S:\\\\Remix\\\\rtx-remix\\\\mods\\\\portal_rtx\\\\deps\" \"S:\\\\Remix\\\\rtx-remix\"'"
}
]
},
'contexts': {'runtime': {'build': '3.10.13 (main, Sep 6 2023, 19:28:27) [GCC '
'7.3.1 20180303 (Red Hat 7.3.1-5)]',
'name': 'CPython',
'version': '3.10.13'}},
'environment': 'production',
'event_id': 'd4097ca1c6fa4d33ab95ce56cd48e890',
'level': 'error',
'logentry': {'message': "[Watcher] Failed to resolve USD Asset Identifier '../../../../../../capture/materials/AperturePBR_Opacity.mdl' from prim '/RootNode/meshes/mesh_4019D65FB9B7DF03/Looks/M_Fixture_Glados_Screen_A1_Screen/Shader'",
"formatted": "[Watcher] Failed to resolve USD Asset Identifier '../../../../../../capture/materials/AperturePBR_Opacity.mdl' from prim '/RootNode/meshes/mesh_4019D65FB9B7DF03/Looks/M_Fixture_Glados_Screen_A1_Screen/Shader'",
'params': []},
'logger': 'omni.ext._impl._internal',
'modules': {'pip': '21.2.1+nv1', 'setuptools': '65.5.1'},
'platform': 'python',
'release': 'omni.app.mini-0.1.1',
'tags': {'app.environment': 'default',
'app.kit_version': '105.2+.0.00Dev000.local',
'app.name': 'omni.app.mini',
'app.version': '0.1.1',
'session_id': '771899758188315817'},
'user': {'id': '[email protected]'},
"extra": {
"filename": "C:\\buildAgent\\work\\kit\\kit\\source\\extensions\\omni.usd.core\\sharedlibs\\omni.usd\\UsdMaterialWatcher.cpp",
"functionName": "load",
"lineNumber": 332,
"sys.argv": [
"D:\\Repositories\\lightspeedrtx\\lightspeed-kit\\_build\\windows-x86_64\\release\\kit\\kit.exe",
"D:\\Repositories\\lightspeedrtx\\lightspeed-kit\\_build\\windows-x86_64\\release\\apps/lightspeed.app.trex_dev.kit",
"--/rtx/verifyDriverVersion/enabled=false",
"--/app/extensions/registryEnabled=1",
"--enable",
"omni.kit.debug.pycharm",
"--/exts/omni.kit.debug.pycharm/pycharm_location=C:\\Program Files\\JetBrains\\PyCharm 2023.2"
]
},
}
scubbed_event = remove_sentry_pii_data(mock_event, None)
assert int(scubbed_event["user"]["id"]), "User Id should be replaced by a session id"
self.assertEquals(scubbed_event["logentry"]["message"], "[Watcher] Failed to resolve USD Asset Identifier /AperturePBR_Opacity.mdl' from prim /Shader'", "Message shouldn't have paths")
self.assertEquals(scubbed_event["breadcrumbs"]["values"][0]["message"], '\'mklink /J /deps" /rtx-remix"\'', "Message shouldn't have paths")
self.assertEquals(scubbed_event["extra"]["filename"], "/UsdMaterialWatcher.cpp", "Filename should only have last part")
self.assertEquals(scubbed_event["extra"]["sys.argv"][0], "/kit.exe", "Sys argv0 should only have kit")
self.assertEquals(scubbed_event["extra"]["sys.argv"][1], "/lightspeed.app.trex_dev.kit", "Sys argv1 should only have app")
self.assertEquals(scubbed_event["extra"]["sys.argv"][6], "--/exts/omni.kit.debug.pycharm/pycharm_location=/PyCharm 2023.2", "Sys argv6 should not have path to pycharm")
def test_should_enable_sentry(self):
app = MockApp(is_external=False)
settings = {}
assert should_enable_sentry(app, settings) == False, "Shouldn't be enabled in external builds"
app = MockApp(is_external=True)
settings = {"/telemetry/enableSentry": True}
assert should_enable_sentry(app, settings) == False, "Shouldn't be enabled in external builds if setting set"
app = MockApp(is_external=False)
settings = {"/telemetry/enableSentry": True}
assert should_enable_sentry(app, settings) == True, "Should be enabled in internal builds if setting set"
app = MockApp(is_external=False)
settings = {"/telemetry/enableSentry": False}
assert should_enable_sentry(app, settings) == False, "Shouldn't be enabled in internal builds if setting set"
@patch('omni.kit.telemetry.sentry_extension._get_sentry_sdk')
@patch('omni.kit.telemetry.sentry_extension._get_sentry_logging_integration')
def test_start_sentry(self, mocked_sentry_sdk, mock_logging_integration):
app = MockApp(is_external=False)
settings = {"/telemetry/enableSentry": True}
has_started = start_sentry(app, settings)
assert has_started == True, "Sentry should have started"
| 5,513 | Python | 46.947826 | 237 | 0.604027 |
omniverse-code/kit/exts/omni.kit.telemetry/omni/kit/telemetry/impl/sentry_extension.py | import time
import logging
import carb.settings
import carb
import omni.ext
import omni.kit.app
import omni.structuredlog
import sentry_sdk
from sentry_sdk.integrations.logging import LoggingIntegration
logger = logging.getLogger(__name__)
# Link was generated by perflab Sentry instance:
DSN = "https://[email protected]/834"
CARB_LOG_LEVEL_TO_EVENT_LEVEL = {
carb.logging.LEVEL_VERBOSE: "debug",
carb.logging.LEVEL_INFO: "info",
carb.logging.LEVEL_WARN: "warning",
carb.logging.LEVEL_ERROR: "error",
carb.logging.LEVEL_FATAL: "fatal"
}
class Extension(omni.ext.IExt):
def on_startup(self):
s = carb.settings.get_settings()
if s.get("/privacy/externalBuild"):
logger.info("sentry is disabled for external build")
return
if not s.get("/telemetry/enableSentry"):
return
app = omni.kit.app.get_app()
# Setup user using already formed crashreporter data
data = s.get("/crashreporter/data")
if not data:
data = {}
user_id = data.get("userId", None)
if user_id:
sentry_sdk.set_user({"id": user_id})
sentry_sdk.set_tag("app.name", app.get_app_name())
sentry_sdk.set_tag("app.version", app.get_app_version())
sentry_sdk.set_tag("app.environment", app.get_app_environment())
# Pass telemetry session to sentry
structlog_settings = omni.structuredlog.IStructuredLogSettings()
if structlog_settings:
sentry_sdk.set_tag("session_id", str(structlog_settings.session_id))
time_start = time.time()
sentry_sdk.init(
dsn=DSN,
traces_sample_rate=1.0,
auto_enabling_integrations=False,
integrations=[LoggingIntegration(event_level=None, level=None)], # Disable builtin logging integration
release=app.get_kit_version()
)
logger.info("enabled Sentry...(time took: {:.2f}s)".format(time.time()-time_start))
# Subscribe to IApp log listener which outputs carbonite log errors each frame on the main thread
# We could have created custom python logger here, but it is known to create deadlocks with GIL because of being
# called from many threads.
def on_log_event(e):
level = e.payload["level"]
if level >= carb.logging.LEVEL_ERROR:
event = {}
event["level"] = CARB_LOG_LEVEL_TO_EVENT_LEVEL.get(level, "notset")
event["logger"] = e.payload["source"]
event["logentry"] = {
"message": e.payload["message"],
"params": (),
}
event["extra"] = {
"filename": e.payload["filename"],
"functionName": e.payload["functionName"],
"lineNumber": e.payload["lineNumber"]
}
sentry_sdk.capture_event(event)
log_stream = omni.kit.app.get_app().get_log_event_stream()
self._log_sub = log_stream.create_subscription_to_pop(on_log_event, name="omni.kit.telemetry.sentry_extension")
| 3,210 | Python | 33.159574 | 120 | 0.603738 |
omniverse-code/kit/exts/omni.kit.telemetry/omni/kit/telemetry/impl/__init__.py | from .sentry_extension import Extension
| 40 | Python | 19.49999 | 39 | 0.85 |
omniverse-code/kit/exts/omni.graph.examples.cpp/ogn/docs/OgnPrimDeformer2.rst | .. _omni_graph_examples_cpp_PrimDeformer2_1:
.. _omni_graph_examples_cpp_PrimDeformer2:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Example Node: Z Threshold Prim Deformer
:keywords: lang-en omnigraph node examples WriteOnly cpp prim-deformer2
Example Node: Z Threshold Prim Deformer
=======================================
.. <description>
Example deformer node that limits the Z point positions to a threshold, input via a Prim
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.examples.cpp<ext_omni_graph_examples_cpp>` in the Extension Manager.
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.examples.cpp.PrimDeformer2"
"Version", "1"
"Extension", "omni.graph.examples.cpp"
"Has State?", "False"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "Example Node: Z Threshold Prim Deformer"
"Categories", "examples"
"Generated Class Name", "OgnPrimDeformer2Database"
"Python Module", "omni.graph.examples.cpp"
| 1,337 | reStructuredText | 25.759999 | 109 | 0.578908 |
omniverse-code/kit/exts/omni.graph.examples.cpp/ogn/docs/OgnCompound.rst | .. _omni_graph_examples_cpp_Compound_1:
.. _omni_graph_examples_cpp_Compound:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Example Node: Compound
:keywords: lang-en omnigraph node examples threadsafe cpp compound
Example Node: Compound
======================
.. <description>
Encapsulation of one more other nodes into a single node entity. The compound node doesn't have any functionality of its own, it is merely a wrapper for a set of nodes that perform a complex task. It presents a more limited set of input and output attributes than the union of the contained nodes to make it seem as though a single node is performing a higher level function. For example a compound node could present inputs a, b, and c, and outputs root1 and root2 at the compound boundary, wiring up simple math nodes square, squareRoot, add, subtract, times, and divided_by in a simple way that calculates quadratic roots. (root1 = divide(add(b, square_root(subtract(square(b), times(4, times(a, c))))))) (root2 = divide(subtract(b, square_root(subtract(square(b), times(4, times(a, c)))))))
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.examples.cpp<ext_omni_graph_examples_cpp>` in the Extension Manager.
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.examples.cpp.Compound"
"Version", "1"
"Extension", "omni.graph.examples.cpp"
"Has State?", "False"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "None"
"uiName", "Example Node: Compound"
"Categories", "examples"
"Generated Class Name", "OgnCompoundDatabase"
"Python Module", "omni.graph.examples.cpp"
| 1,949 | reStructuredText | 37.999999 | 794 | 0.639302 |
omniverse-code/kit/exts/omni.graph.examples.cpp/ogn/docs/OgnExampleSmooth.rst | .. _omni_graph_examples_cpp_Smooth_1:
.. _omni_graph_examples_cpp_Smooth:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Example Node: Smooth Points
:keywords: lang-en omnigraph node cpp smooth
Example Node: Smooth Points
===========================
.. <description>
Smooths data in a very simple way by averaging values with neighbors.
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.examples.cpp<ext_omni_graph_examples_cpp>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"inputs:iterations", "``int``", "Number of times to average neighboring values", "5"
"inputs:mesh", "``bundle``", "Bundle containing data to be smoothed and neighbor arrays.", "None"
"inputs:nameOfAttributeToSmooth", "``token``", "Name of the attribute in 'mesh' containing the data to be smoothed", "points"
"inputs:nameOfNeighborStartsInputAttribute", "``token``", "Name of the 'int[]' attribute in 'mesh' containing the beginning index of neighbors of each point in the array attribute specified by 'nameOfNeighborsInputAttribute'", "neighborStarts"
"inputs:nameOfNeighborsInputAttribute", "``token``", "Name of the 'int[]' attribute in 'mesh' containing the neighbors of all points. The beginnings of each point's neighbors within this array are provided in the attribute specified by 'nameOfNeighborStartsInputAttribute'.", "neighbors"
"inputs:useGPU", "``bool``", "When this option is on, the node will use the GPU to perform the smoothing computation.", "True"
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"outputs:mesh", "``bundle``", "A copy of 'mesh' with the specified attribute smoothed.", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.examples.cpp.Smooth"
"Version", "1"
"Extension", "omni.graph.examples.cpp"
"Has State?", "False"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "None"
"uiName", "Example Node: Smooth Points"
"Generated Class Name", "OgnExampleSmoothDatabase"
"Python Module", "omni.graph.examples.cpp"
| 2,513 | reStructuredText | 33.916666 | 292 | 0.629526 |
omniverse-code/kit/exts/omni.graph.examples.cpp/ogn/docs/OgnExampleAdjacency.rst | .. _omni_graph_examples_cpp_Adjacency_1:
.. _omni_graph_examples_cpp_Adjacency:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Example Node: Adjacency
:keywords: lang-en omnigraph node cpp adjacency
Example Node: Adjacency
=======================
.. <description>
Computes chosen adjacency information from specified input mesh topology data.
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.examples.cpp<ext_omni_graph_examples_cpp>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"inputs:computeDistances", "``bool``", "When enabled, the distances from each point to its neighbors is computed and stored in a 'float[]' attribute in 'output' as specified by 'nameOfDistancesOutputAttribute'.", "False"
"inputs:computeNeighborCounts", "``bool``", "When enabled, the number of neighbors of each point is computed and all are stored in an 'int[]' attribute in 'output' as specified by 'nameOfNeighborCountsOutputAttribute'.", "False"
"inputs:computeNeighborStarts", "``bool``", "When enabled, the beginning index of neighbors of each point within the arrays computed by either 'computeNeighbors' or 'computeDistances' is computed and all, plus an additional integer to indicate the end of the array, are stored in an 'int[]' attribute in 'output' as specified by 'nameOfNeighborStartsOutputAttribute'. The extra integer at the end allows for easy computing of the number of neighbors of any single point, by subtracting the value in the array corresponding with the point, from the following value in the array.", "True"
"inputs:computeNeighbors", "``bool``", "When enabled, the neighbors of each point are computed and stored contiguously in an 'int[]' attribute in 'output' as specified by 'nameOfNeighborsOutputAttribute'.", "True"
"inputs:mesh", "``bundle``", "Bundle containing topology data to be analysed", "None"
"inputs:nameOfDistancesOutputAttribute", "``token``", "Name of the 'float[]' attribute to be created in 'output' to contain the computed distances to each neighbor. This is only used if 'computeDistances' is true.", "distances"
"inputs:nameOfNeighborCountsOutputAttribute", "``token``", "Name of the 'int[]' attribute to be created in 'output' to contain the number of neighbors of each point. This is only used if 'computeNeighborCounts' is true. A running sum of this array can be computed using 'computeNeighborStarts'. The neighbors themselves can be computed using 'computeNeighbors'.", "neighborCounts"
"inputs:nameOfNeighborStartsOutputAttribute", "``token``", "Name of the 'int[]' attribute to be created in 'output' to contain the beginning index of neighbors of each point in the arrays computed by either 'computeNeighbors' or 'computeDistances'. This is only used if 'computeNeighborStarts' is true.", "neighborStarts"
"inputs:nameOfNeighborsOutputAttribute", "``token``", "Name of the 'int[]' attribute to be created in 'output' to contain the neighbors of all points. This is only used if 'computeNeighbors' is true. The beginnings of each point's neighbors within this array can be computed using 'computeNeighborStarts'. The number of neighbors of each point can be computed using 'computeNeighborCounts'.", "neighbors"
"inputs:nameOfPositionsInputAttribute", "``token``", "Name of the 'point3f[]' attribute in 'mesh' containing the positions of each point. This is only used if 'computeDistances' is true. The element count of this array overrides 'pointCount', when used.", "points"
"inputs:nameOfVertexCountsInputAttribute", "``token``", "Name of the 'int[]' attribute in 'mesh' containing the vertex counts of each face", "faceVertexCounts"
"inputs:nameOfVertexIndicesInputAttribute", "``token``", "Name of the 'int[]' attribute in 'mesh' containing the vertex indices of each face", "faceVertexIndices"
"inputs:pointCount", "``int``", "Number of points being referred to in the vertex indices attribute. This is only used if 'computeDistances' is false, otherwise this is overridden by the element count of the attribute specified by 'nameOfPositionsInputAttribute'.", "0"
"inputs:removeDuplicates", "``bool``", "When enabled, each neighbor of a point will be counted only once, instead of once per edge that connects the point to the neighbor.", "True"
"inputs:treatEdgesAsOneWay", "``bool``", "When enabled, if a face has an edge from A to B, B will be considered a neighbor of A, but A will not be considered a neighbor of B. This can be useful as part of identifying unshared edges or inconsistent face winding order.", "False"
"inputs:treatFacesAsCurves", "``bool``", "When enabled, the input faces will be treated as curves, instead of closed polygons, i.e. no edge from the last vertex of each face to the first vertex of that face will be counted.", "False"
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"outputs:mesh", "``bundle``", "A copy of the input 'mesh' with the computed attributes added, as specified above.", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.examples.cpp.Adjacency"
"Version", "1"
"Extension", "omni.graph.examples.cpp"
"Has State?", "False"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "None"
"uiName", "Example Node: Adjacency"
"Generated Class Name", "OgnExampleAdjacencyDatabase"
"Python Module", "omni.graph.examples.cpp"
| 5,856 | reStructuredText | 70.426828 | 591 | 0.706626 |
omniverse-code/kit/exts/omni.graph.examples.cpp/ogn/docs/OgnDeformerTimeBased.rst | .. _omni_graph_examples_cpp_DeformerTimeBased_1:
.. _omni_graph_examples_cpp_DeformerTimeBased:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Example Node: Time-based Sine Wave Deformer
:keywords: lang-en omnigraph node examples threadsafe cpp deformer-time-based
Example Node: Time-based Sine Wave Deformer
===========================================
.. <description>
This is an example of a simple deformer with time based input to control a time dependent sine wave deformation.
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.examples.cpp<ext_omni_graph_examples_cpp>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"inputs:multiplier", "``float``", "The multiplier for the amplitude of the sine wave", "1"
"inputs:points", "``pointf[3][]``", "The input points to be deformed", "[]"
"inputs:time", "``double``", "Time value to modulate the offset in sine curve evaluation", "0.0"
"inputs:wavelength", "``float``", "The wavelength of the sine wave", "1"
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"outputs:points", "``pointf[3][]``", "The deformed output points", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.examples.cpp.DeformerTimeBased"
"Version", "1"
"Extension", "omni.graph.examples.cpp"
"Has State?", "False"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "None"
"uiName", "Example Node: Time-based Sine Wave Deformer"
"Categories", "examples"
"Generated Class Name", "OgnDeformerTimeBasedDatabase"
"Python Module", "omni.graph.examples.cpp"
| 2,058 | reStructuredText | 28 | 113 | 0.588921 |
omniverse-code/kit/exts/omni.graph.examples.cpp/ogn/docs/OgnScaleCube.rst | .. _omni_graph_examples_cpp_ScaleCube_1:
.. _omni_graph_examples_cpp_ScaleCube:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Example Node: Multiply Float
:keywords: lang-en omnigraph node examples threadsafe cpp scale-cube
Example Node: Multiply Float
============================
.. <description>
Example node that performs a simple multiplication
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.examples.cpp<ext_omni_graph_examples_cpp>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"inputs:multiplier", "``float``", "2nd multiplicand", "0.0"
"inputs:value", "``float``", "1st multiplicand", "0.0"
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"outputs:value", "``double``", "Product of value and multiplier", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.examples.cpp.ScaleCube"
"Version", "1"
"Extension", "omni.graph.examples.cpp"
"Has State?", "False"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "None"
"uiName", "Example Node: Multiply Float"
"Categories", "examples"
"Generated Class Name", "OgnScaleCubeDatabase"
"Python Module", "omni.graph.examples.cpp"
| 1,663 | reStructuredText | 23.115942 | 109 | 0.564041 |
omniverse-code/kit/exts/omni.graph.examples.cpp/ogn/docs/OgnGpuInteropCpuToDisk.rst | .. _omni_graph_examples_cpp_GpuInteropCpuToDisk_1:
.. _omni_graph_examples_cpp_GpuInteropCpuToDisk:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Example Node: Cpu To Disk
:keywords: lang-en omnigraph node examples cpp gpu-interop-cpu-to-disk
Example Node: Cpu To Disk
=========================
.. <description>
Saves specified CPU buffer to disk
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.examples.cpp<ext_omni_graph_examples_cpp>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"activeReset (*inputs:active*)", "``bool``", "Alternative to frameCount/startFrame, does a single frame then autoResets to false", "False"
"aovCpu (*inputs:aovCpu*)", "``string``", "Name of AOV representing CPU buffer of GPU resource", ""
"aovGpu (*inputs:aovGpu*)", "``string``", "Name of AOV representing GPU resource, used for querying format + properties", ""
"autoFileNumber (*inputs:autoFileNumber*)", "``int``", "If non zero, this number will be the starting number for export. Each invocation of this node increases the number by 1.", "-1"
"fileName (*inputs:fileName*)", "``string``", "Optional, if specified the output filename will be fileName_{aovGpu}.{fileType}", ""
"fileNumber (*inputs:fileNumber*)", "``int``", "Number that will be appended to the exported filename. If -1 then the render product's frame number will be used.", "-1"
"fileType (*inputs:fileType*)", "``string``", "bmp,png,exr", "png"
"frameCount (*inputs:frameCount*)", "``int64``", "Number of frames to capture (-1 means never stop)", "-1"
"gpuFoundations (*inputs:gpu*)", "``uint64``", "Pointer to shared context containing gpu foundations", "0"
"maxInflightWrites (*inputs:maxInflightWrites*)", "``int``", "Maximum number of in-flight file write operations before blocking on file i/o", "2"
"renderProduct (*inputs:rp*)", "``uint64``", "Pointer to render product for this view", "0"
"saveFlags (*inputs:saveFlags*)", "``uint64``", "Flags that will be passed to carb::imaging::IImaging for file saving.", "0"
"saveLocation (*inputs:saveLocation*)", "``string``", "Folder to save AOVs as AOV_FrameNumber.{exr,png}", ""
"startFrame (*inputs:startFrame*)", "``uint64``", "Frame to begin saving to disk", "0"
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"gpuFoundations (*outputs:gpu*)", "``uint64``", "Pointer to shared context containing gpu foundations", "None"
"renderProduct (*outputs:rp*)", "``uint64``", "Pointer to render product for this view", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.examples.cpp.GpuInteropCpuToDisk"
"Version", "1"
"Extension", "omni.graph.examples.cpp"
"Has State?", "False"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "None"
"uiName", "Example Node: Cpu To Disk"
"Categories", "examples"
"Generated Class Name", "OgnGpuInteropCpuToDiskDatabase"
"Python Module", "omni.graph.examples.cpp"
| 3,437 | reStructuredText | 40.926829 | 187 | 0.625546 |
omniverse-code/kit/exts/omni.graph.examples.cpp/ogn/docs/OgnSimple.rst | .. _omni_graph_examples_cpp_Simple_1:
.. _omni_graph_examples_cpp_Simple:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Example Node: Simple Multiply
:keywords: lang-en omnigraph node examples threadsafe cpp simple
Example Node: Simple Multiply
=============================
.. <description>
Minimal compute node example that reads two floats and outputs their product
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.examples.cpp<ext_omni_graph_examples_cpp>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"inputs:multiplier", "``float``", "Multiplier of value", "0.0"
"inputs:value", "``float``", "Value to be multiplied", "0.0"
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"outputs:value", "``double``", "Result of the multiplication", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.examples.cpp.Simple"
"Version", "1"
"Extension", "omni.graph.examples.cpp"
"Has State?", "False"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "None"
"uiName", "Example Node: Simple Multiply"
"Categories", "examples"
"Generated Class Name", "OgnSimpleDatabase"
"Python Module", "omni.graph.examples.cpp"
| 1,683 | reStructuredText | 23.405797 | 109 | 0.565062 |
omniverse-code/kit/exts/omni.graph.examples.cpp/ogn/docs/OgnGpuInteropAdjustExposure.rst | .. _omni_graph_examples_cpp_GpuInteropAdjustExposure_1:
.. _omni_graph_examples_cpp_GpuInteropAdjustExposure:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Example Node: Render Postprocess
:keywords: lang-en omnigraph node examples cpp gpu-interop-adjust-exposure
Example Node: Render Postprocess
================================
.. <description>
RTX Renderer Postprocess Example (Exposure Adjustment)
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.examples.cpp<ext_omni_graph_examples_cpp>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"cudaMipmappedArray (*inputs:cudaMipmappedArray*)", "``uint64``", "Pointer to the CUDA Mipmapped Array", "0"
"exposure (*inputs:exposure*)", "``float``", "Exposure value (in stops)", "0.0"
"format (*inputs:format*)", "``uint64``", "Format", "0"
"height (*inputs:height*)", "``uint``", "Height", "0"
"hydraTime (*inputs:hydraTime*)", "``double``", "Hydra time in stage", "0.0"
"mipCount (*inputs:mipCount*)", "``uint``", "Mip Count", "0"
"simTime (*inputs:simTime*)", "``double``", "Simulation time", "0.0"
"stream (*inputs:stream*)", "``uint64``", "Pointer to the CUDA Stream", "0"
"width (*inputs:width*)", "``uint``", "Width", "0"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.examples.cpp.GpuInteropAdjustExposure"
"Version", "1"
"Extension", "omni.graph.examples.cpp"
"Has State?", "False"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "None"
"uiName", "Example Node: Render Postprocess"
"Categories", "examples"
"Generated Class Name", "OgnGpuInteropAdjustExposureDatabase"
"Python Module", "omni.graph.examples.cpp"
| 2,103 | reStructuredText | 30.402985 | 112 | 0.582026 |
omniverse-code/kit/exts/omni.graph.examples.cpp/ogn/docs/OgnDeformer1_CPU.rst | .. _omni_graph_examples_cpp_Deformer1_1:
.. _omni_graph_examples_cpp_Deformer1:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Example Node: Sine Wave Deformer
:keywords: lang-en omnigraph node examples threadsafe cpp deformer1
Example Node: Sine Wave Deformer
================================
.. <description>
Example deformer node that applies a sine wave to a mesh
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.examples.cpp<ext_omni_graph_examples_cpp>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"inputs:multiplier", "``float``", "Amplitude of sinusoidal deformer function", "0.7"
"inputs:points", "``pointf[3][]``", "Set of points to be deformed", "[]"
"inputs:wavelength", "``float``", "Wavelength of sinusodal deformer function", "50.0"
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"outputs:points", "``pointf[3][]``", "Set of deformed points", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.examples.cpp.Deformer1"
"Version", "1"
"Extension", "omni.graph.examples.cpp"
"Has State?", "False"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "None"
"uiName", "Example Node: Sine Wave Deformer"
"Categories", "examples"
"Generated Class Name", "OgnDeformer1_CPUDatabase"
"Python Module", "omni.graph.examples.cpp"
| 1,818 | reStructuredText | 24.985714 | 109 | 0.570957 |
omniverse-code/kit/exts/omni.graph.examples.cpp/ogn/docs/OgnExampleExtractFloat3Array.rst | .. _omni_graph_examples_cpp_ExtractFloat3Array_1:
.. _omni_graph_examples_cpp_ExtractFloat3Array:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Example Node: Extract Float3 Array
:keywords: lang-en omnigraph node examples threadsafe cpp extract-float3-array
Example Node: Extract Float3 Array
==================================
.. <description>
Outputs a float[3][] attribute extracted from a bundle.
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.examples.cpp<ext_omni_graph_examples_cpp>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"inputs:input", "``bundle``", "Bundle containing a float[3][] attribute to be extracted to 'output'", "None"
"inputs:nameOfAttribute", "``token``", "Name of the attribute in 'input' that is to be extracted to 'output'", ""
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"outputs:output", "``float[3][]``", "The float[3][] attribute extracted from 'input'", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.examples.cpp.ExtractFloat3Array"
"Version", "1"
"Extension", "omni.graph.examples.cpp"
"Has State?", "False"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "None"
"uiName", "Example Node: Extract Float3 Array"
"Categories", "examples"
"Generated Class Name", "OgnExampleExtractFloat3ArrayDatabase"
"Python Module", "omni.graph.examples.cpp"
| 1,874 | reStructuredText | 26.173913 | 117 | 0.584312 |
omniverse-code/kit/exts/omni.graph.examples.cpp/ogn/docs/OgnIK.rst | .. _omni_graph_examples_cpp_SimpleIk_1:
.. _omni_graph_examples_cpp_SimpleIk:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Example Node: Simple IK
:keywords: lang-en omnigraph node examples threadsafe cpp simple-ik
Example Node: Simple IK
=======================
.. <description>
Example node that employs a simple IK algorithm to match a three-joint limb to a goal
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.examples.cpp<ext_omni_graph_examples_cpp>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Goal Transform (*inputs:goal*)", "``matrixd[4]``", "Transform of the IK goal", "[[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]]"
State
-----
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Ankle Transform (*state:ankle*)", "``matrixd[4]``", "Computed transform of the ankle joint", "None"
"Hip Transform (*state:hip*)", "``matrixd[4]``", "Computed transform of the hip joint", "None"
"Knee Transform (*state:knee*)", "``matrixd[4]``", "Computed transform of the knee joint", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.examples.cpp.SimpleIk"
"Version", "1"
"Extension", "omni.graph.examples.cpp"
"Has State?", "True"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "None"
"uiName", "Example Node: Simple IK"
"Categories", "examples"
"Generated Class Name", "OgnIKDatabase"
"Python Module", "omni.graph.examples.cpp"
| 1,943 | reStructuredText | 26.771428 | 174 | 0.562017 |
omniverse-code/kit/exts/omni.graph.examples.cpp/config/extension.toml | [package]
title = "OmniGraph C++ Examples"
version = "1.4.2"
category = "Graph"
readme = "docs/README.md"
changelog = "docs/CHANGELOG.md"
description = "Contains a set of sample OmniGraph nodes implemented in C++."
repository = ""
keywords = ["kit", "omnigraph", "nodes"]
# Main module for the Python interface
[[python.module]]
name = "omni.graph.examples.cpp"
# Watch the .ogn files for hot reloading (only works for Python files)
[fswatcher.patterns]
include = ["*.ogn", "*.py"]
exclude = ["Ogn*Database.py"]
# Other extensions that need to load in order for this one to work
[dependencies]
"omni.graph" = {}
"omni.graph.tools" = {}
"omni.kit.pip_archive" = {}
# Python test scripts rely on numpy
[python.pipapi]
requirements = ["numpy"] # SWIPAT filed under: http://nvbugs/3193231
[[native.plugin]]
path = "bin/*.plugin"
recursive = false
[[test]]
timeout = 600 # OM-51983
[documentation]
deps = [
["kit-sdk", "_build/docs/kit-sdk/latest"], # WAR to include omni.graph refs until that workflow is moved
]
pages = [
"docs/Overview.md",
"docs/CHANGELOG.md",
]
| 1,081 | TOML | 23.044444 | 108 | 0.684551 |
omniverse-code/kit/exts/omni.graph.examples.cpp/omni/graph/examples/cpp/__init__.py | """Module containing example nodes written in C++.
There is no public API to this module.
"""
__all__ = []
from ._impl.extension import _PublicExtension as _OmniGraphExamplesCppExtension # noqa: F401
| 203 | Python | 24.499997 | 93 | 0.729064 |
omniverse-code/kit/exts/omni.graph.examples.cpp/omni/graph/examples/cpp/ogn/OgnExampleAdjacencyDatabase.py | """Support for simplified access to data on nodes of type omni.graph.examples.cpp.Adjacency
Computes chosen adjacency information from specified input mesh topology data.
"""
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 OgnExampleAdjacencyDatabase(og.Database):
"""Helper class providing simplified access to data on nodes of type omni.graph.examples.cpp.Adjacency
Class Members:
node: Node being evaluated
Attribute Value Properties:
Inputs:
inputs.computeDistances
inputs.computeNeighborCounts
inputs.computeNeighborStarts
inputs.computeNeighbors
inputs.mesh
inputs.nameOfDistancesOutputAttribute
inputs.nameOfNeighborCountsOutputAttribute
inputs.nameOfNeighborStartsOutputAttribute
inputs.nameOfNeighborsOutputAttribute
inputs.nameOfPositionsInputAttribute
inputs.nameOfVertexCountsInputAttribute
inputs.nameOfVertexIndicesInputAttribute
inputs.pointCount
inputs.removeDuplicates
inputs.treatEdgesAsOneWay
inputs.treatFacesAsCurves
Outputs:
outputs.mesh
"""
# 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:computeDistances', 'bool', 0, None, "When enabled, the distances from each point to its neighbors is computed and stored in a 'float[]' attribute in 'output' as specified by 'nameOfDistancesOutputAttribute'.", {ogn.MetadataKeys.DEFAULT: 'false'}, True, False, False, ''),
('inputs:computeNeighborCounts', 'bool', 0, None, "When enabled, the number of neighbors of each point is computed and all are stored in an 'int[]' attribute in 'output' as specified by 'nameOfNeighborCountsOutputAttribute'.", {ogn.MetadataKeys.DEFAULT: 'false'}, True, False, False, ''),
('inputs:computeNeighborStarts', 'bool', 0, None, "When enabled, the beginning index of neighbors of each point within the arrays computed by either 'computeNeighbors' or 'computeDistances' is computed and all, plus an additional integer to indicate the end of the array, are stored in an 'int[]' attribute in 'output' as specified by 'nameOfNeighborStartsOutputAttribute'. The extra integer at the end allows for easy computing of the number of neighbors of any single point, by subtracting the value in the array corresponding with the point, from the following value in the array.", {ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('inputs:computeNeighbors', 'bool', 0, None, "When enabled, the neighbors of each point are computed and stored contiguously in an 'int[]' attribute in 'output' as specified by 'nameOfNeighborsOutputAttribute'.", {ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('inputs:mesh', 'bundle', 0, None, 'Bundle containing topology data to be analysed', {}, True, None, False, ''),
('inputs:nameOfDistancesOutputAttribute', 'token', 0, None, "Name of the 'float[]' attribute to be created in 'output' to contain the computed distances to each neighbor. This is only used if 'computeDistances' is true.", {ogn.MetadataKeys.DEFAULT: '"distances"'}, True, "distances", False, ''),
('inputs:nameOfNeighborCountsOutputAttribute', 'token', 0, None, "Name of the 'int[]' attribute to be created in 'output' to contain the number of neighbors of each point. This is only used if 'computeNeighborCounts' is true. A running sum of this array can be computed using 'computeNeighborStarts'. The neighbors themselves can be computed using 'computeNeighbors'.", {ogn.MetadataKeys.DEFAULT: '"neighborCounts"'}, True, "neighborCounts", False, ''),
('inputs:nameOfNeighborStartsOutputAttribute', 'token', 0, None, "Name of the 'int[]' attribute to be created in 'output' to contain the beginning index of neighbors of each point in the arrays computed by either 'computeNeighbors' or 'computeDistances'. This is only used if 'computeNeighborStarts' is true.", {ogn.MetadataKeys.DEFAULT: '"neighborStarts"'}, True, "neighborStarts", False, ''),
('inputs:nameOfNeighborsOutputAttribute', 'token', 0, None, "Name of the 'int[]' attribute to be created in 'output' to contain the neighbors of all points. This is only used if 'computeNeighbors' is true. The beginnings of each point's neighbors within this array can be computed using 'computeNeighborStarts'. The number of neighbors of each point can be computed using 'computeNeighborCounts'.", {ogn.MetadataKeys.DEFAULT: '"neighbors"'}, True, "neighbors", False, ''),
('inputs:nameOfPositionsInputAttribute', 'token', 0, None, "Name of the 'point3f[]' attribute in 'mesh' containing the positions of each point. This is only used if 'computeDistances' is true. The element count of this array overrides 'pointCount', when used.", {ogn.MetadataKeys.DEFAULT: '"points"'}, True, "points", False, ''),
('inputs:nameOfVertexCountsInputAttribute', 'token', 0, None, "Name of the 'int[]' attribute in 'mesh' containing the vertex counts of each face", {ogn.MetadataKeys.DEFAULT: '"faceVertexCounts"'}, True, "faceVertexCounts", False, ''),
('inputs:nameOfVertexIndicesInputAttribute', 'token', 0, None, "Name of the 'int[]' attribute in 'mesh' containing the vertex indices of each face", {ogn.MetadataKeys.DEFAULT: '"faceVertexIndices"'}, True, "faceVertexIndices", False, ''),
('inputs:pointCount', 'int', 0, None, "Number of points being referred to in the vertex indices attribute. This is only used if 'computeDistances' is false, otherwise this is overridden by the element count of the attribute specified by 'nameOfPositionsInputAttribute'.", {}, True, 0, False, ''),
('inputs:removeDuplicates', 'bool', 0, None, 'When enabled, each neighbor of a point will be counted only once, instead of once per edge that connects the point to the neighbor.', {ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('inputs:treatEdgesAsOneWay', 'bool', 0, None, 'When enabled, if a face has an edge from A to B, B will be considered a neighbor of A, but A will not be considered a neighbor of B. This can be useful as part of identifying unshared edges or inconsistent face winding order.', {ogn.MetadataKeys.DEFAULT: 'false'}, True, False, False, ''),
('inputs:treatFacesAsCurves', 'bool', 0, None, 'When enabled, the input faces will be treated as curves, instead of closed polygons, i.e. no edge from the last vertex of each face to the first vertex of that face will be counted.', {ogn.MetadataKeys.DEFAULT: 'false'}, True, False, False, ''),
('outputs:mesh', 'bundle', 0, None, "A copy of the input 'mesh' with the computed attributes added, as specified above.", {}, 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.mesh = og.AttributeRole.BUNDLE
role_data.outputs.mesh = 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 computeDistances(self):
data_view = og.AttributeValueHelper(self._attributes.computeDistances)
return data_view.get()
@computeDistances.setter
def computeDistances(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.computeDistances)
data_view = og.AttributeValueHelper(self._attributes.computeDistances)
data_view.set(value)
@property
def computeNeighborCounts(self):
data_view = og.AttributeValueHelper(self._attributes.computeNeighborCounts)
return data_view.get()
@computeNeighborCounts.setter
def computeNeighborCounts(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.computeNeighborCounts)
data_view = og.AttributeValueHelper(self._attributes.computeNeighborCounts)
data_view.set(value)
@property
def computeNeighborStarts(self):
data_view = og.AttributeValueHelper(self._attributes.computeNeighborStarts)
return data_view.get()
@computeNeighborStarts.setter
def computeNeighborStarts(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.computeNeighborStarts)
data_view = og.AttributeValueHelper(self._attributes.computeNeighborStarts)
data_view.set(value)
@property
def computeNeighbors(self):
data_view = og.AttributeValueHelper(self._attributes.computeNeighbors)
return data_view.get()
@computeNeighbors.setter
def computeNeighbors(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.computeNeighbors)
data_view = og.AttributeValueHelper(self._attributes.computeNeighbors)
data_view.set(value)
@property
def mesh(self) -> og.BundleContents:
"""Get the bundle wrapper class for the attribute inputs.mesh"""
return self.__bundles.mesh
@property
def nameOfDistancesOutputAttribute(self):
data_view = og.AttributeValueHelper(self._attributes.nameOfDistancesOutputAttribute)
return data_view.get()
@nameOfDistancesOutputAttribute.setter
def nameOfDistancesOutputAttribute(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.nameOfDistancesOutputAttribute)
data_view = og.AttributeValueHelper(self._attributes.nameOfDistancesOutputAttribute)
data_view.set(value)
@property
def nameOfNeighborCountsOutputAttribute(self):
data_view = og.AttributeValueHelper(self._attributes.nameOfNeighborCountsOutputAttribute)
return data_view.get()
@nameOfNeighborCountsOutputAttribute.setter
def nameOfNeighborCountsOutputAttribute(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.nameOfNeighborCountsOutputAttribute)
data_view = og.AttributeValueHelper(self._attributes.nameOfNeighborCountsOutputAttribute)
data_view.set(value)
@property
def nameOfNeighborStartsOutputAttribute(self):
data_view = og.AttributeValueHelper(self._attributes.nameOfNeighborStartsOutputAttribute)
return data_view.get()
@nameOfNeighborStartsOutputAttribute.setter
def nameOfNeighborStartsOutputAttribute(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.nameOfNeighborStartsOutputAttribute)
data_view = og.AttributeValueHelper(self._attributes.nameOfNeighborStartsOutputAttribute)
data_view.set(value)
@property
def nameOfNeighborsOutputAttribute(self):
data_view = og.AttributeValueHelper(self._attributes.nameOfNeighborsOutputAttribute)
return data_view.get()
@nameOfNeighborsOutputAttribute.setter
def nameOfNeighborsOutputAttribute(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.nameOfNeighborsOutputAttribute)
data_view = og.AttributeValueHelper(self._attributes.nameOfNeighborsOutputAttribute)
data_view.set(value)
@property
def nameOfPositionsInputAttribute(self):
data_view = og.AttributeValueHelper(self._attributes.nameOfPositionsInputAttribute)
return data_view.get()
@nameOfPositionsInputAttribute.setter
def nameOfPositionsInputAttribute(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.nameOfPositionsInputAttribute)
data_view = og.AttributeValueHelper(self._attributes.nameOfPositionsInputAttribute)
data_view.set(value)
@property
def nameOfVertexCountsInputAttribute(self):
data_view = og.AttributeValueHelper(self._attributes.nameOfVertexCountsInputAttribute)
return data_view.get()
@nameOfVertexCountsInputAttribute.setter
def nameOfVertexCountsInputAttribute(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.nameOfVertexCountsInputAttribute)
data_view = og.AttributeValueHelper(self._attributes.nameOfVertexCountsInputAttribute)
data_view.set(value)
@property
def nameOfVertexIndicesInputAttribute(self):
data_view = og.AttributeValueHelper(self._attributes.nameOfVertexIndicesInputAttribute)
return data_view.get()
@nameOfVertexIndicesInputAttribute.setter
def nameOfVertexIndicesInputAttribute(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.nameOfVertexIndicesInputAttribute)
data_view = og.AttributeValueHelper(self._attributes.nameOfVertexIndicesInputAttribute)
data_view.set(value)
@property
def pointCount(self):
data_view = og.AttributeValueHelper(self._attributes.pointCount)
return data_view.get()
@pointCount.setter
def pointCount(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.pointCount)
data_view = og.AttributeValueHelper(self._attributes.pointCount)
data_view.set(value)
@property
def removeDuplicates(self):
data_view = og.AttributeValueHelper(self._attributes.removeDuplicates)
return data_view.get()
@removeDuplicates.setter
def removeDuplicates(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.removeDuplicates)
data_view = og.AttributeValueHelper(self._attributes.removeDuplicates)
data_view.set(value)
@property
def treatEdgesAsOneWay(self):
data_view = og.AttributeValueHelper(self._attributes.treatEdgesAsOneWay)
return data_view.get()
@treatEdgesAsOneWay.setter
def treatEdgesAsOneWay(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.treatEdgesAsOneWay)
data_view = og.AttributeValueHelper(self._attributes.treatEdgesAsOneWay)
data_view.set(value)
@property
def treatFacesAsCurves(self):
data_view = og.AttributeValueHelper(self._attributes.treatFacesAsCurves)
return data_view.get()
@treatFacesAsCurves.setter
def treatFacesAsCurves(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.treatFacesAsCurves)
data_view = og.AttributeValueHelper(self._attributes.treatFacesAsCurves)
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 mesh(self) -> og.BundleContents:
"""Get the bundle wrapper class for the attribute outputs.mesh"""
return self.__bundles.mesh
@mesh.setter
def mesh(self, bundle: og.BundleContents):
"""Overwrite the bundle attribute outputs.mesh 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.mesh.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 = OgnExampleAdjacencyDatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
self.outputs = OgnExampleAdjacencyDatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
self.state = OgnExampleAdjacencyDatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
| 19,410 | Python | 58.726154 | 654 | 0.688357 |
omniverse-code/kit/exts/omni.graph.examples.cpp/omni/graph/examples/cpp/ogn/OgnExampleSmoothDatabase.py | """Support for simplified access to data on nodes of type omni.graph.examples.cpp.Smooth
Smooths data in a very simple way by averaging values with neighbors.
"""
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 OgnExampleSmoothDatabase(og.Database):
"""Helper class providing simplified access to data on nodes of type omni.graph.examples.cpp.Smooth
Class Members:
node: Node being evaluated
Attribute Value Properties:
Inputs:
inputs.iterations
inputs.mesh
inputs.nameOfAttributeToSmooth
inputs.nameOfNeighborStartsInputAttribute
inputs.nameOfNeighborsInputAttribute
inputs.useGPU
Outputs:
outputs.mesh
"""
# 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:iterations', 'int', 0, None, 'Number of times to average neighboring values', {ogn.MetadataKeys.DEFAULT: '5'}, True, 5, False, ''),
('inputs:mesh', 'bundle', 0, None, 'Bundle containing data to be smoothed and neighbor arrays.', {}, True, None, False, ''),
('inputs:nameOfAttributeToSmooth', 'token', 0, None, "Name of the attribute in 'mesh' containing the data to be smoothed", {ogn.MetadataKeys.DEFAULT: '"points"'}, True, "points", False, ''),
('inputs:nameOfNeighborStartsInputAttribute', 'token', 0, None, "Name of the 'int[]' attribute in 'mesh' containing the beginning index of neighbors of each point in the array attribute specified by 'nameOfNeighborsInputAttribute'", {ogn.MetadataKeys.DEFAULT: '"neighborStarts"'}, True, "neighborStarts", False, ''),
('inputs:nameOfNeighborsInputAttribute', 'token', 0, None, "Name of the 'int[]' attribute in 'mesh' containing the neighbors of all points. The beginnings of each point's neighbors within this array are provided in the attribute specified by 'nameOfNeighborStartsInputAttribute'.", {ogn.MetadataKeys.DEFAULT: '"neighbors"'}, True, "neighbors", False, ''),
('inputs:useGPU', 'bool', 0, None, 'When this option is on, the node will use the GPU to perform the smoothing computation.', {ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('outputs:mesh', 'bundle', 0, None, "A copy of 'mesh' with the specified attribute smoothed.", {}, 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.mesh = og.AttributeRole.BUNDLE
role_data.outputs.mesh = 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 iterations(self):
data_view = og.AttributeValueHelper(self._attributes.iterations)
return data_view.get()
@iterations.setter
def iterations(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.iterations)
data_view = og.AttributeValueHelper(self._attributes.iterations)
data_view.set(value)
@property
def mesh(self) -> og.BundleContents:
"""Get the bundle wrapper class for the attribute inputs.mesh"""
return self.__bundles.mesh
@property
def nameOfAttributeToSmooth(self):
data_view = og.AttributeValueHelper(self._attributes.nameOfAttributeToSmooth)
return data_view.get()
@nameOfAttributeToSmooth.setter
def nameOfAttributeToSmooth(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.nameOfAttributeToSmooth)
data_view = og.AttributeValueHelper(self._attributes.nameOfAttributeToSmooth)
data_view.set(value)
@property
def nameOfNeighborStartsInputAttribute(self):
data_view = og.AttributeValueHelper(self._attributes.nameOfNeighborStartsInputAttribute)
return data_view.get()
@nameOfNeighborStartsInputAttribute.setter
def nameOfNeighborStartsInputAttribute(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.nameOfNeighborStartsInputAttribute)
data_view = og.AttributeValueHelper(self._attributes.nameOfNeighborStartsInputAttribute)
data_view.set(value)
@property
def nameOfNeighborsInputAttribute(self):
data_view = og.AttributeValueHelper(self._attributes.nameOfNeighborsInputAttribute)
return data_view.get()
@nameOfNeighborsInputAttribute.setter
def nameOfNeighborsInputAttribute(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.nameOfNeighborsInputAttribute)
data_view = og.AttributeValueHelper(self._attributes.nameOfNeighborsInputAttribute)
data_view.set(value)
@property
def useGPU(self):
data_view = og.AttributeValueHelper(self._attributes.useGPU)
return data_view.get()
@useGPU.setter
def useGPU(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.useGPU)
data_view = og.AttributeValueHelper(self._attributes.useGPU)
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 mesh(self) -> og.BundleContents:
"""Get the bundle wrapper class for the attribute outputs.mesh"""
return self.__bundles.mesh
@mesh.setter
def mesh(self, bundle: og.BundleContents):
"""Overwrite the bundle attribute outputs.mesh 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.mesh.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 = OgnExampleSmoothDatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
self.outputs = OgnExampleSmoothDatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
self.state = OgnExampleSmoothDatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
| 9,571 | Python | 50.74054 | 364 | 0.672448 |
omniverse-code/kit/exts/omni.graph.examples.cpp/omni/graph/examples/cpp/ogn/OgnUniversalAddDatabase.py | """Support for simplified access to data on nodes of type omni.graph.examples.cpp.UniversalAdd
Universal add node for all types. This file was originally generated using UniversalAddGenerator.py. Edits have been made
since the initial generation as the API evolved. This example uses outputs and pairs of inputs of every type to be 'universal'.
See the 'Add' node for a Python implementation that uses only one output and one pair of inputs using the 'any' type.
"""
import numpy
import omni.graph.core as og
import omni.graph.core._omni_graph_core as _og
import omni.graph.tools.ogn as ogn
class OgnUniversalAddDatabase(og.Database):
"""Helper class providing simplified access to data on nodes of type omni.graph.examples.cpp.UniversalAdd
Class Members:
node: Node being evaluated
Attribute Value Properties:
Inputs:
inputs.bool_0
inputs.bool_1
inputs.bool_arr_0
inputs.bool_arr_1
inputs.colord3_0
inputs.colord3_1
inputs.colord3_arr_0
inputs.colord3_arr_1
inputs.colord4_0
inputs.colord4_1
inputs.colord4_arr_0
inputs.colord4_arr_1
inputs.colorf3_0
inputs.colorf3_1
inputs.colorf3_arr_0
inputs.colorf3_arr_1
inputs.colorf4_0
inputs.colorf4_1
inputs.colorf4_arr_0
inputs.colorf4_arr_1
inputs.colorh3_0
inputs.colorh3_1
inputs.colorh3_arr_0
inputs.colorh3_arr_1
inputs.colorh4_0
inputs.colorh4_1
inputs.colorh4_arr_0
inputs.colorh4_arr_1
inputs.double2_0
inputs.double2_1
inputs.double2_arr_0
inputs.double2_arr_1
inputs.double3_0
inputs.double3_1
inputs.double3_arr_0
inputs.double3_arr_1
inputs.double4_0
inputs.double4_1
inputs.double4_arr_0
inputs.double4_arr_1
inputs.double_0
inputs.double_1
inputs.double_arr_0
inputs.double_arr_1
inputs.float2_0
inputs.float2_1
inputs.float2_arr_0
inputs.float2_arr_1
inputs.float3_0
inputs.float3_1
inputs.float3_arr_0
inputs.float3_arr_1
inputs.float4_0
inputs.float4_1
inputs.float4_arr_0
inputs.float4_arr_1
inputs.float_0
inputs.float_1
inputs.float_arr_0
inputs.float_arr_1
inputs.frame4_0
inputs.frame4_1
inputs.frame4_arr_0
inputs.frame4_arr_1
inputs.half2_0
inputs.half2_1
inputs.half2_arr_0
inputs.half2_arr_1
inputs.half3_0
inputs.half3_1
inputs.half3_arr_0
inputs.half3_arr_1
inputs.half4_0
inputs.half4_1
inputs.half4_arr_0
inputs.half4_arr_1
inputs.half_0
inputs.half_1
inputs.half_arr_0
inputs.half_arr_1
inputs.int2_0
inputs.int2_1
inputs.int2_arr_0
inputs.int2_arr_1
inputs.int3_0
inputs.int3_1
inputs.int3_arr_0
inputs.int3_arr_1
inputs.int4_0
inputs.int4_1
inputs.int4_arr_0
inputs.int4_arr_1
inputs.int64_0
inputs.int64_1
inputs.int64_arr_0
inputs.int64_arr_1
inputs.int_0
inputs.int_1
inputs.int_arr_0
inputs.int_arr_1
inputs.matrixd2_0
inputs.matrixd2_1
inputs.matrixd2_arr_0
inputs.matrixd2_arr_1
inputs.matrixd3_0
inputs.matrixd3_1
inputs.matrixd3_arr_0
inputs.matrixd3_arr_1
inputs.matrixd4_0
inputs.matrixd4_1
inputs.matrixd4_arr_0
inputs.matrixd4_arr_1
inputs.normald3_0
inputs.normald3_1
inputs.normald3_arr_0
inputs.normald3_arr_1
inputs.normalf3_0
inputs.normalf3_1
inputs.normalf3_arr_0
inputs.normalf3_arr_1
inputs.normalh3_0
inputs.normalh3_1
inputs.normalh3_arr_0
inputs.normalh3_arr_1
inputs.pointd3_0
inputs.pointd3_1
inputs.pointd3_arr_0
inputs.pointd3_arr_1
inputs.pointf3_0
inputs.pointf3_1
inputs.pointf3_arr_0
inputs.pointf3_arr_1
inputs.pointh3_0
inputs.pointh3_1
inputs.pointh3_arr_0
inputs.pointh3_arr_1
inputs.quatd4_0
inputs.quatd4_1
inputs.quatd4_arr_0
inputs.quatd4_arr_1
inputs.quatf4_0
inputs.quatf4_1
inputs.quatf4_arr_0
inputs.quatf4_arr_1
inputs.quath4_0
inputs.quath4_1
inputs.quath4_arr_0
inputs.quath4_arr_1
inputs.texcoordd2_0
inputs.texcoordd2_1
inputs.texcoordd2_arr_0
inputs.texcoordd2_arr_1
inputs.texcoordd3_0
inputs.texcoordd3_1
inputs.texcoordd3_arr_0
inputs.texcoordd3_arr_1
inputs.texcoordf2_0
inputs.texcoordf2_1
inputs.texcoordf2_arr_0
inputs.texcoordf2_arr_1
inputs.texcoordf3_0
inputs.texcoordf3_1
inputs.texcoordf3_arr_0
inputs.texcoordf3_arr_1
inputs.texcoordh2_0
inputs.texcoordh2_1
inputs.texcoordh2_arr_0
inputs.texcoordh2_arr_1
inputs.texcoordh3_0
inputs.texcoordh3_1
inputs.texcoordh3_arr_0
inputs.texcoordh3_arr_1
inputs.timecode_0
inputs.timecode_1
inputs.timecode_arr_0
inputs.timecode_arr_1
inputs.token_0
inputs.token_1
inputs.token_arr_0
inputs.token_arr_1
inputs.transform4_0
inputs.transform4_1
inputs.transform4_arr_0
inputs.transform4_arr_1
inputs.uchar_0
inputs.uchar_1
inputs.uchar_arr_0
inputs.uchar_arr_1
inputs.uint64_0
inputs.uint64_1
inputs.uint64_arr_0
inputs.uint64_arr_1
inputs.uint_0
inputs.uint_1
inputs.uint_arr_0
inputs.uint_arr_1
inputs.vectord3_0
inputs.vectord3_1
inputs.vectord3_arr_0
inputs.vectord3_arr_1
inputs.vectorf3_0
inputs.vectorf3_1
inputs.vectorf3_arr_0
inputs.vectorf3_arr_1
inputs.vectorh3_0
inputs.vectorh3_1
inputs.vectorh3_arr_0
inputs.vectorh3_arr_1
Outputs:
outputs.bool_0
outputs.bool_arr_0
outputs.colord3_0
outputs.colord3_arr_0
outputs.colord4_0
outputs.colord4_arr_0
outputs.colorf3_0
outputs.colorf3_arr_0
outputs.colorf4_0
outputs.colorf4_arr_0
outputs.colorh3_0
outputs.colorh3_arr_0
outputs.colorh4_0
outputs.colorh4_arr_0
outputs.double2_0
outputs.double2_arr_0
outputs.double3_0
outputs.double3_arr_0
outputs.double4_0
outputs.double4_arr_0
outputs.double_0
outputs.double_arr_0
outputs.float2_0
outputs.float2_arr_0
outputs.float3_0
outputs.float3_arr_0
outputs.float4_0
outputs.float4_arr_0
outputs.float_0
outputs.float_arr_0
outputs.frame4_0
outputs.frame4_arr_0
outputs.half2_0
outputs.half2_arr_0
outputs.half3_0
outputs.half3_arr_0
outputs.half4_0
outputs.half4_arr_0
outputs.half_0
outputs.half_arr_0
outputs.int2_0
outputs.int2_arr_0
outputs.int3_0
outputs.int3_arr_0
outputs.int4_0
outputs.int4_arr_0
outputs.int64_0
outputs.int64_arr_0
outputs.int_0
outputs.int_arr_0
outputs.matrixd2_0
outputs.matrixd2_arr_0
outputs.matrixd3_0
outputs.matrixd3_arr_0
outputs.matrixd4_0
outputs.matrixd4_arr_0
outputs.normald3_0
outputs.normald3_arr_0
outputs.normalf3_0
outputs.normalf3_arr_0
outputs.normalh3_0
outputs.normalh3_arr_0
outputs.pointd3_0
outputs.pointd3_arr_0
outputs.pointf3_0
outputs.pointf3_arr_0
outputs.pointh3_0
outputs.pointh3_arr_0
outputs.quatd4_0
outputs.quatd4_arr_0
outputs.quatf4_0
outputs.quatf4_arr_0
outputs.quath4_0
outputs.quath4_arr_0
outputs.texcoordd2_0
outputs.texcoordd2_arr_0
outputs.texcoordd3_0
outputs.texcoordd3_arr_0
outputs.texcoordf2_0
outputs.texcoordf2_arr_0
outputs.texcoordf3_0
outputs.texcoordf3_arr_0
outputs.texcoordh2_0
outputs.texcoordh2_arr_0
outputs.texcoordh3_0
outputs.texcoordh3_arr_0
outputs.timecode_0
outputs.timecode_arr_0
outputs.token_0
outputs.token_arr_0
outputs.transform4_0
outputs.transform4_arr_0
outputs.uchar_0
outputs.uchar_arr_0
outputs.uint64_0
outputs.uint64_arr_0
outputs.uint_0
outputs.uint_arr_0
outputs.vectord3_0
outputs.vectord3_arr_0
outputs.vectorf3_0
outputs.vectorf3_arr_0
outputs.vectorh3_0
outputs.vectorh3_arr_0
"""
# 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:bool_0', 'bool', 0, None, 'Input of type bool', {ogn.MetadataKeys.DEFAULT: 'false'}, True, False, False, ''),
('inputs:bool_1', 'bool', 0, None, 'Input of type bool', {ogn.MetadataKeys.DEFAULT: 'false'}, True, False, False, ''),
('inputs:bool_arr_0', 'bool[]', 0, None, 'Input of type bool[]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:bool_arr_1', 'bool[]', 0, None, 'Input of type bool[]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:colord3_0', 'color3d', 0, None, 'Input of type colord[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('inputs:colord3_1', 'color3d', 0, None, 'Input of type colord[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('inputs:colord3_arr_0', 'color3d[]', 0, None, 'Input of type colord[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:colord3_arr_1', 'color3d[]', 0, None, 'Input of type colord[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:colord4_0', 'color4d', 0, None, 'Input of type colord[4]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0], False, ''),
('inputs:colord4_1', 'color4d', 0, None, 'Input of type colord[4]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0], False, ''),
('inputs:colord4_arr_0', 'color4d[]', 0, None, 'Input of type colord[4][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:colord4_arr_1', 'color4d[]', 0, None, 'Input of type colord[4][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:colorf3_0', 'color3f', 0, None, 'Input of type colorf[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('inputs:colorf3_1', 'color3f', 0, None, 'Input of type colorf[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('inputs:colorf3_arr_0', 'color3f[]', 0, None, 'Input of type colorf[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:colorf3_arr_1', 'color3f[]', 0, None, 'Input of type colorf[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:colorf4_0', 'color4f', 0, None, 'Input of type colorf[4]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0], False, ''),
('inputs:colorf4_1', 'color4f', 0, None, 'Input of type colorf[4]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0], False, ''),
('inputs:colorf4_arr_0', 'color4f[]', 0, None, 'Input of type colorf[4][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:colorf4_arr_1', 'color4f[]', 0, None, 'Input of type colorf[4][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:colorh3_0', 'color3h', 0, None, 'Input of type colorh[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('inputs:colorh3_1', 'color3h', 0, None, 'Input of type colorh[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('inputs:colorh3_arr_0', 'color3h[]', 0, None, 'Input of type colorh[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:colorh3_arr_1', 'color3h[]', 0, None, 'Input of type colorh[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:colorh4_0', 'color4h', 0, None, 'Input of type colorh[4]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0], False, ''),
('inputs:colorh4_1', 'color4h', 0, None, 'Input of type colorh[4]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0], False, ''),
('inputs:colorh4_arr_0', 'color4h[]', 0, None, 'Input of type colorh[4][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:colorh4_arr_1', 'color4h[]', 0, None, 'Input of type colorh[4][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:double2_0', 'double2', 0, None, 'Input of type double[2]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0]'}, True, [0.0, 0.0], False, ''),
('inputs:double2_1', 'double2', 0, None, 'Input of type double[2]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0]'}, True, [0.0, 0.0], False, ''),
('inputs:double2_arr_0', 'double2[]', 0, None, 'Input of type double[2][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:double2_arr_1', 'double2[]', 0, None, 'Input of type double[2][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:double3_0', 'double3', 0, None, 'Input of type double[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('inputs:double3_1', 'double3', 0, None, 'Input of type double[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('inputs:double3_arr_0', 'double3[]', 0, None, 'Input of type double[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:double3_arr_1', 'double3[]', 0, None, 'Input of type double[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:double4_0', 'double4', 0, None, 'Input of type double[4]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0], False, ''),
('inputs:double4_1', 'double4', 0, None, 'Input of type double[4]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0], False, ''),
('inputs:double4_arr_0', 'double4[]', 0, None, 'Input of type double[4][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:double4_arr_1', 'double4[]', 0, None, 'Input of type double[4][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:double_0', 'double', 0, None, 'Input of type double', {ogn.MetadataKeys.DEFAULT: '0.0'}, True, 0.0, False, ''),
('inputs:double_1', 'double', 0, None, 'Input of type double', {ogn.MetadataKeys.DEFAULT: '0.0'}, True, 0.0, False, ''),
('inputs:double_arr_0', 'double[]', 0, None, 'Input of type double[]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:double_arr_1', 'double[]', 0, None, 'Input of type double[]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:float2_0', 'float2', 0, None, 'Input of type float[2]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0]'}, True, [0.0, 0.0], False, ''),
('inputs:float2_1', 'float2', 0, None, 'Input of type float[2]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0]'}, True, [0.0, 0.0], False, ''),
('inputs:float2_arr_0', 'float2[]', 0, None, 'Input of type float[2][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:float2_arr_1', 'float2[]', 0, None, 'Input of type float[2][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:float3_0', 'float3', 0, None, 'Input of type float[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('inputs:float3_1', 'float3', 0, None, 'Input of type float[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('inputs:float3_arr_0', 'float3[]', 0, None, 'Input of type float[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:float3_arr_1', 'float3[]', 0, None, 'Input of type float[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:float4_0', 'float4', 0, None, 'Input of type float[4]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0], False, ''),
('inputs:float4_1', 'float4', 0, None, 'Input of type float[4]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0], False, ''),
('inputs:float4_arr_0', 'float4[]', 0, None, 'Input of type float[4][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:float4_arr_1', 'float4[]', 0, None, 'Input of type float[4][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:float_0', 'float', 0, None, 'Input of type float', {ogn.MetadataKeys.DEFAULT: '0.0'}, True, 0.0, False, ''),
('inputs:float_1', 'float', 0, None, 'Input of type float', {ogn.MetadataKeys.DEFAULT: '0.0'}, True, 0.0, False, ''),
('inputs:float_arr_0', 'float[]', 0, None, 'Input of type float[]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:float_arr_1', 'float[]', 0, None, 'Input of type float[]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:frame4_0', 'frame4d', 0, None, 'Input of type frame[4]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], False, ''),
('inputs:frame4_1', 'frame4d', 0, None, 'Input of type frame[4]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], False, ''),
('inputs:frame4_arr_0', 'frame4d[]', 0, None, 'Input of type frame[4][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:frame4_arr_1', 'frame4d[]', 0, None, 'Input of type frame[4][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:half2_0', 'half2', 0, None, 'Input of type half[2]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0]'}, True, [0.0, 0.0], False, ''),
('inputs:half2_1', 'half2', 0, None, 'Input of type half[2]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0]'}, True, [0.0, 0.0], False, ''),
('inputs:half2_arr_0', 'half2[]', 0, None, 'Input of type half[2][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:half2_arr_1', 'half2[]', 0, None, 'Input of type half[2][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:half3_0', 'half3', 0, None, 'Input of type half[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('inputs:half3_1', 'half3', 0, None, 'Input of type half[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('inputs:half3_arr_0', 'half3[]', 0, None, 'Input of type half[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:half3_arr_1', 'half3[]', 0, None, 'Input of type half[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:half4_0', 'half4', 0, None, 'Input of type half[4]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0], False, ''),
('inputs:half4_1', 'half4', 0, None, 'Input of type half[4]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0], False, ''),
('inputs:half4_arr_0', 'half4[]', 0, None, 'Input of type half[4][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:half4_arr_1', 'half4[]', 0, None, 'Input of type half[4][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:half_0', 'half', 0, None, 'Input of type half', {ogn.MetadataKeys.DEFAULT: '0.0'}, True, 0.0, False, ''),
('inputs:half_1', 'half', 0, None, 'Input of type half', {ogn.MetadataKeys.DEFAULT: '0.0'}, True, 0.0, False, ''),
('inputs:half_arr_0', 'half[]', 0, None, 'Input of type half[]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:half_arr_1', 'half[]', 0, None, 'Input of type half[]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:int2_0', 'int2', 0, None, 'Input of type int[2]', {ogn.MetadataKeys.DEFAULT: '[0, 0]'}, True, [0, 0], False, ''),
('inputs:int2_1', 'int2', 0, None, 'Input of type int[2]', {ogn.MetadataKeys.DEFAULT: '[0, 0]'}, True, [0, 0], False, ''),
('inputs:int2_arr_0', 'int2[]', 0, None, 'Input of type int[2][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:int2_arr_1', 'int2[]', 0, None, 'Input of type int[2][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:int3_0', 'int3', 0, None, 'Input of type int[3]', {ogn.MetadataKeys.DEFAULT: '[0, 0, 0]'}, True, [0, 0, 0], False, ''),
('inputs:int3_1', 'int3', 0, None, 'Input of type int[3]', {ogn.MetadataKeys.DEFAULT: '[0, 0, 0]'}, True, [0, 0, 0], False, ''),
('inputs:int3_arr_0', 'int3[]', 0, None, 'Input of type int[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:int3_arr_1', 'int3[]', 0, None, 'Input of type int[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:int4_0', 'int4', 0, None, 'Input of type int[4]', {ogn.MetadataKeys.DEFAULT: '[0, 0, 0, 0]'}, True, [0, 0, 0, 0], False, ''),
('inputs:int4_1', 'int4', 0, None, 'Input of type int[4]', {ogn.MetadataKeys.DEFAULT: '[0, 0, 0, 0]'}, True, [0, 0, 0, 0], False, ''),
('inputs:int4_arr_0', 'int4[]', 0, None, 'Input of type int[4][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:int4_arr_1', 'int4[]', 0, None, 'Input of type int[4][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:int64_0', 'int64', 0, None, 'Input of type int64', {ogn.MetadataKeys.DEFAULT: '0'}, True, 0, False, ''),
('inputs:int64_1', 'int64', 0, None, 'Input of type int64', {ogn.MetadataKeys.DEFAULT: '0'}, True, 0, False, ''),
('inputs:int64_arr_0', 'int64[]', 0, None, 'Input of type int64[]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:int64_arr_1', 'int64[]', 0, None, 'Input of type int64[]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:int_0', 'int', 0, None, 'Input of type int', {ogn.MetadataKeys.DEFAULT: '0'}, True, 0, False, ''),
('inputs:int_1', 'int', 0, None, 'Input of type int', {ogn.MetadataKeys.DEFAULT: '0'}, True, 0, False, ''),
('inputs:int_arr_0', 'int[]', 0, None, 'Input of type int[]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:int_arr_1', 'int[]', 0, None, 'Input of type int[]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:matrixd2_0', 'matrix2d', 0, None, 'Input of type matrixd[2]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0], False, ''),
('inputs:matrixd2_1', 'matrix2d', 0, None, 'Input of type matrixd[2]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0], False, ''),
('inputs:matrixd2_arr_0', 'matrix2d[]', 0, None, 'Input of type matrixd[2][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:matrixd2_arr_1', 'matrix2d[]', 0, None, 'Input of type matrixd[2][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:matrixd3_0', 'matrix3d', 0, None, 'Input of type matrixd[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], False, ''),
('inputs:matrixd3_1', 'matrix3d', 0, None, 'Input of type matrixd[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], False, ''),
('inputs:matrixd3_arr_0', 'matrix3d[]', 0, None, 'Input of type matrixd[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:matrixd3_arr_1', 'matrix3d[]', 0, None, 'Input of type matrixd[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:matrixd4_0', 'matrix4d', 0, None, 'Input of type matrixd[4]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], False, ''),
('inputs:matrixd4_1', 'matrix4d', 0, None, 'Input of type matrixd[4]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], False, ''),
('inputs:matrixd4_arr_0', 'matrix4d[]', 0, None, 'Input of type matrixd[4][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:matrixd4_arr_1', 'matrix4d[]', 0, None, 'Input of type matrixd[4][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:normald3_0', 'normal3d', 0, None, 'Input of type normald[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('inputs:normald3_1', 'normal3d', 0, None, 'Input of type normald[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('inputs:normald3_arr_0', 'normal3d[]', 0, None, 'Input of type normald[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:normald3_arr_1', 'normal3d[]', 0, None, 'Input of type normald[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:normalf3_0', 'normal3f', 0, None, 'Input of type normalf[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('inputs:normalf3_1', 'normal3f', 0, None, 'Input of type normalf[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('inputs:normalf3_arr_0', 'normal3f[]', 0, None, 'Input of type normalf[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:normalf3_arr_1', 'normal3f[]', 0, None, 'Input of type normalf[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:normalh3_0', 'normal3h', 0, None, 'Input of type normalh[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('inputs:normalh3_1', 'normal3h', 0, None, 'Input of type normalh[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('inputs:normalh3_arr_0', 'normal3h[]', 0, None, 'Input of type normalh[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:normalh3_arr_1', 'normal3h[]', 0, None, 'Input of type normalh[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:pointd3_0', 'point3d', 0, None, 'Input of type pointd[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('inputs:pointd3_1', 'point3d', 0, None, 'Input of type pointd[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('inputs:pointd3_arr_0', 'point3d[]', 0, None, 'Input of type pointd[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:pointd3_arr_1', 'point3d[]', 0, None, 'Input of type pointd[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:pointf3_0', 'point3f', 0, None, 'Input of type pointf[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('inputs:pointf3_1', 'point3f', 0, None, 'Input of type pointf[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('inputs:pointf3_arr_0', 'point3f[]', 0, None, 'Input of type pointf[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:pointf3_arr_1', 'point3f[]', 0, None, 'Input of type pointf[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:pointh3_0', 'point3h', 0, None, 'Input of type pointh[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('inputs:pointh3_1', 'point3h', 0, None, 'Input of type pointh[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('inputs:pointh3_arr_0', 'point3h[]', 0, None, 'Input of type pointh[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:pointh3_arr_1', 'point3h[]', 0, None, 'Input of type pointh[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:quatd4_0', 'quatd', 0, None, 'Input of type quatd[4]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0], False, ''),
('inputs:quatd4_1', 'quatd', 0, None, 'Input of type quatd[4]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0], False, ''),
('inputs:quatd4_arr_0', 'quatd[]', 0, None, 'Input of type quatd[4][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:quatd4_arr_1', 'quatd[]', 0, None, 'Input of type quatd[4][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:quatf4_0', 'quatf', 0, None, 'Input of type quatf[4]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0], False, ''),
('inputs:quatf4_1', 'quatf', 0, None, 'Input of type quatf[4]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0], False, ''),
('inputs:quatf4_arr_0', 'quatf[]', 0, None, 'Input of type quatf[4][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:quatf4_arr_1', 'quatf[]', 0, None, 'Input of type quatf[4][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:quath4_0', 'quath', 0, None, 'Input of type quath[4]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0], False, ''),
('inputs:quath4_1', 'quath', 0, None, 'Input of type quath[4]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0], False, ''),
('inputs:quath4_arr_0', 'quath[]', 0, None, 'Input of type quath[4][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:quath4_arr_1', 'quath[]', 0, None, 'Input of type quath[4][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:texcoordd2_0', 'texCoord2d', 0, None, 'Input of type texcoordd[2]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0]'}, True, [0.0, 0.0], False, ''),
('inputs:texcoordd2_1', 'texCoord2d', 0, None, 'Input of type texcoordd[2]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0]'}, True, [0.0, 0.0], False, ''),
('inputs:texcoordd2_arr_0', 'texCoord2d[]', 0, None, 'Input of type texcoordd[2][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:texcoordd2_arr_1', 'texCoord2d[]', 0, None, 'Input of type texcoordd[2][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:texcoordd3_0', 'texCoord3d', 0, None, 'Input of type texcoordd[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('inputs:texcoordd3_1', 'texCoord3d', 0, None, 'Input of type texcoordd[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('inputs:texcoordd3_arr_0', 'texCoord3d[]', 0, None, 'Input of type texcoordd[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:texcoordd3_arr_1', 'texCoord3d[]', 0, None, 'Input of type texcoordd[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:texcoordf2_0', 'texCoord2f', 0, None, 'Input of type texcoordf[2]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0]'}, True, [0.0, 0.0], False, ''),
('inputs:texcoordf2_1', 'texCoord2f', 0, None, 'Input of type texcoordf[2]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0]'}, True, [0.0, 0.0], False, ''),
('inputs:texcoordf2_arr_0', 'texCoord2f[]', 0, None, 'Input of type texcoordf[2][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:texcoordf2_arr_1', 'texCoord2f[]', 0, None, 'Input of type texcoordf[2][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:texcoordf3_0', 'texCoord3f', 0, None, 'Input of type texcoordf[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('inputs:texcoordf3_1', 'texCoord3f', 0, None, 'Input of type texcoordf[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('inputs:texcoordf3_arr_0', 'texCoord3f[]', 0, None, 'Input of type texcoordf[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:texcoordf3_arr_1', 'texCoord3f[]', 0, None, 'Input of type texcoordf[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:texcoordh2_0', 'texCoord2h', 0, None, 'Input of type texcoordh[2]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0]'}, True, [0.0, 0.0], False, ''),
('inputs:texcoordh2_1', 'texCoord2h', 0, None, 'Input of type texcoordh[2]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0]'}, True, [0.0, 0.0], False, ''),
('inputs:texcoordh2_arr_0', 'texCoord2h[]', 0, None, 'Input of type texcoordh[2][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:texcoordh2_arr_1', 'texCoord2h[]', 0, None, 'Input of type texcoordh[2][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:texcoordh3_0', 'texCoord3h', 0, None, 'Input of type texcoordh[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('inputs:texcoordh3_1', 'texCoord3h', 0, None, 'Input of type texcoordh[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('inputs:texcoordh3_arr_0', 'texCoord3h[]', 0, None, 'Input of type texcoordh[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:texcoordh3_arr_1', 'texCoord3h[]', 0, None, 'Input of type texcoordh[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:timecode_0', 'timecode', 0, None, 'Input of type timecode', {ogn.MetadataKeys.DEFAULT: '0.0'}, True, 0.0, False, ''),
('inputs:timecode_1', 'timecode', 0, None, 'Input of type timecode', {ogn.MetadataKeys.DEFAULT: '0.0'}, True, 0.0, False, ''),
('inputs:timecode_arr_0', 'timecode[]', 0, None, 'Input of type timecode[]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:timecode_arr_1', 'timecode[]', 0, None, 'Input of type timecode[]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:token_0', 'token', 0, None, 'Input of type token', {ogn.MetadataKeys.DEFAULT: '"default_token"'}, True, "default_token", False, ''),
('inputs:token_1', 'token', 0, None, 'Input of type token', {ogn.MetadataKeys.DEFAULT: '"default_token"'}, True, "default_token", False, ''),
('inputs:token_arr_0', 'token[]', 0, None, 'Input of type token[]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:token_arr_1', 'token[]', 0, None, 'Input of type token[]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:transform4_0', 'frame4d', 0, None, 'Input of type transform[4]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], False, ''),
('inputs:transform4_1', 'frame4d', 0, None, 'Input of type transform[4]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], False, ''),
('inputs:transform4_arr_0', 'frame4d[]', 0, None, 'Input of type transform[4][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:transform4_arr_1', 'frame4d[]', 0, None, 'Input of type transform[4][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:uchar_0', 'uchar', 0, None, 'Input of type uchar', {ogn.MetadataKeys.DEFAULT: '0'}, True, 0, False, ''),
('inputs:uchar_1', 'uchar', 0, None, 'Input of type uchar', {ogn.MetadataKeys.DEFAULT: '0'}, True, 0, False, ''),
('inputs:uchar_arr_0', 'uchar[]', 0, None, 'Input of type uchar[]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:uchar_arr_1', 'uchar[]', 0, None, 'Input of type uchar[]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:uint64_0', 'uint64', 0, None, 'Input of type uint64', {ogn.MetadataKeys.DEFAULT: '0'}, True, 0, False, ''),
('inputs:uint64_1', 'uint64', 0, None, 'Input of type uint64', {ogn.MetadataKeys.DEFAULT: '0'}, True, 0, False, ''),
('inputs:uint64_arr_0', 'uint64[]', 0, None, 'Input of type uint64[]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:uint64_arr_1', 'uint64[]', 0, None, 'Input of type uint64[]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:uint_0', 'uint', 0, None, 'Input of type uint', {ogn.MetadataKeys.DEFAULT: '0'}, True, 0, False, ''),
('inputs:uint_1', 'uint', 0, None, 'Input of type uint', {ogn.MetadataKeys.DEFAULT: '0'}, True, 0, False, ''),
('inputs:uint_arr_0', 'uint[]', 0, None, 'Input of type uint[]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:uint_arr_1', 'uint[]', 0, None, 'Input of type uint[]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:vectord3_0', 'vector3d', 0, None, 'Input of type vectord[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('inputs:vectord3_1', 'vector3d', 0, None, 'Input of type vectord[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('inputs:vectord3_arr_0', 'vector3d[]', 0, None, 'Input of type vectord[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:vectord3_arr_1', 'vector3d[]', 0, None, 'Input of type vectord[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:vectorf3_0', 'vector3f', 0, None, 'Input of type vectorf[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('inputs:vectorf3_1', 'vector3f', 0, None, 'Input of type vectorf[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('inputs:vectorf3_arr_0', 'vector3f[]', 0, None, 'Input of type vectorf[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:vectorf3_arr_1', 'vector3f[]', 0, None, 'Input of type vectorf[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:vectorh3_0', 'vector3h', 0, None, 'Input of type vectorh[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('inputs:vectorh3_1', 'vector3h', 0, None, 'Input of type vectorh[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('inputs:vectorh3_arr_0', 'vector3h[]', 0, None, 'Input of type vectorh[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:vectorh3_arr_1', 'vector3h[]', 0, None, 'Input of type vectorh[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:bool_0', 'bool', 0, None, 'Output of type bool', {ogn.MetadataKeys.DEFAULT: 'false'}, True, False, False, ''),
('outputs:bool_arr_0', 'bool[]', 0, None, 'Output of type bool[]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:colord3_0', 'color3d', 0, None, 'Output of type colord[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('outputs:colord3_arr_0', 'color3d[]', 0, None, 'Output of type colord[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:colord4_0', 'color4d', 0, None, 'Output of type colord[4]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0], False, ''),
('outputs:colord4_arr_0', 'color4d[]', 0, None, 'Output of type colord[4][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:colorf3_0', 'color3f', 0, None, 'Output of type colorf[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('outputs:colorf3_arr_0', 'color3f[]', 0, None, 'Output of type colorf[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:colorf4_0', 'color4f', 0, None, 'Output of type colorf[4]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0], False, ''),
('outputs:colorf4_arr_0', 'color4f[]', 0, None, 'Output of type colorf[4][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:colorh3_0', 'color3h', 0, None, 'Output of type colorh[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('outputs:colorh3_arr_0', 'color3h[]', 0, None, 'Output of type colorh[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:colorh4_0', 'color4h', 0, None, 'Output of type colorh[4]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0], False, ''),
('outputs:colorh4_arr_0', 'color4h[]', 0, None, 'Output of type colorh[4][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:double2_0', 'double2', 0, None, 'Output of type double[2]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0]'}, True, [0.0, 0.0], False, ''),
('outputs:double2_arr_0', 'double2[]', 0, None, 'Output of type double[2][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:double3_0', 'double3', 0, None, 'Output of type double[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('outputs:double3_arr_0', 'double3[]', 0, None, 'Output of type double[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:double4_0', 'double4', 0, None, 'Output of type double[4]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0], False, ''),
('outputs:double4_arr_0', 'double4[]', 0, None, 'Output of type double[4][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:double_0', 'double', 0, None, 'Output of type double', {ogn.MetadataKeys.DEFAULT: '0.0'}, True, 0.0, False, ''),
('outputs:double_arr_0', 'double[]', 0, None, 'Output of type double[]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:float2_0', 'float2', 0, None, 'Output of type float[2]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0]'}, True, [0.0, 0.0], False, ''),
('outputs:float2_arr_0', 'float2[]', 0, None, 'Output of type float[2][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:float3_0', 'float3', 0, None, 'Output of type float[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('outputs:float3_arr_0', 'float3[]', 0, None, 'Output of type float[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:float4_0', 'float4', 0, None, 'Output of type float[4]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0], False, ''),
('outputs:float4_arr_0', 'float4[]', 0, None, 'Output of type float[4][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:float_0', 'float', 0, None, 'Output of type float', {ogn.MetadataKeys.DEFAULT: '0.0'}, True, 0.0, False, ''),
('outputs:float_arr_0', 'float[]', 0, None, 'Output of type float[]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:frame4_0', 'frame4d', 0, None, 'Output of type frame[4]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], False, ''),
('outputs:frame4_arr_0', 'frame4d[]', 0, None, 'Output of type frame[4][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:half2_0', 'half2', 0, None, 'Output of type half[2]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0]'}, True, [0.0, 0.0], False, ''),
('outputs:half2_arr_0', 'half2[]', 0, None, 'Output of type half[2][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:half3_0', 'half3', 0, None, 'Output of type half[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('outputs:half3_arr_0', 'half3[]', 0, None, 'Output of type half[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:half4_0', 'half4', 0, None, 'Output of type half[4]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0], False, ''),
('outputs:half4_arr_0', 'half4[]', 0, None, 'Output of type half[4][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:half_0', 'half', 0, None, 'Output of type half', {ogn.MetadataKeys.DEFAULT: '0.0'}, True, 0.0, False, ''),
('outputs:half_arr_0', 'half[]', 0, None, 'Output of type half[]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:int2_0', 'int2', 0, None, 'Output of type int[2]', {ogn.MetadataKeys.DEFAULT: '[0, 0]'}, True, [0, 0], False, ''),
('outputs:int2_arr_0', 'int2[]', 0, None, 'Output of type int[2][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:int3_0', 'int3', 0, None, 'Output of type int[3]', {ogn.MetadataKeys.DEFAULT: '[0, 0, 0]'}, True, [0, 0, 0], False, ''),
('outputs:int3_arr_0', 'int3[]', 0, None, 'Output of type int[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:int4_0', 'int4', 0, None, 'Output of type int[4]', {ogn.MetadataKeys.DEFAULT: '[0, 0, 0, 0]'}, True, [0, 0, 0, 0], False, ''),
('outputs:int4_arr_0', 'int4[]', 0, None, 'Output of type int[4][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:int64_0', 'int64', 0, None, 'Output of type int64', {ogn.MetadataKeys.DEFAULT: '0'}, True, 0, False, ''),
('outputs:int64_arr_0', 'int64[]', 0, None, 'Output of type int64[]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:int_0', 'int', 0, None, 'Output of type int', {ogn.MetadataKeys.DEFAULT: '0'}, True, 0, False, ''),
('outputs:int_arr_0', 'int[]', 0, None, 'Output of type int[]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:matrixd2_0', 'matrix2d', 0, None, 'Output of type matrixd[2]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0], False, ''),
('outputs:matrixd2_arr_0', 'matrix2d[]', 0, None, 'Output of type matrixd[2][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:matrixd3_0', 'matrix3d', 0, None, 'Output of type matrixd[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], False, ''),
('outputs:matrixd3_arr_0', 'matrix3d[]', 0, None, 'Output of type matrixd[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:matrixd4_0', 'matrix4d', 0, None, 'Output of type matrixd[4]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], False, ''),
('outputs:matrixd4_arr_0', 'matrix4d[]', 0, None, 'Output of type matrixd[4][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:normald3_0', 'normal3d', 0, None, 'Output of type normald[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('outputs:normald3_arr_0', 'normal3d[]', 0, None, 'Output of type normald[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:normalf3_0', 'normal3f', 0, None, 'Output of type normalf[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('outputs:normalf3_arr_0', 'normal3f[]', 0, None, 'Output of type normalf[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:normalh3_0', 'normal3h', 0, None, 'Output of type normalh[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('outputs:normalh3_arr_0', 'normal3h[]', 0, None, 'Output of type normalh[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:pointd3_0', 'point3d', 0, None, 'Output of type pointd[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('outputs:pointd3_arr_0', 'point3d[]', 0, None, 'Output of type pointd[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:pointf3_0', 'point3f', 0, None, 'Output of type pointf[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('outputs:pointf3_arr_0', 'point3f[]', 0, None, 'Output of type pointf[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:pointh3_0', 'point3h', 0, None, 'Output of type pointh[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('outputs:pointh3_arr_0', 'point3h[]', 0, None, 'Output of type pointh[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:quatd4_0', 'quatd', 0, None, 'Output of type quatd[4]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0], False, ''),
('outputs:quatd4_arr_0', 'quatd[]', 0, None, 'Output of type quatd[4][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:quatf4_0', 'quatf', 0, None, 'Output of type quatf[4]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0], False, ''),
('outputs:quatf4_arr_0', 'quatf[]', 0, None, 'Output of type quatf[4][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:quath4_0', 'quath', 0, None, 'Output of type quath[4]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0], False, ''),
('outputs:quath4_arr_0', 'quath[]', 0, None, 'Output of type quath[4][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:texcoordd2_0', 'texCoord2d', 0, None, 'Output of type texcoordd[2]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0]'}, True, [0.0, 0.0], False, ''),
('outputs:texcoordd2_arr_0', 'texCoord2d[]', 0, None, 'Output of type texcoordd[2][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:texcoordd3_0', 'texCoord3d', 0, None, 'Output of type texcoordd[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('outputs:texcoordd3_arr_0', 'texCoord3d[]', 0, None, 'Output of type texcoordd[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:texcoordf2_0', 'texCoord2f', 0, None, 'Output of type texcoordf[2]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0]'}, True, [0.0, 0.0], False, ''),
('outputs:texcoordf2_arr_0', 'texCoord2f[]', 0, None, 'Output of type texcoordf[2][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:texcoordf3_0', 'texCoord3f', 0, None, 'Output of type texcoordf[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('outputs:texcoordf3_arr_0', 'texCoord3f[]', 0, None, 'Output of type texcoordf[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:texcoordh2_0', 'texCoord2h', 0, None, 'Output of type texcoordh[2]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0]'}, True, [0.0, 0.0], False, ''),
('outputs:texcoordh2_arr_0', 'texCoord2h[]', 0, None, 'Output of type texcoordh[2][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:texcoordh3_0', 'texCoord3h', 0, None, 'Output of type texcoordh[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('outputs:texcoordh3_arr_0', 'texCoord3h[]', 0, None, 'Output of type texcoordh[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:timecode_0', 'timecode', 0, None, 'Output of type timecode', {ogn.MetadataKeys.DEFAULT: '0.0'}, True, 0.0, False, ''),
('outputs:timecode_arr_0', 'timecode[]', 0, None, 'Output of type timecode[]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:token_0', 'token', 0, None, 'Output of type token', {ogn.MetadataKeys.DEFAULT: '"default_token"'}, True, "default_token", False, ''),
('outputs:token_arr_0', 'token[]', 0, None, 'Output of type token[]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:transform4_0', 'frame4d', 0, None, 'Output of type transform[4]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], False, ''),
('outputs:transform4_arr_0', 'frame4d[]', 0, None, 'Output of type transform[4][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:uchar_0', 'uchar', 0, None, 'Output of type uchar', {ogn.MetadataKeys.DEFAULT: '0'}, True, 0, False, ''),
('outputs:uchar_arr_0', 'uchar[]', 0, None, 'Output of type uchar[]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:uint64_0', 'uint64', 0, None, 'Output of type uint64', {ogn.MetadataKeys.DEFAULT: '0'}, True, 0, False, ''),
('outputs:uint64_arr_0', 'uint64[]', 0, None, 'Output of type uint64[]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:uint_0', 'uint', 0, None, 'Output of type uint', {ogn.MetadataKeys.DEFAULT: '0'}, True, 0, False, ''),
('outputs:uint_arr_0', 'uint[]', 0, None, 'Output of type uint[]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:vectord3_0', 'vector3d', 0, None, 'Output of type vectord[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('outputs:vectord3_arr_0', 'vector3d[]', 0, None, 'Output of type vectord[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:vectorf3_0', 'vector3f', 0, None, 'Output of type vectorf[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('outputs:vectorf3_arr_0', 'vector3f[]', 0, None, 'Output of type vectorf[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:vectorh3_0', 'vector3h', 0, None, 'Output of type vectorh[3]', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('outputs:vectorh3_arr_0', 'vector3h[]', 0, None, 'Output of type vectorh[3][]', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], 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.colord3_0 = og.AttributeRole.COLOR
role_data.inputs.colord3_1 = og.AttributeRole.COLOR
role_data.inputs.colord3_arr_0 = og.AttributeRole.COLOR
role_data.inputs.colord3_arr_1 = og.AttributeRole.COLOR
role_data.inputs.colord4_0 = og.AttributeRole.COLOR
role_data.inputs.colord4_1 = og.AttributeRole.COLOR
role_data.inputs.colord4_arr_0 = og.AttributeRole.COLOR
role_data.inputs.colord4_arr_1 = og.AttributeRole.COLOR
role_data.inputs.colorf3_0 = og.AttributeRole.COLOR
role_data.inputs.colorf3_1 = og.AttributeRole.COLOR
role_data.inputs.colorf3_arr_0 = og.AttributeRole.COLOR
role_data.inputs.colorf3_arr_1 = og.AttributeRole.COLOR
role_data.inputs.colorf4_0 = og.AttributeRole.COLOR
role_data.inputs.colorf4_1 = og.AttributeRole.COLOR
role_data.inputs.colorf4_arr_0 = og.AttributeRole.COLOR
role_data.inputs.colorf4_arr_1 = og.AttributeRole.COLOR
role_data.inputs.colorh3_0 = og.AttributeRole.COLOR
role_data.inputs.colorh3_1 = og.AttributeRole.COLOR
role_data.inputs.colorh3_arr_0 = og.AttributeRole.COLOR
role_data.inputs.colorh3_arr_1 = og.AttributeRole.COLOR
role_data.inputs.colorh4_0 = og.AttributeRole.COLOR
role_data.inputs.colorh4_1 = og.AttributeRole.COLOR
role_data.inputs.colorh4_arr_0 = og.AttributeRole.COLOR
role_data.inputs.colorh4_arr_1 = og.AttributeRole.COLOR
role_data.inputs.frame4_0 = og.AttributeRole.FRAME
role_data.inputs.frame4_1 = og.AttributeRole.FRAME
role_data.inputs.frame4_arr_0 = og.AttributeRole.FRAME
role_data.inputs.frame4_arr_1 = og.AttributeRole.FRAME
role_data.inputs.matrixd2_0 = og.AttributeRole.MATRIX
role_data.inputs.matrixd2_1 = og.AttributeRole.MATRIX
role_data.inputs.matrixd2_arr_0 = og.AttributeRole.MATRIX
role_data.inputs.matrixd2_arr_1 = og.AttributeRole.MATRIX
role_data.inputs.matrixd3_0 = og.AttributeRole.MATRIX
role_data.inputs.matrixd3_1 = og.AttributeRole.MATRIX
role_data.inputs.matrixd3_arr_0 = og.AttributeRole.MATRIX
role_data.inputs.matrixd3_arr_1 = og.AttributeRole.MATRIX
role_data.inputs.matrixd4_0 = og.AttributeRole.MATRIX
role_data.inputs.matrixd4_1 = og.AttributeRole.MATRIX
role_data.inputs.matrixd4_arr_0 = og.AttributeRole.MATRIX
role_data.inputs.matrixd4_arr_1 = og.AttributeRole.MATRIX
role_data.inputs.normald3_0 = og.AttributeRole.NORMAL
role_data.inputs.normald3_1 = og.AttributeRole.NORMAL
role_data.inputs.normald3_arr_0 = og.AttributeRole.NORMAL
role_data.inputs.normald3_arr_1 = og.AttributeRole.NORMAL
role_data.inputs.normalf3_0 = og.AttributeRole.NORMAL
role_data.inputs.normalf3_1 = og.AttributeRole.NORMAL
role_data.inputs.normalf3_arr_0 = og.AttributeRole.NORMAL
role_data.inputs.normalf3_arr_1 = og.AttributeRole.NORMAL
role_data.inputs.normalh3_0 = og.AttributeRole.NORMAL
role_data.inputs.normalh3_1 = og.AttributeRole.NORMAL
role_data.inputs.normalh3_arr_0 = og.AttributeRole.NORMAL
role_data.inputs.normalh3_arr_1 = og.AttributeRole.NORMAL
role_data.inputs.pointd3_0 = og.AttributeRole.POSITION
role_data.inputs.pointd3_1 = og.AttributeRole.POSITION
role_data.inputs.pointd3_arr_0 = og.AttributeRole.POSITION
role_data.inputs.pointd3_arr_1 = og.AttributeRole.POSITION
role_data.inputs.pointf3_0 = og.AttributeRole.POSITION
role_data.inputs.pointf3_1 = og.AttributeRole.POSITION
role_data.inputs.pointf3_arr_0 = og.AttributeRole.POSITION
role_data.inputs.pointf3_arr_1 = og.AttributeRole.POSITION
role_data.inputs.pointh3_0 = og.AttributeRole.POSITION
role_data.inputs.pointh3_1 = og.AttributeRole.POSITION
role_data.inputs.pointh3_arr_0 = og.AttributeRole.POSITION
role_data.inputs.pointh3_arr_1 = og.AttributeRole.POSITION
role_data.inputs.quatd4_0 = og.AttributeRole.QUATERNION
role_data.inputs.quatd4_1 = og.AttributeRole.QUATERNION
role_data.inputs.quatd4_arr_0 = og.AttributeRole.QUATERNION
role_data.inputs.quatd4_arr_1 = og.AttributeRole.QUATERNION
role_data.inputs.quatf4_0 = og.AttributeRole.QUATERNION
role_data.inputs.quatf4_1 = og.AttributeRole.QUATERNION
role_data.inputs.quatf4_arr_0 = og.AttributeRole.QUATERNION
role_data.inputs.quatf4_arr_1 = og.AttributeRole.QUATERNION
role_data.inputs.quath4_0 = og.AttributeRole.QUATERNION
role_data.inputs.quath4_1 = og.AttributeRole.QUATERNION
role_data.inputs.quath4_arr_0 = og.AttributeRole.QUATERNION
role_data.inputs.quath4_arr_1 = og.AttributeRole.QUATERNION
role_data.inputs.texcoordd2_0 = og.AttributeRole.TEXCOORD
role_data.inputs.texcoordd2_1 = og.AttributeRole.TEXCOORD
role_data.inputs.texcoordd2_arr_0 = og.AttributeRole.TEXCOORD
role_data.inputs.texcoordd2_arr_1 = og.AttributeRole.TEXCOORD
role_data.inputs.texcoordd3_0 = og.AttributeRole.TEXCOORD
role_data.inputs.texcoordd3_1 = og.AttributeRole.TEXCOORD
role_data.inputs.texcoordd3_arr_0 = og.AttributeRole.TEXCOORD
role_data.inputs.texcoordd3_arr_1 = og.AttributeRole.TEXCOORD
role_data.inputs.texcoordf2_0 = og.AttributeRole.TEXCOORD
role_data.inputs.texcoordf2_1 = og.AttributeRole.TEXCOORD
role_data.inputs.texcoordf2_arr_0 = og.AttributeRole.TEXCOORD
role_data.inputs.texcoordf2_arr_1 = og.AttributeRole.TEXCOORD
role_data.inputs.texcoordf3_0 = og.AttributeRole.TEXCOORD
role_data.inputs.texcoordf3_1 = og.AttributeRole.TEXCOORD
role_data.inputs.texcoordf3_arr_0 = og.AttributeRole.TEXCOORD
role_data.inputs.texcoordf3_arr_1 = og.AttributeRole.TEXCOORD
role_data.inputs.texcoordh2_0 = og.AttributeRole.TEXCOORD
role_data.inputs.texcoordh2_1 = og.AttributeRole.TEXCOORD
role_data.inputs.texcoordh2_arr_0 = og.AttributeRole.TEXCOORD
role_data.inputs.texcoordh2_arr_1 = og.AttributeRole.TEXCOORD
role_data.inputs.texcoordh3_0 = og.AttributeRole.TEXCOORD
role_data.inputs.texcoordh3_1 = og.AttributeRole.TEXCOORD
role_data.inputs.texcoordh3_arr_0 = og.AttributeRole.TEXCOORD
role_data.inputs.texcoordh3_arr_1 = og.AttributeRole.TEXCOORD
role_data.inputs.timecode_0 = og.AttributeRole.TIMECODE
role_data.inputs.timecode_1 = og.AttributeRole.TIMECODE
role_data.inputs.timecode_arr_0 = og.AttributeRole.TIMECODE
role_data.inputs.timecode_arr_1 = og.AttributeRole.TIMECODE
role_data.inputs.transform4_0 = og.AttributeRole.TRANSFORM
role_data.inputs.transform4_1 = og.AttributeRole.TRANSFORM
role_data.inputs.transform4_arr_0 = og.AttributeRole.TRANSFORM
role_data.inputs.transform4_arr_1 = og.AttributeRole.TRANSFORM
role_data.inputs.vectord3_0 = og.AttributeRole.VECTOR
role_data.inputs.vectord3_1 = og.AttributeRole.VECTOR
role_data.inputs.vectord3_arr_0 = og.AttributeRole.VECTOR
role_data.inputs.vectord3_arr_1 = og.AttributeRole.VECTOR
role_data.inputs.vectorf3_0 = og.AttributeRole.VECTOR
role_data.inputs.vectorf3_1 = og.AttributeRole.VECTOR
role_data.inputs.vectorf3_arr_0 = og.AttributeRole.VECTOR
role_data.inputs.vectorf3_arr_1 = og.AttributeRole.VECTOR
role_data.inputs.vectorh3_0 = og.AttributeRole.VECTOR
role_data.inputs.vectorh3_1 = og.AttributeRole.VECTOR
role_data.inputs.vectorh3_arr_0 = og.AttributeRole.VECTOR
role_data.inputs.vectorh3_arr_1 = og.AttributeRole.VECTOR
role_data.outputs.colord3_0 = og.AttributeRole.COLOR
role_data.outputs.colord3_arr_0 = og.AttributeRole.COLOR
role_data.outputs.colord4_0 = og.AttributeRole.COLOR
role_data.outputs.colord4_arr_0 = og.AttributeRole.COLOR
role_data.outputs.colorf3_0 = og.AttributeRole.COLOR
role_data.outputs.colorf3_arr_0 = og.AttributeRole.COLOR
role_data.outputs.colorf4_0 = og.AttributeRole.COLOR
role_data.outputs.colorf4_arr_0 = og.AttributeRole.COLOR
role_data.outputs.colorh3_0 = og.AttributeRole.COLOR
role_data.outputs.colorh3_arr_0 = og.AttributeRole.COLOR
role_data.outputs.colorh4_0 = og.AttributeRole.COLOR
role_data.outputs.colorh4_arr_0 = og.AttributeRole.COLOR
role_data.outputs.frame4_0 = og.AttributeRole.FRAME
role_data.outputs.frame4_arr_0 = og.AttributeRole.FRAME
role_data.outputs.matrixd2_0 = og.AttributeRole.MATRIX
role_data.outputs.matrixd2_arr_0 = og.AttributeRole.MATRIX
role_data.outputs.matrixd3_0 = og.AttributeRole.MATRIX
role_data.outputs.matrixd3_arr_0 = og.AttributeRole.MATRIX
role_data.outputs.matrixd4_0 = og.AttributeRole.MATRIX
role_data.outputs.matrixd4_arr_0 = og.AttributeRole.MATRIX
role_data.outputs.normald3_0 = og.AttributeRole.NORMAL
role_data.outputs.normald3_arr_0 = og.AttributeRole.NORMAL
role_data.outputs.normalf3_0 = og.AttributeRole.NORMAL
role_data.outputs.normalf3_arr_0 = og.AttributeRole.NORMAL
role_data.outputs.normalh3_0 = og.AttributeRole.NORMAL
role_data.outputs.normalh3_arr_0 = og.AttributeRole.NORMAL
role_data.outputs.pointd3_0 = og.AttributeRole.POSITION
role_data.outputs.pointd3_arr_0 = og.AttributeRole.POSITION
role_data.outputs.pointf3_0 = og.AttributeRole.POSITION
role_data.outputs.pointf3_arr_0 = og.AttributeRole.POSITION
role_data.outputs.pointh3_0 = og.AttributeRole.POSITION
role_data.outputs.pointh3_arr_0 = og.AttributeRole.POSITION
role_data.outputs.quatd4_0 = og.AttributeRole.QUATERNION
role_data.outputs.quatd4_arr_0 = og.AttributeRole.QUATERNION
role_data.outputs.quatf4_0 = og.AttributeRole.QUATERNION
role_data.outputs.quatf4_arr_0 = og.AttributeRole.QUATERNION
role_data.outputs.quath4_0 = og.AttributeRole.QUATERNION
role_data.outputs.quath4_arr_0 = og.AttributeRole.QUATERNION
role_data.outputs.texcoordd2_0 = og.AttributeRole.TEXCOORD
role_data.outputs.texcoordd2_arr_0 = og.AttributeRole.TEXCOORD
role_data.outputs.texcoordd3_0 = og.AttributeRole.TEXCOORD
role_data.outputs.texcoordd3_arr_0 = og.AttributeRole.TEXCOORD
role_data.outputs.texcoordf2_0 = og.AttributeRole.TEXCOORD
role_data.outputs.texcoordf2_arr_0 = og.AttributeRole.TEXCOORD
role_data.outputs.texcoordf3_0 = og.AttributeRole.TEXCOORD
role_data.outputs.texcoordf3_arr_0 = og.AttributeRole.TEXCOORD
role_data.outputs.texcoordh2_0 = og.AttributeRole.TEXCOORD
role_data.outputs.texcoordh2_arr_0 = og.AttributeRole.TEXCOORD
role_data.outputs.texcoordh3_0 = og.AttributeRole.TEXCOORD
role_data.outputs.texcoordh3_arr_0 = og.AttributeRole.TEXCOORD
role_data.outputs.timecode_0 = og.AttributeRole.TIMECODE
role_data.outputs.timecode_arr_0 = og.AttributeRole.TIMECODE
role_data.outputs.transform4_0 = og.AttributeRole.TRANSFORM
role_data.outputs.transform4_arr_0 = og.AttributeRole.TRANSFORM
role_data.outputs.vectord3_0 = og.AttributeRole.VECTOR
role_data.outputs.vectord3_arr_0 = og.AttributeRole.VECTOR
role_data.outputs.vectorf3_0 = og.AttributeRole.VECTOR
role_data.outputs.vectorf3_arr_0 = og.AttributeRole.VECTOR
role_data.outputs.vectorh3_0 = og.AttributeRole.VECTOR
role_data.outputs.vectorh3_arr_0 = og.AttributeRole.VECTOR
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._batchedReadAttributes = []
self._batchedReadValues = []
@property
def bool_0(self):
data_view = og.AttributeValueHelper(self._attributes.bool_0)
return data_view.get()
@bool_0.setter
def bool_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.bool_0)
data_view = og.AttributeValueHelper(self._attributes.bool_0)
data_view.set(value)
@property
def bool_1(self):
data_view = og.AttributeValueHelper(self._attributes.bool_1)
return data_view.get()
@bool_1.setter
def bool_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.bool_1)
data_view = og.AttributeValueHelper(self._attributes.bool_1)
data_view.set(value)
@property
def bool_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.bool_arr_0)
return data_view.get()
@bool_arr_0.setter
def bool_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.bool_arr_0)
data_view = og.AttributeValueHelper(self._attributes.bool_arr_0)
data_view.set(value)
self.bool_arr_0_size = data_view.get_array_size()
@property
def bool_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.bool_arr_1)
return data_view.get()
@bool_arr_1.setter
def bool_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.bool_arr_1)
data_view = og.AttributeValueHelper(self._attributes.bool_arr_1)
data_view.set(value)
self.bool_arr_1_size = data_view.get_array_size()
@property
def colord3_0(self):
data_view = og.AttributeValueHelper(self._attributes.colord3_0)
return data_view.get()
@colord3_0.setter
def colord3_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.colord3_0)
data_view = og.AttributeValueHelper(self._attributes.colord3_0)
data_view.set(value)
@property
def colord3_1(self):
data_view = og.AttributeValueHelper(self._attributes.colord3_1)
return data_view.get()
@colord3_1.setter
def colord3_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.colord3_1)
data_view = og.AttributeValueHelper(self._attributes.colord3_1)
data_view.set(value)
@property
def colord3_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.colord3_arr_0)
return data_view.get()
@colord3_arr_0.setter
def colord3_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.colord3_arr_0)
data_view = og.AttributeValueHelper(self._attributes.colord3_arr_0)
data_view.set(value)
self.colord3_arr_0_size = data_view.get_array_size()
@property
def colord3_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.colord3_arr_1)
return data_view.get()
@colord3_arr_1.setter
def colord3_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.colord3_arr_1)
data_view = og.AttributeValueHelper(self._attributes.colord3_arr_1)
data_view.set(value)
self.colord3_arr_1_size = data_view.get_array_size()
@property
def colord4_0(self):
data_view = og.AttributeValueHelper(self._attributes.colord4_0)
return data_view.get()
@colord4_0.setter
def colord4_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.colord4_0)
data_view = og.AttributeValueHelper(self._attributes.colord4_0)
data_view.set(value)
@property
def colord4_1(self):
data_view = og.AttributeValueHelper(self._attributes.colord4_1)
return data_view.get()
@colord4_1.setter
def colord4_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.colord4_1)
data_view = og.AttributeValueHelper(self._attributes.colord4_1)
data_view.set(value)
@property
def colord4_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.colord4_arr_0)
return data_view.get()
@colord4_arr_0.setter
def colord4_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.colord4_arr_0)
data_view = og.AttributeValueHelper(self._attributes.colord4_arr_0)
data_view.set(value)
self.colord4_arr_0_size = data_view.get_array_size()
@property
def colord4_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.colord4_arr_1)
return data_view.get()
@colord4_arr_1.setter
def colord4_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.colord4_arr_1)
data_view = og.AttributeValueHelper(self._attributes.colord4_arr_1)
data_view.set(value)
self.colord4_arr_1_size = data_view.get_array_size()
@property
def colorf3_0(self):
data_view = og.AttributeValueHelper(self._attributes.colorf3_0)
return data_view.get()
@colorf3_0.setter
def colorf3_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.colorf3_0)
data_view = og.AttributeValueHelper(self._attributes.colorf3_0)
data_view.set(value)
@property
def colorf3_1(self):
data_view = og.AttributeValueHelper(self._attributes.colorf3_1)
return data_view.get()
@colorf3_1.setter
def colorf3_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.colorf3_1)
data_view = og.AttributeValueHelper(self._attributes.colorf3_1)
data_view.set(value)
@property
def colorf3_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.colorf3_arr_0)
return data_view.get()
@colorf3_arr_0.setter
def colorf3_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.colorf3_arr_0)
data_view = og.AttributeValueHelper(self._attributes.colorf3_arr_0)
data_view.set(value)
self.colorf3_arr_0_size = data_view.get_array_size()
@property
def colorf3_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.colorf3_arr_1)
return data_view.get()
@colorf3_arr_1.setter
def colorf3_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.colorf3_arr_1)
data_view = og.AttributeValueHelper(self._attributes.colorf3_arr_1)
data_view.set(value)
self.colorf3_arr_1_size = data_view.get_array_size()
@property
def colorf4_0(self):
data_view = og.AttributeValueHelper(self._attributes.colorf4_0)
return data_view.get()
@colorf4_0.setter
def colorf4_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.colorf4_0)
data_view = og.AttributeValueHelper(self._attributes.colorf4_0)
data_view.set(value)
@property
def colorf4_1(self):
data_view = og.AttributeValueHelper(self._attributes.colorf4_1)
return data_view.get()
@colorf4_1.setter
def colorf4_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.colorf4_1)
data_view = og.AttributeValueHelper(self._attributes.colorf4_1)
data_view.set(value)
@property
def colorf4_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.colorf4_arr_0)
return data_view.get()
@colorf4_arr_0.setter
def colorf4_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.colorf4_arr_0)
data_view = og.AttributeValueHelper(self._attributes.colorf4_arr_0)
data_view.set(value)
self.colorf4_arr_0_size = data_view.get_array_size()
@property
def colorf4_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.colorf4_arr_1)
return data_view.get()
@colorf4_arr_1.setter
def colorf4_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.colorf4_arr_1)
data_view = og.AttributeValueHelper(self._attributes.colorf4_arr_1)
data_view.set(value)
self.colorf4_arr_1_size = data_view.get_array_size()
@property
def colorh3_0(self):
data_view = og.AttributeValueHelper(self._attributes.colorh3_0)
return data_view.get()
@colorh3_0.setter
def colorh3_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.colorh3_0)
data_view = og.AttributeValueHelper(self._attributes.colorh3_0)
data_view.set(value)
@property
def colorh3_1(self):
data_view = og.AttributeValueHelper(self._attributes.colorh3_1)
return data_view.get()
@colorh3_1.setter
def colorh3_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.colorh3_1)
data_view = og.AttributeValueHelper(self._attributes.colorh3_1)
data_view.set(value)
@property
def colorh3_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.colorh3_arr_0)
return data_view.get()
@colorh3_arr_0.setter
def colorh3_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.colorh3_arr_0)
data_view = og.AttributeValueHelper(self._attributes.colorh3_arr_0)
data_view.set(value)
self.colorh3_arr_0_size = data_view.get_array_size()
@property
def colorh3_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.colorh3_arr_1)
return data_view.get()
@colorh3_arr_1.setter
def colorh3_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.colorh3_arr_1)
data_view = og.AttributeValueHelper(self._attributes.colorh3_arr_1)
data_view.set(value)
self.colorh3_arr_1_size = data_view.get_array_size()
@property
def colorh4_0(self):
data_view = og.AttributeValueHelper(self._attributes.colorh4_0)
return data_view.get()
@colorh4_0.setter
def colorh4_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.colorh4_0)
data_view = og.AttributeValueHelper(self._attributes.colorh4_0)
data_view.set(value)
@property
def colorh4_1(self):
data_view = og.AttributeValueHelper(self._attributes.colorh4_1)
return data_view.get()
@colorh4_1.setter
def colorh4_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.colorh4_1)
data_view = og.AttributeValueHelper(self._attributes.colorh4_1)
data_view.set(value)
@property
def colorh4_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.colorh4_arr_0)
return data_view.get()
@colorh4_arr_0.setter
def colorh4_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.colorh4_arr_0)
data_view = og.AttributeValueHelper(self._attributes.colorh4_arr_0)
data_view.set(value)
self.colorh4_arr_0_size = data_view.get_array_size()
@property
def colorh4_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.colorh4_arr_1)
return data_view.get()
@colorh4_arr_1.setter
def colorh4_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.colorh4_arr_1)
data_view = og.AttributeValueHelper(self._attributes.colorh4_arr_1)
data_view.set(value)
self.colorh4_arr_1_size = data_view.get_array_size()
@property
def double2_0(self):
data_view = og.AttributeValueHelper(self._attributes.double2_0)
return data_view.get()
@double2_0.setter
def double2_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.double2_0)
data_view = og.AttributeValueHelper(self._attributes.double2_0)
data_view.set(value)
@property
def double2_1(self):
data_view = og.AttributeValueHelper(self._attributes.double2_1)
return data_view.get()
@double2_1.setter
def double2_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.double2_1)
data_view = og.AttributeValueHelper(self._attributes.double2_1)
data_view.set(value)
@property
def double2_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.double2_arr_0)
return data_view.get()
@double2_arr_0.setter
def double2_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.double2_arr_0)
data_view = og.AttributeValueHelper(self._attributes.double2_arr_0)
data_view.set(value)
self.double2_arr_0_size = data_view.get_array_size()
@property
def double2_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.double2_arr_1)
return data_view.get()
@double2_arr_1.setter
def double2_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.double2_arr_1)
data_view = og.AttributeValueHelper(self._attributes.double2_arr_1)
data_view.set(value)
self.double2_arr_1_size = data_view.get_array_size()
@property
def double3_0(self):
data_view = og.AttributeValueHelper(self._attributes.double3_0)
return data_view.get()
@double3_0.setter
def double3_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.double3_0)
data_view = og.AttributeValueHelper(self._attributes.double3_0)
data_view.set(value)
@property
def double3_1(self):
data_view = og.AttributeValueHelper(self._attributes.double3_1)
return data_view.get()
@double3_1.setter
def double3_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.double3_1)
data_view = og.AttributeValueHelper(self._attributes.double3_1)
data_view.set(value)
@property
def double3_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.double3_arr_0)
return data_view.get()
@double3_arr_0.setter
def double3_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.double3_arr_0)
data_view = og.AttributeValueHelper(self._attributes.double3_arr_0)
data_view.set(value)
self.double3_arr_0_size = data_view.get_array_size()
@property
def double3_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.double3_arr_1)
return data_view.get()
@double3_arr_1.setter
def double3_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.double3_arr_1)
data_view = og.AttributeValueHelper(self._attributes.double3_arr_1)
data_view.set(value)
self.double3_arr_1_size = data_view.get_array_size()
@property
def double4_0(self):
data_view = og.AttributeValueHelper(self._attributes.double4_0)
return data_view.get()
@double4_0.setter
def double4_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.double4_0)
data_view = og.AttributeValueHelper(self._attributes.double4_0)
data_view.set(value)
@property
def double4_1(self):
data_view = og.AttributeValueHelper(self._attributes.double4_1)
return data_view.get()
@double4_1.setter
def double4_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.double4_1)
data_view = og.AttributeValueHelper(self._attributes.double4_1)
data_view.set(value)
@property
def double4_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.double4_arr_0)
return data_view.get()
@double4_arr_0.setter
def double4_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.double4_arr_0)
data_view = og.AttributeValueHelper(self._attributes.double4_arr_0)
data_view.set(value)
self.double4_arr_0_size = data_view.get_array_size()
@property
def double4_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.double4_arr_1)
return data_view.get()
@double4_arr_1.setter
def double4_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.double4_arr_1)
data_view = og.AttributeValueHelper(self._attributes.double4_arr_1)
data_view.set(value)
self.double4_arr_1_size = data_view.get_array_size()
@property
def double_0(self):
data_view = og.AttributeValueHelper(self._attributes.double_0)
return data_view.get()
@double_0.setter
def double_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.double_0)
data_view = og.AttributeValueHelper(self._attributes.double_0)
data_view.set(value)
@property
def double_1(self):
data_view = og.AttributeValueHelper(self._attributes.double_1)
return data_view.get()
@double_1.setter
def double_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.double_1)
data_view = og.AttributeValueHelper(self._attributes.double_1)
data_view.set(value)
@property
def double_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.double_arr_0)
return data_view.get()
@double_arr_0.setter
def double_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.double_arr_0)
data_view = og.AttributeValueHelper(self._attributes.double_arr_0)
data_view.set(value)
self.double_arr_0_size = data_view.get_array_size()
@property
def double_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.double_arr_1)
return data_view.get()
@double_arr_1.setter
def double_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.double_arr_1)
data_view = og.AttributeValueHelper(self._attributes.double_arr_1)
data_view.set(value)
self.double_arr_1_size = data_view.get_array_size()
@property
def float2_0(self):
data_view = og.AttributeValueHelper(self._attributes.float2_0)
return data_view.get()
@float2_0.setter
def float2_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.float2_0)
data_view = og.AttributeValueHelper(self._attributes.float2_0)
data_view.set(value)
@property
def float2_1(self):
data_view = og.AttributeValueHelper(self._attributes.float2_1)
return data_view.get()
@float2_1.setter
def float2_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.float2_1)
data_view = og.AttributeValueHelper(self._attributes.float2_1)
data_view.set(value)
@property
def float2_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.float2_arr_0)
return data_view.get()
@float2_arr_0.setter
def float2_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.float2_arr_0)
data_view = og.AttributeValueHelper(self._attributes.float2_arr_0)
data_view.set(value)
self.float2_arr_0_size = data_view.get_array_size()
@property
def float2_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.float2_arr_1)
return data_view.get()
@float2_arr_1.setter
def float2_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.float2_arr_1)
data_view = og.AttributeValueHelper(self._attributes.float2_arr_1)
data_view.set(value)
self.float2_arr_1_size = data_view.get_array_size()
@property
def float3_0(self):
data_view = og.AttributeValueHelper(self._attributes.float3_0)
return data_view.get()
@float3_0.setter
def float3_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.float3_0)
data_view = og.AttributeValueHelper(self._attributes.float3_0)
data_view.set(value)
@property
def float3_1(self):
data_view = og.AttributeValueHelper(self._attributes.float3_1)
return data_view.get()
@float3_1.setter
def float3_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.float3_1)
data_view = og.AttributeValueHelper(self._attributes.float3_1)
data_view.set(value)
@property
def float3_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.float3_arr_0)
return data_view.get()
@float3_arr_0.setter
def float3_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.float3_arr_0)
data_view = og.AttributeValueHelper(self._attributes.float3_arr_0)
data_view.set(value)
self.float3_arr_0_size = data_view.get_array_size()
@property
def float3_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.float3_arr_1)
return data_view.get()
@float3_arr_1.setter
def float3_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.float3_arr_1)
data_view = og.AttributeValueHelper(self._attributes.float3_arr_1)
data_view.set(value)
self.float3_arr_1_size = data_view.get_array_size()
@property
def float4_0(self):
data_view = og.AttributeValueHelper(self._attributes.float4_0)
return data_view.get()
@float4_0.setter
def float4_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.float4_0)
data_view = og.AttributeValueHelper(self._attributes.float4_0)
data_view.set(value)
@property
def float4_1(self):
data_view = og.AttributeValueHelper(self._attributes.float4_1)
return data_view.get()
@float4_1.setter
def float4_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.float4_1)
data_view = og.AttributeValueHelper(self._attributes.float4_1)
data_view.set(value)
@property
def float4_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.float4_arr_0)
return data_view.get()
@float4_arr_0.setter
def float4_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.float4_arr_0)
data_view = og.AttributeValueHelper(self._attributes.float4_arr_0)
data_view.set(value)
self.float4_arr_0_size = data_view.get_array_size()
@property
def float4_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.float4_arr_1)
return data_view.get()
@float4_arr_1.setter
def float4_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.float4_arr_1)
data_view = og.AttributeValueHelper(self._attributes.float4_arr_1)
data_view.set(value)
self.float4_arr_1_size = data_view.get_array_size()
@property
def float_0(self):
data_view = og.AttributeValueHelper(self._attributes.float_0)
return data_view.get()
@float_0.setter
def float_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.float_0)
data_view = og.AttributeValueHelper(self._attributes.float_0)
data_view.set(value)
@property
def float_1(self):
data_view = og.AttributeValueHelper(self._attributes.float_1)
return data_view.get()
@float_1.setter
def float_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.float_1)
data_view = og.AttributeValueHelper(self._attributes.float_1)
data_view.set(value)
@property
def float_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.float_arr_0)
return data_view.get()
@float_arr_0.setter
def float_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.float_arr_0)
data_view = og.AttributeValueHelper(self._attributes.float_arr_0)
data_view.set(value)
self.float_arr_0_size = data_view.get_array_size()
@property
def float_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.float_arr_1)
return data_view.get()
@float_arr_1.setter
def float_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.float_arr_1)
data_view = og.AttributeValueHelper(self._attributes.float_arr_1)
data_view.set(value)
self.float_arr_1_size = data_view.get_array_size()
@property
def frame4_0(self):
data_view = og.AttributeValueHelper(self._attributes.frame4_0)
return data_view.get()
@frame4_0.setter
def frame4_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.frame4_0)
data_view = og.AttributeValueHelper(self._attributes.frame4_0)
data_view.set(value)
@property
def frame4_1(self):
data_view = og.AttributeValueHelper(self._attributes.frame4_1)
return data_view.get()
@frame4_1.setter
def frame4_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.frame4_1)
data_view = og.AttributeValueHelper(self._attributes.frame4_1)
data_view.set(value)
@property
def frame4_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.frame4_arr_0)
return data_view.get()
@frame4_arr_0.setter
def frame4_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.frame4_arr_0)
data_view = og.AttributeValueHelper(self._attributes.frame4_arr_0)
data_view.set(value)
self.frame4_arr_0_size = data_view.get_array_size()
@property
def frame4_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.frame4_arr_1)
return data_view.get()
@frame4_arr_1.setter
def frame4_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.frame4_arr_1)
data_view = og.AttributeValueHelper(self._attributes.frame4_arr_1)
data_view.set(value)
self.frame4_arr_1_size = data_view.get_array_size()
@property
def half2_0(self):
data_view = og.AttributeValueHelper(self._attributes.half2_0)
return data_view.get()
@half2_0.setter
def half2_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.half2_0)
data_view = og.AttributeValueHelper(self._attributes.half2_0)
data_view.set(value)
@property
def half2_1(self):
data_view = og.AttributeValueHelper(self._attributes.half2_1)
return data_view.get()
@half2_1.setter
def half2_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.half2_1)
data_view = og.AttributeValueHelper(self._attributes.half2_1)
data_view.set(value)
@property
def half2_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.half2_arr_0)
return data_view.get()
@half2_arr_0.setter
def half2_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.half2_arr_0)
data_view = og.AttributeValueHelper(self._attributes.half2_arr_0)
data_view.set(value)
self.half2_arr_0_size = data_view.get_array_size()
@property
def half2_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.half2_arr_1)
return data_view.get()
@half2_arr_1.setter
def half2_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.half2_arr_1)
data_view = og.AttributeValueHelper(self._attributes.half2_arr_1)
data_view.set(value)
self.half2_arr_1_size = data_view.get_array_size()
@property
def half3_0(self):
data_view = og.AttributeValueHelper(self._attributes.half3_0)
return data_view.get()
@half3_0.setter
def half3_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.half3_0)
data_view = og.AttributeValueHelper(self._attributes.half3_0)
data_view.set(value)
@property
def half3_1(self):
data_view = og.AttributeValueHelper(self._attributes.half3_1)
return data_view.get()
@half3_1.setter
def half3_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.half3_1)
data_view = og.AttributeValueHelper(self._attributes.half3_1)
data_view.set(value)
@property
def half3_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.half3_arr_0)
return data_view.get()
@half3_arr_0.setter
def half3_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.half3_arr_0)
data_view = og.AttributeValueHelper(self._attributes.half3_arr_0)
data_view.set(value)
self.half3_arr_0_size = data_view.get_array_size()
@property
def half3_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.half3_arr_1)
return data_view.get()
@half3_arr_1.setter
def half3_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.half3_arr_1)
data_view = og.AttributeValueHelper(self._attributes.half3_arr_1)
data_view.set(value)
self.half3_arr_1_size = data_view.get_array_size()
@property
def half4_0(self):
data_view = og.AttributeValueHelper(self._attributes.half4_0)
return data_view.get()
@half4_0.setter
def half4_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.half4_0)
data_view = og.AttributeValueHelper(self._attributes.half4_0)
data_view.set(value)
@property
def half4_1(self):
data_view = og.AttributeValueHelper(self._attributes.half4_1)
return data_view.get()
@half4_1.setter
def half4_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.half4_1)
data_view = og.AttributeValueHelper(self._attributes.half4_1)
data_view.set(value)
@property
def half4_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.half4_arr_0)
return data_view.get()
@half4_arr_0.setter
def half4_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.half4_arr_0)
data_view = og.AttributeValueHelper(self._attributes.half4_arr_0)
data_view.set(value)
self.half4_arr_0_size = data_view.get_array_size()
@property
def half4_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.half4_arr_1)
return data_view.get()
@half4_arr_1.setter
def half4_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.half4_arr_1)
data_view = og.AttributeValueHelper(self._attributes.half4_arr_1)
data_view.set(value)
self.half4_arr_1_size = data_view.get_array_size()
@property
def half_0(self):
data_view = og.AttributeValueHelper(self._attributes.half_0)
return data_view.get()
@half_0.setter
def half_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.half_0)
data_view = og.AttributeValueHelper(self._attributes.half_0)
data_view.set(value)
@property
def half_1(self):
data_view = og.AttributeValueHelper(self._attributes.half_1)
return data_view.get()
@half_1.setter
def half_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.half_1)
data_view = og.AttributeValueHelper(self._attributes.half_1)
data_view.set(value)
@property
def half_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.half_arr_0)
return data_view.get()
@half_arr_0.setter
def half_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.half_arr_0)
data_view = og.AttributeValueHelper(self._attributes.half_arr_0)
data_view.set(value)
self.half_arr_0_size = data_view.get_array_size()
@property
def half_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.half_arr_1)
return data_view.get()
@half_arr_1.setter
def half_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.half_arr_1)
data_view = og.AttributeValueHelper(self._attributes.half_arr_1)
data_view.set(value)
self.half_arr_1_size = data_view.get_array_size()
@property
def int2_0(self):
data_view = og.AttributeValueHelper(self._attributes.int2_0)
return data_view.get()
@int2_0.setter
def int2_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.int2_0)
data_view = og.AttributeValueHelper(self._attributes.int2_0)
data_view.set(value)
@property
def int2_1(self):
data_view = og.AttributeValueHelper(self._attributes.int2_1)
return data_view.get()
@int2_1.setter
def int2_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.int2_1)
data_view = og.AttributeValueHelper(self._attributes.int2_1)
data_view.set(value)
@property
def int2_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.int2_arr_0)
return data_view.get()
@int2_arr_0.setter
def int2_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.int2_arr_0)
data_view = og.AttributeValueHelper(self._attributes.int2_arr_0)
data_view.set(value)
self.int2_arr_0_size = data_view.get_array_size()
@property
def int2_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.int2_arr_1)
return data_view.get()
@int2_arr_1.setter
def int2_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.int2_arr_1)
data_view = og.AttributeValueHelper(self._attributes.int2_arr_1)
data_view.set(value)
self.int2_arr_1_size = data_view.get_array_size()
@property
def int3_0(self):
data_view = og.AttributeValueHelper(self._attributes.int3_0)
return data_view.get()
@int3_0.setter
def int3_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.int3_0)
data_view = og.AttributeValueHelper(self._attributes.int3_0)
data_view.set(value)
@property
def int3_1(self):
data_view = og.AttributeValueHelper(self._attributes.int3_1)
return data_view.get()
@int3_1.setter
def int3_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.int3_1)
data_view = og.AttributeValueHelper(self._attributes.int3_1)
data_view.set(value)
@property
def int3_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.int3_arr_0)
return data_view.get()
@int3_arr_0.setter
def int3_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.int3_arr_0)
data_view = og.AttributeValueHelper(self._attributes.int3_arr_0)
data_view.set(value)
self.int3_arr_0_size = data_view.get_array_size()
@property
def int3_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.int3_arr_1)
return data_view.get()
@int3_arr_1.setter
def int3_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.int3_arr_1)
data_view = og.AttributeValueHelper(self._attributes.int3_arr_1)
data_view.set(value)
self.int3_arr_1_size = data_view.get_array_size()
@property
def int4_0(self):
data_view = og.AttributeValueHelper(self._attributes.int4_0)
return data_view.get()
@int4_0.setter
def int4_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.int4_0)
data_view = og.AttributeValueHelper(self._attributes.int4_0)
data_view.set(value)
@property
def int4_1(self):
data_view = og.AttributeValueHelper(self._attributes.int4_1)
return data_view.get()
@int4_1.setter
def int4_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.int4_1)
data_view = og.AttributeValueHelper(self._attributes.int4_1)
data_view.set(value)
@property
def int4_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.int4_arr_0)
return data_view.get()
@int4_arr_0.setter
def int4_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.int4_arr_0)
data_view = og.AttributeValueHelper(self._attributes.int4_arr_0)
data_view.set(value)
self.int4_arr_0_size = data_view.get_array_size()
@property
def int4_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.int4_arr_1)
return data_view.get()
@int4_arr_1.setter
def int4_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.int4_arr_1)
data_view = og.AttributeValueHelper(self._attributes.int4_arr_1)
data_view.set(value)
self.int4_arr_1_size = data_view.get_array_size()
@property
def int64_0(self):
data_view = og.AttributeValueHelper(self._attributes.int64_0)
return data_view.get()
@int64_0.setter
def int64_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.int64_0)
data_view = og.AttributeValueHelper(self._attributes.int64_0)
data_view.set(value)
@property
def int64_1(self):
data_view = og.AttributeValueHelper(self._attributes.int64_1)
return data_view.get()
@int64_1.setter
def int64_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.int64_1)
data_view = og.AttributeValueHelper(self._attributes.int64_1)
data_view.set(value)
@property
def int64_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.int64_arr_0)
return data_view.get()
@int64_arr_0.setter
def int64_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.int64_arr_0)
data_view = og.AttributeValueHelper(self._attributes.int64_arr_0)
data_view.set(value)
self.int64_arr_0_size = data_view.get_array_size()
@property
def int64_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.int64_arr_1)
return data_view.get()
@int64_arr_1.setter
def int64_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.int64_arr_1)
data_view = og.AttributeValueHelper(self._attributes.int64_arr_1)
data_view.set(value)
self.int64_arr_1_size = data_view.get_array_size()
@property
def int_0(self):
data_view = og.AttributeValueHelper(self._attributes.int_0)
return data_view.get()
@int_0.setter
def int_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.int_0)
data_view = og.AttributeValueHelper(self._attributes.int_0)
data_view.set(value)
@property
def int_1(self):
data_view = og.AttributeValueHelper(self._attributes.int_1)
return data_view.get()
@int_1.setter
def int_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.int_1)
data_view = og.AttributeValueHelper(self._attributes.int_1)
data_view.set(value)
@property
def int_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.int_arr_0)
return data_view.get()
@int_arr_0.setter
def int_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.int_arr_0)
data_view = og.AttributeValueHelper(self._attributes.int_arr_0)
data_view.set(value)
self.int_arr_0_size = data_view.get_array_size()
@property
def int_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.int_arr_1)
return data_view.get()
@int_arr_1.setter
def int_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.int_arr_1)
data_view = og.AttributeValueHelper(self._attributes.int_arr_1)
data_view.set(value)
self.int_arr_1_size = data_view.get_array_size()
@property
def matrixd2_0(self):
data_view = og.AttributeValueHelper(self._attributes.matrixd2_0)
return data_view.get()
@matrixd2_0.setter
def matrixd2_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.matrixd2_0)
data_view = og.AttributeValueHelper(self._attributes.matrixd2_0)
data_view.set(value)
@property
def matrixd2_1(self):
data_view = og.AttributeValueHelper(self._attributes.matrixd2_1)
return data_view.get()
@matrixd2_1.setter
def matrixd2_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.matrixd2_1)
data_view = og.AttributeValueHelper(self._attributes.matrixd2_1)
data_view.set(value)
@property
def matrixd2_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.matrixd2_arr_0)
return data_view.get()
@matrixd2_arr_0.setter
def matrixd2_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.matrixd2_arr_0)
data_view = og.AttributeValueHelper(self._attributes.matrixd2_arr_0)
data_view.set(value)
self.matrixd2_arr_0_size = data_view.get_array_size()
@property
def matrixd2_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.matrixd2_arr_1)
return data_view.get()
@matrixd2_arr_1.setter
def matrixd2_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.matrixd2_arr_1)
data_view = og.AttributeValueHelper(self._attributes.matrixd2_arr_1)
data_view.set(value)
self.matrixd2_arr_1_size = data_view.get_array_size()
@property
def matrixd3_0(self):
data_view = og.AttributeValueHelper(self._attributes.matrixd3_0)
return data_view.get()
@matrixd3_0.setter
def matrixd3_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.matrixd3_0)
data_view = og.AttributeValueHelper(self._attributes.matrixd3_0)
data_view.set(value)
@property
def matrixd3_1(self):
data_view = og.AttributeValueHelper(self._attributes.matrixd3_1)
return data_view.get()
@matrixd3_1.setter
def matrixd3_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.matrixd3_1)
data_view = og.AttributeValueHelper(self._attributes.matrixd3_1)
data_view.set(value)
@property
def matrixd3_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.matrixd3_arr_0)
return data_view.get()
@matrixd3_arr_0.setter
def matrixd3_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.matrixd3_arr_0)
data_view = og.AttributeValueHelper(self._attributes.matrixd3_arr_0)
data_view.set(value)
self.matrixd3_arr_0_size = data_view.get_array_size()
@property
def matrixd3_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.matrixd3_arr_1)
return data_view.get()
@matrixd3_arr_1.setter
def matrixd3_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.matrixd3_arr_1)
data_view = og.AttributeValueHelper(self._attributes.matrixd3_arr_1)
data_view.set(value)
self.matrixd3_arr_1_size = data_view.get_array_size()
@property
def matrixd4_0(self):
data_view = og.AttributeValueHelper(self._attributes.matrixd4_0)
return data_view.get()
@matrixd4_0.setter
def matrixd4_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.matrixd4_0)
data_view = og.AttributeValueHelper(self._attributes.matrixd4_0)
data_view.set(value)
@property
def matrixd4_1(self):
data_view = og.AttributeValueHelper(self._attributes.matrixd4_1)
return data_view.get()
@matrixd4_1.setter
def matrixd4_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.matrixd4_1)
data_view = og.AttributeValueHelper(self._attributes.matrixd4_1)
data_view.set(value)
@property
def matrixd4_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.matrixd4_arr_0)
return data_view.get()
@matrixd4_arr_0.setter
def matrixd4_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.matrixd4_arr_0)
data_view = og.AttributeValueHelper(self._attributes.matrixd4_arr_0)
data_view.set(value)
self.matrixd4_arr_0_size = data_view.get_array_size()
@property
def matrixd4_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.matrixd4_arr_1)
return data_view.get()
@matrixd4_arr_1.setter
def matrixd4_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.matrixd4_arr_1)
data_view = og.AttributeValueHelper(self._attributes.matrixd4_arr_1)
data_view.set(value)
self.matrixd4_arr_1_size = data_view.get_array_size()
@property
def normald3_0(self):
data_view = og.AttributeValueHelper(self._attributes.normald3_0)
return data_view.get()
@normald3_0.setter
def normald3_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.normald3_0)
data_view = og.AttributeValueHelper(self._attributes.normald3_0)
data_view.set(value)
@property
def normald3_1(self):
data_view = og.AttributeValueHelper(self._attributes.normald3_1)
return data_view.get()
@normald3_1.setter
def normald3_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.normald3_1)
data_view = og.AttributeValueHelper(self._attributes.normald3_1)
data_view.set(value)
@property
def normald3_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.normald3_arr_0)
return data_view.get()
@normald3_arr_0.setter
def normald3_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.normald3_arr_0)
data_view = og.AttributeValueHelper(self._attributes.normald3_arr_0)
data_view.set(value)
self.normald3_arr_0_size = data_view.get_array_size()
@property
def normald3_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.normald3_arr_1)
return data_view.get()
@normald3_arr_1.setter
def normald3_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.normald3_arr_1)
data_view = og.AttributeValueHelper(self._attributes.normald3_arr_1)
data_view.set(value)
self.normald3_arr_1_size = data_view.get_array_size()
@property
def normalf3_0(self):
data_view = og.AttributeValueHelper(self._attributes.normalf3_0)
return data_view.get()
@normalf3_0.setter
def normalf3_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.normalf3_0)
data_view = og.AttributeValueHelper(self._attributes.normalf3_0)
data_view.set(value)
@property
def normalf3_1(self):
data_view = og.AttributeValueHelper(self._attributes.normalf3_1)
return data_view.get()
@normalf3_1.setter
def normalf3_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.normalf3_1)
data_view = og.AttributeValueHelper(self._attributes.normalf3_1)
data_view.set(value)
@property
def normalf3_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.normalf3_arr_0)
return data_view.get()
@normalf3_arr_0.setter
def normalf3_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.normalf3_arr_0)
data_view = og.AttributeValueHelper(self._attributes.normalf3_arr_0)
data_view.set(value)
self.normalf3_arr_0_size = data_view.get_array_size()
@property
def normalf3_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.normalf3_arr_1)
return data_view.get()
@normalf3_arr_1.setter
def normalf3_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.normalf3_arr_1)
data_view = og.AttributeValueHelper(self._attributes.normalf3_arr_1)
data_view.set(value)
self.normalf3_arr_1_size = data_view.get_array_size()
@property
def normalh3_0(self):
data_view = og.AttributeValueHelper(self._attributes.normalh3_0)
return data_view.get()
@normalh3_0.setter
def normalh3_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.normalh3_0)
data_view = og.AttributeValueHelper(self._attributes.normalh3_0)
data_view.set(value)
@property
def normalh3_1(self):
data_view = og.AttributeValueHelper(self._attributes.normalh3_1)
return data_view.get()
@normalh3_1.setter
def normalh3_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.normalh3_1)
data_view = og.AttributeValueHelper(self._attributes.normalh3_1)
data_view.set(value)
@property
def normalh3_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.normalh3_arr_0)
return data_view.get()
@normalh3_arr_0.setter
def normalh3_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.normalh3_arr_0)
data_view = og.AttributeValueHelper(self._attributes.normalh3_arr_0)
data_view.set(value)
self.normalh3_arr_0_size = data_view.get_array_size()
@property
def normalh3_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.normalh3_arr_1)
return data_view.get()
@normalh3_arr_1.setter
def normalh3_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.normalh3_arr_1)
data_view = og.AttributeValueHelper(self._attributes.normalh3_arr_1)
data_view.set(value)
self.normalh3_arr_1_size = data_view.get_array_size()
@property
def pointd3_0(self):
data_view = og.AttributeValueHelper(self._attributes.pointd3_0)
return data_view.get()
@pointd3_0.setter
def pointd3_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.pointd3_0)
data_view = og.AttributeValueHelper(self._attributes.pointd3_0)
data_view.set(value)
@property
def pointd3_1(self):
data_view = og.AttributeValueHelper(self._attributes.pointd3_1)
return data_view.get()
@pointd3_1.setter
def pointd3_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.pointd3_1)
data_view = og.AttributeValueHelper(self._attributes.pointd3_1)
data_view.set(value)
@property
def pointd3_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.pointd3_arr_0)
return data_view.get()
@pointd3_arr_0.setter
def pointd3_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.pointd3_arr_0)
data_view = og.AttributeValueHelper(self._attributes.pointd3_arr_0)
data_view.set(value)
self.pointd3_arr_0_size = data_view.get_array_size()
@property
def pointd3_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.pointd3_arr_1)
return data_view.get()
@pointd3_arr_1.setter
def pointd3_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.pointd3_arr_1)
data_view = og.AttributeValueHelper(self._attributes.pointd3_arr_1)
data_view.set(value)
self.pointd3_arr_1_size = data_view.get_array_size()
@property
def pointf3_0(self):
data_view = og.AttributeValueHelper(self._attributes.pointf3_0)
return data_view.get()
@pointf3_0.setter
def pointf3_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.pointf3_0)
data_view = og.AttributeValueHelper(self._attributes.pointf3_0)
data_view.set(value)
@property
def pointf3_1(self):
data_view = og.AttributeValueHelper(self._attributes.pointf3_1)
return data_view.get()
@pointf3_1.setter
def pointf3_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.pointf3_1)
data_view = og.AttributeValueHelper(self._attributes.pointf3_1)
data_view.set(value)
@property
def pointf3_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.pointf3_arr_0)
return data_view.get()
@pointf3_arr_0.setter
def pointf3_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.pointf3_arr_0)
data_view = og.AttributeValueHelper(self._attributes.pointf3_arr_0)
data_view.set(value)
self.pointf3_arr_0_size = data_view.get_array_size()
@property
def pointf3_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.pointf3_arr_1)
return data_view.get()
@pointf3_arr_1.setter
def pointf3_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.pointf3_arr_1)
data_view = og.AttributeValueHelper(self._attributes.pointf3_arr_1)
data_view.set(value)
self.pointf3_arr_1_size = data_view.get_array_size()
@property
def pointh3_0(self):
data_view = og.AttributeValueHelper(self._attributes.pointh3_0)
return data_view.get()
@pointh3_0.setter
def pointh3_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.pointh3_0)
data_view = og.AttributeValueHelper(self._attributes.pointh3_0)
data_view.set(value)
@property
def pointh3_1(self):
data_view = og.AttributeValueHelper(self._attributes.pointh3_1)
return data_view.get()
@pointh3_1.setter
def pointh3_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.pointh3_1)
data_view = og.AttributeValueHelper(self._attributes.pointh3_1)
data_view.set(value)
@property
def pointh3_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.pointh3_arr_0)
return data_view.get()
@pointh3_arr_0.setter
def pointh3_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.pointh3_arr_0)
data_view = og.AttributeValueHelper(self._attributes.pointh3_arr_0)
data_view.set(value)
self.pointh3_arr_0_size = data_view.get_array_size()
@property
def pointh3_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.pointh3_arr_1)
return data_view.get()
@pointh3_arr_1.setter
def pointh3_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.pointh3_arr_1)
data_view = og.AttributeValueHelper(self._attributes.pointh3_arr_1)
data_view.set(value)
self.pointh3_arr_1_size = data_view.get_array_size()
@property
def quatd4_0(self):
data_view = og.AttributeValueHelper(self._attributes.quatd4_0)
return data_view.get()
@quatd4_0.setter
def quatd4_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.quatd4_0)
data_view = og.AttributeValueHelper(self._attributes.quatd4_0)
data_view.set(value)
@property
def quatd4_1(self):
data_view = og.AttributeValueHelper(self._attributes.quatd4_1)
return data_view.get()
@quatd4_1.setter
def quatd4_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.quatd4_1)
data_view = og.AttributeValueHelper(self._attributes.quatd4_1)
data_view.set(value)
@property
def quatd4_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.quatd4_arr_0)
return data_view.get()
@quatd4_arr_0.setter
def quatd4_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.quatd4_arr_0)
data_view = og.AttributeValueHelper(self._attributes.quatd4_arr_0)
data_view.set(value)
self.quatd4_arr_0_size = data_view.get_array_size()
@property
def quatd4_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.quatd4_arr_1)
return data_view.get()
@quatd4_arr_1.setter
def quatd4_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.quatd4_arr_1)
data_view = og.AttributeValueHelper(self._attributes.quatd4_arr_1)
data_view.set(value)
self.quatd4_arr_1_size = data_view.get_array_size()
@property
def quatf4_0(self):
data_view = og.AttributeValueHelper(self._attributes.quatf4_0)
return data_view.get()
@quatf4_0.setter
def quatf4_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.quatf4_0)
data_view = og.AttributeValueHelper(self._attributes.quatf4_0)
data_view.set(value)
@property
def quatf4_1(self):
data_view = og.AttributeValueHelper(self._attributes.quatf4_1)
return data_view.get()
@quatf4_1.setter
def quatf4_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.quatf4_1)
data_view = og.AttributeValueHelper(self._attributes.quatf4_1)
data_view.set(value)
@property
def quatf4_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.quatf4_arr_0)
return data_view.get()
@quatf4_arr_0.setter
def quatf4_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.quatf4_arr_0)
data_view = og.AttributeValueHelper(self._attributes.quatf4_arr_0)
data_view.set(value)
self.quatf4_arr_0_size = data_view.get_array_size()
@property
def quatf4_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.quatf4_arr_1)
return data_view.get()
@quatf4_arr_1.setter
def quatf4_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.quatf4_arr_1)
data_view = og.AttributeValueHelper(self._attributes.quatf4_arr_1)
data_view.set(value)
self.quatf4_arr_1_size = data_view.get_array_size()
@property
def quath4_0(self):
data_view = og.AttributeValueHelper(self._attributes.quath4_0)
return data_view.get()
@quath4_0.setter
def quath4_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.quath4_0)
data_view = og.AttributeValueHelper(self._attributes.quath4_0)
data_view.set(value)
@property
def quath4_1(self):
data_view = og.AttributeValueHelper(self._attributes.quath4_1)
return data_view.get()
@quath4_1.setter
def quath4_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.quath4_1)
data_view = og.AttributeValueHelper(self._attributes.quath4_1)
data_view.set(value)
@property
def quath4_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.quath4_arr_0)
return data_view.get()
@quath4_arr_0.setter
def quath4_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.quath4_arr_0)
data_view = og.AttributeValueHelper(self._attributes.quath4_arr_0)
data_view.set(value)
self.quath4_arr_0_size = data_view.get_array_size()
@property
def quath4_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.quath4_arr_1)
return data_view.get()
@quath4_arr_1.setter
def quath4_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.quath4_arr_1)
data_view = og.AttributeValueHelper(self._attributes.quath4_arr_1)
data_view.set(value)
self.quath4_arr_1_size = data_view.get_array_size()
@property
def texcoordd2_0(self):
data_view = og.AttributeValueHelper(self._attributes.texcoordd2_0)
return data_view.get()
@texcoordd2_0.setter
def texcoordd2_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.texcoordd2_0)
data_view = og.AttributeValueHelper(self._attributes.texcoordd2_0)
data_view.set(value)
@property
def texcoordd2_1(self):
data_view = og.AttributeValueHelper(self._attributes.texcoordd2_1)
return data_view.get()
@texcoordd2_1.setter
def texcoordd2_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.texcoordd2_1)
data_view = og.AttributeValueHelper(self._attributes.texcoordd2_1)
data_view.set(value)
@property
def texcoordd2_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.texcoordd2_arr_0)
return data_view.get()
@texcoordd2_arr_0.setter
def texcoordd2_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.texcoordd2_arr_0)
data_view = og.AttributeValueHelper(self._attributes.texcoordd2_arr_0)
data_view.set(value)
self.texcoordd2_arr_0_size = data_view.get_array_size()
@property
def texcoordd2_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.texcoordd2_arr_1)
return data_view.get()
@texcoordd2_arr_1.setter
def texcoordd2_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.texcoordd2_arr_1)
data_view = og.AttributeValueHelper(self._attributes.texcoordd2_arr_1)
data_view.set(value)
self.texcoordd2_arr_1_size = data_view.get_array_size()
@property
def texcoordd3_0(self):
data_view = og.AttributeValueHelper(self._attributes.texcoordd3_0)
return data_view.get()
@texcoordd3_0.setter
def texcoordd3_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.texcoordd3_0)
data_view = og.AttributeValueHelper(self._attributes.texcoordd3_0)
data_view.set(value)
@property
def texcoordd3_1(self):
data_view = og.AttributeValueHelper(self._attributes.texcoordd3_1)
return data_view.get()
@texcoordd3_1.setter
def texcoordd3_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.texcoordd3_1)
data_view = og.AttributeValueHelper(self._attributes.texcoordd3_1)
data_view.set(value)
@property
def texcoordd3_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.texcoordd3_arr_0)
return data_view.get()
@texcoordd3_arr_0.setter
def texcoordd3_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.texcoordd3_arr_0)
data_view = og.AttributeValueHelper(self._attributes.texcoordd3_arr_0)
data_view.set(value)
self.texcoordd3_arr_0_size = data_view.get_array_size()
@property
def texcoordd3_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.texcoordd3_arr_1)
return data_view.get()
@texcoordd3_arr_1.setter
def texcoordd3_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.texcoordd3_arr_1)
data_view = og.AttributeValueHelper(self._attributes.texcoordd3_arr_1)
data_view.set(value)
self.texcoordd3_arr_1_size = data_view.get_array_size()
@property
def texcoordf2_0(self):
data_view = og.AttributeValueHelper(self._attributes.texcoordf2_0)
return data_view.get()
@texcoordf2_0.setter
def texcoordf2_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.texcoordf2_0)
data_view = og.AttributeValueHelper(self._attributes.texcoordf2_0)
data_view.set(value)
@property
def texcoordf2_1(self):
data_view = og.AttributeValueHelper(self._attributes.texcoordf2_1)
return data_view.get()
@texcoordf2_1.setter
def texcoordf2_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.texcoordf2_1)
data_view = og.AttributeValueHelper(self._attributes.texcoordf2_1)
data_view.set(value)
@property
def texcoordf2_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.texcoordf2_arr_0)
return data_view.get()
@texcoordf2_arr_0.setter
def texcoordf2_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.texcoordf2_arr_0)
data_view = og.AttributeValueHelper(self._attributes.texcoordf2_arr_0)
data_view.set(value)
self.texcoordf2_arr_0_size = data_view.get_array_size()
@property
def texcoordf2_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.texcoordf2_arr_1)
return data_view.get()
@texcoordf2_arr_1.setter
def texcoordf2_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.texcoordf2_arr_1)
data_view = og.AttributeValueHelper(self._attributes.texcoordf2_arr_1)
data_view.set(value)
self.texcoordf2_arr_1_size = data_view.get_array_size()
@property
def texcoordf3_0(self):
data_view = og.AttributeValueHelper(self._attributes.texcoordf3_0)
return data_view.get()
@texcoordf3_0.setter
def texcoordf3_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.texcoordf3_0)
data_view = og.AttributeValueHelper(self._attributes.texcoordf3_0)
data_view.set(value)
@property
def texcoordf3_1(self):
data_view = og.AttributeValueHelper(self._attributes.texcoordf3_1)
return data_view.get()
@texcoordf3_1.setter
def texcoordf3_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.texcoordf3_1)
data_view = og.AttributeValueHelper(self._attributes.texcoordf3_1)
data_view.set(value)
@property
def texcoordf3_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.texcoordf3_arr_0)
return data_view.get()
@texcoordf3_arr_0.setter
def texcoordf3_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.texcoordf3_arr_0)
data_view = og.AttributeValueHelper(self._attributes.texcoordf3_arr_0)
data_view.set(value)
self.texcoordf3_arr_0_size = data_view.get_array_size()
@property
def texcoordf3_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.texcoordf3_arr_1)
return data_view.get()
@texcoordf3_arr_1.setter
def texcoordf3_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.texcoordf3_arr_1)
data_view = og.AttributeValueHelper(self._attributes.texcoordf3_arr_1)
data_view.set(value)
self.texcoordf3_arr_1_size = data_view.get_array_size()
@property
def texcoordh2_0(self):
data_view = og.AttributeValueHelper(self._attributes.texcoordh2_0)
return data_view.get()
@texcoordh2_0.setter
def texcoordh2_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.texcoordh2_0)
data_view = og.AttributeValueHelper(self._attributes.texcoordh2_0)
data_view.set(value)
@property
def texcoordh2_1(self):
data_view = og.AttributeValueHelper(self._attributes.texcoordh2_1)
return data_view.get()
@texcoordh2_1.setter
def texcoordh2_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.texcoordh2_1)
data_view = og.AttributeValueHelper(self._attributes.texcoordh2_1)
data_view.set(value)
@property
def texcoordh2_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.texcoordh2_arr_0)
return data_view.get()
@texcoordh2_arr_0.setter
def texcoordh2_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.texcoordh2_arr_0)
data_view = og.AttributeValueHelper(self._attributes.texcoordh2_arr_0)
data_view.set(value)
self.texcoordh2_arr_0_size = data_view.get_array_size()
@property
def texcoordh2_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.texcoordh2_arr_1)
return data_view.get()
@texcoordh2_arr_1.setter
def texcoordh2_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.texcoordh2_arr_1)
data_view = og.AttributeValueHelper(self._attributes.texcoordh2_arr_1)
data_view.set(value)
self.texcoordh2_arr_1_size = data_view.get_array_size()
@property
def texcoordh3_0(self):
data_view = og.AttributeValueHelper(self._attributes.texcoordh3_0)
return data_view.get()
@texcoordh3_0.setter
def texcoordh3_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.texcoordh3_0)
data_view = og.AttributeValueHelper(self._attributes.texcoordh3_0)
data_view.set(value)
@property
def texcoordh3_1(self):
data_view = og.AttributeValueHelper(self._attributes.texcoordh3_1)
return data_view.get()
@texcoordh3_1.setter
def texcoordh3_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.texcoordh3_1)
data_view = og.AttributeValueHelper(self._attributes.texcoordh3_1)
data_view.set(value)
@property
def texcoordh3_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.texcoordh3_arr_0)
return data_view.get()
@texcoordh3_arr_0.setter
def texcoordh3_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.texcoordh3_arr_0)
data_view = og.AttributeValueHelper(self._attributes.texcoordh3_arr_0)
data_view.set(value)
self.texcoordh3_arr_0_size = data_view.get_array_size()
@property
def texcoordh3_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.texcoordh3_arr_1)
return data_view.get()
@texcoordh3_arr_1.setter
def texcoordh3_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.texcoordh3_arr_1)
data_view = og.AttributeValueHelper(self._attributes.texcoordh3_arr_1)
data_view.set(value)
self.texcoordh3_arr_1_size = data_view.get_array_size()
@property
def timecode_0(self):
data_view = og.AttributeValueHelper(self._attributes.timecode_0)
return data_view.get()
@timecode_0.setter
def timecode_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.timecode_0)
data_view = og.AttributeValueHelper(self._attributes.timecode_0)
data_view.set(value)
@property
def timecode_1(self):
data_view = og.AttributeValueHelper(self._attributes.timecode_1)
return data_view.get()
@timecode_1.setter
def timecode_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.timecode_1)
data_view = og.AttributeValueHelper(self._attributes.timecode_1)
data_view.set(value)
@property
def timecode_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.timecode_arr_0)
return data_view.get()
@timecode_arr_0.setter
def timecode_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.timecode_arr_0)
data_view = og.AttributeValueHelper(self._attributes.timecode_arr_0)
data_view.set(value)
self.timecode_arr_0_size = data_view.get_array_size()
@property
def timecode_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.timecode_arr_1)
return data_view.get()
@timecode_arr_1.setter
def timecode_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.timecode_arr_1)
data_view = og.AttributeValueHelper(self._attributes.timecode_arr_1)
data_view.set(value)
self.timecode_arr_1_size = data_view.get_array_size()
@property
def token_0(self):
data_view = og.AttributeValueHelper(self._attributes.token_0)
return data_view.get()
@token_0.setter
def token_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.token_0)
data_view = og.AttributeValueHelper(self._attributes.token_0)
data_view.set(value)
@property
def token_1(self):
data_view = og.AttributeValueHelper(self._attributes.token_1)
return data_view.get()
@token_1.setter
def token_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.token_1)
data_view = og.AttributeValueHelper(self._attributes.token_1)
data_view.set(value)
@property
def token_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.token_arr_0)
return data_view.get()
@token_arr_0.setter
def token_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.token_arr_0)
data_view = og.AttributeValueHelper(self._attributes.token_arr_0)
data_view.set(value)
self.token_arr_0_size = data_view.get_array_size()
@property
def token_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.token_arr_1)
return data_view.get()
@token_arr_1.setter
def token_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.token_arr_1)
data_view = og.AttributeValueHelper(self._attributes.token_arr_1)
data_view.set(value)
self.token_arr_1_size = data_view.get_array_size()
@property
def transform4_0(self):
data_view = og.AttributeValueHelper(self._attributes.transform4_0)
return data_view.get()
@transform4_0.setter
def transform4_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.transform4_0)
data_view = og.AttributeValueHelper(self._attributes.transform4_0)
data_view.set(value)
@property
def transform4_1(self):
data_view = og.AttributeValueHelper(self._attributes.transform4_1)
return data_view.get()
@transform4_1.setter
def transform4_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.transform4_1)
data_view = og.AttributeValueHelper(self._attributes.transform4_1)
data_view.set(value)
@property
def transform4_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.transform4_arr_0)
return data_view.get()
@transform4_arr_0.setter
def transform4_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.transform4_arr_0)
data_view = og.AttributeValueHelper(self._attributes.transform4_arr_0)
data_view.set(value)
self.transform4_arr_0_size = data_view.get_array_size()
@property
def transform4_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.transform4_arr_1)
return data_view.get()
@transform4_arr_1.setter
def transform4_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.transform4_arr_1)
data_view = og.AttributeValueHelper(self._attributes.transform4_arr_1)
data_view.set(value)
self.transform4_arr_1_size = data_view.get_array_size()
@property
def uchar_0(self):
data_view = og.AttributeValueHelper(self._attributes.uchar_0)
return data_view.get()
@uchar_0.setter
def uchar_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.uchar_0)
data_view = og.AttributeValueHelper(self._attributes.uchar_0)
data_view.set(value)
@property
def uchar_1(self):
data_view = og.AttributeValueHelper(self._attributes.uchar_1)
return data_view.get()
@uchar_1.setter
def uchar_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.uchar_1)
data_view = og.AttributeValueHelper(self._attributes.uchar_1)
data_view.set(value)
@property
def uchar_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.uchar_arr_0)
return data_view.get()
@uchar_arr_0.setter
def uchar_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.uchar_arr_0)
data_view = og.AttributeValueHelper(self._attributes.uchar_arr_0)
data_view.set(value)
self.uchar_arr_0_size = data_view.get_array_size()
@property
def uchar_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.uchar_arr_1)
return data_view.get()
@uchar_arr_1.setter
def uchar_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.uchar_arr_1)
data_view = og.AttributeValueHelper(self._attributes.uchar_arr_1)
data_view.set(value)
self.uchar_arr_1_size = data_view.get_array_size()
@property
def uint64_0(self):
data_view = og.AttributeValueHelper(self._attributes.uint64_0)
return data_view.get()
@uint64_0.setter
def uint64_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.uint64_0)
data_view = og.AttributeValueHelper(self._attributes.uint64_0)
data_view.set(value)
@property
def uint64_1(self):
data_view = og.AttributeValueHelper(self._attributes.uint64_1)
return data_view.get()
@uint64_1.setter
def uint64_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.uint64_1)
data_view = og.AttributeValueHelper(self._attributes.uint64_1)
data_view.set(value)
@property
def uint64_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.uint64_arr_0)
return data_view.get()
@uint64_arr_0.setter
def uint64_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.uint64_arr_0)
data_view = og.AttributeValueHelper(self._attributes.uint64_arr_0)
data_view.set(value)
self.uint64_arr_0_size = data_view.get_array_size()
@property
def uint64_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.uint64_arr_1)
return data_view.get()
@uint64_arr_1.setter
def uint64_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.uint64_arr_1)
data_view = og.AttributeValueHelper(self._attributes.uint64_arr_1)
data_view.set(value)
self.uint64_arr_1_size = data_view.get_array_size()
@property
def uint_0(self):
data_view = og.AttributeValueHelper(self._attributes.uint_0)
return data_view.get()
@uint_0.setter
def uint_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.uint_0)
data_view = og.AttributeValueHelper(self._attributes.uint_0)
data_view.set(value)
@property
def uint_1(self):
data_view = og.AttributeValueHelper(self._attributes.uint_1)
return data_view.get()
@uint_1.setter
def uint_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.uint_1)
data_view = og.AttributeValueHelper(self._attributes.uint_1)
data_view.set(value)
@property
def uint_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.uint_arr_0)
return data_view.get()
@uint_arr_0.setter
def uint_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.uint_arr_0)
data_view = og.AttributeValueHelper(self._attributes.uint_arr_0)
data_view.set(value)
self.uint_arr_0_size = data_view.get_array_size()
@property
def uint_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.uint_arr_1)
return data_view.get()
@uint_arr_1.setter
def uint_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.uint_arr_1)
data_view = og.AttributeValueHelper(self._attributes.uint_arr_1)
data_view.set(value)
self.uint_arr_1_size = data_view.get_array_size()
@property
def vectord3_0(self):
data_view = og.AttributeValueHelper(self._attributes.vectord3_0)
return data_view.get()
@vectord3_0.setter
def vectord3_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.vectord3_0)
data_view = og.AttributeValueHelper(self._attributes.vectord3_0)
data_view.set(value)
@property
def vectord3_1(self):
data_view = og.AttributeValueHelper(self._attributes.vectord3_1)
return data_view.get()
@vectord3_1.setter
def vectord3_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.vectord3_1)
data_view = og.AttributeValueHelper(self._attributes.vectord3_1)
data_view.set(value)
@property
def vectord3_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.vectord3_arr_0)
return data_view.get()
@vectord3_arr_0.setter
def vectord3_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.vectord3_arr_0)
data_view = og.AttributeValueHelper(self._attributes.vectord3_arr_0)
data_view.set(value)
self.vectord3_arr_0_size = data_view.get_array_size()
@property
def vectord3_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.vectord3_arr_1)
return data_view.get()
@vectord3_arr_1.setter
def vectord3_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.vectord3_arr_1)
data_view = og.AttributeValueHelper(self._attributes.vectord3_arr_1)
data_view.set(value)
self.vectord3_arr_1_size = data_view.get_array_size()
@property
def vectorf3_0(self):
data_view = og.AttributeValueHelper(self._attributes.vectorf3_0)
return data_view.get()
@vectorf3_0.setter
def vectorf3_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.vectorf3_0)
data_view = og.AttributeValueHelper(self._attributes.vectorf3_0)
data_view.set(value)
@property
def vectorf3_1(self):
data_view = og.AttributeValueHelper(self._attributes.vectorf3_1)
return data_view.get()
@vectorf3_1.setter
def vectorf3_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.vectorf3_1)
data_view = og.AttributeValueHelper(self._attributes.vectorf3_1)
data_view.set(value)
@property
def vectorf3_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.vectorf3_arr_0)
return data_view.get()
@vectorf3_arr_0.setter
def vectorf3_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.vectorf3_arr_0)
data_view = og.AttributeValueHelper(self._attributes.vectorf3_arr_0)
data_view.set(value)
self.vectorf3_arr_0_size = data_view.get_array_size()
@property
def vectorf3_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.vectorf3_arr_1)
return data_view.get()
@vectorf3_arr_1.setter
def vectorf3_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.vectorf3_arr_1)
data_view = og.AttributeValueHelper(self._attributes.vectorf3_arr_1)
data_view.set(value)
self.vectorf3_arr_1_size = data_view.get_array_size()
@property
def vectorh3_0(self):
data_view = og.AttributeValueHelper(self._attributes.vectorh3_0)
return data_view.get()
@vectorh3_0.setter
def vectorh3_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.vectorh3_0)
data_view = og.AttributeValueHelper(self._attributes.vectorh3_0)
data_view.set(value)
@property
def vectorh3_1(self):
data_view = og.AttributeValueHelper(self._attributes.vectorh3_1)
return data_view.get()
@vectorh3_1.setter
def vectorh3_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.vectorh3_1)
data_view = og.AttributeValueHelper(self._attributes.vectorh3_1)
data_view.set(value)
@property
def vectorh3_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.vectorh3_arr_0)
return data_view.get()
@vectorh3_arr_0.setter
def vectorh3_arr_0(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.vectorh3_arr_0)
data_view = og.AttributeValueHelper(self._attributes.vectorh3_arr_0)
data_view.set(value)
self.vectorh3_arr_0_size = data_view.get_array_size()
@property
def vectorh3_arr_1(self):
data_view = og.AttributeValueHelper(self._attributes.vectorh3_arr_1)
return data_view.get()
@vectorh3_arr_1.setter
def vectorh3_arr_1(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.vectorh3_arr_1)
data_view = og.AttributeValueHelper(self._attributes.vectorh3_arr_1)
data_view.set(value)
self.vectorh3_arr_1_size = data_view.get_array_size()
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.bool_arr_0_size = 0
self.colord3_arr_0_size = 0
self.colord4_arr_0_size = 0
self.colorf3_arr_0_size = 0
self.colorf4_arr_0_size = 0
self.colorh3_arr_0_size = 0
self.colorh4_arr_0_size = 0
self.double2_arr_0_size = 0
self.double3_arr_0_size = 0
self.double4_arr_0_size = 0
self.double_arr_0_size = 0
self.float2_arr_0_size = 0
self.float3_arr_0_size = 0
self.float4_arr_0_size = 0
self.float_arr_0_size = 0
self.frame4_arr_0_size = 0
self.half2_arr_0_size = 0
self.half3_arr_0_size = 0
self.half4_arr_0_size = 0
self.half_arr_0_size = 0
self.int2_arr_0_size = 0
self.int3_arr_0_size = 0
self.int4_arr_0_size = 0
self.int64_arr_0_size = 0
self.int_arr_0_size = 0
self.matrixd2_arr_0_size = 0
self.matrixd3_arr_0_size = 0
self.matrixd4_arr_0_size = 0
self.normald3_arr_0_size = 0
self.normalf3_arr_0_size = 0
self.normalh3_arr_0_size = 0
self.pointd3_arr_0_size = 0
self.pointf3_arr_0_size = 0
self.pointh3_arr_0_size = 0
self.quatd4_arr_0_size = 0
self.quatf4_arr_0_size = 0
self.quath4_arr_0_size = 0
self.texcoordd2_arr_0_size = 0
self.texcoordd3_arr_0_size = 0
self.texcoordf2_arr_0_size = 0
self.texcoordf3_arr_0_size = 0
self.texcoordh2_arr_0_size = 0
self.texcoordh3_arr_0_size = 0
self.timecode_arr_0_size = 0
self.token_arr_0_size = 0
self.transform4_arr_0_size = 0
self.uchar_arr_0_size = 0
self.uint64_arr_0_size = 0
self.uint_arr_0_size = 0
self.vectord3_arr_0_size = 0
self.vectorf3_arr_0_size = 0
self.vectorh3_arr_0_size = 0
self._batchedWriteValues = { }
@property
def bool_0(self):
data_view = og.AttributeValueHelper(self._attributes.bool_0)
return data_view.get()
@bool_0.setter
def bool_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.bool_0)
data_view.set(value)
@property
def bool_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.bool_arr_0)
return data_view.get(reserved_element_count=self.bool_arr_0_size)
@bool_arr_0.setter
def bool_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.bool_arr_0)
data_view.set(value)
self.bool_arr_0_size = data_view.get_array_size()
@property
def colord3_0(self):
data_view = og.AttributeValueHelper(self._attributes.colord3_0)
return data_view.get()
@colord3_0.setter
def colord3_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.colord3_0)
data_view.set(value)
@property
def colord3_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.colord3_arr_0)
return data_view.get(reserved_element_count=self.colord3_arr_0_size)
@colord3_arr_0.setter
def colord3_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.colord3_arr_0)
data_view.set(value)
self.colord3_arr_0_size = data_view.get_array_size()
@property
def colord4_0(self):
data_view = og.AttributeValueHelper(self._attributes.colord4_0)
return data_view.get()
@colord4_0.setter
def colord4_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.colord4_0)
data_view.set(value)
@property
def colord4_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.colord4_arr_0)
return data_view.get(reserved_element_count=self.colord4_arr_0_size)
@colord4_arr_0.setter
def colord4_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.colord4_arr_0)
data_view.set(value)
self.colord4_arr_0_size = data_view.get_array_size()
@property
def colorf3_0(self):
data_view = og.AttributeValueHelper(self._attributes.colorf3_0)
return data_view.get()
@colorf3_0.setter
def colorf3_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.colorf3_0)
data_view.set(value)
@property
def colorf3_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.colorf3_arr_0)
return data_view.get(reserved_element_count=self.colorf3_arr_0_size)
@colorf3_arr_0.setter
def colorf3_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.colorf3_arr_0)
data_view.set(value)
self.colorf3_arr_0_size = data_view.get_array_size()
@property
def colorf4_0(self):
data_view = og.AttributeValueHelper(self._attributes.colorf4_0)
return data_view.get()
@colorf4_0.setter
def colorf4_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.colorf4_0)
data_view.set(value)
@property
def colorf4_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.colorf4_arr_0)
return data_view.get(reserved_element_count=self.colorf4_arr_0_size)
@colorf4_arr_0.setter
def colorf4_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.colorf4_arr_0)
data_view.set(value)
self.colorf4_arr_0_size = data_view.get_array_size()
@property
def colorh3_0(self):
data_view = og.AttributeValueHelper(self._attributes.colorh3_0)
return data_view.get()
@colorh3_0.setter
def colorh3_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.colorh3_0)
data_view.set(value)
@property
def colorh3_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.colorh3_arr_0)
return data_view.get(reserved_element_count=self.colorh3_arr_0_size)
@colorh3_arr_0.setter
def colorh3_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.colorh3_arr_0)
data_view.set(value)
self.colorh3_arr_0_size = data_view.get_array_size()
@property
def colorh4_0(self):
data_view = og.AttributeValueHelper(self._attributes.colorh4_0)
return data_view.get()
@colorh4_0.setter
def colorh4_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.colorh4_0)
data_view.set(value)
@property
def colorh4_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.colorh4_arr_0)
return data_view.get(reserved_element_count=self.colorh4_arr_0_size)
@colorh4_arr_0.setter
def colorh4_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.colorh4_arr_0)
data_view.set(value)
self.colorh4_arr_0_size = data_view.get_array_size()
@property
def double2_0(self):
data_view = og.AttributeValueHelper(self._attributes.double2_0)
return data_view.get()
@double2_0.setter
def double2_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.double2_0)
data_view.set(value)
@property
def double2_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.double2_arr_0)
return data_view.get(reserved_element_count=self.double2_arr_0_size)
@double2_arr_0.setter
def double2_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.double2_arr_0)
data_view.set(value)
self.double2_arr_0_size = data_view.get_array_size()
@property
def double3_0(self):
data_view = og.AttributeValueHelper(self._attributes.double3_0)
return data_view.get()
@double3_0.setter
def double3_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.double3_0)
data_view.set(value)
@property
def double3_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.double3_arr_0)
return data_view.get(reserved_element_count=self.double3_arr_0_size)
@double3_arr_0.setter
def double3_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.double3_arr_0)
data_view.set(value)
self.double3_arr_0_size = data_view.get_array_size()
@property
def double4_0(self):
data_view = og.AttributeValueHelper(self._attributes.double4_0)
return data_view.get()
@double4_0.setter
def double4_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.double4_0)
data_view.set(value)
@property
def double4_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.double4_arr_0)
return data_view.get(reserved_element_count=self.double4_arr_0_size)
@double4_arr_0.setter
def double4_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.double4_arr_0)
data_view.set(value)
self.double4_arr_0_size = data_view.get_array_size()
@property
def double_0(self):
data_view = og.AttributeValueHelper(self._attributes.double_0)
return data_view.get()
@double_0.setter
def double_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.double_0)
data_view.set(value)
@property
def double_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.double_arr_0)
return data_view.get(reserved_element_count=self.double_arr_0_size)
@double_arr_0.setter
def double_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.double_arr_0)
data_view.set(value)
self.double_arr_0_size = data_view.get_array_size()
@property
def float2_0(self):
data_view = og.AttributeValueHelper(self._attributes.float2_0)
return data_view.get()
@float2_0.setter
def float2_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.float2_0)
data_view.set(value)
@property
def float2_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.float2_arr_0)
return data_view.get(reserved_element_count=self.float2_arr_0_size)
@float2_arr_0.setter
def float2_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.float2_arr_0)
data_view.set(value)
self.float2_arr_0_size = data_view.get_array_size()
@property
def float3_0(self):
data_view = og.AttributeValueHelper(self._attributes.float3_0)
return data_view.get()
@float3_0.setter
def float3_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.float3_0)
data_view.set(value)
@property
def float3_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.float3_arr_0)
return data_view.get(reserved_element_count=self.float3_arr_0_size)
@float3_arr_0.setter
def float3_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.float3_arr_0)
data_view.set(value)
self.float3_arr_0_size = data_view.get_array_size()
@property
def float4_0(self):
data_view = og.AttributeValueHelper(self._attributes.float4_0)
return data_view.get()
@float4_0.setter
def float4_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.float4_0)
data_view.set(value)
@property
def float4_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.float4_arr_0)
return data_view.get(reserved_element_count=self.float4_arr_0_size)
@float4_arr_0.setter
def float4_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.float4_arr_0)
data_view.set(value)
self.float4_arr_0_size = data_view.get_array_size()
@property
def float_0(self):
data_view = og.AttributeValueHelper(self._attributes.float_0)
return data_view.get()
@float_0.setter
def float_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.float_0)
data_view.set(value)
@property
def float_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.float_arr_0)
return data_view.get(reserved_element_count=self.float_arr_0_size)
@float_arr_0.setter
def float_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.float_arr_0)
data_view.set(value)
self.float_arr_0_size = data_view.get_array_size()
@property
def frame4_0(self):
data_view = og.AttributeValueHelper(self._attributes.frame4_0)
return data_view.get()
@frame4_0.setter
def frame4_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.frame4_0)
data_view.set(value)
@property
def frame4_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.frame4_arr_0)
return data_view.get(reserved_element_count=self.frame4_arr_0_size)
@frame4_arr_0.setter
def frame4_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.frame4_arr_0)
data_view.set(value)
self.frame4_arr_0_size = data_view.get_array_size()
@property
def half2_0(self):
data_view = og.AttributeValueHelper(self._attributes.half2_0)
return data_view.get()
@half2_0.setter
def half2_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.half2_0)
data_view.set(value)
@property
def half2_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.half2_arr_0)
return data_view.get(reserved_element_count=self.half2_arr_0_size)
@half2_arr_0.setter
def half2_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.half2_arr_0)
data_view.set(value)
self.half2_arr_0_size = data_view.get_array_size()
@property
def half3_0(self):
data_view = og.AttributeValueHelper(self._attributes.half3_0)
return data_view.get()
@half3_0.setter
def half3_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.half3_0)
data_view.set(value)
@property
def half3_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.half3_arr_0)
return data_view.get(reserved_element_count=self.half3_arr_0_size)
@half3_arr_0.setter
def half3_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.half3_arr_0)
data_view.set(value)
self.half3_arr_0_size = data_view.get_array_size()
@property
def half4_0(self):
data_view = og.AttributeValueHelper(self._attributes.half4_0)
return data_view.get()
@half4_0.setter
def half4_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.half4_0)
data_view.set(value)
@property
def half4_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.half4_arr_0)
return data_view.get(reserved_element_count=self.half4_arr_0_size)
@half4_arr_0.setter
def half4_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.half4_arr_0)
data_view.set(value)
self.half4_arr_0_size = data_view.get_array_size()
@property
def half_0(self):
data_view = og.AttributeValueHelper(self._attributes.half_0)
return data_view.get()
@half_0.setter
def half_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.half_0)
data_view.set(value)
@property
def half_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.half_arr_0)
return data_view.get(reserved_element_count=self.half_arr_0_size)
@half_arr_0.setter
def half_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.half_arr_0)
data_view.set(value)
self.half_arr_0_size = data_view.get_array_size()
@property
def int2_0(self):
data_view = og.AttributeValueHelper(self._attributes.int2_0)
return data_view.get()
@int2_0.setter
def int2_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.int2_0)
data_view.set(value)
@property
def int2_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.int2_arr_0)
return data_view.get(reserved_element_count=self.int2_arr_0_size)
@int2_arr_0.setter
def int2_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.int2_arr_0)
data_view.set(value)
self.int2_arr_0_size = data_view.get_array_size()
@property
def int3_0(self):
data_view = og.AttributeValueHelper(self._attributes.int3_0)
return data_view.get()
@int3_0.setter
def int3_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.int3_0)
data_view.set(value)
@property
def int3_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.int3_arr_0)
return data_view.get(reserved_element_count=self.int3_arr_0_size)
@int3_arr_0.setter
def int3_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.int3_arr_0)
data_view.set(value)
self.int3_arr_0_size = data_view.get_array_size()
@property
def int4_0(self):
data_view = og.AttributeValueHelper(self._attributes.int4_0)
return data_view.get()
@int4_0.setter
def int4_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.int4_0)
data_view.set(value)
@property
def int4_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.int4_arr_0)
return data_view.get(reserved_element_count=self.int4_arr_0_size)
@int4_arr_0.setter
def int4_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.int4_arr_0)
data_view.set(value)
self.int4_arr_0_size = data_view.get_array_size()
@property
def int64_0(self):
data_view = og.AttributeValueHelper(self._attributes.int64_0)
return data_view.get()
@int64_0.setter
def int64_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.int64_0)
data_view.set(value)
@property
def int64_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.int64_arr_0)
return data_view.get(reserved_element_count=self.int64_arr_0_size)
@int64_arr_0.setter
def int64_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.int64_arr_0)
data_view.set(value)
self.int64_arr_0_size = data_view.get_array_size()
@property
def int_0(self):
data_view = og.AttributeValueHelper(self._attributes.int_0)
return data_view.get()
@int_0.setter
def int_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.int_0)
data_view.set(value)
@property
def int_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.int_arr_0)
return data_view.get(reserved_element_count=self.int_arr_0_size)
@int_arr_0.setter
def int_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.int_arr_0)
data_view.set(value)
self.int_arr_0_size = data_view.get_array_size()
@property
def matrixd2_0(self):
data_view = og.AttributeValueHelper(self._attributes.matrixd2_0)
return data_view.get()
@matrixd2_0.setter
def matrixd2_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.matrixd2_0)
data_view.set(value)
@property
def matrixd2_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.matrixd2_arr_0)
return data_view.get(reserved_element_count=self.matrixd2_arr_0_size)
@matrixd2_arr_0.setter
def matrixd2_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.matrixd2_arr_0)
data_view.set(value)
self.matrixd2_arr_0_size = data_view.get_array_size()
@property
def matrixd3_0(self):
data_view = og.AttributeValueHelper(self._attributes.matrixd3_0)
return data_view.get()
@matrixd3_0.setter
def matrixd3_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.matrixd3_0)
data_view.set(value)
@property
def matrixd3_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.matrixd3_arr_0)
return data_view.get(reserved_element_count=self.matrixd3_arr_0_size)
@matrixd3_arr_0.setter
def matrixd3_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.matrixd3_arr_0)
data_view.set(value)
self.matrixd3_arr_0_size = data_view.get_array_size()
@property
def matrixd4_0(self):
data_view = og.AttributeValueHelper(self._attributes.matrixd4_0)
return data_view.get()
@matrixd4_0.setter
def matrixd4_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.matrixd4_0)
data_view.set(value)
@property
def matrixd4_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.matrixd4_arr_0)
return data_view.get(reserved_element_count=self.matrixd4_arr_0_size)
@matrixd4_arr_0.setter
def matrixd4_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.matrixd4_arr_0)
data_view.set(value)
self.matrixd4_arr_0_size = data_view.get_array_size()
@property
def normald3_0(self):
data_view = og.AttributeValueHelper(self._attributes.normald3_0)
return data_view.get()
@normald3_0.setter
def normald3_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.normald3_0)
data_view.set(value)
@property
def normald3_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.normald3_arr_0)
return data_view.get(reserved_element_count=self.normald3_arr_0_size)
@normald3_arr_0.setter
def normald3_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.normald3_arr_0)
data_view.set(value)
self.normald3_arr_0_size = data_view.get_array_size()
@property
def normalf3_0(self):
data_view = og.AttributeValueHelper(self._attributes.normalf3_0)
return data_view.get()
@normalf3_0.setter
def normalf3_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.normalf3_0)
data_view.set(value)
@property
def normalf3_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.normalf3_arr_0)
return data_view.get(reserved_element_count=self.normalf3_arr_0_size)
@normalf3_arr_0.setter
def normalf3_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.normalf3_arr_0)
data_view.set(value)
self.normalf3_arr_0_size = data_view.get_array_size()
@property
def normalh3_0(self):
data_view = og.AttributeValueHelper(self._attributes.normalh3_0)
return data_view.get()
@normalh3_0.setter
def normalh3_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.normalh3_0)
data_view.set(value)
@property
def normalh3_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.normalh3_arr_0)
return data_view.get(reserved_element_count=self.normalh3_arr_0_size)
@normalh3_arr_0.setter
def normalh3_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.normalh3_arr_0)
data_view.set(value)
self.normalh3_arr_0_size = data_view.get_array_size()
@property
def pointd3_0(self):
data_view = og.AttributeValueHelper(self._attributes.pointd3_0)
return data_view.get()
@pointd3_0.setter
def pointd3_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.pointd3_0)
data_view.set(value)
@property
def pointd3_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.pointd3_arr_0)
return data_view.get(reserved_element_count=self.pointd3_arr_0_size)
@pointd3_arr_0.setter
def pointd3_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.pointd3_arr_0)
data_view.set(value)
self.pointd3_arr_0_size = data_view.get_array_size()
@property
def pointf3_0(self):
data_view = og.AttributeValueHelper(self._attributes.pointf3_0)
return data_view.get()
@pointf3_0.setter
def pointf3_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.pointf3_0)
data_view.set(value)
@property
def pointf3_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.pointf3_arr_0)
return data_view.get(reserved_element_count=self.pointf3_arr_0_size)
@pointf3_arr_0.setter
def pointf3_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.pointf3_arr_0)
data_view.set(value)
self.pointf3_arr_0_size = data_view.get_array_size()
@property
def pointh3_0(self):
data_view = og.AttributeValueHelper(self._attributes.pointh3_0)
return data_view.get()
@pointh3_0.setter
def pointh3_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.pointh3_0)
data_view.set(value)
@property
def pointh3_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.pointh3_arr_0)
return data_view.get(reserved_element_count=self.pointh3_arr_0_size)
@pointh3_arr_0.setter
def pointh3_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.pointh3_arr_0)
data_view.set(value)
self.pointh3_arr_0_size = data_view.get_array_size()
@property
def quatd4_0(self):
data_view = og.AttributeValueHelper(self._attributes.quatd4_0)
return data_view.get()
@quatd4_0.setter
def quatd4_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.quatd4_0)
data_view.set(value)
@property
def quatd4_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.quatd4_arr_0)
return data_view.get(reserved_element_count=self.quatd4_arr_0_size)
@quatd4_arr_0.setter
def quatd4_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.quatd4_arr_0)
data_view.set(value)
self.quatd4_arr_0_size = data_view.get_array_size()
@property
def quatf4_0(self):
data_view = og.AttributeValueHelper(self._attributes.quatf4_0)
return data_view.get()
@quatf4_0.setter
def quatf4_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.quatf4_0)
data_view.set(value)
@property
def quatf4_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.quatf4_arr_0)
return data_view.get(reserved_element_count=self.quatf4_arr_0_size)
@quatf4_arr_0.setter
def quatf4_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.quatf4_arr_0)
data_view.set(value)
self.quatf4_arr_0_size = data_view.get_array_size()
@property
def quath4_0(self):
data_view = og.AttributeValueHelper(self._attributes.quath4_0)
return data_view.get()
@quath4_0.setter
def quath4_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.quath4_0)
data_view.set(value)
@property
def quath4_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.quath4_arr_0)
return data_view.get(reserved_element_count=self.quath4_arr_0_size)
@quath4_arr_0.setter
def quath4_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.quath4_arr_0)
data_view.set(value)
self.quath4_arr_0_size = data_view.get_array_size()
@property
def texcoordd2_0(self):
data_view = og.AttributeValueHelper(self._attributes.texcoordd2_0)
return data_view.get()
@texcoordd2_0.setter
def texcoordd2_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.texcoordd2_0)
data_view.set(value)
@property
def texcoordd2_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.texcoordd2_arr_0)
return data_view.get(reserved_element_count=self.texcoordd2_arr_0_size)
@texcoordd2_arr_0.setter
def texcoordd2_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.texcoordd2_arr_0)
data_view.set(value)
self.texcoordd2_arr_0_size = data_view.get_array_size()
@property
def texcoordd3_0(self):
data_view = og.AttributeValueHelper(self._attributes.texcoordd3_0)
return data_view.get()
@texcoordd3_0.setter
def texcoordd3_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.texcoordd3_0)
data_view.set(value)
@property
def texcoordd3_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.texcoordd3_arr_0)
return data_view.get(reserved_element_count=self.texcoordd3_arr_0_size)
@texcoordd3_arr_0.setter
def texcoordd3_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.texcoordd3_arr_0)
data_view.set(value)
self.texcoordd3_arr_0_size = data_view.get_array_size()
@property
def texcoordf2_0(self):
data_view = og.AttributeValueHelper(self._attributes.texcoordf2_0)
return data_view.get()
@texcoordf2_0.setter
def texcoordf2_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.texcoordf2_0)
data_view.set(value)
@property
def texcoordf2_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.texcoordf2_arr_0)
return data_view.get(reserved_element_count=self.texcoordf2_arr_0_size)
@texcoordf2_arr_0.setter
def texcoordf2_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.texcoordf2_arr_0)
data_view.set(value)
self.texcoordf2_arr_0_size = data_view.get_array_size()
@property
def texcoordf3_0(self):
data_view = og.AttributeValueHelper(self._attributes.texcoordf3_0)
return data_view.get()
@texcoordf3_0.setter
def texcoordf3_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.texcoordf3_0)
data_view.set(value)
@property
def texcoordf3_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.texcoordf3_arr_0)
return data_view.get(reserved_element_count=self.texcoordf3_arr_0_size)
@texcoordf3_arr_0.setter
def texcoordf3_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.texcoordf3_arr_0)
data_view.set(value)
self.texcoordf3_arr_0_size = data_view.get_array_size()
@property
def texcoordh2_0(self):
data_view = og.AttributeValueHelper(self._attributes.texcoordh2_0)
return data_view.get()
@texcoordh2_0.setter
def texcoordh2_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.texcoordh2_0)
data_view.set(value)
@property
def texcoordh2_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.texcoordh2_arr_0)
return data_view.get(reserved_element_count=self.texcoordh2_arr_0_size)
@texcoordh2_arr_0.setter
def texcoordh2_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.texcoordh2_arr_0)
data_view.set(value)
self.texcoordh2_arr_0_size = data_view.get_array_size()
@property
def texcoordh3_0(self):
data_view = og.AttributeValueHelper(self._attributes.texcoordh3_0)
return data_view.get()
@texcoordh3_0.setter
def texcoordh3_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.texcoordh3_0)
data_view.set(value)
@property
def texcoordh3_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.texcoordh3_arr_0)
return data_view.get(reserved_element_count=self.texcoordh3_arr_0_size)
@texcoordh3_arr_0.setter
def texcoordh3_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.texcoordh3_arr_0)
data_view.set(value)
self.texcoordh3_arr_0_size = data_view.get_array_size()
@property
def timecode_0(self):
data_view = og.AttributeValueHelper(self._attributes.timecode_0)
return data_view.get()
@timecode_0.setter
def timecode_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.timecode_0)
data_view.set(value)
@property
def timecode_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.timecode_arr_0)
return data_view.get(reserved_element_count=self.timecode_arr_0_size)
@timecode_arr_0.setter
def timecode_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.timecode_arr_0)
data_view.set(value)
self.timecode_arr_0_size = data_view.get_array_size()
@property
def token_0(self):
data_view = og.AttributeValueHelper(self._attributes.token_0)
return data_view.get()
@token_0.setter
def token_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.token_0)
data_view.set(value)
@property
def token_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.token_arr_0)
return data_view.get(reserved_element_count=self.token_arr_0_size)
@token_arr_0.setter
def token_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.token_arr_0)
data_view.set(value)
self.token_arr_0_size = data_view.get_array_size()
@property
def transform4_0(self):
data_view = og.AttributeValueHelper(self._attributes.transform4_0)
return data_view.get()
@transform4_0.setter
def transform4_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.transform4_0)
data_view.set(value)
@property
def transform4_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.transform4_arr_0)
return data_view.get(reserved_element_count=self.transform4_arr_0_size)
@transform4_arr_0.setter
def transform4_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.transform4_arr_0)
data_view.set(value)
self.transform4_arr_0_size = data_view.get_array_size()
@property
def uchar_0(self):
data_view = og.AttributeValueHelper(self._attributes.uchar_0)
return data_view.get()
@uchar_0.setter
def uchar_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.uchar_0)
data_view.set(value)
@property
def uchar_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.uchar_arr_0)
return data_view.get(reserved_element_count=self.uchar_arr_0_size)
@uchar_arr_0.setter
def uchar_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.uchar_arr_0)
data_view.set(value)
self.uchar_arr_0_size = data_view.get_array_size()
@property
def uint64_0(self):
data_view = og.AttributeValueHelper(self._attributes.uint64_0)
return data_view.get()
@uint64_0.setter
def uint64_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.uint64_0)
data_view.set(value)
@property
def uint64_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.uint64_arr_0)
return data_view.get(reserved_element_count=self.uint64_arr_0_size)
@uint64_arr_0.setter
def uint64_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.uint64_arr_0)
data_view.set(value)
self.uint64_arr_0_size = data_view.get_array_size()
@property
def uint_0(self):
data_view = og.AttributeValueHelper(self._attributes.uint_0)
return data_view.get()
@uint_0.setter
def uint_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.uint_0)
data_view.set(value)
@property
def uint_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.uint_arr_0)
return data_view.get(reserved_element_count=self.uint_arr_0_size)
@uint_arr_0.setter
def uint_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.uint_arr_0)
data_view.set(value)
self.uint_arr_0_size = data_view.get_array_size()
@property
def vectord3_0(self):
data_view = og.AttributeValueHelper(self._attributes.vectord3_0)
return data_view.get()
@vectord3_0.setter
def vectord3_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.vectord3_0)
data_view.set(value)
@property
def vectord3_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.vectord3_arr_0)
return data_view.get(reserved_element_count=self.vectord3_arr_0_size)
@vectord3_arr_0.setter
def vectord3_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.vectord3_arr_0)
data_view.set(value)
self.vectord3_arr_0_size = data_view.get_array_size()
@property
def vectorf3_0(self):
data_view = og.AttributeValueHelper(self._attributes.vectorf3_0)
return data_view.get()
@vectorf3_0.setter
def vectorf3_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.vectorf3_0)
data_view.set(value)
@property
def vectorf3_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.vectorf3_arr_0)
return data_view.get(reserved_element_count=self.vectorf3_arr_0_size)
@vectorf3_arr_0.setter
def vectorf3_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.vectorf3_arr_0)
data_view.set(value)
self.vectorf3_arr_0_size = data_view.get_array_size()
@property
def vectorh3_0(self):
data_view = og.AttributeValueHelper(self._attributes.vectorh3_0)
return data_view.get()
@vectorh3_0.setter
def vectorh3_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.vectorh3_0)
data_view.set(value)
@property
def vectorh3_arr_0(self):
data_view = og.AttributeValueHelper(self._attributes.vectorh3_arr_0)
return data_view.get(reserved_element_count=self.vectorh3_arr_0_size)
@vectorh3_arr_0.setter
def vectorh3_arr_0(self, value):
data_view = og.AttributeValueHelper(self._attributes.vectorh3_arr_0)
data_view.set(value)
self.vectorh3_arr_0_size = data_view.get_array_size()
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 = OgnUniversalAddDatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
self.outputs = OgnUniversalAddDatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
self.state = OgnUniversalAddDatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
| 215,357 | Python | 45.413362 | 295 | 0.589226 |
omniverse-code/kit/exts/omni.graph.examples.cpp/omni/graph/examples/cpp/ogn/OgnGpuInteropCpuToDiskDatabase.py | """Support for simplified access to data on nodes of type omni.graph.examples.cpp.GpuInteropCpuToDisk
Saves specified CPU buffer to disk
"""
import omni.graph.core as og
import omni.graph.core._omni_graph_core as _og
import omni.graph.tools.ogn as ogn
class OgnGpuInteropCpuToDiskDatabase(og.Database):
"""Helper class providing simplified access to data on nodes of type omni.graph.examples.cpp.GpuInteropCpuToDisk
Class Members:
node: Node being evaluated
Attribute Value Properties:
Inputs:
inputs.active
inputs.aovCpu
inputs.aovGpu
inputs.autoFileNumber
inputs.fileName
inputs.fileNumber
inputs.fileType
inputs.frameCount
inputs.gpu
inputs.maxInflightWrites
inputs.rp
inputs.saveFlags
inputs.saveLocation
inputs.startFrame
Outputs:
outputs.gpu
outputs.rp
"""
# 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:active', 'bool', 0, 'activeReset', 'Alternative to frameCount/startFrame, does a single frame then autoResets to false', {ogn.MetadataKeys.DEFAULT: 'false'}, True, False, False, ''),
('inputs:aovCpu', 'string', 0, 'aovCpu', 'Name of AOV representing CPU buffer of GPU resource', {ogn.MetadataKeys.DEFAULT: '""'}, True, "", False, ''),
('inputs:aovGpu', 'string', 0, 'aovGpu', 'Name of AOV representing GPU resource, used for querying format + properties', {ogn.MetadataKeys.DEFAULT: '""'}, True, "", False, ''),
('inputs:autoFileNumber', 'int', 0, 'autoFileNumber', 'If non zero, this number will be the starting number for export. Each invocation of this node increases the number by 1.', {ogn.MetadataKeys.DEFAULT: '-1'}, True, -1, False, ''),
('inputs:fileName', 'string', 0, 'fileName', 'Optional, if specified the output filename will be fileName_{aovGpu}.{fileType}', {ogn.MetadataKeys.DEFAULT: '""'}, True, "", False, ''),
('inputs:fileNumber', 'int', 0, 'fileNumber', "Number that will be appended to the exported filename. If -1 then the render product's frame number will be used.", {ogn.MetadataKeys.DEFAULT: '-1'}, True, -1, False, ''),
('inputs:fileType', 'string', 0, 'fileType', 'bmp,png,exr', {ogn.MetadataKeys.DEFAULT: '"png"'}, True, "png", False, ''),
('inputs:frameCount', 'int64', 0, 'frameCount', 'Number of frames to capture (-1 means never stop)', {ogn.MetadataKeys.DEFAULT: '-1'}, True, -1, False, ''),
('inputs:gpu', 'uint64', 0, 'gpuFoundations', 'Pointer to shared context containing gpu foundations', {}, True, 0, False, ''),
('inputs:maxInflightWrites', 'int', 0, 'maxInflightWrites', 'Maximum number of in-flight file write operations before blocking on file i/o', {ogn.MetadataKeys.DEFAULT: '2'}, True, 2, False, ''),
('inputs:rp', 'uint64', 0, 'renderProduct', 'Pointer to render product for this view', {}, True, 0, False, ''),
('inputs:saveFlags', 'uint64', 0, 'saveFlags', 'Flags that will be passed to carb::imaging::IImaging for file saving.', {ogn.MetadataKeys.DEFAULT: '0'}, True, 0, False, ''),
('inputs:saveLocation', 'string', 0, 'saveLocation', 'Folder to save AOVs as AOV_FrameNumber.{exr,png}', {ogn.MetadataKeys.DEFAULT: '""'}, True, "", False, ''),
('inputs:startFrame', 'uint64', 0, 'startFrame', 'Frame to begin saving to disk', {ogn.MetadataKeys.DEFAULT: '0'}, True, 0, False, ''),
('outputs:gpu', 'uint64', 0, 'gpuFoundations', 'Pointer to shared context containing gpu foundations', {}, True, None, False, ''),
('outputs:rp', 'uint64', 0, 'renderProduct', 'Pointer to render product for this view', {}, 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.aovCpu = og.AttributeRole.TEXT
role_data.inputs.aovGpu = og.AttributeRole.TEXT
role_data.inputs.fileName = og.AttributeRole.TEXT
role_data.inputs.fileType = og.AttributeRole.TEXT
role_data.inputs.saveLocation = og.AttributeRole.TEXT
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._batchedReadAttributes = []
self._batchedReadValues = []
@property
def active(self):
data_view = og.AttributeValueHelper(self._attributes.active)
return data_view.get()
@active.setter
def active(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.active)
data_view = og.AttributeValueHelper(self._attributes.active)
data_view.set(value)
@property
def aovCpu(self):
data_view = og.AttributeValueHelper(self._attributes.aovCpu)
return data_view.get()
@aovCpu.setter
def aovCpu(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.aovCpu)
data_view = og.AttributeValueHelper(self._attributes.aovCpu)
data_view.set(value)
self.aovCpu_size = data_view.get_array_size()
@property
def aovGpu(self):
data_view = og.AttributeValueHelper(self._attributes.aovGpu)
return data_view.get()
@aovGpu.setter
def aovGpu(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.aovGpu)
data_view = og.AttributeValueHelper(self._attributes.aovGpu)
data_view.set(value)
self.aovGpu_size = data_view.get_array_size()
@property
def autoFileNumber(self):
data_view = og.AttributeValueHelper(self._attributes.autoFileNumber)
return data_view.get()
@autoFileNumber.setter
def autoFileNumber(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.autoFileNumber)
data_view = og.AttributeValueHelper(self._attributes.autoFileNumber)
data_view.set(value)
@property
def fileName(self):
data_view = og.AttributeValueHelper(self._attributes.fileName)
return data_view.get()
@fileName.setter
def fileName(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.fileName)
data_view = og.AttributeValueHelper(self._attributes.fileName)
data_view.set(value)
self.fileName_size = data_view.get_array_size()
@property
def fileNumber(self):
data_view = og.AttributeValueHelper(self._attributes.fileNumber)
return data_view.get()
@fileNumber.setter
def fileNumber(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.fileNumber)
data_view = og.AttributeValueHelper(self._attributes.fileNumber)
data_view.set(value)
@property
def fileType(self):
data_view = og.AttributeValueHelper(self._attributes.fileType)
return data_view.get()
@fileType.setter
def fileType(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.fileType)
data_view = og.AttributeValueHelper(self._attributes.fileType)
data_view.set(value)
self.fileType_size = data_view.get_array_size()
@property
def frameCount(self):
data_view = og.AttributeValueHelper(self._attributes.frameCount)
return data_view.get()
@frameCount.setter
def frameCount(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.frameCount)
data_view = og.AttributeValueHelper(self._attributes.frameCount)
data_view.set(value)
@property
def gpu(self):
data_view = og.AttributeValueHelper(self._attributes.gpu)
return data_view.get()
@gpu.setter
def gpu(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.gpu)
data_view = og.AttributeValueHelper(self._attributes.gpu)
data_view.set(value)
@property
def maxInflightWrites(self):
data_view = og.AttributeValueHelper(self._attributes.maxInflightWrites)
return data_view.get()
@maxInflightWrites.setter
def maxInflightWrites(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.maxInflightWrites)
data_view = og.AttributeValueHelper(self._attributes.maxInflightWrites)
data_view.set(value)
@property
def rp(self):
data_view = og.AttributeValueHelper(self._attributes.rp)
return data_view.get()
@rp.setter
def rp(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.rp)
data_view = og.AttributeValueHelper(self._attributes.rp)
data_view.set(value)
@property
def saveFlags(self):
data_view = og.AttributeValueHelper(self._attributes.saveFlags)
return data_view.get()
@saveFlags.setter
def saveFlags(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.saveFlags)
data_view = og.AttributeValueHelper(self._attributes.saveFlags)
data_view.set(value)
@property
def saveLocation(self):
data_view = og.AttributeValueHelper(self._attributes.saveLocation)
return data_view.get()
@saveLocation.setter
def saveLocation(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.saveLocation)
data_view = og.AttributeValueHelper(self._attributes.saveLocation)
data_view.set(value)
self.saveLocation_size = data_view.get_array_size()
@property
def startFrame(self):
data_view = og.AttributeValueHelper(self._attributes.startFrame)
return data_view.get()
@startFrame.setter
def startFrame(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.startFrame)
data_view = og.AttributeValueHelper(self._attributes.startFrame)
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 gpu(self):
data_view = og.AttributeValueHelper(self._attributes.gpu)
return data_view.get()
@gpu.setter
def gpu(self, value):
data_view = og.AttributeValueHelper(self._attributes.gpu)
data_view.set(value)
@property
def rp(self):
data_view = og.AttributeValueHelper(self._attributes.rp)
return data_view.get()
@rp.setter
def rp(self, value):
data_view = og.AttributeValueHelper(self._attributes.rp)
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 = OgnGpuInteropCpuToDiskDatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
self.outputs = OgnGpuInteropCpuToDiskDatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
self.state = OgnGpuInteropCpuToDiskDatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
| 14,661 | Python | 44.962382 | 241 | 0.632153 |
omniverse-code/kit/exts/omni.graph.examples.cpp/omni/graph/examples/cpp/ogn/OgnIKDatabase.py | """Support for simplified access to data on nodes of type omni.graph.examples.cpp.SimpleIk
Example node that employs a simple IK algorithm to match a three-joint limb to a goal
"""
import numpy
import omni.graph.core as og
import omni.graph.core._omni_graph_core as _og
import omni.graph.tools.ogn as ogn
class OgnIKDatabase(og.Database):
"""Helper class providing simplified access to data on nodes of type omni.graph.examples.cpp.SimpleIk
Class Members:
node: Node being evaluated
Attribute Value Properties:
Inputs:
inputs.goal
State:
state.ankle
state.hip
state.knee
"""
# 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:goal', 'matrix4d', 0, 'Goal Transform', 'Transform of the IK goal', {}, 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, ''),
('state:ankle', 'matrix4d', 0, 'Ankle Transform', 'Computed transform of the ankle joint', {}, True, None, False, ''),
('state:hip', 'matrix4d', 0, 'Hip Transform', 'Computed transform of the hip joint', {}, True, None, False, ''),
('state:knee', 'matrix4d', 0, 'Knee Transform', 'Computed transform of the knee joint', {}, 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.goal = og.AttributeRole.MATRIX
role_data.state.ankle = og.AttributeRole.MATRIX
role_data.state.hip = og.AttributeRole.MATRIX
role_data.state.knee = 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._batchedReadAttributes = []
self._batchedReadValues = []
@property
def goal(self):
data_view = og.AttributeValueHelper(self._attributes.goal)
return data_view.get()
@goal.setter
def goal(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.goal)
data_view = og.AttributeValueHelper(self._attributes.goal)
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 = { }
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)
@property
def ankle(self):
data_view = og.AttributeValueHelper(self._attributes.ankle)
return data_view.get()
@ankle.setter
def ankle(self, value):
data_view = og.AttributeValueHelper(self._attributes.ankle)
data_view.set(value)
@property
def hip(self):
data_view = og.AttributeValueHelper(self._attributes.hip)
return data_view.get()
@hip.setter
def hip(self, value):
data_view = og.AttributeValueHelper(self._attributes.hip)
data_view.set(value)
@property
def knee(self):
data_view = og.AttributeValueHelper(self._attributes.knee)
return data_view.get()
@knee.setter
def knee(self, value):
data_view = og.AttributeValueHelper(self._attributes.knee)
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 = OgnIKDatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
self.outputs = OgnIKDatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
self.state = OgnIKDatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
| 6,427 | Python | 43.638889 | 196 | 0.648047 |
omniverse-code/kit/exts/omni.graph.examples.cpp/omni/graph/examples/cpp/ogn/OgnExampleExtractFloat3ArrayDatabase.py | """Support for simplified access to data on nodes of type omni.graph.examples.cpp.ExtractFloat3Array
Outputs a float[3][] attribute extracted from a bundle.
"""
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 OgnExampleExtractFloat3ArrayDatabase(og.Database):
"""Helper class providing simplified access to data on nodes of type omni.graph.examples.cpp.ExtractFloat3Array
Class Members:
node: Node being evaluated
Attribute Value Properties:
Inputs:
inputs.input
inputs.nameOfAttribute
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, "Bundle containing a float[3][] attribute to be extracted to 'output'", {}, True, None, False, ''),
('inputs:nameOfAttribute', 'token', 0, None, "Name of the attribute in 'input' that is to be extracted to 'output'", {}, True, "", False, ''),
('outputs:output', 'float3[]', 0, None, "The float[3][] attribute extracted from 'input'", {}, 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
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 nameOfAttribute(self):
data_view = og.AttributeValueHelper(self._attributes.nameOfAttribute)
return data_view.get()
@nameOfAttribute.setter
def nameOfAttribute(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.nameOfAttribute)
data_view = og.AttributeValueHelper(self._attributes.nameOfAttribute)
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.output_size = None
self._batchedWriteValues = { }
@property
def output(self):
data_view = og.AttributeValueHelper(self._attributes.output)
return data_view.get(reserved_element_count=self.output_size)
@output.setter
def output(self, value):
data_view = og.AttributeValueHelper(self._attributes.output)
data_view.set(value)
self.output_size = data_view.get_array_size()
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 = OgnExampleExtractFloat3ArrayDatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
self.outputs = OgnExampleExtractFloat3ArrayDatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
self.state = OgnExampleExtractFloat3ArrayDatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
| 6,099 | Python | 46.65625 | 150 | 0.67011 |
omniverse-code/kit/exts/omni.graph.examples.cpp/omni/graph/examples/cpp/ogn/OgnGpuInteropGpuToCpuCopyDatabase.py | """Support for simplified access to data on nodes of type omni.graph.examples.cpp.GpuInteropGpuToCpuCopy
Generates a new AOV representing a CPU copy of a GPU buffer
"""
import omni.graph.core as og
import omni.graph.core._omni_graph_core as _og
import omni.graph.tools.ogn as ogn
class OgnGpuInteropGpuToCpuCopyDatabase(og.Database):
"""Helper class providing simplified access to data on nodes of type omni.graph.examples.cpp.GpuInteropGpuToCpuCopy
Class Members:
node: Node being evaluated
Attribute Value Properties:
Inputs:
inputs.aovGpu
inputs.gpu
inputs.rp
Outputs:
outputs.aovCpu
outputs.gpu
outputs.rp
"""
# 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:aovGpu', 'string', 0, 'aovGpu', 'Name of AOV to copy from GPU to CPU', {ogn.MetadataKeys.DEFAULT: '""'}, True, "", False, ''),
('inputs:gpu', 'uint64', 0, 'gpuFoundations', 'Pointer to shared context containing gpu foundations', {}, True, 0, False, ''),
('inputs:rp', 'uint64', 0, 'renderProduct', 'Pointer to render product for this view', {}, True, 0, False, ''),
('outputs:aovCpu', 'string', 0, 'aovCpu', 'Name of AOV representing CPU buffer of GPU resource', {ogn.MetadataKeys.DEFAULT: '""'}, True, "", False, ''),
('outputs:gpu', 'uint64', 0, 'gpuFoundations', 'Pointer to shared context containing gpu foundations', {}, True, None, False, ''),
('outputs:rp', 'uint64', 0, 'renderProduct', 'Pointer to render product for this view', {}, 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.aovGpu = og.AttributeRole.TEXT
role_data.outputs.aovCpu = og.AttributeRole.TEXT
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._batchedReadAttributes = []
self._batchedReadValues = []
@property
def aovGpu(self):
data_view = og.AttributeValueHelper(self._attributes.aovGpu)
return data_view.get()
@aovGpu.setter
def aovGpu(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.aovGpu)
data_view = og.AttributeValueHelper(self._attributes.aovGpu)
data_view.set(value)
self.aovGpu_size = data_view.get_array_size()
@property
def gpu(self):
data_view = og.AttributeValueHelper(self._attributes.gpu)
return data_view.get()
@gpu.setter
def gpu(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.gpu)
data_view = og.AttributeValueHelper(self._attributes.gpu)
data_view.set(value)
@property
def rp(self):
data_view = og.AttributeValueHelper(self._attributes.rp)
return data_view.get()
@rp.setter
def rp(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.rp)
data_view = og.AttributeValueHelper(self._attributes.rp)
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.aovCpu_size = 0
self._batchedWriteValues = { }
@property
def aovCpu(self):
data_view = og.AttributeValueHelper(self._attributes.aovCpu)
return data_view.get(reserved_element_count=self.aovCpu_size)
@aovCpu.setter
def aovCpu(self, value):
data_view = og.AttributeValueHelper(self._attributes.aovCpu)
data_view.set(value)
self.aovCpu_size = data_view.get_array_size()
@property
def gpu(self):
data_view = og.AttributeValueHelper(self._attributes.gpu)
return data_view.get()
@gpu.setter
def gpu(self, value):
data_view = og.AttributeValueHelper(self._attributes.gpu)
data_view.set(value)
@property
def rp(self):
data_view = og.AttributeValueHelper(self._attributes.rp)
return data_view.get()
@rp.setter
def rp(self, value):
data_view = og.AttributeValueHelper(self._attributes.rp)
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 = OgnGpuInteropGpuToCpuCopyDatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
self.outputs = OgnGpuInteropGpuToCpuCopyDatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
self.state = OgnGpuInteropGpuToCpuCopyDatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
| 7,683 | Python | 43.674418 | 160 | 0.644019 |
omniverse-code/kit/exts/omni.graph.examples.cpp/omni/graph/examples/cpp/ogn/tests/TestOgnSimpleGather.py | import omni.kit.test
import omni.graph.core as og
import omni.graph.core.tests as ogts
class TestOgn(ogts.OmniGraphTestCase):
async def test_data_access(self):
from omni.graph.examples.cpp.ogn.OgnSimpleGatherDatabase import OgnSimpleGatherDatabase
(_, (test_node,), _, _) = og.Controller.edit("/TestGraph", {
og.Controller.Keys.CREATE_NODES: ("Template_omni_graph_examples_cpp_SimpleGather", "omni.graph.examples.cpp.SimpleGather")
})
database = OgnSimpleGatherDatabase(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:input0"))
attribute = test_node.get_attribute("inputs:input0")
db_value = database.inputs.input0
expected_value = []
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:multiplier"))
attribute = test_node.get_attribute("inputs:multiplier")
db_value = database.inputs.multiplier
expected_value = 0.0
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("outputs:output0"))
attribute = test_node.get_attribute("outputs:output0")
db_value = database.outputs.output0
| 1,727 | Python | 44.473683 | 134 | 0.676896 |
omniverse-code/kit/exts/omni.graph.examples.cpp/omni/graph/examples/cpp/ogn/tests/TestOgnExampleAdjacency.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.examples.cpp.ogn.OgnExampleAdjacencyDatabase import OgnExampleAdjacencyDatabase
test_file_name = "OgnExampleAdjacencyTemplate.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_examples_cpp_Adjacency")
database = OgnExampleAdjacencyDatabase(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:computeDistances"))
attribute = test_node.get_attribute("inputs:computeDistances")
db_value = database.inputs.computeDistances
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:computeNeighborCounts"))
attribute = test_node.get_attribute("inputs:computeNeighborCounts")
db_value = database.inputs.computeNeighborCounts
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:computeNeighborStarts"))
attribute = test_node.get_attribute("inputs:computeNeighborStarts")
db_value = database.inputs.computeNeighborStarts
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:computeNeighbors"))
attribute = test_node.get_attribute("inputs:computeNeighbors")
db_value = database.inputs.computeNeighbors
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:mesh"))
attribute = test_node.get_attribute("inputs:mesh")
db_value = database.inputs.mesh
self.assertTrue(test_node.get_attribute_exists("inputs:nameOfDistancesOutputAttribute"))
attribute = test_node.get_attribute("inputs:nameOfDistancesOutputAttribute")
db_value = database.inputs.nameOfDistancesOutputAttribute
expected_value = "distances"
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:nameOfNeighborCountsOutputAttribute"))
attribute = test_node.get_attribute("inputs:nameOfNeighborCountsOutputAttribute")
db_value = database.inputs.nameOfNeighborCountsOutputAttribute
expected_value = "neighborCounts"
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:nameOfNeighborStartsOutputAttribute"))
attribute = test_node.get_attribute("inputs:nameOfNeighborStartsOutputAttribute")
db_value = database.inputs.nameOfNeighborStartsOutputAttribute
expected_value = "neighborStarts"
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:nameOfNeighborsOutputAttribute"))
attribute = test_node.get_attribute("inputs:nameOfNeighborsOutputAttribute")
db_value = database.inputs.nameOfNeighborsOutputAttribute
expected_value = "neighbors"
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:nameOfPositionsInputAttribute"))
attribute = test_node.get_attribute("inputs:nameOfPositionsInputAttribute")
db_value = database.inputs.nameOfPositionsInputAttribute
expected_value = "points"
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:nameOfVertexCountsInputAttribute"))
attribute = test_node.get_attribute("inputs:nameOfVertexCountsInputAttribute")
db_value = database.inputs.nameOfVertexCountsInputAttribute
expected_value = "faceVertexCounts"
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:nameOfVertexIndicesInputAttribute"))
attribute = test_node.get_attribute("inputs:nameOfVertexIndicesInputAttribute")
db_value = database.inputs.nameOfVertexIndicesInputAttribute
expected_value = "faceVertexIndices"
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:pointCount"))
attribute = test_node.get_attribute("inputs:pointCount")
db_value = database.inputs.pointCount
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("inputs:removeDuplicates"))
attribute = test_node.get_attribute("inputs:removeDuplicates")
db_value = database.inputs.removeDuplicates
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:treatEdgesAsOneWay"))
attribute = test_node.get_attribute("inputs:treatEdgesAsOneWay")
db_value = database.inputs.treatEdgesAsOneWay
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:treatFacesAsCurves"))
attribute = test_node.get_attribute("inputs:treatFacesAsCurves")
db_value = database.inputs.treatFacesAsCurves
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("outputs_mesh"))
attribute = test_node.get_attribute("outputs_mesh")
db_value = database.outputs.mesh
| 9,206 | Python | 56.90566 | 103 | 0.714643 |
omniverse-code/kit/exts/omni.graph.examples.cpp/omni/graph/examples/cpp/ogn/tests/TestOgnGpuInteropCpuToDisk.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.examples.cpp.ogn.OgnGpuInteropCpuToDiskDatabase import OgnGpuInteropCpuToDiskDatabase
test_file_name = "OgnGpuInteropCpuToDiskTemplate.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_examples_cpp_GpuInteropCpuToDisk")
database = OgnGpuInteropCpuToDiskDatabase(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:active"))
attribute = test_node.get_attribute("inputs:active")
db_value = database.inputs.active
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:aovCpu"))
attribute = test_node.get_attribute("inputs:aovCpu")
db_value = database.inputs.aovCpu
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:aovGpu"))
attribute = test_node.get_attribute("inputs:aovGpu")
db_value = database.inputs.aovGpu
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:autoFileNumber"))
attribute = test_node.get_attribute("inputs:autoFileNumber")
db_value = database.inputs.autoFileNumber
expected_value = -1
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:fileName"))
attribute = test_node.get_attribute("inputs:fileName")
db_value = database.inputs.fileName
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:fileNumber"))
attribute = test_node.get_attribute("inputs:fileNumber")
db_value = database.inputs.fileNumber
expected_value = -1
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:fileType"))
attribute = test_node.get_attribute("inputs:fileType")
db_value = database.inputs.fileType
expected_value = "png"
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:frameCount"))
attribute = test_node.get_attribute("inputs:frameCount")
db_value = database.inputs.frameCount
expected_value = -1
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:gpu"))
attribute = test_node.get_attribute("inputs:gpu")
db_value = database.inputs.gpu
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("inputs:maxInflightWrites"))
attribute = test_node.get_attribute("inputs:maxInflightWrites")
db_value = database.inputs.maxInflightWrites
expected_value = 2
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:rp"))
attribute = test_node.get_attribute("inputs:rp")
db_value = database.inputs.rp
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("inputs:saveFlags"))
attribute = test_node.get_attribute("inputs:saveFlags")
db_value = database.inputs.saveFlags
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("inputs:saveLocation"))
attribute = test_node.get_attribute("inputs:saveLocation")
db_value = database.inputs.saveLocation
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:startFrame"))
attribute = test_node.get_attribute("inputs:startFrame")
db_value = database.inputs.startFrame
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:gpu"))
attribute = test_node.get_attribute("outputs:gpu")
db_value = database.outputs.gpu
self.assertTrue(test_node.get_attribute_exists("outputs:rp"))
attribute = test_node.get_attribute("outputs:rp")
db_value = database.outputs.rp
| 7,994 | Python | 51.94702 | 109 | 0.688641 |
omniverse-code/kit/exts/omni.graph.examples.cpp/omni/graph/examples/cpp/_impl/extension.py | """Support required by the Carbonite extension loader - no visible API exists.
"""
__all__ = []
import omni.ext
from ..bindings._omni_graph_examples_cpp import acquire_interface as _acquire
from ..bindings._omni_graph_examples_cpp import release_interface as _release
class _PublicExtension(omni.ext.IExt):
"""Object that tracks the lifetime of the Python part of the extension loading"""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.__interface = None
def on_startup(self):
"""Set up initial conditions for the Python part of the extension"""
self.__interface = _acquire()
def on_shutdown(self):
"""Shutting down this part of the extension prepares it for hot reload"""
_release(self.__interface)
self.__interface = None
| 833 | Python | 29.888888 | 85 | 0.663866 |
omniverse-code/kit/exts/omni.graph.examples.cpp/omni/graph/examples/cpp/tests/test_extension_shutdown.py | """Test cases for extension shutdown"""
import omni.graph.core as og
import omni.graph.core.tests as ogts
import omni.kit
# ======================================================================
class TestExtensionShutdown(ogts.OmniGraphTestCase):
"""Testing for extension shutdown"""
# ----------------------------------------------------------------------
async def test_om_43835(self):
"""Verify safe ordering of node state release on extension shutdown.
The test had to be put into this extension so that it could shut down the extension where the test node
lives without unloading the test itself.
"""
manager = omni.kit.app.get_app_interface().get_extension_manager()
test_nodes_extension = "omni.graph.test"
test_node_type = f"{test_nodes_extension}.TestGracefulShutdown"
was_extension_enabled = manager.is_extension_enabled(test_nodes_extension)
try:
manager.set_extension_enabled_immediate(test_nodes_extension, True)
self.assertTrue(manager.is_extension_enabled(test_nodes_extension))
# Creating a node is all that it takes to set up the state information required by the test
controller = og.Controller()
(graph, _, _, _) = controller.edit(
"/TestGraph",
{
og.Controller.Keys.CREATE_NODES: ("TestNode", test_node_type),
},
)
await controller.evaluate(graph)
# Unloading the extension triggers the state release, which will test the necessary conditions
manager.set_extension_enabled_immediate(test_nodes_extension, False)
self.assertEqual(0, og.test_failure_count(), "Test failure was reported by the node state")
finally:
manager.set_extension_enabled_immediate(test_nodes_extension, was_extension_enabled)
| 1,918 | Python | 44.690475 | 111 | 0.604275 |
omniverse-code/kit/exts/omni.graph.examples.cpp/omni/graph/examples/cpp/tests/test_partition_passes.py | """Partition pass example unit tests for OG"""
import carb
import omni.graph.core as og
import omni.graph.core.tests as ogts
# ======================================================================
class SimpleGraphScene:
def __init__(self):
self.graph = None
self.nodes = None
# ======================================================================
def create_scriptnode_graph():
"""Create a scene containing a PushGraph with a specific ScriptNode that is compatible with
the corresponding partition pass."""
scene = SimpleGraphScene()
(scene.graph, scene.nodes, _, _) = og.Controller.edit(
"/World/PushGraph",
{og.Controller.Keys.CREATE_NODES: [("ScriptNode", "omni.graph.scriptnode.ScriptNode")]},
)
return scene
# ======================================================================
def create_lazy_foreach_graph():
"""Create a simple LazyGraph with a ForEach node to test that dirty_push evaluation
is still respected after a partition pass is run."""
scene = SimpleGraphScene()
(scene.graph, scene.nodes, _, _) = og.Controller.edit(
{"graph_path": "/World/TestGraph", "evaluator_name": "dirty_push"},
{
og.Controller.Keys.CREATE_NODES: [
("Val0", "omni.graph.nodes.ConstantInt"),
("Val1", "omni.graph.nodes.ConstantInt"),
("Val2", "omni.graph.nodes.ConstantInt"),
("Array", "omni.graph.nodes.MakeArray"),
("ForEach", "omni.graph.action.ForEach"),
("Counter", "omni.graph.action.Counter"),
],
og.Controller.Keys.SET_VALUES: [
("Val0.inputs:value", 0),
("Val1.inputs:value", 1),
("Val2.inputs:value", 2),
("Array.inputs:arraySize", 3),
],
og.Controller.Keys.CONNECT: [
("Val0.inputs:value", "Array.inputs:a"),
("Val1.inputs:value", "Array.inputs:b"),
("Val2.inputs:value", "Array.inputs:c"),
("ForEach.outputs:finished", "Counter.inputs:execIn"),
],
},
)
return scene
# ======================================================================
class TestOmniGraphPartitionPasses(ogts.OmniGraphTestCase):
"""OmniGraph Partition Pass Unit Tests"""
async def test_override_foreachnode_pass(self):
"""Exercise the ForEach Node Pattern Partition Pass"""
# Wrapper method for loading and initializing the test scene.
async def setup_and_check(self, enable_pass: bool, expected_result):
"""Wrapper method for convenient test setup and execution"""
# Set the partition pass setting.
carb.settings.get_settings().set("/app/omni.graph.examples/enableForEachPass", enable_pass)
# Load the test scene.
(result, error) = await ogts.load_test_file("ForEachInPushGraph.usda", use_caller_subdirectory=True)
self.assertTrue(result, error)
# Read the scene graph.
graph = og.get_graph_by_path("/World/DrawLine")
graph_context = graph.get_default_graph_context()
variable = graph.find_variable("Points")
# Check that the necessary conditions are met.
for i in range(20):
await og.Controller.evaluate(graph)
value = variable.get_array(graph_context, False, 0)
for j in range(3):
for k in range(3):
self.assertAlmostEqual(
value[j][k], expected_result[i % len(expected_result)][j][k], places=4 # noqa: S001
)
# Note that we wrap the driver test code in a try-finally block to ensure
# that the enableForEachPass setting gets reset to False if an exception
# occurs (thus ensuring that it won't stick around and potentially pollute
# downstream tests).
try:
# ForEach partition pass disabled. When the partition pass is disabled in this test,
# each of 3 point values gets computed on a separate graph tick and the entire Points
# array gets overwritten. As a result, at most only one double[3] point in the array
# will be computed/composed of non-zero elements at any given evaluation, and the
# values contained in the variable will be subject to change each compute cycle.
expected_result_disabled = [
[[0, 0, 0], [0, 0, 0], [2.83183032e2, -3.41060513e-13, -1.50866692e2]],
[[0, 0, 0], [0, 0, 0], [2.83183032e2, -3.41060513e-13, -1.50866692e2]],
[[-300, 0, 0], [0, 0, 0], [0, 0, 0]],
[[0, 0, 0], [7.75462661, -1.13686838e-13, 1.54487908e2], [0, 0, 0]],
]
await setup_and_check(self, False, expected_result_disabled)
# ForEach partition pass enabled. When the partition pass is enabled in this test,
# each of the 3 individual point values get computed and written out to the Points
# variable in a single graph tick. As a result, the Points variable will not have
# any zero points, and the array will contain the same values each tick.
expected_result_enabled = [
[
[-300, 0, 0],
[7.75462661, -1.13686838e-13, 1.54487908e2],
[2.83183032e2, -3.41060513e-13, -1.50866692e2],
],
]
await setup_and_check(self, True, expected_result_enabled)
finally:
carb.settings.get_settings().set("/app/omni.graph.examples/enableForEachPass", False)
async def test_override_scriptnode_pass(self):
"""Exercise the Script Node Partition Pass"""
scene = create_scriptnode_graph()
# Add the necessary inputs and outputs to the script node so
# that the partition pass recognizes it.
og.Controller.create_attribute(
scene.nodes[0],
"inputs:my_input_attribute",
og.Type(og.BaseDataType.INT, 1, 0, og.AttributeRole.NONE),
og.AttributePortType.ATTRIBUTE_PORT_TYPE_INPUT,
)
og.Controller.create_attribute(
scene.nodes[0],
"outputs:my_output_attribute",
og.Type(og.BaseDataType.INT, 1, 0, og.AttributeRole.NONE),
og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT,
)
# Add an internal state variable to the script node that gets ticked
# for every evaluation. We'll use this counter to determine whether the
# node computed or simply passed its cached output value downstream
# (without a nodal compute being invoked).
og.Controller.create_attribute(
scene.nodes[0],
"state:my_internal_state",
og.Type(og.BaseDataType.INT, 1, 0, og.AttributeRole.NONE),
og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE,
)
# Set the script node's internal script to compute the nth Fibonacci
# Fibonacci in an iterative fashion (where n is the given integer via
# "inputs:my_input_attribute").
script_string = "def fib(count):\n"
script_string += " if count == 0:\n"
script_string += " return 0\n"
script_string += " if count == 1:\n"
script_string += " return 1\n"
script_string += "\n"
script_string += " num1 = 0\n"
script_string += " num2 = 1\n"
script_string += "\n"
script_string += " for i in range(count):\n"
script_string += " numth = num1 + num2\n"
script_string += " num1 = num2\n"
script_string += " num2 = numth\n"
script_string += " return num1\n"
script_string += "\n"
script_string += "def compute(db):\n"
script_string += " count = db.inputs.my_input_attribute\n"
script_string += " db.outputs.my_output_attribute = fib(count)\n"
script_string += " if db.state.my_internal_state < 10000:\n"
script_string += " db.state.my_internal_state += 1\n"
script_string += " else:\n"
script_string += " db.state.my_internal_state = 0\n"
scene.nodes[0].get_attribute("inputs:script").set(script_string)
my_input_attr = scene.nodes[0].get_attribute("inputs:my_input_attribute")
my_internal_state = scene.nodes[0].get_attribute("state:my_internal_state")
my_output_attr = scene.nodes[0].get_attribute("outputs:my_output_attribute")
# Set the input and try computing multiple times. Only the first
# call to evaluate the graph should have triggered a script node
# evaluation (per the partition pass that's being tested here).
# Note that we *temporarily* enable the script node partition
# during this test *only* in order to not potentially impact any
# other downstream tests.
with og.Settings.temporary("/app/omni.graph.examples/enableScriptNodePass", True):
my_input_attr.set(10)
for _ in range(4):
await og.Controller.evaluate(scene.graph)
self.assertEqual(my_output_attr.get(), 55)
self.assertEqual(my_internal_state.get(), 1)
my_input_attr.set(15)
for _ in range(4):
await og.Controller.evaluate(scene.graph)
self.assertEqual(my_output_attr.get(), 610)
self.assertEqual(my_internal_state.get(), 2)
my_input_attr.set(10)
for _ in range(4):
await og.Controller.evaluate(scene.graph)
self.assertEqual(my_output_attr.get(), 55)
self.assertEqual(my_internal_state.get(), 3)
async def test_lazy_foreach_graph_with_partition_pass(self):
"""Check that dirty_push evaluation graphs work correctly after
partition passes are run on said graphs (OM-93668)"""
scene = create_lazy_foreach_graph()
try:
# Enable the ForEach partition pass.
carb.settings.get_settings().set("/app/omni.graph.examples/enableForEachPass", True)
# Get some necessary node attributes for the test.
const_int_node_0 = scene.nodes[0]
in_value_attr = const_int_node_0.get_attribute("inputs:value")
make_array_node = scene.nodes[3]
in_inputsa_attr = make_array_node.get_attribute("inputs:a")
counter_node = scene.nodes[5]
out_count_attr = counter_node.get_attribute("outputs:count")
# If nothing changes in the graph, no nodes should be evaluated after
# the initial computation (i.e. immediately after creating the graph)
# => the counter node's output value should be one. Prior to OM-93668
# being addressed the counter node would instead get ticked/incremented
# each compute., so out_count_attr.get() would equal 3.
await og.Controller.evaluate(scene.graph)
await og.Controller.evaluate(scene.graph)
await og.Controller.evaluate(scene.graph)
self.assertEqual(out_count_attr.get(), 1)
# The counter node should only be triggered to evaluate when downstream
# changes are made. Prior to OM-93668 the counter node would instead get
# ticked/incremented each compute, so out_count_attr.get() would equal 6.
og.Controller.disconnect(in_value_attr, in_inputsa_attr)
await og.Controller.evaluate(scene.graph)
await og.Controller.evaluate(scene.graph)
await og.Controller.evaluate(scene.graph)
self.assertEqual(out_count_attr.get(), 2)
finally:
# Disable the ForEach partition pass.
carb.settings.get_settings().set("/app/omni.graph.examples/enableForEachPass", False)
| 12,050 | Python | 46.444882 | 112 | 0.580166 |
omniverse-code/kit/exts/omni.graph.examples.cpp/omni/graph/examples/cpp/tests/test_api.py | """Testing the stability of the API in this module"""
import omni.graph.core.tests as ogts
import omni.graph.examples.cpp as ogec
from omni.graph.tools.tests.internal_utils import _check_module_api_consistency, _check_public_api_contents
# ======================================================================
class _TestOmniGraphExamplesCppApi(ogts.OmniGraphTestCase):
_UNPUBLISHED = ["bindings", "ogn", "tests"]
async def test_api(self):
_check_module_api_consistency(ogec, self._UNPUBLISHED) # noqa: PLW0212
_check_module_api_consistency(ogec.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(ogec, [], self._UNPUBLISHED, only_expected_allowed=True) # noqa: PLW0212
_check_public_api_contents(ogec.tests, [], [], only_expected_allowed=True) # noqa: PLW0212
| 941 | Python | 48.578945 | 108 | 0.658874 |
omniverse-code/kit/exts/omni.graph.examples.cpp/docs/CHANGELOG.md | # Changelog
All notable changes to this project will be documented in this file.
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
## [Unreleased]
## [1.4.2] - 2022-12-19
### Fixed
- Avoid null pointer dereferences in compute for various nodes
## [1.4.1] - 2022-08-09
### Fixed
- Applied formatting to all of the Python files
## [1.4.0] - 2022-07-07
### Added
- Test for public API consistency
## [1.3.0] - 2022-06-28
### Changed
- Modified the Python code to create a more definitive API surface
## [1.2.0] - 2022-06-23
### Changed
- Modified the Python code to create a more definitive API surface
## [1.1.0] - 2022-04-29
### Removed
- Obsolete settings test
## [1.0.1] - 2022-03-14
### Changed
- Added categories to node OGN
## [1.0.0] - 2021-03-01
### Initial Version
- Started changelog with initial released version of the OmniGraph core
| 974 | Markdown | 22.780487 | 87 | 0.693018 |
omniverse-code/kit/exts/omni.graph.examples.cpp/docs/README.md | # OmniGraph C++ Examples [omni.graph.examples.cpp]
This extension contains example implementations for OmniGraph nodes written in C++.
| 136 | Markdown | 33.249992 | 83 | 0.794118 |
omniverse-code/kit/exts/omni.graph.examples.cpp/docs/index.rst | .. _ogn_omni_graph_examples_cpp:
OmniGraph C++ Example Nodes
###########################
.. tabularcolumns:: |L|R|
.. csv-table::
:width: 100%
**Extension**: omni.graph.examples.cpp,**Documentation Generated**: |today|
.. toctree::
:maxdepth: 1
CHANGELOG
This is a miscellaneous collection of examples that exercise some of the functionality of the OmniGraph.
Unlike the set of nodes implementing common features found in :ref:`ogn_omni_graph_nodes`
the nodes here do not serve a common purpose, they are just used to illustrate the use of certain features of
the OmniGraph.
For examples of nodes implemented in Python see the extension :ref:`ogn_omni_graph_examples_python`.
For more comprehensive examples targeted at explaining the use of OmniGraph node features in detail see
:ref:`ogn_user_guide`.
| 826 | reStructuredText | 27.51724 | 109 | 0.728814 |
omniverse-code/kit/exts/omni.graph.examples.cpp/docs/Overview.md | # OmniGraph C++ Example Nodes
```{csv-table}
**Extension**: omni.graph.examples.cpp,**Documentation Generated**: {sub-ref}`today`
```
This is a miscellaneous collection of examples that exercise some of the functionality of the OmniGraph.
Unlike the set of nodes implementing common features found in {ref}`ogn_omni_graph_nodes`
the nodes here do not serve a common purpose, they are just used to illustrate the use of certain features of
the OmniGraph.
For examples of nodes implemented in Python see the extension {ref}`ogn_omni_graph_examples_python`.
For more comprehensive examples targeted at explaining the use of OmniGraph node features in detail see
{ref}`ogn_user_guide`. | 685 | Markdown | 44.73333 | 109 | 0.782482 |
omniverse-code/kit/exts/omni.hydra.pxr.settings/config/extension.toml | [package]
# Semantic Versioning is used: https://semver.org/
version = "1.0.3"
# 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 = "External Hydra Delegate Renderer Settings"
description="Settings to an external Hydra delegate"
# 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 = "Rendering"
# Keywords for the extension
keywords = ["kit", "hydra", "rendering", "external"]
# 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/hydra-icon.png"
# this need to be activated with iray on starup
toggleable = false
[dependencies]
"omni.ui" = {}
"omni.rtx.window.settings" = {}
"omni.hydra.pxr" = {}
# Main python module this extension provides, it will be publicly available as "import omni.example.hello".
[[python.module]]
name = "omni.hydra.pxr.settings"
[[test]]
args = [
"--/renderer/enabled=pxr",
"--/renderer/active=pxr",
"--/renderer/multiGpu/enabled=false",
"--/renderer/multiGpu/autoEnable=false", # Disable mGPU with PXR due to OM-51026, OM-53611
"--/renderer/multiGpu/maxGpuCount=1",
"--/app/asyncRendering=false",
"--/pxr/rendermode=HdStormRendererPlugin",
"--/app/window/dpiScaleOverride=1.0",
"--/app/window/scaleToMonitor=false",
"--/app/window/width=640",
"--/app/window/height=500",
"--no-window",
]
dependencies = [
"omni.ui", # For omni.ui.tests
"omni.kit.renderer.capture",
"omni.kit.viewport.utility", # To hide the default Viewport
"omni.kit.window.viewport", # Currently needed to load native C++ settings
]
stdoutFailPatterns.exclude = [
"*HydraRenderer failed to render this frame*", # Can drop a frame or two rendering with OpenGL interop
]
| 2,483 | TOML | 33.985915 | 118 | 0.717277 |
omniverse-code/kit/exts/omni.hydra.pxr.settings/omni/hydra/pxr/settings/extension.py | import omni.ext
import omni.kit.app
import carb.settings
from omni.rtx.window.settings import RendererSettingsFactory
from .widgets.common_widgets import CommonPxrHydraSettingStack, PxrHydraRendererSettingStack
kLoadedDelegatesSettingsPath = '/pxr/renderers'
kActiveDelegatesSettingsPath = '/pxr/rendermode'
kActiveHydraEnginePath = '/renderer/active'
kSavedDelegatesSettingsPath = '/persistent/app/hydra/delegates'
kDelegateSettingsKey = 'settings'
class HdSettingsDesc(object):
def __init__(self, *args):
self.plugin_id, self.display_name, self.settings_key = args
def _build_settings(settings, instatiator):
instances = []
delegates = settings.get(kLoadedDelegatesSettingsPath)
delegates = [names.split(':') for names in delegates.split('|')] if delegates else []
# for plugin_name, config_dict in settings.get(kAllDelegatesSettingsPath).items():
for plugin_name, display_name in delegates:
if display_name == 'GL':
display_name = 'Storm'
settings_key = kSavedDelegatesSettingsPath + '/' + plugin_name + '/' + kDelegateSettingsKey
instance = instatiator(HdSettingsDesc(plugin_name, display_name, settings_key))
if instance:
instances.append(instance)
return instances
class PxrHydraSettingsExtension(omni.ext.IExt):
"""The entry point for External Delegate Settings Window"""
def __renderersUpdated(self, loaded_delegates_value, event_type):
if event_type != carb.settings.ChangeEventType.CHANGED:
return
# Delay all creation until omni.hydra.pxr is ctive and using a loaded delegate
settings = carb.settings.get_settings()
if settings.get(kActiveHydraEnginePath) != 'pxr':
return
active_plugin = settings.get(kActiveDelegatesSettingsPath)
if not active_plugin:
return
def buildRendererSettings(desc):
plugin_id = desc.plugin_id
# Check if an extension has already registered a Render Settings widget for this renderer.
rs = RendererSettingsFactory._get_render_settings_extension()
if rs and plugin_id in rs._settings_window.get_registered_renderers():
return
if active_plugin == plugin_id and not plugin_id in self.__hdsettings:
RendererSettingsFactory.register_renderer(desc.plugin_id, ['Global', desc.display_name])
RendererSettingsFactory.register_stack('Global',
lambda desc = desc: CommonPxrHydraSettingStack())
RendererSettingsFactory.register_stack(desc.display_name,
lambda desc = desc: PxrHydraRendererSettingStack(desc))
return desc
added = _build_settings(settings, buildRendererSettings)
for desc in added:
self.__hdsettings.append(desc.plugin_id)
def on_startup(self):
self.__hdsettings = []
# XXX: Need a better and more common way to watch for renderer-changes
self.__hd_renderers_changed = (
omni.kit.app.SettingChangeSubscription(kLoadedDelegatesSettingsPath, self.__renderersUpdated),
omni.kit.app.SettingChangeSubscription(kActiveHydraEnginePath, self.__renderersUpdated),
omni.kit.app.SettingChangeSubscription(kActiveDelegatesSettingsPath, self.__renderersUpdated)
)
def on_shutdown(self):
descs = self.__hdsettings
self.__hdsettings = None
self.__hd_renderers_changed = None
for plugin_id in descs:
RendererSettingsFactory.unregister_renderer(plugin_id)
RendererSettingsFactory.unregister_stack(plugin_id)
RendererSettingsFactory.build_ui()
| 3,723 | Python | 42.302325 | 106 | 0.684394 |
omniverse-code/kit/exts/omni.hydra.pxr.settings/omni/hydra/pxr/settings/__init__.py | from .extension import *
# Expose our own RendererSettingsFactory instead of having users use the RTX version directly.
# We'll just call into the RTX-RendererSettingsFactory for now, but add a few methods to add and
# remove the renderer from the Viewport's available list.
from omni.rtx.window.settings import RendererSettingsFactory as RTXRendererSettingsFactory
from typing import List
import carb
class RendererSettingsFactory(RTXRendererSettingsFactory):
@staticmethod
def register_renderer(plugin_id: str, stacks_list: List[str], display_name: str):
"""Register a list of stacks for visibility in the RenderSettings Widget.
This will also let the renderer be available in the Viewport renderer drop-down.
"""
RTXRendererSettingsFactory.register_renderer(plugin_id, stacks_list)
RendererSettingsFactory.enable_viewport_renderer(plugin_id, display_name)
@staticmethod
def unregister_renderer(plugin_id: str):
"""De-register a renderer in the RenderSettings Widget.
This will also remove the renderer from the Viewport renderer drop-down.
"""
RTXRendererSettingsFactory.unregister_renderer(plugin_id)
RendererSettingsFactory.disable_viewport_renderer(plugin_id)
__g_renderers = {}
@staticmethod
def enable_viewport_renderer(plugin_id: str, display_name: str):
# Subject to change, but currently this is needed for Viewport-1's render-menu
RendererSettingsFactory.__g_renderers[plugin_id] = display_name
settings = carb.settings.get_settings()
renderers = settings.get('/pxr/renderers')
cur_key = f'{plugin_id}:{display_name}'
if not renderers or renderers.find(cur_key) == -1:
renderers = (renderers + '|') if renderers else ''
settings.set('/pxr/renderers', renderers + cur_key)
@staticmethod
def disable_viewport_renderer(plugin_id: str):
cur_key = f'{plugin_id}:{RendererSettingsFactory.__g_renderers[plugin_id]}'
del RendererSettingsFactory.__g_renderers[plugin_id]
# Again, subject to change, but remove ourself from the Viewport-1 menu
# We don't know where we were inserted so just be careful and remove any empty spots we may create
settings = carb.settings.get_settings()
renderers = settings.get('/pxr/renderers')
if not renderers:
return
renderers = renderers.replace(cur_key, '').replace('||', '')
if renderers.startswith('|'):
renderers = renderers[1:]
if renderers.endswith('|'):
renderers = renderers[0:-1]
settings.set('/pxr/renderers', renderers)
| 2,688 | Python | 45.362068 | 106 | 0.69122 |
omniverse-code/kit/exts/omni.hydra.pxr.settings/omni/hydra/pxr/settings/widgets/common_widgets.py | import omni.ui as ui
import carb
from omni.rtx.window.settings.rtx_settings_stack import RTXSettingsStack
from omni.rtx.window.settings.settings_collection_frame import SettingsCollectionFrame
from omni.kit.widget.settings import SettingType
class CarbDictSettingsFrame(SettingsCollectionFrame):
def __value_to_type(self, value):
if isinstance(value, bool):
return SettingType.BOOL
if isinstance(value, int):
return SettingType.INT
if isinstance(value, float):
return SettingType.FLOAT
if isinstance(value, str):
return SettingType.STRING
if isinstance(value, carb.ColorRgb):
return SettingType.COLOR3
if isinstance(value, carb.Double3):
return SettingType.DOUBLE3
if isinstance(value, carb.Double2):
return SettingType.DOUBLE2
if isinstance(value, carb.Int2):
return SettingType.INT2
def __init__(self, desc, *args, **kwargs):
super().__init__(desc.display_name, *args, **kwargs)
self._settings_key = desc.settings_key
self._plugin_id = desc.plugin_id
def _add_common_settings(self):
# Add the renderer-specific light adjustment
self._add_setting(SettingType.FLOAT, name='Renderer Lighting Factor',
path=f'/persistent/app/hydra/delegates/{self._plugin_id}/omniLightAdjustment',
tooltip='Renderer specific amount to scale lighting by.')
def _add_setting_dictionary(self, setting_dict: dict, root_key: str, sub_dicts: dict):
for name, setting in setting_dict.items():
value = setting.get('value', None)
if value is None:
if isinstance(setting, dict):
sub_dicts[f'{root_key}/{name}'] = setting
continue
setting_type = self.__value_to_type(value)
if setting_type is not None:
value_key = f'{root_key}/{name}/value'
self._add_setting(setting_type, name=setting.get('name', name), path=value_key, tooltip=setting.get('tooltip', ''))
def _build_ui(self):
# Add all the common renderer specific settings
self._add_common_settings()
settings = carb.settings.get_settings().get(self._settings_key)
if settings:
# Collect all namespaced entries, and do them last
namespaced = {}
# Start with the root item
self._add_setting_dictionary(settings, self._settings_key, namespaced)
# Error/Exit if over 100 nested dictionaries / namespaces to avoid infinite loop
ns_counter = 100
while namespaced:
# Swap to a local_dict and re-write into namespaced
local_dict, namespaced = namespaced, {}
for root_key, root_dict in local_dict.items():
self._add_setting_dictionary(root_dict, root_key, namespaced)
ns_counter = ns_counter - 1
if ns_counter <= 0:
carb.log_error('Exiting CarbDictSettingsFrame because of unexpectedly large number of dicitonaries')
break
class PxrHydraRendererSettingStack(RTXSettingsStack):
def __init__(self, desc, *args, **kwargs) -> None:
super().__init__(*args, **kwargs)
# _self._stack is required for RTXSettingsStack
self._stack = ui.VStack(spacing=10)
with self._stack:
CarbDictSettingsFrame(desc, parent=self)
ui.Spacer()
class GlobalSettingsFrame(SettingsCollectionFrame):
def _build_ui(self):
# Add the global light adjustment setting
self._add_setting(SettingType.FLOAT, name='Global Lighting Factor',
path=f'/persistent/app/hydra/delegates/common/omniGlobalLightAdjustment',
tooltip='Global amount to scale lighting by.')
class CommonPxrHydraSettingStack(RTXSettingsStack):
def __init__(self, *args, **kwargs) -> None:
super().__init__(*args, **kwargs)
# _self._stack is required for RTXSettingsStack
self._stack = ui.VStack(spacing=10)
with self._stack:
GlobalSettingsFrame('Global', parent=self)
ui.Spacer()
| 4,296 | Python | 41.544554 | 131 | 0.615456 |
omniverse-code/kit/exts/omni.hydra.pxr.settings/omni/hydra/pxr/settings/tests/test_ui.py | import omni.kit.test
import omni.kit.app
from omni.hydra.pxr.settings import RendererSettingsFactory
from omni.kit.viewport.utility import get_active_viewport_window
from omni.hydra.pxr.settings.widgets.common_widgets import CommonPxrHydraSettingStack, PxrHydraRendererSettingStack
from omni.hydra.pxr.settings.extension import HdSettingsDesc, kSavedDelegatesSettingsPath, kDelegateSettingsKey
from omni.rtx.window.settings.tests.test_ui import TestSetRenderSettings
from omni.rtx.window.settings import RendererSettingsFactory as RTXRendererSettingsFactory
from omni.rtx.window.settings.rtx_settings_stack import RTXSettingsStack
from omni.rtx.window.settings.settings_collection_frame import FrameSessionState
from omni.ui.tests.test_base import OmniUiTest
from pathlib import Path
import carb
import omni.ui
DATA_PATH = Path(carb.tokens.get_tokens_interface().resolve("${omni.hydra.pxr.settings}/data")).absolute().resolve()
GOLDEN_IMAGE_DIR = DATA_PATH.joinpath("tests").absolute().resolve()
class TestPXRCommandsDefaults(TestSetRenderSettings, OmniUiTest):
async def setUp(self):
# Load the scene
# This currently needs to happen as omni.hydra.pxr settings are only known at runtime,
# once the renderer is loaded, and it will only be loaded when a stage is attached.
scene_path = str(DATA_PATH.joinpath("tests", "cube.usda"))
await omni.usd.get_context().open_stage_async(scene_path)
await omni.kit.app.get_app().next_update_async()
async def test_pxr_settings_ui(self):
# Clear this out, so both legacy and viewport-next start at the same place
carb.settings.get_settings().set('/pxr/renderers', '')
# Enable Storm for some tests in run_test_render_settings_ui
RendererSettingsFactory.enable_viewport_renderer('HdStormRendererPlugin', 'Storm')
# Make sure the renderer was registered in the UI stack
renderers = RendererSettingsFactory.get_registered_renderers()
self.assertNotEqual(len(renderers), 0)
# Run the base-line render-settings window ui tests on the known settings path
await self.run_test_render_settings_ui("/persistent/app/hydra/delegates/HdStormRendererPlugin/settings")
RendererSettingsFactory.disable_viewport_renderer('HdStormRendererPlugin')
async def test_hd_storm_unload(self):
# Simulate a load and make sure it appears in the renderer-list
RendererSettingsFactory.enable_viewport_renderer('HdStormRendererPlugin', 'Storm')
self.assertNotEqual(carb.settings.get_settings().get("/pxr/renderers").find("HdStormRendererPlugin:Storm"), -1)
# Simulate an unload and make sure it no longer appears in the renderer-list
RendererSettingsFactory.disable_viewport_renderer('HdStormRendererPlugin')
self.assertEqual(carb.settings.get_settings().get("/pxr/renderers").find("HdStormRendererPlugin:Storm"), -1)
async def test_carb_dict_to_settings(self):
WIDTH, HEIGHT = 640, 500
await self.create_test_area(width=WIDTH, height=HEIGHT)
# Build a fake plugin to test
test_plugin_id = 'HdRenderPluginDictTest'
# This is where settings are stored
settings_key = f'{kSavedDelegatesSettingsPath}/{test_plugin_id}/{kDelegateSettingsKey}'
# Simple object that is used to pass to build settings
test_plugin_desc = HdSettingsDesc(test_plugin_id, 'DictTest', settings_key)
# Generate a few settings, importantly to test nested-dictionary -> USD namespace conversion
settings_dict = {
'namespace1': {
'setting1': {
'name': 'namespace1_LABEL',
'value': 'namespace1_VALUE'
},
'namespace2': {
'setting2': {
'name': 'namespace2_LABEL',
'value': True
},
'namespace3': {
'setting3': {
'name': 'namespace3_LABEL',
'value': 3.0
}
}
}
}
}
# Set the defaults
settings = carb.settings.get_settings()
settings.set(settings_key, settings_dict)
# Setup a default state that won't cause issues with test
# Expand the the render-settings for capture
FrameSessionState.set_state('omni.hydra.pxr.settings.widgets.common_widgets.CarbDictSettingsFrame', 'collapsed', False)
# omni.ui conversion error if the value is initially None
settings.set(f'/persistent/app/hydra/delegates/{test_plugin_id}/omniLightAdjustment', 1.0)
# XXX: RendererSettings needs this to be set properly for Viewport-2 case, but not Viewport-1
class ActiveRendererRIIA:
def __init__(self):
carb.settings.get_settings().set('/pxr/rendermode', 'HdRenderPluginDictTest')
def __del__(self):
carb.settings.get_settings().set('/pxr/rendermode', 'HdStormRendererPlugin')
active_raii = ActiveRendererRIIA()
# Register all the settings stacks
RTXRendererSettingsFactory.register_renderer(test_plugin_id, ['Global', test_plugin_desc.display_name])
RTXRendererSettingsFactory.register_stack('Global', lambda *args: CommonPxrHydraSettingStack())
RTXRendererSettingsFactory.register_stack(test_plugin_desc.display_name, lambda *args: PxrHydraRendererSettingStack(test_plugin_desc))
RTXRendererSettingsFactory.set_current_stack(test_plugin_desc.display_name)
# Get a reference to the window and resize it
window = omni.ui.Window(title='Render Settings')
window.width = WIDTH
window.height = HEIGHT
# Hide the Viewport window from the screen-shot
# We're currently dependent on it to load omni.hydra.pxr and Storm's runtime settings
viewport_window = get_active_viewport_window()
if viewport_window:
viewport_window.visible = False
for i in range(3):
await omni.kit.app.get_app().next_update_async()
# Unegister everything
RTXRendererSettingsFactory.unregister_renderer(test_plugin_id)
RTXRendererSettingsFactory.unregister_stack(test_plugin_id)
await self.finalize_test(golden_img_dir=GOLDEN_IMAGE_DIR, golden_img_name='test_carb_dict_to_settings.png')
| 6,470 | Python | 48.776923 | 142 | 0.677743 |
omniverse-code/kit/exts/omni.hydra.pxr.settings/docs/CHANGELOG.md | # CHANGELOG
This document records all notable changes to ``omni.hydra.pxr.settings`` extension.
This project adheres to `Semantic Versioning <https://semver.org/>`.
## [1.0.3] 2022-06-02
### Changed
- Hide Viewport durring test suite capture and update golden-image.
## [1.0.2] 2022-03-09
### Changed
- Mitigate lack of OpenGL interop TC failures.
### Fixed
- Fix building of namespaced render-settings more than one level deep.
## [1.0.1] 2022-02-16
### Added
- Tests
## [1.0.0] 2021-09-05
### Added
- Initial Release
| 524 | Markdown | 21.826086 | 83 | 0.704198 |
omniverse-code/kit/exts/omni.kit.extpath.git/omni/kit/extpath/git/extpath_git.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.
#
import os
import sys
import base64
import hashlib
from urllib.parse import urlparse, parse_qs, urljoin, urlunsplit
from enum import Enum
from typing import Tuple, List
from urllib import parse
import carb.dictionary
import carb.tokens
import carb.settings
import omni.kit.app
import omni.ext
from .utils import _info, _error, _print, _get_setting
def short_hash(name: str, length: int = 10) -> str:
hasher = hashlib.sha1(name.encode("utf-8"))
return base64.urlsafe_b64encode(hasher.digest()[:length]).decode("ascii").rstrip("=")
def _try_post_notification(message):
try:
import omni.kit.notification_manager
omni.kit.notification_manager.post_notification(message)
return True
except:
pass
return False
def _call_git(args, cwd=None):
import subprocess
cmd = ["git"] + args
_info("run process: {}".format(cmd))
try:
res = subprocess.run(cmd, cwd=cwd)
if res.returncode != 0:
_error(f"error running process: {cmd}. Result: {res}. Stderr: {res.stderr}")
return False
return True
except FileNotFoundError:
_error("Failed calling git. 'omni.kit.extpath.git' extension requires git installed and available.")
_try_post_notification("Can't find git. Please install it to use git scheme for extension search path.")
return False
except PermissionError:
_error("No permission execute git. 'omni.kit.extpath.git' extension requires git installed and available.")
return False
def _remove_prefix(text, prefix):
return text[text.startswith(prefix) and len(prefix) :]
class ExtPath:
def __init__(self, url, cache_path):
self.local_path = ""
self.path_sh = short_hash(url)
parsed = urlparse(url)
q = parse_qs(parsed.query)
self.branch = q.get("branch", [""])[0]
self.tag = q.get("tag", [""])[0]
self.sha = q.get("sha", [""])[0]
self.dir = q.get("dir", [""])[0]
scheme = parsed.scheme
if scheme == "git":
scheme = "git+https"
scheme = _remove_prefix(scheme, "git+")
self.url = urlunsplit([scheme, parsed.netloc, parsed.path, "", ""])
self.dest = f"{cache_path}/{self.path_sh}"
self.rev = self.sha
if not self.rev:
self.rev = "origin/" + (self.branch or self.tag or "master")
if not os.path.exists(self.dest):
_call_git(["clone", "-q", self.url, self.dest])
_call_git(["checkout", "-q", self.rev], cwd=self.dest)
self._update_submodules()
self.local_path = os.path.join(self.dest, self.dir)
_info(f"local_path: {self.local_path} for url: {url} is ready to use")
def update(self):
if self.sha:
return
_print(f"updating git path: {self.url}. rev: {self.rev} into '{self.dest}'...")
_call_git(["fetch", "-q"], cwd=self.dest)
_call_git(["reset", "--hard", "-q", self.rev], cwd=self.dest)
self._update_submodules()
def _update_submodules(self):
if not os.path.exists(os.path.join(self.dest, ".gitmodules")):
return
_call_git(["submodule", "update", "--init", "--recursive", "-q"], cwd=self.dest)
SCHEMES = ["git", "git+https", "git+http", "git+ssh"]
_git_paths = {}
_cache_path = ""
def update_git_path(path: str):
"""Update checked out git repo branch/tag to latest (git pull) for specified extension path."""
if path in _git_paths:
_git_paths[path].update()
def update_all_git_paths():
"""Update checked out git repo branch/tag to latest (git pull) for all extension paths."""
for p in _git_paths.values():
p.update()
def get_local_path(path: str):
if path in _git_paths:
return _git_paths[path].local_path
return None
def is_git_path(path: str):
return path in _git_paths
def get_cache_path() -> str:
return _cache_path
class ExtPathGitExt(omni.ext.IExt):
def on_startup(self):
self._ext_manager = omni.kit.app.get_app().get_extension_manager()
if not _call_git(["--version"]):
return
global _cache_path
_cache_path = _get_setting("/exts/omni.kit.extpath.git/cachePath", None)
_cache_path = carb.tokens.get_tokens_interface().resolve(_cache_path)
self._update = _get_setting("/exts/omni.kit.extpath.git/autoUpdate", False)
for scheme in SCHEMES:
self._ext_manager.add_path_protocol_provider(scheme, self._on_add_path, self._on_remove_path)
def _on_add_path(self, path):
_info(f"ExtPathGitExt::_on_add_path: {path}")
p = ExtPath(path, cache_path=_cache_path)
if self._update:
p.update()
global _git_paths
_git_paths[path] = p
return p.local_path
def _on_remove_path(self, path):
_info(f"ExtPathGitExt::_on_remove_path: {path}")
_git_paths.pop(path, None)
def on_shutdown(self):
for scheme in SCHEMES:
self._ext_manager.remove_path_protocol_provider(scheme)
global _git_paths
_git_paths.clear()
| 5,582 | Python | 29.845304 | 115 | 0.621641 |
omniverse-code/kit/exts/omni.kit.extpath.git/omni/kit/extpath/git/__init__.py | from .extpath_git import *
| 27 | Python | 12.999994 | 26 | 0.740741 |
omniverse-code/kit/exts/omni.kit.extpath.git/omni/kit/extpath/git/utils.py | import os
import carb
import carb.settings
def _get_setting(path, default=None):
setting = carb.settings.get_settings().get(path)
return setting if setting is not None else default
def _to_log_str(s: str) -> str:
return f"[omni.kit.extpath.git]: {s}"
# print() instead of carb.log_info when this env var is set:
_debug_print = bool(os.getenv("OMNI_KIT_EXTPATH_GIT_DEBUG", default=False))
def _info(s):
s = _to_log_str(s)
carb.log_info(s)
if _debug_print:
print(s)
def _print(s):
s = _to_log_str(s)
carb.log_info(s)
print(_to_log_str(s))
def _error(s):
carb.log_error(_to_log_str(s))
def _warn(s):
carb.log_warn(_to_log_str(s))
| 693 | Python | 17.263157 | 75 | 0.630592 |
omniverse-code/kit/exts/omni.kit.extpath.git/omni/kit/extpath/git/tests/__init__.py | from .test_extpath_git import TestExtPathGit | 44 | Python | 43.999956 | 44 | 0.863636 |
omniverse-code/kit/exts/omni.kit.extpath.git/omni/kit/extpath/git/tests/test_extpath_git.py | import os
import omni.kit.test
import omni.kit.extpath.git
import omni.kit.app
import unittest
ENABLE_TESTS_ENV = "OMNI_KIT_ENABLE_ONLINE_TESTS"
ENABLE_TESTS = bool(os.getenv(ENABLE_TESTS_ENV))
from unittest import mock
class TestExtPathGit(omni.kit.test.AsyncTestCase):
@unittest.skipUnless(ENABLE_TESTS, f"Skip online tests, set {ENABLE_TESTS_ENV} env to enable.")
async def test_git(self):
manager = omni.kit.app.get_app_interface().get_extension_manager()
URL = "git+https://gitlab-master.nvidia.com/anovoselov/test-git-extensions.git?dir=exts&branch=main"
manager.add_path(URL)
self.assertTrue(omni.kit.extpath.git.get_local_path(URL))
await omni.kit.app.get_app().next_update_async()
all_exts = {ext["id"] for ext in manager.get_extensions()}
self.assertIn("omni.foo-0.3.55", all_exts)
async def test_git_with_mock(self):
manager = omni.kit.app.get_app_interface().get_extension_manager()
with mock.patch("omni.kit.extpath.git.extpath_git._call_git", return_value=True):
url1 = "git+https://some_1.git?dir=exts&branch=main"
manager.add_path(url1)
self.assertIsNotNone(omni.kit.extpath.git.get_local_path(url1))
| 1,248 | Python | 33.694444 | 108 | 0.685897 |
omniverse-code/kit/exts/omni.kit.extpath.git/docs/index.rst | omni.kit.extpath.git
###########################
Git Url as Extension Search Path Support.
Settings
***********
Refer to ``extension.toml`` file for settings.
| 164 | reStructuredText | 12.749999 | 46 | 0.573171 |
omniverse-code/kit/exts/omni.kit.menu.edit/omni/kit/menu/edit/scripts/edit.py | import os
import asyncio
import carb.input
import omni.ext
import omni.usd
import omni.ui as ui
import omni.kit.app
import omni.kit.menu.utils
import omni.kit.notification_manager as nm
import omni.kit.usd.layers as layers
from functools import partial
from omni.kit.menu.utils import MenuItemDescription
from .selection import Selection
from .selection_window import SelectionSetWindow
from .edit_actions import register_actions, deregister_actions
from pxr import Sdf, Usd, Kind, Tf
_extension_instance = None
_extension_path = None
PERSISTENT_SETTINGS_PREFIX = "/persistent"
KEEP_TRANSFORM_FOR_REPARENTING = "/persistent/app/stage/movePrimInPlace"
class EditMenuExtension(omni.ext.IExt):
def __init__(self):
super().__init__()
omni.kit.menu.utils.set_default_menu_proirity("Edit", -9)
self._select_recent_menu_list = [ MenuItemDescription(name="None", enabled=False) ]
self._selection_set_menu_list = [ MenuItemDescription(name="None", enabled=False) ]
self._selection_kind_menu_list = [ MenuItemDescription(name="None", enabled=False) ]
self._select_recent = []
self._selection_set = []
def on_startup(self, ext_id):
global _extension_instance
_extension_instance = self
global _extension_path
_extension_path = omni.kit.app.get_app_interface().get_extension_manager().get_extension_path(ext_id)
self._ext_name = omni.ext.get_extension_name(ext_id)
register_actions(self._ext_name, EditMenuExtension, lambda: _extension_instance)
self._select_recent_menu_list = [ MenuItemDescription(name="None", enabled=False) ]
self._selection_set_menu_list = [ MenuItemDescription(name="None", enabled=False) ]
self._selection_kind_menu_list = [ MenuItemDescription(name="None", enabled=False) ]
self._select_recent = []
self._selection_set = []
self._create_selection_window = None
self._edit_menu_list = None
self._build_edit_menu()
# self._stage_event_sub = omni.usd.get_context().get_stage_event_stream().create_subscription_to_pop(self._on_stage_event, name="omni.usd.menu.edit")
self._context_menus = []
manager = omni.kit.app.get_app().get_extension_manager()
self._cm_hooks = manager.subscribe_to_extension_enable(
lambda _: self._register_context_menu(),
lambda _: self._unregister_context_menu(),
ext_name="omni.kit.context_menu",
hook_name="menu edit listener",
)
def on_shutdown(self):
global _extension_instance
global _template_list
deregister_actions(self._ext_name)
self._unregister_context_menu()
self._cm_hooks = None
_extension_instance = None
_template_list = None
# self._stage_event_sub = None
self._select_recent_menu_list = []
self._selection_set_menu_list = []
self._selection_kind_menu_list = []
self._select_recent = []
self._selection_set = []
if self._create_selection_window:
self._create_selection_window.shutdown()
del self._create_selection_window
omni.kit.menu.utils.remove_menu_items(self._edit_menu_list, "Edit")
def post_notification(message: str, info: bool = False, duration: int = 3):
if info:
type = nm.NotificationStatus.INFO
else:
type = nm.NotificationStatus.WARNING
nm.post_notification(message, status=type, duration=duration)
def _usd_kinds(self):
return ["model", "assembly", "group", "component", "subcomponent"]
def _usd_kinds_display(self):
return self._usd_kinds()[1:]
def _plugin_kinds(self):
all_kinds = set(Kind.Registry.GetAllKinds())
return all_kinds - set(self._usd_kinds())
def _create_selection_set(self):
paths = omni.usd.get_context().get_selection().get_selected_prim_paths()
if not paths:
EditMenuExtension.post_notification("Cannot Create Selection Set as no prims are selected")
return
if self._create_selection_window:
self._create_selection_window.show()
else:
self._create_selection_window = SelectionSetWindow(self._add_to_selection_set)
def _build_recent_menu(self):
if self._select_recent:
self._select_recent_menu_list.clear()
self._select_recent.sort(reverse=True, key=lambda x: x.time)
del self._select_recent[5:]
for recent in self._select_recent:
index = self._select_recent.index(recent)
self._select_recent_menu_list.append(
MenuItemDescription(
name=recent.description, onclick_action=("omni.kit.menu.edit", "select_recent", index)
)
)
omni.kit.menu.utils.rebuild_menus()
def _on_select_recent(self, index):
async def select_func():
await omni.kit.app.get_app().next_update_async()
do_recent = self._select_recent[index]
omni.kit.commands.execute("SelectListCommand", selection=do_recent.selection)
do_recent.touch()
self._build_recent_menu()
asyncio.ensure_future(select_func())
def _add_to_selection_set(self, description):
new_selection = omni.usd.get_context().get_selection().get_selected_prim_paths()
for selection in self._selection_set:
if selection.description == description:
EditMenuExtension.post_notification(f"Selection set \"{description}\" already exists")
return
self._selection_set.append(Selection(description, new_selection))
self._build_selection_set_menu()
def _add_to_recent(self, description, selection):
found = False
for prev_selection in self._select_recent:
if prev_selection.description == description and prev_selection.selection == selection:
prev_selection.touch()
found = True
break
if not found:
self._select_recent.append(Selection(description, selection))
self._build_recent_menu()
def _on_select_selection_set(self, index):
async def select_func():
await omni.kit.app.get_app().next_update_async()
do_select = self._selection_set[index]
omni.kit.commands.execute("SelectListCommand", selection=do_select.selection)
asyncio.ensure_future(select_func())
def _build_selection_set_menu(self):
self._selection_set_menu_list.clear()
self._selection_set.sort(key=lambda x: x.description)
for recent in self._selection_set:
index=self._selection_set.index(recent)
self._selection_set_menu_list.append(MenuItemDescription(name=recent.description, onclick_action=("omni.kit.menu.edit", "select_selection_set", index)))
omni.kit.menu.utils.rebuild_menus()
def _on_select_by_kind(self, kind):
async def select_func():
await omni.kit.app.get_app().next_update_async()
omni.kit.commands.execute("SelectKindCommand", kind=kind)
asyncio.ensure_future(select_func())
def _build_selection_kind_menu(self):
self._selection_kind_menu_list.clear()
for kind in self._usd_kinds_display():
self._selection_kind_menu_list.append(MenuItemDescription(name=str(kind).capitalize(), onclick_action=("omni.kit.menu.edit", "select_by_kind", kind)))
for kind in self._plugin_kinds():
self._selection_kind_menu_list.append(MenuItemDescription(name=str(kind).capitalize(), onclick_action=("omni.kit.menu.edit", "select_by_kind", kind)))
def _build_edit_menu(self):
self._build_recent_menu()
self._build_selection_kind_menu()
# setup menus
self._edit_select_menu = [
MenuItemDescription(
name="Select Recent",
sub_menu=self._select_recent_menu_list
),
MenuItemDescription(
name="Select All",
onclick_action=("omni.kit.selection", "all"),
hotkey=(carb.input.KEYBOARD_MODIFIER_FLAG_CONTROL, carb.input.KeyboardInput.A),
),
MenuItemDescription(
name="Select None",
# enable_fn=EditMenuExtension.prim_selected,
onclick_action=("omni.kit.selection", "none"),
hotkey=(0, carb.input.KeyboardInput.ESCAPE),
),
MenuItemDescription(
name="Select Invert",
# enable_fn=EditMenuExtension.prim_selected,
onclick_action=("omni.kit.menu.edit", "selection_invert"),
hotkey=(carb.input.KEYBOARD_MODIFIER_FLAG_CONTROL, carb.input.KeyboardInput.I),
),
MenuItemDescription(
name="Select Parent",
# enable_fn=EditMenuExtension.prim_selected,
onclick_action=("omni.kit.menu.edit", "selection_parent"),
hotkey=(0, carb.input.KeyboardInput.UP),
),
MenuItemDescription(
name="Select Leaf",
# enable_fn=EditMenuExtension.prim_selected,
onclick_action=("omni.kit.menu.edit", "selection_leaf"),
),
MenuItemDescription(
name="Select Hierarchy",
onclick_action=("omni.kit.menu.edit", "selection_hierarchy"),
# enable_fn=EditMenuExtension.prim_selected,
),
MenuItemDescription(
name="Select Similar",
# enable_fn=EditMenuExtension.prim_selected,
onclick_action=("omni.kit.menu.edit", "selection_similar"),
),
MenuItemDescription(),
MenuItemDescription(
name="Create Selection Set",
# enable_fn=EditMenuExtension.prim_selected,
onclick_action=("omni.kit.menu.edit", "create_selection_set"),
),
MenuItemDescription(
name="Select Set",
sub_menu=self._selection_set_menu_list
),
MenuItemDescription(),
MenuItemDescription(
name="Select by Kind",
sub_menu=self._selection_kind_menu_list
)]
self._edit_menu_list = [
MenuItemDescription(
name="Undo",
glyph="none.svg",
onclick_action=("omni.kit.commands", "undo"),
hotkey=(carb.input.KEYBOARD_MODIFIER_FLAG_CONTROL, carb.input.KeyboardInput.Z),
),
MenuItemDescription(
name="Redo",
glyph="none.svg",
onclick_action=("omni.kit.commands", "redo"),
hotkey=(carb.input.KEYBOARD_MODIFIER_FLAG_CONTROL, carb.input.KeyboardInput.Y),
),
MenuItemDescription(
name="Repeat",
glyph="none.svg",
onclick_action=("omni.kit.commands", "repeat"),
hotkey=(carb.input.KEYBOARD_MODIFIER_FLAG_CONTROL, carb.input.KeyboardInput.R),
),
MenuItemDescription(
name="Select",
glyph="none.svg",
sub_menu=self._edit_select_menu
),
MenuItemDescription(),
MenuItemDescription(
name="Instance",
glyph="none.svg",
# enable_fn=[EditMenuExtension.prim_selected, EditMenuExtension.can_be_instanced],
onclick_action=("omni.kit.menu.edit", "instance_prim"),
hotkey=(
carb.input.KEYBOARD_MODIFIER_FLAG_CONTROL | carb.input.KEYBOARD_MODIFIER_FLAG_SHIFT,
carb.input.KeyboardInput.I,
),
),
MenuItemDescription(
name="Duplicate",
glyph="copy.svg",
# enable_fn=EditMenuExtension.prim_selected,
onclick_action=("omni.kit.menu.edit", "duplicate_prim"),
hotkey=(carb.input.KEYBOARD_MODIFIER_FLAG_CONTROL, carb.input.KeyboardInput.D),
),
MenuItemDescription(
name="Duplicate - All Layers",
glyph="copy.svg",
# enable_fn=[EditMenuExtension.prim_selected, EditMenuExtension.is_not_in_live_session],
onclick_action=("omni.kit.menu.edit", "duplicate_prim_and_layers"),
),
MenuItemDescription(
name="Duplicate - Collapsed",
glyph="copy.svg",
# enable_fn=EditMenuExtension.prim_selected,
onclick_action=("omni.kit.menu.edit", "duplicate_prim_and_combine_layers"),
),
MenuItemDescription(
name="Parent",
glyph="copy.svg",
# enable_fn=[EditMenuExtension.can_prims_parent, EditMenuExtension.is_not_in_live_session],
onclick_action=("omni.kit.menu.edit", "parent_prims"),
hotkey=(0, carb.input.KeyboardInput.P),
),
MenuItemDescription(
name="Unparent",
glyph="copy.svg",
# enable_fn=[EditMenuExtension.can_prims_unparent, EditMenuExtension.is_not_in_live_session],
onclick_action=("omni.kit.menu.edit", "unparent_prims"),
hotkey=(carb.input.KEYBOARD_MODIFIER_FLAG_SHIFT, carb.input.KeyboardInput.P),
),
MenuItemDescription(
name="Group",
glyph="none.svg",
# enable_fn=EditMenuExtension.prim_selected,
onclick_action=("omni.kit.menu.edit", "create_xform_to_group"),
hotkey=(carb.input.KEYBOARD_MODIFIER_FLAG_CONTROL, carb.input.KeyboardInput.G),
),
MenuItemDescription(
name="Ungroup",
glyph="none.svg",
# enable_fn=EditMenuExtension.prim_selected,
onclick_action=("omni.kit.menu.edit", "ungroup_prims"),
),
MenuItemDescription(
name="Toggle Visibility",
glyph="none.svg",
# enable_fn=EditMenuExtension.prim_selected,
onclick_action=("omni.kit.menu.edit", "toggle_visibillity"),
hotkey=(0, carb.input.KeyboardInput.H),
),
MenuItemDescription(),
MenuItemDescription(
name="Delete",
glyph="trash.svg",
# enable_fn=EditMenuExtension.prim_selected,
onclick_action=("omni.kit.menu.edit", "delete_prim"),
hotkey=(0, carb.input.KeyboardInput.DEL),
),
MenuItemDescription(
name="Delete - All Layers",
glyph="trash.svg",
# enable_fn=[EditMenuExtension.prim_selected, EditMenuExtension.is_not_in_live_session],
onclick_action=("omni.kit.menu.edit", "delete_prim_all_layers"),
),
MenuItemDescription(
name="Rename",
glyph="pencil.svg",
# enable_fn=[EditMenuExtension.prim_selected, EditMenuExtension.is_one_prim_selected, EditMenuExtension.can_delete],
onclick_action=("omni.kit.menu.edit", "menu_rename_prim_dialog"),
hotkey=(0, carb.input.KeyboardInput.F2),
appear_after="Delete - All Layers",
),
MenuItemDescription(),
MenuItemDescription(
name="Hide Unselected",
glyph="none.svg",
onclick_action=("omni.kit.selection", "HideUnselected"),
),
MenuItemDescription(
name="Unhide All",
glyph="none.svg",
onclick_action=("omni.kit.selection", "UnhideAllPrims"),
),
MenuItemDescription(),
MenuItemDescription(
name="Focus",
glyph="none.svg",
# enable_fn=EditMenuExtension.prim_selected,
onclick_action=("omni.kit.menu.edit", "focus_prim"),
hotkey=(0, carb.input.KeyboardInput.F),
),
MenuItemDescription(
name="Toggle Visualization Mode",
glyph="none.svg",
onclick_action=("omni.kit.viewport.actions", "toggle_global_visibility"),
),
MenuItemDescription(
name="Capture Screenshot",
glyph="none.svg",
onclick_action=("omni.kit.menu.edit", "capture_screenshot"),
hotkey=(0, carb.input.KeyboardInput.F10),
),
]
omni.kit.menu.utils.add_menu_items(self._edit_menu_list, "Edit", -9)
# def _on_stage_event(self, event):
# if event.type == int(omni.usd.StageEventType.SELECTION_CHANGED):
# async def refresh_menu_items():
# omni.kit.menu.utils.refresh_menu_items("Edit")
# asyncio.ensure_future(refresh_menu_items())
def _register_context_menu(self):
import omni.kit.context_menu
select_context_menu_dict = {
"name": {
"Select": [
{"name": {"Select Recent": self._select_recent_menu_list}},
{"name": "Select All", "onclick_action": ("omni.kit.selection", "all")},
{"name": "Select None", "onclick_action": ("omni.kit.selection", "none")},
{"name": "Select Invert", "onclick_action": ("omni.kit.menu.edit", "selection_invert")},
{"name": "Select Parent", "onclick_action": ("omni.kit.menu.edit", "selection_parent")},
{"name": "Select Leaf", "onclick_action": ("omni.kit.menu.edit", "selection_leaf")},
{"name": "Select Hierarchy", "onclick_action": ("omni.kit.menu.edit", "selection_hierarchy")},
{"name": "Select Similar", "onclick_action": ("omni.kit.menu.edit", "selection_similar")},
{"name": ""},
{"name": {"Select by Kind": self._selection_kind_menu_list}},
]
},
"glyph": "none.svg",
"appear_after": ""
}
self._context_menus.append(
omni.kit.context_menu.add_menu(select_context_menu_dict, "MENU", "omni.kit.window.viewport")
)
def _unregister_context_menu(self):
for menu in self._context_menus:
menu.release()
self._context_menus.clear()
def prim_selected():
paths = omni.usd.get_context().get_selection().get_selected_prim_paths()
return bool(paths)
def is_in_live_session():
usd_context = omni.usd.get_context()
live_syncing = layers.get_layers(usd_context).get_live_syncing()
return live_syncing.is_stage_in_live_session()
def is_not_in_live_session():
return not EditMenuExtension.is_stage_in_live_session()
def can_delete():
paths = omni.usd.get_context().get_selection().get_selected_prim_paths()
stage = omni.usd.get_context().get_stage()
if not stage:
return False
for path in paths:
prim = stage.GetPrimAtPath(path)
if not prim or not prim.IsValid():
return False
no_delete = prim.GetMetadata("no_delete")
if no_delete is not None and no_delete is True:
return False
return True
def is_one_prim_selected():
paths = omni.usd.get_context().get_selection().get_selected_prim_paths()
return len(paths) == 1
def can_prims_parent():
paths = omni.usd.get_context().get_selection().get_selected_prim_paths()
if paths:
return bool(len(paths)>1)
return False
def can_prims_unparent():
paths = omni.usd.get_context().get_selection().get_selected_prim_paths()
if paths:
return True
return False
def can_be_instanced():
allowed_types_for_instancing = ["Xform"]
stage = omni.usd.get_context().get_stage()
if not stage:
return False
paths = omni.usd.get_context().get_selection().get_selected_prim_paths()
for path in paths:
prim = stage.GetPrimAtPath(path)
if not prim or prim.GetTypeName() not in allowed_types_for_instancing:
return False
return True
def instance_prim():
usd_context = omni.usd.get_context()
paths = usd_context.get_selection().get_selected_prim_paths()
if not paths:
EditMenuExtension.post_notification("Cannot instance prim as no prims are selected")
return
with omni.kit.usd.layers.active_authoring_layer_context(usd_context):
paths = usd_context.get_selection().get_selected_prim_paths()
omni.kit.commands.execute("CreateInstances", paths_from=paths)
# When combine_layers is True, it means to duplicate with flattening references.
def duplicate_prim(duplicate_layers, combine_layers):
paths = omni.usd.get_context().get_selection().get_selected_prim_paths()
if not paths:
EditMenuExtension.post_notification("Cannot duplicate prim as no prims are selected")
return
if EditMenuExtension.is_in_live_session() and duplicate_layers and not combine_layers:
warn = "Destructive duplication is not supported in live-syncing."
carb.log_warn(warn)
EditMenuExtension.post_notification(warn)
return
paths = omni.usd.get_context().get_selection().get_selected_prim_paths()
usd_context = omni.usd.get_context()
with layers.active_authoring_layer_context(usd_context):
omni.kit.commands.execute(
"CopyPrims", paths_from=paths, duplicate_layers=duplicate_layers, combine_layers=combine_layers,
flatten_references=combine_layers
)
def parent_prims():
stage = omni.usd.get_context().get_stage()
if not stage:
EditMenuExtension.post_notification("Cannot parent prim as no stage is loaded")
return
if not EditMenuExtension.can_prims_parent():
EditMenuExtension.post_notification("Cannot parent prim as two or more prims are not selected")
return
if EditMenuExtension.is_in_live_session():
EditMenuExtension.post_notification("Parent is not supported in live-syncing.")
return
paths = omni.usd.get_context().get_selection().get_selected_prim_paths()
if paths:
def prim_renamed(old_prim_name: Sdf.Path, new_prim_name: Sdf.Path):
try:
index = paths.index(old_prim_name.pathString)
paths[index] = new_prim_name.pathString
except Exception as exc:
carb.log_warn(f"prim_renamed error {exc}")
parent_path = paths.pop()
prim = stage.GetPrimAtPath(parent_path)
if prim and prim.IsInstanceable():
EditMenuExtension.post_notification(f"{parent_path} cannot be parent as its Instanceable")
return
settings = carb.settings.get_settings()
keep_transform = settings.get(KEEP_TRANSFORM_FOR_REPARENTING)
if keep_transform is None:
keep_transform = True
omni.kit.commands.execute(
"ParentPrims",
parent_path=parent_path,
child_paths=paths,
on_move_fn=prim_renamed,
keep_world_transform=keep_transform
)
omni.usd.get_context().get_selection().set_selected_prim_paths(paths, True)
def unparent_prims():
stage = omni.usd.get_context().get_stage()
if not stage:
EditMenuExtension.post_notification("Cannot unparent prim as no stage is loaded")
return
if not EditMenuExtension.can_prims_unparent():
EditMenuExtension.post_notification("Cannot unparent prim as no prims are not selected")
return
if EditMenuExtension.is_in_live_session():
EditMenuExtension.post_notification("Unparent is not supported in live-syncing.")
return
paths = omni.usd.get_context().get_selection().get_selected_prim_paths()
if paths:
settings = carb.settings.get_settings()
keep_transform = settings.get(KEEP_TRANSFORM_FOR_REPARENTING)
if keep_transform is None:
keep_transform = True
omni.kit.commands.execute("UnparentPrims", paths=paths, keep_world_transform=keep_transform)
def create_xform_to_group():
usd_context = omni.usd.get_context()
paths = usd_context.get_selection().get_selected_prim_paths()
if not paths:
EditMenuExtension.post_notification("Cannot Group as no prims are selected")
return
stage = usd_context.get_stage()
if not stage:
EditMenuExtension.post_notification("Cannot Group prim as no stage is loaded")
return
if stage.HasDefaultPrim() and stage.GetDefaultPrim().GetPath().pathString in paths:
EditMenuExtension.post_notification("Cannot Group default prim")
return
with omni.kit.usd.layers.active_authoring_layer_context(usd_context):
omni.kit.commands.execute("GroupPrims", prim_paths=paths, destructive=False)
return True
def ungroup_prims():
usd_context = omni.usd.get_context()
paths = usd_context.get_selection().get_selected_prim_paths()
if not paths:
EditMenuExtension.post_notification("Cannot Ungroup as no prims are selected")
return
stage = usd_context.get_stage()
if not stage:
EditMenuExtension.post_notification("Cannot Ungroup prim as no stage is loaded")
return
with omni.kit.usd.layers.active_authoring_layer_context(usd_context):
omni.kit.commands.execute("UngroupPrims", prim_paths=paths, destructive=False)
return True
def delete_prim(destructive):
paths = omni.usd.get_context().get_selection().get_selected_prim_paths()
if not paths:
EditMenuExtension.post_notification("Cannot Delete as no prims are selected")
return
if destructive and EditMenuExtension.is_in_live_session():
EditMenuExtension.post_notification("Delete prims is not supported in live-syncing.")
return
omni.kit.commands.execute("DeletePrims", paths=paths, destructive=destructive)
def focus_prim():
from omni.kit.viewport.utility import frame_viewport_selection
frame_viewport_selection(force_legacy_api=True)
def toggle_visibillity():
paths = omni.usd.get_context().get_selection().get_selected_prim_paths()
if not paths:
EditMenuExtension.post_notification("Cannot Toggle Visibillity as no prims are selected")
return
omni.kit.commands.execute("ToggleVisibilitySelectedPrims", selected_paths=paths)
def toggle_global_visibility():
carb.log_error("omni.kit.menu.edit.toggle_global_visibility is deprecated, use omni.kit.viewport.actions.toggle_global_visibility")
action_registry = omni.kit.actions.core.get_action_registry()
exc_action = action_registry.get_action("omni.kit.viewport.actions", "toggle_global_visibility")
if exc_action:
return exc_action.execute()
carb.log_error("omni.kit.viewport.actions must be enabled")
def capture_screenshot(on_complete_fn: callable=None):
from datetime import datetime
now = datetime.now()
date_time = now.strftime("%Y-%m-%d %H.%M.%S")
capture_filename = "capture.%s.png" % (date_time)
# Check if the user specified the screenshots folder.
settings = carb.settings.get_settings()
screenshot_path = settings.get(PERSISTENT_SETTINGS_PREFIX + "/app/captureFrame/path")
if screenshot_path:
if os.path.isdir(screenshot_path):
capture_filename = os.path.join(screenshot_path, capture_filename)
else:
carb.log_error(f"Can't save screenshot to {str(screenshot_path)} because it is not a directory")
async def capture_frame(capture_filename: str, on_complete_fn: callable):
import omni.kit.app
carb.log_warn("Capturing %s" % (capture_filename))
# wait for next frame so menu has closed
await omni.kit.app.get_app().next_update_async()
capture_viewport = settings.get(PERSISTENT_SETTINGS_PREFIX + "/app/captureFrame/viewport")
success = False
try:
if not capture_viewport:
import omni.renderer_capture
renderer_capture = omni.renderer_capture.acquire_renderer_capture_interface()
renderer_capture.capture_next_frame_swapchain(capture_filename)
success = True
else:
from omni.kit.viewport.utility import get_active_viewport, capture_viewport_to_file
viewport = get_active_viewport()
if viewport:
capture_viewport_to_file(viewport, file_path=capture_filename, is_hdr=False)
success = True
except ImportError:
pass
if not success:
carb.log_error("Failed to capture " + ("viewport" if capture_viewport else "") + "screenshot")
if on_complete_fn:
# wait for screenshot to complete
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
on_complete_fn(success, capture_filename)
# wait for next frame so menu has closed
asyncio.ensure_future(capture_frame(capture_filename, on_complete_fn))
@staticmethod
def _rename_viewport_active_camera(old_prim_name: Sdf.Path, new_prim_name: Sdf.Path):
try:
from omni.kit.viewport.utility import get_active_viewport
viewport = get_active_viewport()
if viewport and viewport.camera_path == old_prim_name:
viewport.camera_path = new_prim_name or "/OmniverseKit_Persp"
except ImportError:
pass
@staticmethod
def rename_prim(stage, prim, window, field_widget):
if window:
window.visible = False
if field_widget:
def select_new_prim(old_prim_name: Sdf.Path, new_prim_name: Sdf.Path):
omni.usd.get_context().get_selection().set_selected_prim_paths([new_prim_name.pathString], True)
if prim.GetPath().name != field_widget.model.get_value_as_string():
old_prim_name = prim.GetPath()
new_prim_name = prim.GetPath().GetParentPath()
new_prim_name = new_prim_name.AppendChild(Tf.MakeValidIdentifier(field_widget.model.get_value_as_string()))
new_prim_name = omni.usd.get_stage_next_free_path(stage, new_prim_name.pathString, False)
on_move_fn = select_new_prim
if Sdf.Path.IsValidPathString(new_prim_name):
EditMenuExtension._rename_viewport_active_camera(old_prim_name, new_prim_name)
move_dict = {old_prim_name: new_prim_name}
omni.kit.commands.execute("MovePrims", paths_to_move=move_dict, on_move_fn=on_move_fn, destructive=False)
else:
EditMenuExtension.post_notification(f"Cannot rename {old_prim_name} to {new_prim_name} as its not a valid USD path")
def menu_rename_prim_dialog(self):
import omni.usd
paths = omni.usd.get_context().get_selection().get_selected_prim_paths()
if not paths:
EditMenuExtension.post_notification("Cannot Rename prim as no prims are selected")
return
if len(paths) != 1:
EditMenuExtension.post_notification("Cannot Rename more then one prim")
return
stage = omni.usd.get_context().get_stage()
if not stage or not paths:
return
# try to use omni.kit.widget.stage rename...
try:
import omni.kit.window.stage
window = ui.Workspace.get_window("Stage")
stage_widget = window.get_widget()
items = stage_widget.get_treeview().selection
if len(items) == 1:
return stage_widget.get_delegate().get_name_column_delegate().rename_item(items[0])
except Exception as exc:
carb.log_warn(f"stage window rename failed due to {exc}")
# do dialog rename
prim = stage.GetPrimAtPath(paths[0])
window = ui.Window(
"Rename " + prim.GetPath().name + "###context_menu_rename",
width=200,
height=0,
flags=ui.WINDOW_FLAGS_NO_RESIZE | ui.WINDOW_FLAGS_NO_SCROLLBAR | ui.WINDOW_FLAGS_MODAL,
)
with window.frame:
with ui.VStack(
height=0,
spacing=5,
name="top_level_stack",
style={"VStack::top_level_stack": {"margin": 5}, "Button": {"margin": 0}},
):
async def focus(field):
await omni.kit.app.get_app().next_update_async()
field.focus_keyboard()
new_name_widget = ui.StringField()
new_name_widget.model.set_value(prim.GetPath().name)
new_name_widget.focus_keyboard()
ui.Spacer(width=5, height=5)
with ui.HStack(spacing=5):
ui.Button(
"Ok",
clicked_fn=partial(EditMenuExtension.rename_prim, stage, prim, window, new_name_widget),
)
ui.Button(
"Cancel", clicked_fn=partial(EditMenuExtension.rename_prim, stage, prim, window, None)
)
editing_started = False
def on_begin():
nonlocal editing_started
editing_started = True
def on_end():
nonlocal editing_started
editing_started = False
def window_pressed_key(key_index, key_flags, key_down):
nonlocal editing_started
key_mod = key_flags & ~ui.Widget.FLAG_WANT_CAPTURE_KEYBOARD
if carb.input.KeyboardInput(key_index) in [carb.input.KeyboardInput.ENTER, carb.input.KeyboardInput.NUMPAD_ENTER] and key_mod == 0 and key_down and editing_started:
on_end()
EditMenuExtension.rename_prim(stage, prim, window, new_name_widget)
new_name_widget.model.add_begin_edit_fn(lambda m: on_begin())
new_name_widget.model.add_end_edit_fn(lambda m: on_end())
window.set_key_pressed_fn(window_pressed_key)
asyncio.ensure_future(focus(new_name_widget))
def get_extension_path(sub_directory):
global _extension_path
path = _extension_path
if sub_directory:
path = os.path.normpath(os.path.join(path, sub_directory))
return path
| 35,891 | Python | 41.526066 | 188 | 0.582542 |
omniverse-code/kit/exts/omni.kit.menu.edit/omni/kit/menu/edit/scripts/edit_actions.py | import carb
import asyncio
import omni.kit.actions.core
def register_actions(extension_id, cls, get_self_fn):
def select_prim(description: str, select_name: callable):
paths = omni.usd.get_context().get_selection().get_selected_prim_paths()
if not paths:
cls.post_notification(f"Cannot select \"{description}\" as no prims are selected")
return
return do_select(description, select_name, paths)
def add_to_recent(description: str, select_name: callable):
paths = omni.usd.get_context().get_selection().get_selected_prim_paths()
if not paths:
cls.post_notification("Cannot add to recent as no prims are selected")
return
return do_select(description, select_name, paths)
def do_select(description: str, select_name: callable, paths: list[str]):
old_selection = omni.usd.get_context().get_selection().get_selected_prim_paths()
async def select_func():
await omni.kit.app.get_app().next_update_async()
omni.kit.actions.core.execute_action("omni.kit.selection", select_name)
last_description = f"{description} {old_selection}"
new_selection = omni.usd.get_context().get_selection().get_selected_prim_paths()
if len(last_description) > 45:
last_description = last_description[:42] + "..."
get_self_fn()._add_to_recent(last_description, new_selection)
asyncio.ensure_future(select_func())
action_registry = omni.kit.actions.core.get_action_registry()
actions_tag = "Edit Menu Actions"
# actions
action_registry.register_action(
extension_id,
"select_recent",
get_self_fn()._on_select_recent,
display_name="Edit->Recent",
description="Recent",
tag=actions_tag,
)
action_registry.register_action(
extension_id,
"select_selection_set",
get_self_fn()._on_select_selection_set,
display_name="Edit->Selection Set",
description="Selection Set",
tag=actions_tag,
)
action_registry.register_action(
extension_id,
"select_by_kind",
get_self_fn()._on_select_by_kind,
display_name="Edit->Select By Kind",
description="Select By Kind",
tag=actions_tag,
)
action_registry.register_action(
extension_id,
"selection_invert",
lambda: select_prim(description="Inverse of", select_name="invert"),
display_name="Edit->Select Invert",
description="Select Invert",
tag=actions_tag,
)
action_registry.register_action(
extension_id,
"selection_parent",
lambda: select_prim(description="Parent of", select_name="parent"),
display_name="Edit->Select Parent",
description="Select Parent",
tag=actions_tag,
)
action_registry.register_action(
extension_id,
"selection_leaf",
lambda: select_prim(description="Leaves of", select_name="leaf"),
display_name="Edit->Select Leaf",
description="Select Leaf",
tag=actions_tag,
)
action_registry.register_action(
extension_id,
"selection_hierarchy",
lambda: select_prim(description="Hierarchy of", select_name="hierarchy"),
display_name="Edit->Select Hierarchy",
description="Select Hierarchy",
tag=actions_tag,
)
action_registry.register_action(
extension_id,
"selection_similar",
lambda: select_prim(description="Similar of", select_name="similar"),
display_name="Edit->Select Similar",
description="Select Similar",
tag=actions_tag,
)
action_registry.register_action(
extension_id,
"create_selection_set",
get_self_fn()._create_selection_set,
display_name="Edit->Create Selection Set",
description="Create Selection Set",
tag=actions_tag,
)
action_registry.register_action(
extension_id,
"instance_prim",
cls.instance_prim,
display_name="Edit->Instance Prim",
description="Instance Prim",
tag=actions_tag,
)
action_registry.register_action(
extension_id,
"duplicate_prim",
lambda: cls.duplicate_prim(duplicate_layers=False, combine_layers=False),
display_name="Edit->Duplicate Prim",
description="Duplicate Prim",
tag=actions_tag,
)
action_registry.register_action(
extension_id,
"duplicate_prim_and_layers",
lambda: cls.duplicate_prim(duplicate_layers=True, combine_layers=False),
display_name="Edit->Duplicate Prim & Duplicate Layers",
description="Duplicate Prim & Duplicate Layers",
tag=actions_tag,
)
action_registry.register_action(
extension_id,
"duplicate_prim_and_combine_layers",
lambda: cls.duplicate_prim(duplicate_layers=True, combine_layers=True),
display_name="Edit->Duplicate Prim & Combine Layers",
description="Duplicate Prim & Combine Layers",
tag=actions_tag,
)
action_registry.register_action(
extension_id,
"parent_prims",
cls.parent_prims,
display_name="Edit->Parent Prims",
description="Parent Prims",
tag=actions_tag,
)
action_registry.register_action(
extension_id,
"unparent_prims",
cls.unparent_prims,
display_name="Edit->Unparent Prims",
description="Unparent Prims",
tag=actions_tag,
)
action_registry.register_action(
extension_id,
"create_xform_to_group",
cls.create_xform_to_group,
display_name="Edit->Create XForm To Group",
description="Create XForm To Group",
tag=actions_tag,
)
action_registry.register_action(
extension_id,
"ungroup_prims",
cls.ungroup_prims,
display_name="Edit->Create XForm To Group",
description="Create XForm To Group",
tag=actions_tag,
)
action_registry.register_action(
extension_id,
"toggle_visibillity",
cls.toggle_visibillity,
display_name="Edit->Toggle Visibillity",
description="Toggle Visibillity",
tag=actions_tag,
)
action_registry.register_action(
extension_id,
"delete_prim",
lambda: cls.delete_prim(False),
display_name="Edit->Delete Prim",
description="Delete Prim",
tag=actions_tag,
)
action_registry.register_action(
extension_id,
"delete_prim_all_layers",
lambda: cls.delete_prim(True),
display_name="Edit->Delete Prim - All Layers",
description="Delete Prim - All Layers",
tag=actions_tag,
)
action_registry.register_action(
extension_id,
"menu_rename_prim_dialog",
get_self_fn().menu_rename_prim_dialog,
display_name="Edit->Rename Prim",
description="Rename Prim",
tag=actions_tag,
)
action_registry.register_action(
extension_id,
"focus_prim",
cls.focus_prim,
display_name="Edit->Focus Prim",
description="Focus Prim",
tag=actions_tag,
)
action_registry.register_action(
extension_id,
"toggle_global_visibility",
cls.toggle_global_visibility,
display_name="Edit->Toggle Global Visibility",
description="Toggle Global Visibility",
tag=actions_tag,
)
action_registry.register_action(
extension_id,
"capture_screenshot",
cls.capture_screenshot,
display_name="Edit->Capture Screenshot",
description="Capture Screenshot",
tag=actions_tag,
)
def deregister_actions(extension_id):
action_registry = omni.kit.actions.core.get_action_registry()
action_registry.deregister_all_actions_for_extension(extension_id)
| 8,022 | Python | 29.976834 | 94 | 0.614186 |
omniverse-code/kit/exts/omni.kit.menu.edit/omni/kit/menu/edit/scripts/__init__.py | from .edit import *
| 20 | Python | 9.499995 | 19 | 0.7 |
omniverse-code/kit/exts/omni.kit.menu.edit/omni/kit/menu/edit/scripts/selection.py | import time
class Selection():
def __init__(self, description, selection):
self.time = time.time()
self.description = description
self.selection = selection
def touch(self):
self.time = time.time()
| 240 | Python | 20.909089 | 47 | 0.6125 |
omniverse-code/kit/exts/omni.kit.menu.edit/omni/kit/menu/edit/scripts/selection_window.py | import omni.ui as ui
class SelectionSetWindow():
def __init__(self, callback):
self._callback = callback
window = ui.Window(
"Selection Set Name",
width=300,
height=110,
flags=ui.WINDOW_FLAGS_NO_RESIZE | ui.WINDOW_FLAGS_NO_SCROLLBAR | ui.WINDOW_FLAGS_MODAL
)
with window.frame:
def on_create(widget):
self._callback(widget.model.as_string)
window.visible = False
def on_cancel():
window.visible = False
with ui.VStack(
height=0,
spacing=5,
name="top_level_stack",
style={"VStack::top_level_stack": {"margin": 5}, "Button": {"margin": 0}},
):
ui.Label("New selection set name:")
widget = ui.StringField()
ui.Spacer(width=5, height=5)
with ui.HStack(spacing=5):
create_button = ui.Button("Create", enabled=False, clicked_fn=lambda w=widget: on_create(w))
ui.Button("Cancel", clicked_fn=lambda: on_cancel())
def window_pressed_key(key_index, key_flags, key_down):
import carb.input
create_button.enabled = bool(len(widget.model.as_string) > 0)
key_mod = key_flags & ~ui.Widget.FLAG_WANT_CAPTURE_KEYBOARD
if create_button.enabled and carb.input.KeyboardInput(key_index) in [carb.input.KeyboardInput.ENTER, carb.input.KeyboardInput.NUMPAD_ENTER] and key_mod == 0 and key_down:
on_create(widget)
widget.focus_keyboard()
window.set_key_pressed_fn(window_pressed_key)
self._window = window
self._widget = widget
def shutdown(self):
self._callback = None
del self._window
def show(self):
self._window.visible = True
self._widget.model.set_value("")
self._widget.focus_keyboard()
| 2,049 | Python | 34.964912 | 190 | 0.532455 |
omniverse-code/kit/exts/omni.kit.menu.edit/omni/kit/menu/edit/tests/test_func_edit_undo.py | import asyncio
import carb
import omni.usd
import omni.ui as ui
from omni.kit import ui_test
from omni.kit.menu.utils import MenuItemDescription, MenuLayout
async def edit_test_func_edit_undo(tester, menu_item: MenuItemDescription):
stage = omni.usd.get_context().get_stage()
menu_widget = ui_test.get_menubar()
# verify no prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == [])
## create prim
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Sphere")
await ui_test.human_delay()
# verify prim created
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Sphere'])
# click undo
await menu_widget.find_menu("Edit").click()
await menu_widget.find_menu("Undo").click()
await ui_test.human_delay()
# verify no prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == [])
async def edit_test_hotkey_func_edit_undo(tester, menu_item: MenuItemDescription):
stage = omni.usd.get_context().get_stage()
# verify no prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == [])
## create prim
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Sphere")
await ui_test.human_delay()
# verify prim created
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Sphere'])
# hotkey
await ui_test.emulate_keyboard_press(menu_item.hotkey[1], menu_item.hotkey[0])
# verify no prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == [])
async def edit_test_func_edit_redo(tester, menu_item: MenuItemDescription):
stage = omni.usd.get_context().get_stage()
menu_widget = ui_test.get_menubar()
# verify no prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == [])
# do/undo so redo will work
await edit_test_func_edit_undo(tester, None)
# click redo
await menu_widget.find_menu("Edit").click()
await menu_widget.find_menu("Redo").click()
await ui_test.human_delay()
# verify sphere re-created prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Sphere'])
async def edit_test_hotkey_func_edit_redo(tester, menu_item: MenuItemDescription):
stage = omni.usd.get_context().get_stage()
# verify no prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == [])
# do/undo so redo will work
await edit_test_func_edit_undo(tester, None)
# hotkey
await ui_test.emulate_keyboard_press(menu_item.hotkey[1], menu_item.hotkey[0])
# verify sphere re-created prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Sphere'])
async def edit_test_func_edit_repeat(tester, menu_item: MenuItemDescription):
menu_widget = ui_test.get_menubar()
# verify no prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == [])
## create prim
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Sphere")
await ui_test.human_delay()
# verify prim created
prim_list = tester.get_stage_prims()
tester.assertListEqual(prim_list, ['/Sphere'])
# click repeat
await menu_widget.find_menu("Edit").click()
await menu_widget.find_menu("Repeat").click()
await ui_test.human_delay()
# verify prim was repeated
prim_list = tester.get_stage_prims()
tester.assertListEqual(prim_list, ['/Sphere', '/Sphere_01'])
async def edit_test_hotkey_func_edit_repeat(tester, menu_item: MenuItemDescription):
# verify no prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == [])
## create prim
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Sphere")
await ui_test.human_delay()
# verify prim created
prim_list = tester.get_stage_prims()
tester.assertListEqual(prim_list, ['/Sphere'])
# hotkey
await ui_test.emulate_keyboard_press(menu_item.hotkey[1], menu_item.hotkey[0])
# verify prim was repeated
prim_list = tester.get_stage_prims()
tester.assertListEqual(prim_list, ['/Sphere', '/Sphere_01'])
| 4,210 | Python | 28.865248 | 84 | 0.677197 |
omniverse-code/kit/exts/omni.kit.menu.edit/omni/kit/menu/edit/tests/test_func_edit_misc.py | import asyncio
import carb
import omni.usd
import omni.ui as ui
from omni.kit import ui_test
from omni.kit.menu.utils import MenuItemDescription, MenuLayout
from omni.kit.viewport.utility.camera_state import ViewportCameraState
from pathlib import Path
async def edit_test_func_edit_focus(tester, menu_item: MenuItemDescription):
# get file path
extension_path = omni.kit.app.get_app().get_extension_manager().get_extension_path_by_module(__name__)
await omni.usd.get_context().open_stage_async(str(Path(extension_path).joinpath("data").joinpath("tests").joinpath("stages").joinpath("focus_prims.usda")))
# test focus
stage = omni.usd.get_context().get_stage()
prim_pos = ViewportCameraState().position_world
for prim_path in ['/World/Cone', '/World/Cube', '/World/Sphere', '/World/defaultLight']:
# select prim
omni.usd.get_context().get_selection().set_selected_prim_paths([prim_path], True)
# use menu
await ui_test.menu_click("Edit/Focus")
await ui_test.human_delay(50)
# verify camera has moved
pos = ViewportCameraState().position_world
tester.assertTrue(pos != prim_pos)
prim_pos = pos
async def edit_test_hotkey_func_edit_focus(tester, menu_item: MenuItemDescription):
# get file path
extension_path = omni.kit.app.get_app().get_extension_manager().get_extension_path_by_module(__name__)
await omni.usd.get_context().open_stage_async(str(Path(extension_path).joinpath("data").joinpath("tests").joinpath("stages").joinpath("focus_prims.usda")))
# test focus
stage = omni.usd.get_context().get_stage()
prim_pos = ViewportCameraState().position_world
for prim_path in ['/World/Cone', '/World/Cube', '/World/Sphere', '/World/defaultLight']:
# select prim
omni.usd.get_context().get_selection().set_selected_prim_paths([prim_path], True)
# hotkey
await ui_test.emulate_keyboard_press(menu_item.hotkey[1], menu_item.hotkey[0])
await ui_test.human_delay(50)
# verify camera has moved
pos = ViewportCameraState().position_world
tester.assertTrue(pos != prim_pos)
prim_pos = pos
async def edit_test_func_edit_toggle_visualization_mode(tester, menu_item: MenuItemDescription):
# this test is odd due to the way viewport changed grid/display state
# it is only tested on legacy Viewport as the test is against implememtation details / settings
from omni.kit.viewport.utility import get_active_viewport
if not hasattr(get_active_viewport(), "legacy_window"):
return
settings = carb.settings.get_settings()
def get_state():
return (settings.get("/app/viewport/grid/enabled"),
settings.get("/persistent/app/viewport/displayOptions"))
async def run_toggle():
# use menu item
await ui_test.menu_click("Edit/Toggle Visualization Mode")
await ui_test.human_delay(1)
return get_state()
# Grab state to restore to
grid_restore, display_restore = get_state()
try:
# Setup state to test against
grid_state_a, display_state_a = True, 32767
settings.set("/app/viewport/grid/enabled", grid_state_a)
settings.set("/persistent/app/viewport/displayOptions", display_state_a)
# run the menu item
grid_state_b, display_state_b = await run_toggle()
# values should not be equal fro mthe toggle
tester.assertNotEqual(grid_state_a, grid_state_b)
tester.assertNotEqual(display_state_a, display_state_b)
# run the menu item
grid_state_b, display_state_b = await run_toggle()
# verify state changed back to original
tester.assertEqual(grid_state_a, grid_state_b)
tester.assertEqual(display_state_a, display_state_b)
finally:
# Restore to incoming state for any other tests
settings.set("/app/viewport/grid/enabled", grid_restore)
settings.set("/persistent/app/viewport/displayOptions", display_restore)
async def edit_test_func_edit_capture_screenshot(tester, menu_item: MenuItemDescription):
warning_count = 0
def on_log_event(e):
if e.payload["level"] == carb.logging.LEVEL_WARN:
nonlocal warning_count
warning_count += 1
# log event, count number of warnings outputed - FIXME: can I parse log and get messages?
log_stream = omni.kit.app.get_app().get_log_event_stream()
log_sub = log_stream.create_subscription_to_pop(on_log_event, name="edit_test_func_edit_capture_screenshot log event")
# use menu
await ui_test.menu_click("Edit/Capture Screenshot")
# wait for screenshot to finish
await ui_test.human_delay(100)
log_stream = None
log_sub = None
tester.assertTrue(warning_count == 1)
async def edit_test_hotkey_func_edit_capture_screenshot(tester, menu_item: MenuItemDescription):
warning_count = 0
def on_log_event(e):
if e.payload["level"] == carb.logging.LEVEL_WARN:
nonlocal warning_count
warning_count += 1
# log event, count number of warnings outputed - FIXME: can I parse log and get messages?
log_stream = omni.kit.app.get_app().get_log_event_stream()
log_sub = log_stream.create_subscription_to_pop(on_log_event, name="edit_test_func_edit_capture_screenshot log event")
# hotkey
await ui_test.emulate_keyboard_press(menu_item.hotkey[1], menu_item.hotkey[0])
# wait for screenshot to finish
await ui_test.human_delay(100)
log_stream = None
log_sub = None
tester.assertTrue(warning_count == 1)
async def _edit_test_hotkey_func_edit_toggle_some_visibility(tester, menu_item: MenuItemDescription, setting_key: str):
settings = carb.settings.get_settings()
initial_state = settings.get(setting_key) or False
await ui_test.emulate_keyboard_press(menu_item.hotkey[1])
await ui_test.human_delay(2)
tester.assertNotEqual(settings.get(setting_key), initial_state)
await ui_test.emulate_keyboard_press(menu_item.hotkey[1])
await ui_test.human_delay(2)
tester.assertEqual(settings.get(setting_key), initial_state)
| 6,165 | Python | 38.025316 | 159 | 0.683536 |
omniverse-code/kit/exts/omni.kit.menu.edit/omni/kit/menu/edit/tests/__init__.py | from .edit_tests import *
from .rename_tests import *
| 54 | Python | 17.333328 | 27 | 0.740741 |
omniverse-code/kit/exts/omni.kit.menu.edit/omni/kit/menu/edit/tests/rename_tests.py | import sys
import re
import asyncio
import unittest
import carb
import omni.kit.test
import omni.kit.ui_test as ui_test
import omni.kit.commands
from carb.input import KeyboardInput
class TestMenuEditRename(omni.kit.test.AsyncTestCase):
async def setUp(self):
from omni.kit.test_suite.helpers import arrange_windows
await arrange_windows()
await omni.usd.get_context().new_stage_async()
async def tearDown(self):
pass
async def test_edit_menu_rename(self):
import omni.kit.material.library
from omni.kit.test_suite.helpers import get_test_data_path, wait_stage_loading, get_prims
# wait for material to be preloaded so create menu is complete & menus don't rebuild during tests
await omni.kit.material.library.get_mdl_list_async()
await ui_test.human_delay()
## create prim
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Sphere")
await ui_test.human_delay()
# verify prims were created
stage = omni.usd.get_context().get_stage()
prim_list = [prim.GetPath().pathString for prim in get_prims(stage) if not omni.usd.is_hidden_type(prim)]
self.assertTrue(prim_list == ['/Sphere'])
# select prim
omni.usd.get_context().get_selection().set_selected_prim_paths(['/Sphere'], True)
await ui_test.human_delay()
# use menu - As omni.kit.window.stage is loaded then that should
# be used to rename, not dialog like in edit_test_func_edit_rename
await ui_test.menu_click("Edit/Rename")
# type new name
await ui_test.human_delay()
await ui_test.emulate_keyboard_press(KeyboardInput.DEL)
await ui_test.human_delay()
await ui_test.emulate_char_press("MyHovercraftISFullOfEels@@xx1/\!!")
await ui_test.human_delay()
await ui_test.emulate_keyboard_press(KeyboardInput.ENTER)
await ui_test.human_delay()
# verify rename worked and bad characters were handled
prim_list = [prim.GetPath().pathString for prim in get_prims(stage) if not omni.usd.is_hidden_type(prim)]
self.assertTrue(prim_list == ['/MyHovercraftISFullOfEels__xx1____'])
# test undo
omni.kit.undo.undo()
await ui_test.human_delay()
prim_list = [prim.GetPath().pathString for prim in get_prims(stage) if not omni.usd.is_hidden_type(prim)]
self.assertTrue(prim_list == ['/Sphere'])
| 2,477 | Python | 37.123076 | 113 | 0.666532 |
omniverse-code/kit/exts/omni.kit.menu.edit/omni/kit/menu/edit/tests/test_func_edit_select.py | import asyncio
import carb
import omni.usd
import omni.ui as ui
from omni.kit import ui_test
from omni.kit.menu.utils import MenuItemDescription, MenuLayout
async def edit_test_func_edit_select_select_all(tester, menu_item: MenuItemDescription):
stage = omni.usd.get_context().get_stage()
## create prim
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Sphere")
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Xform")
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Cube")
await ui_test.human_delay()
# verify prims were created
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Sphere', '/Xform', '/Cube'])
# use menu
await ui_test.menu_click("Edit/Select/Select All")
# verify all prims are selected
tester.assertTrue(omni.usd.get_context().get_selection().get_selected_prim_paths() == prim_list)
async def edit_test_hotkey_func_edit_select_select_all(tester, menu_item: MenuItemDescription):
stage = omni.usd.get_context().get_stage()
## create prim
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Sphere")
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Xform")
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Cube")
await ui_test.human_delay()
# verify prims were created
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Sphere', '/Xform', '/Cube'])
# hotkey
await ui_test.emulate_keyboard_press(menu_item.hotkey[1], menu_item.hotkey[0])
# verify all prims are selected
tester.assertTrue(omni.usd.get_context().get_selection().get_selected_prim_paths() == prim_list)
async def edit_test_func_edit_select_select_none(tester, menu_item: MenuItemDescription):
stage = omni.usd.get_context().get_stage()
## create prim
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Sphere")
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Xform")
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Cube")
await ui_test.human_delay()
# verify prims were created
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Sphere', '/Xform', '/Cube'])
# select prims
omni.usd.get_context().get_selection().set_selected_prim_paths(prim_list, True)
await ui_test.human_delay()
# use menu
await ui_test.menu_click("Edit/Select/Select None")
# verify all prims are selected
tester.assertTrue(omni.usd.get_context().get_selection().get_selected_prim_paths() == [])
async def edit_test_hotkey_func_edit_select_select_none(tester, menu_item: MenuItemDescription):
stage = omni.usd.get_context().get_stage()
## create prim
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Sphere")
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Xform")
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Cube")
await ui_test.human_delay()
# verify prims were created
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Sphere', '/Xform', '/Cube'])
# select prims
omni.usd.get_context().get_selection().set_selected_prim_paths(prim_list, True)
await ui_test.human_delay()
# hotkey
await ui_test.emulate_keyboard_press(menu_item.hotkey[1], menu_item.hotkey[0])
# verify all prims are selected
tester.assertTrue(omni.usd.get_context().get_selection().get_selected_prim_paths() == [])
async def edit_test_func_edit_select_select_invert(tester, menu_item: MenuItemDescription):
stage = omni.usd.get_context().get_stage()
## create prim
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Sphere")
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Xform")
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Cube")
await ui_test.human_delay()
# verify prims were created
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Sphere', '/Xform', '/Cube'])
# select prims
omni.usd.get_context().get_selection().set_selected_prim_paths(['/Xform'], True)
await ui_test.human_delay()
# verify prim is selected
tester.assertTrue(omni.usd.get_context().get_selection().get_selected_prim_paths() == ['/Xform'])
# use menu
await ui_test.menu_click("Edit/Select/Select Invert")
# verify all prims are selected
tester.assertTrue(omni.usd.get_context().get_selection().get_selected_prim_paths() == ['/Sphere', '/Cube'])
async def edit_test_hotkey_func_edit_select_select_invert(tester, menu_item: MenuItemDescription):
stage = omni.usd.get_context().get_stage()
## create prim
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Sphere")
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Xform")
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Cube")
await ui_test.human_delay()
# verify prims were created
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Sphere', '/Xform', '/Cube'])
# select prims
omni.usd.get_context().get_selection().set_selected_prim_paths(['/Xform'], True)
await ui_test.human_delay()
# verify prim is selected
tester.assertTrue(omni.usd.get_context().get_selection().get_selected_prim_paths() == ['/Xform'])
# hotkey
await ui_test.emulate_keyboard_press(menu_item.hotkey[1], menu_item.hotkey[0])
# verify all prims are selected
tester.assertTrue(omni.usd.get_context().get_selection().get_selected_prim_paths() == ['/Sphere', '/Cube'])
async def edit_test_func_edit_select_select_parent(tester, menu_item: MenuItemDescription):
stage = omni.usd.get_context().get_stage()
# verify no prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == [])
## create prim
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Sphere")
await ui_test.human_delay()
# verify prims were created
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Sphere'])
# select prim
omni.usd.get_context().get_selection().set_selected_prim_paths(['/Sphere'], True)
await ui_test.human_delay()
# use menu
await ui_test.menu_click("Edit/Group")
omni.usd.get_context().get_selection().set_selected_prim_paths(['/Group/Sphere'], True)
# use menu
await ui_test.menu_click("Edit/Select/Select Parent")
# verify
tester.assertTrue(omni.usd.get_context().get_selection().get_selected_prim_paths() == ['/Group'])
async def edit_test_hotkey_func_edit_select_select_parent(tester, menu_item: MenuItemDescription):
stage = omni.usd.get_context().get_stage()
# verify no prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == [])
## create prim
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Sphere")
await ui_test.human_delay()
# verify prims were created
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Sphere'])
# select prim
omni.usd.get_context().get_selection().set_selected_prim_paths(['/Sphere'], True)
await ui_test.human_delay()
# use menu
await ui_test.menu_click("Edit/Group")
omni.usd.get_context().get_selection().set_selected_prim_paths(['/Group/Sphere'], True)
# hotkey
await ui_test.emulate_keyboard_press(menu_item.hotkey[1], menu_item.hotkey[0])
tester.assertTrue(omni.usd.get_context().get_selection().get_selected_prim_paths() == ['/Group'])
async def edit_test_func_edit_select_select_leaf(tester, menu_item: MenuItemDescription):
from pathlib import Path
# get file path
extension_path = omni.kit.app.get_app().get_extension_manager().get_extension_path_by_module(__name__)
await omni.usd.get_context().open_stage_async(str(Path(extension_path).joinpath("data").joinpath("tests").joinpath("stages").joinpath("leaf_test.usda")))
stage = omni.usd.get_context().get_stage()
# select prim
omni.usd.get_context().get_selection().set_selected_prim_paths(['/World'], True)
await ui_test.human_delay()
# use menu
await ui_test.menu_click("Edit/Select/Select Leaf")
await ui_test.human_delay()
# verify world leafs
leafs = omni.usd.get_context().get_selection().get_selected_prim_paths()
tester.assertTrue(leafs == ['/World/Cone', '/World/Cube', '/World/Cylinder', '/World/Disk', '/World/Plane', '/World/Scope/Capsule', '/World/Scope/Cylinder', '/World/Sphere', '/World/Torus', '/World/defaultLight'])
# select prim
omni.usd.get_context().get_selection().set_selected_prim_paths(['/World/Scope'], True)
await ui_test.human_delay()
# use menu
await ui_test.menu_click("Edit/Select/Select Leaf")
await ui_test.human_delay()
# verify scope leafs
leafs = omni.usd.get_context().get_selection().get_selected_prim_paths()
tester.assertTrue(leafs == ['/World/Scope/Capsule', '/World/Scope/Cylinder'])
async def edit_test_func_edit_select_select_hierarchy(tester, menu_item: MenuItemDescription):
from pathlib import Path
# get file path
extension_path = omni.kit.app.get_app().get_extension_manager().get_extension_path_by_module(__name__)
await omni.usd.get_context().open_stage_async(str(Path(extension_path).joinpath("data").joinpath("tests").joinpath("stages").joinpath("leaf_test.usda")))
stage = omni.usd.get_context().get_stage()
# select prim
omni.usd.get_context().get_selection().set_selected_prim_paths(['/World'], True)
await ui_test.human_delay()
# use menu
await ui_test.menu_click("Edit/Select/Select Hierarchy")
await ui_test.human_delay()
# verify world leafs
hierarchy = omni.usd.get_context().get_selection().get_selected_prim_paths()
tester.assertTrue(hierarchy == ['/World', '/World/Cone', '/World/Cube', '/World/Cylinder', '/World/Disk', '/World/Plane', '/World/Scope', '/World/Scope/Capsule', '/World/Scope/Cylinder', '/World/Sphere', '/World/Torus', '/World/defaultLight'])
# select prim
omni.usd.get_context().get_selection().set_selected_prim_paths(['/World/Scope'], True)
await ui_test.human_delay()
# use menu
await ui_test.menu_click("Edit/Select/Select Hierarchy")
await ui_test.human_delay()
# verify scope leafs
hierarchy = omni.usd.get_context().get_selection().get_selected_prim_paths()
tester.assertTrue(hierarchy == ['/World/Scope', '/World/Scope/Capsule', '/World/Scope/Cylinder'])
async def edit_test_func_edit_select_select_similar(tester, menu_item: MenuItemDescription):
from pathlib import Path
# get file path
extension_path = omni.kit.app.get_app().get_extension_manager().get_extension_path_by_module(__name__)
await omni.usd.get_context().open_stage_async(str(Path(extension_path).joinpath("data").joinpath("tests").joinpath("stages").joinpath("leaf_test.usda")))
stage = omni.usd.get_context().get_stage()
# NOTE: prim names do not reflect prim types
expected = {
"/World": ['/World'],
"/World/defaultLight": ['/World/defaultLight'],
"/World/Cone": ['/World/Cone', '/World/Cylinder', '/World/Torus', '/World/Scope/Capsule'],
"/World/Cube": ['/World/Cube', '/World/Plane'],
"/World/Cylinder": ['/World/Cone', '/World/Cylinder', '/World/Torus', '/World/Scope/Capsule'],
"/World/Disk": ['/World/Disk', '/World/Sphere', '/World/Scope/Cylinder'],
"/World/Plane": ['/World/Cube', '/World/Plane'],
"/World/Sphere": ['/World/Disk', '/World/Sphere', '/World/Scope/Cylinder'],
"/World/Torus": ['/World/Cone', '/World/Cylinder', '/World/Torus', '/World/Scope/Capsule'],
"/World/Scope": ['/World/Scope'],
"/World/Scope/Capsule": ['/World/Cone', '/World/Cylinder', '/World/Torus', '/World/Scope/Capsule'],
"/World/Scope/Cylinder": ['/World/Disk', '/World/Sphere', '/World/Scope/Cylinder'],
}
for prim_name in tester.get_stage_prims():
# select prim
omni.usd.get_context().get_selection().set_selected_prim_paths([prim_name], True)
await ui_test.human_delay()
# use menu
await ui_test.menu_click("Edit/Select/Select Similar")
await ui_test.human_delay()
similar = omni.usd.get_context().get_selection().get_selected_prim_paths()
tester.assertTrue(expected[prim_name] == similar)
async def edit_test_func_edit_select_create_selection_set(tester, menu_item: MenuItemDescription):
from carb.input import KeyboardInput
stage = omni.usd.get_context().get_stage()
## create prim
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Sphere")
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Xform")
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Cube")
await ui_test.human_delay()
# use menu
await ui_test.menu_click("Edit/Select/Select All")
await ui_test.human_delay()
await ui_test.menu_click("Edit/Select/Create Selection Set")
await ui_test.human_delay()
widget = ui_test.find("Selection Set Name//Frame/**/StringField[*]")
await widget.click(double=True)
await ui_test.human_delay()
await ui_test.emulate_keyboard_press(KeyboardInput.DEL)
await ui_test.human_delay()
await ui_test.emulate_char_press("All")
await ui_test.human_delay()
await ui_test.emulate_keyboard_press(KeyboardInput.ENTER)
await ui_test.human_delay()
# verify "All"
omni.usd.get_context().get_selection().set_selected_prim_paths([], True)
await ui_test.human_delay()
await ui_test.menu_click("Edit/Select/Select Set/All")
await ui_test.human_delay()
selected_prims = omni.usd.get_context().get_selection().get_selected_prim_paths()
tester.assertTrue(selected_prims == ['/Sphere', '/Xform', '/Cube'])
async def edit_test_func_edit_select_select_by_kind_subcomponent(tester, menu_item: MenuItemDescription):
from pathlib import Path
# get file path
extension_path = omni.kit.app.get_app().get_extension_manager().get_extension_path_by_module(__name__)
await omni.usd.get_context().open_stage_async(str(Path(extension_path).joinpath("data").joinpath("tests").joinpath("stages").joinpath("leaf_test.usda")))
stage = omni.usd.get_context().get_stage()
# use menu
await ui_test.menu_click("Edit/Select/Select by Kind/Subcomponent")
await ui_test.human_delay()
# verify world leafs
selection = omni.usd.get_context().get_selection().get_selected_prim_paths()
tester.assertEqual(selection, ['/World/Cone', '/World/Scope/Capsule'])
async def edit_test_func_edit_select_select_by_kind_component(tester, menu_item: MenuItemDescription):
from pathlib import Path
# get file path
extension_path = omni.kit.app.get_app().get_extension_manager().get_extension_path_by_module(__name__)
await omni.usd.get_context().open_stage_async(str(Path(extension_path).joinpath("data").joinpath("tests").joinpath("stages").joinpath("leaf_test.usda")))
stage = omni.usd.get_context().get_stage()
# use menu
await ui_test.menu_click("Edit/Select/Select by Kind/Component")
await ui_test.human_delay()
# verify world leafs
selection = omni.usd.get_context().get_selection().get_selected_prim_paths()
# The /OmniverseKit_* prims are added by Kit
tester.assertEqual(selection, ['/World/Cube', '/World/Disk', '/OmniverseKit_Persp', '/OmniverseKit_Front', '/OmniverseKit_Top', '/OmniverseKit_Right'])
async def edit_test_func_edit_select_select_by_kind_group(tester, menu_item: MenuItemDescription):
from pathlib import Path
# get file path
extension_path = omni.kit.app.get_app().get_extension_manager().get_extension_path_by_module(__name__)
await omni.usd.get_context().open_stage_async(str(Path(extension_path).joinpath("data").joinpath("tests").joinpath("stages").joinpath("leaf_test.usda")))
stage = omni.usd.get_context().get_stage()
# use menu
await ui_test.menu_click("Edit/Select/Select by Kind/Group")
await ui_test.human_delay()
# verify world leafs
selection = omni.usd.get_context().get_selection().get_selected_prim_paths()
tester.assertEqual(selection, ['/World/Cylinder', '/World/Plane', '/World/Sphere'])
async def edit_test_func_edit_select_select_by_kind_assembly(tester, menu_item: MenuItemDescription):
from pathlib import Path
# get file path
extension_path = omni.kit.app.get_app().get_extension_manager().get_extension_path_by_module(__name__)
await omni.usd.get_context().open_stage_async(str(Path(extension_path).joinpath("data").joinpath("tests").joinpath("stages").joinpath("leaf_test.usda")))
stage = omni.usd.get_context().get_stage()
# use menu
await ui_test.menu_click("Edit/Select/Select by Kind/Assembly")
await ui_test.human_delay()
# verify world leafs
selection = omni.usd.get_context().get_selection().get_selected_prim_paths()
tester.assertEqual(selection, ['/World/Plane'])
| 17,247 | Python | 39.872038 | 247 | 0.687424 |
omniverse-code/kit/exts/omni.kit.menu.edit/omni/kit/menu/edit/tests/test_func_edit_prims.py | import asyncio
import carb
import omni.usd
import omni.kit.undo
import omni.ui as ui
from pxr import UsdGeom
from omni.kit import ui_test
from carb.input import KeyboardInput
from omni.kit.menu.utils import MenuItemDescription, MenuLayout
async def verify_menu_item_greyed(tester, menu, state):
# open/close menu to ensure menu state is correct
menu_widget = ui_test.get_menubar()
edit_menu = menu_widget.find_menu("Edit")
await edit_menu.click()
await edit_menu.click()
# contextual menu enable/disable has been temportally removed
# check state
# widget = edit_menu.find_menu(menu.name if isinstance(menu, MenuItemDescription) else menu)
# tester.assertTrue(widget.widget.enabled == state)
async def edit_test_func_edit_instance(tester, menu_item: MenuItemDescription):
stage = omni.usd.get_context().get_stage()
# verify no prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == [])
## create prim
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Sphere")
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Xform")
await ui_test.human_delay()
# verify prims were created
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Sphere', '/Xform'])
# verify instance is grey with nothing selected
omni.usd.get_context().get_selection().set_selected_prim_paths([], True)
await verify_menu_item_greyed(tester, menu_item, False)
# verify instance is grey with sphere selected
omni.usd.get_context().get_selection().set_selected_prim_paths(['/Sphere'], True)
await ui_test.human_delay()
await verify_menu_item_greyed(tester, menu_item, False)
# verify instance is enabled with xform selected
omni.usd.get_context().get_selection().set_selected_prim_paths(['/Xform'], True)
await ui_test.human_delay()
await verify_menu_item_greyed(tester, menu_item, True)
# use menu
await ui_test.menu_click("Edit/Instance")
# verify prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Sphere', '/Xform', '/Xform_01'])
async def edit_test_hotkey_func_edit_instance(tester, menu_item: MenuItemDescription):
stage = omni.usd.get_context().get_stage()
# verify no prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == [])
## create prim
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Xform")
await ui_test.human_delay()
# verify prims were created
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Xform'])
# select prims
omni.usd.get_context().get_selection().set_selected_prim_paths(['/Xform'], True)
await ui_test.human_delay()
# hotkey
await ui_test.emulate_keyboard_press(menu_item.hotkey[1], menu_item.hotkey[0])
# verify prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Xform', '/Xform_01'])
async def edit_test_func_edit_duplicate(tester, menu_item: MenuItemDescription):
stage = omni.usd.get_context().get_stage()
# verify no prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == [])
## create prim
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Sphere")
await ui_test.human_delay()
# verify prims were created
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Sphere'])
# verify instance is grey with nothing selected
omni.usd.get_context().get_selection().set_selected_prim_paths([], True)
await verify_menu_item_greyed(tester, menu_item, False)
# verify instance is enabled with xform selected
omni.usd.get_context().get_selection().set_selected_prim_paths(['/Sphere'], True)
await ui_test.human_delay()
await verify_menu_item_greyed(tester, menu_item, True)
# use menu
await ui_test.menu_click("Edit/Duplicate")
# verify prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Sphere', '/Sphere_01'])
async def edit_test_hotkey_func_edit_duplicate(tester, menu_item: MenuItemDescription):
stage = omni.usd.get_context().get_stage()
# verify no prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == [])
## create prim
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Sphere")
await ui_test.human_delay()
# verify prims were created
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Sphere'])
# select prims
omni.usd.get_context().get_selection().set_selected_prim_paths(['/Sphere'], True)
await ui_test.human_delay()
# hotkey
await ui_test.emulate_keyboard_press(menu_item.hotkey[1], menu_item.hotkey[0])
# verify prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Sphere', '/Sphere_01'])
async def edit_test_func_edit_duplicate___all_layers(tester, menu_item: MenuItemDescription):
stage = omni.usd.get_context().get_stage()
# verify no prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == [])
## create prim
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Sphere")
await ui_test.human_delay()
# verify prims were created
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Sphere'])
# verify instance is grey with nothing selected
omni.usd.get_context().get_selection().set_selected_prim_paths([], True)
await verify_menu_item_greyed(tester, menu_item, False)
# verify instance is enabled with xform selected
omni.usd.get_context().get_selection().set_selected_prim_paths(['/Sphere'], True)
await ui_test.human_delay()
await verify_menu_item_greyed(tester, menu_item, True)
# use menu
await ui_test.menu_click("Edit/Duplicate - All Layers")
# verify prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Sphere', '/Sphere_01'])
async def edit_test_func_edit_duplicate___collapsed(tester, menu_item: MenuItemDescription):
stage = omni.usd.get_context().get_stage()
# verify no prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == [])
## create prim
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Sphere")
await ui_test.human_delay()
# verify prims were created
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Sphere'])
# verify instance is grey with nothing selected
omni.usd.get_context().get_selection().set_selected_prim_paths([], True)
await verify_menu_item_greyed(tester, menu_item, False)
# verify instance is enabled with xform selected
omni.usd.get_context().get_selection().set_selected_prim_paths(['/Sphere'], True)
await ui_test.human_delay()
await verify_menu_item_greyed(tester, menu_item, True)
# use menu
await ui_test.menu_click("Edit/Duplicate - Collapsed")
# verify prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Sphere', '/Sphere_01'])
async def edit_test_func_edit_parent(tester, menu_item: MenuItemDescription):
stage = omni.usd.get_context().get_stage()
# verify no prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == [])
## create prim
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Sphere")
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Xform")
await ui_test.human_delay()
# verify prims were created
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Sphere', '/Xform'])
# verify instance is grey with nothing selected
omni.usd.get_context().get_selection().set_selected_prim_paths([], True)
await verify_menu_item_greyed(tester, menu_item, False)
# verify instance is grey with sphere selected
omni.usd.get_context().get_selection().set_selected_prim_paths(['/Sphere'], True)
await ui_test.human_delay()
await verify_menu_item_greyed(tester, menu_item, False)
# verify parent is enabled with prims selected
omni.usd.get_context().get_selection().set_selected_prim_paths(['/Sphere', '/Xform'], True)
await ui_test.human_delay()
await verify_menu_item_greyed(tester, menu_item, True)
# use menu
await ui_test.menu_click("Edit/Parent")
# verify prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Xform', '/Xform/Sphere'])
async def edit_test_hotkey_func_edit_parent(tester, menu_item: MenuItemDescription):
stage = omni.usd.get_context().get_stage()
# verify no prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == [])
## create prim
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Sphere")
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Xform")
await ui_test.human_delay()
# verify prims were created
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Sphere', '/Xform'])
# select prims
omni.usd.get_context().get_selection().set_selected_prim_paths(['/Sphere', '/Xform'], True)
await ui_test.human_delay()
await verify_menu_item_greyed(tester, menu_item, True)
# hotkey
await ui_test.emulate_keyboard_press(menu_item.hotkey[1], menu_item.hotkey[0])
# verify prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Xform', '/Xform/Sphere'])
async def edit_test_func_edit_unparent(tester, menu_item: MenuItemDescription):
stage = omni.usd.get_context().get_stage()
await edit_test_func_edit_parent(tester, "Parent")
# verify unparent is enabled with prims selected
omni.usd.get_context().get_selection().set_selected_prim_paths(['/Xform/Sphere'], True)
await ui_test.human_delay()
await verify_menu_item_greyed(tester, menu_item, True)
# use menu
await ui_test.menu_click("Edit/Unparent")
# verify prims
prim_list = tester.get_stage_prims()
tester.assertEqual(set(prim_list), set(['/Sphere', '/Xform']))
async def edit_test_hotkey_func_edit_unparent(tester, menu_item: MenuItemDescription):
stage = omni.usd.get_context().get_stage()
await edit_test_func_edit_parent(tester, "Parent")
# verify unparent is enabled with prims selected
omni.usd.get_context().get_selection().set_selected_prim_paths(['/Xform/Sphere'], True)
await ui_test.human_delay()
await verify_menu_item_greyed(tester, menu_item, True)
# hotkey
await ui_test.emulate_keyboard_press(menu_item.hotkey[1], menu_item.hotkey[0])
# verify prims
prim_list = tester.get_stage_prims()
tester.assertEqual(set(prim_list), set(['/Sphere', '/Xform']))
async def edit_test_func_edit_group(tester, menu_item: MenuItemDescription):
stage = omni.usd.get_context().get_stage()
# verify no prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == [])
## create prim
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Sphere")
await ui_test.human_delay()
# verify prims were created
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Sphere'])
# verify group is grey with nothing selected
omni.usd.get_context().get_selection().set_selected_prim_paths([], True)
await verify_menu_item_greyed(tester, menu_item, False)
# verify group is enabled with xform selected
omni.usd.get_context().get_selection().set_selected_prim_paths(['/Sphere'], True)
await ui_test.human_delay()
await verify_menu_item_greyed(tester, menu_item, True)
# use menu
await ui_test.menu_click("Edit/Group")
# verify prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Group', '/Group/Sphere'])
# verify you cannot group DefaultPrim
omni.kit.undo.undo()
await ui_test.human_delay()
## create default prim
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_path="/World", prim_type="Scope")
await ui_test.human_delay()
prim = stage.GetPrimAtPath("/World")
stage.SetDefaultPrim(prim)
# verify prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Sphere', '/World'])
# group prims
omni.usd.get_context().get_selection().set_selected_prim_paths(['/Sphere', '/World'], True)
await ui_test.human_delay()
await verify_menu_item_greyed(tester, menu_item, True)
await ui_test.menu_click("Edit/Group")
# verify prims were not grouped
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Sphere', '/World'])
async def edit_test_hotkey_func_edit_group(tester, menu_item: MenuItemDescription):
stage = omni.usd.get_context().get_stage()
# verify no prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == [])
## create prim
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Sphere")
await ui_test.human_delay()
# verify prims were created
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Sphere'])
# select prims
omni.usd.get_context().get_selection().set_selected_prim_paths(['/Sphere'], True)
await ui_test.human_delay()
# hotkey
await ui_test.emulate_keyboard_press(menu_item.hotkey[1], menu_item.hotkey[0])
# verify prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Group', '/Group/Sphere'])
# verify you cannot group DefaultPrim
omni.kit.undo.undo()
await ui_test.human_delay()
## create default prim
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_path="/World", prim_type="Scope")
await ui_test.human_delay()
prim = stage.GetPrimAtPath("/World")
stage.SetDefaultPrim(prim)
# verify prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Sphere', '/World'])
# group prims
omni.usd.get_context().get_selection().set_selected_prim_paths(['/Sphere', '/World'], True)
await ui_test.human_delay()
# hotkey
await ui_test.emulate_keyboard_press(menu_item.hotkey[1], menu_item.hotkey[0])
# verify prims were not grouped
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Sphere', '/World'])
async def edit_test_func_edit_ungroup(tester, menu_item: MenuItemDescription):
stage = omni.usd.get_context().get_stage()
# verify no prims
prim_list = tester.get_stage_prims()
tester.assertEqual(prim_list, [])
## create prim
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Sphere")
await ui_test.human_delay()
# verify prims were created
prim_list = tester.get_stage_prims()
tester.assertEqual(prim_list, ['/Sphere'])
# verify ungroup is grey with nothing selected
omni.usd.get_context().get_selection().set_selected_prim_paths([], True)
await verify_menu_item_greyed(tester, menu_item, False)
# verify group is enabled with xform selected
omni.usd.get_context().get_selection().set_selected_prim_paths(['/Sphere'], True)
await ui_test.human_delay()
await verify_menu_item_greyed(tester, menu_item, True)
# use menu
await ui_test.menu_click("Edit/Group")
# verify prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Group', '/Group/Sphere'])
# verify ungroup is enabled with sphere selected
omni.usd.get_context().get_selection().set_selected_prim_paths(['/Group/Sphere'], True)
await ui_test.human_delay()
await verify_menu_item_greyed(tester, menu_item, True)
# ungroup prims
await verify_menu_item_greyed(tester, menu_item, True)
await ui_test.menu_click("Edit/Ungroup")
# verify prim are ungrouped
prim_list = tester.get_stage_prims()
tester.assertEqual(prim_list, ['/Sphere'])
async def edit_test_func_edit_toggle_visibility(tester, menu_item: MenuItemDescription):
stage = omni.usd.get_context().get_stage()
# verify no prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == [])
## create prim
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Sphere")
await ui_test.human_delay()
# verify prims were created
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Sphere'])
# verify instance is grey with nothing selected
omni.usd.get_context().get_selection().set_selected_prim_paths([], True)
await verify_menu_item_greyed(tester, menu_item, False)
# verify instance is enabled with xform selected
omni.usd.get_context().get_selection().set_selected_prim_paths(['/Sphere'], True)
await ui_test.human_delay()
await verify_menu_item_greyed(tester, menu_item, True)
# verify prim inherited
tester.assertTrue(UsdGeom.Imageable(stage.GetPrimAtPath("/Sphere")).ComputeVisibility() == UsdGeom.Tokens.inherited)
# use menu
await ui_test.menu_click("Edit/Toggle Visibility")
# verify prim invisible
tester.assertTrue(UsdGeom.Imageable(stage.GetPrimAtPath("/Sphere")).ComputeVisibility() == UsdGeom.Tokens.invisible)
# use menu
await ui_test.menu_click("Edit/Toggle Visibility")
# verify prim inherited
tester.assertTrue(UsdGeom.Imageable(stage.GetPrimAtPath("/Sphere")).ComputeVisibility() == UsdGeom.Tokens.inherited)
async def edit_test_hotkey_func_edit_toggle_visibility(tester, menu_item: MenuItemDescription):
stage = omni.usd.get_context().get_stage()
# verify no prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == [])
## create prim
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Sphere")
await ui_test.human_delay()
# verify prims were created
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Sphere'])
# select prim
omni.usd.get_context().get_selection().set_selected_prim_paths(['/Sphere'], True)
await ui_test.human_delay()
# verify prim inherited
tester.assertTrue(UsdGeom.Imageable(stage.GetPrimAtPath("/Sphere")).ComputeVisibility() == UsdGeom.Tokens.inherited)
# hotkey
await ui_test.emulate_keyboard_press(menu_item.hotkey[1], menu_item.hotkey[0])
# verify prim invisible
tester.assertTrue(UsdGeom.Imageable(stage.GetPrimAtPath("/Sphere")).ComputeVisibility() == UsdGeom.Tokens.invisible)
# hotkey
await ui_test.emulate_keyboard_press(menu_item.hotkey[1], menu_item.hotkey[0])
# verify prim inherited
tester.assertTrue(UsdGeom.Imageable(stage.GetPrimAtPath("/Sphere")).ComputeVisibility() == UsdGeom.Tokens.inherited)
async def edit_test_func_edit_delete(tester, menu_item: MenuItemDescription):
stage = omni.usd.get_context().get_stage()
# verify no prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == [])
## create prim
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Sphere")
await ui_test.human_delay()
# verify prims were created
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Sphere'])
# verify instance is grey with nothing selected
omni.usd.get_context().get_selection().set_selected_prim_paths([], True)
await verify_menu_item_greyed(tester, menu_item, False)
# verify instance is enabled with xform selected
omni.usd.get_context().get_selection().set_selected_prim_paths(['/Sphere'], True)
await ui_test.human_delay()
await verify_menu_item_greyed(tester, menu_item, True)
# use menu
await ui_test.menu_click("Edit/Delete")
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == [])
async def edit_test_func_edit_delete___all_layers(tester, menu_item: MenuItemDescription):
stage = omni.usd.get_context().get_stage()
# verify no prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == [])
## create prim
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Sphere")
await ui_test.human_delay()
# verify prims were created
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Sphere'])
# verify instance is grey with nothing selected
omni.usd.get_context().get_selection().set_selected_prim_paths([], True)
await verify_menu_item_greyed(tester, menu_item, False)
# verify instance is enabled with xform selected
omni.usd.get_context().get_selection().set_selected_prim_paths(['/Sphere'], True)
await ui_test.human_delay()
await verify_menu_item_greyed(tester, menu_item, True)
# use menu
await ui_test.menu_click("Edit/Delete - All Layers")
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == [])
async def edit_test_hotkey_func_edit_delete(tester, menu_item: MenuItemDescription):
stage = omni.usd.get_context().get_stage()
# verify no prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == [])
## create prim
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Sphere")
await ui_test.human_delay()
# verify prims were created
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Sphere'])
# selected prim
omni.usd.get_context().get_selection().set_selected_prim_paths(['/Sphere'], True)
await ui_test.human_delay()
# hotkey
await ui_test.emulate_keyboard_press(menu_item.hotkey[1], menu_item.hotkey[0])
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == [])
async def edit_test_func_edit_rename(tester, menu_item: MenuItemDescription):
stage = omni.usd.get_context().get_stage()
# verify no prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == [])
## create prim
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Sphere")
await ui_test.human_delay()
# verify prims were created
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Sphere'])
# verify instance is grey with nothing selected
omni.usd.get_context().get_selection().set_selected_prim_paths([], True)
await verify_menu_item_greyed(tester, menu_item, False)
# verify instance is enabled with xform selected
omni.usd.get_context().get_selection().set_selected_prim_paths(['/Sphere'], True)
await ui_test.human_delay()
await verify_menu_item_greyed(tester, menu_item, True)
# use menu
await ui_test.menu_click("Edit/Rename")
await ui_test.human_delay()
widget = ui_test.find("Rename Sphere###context_menu_rename//Frame/**/StringField[*]")
await widget.click(double=True)
await ui_test.human_delay()
await ui_test.emulate_keyboard_press(KeyboardInput.DEL)
await ui_test.human_delay()
await ui_test.emulate_char_press("MyPrim")
await ui_test.human_delay()
await ui_test.emulate_keyboard_press(KeyboardInput.ENTER)
await ui_test.human_delay()
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/MyPrim'])
# again with bad characters
await ui_test.menu_click("Edit/Rename")
await ui_test.human_delay()
widget = ui_test.find("Rename Sphere###context_menu_rename//Frame/**/StringField[*]")
await widget.click(double=True)
await ui_test.human_delay()
await ui_test.emulate_keyboard_press(KeyboardInput.DEL)
await ui_test.human_delay()
await ui_test.emulate_char_press("MyPrim@@@xx/1")
await ui_test.human_delay()
await ui_test.emulate_keyboard_press(KeyboardInput.ENTER)
await ui_test.human_delay()
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/MyPrim___xx_1'])
async def edit_test_hotkey_func_edit_rename(tester, menu_item: MenuItemDescription):
stage = omni.usd.get_context().get_stage()
# verify no prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == [])
## create prim
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Sphere")
await ui_test.human_delay()
# verify prims were created
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Sphere'])
# select prim
omni.usd.get_context().get_selection().set_selected_prim_paths(['/Sphere'], True)
# hotkey
await ui_test.emulate_keyboard_press(menu_item.hotkey[1], menu_item.hotkey[0])
await ui_test.human_delay()
widget = ui_test.find("Rename Sphere###context_menu_rename//Frame/**/StringField[*]")
await widget.click(double=True)
await ui_test.human_delay()
await ui_test.emulate_keyboard_press(KeyboardInput.DEL)
await ui_test.human_delay()
await ui_test.emulate_char_press("MyPrim")
await ui_test.human_delay()
await ui_test.emulate_keyboard_press(KeyboardInput.ENTER)
await ui_test.human_delay()
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/MyPrim'])
async def edit_test_func_edit_hide_unselected(tester, menu_item: MenuItemDescription):
stage = omni.usd.get_context().get_stage()
# verify no prims
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == [])
## create prim
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Sphere")
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Cube")
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Xform")
await ui_test.human_delay()
# verify prims were created
prim_list = tester.get_stage_prims()
tester.assertTrue(prim_list == ['/Sphere', '/Cube', '/Xform'])
# verify prim invisible
tester.assertTrue(UsdGeom.Imageable(stage.GetPrimAtPath("/Sphere")).ComputeVisibility() == UsdGeom.Tokens.inherited)
tester.assertTrue(UsdGeom.Imageable(stage.GetPrimAtPath("/Cube")).ComputeVisibility() == UsdGeom.Tokens.inherited)
tester.assertTrue(UsdGeom.Imageable(stage.GetPrimAtPath("/Xform")).ComputeVisibility() == UsdGeom.Tokens.inherited)
# select prims
omni.usd.get_context().get_selection().set_selected_prim_paths(['/Cube'], True)
# use menu
await ui_test.menu_click("Edit/Hide Unselected")
# verify prims
tester.assertTrue(UsdGeom.Imageable(stage.GetPrimAtPath("/Sphere")).ComputeVisibility() == UsdGeom.Tokens.invisible)
tester.assertTrue(UsdGeom.Imageable(stage.GetPrimAtPath("/Cube")).ComputeVisibility() == UsdGeom.Tokens.inherited)
tester.assertTrue(UsdGeom.Imageable(stage.GetPrimAtPath("/Xform")).ComputeVisibility() == UsdGeom.Tokens.invisible)
async def edit_test_func_edit_unhide_all(tester, menu_item: MenuItemDescription):
stage = omni.usd.get_context().get_stage()
await edit_test_func_edit_hide_unselected(tester, None)
# use menu
await ui_test.menu_click("Edit/Unhide All")
# verify prims
tester.assertTrue(UsdGeom.Imageable(stage.GetPrimAtPath("/Sphere")).ComputeVisibility() == UsdGeom.Tokens.inherited)
tester.assertTrue(UsdGeom.Imageable(stage.GetPrimAtPath("/Cube")).ComputeVisibility() == UsdGeom.Tokens.inherited)
tester.assertTrue(UsdGeom.Imageable(stage.GetPrimAtPath("/Xform")).ComputeVisibility() == UsdGeom.Tokens.inherited)
| 27,409 | Python | 34.45925 | 120 | 0.690175 |
omniverse-code/kit/exts/omni.kit.menu.edit/docs/CHANGELOG.md | # Changelog
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
## [1.1.6] - 2022-11-29
### Changes
- Don't allow grouping of default prim
## [1.1.5] - 2022-07-28
### Changes
- Don't filter frame-command based on selection.
## [1.1.4] - 2022-07-27
### Changes
- Fix unparent regression.
## [1.1.3] - 2022-07-19
### Changes
- Disabled contextual greying of menu items
## [1.1.2] - 2022-07-08
### Added
- Hidden item for toggling Grid visibility
## [1.1.1] - 2022-06-27
### Changes
- Fixed HideUnselected & UnhideAllPrims
- Fixed menu_rename_prim_dialog
- Fixed recent menu updating
## [1.1.0] - 2022-06-08
### Changes
- Updated menus to use actions
## [1.0.8] - 2022-06-05
### Changes
- Pass tests on either Viewport
## [1.0.7] - 2022-05-24
### Changes
- Removed undo/redo greying. Menu items are always enabled
## [1.0.6] - 2022-05-23
### Changes
- Support legacy and new Viewport API
- Add dependency on omni.kit.viewport.utility
## [1.0.5] - 2021-10-27
### Changes
- Set menus default order
## [1.0.4] - 2021-10-27
### Changes
- Prevent crash in event callback
## [1.0.3] - 2021-06-11
### Changes
- Add auto-authoring mode support
## [1.0.2] - 2021-05-12
### Changes
- Added more select options
## [1.0.1] - 2021-03-15
### Changes
- Added prim parent/unparent
## [1.0.0] - 2020-12-15
### Changes
- Created
| 1,354 | Markdown | 18.084507 | 80 | 0.65288 |
omniverse-code/kit/exts/omni.kit.menu.edit/docs/index.rst | omni.kit.menu.edit
###########################
Edit Menu
.. toctree::
:maxdepth: 1
CHANGELOG
| 107 | reStructuredText | 6.2 | 27 | 0.448598 |
omniverse-code/kit/exts/omni.kit.usd.layers/config/extension.toml | [package]
version = "2.0.11"
title = "Layers Core"
description = "Layers core that extends vanilla USD and provides utilities and workflows around layers."
authors = ["NVIDIA"]
repository = ""
readme = "docs/README.md"
keywords = ["core", "layers", "usd"]
changelog = "docs/CHANGELOG.md"
icon = "data/icon.png"
[[python.module]]
name = "omni.kit.usd.layers"
[[native.plugin]]
path = "bin/*.plugin"
recursive = false
[dependencies]
"omni.usd" = {}
"omni.usd.libs" = {}
"omni.client" = {}
"omni.kit.commands" = {}
"omni.kit.collaboration.channel_manager" = {}
[[test]]
args = [
"--/app/asyncRendering=false",
"--/app/window/dpiScaleOverride=1.0",
"--/app/window/scaleToMonitor=false",
"--/persistent/app/stage/dragDropImport='reference'",
"--/persistent/app/material/dragDropMaterialPath='absolute'",
"--no-window"
]
dependencies = []
stdoutFailPatterns.include = []
stdoutFailPatterns.exclude = [
"*Cannot create session*",
"*Cannot join session*"
]
[settings]
exts."omni.kit.usd.layers".enable_server_tests = false
| 1,054 | TOML | 22.444444 | 104 | 0.674573 |
omniverse-code/kit/exts/omni.kit.usd.layers/omni/kit/usd/layers/tests/test_workflow_specs_locking.py | import asyncio
import carb
import os
import tempfile
import omni.kit.test
import omni.usd
import omni.client
from pxr import Sdf, Usd, UsdGeom, Gf
from omni.kit.usd.layers import get_layers, LayerUtils, get_layer_event_payload, LayerEventType
class TestSpecsLocking(omni.kit.test.AsyncTestCase):
# Before running each test
async def setUp(self):
self.usd_context = omni.usd.get_context()
await omni.usd.get_context().new_stage_async()
async def tearDown(self):
if omni.usd.get_context().get_stage():
await omni.usd.get_context().close_stage_async()
def __get_all_property_paths(self, prim):
paths = []
for p in prim.GetProperties():
paths.append(str(p.GetPath()))
return paths
def __get_all_prim_childrens(self, prim, hierarchy=False):
paths = [str(prim.GetPath())]
paths.extend(self.__get_all_property_paths(prim))
if hierarchy:
for child in prim.GetAllPrimChildren():
paths.append(str(child.GetPath()))
paths.extend(self.__get_all_property_paths(child))
return paths
def __get_all_stage_paths(self, stage):
paths = []
for prim in stage.TraverseAll():
paths.extend(self.__get_all_prim_childrens(prim))
return paths
async def test_lock_unlock_specs_and_events(self):
layers = get_layers()
specs_locking = layers.get_specs_locking()
event_stream = layers.get_event_stream()
payload = None
def _on_layer_event(event: carb.events.IEvent):
nonlocal payload
temp = get_layer_event_payload(event)
if temp.event_type == LayerEventType.SPECS_LOCKING_CHANGED:
payload = temp
subscription = event_stream.create_subscription_to_pop(_on_layer_event, name="layer events")
context = omni.usd.get_context()
stage = context.get_stage()
root_layer = stage.GetRootLayer()
layer0 = Sdf.Layer.CreateAnonymous()
layer1 = Sdf.Layer.CreateAnonymous()
root_layer.subLayerPaths.append(layer0.identifier)
root_layer.subLayerPaths.append(layer1.identifier)
asset_name = f"/root/test0/l1/l2/l3"
asset_prim = stage.DefinePrim(asset_name, "Xform")
UsdGeom.XformCommonAPI(asset_prim).SetTranslate(Gf.Vec3d(1.0))
all_spec_paths = set(self.__get_all_stage_paths(stage))
# Lock all
locked_paths = specs_locking.lock_spec("/", hierarchy=True)
self.assertEqual(set(locked_paths), set(all_spec_paths))
self.assertIsNotNone(payload)
self.assertEqual(payload.event_type, LayerEventType.SPECS_LOCKING_CHANGED)
self.assertEqual(set(payload.identifiers_or_spec_paths), set(all_spec_paths))
all_locked_paths = specs_locking.get_all_locked_specs()
self.assertEqual(set(all_locked_paths), set(all_spec_paths))
payload = None
unlocked_paths = specs_locking.unlock_spec("/", hierarchy=True)
self.assertEqual(set(unlocked_paths), set(locked_paths))
self.assertIsNotNone(payload)
self.assertEqual(payload.event_type, LayerEventType.SPECS_LOCKING_CHANGED)
self.assertEqual(set(payload.identifiers_or_spec_paths), set(locked_paths))
locked_paths = specs_locking.lock_spec("/root/test0", hierarchy=True)
specs_locking.unlock_all_specs()
all_unlocked_paths = specs_locking.get_all_locked_specs()
self.assertEqual(len(all_unlocked_paths), 0)
payload = None
locked_paths = specs_locking.lock_spec("/root", hierarchy=False)
self.assertEqual(locked_paths, ["/root"])
self.assertTrue(specs_locking.is_spec_locked("/root"))
self.assertFalse(specs_locking.is_spec_locked("/root/test0"))
self.assertIsNotNone(payload)
self.assertEqual(payload.event_type, LayerEventType.SPECS_LOCKING_CHANGED)
self.assertEqual(set(payload.identifiers_or_spec_paths), set(["/root"]))
payload = None
specs_locking.unlock_all_specs()
lock_single_attribute = asset_name + ".xformOp:translate"
attributes = specs_locking.lock_spec(lock_single_attribute, False)
self.assertEqual(set(attributes), set([lock_single_attribute]))
self.assertIsNotNone(payload)
self.assertEqual(payload.event_type, LayerEventType.SPECS_LOCKING_CHANGED)
self.assertEqual(set(payload.identifiers_or_spec_paths), set([lock_single_attribute]))
async def _try_to_edit_translate(self, xform_api, new_value, expected_value):
xform_api.SetTranslate(new_value)
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
xform_vectors = xform_api.GetXformVectors(Usd.TimeCode.Default())
self.assertEqual(xform_vectors[0], expected_value)
async def test_specs_locking_for_stage_edits(self):
layers = get_layers()
specs_locking = layers.get_specs_locking()
context = omni.usd.get_context()
root_layer = Sdf.Layer.CreateAnonymous()
stage = Usd.Stage.Open(root_layer)
# Initialize a prim and its translation
asset_name = f"/l3"
asset_prim = stage.DefinePrim(asset_name, "Xform")
xform_api = UsdGeom.XformCommonAPI(asset_prim)
# It can be changed if it's not locked.
await self._try_to_edit_translate(xform_api, Gf.Vec3d(1.0), Gf.Vec3d(1.0))
await context.attach_stage_async(stage)
layer0 = Sdf.Layer.CreateAnonymous()
root_layer.subLayerPaths.append(layer0.identifier)
locked_attribute = asset_name + ".xformOp:translate"
attributes = specs_locking.lock_spec(locked_attribute, False)
self.assertEqual(set(attributes), set([locked_attribute]))
await omni.kit.app.get_app().next_update_async()
# Try to modify translate will return to state before it's locked.
await self._try_to_edit_translate(xform_api, Gf.Vec3d(2.0), Gf.Vec3d(1.0))
# Try to modify translate to other sublayers will return to it's previous state also.
session_layer = stage.GetSessionLayer()
with Usd.EditContext(stage, session_layer):
await self._try_to_edit_translate(xform_api, Gf.Vec3d(2.0), Gf.Vec3d(1.0))
self.assertFalse(session_layer.GetPrimAtPath(locked_attribute))
self.assertFalse(session_layer.GetPrimAtPath(asset_name + ".xformOpOrder"))
with Usd.EditContext(stage, layer0):
await self._try_to_edit_translate(xform_api, Gf.Vec3d(2.0), Gf.Vec3d(1.0))
self.assertFalse(session_layer.GetPrimAtPath(locked_attribute))
self.assertFalse(session_layer.GetPrimAtPath(asset_name + ".xformOpOrder"))
async def add_reference_and_check(prim, identifier, expected):
prim.GetReferences().AddReference(identifier)
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
ref_and_layers = omni.usd.get_composed_references_from_prim(prim)
self.assertEqual(len(ref_and_layers), len(expected))
identifiers = [item[0].assetPath for item in ref_and_layers]
self.assertEqual(set(identifiers), set(expected))
# Locks whole prim and try to add reference
specs_locking.lock_spec(asset_name, True)
layer1 = Sdf.Layer.CreateAnonymous()
await add_reference_and_check(asset_prim, layer1.identifier, [])
# Unlock and see
attributes = specs_locking.unlock_spec(asset_name, False)
await add_reference_and_check(asset_prim, layer1.identifier, [layer1.identifier])
# Lock add and add another
layer2 = Sdf.Layer.CreateAnonymous()
attributes = specs_locking.lock_spec(asset_name, False)
await add_reference_and_check(asset_prim, layer2.identifier, [layer1.identifier])
| 7,976 | Python | 41.887097 | 100 | 0.659353 |
omniverse-code/kit/exts/omni.kit.usd.layers/omni/kit/usd/layers/tests/test_workflow_auto_authoring.py | import asyncio
from enum import auto
import carb
import os
import tempfile
import omni.kit.test
import omni.usd
import omni.client
from pxr import Sdf, Usd, UsdGeom, Gf
from omni.kit.usd.layers import get_layers, LayerUtils, get_layer_event_payload, LayerEventType, LayerEditMode
class TestAutoAuthoring(omni.kit.test.AsyncTestCase):
# Before running each test
async def setUp(self):
self.usd_context = omni.usd.get_context()
await omni.usd.get_context().new_stage_async()
async def tearDown(self):
if omni.usd.get_context().get_stage():
await omni.usd.get_context().close_stage_async()
async def test_edit_mode_switch(self):
layers = get_layers()
auto_authoring = layers.get_auto_authoring()
event_stream = layers.get_event_stream()
payload = None
def _on_layer_event(event: carb.events.IEvent):
nonlocal payload
temp = get_layer_event_payload(event)
if temp.event_type == LayerEventType.DEFAULT_LAYER_CHANGED:
payload = temp
subscription = event_stream.create_subscription_to_pop(_on_layer_event, name="layer events")
stage = self.usd_context.get_stage()
root_layer = stage.GetRootLayer()
layers.set_edit_mode(LayerEditMode.NORMAL)
self.assertEqual(layers.get_edit_mode(), LayerEditMode.NORMAL)
layers.set_edit_mode(LayerEditMode.AUTO_AUTHORING)
self.assertTrue(auto_authoring.is_enabled())
self.assertEqual(layers.get_edit_mode(), LayerEditMode.AUTO_AUTHORING)
self.assertEqual(auto_authoring.get_default_layer(), root_layer.identifier)
auto_authoring.set_default_layer(stage.GetSessionLayer().identifier)
# It cannot set session layer as edit layer.
self.assertEqual(auto_authoring.get_default_layer(), root_layer.identifier)
layer0 = Sdf.Layer.CreateAnonymous()
root_layer.subLayerPaths.append(layer0.identifier)
auto_authoring.set_default_layer(layer0.identifier)
self.assertEqual(auto_authoring.get_default_layer(), layer0.identifier)
# Set invalid edit layer will switch it to root layer
auto_authoring.set_default_layer("invalid_identifier.usd")
self.assertEqual(auto_authoring.get_default_layer(), layer0.identifier)
# Try to change edit target will fail
LayerUtils.set_edit_target(stage, root_layer.identifier)
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
edit_target_identifier = LayerUtils.get_edit_target(stage)
self.assertNotEqual(LayerUtils.get_edit_target(stage), root_layer.identifier)
self.assertIn("__DELTA_LAYER__", edit_target_identifier)
# Switch from no deltas mode to authoring mode will keep the current edit layer as edit target.
auto_authoring.set_default_layer(root_layer.identifier)
payload = None
auto_authoring.set_default_layer(layer0.identifier)
self.assertIsNotNone(payload)
self.assertEqual(payload.event_type, LayerEventType.DEFAULT_LAYER_CHANGED)
self.assertEqual(layer0.identifier, auto_authoring.get_default_layer())
layers.set_edit_mode(LayerEditMode.NORMAL)
self.assertEqual(layers.get_edit_mode(), LayerEditMode.NORMAL)
self.assertEqual(LayerUtils.get_edit_target(stage), layer0.identifier)
async def _wait(self):
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
async def test_deltas_merge_under_auto_authoring_mode(self):
layers = get_layers()
auto_authoring = layers.get_auto_authoring()
stage = self.usd_context.get_stage()
root = stage.GetRootLayer()
layer0 = Sdf.Layer.CreateAnonymous()
layer1 = Sdf.Layer.CreateAnonymous()
layer2 = Sdf.Layer.CreateAnonymous()
root.subLayerPaths.append(layer0.identifier)
root.subLayerPaths.append(layer1.identifier)
root.subLayerPaths.append(layer2.identifier)
translation = Gf.Vec3d(0.0, 0.0, 0.0)
rotation = Gf.Vec3f(0.0, 0.0, 0.0)
scale = Gf.Vec3f(1.0, 1.0, 1.0)
layers.set_edit_mode(LayerEditMode.NORMAL)
LayerUtils.set_edit_target(stage, layer1.identifier)
cube_prim = UsdGeom.Cube.Define(stage, "/cube")
UsdGeom.XformCommonAPI(cube_prim).SetTranslate(translation)
UsdGeom.XformCommonAPI(cube_prim).SetRotate(rotation)
UsdGeom.XformCommonAPI(cube_prim).SetScale(scale)
LayerUtils.set_edit_target(stage, layer2.identifier)
sphere_prim = UsdGeom.Sphere.Define(stage, "/sphere")
UsdGeom.XformCommonAPI(sphere_prim).SetTranslate(translation)
UsdGeom.XformCommonAPI(sphere_prim).SetRotate(rotation)
UsdGeom.XformCommonAPI(sphere_prim).SetScale(scale)
layers.set_edit_mode(LayerEditMode.AUTO_AUTHORING)
LayerUtils.set_edit_target(stage, layer0.identifier)
# It needs to wait for at least one frame so that it will not allow to change edit target.
await self._wait()
auto_authoring.set_default_layer(layer0.identifier)
translate = Gf.Vec3d(100.0, 100.0, 100.0)
UsdGeom.XformCommonAPI(cube_prim).SetTranslate(translate)
UsdGeom.XformCommonAPI(sphere_prim).SetTranslate(translate * 2)
await self._wait()
xform_vectors = UsdGeom.XformCommonAPI(cube_prim).GetXformVectors(Usd.TimeCode.Default())
self.assertFalse(layer0.GetPrimAtPath(cube_prim.GetPath()))
self.assertEqual(xform_vectors[0], translate)
# Make sure the authoring is merged
translate_property_path = cube_prim.GetPath().AppendProperty("xformOp:translate")
translate_property = layer1.GetPropertyAtPath(translate_property_path)
self.assertTrue(translate_property)
self.assertEqual(translate_property.default, translate)
xform_vectors = UsdGeom.XformCommonAPI(sphere_prim).GetXformVectors(Usd.TimeCode.Default())
self.assertFalse(layer0.GetPrimAtPath(sphere_prim.GetPath()))
self.assertEqual(xform_vectors[0], translate * 2)
# Make sure the authoring is merged
translate_property_path = sphere_prim.GetPath().AppendProperty("xformOp:translate")
translate_property = layer2.GetPropertyAtPath(translate_property_path)
self.assertTrue(translate_property)
self.assertEqual(translate_property.default, translate * 2)
# Switches to normal authoring mode and creates deltas there for cube
layers.set_edit_mode(LayerEditMode.NORMAL)
LayerUtils.set_edit_target(stage, layer0.identifier)
translate = Gf.Vec3d(1000.0, 1000.0, 1000.0)
UsdGeom.XformCommonAPI(cube_prim).SetTranslate(translate)
xform_vectors = UsdGeom.XformCommonAPI(cube_prim).GetXformVectors(Usd.TimeCode.Default())
self.assertTrue(layer0.GetPrimAtPath(cube_prim.GetPath()))
self.assertEqual(xform_vectors[0], translate)
# Then modify cube and sphere again, this time cube movement will go into layer0 instead
# of where its defined, which sphere will still be in its define layer.
layers.set_edit_mode(LayerEditMode.AUTO_AUTHORING)
auto_authoring.set_default_layer(layer0.identifier)
translate = Gf.Vec3d(200.0, 200.0, 200.0)
UsdGeom.XformCommonAPI(cube_prim).SetTranslate(translate)
UsdGeom.XformCommonAPI(sphere_prim).SetTranslate(translate * 2)
await self._wait()
# Check layer 0
xform_vectors = UsdGeom.XformCommonAPI(cube_prim).GetXformVectors(Usd.TimeCode.Default())
self.assertTrue(layer0.GetPrimAtPath(cube_prim.GetPath()))
self.assertEqual(xform_vectors[0], translate)
# Make sure the authoring is merged
translate_property_path = cube_prim.GetPath().AppendProperty("xformOp:translate")
translate_property = layer0.GetPropertyAtPath(translate_property_path)
self.assertTrue(translate_property)
self.assertEqual(translate_property.default, translate)
xform_vectors = UsdGeom.XformCommonAPI(sphere_prim).GetXformVectors(Usd.TimeCode.Default())
self.assertFalse(layer0.GetPrimAtPath(sphere_prim.GetPath()))
self.assertEqual(xform_vectors[0], translate * 2)
# Make sure the authoring is merged
translate_property_path = sphere_prim.GetPath().AppendProperty("xformOp:translate")
translate_property = layer2.GetPropertyAtPath(translate_property_path)
self.assertTrue(translate_property)
self.assertEqual(translate_property.default, translate * 2)
async def test_new_prim_create_under_auto_authoring_mode(self):
layers = get_layers()
auto_authoring = layers.get_auto_authoring()
stage = self.usd_context.get_stage()
root = stage.GetRootLayer()
layer0 = Sdf.Layer.CreateAnonymous()
layer1 = Sdf.Layer.CreateAnonymous()
layer2 = Sdf.Layer.CreateAnonymous()
root.subLayerPaths.append(layer0.identifier)
root.subLayerPaths.append(layer1.identifier)
root.subLayerPaths.append(layer2.identifier)
layers.set_edit_mode(LayerEditMode.AUTO_AUTHORING)
auto_authoring.set_default_layer(layer1.identifier)
# Making sure that layer1 is not edit target at this moment.
self.assertNotEqual(LayerUtils.get_edit_target(stage), layer1.identifier)
all_cube_prims = []
for i in range(1000):
cube_path = f"/cube{i}"
self.assertFalse(layer1.GetPrimAtPath(cube_path))
cube_prim = UsdGeom.Cube.Define(stage, cube_path)
# It's not in layer1 even after creation until it's moved in next frame.
self.assertFalse(layer1.GetPrimAtPath(cube_path))
self.assertTrue(cube_prim)
all_cube_prims.append(cube_prim)
# It needs to wait for prims move.
await self._wait()
for i in range(len(all_cube_prims)):
cube_path = f"/cube{i}"
cube_prim = all_cube_prims[i]
prim_stack = cube_prim.GetPrim().GetPrimStack()
# The first one is the auto authoring layer
cube_prim_spec = layer1.GetPrimAtPath(cube_prim.GetPath())
self.assertTrue(cube_prim_spec)
self.assertTrue(cube_prim_spec.path, cube_path)
self.assertTrue(cube_prim_spec)
self.assertEqual(cube_prim_spec.specifier, Sdf.SpecifierDef)
self.assertEqual(cube_prim_spec.typeName, "Cube")
async def test_correct_merge_layer_of_spec(self):
layers = get_layers()
auto_authoring = layers.get_auto_authoring()
stage = self.usd_context.get_stage()
root = stage.GetRootLayer()
session = stage.GetSessionLayer()
layer0 = Sdf.Layer.CreateAnonymous()
layer1 = Sdf.Layer.CreateAnonymous()
root.subLayerPaths.append(layer0.identifier)
root.subLayerPaths.append(layer1.identifier)
layers.set_edit_mode(LayerEditMode.AUTO_AUTHORING)
auto_authoring.set_default_layer(layer1.identifier)
# Making sure that layer1 is not edit target at this moment.
self.assertNotEqual(LayerUtils.get_edit_target(stage), layer1.identifier)
cube_path = f"/cube0"
with Usd.EditContext(stage, layer1):
cube_prim = UsdGeom.Cube.Define(stage, cube_path)
self.assertFalse(layer0.GetPrimAtPath(cube_path))
self.assertTrue(cube_prim)
# Authoring to auto authoring layer.
UsdGeom.XformCommonAPI(cube_prim.GetPrim()).SetTranslate(Gf.Vec3d(200.0, 200.0, 200.0))
await self._wait()
xform_vectors = UsdGeom.XformCommonAPI(cube_prim.GetPrim()).GetXformVectors(Usd.TimeCode.Default())
self.assertEqual(xform_vectors[0], Gf.Vec3d(200.0, 200.0, 200.0))
self.assertFalse(layer0.GetPrimAtPath(cube_path))
self.assertFalse(root.GetPrimAtPath(cube_path))
self.assertFalse(session.GetPrimAtPath(cube_path))
# Switch to normal mode to make sure it's saved to layer1.
layers.set_edit_mode(LayerEditMode.NORMAL)
xform_vectors = UsdGeom.XformCommonAPI(cube_prim.GetPrim()).GetXformVectors(Usd.TimeCode.Default())
self.assertEqual(xform_vectors[0], Gf.Vec3d(200.0, 200.0, 200.0))
# Switch to auto authoring mode again and try to edit weaker layers under auto authoring layer.
layers.set_edit_mode(LayerEditMode.AUTO_AUTHORING)
# Create a delta for cube_prim in layer 0
with Usd.EditContext(stage, layer0):
cube_prim.GetPrim().CreateAttribute("test_property", Sdf.ValueTypeNames.Bool, False).Set(False)
# Edit the translate again and check if the translate will be merged to layer1 instead of layer0
UsdGeom.XformCommonAPI(cube_prim.GetPrim()).SetTranslate(Gf.Vec3d(400.0, 400.0, 400.0))
await self._wait()
xform_vectors = UsdGeom.XformCommonAPI(cube_prim.GetPrim()).GetXformVectors(Usd.TimeCode.Default())
self.assertEqual(xform_vectors[0], Gf.Vec3d(400.0, 400.0, 400.0))
async def test_whole_stage_refresh(self):
stage = self.usd_context.get_stage()
layers = get_layers()
root = stage.GetRootLayer()
session = stage.GetSessionLayer()
layer0 = Sdf.Layer.CreateAnonymous()
layer1 = Sdf.Layer.CreateAnonymous()
root.subLayerPaths.append(layer0.identifier)
root.subLayerPaths.append(layer1.identifier)
layers.set_edit_mode(LayerEditMode.AUTO_AUTHORING)
cube_path = f"/cube0"
with Usd.EditContext(stage, layer1):
cube_prim = UsdGeom.Cube.Define(stage, cube_path)
self.assertFalse(layer0.GetPrimAtPath(cube_path))
self.assertTrue(cube_prim)
UsdGeom.XformCommonAPI(cube_prim.GetPrim()).SetTranslate(Gf.Vec3d(100.0, 100.0, 100.0))
identifier = session.subLayerPaths[0]
auto_authoring_layer = Sdf.Find(identifier)
self.assertTrue(auto_authoring_layer)
self.assertTrue(len(auto_authoring_layer.rootPrims) == 0)
# Creates a delta to auto authoring layer
UsdGeom.XformCommonAPI(cube_prim.GetPrim()).SetTranslate(Gf.Vec3d(200.0, 200.0, 200.0))
await self._wait()
self.assertTrue(len(auto_authoring_layer.rootPrims) > 0)
# Remove layer to trigger whole stage refresh
del root.subLayerPaths[1]
await self._wait()
# After that, the auto authoring layer will be cleared.
self.assertTrue(len(auto_authoring_layer.rootPrims) == 0)
async def test_weaker_layers_authoring(self):
stage = self.usd_context.get_stage()
layers = get_layers()
auto_authoring = layers.get_auto_authoring()
root = stage.GetRootLayer()
layer0 = Sdf.Layer.CreateAnonymous()
layer1 = Sdf.Layer.CreateAnonymous()
root.subLayerPaths.append(layer0.identifier)
root.subLayerPaths.append(layer1.identifier)
layers.set_edit_mode(LayerEditMode.AUTO_AUTHORING)
auto_authoring.set_default_layer(layer1.identifier)
# Making sure that layer1 is not edit target at this moment.
self.assertNotEqual(LayerUtils.get_edit_target(stage), layer1.identifier)
cube_path = f"/cube0"
with Usd.EditContext(stage, layer1):
cube_prim = UsdGeom.Cube.Define(stage, cube_path)
self.assertFalse(layer0.GetPrimAtPath(cube_path))
self.assertTrue(cube_prim)
UsdGeom.XformCommonAPI(cube_prim.GetPrim()).SetTranslate(Gf.Vec3d(100.0, 100.0, 100.0))
self.assertEqual(self._get_xform_translate(cube_prim.GetPrim()), Gf.Vec3d(100.0, 100.0, 100.0))
# Authoring to auto authoring layer.
UsdGeom.XformCommonAPI(cube_prim.GetPrim()).SetTranslate(Gf.Vec3d(200.0, 200.0, 200.0))
await self._wait()
self.assertEqual(self._get_xform_translate(cube_prim.GetPrim()), Gf.Vec3d(200.0, 200.0, 200.0))
self.assertFalse(layer0.GetPrimAtPath(cube_path))
# Switch to normal mode to make sure it's saved back.
layers.set_edit_mode(LayerEditMode.NORMAL)
self.assertEqual(self._get_xform_translate(cube_prim.GetPrim()), Gf.Vec3d(200.0, 200.0, 200.0))
# Switch to auto authoring mode again and try to edit weaker layers under auto authoring layer.
layers.set_edit_mode(LayerEditMode.AUTO_AUTHORING)
UsdGeom.XformCommonAPI(cube_prim.GetPrim()).SetTranslate(Gf.Vec3d(400.0, 400.0, 400.0))
await self._wait()
# Edit weaker layers
with Usd.EditContext(stage, layer0):
UsdGeom.XformCommonAPI(cube_prim.GetPrim()).SetTranslate(Gf.Vec3d(300.0, 300.0, 300.0))
# Wait until it's merge back to auto authoring layer
await self._wait()
self.assertEqual(self._get_xform_translate(cube_prim.GetPrim()), Gf.Vec3d(300.0, 300.0, 300.0))
# Edit weakest layer to make sure it will not be merged back to auto authoring layer
# since layer0 is stronger.
with Usd.EditContext(stage, layer1):
UsdGeom.XformCommonAPI(cube_prim.GetPrim()).SetTranslate(Gf.Vec3d(1000.0, 1000.0, 1000.0))
await self._wait()
self.assertEqual(self._get_xform_translate(cube_prim.GetPrim()), Gf.Vec3d(300.0, 300.0, 300.0))
def _get_xform_translate(self, prim):
xform_vectors = UsdGeom.XformCommonAPI(prim).GetXformVectors(Usd.TimeCode.Default())
return xform_vectors[0]
async def test_read_only_layer_edit(self):
# Test for OM-35472
stage = self.usd_context.get_stage()
root = stage.GetRootLayer()
layers = get_layers()
layer0 = Sdf.Layer.CreateAnonymous()
root.subLayerPaths.append(layer0.identifier)
layers.set_edit_mode(LayerEditMode.AUTO_AUTHORING)
with Usd.EditContext(stage, layer0):
cube_prim = UsdGeom.Cube.Define(stage, "/world/cube")
UsdGeom.XformCommonAPI(cube_prim.GetPrim()).SetTranslate(Gf.Vec3d(1000.0, 1000.0, 1000.0))
self.assertEqual(self._get_xform_translate(cube_prim.GetPrim()), Gf.Vec3d(1000, 1000, 1000))
LayerUtils.set_layer_lock_status(root, layer0.identifier, True)
UsdGeom.XformCommonAPI(cube_prim.GetPrim()).SetTranslate(Gf.Vec3d(100.0, 100.0, 100.0))
self.assertEqual(self._get_xform_translate(cube_prim.GetPrim()), Gf.Vec3d(100, 100, 100))
# It will return back to old value since it's read-only layer
await self._wait()
self.assertEqual(self._get_xform_translate(cube_prim.GetPrim()), Gf.Vec3d(1000, 1000, 1000))
# Make sure it can be edited again
LayerUtils.set_layer_lock_status(root, layer0.identifier, False)
UsdGeom.XformCommonAPI(cube_prim.GetPrim()).SetTranslate(Gf.Vec3d(100.0, 100.0, 100.0))
self.assertEqual(self._get_xform_translate(cube_prim.GetPrim()), Gf.Vec3d(100, 100, 100))
await self._wait()
self.assertEqual(self._get_xform_translate(cube_prim.GetPrim()), Gf.Vec3d(100, 100, 100))
| 19,148 | Python | 45.933823 | 110 | 0.678086 |
omniverse-code/kit/exts/omni.kit.usd.layers/omni/kit/usd/layers/tests/test_path_utils.py | import omni.kit.test
import omni.usd
from omni.kit.usd.layers.impl.path_utils import PathUtils
class TestPathUtils(omni.kit.test.AsyncTestCase):
def test_is_omni_path(self):
path = "omniverse://test-server/invalid_path"
self.assertTrue(PathUtils.is_omni_path(path))
path = "c:/file.usd"
self.assertFalse(PathUtils.is_omni_path(path))
| 373 | Python | 27.769229 | 57 | 0.702413 |
omniverse-code/kit/exts/omni.kit.usd.layers/omni/kit/usd/layers/tests/__init__.py | from .test_layers_interface import TestLayersInterface
from .test_layers_state import TestLayersState
from .test_layer_utils import TestLayerUtils
from .test_path_utils import TestPathUtils
from .test_commands import TestUsdCommands
from .test_workflow_specs_locking import TestSpecsLocking
from .test_workflow_auto_authoring import TestAutoAuthoring
from .test_workflow_specs_linking import TestSpecsLinking
from .test_workflow_live_syncing import TestLiveSyncing
| 465 | Python | 45.599995 | 59 | 0.858065 |
omniverse-code/kit/exts/omni.kit.usd.layers/omni/kit/usd/layers/tests/test_layers_interface.py | import asyncio
import carb
import os
import tempfile
import omni.kit.test
import omni.usd
import omni.client
from omni.kit.usd.layers import get_layers, LayerEditMode, get_layer_event_payload, LayerEventType
class TestLayersInterface(omni.kit.test.AsyncTestCase):
async def setUp(self):
self.usd_context = omni.usd.get_context()
await omni.usd.get_context().new_stage_async()
async def tearDown(self):
if omni.usd.get_context().get_stage():
await omni.usd.get_context().close_stage_async()
async def test_edit_mode_switch(self):
layers = get_layers()
event_stream = layers.get_event_stream()
payload = None
def _on_layer_event(event: carb.events.IEvent):
nonlocal payload
temp = get_layer_event_payload(event)
if temp.event_type == LayerEventType.EDIT_MODE_CHANGED:
payload = temp
subscription = event_stream.create_subscription_to_pop(_on_layer_event, name="Layers Interface Tests")
self.assertEqual(layers.get_edit_mode(), LayerEditMode.NORMAL)
def change_edit_mode_and_verify(edit_mode):
nonlocal payload
payload = None
layers.set_edit_mode(edit_mode)
self.assertIsNotNone(payload)
self.assertEqual(payload.event_type, LayerEventType.EDIT_MODE_CHANGED)
self.assertEqual(layers.get_edit_mode(), edit_mode)
change_edit_mode_and_verify(LayerEditMode.AUTO_AUTHORING)
change_edit_mode_and_verify(LayerEditMode.SPECS_LINKING)
change_edit_mode_and_verify(LayerEditMode.NORMAL)
| 1,636 | Python | 33.104166 | 110 | 0.668093 |
omniverse-code/kit/exts/omni.kit.usd.layers/omni/kit/usd/layers/tests/test_workflow_live_syncing.py | import carb
import omni.kit.test
import omni.usd
import omni.client
import unittest
import omni.kit.app
from omni.kit.usd.layers import get_layers, get_layer_event_payload, LayerEventType, LayerUtils
from .test_base import enable_server_tests
from pxr import Usd, Sdf
class TestLiveSyncing(omni.kit.test.AsyncTestCase):
# Before running each test
async def setUp(self):
self.app = omni.kit.app.get_app()
self.usd_context = omni.usd.get_context()
self.layers = get_layers(self.usd_context)
await omni.usd.get_context().new_stage_async()
if enable_server_tests():
self.test_folder = "omniverse://localhost/Projects/omni.kit.usd.layers/test_live_syncing/"
await omni.client.delete_async(self.test_folder)
self.stage_url = self.test_folder + "test.usd"
self.sublayer = self.test_folder + "test2.usd"
self.sublayer2 = self.test_folder + "test3.usd"
stage = Usd.Stage.CreateNew(self.stage_url)
sublayer = Sdf.Layer.CreateNew(self.sublayer)
stage.GetRootLayer().subLayerPaths.append(self.sublayer)
await self.usd_context.attach_stage_async(stage)
self.stage = self.usd_context.get_stage()
else:
self.test_folder = ""
self.stage_url = ""
self.stage = None
async def tearDown(self):
if omni.usd.get_context().get_stage():
await omni.usd.get_context().close_stage_async()
self.stage = None
if enable_server_tests():
await omni.client.delete_async(self.test_folder)
async def wait(self, frames=10):
for i in range(frames):
await self.app.next_update_async()
async def test_other_interfaces(self):
layers = get_layers()
live_syncing = layers.get_live_syncing()
live_syncing.mute_live_session_merge_notice("omniverse://fake-test-server/a.usd")
live_syncing.mute_live_session_merge_notice("omniverse://fake-test-server/b.usd")
self.assertTrue(live_syncing.is_live_session_merge_notice_muted("omniverse://fake-test-server/a.usd"))
self.assertTrue(live_syncing.is_live_session_merge_notice_muted("omniverse://fake-test-server/b.usd"))
live_syncing.unmute_live_session_merge_notice("omniverse://fake-test-server/a.usd")
self.assertFalse(live_syncing.is_live_session_merge_notice_muted("omniverse://fake-test-server/a.usd"))
self.assertTrue(live_syncing.is_live_session_merge_notice_muted("omniverse://fake-test-server/b.usd"))
@unittest.skipIf(not enable_server_tests(), "")
async def test_join_session_with_url(self):
layers = get_layers()
live_syncing = layers.get_live_syncing()
session_url = omni.client.combine_urls(self.stage_url, ".live/test.live/customized_session.live")
self.assertFalse(live_syncing.join_live_session_by_url(self.stage_url, session_url, False))
self.assertTrue(live_syncing.join_live_session_by_url(self.stage_url, session_url, True))
current_live_session = live_syncing.get_current_live_session()
self.assertTrue(current_live_session)
self.assertTrue(live_syncing.is_stage_in_live_session())
self.assertTrue(live_syncing.is_in_live_session())
self.assertTrue(live_syncing.is_layer_in_live_session(self.stage_url))
self.assertEqual(current_live_session.name, "customized_session")
self.assertEqual(current_live_session.url, session_url)
self.assertTrue(live_syncing.get_live_session_by_url(session_url))
live_syncing.stop_all_live_sessions()
@unittest.skipIf(not enable_server_tests(), "")
async def test_session_management(self):
for layer_identifier in [self.sublayer, self.stage_url]:
await self.__test_session_management_internal(layer_identifier, False)
@unittest.skipIf(not enable_server_tests(), "")
async def test_session_management_merge_to_new_layer(self):
await self.__test_session_management_internal(self.sublayer, True)
async def __test_session_management_internal(self, sublayer_identifier, merge_to_new_layer=False):
layers = get_layers()
live_syncing = layers.get_live_syncing()
is_root_layer = sublayer_identifier == self.usd_context.get_stage_url()
event_stream = layers.get_event_stream()
payload = None
merge_started = None
merge_ended = None
def _on_layer_event(event: carb.events.IEvent):
nonlocal payload
nonlocal merge_started
nonlocal merge_ended
temp = get_layer_event_payload(event)
if temp.event_type == LayerEventType.LIVE_SESSION_LIST_CHANGED or temp.event_type == LayerEventType.LIVE_SESSION_STATE_CHANGED:
payload = temp
elif temp.event_type == LayerEventType.LIVE_SESSION_MERGE_STARTED:
merge_started = temp
elif temp.event_type == LayerEventType.LIVE_SESSION_MERGE_ENDED:
merge_ended = temp
subscription = event_stream.create_subscription_to_pop(_on_layer_event, name="layer events")
self.assertEqual(len(live_syncing.get_all_live_sessions(sublayer_identifier)), 0)
live_session = live_syncing.create_live_session("test", layer_identifier=sublayer_identifier)
self.assertTrue(live_session)
self.assertEqual(live_session.name, "test")
self.assertTrue(live_session.merge_permission)
self.assertTrue(live_session.channel_url)
self.assertTrue(live_session.url)
self.assertTrue(live_session.root)
self.assertTrue(live_session.owner)
sessions = live_syncing.get_all_live_sessions(sublayer_identifier)
self.assertEqual(len(sessions), 1)
session = sessions[0]
self.assertEqual(live_session.name, session.name)
self.assertEqual(live_session.owner, session.owner)
self.assertEqual(live_session.url, session.url)
self.assertEqual(live_session.root, session.root)
self.assertEqual(live_session.channel_url, session.channel_url)
self.assertEqual(live_session.merge_permission, session.merge_permission)
await self.wait()
self.assertTrue(payload)
self.assertEqual(payload.event_type, LayerEventType.LIVE_SESSION_LIST_CHANGED)
live_session = live_syncing.create_live_session("test", layer_identifier=sublayer_identifier)
# Create session with the same name will fail.
self.assertFalse(live_session)
# Create session with empty name will fail.
live_session = live_syncing.create_live_session("", layer_identifier=sublayer_identifier)
self.assertFalse(live_session)
live_session = live_syncing.create_live_session("test2", layer_identifier=sublayer_identifier)
sessions = live_syncing.get_all_live_sessions(sublayer_identifier)
self.assertEqual(len(sessions), 2)
live_syncing.stop_live_session(sublayer_identifier)
await self.wait()
payload = None
self.assertTrue(live_syncing.join_live_session(live_session))
current_session = live_syncing.get_current_live_session(sublayer_identifier)
self.assertTrue(current_session)
self.assertTrue(current_session.name, live_session.name)
result, server_info = await omni.client.get_server_info_async(sublayer_identifier)
self.assertTrue(result == omni.client.Result.OK)
self.assertEqual(server_info.username, current_session.logged_user_name)
self.assertEqual(server_info.connection_id, current_session.logged_user_id)
self.assertTrue(live_syncing.is_layer_in_live_session(sublayer_identifier))
if is_root_layer:
self.assertTrue(self.usd_context.is_stage_live())
self.assertEqual(self.usd_context.get_stage_live_mode(), omni.usd.StageLiveModeType.ALWAYS_ON)
await self.wait()
self.assertTrue(payload)
self.assertEqual(payload.event_type, LayerEventType.LIVE_SESSION_STATE_CHANGED)
all_sublayers = set(LayerUtils.get_all_sublayers(self.stage, is_root_layer, True, False))
all_sublayers.discard(self.stage_url)
all_sublayers.discard(self.sublayer)
all_sublayers.discard(self.sublayer2)
for sublayer in all_sublayers:
self.assertTrue(live_syncing.is_live_session_layer(sublayer))
all_sublayers = set(live_syncing.get_current_live_session_layers(sublayer_identifier))
all_sublayers.discard(self.sublayer2)
self.assertEqual(len(all_sublayers), 1)
self.assertTrue(live_syncing.is_live_session_layer(all_sublayers.pop()))
# Makes some edits
root_live_layer = Sdf.Find(current_session.root)
self.assertTrue(root_live_layer)
layer_content = """\
#usda 1.0
(
subLayers = [
@omniverse://test-ov-fake-server/fake/path/sublayers/level2/sublayer2.usd@
]
)
over "root"
{
over "test_prim" (
prepend payload = @../invalid/payload2.usd@
prepend references = @../invalid/reference2.usd@
)
{
asset[] AssetArray = [@1.usd@, @2.usd@, @OmniPBR.mdl@]
bool[] BoolArray = [0, 1]
float[] FloatArray = [1, 2, 3]
int[] IntArray = [1, 2, 3]
string[] StringArray = ["string1", "string2", "string3"]
int test = 3
asset test2 = @../../invalid/path.usd@
asset test3 = @OmniPBR.mdl@
token[] TokenArray = ["token1", "token2", "token3"]
}
}
"""
if is_root_layer:
expected_string = """
#usda 1.0
(
customLayerData = {
dictionary omni_layer = {
dictionary locked = {
bool "./test2.usd" = 0
}
}
}
metersPerUnit = 0.01
subLayers = [
@omniverse://localhost/Projects/omni.kit.usd.layers/test_live_syncing/test2.usd@
]
)
over "root"
{
over "test_prim" (
prepend payload = @./.live/test.live/invalid/payload2.usd@
prepend references = @./.live/test.live/invalid/reference2.usd@
)
{
asset[] AssetArray = [@1.usd@, @2.usd@, @OmniPBR.mdl@]
bool[] BoolArray = [0, 1]
float[] FloatArray = [1, 2, 3]
int[] IntArray = [1, 2, 3]
string[] StringArray = ["string1", "string2", "string3"]
int test = 3
asset test2 = @./.live/invalid/path.usd@
asset test3 = @OmniPBR.mdl@
token[] TokenArray = ["token1", "token2", "token3"]
}
}
"""
else:
expected_string = """
#usda 1.0
over "root"
{
over "test_prim" (
prepend payload = @./.live/test2.live/invalid/payload2.usd@
prepend references = @./.live/test2.live/invalid/reference2.usd@
)
{
asset[] AssetArray = [@1.usd@, @2.usd@, @OmniPBR.mdl@]
bool[] BoolArray = [0, 1]
float[] FloatArray = [1, 2, 3]
int[] IntArray = [1, 2, 3]
string[] StringArray = ["string1", "string2", "string3"]
int test = 3
asset test2 = @./.live/invalid/path.usd@
asset test3 = @OmniPBR.mdl@
token[] TokenArray = ["token1", "token2", "token3"]
}
}
"""
root_live_layer.ImportFromString(layer_content)
payload = None
merge_started = None
merge_ended = None
if merge_to_new_layer:
new_sublayer = Sdf.Layer.CreateNew(self.sublayer2)
live_syncing.merge_live_session_changes_to_specific_layer(sublayer_identifier, self.sublayer2, True, True)
all_sublayers = set(LayerUtils.get_all_sublayers(self.stage, False, True, False))
self.assertIn(self.sublayer2, all_sublayers)
layer_identifier = sublayer_identifier
elif is_root_layer:
live_syncing.merge_changes_to_base_layers(True)
layer_identifier = self.stage.GetRootLayer().identifier
else:
live_syncing.merge_live_session_changes(sublayer_identifier, True)
layer_identifier = sublayer_identifier
self.assertTrue(merge_started)
self.assertTrue(merge_ended)
self.assertTrue(merge_started.layer_identifier == layer_identifier)
self.assertTrue(merge_ended.layer_identifier == layer_identifier)
self.assertTrue(merge_ended.success)
current_session = live_syncing.get_current_live_session(sublayer_identifier)
self.assertFalse(current_session)
if is_root_layer:
self.assertFalse(live_syncing.is_in_live_session())
else:
self.assertFalse(live_syncing.is_layer_in_live_session(sublayer_identifier))
await self.wait()
self.assertTrue(payload)
self.assertEqual(payload.event_type, LayerEventType.LIVE_SESSION_STATE_CHANGED)
if merge_to_new_layer:
layer = Sdf.Find(self.sublayer2)
elif is_root_layer:
layer = self.stage.GetRootLayer()
else:
layer = Sdf.Find(self.sublayer)
string = layer.ExportToString()
self.assertEqual(string.strip(), expected_string.strip())
if merge_to_new_layer:
LayerUtils.remove_sublayer(self.stage.GetRootLayer(), 0)
| 13,600 | Python | 41.636364 | 139 | 0.628382 |
omniverse-code/kit/exts/omni.kit.usd.layers/omni/kit/usd/layers/tests/test_workflow_specs_linking.py | import asyncio
import carb
import os
import tempfile
import omni.kit.test
import omni.usd
import omni.client
from pxr import Sdf, Usd, UsdGeom, Gf
from omni.kit.usd.layers import get_layers, LayerUtils, get_layer_event_payload, LayerEventType, LayerEditMode
class TestSpecsLinking(omni.kit.test.AsyncTestCase):
# Before running each test
async def setUp(self):
self.usd_context = omni.usd.get_context()
await omni.usd.get_context().new_stage_async()
async def tearDown(self):
if omni.usd.get_context().get_stage():
await omni.usd.get_context().close_stage_async()
def __get_all_property_paths(self, prim):
paths = []
for p in prim.GetProperties():
paths.append(str(p.GetPath()))
return paths
def __get_all_prim_childrens(self, prim, hierarchy=False):
paths = [str(prim.GetPath())]
paths.extend(self.__get_all_property_paths(prim))
if hierarchy:
for child in prim.GetAllPrimChildren():
paths.append(str(child.GetPath()))
paths.extend(self.__get_all_property_paths(child))
return paths
def __get_all_stage_paths(self, stage):
paths = []
for prim in stage.TraverseAll():
paths.extend(self.__get_all_prim_childrens(prim))
return paths
async def test_link_specs(self):
layers = get_layers()
specs_linking = layers.get_specs_linking()
event_stream = layers.get_event_stream()
payload = None
def _on_layer_event(event: carb.events.IEvent):
nonlocal payload
temp = get_layer_event_payload(event)
if temp.event_type == LayerEventType.SPECS_LINKING_CHANGED:
payload = temp
subscription = event_stream.create_subscription_to_pop(_on_layer_event, name="layer events")
layers.set_edit_mode(LayerEditMode.SPECS_LINKING)
context = omni.usd.get_context()
stage = context.get_stage()
root_layer = stage.GetRootLayer()
layer0 = Sdf.Layer.CreateAnonymous()
layer1 = Sdf.Layer.CreateAnonymous()
layer2 = Sdf.Layer.CreateAnonymous()
root_layer.subLayerPaths.append(layer0.identifier)
root_layer.subLayerPaths.append(layer1.identifier)
root_layer.subLayerPaths.append(layer2.identifier)
asset_name = f"/root/test0/l1/l2/l3"
asset_prim = stage.DefinePrim(asset_name, "Xform")
all_spec_paths = set(self.__get_all_stage_paths(stage))
# Invalid identifier or spec path will return empty result.
paths = specs_linking.link_spec("/", "")
self.assertEqual(len(paths), 0)
self.assertIsNone(payload)
paths = specs_linking.link_spec("", layer0.identifier)
self.assertEqual(len(paths), 0)
self.assertIsNone(payload)
# Links root prim to layer0 without hierarchy, root prim cannot be linked.
paths = specs_linking.link_spec("/", layer0.identifier, hierarchy=False)
self.assertEqual(len(paths), 0)
self.assertIsNone(payload)
# Links all prims in the prim tree.
paths = specs_linking.link_spec("/", layer0.identifier, hierarchy=True)
self.assertEqual(set(paths), all_spec_paths)
self.assertIsNotNone(payload)
self.assertEqual(payload.event_type, LayerEventType.SPECS_LINKING_CHANGED)
self.assertEqual(set([layer0.identifier]), set(payload.layer_spec_paths.keys()))
self.assertEqual(set(payload.layer_spec_paths[layer0.identifier]), set(all_spec_paths))
paths = specs_linking.get_spec_layer_links("/", hierarchy=False)
self.assertEqual(len(paths), 0)
paths = specs_linking.get_spec_layer_links("/", hierarchy=True)
for path, value in paths.items():
self.assertIn(path, all_spec_paths)
self.assertEqual(len(value), 1)
self.assertEqual(value[0], layer0.identifier)
self.assertTrue(specs_linking.is_spec_linked(path, layer0.identifier))
self.assertTrue(specs_linking.is_spec_linked(path))
self.assertFalse(specs_linking.is_spec_linked(path, layer1.identifier))
# Since it's prim is already linked, add properties will not change anything.
root_translate_path = "/root.xformOp:translate"
specs_linking.link_spec(root_translate_path, layer0.identifier)
paths = specs_linking.get_spec_layer_links("/", hierarchy=True)
for path, value in paths.items():
self.assertIn(path, all_spec_paths)
self.assertEqual(len(value), 1)
self.assertEqual(value[0], layer0.identifier)
self.assertTrue(specs_linking.is_spec_linked(root_translate_path, layer0.identifier))
self.assertTrue(specs_linking.is_spec_linked(root_translate_path))
self.assertFalse(specs_linking.is_spec_linked(root_translate_path, layer1.identifier))
# Links translate
specs_linking.unlink_all_specs()
payload = None
specs_linking.link_spec(root_translate_path, layer0.identifier, hierarchy=True)
paths = specs_linking.get_all_spec_links()
prims = ["/root.xformOp:translate"]
for path, value in paths.items():
self.assertIn(path, prims)
self.assertEqual(len(value), 1)
self.assertEqual(value[0], layer0.identifier)
self.assertIsNotNone(payload)
self.assertEqual(payload.event_type, LayerEventType.SPECS_LINKING_CHANGED)
self.assertEqual(set([layer0.identifier]), set(payload.layer_spec_paths.keys()))
self.assertEqual(set(payload.layer_spec_paths[layer0.identifier]), set(prims))
specs_linking.link_spec(root_translate_path, layer1.identifier, hierarchy=True)
paths = specs_linking.get_spec_layer_links(root_translate_path, hierarchy=True)
self.assertIn(root_translate_path, paths)
layers = paths[root_translate_path]
self.assertEqual(set([layer0.identifier, layer1.identifier]), set(layers))
# Links root translate to layer2 only.
paths = specs_linking.get_spec_layer_links(root_translate_path, hierarchy=True)
specs_linking.unlink_spec_from_all_layers(root_translate_path)
paths = specs_linking.get_spec_layer_links(root_translate_path, hierarchy=True)
specs_linking.link_spec(root_translate_path, layer2.identifier)
paths = specs_linking.get_spec_layer_links(root_translate_path, hierarchy=True)
self.assertIn(root_translate_path, paths)
layers = paths[root_translate_path]
self.assertEqual(set([layer2.identifier]), set(layers))
specs_linking.unlink_all_specs()
# Link all prims to layer 0
paths = specs_linking.link_spec("/", layer0.identifier, hierarchy=True)
# Link /root/test0/l1 and all its descendants to both layer0 and layer1
paths = specs_linking.link_spec("/root/test0/l1", layer1.identifier, hierarchy=True)
links = specs_linking.get_all_spec_links()
for path, layers in links.items():
if path.startswith("/root/test0/l1"):
self.assertEqual(set(layers), set([layer0.identifier, layer1.identifier]))
else:
self.assertEqual(set(layers), set([layer0.identifier]))
async def test_unlink_spec(self):
layers = get_layers()
specs_linking = layers.get_specs_linking()
event_stream = layers.get_event_stream()
payload = None
def _on_layer_event(event: carb.events.IEvent):
nonlocal payload
temp = get_layer_event_payload(event)
if temp.event_type == LayerEventType.SPECS_LINKING_CHANGED:
payload = temp
subscription = event_stream.create_subscription_to_pop(_on_layer_event, name="layer events")
context = omni.usd.get_context()
layers.set_edit_mode(LayerEditMode.SPECS_LINKING)
stage = context.get_stage()
root_layer = stage.GetRootLayer()
layer0 = Sdf.Layer.CreateAnonymous()
layer1 = Sdf.Layer.CreateAnonymous()
root_layer.subLayerPaths.append(layer0.identifier)
root_layer.subLayerPaths.append(layer1.identifier)
asset_name = f"/root/test0/l1/l2/l3"
asset_prim = stage.DefinePrim(asset_name, "Xform")
all_spec_paths = set(self.__get_all_stage_paths(stage))
# Links root prim to layer0 with hierarchy.
paths = specs_linking.link_spec("/", layer0.identifier, hierarchy=True)
self.assertEqual(set(paths), all_spec_paths)
links = specs_linking.get_all_spec_links()
self.assertEqual(set(links), all_spec_paths)
# Unlink absolute root path without hierarchy will unlink nothing
specs_linking.unlink_spec("/", layer0.identifier, hierarchy=False)
links = specs_linking.get_all_spec_links()
self.assertEqual(set(paths), all_spec_paths)
# Unlink all
unlinked_paths = specs_linking.unlink_spec("/", layer0.identifier, hierarchy=True)
links = specs_linking.get_all_spec_links()
self.assertEqual(set(unlinked_paths), all_spec_paths)
self.assertEqual(len(links), 0)
self.assertIsNotNone(payload)
self.assertEqual(payload.event_type, LayerEventType.SPECS_LINKING_CHANGED)
self.assertEqual(set([layer0.identifier]), set(payload.layer_spec_paths.keys()))
self.assertEqual(set(payload.layer_spec_paths[layer0.identifier]), set(all_spec_paths))
for path in unlinked_paths:
self.assertFalse(specs_linking.is_spec_linked(path))
self.assertFalse(specs_linking.is_spec_linked(path, layer0.identifier))
# Unlinks a subset of paths
paths = specs_linking.link_spec("/", layer0.identifier, hierarchy=True)
unlinked_paths = specs_linking.unlink_spec("/root/test0", layer0.identifier, hierarchy=True)
links = specs_linking.get_all_spec_links()
expected_unlinked_paths = all_spec_paths.difference(set(links))
self.assertEqual(set(unlinked_paths), set(expected_unlinked_paths))
# Unlinks single path
unlinked_paths = specs_linking.unlink_spec("/root", layer0.identifier, hierarchy=False)
new_links = specs_linking.get_all_spec_links()
expected_unlinked_paths = set(links).difference(set(new_links))
self.assertEqual(set(unlinked_paths), set(expected_unlinked_paths))
# Unlinks specs from subset of layers.
specs_linking.unlink_all_specs()
paths = specs_linking.link_spec("/", layer0.identifier, hierarchy=True)
paths.extend(specs_linking.link_spec("/", layer1.identifier, hierarchy=True))
unlinked_paths = specs_linking.unlink_spec("/", layer0.identifier, hierarchy=True)
links = specs_linking.get_all_spec_links()
self.assertEqual(set(paths), all_spec_paths)
self.assertEqual(set(unlinked_paths), all_spec_paths)
# Checkes if only layer1's link is existed.
for _, linked_layers in links.items():
self.assertEqual(linked_layers, [layer1.identifier])
# Unlinks all specs linked to specific layers
specs_linking.unlink_all_specs()
paths = specs_linking.link_spec("/", layer0.identifier, hierarchy=True)
paths.extend(specs_linking.link_spec("/", layer1.identifier, hierarchy=True))
unlinked_paths = specs_linking.unlink_specs_to_layer(layer0.identifier)
links = specs_linking.get_all_spec_links()
self.assertEqual(set(paths), all_spec_paths)
self.assertEqual(set(unlinked_paths), all_spec_paths)
for _, linked_layers in links.items():
self.assertEqual(linked_layers, [layer1.identifier])
# Unlinks specific specs from all layers
specs_linking.unlink_all_specs()
paths = specs_linking.link_spec("/", layer0.identifier, hierarchy=True)
paths.extend(specs_linking.link_spec("/", layer1.identifier, hierarchy=True))
unlinked_paths = specs_linking.unlink_spec_from_all_layers("/root/test0", hierarchy=True)
self.assertTrue(len(unlinked_paths) != 0)
links = specs_linking.get_all_spec_links()
self.assertTrue("/root/test0" not in links)
expected_unlinked_paths = all_spec_paths.difference(set(links))
self.assertEqual(set(unlinked_paths), set(expected_unlinked_paths))
async def test_stage_edits_for_spec_links(self):
layers = get_layers()
specs_linking = layers.get_specs_linking()
context = omni.usd.get_context()
layers.set_edit_mode(LayerEditMode.SPECS_LINKING)
stage = context.get_stage()
root_layer = stage.GetRootLayer()
layer0 = Sdf.Layer.CreateAnonymous()
layer1 = Sdf.Layer.CreateAnonymous()
layer2 = Sdf.Layer.CreateAnonymous()
root_layer.subLayerPaths.append(layer0.identifier)
root_layer.subLayerPaths.append(layer1.identifier)
root_layer.subLayerPaths.append(layer2.identifier)
asset_name = f"/root/test0/l1/l2/l3"
asset_prim = stage.DefinePrim(asset_name, "Xform")
await omni.kit.app.get_app().next_update_async()
specs_linking.link_spec("/", layer0.identifier, hierarchy=True)
specs_linking.link_spec("/", layer1.identifier, hierarchy=True)
# Create an attribute and make sure its edits are distributed to both layer0 and layer1
prim = stage.GetPrimAtPath("/root/test0/l1")
attr = prim.CreateAttribute("custom", Sdf.ValueTypeNames.Float)
attr.Set(1.0)
await omni.kit.app.get_app().next_update_async()
layer0_prim_spec = layer0.GetPrimAtPath("/root/test0/l1")
layer1_prim_spec = layer1.GetPrimAtPath("/root/test0/l1")
self.assertTrue(layer0_prim_spec)
self.assertTrue(layer1_prim_spec)
attr_spec0 = layer0.GetAttributeAtPath(attr.GetPath())
attr_spec1 = layer1.GetAttributeAtPath(attr.GetPath())
self.assertTrue(attr_spec0)
self.assertTrue(attr_spec1)
self.assertEqual(attr_spec0.default, 1.0)
self.assertEqual(attr_spec1.default, 1.0)
# Create an attribute and make sure its edits are distributed to layer0 only.
# Unlink it from layer1 firstly to leave layer0 only.
prim = stage.GetPrimAtPath("/root/test0/l1/l2")
paths = specs_linking.unlink_spec(prim.GetPath(), layer1.identifier, hierarchy=False)
attr = prim.CreateAttribute("custom", Sdf.ValueTypeNames.Float)
attr.Set(100.0)
await omni.kit.app.get_app().next_update_async()
layer0_prim_spec = layer0.GetPrimAtPath(prim.GetPath())
layer1_prim_spec = layer1.GetPrimAtPath(prim.GetPath())
self.assertTrue(layer0_prim_spec)
self.assertFalse(layer1_prim_spec)
attr_spec0 = layer0.GetAttributeAtPath(attr.GetPath())
self.assertTrue(attr_spec0)
self.assertEqual(attr_spec0.default, 100.0)
# Link rotate attr to layer2 only, and lock translate attr.
translate_attr = "/root/test0/l1/l2/l3.xformOp:translate"
rotate_attr = "/root/test0/l1/l2/l3.xformOp:rotateXYZ"
specs_linking.unlink_spec_from_all_layers(rotate_attr)
specs_linking.link_spec(rotate_attr, layer2.identifier, hierarchy=False)
xform_prim = stage.GetPrimAtPath("/root/test0/l1/l2/l3")
common_api = UsdGeom.XformCommonAPI(xform_prim)
common_api.SetRotate(Gf.Vec3f(200.0, 200.0, 200.0))
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
xform_vectors = common_api.GetXformVectors(Usd.TimeCode.Default())
# Translate does not change and rotation is changed.
self.assertEqual(xform_vectors[1], Gf.Vec3f(200.0, 200.0, 200.0))
layer0_translate_attr = layer0.GetAttributeAtPath(translate_attr)
layer1_translate_attr = layer1.GetAttributeAtPath(translate_attr)
layer2_translate_attr = layer2.GetAttributeAtPath(translate_attr)
root_layer_translate_attr = root_layer.GetAttributeAtPath(translate_attr)
self.assertFalse(root_layer_translate_attr)
self.assertFalse(layer0_translate_attr)
self.assertFalse(layer1_translate_attr)
self.assertFalse(layer2_translate_attr)
layer0_rotation_attr = layer0.GetAttributeAtPath(rotate_attr)
layer1_rotation_attr = layer1.GetAttributeAtPath(rotate_attr)
layer2_rotation_attr = layer2.GetAttributeAtPath(rotate_attr)
root_layer_rotation_attr = root_layer.GetAttributeAtPath(rotate_attr)
self.assertFalse(layer0_rotation_attr)
self.assertFalse(layer1_rotation_attr)
self.assertTrue(layer2_rotation_attr)
self.assertFalse(root_layer_rotation_attr)
| 16,812 | Python | 46.49435 | 110 | 0.666488 |
omniverse-code/kit/exts/omni.kit.usd.layers/omni/kit/usd/layers/tests/test_layer_utils.py | import os
import carb
import omni.kit.test
import omni.usd
from omni.kit.usd.layers import LayerUtils
from pxr import Sdf, Usd, UsdGeom, UsdShade, Vt
class TestLayerUtils(omni.kit.test.AsyncTestCase):
async def setUp(self):
self.usd_context = omni.usd.get_context()
await omni.usd.get_context().new_stage_async()
async def tearDown(self):
await omni.usd.get_context().close_stage_async()
def check_sublayers(self, layer, expected_layer_identifiers):
sublayers = layer.subLayerPaths
self.assertTrue(len(sublayers) == len(expected_layer_identifiers), "Sublayers count does not match")
sublayer_paths = []
for sublayer_path in sublayers:
sublayer_paths.append(sublayer_path)
self.assertTrue(
sublayer_paths == expected_layer_identifiers,
f"Sublayers array does not match, got: {sublayer_paths}, expected: {expected_layer_identifiers}",
)
async def test_create_sublayer(self):
layer = Sdf.Layer.CreateAnonymous()
layer0 = LayerUtils.create_sublayer(layer, 0, "")
layer1 = LayerUtils.create_sublayer(layer, 1, "")
layer2 = LayerUtils.create_sublayer(layer, 2, "")
self.check_sublayers(layer, [layer0.identifier, layer1.identifier, layer2.identifier])
layer3 = LayerUtils.create_sublayer(layer, 3, "")
self.check_sublayers(layer, [layer0.identifier, layer1.identifier, layer2.identifier, layer3.identifier])
layer4 = LayerUtils.create_sublayer(layer, 3, "")
self.check_sublayers(
layer, [layer0.identifier, layer1.identifier, layer2.identifier, layer4.identifier, layer3.identifier]
)
layer5 = LayerUtils.create_sublayer(layer, -1, "")
self.check_sublayers(
layer,
[
layer0.identifier,
layer1.identifier,
layer2.identifier,
layer4.identifier,
layer3.identifier,
layer5.identifier,
],
)
layer6 = LayerUtils.create_sublayer(layer, 100, "")
self.check_sublayers(
layer,
[
layer0.identifier,
layer1.identifier,
layer2.identifier,
layer4.identifier,
layer3.identifier,
layer5.identifier,
layer6.identifier,
],
)
layer7 = LayerUtils.create_sublayer(layer, -2, "")
self.check_sublayers(
layer,
[
layer0.identifier,
layer1.identifier,
layer2.identifier,
layer4.identifier,
layer3.identifier,
layer5.identifier,
layer6.identifier,
],
)
layer8 = LayerUtils.create_sublayer(layer, 0, "")
self.check_sublayers(
layer,
[
layer8.identifier,
layer0.identifier,
layer1.identifier,
layer2.identifier,
layer4.identifier,
layer3.identifier,
layer5.identifier,
layer6.identifier,
],
)
async def test_insert_sublayer(self):
layer = Sdf.Layer.CreateAnonymous()
all_layers = []
for i in range(9):
all_layers.append(Sdf.Layer.CreateAnonymous())
layer0 = LayerUtils.insert_sublayer(layer, 0, all_layers[0].identifier)
layer1 = LayerUtils.insert_sublayer(layer, 1, all_layers[1].identifier)
layer2 = LayerUtils.insert_sublayer(layer, 2, all_layers[2].identifier)
self.check_sublayers(layer, [all_layers[0].identifier, all_layers[1].identifier, all_layers[2].identifier])
layer3 = LayerUtils.insert_sublayer(layer, 3, all_layers[3].identifier)
self.check_sublayers(
layer,
[all_layers[0].identifier, all_layers[1].identifier, all_layers[2].identifier, all_layers[3].identifier],
)
layer4 = LayerUtils.insert_sublayer(layer, 3, all_layers[4].identifier)
self.check_sublayers(
layer,
[
all_layers[0].identifier,
all_layers[1].identifier,
all_layers[2].identifier,
all_layers[4].identifier,
all_layers[3].identifier,
],
)
layer5 = LayerUtils.insert_sublayer(layer, -1, all_layers[5].identifier)
self.check_sublayers(
layer,
[
all_layers[0].identifier,
all_layers[1].identifier,
all_layers[2].identifier,
all_layers[4].identifier,
all_layers[3].identifier,
all_layers[5].identifier,
],
)
layer6 = LayerUtils.insert_sublayer(layer, 100, all_layers[6].identifier)
self.check_sublayers(
layer,
[
all_layers[0].identifier,
all_layers[1].identifier,
all_layers[2].identifier,
all_layers[4].identifier,
all_layers[3].identifier,
all_layers[5].identifier,
all_layers[6].identifier,
],
)
layer7 = LayerUtils.insert_sublayer(layer, -2, all_layers[7].identifier)
self.check_sublayers(
layer,
[
all_layers[0].identifier,
all_layers[1].identifier,
all_layers[2].identifier,
all_layers[4].identifier,
all_layers[3].identifier,
all_layers[5].identifier,
all_layers[6].identifier,
],
)
layer8 = LayerUtils.insert_sublayer(layer, 0, all_layers[8].identifier)
self.check_sublayers(
layer,
[
all_layers[8].identifier,
all_layers[0].identifier,
all_layers[1].identifier,
all_layers[2].identifier,
all_layers[4].identifier,
all_layers[3].identifier,
all_layers[5].identifier,
all_layers[6].identifier,
],
)
async def test_replace_sublayer(self):
layer = Sdf.Layer.CreateAnonymous()
all_layers = []
for i in range(7):
all_layers.append(Sdf.Layer.CreateAnonymous())
layer0 = LayerUtils.insert_sublayer(layer, 0, all_layers[0].identifier)
layer1 = LayerUtils.insert_sublayer(layer, 1, all_layers[1].identifier)
layer2 = LayerUtils.insert_sublayer(layer, 2, all_layers[2].identifier)
self.check_sublayers(layer, [all_layers[0].identifier, all_layers[1].identifier, all_layers[2].identifier])
layer3 = LayerUtils.replace_sublayer(layer, 2, all_layers[3].identifier)
self.check_sublayers(layer, [all_layers[0].identifier, all_layers[1].identifier, all_layers[3].identifier])
layer4 = LayerUtils.replace_sublayer(layer, -1, all_layers[4].identifier)
self.check_sublayers(layer, [all_layers[0].identifier, all_layers[1].identifier, all_layers[3].identifier])
layer5 = LayerUtils.replace_sublayer(layer, 0, all_layers[5].identifier)
self.check_sublayers(layer, [all_layers[5].identifier, all_layers[1].identifier, all_layers[3].identifier])
layer6 = LayerUtils.replace_sublayer(layer, 100, all_layers[6].identifier)
self.check_sublayers(layer, [all_layers[5].identifier, all_layers[1].identifier, all_layers[3].identifier])
async def test_get_set_custom_name(self):
layer = Sdf.Layer.CreateAnonymous()
LayerUtils.set_custom_layer_name(layer, "name1")
self.assertTrue(LayerUtils.get_custom_layer_name(layer) == "name1")
LayerUtils.set_custom_layer_name(layer, "")
self.assertTrue(LayerUtils.get_custom_layer_name(layer) == "name1")
LayerUtils.set_custom_layer_name(layer, "name test with space")
self.assertTrue(LayerUtils.get_custom_layer_name(layer) == "name test with space")
def _create_material(self, stage, material_name, material_file_path):
materials_group = UsdGeom.Scope.Define(stage, "/root/materials")
material_path = materials_group.GetPath().AppendElementString(material_name)
shader_path = material_path.AppendElementString(material_name)
material = UsdShade.Material.Define(stage, material_path)
shader = UsdShade.Shader.Define(stage, shader_path)
shader.CreateOutput("out", Sdf.ValueTypeNames.Token)
material.CreateSurfaceOutput().ConnectToSource(shader, "out")
shader.SetSourceAsset(material_file_path, "mdl")
shader.SetSourceAssetSubIdentifier(material_name)
shader.GetImplementationSourceAttr().Set(UsdShade.Tokens.sourceAsset)
return material, shader
async def test_resolve_paths(self):
format = Sdf.FileFormat.FindByExtension(".usd")
layer = Sdf.Layer.New(format, "omniverse://test-ov-fake-server/fake/path/a.usd")
sublayer0 = Sdf.Layer.New(format, "omniverse://test-ov-fake-server/fake/path/sublayers/sublayer0.usd")
layer.subLayerPaths.insert(0, "./sublayers/sublayer0.usd")
layer.subLayerOffsets[0] = Sdf.LayerOffset(2.0, 3.0)
custom_data = layer.customLayerData
custom_data["path"] = Sdf.AssetPath("../test_path.usd")
layer.customLayerData = custom_data
stage = Usd.Stage.Open(layer)
mesh = UsdGeom.Mesh.Define(stage, "/root/test")
test_prim = mesh.GetPrim()
test_prim.GetReferences().AddReference("../b.usd")
test_prim.GetPayloads().AddPayload("../c.usd")
test_prim.CreateAttribute("Asset", Sdf.ValueTypeNames.Asset, False).Set("../d.usd")
test_prim.CreateAttribute("AssetArray", Sdf.ValueTypeNames.AssetArray, False).Set(
["../e.usd", "../f.usd", "OmniPBR.mdl"]
)
test_prim_spec = layer.GetPrimAtPath(test_prim.GetPath())
test_prim_spec.customData["path"] = Sdf.AssetPath("../test.usd")
omnipbr_mat, omnipbr_shader = self._create_material(stage, "omnipbr", "OmniPBR.mdl")
external_mat, external_shader = self._create_material(stage, "external_mat", "../invalid_path/external_mat.mdl")
# OM-42410: Paths without "./" are search paths
searchpath_mat, searchpath_shader = self._create_material(stage, "searchpath_mat", "nvidia/searchpath_mat.mdl")
material_binding = UsdShade.MaterialBindingAPI(test_prim)
material_binding.Bind(omnipbr_mat)
mesh = UsdGeom.Mesh.Define(stage, "/root/test2")
test2_prim = mesh.GetPrim()
material_binding = UsdShade.MaterialBindingAPI(test2_prim)
material_binding.Bind(external_mat)
mesh2 = UsdGeom.Mesh.Define(stage, "/root/test3")
test3_prim = mesh2.GetPrim()
material_binding = UsdShade.MaterialBindingAPI(test3_prim)
material_binding.Bind(searchpath_mat)
omni.usd.create_material_input(
external_mat.GetPrim(),
"diffuse_texture",
Sdf.AssetPath("../invalid_path/invalid.png"),
Sdf.ValueTypeNames.Asset,
)
target_layer = Sdf.Layer.New(format, "omniverse://test-ov-fake-server/fake/path/deep/level/a.usd")
target_layer.TransferContent(layer)
LayerUtils.resolve_paths(layer, target_layer, True, False, True)
# Make sure that layer offset and scale are not changed.
sublayer_offset = target_layer.subLayerOffsets[0]
self.assertTrue(float(sublayer_offset.offset) == 2.0 and float(sublayer_offset.scale) == 3.0)
string = target_layer.ExportToString()
# FIXME: Search string directly instead of using USD API since it will cause unknown crashes.
self.assertTrue(
string.find("@../../sublayers/sublayer0.usd@") != -1,
f"Sublayer repathing failed, expected: ../../sublayers/sublayer0.usd.",
)
self.assertTrue(string.find("@../../../b.usd@") != -1, f"Reference is not resolved, expected: ../../../b.usd.")
self.assertTrue(string.find("@../../../c.usd@") != -1, f"Payload is not resolved, expected: ../../../c.usd.")
self.assertTrue(
string.find("@OmniPBR.mdl@") != -1,
f"MDL from Core MDL Library should not be repathing, expected: OmniPBR.mdl.",
)
self.assertTrue(
string.find("@../../../invalid_path/external_mat.mdl@") != -1,
f"MDL repathing failed, expected: ../../../invalid_path/external_mat.mdl.",
)
self.assertTrue(
string.find("@../../../invalid_path/invalid.png@") != -1,
f"Material input repathing failed, expected: ../../../invalid_path/invalid.mdl.",
)
# Checks if all paths in target_path is re-pathing correctly.
custom_data = target_layer.customLayerData
self.assertTrue("path" in custom_data)
self.assertEqual(custom_data["path"], "../../../test_path.usd")
test_prim_spec = target_layer.GetPrimAtPath(test_prim.GetPath())
self.assertTrue("path" in test_prim_spec.customData)
self.assertEqual(test_prim_spec.customData["path"], "../../../test.usd")
references = test_prim_spec.referenceList.prependedItems
reference = references[0]
self.assertEqual(reference.assetPath, "../../../b.usd")
payloads = test_prim_spec.payloadList.prependedItems
payload = payloads[0]
self.assertEqual(payload.assetPath, "../../../c.usd")
new_stage = Usd.Stage.Open(target_layer)
test_prim = new_stage.GetPrimAtPath(test_prim.GetPath())
attribute = test_prim.GetAttribute("Asset")
self.assertEqual(attribute.GetTypeName(), Sdf.ValueTypeNames.Asset)
path = attribute.Get().path
self.assertEqual(path, "../../../d.usd")
attribute = test_prim.GetAttribute("AssetArray")
self.assertTrue(attribute.GetTypeName() == Sdf.ValueTypeNames.AssetArray)
asset_array = attribute.Get()
self.assertEqual
(asset_array, Vt.StringArray(3, ("../../../e.usd", "../../../f.usd", "OmniPBR.mdl")))
# MDL from core mdl library should stay untouched
target_stage = Usd.Stage.Open(target_layer)
target_omnipbr_shader = UsdShade.Shader.Get(target_stage, omnipbr_shader.GetPrim().GetPath())
mdl = target_omnipbr_shader.GetSourceAsset("mdl")
self.assertEqual(mdl.path, "OmniPBR.mdl")
# MDL from external should be repathing to be relative to target layer.
target_external_shader = UsdShade.Shader.Get(target_stage, external_shader.GetPrim().GetPath())
mdl = target_external_shader.GetSourceAsset("mdl")
self.assertEqual(mdl.path, "../../../invalid_path/external_mat.mdl")
# MDL from search path should stay untouched.
target_searchpath_shader = UsdShade.Shader.Get(target_stage, searchpath_shader.GetPrim().GetPath())
mdl = target_searchpath_shader.GetSourceAsset("mdl")
self.assertEqual(mdl.path, "nvidia/searchpath_mat.mdl")
texture_input = target_external_shader.GetInput("diffuse_texture")
path = texture_input.Get().path
self.assertEqual(path, "../../../invalid_path/invalid.png")
def test_get_sublayer_position_in_parent(self):
layer = Sdf.Layer.CreateAnonymous()
layer0 = LayerUtils.create_sublayer(layer, 0, "")
layer1 = LayerUtils.create_sublayer(layer, 1, "")
layer2 = LayerUtils.create_sublayer(layer, 2, "")
position = LayerUtils.get_sublayer_position_in_parent(layer.identifier, layer0.identifier)
self.assertTrue(position == 0)
position = LayerUtils.get_sublayer_position_in_parent(layer.identifier, layer1.identifier)
self.assertTrue(position == 1)
position = LayerUtils.get_sublayer_position_in_parent(layer.identifier, layer2.identifier)
self.assertTrue(position == 2)
position = LayerUtils.get_sublayer_position_in_parent(layer.identifier, "random")
self.assertTrue(position == -1)
position = LayerUtils.get_sublayer_position_in_parent(layer.identifier, "")
self.assertTrue(position == -1)
def test_get_set_layer_global_muteness(self):
layer = Sdf.Layer.CreateAnonymous()
LayerUtils.set_layer_global_muteness(layer, "c:/test/abcd/a.usd", True)
self.assertTrue(LayerUtils.get_layer_global_muteness(layer, "c:/test/abcd/a.usd"))
LayerUtils.set_layer_global_muteness(layer, "c:/random_string", True)
self.assertTrue(LayerUtils.get_layer_global_muteness(layer, "c:/random_string"))
LayerUtils.remove_layer_global_muteness(layer, "c:/random_string")
self.assertFalse(LayerUtils.get_layer_global_muteness(layer, "c:/random_string"))
def test_get_set_layer_lock_status(self):
layer = Sdf.Layer.CreateAnonymous()
LayerUtils.set_layer_lock_status(layer, "c:/test/abcd/a.usd", True)
self.assertTrue(LayerUtils.get_layer_lock_status(layer, "c:/test/abcd/a.usd"))
LayerUtils.set_layer_lock_status(layer, "c:/random_string", True)
self.assertTrue(LayerUtils.get_layer_lock_status(layer, "c:/random_string"))
LayerUtils.remove_layer_lock_status(layer, "c:/random_string")
self.assertFalse(LayerUtils.get_layer_lock_status(layer, "c:/random_string"))
def test_has_prim_spec(self):
layer = Sdf.Layer.CreateAnonymous()
stage = Usd.Stage.Open(layer)
stage.DefinePrim("/Root/TestPrim")
self.assertTrue(LayerUtils.has_prim_spec(layer.identifier, "/Root/TestPrim"))
self.assertTrue(LayerUtils.has_prim_spec(layer.identifier, "/"))
self.assertTrue(LayerUtils.has_prim_spec(layer.identifier, "/Root"))
self.assertFalse(LayerUtils.has_prim_spec(layer.identifier, "/Root/TestPrim2"))
self.assertFalse(LayerUtils.has_prim_spec(layer.identifier, ""))
def test_get_sublayer_identifier(self):
format = Sdf.FileFormat.FindByExtension(".usd")
layer = Sdf.Layer.New(format, "omniverse://test-ov-fake-server/fake/path/a.usd")
sublayer0 = Sdf.Layer.New(format, "omniverse://test-ov-fake-server/fake/path/sublayers/sublayer0.usd")
layer.subLayerPaths.insert(0, "./sublayers/sublayer0.usd")
identifier = LayerUtils.get_sublayer_identifier(layer.identifier, 0)
self.assertTrue(sublayer0.identifier == identifier)
def test_restore_muteness_from_custom_data(self):
format = Sdf.FileFormat.FindByExtension(".usd")
layer = Sdf.Layer.CreateAnonymous()
layer0 = Sdf.Layer.CreateAnonymous()
layer1 = Sdf.Layer.CreateAnonymous()
layer2 = Sdf.Layer.CreateAnonymous()
layer3 = Sdf.Layer.CreateAnonymous()
layer4 = Sdf.Layer.CreateAnonymous()
layer.subLayerPaths.append(layer0.identifier)
layer.subLayerPaths.append(layer1.identifier)
layer.subLayerPaths.append(layer2.identifier)
layer.subLayerPaths.append(layer3.identifier)
layer.subLayerPaths.append(layer4.identifier)
LayerUtils.set_layer_global_muteness(layer, layer0.identifier, True)
LayerUtils.set_layer_global_muteness(layer, layer1.identifier, False)
LayerUtils.set_layer_global_muteness(layer, layer2.identifier, True)
LayerUtils.set_layer_global_muteness(layer, layer3.identifier, False)
LayerUtils.set_layer_global_muteness(layer, layer4.identifier, True)
stage = Usd.Stage.Open(layer)
LayerUtils.restore_muteness_from_custom_data(stage)
self.assertTrue(stage.IsLayerMuted(layer0.identifier))
self.assertFalse(stage.IsLayerMuted(layer1.identifier))
self.assertTrue(stage.IsLayerMuted(layer2.identifier))
self.assertFalse(stage.IsLayerMuted(layer3.identifier))
self.assertTrue(stage.IsLayerMuted(layer4.identifier))
def test_set_get_global_muteness(self):
layer = Sdf.Layer.CreateAnonymous()
LayerUtils.set_layer_global_muteness(layer, "test_identifier", True)
LayerUtils.set_layer_global_muteness(layer, "", True)
self.assertTrue(LayerUtils.get_layer_global_muteness(layer, "test_identifier"))
self.assertFalse(LayerUtils.get_layer_global_muteness(layer, "test_identifier2"))
self.assertFalse(LayerUtils.get_layer_global_muteness(layer, ""))
LayerUtils.remove_layer_global_muteness(layer, "test_identifier")
self.assertFalse(LayerUtils.get_layer_global_muteness(layer, "test_identifier"))
def test_remove_sublayer(self):
format = Sdf.FileFormat.FindByExtension(".usd")
layer = Sdf.Layer.CreateAnonymous()
layer0 = Sdf.Layer.CreateAnonymous()
layer1 = Sdf.Layer.CreateAnonymous()
layer2 = Sdf.Layer.CreateAnonymous()
layer3 = Sdf.Layer.CreateAnonymous()
layer4 = Sdf.Layer.CreateAnonymous()
layer.subLayerPaths.append(layer0.identifier)
layer.subLayerPaths.append(layer1.identifier)
layer.subLayerPaths.append(layer2.identifier)
layer.subLayerPaths.append(layer3.identifier)
layer.subLayerPaths.append(layer4.identifier)
LayerUtils.remove_sublayer(layer, 0)
self.check_sublayers(layer, [layer1.identifier, layer2.identifier, layer3.identifier, layer4.identifier])
# -1 means the last element.
LayerUtils.remove_sublayer(layer, -1)
self.check_sublayers(layer, [layer1.identifier, layer2.identifier, layer3.identifier])
# Invalid index
LayerUtils.remove_sublayer(layer, 100)
self.check_sublayers(layer, [layer1.identifier, layer2.identifier, layer3.identifier])
# Invalid index
LayerUtils.remove_sublayer(layer, -2)
self.check_sublayers(layer, [layer1.identifier, layer2.identifier, layer3.identifier])
# clear it and try to remove an sublayer.
layer.subLayerPaths = []
LayerUtils.remove_sublayer(layer, 1)
self.check_sublayers(layer, [])
def test_remove_prim_spec(self):
layer = Sdf.Layer.CreateAnonymous()
stage = Usd.Stage.Open(layer)
mesh = UsdGeom.Mesh.Define(stage, "/root/test")
self.assertTrue(layer.GetPrimAtPath("/root/test"))
LayerUtils.remove_prim_spec(layer, "/root/test")
self.assertFalse(layer.GetPrimAtPath("/root/test"))
self.assertTrue(layer.GetPrimAtPath("/root"))
LayerUtils.remove_prim_spec(layer, "/root")
self.assertFalse(layer.GetPrimAtPath("/root"))
def test_get_all_sublayers(self):
layer = Sdf.Layer.CreateAnonymous()
layer0 = Sdf.Layer.CreateAnonymous()
layer1 = Sdf.Layer.CreateAnonymous()
layer2 = Sdf.Layer.CreateAnonymous()
layer3 = Sdf.Layer.CreateAnonymous()
layer4 = Sdf.Layer.CreateAnonymous()
layer5 = Sdf.Layer.CreateAnonymous()
layer.subLayerPaths.append(layer0.identifier)
layer.subLayerPaths.append(layer1.identifier)
layer.subLayerPaths.append(layer2.identifier)
layer.subLayerPaths.append(layer3.identifier)
# Creates a circular reference: layer -> layer0 -> layer
layer0.subLayerPaths.append(layer.identifier)
layer3.subLayerPaths.append(layer4.identifier)
layer4.subLayerPaths.append(layer5.identifier)
stage = Usd.Stage.Open(layer)
self.assertTrue(
LayerUtils.get_all_sublayers(stage),
[
layer0.identifier,
layer1.identifier,
layer2.identifier,
layer3.identifier,
layer4.identifier,
layer5.identifier,
],
)
def test_move_layer(self):
layer = Sdf.Layer.CreateAnonymous()
layer0 = Sdf.Layer.CreateAnonymous()
layer1 = Sdf.Layer.CreateAnonymous()
layer2 = Sdf.Layer.CreateAnonymous()
layer3 = Sdf.Layer.CreateAnonymous()
layer4 = Sdf.Layer.CreateAnonymous()
layer5 = Sdf.Layer.CreateAnonymous()
layer.subLayerPaths.append(layer0.identifier)
layer.subLayerPaths.append(layer1.identifier)
layer.subLayerPaths.append(layer2.identifier)
layer.subLayerPaths.append(layer3.identifier)
# Creates a circular reference: layer -> layer0 -> layer
layer0.subLayerPaths.append(layer.identifier)
layer3.subLayerPaths.append(layer4.identifier)
layer4.subLayerPaths.append(layer5.identifier)
LayerUtils.move_layer(layer.identifier, 0, layer.identifier, 1, True)
self.check_sublayers(layer, [layer1.identifier, layer0.identifier, layer2.identifier, layer3.identifier])
# Move to the end
LayerUtils.move_layer(layer.identifier, 0, layer.identifier, -1, True)
self.check_sublayers(layer, [layer0.identifier, layer2.identifier, layer3.identifier, layer1.identifier])
LayerUtils.move_layer(layer.identifier, 0, layer.identifier, 100, True)
self.check_sublayers(layer, [layer2.identifier, layer3.identifier, layer1.identifier, layer0.identifier])
# Invalid source
LayerUtils.move_layer(layer.identifier, -1, layer.identifier, 0, True)
self.check_sublayers(layer, [layer2.identifier, layer3.identifier, layer1.identifier, layer0.identifier])
# Invalid target
LayerUtils.move_layer(layer.identifier, 0, layer.identifier, -100, True)
self.check_sublayers(layer, [layer2.identifier, layer3.identifier, layer1.identifier, layer0.identifier])
# Move it to layer3 but not deletes it from source layer.
LayerUtils.move_layer(layer.identifier, 0, layer3.identifier, 0, False)
self.check_sublayers(layer, [layer2.identifier, layer3.identifier, layer1.identifier, layer0.identifier])
self.check_sublayers(layer3, [layer2.identifier, layer4.identifier])
LayerUtils.move_layer(layer.identifier, 0, layer1.identifier, 0, True)
self.check_sublayers(layer, [layer3.identifier, layer1.identifier, layer0.identifier])
self.check_sublayers(layer1, [layer2.identifier])
def test_stitch_prim_specs(self):
layer_content = """\
#usda 1.0
(
subLayers = [
@omniverse://test-ov-fake-server/fake/path/sublayers/sublayer0.usd@,
@omniverse://test-ov-fake-server/fake/path/sublayers/sublayer1.usd@
]
)
def "root"
{
def "test_prim"
{
int test = 1
def "test_prim2"
{
int test = 1
}
}
def "test_prim3"
{
int test = 1
}
}
"""
layer0_content = """\
#usda 1.0
over "root"
{
over "test_prim" (
prepend payload = @../invalid/payload1.usd@
prepend references = @../invalid/reference1.usd@
)
{
int test = 2
over "test_prim2" (
prepend payload = @../invalid/payload1.usd@
prepend references = @../invalid/reference1.usd@
)
{
int test = 2
}
}
over "test_prim3" (
prepend payload = @../invalid/payload1.usd@
prepend references = @../invalid/reference1.usd@
)
{
int test = 2
}
}
"""
layer1_content = """\
#usda 1.0
(
subLayers = [
@omniverse://test-ov-fake-server/fake/path/sublayers/level2/sublayer2.usd@
]
)
over "root"
{
over "test_prim" (
prepend payload = @../invalid/payload2.usd@
prepend references = @../invalid/reference2.usd@
)
{
asset[] AssetArray = [@1.usd@, @2.usd@, @OmniPBR.mdl@]
bool[] BoolArray = [0, 1]
float[] FloatArray = [1, 2, 3]
int[] IntArray = [1, 2, 3]
string[] StringArray = ["string1", "string2", "string3"]
int test = 3
asset test2 = @../../invalid/path.usd@
asset test3 = @OmniPBR.mdl@
token[] TokenArray = ["token1", "token2", "token3"]
}
}
"""
layer2_content = """\
#usda 1.0
over "root"
{
over "test_prim" (
prepend payload = @../invalid/payload2.usd@
prepend references = @../invalid/reference2.usd@
)
{
asset[] AssetArray = [@3.usd@, @4.usd@, @OmniPBR.mdl@]
bool[] BoolArray = [1, 0]
float[] FloatArray = [3, 2, 1]
int[] IntArray = [3, 2, 1]
string[] StringArray = ["string3", "string2", "string1"]
int test = 3
asset test2 = @../../invalid/path.usd@
asset test3 = @OmniPBR.mdl@
asset test4 = @./invalid.mdl@
asset test5 = @nvidia/invalid.mdl@
token[] TokenArray = ["token3", "token2", "token1"]
}
}
"""
format = Sdf.FileFormat.FindByExtension(".usd")
layer = Sdf.Layer.New(format, "omniverse://test-ov-fake-server/fake/path/a.usd")
layer0 = Sdf.Layer.New(format, "omniverse://test-ov-fake-server/fake/path/sublayers/sublayer0.usd")
layer1 = Sdf.Layer.New(format, "omniverse://test-ov-fake-server/fake/path/sublayers/sublayer1.usd")
layer2 = Sdf.Layer.New(format, "omniverse://test-ov-fake-server/fake/path/sublayers/level2/sublayer2.usd")
layer.ImportFromString(layer_content)
layer0.ImportFromString(layer0_content)
layer1.ImportFromString(layer1_content)
layer2.ImportFromString(layer2_content)
stage = Usd.Stage.Open(layer)
result_layer = Sdf.Layer.CreateAnonymous()
prim_paths = ["/root/test_prim", "/root/test_prim3"]
with Sdf.ChangeBlock():
for prim_path in prim_paths:
omni.usd.stitch_prim_specs(stage, prim_path, result_layer)
new_stage = Usd.Stage.Open(result_layer)
prim = new_stage.GetPrimAtPath("/root/test_prim")
prim_spec = result_layer.GetPrimAtPath("/root/test_prim")
references = prim_spec.referenceList.prependedItems
self.assertTrue(len(references), 3)
self.assertEqual(references[0].assetPath, "omniverse://test-ov-fake-server/fake/path/invalid/reference1.usd")
self.assertEqual(references[1].assetPath, "omniverse://test-ov-fake-server/fake/path/invalid/reference2.usd")
self.assertEqual(
references[2].assetPath, "omniverse://test-ov-fake-server/fake/path/sublayers/invalid/reference2.usd"
)
payloads = prim_spec.payloadList.prependedItems
self.assertTrue(len(payloads), 3)
self.assertEqual(payloads[0].assetPath, "omniverse://test-ov-fake-server/fake/path/invalid/payload1.usd")
self.assertEqual(payloads[1].assetPath, "omniverse://test-ov-fake-server/fake/path/invalid/payload2.usd")
self.assertEqual(
payloads[2].assetPath, "omniverse://test-ov-fake-server/fake/path/sublayers/invalid/payload2.usd"
)
self.assertTrue(not not prim)
attribute = prim.GetAttribute("test")
self.assertTrue(attribute.GetTypeName() == Sdf.ValueTypeNames.Int)
self.assertTrue(attribute.Get() == 1)
attribute = prim.GetAttribute("test2")
self.assertTrue(attribute.GetTypeName() == Sdf.ValueTypeNames.Asset)
path = attribute.Get().path
self.assertTrue(
path == "omniverse://test-ov-fake-server/fake/invalid/path.usd", f"Path resolved is not correct: {path}."
)
attribute = prim.GetAttribute("test3")
self.assertTrue(attribute.GetTypeName() == Sdf.ValueTypeNames.Asset)
path = attribute.Get().path
# For path from core mdl library, it should not be re-mapping.
self.assertTrue(path == "OmniPBR.mdl", f"Path resolved is not correct: {path}.")
attribute = prim.GetAttribute("test4")
self.assertTrue(attribute.GetTypeName() == Sdf.ValueTypeNames.Asset)
path = attribute.Get().path
self.assertTrue(
path == "omniverse://test-ov-fake-server/fake/path/sublayers/level2/invalid.mdl",
f"Path resolved is not correct: {path}.",
)
# Search path should stay untouched.
attribute = prim.GetAttribute("test5")
self.assertTrue(attribute.GetTypeName() == Sdf.ValueTypeNames.Asset)
path = attribute.Get().path
self.assertTrue(path == "nvidia/invalid.mdl", f"Path resolved is not correct: {path}.")
attribute = prim.GetAttribute("BoolArray")
self.assertTrue(attribute.GetTypeName() == Sdf.ValueTypeNames.BoolArray)
bool_array = attribute.Get()
self.assertTrue(len(bool_array) == 2)
self.assertEqual(bool_array, Vt.BoolArray(2, (False, True)))
attribute = prim.GetAttribute("IntArray")
self.assertTrue(attribute.GetTypeName() == Sdf.ValueTypeNames.IntArray)
int_array = attribute.Get()
self.assertEqual(int_array, Vt.IntArray(3, (1, 2, 3)))
attribute = prim.GetAttribute("FloatArray")
self.assertTrue(attribute.GetTypeName() == Sdf.ValueTypeNames.FloatArray)
float_array = attribute.Get()
self.assertEqual(float_array, Vt.FloatArray(3, (1.0, 2.0, 3.0)))
attribute = prim.GetAttribute("TokenArray")
self.assertTrue(attribute.GetTypeName() == Sdf.ValueTypeNames.TokenArray)
token_array = attribute.Get()
self.assertEqual(token_array, Vt.TokenArray(3, ("token1", "token2", "token3")))
attribute = prim.GetAttribute("StringArray")
self.assertTrue(attribute.GetTypeName() == Sdf.ValueTypeNames.StringArray)
string_array = attribute.Get()
self.assertEqual(string_array, Vt.StringArray(3, ("string1", "string2", "string3")))
attribute = prim.GetAttribute("AssetArray")
self.assertTrue(attribute.GetTypeName() == Sdf.ValueTypeNames.AssetArray)
asset_array = attribute.Get()
self.assertEqual
(
asset_array,
Vt.StringArray(
3,
(
"omniverse://test-ov-fake-server/fake/path/sublayers/1.usd",
"omniverse://test-ov-fake-server/fake/path/sublayers/2.usd",
"OmniPBR.mdl",
),
),
)
prim = new_stage.GetPrimAtPath("/root/test_prim/test_prim2")
prim_spec = result_layer.GetPrimAtPath("/root/test_prim/test_prim2")
references = prim_spec.referenceList.prependedItems
self.assertTrue(len(references), 1)
self.assertEqual(references[0].assetPath, "omniverse://test-ov-fake-server/fake/path/invalid/reference1.usd")
payloads = prim_spec.payloadList.prependedItems
self.assertTrue(len(payloads), 1)
self.assertEqual(payloads[0].assetPath, "omniverse://test-ov-fake-server/fake/path/invalid/payload1.usd")
self.assertTrue(not not prim)
attribute = prim.GetAttribute("test")
self.assertTrue(attribute.GetTypeName() == Sdf.ValueTypeNames.Int)
self.assertTrue(attribute.Get() == 1)
prim = new_stage.GetPrimAtPath("/root/test_prim3")
prim_spec = result_layer.GetPrimAtPath("/root/test_prim3")
references = prim_spec.referenceList.prependedItems
self.assertTrue(len(references), 1)
self.assertEqual(references[0].assetPath, "omniverse://test-ov-fake-server/fake/path/invalid/reference1.usd")
payloads = prim_spec.payloadList.prependedItems
self.assertTrue(len(payloads), 1)
self.assertEqual(payloads[0].assetPath, "omniverse://test-ov-fake-server/fake/path/invalid/payload1.usd")
self.assertTrue(not not prim)
attribute = prim.GetAttribute("test")
self.assertTrue(attribute.GetTypeName() == Sdf.ValueTypeNames.Int)
self.assertTrue(attribute.Get() == 1)
| 36,841 | Python | 43.495169 | 120 | 0.614234 |
omniverse-code/kit/exts/omni.kit.usd.layers/omni/kit/usd/layers/tests/test_commands.py | from pathlib import Path
import omni.kit.test
import omni.kit.undo
import omni.kit.commands
import omni.timeline
import omni.usd
from omni.kit.usd.layers import LayerUtils, get_layers, LayerEditMode
from pxr import Gf, Kind, Sdf, Usd, UsdGeom, UsdShade, UsdUtils
CURRENT_PATH = Path(__file__).parent.parent.parent.parent.parent.parent.joinpath("data")
FILE_PATH_OmniPBR = CURRENT_PATH.joinpath("material_OmniPBR.usda").as_posix()
FILE_PATH_OmniGlass = CURRENT_PATH.joinpath("material_OmniGlass.usda").as_posix()
def get_stage_default_prim_path(stage):
if stage.HasDefaultPrim():
return stage.GetDefaultPrim().GetPath()
else:
return Sdf.Path.absoluteRootPath
class TestUsdCommands(omni.kit.test.AsyncTestCase):
# Before running each test
async def setUp(self):
self.usd_context = omni.usd.get_context()
await omni.usd.get_context().new_stage_async()
async def tearDown(self):
if omni.usd.get_context().get_stage():
await omni.usd.get_context().close_stage_async()
async def test_create_layer(self):
usd_context = omni.usd.get_context()
stage = usd_context.get_stage()
default_prim_path = get_stage_default_prim_path(stage)
root_layer = stage.GetRootLayer()
metadata = {"upAxis": "Z", "metersPerUnit": 0.005, "timeCodesPerSecond": 32}
if stage.HasDefaultPrim():
metadata["defaultPrim"] = stage.GetDefaultPrim().GetName()
for key, val in metadata.items():
stage.SetMetadata(key, val)
# make a sphere in the root layer to test the transfer content feature
with Usd.EditContext(stage, root_layer):
omni.kit.commands.execute("CreatePrim", prim_type="Sphere")
prim = stage.GetPrimAtPath(default_prim_path.AppendChild("Sphere"))
def check_layers(layers_info):
for key, desired_val in metadata.items():
val = stage.GetMetadata(key)
self.assertTrue(val == desired_val, "stage metadata changed")
self.assertTrue(len(layers_info) == len(root_layer.subLayerPaths), "number of layers")
for layer_info in layers_info:
index, anon, transfered = layer_info
# check assumes we only transfered content 0-1 times
layer = Sdf.Find(root_layer.subLayerPaths[index])
self.assertTrue(layer is not None, "layer is found")
prim = layer.GetPrimAtPath(default_prim_path.AppendChild("Sphere"))
if transfered:
self.assertTrue(prim, "prim was transferred")
else:
self.assertFalse(prim, "prim wasn't transferred")
# test one layer - anonymous - no transfer
# position_before, anonymous, transfer_root_content
omni.kit.commands.execute(
"CreateSublayer",
layer_identifier=root_layer.identifier,
sublayer_position=0,
new_layer_path="",
transfer_root_content=False,
create_or_insert=True,
)
check_layers([(0, True, False)])
omni.kit.undo.undo()
check_layers([])
omni.kit.undo.redo()
check_layers([(0, True, False)])
omni.kit.undo.undo()
check_layers([])
# test one layer - anonymous - transfer
omni.kit.commands.execute(
"CreateSublayer",
layer_identifier=root_layer.identifier,
sublayer_position=0,
new_layer_path="",
transfer_root_content=True,
create_or_insert=True,
)
check_layers([(0, True, True)])
omni.kit.undo.undo()
check_layers([])
omni.kit.undo.redo()
check_layers([(0, True, True)])
omni.kit.undo.undo()
check_layers([])
# test multiple layers - anonymous - no transfer
omni.kit.commands.execute(
"CreateSublayer",
layer_identifier=root_layer.identifier,
sublayer_position=0,
new_layer_path="",
transfer_root_content=False,
create_or_insert=True,
)
omni.kit.commands.execute(
"CreateSublayer",
layer_identifier=root_layer.identifier,
sublayer_position=1,
new_layer_path="",
transfer_root_content=False,
create_or_insert=True,
)
omni.kit.commands.execute(
"CreateSublayer",
layer_identifier=root_layer.identifier,
sublayer_position=2,
new_layer_path="",
transfer_root_content=False,
create_or_insert=True,
)
check_layers([(0, True, False), (1, True, False), (2, True, False)])
omni.kit.undo.undo()
check_layers([(0, True, False), (1, True, False)])
omni.kit.undo.redo()
check_layers([(0, True, False), (1, True, False), (2, True, False)])
omni.kit.undo.undo()
omni.kit.undo.undo()
check_layers([(0, True, False)])
omni.kit.undo.redo()
check_layers([(0, True, False), (1, True, False)])
omni.kit.undo.undo()
omni.kit.undo.undo()
check_layers([])
omni.kit.undo.redo()
check_layers([(0, True, False)])
omni.kit.undo.undo()
check_layers([])
async def test_replace_sublayer(self):
usd_context = omni.usd.get_context()
stage = usd_context.get_stage()
root_layer = stage.GetRootLayer()
omni.kit.commands.execute(
"CreateSublayer",
layer_identifier=root_layer.identifier,
sublayer_position=1,
new_layer_path="",
transfer_root_content=False,
create_or_insert=True,
)
sublayer_paths = root_layer.subLayerPaths
self.assertTrue(len(sublayer_paths) == 1)
sublayer1 = Sdf.Layer.FindOrOpen(sublayer_paths[0])
sublayer2 = Sdf.Layer.CreateAnonymous()
edit_target_identifier = LayerUtils.get_edit_target(stage)
self.assertTrue(edit_target_identifier == root_layer.identifier)
# Replace layer and check if it's successfull and edit target does not change.
omni.kit.commands.execute(
"ReplaceSublayer",
layer_identifier=root_layer.identifier,
sublayer_position=0,
new_layer_path=sublayer2.identifier,
)
edit_target_identifier = LayerUtils.get_edit_target(stage)
self.assertTrue(edit_target_identifier == root_layer.identifier)
sublayer_paths = root_layer.subLayerPaths
self.assertTrue(len(sublayer_paths) == 1)
self.assertTrue(sublayer_paths[0] == sublayer2.identifier)
omni.kit.undo.undo()
self.assertTrue(len(sublayer_paths) == 1)
sublayer_paths = root_layer.subLayerPaths
self.assertTrue(sublayer_paths[0] == sublayer1.identifier)
omni.kit.undo.redo()
self.assertTrue(len(sublayer_paths) == 1)
sublayer_paths = root_layer.subLayerPaths
self.assertTrue(sublayer_paths[0] == sublayer2.identifier)
omni.kit.undo.undo()
# Sets sublayer as edit target and do the replacement to see if edit target is changed or not.
LayerUtils.set_edit_target(stage, sublayer1.identifier)
omni.kit.commands.execute(
"ReplaceSublayer",
layer_identifier=root_layer.identifier,
sublayer_position=0,
new_layer_path=sublayer2.identifier,
)
edit_target_identifier = LayerUtils.get_edit_target(stage)
self.assertTrue(edit_target_identifier == sublayer2.identifier)
sublayer_paths = root_layer.subLayerPaths
self.assertTrue(len(sublayer_paths) == 1)
self.assertTrue(sublayer_paths[0] == sublayer2.identifier)
omni.kit.undo.undo()
edit_target_identifier = LayerUtils.get_edit_target(stage)
self.assertTrue(edit_target_identifier == sublayer1.identifier)
# Replace a invalid index will fail.
omni.kit.commands.execute(
"ReplaceSublayer",
layer_identifier=root_layer.identifier,
sublayer_position=100,
new_layer_path=sublayer2.identifier,
)
self.assertTrue(len(sublayer_paths) == 1)
sublayer_paths = root_layer.subLayerPaths
self.assertEqual(sublayer_paths[0], sublayer1.identifier)
async def test_move_nodes(self):
# move nodes also uses merge nodes and remove nodes
usd_context = omni.usd.get_context()
stage = usd_context.get_stage()
default_prim_path = get_stage_default_prim_path(stage)
root_layer = stage.GetRootLayer()
# create anonymous layers
LayerUtils.create_sublayer(root_layer, 0, "")
LayerUtils.create_sublayer(root_layer, 1, "")
LayerUtils.create_sublayer(root_layer, 2, "")
strong_layer = Sdf.Find(root_layer.subLayerPaths[0])
intermediate_layer = Sdf.Find(root_layer.subLayerPaths[1])
weak_layer = Sdf.Find(root_layer.subLayerPaths[2])
# add some content
# root: stage/cone* height=0.7
# strong: stage/sphere* radius=0.5, stage/cone
# intermediate: empty
# weak: stage/sphere radius=1.234
with Usd.EditContext(stage, weak_layer):
omni.kit.commands.execute("CreatePrim", prim_type="Sphere")
prim = stage.GetPrimAtPath(default_prim_path.AppendChild("Sphere"))
sphere = UsdGeom.Sphere(prim)
with Usd.EditContext(stage, weak_layer):
sphere.CreateRadiusAttr(1.234)
with Usd.EditContext(stage, strong_layer):
sphere.CreateRadiusAttr(0.5)
with Usd.EditContext(stage, strong_layer):
omni.kit.commands.execute("CreatePrim", prim_type="Cone")
prim = stage.GetPrimAtPath(default_prim_path.AppendChild("Cone"))
cone = UsdGeom.Cone(prim)
with Usd.EditContext(stage, root_layer):
cone.CreateHeightAttr(0.7)
def everything_normal():
sphere = UsdGeom.Sphere(stage.GetPrimAtPath(default_prim_path.AppendChild("Sphere")))
cone = UsdGeom.Cone(stage.GetPrimAtPath(default_prim_path.AppendChild("Cone")))
self.assertTrue(
len(stage.GetRootLayer().subLayerPaths) == 3, "Three layers"
) # 3 sublayers of root plus root and session layer
self.assertTrue(sphere.GetRadiusAttr().Get() == 0.5)
layer_identifier = LayerUtils.get_sublayer_identifier(root_layer.identifier, 0)
stage.MuteLayer(layer_identifier) # mute the strongest layer
self.assertTrue(sphere.GetRadiusAttr().Get() == 1.234)
stage.UnmuteLayer(layer_identifier) # unmute the strongest layer
self.assertTrue(sphere.GetRadiusAttr().Get() == 0.5)
self.assertTrue(cone.GetHeightAttr().Get() == 0.7)
everything_normal()
omni.kit.commands.execute(
"MovePrimSpecsToLayer",
dst_layer_identifier=strong_layer.identifier,
src_layer_identifier=weak_layer.identifier,
prim_spec_path=default_prim_path.AppendChild("Sphere").pathString,
dst_stronger_than_src=True,
)
def check_1():
# check that Stage/Sphere is only in the strong layer with merged value
sphere = UsdGeom.Sphere(stage.GetPrimAtPath(default_prim_path.AppendChild("Sphere")))
self.assertEqual(sphere.GetRadiusAttr().Get(), 0.5)
layer_identifier = LayerUtils.get_sublayer_identifier(root_layer.identifier, 0)
stage.MuteLayer(layer_identifier) # mute the strongest layer
self.assertFalse(stage.GetPrimAtPath(default_prim_path.AppendChild("Sphere")))
stage.UnmuteLayer(layer_identifier) # unmute the strongest layer
check_1()
omni.kit.undo.undo()
everything_normal()
omni.kit.undo.redo()
check_1()
omni.kit.undo.undo()
everything_normal()
# Strong to weak
omni.kit.commands.execute(
"MovePrimSpecsToLayer",
dst_layer_identifier=weak_layer.identifier,
src_layer_identifier=strong_layer.identifier,
prim_spec_path=default_prim_path.AppendChild("Sphere").pathString,
dst_stronger_than_src=False,
)
def check_2():
# other layers [2, ROOT] should only contain stage. [0] should have cone and sphere
self.assertFalse(strong_layer.GetPrimAtPath(default_prim_path.AppendChild("Sphere")))
# Radius will be the strong one
sphere = UsdGeom.Sphere(stage.GetPrimAtPath(default_prim_path.AppendChild("Sphere")))
self.assertTrue(sphere.GetRadiusAttr().Get() == 0.5)
check_2()
omni.kit.undo.undo()
everything_normal()
omni.kit.undo.redo()
check_2()
omni.kit.undo.undo()
everything_normal()
async def test_flatten_layers(self):
# Note: FlattenLayers also uses MergeLayers and RemoveLayer
usd_context = omni.usd.get_context()
stage = usd_context.get_stage()
default_prim_path = get_stage_default_prim_path(stage)
root_layer = stage.GetRootLayer()
# When no layers are created, the total layers are 2 (root and session layer).
omni.kit.commands.execute("FlattenLayers")
self.assertTrue(len(root_layer.subLayerPaths) == 0)
omni.kit.undo.undo()
self.assertTrue(len(root_layer.subLayerPaths) == 0)
path = LayerUtils.create_sublayer(root_layer, 0, "").identifier # strong_layer
layer = Sdf.Layer.FindOrOpen(path)
self.assertTrue(layer, "layer is found before flatten")
omni.kit.commands.execute("FlattenLayers")
self.assertTrue(len(root_layer.subLayerPaths) == 0)
omni.kit.undo.undo()
self.assertTrue(len(root_layer.subLayerPaths) == 1)
self.assertTrue(Sdf.Find(path), "layer is found after undo")
LayerUtils.create_sublayer(root_layer, 1, "") # intermediate_layer
LayerUtils.create_sublayer(root_layer, 2, "") # weak_layer
self.assertTrue(len(root_layer.subLayerPaths) == 3)
strong_layer = Sdf.Find(root_layer.subLayerPaths[0])
intermediate_layer = Sdf.Find(root_layer.subLayerPaths[1])
weak_layer = Sdf.Find(root_layer.subLayerPaths[2])
self.assertTrue(strong_layer, "strong_layer")
self.assertTrue(intermediate_layer, "intermediate_layer")
self.assertTrue(weak_layer, "weak_layer")
with Usd.EditContext(stage, weak_layer):
omni.kit.commands.execute("CreatePrim", prim_type="Sphere")
prim = stage.GetPrimAtPath(default_prim_path.AppendChild("Sphere"))
self.assertTrue(prim, "Prim exists")
sphere = UsdGeom.Sphere(prim)
with Usd.EditContext(stage, intermediate_layer):
sphere.CreateRadiusAttr(0.987)
with Usd.EditContext(stage, strong_layer):
sphere.CreateRadiusAttr(1.234)
omni.kit.commands.execute("FlattenLayers")
self.assertTrue(len(root_layer.subLayerPaths) == 0)
prim = stage.GetPrimAtPath(default_prim_path.AppendChild("Sphere"))
self.assertTrue(prim)
sphere = UsdGeom.Sphere(prim)
self.assertTrue(sphere.GetRadiusAttr().Get() == 1.234)
omni.kit.undo.undo()
self.assertTrue(len(root_layer.subLayerPaths) == 3)
layer_identifier = LayerUtils.get_sublayer_identifier(root_layer.identifier, 0)
stage.MuteLayer(layer_identifier) # mute the strongest layer
prim = stage.GetPrimAtPath(default_prim_path.AppendChild("Sphere"))
self.assertTrue(prim)
sphere = UsdGeom.Sphere(prim)
self.assertTrue(sphere.GetRadiusAttr().Get() == 0.987)
# OM-77653: Test for making sure flattening will not retime timesamples.
await usd_context.new_stage_async()
layer = Sdf.Layer.CreateAnonymous()
layer_content = """#sdf 1.0
(
defaultPrim = "World"
endTimeCode = 100
metersPerUnit = 0.01
startTimeCode = 0
timeCodesPerSecond = 30
upAxis = "Y"
)
def Xform "World"
{
def Mesh "Cube_30"
{
float3[] extent = [(-50, -50, -50), (50, 50, 50)]
int[] faceVertexCounts = [4, 4, 4, 4, 4, 4]
int[] faceVertexIndices = [0, 1, 3, 2, 0, 4, 5, 1, 1, 5, 6, 3, 2, 3, 6, 7, 0, 2, 7, 4, 4, 7, 6, 5]
normal3f[] normals = [(0, -1, 0), (0, -1, 0), (0, -1, 0), (0, -1, 0), (0, 0, -1), (0, 0, -1), (0, 0, -1), (0, 0, -1), (1, 0, 0), (1, 0, 0), (1, 0, 0), (1, 0, 0), (0, 0, 1), (0, 0, 1), (0, 0, 1), (0, 0, 1), (-1, 0, 0), (-1, 0, 0), (-1, 0, 0), (-1, 0, 0), (0, 1, 0), (0, 1, 0), (0, 1, 0), (0, 1, 0)] (
interpolation = "faceVarying"
)
point3f[] points = [(-50, -50, -50), (50, -50, -50), (-50, -50, 50), (50, -50, 50), (-50, 50, -50), (50, 50, -50), (50, 50, 50), (-50, 50, 50)]
float2[] primvars:st = [(1, 0), (0, 0), (0, 1), (1, 1), (1, 0), (1, 1), (0, 1), (0, 0), (1, 0), (0, 0), (0, 1), (1, 1), (1, 0), (0, 0), (0, 1), (1, 1), (1, 0), (1, 1), (0, 1), (0, 0), (1, 0), (1, 1), (0, 1), (0, 0)] (
interpolation = "faceVarying"
)
uniform token subdivisionScheme = "none"
double3 xformOp:rotateXYZ = (0, 0, 0)
double3 xformOp:scale = (1, 1, 1)
double3 xformOp:translate = (0, 0, 0)
double3 xformOp:translate.timeSamples = {
0: (0, 0, 0),
100: (0, 100, 0),
}
uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
}
}
"""
layer.ImportFromString(layer_content)
stage = usd_context.get_stage()
stage.GetRootLayer().subLayerPaths.append(layer.identifier)
UsdUtils.CopyLayerMetadata(layer, stage.GetRootLayer(), True)
omni.kit.commands.execute("FlattenLayers")
expected_string = """#usda 1.0
(
defaultPrim = "World"
endTimeCode = 100
metersPerUnit = 0.01
startTimeCode = 0
timeCodesPerSecond = 30
upAxis = "Y"
)
def Xform "World"
{
def Mesh "Cube_30"
{
float3[] extent = [(-50, -50, -50), (50, 50, 50)]
int[] faceVertexCounts = [4, 4, 4, 4, 4, 4]
int[] faceVertexIndices = [0, 1, 3, 2, 0, 4, 5, 1, 1, 5, 6, 3, 2, 3, 6, 7, 0, 2, 7, 4, 4, 7, 6, 5]
normal3f[] normals = [(0, -1, 0), (0, -1, 0), (0, -1, 0), (0, -1, 0), (0, 0, -1), (0, 0, -1), (0, 0, -1), (0, 0, -1), (1, 0, 0), (1, 0, 0), (1, 0, 0), (1, 0, 0), (0, 0, 1), (0, 0, 1), (0, 0, 1), (0, 0, 1), (-1, 0, 0), (-1, 0, 0), (-1, 0, 0), (-1, 0, 0), (0, 1, 0), (0, 1, 0), (0, 1, 0), (0, 1, 0)] (
interpolation = "faceVarying"
)
point3f[] points = [(-50, -50, -50), (50, -50, -50), (-50, -50, 50), (50, -50, 50), (-50, 50, -50), (50, 50, -50), (50, 50, 50), (-50, 50, 50)]
float2[] primvars:st = [(1, 0), (0, 0), (0, 1), (1, 1), (1, 0), (1, 1), (0, 1), (0, 0), (1, 0), (0, 0), (0, 1), (1, 1), (1, 0), (0, 0), (0, 1), (1, 1), (1, 0), (1, 1), (0, 1), (0, 0), (1, 0), (1, 1), (0, 1), (0, 0)] (
interpolation = "faceVarying"
)
uniform token subdivisionScheme = "none"
double3 xformOp:rotateXYZ = (0, 0, 0)
double3 xformOp:scale = (1, 1, 1)
double3 xformOp:translate = (0, 0, 0)
double3 xformOp:translate.timeSamples = {
0: (0, 0, 0),
100: (0, 100, 0),
}
uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
}
}"""
self.assertEqual(stage.GetRootLayer().ExportToString().strip(), expected_string.strip())
async def test_merge_layers(self):
# Note: FlattenLayers also uses MergeLayers and RemoveLayer
usd_context = omni.usd.get_context()
stage = usd_context.get_stage()
default_prim_path = get_stage_default_prim_path(stage)
root_layer = stage.GetRootLayer()
path = LayerUtils.create_sublayer(root_layer, 0, "").identifier # strong_layer
self.assertTrue(Sdf.Find(path), "layer is found before merge")
LayerUtils.create_sublayer(root_layer, 1, "") # intermediate_layer
LayerUtils.create_sublayer(root_layer, 2, "") # weak_layer
self.assertTrue(len(root_layer.subLayerPaths) == 3)
strong_layer = Sdf.Find(root_layer.subLayerPaths[0])
intermediate_layer = Sdf.Find(root_layer.subLayerPaths[1])
weak_layer = Sdf.Find(root_layer.subLayerPaths[2])
self.assertTrue(strong_layer, "strong_layer")
self.assertTrue(intermediate_layer, "intermediate_layer")
self.assertTrue(weak_layer, "weak_layer")
with Usd.EditContext(stage, weak_layer):
omni.kit.commands.execute("CreatePrim", prim_type="Sphere")
prim = stage.GetPrimAtPath(default_prim_path.AppendChild("Sphere"))
self.assertTrue(prim, "Prim exists")
sphere = UsdGeom.Sphere(prim)
with Usd.EditContext(stage, intermediate_layer):
sphere.CreateRadiusAttr(0.987)
with Usd.EditContext(stage, strong_layer):
sphere.CreateRadiusAttr(1.234)
omni.kit.commands.execute(
"MergeLayers",
dst_parent_layer_identifier=root_layer.identifier,
dst_layer_identifier=strong_layer.identifier,
src_parent_layer_identifier=root_layer.identifier,
src_layer_identifier=intermediate_layer.identifier,
dst_stronger_than_src=True,
)
self.assertTrue(len(root_layer.subLayerPaths) == 2)
prim = stage.GetPrimAtPath(default_prim_path.AppendChild("Sphere"))
self.assertTrue(prim)
sphere = UsdGeom.Sphere(prim)
self.assertTrue(sphere.GetRadiusAttr().Get() == 1.234)
omni.kit.undo.undo()
self.assertTrue(len(root_layer.subLayerPaths) == 3)
layer_identifier = strong_layer.identifier
stage.MuteLayer(layer_identifier) # mute the strongest layer
prim = stage.GetPrimAtPath(default_prim_path.AppendChild("Sphere"))
self.assertTrue(prim)
sphere = UsdGeom.Sphere(prim)
self.assertTrue(sphere.GetRadiusAttr().Get() == 0.987)
stage.UnmuteLayer(layer_identifier)
# Assumes we want to overide strong layer's radius with intermediate one.
omni.kit.commands.execute(
"MergeLayers",
dst_parent_layer_identifier=root_layer.identifier,
dst_layer_identifier=strong_layer.identifier,
src_parent_layer_identifier=root_layer.identifier,
src_layer_identifier=intermediate_layer.identifier,
dst_stronger_than_src=False,
)
self.assertTrue(len(root_layer.subLayerPaths) == 2)
prim = stage.GetPrimAtPath(default_prim_path.AppendChild("Sphere"))
self.assertTrue(prim)
sphere = UsdGeom.Sphere(prim)
self.assertTrue(sphere.GetRadiusAttr().Get() == 0.987)
omni.kit.undo.undo()
prim = stage.GetPrimAtPath(default_prim_path.AppendChild("Sphere"))
self.assertTrue(prim)
sphere = UsdGeom.Sphere(prim)
self.assertTrue(sphere.GetRadiusAttr().Get() == 1.234)
layer_identifier = strong_layer.identifier
stage.MuteLayer(layer_identifier) # mute the strongest layer
prim = stage.GetPrimAtPath(default_prim_path.AppendChild("Sphere"))
self.assertTrue(prim)
sphere = UsdGeom.Sphere(prim)
self.assertTrue(sphere.GetRadiusAttr().Get() == 0.987)
stage.UnmuteLayer(layer_identifier)
async def test_remove_layer(self):
usd_context = omni.usd.get_context()
stage = usd_context.get_stage()
default_prim_path = get_stage_default_prim_path(stage)
root_layer = stage.GetRootLayer()
LayerUtils.create_sublayer(root_layer, 0, "")
LayerUtils.create_sublayer(root_layer, 1, "")
LayerUtils.create_sublayer(root_layer, 2, "")
layer = Sdf.Find(root_layer.subLayerPaths[2])
identifier = layer.identifier
sphere_path = default_prim_path.AppendChild("Sphere")
with Usd.EditContext(stage, layer):
omni.kit.commands.execute("CreatePrim", prim_type="Sphere")
with Usd.EditContext(stage, root_layer):
prim = stage.GetPrimAtPath(sphere_path)
sphere = UsdGeom.Sphere(prim)
sphere.CreateRadiusAttr(1.234)
def check_exists():
self.assertTrue(len(root_layer.subLayerPaths) == 3, "There are the correct number of sublayers")
self.assertTrue(stage.GetPrimAtPath(sphere_path), "The prim exists")
sphere = UsdGeom.Sphere(stage.GetPrimAtPath(sphere_path))
radius = sphere.GetRadiusAttr().Get()
self.assertTrue(radius == 1.234, "The sphere has the correct attr")
layer = Sdf.Find(root_layer.subLayerPaths[2])
self.assertTrue(identifier == layer.identifier, "{} should equal {}".format(identifier, layer.identifier))
def check_does_not_exist():
self.assertTrue(len(root_layer.subLayerPaths) == 2, "The layer was removed")
prim = stage.GetPrimAtPath(sphere_path)
self.assertFalse(prim.IsDefined(), "Prim is not removed")
check_exists()
omni.kit.commands.execute("RemoveSublayer", layer_identifier=root_layer.identifier, sublayer_position=2)
check_does_not_exist()
omni.kit.undo.undo()
check_exists()
async def test_move_layer(self):
usd_context = omni.usd.get_context()
stage = usd_context.get_stage()
root_layer = stage.GetRootLayer()
identifier1 = LayerUtils.create_sublayer(root_layer, 0, "").identifier
identifier2 = LayerUtils.create_sublayer(root_layer, 1, "").identifier
identifier3 = LayerUtils.create_sublayer(root_layer, 2, "").identifier
def check_layers(layers_info):
self.assertTrue(len(layers_info) == len(root_layer.subLayerPaths), "number of layers")
for layer_info in layers_info:
index, identifier = layer_info
layer_identifier = LayerUtils.get_sublayer_identifier(root_layer.identifier, index)
self.assertTrue(identifier == layer_identifier, "layer identifier")
layer = Sdf.Find(layer_identifier)
self.assertTrue(layer is not None, "layer is found")
check_layers([(0, identifier1), (1, identifier2), (2, identifier3)])
omni.kit.commands.execute(
"MoveSublayer",
from_parent_layer_identifier=root_layer.identifier,
from_sublayer_position=2,
to_parent_layer_identifier=root_layer.identifier,
to_sublayer_position=0,
remove_source=True,
)
check_layers([(0, identifier3), (1, identifier1), (2, identifier2)])
omni.kit.undo.undo()
check_layers([(0, identifier1), (1, identifier2), (2, identifier3)])
# Move invalid layer will fail to execute
omni.kit.commands.execute(
"MoveSublayer",
from_parent_layer_identifier=root_layer.identifier,
from_sublayer_position=-100,
to_parent_layer_identifier=root_layer.identifier,
to_sublayer_position=0,
remove_source=True,
)
check_layers([(0, identifier1), (1, identifier2), (2, identifier3)])
# Move layer outside of layer stack will fail to execute
omni.kit.commands.execute(
"MoveSublayer",
from_parent_layer_identifier=root_layer.identifier,
from_sublayer_position=100,
to_parent_layer_identifier=root_layer.identifier,
to_sublayer_position=0,
remove_source=True,
)
check_layers([(0, identifier1), (1, identifier2), (2, identifier3)])
# Move layer to position that passes the end of layer stack will move this layer to the end of the stack
omni.kit.commands.execute(
"MoveSublayer",
from_parent_layer_identifier=root_layer.identifier,
from_sublayer_position=0,
to_parent_layer_identifier=root_layer.identifier,
to_sublayer_position=100,
remove_source=True,
)
check_layers([(0, identifier2), (1, identifier3), (2, identifier1)])
omni.kit.undo.undo()
check_layers([(0, identifier1), (1, identifier2), (2, identifier3)])
# Move layer to position before the last layer
omni.kit.commands.execute(
"MoveSublayer",
from_parent_layer_identifier=root_layer.identifier,
from_sublayer_position=0,
to_parent_layer_identifier=root_layer.identifier,
to_sublayer_position=-1,
remove_source=True,
)
check_layers([(0, identifier2), (1, identifier3), (2, identifier1)])
omni.kit.undo.undo()
check_layers([(0, identifier1), (1, identifier2), (2, identifier3)])
async def test_select_layer(self):
usd_context = omni.usd.get_context()
stage = usd_context.get_stage()
root_layer = stage.GetRootLayer()
identifier1 = LayerUtils.create_sublayer(root_layer, 0, "").identifier
identifier2 = LayerUtils.create_sublayer(root_layer, 1, "").identifier
identifier3 = LayerUtils.create_sublayer(root_layer, 2, "").identifier
LayerUtils.set_edit_target(stage, identifier3)
edit_target = stage.GetEditTarget()
current_selected_layer = edit_target.GetLayer().identifier
self.assertTrue(current_selected_layer == identifier3) # root layer
omni.kit.commands.execute("SetEditTarget", layer_identifier=identifier1)
edit_target = stage.GetEditTarget()
current_selected_layer = edit_target.GetLayer().identifier
self.assertTrue(current_selected_layer == identifier1)
omni.kit.undo.undo()
edit_target = stage.GetEditTarget()
current_selected_layer = edit_target.GetLayer().identifier
self.assertTrue(current_selected_layer == identifier3)
# Select invalid layer will keep the current edit target not changed.
omni.kit.commands.execute("SetEditTarget", layer_identifier="")
edit_target = stage.GetEditTarget()
current_selected_layer = edit_target.GetLayer().identifier
self.assertTrue(current_selected_layer == identifier3)
omni.kit.undo.undo()
omni.kit.commands.execute("SetEditTarget", layer_identifier=identifier2)
edit_target = stage.GetEditTarget()
current_selected_layer = edit_target.GetLayer().identifier
self.assertTrue(current_selected_layer == identifier2)
omni.kit.undo.undo()
edit_target = stage.GetEditTarget()
current_selected_layer = edit_target.GetLayer().identifier
self.assertTrue(current_selected_layer == identifier3)
async def test_layer_lock(self):
usd_context = omni.usd.get_context()
stage = usd_context.get_stage()
root_layer = stage.GetRootLayer()
sublayer = LayerUtils.create_sublayer(root_layer, 0, "")
omni.kit.commands.execute("LockLayer", layer_identifier=root_layer.identifier, locked=True)
self.assertFalse(LayerUtils.get_layer_lock_status(root_layer, root_layer.identifier))
LayerUtils.set_edit_target(stage, sublayer.identifier)
self.assertEqual(LayerUtils.get_edit_target(stage), sublayer.identifier)
omni.kit.commands.execute("LockLayer", layer_identifier=sublayer.identifier, locked=True)
self.assertEqual(LayerUtils.get_edit_target(stage), root_layer.identifier)
self.assertTrue(LayerUtils.get_layer_lock_status(root_layer, sublayer.identifier))
omni.kit.undo.undo()
self.assertEqual(LayerUtils.get_edit_target(stage), sublayer.identifier)
self.assertFalse(LayerUtils.get_layer_lock_status(root_layer, sublayer.identifier))
async def test_unmute_layer(self):
usd_context = omni.usd.get_context()
stage = usd_context.get_stage()
root_layer = stage.GetRootLayer()
layer3 = LayerUtils.create_sublayer(root_layer, 2, "")
identifier3 = layer3.identifier
LayerUtils.set_edit_target(stage, identifier3)
current_selected_layer = LayerUtils.get_edit_target(stage)
self.assertTrue(current_selected_layer == identifier3)
# mute root layer will do nothing
omni.kit.commands.execute("SetLayerMuteness", layer_identifier=root_layer.identifier, muted=True)
current_selected_layer = LayerUtils.get_edit_target(stage)
self.assertEqual(current_selected_layer, identifier3)
# mute invalid layer will do nothing
omni.kit.commands.execute("SetLayerMuteness", layer_identifier="", muted=True)
current_selected_layer = LayerUtils.get_edit_target(stage)
self.assertEqual(current_selected_layer, identifier3)
# mute layer 2
omni.kit.commands.execute("SetLayerMuteness", layer_identifier=identifier3, muted=True)
self.assertTrue(stage.IsLayerMuted(identifier3))
current_selected_layer = LayerUtils.get_edit_target(stage)
self.assertNotEqual(current_selected_layer, identifier3)
omni.kit.undo.undo()
current_selected_layer = LayerUtils.get_edit_target(stage)
self.assertEqual(current_selected_layer, identifier3)
self.assertTrue(not stage.IsLayerMuted(identifier3))
# mute, then unmute
omni.kit.commands.execute("SetLayerMuteness", layer_identifier=identifier3, muted=True)
omni.kit.commands.execute("SetLayerMuteness", layer_identifier=identifier3, muted=False)
self.assertTrue(not stage.IsLayerMuted(identifier3))
omni.kit.undo.undo()
self.assertTrue(stage.IsLayerMuted(identifier3))
omni.kit.undo.undo()
self.assertTrue(not stage.IsLayerMuted(identifier3))
async def test_stitch_prim_specss_command(self):
# move nodes also uses merge nodes and remove nodes
usd_context = omni.usd.get_context()
stage = usd_context.get_stage()
default_prim_path = get_stage_default_prim_path(stage)
root_layer = stage.GetRootLayer()
# create anonymous layers
strong_layer = LayerUtils.create_sublayer(root_layer, 0, "")
intermediate_layer = LayerUtils.create_sublayer(root_layer, 1, "")
weak_layer = LayerUtils.create_sublayer(root_layer, 2, "")
# add some content
# root: stage/cone* height=0.7
# strong: stage/sphere* radius=0.5, stage/cone
# intermediate: empty
# weak: stage/sphere radius=1.234
with Usd.EditContext(stage, weak_layer):
omni.kit.commands.execute("CreatePrimCommand", prim_type="Sphere")
prim = stage.GetPrimAtPath(default_prim_path.AppendChild("Sphere"))
sphere = UsdGeom.Sphere(prim)
with Usd.EditContext(stage, weak_layer):
sphere.CreateRadiusAttr(1.234)
with Usd.EditContext(stage, strong_layer):
sphere.CreateRadiusAttr(0.5)
with Usd.EditContext(stage, strong_layer):
omni.kit.commands.execute("CreatePrimCommand", prim_type="Cone")
prim = stage.GetPrimAtPath(default_prim_path.AppendChild("Cone"))
cone = UsdGeom.Cone(prim)
with Usd.EditContext(stage, root_layer):
cone.CreateHeightAttr(0.7)
def everything_normal():
sphere = UsdGeom.Sphere(stage.GetPrimAtPath(default_prim_path.AppendChild("Sphere")))
cone = UsdGeom.Cone(stage.GetPrimAtPath(default_prim_path.AppendChild("Cone")))
self.assertTrue(
len(stage.GetRootLayer().subLayerPaths) == 3, "Three layers"
) # 3 sublayers of root plus root and session layer
self.assertTrue(sphere.GetRadiusAttr().Get() == 0.5)
layer_identifier = LayerUtils.get_sublayer_identifier(root_layer.identifier, 0)
stage.MuteLayer(layer_identifier) # mute the strongest layer
self.assertTrue(sphere.GetRadiusAttr().Get() == 1.234)
stage.UnmuteLayer(layer_identifier) # unmute the strongest layer
self.assertTrue(sphere.GetRadiusAttr().Get() == 0.5)
self.assertTrue(cone.GetHeightAttr().Get() == 0.7)
everything_normal()
omni.kit.commands.execute(
"StitchPrimSpecsToLayer",
prim_paths=[default_prim_path.AppendChild("Sphere").pathString],
target_layer_identifier=strong_layer.identifier,
)
def check_1():
# check that Stage/Sphere is only in the strong layer with merged value
sphere = UsdGeom.Sphere(stage.GetPrimAtPath(default_prim_path.AppendChild("Sphere")))
self.assertEqual(sphere.GetRadiusAttr().Get(), 0.5)
check_1()
omni.kit.undo.undo()
everything_normal()
omni.kit.undo.redo()
check_1()
omni.kit.undo.undo()
everything_normal()
# Strong to weak
omni.kit.commands.execute(
"StitchPrimSpecsToLayer",
prim_paths=[default_prim_path.AppendChild("Sphere").pathString],
target_layer_identifier=weak_layer.identifier,
)
check_1()
omni.kit.undo.undo()
everything_normal()
omni.kit.undo.redo()
check_1()
omni.kit.undo.undo()
everything_normal()
async def test_layer_removal_with_stage_update(self):
usd_context = omni.usd.get_context()
stage = usd_context.get_stage()
root_layer = stage.GetRootLayer()
# insert a subLayer with material.usda which contains just one material prim
omni.kit.commands.execute(
"CreateSublayer",
layer_identifier=root_layer.identifier,
sublayer_position=0,
new_layer_path=FILE_PATH_OmniPBR,
transfer_root_content=False,
create_or_insert=False,
)
await omni.kit.app.get_app().next_update_async()
# check the material prim is defined in the stage
material_prim = stage.GetPrimAtPath("/World/Looks/OmniPBR")
self.assertTrue(material_prim.IsDefined())
# remove the subLayer
omni.kit.commands.execute("RemoveSublayer", layer_identifier=root_layer.identifier, sublayer_position=0)
await omni.kit.app.get_app().next_update_async()
# check the material prim is not there anymore
material_prim = stage.GetPrimAtPath("/World/Looks/OmniPBR")
self.assertFalse(material_prim.IsValid())
# check the parent folder scope is removed too
scope_prim = stage.GetPrimAtPath("/World/Looks")
self.assertFalse(scope_prim.IsValid())
# insert the subLayer again
omni.kit.commands.execute(
"CreateSublayer",
layer_identifier=root_layer.identifier,
sublayer_position=0,
new_layer_path=FILE_PATH_OmniPBR,
transfer_root_content=False,
create_or_insert=False,
)
await omni.kit.app.get_app().next_update_async()
# check both material prims are defined in the stage
material_prim = stage.GetPrimAtPath("/World/Looks/OmniPBR")
self.assertTrue(material_prim.IsDefined())
# insert another subLayer
omni.kit.commands.execute(
"CreateSublayer",
layer_identifier=root_layer.identifier,
sublayer_position=1,
new_layer_path=FILE_PATH_OmniGlass,
transfer_root_content=False,
create_or_insert=False,
)
await omni.kit.app.get_app().next_update_async()
# check both material prims are defined in the stage
material_prim = stage.GetPrimAtPath("/World/Looks/OmniGlass")
self.assertTrue(material_prim.IsDefined())
# remove the first subLayer
omni.kit.commands.execute("RemoveSublayer", layer_identifier=root_layer.identifier, sublayer_position=0)
await omni.kit.app.get_app().next_update_async()
# check the material prim is not there anymore
material_prim = stage.GetPrimAtPath("/World/Looks/OmniPBR")
self.assertFalse(material_prim.IsValid())
# check the second sublayer is still there
scope_prim = stage.GetPrimAtPath("/World/Looks")
self.assertTrue(scope_prim.IsValid())
material_prim = stage.GetPrimAtPath("/World/Looks/OmniGlass")
self.assertTrue(material_prim.IsDefined())
def __get_all_property_paths(self, prim):
paths = []
for p in prim.GetProperties():
paths.append(str(p.GetPath()))
return paths
def __get_all_prim_childrens(self, prim, hierarchy=False):
paths = [str(prim.GetPath())]
paths.extend(self.__get_all_property_paths(prim))
if hierarchy:
for child in prim.GetAllPrimChildren():
paths.append(str(child.GetPath()))
paths.extend(self.__get_all_property_paths(child))
return paths
def __get_all_stage_paths(self, stage):
paths = []
for prim in stage.TraverseAll():
paths.extend(self.__get_all_prim_childrens(prim))
return paths
async def test_link_specs_command(self):
layers = get_layers()
specs_linking = layers.get_specs_linking()
context = omni.usd.get_context()
layers.set_edit_mode(LayerEditMode.SPECS_LINKING)
stage = context.get_stage()
root_layer = stage.GetRootLayer()
layer0 = Sdf.Layer.CreateAnonymous()
layer1 = Sdf.Layer.CreateAnonymous()
layer2 = Sdf.Layer.CreateAnonymous()
root_layer.subLayerPaths.append(layer0.identifier)
root_layer.subLayerPaths.append(layer1.identifier)
root_layer.subLayerPaths.append(layer2.identifier)
asset_name = f"/root/test0/l1/l2/l3"
asset_prim = stage.DefinePrim(asset_name, "Xform")
all_spec_paths = set(self.__get_all_stage_paths(stage))
await omni.kit.app.get_app().next_update_async()
specs_linking.link_spec("/root/test0", layer0.identifier, hierarchy=True)
old_links = specs_linking.get_all_spec_links()
for path in ["/", "/root", "/root/test0", "/root/test0/l1/l2/l3"]:
for hierarchy in [False, True]:
for additive in [False, True]:
omni.kit.commands.execute(
"LinkSpecs",
spec_paths=path,
layer_identifiers=layer1.identifier,
additive=additive,
hierarchy=hierarchy,
)
if path.startswith("/root/test0"):
base_path = path
else:
base_path = "/root/test0"
# Make sure it's linked successfully
links = specs_linking.get_all_spec_links()
for spec_path, layers in links.items():
if hierarchy:
if spec_path.startswith(base_path):
if not additive:
self.assertEqual(set(layers), set([layer1.identifier]))
else:
self.assertEqual(set(layers), set([layer0.identifier, layer1.identifier]))
else:
if spec_path.startswith("/root/test0"):
self.assertEqual(set(layers), set([layer0.identifier]))
else:
self.assertEqual(set(layers), set([layer1.identifier]))
else:
sdf_path = Sdf.Path(spec_path)
if str(sdf_path.GetPrimPath()) == path:
if spec_path.startswith(base_path):
if not additive:
self.assertEqual(set(layers), set([layer1.identifier]))
else:
self.assertEqual(set(layers), set([layer0.identifier, layer1.identifier]))
else:
if spec_path.startswith("/root/test0"):
self.assertEqual(set(layers), set([layer0.identifier]))
else:
self.assertEqual(set(layers), set([layer1.identifier]))
else:
self.assertEqual(set(layers), set([layer0.identifier]))
omni.kit.undo.undo()
# Make sure it's returned to old states.
new_links = specs_linking.get_all_spec_links()
self.__compare_links_map(old_links, new_links)
def __compare_links_map(self, old_links, new_links):
for path, layers in old_links.items():
self.assertTrue(path in new_links, f"Spec {path} is not existed in new links.")
new_layers = new_links.get(path)
self.assertEqual(set(layers), set(new_layers), f"Links spec {path} are different.")
async def test_unlink_specs_command(self):
layers = get_layers()
specs_linking = layers.get_specs_linking()
context = omni.usd.get_context()
layers.set_edit_mode(LayerEditMode.SPECS_LINKING)
stage = context.get_stage()
root_layer = stage.GetRootLayer()
layer0 = Sdf.Layer.CreateAnonymous()
layer1 = Sdf.Layer.CreateAnonymous()
layer2 = Sdf.Layer.CreateAnonymous()
root_layer.subLayerPaths.append(layer0.identifier)
root_layer.subLayerPaths.append(layer1.identifier)
root_layer.subLayerPaths.append(layer2.identifier)
asset_name = f"/root/test0/l1/l2/l3"
asset_prim = stage.DefinePrim(asset_name, "Xform")
all_spec_paths = set(self.__get_all_stage_paths(stage))
await omni.kit.app.get_app().next_update_async()
for layer_identifier in [layer0.identifier, layer1.identifier]:
specs_linking.link_spec("/root/test0", layer_identifier, hierarchy=True)
old_links = specs_linking.get_all_spec_links()
for path in ["/", "/root", "/root/test0", "/root/test0/l1/l2/l3"]:
for hierarchy in [False, True]:
omni.kit.commands.execute(
"UnlinkSpecs", spec_paths=path, layer_identifiers=layer1.identifier, hierarchy=hierarchy
)
if path.startswith("/root/test0"):
base_path = path
else:
base_path = "/root/test0"
# Make sure it's unlinked successfully
links = specs_linking.get_all_spec_links()
for spec_path, layers in links.items():
if hierarchy:
if spec_path.startswith(base_path):
self.assertEqual(set(layers), set([layer0.identifier]))
else:
self.assertEqual(set(layers), set([layer0.identifier, layer1.identifier]))
else:
sdf_path = Sdf.Path(spec_path)
if str(sdf_path.GetPrimPath()) == path and spec_path.startswith(base_path):
self.assertEqual(set(layers), set([layer0.identifier]))
else:
self.assertEqual(set(layers), set([layer0.identifier, layer1.identifier]))
omni.kit.undo.undo()
# Make sure it's returned to old states.
new_links = specs_linking.get_all_spec_links()
self.__compare_links_map(old_links, new_links)
async def test_lock_specs_command(self):
layers = get_layers()
specs_locking = layers.get_specs_locking()
context = omni.usd.get_context()
stage = context.get_stage()
root_layer = stage.GetRootLayer()
layer0 = Sdf.Layer.CreateAnonymous()
layer1 = Sdf.Layer.CreateAnonymous()
layer2 = Sdf.Layer.CreateAnonymous()
root_layer.subLayerPaths.append(layer0.identifier)
root_layer.subLayerPaths.append(layer1.identifier)
root_layer.subLayerPaths.append(layer2.identifier)
asset_name = f"/root/test0/l1/l2/l3"
asset_prim = stage.DefinePrim(asset_name, "Xform")
await omni.kit.app.get_app().next_update_async()
specs_locking.lock_spec("/root", hierarchy=False)
old_locks = specs_locking.get_all_locked_specs()
for path in ["/", "/root", "/root/test0", "/root/test0/l1/l2/l3"]:
for hierarchy in [False, True]:
omni.kit.commands.execute("LockSpecs", spec_paths=path, hierarchy=hierarchy)
omni.kit.undo.undo()
# Make sure it's returned to old states.
new_locks = specs_locking.get_all_locked_specs()
self.assertEqual(set(old_locks), set(new_locks))
async def test_unlock_specs_command(self):
layers = get_layers()
specs_locking = layers.get_specs_locking()
context = omni.usd.get_context()
stage = context.get_stage()
root_layer = stage.GetRootLayer()
layer0 = Sdf.Layer.CreateAnonymous()
layer1 = Sdf.Layer.CreateAnonymous()
layer2 = Sdf.Layer.CreateAnonymous()
root_layer.subLayerPaths.append(layer0.identifier)
root_layer.subLayerPaths.append(layer1.identifier)
root_layer.subLayerPaths.append(layer2.identifier)
asset_name = f"/root/test0/l1/l2/l3"
asset_prim = stage.DefinePrim(asset_name, "Xform")
await omni.kit.app.get_app().next_update_async()
specs_locking.lock_spec("/root", hierarchy=True)
old_locks = omni.kit.usd.layers.get_all_locked_specs(context)
for path in ["/", "/root", "/root/test0", "/root/test0/l1/l2/l3"]:
for hierarchy in [False, True]:
omni.kit.commands.execute("UnlockSpecs", spec_paths=path, hierarchy=hierarchy)
# Make sure it's locked successfully
locks = specs_locking.get_all_locked_specs()
for spec_path in locks:
if hierarchy:
self.assertFalse(spec_path.startswith(path))
else:
sdf_path = Sdf.Path(spec_path)
self.assertNotEqual(str(sdf_path.GetPrimPath()), path)
omni.kit.undo.undo()
new_locks = specs_locking.get_all_locked_specs()
self.assertEqual(set(old_locks), set(new_locks))
| 51,036 | Python | 44.937894 | 307 | 0.603809 |
omniverse-code/kit/exts/omni.kit.usd.layers/omni/kit/usd/layers/tests/test_layers_state.py | import asyncio
import carb
import os
import tempfile
import omni.kit.test
import omni.usd
import omni.client
import unittest
from stat import S_IREAD, S_IWRITE
from pxr import Sdf, Usd, UsdGeom, Gf
from .test_base import enable_server_tests
from omni.kit.usd.layers import get_layers, LayerUtils, get_layer_event_payload, LayerEventType
class TestLayersState(omni.kit.test.AsyncTestCase):
# Before running each test
async def setUp(self):
self.usd_context = omni.usd.get_context()
await omni.usd.get_context().new_stage_async()
async def tearDown(self):
if omni.usd.get_context().get_stage():
await omni.usd.get_context().close_stage_async()
async def test_layers_state_muteness_interfaces(self):
layers = get_layers()
layers_state = layers.get_layers_state()
stage = omni.usd.get_context().get_stage()
layer0 = Sdf.Layer.CreateAnonymous()
layer1 = Sdf.Layer.CreateAnonymous()
layer2 = Sdf.Layer.CreateAnonymous()
stage.GetRootLayer().subLayerPaths.append(layer0.identifier)
stage.GetRootLayer().subLayerPaths.append(layer1.identifier)
stage.GetRootLayer().subLayerPaths.append(layer2.identifier)
self.assertFalse(layers_state.is_muteness_global())
stage.MuteLayer(layer0.identifier)
await omni.kit.app.get_app().next_update_async()
self.assertTrue(layers_state.is_layer_locally_muted(layer0.identifier))
self.assertFalse(layers_state.is_layer_globally_muted(layer0.identifier))
self.assertFalse(layers_state.is_layer_locally_muted(layer1.identifier))
self.assertFalse(layers_state.is_layer_locally_muted(layer2.identifier))
stage.UnmuteLayer(layer0.identifier)
await omni.kit.app.get_app().next_update_async()
self.assertFalse(layers_state.is_layer_locally_muted(layer0.identifier))
# Mute layers before muteness scope switches.
stage.MuteLayer(layer0.identifier)
await omni.kit.app.get_app().next_update_async()
self.assertTrue(layers_state.is_layer_locally_muted(layer0.identifier))
layers_state.set_muteness_scope(True)
self.assertTrue(layers_state.is_muteness_global())
self.assertTrue(layers_state.is_layer_locally_muted(layer0.identifier))
self.assertFalse(layers_state.is_layer_globally_muted(layer0.identifier))
# Layer is not muted since it's muted in local mode.
self.assertFalse(stage.IsLayerMuted(layer0.identifier))
stage.MuteLayer(layer0.identifier)
await omni.kit.app.get_app().next_update_async()
# Local muteness flag is still true.
self.assertTrue(layers_state.is_layer_locally_muted(layer0.identifier))
self.assertTrue(layers_state.is_layer_globally_muted(layer0.identifier))
self.assertTrue(stage.IsLayerMuted(layer0.identifier))
stage.UnmuteLayer(layer0.identifier)
await omni.kit.app.get_app().next_update_async()
self.assertFalse(layers_state.is_layer_globally_muted(layer0.identifier))
self.assertFalse(stage.IsLayerMuted(layer0.identifier))
# Swiches back to local scope again.
layers_state.set_muteness_scope(False)
self.assertTrue(layers_state.is_layer_locally_muted(layer0.identifier))
self.assertFalse(layers_state.is_layer_globally_muted(layer0.identifier))
self.assertTrue(stage.IsLayerMuted(layer0.identifier))
# Pass None for identifier will not cause any issues
self.assertFalse(layers_state.is_layer_locally_muted(None))
async def test_live_update_muteness(self):
# The test is not to do real live update, but tries to simulate live update
# by changing the custom data of muteness directly.
layers = get_layers()
layers_state = layers.get_layers_state()
layers_state.set_muteness_scope(False)
stage = omni.usd.get_context().get_stage()
layer0 = Sdf.Layer.CreateAnonymous()
stage.GetRootLayer().subLayerPaths.append(layer0.identifier)
LayerUtils.set_layer_global_muteness(stage.GetRootLayer(), layer0.identifier, True)
await omni.kit.app.get_app().next_update_async()
self.assertTrue(layers_state.is_layer_globally_muted(layer0.identifier))
self.assertFalse(stage.IsLayerMuted(layer0.identifier))
layers_state.set_muteness_scope(True)
await omni.kit.app.get_app().next_update_async()
self.assertTrue(layers_state.is_layer_globally_muted(layer0.identifier))
self.assertTrue(stage.IsLayerMuted(layer0.identifier))
async def test_permissions_query_interface(self):
layers = get_layers()
layers_state = layers.get_layers_state()
with tempfile.TemporaryDirectory() as tempdir:
file = os.path.join(tempdir, "test.usd")
layer = Sdf.Layer.CreateNew(file)
layer.Save()
layer = None
os.chmod(file, S_IREAD)
await omni.usd.get_context().open_stage_async(file)
is_writable = layers_state.is_layer_writable(file)
is_read_only_on_disk = layers_state.is_layer_readonly_on_disk(file)
is_savable = layers_state.is_layer_savable(file)
await omni.usd.get_context().new_stage_async()
os.chmod(file, S_IWRITE)
self.assertFalse(is_writable)
self.assertTrue(is_read_only_on_disk)
self.assertFalse(is_savable)
self.assertFalse(layers_state.is_layer_locked(file))
stage = omni.usd.get_context().get_stage()
root_layer = stage.GetRootLayer()
LayerUtils.set_layer_lock_status(root_layer, root_layer.identifier, True)
# Root layer cannot be locked
self.assertTrue(layers_state.is_layer_writable(root_layer.identifier))
# Anonymous layer cannot be saved.
self.assertFalse(layers_state.is_layer_savable(root_layer.identifier))
self.assertFalse(layers_state.is_layer_locked(file))
with tempfile.TemporaryDirectory() as tempdir:
file = os.path.join(tempdir, "test.usd")
layer = Sdf.Layer.CreateNew(file)
root_layer.subLayerPaths.append(file)
LayerUtils.set_layer_lock_status(root_layer, file, True)
# Locked layer cannot be writable or savable.
self.assertFalse(layers_state.is_layer_writable(file))
# Even it's locked, it's still not readonly on disk.
self.assertFalse(layers_state.is_layer_readonly_on_disk(file))
self.assertFalse(layers_state.is_layer_savable(file))
self.assertTrue(layers_state.is_layer_locked(file))
# Close stage to release temp file
layer = None
stage = None
root_layer = None
await omni.usd.get_context().close_stage_async()
async def test_set_get_layer_names(self):
layers = get_layers()
layers_state = layers.get_layers_state()
stage = omni.usd.get_context().get_stage()
root_layer = stage.GetRootLayer()
session_layer = stage.GetSessionLayer()
self.assertEqual(layers_state.get_layer_name(root_layer.identifier), "Root Layer")
self.assertEqual(layers_state.get_layer_name(session_layer.identifier), "Session Layer")
sublayer = Sdf.Layer.CreateAnonymous()
root_layer.subLayerPaths.append(sublayer.identifier)
layers_state.set_layer_name(sublayer.identifier, "test")
self.assertEqual(layers_state.get_layer_name(sublayer.identifier), "test")
self.assertEqual("abc.usd", layers_state.get_layer_name("c:/a/b/abc.usd"))
self.assertEqual("abc.usda", layers_state.get_layer_name("c:/a/b/abc.usda"))
self.assertEqual("abc.usda", layers_state.get_layer_name("omniverse://ov-invalid-fake-server/a/b/abc.usda"))
layer = Sdf.Layer.CreateAnonymous()
self.assertEqual(layer.identifier, layers_state.get_layer_name(layer.identifier))
self.assertEqual("", layers_state.get_layer_name(""))
self.assertEqual(
"a b c.usda", layers_state.get_layer_name("omniverse://ov-invalid-fake-server/a/b/a%20b%20c.usda")
)
@unittest.skipIf(not enable_server_tests(), "")
async def test_layer_refresh(self):
layers = get_layers()
layers_state = layers.get_layers_state()
stage = omni.usd.get_context().get_stage()
file = "omniverse://localhost/Projects/tests/omni.kit.usd.layers/test_layer_refresh/test.usd"
layer = Sdf.Layer.FindOrOpen(file)
if not layer:
layer = Sdf.Layer.CreateNew(file)
layer.Save()
stage.GetRootLayer().subLayerPaths.append(layer.identifier)
self.assertFalse(layers_state.is_layer_outdated(layer.identifier))
custom_data = layer.customLayerData
custom_data['test'] = 1
layer.customLayerData = custom_data
layer.Save()
for i in range(100):
await omni.kit.app.get_app().next_update_async()
self.assertFalse(layers_state.is_layer_outdated(layer.identifier))
layer.Reload()
self.assertFalse(layers_state.is_layer_outdated(layer.identifier))
custom_data = layer.customLayerData
custom_data['test'] = 1
layer.customLayerData = custom_data
# Saves with customized interface will update latest state
layer.Save()
for i in range(100):
await omni.kit.app.get_app().next_update_async()
self.assertFalse(layers_state.is_layer_outdated(layer.identifier))
async def test_layer_edit_target_changed(self):
# Test layer edit target change if it's muted/locked/removed.
layers = get_layers()
layers_state = layers.get_layers_state()
stage = omni.usd.get_context().get_stage()
sublayer0 = Sdf.Layer.CreateAnonymous()
root_layer = stage.GetRootLayer()
LayerUtils.insert_sublayer(root_layer, 0, sublayer0.identifier, False)
# Mute/lock/remove current edit target will change its edit target to root layer.
LayerUtils.set_edit_target(stage, sublayer0.identifier)
self.assertEqual(sublayer0.identifier, LayerUtils.get_edit_target(stage))
stage.MuteLayer(sublayer0.identifier)
await omni.kit.app.get_app().next_update_async()
self.assertEqual(root_layer.identifier, LayerUtils.get_edit_target(stage))
stage.UnmuteLayer(sublayer0.identifier)
LayerUtils.set_edit_target(stage, sublayer0.identifier)
self.assertEqual(sublayer0.identifier, LayerUtils.get_edit_target(stage))
layers_state.set_layer_lock_state(sublayer0.identifier, True)
self.assertEqual(root_layer.identifier, LayerUtils.get_edit_target(stage))
layers_state.set_layer_lock_state(sublayer0.identifier, False)
LayerUtils.set_edit_target(stage, sublayer0.identifier)
self.assertEqual(sublayer0.identifier, LayerUtils.get_edit_target(stage))
LayerUtils.remove_sublayer(root_layer, 0)
self.assertEqual(root_layer.identifier, LayerUtils.get_edit_target(stage))
async def test_layer_muteness_events(self):
layers = get_layers()
layers_state = layers.get_layers_state()
event_stream = layers.get_event_stream()
payload = None
def _on_layer_event(event: carb.events.IEvent):
nonlocal payload
payload = get_layer_event_payload(event)
subscription = event_stream.create_subscription_to_pop(_on_layer_event, name="layer events")
layers_state = layers.get_layers_state()
layers_state.set_muteness_scope(True)
self.assertIsNotNone(payload)
self.assertEqual(payload.event_type, LayerEventType.MUTENESS_SCOPE_CHANGED)
stage = omni.usd.get_context().get_stage()
sublayer0 = Sdf.Layer.CreateAnonymous()
sublayer1 = Sdf.Layer.CreateAnonymous()
root_layer = stage.GetRootLayer()
LayerUtils.insert_sublayer(root_layer, 0, sublayer0.identifier, False)
LayerUtils.insert_sublayer(root_layer, 1, sublayer1.identifier, False)
await omni.kit.app.get_app().next_update_async()
stage.MuteAndUnmuteLayers([sublayer0.identifier, sublayer1.identifier], [])
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
self.assertIsNotNone(payload)
self.assertEqual(payload.event_type, LayerEventType.MUTENESS_STATE_CHANGED)
self.assertEqual(set(payload.identifiers_or_spec_paths), set([sublayer0.identifier, sublayer1.identifier]))
stage.UnmuteLayer(sublayer1.identifier)
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
self.assertIsNotNone(payload)
self.assertEqual(payload.event_type, LayerEventType.MUTENESS_STATE_CHANGED)
self.assertEqual(set(payload.identifiers_or_spec_paths), set([sublayer1.identifier]))
layers_state.set_muteness_scope(False)
# Switch scope will load local muteness.
self.assertIsNotNone(payload)
self.assertEqual(payload.event_type, LayerEventType.MUTENESS_STATE_CHANGED)
# Since only sublayer0's state is changed.
self.assertEqual(set(payload.identifiers_or_spec_paths), set([sublayer0.identifier]))
async def test_layer_lock_events(self):
layers = get_layers()
layers_state = layers.get_layers_state()
event_stream = layers.get_event_stream()
payload = None
def _on_layer_event(event: carb.events.IEvent):
nonlocal payload
payload = get_layer_event_payload(event)
stage = omni.usd.get_context().get_stage()
sublayer0 = Sdf.Layer.CreateAnonymous()
sublayer1 = Sdf.Layer.CreateAnonymous()
root_layer = stage.GetRootLayer()
LayerUtils.insert_sublayer(root_layer, 0, sublayer0.identifier, False)
LayerUtils.insert_sublayer(root_layer, 1, sublayer1.identifier, False)
subscription = event_stream.create_subscription_to_pop(_on_layer_event, name="layer events")
# Lock
layers_state.set_layer_lock_state(sublayer0.identifier, True)
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
self.assertIsNotNone(payload)
self.assertEqual(payload.event_type, LayerEventType.LOCK_STATE_CHANGED)
self.assertEqual(set(payload.identifiers_or_spec_paths), set([sublayer0.identifier]))
# Unlock
payload = None
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
layers_state.set_layer_lock_state(sublayer0.identifier, False)
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
self.assertIsNotNone(payload)
self.assertEqual(payload.event_type, LayerEventType.LOCK_STATE_CHANGED)
self.assertEqual(set(payload.identifiers_or_spec_paths), set([sublayer0.identifier]))
payload = None
with Sdf.ChangeBlock():
LayerUtils.set_layer_lock_status(root_layer, sublayer0.identifier, True)
LayerUtils.set_layer_lock_status(root_layer, sublayer1.identifier, True)
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
self.assertIsNotNone(payload)
self.assertEqual(payload.event_type, LayerEventType.LOCK_STATE_CHANGED)
self.assertEqual(set(payload.identifiers_or_spec_paths), set([sublayer0.identifier, sublayer1.identifier]))
async def test_layer_dirty_state_events(self):
layers = get_layers()
event_stream = layers.get_event_stream()
payload = None
def _on_layer_event(event: carb.events.IEvent):
nonlocal payload
temp = get_layer_event_payload(event)
if temp.event_type == LayerEventType.DIRTY_STATE_CHANGED:
payload = temp
with tempfile.TemporaryDirectory() as tempdir:
file = os.path.join(tempdir, "test.usd")
file1 = os.path.join(tempdir, "test1.usd")
layer = Sdf.Layer.CreateNew(file)
layer.Save()
layer1 = Sdf.Layer.CreateNew(file1)
layer1.Save()
stage = omni.usd.get_context().get_stage()
root_layer = stage.GetRootLayer()
LayerUtils.insert_sublayer(root_layer, 0, layer.identifier, False)
LayerUtils.insert_sublayer(root_layer, 1, layer1.identifier, False)
subscription = event_stream.create_subscription_to_pop(_on_layer_event, name="layer events")
# Change anonymous layer will not emit dirty event
with Usd.EditContext(stage, stage.GetRootLayer()):
stage.DefinePrim("/root/prim")
await omni.kit.app.get_app().next_update_async()
self.assertIsNone(payload)
with Usd.EditContext(stage, layer):
stage.DefinePrim("/root/prim2")
await omni.kit.app.get_app().next_update_async()
self.assertIsNotNone(payload)
self.assertEqual(payload.event_type, LayerEventType.DIRTY_STATE_CHANGED)
self.assertEqual(set(payload.identifiers_or_spec_paths), set([layer.identifier]))
self.assertTrue(layer.dirty)
# Change a dirty layer will not emit dirty event again
payload = None
stage.DefinePrim("/root/prim3")
self.assertIsNone(payload)
with Usd.EditContext(stage, layer1):
stage.DefinePrim("/root/prim4")
await omni.kit.app.get_app().next_update_async()
# Save dirty layers will emit dirty change event
payload = None
stage.Save()
await omni.kit.app.get_app().next_update_async()
self.assertIsNotNone(payload)
self.assertEqual(payload.event_type, LayerEventType.DIRTY_STATE_CHANGED)
self.assertEqual(set(payload.identifiers_or_spec_paths), set([layer.identifier, layer1.identifier]))
self.assertFalse(layer.dirty)
self.assertFalse(layer1.dirty)
layer = None
layer1 = None
root_layer = None
await omni.usd.get_context().new_stage_async()
async def test_layer_outdate_state_events(self):
pass
async def test_layer_prim_specs_events(self):
layers = get_layers()
event_stream = layers.get_event_stream()
payload = None
def _on_layer_event(event: carb.events.IEvent):
nonlocal payload
temp = get_layer_event_payload(event)
if temp.event_type == LayerEventType.PRIM_SPECS_CHANGED:
payload = temp
subscription = event_stream.create_subscription_to_pop(_on_layer_event, name="layer events")
stage = omni.usd.get_context().get_stage()
all_prims = []
for i in range(100):
prim = stage.DefinePrim(f"/test_{i}")
all_prims.append(str(prim.GetPath()))
await omni.kit.app.get_app().next_update_async()
self.assertIsNotNone(payload)
self.assertEqual(payload.event_type, LayerEventType.PRIM_SPECS_CHANGED)
root_layer_identifier = stage.GetRootLayer().identifier
self.assertIn(root_layer_identifier, payload.layer_spec_paths)
self.assertEqual(set(payload.layer_spec_paths[root_layer_identifier]), set(all_prims))
stage.GetRootLayer().Clear()
await omni.kit.app.get_app().next_update_async()
self.assertIsNotNone(payload)
self.assertEqual(payload.event_type, LayerEventType.PRIM_SPECS_CHANGED)
root_layer_identifier = stage.GetRootLayer().identifier
self.assertIn(root_layer_identifier, payload.layer_spec_paths)
self.assertEqual(set(payload.layer_spec_paths[root_layer_identifier]), set([str(Sdf.Path.absoluteRootPath)]))
async def test_sublayers_changed_events(self):
layers = get_layers()
event_stream = layers.get_event_stream()
payload = None
def _on_layer_event(event: carb.events.IEvent):
nonlocal payload
temp = get_layer_event_payload(event)
if temp.event_type == LayerEventType.SUBLAYERS_CHANGED:
payload = temp
subscription = event_stream.create_subscription_to_pop(_on_layer_event, name="layer events")
stage = omni.usd.get_context().get_stage()
root_layer = stage.GetRootLayer()
sublayer0 = Sdf.Layer.CreateAnonymous()
sublayer1 = Sdf.Layer.CreateAnonymous()
root_layer.subLayerPaths.append(sublayer0.identifier)
await omni.kit.app.get_app().next_update_async()
self.assertIsNotNone(payload)
self.assertEqual(payload.event_type, LayerEventType.SUBLAYERS_CHANGED)
payload = None
LayerUtils.remove_sublayer(root_layer, 0)
await omni.kit.app.get_app().next_update_async()
self.assertIsNotNone(payload)
self.assertEqual(payload.event_type, LayerEventType.SUBLAYERS_CHANGED)
root_layer.subLayerPaths.append(sublayer0.identifier)
root_layer.subLayerPaths.append(sublayer1.identifier)
# Layer move
payload = None
LayerUtils.move_layer(root_layer.identifier, 0, sublayer1.identifier, 0, True)
await omni.kit.app.get_app().next_update_async()
self.assertIsNotNone(payload)
self.assertEqual(payload.event_type, LayerEventType.SUBLAYERS_CHANGED)
# Not all edits will emit sublayer changes events.
payload = None
stage.DefinePrim("/root/test")
self.assertIsNone(payload)
async def test_layer_info_changed_events(self):
layers = get_layers()
event_stream = layers.get_event_stream()
payload = None
def _on_layer_event(event: carb.events.IEvent):
nonlocal payload
temp = get_layer_event_payload(event)
if temp.event_type == LayerEventType.INFO_CHANGED:
payload = temp
subscription = event_stream.create_subscription_to_pop(_on_layer_event, name="layer events")
stage = omni.usd.get_context().get_stage()
root_layer = stage.GetRootLayer()
sublayer0 = Sdf.Layer.CreateAnonymous()
root_layer.subLayerPaths.append(sublayer0.identifier)
root_layer.subLayerOffsets[0] = Sdf.LayerOffset(2.0, 3.0)
up_axis = UsdGeom.GetStageUpAxis(stage)
with Sdf.ChangeBlock():
if up_axis == UsdGeom.Tokens.z:
UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.y)
else:
UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.z)
root_layer.comment = "test"
root_layer.documentation = "test2"
UsdGeom.SetStageMetersPerUnit(stage, 100.0)
stage.SetStartTimeCode(100.99)
stage.SetEndTimeCode(1000.99)
root_layer.framesPerSecond = 100
stage.SetTimeCodesPerSecond(1000)
await omni.kit.app.get_app().next_update_async()
self.assertIsNotNone(payload)
self.assertEqual(payload.event_type, LayerEventType.INFO_CHANGED)
self.assertIn(root_layer.identifier, payload.layer_info_data)
expected_changes = (
"documentation",
"upAxis",
"comment",
"metersPerUnit",
"startTimeCode",
"framesPerSecond",
"endTimeCode",
"timeCodesPerSecond",
)
self.assertEqual(set(payload.layer_info_data[root_layer.identifier]), set(expected_changes))
async def test_edit_target_changed(self):
layers = get_layers()
event_stream = layers.get_event_stream()
payload = None
def _on_layer_event(event: carb.events.IEvent):
nonlocal payload
temp = get_layer_event_payload(event)
if temp.event_type == LayerEventType.EDIT_TARGET_CHANGED:
payload = temp
subscription = event_stream.create_subscription_to_pop(_on_layer_event, name="layer events")
stage = omni.usd.get_context().get_stage()
root_layer = stage.GetRootLayer()
sublayer0 = Sdf.Layer.CreateAnonymous()
root_layer.subLayerPaths.append(sublayer0.identifier)
edit_target = Usd.EditTarget(sublayer0)
stage.SetEditTarget(edit_target)
await omni.kit.app.get_app().next_update_async()
self.assertIsNotNone(payload)
self.assertEqual(payload.event_type, LayerEventType.EDIT_TARGET_CHANGED)
# Set the same edit target will not trigger any events
payload = None
stage.SetEditTarget(edit_target)
await omni.kit.app.get_app().next_update_async()
self.assertIsNone(payload)
def check_sublayers(self, sublayer_paths, expected_layer_identifiers):
sublayer_paths = sorted(sublayer_paths)
expected_layer_identifiers = sorted(expected_layer_identifiers)
self.assertTrue(
sublayer_paths == expected_layer_identifiers,
f"Sublayers array does not match, got: {sublayer_paths}, expected: {expected_layer_identifiers}",
)
async def test_get_used_sublayers(self):
layers = get_layers()
stage = self.usd_context.get_stage()
root_layer = stage.GetRootLayer()
sublayers = layers.get_layers_state().get_local_layer_identifiers()
self.check_sublayers(sublayers, [root_layer.identifier])
layer0 = Sdf.Layer.CreateAnonymous()
LayerUtils.insert_sublayer(root_layer, 0, layer0.identifier)
sublayers = layers.get_layers_state().get_local_layer_identifiers()
self.check_sublayers(sublayers, [root_layer.identifier, layer0.identifier])
layer1 = Sdf.Layer.CreateAnonymous()
LayerUtils.insert_sublayer(root_layer, 1, layer1.identifier)
sublayers = layers.get_layers_state().get_local_layer_identifiers()
self.check_sublayers(sublayers, [root_layer.identifier, layer0.identifier, layer1.identifier])
layer2 = Sdf.Layer.CreateAnonymous()
layer3 = Sdf.Layer.CreateAnonymous()
layer4 = Sdf.Layer.CreateAnonymous()
layer5 = Sdf.Layer.CreateAnonymous()
LayerUtils.insert_sublayer(layer2, 0, layer3.identifier)
LayerUtils.insert_sublayer(layer2, 1, layer4.identifier)
LayerUtils.insert_sublayer(layer4, 0, layer5.identifier)
LayerUtils.insert_sublayer(root_layer, 2, layer2.identifier)
sublayers = layers.get_layers_state().get_local_layer_identifiers()
self.check_sublayers(
sublayers,
[
root_layer.identifier,
layer0.identifier,
layer1.identifier,
layer2.identifier,
layer3.identifier,
layer4.identifier,
layer5.identifier,
],
)
# Removes layer0
LayerUtils.remove_sublayer(root_layer, 0)
sublayers = layers.get_layers_state().get_local_layer_identifiers()
self.check_sublayers(
sublayers,
[
root_layer.identifier,
layer1.identifier,
layer2.identifier,
layer3.identifier,
layer4.identifier,
layer5.identifier,
],
)
# Removes layer2 will remove layer2, layer3, layer4, layer5
LayerUtils.remove_sublayer(root_layer, 1)
sublayers = layers.get_layers_state().get_local_layer_identifiers()
self.check_sublayers(sublayers, [root_layer.identifier, layer1.identifier])
async def test_get_dirty_sublayers(self):
layers = get_layers()
stage = self.usd_context.get_stage()
root_layer = stage.GetRootLayer()
with tempfile.TemporaryDirectory() as tempdir:
format = Sdf.FileFormat.FindByExtension(".usd")
layer0 = Sdf.Layer.New(format, f"{tempdir}/1.usd")
layer1 = Sdf.Layer.New(format, f"{tempdir}/2.usd")
layer2 = Sdf.Layer.New(format, f"{tempdir}/3.usd")
layer3 = Sdf.Layer.New(format, f"{tempdir}/4.usd")
layer4 = Sdf.Layer.New(format, f"{tempdir}/5.usd")
layer5 = Sdf.Layer.New(format, f"{tempdir}/6.usd")
LayerUtils.insert_sublayer(root_layer, 0, layer0.identifier, False)
LayerUtils.insert_sublayer(root_layer, 0, layer1.identifier, False)
LayerUtils.insert_sublayer(layer2, 0, layer3.identifier, False)
LayerUtils.insert_sublayer(layer2, 0, layer4.identifier, False)
LayerUtils.insert_sublayer(layer4, 0, layer5.identifier, False)
LayerUtils.insert_sublayer(root_layer, 0, layer2.identifier, False)
sublayers = layers.get_layers_state().get_local_layer_identifiers()
self.check_sublayers(
sublayers,
[
root_layer.identifier,
layer0.identifier,
layer1.identifier,
layer2.identifier,
layer3.identifier,
layer4.identifier,
layer5.identifier,
],
)
# Checkes dirtiness of layers since layer2 and layer4 have been touched.
# They should be dirty at this moment
dirty_sublayers = layers.get_layers_state().get_dirty_layer_identifiers()
self.check_sublayers(dirty_sublayers, [layer2.identifier, layer4.identifier])
# Touches layer1
LayerUtils.set_edit_target(stage, layer1.identifier)
UsdGeom.Mesh.Define(stage, "/root/test")
dirty_sublayers = layers.get_layers_state().get_dirty_layer_identifiers()
self.check_sublayers(dirty_sublayers, [layer1.identifier, layer2.identifier, layer4.identifier])
| 30,154 | Python | 43.021898 | 117 | 0.649897 |
omniverse-code/kit/exts/omni.kit.usd.layers/omni/kit/usd/layers/tests/test_base.py | import carb.settings
def enable_server_tests():
settings = carb.settings.get_settings()
return settings.get_as_bool("/exts/omni.kit.usd.layers/enable_server_tests")
| 176 | Python | 21.124997 | 80 | 0.732955 |
omniverse-code/kit/exts/omni.kit.usd.layers/omni/kit/usd/layers/impl/layer_commands.py | import omni
import carb
import omni.kit.commands
from pxr import Usd, Sdf, UsdGeom
from .layer_utils import LayerUtils
from typing import Union, List
from .extension import get_layers
from .specs_linking_and_locking_utils import *
def _get_usd_context(context_name_or_instance: Union[str, omni.usd.UsdContext] = ""):
if not context_name_or_instance:
context_name_or_instance = ""
if isinstance(context_name_or_instance, str):
usd_context = omni.usd.get_context(context_name_or_instance)
elif isinstance(context_name_or_instance, omni.usd.UsdContext):
usd_context = context_name_or_instance
else:
usd_context = None
return usd_context
class AbstractLayerCommand(omni.kit.commands.Command):
"""
Abstract base class for layer commands.
It's mainly responsible to create a commmon class
to recover layer selection in layer window, and
edit target for USD Stage in undo.
"""
def __init__(self, context_name_or_instance: Union[str, omni.usd.UsdContext] = ""):
self._usd_context = _get_usd_context(context_name_or_instance)
self._selection = self._usd_context.get_selection()
def get_layers(self):
return get_layers(self._usd_context_name)
def get_specs_linking(self):
layers = self.get_layers()
if not layers:
return None
return layers.get_specs_linking()
def get_specs_locking(self):
layers = self.get_layers()
if not layers:
return None
return layers.get_specs_locking()
def _restore_spec_links_from_dict(self, spec_path_to_layers):
specs_linking = self.get_specs_linking()
for spec_path, _ in spec_path_to_layers.items():
specs_linking.unlink_spec_from_all_layers(spec_path, False)
for spec_path, layer_identifiers in spec_path_to_layers.items():
for layer_identifier in layer_identifiers:
specs_linking.link_spec(spec_path, layer_identifier, False)
def get_layers(self):
return get_layers(self._usd_context)
def get_specs_linking(self):
layers = self.get_layers()
if not layers:
return None
return layers.get_specs_linking()
def get_specs_locking(self):
layers = self.get_layers()
if not layers:
return None
return layers.get_specs_locking()
def _restore_spec_links_from_dict(self, spec_path_to_layers):
specs_linking = self.get_specs_linking()
for spec_path, _ in spec_path_to_layers.items():
specs_linking.unlink_spec_from_all_layers(spec_path, False)
for spec_path, layer_identifiers in spec_path_to_layers.items():
for layer_identifier in layer_identifiers:
specs_linking.link_spec(spec_path, layer_identifier, False)
def do(self):
stage = self._usd_context.get_stage()
if stage.GetEditTarget().GetLayer():
self._edit_target_identifier = stage.GetEditTarget().GetLayer().identifier
else:
self._edit_target_identifier = stage.GetRootLayer().identifier
self._prev_selected_paths = list(self._selection.get_selected_prim_paths())
self.do_impl()
def do_impl(self):
raise NotImplementedError("Method must be implemented")
def undo_impl(self):
raise NotImplementedError("Method must be implemented")
def undo(self):
self.undo_impl()
# restore selected prims and layer
self._selection.set_selected_prim_paths(self._prev_selected_paths, False)
stage = self._usd_context.get_stage()
layer = Sdf.Find(self._edit_target_identifier)
if layer and not stage.IsLayerMuted(layer.identifier):
edit_target_layer = layer
else:
edit_target_layer = stage.GetRootLayer()
if stage.HasLocalLayer(edit_target_layer):
edit_target = Usd.EditTarget(edit_target_layer)
stage.SetEditTarget(edit_target)
class SetEditTargetCommand(AbstractLayerCommand):
"""Select Layer as Edit Target undoable **Command**."""
def __init__(self, layer_identifier: str, usd_context: Union[str, omni.usd.UsdContext] = ""):
"""Constructor.
Keyword Arguments:
layer_identifier (str): Layer identifier.
usd_context (Union[str, omni.usd.UsdContext]): Usd context name or instance. It uses default context if it's empty.
"""
super().__init__(usd_context)
self._current_edit_target_identifier = layer_identifier
def do_impl(self):
layer = Sdf.Find(self._current_edit_target_identifier)
if not layer:
carb.log_warn(f"Set authoring command failed. Cannot find layer {self._current_edit_target_identifier}")
else:
edit_target = Usd.EditTarget(layer)
stage = self._usd_context.get_stage()
if not stage.IsLayerMuted(layer.identifier) and stage.HasLocalLayer(layer):
stage.SetEditTarget(edit_target)
def undo_impl(self):
pass
class CreateSublayerCommand(AbstractLayerCommand):
"""Create Sublayer undoable **Command**."""
def __init__(
self,
layer_identifier: str,
sublayer_position: int,
new_layer_path: str,
transfer_root_content: bool,
create_or_insert: bool,
layer_name: str = "",
usd_context: Union[str, omni.usd.UsdContext] = "",
):
"""Constructor.
Keyword arguments::
layer_identifier (str): The identifier of layer to create sublayer. It should be found by Sdf.Find.
sublayer_position (int): Sublayer position that the new sublayer is created before.
If position_before == -1, it will create layer at the end of sublayer list.
If position_before >= total_number_of_sublayers, it will create layer at the end of sublayer list.
new_layer_path (str): Absolute path of new layer. If it's empty, it will create anonymous layer if create_or_insert == True.
If create_or_insert == False and it's empty, it will fail to insert layer.
transfer_root_content (bool): True if we should move the root contents to the new layer.
create_or_insert (bool): If it's true, it will create layer from this path. It's insert, otherwise.
layer_name (str, optional): If it's to create anonymous layer (new_layer_path is empty), this name is used.
usd_context (Union[str, omni.usd.UsdContext]): Usd context name or instance. It uses default context if it's empty.
"""
super().__init__(usd_context)
self._layer_identifier = layer_identifier
self._sublayer_position = sublayer_position
self._new_layer_path = new_layer_path
self._create_or_insert = create_or_insert
if create_or_insert:
self._transfer_root_content = transfer_root_content
else:
self._transfer_root_content = False
self._new_layer_identifier = None
self._layer_name = layer_name
self._temp_layer = None
def do_impl(self):
stage = self._usd_context.get_stage()
root = stage.GetRootLayer()
parent_layer = Sdf.Find(self._layer_identifier)
if self._create_or_insert:
if self._transfer_root_content:
self._temp_layer = Sdf.Layer.CreateAnonymous()
self._temp_layer.TransferContent(root)
if parent_layer:
new_layer = LayerUtils.create_sublayer(parent_layer, self._sublayer_position, self._new_layer_path)
if new_layer:
# Copy stage axis
up_axis = UsdGeom.GetStageUpAxis(stage)
stage_hanlde = Usd.Stage.Open(new_layer)
UsdGeom.SetStageUpAxis(stage_hanlde, up_axis)
LayerUtils.set_custom_layer_name(new_layer, self._layer_name)
if self._transfer_root_content:
LayerUtils.transfer_layer_content(root, new_layer)
root.rootPrims.clear()
self._new_layer_identifier = new_layer.identifier
else:
self._new_layer_identifier = None
else:
layer = LayerUtils.insert_sublayer(parent_layer, self._sublayer_position, self._new_layer_path)
if layer:
self._new_layer_identifier = layer.identifier
def undo_impl(self):
if self._new_layer_identifier:
stage = self._usd_context.get_stage()
with Sdf.ChangeBlock():
if self._transfer_root_content and self._temp_layer:
root = stage.GetRootLayer()
root.TransferContent(self._temp_layer)
layer_position_in_parent = LayerUtils.get_sublayer_position_in_parent(
self._layer_identifier, self._new_layer_identifier
)
if layer_position_in_parent != -1:
layer = Sdf.Find(self._layer_identifier)
if not layer:
return
layer_identifier = LayerUtils.remove_sublayer(layer, layer_position_in_parent)
LayerUtils.remove_layer_global_muteness(layer, layer_identifier)
class RemoveSublayerCommand(AbstractLayerCommand):
"""Remove Sublayer undoable **Command**."""
def __init__(
self, layer_identifier: str, sublayer_position: int, usd_context: Union[str, omni.usd.UsdContext] = ""
):
"""Constructor.
Keyword Arguments:
layer_identifier (str): The identifier of layer to remove sublayer.
sublayer_position (int): The sublayer position to be removed.
usd_context (Union[str, omni.usd.UsdContext]): Usd context name or instance. It uses default context if it's empty.
"""
super().__init__(usd_context)
self._layer_identifier = layer_identifier
self._sublayer_position = sublayer_position
def do_impl(self):
stage = self._usd_context.get_stage()
root_layer = stage.GetRootLayer()
self._removed_layer_identifier = None
layer = Sdf.Find(self._layer_identifier)
sublayer_identifier = LayerUtils.get_sublayer_identifier(self._layer_identifier, self._sublayer_position)
if not layer or not sublayer_identifier:
return
self._old_layer_global_mute = LayerUtils.get_layer_global_muteness(root_layer, sublayer_identifier)
self._old_layer_local_mute = stage.IsLayerMuted(sublayer_identifier)
self._old_layer_lock_status = LayerUtils.get_layer_lock_status(root_layer, sublayer_identifier)
if Sdf.Layer.IsAnonymousLayerIdentifier(sublayer_identifier):
# Hold layer reference to avoid it's released for undo
self._removed_layer = Sdf.Layer.FindOrOpen(sublayer_identifier)
else:
self._removed_layer = None
edit_target_layer = stage.GetEditTarget().GetLayer()
if edit_target_layer:
current_edit_target = edit_target_layer.identifier
else:
current_edit_target = None
self._removed_layer_identifier = LayerUtils.remove_sublayer(layer, self._sublayer_position)
LayerUtils.remove_layer_global_muteness(root_layer, self._removed_layer_identifier)
LayerUtils.remove_layer_lock_status(root_layer, self._removed_layer_identifier)
if current_edit_target and current_edit_target == self._removed_layer_identifier:
edit_target = Usd.EditTarget(stage.GetRootLayer())
stage.SetEditTarget(edit_target)
elif not current_edit_target:
root_layer_target = Usd.EditTarget(stage.GetRootLayer())
stage.SetEditTarget(root_layer_target)
def undo_impl(self):
if self._removed_layer_identifier:
stage = self._usd_context.get_stage()
root_layer = stage.GetRootLayer()
layer = Sdf.Find(self._layer_identifier)
if layer:
position = self._sublayer_position
sublayer = LayerUtils.insert_sublayer(layer, position, self._removed_layer_identifier)
if sublayer:
if self._old_layer_local_mute:
stage.MuteLayer(sublayer.identifier)
else:
stage.UnmuteLayer(sublayer.identifier)
LayerUtils.set_layer_global_muteness(root_layer, sublayer.identifier, self._old_layer_global_mute)
LayerUtils.set_layer_lock_status(root_layer, sublayer.identifier, self._old_layer_lock_status)
class RemovePrimSpecCommand(omni.kit.commands.Command):
"""Remove Prim undoable **Command**."""
def __init__(
self,
layer_identifier: str,
prim_spec_path: Union[Sdf.Path, List[Sdf.Path]],
usd_context: Union[str, omni.usd.UsdContext] = "",
):
"""Constructor.
Keyword Arguments:
layer_identifier (str): The identifier of layer to remove prim.
prim_spec_path (Union[Sdf.Path, List[Sdf.Path]]): The prim paths to be removed.
usd_context (Union[str, omni.usd.UsdContext]): Usd context name or instance. It uses default context if it's empty.
"""
self._usd_context = _get_usd_context(usd_context)
self._layer_identifier = layer_identifier
self._anon_layer = None
if isinstance(prim_spec_path, Sdf.Path) or isinstance(prim_spec_path, str):
self._prim_spec_paths = [prim_spec_path]
else:
self._prim_spec_paths = prim_spec_path
def do(self):
layer = Sdf.Find(self._layer_identifier)
if layer:
with Sdf.ChangeBlock():
for prim_spec_path in self._prim_spec_paths:
prim_spec = layer.GetPrimAtPath(prim_spec_path)
if not prim_spec:
return
self._anon_layer = Sdf.Layer.CreateAnonymous()
Sdf.CreatePrimInLayer(self._anon_layer, prim_spec_path)
Sdf.CopySpec(layer, prim_spec_path, self._anon_layer, prim_spec_path)
LayerUtils.remove_prim_spec(layer, prim_spec_path)
else:
self._anon_layer = None
self._layer_identifier = None
def undo(self):
if self._anon_layer and self._layer_identifier:
layer = Sdf.Find(self._layer_identifier)
if layer:
with Sdf.ChangeBlock():
for prim_spec_path in self._prim_spec_paths:
Sdf.CreatePrimInLayer(self._anon_layer, prim_spec_path)
Sdf.CopySpec(self._anon_layer, prim_spec_path, layer, prim_spec_path)
self._anon_layer = None
class MergeLayersCommand(AbstractLayerCommand):
"""Merge Layers undoable **Command**."""
def __init__(
self,
dst_parent_layer_identifier: str,
dst_layer_identifier,
src_parent_layer_identifier: str,
src_layer_identifier: str,
dst_stronger_than_src: bool,
usd_context: Union[str, omni.usd.UsdContext] = "",
):
"""Constructor.
Keyword Arguments:
dst_parent_layer_identifier: The parent of target layer.
dst_layer_identifier: The target layer that source layer is merged to.
src_parent_layer_identifier: The parent of source layer.
src_layer_identifier: The source layer.
dst_stronger_than_src (bool): If target layer is stronger than source, which will decide
how to merge opinions that appear in both layers.
usd_context (Union[str, omni.usd.UsdContext]): Usd context name or instance. It uses default context if it's empty.
"""
super().__init__(usd_context)
self._merged = False
self._delete_cmds = []
self._dst_layer_identifier = dst_layer_identifier
self._src_layer_identifier = src_layer_identifier
self._dst_parent_layer_identifier = dst_parent_layer_identifier
self._src_parent_layer_identifier = src_parent_layer_identifier
self._dst_stronger_than_src = dst_stronger_than_src
def do_impl(self):
temp_layer = None
stage = self._usd_context.get_stage()
strong_muted = stage.IsLayerMuted(self._dst_layer_identifier)
weak_muted = stage.IsLayerMuted(self._src_layer_identifier)
strong_layer = Sdf.Layer.Find(self._dst_layer_identifier)
src_sublayer_position = LayerUtils.get_sublayer_position_in_parent(
self._src_parent_layer_identifier, self._src_layer_identifier
)
if strong_muted or not strong_layer:
# strong layer inactive - delete it
sublayer_position = LayerUtils.get_sublayer_position_in_parent(
self._dst_parent_layer_identifier, self._dst_layer_identifier
)
delete_cmd = RemoveSublayerCommand(self._dst_parent_layer_identifier, sublayer_position)
delete_cmd.do_impl()
self._delete_cmds.append(delete_cmd)
elif not weak_muted:
# both are not muted - merge
temp_layer = Sdf.Layer.CreateAnonymous()
temp_layer.TransferContent(strong_layer)
self._removed_layer = temp_layer
omni.usd.merge_layers(self._dst_layer_identifier, self._src_layer_identifier, self._dst_stronger_than_src)
self._merged = True
if self._merged or (not strong_muted and strong_layer):
# Since omni.usd.merge_layers will clear all sublayers, it needs to
# insert again to create a remove command if src layer is a sublayer of dst layer.
if self._merged and self._dst_layer_identifier == self._src_parent_layer_identifier:
LayerUtils.insert_sublayer(strong_layer, src_sublayer_position, self._src_layer_identifier)
delete_cmd = RemoveSublayerCommand(self._src_parent_layer_identifier, src_sublayer_position)
delete_cmd.do_impl()
self._delete_cmds.append(delete_cmd)
# FIXME: Remove this weak layer from temp layer also.
# This is not an issue for offline stage.
if temp_layer:
if self._dst_layer_identifier == self._src_parent_layer_identifier:
LayerUtils.remove_sublayer(temp_layer, src_sublayer_position)
def undo_impl(self):
if self._merged:
if self._dst_layer_identifier == self._src_parent_layer_identifier:
# transfering content here will invalidate prims in the deleted layer
dst_layer = Sdf.Find(self._dst_layer_identifier)
if dst_layer:
with Sdf.ChangeBlock():
Sdf.CopySpec(
self._removed_layer, Sdf.Path.absoluteRootPath, dst_layer, Sdf.Path.absoluteRootPath
)
for delete_cmd in reversed(self._delete_cmds):
delete_cmd.undo_impl()
else:
with Sdf.ChangeBlock():
for delete_cmd in reversed(self._delete_cmds):
delete_cmd.undo_impl()
layer = Sdf.Find(self._dst_layer_identifier)
if layer:
# FIXME: It cannot use TransferContent which does not notify anything
Sdf.CopySpec(self._removed_layer, Sdf.Path.absoluteRootPath, layer, Sdf.Path.absoluteRootPath)
for sublayer in self._removed_layer.subLayerPaths:
if sublayer not in layer.subLayerPaths:
layer.subLayerPaths.append(sublayer)
self._removed_layer = None
else:
with Sdf.ChangeBlock():
for delete_cmd in reversed(self._delete_cmds):
delete_cmd.undo_impl()
self._delete_cmds.clear()
class FlattenLayersCommand(AbstractLayerCommand):
"""Flatten Layers undoable **Command**."""
def __init__(self, usd_context: Union[str, omni.usd.UsdContext] = ""):
"""Constructor.
Keyword Arguments:
usd_context (Union[str, omni.usd.UsdContext]): Usd context name or instance. It uses default context if it's empty.
"""
super().__init__(usd_context)
self._merges = []
def _traverse(self, results, parent_layer_identifier, layer, layer_identifier, current_subtree_stack):
# It has circular sublayer tree, like sub1 -> sub2 -> sub1
if layer_identifier in current_subtree_stack:
return
results.append((parent_layer_identifier, layer_identifier))
current_subtree_stack.append(layer_identifier)
if not layer:
return
for sublayer in layer.subLayerPaths:
sublayer_identifier = layer.ComputeAbsolutePath(sublayer)
sublayer = Sdf.Find(sublayer_identifier)
self._traverse(results, layer.identifier, sublayer, sublayer_identifier, current_subtree_stack)
current_subtree_stack.pop()
def _get_sublayers_from_strongest_to_weakest(self):
stage = self._usd_context.get_stage()
root_layer = stage.GetRootLayer()
all_layers = []
current_subtree_stack = []
self._traverse(all_layers, None, root_layer, root_layer.identifier, current_subtree_stack)
return all_layers
def do_impl(self):
all_sublayers = self._get_sublayers_from_strongest_to_weakest()
mergable_parent_identifier = None
mergable_sublayer_identifier = None
for i in reversed(range(len(all_sublayers))):
parent_identifier = all_sublayers[i][0]
sublayer_identifier = all_sublayers[i][1]
if mergable_parent_identifier is not None:
merge = MergeLayersCommand(
parent_identifier,
sublayer_identifier,
mergable_parent_identifier,
mergable_sublayer_identifier,
True,
)
merge.do_impl()
self._merges.append(merge)
mergable_parent_identifier = parent_identifier
mergable_sublayer_identifier = sublayer_identifier
def undo_impl(self):
self._merges.reverse()
for m in self._merges:
m.undo_impl()
self._merges.clear()
class CreateLayerReferenceCommand(AbstractLayerCommand):
"""
Create reference in specific layer undoable **Command**.
It creates a new prim and adds the asset and path as references in specific layer.
Args:
layer_identifier: str: Layer identifier to create prim inside.
path_to (Sdf.Path): Path to create a new prim.
asset_path (str): The asset it's necessary to add to references.
prim_path (Sdf.Path): The prim in asset to reference.
usd_context (Union[str, omni.usd.UsdContext]): Usd context name or instance. It uses default context if it's empty.
"""
def __init__(
self,
layer_identifier: str,
path_to: Sdf.Path,
asset_path: str = None,
prim_path: Sdf.Path = None,
usd_context: Union[str, omni.usd.UsdContext] = "",
):
super().__init__(usd_context)
self._selection = self._usd_context.get_selection()
stage = self._usd_context.get_stage()
path_to = Sdf.Path(omni.usd.get_stage_next_free_path(stage, str(path_to), False))
self._layer_identifier = layer_identifier
self._asset_path = asset_path
self._prim_path = prim_path
self._path_to = path_to
def do_impl(self):
layer = Sdf.Find(self._layer_identifier)
if not layer:
return False
stage = self._usd_context.get_stage()
with Usd.EditContext(stage, layer):
prim_to = stage.DefinePrim(self._path_to)
with Sdf.ChangeBlock():
# Set inctanceable
if self._asset_path:
if self._prim_path:
prim_to.GetReferences().AddReference(self._asset_path, self._prim_path)
else:
prim_to.GetReferences().AddReference(self._asset_path)
elif self._prim_path:
prim_to.GetReferences().AddInternalReference(self._prim_path)
def undo_impl(self):
layer = Sdf.Find(self._layer_identifier)
if not layer:
return False
# Dereference this. Otherwise it fires error: Cannot remove ancestral prim
stage = self._usd_context.get_stage()
with Usd.EditContext(stage, layer):
prim_to = stage.GetPrimAtPath(self._path_to)
prim_to.GetReferences().ClearReferences()
# It would be better to use the following command, but it's in buildins and not available:
# delete_cmd = DeletePrimsCommand([self._path_to])
# delete_cmd.do()
for layer in stage.GetLayerStack():
edit = Sdf.BatchNamespaceEdit()
temp_layer = Sdf.Layer.CreateAnonymous()
prim_spec = layer.GetPrimAtPath(self._path_to)
if prim_spec is None:
continue
parent_spec = prim_spec.realNameParent
if parent_spec is not None:
Sdf.CreatePrimInLayer(temp_layer, self._path_to)
Sdf.CopySpec(layer, self._path_to, temp_layer, self._path_to)
edit.Add(self._path_to, Sdf.Path.emptyPath)
layer.Apply(edit)
class StitchPrimSpecsToLayer(AbstractLayerCommand):
"""Flatten specific prims in the stage.
It will remove original prim specs after flatten.
"""
def __init__(
self, prim_paths: List[str], target_layer_identifier: str, usd_context: Union[str, omni.usd.UsdContext] = ""
):
"""Constructor.
Keyword Arguments:
prim_paths (List[str]): A list of prim_paths to flatten with.
target_layer_identifier (str): The target layer to store the flatten results.
usd_context (Union[str, omni.usd.UsdContext]): Usd context name or instance. It uses default context if it's empty.
"""
super().__init__(usd_context)
self._prim_paths = prim_paths
self._target_layer_identifier = target_layer_identifier
self._to_recoverd_layers = {}
def do_impl(self):
self._to_recoverd_layers.clear()
target_layer = Sdf.Find(self._target_layer_identifier)
stage = self._usd_context.get_stage()
if stage and target_layer and self._prim_paths:
# Saves context before real flatten for undo.
all_sublayer_paths = LayerUtils.get_all_sublayers(stage)
if self._target_layer_identifier not in all_sublayer_paths:
all_sublayer_paths.append(self._target_layer_identifier)
with Sdf.ChangeBlock():
for sublayer_path in all_sublayer_paths:
sublayer = Sdf.Layer.Find(sublayer_path)
if not sublayer:
continue
for prim_spec_path in self._prim_paths:
recover_layer = self._to_recoverd_layers.get(sublayer_path, None)
if not recover_layer:
recover_layer = Sdf.Layer.CreateAnonymous()
self._to_recoverd_layers[sublayer_path] = recover_layer
prim_spec = sublayer.GetPrimAtPath(prim_spec_path)
if not prim_spec:
continue
Sdf.CreatePrimInLayer(recover_layer, prim_spec_path)
Sdf.CopySpec(sublayer, prim_spec_path, recover_layer, prim_spec_path)
for prim_path in self._prim_paths:
omni.usd.stitch_prim_specs(stage, prim_path, target_layer)
# Delete it from src layer
all_sublayer_paths.remove(self._target_layer_identifier)
for sublayer_path in all_sublayer_paths:
for prim_spec_path in self._prim_paths:
sublayer = Sdf.Layer.Find(sublayer_path)
if not sublayer:
continue
LayerUtils.remove_prim_spec(sublayer, prim_spec_path)
def undo_impl(self):
with Sdf.ChangeBlock():
for layer_identifier, layer_content in self._to_recoverd_layers.items():
original_layer = Sdf.Layer.Find(layer_identifier)
if not original_layer:
continue
for prim_spec_path in self._prim_paths:
if layer_content.GetPrimAtPath(prim_spec_path):
Sdf.CreatePrimInLayer(original_layer, prim_spec_path)
Sdf.CopySpec(layer_content, prim_spec_path, original_layer, prim_spec_path)
else:
LayerUtils.remove_prim_spec(original_layer, prim_spec_path)
self._to_recoverd_layers.clear()
class MovePrimSpecsToLayerCommand(AbstractLayerCommand):
"""Merge prim spec from src layer to dst layer and remove it from src layer."""
def __init__(
self,
dst_layer_identifier: str,
src_layer_identifier: str,
prim_spec_path: str,
dst_stronger_than_src: bool,
usd_context: Union[str, omni.usd.UsdContext] = "",
):
"""Constructor.
Keyword Arguments:
dst_layer_identifier (str): The identifier of target layer.
src_layer_identifier (str): The identifier of source layer.
prim_spec_path (str): The prim spec path to be merged.
dst_stronger_than_src (bool): Target layer is stronger than source layer in stage.
usd_context (Union[str, omni.usd.UsdContext]): Usd context name or instance. It uses default context if it's empty.
"""
super().__init__(usd_context)
self._dst_layer_identifier = dst_layer_identifier
self._src_layer_identifier = src_layer_identifier
self._prim_spec_path = prim_spec_path
self._dst_stronger_than_src = dst_stronger_than_src
def do_impl(self):
if self._dst_layer_identifier != self._src_layer_identifier:
dst_layer = Sdf.Find(self._dst_layer_identifier)
src_layer = Sdf.Find(self._src_layer_identifier)
if dst_layer and src_layer:
self._anon_dst_layer = Sdf.Layer.CreateAnonymous()
# backup dst node for undo if prim exists
prim_spec = dst_layer.GetPrimAtPath(self._prim_spec_path)
self._created_prim = None
if prim_spec is not None:
Sdf.CreatePrimInLayer(self._anon_dst_layer, self._prim_spec_path)
Sdf.CopySpec(dst_layer, self._prim_spec_path, self._anon_dst_layer, self._prim_spec_path)
else:
# prim doesnt exist in dst, so merge_prim_spec will create any missing parents in dst,
# and we will have to remove them during undo
prim_spec = src_layer.GetPrimAtPath(self._prim_spec_path)
parent = prim_spec.realNameParent
while (
parent is not None
and parent.realNameParent is not None
and dst_layer.GetPrimAtPath(parent.path) is None
):
self._created_prim = parent.path
parent = parent.realNameParent
# Create prim spec in dst if it's not existed.
omni.usd.merge_prim_spec(
self._dst_layer_identifier,
self._src_layer_identifier,
self._prim_spec_path,
self._dst_stronger_than_src,
)
# Delete it from src layer
self._delete_cmd = RemovePrimSpecCommand(self._src_layer_identifier, self._prim_spec_path)
self._delete_cmd.do()
self._dst_layer_path = self._dst_layer_identifier
else:
self._dst_layer_path = None
def undo_impl(self):
if self._dst_layer_identifier != self._src_layer_identifier:
self._delete_cmd.undo()
self._delete_cmd = None
if not self._dst_layer_path:
return
dst_layer = Sdf.Find(self._dst_layer_identifier)
if dst_layer:
prim_spec = self._anon_dst_layer.GetPrimAtPath(self._prim_spec_path)
if prim_spec is not None:
Sdf.CopySpec(self._anon_dst_layer, self._prim_spec_path, dst_layer, self._prim_spec_path)
else:
LayerUtils.remove_prim_spec(dst_layer, self._prim_spec_path)
if self._created_prim is not None:
LayerUtils.remove_prim_spec(dst_layer, self._created_prim.pathString)
self._anon_dst_layer = None
class MoveSublayerCommand(AbstractLayerCommand):
"""Move Sublayer undoable **Command**."""
def __init__(
self,
from_parent_layer_identifier: str,
from_sublayer_position: int,
to_parent_layer_identifier: str,
to_sublayer_position: int,
remove_source: bool = False,
usd_context: Union[str, omni.usd.UsdContext] = "",
):
"""Constructor.
Keyword Arguments:
from_parent_layer_identifier (str): The identifier of source parent layer.
from_sublayer_position (int): The sublayer position in source parent layer to move.
to_parent_layer_identifier (str): The identifier of target parent layer.
to_sublayer_position (int): The sublayer position in target parent layer that layers moves to.
If this position is -1, it means the last position of sublayer array.
If this position is beyond the end of sublayer array. It means to
move this layer to the end of that array.
Otherwise, it's invalid if it's below 0.
remove_source (bool): Remove source sublayer after moving to target or not.
usd_context (Union[str, omni.usd.UsdContext]): Usd context name or instance. It uses default context if it's empty.
"""
super().__init__(usd_context)
self._from_parent_layer_identifier = from_parent_layer_identifier
self._from_sublayer_position = from_sublayer_position
self._sublayer_identifier = LayerUtils.get_sublayer_identifier(
self._from_parent_layer_identifier, self._from_sublayer_position
)
if self._sublayer_identifier:
self._to_parent_layer_identifier = to_parent_layer_identifier
self._to_sublayer_position = to_sublayer_position
self._success = False
sublayer_position_in_target = LayerUtils.get_sublayer_position_in_parent(
self._to_parent_layer_identifier, self._sublayer_identifier
)
self._remove_source = remove_source
if self._from_parent_layer_identifier == self._to_parent_layer_identifier:
# It must remove source to move this layer.
self._remove_source = True
self._has_same_layer_in_target = False
else:
self._has_same_layer_in_target = sublayer_position_in_target != -1
def _move_layer(
self,
from_parent_layer_identifier,
sublayer_identifier,
to_parent_layer_identifier,
to_sublayer_position,
remove_source,
):
# Finds moved layer.
layer_position_in_parent = LayerUtils.get_sublayer_position_in_parent(
from_parent_layer_identifier, sublayer_identifier
)
# Cannot find moved layer
if layer_position_in_parent == -1:
carb.log_warn(
f"Cannot move layer from sublayer {sublayer_identifier} under parent {from_parent_layer_identifier} to "
f"sublayer at position {to_sublayer_position} under parent {to_parent_layer_identifier} "
f"since moved layer cannot be found."
)
return False
# Find target layer
return LayerUtils.move_layer(
from_parent_layer_identifier,
layer_position_in_parent,
to_parent_layer_identifier,
to_sublayer_position,
remove_source,
)
def do_impl(self):
if not self._sublayer_identifier:
return
self._move_layer(
self._from_parent_layer_identifier,
self._sublayer_identifier,
self._to_parent_layer_identifier,
self._to_sublayer_position,
self._remove_source,
)
def undo_impl(self):
if not self._sublayer_identifier:
return
self._move_layer(
self._to_parent_layer_identifier,
self._sublayer_identifier,
self._from_parent_layer_identifier,
self._from_sublayer_position,
not self._has_same_layer_in_target,
)
class ReplaceSublayerCommand(AbstractLayerCommand):
"""Replace Layer undoable **Command**."""
def __init__(
self,
layer_identifier: str,
sublayer_position: int,
new_layer_path: str,
usd_context: Union[str, omni.usd.UsdContext] = "",
):
"""Constructor.
Keyword Arguments:
layer_identifier (str): The identifier of layer to replace sublayer.
sublayer_position (int): The sublayer position to be replaced.
new_layer_path (str): The path of new layer.
usd_context (Union[str, omni.usd.UsdContext]): Usd context name or instance. It uses default context if it's empty.
"""
super().__init__(usd_context)
self._layer_identifier = layer_identifier
self._sublayer_position = sublayer_position
self._new_layer_path = new_layer_path
self._old_layer_identifier = None
self._new_layer_identifier = None
def do_impl(self):
self._old_layer_identifier = LayerUtils.get_sublayer_identifier(self._layer_identifier, self._sublayer_position)
if not self._old_layer_identifier:
carb.log_warn(f"Cannot replace sublayer with an invalid index {self._sublayer_position}.")
return
stage = self._usd_context.get_stage()
root_layer = stage.GetRootLayer()
self._old_layer_global_mute = LayerUtils.get_layer_global_muteness(root_layer, self._layer_identifier)
self._old_layer_local_mute = stage.IsLayerMuted(self._layer_identifier)
self._old_layer_lock_status = LayerUtils.get_layer_lock_status(root_layer, self._layer_identifier)
layer = Sdf.Find(self._layer_identifier)
if layer:
edit_target_identifier = LayerUtils.get_edit_target(stage)
new_layer = LayerUtils.replace_sublayer(layer, self._sublayer_position, self._new_layer_path)
if edit_target_identifier == self._old_layer_identifier:
LayerUtils.set_edit_target(stage, self._new_layer_path)
if new_layer:
LayerUtils.remove_layer_global_muteness(root_layer, self._layer_identifier)
LayerUtils.remove_layer_lock_status(root_layer, self._layer_identifier)
self._new_layer_identifier = new_layer.identifier
else:
self._new_layer_identifier = None
else:
self._new_layer_identifier = None
def undo_impl(self):
stage = self._usd_context.get_stage()
root_layer = stage.GetRootLayer()
if self._new_layer_identifier:
with Sdf.ChangeBlock():
new_layer_position_in_parent = LayerUtils.get_sublayer_position_in_parent(
self._layer_identifier, self._new_layer_identifier
)
if new_layer_position_in_parent != -1:
layer = Sdf.Find(self._layer_identifier)
if layer:
edit_target_identifier = LayerUtils.get_edit_target(stage)
LayerUtils.replace_sublayer(layer, new_layer_position_in_parent, self._old_layer_identifier)
if edit_target_identifier == self._old_layer_identifier:
LayerUtils.set_edit_target(stage, self._new_layer_path)
if self._old_layer_local_mute:
stage.MuteLayer(self._old_layer_identifier)
else:
stage.UnmuteLayer(self._old_layer_identifier)
LayerUtils.set_layer_global_muteness(
root_layer, self._old_layer_identifier, self._old_layer_global_mute
)
LayerUtils.set_layer_lock_status(
root_layer, self._old_layer_identifier, self._old_layer_lock_status
)
class SetLayerMutenessCommand(AbstractLayerCommand):
"""Set Layer's muteness undoable **Command**."""
def __init__(self, layer_identifier: str, muted: bool, usd_context: Union[str, omni.usd.UsdContext] = ""):
"""Constructor.
Keyword Arguments:
layer_identifier (str): The identifier of layer to be muted/unmuted.
muted (bool): Muted or not of this layer.
usd_context (Union[str, omni.usd.UsdContext]): Usd context name or instance. It uses default context if it's empty.
"""
super().__init__(usd_context)
self._layer_identifier = layer_identifier
self._muted = muted
def do_impl(self):
stage = self._usd_context.get_stage()
if not stage:
return False
session_layer_identifier = stage.GetSessionLayer().identifier
root_layer_identifier = stage.GetRootLayer().identifier
if self._layer_identifier == session_layer_identifier or self._layer_identifier == root_layer_identifier:
return False
edit_target_identifier = LayerUtils.get_edit_target(stage)
if self._muted:
stage.MuteLayer(self._layer_identifier)
if edit_target_identifier == self._layer_identifier:
stage.SetEditTarget(Usd.EditTarget(stage.GetRootLayer()))
else:
stage.UnmuteLayer(self._layer_identifier)
def undo_impl(self):
stage = self._usd_context.get_stage()
if not stage:
return False
edit_target_identifier = LayerUtils.get_edit_target(stage)
if not self._muted:
stage.MuteLayer(self._layer_identifier)
if edit_target_identifier == self._layer_identifier:
stage.SetEditTarget(Usd.EditTarget(stage.GetRootLayer()))
else:
stage.UnmuteLayer(self._layer_identifier)
class LockLayer(AbstractLayerCommand):
"""Set Layer's lock status undoable **Command**."""
def __init__(self, layer_identifier: str, locked: bool, usd_context: Union[str, omni.usd.UsdContext] = ""):
"""Constructor. REMINDER: Locking root layer is not permitted.
Keyword Arguments:
layer_identifier (str): The identifier of layer to be muted/unmuted.
locked (bool): Muted or not of this layer.
usd_context (Union[str, omni.usd.UsdContext]): Usd context name or instance. It uses default context if it's empty.
"""
super().__init__(usd_context)
self._layer_identifier = layer_identifier
self._locked = locked
def do_impl(self):
stage = self._usd_context.get_stage()
if not stage or self._layer_identifier == stage.GetRootLayer().identifier:
return False
root_layer = stage.GetRootLayer()
LayerUtils.set_layer_lock_status(root_layer, self._layer_identifier, self._locked)
if self._locked and LayerUtils.get_edit_target(stage) == self._layer_identifier:
LayerUtils.set_edit_target(stage, stage.GetRootLayer().identifier)
def undo_impl(self):
stage = self._usd_context.get_stage()
if not stage or self._layer_identifier == stage.GetRootLayer().identifier:
return False
root_layer = stage.GetRootLayer()
LayerUtils.set_layer_lock_status(root_layer, self._layer_identifier, not self._locked)
class LinkSpecsCommand(AbstractLayerCommand):
"""Links spec paths to layers undoable **Command**."""
def __init__(
self,
spec_paths: Union[str, List[str]],
layer_identifiers: Union[str, List[str]],
additive: bool = True,
hierarchy: bool = False,
usd_context: Union[str, omni.usd.UsdContext] = "",
):
"""Constructor.
Keyword Arguments:
spec_paths (Union[str, List[str]]): List of spec paths or single spec path to be linked.
layer_identifiers (Union[str, List[str]]): List of layer identifiers or single layer identifier.
additive (bool): Clearing exsiting links or not.
hierarchy (bool): Linking descendant specs or not.
usd_context (Union[str, omni.usd.UsdContext]): Usd context name or instance. It uses default context if it's empty.
"""
super().__init__(usd_context)
if isinstance(spec_paths, str) or isinstance(spec_paths, Sdf.Path):
self._paths = [spec_paths]
else:
self._paths = spec_paths
if isinstance(layer_identifiers, str):
self._layer_identifiers = [layer_identifiers]
else:
self._layer_identifiers = layer_identifiers
self._additive = additive
self._hierarchy = hierarchy
self._old_spec_links = {}
# TODO: Support transferring and discard edits
def do(self):
self._old_spec_links = get_spec_layer_links(self._usd_context, self._paths, self._hierarchy)
if not self._additive:
unlink_specs_from_all_layers(self._usd_context, self._paths, self._hierarchy)
link_specs(self._usd_context, self._paths, self._layer_identifiers, self._hierarchy)
def undo(self):
new_paths = []
for path in self._paths:
if path not in self._old_spec_links:
new_paths.append(path)
unlink_specs_from_all_layers(self._usd_context, self._paths, self._hierarchy)
self._restore_spec_links_from_dict(self._old_spec_links)
class UnlinkSpecsCommand(AbstractLayerCommand):
"""Unlinks spec paths to layers undoable **Command**."""
def __init__(
self,
spec_paths: Union[str, List[str]],
layer_identifiers: Union[str, List[str]],
hierarchy=False,
usd_context: Union[str, omni.usd.UsdContext] = "",
):
"""Constructor.
Keyword Arguments:
spec_paths (Union[str, List[str]]): List of spec paths or single spec path to be unlinked.
layer_identifiers (Union[str, List[str]]): List of layer identifiers or single layer identifier.
hierarchy (bool): Unlinking descendant specs or not.
usd_context (Union[str, omni.usd.UsdContext]): Usd context name or instance. It uses default context if it's empty.
"""
super().__init__(usd_context)
if isinstance(spec_paths, str) or isinstance(spec_paths, Sdf.Path):
self._paths = [spec_paths]
else:
self._paths = spec_paths
if isinstance(layer_identifiers, str):
self._layer_identifiers = [layer_identifiers]
else:
self._layer_identifiers = layer_identifiers
self._hierarchy = hierarchy
self._old_spec_links = {}
def do(self):
self._old_spec_links = get_spec_layer_links(self._usd_context, self._paths, self._hierarchy)
unlink_specs(self._usd_context, self._paths, self._layer_identifiers, self._hierarchy)
def undo(self):
self._restore_spec_links_from_dict(self._old_spec_links)
class LockSpecsCommand(AbstractLayerCommand):
"""Locks spec paths undoable **Command**."""
def __init__(
self, spec_paths: Union[str, List[str]], hierarchy=False, usd_context: Union[str, omni.usd.UsdContext] = ""
):
"""Constructor.
Keyword Arguments:
spec_paths (Union[str, List[str]]): List of spec paths or single spec path to be locked.
hierarchy (bool): Locking descendant specs or not.
usd_context (Union[str, omni.usd.UsdContext]): Usd context name or instance. It uses default context if it's empty.
"""
super().__init__(usd_context)
if isinstance(spec_paths, str) or isinstance(spec_paths, Sdf.Path):
self._paths = [spec_paths]
else:
self._paths = spec_paths
self._hierarchy = hierarchy
self._old_spec_locks = []
self._locked_specs = []
def do(self):
self._old_spec_locks = get_all_locked_specs(self._usd_context)
lock_specs(self._usd_context, self._paths, self._hierarchy)
self._locked_specs = get_all_locked_specs(self._usd_context)
def undo(self):
unlock_specs(self._usd_context, self._locked_specs, False)
self._locked_specs = []
lock_specs(self._usd_context, self._old_spec_locks, False)
self._old_spec_locks = []
class UnlockSpecsCommand(AbstractLayerCommand):
"""Unlocks spec paths undoable **Command**."""
def __init__(
self, spec_paths: Union[str, List[str]], hierarchy=False, usd_context: Union[str, omni.usd.UsdContext] = ""
):
"""Constructor.
Keyword Arguments:
spec_paths (Union[str, List[str]]): List of spec paths or single spec path to be unlocked.
hierarchy (bool): Unlocking descendant specs or not.
usd_context (Union[str, omni.usd.UsdContext]): Usd context name or instance. It uses default context if it's empty.
"""
super().__init__(usd_context)
if isinstance(spec_paths, str) or isinstance(spec_paths, Sdf.Path):
self._paths = [spec_paths]
else:
self._paths = spec_paths
self._hierarchy = hierarchy
self._old_spec_locks = []
def do(self):
self._old_spec_locks = get_all_locked_specs(self._usd_context)
unlock_specs(self._usd_context, self._paths, self._hierarchy)
def undo(self):
lock_specs(self._usd_context, self._old_spec_locks, False)
| 51,798 | Python | 40.045166 | 136 | 0.591702 |
omniverse-code/kit/exts/omni.kit.usd.layers/omni/kit/usd/layers/impl/layers_state.py | import carb
from pxr import Sdf
from urllib.parse import unquote
from .layer_utils import LayerUtils
from .._omni_kit_usd_layers import (
acquire_layers_state_interface,
release_layers_state_interface,
ILayersInstance,
)
class LayersState:
def __init__(self, layers_instance: ILayersInstance, usd_context) -> None:
self._layers_instance = layers_instance
self._layers_state_interface = acquire_layers_state_interface()
self._dictionary = carb.dictionary.get_dictionary()
self._usd_context = usd_context
@property
def usd_context(self):
return self._usd_context
def destroy(self):
self._layers_instance = None
release_layers_state_interface(self._layers_state_interface)
def set_muteness_scope(self, global_scope: bool):
self._layers_state_interface.set_muteness_scope(self._layers_instance, global_scope)
def is_muteness_global(self) -> bool:
"""
Global muteness is an extended concept for Omniverse so muteness can be authored into
USD for persistence. When you set muteness scope as global with set_muteness_scope,
all muteness of sublayers will be stored to root layer's custom data and it will be
loaded for next stage open.
"""
return self._layers_state_interface.is_muteness_global(self._layers_instance)
def is_layer_locally_muted(self, layer_identifier: str) -> bool:
return self._layers_state_interface.is_layer_locally_muted(self._layers_instance, layer_identifier)
def is_layer_globally_muted(self, layer_identifier: str) -> bool:
"""
Checkes if layer is globally muted or not in this usd context.
Global muteness is a customize concept in Kit that's not from USD. It's used for complement
the USD muteness, that works for two purposes:
1. It's stage bound. So a layer is globally muted in this stage will not influence others.
2. It's persistent. Right now, it's saved inside the custom data of root layer.
After stage load, it will be read to initialize the muteness of layers. Also, global muteness
only takes effective when it's in global state mode. See omni.usd.UsdContext.set_layer_muteness_scope
about how to switch muteness scope. When it's not in global state mode, authoring global
muteness will not incluence layer's muteness in stage.
"""
return self._layers_state_interface.is_layer_globally_muted(self._layers_instance, layer_identifier)
def is_layer_writable(self, layer_identifier: str) -> bool:
"""
Checkes if layer is writable. A layer is writable means it can be set as edit target, which should satisfy:
1. It's not read-only on disk.
2. It's not locked by set_layer_lock_state.
3. It's not muted.
It still can be set as edit target with scripts, while this can be used for guardrails.
"""
return self._layers_state_interface.is_layer_writable(self._layers_instance, layer_identifier)
def is_layer_readonly_on_disk(self, layer_identifier: str) -> bool:
"""
Checkes if this layer is physically read-only on disk.
"""
return self._layers_state_interface.is_layer_readonly_on_disk(self._layers_instance, layer_identifier)
def is_layer_savable(self, layer_identifier: str) -> bool:
"""
Checkes if this layer is savable. If it's savable means it's true by checking is_layer_writable and not anonymous.
"""
return self._layers_state_interface.is_layer_savable(self._layers_instance, layer_identifier)
def set_layer_lock_state(self, layer_identifier: str, locked: bool):
"""
Layer lock is an extended concept in Omniverse that works for lock this layer temporarily without real change
the file permission of this layer. It's just authored as a meta inside layer's custom data section, and read by
UI.
"""
self._layers_state_interface.set_layer_lock_state(self._layers_instance, layer_identifier, locked)
def is_layer_locked(self, layer_identifier: str) -> bool:
return self._layers_state_interface.is_layer_locked(self._layers_instance, layer_identifier)
def set_layer_name(self, layer_identifier: str, name: str):
self._layers_state_interface.set_layer_name(self._layers_instance, layer_identifier, name)
def get_layer_name(self, layer_identifier: str) -> str:
name = self._layers_state_interface.get_layer_name(self._layers_instance, layer_identifier)
if not name:
if Sdf.Layer.IsAnonymousLayerIdentifier(layer_identifier):
layer = Sdf.Find(layer_identifier)
if layer:
name = LayerUtils.get_custom_layer_name(layer)
else:
name = layer_identifier
else:
name = Sdf.Layer.GetDisplayNameFromIdentifier(layer_identifier)
return unquote(name)
def is_layer_outdated(self, layer_identifier: str) -> bool:
"""
If layer is out of sync. This only works for layer inside server.
"""
return self._layers_state_interface.is_layer_outdated(self._layers_instance, layer_identifier)
def _populate_all_identifiers(self, item: carb.dictionary.Item):
all_layer_identifiers = []
count = self._dictionary.get_item_child_count(item)
for i in range(count):
layer_item = self._dictionary.get_item_child_by_index(item, i)
layer_identifier = self._dictionary.get_as_string(layer_item)
all_layer_identifiers.append(layer_identifier)
return all_layer_identifiers
def get_local_layer_identifiers(self, include_session_layers=False, include_anonymous_layers=True, include_invalid_layers=False):
item = self._layers_state_interface.get_local_layer_identifiers(self._layers_instance, include_session_layers, include_anonymous_layers, include_invalid_layers)
if not item:
return []
all_layer_identifiers = self._populate_all_identifiers(item)
self._dictionary.destroy_item(item)
return all_layer_identifiers
def get_dirty_layer_identifiers(self):
"""Gets all layer identifiers that have pending edits that are not saved."""
item = self._layers_state_interface.get_dirty_layer_identifiers(self._layers_instance)
if not item:
return []
all_layer_identifiers = self._populate_all_identifiers(item)
self._dictionary.destroy_item(item)
return all_layer_identifiers
def has_local_layer(self, layer_identifier):
"""Layer is in the local layer stack of current stage."""
stage = self._usd_context.get_stage()
if not stage:
return False
layer = Sdf.Find(layer_identifier)
if not layer:
return False
return stage.HasLocalLayer(layer)
| 7,066 | Python | 41.572289 | 168 | 0.665016 |
omniverse-code/kit/exts/omni.kit.usd.layers/omni/kit/usd/layers/impl/interface_utils.py | import carb
from typing import List, Dict
from .._omni_kit_usd_layers import LayerEventType
class LayerEventPayload:
def __init__(self, event: carb.events.IEvent) -> None:
# It is non-empty if event_type is INFO_CHANGED, for which key is the layer identifier,
# and value is the set of strings that represent the info tokens.
self.layer_info_data: Dict[str, List[str]] = {}
# It's non-empty if event_type is DIRTY_STATE_CHANGED, OUTDATE_STATE_CHANGED
# LOCK_STATE_CHANGED, MUTENESS_STATE_CHANGED, SPECS_LOCKING_CHANGED, or
# LIVE_SESSION_STATE_CHANGED,
# which will include all influenced layer identifiers or spec paths.
self.identifiers_or_spec_paths: List[str] = []
# It's non-empty if event_type is PRIM_SPECS_CHANGED or SPECS_LINKING_CHANGED. For which, the key is the layer identifier,
# and value is the list of strings that represent spec paths.
self.layer_spec_paths: Dict[str, List[str]] = {}
# It's non-empty if event_type is LIVE_SESSION_USER_JOINED or LIVE_SESSION_USER_LEFT
self.user_name = None
# It's non-empty if event_type is LIVE_SESSION_USER_JOINED or LIVE_SESSION_USER_LEFT
self.user_id = None
# It's non-empty if event_type is LIVE_SESSION_MERGE_STARTED or LIVE_SESSION_MERGE_ENDED
self.layer_identifier = None
# It means if the merge of live session is successful or not.
self.success = True
self.event_type = LayerEventType(event.type)
if event.type == int(LayerEventType.INFO_CHANGED):
layer_identifier = event.payload["layer_identifier"]
info_data = event.payload["val"]
self.layer_info_data[layer_identifier] = list(info_data)
elif (
event.type == int(LayerEventType.DIRTY_STATE_CHANGED)
or event.type == int(LayerEventType.OUTDATE_STATE_CHANGED)
or event.type == int(LayerEventType.MUTENESS_STATE_CHANGED)
or event.type == int(LayerEventType.LOCK_STATE_CHANGED)
or event.type == int(LayerEventType.SPECS_LOCKING_CHANGED)
):
self.identifiers_or_spec_paths = list(event.payload["val"])
elif event.type == int(LayerEventType.PRIM_SPECS_CHANGED):
layer_identifier = event.payload["layer_identifier"]
prim_specs = event.payload["val"]
self.layer_spec_paths[layer_identifier] = list(prim_specs)
elif event.type == int(LayerEventType.SPECS_LINKING_CHANGED):
for _, value in event.payload["val"].items():
layer_identifier = value.get("key", "")
spec_paths = value.get("value", [])
if layer_identifier and spec_paths:
self.layer_spec_paths[layer_identifier] = spec_paths
elif (
event.type == int(LayerEventType.LIVE_SESSION_USER_JOINED)
or event.type == int(LayerEventType.LIVE_SESSION_USER_LEFT)
):
self.user_name = event.payload["user_name"]
self.user_id = event.payload["user_id"]
elif event.type == int(LayerEventType.LIVE_SESSION_STATE_CHANGED):
layer_identifiers = list(event.payload["val"])
if layer_identifiers:
self.identifiers_or_spec_paths = layer_identifiers
elif event.type == int(LayerEventType.LIVE_SESSION_LIST_CHANGED):
layer_identifier = event.payload["val"]
if layer_identifier:
self.identifiers_or_spec_paths = [layer_identifier]
elif (
event.type == int(LayerEventType.LIVE_SESSION_MERGE_STARTED) or
event.type == int(LayerEventType.LIVE_SESSION_MERGE_ENDED)
):
self.layer_identifier = event.payload["layer_identifier"]
self.success = event.payload["success"]
def get_layer_event_payload(event: carb.events.IEvent) -> LayerEventPayload:
try:
return LayerEventPayload(event)
except Exception as e:
carb.log_error(f"Failed to convert event: {str(e)}")
return None
def post_notification(message: str, info=True):
try:
import omni.kit.notification_manager as nm
if info:
status = nm.NotificationStatus.INFO
else:
status = nm.NotificationStatus.WARNING
nm.post_notification(message, status=status)
except Exception:
pass
| 4,426 | Python | 44.173469 | 130 | 0.633981 |
omniverse-code/kit/exts/omni.kit.usd.layers/omni/kit/usd/layers/impl/layers_interface.py | from .._omni_kit_usd_layers import LayerEditMode
from .layers_state import LayersState
from .specs_locking import SpecsLocking
from .auto_authoring import AutoAuthoring
from .specs_linking import SpecsLinking
from .live_syncing import LiveSyncing
class Layers:
def __init__(self, layers_instance, usd_context) -> None:
self._layers_instance = layers_instance
self._usd_context = usd_context
if self._layers_instance:
self._layers_state = LayersState(layers_instance, usd_context)
self._specs_locking = SpecsLocking(layers_instance, usd_context)
self._auto_authoring = AutoAuthoring(layers_instance, usd_context)
self._specs_linking = SpecsLinking(layers_instance, usd_context)
self._live_syncing = LiveSyncing(layers_instance, usd_context, self._layers_state)
else:
self._layers_state = None
self._specs_locking = None
self._auto_authoring = None
self._specs_linking = None
self._live_syncing = None
def destroy(self):
if self._specs_locking:
self._specs_locking.destroy()
self._specs_locking = None
if self._auto_authoring:
self._auto_authoring.destroy()
self._auto_authoring = None
if self._specs_linking:
self._specs_linking.destroy()
self._specs_linking = None
if self._live_syncing:
self._live_syncing.stop_all_live_sessions()
self._live_syncing.destroy()
self._live_syncing = None
if self._layers_state:
self._layers_state.destroy()
self._layers_state = None
self._usd_context = None
def get_layers_state(self) -> LayersState:
return self._layers_state
def get_specs_locking(self) -> SpecsLocking:
return self._specs_locking
def get_auto_authoring(self) -> AutoAuthoring:
return self._auto_authoring
def get_specs_linking(self) -> SpecsLinking:
return self._specs_linking
def get_live_syncing(self) -> LiveSyncing:
return self._live_syncing
def get_event_stream(self):
return self._layers_instance.get_event_stream()
def get_edit_mode(self) -> LayerEditMode:
return self._layers_instance.get_edit_mode()
def set_edit_mode(self, edit_mode: LayerEditMode):
self._layers_instance.set_edit_mode(edit_mode)
@property
def usd_context(self):
return self._usd_context
| 2,540 | Python | 33.337837 | 94 | 0.629921 |
omniverse-code/kit/exts/omni.kit.usd.layers/omni/kit/usd/layers/impl/extension.py | import carb
import omni.ext
import omni.usd
from typing import List, Union, Dict
from .layers_interface import Layers, LiveSyncing, LayersState, AutoAuthoring
from .._omni_kit_usd_layers import acquire_layers_interface, release_layers_interface, LayerEditMode
from pxr import Sdf, Usd
_all_layers_instances: Dict[omni.usd.UsdContext, Layers] = {}
_layers_interface = None
def get_layers_interface():
global _layers_interface
if not _layers_interface:
_layers_interface = acquire_layers_interface()
return _layers_interface
def get_layers(context_name_or_instance: Union[str, omni.usd.UsdContext] = "") -> Union[Layers, None]:
global _all_layers_instances
if not context_name_or_instance:
context_name_or_instance = ""
if isinstance(context_name_or_instance, str):
usd_context = omni.usd.get_context(context_name_or_instance)
elif isinstance(context_name_or_instance, omni.usd.UsdContext):
usd_context = context_name_or_instance
else:
carb.log_warn("Failed to get layers instance since the param must be name or instance of UsdContext.")
return None
if not usd_context:
carb.log_warn("Failed to query layers instance since UsdContext cannot be found.")
return None
layers_instance = _all_layers_instances.get(usd_context, None)
if not layers_instance:
instance_native = get_layers_interface().get_layers_instance_by_context(usd_context)
if instance_native:
layers_instance = Layers(instance_native, usd_context)
_all_layers_instances[usd_context] = layers_instance
else:
layers_instance = None
carb.log_warn("Failed to query layers instance.")
return layers_instance
def get_auto_authoring(context_name_or_instance: Union[str, omni.usd.UsdContext] = "") -> Union[AutoAuthoring, None]:
layers = get_layers(context_name_or_instance)
if layers:
return layers.get_auto_authoring()
return None
def get_layers_state(context_name_or_instance: Union[str, omni.usd.UsdContext] = "") -> Union[LayersState, None]:
layers = get_layers(context_name_or_instance)
if layers:
return layers.get_layers_state()
return None
def get_live_syncing(context_name_or_instance: Union[str, omni.usd.UsdContext] = "") -> Union[LiveSyncing, None]:
layers = get_layers(context_name_or_instance)
if layers:
return layers.get_live_syncing()
return None
def active_authoring_layer_context(usd_context) -> Usd.EditContext:
"""
Gets the edit context for edit target if it's in non-auto authoring mode,
or edit context for default edit layer if it's in auto authoring mode.
"""
stage = usd_context.get_stage()
layers = get_layers(usd_context)
auto_authoring = layers.get_auto_authoring()
edit_mode = layers.get_edit_mode()
if edit_mode == LayerEditMode.NORMAL:
edit_target_layer = stage.GetEditTarget().GetLayer()
else:
default_edit_layer_identifier = auto_authoring.get_default_layer()
edit_target_layer = Sdf.Find(default_edit_layer_identifier)
if not edit_target_layer:
edit_target_layer = stage.GetRootLayer()
return Usd.EditContext(stage, edit_target_layer)
# Use extension entry points to acquire and release interface.
class Extension(omni.ext.IExt):
def on_startup(self):
# Load layers for default context
get_layers()
def on_shutdown(self):
global _all_layers_instances
for _, instance in _all_layers_instances.items():
instance.destroy()
_all_layers_instances.clear()
global _layers_interface
if _layers_interface:
release_layers_interface(_layers_interface)
| 3,785 | Python | 32.504424 | 117 | 0.684016 |
omniverse-code/kit/exts/omni.kit.usd.layers/omni/kit/usd/layers/impl/__init__.py | from .extension import (
Extension, get_layers,
active_authoring_layer_context,
LayerEditMode, get_auto_authoring,
get_layers_state,
get_live_syncing
)
from .interface_utils import (
get_layer_event_payload, LayerEventPayload,
LayerEventType
)
from .layers_interface import Layers
from .layers_state import LayersState
from .specs_locking import SpecsLocking
from .auto_authoring import AutoAuthoring
from .specs_linking import SpecsLinking
from .live_syncing import LiveSyncing, LiveSession, MESSAGE_USER_NAME_KEY, MESSAGE_SESSION_URL_KEY, MESSAGE_USER_ID_KEY
from .layer_utils import LayerUtils
from .layer_commands import *
from .specs_linking_and_locking_utils import *
| 704 | Python | 31.045453 | 119 | 0.78125 |
omniverse-code/kit/exts/omni.kit.usd.layers/omni/kit/usd/layers/impl/specs_linking_and_locking_utils.py | import carb
from typing import Union, List, Dict
from pxr import Sdf
from .extension import get_layers
def __to_str_list(pathOrPaths: Union[Union[str, Sdf.Path], List[Union[str, Sdf.Path]]]):
paths = []
if pathOrPaths:
if isinstance(pathOrPaths, str) or isinstance(pathOrPaths, Sdf.Path):
paths = [str(pathOrPaths)]
else:
paths = [str(path) for path in pathOrPaths]
return paths
def link_specs(
usd_context,
spec_paths: Union[Union[str, Sdf.Path], List[Union[str, Sdf.Path]]],
layer_identifiers: Union[str, List[str]],
hierarchy=False,
) -> Dict[str, List[str]]:
paths = __to_str_list(spec_paths)
identifiers = __to_str_list(layer_identifiers)
layers = get_layers(usd_context)
if not layers:
carb.log_warn(f"Cannot link specs as corresponding layers instance cannot be found.")
return None
specs_linking = layers.get_specs_linking()
if not specs_linking.is_enabled():
carb.log_warn(f"Cannot link specs as it's not in SPECS_LINKING mode.")
return None
spec_path_to_layers: Dict[str, List[str]] = {}
for path in paths:
for identifier in identifiers:
linked_spec_paths = specs_linking.link_spec(path, identifier, hierarchy)
for spec_path in linked_spec_paths:
if spec_path not in spec_path_to_layers:
spec_path_to_layers[spec_path] = [identifier]
else:
spec_path_to_layers[spec_path].append(identifier)
return spec_path_to_layers
def unlink_specs(
usd_context,
spec_paths: Union[Union[str, Sdf.Path], List[Union[str, Sdf.Path]]],
layer_identifiers: Union[str, List[str]],
hierarchy=False,
) -> Dict[str, List[str]]:
paths = __to_str_list(spec_paths)
identifiers = __to_str_list(layer_identifiers)
layers = get_layers(usd_context)
if not layers:
carb.log_warn(f"Cannot unlink specs as corresponding layers instance cannot be found.")
return None
specs_linking = layers.get_specs_linking()
if not specs_linking.is_enabled():
carb.log_warn(f"Cannot unlink specs as it's not in SPECS_LINKING mode.")
return None
spec_path_to_layers: Dict[str, List[str]] = {}
for path in paths:
for identifier in identifiers:
unlinked_spec_paths = specs_linking.unlink_spec(path, identifier, hierarchy)
for spec_path in unlinked_spec_paths:
if spec_path not in spec_path_to_layers:
spec_path_to_layers[spec_path] = [identifier]
else:
spec_path_to_layers[spec_path].append(identifier)
return spec_path_to_layers
def unlink_specs_to_layers(usd_context, layer_identifiers: Union[str, List[str]]) -> Dict[str, List[str]]:
identifiers = __to_str_list(layer_identifiers)
layers = get_layers(usd_context)
if not layers:
carb.log_warn(f"Cannot unlink specs as corresponding layers instance cannot be found.")
return None
specs_linking = layers.get_specs_linking()
if not specs_linking.is_enabled():
carb.log_warn(f"Cannot unlink specs as it's not in SPECS_LINKING mode.")
return None
layer_to_spec_paths: Dict[str, List[str]] = {}
for identifier in identifiers:
spec_paths = specs_linking.unlink_specs_to_layer(identifier)
layer_to_spec_paths.update(spec_paths)
return layer_to_spec_paths
def unlink_specs_from_all_layers(
usd_context, spec_paths: Union[str, List[str]], hierarchy=False
) -> Dict[str, List[str]]:
paths = __to_str_list(spec_paths)
layers = get_layers(usd_context)
if not layers:
carb.log_warn(f"Cannot unlink specs as corresponding layers instance cannot be found.")
return None
specs_linking = layers.get_specs_linking()
if not specs_linking.is_enabled():
carb.log_warn(f"Cannot unlink specs as it's not in SPECS_LINKING mode.")
return None
spec_path_to_layers: Dict[str, List[str]] = {}
for path in paths:
spec_paths = specs_linking.unlink_spec_from_all_layers(path, hierarchy)
spec_path_to_layers.update(spec_paths)
return spec_path_to_layers
def unlink_all_specs(usd_context):
layers = get_layers(usd_context)
if not layers:
carb.log_warn(f"Cannot unlink specs as corresponding layers instance cannot be found.")
return None
specs_linking = layers.get_specs_linking()
if not specs_linking.is_enabled():
carb.log_warn(f"Cannot unlink specs as it's not in SPECS_LINKING mode.")
return None
specs_linking.unlink_all_specs()
def get_spec_layer_links(
usd_context, spec_paths: Union[Union[str, Sdf.Path], List[Union[str, Sdf.Path]]], hierarchy=False
) -> Dict[str, List[str]]:
paths = __to_str_list(spec_paths)
layers = get_layers(usd_context)
if not layers:
carb.log_warn(f"Cannot get links as corresponding layers instance cannot be found.")
return None
specs_linking = layers.get_specs_linking()
spec_path_to_layers = {}
for path in paths:
spec_path_to_layers.update(specs_linking.get_spec_layer_links(path, hierarchy))
return spec_path_to_layers
def get_spec_links_for_layers(usd_context, layer_identifiers: Union[str, List[str]]) -> Dict[str, List[str]]:
identifiers = __to_str_list(layer_identifiers)
layers = get_layers(usd_context)
if not layers:
carb.log_warn(f"Cannot get links as corresponding layers instance cannot be found.")
return None
specs_linking = layers.get_specs_linking()
layer_to_spec_paths: Dict[str, List[str]] = {}
for layer_identifier in identifiers:
spec_paths = specs_linking.get_spec_links_for_layer(layer_identifier)
if layer_identifier not in layer_to_spec_paths:
layer_to_spec_paths[layer_identifier] = spec_paths
else:
layer_to_spec_paths[layer_identifier].extend(spec_paths)
return layer_to_spec_paths
def get_all_spec_links(usd_context) -> Dict[str, List[str]]:
layers = get_layers(usd_context)
if not layers:
carb.log_warn(f"Cannot get links as corresponding layers instance cannot be found.")
return None
specs_linking = layers.get_specs_linking()
return specs_linking.get_all_spec_links()
def is_spec_linked(usd_context, spec_path: Union[str, Sdf.Path], layer_identifier: str = "") -> bool:
path = __to_str_list(spec_path)
if not path:
return False
layers = get_layers(usd_context)
if not layers:
carb.log_warn(f"Cannot check link state as corresponding layers instance cannot be found.")
return None
specs_linking = layers.get_specs_linking()
return specs_linking.is_spec_linked(path[0], layer_identifier)
def lock_specs(
usd_context, spec_paths: Union[Union[str, Sdf.Path], List[Union[str, Sdf.Path]]], hierarchy=False
) -> List[str]:
paths = __to_str_list(spec_paths)
layers = get_layers(usd_context)
if not layers:
carb.log_warn(f"Cannot lock specs as corresponding layers instance cannot be found.")
return None
locked_spec_paths = []
specs_locking = layers.get_specs_locking()
for path in paths:
locked_spec_paths.extend(specs_locking.lock_spec(path, hierarchy))
return locked_spec_paths
def unlock_specs(usd_context, spec_paths: Union[str, List[str]], hierarchy=False) -> List[str]:
paths = __to_str_list(spec_paths)
layers = get_layers(usd_context)
if not layers:
carb.log_warn(f"Cannot unlock specs as corresponding layers instance cannot be found.")
return None
unlocked_spec_paths = []
specs_locking = layers.get_specs_locking()
for path in paths:
unlocked_spec_paths.extend(specs_locking.unlock_spec(path, hierarchy))
return unlocked_spec_paths
def unlock_all_specs(usd_context):
layers = get_layers(usd_context)
if not layers:
carb.log_warn(f"Cannot unlock specs as corresponding layers instance cannot be found.")
return None
specs_locking = layers.get_specs_locking()
specs_locking.unlock_all_specs()
def get_all_locked_specs(usd_context) -> List[str]:
layers = get_layers(usd_context)
if not layers:
carb.log_warn(f"Cannot get lock states as corresponding layers instance cannot be found.")
return None
specs_locking = layers.get_specs_locking()
return specs_locking.get_all_locked_specs()
def is_spec_locked(usd_context, spec_path: Union[str, Sdf.Path]) -> bool:
path = __to_str_list(spec_path)
if not path:
return False
layers = get_layers(usd_context)
if not layers:
carb.log_warn(f"Cannot check lock state as corresponding layers instance cannot be found.")
return None
specs_locking = layers.get_specs_locking()
return specs_locking.is_spec_locked(path[0])
| 8,965 | Python | 32.084871 | 109 | 0.660234 |
omniverse-code/kit/exts/omni.kit.usd.layers/omni/kit/usd/layers/impl/specs_locking.py | from re import S
import carb.dictionary
from pxr import Sdf
from typing import Union, List
from .._omni_kit_usd_layers import acquire_specs_locking_interface, release_specs_locking_interface, ILayersInstance
class SpecsLocking:
def __init__(self, layers_instance: ILayersInstance, usd_context) -> None:
self._layers_instance = layers_instance
self._usd_context = usd_context
self._specs_locking_interface = acquire_specs_locking_interface()
self._dictionary = carb.dictionary.get_dictionary()
@property
def usd_context(self):
return self._usd_context
def destroy(self):
self._layers_instance = None
release_specs_locking_interface(self._specs_locking_interface)
def _populate_all_paths(self, item: carb.dictionary.Item):
all_locked_spec_paths = []
count = self._dictionary.get_item_child_count(item)
for i in range(count):
spec_path_item = self._dictionary.get_item_child_by_index(item, i)
spec_path = self._dictionary.get_as_string(spec_path_item)
all_locked_spec_paths.append(spec_path)
return all_locked_spec_paths
def lock_spec(self, spec_path: Union[str, Sdf.Path], hierarchy: bool = False) -> List[str]:
item = self._specs_locking_interface.lock_spec(self._layers_instance, str(spec_path), hierarchy)
if not item:
return []
all_locked_spec_paths = self._populate_all_paths(item)
self._dictionary.destroy_item(item)
return all_locked_spec_paths
def unlock_spec(self, spec_path: Union[str, Sdf.Path], hierarchy: bool = False) -> List[str]:
item = self._specs_locking_interface.unlock_spec(self._layers_instance, str(spec_path), hierarchy)
if not item:
return []
all_unlocked_spec_paths = self._populate_all_paths(item)
self._dictionary.destroy_item(item)
return all_unlocked_spec_paths
def unlock_all_specs(self):
self._specs_locking_interface.unlock_all_specs(self._layers_instance)
def get_all_locked_specs(self) -> List[str]:
item = self._specs_locking_interface.get_all_locked_specs(self._layers_instance)
if not item:
return []
all_locked_spec_paths = self._populate_all_paths(item)
self._dictionary.destroy_item(item)
return all_locked_spec_paths
def is_spec_locked(self, spec_path: Union[str, Sdf.Path]) -> bool:
return self._specs_locking_interface.is_spec_locked(self._layers_instance, str(spec_path))
| 2,573 | Python | 36.304347 | 116 | 0.661096 |
omniverse-code/kit/exts/omni.kit.usd.layers/omni/kit/usd/layers/impl/specs_linking.py | from re import S
import carb.dictionary
from pxr import Sdf
from typing import Union, List, Dict
from .._omni_kit_usd_layers import acquire_specs_linking_interface, release_specs_linking_interface, ILayersInstance
class SpecsLinking:
def __init__(self, layers_instance: ILayersInstance, usd_context) -> None:
self._layers_instance = layers_instance
self._usd_context = usd_context
self._specs_linking_interface = acquire_specs_linking_interface()
self._dictionary = carb.dictionary.get_dictionary()
@property
def usd_context(self):
return self._usd_context
def destroy(self):
self._layers_instance = None
release_specs_linking_interface(self._specs_linking_interface)
def _populate_all_paths(self, item: carb.dictionary.Item):
layer_spec_paths = {}
count = self._dictionary.get_item_child_count(item)
for i in range(count):
sub_item = self._dictionary.get_item_child_by_index(item, i)
identifier_item = self._dictionary.get_item(sub_item, "key")
spec_paths_item = self._dictionary.get_item(sub_item, "value")
identifier_or_spec_path = self._dictionary.get_as_string(identifier_item)
value_count = self._dictionary.get_item_child_count(spec_paths_item)
all_paths = []
for j in range(value_count):
spec_path_item = self._dictionary.get_item_child_by_index(spec_paths_item, j)
spec_path = self._dictionary.get_as_string(spec_path_item)
all_paths.append(spec_path)
layer_spec_paths[identifier_or_spec_path] = all_paths
return layer_spec_paths
def is_enabled(self) -> bool:
return self._specs_linking_interface.is_enabled(self._layers_instance)
def link_spec(self, spec_path: Union[str, Sdf.Path], layer_identifier: str, hierarchy: bool = False) -> List[str]:
item = self._specs_linking_interface.link_spec(
self._layers_instance, str(spec_path), layer_identifier, hierarchy
)
if not item:
return []
all_spec_paths = self._populate_all_paths(item)
self._dictionary.destroy_item(item)
return all_spec_paths.get(layer_identifier, [])
def unlink_spec(self, spec_path: Union[str, Sdf.Path], layer_identifier: str, hierarchy: bool = False) -> List[str]:
item = self._specs_linking_interface.unlink_spec(
self._layers_instance, str(spec_path), layer_identifier, hierarchy
)
if not item:
return []
all_spec_paths = self._populate_all_paths(item)
self._dictionary.destroy_item(item)
return all_spec_paths.get(layer_identifier, [])
def unlink_spec_from_all_layers(
self, spec_path: Union[str, Sdf.Path], hierarchy: bool = False
) -> Dict[str, List[str]]:
item = self._specs_linking_interface.unlink_spec_from_all_layers(
self._layers_instance, str(spec_path), hierarchy
)
if not item:
return {}
spec_to_layers = self._populate_all_paths(item)
self._dictionary.destroy_item(item)
return spec_to_layers
def unlink_specs_to_layer(self, layer_identifier: str) -> List[str]:
item = self._specs_linking_interface.unlink_specs_to_layer(self._layers_instance, layer_identifier)
if not item:
return []
all_spec_paths = self._populate_all_paths(item)
self._dictionary.destroy_item(item)
return all_spec_paths.get(layer_identifier, [])
def unlink_all_specs(self):
self._specs_linking_interface.unlink_all_specs(self._layers_instance)
def get_spec_layer_links(self, spec_path: Union[str, Sdf.Path], hierarchy: bool = False):
item = self._specs_linking_interface.get_spec_layer_links(self._layers_instance, str(spec_path), hierarchy)
if not item:
return {}
spec_to_layers = self._populate_all_paths(item)
self._dictionary.destroy_item(item)
return spec_to_layers
def get_spec_links_for_layer(self, layer_identifier: str) -> List[str]:
item = self._specs_linking_interface.get_spec_links_for_layer(self._layers_instance, layer_identifier)
if not item:
return []
result = self._populate_all_paths(item)
self._dictionary.destroy_item(item)
return result.get(layer_identifier, [])
def get_all_spec_links(self):
item = self._specs_linking_interface.get_all_spec_links(self._layers_instance)
if not item:
return {}
spec_to_layers = self._populate_all_paths(item)
self._dictionary.destroy_item(item)
return spec_to_layers
def is_spec_linked(self, spec_path: str, layer_identifier: str = ""):
return self._specs_linking_interface.is_spec_linked(self._layers_instance, spec_path, layer_identifier)
| 4,954 | Python | 37.410852 | 120 | 0.638474 |
omniverse-code/kit/exts/omni.kit.usd.layers/omni/kit/usd/layers/impl/live_session_channel_manager.py | import asyncio
import carb
import omni.kit.collaboration.channel_manager as cm
from typing import Dict, List
from .interface_utils import post_notification
from .._omni_kit_usd_layers import LayerEventType
SESSION_MANAGEMENT_VERSION_KEY = "version"
SESSION_MANAGEMENT_VERSION = "1.0"
MESSAGE_GROUP_KEY = "__SESSION_MANAGEMENT__"
MESSAGE_KEY = "message"
MESSAGE_MERGE_STARTED = "MERGE_STARTED"
MESSAGE_MERGE_FINISHED = "MERGE_FINISHED"
MESSAGE_USER_NAME_KEY = "user_name"
MESSAGE_USER_ID_KEY = "user_id"
MESSAGE_SESSION_URL_KEY = "session_url"
class LiveSessionChannelManager:
def __init__(self, current_session, live_syncing_interface):
self._base_layer_identifier: str = current_session.base_layer_identifier
self._session_url = current_session.url
self._session_name: str = current_session.name
self._channel_url = current_session.channel_url
self._channel: cm.Channel = None
self._channel_subscriber: cm.ChannelSubscriber = None
self._join_channel_future = None
self._live_syncing = live_syncing_interface
self._event_stream = live_syncing_interface._layers_instance.get_event_stream()
def destroy(self):
self._stop_channel()
self._live_syncing = None
self._event_stream = None
def start_async(self):
self._join_channel_future = asyncio.ensure_future(self._join_channel_async(self._channel_url))
return self._join_channel_future
def stop(self):
self._stop_channel()
@property
def stopped(self):
return self._channel and self._channel.stopped
@property
def logged_user_name(self):
return self._channel and self._channel.logged_user_name
@property
def logged_user_id(self):
return self._channel and self._channel.logged_user_id
def _send_layer_event(self, event_type: LayerEventType, payload={}):
payload[MESSAGE_SESSION_URL_KEY] = self._session_url
if payload:
self._event_stream.push(int(event_type), 0, payload)
else:
self._event_stream.push(int(event_type))
@property
def peer_users(self) -> List[cm.PeerUser]:
if self._channel:
return list(self._channel.peer_users.values())
return []
async def broadcast_merge_started_message_async(self):
if self._channel:
message = {
MESSAGE_GROUP_KEY: {
SESSION_MANAGEMENT_VERSION_KEY: SESSION_MANAGEMENT_VERSION,
MESSAGE_KEY: MESSAGE_MERGE_STARTED
}
}
await self._channel.send_message_async(message)
async def broadcast_merge_done_message_async(self):
if self._channel:
message = {
MESSAGE_GROUP_KEY: {
SESSION_MANAGEMENT_VERSION_KEY: SESSION_MANAGEMENT_VERSION,
MESSAGE_KEY: MESSAGE_MERGE_FINISHED
}
}
await self._channel.send_message_async(message)
async def _join_channel_async(self, url):
self._channel = await cm.join_channel_async(url)
if not self._channel:
post_notification(f"Failed to join channel {url}. Stopping session '{self._session_name}'...")
self._live_syncing.stop_live_session(self._base_layer_identifier)
return False
self._channel_subscriber = self._channel.add_subscriber(self._on_channel_message)
return True
def _on_channel_message(self, message: cm.Message):
info = None
from_user = message.from_user
if message.message_type == cm.MessageType.JOIN:
info = f"User {message.from_user.user_name} has joined the session '{self._session_name}'."
self._send_layer_event(
LayerEventType.LIVE_SESSION_USER_JOINED,
{
MESSAGE_USER_NAME_KEY: from_user.user_name,
MESSAGE_USER_ID_KEY: from_user.user_id,
}
)
elif message.message_type == cm.MessageType.LEFT:
info = f"User {message.from_user.user_name} has left the session '{self._session_name}."
self._send_layer_event(
LayerEventType.LIVE_SESSION_USER_LEFT,
{
MESSAGE_USER_NAME_KEY: from_user.user_name,
MESSAGE_USER_ID_KEY: from_user.user_id,
}
)
elif message.message_type == cm.MessageType.HELLO:
info = f"User {message.from_user.user_name} has joined the session '{self._session_name}'."
self._send_layer_event(
LayerEventType.LIVE_SESSION_USER_JOINED,
{
MESSAGE_USER_NAME_KEY: from_user.user_name,
MESSAGE_USER_ID_KEY: from_user.user_id,
}
)
elif message.message_type == cm.MessageType.MESSAGE:
content = message.content.get(MESSAGE_GROUP_KEY, None) or message.content.get(MESSAGE_GROUP_KEY.lower(), None)
if not content or not isinstance(content, dict):
return
message_type = content.get(MESSAGE_KEY, None) or content.get(MESSAGE_KEY.lower(), None)
if not message_type:
return
current_session = self._live_syncing.get_current_live_session(self._base_layer_identifier)
if not current_session:
carb.log_error("Invalid state. Live Session is not started but channel is still alive.")
return
if message_type.lower() == MESSAGE_MERGE_STARTED.lower():
if self._live_syncing.is_live_session_merge_notice_muted(self._base_layer_identifier):
self._live_syncing.stop_live_session(self._base_layer_identifier)
else:
try:
from omni.kit.widget.prompt import PromptButtonInfo, PromptManager
PromptManager.post_simple_prompt(
"Leave Session",
f"`{current_session.owner}' is ending the live session. "
"Stop all work and leave the session.",
PromptButtonInfo(
"LEAVE", lambda: self._live_syncing.stop_live_session(self._base_layer_identifier)
),
shortcut_keys=False
)
except Exception:
carb.log_warn("Cannot post prompt as omni.ui is not enabled, stopping live session forcely.")
self._live_syncing.stop_live_session(self._base_layer_identifier)
else:
return
# Don't explicitly make layers backend dependent on notification manager
if info:
post_notification(info)
carb.log_info(info)
def _stop_channel(self):
if self._channel_subscriber:
self._channel_subscriber.unsubscribe()
self._channel_subscriber = None
if self._channel:
self._channel.stop()
self._channel = None
try:
if self._join_channel_future and not self._join_channel_future.done():
self._join_channel_future.cancel()
except Exception:
pass
| 7,441 | Python | 39.010752 | 122 | 0.58003 |
omniverse-code/kit/exts/omni.kit.usd.layers/omni/kit/usd/layers/impl/live_syncing.py | import asyncio
import weakref
import carb
import carb.dictionary
import omni.kit.app
import omni.kit.collaboration.channel_manager as cm
import time
from typing import List, Callable, Awaitable, Dict
from .layer_utils import LayerUtils
from .interface_utils import get_layer_event_payload, post_notification
from .live_session_channel_manager import (
LiveSessionChannelManager, MESSAGE_SESSION_URL_KEY, MESSAGE_USER_ID_KEY, MESSAGE_USER_NAME_KEY
)
from pxr import Sdf
from .._omni_kit_usd_layers import (
acquire_live_syncing_interface,
release_live_syncing_interface,
ILayersInstance,
LayerEventType
)
class LiveSession:
def __init__(self, handle, session_channel, live_syncing):
self._session_handle = handle
if session_channel:
self._session_channel = weakref.ref(session_channel)
else:
self._session_channel = None
self._live_syncing = weakref.ref(live_syncing)
interface = self._live_syncing()._live_syncing_interface
layers_instance = self._live_syncing()._layers_instance
session_handle = self._session_handle
self._session_url = interface.get_live_session_url(layers_instance, session_handle)
self._session_name = interface.get_live_session_name(layers_instance, session_handle)
self._session_root = interface.get_live_session_root_identifier(layers_instance, session_handle)
self._merge_permission = interface.permission_to_merge_session_changes(layers_instance, session_handle)
self._owner = interface.get_live_session_owner(layers_instance, session_handle)
self._channel_url = interface.get_live_session_channel_url(layers_instance, session_handle)
self._base_layer_identifier = interface.get_live_session_base_layer_identifier(layers_instance, session_handle)
self._logged_user_name = interface.get_logged_in_user_name_for_layer(layers_instance, self._base_layer_identifier)
self._logged_user_id = interface.get_logged_in_user_id_for_layer(layers_instance, self._base_layer_identifier)
@property
def valid(self):
if (
not self._session_handle or
not self._session_channel or
not self._session_channel() or
not self._live_syncing()
):
return False
interface = self._live_syncing()._live_syncing_interface
layers_instance = self._live_syncing()._layers_instance
return interface.is_valid_live_session(layers_instance, self._session_handle)
@property
def channel_url(self):
return self._channel_url
@property
def base_layer_identifier(self):
return self._base_layer_identifier
@property
def name(self):
return self._session_name
@property
def url(self):
return self._session_url
@property
def owner(self):
return self._owner
@property
def merge_permission(self):
return self._merge_permission
@property
def root(self):
return self._session_root
@property
def peer_users(self) -> List[cm.PeerUser]:
if not self.valid:
return []
return list(self._session_channel().peer_users)
@property
def logged_user_name(self):
"""User name that joins this session."""
return self._logged_user_name
@property
def logged_user_id(self):
"""
User id that joins this session. User id can be used to uniquely identify
the user in a live session.
"""
return self._logged_user_id
def __str__(self) -> str:
return f"<root = {self._session_root}, name = {self._session_name}, url = {self._session_url}>"
class LiveSyncing:
def __init__(self, layers_instance: ILayersInstance, usd_context, layers_state) -> None:
self._layers_state = layers_state
self._layers_instance = layers_instance
self._usd_context = usd_context
self._live_syncing_interface = acquire_live_syncing_interface()
self._dictionary = carb.dictionary.get_dictionary()
self._layers_event_sub = self._layers_instance.get_event_stream().create_subscription_to_pop(
self._on_layer_event, name="omni.kit.usd.layers.LiveSyncing"
)
self._update_subscription = omni.kit.app.get_app().get_update_event_stream().create_subscription_to_pop(
self._on_update, name="omni.kit.usd.layers.LiveSyncing Update"
)
self._stage_event_sub = self._usd_context.get_stage_event_stream().create_subscription_to_pop(
self._on_stage_event, name="omni.kit.usd.layers Stage events"
)
self._session_channels = {}
self._merging_live_session = False
self._all_outdated_layers = set([])
self._outdate_notification = None
self._last_outdate_notification_time = 0
self._joining_session = False
self._silent_leave_layers = set([])
@property
def usd_context(self):
return self._usd_context
def _on_stage_event(self, event):
if event.type == int(omni.usd.StageEventType.CLOSING):
self._all_outdated_layers.clear()
self._last_outdate_notification_time = 0
self._silent_leave_layers.clear()
if self._outdate_notification:
self._outdate_notification.dismiss()
self._outdate_notification = None
def _on_update(self, dt):
if self._outdate_notification or not self._all_outdated_layers:
return
now = time.time()
# It will accumulate all changes in 2s.
if now - self._last_outdate_notification_time < 2:
return
self._last_outdate_notification_time = now
try:
import omni.kit.notification_manager as nm
def reload_all_outdated_layers():
outdated_layers, self._all_outdated_layers = self._all_outdated_layers, set([])
for outdate_layer in outdated_layers:
layer = Sdf.Find(outdate_layer)
if layer:
layer.Reload()
self._outdate_notification = None
self._outdate_notification = nm.post_notification(
"Base USD files have been changed, please fetch changes.",
hide_after_timeout=False,
button_infos=[
nm.NotificationButtonInfo("FETCH", on_complete=reload_all_outdated_layers),
nm.NotificationButtonInfo("CANCEL", on_complete=None),
]
)
except Exception:
pass
def _on_layer_event(self, event: carb.events.IEvent):
payload = get_layer_event_payload(event)
if not payload:
return
if payload.event_type == LayerEventType.LIVE_SESSION_STATE_CHANGED:
if self._joining_session or self._merging_live_session:
return
for layer_identifier in payload.identifiers_or_spec_paths:
current_live_session = self.get_current_live_session(layer_identifier)
if not current_live_session:
session_channel = self._session_channels.pop(layer_identifier, None)
if session_channel:
session_channel.destroy()
elif current_live_session and not self._session_channels.get(layer_identifier, None):
session_channel = LiveSessionChannelManager(current_live_session, self)
session_channel.start_async()
self._session_channels[layer_identifier] = session_channel
elif payload.event_type == LayerEventType.OUTDATE_STATE_CHANGED:
if not self._all_outdated_layers:
# Delays the notification
self._last_outdate_notification_time = time.time()
outdated_layer_identifiers = payload.identifiers_or_spec_paths
for layer_identifier in outdated_layer_identifiers:
if self._layers_state.is_layer_outdated(layer_identifier):
self._all_outdated_layers.add(layer_identifier)
else:
self._all_outdated_layers.discard(layer_identifier)
# Dismiss the notification if all layers are not outdated anymore.
if not self._all_outdated_layers and self._outdate_notification:
self._outdate_notification.dismiss()
self._outdate_notification = None
def destroy(self):
self._stage_event_sub = None
self._layers_event_sub = None
self._layers_instance = None
self._outdate_notification = None
self._update_subscription = None
self._layers_state = None
self._silent_leave_layers.clear()
for session_channel in self._session_channels.values():
session_channel.destroy()
self._session_channels.clear()
release_live_syncing_interface(self._live_syncing_interface)
def _to_live_session(self, session_handle, base_layer_identifier):
session_channel = self._session_channels.get(base_layer_identifier, None)
live_session = LiveSession(session_handle, session_channel, self)
return live_session
def get_all_live_sessions(self, layer_identifier: str = None) -> List[LiveSession]:
"""
Gets all existing live sessions for a specific layer.
Args:
layer_identifier (str): Layer identifier. If it's empty, it will be root layer by default.
Returns:
A list of live sessions.
"""
if not self.usd_context.get_stage():
return []
if not layer_identifier:
layer_identifier = self.usd_context.get_stage().GetRootLayer().identifier
total_live_sessions = self._live_syncing_interface.get_total_live_sessions(self._layers_instance, layer_identifier)
all_live_sessions = []
for i in range(total_live_sessions):
session_handle = self._live_syncing_interface.get_live_session_at_index(self._layers_instance, layer_identifier, i)
all_live_sessions.append(self._to_live_session(session_handle, layer_identifier))
return all_live_sessions
def create_live_session(self, name: str, layer_identifier: str = None):
"""
Creates a named live session.
Args:
name (str): Name of the session. Currently, name should be unique across all live sessions.
layer_identifier (str): The sublayer identifier to create live session. If it's not provided,
it will be root layer by default.
"""
if not self.usd_context.get_stage():
return None
# It's to be compatible with old interface. The second param
# of old interface is to enable auto_authoring, which is deprecated for now.
if not layer_identifier or isinstance(layer_identifier, bool):
layer_identifier = self.usd_context.get_stage().GetRootLayer().identifier
session_handle = self._live_syncing_interface.create_live_session(self._layers_instance, layer_identifier, name)
if not session_handle:
return None
live_session = self._to_live_session(session_handle, layer_identifier)
return live_session
def join_live_session(self, live_session: LiveSession):
"""Joins the live session."""
self._joining_session = True
session_handle = live_session._session_handle
success = self._live_syncing_interface.join_live_session(self._layers_instance, session_handle)
self._joining_session = False
if success:
session_channel = LiveSessionChannelManager(live_session, self)
session_channel.start_async()
self._session_channels[live_session.base_layer_identifier] = session_channel
return success
def join_live_session_by_url(self, layer_identifier: str, live_session_url: str, create_if_not_existed: bool=False):
"""
Joins the live session specified by the live session URL.
Args:
layer_identifier (str): The base layer of the live session.
live_session_url (str): The unique URL of the live session. The live session must be created against
with the base layer, otherwise, it will fail to join.
create_if_not_existed (bool): Creates the live session if it's not existed.
"""
self._joining_session = True
success = self._live_syncing_interface.join_live_session_by_url(self._layers_instance, layer_identifier, live_session_url, create_if_not_existed)
self._joining_session = False
if success:
live_session = self.get_current_live_session(layer_identifier)
session_channel = LiveSessionChannelManager(live_session, self)
session_channel.start_async()
self._session_channels[live_session.base_layer_identifier] = session_channel
return success
def stop_live_session(self, layer_identifier: str = None):
"""Stops the live session for specific layer."""
if not self.usd_context.get_stage():
return
if not layer_identifier or isinstance(layer_identifier, bool):
layer_identifier = self.usd_context.get_stage().GetRootLayer().identifier
self._joining_session = True
self._live_syncing_interface.stop_live_session(self._layers_instance, layer_identifier)
self._joining_session = False
session_channel = self._session_channels.pop(layer_identifier, None)
if session_channel:
session_channel.destroy()
def stop_all_live_sessions(self):
"""Stops all the live sessions that are enabled for the current stage."""
self._joining_session = True
self._live_syncing_interface.stop_all_live_sessions(self._layers_instance)
self._joining_session = False
for session_channel in self._session_channels.values():
session_channel.destroy()
self._session_channels.clear()
def is_stage_in_live_session(self):
return self._live_syncing_interface.is_stage_in_live_session(self._layers_instance)
def is_layer_in_live_session(self, layer_identifier):
return self._live_syncing_interface.is_layer_in_live_session(self._layers_instance, layer_identifier)
def is_in_live_session(self):
"""[DEPRECATED] If root layer is in a live session."""
if not self.usd_context.get_stage():
return False
layer_identifier = self.usd_context.get_stage().GetRootLayer().identifier
return self.is_layer_in_live_session(layer_identifier)
def is_live_session_layer(self, layer_identifier: str):
return self._live_syncing_interface.is_live_session_layer(self._layers_instance, layer_identifier)
def get_current_live_session_layers(self, layer_identifier: str = None):
"""
[DEPRECATED] Returns the live session layers attached to this live session of specifc base layer.
"""
current_live_session = self.get_current_live_session(layer_identifier)
if current_live_session:
return [current_live_session.root]
return []
def get_current_live_session_peer_users(self, layer_identifier: str = None) -> List[cm.PeerUser]:
"""
[DEPRECATED] Returns the live session layers attached to this live session of specifc base layer.
Args:
layer_identifier (str): It's root layer if it's not provided.
"""
current_live_session = self.get_current_live_session(layer_identifier)
if current_live_session:
return current_live_session.peer_users
return []
def get_live_session_for_live_layer(self, live_layer_identifier: str):
"""
Gets the live session that the live layer is attached to.
Args:
live_layer_identifier (str): The .live layer that's in the live session.
"""
session_handle = self._live_syncing_interface.get_live_session_for_live_layer(
self._layers_instance, live_layer_identifier
)
if not session_handle:
return None
base_layer_identifier = self._live_syncing_interface.get_live_session_base_layer_identifier(
self._layers_instance, session_handle
)
return self._to_live_session(session_handle, base_layer_identifier)
def get_current_live_session(self, layer_identifier: str = None) -> LiveSession:
"""
Gets the current live session of the base layer joined.
Args:
layer_identifier (str): Base layer identifier. It's root layer if it's not provided.
"""
if not self.usd_context.get_stage():
return None
if not layer_identifier:
layer_identifier = self.usd_context.get_stage().GetRootLayer().identifier
session_handle = self._live_syncing_interface.get_current_live_session(self._layers_instance, layer_identifier)
if not session_handle:
return None
return self._to_live_session(session_handle, layer_identifier)
def get_all_current_live_sessions(self) -> List[LiveSession]:
"""Gets all live sessions that are joined for the current stage."""
layer_identifiers = LayerUtils.get_all_sublayers(self.usd_context.get_stage(), True, True, False)
all_joined_sessions = []
for layer_identifier in layer_identifiers:
if layer_identifier.endswith(".live"):
continue
current_session = self.get_current_live_session(layer_identifier)
if current_session:
all_joined_sessions.append(current_session)
return all_joined_sessions
def get_live_session_by_url(self, session_url) -> LiveSession:
"""
Gets the live session by the url. It can only get the live session belongs to one of the sublayer
in the current stage.
"""
session_handle = self._live_syncing_interface.get_live_session_by_url(self._layers_instance, session_url)
base_layer_identifier = self._live_syncing_interface.get_live_session_base_layer_identifier(
self._layers_instance, session_handle
)
return self._to_live_session(session_handle, base_layer_identifier)
@property
def permission_to_merge_current_session(self, layer_identifier: str = None):
"""
[DEPRECATED] Checkes to see if it can merge the current live session of specified layer.
Args:
layer_identifier (str): It's root layer if it's not provided.
"""
current_session = self.get_current_live_session(layer_identifier)
if not current_session:
return False
return current_session.merge_permission
def merge_live_session_changes(self, layer_identifier: str, stop_session: bool):
return self._live_syncing_interface.merge_live_session_changes(
self._layers_instance, layer_identifier, stop_session
)
def merge_live_session_changes_to_specific_layer(
self, layer_identifier: str,
target_layer_identifier: str,
stop_session: bool, clear_target_layer: bool
):
return self._live_syncing_interface.merge_live_session_changes_to_specific_layer(
self._layers_instance,
layer_identifier,
target_layer_identifier,
stop_session,
clear_target_layer
)
def merge_changes_to_base_layers(self, stop_session: bool):
"""
[DEPRECATED] Merges changes of root layer's live session to its base layer.
"""
if not self.usd_context.get_stage():
return False
layer_identifier = self.usd_context.get_stage().GetRootLayer().identifier
return self.merge_live_session_changes(layer_identifier, stop_session)
def merge_changes_to_specific_layer(self, target_layer_identifier: str, stop_session: bool, clear_target_layer: bool):
"""
[DEPRECATED] Merges changes of root layer's live session to specified layer.
"""
if not self.usd_context.get_stage():
return False
base_layer_identifier = self.usd_context.get_stage().GetRootLayer().identifier
return self.merge_live_session_changes_to_specific_layer(
base_layer_identifier, target_layer_identifier, stop_session, clear_target_layer
)
async def broadcast_merge_started_message_async(self, layer_identifier: str = None):
"""
Broadcasts merge started message to other peer clients. This is normally
called before merging the live session to its base layer.
"""
if not self.usd_context.get_stage():
return
if not layer_identifier:
layer_identifier = self.usd_context.get_stage().GetRootLayer().identifier
session_channel = self._session_channels.get(layer_identifier, None)
if session_channel:
await session_channel.broadcast_merge_started_message_async()
async def broadcast_merge_done_message_async(self, destroy=True, layer_identifier: str = None):
"""
Broadcasts merge finished message to other peer clients. This is normally
called after merging the live session to its base layer.
"Args:
destroy (bool): If it needs to destroy the session channel after merging.
layer_identifier (str): The base layer of the live session.
"""
if not layer_identifier:
layer_identifier = self.usd_context.get_stage().GetRootLayer().identifier
session_channel = self._session_channels.get(layer_identifier, None)
if session_channel:
await session_channel.broadcast_merge_done_message_async()
if destroy:
session_channel.destroy()
self._session_channels.pop(layer_identifier, None)
async def merge_and_stop_live_session_async(
self, target_layer: str = None, comment="",
pre_merge: Callable[[LiveSession], Awaitable] = None,
post_merge: Callable[[bool], Awaitable] = None,
layer_identifier: str = None
):
"""Saves chagnes of live session to their base layer if it's in live mode.
Args:
target_layer (str): Target layer to merge all live changes to.
comment (str): The checkpoint comments.
pre_merge (Callable[[LiveSession], Awaitable]): It will be called before merge.
post_merge (Callable[[bool, str], Awaitable]): It will be called after merge is done. The first
param means if it's successful, and the second includes
the error message if it's not.
layer_identifier (str): The base layer of the live session. It's root layer if it's not provided.
"""
if not self.usd_context.get_stage():
return False
if not layer_identifier:
layer_identifier = self.usd_context.get_stage().GetRootLayer().identifier
current_session = self.get_current_live_session(layer_identifier)
if pre_merge:
await pre_merge(current_session)
error = None
success = True
try:
import omni.usd_resolver
if not self.is_layer_in_live_session(layer_identifier):
error = "Cannot merge live layers since it's not in live session."
success = False
return False
if not current_session.merge_permission:
error = f"Cannot merge live layers since only owner {current_session.owner} can merge them."
success = False
return False
if self._merging_live_session:
error = "Current session is already in progress of merging."
success = False
return False
self._merging_live_session = True
def report_checkpoint_errors(failed_layers):
nonlocal error
nonlocal success
success = False
if len(failed_layers) == 1:
error = f"Failed to create checkpoints for {failed_layers[0]}."
elif len(failed_layers) > 1:
error = "Failed to create checkpoints for several layers. Please check console for more details."
all_live_layers = [current_session.root]
_, failed_layers = await LayerUtils.create_checkpoint_async(all_live_layers, comment, True)
if failed_layers:
report_checkpoint_errors(failed_layers)
return False
comment = f"Merge changes from live {current_session.name}: {comment}"
omni.usd_resolver.set_checkpoint_message(comment)
# Clear checkpoint message to ensure comment is not used in future file operations.
if not target_layer:
success = self.merge_live_session_changes(layer_identifier, True)
if success:
dirty_layers = LayerUtils.get_dirty_layers(self.usd_context.get_stage(), True, True)
self._save_layers(dirty_layers)
else:
layer = Sdf.Find(target_layer)
success = self.merge_live_session_changes_to_specific_layer(layer_identifier, target_layer, True, True)
# It means it's existing layer, create a checkpoint firstly then save.
if layer and success:
self._save_layers([target_layer])
if not success:
error = "Failed to merge live changes due to permission issues."
finally:
omni.usd_resolver.set_checkpoint_message("")
if not success:
carb.log_error(error)
post_notification(error, False)
if post_merge:
await post_merge(success)
if not self.is_layer_in_live_session(layer_identifier):
session_channel = self._session_channels.pop(layer_identifier, None)
if session_channel:
session_channel.destroy()
self._merging_live_session = False
return success
def mute_live_session_merge_notice(self, layer_identifier):
"""
By default, when session owner merges the session, it will
notify peer clients to leave the session by showing a prompt.
This is used to disable the prompt and stop session directly
so it will not be disruptive especially for applications that
don't have layer window and manages all sublayer live sessions
with scripting and don't want to receive prompt for sublayer sessions.
"""
self._silent_leave_layers.add(layer_identifier)
def unmute_live_session_merge_notice(self, layer_identifier):
self._silent_leave_layers.discard(layer_identifier)
def is_live_session_merge_notice_muted(self, layer_identifier):
return layer_identifier in self._silent_leave_layers
def _save_layers(self, layer_identifiers):
success = True
for layer_identifier in layer_identifiers:
layer = Sdf.Find(layer_identifier)
if not layer:
carb.log_error(f"Failed to save layer {layer_identifier} as it cannot be found.")
continue
if not layer.Save():
carb.log_error(f"Failed to save layer {layer_identifier} because of permission issue.")
success = False
return success
| 28,500 | Python | 39.599715 | 153 | 0.616211 |
omniverse-code/kit/exts/omni.kit.usd.layers/omni/kit/usd/layers/impl/layer_utils.py | import asyncio
import os
import carb
import omni
import omni.client
from .path_utils import PathUtils
from pxr import Sdf, Usd, UsdUtils
from typing import List, Set, Union
class LayerUtils:
LAYER_OMNI_CUSTOM_KEY = "omni_layer"
LAYER_MUTENESS_CUSTOM_KEY = "muteness"
LAYER_LOCK_STATUS_CUSTOM_KEY = "locked"
LAYER_NAME_CUSTOM_KEY = "custom_name"
LAYER_AUTHORING_LAYER_CUSTOM_KEY = "authoring_layer"
@staticmethod
def create_sublayer(layer: Sdf.Layer, sublayer_position: int, layer_identifier: str):
"""Creates new sublayer at specific position.
Args:
layer (Sdf.Layer): Layer handle.
sublayer_position: Position to create the new layer.
Position should be -1 (the last position) or above 0.
If position == -1 or position > len(layer.subLayerPaths), it will create the sublayer at the end.
Any other position will be treated as invalid index.
layer_identifier: New layer path. If it's empty or None, it will create anonymous layer.
Return:
New sublayer handle or None if sublayer_position is not valid.
"""
if sublayer_position != -1 and sublayer_position < 0:
return None
if sublayer_position > len(layer.subLayerPaths) or sublayer_position == -1:
sublayer_position = len(layer.subLayerPaths)
if layer_identifier:
new_layer = Sdf.Layer.FindOrOpen(layer_identifier)
if new_layer:
new_layer.Clear()
else:
new_layer = Sdf.Layer.CreateNew(layer_identifier)
else:
new_layer = Sdf.Layer.CreateAnonymous()
if new_layer:
relative_path = PathUtils.compute_relative_path(layer.identifier, new_layer.identifier)
layer.subLayerPaths.insert(sublayer_position, relative_path)
return new_layer
@staticmethod
def insert_sublayer(layer: Sdf.Layer, sublayer_position: int, layer_identifier: str, check_empty_layer=True):
"""Inserts new sublayer at specific position.
Args:
layer (Sdf.Layer): Layer handle.
sublayer_position: Position to insert the new layer.
Position should be -1 (the last position) or above 0.
If position == -1 or position > len(layer.subLayerPaths), it will insert the sublayer at the end.
Any other position will be treated as invalid index.
layer_identifier: New layer path.
Return:
Sublayer handle or None if sublayer_position is not valid or layer_identifier is empty or inserted layer is not existed.
"""
if sublayer_position != -1 and sublayer_position < 0:
return None
if sublayer_position > len(layer.subLayerPaths) or sublayer_position == -1:
sublayer_position = len(layer.subLayerPaths)
new_layer = Sdf.Layer.FindOrOpen(layer_identifier)
if new_layer:
relative_path = PathUtils.compute_relative_path(layer.identifier, new_layer.identifier)
layer.subLayerPaths.insert(sublayer_position, relative_path)
else:
carb.log_error(f"Failed to insert sublayer {layer_identifier} since it cannot be opened.")
return new_layer
@staticmethod
def replace_sublayer(layer: Sdf.Layer, sublayer_position: int, layer_identifier: str):
"""Replaces new sublayer at specific position.
Args:
layer (Sdf.Layer): Layer handle.
sublayer_position: Position to insert the new layer.
Position should be less than len(layer.subLayerPaths).
Any other position will be treated as invalid index.
layer_identifier: New layer path.
Return:
Sublayer handle or None if sublayer_position is not valid or layer_identifier is empty or replaced layer is not existed.
"""
if sublayer_position < 0 or sublayer_position >= len(layer.subLayerPaths):
return None
new_layer = Sdf.Layer.FindOrOpen(layer_identifier)
if new_layer:
relative_path = PathUtils.compute_relative_path(layer.identifier, new_layer.identifier)
layer.subLayerPaths[sublayer_position] = relative_path
else:
carb.log_error(f"Failed to replace sublayer with {layer_identifier} since it cannot be opened.")
return new_layer
@staticmethod
def get_custom_layer_name(layer: Sdf.Layer):
"""Gets the custom name of layer. This name is saved inside the custom data of layer."""
custom_data = layer.customLayerData
name = None
if LayerUtils.LAYER_OMNI_CUSTOM_KEY in custom_data:
omni_data = custom_data[LayerUtils.LAYER_OMNI_CUSTOM_KEY]
if LayerUtils.LAYER_NAME_CUSTOM_KEY in omni_data:
name = omni_data[LayerUtils.LAYER_NAME_CUSTOM_KEY]
if not name:
name = os.path.basename(layer.identifier)
return name
@staticmethod
def set_custom_layer_name(layer: Sdf.Layer, name: str):
"""Sets the custom name of layer. This name is saved insdie the custom data of layer."""
if name:
custom_data = layer.customLayerData
if LayerUtils.LAYER_OMNI_CUSTOM_KEY not in custom_data:
custom_data[LayerUtils.LAYER_OMNI_CUSTOM_KEY] = {}
omni_data = custom_data[LayerUtils.LAYER_OMNI_CUSTOM_KEY]
omni_data[LayerUtils.LAYER_NAME_CUSTOM_KEY] = name
custom_data[LayerUtils.LAYER_OMNI_CUSTOM_KEY] = omni_data
layer.customLayerData = custom_data
@staticmethod
def transfer_layer_content(
source_layer: Sdf.Layer, target_layer: Sdf.Layer, copy_custom_data=True, skip_sublayers=True
):
for root_prim in source_layer.rootPrims:
Sdf.CopySpec(source_layer, root_prim.path, target_layer, root_prim.path)
if copy_custom_data:
UsdUtils.CopyLayerMetadata(source_layer, target_layer, skip_sublayers)
LayerUtils.resolve_paths(source_layer, target_layer)
@staticmethod
def resolve_paths(
base_layer: Sdf.Layer,
target_layer: Sdf.Layer,
store_relative_path=True,
relative_to_base_layer=False,
copy_sublayer_offsets=False,
):
"""Resolve all paths from References, Sublayers and AssetPaths of target layer based on source layer.
This function is used normally when you transfer the content from source layer to target layer that
are not in the same directory. So it needs to resolve all references so that they point to correct
location.
Args:
base_layer (Sdf.Layer): Source layer that references in target layer based on.
target_layer (Sdf.Layer): Target layer to resolve.
store_relative_path (bool): True to store relative path, or False to store absolute path.
if relative path cannot be computed (like source layer and
target are not in the same domain), it will save absolute paths.
relative_to_base_layer (bool): True if the relative path is computed against the target_layer.
False otherwise.
copy_sublayer_offsets (bool): True to copy sublayer offsets and scales from base to target.
"""
omni.usd.resolve_paths(
base_layer.identifier,
target_layer.identifier,
store_relative_path,
relative_to_base_layer,
copy_sublayer_offsets,
)
@staticmethod
def get_sublayer_position_in_parent(parent_layer_identifier, layer_identifier):
parent_layer = Sdf.Find(parent_layer_identifier)
if not parent_layer:
return -1
sublayer_paths = parent_layer.subLayerPaths
layer_identifier = parent_layer.ComputeAbsolutePath(layer_identifier)
for i in range(len(sublayer_paths)):
sublayer_path = sublayer_paths[i]
sublayer_identifier = parent_layer.ComputeAbsolutePath(sublayer_path)
if sublayer_identifier == layer_identifier:
return i
return -1
@staticmethod
def has_prim_spec(layer_identifier: str, prim_spec_path):
layer = Sdf.Find(layer_identifier)
if not layer:
return False
prim_spec = layer.GetPrimAtPath(prim_spec_path)
return not not prim_spec
@staticmethod
def get_sublayer_identifier(layer_identifier: str, sublayer_position: int):
parent_layer = Sdf.Find(layer_identifier)
if not parent_layer:
return None
sublayer_paths = parent_layer.subLayerPaths
if len(sublayer_paths) == 0:
return None
if sublayer_position >= len(sublayer_paths) or (sublayer_position != -1 and sublayer_position < 0):
return None
sublayer_identifier = parent_layer.ComputeAbsolutePath(sublayer_paths[sublayer_position])
return sublayer_identifier
@staticmethod
def restore_authoring_layer_from_custom_data(stage):
root_layer = stage.GetRootLayer()
try:
# OM-57080: it will through exception if meta includes invalid fields.
custom_data = root_layer.customLayerData
if LayerUtils.LAYER_OMNI_CUSTOM_KEY in custom_data:
omni_data = custom_data[LayerUtils.LAYER_OMNI_CUSTOM_KEY]
if LayerUtils.LAYER_AUTHORING_LAYER_CUSTOM_KEY in omni_data:
authoring_layer = omni_data[LayerUtils.LAYER_AUTHORING_LAYER_CUSTOM_KEY]
authoring_layer = root_layer.ComputeAbsolutePath(authoring_layer)
for layer in stage.GetLayerStack():
if layer.identifier == authoring_layer:
edit_target = Usd.EditTarget(layer)
stage.SetEditTarget(edit_target)
return
except Exception as e:
carb.log_error(f"Failed to restore authoring layer from custom data: {str(e)}.")
return
@staticmethod
def save_authoring_layer_to_custom_data(stage):
edit_target = stage.GetEditTarget()
if edit_target.GetLayer() and edit_target.GetLayer().anonymous:
return
root_layer = stage.GetRootLayer()
custom_data = root_layer.customLayerData
if LayerUtils.LAYER_OMNI_CUSTOM_KEY not in custom_data:
custom_data[LayerUtils.LAYER_OMNI_CUSTOM_KEY] = {}
omni_data = custom_data[LayerUtils.LAYER_OMNI_CUSTOM_KEY]
authoring_layer = edit_target.GetLayer().identifier
authoring_layer = PathUtils.compute_relative_path(root_layer.identifier, authoring_layer)
omni_data[LayerUtils.LAYER_AUTHORING_LAYER_CUSTOM_KEY] = authoring_layer
custom_data[LayerUtils.LAYER_OMNI_CUSTOM_KEY] = omni_data
root_layer.customLayerData = custom_data
@staticmethod
def _get_layer_custom_data_value(root_layer: Sdf.Layer, layer_identifier: str, key: str, default_value=None):
custom_data = root_layer.customLayerData
if LayerUtils.LAYER_OMNI_CUSTOM_KEY in custom_data:
omni_data = custom_data[LayerUtils.LAYER_OMNI_CUSTOM_KEY]
if key in omni_data:
data = omni_data[key]
layer_identifier = omni.client.normalize_url(layer_identifier)
for relatvie_path, value in data.items():
absolute_path = root_layer.ComputeAbsolutePath(relatvie_path)
if layer_identifier == absolute_path:
return value
return default_value
@staticmethod
def _set_layer_custom_data_value(root_layer: Sdf.Layer, layer_identifier: str, key: str, value):
if not layer_identifier:
return
custom_data = root_layer.customLayerData
if LayerUtils.LAYER_OMNI_CUSTOM_KEY not in custom_data:
custom_data[LayerUtils.LAYER_OMNI_CUSTOM_KEY] = {}
omni_data = custom_data[LayerUtils.LAYER_OMNI_CUSTOM_KEY]
relative_path = PathUtils.compute_relative_path(root_layer.identifier, layer_identifier)
if key in omni_data:
found = False
layer_identifier = omni.client.normalize_url(layer_identifier)
for path, _ in omni_data[key].items():
absolute_path = root_layer.ComputeAbsolutePath(path)
if layer_identifier == absolute_path:
omni_data[key][path] = value
found = True
break
if not found:
omni_data[key][relative_path] = value
else:
omni_data[key] = {relative_path: value}
custom_data[LayerUtils.LAYER_OMNI_CUSTOM_KEY] = omni_data
root_layer.customLayerData = custom_data
@staticmethod
def _remove_layer_custom_data_by_key(root_layer: Sdf.Layer, layer_identifier: str, key: str):
if not layer_identifier:
return
custom_data = root_layer.customLayerData
if LayerUtils.LAYER_OMNI_CUSTOM_KEY in custom_data:
omni_data = custom_data[LayerUtils.LAYER_OMNI_CUSTOM_KEY]
if key in omni_data:
data = omni_data[key]
layer_identifier = omni.client.normalize_url(layer_identifier)
for path, _ in data.items():
absolute_path = root_layer.ComputeAbsolutePath(path)
if layer_identifier == absolute_path:
del data[path]
omni_data[key] = data
custom_data[LayerUtils.LAYER_OMNI_CUSTOM_KEY] = omni_data
root_layer.customLayerData = custom_data
break
@staticmethod
def get_layer_global_muteness(root_layer: Sdf.Layer, layer_identifier: str):
return LayerUtils._get_layer_custom_data_value(
root_layer, layer_identifier, LayerUtils.LAYER_MUTENESS_CUSTOM_KEY, False
)
@staticmethod
def set_layer_global_muteness(root_layer: Sdf.Layer, layer_identifier: str, muted: bool):
return LayerUtils._set_layer_custom_data_value(
root_layer, layer_identifier, LayerUtils.LAYER_MUTENESS_CUSTOM_KEY, muted
)
@staticmethod
def remove_layer_global_muteness(root_layer: Sdf.Layer, layer_identifier: str):
return LayerUtils._remove_layer_custom_data_by_key(
root_layer, layer_identifier, LayerUtils.LAYER_MUTENESS_CUSTOM_KEY
)
@staticmethod
def get_layer_lock_status(root_layer: Sdf.Layer, layer_identifier: str):
return LayerUtils._get_layer_custom_data_value(
root_layer, layer_identifier, LayerUtils.LAYER_LOCK_STATUS_CUSTOM_KEY, False
)
@staticmethod
def set_layer_lock_status(root_layer: Sdf.Layer, layer_identifier: str, locked: bool):
if root_layer.identifier == layer_identifier:
return
LayerUtils._set_layer_custom_data_value(
root_layer, layer_identifier, LayerUtils.LAYER_LOCK_STATUS_CUSTOM_KEY, locked
)
@staticmethod
def remove_layer_lock_status(root_layer: Sdf.Layer, layer_identifier: str):
return LayerUtils._remove_layer_custom_data_by_key(
root_layer, layer_identifier, LayerUtils.LAYER_LOCK_STATUS_CUSTOM_KEY
)
@staticmethod
def restore_muteness_from_custom_data(stage):
muted_layer_identifiers = []
unmuted_layer_identifiers = []
sublayers = LayerUtils.get_all_sublayers(stage)
for sublayer_identifier in sublayers:
if LayerUtils.get_layer_global_muteness(stage.GetRootLayer(), sublayer_identifier):
muted_layer_identifiers.append(sublayer_identifier)
else:
unmuted_layer_identifiers.append(sublayer_identifier)
stage.MuteAndUnmuteLayers(muted_layer_identifiers, unmuted_layer_identifiers)
@staticmethod
def remove_sublayer(layer: Sdf.Layer, position):
if len(layer.subLayerPaths) == 0:
return None
if position < -1 or position >= len(layer.subLayerPaths):
return None
layer_identifier = layer.ComputeAbsolutePath(layer.subLayerPaths[position])
del layer.subLayerPaths[position]
return layer_identifier
@staticmethod
def is_read_only_prim(prim):
if not prim.IsValid():
return False
no_delete = prim.GetMetadata("no_delete")
if no_delete is not None and no_delete is True:
return True
return False
@staticmethod
def remove_prim_spec(layer: Sdf.Layer, prim_spec_path: str):
"""Removes prim spec from layer."""
prim_spec = layer.GetPrimAtPath(prim_spec_path)
if not prim_spec:
return False
if prim_spec.nameParent:
name_parent = prim_spec.nameParent
else:
name_parent = layer.pseudoRoot
if not name_parent:
return False
name = prim_spec.name
if name in name_parent.nameChildren:
del name_parent.nameChildren[name]
return True
@staticmethod
def move_layer(
from_parent_layer_identifier,
from_sublayer_position,
to_parent_layer_identifier,
to_sublayer_position,
remove_source=False,
):
"""Move sublayer from source parent to position of target parent.
Args:
from_parent_layer_identifier: The parent of source sublayer.
from_sublayer_position: The sublayer position to be moved.
to_parent_layer_identifier: The parent of target sublayer.
to_sublayer_position: The sublayer position in target parent that source moves to.
remove_source: Removes the source sublayer or not from source parent after move.
If from_parent_layer_identifier == to_parent_layer_layer_identifier,
it will always be True.
Return:
True if it's successful, False otherwise,
"""
if (
from_parent_layer_identifier == to_parent_layer_identifier
and from_sublayer_position == to_sublayer_position
):
return True
from_parent_layer = Sdf.Find(from_parent_layer_identifier)
to_parent_layer = Sdf.Find(to_parent_layer_identifier)
if not from_parent_layer or not to_parent_layer:
carb.log_warn(
f"Move layer failed as layer {from_parent_layer_identifier} or {to_parent_layer_identifier} cannot be found."
)
return False
if len(from_parent_layer.subLayerPaths) == 0:
carb.log_warn(
f"Failed to move layer at position {from_sublayer_position} of parent {from_parent_layer_identifier}"
f" as parent has no sublayers."
)
return False
if (
from_sublayer_position >= len(from_parent_layer.subLayerPaths)
or from_sublayer_position < 0
or (to_sublayer_position != -1 and to_sublayer_position < 0)
):
carb.log_warn(
f"Failed to move layer at position {from_sublayer_position} of parent {from_parent_layer_identifier} to"
f" layer at position {to_sublayer_position} of parent {to_parent_layer_identifier}"
)
return False
src_sublayer_paths = from_parent_layer.subLayerPaths
sublayer_path = src_sublayer_paths[from_sublayer_position]
sublayer_path = from_parent_layer.ComputeAbsolutePath(sublayer_path)
# Holds sublayer to avoid it to be released during delete/insert.
sublayer = LayerUtils.find_layer(sublayer_path)
if remove_source:
del src_sublayer_paths[from_sublayer_position]
# Source layer is not in target parent or they are in the same parent
target_position = LayerUtils.get_sublayer_position_in_parent(to_parent_layer_identifier, sublayer_path)
if target_position == -1:
sublayer_path = PathUtils.compute_relative_path(to_parent_layer_identifier, sublayer_path)
dst_sublayer_paths = to_parent_layer.subLayerPaths
if to_sublayer_position > len(dst_sublayer_paths) or to_sublayer_position == -1:
to_sublayer_position = len(dst_sublayer_paths)
dst_sublayer_paths.insert(to_sublayer_position, sublayer_path)
return True
@staticmethod
def get_edit_target(stage) -> str:
return omni.usd.get_edit_target_identifier(stage)
@staticmethod
def set_edit_target(stage, layer_identifier):
return omni.usd.set_edit_target_by_identifier(stage, layer_identifier)
@staticmethod
def get_all_sublayers(stage, include_session_layers=False, include_only_omni_layers=False, include_anonymous_layers=True) -> List[str]:
return omni.usd.get_all_sublayers(stage, include_session_layers, include_only_omni_layers, include_anonymous_layers)
@staticmethod
def is_layer_writable(layer_identifier) -> bool:
if Sdf.Layer.IsAnonymousLayerIdentifier(layer_identifier):
return True
if not omni.usd.is_usd_writable_filetype(layer_identifier):
return False
return omni.usd.is_layer_writable(layer_identifier)
@staticmethod
def get_dirty_layers(stage, include_root_layer=True, include_only_omni_layers=False) -> List[str]:
dirty_layers = []
root_layer_identifier = stage.GetRootLayer().identifier
all_sublayer_identifiers = LayerUtils.get_all_sublayers(stage, True, include_only_omni_layers, False)
for sublayer_identifier in all_sublayer_identifiers:
if not include_root_layer and sublayer_identifier == root_layer_identifier:
continue
if sublayer_identifier.endswith('.live'):
continue
layer = Sdf.Find(sublayer_identifier)
if layer and layer.dirty:
dirty_layers.append(sublayer_identifier)
return dirty_layers
@staticmethod
def find_layer(layer_identifier):
try:
if Sdf.Layer.IsAnonymousLayerIdentifier(layer_identifier):
return Sdf.Find(layer_identifier)
else:
return Sdf.Layer.FindOrOpen(layer_identifier)
except Exception:
return None
@staticmethod
def get_all_layers_existence(stage):
layer_existence_map = {}
accessed_layers = []
layer_queue = [stage.GetRootLayer().identifier]
while len(layer_queue) > 0:
layer_path = layer_queue.pop(0)
reference_layer = LayerUtils.find_layer(layer_path)
accessed_layers.append(layer_path)
if not reference_layer:
layer_existence_map[layer_path] = False
else:
layer_existence_map[layer_path] = True
for reference in reference_layer.externalReferences:
if len(reference) > 0:
absolute_path = reference_layer.ComputeAbsolutePath(reference)
if absolute_path not in accessed_layers:
layer_queue.append(absolute_path)
return layer_existence_map
@staticmethod
def get_layer_version(layer_identifier: str) -> str:
if PathUtils.is_omni_path(layer_identifier):
(result, entry) = omni.client.stat(layer_identifier)
if result == omni.client.Result.OK:
return entry.version
return ""
# TODO Move version related code out
@staticmethod
def _is_versioning_enabled():
try:
import omni.kit.widget.versioning
enable_versioning = True
except Exception:
enable_versioning = False
return enable_versioning
@staticmethod
async def create_checkpoint_async(layer_identifier: Union[str, List[str]], comment: str, force=False):
if not LayerUtils._is_versioning_enabled():
return
if isinstance(layer_identifier, list):
identifiers = layer_identifier
else:
identifiers = [layer_identifier]
success_layers = []
failed_layers = []
async def check_server_support_and_create_checkpoint(identifier):
result, server_info = await omni.client.get_server_info_async(identifier)
if result == omni.client.Result.OK and server_info and server_info.checkpoints_enabled:
result, _ = await omni.client.create_checkpoint_async(identifier, comment, force)
if result == omni.client.Result.OK or result == omni.client.Result.ERROR_ALREADY_EXISTS:
success_layers.append(identifier)
else:
failed_layers.append(identifier)
carb.log_error(f"Failed to create checkpoint for layer {identifier}: {result}.")
all_futures = []
for identifier in identifiers:
all_futures.append(asyncio.ensure_future(check_server_support_and_create_checkpoint(identifier)))
await asyncio.wait(all_futures)
return success_layers, failed_layers
@staticmethod
def create_checkpoint(layer_identifier: Union[str, List[str]], comment: str, force=False):
asyncio.ensure_future(LayerUtils.create_checkpoint_async(layer_identifier, comment, force))
@staticmethod
async def create_checkpoint_for_stage_async(stage, comment: str, only_dirty_layers=False, force=False):
if only_dirty_layers:
all_layers = LayerUtils.get_dirty_layers(stage, True)
else:
all_layers = LayerUtils.get_all_sublayers(stage, False, True, False)
return await LayerUtils.create_checkpoint_async(all_layers, comment, force)
| 26,301 | Python | 40.355346 | 139 | 0.624767 |
omniverse-code/kit/exts/omni.kit.usd.layers/omni/kit/usd/layers/impl/path_utils.py | import re
import traceback
import carb
import omni.client
from pxr import Sdf, Usd
class PathUtils:
@staticmethod
def is_omni_path(path: str):
return path.startswith("omniverse://")
@staticmethod
def compute_absolute_path(base_path, path):
"""Computes absolute path.
Args:
base_path (str): Absolute path that path will be based on.
path (str): Path to be combined.
"""
if Sdf.Layer.IsAnonymousLayerIdentifier(path) or Sdf.Layer.IsAnonymousLayerIdentifier(base_path):
return omni.client.normalize_url(path)
# If it's old path without server, it needs to strip omni prefix
if not path.startswith("omni://") and path.startswith("omni:/"):
path = path[5:]
return omni.client.combine_urls(base_path, path)
@staticmethod
def compute_relative_path(base_path, file_path):
"""Computes relative path given base path.
Args:
base_path (str): Absolute path that file path will be relative to.
file_path (str): Absolute path.
Return:
Relative path of file_path that is relative to base_path. If base_path
and file_path are not in the same domain or server, it will return file_path
directly.
"""
if Sdf.Layer.IsAnonymousLayerIdentifier(file_path) or Sdf.Layer.IsAnonymousLayerIdentifier(base_path):
return omni.client.normalize_url(file_path)
return omni.client.make_relative_url(base_path, file_path)
@staticmethod
async def exists_async(path):
try:
result, _ = await omni.client.stat_async(path)
return result == omni.client.Result.OK
except Exception as e:
traceback.print_exc()
carb.log_error(str(e))
return False
@staticmethod
def exists_sync(path):
try:
result, _ = omni.client.stat(path)
return result == omni.client.Result.OK
except Exception as e:
traceback.print_exc()
carb.log_error(str(e))
return False
| 2,154 | Python | 30.691176 | 110 | 0.608635 |
omniverse-code/kit/exts/omni.kit.usd.layers/omni/kit/usd/layers/impl/auto_authoring.py | from .._omni_kit_usd_layers import acquire_auto_authoring_interface, release_auto_authoring_interface, ILayersInstance
class AutoAuthoring:
def __init__(self, layers_instance: ILayersInstance, usd_context) -> None:
self._layers_instance = layers_instance
self._usd_context = usd_context
self._auto_authoring_interface = acquire_auto_authoring_interface()
@property
def usd_context(self):
return self._usd_context
def destroy(self):
self._layers_instance = None
release_auto_authoring_interface(self._auto_authoring_interface)
def is_enabled(self) -> bool:
return self._auto_authoring_interface.is_enabled(self._layers_instance)
def set_default_layer(self, layer_identifier: str):
self._auto_authoring_interface.set_default_layer(self._layers_instance, layer_identifier)
def get_default_layer(self) -> str:
return self._auto_authoring_interface.get_default_layer(self._layers_instance)
def is_auto_authoring_layer(self, layer_identifier: str) -> bool:
return self._auto_authoring_interface.is_auto_authoring_layer(self._layers_instance, layer_identifier)
| 1,182 | Python | 39.793102 | 118 | 0.70643 |
omniverse-code/kit/exts/omni.kit.usd.layers/docs/CHANGELOG.md | # Changelog
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
## [2.0.11] - 2023-02-16
- Only copy interested layer meta into live layer when it's in a live session.
## [2.0.10] - 2022-11-30
- Fix permission issue for sublayer live session if root layer is anonymous.
## [2.0.9] - 2022-11-09
- Fix flaky specs_locking test
- Fix unreliable tests for specs locking.
## [2.0.8] - 2022-11-02
- Add API for fetching logged-in user and id for layer.
- New events before/after merging live session.
## [2.0.7] - 2022-10-28
- Fix issue that session creates with different DNS alias cannot be found.
## [2.0.6] - 2022-10-27
- Fix UI issue that can show two sublayers as edit target.
## [2.0.5] - 2022-10-21
- Fix regression to merge live session to new layer.
## [2.0.4] - 2022-10-20
- Fix live session list refresh issue created by other connectors.
## [2.0.3] - 2022-10-15
- Fix issue to parse payload of LIVE_SESSION_LIST_CHANGED event.
## [2.0.2] - 2022-10-12
- Fix join live session by url that returns invalid session pointer.
## [2.0.1] - 2022-10-05
- Fix crash if a session is joined and it's removed from disk.
- Fix edit target switch issue after joining live session.
- Notification to remind saved session inside opened stage.
## [2.0.0] - 2022-09-29
- Re-work omni.kit.usd.layers to support sublayer live sesison.
## [1.1.8] - 2022-09-20
- Fix layer refresh if layer stack includes duplicate sublayer.
- Fix crash to switch muteness scope.
## [1.1.7] - 2022-09-13
- Ignore case for comparing session management message.
- Synchronize layer meta between root and live root layer in live session.
## [1.1.6] - 2022-08-09
- Fix layer version refresh
## [1.1.5] - 2022-08-05
- Add version safeguard for TOML file.
## [1.1.4] - 2022-07-25
- Fix duplicate outdate notification.
- Move outdate notification from layer view into this extension.
## [1.1.3] - 2022-07-20
- Add API to support link live layer to specific base layer for supporting projec workflow of other connectors.
## [1.1.2] - 2022-07-11
- Fix merge_changes_to_specific_layer and add tests.
## [1.1.1] - 2022-06-15
- Move channel management into this extension from layers view.
## [1.1.0] - 2022-05-31
- Supports new live workflow.
## [1.0.0] - 2022-03-31
- Initial extension.
- Refactoring omni.usd to move layers interface to this extension.
| 2,364 | Markdown | 28.936708 | 111 | 0.706853 |
omniverse-code/kit/exts/omni.kit.usd.layers/docs/README.md | # Omniverse Layers Extended Interfaces and Workflows
Extension omni.kit.usd.layers works to extend the USD to provide utilities and workflows around `sublayers` that are not provided by vanilla USD.
| 204 | Markdown | 24.624997 | 145 | 0.803922 |
omniverse-code/kit/exts/omni.kit.usd.layers/docs/index.rst | omni.kit.usd.layers
###########################
Introduction
************
Extension **omni.kit.usd.layers** works to extend the USD to provide utilities and workflows around **sublayers** that are not provided by vanilla USD. We extended several workflows on vanilla USD for working the the following purpose.
Layer State Management
======================
In Omniverse Kit, the following states are extended or encapsulated from vanilla USD for better access:
- **Writable or not**. USD only provides a runtime flag to make the layer read-only. It does not care about access permission from the file system. We extended this to include file system permissions.
- **Muteness**. Muteness in USD is not serialized. In Omniverse Kit, it defines the muteness scope so muteness will be serialized into USD based on the influence scope. It includes two scopes:
1. **Local**. Local scope is provided by vanilla USD, so all muteness operation will not be serialized.
2. **Global**. Global scope will serialize muteness for the next session and live update for multiple users.
- **Layer Lock**. Lock status is the concept to support locking layers so users cannot switch it as edit target nor it cannot be saved. It’s a flag saved inside the custom data of the layer to be locked. So it can be serialized and live updated. Lock is not like write permission, which only works during runtime, while write permission reflects the status of the filesystem.
- **Dirtiness**. If it has pending edits that are not saved yet.
- **Up-to-date or not**. If this layer in memory is out of sync with the version on the disk or Nucleus server.
Around those concepts, it provides APIs to query/change status, and provides event subscriptions for monitoring state updates.
Providing Extended Python APIs
==============================
It provides extended APIs for Python to access or subscribe states, which are not provided by vanilla USD. It includes:
- Subscriptions to filter interested custom data for Layer Property Window.
- Subscriptions to notify sublayer changes.
- Subscriptions to notify prim changes for a single layer.
New workflows
=============
Omniverse Kit also builds new workflows on top of vanilla USD, which includes:
- **Auto Authoring**. USD supports switching edit targets so that all authoring will take place in that specified layer. When it's working with multiple sublayers, this kind of freedom may cause experience issues. User has to be aware the changes made are not overridden in any stronger layer. We extend a new mode called **Auto Authoring** to improve it. In this mode, all changes will firstly go into a middle delegate layer and it will then distribute edits (per frame) into their corresponding layers where the edits have the strongest opinions. So it cannot switch edit targets freely, and users do not need to be aware of the existence of multi-sublayers and how USD will compose the changes.
- **Prim/Attributes Locking**. Omniverse Kit supports to lock prims/attributes. After locking, the prims/attributes cannot be edited.
- **Layer Linking (Experimental)**. Layer link is a concept to support linking prim changes to specific layers, and serialization of those links. So if the prims/attributes are linked, all the edits to those prims or attributes will be forwarded to the layers specified. `This is an experimental feature right now.`
Programming Guide
*****************
Currently, **omni.kit.usd.layers** is mainly used by **omni.kit.widget.layers** or **omni.kit.property.layer** for UI workflows. It supports both C++ and Python APIs to query layer states and control workflows.
Python
======
Here are the steps to use Python APIs for accessing different interfaces:
1. Imports package:
::
import omni.kit.usd.layers as layers
...
2. Gets layers instance to specific UsdContext:
::
layers_interface = layers.get_layers(usd_context_name or instance_of_usd_context)
...
3. Gets specific interfaces:
::
layers_state = layers_interface.get_layers_state()
specs_linking = layers_interface.get_specs_linking()
specs_locking = layers_interface.get_specs_locking()
...
4. If you want to subscribe states change from sublayers:
::
def on_events(events: carb.events.IEvent):
payload = layers.get_layer_event_payload(events)
if payload.event_type == layers.LayerEventType.XXXXXX:
...
...
subscription = layers.get_event_stream().create_subscription_to_pop(on_events, name="xxxx")
...
C++
===
C++ interfaces are exposed as pure Carbonite plugin, which you can refer to the headers **omni/kit/usd/layers/ILayers.h** and its helper **omni/kit/usd/layers/LayersHelper.hpp**.
.. toctree::
:maxdepth: 1
CHANGELOG
| 4,753 | reStructuredText | 46.069306 | 699 | 0.740375 |
omniverse-code/kit/exts/omni.iray.settings.core/config/extension.toml | [package]
# Semantic Versioning is used: https://semver.org/
version = "0.6.4"
# 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 = "Iray Renderer Settings"
description="All the settings to Control Iray"
# 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 = "Rendering"
# Keywords for the extension
keywords = ["kit", "iray", "rendering"]
# 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"
# this need to be activated with iray on starup
toggleable = false
[dependencies]
"omni.kit.commands" = {}
"omni.ui" = {}
"omni.rtx.window.settings" = {}
# Should always load after omni.hydra.iray, but keep as an optional dependency
"omni.hydra.iray" = {optional = true}
# Main python module this extension provides, it will be publicly available as "import omni.example.hello".
[[python.module]]
name = "omni.iray.settings.core"
[[test]]
# Linux: rtx/iray/TexCopyIray.compute.hlsl issue
viewport_legacy_only = true
args = [
# OM-20773, OM-25786, OM-20773: Shutdown ordering of GPU foundation casuing issues.
"--/app/fastShutdown=true",
"--/app/window/dpiScaleOverride=1.0",
"--/app/window/scaleToMonitor=false",
"--/renderer/enabled=iray",
"--/renderer/active=iray",
"--/app/renderer/resolution/width=128",
"--/app/renderer/resolution/height=128",
"--no-window"
]
dependencies = [
"omni.kit.renderer.capture",
"omni.kit.mainwindow",
"omni.kit.ui_test",
"omni.hydra.iray",
"omni.kit.window.viewport",
]
stdoutFailPatterns.exclude = [
"*[Error] [gpu.foundation.plugin]*",
"*[Error] [carb.scenerenderer-iray.plugin] Failed to create rtx::postprocessing::TonemappingContext*"
]
unreliable = true # OM-54840
pythonTests.unreliable = [
"*test_combo_box_setting", # OM-53610
"*test_int_setting", # OM-53610
]
| 2,635 | TOML | 29.651162 | 118 | 0.713852 |
omniverse-code/kit/exts/omni.iray.settings.core/omni/iray/settings/core/extension.py | from typing import Union
import omni.ext
import omni.ui as ui
from omni.rtx.window.settings import RendererSettingsFactory
from .widgets.common_widgets import CommonIRaySettingStack
class IRaySettingsExtension(omni.ext.IExt):
"""The entry point for RTX - Accurate (Iray) Settings Window"""
MENU_PATH = "Rendering"
def on_startup(self):
RendererSettingsFactory.register_renderer("Accurate (Iray)", ["Common", "Accurate (Iray)", "Post Processing"])
RendererSettingsFactory.register_stack("Accurate (Iray)", CommonIRaySettingStack)
def on_shutdown(self):
RendererSettingsFactory.unregister_renderer("Accurate (Iray)")
RendererSettingsFactory.unregister_stack("Accurate (Iray)")
RendererSettingsFactory.build_ui()
| 773 | Python | 32.652172 | 118 | 0.742561 |
omniverse-code/kit/exts/omni.iray.settings.core/omni/iray/settings/core/widgets/common_widgets.py | from omni.kit.widget.settings import SettingType
import omni.ui as ui
import carb
import omni.kit.app
from omni.rtx.window.settings.rtx_settings_stack import RTXSettingsStack
from omni.rtx.window.settings.settings_collection_frame import SettingsCollectionFrame
from omni.rtx.window.settings.rendersettingsdefaults import SettingsDefaultHandler
from .heatmap_bar import *
class DeviceSettingsFrame(SettingsCollectionFrame):
def _build_ui(self):
""" RTX - Accurate (Iray) Device Settings """
# CPU
self._add_setting(
SettingType.BOOL, "CPU Enabled", "/iray/device/cpuEnabled", has_reset=False, tooltip="Enable/Disable CPU"
)
self._change_cb = omni.kit.app.SettingChangeSubscription("/iray/device/gpuCount", self._on_change)
# GPU selection
gpuCount = self._settings.get("/iray/device/gpuCount")
if gpuCount is not None and gpuCount > 0:
gpuCount = int(gpuCount)
for deviceIdx in range(0, gpuCount):
isAttachedToDisplay = self._settings.get("/iray/device/gpu" + str(deviceIdx) + "/isAttachedToDisplay")
name = self._settings.get("/iray/device/gpu" + str(deviceIdx) + "/name")
deviceName = "GPU " + str(deviceIdx) + " " + name + (" (display)" if isAttachedToDisplay else "")
self._add_setting(
SettingType.BOOL,
deviceName,
"/iray/device/gpu" + str(deviceIdx) + "/enabled",
has_reset=False,
tooltip="Enable/Disable GPU " + str(deviceIdx),
)
else:
ui.Label("GPU settings available when Iray is in use");
class SchedulerSettingsFrame(SettingsCollectionFrame):
def _build_ui(self):
iray_scheduler_mode_items = {"Interactive": "interactive", "Final Frame": "batch"}
schedulerModeCombo = self._add_setting_combo(
"Scheduler Mode",
"/rtx/iray/scheduler_mode",
iray_scheduler_mode_items,
tooltip="Optimize for interactivity or faster convergence",
)
self._add_setting(
SettingType.INT,
"Samples Limit",
"/rtx/iray/progressive_rendering_max_samples",
-1,
1048576,
1000,
tooltip="Stop rendering after this amount of samples (-1 means never stop)",
)
maxQualityEnabledWidget = self._add_setting(
SettingType.BOOL,
"Quality Limit Enabled",
"/rtx/iray/progressive_rendering_quality_enabled",
tooltip="Activate quality estimation (only available in Final Frame mode)",
)
maxQualityWidget = self._add_setting(
SettingType.FLOAT,
"Quality Limit",
"/rtx/iray/progressive_rendering_quality",
0.0,
1.0,
0.005,
tooltip="Stop rendering when the image has reached this quality threshold between 0.0 and 1.0 (fully converged)",
)
clampSpp = self._settings.get("/rtx/iray/max_min_samples_per_update")
if clampSpp is not None:
if clampSpp <= 1: # better 0, but setting range = (1,1) completely disables the UI control range
clampSpp = 512
self._add_setting(
SettingType.INT,
"Samples per Frame",
"/rtx/iray/min_samples_per_update",
1,
clampSpp,
tooltip="Render this many samples per frame",
)
class RenderSettingsFrame(SettingsCollectionFrame):
def _build_ui(self):
canvas_type_items = {
"Beauty": "result",
"Diffuse": "diffuse",
"Specular": "specular",
"Glossy": "glossy",
"Emission": "emission",
"Custom LPE": "custom_lpe",
"Alpha": "alpha",
"Illuminance": "irradiance",
"Luminance": "luminance",
"Ray Length": "ray_length",
"Depth": "depth",
"Normal": "normal",
"UVWs[0]": "texture_coordinate[0]",
"UVWs[1]": "texture_coordinate[1]",
"Material ID": "material_tag",
}
if self._settings.get("/rtx/iray/debugMotion") == True:
canvas_type_items["Motion Vectors"] = "motion_vector";
self._add_setting_combo(
"Canvas", "/rtx/iray/canvasType", canvas_type_items, tooltip="Render specified canvas type"
)
self._change_cb = omni.kit.app.SettingChangeSubscription("/rtx/iray/canvasType", self._on_change)
if self._settings.get("/rtx/iray/canvasType") == "diffuse":
self._add_setting(
SettingType.STRING,
"LPE",
"/rtx/iray/lpeDiffuse",
tooltip="Diffuse light path expression",
)
if self._settings.get("/rtx/iray/canvasType") == "glossy":
self._add_setting(
SettingType.STRING,
"LPE",
"/rtx/iray/lpeGlossy",
tooltip="Glossy light path expression",
)
if self._settings.get("/rtx/iray/canvasType") == "specular":
self._add_setting(
SettingType.STRING,
"LPE",
"/rtx/iray/lpeSpecular",
tooltip="Specular light path expression",
)
if self._settings.get("/rtx/iray/canvasType") == "emission":
self._add_setting(
SettingType.STRING,
"LPE",
"/rtx/iray/lpeEmission",
tooltip="Emissive light path expression",
)
if self._settings.get("/rtx/iray/canvasType") == "custom_lpe":
self._add_setting(
SettingType.STRING,
"LPE",
"/rtx/iray/lpeCustom",
tooltip="Custom light path expression",
)
if self._settings.get("/rtx/iray/canvasType") == "alpha":
self._add_setting(
SettingType.STRING,
"Alpha LPE",
"/rtx/iray/lpeAlpha",
tooltip="Alpha light path expression",
)
if self._settings.get("/rtx/iray/canvasType") == "irradiance":
self._add_setting(
SettingType.STRING,
"Illuminance Value",
"/iray/illuminanceVal",
tooltip="The Illuminance value at the last clicked position",)
self._add_setting(
SettingType.BOOL, "Auto Range", "/rtx/iray/illuminanceAutoRange", tooltip="Enable/disable auto range",)
self._change_cb_2 = omni.kit.app.SettingChangeSubscription("/rtx/iray/illuminanceAutoRange", self._on_change)
if self._settings.get("/rtx/iray/illuminanceAutoRange") == True:
self._add_setting(
SettingType.FLOAT,
" Range Min",
"/iray/illuminanceMin",
tooltip="Min illuminance range value", has_reset=False)
self._add_setting(
SettingType.FLOAT,
" Range Max",
"/iray/illuminanceMax",
tooltip="Max illuminance range value", has_reset=False)
else:
self._add_setting(
SettingType.FLOAT,
" User Range Min",
"/rtx/iray/illuminanceUserMin",
tooltip="User min illuminance range value")
self._add_setting(
SettingType.FLOAT,
" User Range Max",
"/rtx/iray/illuminanceUserMax",
tooltip="User max illuminance range value",)
with ui.HStack():
ui.Button("Show Illuminance Legend", clicked_fn=self._on_open_illuminance_bar)
if self._settings.get("/rtx/iray/canvasType") == "luminance":
self._add_setting(
SettingType.STRING,
"Luminance Value",
"/iray/luminanceVal",
tooltip="The luminance value at the last clicked position",)
self._add_setting(
SettingType.BOOL, "Auto Range", "/rtx/iray/luminanceAutoRange", tooltip="Enable/disable auto range",)
self._change_cb_3 = omni.kit.app.SettingChangeSubscription("/rtx/iray/luminanceAutoRange", self._on_change)
if self._settings.get("/rtx/iray/luminanceAutoRange") == True:
self._add_setting(
SettingType.FLOAT,
" Range Min",
"/iray/luminanceMin",
tooltip="Min luminance range value", has_reset=False)
self._add_setting(
SettingType.FLOAT,
" Range Max",
"/iray/luminanceMax",
tooltip="Max luminance range value", has_reset=False)
else:
self._add_setting(
SettingType.FLOAT,
" User Range Min",
"/rtx/iray/luminanceUserMin",
tooltip="User min luminance range value")
self._add_setting(
SettingType.FLOAT,
" User Range Max",
"/rtx/iray/luminanceUserMax",
tooltip="User max luminance range value",)
with ui.HStack():
ui.Button("Show Luminance Legend", clicked_fn=self._on_open_luminance_bar)
self._add_setting(
SettingType.BOOL, "Denoiser", "/rtx/iray/optixDenoiser/enabled", tooltip="Enable/Disable Denoising"
)
self._add_setting(
SettingType.BOOL,
"Caustic Sampler",
"/rtx/iray/iray_caustic_sampler",
tooltip="Enable to improve the quality of caustics (can impact performance)",
)
self._add_setting(
SettingType.BOOL,
"Guided Sampling",
"/rtx/iray/guided_sampling",
tooltip="Enable to improve overall convergence speed, especially for indoor scenes"
)
self._add_setting(
SettingType.BOOL,
"Backplate Refraction",
"/rtx/iray/refract_backplate",
tooltip="Forces perfectly specular materials to respect the virtual backplate (in addition to the environment)",
)
# see LightTypes.hlslh for enum
show_lights_settings = {
"Per-Light Enable": 0,
"Force Enable": 1,
"Force Disable": 2
}
self._add_setting_combo("Light Visibility In Primary Rays", "/rtx/iray/showLights", show_lights_settings, tooltip="Specify how lights are made visible in primary rays")
def _on_open_illuminance_bar(self):
if not hasattr(self, '_illuminance_legend') or self._illuminance_legend is None:
self._illuminance_legend = ui.Window("RTX - Accurate Illuminance Legend", width=400, height=100)
self._illuminance_legend.set_visibility_changed_fn(self._on_illum_window_visibility_changed)
with self._illuminance_legend.frame:
with ui.VStack():
IrayHeatmapBarWidget(self._illuminance_legend, 400, 100, 5, "illumination")
else:
self._illuminance_legend.visible = True
def _on_open_luminance_bar(self):
if not hasattr(self, '_luminance_legend') or self._luminance_legend is None:
self._luminance_legend = ui.Window("RTX - Accurate Luminance Legend", width=400, height=100)
self._luminance_legend.set_visibility_changed_fn(self._on_lum_window_visibility_changed)
with self._luminance_legend.frame:
with ui.VStack():
IrayHeatmapBarWidget(self._luminance_legend, 400, 100, 5, "lumination")
else:
self._luminance_legend.visible = True
def _on_illum_window_visibility_changed(self, val):
pass
def _on_lum_window_visibility_changed(self, val):
pass
def destroy(self):
if hasattr(self, '_illuminance_legend') and self._illuminance_legend:
self._illuminance_legend.destroy()
self._illuminance_legend = None
if hasattr(self, '_luminance_legend') and self._luminance_legend:
self._luminance_legend.destroy()
self._luminance_legend = None
super().destroy()
class SpectralRenderSettingsFrame(SettingsCollectionFrame):
def _build_ui(self):
""" Spectral Rendering """
self._add_setting(
SettingType.BOOL,
"Spectral Rendering",
"/rtx/iray/iray_spectral_rendering",
tooltip="Enable/Disable spectral rendering (light transport simulated on a continuous range of wavelengths)",
)
self._change_cb = omni.kit.app.SettingChangeSubscription("/rtx/iray/iray_spectral_rendering", self._on_change)
if self._settings.get("/rtx/iray/iray_spectral_rendering"):
iray_spectral_conversion_color_space_items = {
"CIE XYZ": "xyz",
"Rec.709/linear sRGB": "rec709",
"Rec.2020": "rec2020",
"ACES2065-1": "aces",
"ACEScg": "acescg",
}
self._add_setting_combo(
"Conversion Color Space",
"/rtx/iray/iray_spectral_conversion_color_space",
iray_spectral_conversion_color_space_items,
tooltip="The color space of the color data (also used without spectral rendering if spectral data is provided)",
)
iray_spectral_conversion_intent_items = {"Natural": "natural", "Faithful": "faithful"}
self._add_setting_combo(
"Conversion Intent",
"/rtx/iray/iray_spectral_conversion_intent",
iray_spectral_conversion_intent_items,
tooltip="Natural for more smoothness or Faithful for more compatibility with color rendering (only used with rec709 color space)",
)
iray_spectral_observer_items = {"CIE 1931 2 degree": "cie1931", "CIE 1964 10 degree": "cie1964"}
self._add_setting_combo(
"Color Matching",
"/rtx/iray/iray_spectral_observer",
iray_spectral_observer_items,
tooltip="Specifies the color matching function to use",
)
def destroy(self):
self._change_cb = None
super().destroy()
class GroundSettingsFrame(SettingsCollectionFrame):
def _build_ui(self):
self._add_setting(
SettingType.BOOL,
"Enable",
"/rtx/iray/environment_dome_ground",
tooltip="Enable/Disable an implicit ground plane to catch shadows (requires a dome light in the scene)",
)
self._change_cb = omni.kit.app.SettingChangeSubscription("/rtx/iray/environment_dome_ground", self._on_change)
if self._settings.get("/rtx/iray/environment_dome_ground"):
self._add_setting(
SettingType.COLOR3,
"Reflectivity",
"/rtx/iray/environment_dome_ground_reflectivity",
tooltip="The amount of reflectivity of the ground plane",
)
self._add_setting(
SettingType.FLOAT,
"Glossiness",
"/rtx/iray/environment_dome_ground_glossiness",
0,
10000000,
100,
tooltip="Sets the glossiness of the reflection from 0 (diffuse) to 10000000 (perfect mirror)",
)
self._add_setting(
SettingType.FLOAT,
"Shadow Intensity",
"/rtx/iray/environment_dome_ground_shadow_intensity",
0,
2,
0.01,
tooltip="Controls shadow intensity where 0.0 is no shadow, 1.0 is normal shadow, and 2.0 is very heavy shadow",
)
self._add_setting(
SettingType.DOUBLE3,
"Position",
"/rtx/iray/environment_dome_ground_position",
tooltip="The origin of the ground plane",
)
self._add_setting(
SettingType.DOUBLE3,
"Rotation Axis",
"/rtx/iray/environment_dome_rotation_axis",
tooltip="Defines rotation axis and up vector of the ground plane, (0,1,0) for y-up scenes and (0,0,1) for z-up scenes",
)
self._add_setting(
SettingType.FLOAT,
"Environment Rotation",
"/rtx/iray/environment_dome_rotation_angle",
0,
360,
tooltip="Inexpensive rotation of the dome around the specified rotation axis from 0 to 360 degrees",
)
def destroy(self):
self._change_cb = None
super().destroy()
class IrayServerSettingsFrame(SettingsCollectionFrame):
def _build_ui(self):
self._change_cb = omni.kit.app.SettingChangeSubscription("/iray/iray_server/state", self._on_change)
self._change_cb_2 = omni.kit.app.SettingChangeSubscription("/iray/iray_server/bridge_upload_message", self._on_change)
#self._change_cb_2 = omni.kit.app.SettingChangeSubscription("/iray/iray_server/queue_state", self._on_change)
#self._change_cb_3 = omni.kit.app.SettingChangeSubscription("/iray/iray_server/job_state", self._on_change)
def do_connect():
print("Connecting to server...")
self._settings.set("/iray/iray_server/state", "connecting")
self._settings.set("/iray/iray_server/connect", True)
def do_cancel_connect():
print("Cancelling connection to server...")
self._settings.set("/iray/iray_server/connect", False)
#self._settings.set("/iray/iray_server/state", "disconnected")
def do_disconnect():
print("Disconnecting from server...")
self._settings.set("/iray/iray_server/connect", False)
#self._settings.set("/iray/iray_server/state", "disconnected")
def do_queue_connect():
print("Connecting to Queue Manager...")
self._settings.set("/iray/iray_server/queue_state", "connecting")
self._settings.set("/iray/iray_server/queue_msg", "Connecting to server...")
self._settings.set("/iray/iray_server/queue_connect", "true")
def do_queue_disconnect():
print("Disconnecting from Queue Manager...")
self._settings.set("/iray/iray_server/queue_connect", "false")
self._settings.set("/iray/iray_server/queue_state", "disconnected")
self._settings.set("/iray/iray_server/queue_msg", "")
def do_add_job():
print("Adding server job...")
self._settings.set("/iray/iray_server/add_job", True)
self._settings.set("/iray/iray_server/queue_msg", "")
def do_cancel_job():
print("Cancling server job...")
self._settings.set("/iray/iray_server/job_state", "idle")
self._settings.set("/iray/iray_server/queue_msg", "")
state = self._settings.get("/iray/iray_server/state")
if state == "disconnected" or state == "error":
self._add_setting(
SettingType.STRING,
"Server Address",
"/rtx/iray/iray_server/address",
tooltip="The address to the Iray Server to connect to",
)
self._add_setting(
SettingType.INT,
"Server Port",
"/rtx/iray/iray_server/port",
0,
255,
tooltip="The Iray Server port to connect to",
)
self._add_setting(
SettingType.BOOL,
"Use Encryption",
"/rtx/iray/iray_server/ssl",
tooltip="Enable ssl encrytion. Note that the server must be set up to support this.",
)
self._add_setting(
SettingType.STRING,
"User Name",
"/rtx/iray/iray_server/user",
tooltip="Iray Server user",
)
self._add_setting(
SettingType.STRING,
"Password",
"/iray/iray_server/pwd",
tooltip="Iray Server user password",
)
# Bridge streaming options
#ui.Label("Streaming", alignment=ui.Alignment.CENTER)
if state == "connected":
ui.Label("Connected to " + self._settings.get("/rtx/iray/iray_server/user") + "@" + self._settings.get("/rtx/iray/iray_server/address") + ":" + str(self._settings.get("/rtx/iray/iray_server/port")), style={"color": 0xFFFFFFFF});
self._add_setting(SettingType.BOOL, "Cloud rendering","/iray/iray_server/cloud_rendering", tooltip="Enable cloud rendering.")
if self._settings.get("/iray/iray_server/bridge_upload_state") == "detecting":
ui.Label("Detecting changes...");
elif self._settings.get("/iray/iray_server/bridge_upload_state") == "calculating":
ui.Label("Calculating hashes...");
elif self._settings.get("/iray/iray_server/bridge_upload_state") == "cache_status":
ui.Label("Querying cache status...");
elif self._settings.get("/iray/iray_server/bridge_upload_state") == "uploading":
ui.Label("Uploading data...");
elif self._settings.get("/iray/iray_server/bridge_upload_state") == "waiting":
ui.Label("Server processing data...");
#else:
# ui.Label("Idle");
ui.Label(self._settings.get("/iray/iray_server/bridge_upload_message"));
ui.Button("Disconnect", tooltip="Disconnect from server", clicked_fn=do_disconnect, width=120)
elif state == "disconnected":
ui.Button("Connect", tooltip="Connect to server", clicked_fn=do_connect, width=120)
elif state == "connecting":
ui.Label("Connecting to server...");
ui.Button("Cancel", tooltip="Cancel connection", clicked_fn=do_cancel_connect, width=100)
elif state == None:
ui.Label("Switch to Accurate to connect to Iray Server", word_wrap=True);
else:
ui.Label("Failed to connect:", word_wrap=True, style={"color": 0xFF0000FF});
ui.Label(self._settings.get("/iray/iray_server/error_msg"));
ui.Button("Connect", tooltip="Connect to server", clicked_fn=do_connect, width=120)
# Queue manager options (currently not exposed)
if False:
ui.Label("Job Queue", alignment=ui.Alignment.CENTER)
if self._settings.get("/iray/iray_server/queue_state") == "disconnected":
ui.Button("Connect", tooltip="Connect to Queue Manager", clicked_fn=do_queue_connect, width=120)
ui.Label(self._settings.get("/iray/iray_server/queue_msg"));
elif self._settings.get("/iray/iray_server/queue_state") == "connected":
ui.Button("Disconnect", tooltip="Disconnect from Queue Manager", clicked_fn=do_queue_disconnect, width=120)
ui.Button("Add Job", tooltip="Add a job to the queue", clicked_fn=do_add_job, width=120)
ui.Label(self._settings.get("/iray/iray_server/queue_msg"));
else:
ui.Button("Connect", tooltip="Connect to Queue Manager", clicked_fn=do_queue_connect, width=120)
ui.Label(self._settings.get("/iray/iray_server/queue_msg"));
def destroy(self):
self._change_cb = None
super().destroy()
class AdvancedSettingsFrame(SettingsCollectionFrame):
def _build_ui(self):
self._add_setting(
SettingType.INT,
"Max Path Length",
"/rtx/iray/iray_max_path_length",
0,
500,
tooltip="Limits the number of light path bounces that contribute to the result (-1 means no limit)",
)
self._add_setting(
SettingType.BOOL,
"Firefly Filter",
"/rtx/iray/iray_firefly_filter",
tooltip="Enable/disable the firefly filter",
)
iray_instancing_items = {"On": "on", "Off": "off", "Auto": "auto"}
self._add_setting_combo(
"Instancing",
"/rtx/iray/iray_instancing",
iray_instancing_items,
tooltip="Off favors render speed, On favors interactivity when moving objects and saves memory when geometry is instanced, and Auto tries to balance this automatically",
)
self._add_setting(
SettingType.INT,
"Environment Resolution",
"/rtx/iray/environment_lighting_resolution",
64,
8192,
tooltip="The resolution to use for dome light baking",
)
self._add_setting(
SettingType.INT,
"Environment Sample Count",
"/rtx/iray/environment_lighting_shader_samples",
1,
1024,
tooltip="The sample count to use for dome light baking",
)
shadow_terminator_items = {"Off": "off", "On": "on", "Per Object" : "user"}
self._add_setting_combo(
"Smooth Shadow Terminator",
"/rtx/iray/shadow_terminator_offset_mode",
shadow_terminator_items,
tooltip="Enable/disable to override the per-object boolean attribute that controls if shading artifacts of curved surfaces with low detail shoud be reduced (can cause other problems, so more detail should always be preferred)",
)
self._add_setting(
SettingType.INT,
"Max value for \"Samples per Frame\"",
"/rtx/iray/max_min_samples_per_update",
2,
10240,
tooltip="Limits the maximum number of iterations per frame that can be set",
)
iray_texture_compression_items = {"None": "none", "Medium": "medium", "High": "high"}
self._add_setting_combo(
"Texture Compression",
"/rtx/iray/iray_texture_compression",
iray_texture_compression_items,
tooltip="Enable to reduces texture memory usage at the cost of visual quality",
)
self._add_setting(
SettingType.BOOL,
"Window Glass Optimization",
"/rtx/iray/windowGlassOptimization",
tooltip="Enable to get faster results when light is travelling through window panes, with the caveat of inconsistent shadowing in some corner cases",
)
self._add_setting(
SettingType.BOOL,
"Use Iray's built-in denoiser",
"/rtx/iray/useBuiltinDenoiser",
tooltip="When enabled, Iray's built-in denoiser is used. Temporal denoising is not available in this case.",
)
self._add_setting(
SettingType.BOOL,
"Temporal Denoising during Navigation",
"/rtx/iray/temporalDenoiser",
tooltip="When enabled, the temporal denoiser is used during navigation. The setting is ignored when denoising is disabled in the Rendering Options or Iray's built-in denoiser is used.",
)
self._add_setting(
SettingType.BOOL,
"Iray Selection Outline",
"/rtx/iray/selection_outline",
tooltip="Disable to skip rendering selection outlines for Iray.",
)
self._add_setting(
SettingType.STRING,
".mi File Path",
"/iray/export/exportFilename",
tooltip="Absolute path to the .mi file to export (for example c:\\scenes\\test.mi)",
)
def do_export():
print("Setting /iray/export/doExport=True setting for Iray..")
self._settings.set("/iray/export/doExport", True)
ui.Button("Export", tooltip="Export .mi file (experimental)", clicked_fn=do_export)
class CommonIRaySettingStack(RTXSettingsStack):
def __init__(self) -> None:
self._stack = ui.VStack(spacing=10, identifier=__class__.__name__)
self._settings = carb.settings.get_settings()
with self._stack:
gpuCount = None
if SettingsDefaultHandler().does_exist("/iray/device/gpuCount"):
gpuCount = self._settings.get("/iray/device/gpuCount")
if gpuCount is None:
ui.Label("Iray doesn't appear to be loaded....")
return
DeviceSettingsFrame("Device Settings", parent=self)
SchedulerSettingsFrame("Scheduler Settings", parent=self)
RenderSettingsFrame("Render Settings", parent=self)
SpectralRenderSettingsFrame("Spectral Rendering", parent=self)
GroundSettingsFrame("Matte Ground Plane Settings", parent=self)
IrayServerSettingsFrame("Iray Server Settings", parent=self)
AdvancedSettingsFrame("Advanced", parent=self)
ui.Spacer()
| 29,417 | Python | 41.328057 | 240 | 0.562634 |
omniverse-code/kit/exts/omni.iray.settings.core/omni/iray/settings/core/widgets/heatmap_bar.py | import omni.ui as ui
import carb.settings as settings
class IrayHeatmapBarWidget:
def __init__(self, parent_widget, width = 400, height = 20, steps = 4, type = "illumination"):
self._settings = settings.get_settings()
if type == "illumination":
self._unit = "Lux"
self._rangeMinSetting = "/iray/illuminanceMin"
self._rangeMaxSetting = "/iray/illuminanceMax"
self._rangeUserMinSetting = "/rtx/iray/illuminanceUserMin"
self._rangeUserMaxSetting = "/rtx/iray/illuminanceUserMax"
self._valueSetting = "/iray/illuminanceVal"
self._rangeAutoRangeSetting = "/rtx/iray/illuminanceAutoRange"
elif type == "lumination":
self._unit = "Nits"
self._rangeMinSetting = "/iray/luminanceMin"
self._rangeMaxSetting = "/iray/luminanceMax"
self._rangeUserMinSetting = "/rtx/iray/luminanceUserMin"
self._rangeUserMaxSetting = "/rtx/iray/luminanceUserMax"
self._valueSetting = "/iray/luminanceVal"
self._rangeAutoRangeSetting = "/rtx/iray/luminanceAutoRange"
else:
raise Exception("Unsupported heatmap type " + type)
self._parent_widget = parent_widget
self._width = width
self._height = height
self._labels = []
self._steps = steps
self._illum_min = 0.0
self._illum_max = 0.0
self._illum_value = 0.0
self._illum_value_str = "0.0 " + self._unit
self._illum_value_fraction = 0.0
self._update_values()
with ui.Frame():
with ui.VStack():
p = ui.Percent((100/self._steps) * 0.5)
# current illuminance value
with ui.HStack(height=20):
self._illum_value_spacer_l = ui.Spacer()
self._illum_value_label = ui.Label("0.0", alignment=ui.Alignment.CENTER, width=ui.Percent(p*2))
self._illum_value_spacer_r = ui.Spacer()
self._update_value()
# color bar
with ui.HStack(height=20):
ui.Spacer(width=ui.Percent(p))
pixels = [0] * width * height * 4
self._color_bar = ui.ByteImageProvider()
self._color_bar.set_bytes_data(pixels, [width, height])
ui.ImageWithProvider(self._color_bar, fill_policy=ui.IwpFillPolicy.IWP_STRETCH)
self._fill_color_bar(self._illum_value_fraction)
ui.Spacer(width=ui.Percent(p))
# ticks bar
with ui.HStack(height=10):
ui.Spacer(width=ui.Percent(p))
self._ticks_bar = ui.ByteImageProvider()
self._ticks_bar.set_bytes_data(pixels, [width, height])
ui.ImageWithProvider(self._ticks_bar,
fill_policy=ui.IwpFillPolicy.IWP_STRETCH,
)
self._fill_ticks_bar(0.0)
ui.Spacer(width=ui.Percent(p))
with ui.HStack(height=20):
for i in range(steps):
self._labels.append(ui.Label(str(i), alignment=ui.Alignment.CENTER))
self._update_legend()
self._settings.subscribe_to_node_change_events(self._rangeMinSetting, self._update_cb)
self._settings.subscribe_to_node_change_events(self._rangeMaxSetting, self._update_cb)
self._settings.subscribe_to_node_change_events(self._rangeUserMinSetting, self._update_cb)
self._settings.subscribe_to_node_change_events(self._rangeUserMaxSetting, self._update_cb)
self._settings.subscribe_to_node_change_events(self._rangeAutoRangeSetting,
self._update_cb)
self._settings.subscribe_to_node_change_events(self._valueSetting, self._update_cb)
def _fill_ticks_bar(self, val):
pixels = [0] * self._width * self._height * 4
l = int(self._width * val)
r = int((self._width) / (self._steps - 1))
for x in range(self._width):
for y in range(self._height):
p = y * self._width * 4 + x * 4
if x % r < 2 or x >= self._width - 2:
pixels[p + 0] = 255
pixels[p + 1] = 255
pixels[p + 2] = 255
pixels[p + 3] = 255
self._ticks_bar.set_bytes_data(pixels, [self._width, self._height])
def _fill_color_bar(self, val):
def get_color(t):
c = [255,255,255]
if t < 0.25:
c[0] = 0
c[1] = int(4.0 * t * 255)
elif t < 0.5:
c[0] = 0
c[2] = int((1.0 + 4.0 * (0.25 * 1.0 - t)) * 255)
elif t < 0.75:
c[0] = int(4.0 * (t - 0.5) * 255)
c[2] = 0
else:
c[1] = int((1.0 + 4.0 * (0.75 - t)) * 255)
c[2] = 0
return c
pixels = [255] * self._width * self._height * 4
l = int(self._width * val)
for x in range(self._width):
for y in range(self._height):
p = y * self._width * 4 + x * 4
if x >= l-1 and x <= l+1:
c = [255] * 4
else:
c = get_color(x / self._width)
pixels[p + 0] = c[0]
pixels[p + 1] = c[1]
pixels[p + 2] = c[2]
self._color_bar.set_bytes_data(pixels, [self._width, self._height])
def _update_values(self):
self._illum_min = float(self._settings.get(self._get_range_min_name()) or 0.0)
self._illum_max = float(self._settings.get(self._get_range_max_name()) or 10000.0)
if self._illum_max <= 0.0:
self._illum_max = 10000
self._illum_value_str = settings.get_settings().get(self._valueSetting) or "0.0 " + self._unit
try:
self._illum_value = float(self._illum_value_str.split()[0])
except:
self._illum_value = 0.0
d = self._illum_max - self._illum_min
if d == 0.0:
d = 1.0
if self._illum_value > self._illum_max:# can happen with user-range
self._illum_value = self._illum_max
if self._illum_value < self._illum_min:# can happen with user-range
self._illum_value = self._illum_min
self._illum_value_fraction = (self._illum_value - self._illum_min) / d
def _update_cb(self, item, event_type):
self._update_values()
self._update_legend()
self._update_value()
self._fill_color_bar(self._illum_value_fraction)
def _update_legend(self):
incr = (self._illum_max - self._illum_min) / (self._steps - 1)
for i in range(self._steps):
self._labels[i].text = "%.1f" % (self._illum_min + i * incr)
def _update_value(self):
w1 = 1/ (1 /self._steps + 1)
self._illum_value_label.text = self._illum_value_str
p = 0#ui.Percent((100/self._steps) * 0.5)
p0 = self._illum_value_fraction * w1 * 100
if p0-p <= 0:
p0 = 0
self._illum_value_spacer_l.width = ui.Percent(p0-p)
def _get_range_min_name(self):
auto_range = settings.get_settings().get(self._rangeAutoRangeSetting)
if auto_range:
return self._rangeMinSetting
return self._rangeUserMinSetting
def _get_range_max_name(self):
auto_range = settings.get_settings().get(self._rangeAutoRangeSetting)
if auto_range:
return self._rangeMaxSetting
return self._rangeUserMaxSetting
def __del__(self):
self._settings.unsubscribe_to_change_events(self._update_cb)
| 8,098 | Python | 39.90404 | 115 | 0.508644 |
omniverse-code/kit/exts/omni.iray.settings.core/omni/iray/settings/core/tests/__init__.py | from .test_settings import TestIRaySettingsUI | 45 | Python | 44.999955 | 45 | 0.888889 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.