file_path
stringlengths 20
202
| content
stringlengths 9
3.85M
| size
int64 9
3.85M
| lang
stringclasses 9
values | avg_line_length
float64 3.33
100
| max_line_length
int64 8
993
| alphanum_fraction
float64 0.26
0.93
|
|---|---|---|---|---|---|---|
omniverse-code/kit/exts/omni.graph/omni/graph/core/tests/test_bundle_attribute_data_access.py
|
import omni.graph.core as og
import omni.graph.core.tests as ogt
class TestBundleAttributeAccess(ogt.OmniGraphTestCase):
async def setUp(self):
await super().setUp()
self.graph = og.Controller.create_graph("/graph")
self.context = self.graph.get_default_graph_context()
self.factory = og.IBundleFactory.create()
self.assertTrue(self.factory is not None)
self.bundle1Name = "bundle1"
self.rwBundle = self.factory.create_bundle(self.context, self.bundle1Name)
self.assertTrue(self.rwBundle.valid)
self.attr1Name = "attr1"
self.tupleType = og.Type(og.BaseDataType.INT, 2, 0)
self.arrayType = og.Type(og.BaseDataType.INT, 1, 1)
self.arrayTupleType = og.Type(og.BaseDataType.INT, 2, 1)
async def test_tuple_write_permissions(self):
attr = self.rwBundle.create_attribute(self.attr1Name, self.tupleType)
with self.assertRaises(ValueError):
data = attr.as_read_only().get()
data[0] = 42 # writing to data will throw
data = attr.get()
data[0] = 42 # writing to data will not throw
async def test_array_type_write_permissions(self):
attr = self.rwBundle.create_attribute(self.attr1Name, self.arrayType)
# GPU = False, Write = True
# calling get_array will throw
with self.assertRaises(ValueError):
attr.as_read_only().get_array(False, True, 10)
# GPU = False, Write = False
# calling get_array will not throw
attr.as_read_only().get_array(False, False, 10)
async def test_array_of_tuple_write_permissions(self):
attr = self.rwBundle.create_attribute(self.attr1Name, self.arrayTupleType)
# GPU = False, Write = True
# calling get_array will throw
with self.assertRaises(ValueError):
attr.as_read_only().get_array(False, True, 10)
# GPU = False, Write = False
# calling get_array will not throw
attr.get_array(False, False, 10)
| 2,035 |
Python
| 36.018181 | 82 | 0.642752 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/tests/test_data_wrapper.py
|
"""Suite of tests to exercise the DataWrapper class as a unit."""
import omni.graph.core as og
import omni.kit.test
# The test needs some non-standard imports to do its thing
from omni.graph.core._impl.dtypes import (
Bool,
BundleOutput,
Double,
Double2,
Double3,
Double4,
Float,
Float2,
Float3,
Float4,
Half,
Half2,
Half3,
Half4,
Int,
Int2,
Int3,
Int4,
Int64,
Matrix2d,
Matrix3d,
Matrix4d,
Token,
UChar,
UInt,
UInt64,
)
class TestDataWrapper(omni.kit.test.AsyncTestCase):
"""Wrapper for unit tests for the og.DataWrapper class"""
# ----------------------------------------------------------------------
async def test_data_wrapper_creation(self):
"""Test creation of the DataWrapper from the raw og.Type"""
# Test data that enumerates all of the OGN types. Values of the list entries are:
# OGN type name
# Expected dtype
# Expected shape for non-gathered attributes
# Expected shape for gathered attributes
test_data = [
("any", Token, None, (2,)),
("bool", Bool, None, (2,)),
("bool[]", Bool, (0,), ((2, 2))),
("bundle", BundleOutput, None, (2,)),
("colord[3]", Double3, (3,), ((2,), 3)),
("colord[3][]", Double3, (0, 3), (((2, 2)), 3)),
("colord[4]", Double4, (4,), ((2,), 4)),
("colord[4][]", Double4, (0, 4), ((2, 2), 4)),
("colorf[3]", Float3, (3,), ((2,), 3)),
("colorf[3][]", Float3, (0, 3), ((2, 2), 3)),
("colorf[4]", Float4, (4,), ((2,), 4)),
("colorf[4][]", Float4, (0, 4), ((2, 2), 4)),
("colorh[3]", Half3, (3,), ((2,), 3)),
("colorh[3][]", Half3, (0, 3), ((2, 2), 3)),
("colorh[4]", Half4, (4,), ((2,), 4)),
("colorh[4][]", Half4, (0, 4), ((2, 2), 4)),
("double", Double, None, (2,)),
("double[]", Double, (0,), ((2, 2))),
("double[2]", Double2, (2,), ((2,), 2)),
("double[2][]", Double2, (0, 2), ((2, 2), 2)),
("double[3]", Double3, (3,), ((2,), 3)),
("double[3][]", Double3, (0, 3), ((2, 2), 3)),
("double[4]", Double4, (4,), ((2,), 4)),
("double[4][]", Double4, (0, 4), ((2, 2), 4)),
("execution", UInt, None, (2,)),
("float", Float, None, (2,)),
("float[]", Float, (0,), ((2, 2))),
("float[2]", Float2, (2,), ((2,), 2)),
("float[2][]", Float2, (0, 2), ((2, 2), 2)),
("float[3]", Float3, (3,), ((2,), 3)),
("float[3][]", Float3, (0, 3), ((2, 2), 3)),
("float[4]", Float4, (4,), ((2,), 4)),
("float[4][]", Float4, (0, 4), ((2, 2), 4)),
("frame[4]", Matrix4d, (4, 4), ((2,), 4, 4)),
("frame[4][]", Matrix4d, (0, 4, 4), ((2, 2), 4, 4)),
("half", Half, None, (2,)),
("half[]", Half, (0,), ((2, 2))),
("half[2]", Half2, (2,), ((2,), 2)),
("half[2][]", Half2, (0, 2), ((2, 2), 2)),
("half[3]", Half3, (3,), ((2,), 3)),
("half[3][]", Half3, (0, 3), ((2, 2), 3)),
("half[4]", Half4, (4,), ((2,), 4)),
("half[4][]", Half4, (0, 4), ((2, 2), 4)),
("int", Int, None, (2,)),
("int[]", Int, (0,), ((2, 2))),
("int[2]", Int2, (2,), ((2,), 2)),
("int[2][]", Int2, (0, 2), ((2, 2), 2)),
("int[3]", Int3, (3,), ((2,), 3)),
("int[3][]", Int3, (0, 3), ((2, 2), 3)),
("int[4]", Int4, (4,), ((2,), 4)),
("int[4][]", Int4, (0, 4), ((2, 2), 4)),
("int64", Int64, None, (2,)),
("int64[]", Int64, (0,), ((2, 2))),
("matrixd[2]", Matrix2d, (2, 2), ((2,), 2, 2)),
("matrixd[2][]", Matrix2d, (0, 2, 2), ((2, 2), 2, 2)),
("matrixd[3]", Matrix3d, (3, 3), ((2,), 3, 3)),
("matrixd[3][]", Matrix3d, (0, 3, 3), ((2, 2), 3, 3)),
("matrixd[4]", Matrix4d, (4, 4), ((2,), 4, 4)),
("matrixd[4][]", Matrix4d, (0, 4, 4), ((2, 2), 4, 4)),
("normald[3]", Double3, (3,), ((2,), 3)),
("normald[3][]", Double3, (0, 3), (((2, 2)), 3)),
("normalf[3]", Float3, (3,), ((2,), 3)),
("normalf[3][]", Float3, (0, 3), ((2, 2), 3)),
("normalh[3]", Half3, (3,), ((2,), 3)),
("normalh[3][]", Half3, (0, 3), ((2, 2), 3)),
("objectId", UInt64, None, (2,)),
("objectId[]", UInt64, (0,), ((2, 2))),
("pointd[3]", Double3, (3,), ((2,), 3)),
("pointd[3][]", Double3, (0, 3), (((2, 2)), 3)),
("pointf[3]", Float3, (3,), ((2,), 3)),
("pointf[3][]", Float3, (0, 3), ((2, 2), 3)),
("pointh[3]", Half3, (3,), ((2,), 3)),
("pointh[3][]", Half3, (0, 3), ((2, 2), 3)),
("quatd[4]", Double4, (4,), ((2,), 4)),
("quatd[4][]", Double4, (0, 4), (((2, 2)), 4)),
("quatf[4]", Float4, (4,), ((2,), 4)),
("quatf[4][]", Float4, (0, 4), ((2, 2), 4)),
("quath[4]", Half4, (4,), ((2,), 4)),
("quath[4][]", Half4, (0, 4), ((2, 2), 4)),
("string", UChar, (0,), ((2, 2))),
("target", BundleOutput, None, (2,)),
("texcoordd[2]", Double2, (2,), ((2,), 2)),
("texcoordd[2][]", Double2, (0, 2), (((2, 2)), 2)),
("texcoordd[3]", Double3, (3,), ((2,), 3)),
("texcoordd[3][]", Double3, (0, 3), ((2, 2), 3)),
("texcoordf[2]", Float2, (2,), ((2,), 2)),
("texcoordf[2][]", Float2, (0, 2), ((2, 2), 2)),
("texcoordf[3]", Float3, (3,), ((2,), 3)),
("texcoordf[3][]", Float3, (0, 3), ((2, 2), 3)),
("texcoordh[2]", Half2, (2,), ((2,), 2)),
("texcoordh[2][]", Half2, (0, 2), ((2, 2), 2)),
("texcoordh[3]", Half3, (3,), ((2,), 3)),
("texcoordh[3][]", Half3, (0, 3), ((2, 2), 3)),
("timecode", Double, None, (2,)),
("timecode[]", Double, (0,), ((2, 2))),
("token", Token, None, (2,)),
("token[]", Token, (0,), ((2, 2))),
("uchar", UChar, None, (2,)),
("uchar[]", UChar, (0,), ((2, 2))),
("uint", UInt, None, (2,)),
("uint[]", UInt, (0,), ((2, 2))),
("uint64", UInt64, None, (2,)),
("uint64[]", UInt64, (0,), ((2, 2))),
("vectord[3]", Double3, (3,), ((2,), 3)),
("vectord[3][]", Double3, (0, 3), (((2, 2)), 3)),
("vectorf[3]", Float3, (3,), ((2,), 3)),
("vectorf[3][]", Float3, (0, 3), ((2, 2), 3)),
("vectorh[3]", Half3, (3,), ((2,), 3)),
("vectorh[3][]", Half3, (0, 3), ((2, 2), 3)),
]
for name, expected_dtype, expected_ungathered_shape, expected_gathered_shape in test_data:
attribute_type = og.AttributeType.type_from_ogn_type_name(name)
ungathered_dtype, ungathered_shape = og.data_shape_from_type(attribute_type, is_gathered=False)
gathered_dtype, gathered_shape = og.data_shape_from_type(attribute_type, is_gathered=True)
self.assertEqual(ungathered_dtype.__class__, expected_dtype, f"Mismatched type for {name}")
self.assertEqual(ungathered_shape, expected_ungathered_shape, f"Mismatched shape for {name}")
self.assertEqual(ungathered_dtype, gathered_dtype, f"Mismatched gathered type for {name}")
self.assertEqual(gathered_shape, expected_gathered_shape, f"Mismatched gathered shape for {name}")
# ----------------------------------------------------------------------
async def test_data_wrapper_indexing(self):
"""Test indexing of the DataWrapper for all of the documented supported types"""
# Test data drives all of the test cases for expected index results. The data is a list of test
# configurations consisting of:
# Dtype of the parent wrapper
# Shape of the parent wrapper
# Index to be be taken to get the child
# Expected Dtype of the child wrapper (None means to expect an exception raised)
# Expected shape of the child wrapper
# Expected memory location offset of the child at index 1 from the parent
test_data = [
[Float, None, 1, None, None, 0], # Single value
[Float, (3,), 1, Float, None, Float.size], # Array of 3 simple values
[Float3, (3,), 1, Float, None, Float.size], # Tuple of 3 simple values
[Float3, (2, 3), 1, Float3, (3,), Float3.size], # Array of 2 triple values
[Matrix2d, (2, 2), 1, Double2, (2,), Double2.size], # A 2x2 matrix
[Matrix2d, (3, 2, 2), 1, Matrix2d, (2, 2), Matrix2d.size], # An array of 3 2x2 matrixes
[Float3, (3,), -1, None, None, 0], # Index too low
[Float3, (3, 3), -1, None, None, 0],
[Float3, ((3,), 3), -1, None, None, 0],
[Float3, ((3, 4), 3), -1, None, None, 0],
[Float, (3,), -1, None, None, 0],
[Float, ((3,), 3), -1, None, None, 0],
[Float, ((3, 4), 3), -1, None, None, 0],
[Matrix2d, (2, 2), -1, None, None, 0],
[Matrix2d, (3, 2, 2), -1, None, None, 0],
[Matrix2d, ((3,), 2, 2), -1, None, None, 0],
[Matrix2d, ((3, 4), 2, 2), -1, None, None, 0],
[Float3, (3,), 4, None, None, 0], # Index too high
[Float3, (3, 3), 4, None, None, 0],
[Float3, ((3,), 3), 4, None, None, 0],
[Float3, ((3, 4), 3), 4, None, None, 0],
[Float, (3,), 4, None, None, 0],
[Float, ((3,), 3), 4, None, None, 0],
[Float, ((3, 4), 3), 4, None, None, 0],
[Matrix2d, (2, 2), 4, None, None, 0],
[Matrix2d, (3, 2, 2), 4, None, None, 0],
[Matrix2d, ((3,), 2, 2), 4, None, None, 0],
[Matrix2d, ((3, 4), 2, 2), 4, None, None, 0],
[Float, (3, 3), 1, None, None, 0], # Too many levels of array
[Float4, (3,), 1, None, None, 0], # Mismatched shape size for tuple
[Float4, (3, 3), 1, None, None, 0], # Mismatched shape size for tuple array
[Matrix2d, (3, 3), 1, None, None, 0], # Mismatched shape size for matrix
[Matrix2d, (2, 3, 3), 1, None, None, 0], # Mismatched shape size for matrix array
]
for parent_dtype, parent_shape, child_index, child_dtype, child_shape, child_offset in test_data:
if child_dtype is None:
with self.assertRaises(ValueError):
parent_wrapper = og.DataWrapper(0, parent_dtype, parent_shape, og.Device.cuda)
_ = parent_wrapper[child_index]
else:
parent_wrapper = og.DataWrapper(0, parent_dtype, parent_shape, og.Device.cuda)
child_wrapper = parent_wrapper[child_index]
self.assertEqual(child_wrapper.dtype.tuple_count, child_dtype.tuple_count)
self.assertEqual(child_wrapper.dtype.base_type, child_dtype.base_type)
self.assertEqual(child_wrapper.shape, child_shape)
self.assertEqual(child_wrapper.memory, child_offset)
| 11,393 |
Python
| 48.53913 | 110 | 0.43202 |
omniverse-code/kit/exts/omni.graph/docs/testing.rst
|
.. _set_up_omnigraph_tests:
Set Up OmniGraph Tests
======================
Much of the testing for a node can be set up through the .ogn file's :ref:`test section<ogn_defining_automatic_tests>`,
however there are a number of situations that require more detailed setup or more flexible checking than the
automatically generated tests can provide. For such tests you will want to hook into Kit's testing system.
Some examples of these situations are when you need to check for attributes that are one-of a set of allowed results
rather than a fixed value, where you need to check node or attribute information that is more than just the current
value, where you need to call utility scripts to set up desired configurations, or when your results depend on some
external condition such as the graph state.
Described here are some best practices for writing such tests. This is only meant to describe setting up Python
regression tests that use the Kit extensions to the Python `unittest` modeule. It is not meant to describe setting up
C++ unit tests.
.. note::
For clarity a lot of recommended coding practices, like adding docstrings to all classes, functions, and modules,
or checking for unexpected exceptions in order to provide better error messages, are not followed. Please do use
them when you write your actual tests though.
Locating The Tests
------------------
The Kit extension system uses an automatic module recognition algorithm to detect directories in which test cases
may be found. In particular it looks for **.tests** submodules. So if your Python module is named `omni.graph.foo` it
will check the contents of the module `omni.graph.foo.tests`, if it exists, and attempt to find files containing
classes derived from `unittest.TestCase`, or the Kit version `omni.kit.test.AsyncTestCase`.
The usual way of structuring extensions provides a directory structure that looks like this:
.. code-block:: text
omni.graph.foo/
python/
tests/
test_some_stuff.py
The *tests/* subdirectory would be linked into the build using these lines in your *premake5.lua* file inside the
python project definition:
.. code-block:: lua
add_files("python/tests", "python/tests/*.py")
repo_build.prebuild_link {
{ "python/tests", ogn.python_tests_target_path },
}
This creates a link that creates a **.tests** submodule for your extension.
The files containing tests should all begin with the prefix *test_*.
Creating A Test Class
---------------------
OmniGraph tests have some shared setUp and tearDown operations so the easiest way to set up your test class is to
have it derive from the derived test case class that implements them:
.. code-block:: python
import omni.graph.core.tests as ogts
class TestsForMe(ogts.OmniGraphTestCase):
pass
This will ensure your tests are part of the Kit regression test system. The parent class will define some temporary
settings as required by OmniGraph, and will clear the scene when the test is done so as not to influence the results
of the test after it (barring any other side effects the test itself causes of course).
.. tip::
Although the name of the class is not significant it's helpful to prefix it with *Tests* to make it easy to identify.
Specialized SetUp And TearDown
++++++++++++++++++++++++++++++
If you have some other setUp or tearDown functions you wish to perform you do it in the usual Pythonic manner:
.. code:: python
import omni.graph.core.tests as ogts
class TestsForMe(ogts.OmniGraphTestCase):
async def setUp(self):
await super().setUp()
do_my_setup()
async def tearDown(self):
do_my_teardown()
await super().tearDown()
.. note::
The tests are async so both they and the setUp/tearDown will be "awaited" when running. This was done to facilitate
easier access to some of the Kit async functions, though normally you want to ensure your test steps run
sequentially.
Adding Tests
++++++++++++
Tests are added in the usual way for the Python `unittest` framework, by creating a function with the prefix *test_*.
As the tests are all awaited your functions should be async.
.. code:: python
import omni.graph.core.tests as ogts
class TestsForMe(ogts.OmniGraphTestCase):
async def setUp(self):
await super().setUp()
do_my_setup()
async def tearDown(self):
do_my_teardown()
await super().tearDown()
async def test1(self):
self.assertTrue(run_first_test())
async def test2(self):
self.assertTrue(run_second_test())
How you divide your test bodies is up to you. You'll want to balance the slower performance of repetitive setup
against the isolation of specific test conditions.
Your best friend in setting up test conditions is the :ref:`og.Controller<howto_omnigraph_controller>` class. It
provides a lot of what you will need for setting up and inspecting your graph, nodes, and attributes.
Here is a simple example that will create an add node with one constant input, and one input supplied from another
node that will test to make sure that results are correct over a set of inputs. It uses several concepts from the
controller to illustrate its use.
.. code-block:: python
import omni.graph.core as og
import omni.graph.core.tests as ogts
class TestsForMe(ogts.OmniGraphTestCase):
async def test_add(self):
keys = og.Controller.Keys
(graph, nodes, _, _) = og.Controller.edit("/TestGraph", {
keys.CREATE_NODES: [
("Add", "omni.graph.nodes.Add"),
("ConstInt", "omni.graph.nodes.ConstantInt"),
],
keys.CONNECT: ("ConstInt.inputs:value", "Add.inputs:a"),
keys.SET_VALUES: [("ConstInt.inputs:value", 3), ("Add.inputs:b", {"type": "int", "value": 1})]
})
# Get controllers attached to the attributes since they will be accessed in a loop
b_view = og.Controller(attribute=og.Controller.attribute("inputs:b", nodes[0]))
sum_view = og.Controller(attribute=og.Controller.attribute("outputs:sum", nodes[0]))
# Test configurations are pairs of (input_b_value, output_sum_expected)
test_configurations = [
({"type": "int", "value": 1}, 4),
({"type": "int", "value": -3}, 0),
({"type": "int", "value": 1000000}, 1000003),
]
for b_value, sum_expected in test_configurations:
b_view.set(b_value)
# Before checking computed values you must ensure the graph has evaluated
await og.Controller.evaluate(graph)
self.assertAlmostEqual(sum_expected, sum_view.get())
Expected Errors
+++++++++++++++
When writing tests, it can be desirable to test error conditions. However, this may cause errors to be
displayed to the console, which can cause tests to fail when running in batch mode.
One way to have the testing system ignore these errors is to prepend a additional text to the error line.
.. code-block:: python
# write to the console, skipping the newline to prepend the expected error message
print("[Ignore this error/warning] ", end ="")
self.assertFalse(self.function_that_causes_error())
Then, in your packages extensions.toml file, tell the test system to ignore error output when the prepended output
occurs.
.. code-block:: rst
[[test]]
stdoutFailPatterns.exclude = [
# Exclude messages which say they should be ignored
"*Ignore this error/warning*",
]
This allows for the test to specify which errors should be ignored without ignoring all errors with the same
output in the entire package, or by disabling all error checking from your test class.
Executing Your Tests
--------------------
Now that your tests are visible to Kit they will be automatically run by TeamCity. To run them yourself locally you
have two options.
Batch Running Tests
+++++++++++++++++++
All tests registered in the manner described above will be added to a batch file that runs
all tests in your extension. You can find this file at *$BUILD/tests-omni.graph.foo.{bat|sh}*. Executing this file
will run your tests in a minimal Kit configuration. (It basically loads your extension and all dependent extensions,
including the test manager.) Look up the documentation on ``omni.kit.test`` for more information on how the tests
can be configured.
Test Runner
+++++++++++
Kit's *Test Runner* window is a handy way to interactively run one or more of your tests at a finer granularity through
a UI. By default none of the tests are added to the window, however, so you must add a line like this to your
user configuration file, usually in **~/Documents/Kit/shared/user.toml**, to specify which tests it should load:
.. code-block:: toml
exts."omni.kit.test".includeTests = ["omni.graph.foo.*"]
Debugging Your Tests
--------------------
Whether you're tracking down a bug or engaging in test-driven-development eventually you will end up in a situation
where you need to debug your tests.
One of the best tools is to use the script editor and the UI in Kit to inspect and manipulate your test scene.
While the normal OmniGraph test case class deletes the scene at the end of the test you can make a temporary change
to instead use a variation of the test case that does not do that, so that you can examine the failing scene.
.. code-block:: python
:emphasize-lines: 3
import omni.graph.core.tests as ogts
class TestsForMe(ogts.OmniGraphTestCaseNoClear):
pass
Running Test Batch Files With Attached Debuggers
++++++++++++++++++++++++++++++++++++++++++++++++
You're probably familiar with the debugging extensions ``omni.kit.debug.python`` and ``omni.kit.debug.vscode``,
with which you can attach debuggers to running versions of Kit.
If you are running the test batch file, however, you have to ensure that these extensions are running as part of the
test environment. To do so you just need to add these flags to your invocation of the test ``.bat`` file:
.. code-block:: bash
$BUILD/tests-omni.graph.foo.bat --enable omni.kit.debug.vscode --enable omni.kit.debug.python
This will enable the extra extensions required to attach the debuggers while the test scripts are running. Of course
you still have to manually attach them from your IDE in the same way you usually do.
.. note::
As of this writing you might see two ``kit.exe`` processes when attaching a C++ debugger to a test script. The
safest thing to do is attach to both of them.
The .bat files also support the flag ``-d`` flag to wait for the debugger to attach before executing. If you're running
a debug cut this probably won't be necessary as the startup time is ample for attaching a debugger.
| 10,992 |
reStructuredText
| 40.018657 | 121 | 0.702966 |
omniverse-code/kit/exts/omni.graph/docs/runtimeInitialize.rst
|
.. _runtime_attribute_value_initialization_in_omnigraph_nodes:
Runtime Attribute Value Initialization In OmniGraph Nodes
=========================================================
Normally you will specify attribute default values in your .ogn files and the attributes will be given those values
when the node is created. Occasionally, you may wish to provide different default values for your attributes based
on some condition that can only be ascertained at runtime. This document describes the current best-practice for
achieving that goal, in both C++ and Python nodes.
As of this writing the database cannot be accessed during the node's *initialize()* method, so providing new values in
there will not work. (If in the future that changes this document will be updated to explain how to use it instead.)
In fact, the only time the data is guaranteed to be available to use or set is in the node's *compute()* method, so
that will be used to set up a delayed initialization of attribute values.
The general approach to this initialization will be to use a boolean state value in the node to determine whether the
attribute or attributes have been given their initial values or not when the *compute()* method is called. It's also
possible that the attribute would have been given a value directly so that also must be considered when managing the
boolean state value.
For these examples this node definition will be used:
.. code-block:: json
{
"RandomInt": {
"version": 1,
"description": "Holds an integer with a random integer number.",
"outputs": {
"number": {
"description": "The random integer",
"type": "int"
}
},
"state": {
"$comment": "This section exists solely to inform the scheduler that there is internal state information."
}
}
}
.. note::
For the Python node assume the addition of the line `"language": "python"`.
Initializing Values In C++ Nodes
--------------------------------
In the :ref:`internal state tutorial<ogn_tutorial_state>` you can see that the way to add state information to a C++
node is to make some class members. We'll add a boolean class member to tell us if the node is initialized or not,
and check it in the **compute()** method.
.. code-block:: cpp
#include <OgnRandomIntDatabase.h>
#include <cstdlib>
class OgnRandomInt
{
bool m_initialized{ false }; // State information the tells if the attribute value has been initialized yet
public:
static bool compute(OgnRandomIntDatabase& db)
{
auto& state = db.internalState<OgnRandomInt>();
if (! state.m_initialized)
{
db.outputs.number() = std::rand();
state.m_initialized = true;
}
// Normally you would have other things to do as part of the compute as well...
return true;
}
};
REGISTER_OGN_NODE()
If you know your attribute will never be set from the outside then that is sufficient, however usually there is no
guarantee that some script or UI has not set the attribute value. Fortunately the node can monitor that using the
**registerValueChangedCallback()** ABI function on the attribute. It can be set up in the node's **initialize()**
method.
Putting this in with the above code you get this:
.. code-block:: cpp
#include <OgnRandomIntDatabase.h>
#include <cstdlib>
class OgnRandomInt
{
bool m_initialized{ false }; // State information the tells if the attribute value has been initialized yet
static void attributeChanged(const AttributeObj& attr, const void*)
{
auto& state = OgnRandomIntDatabase::sInternalState<OgnRandomInt>(attr.iAttribute->getNode(attr));
state.m_initialized = true;
}
public:
static bool compute(OgnRandomIntDatabase& db)
{
auto& state = db.internalState<OgnRandomInt>();
if (! state.m_initialized)
{
db.outputs.number() = std::rand();
state.m_initialized = true;
}
// Normally you would have other things to do as part of the compute as well...
return true;
}
static void initialize(const GraphContextObj&, const NodeObj& nodeObj)
{
AttributeObj attrObj = nodeObj.iNode->getAttributeByToken(nodeObj, outputs::number.m_token);
attrObj.iAttribute->registerValueChangedCallback(attrObj, attributeChanged, true);
}
};
REGISTER_OGN_NODE()
Initializing Values In Python Nodes
-----------------------------------
In the :ref:`internal state tutorial<ogn_tutorial_state_py>` you can see that the way to add state information to a
Python node is to create a static **internal_state** method. We'll create a simple class with a boolean class member to
tell us if the node is initialized or not, and check it in the **compute()** method.
.. code-block:: python
from dataclasses import dataclass
from random import randint
class OgnRandomInt:
@dataclass
class State:
initialized: bool = False
@staticmethod
def internal_state() -> State:
return OgnRandomInt.State()
@staticmethod
def compute(db) -> bool:
if not db.internal_state.initialized:
db.outputs.number = randint(-0x7fffffff, 0x7fffffff)
db.internal_state.initialized = True
# Normally you would have other things to do as part of the compute as well...
return True
If you know your attribute will never be set from the outside then that is sufficient. Unfortunately the Python API
does not yet have a method of getting a callback when an attribute value has changed so for now this is all you can do.
| 5,974 |
reStructuredText
| 37.798701 | 122 | 0.652996 |
omniverse-code/kit/exts/omni.graph/docs/autonode.rst
|
.. _autonode_ref:
AutoNode - Autogenerating Nodes From Code
================================================================================
This is a description of the automated node generator for python code in OmniGraph.
It turns this:
.. code-block:: python
import omni.graph.core as og
@og.AutoFunc(pure=True)
def dot(vec1: og.Float3, vec2: og.Float3) -> float:
return vec1[0] * vec2[0] + vec1[1] * vec2[1] + vec1[2] * vec2[2]
Into this:
.. image:: images/dot.png
What it Does
--------------------------------------------------------------------------------
AutoNode allows developers to create OmniGraph nodes from any of the following:
* **Free functions** (see `AutoFunc`_)
* **Python classes and class instances** - AutoNode also scans classes and generates getters and setters (see `AutoClass`_ and `Passing Python Types in AutoNode`_ ).
* **CPython and Pybind types** - see `Annotations: Overriding CPython Types`_.
* **OmniGraph types** (see `Supported Types`_ )
* **Container types** (see `Bundles`_)
* **Events, Enums and other special types**.
This process will generate both the OGN description of the node and its attributes, and the implementation of the node compute function in Python.
How it Works
--------------------------------------------------------------------------------
AutoNode generates node signatures by extracting type annotations stored in functions and variables. In order for nodes to be generated, type annotations must be available to the decorator at initialization time. For most developers, this means using `type annotations <https://docs.python.org/3/library/typing.html>`_ for python 3, like in the example above.
Under the hood, annotation extraction is done with the python ``__annotations__`` ( `PEP 3107 <https://www.python.org/dev/peps/pep-3107/>`_ ) dictionary in every class.
.. note::
While the API will remain relatively stable, there is no current guarantee that the backend will not be changed. Some implementation details are captured in `Implementation Details`_, purely for reference.
API Details
--------------------------------------------------------------------------------
Decorators
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
``omni.graph.core`` currently exposes these autogeneration functions: ``AutoFunc()``, ``AutoClass()``. Both these functions can be used as decorators or as free function calls:
.. code-block:: python
import omni.graph.core as og
#this is convenient
@og.AutoFunc()
def say_hi() -> str:
return "hi, everybody!"
def say_hello() -> str:
return "Hello, World!"
# but this does virtually the same thing
og.AutoFunc()(say_hello)
``AutoFunc``
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Here's an example of wrapping a free function:
.. code-block:: python
import omni.graph.core as og
@og.AutoFunc()
def one_up(input : int = 0) -> str:
"""this documentation will appear in the node's help"""
return f"one up! {input + 1}"
**Note:** The type annotations really matter. Without them, AutoNode can't define node inputs and outputs.
You can create multiple returns by making your return type a `typing.Tuple`:
.. code-block:: python
import omni.graph.core as og
from typing import Tuple
@og.AutoFunc()
def break_vector(input : og.Float3) -> Tuple[og.Float, og.Float, og.Float]
return (input[0], input[1], input[2])
``AutoClass``
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
This exposes entire classes to OGN. Here are the rules of evaluation:
* Private properties and methods (starting with ``_``) will not be exposed
* Public properties exposed will attempt to find a type annotation using ``__annotations__`` and will default to the inferred type. ``None`` types will be ignored.
* Public methods will be associated with the class type, and will not attempt to find a type for ``self``.
* Bound methods in classes (methods with an immutable ``__self__`` reference) will be stored for representation, but the actual method to be called will come from the specific instance that's being applied for this. For instance - if class ``A`` was decorated with ``AutoClass``, and it contained a method ``A.Method(self, arg: int)->str``, with ``__self__`` stored in the method ("bound method"), then when a class ``B`` with an overriding method gets called on this node, the node will search for inside ``B.Method`` and call it instead.
Here is a simple case of wrapping a class:
.. code-block:: python
import omni.graph.core as og
@og.AutoClass(module_name="AutoNodeDemo")
class TestClass:
#this will not generate getters and setters
_private_var = 42
#this will generate getters and setters, and will make them of type ``float``
public_var: float = 3.141
# initializers are private methods and will not be exposed by the decorator
def __init__(self):
pass
def public_method(self, exponent: float) -> float:
"""this method will be exposed into OmniGraph, along with its'
documentation here. The function signature is necessary on every
argument except for ``self``, which is implied."""
return self.public_var ** exponent
This results in the following menu and implementation:
.. image:: images/Autoclass01.png
.. image:: images/Autoclass02.png
Note that getters and setters take in a ``target`` variable. This allows users to pass in a reference to an existing class. See `Passing Python Types in AutoNode`_ for more details.
Decorator Parameters
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
``pure``
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Boolean. Setting ``@og.AutoFunc(pure=True)`` will generate a method that can be used in a push or execute context, without an execution input or output. ``AutoFunc`` only.
For example, these two functions:
.. code-block:: python
import omni.graph.core as og
@og.AutoFunc(pure=True)
def dot(vec1: og.Float3, vec2: og.Float3) -> float:
return vec1[0] * vec2[0] + vec1[1] * vec2[1] + vec1[2] * vec2[2]
@og.AutoFunc()
def exec_dot(vec1: og.Float3, vec2: og.Float3) -> float:
return vec1[0] * vec2[0] + vec1[1] * vec2[1] + vec1[2] * vec2[2]
Will generate these nodes:
.. image:: images/pure.png
``module_name``
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Specifies where the node will be registered. This affects UI menus and node spawning by name. For example, setting
.. code-block:: python
import omni.graph.core as og
import MyModule
@og.AutoFunc(module_name="test_module")
def add_one(input: int) -> int:
return input + 1
og.AutoClass(module_name="test_module")(MyModule.TestClass)
Will result in a UI displaying access to this node from ``test_module``
``ui_name``
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Specifies the onscreen name of the function. ``AutoFunc`` only.
``annotation``
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
See `Annotations: Overriding CPython Types`_.
``tags``
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Array of text tags to be added to the node.
``metadata``
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Other metadata to pass through AutoNode, such as icon information.
Supported Types
--------------------------------------------------------------------------------
Currently, this is the list of types supported by AutoNode:
.. code-block:: python
import omni.graph.core as og
# Generic Vectors
[og.Vector3d, og.Vector3h, og.Vector3f]
# Scalar and Vector types
[og.Float, og.Float2, og.Float3, og.Float4]
[og.Half, og.Half2, og.Half3, og.Half4]
[og.Double, og.Double2, og.Double3, og.Double4]
[og.Int, og.Int2, og.Int3, og.Int4]
# Matrix Types
[og.Matrix2d, og.Matrix3d, og.Matrix4d]
# Vector Types with roles
[og.Normal3d, og.Normal3f, og.Normal3h]
[og.Point3d, og.Point3f, og.Point3h]
[og.Quatd, og.Quatf, og.Quath]
[og.TexCoord2d, og.TexCoord2f, og.TexCoord2h]
[og.TexCoord3d, og.TexCoord3f, og.TexCoord3h]
[og.Color3d, og.Color3f, og.Color3h, og.Color4d, og.Color4f, og.Color4h]
# Specialty Types
[og.Timecode, og.Uint, og.Uchar, og.Token]
# Underspecified, but accepted types
# str, int, float
.. note::
Not all `python typing <https://docs.python.org/3/library/typing.html>`_ types are supported.
.. _Bundles:
``Bundle`` Types : The Omniverse struct
+++++++++++++++++++++++++++++++++++++++
Since most of Omniverse's computations require concrete numerical types - matrices, vectors, numbers with known precision - it makes sense to have a data structure to pass them in together - and to make that data structure GPU-friendly. ``Bundle`` serves that purpose - it's a lightweight data structure which contains information about the types it holds.
``Bundle`` can be passed around between nodes in OmniGraph without special handling. Here is one example:
.. code-block:: python
import omni.graph.core as og
@og.AutoFunc(pure=True)
def pack(v: og.Float3, c: og.Color3f) -> og.Bundle:
bundle = og.Bundle("return", False)
bundle.create_attribute("vec", og.Float3).value = v
bundle.create_attribute("col", og.Color3f).value = c
return bundle
@og.AutoFunc(pure=True)
def unpack_vector(bundle: og.Bundle) -> og.Float3:
vec = bundle.attribute_by_name("vec")
if vec:
return vec.value
return [0,0,0]
Will yield this:
.. image:: images/Bundle01.png
Bundles aren't just useful as ways to easily pass data structures into the graph - they're also useful within python. Passing bundles between python methods is relatively cheap, and allows all users of the data to know the exact type and size it was used in. Furthermore, usage of bundles allows OmniGraph to move data to the GPU at will.
Passing Python Types in AutoNode
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
While OmniGraph can only understand and manipulated the types listed above, any python type can be passed through OmniGraph by AutoNode.
This is done by using a special type called ``objectId``, which is used by AutoNode to keep a reference (usually a hash, but that can change, see `Implementation Details`_) to the object being passed through OmniGraph.
Any type in a method I/O that isn't recognized by AutoNode as supported by OmniGraph is automatically handled by AutoNode like this:
1. When a method signature has a type not recognized by AutoNode, AutoNode generates an ``objectId`` signature for that type in the node's ``ogn`` descriptor.
2. When a method outputs a object whose type is represented by an ``objectId`` in the output, AutoNode stores the object in a *Temporary Object Store*, a special runtime collection of python objects resident in OmniGraph memory.
3. When an input ``objectId`` is received by a method, the method requests the object from the *Temporary Object Store*. The object store is "read once" - after a single read, the object is deleted from the store. Every subsequent call will result in an error.
Special Types
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
AutoNode adds special type handlers (see `Adding Type Handlers`_) to deal with how certain types are used in practice.
Enums
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Type handlers which specialize enums are built for how enums are typically used: Switching on an Enum, like an event type.
The switch class has one exec input and one enum input, and exec outputs to match the number of enum members:
.. code-block:: python
from enum import Enum
@AutoClass()
class DogType(Enum):
SHIBA = 1
HUSKY = 2
SALUKI = 4
Results in:
.. image:: images/Enum.png
Events
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
TODO
Annotations: Overriding CPython Types
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Sometimes, importing modules created in CPython is essential. Those modules may not have a ``__annotations__`` property, so we can create it for them. Suppose the codeblocks above were defined in CPython and didn't contain annotations. Here we create a shim for them:
.. code-block:: python
import omni.graph.core as og
import MyModule
# Note that we don't need a decorator call, since the function is being passed as an argument
og.AutoFunc(annotation={
"input": int,
"return": str
})(MyModule.one_up)
Similarly, for classes:
.. code-block:: python
import omni.graph.core as og
import MyModule
# Note that members only get a type annotation, but functions get the entire annotation.
og.AutoClass( annotation={
"public_var" : float,
"public_method": {
"self": MyModule.TestClass,
"exponent": float,
"return": float}
})(MyModule.TestClass)
Customizing AutoNode
--------------------------------------------------------------------------------
Adding Type Handlers
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Types going through ``AutoClass`` are highly customizable. By default, when a class is scanned, it is run through a series of custom handlers, each of type ``AutoNodeDefinitionGenerator``. This class implements this interface:
.. code-block:: python
import omni.graph.core as og
# ================================================================================
class MyDefinitionGenerator(og.AutoNodeDefinitionGenerator):
"""Defines a property handler"""
# Fill this with the type you wish to scan
_name = "MyDefinition"
# --------------------------------------------------------------------------------
@classmethod
def generate_from_definitions(cls, new_type: type) -> Tuple[Iterable[og.AutoNodeDefinitionWrapper], Iterable[str]]:
'''This method scans the type new_type and outputs an AutoNodeDefinitionWrapper from it, representing the type,
as well as a list of members it wishes to hide from the rest of the node extraction process.
Args:
new_type: the type to analyze by attribute
Returns: a tuple of:
Iterable[AutoNodeDefinitionWrapper] - an iterable of AutoNodeDefinitionWrapper - every node wrapper that is
generated from this type.
Iterable[str] - an iterable of all members covered by this handler that other handlers should ignore.
'''
pass
The emitted ``AutoNodeDefinitionGenerator`` class has the following signature:
.. code-block:: python
import omni.graph.core as og
class MyNodeDefinitionWrapper(og.AutoNodeDefinitionWrapper):
"""Container for a single node representation consumed by the Ogn code generator.
Class is abstract and meant to be overridden. A sufficient implementation overrides these methods:
* get_ogn(self) -> Dict
* get_node_impl(self)
* get_unique_name(self) -> str
* get_module_name(self) -> str
"""
def __init__(self):
super().__init__()
# --------------------------------------------------------------------------------
def get_ogn(self) -> Dict:
"""Get the Ogn dictionary representation of the node interface.
Overrides the AutoNodeDefinitionWrapper function of the same name.
"""
return {}
# --------------------------------------------------------------------------------
def get_node_impl(self):
"""Returns the Ogn class implementing the node behavior. See the OmniGraph documentation on how to implement.
A sufficient implementation contains a staticmethod with the function: compute(db)
Overrides the AutoNodeDefinitionWrapper function of the same name.
"""
return None
# --------------------------------------------------------------------------------
def get_unique_name(self) -> str:
"""Get nodes unique name, to be saved as an accessor in the node database.
Overrides the AutoNodeDefinitionWrapper function of the same name.
Returns:
the nongled unique name
"""
return ""
# --------------------------------------------------------------------------------
def get_module_name(self) -> str:
"""Get the module this AutoNode method was defined in.
Overrides the AutoNodeDefinitionWrapper function of the same name.
Returns:
the module name
"""
return ""
For more information on node implementations requires for ``get_node_impl``, read :ref:`ogn_tutorial_complexData_py`.
Here is an example of creating an extension for ``enum`` types:
.. code-block:: python
from typing import Dict, OrderedDict, Tuple, Iterable
import omni.graph.core as og
# ================================================================================
class OgnEnumExecutionWrapper:
# We use the __init_subclass__ mechanism to execute operations on a type
def __init_subclass__(cls, target_class: type) -> None:
# __members__ are the property required for identifying an enum
cls.member_names = [name for name in target_class.__members__]
cls.value_to_name = {
getattr(target_class, name): name for name in target_class.__members__}
# --------------------------------------------------------------------------------
@classmethod
def compute(*args):
cls = args[0]
db = args[1]
# don't execute if there's no need
if not db.inputs.exec:
return True
input = db.inputs.enum
input_value = og.TypeRegistry.instance().refs.pop(input)
name = cls.value_to_name.get(input_value.value, None)
if name is not None:
out = getattr(db.outputs.attributes, name)
db.outputs.context_helper.set_attr_value(True, out)
return True
return False
# ================================================================================
class OgnEnumWrapper(og.AutoNodeDefinitionWrapper):
"""Wrapper around Enums"""
def __init__(
self,
target_class,
unique_name: str,
module_name: str,
*,
ui_name: str = None):
"""Generate a definition from a parsed enum
"""
self.target_class = target_class
self.unique_name = unique_name
self.ui_name = ui_name or target_class.__name__
self.module_name = module_name
# begin building the ogn descriptor
self.descriptor: Dict = {}
self.descriptor["uiName"] = ui_name
self.descriptor["version"] = 1
self.descriptor["language"] = "Python"
self.descriptor["description"] = f"Enum Wrapper for {self.ui_name}"
self.descriptor["inputs"] = OrderedDict({
"enum": {
"uiName": "Input",
"description": "Enum input",
"type": "uint64",
"default": 0,
"metadata": {
"python_type_desc" : self.unique_name }},
"exec": {
"uiName": "Exec",
"description": "Execution input",
"type": "execution",
"default": 0 }})
def signature(name):
return {
"description": f"Execute on {name}",
"type": "execution",
"default": 0 }
self.descriptor["outputs"] = OrderedDict({
name: signature(name) for name in self.target_class.__members__ })
# --------------------------------------------------------------------------------
def get_unique_name(self) -> str:
"""overloaded from AutoNodeDefinitionWrapper"""
return self.unique_name
# --------------------------------------------------------------------------------
def get_module_name(self) -> str:
"""overloaded from AutoNodeDefinitionWrapper"""
return self.module_name
# --------------------------------------------------------------------------------
def get_node_impl(self):
"""overloaded from AutoNodeDefinitionWrapper"""
class OgnEnumReturnType(
OgnEnumExecutionWrapper,
target_class=self.target_class):
pass
return OgnEnumReturnType
# --------------------------------------------------------------------------------
def get_ogn(self) -> Dict:
"""overloaded from AutoNodeDefinitionWrapper"""
d = {self.unique_name: self.descriptor}
return d
# ================================================================================
class EnumAutoNodeDefinitionGenerator(og.AutoNodeDefinitionGenerator):
_name = "Enum"
# --------------------------------------------------------------------------------
@classmethod
def generate_from_definitions(
cls,
target_type: type,
type_name_sanitized: str,
type_name_short: str,
module_name: str) -> Tuple[Iterable[og.AutoNodeDefinitionWrapper], Iterable[str]]:
members_covered = set()
returned_generators = set()
if hasattr(target_type, "__members__"):
ret = OgnEnumWrapper(
target_type,
unique_name=type_name_sanitized,
module_name=module_name,
ui_name=f"Switch on {type_name_short}")
members_covered.update(target_type.__members__)
returned_generators.add(ret)
return returned_generators, members_covered
# ================================================================================
# submit this to AutoNode
og.register_autonode_type_extension(og.EnumAutoNodeDefinitionGenerator)
Implementation Details
------------------------------
This information is presented for debugging purposes. *Do not rely on this information for your API*.
Name Mangling
++++++++++++++++++++++++++++++
To avoid name collisions between two nodes from different origins, OGN mangles names of functions. *If you are only using the UI to access your nodes, this shouldn't interest you*, but when accessing autogenerated nodes from code, the full node name is used.
Mangling is done according to these rules:
* Function specifiers have their ``.`` s replaced with ``__FUNC__`` as an infix, like: ``MyClass.Function -> MyClass__FUNC__Function``
* Property specifiers have their ``.`` s replaced with ``__PROP__`` as an infix, like: ``MyClass.Property -> MyClass__PROP__Property``
* Property getters and setters are suffixed as ``__GET`` and ``__SET``, like so: ``MyClass__PROP__Property__GET`` and ``MyClass__PROP__Property__SET``
* If any of those are nested inside another namespace will replace their separating dots with ``__NSP__``
Here is an example with conversions:
.. code-block:: python
import omni.graph.core as og
@og.AutoClass(module_name="test_module")
class TestClass:
class TestSubclass:
# TestClass__NSP__TestSubclass__PROP__public_var__GET
# TestClass__NSP__TestSubclass__PROP__public_var__SET
public_var: float = 3.141
# TestClass__FUNC__public_method
def public_method(self, exponent: float) -> float:
return self.public_var ** exponent
This is done in order to spawn the node with code, like so:
.. code-block:: python
import omni.graph.core as og
# This brings up `add_one` from the example above.
path_01 = '/Test/MyNodes/AddOne'
add_one = og.Controller.create_node(path_01, 'test_module.add_one')
# This brings up `TestClass.public_method` from the example above.
path_02 = '/Test/MyNodes/TestClassGetPublicMethod'
public_method = og.Controller.create_node(path_02, 'test_module.TestClass__FUNC__public_method')
path_03 = '/Test/MyNodes/TestClassGetPublicMethod'
public_var_getter = og.Controller.create_node(path_03, 'test_module.TestClass__NSP__TestSubclass__PROP__public_var__GET')
| 25,343 |
reStructuredText
| 37.516717 | 539 | 0.568402 |
omniverse-code/kit/exts/omni.graph/docs/running_one_script.rst
|
.. _run_omnigraph_python_script:
Running Minimal Kit With OmniGraph
==================================
The Kit application at its core is a basic framework from plugging in extensions with a common communication method.
We can take advantage of this to run a script that works with OmniGraph without pulling in the entire Kit overhead.
Running With Python Support
---------------------------
The most user-friendly approach to running a minimal version of Kit with OmniGraph is to make use of the `omni.graph`
extension, which adds Python bindings and scripts to the OmniGraph core.
Your extension must have a dependency on `omni.graph` using these lines in your `extension.toml` file:
.. code-block:: toml
[dependencies]
"omni.graph" = {}
Let's say your extension, `omni.my.extension`, has a single node type `MyNodeType` that when executed will take a
directory path name as input and will print out the number of files and total file size of every file in that
directory. This is a script that will set up and execute an OmniGraph that creates a node that will display that
information for the Omniverse Cache directory.
.. code-block:: Python
import carb
import omni.graph.core as og
import omni.usd
# This is needed to initialize the OmniGraph backing
omni.usd.get_context().new_stage()
# Get the cache directory to be examined
cache_directory = carb.tokens.get_tokens_interface().resolve("${omni_cache}")
# Create a graph with the node that will print out the cache directory contents
_ = og.Controller.edit("/CacheGraph", {
og.Controller.Keys.CREATE_NODES: ("MyNode", "omni.my.extension.MyNodeType"),
og.Controller.Keys.SET_VALUES: ("MyNode.inputs:directory", cache_directory)
})
# Evaluate the node to complete the operation
og.Controller.evaluate_sync()
If this script is saved in the file `showCache.py` then you run this from your Kit executable directory:
.. code-block:: sh
$ ./kit.exe --enable omni.my.extension --exec showCache.py
C:/Kit/cache contained 123 files with a total size of 456,789 bytes
.. note::
Running with only `omni.graph` enabled will work, but it is just a framework and has no nodes of its own to
execute. That is why you must enable your own extension. You might also want to enable other extensions such as
`omni.graph.nodes` or `omni.graph.action` if you want to access the standard set of OmniGraph nodes.
Running With Just The Core
--------------------------
If you have an extension that uses the C++ ABI to create and manipulate an OmniGraph you can run Kit with only
your extension enabled, executing a script that will trigger the code you wish to execute.
Your extension must have a dependency on `omni.graph.core` using these lines in your `extension.toml` file:
.. code-block:: toml
[dependencies]
"omni.graph.core" = {}
You can then run your own script `setUpOmniGraphAndEvaluate.py` that executes your C++ code to create and evaluate the
graph in a way similar to the above, but using the C++ ABI, with the same command line:
.. code-block:: sh
$ ./kit.exe --enable omni.my.extension --exec setUpOmniGraphAndEvaluate.py
| 3,199 |
reStructuredText
| 39.506329 | 118 | 0.723038 |
omniverse-code/kit/exts/omni.graph/docs/controller.rst
|
.. _omnigraph_controller_class:
OmniGraph Controller Class
==========================
.. _howto_omnigraph_controller:
The primary interface you can use for interacting with OmniGraph is the `Controller` class. It is in the main module
so you can access it like this:
.. code-block:: python
import omni.graph.core as og
keys = og.Controller.Keys
controller = og.Controller()
.. note::
For future examples these two lines will be assumed to be present.
Structure
---------
The `Controller` class is an amalgam of several other classes with specific subsets of functionality. It derives from
each of them, so that all of their functionality can be accessed through the one `Controller` class.
- **GraphController** handles operations that affect the structure of the graph
- **NodeController** handles operations that affect individual nodes
- **ObjectLookup** provides a generic set of interfaces for finding OmniGraph objects with a flexible set of inputs
- **DataView** lets you get and set attribute values
For the most part the controller functions can be accessed as static class members:
.. code-block:: python
og.Controller.edit("/World/MyGraph", {keys.CREATE_NODES: ("MyNode", "omni.graph.tutorials.SimpleData")})
og.Controller.edit("/World/MyGraph", {keys.SET_VALUES: ("/World/MyGraph/MyNode.inputs:a_bool", False)})
A second way to do it is to instantiate the controller so that the relative paths are all remembered:
.. code-block:: python
controller.edit("/World/MyGraph", {keys.CREATE_NODES: ("MyNode", "omni.graph.tutorials.SimpleData")})
controller.edit("/World/MyGraph", {keys.SET_VALUES: ("MyNode.inputs:a_bool", False)})
Or you can remember the return values of the first call yourself and reuse them:
.. code-block:: python
(graph, nodes, _, _) = og.Controller.edit("/World/MyGraph", {keys.CREATE_NODES: ("MyNode", "omni.graph.tutorials.SimpleData")})
og.Controller.edit(graph, {keys.SET_VALUES: (("inputs:a_bool", nodes[0]), False))
The exceptions are when using the :py:class:`omni.graph.core.DataView` functions, as that class requires an attribute
in order to perform its operations. For those you can pass an `Attribute` or `AttributeValue` identifier to construct
a controller that can handle those operations:
.. code-block:: python
controller = og.Controller(og.Controller.attribute("/World/MyGraph/MyNode.inputs:myInput"))
print(f"My attribute value is {controller.get()}")
.. literalinclude:: ../../../../source/extensions/omni.graph/python/_impl/controller.py
:language: python
:start-after: begin-controller-docs
:end-before: end-controller-docs
Controller Functions
--------------------
In addition to the functions inherited from the other classes the `Controller` has a couple of key functions itself.
There is a coroutine to evaluate one or more graphs:
.. code-block:: python
async def my_function():
await og.Controller.evaluate()
The :py:meth:`evaluate()<omni.graph.core.Controller.evaluate>` method takes an optional parameter
with a graph or list of graphs to be evaluated. By default it evaluates all graphs in the scene.
If you want to evaluate but are not in a coroutine then you can use the synchronous version `evaluate_sync()`
.. code-block:: python
def my_normal_function():
og.Controller.evaluate_sync()
The :py:meth:`evaluate_sync()<omni.graph.core.Controller.evaluate_sync>` method also takes an optional parameter
with a graph or list of graphs to be evaluated. By default it evaluates all graphs in the scene.
The workhorse of the controller class is the :py:meth:`edit()<omni.graph.core.Controller.edit>` method. It provides
simple access to a lot of the underlying functionality for manipulating the contents of OmniGraph.
It should be noted here that this method can be accessed as both a class method and an object method. The reason you
would create an instance of a `Controller` object is if you wish to preserve the internal mapping of node names to
instantiated node paths for future use.
For example, this code sequence could be used to create a node and then set a value on one of its attributes:
.. code-block:: python
og.Controller.edit("/World/PushGraph",
{
og.Controller.Keys.CREATE_NODES: ("NewNode", "omni.graph.nodes.Add"),
og.Controller.Keys.SET_VALUES: ("NewNode.inputs:a", {"type": "float", "value": 1.0})
}
)
In this example the extended version of value setting is used, where both the type and value are provided so that
the extended attribute type in `omni.graph.nodes.Add` can resolve its type.
ObjectLookup
------------
This class contains the functions you will probably use the most. It provides an extremely flexible method for looking
up OmniGraph objects from the information you have on hand. The specs it accepts as arguments can be seen in the
:py:class:`class documentation<omni.graph.core.ObjectLookup>`.
Here's a quick summary of the most useful methods on this class:
- :py:meth:`graph()<omni.graph.core.ObjectLookup.graph>` gets an **og.Graph** object
- :py:meth:`node()<omni.graph.core.ObjectLookup.node>` gets an **og.Node** object
- :py:meth:`attribute()<omni.graph.core.ObjectLookup.attribute>` gets an **og.Attribute** object
- :py:meth:`attribute_type()<omni.graph.core.ObjectLookup.attribute_type>` gets an **og.Type** object
- :py:meth:`node_type()<omni.graph.core.ObjectLookup.node_type>` gets an **og.NodeType** object
- :py:meth:`prim()<omni.graph.core.ObjectLookup.prim>` gets a **Usd.Prim** object
- :py:meth:`usd_attribute()<omni.graph.core.ObjectLookup.usd_attribute>` gets a **Usd.Attribute** object
- :py:meth:`variable()<omni.graph.core.ObjectLookup.variable>` gets a **og.IVariable** object
Other methods will be added as they become useful.
GraphController
---------------
This class contains the functions that manipulate the structure of the graph, including creating a graph. The
:py:class:`class documentation<omni.graph.core.GraphController>` describe the details of what it can do.
Here's a quick summary of the most useful methods in the class. All but the last of them can be accessed through
different keywords in the dictionary passed to :py:meth:`og.Controller.edit()<omni.graph.core.Controller.edit>`.
- :py:meth:`create_graph()<omni.graph.core.GraphController.create_graph>` creates a new **og.Graph**
- :py:meth:`create_node()<omni.graph.core.GraphController.create_node>` creates a new **og.Node**
- :py:meth:`create_prim()<omni.graph.core.GraphController.create_prim>` creates a new **Usd.Prim**
- :py:meth:`create_variable()<omni.graph.core.GraphController.create_variable>` creates a new **og.IVariable**
- :py:meth:`delete_node()<omni.graph.core.GraphController.delete_node>` deletes an existing **og.Node**
- :py:meth:`expose_prim()<omni.graph.core.GraphController.expose_prim>` makes a **Usd.Prim** visible to OmniGraph through a read node
- :py:meth:`connect()<omni.graph.core.GraphController.connect>` connects two **og.Attributes** together
- :py:meth:`disconnect()<omni.graph.core.GraphController.disconnect>` breaks an existing connection between two **og.Attributes**
- :py:meth:`disconnect_all()<omni.graph.core.GraphController.disconnect_all>` disconnects everything from an existing **og.Attribute**
- :py:meth:`set_variable_default_value()<omni.graph.core.GraphController.set_variable_default_value>` sets the default value of an **og.IVariable**
- :py:meth:`get_variable_default_value()<omni.graph.core.GraphController.get_variable_default_value>` gets the default value of an **og.IVariable**
NodeController
--------------
This class contains the functions that manipulate the contents of a node. It only has a few functions. The
:py:class:`class documentation<omni.graph.core.NodeController>` outlines its areas of control.
Here's a quick summary of the most useful methods in the class:
- :py:meth:`create_attribute()<omni.graph.core.NodeController.create_attribute>` creates a new dynamic **og.Attribute**
- :py:meth:`remove_attribute()<omni.graph.core.NodeController.remove_attribute>` removes an existing dynamic **og.Attribute**
- :py:meth:`safe_node_name()<omni.graph.core.NodeController.safe_node_name>` returns a node name based on an **og.NodeType** that is USD-safe
.. note::
A **dynamic** attribute in this context means an attribute that can be added to the node that does not exist in the
node's .ogn file.
DataView
--------
This class contains the functions to get and set attribute values. It has a flexible **__init__** function that can
optionally take an "attribute" parameter to specify either an **og.Attribute** or **og.AttributeData** to which the
data operations will apply. The :py:class:`class documentation<omni.graph.core.DataView>` shows the available
functionality.
Here's a quick summary of the most useful methods in the class:
- :py:meth:`get()<omni.graph.core.DataView.get>` gets the current value of the attribute
- :py:meth:`get_array_size()<omni.graph.core.DataView.get_array_size>` gets the number of elements in an array attribute
- :py:meth:`set()<omni.graph.core.DataView.set>` sets a new value on the attribute
All of these methods are set up to work either as class methods or as object methods. The difference is that when
called as a class method you have add an extra parameter at the beginning that is the attribute whose value is being
processed.
These two calls, for example, are equivalent:
.. code-block:: python
attribute = og.Controller.attribute("/World/PushGraph/Add:inputs:a")
# As a class method
value = og.DataView.get(attribute)
# or value = og.Controller.get(attribute)
# As an object method
value = og.DataView(attribute=attribute).get()
# or value = og.Controller(attribute=attribute).get()
| 9,827 |
reStructuredText
| 47.653465 | 147 | 0.741935 |
omniverse-code/kit/exts/omni.graph/docs/omni.graph.core.bindings.rst
|
omni.graph.core.bindings
========================
All of the OmniGraph ABI interfaces have Python bindings on top of them, as well as additional bindings that provide
convenient Pythonic access to some of the data.
See the full description in the :ref:`Python API<omnigraph_python_api>`
| 289 |
reStructuredText
| 35.249996 | 116 | 0.733564 |
omniverse-code/kit/exts/omni.graph/docs/commands.rst
|
OmniGraph Commands
==================
Like other extensions, the OmniGraph extensions expose undoable functionality through some basic commands. A lot
of the functionality of the commands can be accessed from the *og.Controller* object, described above.
OmniGraph has created a shortcut to allow more natural expression of command execution. The raw method of executing a
command is something like this:
.. code-block:: python
import omni.graph.core as og
graph = og.get_graph_by_path("/World/PushGraph")
omni.kit.commands.execute("CreateNode", graph=graph, node_path="/World/PushGraph/TestSingleton", node_type="omni.graph.examples.python.TestSingleton", create_usd=True)
The abbreviated method, using the constructed *cmds* object looks like this:
.. code-block:: python
import omni.graph.core as og
graph = og.get_graph_by_path("/World/PushGraph")
cmds.CreateNode(graph=graph, node_path="/World/PushGraph/TestSingleton", node_type="omni.graph.examples.python.TestSingleton", create_usd=True)
However for most operations you would use the controller class, which is a single line:
.. code-block:: python
import omni.graph.core as og
og.Controller.edit("/World/PushGraph", {
og.Controller.Keys.CREATE_NODES: ("TestSingleton", "omni.graph.examples.python.TestSingleton")
})
.. tip::
Running the Python command *help(omni.graph.core.cmds)* in the script editor will give you a description of
all available commands.
| 1,479 |
reStructuredText
| 38.999999 | 171 | 0.745098 |
omniverse-code/kit/exts/omni.graph/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.50.2] - 2023-02-14
### Fixed
- Made test file pattern account for node files not beginning with Ogn
## [1.50.1] - 2022-11-22
### Added
- Documentation for running a minimal Kit with OmniGraph
## [1.50.0] - 2022-11-15
### Changed
- Default simple dynamic attribute values to the CPU
## [1.49.0] - 2022-11-14
### Added
- instance_path argument added to IVariable.get, get_array and set methods to specify the instance of the variable
- node_type.get_path(), which returns the path to the prim associated with a node type
## [1.48.0] - 2022-11-09
### Added
- Support for redirecting dynamic attributes to the GPU
## [1.47.1] - 2022-10-18
### Fixed
- Corrected the path to the default category files
## [1.47.0] - 2022-09-28
### Changed
- Refactored controller classes to accept variable arguments in all methods and constructor
### Removed
- References to obsolete set of unsupported types
- Last remaining references to the obsolete ContextHelper
### Added
- Argument flattening utility
## [1.46.0] - 2022-09-27
### Added
- Collection of registration and deregistration timing for Python node types
## [1.45.2] - 2022-09-01
### Fixed
- Fixed the type name access in the node controller to handle bundles properly
## [1.45.1] - 2022-08-31
### Fixed
- Refactored out use of a deprecated class
## [1.45.0] - 2022-08-30
### Added
- Handling for allocation of memory and transfer of values for Python default values
## [1.44.0] - 2022-08-25
### Added
- Access to new setting that turns deprecations into errors
## [1.43.0] - 2022-08-17
### Added
- Cross-handling of array and non-array types when compatible
## [1.42.0] - 2022-08-12
### Changed
- og.AttributeData now raise exceptions for errors instead of printing
## [1.41.1] - 2022-08-09
### Fixed
- All of the lint errors reported on the Python files in this extension
## [1.41.0] - 2022-08-02
### Added
- Optimize attribute setting from python nodes - during runtime computation we skip commands (no need for undo)
## [1.40.0] - 2022-07-27
### Added
- IBundle2 remove_attributes_by_name, remove_child_bundles_by_name
## [1.39.0] - 2022-07-27
### Changed
- Added better __repr__ to Attribute and Node
## [1.38.1] - 2022-07-26
### Fixed
- Adjusted config to avoid obsolete commands module
- Added firewall protection to AutoFunc and AutoClass initialization so that they work in the script editor
## [1.38.0] - 2022-07-19
### Added
- IBundle2 interface API review
## [1.37.0] - 2022-07-12
### Added
- Python performance: database caching, prefetch and commit for batching of simple attribute reads/writes
## [1.36.0] - 2022-07-12
### Fixed
- Backward compatibility of the generated attribute descriptions.
## [1.35.0] - 2022-07-08
### Added
- omni.graph.core.Attribute.is_deprecated()
- omni.graph.core.Attribute.deprecation_message()
- omni.graph.core.Internal sub-module
- omni.graph.core.Internal._deprecateAttribute()
## [1.34.0] - 2022-07-07
### Changed
- Refactored imports from omni.graph.tools to get the new locations
- Moved node_generator/ into the _impl/ subdirectory
- Made dunder attribute names in AttributeDataValueHelper into single-underscore to avoid Python compatibility problem
### Added
- Test for public API consistency
## [1.33.0] - 2022-07-06
### Added
- Metadata support for IBundle2 interface
## [1.32.3] - 2022-07-04
### Fixed
- Py_GraphContext's __eq__ and __hash__ now use the underlying GraphContext object rather than the Python wrapper
## [1.32.2] - 2022-06-28
### Changed
- Made node type failure a more actionable error
- Bootstrap the nodeContextHandle to allow independent database creation
### Added
- Linked docs in the build area
## [1.32.1] - 2022-06-26
### Changed
- Made node type failure a more actionable error
## [1.32.0] - 2022-06-26
### Added
- Added test for clearing bundle contents
## [1.31.1] - 2022-06-21
### Changed
- Fixed error in graph_settings when loading non-schema prims
## [1.31.0] - 2022-06-17
### Added
- omni.graph.core.graph.get_evaluator_name()
## [1.30.1] - 2022-06-17
### Added
- Added ApplyOmniGraph and RemoveOmniGraph api commands
## [1.30.0] - 2022-06-13
### Added
- omni.graph.core.GraphEvaluationMode enum
- evaluation_mode argument added to omni.graph.core.Graph.create_graph_as_node
- evaluation_mode property added to omni.graph.core.Graph
- SetEvaluationModeCommand
- evaluation_mode parameter added to CreateGraphAsNodeCommand
- evaluation_mode option added to GraphController
## [1.29.0] - 2022-06-13
### Added
- Temporary binding function to prevent Python node initialization from overwriting values already set
## [1.28.0] - 2022-06-07
### Added
- Added CPU-GPU pointer support in data_view class and propagation of the state through python wrapper classes
## [1.27.0] - 2022-06-07
### Added
- Support for the generator settings to complement runtime settings
## [1.26.1] - 2022-06-04
### Fixed
- Nodes with invalid connections no longer break upgrades to OmniGraph schema
## [1.26.0] - 2022-05-06
### Fixed
- Handling of runtime attributes whose bundle uses CPU to GPU pointers
### Added
- Support for CPU to GPU data in the DataWrapper
## [1.25.0] - 2022-05-05
### Removed
- Python subscriptions to changes in settings, now handled in C++
## [1.24.1] - 2022-05-05
### Deprecated
- Deprecated OmniGraphHelper and ContextHelper for og.Controller
## [1.24.0] - 2022-04-29
### Fixed
- Fixed override method for IPythonNode type
### Removed
- Obsolete example files
### Added
- Explicit settings handler
### Changed
- Used explicit OmniGraph test handler base classes
## [1.24.0] - 2022-04-27
### Added
- *GraphController.set_variable_default_value*
- *GraphController.get_variable_default_value*
- *ObjectLookup.variable*
- *GraphContext.get_graph_target*
## [1.23.0] - 2022-04-25
### Added
- Added a test to confirm that all version references in omni.graph.* match
## [1.22.2] - 2022-04-20
### Fixed
- Undoing the deletion of a connection's src prim will now restore the connection on undo.
## [1.22.1] - 2022-04-18
### Changed
- og.Attribute will now raise an exception when methods are called when in an invalid state.
## [1.22.0] - 2022-04-11
### Fixed
- Moved Py_Node and Py_Graph callback lists to static storage where they won't
be destroyed prematurely.
- Callback objects now get destroyed when the extension is unloaded.
## [1.21.1] - 2022-04-05
### Fixed
- Added hash check to avoid overwriting ogn/tests/__init__.py when it hasn't changed
- Fix deprecated generator of ogn/tests/__init__.py to generate a safer, non-changing version
## [1.21.0] - 2022-03-31
### Added
- `IConstBundle2`, `IBundle2` and `IBundleFactory` interface python bindings.
- Unit tests for bundle interfaces
## [1.20.1] - 2022-03-24
### Fixed
- Fixed location of live-generation of USD files from .ogn
- Fixed contents of the generated tests/__init__.py file
### [1.20.0] - 2022-03-23
### Added
- *GraphEvent.CREATE_VARIABLE* and *GraphEvent.REMOVE_VARIABLE* event types
- *Graph.get_event_stream()*
## [1.19.0] - 2022-03-18
### Added
- Added command to set variable tooltip
## [1.18.0] - 2022-03-16
### Added
- support for *enableLegacyPrimConnection* setting to test utils
## [1.17.1] - 2022-03-14
### Fixed
- Corrected creation of implicit graphs that were not at the root path
- Added tests for such graphs and a graph in a layer
## [1.17.0] - 2022-03-11
### Added
- *Node.get_backing_bucket_id()*
- *GraphContext.write_bucket_to_backing()*
## [1.16.0] - 2022-03-01
### Added
- *expected_error.ExpectedError* (moved from omni.graph.test)
### Changed
- Updated OmniGraphTestCase and derived classes to use *test_case_class*
## [1.15.0] - 2022-02-16
### Added
- Added commands to create and remove variables
## [1.14.0] - 2022-02-11
### Added
- *Attribute.register_value_changed_callback*
- *Database.get_variable*
- *Database.set_variable*
- *Controller.keys.CREATE_VARIABLES*
- *GraphController.create_variable*
## [1.13.0] - 2022-02-10
### Added
- Added support for migration of old graphs to use schema prims
## [1.12.2] - 2022-02-07
### Changed
- Moved carb logging out of database.py and into Node::logComputeMessage.
- Fall back to old localized logging for Python nodes which don't yet
support the compute message logging ABI.
## [1.12.1] - 2022-02-04
### Fixed
- Compute counts weren't working for Python nodes
- Compute messages from Python nodes weren't visible in the graph editors
## [1.12.0] - 2022-01-28
### Added
- Support for WritePrim creation in *GraphController.expose_prims*
## [1.11.0] - 2022-01-29
### Changed
- Reflecting change of omni.graph.core from 2.11 -> 2.12
## [1.10.0] - 2022-01-27
### Added
- *ObjectLookup.usd_attribute*
## [1.9.0] - 2022-01-21
### Added
- *Node.log_compute_message*
- *Node.get_compute_messages*
- *Node.clear_old_compute_messages*
- *Graph.register_error_status_change_callback*
- *Graph.deregister_error_status_change_callback*
- *Severity* enum
## [1.8.0] - 2021-12-17
### Added
- Added *NodeType.get_all_categories_*
- Added *get_node_categories_interface*
- Created binding class *NodeCategories*
## [1.7.0] - 2021-12-15
### Added
- Added _NodeType::isValid_ and cast to bool
- Added _Controller_ class
- Added _GraphController_ class
## [1.6.0] - 2021-12-06
### Added
- og.NodeEvent.ATTRIBUTE_TYPE_RESOLVE
## [1.5.2] - 2021-12-03
### Added
- Node, Attribute, AttributeData, Graph, and Type objects are now hashable
in Python, meaning that they can be used in sets, as keys in dicts, etc.
### Fixed
- Comparing Node and Graph objects for equality in Python now compare the
actual objects referenced rather than the wrappers which hold the references
- Comparing Attribute and AttributeData objects to None in Python no longer
generates an exception.
## [1.5.0] - 2021-12-01
- Added functions to get extension versions for core and tools
- Added cascading Python node registration process, that auto-generates when out of date
- Added user cache location for live regeneration of nodes
## [1.4.0] - 2021-11-26
### Added
- Python Api `Graph.get_parent_graph`
### Fixed
- Fix failure when disconnecting a connection from a subgraph node to the parent graph node
## [1.3.2] - 2021-11-24
### Changed
- Generated python nodes will emit info instead of warning when inputs are unresolved
## [1.3.1] - 2021-11-22
### Changed
- Improved error messages from wrapped functions
## [1.3.0] - 2021-11-19
### Added
- __bool__ operators added to all returned OG Objects. So `if node:` is equivalent to `if node.is_valid():`
### Changed
- Bug fix in Graph getter methods
## [1.2.0] - 2021-11-10
### Added
- `og.get_node_by_path`
- `get_graph_by_path`, `get_node_by_path` now return None on failure
## [1.1.0] - 2021-10-17
### Added
- og.get_graph_by_path
## [1.0.0] - 2021-10-17
### Initial Version
- Started changelog with current version of omni.graph
| 11,068 |
Markdown
| 28.128947 | 118 | 0.714583 |
omniverse-code/kit/exts/omni.graph/docs/python_api.rst
|
.. _omnigraph_python_api:
OmniGraph Python API Documentation
**********************************
.. automodule:: omni.graph.core
:platform: Windows-x86_64, Linux-x86_64, Linux-aarch64
:members:
:undoc-members:
:imported-members:
| 246 |
reStructuredText
| 21.454544 | 58 | 0.601626 |
omniverse-code/kit/exts/omni.graph/docs/README.md
|
# OmniGraph [omni.graph]
This extension provides the Python bindings, script support, data files, and other non-core support for the OmniGraph
implementation extension `omni.graph.core`.
It behaves as an addition to that extension, so you will still use the Python import path `omni.graph.core` for
scripts in this directory.
| 328 |
Markdown
| 40.124995 | 117 | 0.795732 |
omniverse-code/kit/exts/omni.graph/docs/index.rst
|
.. _omnigraph_python_scripting:
OmniGraph Python Scripting
##########################
.. tabularcolumns:: |L|R|
.. csv-table::
:width: 100%
**Extension**: omni.graph,**Documentation Generated**: |today|
While the core part of OmniGraph is built in C++ there are Python bindings and scripts built on top of it to make
it easier to work with.
Importing
---------
The Python interface is exposed in a consistent way so that you can easily find any of the OmniGraph scripting
information. Any script can start with this simple import, in the spirit of how popular packages such as `numpy`
and `pandas` work:
.. code-block:: python
import omni.graph.core as og
Using this module you can access internal documentation through the usual Python mechanisms:
.. code-block:: python
help(og)
Bindings
--------
The first level of support is the :doc:`Python Bindings<omni.graph.core.bindings>` which provide a wrapper on top of the
C++ ABI of the OmniGraph core. These have been made available from the same import to make user of all OmniGraph
functionality consistent. When you are programming in Python you really don't need to be aware of the C++
underpinnings.
The bound functions have all of the same documentation available at runtime so they can be inspected in the same way
you would work with any regular Pythyon scripts. For the most part the bindings follow the C++ ABI closely, with the
minor exception of using the standard PEP8 naming conventions rather than the established C++ naming conventions.
For example a C++ ABI function `getAttributeType` will be named `get_attribute_type` in the Python binding. This was
primarily done to deemphasize the boundary between Python and C++ so that Python writers can stick with Python
conventions and C++ writers can stick with C++ conventions.
As the Python world doesn't have the C++ concept of an interface definition there is no separation between the
objects providing the functionality and the objects storing the implementation and data. For example in C++ you
would have an `AttributeObj` which contains a handle to the internal data and a reference to the `IAttribute`
interface definition. In Python you only have the `og.Attribute` object which encapsulates both.
You can see the online version of the Python documentation at :ref:`omnigraph_python_api`.
The One Thing You Need
----------------------
A lot of the imported submodules and functions available are used internally by generated code and you won't have
much occasion to use them. You can explore the internal documentation to see if any look useful to you. The naming
was intentionally made verbose so that it's easier to discover functionality.
.. _ogn_omnigraph_controller:
One class deserves special attention though, as it is quite useful for interacting with the OmniGraph.
.. code-block:: python
import omni.graph.core as og
controller = og.Controller()
The `Controller` class provides functionality for you to change the graph topology, or modify and inspect
values within the graph.
.. literalinclude:: ../python/_impl/controller.py
:language: python
:start-after: begin-controller-docs
:end-before: end-controller-docs
See the internal documentation at :py:class:`omni.graph.core.Controller` for details, or take a tour of how to use
the controller with :ref:`this how-to documentation<howto_omnigraph_controller>`
.. toctree::
:maxdepth: 1
:caption: Contents
OmniGraph Commands <commands>
How-To Guides<../../omni.graph.core/docs/how_to.rst>
running_one_script
Python API <python_api>
omni.graph.core.bindings
autonode
How versions are updated <../../omni.graph.core/docs/versioning>
controller
runtimeInitialize
testing
CHANGELOG
| 3,775 |
reStructuredText
| 37.141414 | 120 | 0.753113 |
omniverse-code/kit/exts/omni.kit.actions.core/omni/kit/actions/core/_kit_actions_core.pyi
|
"""pybind11 omni.kit.actions.core bindings"""
from __future__ import annotations
import omni.kit.actions.core._kit_actions_core
import typing
__all__ = [
"Action",
"IActionRegistry",
"acquire_action_registry",
"release_action_registry"
]
class Action():
"""
Abstract action base class.
"""
def __init__(self, extension_id: str, action_id: str, python_object: object, display_name: str = '', description: str = '', icon_url: str = '', tag: str = '') -> None:
"""
Create an action.
Args:
extension_id: The id of the source extension registering the action.
action_id: Id of the action, unique to the extension registering it.
python_object: The Python object called when the action is executed.
display_name: The name of the action for display purposes.
description: A brief description of what the action does.
icon_url: The URL of an image which represents the action.
tag: Arbitrary tag used to group sets of related actions.
Return:
The action that was created.
"""
def execute(self, *args, **kwargs) -> object:
"""
Execute the action.
Args:
*args: Variable length argument list which will be forwarded to execute.
**kwargs: Arbitrary keyword arguments that will be forwarded to execute.
Return:
The result of executing the action, converted to a Python object (could be None).
"""
def invalidate(self) -> None:
"""
Invalidate this action so that executing it will not do anything.
This can be called if it is no longer safe to execute the action,
and by default is called when deregistering an action (optional).
"""
@property
def description(self) -> str:
"""
Get the description of this action.
Return:
str: The description of this action.
:type: str
"""
@property
def display_name(self) -> str:
"""
Get the display name of this action.
Return:
str: The display name of this action.
:type: str
"""
@property
def extension_id(self) -> str:
"""
Get the id of the source extension which registered this action.
Return:
str: The id of the source extension which registered this action.
:type: str
"""
@property
def icon_url(self) -> str:
"""
Get the URL of the icon used to represent this action.
Return:
str: The URL of the icon used to represent this action.
:type: str
"""
@property
def id(self) -> str:
"""
Get the id of this action, unique to the extension that registered it.
Return:
str: The id of this action, unique to the extension that registered it.
:type: str
"""
@property
def parameters(self) -> dict:
"""
Get the parameters accepted by this action's execute function.
Return:
dict: The parameters accepted by this action's execute function.
:type: dict
"""
@property
def requires_parameters(self) -> bool:
"""
Query whether this action requires any parameters to be passed when executed?
Return:
bool: True if this action requires any parameters to be passed when executed, false otherwise.
:type: bool
"""
@property
def tag(self) -> str:
"""
Get the tag that this action is grouped with.
Return:
str: The tag that this action is grouped with.
:type: str
"""
pass
class IActionRegistry():
"""
Maintains a collection of all registered actions and allows any extension to discover them.
"""
@staticmethod
def deregister_action(*args, **kwargs) -> typing.Any:
"""
Deregister an action.
Args:
action: The action to deregister.
invalidate: Should the action be invalidated so executing does nothing?
Find and deregister an action.
Args:
extension_id: The id of the source extension that registered the action.
action_id: Id of the action, unique to the extension that registered it.
invalidate: Should the action be invalidated so executing does nothing?
Return:
The action if it exists and was deregistered, an empty object otherwise.
"""
def deregister_all_actions_for_extension(self, extension_id: str, invalidate: bool = True) -> None:
"""
"Deregister all actions that were registered by the specified extension.
Args:
extension_id: The id of the source extension that registered the actions.
iinvalidate: Should the actions be invalidated so executing does nothing?
"""
def execute_action(self, extension_id: str, action_id: str, *args, **kwargs) -> object:
"""
Find and execute an action.
Args:
extension_id: The id of the source extension that registered the action.
action_id: Id of the action, unique to the extension that registered it.
*args: Variable length argument list which will be forwarded to execute.
**kwargs: Arbitrary keyword arguments that will be forwarded to execute.
Return:
The result of executing the action, which is an arbitrary Python object
that could be None (will also return None if the action was not found).
"""
@staticmethod
def get_action(*args, **kwargs) -> typing.Any:
"""
Get an action.
Args:
extension_id: The id of the source extension that registered the action.
action_id: Id of the action, unique to the extension that registered it.
Return:
The action if it exists, an empty object otherwise.
"""
@staticmethod
def get_all_actions(*args, **kwargs) -> typing.Any:
"""
Get all registered actions.
Return:
All registered actions.
"""
@staticmethod
def get_all_actions_for_extension(*args, **kwargs) -> typing.Any:
"""
Get all actions that were registered by the specified extension.
Args:
extension_id: The id of the source extension that registered the actions.
Return:
All actions that were registered by the specified extension.
"""
@staticmethod
def register_action(*args, **kwargs) -> typing.Any:
"""
Register an action.
Args:
action: The action to register.
Create and register an action.
Args:
extension_id: The id of the source extension registering the action.
action_id: Id of the action, unique to the extension registering it.
python_object: The Python object called when the action is executed.
display_name: The name of the action for display purposes.
description: A brief description of what the action does.
icon_url: The URL of an image which represents the action.
tag: Arbitrary tag used to group sets of related actions.
Return:
The action if it was created and registered, an empty object otherwise.
"""
pass
def acquire_action_registry(plugin_name: str = None, library_path: str = None) -> IActionRegistry:
pass
def release_action_registry(arg0: IActionRegistry) -> None:
pass
| 8,190 |
unknown
| 32.161943 | 172 | 0.567521 |
omniverse-code/kit/exts/omni.kit.actions.core/omni/kit/actions/core/__init__.py
|
# Copyright (c) 2023, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
"""
Omni Kit Actions Core
---------------------
Omni Kit Actions Core is a framework for creating, registering, and discovering actions.
Here is an example of registering an action that creates a new file when it is executed:
.. code-block::
action_registry = omni.kit.actions.core.get_action_registry()
actions_tag = "File Actions"
action_registry.register_action(
extension_id,
"new",
omni.kit.window.file.new,
display_name="File->New",
description="Create a new USD stage.",
tag=actions_tag,
)
For more examples, please consult the Python and C++ Usage Example pages.
For Python API documentation, please consult the following subpages.
For C++ API documentation, please consult the API(C++) page.
"""
__all__ = ["Action", "IActionRegistry", "get_action_registry", "execute_action"]
from .actions import *
| 1,310 |
Python
| 31.774999 | 88 | 0.717557 |
omniverse-code/kit/exts/omni.kit.actions.core/omni/kit/actions/core/actions.py
|
# Copyright (c) 2023, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
import omni.ext
from ._kit_actions_core import *
# Put interface object publicly to use in our API.
_action_registry = None
# public API
def get_action_registry() -> IActionRegistry:
"""
Get the action registry.
Return:
ActionRegistry object which implements the IActionRegistry interface.
"""
return _action_registry
def execute_action(extension_id: str, action_id: str, *args, **kwargs):
"""
Find and execute an action.
Args:
extension_id: The id of the source extension that registered the action.
action_id: Id of the action, unique to the extension that registered it.
*args: Variable length argument list which will be forwarded to execute.
**kwargs: Arbitrary keyword arguments that will be forwarded to execute.
Return:
The result of executing the action, which is an arbitrary Python object
that could be None (will also return None if the action was not found).
"""
return get_action_registry().execute_action(extension_id, action_id, *args, **kwargs)
# Use extension entry points to acquire and release the interface.
class ActionsExtension(omni.ext.IExt):
def __init__(self):
super().__init__()
global _action_registry
_action_registry = acquire_action_registry()
def on_shutdown(self):
global _action_registry
release_action_registry(_action_registry)
_action_registry = None
| 1,884 |
Python
| 33.272727 | 89 | 0.710722 |
omniverse-code/kit/exts/omni.kit.actions.core/omni/kit/actions/core/tests/test_actions.py
|
# Copyright (c) 2023, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
import inspect
import omni.kit.test
import omni.kit.app
import omni.kit.actions.core
from ._kit_actions_core_tests import *
_last_args = None
_last_kwargs = None
_was_called = False
_action_tests = None
_print_execution_info = False
def setUpModule():
global _action_tests
_action_tests = acquire_action_tests()
_action_tests.print_test_action_execution_info = _print_execution_info
def tearDownModule():
global _action_tests
release_action_tests(_action_tests)
_action_tests = None
def test_callable_function(*args, **kwargs):
global _last_args, _last_kwargs, _was_called, _print_execution_info
_last_args = args
_last_kwargs = kwargs
_was_called = True
if _print_execution_info:
print(f"Executed test callable function with args: {args} and kwargs: {kwargs}")
return list(_last_args)
def test_execute_callable_function_action_with_args(test_context, *args, **kwargs):
global _last_args, _last_kwargs, _was_called
_last_args = None
_last_kwargs = None
_was_called = False
result = test_context.test_callable_function_action.execute(*args, **kwargs)
test_context.assertTrue(_was_called)
test_context.assertListEqual(result, list(args))
test_context.assertListEqual(list(_last_args), list(args))
test_context.assertDictEqual(_last_kwargs, kwargs)
class TestCallableClass:
def __call__(self, *args, **kwargs):
global _print_execution_info
self.last_args = args
self.last_kwargs = kwargs
self.was_called = True
if _print_execution_info:
print(f"Executed test callable object with args: {args} and kwargs: {kwargs}")
return list(self.last_args)
def test_execute_callable_object_action_with_args(test_context, *args, **kwargs):
test_context.test_callable_object.last_args = None
test_context.test_callable_object.last_kwargs = None
test_context.test_callable_object.was_called = False
result = test_context.test_callable_object_action.execute(*args, **kwargs)
test_context.assertTrue(test_context.test_callable_object.was_called)
test_context.assertListEqual(result, list(args))
test_context.assertListEqual(list(test_context.test_callable_object.last_args), list(args))
test_context.assertDictEqual(test_context.test_callable_object.last_kwargs, kwargs)
def test_execute_lambda_action_with_args(test_context, *args, **kwargs):
result = test_context.test_lambda_action.execute(*args, **kwargs)
test_context.assertTrue(result)
def test_execute_cpp_action_with_args(test_context, *args, **kwargs):
test_context.test_cpp_action.reset_execution_count()
test_context.assertEqual(test_context.test_cpp_action.execution_count, 0)
result = test_context.test_cpp_action.execute(*args, **kwargs)
test_context.assertTrue(result)
test_context.assertEqual(test_context.test_cpp_action.execution_count, 1)
test_context.assertTrue(test_context.test_cpp_action.was_executed_with_args(*args, **kwargs))
test_context.test_cpp_action.reset_execution_count()
test_context.assertEqual(test_context.test_cpp_action.execution_count, 0)
class TestActions(omni.kit.test.AsyncTestCase):
async def setUp(self):
global _action_tests
# Cache the action tests and action registry interfaces.
self.extension_id = "omni.kit.actions.core_tests"
self.action_tests = _action_tests
self.action_registry = omni.kit.actions.core.get_action_registry()
# Register a test action that invokes a Python function.
self.test_callable_function_action = self.action_registry.register_action(
self.extension_id,
"test_callable_function",
test_callable_function,
display_name="Test Callable Function Action",
description="An action which invokes a callable Python function.",
tag="TestTag",
)
# Register a test action that invokes a Python object.
self.test_callable_object = TestCallableClass()
self.test_callable_object_action = self.action_registry.register_action(
self.extension_id,
"test_callable_object",
self.test_callable_object,
display_name="Test Callable Object Action",
description="An action which invokes a callable Python object.",
)
# Create and register a test action that invokes a C++ lambda.
self.test_lambda_action = self.action_tests.create_test_lambda_action(
self.extension_id, "test_lambda_action", "Test Lambda Action", "A lambda action which was created in C++."
)
self.action_registry.register_action(self.test_lambda_action)
# Create a test action in C++.
self.test_cpp_action = self.action_tests.create_test_cpp_action(
self.extension_id, "test_cpp_action", "Test Cpp Action", "An action which was created in C++."
)
self.action_registry.register_action(self.test_cpp_action)
async def tearDown(self):
# Deregister all the test actions.
self.action_registry.deregister_action(self.test_cpp_action)
self.action_registry.deregister_action(self.test_lambda_action)
self.action_registry.deregister_action(self.extension_id, "test_callable_object")
self.action_registry.deregister_action(self.extension_id, "test_callable_function")
# Destroy all the test actions.
self.test_cpp_action = None
self.test_lambda_action = None
self.test_callable_object = None
self.test_callable_object_action = None
self.test_callable_function_action = None
# Clear the action tests and action registry interfaces.
self.action_registry = None
self.action_tests = None
self.extension_id = None
async def test_find_registered_action(self):
action = self.action_registry.get_action(self.extension_id, "test_callable_function")
self.assertIsNotNone(action)
action = self.action_registry.get_action(self.extension_id, "test_callable_object")
self.assertIsNotNone(action)
action = self.action_registry.get_action(self.extension_id, "test_lambda_action")
self.assertIsNotNone(action)
action = self.action_registry.get_action(self.extension_id, "test_cpp_action")
self.assertIsNotNone(action)
async def test_find_unregistered_action(self):
action = self.action_registry.get_action(self.extension_id, "some_unregistered_action")
self.assertIsNone(action)
async def test_access_action_fields(self):
action = self.action_registry.get_action(self.extension_id, "test_callable_function")
self.assertEqual(action.id, "test_callable_function")
self.assertEqual(action.extension_id, self.extension_id)
self.assertEqual(action.display_name, "Test Callable Function Action")
self.assertEqual(action.description, "An action which invokes a callable Python function.")
self.assertEqual(action.icon_url, "")
self.assertEqual(action.tag, "TestTag")
async def test_get_all_actions(self):
# If any of the asserts below fail, the 'actions' list object doesn't seem to get cleaned up properly,
# resulting in a crash instead of a failed test. To protect against this we'll cache all the things we
# need to assert are valid and clear the 'actions' list object before performing any of the asserts.
actions = self.action_registry.get_all_actions()
found_registered_action_0 = (
not (next((action for action in actions if action.id == "test_callable_function"), None)) is None
)
found_registered_action_1 = (
not (next((action for action in actions if action.id == "test_callable_object"), None)) is None
)
found_registered_action_2 = (
not (next((action for action in actions if action.id == "test_lambda_action"), None)) is None
)
found_registered_action_3 = (
not (next((action for action in actions if action.id == "test_cpp_action"), None)) is None
)
found_unregistered_action = (
not (next((action for action in actions if action.id == "some_unregistered_action"), None)) is None
)
actions_length = len(actions)
actions.clear()
self.assertTrue(found_registered_action_0)
self.assertTrue(found_registered_action_1)
self.assertTrue(found_registered_action_2)
self.assertTrue(found_registered_action_3)
self.assertFalse(found_unregistered_action)
# Ideally we would assert that the number of actions found is what we expect,
# but the kit app itself registers some actions and we don't want to have to
# keep updating this test to account for those, so we won't assert for this.
# self.assertEqual(actions_length, 4)
async def test_get_all_actions_registered_by_extension(self):
# If any of the asserts below fail, the 'actions' list object doesn't seem to get cleaned up properly,
# resulting in a crash instead of a failed test. To protect against this we'll cache all the things we
# need to assert are valid and clear the 'actions' list object before performing any of the asserts.
self.action_registry.register_action("some_other_extension_id", "test_action_registered_by_another_extension", test_callable_function)
actions = self.action_registry.get_all_actions_for_extension(self.extension_id)
found_registered_action_0 = (
not (next((action for action in actions if action.id == "test_callable_function"), None)) is None
)
found_registered_action_1 = (
not (next((action for action in actions if action.id == "test_callable_object"), None)) is None
)
found_registered_action_2 = (
not (next((action for action in actions if action.id == "test_lambda_action"), None)) is None
)
found_registered_action_3 = (
not (next((action for action in actions if action.id == "test_cpp_action"), None)) is None
)
found_unregistered_action = (
not (next((action for action in actions if action.id == "some_unregistered_action"), None)) is None
)
found_action_registered_by_another_extension = (
not (next((action for action in actions if action.id == "test_action_registered_by_another_extension"), None)) is None
)
actions.clear()
self.assertTrue(found_registered_action_0)
self.assertTrue(found_registered_action_1)
self.assertTrue(found_registered_action_2)
self.assertTrue(found_registered_action_3)
self.assertFalse(found_unregistered_action)
self.assertFalse(found_action_registered_by_another_extension)
actions = self.action_registry.get_all_actions_for_extension("some_other_extension_id")
found_registered_action_0 = (
not (next((action for action in actions if action.id == "test_callable_function"), None)) is None
)
found_registered_action_1 = (
not (next((action for action in actions if action.id == "test_callable_object"), None)) is None
)
found_registered_action_2 = (
not (next((action for action in actions if action.id == "test_lambda_action"), None)) is None
)
found_registered_action_3 = (
not (next((action for action in actions if action.id == "test_cpp_action"), None)) is None
)
found_unregistered_action = (
not (next((action for action in actions if action.id == "some_unregistered_action"), None)) is None
)
found_action_registered_by_another_extension = (
not (next((action for action in actions if action.id == "test_action_registered_by_another_extension"), None)) is None
)
actions.clear()
self.assertFalse(found_registered_action_0)
self.assertFalse(found_registered_action_1)
self.assertFalse(found_registered_action_2)
self.assertFalse(found_registered_action_3)
self.assertFalse(found_unregistered_action)
self.assertTrue(found_action_registered_by_another_extension)
self.action_registry.deregister_action("some_other_extension_id", "test_action_registered_by_another_extension")
async def test_create_actions_on_registeration(self):
self.action_registry.register_action(self.extension_id, "test_python_action_created_on_registration", test_callable_function)
action = self.action_registry.get_action(self.extension_id, "test_python_action_created_on_registration")
self.assertIsNotNone(action)
self.action_tests.create_test_action_on_registrartion(self.extension_id, "test_cpp_action_created_on_registration")
action = self.action_registry.get_action(self.extension_id, "test_cpp_action_created_on_registration")
self.assertIsNotNone(action)
self.action_registry.deregister_action(self.extension_id, "test_cpp_action_created_on_registration")
action = self.action_registry.get_action(self.extension_id, "test_cpp_action_created_on_registration")
self.assertIsNone(action)
self.action_registry.deregister_action(self.extension_id, "test_python_action_created_on_registration")
action = self.action_registry.get_action(self.extension_id, "test_python_action_created_on_registration")
self.assertIsNone(action)
async def test_get_parameters(self):
def test_function():
self.assertFalse(True) # Should never be called
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
self.assertDictEqual(test_action.parameters, dict(inspect.signature(test_function).parameters))
def test_function(arg0):
self.assertFalse(True) # Should never be called
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
self.assertDictEqual(test_action.parameters, dict(inspect.signature(test_function).parameters))
def test_function(arg0, arg1):
self.assertFalse(True) # Should never be called
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
self.assertDictEqual(test_action.parameters, dict(inspect.signature(test_function).parameters))
def test_function(arg0, arg1, arg2):
self.assertFalse(True) # Should never be called
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
self.assertDictEqual(test_action.parameters, dict(inspect.signature(test_function).parameters))
def test_function(*args, **kwargs):
self.assertFalse(True) # Should never be called
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
self.assertDictEqual(test_action.parameters, dict(inspect.signature(test_function).parameters))
def test_function(arg0, *args, **kwargs):
self.assertFalse(True) # Should never be called
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
self.assertDictEqual(test_action.parameters, dict(inspect.signature(test_function).parameters))
async def test_requires_parameters(self):
def test_function():
self.assertFalse(True) # Should never be called
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
self.assertFalse(test_action.requires_parameters)
def test_function(arg0):
self.assertFalse(True) # Should never be called
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
self.assertTrue(test_action.requires_parameters)
def test_function(arg0=False):
self.assertFalse(True) # Should never be called
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
self.assertFalse(test_action.requires_parameters)
def test_function(arg0, arg1=False):
self.assertFalse(True) # Should never be called
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
self.assertTrue(test_action.requires_parameters)
def test_function(arg0=True, arg1=False):
self.assertFalse(True) # Should never be called
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
self.assertFalse(test_action.requires_parameters)
def test_function(arg0="Nine", arg1=-9, arg2=False):
self.assertFalse(True) # Should never be called
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
self.assertFalse(test_action.requires_parameters)
def test_function(*args, **kwargs):
self.assertFalse(True) # Should never be called
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
self.assertFalse(test_action.requires_parameters)
def test_function(arg0, *args, **kwargs):
self.assertFalse(True) # Should never be called
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
self.assertTrue(test_action.requires_parameters)
def test_function(arg0="Nine", *args, **kwargs):
self.assertFalse(True) # Should never be called
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
self.assertFalse(test_action.requires_parameters)
async def test_execute_callable_function_action(self):
global _last_args, _last_kwargs, _was_called
_last_args = None
_last_kwargs = None
_was_called = False
result = self.test_callable_function_action.execute()
self.assertTrue(_was_called)
self.assertFalse(result)
self.assertFalse(_last_args)
self.assertFalse(_last_kwargs)
async def test_execute_callable_object_action(self):
self.test_callable_object.last_args = None
self.test_callable_object.last_kwargs = None
self.test_callable_object.was_called = False
result = self.test_callable_object_action.execute()
self.assertTrue(self.test_callable_object.was_called)
self.assertFalse(result)
self.assertFalse(self.test_callable_object.last_args)
self.assertFalse(self.test_callable_object.last_kwargs)
async def test_execute_lambda_action(self):
result = self.test_lambda_action.execute()
self.assertTrue(result)
async def test_execute_cpp_action(self):
self.test_cpp_action.reset_execution_count()
self.assertEqual(self.test_cpp_action.execution_count, 0)
result = self.test_cpp_action.execute()
self.assertTrue(result)
self.assertEqual(self.test_cpp_action.execution_count, 1)
result = self.test_cpp_action.execute()
self.assertTrue(result)
self.assertEqual(self.test_cpp_action.execution_count, 2)
result = self.test_cpp_action.execute()
self.assertTrue(result)
self.assertEqual(self.test_cpp_action.execution_count, 3)
self.test_cpp_action.reset_execution_count()
self.assertEqual(self.test_cpp_action.execution_count, 0)
async def test_execute_action_using_id(self):
global _last_args, _last_kwargs, _was_called
_last_args = None
_last_kwargs = None
_was_called = False
result = omni.kit.actions.core.execute_action(self.extension_id, "test_callable_function")
self.assertTrue(_was_called)
self.assertFalse(result)
self.assertFalse(_last_args)
self.assertFalse(_last_kwargs)
self.test_callable_object.last_args = None
self.test_callable_object.last_kwargs = None
self.test_callable_object.was_called = False
result = omni.kit.actions.core.execute_action(self.extension_id, "test_callable_object", True, 9, "Nine")
self.assertTrue(self.test_callable_object.was_called)
self.assertListEqual(result, [True, 9, "Nine"])
self.assertListEqual(list(self.test_callable_object.last_args), [True, 9, "Nine"])
self.assertFalse(self.test_callable_object.last_kwargs)
async def test_find_and_execute_python_action_from_cpp(self):
self.test_callable_object.last_args = None
self.test_callable_object.last_kwargs = None
self.test_callable_object.was_called = False
result = self.action_tests.find_and_execute_test_action_from_cpp(self.extension_id, "test_callable_object")
self.assertTrue(self.test_callable_object.was_called)
self.assertFalse(result)
self.assertFalse(self.test_callable_object.last_args)
self.assertFalse(self.test_callable_object.last_kwargs)
async def test_find_and_execute_cpp_action_from_cpp(self):
self.test_cpp_action.reset_execution_count()
self.assertEqual(self.test_cpp_action.execution_count, 0)
result = self.action_tests.find_and_execute_test_action_from_cpp(self.extension_id, "test_cpp_action")
self.assertTrue(result)
self.assertEqual(self.test_cpp_action.execution_count, 1)
self.test_cpp_action.reset_execution_count()
self.assertEqual(self.test_cpp_action.execution_count, 0)
async def test_find_and_execute_cpp_action_from_python(self):
self.test_cpp_action.reset_execution_count()
self.assertEqual(self.test_cpp_action.execution_count, 0)
action = self.action_registry.get_action(self.extension_id, "test_cpp_action")
self.assertIsNotNone(action)
result = action.execute()
self.assertTrue(result)
self.assertEqual(self.test_cpp_action.execution_count, 1)
self.test_cpp_action.reset_execution_count()
self.assertEqual(self.test_cpp_action.execution_count, 0)
async def test_execute_action_with_return_value(self):
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", lambda x: x * x)
result = test_action.execute(9)
self.assertEqual(result, 81)
result = self.action_tests.execute_square_value_action_from_cpp(8)
self.assertEqual(result, 64)
async def test_invalidate_python_action(self):
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", lambda x: x * x)
result = test_action.execute(9)
self.assertEqual(result, 81)
test_action.invalidate()
result = test_action.execute(9)
self.assertIsNone(result)
async def test_invalidate_lambda_action(self):
test_action = self.action_tests.create_test_lambda_action(self.extension_id, "test_action", "", "")
result = test_action.execute()
self.assertTrue(result)
test_action.invalidate()
result = test_action.execute()
self.assertIsNone(result)
async def test_execute_actions_with_bool(self):
test_execute_callable_function_action_with_args(self, True)
test_execute_callable_object_action_with_args(self, True)
test_execute_lambda_action_with_args(self, True)
test_execute_cpp_action_with_args(self, True)
def test_function(arg):
self.assertTrue(arg)
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
test_action.execute(True)
self.action_tests.execute_test_action_from_cpp_with_bool(test_action, True)
async def test_execute_actions_with_int(self):
test_execute_callable_function_action_with_args(self, 9)
test_execute_callable_object_action_with_args(self, 9)
test_execute_lambda_action_with_args(self, 9)
test_execute_cpp_action_with_args(self, 9)
def test_function(arg):
self.assertEqual(arg, 9)
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
test_action.execute(9)
self.action_tests.execute_test_action_from_cpp_with_int(test_action, 9)
async def test_execute_actions_with_string(self):
test_execute_callable_function_action_with_args(self, "Nine")
test_execute_callable_object_action_with_args(self, "Nine")
test_execute_lambda_action_with_args(self, "Nine")
test_execute_cpp_action_with_args(self, "Nine")
def test_function(arg):
self.assertEqual(arg, "Nine")
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
test_action.execute("Nine")
self.action_tests.execute_test_action_from_cpp_with_string(test_action, "Nine")
async def test_execute_actions_with_multiple_args(self):
test_execute_callable_function_action_with_args(self, "Nine", 9, True)
test_execute_callable_object_action_with_args(self, "Nine", 9, True)
test_execute_lambda_action_with_args(self, "Nine", 9, True)
test_execute_cpp_action_with_args(self, "Nine", 9, True)
def test_function(arg0, arg1, arg2):
self.assertEqual(arg0, "Nine")
self.assertEqual(arg1, 9)
self.assertTrue(arg2)
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
test_action.execute("Nine", 9, True)
self.action_tests.execute_test_action_from_cpp_with_multiple_args(test_action, "Nine", 9, True)
async def test_execute_actions_with_nested_args(self):
test_nested_args = (False, 99, "Ninety-Nine")
test_execute_callable_function_action_with_args(self, "Nine", test_nested_args, 9, True)
test_execute_callable_object_action_with_args(self, "Nine", test_nested_args, 9, True)
test_execute_lambda_action_with_args(self, "Nine", test_nested_args, 9, True)
test_execute_cpp_action_with_args(self, "Nine", test_nested_args, 9, True)
def test_function(arg0, arg1, arg2, arg3):
self.assertEqual(arg0, "Nine")
self.assertListEqual(list(arg1), list(test_nested_args))
self.assertEqual(arg2, 9)
self.assertTrue(arg3)
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
test_action.execute("Nine", test_nested_args, 9, True)
async def test_execute_actions_with_keyword_args(self):
test_execute_callable_function_action_with_args(self, kwarg0="Nine", kwarg1=9, kwarg2=True)
test_execute_callable_object_action_with_args(self, kwarg0="Nine", kwarg1=9, kwarg2=True)
test_execute_lambda_action_with_args(self, kwarg0="Nine", kwarg1=9, kwarg2=True)
test_execute_cpp_action_with_args(self, kwarg0="Nine", kwarg1=9, kwarg2=True)
def test_function(kwarg0="", kwarg1=0, kwarg2=False):
self.assertEqual(kwarg0, "Nine")
self.assertEqual(kwarg1, 9)
self.assertTrue(kwarg2)
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
test_action.execute(kwarg0="Nine", kwarg1=9, kwarg2=True)
test_action.execute(kwarg2=True, kwarg1=9, kwarg0="Nine")
self.action_tests.execute_test_action_from_cpp_with_variable_args(
test_action, kwarg0="Nine", kwarg1=9, kwarg2=True
)
async def test_execute_actions_with_mixed_args(self):
test_execute_callable_function_action_with_args(
self, "Nine", 9, True, kwarg0=False, kwarg1=99, kwarg2="Ninety-Nine"
)
test_execute_callable_object_action_with_args(
self, "Nine", 9, True, kwarg0=False, kwarg1=99, kwarg2="Ninety-Nine"
)
test_execute_lambda_action_with_args(self, "Nine", 9, True, kwarg0=False, kwarg1=99, kwarg2="Ninety-Nine")
test_execute_cpp_action_with_args(self, "Nine", 9, True, kwarg0=False, kwarg1=99, kwarg2="Ninety-Nine")
def test_function(arg0, arg1, arg2, kwarg0=True, kwarg1=0, kwarg2=""):
self.assertEqual(arg0, "Nine")
self.assertEqual(arg1, 9)
self.assertTrue(arg2)
self.assertFalse(kwarg0)
self.assertEqual(kwarg1, 99)
self.assertEqual(kwarg2, "Ninety-Nine")
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
test_action.execute("Nine", 9, True, kwarg0=False, kwarg1=99, kwarg2="Ninety-Nine")
test_action.execute("Nine", 9, True, kwarg2="Ninety-Nine", kwarg1=99, kwarg0=False)
self.action_tests.execute_test_action_from_cpp_with_variable_args(
test_action, "Nine", 9, True, kwarg0=False, kwarg1=99, kwarg2="Ninety-Nine"
)
| 29,503 |
Python
| 46.055821 | 142 | 0.67644 |
omniverse-code/kit/exts/omni.kit.menu.utils/omni/kit/menu/utils/__init__.py
|
from .scripts import *
| 23 |
Python
| 10.999995 | 22 | 0.73913 |
omniverse-code/kit/exts/omni.kit.menu.utils/omni/kit/menu/utils/scripts/debug_window.py
|
import asyncio
import functools
import carb
import carb.settings
import omni.ext
import json
from omni import ui
from omni.ui import color as cl
class MenuUtilsDebugExtension(omni.ext.IExt):
def on_startup(self):
manager = omni.kit.app.get_app().get_extension_manager()
self._extension_name = omni.ext.get_extension_name(manager.get_extension_id_by_module(__name__))
self._hooks = []
self._debug_window = None
self._hooks.append(
manager.subscribe_to_extension_enable(
on_enable_fn=lambda _: self._register_actions(),
ext_name="omni.kit.actions.core",
hook_name="omni.kit.menu.utils debug omni.kit.actions.core listener",
)
)
self._hooks.append(
manager.subscribe_to_extension_enable(
on_enable_fn=lambda _: self._register_hotkeys(),
ext_name="omni.kit.hotkeys.core",
hook_name="omni.kit.menu.utils debug omni.kit.hotkeys.core listener",
)
)
def on_shutdown(self):
omni.kit.actions.core.get_action_registry().deregister_action(self._extension_name, "show_menu_debug_debug_window")
if self._debug_window:
del self._debug_window
self._debug_window = None
try:
from omni.kit.hotkeys.core import get_hotkey_registry
hotkey_registry = get_hotkey_registry()
hotkey_registry.deregister_hotkey(self._registered_hotkey)
except (ModuleNotFoundError, AttributeError):
pass
def _register_actions(self):
import omni.kit.actions.core
omni.kit.actions.core.get_action_registry().register_action(
self._extension_name,
"show_menu_debug_debug_window", lambda: self.show_menu_debug_debug_window(),
display_name="Show Menu Debug Window",
description="Show Menu Debug Window",
tag = "Menu Debug Actions"
)
def _register_hotkeys(self):
import omni.kit.hotkeys.core
from omni.kit.hotkeys.core import KeyCombination, get_hotkey_registry
hotkey_combo = KeyCombination(carb.input.KeyboardInput.M, modifiers=carb.input.KEYBOARD_MODIFIER_FLAG_CONTROL + carb.input.KEYBOARD_MODIFIER_FLAG_ALT + carb.input.KEYBOARD_MODIFIER_FLAG_SHIFT)
hotkey_registry = get_hotkey_registry()
self._registered_hotkey = hotkey_registry.register_hotkey(self._extension_name, hotkey_combo, self._extension_name, "show_menu_debug_debug_window")
def show_menu_debug_debug_window(self):
CollapsableFrame_style = {
"CollapsableFrame": {
"background_color": 0xFF343432,
"secondary_color": 0xFF343432,
"color": 0xFFAAAAAA,
"border_radius": 4.0,
"border_color": 0x0,
"border_width": 0,
"font_size": 14,
"padding": 0,
},
"HStack::header": {"margin": 5},
"CollapsableFrame:hovered": {"secondary_color": 0xFF3A3A3A},
"CollapsableFrame:pressed": {"secondary_color": 0xFF343432},
}
def show_dict_data(legend, value):
if value:
ui.Button(f"Save {legend}", clicked_fn=lambda b=None: save_dict(legend, value), height=24)
else:
ui.Button(f"Save {legend}", clicked_fn=lambda b=None: save_dict(legend, value), height=24, enabled=False)
async def refresh_debug_window(rebuild_menus):
await omni.kit.app.get_app().next_update_async()
self._debug_window.frame.clear()
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
del self._debug_window
self._debug_window = None
if rebuild_menus:
omni.kit.menu.utils.rebuild_menus()
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
self.show_menu_debug_debug_window()
def save_dict(legend, value):
from omni.kit.window.filepicker import FilePickerDialog
def on_click_save(dialog: FilePickerDialog, filename: str, dirname: str, value: dict):
dialog.hide()
dirname = dirname.strip()
if dirname and not dirname.endswith("/"):
dirname += "/"
fullpath = f"{dirname}{filename}"
def serialize(obj):
if hasattr(obj, "json_enc"):
return obj.json_enc()
elif hasattr(obj, "__dict__"):
return obj.__dict__
return {"unknown": f"{obj}"}
with open(fullpath, 'w') as file:
file.write(json.dumps(value, default=lambda obj: serialize(obj)))
dialog = FilePickerDialog(
f"Save {legend} as json",
apply_button_label="Save",
click_apply_handler=lambda filename, dirname: on_click_save(dialog, filename, dirname, value),
)
dialog.show()
self._debug_window = ui.Window("omni.kit.menu.utils debug", width=600)
with self._debug_window.frame:
with ui.VStack():
menu_instance = omni.kit.menu.utils.get_instance()
menu_creator = None
if menu_instance:
ui.Label(f"omni.kit.menu.utils - Alive", height=20)
menu_creator = menu_instance._menu_creator
else:
ui.Label(f"omni.kit.menu.utils - Shut Down", height=20)
legacy_mode = omni.kit.ui.using_legacy_mode()
ui.Label(f"omni.kit.ui.get_editor_menu() -> omni.kit.menu.utils: {not legacy_mode}", height=20)
if menu_creator:
ui.Label(f"omni.kit.menu.utils - Creator: {menu_creator.__class__.__name__}", height=20)
else:
ui.Label(f"omni.kit.menu.utils - Creator: Not Found", height=20)
ui.Spacer(height=8)
open_stat_frame = False
stat_frame = ui.CollapsableFrame(title="Debug Stats", collapsed=True, style=CollapsableFrame_style, height=12)
with stat_frame:
with ui.VStack():
debug_stats = omni.kit.menu.utils.get_debug_stats()
for stat in debug_stats.keys():
name = stat.replace("_", " ").title()
if stat == "extension_loaded_count":
if debug_stats[stat] != 1:
open_stat_frame = True
ui.Label(f" {name}: {debug_stats[stat]}", height=18, style={"color": cl.red if open_stat_frame else cl.white})
else:
ui.Label(f" {name}: {debug_stats[stat]}", height=18, style={"color": cl.white})
open_menu_frame = False
if menu_creator:
ui.Spacer(height=8)
if menu_creator.__class__.__name__ == "AppMenu":
menu_frame = ui.CollapsableFrame(title="ui.Menu", collapsed=True, style=CollapsableFrame_style, height=12)
with menu_frame:
with ui.VStack():
menu_chain = menu_creator._main_menus
if not menu_chain or not all(k in menu_chain for k in ["File", "Edit", "Window", "Help"]):
ui.Label(f" ERROR MISSING MENUS", height=20, style={"color": cl.red})
open_menu_frame = True
for key in menu_chain.keys():
if menu_chain[key].visible == False:
open_menu_frame = True
ui.Label(f" {key} visible:{menu_chain[key].visible}", height=20, style={"color": cl.white if menu_chain[key].visible else cl.red})
ui.Spacer(height=8)
menu_layout = omni.kit.menu.utils.get_menu_layout()
merged_menus = omni.kit.menu.utils.get_merged_menus()
show_dict_data("Menu Layout", menu_layout)
show_dict_data("Menus", merged_menus)
ui.Button("Refresh Window", clicked_fn=lambda: asyncio.ensure_future(refresh_debug_window(False)), height=24)
ui.Button("Rebuild Menus", clicked_fn=lambda: asyncio.ensure_future(refresh_debug_window(True)), height=24)
ui.Spacer(height=30)
if open_stat_frame:
stat_frame.collapsed = False
if open_menu_frame:
menu_frame.collapsed = False
| 9,026 |
Python
| 42.820388 | 200 | 0.536339 |
omniverse-code/kit/exts/omni.kit.menu.utils/omni/kit/menu/utils/scripts/builder_utils.py
|
import carb
import omni.kit.ui
from typing import Callable, Tuple, Union, List
from omni import ui
def get_menu_name(menu_entry):
if menu_entry.name_fn:
try:
return f"{menu_entry.name_fn()}"
except Exception as exc:
carb.log_warn(f"get_menu_name error:{str(exc)}")
return f"{menu_entry.name}"
def get_action_path(action_prefix: str, menu_entry_name: str):
if not menu_entry_name:
return action_prefix.replace(" ", "_").replace("/", "_").replace(".", "")
return f"{action_prefix}/{menu_entry_name}".replace(" ", "_").replace("/", "_").replace(".", "")
def has_delegate_func(delegate, func_name):
return bool(delegate and hasattr(delegate, func_name) and callable(getattr(delegate, func_name)))
def create_prebuild_entry(prebuilt_menus: dict, prefix_name: str, action_prefix: str):
if not action_prefix in prebuilt_menus:
# prefix_name cannot be "" as creating submenus with "" causes problems
prebuilt_menus[action_prefix] = {}
prebuilt_menus[action_prefix]["items"] = []
prebuilt_menus[action_prefix]["prefix_name"] = prefix_name if prefix_name else "Empty"
prebuilt_menus[action_prefix]["remapped"] = []
prebuilt_menus[action_prefix]["action_prefix"] = action_prefix
class PrebuiltItemOrder:
UNORDERED = 0x7FFFFFFF
LAYOUT_ORDERED = 0x00000000
LAYOUT_SUBMENU_SORTED = 0x00001000
LAYOUT_ITEM_SORTED = 0x00002000
class MenuAlignment:
DEFAULT = 0
RIGHT = 1
class LayoutSourceSearch:
EVERYWHERE = 0
LOCAL_ONLY = 1
class MenuItemDescription:
"""
name is name shown on menu. (if name is "" then a menu spacer is added. Can be combined with show_fn)
glyph is icon shown on menu
header is True/False to show seperator above item
hotkey hotkey for menu item
enabled enabled True/False is item enabled
ticked menu item is ticked when True
sub_menu is sub menu to this menu
name_fn is function to get menu name
show_fn funcion or list of functions used to decide if menu item is shown. All functions must return True to show
enable_fn funcion or list of functions used to decide if menu item is enabled. All functions must return True to be enabled
onclick_action action called when user clicks menu item
unclick_action action called when user releases click on menu item
onclick_fn function called when user clicks menu item (deprecated)
unclick_fn function called when user releases click on menu item (deprecated)
onclick_right_fn function called when user right clicks menu item (deprecated)
ticked_fn funcion or list of functions used to decide if menu item is ticked
appear_after is name of menu item to insert after. Used for appending menus, can be a list or string
user is user dictonary that is passed to menu
"""
MAX_DEPTH = 16
def __init__(
self,
name: str = "",
glyph: str = "",
header: str = None,
appear_after: Union[list, str] = "",
enabled: bool = True,
ticked: bool = False,
ticked_value: Union[bool, None] = None,
sub_menu=None,
hotkey: Tuple[int, int] = None,
name_fn: Callable = None,
show_fn: Callable = None,
enable_fn: Callable = None,
ticked_fn: Callable = None,
onclick_action: Tuple = None,
unclick_action: Tuple = None,
onclick_fn: Callable = None, # deprecated
unclick_fn: Callable = None, # deprecated
onclick_right_fn: Callable = None, # deprecated
original_svg_color: bool = False, # deprecated - only used for editor_menu
original_menu_item = None, # private for hotkey processing
user = {}
):
self._on_delete_funcs = []
self._on_hotkey_update_funcs = []
# don't allow unnamed submenus as causes Menu problems
if name == "" and sub_menu:
self.name = "SubMenu"
else:
self.name = name
self.glyph = glyph
self.header = header
self.appear_after = appear_after
self.ticked = True if ticked or ticked_value is not None or ticked_fn is not None else False
self.ticked_value = ticked_value
self.enabled = enabled
self.sub_menu = sub_menu
self.name_fn = name_fn
self.show_fn = show_fn
self.enable_fn = enable_fn
self.ticked_fn = ticked_fn
self.onclick_action = onclick_action
self.unclick_action = unclick_action
self.set_hotkey(hotkey)
self.original_menu_item = original_menu_item
self.user = user.copy()
# Deprecated
self.original_svg_color = original_svg_color
self.onclick_fn = onclick_fn
self.unclick_fn = unclick_fn
self.onclick_right_fn = onclick_right_fn
log_deprecated = bool((carb.settings.get_settings().get_as_string("/exts/omni.kit.menu.utils/logDeprecated") or "true") == "true")
if log_deprecated and not "shown_deprecated_warning" in self.user:
def deprecated_msg(fn_name, func):
carb.log_warn(f"Menu item \"{name}\" from {func.__module__} uses {fn_name}")
self.user["shown_deprecated_warning"] = True
if onclick_fn or unclick_fn or onclick_right_fn or original_svg_color:
carb.log_warn(f"********************* MenuItemDescription {name} *********************")
if onclick_fn:
deprecated_msg("onclick_fn", onclick_fn)
if unclick_fn:
deprecated_msg("unclick_fn", unclick_fn)
if onclick_right_fn:
deprecated_msg("onclick_right_fn", onclick_right_fn)
if original_svg_color:
deprecated_msg("original_svg_color", original_svg_color)
def add_on_delete_func(self, on_delete_fn: callable):
self._on_delete_funcs.append(on_delete_fn)
def remove_on_delete_func(self, on_delete_fn: callable):
try:
self._on_delete_funcs.remove(on_delete_fn)
except Exception as exc:
carb.log_warn(f"omni.kit.menu.utils remove_on_delete_func failed {str(exc)}")
def add_on_hotkey_update_func(self, hotkey_update_fn: callable):
self._on_hotkey_update_funcs.append(hotkey_update_fn)
def remove_on_hotkey_update_func(self, hotkey_update_fn: callable):
try:
self._on_hotkey_update_funcs.remove(hotkey_update_fn)
except Exception as exc:
carb.log_warn(f"omni.kit.menu.utils remove_on_hotkey_update_func failed {str(exc)}")
def set_hotkey(self, hotkey):
self.hotkey = None
self.hotkey_text = ""
if hotkey:
self.hotkey = hotkey
self.hotkey_text = self.get_action_mapping_desc().replace("Keyboard::", "")
for on_hotkey_update_fn in self._on_hotkey_update_funcs:
on_hotkey_update_fn(self)
def get_action_mapping_desc(self):
if isinstance(self.hotkey, carb.input.GamepadInput):
return carb.input.get_string_from_action_mapping_desc(self.hotkey)
return carb.input.get_string_from_action_mapping_desc(self.hotkey[1], self.hotkey[0])
def has_action(self):
return bool(self.onclick_fn or self.onclick_action or self.unclick_fn or self.unclick_action)
def __del__(self):
self.original_menu_item = None
for on_delete_fn in self._on_delete_funcs:
on_delete_fn(self)
del self._on_delete_funcs
del self._on_hotkey_update_funcs
def __repr__(self):
return f"<{self.__class__} name:{self.name} user:{self.user}>"
def __copy__(self):
# as hotkeys are removed on copyed item delete, hotkeys are accessed via original_menu_item as these are not deleted until the menu is removed
def get_original(item):
original = item.original_menu_item
if original:
while(original.original_menu_item and original.original_menu_item.original_menu_item):
original = original.original_menu_item
return original
return item
sub_menu = self.sub_menu
if sub_menu:
def copy_sub_menu(sub_menu, new_sub_menu, max_depth=MenuItemDescription.MAX_DEPTH):
if max_depth == 0:
carb.log_warn(f"Recursive sub_menu {sub_menu} aborting copy")
return
for sub_item in sub_menu:
item = MenuItemDescription(name=sub_item.name,
glyph=sub_item.glyph,
header=sub_item.header,
appear_after=sub_item.appear_after,
enabled=sub_item.enabled,
ticked=sub_item.ticked,
ticked_value=sub_item.ticked_value,
sub_menu=None,
hotkey=None,
name_fn=sub_item.name_fn,
show_fn=sub_item.show_fn,
enable_fn=sub_item.enable_fn,
ticked_fn=sub_item.ticked_fn,
onclick_action=sub_item.onclick_action,
unclick_action=sub_item.unclick_action,
onclick_fn=sub_item.onclick_fn,
unclick_fn=sub_item.unclick_fn,
onclick_right_fn=sub_item.onclick_right_fn,
original_svg_color=sub_item.original_svg_color,
original_menu_item=get_original(sub_item),
user=sub_item.user)
new_sub_menu.append(item)
if sub_item.sub_menu:
item.sub_menu = []
copy_sub_menu(sub_item.sub_menu, item.sub_menu, max_depth-1)
new_sub_menu = []
copy_sub_menu(sub_menu, new_sub_menu)
sub_menu = new_sub_menu
return MenuItemDescription(name=self.name,
glyph=self.glyph,
header=self.header,
appear_after=self.appear_after,
enabled=self.enabled,
ticked=self.ticked,
ticked_value=self.ticked_value,
sub_menu=sub_menu,
hotkey=None,
name_fn=self.name_fn,
show_fn=self.show_fn,
enable_fn=self.enable_fn,
ticked_fn=self.ticked_fn,
onclick_action=self.onclick_action,
unclick_action=self.unclick_action,
onclick_fn=self.onclick_fn,
unclick_fn=self.unclick_fn,
onclick_right_fn=self.onclick_right_fn,
original_svg_color=self.original_svg_color,
original_menu_item=get_original(self),
user=self.user)
def json_enc(self):
values = { "name": self.name,
"glyph": self.glyph,
"header": self.header,
"enabled": self.enabled,
"sub_menu": self.sub_menu,
"hotkey": self.hotkey,
"name_fn": self.name_fn,
"show_fn": self.show_fn,
"enable_fn": self.enable_fn,
"onclick_action": self.onclick_action,
"unclick_action": self.unclick_action,
"onclick_fn": self.onclick_fn,
"unclick_fn": self.unclick_fn,
"onclick_right_fn": self.onclick_right_fn,
"original_svg_color": self.original_svg_color,
"user": self.user}
if self.ticked:
values["ticked"] = self.ticked
values["ticked_value"] = self.ticked_value
values["ticked_fn"] = self.ticked_fn
if self.appear_after:
values["appear_after"] = self.appear_after
return {k: v for k, v in values.items() if v is not None}
# Make a dict like interface for MenuItemDescription so it can be used as an entry for omni.kit.context_menu
# overrides [] and get for read-only access
def __getitem__(self, key, default_value=None):
return getattr(self, key, default_value)
def __contains__(self, key):
return self.__getitem__(key) is not None
def get(self, key, default_value=None):
return self.__getitem__(key, default_value)
| 13,333 |
Python
| 43.744966 | 150 | 0.545489 |
omniverse-code/kit/exts/omni.kit.menu.utils/omni/kit/menu/utils/scripts/app_menu.py
|
import asyncio
import functools
import weakref
import carb
import omni.kit.ui
import omni.kit.app
from functools import partial
from enum import IntFlag, Enum
from omni import ui
from typing import Callable, Tuple, Any
from pathlib import Path
from .builder_utils import get_menu_name, get_action_path, create_prebuild_entry, has_delegate_func
from .builder_utils import MenuItemDescription, PrebuiltItemOrder, MenuAlignment
class MenuItemOrder:
FIRST = "@first"
LAST = "@last"
class MenuState(IntFlag):
Invalid = 0
Created = 1
class MenuActionControl(Enum):
NONE = "@MenuActionControl.NONE"
NODELAY = "@MenuActionControl.NODELAY"
class uiMenu(ui.Menu):
def __init__(self, *args, **kwargs):
self.glyph = None
self.submenu = False
self.menu_hotkey_text = None
self.menu_checkable = False
if "glyph" in kwargs:
self.glyph = kwargs["glyph"]
del kwargs["glyph"]
if "menu_checkable" in kwargs:
self.menu_checkable = kwargs["menu_checkable"]
del kwargs["menu_checkable"]
if "menu_hotkey_text" in kwargs:
self.menu_hotkey_text = kwargs["menu_hotkey_text"]
del kwargs["menu_hotkey_text"]
if "submenu" in kwargs:
self.submenu = kwargs["submenu"]
del kwargs["submenu"]
super().__init__(*args, **kwargs, spacing=2, menu_compatibility=False)
class uiMenuItem(ui.MenuItem):
def __init__(self, *args, **kwargs):
self.glyph = None
self.submenu = False
self.menu_hotkey_text = None
self.menu_checkable = False
if "glyph" in kwargs:
self.glyph = kwargs["glyph"]
del kwargs["glyph"]
if "menu_checkable" in kwargs:
self.menu_checkable = kwargs["menu_checkable"]
del kwargs["menu_checkable"]
if "menu_hotkey_text" in kwargs:
self.menu_hotkey_text = kwargs["menu_hotkey_text"]
del kwargs["menu_hotkey_text"]
super().__init__(*args, **kwargs, menu_compatibility=False)
class IconMenuDelegate(ui.MenuDelegate):
EXTENSION_FOLDER_PATH = Path()
ICON_PATH = EXTENSION_FOLDER_PATH.joinpath("data/icons")
ICON_SIZE = 14
TICK_SIZE = 14
TICK_SPACING = [3, 6]
MARGIN_SIZE = [4, 4]
ROOT_SPACING = 1
SUBMENU_PRE_SPACING = 5
SUBMENU_SPACING = 4
SUBMENU_ICON_SIZE = 10
ITEM_SPACING = 4
ICON_SPACING = 4
HOTKEY_SPACING = [8, 108]
COLOR_LABEL_ENABLED = 0xFFCCCCCC
COLOR_LABEL_DISABLED = 0xFF6F6F6F
COLOR_TICK_ENABLED = 0xFFCCCCCC
COLOR_TICK_DISABLED = 0xFF4F4F4F
COLOR_SEPARATOR = 0xFF6F6F6F
# doc compiler breaks if `omni.kit.app.get_app()` or `carb.settings.get_settings()` is called
try:
EXTENSION_FOLDER_PATH = Path(omni.kit.app.get_app().get_extension_manager().get_extension_path_by_module(__name__))
ICON_PATH = EXTENSION_FOLDER_PATH.joinpath("data/icons")
ICON_SIZE = carb.settings.get_settings().get("exts/omni.kit.menu.utils/icon_size")
TICK_SIZE = carb.settings.get_settings().get("exts/omni.kit.menu.utils/tick_size")
TICK_SPACING = carb.settings.get_settings().get("exts/omni.kit.menu.utils/tick_spacing")
MARGIN_SIZE = carb.settings.get_settings().get("exts/omni.kit.menu.utils/margin_size")
ROOT_SPACING = carb.settings.get_settings().get("exts/omni.kit.menu.utils/root_spacing")
SUBMENU_PRE_SPACING = carb.settings.get_settings().get("exts/omni.kit.menu.utils/submenu_pre_spacing")
SUBMENU_SPACING = carb.settings.get_settings().get("exts/omni.kit.menu.utils/submenu_spacing")
SUBMENU_ICON_SIZE = carb.settings.get_settings().get("exts/omni.kit.menu.utils/submenu_icon_size")
ITEM_SPACING = carb.settings.get_settings().get("exts/omni.kit.menu.utils/item_spacing")
ICON_SPACING = carb.settings.get_settings().get("exts/omni.kit.menu.utils/icon_spacing")
HOTKEY_SPACING = carb.settings.get_settings().get("exts/omni.kit.menu.utils/hotkey_spacing")
COLOR_LABEL_ENABLED = carb.settings.get_settings().get("exts/omni.kit.menu.utils/color_label_enabled")
COLOR_LABEL_DISABLED = carb.settings.get_settings().get("exts/omni.kit.menu.utils/color_label_disabled")
COLOR_TICK_ENABLED = carb.settings.get_settings().get("exts/omni.kit.menu.utils/color_tick_enabled")
COLOR_TICK_DISABLED = carb.settings.get_settings().get("exts/omni.kit.menu.utils/color_tick_disabled")
COLOR_SEPARATOR = carb.settings.get_settings().get("exts/omni.kit.menu.utils/color_separator")
except Exception as exc:
carb.log_warn(f"IconMenuDelegate: failed to get EXTENSION_FOLDER_PATH and defaults {exc}")
MENU_STYLE = {"Label::Enabled": {"margin_width": MARGIN_SIZE[0], "margin_height": MARGIN_SIZE[1], "color": COLOR_LABEL_ENABLED},
"Label::Disabled": {"margin_width": MARGIN_SIZE[0], "margin_height": MARGIN_SIZE[1], "color": COLOR_LABEL_DISABLED},
"Image::Icon": {"margin_width": 0, "margin_height": 0, "color": COLOR_LABEL_ENABLED},
"Image::SubMenu": {"image_url": f"{ICON_PATH}/subdir.svg", "margin_width": 0, "margin_height": 0, "color": COLOR_LABEL_ENABLED},
"Image::TickEnabled": {"image_url": f"{ICON_PATH}/checked.svg", "margin_width": 0, "margin_height": 0, "color": COLOR_TICK_ENABLED},
"Image::TickDisabled": {"image_url": f"{ICON_PATH}/checked.svg", "margin_width": 0, "margin_height": 0, "color": COLOR_TICK_DISABLED},
"Menu.Separator": {
"color": COLOR_SEPARATOR
},
}
def build_item(self, item: ui.Menu):
if isinstance(item, ui.Separator):
with ui.HStack(height=0, style=IconMenuDelegate.MENU_STYLE):
return super().build_item(item)
with ui.HStack(height=0, style=IconMenuDelegate.MENU_STYLE):
if not (isinstance(item, uiMenu) and not item.submenu):
ui.Spacer(width=IconMenuDelegate.ITEM_SPACING)
else:
ui.Spacer(width=IconMenuDelegate.ROOT_SPACING)
# build tick
if item.menu_checkable:
ui.Spacer(width=IconMenuDelegate.TICK_SPACING[0])
if item.checkable:
ui.Image("", width=IconMenuDelegate.TICK_SIZE, name="TickEnabled" if item.checked else "TickDisabled")
else:
ui.Spacer(width=IconMenuDelegate.TICK_SIZE)
ui.Spacer(width=IconMenuDelegate.TICK_SPACING[1])
# build glyph
if item.glyph:
glyph_path = item.glyph if "/" in item.glyph.replace("\\", "/") else carb.tokens.get_tokens_interface().resolve("${glyphs}/"+ item.glyph)
ui.Spacer(width=IconMenuDelegate.ICON_SPACING)
ui.Image(glyph_path, width=IconMenuDelegate.ICON_SIZE, name="Icon")
ui.Spacer(width=IconMenuDelegate.ICON_SPACING)
# build label
if isinstance(item, uiMenu):
ui.Label(f"{item.text}", height=IconMenuDelegate.ICON_SIZE, name="Enabled" if item.enabled else "Disabled")
ui.Spacer(width=IconMenuDelegate.ROOT_SPACING)
else:
ui.Label(f"{item.text} ", height=IconMenuDelegate.ICON_SIZE, name="Enabled" if item.enabled else "Disabled")
# build hotkey text
if item.hotkey_text:
ui.Spacer(width=IconMenuDelegate.HOTKEY_SPACING[0])
ui.Label(item.hotkey_text.title(), height=IconMenuDelegate.ICON_SIZE, name="Disabled", width=100)
elif item.menu_hotkey_text:
ui.Spacer(width=IconMenuDelegate.HOTKEY_SPACING[1])
# build subdir marker
if item.submenu:
ui.Spacer(width=IconMenuDelegate.SUBMENU_PRE_SPACING)
ui.Image("", width=IconMenuDelegate.SUBMENU_ICON_SIZE, name="SubMenu")
ui.Spacer(width=IconMenuDelegate.SUBMENU_SPACING)
class AppMenu():
def __init__(self, get_instance: callable):
from omni.kit.mainwindow import get_main_window
self._get_instance = get_instance
self._menu_hooks = []
self._active_menus = {}
self._main_menus = {}
self.set_right_padding(0)
self._dirty_menus = set()
self._stats = omni.kit.menu.utils.get_debug_stats()
if not "triggered_refresh" in self._stats:
self._stats["triggered_refresh"] = 0
# setup window
self._menu_bar = get_main_window().get_main_menu_bar()
self._menu_bar.visible = True
def destroy(self):
for action_path in self._active_menus:
self._active_menus[action_path] = None
del self._active_menus
self._active_menus = {}
self._main_menus = {}
self._menu_bar.clear()
self._menu_bar = None
def add_hook(self, callback: Callable):
self._menu_hooks.append(callback)
def remove_hook(self, callback: Callable):
try:
self._menu_hooks.remove(callback)
except Exception as exc:
carb.log_warn(f"omni.kit.menu.utils remove_hook failed {exc}")
def merge_menus(self, menu_keys: list, menu_defs: list, menu_order: list, delegates: dict={}):
merged_menu = {}
def order_sort(name):
if name in menu_order:
return menu_order[name]
return 0
def get_item_menu_index(menu: list, name: str):
for index, item in enumerate(menu):
if item.name == name:
return index
return -1
def process_part(name, part):
used = False
if isinstance(part.appear_after, list):
for after in part.appear_after:
if after == MenuItemOrder.FIRST:
merged_menu[name].insert(0, part)
used = True
break
elif after == MenuItemOrder.LAST:
merged_menu[name].append(part)
used = True
break
index = get_item_menu_index(merged_menu[name], after)
if index != -1:
merged_menu[name].insert(index + 1, part)
used = True
break
else:
index = get_item_menu_index(merged_menu[name], part.appear_after)
if index != -1:
merged_menu[name].insert(index + 1, part)
used = True
return used
def get_items(sorted_keys, use_appear_after):
appear_after_retries = []
for name in sorted_keys:
if not name in merged_menu:
merged_menu[name] = []
for parts in menu_defs[name]:
for part in parts:
if part.appear_after:
if use_appear_after:
used = process_part(name, part)
if not used:
appear_after_retries.append((name, part))
elif not use_appear_after:
merged_menu[name].append(part)
for name, part in appear_after_retries:
used = process_part(name, part)
if not used:
carb.log_verbose(f"Warning: menu item failed to find appear_after index {part.appear_after}")
merged_menu[name].append(part)
# order using menu_order
sorted_keys = list(menu_keys)
if menu_order:
sorted_keys.sort(key=order_sort)
# get menu non-appear_after items & appear_after items
get_items(sorted_keys, False)
get_items(sorted_keys, True)
for hook_fn in self._menu_hooks:
hook_fn(merged_menu)
# prebuild menus so layout can be applied before building
self._prebuilt_menus = {}
for name in merged_menu.keys():
self.prebuild_menu(merged_menu[name], name, get_action_path(name, None), delegates[name][0] if name in delegates else None)
prebuilt_menus = self._prebuilt_menus
self._prebuilt_menus = None
self.get_menu_layout().apply_layout(prebuilt_menus)
return prebuilt_menus
def prebuild_menu(self, menus, prefix_name, action_prefix, delegate):
try:
import copy
def prebuild_menu(entry, prefix_name, action_prefix):
item = copy.copy(entry)
item.user["prebuilt_order"] = PrebuiltItemOrder.UNORDERED
# add submenu items to list
create_prebuild_entry(self._prebuilt_menus, prefix_name, action_prefix)
# check if item already on list, to avoid duplicates
duplicate = False
if item.name != "":
for old_item in self._prebuilt_menus[action_prefix]["items"]:
if item.name == old_item.name:
duplicate = True
break
if not duplicate:
# prefix_name cannot be "" as creating submenus with "" causes problems
self._prebuilt_menus[action_prefix]["items"].append(item)
self._prebuilt_menus[action_prefix]["prefix_name"] = prefix_name if prefix_name else "Empty"
self._prebuilt_menus[action_prefix]["remapped"] = []
self._prebuilt_menus[action_prefix]["action_prefix"] = action_prefix
self._prebuilt_menus[action_prefix]["menu_alignment"] = MenuAlignment.DEFAULT
self._prebuilt_menus[action_prefix]["delegate"] = delegate
if has_delegate_func(delegate, "get_menu_alignment"):
self._prebuilt_menus[action_prefix]["menu_alignment"] = delegate.get_menu_alignment()
if item.sub_menu and entry.name:
sub_prefix = get_menu_name(entry)
sub_action = get_action_path(action_prefix, entry.name)
for sub_item in item.sub_menu:
prebuild_menu(sub_item, sub_prefix, sub_action)
self._prebuilt_menus[sub_action]["sub_menu"] = True
item.sub_menu = sub_action
for menu_entry in menus:
prebuild_menu(menu_entry, prefix_name, action_prefix)
except Exception as e:
carb.log_error(f"Error {e} creating menu {menu_entry}")
import traceback, sys
traceback.print_exc(file=sys.stdout)
def get_menu_layout(self):
instance = self._get_instance()
if instance:
return instance.get_menu_layout()
return None
def get_fn_result(self, menu_entry: MenuItemDescription, name: str, default: bool=True):
fn = getattr(menu_entry, name)
if not fn:
return default
if isinstance(fn, list):
for fn_item in fn:
if fn_item and not fn_item():
return False
else:
if fn and not fn():
return False
return default
def get_menu_data(self):
instance = self._get_instance()
if instance:
return instance.get_menu_data()
return None, None, None
def set_right_padding(self, padding):
self._right_padding = padding
def create_menu(self):
menu_defs, menu_order, delegates = self.get_menu_data()
self._menu_bar.clear()
self._active_menus = {}
self._main_menus = {}
self._visible_menus = {}
self._last_item = {}
menus = self.merge_menus(menu_defs.keys(), menu_defs, menu_order, delegates)
right_menus = []
with self._menu_bar:
for name in menus.keys():
if not "sub_menu" in menus[name]:
if menus[name]["menu_alignment"] == MenuAlignment.RIGHT:
right_menus.append(name)
else:
self._build_menu(menus[name], menus, True)
if right_menus:
ui.Spacer().identifier = "right_aligned_menus"
for name in right_menus:
self._build_menu(menus[name], menus, True)
ui.Spacer(width=self._right_padding).identifier = "right_padding"
for key in self._main_menus.keys():
if key not in self._visible_menus:
self._main_menus[key].visible = False
if key in self._last_item:
if isinstance(self._last_item[key], ui.Separator):
self._last_item[key].visible = False
self._last_item = None
self._visible_menus = None
return menus
def refresh_menu_items(self, name: str):
self._dirty_menus.add(name)
def _submenu_is_shown(self, action_prefix: str, visible: bool, delegate: Any, refresh :bool):
if action_prefix in self._main_menus:
self._main_menus[action_prefix].visible = visible
if has_delegate_func(delegate, "update_menu_item"):
delegate.update_menu_item(self._main_menus[action_prefix], refresh)
# update to use new prebuild/layouts
def _refresh_menu(self, prebuilt_menus, prebuilt_menus_root, visible_override=None):
menus = prebuilt_menus["items"]
prefix_name = prebuilt_menus["prefix_name"]
action_prefix = prebuilt_menus["action_prefix"]
delegate = prebuilt_menus["delegate"] if "delegate" in prebuilt_menus else None
visible_count = 0
for menu_entry in sorted(menus, key=lambda a: a.user["prebuilt_order"]):
try:
menu_name = get_menu_name(menu_entry)
action_path = (get_action_path(action_prefix, menu_entry.name))
enabled = menu_entry.enabled
value = menu_entry.ticked_value
visible = True
if menu_entry.enable_fn:
enabled = self.get_fn_result(menu_entry, "enable_fn")
if menu_entry.ticked_fn:
value = self.get_fn_result(menu_entry, "ticked_fn")
if menu_entry.show_fn:
visible = self.get_fn_result(menu_entry, "show_fn")
# handle sub_menu before action_path/active_menus can skip it
if menu_entry.sub_menu and menu_entry.sub_menu in prebuilt_menus_root:
visible = self._refresh_menu(prebuilt_menus_root[menu_entry.sub_menu], prebuilt_menus_root, self.get_fn_result(menu_entry, "show_fn", None))
# update visibility
if visible_override is not None:
visible = visible_override
visible_count += 1 if visible else 0
self._submenu_is_shown(menu_entry.sub_menu, visible, delegate, True)
continue
if not action_path in self._active_menus:
continue
item = self._active_menus[action_path]
item.enabled = enabled
item.checked = value
item.visible = visible
if has_delegate_func(delegate, "update_menu_item"):
delegate.update_menu_item(item, True)
visible_count += 1 if item.visible else 0
except Exception as e:
carb.log_error(f"Error {e} refreshing menu {menu_entry}")
import traceback, sys
traceback.print_exc(file=sys.stdout)
return bool(visible_count > 0)
def _build_menu(self, prebuilt_menus, prebuilt_menus_root, is_root_menu, visible_override=None, menu_checkable=False, menu_hotkey_text=False, glyph=None) -> int:
def on_triggered():
if self._dirty_menus:
self._stats["triggered_refresh"] += 1
menu_defs, menu_order, menu_delegates = self.get_menu_data()
menus = self.merge_menus(menu_defs.keys(), menu_defs, menu_order)
for name in self._dirty_menus:
action_path = get_action_path(name, None)
if action_path in menus:
self._refresh_menu(menus[action_path], menus)
for remapped in menus[action_path]["remapped"]:
self._refresh_menu(menus[remapped], menus)
self._dirty_menus.clear()
def prep_menu(main_menu, prefix_name: str, action_prefix: str, visible: bool, delegate: callable, glyph: str, menu_checkable: bool, menu_hotkey_text: bool):
if not action_prefix in main_menu:
main_menu[action_prefix] = uiMenu(prefix_name, visible=visible, delegate=delegate, glyph=glyph, menu_checkable=menu_checkable, menu_hotkey_text=menu_hotkey_text, submenu=not is_root_menu)
if is_root_menu:
main_menu[action_prefix].set_triggered_fn(on_triggered)
menus = prebuilt_menus["items"]
prefix_name = prebuilt_menus["prefix_name"]
action_prefix = prebuilt_menus["action_prefix"]
delegate = prebuilt_menus["delegate"] if "delegate" in prebuilt_menus else None
visible_count = 0
icon_delegate = IconMenuDelegate()
# this menu item is built with menu_checkable passed via caller
prep_menu(self._main_menus, prefix_name, action_prefix, True if visible_override is None else visible_override, delegate if delegate else icon_delegate, glyph, menu_checkable, menu_hotkey_text)
# get delegate for icons
menu_hotkey_text = False
menu_checkable = False
for menu_entry in sorted(menus, key=lambda a: a.user["prebuilt_order"]):
if menu_entry.ticked:
menu_checkable = True
if menu_entry.original_menu_item and menu_entry.original_menu_item.hotkey:
menu_hotkey_text = True
with self._main_menus[action_prefix]:
for menu_entry in sorted(menus, key=lambda a: a.user["prebuilt_order"]):
try:
item = None
menu_name = get_menu_name(menu_entry)
action_path = (get_action_path(action_prefix, menu_entry.name))
on_lmb_click = None
if menu_entry.onclick_action and menu_entry.unclick_action:
def on_hotkey_action(onclick_action, unclick_action):
self._execute_action(onclick_action)
self._execute_action(unclick_action)
on_lmb_click = lambda oca=menu_entry.onclick_action, uca=menu_entry.unclick_action: on_hotkey_action(oca, uca)
elif menu_entry.onclick_action:
on_lmb_click = lambda oca=menu_entry.onclick_action: self._execute_action(oca)
elif menu_entry.onclick_fn and menu_entry.unclick_fn:
def on_hotkey_click():
menu_entry.onclick_fn()
menu_entry.unclick_fn()
on_lmb_click = on_hotkey_click
else:
on_lmb_click = menu_entry.onclick_fn
hotkey = None
if menu_entry.original_menu_item:
hotkey = menu_entry.original_menu_item.hotkey
enabled = menu_entry.enabled
ticked = menu_entry.ticked
value = menu_entry.ticked_value
visible = True
if menu_entry.enable_fn:
enabled = self.get_fn_result(menu_entry, "enable_fn")
if menu_entry.ticked_fn:
value = self.get_fn_result(menu_entry, "ticked_fn")
if menu_entry.show_fn:
visible = self.get_fn_result(menu_entry, "show_fn")
if menu_entry.name and menu_entry.sub_menu:
if menu_entry.sub_menu in prebuilt_menus_root:
self._visible_menus[action_prefix] = visible
visible = self._build_menu(prebuilt_menus_root[menu_entry.sub_menu], prebuilt_menus_root, False, self.get_fn_result(menu_entry, "show_fn", None), menu_checkable, menu_hotkey_text, menu_entry.glyph)
if visible_override is not None:
visible = visible_override
visible_count += 1 if visible else 0
self._submenu_is_shown(menu_entry.sub_menu, visible, delegate, False)
continue
elif menu_entry.header != None:
if action_prefix in self._last_item:
if isinstance(self._last_item[action_prefix], ui.Separator):
# last thing was a Separator, change the text to new value
self._last_item[action_prefix].text = menu_entry.header
else:
item = ui.Separator(menu_entry.header)
else:
item = ui.Separator(menu_entry.header)
elif menu_entry.name == "":
if action_prefix in self._last_item:
if action_prefix in self._last_item and not isinstance(self._last_item[action_prefix], ui.Separator):
item = ui.Separator()
else:
item = ui.Separator()
else:
item = uiMenuItem(menu_name, triggered_fn=on_lmb_click if on_lmb_click else None, checkable=ticked, checked=value, enabled=enabled, visible=visible, style=menu_entry.user.get("user_style", {}), delegate=icon_delegate, glyph=menu_entry.glyph, menu_checkable=menu_checkable, menu_hotkey_text=menu_hotkey_text)
if has_delegate_func(delegate, "update_menu_item"):
delegate.update_menu_item(item, False)
self._active_menus[action_path] = item
if hotkey:
item.hotkey_text = " " + menu_entry.original_menu_item.hotkey_text
setup_hotkey = True
try:
import omni.kit.hotkeys.core
# Always setup hotkey because hotkey may changed
setup_hotkey = True
except ImportError:
if hasattr(menu_entry.original_menu_item, "_action_setting_sub_id"):
setup_hotkey = False
if setup_hotkey:
hotkey_text = self._setup_hotkey(menu_entry.original_menu_item, action_path)
if hotkey_text is not None:
item.hotkey_text = hotkey_text
if item:
self._last_item[action_prefix] = item
self._visible_menus[action_prefix] = visible
visible_count += 1 if visible else 0
except Exception as e:
carb.log_error(f"Error {e} creating menu {menu_entry}")
import traceback, sys
traceback.print_exc(file=sys.stdout)
return bool(visible_count > 0)
def _execute_action(self, action: Tuple):
if not action:
return
async_delay = True
# check for MenuActionControl in action & remove
actioncontrol_list = [e for e in MenuActionControl]
if any(a in action for a in actioncontrol_list):
if MenuActionControl.NODELAY in action:
async_delay = False
action = tuple([item for item in action if item not in actioncontrol_list])
try:
import omni.kit.actions.core
import omni.kit.app
if async_delay:
async def execute_action(action):
await omni.kit.app.get_app().next_update_async()
omni.kit.actions.core.execute_action(*action)
# omni.ui can sometimes crash is menu callback does ui calls.
# To avoid this, use async function with frame delay
asyncio.ensure_future(execute_action(action))
else:
omni.kit.actions.core.execute_action(*action)
except ModuleNotFoundError:
carb.log_warn(f"menu_action: error omni.kit.actions.core not loaded")
except Exception as exc:
carb.log_warn(f"menu_action: error {exc}")
def _setup_hotkey(self, menu_entry: MenuItemDescription, action_path: str) -> str:
def action_trigger(on_action_pressed_fn, on_action_release_fn, evt, *_):
if evt.flags & carb.input.BUTTON_FLAG_PRESSED:
if on_action_pressed_fn:
on_action_pressed_fn()
elif on_action_release_fn:
on_action_release_fn()
if not menu_entry.hotkey:
return None
self._clear_hotkey(menu_entry)
self._unregister_hotkey(menu_entry)
import omni.appwindow
appwindow = omni.appwindow.get_default_app_window()
input = carb.input.acquire_input_interface()
settings = carb.settings.get_settings()
action_mapping_set_path = appwindow.get_action_mapping_set_path()
action_mapping_set = input.get_action_mapping_set_by_path(action_mapping_set_path)
input_string = menu_entry.get_action_mapping_desc()
menu_entry._action_setting_input_path = action_mapping_set_path + "/" + action_path + "/0"
settings.set_default_string(menu_entry._action_setting_input_path, input_string)
if menu_entry.onclick_action:
try:
from omni.kit.hotkeys.core import get_hotkey_registry
if not get_hotkey_registry():
raise ImportError
current_action_triggger = None
self._register_hotkey(menu_entry)
menu_entry.add_on_hotkey_update_func(lambda me, a=action_path: self._setup_hotkey(me, a))
if hasattr(menu_entry, "_pressed_hotkey"):
return menu_entry._pressed_hotkey.key_text if menu_entry._pressed_hotkey else ""
elif hasattr(menu_entry, "_released_hotkey"):
return menu_entry._released_hotkey.key_text if menu_entry._released_hotkey else ""
else:
return None
except ImportError:
current_action_triggger = functools.partial(action_trigger, lambda oca=menu_entry.onclick_action: self._execute_action(oca), lambda uca=menu_entry.unclick_action: self._execute_action(uca))
else:
current_action_triggger = functools.partial(action_trigger, menu_entry.onclick_fn, menu_entry.unclick_fn)
if current_action_triggger:
menu_entry._action_setting_sub_id = input.subscribe_to_action_events(action_mapping_set, action_path, current_action_triggger)
menu_entry.add_on_delete_func(self._clear_hotkey)
menu_entry.add_on_hotkey_update_func(lambda me, a=action_path: self._setup_hotkey(me, a))
# menu needs to refresh when self._action_setting_input_path changes
def hotkey_changed(changed_item: carb.dictionary.Item, change_event_type: carb.settings.ChangeEventType, weak_entry: weakref, action_path: str):
import carb.input
def set_hotkey_text(action_path, hotkey_text, active_menu_text):
menu_entry.hotkey_text = hotkey_text
if action_path in self._active_menus:
self._active_menus[action_path].hotkey_text = active_menu_text
menu_entry = weak_entry()
if not menu_entry:
return
# "changed_item" was DESTROYED, so remove hotkey
if change_event_type == carb.settings.ChangeEventType.DESTROYED:
set_hotkey_text(action_path, "", "")
return
hotkey_mapping = changed_item.get_dict()
if isinstance(hotkey_mapping, str):
set_hotkey_text(action_path, hotkey_mapping.replace("Keyboard::", ""), " " + menu_entry.hotkey_text)
else:
set_hotkey_text(action_path, "", "")
menu_entry._action_setting_changed_sub = settings.subscribe_to_node_change_events(menu_entry._action_setting_input_path, lambda ci, ev, m=weakref.ref(menu_entry), a=action_path: hotkey_changed(ci, ev, m, a))
return None
def _clear_hotkey(self, menu_entry):
if hasattr(menu_entry, "_action_setting_sub_id"):
try:
input = carb.input.acquire_input_interface()
input.unsubscribe_to_action_events(menu_entry._action_setting_sub_id)
del menu_entry._action_setting_sub_id
settings = carb.settings.get_settings()
settings.unsubscribe_to_change_events(menu_entry._action_setting_changed_sub)
del menu_entry._action_setting_changed_sub
del menu_entry._action_setting_input_path
except:
pass
def _register_hotkey(self, menu_entry: MenuItemDescription):
try:
from omni.kit.hotkeys.core import get_hotkey_registry, KeyCombination
hotkey_registry = get_hotkey_registry()
if not hotkey_registry:
raise ImportError
HOTKEY_EXT_ID = "omni.kit.menu.utils"
if menu_entry.onclick_action:
key = KeyCombination(menu_entry.hotkey[1], modifiers=menu_entry.hotkey[0])
menu_entry._pressed_hotkey = hotkey_registry.register_hotkey(HOTKEY_EXT_ID, key, menu_entry.onclick_action[0], menu_entry.onclick_action[1])
if menu_entry.unclick_action:
key = KeyCombination(menu_entry.hotkey[1], modifiers=menu_entry.hotkey[0], trigger_press=False)
menu_entry._released_hotkey = hotkey_registry.register_hotkey(HOTKEY_EXT_ID, key, menu_entry.unclick_action[0], menu_entry.unclick_action[1])
menu_entry.add_on_delete_func(self._unregister_hotkey)
except ImportError:
pass
def _unregister_hotkey(self, menu_entry: MenuItemDescription):
try:
from omni.kit.hotkeys.core import get_hotkey_registry
hotkey_registry = get_hotkey_registry()
if hotkey_registry:
if hasattr(menu_entry, "_pressed_hotkey"):
if menu_entry._pressed_hotkey:
hotkey_registry.deregister_hotkey(menu_entry._pressed_hotkey)
if hasattr(menu_entry, "_released_hotkey"):
if menu_entry._released_hotkey:
hotkey_registry.deregister_hotkey(menu_entry._released_hotkey)
if hasattr(menu_entry, "__hotkey_changed_event_sub"):
menu_entry.__hotkey_changed_event_sub = None
except ImportError:
pass
| 35,928 |
Python
| 46.399736 | 331 | 0.563933 |
omniverse-code/kit/exts/omni.kit.menu.utils/omni/kit/menu/utils/scripts/__init__.py
|
from .utils import *
from .debug_window import *
| 49 |
Python
| 15.666661 | 27 | 0.734694 |
omniverse-code/kit/exts/omni.kit.menu.utils/omni/kit/menu/utils/scripts/utils.py
|
import asyncio
import functools
import carb
import carb.settings
import omni.ext
import omni.kit.app
from functools import partial
from typing import Callable, Tuple, Union, List
from .actions import add_action_to_menu, ActionMenuSubscription
from .layout import MenuLayout
from .builder_utils import MenuItemDescription, PrebuiltItemOrder, MenuAlignment, LayoutSourceSearch
from .app_menu import MenuItemOrder, MenuState, MenuActionControl, IconMenuDelegate
_extension_instance = None
class MenuUtilsExtension(omni.ext.IExt):
def __init__(self):
super().__init__()
self._menu_defs = {}
self._menu_delegates = {}
self._menu_order = {}
self._master_menu = {}
self._ready_state = MenuState.Invalid
self._menus_to_refresh = set()
self._refresh_task = None
# debug stats
self._stats = {}
self._stats["add_menu_items"] = 0
self._stats["remove_menu_items"] = 0
self._stats["add_hook"] = 0
self._stats["remove_hook"] = 0
self._stats["add_layout"] = 0
self._stats["remove_layout"] = 0
self._stats["refresh_menu_items"] = 0
self._stats["refresh_menu_items_skipped"] = 0
self._stats["rebuild_menus"] = 0
self._stats["rebuild_menus_skipped"] = 0
def on_startup(self, ext_id):
global _extension_instance
_extension_instance = self
LOADED_EXTENSION_COUNT_MENU = "/exts/omni.kit.menu.utils/loaded_extension_count"
settings = carb.settings.get_settings()
settings.set_default_int(LOADED_EXTENSION_COUNT_MENU, 0)
loaded_extension_count = settings.get(LOADED_EXTENSION_COUNT_MENU) + 1
settings.set(LOADED_EXTENSION_COUNT_MENU, loaded_extension_count)
self._menu_creator = None
self._menu_layout = MenuLayout()
self._hooks = []
self._stats["extension_loaded_count"] = loaded_extension_count
ext_manager = omni.kit.app.get_app_interface().get_extension_manager()
# Hook to extension enable/disable
# to setup hotkey with different ways with omni.kit.hotkeys.core enabled/disabled
hooks = ext_manager.get_hooks()
self.__extension_enabled_hook = hooks.create_extension_state_change_hook(
self.__on_ext_changed, omni.ext.ExtensionStateChangeType.AFTER_EXTENSION_ENABLE
)
self.__extension_disabled_hook = hooks.create_extension_state_change_hook(
self.__on_ext_changed, omni.ext.ExtensionStateChangeType.AFTER_EXTENSION_DISABLE
)
mainwindow_loaded = next(
(
ext
for ext in ext_manager.get_extensions()
if ext["id"].startswith("omni.kit.mainwindow") and ext["enabled"]
),
None,
)
settings = carb.settings.get_settings()
if settings.get("/exts/omni.kit.menu.utils/forceEditorMenu") is not None:
carb.log_error(f"omni.kit.menu.utils forceEditorMenu is no longer supported")
if mainwindow_loaded:
from .app_menu import AppMenu
self._menu_creator = AppMenu(lambda: _extension_instance)
else:
carb.log_info(f"omni.kit.mainwindow is not loaded. Menus are disabled")
# if mainwindow loads later, need to refresh menu_creator
manager = omni.kit.app.get_app().get_extension_manager()
self._hooks.append(
manager.subscribe_to_extension_enable(
on_enable_fn=lambda _: self._mainwindow_loaded(),
on_disable_fn=None,
ext_name="omni.kit.mainwindow",
hook_name="omni.kit.menu.utils omni.kit.mainwindow listener",
)
)
# set app started trigger. refresh_menu_items & rebuild_menus won't do anything until self._ready_state is MenuState.Created
self._app_ready_sub = (
omni.kit.app.get_app()
.get_startup_event_stream()
.create_subscription_to_pop_by_type(
omni.kit.app.EVENT_APP_READY, self._build_menus_after_loading, name="omni.kit.menu.utils app started trigger"
)
)
def __on_ext_changed(self, ext_id: str, *_):
if ext_id.startswith("omni.kit.hotkeys.core"):
self.rebuild_menus()
def _mainwindow_loaded(self):
from .app_menu import AppMenu
self._menu_creator = AppMenu(lambda: _extension_instance)
self.rebuild_menus()
carb.log_info(f"omni.kit.mainwindow is now loaded. Menus are enabled")
def _build_menus_after_loading(self, event):
self._ready_state = MenuState.Created
self._menu_layout.menus_created()
self.rebuild_menus()
def on_shutdown(self):
global _extension_instance
_extension_instance = None
self.__extension_enabled_hook = None
self.__extension_disabled_hook = None
if self._menu_creator:
self._menu_creator.destroy()
del self._menu_creator
self._menu_creator = None
if self._menu_layout:
self._menu_layout.destroy()
del self._menu_layout
self._menu_layout = None
self._menus_to_refresh = None
self._refresh_task = None
self._menu_defs = None
self._menu_delegates = None
self._menu_order = None
self._hooks = None
def add_menu_items(self, menu: list, name: str, menu_index: int, rebuild_menus: bool, delegate = None) -> list:
if not menu and delegate:
menu = [MenuItemDescription(name="placeholder", show_fn=lambda: False)]
if menu and not isinstance(menu[0], MenuItemDescription):
carb.log_error(f"add_menu_items: menu {menu} is not a MenuItemDescription")
return None
self._stats["add_menu_items"] += 1
if not name in self._menu_defs:
self._menu_defs[name] = []
self._menu_defs[name].append(menu)
if name in self._menu_delegates:
_delegate, count = self._menu_delegates[name]
if delegate != _delegate:
carb.log_warn(f"add_menu_items: menu {menu} cannot change delegate")
self._menu_delegates[name] = (_delegate, count + 1)
elif delegate:
self._menu_delegates[name] = (delegate, 1)
if menu_index != 0 and name not in self._menu_order:
self._menu_order[name] = menu_index
if rebuild_menus:
self.rebuild_menus()
return menu
def set_default_menu_proirity(self, name: str, menu_index: int):
if menu_index == 0:
return
for index in self._menu_order:
if self._menu_order[index] == menu_index:
return
self._menu_order[name] = menu_index
def remove_menu_items(self, menu: list, name: str, rebuild_menus: bool):
self._stats["remove_menu_items"] += 1
try:
if name in self._menu_defs:
self._menu_defs[name].remove(menu)
if name in self._menu_delegates:
delegate, count = self._menu_delegates[name]
if count == 1:
del self._menu_delegates[name]
else:
self._menu_delegates[name] = (delegate, count - 1)
if rebuild_menus:
self.rebuild_menus()
except Exception as exc:
carb.log_warn(f"omni.kit.menu.utils remove_menu_items \"{name}\" failed {exc}")
def add_hook(self, callback: Callable):
self._stats["add_hook"] += 1
if self._menu_creator:
self._menu_creator.add_hook(callback)
def remove_hook(self, callback: Callable):
self._stats["remove_hook"] += 1
try:
if self._menu_creator:
self._menu_creator.remove_hook(callback)
except Exception as exc:
carb.log_warn(f"omni.kit.menu.utils remove_hook failed {exc}")
def add_layout(self, layout: List[Union[MenuLayout.Menu, MenuLayout.SubMenu, MenuLayout.Item, MenuLayout.Seperator, MenuLayout.Group]]):
self._stats["add_layout"] += 1
self._menu_layout.add_layout(layout)
self.rebuild_menus()
def remove_layout(self, layout: List[Union[MenuLayout.Menu, MenuLayout.SubMenu, MenuLayout.Item, MenuLayout.Seperator, MenuLayout.Group]]):
self._stats["remove_layout"] += 1
self._menu_layout.remove_layout(layout)
self.rebuild_menus()
def get_merged_menus(self):
return self._menu_creator.merge_menus(self._menu_defs.keys(), self._menu_defs, self._menu_order)
def refresh_menu_items(self, name: str, immediately: bool = False):
if not self._ready_state & MenuState.Created:
self._stats["refresh_menu_items_skipped"] += 1
return
self._stats["refresh_menu_items"] += 1
if self._menu_creator:
self._menu_creator.refresh_menu_items(name)
def rebuild_menus(self):
if not self._ready_state & MenuState.Created:
self._stats["rebuild_menus_skipped"] += 1
return
self._stats["rebuild_menus"] += 1
if self._menu_creator:
self._menu_creator.create_menu()
def get_menu_layout(self):
return self._menu_layout
def get_menu_data(self):
return self._menu_defs, self._menu_order, self._menu_delegates
def get_instance():
return _extension_instance
def add_menu_items(menu: list, name: str, menu_index: int = 0, rebuild_menus: bool = True, delegate = None):
"""
add a list of menus items to menu.
menu is list of MenuItemDescription()
name is name to appear when menu is collapsed
menu_index is horizontal positioning
rebuild_menus is flag to call rebuild_menus when True
delegate ui.MenuDelegate delegate
"""
instance = get_instance()
if instance:
return get_instance().add_menu_items(menu, name, menu_index, rebuild_menus, delegate)
def remove_menu_items(menu: list, name: str, rebuild_menus: bool = True):
"""
remove a list of menus items to menu.
menu is list of MenuItemDescription()
name is name to appear when menu is collapsed
rebuild_menus is flag to call rebuild_menus when True
"""
instance = get_instance()
if instance:
instance.remove_menu_items(menu, name, rebuild_menus)
def refresh_menu_items(name: str, immediately = None):
"""
update menus enabled state
menu is list of MenuItemDescription()
name is name to appear when menu is collapsed
immediately is deprecated and not used
"""
instance = get_instance()
if instance:
carb.log_info(f"omni.kit.menu.utils.refresh_menu_items {name}")
if immediately != None:
carb.log_warn(f"refresh_menu_items immediately parameter is deprecated and not used")
instance.refresh_menu_items(name)
def add_hook(callback: Callable):
"""
add a menu modification callback hook
callback is function to be called when menus are re-generated
"""
instance = get_instance()
if instance:
instance.add_hook(callback)
def remove_hook(callback: Callable):
"""
remove a menu modification callback hook
callback is function to be called when menus are re-generated
"""
instance = get_instance()
if instance:
instance.remove_hook(callback)
def rebuild_menus():
"""
force menus to rebuild, triggering hooks
"""
instance = get_instance()
if instance:
carb.log_info(f"omni.kit.menu.utils.rebuild_menus")
instance.rebuild_menus()
def set_default_menu_proirity(name, menu_index):
"""
set default menu priority
"""
instance = get_instance()
if instance:
instance.set_default_menu_proirity(name, menu_index)
def add_layout(layout: List[Union[MenuLayout.Menu, MenuLayout.SubMenu, MenuLayout.Item, MenuLayout.Seperator, MenuLayout.Group]]):
"""
add a menu layout.
"""
instance = get_instance()
if instance:
instance.add_layout(layout)
def remove_layout(layout: List[Union[MenuLayout.Menu, MenuLayout.SubMenu, MenuLayout.Item, MenuLayout.Seperator, MenuLayout.Group]]):
"""
remove a menu layout.
"""
instance = get_instance()
if instance:
instance.remove_layout(layout)
def get_menu_layout():
"""
get menu layouts.
"""
instance = get_instance()
if instance:
return instance.get_menu_layout().get_layout()
def get_merged_menus() -> dict:
"""
get combined menus as dictionary
"""
instance = get_instance()
if instance:
return instance.get_merged_menus()
return None
def get_debug_stats() -> dict:
instance = get_instance()
if instance:
return instance._stats
return None
| 12,910 |
Python
| 32.710183 | 143 | 0.617041 |
omniverse-code/kit/exts/omni.kit.menu.utils/omni/kit/menu/utils/scripts/actions.py
|
"""Actions Omniverse Kit API
Module to work with **Actions** in the Kit. It is built on top of ``carb.input`` system that features action mapping logic.
"""
import omni.kit.ui
import omni.appwindow
import carb.input
import carb.settings
from typing import Callable, Tuple
import functools
class ActionMenuSubscription:
"""
Action menu subscription wrapper to make it scoped (auto unsubscribe on del)
"""
def __init__(self, _on_del: Callable):
self._on_del = _on_del
self._mapped = True
def unsubscribe(self):
if self._mapped:
self._mapped = False
self._on_del()
def __del__(self):
self.unsubscribe()
def add_action_to_menu(
menu_path: str,
on_action: Callable,
action_name: str = None,
default_hotkey: Tuple[int, int] = None,
on_rmb_click: Callable = None,
) -> ActionMenuSubscription:
"""
Add action to menu path.
This function binds passed callable `on_action` function with :mod:`carb.input` action and a menu path together. If
`default_hotkey` is provided it is set into settings and appears on the menu.
Args:
menu_path: menu path. E.g. "File/Open".
on_action: function to be called as an action.
on_rmb_click: function to be called when right mouse button clicked.
action_name: action name. If not provided menu path is used as action, where all '/' are replaced with '-'.
default_hotkey(tuple(int, :class:`carb.input.KeyboardInput`)): modifier and key tuple to associate with given action.
Returns:
Subscription holder object. Action is removed when this object is destroyed.
"""
return omni.kit.ui.get_editor_menu().add_action_to_menu(menu_path, on_action, action_name, default_hotkey, on_rmb_click)
def unsubsribe():
input.unsubscribe_to_action_events(sub_id)
menu = omni.kit.ui.get_editor_menu()
if menu:
menu.set_action(menu_path, action_mapping_set_path, "")
return ActionMenuSubscription(unsubsribe)
| 2,051 |
Python
| 31.0625 | 125 | 0.665529 |
omniverse-code/kit/exts/omni.kit.menu.utils/omni/kit/menu/utils/scripts/layout.py
|
import os
import carb
import carb.settings
from typing import List, Union, Dict
from enum import Enum
from .builder_utils import get_action_path, create_prebuild_entry
from .builder_utils import MenuItemDescription, PrebuiltItemOrder, LayoutSourceSearch
class MenuLayout:
class MenuLayoutItem:
def __init__(self, name=None, source=None, source_search=LayoutSourceSearch.EVERYWHERE):
self.name = name
self.source = source
self.source_search = source_search
def __repr__(self):
if self.source:
return f"<{self.__class__} name:{self.name} source:{self.source}>"
return f"<{self.__class__} name:{self.name}>"
def json_enc(self):
sub_items = {}
values = {f"MenuLayout.{self.__class__.__name__}": sub_items}
for index in dir(self):
if not index.startswith("_"):
item = getattr(self, index)
if item is not None and not callable(item):
sub_items[index] = item
return values
class Menu(MenuLayoutItem):
def __init__(self, name, items=[], source=None, source_search=LayoutSourceSearch.EVERYWHERE, remove=False):
super().__init__(name, source, source_search)
self.items = items
self.remove = remove
class SubMenu(MenuLayoutItem):
def __init__(self, name, items=[], source=None, source_search=LayoutSourceSearch.EVERYWHERE, remove=False):
super().__init__(name, source, source_search)
self.items = items
self.remove = remove
class Item(MenuLayoutItem):
def __init__(self, name, source=None, source_search=LayoutSourceSearch.EVERYWHERE, remove=False):
super().__init__(name, source, source_search)
self.remove = remove
class Seperator(MenuLayoutItem):
def __init__(self, name=None, source=None, source_search=LayoutSourceSearch.EVERYWHERE):
super().__init__(name, source, source_search)
class Group(MenuLayoutItem):
def __init__(self, name, items=[], source=None, source_search=LayoutSourceSearch.EVERYWHERE):
super().__init__(name, source, source_search)
self.items = items
class Sort(MenuLayoutItem):
def __init__(self, name=None, source=None, source_search=LayoutSourceSearch.EVERYWHERE, exclude_items=[], sort_submenus=False):
super().__init__(name, source)
self.items = exclude_items
self.sort_submenus = sort_submenus
def __repr__(self):
return f"<{self.__class__} items:{self.items}>"
def __init__(self, debuglog = False):
self._layout_template = []
self._menus_created = False
self._debuglog = debuglog
def __del__(self):
self.destroy()
def destroy(self):
self._layout_template = None
def menus_created(self):
self._menus_created = True
def add_layout(self, layout: List[MenuLayoutItem]):
self._layout_template.append(layout.copy())
def remove_layout(self, layout: List[MenuLayoutItem]):
self._layout_template.remove(layout)
def get_layout(self):
return self._layout_template
def apply_layout(self, prebuilt_menus: dict):
if not self._menus_created:
return
menu_layout_lists = self.get_layout()
for menu_layout in menu_layout_lists:
MenuLayout.process_layout(prebuilt_menus, menu_layout, menu_name=None, submenu_name=None, parent_layout_offset=0, parent_layout_index=PrebuiltItemOrder.UNORDERED, debuglog=self._debuglog)
# static functions to prevent self leaks
@staticmethod
def find_menu_item(menu_items: List, menu_items_root: List, layout_item: MenuLayoutItem):
if layout_item.source:
if "/" in layout_item.source.replace("\\", "/"):
sub_name = get_action_path(os.path.dirname(layout_item.source), "")
sub_prefix = os.path.basename(layout_item.source)
if sub_name in menu_items_root:
menu_subitems = menu_items_root[sub_name]["items"]
for item in menu_subitems:
if item.name == sub_prefix:
return item, menu_subitems, sub_name
return None, None, None
for item in menu_items:
if item.name == layout_item.source:
return item, None, None
else:
for item in menu_items:
if item.name == layout_item.name:
return item, None, None
if layout_item.source_search == LayoutSourceSearch.EVERYWHERE:
# not in current menu, search them all....
for sub_name in menu_items_root.keys():
menu_subitems = menu_items_root[sub_name]["items"]
for item in menu_subitems:
if item.name == layout_item.name:
layout_item.source = f"{sub_name}/{layout_item.name}"
return item, menu_subitems, sub_name
return None, None, None
@staticmethod
def process_layout(prebuilt_menus: dict, menu_layout:List, menu_name: str, submenu_name: str, parent_layout_offset: int, parent_layout_index: int, debuglog: bool):
def item_in_menu(menus, menu_name):
for sub_item in menus:
if sub_item.name == menu_name:
return True
return False
def create_menu_entry(menu_name, submenu_name):
action_prefix = get_action_path(menu_name, submenu_name)
if not action_prefix in prebuilt_menus:
if menu_name in prebuilt_menus:
menu_subitems = prebuilt_menus[menu_name]["items"]
# if item not already in submenu, add it
if not item_in_menu(menu_subitems, submenu_name):
item = MenuItemDescription(submenu_name, sub_menu=action_prefix)
item.user["prebuilt_order"] = PrebuiltItemOrder.LAYOUT_ORDERED + parent_layout_offset + parent_layout_index
menu_subitems.append(item)
create_prebuild_entry(prebuilt_menus, submenu_name, action_prefix)
prebuilt_menus[action_prefix]["sub_menu"] = True
for layout_index, layout_item in enumerate(menu_layout):
# MenuLayout.Menu
if isinstance(layout_item, MenuLayout.Menu):
action_prefix = get_action_path(layout_item.name, None)
if layout_item.remove:
if action_prefix in prebuilt_menus:
del prebuilt_menus[action_prefix]
elif debuglog:
carb.log_warn(f"Warning: Layout item {layout_item} not found in prebuilt_menus")
else:
# menu doesn't exist, create one
if not action_prefix in prebuilt_menus:
carb.log_warn(f"Menu {layout_item.name} not found. Create with; (\"menu_index\" controls menu order)")
carb.log_warn(f" self._menu_placeholder = omni.kit.menu.utils.add_menu_items([MenuItemDescription(name=\"placeholder\", show_fn=lambda: False)], name=\"{layout_item.name}\", menu_index=90)")
continue
MenuLayout.process_layout(prebuilt_menus, layout_item.items, layout_item.name, submenu_name, 0, layout_index, debuglog)
# MenuLayout.SubMenu
elif isinstance(layout_item, MenuLayout.SubMenu):
if not menu_name:
carb.log_warn(f"Warning: Bad Layout item {layout_item}. Cannot have SubMenu without Menu as parent")
if layout_item.remove:
action_prefix = get_action_path(menu_name, layout_item.name)
if action_prefix in prebuilt_menus:
del prebuilt_menus[action_prefix]
menu_subitems = prebuilt_menus[menu_name]["items"]
for item in menu_subitems:
if item.sub_menu == layout_item.name:
menu_subitems.remove(item)
break
elif debuglog:
carb.log_warn(f"Warning: Layout item {layout_item} not found in prebuilt_menus")
else:
action_prefix = get_action_path(menu_name, None)
if action_prefix in prebuilt_menus:
menu_subitems = prebuilt_menus[action_prefix]["items"]
menu_subitem, source_menu, _ = MenuLayout.find_menu_item(menu_subitems, prebuilt_menus, layout_item)
if menu_subitem:
menu_subitem.user["prebuilt_order"] = PrebuiltItemOrder.LAYOUT_ORDERED + parent_layout_offset + layout_index
else:
# add submenu item
menu_subitem = MenuItemDescription(name=layout_item.name, sub_menu=get_action_path(menu_name, layout_item.name))
menu_subitems.append(menu_subitem)
menu_subitem.user["prebuilt_order"] = PrebuiltItemOrder.LAYOUT_ORDERED + parent_layout_offset + layout_index
if submenu_name:
action_prefix = get_action_path(menu_name, submenu_name)
MenuLayout.process_layout(prebuilt_menus, layout_item.items, action_prefix, layout_item.name, parent_layout_offset, layout_index + 1, debuglog)
else:
MenuLayout.process_layout(prebuilt_menus, layout_item.items, menu_name, layout_item.name, parent_layout_offset, layout_index, debuglog)
parent_layout_offset += len(layout_item.items) + 1
# MenuLayout.Item
elif isinstance(layout_item, MenuLayout.Item):
action_prefix = get_action_path(menu_name, submenu_name)
create_menu_entry(menu_name, submenu_name)
menu_subitems = prebuilt_menus[action_prefix]["items"]
menu_subitem, source_menu, orig_root_menu = MenuLayout.find_menu_item(menu_subitems, prebuilt_menus, layout_item)
if not submenu_name and orig_root_menu:
prebuilt_menus[orig_root_menu]["remapped"].append(action_prefix)
if menu_subitem:
menu_subitem.user["prebuilt_order"] = PrebuiltItemOrder.LAYOUT_ORDERED + parent_layout_offset + layout_index
if source_menu and source_menu != menu_subitems:
menu_subitems.append(menu_subitem)
source_menu.remove(menu_subitem)
if layout_item.source:
menu_subitem.name = layout_item.name
else:
if layout_item.remove:
menu_subitems.remove(menu_subitem)
elif layout_item.source:
menu_subitem.name = layout_item.name
elif debuglog:
carb.log_warn(f"Warning: Layout not found {layout_item}")
# MenuLayout.Seperator
elif isinstance(layout_item, MenuLayout.Seperator):
action_prefix = get_action_path(menu_name, submenu_name)
if action_prefix in prebuilt_menus:
menu_subitems = prebuilt_menus[action_prefix]["items"]
item = MenuItemDescription()
if layout_item.name:
item.header = layout_item.name
item.user["prebuilt_order"] = PrebuiltItemOrder.LAYOUT_ORDERED + parent_layout_offset + layout_index
menu_subitems.append(item)
# MenuLayout.Group
elif isinstance(layout_item, MenuLayout.Group):
action_prefix = get_action_path(menu_name, submenu_name)
create_menu_entry(menu_name, submenu_name)
menu_subitems = prebuilt_menus[action_prefix]["items"]
item = MenuItemDescription(header=layout_item.name)
item.user["prebuilt_order"] = PrebuiltItemOrder.LAYOUT_ORDERED + parent_layout_offset + layout_index
menu_subitems.append(item)
MenuLayout.process_layout(prebuilt_menus, layout_item.items, menu_name, submenu_name, parent_layout_offset + layout_index + 1, parent_layout_index, debuglog)
parent_layout_offset += len(layout_item.items) + 1
if layout_item.source:
menu_subitem, source_menu, _ = MenuLayout.find_menu_item(menu_subitems, prebuilt_menus, layout_item)
if source_menu and source_menu != menu_subitems:
if menu_subitem.sub_menu:
for item in prebuilt_menus[menu_subitem.sub_menu]["items"]:
item.user["prebuilt_order"] = PrebuiltItemOrder.LAYOUT_ORDERED + parent_layout_offset + layout_index
menu_subitems.append(item)
parent_layout_offset += 1
else:
menu_subitems.append(menu_subitem)
source_menu.remove(menu_subitem)
# MenuLayout.Sort
elif isinstance(layout_item, MenuLayout.Sort):
action_prefix = get_action_path(menu_name, submenu_name)
create_menu_entry(menu_name, submenu_name)
menu_subitems = prebuilt_menus[action_prefix]["items"]
sort_submenus = []
items = [i for i in menu_subitems if i.name != "" and not i.name in layout_item.items]
for index, item in enumerate(sorted(items, key=lambda a: a.name)):
item_offset = PrebuiltItemOrder.LAYOUT_SUBMENU_SORTED if item.sub_menu else PrebuiltItemOrder.LAYOUT_ITEM_SORTED
item.user["prebuilt_order"] = item_offset + parent_layout_offset + index
if layout_item.sort_submenus and item.sub_menu and not item.sub_menu in layout_item.items:
sort_submenus.append(item.sub_menu)
for sub_menu in sort_submenus:
item_list = prebuilt_menus[sub_menu]["items"]
# seperators must not move, just sort items inbetween
groups = []
last_seperator = 0
for index, item in enumerate(item_list):
if item.name == "":
if last_seperator != index:
groups.append((last_seperator, index))
last_seperator = index
if last_seperator:
groups.append((last_seperator, len(item_list)))
for gstart, gend in groups:
items = [i for i in item_list[gstart : gend] if not i.name in layout_item.items]
item_offset = items[0].user["prebuilt_order"]
items = items[1:]
for index, item in enumerate(sorted(items, key=lambda a: a.name)):
item.user["prebuilt_order"] = item_offset + index
if item.sub_menu and not item.sub_menu in layout_item.items:
sort_submenus.append(item.sub_menu)
else:
items = [i for i in item_list if not i.name in layout_item.items]
for index, item in enumerate(sorted(items, key=lambda a: a.name)):
item_offset = PrebuiltItemOrder.LAYOUT_SUBMENU_SORTED if item.sub_menu else PrebuiltItemOrder.LAYOUT_ITEM_SORTED
item.user["prebuilt_order"] = item_offset + parent_layout_offset + index
if item.sub_menu and not item.sub_menu in layout_item.items:
sort_submenus.append(item.sub_menu)
elif debuglog:
carb.log_warn(f"Warning: Unknown layout type {layout_item}")
| 16,446 |
Python
| 52.748366 | 215 | 0.557522 |
omniverse-code/kit/exts/omni.kit.menu.utils/omni/kit/menu/utils/tests/test_debug_menu.py
|
import os
import unittest
import pathlib
import carb
import carb.input
import omni.kit.test
import omni.ui as ui
from pathlib import Path
from omni.kit import ui_test
from omni.ui.tests.test_base import OmniUiTest
from omni.kit.test_suite.helpers import get_test_data_path
class TestDebugMenu(OmniUiTest):
async def setUp(self):
pass
async def tearDown(self):
pass
async def test_debug_menu(self):
DebugWindowName = "omni.kit.menu.utils debug"
# hotkey - show_menu_debug_window
await ui_test.emulate_keyboard_press(carb.input.KeyboardInput.M, carb.input.KEYBOARD_MODIFIER_FLAG_CONTROL + carb.input.KEYBOARD_MODIFIER_FLAG_ALT + carb.input.KEYBOARD_MODIFIER_FLAG_SHIFT)
await ui_test.human_delay(50)
golden_img_dir = pathlib.Path(get_test_data_path(__name__, "golden_img"))
await self.docked_test_window(
window=ui.Workspace.get_window(DebugWindowName),
width=450,
height=300)
await self.finalize_test(golden_img_dir=golden_img_dir, golden_img_name="test_debug_window.png")
await ui_test.human_delay(50)
ui.Workspace.show_window(DebugWindowName, False)
| 1,195 |
Python
| 30.473683 | 197 | 0.699582 |
omniverse-code/kit/exts/omni.kit.menu.utils/omni/kit/menu/utils/tests/test_menu_layouts.py
|
import os
import unittest
import carb
import omni.kit.test
import omni.ui as ui
from omni.kit import ui_test
from omni.kit.menu.utils import MenuItemDescription, MenuLayout, LayoutSourceSearch
from .utils import verify_menu_items, verify_menu_checked_items
class TestMenuLayoutUtils(omni.kit.test.AsyncTestCase):
async def setUp(self):
pass
async def tearDown(self):
pass
async def test_nested_submenu_layout(self):
menu_placeholder = [MenuItemDescription(name="placeholder", show_fn=lambda: False)]
menu_physics = [ MenuItemDescription(name="Physics", sub_menu=[
MenuItemDescription(name="Debug"),
MenuItemDescription(name="Settings"),
MenuItemDescription(name="Demo Scenes"),
MenuItemDescription(name="Test Runner"),
MenuItemDescription(name="Character Controller")]) ]
menu_blast = [ MenuItemDescription(name="Blast", sub_menu=[
MenuItemDescription(name="Settings"),
MenuItemDescription(name="Documentation", sub_menu=[
MenuItemDescription(name="Kit UI"),
MenuItemDescription(name="Programming"),
MenuItemDescription(name="USD Schemas")]) ])]
menu_flow = [ MenuItemDescription(name="Flow", sub_menu=[
MenuItemDescription(name="Presets"),
MenuItemDescription(name="Monitor")]) ]
# add menu
omni.kit.menu.utils.add_menu_items(menu_placeholder, "Window", 90)
omni.kit.menu.utils.add_menu_items(menu_physics, "Window")
omni.kit.menu.utils.add_menu_items(menu_blast, "Window")
omni.kit.menu.utils.add_menu_items(menu_flow, "Window")
await ui_test.human_delay()
# ----------------------------------------------------
# nested layout test
# ----------------------------------------------------
menu_layout = [
MenuLayout.Menu("Window", [
MenuLayout.SubMenu("Simulation", [
MenuLayout.Group("Flow", [
MenuLayout.Item("Presets", source="Window/Flow/Presets"),
MenuLayout.Item("Monitor", source="Window/Flow/Monitor"),
]),
MenuLayout.Group("Blast", [
MenuLayout.Item("Settings", source="Window/Blast/Settings"),
MenuLayout.SubMenu("Documentation", [
MenuLayout.Item("Kit UI", source="Window/Blast/Documentation/Kit UI"),
MenuLayout.Item("Programming", source="Window/Blast/Documentation/Programming"),
MenuLayout.Item("USD Schemas", source="Window/Blast/Documentation/USD Schemas"),
]),
]),
MenuLayout.Group("Physics", [
MenuLayout.Item("Demo Scenes"),
MenuLayout.Item("Settings", source="Window/Physics/Settings"),
MenuLayout.Item("Debug"),
MenuLayout.Item("Test Runner"),
MenuLayout.Item("Character Controller")
]),
]),
])
]
omni.kit.menu.utils.add_layout(menu_layout)
# verify layout
verify_menu_items(self, [(ui.Menu, "Window", True), (ui.Menu, "Simulation", True), (ui.MenuItem, "placeholder", False), (ui.Menu, "Physics", False), (ui.Menu, "Blast", False), (ui.Menu, "Flow", False), (ui.Separator, "Flow", True), (ui.MenuItem, "Presets", True), (ui.MenuItem, "Monitor", True), (ui.Separator, "Blast", True), (ui.MenuItem, "Settings", True), (ui.Menu, "Documentation", True), (ui.Separator, "Physics", True), (ui.MenuItem, "Demo Scenes", True), (ui.MenuItem, "Settings", True), (ui.MenuItem, "Debug", True), (ui.MenuItem, "Test Runner", True), (ui.MenuItem, "Character Controller", True), (ui.MenuItem, "Kit UI", True), (ui.MenuItem, "Programming", True), (ui.MenuItem, "USD Schemas", True), (ui.Menu, "Documentation", False)])
# remove layout
omni.kit.menu.utils.remove_layout(menu_layout)
self.assertTrue(omni.kit.menu.utils.get_menu_layout() == [])
# remove menu
omni.kit.menu.utils.remove_menu_items(menu_physics, "Window")
omni.kit.menu.utils.remove_menu_items(menu_blast, "Window")
omni.kit.menu.utils.remove_menu_items(menu_flow, "Window")
omni.kit.menu.utils.remove_menu_items(menu_placeholder, "Window")
self.assertTrue(omni.kit.menu.utils.get_merged_menus() == {})
async def test_remapped_layout_checkbox(self):
menu_placeholder = [MenuItemDescription(name="placeholder", show_fn=lambda: False)]
async def refresh_menus():
await ui_test.menu_click("Tools", human_delay_speed=4, show=True)
await ui_test.menu_click("More Tools", human_delay_speed=4, show=True)
await ui_test.menu_click("More Tools", human_delay_speed=4, show=False)
example_window_is_ticked = False
def get_example_window_is_ticked():
nonlocal example_window_is_ticked
return example_window_is_ticked
def toggle_example_window_is_ticked():
nonlocal example_window_is_ticked
example_window_is_ticked = not example_window_is_ticked
menu_entry1 = [ MenuItemDescription(name="Example Window", ticked=True, ticked_fn=get_example_window_is_ticked, onclick_fn=toggle_example_window_is_ticked) ]
menu_entry2 = [ MenuItemDescription(name="Best Window Ever", ticked=True, ticked_fn=get_example_window_is_ticked, onclick_fn=toggle_example_window_is_ticked) ]
# add menu
omni.kit.menu.utils.add_menu_items(menu_placeholder, "Tools")
omni.kit.menu.utils.add_menu_items(menu_placeholder, "More Tools")
omni.kit.menu.utils.add_menu_items(menu_entry1, "Window")
omni.kit.menu.utils.add_menu_items(menu_entry2, "Window")
await ui_test.human_delay()
# more the "Example Window" and "Best Window Ever" to differrent menus
menu_layout = [
MenuLayout.Menu("Tools", [
MenuLayout.Item("Stage Window", source="Window/Example Window")
]),
MenuLayout.Menu("More Tools", [
MenuLayout.Item("Another Stage Window", source="Window/Best Window Ever")
]),
MenuLayout.Menu("More Cheese", [
MenuLayout.Item("Not A Menu Item", source="No Menu/Worst Window Ever")
])
]
omni.kit.menu.utils.add_layout(menu_layout)
await ui_test.human_delay()
# update checked status (checked) - refreshing window should refresh "Tools" and "More Tools"
example_window_is_ticked = True
omni.kit.menu.utils.refresh_menu_items("Window")
# open menu as items are not refreshed on refresh_menu_items
await refresh_menus()
# verify
verify_menu_checked_items(self, [(ui.Menu, "Tools", True, False, False), (ui.Menu, "More Tools", True, False, False), (ui.Menu, "Window", False, False, False), (ui.MenuItem, "Stage Window", True, True, True), (ui.MenuItem, "Another Stage Window", True, True, True)])
# update checked status (unchecked) - refreshing window should refresh "Tools" and "More Tools"
example_window_is_ticked = False
omni.kit.menu.utils.refresh_menu_items("Window")
# open menu as items are not refreshed on refresh_menu_items
await refresh_menus()
# verify
verify_menu_checked_items(self, [(ui.Menu, "Tools", True, False, False), (ui.Menu, "More Tools", True, False, False), (ui.Menu, "Window", False, False, False), (ui.MenuItem, "Stage Window", True, True, False), (ui.MenuItem, "Another Stage Window", True, True, False)])
# remove layout
omni.kit.menu.utils.remove_layout(menu_layout)
self.assertTrue(omni.kit.menu.utils.get_menu_layout() == [])
# remove menu
omni.kit.menu.utils.remove_menu_items(menu_entry2, "Window")
omni.kit.menu.utils.remove_menu_items(menu_entry1, "Window")
omni.kit.menu.utils.remove_menu_items(menu_placeholder, "Tools")
omni.kit.menu.utils.remove_menu_items(menu_placeholder, "More Tools")
self.assertTrue(omni.kit.menu.utils.get_merged_menus() == {})
async def test_layout_local_source(self):
menu_placeholder = [MenuItemDescription(name="placeholder", show_fn=lambda: False)]
menu_physics = [ MenuItemDescription(name="Physics", sub_menu=[
MenuItemDescription(name="Debug"),
MenuItemDescription(name="Settings"),
MenuItemDescription(name="Demo Scenes"),
MenuItemDescription(name="Test Runner"),
MenuItemDescription(name="Character Controller")]) ]
menu_blast = [ MenuItemDescription(name="Blast", sub_menu=[
MenuItemDescription(name="Settings"),
MenuItemDescription(name="Documentation", sub_menu=[
MenuItemDescription(name="Kit UI"),
MenuItemDescription(name="Programming"),
MenuItemDescription(name="USD Schemas")]) ])]
menu_flow = [ MenuItemDescription(name="Flow", sub_menu=[
MenuItemDescription(name="Presets"),
MenuItemDescription(name="Monitor")]) ]
# add menu
omni.kit.menu.utils.add_menu_items(menu_placeholder, "Window", 90)
omni.kit.menu.utils.add_menu_items(menu_physics, "Window")
omni.kit.menu.utils.add_menu_items(menu_blast, "Window")
omni.kit.menu.utils.add_menu_items(menu_flow, "Window")
await ui_test.human_delay()
# ----------------------------------------------------
# nested layout test
# ----------------------------------------------------
menu_layout = [
MenuLayout.Menu("Window", [
MenuLayout.SubMenu("Simulation", [
MenuLayout.Group("Flow", [
MenuLayout.Item("Presets", source="Window/Flow/Presets"),
MenuLayout.Item("Monitor", source="Window/Flow/Monitor"),
]),
MenuLayout.Group("Blast", [
MenuLayout.Item("Settings", source="Window/Blast/Settings"),
MenuLayout.SubMenu("Documentation", [
MenuLayout.Item("Kit UI", source="Window/Blast/Documentation/Kit UI"),
MenuLayout.Item("Programming", source="Window/Blast/Documentation/Programming"),
MenuLayout.Item("USD Schemas", source="Window/Blast/Documentation/USD Schemas"),
]),
]),
MenuLayout.Group("Physics", [
MenuLayout.Item("Demo Scenes"),
MenuLayout.Item("Settings", source="Window/Physics/Settings"),
MenuLayout.Item("Debug"),
MenuLayout.Item("Test Runner"),
MenuLayout.Item("Character Controller")
]),
]),
# these should not be moved as they are local only
MenuLayout.Item("Demo Scenes", source_search=LayoutSourceSearch.LOCAL_ONLY),
MenuLayout.Item("Settings", source_search=LayoutSourceSearch.LOCAL_ONLY),
MenuLayout.Item("Debug", source_search=LayoutSourceSearch.LOCAL_ONLY),
MenuLayout.Item("Test Runner", source_search=LayoutSourceSearch.LOCAL_ONLY),
MenuLayout.Item("Character Controller", source_search=LayoutSourceSearch.LOCAL_ONLY),
])
]
omni.kit.menu.utils.add_layout(menu_layout)
# verify layout
verify_menu_items(self, [(ui.Menu, "Window", True), (ui.Menu, "Simulation", True), (ui.MenuItem, "placeholder", False), (ui.Menu, "Physics", False), (ui.Menu, "Blast", False), (ui.Menu, "Flow", False), (ui.Separator, "Flow", True), (ui.MenuItem, "Presets", True), (ui.MenuItem, "Monitor", True), (ui.Separator, "Blast", True), (ui.MenuItem, "Settings", True), (ui.Menu, "Documentation", True), (ui.Separator, "Physics", True), (ui.MenuItem, "Demo Scenes", True), (ui.MenuItem, "Settings", True), (ui.MenuItem, "Debug", True), (ui.MenuItem, "Test Runner", True), (ui.MenuItem, "Character Controller", True), (ui.MenuItem, "Kit UI", True), (ui.MenuItem, "Programming", True), (ui.MenuItem, "USD Schemas", True), (ui.Menu, "Documentation", False)])
# remove layout
omni.kit.menu.utils.remove_layout(menu_layout)
self.assertTrue(omni.kit.menu.utils.get_menu_layout() == [])
# remove menu
omni.kit.menu.utils.remove_menu_items(menu_physics, "Window")
omni.kit.menu.utils.remove_menu_items(menu_blast, "Window")
omni.kit.menu.utils.remove_menu_items(menu_flow, "Window")
omni.kit.menu.utils.remove_menu_items(menu_placeholder, "Window")
self.assertTrue(omni.kit.menu.utils.get_merged_menus() == {})
| 13,396 |
Python
| 55.766949 | 753 | 0.581293 |
omniverse-code/kit/exts/omni.kit.menu.utils/omni/kit/menu/utils/tests/test_right_menus.py
|
import os
import unittest
import carb
import omni.kit.test
import omni.ui as ui
from typing import Callable, Union
from omni.kit import ui_test
from omni.kit.menu.utils import MenuItemDescription, MenuAlignment
from .utils import verify_menu_items
class TestMenuRightAlignedUtils(omni.kit.test.AsyncTestCase):
async def setUp(self):
pass
async def tearDown(self):
pass
async def test_right_menu(self):
class MenuDelegate(ui.MenuDelegate):
def __init__(self, **kwargs):
super().__init__(**kwargs)
def build_item(self, item: ui.MenuHelper):
super().build_item(item)
def build_status(self, item: ui.MenuHelper):
super().build_status(item)
def build_title(self, item: ui.MenuHelper):
super().build_title(item)
def get_menu_alignment(self):
return MenuAlignment.RIGHT
class MenuDelegateHidden(MenuDelegate):
def update_menu_item(self, menu_item: Union[ui.Menu, ui.MenuItem], menu_refresh: bool):
if isinstance(menu_item, ui.MenuItem):
menu_item.visible = False
elif isinstance(menu_item, ui.Menu):
menu_item.visible = True
class MenuDelegateButton(MenuDelegate):
def build_item(self, item: ui.MenuHelper):
with ui.HStack(width=0):
with ui.VStack(content_clipping=1, width=0):
ui.Button("Button", style={"margin": 0}, clicked_fn=lambda: print("clicked"))
# ----------------------------------------------------
# left aligned menu
# ----------------------------------------------------
submenu_list3 = [ MenuItemDescription(name="SubMenu Item") ]
submenu_list2 = [ MenuItemDescription(name="SubMenu 2", sub_menu=submenu_list3) ]
submenu_list1 = [ MenuItemDescription(name="SubMenu 1", sub_menu=submenu_list2) ]
left_menu_list = [ MenuItemDescription(name="Root Item", sub_menu=submenu_list1) ]
# add menu
omni.kit.menu.utils.add_menu_items(left_menu_list, "SubMenu Test", 99)
verify_menu_items(self, [(ui.Menu, "SubMenu Test", True), (ui.Menu, "Root Item", True), (ui.Menu, "SubMenu 1", True), (ui.Menu, "SubMenu 2", True), (ui.MenuItem, "SubMenu Item", True)])
# refresh and verify
omni.kit.menu.utils.refresh_menu_items("SubMenu Test")
verify_menu_items(self, [(ui.Menu, "SubMenu Test", True), (ui.Menu, "Root Item", True), (ui.Menu, "SubMenu 1", True), (ui.Menu, "SubMenu 2", True), (ui.MenuItem, "SubMenu Item", True)])
# ----------------------------------------------------
# right aligned menu
# ----------------------------------------------------
right_menu_list = [ MenuItemDescription(name="SubMenu Item 1"), MenuItemDescription(name="SubMenu Item 2") ]
right_menu1 = omni.kit.menu.utils.add_menu_items(right_menu_list, "Right Menu Test 1", delegate=MenuDelegate())
right_menu2 = omni.kit.menu.utils.add_menu_items(right_menu_list, "Right Menu Test 2", delegate=MenuDelegate())
right_menu3 = omni.kit.menu.utils.add_menu_items([], name="Empty Menu", delegate=MenuDelegateHidden())
right_menu4 = omni.kit.menu.utils.add_menu_items([], name="Button Menu", delegate=MenuDelegateButton())
# verify
verify_menu_items(self, [(ui.Menu, "SubMenu Test", True), (ui.Spacer, True), (ui.Menu, "Right Menu Test 1", True), (ui.Menu, "Right Menu Test 2", True), (ui.Menu, "Empty Menu", True), (ui.Menu, "Button Menu", True), (ui.Spacer, True), (ui.Menu, "Root Item", True), (ui.Menu, "SubMenu 1", True), (ui.Menu, "SubMenu 2", True), (ui.MenuItem, "SubMenu Item", True), (ui.MenuItem, "SubMenu Item 1", True), (ui.MenuItem, "SubMenu Item 2", True), (ui.MenuItem, "SubMenu Item 1", True), (ui.MenuItem, "SubMenu Item 2", True), (ui.MenuItem, "placeholder", False), (ui.MenuItem, "placeholder", False)], True)
# refresh and verify
omni.kit.menu.utils.refresh_menu_items("Right Menu Test 1")
verify_menu_items(self, [(ui.Menu, "SubMenu Test", True), (ui.Spacer, True), (ui.Menu, "Right Menu Test 1", True), (ui.Menu, "Right Menu Test 2", True), (ui.Menu, "Empty Menu", True), (ui.Menu, "Button Menu", True), (ui.Spacer, True), (ui.Menu, "Root Item", True), (ui.Menu, "SubMenu 1", True), (ui.Menu, "SubMenu 2", True), (ui.MenuItem, "SubMenu Item", True), (ui.MenuItem, "SubMenu Item 1", True), (ui.MenuItem, "SubMenu Item 2", True), (ui.MenuItem, "SubMenu Item 1", True), (ui.MenuItem, "SubMenu Item 2", True), (ui.MenuItem, "placeholder", False), (ui.MenuItem, "placeholder", False)], True)
# remove menus
omni.kit.menu.utils.remove_menu_items(left_menu_list, "SubMenu Test")
omni.kit.menu.utils.remove_menu_items(right_menu1, "Right Menu Test 1")
omni.kit.menu.utils.remove_menu_items(right_menu2, "Right Menu Test 2")
omni.kit.menu.utils.remove_menu_items(right_menu3, "Empty Menu")
omni.kit.menu.utils.remove_menu_items(right_menu4, "Button Menu")
# verify menus removed
self.assertTrue(omni.kit.menu.utils.get_merged_menus() == {})
async def test_multi_delegate_menu(self):
class MenuDelegate(ui.MenuDelegate):
def __init__(self, **kwargs):
super().__init__(**kwargs)
def build_item(self, item: ui.MenuHelper):
super().build_item(item)
def build_status(self, item: ui.MenuHelper):
super().build_status(item)
def build_title(self, item: ui.MenuHelper):
super().build_title(item)
def get_menu_alignment(self):
return MenuAlignment.RIGHT
class MenuDelegateHidden(MenuDelegate):
def update_menu_item(self, menu_item: Union[ui.Menu, ui.MenuItem], menu_refresh: bool):
if isinstance(menu_item, ui.MenuItem):
menu_item.visible = False
elif isinstance(menu_item, ui.Menu):
menu_item.visible = True
class MenuDelegateButton(MenuDelegate):
def build_item(self, item: ui.MenuHelper):
with ui.HStack(width=0):
with ui.VStack(content_clipping=1, width=0):
ui.Button("Button", style={"margin": 0}, clicked_fn=lambda: print("clicked"))
# ----------------------------------------------------
# left aligned menu
# ----------------------------------------------------
submenu_list3 = [ MenuItemDescription(name="SubMenu Item") ]
submenu_list2 = [ MenuItemDescription(name="SubMenu 2", sub_menu=submenu_list3) ]
submenu_list1 = [ MenuItemDescription(name="SubMenu 1", sub_menu=submenu_list2) ]
left_menu_list = [ MenuItemDescription(name="Root Item", sub_menu=submenu_list1) ]
# add menu
omni.kit.menu.utils.add_menu_items(left_menu_list, "SubMenu Test", 99)
verify_menu_items(self, [(ui.Menu, "SubMenu Test", True), (ui.Menu, "Root Item", True), (ui.Menu, "SubMenu 1", True), (ui.Menu, "SubMenu 2", True), (ui.MenuItem, "SubMenu Item", True)])
# refresh and verify
omni.kit.menu.utils.refresh_menu_items("SubMenu Test")
verify_menu_items(self, [(ui.Menu, "SubMenu Test", True), (ui.Menu, "Root Item", True), (ui.Menu, "SubMenu 1", True), (ui.Menu, "SubMenu 2", True), (ui.MenuItem, "SubMenu Item", True)])
# ----------------------------------------------------
# right aligned menu
# ----------------------------------------------------
md = MenuDelegate()
right_menu_list = [ MenuItemDescription(name="SubMenu Item 1"), MenuItemDescription(name="SubMenu Item 2") ]
right_menu1 = omni.kit.menu.utils.add_menu_items(right_menu_list, "Right Menu Test", delegate=md)
right_menu2 = omni.kit.menu.utils.add_menu_items(right_menu_list, "Right Menu Test", delegate=md)
right_menu3 = omni.kit.menu.utils.add_menu_items([], name="Right Menu Test", delegate=MenuDelegateHidden())
right_menu4 = omni.kit.menu.utils.add_menu_items([], name="Right Menu Test", delegate=MenuDelegateButton())
# verify
verify_menu_items(self, [(ui.Menu, "SubMenu Test", True), (ui.Spacer, True), (ui.Menu, "Right Menu Test", True), (ui.Spacer, True), (ui.Menu, "Root Item", True), (ui.Menu, "SubMenu 1", True), (ui.Menu, "SubMenu 2", True), (ui.MenuItem, "SubMenu Item", True), (ui.MenuItem, "SubMenu Item 1", True), (ui.MenuItem, "SubMenu Item 2", True), (ui.MenuItem, "placeholder", False)], True)
# refresh and verify
omni.kit.menu.utils.refresh_menu_items("Right Menu Test")
verify_menu_items(self, [(ui.Menu, "SubMenu Test", True), (ui.Spacer, True), (ui.Menu, "Right Menu Test", True), (ui.Spacer, True), (ui.Menu, "Root Item", True), (ui.Menu, "SubMenu 1", True), (ui.Menu, "SubMenu 2", True), (ui.MenuItem, "SubMenu Item", True), (ui.MenuItem, "SubMenu Item 1", True), (ui.MenuItem, "SubMenu Item 2", True), (ui.MenuItem, "placeholder", False)], True)
# remove menus
omni.kit.menu.utils.remove_menu_items(left_menu_list, "SubMenu Test")
omni.kit.menu.utils.remove_menu_items(right_menu1, "Right Menu Test")
omni.kit.menu.utils.remove_menu_items(right_menu2, "Right Menu Test")
omni.kit.menu.utils.remove_menu_items(right_menu3, "Right Menu Test")
omni.kit.menu.utils.remove_menu_items(right_menu4, "Right Menu Test")
# verify menus removed
self.assertTrue(omni.kit.menu.utils.get_merged_menus() == {})
| 9,703 |
Python
| 61.606451 | 606 | 0.595589 |
omniverse-code/kit/exts/omni.kit.menu.utils/omni/kit/menu/utils/tests/__init__.py
|
from .test_menus import *
from .test_menu_layouts import *
from .test_action_mapping import *
from .test_right_menus import *
from .test_debug_menu import *
from .test_menu_icons import *
| 188 |
Python
| 25.999996 | 34 | 0.75 |
omniverse-code/kit/exts/omni.kit.menu.utils/omni/kit/menu/utils/tests/test_action_mapping.py
|
import os
import unittest
import carb
import omni.kit.test
from omni.kit import ui_test
from omni.kit.menu.utils import MenuItemDescription
class TestActionMappingMenuUtils(omni.kit.test.AsyncTestCase):
async def setUp(self):
self._menus = [
MenuItemDescription(
name="Test Hotkey Mapping",
glyph="none.svg",
hotkey=(
carb.input.KEYBOARD_MODIFIER_FLAG_CONTROL | carb.input.KEYBOARD_MODIFIER_FLAG_SHIFT,
carb.input.KeyboardInput.EQUAL,
),
)
]
omni.kit.menu.utils.add_menu_items( self._menus, "Test", 99)
async def tearDown(self):
omni.kit.menu.utils.remove_menu_items( self._menus, "Test")
pass
async def wait_for_update(self, usd_context=omni.usd.get_context(), wait_frames=10):
max_loops = 0
while max_loops < wait_frames:
_, files_loaded, total_files = usd_context.get_stage_loading_status()
await omni.kit.app.get_app().next_update_async()
if files_loaded or total_files:
continue
max_loops = max_loops + 1
async def test_action_mapping(self):
import re
mapping_path = "/app/inputBindings/global/Test_Test_Hotkey_Mapping"
menu_widget = ui_test.get_menubar()
widget = menu_widget.find_menu("Test Hotkey Mapping")
settings = carb.settings.get_settings()
await self.wait_for_update(wait_frames=10)
# verify initial value
menu_text = re.sub(r'[^\x00-\x7F]+','', widget.widget.text).replace(" ", "")
self.assertTrue(menu_text == "TestHotkeyMapping")
key_mapping = settings.get(mapping_path)
self.assertTrue(key_mapping == ['Shift + Ctrl + Keyboard::='])
hotkey_text = widget.widget.hotkey_text.replace(" ", "")
self.assertTrue(hotkey_text == "Shift+Ctrl+=")
# set to bad value..
settings.set(mapping_path, "Nothingness")
await self.wait_for_update(wait_frames=10)
hotkey_text = widget.widget.hotkey_text.replace(" ", "")
self.assertTrue(hotkey_text == "")
# set to bad value.. (this crashes kit)
# settings.set(mapping_path, ["Nothingness"])
# await self.wait_for_update(wait_frames=10)
# hotkey_text = widget.widget.hotkey_text.replace(" ", "")
# self.assertTrue(hotkey_text == "")
# set to good value..
settings.set(mapping_path, ["Shift + Ctrl + Keyboard::O"])
await self.wait_for_update(wait_frames=10)
hotkey_text = widget.widget.hotkey_text.replace(" ", "")
self.assertTrue(hotkey_text == "Shift+Ctrl+O")
# set to good value..
settings.set(mapping_path, ["Shift + Ctrl + Keyboard::="])
await self.wait_for_update(wait_frames=10)
hotkey_text = widget.widget.hotkey_text.replace(" ", "")
self.assertTrue(hotkey_text == "Shift+Ctrl+=")
| 3,006 |
Python
| 37.551282 | 104 | 0.594145 |
omniverse-code/kit/exts/omni.kit.menu.utils/omni/kit/menu/utils/tests/utils.py
|
import carb
import omni.ui as ui
from omni.kit import ui_test
def verify_menu_items(cls, verify_list, use_menu_spacers: bool=False):
menu_widget = ui_test.get_menubar()
menu_widgets = []
def show_debug():
debug_info = ""
for w in menu_widgets:
if isinstance(w.widget, (ui.Menu, ui.MenuItem, ui.Separator)):
debug_info += f"(ui.{w.widget.__class__.__name__}, \"{w.widget.text.strip()}\", {w.widget.visible}), "
elif isinstance(w.widget, ui.Spacer) and use_menu_spacers:
debug_info += f"(ui.{w.widget.__class__.__name__}, {w.widget.visible}), "
carb.log_warn(f"verify_menu_items [{debug_info[:-2]}] vs {verify_list}")
for w in menu_widget.find_all("**/"):
if isinstance(w.widget, (ui.Menu, ui.MenuItem, ui.Separator)):
menu_widgets.append(w)
elif isinstance(w.widget, ui.Spacer) and use_menu_spacers and w.widget.identifier in ["right_aligned_menus", "right_padding"]:
menu_widgets.append(w)
try:
cls.assertEqual(len(menu_widgets), len(verify_list))
for index, item in enumerate(verify_list):
widget = menu_widgets[index]
cls.assertTrue(isinstance(widget.widget, item[0]), f"menu type error {widget.widget} vs {item[0]}")
if isinstance(widget.widget, (ui.Menu, ui.MenuItem, ui.Separator)):
cls.assertEqual(widget.widget.text.strip(), item[1])
cls.assertEqual(widget.widget.visible, item[2])
elif isinstance(widget.widget, ui.Spacer) and use_menu_spacers and widget.widget.identifier in ["right_aligned_menus", "right_padding"]:
cls.assertEqual(widget.widget.visible, item[1])
except Exception as exc:
show_debug()
raise Exception(exc)
def verify_menu_checked_items(cls, verify_list):
menu_widget = ui_test.get_menubar()
menu_widgets = []
def show_debug():
debug_info = ""
for w in menu_widgets:
if isinstance(w.widget, (ui.Menu, ui.MenuItem)) and w.widget.text.strip() != "placeholder":
debug_info += f"(ui.{w.widget.__class__.__name__}, \"{w.widget.text.strip()}\", {w.widget.visible}, {w.widget.checkable}, {w.widget.checked}), "
carb.log_warn(f"verify_menu_items [{debug_info[:-2]}] vs {verify_list}")
for w in menu_widget.find_all("**/"):
if isinstance(w.widget, (ui.Menu, ui.MenuItem)) and w.widget.text.strip() != "placeholder":
menu_widgets.append(w)
try:
cls.assertEqual(len(menu_widgets), len(verify_list))
for index, item in enumerate(verify_list):
widget = menu_widgets[index]
cls.assertTrue(isinstance(widget.widget, item[0]), f"menu type error {widget.widget} vs {item[0]}")
cls.assertEqual(widget.widget.text.strip(), item[1])
cls.assertEqual(widget.widget.visible, item[2])
cls.assertEqual(widget.widget.checkable, item[3])
cls.assertEqual(widget.widget.checked, item[4])
except Exception as exc:
show_debug()
raise Exception(exc)
| 3,127 |
Python
| 44.999999 | 160 | 0.610169 |
omniverse-code/kit/exts/omni.kit.menu.utils/omni/kit/menu/utils/tests/test_menu_icons.py
|
from pathlib import Path
import unittest
import carb
import omni.kit.test
import omni.ui as ui
from omni.kit import ui_test
from omni.kit.menu.utils import MenuItemDescription, MenuLayout
from omni.ui.tests.test_base import OmniUiTest
from omni.kit.test_suite.helpers import get_test_data_path
class TestMenuIcon(OmniUiTest):
async def setUp(self):
pass
async def tearDown(self):
pass
async def test_menu_icon(self):
icon_path = Path(omni.kit.app.get_app().get_extension_manager().get_extension_path_by_module(__name__)).joinpath("data/tests/icons/audio_record.svg")
golden_img_dir = Path(get_test_data_path(__name__, "golden_img"))
submenu_list = [ MenuItemDescription(name="Menu Item", glyph=str(icon_path)) ]
menu_list = [ MenuItemDescription(name="Icon Menu Test", glyph=str(icon_path), sub_menu=submenu_list) ]
omni.kit.menu.utils.add_menu_items(menu_list, "Icon Test", 99)
omni.kit.menu.utils.rebuild_menus()
await ui_test.human_delay(50)
await ui_test.menu_click("Icon Test/Icon Menu Test", human_delay_speed=4)
await ui_test.human_delay(10)
await self.finalize_test(golden_img_dir=golden_img_dir, golden_img_name="test_menu_icon.png", hide_menu_bar=False)
await ui_test.human_delay(50)
omni.kit.menu.utils.remove_menu_items(menu_list, "Icon Test")
self.assertTrue(omni.kit.menu.utils.get_merged_menus() == {})
| 1,461 |
Python
| 38.513512 | 157 | 0.689938 |
omniverse-code/kit/exts/omni.kit.menu.utils/docs/index.rst
|
omni.kit.menu.utils
###########################
Menu Utils
.. toctree::
:maxdepth: 1
CHANGELOG
| 109 |
reStructuredText
| 6.333333 | 27 | 0.458716 |
omniverse-code/kit/exts/omni.kit.search_core/config/extension.toml
|
[package]
# Semantic Versioning is used: https://semver.org/
version = "1.0.2"
# Lists people or organizations that are considered the "authors" of the package.
authors = ["NVIDIA"]
# The title and description fields are primarly for displaying extension info in UI
title = "Search Core Classes"
description="The extension provides the base classes for search and registering search engines."
# Path (relative to the root) or content of readme markdown file for UI.
readme = "docs/README.md"
# URL of the extension source repository.
repository = ""
# Keywords for the extension
keywords = ["search", "filepicker", "content"]
# Location of change log file in target (final) folder of extension, relative to the root.
# More info on writing changelog: https://keepachangelog.com/en/1.0.0/
changelog="docs/CHANGELOG.md"
# Preview image. Folder named "data" automatically goes in git lfs (see .gitattributes file).
preview_image = "data/preview.png"
# Main python module this extension provides, it will be publicly available as "import omni.example.hello".
[[python.module]]
name = "omni.kit.search_core"
| 1,112 |
TOML
| 34.903225 | 107 | 0.754496 |
omniverse-code/kit/exts/omni.kit.search_core/omni/kit/search_core/search_engine_registry.py
|
# Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
from .singleton import Singleton
from omni.kit.widget.nucleus_info import get_instance as get_nucleus
@Singleton
class SearchEngineRegistry:
"""
Singleton that keeps all the search engines. It's used to put custom
search engine to the content browser.
"""
class _Event(set):
"""
A list of callable objects. Calling an instance of this will cause a
call to each item in the list in ascending order by index.
"""
def __call__(self, *args, **kwargs):
"""Called when the instance is “called” as a function"""
# Call all the saved functions
for f in self:
f(*args, **kwargs)
def __repr__(self):
"""
Called by the repr() built-in function to compute the “official”
string representation of an object.
"""
return f"Event({set.__repr__(self)})"
class _EventSubscription:
"""
Event subscription.
_Event has callback while this object exists.
"""
def __init__(self, event, fn):
"""
Save the function, the event, and add the function to the event.
"""
self._fn = fn
self._event = event
event.add(self._fn)
def __del__(self):
"""Called by GC."""
self._event.remove(self._fn)
class _EngineSubscription:
"""
Event subscription.
_Event has callback while this object exists.
"""
def __init__(self, name, model_type):
"""
Save name and type to the list.
"""
self._name = name
SearchEngineRegistry()._engines[self._name] = model_type
SearchEngineRegistry()._on_engines_changed()
def __del__(self):
"""Called by GC."""
del SearchEngineRegistry()._engines[self._name]
SearchEngineRegistry()._on_engines_changed()
def __init__(self):
self._engines = {}
self._on_engines_changed = self._Event()
def register_search_model(self, name, model_type):
"""
Add a new engine to the registry.
name: the name of the engine as it appears in the menu.
model_type: the type derived from AbstractSearchModel. Content
browser will create an object of this type when it needs
a new search.
"""
if name in self._engines:
# TODO: Warning
return
return self._EngineSubscription(name, model_type)
def get_search_names(self):
"""Returns all the search names"""
return list(sorted(self._engines.keys()))
def get_available_search_names(self, server: str):
"""Returns available search names in given server"""
search_names = list(sorted(self._engines.keys()))
available_search_names = []
for name in search_names:
if "Service" not in name or get_nucleus().is_service_available(name, server):
available_search_names.append(name)
return available_search_names
def get_search_model(self, name):
"""Returns the type of derived from AbstractSearchModel for the given name"""
return self._engines.get(name, None)
def subscribe_engines_changed(self, fn):
"""
Add the provided function to engines changed event subscription callbacks.
Return the object that will automatically unsubscribe when destroyed.
"""
return self._EventSubscription(self._on_engines_changed, fn)
| 4,059 |
Python
| 32.833333 | 89 | 0.598423 |
omniverse-code/kit/exts/omni.kit.search_core/omni/kit/search_core/abstract_search_model.py
|
# Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
from datetime import datetime
import abc
class AbstractSearchItem:
"""AbstractSearchItem represents a single file in the file browser."""
@property
def path(self):
"""The full path that goes to usd when Drag and Drop"""
return ""
@property
def name(self):
"""The name as it appears in the widget"""
return ""
@property
def date(self):
# TODO: Grid View needs datatime, but Tree View needs a string. We need to make them the same.
return datetime.now()
@property
def size(self):
# TODO: Grid View needs int, but Tree View needs a string. We need to make them the same.
return 0
@property
def icon(self):
pass
@property
def is_folder(self):
pass
def __getitem__(self, key):
"""Access to methods by text for _RedirectModel"""
return getattr(self, key)
class SearchLifetimeObject(metaclass=abc.ABCMeta):
"""
SearchLifetimeObject encapsulates a callback to be called when a search is finished.
It is the responsibility of the implementers of AbstractSearchModel to get the object
argument and keep it alive until the search is completed if the search runs long.
"""
def __init__(self, callback):
self._callback = callback
def __del__(self):
self.destroy()
def destroy(self):
if self._callback:
self._callback()
self._callback = None
class AbstractSearchModel(metaclass=abc.ABCMeta):
"""
AbstractSearchModel represents the search results. It supports async
mode. If the search engine needs some time to process the request, it can
return an empty list and do a search in async mode. As soon as a result
is ready, the model should call `self._item_changed()`. It will make the
view reload the model. It's also possible to return the search result
with portions.
__init__ is usually called with the named arguments search_text and
current_dir, and optionally a search_lifetime object.
"""
class _Event(set):
"""
A list of callable objects. Calling an instance of this will cause a
call to each item in the list in ascending order by index.
"""
def __call__(self, *args, **kwargs):
"""Called when the instance is “called” as a function"""
# Call all the saved functions
for f in self:
f(*args, **kwargs)
def __repr__(self):
"""
Called by the repr() built-in function to compute the “official”
string representation of an object.
"""
return f"Event({set.__repr__(self)})"
class _EventSubscription:
"""
Event subscription.
_Event has callback while this object exists.
"""
def __init__(self, event, fn):
"""
Save the function, the event, and add the function to the event.
"""
self._fn = fn
self._event = event
event.add(self._fn)
def __del__(self):
"""Called by GC."""
self._event.remove(self._fn)
def __init__(self):
# TODO: begin_edit/end_edit
self.__on_item_changed = self._Event()
@property
@abc.abstractmethod
def items(self):
"""Should be implemented"""
pass
def destroy(self):
"""Called to cancel current search"""
pass
def _item_changed(self, item=None):
"""Call the event object that has the list of functions"""
self.__on_item_changed(item)
def subscribe_item_changed(self, fn):
"""
Return the object that will automatically unsubscribe when destroyed.
"""
return self._EventSubscription(self.__on_item_changed, fn)
| 4,281 |
Python
| 29.368794 | 102 | 0.619248 |
omniverse-code/kit/exts/omni.kit.search_core/omni/kit/search_core/tests/search_core_test.py
|
## Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
##
## NVIDIA CORPORATION and its licensors retain all intellectual property
## and proprietary rights in and to this software, related documentation
## and any modifications thereto. Any use, reproduction, disclosure or
## distribution of this software and related documentation without an express
## license agreement from NVIDIA CORPORATION is strictly prohibited.
##
from ..search_engine_registry import SearchEngineRegistry
from ..abstract_search_model import AbstractSearchItem
from ..abstract_search_model import AbstractSearchModel
import omni.kit.test
from unittest.mock import Mock
class TestSearchItem(AbstractSearchItem):
pass
class TestSearchModel(AbstractSearchModel):
running_search = None
def __init__(self, **kwargs):
super().__init__()
self.__items = [TestSearchItem()]
def destroy(self):
self.__items = []
@property
def items(self):
return self.__items
class TestSearchCore(omni.kit.test.AsyncTestCase):
async def test_registry(self):
test_name = "TEST_SEARCH"
self._subscription = SearchEngineRegistry().register_search_model(test_name, TestSearchModel)
self.assertIn(test_name, SearchEngineRegistry().get_search_names())
self.assertIn(test_name, SearchEngineRegistry().get_available_search_names("DummyServer"))
self.assertIs(TestSearchModel, SearchEngineRegistry().get_search_model(test_name))
self._subscription = None
self.assertNotIn(test_name, SearchEngineRegistry().get_search_names())
async def test_event_subscription(self):
mock_callback = Mock()
self._sub = SearchEngineRegistry().subscribe_engines_changed(mock_callback)
self._added_model = SearchEngineRegistry().register_search_model("dummy", TestSearchModel)
mock_callback.assert_called_once()
mock_callback.reset_mock()
self._added_model = None
mock_callback.assert_called_once()
async def test_item_changed_subscription(self):
mock_callback = Mock()
model = TestSearchModel()
self._sub = model.subscribe_item_changed(mock_callback)
model._item_changed()
mock_callback.assert_called_once()
| 2,280 |
Python
| 32.544117 | 101 | 0.709211 |
omniverse-code/kit/exts/omni.kit.search_core/docs/CHANGELOG.md
|
# Changelog
This document records all notable changes to ``omni.kit.search_core`` extension.
## [1.0.2] - 2022-11-10
### Removed
- Removed dependency on omni.kit.test
## [1.0.1] - 2022-03-07
### Added
- Added a search lifetime object that can be used for callbacks after search is done to indicate progress.
## [1.0.0] - 2020-10-05
### Added
- Initial model and registry
| 375 |
Markdown
| 22.499999 | 106 | 0.698667 |
omniverse-code/kit/exts/omni.kit.search_core/docs/README.md
|
# omni.kit.search_example
## Python Search Core
The example provides search model AbstractSearchModel and search registry
SearchEngineRegistry.
`AbstractSearchModel` represents the search results. It supports async mode. If
the search engine needs some time to process the request, it can return an
empty list and do a search in async mode. As soon as a result is ready, the
model should call `self._item_changed()`. It will make the view reload the
model. It's also possible to return the search result with portions.
`AbstractSearchModel.__init__` is usually called with the named arguments
search_text and current_dir.
`SearchEngineRegistry` keeps all the search engines. It's used to put custom
search engine to the content browser. It provides fast access to search
engines. Any extension that can use the objects derived from
`AbstractSearchModel` can use the search.
| 879 |
Markdown
| 40.90476 | 79 | 0.798635 |
omniverse-code/kit/exts/omni.graph.bundle.action/config/extension.toml
|
[package]
# Semantic Versioning is used: https://semver.org/
version = "1.3.0"
# Lists people or organizations that are considered the "authors" of the package.
authors = ["NVIDIA"]
# The title description fields are primarly for displaying extension info in UI
title = "Action Graph Bundle"
description="Load all extensions necessary for using OmniGraph action graphs"
category = "Graph"
feature = true
# URL of the extension source repository.
repository = ""
# Keywords for the extension
keywords = ["kit", "omnigraph", "action"]
# Preview image. Folder named "data" automatically goes in git lfs (see .gitattributes file).
preview_image = "data/preview.png"
# Icon is shown in Extensions window, it is recommended to be square, of size 256x256.
icon = "data/icon.svg"
# Location of change log file in target (final) folder of extension, relative to the root.
changelog="docs/CHANGELOG.md"
# Path (relative to the root) of the main documentation file.
readme = "docs/index.rst"
[dependencies]
"omni.graph" = {}
"omni.graph.action" = {}
"omni.graph.nodes" = {}
"omni.graph.ui" = {}
[[test]]
unreliable = true # OM-51994
waiver = "Empty extension that bundles other extensions"
args = [
"--/app/extensions/registryEnabled=1" # needs to be fixed and removed: OM-49578
]
[documentation]
pages = [
"docs/Overview.md",
"docs/CHANGELOG.md",
]
| 1,365 |
TOML
| 25.26923 | 93 | 0.721612 |
omniverse-code/kit/exts/omni.graph.bundle.action/docs/CHANGELOG.md
|
# Changelog
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
## [1.3.0] - 2022-08-11
### Removed
- omni.graph.window.action dependency
## [1.2.0] - 2022-08-04
### Removed
- omni.graph.instancing dependency
## [1.1.1] - 2022-06-21
### Fixed
- Put docs in the README for the extension manager
## [1.1.0] - 2022-05-05
### Removed
- omni.graph.tutorials dependency
## [1.0.0] - 2021-11-18
### Changes
- Created with initial required set of extensions
| 486 |
Markdown
| 19.291666 | 80 | 0.668724 |
omniverse-code/kit/exts/omni.graph.bundle.action/docs/README.md
|
# OmniGraph Action Bundle [omni.graph.bundle.action]
Action Graphs are a subset of OmniGraph that control execution flow through event triggers.
Loading this bundled extension is a convenient way to load all of the extensions required for OmniGraph action graphs to run.
For visual editing of Action graphs, see `omni.graph.window.action`.
| 342 |
Markdown
| 47.999993 | 125 | 0.809942 |
omniverse-code/kit/exts/omni.graph.bundle.action/docs/index.rst
|
OmniGraph Action Graph Bundle
#############################
.. tabularcolumns:: |L|R|
.. csv-table::
:width: 100%
**Extension**: omni.graph.bundle.action,**Documentation Generated**: |today|
Action Graphs are a subset of OmniGraph that control execution flow through event triggers.
Loading this bundled extension is a convenient way to load all of the extensions required to use the OmniGraph
action graphs.
Extensions Loaded
=================
- omni.graph
- omni.graph.action
- omni.graph.nodes
- omni.graph.ui
- omni.graph.window.action
.. toctree::
:maxdepth: 1
CHANGELOG
| 596 |
reStructuredText
| 20.321428 | 110 | 0.682886 |
omniverse-code/kit/exts/omni.graph.bundle.action/docs/Overview.md
|
# OmniGraph Action Graph Bundle
```{csv-table}
**Extension**: omni.graph.bundle.action,**Documentation Generated**: {sub-ref}`today`
```
Action Graphs are a subset of OmniGraph that control execution flow through event triggers.
Loading this bundled extension is a convenient way to load all of the extensions required to use the OmniGraph
action graphs.
## Extensions Loaded
- omni.graph
- omni.graph.action
- omni.graph.nodes
- omni.graph.ui
- omni.graph.window.action
| 474 |
Markdown
| 26.941175 | 110 | 0.767932 |
omniverse-code/kit/exts/omni.graph.test/config/extension.toml
|
[package]
version = "0.18.0"
title = "OmniGraph Regression Testing"
category = "Graph"
readme = "docs/README.md"
changelog = "docs/CHANGELOG.md"
description = "Contains test scripts and files used to test the OmniGraph extensions where the tests cannot live in a single extension."
repository = ""
keywords = ["kit", "omnigraph", "tests"]
# Main module for the Python interface
[[python.module]]
name = "omni.graph.test"
[[native.plugin]]
path = "bin/*.plugin"
recursive = false
# Watch the .ogn files for hot reloading (only works for Python files)
[fswatcher.patterns]
include = ["*.ogn", "*.py"]
exclude = ["Ogn*Database.py"]
# Python array data uses numpy as its format
[python.pipapi]
requirements = ["numpy"]
# Other extensions that need to load in order for this one to work
[dependencies]
"omni.graph" = {}
"omni.graph.tools" = {}
"omni.kit.pipapi" = {}
"omni.graph.examples.cpp" = {}
"omni.graph.examples.python" = {}
"omni.graph.nodes" = {}
"omni.graph.tutorials" = {}
"omni.graph.action" = {}
"omni.graph.scriptnode" = {}
"omni.inspect" = {}
"omni.usd" = {}
[[test]]
timeout = 600
stdoutFailPatterns.exclude = [
# Exclude carb.events leak that only shows up locally
"*[Error] [carb.events.plugin]*PooledAllocator*",
# Exclude messages which say they should be ignored
"*Ignore this error/warning*",
]
pythonTests.unreliable = [
# "*test_graph_load", # OM-53608
# "*test_hashability", # OM-53608
# "*test_rename_deformer", # OM-53608
"*test_import_time_sampled_data", # OM-58596
# "*test_import_time_samples", # OM-61324
"*test_reparent_graph", # OM-58852
"*test_simple_rename", # OM-58852
"*test_copy_on_write", # OM-58586
"*test_reparent_fabric", # OM-63175
]
[documentation]
pages = [
"docs/Overview.md",
"docs/CHANGELOG.md",
]
| 1,809 |
TOML
| 25.617647 | 136 | 0.671089 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/__init__.py
|
"""There is no public API to this module."""
__all__ = []
from ._impl.extension import _PublicExtension # noqa: F401
| 119 |
Python
| 22.999995 | 59 | 0.663866 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/OgnTestDataModelDatabase.py
|
"""Support for simplified access to data on nodes of type omni.graph.test.TestDataModel
Helper node that allows to test that core features of datamodel are working as expected (CoW, DataStealing, ...)
"""
import carb
import numpy
import carb
import omni.graph.core as og
import omni.graph.core._omni_graph_core as _og
import omni.graph.tools.ogn as ogn
class OgnTestDataModelDatabase(og.Database):
"""Helper class providing simplified access to data on nodes of type omni.graph.test.TestDataModel
Class Members:
node: Node being evaluated
Attribute Value Properties:
Inputs:
inputs.arrayShouldMatch
inputs.attrib
inputs.bundleArraysThatShouldDiffer
inputs.bundleShouldMatch
inputs.mutArray
inputs.mutBundle
inputs.mutateArray
inputs.refArray
inputs.refBundle
Outputs:
outputs.array
outputs.bundle
"""
# 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:arrayShouldMatch', 'bool', 0, 'Array should match', 'Whether or not the input arrays should be the same one one', {ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('inputs:attrib', 'token', 0, 'Attrib to mutate', 'Attribute to mutate in the bundle', {}, True, "", False, ''),
('inputs:bundleArraysThatShouldDiffer', 'int', 0, 'Number of != arrays in bundles', 'The number of arrays attribute in the input bundles that should differs', {ogn.MetadataKeys.DEFAULT: '0'}, True, 0, False, ''),
('inputs:bundleShouldMatch', 'bool', 0, 'Bundles should match', 'Whether or not the input bundles should be the same one', {ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('inputs:mutArray', 'point3f[]', 0, 'In array', 'Array meant to be mutated', {}, True, [], False, ''),
('inputs:mutBundle', 'bundle', 0, 'In bundle', 'Bundle meant to be mutated (or not)', {}, True, None, False, ''),
('inputs:mutateArray', 'bool', 0, 'Mutate array', 'Whether or not to mutate the array or just passthrough', {ogn.MetadataKeys.DEFAULT: 'false'}, True, False, False, ''),
('inputs:refArray', 'point3f[]', 0, 'Ref array', 'A reference array used as a point of comparaison', {}, True, [], False, ''),
('inputs:refBundle', 'bundle', 0, 'Ref bundle', 'Reference Bundle used as a point of comparaison', {}, True, None, False, ''),
('outputs:array', 'point3f[]', 0, 'Output array', 'The outputed array', {}, True, None, False, ''),
('outputs:bundle', 'bundle', 0, 'Output bundle', 'The outputed bundle', {}, 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.mutArray = og.AttributeRole.POSITION
role_data.inputs.mutBundle = og.AttributeRole.BUNDLE
role_data.inputs.refArray = og.AttributeRole.POSITION
role_data.inputs.refBundle = og.AttributeRole.BUNDLE
role_data.outputs.array = og.AttributeRole.POSITION
role_data.outputs.bundle = og.AttributeRole.BUNDLE
return role_data
class ValuesForInputs(og.DynamicAttributeAccess):
LOCAL_PROPERTY_NAMES = { }
"""Helper class that creates natural hierarchical access to input attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
self.__bundles = og.BundleContainer(context, node, attributes, [], read_only=True, gpu_ptr_kinds={})
self._batchedReadAttributes = []
self._batchedReadValues = []
@property
def arrayShouldMatch(self):
data_view = og.AttributeValueHelper(self._attributes.arrayShouldMatch)
return data_view.get()
@arrayShouldMatch.setter
def arrayShouldMatch(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.arrayShouldMatch)
data_view = og.AttributeValueHelper(self._attributes.arrayShouldMatch)
data_view.set(value)
@property
def attrib(self):
data_view = og.AttributeValueHelper(self._attributes.attrib)
return data_view.get()
@attrib.setter
def attrib(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.attrib)
data_view = og.AttributeValueHelper(self._attributes.attrib)
data_view.set(value)
@property
def bundleArraysThatShouldDiffer(self):
data_view = og.AttributeValueHelper(self._attributes.bundleArraysThatShouldDiffer)
return data_view.get()
@bundleArraysThatShouldDiffer.setter
def bundleArraysThatShouldDiffer(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.bundleArraysThatShouldDiffer)
data_view = og.AttributeValueHelper(self._attributes.bundleArraysThatShouldDiffer)
data_view.set(value)
@property
def bundleShouldMatch(self):
data_view = og.AttributeValueHelper(self._attributes.bundleShouldMatch)
return data_view.get()
@bundleShouldMatch.setter
def bundleShouldMatch(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.bundleShouldMatch)
data_view = og.AttributeValueHelper(self._attributes.bundleShouldMatch)
data_view.set(value)
@property
def mutArray(self):
data_view = og.AttributeValueHelper(self._attributes.mutArray)
return data_view.get()
@mutArray.setter
def mutArray(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.mutArray)
data_view = og.AttributeValueHelper(self._attributes.mutArray)
data_view.set(value)
self.mutArray_size = data_view.get_array_size()
@property
def mutBundle(self) -> og.BundleContents:
"""Get the bundle wrapper class for the attribute inputs.mutBundle"""
return self.__bundles.mutBundle
@property
def mutateArray(self):
data_view = og.AttributeValueHelper(self._attributes.mutateArray)
return data_view.get()
@mutateArray.setter
def mutateArray(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.mutateArray)
data_view = og.AttributeValueHelper(self._attributes.mutateArray)
data_view.set(value)
@property
def refArray(self):
data_view = og.AttributeValueHelper(self._attributes.refArray)
return data_view.get()
@refArray.setter
def refArray(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.refArray)
data_view = og.AttributeValueHelper(self._attributes.refArray)
data_view.set(value)
self.refArray_size = data_view.get_array_size()
@property
def refBundle(self) -> og.BundleContents:
"""Get the bundle wrapper class for the attribute inputs.refBundle"""
return self.__bundles.refBundle
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.array_size = None
self._batchedWriteValues = { }
@property
def array(self):
data_view = og.AttributeValueHelper(self._attributes.array)
return data_view.get(reserved_element_count=self.array_size)
@array.setter
def array(self, value):
data_view = og.AttributeValueHelper(self._attributes.array)
data_view.set(value)
self.array_size = data_view.get_array_size()
@property
def bundle(self) -> og.BundleContents:
"""Get the bundle wrapper class for the attribute outputs.bundle"""
return self.__bundles.bundle
@bundle.setter
def bundle(self, bundle: og.BundleContents):
"""Overwrite the bundle attribute outputs.bundle 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.bundle.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 = OgnTestDataModelDatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
self.outputs = OgnTestDataModelDatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
self.state = OgnTestDataModelDatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
| 11,607 |
Python
| 46.966942 | 220 | 0.649091 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/OgnTestGatherDatabase.py
|
"""Support for simplified access to data on nodes of type omni.graph.test.TestGather
Test node to test out the effects of vectorization.
"""
import omni.graph.core as og
import omni.graph.core._omni_graph_core as _og
import omni.graph.tools.ogn as ogn
import carb
import numpy
class OgnTestGatherDatabase(og.Database):
"""Helper class providing simplified access to data on nodes of type omni.graph.test.TestGather
Class Members:
node: Node being evaluated
Attribute Value Properties:
Inputs:
inputs.base_name
inputs.num_instances
Outputs:
outputs.gathered_paths
outputs.rotations
"""
# 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:base_name', 'token', 0, None, 'The base name of the pattern to match', {ogn.MetadataKeys.DEFAULT: '""'}, True, '', False, ''),
('inputs:num_instances', 'int', 0, None, 'How many instances are involved', {ogn.MetadataKeys.DEFAULT: '1'}, True, 1, False, ''),
('outputs:gathered_paths', 'token[]', 0, None, 'The paths of the gathered objects', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:rotations', 'double3[]', 0, None, 'The rotations of the gathered points', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
])
class ValuesForInputs(og.DynamicAttributeAccess):
LOCAL_PROPERTY_NAMES = {"base_name", "num_instances", "_setting_locked", "_batchedReadAttributes", "_batchedReadValues"}
"""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._attributes.base_name, self._attributes.num_instances]
self._batchedReadValues = ["", 1]
@property
def base_name(self):
return self._batchedReadValues[0]
@base_name.setter
def base_name(self, value):
self._batchedReadValues[0] = value
@property
def num_instances(self):
return self._batchedReadValues[1]
@num_instances.setter
def num_instances(self, value):
self._batchedReadValues[1] = value
def __getattr__(self, item: str):
if item in self.LOCAL_PROPERTY_NAMES:
return object.__getattribute__(self, item)
else:
return super().__getattr__(item)
def __setattr__(self, item: str, new_value):
if item in self.LOCAL_PROPERTY_NAMES:
object.__setattr__(self, item, new_value)
else:
super().__setattr__(item, new_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.gathered_paths_size = 0
self.rotations_size = 0
self._batchedWriteValues = { }
@property
def gathered_paths(self):
data_view = og.AttributeValueHelper(self._attributes.gathered_paths)
return data_view.get(reserved_element_count=self.gathered_paths_size)
@gathered_paths.setter
def gathered_paths(self, value):
data_view = og.AttributeValueHelper(self._attributes.gathered_paths)
data_view.set(value)
self.gathered_paths_size = data_view.get_array_size()
@property
def rotations(self):
data_view = og.AttributeValueHelper(self._attributes.rotations)
return data_view.get(reserved_element_count=self.rotations_size)
@rotations.setter
def rotations(self, value):
data_view = og.AttributeValueHelper(self._attributes.rotations)
data_view.set(value)
self.rotations_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 = OgnTestGatherDatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
self.outputs = OgnTestGatherDatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
self.state = OgnTestGatherDatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
| 6,560 |
Python
| 49.083969 | 147 | 0.653506 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/OgnDecomposeDouble3CDatabase.py
|
"""Support for simplified access to data on nodes of type omni.graph.test.DecomposeDouble3C
Example node that takes in a double[3] and outputs scalars that are its components
"""
import carb
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 OgnDecomposeDouble3CDatabase(og.Database):
"""Helper class providing simplified access to data on nodes of type omni.graph.test.DecomposeDouble3C
Class Members:
node: Node being evaluated
Attribute Value Properties:
Inputs:
inputs.double3
Outputs:
outputs.x
outputs.y
outputs.z
"""
# 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:double3', 'double3', 0, None, 'Input to decompose', {ogn.MetadataKeys.DEFAULT: '[0, 0, 0]'}, True, [0, 0, 0], False, ''),
('outputs:x', 'double', 0, None, 'The x component of the input', {}, True, None, False, ''),
('outputs:y', 'double', 0, None, 'The y component of the input', {}, True, None, False, ''),
('outputs:z', 'double', 0, None, 'The z component of the input', {}, True, None, False, ''),
])
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 double3(self):
data_view = og.AttributeValueHelper(self._attributes.double3)
return data_view.get()
@double3.setter
def double3(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.double3)
data_view = og.AttributeValueHelper(self._attributes.double3)
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 x(self):
data_view = og.AttributeValueHelper(self._attributes.x)
return data_view.get()
@x.setter
def x(self, value):
data_view = og.AttributeValueHelper(self._attributes.x)
data_view.set(value)
@property
def y(self):
data_view = og.AttributeValueHelper(self._attributes.y)
return data_view.get()
@y.setter
def y(self, value):
data_view = og.AttributeValueHelper(self._attributes.y)
data_view.set(value)
@property
def z(self):
data_view = og.AttributeValueHelper(self._attributes.z)
return data_view.get()
@z.setter
def z(self, value):
data_view = og.AttributeValueHelper(self._attributes.z)
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 = OgnDecomposeDouble3CDatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
self.outputs = OgnDecomposeDouble3CDatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
self.state = OgnDecomposeDouble3CDatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
| 5,913 |
Python
| 42.807407 | 138 | 0.651108 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/OgnComputeErrorCppDatabase.py
|
"""Support for simplified access to data on nodes of type omni.graph.test.ComputeErrorCpp
Generates a customizable error during its compute(), for testing purposes. C++ version.
"""
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 OgnComputeErrorCppDatabase(og.Database):
"""Helper class providing simplified access to data on nodes of type omni.graph.test.ComputeErrorCpp
Class Members:
node: Node being evaluated
Attribute Value Properties:
Inputs:
inputs.deprecatedInInit
inputs.deprecatedInOgn
inputs.dummyIn
inputs.failCompute
inputs.message
inputs.severity
Outputs:
outputs.dummyOut
Predefined Tokens:
tokens.none
tokens.warning
tokens.error
"""
# 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:deprecatedInInit', 'float', 0, None, "Attribute which has been deprecated in the node's initialization code.", {}, True, 0.0, False, ''),
('inputs:deprecatedInOgn', 'float', 0, None, 'Attribute which has been deprecated here in the .ogn file.', {}, True, 0.0, True, "Use 'dummyIn' instead."),
('inputs:dummyIn', 'int', 0, None, 'Dummy value to be copied to the output.', {ogn.MetadataKeys.DEFAULT: '0'}, True, 0, False, ''),
('inputs:failCompute', 'bool', 0, None, 'If true, the compute() call will return failure to the evaluator.', {ogn.MetadataKeys.DEFAULT: 'false'}, True, False, False, ''),
('inputs:message', 'string', 0, None, 'Text of the error message.', {}, True, "", False, ''),
('inputs:severity', 'token', 0, None, "Severity of the error. 'none' disables the error.", {ogn.MetadataKeys.ALLOWED_TOKENS: 'none,warning,error', ogn.MetadataKeys.ALLOWED_TOKENS_RAW: '["none", "warning", "error"]', ogn.MetadataKeys.DEFAULT: '"none"'}, True, "none", False, ''),
('outputs:dummyOut', 'int', 0, None, "Value copied from 'dummyIn'", {ogn.MetadataKeys.DEFAULT: '0'}, True, 0, False, ''),
])
class tokens:
none = "none"
warning = "warning"
error = "error"
@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.message = 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 deprecatedInInit(self):
data_view = og.AttributeValueHelper(self._attributes.deprecatedInInit)
return data_view.get()
@deprecatedInInit.setter
def deprecatedInInit(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.deprecatedInInit)
data_view = og.AttributeValueHelper(self._attributes.deprecatedInInit)
data_view.set(value)
@property
def deprecatedInOgn(self):
data_view = og.AttributeValueHelper(self._attributes.deprecatedInOgn)
return data_view.get()
@deprecatedInOgn.setter
def deprecatedInOgn(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.deprecatedInOgn)
data_view = og.AttributeValueHelper(self._attributes.deprecatedInOgn)
data_view.set(value)
@property
def dummyIn(self):
data_view = og.AttributeValueHelper(self._attributes.dummyIn)
return data_view.get()
@dummyIn.setter
def dummyIn(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.dummyIn)
data_view = og.AttributeValueHelper(self._attributes.dummyIn)
data_view.set(value)
@property
def failCompute(self):
data_view = og.AttributeValueHelper(self._attributes.failCompute)
return data_view.get()
@failCompute.setter
def failCompute(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.failCompute)
data_view = og.AttributeValueHelper(self._attributes.failCompute)
data_view.set(value)
@property
def message(self):
data_view = og.AttributeValueHelper(self._attributes.message)
return data_view.get()
@message.setter
def message(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.message)
data_view = og.AttributeValueHelper(self._attributes.message)
data_view.set(value)
self.message_size = data_view.get_array_size()
@property
def severity(self):
data_view = og.AttributeValueHelper(self._attributes.severity)
return data_view.get()
@severity.setter
def severity(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.severity)
data_view = og.AttributeValueHelper(self._attributes.severity)
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 dummyOut(self):
data_view = og.AttributeValueHelper(self._attributes.dummyOut)
return data_view.get()
@dummyOut.setter
def dummyOut(self, value):
data_view = og.AttributeValueHelper(self._attributes.dummyOut)
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 = OgnComputeErrorCppDatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
self.outputs = OgnComputeErrorCppDatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
self.state = OgnComputeErrorCppDatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
| 8,936 |
Python
| 44.136363 | 286 | 0.648389 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/OgnTestGatherRandomRotationsDatabase.py
|
"""Support for simplified access to data on nodes of type omni.graph.test.TestGatherRandomRotations
A sample node that gathers (vectorizes) a bunch of translations and rotations for OmniHydra. It lays out the objects in
a grid and assigns a random value for the rotation
"""
import omni.graph.core as og
import omni.graph.core._omni_graph_core as _og
import omni.graph.tools.ogn as ogn
import carb
class OgnTestGatherRandomRotationsDatabase(og.Database):
"""Helper class providing simplified access to data on nodes of type omni.graph.test.TestGatherRandomRotations
Class Members:
node: Node being evaluated
Attribute Value Properties:
Inputs:
inputs.bucketIds
"""
# 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:bucketIds', 'uint64', 0, None, 'bucketIds of the buckets involved in the gather', {ogn.MetadataKeys.DEFAULT: '0'}, True, 0, False, ''),
])
class ValuesForInputs(og.DynamicAttributeAccess):
LOCAL_PROPERTY_NAMES = {"bucketIds", "_setting_locked", "_batchedReadAttributes", "_batchedReadValues"}
"""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._attributes.bucketIds]
self._batchedReadValues = [0]
@property
def bucketIds(self):
return self._batchedReadValues[0]
@bucketIds.setter
def bucketIds(self, value):
self._batchedReadValues[0] = value
def __getattr__(self, item: str):
if item in self.LOCAL_PROPERTY_NAMES:
return object.__getattribute__(self, item)
else:
return super().__getattr__(item)
def __setattr__(self, item: str, new_value):
if item in self.LOCAL_PROPERTY_NAMES:
object.__setattr__(self, item, new_value)
else:
super().__setattr__(item, new_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)
def __init__(self, node):
super().__init__(node)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_INPUT)
self.inputs = OgnTestGatherRandomRotationsDatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
self.outputs = OgnTestGatherRandomRotationsDatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
self.state = OgnTestGatherRandomRotationsDatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
| 4,969 |
Python
| 53.021739 | 152 | 0.680217 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/OgnTestAllDataTypesDatabase.py
|
"""Support for simplified access to data on nodes of type omni.graph.test.TestAllDataTypes
This node is meant to exercise data access for all available data types, including all legal combinations of tuples, arrays,
and bundle members. This node definition is a duplicate of OgnTestAllDataTypesPy.ogn, except the implementation language
is C++.
"""
import carb
import numpy
import usdrt
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 OgnTestAllDataTypesDatabase(og.Database):
"""Helper class providing simplified access to data on nodes of type omni.graph.test.TestAllDataTypes
Class Members:
node: Node being evaluated
Attribute Value Properties:
Inputs:
inputs.a_bool
inputs.a_bool_array
inputs.a_bundle
inputs.a_colord_3
inputs.a_colord_3_array
inputs.a_colord_4
inputs.a_colord_4_array
inputs.a_colorf_3
inputs.a_colorf_3_array
inputs.a_colorf_4
inputs.a_colorf_4_array
inputs.a_colorh_3
inputs.a_colorh_3_array
inputs.a_colorh_4
inputs.a_colorh_4_array
inputs.a_double
inputs.a_double_2
inputs.a_double_2_array
inputs.a_double_3
inputs.a_double_3_array
inputs.a_double_4
inputs.a_double_4_array
inputs.a_double_array
inputs.a_execution
inputs.a_float
inputs.a_float_2
inputs.a_float_2_array
inputs.a_float_3
inputs.a_float_3_array
inputs.a_float_4
inputs.a_float_4_array
inputs.a_float_array
inputs.a_frame_4
inputs.a_frame_4_array
inputs.a_half
inputs.a_half_2
inputs.a_half_2_array
inputs.a_half_3
inputs.a_half_3_array
inputs.a_half_4
inputs.a_half_4_array
inputs.a_half_array
inputs.a_int
inputs.a_int64
inputs.a_int64_array
inputs.a_int_2
inputs.a_int_2_array
inputs.a_int_3
inputs.a_int_3_array
inputs.a_int_4
inputs.a_int_4_array
inputs.a_int_array
inputs.a_matrixd_2
inputs.a_matrixd_2_array
inputs.a_matrixd_3
inputs.a_matrixd_3_array
inputs.a_matrixd_4
inputs.a_matrixd_4_array
inputs.a_normald_3
inputs.a_normald_3_array
inputs.a_normalf_3
inputs.a_normalf_3_array
inputs.a_normalh_3
inputs.a_normalh_3_array
inputs.a_objectId
inputs.a_objectId_array
inputs.a_path
inputs.a_pointd_3
inputs.a_pointd_3_array
inputs.a_pointf_3
inputs.a_pointf_3_array
inputs.a_pointh_3
inputs.a_pointh_3_array
inputs.a_quatd_4
inputs.a_quatd_4_array
inputs.a_quatf_4
inputs.a_quatf_4_array
inputs.a_quath_4
inputs.a_quath_4_array
inputs.a_string
inputs.a_target
inputs.a_texcoordd_2
inputs.a_texcoordd_2_array
inputs.a_texcoordd_3
inputs.a_texcoordd_3_array
inputs.a_texcoordf_2
inputs.a_texcoordf_2_array
inputs.a_texcoordf_3
inputs.a_texcoordf_3_array
inputs.a_texcoordh_2
inputs.a_texcoordh_2_array
inputs.a_texcoordh_3
inputs.a_texcoordh_3_array
inputs.a_timecode
inputs.a_timecode_array
inputs.a_token
inputs.a_token_array
inputs.a_uchar
inputs.a_uchar_array
inputs.a_uint
inputs.a_uint64
inputs.a_uint64_array
inputs.a_uint_array
inputs.a_vectord_3
inputs.a_vectord_3_array
inputs.a_vectorf_3
inputs.a_vectorf_3_array
inputs.a_vectorh_3
inputs.a_vectorh_3_array
inputs.doNotCompute
Outputs:
outputs.a_bool
outputs.a_bool_array
outputs.a_bundle
outputs.a_colord_3
outputs.a_colord_3_array
outputs.a_colord_4
outputs.a_colord_4_array
outputs.a_colorf_3
outputs.a_colorf_3_array
outputs.a_colorf_4
outputs.a_colorf_4_array
outputs.a_colorh_3
outputs.a_colorh_3_array
outputs.a_colorh_4
outputs.a_colorh_4_array
outputs.a_double
outputs.a_double_2
outputs.a_double_2_array
outputs.a_double_3
outputs.a_double_3_array
outputs.a_double_4
outputs.a_double_4_array
outputs.a_double_array
outputs.a_execution
outputs.a_float
outputs.a_float_2
outputs.a_float_2_array
outputs.a_float_3
outputs.a_float_3_array
outputs.a_float_4
outputs.a_float_4_array
outputs.a_float_array
outputs.a_frame_4
outputs.a_frame_4_array
outputs.a_half
outputs.a_half_2
outputs.a_half_2_array
outputs.a_half_3
outputs.a_half_3_array
outputs.a_half_4
outputs.a_half_4_array
outputs.a_half_array
outputs.a_int
outputs.a_int64
outputs.a_int64_array
outputs.a_int_2
outputs.a_int_2_array
outputs.a_int_3
outputs.a_int_3_array
outputs.a_int_4
outputs.a_int_4_array
outputs.a_int_array
outputs.a_matrixd_2
outputs.a_matrixd_2_array
outputs.a_matrixd_3
outputs.a_matrixd_3_array
outputs.a_matrixd_4
outputs.a_matrixd_4_array
outputs.a_normald_3
outputs.a_normald_3_array
outputs.a_normalf_3
outputs.a_normalf_3_array
outputs.a_normalh_3
outputs.a_normalh_3_array
outputs.a_objectId
outputs.a_objectId_array
outputs.a_path
outputs.a_pointd_3
outputs.a_pointd_3_array
outputs.a_pointf_3
outputs.a_pointf_3_array
outputs.a_pointh_3
outputs.a_pointh_3_array
outputs.a_quatd_4
outputs.a_quatd_4_array
outputs.a_quatf_4
outputs.a_quatf_4_array
outputs.a_quath_4
outputs.a_quath_4_array
outputs.a_string
outputs.a_target
outputs.a_texcoordd_2
outputs.a_texcoordd_2_array
outputs.a_texcoordd_3
outputs.a_texcoordd_3_array
outputs.a_texcoordf_2
outputs.a_texcoordf_2_array
outputs.a_texcoordf_3
outputs.a_texcoordf_3_array
outputs.a_texcoordh_2
outputs.a_texcoordh_2_array
outputs.a_texcoordh_3
outputs.a_texcoordh_3_array
outputs.a_timecode
outputs.a_timecode_array
outputs.a_token
outputs.a_token_array
outputs.a_uchar
outputs.a_uchar_array
outputs.a_uint
outputs.a_uint64
outputs.a_uint64_array
outputs.a_uint_array
outputs.a_vectord_3
outputs.a_vectord_3_array
outputs.a_vectorf_3
outputs.a_vectorf_3_array
outputs.a_vectorh_3
outputs.a_vectorh_3_array
State:
state.a_bool
state.a_bool_array
state.a_bundle
state.a_colord_3
state.a_colord_3_array
state.a_colord_4
state.a_colord_4_array
state.a_colorf_3
state.a_colorf_3_array
state.a_colorf_4
state.a_colorf_4_array
state.a_colorh_3
state.a_colorh_3_array
state.a_colorh_4
state.a_colorh_4_array
state.a_double
state.a_double_2
state.a_double_2_array
state.a_double_3
state.a_double_3_array
state.a_double_4
state.a_double_4_array
state.a_double_array
state.a_execution
state.a_firstEvaluation
state.a_float
state.a_float_2
state.a_float_2_array
state.a_float_3
state.a_float_3_array
state.a_float_4
state.a_float_4_array
state.a_float_array
state.a_frame_4
state.a_frame_4_array
state.a_half
state.a_half_2
state.a_half_2_array
state.a_half_3
state.a_half_3_array
state.a_half_4
state.a_half_4_array
state.a_half_array
state.a_int
state.a_int64
state.a_int64_array
state.a_int_2
state.a_int_2_array
state.a_int_3
state.a_int_3_array
state.a_int_4
state.a_int_4_array
state.a_int_array
state.a_matrixd_2
state.a_matrixd_2_array
state.a_matrixd_3
state.a_matrixd_3_array
state.a_matrixd_4
state.a_matrixd_4_array
state.a_normald_3
state.a_normald_3_array
state.a_normalf_3
state.a_normalf_3_array
state.a_normalh_3
state.a_normalh_3_array
state.a_objectId
state.a_objectId_array
state.a_path
state.a_pointd_3
state.a_pointd_3_array
state.a_pointf_3
state.a_pointf_3_array
state.a_pointh_3
state.a_pointh_3_array
state.a_quatd_4
state.a_quatd_4_array
state.a_quatf_4
state.a_quatf_4_array
state.a_quath_4
state.a_quath_4_array
state.a_string
state.a_stringEmpty
state.a_target
state.a_texcoordd_2
state.a_texcoordd_2_array
state.a_texcoordd_3
state.a_texcoordd_3_array
state.a_texcoordf_2
state.a_texcoordf_2_array
state.a_texcoordf_3
state.a_texcoordf_3_array
state.a_texcoordh_2
state.a_texcoordh_2_array
state.a_texcoordh_3
state.a_texcoordh_3_array
state.a_timecode
state.a_timecode_array
state.a_token
state.a_token_array
state.a_uchar
state.a_uchar_array
state.a_uint
state.a_uint64
state.a_uint64_array
state.a_uint_array
state.a_vectord_3
state.a_vectord_3_array
state.a_vectorf_3
state.a_vectorf_3_array
state.a_vectorh_3
state.a_vectorh_3_array
"""
# 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:a_bool', 'bool', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: 'false'}, True, False, False, ''),
('inputs:a_bool_array', 'bool[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[false, true]'}, True, [False, True], False, ''),
('inputs:a_bundle', 'bundle', 0, None, 'Input Attribute', {}, False, None, False, ''),
('inputs:a_colord_3', 'color3d', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1.0, 2.0, 3.0]'}, True, [1.0, 2.0, 3.0], False, ''),
('inputs:a_colord_3_array', 'color3d[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.0, 2.0, 3.0], [11.0, 12.0, 13.0]]'}, True, [[1.0, 2.0, 3.0], [11.0, 12.0, 13.0]], False, ''),
('inputs:a_colord_4', 'color4d', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1.0, 2.0, 3.0, 4.0]'}, True, [1.0, 2.0, 3.0, 4.0], False, ''),
('inputs:a_colord_4_array', 'color4d[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.0, 2.0, 3.0, 4.0], [11.0, 12.0, 13.0, 14.0]]'}, True, [[1.0, 2.0, 3.0, 4.0], [11.0, 12.0, 13.0, 14.0]], False, ''),
('inputs:a_colorf_3', 'color3f', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1.0, 2.0, 3.0]'}, True, [1.0, 2.0, 3.0], False, ''),
('inputs:a_colorf_3_array', 'color3f[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.0, 2.0, 3.0], [11.0, 12.0, 13.0]]'}, True, [[1.0, 2.0, 3.0], [11.0, 12.0, 13.0]], False, ''),
('inputs:a_colorf_4', 'color4f', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1.0, 2.0, 3.0, 4.0]'}, True, [1.0, 2.0, 3.0, 4.0], False, ''),
('inputs:a_colorf_4_array', 'color4f[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.0, 2.0, 3.0, 4.0], [11.0, 12.0, 13.0, 14.0]]'}, True, [[1.0, 2.0, 3.0, 4.0], [11.0, 12.0, 13.0, 14.0]], False, ''),
('inputs:a_colorh_3', 'color3h', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1.0, 2.0, 3.0]'}, True, [1.0, 2.0, 3.0], False, ''),
('inputs:a_colorh_3_array', 'color3h[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.0, 2.0, 3.0], [11.0, 12.0, 13.0]]'}, True, [[1.0, 2.0, 3.0], [11.0, 12.0, 13.0]], False, ''),
('inputs:a_colorh_4', 'color4h', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1.0, 2.0, 3.0, 4.0]'}, True, [1.0, 2.0, 3.0, 4.0], False, ''),
('inputs:a_colorh_4_array', 'color4h[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.0, 2.0, 3.0, 4.0], [11.0, 12.0, 13.0, 14.0]]'}, True, [[1.0, 2.0, 3.0, 4.0], [11.0, 12.0, 13.0, 14.0]], False, ''),
('inputs:a_double', 'double', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '1.0'}, True, 1.0, False, ''),
('inputs:a_double_2', 'double2', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1.0, 2.0]'}, True, [1.0, 2.0], False, ''),
('inputs:a_double_2_array', 'double2[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.0, 2.0], [11.0, 12.0]]'}, True, [[1.0, 2.0], [11.0, 12.0]], False, ''),
('inputs:a_double_3', 'double3', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1.0, 2.0, 3.0]'}, True, [1.0, 2.0, 3.0], False, ''),
('inputs:a_double_3_array', 'double3[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.0, 2.0, 3.0], [11.0, 12.0, 13.0]]'}, True, [[1.0, 2.0, 3.0], [11.0, 12.0, 13.0]], False, ''),
('inputs:a_double_4', 'double4', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1.0, 2.0, 3.0, 4.0]'}, True, [1.0, 2.0, 3.0, 4.0], False, ''),
('inputs:a_double_4_array', 'double4[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.0, 2.0, 3.0, 4.0], [11.0, 12.0, 13.0, 14.0]]'}, True, [[1.0, 2.0, 3.0, 4.0], [11.0, 12.0, 13.0, 14.0]], False, ''),
('inputs:a_double_array', 'double[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1.0, 2.0]'}, True, [1.0, 2.0], False, ''),
('inputs:a_execution', 'execution', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '1'}, True, 1, False, ''),
('inputs:a_float', 'float', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '1.0'}, True, 1.0, False, ''),
('inputs:a_float_2', 'float2', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1.0, 2.0]'}, True, [1.0, 2.0], False, ''),
('inputs:a_float_2_array', 'float2[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.0, 2.0], [11.0, 12.0]]'}, True, [[1.0, 2.0], [11.0, 12.0]], False, ''),
('inputs:a_float_3', 'float3', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1.0, 2.0, 3.0]'}, True, [1.0, 2.0, 3.0], False, ''),
('inputs:a_float_3_array', 'float3[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.0, 2.0, 3.0], [11.0, 12.0, 13.0]]'}, True, [[1.0, 2.0, 3.0], [11.0, 12.0, 13.0]], False, ''),
('inputs:a_float_4', 'float4', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1.0, 2.0, 3.0, 4.0]'}, True, [1.0, 2.0, 3.0, 4.0], False, ''),
('inputs:a_float_4_array', 'float4[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.0, 2.0, 3.0, 4.0], [11.0, 12.0, 13.0, 14.0]]'}, True, [[1.0, 2.0, 3.0, 4.0], [11.0, 12.0, 13.0, 14.0]], False, ''),
('inputs:a_float_array', 'float[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1.0, 2.0]'}, True, [1.0, 2.0], False, ''),
('inputs:a_frame_4', 'frame4d', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0], [9.0, 10.0, 11.0, 12.0], [13.0, 14.0, 15.0, 16.0]]'}, True, [[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0], [9.0, 10.0, 11.0, 12.0], [13.0, 14.0, 15.0, 16.0]], False, ''),
('inputs:a_frame_4_array', 'frame4d[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0], [9.0, 10.0, 11.0, 12.0], [13.0, 14.0, 15.0, 16.0]], [[11.0, 12.0, 13.0, 14.0], [15.0, 16.0, 17.0, 18.0], [19.0, 20.0, 21.0, 22.0], [23.0, 24.0, 25.0, 26.0]]]'}, True, [[[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0], [9.0, 10.0, 11.0, 12.0], [13.0, 14.0, 15.0, 16.0]], [[11.0, 12.0, 13.0, 14.0], [15.0, 16.0, 17.0, 18.0], [19.0, 20.0, 21.0, 22.0], [23.0, 24.0, 25.0, 26.0]]], False, ''),
('inputs:a_half', 'half', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '1.0'}, True, 1.0, False, ''),
('inputs:a_half_2', 'half2', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1.0, 2.0]'}, True, [1.0, 2.0], False, ''),
('inputs:a_half_2_array', 'half2[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.0, 2.0], [11.0, 12.0]]'}, True, [[1.0, 2.0], [11.0, 12.0]], False, ''),
('inputs:a_half_3', 'half3', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1.0, 2.0, 3.0]'}, True, [1.0, 2.0, 3.0], False, ''),
('inputs:a_half_3_array', 'half3[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.0, 2.0, 3.0], [11.0, 12.0, 13.0]]'}, True, [[1.0, 2.0, 3.0], [11.0, 12.0, 13.0]], False, ''),
('inputs:a_half_4', 'half4', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1.0, 2.0, 3.0, 4.0]'}, True, [1.0, 2.0, 3.0, 4.0], False, ''),
('inputs:a_half_4_array', 'half4[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.0, 2.0, 3.0, 4.0], [11.0, 12.0, 13.0, 14.0]]'}, True, [[1.0, 2.0, 3.0, 4.0], [11.0, 12.0, 13.0, 14.0]], False, ''),
('inputs:a_half_array', 'half[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1.0, 2.0]'}, True, [1.0, 2.0], False, ''),
('inputs:a_int', 'int', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '1'}, True, 1, False, ''),
('inputs:a_int64', 'int64', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '12345'}, True, 12345, False, ''),
('inputs:a_int64_array', 'int64[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[12345, 23456]'}, True, [12345, 23456], False, ''),
('inputs:a_int_2', 'int2', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1, 2]'}, True, [1, 2], False, ''),
('inputs:a_int_2_array', 'int2[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[1, 2], [3, 4]]'}, True, [[1, 2], [3, 4]], False, ''),
('inputs:a_int_3', 'int3', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1, 2, 3]'}, True, [1, 2, 3], False, ''),
('inputs:a_int_3_array', 'int3[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[1, 2, 3], [4, 5, 6]]'}, True, [[1, 2, 3], [4, 5, 6]], False, ''),
('inputs:a_int_4', 'int4', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1, 2, 3, 4]'}, True, [1, 2, 3, 4], False, ''),
('inputs:a_int_4_array', 'int4[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[1, 2, 3, 4], [5, 6, 7, 8]]'}, True, [[1, 2, 3, 4], [5, 6, 7, 8]], False, ''),
('inputs:a_int_array', 'int[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1, 2]'}, True, [1, 2], False, ''),
('inputs:a_matrixd_2', 'matrix2d', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.0, 2.0], [3.0, 4.0]]'}, True, [[1.0, 2.0], [3.0, 4.0]], False, ''),
('inputs:a_matrixd_2_array', 'matrix2d[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[[1.0, 2.0], [3.0, 4.0]], [[11.0, 12.0], [13.0, 14.0]]]'}, True, [[[1.0, 2.0], [3.0, 4.0]], [[11.0, 12.0], [13.0, 14.0]]], False, ''),
('inputs:a_matrixd_3', 'matrix3d', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]'}, True, [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]], False, ''),
('inputs:a_matrixd_3_array', 'matrix3d[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]], [[11.0, 12.0, 13.0], [14.0, 15.0, 16.0], [17.0, 18.0, 19.0]]]'}, True, [[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]], [[11.0, 12.0, 13.0], [14.0, 15.0, 16.0], [17.0, 18.0, 19.0]]], False, ''),
('inputs:a_matrixd_4', 'matrix4d', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0], [9.0, 10.0, 11.0, 12.0], [13.0, 14.0, 15.0, 16.0]]'}, True, [[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0], [9.0, 10.0, 11.0, 12.0], [13.0, 14.0, 15.0, 16.0]], False, ''),
('inputs:a_matrixd_4_array', 'matrix4d[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0], [9.0, 10.0, 11.0, 12.0], [13.0, 14.0, 15.0, 16.0]], [[11.0, 12.0, 13.0, 14.0], [15.0, 16.0, 17.0, 18.0], [19.0, 20.0, 21.0, 22.0], [23.0, 24.0, 25.0, 26.0]]]'}, True, [[[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0], [9.0, 10.0, 11.0, 12.0], [13.0, 14.0, 15.0, 16.0]], [[11.0, 12.0, 13.0, 14.0], [15.0, 16.0, 17.0, 18.0], [19.0, 20.0, 21.0, 22.0], [23.0, 24.0, 25.0, 26.0]]], False, ''),
('inputs:a_normald_3', 'normal3d', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1.0, 2.0, 3.0]'}, True, [1.0, 2.0, 3.0], False, ''),
('inputs:a_normald_3_array', 'normal3d[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.0, 2.0, 3.0], [11.0, 12.0, 13.0]]'}, True, [[1.0, 2.0, 3.0], [11.0, 12.0, 13.0]], False, ''),
('inputs:a_normalf_3', 'normal3f', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1.0, 2.0, 3.0]'}, True, [1.0, 2.0, 3.0], False, ''),
('inputs:a_normalf_3_array', 'normal3f[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.0, 2.0, 3.0], [11.0, 12.0, 13.0]]'}, True, [[1.0, 2.0, 3.0], [11.0, 12.0, 13.0]], False, ''),
('inputs:a_normalh_3', 'normal3h', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1.0, 2.0, 3.0]'}, True, [1.0, 2.0, 3.0], False, ''),
('inputs:a_normalh_3_array', 'normal3h[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.0, 2.0, 3.0], [11.0, 12.0, 13.0]]'}, True, [[1.0, 2.0, 3.0], [11.0, 12.0, 13.0]], False, ''),
('inputs:a_objectId', 'objectId', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '1'}, True, 1, False, ''),
('inputs:a_objectId_array', 'objectId[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1, 2]'}, True, [1, 2], False, ''),
('inputs:a_path', 'path', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '"/Input"'}, True, "/Input", False, ''),
('inputs:a_pointd_3', 'point3d', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1.0, 2.0, 3.0]'}, True, [1.0, 2.0, 3.0], False, ''),
('inputs:a_pointd_3_array', 'point3d[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.0, 2.0, 3.0], [11.0, 12.0, 13.0]]'}, True, [[1.0, 2.0, 3.0], [11.0, 12.0, 13.0]], False, ''),
('inputs:a_pointf_3', 'point3f', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1.0, 2.0, 3.0]'}, True, [1.0, 2.0, 3.0], False, ''),
('inputs:a_pointf_3_array', 'point3f[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.0, 2.0, 3.0], [11.0, 12.0, 13.0]]'}, True, [[1.0, 2.0, 3.0], [11.0, 12.0, 13.0]], False, ''),
('inputs:a_pointh_3', 'point3h', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1.0, 2.0, 3.0]'}, True, [1.0, 2.0, 3.0], False, ''),
('inputs:a_pointh_3_array', 'point3h[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.0, 2.0, 3.0], [11.0, 12.0, 13.0]]'}, True, [[1.0, 2.0, 3.0], [11.0, 12.0, 13.0]], False, ''),
('inputs:a_quatd_4', 'quatd', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1.0, 2.0, 3.0, 4.0]'}, True, [1.0, 2.0, 3.0, 4.0], False, ''),
('inputs:a_quatd_4_array', 'quatd[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.0, 2.0, 3.0, 4.0], [11.0, 12.0, 13.0, 14.0]]'}, True, [[1.0, 2.0, 3.0, 4.0], [11.0, 12.0, 13.0, 14.0]], False, ''),
('inputs:a_quatf_4', 'quatf', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1.0, 2.0, 3.0, 4.0]'}, True, [1.0, 2.0, 3.0, 4.0], False, ''),
('inputs:a_quatf_4_array', 'quatf[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.0, 2.0, 3.0, 4.0], [11.0, 12.0, 13.0, 14.0]]'}, True, [[1.0, 2.0, 3.0, 4.0], [11.0, 12.0, 13.0, 14.0]], False, ''),
('inputs:a_quath_4', 'quath', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1.0, 2.0, 3.0, 4.0]'}, True, [1.0, 2.0, 3.0, 4.0], False, ''),
('inputs:a_quath_4_array', 'quath[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.0, 2.0, 3.0, 4.0], [11.0, 12.0, 13.0, 14.0]]'}, True, [[1.0, 2.0, 3.0, 4.0], [11.0, 12.0, 13.0, 14.0]], False, ''),
('inputs:a_string', 'string', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '"Rey\\n\\"Palpatine\\" Skywalker"'}, True, "Rey\n\"Palpatine\" Skywalker", False, ''),
('inputs:a_target', 'target', 0, None, 'Input Attribute', {ogn.MetadataKeys.ALLOW_MULTI_INPUTS: '1'}, True, [], False, ''),
('inputs:a_texcoordd_2', 'texCoord2d', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1.0, 2.0]'}, True, [1.0, 2.0], False, ''),
('inputs:a_texcoordd_2_array', 'texCoord2d[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.0, 2.0], [11.0, 12.0]]'}, True, [[1.0, 2.0], [11.0, 12.0]], False, ''),
('inputs:a_texcoordd_3', 'texCoord3d', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1.0, 2.0, 3.0]'}, True, [1.0, 2.0, 3.0], False, ''),
('inputs:a_texcoordd_3_array', 'texCoord3d[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.0, 2.0, 3.0], [11.0, 12.0, 13.0]]'}, True, [[1.0, 2.0, 3.0], [11.0, 12.0, 13.0]], False, ''),
('inputs:a_texcoordf_2', 'texCoord2f', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1.0, 2.0]'}, True, [1.0, 2.0], False, ''),
('inputs:a_texcoordf_2_array', 'texCoord2f[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.0, 2.0], [11.0, 12.0]]'}, True, [[1.0, 2.0], [11.0, 12.0]], False, ''),
('inputs:a_texcoordf_3', 'texCoord3f', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1.0, 2.0, 3.0]'}, True, [1.0, 2.0, 3.0], False, ''),
('inputs:a_texcoordf_3_array', 'texCoord3f[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.0, 2.0, 3.0], [11.0, 12.0, 13.0]]'}, True, [[1.0, 2.0, 3.0], [11.0, 12.0, 13.0]], False, ''),
('inputs:a_texcoordh_2', 'texCoord2h', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1.0, 2.0]'}, True, [1.0, 2.0], False, ''),
('inputs:a_texcoordh_2_array', 'texCoord2h[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.0, 2.0], [11.0, 12.0]]'}, True, [[1.0, 2.0], [11.0, 12.0]], False, ''),
('inputs:a_texcoordh_3', 'texCoord3h', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1.0, 2.0, 3.0]'}, True, [1.0, 2.0, 3.0], False, ''),
('inputs:a_texcoordh_3_array', 'texCoord3h[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.0, 2.0, 3.0], [11.0, 12.0, 13.0]]'}, True, [[1.0, 2.0, 3.0], [11.0, 12.0, 13.0]], False, ''),
('inputs:a_timecode', 'timecode', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '1.0'}, True, 1.0, False, ''),
('inputs:a_timecode_array', 'timecode[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1.0, 2.0]'}, True, [1.0, 2.0], False, ''),
('inputs:a_token', 'token', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '"Sith\\nLord"'}, True, "Sith\nLord", False, ''),
('inputs:a_token_array', 'token[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '["Kylo\\n\\"The Putz\\"", "Ren"]'}, True, ['Kylo\n"The Putz"', 'Ren'], False, ''),
('inputs:a_uchar', 'uchar', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '1'}, True, 1, False, ''),
('inputs:a_uchar_array', 'uchar[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1, 2]'}, True, [1, 2], False, ''),
('inputs:a_uint', 'uint', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '1'}, True, 1, False, ''),
('inputs:a_uint64', 'uint64', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '1'}, True, 1, False, ''),
('inputs:a_uint64_array', 'uint64[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1, 2]'}, True, [1, 2], False, ''),
('inputs:a_uint_array', 'uint[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1, 2]'}, True, [1, 2], False, ''),
('inputs:a_vectord_3', 'vector3d', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1.0, 2.0, 3.0]'}, True, [1.0, 2.0, 3.0], False, ''),
('inputs:a_vectord_3_array', 'vector3d[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.0, 2.0, 3.0], [11.0, 12.0, 13.0]]'}, True, [[1.0, 2.0, 3.0], [11.0, 12.0, 13.0]], False, ''),
('inputs:a_vectorf_3', 'vector3f', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1.0, 2.0, 3.0]'}, True, [1.0, 2.0, 3.0], False, ''),
('inputs:a_vectorf_3_array', 'vector3f[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.0, 2.0, 3.0], [11.0, 12.0, 13.0]]'}, True, [[1.0, 2.0, 3.0], [11.0, 12.0, 13.0]], False, ''),
('inputs:a_vectorh_3', 'vector3h', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[1.0, 2.0, 3.0]'}, True, [1.0, 2.0, 3.0], False, ''),
('inputs:a_vectorh_3_array', 'vector3h[]', 0, None, 'Input Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.0, 2.0, 3.0], [11.0, 12.0, 13.0]]'}, True, [[1.0, 2.0, 3.0], [11.0, 12.0, 13.0]], False, ''),
('inputs:doNotCompute', 'bool', 0, None, 'Prevent the compute from running', {ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('outputs:a_bool', 'bool', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('outputs:a_bool_array', 'bool[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[true, false]'}, True, [True, False], False, ''),
('outputs:a_bundle', 'bundle', 0, None, 'Computed Attribute', {}, True, None, False, ''),
('outputs:a_colord_3', 'color3d', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5]'}, True, [1.5, 2.5, 3.5], False, ''),
('outputs:a_colord_3_array', 'color3d[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]]'}, True, [[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]], False, ''),
('outputs:a_colord_4', 'color4d', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5, 4.5]'}, True, [1.5, 2.5, 3.5, 4.5], False, ''),
('outputs:a_colord_4_array', 'color4d[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5, 4.5], [11.5, 12.5, 13.5, 14.5]]'}, True, [[1.5, 2.5, 3.5, 4.5], [11.5, 12.5, 13.5, 14.5]], False, ''),
('outputs:a_colorf_3', 'color3f', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5]'}, True, [1.5, 2.5, 3.5], False, ''),
('outputs:a_colorf_3_array', 'color3f[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]]'}, True, [[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]], False, ''),
('outputs:a_colorf_4', 'color4f', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5, 4.5]'}, True, [1.5, 2.5, 3.5, 4.5], False, ''),
('outputs:a_colorf_4_array', 'color4f[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5, 4.5], [11.5, 12.5, 13.5, 14.5]]'}, True, [[1.5, 2.5, 3.5, 4.5], [11.5, 12.5, 13.5, 14.5]], False, ''),
('outputs:a_colorh_3', 'color3h', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5]'}, True, [1.5, 2.5, 3.5], False, ''),
('outputs:a_colorh_3_array', 'color3h[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]]'}, True, [[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]], False, ''),
('outputs:a_colorh_4', 'color4h', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5, 4.5]'}, True, [1.5, 2.5, 3.5, 4.5], False, ''),
('outputs:a_colorh_4_array', 'color4h[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5, 4.5], [11.5, 12.5, 13.5, 14.5]]'}, True, [[1.5, 2.5, 3.5, 4.5], [11.5, 12.5, 13.5, 14.5]], False, ''),
('outputs:a_double', 'double', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '1.5'}, True, 1.5, False, ''),
('outputs:a_double_2', 'double2', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5]'}, True, [1.5, 2.5], False, ''),
('outputs:a_double_2_array', 'double2[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5], [11.5, 12.5]]'}, True, [[1.5, 2.5], [11.5, 12.5]], False, ''),
('outputs:a_double_3', 'double3', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5]'}, True, [1.5, 2.5, 3.5], False, ''),
('outputs:a_double_3_array', 'double3[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]]'}, True, [[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]], False, ''),
('outputs:a_double_4', 'double4', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5, 4.5]'}, True, [1.5, 2.5, 3.5, 4.5], False, ''),
('outputs:a_double_4_array', 'double4[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5, 4.5], [11.5, 12.5, 13.5, 14.5]]'}, True, [[1.5, 2.5, 3.5, 4.5], [11.5, 12.5, 13.5, 14.5]], False, ''),
('outputs:a_double_array', 'double[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5]'}, True, [1.5, 2.5], False, ''),
('outputs:a_execution', 'execution', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '2'}, True, 2, False, ''),
('outputs:a_float', 'float', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '1.5'}, True, 1.5, False, ''),
('outputs:a_float_2', 'float2', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5]'}, True, [1.5, 2.5], False, ''),
('outputs:a_float_2_array', 'float2[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5], [11.5, 12.5]]'}, True, [[1.5, 2.5], [11.5, 12.5]], False, ''),
('outputs:a_float_3', 'float3', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5]'}, True, [1.5, 2.5, 3.5], False, ''),
('outputs:a_float_3_array', 'float3[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]]'}, True, [[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]], False, ''),
('outputs:a_float_4', 'float4', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5, 4.5]'}, True, [1.5, 2.5, 3.5, 4.5], False, ''),
('outputs:a_float_4_array', 'float4[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5, 4.5], [11.5, 12.5, 13.5, 14.5]]'}, True, [[1.5, 2.5, 3.5, 4.5], [11.5, 12.5, 13.5, 14.5]], False, ''),
('outputs:a_float_array', 'float[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5]'}, True, [1.5, 2.5], False, ''),
('outputs:a_frame_4', 'frame4d', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5, 4.5], [5.5, 6.5, 7.5, 8.5], [9.5, 10.5, 11.5, 12.5], [13.5, 14.5, 15.5, 16.5]]'}, True, [[1.5, 2.5, 3.5, 4.5], [5.5, 6.5, 7.5, 8.5], [9.5, 10.5, 11.5, 12.5], [13.5, 14.5, 15.5, 16.5]], False, ''),
('outputs:a_frame_4_array', 'frame4d[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[[1.5, 2.5, 3.5, 4.5], [5.5, 6.5, 7.5, 8.5], [9.5, 10.5, 11.5, 12.5], [13.5, 14.5, 15.5, 16.5]], [[11.5, 12.5, 13.5, 14.5], [15.5, 16.5, 17.5, 18.5], [19.5, 20.5, 21.5, 22.5], [23.5, 24.5, 25.5, 26.5]]]'}, True, [[[1.5, 2.5, 3.5, 4.5], [5.5, 6.5, 7.5, 8.5], [9.5, 10.5, 11.5, 12.5], [13.5, 14.5, 15.5, 16.5]], [[11.5, 12.5, 13.5, 14.5], [15.5, 16.5, 17.5, 18.5], [19.5, 20.5, 21.5, 22.5], [23.5, 24.5, 25.5, 26.5]]], False, ''),
('outputs:a_half', 'half', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '1.5'}, True, 1.5, False, ''),
('outputs:a_half_2', 'half2', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5]'}, True, [1.5, 2.5], False, ''),
('outputs:a_half_2_array', 'half2[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5], [11.5, 12.5]]'}, True, [[1.5, 2.5], [11.5, 12.5]], False, ''),
('outputs:a_half_3', 'half3', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5]'}, True, [1.5, 2.5, 3.5], False, ''),
('outputs:a_half_3_array', 'half3[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]]'}, True, [[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]], False, ''),
('outputs:a_half_4', 'half4', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5, 4.5]'}, True, [1.5, 2.5, 3.5, 4.5], False, ''),
('outputs:a_half_4_array', 'half4[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5, 4.5], [11.5, 12.5, 13.5, 14.5]]'}, True, [[1.5, 2.5, 3.5, 4.5], [11.5, 12.5, 13.5, 14.5]], False, ''),
('outputs:a_half_array', 'half[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5]'}, True, [1.5, 2.5], False, ''),
('outputs:a_int', 'int', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '1'}, True, 1, False, ''),
('outputs:a_int64', 'int64', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '12345'}, True, 12345, False, ''),
('outputs:a_int64_array', 'int64[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[12345, 23456]'}, True, [12345, 23456], False, ''),
('outputs:a_int_2', 'int2', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[1, 2]'}, True, [1, 2], False, ''),
('outputs:a_int_2_array', 'int2[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[1, 2], [3, 4]]'}, True, [[1, 2], [3, 4]], False, ''),
('outputs:a_int_3', 'int3', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[1, 2, 3]'}, True, [1, 2, 3], False, ''),
('outputs:a_int_3_array', 'int3[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[1, 2, 3], [4, 5, 6]]'}, True, [[1, 2, 3], [4, 5, 6]], False, ''),
('outputs:a_int_4', 'int4', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[1, 2, 3, 4]'}, True, [1, 2, 3, 4], False, ''),
('outputs:a_int_4_array', 'int4[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[1, 2, 3, 4], [5, 6, 7, 8]]'}, True, [[1, 2, 3, 4], [5, 6, 7, 8]], False, ''),
('outputs:a_int_array', 'int[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[1, 2]'}, True, [1, 2], False, ''),
('outputs:a_matrixd_2', 'matrix2d', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5], [3.5, 4.5]]'}, True, [[1.5, 2.5], [3.5, 4.5]], False, ''),
('outputs:a_matrixd_2_array', 'matrix2d[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[[1.5, 2.5], [3.5, 4.5]], [[11.5, 12.5], [13.5, 14.5]]]'}, True, [[[1.5, 2.5], [3.5, 4.5]], [[11.5, 12.5], [13.5, 14.5]]], False, ''),
('outputs:a_matrixd_3', 'matrix3d', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5], [4.5, 5.5, 6.5], [7.5, 8.5, 9.5]]'}, True, [[1.5, 2.5, 3.5], [4.5, 5.5, 6.5], [7.5, 8.5, 9.5]], False, ''),
('outputs:a_matrixd_3_array', 'matrix3d[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[[1.5, 2.5, 3.5], [4.5, 5.5, 6.5], [7.5, 8.5, 9.5]], [[11.5, 12.5, 13.5], [14.5, 15.5, 16.5], [17.5, 18.5, 19.5]]]'}, True, [[[1.5, 2.5, 3.5], [4.5, 5.5, 6.5], [7.5, 8.5, 9.5]], [[11.5, 12.5, 13.5], [14.5, 15.5, 16.5], [17.5, 18.5, 19.5]]], False, ''),
('outputs:a_matrixd_4', 'matrix4d', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5, 4.5], [5.5, 6.5, 7.5, 8.5], [9.5, 10.5, 11.5, 12.5], [13.5, 14.5, 15.5, 16.5]]'}, True, [[1.5, 2.5, 3.5, 4.5], [5.5, 6.5, 7.5, 8.5], [9.5, 10.5, 11.5, 12.5], [13.5, 14.5, 15.5, 16.5]], False, ''),
('outputs:a_matrixd_4_array', 'matrix4d[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[[1.5, 2.5, 3.5, 4.5], [5.5, 6.5, 7.5, 8.5], [9.5, 10.5, 11.5, 12.5], [13.5, 14.5, 15.5, 16.5]], [[11.5, 12.5, 13.5, 14.5], [15.5, 16.5, 17.5, 18.5], [19.5, 20.5, 21.5, 22.5], [23.5, 24.5, 25.5, 26.5]]]'}, True, [[[1.5, 2.5, 3.5, 4.5], [5.5, 6.5, 7.5, 8.5], [9.5, 10.5, 11.5, 12.5], [13.5, 14.5, 15.5, 16.5]], [[11.5, 12.5, 13.5, 14.5], [15.5, 16.5, 17.5, 18.5], [19.5, 20.5, 21.5, 22.5], [23.5, 24.5, 25.5, 26.5]]], False, ''),
('outputs:a_normald_3', 'normal3d', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5]'}, True, [1.5, 2.5, 3.5], False, ''),
('outputs:a_normald_3_array', 'normal3d[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]]'}, True, [[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]], False, ''),
('outputs:a_normalf_3', 'normal3f', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5]'}, True, [1.5, 2.5, 3.5], False, ''),
('outputs:a_normalf_3_array', 'normal3f[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]]'}, True, [[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]], False, ''),
('outputs:a_normalh_3', 'normal3h', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5]'}, True, [1.5, 2.5, 3.5], False, ''),
('outputs:a_normalh_3_array', 'normal3h[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]]'}, True, [[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]], False, ''),
('outputs:a_objectId', 'objectId', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '2'}, True, 2, False, ''),
('outputs:a_objectId_array', 'objectId[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[2, 3]'}, True, [2, 3], False, ''),
('outputs:a_path', 'path', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '"/Output"'}, True, "/Output", False, ''),
('outputs:a_pointd_3', 'point3d', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5]'}, True, [1.5, 2.5, 3.5], False, ''),
('outputs:a_pointd_3_array', 'point3d[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]]'}, True, [[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]], False, ''),
('outputs:a_pointf_3', 'point3f', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5]'}, True, [1.5, 2.5, 3.5], False, ''),
('outputs:a_pointf_3_array', 'point3f[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]]'}, True, [[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]], False, ''),
('outputs:a_pointh_3', 'point3h', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5]'}, True, [1.5, 2.5, 3.5], False, ''),
('outputs:a_pointh_3_array', 'point3h[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]]'}, True, [[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]], False, ''),
('outputs:a_quatd_4', 'quatd', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5, 4.5]'}, True, [1.5, 2.5, 3.5, 4.5], False, ''),
('outputs:a_quatd_4_array', 'quatd[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5, 4.5], [11.5, 12.5, 13.5, 14.5]]'}, True, [[1.5, 2.5, 3.5, 4.5], [11.5, 12.5, 13.5, 14.5]], False, ''),
('outputs:a_quatf_4', 'quatf', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5, 4.5]'}, True, [1.5, 2.5, 3.5, 4.5], False, ''),
('outputs:a_quatf_4_array', 'quatf[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5, 4.5], [11.5, 12.5, 13.5, 14.5]]'}, True, [[1.5, 2.5, 3.5, 4.5], [11.5, 12.5, 13.5, 14.5]], False, ''),
('outputs:a_quath_4', 'quath', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5, 4.5]'}, True, [1.5, 2.5, 3.5, 4.5], False, ''),
('outputs:a_quath_4_array', 'quath[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5, 4.5], [11.5, 12.5, 13.5, 14.5]]'}, True, [[1.5, 2.5, 3.5, 4.5], [11.5, 12.5, 13.5, 14.5]], False, ''),
('outputs:a_string', 'string', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '"Emperor\\n\\"Half\\" Snoke"'}, True, "Emperor\n\"Half\" Snoke", False, ''),
('outputs:a_target', 'target', 0, None, 'Computed Attribute', {}, True, [], False, ''),
('outputs:a_texcoordd_2', 'texCoord2d', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5]'}, True, [1.5, 2.5], False, ''),
('outputs:a_texcoordd_2_array', 'texCoord2d[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5], [11.5, 12.5]]'}, True, [[1.5, 2.5], [11.5, 12.5]], False, ''),
('outputs:a_texcoordd_3', 'texCoord3d', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5]'}, True, [1.5, 2.5, 3.5], False, ''),
('outputs:a_texcoordd_3_array', 'texCoord3d[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]]'}, True, [[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]], False, ''),
('outputs:a_texcoordf_2', 'texCoord2f', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5]'}, True, [1.5, 2.5], False, ''),
('outputs:a_texcoordf_2_array', 'texCoord2f[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5], [11.5, 12.5]]'}, True, [[1.5, 2.5], [11.5, 12.5]], False, ''),
('outputs:a_texcoordf_3', 'texCoord3f', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5]'}, True, [1.5, 2.5, 3.5], False, ''),
('outputs:a_texcoordf_3_array', 'texCoord3f[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]]'}, True, [[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]], False, ''),
('outputs:a_texcoordh_2', 'texCoord2h', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5]'}, True, [1.5, 2.5], False, ''),
('outputs:a_texcoordh_2_array', 'texCoord2h[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5], [11.5, 12.5]]'}, True, [[1.5, 2.5], [11.5, 12.5]], False, ''),
('outputs:a_texcoordh_3', 'texCoord3h', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5]'}, True, [1.5, 2.5, 3.5], False, ''),
('outputs:a_texcoordh_3_array', 'texCoord3h[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]]'}, True, [[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]], False, ''),
('outputs:a_timecode', 'timecode', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '2.5'}, True, 2.5, False, ''),
('outputs:a_timecode_array', 'timecode[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[2.5, 3.5]'}, True, [2.5, 3.5], False, ''),
('outputs:a_token', 'token', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '"Jedi\\nMaster"'}, True, "Jedi\nMaster", False, ''),
('outputs:a_token_array', 'token[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '["Luke\\n\\"Whiner\\"", "Skywalker"]'}, True, ['Luke\n"Whiner"', 'Skywalker'], False, ''),
('outputs:a_uchar', 'uchar', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '2'}, True, 2, False, ''),
('outputs:a_uchar_array', 'uchar[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[2, 3]'}, True, [2, 3], False, ''),
('outputs:a_uint', 'uint', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '2'}, True, 2, False, ''),
('outputs:a_uint64', 'uint64', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '2'}, True, 2, False, ''),
('outputs:a_uint64_array', 'uint64[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[2, 3]'}, True, [2, 3], False, ''),
('outputs:a_uint_array', 'uint[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[2, 3]'}, True, [2, 3], False, ''),
('outputs:a_vectord_3', 'vector3d', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5]'}, True, [1.5, 2.5, 3.5], False, ''),
('outputs:a_vectord_3_array', 'vector3d[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]]'}, True, [[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]], False, ''),
('outputs:a_vectorf_3', 'vector3f', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5]'}, True, [1.5, 2.5, 3.5], False, ''),
('outputs:a_vectorf_3_array', 'vector3f[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]]'}, True, [[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]], False, ''),
('outputs:a_vectorh_3', 'vector3h', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5]'}, True, [1.5, 2.5, 3.5], False, ''),
('outputs:a_vectorh_3_array', 'vector3h[]', 0, None, 'Computed Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]]'}, True, [[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]], False, ''),
('state:a_bool', 'bool', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('state:a_bool_array', 'bool[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[true, false]'}, True, [True, False], False, ''),
('state:a_bundle', 'bundle', 0, None, 'State Attribute', {}, True, None, False, ''),
('state:a_colord_3', 'color3d', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5]'}, True, [1.5, 2.5, 3.5], False, ''),
('state:a_colord_3_array', 'color3d[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]]'}, True, [[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]], False, ''),
('state:a_colord_4', 'color4d', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5, 4.5]'}, True, [1.5, 2.5, 3.5, 4.5], False, ''),
('state:a_colord_4_array', 'color4d[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5, 4.5], [11.5, 12.5, 13.5, 14.5]]'}, True, [[1.5, 2.5, 3.5, 4.5], [11.5, 12.5, 13.5, 14.5]], False, ''),
('state:a_colorf_3', 'color3f', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5]'}, True, [1.5, 2.5, 3.5], False, ''),
('state:a_colorf_3_array', 'color3f[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]]'}, True, [[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]], False, ''),
('state:a_colorf_4', 'color4f', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5, 4.5]'}, True, [1.5, 2.5, 3.5, 4.5], False, ''),
('state:a_colorf_4_array', 'color4f[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5, 4.5], [11.5, 12.5, 13.5, 14.5]]'}, True, [[1.5, 2.5, 3.5, 4.5], [11.5, 12.5, 13.5, 14.5]], False, ''),
('state:a_colorh_3', 'color3h', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5]'}, True, [1.5, 2.5, 3.5], False, ''),
('state:a_colorh_3_array', 'color3h[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]]'}, True, [[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]], False, ''),
('state:a_colorh_4', 'color4h', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5, 4.5]'}, True, [1.5, 2.5, 3.5, 4.5], False, ''),
('state:a_colorh_4_array', 'color4h[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5, 4.5], [11.5, 12.5, 13.5, 14.5]]'}, True, [[1.5, 2.5, 3.5, 4.5], [11.5, 12.5, 13.5, 14.5]], False, ''),
('state:a_double', 'double', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '1.5'}, True, 1.5, False, ''),
('state:a_double_2', 'double2', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5]'}, True, [1.5, 2.5], False, ''),
('state:a_double_2_array', 'double2[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5], [11.5, 12.5]]'}, True, [[1.5, 2.5], [11.5, 12.5]], False, ''),
('state:a_double_3', 'double3', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5]'}, True, [1.5, 2.5, 3.5], False, ''),
('state:a_double_3_array', 'double3[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]]'}, True, [[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]], False, ''),
('state:a_double_4', 'double4', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5, 4.5]'}, True, [1.5, 2.5, 3.5, 4.5], False, ''),
('state:a_double_4_array', 'double4[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5, 4.5], [11.5, 12.5, 13.5, 14.5]]'}, True, [[1.5, 2.5, 3.5, 4.5], [11.5, 12.5, 13.5, 14.5]], False, ''),
('state:a_double_array', 'double[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5]'}, True, [1.5, 2.5], False, ''),
('state:a_execution', 'execution', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '2'}, True, 2, False, ''),
('state:a_firstEvaluation', 'bool', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('state:a_float', 'float', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '1.5'}, True, 1.5, False, ''),
('state:a_float_2', 'float2', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5]'}, True, [1.5, 2.5], False, ''),
('state:a_float_2_array', 'float2[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5], [11.5, 12.5]]'}, True, [[1.5, 2.5], [11.5, 12.5]], False, ''),
('state:a_float_3', 'float3', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5]'}, True, [1.5, 2.5, 3.5], False, ''),
('state:a_float_3_array', 'float3[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]]'}, True, [[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]], False, ''),
('state:a_float_4', 'float4', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5, 4.5]'}, True, [1.5, 2.5, 3.5, 4.5], False, ''),
('state:a_float_4_array', 'float4[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5, 4.5], [11.5, 12.5, 13.5, 14.5]]'}, True, [[1.5, 2.5, 3.5, 4.5], [11.5, 12.5, 13.5, 14.5]], False, ''),
('state:a_float_array', 'float[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5]'}, True, [1.5, 2.5], False, ''),
('state:a_frame_4', 'frame4d', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5, 4.5], [5.5, 6.5, 7.5, 8.5], [9.5, 10.5, 11.5, 12.5], [13.5, 14.5, 15.5, 16.5]]'}, True, [[1.5, 2.5, 3.5, 4.5], [5.5, 6.5, 7.5, 8.5], [9.5, 10.5, 11.5, 12.5], [13.5, 14.5, 15.5, 16.5]], False, ''),
('state:a_frame_4_array', 'frame4d[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[[1.5, 2.5, 3.5, 4.5], [5.5, 6.5, 7.5, 8.5], [9.5, 10.5, 11.5, 12.5], [13.5, 14.5, 15.5, 16.5]], [[11.5, 12.5, 13.5, 14.5], [15.5, 16.5, 17.5, 18.5], [19.5, 20.5, 21.5, 22.5], [23.5, 24.5, 25.5, 26.5]]]'}, True, [[[1.5, 2.5, 3.5, 4.5], [5.5, 6.5, 7.5, 8.5], [9.5, 10.5, 11.5, 12.5], [13.5, 14.5, 15.5, 16.5]], [[11.5, 12.5, 13.5, 14.5], [15.5, 16.5, 17.5, 18.5], [19.5, 20.5, 21.5, 22.5], [23.5, 24.5, 25.5, 26.5]]], False, ''),
('state:a_half', 'half', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '1.5'}, True, 1.5, False, ''),
('state:a_half_2', 'half2', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5]'}, True, [1.5, 2.5], False, ''),
('state:a_half_2_array', 'half2[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5], [11.5, 12.5]]'}, True, [[1.5, 2.5], [11.5, 12.5]], False, ''),
('state:a_half_3', 'half3', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5]'}, True, [1.5, 2.5, 3.5], False, ''),
('state:a_half_3_array', 'half3[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]]'}, True, [[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]], False, ''),
('state:a_half_4', 'half4', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5, 4.5]'}, True, [1.5, 2.5, 3.5, 4.5], False, ''),
('state:a_half_4_array', 'half4[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5, 4.5], [11.5, 12.5, 13.5, 14.5]]'}, True, [[1.5, 2.5, 3.5, 4.5], [11.5, 12.5, 13.5, 14.5]], False, ''),
('state:a_half_array', 'half[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5]'}, True, [1.5, 2.5], False, ''),
('state:a_int', 'int', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '1'}, True, 1, False, ''),
('state:a_int64', 'int64', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '12345'}, True, 12345, False, ''),
('state:a_int64_array', 'int64[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[12345, 23456]'}, True, [12345, 23456], False, ''),
('state:a_int_2', 'int2', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[1, 2]'}, True, [1, 2], False, ''),
('state:a_int_2_array', 'int2[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[1, 2], [3, 4]]'}, True, [[1, 2], [3, 4]], False, ''),
('state:a_int_3', 'int3', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[1, 2, 3]'}, True, [1, 2, 3], False, ''),
('state:a_int_3_array', 'int3[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[1, 2, 3], [4, 5, 6]]'}, True, [[1, 2, 3], [4, 5, 6]], False, ''),
('state:a_int_4', 'int4', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[1, 2, 3, 4]'}, True, [1, 2, 3, 4], False, ''),
('state:a_int_4_array', 'int4[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[1, 2, 3, 4], [5, 6, 7, 8]]'}, True, [[1, 2, 3, 4], [5, 6, 7, 8]], False, ''),
('state:a_int_array', 'int[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[1, 2]'}, True, [1, 2], False, ''),
('state:a_matrixd_2', 'matrix2d', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5], [3.5, 4.5]]'}, True, [[1.5, 2.5], [3.5, 4.5]], False, ''),
('state:a_matrixd_2_array', 'matrix2d[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[[1.5, 2.5], [3.5, 4.5]], [[11.5, 12.5], [13.5, 14.5]]]'}, True, [[[1.5, 2.5], [3.5, 4.5]], [[11.5, 12.5], [13.5, 14.5]]], False, ''),
('state:a_matrixd_3', 'matrix3d', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5], [4.5, 5.5, 6.5], [7.5, 8.5, 9.5]]'}, True, [[1.5, 2.5, 3.5], [4.5, 5.5, 6.5], [7.5, 8.5, 9.5]], False, ''),
('state:a_matrixd_3_array', 'matrix3d[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[[1.5, 2.5, 3.5], [4.5, 5.5, 6.5], [7.5, 8.5, 9.5]], [[11.5, 12.5, 13.5], [14.5, 15.5, 16.5], [17.5, 18.5, 19.5]]]'}, True, [[[1.5, 2.5, 3.5], [4.5, 5.5, 6.5], [7.5, 8.5, 9.5]], [[11.5, 12.5, 13.5], [14.5, 15.5, 16.5], [17.5, 18.5, 19.5]]], False, ''),
('state:a_matrixd_4', 'matrix4d', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5, 4.5], [5.5, 6.5, 7.5, 8.5], [9.5, 10.5, 11.5, 12.5], [13.5, 14.5, 15.5, 16.5]]'}, True, [[1.5, 2.5, 3.5, 4.5], [5.5, 6.5, 7.5, 8.5], [9.5, 10.5, 11.5, 12.5], [13.5, 14.5, 15.5, 16.5]], False, ''),
('state:a_matrixd_4_array', 'matrix4d[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[[1.5, 2.5, 3.5, 4.5], [5.5, 6.5, 7.5, 8.5], [9.5, 10.5, 11.5, 12.5], [13.5, 14.5, 15.5, 16.5]], [[11.5, 12.5, 13.5, 14.5], [15.5, 16.5, 17.5, 18.5], [19.5, 20.5, 21.5, 22.5], [23.5, 24.5, 25.5, 26.5]]]'}, True, [[[1.5, 2.5, 3.5, 4.5], [5.5, 6.5, 7.5, 8.5], [9.5, 10.5, 11.5, 12.5], [13.5, 14.5, 15.5, 16.5]], [[11.5, 12.5, 13.5, 14.5], [15.5, 16.5, 17.5, 18.5], [19.5, 20.5, 21.5, 22.5], [23.5, 24.5, 25.5, 26.5]]], False, ''),
('state:a_normald_3', 'normal3d', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5]'}, True, [1.5, 2.5, 3.5], False, ''),
('state:a_normald_3_array', 'normal3d[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]]'}, True, [[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]], False, ''),
('state:a_normalf_3', 'normal3f', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5]'}, True, [1.5, 2.5, 3.5], False, ''),
('state:a_normalf_3_array', 'normal3f[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]]'}, True, [[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]], False, ''),
('state:a_normalh_3', 'normal3h', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5]'}, True, [1.5, 2.5, 3.5], False, ''),
('state:a_normalh_3_array', 'normal3h[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]]'}, True, [[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]], False, ''),
('state:a_objectId', 'objectId', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '2'}, True, 2, False, ''),
('state:a_objectId_array', 'objectId[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[2, 3]'}, True, [2, 3], False, ''),
('state:a_path', 'path', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '"/State"'}, True, "/State", False, ''),
('state:a_pointd_3', 'point3d', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5]'}, True, [1.5, 2.5, 3.5], False, ''),
('state:a_pointd_3_array', 'point3d[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]]'}, True, [[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]], False, ''),
('state:a_pointf_3', 'point3f', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5]'}, True, [1.5, 2.5, 3.5], False, ''),
('state:a_pointf_3_array', 'point3f[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]]'}, True, [[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]], False, ''),
('state:a_pointh_3', 'point3h', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5]'}, True, [1.5, 2.5, 3.5], False, ''),
('state:a_pointh_3_array', 'point3h[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]]'}, True, [[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]], False, ''),
('state:a_quatd_4', 'quatd', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5, 4.5]'}, True, [1.5, 2.5, 3.5, 4.5], False, ''),
('state:a_quatd_4_array', 'quatd[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5, 4.5], [11.5, 12.5, 13.5, 14.5]]'}, True, [[1.5, 2.5, 3.5, 4.5], [11.5, 12.5, 13.5, 14.5]], False, ''),
('state:a_quatf_4', 'quatf', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5, 4.5]'}, True, [1.5, 2.5, 3.5, 4.5], False, ''),
('state:a_quatf_4_array', 'quatf[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5, 4.5], [11.5, 12.5, 13.5, 14.5]]'}, True, [[1.5, 2.5, 3.5, 4.5], [11.5, 12.5, 13.5, 14.5]], False, ''),
('state:a_quath_4', 'quath', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5, 4.5]'}, True, [1.5, 2.5, 3.5, 4.5], False, ''),
('state:a_quath_4_array', 'quath[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5, 4.5], [11.5, 12.5, 13.5, 14.5]]'}, True, [[1.5, 2.5, 3.5, 4.5], [11.5, 12.5, 13.5, 14.5]], False, ''),
('state:a_string', 'string', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '"Emperor\\n\\"Half\\" Snoke"'}, True, "Emperor\n\"Half\" Snoke", False, ''),
('state:a_stringEmpty', 'string', 0, None, 'State Attribute', {}, True, None, False, ''),
('state:a_target', 'target', 0, None, 'State Attribute', {}, True, [], False, ''),
('state:a_texcoordd_2', 'texCoord2d', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5]'}, True, [1.5, 2.5], False, ''),
('state:a_texcoordd_2_array', 'texCoord2d[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5], [11.5, 12.5]]'}, True, [[1.5, 2.5], [11.5, 12.5]], False, ''),
('state:a_texcoordd_3', 'texCoord3d', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5]'}, True, [1.5, 2.5, 3.5], False, ''),
('state:a_texcoordd_3_array', 'texCoord3d[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]]'}, True, [[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]], False, ''),
('state:a_texcoordf_2', 'texCoord2f', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5]'}, True, [1.5, 2.5], False, ''),
('state:a_texcoordf_2_array', 'texCoord2f[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5], [11.5, 12.5]]'}, True, [[1.5, 2.5], [11.5, 12.5]], False, ''),
('state:a_texcoordf_3', 'texCoord3f', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5]'}, True, [1.5, 2.5, 3.5], False, ''),
('state:a_texcoordf_3_array', 'texCoord3f[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]]'}, True, [[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]], False, ''),
('state:a_texcoordh_2', 'texCoord2h', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5]'}, True, [1.5, 2.5], False, ''),
('state:a_texcoordh_2_array', 'texCoord2h[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5], [11.5, 12.5]]'}, True, [[1.5, 2.5], [11.5, 12.5]], False, ''),
('state:a_texcoordh_3', 'texCoord3h', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5]'}, True, [1.5, 2.5, 3.5], False, ''),
('state:a_texcoordh_3_array', 'texCoord3h[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]]'}, True, [[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]], False, ''),
('state:a_timecode', 'timecode', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '2.5'}, True, 2.5, False, ''),
('state:a_timecode_array', 'timecode[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[2.5, 3.5]'}, True, [2.5, 3.5], False, ''),
('state:a_token', 'token', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '"Jedi\\nMaster"'}, True, "Jedi\nMaster", False, ''),
('state:a_token_array', 'token[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '["Luke\\n\\"Whiner\\"", "Skywalker"]'}, True, ['Luke\n"Whiner"', 'Skywalker'], False, ''),
('state:a_uchar', 'uchar', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '2'}, True, 2, False, ''),
('state:a_uchar_array', 'uchar[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[2, 3]'}, True, [2, 3], False, ''),
('state:a_uint', 'uint', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '2'}, True, 2, False, ''),
('state:a_uint64', 'uint64', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '2'}, True, 2, False, ''),
('state:a_uint64_array', 'uint64[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[2, 3]'}, True, [2, 3], False, ''),
('state:a_uint_array', 'uint[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[2, 3]'}, True, [2, 3], False, ''),
('state:a_vectord_3', 'vector3d', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5]'}, True, [1.5, 2.5, 3.5], False, ''),
('state:a_vectord_3_array', 'vector3d[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]]'}, True, [[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]], False, ''),
('state:a_vectorf_3', 'vector3f', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5]'}, True, [1.5, 2.5, 3.5], False, ''),
('state:a_vectorf_3_array', 'vector3f[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]]'}, True, [[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]], False, ''),
('state:a_vectorh_3', 'vector3h', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[1.5, 2.5, 3.5]'}, True, [1.5, 2.5, 3.5], False, ''),
('state:a_vectorh_3_array', 'vector3h[]', 0, None, 'State Attribute', {ogn.MetadataKeys.DEFAULT: '[[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]]'}, True, [[1.5, 2.5, 3.5], [11.5, 12.5, 13.5]], 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.a_bundle = og.AttributeRole.BUNDLE
role_data.inputs.a_colord_3 = og.AttributeRole.COLOR
role_data.inputs.a_colord_3_array = og.AttributeRole.COLOR
role_data.inputs.a_colord_4 = og.AttributeRole.COLOR
role_data.inputs.a_colord_4_array = og.AttributeRole.COLOR
role_data.inputs.a_colorf_3 = og.AttributeRole.COLOR
role_data.inputs.a_colorf_3_array = og.AttributeRole.COLOR
role_data.inputs.a_colorf_4 = og.AttributeRole.COLOR
role_data.inputs.a_colorf_4_array = og.AttributeRole.COLOR
role_data.inputs.a_colorh_3 = og.AttributeRole.COLOR
role_data.inputs.a_colorh_3_array = og.AttributeRole.COLOR
role_data.inputs.a_colorh_4 = og.AttributeRole.COLOR
role_data.inputs.a_colorh_4_array = og.AttributeRole.COLOR
role_data.inputs.a_execution = og.AttributeRole.EXECUTION
role_data.inputs.a_frame_4 = og.AttributeRole.FRAME
role_data.inputs.a_frame_4_array = og.AttributeRole.FRAME
role_data.inputs.a_matrixd_2 = og.AttributeRole.MATRIX
role_data.inputs.a_matrixd_2_array = og.AttributeRole.MATRIX
role_data.inputs.a_matrixd_3 = og.AttributeRole.MATRIX
role_data.inputs.a_matrixd_3_array = og.AttributeRole.MATRIX
role_data.inputs.a_matrixd_4 = og.AttributeRole.MATRIX
role_data.inputs.a_matrixd_4_array = og.AttributeRole.MATRIX
role_data.inputs.a_normald_3 = og.AttributeRole.NORMAL
role_data.inputs.a_normald_3_array = og.AttributeRole.NORMAL
role_data.inputs.a_normalf_3 = og.AttributeRole.NORMAL
role_data.inputs.a_normalf_3_array = og.AttributeRole.NORMAL
role_data.inputs.a_normalh_3 = og.AttributeRole.NORMAL
role_data.inputs.a_normalh_3_array = og.AttributeRole.NORMAL
role_data.inputs.a_objectId = og.AttributeRole.OBJECT_ID
role_data.inputs.a_objectId_array = og.AttributeRole.OBJECT_ID
role_data.inputs.a_path = og.AttributeRole.PATH
role_data.inputs.a_pointd_3 = og.AttributeRole.POSITION
role_data.inputs.a_pointd_3_array = og.AttributeRole.POSITION
role_data.inputs.a_pointf_3 = og.AttributeRole.POSITION
role_data.inputs.a_pointf_3_array = og.AttributeRole.POSITION
role_data.inputs.a_pointh_3 = og.AttributeRole.POSITION
role_data.inputs.a_pointh_3_array = og.AttributeRole.POSITION
role_data.inputs.a_quatd_4 = og.AttributeRole.QUATERNION
role_data.inputs.a_quatd_4_array = og.AttributeRole.QUATERNION
role_data.inputs.a_quatf_4 = og.AttributeRole.QUATERNION
role_data.inputs.a_quatf_4_array = og.AttributeRole.QUATERNION
role_data.inputs.a_quath_4 = og.AttributeRole.QUATERNION
role_data.inputs.a_quath_4_array = og.AttributeRole.QUATERNION
role_data.inputs.a_string = og.AttributeRole.TEXT
role_data.inputs.a_target = og.AttributeRole.TARGET
role_data.inputs.a_texcoordd_2 = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordd_2_array = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordd_3 = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordd_3_array = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordf_2 = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordf_2_array = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordf_3 = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordf_3_array = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordh_2 = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordh_2_array = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordh_3 = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordh_3_array = og.AttributeRole.TEXCOORD
role_data.inputs.a_timecode = og.AttributeRole.TIMECODE
role_data.inputs.a_timecode_array = og.AttributeRole.TIMECODE
role_data.inputs.a_vectord_3 = og.AttributeRole.VECTOR
role_data.inputs.a_vectord_3_array = og.AttributeRole.VECTOR
role_data.inputs.a_vectorf_3 = og.AttributeRole.VECTOR
role_data.inputs.a_vectorf_3_array = og.AttributeRole.VECTOR
role_data.inputs.a_vectorh_3 = og.AttributeRole.VECTOR
role_data.inputs.a_vectorh_3_array = og.AttributeRole.VECTOR
role_data.outputs.a_bundle = og.AttributeRole.BUNDLE
role_data.outputs.a_colord_3 = og.AttributeRole.COLOR
role_data.outputs.a_colord_3_array = og.AttributeRole.COLOR
role_data.outputs.a_colord_4 = og.AttributeRole.COLOR
role_data.outputs.a_colord_4_array = og.AttributeRole.COLOR
role_data.outputs.a_colorf_3 = og.AttributeRole.COLOR
role_data.outputs.a_colorf_3_array = og.AttributeRole.COLOR
role_data.outputs.a_colorf_4 = og.AttributeRole.COLOR
role_data.outputs.a_colorf_4_array = og.AttributeRole.COLOR
role_data.outputs.a_colorh_3 = og.AttributeRole.COLOR
role_data.outputs.a_colorh_3_array = og.AttributeRole.COLOR
role_data.outputs.a_colorh_4 = og.AttributeRole.COLOR
role_data.outputs.a_colorh_4_array = og.AttributeRole.COLOR
role_data.outputs.a_execution = og.AttributeRole.EXECUTION
role_data.outputs.a_frame_4 = og.AttributeRole.FRAME
role_data.outputs.a_frame_4_array = og.AttributeRole.FRAME
role_data.outputs.a_matrixd_2 = og.AttributeRole.MATRIX
role_data.outputs.a_matrixd_2_array = og.AttributeRole.MATRIX
role_data.outputs.a_matrixd_3 = og.AttributeRole.MATRIX
role_data.outputs.a_matrixd_3_array = og.AttributeRole.MATRIX
role_data.outputs.a_matrixd_4 = og.AttributeRole.MATRIX
role_data.outputs.a_matrixd_4_array = og.AttributeRole.MATRIX
role_data.outputs.a_normald_3 = og.AttributeRole.NORMAL
role_data.outputs.a_normald_3_array = og.AttributeRole.NORMAL
role_data.outputs.a_normalf_3 = og.AttributeRole.NORMAL
role_data.outputs.a_normalf_3_array = og.AttributeRole.NORMAL
role_data.outputs.a_normalh_3 = og.AttributeRole.NORMAL
role_data.outputs.a_normalh_3_array = og.AttributeRole.NORMAL
role_data.outputs.a_objectId = og.AttributeRole.OBJECT_ID
role_data.outputs.a_objectId_array = og.AttributeRole.OBJECT_ID
role_data.outputs.a_path = og.AttributeRole.PATH
role_data.outputs.a_pointd_3 = og.AttributeRole.POSITION
role_data.outputs.a_pointd_3_array = og.AttributeRole.POSITION
role_data.outputs.a_pointf_3 = og.AttributeRole.POSITION
role_data.outputs.a_pointf_3_array = og.AttributeRole.POSITION
role_data.outputs.a_pointh_3 = og.AttributeRole.POSITION
role_data.outputs.a_pointh_3_array = og.AttributeRole.POSITION
role_data.outputs.a_quatd_4 = og.AttributeRole.QUATERNION
role_data.outputs.a_quatd_4_array = og.AttributeRole.QUATERNION
role_data.outputs.a_quatf_4 = og.AttributeRole.QUATERNION
role_data.outputs.a_quatf_4_array = og.AttributeRole.QUATERNION
role_data.outputs.a_quath_4 = og.AttributeRole.QUATERNION
role_data.outputs.a_quath_4_array = og.AttributeRole.QUATERNION
role_data.outputs.a_string = og.AttributeRole.TEXT
role_data.outputs.a_target = og.AttributeRole.TARGET
role_data.outputs.a_texcoordd_2 = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordd_2_array = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordd_3 = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordd_3_array = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordf_2 = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordf_2_array = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordf_3 = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordf_3_array = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordh_2 = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordh_2_array = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordh_3 = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordh_3_array = og.AttributeRole.TEXCOORD
role_data.outputs.a_timecode = og.AttributeRole.TIMECODE
role_data.outputs.a_timecode_array = og.AttributeRole.TIMECODE
role_data.outputs.a_vectord_3 = og.AttributeRole.VECTOR
role_data.outputs.a_vectord_3_array = og.AttributeRole.VECTOR
role_data.outputs.a_vectorf_3 = og.AttributeRole.VECTOR
role_data.outputs.a_vectorf_3_array = og.AttributeRole.VECTOR
role_data.outputs.a_vectorh_3 = og.AttributeRole.VECTOR
role_data.outputs.a_vectorh_3_array = og.AttributeRole.VECTOR
role_data.state.a_bundle = og.AttributeRole.BUNDLE
role_data.state.a_colord_3 = og.AttributeRole.COLOR
role_data.state.a_colord_3_array = og.AttributeRole.COLOR
role_data.state.a_colord_4 = og.AttributeRole.COLOR
role_data.state.a_colord_4_array = og.AttributeRole.COLOR
role_data.state.a_colorf_3 = og.AttributeRole.COLOR
role_data.state.a_colorf_3_array = og.AttributeRole.COLOR
role_data.state.a_colorf_4 = og.AttributeRole.COLOR
role_data.state.a_colorf_4_array = og.AttributeRole.COLOR
role_data.state.a_colorh_3 = og.AttributeRole.COLOR
role_data.state.a_colorh_3_array = og.AttributeRole.COLOR
role_data.state.a_colorh_4 = og.AttributeRole.COLOR
role_data.state.a_colorh_4_array = og.AttributeRole.COLOR
role_data.state.a_execution = og.AttributeRole.EXECUTION
role_data.state.a_frame_4 = og.AttributeRole.FRAME
role_data.state.a_frame_4_array = og.AttributeRole.FRAME
role_data.state.a_matrixd_2 = og.AttributeRole.MATRIX
role_data.state.a_matrixd_2_array = og.AttributeRole.MATRIX
role_data.state.a_matrixd_3 = og.AttributeRole.MATRIX
role_data.state.a_matrixd_3_array = og.AttributeRole.MATRIX
role_data.state.a_matrixd_4 = og.AttributeRole.MATRIX
role_data.state.a_matrixd_4_array = og.AttributeRole.MATRIX
role_data.state.a_normald_3 = og.AttributeRole.NORMAL
role_data.state.a_normald_3_array = og.AttributeRole.NORMAL
role_data.state.a_normalf_3 = og.AttributeRole.NORMAL
role_data.state.a_normalf_3_array = og.AttributeRole.NORMAL
role_data.state.a_normalh_3 = og.AttributeRole.NORMAL
role_data.state.a_normalh_3_array = og.AttributeRole.NORMAL
role_data.state.a_objectId = og.AttributeRole.OBJECT_ID
role_data.state.a_objectId_array = og.AttributeRole.OBJECT_ID
role_data.state.a_path = og.AttributeRole.PATH
role_data.state.a_pointd_3 = og.AttributeRole.POSITION
role_data.state.a_pointd_3_array = og.AttributeRole.POSITION
role_data.state.a_pointf_3 = og.AttributeRole.POSITION
role_data.state.a_pointf_3_array = og.AttributeRole.POSITION
role_data.state.a_pointh_3 = og.AttributeRole.POSITION
role_data.state.a_pointh_3_array = og.AttributeRole.POSITION
role_data.state.a_quatd_4 = og.AttributeRole.QUATERNION
role_data.state.a_quatd_4_array = og.AttributeRole.QUATERNION
role_data.state.a_quatf_4 = og.AttributeRole.QUATERNION
role_data.state.a_quatf_4_array = og.AttributeRole.QUATERNION
role_data.state.a_quath_4 = og.AttributeRole.QUATERNION
role_data.state.a_quath_4_array = og.AttributeRole.QUATERNION
role_data.state.a_string = og.AttributeRole.TEXT
role_data.state.a_stringEmpty = og.AttributeRole.TEXT
role_data.state.a_target = og.AttributeRole.TARGET
role_data.state.a_texcoordd_2 = og.AttributeRole.TEXCOORD
role_data.state.a_texcoordd_2_array = og.AttributeRole.TEXCOORD
role_data.state.a_texcoordd_3 = og.AttributeRole.TEXCOORD
role_data.state.a_texcoordd_3_array = og.AttributeRole.TEXCOORD
role_data.state.a_texcoordf_2 = og.AttributeRole.TEXCOORD
role_data.state.a_texcoordf_2_array = og.AttributeRole.TEXCOORD
role_data.state.a_texcoordf_3 = og.AttributeRole.TEXCOORD
role_data.state.a_texcoordf_3_array = og.AttributeRole.TEXCOORD
role_data.state.a_texcoordh_2 = og.AttributeRole.TEXCOORD
role_data.state.a_texcoordh_2_array = og.AttributeRole.TEXCOORD
role_data.state.a_texcoordh_3 = og.AttributeRole.TEXCOORD
role_data.state.a_texcoordh_3_array = og.AttributeRole.TEXCOORD
role_data.state.a_timecode = og.AttributeRole.TIMECODE
role_data.state.a_timecode_array = og.AttributeRole.TIMECODE
role_data.state.a_vectord_3 = og.AttributeRole.VECTOR
role_data.state.a_vectord_3_array = og.AttributeRole.VECTOR
role_data.state.a_vectorf_3 = og.AttributeRole.VECTOR
role_data.state.a_vectorf_3_array = og.AttributeRole.VECTOR
role_data.state.a_vectorh_3 = og.AttributeRole.VECTOR
role_data.state.a_vectorh_3_array = 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.__bundles = og.BundleContainer(context, node, attributes, [], read_only=True, gpu_ptr_kinds={})
self._batchedReadAttributes = []
self._batchedReadValues = []
@property
def a_bool(self):
data_view = og.AttributeValueHelper(self._attributes.a_bool)
return data_view.get()
@a_bool.setter
def a_bool(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_bool)
data_view = og.AttributeValueHelper(self._attributes.a_bool)
data_view.set(value)
@property
def a_bool_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_bool_array)
return data_view.get()
@a_bool_array.setter
def a_bool_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_bool_array)
data_view = og.AttributeValueHelper(self._attributes.a_bool_array)
data_view.set(value)
self.a_bool_array_size = data_view.get_array_size()
@property
def a_bundle(self) -> og.BundleContents:
"""Get the bundle wrapper class for the attribute inputs.a_bundle"""
return self.__bundles.a_bundle
@property
def a_colord_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord_3)
return data_view.get()
@a_colord_3.setter
def a_colord_3(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colord_3)
data_view = og.AttributeValueHelper(self._attributes.a_colord_3)
data_view.set(value)
@property
def a_colord_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord_3_array)
return data_view.get()
@a_colord_3_array.setter
def a_colord_3_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colord_3_array)
data_view = og.AttributeValueHelper(self._attributes.a_colord_3_array)
data_view.set(value)
self.a_colord_3_array_size = data_view.get_array_size()
@property
def a_colord_4(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord_4)
return data_view.get()
@a_colord_4.setter
def a_colord_4(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colord_4)
data_view = og.AttributeValueHelper(self._attributes.a_colord_4)
data_view.set(value)
@property
def a_colord_4_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord_4_array)
return data_view.get()
@a_colord_4_array.setter
def a_colord_4_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colord_4_array)
data_view = og.AttributeValueHelper(self._attributes.a_colord_4_array)
data_view.set(value)
self.a_colord_4_array_size = data_view.get_array_size()
@property
def a_colorf_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf_3)
return data_view.get()
@a_colorf_3.setter
def a_colorf_3(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colorf_3)
data_view = og.AttributeValueHelper(self._attributes.a_colorf_3)
data_view.set(value)
@property
def a_colorf_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf_3_array)
return data_view.get()
@a_colorf_3_array.setter
def a_colorf_3_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colorf_3_array)
data_view = og.AttributeValueHelper(self._attributes.a_colorf_3_array)
data_view.set(value)
self.a_colorf_3_array_size = data_view.get_array_size()
@property
def a_colorf_4(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf_4)
return data_view.get()
@a_colorf_4.setter
def a_colorf_4(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colorf_4)
data_view = og.AttributeValueHelper(self._attributes.a_colorf_4)
data_view.set(value)
@property
def a_colorf_4_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf_4_array)
return data_view.get()
@a_colorf_4_array.setter
def a_colorf_4_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colorf_4_array)
data_view = og.AttributeValueHelper(self._attributes.a_colorf_4_array)
data_view.set(value)
self.a_colorf_4_array_size = data_view.get_array_size()
@property
def a_colorh_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh_3)
return data_view.get()
@a_colorh_3.setter
def a_colorh_3(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colorh_3)
data_view = og.AttributeValueHelper(self._attributes.a_colorh_3)
data_view.set(value)
@property
def a_colorh_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh_3_array)
return data_view.get()
@a_colorh_3_array.setter
def a_colorh_3_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colorh_3_array)
data_view = og.AttributeValueHelper(self._attributes.a_colorh_3_array)
data_view.set(value)
self.a_colorh_3_array_size = data_view.get_array_size()
@property
def a_colorh_4(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh_4)
return data_view.get()
@a_colorh_4.setter
def a_colorh_4(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colorh_4)
data_view = og.AttributeValueHelper(self._attributes.a_colorh_4)
data_view.set(value)
@property
def a_colorh_4_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh_4_array)
return data_view.get()
@a_colorh_4_array.setter
def a_colorh_4_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colorh_4_array)
data_view = og.AttributeValueHelper(self._attributes.a_colorh_4_array)
data_view.set(value)
self.a_colorh_4_array_size = data_view.get_array_size()
@property
def a_double(self):
data_view = og.AttributeValueHelper(self._attributes.a_double)
return data_view.get()
@a_double.setter
def a_double(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_double)
data_view = og.AttributeValueHelper(self._attributes.a_double)
data_view.set(value)
@property
def a_double_2(self):
data_view = og.AttributeValueHelper(self._attributes.a_double_2)
return data_view.get()
@a_double_2.setter
def a_double_2(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_double_2)
data_view = og.AttributeValueHelper(self._attributes.a_double_2)
data_view.set(value)
@property
def a_double_2_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_double_2_array)
return data_view.get()
@a_double_2_array.setter
def a_double_2_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_double_2_array)
data_view = og.AttributeValueHelper(self._attributes.a_double_2_array)
data_view.set(value)
self.a_double_2_array_size = data_view.get_array_size()
@property
def a_double_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_double_3)
return data_view.get()
@a_double_3.setter
def a_double_3(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_double_3)
data_view = og.AttributeValueHelper(self._attributes.a_double_3)
data_view.set(value)
@property
def a_double_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_double_3_array)
return data_view.get()
@a_double_3_array.setter
def a_double_3_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_double_3_array)
data_view = og.AttributeValueHelper(self._attributes.a_double_3_array)
data_view.set(value)
self.a_double_3_array_size = data_view.get_array_size()
@property
def a_double_4(self):
data_view = og.AttributeValueHelper(self._attributes.a_double_4)
return data_view.get()
@a_double_4.setter
def a_double_4(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_double_4)
data_view = og.AttributeValueHelper(self._attributes.a_double_4)
data_view.set(value)
@property
def a_double_4_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_double_4_array)
return data_view.get()
@a_double_4_array.setter
def a_double_4_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_double_4_array)
data_view = og.AttributeValueHelper(self._attributes.a_double_4_array)
data_view.set(value)
self.a_double_4_array_size = data_view.get_array_size()
@property
def a_double_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_double_array)
return data_view.get()
@a_double_array.setter
def a_double_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_double_array)
data_view = og.AttributeValueHelper(self._attributes.a_double_array)
data_view.set(value)
self.a_double_array_size = data_view.get_array_size()
@property
def a_execution(self):
data_view = og.AttributeValueHelper(self._attributes.a_execution)
return data_view.get()
@a_execution.setter
def a_execution(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_execution)
data_view = og.AttributeValueHelper(self._attributes.a_execution)
data_view.set(value)
@property
def a_float(self):
data_view = og.AttributeValueHelper(self._attributes.a_float)
return data_view.get()
@a_float.setter
def a_float(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_float)
data_view = og.AttributeValueHelper(self._attributes.a_float)
data_view.set(value)
@property
def a_float_2(self):
data_view = og.AttributeValueHelper(self._attributes.a_float_2)
return data_view.get()
@a_float_2.setter
def a_float_2(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_float_2)
data_view = og.AttributeValueHelper(self._attributes.a_float_2)
data_view.set(value)
@property
def a_float_2_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_float_2_array)
return data_view.get()
@a_float_2_array.setter
def a_float_2_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_float_2_array)
data_view = og.AttributeValueHelper(self._attributes.a_float_2_array)
data_view.set(value)
self.a_float_2_array_size = data_view.get_array_size()
@property
def a_float_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_float_3)
return data_view.get()
@a_float_3.setter
def a_float_3(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_float_3)
data_view = og.AttributeValueHelper(self._attributes.a_float_3)
data_view.set(value)
@property
def a_float_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_float_3_array)
return data_view.get()
@a_float_3_array.setter
def a_float_3_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_float_3_array)
data_view = og.AttributeValueHelper(self._attributes.a_float_3_array)
data_view.set(value)
self.a_float_3_array_size = data_view.get_array_size()
@property
def a_float_4(self):
data_view = og.AttributeValueHelper(self._attributes.a_float_4)
return data_view.get()
@a_float_4.setter
def a_float_4(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_float_4)
data_view = og.AttributeValueHelper(self._attributes.a_float_4)
data_view.set(value)
@property
def a_float_4_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_float_4_array)
return data_view.get()
@a_float_4_array.setter
def a_float_4_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_float_4_array)
data_view = og.AttributeValueHelper(self._attributes.a_float_4_array)
data_view.set(value)
self.a_float_4_array_size = data_view.get_array_size()
@property
def a_float_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_float_array)
return data_view.get()
@a_float_array.setter
def a_float_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_float_array)
data_view = og.AttributeValueHelper(self._attributes.a_float_array)
data_view.set(value)
self.a_float_array_size = data_view.get_array_size()
@property
def a_frame_4(self):
data_view = og.AttributeValueHelper(self._attributes.a_frame_4)
return data_view.get()
@a_frame_4.setter
def a_frame_4(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_frame_4)
data_view = og.AttributeValueHelper(self._attributes.a_frame_4)
data_view.set(value)
@property
def a_frame_4_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_frame_4_array)
return data_view.get()
@a_frame_4_array.setter
def a_frame_4_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_frame_4_array)
data_view = og.AttributeValueHelper(self._attributes.a_frame_4_array)
data_view.set(value)
self.a_frame_4_array_size = data_view.get_array_size()
@property
def a_half(self):
data_view = og.AttributeValueHelper(self._attributes.a_half)
return data_view.get()
@a_half.setter
def a_half(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_half)
data_view = og.AttributeValueHelper(self._attributes.a_half)
data_view.set(value)
@property
def a_half_2(self):
data_view = og.AttributeValueHelper(self._attributes.a_half_2)
return data_view.get()
@a_half_2.setter
def a_half_2(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_half_2)
data_view = og.AttributeValueHelper(self._attributes.a_half_2)
data_view.set(value)
@property
def a_half_2_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_half_2_array)
return data_view.get()
@a_half_2_array.setter
def a_half_2_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_half_2_array)
data_view = og.AttributeValueHelper(self._attributes.a_half_2_array)
data_view.set(value)
self.a_half_2_array_size = data_view.get_array_size()
@property
def a_half_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_half_3)
return data_view.get()
@a_half_3.setter
def a_half_3(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_half_3)
data_view = og.AttributeValueHelper(self._attributes.a_half_3)
data_view.set(value)
@property
def a_half_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_half_3_array)
return data_view.get()
@a_half_3_array.setter
def a_half_3_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_half_3_array)
data_view = og.AttributeValueHelper(self._attributes.a_half_3_array)
data_view.set(value)
self.a_half_3_array_size = data_view.get_array_size()
@property
def a_half_4(self):
data_view = og.AttributeValueHelper(self._attributes.a_half_4)
return data_view.get()
@a_half_4.setter
def a_half_4(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_half_4)
data_view = og.AttributeValueHelper(self._attributes.a_half_4)
data_view.set(value)
@property
def a_half_4_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_half_4_array)
return data_view.get()
@a_half_4_array.setter
def a_half_4_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_half_4_array)
data_view = og.AttributeValueHelper(self._attributes.a_half_4_array)
data_view.set(value)
self.a_half_4_array_size = data_view.get_array_size()
@property
def a_half_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_half_array)
return data_view.get()
@a_half_array.setter
def a_half_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_half_array)
data_view = og.AttributeValueHelper(self._attributes.a_half_array)
data_view.set(value)
self.a_half_array_size = data_view.get_array_size()
@property
def a_int(self):
data_view = og.AttributeValueHelper(self._attributes.a_int)
return data_view.get()
@a_int.setter
def a_int(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_int)
data_view = og.AttributeValueHelper(self._attributes.a_int)
data_view.set(value)
@property
def a_int64(self):
data_view = og.AttributeValueHelper(self._attributes.a_int64)
return data_view.get()
@a_int64.setter
def a_int64(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_int64)
data_view = og.AttributeValueHelper(self._attributes.a_int64)
data_view.set(value)
@property
def a_int64_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_int64_array)
return data_view.get()
@a_int64_array.setter
def a_int64_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_int64_array)
data_view = og.AttributeValueHelper(self._attributes.a_int64_array)
data_view.set(value)
self.a_int64_array_size = data_view.get_array_size()
@property
def a_int_2(self):
data_view = og.AttributeValueHelper(self._attributes.a_int_2)
return data_view.get()
@a_int_2.setter
def a_int_2(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_int_2)
data_view = og.AttributeValueHelper(self._attributes.a_int_2)
data_view.set(value)
@property
def a_int_2_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_int_2_array)
return data_view.get()
@a_int_2_array.setter
def a_int_2_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_int_2_array)
data_view = og.AttributeValueHelper(self._attributes.a_int_2_array)
data_view.set(value)
self.a_int_2_array_size = data_view.get_array_size()
@property
def a_int_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_int_3)
return data_view.get()
@a_int_3.setter
def a_int_3(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_int_3)
data_view = og.AttributeValueHelper(self._attributes.a_int_3)
data_view.set(value)
@property
def a_int_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_int_3_array)
return data_view.get()
@a_int_3_array.setter
def a_int_3_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_int_3_array)
data_view = og.AttributeValueHelper(self._attributes.a_int_3_array)
data_view.set(value)
self.a_int_3_array_size = data_view.get_array_size()
@property
def a_int_4(self):
data_view = og.AttributeValueHelper(self._attributes.a_int_4)
return data_view.get()
@a_int_4.setter
def a_int_4(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_int_4)
data_view = og.AttributeValueHelper(self._attributes.a_int_4)
data_view.set(value)
@property
def a_int_4_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_int_4_array)
return data_view.get()
@a_int_4_array.setter
def a_int_4_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_int_4_array)
data_view = og.AttributeValueHelper(self._attributes.a_int_4_array)
data_view.set(value)
self.a_int_4_array_size = data_view.get_array_size()
@property
def a_int_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_int_array)
return data_view.get()
@a_int_array.setter
def a_int_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_int_array)
data_view = og.AttributeValueHelper(self._attributes.a_int_array)
data_view.set(value)
self.a_int_array_size = data_view.get_array_size()
@property
def a_matrixd_2(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd_2)
return data_view.get()
@a_matrixd_2.setter
def a_matrixd_2(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_matrixd_2)
data_view = og.AttributeValueHelper(self._attributes.a_matrixd_2)
data_view.set(value)
@property
def a_matrixd_2_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd_2_array)
return data_view.get()
@a_matrixd_2_array.setter
def a_matrixd_2_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_matrixd_2_array)
data_view = og.AttributeValueHelper(self._attributes.a_matrixd_2_array)
data_view.set(value)
self.a_matrixd_2_array_size = data_view.get_array_size()
@property
def a_matrixd_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd_3)
return data_view.get()
@a_matrixd_3.setter
def a_matrixd_3(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_matrixd_3)
data_view = og.AttributeValueHelper(self._attributes.a_matrixd_3)
data_view.set(value)
@property
def a_matrixd_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd_3_array)
return data_view.get()
@a_matrixd_3_array.setter
def a_matrixd_3_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_matrixd_3_array)
data_view = og.AttributeValueHelper(self._attributes.a_matrixd_3_array)
data_view.set(value)
self.a_matrixd_3_array_size = data_view.get_array_size()
@property
def a_matrixd_4(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd_4)
return data_view.get()
@a_matrixd_4.setter
def a_matrixd_4(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_matrixd_4)
data_view = og.AttributeValueHelper(self._attributes.a_matrixd_4)
data_view.set(value)
@property
def a_matrixd_4_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd_4_array)
return data_view.get()
@a_matrixd_4_array.setter
def a_matrixd_4_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_matrixd_4_array)
data_view = og.AttributeValueHelper(self._attributes.a_matrixd_4_array)
data_view.set(value)
self.a_matrixd_4_array_size = data_view.get_array_size()
@property
def a_normald_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_normald_3)
return data_view.get()
@a_normald_3.setter
def a_normald_3(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_normald_3)
data_view = og.AttributeValueHelper(self._attributes.a_normald_3)
data_view.set(value)
@property
def a_normald_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_normald_3_array)
return data_view.get()
@a_normald_3_array.setter
def a_normald_3_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_normald_3_array)
data_view = og.AttributeValueHelper(self._attributes.a_normald_3_array)
data_view.set(value)
self.a_normald_3_array_size = data_view.get_array_size()
@property
def a_normalf_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalf_3)
return data_view.get()
@a_normalf_3.setter
def a_normalf_3(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_normalf_3)
data_view = og.AttributeValueHelper(self._attributes.a_normalf_3)
data_view.set(value)
@property
def a_normalf_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalf_3_array)
return data_view.get()
@a_normalf_3_array.setter
def a_normalf_3_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_normalf_3_array)
data_view = og.AttributeValueHelper(self._attributes.a_normalf_3_array)
data_view.set(value)
self.a_normalf_3_array_size = data_view.get_array_size()
@property
def a_normalh_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalh_3)
return data_view.get()
@a_normalh_3.setter
def a_normalh_3(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_normalh_3)
data_view = og.AttributeValueHelper(self._attributes.a_normalh_3)
data_view.set(value)
@property
def a_normalh_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalh_3_array)
return data_view.get()
@a_normalh_3_array.setter
def a_normalh_3_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_normalh_3_array)
data_view = og.AttributeValueHelper(self._attributes.a_normalh_3_array)
data_view.set(value)
self.a_normalh_3_array_size = data_view.get_array_size()
@property
def a_objectId(self):
data_view = og.AttributeValueHelper(self._attributes.a_objectId)
return data_view.get()
@a_objectId.setter
def a_objectId(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_objectId)
data_view = og.AttributeValueHelper(self._attributes.a_objectId)
data_view.set(value)
@property
def a_objectId_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_objectId_array)
return data_view.get()
@a_objectId_array.setter
def a_objectId_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_objectId_array)
data_view = og.AttributeValueHelper(self._attributes.a_objectId_array)
data_view.set(value)
self.a_objectId_array_size = data_view.get_array_size()
@property
def a_path(self):
data_view = og.AttributeValueHelper(self._attributes.a_path)
return data_view.get()
@a_path.setter
def a_path(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_path)
data_view = og.AttributeValueHelper(self._attributes.a_path)
data_view.set(value)
self.a_path_size = data_view.get_array_size()
@property
def a_pointd_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointd_3)
return data_view.get()
@a_pointd_3.setter
def a_pointd_3(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_pointd_3)
data_view = og.AttributeValueHelper(self._attributes.a_pointd_3)
data_view.set(value)
@property
def a_pointd_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointd_3_array)
return data_view.get()
@a_pointd_3_array.setter
def a_pointd_3_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_pointd_3_array)
data_view = og.AttributeValueHelper(self._attributes.a_pointd_3_array)
data_view.set(value)
self.a_pointd_3_array_size = data_view.get_array_size()
@property
def a_pointf_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointf_3)
return data_view.get()
@a_pointf_3.setter
def a_pointf_3(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_pointf_3)
data_view = og.AttributeValueHelper(self._attributes.a_pointf_3)
data_view.set(value)
@property
def a_pointf_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointf_3_array)
return data_view.get()
@a_pointf_3_array.setter
def a_pointf_3_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_pointf_3_array)
data_view = og.AttributeValueHelper(self._attributes.a_pointf_3_array)
data_view.set(value)
self.a_pointf_3_array_size = data_view.get_array_size()
@property
def a_pointh_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointh_3)
return data_view.get()
@a_pointh_3.setter
def a_pointh_3(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_pointh_3)
data_view = og.AttributeValueHelper(self._attributes.a_pointh_3)
data_view.set(value)
@property
def a_pointh_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointh_3_array)
return data_view.get()
@a_pointh_3_array.setter
def a_pointh_3_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_pointh_3_array)
data_view = og.AttributeValueHelper(self._attributes.a_pointh_3_array)
data_view.set(value)
self.a_pointh_3_array_size = data_view.get_array_size()
@property
def a_quatd_4(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatd_4)
return data_view.get()
@a_quatd_4.setter
def a_quatd_4(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_quatd_4)
data_view = og.AttributeValueHelper(self._attributes.a_quatd_4)
data_view.set(value)
@property
def a_quatd_4_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatd_4_array)
return data_view.get()
@a_quatd_4_array.setter
def a_quatd_4_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_quatd_4_array)
data_view = og.AttributeValueHelper(self._attributes.a_quatd_4_array)
data_view.set(value)
self.a_quatd_4_array_size = data_view.get_array_size()
@property
def a_quatf_4(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatf_4)
return data_view.get()
@a_quatf_4.setter
def a_quatf_4(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_quatf_4)
data_view = og.AttributeValueHelper(self._attributes.a_quatf_4)
data_view.set(value)
@property
def a_quatf_4_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatf_4_array)
return data_view.get()
@a_quatf_4_array.setter
def a_quatf_4_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_quatf_4_array)
data_view = og.AttributeValueHelper(self._attributes.a_quatf_4_array)
data_view.set(value)
self.a_quatf_4_array_size = data_view.get_array_size()
@property
def a_quath_4(self):
data_view = og.AttributeValueHelper(self._attributes.a_quath_4)
return data_view.get()
@a_quath_4.setter
def a_quath_4(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_quath_4)
data_view = og.AttributeValueHelper(self._attributes.a_quath_4)
data_view.set(value)
@property
def a_quath_4_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_quath_4_array)
return data_view.get()
@a_quath_4_array.setter
def a_quath_4_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_quath_4_array)
data_view = og.AttributeValueHelper(self._attributes.a_quath_4_array)
data_view.set(value)
self.a_quath_4_array_size = data_view.get_array_size()
@property
def a_string(self):
data_view = og.AttributeValueHelper(self._attributes.a_string)
return data_view.get()
@a_string.setter
def a_string(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_string)
data_view = og.AttributeValueHelper(self._attributes.a_string)
data_view.set(value)
self.a_string_size = data_view.get_array_size()
@property
def a_target(self):
data_view = og.AttributeValueHelper(self._attributes.a_target)
return data_view.get()
@a_target.setter
def a_target(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_target)
data_view = og.AttributeValueHelper(self._attributes.a_target)
data_view.set(value)
self.a_target_size = data_view.get_array_size()
@property
def a_texcoordd_2(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd_2)
return data_view.get()
@a_texcoordd_2.setter
def a_texcoordd_2(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordd_2)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd_2)
data_view.set(value)
@property
def a_texcoordd_2_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd_2_array)
return data_view.get()
@a_texcoordd_2_array.setter
def a_texcoordd_2_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordd_2_array)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd_2_array)
data_view.set(value)
self.a_texcoordd_2_array_size = data_view.get_array_size()
@property
def a_texcoordd_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd_3)
return data_view.get()
@a_texcoordd_3.setter
def a_texcoordd_3(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordd_3)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd_3)
data_view.set(value)
@property
def a_texcoordd_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd_3_array)
return data_view.get()
@a_texcoordd_3_array.setter
def a_texcoordd_3_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordd_3_array)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd_3_array)
data_view.set(value)
self.a_texcoordd_3_array_size = data_view.get_array_size()
@property
def a_texcoordf_2(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf_2)
return data_view.get()
@a_texcoordf_2.setter
def a_texcoordf_2(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordf_2)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf_2)
data_view.set(value)
@property
def a_texcoordf_2_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf_2_array)
return data_view.get()
@a_texcoordf_2_array.setter
def a_texcoordf_2_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordf_2_array)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf_2_array)
data_view.set(value)
self.a_texcoordf_2_array_size = data_view.get_array_size()
@property
def a_texcoordf_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf_3)
return data_view.get()
@a_texcoordf_3.setter
def a_texcoordf_3(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordf_3)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf_3)
data_view.set(value)
@property
def a_texcoordf_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf_3_array)
return data_view.get()
@a_texcoordf_3_array.setter
def a_texcoordf_3_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordf_3_array)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf_3_array)
data_view.set(value)
self.a_texcoordf_3_array_size = data_view.get_array_size()
@property
def a_texcoordh_2(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh_2)
return data_view.get()
@a_texcoordh_2.setter
def a_texcoordh_2(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordh_2)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh_2)
data_view.set(value)
@property
def a_texcoordh_2_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh_2_array)
return data_view.get()
@a_texcoordh_2_array.setter
def a_texcoordh_2_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordh_2_array)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh_2_array)
data_view.set(value)
self.a_texcoordh_2_array_size = data_view.get_array_size()
@property
def a_texcoordh_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh_3)
return data_view.get()
@a_texcoordh_3.setter
def a_texcoordh_3(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordh_3)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh_3)
data_view.set(value)
@property
def a_texcoordh_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh_3_array)
return data_view.get()
@a_texcoordh_3_array.setter
def a_texcoordh_3_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordh_3_array)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh_3_array)
data_view.set(value)
self.a_texcoordh_3_array_size = data_view.get_array_size()
@property
def a_timecode(self):
data_view = og.AttributeValueHelper(self._attributes.a_timecode)
return data_view.get()
@a_timecode.setter
def a_timecode(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_timecode)
data_view = og.AttributeValueHelper(self._attributes.a_timecode)
data_view.set(value)
@property
def a_timecode_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_timecode_array)
return data_view.get()
@a_timecode_array.setter
def a_timecode_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_timecode_array)
data_view = og.AttributeValueHelper(self._attributes.a_timecode_array)
data_view.set(value)
self.a_timecode_array_size = data_view.get_array_size()
@property
def a_token(self):
data_view = og.AttributeValueHelper(self._attributes.a_token)
return data_view.get()
@a_token.setter
def a_token(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_token)
data_view = og.AttributeValueHelper(self._attributes.a_token)
data_view.set(value)
@property
def a_token_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_token_array)
return data_view.get()
@a_token_array.setter
def a_token_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_token_array)
data_view = og.AttributeValueHelper(self._attributes.a_token_array)
data_view.set(value)
self.a_token_array_size = data_view.get_array_size()
@property
def a_uchar(self):
data_view = og.AttributeValueHelper(self._attributes.a_uchar)
return data_view.get()
@a_uchar.setter
def a_uchar(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_uchar)
data_view = og.AttributeValueHelper(self._attributes.a_uchar)
data_view.set(value)
@property
def a_uchar_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_uchar_array)
return data_view.get()
@a_uchar_array.setter
def a_uchar_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_uchar_array)
data_view = og.AttributeValueHelper(self._attributes.a_uchar_array)
data_view.set(value)
self.a_uchar_array_size = data_view.get_array_size()
@property
def a_uint(self):
data_view = og.AttributeValueHelper(self._attributes.a_uint)
return data_view.get()
@a_uint.setter
def a_uint(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_uint)
data_view = og.AttributeValueHelper(self._attributes.a_uint)
data_view.set(value)
@property
def a_uint64(self):
data_view = og.AttributeValueHelper(self._attributes.a_uint64)
return data_view.get()
@a_uint64.setter
def a_uint64(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_uint64)
data_view = og.AttributeValueHelper(self._attributes.a_uint64)
data_view.set(value)
@property
def a_uint64_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_uint64_array)
return data_view.get()
@a_uint64_array.setter
def a_uint64_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_uint64_array)
data_view = og.AttributeValueHelper(self._attributes.a_uint64_array)
data_view.set(value)
self.a_uint64_array_size = data_view.get_array_size()
@property
def a_uint_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_uint_array)
return data_view.get()
@a_uint_array.setter
def a_uint_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_uint_array)
data_view = og.AttributeValueHelper(self._attributes.a_uint_array)
data_view.set(value)
self.a_uint_array_size = data_view.get_array_size()
@property
def a_vectord_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectord_3)
return data_view.get()
@a_vectord_3.setter
def a_vectord_3(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_vectord_3)
data_view = og.AttributeValueHelper(self._attributes.a_vectord_3)
data_view.set(value)
@property
def a_vectord_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectord_3_array)
return data_view.get()
@a_vectord_3_array.setter
def a_vectord_3_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_vectord_3_array)
data_view = og.AttributeValueHelper(self._attributes.a_vectord_3_array)
data_view.set(value)
self.a_vectord_3_array_size = data_view.get_array_size()
@property
def a_vectorf_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorf_3)
return data_view.get()
@a_vectorf_3.setter
def a_vectorf_3(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_vectorf_3)
data_view = og.AttributeValueHelper(self._attributes.a_vectorf_3)
data_view.set(value)
@property
def a_vectorf_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorf_3_array)
return data_view.get()
@a_vectorf_3_array.setter
def a_vectorf_3_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_vectorf_3_array)
data_view = og.AttributeValueHelper(self._attributes.a_vectorf_3_array)
data_view.set(value)
self.a_vectorf_3_array_size = data_view.get_array_size()
@property
def a_vectorh_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorh_3)
return data_view.get()
@a_vectorh_3.setter
def a_vectorh_3(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_vectorh_3)
data_view = og.AttributeValueHelper(self._attributes.a_vectorh_3)
data_view.set(value)
@property
def a_vectorh_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorh_3_array)
return data_view.get()
@a_vectorh_3_array.setter
def a_vectorh_3_array(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_vectorh_3_array)
data_view = og.AttributeValueHelper(self._attributes.a_vectorh_3_array)
data_view.set(value)
self.a_vectorh_3_array_size = data_view.get_array_size()
@property
def doNotCompute(self):
data_view = og.AttributeValueHelper(self._attributes.doNotCompute)
return data_view.get()
@doNotCompute.setter
def doNotCompute(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.doNotCompute)
data_view = og.AttributeValueHelper(self._attributes.doNotCompute)
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.a_bool_array_size = 2
self.a_colord_3_array_size = 2
self.a_colord_4_array_size = 2
self.a_colorf_3_array_size = 2
self.a_colorf_4_array_size = 2
self.a_colorh_3_array_size = 2
self.a_colorh_4_array_size = 2
self.a_double_2_array_size = 2
self.a_double_3_array_size = 2
self.a_double_4_array_size = 2
self.a_double_array_size = 2
self.a_float_2_array_size = 2
self.a_float_3_array_size = 2
self.a_float_4_array_size = 2
self.a_float_array_size = 2
self.a_frame_4_array_size = 2
self.a_half_2_array_size = 2
self.a_half_3_array_size = 2
self.a_half_4_array_size = 2
self.a_half_array_size = 2
self.a_int64_array_size = 2
self.a_int_2_array_size = 2
self.a_int_3_array_size = 2
self.a_int_4_array_size = 2
self.a_int_array_size = 2
self.a_matrixd_2_array_size = 2
self.a_matrixd_3_array_size = 2
self.a_matrixd_4_array_size = 2
self.a_normald_3_array_size = 2
self.a_normalf_3_array_size = 2
self.a_normalh_3_array_size = 2
self.a_objectId_array_size = 2
self.a_path_size = 7
self.a_pointd_3_array_size = 2
self.a_pointf_3_array_size = 2
self.a_pointh_3_array_size = 2
self.a_quatd_4_array_size = 2
self.a_quatf_4_array_size = 2
self.a_quath_4_array_size = 2
self.a_string_size = 20
self.a_target_size = None
self.a_texcoordd_2_array_size = 2
self.a_texcoordd_3_array_size = 2
self.a_texcoordf_2_array_size = 2
self.a_texcoordf_3_array_size = 2
self.a_texcoordh_2_array_size = 2
self.a_texcoordh_3_array_size = 2
self.a_timecode_array_size = 2
self.a_token_array_size = 2
self.a_uchar_array_size = 2
self.a_uint64_array_size = 2
self.a_uint_array_size = 2
self.a_vectord_3_array_size = 2
self.a_vectorf_3_array_size = 2
self.a_vectorh_3_array_size = 2
self._batchedWriteValues = { }
@property
def a_bool(self):
data_view = og.AttributeValueHelper(self._attributes.a_bool)
return data_view.get()
@a_bool.setter
def a_bool(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_bool)
data_view.set(value)
@property
def a_bool_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_bool_array)
return data_view.get(reserved_element_count=self.a_bool_array_size)
@a_bool_array.setter
def a_bool_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_bool_array)
data_view.set(value)
self.a_bool_array_size = data_view.get_array_size()
@property
def a_bundle(self) -> og.BundleContents:
"""Get the bundle wrapper class for the attribute outputs.a_bundle"""
return self.__bundles.a_bundle
@a_bundle.setter
def a_bundle(self, bundle: og.BundleContents):
"""Overwrite the bundle attribute outputs.a_bundle 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.a_bundle.bundle = bundle
@property
def a_colord_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord_3)
return data_view.get()
@a_colord_3.setter
def a_colord_3(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colord_3)
data_view.set(value)
@property
def a_colord_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord_3_array)
return data_view.get(reserved_element_count=self.a_colord_3_array_size)
@a_colord_3_array.setter
def a_colord_3_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colord_3_array)
data_view.set(value)
self.a_colord_3_array_size = data_view.get_array_size()
@property
def a_colord_4(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord_4)
return data_view.get()
@a_colord_4.setter
def a_colord_4(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colord_4)
data_view.set(value)
@property
def a_colord_4_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord_4_array)
return data_view.get(reserved_element_count=self.a_colord_4_array_size)
@a_colord_4_array.setter
def a_colord_4_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colord_4_array)
data_view.set(value)
self.a_colord_4_array_size = data_view.get_array_size()
@property
def a_colorf_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf_3)
return data_view.get()
@a_colorf_3.setter
def a_colorf_3(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorf_3)
data_view.set(value)
@property
def a_colorf_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf_3_array)
return data_view.get(reserved_element_count=self.a_colorf_3_array_size)
@a_colorf_3_array.setter
def a_colorf_3_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorf_3_array)
data_view.set(value)
self.a_colorf_3_array_size = data_view.get_array_size()
@property
def a_colorf_4(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf_4)
return data_view.get()
@a_colorf_4.setter
def a_colorf_4(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorf_4)
data_view.set(value)
@property
def a_colorf_4_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf_4_array)
return data_view.get(reserved_element_count=self.a_colorf_4_array_size)
@a_colorf_4_array.setter
def a_colorf_4_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorf_4_array)
data_view.set(value)
self.a_colorf_4_array_size = data_view.get_array_size()
@property
def a_colorh_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh_3)
return data_view.get()
@a_colorh_3.setter
def a_colorh_3(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorh_3)
data_view.set(value)
@property
def a_colorh_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh_3_array)
return data_view.get(reserved_element_count=self.a_colorh_3_array_size)
@a_colorh_3_array.setter
def a_colorh_3_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorh_3_array)
data_view.set(value)
self.a_colorh_3_array_size = data_view.get_array_size()
@property
def a_colorh_4(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh_4)
return data_view.get()
@a_colorh_4.setter
def a_colorh_4(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorh_4)
data_view.set(value)
@property
def a_colorh_4_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh_4_array)
return data_view.get(reserved_element_count=self.a_colorh_4_array_size)
@a_colorh_4_array.setter
def a_colorh_4_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorh_4_array)
data_view.set(value)
self.a_colorh_4_array_size = data_view.get_array_size()
@property
def a_double(self):
data_view = og.AttributeValueHelper(self._attributes.a_double)
return data_view.get()
@a_double.setter
def a_double(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double)
data_view.set(value)
@property
def a_double_2(self):
data_view = og.AttributeValueHelper(self._attributes.a_double_2)
return data_view.get()
@a_double_2.setter
def a_double_2(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double_2)
data_view.set(value)
@property
def a_double_2_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_double_2_array)
return data_view.get(reserved_element_count=self.a_double_2_array_size)
@a_double_2_array.setter
def a_double_2_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double_2_array)
data_view.set(value)
self.a_double_2_array_size = data_view.get_array_size()
@property
def a_double_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_double_3)
return data_view.get()
@a_double_3.setter
def a_double_3(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double_3)
data_view.set(value)
@property
def a_double_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_double_3_array)
return data_view.get(reserved_element_count=self.a_double_3_array_size)
@a_double_3_array.setter
def a_double_3_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double_3_array)
data_view.set(value)
self.a_double_3_array_size = data_view.get_array_size()
@property
def a_double_4(self):
data_view = og.AttributeValueHelper(self._attributes.a_double_4)
return data_view.get()
@a_double_4.setter
def a_double_4(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double_4)
data_view.set(value)
@property
def a_double_4_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_double_4_array)
return data_view.get(reserved_element_count=self.a_double_4_array_size)
@a_double_4_array.setter
def a_double_4_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double_4_array)
data_view.set(value)
self.a_double_4_array_size = data_view.get_array_size()
@property
def a_double_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_double_array)
return data_view.get(reserved_element_count=self.a_double_array_size)
@a_double_array.setter
def a_double_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double_array)
data_view.set(value)
self.a_double_array_size = data_view.get_array_size()
@property
def a_execution(self):
data_view = og.AttributeValueHelper(self._attributes.a_execution)
return data_view.get()
@a_execution.setter
def a_execution(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_execution)
data_view.set(value)
@property
def a_float(self):
data_view = og.AttributeValueHelper(self._attributes.a_float)
return data_view.get()
@a_float.setter
def a_float(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float)
data_view.set(value)
@property
def a_float_2(self):
data_view = og.AttributeValueHelper(self._attributes.a_float_2)
return data_view.get()
@a_float_2.setter
def a_float_2(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float_2)
data_view.set(value)
@property
def a_float_2_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_float_2_array)
return data_view.get(reserved_element_count=self.a_float_2_array_size)
@a_float_2_array.setter
def a_float_2_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float_2_array)
data_view.set(value)
self.a_float_2_array_size = data_view.get_array_size()
@property
def a_float_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_float_3)
return data_view.get()
@a_float_3.setter
def a_float_3(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float_3)
data_view.set(value)
@property
def a_float_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_float_3_array)
return data_view.get(reserved_element_count=self.a_float_3_array_size)
@a_float_3_array.setter
def a_float_3_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float_3_array)
data_view.set(value)
self.a_float_3_array_size = data_view.get_array_size()
@property
def a_float_4(self):
data_view = og.AttributeValueHelper(self._attributes.a_float_4)
return data_view.get()
@a_float_4.setter
def a_float_4(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float_4)
data_view.set(value)
@property
def a_float_4_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_float_4_array)
return data_view.get(reserved_element_count=self.a_float_4_array_size)
@a_float_4_array.setter
def a_float_4_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float_4_array)
data_view.set(value)
self.a_float_4_array_size = data_view.get_array_size()
@property
def a_float_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_float_array)
return data_view.get(reserved_element_count=self.a_float_array_size)
@a_float_array.setter
def a_float_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float_array)
data_view.set(value)
self.a_float_array_size = data_view.get_array_size()
@property
def a_frame_4(self):
data_view = og.AttributeValueHelper(self._attributes.a_frame_4)
return data_view.get()
@a_frame_4.setter
def a_frame_4(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_frame_4)
data_view.set(value)
@property
def a_frame_4_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_frame_4_array)
return data_view.get(reserved_element_count=self.a_frame_4_array_size)
@a_frame_4_array.setter
def a_frame_4_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_frame_4_array)
data_view.set(value)
self.a_frame_4_array_size = data_view.get_array_size()
@property
def a_half(self):
data_view = og.AttributeValueHelper(self._attributes.a_half)
return data_view.get()
@a_half.setter
def a_half(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half)
data_view.set(value)
@property
def a_half_2(self):
data_view = og.AttributeValueHelper(self._attributes.a_half_2)
return data_view.get()
@a_half_2.setter
def a_half_2(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half_2)
data_view.set(value)
@property
def a_half_2_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_half_2_array)
return data_view.get(reserved_element_count=self.a_half_2_array_size)
@a_half_2_array.setter
def a_half_2_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half_2_array)
data_view.set(value)
self.a_half_2_array_size = data_view.get_array_size()
@property
def a_half_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_half_3)
return data_view.get()
@a_half_3.setter
def a_half_3(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half_3)
data_view.set(value)
@property
def a_half_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_half_3_array)
return data_view.get(reserved_element_count=self.a_half_3_array_size)
@a_half_3_array.setter
def a_half_3_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half_3_array)
data_view.set(value)
self.a_half_3_array_size = data_view.get_array_size()
@property
def a_half_4(self):
data_view = og.AttributeValueHelper(self._attributes.a_half_4)
return data_view.get()
@a_half_4.setter
def a_half_4(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half_4)
data_view.set(value)
@property
def a_half_4_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_half_4_array)
return data_view.get(reserved_element_count=self.a_half_4_array_size)
@a_half_4_array.setter
def a_half_4_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half_4_array)
data_view.set(value)
self.a_half_4_array_size = data_view.get_array_size()
@property
def a_half_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_half_array)
return data_view.get(reserved_element_count=self.a_half_array_size)
@a_half_array.setter
def a_half_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half_array)
data_view.set(value)
self.a_half_array_size = data_view.get_array_size()
@property
def a_int(self):
data_view = og.AttributeValueHelper(self._attributes.a_int)
return data_view.get()
@a_int.setter
def a_int(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_int)
data_view.set(value)
@property
def a_int64(self):
data_view = og.AttributeValueHelper(self._attributes.a_int64)
return data_view.get()
@a_int64.setter
def a_int64(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_int64)
data_view.set(value)
@property
def a_int64_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_int64_array)
return data_view.get(reserved_element_count=self.a_int64_array_size)
@a_int64_array.setter
def a_int64_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_int64_array)
data_view.set(value)
self.a_int64_array_size = data_view.get_array_size()
@property
def a_int_2(self):
data_view = og.AttributeValueHelper(self._attributes.a_int_2)
return data_view.get()
@a_int_2.setter
def a_int_2(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_int_2)
data_view.set(value)
@property
def a_int_2_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_int_2_array)
return data_view.get(reserved_element_count=self.a_int_2_array_size)
@a_int_2_array.setter
def a_int_2_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_int_2_array)
data_view.set(value)
self.a_int_2_array_size = data_view.get_array_size()
@property
def a_int_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_int_3)
return data_view.get()
@a_int_3.setter
def a_int_3(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_int_3)
data_view.set(value)
@property
def a_int_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_int_3_array)
return data_view.get(reserved_element_count=self.a_int_3_array_size)
@a_int_3_array.setter
def a_int_3_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_int_3_array)
data_view.set(value)
self.a_int_3_array_size = data_view.get_array_size()
@property
def a_int_4(self):
data_view = og.AttributeValueHelper(self._attributes.a_int_4)
return data_view.get()
@a_int_4.setter
def a_int_4(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_int_4)
data_view.set(value)
@property
def a_int_4_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_int_4_array)
return data_view.get(reserved_element_count=self.a_int_4_array_size)
@a_int_4_array.setter
def a_int_4_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_int_4_array)
data_view.set(value)
self.a_int_4_array_size = data_view.get_array_size()
@property
def a_int_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_int_array)
return data_view.get(reserved_element_count=self.a_int_array_size)
@a_int_array.setter
def a_int_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_int_array)
data_view.set(value)
self.a_int_array_size = data_view.get_array_size()
@property
def a_matrixd_2(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd_2)
return data_view.get()
@a_matrixd_2.setter
def a_matrixd_2(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd_2)
data_view.set(value)
@property
def a_matrixd_2_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd_2_array)
return data_view.get(reserved_element_count=self.a_matrixd_2_array_size)
@a_matrixd_2_array.setter
def a_matrixd_2_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd_2_array)
data_view.set(value)
self.a_matrixd_2_array_size = data_view.get_array_size()
@property
def a_matrixd_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd_3)
return data_view.get()
@a_matrixd_3.setter
def a_matrixd_3(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd_3)
data_view.set(value)
@property
def a_matrixd_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd_3_array)
return data_view.get(reserved_element_count=self.a_matrixd_3_array_size)
@a_matrixd_3_array.setter
def a_matrixd_3_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd_3_array)
data_view.set(value)
self.a_matrixd_3_array_size = data_view.get_array_size()
@property
def a_matrixd_4(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd_4)
return data_view.get()
@a_matrixd_4.setter
def a_matrixd_4(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd_4)
data_view.set(value)
@property
def a_matrixd_4_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd_4_array)
return data_view.get(reserved_element_count=self.a_matrixd_4_array_size)
@a_matrixd_4_array.setter
def a_matrixd_4_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd_4_array)
data_view.set(value)
self.a_matrixd_4_array_size = data_view.get_array_size()
@property
def a_normald_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_normald_3)
return data_view.get()
@a_normald_3.setter
def a_normald_3(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_normald_3)
data_view.set(value)
@property
def a_normald_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_normald_3_array)
return data_view.get(reserved_element_count=self.a_normald_3_array_size)
@a_normald_3_array.setter
def a_normald_3_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_normald_3_array)
data_view.set(value)
self.a_normald_3_array_size = data_view.get_array_size()
@property
def a_normalf_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalf_3)
return data_view.get()
@a_normalf_3.setter
def a_normalf_3(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_normalf_3)
data_view.set(value)
@property
def a_normalf_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalf_3_array)
return data_view.get(reserved_element_count=self.a_normalf_3_array_size)
@a_normalf_3_array.setter
def a_normalf_3_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_normalf_3_array)
data_view.set(value)
self.a_normalf_3_array_size = data_view.get_array_size()
@property
def a_normalh_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalh_3)
return data_view.get()
@a_normalh_3.setter
def a_normalh_3(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_normalh_3)
data_view.set(value)
@property
def a_normalh_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalh_3_array)
return data_view.get(reserved_element_count=self.a_normalh_3_array_size)
@a_normalh_3_array.setter
def a_normalh_3_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_normalh_3_array)
data_view.set(value)
self.a_normalh_3_array_size = data_view.get_array_size()
@property
def a_objectId(self):
data_view = og.AttributeValueHelper(self._attributes.a_objectId)
return data_view.get()
@a_objectId.setter
def a_objectId(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_objectId)
data_view.set(value)
@property
def a_objectId_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_objectId_array)
return data_view.get(reserved_element_count=self.a_objectId_array_size)
@a_objectId_array.setter
def a_objectId_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_objectId_array)
data_view.set(value)
self.a_objectId_array_size = data_view.get_array_size()
@property
def a_path(self):
data_view = og.AttributeValueHelper(self._attributes.a_path)
return data_view.get(reserved_element_count=self.a_path_size)
@a_path.setter
def a_path(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_path)
data_view.set(value)
self.a_path_size = data_view.get_array_size()
@property
def a_pointd_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointd_3)
return data_view.get()
@a_pointd_3.setter
def a_pointd_3(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_pointd_3)
data_view.set(value)
@property
def a_pointd_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointd_3_array)
return data_view.get(reserved_element_count=self.a_pointd_3_array_size)
@a_pointd_3_array.setter
def a_pointd_3_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_pointd_3_array)
data_view.set(value)
self.a_pointd_3_array_size = data_view.get_array_size()
@property
def a_pointf_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointf_3)
return data_view.get()
@a_pointf_3.setter
def a_pointf_3(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_pointf_3)
data_view.set(value)
@property
def a_pointf_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointf_3_array)
return data_view.get(reserved_element_count=self.a_pointf_3_array_size)
@a_pointf_3_array.setter
def a_pointf_3_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_pointf_3_array)
data_view.set(value)
self.a_pointf_3_array_size = data_view.get_array_size()
@property
def a_pointh_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointh_3)
return data_view.get()
@a_pointh_3.setter
def a_pointh_3(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_pointh_3)
data_view.set(value)
@property
def a_pointh_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointh_3_array)
return data_view.get(reserved_element_count=self.a_pointh_3_array_size)
@a_pointh_3_array.setter
def a_pointh_3_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_pointh_3_array)
data_view.set(value)
self.a_pointh_3_array_size = data_view.get_array_size()
@property
def a_quatd_4(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatd_4)
return data_view.get()
@a_quatd_4.setter
def a_quatd_4(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_quatd_4)
data_view.set(value)
@property
def a_quatd_4_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatd_4_array)
return data_view.get(reserved_element_count=self.a_quatd_4_array_size)
@a_quatd_4_array.setter
def a_quatd_4_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_quatd_4_array)
data_view.set(value)
self.a_quatd_4_array_size = data_view.get_array_size()
@property
def a_quatf_4(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatf_4)
return data_view.get()
@a_quatf_4.setter
def a_quatf_4(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_quatf_4)
data_view.set(value)
@property
def a_quatf_4_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatf_4_array)
return data_view.get(reserved_element_count=self.a_quatf_4_array_size)
@a_quatf_4_array.setter
def a_quatf_4_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_quatf_4_array)
data_view.set(value)
self.a_quatf_4_array_size = data_view.get_array_size()
@property
def a_quath_4(self):
data_view = og.AttributeValueHelper(self._attributes.a_quath_4)
return data_view.get()
@a_quath_4.setter
def a_quath_4(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_quath_4)
data_view.set(value)
@property
def a_quath_4_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_quath_4_array)
return data_view.get(reserved_element_count=self.a_quath_4_array_size)
@a_quath_4_array.setter
def a_quath_4_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_quath_4_array)
data_view.set(value)
self.a_quath_4_array_size = data_view.get_array_size()
@property
def a_string(self):
data_view = og.AttributeValueHelper(self._attributes.a_string)
return data_view.get(reserved_element_count=self.a_string_size)
@a_string.setter
def a_string(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_string)
data_view.set(value)
self.a_string_size = data_view.get_array_size()
@property
def a_target(self):
data_view = og.AttributeValueHelper(self._attributes.a_target)
return data_view.get(reserved_element_count=self.a_target_size)
@a_target.setter
def a_target(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_target)
data_view.set(value)
self.a_target_size = data_view.get_array_size()
@property
def a_texcoordd_2(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd_2)
return data_view.get()
@a_texcoordd_2.setter
def a_texcoordd_2(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd_2)
data_view.set(value)
@property
def a_texcoordd_2_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd_2_array)
return data_view.get(reserved_element_count=self.a_texcoordd_2_array_size)
@a_texcoordd_2_array.setter
def a_texcoordd_2_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd_2_array)
data_view.set(value)
self.a_texcoordd_2_array_size = data_view.get_array_size()
@property
def a_texcoordd_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd_3)
return data_view.get()
@a_texcoordd_3.setter
def a_texcoordd_3(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd_3)
data_view.set(value)
@property
def a_texcoordd_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd_3_array)
return data_view.get(reserved_element_count=self.a_texcoordd_3_array_size)
@a_texcoordd_3_array.setter
def a_texcoordd_3_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd_3_array)
data_view.set(value)
self.a_texcoordd_3_array_size = data_view.get_array_size()
@property
def a_texcoordf_2(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf_2)
return data_view.get()
@a_texcoordf_2.setter
def a_texcoordf_2(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf_2)
data_view.set(value)
@property
def a_texcoordf_2_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf_2_array)
return data_view.get(reserved_element_count=self.a_texcoordf_2_array_size)
@a_texcoordf_2_array.setter
def a_texcoordf_2_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf_2_array)
data_view.set(value)
self.a_texcoordf_2_array_size = data_view.get_array_size()
@property
def a_texcoordf_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf_3)
return data_view.get()
@a_texcoordf_3.setter
def a_texcoordf_3(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf_3)
data_view.set(value)
@property
def a_texcoordf_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf_3_array)
return data_view.get(reserved_element_count=self.a_texcoordf_3_array_size)
@a_texcoordf_3_array.setter
def a_texcoordf_3_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf_3_array)
data_view.set(value)
self.a_texcoordf_3_array_size = data_view.get_array_size()
@property
def a_texcoordh_2(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh_2)
return data_view.get()
@a_texcoordh_2.setter
def a_texcoordh_2(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh_2)
data_view.set(value)
@property
def a_texcoordh_2_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh_2_array)
return data_view.get(reserved_element_count=self.a_texcoordh_2_array_size)
@a_texcoordh_2_array.setter
def a_texcoordh_2_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh_2_array)
data_view.set(value)
self.a_texcoordh_2_array_size = data_view.get_array_size()
@property
def a_texcoordh_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh_3)
return data_view.get()
@a_texcoordh_3.setter
def a_texcoordh_3(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh_3)
data_view.set(value)
@property
def a_texcoordh_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh_3_array)
return data_view.get(reserved_element_count=self.a_texcoordh_3_array_size)
@a_texcoordh_3_array.setter
def a_texcoordh_3_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh_3_array)
data_view.set(value)
self.a_texcoordh_3_array_size = data_view.get_array_size()
@property
def a_timecode(self):
data_view = og.AttributeValueHelper(self._attributes.a_timecode)
return data_view.get()
@a_timecode.setter
def a_timecode(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_timecode)
data_view.set(value)
@property
def a_timecode_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_timecode_array)
return data_view.get(reserved_element_count=self.a_timecode_array_size)
@a_timecode_array.setter
def a_timecode_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_timecode_array)
data_view.set(value)
self.a_timecode_array_size = data_view.get_array_size()
@property
def a_token(self):
data_view = og.AttributeValueHelper(self._attributes.a_token)
return data_view.get()
@a_token.setter
def a_token(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_token)
data_view.set(value)
@property
def a_token_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_token_array)
return data_view.get(reserved_element_count=self.a_token_array_size)
@a_token_array.setter
def a_token_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_token_array)
data_view.set(value)
self.a_token_array_size = data_view.get_array_size()
@property
def a_uchar(self):
data_view = og.AttributeValueHelper(self._attributes.a_uchar)
return data_view.get()
@a_uchar.setter
def a_uchar(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_uchar)
data_view.set(value)
@property
def a_uchar_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_uchar_array)
return data_view.get(reserved_element_count=self.a_uchar_array_size)
@a_uchar_array.setter
def a_uchar_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_uchar_array)
data_view.set(value)
self.a_uchar_array_size = data_view.get_array_size()
@property
def a_uint(self):
data_view = og.AttributeValueHelper(self._attributes.a_uint)
return data_view.get()
@a_uint.setter
def a_uint(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_uint)
data_view.set(value)
@property
def a_uint64(self):
data_view = og.AttributeValueHelper(self._attributes.a_uint64)
return data_view.get()
@a_uint64.setter
def a_uint64(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_uint64)
data_view.set(value)
@property
def a_uint64_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_uint64_array)
return data_view.get(reserved_element_count=self.a_uint64_array_size)
@a_uint64_array.setter
def a_uint64_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_uint64_array)
data_view.set(value)
self.a_uint64_array_size = data_view.get_array_size()
@property
def a_uint_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_uint_array)
return data_view.get(reserved_element_count=self.a_uint_array_size)
@a_uint_array.setter
def a_uint_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_uint_array)
data_view.set(value)
self.a_uint_array_size = data_view.get_array_size()
@property
def a_vectord_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectord_3)
return data_view.get()
@a_vectord_3.setter
def a_vectord_3(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_vectord_3)
data_view.set(value)
@property
def a_vectord_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectord_3_array)
return data_view.get(reserved_element_count=self.a_vectord_3_array_size)
@a_vectord_3_array.setter
def a_vectord_3_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_vectord_3_array)
data_view.set(value)
self.a_vectord_3_array_size = data_view.get_array_size()
@property
def a_vectorf_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorf_3)
return data_view.get()
@a_vectorf_3.setter
def a_vectorf_3(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_vectorf_3)
data_view.set(value)
@property
def a_vectorf_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorf_3_array)
return data_view.get(reserved_element_count=self.a_vectorf_3_array_size)
@a_vectorf_3_array.setter
def a_vectorf_3_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_vectorf_3_array)
data_view.set(value)
self.a_vectorf_3_array_size = data_view.get_array_size()
@property
def a_vectorh_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorh_3)
return data_view.get()
@a_vectorh_3.setter
def a_vectorh_3(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_vectorh_3)
data_view.set(value)
@property
def a_vectorh_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorh_3_array)
return data_view.get(reserved_element_count=self.a_vectorh_3_array_size)
@a_vectorh_3_array.setter
def a_vectorh_3_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_vectorh_3_array)
data_view.set(value)
self.a_vectorh_3_array_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)
self.__bundles = og.BundleContainer(context, node, attributes, [], read_only=False, gpu_ptr_kinds={})
self.a_bool_array_size = 2
self.a_colord_3_array_size = 2
self.a_colord_4_array_size = 2
self.a_colorf_3_array_size = 2
self.a_colorf_4_array_size = 2
self.a_colorh_3_array_size = 2
self.a_colorh_4_array_size = 2
self.a_double_2_array_size = 2
self.a_double_3_array_size = 2
self.a_double_4_array_size = 2
self.a_double_array_size = 2
self.a_float_2_array_size = 2
self.a_float_3_array_size = 2
self.a_float_4_array_size = 2
self.a_float_array_size = 2
self.a_frame_4_array_size = 2
self.a_half_2_array_size = 2
self.a_half_3_array_size = 2
self.a_half_4_array_size = 2
self.a_half_array_size = 2
self.a_int64_array_size = 2
self.a_int_2_array_size = 2
self.a_int_3_array_size = 2
self.a_int_4_array_size = 2
self.a_int_array_size = 2
self.a_matrixd_2_array_size = 2
self.a_matrixd_3_array_size = 2
self.a_matrixd_4_array_size = 2
self.a_normald_3_array_size = 2
self.a_normalf_3_array_size = 2
self.a_normalh_3_array_size = 2
self.a_objectId_array_size = 2
self.a_path_size = 6
self.a_pointd_3_array_size = 2
self.a_pointf_3_array_size = 2
self.a_pointh_3_array_size = 2
self.a_quatd_4_array_size = 2
self.a_quatf_4_array_size = 2
self.a_quath_4_array_size = 2
self.a_string_size = 20
self.a_stringEmpty_size = None
self.a_target_size = None
self.a_texcoordd_2_array_size = 2
self.a_texcoordd_3_array_size = 2
self.a_texcoordf_2_array_size = 2
self.a_texcoordf_3_array_size = 2
self.a_texcoordh_2_array_size = 2
self.a_texcoordh_3_array_size = 2
self.a_timecode_array_size = 2
self.a_token_array_size = 2
self.a_uchar_array_size = 2
self.a_uint64_array_size = 2
self.a_uint_array_size = 2
self.a_vectord_3_array_size = 2
self.a_vectorf_3_array_size = 2
self.a_vectorh_3_array_size = 2
@property
def a_bool(self):
data_view = og.AttributeValueHelper(self._attributes.a_bool)
return data_view.get()
@a_bool.setter
def a_bool(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_bool)
data_view.set(value)
@property
def a_bool_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_bool_array)
self.a_bool_array_size = data_view.get_array_size()
return data_view.get()
@a_bool_array.setter
def a_bool_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_bool_array)
data_view.set(value)
self.a_bool_array_size = data_view.get_array_size()
@property
def a_bundle(self) -> og.BundleContents:
"""Get the bundle wrapper class for the attribute state.a_bundle"""
return self.__bundles.a_bundle
@a_bundle.setter
def a_bundle(self, bundle: og.BundleContents):
"""Overwrite the bundle attribute state.a_bundle 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.a_bundle.bundle = bundle
@property
def a_colord_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord_3)
return data_view.get()
@a_colord_3.setter
def a_colord_3(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colord_3)
data_view.set(value)
@property
def a_colord_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord_3_array)
self.a_colord_3_array_size = data_view.get_array_size()
return data_view.get()
@a_colord_3_array.setter
def a_colord_3_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colord_3_array)
data_view.set(value)
self.a_colord_3_array_size = data_view.get_array_size()
@property
def a_colord_4(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord_4)
return data_view.get()
@a_colord_4.setter
def a_colord_4(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colord_4)
data_view.set(value)
@property
def a_colord_4_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord_4_array)
self.a_colord_4_array_size = data_view.get_array_size()
return data_view.get()
@a_colord_4_array.setter
def a_colord_4_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colord_4_array)
data_view.set(value)
self.a_colord_4_array_size = data_view.get_array_size()
@property
def a_colorf_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf_3)
return data_view.get()
@a_colorf_3.setter
def a_colorf_3(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorf_3)
data_view.set(value)
@property
def a_colorf_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf_3_array)
self.a_colorf_3_array_size = data_view.get_array_size()
return data_view.get()
@a_colorf_3_array.setter
def a_colorf_3_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorf_3_array)
data_view.set(value)
self.a_colorf_3_array_size = data_view.get_array_size()
@property
def a_colorf_4(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf_4)
return data_view.get()
@a_colorf_4.setter
def a_colorf_4(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorf_4)
data_view.set(value)
@property
def a_colorf_4_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf_4_array)
self.a_colorf_4_array_size = data_view.get_array_size()
return data_view.get()
@a_colorf_4_array.setter
def a_colorf_4_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorf_4_array)
data_view.set(value)
self.a_colorf_4_array_size = data_view.get_array_size()
@property
def a_colorh_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh_3)
return data_view.get()
@a_colorh_3.setter
def a_colorh_3(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorh_3)
data_view.set(value)
@property
def a_colorh_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh_3_array)
self.a_colorh_3_array_size = data_view.get_array_size()
return data_view.get()
@a_colorh_3_array.setter
def a_colorh_3_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorh_3_array)
data_view.set(value)
self.a_colorh_3_array_size = data_view.get_array_size()
@property
def a_colorh_4(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh_4)
return data_view.get()
@a_colorh_4.setter
def a_colorh_4(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorh_4)
data_view.set(value)
@property
def a_colorh_4_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh_4_array)
self.a_colorh_4_array_size = data_view.get_array_size()
return data_view.get()
@a_colorh_4_array.setter
def a_colorh_4_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorh_4_array)
data_view.set(value)
self.a_colorh_4_array_size = data_view.get_array_size()
@property
def a_double(self):
data_view = og.AttributeValueHelper(self._attributes.a_double)
return data_view.get()
@a_double.setter
def a_double(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double)
data_view.set(value)
@property
def a_double_2(self):
data_view = og.AttributeValueHelper(self._attributes.a_double_2)
return data_view.get()
@a_double_2.setter
def a_double_2(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double_2)
data_view.set(value)
@property
def a_double_2_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_double_2_array)
self.a_double_2_array_size = data_view.get_array_size()
return data_view.get()
@a_double_2_array.setter
def a_double_2_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double_2_array)
data_view.set(value)
self.a_double_2_array_size = data_view.get_array_size()
@property
def a_double_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_double_3)
return data_view.get()
@a_double_3.setter
def a_double_3(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double_3)
data_view.set(value)
@property
def a_double_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_double_3_array)
self.a_double_3_array_size = data_view.get_array_size()
return data_view.get()
@a_double_3_array.setter
def a_double_3_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double_3_array)
data_view.set(value)
self.a_double_3_array_size = data_view.get_array_size()
@property
def a_double_4(self):
data_view = og.AttributeValueHelper(self._attributes.a_double_4)
return data_view.get()
@a_double_4.setter
def a_double_4(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double_4)
data_view.set(value)
@property
def a_double_4_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_double_4_array)
self.a_double_4_array_size = data_view.get_array_size()
return data_view.get()
@a_double_4_array.setter
def a_double_4_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double_4_array)
data_view.set(value)
self.a_double_4_array_size = data_view.get_array_size()
@property
def a_double_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_double_array)
self.a_double_array_size = data_view.get_array_size()
return data_view.get()
@a_double_array.setter
def a_double_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double_array)
data_view.set(value)
self.a_double_array_size = data_view.get_array_size()
@property
def a_execution(self):
data_view = og.AttributeValueHelper(self._attributes.a_execution)
return data_view.get()
@a_execution.setter
def a_execution(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_execution)
data_view.set(value)
@property
def a_firstEvaluation(self):
data_view = og.AttributeValueHelper(self._attributes.a_firstEvaluation)
return data_view.get()
@a_firstEvaluation.setter
def a_firstEvaluation(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_firstEvaluation)
data_view.set(value)
@property
def a_float(self):
data_view = og.AttributeValueHelper(self._attributes.a_float)
return data_view.get()
@a_float.setter
def a_float(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float)
data_view.set(value)
@property
def a_float_2(self):
data_view = og.AttributeValueHelper(self._attributes.a_float_2)
return data_view.get()
@a_float_2.setter
def a_float_2(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float_2)
data_view.set(value)
@property
def a_float_2_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_float_2_array)
self.a_float_2_array_size = data_view.get_array_size()
return data_view.get()
@a_float_2_array.setter
def a_float_2_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float_2_array)
data_view.set(value)
self.a_float_2_array_size = data_view.get_array_size()
@property
def a_float_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_float_3)
return data_view.get()
@a_float_3.setter
def a_float_3(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float_3)
data_view.set(value)
@property
def a_float_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_float_3_array)
self.a_float_3_array_size = data_view.get_array_size()
return data_view.get()
@a_float_3_array.setter
def a_float_3_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float_3_array)
data_view.set(value)
self.a_float_3_array_size = data_view.get_array_size()
@property
def a_float_4(self):
data_view = og.AttributeValueHelper(self._attributes.a_float_4)
return data_view.get()
@a_float_4.setter
def a_float_4(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float_4)
data_view.set(value)
@property
def a_float_4_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_float_4_array)
self.a_float_4_array_size = data_view.get_array_size()
return data_view.get()
@a_float_4_array.setter
def a_float_4_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float_4_array)
data_view.set(value)
self.a_float_4_array_size = data_view.get_array_size()
@property
def a_float_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_float_array)
self.a_float_array_size = data_view.get_array_size()
return data_view.get()
@a_float_array.setter
def a_float_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float_array)
data_view.set(value)
self.a_float_array_size = data_view.get_array_size()
@property
def a_frame_4(self):
data_view = og.AttributeValueHelper(self._attributes.a_frame_4)
return data_view.get()
@a_frame_4.setter
def a_frame_4(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_frame_4)
data_view.set(value)
@property
def a_frame_4_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_frame_4_array)
self.a_frame_4_array_size = data_view.get_array_size()
return data_view.get()
@a_frame_4_array.setter
def a_frame_4_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_frame_4_array)
data_view.set(value)
self.a_frame_4_array_size = data_view.get_array_size()
@property
def a_half(self):
data_view = og.AttributeValueHelper(self._attributes.a_half)
return data_view.get()
@a_half.setter
def a_half(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half)
data_view.set(value)
@property
def a_half_2(self):
data_view = og.AttributeValueHelper(self._attributes.a_half_2)
return data_view.get()
@a_half_2.setter
def a_half_2(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half_2)
data_view.set(value)
@property
def a_half_2_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_half_2_array)
self.a_half_2_array_size = data_view.get_array_size()
return data_view.get()
@a_half_2_array.setter
def a_half_2_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half_2_array)
data_view.set(value)
self.a_half_2_array_size = data_view.get_array_size()
@property
def a_half_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_half_3)
return data_view.get()
@a_half_3.setter
def a_half_3(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half_3)
data_view.set(value)
@property
def a_half_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_half_3_array)
self.a_half_3_array_size = data_view.get_array_size()
return data_view.get()
@a_half_3_array.setter
def a_half_3_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half_3_array)
data_view.set(value)
self.a_half_3_array_size = data_view.get_array_size()
@property
def a_half_4(self):
data_view = og.AttributeValueHelper(self._attributes.a_half_4)
return data_view.get()
@a_half_4.setter
def a_half_4(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half_4)
data_view.set(value)
@property
def a_half_4_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_half_4_array)
self.a_half_4_array_size = data_view.get_array_size()
return data_view.get()
@a_half_4_array.setter
def a_half_4_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half_4_array)
data_view.set(value)
self.a_half_4_array_size = data_view.get_array_size()
@property
def a_half_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_half_array)
self.a_half_array_size = data_view.get_array_size()
return data_view.get()
@a_half_array.setter
def a_half_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half_array)
data_view.set(value)
self.a_half_array_size = data_view.get_array_size()
@property
def a_int(self):
data_view = og.AttributeValueHelper(self._attributes.a_int)
return data_view.get()
@a_int.setter
def a_int(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_int)
data_view.set(value)
@property
def a_int64(self):
data_view = og.AttributeValueHelper(self._attributes.a_int64)
return data_view.get()
@a_int64.setter
def a_int64(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_int64)
data_view.set(value)
@property
def a_int64_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_int64_array)
self.a_int64_array_size = data_view.get_array_size()
return data_view.get()
@a_int64_array.setter
def a_int64_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_int64_array)
data_view.set(value)
self.a_int64_array_size = data_view.get_array_size()
@property
def a_int_2(self):
data_view = og.AttributeValueHelper(self._attributes.a_int_2)
return data_view.get()
@a_int_2.setter
def a_int_2(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_int_2)
data_view.set(value)
@property
def a_int_2_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_int_2_array)
self.a_int_2_array_size = data_view.get_array_size()
return data_view.get()
@a_int_2_array.setter
def a_int_2_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_int_2_array)
data_view.set(value)
self.a_int_2_array_size = data_view.get_array_size()
@property
def a_int_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_int_3)
return data_view.get()
@a_int_3.setter
def a_int_3(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_int_3)
data_view.set(value)
@property
def a_int_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_int_3_array)
self.a_int_3_array_size = data_view.get_array_size()
return data_view.get()
@a_int_3_array.setter
def a_int_3_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_int_3_array)
data_view.set(value)
self.a_int_3_array_size = data_view.get_array_size()
@property
def a_int_4(self):
data_view = og.AttributeValueHelper(self._attributes.a_int_4)
return data_view.get()
@a_int_4.setter
def a_int_4(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_int_4)
data_view.set(value)
@property
def a_int_4_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_int_4_array)
self.a_int_4_array_size = data_view.get_array_size()
return data_view.get()
@a_int_4_array.setter
def a_int_4_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_int_4_array)
data_view.set(value)
self.a_int_4_array_size = data_view.get_array_size()
@property
def a_int_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_int_array)
self.a_int_array_size = data_view.get_array_size()
return data_view.get()
@a_int_array.setter
def a_int_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_int_array)
data_view.set(value)
self.a_int_array_size = data_view.get_array_size()
@property
def a_matrixd_2(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd_2)
return data_view.get()
@a_matrixd_2.setter
def a_matrixd_2(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd_2)
data_view.set(value)
@property
def a_matrixd_2_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd_2_array)
self.a_matrixd_2_array_size = data_view.get_array_size()
return data_view.get()
@a_matrixd_2_array.setter
def a_matrixd_2_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd_2_array)
data_view.set(value)
self.a_matrixd_2_array_size = data_view.get_array_size()
@property
def a_matrixd_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd_3)
return data_view.get()
@a_matrixd_3.setter
def a_matrixd_3(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd_3)
data_view.set(value)
@property
def a_matrixd_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd_3_array)
self.a_matrixd_3_array_size = data_view.get_array_size()
return data_view.get()
@a_matrixd_3_array.setter
def a_matrixd_3_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd_3_array)
data_view.set(value)
self.a_matrixd_3_array_size = data_view.get_array_size()
@property
def a_matrixd_4(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd_4)
return data_view.get()
@a_matrixd_4.setter
def a_matrixd_4(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd_4)
data_view.set(value)
@property
def a_matrixd_4_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd_4_array)
self.a_matrixd_4_array_size = data_view.get_array_size()
return data_view.get()
@a_matrixd_4_array.setter
def a_matrixd_4_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd_4_array)
data_view.set(value)
self.a_matrixd_4_array_size = data_view.get_array_size()
@property
def a_normald_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_normald_3)
return data_view.get()
@a_normald_3.setter
def a_normald_3(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_normald_3)
data_view.set(value)
@property
def a_normald_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_normald_3_array)
self.a_normald_3_array_size = data_view.get_array_size()
return data_view.get()
@a_normald_3_array.setter
def a_normald_3_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_normald_3_array)
data_view.set(value)
self.a_normald_3_array_size = data_view.get_array_size()
@property
def a_normalf_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalf_3)
return data_view.get()
@a_normalf_3.setter
def a_normalf_3(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_normalf_3)
data_view.set(value)
@property
def a_normalf_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalf_3_array)
self.a_normalf_3_array_size = data_view.get_array_size()
return data_view.get()
@a_normalf_3_array.setter
def a_normalf_3_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_normalf_3_array)
data_view.set(value)
self.a_normalf_3_array_size = data_view.get_array_size()
@property
def a_normalh_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalh_3)
return data_view.get()
@a_normalh_3.setter
def a_normalh_3(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_normalh_3)
data_view.set(value)
@property
def a_normalh_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalh_3_array)
self.a_normalh_3_array_size = data_view.get_array_size()
return data_view.get()
@a_normalh_3_array.setter
def a_normalh_3_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_normalh_3_array)
data_view.set(value)
self.a_normalh_3_array_size = data_view.get_array_size()
@property
def a_objectId(self):
data_view = og.AttributeValueHelper(self._attributes.a_objectId)
return data_view.get()
@a_objectId.setter
def a_objectId(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_objectId)
data_view.set(value)
@property
def a_objectId_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_objectId_array)
self.a_objectId_array_size = data_view.get_array_size()
return data_view.get()
@a_objectId_array.setter
def a_objectId_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_objectId_array)
data_view.set(value)
self.a_objectId_array_size = data_view.get_array_size()
@property
def a_path(self):
data_view = og.AttributeValueHelper(self._attributes.a_path)
self.a_path_size = data_view.get_array_size()
return data_view.get()
@a_path.setter
def a_path(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_path)
data_view.set(value)
self.a_path_size = data_view.get_array_size()
@property
def a_pointd_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointd_3)
return data_view.get()
@a_pointd_3.setter
def a_pointd_3(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_pointd_3)
data_view.set(value)
@property
def a_pointd_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointd_3_array)
self.a_pointd_3_array_size = data_view.get_array_size()
return data_view.get()
@a_pointd_3_array.setter
def a_pointd_3_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_pointd_3_array)
data_view.set(value)
self.a_pointd_3_array_size = data_view.get_array_size()
@property
def a_pointf_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointf_3)
return data_view.get()
@a_pointf_3.setter
def a_pointf_3(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_pointf_3)
data_view.set(value)
@property
def a_pointf_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointf_3_array)
self.a_pointf_3_array_size = data_view.get_array_size()
return data_view.get()
@a_pointf_3_array.setter
def a_pointf_3_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_pointf_3_array)
data_view.set(value)
self.a_pointf_3_array_size = data_view.get_array_size()
@property
def a_pointh_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointh_3)
return data_view.get()
@a_pointh_3.setter
def a_pointh_3(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_pointh_3)
data_view.set(value)
@property
def a_pointh_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointh_3_array)
self.a_pointh_3_array_size = data_view.get_array_size()
return data_view.get()
@a_pointh_3_array.setter
def a_pointh_3_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_pointh_3_array)
data_view.set(value)
self.a_pointh_3_array_size = data_view.get_array_size()
@property
def a_quatd_4(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatd_4)
return data_view.get()
@a_quatd_4.setter
def a_quatd_4(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_quatd_4)
data_view.set(value)
@property
def a_quatd_4_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatd_4_array)
self.a_quatd_4_array_size = data_view.get_array_size()
return data_view.get()
@a_quatd_4_array.setter
def a_quatd_4_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_quatd_4_array)
data_view.set(value)
self.a_quatd_4_array_size = data_view.get_array_size()
@property
def a_quatf_4(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatf_4)
return data_view.get()
@a_quatf_4.setter
def a_quatf_4(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_quatf_4)
data_view.set(value)
@property
def a_quatf_4_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatf_4_array)
self.a_quatf_4_array_size = data_view.get_array_size()
return data_view.get()
@a_quatf_4_array.setter
def a_quatf_4_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_quatf_4_array)
data_view.set(value)
self.a_quatf_4_array_size = data_view.get_array_size()
@property
def a_quath_4(self):
data_view = og.AttributeValueHelper(self._attributes.a_quath_4)
return data_view.get()
@a_quath_4.setter
def a_quath_4(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_quath_4)
data_view.set(value)
@property
def a_quath_4_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_quath_4_array)
self.a_quath_4_array_size = data_view.get_array_size()
return data_view.get()
@a_quath_4_array.setter
def a_quath_4_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_quath_4_array)
data_view.set(value)
self.a_quath_4_array_size = data_view.get_array_size()
@property
def a_string(self):
data_view = og.AttributeValueHelper(self._attributes.a_string)
self.a_string_size = data_view.get_array_size()
return data_view.get()
@a_string.setter
def a_string(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_string)
data_view.set(value)
self.a_string_size = data_view.get_array_size()
@property
def a_stringEmpty(self):
data_view = og.AttributeValueHelper(self._attributes.a_stringEmpty)
self.a_stringEmpty_size = data_view.get_array_size()
return data_view.get()
@a_stringEmpty.setter
def a_stringEmpty(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_stringEmpty)
data_view.set(value)
self.a_stringEmpty_size = data_view.get_array_size()
@property
def a_target(self):
data_view = og.AttributeValueHelper(self._attributes.a_target)
self.a_target_size = data_view.get_array_size()
return data_view.get()
@a_target.setter
def a_target(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_target)
data_view.set(value)
self.a_target_size = data_view.get_array_size()
@property
def a_texcoordd_2(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd_2)
return data_view.get()
@a_texcoordd_2.setter
def a_texcoordd_2(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd_2)
data_view.set(value)
@property
def a_texcoordd_2_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd_2_array)
self.a_texcoordd_2_array_size = data_view.get_array_size()
return data_view.get()
@a_texcoordd_2_array.setter
def a_texcoordd_2_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd_2_array)
data_view.set(value)
self.a_texcoordd_2_array_size = data_view.get_array_size()
@property
def a_texcoordd_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd_3)
return data_view.get()
@a_texcoordd_3.setter
def a_texcoordd_3(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd_3)
data_view.set(value)
@property
def a_texcoordd_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd_3_array)
self.a_texcoordd_3_array_size = data_view.get_array_size()
return data_view.get()
@a_texcoordd_3_array.setter
def a_texcoordd_3_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd_3_array)
data_view.set(value)
self.a_texcoordd_3_array_size = data_view.get_array_size()
@property
def a_texcoordf_2(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf_2)
return data_view.get()
@a_texcoordf_2.setter
def a_texcoordf_2(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf_2)
data_view.set(value)
@property
def a_texcoordf_2_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf_2_array)
self.a_texcoordf_2_array_size = data_view.get_array_size()
return data_view.get()
@a_texcoordf_2_array.setter
def a_texcoordf_2_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf_2_array)
data_view.set(value)
self.a_texcoordf_2_array_size = data_view.get_array_size()
@property
def a_texcoordf_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf_3)
return data_view.get()
@a_texcoordf_3.setter
def a_texcoordf_3(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf_3)
data_view.set(value)
@property
def a_texcoordf_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf_3_array)
self.a_texcoordf_3_array_size = data_view.get_array_size()
return data_view.get()
@a_texcoordf_3_array.setter
def a_texcoordf_3_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf_3_array)
data_view.set(value)
self.a_texcoordf_3_array_size = data_view.get_array_size()
@property
def a_texcoordh_2(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh_2)
return data_view.get()
@a_texcoordh_2.setter
def a_texcoordh_2(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh_2)
data_view.set(value)
@property
def a_texcoordh_2_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh_2_array)
self.a_texcoordh_2_array_size = data_view.get_array_size()
return data_view.get()
@a_texcoordh_2_array.setter
def a_texcoordh_2_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh_2_array)
data_view.set(value)
self.a_texcoordh_2_array_size = data_view.get_array_size()
@property
def a_texcoordh_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh_3)
return data_view.get()
@a_texcoordh_3.setter
def a_texcoordh_3(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh_3)
data_view.set(value)
@property
def a_texcoordh_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh_3_array)
self.a_texcoordh_3_array_size = data_view.get_array_size()
return data_view.get()
@a_texcoordh_3_array.setter
def a_texcoordh_3_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh_3_array)
data_view.set(value)
self.a_texcoordh_3_array_size = data_view.get_array_size()
@property
def a_timecode(self):
data_view = og.AttributeValueHelper(self._attributes.a_timecode)
return data_view.get()
@a_timecode.setter
def a_timecode(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_timecode)
data_view.set(value)
@property
def a_timecode_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_timecode_array)
self.a_timecode_array_size = data_view.get_array_size()
return data_view.get()
@a_timecode_array.setter
def a_timecode_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_timecode_array)
data_view.set(value)
self.a_timecode_array_size = data_view.get_array_size()
@property
def a_token(self):
data_view = og.AttributeValueHelper(self._attributes.a_token)
return data_view.get()
@a_token.setter
def a_token(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_token)
data_view.set(value)
@property
def a_token_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_token_array)
self.a_token_array_size = data_view.get_array_size()
return data_view.get()
@a_token_array.setter
def a_token_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_token_array)
data_view.set(value)
self.a_token_array_size = data_view.get_array_size()
@property
def a_uchar(self):
data_view = og.AttributeValueHelper(self._attributes.a_uchar)
return data_view.get()
@a_uchar.setter
def a_uchar(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_uchar)
data_view.set(value)
@property
def a_uchar_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_uchar_array)
self.a_uchar_array_size = data_view.get_array_size()
return data_view.get()
@a_uchar_array.setter
def a_uchar_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_uchar_array)
data_view.set(value)
self.a_uchar_array_size = data_view.get_array_size()
@property
def a_uint(self):
data_view = og.AttributeValueHelper(self._attributes.a_uint)
return data_view.get()
@a_uint.setter
def a_uint(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_uint)
data_view.set(value)
@property
def a_uint64(self):
data_view = og.AttributeValueHelper(self._attributes.a_uint64)
return data_view.get()
@a_uint64.setter
def a_uint64(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_uint64)
data_view.set(value)
@property
def a_uint64_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_uint64_array)
self.a_uint64_array_size = data_view.get_array_size()
return data_view.get()
@a_uint64_array.setter
def a_uint64_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_uint64_array)
data_view.set(value)
self.a_uint64_array_size = data_view.get_array_size()
@property
def a_uint_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_uint_array)
self.a_uint_array_size = data_view.get_array_size()
return data_view.get()
@a_uint_array.setter
def a_uint_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_uint_array)
data_view.set(value)
self.a_uint_array_size = data_view.get_array_size()
@property
def a_vectord_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectord_3)
return data_view.get()
@a_vectord_3.setter
def a_vectord_3(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_vectord_3)
data_view.set(value)
@property
def a_vectord_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectord_3_array)
self.a_vectord_3_array_size = data_view.get_array_size()
return data_view.get()
@a_vectord_3_array.setter
def a_vectord_3_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_vectord_3_array)
data_view.set(value)
self.a_vectord_3_array_size = data_view.get_array_size()
@property
def a_vectorf_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorf_3)
return data_view.get()
@a_vectorf_3.setter
def a_vectorf_3(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_vectorf_3)
data_view.set(value)
@property
def a_vectorf_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorf_3_array)
self.a_vectorf_3_array_size = data_view.get_array_size()
return data_view.get()
@a_vectorf_3_array.setter
def a_vectorf_3_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_vectorf_3_array)
data_view.set(value)
self.a_vectorf_3_array_size = data_view.get_array_size()
@property
def a_vectorh_3(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorh_3)
return data_view.get()
@a_vectorh_3.setter
def a_vectorh_3(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_vectorh_3)
data_view.set(value)
@property
def a_vectorh_3_array(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorh_3_array)
self.a_vectorh_3_array_size = data_view.get_array_size()
return data_view.get()
@a_vectorh_3_array.setter
def a_vectorh_3_array(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_vectorh_3_array)
data_view.set(value)
self.a_vectorh_3_array_size = data_view.get_array_size()
def __init__(self, node):
super().__init__(node)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_INPUT)
self.inputs = OgnTestAllDataTypesDatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
self.outputs = OgnTestAllDataTypesDatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
self.state = OgnTestAllDataTypesDatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
| 235,864 |
Python
| 48.087409 | 540 | 0.582777 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/OgnTestNanInfDatabase.py
|
"""Support for simplified access to data on nodes of type omni.graph.test.TestNanInf
Test node that exercises specification of NaN and Inf numbers, tuples, and arrays
"""
import carb
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 OgnTestNanInfDatabase(og.Database):
"""Helper class providing simplified access to data on nodes of type omni.graph.test.TestNanInf
Class Members:
node: Node being evaluated
Attribute Value Properties:
Inputs:
inputs.a_colord3_array_inf
inputs.a_colord3_array_nan
inputs.a_colord3_array_ninf
inputs.a_colord3_array_snan
inputs.a_colord3_inf
inputs.a_colord3_nan
inputs.a_colord3_ninf
inputs.a_colord3_snan
inputs.a_colord4_array_inf
inputs.a_colord4_array_nan
inputs.a_colord4_array_ninf
inputs.a_colord4_array_snan
inputs.a_colord4_inf
inputs.a_colord4_nan
inputs.a_colord4_ninf
inputs.a_colord4_snan
inputs.a_colorf3_array_inf
inputs.a_colorf3_array_nan
inputs.a_colorf3_array_ninf
inputs.a_colorf3_array_snan
inputs.a_colorf3_inf
inputs.a_colorf3_nan
inputs.a_colorf3_ninf
inputs.a_colorf3_snan
inputs.a_colorf4_array_inf
inputs.a_colorf4_array_nan
inputs.a_colorf4_array_ninf
inputs.a_colorf4_array_snan
inputs.a_colorf4_inf
inputs.a_colorf4_nan
inputs.a_colorf4_ninf
inputs.a_colorf4_snan
inputs.a_colorh3_array_inf
inputs.a_colorh3_array_nan
inputs.a_colorh3_array_ninf
inputs.a_colorh3_array_snan
inputs.a_colorh3_inf
inputs.a_colorh3_nan
inputs.a_colorh3_ninf
inputs.a_colorh3_snan
inputs.a_colorh4_array_inf
inputs.a_colorh4_array_nan
inputs.a_colorh4_array_ninf
inputs.a_colorh4_array_snan
inputs.a_colorh4_inf
inputs.a_colorh4_nan
inputs.a_colorh4_ninf
inputs.a_colorh4_snan
inputs.a_double2_array_inf
inputs.a_double2_array_nan
inputs.a_double2_array_ninf
inputs.a_double2_array_snan
inputs.a_double2_inf
inputs.a_double2_nan
inputs.a_double2_ninf
inputs.a_double2_snan
inputs.a_double3_array_inf
inputs.a_double3_array_nan
inputs.a_double3_array_ninf
inputs.a_double3_array_snan
inputs.a_double3_inf
inputs.a_double3_nan
inputs.a_double3_ninf
inputs.a_double3_snan
inputs.a_double4_array_inf
inputs.a_double4_array_nan
inputs.a_double4_array_ninf
inputs.a_double4_array_snan
inputs.a_double4_inf
inputs.a_double4_nan
inputs.a_double4_ninf
inputs.a_double4_snan
inputs.a_double_array_inf
inputs.a_double_array_nan
inputs.a_double_array_ninf
inputs.a_double_array_snan
inputs.a_double_inf
inputs.a_double_nan
inputs.a_double_ninf
inputs.a_double_snan
inputs.a_float2_array_inf
inputs.a_float2_array_nan
inputs.a_float2_array_ninf
inputs.a_float2_array_snan
inputs.a_float2_inf
inputs.a_float2_nan
inputs.a_float2_ninf
inputs.a_float2_snan
inputs.a_float3_array_inf
inputs.a_float3_array_nan
inputs.a_float3_array_ninf
inputs.a_float3_array_snan
inputs.a_float3_inf
inputs.a_float3_nan
inputs.a_float3_ninf
inputs.a_float3_snan
inputs.a_float4_array_inf
inputs.a_float4_array_nan
inputs.a_float4_array_ninf
inputs.a_float4_array_snan
inputs.a_float4_inf
inputs.a_float4_nan
inputs.a_float4_ninf
inputs.a_float4_snan
inputs.a_float_array_inf
inputs.a_float_array_nan
inputs.a_float_array_ninf
inputs.a_float_array_snan
inputs.a_float_inf
inputs.a_float_nan
inputs.a_float_ninf
inputs.a_float_snan
inputs.a_frame4_array_inf
inputs.a_frame4_array_nan
inputs.a_frame4_array_ninf
inputs.a_frame4_array_snan
inputs.a_frame4_inf
inputs.a_frame4_nan
inputs.a_frame4_ninf
inputs.a_frame4_snan
inputs.a_half2_array_inf
inputs.a_half2_array_nan
inputs.a_half2_array_ninf
inputs.a_half2_array_snan
inputs.a_half2_inf
inputs.a_half2_nan
inputs.a_half2_ninf
inputs.a_half2_snan
inputs.a_half3_array_inf
inputs.a_half3_array_nan
inputs.a_half3_array_ninf
inputs.a_half3_array_snan
inputs.a_half3_inf
inputs.a_half3_nan
inputs.a_half3_ninf
inputs.a_half3_snan
inputs.a_half4_array_inf
inputs.a_half4_array_nan
inputs.a_half4_array_ninf
inputs.a_half4_array_snan
inputs.a_half4_inf
inputs.a_half4_nan
inputs.a_half4_ninf
inputs.a_half4_snan
inputs.a_half_array_inf
inputs.a_half_array_nan
inputs.a_half_array_ninf
inputs.a_half_array_snan
inputs.a_half_inf
inputs.a_half_nan
inputs.a_half_ninf
inputs.a_half_snan
inputs.a_matrixd2_array_inf
inputs.a_matrixd2_array_nan
inputs.a_matrixd2_array_ninf
inputs.a_matrixd2_array_snan
inputs.a_matrixd2_inf
inputs.a_matrixd2_nan
inputs.a_matrixd2_ninf
inputs.a_matrixd2_snan
inputs.a_matrixd3_array_inf
inputs.a_matrixd3_array_nan
inputs.a_matrixd3_array_ninf
inputs.a_matrixd3_array_snan
inputs.a_matrixd3_inf
inputs.a_matrixd3_nan
inputs.a_matrixd3_ninf
inputs.a_matrixd3_snan
inputs.a_matrixd4_array_inf
inputs.a_matrixd4_array_nan
inputs.a_matrixd4_array_ninf
inputs.a_matrixd4_array_snan
inputs.a_matrixd4_inf
inputs.a_matrixd4_nan
inputs.a_matrixd4_ninf
inputs.a_matrixd4_snan
inputs.a_normald3_array_inf
inputs.a_normald3_array_nan
inputs.a_normald3_array_ninf
inputs.a_normald3_array_snan
inputs.a_normald3_inf
inputs.a_normald3_nan
inputs.a_normald3_ninf
inputs.a_normald3_snan
inputs.a_normalf3_array_inf
inputs.a_normalf3_array_nan
inputs.a_normalf3_array_ninf
inputs.a_normalf3_array_snan
inputs.a_normalf3_inf
inputs.a_normalf3_nan
inputs.a_normalf3_ninf
inputs.a_normalf3_snan
inputs.a_normalh3_array_inf
inputs.a_normalh3_array_nan
inputs.a_normalh3_array_ninf
inputs.a_normalh3_array_snan
inputs.a_normalh3_inf
inputs.a_normalh3_nan
inputs.a_normalh3_ninf
inputs.a_normalh3_snan
inputs.a_pointd3_array_inf
inputs.a_pointd3_array_nan
inputs.a_pointd3_array_ninf
inputs.a_pointd3_array_snan
inputs.a_pointd3_inf
inputs.a_pointd3_nan
inputs.a_pointd3_ninf
inputs.a_pointd3_snan
inputs.a_pointf3_array_inf
inputs.a_pointf3_array_nan
inputs.a_pointf3_array_ninf
inputs.a_pointf3_array_snan
inputs.a_pointf3_inf
inputs.a_pointf3_nan
inputs.a_pointf3_ninf
inputs.a_pointf3_snan
inputs.a_pointh3_array_inf
inputs.a_pointh3_array_nan
inputs.a_pointh3_array_ninf
inputs.a_pointh3_array_snan
inputs.a_pointh3_inf
inputs.a_pointh3_nan
inputs.a_pointh3_ninf
inputs.a_pointh3_snan
inputs.a_quatd4_array_inf
inputs.a_quatd4_array_nan
inputs.a_quatd4_array_ninf
inputs.a_quatd4_array_snan
inputs.a_quatd4_inf
inputs.a_quatd4_nan
inputs.a_quatd4_ninf
inputs.a_quatd4_snan
inputs.a_quatf4_array_inf
inputs.a_quatf4_array_nan
inputs.a_quatf4_array_ninf
inputs.a_quatf4_array_snan
inputs.a_quatf4_inf
inputs.a_quatf4_nan
inputs.a_quatf4_ninf
inputs.a_quatf4_snan
inputs.a_quath4_array_inf
inputs.a_quath4_array_nan
inputs.a_quath4_array_ninf
inputs.a_quath4_array_snan
inputs.a_quath4_inf
inputs.a_quath4_nan
inputs.a_quath4_ninf
inputs.a_quath4_snan
inputs.a_texcoordd2_array_inf
inputs.a_texcoordd2_array_nan
inputs.a_texcoordd2_array_ninf
inputs.a_texcoordd2_array_snan
inputs.a_texcoordd2_inf
inputs.a_texcoordd2_nan
inputs.a_texcoordd2_ninf
inputs.a_texcoordd2_snan
inputs.a_texcoordd3_array_inf
inputs.a_texcoordd3_array_nan
inputs.a_texcoordd3_array_ninf
inputs.a_texcoordd3_array_snan
inputs.a_texcoordd3_inf
inputs.a_texcoordd3_nan
inputs.a_texcoordd3_ninf
inputs.a_texcoordd3_snan
inputs.a_texcoordf2_array_inf
inputs.a_texcoordf2_array_nan
inputs.a_texcoordf2_array_ninf
inputs.a_texcoordf2_array_snan
inputs.a_texcoordf2_inf
inputs.a_texcoordf2_nan
inputs.a_texcoordf2_ninf
inputs.a_texcoordf2_snan
inputs.a_texcoordf3_array_inf
inputs.a_texcoordf3_array_nan
inputs.a_texcoordf3_array_ninf
inputs.a_texcoordf3_array_snan
inputs.a_texcoordf3_inf
inputs.a_texcoordf3_nan
inputs.a_texcoordf3_ninf
inputs.a_texcoordf3_snan
inputs.a_texcoordh2_array_inf
inputs.a_texcoordh2_array_nan
inputs.a_texcoordh2_array_ninf
inputs.a_texcoordh2_array_snan
inputs.a_texcoordh2_inf
inputs.a_texcoordh2_nan
inputs.a_texcoordh2_ninf
inputs.a_texcoordh2_snan
inputs.a_texcoordh3_array_inf
inputs.a_texcoordh3_array_nan
inputs.a_texcoordh3_array_ninf
inputs.a_texcoordh3_array_snan
inputs.a_texcoordh3_inf
inputs.a_texcoordh3_nan
inputs.a_texcoordh3_ninf
inputs.a_texcoordh3_snan
inputs.a_timecode_array_inf
inputs.a_timecode_array_nan
inputs.a_timecode_array_ninf
inputs.a_timecode_array_snan
inputs.a_timecode_inf
inputs.a_timecode_nan
inputs.a_timecode_ninf
inputs.a_timecode_snan
inputs.a_vectord3_array_inf
inputs.a_vectord3_array_nan
inputs.a_vectord3_array_ninf
inputs.a_vectord3_array_snan
inputs.a_vectord3_inf
inputs.a_vectord3_nan
inputs.a_vectord3_ninf
inputs.a_vectord3_snan
inputs.a_vectorf3_array_inf
inputs.a_vectorf3_array_nan
inputs.a_vectorf3_array_ninf
inputs.a_vectorf3_array_snan
inputs.a_vectorf3_inf
inputs.a_vectorf3_nan
inputs.a_vectorf3_ninf
inputs.a_vectorf3_snan
inputs.a_vectorh3_array_inf
inputs.a_vectorh3_array_nan
inputs.a_vectorh3_array_ninf
inputs.a_vectorh3_array_snan
inputs.a_vectorh3_inf
inputs.a_vectorh3_nan
inputs.a_vectorh3_ninf
inputs.a_vectorh3_snan
Outputs:
outputs.a_colord3_array_inf
outputs.a_colord3_array_nan
outputs.a_colord3_array_ninf
outputs.a_colord3_array_snan
outputs.a_colord3_inf
outputs.a_colord3_nan
outputs.a_colord3_ninf
outputs.a_colord3_snan
outputs.a_colord4_array_inf
outputs.a_colord4_array_nan
outputs.a_colord4_array_ninf
outputs.a_colord4_array_snan
outputs.a_colord4_inf
outputs.a_colord4_nan
outputs.a_colord4_ninf
outputs.a_colord4_snan
outputs.a_colorf3_array_inf
outputs.a_colorf3_array_nan
outputs.a_colorf3_array_ninf
outputs.a_colorf3_array_snan
outputs.a_colorf3_inf
outputs.a_colorf3_nan
outputs.a_colorf3_ninf
outputs.a_colorf3_snan
outputs.a_colorf4_array_inf
outputs.a_colorf4_array_nan
outputs.a_colorf4_array_ninf
outputs.a_colorf4_array_snan
outputs.a_colorf4_inf
outputs.a_colorf4_nan
outputs.a_colorf4_ninf
outputs.a_colorf4_snan
outputs.a_colorh3_array_inf
outputs.a_colorh3_array_nan
outputs.a_colorh3_array_ninf
outputs.a_colorh3_array_snan
outputs.a_colorh3_inf
outputs.a_colorh3_nan
outputs.a_colorh3_ninf
outputs.a_colorh3_snan
outputs.a_colorh4_array_inf
outputs.a_colorh4_array_nan
outputs.a_colorh4_array_ninf
outputs.a_colorh4_array_snan
outputs.a_colorh4_inf
outputs.a_colorh4_nan
outputs.a_colorh4_ninf
outputs.a_colorh4_snan
outputs.a_double2_array_inf
outputs.a_double2_array_nan
outputs.a_double2_array_ninf
outputs.a_double2_array_snan
outputs.a_double2_inf
outputs.a_double2_nan
outputs.a_double2_ninf
outputs.a_double2_snan
outputs.a_double3_array_inf
outputs.a_double3_array_nan
outputs.a_double3_array_ninf
outputs.a_double3_array_snan
outputs.a_double3_inf
outputs.a_double3_nan
outputs.a_double3_ninf
outputs.a_double3_snan
outputs.a_double4_array_inf
outputs.a_double4_array_nan
outputs.a_double4_array_ninf
outputs.a_double4_array_snan
outputs.a_double4_inf
outputs.a_double4_nan
outputs.a_double4_ninf
outputs.a_double4_snan
outputs.a_double_array_inf
outputs.a_double_array_nan
outputs.a_double_array_ninf
outputs.a_double_array_snan
outputs.a_double_inf
outputs.a_double_nan
outputs.a_double_ninf
outputs.a_double_snan
outputs.a_float2_array_inf
outputs.a_float2_array_nan
outputs.a_float2_array_ninf
outputs.a_float2_array_snan
outputs.a_float2_inf
outputs.a_float2_nan
outputs.a_float2_ninf
outputs.a_float2_snan
outputs.a_float3_array_inf
outputs.a_float3_array_nan
outputs.a_float3_array_ninf
outputs.a_float3_array_snan
outputs.a_float3_inf
outputs.a_float3_nan
outputs.a_float3_ninf
outputs.a_float3_snan
outputs.a_float4_array_inf
outputs.a_float4_array_nan
outputs.a_float4_array_ninf
outputs.a_float4_array_snan
outputs.a_float4_inf
outputs.a_float4_nan
outputs.a_float4_ninf
outputs.a_float4_snan
outputs.a_float_array_inf
outputs.a_float_array_nan
outputs.a_float_array_ninf
outputs.a_float_array_snan
outputs.a_float_inf
outputs.a_float_nan
outputs.a_float_ninf
outputs.a_float_snan
outputs.a_frame4_array_inf
outputs.a_frame4_array_nan
outputs.a_frame4_array_ninf
outputs.a_frame4_array_snan
outputs.a_frame4_inf
outputs.a_frame4_nan
outputs.a_frame4_ninf
outputs.a_frame4_snan
outputs.a_half2_array_inf
outputs.a_half2_array_nan
outputs.a_half2_array_ninf
outputs.a_half2_array_snan
outputs.a_half2_inf
outputs.a_half2_nan
outputs.a_half2_ninf
outputs.a_half2_snan
outputs.a_half3_array_inf
outputs.a_half3_array_nan
outputs.a_half3_array_ninf
outputs.a_half3_array_snan
outputs.a_half3_inf
outputs.a_half3_nan
outputs.a_half3_ninf
outputs.a_half3_snan
outputs.a_half4_array_inf
outputs.a_half4_array_nan
outputs.a_half4_array_ninf
outputs.a_half4_array_snan
outputs.a_half4_inf
outputs.a_half4_nan
outputs.a_half4_ninf
outputs.a_half4_snan
outputs.a_half_array_inf
outputs.a_half_array_nan
outputs.a_half_array_ninf
outputs.a_half_array_snan
outputs.a_half_inf
outputs.a_half_nan
outputs.a_half_ninf
outputs.a_half_snan
outputs.a_matrixd2_array_inf
outputs.a_matrixd2_array_nan
outputs.a_matrixd2_array_ninf
outputs.a_matrixd2_array_snan
outputs.a_matrixd2_inf
outputs.a_matrixd2_nan
outputs.a_matrixd2_ninf
outputs.a_matrixd2_snan
outputs.a_matrixd3_array_inf
outputs.a_matrixd3_array_nan
outputs.a_matrixd3_array_ninf
outputs.a_matrixd3_array_snan
outputs.a_matrixd3_inf
outputs.a_matrixd3_nan
outputs.a_matrixd3_ninf
outputs.a_matrixd3_snan
outputs.a_matrixd4_array_inf
outputs.a_matrixd4_array_nan
outputs.a_matrixd4_array_ninf
outputs.a_matrixd4_array_snan
outputs.a_matrixd4_inf
outputs.a_matrixd4_nan
outputs.a_matrixd4_ninf
outputs.a_matrixd4_snan
outputs.a_normald3_array_inf
outputs.a_normald3_array_nan
outputs.a_normald3_array_ninf
outputs.a_normald3_array_snan
outputs.a_normald3_inf
outputs.a_normald3_nan
outputs.a_normald3_ninf
outputs.a_normald3_snan
outputs.a_normalf3_array_inf
outputs.a_normalf3_array_nan
outputs.a_normalf3_array_ninf
outputs.a_normalf3_array_snan
outputs.a_normalf3_inf
outputs.a_normalf3_nan
outputs.a_normalf3_ninf
outputs.a_normalf3_snan
outputs.a_normalh3_array_inf
outputs.a_normalh3_array_nan
outputs.a_normalh3_array_ninf
outputs.a_normalh3_array_snan
outputs.a_normalh3_inf
outputs.a_normalh3_nan
outputs.a_normalh3_ninf
outputs.a_normalh3_snan
outputs.a_pointd3_array_inf
outputs.a_pointd3_array_nan
outputs.a_pointd3_array_ninf
outputs.a_pointd3_array_snan
outputs.a_pointd3_inf
outputs.a_pointd3_nan
outputs.a_pointd3_ninf
outputs.a_pointd3_snan
outputs.a_pointf3_array_inf
outputs.a_pointf3_array_nan
outputs.a_pointf3_array_ninf
outputs.a_pointf3_array_snan
outputs.a_pointf3_inf
outputs.a_pointf3_nan
outputs.a_pointf3_ninf
outputs.a_pointf3_snan
outputs.a_pointh3_array_inf
outputs.a_pointh3_array_nan
outputs.a_pointh3_array_ninf
outputs.a_pointh3_array_snan
outputs.a_pointh3_inf
outputs.a_pointh3_nan
outputs.a_pointh3_ninf
outputs.a_pointh3_snan
outputs.a_quatd4_array_inf
outputs.a_quatd4_array_nan
outputs.a_quatd4_array_ninf
outputs.a_quatd4_array_snan
outputs.a_quatd4_inf
outputs.a_quatd4_nan
outputs.a_quatd4_ninf
outputs.a_quatd4_snan
outputs.a_quatf4_array_inf
outputs.a_quatf4_array_nan
outputs.a_quatf4_array_ninf
outputs.a_quatf4_array_snan
outputs.a_quatf4_inf
outputs.a_quatf4_nan
outputs.a_quatf4_ninf
outputs.a_quatf4_snan
outputs.a_quath4_array_inf
outputs.a_quath4_array_nan
outputs.a_quath4_array_ninf
outputs.a_quath4_array_snan
outputs.a_quath4_inf
outputs.a_quath4_nan
outputs.a_quath4_ninf
outputs.a_quath4_snan
outputs.a_texcoordd2_array_inf
outputs.a_texcoordd2_array_nan
outputs.a_texcoordd2_array_ninf
outputs.a_texcoordd2_array_snan
outputs.a_texcoordd2_inf
outputs.a_texcoordd2_nan
outputs.a_texcoordd2_ninf
outputs.a_texcoordd2_snan
outputs.a_texcoordd3_array_inf
outputs.a_texcoordd3_array_nan
outputs.a_texcoordd3_array_ninf
outputs.a_texcoordd3_array_snan
outputs.a_texcoordd3_inf
outputs.a_texcoordd3_nan
outputs.a_texcoordd3_ninf
outputs.a_texcoordd3_snan
outputs.a_texcoordf2_array_inf
outputs.a_texcoordf2_array_nan
outputs.a_texcoordf2_array_ninf
outputs.a_texcoordf2_array_snan
outputs.a_texcoordf2_inf
outputs.a_texcoordf2_nan
outputs.a_texcoordf2_ninf
outputs.a_texcoordf2_snan
outputs.a_texcoordf3_array_inf
outputs.a_texcoordf3_array_nan
outputs.a_texcoordf3_array_ninf
outputs.a_texcoordf3_array_snan
outputs.a_texcoordf3_inf
outputs.a_texcoordf3_nan
outputs.a_texcoordf3_ninf
outputs.a_texcoordf3_snan
outputs.a_texcoordh2_array_inf
outputs.a_texcoordh2_array_nan
outputs.a_texcoordh2_array_ninf
outputs.a_texcoordh2_array_snan
outputs.a_texcoordh2_inf
outputs.a_texcoordh2_nan
outputs.a_texcoordh2_ninf
outputs.a_texcoordh2_snan
outputs.a_texcoordh3_array_inf
outputs.a_texcoordh3_array_nan
outputs.a_texcoordh3_array_ninf
outputs.a_texcoordh3_array_snan
outputs.a_texcoordh3_inf
outputs.a_texcoordh3_nan
outputs.a_texcoordh3_ninf
outputs.a_texcoordh3_snan
outputs.a_timecode_array_inf
outputs.a_timecode_array_nan
outputs.a_timecode_array_ninf
outputs.a_timecode_array_snan
outputs.a_timecode_inf
outputs.a_timecode_nan
outputs.a_timecode_ninf
outputs.a_timecode_snan
outputs.a_vectord3_array_inf
outputs.a_vectord3_array_nan
outputs.a_vectord3_array_ninf
outputs.a_vectord3_array_snan
outputs.a_vectord3_inf
outputs.a_vectord3_nan
outputs.a_vectord3_ninf
outputs.a_vectord3_snan
outputs.a_vectorf3_array_inf
outputs.a_vectorf3_array_nan
outputs.a_vectorf3_array_ninf
outputs.a_vectorf3_array_snan
outputs.a_vectorf3_inf
outputs.a_vectorf3_nan
outputs.a_vectorf3_ninf
outputs.a_vectorf3_snan
outputs.a_vectorh3_array_inf
outputs.a_vectorh3_array_nan
outputs.a_vectorh3_array_ninf
outputs.a_vectorh3_array_snan
outputs.a_vectorh3_inf
outputs.a_vectorh3_nan
outputs.a_vectorh3_ninf
outputs.a_vectorh3_snan
"""
# 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:a_colord3_array_inf', 'color3d[]', 0, None, 'colord3_array Infinity', {ogn.MetadataKeys.DEFAULT: '[["inf", "inf", "inf"], ["inf", "inf", "inf"]]'}, True, [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False, ''),
('inputs:a_colord3_array_nan', 'color3d[]', 0, None, 'colord3_array NaN', {ogn.MetadataKeys.DEFAULT: '[["nan", "nan", "nan"], ["nan", "nan", "nan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_colord3_array_ninf', 'color3d[]', 0, None, 'colord3_array -Infinity', {ogn.MetadataKeys.DEFAULT: '[["-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf"]]'}, True, [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False, ''),
('inputs:a_colord3_array_snan', 'color3d[]', 0, None, 'colord3_array sNaN', {ogn.MetadataKeys.DEFAULT: '[["snan", "snan", "snan"], ["snan", "snan", "snan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_colord3_inf', 'color3d', 0, None, 'colord3 Infinity', {ogn.MetadataKeys.DEFAULT: '["inf", "inf", "inf"]'}, True, [float("Inf"), float("Inf"), float("Inf")], False, ''),
('inputs:a_colord3_nan', 'color3d', 0, None, 'colord3 NaN', {ogn.MetadataKeys.DEFAULT: '["nan", "nan", "nan"]'}, True, [float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_colord3_ninf', 'color3d', 0, None, 'colord3 -Infinity', {ogn.MetadataKeys.DEFAULT: '["-inf", "-inf", "-inf"]'}, True, [float("-Inf"), float("-Inf"), float("-Inf")], False, ''),
('inputs:a_colord3_snan', 'color3d', 0, None, 'colord3 sNaN', {ogn.MetadataKeys.DEFAULT: '["snan", "snan", "snan"]'}, True, [float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_colord4_array_inf', 'color4d[]', 0, None, 'colord4_array Infinity', {ogn.MetadataKeys.DEFAULT: '[["inf", "inf", "inf", "inf"], ["inf", "inf", "inf", "inf"]]'}, True, [[float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")]], False, ''),
('inputs:a_colord4_array_nan', 'color4d[]', 0, None, 'colord4_array NaN', {ogn.MetadataKeys.DEFAULT: '[["nan", "nan", "nan", "nan"], ["nan", "nan", "nan", "nan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_colord4_array_ninf', 'color4d[]', 0, None, 'colord4_array -Infinity', {ogn.MetadataKeys.DEFAULT: '[["-inf", "-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf", "-inf"]]'}, True, [[float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")]], False, ''),
('inputs:a_colord4_array_snan', 'color4d[]', 0, None, 'colord4_array sNaN', {ogn.MetadataKeys.DEFAULT: '[["snan", "snan", "snan", "snan"], ["snan", "snan", "snan", "snan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_colord4_inf', 'color4d', 0, None, 'colord4 Infinity', {ogn.MetadataKeys.DEFAULT: '["inf", "inf", "inf", "inf"]'}, True, [float("Inf"), float("Inf"), float("Inf"), float("Inf")], False, ''),
('inputs:a_colord4_nan', 'color4d', 0, None, 'colord4 NaN', {ogn.MetadataKeys.DEFAULT: '["nan", "nan", "nan", "nan"]'}, True, [float("NaN"), float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_colord4_ninf', 'color4d', 0, None, 'colord4 -Infinity', {ogn.MetadataKeys.DEFAULT: '["-inf", "-inf", "-inf", "-inf"]'}, True, [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], False, ''),
('inputs:a_colord4_snan', 'color4d', 0, None, 'colord4 sNaN', {ogn.MetadataKeys.DEFAULT: '["snan", "snan", "snan", "snan"]'}, True, [float("NaN"), float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_colorf3_array_inf', 'color3f[]', 0, None, 'colorf3_array Infinity', {ogn.MetadataKeys.DEFAULT: '[["inf", "inf", "inf"], ["inf", "inf", "inf"]]'}, True, [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False, ''),
('inputs:a_colorf3_array_nan', 'color3f[]', 0, None, 'colorf3_array NaN', {ogn.MetadataKeys.DEFAULT: '[["nan", "nan", "nan"], ["nan", "nan", "nan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_colorf3_array_ninf', 'color3f[]', 0, None, 'colorf3_array -Infinity', {ogn.MetadataKeys.DEFAULT: '[["-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf"]]'}, True, [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False, ''),
('inputs:a_colorf3_array_snan', 'color3f[]', 0, None, 'colorf3_array sNaN', {ogn.MetadataKeys.DEFAULT: '[["snan", "snan", "snan"], ["snan", "snan", "snan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_colorf3_inf', 'color3f', 0, None, 'colorf3 Infinity', {ogn.MetadataKeys.DEFAULT: '["inf", "inf", "inf"]'}, True, [float("Inf"), float("Inf"), float("Inf")], False, ''),
('inputs:a_colorf3_nan', 'color3f', 0, None, 'colorf3 NaN', {ogn.MetadataKeys.DEFAULT: '["nan", "nan", "nan"]'}, True, [float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_colorf3_ninf', 'color3f', 0, None, 'colorf3 -Infinity', {ogn.MetadataKeys.DEFAULT: '["-inf", "-inf", "-inf"]'}, True, [float("-Inf"), float("-Inf"), float("-Inf")], False, ''),
('inputs:a_colorf3_snan', 'color3f', 0, None, 'colorf3 sNaN', {ogn.MetadataKeys.DEFAULT: '["snan", "snan", "snan"]'}, True, [float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_colorf4_array_inf', 'color4f[]', 0, None, 'colorf4_array Infinity', {ogn.MetadataKeys.DEFAULT: '[["inf", "inf", "inf", "inf"], ["inf", "inf", "inf", "inf"]]'}, True, [[float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")]], False, ''),
('inputs:a_colorf4_array_nan', 'color4f[]', 0, None, 'colorf4_array NaN', {ogn.MetadataKeys.DEFAULT: '[["nan", "nan", "nan", "nan"], ["nan", "nan", "nan", "nan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_colorf4_array_ninf', 'color4f[]', 0, None, 'colorf4_array -Infinity', {ogn.MetadataKeys.DEFAULT: '[["-inf", "-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf", "-inf"]]'}, True, [[float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")]], False, ''),
('inputs:a_colorf4_array_snan', 'color4f[]', 0, None, 'colorf4_array sNaN', {ogn.MetadataKeys.DEFAULT: '[["snan", "snan", "snan", "snan"], ["snan", "snan", "snan", "snan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_colorf4_inf', 'color4f', 0, None, 'colorf4 Infinity', {ogn.MetadataKeys.DEFAULT: '["inf", "inf", "inf", "inf"]'}, True, [float("Inf"), float("Inf"), float("Inf"), float("Inf")], False, ''),
('inputs:a_colorf4_nan', 'color4f', 0, None, 'colorf4 NaN', {ogn.MetadataKeys.DEFAULT: '["nan", "nan", "nan", "nan"]'}, True, [float("NaN"), float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_colorf4_ninf', 'color4f', 0, None, 'colorf4 -Infinity', {ogn.MetadataKeys.DEFAULT: '["-inf", "-inf", "-inf", "-inf"]'}, True, [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], False, ''),
('inputs:a_colorf4_snan', 'color4f', 0, None, 'colorf4 sNaN', {ogn.MetadataKeys.DEFAULT: '["snan", "snan", "snan", "snan"]'}, True, [float("NaN"), float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_colorh3_array_inf', 'color3h[]', 0, None, 'colorh3_array Infinity', {ogn.MetadataKeys.DEFAULT: '[["inf", "inf", "inf"], ["inf", "inf", "inf"]]'}, True, [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False, ''),
('inputs:a_colorh3_array_nan', 'color3h[]', 0, None, 'colorh3_array NaN', {ogn.MetadataKeys.DEFAULT: '[["nan", "nan", "nan"], ["nan", "nan", "nan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_colorh3_array_ninf', 'color3h[]', 0, None, 'colorh3_array -Infinity', {ogn.MetadataKeys.DEFAULT: '[["-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf"]]'}, True, [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False, ''),
('inputs:a_colorh3_array_snan', 'color3h[]', 0, None, 'colorh3_array sNaN', {ogn.MetadataKeys.DEFAULT: '[["snan", "snan", "snan"], ["snan", "snan", "snan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_colorh3_inf', 'color3h', 0, None, 'colorh3 Infinity', {ogn.MetadataKeys.DEFAULT: '["inf", "inf", "inf"]'}, True, [float("Inf"), float("Inf"), float("Inf")], False, ''),
('inputs:a_colorh3_nan', 'color3h', 0, None, 'colorh3 NaN', {ogn.MetadataKeys.DEFAULT: '["nan", "nan", "nan"]'}, True, [float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_colorh3_ninf', 'color3h', 0, None, 'colorh3 -Infinity', {ogn.MetadataKeys.DEFAULT: '["-inf", "-inf", "-inf"]'}, True, [float("-Inf"), float("-Inf"), float("-Inf")], False, ''),
('inputs:a_colorh3_snan', 'color3h', 0, None, 'colorh3 sNaN', {ogn.MetadataKeys.DEFAULT: '["snan", "snan", "snan"]'}, True, [float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_colorh4_array_inf', 'color4h[]', 0, None, 'colorh4_array Infinity', {ogn.MetadataKeys.DEFAULT: '[["inf", "inf", "inf", "inf"], ["inf", "inf", "inf", "inf"]]'}, True, [[float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")]], False, ''),
('inputs:a_colorh4_array_nan', 'color4h[]', 0, None, 'colorh4_array NaN', {ogn.MetadataKeys.DEFAULT: '[["nan", "nan", "nan", "nan"], ["nan", "nan", "nan", "nan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_colorh4_array_ninf', 'color4h[]', 0, None, 'colorh4_array -Infinity', {ogn.MetadataKeys.DEFAULT: '[["-inf", "-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf", "-inf"]]'}, True, [[float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")]], False, ''),
('inputs:a_colorh4_array_snan', 'color4h[]', 0, None, 'colorh4_array sNaN', {ogn.MetadataKeys.DEFAULT: '[["snan", "snan", "snan", "snan"], ["snan", "snan", "snan", "snan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_colorh4_inf', 'color4h', 0, None, 'colorh4 Infinity', {ogn.MetadataKeys.DEFAULT: '["inf", "inf", "inf", "inf"]'}, True, [float("Inf"), float("Inf"), float("Inf"), float("Inf")], False, ''),
('inputs:a_colorh4_nan', 'color4h', 0, None, 'colorh4 NaN', {ogn.MetadataKeys.DEFAULT: '["nan", "nan", "nan", "nan"]'}, True, [float("NaN"), float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_colorh4_ninf', 'color4h', 0, None, 'colorh4 -Infinity', {ogn.MetadataKeys.DEFAULT: '["-inf", "-inf", "-inf", "-inf"]'}, True, [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], False, ''),
('inputs:a_colorh4_snan', 'color4h', 0, None, 'colorh4 sNaN', {ogn.MetadataKeys.DEFAULT: '["snan", "snan", "snan", "snan"]'}, True, [float("NaN"), float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_double2_array_inf', 'double2[]', 0, None, 'double2_array Infinity', {ogn.MetadataKeys.DEFAULT: '[["inf", "inf"], ["inf", "inf"]]'}, True, [[float("Inf"), float("Inf")], [float("Inf"), float("Inf")]], False, ''),
('inputs:a_double2_array_nan', 'double2[]', 0, None, 'double2_array NaN', {ogn.MetadataKeys.DEFAULT: '[["nan", "nan"], ["nan", "nan"]]'}, True, [[float("NaN"), float("NaN")], [float("NaN"), float("NaN")]], False, ''),
('inputs:a_double2_array_ninf', 'double2[]', 0, None, 'double2_array -Infinity', {ogn.MetadataKeys.DEFAULT: '[["-inf", "-inf"], ["-inf", "-inf"]]'}, True, [[float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf")]], False, ''),
('inputs:a_double2_array_snan', 'double2[]', 0, None, 'double2_array sNaN', {ogn.MetadataKeys.DEFAULT: '[["snan", "snan"], ["snan", "snan"]]'}, True, [[float("NaN"), float("NaN")], [float("NaN"), float("NaN")]], False, ''),
('inputs:a_double2_inf', 'double2', 0, None, 'double2 Infinity', {ogn.MetadataKeys.DEFAULT: '["inf", "inf"]'}, True, [float("Inf"), float("Inf")], False, ''),
('inputs:a_double2_nan', 'double2', 0, None, 'double2 NaN', {ogn.MetadataKeys.DEFAULT: '["nan", "nan"]'}, True, [float("NaN"), float("NaN")], False, ''),
('inputs:a_double2_ninf', 'double2', 0, None, 'double2 -Infinity', {ogn.MetadataKeys.DEFAULT: '["-inf", "-inf"]'}, True, [float("-Inf"), float("-Inf")], False, ''),
('inputs:a_double2_snan', 'double2', 0, None, 'double2 sNaN', {ogn.MetadataKeys.DEFAULT: '["snan", "snan"]'}, True, [float("NaN"), float("NaN")], False, ''),
('inputs:a_double3_array_inf', 'double3[]', 0, None, 'double3_array Infinity', {ogn.MetadataKeys.DEFAULT: '[["inf", "inf", "inf"], ["inf", "inf", "inf"]]'}, True, [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False, ''),
('inputs:a_double3_array_nan', 'double3[]', 0, None, 'double3_array NaN', {ogn.MetadataKeys.DEFAULT: '[["nan", "nan", "nan"], ["nan", "nan", "nan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_double3_array_ninf', 'double3[]', 0, None, 'double3_array -Infinity', {ogn.MetadataKeys.DEFAULT: '[["-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf"]]'}, True, [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False, ''),
('inputs:a_double3_array_snan', 'double3[]', 0, None, 'double3_array sNaN', {ogn.MetadataKeys.DEFAULT: '[["snan", "snan", "snan"], ["snan", "snan", "snan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_double3_inf', 'double3', 0, None, 'double3 Infinity', {ogn.MetadataKeys.DEFAULT: '["inf", "inf", "inf"]'}, True, [float("Inf"), float("Inf"), float("Inf")], False, ''),
('inputs:a_double3_nan', 'double3', 0, None, 'double3 NaN', {ogn.MetadataKeys.DEFAULT: '["nan", "nan", "nan"]'}, True, [float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_double3_ninf', 'double3', 0, None, 'double3 -Infinity', {ogn.MetadataKeys.DEFAULT: '["-inf", "-inf", "-inf"]'}, True, [float("-Inf"), float("-Inf"), float("-Inf")], False, ''),
('inputs:a_double3_snan', 'double3', 0, None, 'double3 sNaN', {ogn.MetadataKeys.DEFAULT: '["snan", "snan", "snan"]'}, True, [float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_double4_array_inf', 'double4[]', 0, None, 'double4_array Infinity', {ogn.MetadataKeys.DEFAULT: '[["inf", "inf", "inf", "inf"], ["inf", "inf", "inf", "inf"]]'}, True, [[float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")]], False, ''),
('inputs:a_double4_array_nan', 'double4[]', 0, None, 'double4_array NaN', {ogn.MetadataKeys.DEFAULT: '[["nan", "nan", "nan", "nan"], ["nan", "nan", "nan", "nan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_double4_array_ninf', 'double4[]', 0, None, 'double4_array -Infinity', {ogn.MetadataKeys.DEFAULT: '[["-inf", "-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf", "-inf"]]'}, True, [[float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")]], False, ''),
('inputs:a_double4_array_snan', 'double4[]', 0, None, 'double4_array sNaN', {ogn.MetadataKeys.DEFAULT: '[["snan", "snan", "snan", "snan"], ["snan", "snan", "snan", "snan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_double4_inf', 'double4', 0, None, 'double4 Infinity', {ogn.MetadataKeys.DEFAULT: '["inf", "inf", "inf", "inf"]'}, True, [float("Inf"), float("Inf"), float("Inf"), float("Inf")], False, ''),
('inputs:a_double4_nan', 'double4', 0, None, 'double4 NaN', {ogn.MetadataKeys.DEFAULT: '["nan", "nan", "nan", "nan"]'}, True, [float("NaN"), float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_double4_ninf', 'double4', 0, None, 'double4 -Infinity', {ogn.MetadataKeys.DEFAULT: '["-inf", "-inf", "-inf", "-inf"]'}, True, [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], False, ''),
('inputs:a_double4_snan', 'double4', 0, None, 'double4 sNaN', {ogn.MetadataKeys.DEFAULT: '["snan", "snan", "snan", "snan"]'}, True, [float("NaN"), float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_double_array_inf', 'double[]', 0, None, 'double_array Infinity', {ogn.MetadataKeys.DEFAULT: '["inf", "inf"]'}, True, [float("Inf"), float("Inf")], False, ''),
('inputs:a_double_array_nan', 'double[]', 0, None, 'double_array NaN', {ogn.MetadataKeys.DEFAULT: '["nan", "nan"]'}, True, [float("NaN"), float("NaN")], False, ''),
('inputs:a_double_array_ninf', 'double[]', 0, None, 'double_array -Infinity', {ogn.MetadataKeys.DEFAULT: '["-inf", "-inf"]'}, True, [float("-Inf"), float("-Inf")], False, ''),
('inputs:a_double_array_snan', 'double[]', 0, None, 'double_array sNaN', {ogn.MetadataKeys.DEFAULT: '["snan", "snan"]'}, True, [float("NaN"), float("NaN")], False, ''),
('inputs:a_double_inf', 'double', 0, None, 'double Infinity', {ogn.MetadataKeys.DEFAULT: '"inf"'}, True, float("Inf"), False, ''),
('inputs:a_double_nan', 'double', 0, None, 'double NaN', {ogn.MetadataKeys.DEFAULT: '"nan"'}, True, float("NaN"), False, ''),
('inputs:a_double_ninf', 'double', 0, None, 'double -Infinity', {ogn.MetadataKeys.DEFAULT: '"-inf"'}, True, float("-Inf"), False, ''),
('inputs:a_double_snan', 'double', 0, None, 'double sNaN', {ogn.MetadataKeys.DEFAULT: '"snan"'}, True, float("NaN"), False, ''),
('inputs:a_float2_array_inf', 'float2[]', 0, None, 'float2_array Infinity', {ogn.MetadataKeys.DEFAULT: '[["inf", "inf"], ["inf", "inf"]]'}, True, [[float("Inf"), float("Inf")], [float("Inf"), float("Inf")]], False, ''),
('inputs:a_float2_array_nan', 'float2[]', 0, None, 'float2_array NaN', {ogn.MetadataKeys.DEFAULT: '[["nan", "nan"], ["nan", "nan"]]'}, True, [[float("NaN"), float("NaN")], [float("NaN"), float("NaN")]], False, ''),
('inputs:a_float2_array_ninf', 'float2[]', 0, None, 'float2_array -Infinity', {ogn.MetadataKeys.DEFAULT: '[["-inf", "-inf"], ["-inf", "-inf"]]'}, True, [[float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf")]], False, ''),
('inputs:a_float2_array_snan', 'float2[]', 0, None, 'float2_array sNaN', {ogn.MetadataKeys.DEFAULT: '[["snan", "snan"], ["snan", "snan"]]'}, True, [[float("NaN"), float("NaN")], [float("NaN"), float("NaN")]], False, ''),
('inputs:a_float2_inf', 'float2', 0, None, 'float2 Infinity', {ogn.MetadataKeys.DEFAULT: '["inf", "inf"]'}, True, [float("Inf"), float("Inf")], False, ''),
('inputs:a_float2_nan', 'float2', 0, None, 'float2 NaN', {ogn.MetadataKeys.DEFAULT: '["nan", "nan"]'}, True, [float("NaN"), float("NaN")], False, ''),
('inputs:a_float2_ninf', 'float2', 0, None, 'float2 -Infinity', {ogn.MetadataKeys.DEFAULT: '["-inf", "-inf"]'}, True, [float("-Inf"), float("-Inf")], False, ''),
('inputs:a_float2_snan', 'float2', 0, None, 'float2 sNaN', {ogn.MetadataKeys.DEFAULT: '["snan", "snan"]'}, True, [float("NaN"), float("NaN")], False, ''),
('inputs:a_float3_array_inf', 'float3[]', 0, None, 'float3_array Infinity', {ogn.MetadataKeys.DEFAULT: '[["inf", "inf", "inf"], ["inf", "inf", "inf"]]'}, True, [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False, ''),
('inputs:a_float3_array_nan', 'float3[]', 0, None, 'float3_array NaN', {ogn.MetadataKeys.DEFAULT: '[["nan", "nan", "nan"], ["nan", "nan", "nan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_float3_array_ninf', 'float3[]', 0, None, 'float3_array -Infinity', {ogn.MetadataKeys.DEFAULT: '[["-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf"]]'}, True, [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False, ''),
('inputs:a_float3_array_snan', 'float3[]', 0, None, 'float3_array sNaN', {ogn.MetadataKeys.DEFAULT: '[["snan", "snan", "snan"], ["snan", "snan", "snan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_float3_inf', 'float3', 0, None, 'float3 Infinity', {ogn.MetadataKeys.DEFAULT: '["inf", "inf", "inf"]'}, True, [float("Inf"), float("Inf"), float("Inf")], False, ''),
('inputs:a_float3_nan', 'float3', 0, None, 'float3 NaN', {ogn.MetadataKeys.DEFAULT: '["nan", "nan", "nan"]'}, True, [float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_float3_ninf', 'float3', 0, None, 'float3 -Infinity', {ogn.MetadataKeys.DEFAULT: '["-inf", "-inf", "-inf"]'}, True, [float("-Inf"), float("-Inf"), float("-Inf")], False, ''),
('inputs:a_float3_snan', 'float3', 0, None, 'float3 sNaN', {ogn.MetadataKeys.DEFAULT: '["snan", "snan", "snan"]'}, True, [float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_float4_array_inf', 'float4[]', 0, None, 'float4_array Infinity', {ogn.MetadataKeys.DEFAULT: '[["inf", "inf", "inf", "inf"], ["inf", "inf", "inf", "inf"]]'}, True, [[float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")]], False, ''),
('inputs:a_float4_array_nan', 'float4[]', 0, None, 'float4_array NaN', {ogn.MetadataKeys.DEFAULT: '[["nan", "nan", "nan", "nan"], ["nan", "nan", "nan", "nan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_float4_array_ninf', 'float4[]', 0, None, 'float4_array -Infinity', {ogn.MetadataKeys.DEFAULT: '[["-inf", "-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf", "-inf"]]'}, True, [[float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")]], False, ''),
('inputs:a_float4_array_snan', 'float4[]', 0, None, 'float4_array sNaN', {ogn.MetadataKeys.DEFAULT: '[["snan", "snan", "snan", "snan"], ["snan", "snan", "snan", "snan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_float4_inf', 'float4', 0, None, 'float4 Infinity', {ogn.MetadataKeys.DEFAULT: '["inf", "inf", "inf", "inf"]'}, True, [float("Inf"), float("Inf"), float("Inf"), float("Inf")], False, ''),
('inputs:a_float4_nan', 'float4', 0, None, 'float4 NaN', {ogn.MetadataKeys.DEFAULT: '["nan", "nan", "nan", "nan"]'}, True, [float("NaN"), float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_float4_ninf', 'float4', 0, None, 'float4 -Infinity', {ogn.MetadataKeys.DEFAULT: '["-inf", "-inf", "-inf", "-inf"]'}, True, [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], False, ''),
('inputs:a_float4_snan', 'float4', 0, None, 'float4 sNaN', {ogn.MetadataKeys.DEFAULT: '["snan", "snan", "snan", "snan"]'}, True, [float("NaN"), float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_float_array_inf', 'float[]', 0, None, 'float_array Infinity', {ogn.MetadataKeys.DEFAULT: '["inf", "inf"]'}, True, [float("Inf"), float("Inf")], False, ''),
('inputs:a_float_array_nan', 'float[]', 0, None, 'float_array NaN', {ogn.MetadataKeys.DEFAULT: '["nan", "nan"]'}, True, [float("NaN"), float("NaN")], False, ''),
('inputs:a_float_array_ninf', 'float[]', 0, None, 'float_array -Infinity', {ogn.MetadataKeys.DEFAULT: '["-inf", "-inf"]'}, True, [float("-Inf"), float("-Inf")], False, ''),
('inputs:a_float_array_snan', 'float[]', 0, None, 'float_array sNaN', {ogn.MetadataKeys.DEFAULT: '["snan", "snan"]'}, True, [float("NaN"), float("NaN")], False, ''),
('inputs:a_float_inf', 'float', 0, None, 'float Infinity', {ogn.MetadataKeys.DEFAULT: '"inf"'}, True, float("Inf"), False, ''),
('inputs:a_float_nan', 'float', 0, None, 'float NaN', {ogn.MetadataKeys.DEFAULT: '"nan"'}, True, float("NaN"), False, ''),
('inputs:a_float_ninf', 'float', 0, None, 'float -Infinity', {ogn.MetadataKeys.DEFAULT: '"-inf"'}, True, float("-Inf"), False, ''),
('inputs:a_float_snan', 'float', 0, None, 'float sNaN', {ogn.MetadataKeys.DEFAULT: '"snan"'}, True, float("NaN"), False, ''),
('inputs:a_frame4_array_inf', 'frame4d[]', 0, None, 'frame4_array Infinity', {ogn.MetadataKeys.DEFAULT: '[[["inf", "inf", "inf", "inf"], ["inf", "inf", "inf", "inf"], ["inf", "inf", "inf", "inf"], ["inf", "inf", "inf", "inf"]], [["inf", "inf", "inf", "inf"], ["inf", "inf", "inf", "inf"], ["inf", "inf", "inf", "inf"], ["inf", "inf", "inf", "inf"]]]'}, True, [[[float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")]], [[float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")]]], False, ''),
('inputs:a_frame4_array_nan', 'frame4d[]', 0, None, 'frame4_array NaN', {ogn.MetadataKeys.DEFAULT: '[[["nan", "nan", "nan", "nan"], ["nan", "nan", "nan", "nan"], ["nan", "nan", "nan", "nan"], ["nan", "nan", "nan", "nan"]], [["nan", "nan", "nan", "nan"], ["nan", "nan", "nan", "nan"], ["nan", "nan", "nan", "nan"], ["nan", "nan", "nan", "nan"]]]'}, True, [[[float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")]], [[float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")]]], False, ''),
('inputs:a_frame4_array_ninf', 'frame4d[]', 0, None, 'frame4_array -Infinity', {ogn.MetadataKeys.DEFAULT: '[[["-inf", "-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf", "-inf"]], [["-inf", "-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf", "-inf"]]]'}, True, [[[float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")]], [[float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")]]], False, ''),
('inputs:a_frame4_array_snan', 'frame4d[]', 0, None, 'frame4_array sNaN', {ogn.MetadataKeys.DEFAULT: '[[["snan", "snan", "snan", "snan"], ["snan", "snan", "snan", "snan"], ["snan", "snan", "snan", "snan"], ["snan", "snan", "snan", "snan"]], [["snan", "snan", "snan", "snan"], ["snan", "snan", "snan", "snan"], ["snan", "snan", "snan", "snan"], ["snan", "snan", "snan", "snan"]]]'}, True, [[[float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")]], [[float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")]]], False, ''),
('inputs:a_frame4_inf', 'frame4d', 0, None, 'frame4 Infinity', {ogn.MetadataKeys.DEFAULT: '[["inf", "inf", "inf", "inf"], ["inf", "inf", "inf", "inf"], ["inf", "inf", "inf", "inf"], ["inf", "inf", "inf", "inf"]]'}, True, [[float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")]], False, ''),
('inputs:a_frame4_nan', 'frame4d', 0, None, 'frame4 NaN', {ogn.MetadataKeys.DEFAULT: '[["nan", "nan", "nan", "nan"], ["nan", "nan", "nan", "nan"], ["nan", "nan", "nan", "nan"], ["nan", "nan", "nan", "nan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_frame4_ninf', 'frame4d', 0, None, 'frame4 -Infinity', {ogn.MetadataKeys.DEFAULT: '[["-inf", "-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf", "-inf"]]'}, True, [[float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")]], False, ''),
('inputs:a_frame4_snan', 'frame4d', 0, None, 'frame4 sNaN', {ogn.MetadataKeys.DEFAULT: '[["snan", "snan", "snan", "snan"], ["snan", "snan", "snan", "snan"], ["snan", "snan", "snan", "snan"], ["snan", "snan", "snan", "snan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_half2_array_inf', 'half2[]', 0, None, 'half2_array Infinity', {ogn.MetadataKeys.DEFAULT: '[["inf", "inf"], ["inf", "inf"]]'}, True, [[float("Inf"), float("Inf")], [float("Inf"), float("Inf")]], False, ''),
('inputs:a_half2_array_nan', 'half2[]', 0, None, 'half2_array NaN', {ogn.MetadataKeys.DEFAULT: '[["nan", "nan"], ["nan", "nan"]]'}, True, [[float("NaN"), float("NaN")], [float("NaN"), float("NaN")]], False, ''),
('inputs:a_half2_array_ninf', 'half2[]', 0, None, 'half2_array -Infinity', {ogn.MetadataKeys.DEFAULT: '[["-inf", "-inf"], ["-inf", "-inf"]]'}, True, [[float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf")]], False, ''),
('inputs:a_half2_array_snan', 'half2[]', 0, None, 'half2_array sNaN', {ogn.MetadataKeys.DEFAULT: '[["snan", "snan"], ["snan", "snan"]]'}, True, [[float("NaN"), float("NaN")], [float("NaN"), float("NaN")]], False, ''),
('inputs:a_half2_inf', 'half2', 0, None, 'half2 Infinity', {ogn.MetadataKeys.DEFAULT: '["inf", "inf"]'}, True, [float("Inf"), float("Inf")], False, ''),
('inputs:a_half2_nan', 'half2', 0, None, 'half2 NaN', {ogn.MetadataKeys.DEFAULT: '["nan", "nan"]'}, True, [float("NaN"), float("NaN")], False, ''),
('inputs:a_half2_ninf', 'half2', 0, None, 'half2 -Infinity', {ogn.MetadataKeys.DEFAULT: '["-inf", "-inf"]'}, True, [float("-Inf"), float("-Inf")], False, ''),
('inputs:a_half2_snan', 'half2', 0, None, 'half2 sNaN', {ogn.MetadataKeys.DEFAULT: '["snan", "snan"]'}, True, [float("NaN"), float("NaN")], False, ''),
('inputs:a_half3_array_inf', 'half3[]', 0, None, 'half3_array Infinity', {ogn.MetadataKeys.DEFAULT: '[["inf", "inf", "inf"], ["inf", "inf", "inf"]]'}, True, [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False, ''),
('inputs:a_half3_array_nan', 'half3[]', 0, None, 'half3_array NaN', {ogn.MetadataKeys.DEFAULT: '[["nan", "nan", "nan"], ["nan", "nan", "nan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_half3_array_ninf', 'half3[]', 0, None, 'half3_array -Infinity', {ogn.MetadataKeys.DEFAULT: '[["-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf"]]'}, True, [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False, ''),
('inputs:a_half3_array_snan', 'half3[]', 0, None, 'half3_array sNaN', {ogn.MetadataKeys.DEFAULT: '[["snan", "snan", "snan"], ["snan", "snan", "snan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_half3_inf', 'half3', 0, None, 'half3 Infinity', {ogn.MetadataKeys.DEFAULT: '["inf", "inf", "inf"]'}, True, [float("Inf"), float("Inf"), float("Inf")], False, ''),
('inputs:a_half3_nan', 'half3', 0, None, 'half3 NaN', {ogn.MetadataKeys.DEFAULT: '["nan", "nan", "nan"]'}, True, [float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_half3_ninf', 'half3', 0, None, 'half3 -Infinity', {ogn.MetadataKeys.DEFAULT: '["-inf", "-inf", "-inf"]'}, True, [float("-Inf"), float("-Inf"), float("-Inf")], False, ''),
('inputs:a_half3_snan', 'half3', 0, None, 'half3 sNaN', {ogn.MetadataKeys.DEFAULT: '["snan", "snan", "snan"]'}, True, [float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_half4_array_inf', 'half4[]', 0, None, 'half4_array Infinity', {ogn.MetadataKeys.DEFAULT: '[["inf", "inf", "inf", "inf"], ["inf", "inf", "inf", "inf"]]'}, True, [[float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")]], False, ''),
('inputs:a_half4_array_nan', 'half4[]', 0, None, 'half4_array NaN', {ogn.MetadataKeys.DEFAULT: '[["nan", "nan", "nan", "nan"], ["nan", "nan", "nan", "nan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_half4_array_ninf', 'half4[]', 0, None, 'half4_array -Infinity', {ogn.MetadataKeys.DEFAULT: '[["-inf", "-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf", "-inf"]]'}, True, [[float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")]], False, ''),
('inputs:a_half4_array_snan', 'half4[]', 0, None, 'half4_array sNaN', {ogn.MetadataKeys.DEFAULT: '[["snan", "snan", "snan", "snan"], ["snan", "snan", "snan", "snan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_half4_inf', 'half4', 0, None, 'half4 Infinity', {ogn.MetadataKeys.DEFAULT: '["inf", "inf", "inf", "inf"]'}, True, [float("Inf"), float("Inf"), float("Inf"), float("Inf")], False, ''),
('inputs:a_half4_nan', 'half4', 0, None, 'half4 NaN', {ogn.MetadataKeys.DEFAULT: '["nan", "nan", "nan", "nan"]'}, True, [float("NaN"), float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_half4_ninf', 'half4', 0, None, 'half4 -Infinity', {ogn.MetadataKeys.DEFAULT: '["-inf", "-inf", "-inf", "-inf"]'}, True, [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], False, ''),
('inputs:a_half4_snan', 'half4', 0, None, 'half4 sNaN', {ogn.MetadataKeys.DEFAULT: '["snan", "snan", "snan", "snan"]'}, True, [float("NaN"), float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_half_array_inf', 'half[]', 0, None, 'half_array Infinity', {ogn.MetadataKeys.DEFAULT: '["inf", "inf"]'}, True, [float("Inf"), float("Inf")], False, ''),
('inputs:a_half_array_nan', 'half[]', 0, None, 'half_array NaN', {ogn.MetadataKeys.DEFAULT: '["nan", "nan"]'}, True, [float("NaN"), float("NaN")], False, ''),
('inputs:a_half_array_ninf', 'half[]', 0, None, 'half_array -Infinity', {ogn.MetadataKeys.DEFAULT: '["-inf", "-inf"]'}, True, [float("-Inf"), float("-Inf")], False, ''),
('inputs:a_half_array_snan', 'half[]', 0, None, 'half_array sNaN', {ogn.MetadataKeys.DEFAULT: '["snan", "snan"]'}, True, [float("NaN"), float("NaN")], False, ''),
('inputs:a_half_inf', 'half', 0, None, 'half Infinity', {ogn.MetadataKeys.DEFAULT: '"inf"'}, True, float("Inf"), False, ''),
('inputs:a_half_nan', 'half', 0, None, 'half NaN', {ogn.MetadataKeys.DEFAULT: '"nan"'}, True, float("NaN"), False, ''),
('inputs:a_half_ninf', 'half', 0, None, 'half -Infinity', {ogn.MetadataKeys.DEFAULT: '"-inf"'}, True, float("-Inf"), False, ''),
('inputs:a_half_snan', 'half', 0, None, 'half sNaN', {ogn.MetadataKeys.DEFAULT: '"snan"'}, True, float("NaN"), False, ''),
('inputs:a_matrixd2_array_inf', 'matrix2d[]', 0, None, 'matrixd2_array Infinity', {ogn.MetadataKeys.DEFAULT: '[[["inf", "inf"], ["inf", "inf"]], [["inf", "inf"], ["inf", "inf"]]]'}, True, [[[float("Inf"), float("Inf")], [float("Inf"), float("Inf")]], [[float("Inf"), float("Inf")], [float("Inf"), float("Inf")]]], False, ''),
('inputs:a_matrixd2_array_nan', 'matrix2d[]', 0, None, 'matrixd2_array NaN', {ogn.MetadataKeys.DEFAULT: '[[["nan", "nan"], ["nan", "nan"]], [["nan", "nan"], ["nan", "nan"]]]'}, True, [[[float("NaN"), float("NaN")], [float("NaN"), float("NaN")]], [[float("NaN"), float("NaN")], [float("NaN"), float("NaN")]]], False, ''),
('inputs:a_matrixd2_array_ninf', 'matrix2d[]', 0, None, 'matrixd2_array -Infinity', {ogn.MetadataKeys.DEFAULT: '[[["-inf", "-inf"], ["-inf", "-inf"]], [["-inf", "-inf"], ["-inf", "-inf"]]]'}, True, [[[float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf")]], [[float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf")]]], False, ''),
('inputs:a_matrixd2_array_snan', 'matrix2d[]', 0, None, 'matrixd2_array sNaN', {ogn.MetadataKeys.DEFAULT: '[[["snan", "snan"], ["snan", "snan"]], [["snan", "snan"], ["snan", "snan"]]]'}, True, [[[float("NaN"), float("NaN")], [float("NaN"), float("NaN")]], [[float("NaN"), float("NaN")], [float("NaN"), float("NaN")]]], False, ''),
('inputs:a_matrixd2_inf', 'matrix2d', 0, None, 'matrixd2 Infinity', {ogn.MetadataKeys.DEFAULT: '[["inf", "inf"], ["inf", "inf"]]'}, True, [[float("Inf"), float("Inf")], [float("Inf"), float("Inf")]], False, ''),
('inputs:a_matrixd2_nan', 'matrix2d', 0, None, 'matrixd2 NaN', {ogn.MetadataKeys.DEFAULT: '[["nan", "nan"], ["nan", "nan"]]'}, True, [[float("NaN"), float("NaN")], [float("NaN"), float("NaN")]], False, ''),
('inputs:a_matrixd2_ninf', 'matrix2d', 0, None, 'matrixd2 -Infinity', {ogn.MetadataKeys.DEFAULT: '[["-inf", "-inf"], ["-inf", "-inf"]]'}, True, [[float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf")]], False, ''),
('inputs:a_matrixd2_snan', 'matrix2d', 0, None, 'matrixd2 sNaN', {ogn.MetadataKeys.DEFAULT: '[["snan", "snan"], ["snan", "snan"]]'}, True, [[float("NaN"), float("NaN")], [float("NaN"), float("NaN")]], False, ''),
('inputs:a_matrixd3_array_inf', 'matrix3d[]', 0, None, 'matrixd3_array Infinity', {ogn.MetadataKeys.DEFAULT: '[[["inf", "inf", "inf"], ["inf", "inf", "inf"], ["inf", "inf", "inf"]], [["inf", "inf", "inf"], ["inf", "inf", "inf"], ["inf", "inf", "inf"]]]'}, True, [[[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]]], False, ''),
('inputs:a_matrixd3_array_nan', 'matrix3d[]', 0, None, 'matrixd3_array NaN', {ogn.MetadataKeys.DEFAULT: '[[["nan", "nan", "nan"], ["nan", "nan", "nan"], ["nan", "nan", "nan"]], [["nan", "nan", "nan"], ["nan", "nan", "nan"], ["nan", "nan", "nan"]]]'}, True, [[[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]], [[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]]], False, ''),
('inputs:a_matrixd3_array_ninf', 'matrix3d[]', 0, None, 'matrixd3_array -Infinity', {ogn.MetadataKeys.DEFAULT: '[[["-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf"]], [["-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf"]]]'}, True, [[[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]]], False, ''),
('inputs:a_matrixd3_array_snan', 'matrix3d[]', 0, None, 'matrixd3_array sNaN', {ogn.MetadataKeys.DEFAULT: '[[["snan", "snan", "snan"], ["snan", "snan", "snan"], ["snan", "snan", "snan"]], [["snan", "snan", "snan"], ["snan", "snan", "snan"], ["snan", "snan", "snan"]]]'}, True, [[[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]], [[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]]], False, ''),
('inputs:a_matrixd3_inf', 'matrix3d', 0, None, 'matrixd3 Infinity', {ogn.MetadataKeys.DEFAULT: '[["inf", "inf", "inf"], ["inf", "inf", "inf"], ["inf", "inf", "inf"]]'}, True, [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False, ''),
('inputs:a_matrixd3_nan', 'matrix3d', 0, None, 'matrixd3 NaN', {ogn.MetadataKeys.DEFAULT: '[["nan", "nan", "nan"], ["nan", "nan", "nan"], ["nan", "nan", "nan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_matrixd3_ninf', 'matrix3d', 0, None, 'matrixd3 -Infinity', {ogn.MetadataKeys.DEFAULT: '[["-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf"]]'}, True, [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False, ''),
('inputs:a_matrixd3_snan', 'matrix3d', 0, None, 'matrixd3 sNaN', {ogn.MetadataKeys.DEFAULT: '[["snan", "snan", "snan"], ["snan", "snan", "snan"], ["snan", "snan", "snan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_matrixd4_array_inf', 'matrix4d[]', 0, None, 'matrixd4_array Infinity', {ogn.MetadataKeys.DEFAULT: '[[["inf", "inf", "inf", "inf"], ["inf", "inf", "inf", "inf"], ["inf", "inf", "inf", "inf"], ["inf", "inf", "inf", "inf"]], [["inf", "inf", "inf", "inf"], ["inf", "inf", "inf", "inf"], ["inf", "inf", "inf", "inf"], ["inf", "inf", "inf", "inf"]]]'}, True, [[[float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")]], [[float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")]]], False, ''),
('inputs:a_matrixd4_array_nan', 'matrix4d[]', 0, None, 'matrixd4_array NaN', {ogn.MetadataKeys.DEFAULT: '[[["nan", "nan", "nan", "nan"], ["nan", "nan", "nan", "nan"], ["nan", "nan", "nan", "nan"], ["nan", "nan", "nan", "nan"]], [["nan", "nan", "nan", "nan"], ["nan", "nan", "nan", "nan"], ["nan", "nan", "nan", "nan"], ["nan", "nan", "nan", "nan"]]]'}, True, [[[float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")]], [[float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")]]], False, ''),
('inputs:a_matrixd4_array_ninf', 'matrix4d[]', 0, None, 'matrixd4_array -Infinity', {ogn.MetadataKeys.DEFAULT: '[[["-inf", "-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf", "-inf"]], [["-inf", "-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf", "-inf"]]]'}, True, [[[float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")]], [[float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")]]], False, ''),
('inputs:a_matrixd4_array_snan', 'matrix4d[]', 0, None, 'matrixd4_array sNaN', {ogn.MetadataKeys.DEFAULT: '[[["snan", "snan", "snan", "snan"], ["snan", "snan", "snan", "snan"], ["snan", "snan", "snan", "snan"], ["snan", "snan", "snan", "snan"]], [["snan", "snan", "snan", "snan"], ["snan", "snan", "snan", "snan"], ["snan", "snan", "snan", "snan"], ["snan", "snan", "snan", "snan"]]]'}, True, [[[float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")]], [[float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")]]], False, ''),
('inputs:a_matrixd4_inf', 'matrix4d', 0, None, 'matrixd4 Infinity', {ogn.MetadataKeys.DEFAULT: '[["inf", "inf", "inf", "inf"], ["inf", "inf", "inf", "inf"], ["inf", "inf", "inf", "inf"], ["inf", "inf", "inf", "inf"]]'}, True, [[float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")]], False, ''),
('inputs:a_matrixd4_nan', 'matrix4d', 0, None, 'matrixd4 NaN', {ogn.MetadataKeys.DEFAULT: '[["nan", "nan", "nan", "nan"], ["nan", "nan", "nan", "nan"], ["nan", "nan", "nan", "nan"], ["nan", "nan", "nan", "nan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_matrixd4_ninf', 'matrix4d', 0, None, 'matrixd4 -Infinity', {ogn.MetadataKeys.DEFAULT: '[["-inf", "-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf", "-inf"]]'}, True, [[float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")]], False, ''),
('inputs:a_matrixd4_snan', 'matrix4d', 0, None, 'matrixd4 sNaN', {ogn.MetadataKeys.DEFAULT: '[["snan", "snan", "snan", "snan"], ["snan", "snan", "snan", "snan"], ["snan", "snan", "snan", "snan"], ["snan", "snan", "snan", "snan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_normald3_array_inf', 'normal3d[]', 0, None, 'normald3_array Infinity', {ogn.MetadataKeys.DEFAULT: '[["inf", "inf", "inf"], ["inf", "inf", "inf"]]'}, True, [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False, ''),
('inputs:a_normald3_array_nan', 'normal3d[]', 0, None, 'normald3_array NaN', {ogn.MetadataKeys.DEFAULT: '[["nan", "nan", "nan"], ["nan", "nan", "nan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_normald3_array_ninf', 'normal3d[]', 0, None, 'normald3_array -Infinity', {ogn.MetadataKeys.DEFAULT: '[["-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf"]]'}, True, [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False, ''),
('inputs:a_normald3_array_snan', 'normal3d[]', 0, None, 'normald3_array sNaN', {ogn.MetadataKeys.DEFAULT: '[["snan", "snan", "snan"], ["snan", "snan", "snan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_normald3_inf', 'normal3d', 0, None, 'normald3 Infinity', {ogn.MetadataKeys.DEFAULT: '["inf", "inf", "inf"]'}, True, [float("Inf"), float("Inf"), float("Inf")], False, ''),
('inputs:a_normald3_nan', 'normal3d', 0, None, 'normald3 NaN', {ogn.MetadataKeys.DEFAULT: '["nan", "nan", "nan"]'}, True, [float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_normald3_ninf', 'normal3d', 0, None, 'normald3 -Infinity', {ogn.MetadataKeys.DEFAULT: '["-inf", "-inf", "-inf"]'}, True, [float("-Inf"), float("-Inf"), float("-Inf")], False, ''),
('inputs:a_normald3_snan', 'normal3d', 0, None, 'normald3 sNaN', {ogn.MetadataKeys.DEFAULT: '["snan", "snan", "snan"]'}, True, [float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_normalf3_array_inf', 'normal3f[]', 0, None, 'normalf3_array Infinity', {ogn.MetadataKeys.DEFAULT: '[["inf", "inf", "inf"], ["inf", "inf", "inf"]]'}, True, [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False, ''),
('inputs:a_normalf3_array_nan', 'normal3f[]', 0, None, 'normalf3_array NaN', {ogn.MetadataKeys.DEFAULT: '[["nan", "nan", "nan"], ["nan", "nan", "nan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_normalf3_array_ninf', 'normal3f[]', 0, None, 'normalf3_array -Infinity', {ogn.MetadataKeys.DEFAULT: '[["-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf"]]'}, True, [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False, ''),
('inputs:a_normalf3_array_snan', 'normal3f[]', 0, None, 'normalf3_array sNaN', {ogn.MetadataKeys.DEFAULT: '[["snan", "snan", "snan"], ["snan", "snan", "snan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_normalf3_inf', 'normal3f', 0, None, 'normalf3 Infinity', {ogn.MetadataKeys.DEFAULT: '["inf", "inf", "inf"]'}, True, [float("Inf"), float("Inf"), float("Inf")], False, ''),
('inputs:a_normalf3_nan', 'normal3f', 0, None, 'normalf3 NaN', {ogn.MetadataKeys.DEFAULT: '["nan", "nan", "nan"]'}, True, [float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_normalf3_ninf', 'normal3f', 0, None, 'normalf3 -Infinity', {ogn.MetadataKeys.DEFAULT: '["-inf", "-inf", "-inf"]'}, True, [float("-Inf"), float("-Inf"), float("-Inf")], False, ''),
('inputs:a_normalf3_snan', 'normal3f', 0, None, 'normalf3 sNaN', {ogn.MetadataKeys.DEFAULT: '["snan", "snan", "snan"]'}, True, [float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_normalh3_array_inf', 'normal3h[]', 0, None, 'normalh3_array Infinity', {ogn.MetadataKeys.DEFAULT: '[["inf", "inf", "inf"], ["inf", "inf", "inf"]]'}, True, [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False, ''),
('inputs:a_normalh3_array_nan', 'normal3h[]', 0, None, 'normalh3_array NaN', {ogn.MetadataKeys.DEFAULT: '[["nan", "nan", "nan"], ["nan", "nan", "nan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_normalh3_array_ninf', 'normal3h[]', 0, None, 'normalh3_array -Infinity', {ogn.MetadataKeys.DEFAULT: '[["-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf"]]'}, True, [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False, ''),
('inputs:a_normalh3_array_snan', 'normal3h[]', 0, None, 'normalh3_array sNaN', {ogn.MetadataKeys.DEFAULT: '[["snan", "snan", "snan"], ["snan", "snan", "snan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_normalh3_inf', 'normal3h', 0, None, 'normalh3 Infinity', {ogn.MetadataKeys.DEFAULT: '["inf", "inf", "inf"]'}, True, [float("Inf"), float("Inf"), float("Inf")], False, ''),
('inputs:a_normalh3_nan', 'normal3h', 0, None, 'normalh3 NaN', {ogn.MetadataKeys.DEFAULT: '["nan", "nan", "nan"]'}, True, [float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_normalh3_ninf', 'normal3h', 0, None, 'normalh3 -Infinity', {ogn.MetadataKeys.DEFAULT: '["-inf", "-inf", "-inf"]'}, True, [float("-Inf"), float("-Inf"), float("-Inf")], False, ''),
('inputs:a_normalh3_snan', 'normal3h', 0, None, 'normalh3 sNaN', {ogn.MetadataKeys.DEFAULT: '["snan", "snan", "snan"]'}, True, [float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_pointd3_array_inf', 'point3d[]', 0, None, 'pointd3_array Infinity', {ogn.MetadataKeys.DEFAULT: '[["inf", "inf", "inf"], ["inf", "inf", "inf"]]'}, True, [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False, ''),
('inputs:a_pointd3_array_nan', 'point3d[]', 0, None, 'pointd3_array NaN', {ogn.MetadataKeys.DEFAULT: '[["nan", "nan", "nan"], ["nan", "nan", "nan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_pointd3_array_ninf', 'point3d[]', 0, None, 'pointd3_array -Infinity', {ogn.MetadataKeys.DEFAULT: '[["-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf"]]'}, True, [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False, ''),
('inputs:a_pointd3_array_snan', 'point3d[]', 0, None, 'pointd3_array sNaN', {ogn.MetadataKeys.DEFAULT: '[["snan", "snan", "snan"], ["snan", "snan", "snan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_pointd3_inf', 'point3d', 0, None, 'pointd3 Infinity', {ogn.MetadataKeys.DEFAULT: '["inf", "inf", "inf"]'}, True, [float("Inf"), float("Inf"), float("Inf")], False, ''),
('inputs:a_pointd3_nan', 'point3d', 0, None, 'pointd3 NaN', {ogn.MetadataKeys.DEFAULT: '["nan", "nan", "nan"]'}, True, [float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_pointd3_ninf', 'point3d', 0, None, 'pointd3 -Infinity', {ogn.MetadataKeys.DEFAULT: '["-inf", "-inf", "-inf"]'}, True, [float("-Inf"), float("-Inf"), float("-Inf")], False, ''),
('inputs:a_pointd3_snan', 'point3d', 0, None, 'pointd3 sNaN', {ogn.MetadataKeys.DEFAULT: '["snan", "snan", "snan"]'}, True, [float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_pointf3_array_inf', 'point3f[]', 0, None, 'pointf3_array Infinity', {ogn.MetadataKeys.DEFAULT: '[["inf", "inf", "inf"], ["inf", "inf", "inf"]]'}, True, [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False, ''),
('inputs:a_pointf3_array_nan', 'point3f[]', 0, None, 'pointf3_array NaN', {ogn.MetadataKeys.DEFAULT: '[["nan", "nan", "nan"], ["nan", "nan", "nan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_pointf3_array_ninf', 'point3f[]', 0, None, 'pointf3_array -Infinity', {ogn.MetadataKeys.DEFAULT: '[["-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf"]]'}, True, [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False, ''),
('inputs:a_pointf3_array_snan', 'point3f[]', 0, None, 'pointf3_array sNaN', {ogn.MetadataKeys.DEFAULT: '[["snan", "snan", "snan"], ["snan", "snan", "snan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_pointf3_inf', 'point3f', 0, None, 'pointf3 Infinity', {ogn.MetadataKeys.DEFAULT: '["inf", "inf", "inf"]'}, True, [float("Inf"), float("Inf"), float("Inf")], False, ''),
('inputs:a_pointf3_nan', 'point3f', 0, None, 'pointf3 NaN', {ogn.MetadataKeys.DEFAULT: '["nan", "nan", "nan"]'}, True, [float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_pointf3_ninf', 'point3f', 0, None, 'pointf3 -Infinity', {ogn.MetadataKeys.DEFAULT: '["-inf", "-inf", "-inf"]'}, True, [float("-Inf"), float("-Inf"), float("-Inf")], False, ''),
('inputs:a_pointf3_snan', 'point3f', 0, None, 'pointf3 sNaN', {ogn.MetadataKeys.DEFAULT: '["snan", "snan", "snan"]'}, True, [float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_pointh3_array_inf', 'point3h[]', 0, None, 'pointh3_array Infinity', {ogn.MetadataKeys.DEFAULT: '[["inf", "inf", "inf"], ["inf", "inf", "inf"]]'}, True, [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False, ''),
('inputs:a_pointh3_array_nan', 'point3h[]', 0, None, 'pointh3_array NaN', {ogn.MetadataKeys.DEFAULT: '[["nan", "nan", "nan"], ["nan", "nan", "nan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_pointh3_array_ninf', 'point3h[]', 0, None, 'pointh3_array -Infinity', {ogn.MetadataKeys.DEFAULT: '[["-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf"]]'}, True, [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False, ''),
('inputs:a_pointh3_array_snan', 'point3h[]', 0, None, 'pointh3_array sNaN', {ogn.MetadataKeys.DEFAULT: '[["snan", "snan", "snan"], ["snan", "snan", "snan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_pointh3_inf', 'point3h', 0, None, 'pointh3 Infinity', {ogn.MetadataKeys.DEFAULT: '["inf", "inf", "inf"]'}, True, [float("Inf"), float("Inf"), float("Inf")], False, ''),
('inputs:a_pointh3_nan', 'point3h', 0, None, 'pointh3 NaN', {ogn.MetadataKeys.DEFAULT: '["nan", "nan", "nan"]'}, True, [float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_pointh3_ninf', 'point3h', 0, None, 'pointh3 -Infinity', {ogn.MetadataKeys.DEFAULT: '["-inf", "-inf", "-inf"]'}, True, [float("-Inf"), float("-Inf"), float("-Inf")], False, ''),
('inputs:a_pointh3_snan', 'point3h', 0, None, 'pointh3 sNaN', {ogn.MetadataKeys.DEFAULT: '["snan", "snan", "snan"]'}, True, [float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_quatd4_array_inf', 'quatd[]', 0, None, 'quatd4_array Infinity', {ogn.MetadataKeys.DEFAULT: '[["inf", "inf", "inf", "inf"], ["inf", "inf", "inf", "inf"]]'}, True, [[float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")]], False, ''),
('inputs:a_quatd4_array_nan', 'quatd[]', 0, None, 'quatd4_array NaN', {ogn.MetadataKeys.DEFAULT: '[["nan", "nan", "nan", "nan"], ["nan", "nan", "nan", "nan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_quatd4_array_ninf', 'quatd[]', 0, None, 'quatd4_array -Infinity', {ogn.MetadataKeys.DEFAULT: '[["-inf", "-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf", "-inf"]]'}, True, [[float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")]], False, ''),
('inputs:a_quatd4_array_snan', 'quatd[]', 0, None, 'quatd4_array sNaN', {ogn.MetadataKeys.DEFAULT: '[["snan", "snan", "snan", "snan"], ["snan", "snan", "snan", "snan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_quatd4_inf', 'quatd', 0, None, 'quatd4 Infinity', {ogn.MetadataKeys.DEFAULT: '["inf", "inf", "inf", "inf"]'}, True, [float("Inf"), float("Inf"), float("Inf"), float("Inf")], False, ''),
('inputs:a_quatd4_nan', 'quatd', 0, None, 'quatd4 NaN', {ogn.MetadataKeys.DEFAULT: '["nan", "nan", "nan", "nan"]'}, True, [float("NaN"), float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_quatd4_ninf', 'quatd', 0, None, 'quatd4 -Infinity', {ogn.MetadataKeys.DEFAULT: '["-inf", "-inf", "-inf", "-inf"]'}, True, [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], False, ''),
('inputs:a_quatd4_snan', 'quatd', 0, None, 'quatd4 sNaN', {ogn.MetadataKeys.DEFAULT: '["snan", "snan", "snan", "snan"]'}, True, [float("NaN"), float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_quatf4_array_inf', 'quatf[]', 0, None, 'quatf4_array Infinity', {ogn.MetadataKeys.DEFAULT: '[["inf", "inf", "inf", "inf"], ["inf", "inf", "inf", "inf"]]'}, True, [[float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")]], False, ''),
('inputs:a_quatf4_array_nan', 'quatf[]', 0, None, 'quatf4_array NaN', {ogn.MetadataKeys.DEFAULT: '[["nan", "nan", "nan", "nan"], ["nan", "nan", "nan", "nan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_quatf4_array_ninf', 'quatf[]', 0, None, 'quatf4_array -Infinity', {ogn.MetadataKeys.DEFAULT: '[["-inf", "-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf", "-inf"]]'}, True, [[float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")]], False, ''),
('inputs:a_quatf4_array_snan', 'quatf[]', 0, None, 'quatf4_array sNaN', {ogn.MetadataKeys.DEFAULT: '[["snan", "snan", "snan", "snan"], ["snan", "snan", "snan", "snan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_quatf4_inf', 'quatf', 0, None, 'quatf4 Infinity', {ogn.MetadataKeys.DEFAULT: '["inf", "inf", "inf", "inf"]'}, True, [float("Inf"), float("Inf"), float("Inf"), float("Inf")], False, ''),
('inputs:a_quatf4_nan', 'quatf', 0, None, 'quatf4 NaN', {ogn.MetadataKeys.DEFAULT: '["nan", "nan", "nan", "nan"]'}, True, [float("NaN"), float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_quatf4_ninf', 'quatf', 0, None, 'quatf4 -Infinity', {ogn.MetadataKeys.DEFAULT: '["-inf", "-inf", "-inf", "-inf"]'}, True, [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], False, ''),
('inputs:a_quatf4_snan', 'quatf', 0, None, 'quatf4 sNaN', {ogn.MetadataKeys.DEFAULT: '["snan", "snan", "snan", "snan"]'}, True, [float("NaN"), float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_quath4_array_inf', 'quath[]', 0, None, 'quath4_array Infinity', {ogn.MetadataKeys.DEFAULT: '[["inf", "inf", "inf", "inf"], ["inf", "inf", "inf", "inf"]]'}, True, [[float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")]], False, ''),
('inputs:a_quath4_array_nan', 'quath[]', 0, None, 'quath4_array NaN', {ogn.MetadataKeys.DEFAULT: '[["nan", "nan", "nan", "nan"], ["nan", "nan", "nan", "nan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_quath4_array_ninf', 'quath[]', 0, None, 'quath4_array -Infinity', {ogn.MetadataKeys.DEFAULT: '[["-inf", "-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf", "-inf"]]'}, True, [[float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")]], False, ''),
('inputs:a_quath4_array_snan', 'quath[]', 0, None, 'quath4_array sNaN', {ogn.MetadataKeys.DEFAULT: '[["snan", "snan", "snan", "snan"], ["snan", "snan", "snan", "snan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_quath4_inf', 'quath', 0, None, 'quath4 Infinity', {ogn.MetadataKeys.DEFAULT: '["inf", "inf", "inf", "inf"]'}, True, [float("Inf"), float("Inf"), float("Inf"), float("Inf")], False, ''),
('inputs:a_quath4_nan', 'quath', 0, None, 'quath4 NaN', {ogn.MetadataKeys.DEFAULT: '["nan", "nan", "nan", "nan"]'}, True, [float("NaN"), float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_quath4_ninf', 'quath', 0, None, 'quath4 -Infinity', {ogn.MetadataKeys.DEFAULT: '["-inf", "-inf", "-inf", "-inf"]'}, True, [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], False, ''),
('inputs:a_quath4_snan', 'quath', 0, None, 'quath4 sNaN', {ogn.MetadataKeys.DEFAULT: '["snan", "snan", "snan", "snan"]'}, True, [float("NaN"), float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_texcoordd2_array_inf', 'texCoord2d[]', 0, None, 'texcoordd2_array Infinity', {ogn.MetadataKeys.DEFAULT: '[["inf", "inf"], ["inf", "inf"]]'}, True, [[float("Inf"), float("Inf")], [float("Inf"), float("Inf")]], False, ''),
('inputs:a_texcoordd2_array_nan', 'texCoord2d[]', 0, None, 'texcoordd2_array NaN', {ogn.MetadataKeys.DEFAULT: '[["nan", "nan"], ["nan", "nan"]]'}, True, [[float("NaN"), float("NaN")], [float("NaN"), float("NaN")]], False, ''),
('inputs:a_texcoordd2_array_ninf', 'texCoord2d[]', 0, None, 'texcoordd2_array -Infinity', {ogn.MetadataKeys.DEFAULT: '[["-inf", "-inf"], ["-inf", "-inf"]]'}, True, [[float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf")]], False, ''),
('inputs:a_texcoordd2_array_snan', 'texCoord2d[]', 0, None, 'texcoordd2_array sNaN', {ogn.MetadataKeys.DEFAULT: '[["snan", "snan"], ["snan", "snan"]]'}, True, [[float("NaN"), float("NaN")], [float("NaN"), float("NaN")]], False, ''),
('inputs:a_texcoordd2_inf', 'texCoord2d', 0, None, 'texcoordd2 Infinity', {ogn.MetadataKeys.DEFAULT: '["inf", "inf"]'}, True, [float("Inf"), float("Inf")], False, ''),
('inputs:a_texcoordd2_nan', 'texCoord2d', 0, None, 'texcoordd2 NaN', {ogn.MetadataKeys.DEFAULT: '["nan", "nan"]'}, True, [float("NaN"), float("NaN")], False, ''),
('inputs:a_texcoordd2_ninf', 'texCoord2d', 0, None, 'texcoordd2 -Infinity', {ogn.MetadataKeys.DEFAULT: '["-inf", "-inf"]'}, True, [float("-Inf"), float("-Inf")], False, ''),
('inputs:a_texcoordd2_snan', 'texCoord2d', 0, None, 'texcoordd2 sNaN', {ogn.MetadataKeys.DEFAULT: '["snan", "snan"]'}, True, [float("NaN"), float("NaN")], False, ''),
('inputs:a_texcoordd3_array_inf', 'texCoord3d[]', 0, None, 'texcoordd3_array Infinity', {ogn.MetadataKeys.DEFAULT: '[["inf", "inf", "inf"], ["inf", "inf", "inf"]]'}, True, [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False, ''),
('inputs:a_texcoordd3_array_nan', 'texCoord3d[]', 0, None, 'texcoordd3_array NaN', {ogn.MetadataKeys.DEFAULT: '[["nan", "nan", "nan"], ["nan", "nan", "nan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_texcoordd3_array_ninf', 'texCoord3d[]', 0, None, 'texcoordd3_array -Infinity', {ogn.MetadataKeys.DEFAULT: '[["-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf"]]'}, True, [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False, ''),
('inputs:a_texcoordd3_array_snan', 'texCoord3d[]', 0, None, 'texcoordd3_array sNaN', {ogn.MetadataKeys.DEFAULT: '[["snan", "snan", "snan"], ["snan", "snan", "snan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_texcoordd3_inf', 'texCoord3d', 0, None, 'texcoordd3 Infinity', {ogn.MetadataKeys.DEFAULT: '["inf", "inf", "inf"]'}, True, [float("Inf"), float("Inf"), float("Inf")], False, ''),
('inputs:a_texcoordd3_nan', 'texCoord3d', 0, None, 'texcoordd3 NaN', {ogn.MetadataKeys.DEFAULT: '["nan", "nan", "nan"]'}, True, [float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_texcoordd3_ninf', 'texCoord3d', 0, None, 'texcoordd3 -Infinity', {ogn.MetadataKeys.DEFAULT: '["-inf", "-inf", "-inf"]'}, True, [float("-Inf"), float("-Inf"), float("-Inf")], False, ''),
('inputs:a_texcoordd3_snan', 'texCoord3d', 0, None, 'texcoordd3 sNaN', {ogn.MetadataKeys.DEFAULT: '["snan", "snan", "snan"]'}, True, [float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_texcoordf2_array_inf', 'texCoord2f[]', 0, None, 'texcoordf2_array Infinity', {ogn.MetadataKeys.DEFAULT: '[["inf", "inf"], ["inf", "inf"]]'}, True, [[float("Inf"), float("Inf")], [float("Inf"), float("Inf")]], False, ''),
('inputs:a_texcoordf2_array_nan', 'texCoord2f[]', 0, None, 'texcoordf2_array NaN', {ogn.MetadataKeys.DEFAULT: '[["nan", "nan"], ["nan", "nan"]]'}, True, [[float("NaN"), float("NaN")], [float("NaN"), float("NaN")]], False, ''),
('inputs:a_texcoordf2_array_ninf', 'texCoord2f[]', 0, None, 'texcoordf2_array -Infinity', {ogn.MetadataKeys.DEFAULT: '[["-inf", "-inf"], ["-inf", "-inf"]]'}, True, [[float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf")]], False, ''),
('inputs:a_texcoordf2_array_snan', 'texCoord2f[]', 0, None, 'texcoordf2_array sNaN', {ogn.MetadataKeys.DEFAULT: '[["snan", "snan"], ["snan", "snan"]]'}, True, [[float("NaN"), float("NaN")], [float("NaN"), float("NaN")]], False, ''),
('inputs:a_texcoordf2_inf', 'texCoord2f', 0, None, 'texcoordf2 Infinity', {ogn.MetadataKeys.DEFAULT: '["inf", "inf"]'}, True, [float("Inf"), float("Inf")], False, ''),
('inputs:a_texcoordf2_nan', 'texCoord2f', 0, None, 'texcoordf2 NaN', {ogn.MetadataKeys.DEFAULT: '["nan", "nan"]'}, True, [float("NaN"), float("NaN")], False, ''),
('inputs:a_texcoordf2_ninf', 'texCoord2f', 0, None, 'texcoordf2 -Infinity', {ogn.MetadataKeys.DEFAULT: '["-inf", "-inf"]'}, True, [float("-Inf"), float("-Inf")], False, ''),
('inputs:a_texcoordf2_snan', 'texCoord2f', 0, None, 'texcoordf2 sNaN', {ogn.MetadataKeys.DEFAULT: '["snan", "snan"]'}, True, [float("NaN"), float("NaN")], False, ''),
('inputs:a_texcoordf3_array_inf', 'texCoord3f[]', 0, None, 'texcoordf3_array Infinity', {ogn.MetadataKeys.DEFAULT: '[["inf", "inf", "inf"], ["inf", "inf", "inf"]]'}, True, [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False, ''),
('inputs:a_texcoordf3_array_nan', 'texCoord3f[]', 0, None, 'texcoordf3_array NaN', {ogn.MetadataKeys.DEFAULT: '[["nan", "nan", "nan"], ["nan", "nan", "nan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_texcoordf3_array_ninf', 'texCoord3f[]', 0, None, 'texcoordf3_array -Infinity', {ogn.MetadataKeys.DEFAULT: '[["-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf"]]'}, True, [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False, ''),
('inputs:a_texcoordf3_array_snan', 'texCoord3f[]', 0, None, 'texcoordf3_array sNaN', {ogn.MetadataKeys.DEFAULT: '[["snan", "snan", "snan"], ["snan", "snan", "snan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_texcoordf3_inf', 'texCoord3f', 0, None, 'texcoordf3 Infinity', {ogn.MetadataKeys.DEFAULT: '["inf", "inf", "inf"]'}, True, [float("Inf"), float("Inf"), float("Inf")], False, ''),
('inputs:a_texcoordf3_nan', 'texCoord3f', 0, None, 'texcoordf3 NaN', {ogn.MetadataKeys.DEFAULT: '["nan", "nan", "nan"]'}, True, [float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_texcoordf3_ninf', 'texCoord3f', 0, None, 'texcoordf3 -Infinity', {ogn.MetadataKeys.DEFAULT: '["-inf", "-inf", "-inf"]'}, True, [float("-Inf"), float("-Inf"), float("-Inf")], False, ''),
('inputs:a_texcoordf3_snan', 'texCoord3f', 0, None, 'texcoordf3 sNaN', {ogn.MetadataKeys.DEFAULT: '["snan", "snan", "snan"]'}, True, [float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_texcoordh2_array_inf', 'texCoord2h[]', 0, None, 'texcoordh2_array Infinity', {ogn.MetadataKeys.DEFAULT: '[["inf", "inf"], ["inf", "inf"]]'}, True, [[float("Inf"), float("Inf")], [float("Inf"), float("Inf")]], False, ''),
('inputs:a_texcoordh2_array_nan', 'texCoord2h[]', 0, None, 'texcoordh2_array NaN', {ogn.MetadataKeys.DEFAULT: '[["nan", "nan"], ["nan", "nan"]]'}, True, [[float("NaN"), float("NaN")], [float("NaN"), float("NaN")]], False, ''),
('inputs:a_texcoordh2_array_ninf', 'texCoord2h[]', 0, None, 'texcoordh2_array -Infinity', {ogn.MetadataKeys.DEFAULT: '[["-inf", "-inf"], ["-inf", "-inf"]]'}, True, [[float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf")]], False, ''),
('inputs:a_texcoordh2_array_snan', 'texCoord2h[]', 0, None, 'texcoordh2_array sNaN', {ogn.MetadataKeys.DEFAULT: '[["snan", "snan"], ["snan", "snan"]]'}, True, [[float("NaN"), float("NaN")], [float("NaN"), float("NaN")]], False, ''),
('inputs:a_texcoordh2_inf', 'texCoord2h', 0, None, 'texcoordh2 Infinity', {ogn.MetadataKeys.DEFAULT: '["inf", "inf"]'}, True, [float("Inf"), float("Inf")], False, ''),
('inputs:a_texcoordh2_nan', 'texCoord2h', 0, None, 'texcoordh2 NaN', {ogn.MetadataKeys.DEFAULT: '["nan", "nan"]'}, True, [float("NaN"), float("NaN")], False, ''),
('inputs:a_texcoordh2_ninf', 'texCoord2h', 0, None, 'texcoordh2 -Infinity', {ogn.MetadataKeys.DEFAULT: '["-inf", "-inf"]'}, True, [float("-Inf"), float("-Inf")], False, ''),
('inputs:a_texcoordh2_snan', 'texCoord2h', 0, None, 'texcoordh2 sNaN', {ogn.MetadataKeys.DEFAULT: '["snan", "snan"]'}, True, [float("NaN"), float("NaN")], False, ''),
('inputs:a_texcoordh3_array_inf', 'texCoord3h[]', 0, None, 'texcoordh3_array Infinity', {ogn.MetadataKeys.DEFAULT: '[["inf", "inf", "inf"], ["inf", "inf", "inf"]]'}, True, [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False, ''),
('inputs:a_texcoordh3_array_nan', 'texCoord3h[]', 0, None, 'texcoordh3_array NaN', {ogn.MetadataKeys.DEFAULT: '[["nan", "nan", "nan"], ["nan", "nan", "nan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_texcoordh3_array_ninf', 'texCoord3h[]', 0, None, 'texcoordh3_array -Infinity', {ogn.MetadataKeys.DEFAULT: '[["-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf"]]'}, True, [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False, ''),
('inputs:a_texcoordh3_array_snan', 'texCoord3h[]', 0, None, 'texcoordh3_array sNaN', {ogn.MetadataKeys.DEFAULT: '[["snan", "snan", "snan"], ["snan", "snan", "snan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_texcoordh3_inf', 'texCoord3h', 0, None, 'texcoordh3 Infinity', {ogn.MetadataKeys.DEFAULT: '["inf", "inf", "inf"]'}, True, [float("Inf"), float("Inf"), float("Inf")], False, ''),
('inputs:a_texcoordh3_nan', 'texCoord3h', 0, None, 'texcoordh3 NaN', {ogn.MetadataKeys.DEFAULT: '["nan", "nan", "nan"]'}, True, [float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_texcoordh3_ninf', 'texCoord3h', 0, None, 'texcoordh3 -Infinity', {ogn.MetadataKeys.DEFAULT: '["-inf", "-inf", "-inf"]'}, True, [float("-Inf"), float("-Inf"), float("-Inf")], False, ''),
('inputs:a_texcoordh3_snan', 'texCoord3h', 0, None, 'texcoordh3 sNaN', {ogn.MetadataKeys.DEFAULT: '["snan", "snan", "snan"]'}, True, [float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_timecode_array_inf', 'timecode[]', 0, None, 'timecode_array Infinity', {ogn.MetadataKeys.DEFAULT: '["inf", "inf"]'}, True, [float("Inf"), float("Inf")], False, ''),
('inputs:a_timecode_array_nan', 'timecode[]', 0, None, 'timecode_array NaN', {ogn.MetadataKeys.DEFAULT: '["nan", "nan"]'}, True, [float("NaN"), float("NaN")], False, ''),
('inputs:a_timecode_array_ninf', 'timecode[]', 0, None, 'timecode_array -Infinity', {ogn.MetadataKeys.DEFAULT: '["-inf", "-inf"]'}, True, [float("-Inf"), float("-Inf")], False, ''),
('inputs:a_timecode_array_snan', 'timecode[]', 0, None, 'timecode_array sNaN', {ogn.MetadataKeys.DEFAULT: '["snan", "snan"]'}, True, [float("NaN"), float("NaN")], False, ''),
('inputs:a_timecode_inf', 'timecode', 0, None, 'timecode Infinity', {ogn.MetadataKeys.DEFAULT: '"inf"'}, True, float("Inf"), False, ''),
('inputs:a_timecode_nan', 'timecode', 0, None, 'timecode NaN', {ogn.MetadataKeys.DEFAULT: '"nan"'}, True, float("NaN"), False, ''),
('inputs:a_timecode_ninf', 'timecode', 0, None, 'timecode -Infinity', {ogn.MetadataKeys.DEFAULT: '"-inf"'}, True, float("-Inf"), False, ''),
('inputs:a_timecode_snan', 'timecode', 0, None, 'timecode sNaN', {ogn.MetadataKeys.DEFAULT: '"snan"'}, True, float("NaN"), False, ''),
('inputs:a_vectord3_array_inf', 'vector3d[]', 0, None, 'vectord3_array Infinity', {ogn.MetadataKeys.DEFAULT: '[["inf", "inf", "inf"], ["inf", "inf", "inf"]]'}, True, [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False, ''),
('inputs:a_vectord3_array_nan', 'vector3d[]', 0, None, 'vectord3_array NaN', {ogn.MetadataKeys.DEFAULT: '[["nan", "nan", "nan"], ["nan", "nan", "nan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_vectord3_array_ninf', 'vector3d[]', 0, None, 'vectord3_array -Infinity', {ogn.MetadataKeys.DEFAULT: '[["-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf"]]'}, True, [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False, ''),
('inputs:a_vectord3_array_snan', 'vector3d[]', 0, None, 'vectord3_array sNaN', {ogn.MetadataKeys.DEFAULT: '[["snan", "snan", "snan"], ["snan", "snan", "snan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_vectord3_inf', 'vector3d', 0, None, 'vectord3 Infinity', {ogn.MetadataKeys.DEFAULT: '["inf", "inf", "inf"]'}, True, [float("Inf"), float("Inf"), float("Inf")], False, ''),
('inputs:a_vectord3_nan', 'vector3d', 0, None, 'vectord3 NaN', {ogn.MetadataKeys.DEFAULT: '["nan", "nan", "nan"]'}, True, [float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_vectord3_ninf', 'vector3d', 0, None, 'vectord3 -Infinity', {ogn.MetadataKeys.DEFAULT: '["-inf", "-inf", "-inf"]'}, True, [float("-Inf"), float("-Inf"), float("-Inf")], False, ''),
('inputs:a_vectord3_snan', 'vector3d', 0, None, 'vectord3 sNaN', {ogn.MetadataKeys.DEFAULT: '["snan", "snan", "snan"]'}, True, [float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_vectorf3_array_inf', 'vector3f[]', 0, None, 'vectorf3_array Infinity', {ogn.MetadataKeys.DEFAULT: '[["inf", "inf", "inf"], ["inf", "inf", "inf"]]'}, True, [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False, ''),
('inputs:a_vectorf3_array_nan', 'vector3f[]', 0, None, 'vectorf3_array NaN', {ogn.MetadataKeys.DEFAULT: '[["nan", "nan", "nan"], ["nan", "nan", "nan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_vectorf3_array_ninf', 'vector3f[]', 0, None, 'vectorf3_array -Infinity', {ogn.MetadataKeys.DEFAULT: '[["-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf"]]'}, True, [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False, ''),
('inputs:a_vectorf3_array_snan', 'vector3f[]', 0, None, 'vectorf3_array sNaN', {ogn.MetadataKeys.DEFAULT: '[["snan", "snan", "snan"], ["snan", "snan", "snan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_vectorf3_inf', 'vector3f', 0, None, 'vectorf3 Infinity', {ogn.MetadataKeys.DEFAULT: '["inf", "inf", "inf"]'}, True, [float("Inf"), float("Inf"), float("Inf")], False, ''),
('inputs:a_vectorf3_nan', 'vector3f', 0, None, 'vectorf3 NaN', {ogn.MetadataKeys.DEFAULT: '["nan", "nan", "nan"]'}, True, [float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_vectorf3_ninf', 'vector3f', 0, None, 'vectorf3 -Infinity', {ogn.MetadataKeys.DEFAULT: '["-inf", "-inf", "-inf"]'}, True, [float("-Inf"), float("-Inf"), float("-Inf")], False, ''),
('inputs:a_vectorf3_snan', 'vector3f', 0, None, 'vectorf3 sNaN', {ogn.MetadataKeys.DEFAULT: '["snan", "snan", "snan"]'}, True, [float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_vectorh3_array_inf', 'vector3h[]', 0, None, 'vectorh3_array Infinity', {ogn.MetadataKeys.DEFAULT: '[["inf", "inf", "inf"], ["inf", "inf", "inf"]]'}, True, [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False, ''),
('inputs:a_vectorh3_array_nan', 'vector3h[]', 0, None, 'vectorh3_array NaN', {ogn.MetadataKeys.DEFAULT: '[["nan", "nan", "nan"], ["nan", "nan", "nan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_vectorh3_array_ninf', 'vector3h[]', 0, None, 'vectorh3_array -Infinity', {ogn.MetadataKeys.DEFAULT: '[["-inf", "-inf", "-inf"], ["-inf", "-inf", "-inf"]]'}, True, [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False, ''),
('inputs:a_vectorh3_array_snan', 'vector3h[]', 0, None, 'vectorh3_array sNaN', {ogn.MetadataKeys.DEFAULT: '[["snan", "snan", "snan"], ["snan", "snan", "snan"]]'}, True, [[float("NaN"), float("NaN"), float("NaN")], [float("NaN"), float("NaN"), float("NaN")]], False, ''),
('inputs:a_vectorh3_inf', 'vector3h', 0, None, 'vectorh3 Infinity', {ogn.MetadataKeys.DEFAULT: '["inf", "inf", "inf"]'}, True, [float("Inf"), float("Inf"), float("Inf")], False, ''),
('inputs:a_vectorh3_nan', 'vector3h', 0, None, 'vectorh3 NaN', {ogn.MetadataKeys.DEFAULT: '["nan", "nan", "nan"]'}, True, [float("NaN"), float("NaN"), float("NaN")], False, ''),
('inputs:a_vectorh3_ninf', 'vector3h', 0, None, 'vectorh3 -Infinity', {ogn.MetadataKeys.DEFAULT: '["-inf", "-inf", "-inf"]'}, True, [float("-Inf"), float("-Inf"), float("-Inf")], False, ''),
('inputs:a_vectorh3_snan', 'vector3h', 0, None, 'vectorh3 sNaN', {ogn.MetadataKeys.DEFAULT: '["snan", "snan", "snan"]'}, True, [float("NaN"), float("NaN"), float("NaN")], False, ''),
('outputs:a_colord3_array_inf', 'color3d[]', 0, None, 'colord3_array Infinity', {}, True, None, False, ''),
('outputs:a_colord3_array_nan', 'color3d[]', 0, None, 'colord3_array NaN', {}, True, None, False, ''),
('outputs:a_colord3_array_ninf', 'color3d[]', 0, None, 'colord3_array -Infinity', {}, True, None, False, ''),
('outputs:a_colord3_array_snan', 'color3d[]', 0, None, 'colord3_array sNaN', {}, True, None, False, ''),
('outputs:a_colord3_inf', 'color3d', 0, None, 'colord3 Infinity', {}, True, None, False, ''),
('outputs:a_colord3_nan', 'color3d', 0, None, 'colord3 NaN', {}, True, None, False, ''),
('outputs:a_colord3_ninf', 'color3d', 0, None, 'colord3 -Infinity', {}, True, None, False, ''),
('outputs:a_colord3_snan', 'color3d', 0, None, 'colord3 sNaN', {}, True, None, False, ''),
('outputs:a_colord4_array_inf', 'color4d[]', 0, None, 'colord4_array Infinity', {}, True, None, False, ''),
('outputs:a_colord4_array_nan', 'color4d[]', 0, None, 'colord4_array NaN', {}, True, None, False, ''),
('outputs:a_colord4_array_ninf', 'color4d[]', 0, None, 'colord4_array -Infinity', {}, True, None, False, ''),
('outputs:a_colord4_array_snan', 'color4d[]', 0, None, 'colord4_array sNaN', {}, True, None, False, ''),
('outputs:a_colord4_inf', 'color4d', 0, None, 'colord4 Infinity', {}, True, None, False, ''),
('outputs:a_colord4_nan', 'color4d', 0, None, 'colord4 NaN', {}, True, None, False, ''),
('outputs:a_colord4_ninf', 'color4d', 0, None, 'colord4 -Infinity', {}, True, None, False, ''),
('outputs:a_colord4_snan', 'color4d', 0, None, 'colord4 sNaN', {}, True, None, False, ''),
('outputs:a_colorf3_array_inf', 'color3f[]', 0, None, 'colorf3_array Infinity', {}, True, None, False, ''),
('outputs:a_colorf3_array_nan', 'color3f[]', 0, None, 'colorf3_array NaN', {}, True, None, False, ''),
('outputs:a_colorf3_array_ninf', 'color3f[]', 0, None, 'colorf3_array -Infinity', {}, True, None, False, ''),
('outputs:a_colorf3_array_snan', 'color3f[]', 0, None, 'colorf3_array sNaN', {}, True, None, False, ''),
('outputs:a_colorf3_inf', 'color3f', 0, None, 'colorf3 Infinity', {}, True, None, False, ''),
('outputs:a_colorf3_nan', 'color3f', 0, None, 'colorf3 NaN', {}, True, None, False, ''),
('outputs:a_colorf3_ninf', 'color3f', 0, None, 'colorf3 -Infinity', {}, True, None, False, ''),
('outputs:a_colorf3_snan', 'color3f', 0, None, 'colorf3 sNaN', {}, True, None, False, ''),
('outputs:a_colorf4_array_inf', 'color4f[]', 0, None, 'colorf4_array Infinity', {}, True, None, False, ''),
('outputs:a_colorf4_array_nan', 'color4f[]', 0, None, 'colorf4_array NaN', {}, True, None, False, ''),
('outputs:a_colorf4_array_ninf', 'color4f[]', 0, None, 'colorf4_array -Infinity', {}, True, None, False, ''),
('outputs:a_colorf4_array_snan', 'color4f[]', 0, None, 'colorf4_array sNaN', {}, True, None, False, ''),
('outputs:a_colorf4_inf', 'color4f', 0, None, 'colorf4 Infinity', {}, True, None, False, ''),
('outputs:a_colorf4_nan', 'color4f', 0, None, 'colorf4 NaN', {}, True, None, False, ''),
('outputs:a_colorf4_ninf', 'color4f', 0, None, 'colorf4 -Infinity', {}, True, None, False, ''),
('outputs:a_colorf4_snan', 'color4f', 0, None, 'colorf4 sNaN', {}, True, None, False, ''),
('outputs:a_colorh3_array_inf', 'color3h[]', 0, None, 'colorh3_array Infinity', {}, True, None, False, ''),
('outputs:a_colorh3_array_nan', 'color3h[]', 0, None, 'colorh3_array NaN', {}, True, None, False, ''),
('outputs:a_colorh3_array_ninf', 'color3h[]', 0, None, 'colorh3_array -Infinity', {}, True, None, False, ''),
('outputs:a_colorh3_array_snan', 'color3h[]', 0, None, 'colorh3_array sNaN', {}, True, None, False, ''),
('outputs:a_colorh3_inf', 'color3h', 0, None, 'colorh3 Infinity', {}, True, None, False, ''),
('outputs:a_colorh3_nan', 'color3h', 0, None, 'colorh3 NaN', {}, True, None, False, ''),
('outputs:a_colorh3_ninf', 'color3h', 0, None, 'colorh3 -Infinity', {}, True, None, False, ''),
('outputs:a_colorh3_snan', 'color3h', 0, None, 'colorh3 sNaN', {}, True, None, False, ''),
('outputs:a_colorh4_array_inf', 'color4h[]', 0, None, 'colorh4_array Infinity', {}, True, None, False, ''),
('outputs:a_colorh4_array_nan', 'color4h[]', 0, None, 'colorh4_array NaN', {}, True, None, False, ''),
('outputs:a_colorh4_array_ninf', 'color4h[]', 0, None, 'colorh4_array -Infinity', {}, True, None, False, ''),
('outputs:a_colorh4_array_snan', 'color4h[]', 0, None, 'colorh4_array sNaN', {}, True, None, False, ''),
('outputs:a_colorh4_inf', 'color4h', 0, None, 'colorh4 Infinity', {}, True, None, False, ''),
('outputs:a_colorh4_nan', 'color4h', 0, None, 'colorh4 NaN', {}, True, None, False, ''),
('outputs:a_colorh4_ninf', 'color4h', 0, None, 'colorh4 -Infinity', {}, True, None, False, ''),
('outputs:a_colorh4_snan', 'color4h', 0, None, 'colorh4 sNaN', {}, True, None, False, ''),
('outputs:a_double2_array_inf', 'double2[]', 0, None, 'double2_array Infinity', {}, True, None, False, ''),
('outputs:a_double2_array_nan', 'double2[]', 0, None, 'double2_array NaN', {}, True, None, False, ''),
('outputs:a_double2_array_ninf', 'double2[]', 0, None, 'double2_array -Infinity', {}, True, None, False, ''),
('outputs:a_double2_array_snan', 'double2[]', 0, None, 'double2_array sNaN', {}, True, None, False, ''),
('outputs:a_double2_inf', 'double2', 0, None, 'double2 Infinity', {}, True, None, False, ''),
('outputs:a_double2_nan', 'double2', 0, None, 'double2 NaN', {}, True, None, False, ''),
('outputs:a_double2_ninf', 'double2', 0, None, 'double2 -Infinity', {}, True, None, False, ''),
('outputs:a_double2_snan', 'double2', 0, None, 'double2 sNaN', {}, True, None, False, ''),
('outputs:a_double3_array_inf', 'double3[]', 0, None, 'double3_array Infinity', {}, True, None, False, ''),
('outputs:a_double3_array_nan', 'double3[]', 0, None, 'double3_array NaN', {}, True, None, False, ''),
('outputs:a_double3_array_ninf', 'double3[]', 0, None, 'double3_array -Infinity', {}, True, None, False, ''),
('outputs:a_double3_array_snan', 'double3[]', 0, None, 'double3_array sNaN', {}, True, None, False, ''),
('outputs:a_double3_inf', 'double3', 0, None, 'double3 Infinity', {}, True, None, False, ''),
('outputs:a_double3_nan', 'double3', 0, None, 'double3 NaN', {}, True, None, False, ''),
('outputs:a_double3_ninf', 'double3', 0, None, 'double3 -Infinity', {}, True, None, False, ''),
('outputs:a_double3_snan', 'double3', 0, None, 'double3 sNaN', {}, True, None, False, ''),
('outputs:a_double4_array_inf', 'double4[]', 0, None, 'double4_array Infinity', {}, True, None, False, ''),
('outputs:a_double4_array_nan', 'double4[]', 0, None, 'double4_array NaN', {}, True, None, False, ''),
('outputs:a_double4_array_ninf', 'double4[]', 0, None, 'double4_array -Infinity', {}, True, None, False, ''),
('outputs:a_double4_array_snan', 'double4[]', 0, None, 'double4_array sNaN', {}, True, None, False, ''),
('outputs:a_double4_inf', 'double4', 0, None, 'double4 Infinity', {}, True, None, False, ''),
('outputs:a_double4_nan', 'double4', 0, None, 'double4 NaN', {}, True, None, False, ''),
('outputs:a_double4_ninf', 'double4', 0, None, 'double4 -Infinity', {}, True, None, False, ''),
('outputs:a_double4_snan', 'double4', 0, None, 'double4 sNaN', {}, True, None, False, ''),
('outputs:a_double_array_inf', 'double[]', 0, None, 'double_array Infinity', {}, True, None, False, ''),
('outputs:a_double_array_nan', 'double[]', 0, None, 'double_array NaN', {}, True, None, False, ''),
('outputs:a_double_array_ninf', 'double[]', 0, None, 'double_array -Infinity', {}, True, None, False, ''),
('outputs:a_double_array_snan', 'double[]', 0, None, 'double_array sNaN', {}, True, None, False, ''),
('outputs:a_double_inf', 'double', 0, None, 'double Infinity', {}, True, None, False, ''),
('outputs:a_double_nan', 'double', 0, None, 'double NaN', {}, True, None, False, ''),
('outputs:a_double_ninf', 'double', 0, None, 'double -Infinity', {}, True, None, False, ''),
('outputs:a_double_snan', 'double', 0, None, 'double sNaN', {}, True, None, False, ''),
('outputs:a_float2_array_inf', 'float2[]', 0, None, 'float2_array Infinity', {}, True, None, False, ''),
('outputs:a_float2_array_nan', 'float2[]', 0, None, 'float2_array NaN', {}, True, None, False, ''),
('outputs:a_float2_array_ninf', 'float2[]', 0, None, 'float2_array -Infinity', {}, True, None, False, ''),
('outputs:a_float2_array_snan', 'float2[]', 0, None, 'float2_array sNaN', {}, True, None, False, ''),
('outputs:a_float2_inf', 'float2', 0, None, 'float2 Infinity', {}, True, None, False, ''),
('outputs:a_float2_nan', 'float2', 0, None, 'float2 NaN', {}, True, None, False, ''),
('outputs:a_float2_ninf', 'float2', 0, None, 'float2 -Infinity', {}, True, None, False, ''),
('outputs:a_float2_snan', 'float2', 0, None, 'float2 sNaN', {}, True, None, False, ''),
('outputs:a_float3_array_inf', 'float3[]', 0, None, 'float3_array Infinity', {}, True, None, False, ''),
('outputs:a_float3_array_nan', 'float3[]', 0, None, 'float3_array NaN', {}, True, None, False, ''),
('outputs:a_float3_array_ninf', 'float3[]', 0, None, 'float3_array -Infinity', {}, True, None, False, ''),
('outputs:a_float3_array_snan', 'float3[]', 0, None, 'float3_array sNaN', {}, True, None, False, ''),
('outputs:a_float3_inf', 'float3', 0, None, 'float3 Infinity', {}, True, None, False, ''),
('outputs:a_float3_nan', 'float3', 0, None, 'float3 NaN', {}, True, None, False, ''),
('outputs:a_float3_ninf', 'float3', 0, None, 'float3 -Infinity', {}, True, None, False, ''),
('outputs:a_float3_snan', 'float3', 0, None, 'float3 sNaN', {}, True, None, False, ''),
('outputs:a_float4_array_inf', 'float4[]', 0, None, 'float4_array Infinity', {}, True, None, False, ''),
('outputs:a_float4_array_nan', 'float4[]', 0, None, 'float4_array NaN', {}, True, None, False, ''),
('outputs:a_float4_array_ninf', 'float4[]', 0, None, 'float4_array -Infinity', {}, True, None, False, ''),
('outputs:a_float4_array_snan', 'float4[]', 0, None, 'float4_array sNaN', {}, True, None, False, ''),
('outputs:a_float4_inf', 'float4', 0, None, 'float4 Infinity', {}, True, None, False, ''),
('outputs:a_float4_nan', 'float4', 0, None, 'float4 NaN', {}, True, None, False, ''),
('outputs:a_float4_ninf', 'float4', 0, None, 'float4 -Infinity', {}, True, None, False, ''),
('outputs:a_float4_snan', 'float4', 0, None, 'float4 sNaN', {}, True, None, False, ''),
('outputs:a_float_array_inf', 'float[]', 0, None, 'float_array Infinity', {}, True, None, False, ''),
('outputs:a_float_array_nan', 'float[]', 0, None, 'float_array NaN', {}, True, None, False, ''),
('outputs:a_float_array_ninf', 'float[]', 0, None, 'float_array -Infinity', {}, True, None, False, ''),
('outputs:a_float_array_snan', 'float[]', 0, None, 'float_array sNaN', {}, True, None, False, ''),
('outputs:a_float_inf', 'float', 0, None, 'float Infinity', {}, True, None, False, ''),
('outputs:a_float_nan', 'float', 0, None, 'float NaN', {}, True, None, False, ''),
('outputs:a_float_ninf', 'float', 0, None, 'float -Infinity', {}, True, None, False, ''),
('outputs:a_float_snan', 'float', 0, None, 'float sNaN', {}, True, None, False, ''),
('outputs:a_frame4_array_inf', 'frame4d[]', 0, None, 'frame4_array Infinity', {}, True, None, False, ''),
('outputs:a_frame4_array_nan', 'frame4d[]', 0, None, 'frame4_array NaN', {}, True, None, False, ''),
('outputs:a_frame4_array_ninf', 'frame4d[]', 0, None, 'frame4_array -Infinity', {}, True, None, False, ''),
('outputs:a_frame4_array_snan', 'frame4d[]', 0, None, 'frame4_array sNaN', {}, True, None, False, ''),
('outputs:a_frame4_inf', 'frame4d', 0, None, 'frame4 Infinity', {}, True, None, False, ''),
('outputs:a_frame4_nan', 'frame4d', 0, None, 'frame4 NaN', {}, True, None, False, ''),
('outputs:a_frame4_ninf', 'frame4d', 0, None, 'frame4 -Infinity', {}, True, None, False, ''),
('outputs:a_frame4_snan', 'frame4d', 0, None, 'frame4 sNaN', {}, True, None, False, ''),
('outputs:a_half2_array_inf', 'half2[]', 0, None, 'half2_array Infinity', {}, True, None, False, ''),
('outputs:a_half2_array_nan', 'half2[]', 0, None, 'half2_array NaN', {}, True, None, False, ''),
('outputs:a_half2_array_ninf', 'half2[]', 0, None, 'half2_array -Infinity', {}, True, None, False, ''),
('outputs:a_half2_array_snan', 'half2[]', 0, None, 'half2_array sNaN', {}, True, None, False, ''),
('outputs:a_half2_inf', 'half2', 0, None, 'half2 Infinity', {}, True, None, False, ''),
('outputs:a_half2_nan', 'half2', 0, None, 'half2 NaN', {}, True, None, False, ''),
('outputs:a_half2_ninf', 'half2', 0, None, 'half2 -Infinity', {}, True, None, False, ''),
('outputs:a_half2_snan', 'half2', 0, None, 'half2 sNaN', {}, True, None, False, ''),
('outputs:a_half3_array_inf', 'half3[]', 0, None, 'half3_array Infinity', {}, True, None, False, ''),
('outputs:a_half3_array_nan', 'half3[]', 0, None, 'half3_array NaN', {}, True, None, False, ''),
('outputs:a_half3_array_ninf', 'half3[]', 0, None, 'half3_array -Infinity', {}, True, None, False, ''),
('outputs:a_half3_array_snan', 'half3[]', 0, None, 'half3_array sNaN', {}, True, None, False, ''),
('outputs:a_half3_inf', 'half3', 0, None, 'half3 Infinity', {}, True, None, False, ''),
('outputs:a_half3_nan', 'half3', 0, None, 'half3 NaN', {}, True, None, False, ''),
('outputs:a_half3_ninf', 'half3', 0, None, 'half3 -Infinity', {}, True, None, False, ''),
('outputs:a_half3_snan', 'half3', 0, None, 'half3 sNaN', {}, True, None, False, ''),
('outputs:a_half4_array_inf', 'half4[]', 0, None, 'half4_array Infinity', {}, True, None, False, ''),
('outputs:a_half4_array_nan', 'half4[]', 0, None, 'half4_array NaN', {}, True, None, False, ''),
('outputs:a_half4_array_ninf', 'half4[]', 0, None, 'half4_array -Infinity', {}, True, None, False, ''),
('outputs:a_half4_array_snan', 'half4[]', 0, None, 'half4_array sNaN', {}, True, None, False, ''),
('outputs:a_half4_inf', 'half4', 0, None, 'half4 Infinity', {}, True, None, False, ''),
('outputs:a_half4_nan', 'half4', 0, None, 'half4 NaN', {}, True, None, False, ''),
('outputs:a_half4_ninf', 'half4', 0, None, 'half4 -Infinity', {}, True, None, False, ''),
('outputs:a_half4_snan', 'half4', 0, None, 'half4 sNaN', {}, True, None, False, ''),
('outputs:a_half_array_inf', 'half[]', 0, None, 'half_array Infinity', {}, True, None, False, ''),
('outputs:a_half_array_nan', 'half[]', 0, None, 'half_array NaN', {}, True, None, False, ''),
('outputs:a_half_array_ninf', 'half[]', 0, None, 'half_array -Infinity', {}, True, None, False, ''),
('outputs:a_half_array_snan', 'half[]', 0, None, 'half_array sNaN', {}, True, None, False, ''),
('outputs:a_half_inf', 'half', 0, None, 'half Infinity', {}, True, None, False, ''),
('outputs:a_half_nan', 'half', 0, None, 'half NaN', {}, True, None, False, ''),
('outputs:a_half_ninf', 'half', 0, None, 'half -Infinity', {}, True, None, False, ''),
('outputs:a_half_snan', 'half', 0, None, 'half sNaN', {}, True, None, False, ''),
('outputs:a_matrixd2_array_inf', 'matrix2d[]', 0, None, 'matrixd2_array Infinity', {}, True, None, False, ''),
('outputs:a_matrixd2_array_nan', 'matrix2d[]', 0, None, 'matrixd2_array NaN', {}, True, None, False, ''),
('outputs:a_matrixd2_array_ninf', 'matrix2d[]', 0, None, 'matrixd2_array -Infinity', {}, True, None, False, ''),
('outputs:a_matrixd2_array_snan', 'matrix2d[]', 0, None, 'matrixd2_array sNaN', {}, True, None, False, ''),
('outputs:a_matrixd2_inf', 'matrix2d', 0, None, 'matrixd2 Infinity', {}, True, None, False, ''),
('outputs:a_matrixd2_nan', 'matrix2d', 0, None, 'matrixd2 NaN', {}, True, None, False, ''),
('outputs:a_matrixd2_ninf', 'matrix2d', 0, None, 'matrixd2 -Infinity', {}, True, None, False, ''),
('outputs:a_matrixd2_snan', 'matrix2d', 0, None, 'matrixd2 sNaN', {}, True, None, False, ''),
('outputs:a_matrixd3_array_inf', 'matrix3d[]', 0, None, 'matrixd3_array Infinity', {}, True, None, False, ''),
('outputs:a_matrixd3_array_nan', 'matrix3d[]', 0, None, 'matrixd3_array NaN', {}, True, None, False, ''),
('outputs:a_matrixd3_array_ninf', 'matrix3d[]', 0, None, 'matrixd3_array -Infinity', {}, True, None, False, ''),
('outputs:a_matrixd3_array_snan', 'matrix3d[]', 0, None, 'matrixd3_array sNaN', {}, True, None, False, ''),
('outputs:a_matrixd3_inf', 'matrix3d', 0, None, 'matrixd3 Infinity', {}, True, None, False, ''),
('outputs:a_matrixd3_nan', 'matrix3d', 0, None, 'matrixd3 NaN', {}, True, None, False, ''),
('outputs:a_matrixd3_ninf', 'matrix3d', 0, None, 'matrixd3 -Infinity', {}, True, None, False, ''),
('outputs:a_matrixd3_snan', 'matrix3d', 0, None, 'matrixd3 sNaN', {}, True, None, False, ''),
('outputs:a_matrixd4_array_inf', 'matrix4d[]', 0, None, 'matrixd4_array Infinity', {}, True, None, False, ''),
('outputs:a_matrixd4_array_nan', 'matrix4d[]', 0, None, 'matrixd4_array NaN', {}, True, None, False, ''),
('outputs:a_matrixd4_array_ninf', 'matrix4d[]', 0, None, 'matrixd4_array -Infinity', {}, True, None, False, ''),
('outputs:a_matrixd4_array_snan', 'matrix4d[]', 0, None, 'matrixd4_array sNaN', {}, True, None, False, ''),
('outputs:a_matrixd4_inf', 'matrix4d', 0, None, 'matrixd4 Infinity', {}, True, None, False, ''),
('outputs:a_matrixd4_nan', 'matrix4d', 0, None, 'matrixd4 NaN', {}, True, None, False, ''),
('outputs:a_matrixd4_ninf', 'matrix4d', 0, None, 'matrixd4 -Infinity', {}, True, None, False, ''),
('outputs:a_matrixd4_snan', 'matrix4d', 0, None, 'matrixd4 sNaN', {}, True, None, False, ''),
('outputs:a_normald3_array_inf', 'normal3d[]', 0, None, 'normald3_array Infinity', {}, True, None, False, ''),
('outputs:a_normald3_array_nan', 'normal3d[]', 0, None, 'normald3_array NaN', {}, True, None, False, ''),
('outputs:a_normald3_array_ninf', 'normal3d[]', 0, None, 'normald3_array -Infinity', {}, True, None, False, ''),
('outputs:a_normald3_array_snan', 'normal3d[]', 0, None, 'normald3_array sNaN', {}, True, None, False, ''),
('outputs:a_normald3_inf', 'normal3d', 0, None, 'normald3 Infinity', {}, True, None, False, ''),
('outputs:a_normald3_nan', 'normal3d', 0, None, 'normald3 NaN', {}, True, None, False, ''),
('outputs:a_normald3_ninf', 'normal3d', 0, None, 'normald3 -Infinity', {}, True, None, False, ''),
('outputs:a_normald3_snan', 'normal3d', 0, None, 'normald3 sNaN', {}, True, None, False, ''),
('outputs:a_normalf3_array_inf', 'normal3f[]', 0, None, 'normalf3_array Infinity', {}, True, None, False, ''),
('outputs:a_normalf3_array_nan', 'normal3f[]', 0, None, 'normalf3_array NaN', {}, True, None, False, ''),
('outputs:a_normalf3_array_ninf', 'normal3f[]', 0, None, 'normalf3_array -Infinity', {}, True, None, False, ''),
('outputs:a_normalf3_array_snan', 'normal3f[]', 0, None, 'normalf3_array sNaN', {}, True, None, False, ''),
('outputs:a_normalf3_inf', 'normal3f', 0, None, 'normalf3 Infinity', {}, True, None, False, ''),
('outputs:a_normalf3_nan', 'normal3f', 0, None, 'normalf3 NaN', {}, True, None, False, ''),
('outputs:a_normalf3_ninf', 'normal3f', 0, None, 'normalf3 -Infinity', {}, True, None, False, ''),
('outputs:a_normalf3_snan', 'normal3f', 0, None, 'normalf3 sNaN', {}, True, None, False, ''),
('outputs:a_normalh3_array_inf', 'normal3h[]', 0, None, 'normalh3_array Infinity', {}, True, None, False, ''),
('outputs:a_normalh3_array_nan', 'normal3h[]', 0, None, 'normalh3_array NaN', {}, True, None, False, ''),
('outputs:a_normalh3_array_ninf', 'normal3h[]', 0, None, 'normalh3_array -Infinity', {}, True, None, False, ''),
('outputs:a_normalh3_array_snan', 'normal3h[]', 0, None, 'normalh3_array sNaN', {}, True, None, False, ''),
('outputs:a_normalh3_inf', 'normal3h', 0, None, 'normalh3 Infinity', {}, True, None, False, ''),
('outputs:a_normalh3_nan', 'normal3h', 0, None, 'normalh3 NaN', {}, True, None, False, ''),
('outputs:a_normalh3_ninf', 'normal3h', 0, None, 'normalh3 -Infinity', {}, True, None, False, ''),
('outputs:a_normalh3_snan', 'normal3h', 0, None, 'normalh3 sNaN', {}, True, None, False, ''),
('outputs:a_pointd3_array_inf', 'point3d[]', 0, None, 'pointd3_array Infinity', {}, True, None, False, ''),
('outputs:a_pointd3_array_nan', 'point3d[]', 0, None, 'pointd3_array NaN', {}, True, None, False, ''),
('outputs:a_pointd3_array_ninf', 'point3d[]', 0, None, 'pointd3_array -Infinity', {}, True, None, False, ''),
('outputs:a_pointd3_array_snan', 'point3d[]', 0, None, 'pointd3_array sNaN', {}, True, None, False, ''),
('outputs:a_pointd3_inf', 'point3d', 0, None, 'pointd3 Infinity', {}, True, None, False, ''),
('outputs:a_pointd3_nan', 'point3d', 0, None, 'pointd3 NaN', {}, True, None, False, ''),
('outputs:a_pointd3_ninf', 'point3d', 0, None, 'pointd3 -Infinity', {}, True, None, False, ''),
('outputs:a_pointd3_snan', 'point3d', 0, None, 'pointd3 sNaN', {}, True, None, False, ''),
('outputs:a_pointf3_array_inf', 'point3f[]', 0, None, 'pointf3_array Infinity', {}, True, None, False, ''),
('outputs:a_pointf3_array_nan', 'point3f[]', 0, None, 'pointf3_array NaN', {}, True, None, False, ''),
('outputs:a_pointf3_array_ninf', 'point3f[]', 0, None, 'pointf3_array -Infinity', {}, True, None, False, ''),
('outputs:a_pointf3_array_snan', 'point3f[]', 0, None, 'pointf3_array sNaN', {}, True, None, False, ''),
('outputs:a_pointf3_inf', 'point3f', 0, None, 'pointf3 Infinity', {}, True, None, False, ''),
('outputs:a_pointf3_nan', 'point3f', 0, None, 'pointf3 NaN', {}, True, None, False, ''),
('outputs:a_pointf3_ninf', 'point3f', 0, None, 'pointf3 -Infinity', {}, True, None, False, ''),
('outputs:a_pointf3_snan', 'point3f', 0, None, 'pointf3 sNaN', {}, True, None, False, ''),
('outputs:a_pointh3_array_inf', 'point3h[]', 0, None, 'pointh3_array Infinity', {}, True, None, False, ''),
('outputs:a_pointh3_array_nan', 'point3h[]', 0, None, 'pointh3_array NaN', {}, True, None, False, ''),
('outputs:a_pointh3_array_ninf', 'point3h[]', 0, None, 'pointh3_array -Infinity', {}, True, None, False, ''),
('outputs:a_pointh3_array_snan', 'point3h[]', 0, None, 'pointh3_array sNaN', {}, True, None, False, ''),
('outputs:a_pointh3_inf', 'point3h', 0, None, 'pointh3 Infinity', {}, True, None, False, ''),
('outputs:a_pointh3_nan', 'point3h', 0, None, 'pointh3 NaN', {}, True, None, False, ''),
('outputs:a_pointh3_ninf', 'point3h', 0, None, 'pointh3 -Infinity', {}, True, None, False, ''),
('outputs:a_pointh3_snan', 'point3h', 0, None, 'pointh3 sNaN', {}, True, None, False, ''),
('outputs:a_quatd4_array_inf', 'quatd[]', 0, None, 'quatd4_array Infinity', {}, True, None, False, ''),
('outputs:a_quatd4_array_nan', 'quatd[]', 0, None, 'quatd4_array NaN', {}, True, None, False, ''),
('outputs:a_quatd4_array_ninf', 'quatd[]', 0, None, 'quatd4_array -Infinity', {}, True, None, False, ''),
('outputs:a_quatd4_array_snan', 'quatd[]', 0, None, 'quatd4_array sNaN', {}, True, None, False, ''),
('outputs:a_quatd4_inf', 'quatd', 0, None, 'quatd4 Infinity', {}, True, None, False, ''),
('outputs:a_quatd4_nan', 'quatd', 0, None, 'quatd4 NaN', {}, True, None, False, ''),
('outputs:a_quatd4_ninf', 'quatd', 0, None, 'quatd4 -Infinity', {}, True, None, False, ''),
('outputs:a_quatd4_snan', 'quatd', 0, None, 'quatd4 sNaN', {}, True, None, False, ''),
('outputs:a_quatf4_array_inf', 'quatf[]', 0, None, 'quatf4_array Infinity', {}, True, None, False, ''),
('outputs:a_quatf4_array_nan', 'quatf[]', 0, None, 'quatf4_array NaN', {}, True, None, False, ''),
('outputs:a_quatf4_array_ninf', 'quatf[]', 0, None, 'quatf4_array -Infinity', {}, True, None, False, ''),
('outputs:a_quatf4_array_snan', 'quatf[]', 0, None, 'quatf4_array sNaN', {}, True, None, False, ''),
('outputs:a_quatf4_inf', 'quatf', 0, None, 'quatf4 Infinity', {}, True, None, False, ''),
('outputs:a_quatf4_nan', 'quatf', 0, None, 'quatf4 NaN', {}, True, None, False, ''),
('outputs:a_quatf4_ninf', 'quatf', 0, None, 'quatf4 -Infinity', {}, True, None, False, ''),
('outputs:a_quatf4_snan', 'quatf', 0, None, 'quatf4 sNaN', {}, True, None, False, ''),
('outputs:a_quath4_array_inf', 'quath[]', 0, None, 'quath4_array Infinity', {}, True, None, False, ''),
('outputs:a_quath4_array_nan', 'quath[]', 0, None, 'quath4_array NaN', {}, True, None, False, ''),
('outputs:a_quath4_array_ninf', 'quath[]', 0, None, 'quath4_array -Infinity', {}, True, None, False, ''),
('outputs:a_quath4_array_snan', 'quath[]', 0, None, 'quath4_array sNaN', {}, True, None, False, ''),
('outputs:a_quath4_inf', 'quath', 0, None, 'quath4 Infinity', {}, True, None, False, ''),
('outputs:a_quath4_nan', 'quath', 0, None, 'quath4 NaN', {}, True, None, False, ''),
('outputs:a_quath4_ninf', 'quath', 0, None, 'quath4 -Infinity', {}, True, None, False, ''),
('outputs:a_quath4_snan', 'quath', 0, None, 'quath4 sNaN', {}, True, None, False, ''),
('outputs:a_texcoordd2_array_inf', 'texCoord2d[]', 0, None, 'texcoordd2_array Infinity', {}, True, None, False, ''),
('outputs:a_texcoordd2_array_nan', 'texCoord2d[]', 0, None, 'texcoordd2_array NaN', {}, True, None, False, ''),
('outputs:a_texcoordd2_array_ninf', 'texCoord2d[]', 0, None, 'texcoordd2_array -Infinity', {}, True, None, False, ''),
('outputs:a_texcoordd2_array_snan', 'texCoord2d[]', 0, None, 'texcoordd2_array sNaN', {}, True, None, False, ''),
('outputs:a_texcoordd2_inf', 'texCoord2d', 0, None, 'texcoordd2 Infinity', {}, True, None, False, ''),
('outputs:a_texcoordd2_nan', 'texCoord2d', 0, None, 'texcoordd2 NaN', {}, True, None, False, ''),
('outputs:a_texcoordd2_ninf', 'texCoord2d', 0, None, 'texcoordd2 -Infinity', {}, True, None, False, ''),
('outputs:a_texcoordd2_snan', 'texCoord2d', 0, None, 'texcoordd2 sNaN', {}, True, None, False, ''),
('outputs:a_texcoordd3_array_inf', 'texCoord3d[]', 0, None, 'texcoordd3_array Infinity', {}, True, None, False, ''),
('outputs:a_texcoordd3_array_nan', 'texCoord3d[]', 0, None, 'texcoordd3_array NaN', {}, True, None, False, ''),
('outputs:a_texcoordd3_array_ninf', 'texCoord3d[]', 0, None, 'texcoordd3_array -Infinity', {}, True, None, False, ''),
('outputs:a_texcoordd3_array_snan', 'texCoord3d[]', 0, None, 'texcoordd3_array sNaN', {}, True, None, False, ''),
('outputs:a_texcoordd3_inf', 'texCoord3d', 0, None, 'texcoordd3 Infinity', {}, True, None, False, ''),
('outputs:a_texcoordd3_nan', 'texCoord3d', 0, None, 'texcoordd3 NaN', {}, True, None, False, ''),
('outputs:a_texcoordd3_ninf', 'texCoord3d', 0, None, 'texcoordd3 -Infinity', {}, True, None, False, ''),
('outputs:a_texcoordd3_snan', 'texCoord3d', 0, None, 'texcoordd3 sNaN', {}, True, None, False, ''),
('outputs:a_texcoordf2_array_inf', 'texCoord2f[]', 0, None, 'texcoordf2_array Infinity', {}, True, None, False, ''),
('outputs:a_texcoordf2_array_nan', 'texCoord2f[]', 0, None, 'texcoordf2_array NaN', {}, True, None, False, ''),
('outputs:a_texcoordf2_array_ninf', 'texCoord2f[]', 0, None, 'texcoordf2_array -Infinity', {}, True, None, False, ''),
('outputs:a_texcoordf2_array_snan', 'texCoord2f[]', 0, None, 'texcoordf2_array sNaN', {}, True, None, False, ''),
('outputs:a_texcoordf2_inf', 'texCoord2f', 0, None, 'texcoordf2 Infinity', {}, True, None, False, ''),
('outputs:a_texcoordf2_nan', 'texCoord2f', 0, None, 'texcoordf2 NaN', {}, True, None, False, ''),
('outputs:a_texcoordf2_ninf', 'texCoord2f', 0, None, 'texcoordf2 -Infinity', {}, True, None, False, ''),
('outputs:a_texcoordf2_snan', 'texCoord2f', 0, None, 'texcoordf2 sNaN', {}, True, None, False, ''),
('outputs:a_texcoordf3_array_inf', 'texCoord3f[]', 0, None, 'texcoordf3_array Infinity', {}, True, None, False, ''),
('outputs:a_texcoordf3_array_nan', 'texCoord3f[]', 0, None, 'texcoordf3_array NaN', {}, True, None, False, ''),
('outputs:a_texcoordf3_array_ninf', 'texCoord3f[]', 0, None, 'texcoordf3_array -Infinity', {}, True, None, False, ''),
('outputs:a_texcoordf3_array_snan', 'texCoord3f[]', 0, None, 'texcoordf3_array sNaN', {}, True, None, False, ''),
('outputs:a_texcoordf3_inf', 'texCoord3f', 0, None, 'texcoordf3 Infinity', {}, True, None, False, ''),
('outputs:a_texcoordf3_nan', 'texCoord3f', 0, None, 'texcoordf3 NaN', {}, True, None, False, ''),
('outputs:a_texcoordf3_ninf', 'texCoord3f', 0, None, 'texcoordf3 -Infinity', {}, True, None, False, ''),
('outputs:a_texcoordf3_snan', 'texCoord3f', 0, None, 'texcoordf3 sNaN', {}, True, None, False, ''),
('outputs:a_texcoordh2_array_inf', 'texCoord2h[]', 0, None, 'texcoordh2_array Infinity', {}, True, None, False, ''),
('outputs:a_texcoordh2_array_nan', 'texCoord2h[]', 0, None, 'texcoordh2_array NaN', {}, True, None, False, ''),
('outputs:a_texcoordh2_array_ninf', 'texCoord2h[]', 0, None, 'texcoordh2_array -Infinity', {}, True, None, False, ''),
('outputs:a_texcoordh2_array_snan', 'texCoord2h[]', 0, None, 'texcoordh2_array sNaN', {}, True, None, False, ''),
('outputs:a_texcoordh2_inf', 'texCoord2h', 0, None, 'texcoordh2 Infinity', {}, True, None, False, ''),
('outputs:a_texcoordh2_nan', 'texCoord2h', 0, None, 'texcoordh2 NaN', {}, True, None, False, ''),
('outputs:a_texcoordh2_ninf', 'texCoord2h', 0, None, 'texcoordh2 -Infinity', {}, True, None, False, ''),
('outputs:a_texcoordh2_snan', 'texCoord2h', 0, None, 'texcoordh2 sNaN', {}, True, None, False, ''),
('outputs:a_texcoordh3_array_inf', 'texCoord3h[]', 0, None, 'texcoordh3_array Infinity', {}, True, None, False, ''),
('outputs:a_texcoordh3_array_nan', 'texCoord3h[]', 0, None, 'texcoordh3_array NaN', {}, True, None, False, ''),
('outputs:a_texcoordh3_array_ninf', 'texCoord3h[]', 0, None, 'texcoordh3_array -Infinity', {}, True, None, False, ''),
('outputs:a_texcoordh3_array_snan', 'texCoord3h[]', 0, None, 'texcoordh3_array sNaN', {}, True, None, False, ''),
('outputs:a_texcoordh3_inf', 'texCoord3h', 0, None, 'texcoordh3 Infinity', {}, True, None, False, ''),
('outputs:a_texcoordh3_nan', 'texCoord3h', 0, None, 'texcoordh3 NaN', {}, True, None, False, ''),
('outputs:a_texcoordh3_ninf', 'texCoord3h', 0, None, 'texcoordh3 -Infinity', {}, True, None, False, ''),
('outputs:a_texcoordh3_snan', 'texCoord3h', 0, None, 'texcoordh3 sNaN', {}, True, None, False, ''),
('outputs:a_timecode_array_inf', 'timecode[]', 0, None, 'timecode_array Infinity', {}, True, None, False, ''),
('outputs:a_timecode_array_nan', 'timecode[]', 0, None, 'timecode_array NaN', {}, True, None, False, ''),
('outputs:a_timecode_array_ninf', 'timecode[]', 0, None, 'timecode_array -Infinity', {}, True, None, False, ''),
('outputs:a_timecode_array_snan', 'timecode[]', 0, None, 'timecode_array sNaN', {}, True, None, False, ''),
('outputs:a_timecode_inf', 'timecode', 0, None, 'timecode Infinity', {}, True, None, False, ''),
('outputs:a_timecode_nan', 'timecode', 0, None, 'timecode NaN', {}, True, None, False, ''),
('outputs:a_timecode_ninf', 'timecode', 0, None, 'timecode -Infinity', {}, True, None, False, ''),
('outputs:a_timecode_snan', 'timecode', 0, None, 'timecode sNaN', {}, True, None, False, ''),
('outputs:a_vectord3_array_inf', 'vector3d[]', 0, None, 'vectord3_array Infinity', {}, True, None, False, ''),
('outputs:a_vectord3_array_nan', 'vector3d[]', 0, None, 'vectord3_array NaN', {}, True, None, False, ''),
('outputs:a_vectord3_array_ninf', 'vector3d[]', 0, None, 'vectord3_array -Infinity', {}, True, None, False, ''),
('outputs:a_vectord3_array_snan', 'vector3d[]', 0, None, 'vectord3_array sNaN', {}, True, None, False, ''),
('outputs:a_vectord3_inf', 'vector3d', 0, None, 'vectord3 Infinity', {}, True, None, False, ''),
('outputs:a_vectord3_nan', 'vector3d', 0, None, 'vectord3 NaN', {}, True, None, False, ''),
('outputs:a_vectord3_ninf', 'vector3d', 0, None, 'vectord3 -Infinity', {}, True, None, False, ''),
('outputs:a_vectord3_snan', 'vector3d', 0, None, 'vectord3 sNaN', {}, True, None, False, ''),
('outputs:a_vectorf3_array_inf', 'vector3f[]', 0, None, 'vectorf3_array Infinity', {}, True, None, False, ''),
('outputs:a_vectorf3_array_nan', 'vector3f[]', 0, None, 'vectorf3_array NaN', {}, True, None, False, ''),
('outputs:a_vectorf3_array_ninf', 'vector3f[]', 0, None, 'vectorf3_array -Infinity', {}, True, None, False, ''),
('outputs:a_vectorf3_array_snan', 'vector3f[]', 0, None, 'vectorf3_array sNaN', {}, True, None, False, ''),
('outputs:a_vectorf3_inf', 'vector3f', 0, None, 'vectorf3 Infinity', {}, True, None, False, ''),
('outputs:a_vectorf3_nan', 'vector3f', 0, None, 'vectorf3 NaN', {}, True, None, False, ''),
('outputs:a_vectorf3_ninf', 'vector3f', 0, None, 'vectorf3 -Infinity', {}, True, None, False, ''),
('outputs:a_vectorf3_snan', 'vector3f', 0, None, 'vectorf3 sNaN', {}, True, None, False, ''),
('outputs:a_vectorh3_array_inf', 'vector3h[]', 0, None, 'vectorh3_array Infinity', {}, True, None, False, ''),
('outputs:a_vectorh3_array_nan', 'vector3h[]', 0, None, 'vectorh3_array NaN', {}, True, None, False, ''),
('outputs:a_vectorh3_array_ninf', 'vector3h[]', 0, None, 'vectorh3_array -Infinity', {}, True, None, False, ''),
('outputs:a_vectorh3_array_snan', 'vector3h[]', 0, None, 'vectorh3_array sNaN', {}, True, None, False, ''),
('outputs:a_vectorh3_inf', 'vector3h', 0, None, 'vectorh3 Infinity', {}, True, None, False, ''),
('outputs:a_vectorh3_nan', 'vector3h', 0, None, 'vectorh3 NaN', {}, True, None, False, ''),
('outputs:a_vectorh3_ninf', 'vector3h', 0, None, 'vectorh3 -Infinity', {}, True, None, False, ''),
('outputs:a_vectorh3_snan', 'vector3h', 0, None, 'vectorh3 sNaN', {}, 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.a_colord3_array_inf = og.AttributeRole.COLOR
role_data.inputs.a_colord3_array_nan = og.AttributeRole.COLOR
role_data.inputs.a_colord3_array_ninf = og.AttributeRole.COLOR
role_data.inputs.a_colord3_array_snan = og.AttributeRole.COLOR
role_data.inputs.a_colord3_inf = og.AttributeRole.COLOR
role_data.inputs.a_colord3_nan = og.AttributeRole.COLOR
role_data.inputs.a_colord3_ninf = og.AttributeRole.COLOR
role_data.inputs.a_colord3_snan = og.AttributeRole.COLOR
role_data.inputs.a_colord4_array_inf = og.AttributeRole.COLOR
role_data.inputs.a_colord4_array_nan = og.AttributeRole.COLOR
role_data.inputs.a_colord4_array_ninf = og.AttributeRole.COLOR
role_data.inputs.a_colord4_array_snan = og.AttributeRole.COLOR
role_data.inputs.a_colord4_inf = og.AttributeRole.COLOR
role_data.inputs.a_colord4_nan = og.AttributeRole.COLOR
role_data.inputs.a_colord4_ninf = og.AttributeRole.COLOR
role_data.inputs.a_colord4_snan = og.AttributeRole.COLOR
role_data.inputs.a_colorf3_array_inf = og.AttributeRole.COLOR
role_data.inputs.a_colorf3_array_nan = og.AttributeRole.COLOR
role_data.inputs.a_colorf3_array_ninf = og.AttributeRole.COLOR
role_data.inputs.a_colorf3_array_snan = og.AttributeRole.COLOR
role_data.inputs.a_colorf3_inf = og.AttributeRole.COLOR
role_data.inputs.a_colorf3_nan = og.AttributeRole.COLOR
role_data.inputs.a_colorf3_ninf = og.AttributeRole.COLOR
role_data.inputs.a_colorf3_snan = og.AttributeRole.COLOR
role_data.inputs.a_colorf4_array_inf = og.AttributeRole.COLOR
role_data.inputs.a_colorf4_array_nan = og.AttributeRole.COLOR
role_data.inputs.a_colorf4_array_ninf = og.AttributeRole.COLOR
role_data.inputs.a_colorf4_array_snan = og.AttributeRole.COLOR
role_data.inputs.a_colorf4_inf = og.AttributeRole.COLOR
role_data.inputs.a_colorf4_nan = og.AttributeRole.COLOR
role_data.inputs.a_colorf4_ninf = og.AttributeRole.COLOR
role_data.inputs.a_colorf4_snan = og.AttributeRole.COLOR
role_data.inputs.a_colorh3_array_inf = og.AttributeRole.COLOR
role_data.inputs.a_colorh3_array_nan = og.AttributeRole.COLOR
role_data.inputs.a_colorh3_array_ninf = og.AttributeRole.COLOR
role_data.inputs.a_colorh3_array_snan = og.AttributeRole.COLOR
role_data.inputs.a_colorh3_inf = og.AttributeRole.COLOR
role_data.inputs.a_colorh3_nan = og.AttributeRole.COLOR
role_data.inputs.a_colorh3_ninf = og.AttributeRole.COLOR
role_data.inputs.a_colorh3_snan = og.AttributeRole.COLOR
role_data.inputs.a_colorh4_array_inf = og.AttributeRole.COLOR
role_data.inputs.a_colorh4_array_nan = og.AttributeRole.COLOR
role_data.inputs.a_colorh4_array_ninf = og.AttributeRole.COLOR
role_data.inputs.a_colorh4_array_snan = og.AttributeRole.COLOR
role_data.inputs.a_colorh4_inf = og.AttributeRole.COLOR
role_data.inputs.a_colorh4_nan = og.AttributeRole.COLOR
role_data.inputs.a_colorh4_ninf = og.AttributeRole.COLOR
role_data.inputs.a_colorh4_snan = og.AttributeRole.COLOR
role_data.inputs.a_frame4_array_inf = og.AttributeRole.FRAME
role_data.inputs.a_frame4_array_nan = og.AttributeRole.FRAME
role_data.inputs.a_frame4_array_ninf = og.AttributeRole.FRAME
role_data.inputs.a_frame4_array_snan = og.AttributeRole.FRAME
role_data.inputs.a_frame4_inf = og.AttributeRole.FRAME
role_data.inputs.a_frame4_nan = og.AttributeRole.FRAME
role_data.inputs.a_frame4_ninf = og.AttributeRole.FRAME
role_data.inputs.a_frame4_snan = og.AttributeRole.FRAME
role_data.inputs.a_matrixd2_array_inf = og.AttributeRole.MATRIX
role_data.inputs.a_matrixd2_array_nan = og.AttributeRole.MATRIX
role_data.inputs.a_matrixd2_array_ninf = og.AttributeRole.MATRIX
role_data.inputs.a_matrixd2_array_snan = og.AttributeRole.MATRIX
role_data.inputs.a_matrixd2_inf = og.AttributeRole.MATRIX
role_data.inputs.a_matrixd2_nan = og.AttributeRole.MATRIX
role_data.inputs.a_matrixd2_ninf = og.AttributeRole.MATRIX
role_data.inputs.a_matrixd2_snan = og.AttributeRole.MATRIX
role_data.inputs.a_matrixd3_array_inf = og.AttributeRole.MATRIX
role_data.inputs.a_matrixd3_array_nan = og.AttributeRole.MATRIX
role_data.inputs.a_matrixd3_array_ninf = og.AttributeRole.MATRIX
role_data.inputs.a_matrixd3_array_snan = og.AttributeRole.MATRIX
role_data.inputs.a_matrixd3_inf = og.AttributeRole.MATRIX
role_data.inputs.a_matrixd3_nan = og.AttributeRole.MATRIX
role_data.inputs.a_matrixd3_ninf = og.AttributeRole.MATRIX
role_data.inputs.a_matrixd3_snan = og.AttributeRole.MATRIX
role_data.inputs.a_matrixd4_array_inf = og.AttributeRole.MATRIX
role_data.inputs.a_matrixd4_array_nan = og.AttributeRole.MATRIX
role_data.inputs.a_matrixd4_array_ninf = og.AttributeRole.MATRIX
role_data.inputs.a_matrixd4_array_snan = og.AttributeRole.MATRIX
role_data.inputs.a_matrixd4_inf = og.AttributeRole.MATRIX
role_data.inputs.a_matrixd4_nan = og.AttributeRole.MATRIX
role_data.inputs.a_matrixd4_ninf = og.AttributeRole.MATRIX
role_data.inputs.a_matrixd4_snan = og.AttributeRole.MATRIX
role_data.inputs.a_normald3_array_inf = og.AttributeRole.NORMAL
role_data.inputs.a_normald3_array_nan = og.AttributeRole.NORMAL
role_data.inputs.a_normald3_array_ninf = og.AttributeRole.NORMAL
role_data.inputs.a_normald3_array_snan = og.AttributeRole.NORMAL
role_data.inputs.a_normald3_inf = og.AttributeRole.NORMAL
role_data.inputs.a_normald3_nan = og.AttributeRole.NORMAL
role_data.inputs.a_normald3_ninf = og.AttributeRole.NORMAL
role_data.inputs.a_normald3_snan = og.AttributeRole.NORMAL
role_data.inputs.a_normalf3_array_inf = og.AttributeRole.NORMAL
role_data.inputs.a_normalf3_array_nan = og.AttributeRole.NORMAL
role_data.inputs.a_normalf3_array_ninf = og.AttributeRole.NORMAL
role_data.inputs.a_normalf3_array_snan = og.AttributeRole.NORMAL
role_data.inputs.a_normalf3_inf = og.AttributeRole.NORMAL
role_data.inputs.a_normalf3_nan = og.AttributeRole.NORMAL
role_data.inputs.a_normalf3_ninf = og.AttributeRole.NORMAL
role_data.inputs.a_normalf3_snan = og.AttributeRole.NORMAL
role_data.inputs.a_normalh3_array_inf = og.AttributeRole.NORMAL
role_data.inputs.a_normalh3_array_nan = og.AttributeRole.NORMAL
role_data.inputs.a_normalh3_array_ninf = og.AttributeRole.NORMAL
role_data.inputs.a_normalh3_array_snan = og.AttributeRole.NORMAL
role_data.inputs.a_normalh3_inf = og.AttributeRole.NORMAL
role_data.inputs.a_normalh3_nan = og.AttributeRole.NORMAL
role_data.inputs.a_normalh3_ninf = og.AttributeRole.NORMAL
role_data.inputs.a_normalh3_snan = og.AttributeRole.NORMAL
role_data.inputs.a_pointd3_array_inf = og.AttributeRole.POSITION
role_data.inputs.a_pointd3_array_nan = og.AttributeRole.POSITION
role_data.inputs.a_pointd3_array_ninf = og.AttributeRole.POSITION
role_data.inputs.a_pointd3_array_snan = og.AttributeRole.POSITION
role_data.inputs.a_pointd3_inf = og.AttributeRole.POSITION
role_data.inputs.a_pointd3_nan = og.AttributeRole.POSITION
role_data.inputs.a_pointd3_ninf = og.AttributeRole.POSITION
role_data.inputs.a_pointd3_snan = og.AttributeRole.POSITION
role_data.inputs.a_pointf3_array_inf = og.AttributeRole.POSITION
role_data.inputs.a_pointf3_array_nan = og.AttributeRole.POSITION
role_data.inputs.a_pointf3_array_ninf = og.AttributeRole.POSITION
role_data.inputs.a_pointf3_array_snan = og.AttributeRole.POSITION
role_data.inputs.a_pointf3_inf = og.AttributeRole.POSITION
role_data.inputs.a_pointf3_nan = og.AttributeRole.POSITION
role_data.inputs.a_pointf3_ninf = og.AttributeRole.POSITION
role_data.inputs.a_pointf3_snan = og.AttributeRole.POSITION
role_data.inputs.a_pointh3_array_inf = og.AttributeRole.POSITION
role_data.inputs.a_pointh3_array_nan = og.AttributeRole.POSITION
role_data.inputs.a_pointh3_array_ninf = og.AttributeRole.POSITION
role_data.inputs.a_pointh3_array_snan = og.AttributeRole.POSITION
role_data.inputs.a_pointh3_inf = og.AttributeRole.POSITION
role_data.inputs.a_pointh3_nan = og.AttributeRole.POSITION
role_data.inputs.a_pointh3_ninf = og.AttributeRole.POSITION
role_data.inputs.a_pointh3_snan = og.AttributeRole.POSITION
role_data.inputs.a_quatd4_array_inf = og.AttributeRole.QUATERNION
role_data.inputs.a_quatd4_array_nan = og.AttributeRole.QUATERNION
role_data.inputs.a_quatd4_array_ninf = og.AttributeRole.QUATERNION
role_data.inputs.a_quatd4_array_snan = og.AttributeRole.QUATERNION
role_data.inputs.a_quatd4_inf = og.AttributeRole.QUATERNION
role_data.inputs.a_quatd4_nan = og.AttributeRole.QUATERNION
role_data.inputs.a_quatd4_ninf = og.AttributeRole.QUATERNION
role_data.inputs.a_quatd4_snan = og.AttributeRole.QUATERNION
role_data.inputs.a_quatf4_array_inf = og.AttributeRole.QUATERNION
role_data.inputs.a_quatf4_array_nan = og.AttributeRole.QUATERNION
role_data.inputs.a_quatf4_array_ninf = og.AttributeRole.QUATERNION
role_data.inputs.a_quatf4_array_snan = og.AttributeRole.QUATERNION
role_data.inputs.a_quatf4_inf = og.AttributeRole.QUATERNION
role_data.inputs.a_quatf4_nan = og.AttributeRole.QUATERNION
role_data.inputs.a_quatf4_ninf = og.AttributeRole.QUATERNION
role_data.inputs.a_quatf4_snan = og.AttributeRole.QUATERNION
role_data.inputs.a_quath4_array_inf = og.AttributeRole.QUATERNION
role_data.inputs.a_quath4_array_nan = og.AttributeRole.QUATERNION
role_data.inputs.a_quath4_array_ninf = og.AttributeRole.QUATERNION
role_data.inputs.a_quath4_array_snan = og.AttributeRole.QUATERNION
role_data.inputs.a_quath4_inf = og.AttributeRole.QUATERNION
role_data.inputs.a_quath4_nan = og.AttributeRole.QUATERNION
role_data.inputs.a_quath4_ninf = og.AttributeRole.QUATERNION
role_data.inputs.a_quath4_snan = og.AttributeRole.QUATERNION
role_data.inputs.a_texcoordd2_array_inf = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordd2_array_nan = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordd2_array_ninf = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordd2_array_snan = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordd2_inf = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordd2_nan = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordd2_ninf = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordd2_snan = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordd3_array_inf = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordd3_array_nan = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordd3_array_ninf = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordd3_array_snan = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordd3_inf = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordd3_nan = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordd3_ninf = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordd3_snan = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordf2_array_inf = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordf2_array_nan = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordf2_array_ninf = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordf2_array_snan = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordf2_inf = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordf2_nan = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordf2_ninf = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordf2_snan = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordf3_array_inf = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordf3_array_nan = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordf3_array_ninf = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordf3_array_snan = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordf3_inf = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordf3_nan = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordf3_ninf = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordf3_snan = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordh2_array_inf = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordh2_array_nan = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordh2_array_ninf = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordh2_array_snan = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordh2_inf = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordh2_nan = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordh2_ninf = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordh2_snan = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordh3_array_inf = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordh3_array_nan = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordh3_array_ninf = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordh3_array_snan = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordh3_inf = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordh3_nan = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordh3_ninf = og.AttributeRole.TEXCOORD
role_data.inputs.a_texcoordh3_snan = og.AttributeRole.TEXCOORD
role_data.inputs.a_timecode_array_inf = og.AttributeRole.TIMECODE
role_data.inputs.a_timecode_array_nan = og.AttributeRole.TIMECODE
role_data.inputs.a_timecode_array_ninf = og.AttributeRole.TIMECODE
role_data.inputs.a_timecode_array_snan = og.AttributeRole.TIMECODE
role_data.inputs.a_timecode_inf = og.AttributeRole.TIMECODE
role_data.inputs.a_timecode_nan = og.AttributeRole.TIMECODE
role_data.inputs.a_timecode_ninf = og.AttributeRole.TIMECODE
role_data.inputs.a_timecode_snan = og.AttributeRole.TIMECODE
role_data.inputs.a_vectord3_array_inf = og.AttributeRole.VECTOR
role_data.inputs.a_vectord3_array_nan = og.AttributeRole.VECTOR
role_data.inputs.a_vectord3_array_ninf = og.AttributeRole.VECTOR
role_data.inputs.a_vectord3_array_snan = og.AttributeRole.VECTOR
role_data.inputs.a_vectord3_inf = og.AttributeRole.VECTOR
role_data.inputs.a_vectord3_nan = og.AttributeRole.VECTOR
role_data.inputs.a_vectord3_ninf = og.AttributeRole.VECTOR
role_data.inputs.a_vectord3_snan = og.AttributeRole.VECTOR
role_data.inputs.a_vectorf3_array_inf = og.AttributeRole.VECTOR
role_data.inputs.a_vectorf3_array_nan = og.AttributeRole.VECTOR
role_data.inputs.a_vectorf3_array_ninf = og.AttributeRole.VECTOR
role_data.inputs.a_vectorf3_array_snan = og.AttributeRole.VECTOR
role_data.inputs.a_vectorf3_inf = og.AttributeRole.VECTOR
role_data.inputs.a_vectorf3_nan = og.AttributeRole.VECTOR
role_data.inputs.a_vectorf3_ninf = og.AttributeRole.VECTOR
role_data.inputs.a_vectorf3_snan = og.AttributeRole.VECTOR
role_data.inputs.a_vectorh3_array_inf = og.AttributeRole.VECTOR
role_data.inputs.a_vectorh3_array_nan = og.AttributeRole.VECTOR
role_data.inputs.a_vectorh3_array_ninf = og.AttributeRole.VECTOR
role_data.inputs.a_vectorh3_array_snan = og.AttributeRole.VECTOR
role_data.inputs.a_vectorh3_inf = og.AttributeRole.VECTOR
role_data.inputs.a_vectorh3_nan = og.AttributeRole.VECTOR
role_data.inputs.a_vectorh3_ninf = og.AttributeRole.VECTOR
role_data.inputs.a_vectorh3_snan = og.AttributeRole.VECTOR
role_data.outputs.a_colord3_array_inf = og.AttributeRole.COLOR
role_data.outputs.a_colord3_array_nan = og.AttributeRole.COLOR
role_data.outputs.a_colord3_array_ninf = og.AttributeRole.COLOR
role_data.outputs.a_colord3_array_snan = og.AttributeRole.COLOR
role_data.outputs.a_colord3_inf = og.AttributeRole.COLOR
role_data.outputs.a_colord3_nan = og.AttributeRole.COLOR
role_data.outputs.a_colord3_ninf = og.AttributeRole.COLOR
role_data.outputs.a_colord3_snan = og.AttributeRole.COLOR
role_data.outputs.a_colord4_array_inf = og.AttributeRole.COLOR
role_data.outputs.a_colord4_array_nan = og.AttributeRole.COLOR
role_data.outputs.a_colord4_array_ninf = og.AttributeRole.COLOR
role_data.outputs.a_colord4_array_snan = og.AttributeRole.COLOR
role_data.outputs.a_colord4_inf = og.AttributeRole.COLOR
role_data.outputs.a_colord4_nan = og.AttributeRole.COLOR
role_data.outputs.a_colord4_ninf = og.AttributeRole.COLOR
role_data.outputs.a_colord4_snan = og.AttributeRole.COLOR
role_data.outputs.a_colorf3_array_inf = og.AttributeRole.COLOR
role_data.outputs.a_colorf3_array_nan = og.AttributeRole.COLOR
role_data.outputs.a_colorf3_array_ninf = og.AttributeRole.COLOR
role_data.outputs.a_colorf3_array_snan = og.AttributeRole.COLOR
role_data.outputs.a_colorf3_inf = og.AttributeRole.COLOR
role_data.outputs.a_colorf3_nan = og.AttributeRole.COLOR
role_data.outputs.a_colorf3_ninf = og.AttributeRole.COLOR
role_data.outputs.a_colorf3_snan = og.AttributeRole.COLOR
role_data.outputs.a_colorf4_array_inf = og.AttributeRole.COLOR
role_data.outputs.a_colorf4_array_nan = og.AttributeRole.COLOR
role_data.outputs.a_colorf4_array_ninf = og.AttributeRole.COLOR
role_data.outputs.a_colorf4_array_snan = og.AttributeRole.COLOR
role_data.outputs.a_colorf4_inf = og.AttributeRole.COLOR
role_data.outputs.a_colorf4_nan = og.AttributeRole.COLOR
role_data.outputs.a_colorf4_ninf = og.AttributeRole.COLOR
role_data.outputs.a_colorf4_snan = og.AttributeRole.COLOR
role_data.outputs.a_colorh3_array_inf = og.AttributeRole.COLOR
role_data.outputs.a_colorh3_array_nan = og.AttributeRole.COLOR
role_data.outputs.a_colorh3_array_ninf = og.AttributeRole.COLOR
role_data.outputs.a_colorh3_array_snan = og.AttributeRole.COLOR
role_data.outputs.a_colorh3_inf = og.AttributeRole.COLOR
role_data.outputs.a_colorh3_nan = og.AttributeRole.COLOR
role_data.outputs.a_colorh3_ninf = og.AttributeRole.COLOR
role_data.outputs.a_colorh3_snan = og.AttributeRole.COLOR
role_data.outputs.a_colorh4_array_inf = og.AttributeRole.COLOR
role_data.outputs.a_colorh4_array_nan = og.AttributeRole.COLOR
role_data.outputs.a_colorh4_array_ninf = og.AttributeRole.COLOR
role_data.outputs.a_colorh4_array_snan = og.AttributeRole.COLOR
role_data.outputs.a_colorh4_inf = og.AttributeRole.COLOR
role_data.outputs.a_colorh4_nan = og.AttributeRole.COLOR
role_data.outputs.a_colorh4_ninf = og.AttributeRole.COLOR
role_data.outputs.a_colorh4_snan = og.AttributeRole.COLOR
role_data.outputs.a_frame4_array_inf = og.AttributeRole.FRAME
role_data.outputs.a_frame4_array_nan = og.AttributeRole.FRAME
role_data.outputs.a_frame4_array_ninf = og.AttributeRole.FRAME
role_data.outputs.a_frame4_array_snan = og.AttributeRole.FRAME
role_data.outputs.a_frame4_inf = og.AttributeRole.FRAME
role_data.outputs.a_frame4_nan = og.AttributeRole.FRAME
role_data.outputs.a_frame4_ninf = og.AttributeRole.FRAME
role_data.outputs.a_frame4_snan = og.AttributeRole.FRAME
role_data.outputs.a_matrixd2_array_inf = og.AttributeRole.MATRIX
role_data.outputs.a_matrixd2_array_nan = og.AttributeRole.MATRIX
role_data.outputs.a_matrixd2_array_ninf = og.AttributeRole.MATRIX
role_data.outputs.a_matrixd2_array_snan = og.AttributeRole.MATRIX
role_data.outputs.a_matrixd2_inf = og.AttributeRole.MATRIX
role_data.outputs.a_matrixd2_nan = og.AttributeRole.MATRIX
role_data.outputs.a_matrixd2_ninf = og.AttributeRole.MATRIX
role_data.outputs.a_matrixd2_snan = og.AttributeRole.MATRIX
role_data.outputs.a_matrixd3_array_inf = og.AttributeRole.MATRIX
role_data.outputs.a_matrixd3_array_nan = og.AttributeRole.MATRIX
role_data.outputs.a_matrixd3_array_ninf = og.AttributeRole.MATRIX
role_data.outputs.a_matrixd3_array_snan = og.AttributeRole.MATRIX
role_data.outputs.a_matrixd3_inf = og.AttributeRole.MATRIX
role_data.outputs.a_matrixd3_nan = og.AttributeRole.MATRIX
role_data.outputs.a_matrixd3_ninf = og.AttributeRole.MATRIX
role_data.outputs.a_matrixd3_snan = og.AttributeRole.MATRIX
role_data.outputs.a_matrixd4_array_inf = og.AttributeRole.MATRIX
role_data.outputs.a_matrixd4_array_nan = og.AttributeRole.MATRIX
role_data.outputs.a_matrixd4_array_ninf = og.AttributeRole.MATRIX
role_data.outputs.a_matrixd4_array_snan = og.AttributeRole.MATRIX
role_data.outputs.a_matrixd4_inf = og.AttributeRole.MATRIX
role_data.outputs.a_matrixd4_nan = og.AttributeRole.MATRIX
role_data.outputs.a_matrixd4_ninf = og.AttributeRole.MATRIX
role_data.outputs.a_matrixd4_snan = og.AttributeRole.MATRIX
role_data.outputs.a_normald3_array_inf = og.AttributeRole.NORMAL
role_data.outputs.a_normald3_array_nan = og.AttributeRole.NORMAL
role_data.outputs.a_normald3_array_ninf = og.AttributeRole.NORMAL
role_data.outputs.a_normald3_array_snan = og.AttributeRole.NORMAL
role_data.outputs.a_normald3_inf = og.AttributeRole.NORMAL
role_data.outputs.a_normald3_nan = og.AttributeRole.NORMAL
role_data.outputs.a_normald3_ninf = og.AttributeRole.NORMAL
role_data.outputs.a_normald3_snan = og.AttributeRole.NORMAL
role_data.outputs.a_normalf3_array_inf = og.AttributeRole.NORMAL
role_data.outputs.a_normalf3_array_nan = og.AttributeRole.NORMAL
role_data.outputs.a_normalf3_array_ninf = og.AttributeRole.NORMAL
role_data.outputs.a_normalf3_array_snan = og.AttributeRole.NORMAL
role_data.outputs.a_normalf3_inf = og.AttributeRole.NORMAL
role_data.outputs.a_normalf3_nan = og.AttributeRole.NORMAL
role_data.outputs.a_normalf3_ninf = og.AttributeRole.NORMAL
role_data.outputs.a_normalf3_snan = og.AttributeRole.NORMAL
role_data.outputs.a_normalh3_array_inf = og.AttributeRole.NORMAL
role_data.outputs.a_normalh3_array_nan = og.AttributeRole.NORMAL
role_data.outputs.a_normalh3_array_ninf = og.AttributeRole.NORMAL
role_data.outputs.a_normalh3_array_snan = og.AttributeRole.NORMAL
role_data.outputs.a_normalh3_inf = og.AttributeRole.NORMAL
role_data.outputs.a_normalh3_nan = og.AttributeRole.NORMAL
role_data.outputs.a_normalh3_ninf = og.AttributeRole.NORMAL
role_data.outputs.a_normalh3_snan = og.AttributeRole.NORMAL
role_data.outputs.a_pointd3_array_inf = og.AttributeRole.POSITION
role_data.outputs.a_pointd3_array_nan = og.AttributeRole.POSITION
role_data.outputs.a_pointd3_array_ninf = og.AttributeRole.POSITION
role_data.outputs.a_pointd3_array_snan = og.AttributeRole.POSITION
role_data.outputs.a_pointd3_inf = og.AttributeRole.POSITION
role_data.outputs.a_pointd3_nan = og.AttributeRole.POSITION
role_data.outputs.a_pointd3_ninf = og.AttributeRole.POSITION
role_data.outputs.a_pointd3_snan = og.AttributeRole.POSITION
role_data.outputs.a_pointf3_array_inf = og.AttributeRole.POSITION
role_data.outputs.a_pointf3_array_nan = og.AttributeRole.POSITION
role_data.outputs.a_pointf3_array_ninf = og.AttributeRole.POSITION
role_data.outputs.a_pointf3_array_snan = og.AttributeRole.POSITION
role_data.outputs.a_pointf3_inf = og.AttributeRole.POSITION
role_data.outputs.a_pointf3_nan = og.AttributeRole.POSITION
role_data.outputs.a_pointf3_ninf = og.AttributeRole.POSITION
role_data.outputs.a_pointf3_snan = og.AttributeRole.POSITION
role_data.outputs.a_pointh3_array_inf = og.AttributeRole.POSITION
role_data.outputs.a_pointh3_array_nan = og.AttributeRole.POSITION
role_data.outputs.a_pointh3_array_ninf = og.AttributeRole.POSITION
role_data.outputs.a_pointh3_array_snan = og.AttributeRole.POSITION
role_data.outputs.a_pointh3_inf = og.AttributeRole.POSITION
role_data.outputs.a_pointh3_nan = og.AttributeRole.POSITION
role_data.outputs.a_pointh3_ninf = og.AttributeRole.POSITION
role_data.outputs.a_pointh3_snan = og.AttributeRole.POSITION
role_data.outputs.a_quatd4_array_inf = og.AttributeRole.QUATERNION
role_data.outputs.a_quatd4_array_nan = og.AttributeRole.QUATERNION
role_data.outputs.a_quatd4_array_ninf = og.AttributeRole.QUATERNION
role_data.outputs.a_quatd4_array_snan = og.AttributeRole.QUATERNION
role_data.outputs.a_quatd4_inf = og.AttributeRole.QUATERNION
role_data.outputs.a_quatd4_nan = og.AttributeRole.QUATERNION
role_data.outputs.a_quatd4_ninf = og.AttributeRole.QUATERNION
role_data.outputs.a_quatd4_snan = og.AttributeRole.QUATERNION
role_data.outputs.a_quatf4_array_inf = og.AttributeRole.QUATERNION
role_data.outputs.a_quatf4_array_nan = og.AttributeRole.QUATERNION
role_data.outputs.a_quatf4_array_ninf = og.AttributeRole.QUATERNION
role_data.outputs.a_quatf4_array_snan = og.AttributeRole.QUATERNION
role_data.outputs.a_quatf4_inf = og.AttributeRole.QUATERNION
role_data.outputs.a_quatf4_nan = og.AttributeRole.QUATERNION
role_data.outputs.a_quatf4_ninf = og.AttributeRole.QUATERNION
role_data.outputs.a_quatf4_snan = og.AttributeRole.QUATERNION
role_data.outputs.a_quath4_array_inf = og.AttributeRole.QUATERNION
role_data.outputs.a_quath4_array_nan = og.AttributeRole.QUATERNION
role_data.outputs.a_quath4_array_ninf = og.AttributeRole.QUATERNION
role_data.outputs.a_quath4_array_snan = og.AttributeRole.QUATERNION
role_data.outputs.a_quath4_inf = og.AttributeRole.QUATERNION
role_data.outputs.a_quath4_nan = og.AttributeRole.QUATERNION
role_data.outputs.a_quath4_ninf = og.AttributeRole.QUATERNION
role_data.outputs.a_quath4_snan = og.AttributeRole.QUATERNION
role_data.outputs.a_texcoordd2_array_inf = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordd2_array_nan = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordd2_array_ninf = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordd2_array_snan = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordd2_inf = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordd2_nan = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordd2_ninf = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordd2_snan = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordd3_array_inf = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordd3_array_nan = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordd3_array_ninf = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordd3_array_snan = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordd3_inf = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordd3_nan = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordd3_ninf = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordd3_snan = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordf2_array_inf = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordf2_array_nan = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordf2_array_ninf = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordf2_array_snan = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordf2_inf = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordf2_nan = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordf2_ninf = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordf2_snan = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordf3_array_inf = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordf3_array_nan = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordf3_array_ninf = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordf3_array_snan = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordf3_inf = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordf3_nan = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordf3_ninf = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordf3_snan = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordh2_array_inf = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordh2_array_nan = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordh2_array_ninf = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordh2_array_snan = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordh2_inf = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordh2_nan = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordh2_ninf = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordh2_snan = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordh3_array_inf = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordh3_array_nan = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordh3_array_ninf = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordh3_array_snan = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordh3_inf = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordh3_nan = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordh3_ninf = og.AttributeRole.TEXCOORD
role_data.outputs.a_texcoordh3_snan = og.AttributeRole.TEXCOORD
role_data.outputs.a_timecode_array_inf = og.AttributeRole.TIMECODE
role_data.outputs.a_timecode_array_nan = og.AttributeRole.TIMECODE
role_data.outputs.a_timecode_array_ninf = og.AttributeRole.TIMECODE
role_data.outputs.a_timecode_array_snan = og.AttributeRole.TIMECODE
role_data.outputs.a_timecode_inf = og.AttributeRole.TIMECODE
role_data.outputs.a_timecode_nan = og.AttributeRole.TIMECODE
role_data.outputs.a_timecode_ninf = og.AttributeRole.TIMECODE
role_data.outputs.a_timecode_snan = og.AttributeRole.TIMECODE
role_data.outputs.a_vectord3_array_inf = og.AttributeRole.VECTOR
role_data.outputs.a_vectord3_array_nan = og.AttributeRole.VECTOR
role_data.outputs.a_vectord3_array_ninf = og.AttributeRole.VECTOR
role_data.outputs.a_vectord3_array_snan = og.AttributeRole.VECTOR
role_data.outputs.a_vectord3_inf = og.AttributeRole.VECTOR
role_data.outputs.a_vectord3_nan = og.AttributeRole.VECTOR
role_data.outputs.a_vectord3_ninf = og.AttributeRole.VECTOR
role_data.outputs.a_vectord3_snan = og.AttributeRole.VECTOR
role_data.outputs.a_vectorf3_array_inf = og.AttributeRole.VECTOR
role_data.outputs.a_vectorf3_array_nan = og.AttributeRole.VECTOR
role_data.outputs.a_vectorf3_array_ninf = og.AttributeRole.VECTOR
role_data.outputs.a_vectorf3_array_snan = og.AttributeRole.VECTOR
role_data.outputs.a_vectorf3_inf = og.AttributeRole.VECTOR
role_data.outputs.a_vectorf3_nan = og.AttributeRole.VECTOR
role_data.outputs.a_vectorf3_ninf = og.AttributeRole.VECTOR
role_data.outputs.a_vectorf3_snan = og.AttributeRole.VECTOR
role_data.outputs.a_vectorh3_array_inf = og.AttributeRole.VECTOR
role_data.outputs.a_vectorh3_array_nan = og.AttributeRole.VECTOR
role_data.outputs.a_vectorh3_array_ninf = og.AttributeRole.VECTOR
role_data.outputs.a_vectorh3_array_snan = og.AttributeRole.VECTOR
role_data.outputs.a_vectorh3_inf = og.AttributeRole.VECTOR
role_data.outputs.a_vectorh3_nan = og.AttributeRole.VECTOR
role_data.outputs.a_vectorh3_ninf = og.AttributeRole.VECTOR
role_data.outputs.a_vectorh3_snan = 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 a_colord3_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord3_array_inf)
return data_view.get()
@a_colord3_array_inf.setter
def a_colord3_array_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colord3_array_inf)
data_view = og.AttributeValueHelper(self._attributes.a_colord3_array_inf)
data_view.set(value)
self.a_colord3_array_inf_size = data_view.get_array_size()
@property
def a_colord3_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord3_array_nan)
return data_view.get()
@a_colord3_array_nan.setter
def a_colord3_array_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colord3_array_nan)
data_view = og.AttributeValueHelper(self._attributes.a_colord3_array_nan)
data_view.set(value)
self.a_colord3_array_nan_size = data_view.get_array_size()
@property
def a_colord3_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord3_array_ninf)
return data_view.get()
@a_colord3_array_ninf.setter
def a_colord3_array_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colord3_array_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_colord3_array_ninf)
data_view.set(value)
self.a_colord3_array_ninf_size = data_view.get_array_size()
@property
def a_colord3_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord3_array_snan)
return data_view.get()
@a_colord3_array_snan.setter
def a_colord3_array_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colord3_array_snan)
data_view = og.AttributeValueHelper(self._attributes.a_colord3_array_snan)
data_view.set(value)
self.a_colord3_array_snan_size = data_view.get_array_size()
@property
def a_colord3_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord3_inf)
return data_view.get()
@a_colord3_inf.setter
def a_colord3_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colord3_inf)
data_view = og.AttributeValueHelper(self._attributes.a_colord3_inf)
data_view.set(value)
@property
def a_colord3_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord3_nan)
return data_view.get()
@a_colord3_nan.setter
def a_colord3_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colord3_nan)
data_view = og.AttributeValueHelper(self._attributes.a_colord3_nan)
data_view.set(value)
@property
def a_colord3_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord3_ninf)
return data_view.get()
@a_colord3_ninf.setter
def a_colord3_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colord3_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_colord3_ninf)
data_view.set(value)
@property
def a_colord3_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord3_snan)
return data_view.get()
@a_colord3_snan.setter
def a_colord3_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colord3_snan)
data_view = og.AttributeValueHelper(self._attributes.a_colord3_snan)
data_view.set(value)
@property
def a_colord4_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord4_array_inf)
return data_view.get()
@a_colord4_array_inf.setter
def a_colord4_array_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colord4_array_inf)
data_view = og.AttributeValueHelper(self._attributes.a_colord4_array_inf)
data_view.set(value)
self.a_colord4_array_inf_size = data_view.get_array_size()
@property
def a_colord4_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord4_array_nan)
return data_view.get()
@a_colord4_array_nan.setter
def a_colord4_array_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colord4_array_nan)
data_view = og.AttributeValueHelper(self._attributes.a_colord4_array_nan)
data_view.set(value)
self.a_colord4_array_nan_size = data_view.get_array_size()
@property
def a_colord4_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord4_array_ninf)
return data_view.get()
@a_colord4_array_ninf.setter
def a_colord4_array_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colord4_array_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_colord4_array_ninf)
data_view.set(value)
self.a_colord4_array_ninf_size = data_view.get_array_size()
@property
def a_colord4_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord4_array_snan)
return data_view.get()
@a_colord4_array_snan.setter
def a_colord4_array_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colord4_array_snan)
data_view = og.AttributeValueHelper(self._attributes.a_colord4_array_snan)
data_view.set(value)
self.a_colord4_array_snan_size = data_view.get_array_size()
@property
def a_colord4_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord4_inf)
return data_view.get()
@a_colord4_inf.setter
def a_colord4_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colord4_inf)
data_view = og.AttributeValueHelper(self._attributes.a_colord4_inf)
data_view.set(value)
@property
def a_colord4_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord4_nan)
return data_view.get()
@a_colord4_nan.setter
def a_colord4_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colord4_nan)
data_view = og.AttributeValueHelper(self._attributes.a_colord4_nan)
data_view.set(value)
@property
def a_colord4_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord4_ninf)
return data_view.get()
@a_colord4_ninf.setter
def a_colord4_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colord4_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_colord4_ninf)
data_view.set(value)
@property
def a_colord4_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord4_snan)
return data_view.get()
@a_colord4_snan.setter
def a_colord4_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colord4_snan)
data_view = og.AttributeValueHelper(self._attributes.a_colord4_snan)
data_view.set(value)
@property
def a_colorf3_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf3_array_inf)
return data_view.get()
@a_colorf3_array_inf.setter
def a_colorf3_array_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colorf3_array_inf)
data_view = og.AttributeValueHelper(self._attributes.a_colorf3_array_inf)
data_view.set(value)
self.a_colorf3_array_inf_size = data_view.get_array_size()
@property
def a_colorf3_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf3_array_nan)
return data_view.get()
@a_colorf3_array_nan.setter
def a_colorf3_array_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colorf3_array_nan)
data_view = og.AttributeValueHelper(self._attributes.a_colorf3_array_nan)
data_view.set(value)
self.a_colorf3_array_nan_size = data_view.get_array_size()
@property
def a_colorf3_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf3_array_ninf)
return data_view.get()
@a_colorf3_array_ninf.setter
def a_colorf3_array_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colorf3_array_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_colorf3_array_ninf)
data_view.set(value)
self.a_colorf3_array_ninf_size = data_view.get_array_size()
@property
def a_colorf3_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf3_array_snan)
return data_view.get()
@a_colorf3_array_snan.setter
def a_colorf3_array_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colorf3_array_snan)
data_view = og.AttributeValueHelper(self._attributes.a_colorf3_array_snan)
data_view.set(value)
self.a_colorf3_array_snan_size = data_view.get_array_size()
@property
def a_colorf3_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf3_inf)
return data_view.get()
@a_colorf3_inf.setter
def a_colorf3_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colorf3_inf)
data_view = og.AttributeValueHelper(self._attributes.a_colorf3_inf)
data_view.set(value)
@property
def a_colorf3_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf3_nan)
return data_view.get()
@a_colorf3_nan.setter
def a_colorf3_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colorf3_nan)
data_view = og.AttributeValueHelper(self._attributes.a_colorf3_nan)
data_view.set(value)
@property
def a_colorf3_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf3_ninf)
return data_view.get()
@a_colorf3_ninf.setter
def a_colorf3_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colorf3_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_colorf3_ninf)
data_view.set(value)
@property
def a_colorf3_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf3_snan)
return data_view.get()
@a_colorf3_snan.setter
def a_colorf3_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colorf3_snan)
data_view = og.AttributeValueHelper(self._attributes.a_colorf3_snan)
data_view.set(value)
@property
def a_colorf4_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf4_array_inf)
return data_view.get()
@a_colorf4_array_inf.setter
def a_colorf4_array_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colorf4_array_inf)
data_view = og.AttributeValueHelper(self._attributes.a_colorf4_array_inf)
data_view.set(value)
self.a_colorf4_array_inf_size = data_view.get_array_size()
@property
def a_colorf4_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf4_array_nan)
return data_view.get()
@a_colorf4_array_nan.setter
def a_colorf4_array_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colorf4_array_nan)
data_view = og.AttributeValueHelper(self._attributes.a_colorf4_array_nan)
data_view.set(value)
self.a_colorf4_array_nan_size = data_view.get_array_size()
@property
def a_colorf4_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf4_array_ninf)
return data_view.get()
@a_colorf4_array_ninf.setter
def a_colorf4_array_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colorf4_array_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_colorf4_array_ninf)
data_view.set(value)
self.a_colorf4_array_ninf_size = data_view.get_array_size()
@property
def a_colorf4_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf4_array_snan)
return data_view.get()
@a_colorf4_array_snan.setter
def a_colorf4_array_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colorf4_array_snan)
data_view = og.AttributeValueHelper(self._attributes.a_colorf4_array_snan)
data_view.set(value)
self.a_colorf4_array_snan_size = data_view.get_array_size()
@property
def a_colorf4_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf4_inf)
return data_view.get()
@a_colorf4_inf.setter
def a_colorf4_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colorf4_inf)
data_view = og.AttributeValueHelper(self._attributes.a_colorf4_inf)
data_view.set(value)
@property
def a_colorf4_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf4_nan)
return data_view.get()
@a_colorf4_nan.setter
def a_colorf4_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colorf4_nan)
data_view = og.AttributeValueHelper(self._attributes.a_colorf4_nan)
data_view.set(value)
@property
def a_colorf4_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf4_ninf)
return data_view.get()
@a_colorf4_ninf.setter
def a_colorf4_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colorf4_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_colorf4_ninf)
data_view.set(value)
@property
def a_colorf4_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf4_snan)
return data_view.get()
@a_colorf4_snan.setter
def a_colorf4_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colorf4_snan)
data_view = og.AttributeValueHelper(self._attributes.a_colorf4_snan)
data_view.set(value)
@property
def a_colorh3_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh3_array_inf)
return data_view.get()
@a_colorh3_array_inf.setter
def a_colorh3_array_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colorh3_array_inf)
data_view = og.AttributeValueHelper(self._attributes.a_colorh3_array_inf)
data_view.set(value)
self.a_colorh3_array_inf_size = data_view.get_array_size()
@property
def a_colorh3_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh3_array_nan)
return data_view.get()
@a_colorh3_array_nan.setter
def a_colorh3_array_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colorh3_array_nan)
data_view = og.AttributeValueHelper(self._attributes.a_colorh3_array_nan)
data_view.set(value)
self.a_colorh3_array_nan_size = data_view.get_array_size()
@property
def a_colorh3_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh3_array_ninf)
return data_view.get()
@a_colorh3_array_ninf.setter
def a_colorh3_array_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colorh3_array_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_colorh3_array_ninf)
data_view.set(value)
self.a_colorh3_array_ninf_size = data_view.get_array_size()
@property
def a_colorh3_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh3_array_snan)
return data_view.get()
@a_colorh3_array_snan.setter
def a_colorh3_array_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colorh3_array_snan)
data_view = og.AttributeValueHelper(self._attributes.a_colorh3_array_snan)
data_view.set(value)
self.a_colorh3_array_snan_size = data_view.get_array_size()
@property
def a_colorh3_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh3_inf)
return data_view.get()
@a_colorh3_inf.setter
def a_colorh3_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colorh3_inf)
data_view = og.AttributeValueHelper(self._attributes.a_colorh3_inf)
data_view.set(value)
@property
def a_colorh3_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh3_nan)
return data_view.get()
@a_colorh3_nan.setter
def a_colorh3_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colorh3_nan)
data_view = og.AttributeValueHelper(self._attributes.a_colorh3_nan)
data_view.set(value)
@property
def a_colorh3_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh3_ninf)
return data_view.get()
@a_colorh3_ninf.setter
def a_colorh3_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colorh3_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_colorh3_ninf)
data_view.set(value)
@property
def a_colorh3_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh3_snan)
return data_view.get()
@a_colorh3_snan.setter
def a_colorh3_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colorh3_snan)
data_view = og.AttributeValueHelper(self._attributes.a_colorh3_snan)
data_view.set(value)
@property
def a_colorh4_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh4_array_inf)
return data_view.get()
@a_colorh4_array_inf.setter
def a_colorh4_array_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colorh4_array_inf)
data_view = og.AttributeValueHelper(self._attributes.a_colorh4_array_inf)
data_view.set(value)
self.a_colorh4_array_inf_size = data_view.get_array_size()
@property
def a_colorh4_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh4_array_nan)
return data_view.get()
@a_colorh4_array_nan.setter
def a_colorh4_array_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colorh4_array_nan)
data_view = og.AttributeValueHelper(self._attributes.a_colorh4_array_nan)
data_view.set(value)
self.a_colorh4_array_nan_size = data_view.get_array_size()
@property
def a_colorh4_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh4_array_ninf)
return data_view.get()
@a_colorh4_array_ninf.setter
def a_colorh4_array_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colorh4_array_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_colorh4_array_ninf)
data_view.set(value)
self.a_colorh4_array_ninf_size = data_view.get_array_size()
@property
def a_colorh4_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh4_array_snan)
return data_view.get()
@a_colorh4_array_snan.setter
def a_colorh4_array_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colorh4_array_snan)
data_view = og.AttributeValueHelper(self._attributes.a_colorh4_array_snan)
data_view.set(value)
self.a_colorh4_array_snan_size = data_view.get_array_size()
@property
def a_colorh4_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh4_inf)
return data_view.get()
@a_colorh4_inf.setter
def a_colorh4_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colorh4_inf)
data_view = og.AttributeValueHelper(self._attributes.a_colorh4_inf)
data_view.set(value)
@property
def a_colorh4_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh4_nan)
return data_view.get()
@a_colorh4_nan.setter
def a_colorh4_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colorh4_nan)
data_view = og.AttributeValueHelper(self._attributes.a_colorh4_nan)
data_view.set(value)
@property
def a_colorh4_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh4_ninf)
return data_view.get()
@a_colorh4_ninf.setter
def a_colorh4_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colorh4_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_colorh4_ninf)
data_view.set(value)
@property
def a_colorh4_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh4_snan)
return data_view.get()
@a_colorh4_snan.setter
def a_colorh4_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_colorh4_snan)
data_view = og.AttributeValueHelper(self._attributes.a_colorh4_snan)
data_view.set(value)
@property
def a_double2_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_double2_array_inf)
return data_view.get()
@a_double2_array_inf.setter
def a_double2_array_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_double2_array_inf)
data_view = og.AttributeValueHelper(self._attributes.a_double2_array_inf)
data_view.set(value)
self.a_double2_array_inf_size = data_view.get_array_size()
@property
def a_double2_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_double2_array_nan)
return data_view.get()
@a_double2_array_nan.setter
def a_double2_array_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_double2_array_nan)
data_view = og.AttributeValueHelper(self._attributes.a_double2_array_nan)
data_view.set(value)
self.a_double2_array_nan_size = data_view.get_array_size()
@property
def a_double2_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_double2_array_ninf)
return data_view.get()
@a_double2_array_ninf.setter
def a_double2_array_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_double2_array_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_double2_array_ninf)
data_view.set(value)
self.a_double2_array_ninf_size = data_view.get_array_size()
@property
def a_double2_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_double2_array_snan)
return data_view.get()
@a_double2_array_snan.setter
def a_double2_array_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_double2_array_snan)
data_view = og.AttributeValueHelper(self._attributes.a_double2_array_snan)
data_view.set(value)
self.a_double2_array_snan_size = data_view.get_array_size()
@property
def a_double2_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_double2_inf)
return data_view.get()
@a_double2_inf.setter
def a_double2_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_double2_inf)
data_view = og.AttributeValueHelper(self._attributes.a_double2_inf)
data_view.set(value)
@property
def a_double2_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_double2_nan)
return data_view.get()
@a_double2_nan.setter
def a_double2_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_double2_nan)
data_view = og.AttributeValueHelper(self._attributes.a_double2_nan)
data_view.set(value)
@property
def a_double2_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_double2_ninf)
return data_view.get()
@a_double2_ninf.setter
def a_double2_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_double2_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_double2_ninf)
data_view.set(value)
@property
def a_double2_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_double2_snan)
return data_view.get()
@a_double2_snan.setter
def a_double2_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_double2_snan)
data_view = og.AttributeValueHelper(self._attributes.a_double2_snan)
data_view.set(value)
@property
def a_double3_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_double3_array_inf)
return data_view.get()
@a_double3_array_inf.setter
def a_double3_array_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_double3_array_inf)
data_view = og.AttributeValueHelper(self._attributes.a_double3_array_inf)
data_view.set(value)
self.a_double3_array_inf_size = data_view.get_array_size()
@property
def a_double3_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_double3_array_nan)
return data_view.get()
@a_double3_array_nan.setter
def a_double3_array_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_double3_array_nan)
data_view = og.AttributeValueHelper(self._attributes.a_double3_array_nan)
data_view.set(value)
self.a_double3_array_nan_size = data_view.get_array_size()
@property
def a_double3_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_double3_array_ninf)
return data_view.get()
@a_double3_array_ninf.setter
def a_double3_array_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_double3_array_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_double3_array_ninf)
data_view.set(value)
self.a_double3_array_ninf_size = data_view.get_array_size()
@property
def a_double3_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_double3_array_snan)
return data_view.get()
@a_double3_array_snan.setter
def a_double3_array_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_double3_array_snan)
data_view = og.AttributeValueHelper(self._attributes.a_double3_array_snan)
data_view.set(value)
self.a_double3_array_snan_size = data_view.get_array_size()
@property
def a_double3_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_double3_inf)
return data_view.get()
@a_double3_inf.setter
def a_double3_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_double3_inf)
data_view = og.AttributeValueHelper(self._attributes.a_double3_inf)
data_view.set(value)
@property
def a_double3_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_double3_nan)
return data_view.get()
@a_double3_nan.setter
def a_double3_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_double3_nan)
data_view = og.AttributeValueHelper(self._attributes.a_double3_nan)
data_view.set(value)
@property
def a_double3_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_double3_ninf)
return data_view.get()
@a_double3_ninf.setter
def a_double3_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_double3_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_double3_ninf)
data_view.set(value)
@property
def a_double3_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_double3_snan)
return data_view.get()
@a_double3_snan.setter
def a_double3_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_double3_snan)
data_view = og.AttributeValueHelper(self._attributes.a_double3_snan)
data_view.set(value)
@property
def a_double4_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_double4_array_inf)
return data_view.get()
@a_double4_array_inf.setter
def a_double4_array_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_double4_array_inf)
data_view = og.AttributeValueHelper(self._attributes.a_double4_array_inf)
data_view.set(value)
self.a_double4_array_inf_size = data_view.get_array_size()
@property
def a_double4_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_double4_array_nan)
return data_view.get()
@a_double4_array_nan.setter
def a_double4_array_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_double4_array_nan)
data_view = og.AttributeValueHelper(self._attributes.a_double4_array_nan)
data_view.set(value)
self.a_double4_array_nan_size = data_view.get_array_size()
@property
def a_double4_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_double4_array_ninf)
return data_view.get()
@a_double4_array_ninf.setter
def a_double4_array_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_double4_array_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_double4_array_ninf)
data_view.set(value)
self.a_double4_array_ninf_size = data_view.get_array_size()
@property
def a_double4_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_double4_array_snan)
return data_view.get()
@a_double4_array_snan.setter
def a_double4_array_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_double4_array_snan)
data_view = og.AttributeValueHelper(self._attributes.a_double4_array_snan)
data_view.set(value)
self.a_double4_array_snan_size = data_view.get_array_size()
@property
def a_double4_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_double4_inf)
return data_view.get()
@a_double4_inf.setter
def a_double4_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_double4_inf)
data_view = og.AttributeValueHelper(self._attributes.a_double4_inf)
data_view.set(value)
@property
def a_double4_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_double4_nan)
return data_view.get()
@a_double4_nan.setter
def a_double4_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_double4_nan)
data_view = og.AttributeValueHelper(self._attributes.a_double4_nan)
data_view.set(value)
@property
def a_double4_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_double4_ninf)
return data_view.get()
@a_double4_ninf.setter
def a_double4_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_double4_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_double4_ninf)
data_view.set(value)
@property
def a_double4_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_double4_snan)
return data_view.get()
@a_double4_snan.setter
def a_double4_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_double4_snan)
data_view = og.AttributeValueHelper(self._attributes.a_double4_snan)
data_view.set(value)
@property
def a_double_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_double_array_inf)
return data_view.get()
@a_double_array_inf.setter
def a_double_array_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_double_array_inf)
data_view = og.AttributeValueHelper(self._attributes.a_double_array_inf)
data_view.set(value)
self.a_double_array_inf_size = data_view.get_array_size()
@property
def a_double_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_double_array_nan)
return data_view.get()
@a_double_array_nan.setter
def a_double_array_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_double_array_nan)
data_view = og.AttributeValueHelper(self._attributes.a_double_array_nan)
data_view.set(value)
self.a_double_array_nan_size = data_view.get_array_size()
@property
def a_double_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_double_array_ninf)
return data_view.get()
@a_double_array_ninf.setter
def a_double_array_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_double_array_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_double_array_ninf)
data_view.set(value)
self.a_double_array_ninf_size = data_view.get_array_size()
@property
def a_double_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_double_array_snan)
return data_view.get()
@a_double_array_snan.setter
def a_double_array_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_double_array_snan)
data_view = og.AttributeValueHelper(self._attributes.a_double_array_snan)
data_view.set(value)
self.a_double_array_snan_size = data_view.get_array_size()
@property
def a_double_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_double_inf)
return data_view.get()
@a_double_inf.setter
def a_double_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_double_inf)
data_view = og.AttributeValueHelper(self._attributes.a_double_inf)
data_view.set(value)
@property
def a_double_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_double_nan)
return data_view.get()
@a_double_nan.setter
def a_double_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_double_nan)
data_view = og.AttributeValueHelper(self._attributes.a_double_nan)
data_view.set(value)
@property
def a_double_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_double_ninf)
return data_view.get()
@a_double_ninf.setter
def a_double_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_double_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_double_ninf)
data_view.set(value)
@property
def a_double_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_double_snan)
return data_view.get()
@a_double_snan.setter
def a_double_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_double_snan)
data_view = og.AttributeValueHelper(self._attributes.a_double_snan)
data_view.set(value)
@property
def a_float2_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_float2_array_inf)
return data_view.get()
@a_float2_array_inf.setter
def a_float2_array_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_float2_array_inf)
data_view = og.AttributeValueHelper(self._attributes.a_float2_array_inf)
data_view.set(value)
self.a_float2_array_inf_size = data_view.get_array_size()
@property
def a_float2_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_float2_array_nan)
return data_view.get()
@a_float2_array_nan.setter
def a_float2_array_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_float2_array_nan)
data_view = og.AttributeValueHelper(self._attributes.a_float2_array_nan)
data_view.set(value)
self.a_float2_array_nan_size = data_view.get_array_size()
@property
def a_float2_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_float2_array_ninf)
return data_view.get()
@a_float2_array_ninf.setter
def a_float2_array_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_float2_array_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_float2_array_ninf)
data_view.set(value)
self.a_float2_array_ninf_size = data_view.get_array_size()
@property
def a_float2_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_float2_array_snan)
return data_view.get()
@a_float2_array_snan.setter
def a_float2_array_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_float2_array_snan)
data_view = og.AttributeValueHelper(self._attributes.a_float2_array_snan)
data_view.set(value)
self.a_float2_array_snan_size = data_view.get_array_size()
@property
def a_float2_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_float2_inf)
return data_view.get()
@a_float2_inf.setter
def a_float2_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_float2_inf)
data_view = og.AttributeValueHelper(self._attributes.a_float2_inf)
data_view.set(value)
@property
def a_float2_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_float2_nan)
return data_view.get()
@a_float2_nan.setter
def a_float2_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_float2_nan)
data_view = og.AttributeValueHelper(self._attributes.a_float2_nan)
data_view.set(value)
@property
def a_float2_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_float2_ninf)
return data_view.get()
@a_float2_ninf.setter
def a_float2_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_float2_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_float2_ninf)
data_view.set(value)
@property
def a_float2_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_float2_snan)
return data_view.get()
@a_float2_snan.setter
def a_float2_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_float2_snan)
data_view = og.AttributeValueHelper(self._attributes.a_float2_snan)
data_view.set(value)
@property
def a_float3_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_float3_array_inf)
return data_view.get()
@a_float3_array_inf.setter
def a_float3_array_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_float3_array_inf)
data_view = og.AttributeValueHelper(self._attributes.a_float3_array_inf)
data_view.set(value)
self.a_float3_array_inf_size = data_view.get_array_size()
@property
def a_float3_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_float3_array_nan)
return data_view.get()
@a_float3_array_nan.setter
def a_float3_array_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_float3_array_nan)
data_view = og.AttributeValueHelper(self._attributes.a_float3_array_nan)
data_view.set(value)
self.a_float3_array_nan_size = data_view.get_array_size()
@property
def a_float3_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_float3_array_ninf)
return data_view.get()
@a_float3_array_ninf.setter
def a_float3_array_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_float3_array_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_float3_array_ninf)
data_view.set(value)
self.a_float3_array_ninf_size = data_view.get_array_size()
@property
def a_float3_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_float3_array_snan)
return data_view.get()
@a_float3_array_snan.setter
def a_float3_array_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_float3_array_snan)
data_view = og.AttributeValueHelper(self._attributes.a_float3_array_snan)
data_view.set(value)
self.a_float3_array_snan_size = data_view.get_array_size()
@property
def a_float3_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_float3_inf)
return data_view.get()
@a_float3_inf.setter
def a_float3_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_float3_inf)
data_view = og.AttributeValueHelper(self._attributes.a_float3_inf)
data_view.set(value)
@property
def a_float3_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_float3_nan)
return data_view.get()
@a_float3_nan.setter
def a_float3_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_float3_nan)
data_view = og.AttributeValueHelper(self._attributes.a_float3_nan)
data_view.set(value)
@property
def a_float3_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_float3_ninf)
return data_view.get()
@a_float3_ninf.setter
def a_float3_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_float3_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_float3_ninf)
data_view.set(value)
@property
def a_float3_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_float3_snan)
return data_view.get()
@a_float3_snan.setter
def a_float3_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_float3_snan)
data_view = og.AttributeValueHelper(self._attributes.a_float3_snan)
data_view.set(value)
@property
def a_float4_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_float4_array_inf)
return data_view.get()
@a_float4_array_inf.setter
def a_float4_array_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_float4_array_inf)
data_view = og.AttributeValueHelper(self._attributes.a_float4_array_inf)
data_view.set(value)
self.a_float4_array_inf_size = data_view.get_array_size()
@property
def a_float4_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_float4_array_nan)
return data_view.get()
@a_float4_array_nan.setter
def a_float4_array_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_float4_array_nan)
data_view = og.AttributeValueHelper(self._attributes.a_float4_array_nan)
data_view.set(value)
self.a_float4_array_nan_size = data_view.get_array_size()
@property
def a_float4_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_float4_array_ninf)
return data_view.get()
@a_float4_array_ninf.setter
def a_float4_array_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_float4_array_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_float4_array_ninf)
data_view.set(value)
self.a_float4_array_ninf_size = data_view.get_array_size()
@property
def a_float4_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_float4_array_snan)
return data_view.get()
@a_float4_array_snan.setter
def a_float4_array_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_float4_array_snan)
data_view = og.AttributeValueHelper(self._attributes.a_float4_array_snan)
data_view.set(value)
self.a_float4_array_snan_size = data_view.get_array_size()
@property
def a_float4_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_float4_inf)
return data_view.get()
@a_float4_inf.setter
def a_float4_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_float4_inf)
data_view = og.AttributeValueHelper(self._attributes.a_float4_inf)
data_view.set(value)
@property
def a_float4_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_float4_nan)
return data_view.get()
@a_float4_nan.setter
def a_float4_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_float4_nan)
data_view = og.AttributeValueHelper(self._attributes.a_float4_nan)
data_view.set(value)
@property
def a_float4_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_float4_ninf)
return data_view.get()
@a_float4_ninf.setter
def a_float4_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_float4_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_float4_ninf)
data_view.set(value)
@property
def a_float4_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_float4_snan)
return data_view.get()
@a_float4_snan.setter
def a_float4_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_float4_snan)
data_view = og.AttributeValueHelper(self._attributes.a_float4_snan)
data_view.set(value)
@property
def a_float_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_float_array_inf)
return data_view.get()
@a_float_array_inf.setter
def a_float_array_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_float_array_inf)
data_view = og.AttributeValueHelper(self._attributes.a_float_array_inf)
data_view.set(value)
self.a_float_array_inf_size = data_view.get_array_size()
@property
def a_float_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_float_array_nan)
return data_view.get()
@a_float_array_nan.setter
def a_float_array_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_float_array_nan)
data_view = og.AttributeValueHelper(self._attributes.a_float_array_nan)
data_view.set(value)
self.a_float_array_nan_size = data_view.get_array_size()
@property
def a_float_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_float_array_ninf)
return data_view.get()
@a_float_array_ninf.setter
def a_float_array_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_float_array_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_float_array_ninf)
data_view.set(value)
self.a_float_array_ninf_size = data_view.get_array_size()
@property
def a_float_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_float_array_snan)
return data_view.get()
@a_float_array_snan.setter
def a_float_array_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_float_array_snan)
data_view = og.AttributeValueHelper(self._attributes.a_float_array_snan)
data_view.set(value)
self.a_float_array_snan_size = data_view.get_array_size()
@property
def a_float_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_float_inf)
return data_view.get()
@a_float_inf.setter
def a_float_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_float_inf)
data_view = og.AttributeValueHelper(self._attributes.a_float_inf)
data_view.set(value)
@property
def a_float_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_float_nan)
return data_view.get()
@a_float_nan.setter
def a_float_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_float_nan)
data_view = og.AttributeValueHelper(self._attributes.a_float_nan)
data_view.set(value)
@property
def a_float_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_float_ninf)
return data_view.get()
@a_float_ninf.setter
def a_float_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_float_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_float_ninf)
data_view.set(value)
@property
def a_float_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_float_snan)
return data_view.get()
@a_float_snan.setter
def a_float_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_float_snan)
data_view = og.AttributeValueHelper(self._attributes.a_float_snan)
data_view.set(value)
@property
def a_frame4_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_frame4_array_inf)
return data_view.get()
@a_frame4_array_inf.setter
def a_frame4_array_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_frame4_array_inf)
data_view = og.AttributeValueHelper(self._attributes.a_frame4_array_inf)
data_view.set(value)
self.a_frame4_array_inf_size = data_view.get_array_size()
@property
def a_frame4_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_frame4_array_nan)
return data_view.get()
@a_frame4_array_nan.setter
def a_frame4_array_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_frame4_array_nan)
data_view = og.AttributeValueHelper(self._attributes.a_frame4_array_nan)
data_view.set(value)
self.a_frame4_array_nan_size = data_view.get_array_size()
@property
def a_frame4_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_frame4_array_ninf)
return data_view.get()
@a_frame4_array_ninf.setter
def a_frame4_array_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_frame4_array_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_frame4_array_ninf)
data_view.set(value)
self.a_frame4_array_ninf_size = data_view.get_array_size()
@property
def a_frame4_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_frame4_array_snan)
return data_view.get()
@a_frame4_array_snan.setter
def a_frame4_array_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_frame4_array_snan)
data_view = og.AttributeValueHelper(self._attributes.a_frame4_array_snan)
data_view.set(value)
self.a_frame4_array_snan_size = data_view.get_array_size()
@property
def a_frame4_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_frame4_inf)
return data_view.get()
@a_frame4_inf.setter
def a_frame4_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_frame4_inf)
data_view = og.AttributeValueHelper(self._attributes.a_frame4_inf)
data_view.set(value)
@property
def a_frame4_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_frame4_nan)
return data_view.get()
@a_frame4_nan.setter
def a_frame4_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_frame4_nan)
data_view = og.AttributeValueHelper(self._attributes.a_frame4_nan)
data_view.set(value)
@property
def a_frame4_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_frame4_ninf)
return data_view.get()
@a_frame4_ninf.setter
def a_frame4_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_frame4_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_frame4_ninf)
data_view.set(value)
@property
def a_frame4_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_frame4_snan)
return data_view.get()
@a_frame4_snan.setter
def a_frame4_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_frame4_snan)
data_view = og.AttributeValueHelper(self._attributes.a_frame4_snan)
data_view.set(value)
@property
def a_half2_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_half2_array_inf)
return data_view.get()
@a_half2_array_inf.setter
def a_half2_array_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_half2_array_inf)
data_view = og.AttributeValueHelper(self._attributes.a_half2_array_inf)
data_view.set(value)
self.a_half2_array_inf_size = data_view.get_array_size()
@property
def a_half2_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_half2_array_nan)
return data_view.get()
@a_half2_array_nan.setter
def a_half2_array_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_half2_array_nan)
data_view = og.AttributeValueHelper(self._attributes.a_half2_array_nan)
data_view.set(value)
self.a_half2_array_nan_size = data_view.get_array_size()
@property
def a_half2_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_half2_array_ninf)
return data_view.get()
@a_half2_array_ninf.setter
def a_half2_array_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_half2_array_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_half2_array_ninf)
data_view.set(value)
self.a_half2_array_ninf_size = data_view.get_array_size()
@property
def a_half2_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_half2_array_snan)
return data_view.get()
@a_half2_array_snan.setter
def a_half2_array_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_half2_array_snan)
data_view = og.AttributeValueHelper(self._attributes.a_half2_array_snan)
data_view.set(value)
self.a_half2_array_snan_size = data_view.get_array_size()
@property
def a_half2_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_half2_inf)
return data_view.get()
@a_half2_inf.setter
def a_half2_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_half2_inf)
data_view = og.AttributeValueHelper(self._attributes.a_half2_inf)
data_view.set(value)
@property
def a_half2_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_half2_nan)
return data_view.get()
@a_half2_nan.setter
def a_half2_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_half2_nan)
data_view = og.AttributeValueHelper(self._attributes.a_half2_nan)
data_view.set(value)
@property
def a_half2_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_half2_ninf)
return data_view.get()
@a_half2_ninf.setter
def a_half2_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_half2_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_half2_ninf)
data_view.set(value)
@property
def a_half2_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_half2_snan)
return data_view.get()
@a_half2_snan.setter
def a_half2_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_half2_snan)
data_view = og.AttributeValueHelper(self._attributes.a_half2_snan)
data_view.set(value)
@property
def a_half3_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_half3_array_inf)
return data_view.get()
@a_half3_array_inf.setter
def a_half3_array_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_half3_array_inf)
data_view = og.AttributeValueHelper(self._attributes.a_half3_array_inf)
data_view.set(value)
self.a_half3_array_inf_size = data_view.get_array_size()
@property
def a_half3_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_half3_array_nan)
return data_view.get()
@a_half3_array_nan.setter
def a_half3_array_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_half3_array_nan)
data_view = og.AttributeValueHelper(self._attributes.a_half3_array_nan)
data_view.set(value)
self.a_half3_array_nan_size = data_view.get_array_size()
@property
def a_half3_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_half3_array_ninf)
return data_view.get()
@a_half3_array_ninf.setter
def a_half3_array_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_half3_array_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_half3_array_ninf)
data_view.set(value)
self.a_half3_array_ninf_size = data_view.get_array_size()
@property
def a_half3_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_half3_array_snan)
return data_view.get()
@a_half3_array_snan.setter
def a_half3_array_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_half3_array_snan)
data_view = og.AttributeValueHelper(self._attributes.a_half3_array_snan)
data_view.set(value)
self.a_half3_array_snan_size = data_view.get_array_size()
@property
def a_half3_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_half3_inf)
return data_view.get()
@a_half3_inf.setter
def a_half3_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_half3_inf)
data_view = og.AttributeValueHelper(self._attributes.a_half3_inf)
data_view.set(value)
@property
def a_half3_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_half3_nan)
return data_view.get()
@a_half3_nan.setter
def a_half3_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_half3_nan)
data_view = og.AttributeValueHelper(self._attributes.a_half3_nan)
data_view.set(value)
@property
def a_half3_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_half3_ninf)
return data_view.get()
@a_half3_ninf.setter
def a_half3_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_half3_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_half3_ninf)
data_view.set(value)
@property
def a_half3_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_half3_snan)
return data_view.get()
@a_half3_snan.setter
def a_half3_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_half3_snan)
data_view = og.AttributeValueHelper(self._attributes.a_half3_snan)
data_view.set(value)
@property
def a_half4_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_half4_array_inf)
return data_view.get()
@a_half4_array_inf.setter
def a_half4_array_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_half4_array_inf)
data_view = og.AttributeValueHelper(self._attributes.a_half4_array_inf)
data_view.set(value)
self.a_half4_array_inf_size = data_view.get_array_size()
@property
def a_half4_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_half4_array_nan)
return data_view.get()
@a_half4_array_nan.setter
def a_half4_array_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_half4_array_nan)
data_view = og.AttributeValueHelper(self._attributes.a_half4_array_nan)
data_view.set(value)
self.a_half4_array_nan_size = data_view.get_array_size()
@property
def a_half4_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_half4_array_ninf)
return data_view.get()
@a_half4_array_ninf.setter
def a_half4_array_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_half4_array_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_half4_array_ninf)
data_view.set(value)
self.a_half4_array_ninf_size = data_view.get_array_size()
@property
def a_half4_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_half4_array_snan)
return data_view.get()
@a_half4_array_snan.setter
def a_half4_array_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_half4_array_snan)
data_view = og.AttributeValueHelper(self._attributes.a_half4_array_snan)
data_view.set(value)
self.a_half4_array_snan_size = data_view.get_array_size()
@property
def a_half4_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_half4_inf)
return data_view.get()
@a_half4_inf.setter
def a_half4_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_half4_inf)
data_view = og.AttributeValueHelper(self._attributes.a_half4_inf)
data_view.set(value)
@property
def a_half4_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_half4_nan)
return data_view.get()
@a_half4_nan.setter
def a_half4_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_half4_nan)
data_view = og.AttributeValueHelper(self._attributes.a_half4_nan)
data_view.set(value)
@property
def a_half4_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_half4_ninf)
return data_view.get()
@a_half4_ninf.setter
def a_half4_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_half4_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_half4_ninf)
data_view.set(value)
@property
def a_half4_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_half4_snan)
return data_view.get()
@a_half4_snan.setter
def a_half4_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_half4_snan)
data_view = og.AttributeValueHelper(self._attributes.a_half4_snan)
data_view.set(value)
@property
def a_half_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_half_array_inf)
return data_view.get()
@a_half_array_inf.setter
def a_half_array_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_half_array_inf)
data_view = og.AttributeValueHelper(self._attributes.a_half_array_inf)
data_view.set(value)
self.a_half_array_inf_size = data_view.get_array_size()
@property
def a_half_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_half_array_nan)
return data_view.get()
@a_half_array_nan.setter
def a_half_array_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_half_array_nan)
data_view = og.AttributeValueHelper(self._attributes.a_half_array_nan)
data_view.set(value)
self.a_half_array_nan_size = data_view.get_array_size()
@property
def a_half_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_half_array_ninf)
return data_view.get()
@a_half_array_ninf.setter
def a_half_array_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_half_array_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_half_array_ninf)
data_view.set(value)
self.a_half_array_ninf_size = data_view.get_array_size()
@property
def a_half_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_half_array_snan)
return data_view.get()
@a_half_array_snan.setter
def a_half_array_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_half_array_snan)
data_view = og.AttributeValueHelper(self._attributes.a_half_array_snan)
data_view.set(value)
self.a_half_array_snan_size = data_view.get_array_size()
@property
def a_half_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_half_inf)
return data_view.get()
@a_half_inf.setter
def a_half_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_half_inf)
data_view = og.AttributeValueHelper(self._attributes.a_half_inf)
data_view.set(value)
@property
def a_half_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_half_nan)
return data_view.get()
@a_half_nan.setter
def a_half_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_half_nan)
data_view = og.AttributeValueHelper(self._attributes.a_half_nan)
data_view.set(value)
@property
def a_half_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_half_ninf)
return data_view.get()
@a_half_ninf.setter
def a_half_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_half_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_half_ninf)
data_view.set(value)
@property
def a_half_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_half_snan)
return data_view.get()
@a_half_snan.setter
def a_half_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_half_snan)
data_view = og.AttributeValueHelper(self._attributes.a_half_snan)
data_view.set(value)
@property
def a_matrixd2_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd2_array_inf)
return data_view.get()
@a_matrixd2_array_inf.setter
def a_matrixd2_array_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_matrixd2_array_inf)
data_view = og.AttributeValueHelper(self._attributes.a_matrixd2_array_inf)
data_view.set(value)
self.a_matrixd2_array_inf_size = data_view.get_array_size()
@property
def a_matrixd2_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd2_array_nan)
return data_view.get()
@a_matrixd2_array_nan.setter
def a_matrixd2_array_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_matrixd2_array_nan)
data_view = og.AttributeValueHelper(self._attributes.a_matrixd2_array_nan)
data_view.set(value)
self.a_matrixd2_array_nan_size = data_view.get_array_size()
@property
def a_matrixd2_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd2_array_ninf)
return data_view.get()
@a_matrixd2_array_ninf.setter
def a_matrixd2_array_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_matrixd2_array_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_matrixd2_array_ninf)
data_view.set(value)
self.a_matrixd2_array_ninf_size = data_view.get_array_size()
@property
def a_matrixd2_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd2_array_snan)
return data_view.get()
@a_matrixd2_array_snan.setter
def a_matrixd2_array_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_matrixd2_array_snan)
data_view = og.AttributeValueHelper(self._attributes.a_matrixd2_array_snan)
data_view.set(value)
self.a_matrixd2_array_snan_size = data_view.get_array_size()
@property
def a_matrixd2_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd2_inf)
return data_view.get()
@a_matrixd2_inf.setter
def a_matrixd2_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_matrixd2_inf)
data_view = og.AttributeValueHelper(self._attributes.a_matrixd2_inf)
data_view.set(value)
@property
def a_matrixd2_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd2_nan)
return data_view.get()
@a_matrixd2_nan.setter
def a_matrixd2_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_matrixd2_nan)
data_view = og.AttributeValueHelper(self._attributes.a_matrixd2_nan)
data_view.set(value)
@property
def a_matrixd2_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd2_ninf)
return data_view.get()
@a_matrixd2_ninf.setter
def a_matrixd2_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_matrixd2_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_matrixd2_ninf)
data_view.set(value)
@property
def a_matrixd2_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd2_snan)
return data_view.get()
@a_matrixd2_snan.setter
def a_matrixd2_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_matrixd2_snan)
data_view = og.AttributeValueHelper(self._attributes.a_matrixd2_snan)
data_view.set(value)
@property
def a_matrixd3_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd3_array_inf)
return data_view.get()
@a_matrixd3_array_inf.setter
def a_matrixd3_array_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_matrixd3_array_inf)
data_view = og.AttributeValueHelper(self._attributes.a_matrixd3_array_inf)
data_view.set(value)
self.a_matrixd3_array_inf_size = data_view.get_array_size()
@property
def a_matrixd3_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd3_array_nan)
return data_view.get()
@a_matrixd3_array_nan.setter
def a_matrixd3_array_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_matrixd3_array_nan)
data_view = og.AttributeValueHelper(self._attributes.a_matrixd3_array_nan)
data_view.set(value)
self.a_matrixd3_array_nan_size = data_view.get_array_size()
@property
def a_matrixd3_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd3_array_ninf)
return data_view.get()
@a_matrixd3_array_ninf.setter
def a_matrixd3_array_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_matrixd3_array_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_matrixd3_array_ninf)
data_view.set(value)
self.a_matrixd3_array_ninf_size = data_view.get_array_size()
@property
def a_matrixd3_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd3_array_snan)
return data_view.get()
@a_matrixd3_array_snan.setter
def a_matrixd3_array_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_matrixd3_array_snan)
data_view = og.AttributeValueHelper(self._attributes.a_matrixd3_array_snan)
data_view.set(value)
self.a_matrixd3_array_snan_size = data_view.get_array_size()
@property
def a_matrixd3_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd3_inf)
return data_view.get()
@a_matrixd3_inf.setter
def a_matrixd3_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_matrixd3_inf)
data_view = og.AttributeValueHelper(self._attributes.a_matrixd3_inf)
data_view.set(value)
@property
def a_matrixd3_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd3_nan)
return data_view.get()
@a_matrixd3_nan.setter
def a_matrixd3_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_matrixd3_nan)
data_view = og.AttributeValueHelper(self._attributes.a_matrixd3_nan)
data_view.set(value)
@property
def a_matrixd3_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd3_ninf)
return data_view.get()
@a_matrixd3_ninf.setter
def a_matrixd3_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_matrixd3_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_matrixd3_ninf)
data_view.set(value)
@property
def a_matrixd3_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd3_snan)
return data_view.get()
@a_matrixd3_snan.setter
def a_matrixd3_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_matrixd3_snan)
data_view = og.AttributeValueHelper(self._attributes.a_matrixd3_snan)
data_view.set(value)
@property
def a_matrixd4_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd4_array_inf)
return data_view.get()
@a_matrixd4_array_inf.setter
def a_matrixd4_array_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_matrixd4_array_inf)
data_view = og.AttributeValueHelper(self._attributes.a_matrixd4_array_inf)
data_view.set(value)
self.a_matrixd4_array_inf_size = data_view.get_array_size()
@property
def a_matrixd4_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd4_array_nan)
return data_view.get()
@a_matrixd4_array_nan.setter
def a_matrixd4_array_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_matrixd4_array_nan)
data_view = og.AttributeValueHelper(self._attributes.a_matrixd4_array_nan)
data_view.set(value)
self.a_matrixd4_array_nan_size = data_view.get_array_size()
@property
def a_matrixd4_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd4_array_ninf)
return data_view.get()
@a_matrixd4_array_ninf.setter
def a_matrixd4_array_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_matrixd4_array_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_matrixd4_array_ninf)
data_view.set(value)
self.a_matrixd4_array_ninf_size = data_view.get_array_size()
@property
def a_matrixd4_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd4_array_snan)
return data_view.get()
@a_matrixd4_array_snan.setter
def a_matrixd4_array_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_matrixd4_array_snan)
data_view = og.AttributeValueHelper(self._attributes.a_matrixd4_array_snan)
data_view.set(value)
self.a_matrixd4_array_snan_size = data_view.get_array_size()
@property
def a_matrixd4_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd4_inf)
return data_view.get()
@a_matrixd4_inf.setter
def a_matrixd4_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_matrixd4_inf)
data_view = og.AttributeValueHelper(self._attributes.a_matrixd4_inf)
data_view.set(value)
@property
def a_matrixd4_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd4_nan)
return data_view.get()
@a_matrixd4_nan.setter
def a_matrixd4_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_matrixd4_nan)
data_view = og.AttributeValueHelper(self._attributes.a_matrixd4_nan)
data_view.set(value)
@property
def a_matrixd4_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd4_ninf)
return data_view.get()
@a_matrixd4_ninf.setter
def a_matrixd4_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_matrixd4_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_matrixd4_ninf)
data_view.set(value)
@property
def a_matrixd4_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd4_snan)
return data_view.get()
@a_matrixd4_snan.setter
def a_matrixd4_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_matrixd4_snan)
data_view = og.AttributeValueHelper(self._attributes.a_matrixd4_snan)
data_view.set(value)
@property
def a_normald3_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_normald3_array_inf)
return data_view.get()
@a_normald3_array_inf.setter
def a_normald3_array_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_normald3_array_inf)
data_view = og.AttributeValueHelper(self._attributes.a_normald3_array_inf)
data_view.set(value)
self.a_normald3_array_inf_size = data_view.get_array_size()
@property
def a_normald3_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_normald3_array_nan)
return data_view.get()
@a_normald3_array_nan.setter
def a_normald3_array_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_normald3_array_nan)
data_view = og.AttributeValueHelper(self._attributes.a_normald3_array_nan)
data_view.set(value)
self.a_normald3_array_nan_size = data_view.get_array_size()
@property
def a_normald3_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_normald3_array_ninf)
return data_view.get()
@a_normald3_array_ninf.setter
def a_normald3_array_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_normald3_array_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_normald3_array_ninf)
data_view.set(value)
self.a_normald3_array_ninf_size = data_view.get_array_size()
@property
def a_normald3_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_normald3_array_snan)
return data_view.get()
@a_normald3_array_snan.setter
def a_normald3_array_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_normald3_array_snan)
data_view = og.AttributeValueHelper(self._attributes.a_normald3_array_snan)
data_view.set(value)
self.a_normald3_array_snan_size = data_view.get_array_size()
@property
def a_normald3_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_normald3_inf)
return data_view.get()
@a_normald3_inf.setter
def a_normald3_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_normald3_inf)
data_view = og.AttributeValueHelper(self._attributes.a_normald3_inf)
data_view.set(value)
@property
def a_normald3_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_normald3_nan)
return data_view.get()
@a_normald3_nan.setter
def a_normald3_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_normald3_nan)
data_view = og.AttributeValueHelper(self._attributes.a_normald3_nan)
data_view.set(value)
@property
def a_normald3_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_normald3_ninf)
return data_view.get()
@a_normald3_ninf.setter
def a_normald3_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_normald3_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_normald3_ninf)
data_view.set(value)
@property
def a_normald3_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_normald3_snan)
return data_view.get()
@a_normald3_snan.setter
def a_normald3_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_normald3_snan)
data_view = og.AttributeValueHelper(self._attributes.a_normald3_snan)
data_view.set(value)
@property
def a_normalf3_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalf3_array_inf)
return data_view.get()
@a_normalf3_array_inf.setter
def a_normalf3_array_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_normalf3_array_inf)
data_view = og.AttributeValueHelper(self._attributes.a_normalf3_array_inf)
data_view.set(value)
self.a_normalf3_array_inf_size = data_view.get_array_size()
@property
def a_normalf3_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalf3_array_nan)
return data_view.get()
@a_normalf3_array_nan.setter
def a_normalf3_array_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_normalf3_array_nan)
data_view = og.AttributeValueHelper(self._attributes.a_normalf3_array_nan)
data_view.set(value)
self.a_normalf3_array_nan_size = data_view.get_array_size()
@property
def a_normalf3_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalf3_array_ninf)
return data_view.get()
@a_normalf3_array_ninf.setter
def a_normalf3_array_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_normalf3_array_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_normalf3_array_ninf)
data_view.set(value)
self.a_normalf3_array_ninf_size = data_view.get_array_size()
@property
def a_normalf3_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalf3_array_snan)
return data_view.get()
@a_normalf3_array_snan.setter
def a_normalf3_array_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_normalf3_array_snan)
data_view = og.AttributeValueHelper(self._attributes.a_normalf3_array_snan)
data_view.set(value)
self.a_normalf3_array_snan_size = data_view.get_array_size()
@property
def a_normalf3_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalf3_inf)
return data_view.get()
@a_normalf3_inf.setter
def a_normalf3_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_normalf3_inf)
data_view = og.AttributeValueHelper(self._attributes.a_normalf3_inf)
data_view.set(value)
@property
def a_normalf3_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalf3_nan)
return data_view.get()
@a_normalf3_nan.setter
def a_normalf3_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_normalf3_nan)
data_view = og.AttributeValueHelper(self._attributes.a_normalf3_nan)
data_view.set(value)
@property
def a_normalf3_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalf3_ninf)
return data_view.get()
@a_normalf3_ninf.setter
def a_normalf3_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_normalf3_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_normalf3_ninf)
data_view.set(value)
@property
def a_normalf3_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalf3_snan)
return data_view.get()
@a_normalf3_snan.setter
def a_normalf3_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_normalf3_snan)
data_view = og.AttributeValueHelper(self._attributes.a_normalf3_snan)
data_view.set(value)
@property
def a_normalh3_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalh3_array_inf)
return data_view.get()
@a_normalh3_array_inf.setter
def a_normalh3_array_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_normalh3_array_inf)
data_view = og.AttributeValueHelper(self._attributes.a_normalh3_array_inf)
data_view.set(value)
self.a_normalh3_array_inf_size = data_view.get_array_size()
@property
def a_normalh3_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalh3_array_nan)
return data_view.get()
@a_normalh3_array_nan.setter
def a_normalh3_array_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_normalh3_array_nan)
data_view = og.AttributeValueHelper(self._attributes.a_normalh3_array_nan)
data_view.set(value)
self.a_normalh3_array_nan_size = data_view.get_array_size()
@property
def a_normalh3_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalh3_array_ninf)
return data_view.get()
@a_normalh3_array_ninf.setter
def a_normalh3_array_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_normalh3_array_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_normalh3_array_ninf)
data_view.set(value)
self.a_normalh3_array_ninf_size = data_view.get_array_size()
@property
def a_normalh3_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalh3_array_snan)
return data_view.get()
@a_normalh3_array_snan.setter
def a_normalh3_array_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_normalh3_array_snan)
data_view = og.AttributeValueHelper(self._attributes.a_normalh3_array_snan)
data_view.set(value)
self.a_normalh3_array_snan_size = data_view.get_array_size()
@property
def a_normalh3_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalh3_inf)
return data_view.get()
@a_normalh3_inf.setter
def a_normalh3_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_normalh3_inf)
data_view = og.AttributeValueHelper(self._attributes.a_normalh3_inf)
data_view.set(value)
@property
def a_normalh3_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalh3_nan)
return data_view.get()
@a_normalh3_nan.setter
def a_normalh3_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_normalh3_nan)
data_view = og.AttributeValueHelper(self._attributes.a_normalh3_nan)
data_view.set(value)
@property
def a_normalh3_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalh3_ninf)
return data_view.get()
@a_normalh3_ninf.setter
def a_normalh3_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_normalh3_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_normalh3_ninf)
data_view.set(value)
@property
def a_normalh3_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalh3_snan)
return data_view.get()
@a_normalh3_snan.setter
def a_normalh3_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_normalh3_snan)
data_view = og.AttributeValueHelper(self._attributes.a_normalh3_snan)
data_view.set(value)
@property
def a_pointd3_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointd3_array_inf)
return data_view.get()
@a_pointd3_array_inf.setter
def a_pointd3_array_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_pointd3_array_inf)
data_view = og.AttributeValueHelper(self._attributes.a_pointd3_array_inf)
data_view.set(value)
self.a_pointd3_array_inf_size = data_view.get_array_size()
@property
def a_pointd3_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointd3_array_nan)
return data_view.get()
@a_pointd3_array_nan.setter
def a_pointd3_array_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_pointd3_array_nan)
data_view = og.AttributeValueHelper(self._attributes.a_pointd3_array_nan)
data_view.set(value)
self.a_pointd3_array_nan_size = data_view.get_array_size()
@property
def a_pointd3_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointd3_array_ninf)
return data_view.get()
@a_pointd3_array_ninf.setter
def a_pointd3_array_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_pointd3_array_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_pointd3_array_ninf)
data_view.set(value)
self.a_pointd3_array_ninf_size = data_view.get_array_size()
@property
def a_pointd3_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointd3_array_snan)
return data_view.get()
@a_pointd3_array_snan.setter
def a_pointd3_array_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_pointd3_array_snan)
data_view = og.AttributeValueHelper(self._attributes.a_pointd3_array_snan)
data_view.set(value)
self.a_pointd3_array_snan_size = data_view.get_array_size()
@property
def a_pointd3_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointd3_inf)
return data_view.get()
@a_pointd3_inf.setter
def a_pointd3_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_pointd3_inf)
data_view = og.AttributeValueHelper(self._attributes.a_pointd3_inf)
data_view.set(value)
@property
def a_pointd3_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointd3_nan)
return data_view.get()
@a_pointd3_nan.setter
def a_pointd3_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_pointd3_nan)
data_view = og.AttributeValueHelper(self._attributes.a_pointd3_nan)
data_view.set(value)
@property
def a_pointd3_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointd3_ninf)
return data_view.get()
@a_pointd3_ninf.setter
def a_pointd3_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_pointd3_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_pointd3_ninf)
data_view.set(value)
@property
def a_pointd3_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointd3_snan)
return data_view.get()
@a_pointd3_snan.setter
def a_pointd3_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_pointd3_snan)
data_view = og.AttributeValueHelper(self._attributes.a_pointd3_snan)
data_view.set(value)
@property
def a_pointf3_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointf3_array_inf)
return data_view.get()
@a_pointf3_array_inf.setter
def a_pointf3_array_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_pointf3_array_inf)
data_view = og.AttributeValueHelper(self._attributes.a_pointf3_array_inf)
data_view.set(value)
self.a_pointf3_array_inf_size = data_view.get_array_size()
@property
def a_pointf3_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointf3_array_nan)
return data_view.get()
@a_pointf3_array_nan.setter
def a_pointf3_array_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_pointf3_array_nan)
data_view = og.AttributeValueHelper(self._attributes.a_pointf3_array_nan)
data_view.set(value)
self.a_pointf3_array_nan_size = data_view.get_array_size()
@property
def a_pointf3_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointf3_array_ninf)
return data_view.get()
@a_pointf3_array_ninf.setter
def a_pointf3_array_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_pointf3_array_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_pointf3_array_ninf)
data_view.set(value)
self.a_pointf3_array_ninf_size = data_view.get_array_size()
@property
def a_pointf3_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointf3_array_snan)
return data_view.get()
@a_pointf3_array_snan.setter
def a_pointf3_array_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_pointf3_array_snan)
data_view = og.AttributeValueHelper(self._attributes.a_pointf3_array_snan)
data_view.set(value)
self.a_pointf3_array_snan_size = data_view.get_array_size()
@property
def a_pointf3_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointf3_inf)
return data_view.get()
@a_pointf3_inf.setter
def a_pointf3_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_pointf3_inf)
data_view = og.AttributeValueHelper(self._attributes.a_pointf3_inf)
data_view.set(value)
@property
def a_pointf3_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointf3_nan)
return data_view.get()
@a_pointf3_nan.setter
def a_pointf3_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_pointf3_nan)
data_view = og.AttributeValueHelper(self._attributes.a_pointf3_nan)
data_view.set(value)
@property
def a_pointf3_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointf3_ninf)
return data_view.get()
@a_pointf3_ninf.setter
def a_pointf3_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_pointf3_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_pointf3_ninf)
data_view.set(value)
@property
def a_pointf3_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointf3_snan)
return data_view.get()
@a_pointf3_snan.setter
def a_pointf3_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_pointf3_snan)
data_view = og.AttributeValueHelper(self._attributes.a_pointf3_snan)
data_view.set(value)
@property
def a_pointh3_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointh3_array_inf)
return data_view.get()
@a_pointh3_array_inf.setter
def a_pointh3_array_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_pointh3_array_inf)
data_view = og.AttributeValueHelper(self._attributes.a_pointh3_array_inf)
data_view.set(value)
self.a_pointh3_array_inf_size = data_view.get_array_size()
@property
def a_pointh3_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointh3_array_nan)
return data_view.get()
@a_pointh3_array_nan.setter
def a_pointh3_array_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_pointh3_array_nan)
data_view = og.AttributeValueHelper(self._attributes.a_pointh3_array_nan)
data_view.set(value)
self.a_pointh3_array_nan_size = data_view.get_array_size()
@property
def a_pointh3_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointh3_array_ninf)
return data_view.get()
@a_pointh3_array_ninf.setter
def a_pointh3_array_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_pointh3_array_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_pointh3_array_ninf)
data_view.set(value)
self.a_pointh3_array_ninf_size = data_view.get_array_size()
@property
def a_pointh3_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointh3_array_snan)
return data_view.get()
@a_pointh3_array_snan.setter
def a_pointh3_array_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_pointh3_array_snan)
data_view = og.AttributeValueHelper(self._attributes.a_pointh3_array_snan)
data_view.set(value)
self.a_pointh3_array_snan_size = data_view.get_array_size()
@property
def a_pointh3_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointh3_inf)
return data_view.get()
@a_pointh3_inf.setter
def a_pointh3_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_pointh3_inf)
data_view = og.AttributeValueHelper(self._attributes.a_pointh3_inf)
data_view.set(value)
@property
def a_pointh3_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointh3_nan)
return data_view.get()
@a_pointh3_nan.setter
def a_pointh3_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_pointh3_nan)
data_view = og.AttributeValueHelper(self._attributes.a_pointh3_nan)
data_view.set(value)
@property
def a_pointh3_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointh3_ninf)
return data_view.get()
@a_pointh3_ninf.setter
def a_pointh3_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_pointh3_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_pointh3_ninf)
data_view.set(value)
@property
def a_pointh3_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointh3_snan)
return data_view.get()
@a_pointh3_snan.setter
def a_pointh3_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_pointh3_snan)
data_view = og.AttributeValueHelper(self._attributes.a_pointh3_snan)
data_view.set(value)
@property
def a_quatd4_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatd4_array_inf)
return data_view.get()
@a_quatd4_array_inf.setter
def a_quatd4_array_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_quatd4_array_inf)
data_view = og.AttributeValueHelper(self._attributes.a_quatd4_array_inf)
data_view.set(value)
self.a_quatd4_array_inf_size = data_view.get_array_size()
@property
def a_quatd4_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatd4_array_nan)
return data_view.get()
@a_quatd4_array_nan.setter
def a_quatd4_array_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_quatd4_array_nan)
data_view = og.AttributeValueHelper(self._attributes.a_quatd4_array_nan)
data_view.set(value)
self.a_quatd4_array_nan_size = data_view.get_array_size()
@property
def a_quatd4_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatd4_array_ninf)
return data_view.get()
@a_quatd4_array_ninf.setter
def a_quatd4_array_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_quatd4_array_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_quatd4_array_ninf)
data_view.set(value)
self.a_quatd4_array_ninf_size = data_view.get_array_size()
@property
def a_quatd4_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatd4_array_snan)
return data_view.get()
@a_quatd4_array_snan.setter
def a_quatd4_array_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_quatd4_array_snan)
data_view = og.AttributeValueHelper(self._attributes.a_quatd4_array_snan)
data_view.set(value)
self.a_quatd4_array_snan_size = data_view.get_array_size()
@property
def a_quatd4_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatd4_inf)
return data_view.get()
@a_quatd4_inf.setter
def a_quatd4_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_quatd4_inf)
data_view = og.AttributeValueHelper(self._attributes.a_quatd4_inf)
data_view.set(value)
@property
def a_quatd4_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatd4_nan)
return data_view.get()
@a_quatd4_nan.setter
def a_quatd4_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_quatd4_nan)
data_view = og.AttributeValueHelper(self._attributes.a_quatd4_nan)
data_view.set(value)
@property
def a_quatd4_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatd4_ninf)
return data_view.get()
@a_quatd4_ninf.setter
def a_quatd4_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_quatd4_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_quatd4_ninf)
data_view.set(value)
@property
def a_quatd4_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatd4_snan)
return data_view.get()
@a_quatd4_snan.setter
def a_quatd4_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_quatd4_snan)
data_view = og.AttributeValueHelper(self._attributes.a_quatd4_snan)
data_view.set(value)
@property
def a_quatf4_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatf4_array_inf)
return data_view.get()
@a_quatf4_array_inf.setter
def a_quatf4_array_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_quatf4_array_inf)
data_view = og.AttributeValueHelper(self._attributes.a_quatf4_array_inf)
data_view.set(value)
self.a_quatf4_array_inf_size = data_view.get_array_size()
@property
def a_quatf4_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatf4_array_nan)
return data_view.get()
@a_quatf4_array_nan.setter
def a_quatf4_array_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_quatf4_array_nan)
data_view = og.AttributeValueHelper(self._attributes.a_quatf4_array_nan)
data_view.set(value)
self.a_quatf4_array_nan_size = data_view.get_array_size()
@property
def a_quatf4_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatf4_array_ninf)
return data_view.get()
@a_quatf4_array_ninf.setter
def a_quatf4_array_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_quatf4_array_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_quatf4_array_ninf)
data_view.set(value)
self.a_quatf4_array_ninf_size = data_view.get_array_size()
@property
def a_quatf4_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatf4_array_snan)
return data_view.get()
@a_quatf4_array_snan.setter
def a_quatf4_array_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_quatf4_array_snan)
data_view = og.AttributeValueHelper(self._attributes.a_quatf4_array_snan)
data_view.set(value)
self.a_quatf4_array_snan_size = data_view.get_array_size()
@property
def a_quatf4_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatf4_inf)
return data_view.get()
@a_quatf4_inf.setter
def a_quatf4_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_quatf4_inf)
data_view = og.AttributeValueHelper(self._attributes.a_quatf4_inf)
data_view.set(value)
@property
def a_quatf4_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatf4_nan)
return data_view.get()
@a_quatf4_nan.setter
def a_quatf4_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_quatf4_nan)
data_view = og.AttributeValueHelper(self._attributes.a_quatf4_nan)
data_view.set(value)
@property
def a_quatf4_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatf4_ninf)
return data_view.get()
@a_quatf4_ninf.setter
def a_quatf4_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_quatf4_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_quatf4_ninf)
data_view.set(value)
@property
def a_quatf4_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatf4_snan)
return data_view.get()
@a_quatf4_snan.setter
def a_quatf4_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_quatf4_snan)
data_view = og.AttributeValueHelper(self._attributes.a_quatf4_snan)
data_view.set(value)
@property
def a_quath4_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_quath4_array_inf)
return data_view.get()
@a_quath4_array_inf.setter
def a_quath4_array_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_quath4_array_inf)
data_view = og.AttributeValueHelper(self._attributes.a_quath4_array_inf)
data_view.set(value)
self.a_quath4_array_inf_size = data_view.get_array_size()
@property
def a_quath4_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_quath4_array_nan)
return data_view.get()
@a_quath4_array_nan.setter
def a_quath4_array_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_quath4_array_nan)
data_view = og.AttributeValueHelper(self._attributes.a_quath4_array_nan)
data_view.set(value)
self.a_quath4_array_nan_size = data_view.get_array_size()
@property
def a_quath4_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_quath4_array_ninf)
return data_view.get()
@a_quath4_array_ninf.setter
def a_quath4_array_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_quath4_array_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_quath4_array_ninf)
data_view.set(value)
self.a_quath4_array_ninf_size = data_view.get_array_size()
@property
def a_quath4_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_quath4_array_snan)
return data_view.get()
@a_quath4_array_snan.setter
def a_quath4_array_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_quath4_array_snan)
data_view = og.AttributeValueHelper(self._attributes.a_quath4_array_snan)
data_view.set(value)
self.a_quath4_array_snan_size = data_view.get_array_size()
@property
def a_quath4_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_quath4_inf)
return data_view.get()
@a_quath4_inf.setter
def a_quath4_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_quath4_inf)
data_view = og.AttributeValueHelper(self._attributes.a_quath4_inf)
data_view.set(value)
@property
def a_quath4_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_quath4_nan)
return data_view.get()
@a_quath4_nan.setter
def a_quath4_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_quath4_nan)
data_view = og.AttributeValueHelper(self._attributes.a_quath4_nan)
data_view.set(value)
@property
def a_quath4_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_quath4_ninf)
return data_view.get()
@a_quath4_ninf.setter
def a_quath4_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_quath4_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_quath4_ninf)
data_view.set(value)
@property
def a_quath4_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_quath4_snan)
return data_view.get()
@a_quath4_snan.setter
def a_quath4_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_quath4_snan)
data_view = og.AttributeValueHelper(self._attributes.a_quath4_snan)
data_view.set(value)
@property
def a_texcoordd2_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd2_array_inf)
return data_view.get()
@a_texcoordd2_array_inf.setter
def a_texcoordd2_array_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordd2_array_inf)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd2_array_inf)
data_view.set(value)
self.a_texcoordd2_array_inf_size = data_view.get_array_size()
@property
def a_texcoordd2_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd2_array_nan)
return data_view.get()
@a_texcoordd2_array_nan.setter
def a_texcoordd2_array_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordd2_array_nan)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd2_array_nan)
data_view.set(value)
self.a_texcoordd2_array_nan_size = data_view.get_array_size()
@property
def a_texcoordd2_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd2_array_ninf)
return data_view.get()
@a_texcoordd2_array_ninf.setter
def a_texcoordd2_array_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordd2_array_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd2_array_ninf)
data_view.set(value)
self.a_texcoordd2_array_ninf_size = data_view.get_array_size()
@property
def a_texcoordd2_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd2_array_snan)
return data_view.get()
@a_texcoordd2_array_snan.setter
def a_texcoordd2_array_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordd2_array_snan)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd2_array_snan)
data_view.set(value)
self.a_texcoordd2_array_snan_size = data_view.get_array_size()
@property
def a_texcoordd2_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd2_inf)
return data_view.get()
@a_texcoordd2_inf.setter
def a_texcoordd2_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordd2_inf)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd2_inf)
data_view.set(value)
@property
def a_texcoordd2_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd2_nan)
return data_view.get()
@a_texcoordd2_nan.setter
def a_texcoordd2_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordd2_nan)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd2_nan)
data_view.set(value)
@property
def a_texcoordd2_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd2_ninf)
return data_view.get()
@a_texcoordd2_ninf.setter
def a_texcoordd2_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordd2_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd2_ninf)
data_view.set(value)
@property
def a_texcoordd2_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd2_snan)
return data_view.get()
@a_texcoordd2_snan.setter
def a_texcoordd2_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordd2_snan)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd2_snan)
data_view.set(value)
@property
def a_texcoordd3_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd3_array_inf)
return data_view.get()
@a_texcoordd3_array_inf.setter
def a_texcoordd3_array_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordd3_array_inf)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd3_array_inf)
data_view.set(value)
self.a_texcoordd3_array_inf_size = data_view.get_array_size()
@property
def a_texcoordd3_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd3_array_nan)
return data_view.get()
@a_texcoordd3_array_nan.setter
def a_texcoordd3_array_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordd3_array_nan)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd3_array_nan)
data_view.set(value)
self.a_texcoordd3_array_nan_size = data_view.get_array_size()
@property
def a_texcoordd3_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd3_array_ninf)
return data_view.get()
@a_texcoordd3_array_ninf.setter
def a_texcoordd3_array_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordd3_array_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd3_array_ninf)
data_view.set(value)
self.a_texcoordd3_array_ninf_size = data_view.get_array_size()
@property
def a_texcoordd3_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd3_array_snan)
return data_view.get()
@a_texcoordd3_array_snan.setter
def a_texcoordd3_array_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordd3_array_snan)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd3_array_snan)
data_view.set(value)
self.a_texcoordd3_array_snan_size = data_view.get_array_size()
@property
def a_texcoordd3_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd3_inf)
return data_view.get()
@a_texcoordd3_inf.setter
def a_texcoordd3_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordd3_inf)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd3_inf)
data_view.set(value)
@property
def a_texcoordd3_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd3_nan)
return data_view.get()
@a_texcoordd3_nan.setter
def a_texcoordd3_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordd3_nan)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd3_nan)
data_view.set(value)
@property
def a_texcoordd3_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd3_ninf)
return data_view.get()
@a_texcoordd3_ninf.setter
def a_texcoordd3_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordd3_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd3_ninf)
data_view.set(value)
@property
def a_texcoordd3_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd3_snan)
return data_view.get()
@a_texcoordd3_snan.setter
def a_texcoordd3_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordd3_snan)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd3_snan)
data_view.set(value)
@property
def a_texcoordf2_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf2_array_inf)
return data_view.get()
@a_texcoordf2_array_inf.setter
def a_texcoordf2_array_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordf2_array_inf)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf2_array_inf)
data_view.set(value)
self.a_texcoordf2_array_inf_size = data_view.get_array_size()
@property
def a_texcoordf2_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf2_array_nan)
return data_view.get()
@a_texcoordf2_array_nan.setter
def a_texcoordf2_array_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordf2_array_nan)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf2_array_nan)
data_view.set(value)
self.a_texcoordf2_array_nan_size = data_view.get_array_size()
@property
def a_texcoordf2_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf2_array_ninf)
return data_view.get()
@a_texcoordf2_array_ninf.setter
def a_texcoordf2_array_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordf2_array_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf2_array_ninf)
data_view.set(value)
self.a_texcoordf2_array_ninf_size = data_view.get_array_size()
@property
def a_texcoordf2_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf2_array_snan)
return data_view.get()
@a_texcoordf2_array_snan.setter
def a_texcoordf2_array_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordf2_array_snan)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf2_array_snan)
data_view.set(value)
self.a_texcoordf2_array_snan_size = data_view.get_array_size()
@property
def a_texcoordf2_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf2_inf)
return data_view.get()
@a_texcoordf2_inf.setter
def a_texcoordf2_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordf2_inf)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf2_inf)
data_view.set(value)
@property
def a_texcoordf2_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf2_nan)
return data_view.get()
@a_texcoordf2_nan.setter
def a_texcoordf2_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordf2_nan)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf2_nan)
data_view.set(value)
@property
def a_texcoordf2_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf2_ninf)
return data_view.get()
@a_texcoordf2_ninf.setter
def a_texcoordf2_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordf2_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf2_ninf)
data_view.set(value)
@property
def a_texcoordf2_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf2_snan)
return data_view.get()
@a_texcoordf2_snan.setter
def a_texcoordf2_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordf2_snan)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf2_snan)
data_view.set(value)
@property
def a_texcoordf3_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf3_array_inf)
return data_view.get()
@a_texcoordf3_array_inf.setter
def a_texcoordf3_array_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordf3_array_inf)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf3_array_inf)
data_view.set(value)
self.a_texcoordf3_array_inf_size = data_view.get_array_size()
@property
def a_texcoordf3_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf3_array_nan)
return data_view.get()
@a_texcoordf3_array_nan.setter
def a_texcoordf3_array_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordf3_array_nan)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf3_array_nan)
data_view.set(value)
self.a_texcoordf3_array_nan_size = data_view.get_array_size()
@property
def a_texcoordf3_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf3_array_ninf)
return data_view.get()
@a_texcoordf3_array_ninf.setter
def a_texcoordf3_array_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordf3_array_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf3_array_ninf)
data_view.set(value)
self.a_texcoordf3_array_ninf_size = data_view.get_array_size()
@property
def a_texcoordf3_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf3_array_snan)
return data_view.get()
@a_texcoordf3_array_snan.setter
def a_texcoordf3_array_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordf3_array_snan)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf3_array_snan)
data_view.set(value)
self.a_texcoordf3_array_snan_size = data_view.get_array_size()
@property
def a_texcoordf3_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf3_inf)
return data_view.get()
@a_texcoordf3_inf.setter
def a_texcoordf3_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordf3_inf)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf3_inf)
data_view.set(value)
@property
def a_texcoordf3_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf3_nan)
return data_view.get()
@a_texcoordf3_nan.setter
def a_texcoordf3_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordf3_nan)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf3_nan)
data_view.set(value)
@property
def a_texcoordf3_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf3_ninf)
return data_view.get()
@a_texcoordf3_ninf.setter
def a_texcoordf3_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordf3_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf3_ninf)
data_view.set(value)
@property
def a_texcoordf3_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf3_snan)
return data_view.get()
@a_texcoordf3_snan.setter
def a_texcoordf3_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordf3_snan)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf3_snan)
data_view.set(value)
@property
def a_texcoordh2_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh2_array_inf)
return data_view.get()
@a_texcoordh2_array_inf.setter
def a_texcoordh2_array_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordh2_array_inf)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh2_array_inf)
data_view.set(value)
self.a_texcoordh2_array_inf_size = data_view.get_array_size()
@property
def a_texcoordh2_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh2_array_nan)
return data_view.get()
@a_texcoordh2_array_nan.setter
def a_texcoordh2_array_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordh2_array_nan)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh2_array_nan)
data_view.set(value)
self.a_texcoordh2_array_nan_size = data_view.get_array_size()
@property
def a_texcoordh2_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh2_array_ninf)
return data_view.get()
@a_texcoordh2_array_ninf.setter
def a_texcoordh2_array_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordh2_array_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh2_array_ninf)
data_view.set(value)
self.a_texcoordh2_array_ninf_size = data_view.get_array_size()
@property
def a_texcoordh2_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh2_array_snan)
return data_view.get()
@a_texcoordh2_array_snan.setter
def a_texcoordh2_array_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordh2_array_snan)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh2_array_snan)
data_view.set(value)
self.a_texcoordh2_array_snan_size = data_view.get_array_size()
@property
def a_texcoordh2_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh2_inf)
return data_view.get()
@a_texcoordh2_inf.setter
def a_texcoordh2_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordh2_inf)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh2_inf)
data_view.set(value)
@property
def a_texcoordh2_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh2_nan)
return data_view.get()
@a_texcoordh2_nan.setter
def a_texcoordh2_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordh2_nan)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh2_nan)
data_view.set(value)
@property
def a_texcoordh2_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh2_ninf)
return data_view.get()
@a_texcoordh2_ninf.setter
def a_texcoordh2_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordh2_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh2_ninf)
data_view.set(value)
@property
def a_texcoordh2_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh2_snan)
return data_view.get()
@a_texcoordh2_snan.setter
def a_texcoordh2_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordh2_snan)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh2_snan)
data_view.set(value)
@property
def a_texcoordh3_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh3_array_inf)
return data_view.get()
@a_texcoordh3_array_inf.setter
def a_texcoordh3_array_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordh3_array_inf)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh3_array_inf)
data_view.set(value)
self.a_texcoordh3_array_inf_size = data_view.get_array_size()
@property
def a_texcoordh3_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh3_array_nan)
return data_view.get()
@a_texcoordh3_array_nan.setter
def a_texcoordh3_array_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordh3_array_nan)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh3_array_nan)
data_view.set(value)
self.a_texcoordh3_array_nan_size = data_view.get_array_size()
@property
def a_texcoordh3_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh3_array_ninf)
return data_view.get()
@a_texcoordh3_array_ninf.setter
def a_texcoordh3_array_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordh3_array_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh3_array_ninf)
data_view.set(value)
self.a_texcoordh3_array_ninf_size = data_view.get_array_size()
@property
def a_texcoordh3_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh3_array_snan)
return data_view.get()
@a_texcoordh3_array_snan.setter
def a_texcoordh3_array_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordh3_array_snan)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh3_array_snan)
data_view.set(value)
self.a_texcoordh3_array_snan_size = data_view.get_array_size()
@property
def a_texcoordh3_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh3_inf)
return data_view.get()
@a_texcoordh3_inf.setter
def a_texcoordh3_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordh3_inf)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh3_inf)
data_view.set(value)
@property
def a_texcoordh3_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh3_nan)
return data_view.get()
@a_texcoordh3_nan.setter
def a_texcoordh3_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordh3_nan)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh3_nan)
data_view.set(value)
@property
def a_texcoordh3_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh3_ninf)
return data_view.get()
@a_texcoordh3_ninf.setter
def a_texcoordh3_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordh3_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh3_ninf)
data_view.set(value)
@property
def a_texcoordh3_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh3_snan)
return data_view.get()
@a_texcoordh3_snan.setter
def a_texcoordh3_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_texcoordh3_snan)
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh3_snan)
data_view.set(value)
@property
def a_timecode_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_timecode_array_inf)
return data_view.get()
@a_timecode_array_inf.setter
def a_timecode_array_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_timecode_array_inf)
data_view = og.AttributeValueHelper(self._attributes.a_timecode_array_inf)
data_view.set(value)
self.a_timecode_array_inf_size = data_view.get_array_size()
@property
def a_timecode_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_timecode_array_nan)
return data_view.get()
@a_timecode_array_nan.setter
def a_timecode_array_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_timecode_array_nan)
data_view = og.AttributeValueHelper(self._attributes.a_timecode_array_nan)
data_view.set(value)
self.a_timecode_array_nan_size = data_view.get_array_size()
@property
def a_timecode_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_timecode_array_ninf)
return data_view.get()
@a_timecode_array_ninf.setter
def a_timecode_array_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_timecode_array_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_timecode_array_ninf)
data_view.set(value)
self.a_timecode_array_ninf_size = data_view.get_array_size()
@property
def a_timecode_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_timecode_array_snan)
return data_view.get()
@a_timecode_array_snan.setter
def a_timecode_array_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_timecode_array_snan)
data_view = og.AttributeValueHelper(self._attributes.a_timecode_array_snan)
data_view.set(value)
self.a_timecode_array_snan_size = data_view.get_array_size()
@property
def a_timecode_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_timecode_inf)
return data_view.get()
@a_timecode_inf.setter
def a_timecode_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_timecode_inf)
data_view = og.AttributeValueHelper(self._attributes.a_timecode_inf)
data_view.set(value)
@property
def a_timecode_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_timecode_nan)
return data_view.get()
@a_timecode_nan.setter
def a_timecode_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_timecode_nan)
data_view = og.AttributeValueHelper(self._attributes.a_timecode_nan)
data_view.set(value)
@property
def a_timecode_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_timecode_ninf)
return data_view.get()
@a_timecode_ninf.setter
def a_timecode_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_timecode_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_timecode_ninf)
data_view.set(value)
@property
def a_timecode_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_timecode_snan)
return data_view.get()
@a_timecode_snan.setter
def a_timecode_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_timecode_snan)
data_view = og.AttributeValueHelper(self._attributes.a_timecode_snan)
data_view.set(value)
@property
def a_vectord3_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectord3_array_inf)
return data_view.get()
@a_vectord3_array_inf.setter
def a_vectord3_array_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_vectord3_array_inf)
data_view = og.AttributeValueHelper(self._attributes.a_vectord3_array_inf)
data_view.set(value)
self.a_vectord3_array_inf_size = data_view.get_array_size()
@property
def a_vectord3_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectord3_array_nan)
return data_view.get()
@a_vectord3_array_nan.setter
def a_vectord3_array_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_vectord3_array_nan)
data_view = og.AttributeValueHelper(self._attributes.a_vectord3_array_nan)
data_view.set(value)
self.a_vectord3_array_nan_size = data_view.get_array_size()
@property
def a_vectord3_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectord3_array_ninf)
return data_view.get()
@a_vectord3_array_ninf.setter
def a_vectord3_array_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_vectord3_array_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_vectord3_array_ninf)
data_view.set(value)
self.a_vectord3_array_ninf_size = data_view.get_array_size()
@property
def a_vectord3_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectord3_array_snan)
return data_view.get()
@a_vectord3_array_snan.setter
def a_vectord3_array_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_vectord3_array_snan)
data_view = og.AttributeValueHelper(self._attributes.a_vectord3_array_snan)
data_view.set(value)
self.a_vectord3_array_snan_size = data_view.get_array_size()
@property
def a_vectord3_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectord3_inf)
return data_view.get()
@a_vectord3_inf.setter
def a_vectord3_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_vectord3_inf)
data_view = og.AttributeValueHelper(self._attributes.a_vectord3_inf)
data_view.set(value)
@property
def a_vectord3_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectord3_nan)
return data_view.get()
@a_vectord3_nan.setter
def a_vectord3_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_vectord3_nan)
data_view = og.AttributeValueHelper(self._attributes.a_vectord3_nan)
data_view.set(value)
@property
def a_vectord3_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectord3_ninf)
return data_view.get()
@a_vectord3_ninf.setter
def a_vectord3_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_vectord3_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_vectord3_ninf)
data_view.set(value)
@property
def a_vectord3_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectord3_snan)
return data_view.get()
@a_vectord3_snan.setter
def a_vectord3_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_vectord3_snan)
data_view = og.AttributeValueHelper(self._attributes.a_vectord3_snan)
data_view.set(value)
@property
def a_vectorf3_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorf3_array_inf)
return data_view.get()
@a_vectorf3_array_inf.setter
def a_vectorf3_array_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_vectorf3_array_inf)
data_view = og.AttributeValueHelper(self._attributes.a_vectorf3_array_inf)
data_view.set(value)
self.a_vectorf3_array_inf_size = data_view.get_array_size()
@property
def a_vectorf3_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorf3_array_nan)
return data_view.get()
@a_vectorf3_array_nan.setter
def a_vectorf3_array_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_vectorf3_array_nan)
data_view = og.AttributeValueHelper(self._attributes.a_vectorf3_array_nan)
data_view.set(value)
self.a_vectorf3_array_nan_size = data_view.get_array_size()
@property
def a_vectorf3_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorf3_array_ninf)
return data_view.get()
@a_vectorf3_array_ninf.setter
def a_vectorf3_array_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_vectorf3_array_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_vectorf3_array_ninf)
data_view.set(value)
self.a_vectorf3_array_ninf_size = data_view.get_array_size()
@property
def a_vectorf3_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorf3_array_snan)
return data_view.get()
@a_vectorf3_array_snan.setter
def a_vectorf3_array_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_vectorf3_array_snan)
data_view = og.AttributeValueHelper(self._attributes.a_vectorf3_array_snan)
data_view.set(value)
self.a_vectorf3_array_snan_size = data_view.get_array_size()
@property
def a_vectorf3_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorf3_inf)
return data_view.get()
@a_vectorf3_inf.setter
def a_vectorf3_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_vectorf3_inf)
data_view = og.AttributeValueHelper(self._attributes.a_vectorf3_inf)
data_view.set(value)
@property
def a_vectorf3_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorf3_nan)
return data_view.get()
@a_vectorf3_nan.setter
def a_vectorf3_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_vectorf3_nan)
data_view = og.AttributeValueHelper(self._attributes.a_vectorf3_nan)
data_view.set(value)
@property
def a_vectorf3_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorf3_ninf)
return data_view.get()
@a_vectorf3_ninf.setter
def a_vectorf3_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_vectorf3_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_vectorf3_ninf)
data_view.set(value)
@property
def a_vectorf3_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorf3_snan)
return data_view.get()
@a_vectorf3_snan.setter
def a_vectorf3_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_vectorf3_snan)
data_view = og.AttributeValueHelper(self._attributes.a_vectorf3_snan)
data_view.set(value)
@property
def a_vectorh3_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorh3_array_inf)
return data_view.get()
@a_vectorh3_array_inf.setter
def a_vectorh3_array_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_vectorh3_array_inf)
data_view = og.AttributeValueHelper(self._attributes.a_vectorh3_array_inf)
data_view.set(value)
self.a_vectorh3_array_inf_size = data_view.get_array_size()
@property
def a_vectorh3_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorh3_array_nan)
return data_view.get()
@a_vectorh3_array_nan.setter
def a_vectorh3_array_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_vectorh3_array_nan)
data_view = og.AttributeValueHelper(self._attributes.a_vectorh3_array_nan)
data_view.set(value)
self.a_vectorh3_array_nan_size = data_view.get_array_size()
@property
def a_vectorh3_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorh3_array_ninf)
return data_view.get()
@a_vectorh3_array_ninf.setter
def a_vectorh3_array_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_vectorh3_array_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_vectorh3_array_ninf)
data_view.set(value)
self.a_vectorh3_array_ninf_size = data_view.get_array_size()
@property
def a_vectorh3_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorh3_array_snan)
return data_view.get()
@a_vectorh3_array_snan.setter
def a_vectorh3_array_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_vectorh3_array_snan)
data_view = og.AttributeValueHelper(self._attributes.a_vectorh3_array_snan)
data_view.set(value)
self.a_vectorh3_array_snan_size = data_view.get_array_size()
@property
def a_vectorh3_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorh3_inf)
return data_view.get()
@a_vectorh3_inf.setter
def a_vectorh3_inf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_vectorh3_inf)
data_view = og.AttributeValueHelper(self._attributes.a_vectorh3_inf)
data_view.set(value)
@property
def a_vectorh3_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorh3_nan)
return data_view.get()
@a_vectorh3_nan.setter
def a_vectorh3_nan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_vectorh3_nan)
data_view = og.AttributeValueHelper(self._attributes.a_vectorh3_nan)
data_view.set(value)
@property
def a_vectorh3_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorh3_ninf)
return data_view.get()
@a_vectorh3_ninf.setter
def a_vectorh3_ninf(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_vectorh3_ninf)
data_view = og.AttributeValueHelper(self._attributes.a_vectorh3_ninf)
data_view.set(value)
@property
def a_vectorh3_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorh3_snan)
return data_view.get()
@a_vectorh3_snan.setter
def a_vectorh3_snan(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.a_vectorh3_snan)
data_view = og.AttributeValueHelper(self._attributes.a_vectorh3_snan)
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.a_colord3_array_inf_size = None
self.a_colord3_array_nan_size = None
self.a_colord3_array_ninf_size = None
self.a_colord3_array_snan_size = None
self.a_colord4_array_inf_size = None
self.a_colord4_array_nan_size = None
self.a_colord4_array_ninf_size = None
self.a_colord4_array_snan_size = None
self.a_colorf3_array_inf_size = None
self.a_colorf3_array_nan_size = None
self.a_colorf3_array_ninf_size = None
self.a_colorf3_array_snan_size = None
self.a_colorf4_array_inf_size = None
self.a_colorf4_array_nan_size = None
self.a_colorf4_array_ninf_size = None
self.a_colorf4_array_snan_size = None
self.a_colorh3_array_inf_size = None
self.a_colorh3_array_nan_size = None
self.a_colorh3_array_ninf_size = None
self.a_colorh3_array_snan_size = None
self.a_colorh4_array_inf_size = None
self.a_colorh4_array_nan_size = None
self.a_colorh4_array_ninf_size = None
self.a_colorh4_array_snan_size = None
self.a_double2_array_inf_size = None
self.a_double2_array_nan_size = None
self.a_double2_array_ninf_size = None
self.a_double2_array_snan_size = None
self.a_double3_array_inf_size = None
self.a_double3_array_nan_size = None
self.a_double3_array_ninf_size = None
self.a_double3_array_snan_size = None
self.a_double4_array_inf_size = None
self.a_double4_array_nan_size = None
self.a_double4_array_ninf_size = None
self.a_double4_array_snan_size = None
self.a_double_array_inf_size = None
self.a_double_array_nan_size = None
self.a_double_array_ninf_size = None
self.a_double_array_snan_size = None
self.a_float2_array_inf_size = None
self.a_float2_array_nan_size = None
self.a_float2_array_ninf_size = None
self.a_float2_array_snan_size = None
self.a_float3_array_inf_size = None
self.a_float3_array_nan_size = None
self.a_float3_array_ninf_size = None
self.a_float3_array_snan_size = None
self.a_float4_array_inf_size = None
self.a_float4_array_nan_size = None
self.a_float4_array_ninf_size = None
self.a_float4_array_snan_size = None
self.a_float_array_inf_size = None
self.a_float_array_nan_size = None
self.a_float_array_ninf_size = None
self.a_float_array_snan_size = None
self.a_frame4_array_inf_size = None
self.a_frame4_array_nan_size = None
self.a_frame4_array_ninf_size = None
self.a_frame4_array_snan_size = None
self.a_half2_array_inf_size = None
self.a_half2_array_nan_size = None
self.a_half2_array_ninf_size = None
self.a_half2_array_snan_size = None
self.a_half3_array_inf_size = None
self.a_half3_array_nan_size = None
self.a_half3_array_ninf_size = None
self.a_half3_array_snan_size = None
self.a_half4_array_inf_size = None
self.a_half4_array_nan_size = None
self.a_half4_array_ninf_size = None
self.a_half4_array_snan_size = None
self.a_half_array_inf_size = None
self.a_half_array_nan_size = None
self.a_half_array_ninf_size = None
self.a_half_array_snan_size = None
self.a_matrixd2_array_inf_size = None
self.a_matrixd2_array_nan_size = None
self.a_matrixd2_array_ninf_size = None
self.a_matrixd2_array_snan_size = None
self.a_matrixd3_array_inf_size = None
self.a_matrixd3_array_nan_size = None
self.a_matrixd3_array_ninf_size = None
self.a_matrixd3_array_snan_size = None
self.a_matrixd4_array_inf_size = None
self.a_matrixd4_array_nan_size = None
self.a_matrixd4_array_ninf_size = None
self.a_matrixd4_array_snan_size = None
self.a_normald3_array_inf_size = None
self.a_normald3_array_nan_size = None
self.a_normald3_array_ninf_size = None
self.a_normald3_array_snan_size = None
self.a_normalf3_array_inf_size = None
self.a_normalf3_array_nan_size = None
self.a_normalf3_array_ninf_size = None
self.a_normalf3_array_snan_size = None
self.a_normalh3_array_inf_size = None
self.a_normalh3_array_nan_size = None
self.a_normalh3_array_ninf_size = None
self.a_normalh3_array_snan_size = None
self.a_pointd3_array_inf_size = None
self.a_pointd3_array_nan_size = None
self.a_pointd3_array_ninf_size = None
self.a_pointd3_array_snan_size = None
self.a_pointf3_array_inf_size = None
self.a_pointf3_array_nan_size = None
self.a_pointf3_array_ninf_size = None
self.a_pointf3_array_snan_size = None
self.a_pointh3_array_inf_size = None
self.a_pointh3_array_nan_size = None
self.a_pointh3_array_ninf_size = None
self.a_pointh3_array_snan_size = None
self.a_quatd4_array_inf_size = None
self.a_quatd4_array_nan_size = None
self.a_quatd4_array_ninf_size = None
self.a_quatd4_array_snan_size = None
self.a_quatf4_array_inf_size = None
self.a_quatf4_array_nan_size = None
self.a_quatf4_array_ninf_size = None
self.a_quatf4_array_snan_size = None
self.a_quath4_array_inf_size = None
self.a_quath4_array_nan_size = None
self.a_quath4_array_ninf_size = None
self.a_quath4_array_snan_size = None
self.a_texcoordd2_array_inf_size = None
self.a_texcoordd2_array_nan_size = None
self.a_texcoordd2_array_ninf_size = None
self.a_texcoordd2_array_snan_size = None
self.a_texcoordd3_array_inf_size = None
self.a_texcoordd3_array_nan_size = None
self.a_texcoordd3_array_ninf_size = None
self.a_texcoordd3_array_snan_size = None
self.a_texcoordf2_array_inf_size = None
self.a_texcoordf2_array_nan_size = None
self.a_texcoordf2_array_ninf_size = None
self.a_texcoordf2_array_snan_size = None
self.a_texcoordf3_array_inf_size = None
self.a_texcoordf3_array_nan_size = None
self.a_texcoordf3_array_ninf_size = None
self.a_texcoordf3_array_snan_size = None
self.a_texcoordh2_array_inf_size = None
self.a_texcoordh2_array_nan_size = None
self.a_texcoordh2_array_ninf_size = None
self.a_texcoordh2_array_snan_size = None
self.a_texcoordh3_array_inf_size = None
self.a_texcoordh3_array_nan_size = None
self.a_texcoordh3_array_ninf_size = None
self.a_texcoordh3_array_snan_size = None
self.a_timecode_array_inf_size = None
self.a_timecode_array_nan_size = None
self.a_timecode_array_ninf_size = None
self.a_timecode_array_snan_size = None
self.a_vectord3_array_inf_size = None
self.a_vectord3_array_nan_size = None
self.a_vectord3_array_ninf_size = None
self.a_vectord3_array_snan_size = None
self.a_vectorf3_array_inf_size = None
self.a_vectorf3_array_nan_size = None
self.a_vectorf3_array_ninf_size = None
self.a_vectorf3_array_snan_size = None
self.a_vectorh3_array_inf_size = None
self.a_vectorh3_array_nan_size = None
self.a_vectorh3_array_ninf_size = None
self.a_vectorh3_array_snan_size = None
self._batchedWriteValues = { }
@property
def a_colord3_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord3_array_inf)
return data_view.get(reserved_element_count=self.a_colord3_array_inf_size)
@a_colord3_array_inf.setter
def a_colord3_array_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colord3_array_inf)
data_view.set(value)
self.a_colord3_array_inf_size = data_view.get_array_size()
@property
def a_colord3_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord3_array_nan)
return data_view.get(reserved_element_count=self.a_colord3_array_nan_size)
@a_colord3_array_nan.setter
def a_colord3_array_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colord3_array_nan)
data_view.set(value)
self.a_colord3_array_nan_size = data_view.get_array_size()
@property
def a_colord3_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord3_array_ninf)
return data_view.get(reserved_element_count=self.a_colord3_array_ninf_size)
@a_colord3_array_ninf.setter
def a_colord3_array_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colord3_array_ninf)
data_view.set(value)
self.a_colord3_array_ninf_size = data_view.get_array_size()
@property
def a_colord3_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord3_array_snan)
return data_view.get(reserved_element_count=self.a_colord3_array_snan_size)
@a_colord3_array_snan.setter
def a_colord3_array_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colord3_array_snan)
data_view.set(value)
self.a_colord3_array_snan_size = data_view.get_array_size()
@property
def a_colord3_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord3_inf)
return data_view.get()
@a_colord3_inf.setter
def a_colord3_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colord3_inf)
data_view.set(value)
@property
def a_colord3_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord3_nan)
return data_view.get()
@a_colord3_nan.setter
def a_colord3_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colord3_nan)
data_view.set(value)
@property
def a_colord3_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord3_ninf)
return data_view.get()
@a_colord3_ninf.setter
def a_colord3_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colord3_ninf)
data_view.set(value)
@property
def a_colord3_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord3_snan)
return data_view.get()
@a_colord3_snan.setter
def a_colord3_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colord3_snan)
data_view.set(value)
@property
def a_colord4_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord4_array_inf)
return data_view.get(reserved_element_count=self.a_colord4_array_inf_size)
@a_colord4_array_inf.setter
def a_colord4_array_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colord4_array_inf)
data_view.set(value)
self.a_colord4_array_inf_size = data_view.get_array_size()
@property
def a_colord4_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord4_array_nan)
return data_view.get(reserved_element_count=self.a_colord4_array_nan_size)
@a_colord4_array_nan.setter
def a_colord4_array_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colord4_array_nan)
data_view.set(value)
self.a_colord4_array_nan_size = data_view.get_array_size()
@property
def a_colord4_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord4_array_ninf)
return data_view.get(reserved_element_count=self.a_colord4_array_ninf_size)
@a_colord4_array_ninf.setter
def a_colord4_array_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colord4_array_ninf)
data_view.set(value)
self.a_colord4_array_ninf_size = data_view.get_array_size()
@property
def a_colord4_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord4_array_snan)
return data_view.get(reserved_element_count=self.a_colord4_array_snan_size)
@a_colord4_array_snan.setter
def a_colord4_array_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colord4_array_snan)
data_view.set(value)
self.a_colord4_array_snan_size = data_view.get_array_size()
@property
def a_colord4_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord4_inf)
return data_view.get()
@a_colord4_inf.setter
def a_colord4_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colord4_inf)
data_view.set(value)
@property
def a_colord4_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord4_nan)
return data_view.get()
@a_colord4_nan.setter
def a_colord4_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colord4_nan)
data_view.set(value)
@property
def a_colord4_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord4_ninf)
return data_view.get()
@a_colord4_ninf.setter
def a_colord4_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colord4_ninf)
data_view.set(value)
@property
def a_colord4_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colord4_snan)
return data_view.get()
@a_colord4_snan.setter
def a_colord4_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colord4_snan)
data_view.set(value)
@property
def a_colorf3_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf3_array_inf)
return data_view.get(reserved_element_count=self.a_colorf3_array_inf_size)
@a_colorf3_array_inf.setter
def a_colorf3_array_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorf3_array_inf)
data_view.set(value)
self.a_colorf3_array_inf_size = data_view.get_array_size()
@property
def a_colorf3_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf3_array_nan)
return data_view.get(reserved_element_count=self.a_colorf3_array_nan_size)
@a_colorf3_array_nan.setter
def a_colorf3_array_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorf3_array_nan)
data_view.set(value)
self.a_colorf3_array_nan_size = data_view.get_array_size()
@property
def a_colorf3_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf3_array_ninf)
return data_view.get(reserved_element_count=self.a_colorf3_array_ninf_size)
@a_colorf3_array_ninf.setter
def a_colorf3_array_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorf3_array_ninf)
data_view.set(value)
self.a_colorf3_array_ninf_size = data_view.get_array_size()
@property
def a_colorf3_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf3_array_snan)
return data_view.get(reserved_element_count=self.a_colorf3_array_snan_size)
@a_colorf3_array_snan.setter
def a_colorf3_array_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorf3_array_snan)
data_view.set(value)
self.a_colorf3_array_snan_size = data_view.get_array_size()
@property
def a_colorf3_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf3_inf)
return data_view.get()
@a_colorf3_inf.setter
def a_colorf3_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorf3_inf)
data_view.set(value)
@property
def a_colorf3_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf3_nan)
return data_view.get()
@a_colorf3_nan.setter
def a_colorf3_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorf3_nan)
data_view.set(value)
@property
def a_colorf3_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf3_ninf)
return data_view.get()
@a_colorf3_ninf.setter
def a_colorf3_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorf3_ninf)
data_view.set(value)
@property
def a_colorf3_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf3_snan)
return data_view.get()
@a_colorf3_snan.setter
def a_colorf3_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorf3_snan)
data_view.set(value)
@property
def a_colorf4_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf4_array_inf)
return data_view.get(reserved_element_count=self.a_colorf4_array_inf_size)
@a_colorf4_array_inf.setter
def a_colorf4_array_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorf4_array_inf)
data_view.set(value)
self.a_colorf4_array_inf_size = data_view.get_array_size()
@property
def a_colorf4_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf4_array_nan)
return data_view.get(reserved_element_count=self.a_colorf4_array_nan_size)
@a_colorf4_array_nan.setter
def a_colorf4_array_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorf4_array_nan)
data_view.set(value)
self.a_colorf4_array_nan_size = data_view.get_array_size()
@property
def a_colorf4_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf4_array_ninf)
return data_view.get(reserved_element_count=self.a_colorf4_array_ninf_size)
@a_colorf4_array_ninf.setter
def a_colorf4_array_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorf4_array_ninf)
data_view.set(value)
self.a_colorf4_array_ninf_size = data_view.get_array_size()
@property
def a_colorf4_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf4_array_snan)
return data_view.get(reserved_element_count=self.a_colorf4_array_snan_size)
@a_colorf4_array_snan.setter
def a_colorf4_array_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorf4_array_snan)
data_view.set(value)
self.a_colorf4_array_snan_size = data_view.get_array_size()
@property
def a_colorf4_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf4_inf)
return data_view.get()
@a_colorf4_inf.setter
def a_colorf4_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorf4_inf)
data_view.set(value)
@property
def a_colorf4_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf4_nan)
return data_view.get()
@a_colorf4_nan.setter
def a_colorf4_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorf4_nan)
data_view.set(value)
@property
def a_colorf4_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf4_ninf)
return data_view.get()
@a_colorf4_ninf.setter
def a_colorf4_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorf4_ninf)
data_view.set(value)
@property
def a_colorf4_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorf4_snan)
return data_view.get()
@a_colorf4_snan.setter
def a_colorf4_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorf4_snan)
data_view.set(value)
@property
def a_colorh3_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh3_array_inf)
return data_view.get(reserved_element_count=self.a_colorh3_array_inf_size)
@a_colorh3_array_inf.setter
def a_colorh3_array_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorh3_array_inf)
data_view.set(value)
self.a_colorh3_array_inf_size = data_view.get_array_size()
@property
def a_colorh3_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh3_array_nan)
return data_view.get(reserved_element_count=self.a_colorh3_array_nan_size)
@a_colorh3_array_nan.setter
def a_colorh3_array_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorh3_array_nan)
data_view.set(value)
self.a_colorh3_array_nan_size = data_view.get_array_size()
@property
def a_colorh3_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh3_array_ninf)
return data_view.get(reserved_element_count=self.a_colorh3_array_ninf_size)
@a_colorh3_array_ninf.setter
def a_colorh3_array_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorh3_array_ninf)
data_view.set(value)
self.a_colorh3_array_ninf_size = data_view.get_array_size()
@property
def a_colorh3_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh3_array_snan)
return data_view.get(reserved_element_count=self.a_colorh3_array_snan_size)
@a_colorh3_array_snan.setter
def a_colorh3_array_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorh3_array_snan)
data_view.set(value)
self.a_colorh3_array_snan_size = data_view.get_array_size()
@property
def a_colorh3_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh3_inf)
return data_view.get()
@a_colorh3_inf.setter
def a_colorh3_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorh3_inf)
data_view.set(value)
@property
def a_colorh3_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh3_nan)
return data_view.get()
@a_colorh3_nan.setter
def a_colorh3_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorh3_nan)
data_view.set(value)
@property
def a_colorh3_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh3_ninf)
return data_view.get()
@a_colorh3_ninf.setter
def a_colorh3_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorh3_ninf)
data_view.set(value)
@property
def a_colorh3_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh3_snan)
return data_view.get()
@a_colorh3_snan.setter
def a_colorh3_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorh3_snan)
data_view.set(value)
@property
def a_colorh4_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh4_array_inf)
return data_view.get(reserved_element_count=self.a_colorh4_array_inf_size)
@a_colorh4_array_inf.setter
def a_colorh4_array_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorh4_array_inf)
data_view.set(value)
self.a_colorh4_array_inf_size = data_view.get_array_size()
@property
def a_colorh4_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh4_array_nan)
return data_view.get(reserved_element_count=self.a_colorh4_array_nan_size)
@a_colorh4_array_nan.setter
def a_colorh4_array_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorh4_array_nan)
data_view.set(value)
self.a_colorh4_array_nan_size = data_view.get_array_size()
@property
def a_colorh4_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh4_array_ninf)
return data_view.get(reserved_element_count=self.a_colorh4_array_ninf_size)
@a_colorh4_array_ninf.setter
def a_colorh4_array_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorh4_array_ninf)
data_view.set(value)
self.a_colorh4_array_ninf_size = data_view.get_array_size()
@property
def a_colorh4_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh4_array_snan)
return data_view.get(reserved_element_count=self.a_colorh4_array_snan_size)
@a_colorh4_array_snan.setter
def a_colorh4_array_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorh4_array_snan)
data_view.set(value)
self.a_colorh4_array_snan_size = data_view.get_array_size()
@property
def a_colorh4_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh4_inf)
return data_view.get()
@a_colorh4_inf.setter
def a_colorh4_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorh4_inf)
data_view.set(value)
@property
def a_colorh4_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh4_nan)
return data_view.get()
@a_colorh4_nan.setter
def a_colorh4_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorh4_nan)
data_view.set(value)
@property
def a_colorh4_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh4_ninf)
return data_view.get()
@a_colorh4_ninf.setter
def a_colorh4_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorh4_ninf)
data_view.set(value)
@property
def a_colorh4_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_colorh4_snan)
return data_view.get()
@a_colorh4_snan.setter
def a_colorh4_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_colorh4_snan)
data_view.set(value)
@property
def a_double2_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_double2_array_inf)
return data_view.get(reserved_element_count=self.a_double2_array_inf_size)
@a_double2_array_inf.setter
def a_double2_array_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double2_array_inf)
data_view.set(value)
self.a_double2_array_inf_size = data_view.get_array_size()
@property
def a_double2_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_double2_array_nan)
return data_view.get(reserved_element_count=self.a_double2_array_nan_size)
@a_double2_array_nan.setter
def a_double2_array_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double2_array_nan)
data_view.set(value)
self.a_double2_array_nan_size = data_view.get_array_size()
@property
def a_double2_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_double2_array_ninf)
return data_view.get(reserved_element_count=self.a_double2_array_ninf_size)
@a_double2_array_ninf.setter
def a_double2_array_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double2_array_ninf)
data_view.set(value)
self.a_double2_array_ninf_size = data_view.get_array_size()
@property
def a_double2_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_double2_array_snan)
return data_view.get(reserved_element_count=self.a_double2_array_snan_size)
@a_double2_array_snan.setter
def a_double2_array_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double2_array_snan)
data_view.set(value)
self.a_double2_array_snan_size = data_view.get_array_size()
@property
def a_double2_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_double2_inf)
return data_view.get()
@a_double2_inf.setter
def a_double2_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double2_inf)
data_view.set(value)
@property
def a_double2_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_double2_nan)
return data_view.get()
@a_double2_nan.setter
def a_double2_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double2_nan)
data_view.set(value)
@property
def a_double2_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_double2_ninf)
return data_view.get()
@a_double2_ninf.setter
def a_double2_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double2_ninf)
data_view.set(value)
@property
def a_double2_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_double2_snan)
return data_view.get()
@a_double2_snan.setter
def a_double2_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double2_snan)
data_view.set(value)
@property
def a_double3_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_double3_array_inf)
return data_view.get(reserved_element_count=self.a_double3_array_inf_size)
@a_double3_array_inf.setter
def a_double3_array_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double3_array_inf)
data_view.set(value)
self.a_double3_array_inf_size = data_view.get_array_size()
@property
def a_double3_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_double3_array_nan)
return data_view.get(reserved_element_count=self.a_double3_array_nan_size)
@a_double3_array_nan.setter
def a_double3_array_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double3_array_nan)
data_view.set(value)
self.a_double3_array_nan_size = data_view.get_array_size()
@property
def a_double3_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_double3_array_ninf)
return data_view.get(reserved_element_count=self.a_double3_array_ninf_size)
@a_double3_array_ninf.setter
def a_double3_array_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double3_array_ninf)
data_view.set(value)
self.a_double3_array_ninf_size = data_view.get_array_size()
@property
def a_double3_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_double3_array_snan)
return data_view.get(reserved_element_count=self.a_double3_array_snan_size)
@a_double3_array_snan.setter
def a_double3_array_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double3_array_snan)
data_view.set(value)
self.a_double3_array_snan_size = data_view.get_array_size()
@property
def a_double3_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_double3_inf)
return data_view.get()
@a_double3_inf.setter
def a_double3_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double3_inf)
data_view.set(value)
@property
def a_double3_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_double3_nan)
return data_view.get()
@a_double3_nan.setter
def a_double3_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double3_nan)
data_view.set(value)
@property
def a_double3_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_double3_ninf)
return data_view.get()
@a_double3_ninf.setter
def a_double3_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double3_ninf)
data_view.set(value)
@property
def a_double3_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_double3_snan)
return data_view.get()
@a_double3_snan.setter
def a_double3_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double3_snan)
data_view.set(value)
@property
def a_double4_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_double4_array_inf)
return data_view.get(reserved_element_count=self.a_double4_array_inf_size)
@a_double4_array_inf.setter
def a_double4_array_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double4_array_inf)
data_view.set(value)
self.a_double4_array_inf_size = data_view.get_array_size()
@property
def a_double4_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_double4_array_nan)
return data_view.get(reserved_element_count=self.a_double4_array_nan_size)
@a_double4_array_nan.setter
def a_double4_array_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double4_array_nan)
data_view.set(value)
self.a_double4_array_nan_size = data_view.get_array_size()
@property
def a_double4_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_double4_array_ninf)
return data_view.get(reserved_element_count=self.a_double4_array_ninf_size)
@a_double4_array_ninf.setter
def a_double4_array_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double4_array_ninf)
data_view.set(value)
self.a_double4_array_ninf_size = data_view.get_array_size()
@property
def a_double4_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_double4_array_snan)
return data_view.get(reserved_element_count=self.a_double4_array_snan_size)
@a_double4_array_snan.setter
def a_double4_array_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double4_array_snan)
data_view.set(value)
self.a_double4_array_snan_size = data_view.get_array_size()
@property
def a_double4_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_double4_inf)
return data_view.get()
@a_double4_inf.setter
def a_double4_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double4_inf)
data_view.set(value)
@property
def a_double4_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_double4_nan)
return data_view.get()
@a_double4_nan.setter
def a_double4_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double4_nan)
data_view.set(value)
@property
def a_double4_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_double4_ninf)
return data_view.get()
@a_double4_ninf.setter
def a_double4_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double4_ninf)
data_view.set(value)
@property
def a_double4_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_double4_snan)
return data_view.get()
@a_double4_snan.setter
def a_double4_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double4_snan)
data_view.set(value)
@property
def a_double_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_double_array_inf)
return data_view.get(reserved_element_count=self.a_double_array_inf_size)
@a_double_array_inf.setter
def a_double_array_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double_array_inf)
data_view.set(value)
self.a_double_array_inf_size = data_view.get_array_size()
@property
def a_double_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_double_array_nan)
return data_view.get(reserved_element_count=self.a_double_array_nan_size)
@a_double_array_nan.setter
def a_double_array_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double_array_nan)
data_view.set(value)
self.a_double_array_nan_size = data_view.get_array_size()
@property
def a_double_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_double_array_ninf)
return data_view.get(reserved_element_count=self.a_double_array_ninf_size)
@a_double_array_ninf.setter
def a_double_array_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double_array_ninf)
data_view.set(value)
self.a_double_array_ninf_size = data_view.get_array_size()
@property
def a_double_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_double_array_snan)
return data_view.get(reserved_element_count=self.a_double_array_snan_size)
@a_double_array_snan.setter
def a_double_array_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double_array_snan)
data_view.set(value)
self.a_double_array_snan_size = data_view.get_array_size()
@property
def a_double_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_double_inf)
return data_view.get()
@a_double_inf.setter
def a_double_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double_inf)
data_view.set(value)
@property
def a_double_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_double_nan)
return data_view.get()
@a_double_nan.setter
def a_double_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double_nan)
data_view.set(value)
@property
def a_double_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_double_ninf)
return data_view.get()
@a_double_ninf.setter
def a_double_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double_ninf)
data_view.set(value)
@property
def a_double_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_double_snan)
return data_view.get()
@a_double_snan.setter
def a_double_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_double_snan)
data_view.set(value)
@property
def a_float2_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_float2_array_inf)
return data_view.get(reserved_element_count=self.a_float2_array_inf_size)
@a_float2_array_inf.setter
def a_float2_array_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float2_array_inf)
data_view.set(value)
self.a_float2_array_inf_size = data_view.get_array_size()
@property
def a_float2_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_float2_array_nan)
return data_view.get(reserved_element_count=self.a_float2_array_nan_size)
@a_float2_array_nan.setter
def a_float2_array_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float2_array_nan)
data_view.set(value)
self.a_float2_array_nan_size = data_view.get_array_size()
@property
def a_float2_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_float2_array_ninf)
return data_view.get(reserved_element_count=self.a_float2_array_ninf_size)
@a_float2_array_ninf.setter
def a_float2_array_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float2_array_ninf)
data_view.set(value)
self.a_float2_array_ninf_size = data_view.get_array_size()
@property
def a_float2_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_float2_array_snan)
return data_view.get(reserved_element_count=self.a_float2_array_snan_size)
@a_float2_array_snan.setter
def a_float2_array_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float2_array_snan)
data_view.set(value)
self.a_float2_array_snan_size = data_view.get_array_size()
@property
def a_float2_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_float2_inf)
return data_view.get()
@a_float2_inf.setter
def a_float2_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float2_inf)
data_view.set(value)
@property
def a_float2_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_float2_nan)
return data_view.get()
@a_float2_nan.setter
def a_float2_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float2_nan)
data_view.set(value)
@property
def a_float2_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_float2_ninf)
return data_view.get()
@a_float2_ninf.setter
def a_float2_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float2_ninf)
data_view.set(value)
@property
def a_float2_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_float2_snan)
return data_view.get()
@a_float2_snan.setter
def a_float2_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float2_snan)
data_view.set(value)
@property
def a_float3_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_float3_array_inf)
return data_view.get(reserved_element_count=self.a_float3_array_inf_size)
@a_float3_array_inf.setter
def a_float3_array_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float3_array_inf)
data_view.set(value)
self.a_float3_array_inf_size = data_view.get_array_size()
@property
def a_float3_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_float3_array_nan)
return data_view.get(reserved_element_count=self.a_float3_array_nan_size)
@a_float3_array_nan.setter
def a_float3_array_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float3_array_nan)
data_view.set(value)
self.a_float3_array_nan_size = data_view.get_array_size()
@property
def a_float3_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_float3_array_ninf)
return data_view.get(reserved_element_count=self.a_float3_array_ninf_size)
@a_float3_array_ninf.setter
def a_float3_array_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float3_array_ninf)
data_view.set(value)
self.a_float3_array_ninf_size = data_view.get_array_size()
@property
def a_float3_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_float3_array_snan)
return data_view.get(reserved_element_count=self.a_float3_array_snan_size)
@a_float3_array_snan.setter
def a_float3_array_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float3_array_snan)
data_view.set(value)
self.a_float3_array_snan_size = data_view.get_array_size()
@property
def a_float3_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_float3_inf)
return data_view.get()
@a_float3_inf.setter
def a_float3_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float3_inf)
data_view.set(value)
@property
def a_float3_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_float3_nan)
return data_view.get()
@a_float3_nan.setter
def a_float3_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float3_nan)
data_view.set(value)
@property
def a_float3_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_float3_ninf)
return data_view.get()
@a_float3_ninf.setter
def a_float3_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float3_ninf)
data_view.set(value)
@property
def a_float3_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_float3_snan)
return data_view.get()
@a_float3_snan.setter
def a_float3_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float3_snan)
data_view.set(value)
@property
def a_float4_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_float4_array_inf)
return data_view.get(reserved_element_count=self.a_float4_array_inf_size)
@a_float4_array_inf.setter
def a_float4_array_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float4_array_inf)
data_view.set(value)
self.a_float4_array_inf_size = data_view.get_array_size()
@property
def a_float4_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_float4_array_nan)
return data_view.get(reserved_element_count=self.a_float4_array_nan_size)
@a_float4_array_nan.setter
def a_float4_array_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float4_array_nan)
data_view.set(value)
self.a_float4_array_nan_size = data_view.get_array_size()
@property
def a_float4_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_float4_array_ninf)
return data_view.get(reserved_element_count=self.a_float4_array_ninf_size)
@a_float4_array_ninf.setter
def a_float4_array_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float4_array_ninf)
data_view.set(value)
self.a_float4_array_ninf_size = data_view.get_array_size()
@property
def a_float4_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_float4_array_snan)
return data_view.get(reserved_element_count=self.a_float4_array_snan_size)
@a_float4_array_snan.setter
def a_float4_array_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float4_array_snan)
data_view.set(value)
self.a_float4_array_snan_size = data_view.get_array_size()
@property
def a_float4_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_float4_inf)
return data_view.get()
@a_float4_inf.setter
def a_float4_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float4_inf)
data_view.set(value)
@property
def a_float4_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_float4_nan)
return data_view.get()
@a_float4_nan.setter
def a_float4_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float4_nan)
data_view.set(value)
@property
def a_float4_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_float4_ninf)
return data_view.get()
@a_float4_ninf.setter
def a_float4_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float4_ninf)
data_view.set(value)
@property
def a_float4_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_float4_snan)
return data_view.get()
@a_float4_snan.setter
def a_float4_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float4_snan)
data_view.set(value)
@property
def a_float_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_float_array_inf)
return data_view.get(reserved_element_count=self.a_float_array_inf_size)
@a_float_array_inf.setter
def a_float_array_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float_array_inf)
data_view.set(value)
self.a_float_array_inf_size = data_view.get_array_size()
@property
def a_float_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_float_array_nan)
return data_view.get(reserved_element_count=self.a_float_array_nan_size)
@a_float_array_nan.setter
def a_float_array_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float_array_nan)
data_view.set(value)
self.a_float_array_nan_size = data_view.get_array_size()
@property
def a_float_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_float_array_ninf)
return data_view.get(reserved_element_count=self.a_float_array_ninf_size)
@a_float_array_ninf.setter
def a_float_array_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float_array_ninf)
data_view.set(value)
self.a_float_array_ninf_size = data_view.get_array_size()
@property
def a_float_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_float_array_snan)
return data_view.get(reserved_element_count=self.a_float_array_snan_size)
@a_float_array_snan.setter
def a_float_array_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float_array_snan)
data_view.set(value)
self.a_float_array_snan_size = data_view.get_array_size()
@property
def a_float_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_float_inf)
return data_view.get()
@a_float_inf.setter
def a_float_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float_inf)
data_view.set(value)
@property
def a_float_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_float_nan)
return data_view.get()
@a_float_nan.setter
def a_float_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float_nan)
data_view.set(value)
@property
def a_float_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_float_ninf)
return data_view.get()
@a_float_ninf.setter
def a_float_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float_ninf)
data_view.set(value)
@property
def a_float_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_float_snan)
return data_view.get()
@a_float_snan.setter
def a_float_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_float_snan)
data_view.set(value)
@property
def a_frame4_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_frame4_array_inf)
return data_view.get(reserved_element_count=self.a_frame4_array_inf_size)
@a_frame4_array_inf.setter
def a_frame4_array_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_frame4_array_inf)
data_view.set(value)
self.a_frame4_array_inf_size = data_view.get_array_size()
@property
def a_frame4_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_frame4_array_nan)
return data_view.get(reserved_element_count=self.a_frame4_array_nan_size)
@a_frame4_array_nan.setter
def a_frame4_array_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_frame4_array_nan)
data_view.set(value)
self.a_frame4_array_nan_size = data_view.get_array_size()
@property
def a_frame4_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_frame4_array_ninf)
return data_view.get(reserved_element_count=self.a_frame4_array_ninf_size)
@a_frame4_array_ninf.setter
def a_frame4_array_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_frame4_array_ninf)
data_view.set(value)
self.a_frame4_array_ninf_size = data_view.get_array_size()
@property
def a_frame4_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_frame4_array_snan)
return data_view.get(reserved_element_count=self.a_frame4_array_snan_size)
@a_frame4_array_snan.setter
def a_frame4_array_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_frame4_array_snan)
data_view.set(value)
self.a_frame4_array_snan_size = data_view.get_array_size()
@property
def a_frame4_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_frame4_inf)
return data_view.get()
@a_frame4_inf.setter
def a_frame4_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_frame4_inf)
data_view.set(value)
@property
def a_frame4_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_frame4_nan)
return data_view.get()
@a_frame4_nan.setter
def a_frame4_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_frame4_nan)
data_view.set(value)
@property
def a_frame4_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_frame4_ninf)
return data_view.get()
@a_frame4_ninf.setter
def a_frame4_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_frame4_ninf)
data_view.set(value)
@property
def a_frame4_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_frame4_snan)
return data_view.get()
@a_frame4_snan.setter
def a_frame4_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_frame4_snan)
data_view.set(value)
@property
def a_half2_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_half2_array_inf)
return data_view.get(reserved_element_count=self.a_half2_array_inf_size)
@a_half2_array_inf.setter
def a_half2_array_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half2_array_inf)
data_view.set(value)
self.a_half2_array_inf_size = data_view.get_array_size()
@property
def a_half2_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_half2_array_nan)
return data_view.get(reserved_element_count=self.a_half2_array_nan_size)
@a_half2_array_nan.setter
def a_half2_array_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half2_array_nan)
data_view.set(value)
self.a_half2_array_nan_size = data_view.get_array_size()
@property
def a_half2_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_half2_array_ninf)
return data_view.get(reserved_element_count=self.a_half2_array_ninf_size)
@a_half2_array_ninf.setter
def a_half2_array_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half2_array_ninf)
data_view.set(value)
self.a_half2_array_ninf_size = data_view.get_array_size()
@property
def a_half2_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_half2_array_snan)
return data_view.get(reserved_element_count=self.a_half2_array_snan_size)
@a_half2_array_snan.setter
def a_half2_array_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half2_array_snan)
data_view.set(value)
self.a_half2_array_snan_size = data_view.get_array_size()
@property
def a_half2_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_half2_inf)
return data_view.get()
@a_half2_inf.setter
def a_half2_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half2_inf)
data_view.set(value)
@property
def a_half2_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_half2_nan)
return data_view.get()
@a_half2_nan.setter
def a_half2_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half2_nan)
data_view.set(value)
@property
def a_half2_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_half2_ninf)
return data_view.get()
@a_half2_ninf.setter
def a_half2_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half2_ninf)
data_view.set(value)
@property
def a_half2_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_half2_snan)
return data_view.get()
@a_half2_snan.setter
def a_half2_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half2_snan)
data_view.set(value)
@property
def a_half3_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_half3_array_inf)
return data_view.get(reserved_element_count=self.a_half3_array_inf_size)
@a_half3_array_inf.setter
def a_half3_array_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half3_array_inf)
data_view.set(value)
self.a_half3_array_inf_size = data_view.get_array_size()
@property
def a_half3_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_half3_array_nan)
return data_view.get(reserved_element_count=self.a_half3_array_nan_size)
@a_half3_array_nan.setter
def a_half3_array_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half3_array_nan)
data_view.set(value)
self.a_half3_array_nan_size = data_view.get_array_size()
@property
def a_half3_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_half3_array_ninf)
return data_view.get(reserved_element_count=self.a_half3_array_ninf_size)
@a_half3_array_ninf.setter
def a_half3_array_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half3_array_ninf)
data_view.set(value)
self.a_half3_array_ninf_size = data_view.get_array_size()
@property
def a_half3_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_half3_array_snan)
return data_view.get(reserved_element_count=self.a_half3_array_snan_size)
@a_half3_array_snan.setter
def a_half3_array_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half3_array_snan)
data_view.set(value)
self.a_half3_array_snan_size = data_view.get_array_size()
@property
def a_half3_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_half3_inf)
return data_view.get()
@a_half3_inf.setter
def a_half3_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half3_inf)
data_view.set(value)
@property
def a_half3_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_half3_nan)
return data_view.get()
@a_half3_nan.setter
def a_half3_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half3_nan)
data_view.set(value)
@property
def a_half3_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_half3_ninf)
return data_view.get()
@a_half3_ninf.setter
def a_half3_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half3_ninf)
data_view.set(value)
@property
def a_half3_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_half3_snan)
return data_view.get()
@a_half3_snan.setter
def a_half3_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half3_snan)
data_view.set(value)
@property
def a_half4_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_half4_array_inf)
return data_view.get(reserved_element_count=self.a_half4_array_inf_size)
@a_half4_array_inf.setter
def a_half4_array_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half4_array_inf)
data_view.set(value)
self.a_half4_array_inf_size = data_view.get_array_size()
@property
def a_half4_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_half4_array_nan)
return data_view.get(reserved_element_count=self.a_half4_array_nan_size)
@a_half4_array_nan.setter
def a_half4_array_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half4_array_nan)
data_view.set(value)
self.a_half4_array_nan_size = data_view.get_array_size()
@property
def a_half4_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_half4_array_ninf)
return data_view.get(reserved_element_count=self.a_half4_array_ninf_size)
@a_half4_array_ninf.setter
def a_half4_array_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half4_array_ninf)
data_view.set(value)
self.a_half4_array_ninf_size = data_view.get_array_size()
@property
def a_half4_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_half4_array_snan)
return data_view.get(reserved_element_count=self.a_half4_array_snan_size)
@a_half4_array_snan.setter
def a_half4_array_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half4_array_snan)
data_view.set(value)
self.a_half4_array_snan_size = data_view.get_array_size()
@property
def a_half4_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_half4_inf)
return data_view.get()
@a_half4_inf.setter
def a_half4_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half4_inf)
data_view.set(value)
@property
def a_half4_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_half4_nan)
return data_view.get()
@a_half4_nan.setter
def a_half4_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half4_nan)
data_view.set(value)
@property
def a_half4_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_half4_ninf)
return data_view.get()
@a_half4_ninf.setter
def a_half4_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half4_ninf)
data_view.set(value)
@property
def a_half4_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_half4_snan)
return data_view.get()
@a_half4_snan.setter
def a_half4_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half4_snan)
data_view.set(value)
@property
def a_half_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_half_array_inf)
return data_view.get(reserved_element_count=self.a_half_array_inf_size)
@a_half_array_inf.setter
def a_half_array_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half_array_inf)
data_view.set(value)
self.a_half_array_inf_size = data_view.get_array_size()
@property
def a_half_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_half_array_nan)
return data_view.get(reserved_element_count=self.a_half_array_nan_size)
@a_half_array_nan.setter
def a_half_array_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half_array_nan)
data_view.set(value)
self.a_half_array_nan_size = data_view.get_array_size()
@property
def a_half_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_half_array_ninf)
return data_view.get(reserved_element_count=self.a_half_array_ninf_size)
@a_half_array_ninf.setter
def a_half_array_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half_array_ninf)
data_view.set(value)
self.a_half_array_ninf_size = data_view.get_array_size()
@property
def a_half_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_half_array_snan)
return data_view.get(reserved_element_count=self.a_half_array_snan_size)
@a_half_array_snan.setter
def a_half_array_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half_array_snan)
data_view.set(value)
self.a_half_array_snan_size = data_view.get_array_size()
@property
def a_half_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_half_inf)
return data_view.get()
@a_half_inf.setter
def a_half_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half_inf)
data_view.set(value)
@property
def a_half_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_half_nan)
return data_view.get()
@a_half_nan.setter
def a_half_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half_nan)
data_view.set(value)
@property
def a_half_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_half_ninf)
return data_view.get()
@a_half_ninf.setter
def a_half_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half_ninf)
data_view.set(value)
@property
def a_half_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_half_snan)
return data_view.get()
@a_half_snan.setter
def a_half_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_half_snan)
data_view.set(value)
@property
def a_matrixd2_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd2_array_inf)
return data_view.get(reserved_element_count=self.a_matrixd2_array_inf_size)
@a_matrixd2_array_inf.setter
def a_matrixd2_array_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd2_array_inf)
data_view.set(value)
self.a_matrixd2_array_inf_size = data_view.get_array_size()
@property
def a_matrixd2_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd2_array_nan)
return data_view.get(reserved_element_count=self.a_matrixd2_array_nan_size)
@a_matrixd2_array_nan.setter
def a_matrixd2_array_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd2_array_nan)
data_view.set(value)
self.a_matrixd2_array_nan_size = data_view.get_array_size()
@property
def a_matrixd2_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd2_array_ninf)
return data_view.get(reserved_element_count=self.a_matrixd2_array_ninf_size)
@a_matrixd2_array_ninf.setter
def a_matrixd2_array_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd2_array_ninf)
data_view.set(value)
self.a_matrixd2_array_ninf_size = data_view.get_array_size()
@property
def a_matrixd2_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd2_array_snan)
return data_view.get(reserved_element_count=self.a_matrixd2_array_snan_size)
@a_matrixd2_array_snan.setter
def a_matrixd2_array_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd2_array_snan)
data_view.set(value)
self.a_matrixd2_array_snan_size = data_view.get_array_size()
@property
def a_matrixd2_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd2_inf)
return data_view.get()
@a_matrixd2_inf.setter
def a_matrixd2_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd2_inf)
data_view.set(value)
@property
def a_matrixd2_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd2_nan)
return data_view.get()
@a_matrixd2_nan.setter
def a_matrixd2_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd2_nan)
data_view.set(value)
@property
def a_matrixd2_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd2_ninf)
return data_view.get()
@a_matrixd2_ninf.setter
def a_matrixd2_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd2_ninf)
data_view.set(value)
@property
def a_matrixd2_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd2_snan)
return data_view.get()
@a_matrixd2_snan.setter
def a_matrixd2_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd2_snan)
data_view.set(value)
@property
def a_matrixd3_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd3_array_inf)
return data_view.get(reserved_element_count=self.a_matrixd3_array_inf_size)
@a_matrixd3_array_inf.setter
def a_matrixd3_array_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd3_array_inf)
data_view.set(value)
self.a_matrixd3_array_inf_size = data_view.get_array_size()
@property
def a_matrixd3_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd3_array_nan)
return data_view.get(reserved_element_count=self.a_matrixd3_array_nan_size)
@a_matrixd3_array_nan.setter
def a_matrixd3_array_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd3_array_nan)
data_view.set(value)
self.a_matrixd3_array_nan_size = data_view.get_array_size()
@property
def a_matrixd3_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd3_array_ninf)
return data_view.get(reserved_element_count=self.a_matrixd3_array_ninf_size)
@a_matrixd3_array_ninf.setter
def a_matrixd3_array_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd3_array_ninf)
data_view.set(value)
self.a_matrixd3_array_ninf_size = data_view.get_array_size()
@property
def a_matrixd3_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd3_array_snan)
return data_view.get(reserved_element_count=self.a_matrixd3_array_snan_size)
@a_matrixd3_array_snan.setter
def a_matrixd3_array_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd3_array_snan)
data_view.set(value)
self.a_matrixd3_array_snan_size = data_view.get_array_size()
@property
def a_matrixd3_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd3_inf)
return data_view.get()
@a_matrixd3_inf.setter
def a_matrixd3_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd3_inf)
data_view.set(value)
@property
def a_matrixd3_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd3_nan)
return data_view.get()
@a_matrixd3_nan.setter
def a_matrixd3_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd3_nan)
data_view.set(value)
@property
def a_matrixd3_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd3_ninf)
return data_view.get()
@a_matrixd3_ninf.setter
def a_matrixd3_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd3_ninf)
data_view.set(value)
@property
def a_matrixd3_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd3_snan)
return data_view.get()
@a_matrixd3_snan.setter
def a_matrixd3_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd3_snan)
data_view.set(value)
@property
def a_matrixd4_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd4_array_inf)
return data_view.get(reserved_element_count=self.a_matrixd4_array_inf_size)
@a_matrixd4_array_inf.setter
def a_matrixd4_array_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd4_array_inf)
data_view.set(value)
self.a_matrixd4_array_inf_size = data_view.get_array_size()
@property
def a_matrixd4_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd4_array_nan)
return data_view.get(reserved_element_count=self.a_matrixd4_array_nan_size)
@a_matrixd4_array_nan.setter
def a_matrixd4_array_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd4_array_nan)
data_view.set(value)
self.a_matrixd4_array_nan_size = data_view.get_array_size()
@property
def a_matrixd4_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd4_array_ninf)
return data_view.get(reserved_element_count=self.a_matrixd4_array_ninf_size)
@a_matrixd4_array_ninf.setter
def a_matrixd4_array_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd4_array_ninf)
data_view.set(value)
self.a_matrixd4_array_ninf_size = data_view.get_array_size()
@property
def a_matrixd4_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd4_array_snan)
return data_view.get(reserved_element_count=self.a_matrixd4_array_snan_size)
@a_matrixd4_array_snan.setter
def a_matrixd4_array_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd4_array_snan)
data_view.set(value)
self.a_matrixd4_array_snan_size = data_view.get_array_size()
@property
def a_matrixd4_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd4_inf)
return data_view.get()
@a_matrixd4_inf.setter
def a_matrixd4_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd4_inf)
data_view.set(value)
@property
def a_matrixd4_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd4_nan)
return data_view.get()
@a_matrixd4_nan.setter
def a_matrixd4_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd4_nan)
data_view.set(value)
@property
def a_matrixd4_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd4_ninf)
return data_view.get()
@a_matrixd4_ninf.setter
def a_matrixd4_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd4_ninf)
data_view.set(value)
@property
def a_matrixd4_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd4_snan)
return data_view.get()
@a_matrixd4_snan.setter
def a_matrixd4_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_matrixd4_snan)
data_view.set(value)
@property
def a_normald3_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_normald3_array_inf)
return data_view.get(reserved_element_count=self.a_normald3_array_inf_size)
@a_normald3_array_inf.setter
def a_normald3_array_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_normald3_array_inf)
data_view.set(value)
self.a_normald3_array_inf_size = data_view.get_array_size()
@property
def a_normald3_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_normald3_array_nan)
return data_view.get(reserved_element_count=self.a_normald3_array_nan_size)
@a_normald3_array_nan.setter
def a_normald3_array_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_normald3_array_nan)
data_view.set(value)
self.a_normald3_array_nan_size = data_view.get_array_size()
@property
def a_normald3_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_normald3_array_ninf)
return data_view.get(reserved_element_count=self.a_normald3_array_ninf_size)
@a_normald3_array_ninf.setter
def a_normald3_array_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_normald3_array_ninf)
data_view.set(value)
self.a_normald3_array_ninf_size = data_view.get_array_size()
@property
def a_normald3_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_normald3_array_snan)
return data_view.get(reserved_element_count=self.a_normald3_array_snan_size)
@a_normald3_array_snan.setter
def a_normald3_array_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_normald3_array_snan)
data_view.set(value)
self.a_normald3_array_snan_size = data_view.get_array_size()
@property
def a_normald3_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_normald3_inf)
return data_view.get()
@a_normald3_inf.setter
def a_normald3_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_normald3_inf)
data_view.set(value)
@property
def a_normald3_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_normald3_nan)
return data_view.get()
@a_normald3_nan.setter
def a_normald3_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_normald3_nan)
data_view.set(value)
@property
def a_normald3_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_normald3_ninf)
return data_view.get()
@a_normald3_ninf.setter
def a_normald3_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_normald3_ninf)
data_view.set(value)
@property
def a_normald3_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_normald3_snan)
return data_view.get()
@a_normald3_snan.setter
def a_normald3_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_normald3_snan)
data_view.set(value)
@property
def a_normalf3_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalf3_array_inf)
return data_view.get(reserved_element_count=self.a_normalf3_array_inf_size)
@a_normalf3_array_inf.setter
def a_normalf3_array_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_normalf3_array_inf)
data_view.set(value)
self.a_normalf3_array_inf_size = data_view.get_array_size()
@property
def a_normalf3_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalf3_array_nan)
return data_view.get(reserved_element_count=self.a_normalf3_array_nan_size)
@a_normalf3_array_nan.setter
def a_normalf3_array_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_normalf3_array_nan)
data_view.set(value)
self.a_normalf3_array_nan_size = data_view.get_array_size()
@property
def a_normalf3_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalf3_array_ninf)
return data_view.get(reserved_element_count=self.a_normalf3_array_ninf_size)
@a_normalf3_array_ninf.setter
def a_normalf3_array_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_normalf3_array_ninf)
data_view.set(value)
self.a_normalf3_array_ninf_size = data_view.get_array_size()
@property
def a_normalf3_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalf3_array_snan)
return data_view.get(reserved_element_count=self.a_normalf3_array_snan_size)
@a_normalf3_array_snan.setter
def a_normalf3_array_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_normalf3_array_snan)
data_view.set(value)
self.a_normalf3_array_snan_size = data_view.get_array_size()
@property
def a_normalf3_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalf3_inf)
return data_view.get()
@a_normalf3_inf.setter
def a_normalf3_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_normalf3_inf)
data_view.set(value)
@property
def a_normalf3_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalf3_nan)
return data_view.get()
@a_normalf3_nan.setter
def a_normalf3_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_normalf3_nan)
data_view.set(value)
@property
def a_normalf3_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalf3_ninf)
return data_view.get()
@a_normalf3_ninf.setter
def a_normalf3_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_normalf3_ninf)
data_view.set(value)
@property
def a_normalf3_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalf3_snan)
return data_view.get()
@a_normalf3_snan.setter
def a_normalf3_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_normalf3_snan)
data_view.set(value)
@property
def a_normalh3_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalh3_array_inf)
return data_view.get(reserved_element_count=self.a_normalh3_array_inf_size)
@a_normalh3_array_inf.setter
def a_normalh3_array_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_normalh3_array_inf)
data_view.set(value)
self.a_normalh3_array_inf_size = data_view.get_array_size()
@property
def a_normalh3_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalh3_array_nan)
return data_view.get(reserved_element_count=self.a_normalh3_array_nan_size)
@a_normalh3_array_nan.setter
def a_normalh3_array_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_normalh3_array_nan)
data_view.set(value)
self.a_normalh3_array_nan_size = data_view.get_array_size()
@property
def a_normalh3_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalh3_array_ninf)
return data_view.get(reserved_element_count=self.a_normalh3_array_ninf_size)
@a_normalh3_array_ninf.setter
def a_normalh3_array_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_normalh3_array_ninf)
data_view.set(value)
self.a_normalh3_array_ninf_size = data_view.get_array_size()
@property
def a_normalh3_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalh3_array_snan)
return data_view.get(reserved_element_count=self.a_normalh3_array_snan_size)
@a_normalh3_array_snan.setter
def a_normalh3_array_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_normalh3_array_snan)
data_view.set(value)
self.a_normalh3_array_snan_size = data_view.get_array_size()
@property
def a_normalh3_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalh3_inf)
return data_view.get()
@a_normalh3_inf.setter
def a_normalh3_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_normalh3_inf)
data_view.set(value)
@property
def a_normalh3_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalh3_nan)
return data_view.get()
@a_normalh3_nan.setter
def a_normalh3_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_normalh3_nan)
data_view.set(value)
@property
def a_normalh3_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalh3_ninf)
return data_view.get()
@a_normalh3_ninf.setter
def a_normalh3_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_normalh3_ninf)
data_view.set(value)
@property
def a_normalh3_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_normalh3_snan)
return data_view.get()
@a_normalh3_snan.setter
def a_normalh3_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_normalh3_snan)
data_view.set(value)
@property
def a_pointd3_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointd3_array_inf)
return data_view.get(reserved_element_count=self.a_pointd3_array_inf_size)
@a_pointd3_array_inf.setter
def a_pointd3_array_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_pointd3_array_inf)
data_view.set(value)
self.a_pointd3_array_inf_size = data_view.get_array_size()
@property
def a_pointd3_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointd3_array_nan)
return data_view.get(reserved_element_count=self.a_pointd3_array_nan_size)
@a_pointd3_array_nan.setter
def a_pointd3_array_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_pointd3_array_nan)
data_view.set(value)
self.a_pointd3_array_nan_size = data_view.get_array_size()
@property
def a_pointd3_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointd3_array_ninf)
return data_view.get(reserved_element_count=self.a_pointd3_array_ninf_size)
@a_pointd3_array_ninf.setter
def a_pointd3_array_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_pointd3_array_ninf)
data_view.set(value)
self.a_pointd3_array_ninf_size = data_view.get_array_size()
@property
def a_pointd3_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointd3_array_snan)
return data_view.get(reserved_element_count=self.a_pointd3_array_snan_size)
@a_pointd3_array_snan.setter
def a_pointd3_array_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_pointd3_array_snan)
data_view.set(value)
self.a_pointd3_array_snan_size = data_view.get_array_size()
@property
def a_pointd3_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointd3_inf)
return data_view.get()
@a_pointd3_inf.setter
def a_pointd3_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_pointd3_inf)
data_view.set(value)
@property
def a_pointd3_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointd3_nan)
return data_view.get()
@a_pointd3_nan.setter
def a_pointd3_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_pointd3_nan)
data_view.set(value)
@property
def a_pointd3_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointd3_ninf)
return data_view.get()
@a_pointd3_ninf.setter
def a_pointd3_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_pointd3_ninf)
data_view.set(value)
@property
def a_pointd3_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointd3_snan)
return data_view.get()
@a_pointd3_snan.setter
def a_pointd3_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_pointd3_snan)
data_view.set(value)
@property
def a_pointf3_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointf3_array_inf)
return data_view.get(reserved_element_count=self.a_pointf3_array_inf_size)
@a_pointf3_array_inf.setter
def a_pointf3_array_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_pointf3_array_inf)
data_view.set(value)
self.a_pointf3_array_inf_size = data_view.get_array_size()
@property
def a_pointf3_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointf3_array_nan)
return data_view.get(reserved_element_count=self.a_pointf3_array_nan_size)
@a_pointf3_array_nan.setter
def a_pointf3_array_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_pointf3_array_nan)
data_view.set(value)
self.a_pointf3_array_nan_size = data_view.get_array_size()
@property
def a_pointf3_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointf3_array_ninf)
return data_view.get(reserved_element_count=self.a_pointf3_array_ninf_size)
@a_pointf3_array_ninf.setter
def a_pointf3_array_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_pointf3_array_ninf)
data_view.set(value)
self.a_pointf3_array_ninf_size = data_view.get_array_size()
@property
def a_pointf3_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointf3_array_snan)
return data_view.get(reserved_element_count=self.a_pointf3_array_snan_size)
@a_pointf3_array_snan.setter
def a_pointf3_array_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_pointf3_array_snan)
data_view.set(value)
self.a_pointf3_array_snan_size = data_view.get_array_size()
@property
def a_pointf3_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointf3_inf)
return data_view.get()
@a_pointf3_inf.setter
def a_pointf3_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_pointf3_inf)
data_view.set(value)
@property
def a_pointf3_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointf3_nan)
return data_view.get()
@a_pointf3_nan.setter
def a_pointf3_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_pointf3_nan)
data_view.set(value)
@property
def a_pointf3_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointf3_ninf)
return data_view.get()
@a_pointf3_ninf.setter
def a_pointf3_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_pointf3_ninf)
data_view.set(value)
@property
def a_pointf3_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointf3_snan)
return data_view.get()
@a_pointf3_snan.setter
def a_pointf3_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_pointf3_snan)
data_view.set(value)
@property
def a_pointh3_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointh3_array_inf)
return data_view.get(reserved_element_count=self.a_pointh3_array_inf_size)
@a_pointh3_array_inf.setter
def a_pointh3_array_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_pointh3_array_inf)
data_view.set(value)
self.a_pointh3_array_inf_size = data_view.get_array_size()
@property
def a_pointh3_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointh3_array_nan)
return data_view.get(reserved_element_count=self.a_pointh3_array_nan_size)
@a_pointh3_array_nan.setter
def a_pointh3_array_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_pointh3_array_nan)
data_view.set(value)
self.a_pointh3_array_nan_size = data_view.get_array_size()
@property
def a_pointh3_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointh3_array_ninf)
return data_view.get(reserved_element_count=self.a_pointh3_array_ninf_size)
@a_pointh3_array_ninf.setter
def a_pointh3_array_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_pointh3_array_ninf)
data_view.set(value)
self.a_pointh3_array_ninf_size = data_view.get_array_size()
@property
def a_pointh3_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointh3_array_snan)
return data_view.get(reserved_element_count=self.a_pointh3_array_snan_size)
@a_pointh3_array_snan.setter
def a_pointh3_array_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_pointh3_array_snan)
data_view.set(value)
self.a_pointh3_array_snan_size = data_view.get_array_size()
@property
def a_pointh3_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointh3_inf)
return data_view.get()
@a_pointh3_inf.setter
def a_pointh3_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_pointh3_inf)
data_view.set(value)
@property
def a_pointh3_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointh3_nan)
return data_view.get()
@a_pointh3_nan.setter
def a_pointh3_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_pointh3_nan)
data_view.set(value)
@property
def a_pointh3_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointh3_ninf)
return data_view.get()
@a_pointh3_ninf.setter
def a_pointh3_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_pointh3_ninf)
data_view.set(value)
@property
def a_pointh3_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_pointh3_snan)
return data_view.get()
@a_pointh3_snan.setter
def a_pointh3_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_pointh3_snan)
data_view.set(value)
@property
def a_quatd4_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatd4_array_inf)
return data_view.get(reserved_element_count=self.a_quatd4_array_inf_size)
@a_quatd4_array_inf.setter
def a_quatd4_array_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_quatd4_array_inf)
data_view.set(value)
self.a_quatd4_array_inf_size = data_view.get_array_size()
@property
def a_quatd4_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatd4_array_nan)
return data_view.get(reserved_element_count=self.a_quatd4_array_nan_size)
@a_quatd4_array_nan.setter
def a_quatd4_array_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_quatd4_array_nan)
data_view.set(value)
self.a_quatd4_array_nan_size = data_view.get_array_size()
@property
def a_quatd4_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatd4_array_ninf)
return data_view.get(reserved_element_count=self.a_quatd4_array_ninf_size)
@a_quatd4_array_ninf.setter
def a_quatd4_array_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_quatd4_array_ninf)
data_view.set(value)
self.a_quatd4_array_ninf_size = data_view.get_array_size()
@property
def a_quatd4_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatd4_array_snan)
return data_view.get(reserved_element_count=self.a_quatd4_array_snan_size)
@a_quatd4_array_snan.setter
def a_quatd4_array_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_quatd4_array_snan)
data_view.set(value)
self.a_quatd4_array_snan_size = data_view.get_array_size()
@property
def a_quatd4_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatd4_inf)
return data_view.get()
@a_quatd4_inf.setter
def a_quatd4_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_quatd4_inf)
data_view.set(value)
@property
def a_quatd4_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatd4_nan)
return data_view.get()
@a_quatd4_nan.setter
def a_quatd4_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_quatd4_nan)
data_view.set(value)
@property
def a_quatd4_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatd4_ninf)
return data_view.get()
@a_quatd4_ninf.setter
def a_quatd4_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_quatd4_ninf)
data_view.set(value)
@property
def a_quatd4_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatd4_snan)
return data_view.get()
@a_quatd4_snan.setter
def a_quatd4_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_quatd4_snan)
data_view.set(value)
@property
def a_quatf4_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatf4_array_inf)
return data_view.get(reserved_element_count=self.a_quatf4_array_inf_size)
@a_quatf4_array_inf.setter
def a_quatf4_array_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_quatf4_array_inf)
data_view.set(value)
self.a_quatf4_array_inf_size = data_view.get_array_size()
@property
def a_quatf4_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatf4_array_nan)
return data_view.get(reserved_element_count=self.a_quatf4_array_nan_size)
@a_quatf4_array_nan.setter
def a_quatf4_array_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_quatf4_array_nan)
data_view.set(value)
self.a_quatf4_array_nan_size = data_view.get_array_size()
@property
def a_quatf4_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatf4_array_ninf)
return data_view.get(reserved_element_count=self.a_quatf4_array_ninf_size)
@a_quatf4_array_ninf.setter
def a_quatf4_array_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_quatf4_array_ninf)
data_view.set(value)
self.a_quatf4_array_ninf_size = data_view.get_array_size()
@property
def a_quatf4_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatf4_array_snan)
return data_view.get(reserved_element_count=self.a_quatf4_array_snan_size)
@a_quatf4_array_snan.setter
def a_quatf4_array_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_quatf4_array_snan)
data_view.set(value)
self.a_quatf4_array_snan_size = data_view.get_array_size()
@property
def a_quatf4_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatf4_inf)
return data_view.get()
@a_quatf4_inf.setter
def a_quatf4_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_quatf4_inf)
data_view.set(value)
@property
def a_quatf4_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatf4_nan)
return data_view.get()
@a_quatf4_nan.setter
def a_quatf4_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_quatf4_nan)
data_view.set(value)
@property
def a_quatf4_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatf4_ninf)
return data_view.get()
@a_quatf4_ninf.setter
def a_quatf4_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_quatf4_ninf)
data_view.set(value)
@property
def a_quatf4_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_quatf4_snan)
return data_view.get()
@a_quatf4_snan.setter
def a_quatf4_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_quatf4_snan)
data_view.set(value)
@property
def a_quath4_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_quath4_array_inf)
return data_view.get(reserved_element_count=self.a_quath4_array_inf_size)
@a_quath4_array_inf.setter
def a_quath4_array_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_quath4_array_inf)
data_view.set(value)
self.a_quath4_array_inf_size = data_view.get_array_size()
@property
def a_quath4_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_quath4_array_nan)
return data_view.get(reserved_element_count=self.a_quath4_array_nan_size)
@a_quath4_array_nan.setter
def a_quath4_array_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_quath4_array_nan)
data_view.set(value)
self.a_quath4_array_nan_size = data_view.get_array_size()
@property
def a_quath4_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_quath4_array_ninf)
return data_view.get(reserved_element_count=self.a_quath4_array_ninf_size)
@a_quath4_array_ninf.setter
def a_quath4_array_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_quath4_array_ninf)
data_view.set(value)
self.a_quath4_array_ninf_size = data_view.get_array_size()
@property
def a_quath4_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_quath4_array_snan)
return data_view.get(reserved_element_count=self.a_quath4_array_snan_size)
@a_quath4_array_snan.setter
def a_quath4_array_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_quath4_array_snan)
data_view.set(value)
self.a_quath4_array_snan_size = data_view.get_array_size()
@property
def a_quath4_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_quath4_inf)
return data_view.get()
@a_quath4_inf.setter
def a_quath4_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_quath4_inf)
data_view.set(value)
@property
def a_quath4_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_quath4_nan)
return data_view.get()
@a_quath4_nan.setter
def a_quath4_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_quath4_nan)
data_view.set(value)
@property
def a_quath4_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_quath4_ninf)
return data_view.get()
@a_quath4_ninf.setter
def a_quath4_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_quath4_ninf)
data_view.set(value)
@property
def a_quath4_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_quath4_snan)
return data_view.get()
@a_quath4_snan.setter
def a_quath4_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_quath4_snan)
data_view.set(value)
@property
def a_texcoordd2_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd2_array_inf)
return data_view.get(reserved_element_count=self.a_texcoordd2_array_inf_size)
@a_texcoordd2_array_inf.setter
def a_texcoordd2_array_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd2_array_inf)
data_view.set(value)
self.a_texcoordd2_array_inf_size = data_view.get_array_size()
@property
def a_texcoordd2_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd2_array_nan)
return data_view.get(reserved_element_count=self.a_texcoordd2_array_nan_size)
@a_texcoordd2_array_nan.setter
def a_texcoordd2_array_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd2_array_nan)
data_view.set(value)
self.a_texcoordd2_array_nan_size = data_view.get_array_size()
@property
def a_texcoordd2_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd2_array_ninf)
return data_view.get(reserved_element_count=self.a_texcoordd2_array_ninf_size)
@a_texcoordd2_array_ninf.setter
def a_texcoordd2_array_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd2_array_ninf)
data_view.set(value)
self.a_texcoordd2_array_ninf_size = data_view.get_array_size()
@property
def a_texcoordd2_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd2_array_snan)
return data_view.get(reserved_element_count=self.a_texcoordd2_array_snan_size)
@a_texcoordd2_array_snan.setter
def a_texcoordd2_array_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd2_array_snan)
data_view.set(value)
self.a_texcoordd2_array_snan_size = data_view.get_array_size()
@property
def a_texcoordd2_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd2_inf)
return data_view.get()
@a_texcoordd2_inf.setter
def a_texcoordd2_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd2_inf)
data_view.set(value)
@property
def a_texcoordd2_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd2_nan)
return data_view.get()
@a_texcoordd2_nan.setter
def a_texcoordd2_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd2_nan)
data_view.set(value)
@property
def a_texcoordd2_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd2_ninf)
return data_view.get()
@a_texcoordd2_ninf.setter
def a_texcoordd2_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd2_ninf)
data_view.set(value)
@property
def a_texcoordd2_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd2_snan)
return data_view.get()
@a_texcoordd2_snan.setter
def a_texcoordd2_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd2_snan)
data_view.set(value)
@property
def a_texcoordd3_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd3_array_inf)
return data_view.get(reserved_element_count=self.a_texcoordd3_array_inf_size)
@a_texcoordd3_array_inf.setter
def a_texcoordd3_array_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd3_array_inf)
data_view.set(value)
self.a_texcoordd3_array_inf_size = data_view.get_array_size()
@property
def a_texcoordd3_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd3_array_nan)
return data_view.get(reserved_element_count=self.a_texcoordd3_array_nan_size)
@a_texcoordd3_array_nan.setter
def a_texcoordd3_array_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd3_array_nan)
data_view.set(value)
self.a_texcoordd3_array_nan_size = data_view.get_array_size()
@property
def a_texcoordd3_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd3_array_ninf)
return data_view.get(reserved_element_count=self.a_texcoordd3_array_ninf_size)
@a_texcoordd3_array_ninf.setter
def a_texcoordd3_array_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd3_array_ninf)
data_view.set(value)
self.a_texcoordd3_array_ninf_size = data_view.get_array_size()
@property
def a_texcoordd3_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd3_array_snan)
return data_view.get(reserved_element_count=self.a_texcoordd3_array_snan_size)
@a_texcoordd3_array_snan.setter
def a_texcoordd3_array_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd3_array_snan)
data_view.set(value)
self.a_texcoordd3_array_snan_size = data_view.get_array_size()
@property
def a_texcoordd3_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd3_inf)
return data_view.get()
@a_texcoordd3_inf.setter
def a_texcoordd3_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd3_inf)
data_view.set(value)
@property
def a_texcoordd3_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd3_nan)
return data_view.get()
@a_texcoordd3_nan.setter
def a_texcoordd3_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd3_nan)
data_view.set(value)
@property
def a_texcoordd3_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd3_ninf)
return data_view.get()
@a_texcoordd3_ninf.setter
def a_texcoordd3_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd3_ninf)
data_view.set(value)
@property
def a_texcoordd3_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd3_snan)
return data_view.get()
@a_texcoordd3_snan.setter
def a_texcoordd3_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordd3_snan)
data_view.set(value)
@property
def a_texcoordf2_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf2_array_inf)
return data_view.get(reserved_element_count=self.a_texcoordf2_array_inf_size)
@a_texcoordf2_array_inf.setter
def a_texcoordf2_array_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf2_array_inf)
data_view.set(value)
self.a_texcoordf2_array_inf_size = data_view.get_array_size()
@property
def a_texcoordf2_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf2_array_nan)
return data_view.get(reserved_element_count=self.a_texcoordf2_array_nan_size)
@a_texcoordf2_array_nan.setter
def a_texcoordf2_array_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf2_array_nan)
data_view.set(value)
self.a_texcoordf2_array_nan_size = data_view.get_array_size()
@property
def a_texcoordf2_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf2_array_ninf)
return data_view.get(reserved_element_count=self.a_texcoordf2_array_ninf_size)
@a_texcoordf2_array_ninf.setter
def a_texcoordf2_array_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf2_array_ninf)
data_view.set(value)
self.a_texcoordf2_array_ninf_size = data_view.get_array_size()
@property
def a_texcoordf2_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf2_array_snan)
return data_view.get(reserved_element_count=self.a_texcoordf2_array_snan_size)
@a_texcoordf2_array_snan.setter
def a_texcoordf2_array_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf2_array_snan)
data_view.set(value)
self.a_texcoordf2_array_snan_size = data_view.get_array_size()
@property
def a_texcoordf2_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf2_inf)
return data_view.get()
@a_texcoordf2_inf.setter
def a_texcoordf2_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf2_inf)
data_view.set(value)
@property
def a_texcoordf2_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf2_nan)
return data_view.get()
@a_texcoordf2_nan.setter
def a_texcoordf2_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf2_nan)
data_view.set(value)
@property
def a_texcoordf2_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf2_ninf)
return data_view.get()
@a_texcoordf2_ninf.setter
def a_texcoordf2_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf2_ninf)
data_view.set(value)
@property
def a_texcoordf2_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf2_snan)
return data_view.get()
@a_texcoordf2_snan.setter
def a_texcoordf2_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf2_snan)
data_view.set(value)
@property
def a_texcoordf3_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf3_array_inf)
return data_view.get(reserved_element_count=self.a_texcoordf3_array_inf_size)
@a_texcoordf3_array_inf.setter
def a_texcoordf3_array_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf3_array_inf)
data_view.set(value)
self.a_texcoordf3_array_inf_size = data_view.get_array_size()
@property
def a_texcoordf3_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf3_array_nan)
return data_view.get(reserved_element_count=self.a_texcoordf3_array_nan_size)
@a_texcoordf3_array_nan.setter
def a_texcoordf3_array_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf3_array_nan)
data_view.set(value)
self.a_texcoordf3_array_nan_size = data_view.get_array_size()
@property
def a_texcoordf3_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf3_array_ninf)
return data_view.get(reserved_element_count=self.a_texcoordf3_array_ninf_size)
@a_texcoordf3_array_ninf.setter
def a_texcoordf3_array_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf3_array_ninf)
data_view.set(value)
self.a_texcoordf3_array_ninf_size = data_view.get_array_size()
@property
def a_texcoordf3_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf3_array_snan)
return data_view.get(reserved_element_count=self.a_texcoordf3_array_snan_size)
@a_texcoordf3_array_snan.setter
def a_texcoordf3_array_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf3_array_snan)
data_view.set(value)
self.a_texcoordf3_array_snan_size = data_view.get_array_size()
@property
def a_texcoordf3_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf3_inf)
return data_view.get()
@a_texcoordf3_inf.setter
def a_texcoordf3_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf3_inf)
data_view.set(value)
@property
def a_texcoordf3_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf3_nan)
return data_view.get()
@a_texcoordf3_nan.setter
def a_texcoordf3_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf3_nan)
data_view.set(value)
@property
def a_texcoordf3_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf3_ninf)
return data_view.get()
@a_texcoordf3_ninf.setter
def a_texcoordf3_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf3_ninf)
data_view.set(value)
@property
def a_texcoordf3_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf3_snan)
return data_view.get()
@a_texcoordf3_snan.setter
def a_texcoordf3_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordf3_snan)
data_view.set(value)
@property
def a_texcoordh2_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh2_array_inf)
return data_view.get(reserved_element_count=self.a_texcoordh2_array_inf_size)
@a_texcoordh2_array_inf.setter
def a_texcoordh2_array_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh2_array_inf)
data_view.set(value)
self.a_texcoordh2_array_inf_size = data_view.get_array_size()
@property
def a_texcoordh2_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh2_array_nan)
return data_view.get(reserved_element_count=self.a_texcoordh2_array_nan_size)
@a_texcoordh2_array_nan.setter
def a_texcoordh2_array_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh2_array_nan)
data_view.set(value)
self.a_texcoordh2_array_nan_size = data_view.get_array_size()
@property
def a_texcoordh2_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh2_array_ninf)
return data_view.get(reserved_element_count=self.a_texcoordh2_array_ninf_size)
@a_texcoordh2_array_ninf.setter
def a_texcoordh2_array_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh2_array_ninf)
data_view.set(value)
self.a_texcoordh2_array_ninf_size = data_view.get_array_size()
@property
def a_texcoordh2_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh2_array_snan)
return data_view.get(reserved_element_count=self.a_texcoordh2_array_snan_size)
@a_texcoordh2_array_snan.setter
def a_texcoordh2_array_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh2_array_snan)
data_view.set(value)
self.a_texcoordh2_array_snan_size = data_view.get_array_size()
@property
def a_texcoordh2_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh2_inf)
return data_view.get()
@a_texcoordh2_inf.setter
def a_texcoordh2_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh2_inf)
data_view.set(value)
@property
def a_texcoordh2_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh2_nan)
return data_view.get()
@a_texcoordh2_nan.setter
def a_texcoordh2_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh2_nan)
data_view.set(value)
@property
def a_texcoordh2_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh2_ninf)
return data_view.get()
@a_texcoordh2_ninf.setter
def a_texcoordh2_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh2_ninf)
data_view.set(value)
@property
def a_texcoordh2_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh2_snan)
return data_view.get()
@a_texcoordh2_snan.setter
def a_texcoordh2_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh2_snan)
data_view.set(value)
@property
def a_texcoordh3_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh3_array_inf)
return data_view.get(reserved_element_count=self.a_texcoordh3_array_inf_size)
@a_texcoordh3_array_inf.setter
def a_texcoordh3_array_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh3_array_inf)
data_view.set(value)
self.a_texcoordh3_array_inf_size = data_view.get_array_size()
@property
def a_texcoordh3_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh3_array_nan)
return data_view.get(reserved_element_count=self.a_texcoordh3_array_nan_size)
@a_texcoordh3_array_nan.setter
def a_texcoordh3_array_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh3_array_nan)
data_view.set(value)
self.a_texcoordh3_array_nan_size = data_view.get_array_size()
@property
def a_texcoordh3_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh3_array_ninf)
return data_view.get(reserved_element_count=self.a_texcoordh3_array_ninf_size)
@a_texcoordh3_array_ninf.setter
def a_texcoordh3_array_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh3_array_ninf)
data_view.set(value)
self.a_texcoordh3_array_ninf_size = data_view.get_array_size()
@property
def a_texcoordh3_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh3_array_snan)
return data_view.get(reserved_element_count=self.a_texcoordh3_array_snan_size)
@a_texcoordh3_array_snan.setter
def a_texcoordh3_array_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh3_array_snan)
data_view.set(value)
self.a_texcoordh3_array_snan_size = data_view.get_array_size()
@property
def a_texcoordh3_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh3_inf)
return data_view.get()
@a_texcoordh3_inf.setter
def a_texcoordh3_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh3_inf)
data_view.set(value)
@property
def a_texcoordh3_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh3_nan)
return data_view.get()
@a_texcoordh3_nan.setter
def a_texcoordh3_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh3_nan)
data_view.set(value)
@property
def a_texcoordh3_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh3_ninf)
return data_view.get()
@a_texcoordh3_ninf.setter
def a_texcoordh3_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh3_ninf)
data_view.set(value)
@property
def a_texcoordh3_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh3_snan)
return data_view.get()
@a_texcoordh3_snan.setter
def a_texcoordh3_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_texcoordh3_snan)
data_view.set(value)
@property
def a_timecode_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_timecode_array_inf)
return data_view.get(reserved_element_count=self.a_timecode_array_inf_size)
@a_timecode_array_inf.setter
def a_timecode_array_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_timecode_array_inf)
data_view.set(value)
self.a_timecode_array_inf_size = data_view.get_array_size()
@property
def a_timecode_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_timecode_array_nan)
return data_view.get(reserved_element_count=self.a_timecode_array_nan_size)
@a_timecode_array_nan.setter
def a_timecode_array_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_timecode_array_nan)
data_view.set(value)
self.a_timecode_array_nan_size = data_view.get_array_size()
@property
def a_timecode_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_timecode_array_ninf)
return data_view.get(reserved_element_count=self.a_timecode_array_ninf_size)
@a_timecode_array_ninf.setter
def a_timecode_array_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_timecode_array_ninf)
data_view.set(value)
self.a_timecode_array_ninf_size = data_view.get_array_size()
@property
def a_timecode_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_timecode_array_snan)
return data_view.get(reserved_element_count=self.a_timecode_array_snan_size)
@a_timecode_array_snan.setter
def a_timecode_array_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_timecode_array_snan)
data_view.set(value)
self.a_timecode_array_snan_size = data_view.get_array_size()
@property
def a_timecode_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_timecode_inf)
return data_view.get()
@a_timecode_inf.setter
def a_timecode_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_timecode_inf)
data_view.set(value)
@property
def a_timecode_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_timecode_nan)
return data_view.get()
@a_timecode_nan.setter
def a_timecode_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_timecode_nan)
data_view.set(value)
@property
def a_timecode_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_timecode_ninf)
return data_view.get()
@a_timecode_ninf.setter
def a_timecode_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_timecode_ninf)
data_view.set(value)
@property
def a_timecode_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_timecode_snan)
return data_view.get()
@a_timecode_snan.setter
def a_timecode_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_timecode_snan)
data_view.set(value)
@property
def a_vectord3_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectord3_array_inf)
return data_view.get(reserved_element_count=self.a_vectord3_array_inf_size)
@a_vectord3_array_inf.setter
def a_vectord3_array_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_vectord3_array_inf)
data_view.set(value)
self.a_vectord3_array_inf_size = data_view.get_array_size()
@property
def a_vectord3_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectord3_array_nan)
return data_view.get(reserved_element_count=self.a_vectord3_array_nan_size)
@a_vectord3_array_nan.setter
def a_vectord3_array_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_vectord3_array_nan)
data_view.set(value)
self.a_vectord3_array_nan_size = data_view.get_array_size()
@property
def a_vectord3_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectord3_array_ninf)
return data_view.get(reserved_element_count=self.a_vectord3_array_ninf_size)
@a_vectord3_array_ninf.setter
def a_vectord3_array_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_vectord3_array_ninf)
data_view.set(value)
self.a_vectord3_array_ninf_size = data_view.get_array_size()
@property
def a_vectord3_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectord3_array_snan)
return data_view.get(reserved_element_count=self.a_vectord3_array_snan_size)
@a_vectord3_array_snan.setter
def a_vectord3_array_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_vectord3_array_snan)
data_view.set(value)
self.a_vectord3_array_snan_size = data_view.get_array_size()
@property
def a_vectord3_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectord3_inf)
return data_view.get()
@a_vectord3_inf.setter
def a_vectord3_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_vectord3_inf)
data_view.set(value)
@property
def a_vectord3_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectord3_nan)
return data_view.get()
@a_vectord3_nan.setter
def a_vectord3_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_vectord3_nan)
data_view.set(value)
@property
def a_vectord3_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectord3_ninf)
return data_view.get()
@a_vectord3_ninf.setter
def a_vectord3_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_vectord3_ninf)
data_view.set(value)
@property
def a_vectord3_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectord3_snan)
return data_view.get()
@a_vectord3_snan.setter
def a_vectord3_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_vectord3_snan)
data_view.set(value)
@property
def a_vectorf3_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorf3_array_inf)
return data_view.get(reserved_element_count=self.a_vectorf3_array_inf_size)
@a_vectorf3_array_inf.setter
def a_vectorf3_array_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_vectorf3_array_inf)
data_view.set(value)
self.a_vectorf3_array_inf_size = data_view.get_array_size()
@property
def a_vectorf3_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorf3_array_nan)
return data_view.get(reserved_element_count=self.a_vectorf3_array_nan_size)
@a_vectorf3_array_nan.setter
def a_vectorf3_array_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_vectorf3_array_nan)
data_view.set(value)
self.a_vectorf3_array_nan_size = data_view.get_array_size()
@property
def a_vectorf3_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorf3_array_ninf)
return data_view.get(reserved_element_count=self.a_vectorf3_array_ninf_size)
@a_vectorf3_array_ninf.setter
def a_vectorf3_array_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_vectorf3_array_ninf)
data_view.set(value)
self.a_vectorf3_array_ninf_size = data_view.get_array_size()
@property
def a_vectorf3_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorf3_array_snan)
return data_view.get(reserved_element_count=self.a_vectorf3_array_snan_size)
@a_vectorf3_array_snan.setter
def a_vectorf3_array_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_vectorf3_array_snan)
data_view.set(value)
self.a_vectorf3_array_snan_size = data_view.get_array_size()
@property
def a_vectorf3_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorf3_inf)
return data_view.get()
@a_vectorf3_inf.setter
def a_vectorf3_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_vectorf3_inf)
data_view.set(value)
@property
def a_vectorf3_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorf3_nan)
return data_view.get()
@a_vectorf3_nan.setter
def a_vectorf3_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_vectorf3_nan)
data_view.set(value)
@property
def a_vectorf3_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorf3_ninf)
return data_view.get()
@a_vectorf3_ninf.setter
def a_vectorf3_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_vectorf3_ninf)
data_view.set(value)
@property
def a_vectorf3_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorf3_snan)
return data_view.get()
@a_vectorf3_snan.setter
def a_vectorf3_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_vectorf3_snan)
data_view.set(value)
@property
def a_vectorh3_array_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorh3_array_inf)
return data_view.get(reserved_element_count=self.a_vectorh3_array_inf_size)
@a_vectorh3_array_inf.setter
def a_vectorh3_array_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_vectorh3_array_inf)
data_view.set(value)
self.a_vectorh3_array_inf_size = data_view.get_array_size()
@property
def a_vectorh3_array_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorh3_array_nan)
return data_view.get(reserved_element_count=self.a_vectorh3_array_nan_size)
@a_vectorh3_array_nan.setter
def a_vectorh3_array_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_vectorh3_array_nan)
data_view.set(value)
self.a_vectorh3_array_nan_size = data_view.get_array_size()
@property
def a_vectorh3_array_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorh3_array_ninf)
return data_view.get(reserved_element_count=self.a_vectorh3_array_ninf_size)
@a_vectorh3_array_ninf.setter
def a_vectorh3_array_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_vectorh3_array_ninf)
data_view.set(value)
self.a_vectorh3_array_ninf_size = data_view.get_array_size()
@property
def a_vectorh3_array_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorh3_array_snan)
return data_view.get(reserved_element_count=self.a_vectorh3_array_snan_size)
@a_vectorh3_array_snan.setter
def a_vectorh3_array_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_vectorh3_array_snan)
data_view.set(value)
self.a_vectorh3_array_snan_size = data_view.get_array_size()
@property
def a_vectorh3_inf(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorh3_inf)
return data_view.get()
@a_vectorh3_inf.setter
def a_vectorh3_inf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_vectorh3_inf)
data_view.set(value)
@property
def a_vectorh3_nan(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorh3_nan)
return data_view.get()
@a_vectorh3_nan.setter
def a_vectorh3_nan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_vectorh3_nan)
data_view.set(value)
@property
def a_vectorh3_ninf(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorh3_ninf)
return data_view.get()
@a_vectorh3_ninf.setter
def a_vectorh3_ninf(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_vectorh3_ninf)
data_view.set(value)
@property
def a_vectorh3_snan(self):
data_view = og.AttributeValueHelper(self._attributes.a_vectorh3_snan)
return data_view.get()
@a_vectorh3_snan.setter
def a_vectorh3_snan(self, value):
data_view = og.AttributeValueHelper(self._attributes.a_vectorh3_snan)
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 = OgnTestNanInfDatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
self.outputs = OgnTestNanInfDatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
self.state = OgnTestNanInfDatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
| 500,510 |
Python
| 51.272689 | 919 | 0.605872 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/OgnRandomBundlePointsDatabase.py
|
"""Support for simplified access to data on nodes of type omni.graph.test.RandomBundlePoints
Generate a bundle of 'bundleSize' arrays of 'pointCount' points at random locations within the bounding cube delineated by
the corner points 'minimum' and 'maximum'.
"""
import carb
import numpy
import carb
import omni.graph.core as og
import omni.graph.core._omni_graph_core as _og
import omni.graph.tools.ogn as ogn
class OgnRandomBundlePointsDatabase(og.Database):
"""Helper class providing simplified access to data on nodes of type omni.graph.test.RandomBundlePoints
Class Members:
node: Node being evaluated
Attribute Value Properties:
Inputs:
inputs.bundleSize
inputs.maximum
inputs.minimum
inputs.pointCount
Outputs:
outputs.bundle
"""
# 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:bundleSize', 'int', 0, 'Bundle Size', 'Number of point attributes to generate in the bundle', {}, True, 0, False, ''),
('inputs:maximum', 'point3f', 0, 'Bounding Cube Maximum', 'Highest X, Y, Z values for the bounding volume', {ogn.MetadataKeys.DEFAULT: '[1.0, 1.0, 1.0]'}, True, [1.0, 1.0, 1.0], False, ''),
('inputs:minimum', 'point3f', 0, 'Bounding Cube Minimum', 'Lowest X, Y, Z values for the bounding volume', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('inputs:pointCount', 'uint64', 0, 'Point Count', 'Number of points to generate', {}, True, 0, False, ''),
('outputs:bundle', 'bundle', 0, 'Random Bundle', 'Randomly generated bundle of attributes containing random points', {}, 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.maximum = og.AttributeRole.POSITION
role_data.inputs.minimum = og.AttributeRole.POSITION
role_data.outputs.bundle = og.AttributeRole.BUNDLE
return role_data
class ValuesForInputs(og.DynamicAttributeAccess):
LOCAL_PROPERTY_NAMES = { }
"""Helper class that creates natural hierarchical access to input attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
self._batchedReadAttributes = []
self._batchedReadValues = []
@property
def bundleSize(self):
data_view = og.AttributeValueHelper(self._attributes.bundleSize)
return data_view.get()
@bundleSize.setter
def bundleSize(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.bundleSize)
data_view = og.AttributeValueHelper(self._attributes.bundleSize)
data_view.set(value)
@property
def maximum(self):
data_view = og.AttributeValueHelper(self._attributes.maximum)
return data_view.get()
@maximum.setter
def maximum(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.maximum)
data_view = og.AttributeValueHelper(self._attributes.maximum)
data_view.set(value)
@property
def minimum(self):
data_view = og.AttributeValueHelper(self._attributes.minimum)
return data_view.get()
@minimum.setter
def minimum(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.minimum)
data_view = og.AttributeValueHelper(self._attributes.minimum)
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)
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 bundle(self) -> og.BundleContents:
"""Get the bundle wrapper class for the attribute outputs.bundle"""
return self.__bundles.bundle
@bundle.setter
def bundle(self, bundle: og.BundleContents):
"""Overwrite the bundle attribute outputs.bundle 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.bundle.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 = OgnRandomBundlePointsDatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
self.outputs = OgnRandomBundlePointsDatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
self.state = OgnRandomBundlePointsDatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
| 7,913 |
Python
| 46.389221 | 197 | 0.657652 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/OgnTestScatterDatabase.py
|
"""Support for simplified access to data on nodes of type omni.graph.test.TestScatter
Test node to test out the effects of vectorization. Scatters the results of gathered compute back to FC
"""
import carb
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 OgnTestScatterDatabase(og.Database):
"""Helper class providing simplified access to data on nodes of type omni.graph.test.TestScatter
Class Members:
node: Node being evaluated
Attribute Value Properties:
Inputs:
inputs.gathered_paths
inputs.rotations
Outputs:
outputs.gathered_paths
outputs.rotations
outputs.single_rotation
"""
# 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:gathered_paths', 'token[]', 0, None, 'The paths of the gathered objects', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:rotations', 'double3[]', 0, None, 'The rotations of the gathered points', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:gathered_paths', 'token[]', 0, None, 'The paths of the gathered objects', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:rotations', 'double3[]', 0, None, 'The rotations of the gathered points', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:single_rotation', 'double3', 0, None, 'Placeholder single rotation until we get the scatter working properly', {ogn.MetadataKeys.DEFAULT: '[0, 0, 0]'}, True, [0, 0, 0], False, ''),
])
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 gathered_paths(self):
data_view = og.AttributeValueHelper(self._attributes.gathered_paths)
return data_view.get()
@gathered_paths.setter
def gathered_paths(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.gathered_paths)
data_view = og.AttributeValueHelper(self._attributes.gathered_paths)
data_view.set(value)
self.gathered_paths_size = data_view.get_array_size()
@property
def rotations(self):
data_view = og.AttributeValueHelper(self._attributes.rotations)
return data_view.get()
@rotations.setter
def rotations(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.rotations)
data_view = og.AttributeValueHelper(self._attributes.rotations)
data_view.set(value)
self.rotations_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.gathered_paths_size = 0
self.rotations_size = 0
self._batchedWriteValues = { }
@property
def gathered_paths(self):
data_view = og.AttributeValueHelper(self._attributes.gathered_paths)
return data_view.get(reserved_element_count=self.gathered_paths_size)
@gathered_paths.setter
def gathered_paths(self, value):
data_view = og.AttributeValueHelper(self._attributes.gathered_paths)
data_view.set(value)
self.gathered_paths_size = data_view.get_array_size()
@property
def rotations(self):
data_view = og.AttributeValueHelper(self._attributes.rotations)
return data_view.get(reserved_element_count=self.rotations_size)
@rotations.setter
def rotations(self, value):
data_view = og.AttributeValueHelper(self._attributes.rotations)
data_view.set(value)
self.rotations_size = data_view.get_array_size()
@property
def single_rotation(self):
data_view = og.AttributeValueHelper(self._attributes.single_rotation)
return data_view.get()
@single_rotation.setter
def single_rotation(self, value):
data_view = og.AttributeValueHelper(self._attributes.single_rotation)
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 = OgnTestScatterDatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
self.outputs = OgnTestScatterDatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
self.state = OgnTestScatterDatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
| 7,389 |
Python
| 46.677419 | 198 | 0.658411 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/OgnTestWriteVariablePyDatabase.py
|
"""Support for simplified access to data on nodes of type omni.graph.test.TestWriteVariablePy
Node that test writes a value to a variable in python
"""
from typing import Any
import carb
import sys
import traceback
import omni.graph.core as og
import omni.graph.core._omni_graph_core as _og
import omni.graph.tools.ogn as ogn
class OgnTestWriteVariablePyDatabase(og.Database):
"""Helper class providing simplified access to data on nodes of type omni.graph.test.TestWriteVariablePy
Class Members:
node: Node being evaluated
Attribute Value Properties:
Inputs:
inputs.execIn
inputs.value
inputs.variableName
Outputs:
outputs.execOut
outputs.value
"""
# 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:execIn', 'execution', 0, None, 'Input execution state', {}, True, None, False, ''),
('inputs:value', 'any', 2, None, 'The new value to be written', {}, True, None, False, ''),
('inputs:variableName', 'token', 0, None, 'The name of the graph variable to use.', {}, True, "", False, ''),
('outputs:execOut', 'execution', 0, None, 'Output execution', {}, True, None, False, ''),
('outputs:value', 'any', 2, None, 'The newly written value', {}, 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.execIn = og.AttributeRole.EXECUTION
role_data.outputs.execOut = og.AttributeRole.EXECUTION
return role_data
class ValuesForInputs(og.DynamicAttributeAccess):
LOCAL_PROPERTY_NAMES = {"execIn", "variableName", "_setting_locked", "_batchedReadAttributes", "_batchedReadValues"}
"""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._attributes.execIn, self._attributes.variableName]
self._batchedReadValues = [None, ""]
@property
def value(self) -> og.RuntimeAttribute:
"""Get the runtime wrapper class for the attribute inputs.value"""
return og.RuntimeAttribute(self._attributes.value.get_attribute_data(), self._context, True)
@value.setter
def value(self, value_to_set: Any):
"""Assign another attribute's value to outputs.value"""
if isinstance(value_to_set, og.RuntimeAttribute):
self.value.value = value_to_set.value
else:
self.value.value = value_to_set
@property
def execIn(self):
return self._batchedReadValues[0]
@execIn.setter
def execIn(self, value):
self._batchedReadValues[0] = value
@property
def variableName(self):
return self._batchedReadValues[1]
@variableName.setter
def variableName(self, value):
self._batchedReadValues[1] = value
def __getattr__(self, item: str):
if item in self.LOCAL_PROPERTY_NAMES:
return object.__getattribute__(self, item)
else:
return super().__getattr__(item)
def __setattr__(self, item: str, new_value):
if item in self.LOCAL_PROPERTY_NAMES:
object.__setattr__(self, item, new_value)
else:
super().__setattr__(item, new_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 = {"execOut", "_batchedWriteValues"}
"""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 value(self) -> og.RuntimeAttribute:
"""Get the runtime wrapper class for the attribute outputs.value"""
return og.RuntimeAttribute(self._attributes.value.get_attribute_data(), self._context, False)
@value.setter
def value(self, value_to_set: Any):
"""Assign another attribute's value to outputs.value"""
if isinstance(value_to_set, og.RuntimeAttribute):
self.value.value = value_to_set.value
else:
self.value.value = value_to_set
@property
def execOut(self):
value = self._batchedWriteValues.get(self._attributes.execOut)
if value:
return value
else:
data_view = og.AttributeValueHelper(self._attributes.execOut)
return data_view.get()
@execOut.setter
def execOut(self, value):
self._batchedWriteValues[self._attributes.execOut] = value
def __getattr__(self, item: str):
if item in self.LOCAL_PROPERTY_NAMES:
return object.__getattribute__(self, item)
else:
return super().__getattr__(item)
def __setattr__(self, item: str, new_value):
if item in self.LOCAL_PROPERTY_NAMES:
object.__setattr__(self, item, new_value)
else:
super().__setattr__(item, new_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 = OgnTestWriteVariablePyDatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
self.outputs = OgnTestWriteVariablePyDatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
self.state = OgnTestWriteVariablePyDatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
class abi:
"""Class defining the ABI interface for the node type"""
@staticmethod
def get_node_type():
get_node_type_function = getattr(OgnTestWriteVariablePyDatabase.NODE_TYPE_CLASS, 'get_node_type', None)
if callable(get_node_type_function):
return get_node_type_function()
return 'omni.graph.test.TestWriteVariablePy'
@staticmethod
def compute(context, node):
def database_valid():
if db.inputs.value.type.base_type == og.BaseDataType.UNKNOWN:
db.log_warning('Required extended attribute inputs:value is not resolved, compute skipped')
return False
if db.outputs.value.type.base_type == og.BaseDataType.UNKNOWN:
db.log_warning('Required extended attribute outputs:value is not resolved, compute skipped')
return False
return True
try:
per_node_data = OgnTestWriteVariablePyDatabase.PER_NODE_DATA[node.node_id()]
db = per_node_data.get('_db')
if db is None:
db = OgnTestWriteVariablePyDatabase(node)
per_node_data['_db'] = db
if not database_valid():
per_node_data['_db'] = None
return False
except:
db = OgnTestWriteVariablePyDatabase(node)
try:
compute_function = getattr(OgnTestWriteVariablePyDatabase.NODE_TYPE_CLASS, 'compute', None)
if callable(compute_function) and compute_function.__code__.co_argcount > 1:
return compute_function(context, node)
db.inputs._prefetch()
db.inputs._setting_locked = True
with og.in_compute():
return OgnTestWriteVariablePyDatabase.NODE_TYPE_CLASS.compute(db)
except Exception as error:
stack_trace = "".join(traceback.format_tb(sys.exc_info()[2].tb_next))
db.log_error(f'Assertion raised in compute - {error}\n{stack_trace}', add_context=False)
finally:
db.inputs._setting_locked = False
db.outputs._commit()
return False
@staticmethod
def initialize(context, node):
OgnTestWriteVariablePyDatabase._initialize_per_node_data(node)
initialize_function = getattr(OgnTestWriteVariablePyDatabase.NODE_TYPE_CLASS, 'initialize', None)
if callable(initialize_function):
initialize_function(context, node)
per_node_data = OgnTestWriteVariablePyDatabase.PER_NODE_DATA[node.node_id()]
def on_connection_or_disconnection(*args):
per_node_data['_db'] = None
node.register_on_connected_callback(on_connection_or_disconnection)
node.register_on_disconnected_callback(on_connection_or_disconnection)
@staticmethod
def release(node):
release_function = getattr(OgnTestWriteVariablePyDatabase.NODE_TYPE_CLASS, 'release', None)
if callable(release_function):
release_function(node)
OgnTestWriteVariablePyDatabase._release_per_node_data(node)
@staticmethod
def release_instance(node, target):
OgnTestWriteVariablePyDatabase._release_per_node_instance_data(node, target)
@staticmethod
def update_node_version(context, node, old_version, new_version):
update_node_version_function = getattr(OgnTestWriteVariablePyDatabase.NODE_TYPE_CLASS, 'update_node_version', None)
if callable(update_node_version_function):
return update_node_version_function(context, node, old_version, new_version)
return False
@staticmethod
def initialize_type(node_type):
initialize_type_function = getattr(OgnTestWriteVariablePyDatabase.NODE_TYPE_CLASS, 'initialize_type', None)
needs_initializing = True
if callable(initialize_type_function):
needs_initializing = initialize_type_function(node_type)
if needs_initializing:
node_type.set_metadata(ogn.MetadataKeys.EXTENSION, "omni.graph.test")
node_type.set_metadata(ogn.MetadataKeys.UI_NAME, "Write Variable")
node_type.set_metadata(ogn.MetadataKeys.CATEGORIES, "internal:test")
node_type.set_metadata(ogn.MetadataKeys.DESCRIPTION, "Node that test writes a value to a variable in python")
node_type.set_metadata(ogn.MetadataKeys.EXCLUSIONS, "tests,usd,docs")
node_type.set_metadata(ogn.MetadataKeys.LANGUAGE, "Python")
icon_path = carb.tokens.get_tokens_interface().resolve("${omni.graph.test}")
icon_path = icon_path + '/' + "ogn/icons/omni.graph.test.TestWriteVariablePy.svg"
node_type.set_metadata(ogn.MetadataKeys.ICON_PATH, icon_path)
OgnTestWriteVariablePyDatabase.INTERFACE.add_to_node_type(node_type)
@staticmethod
def on_connection_type_resolve(node):
on_connection_type_resolve_function = getattr(OgnTestWriteVariablePyDatabase.NODE_TYPE_CLASS, 'on_connection_type_resolve', None)
if callable(on_connection_type_resolve_function):
on_connection_type_resolve_function(node)
NODE_TYPE_CLASS = None
@staticmethod
def register(node_type_class):
OgnTestWriteVariablePyDatabase.NODE_TYPE_CLASS = node_type_class
og.register_node_type(OgnTestWriteVariablePyDatabase.abi, 1)
@staticmethod
def deregister():
og.deregister_node_type("omni.graph.test.TestWriteVariablePy")
| 13,982 |
Python
| 45.61 | 141 | 0.629667 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/OgnTestTypeResolutionDatabase.py
|
"""Support for simplified access to data on nodes of type omni.graph.test.TypeResolution
Test node, explicitly constructed to make the attribute type resolution mechanism testable. It has output attributes with
union and any types whose type will be resolved at runtime when they are connected to inputs with a fixed type. The extra
string output provides the resolution information to the test script for verification
"""
from typing import Any
import carb
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 OgnTestTypeResolutionDatabase(og.Database):
"""Helper class providing simplified access to data on nodes of type omni.graph.test.TypeResolution
Class Members:
node: Node being evaluated
Attribute Value Properties:
Inputs:
inputs.anyValueIn
Outputs:
outputs.anyValue
outputs.arrayValue
outputs.mixedValue
outputs.resolvedType
outputs.tupleArrayValue
outputs.tupleValue
outputs.value
"""
# 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:anyValueIn', 'any', 2, None, 'Input that can resolve to any type. Internally the node couples \nthe types of inputs:anyValueIn -> outputs:anyValue. Meaning if one is resolved it will\nautomatically resolve the other', {}, True, None, False, ''),
('outputs:anyValue', 'any', 2, None, 'Output that can resolve to any type at all', {}, True, None, False, ''),
('outputs:arrayValue', 'double[],float[],int64[],int[],uint64[],uint[]', 1, None, 'Output that only resolves to one of the numeric array types.', {}, True, None, False, ''),
('outputs:mixedValue', 'float,float[3],float[3][],float[]', 1, None, 'Output that can resolve to data of different shapes.', {}, True, None, False, ''),
('outputs:resolvedType', 'token[]', 0, None, "Array of strings representing the output attribute's type resolutions.\nThe array items consist of comma-separated pairs of strings representing\nthe output attribute name and the type to which it is currently resolved.\ne.g. if the attribute 'foo' is an integer there would be one entry in the array\nwith the string 'foo,int'", {}, True, None, False, ''),
('outputs:tupleArrayValue', 'double[3][],float[3][],int[3][]', 1, None, 'Output that only resolves to one of the numeric tuple array types.', {}, True, None, False, ''),
('outputs:tupleValue', 'double[3],float[3],int[3]', 1, None, 'Output that only resolves to one of the numeric tuple types.', {}, True, None, False, ''),
('outputs:value', 'double,float,int,int64,uint,uint64', 1, None, 'Output that only resolves to one of the numeric types.', {}, True, None, False, ''),
])
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 anyValueIn(self) -> og.RuntimeAttribute:
"""Get the runtime wrapper class for the attribute inputs.anyValueIn"""
return og.RuntimeAttribute(self._attributes.anyValueIn.get_attribute_data(), self._context, True)
@anyValueIn.setter
def anyValueIn(self, value_to_set: Any):
"""Assign another attribute's value to outputs.anyValueIn"""
if isinstance(value_to_set, og.RuntimeAttribute):
self.anyValueIn.value = value_to_set.value
else:
self.anyValueIn.value = value_to_set
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.resolvedType_size = None
self._batchedWriteValues = { }
@property
def anyValue(self) -> og.RuntimeAttribute:
"""Get the runtime wrapper class for the attribute outputs.anyValue"""
return og.RuntimeAttribute(self._attributes.anyValue.get_attribute_data(), self._context, False)
@anyValue.setter
def anyValue(self, value_to_set: Any):
"""Assign another attribute's value to outputs.anyValue"""
if isinstance(value_to_set, og.RuntimeAttribute):
self.anyValue.value = value_to_set.value
else:
self.anyValue.value = value_to_set
@property
def arrayValue(self) -> og.RuntimeAttribute:
"""Get the runtime wrapper class for the attribute outputs.arrayValue"""
return og.RuntimeAttribute(self._attributes.arrayValue.get_attribute_data(), self._context, False)
@arrayValue.setter
def arrayValue(self, value_to_set: Any):
"""Assign another attribute's value to outputs.arrayValue"""
if isinstance(value_to_set, og.RuntimeAttribute):
self.arrayValue.value = value_to_set.value
else:
self.arrayValue.value = value_to_set
@property
def mixedValue(self) -> og.RuntimeAttribute:
"""Get the runtime wrapper class for the attribute outputs.mixedValue"""
return og.RuntimeAttribute(self._attributes.mixedValue.get_attribute_data(), self._context, False)
@mixedValue.setter
def mixedValue(self, value_to_set: Any):
"""Assign another attribute's value to outputs.mixedValue"""
if isinstance(value_to_set, og.RuntimeAttribute):
self.mixedValue.value = value_to_set.value
else:
self.mixedValue.value = value_to_set
@property
def resolvedType(self):
data_view = og.AttributeValueHelper(self._attributes.resolvedType)
return data_view.get(reserved_element_count=self.resolvedType_size)
@resolvedType.setter
def resolvedType(self, value):
data_view = og.AttributeValueHelper(self._attributes.resolvedType)
data_view.set(value)
self.resolvedType_size = data_view.get_array_size()
@property
def tupleArrayValue(self) -> og.RuntimeAttribute:
"""Get the runtime wrapper class for the attribute outputs.tupleArrayValue"""
return og.RuntimeAttribute(self._attributes.tupleArrayValue.get_attribute_data(), self._context, False)
@tupleArrayValue.setter
def tupleArrayValue(self, value_to_set: Any):
"""Assign another attribute's value to outputs.tupleArrayValue"""
if isinstance(value_to_set, og.RuntimeAttribute):
self.tupleArrayValue.value = value_to_set.value
else:
self.tupleArrayValue.value = value_to_set
@property
def tupleValue(self) -> og.RuntimeAttribute:
"""Get the runtime wrapper class for the attribute outputs.tupleValue"""
return og.RuntimeAttribute(self._attributes.tupleValue.get_attribute_data(), self._context, False)
@tupleValue.setter
def tupleValue(self, value_to_set: Any):
"""Assign another attribute's value to outputs.tupleValue"""
if isinstance(value_to_set, og.RuntimeAttribute):
self.tupleValue.value = value_to_set.value
else:
self.tupleValue.value = value_to_set
@property
def value(self) -> og.RuntimeAttribute:
"""Get the runtime wrapper class for the attribute outputs.value"""
return og.RuntimeAttribute(self._attributes.value.get_attribute_data(), self._context, False)
@value.setter
def value(self, value_to_set: Any):
"""Assign another attribute's value to outputs.value"""
if isinstance(value_to_set, og.RuntimeAttribute):
self.value.value = value_to_set.value
else:
self.value.value = value_to_set
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 = OgnTestTypeResolutionDatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
self.outputs = OgnTestTypeResolutionDatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
self.state = OgnTestTypeResolutionDatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
| 10,983 |
Python
| 52.062802 | 411 | 0.660748 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/OgnTestCppKeywordsDatabase.py
|
"""Support for simplified access to data on nodes of type omni.graph.test.TestCppKeywords
Test that attributes named for C++ keywords produce valid code
"""
import omni.graph.core as og
import omni.graph.core._omni_graph_core as _og
import omni.graph.tools.ogn as ogn
class OgnTestCppKeywordsDatabase(og.Database):
"""Helper class providing simplified access to data on nodes of type omni.graph.test.TestCppKeywords
Class Members:
node: Node being evaluated
Attribute Value Properties:
Inputs:
inputs.atomic_cancel
inputs.atomic_commit
inputs.atomic_noexcept
inputs.consteval
inputs.constinit
inputs.reflexpr
inputs.requires
Outputs:
outputs.verify
"""
# 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:atomic_cancel', 'float', 0, None, 'KW Test for atomic_cancel', {}, True, 0.0, False, ''),
('inputs:atomic_commit', 'float', 0, None, 'KW Test for atomic_commit', {}, True, 0.0, False, ''),
('inputs:atomic_noexcept', 'float', 0, None, 'KW Test for atomic_noexcept', {}, True, 0.0, False, ''),
('inputs:consteval', 'float', 0, None, 'KW Test for consteval', {}, True, 0.0, False, ''),
('inputs:constinit', 'float', 0, None, 'KW Test for constinit', {}, True, 0.0, False, ''),
('inputs:reflexpr', 'float', 0, None, 'KW Test for reflexpr', {}, True, 0.0, False, ''),
('inputs:requires', 'float', 0, None, 'KW Test for requires', {}, True, 0.0, False, ''),
('outputs:verify', 'bool', 0, None, 'Flag to indicate that a node was created and executed', {}, True, None, False, ''),
])
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 atomic_cancel(self):
data_view = og.AttributeValueHelper(self._attributes.atomic_cancel)
return data_view.get()
@atomic_cancel.setter
def atomic_cancel(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.atomic_cancel)
data_view = og.AttributeValueHelper(self._attributes.atomic_cancel)
data_view.set(value)
@property
def atomic_commit(self):
data_view = og.AttributeValueHelper(self._attributes.atomic_commit)
return data_view.get()
@atomic_commit.setter
def atomic_commit(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.atomic_commit)
data_view = og.AttributeValueHelper(self._attributes.atomic_commit)
data_view.set(value)
@property
def atomic_noexcept(self):
data_view = og.AttributeValueHelper(self._attributes.atomic_noexcept)
return data_view.get()
@atomic_noexcept.setter
def atomic_noexcept(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.atomic_noexcept)
data_view = og.AttributeValueHelper(self._attributes.atomic_noexcept)
data_view.set(value)
@property
def consteval(self):
data_view = og.AttributeValueHelper(self._attributes.consteval)
return data_view.get()
@consteval.setter
def consteval(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.consteval)
data_view = og.AttributeValueHelper(self._attributes.consteval)
data_view.set(value)
@property
def constinit(self):
data_view = og.AttributeValueHelper(self._attributes.constinit)
return data_view.get()
@constinit.setter
def constinit(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.constinit)
data_view = og.AttributeValueHelper(self._attributes.constinit)
data_view.set(value)
@property
def reflexpr(self):
data_view = og.AttributeValueHelper(self._attributes.reflexpr)
return data_view.get()
@reflexpr.setter
def reflexpr(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.reflexpr)
data_view = og.AttributeValueHelper(self._attributes.reflexpr)
data_view.set(value)
@property
def requires(self):
data_view = og.AttributeValueHelper(self._attributes.requires)
return data_view.get()
@requires.setter
def requires(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.requires)
data_view = og.AttributeValueHelper(self._attributes.requires)
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 verify(self):
data_view = og.AttributeValueHelper(self._attributes.verify)
return data_view.get()
@verify.setter
def verify(self, value):
data_view = og.AttributeValueHelper(self._attributes.verify)
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 = OgnTestCppKeywordsDatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
self.outputs = OgnTestCppKeywordsDatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
self.state = OgnTestCppKeywordsDatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
| 8,546 |
Python
| 43.284974 | 128 | 0.639129 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/OgnTestAddAnyTypeAnyMemoryDatabase.py
|
"""Support for simplified access to data on nodes of type omni.graph.test.TestAddAnyTypeAnyMemory
Test node that sum 2 runtime attributes that live either on the cpu or the gpu
"""
from typing import Any
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 OgnTestAddAnyTypeAnyMemoryDatabase(og.Database):
"""Helper class providing simplified access to data on nodes of type omni.graph.test.TestAddAnyTypeAnyMemory
Class Members:
node: Node being evaluated
Attribute Value Properties:
Inputs:
inputs.scalar
inputs.vec
Outputs:
outputs.outCpu
outputs.outGpu
"""
# 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:scalar', 'double,float', 1, None, 'A scalar to add to each vector component', {ogn.MetadataKeys.MEMORY_TYPE: 'any'}, True, None, False, ''),
('inputs:vec', 'double[3],float[3]', 1, None, 'vector[3] Input ', {ogn.MetadataKeys.MEMORY_TYPE: 'any'}, True, None, False, ''),
('outputs:outCpu', 'double[3],float[3]', 1, None, 'The result of the scalar added to each component of the vector on the CPU', {ogn.MetadataKeys.MEMORY_TYPE: 'cpu'}, True, None, False, ''),
('outputs:outGpu', 'double[3],float[3]', 1, None, 'The result of the scalar added to each component of the vector on the GPU', {ogn.MetadataKeys.MEMORY_TYPE: 'cuda'}, True, None, False, ''),
])
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 scalar(self) -> og.RuntimeAttribute:
"""Get the runtime wrapper class for the attribute inputs.scalar"""
return og.RuntimeAttribute(self._attributes.scalar.get_attribute_data(), self._context, True)
@scalar.setter
def scalar(self, value_to_set: Any):
"""Assign another attribute's value to outputs.scalar"""
if isinstance(value_to_set, og.RuntimeAttribute):
self.scalar.value = value_to_set.value
else:
self.scalar.value = value_to_set
@property
def vec(self) -> og.RuntimeAttribute:
"""Get the runtime wrapper class for the attribute inputs.vec"""
return og.RuntimeAttribute(self._attributes.vec.get_attribute_data(), self._context, True)
@vec.setter
def vec(self, value_to_set: Any):
"""Assign another attribute's value to outputs.vec"""
if isinstance(value_to_set, og.RuntimeAttribute):
self.vec.value = value_to_set.value
else:
self.vec.value = value_to_set
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 outCpu(self) -> og.RuntimeAttribute:
"""Get the runtime wrapper class for the attribute outputs.outCpu"""
return og.RuntimeAttribute(self._attributes.outCpu.get_attribute_data(), self._context, False)
@outCpu.setter
def outCpu(self, value_to_set: Any):
"""Assign another attribute's value to outputs.outCpu"""
if isinstance(value_to_set, og.RuntimeAttribute):
self.outCpu.value = value_to_set.value
else:
self.outCpu.value = value_to_set
@property
def outGpu(self) -> og.RuntimeAttribute:
"""Get the runtime wrapper class for the attribute outputs.outGpu"""
return og.RuntimeAttribute(self._attributes.outGpu.get_attribute_data(), self._context, False)
@outGpu.setter
def outGpu(self, value_to_set: Any):
"""Assign another attribute's value to outputs.outGpu"""
if isinstance(value_to_set, og.RuntimeAttribute):
self.outGpu.value = value_to_set.value
else:
self.outGpu.value = value_to_set
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 = OgnTestAddAnyTypeAnyMemoryDatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
self.outputs = OgnTestAddAnyTypeAnyMemoryDatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
self.state = OgnTestAddAnyTypeAnyMemoryDatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
| 7,203 |
Python
| 48.682758 | 198 | 0.658059 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/OgnPerturbBundlePointsDatabase.py
|
"""Support for simplified access to data on nodes of type omni.graph.test.PerturbBundlePoints
Randomly modify positions on all points attributes within a bundle
"""
import carb
import numpy
import carb
import omni.graph.core as og
import omni.graph.core._omni_graph_core as _og
import omni.graph.tools.ogn as ogn
class OgnPerturbBundlePointsDatabase(og.Database):
"""Helper class providing simplified access to data on nodes of type omni.graph.test.PerturbBundlePoints
Class Members:
node: Node being evaluated
Attribute Value Properties:
Inputs:
inputs.bundle
inputs.maximum
inputs.minimum
inputs.percentModified
Outputs:
outputs.bundle
"""
# Imprint the generator and target ABI versions in the file for JIT generation
GENERATOR_VERSION = (1, 41, 3)
TARGET_VERSION = (2, 139, 12)
# This is an internal object that provides per-class storage of a per-node data dictionary
PER_NODE_DATA = {}
# This is an internal object that describes unchanging attributes in a generic way
# The values in this list are in no particular order, as a per-attribute tuple
# Name, Type, ExtendedTypeIndex, UiName, Description, Metadata,
# Is_Required, DefaultValue, Is_Deprecated, DeprecationMsg
# You should not need to access any of this data directly, use the defined database interfaces
INTERFACE = og.Database._get_interface([
('inputs:bundle', 'bundle', 0, 'Original Bundle', 'Bundle containing arrays of points to be perturbed', {}, True, None, False, ''),
('inputs:maximum', 'point3f', 0, 'Perturb Maximum', 'Maximum values of the perturbation', {ogn.MetadataKeys.DEFAULT: '[1.0, 1.0, 1.0]'}, True, [1.0, 1.0, 1.0], False, ''),
('inputs:minimum', 'point3f', 0, 'Perturb Minimum', 'Minimum values of the perturbation', {ogn.MetadataKeys.DEFAULT: '[0.0, 0.0, 0.0]'}, True, [0.0, 0.0, 0.0], False, ''),
('inputs:percentModified', 'float', 0, 'Percentage Modified', 'Percentage of points to modify, decided by striding across point set', {ogn.MetadataKeys.DEFAULT: '100.0'}, True, 100.0, False, ''),
('outputs:bundle', 'bundle', 0, 'Perturbed Bundle', 'Bundle containing arrays of points that were perturbed', {}, True, None, False, ''),
])
@classmethod
def _populate_role_data(cls):
"""Populate a role structure with the non-default roles on this node type"""
role_data = super()._populate_role_data()
role_data.inputs.bundle = og.AttributeRole.BUNDLE
role_data.inputs.maximum = og.AttributeRole.POSITION
role_data.inputs.minimum = og.AttributeRole.POSITION
role_data.outputs.bundle = og.AttributeRole.BUNDLE
return role_data
class ValuesForInputs(og.DynamicAttributeAccess):
LOCAL_PROPERTY_NAMES = { }
"""Helper class that creates natural hierarchical access to input attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
self.__bundles = og.BundleContainer(context, node, attributes, [], read_only=True, gpu_ptr_kinds={})
self._batchedReadAttributes = []
self._batchedReadValues = []
@property
def bundle(self) -> og.BundleContents:
"""Get the bundle wrapper class for the attribute inputs.bundle"""
return self.__bundles.bundle
@property
def maximum(self):
data_view = og.AttributeValueHelper(self._attributes.maximum)
return data_view.get()
@maximum.setter
def maximum(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.maximum)
data_view = og.AttributeValueHelper(self._attributes.maximum)
data_view.set(value)
@property
def minimum(self):
data_view = og.AttributeValueHelper(self._attributes.minimum)
return data_view.get()
@minimum.setter
def minimum(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.minimum)
data_view = og.AttributeValueHelper(self._attributes.minimum)
data_view.set(value)
@property
def percentModified(self):
data_view = og.AttributeValueHelper(self._attributes.percentModified)
return data_view.get()
@percentModified.setter
def percentModified(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.percentModified)
data_view = og.AttributeValueHelper(self._attributes.percentModified)
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 bundle(self) -> og.BundleContents:
"""Get the bundle wrapper class for the attribute outputs.bundle"""
return self.__bundles.bundle
@bundle.setter
def bundle(self, bundle: og.BundleContents):
"""Overwrite the bundle attribute outputs.bundle 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.bundle.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 = OgnPerturbBundlePointsDatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
self.outputs = OgnPerturbBundlePointsDatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
self.state = OgnPerturbBundlePointsDatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
| 7,818 |
Python
| 47.565217 | 203 | 0.661678 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/nodes/OgnTestOptionalExtended.py
|
"""Test node exercising the 'optional' flag on extended attributes"""
import omni.graph.core as og
class OgnTestOptionalExtended:
@staticmethod
def compute(db) -> bool:
"""Moves the 'other' input to the 'other' output if both of the optional attributes are not resolved,
sets the 'other' output to the default value if only one of them is resolved, and copies the 'optional' input
to the 'optional' output if both are resolved. (Since this is a test node we can count on the resolution types
being compatible.)
"""
if db.attributes.inputs.optional.get_resolved_type().base_type == og.BaseDataType.UNKNOWN:
if db.attributes.outputs.optional.get_resolved_type().base_type == og.BaseDataType.UNKNOWN:
db.outputs.other = db.inputs.other
else:
db.outputs.other = 10
elif db.attributes.outputs.optional.get_resolved_type().base_type != og.BaseDataType.UNKNOWN:
db.outputs.optional = db.inputs.optional
else:
db.outputs.other = 10
| 1,078 |
Python
| 48.045452 | 118 | 0.663265 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/nodes/OgnTestIsolate.cpp
|
// Copyright (c) 2023 NVIDIA CORPORATION. All rights reserved.
//
// NVIDIA CORPORATION and its licensors retain all intellectual property
// and proprietary rights in and to this software, related documentation
// and any modifications thereto. Any use, reproduction, disclosure or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA CORPORATION is strictly prohibited.
//
#include <OgnTestIsolateDatabase.h>
#include "../include/omni/graph/test/ConcurrencyState.h"
// This is the implementation of the OGN node defined in OgnTestIsolate.ogn
// This node is used as part of a unit test in ../python/tests/test_execution.py
namespace omni {
namespace graph {
namespace test {
class OgnTestIsolate
{
public:
static bool compute(OgnTestIsolateDatabase& db)
{
db.outputs.result() = false;
// Use a race condition finder to confirm that there is no collision between serial and/or isolated
// tasks. If we crash in here, that means ParallelScheduler is not respecting scheduling constraints.
omni::graph::exec::unstable::RaceConditionFinder::Scope detectIssues(getConcurrencyState().raceConditionFinder);
// In addition to ensuring that no other threads try to access the resources held by
// this node/the thread this node gets evaluated in, Isolate scheduling implies that only
// a SINGLE thread processing the current Isolate node can be computing (until said node
// is done being evaluated). To validate that this is the case, try to grab an exclusive
// lock over the global shared mutex. If this node is unable to do that (because concurrently-
// running nodes have ownership over it at the moment), we'll return false. Also, if another
// node/thread tries to access said shared mutex while this node is evaluating, the test will
// end up failing as well.
// Return early if TestIsolate can't exclusively own the shared mutex. outputs:result was already
// set to false at the start, so no need to do anything else.
if (!getConcurrencyState().sharedMutex.try_lock())
{
return true;
}
// Sleep for a while (simulate expensive compute/allows for potential race conditions to occur).
std::this_thread::sleep_for(std::chrono::milliseconds(100));
// Unlock the shared mutex, set output:result to true.
db.outputs.result() = true;
getConcurrencyState().sharedMutex.unlock();
return true;
}
};
REGISTER_OGN_NODE()
} // test
} // namespace graph
} // namespace omni
| 2,644 |
C++
| 41.66129 | 120 | 0.711422 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/nodes/OgnTestSerial.cpp
|
// Copyright (c) 2023 NVIDIA CORPORATION. All rights reserved.
//
// NVIDIA CORPORATION and its licensors retain all intellectual property
// and proprietary rights in and to this software, related documentation
// and any modifications thereto. Any use, reproduction, disclosure or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA CORPORATION is strictly prohibited.
//
#include "../include/omni/graph/test/ConcurrencyState.h"
#include <OgnTestSerialDatabase.h>
// This is the implementation of the OGN node defined in OgnTestSerial.ogn
namespace omni
{
namespace graph
{
namespace test
{
class OgnTestSerial
{
public:
static bool compute(OgnTestSerialDatabase& db)
{
db.outputs.result() = false;
// Use a race condition finder to confirm that there is no collision between serial and/or isolated
// tasks. If we crash in here, that means ParallelScheduler is not respecting scheduling constraints.
omni::graph::exec::unstable::RaceConditionFinder::Scope detectIssues(getConcurrencyState().raceConditionFinder);
// Sleep for a while (simulate expensive compute and give time for potential race conditions
// to arise).
std::this_thread::sleep_for(std::chrono::milliseconds(100));
db.outputs.result() = true;
return true;
}
};
REGISTER_OGN_NODE()
} // test
} // namespace graph
} // namespace omni
| 1,455 |
C++
| 29.333333 | 120 | 0.729897 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/nodes/OgnTestConcurrency.cpp
|
// 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.
//
#include <OgnTestConcurrencyDatabase.h>
#include <omni/graph/exec/unstable/IExecutionContext.h>
#include <omni/graph/exec/unstable/IExecutionCurrentThread.h>
#include <omni/graph/exec/unstable/Stamp.h>
#include "../include/omni/graph/test/ConcurrencyState.h"
#include <atomic>
#include <chrono>
#include <cstdlib>
#include <mutex>
// This is the implementation of the OGN node defined in OgnTestConcurrency.ogn
namespace omni {
namespace graph {
namespace test {
namespace
{
std::mutex g_resetMutex;
exec::unstable::SyncStamp g_currentSyncStamp;
std::atomic<uint64_t> g_currentConcurrency{0};
}
class OgnTestConcurrency
{
public:
static bool compute(OgnTestConcurrencyDatabase& db)
{
auto& result = db.outputs.result();
result = false;
// Try to access the shared mutex via a shared lock. If the node is unable to do
// that (i.e. because TestIsolate currently holds exclusive ownership), we'll
// return early with result set to false.
if (!getConcurrencyState().sharedMutex.try_lock_shared())
{
return true;
}
if (auto task = exec::unstable::getCurrentTask())
{
auto currentStamp = task->getContext()->getExecutionStamp();
if(!g_currentSyncStamp.inSync(currentStamp))
{
std::unique_lock<std::mutex> lock(g_resetMutex);
if(g_currentSyncStamp.makeSync(currentStamp))
{
g_currentConcurrency = 0;
}
}
g_currentConcurrency++;
uint64_t expectedConcurrency = db.inputs.expected();
std::chrono::milliseconds timeOut(db.inputs.timeOut());
auto start = std::chrono::high_resolution_clock::now();
std::chrono::milliseconds currentDuration;
do {
currentDuration = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now()-start);
if(g_currentConcurrency.load() == expectedConcurrency)
{
result = true;
break;
}
std::this_thread::yield();
} while(currentDuration < timeOut);
}
// Release the shared mutex.
getConcurrencyState().sharedMutex.unlock_shared();
return true;
}
};
REGISTER_OGN_NODE()
} // test
} // namespace graph
} // namespace omni
| 2,907 |
C++
| 30.268817 | 137 | 0.634331 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/nodes/OgnTestDynamicAttributeRawData.cpp
|
// Copyright (c) 2023 NVIDIA CORPORATION. All rights reserved.
//
// NVIDIA CORPORATION and its licensors retain all intellectual property
// and proprietary rights in and to this software, related documentation
// and any modifications thereto. Any use, reproduction, disclosure or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA CORPORATION is strictly prohibited.
//
#include <OgnTestDynamicAttributeRawDataDatabase.h>
namespace omni {
namespace graph {
namespace test {
namespace
{
template<typename TAttribute, typename TValue>
void writeRawData(TAttribute& runtimeAttribute, TValue value)
{
uint8_t* dstData{ nullptr };
size_t size{ 0 };
runtimeAttribute.rawData(dstData, size);
memcpy(dstData, &value, size);
}
}
// This node validates the APIs for accessing and mutating the dynamic node attributes (inputs, outputs and state)
class OgnTestDynamicAttributeRawData
{
public:
static bool compute(OgnTestDynamicAttributeRawDataDatabase& db)
{
auto dynamicInputs = db.getDynamicInputs();
auto dynamicOutputs = db.getDynamicOutputs();
auto dynamicStates = db.getDynamicStates();
if (dynamicInputs.empty() || dynamicOutputs.empty() || dynamicStates.empty())
{
return false;
}
int sum = 0;
for (auto const& input : dynamicInputs)
{
ConstRawPtr dataPtr{ nullptr };
size_t size{ 0 };
input().rawData(dataPtr, size);
sum += *reinterpret_cast<int const*>(dataPtr);
}
// ensure that dynamic output and state attributes can be written to using the raw data pointer
writeRawData(dynamicOutputs[0](), sum);
writeRawData(dynamicStates[0](), sum);
return true;
}
};
REGISTER_OGN_NODE()
} // test
} // namespace graph
} // namespace omni
| 1,936 |
C++
| 28.348484 | 114 | 0.67407 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/nodes/OgnTestDynamicAttributeMemory.py
|
"""Test node exercising retrieval of dynamic attribute array values from various memory locations.
Add an input attribute named "array" of type "int[]", another named "simple" of type "double", and output attributes
with matching names and types to pass data through using the dynamic attribute get() and set() methods.
"""
import numpy as np
import omni.graph.core as og
from omni.graph.core._impl.dtypes import Int
class OgnTestDynamicAttributeMemory:
@staticmethod
def compute(db) -> bool:
gpu_ptr_kind = og.PtrToPtrKind.NA
on_gpu = db.inputs.onGpu
if on_gpu:
gpu_ptr_kind = og.PtrToPtrKind.GPU if db.inputs.gpuPtrsOnGpu else og.PtrToPtrKind.CPU
db.set_dynamic_attribute_memory_location(on_gpu=on_gpu, gpu_ptr_kind=gpu_ptr_kind)
try:
array_value = db.inputs.array
simple_value = db.inputs.simple
except AttributeError:
# Only verify when the input dynamic attribute was present
db.outputs.inputMemoryVerified = False
db.outputs.outputMemoryVerified = False
return True
# CPU inputs are returned as np.ndarrays, GPU inputs are og.DataWrapper
if not on_gpu:
db.outputs.inputMemoryVerified = isinstance(array_value, np.ndarray) and isinstance(simple_value, float)
else:
_, *new_shape = array_value.shape
new_shape = tuple(new_shape)
db.outputs.inputMemoryVerified = (
array_value.gpu_ptr_kind == gpu_ptr_kind
and array_value.device.cuda
and array_value.is_array()
and array_value.dtype == Int()
and isinstance(simple_value, float)
)
try:
db.outputs.array = array_value
db.outputs.simple = simple_value
except AttributeError:
# Only verify when the output dynamic attribute was present
db.outputs.outputMemoryVerified = False
return True
# CPU inputs are returned as np.ndarrays, GPU inputs are og.DataWrapper
new_output_arr = db.outputs.array
new_output = db.outputs.simple
if not on_gpu:
db.outputs.outputMemoryVerified = isinstance(new_output_arr, np.ndarray) and isinstance(new_output, float)
else:
_, *new_shape = new_output_arr.shape
new_shape = tuple(new_shape)
db.outputs.outputMemoryVerified = (
new_output_arr.gpu_ptr_kind == gpu_ptr_kind
and new_output_arr.device.cuda
and new_output_arr.is_array()
and new_output_arr.dtype == Int()
and isinstance(new_output, float)
)
return True
| 2,767 |
Python
| 39.705882 | 118 | 0.617636 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/nodes/OgnExecInputEnabledTest.py
|
"""
This node's compute checks that its input attrib is properly enabled.
"""
import omni.graph.core as og
class OgnExecInputEnabledTest:
@staticmethod
def compute(db) -> bool:
if (
db.inputs.execInA == og.ExecutionAttributeState.ENABLED
and db.inputs.execInB == og.ExecutionAttributeState.ENABLED
):
db.log_warning("Unexpected execution with both execution inputs enabled")
return False
if db.inputs.execInA == og.ExecutionAttributeState.ENABLED:
db.outputs.execOutA = og.ExecutionAttributeState.ENABLED
return True
if db.inputs.execInB == og.ExecutionAttributeState.ENABLED:
db.outputs.execOutB = og.ExecutionAttributeState.ENABLED
return True
db.log_warning("Unexpected execution with no execution input enabled")
db.outputs.execOut = og.ExecutionAttributeState.DISABLED
return False
| 951 |
Python
| 34.259258 | 85 | 0.674027 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/nodes/OgnTestCategoryDefinitions.py
|
"""Node that tests custom category assignment through extraction of the current category"""
import omni.graph.tools.ogn as ogn
class OgnTestCategoryDefinitions:
"""Extract the assigned category definition of a node type"""
@staticmethod
def compute(db) -> bool:
"""Compute only extracts the category name and puts it into the output"""
db.outputs.category = db.abi_node.get_node_type().get_metadata(ogn.MetadataKeys.CATEGORIES)
return True
| 480 |
Python
| 33.35714 | 99 | 0.722917 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/nodes/OgnTestWriteVariablePy.py
|
"""
Test node for writing variables
"""
import omni.graph.core as og
class OgnTestWriteVariablePy:
"""Python version of OgnWriteVariable"""
@staticmethod
def compute(db) -> bool:
"""Write the given variable"""
try:
db.set_variable(db.inputs.variableName, db.inputs.value.value)
except og.OmniGraphError:
return False
# Output the value
value = db.inputs.value.value
if value is not None:
db.outputs.value = value
return True
@staticmethod
def initialize(graph_context, node):
function_callback = OgnTestWriteVariablePy.on_value_changed_callback
node.get_attribute("inputs:variableName").register_value_changed_callback(function_callback)
@staticmethod
def on_value_changed_callback(attr):
node = attr.get_node()
name = attr.get_attribute_data().get(False)
var = node.get_graph().find_variable(name)
value_attr = node.get_attribute("inputs:value")
old_type = value_attr.get_resolved_type()
# resolve the input variable
if not var:
value_attr.set_resolved_type(og.Type(og.BaseDataType.UNKNOWN))
elif var.type != old_type:
value_attr.set_resolved_type(og.Type(og.BaseDataType.UNKNOWN))
value_attr.set_resolved_type(var.type)
# resolve the output variable
value_attr = node.get_attribute("outputs:value")
old_type = value_attr.get_resolved_type()
if not var:
value_attr.set_resolved_type(og.Type(og.BaseDataType.UNKNOWN))
elif var.type != old_type:
value_attr.set_resolved_type(og.Type(og.BaseDataType.UNKNOWN))
value_attr.set_resolved_type(var.type)
| 1,768 |
Python
| 32.377358 | 100 | 0.635747 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/nodes/OgnTestSchedulingHintsList.py
|
"""Empty test node used for checking scheduling hints"""
class OgnTestSchedulingHintsList:
@staticmethod
def compute(db) -> bool:
return True
| 160 |
Python
| 19.124998 | 56 | 0.7 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/nodes/OgnTestScatter.cpp
|
// Copyright (c) 2019-2021, NVIDIA CORPORATION. All rights reserved.
//
// NVIDIA CORPORATION and its licensors retain all intellectual property
// and proprietary rights in and to this software, related documentation
// and any modifications thereto. Any use, reproduction, disclosure or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA CORPORATION is strictly prohibited.
//
#include <OgnTestScatterDatabase.h>
#include <cmath>
#include <vector>
using carb::Double3;
namespace omni
{
namespace graph
{
namespace examples
{
class OgnTestScatter
{
public:
static bool compute(OgnTestScatterDatabase& db)
{
/*
const auto& gatheredPaths = db.inputs.gathered_paths();
for (const auto& gatheredPath : gatheredPaths)
{
std::string gatheredPathStr = db.tokenToString(gatheredPath);
printf("gather path = %s\n", gatheredPathStr.c_str());
}*/
const auto& inputRotations = db.inputs.rotations();
int count = 0;
for (const auto& inputRotation : inputRotations)
{
// Pretend scan the inputs. The real scatter node would be writing to the Fabric here with the updated
// transforms.
count++;
}
// Because we don't have the real scatter node yet, we'll just pluck one element of the calculated rotations
// and output there in a temporary single output.
auto& singleRot = db.outputs.single_rotation();
if (inputRotations.size() > 0)
{
singleRot[0] = -90;
singleRot[1] = inputRotations[0][1];
singleRot[2] = 0;
}
return true;
}
};
REGISTER_OGN_NODE()
}
}
}
| 1,774 |
C++
| 25.102941 | 116 | 0.640924 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/nodes/OgnTestAllDataTypesPy.py
|
"""
This node is meant to exercise data access for all available data types, including all",
legal combinations of tuples, arrays, and bundle members. The test section here is intentionally",
omitted so that the regression test script can programmatically generate tests for all known types,",
reducing the change of unintentional omissions. This node definition is a duplicate of",
OgnTestAllDataTypes.ogn, except the implementation language is Python."
"""
class OgnTestAllDataTypesPy:
@staticmethod
def compute(db) -> bool:
"""Compute just copies the input values to the output of the same name and type"""
if db.inputs.doNotCompute:
return True
db.outputs.a_bool = db.inputs.a_bool
db.outputs.a_bool_array = db.inputs.a_bool_array
db.outputs.a_colord_3 = db.inputs.a_colord_3
db.outputs.a_colord_4 = db.inputs.a_colord_4
db.outputs.a_colorf_3 = db.inputs.a_colorf_3
db.outputs.a_colorf_4 = db.inputs.a_colorf_4
db.outputs.a_colorh_3 = db.inputs.a_colorh_3
db.outputs.a_colorh_4 = db.inputs.a_colorh_4
db.outputs.a_colord_3_array = db.inputs.a_colord_3_array
db.outputs.a_colord_4_array = db.inputs.a_colord_4_array
db.outputs.a_colorf_3_array = db.inputs.a_colorf_3_array
db.outputs.a_colorf_4_array = db.inputs.a_colorf_4_array
db.outputs.a_colorh_3_array = db.inputs.a_colorh_3_array
db.outputs.a_colorh_4_array = db.inputs.a_colorh_4_array
db.outputs.a_double = db.inputs.a_double
db.outputs.a_double_2 = db.inputs.a_double_2
db.outputs.a_double_3 = db.inputs.a_double_3
db.outputs.a_double_4 = db.inputs.a_double_4
db.outputs.a_double_array = db.inputs.a_double_array
db.outputs.a_double_2_array = db.inputs.a_double_2_array
db.outputs.a_double_3_array = db.inputs.a_double_3_array
db.outputs.a_double_4_array = db.inputs.a_double_4_array
db.outputs.a_execution = db.inputs.a_execution
db.outputs.a_float = db.inputs.a_float
db.outputs.a_float_2 = db.inputs.a_float_2
db.outputs.a_float_3 = db.inputs.a_float_3
db.outputs.a_float_4 = db.inputs.a_float_4
db.outputs.a_float_array = db.inputs.a_float_array
db.outputs.a_float_2_array = db.inputs.a_float_2_array
db.outputs.a_float_3_array = db.inputs.a_float_3_array
db.outputs.a_float_4_array = db.inputs.a_float_4_array
db.outputs.a_frame_4 = db.inputs.a_frame_4
db.outputs.a_frame_4_array = db.inputs.a_frame_4_array
db.outputs.a_half = db.inputs.a_half
db.outputs.a_half_2 = db.inputs.a_half_2
db.outputs.a_half_3 = db.inputs.a_half_3
db.outputs.a_half_4 = db.inputs.a_half_4
db.outputs.a_half_array = db.inputs.a_half_array
db.outputs.a_half_2_array = db.inputs.a_half_2_array
db.outputs.a_half_3_array = db.inputs.a_half_3_array
db.outputs.a_half_4_array = db.inputs.a_half_4_array
db.outputs.a_int = db.inputs.a_int
db.outputs.a_int_2 = db.inputs.a_int_2
db.outputs.a_int_3 = db.inputs.a_int_3
db.outputs.a_int_4 = db.inputs.a_int_4
db.outputs.a_int_array = db.inputs.a_int_array
db.outputs.a_int_2_array = db.inputs.a_int_2_array
db.outputs.a_int_3_array = db.inputs.a_int_3_array
db.outputs.a_int_4_array = db.inputs.a_int_4_array
db.outputs.a_int64 = db.inputs.a_int64
db.outputs.a_int64_array = db.inputs.a_int64_array
db.outputs.a_matrixd_2 = db.inputs.a_matrixd_2
db.outputs.a_matrixd_3 = db.inputs.a_matrixd_3
db.outputs.a_matrixd_4 = db.inputs.a_matrixd_4
db.outputs.a_matrixd_2_array = db.inputs.a_matrixd_2_array
db.outputs.a_matrixd_3_array = db.inputs.a_matrixd_3_array
db.outputs.a_matrixd_4_array = db.inputs.a_matrixd_4_array
db.outputs.a_normald_3 = db.inputs.a_normald_3
db.outputs.a_normalf_3 = db.inputs.a_normalf_3
db.outputs.a_normalh_3 = db.inputs.a_normalh_3
db.outputs.a_normald_3_array = db.inputs.a_normald_3_array
db.outputs.a_normalf_3_array = db.inputs.a_normalf_3_array
db.outputs.a_normalh_3_array = db.inputs.a_normalh_3_array
db.outputs.a_objectId = db.inputs.a_objectId
db.outputs.a_objectId_array = db.inputs.a_objectId_array
db.outputs.a_path = db.inputs.a_path
db.outputs.a_pointd_3 = db.inputs.a_pointd_3
db.outputs.a_pointf_3 = db.inputs.a_pointf_3
db.outputs.a_pointh_3 = db.inputs.a_pointh_3
db.outputs.a_pointd_3_array = db.inputs.a_pointd_3_array
db.outputs.a_pointf_3_array = db.inputs.a_pointf_3_array
db.outputs.a_pointh_3_array = db.inputs.a_pointh_3_array
db.outputs.a_quatd_4 = db.inputs.a_quatd_4
db.outputs.a_quatf_4 = db.inputs.a_quatf_4
db.outputs.a_quath_4 = db.inputs.a_quath_4
db.outputs.a_quatd_4_array = db.inputs.a_quatd_4_array
db.outputs.a_quatf_4_array = db.inputs.a_quatf_4_array
db.outputs.a_quath_4_array = db.inputs.a_quath_4_array
db.outputs.a_string = db.inputs.a_string
db.outputs.a_target = db.inputs.a_target
db.outputs.a_texcoordd_2 = db.inputs.a_texcoordd_2
db.outputs.a_texcoordd_3 = db.inputs.a_texcoordd_3
db.outputs.a_texcoordf_2 = db.inputs.a_texcoordf_2
db.outputs.a_texcoordf_3 = db.inputs.a_texcoordf_3
db.outputs.a_texcoordh_2 = db.inputs.a_texcoordh_2
db.outputs.a_texcoordh_3 = db.inputs.a_texcoordh_3
db.outputs.a_texcoordd_2_array = db.inputs.a_texcoordd_2_array
db.outputs.a_texcoordd_3_array = db.inputs.a_texcoordd_3_array
db.outputs.a_texcoordf_2_array = db.inputs.a_texcoordf_2_array
db.outputs.a_texcoordf_3_array = db.inputs.a_texcoordf_3_array
db.outputs.a_texcoordh_2_array = db.inputs.a_texcoordh_2_array
db.outputs.a_texcoordh_3_array = db.inputs.a_texcoordh_3_array
db.outputs.a_timecode = db.inputs.a_timecode
db.outputs.a_timecode_array = db.inputs.a_timecode_array
db.outputs.a_token = db.inputs.a_token
db.outputs.a_token_array = db.inputs.a_token_array
db.outputs.a_uchar = db.inputs.a_uchar
db.outputs.a_uchar_array = db.inputs.a_uchar_array
db.outputs.a_uint = db.inputs.a_uint
db.outputs.a_uint_array = db.inputs.a_uint_array
db.outputs.a_uint64 = db.inputs.a_uint64
db.outputs.a_uint64_array = db.inputs.a_uint64_array
db.outputs.a_vectord_3 = db.inputs.a_vectord_3
db.outputs.a_vectorf_3 = db.inputs.a_vectorf_3
db.outputs.a_vectorh_3 = db.inputs.a_vectorh_3
db.outputs.a_vectord_3_array = db.inputs.a_vectord_3_array
db.outputs.a_vectorf_3_array = db.inputs.a_vectorf_3_array
db.outputs.a_vectorh_3_array = db.inputs.a_vectorh_3_array
# Copy inputs of all kinds to the output bundle. The test should connect a bundle with all types of attributes
# so that every data type is exercised.
output_bundle = db.outputs.a_bundle
state_bundle = db.state.a_bundle
for bundled_attribute in db.inputs.a_bundle.attributes:
# By copying each attribute individually rather than doing a bundle copy all of the data types
# encapsulated by that bundle are exercised.
new_output = output_bundle.insert(bundled_attribute)
new_state = state_bundle.insert(bundled_attribute)
new_output.copy_data(bundled_attribute)
new_state.copy_data(bundled_attribute)
# State attributes take on the input values the first time they evaluate, zeroes on subsequent evaluations.
# The a_firstEvaluation attribute is used as the gating state information to decide when evaluation needs to
# happen again.
if db.state.a_firstEvaluation:
db.state.a_firstEvaluation = False
db.state.a_bool = db.inputs.a_bool
db.state.a_bool_array = db.inputs.a_bool_array
db.state.a_colord_3 = db.inputs.a_colord_3
db.state.a_colord_4 = db.inputs.a_colord_4
db.state.a_colorf_3 = db.inputs.a_colorf_3
db.state.a_colorf_4 = db.inputs.a_colorf_4
db.state.a_colorh_3 = db.inputs.a_colorh_3
db.state.a_colorh_4 = db.inputs.a_colorh_4
db.state.a_colord_3_array = db.inputs.a_colord_3_array
db.state.a_colord_4_array = db.inputs.a_colord_4_array
db.state.a_colorf_3_array = db.inputs.a_colorf_3_array
db.state.a_colorf_4_array = db.inputs.a_colorf_4_array
db.state.a_colorh_3_array = db.inputs.a_colorh_3_array
db.state.a_colorh_4_array = db.inputs.a_colorh_4_array
db.state.a_double = db.inputs.a_double
db.state.a_double_2 = db.inputs.a_double_2
db.state.a_double_3 = db.inputs.a_double_3
db.state.a_double_4 = db.inputs.a_double_4
db.state.a_double_array = db.inputs.a_double_array
db.state.a_double_2_array = db.inputs.a_double_2_array
db.state.a_double_3_array = db.inputs.a_double_3_array
db.state.a_double_4_array = db.inputs.a_double_4_array
db.state.a_execution = db.inputs.a_execution
db.state.a_float = db.inputs.a_float
db.state.a_float_2 = db.inputs.a_float_2
db.state.a_float_3 = db.inputs.a_float_3
db.state.a_float_4 = db.inputs.a_float_4
db.state.a_float_array = db.inputs.a_float_array
db.state.a_float_2_array = db.inputs.a_float_2_array
db.state.a_float_3_array = db.inputs.a_float_3_array
db.state.a_float_4_array = db.inputs.a_float_4_array
db.state.a_frame_4 = db.inputs.a_frame_4
db.state.a_frame_4_array = db.inputs.a_frame_4_array
db.state.a_half = db.inputs.a_half
db.state.a_half_2 = db.inputs.a_half_2
db.state.a_half_3 = db.inputs.a_half_3
db.state.a_half_4 = db.inputs.a_half_4
db.state.a_half_array = db.inputs.a_half_array
db.state.a_half_2_array = db.inputs.a_half_2_array
db.state.a_half_3_array = db.inputs.a_half_3_array
db.state.a_half_4_array = db.inputs.a_half_4_array
db.state.a_int = db.inputs.a_int
db.state.a_int_2 = db.inputs.a_int_2
db.state.a_int_3 = db.inputs.a_int_3
db.state.a_int_4 = db.inputs.a_int_4
db.state.a_int_array = db.inputs.a_int_array
db.state.a_int_2_array = db.inputs.a_int_2_array
db.state.a_int_3_array = db.inputs.a_int_3_array
db.state.a_int_4_array = db.inputs.a_int_4_array
db.state.a_int64 = db.inputs.a_int64
db.state.a_int64_array = db.inputs.a_int64_array
db.state.a_matrixd_2 = db.inputs.a_matrixd_2
db.state.a_matrixd_3 = db.inputs.a_matrixd_3
db.state.a_matrixd_4 = db.inputs.a_matrixd_4
db.state.a_matrixd_2_array = db.inputs.a_matrixd_2_array
db.state.a_matrixd_3_array = db.inputs.a_matrixd_3_array
db.state.a_matrixd_4_array = db.inputs.a_matrixd_4_array
db.state.a_normald_3 = db.inputs.a_normald_3
db.state.a_normalf_3 = db.inputs.a_normalf_3
db.state.a_normalh_3 = db.inputs.a_normalh_3
db.state.a_normald_3_array = db.inputs.a_normald_3_array
db.state.a_normalf_3_array = db.inputs.a_normalf_3_array
db.state.a_normalh_3_array = db.inputs.a_normalh_3_array
db.state.a_objectId = db.inputs.a_objectId
db.state.a_objectId_array = db.inputs.a_objectId_array
db.state.a_path = db.inputs.a_path
db.state.a_pointd_3 = db.inputs.a_pointd_3
db.state.a_pointf_3 = db.inputs.a_pointf_3
db.state.a_pointh_3 = db.inputs.a_pointh_3
db.state.a_pointd_3_array = db.inputs.a_pointd_3_array
db.state.a_pointf_3_array = db.inputs.a_pointf_3_array
db.state.a_pointh_3_array = db.inputs.a_pointh_3_array
db.state.a_quatd_4 = db.inputs.a_quatd_4
db.state.a_quatf_4 = db.inputs.a_quatf_4
db.state.a_quath_4 = db.inputs.a_quath_4
db.state.a_quatd_4_array = db.inputs.a_quatd_4_array
db.state.a_quatf_4_array = db.inputs.a_quatf_4_array
db.state.a_quath_4_array = db.inputs.a_quath_4_array
db.state.a_string = db.inputs.a_string
db.state.a_stringEmpty = db.inputs.a_string
db.state.a_target = db.inputs.a_target
db.state.a_texcoordd_2 = db.inputs.a_texcoordd_2
db.state.a_texcoordd_3 = db.inputs.a_texcoordd_3
db.state.a_texcoordf_2 = db.inputs.a_texcoordf_2
db.state.a_texcoordf_3 = db.inputs.a_texcoordf_3
db.state.a_texcoordh_2 = db.inputs.a_texcoordh_2
db.state.a_texcoordh_3 = db.inputs.a_texcoordh_3
db.state.a_texcoordd_2_array = db.inputs.a_texcoordd_2_array
db.state.a_texcoordd_3_array = db.inputs.a_texcoordd_3_array
db.state.a_texcoordf_2_array = db.inputs.a_texcoordf_2_array
db.state.a_texcoordf_3_array = db.inputs.a_texcoordf_3_array
db.state.a_texcoordh_2_array = db.inputs.a_texcoordh_2_array
db.state.a_texcoordh_3_array = db.inputs.a_texcoordh_3_array
db.state.a_timecode = db.inputs.a_timecode
db.state.a_timecode_array = db.inputs.a_timecode_array
db.state.a_token = db.inputs.a_token
db.state.a_token_array = db.inputs.a_token_array
db.state.a_uchar = db.inputs.a_uchar
db.state.a_uchar_array = db.inputs.a_uchar_array
db.state.a_uint = db.inputs.a_uint
db.state.a_uint_array = db.inputs.a_uint_array
db.state.a_uint64 = db.inputs.a_uint64
db.state.a_uint64_array = db.inputs.a_uint64_array
db.state.a_vectord_3 = db.inputs.a_vectord_3
db.state.a_vectorf_3 = db.inputs.a_vectorf_3
db.state.a_vectorh_3 = db.inputs.a_vectorh_3
db.state.a_vectord_3_array = db.inputs.a_vectord_3_array
db.state.a_vectorf_3_array = db.inputs.a_vectorf_3_array
db.state.a_vectorh_3_array = db.inputs.a_vectorh_3_array
else:
db.state.a_bool = False
db.state.a_bool_array = []
db.state.a_colord_3 = [0.0, 0.0, 0.0]
db.state.a_colord_4 = [0.0, 0.0, 0.0, 0.0]
db.state.a_colorf_3 = [0.0, 0.0, 0.0]
db.state.a_colorf_4 = [0.0, 0.0, 0.0, 0.0]
db.state.a_colorh_3 = [0.0, 0.0, 0.0]
db.state.a_colorh_4 = [0.0, 0.0, 0.0, 0.0]
db.state.a_colord_3_array = []
db.state.a_colord_4_array = []
db.state.a_colorf_3_array = []
db.state.a_colorf_4_array = []
db.state.a_colorh_3_array = []
db.state.a_colorh_4_array = []
db.state.a_double = 0.0
db.state.a_double_2 = [0.0, 0.0]
db.state.a_double_3 = [0.0, 0.0, 0.0]
db.state.a_double_4 = [0.0, 0.0, 0.0, 0.0]
db.state.a_double_array = []
db.state.a_double_2_array = []
db.state.a_double_3_array = []
db.state.a_double_4_array = []
db.state.a_execution = 0
db.state.a_float = 0.0
db.state.a_float_2 = [0.0, 0.0]
db.state.a_float_3 = [0.0, 0.0, 0.0]
db.state.a_float_4 = [0.0, 0.0, 0.0, 0.0]
db.state.a_float_array = []
db.state.a_float_2_array = []
db.state.a_float_3_array = []
db.state.a_float_4_array = []
db.state.a_frame_4 = [
[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],
]
db.state.a_frame_4_array = []
db.state.a_half = 0.0
db.state.a_half_2 = [0.0, 0.0]
db.state.a_half_3 = [0.0, 0.0, 0.0]
db.state.a_half_4 = [0.0, 0.0, 0.0, 0.0]
db.state.a_half_array = []
db.state.a_half_2_array = []
db.state.a_half_3_array = []
db.state.a_half_4_array = []
db.state.a_int = 0
db.state.a_int_2 = [0, 0]
db.state.a_int_3 = [0, 0, 0]
db.state.a_int_4 = [0, 0, 0, 0]
db.state.a_int_array = []
db.state.a_int_2_array = []
db.state.a_int_3_array = []
db.state.a_int_4_array = []
db.state.a_int64 = 0
db.state.a_int64_array = []
db.state.a_matrixd_2 = [[0.0, 0.0], [0.0, 0.0]]
db.state.a_matrixd_3 = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]]
db.state.a_matrixd_4 = [
[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],
]
db.state.a_matrixd_2_array = []
db.state.a_matrixd_3_array = []
db.state.a_matrixd_4_array = []
db.state.a_normald_3 = [0.0, 0.0, 0.0]
db.state.a_normalf_3 = [0.0, 0.0, 0.0]
db.state.a_normalh_3 = [0.0, 0.0, 0.0]
db.state.a_normald_3_array = []
db.state.a_normalf_3_array = []
db.state.a_normalh_3_array = []
db.state.a_objectId = 0
db.state.a_objectId_array = []
db.outputs.a_path = ""
db.state.a_pointd_3 = [0.0, 0.0, 0.0]
db.state.a_pointf_3 = [0.0, 0.0, 0.0]
db.state.a_pointh_3 = [0.0, 0.0, 0.0]
db.state.a_pointd_3_array = []
db.state.a_pointf_3_array = []
db.state.a_pointh_3_array = []
db.state.a_quatd_4 = [0.0, 0.0, 0.0, 0.0]
db.state.a_quatf_4 = [0.0, 0.0, 0.0, 0.0]
db.state.a_quath_4 = [0.0, 0.0, 0.0, 0.0]
db.state.a_quatd_4_array = []
db.state.a_quatf_4_array = []
db.state.a_quath_4_array = []
db.state.a_string = ""
db.state.a_stringEmpty = ""
db.state.a_target = []
db.state.a_texcoordd_2 = [0.0, 0.0]
db.state.a_texcoordd_3 = [0.0, 0.0, 0.0]
db.state.a_texcoordf_2 = [0.0, 0.0]
db.state.a_texcoordf_3 = [0.0, 0.0, 0.0]
db.state.a_texcoordh_2 = [0.0, 0.0]
db.state.a_texcoordh_3 = [0.0, 0.0, 0.0]
db.state.a_texcoordd_2_array = []
db.state.a_texcoordd_3_array = []
db.state.a_texcoordf_2_array = []
db.state.a_texcoordf_3_array = []
db.state.a_texcoordh_2_array = []
db.state.a_texcoordh_3_array = []
db.state.a_timecode = 0.0
db.state.a_timecode_array = []
db.state.a_token = ""
db.state.a_token_array = []
db.state.a_uchar = 0
db.state.a_uchar_array = []
db.state.a_uint = 0
db.state.a_uint_array = []
db.state.a_uint64 = 0
db.state.a_uint64_array = []
db.state.a_vectord_3 = [0.0, 0.0, 0.0]
db.state.a_vectorf_3 = [0.0, 0.0, 0.0]
db.state.a_vectorh_3 = [0.0, 0.0, 0.0]
db.state.a_vectord_3_array = []
db.state.a_vectorf_3_array = []
db.state.a_vectorh_3_array = []
return True
| 19,720 |
Python
| 43.217489 | 118 | 0.572363 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/nodes/OgnTestGather.cpp
|
// Copyright (c) 2019-2021, NVIDIA CORPORATION. All rights reserved.
//
// NVIDIA CORPORATION and its licensors retain all intellectual property
// and proprietary rights in and to this software, related documentation
// and any modifications thereto. Any use, reproduction, disclosure or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA CORPORATION is strictly prohibited.
//
#include <OgnTestGatherDatabase.h>
#include <cmath>
#include <vector>
using carb::Double3;
namespace omni
{
namespace graph
{
namespace examples
{
class OgnTestGather
{
public:
static bool compute(OgnTestGatherDatabase& db)
{
// This is a temporary node in place to test performance. It serves no real purpose
static bool firstTime = true;
if (firstTime)
{
auto inputNameToken = db.inputs.base_name();
auto inputNumInstance = db.inputs.num_instances();
std::string inputNameStr = db.tokenToString(inputNameToken);
db.outputs.rotations.resize(inputNumInstance);
auto& outputRotations = db.outputs.rotations();
for (auto& rotation : outputRotations)
{
rotation[0] = 7;
rotation[1] = 8;
rotation[2] = 9;
}
db.outputs.gathered_paths.resize(2);
auto& outputPaths = db.outputs.gathered_paths();
std::string str0 = "foo";
outputPaths[0] = db.stringToToken(str0.c_str());
std::string str1 = "bar";
outputPaths[1] = db.stringToToken(str1.c_str());
printf("input base name =%s\n", inputNameStr.c_str());
firstTime = false;
}
return true;
}
};
REGISTER_OGN_NODE()
}
}
}
| 1,825 |
C++
| 25.085714 | 92 | 0.620274 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/nodes/OgnTestAllowedTokens.py
|
"""
Implementation of an OmniGraph node that contains attributes with the allowedTokens metadata
"""
import omni.graph.tools.ogn as ogn
class OgnTestAllowedTokens:
@staticmethod
def compute(db):
allowed_simple = db.attributes.inputs.simpleTokens.get_metadata(ogn.MetadataKeys.ALLOWED_TOKENS).split(",")
allowed_special = db.attributes.inputs.specialTokens.get_metadata(ogn.MetadataKeys.ALLOWED_TOKENS).split(",")
assert db.tokens.red in allowed_simple
assert db.tokens.green in allowed_simple
assert db.tokens.blue in allowed_simple
assert db.tokens.lt in allowed_special
assert db.tokens.gt in allowed_special
db.outputs.combinedTokens = f"{db.inputs.simpleTokens}{db.inputs.specialTokens}"
return True
| 790 |
Python
| 33.391303 | 117 | 0.724051 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/nodes/OgnPerturbPoints.cpp
|
// Copyright (c) 2021 NVIDIA CORPORATION. All rights reserved.
//
// NVIDIA CORPORATION and its licensors retain all intellectual property
// and proprietary rights in and to this software, related documentation
// and any modifications thereto. Any use, reproduction, disclosure or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA CORPORATION is strictly prohibited.
//
#include <OgnPerturbPointsDatabase.h>
#include <cstdlib>
namespace omni {
namespace graph {
namespace test {
// This is the implementation of the OGN node defined in OgnPerturbPoints.ogn
class OgnPerturbPoints
{
static auto& copy(OgnPerturbPointsDatabase& db)
{
CARB_PROFILE_ZONE(carb::profiler::kCaptureMaskDefault, "Acquiring Data");
db.outputs.points = db.inputs.points;
return db.outputs.points();
}
public:
// Perturb an array of points by random amounts within the limits of the bounding cube formed by the diagonal
// corners "minimum" and "maximum".
static bool compute(OgnPerturbPointsDatabase& db)
{
const auto& minimum = db.inputs.minimum();
GfVec3f rangeSize = db.inputs.maximum() - minimum;
// No points mean nothing to perturb
const auto& inputPoints = db.inputs.points();
size_t pointCount = inputPoints.size();
if (pointCount == 0)
{
return true;
}
// How much of the surface should be perturbed
auto percentModified = db.inputs.percentModified();
percentModified = (percentModified > 100.0f ? 100.0f : (percentModified < 0.0f ? 0.0f : percentModified));
size_t pointsToModify = (size_t)((percentModified * (float)pointCount) / 100.0f);
auto& pointArray = copy(db);
CARB_PROFILE_ZONE(carb::profiler::kCaptureMaskDefault, "Perturbing Data");
size_t index{ 0 };
while (index < pointsToModify)
{
auto& point = pointArray[index++];
GfVec3f offset{
minimum[0] + static_cast<float>(rand()) / (static_cast<float>(RAND_MAX/(rangeSize[0]))),
minimum[1] + static_cast<float>(rand()) / (static_cast<float>(RAND_MAX/(rangeSize[1]))),
minimum[2] + static_cast<float>(rand()) / (static_cast<float>(RAND_MAX/(rangeSize[2])))
};
point = point + offset;
}
return true;
}
};
REGISTER_OGN_NODE()
} // namespace test
} // namespace graph
} // namespace omni
| 2,515 |
C++
| 34.436619 | 114 | 0.649304 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/nodes/OgnTestNanInfPy.py
|
"""
This node is meant to exercise data access for nan and inf values for all types in which they are valid
"""
class OgnTestNanInfPy:
@staticmethod
def compute(db) -> bool:
"""Copy the input to the output of the same name to verify assignment works"""
db.outputs.a_colord3_inf = db.inputs.a_colord3_inf
db.outputs.a_colord3_ninf = db.inputs.a_colord3_ninf
db.outputs.a_colord3_nan = db.inputs.a_colord3_nan
db.outputs.a_colord3_snan = db.inputs.a_colord3_snan
db.outputs.a_colord4_inf = db.inputs.a_colord4_inf
db.outputs.a_colord4_ninf = db.inputs.a_colord4_ninf
db.outputs.a_colord4_nan = db.inputs.a_colord4_nan
db.outputs.a_colord4_snan = db.inputs.a_colord4_snan
db.outputs.a_colord3_array_inf = db.inputs.a_colord3_array_inf
db.outputs.a_colord3_array_ninf = db.inputs.a_colord3_array_ninf
db.outputs.a_colord3_array_nan = db.inputs.a_colord3_array_nan
db.outputs.a_colord3_array_snan = db.inputs.a_colord3_array_snan
db.outputs.a_colord4_array_inf = db.inputs.a_colord4_array_inf
db.outputs.a_colord4_array_ninf = db.inputs.a_colord4_array_ninf
db.outputs.a_colord4_array_nan = db.inputs.a_colord4_array_nan
db.outputs.a_colord4_array_snan = db.inputs.a_colord4_array_snan
db.outputs.a_colorf3_inf = db.inputs.a_colorf3_inf
db.outputs.a_colorf3_ninf = db.inputs.a_colorf3_ninf
db.outputs.a_colorf3_nan = db.inputs.a_colorf3_nan
db.outputs.a_colorf3_snan = db.inputs.a_colorf3_snan
db.outputs.a_colorf4_inf = db.inputs.a_colorf4_inf
db.outputs.a_colorf4_ninf = db.inputs.a_colorf4_ninf
db.outputs.a_colorf4_nan = db.inputs.a_colorf4_nan
db.outputs.a_colorf4_snan = db.inputs.a_colorf4_snan
db.outputs.a_colorf3_array_inf = db.inputs.a_colorf3_array_inf
db.outputs.a_colorf3_array_ninf = db.inputs.a_colorf3_array_ninf
db.outputs.a_colorf3_array_nan = db.inputs.a_colorf3_array_nan
db.outputs.a_colorf3_array_snan = db.inputs.a_colorf3_array_snan
db.outputs.a_colorf4_array_inf = db.inputs.a_colorf4_array_inf
db.outputs.a_colorf4_array_ninf = db.inputs.a_colorf4_array_ninf
db.outputs.a_colorf4_array_nan = db.inputs.a_colorf4_array_nan
db.outputs.a_colorf4_array_snan = db.inputs.a_colorf4_array_snan
db.outputs.a_colorh3_inf = db.inputs.a_colorh3_inf
db.outputs.a_colorh3_ninf = db.inputs.a_colorh3_ninf
db.outputs.a_colorh3_nan = db.inputs.a_colorh3_nan
db.outputs.a_colorh3_snan = db.inputs.a_colorh3_snan
db.outputs.a_colorh4_inf = db.inputs.a_colorh4_inf
db.outputs.a_colorh4_ninf = db.inputs.a_colorh4_ninf
db.outputs.a_colorh4_nan = db.inputs.a_colorh4_nan
db.outputs.a_colorh4_snan = db.inputs.a_colorh4_snan
db.outputs.a_colorh3_array_inf = db.inputs.a_colorh3_array_inf
db.outputs.a_colorh3_array_ninf = db.inputs.a_colorh3_array_ninf
db.outputs.a_colorh3_array_nan = db.inputs.a_colorh3_array_nan
db.outputs.a_colorh3_array_snan = db.inputs.a_colorh3_array_snan
db.outputs.a_colorh4_array_inf = db.inputs.a_colorh4_array_inf
db.outputs.a_colorh4_array_ninf = db.inputs.a_colorh4_array_ninf
db.outputs.a_colorh4_array_nan = db.inputs.a_colorh4_array_nan
db.outputs.a_colorh4_array_snan = db.inputs.a_colorh4_array_snan
db.outputs.a_double_inf = db.inputs.a_double_inf
db.outputs.a_double_ninf = db.inputs.a_double_ninf
db.outputs.a_double_nan = db.inputs.a_double_nan
db.outputs.a_double_snan = db.inputs.a_double_snan
db.outputs.a_double2_inf = db.inputs.a_double2_inf
db.outputs.a_double2_ninf = db.inputs.a_double2_ninf
db.outputs.a_double2_nan = db.inputs.a_double2_nan
db.outputs.a_double2_snan = db.inputs.a_double2_snan
db.outputs.a_double3_inf = db.inputs.a_double3_inf
db.outputs.a_double3_ninf = db.inputs.a_double3_ninf
db.outputs.a_double3_nan = db.inputs.a_double3_nan
db.outputs.a_double3_snan = db.inputs.a_double3_snan
db.outputs.a_double4_inf = db.inputs.a_double4_inf
db.outputs.a_double4_ninf = db.inputs.a_double4_ninf
db.outputs.a_double4_nan = db.inputs.a_double4_nan
db.outputs.a_double4_snan = db.inputs.a_double4_snan
db.outputs.a_double_array_inf = db.inputs.a_double_array_inf
db.outputs.a_double_array_ninf = db.inputs.a_double_array_ninf
db.outputs.a_double_array_nan = db.inputs.a_double_array_nan
db.outputs.a_double_array_snan = db.inputs.a_double_array_snan
db.outputs.a_double2_array_inf = db.inputs.a_double2_array_inf
db.outputs.a_double2_array_ninf = db.inputs.a_double2_array_ninf
db.outputs.a_double2_array_nan = db.inputs.a_double2_array_nan
db.outputs.a_double2_array_snan = db.inputs.a_double2_array_snan
db.outputs.a_double3_array_inf = db.inputs.a_double3_array_inf
db.outputs.a_double3_array_ninf = db.inputs.a_double3_array_ninf
db.outputs.a_double3_array_nan = db.inputs.a_double3_array_nan
db.outputs.a_double3_array_snan = db.inputs.a_double3_array_snan
db.outputs.a_double4_array_inf = db.inputs.a_double4_array_inf
db.outputs.a_double4_array_ninf = db.inputs.a_double4_array_ninf
db.outputs.a_double4_array_nan = db.inputs.a_double4_array_nan
db.outputs.a_double4_array_snan = db.inputs.a_double4_array_snan
db.outputs.a_float_inf = db.inputs.a_float_inf
db.outputs.a_float_ninf = db.inputs.a_float_ninf
db.outputs.a_float_nan = db.inputs.a_float_nan
db.outputs.a_float_snan = db.inputs.a_float_snan
db.outputs.a_float2_inf = db.inputs.a_float2_inf
db.outputs.a_float2_ninf = db.inputs.a_float2_ninf
db.outputs.a_float2_nan = db.inputs.a_float2_nan
db.outputs.a_float2_snan = db.inputs.a_float2_snan
db.outputs.a_float3_inf = db.inputs.a_float3_inf
db.outputs.a_float3_ninf = db.inputs.a_float3_ninf
db.outputs.a_float3_nan = db.inputs.a_float3_nan
db.outputs.a_float3_snan = db.inputs.a_float3_snan
db.outputs.a_float4_inf = db.inputs.a_float4_inf
db.outputs.a_float4_ninf = db.inputs.a_float4_ninf
db.outputs.a_float4_nan = db.inputs.a_float4_nan
db.outputs.a_float4_snan = db.inputs.a_float4_snan
db.outputs.a_float_array_inf = db.inputs.a_float_array_inf
db.outputs.a_float_array_ninf = db.inputs.a_float_array_ninf
db.outputs.a_float_array_nan = db.inputs.a_float_array_nan
db.outputs.a_float_array_snan = db.inputs.a_float_array_snan
db.outputs.a_float2_array_inf = db.inputs.a_float2_array_inf
db.outputs.a_float2_array_ninf = db.inputs.a_float2_array_ninf
db.outputs.a_float2_array_nan = db.inputs.a_float2_array_nan
db.outputs.a_float2_array_snan = db.inputs.a_float2_array_snan
db.outputs.a_float3_array_inf = db.inputs.a_float3_array_inf
db.outputs.a_float3_array_ninf = db.inputs.a_float3_array_ninf
db.outputs.a_float3_array_nan = db.inputs.a_float3_array_nan
db.outputs.a_float3_array_snan = db.inputs.a_float3_array_snan
db.outputs.a_float4_array_inf = db.inputs.a_float4_array_inf
db.outputs.a_float4_array_ninf = db.inputs.a_float4_array_ninf
db.outputs.a_float4_array_nan = db.inputs.a_float4_array_nan
db.outputs.a_float4_array_snan = db.inputs.a_float4_array_snan
db.outputs.a_frame4_inf = db.inputs.a_frame4_inf
db.outputs.a_frame4_ninf = db.inputs.a_frame4_ninf
db.outputs.a_frame4_nan = db.inputs.a_frame4_nan
db.outputs.a_frame4_snan = db.inputs.a_frame4_snan
db.outputs.a_frame4_array_inf = db.inputs.a_frame4_array_inf
db.outputs.a_frame4_array_ninf = db.inputs.a_frame4_array_ninf
db.outputs.a_frame4_array_nan = db.inputs.a_frame4_array_nan
db.outputs.a_frame4_array_snan = db.inputs.a_frame4_array_snan
db.outputs.a_half_inf = db.inputs.a_half_inf
db.outputs.a_half_ninf = db.inputs.a_half_ninf
db.outputs.a_half_nan = db.inputs.a_half_nan
db.outputs.a_half_snan = db.inputs.a_half_snan
db.outputs.a_half2_inf = db.inputs.a_half2_inf
db.outputs.a_half2_ninf = db.inputs.a_half2_ninf
db.outputs.a_half2_nan = db.inputs.a_half2_nan
db.outputs.a_half2_snan = db.inputs.a_half2_snan
db.outputs.a_half3_inf = db.inputs.a_half3_inf
db.outputs.a_half3_ninf = db.inputs.a_half3_ninf
db.outputs.a_half3_nan = db.inputs.a_half3_nan
db.outputs.a_half3_snan = db.inputs.a_half3_snan
db.outputs.a_half4_inf = db.inputs.a_half4_inf
db.outputs.a_half4_ninf = db.inputs.a_half4_ninf
db.outputs.a_half4_nan = db.inputs.a_half4_nan
db.outputs.a_half4_snan = db.inputs.a_half4_snan
db.outputs.a_half_array_inf = db.inputs.a_half_array_inf
db.outputs.a_half_array_ninf = db.inputs.a_half_array_ninf
db.outputs.a_half_array_nan = db.inputs.a_half_array_nan
db.outputs.a_half_array_snan = db.inputs.a_half_array_snan
db.outputs.a_half2_array_inf = db.inputs.a_half2_array_inf
db.outputs.a_half2_array_ninf = db.inputs.a_half2_array_ninf
db.outputs.a_half2_array_nan = db.inputs.a_half2_array_nan
db.outputs.a_half2_array_snan = db.inputs.a_half2_array_snan
db.outputs.a_half3_array_inf = db.inputs.a_half3_array_inf
db.outputs.a_half3_array_ninf = db.inputs.a_half3_array_ninf
db.outputs.a_half3_array_nan = db.inputs.a_half3_array_nan
db.outputs.a_half3_array_snan = db.inputs.a_half3_array_snan
db.outputs.a_half4_array_inf = db.inputs.a_half4_array_inf
db.outputs.a_half4_array_ninf = db.inputs.a_half4_array_ninf
db.outputs.a_half4_array_nan = db.inputs.a_half4_array_nan
db.outputs.a_half4_array_snan = db.inputs.a_half4_array_snan
db.outputs.a_matrixd2_inf = db.inputs.a_matrixd2_inf
db.outputs.a_matrixd2_ninf = db.inputs.a_matrixd2_ninf
db.outputs.a_matrixd2_nan = db.inputs.a_matrixd2_nan
db.outputs.a_matrixd2_snan = db.inputs.a_matrixd2_snan
db.outputs.a_matrixd3_inf = db.inputs.a_matrixd3_inf
db.outputs.a_matrixd3_ninf = db.inputs.a_matrixd3_ninf
db.outputs.a_matrixd3_nan = db.inputs.a_matrixd3_nan
db.outputs.a_matrixd3_snan = db.inputs.a_matrixd3_snan
db.outputs.a_matrixd4_inf = db.inputs.a_matrixd4_inf
db.outputs.a_matrixd4_ninf = db.inputs.a_matrixd4_ninf
db.outputs.a_matrixd4_nan = db.inputs.a_matrixd4_nan
db.outputs.a_matrixd4_snan = db.inputs.a_matrixd4_snan
db.outputs.a_matrixd2_array_inf = db.inputs.a_matrixd2_array_inf
db.outputs.a_matrixd2_array_ninf = db.inputs.a_matrixd2_array_ninf
db.outputs.a_matrixd2_array_nan = db.inputs.a_matrixd2_array_nan
db.outputs.a_matrixd2_array_snan = db.inputs.a_matrixd2_array_snan
db.outputs.a_matrixd3_array_inf = db.inputs.a_matrixd3_array_inf
db.outputs.a_matrixd3_array_ninf = db.inputs.a_matrixd3_array_ninf
db.outputs.a_matrixd3_array_nan = db.inputs.a_matrixd3_array_nan
db.outputs.a_matrixd3_array_snan = db.inputs.a_matrixd3_array_snan
db.outputs.a_matrixd4_array_inf = db.inputs.a_matrixd4_array_inf
db.outputs.a_matrixd4_array_ninf = db.inputs.a_matrixd4_array_ninf
db.outputs.a_matrixd4_array_nan = db.inputs.a_matrixd4_array_nan
db.outputs.a_matrixd4_array_snan = db.inputs.a_matrixd4_array_snan
db.outputs.a_normald3_inf = db.inputs.a_normald3_inf
db.outputs.a_normald3_ninf = db.inputs.a_normald3_ninf
db.outputs.a_normald3_nan = db.inputs.a_normald3_nan
db.outputs.a_normald3_snan = db.inputs.a_normald3_snan
db.outputs.a_normald3_array_inf = db.inputs.a_normald3_array_inf
db.outputs.a_normald3_array_ninf = db.inputs.a_normald3_array_ninf
db.outputs.a_normald3_array_nan = db.inputs.a_normald3_array_nan
db.outputs.a_normald3_array_snan = db.inputs.a_normald3_array_snan
db.outputs.a_normalf3_inf = db.inputs.a_normalf3_inf
db.outputs.a_normalf3_ninf = db.inputs.a_normalf3_ninf
db.outputs.a_normalf3_nan = db.inputs.a_normalf3_nan
db.outputs.a_normalf3_snan = db.inputs.a_normalf3_snan
db.outputs.a_normalf3_array_inf = db.inputs.a_normalf3_array_inf
db.outputs.a_normalf3_array_ninf = db.inputs.a_normalf3_array_ninf
db.outputs.a_normalf3_array_nan = db.inputs.a_normalf3_array_nan
db.outputs.a_normalf3_array_snan = db.inputs.a_normalf3_array_snan
db.outputs.a_normalh3_inf = db.inputs.a_normalh3_inf
db.outputs.a_normalh3_ninf = db.inputs.a_normalh3_ninf
db.outputs.a_normalh3_nan = db.inputs.a_normalh3_nan
db.outputs.a_normalh3_snan = db.inputs.a_normalh3_snan
db.outputs.a_normalh3_array_inf = db.inputs.a_normalh3_array_inf
db.outputs.a_normalh3_array_ninf = db.inputs.a_normalh3_array_ninf
db.outputs.a_normalh3_array_nan = db.inputs.a_normalh3_array_nan
db.outputs.a_normalh3_array_snan = db.inputs.a_normalh3_array_snan
db.outputs.a_pointd3_inf = db.inputs.a_pointd3_inf
db.outputs.a_pointd3_ninf = db.inputs.a_pointd3_ninf
db.outputs.a_pointd3_nan = db.inputs.a_pointd3_nan
db.outputs.a_pointd3_snan = db.inputs.a_pointd3_snan
db.outputs.a_pointd3_array_inf = db.inputs.a_pointd3_array_inf
db.outputs.a_pointd3_array_ninf = db.inputs.a_pointd3_array_ninf
db.outputs.a_pointd3_array_nan = db.inputs.a_pointd3_array_nan
db.outputs.a_pointd3_array_snan = db.inputs.a_pointd3_array_snan
db.outputs.a_pointf3_inf = db.inputs.a_pointf3_inf
db.outputs.a_pointf3_ninf = db.inputs.a_pointf3_ninf
db.outputs.a_pointf3_nan = db.inputs.a_pointf3_nan
db.outputs.a_pointf3_snan = db.inputs.a_pointf3_snan
db.outputs.a_pointf3_array_inf = db.inputs.a_pointf3_array_inf
db.outputs.a_pointf3_array_ninf = db.inputs.a_pointf3_array_ninf
db.outputs.a_pointf3_array_nan = db.inputs.a_pointf3_array_nan
db.outputs.a_pointf3_array_snan = db.inputs.a_pointf3_array_snan
db.outputs.a_pointh3_inf = db.inputs.a_pointh3_inf
db.outputs.a_pointh3_ninf = db.inputs.a_pointh3_ninf
db.outputs.a_pointh3_nan = db.inputs.a_pointh3_nan
db.outputs.a_pointh3_snan = db.inputs.a_pointh3_snan
db.outputs.a_pointh3_array_inf = db.inputs.a_pointh3_array_inf
db.outputs.a_pointh3_array_ninf = db.inputs.a_pointh3_array_ninf
db.outputs.a_pointh3_array_nan = db.inputs.a_pointh3_array_nan
db.outputs.a_pointh3_array_snan = db.inputs.a_pointh3_array_snan
db.outputs.a_quatd4_inf = db.inputs.a_quatd4_inf
db.outputs.a_quatd4_ninf = db.inputs.a_quatd4_ninf
db.outputs.a_quatd4_nan = db.inputs.a_quatd4_nan
db.outputs.a_quatd4_snan = db.inputs.a_quatd4_snan
db.outputs.a_quatd4_array_inf = db.inputs.a_quatd4_array_inf
db.outputs.a_quatd4_array_ninf = db.inputs.a_quatd4_array_ninf
db.outputs.a_quatd4_array_nan = db.inputs.a_quatd4_array_nan
db.outputs.a_quatd4_array_snan = db.inputs.a_quatd4_array_snan
db.outputs.a_quatf4_inf = db.inputs.a_quatf4_inf
db.outputs.a_quatf4_ninf = db.inputs.a_quatf4_ninf
db.outputs.a_quatf4_nan = db.inputs.a_quatf4_nan
db.outputs.a_quatf4_snan = db.inputs.a_quatf4_snan
db.outputs.a_quatf4_array_inf = db.inputs.a_quatf4_array_inf
db.outputs.a_quatf4_array_ninf = db.inputs.a_quatf4_array_ninf
db.outputs.a_quatf4_array_nan = db.inputs.a_quatf4_array_nan
db.outputs.a_quatf4_array_snan = db.inputs.a_quatf4_array_snan
db.outputs.a_quath4_inf = db.inputs.a_quath4_inf
db.outputs.a_quath4_ninf = db.inputs.a_quath4_ninf
db.outputs.a_quath4_nan = db.inputs.a_quath4_nan
db.outputs.a_quath4_snan = db.inputs.a_quath4_snan
db.outputs.a_quath4_array_inf = db.inputs.a_quath4_array_inf
db.outputs.a_quath4_array_ninf = db.inputs.a_quath4_array_ninf
db.outputs.a_quath4_array_nan = db.inputs.a_quath4_array_nan
db.outputs.a_quath4_array_snan = db.inputs.a_quath4_array_snan
db.outputs.a_texcoordd2_inf = db.inputs.a_texcoordd2_inf
db.outputs.a_texcoordd2_ninf = db.inputs.a_texcoordd2_ninf
db.outputs.a_texcoordd2_nan = db.inputs.a_texcoordd2_nan
db.outputs.a_texcoordd2_snan = db.inputs.a_texcoordd2_snan
db.outputs.a_texcoordd3_inf = db.inputs.a_texcoordd3_inf
db.outputs.a_texcoordd3_ninf = db.inputs.a_texcoordd3_ninf
db.outputs.a_texcoordd3_nan = db.inputs.a_texcoordd3_nan
db.outputs.a_texcoordd3_snan = db.inputs.a_texcoordd3_snan
db.outputs.a_texcoordd2_array_inf = db.inputs.a_texcoordd2_array_inf
db.outputs.a_texcoordd2_array_ninf = db.inputs.a_texcoordd2_array_ninf
db.outputs.a_texcoordd2_array_nan = db.inputs.a_texcoordd2_array_nan
db.outputs.a_texcoordd2_array_snan = db.inputs.a_texcoordd2_array_snan
db.outputs.a_texcoordd3_array_inf = db.inputs.a_texcoordd3_array_inf
db.outputs.a_texcoordd3_array_ninf = db.inputs.a_texcoordd3_array_ninf
db.outputs.a_texcoordd3_array_nan = db.inputs.a_texcoordd3_array_nan
db.outputs.a_texcoordd3_array_snan = db.inputs.a_texcoordd3_array_snan
db.outputs.a_texcoordf2_inf = db.inputs.a_texcoordf2_inf
db.outputs.a_texcoordf2_ninf = db.inputs.a_texcoordf2_ninf
db.outputs.a_texcoordf2_nan = db.inputs.a_texcoordf2_nan
db.outputs.a_texcoordf2_snan = db.inputs.a_texcoordf2_snan
db.outputs.a_texcoordf3_inf = db.inputs.a_texcoordf3_inf
db.outputs.a_texcoordf3_ninf = db.inputs.a_texcoordf3_ninf
db.outputs.a_texcoordf3_nan = db.inputs.a_texcoordf3_nan
db.outputs.a_texcoordf3_snan = db.inputs.a_texcoordf3_snan
db.outputs.a_texcoordf2_array_inf = db.inputs.a_texcoordf2_array_inf
db.outputs.a_texcoordf2_array_ninf = db.inputs.a_texcoordf2_array_ninf
db.outputs.a_texcoordf2_array_nan = db.inputs.a_texcoordf2_array_nan
db.outputs.a_texcoordf2_array_snan = db.inputs.a_texcoordf2_array_snan
db.outputs.a_texcoordf3_array_inf = db.inputs.a_texcoordf3_array_inf
db.outputs.a_texcoordf3_array_ninf = db.inputs.a_texcoordf3_array_ninf
db.outputs.a_texcoordf3_array_nan = db.inputs.a_texcoordf3_array_nan
db.outputs.a_texcoordf3_array_snan = db.inputs.a_texcoordf3_array_snan
db.outputs.a_texcoordh2_inf = db.inputs.a_texcoordh2_inf
db.outputs.a_texcoordh2_ninf = db.inputs.a_texcoordh2_ninf
db.outputs.a_texcoordh2_nan = db.inputs.a_texcoordh2_nan
db.outputs.a_texcoordh2_snan = db.inputs.a_texcoordh2_snan
db.outputs.a_texcoordh3_inf = db.inputs.a_texcoordh3_inf
db.outputs.a_texcoordh3_ninf = db.inputs.a_texcoordh3_ninf
db.outputs.a_texcoordh3_nan = db.inputs.a_texcoordh3_nan
db.outputs.a_texcoordh3_snan = db.inputs.a_texcoordh3_snan
db.outputs.a_texcoordh2_array_inf = db.inputs.a_texcoordh2_array_inf
db.outputs.a_texcoordh2_array_ninf = db.inputs.a_texcoordh2_array_ninf
db.outputs.a_texcoordh2_array_nan = db.inputs.a_texcoordh2_array_nan
db.outputs.a_texcoordh2_array_snan = db.inputs.a_texcoordh2_array_snan
db.outputs.a_texcoordh3_array_inf = db.inputs.a_texcoordh3_array_inf
db.outputs.a_texcoordh3_array_ninf = db.inputs.a_texcoordh3_array_ninf
db.outputs.a_texcoordh3_array_nan = db.inputs.a_texcoordh3_array_nan
db.outputs.a_texcoordh3_array_snan = db.inputs.a_texcoordh3_array_snan
db.outputs.a_timecode_inf = db.inputs.a_timecode_inf
db.outputs.a_timecode_ninf = db.inputs.a_timecode_ninf
db.outputs.a_timecode_nan = db.inputs.a_timecode_nan
db.outputs.a_timecode_snan = db.inputs.a_timecode_snan
db.outputs.a_timecode_array_inf = db.inputs.a_timecode_array_inf
db.outputs.a_timecode_array_ninf = db.inputs.a_timecode_array_ninf
db.outputs.a_timecode_array_nan = db.inputs.a_timecode_array_nan
db.outputs.a_timecode_array_snan = db.inputs.a_timecode_array_snan
db.outputs.a_vectord3_inf = db.inputs.a_vectord3_inf
db.outputs.a_vectord3_ninf = db.inputs.a_vectord3_ninf
db.outputs.a_vectord3_nan = db.inputs.a_vectord3_nan
db.outputs.a_vectord3_snan = db.inputs.a_vectord3_snan
db.outputs.a_vectord3_array_inf = db.inputs.a_vectord3_array_inf
db.outputs.a_vectord3_array_ninf = db.inputs.a_vectord3_array_ninf
db.outputs.a_vectord3_array_nan = db.inputs.a_vectord3_array_nan
db.outputs.a_vectord3_array_snan = db.inputs.a_vectord3_array_snan
db.outputs.a_vectorf3_inf = db.inputs.a_vectorf3_inf
db.outputs.a_vectorf3_ninf = db.inputs.a_vectorf3_ninf
db.outputs.a_vectorf3_nan = db.inputs.a_vectorf3_nan
db.outputs.a_vectorf3_snan = db.inputs.a_vectorf3_snan
db.outputs.a_vectorf3_array_inf = db.inputs.a_vectorf3_array_inf
db.outputs.a_vectorf3_array_ninf = db.inputs.a_vectorf3_array_ninf
db.outputs.a_vectorf3_array_nan = db.inputs.a_vectorf3_array_nan
db.outputs.a_vectorf3_array_snan = db.inputs.a_vectorf3_array_snan
db.outputs.a_vectorh3_inf = db.inputs.a_vectorh3_inf
db.outputs.a_vectorh3_ninf = db.inputs.a_vectorh3_ninf
db.outputs.a_vectorh3_nan = db.inputs.a_vectorh3_nan
db.outputs.a_vectorh3_snan = db.inputs.a_vectorh3_snan
db.outputs.a_vectorh3_array_inf = db.inputs.a_vectorh3_array_inf
db.outputs.a_vectorh3_array_ninf = db.inputs.a_vectorh3_array_ninf
db.outputs.a_vectorh3_array_nan = db.inputs.a_vectorh3_array_nan
db.outputs.a_vectorh3_array_snan = db.inputs.a_vectorh3_array_snan
return True
| 22,166 |
Python
| 51.528436 | 103 | 0.681404 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/nodes/OgnBundleConsumerPy.py
|
"""
This node is designed to consume input bundle and test bundle change tracking.
"""
class OgnBundleConsumerPy:
@staticmethod
def compute(db) -> bool:
with db.inputs.bundle.changes() as bundle_changes:
if bundle_changes:
db.outputs.bundle = db.inputs.bundle
db.outputs.hasOutputBundleChanged = True
else:
db.outputs.hasOutputBundleChanged = False
return True
| 460 |
Python
| 26.117646 | 78 | 0.621739 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/nodes/OgnTestExecutionTask.cpp
|
// 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.
//
#include <OgnTestExecutionTaskDatabase.h>
#include <omni/graph/exec/unstable/ExecutionTask.h>
#include <cstdlib>
// This is the implementation of the OGN node defined in OgnTestExecutionTask.ogn
namespace omni {
namespace graph {
namespace test {
class OgnTestExecutionTask
{
public:
static bool compute(OgnTestExecutionTaskDatabase& db)
{
auto& result = db.outputs.result();
if (exec::unstable::getCurrentTask())
result = true;
else
result = false;
return true;
}
};
REGISTER_OGN_NODE()
} // test
} // namespace graph
} // namespace omni
| 1,048 |
C++
| 25.897435 | 81 | 0.722328 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/nodes/OgnRandomPointsGpu.cpp
|
// Copyright (c) 2021 NVIDIA CORPORATION. All rights reserved.
//
// NVIDIA CORPORATION and its licensors retain all intellectual property
// and proprietary rights in and to this software, related documentation
// and any modifications thereto. Any use, reproduction, disclosure or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA CORPORATION is strictly prohibited.
//
#include <OgnRandomPointsGpuDatabase.h>
#include <cstdlib>
// This is the implementation of the OGN node defined in OgnRandomPointsGpu.ogn
namespace omni {
namespace graph {
namespace test {
extern "C"
void generateGpu(
outputs::points_t outputPoints,
inputs::minimum_t minimum,
inputs::maximum_t maximum,
size_t numberOfPoints);
class OgnRandomPointsGpu
{
public:
// Create an array of "pointCount" points at random locations within the bounding cube,
// delineated by the corner points "minimum" and "maximum".
static bool compute(OgnRandomPointsGpuDatabase& db)
{
// No points mean nothing to generate
const auto& pointCount = db.inputs.pointCount();
if (pointCount == 0)
{
return true;
}
CARB_PROFILE_ZONE(carb::profiler::kCaptureMaskDefault, "Generating Data");
db.outputs.points.resize(pointCount);
generateGpu(db.outputs.points(), db.inputs.minimum(), db.inputs.maximum(), pointCount);
return true;
}
};
REGISTER_OGN_NODE()
} // test
} // namespace graph
} // namespace omni
| 1,545 |
C++
| 28.730769 | 95 | 0.710032 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/nodes/OgnBundleChildConsumerPy.py
|
"""
This node is designed to consume shallow copied child from the bundle child
producer.
"""
class OgnBundleChildConsumerPy:
@staticmethod
def compute(db) -> bool:
input_bundle = db.inputs.bundle
db.outputs.numChildren = input_bundle.bundle.get_child_bundle_count()
surfaces_bundle = input_bundle.bundle.get_child_bundle_by_name("surfaces")
if surfaces_bundle.is_valid():
db.outputs.numSurfaces = surfaces_bundle.get_child_bundle_count()
else:
db.outputs.numSurfaces = 0
| 547 |
Python
| 29.444443 | 82 | 0.674589 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/nodes/OgnTestAllDataTypesCarb.cpp
|
// Copyright (c) 2021 NVIDIA CORPORATION. All rights reserved.
//
// NVIDIA CORPORATION and its licensors retain all intellectual property
// and proprietary rights in and to this software, related documentation
// and any modifications thereto. Any use, reproduction, disclosure or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA CORPORATION is strictly prohibited.
//
#include <OgnTestAllDataTypesCarbDatabase.h>
namespace omni {
namespace graph {
using core::ogn::array;
using core::ogn::const_array;
using core::ogn::string;
using core::ogn::const_string;
namespace test {
// Helper template that reduces the testing code while hardcoding to the expected types.
// This version is for types that are directly assignable.
template <typename DataType, typename ConstDataType, typename std::enable_if_t<std::is_assignable<DataType, ConstDataType>::value, int> = 0>
void assign(DataType& dst, ConstDataType& src)
{
dst = src;
}
// This version is for types that cannot be assigned. memcpy works for them since we require types to be byte-compatible
template <typename DataType, typename ConstDataType, typename std::enable_if_t<! std::is_assignable<DataType, ConstDataType>::value, int> = 0>
void assign(DataType& dst, ConstDataType& src)
{
memcpy(&dst, &src, sizeof(DataType));
}
class OgnTestAllDataTypesCarb
{
public:
static bool compute(OgnTestAllDataTypesCarbDatabase& db)
{
if (db.inputs.doNotCompute())
{
return true;
}
assign<bool, const bool>(db.outputs.a_bool(), db.inputs.a_bool());
assign<array<bool>, const const_array<bool>>(db.outputs.a_bool_array(), db.inputs.a_bool_array());
assign<carb::ColorRgbDouble, const carb::ColorRgbDouble>(db.outputs.a_colord_3(), db.inputs.a_colord_3());
assign<carb::ColorRgbaDouble, const carb::ColorRgbaDouble>(db.outputs.a_colord_4(), db.inputs.a_colord_4());
assign<carb::ColorRgb, const carb::ColorRgb>(db.outputs.a_colorf_3(), db.inputs.a_colorf_3());
assign<carb::ColorRgba, const carb::ColorRgba>(db.outputs.a_colorf_4(), db.inputs.a_colorf_4());
assign<pxr::GfVec3h, const pxr::GfVec3h>(db.outputs.a_colorh_3(), db.inputs.a_colorh_3());
assign<pxr::GfVec4h, const pxr::GfVec4h>(db.outputs.a_colorh_4(), db.inputs.a_colorh_4());
assign<array<carb::ColorRgbDouble>, const const_array<carb::ColorRgbDouble>>(db.outputs.a_colord_3_array(), db.inputs.a_colord_3_array());
assign<array<carb::ColorRgbaDouble>, const const_array<carb::ColorRgbaDouble>>(db.outputs.a_colord_4_array(), db.inputs.a_colord_4_array());
assign<array<carb::ColorRgb>, const const_array<carb::ColorRgb>>(db.outputs.a_colorf_3_array(), db.inputs.a_colorf_3_array());
assign<array<carb::ColorRgba>, const const_array<carb::ColorRgba>>(db.outputs.a_colorf_4_array(), db.inputs.a_colorf_4_array());
assign<array<pxr::GfVec3h>, const const_array<pxr::GfVec3h>>(db.outputs.a_colorh_3_array(), db.inputs.a_colorh_3_array());
assign<array<pxr::GfVec4h>, const const_array<pxr::GfVec4h>>(db.outputs.a_colorh_4_array(), db.inputs.a_colorh_4_array());
assign<double, const double>(db.outputs.a_double(), db.inputs.a_double());
assign<carb::Double2, const carb::Double2>(db.outputs.a_double_2(), db.inputs.a_double_2());
assign<carb::Double3, const carb::Double3>(db.outputs.a_double_3(), db.inputs.a_double_3());
assign<carb::Double4, const carb::Double4>(db.outputs.a_double_4(), db.inputs.a_double_4());
assign<array<double>, const const_array<double>>(db.outputs.a_double_array(), db.inputs.a_double_array());
assign<array<carb::Double2>, const const_array<carb::Double2>>(db.outputs.a_double_2_array(), db.inputs.a_double_2_array());
assign<array<carb::Double3>, const const_array<carb::Double3>>(db.outputs.a_double_3_array(), db.inputs.a_double_3_array());
assign<array<carb::Double4>, const const_array<carb::Double4>>(db.outputs.a_double_4_array(), db.inputs.a_double_4_array());
assign<uint32_t, const uint32_t>(db.outputs.a_execution(), db.inputs.a_execution());
assign<float, const float>(db.outputs.a_float(), db.inputs.a_float());
assign<carb::Float2, const carb::Float2>(db.outputs.a_float_2(), db.inputs.a_float_2());
assign<carb::Float3, const carb::Float3>(db.outputs.a_float_3(), db.inputs.a_float_3());
assign<carb::Float4, const carb::Float4>(db.outputs.a_float_4(), db.inputs.a_float_4());
assign<array<float>, const const_array<float>>(db.outputs.a_float_array(), db.inputs.a_float_array());
assign<array<carb::Float2>, const const_array<carb::Float2>>(db.outputs.a_float_2_array(), db.inputs.a_float_2_array());
assign<array<carb::Float3>, const const_array<carb::Float3>>(db.outputs.a_float_3_array(), db.inputs.a_float_3_array());
assign<array<carb::Float4>, const const_array<carb::Float4>>(db.outputs.a_float_4_array(), db.inputs.a_float_4_array());
assign<pxr::GfMatrix4d, const pxr::GfMatrix4d>(db.outputs.a_frame_4(), db.inputs.a_frame_4());
assign<array<pxr::GfMatrix4d>, const const_array<pxr::GfMatrix4d>>(db.outputs.a_frame_4_array(), db.inputs.a_frame_4_array());
assign<pxr::GfHalf, const pxr::GfHalf>(db.outputs.a_half(), db.inputs.a_half());
assign<pxr::GfVec2h, const pxr::GfVec2h>(db.outputs.a_half_2(), db.inputs.a_half_2());
assign<pxr::GfVec3h, const pxr::GfVec3h>(db.outputs.a_half_3(), db.inputs.a_half_3());
assign<pxr::GfVec4h, const pxr::GfVec4h>(db.outputs.a_half_4(), db.inputs.a_half_4());
assign<array<pxr::GfHalf>, const const_array<pxr::GfHalf>>(db.outputs.a_half_array(), db.inputs.a_half_array());
assign<array<pxr::GfVec2h>, const const_array<pxr::GfVec2h>>(db.outputs.a_half_2_array(), db.inputs.a_half_2_array());
assign<array<pxr::GfVec3h>, const const_array<pxr::GfVec3h>>(db.outputs.a_half_3_array(), db.inputs.a_half_3_array());
assign<array<pxr::GfVec4h>, const const_array<pxr::GfVec4h>>(db.outputs.a_half_4_array(), db.inputs.a_half_4_array());
assign<int, const int>(db.outputs.a_int(), db.inputs.a_int());
assign<carb::Int2, const carb::Int2>(db.outputs.a_int_2(), db.inputs.a_int_2());
assign<carb::Int3, const carb::Int3>(db.outputs.a_int_3(), db.inputs.a_int_3());
assign<carb::Int4, const carb::Int4>(db.outputs.a_int_4(), db.inputs.a_int_4());
assign<array<int>, const const_array<int>>(db.outputs.a_int_array(), db.inputs.a_int_array());
assign<array<carb::Int2>, const const_array<carb::Int2>>(db.outputs.a_int_2_array(), db.inputs.a_int_2_array());
assign<array<carb::Int3>, const const_array<carb::Int3>>(db.outputs.a_int_3_array(), db.inputs.a_int_3_array());
assign<array<carb::Int4>, const const_array<carb::Int4>>(db.outputs.a_int_4_array(), db.inputs.a_int_4_array());
assign<int64_t, const int64_t>(db.outputs.a_int64(), db.inputs.a_int64());
assign<array<int64_t>, const const_array<int64_t>>(db.outputs.a_int64_array(), db.inputs.a_int64_array());
assign<pxr::GfMatrix2d, const pxr::GfMatrix2d>(db.outputs.a_matrixd_2(), db.inputs.a_matrixd_2());
assign<pxr::GfMatrix3d, const pxr::GfMatrix3d>(db.outputs.a_matrixd_3(), db.inputs.a_matrixd_3());
assign<pxr::GfMatrix4d, const pxr::GfMatrix4d>(db.outputs.a_matrixd_4(), db.inputs.a_matrixd_4());
assign<array<pxr::GfMatrix2d>, const const_array<pxr::GfMatrix2d>>(db.outputs.a_matrixd_2_array(), db.inputs.a_matrixd_2_array());
assign<array<pxr::GfMatrix3d>, const const_array<pxr::GfMatrix3d>>(db.outputs.a_matrixd_3_array(), db.inputs.a_matrixd_3_array());
assign<array<pxr::GfMatrix4d>, const const_array<pxr::GfMatrix4d>>(db.outputs.a_matrixd_4_array(), db.inputs.a_matrixd_4_array());
assign<carb::Double3, const carb::Double3>(db.outputs.a_normald_3(), db.inputs.a_normald_3());
assign<carb::Float3, const carb::Float3>(db.outputs.a_normalf_3(), db.inputs.a_normalf_3());
assign<pxr::GfVec3h, const pxr::GfVec3h>(db.outputs.a_normalh_3(), db.inputs.a_normalh_3());
assign<array<carb::Double3>, const const_array<carb::Double3>>(db.outputs.a_normald_3_array(), db.inputs.a_normald_3_array());
assign<array<carb::Float3>, const const_array<carb::Float3>>(db.outputs.a_normalf_3_array(), db.inputs.a_normalf_3_array());
assign<array<pxr::GfVec3h>, const const_array<pxr::GfVec3h>>(db.outputs.a_normalh_3_array(), db.inputs.a_normalh_3_array());
assign<uint64_t, const uint64_t>(db.outputs.a_objectId(), db.inputs.a_objectId());
assign<array<uint64_t>, const const_array<uint64_t>>(db.outputs.a_objectId_array(), db.inputs.a_objectId_array());
assign<carb::Double3, const carb::Double3>(db.outputs.a_pointd_3(), db.inputs.a_pointd_3());
assign<carb::Float3, const carb::Float3>(db.outputs.a_pointf_3(), db.inputs.a_pointf_3());
assign<pxr::GfVec3h, const pxr::GfVec3h>(db.outputs.a_pointh_3(), db.inputs.a_pointh_3());
assign<array<carb::Double3>, const const_array<carb::Double3>>(db.outputs.a_pointd_3_array(), db.inputs.a_pointd_3_array());
assign<array<carb::Float3>, const const_array<carb::Float3>>(db.outputs.a_pointf_3_array(), db.inputs.a_pointf_3_array());
assign<array<pxr::GfVec3h>, const const_array<pxr::GfVec3h>>(db.outputs.a_pointh_3_array(), db.inputs.a_pointh_3_array());
assign<carb::Double4, const carb::Double4>(db.outputs.a_quatd_4(), db.inputs.a_quatd_4());
assign<carb::Float4, const carb::Float4>(db.outputs.a_quatf_4(), db.inputs.a_quatf_4());
assign<pxr::GfQuath, const pxr::GfQuath>(db.outputs.a_quath_4(), db.inputs.a_quath_4());
assign<array<carb::Double4>, const const_array<carb::Double4>>(db.outputs.a_quatd_4_array(), db.inputs.a_quatd_4_array());
assign<array<carb::Float4>, const const_array<carb::Float4>>(db.outputs.a_quatf_4_array(), db.inputs.a_quatf_4_array());
assign<array<pxr::GfQuath>, const const_array<pxr::GfQuath>>(db.outputs.a_quath_4_array(), db.inputs.a_quath_4_array());
assign<string, const const_string>(db.outputs.a_string(), db.inputs.a_string());
assign<carb::Double2, const carb::Double2>(db.outputs.a_texcoordd_2(), db.inputs.a_texcoordd_2());
assign<carb::Double3, const carb::Double3>(db.outputs.a_texcoordd_3(), db.inputs.a_texcoordd_3());
assign<carb::Float2, const carb::Float2>(db.outputs.a_texcoordf_2(), db.inputs.a_texcoordf_2());
assign<carb::Float3, const carb::Float3>(db.outputs.a_texcoordf_3(), db.inputs.a_texcoordf_3());
assign<pxr::GfVec2h, const pxr::GfVec2h>(db.outputs.a_texcoordh_2(), db.inputs.a_texcoordh_2());
assign<pxr::GfVec3h, const pxr::GfVec3h>(db.outputs.a_texcoordh_3(), db.inputs.a_texcoordh_3());
assign<array<carb::Double2>, const const_array<carb::Double2>>(db.outputs.a_texcoordd_2_array(), db.inputs.a_texcoordd_2_array());
assign<array<carb::Double3>, const const_array<carb::Double3>>(db.outputs.a_texcoordd_3_array(), db.inputs.a_texcoordd_3_array());
assign<array<carb::Float2>, const const_array<carb::Float2>>(db.outputs.a_texcoordf_2_array(), db.inputs.a_texcoordf_2_array());
assign<array<carb::Float3>, const const_array<carb::Float3>>(db.outputs.a_texcoordf_3_array(), db.inputs.a_texcoordf_3_array());
assign<array<pxr::GfVec2h>, const const_array<pxr::GfVec2h>>(db.outputs.a_texcoordh_2_array(), db.inputs.a_texcoordh_2_array());
assign<array<pxr::GfVec3h>, const const_array<pxr::GfVec3h>>(db.outputs.a_texcoordh_3_array(), db.inputs.a_texcoordh_3_array());
assign<pxr::SdfTimeCode, const pxr::SdfTimeCode>(db.outputs.a_timecode(), db.inputs.a_timecode());
assign<array<pxr::SdfTimeCode>, const const_array<pxr::SdfTimeCode>>(db.outputs.a_timecode_array(), db.inputs.a_timecode_array());
assign<NameToken, const NameToken>(db.outputs.a_token(), db.inputs.a_token());
assign<array<NameToken>, const const_array<NameToken>>(db.outputs.a_token_array(), db.inputs.a_token_array());
assign<uint8_t, const uint8_t>(db.outputs.a_uchar(), db.inputs.a_uchar());
assign<array<uint8_t>, const const_array<uint8_t>>(db.outputs.a_uchar_array(), db.inputs.a_uchar_array());
assign<uint32_t, const uint32_t>(db.outputs.a_uint(), db.inputs.a_uint());
assign<array<uint32_t>, const const_array<uint32_t>>(db.outputs.a_uint_array(), db.inputs.a_uint_array());
assign<uint64_t, const uint64_t>(db.outputs.a_uint64(), db.inputs.a_uint64());
assign<array<uint64_t>, const const_array<uint64_t>>(db.outputs.a_uint64_array(), db.inputs.a_uint64_array());
assign<carb::Double3, const carb::Double3>(db.outputs.a_vectord_3(), db.inputs.a_vectord_3());
assign<carb::Float3, const carb::Float3>(db.outputs.a_vectorf_3(), db.inputs.a_vectorf_3());
assign<pxr::GfVec3h, const pxr::GfVec3h>(db.outputs.a_vectorh_3(), db.inputs.a_vectorh_3());
assign<array<carb::Double3>, const const_array<carb::Double3>>(db.outputs.a_vectord_3_array(), db.inputs.a_vectord_3_array());
assign<array<carb::Float3>, const const_array<carb::Float3>>(db.outputs.a_vectorf_3_array(), db.inputs.a_vectorf_3_array());
assign<array<pxr::GfVec3h>, const const_array<pxr::GfVec3h>>(db.outputs.a_vectorh_3_array(), db.inputs.a_vectorh_3_array());
return true;
}
};
REGISTER_OGN_NODE()
} // namespace test
} // namespace graph
} // namespace omni
| 13,653 |
C++
| 74.855555 | 148 | 0.676701 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/nodes/OgnMultiply2IntArray.cpp
|
// Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved.
//
// NVIDIA CORPORATION and its licensors retain all intellectual property
// and proprietary rights in and to this software, related documentation
// and any modifications thereto. Any use, reproduction, disclosure or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA CORPORATION is strictly prohibited.
//
#include <OgnMultiply2IntArrayDatabase.h>
#include <algorithm>
class OgnMultiply2IntArray
{
public:
static bool compute(OgnMultiply2IntArrayDatabase& db)
{
auto a = db.inputs.a();
auto b = db.inputs.b();
auto output = db.outputs.output();
// If either array has only a single member that value will multiply all members of the other array.
// The case when both have size 1 is handled by the first "if".
if (a.size() == 1)
{
output = b;
std::for_each(output.begin(), output.end(), [a](int& value) { value *= a[0]; });
}
else if (b.size() == 1)
{
output = a;
std::for_each(output.begin(), output.end(), [b](int& value) { value *= b[0]; });
}
else
{
output.resize(a.size());
std::transform(a.begin(), a.end(), b.begin(), output.begin(), std::multiplies<int>());
}
return true;
}
};
REGISTER_OGN_NODE()
| 1,442 |
C++
| 32.558139 | 108 | 0.610264 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/nodes/OgnTestAllDataTypes.cpp
|
// Copyright (c) 2021 NVIDIA CORPORATION. All rights reserved.
//
// NVIDIA CORPORATION and its licensors retain all intellectual property
// and proprietary rights in and to this software, related documentation
// and any modifications thereto. Any use, reproduction, disclosure or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA CORPORATION is strictly prohibited.
//
#include <OgnTestAllDataTypesDatabase.h>
namespace omni {
namespace graph {
namespace test {
class OgnTestAllDataTypes
{
public:
static bool compute(OgnTestAllDataTypesDatabase& db)
{
if (db.inputs.doNotCompute())
{
return true;
}
db.outputs.a_bool() = db.inputs.a_bool();
db.outputs.a_bool_array() = db.inputs.a_bool_array();
db.outputs.a_colord_3() = db.inputs.a_colord_3();
db.outputs.a_colord_4() = db.inputs.a_colord_4();
db.outputs.a_colorf_3() = db.inputs.a_colorf_3();
db.outputs.a_colorf_4() = db.inputs.a_colorf_4();
db.outputs.a_colorh_3() = db.inputs.a_colorh_3();
db.outputs.a_colorh_4() = db.inputs.a_colorh_4();
db.outputs.a_colord_3_array() = db.inputs.a_colord_3_array();
db.outputs.a_colord_4_array() = db.inputs.a_colord_4_array();
db.outputs.a_colorf_3_array() = db.inputs.a_colorf_3_array();
db.outputs.a_colorf_4_array() = db.inputs.a_colorf_4_array();
db.outputs.a_colorh_3_array() = db.inputs.a_colorh_3_array();
db.outputs.a_colorh_4_array() = db.inputs.a_colorh_4_array();
db.outputs.a_double() = db.inputs.a_double();
db.outputs.a_double_2() = db.inputs.a_double_2();
db.outputs.a_double_3() = db.inputs.a_double_3();
db.outputs.a_double_4() = db.inputs.a_double_4();
db.outputs.a_double_array() = db.inputs.a_double_array();
db.outputs.a_double_2_array() = db.inputs.a_double_2_array();
db.outputs.a_double_3_array() = db.inputs.a_double_3_array();
db.outputs.a_double_4_array() = db.inputs.a_double_4_array();
db.outputs.a_execution() = db.inputs.a_execution();
db.outputs.a_float() = db.inputs.a_float();
db.outputs.a_float_2() = db.inputs.a_float_2();
db.outputs.a_float_3() = db.inputs.a_float_3();
db.outputs.a_float_4() = db.inputs.a_float_4();
db.outputs.a_float_array() = db.inputs.a_float_array();
db.outputs.a_float_2_array() = db.inputs.a_float_2_array();
db.outputs.a_float_3_array() = db.inputs.a_float_3_array();
db.outputs.a_float_4_array() = db.inputs.a_float_4_array();
db.outputs.a_frame_4() = db.inputs.a_frame_4();
db.outputs.a_frame_4_array() = db.inputs.a_frame_4_array();
db.outputs.a_half() = db.inputs.a_half();
db.outputs.a_half_2() = db.inputs.a_half_2();
db.outputs.a_half_3() = db.inputs.a_half_3();
db.outputs.a_half_4() = db.inputs.a_half_4();
db.outputs.a_half_array() = db.inputs.a_half_array();
db.outputs.a_half_2_array() = db.inputs.a_half_2_array();
db.outputs.a_half_3_array() = db.inputs.a_half_3_array();
db.outputs.a_half_4_array() = db.inputs.a_half_4_array();
db.outputs.a_int() = db.inputs.a_int();
db.outputs.a_int_2() = db.inputs.a_int_2();
db.outputs.a_int_3() = db.inputs.a_int_3();
db.outputs.a_int_4() = db.inputs.a_int_4();
db.outputs.a_int_array() = db.inputs.a_int_array();
db.outputs.a_int_2_array() = db.inputs.a_int_2_array();
db.outputs.a_int_3_array() = db.inputs.a_int_3_array();
db.outputs.a_int_4_array() = db.inputs.a_int_4_array();
db.outputs.a_int64() = db.inputs.a_int64();
db.outputs.a_int64_array() = db.inputs.a_int64_array();
db.outputs.a_matrixd_2() = db.inputs.a_matrixd_2();
db.outputs.a_matrixd_3() = db.inputs.a_matrixd_3();
db.outputs.a_matrixd_4() = db.inputs.a_matrixd_4();
db.outputs.a_matrixd_2_array() = db.inputs.a_matrixd_2_array();
db.outputs.a_matrixd_3_array() = db.inputs.a_matrixd_3_array();
db.outputs.a_matrixd_4_array() = db.inputs.a_matrixd_4_array();
db.outputs.a_normald_3() = db.inputs.a_normald_3();
db.outputs.a_normalf_3() = db.inputs.a_normalf_3();
db.outputs.a_normalh_3() = db.inputs.a_normalh_3();
db.outputs.a_normald_3_array() = db.inputs.a_normald_3_array();
db.outputs.a_normalf_3_array() = db.inputs.a_normalf_3_array();
db.outputs.a_normalh_3_array() = db.inputs.a_normalh_3_array();
db.outputs.a_objectId() = db.inputs.a_objectId();
db.outputs.a_objectId_array() = db.inputs.a_objectId_array();
db.outputs.a_path() = db.inputs.a_path();
db.outputs.a_pointd_3() = db.inputs.a_pointd_3();
db.outputs.a_pointf_3() = db.inputs.a_pointf_3();
db.outputs.a_pointh_3() = db.inputs.a_pointh_3();
db.outputs.a_pointd_3_array() = db.inputs.a_pointd_3_array();
db.outputs.a_pointf_3_array() = db.inputs.a_pointf_3_array();
db.outputs.a_pointh_3_array() = db.inputs.a_pointh_3_array();
db.outputs.a_quatd_4() = db.inputs.a_quatd_4();
db.outputs.a_quatf_4() = db.inputs.a_quatf_4();
db.outputs.a_quath_4() = db.inputs.a_quath_4();
db.outputs.a_quatd_4_array() = db.inputs.a_quatd_4_array();
db.outputs.a_quatf_4_array() = db.inputs.a_quatf_4_array();
db.outputs.a_quath_4_array() = db.inputs.a_quath_4_array();
db.outputs.a_string() = db.inputs.a_string();
db.outputs.a_target() = db.inputs.a_target();
db.outputs.a_texcoordd_2() = db.inputs.a_texcoordd_2();
db.outputs.a_texcoordd_3() = db.inputs.a_texcoordd_3();
db.outputs.a_texcoordf_2() = db.inputs.a_texcoordf_2();
db.outputs.a_texcoordf_3() = db.inputs.a_texcoordf_3();
db.outputs.a_texcoordh_2() = db.inputs.a_texcoordh_2();
db.outputs.a_texcoordh_3() = db.inputs.a_texcoordh_3();
db.outputs.a_texcoordd_2_array() = db.inputs.a_texcoordd_2_array();
db.outputs.a_texcoordd_3_array() = db.inputs.a_texcoordd_3_array();
db.outputs.a_texcoordf_2_array() = db.inputs.a_texcoordf_2_array();
db.outputs.a_texcoordf_3_array() = db.inputs.a_texcoordf_3_array();
db.outputs.a_texcoordh_2_array() = db.inputs.a_texcoordh_2_array();
db.outputs.a_texcoordh_3_array() = db.inputs.a_texcoordh_3_array();
db.outputs.a_timecode() = db.inputs.a_timecode();
db.outputs.a_timecode_array() = db.inputs.a_timecode_array();
db.outputs.a_token() = db.inputs.a_token();
db.outputs.a_token_array() = db.inputs.a_token_array();
db.outputs.a_uchar() = db.inputs.a_uchar();
db.outputs.a_uchar_array() = db.inputs.a_uchar_array();
db.outputs.a_uint() = db.inputs.a_uint();
db.outputs.a_uint_array() = db.inputs.a_uint_array();
db.outputs.a_uint64() = db.inputs.a_uint64();
db.outputs.a_uint64_array() = db.inputs.a_uint64_array();
db.outputs.a_vectord_3() = db.inputs.a_vectord_3();
db.outputs.a_vectorf_3() = db.inputs.a_vectorf_3();
db.outputs.a_vectorh_3() = db.inputs.a_vectorh_3();
db.outputs.a_vectord_3_array() = db.inputs.a_vectord_3_array();
db.outputs.a_vectorf_3_array() = db.inputs.a_vectorf_3_array();
db.outputs.a_vectorh_3_array() = db.inputs.a_vectorh_3_array();
// The input bundle could contain any of the legal data types so check them all. When a match is found then
// a copy of the regular input attribute with the same type is added to both the state and output bundles.
// As a secondary check it also does type casting to USD types where explicit casting has been implemented.
auto& outputBundle = db.outputs.a_bundle();
auto& stateBundle = db.state.a_bundle();
for (const auto& bundledAttribute : db.inputs.a_bundle())
{
const auto& bundledType = bundledAttribute.type();
// As the copyData handles attributes of all types, and we are by design creating an attribute with a type
// identical to the one it is copying, none of the usual bundle member casting is necessary. A simple
// create-and-copy gives a bundle with contents equal to all of the input attributes.
auto newOutput = outputBundle.addAttribute(bundledAttribute.name(), bundledType);
auto newState = stateBundle.addAttribute(bundledAttribute.name(), bundledType);
newOutput.copyData(bundledAttribute);
newState.copyData(bundledAttribute);
}
// State attributes take on the input values the first time they evaluate, zeroes on subsequent evaluations.
// The a_firstEvaluation attribute is used as the gating state information to decide when evaluation needs to happen again.
if (db.state.a_firstEvaluation())
{
db.state.a_firstEvaluation() = false;
db.state.a_bool() = db.inputs.a_bool();
db.state.a_bool_array() = db.inputs.a_bool_array();
db.state.a_colord_3() = db.inputs.a_colord_3();
db.state.a_colord_4() = db.inputs.a_colord_4();
db.state.a_colorf_3() = db.inputs.a_colorf_3();
db.state.a_colorf_4() = db.inputs.a_colorf_4();
db.state.a_colorh_3() = db.inputs.a_colorh_3();
db.state.a_colorh_4() = db.inputs.a_colorh_4();
db.state.a_colord_3_array() = db.inputs.a_colord_3_array();
db.state.a_colord_4_array() = db.inputs.a_colord_4_array();
db.state.a_colorf_3_array() = db.inputs.a_colorf_3_array();
db.state.a_colorf_4_array() = db.inputs.a_colorf_4_array();
db.state.a_colorh_3_array() = db.inputs.a_colorh_3_array();
db.state.a_colorh_4_array() = db.inputs.a_colorh_4_array();
db.state.a_double() = db.inputs.a_double();
db.state.a_double_2() = db.inputs.a_double_2();
db.state.a_double_3() = db.inputs.a_double_3();
db.state.a_double_4() = db.inputs.a_double_4();
db.state.a_double_array() = db.inputs.a_double_array();
db.state.a_double_2_array() = db.inputs.a_double_2_array();
db.state.a_double_3_array() = db.inputs.a_double_3_array();
db.state.a_double_4_array() = db.inputs.a_double_4_array();
db.state.a_execution() = db.inputs.a_execution();
db.state.a_float() = db.inputs.a_float();
db.state.a_float_2() = db.inputs.a_float_2();
db.state.a_float_3() = db.inputs.a_float_3();
db.state.a_float_4() = db.inputs.a_float_4();
db.state.a_float_array() = db.inputs.a_float_array();
db.state.a_float_2_array() = db.inputs.a_float_2_array();
db.state.a_float_3_array() = db.inputs.a_float_3_array();
db.state.a_float_4_array() = db.inputs.a_float_4_array();
db.state.a_frame_4() = db.inputs.a_frame_4();
db.state.a_frame_4_array() = db.inputs.a_frame_4_array();
db.state.a_half() = db.inputs.a_half();
db.state.a_half_2() = db.inputs.a_half_2();
db.state.a_half_3() = db.inputs.a_half_3();
db.state.a_half_4() = db.inputs.a_half_4();
db.state.a_half_array() = db.inputs.a_half_array();
db.state.a_half_2_array() = db.inputs.a_half_2_array();
db.state.a_half_3_array() = db.inputs.a_half_3_array();
db.state.a_half_4_array() = db.inputs.a_half_4_array();
db.state.a_int() = db.inputs.a_int();
db.state.a_int_2() = db.inputs.a_int_2();
db.state.a_int_3() = db.inputs.a_int_3();
db.state.a_int_4() = db.inputs.a_int_4();
db.state.a_int_array() = db.inputs.a_int_array();
db.state.a_int_2_array() = db.inputs.a_int_2_array();
db.state.a_int_3_array() = db.inputs.a_int_3_array();
db.state.a_int_4_array() = db.inputs.a_int_4_array();
db.state.a_int64() = db.inputs.a_int64();
db.state.a_int64_array() = db.inputs.a_int64_array();
db.state.a_matrixd_2() = db.inputs.a_matrixd_2();
db.state.a_matrixd_3() = db.inputs.a_matrixd_3();
db.state.a_matrixd_4() = db.inputs.a_matrixd_4();
db.state.a_matrixd_2_array() = db.inputs.a_matrixd_2_array();
db.state.a_matrixd_3_array() = db.inputs.a_matrixd_3_array();
db.state.a_matrixd_4_array() = db.inputs.a_matrixd_4_array();
db.state.a_normald_3() = db.inputs.a_normald_3();
db.state.a_normalf_3() = db.inputs.a_normalf_3();
db.state.a_normalh_3() = db.inputs.a_normalh_3();
db.state.a_normald_3_array() = db.inputs.a_normald_3_array();
db.state.a_normalf_3_array() = db.inputs.a_normalf_3_array();
db.state.a_normalh_3_array() = db.inputs.a_normalh_3_array();
db.state.a_objectId() = db.inputs.a_objectId();
db.state.a_objectId_array() = db.inputs.a_objectId_array();
db.state.a_path() = db.inputs.a_path();
db.state.a_pointd_3() = db.inputs.a_pointd_3();
db.state.a_pointf_3() = db.inputs.a_pointf_3();
db.state.a_pointh_3() = db.inputs.a_pointh_3();
db.state.a_pointd_3_array() = db.inputs.a_pointd_3_array();
db.state.a_pointf_3_array() = db.inputs.a_pointf_3_array();
db.state.a_pointh_3_array() = db.inputs.a_pointh_3_array();
db.state.a_quatd_4() = db.inputs.a_quatd_4();
db.state.a_quatf_4() = db.inputs.a_quatf_4();
db.state.a_quath_4() = db.inputs.a_quath_4();
db.state.a_quatd_4_array() = db.inputs.a_quatd_4_array();
db.state.a_quatf_4_array() = db.inputs.a_quatf_4_array();
db.state.a_quath_4_array() = db.inputs.a_quath_4_array();
db.state.a_string() = db.inputs.a_string();
db.state.a_stringEmpty() = db.inputs.a_string();
db.state.a_target() = db.inputs.a_target();
db.state.a_texcoordd_2() = db.inputs.a_texcoordd_2();
db.state.a_texcoordd_3() = db.inputs.a_texcoordd_3();
db.state.a_texcoordf_2() = db.inputs.a_texcoordf_2();
db.state.a_texcoordf_3() = db.inputs.a_texcoordf_3();
db.state.a_texcoordh_2() = db.inputs.a_texcoordh_2();
db.state.a_texcoordh_3() = db.inputs.a_texcoordh_3();
db.state.a_texcoordd_2_array() = db.inputs.a_texcoordd_2_array();
db.state.a_texcoordd_3_array() = db.inputs.a_texcoordd_3_array();
db.state.a_texcoordf_2_array() = db.inputs.a_texcoordf_2_array();
db.state.a_texcoordf_3_array() = db.inputs.a_texcoordf_3_array();
db.state.a_texcoordh_2_array() = db.inputs.a_texcoordh_2_array();
db.state.a_texcoordh_3_array() = db.inputs.a_texcoordh_3_array();
db.state.a_timecode() = db.inputs.a_timecode();
db.state.a_timecode_array() = db.inputs.a_timecode_array();
db.state.a_token() = db.inputs.a_token();
db.state.a_token_array() = db.inputs.a_token_array();
db.state.a_uchar() = db.inputs.a_uchar();
db.state.a_uchar_array() = db.inputs.a_uchar_array();
db.state.a_uint() = db.inputs.a_uint();
db.state.a_uint_array() = db.inputs.a_uint_array();
db.state.a_uint64() = db.inputs.a_uint64();
db.state.a_uint64_array() = db.inputs.a_uint64_array();
db.state.a_vectord_3() = db.inputs.a_vectord_3();
db.state.a_vectorf_3() = db.inputs.a_vectorf_3();
db.state.a_vectorh_3() = db.inputs.a_vectorh_3();
db.state.a_vectord_3_array() = db.inputs.a_vectord_3_array();
db.state.a_vectorf_3_array() = db.inputs.a_vectorf_3_array();
db.state.a_vectorh_3_array() = db.inputs.a_vectorh_3_array();
}
else
{
// On subsequent evaluations the state values are all set to 0 (empty list for array types)
db.state.a_bool() = false;
db.state.a_bool_array.resize(0);
db.state.a_colord_3().Set(0.0, 0.0, 0.0);
db.state.a_colord_4().Set(0.0, 0.0, 0.0, 0.0);
db.state.a_colorf_3().Set(0.0, 0.0, 0.0);
db.state.a_colorf_4().Set(0.0, 0.0, 0.0, 0.0);
db.state.a_colorh_3() *= 0.0;
db.state.a_colorh_4() *= 0.0;
db.state.a_colord_3_array.resize(0);
db.state.a_colord_4_array.resize(0);
db.state.a_colorf_3_array.resize(0);
db.state.a_colorf_4_array.resize(0);
db.state.a_colorh_3_array.resize(0);
db.state.a_colorh_4_array.resize(0);
db.state.a_double() = 0.0;
db.state.a_double_2().Set(0.0, 0.0);
db.state.a_double_3().Set(0.0, 0.0, 0.0);
db.state.a_double_4().Set(0.0, 0.0, 0.0, 0.0);
db.state.a_double_array.resize(0);
db.state.a_double_2_array.resize(0);
db.state.a_double_3_array.resize(0);
db.state.a_double_4_array.resize(0);
db.state.a_execution() = 0;
db.state.a_float() = 0.0f;
db.state.a_float_2().Set(0.0f, 0.0f);
db.state.a_float_3().Set(0.0f, 0.0f, 0.0f);
db.state.a_float_4().Set(0.0f, 0.0f, 0.0f, 0.0f);
db.state.a_float_array.resize(0);
db.state.a_float_2_array.resize(0);
db.state.a_float_3_array.resize(0);
db.state.a_float_4_array.resize(0);
db.state.a_frame_4().SetZero();
db.state.a_frame_4_array.resize(0);
db.state.a_half() = pxr::GfHalf(0.0);
db.state.a_half_2() *= 0.0;
db.state.a_half_3() *= 0.0;
db.state.a_half_4() *= 0.0;
db.state.a_half_array.resize(0);
db.state.a_half_2_array.resize(0);
db.state.a_half_3_array.resize(0);
db.state.a_half_4_array.resize(0);
db.state.a_int() = 0;
db.state.a_int_2().Set(0, 0);
db.state.a_int_3().Set(0, 0, 0);
db.state.a_int_4().Set(0, 0, 0, 0);
db.state.a_int_array.resize(0);
db.state.a_int_2_array.resize(0);
db.state.a_int_3_array.resize(0);
db.state.a_int_4_array.resize(0);
db.state.a_int64() = 0;
db.state.a_int64_array.resize(0);
db.state.a_matrixd_2().SetZero();
db.state.a_matrixd_3().SetZero();
db.state.a_matrixd_4().SetZero();
db.state.a_matrixd_2_array.resize(0);
db.state.a_matrixd_3_array.resize(0);
db.state.a_matrixd_4_array.resize(0);
db.state.a_normald_3().Set(0.0, 0.0, 0.0);
db.state.a_normalf_3().Set(0.0f, 0.0f, 0.0f);
db.state.a_normalh_3() *= 0.0;
db.state.a_normald_3_array.resize(0);
db.state.a_normalf_3_array.resize(0);
db.state.a_normalh_3_array.resize(0);
db.state.a_objectId() = 0;
db.state.a_objectId_array.resize(0);
std::string emptyString;
db.state.a_path() = emptyString;
db.state.a_pointd_3().Set(0.0, 0.0, 0.0);
db.state.a_pointf_3().Set(0.0f, 0.0f, 0.0f);
db.state.a_pointh_3() *= 0.0;
db.state.a_pointd_3_array.resize(0);
db.state.a_pointf_3_array.resize(0);
db.state.a_pointh_3_array.resize(0);
db.state.a_quatd_4().SetReal(0.0);
db.state.a_quatd_4().SetImaginary(0.0, 0.0, 0.0);
db.state.a_quatf_4().SetReal(0.0f);
db.state.a_quatf_4().SetImaginary(0.0f, 0.0f, 0.0f);
db.state.a_quath_4() *= 0.0;
db.state.a_quatd_4_array.resize(0);
db.state.a_quatf_4_array.resize(0);
db.state.a_quath_4_array.resize(0);
db.state.a_string() = "";
db.state.a_target().resize(0);
db.state.a_texcoordd_2().Set(0.0, 0.0);
db.state.a_texcoordd_3().Set(0.0, 0.0, 0.0);
db.state.a_texcoordf_2().Set(0.0f, 0.0f);
db.state.a_texcoordf_3().Set(0.0f, 0.0f, 0.0f);
db.state.a_texcoordh_2() *= 0.0;
db.state.a_texcoordh_3() *= 0.0;
db.state.a_texcoordd_2_array.resize(0);
db.state.a_texcoordd_3_array.resize(0);
db.state.a_texcoordf_2_array.resize(0);
db.state.a_texcoordf_3_array.resize(0);
db.state.a_texcoordh_2_array.resize(0);
db.state.a_texcoordh_3_array.resize(0);
db.state.a_timecode() = db.inputs.a_timecode() * pxr::SdfTimeCode(0.0);
db.state.a_timecode_array.resize(0);
db.state.a_token() = omni::fabric::kUninitializedToken;
db.state.a_token_array.resize(0);
db.state.a_uchar() = 0;
db.state.a_uchar_array.resize(0);
db.state.a_uint() = 0;
db.state.a_uint_array.resize(0);
db.state.a_uint64() = 0;
db.state.a_uint64_array.resize(0);
db.state.a_vectord_3().Set(0.0, 0.0, 0.0);
db.state.a_vectorf_3().Set(0.0f, 0.0f, 0.0f);
db.state.a_vectorh_3() *= 0.0;
db.state.a_vectord_3_array.resize(0);
db.state.a_vectorf_3_array.resize(0);
db.state.a_vectorh_3_array.resize(0);
}
// OM-41949 Not building when referencing certain types of state bundle members
auto runtimeInt3Array = db.state.a_bundle().attributeByName(db.stringToToken("inputs:a_int_3_array"));
if (runtimeInt3Array.isValid())
{
// Artificial path to do something the compiler can't elide
auto extractedValue = runtimeInt3Array.getCpu<int[][3]>();
if (extractedValue.size() > 0)
{
return true;
}
}
return true;
}
};
REGISTER_OGN_NODE()
} // namespace test
} // namespace graph
} // namespace omni
| 22,298 |
C++
| 46.243644 | 131 | 0.563638 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/nodes/OgnTestSchedulingHintsString.cpp
|
// Copyright (c) 2021 NVIDIA CORPORATION. All rights reserved.
//
// NVIDIA CORPORATION and its licensors retain all intellectual property
// and proprietary rights in and to this software, related documentation
// and any modifications thereto. Any use, reproduction, disclosure or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA CORPORATION is strictly prohibited.
//
#include <OgnTestSchedulingHintsStringDatabase.h>
namespace omni {
namespace graph {
namespace core {
class OgnTestSchedulingHintsString
{
public:
// This node does nothing, it's only a container of the scheduling hints
static bool compute(OgnTestSchedulingHintsStringDatabase& db)
{
return true;
}
};
REGISTER_OGN_NODE()
} // namespace core
} // namespace graph
} // namespace omni
| 846 |
C++
| 27.233332 | 77 | 0.762411 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/nodes/OgnTestAllDataTypesPod.cpp
|
// Copyright (c) 2021 NVIDIA CORPORATION. All rights reserved.
//
// NVIDIA CORPORATION and its licensors retain all intellectual property
// and proprietary rights in and to this software, related documentation
// and any modifications thereto. Any use, reproduction, disclosure or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA CORPORATION is strictly prohibited.
//
#include <OgnTestAllDataTypesPodDatabase.h>
namespace omni {
namespace graph {
using core::ogn::array;
using core::ogn::const_array;
using core::ogn::string;
using core::ogn::const_string;
namespace test {
// Helper template that reduces the testing code while hardcoding to the expected types.
// This version is for types that are directly assignable.
template <typename DataType, typename ConstDataType, typename std::enable_if_t<std::is_assignable<DataType, ConstDataType>::value, int> = 0>
void assign(DataType& dst, ConstDataType& src)
{
dst = src;
}
// This version is for types that cannot be assigned. memcpy works for them since we require types to be byte-compatible
template <typename DataType, typename ConstDataType, typename std::enable_if_t<! std::is_assignable<DataType, ConstDataType>::value, int> = 0>
void assign(DataType& dst, ConstDataType& src)
{
memcpy(&dst, &src, sizeof(DataType));
}
class OgnTestAllDataTypesPod
{
public:
static bool compute(OgnTestAllDataTypesPodDatabase& db)
{
if (db.inputs.doNotCompute())
{
return true;
}
assign<bool, const bool>(db.outputs.a_bool(), db.inputs.a_bool());
assign<array<bool>, const const_array<bool>>(db.outputs.a_bool_array(), db.inputs.a_bool_array());
assign<double[3], const double[3]>(db.outputs.a_colord_3(), db.inputs.a_colord_3());
assign<double[4], const double[4]>(db.outputs.a_colord_4(), db.inputs.a_colord_4());
assign<float[3], const float[3]>(db.outputs.a_colorf_3(), db.inputs.a_colorf_3());
assign<float[4], const float[4]>(db.outputs.a_colorf_4(), db.inputs.a_colorf_4());
assign<pxr::GfVec3h, const pxr::GfVec3h>(db.outputs.a_colorh_3(), db.inputs.a_colorh_3());
assign<pxr::GfVec4h, const pxr::GfVec4h>(db.outputs.a_colorh_4(), db.inputs.a_colorh_4());
assign<array<double[3]>, const const_array<double[3]>>(db.outputs.a_colord_3_array(), db.inputs.a_colord_3_array());
assign<array<double[4]>, const const_array<double[4]>>(db.outputs.a_colord_4_array(), db.inputs.a_colord_4_array());
assign<array<float[3]>, const const_array<float[3]>>(db.outputs.a_colorf_3_array(), db.inputs.a_colorf_3_array());
assign<array<float[4]>, const const_array<float[4]>>(db.outputs.a_colorf_4_array(), db.inputs.a_colorf_4_array());
assign<array<pxr::GfVec3h>, const const_array<pxr::GfVec3h>>(db.outputs.a_colorh_3_array(), db.inputs.a_colorh_3_array());
assign<array<pxr::GfVec4h>, const const_array<pxr::GfVec4h>>(db.outputs.a_colorh_4_array(), db.inputs.a_colorh_4_array());
assign<double, const double>(db.outputs.a_double(), db.inputs.a_double());
assign<double[2], const double[2]>(db.outputs.a_double_2(), db.inputs.a_double_2());
assign<double[3], const double[3]>(db.outputs.a_double_3(), db.inputs.a_double_3());
assign<double[4], const double[4]>(db.outputs.a_double_4(), db.inputs.a_double_4());
assign<array<double>, const const_array<double>>(db.outputs.a_double_array(), db.inputs.a_double_array());
assign<array<double[2]>, const const_array<double[2]>>(db.outputs.a_double_2_array(), db.inputs.a_double_2_array());
assign<array<double[3]>, const const_array<double[3]>>(db.outputs.a_double_3_array(), db.inputs.a_double_3_array());
assign<array<double[4]>, const const_array<double[4]>>(db.outputs.a_double_4_array(), db.inputs.a_double_4_array());
assign<uint32_t, const uint32_t>(db.outputs.a_execution(), db.inputs.a_execution());
assign<float, const float>(db.outputs.a_float(), db.inputs.a_float());
assign<float[2], const float[2]>(db.outputs.a_float_2(), db.inputs.a_float_2());
assign<float[3], const float[3]>(db.outputs.a_float_3(), db.inputs.a_float_3());
assign<float[4], const float[4]>(db.outputs.a_float_4(), db.inputs.a_float_4());
assign<array<float>, const const_array<float>>(db.outputs.a_float_array(), db.inputs.a_float_array());
assign<array<float[2]>, const const_array<float[2]>>(db.outputs.a_float_2_array(), db.inputs.a_float_2_array());
assign<array<float[3]>, const const_array<float[3]>>(db.outputs.a_float_3_array(), db.inputs.a_float_3_array());
assign<array<float[4]>, const const_array<float[4]>>(db.outputs.a_float_4_array(), db.inputs.a_float_4_array());
assign<double[4][4], const double[4][4]>(db.outputs.a_frame_4(), db.inputs.a_frame_4());
assign<array<double[4][4]>, const const_array<double[4][4]>>(db.outputs.a_frame_4_array(), db.inputs.a_frame_4_array());
assign<pxr::GfHalf, const pxr::GfHalf>(db.outputs.a_half(), db.inputs.a_half());
assign<pxr::GfVec2h, const pxr::GfVec2h>(db.outputs.a_half_2(), db.inputs.a_half_2());
assign<pxr::GfVec3h, const pxr::GfVec3h>(db.outputs.a_half_3(), db.inputs.a_half_3());
assign<pxr::GfVec4h, const pxr::GfVec4h>(db.outputs.a_half_4(), db.inputs.a_half_4());
assign<array<pxr::GfHalf>, const const_array<pxr::GfHalf>>(db.outputs.a_half_array(), db.inputs.a_half_array());
assign<array<pxr::GfVec2h>, const const_array<pxr::GfVec2h>>(db.outputs.a_half_2_array(), db.inputs.a_half_2_array());
assign<array<pxr::GfVec3h>, const const_array<pxr::GfVec3h>>(db.outputs.a_half_3_array(), db.inputs.a_half_3_array());
assign<array<pxr::GfVec4h>, const const_array<pxr::GfVec4h>>(db.outputs.a_half_4_array(), db.inputs.a_half_4_array());
assign<int, const int>(db.outputs.a_int(), db.inputs.a_int());
assign<int[2], const int[2]>(db.outputs.a_int_2(), db.inputs.a_int_2());
assign<int[3], const int[3]>(db.outputs.a_int_3(), db.inputs.a_int_3());
assign<int[4], const int[4]>(db.outputs.a_int_4(), db.inputs.a_int_4());
assign<array<int>, const const_array<int>>(db.outputs.a_int_array(), db.inputs.a_int_array());
assign<array<int[2]>, const const_array<int[2]>>(db.outputs.a_int_2_array(), db.inputs.a_int_2_array());
assign<array<int[3]>, const const_array<int[3]>>(db.outputs.a_int_3_array(), db.inputs.a_int_3_array());
assign<array<int[4]>, const const_array<int[4]>>(db.outputs.a_int_4_array(), db.inputs.a_int_4_array());
assign<int64_t, const int64_t>(db.outputs.a_int64(), db.inputs.a_int64());
assign<array<int64_t>, const const_array<int64_t>>(db.outputs.a_int64_array(), db.inputs.a_int64_array());
assign<double[2][2], const double[2][2]>(db.outputs.a_matrixd_2(), db.inputs.a_matrixd_2());
assign<double[3][3], const double[3][3]>(db.outputs.a_matrixd_3(), db.inputs.a_matrixd_3());
assign<double[4][4], const double[4][4]>(db.outputs.a_matrixd_4(), db.inputs.a_matrixd_4());
assign<array<double[2][2]>, const const_array<double[2][2]>>(db.outputs.a_matrixd_2_array(), db.inputs.a_matrixd_2_array());
assign<array<double[3][3]>, const const_array<double[3][3]>>(db.outputs.a_matrixd_3_array(), db.inputs.a_matrixd_3_array());
assign<array<double[4][4]>, const const_array<double[4][4]>>(db.outputs.a_matrixd_4_array(), db.inputs.a_matrixd_4_array());
assign<double[3], const double[3]>(db.outputs.a_normald_3(), db.inputs.a_normald_3());
assign<float[3], const float[3]>(db.outputs.a_normalf_3(), db.inputs.a_normalf_3());
assign<pxr::GfVec3h, const pxr::GfVec3h>(db.outputs.a_normalh_3(), db.inputs.a_normalh_3());
assign<array<double[3]>, const const_array<double[3]>>(db.outputs.a_normald_3_array(), db.inputs.a_normald_3_array());
assign<array<float[3]>, const const_array<float[3]>>(db.outputs.a_normalf_3_array(), db.inputs.a_normalf_3_array());
assign<array<pxr::GfVec3h>, const const_array<pxr::GfVec3h>>(db.outputs.a_normalh_3_array(), db.inputs.a_normalh_3_array());
assign<uint64_t, const uint64_t>(db.outputs.a_objectId(), db.inputs.a_objectId());
assign<array<uint64_t>, const const_array<uint64_t>>(db.outputs.a_objectId_array(), db.inputs.a_objectId_array());
assign<double[3], const double[3]>(db.outputs.a_pointd_3(), db.inputs.a_pointd_3());
assign<float[3], const float[3]>(db.outputs.a_pointf_3(), db.inputs.a_pointf_3());
assign<pxr::GfVec3h, const pxr::GfVec3h>(db.outputs.a_pointh_3(), db.inputs.a_pointh_3());
assign<array<double[3]>, const const_array<double[3]>>(db.outputs.a_pointd_3_array(), db.inputs.a_pointd_3_array());
assign<array<float[3]>, const const_array<float[3]>>(db.outputs.a_pointf_3_array(), db.inputs.a_pointf_3_array());
assign<array<pxr::GfVec3h>, const const_array<pxr::GfVec3h>>(db.outputs.a_pointh_3_array(), db.inputs.a_pointh_3_array());
assign<double[4], const double[4]>(db.outputs.a_quatd_4(), db.inputs.a_quatd_4());
assign<float[4], const float[4]>(db.outputs.a_quatf_4(), db.inputs.a_quatf_4());
assign<pxr::GfQuath, const pxr::GfQuath>(db.outputs.a_quath_4(), db.inputs.a_quath_4());
assign<array<double[4]>, const const_array<double[4]>>(db.outputs.a_quatd_4_array(), db.inputs.a_quatd_4_array());
assign<array<float[4]>, const const_array<float[4]>>(db.outputs.a_quatf_4_array(), db.inputs.a_quatf_4_array());
assign<array<pxr::GfQuath>, const const_array<pxr::GfQuath>>(db.outputs.a_quath_4_array(), db.inputs.a_quath_4_array());
assign<string, const const_string>(db.outputs.a_string(), db.inputs.a_string());
assign<double[2], const double[2]>(db.outputs.a_texcoordd_2(), db.inputs.a_texcoordd_2());
assign<double[3], const double[3]>(db.outputs.a_texcoordd_3(), db.inputs.a_texcoordd_3());
assign<float[2], const float[2]>(db.outputs.a_texcoordf_2(), db.inputs.a_texcoordf_2());
assign<float[3], const float[3]>(db.outputs.a_texcoordf_3(), db.inputs.a_texcoordf_3());
assign<pxr::GfVec2h, const pxr::GfVec2h>(db.outputs.a_texcoordh_2(), db.inputs.a_texcoordh_2());
assign<pxr::GfVec3h, const pxr::GfVec3h>(db.outputs.a_texcoordh_3(), db.inputs.a_texcoordh_3());
assign<array<double[2]>, const const_array<double[2]>>(db.outputs.a_texcoordd_2_array(), db.inputs.a_texcoordd_2_array());
assign<array<double[3]>, const const_array<double[3]>>(db.outputs.a_texcoordd_3_array(), db.inputs.a_texcoordd_3_array());
assign<array<float[2]>, const const_array<float[2]>>(db.outputs.a_texcoordf_2_array(), db.inputs.a_texcoordf_2_array());
assign<array<float[3]>, const const_array<float[3]>>(db.outputs.a_texcoordf_3_array(), db.inputs.a_texcoordf_3_array());
assign<array<pxr::GfVec2h>, const const_array<pxr::GfVec2h>>(db.outputs.a_texcoordh_2_array(), db.inputs.a_texcoordh_2_array());
assign<array<pxr::GfVec3h>, const const_array<pxr::GfVec3h>>(db.outputs.a_texcoordh_3_array(), db.inputs.a_texcoordh_3_array());
assign<double, const double>(db.outputs.a_timecode(), db.inputs.a_timecode());
assign<array<double>, const const_array<double>>(db.outputs.a_timecode_array(), db.inputs.a_timecode_array());
assign<NameToken, const NameToken>(db.outputs.a_token(), db.inputs.a_token());
assign<array<NameToken>, const const_array<NameToken>>(db.outputs.a_token_array(), db.inputs.a_token_array());
assign<uint8_t, const uint8_t>(db.outputs.a_uchar(), db.inputs.a_uchar());
assign<array<uint8_t>, const const_array<uint8_t>>(db.outputs.a_uchar_array(), db.inputs.a_uchar_array());
assign<uint32_t, const uint32_t>(db.outputs.a_uint(), db.inputs.a_uint());
assign<array<uint32_t>, const const_array<uint32_t>>(db.outputs.a_uint_array(), db.inputs.a_uint_array());
assign<uint64_t, const uint64_t>(db.outputs.a_uint64(), db.inputs.a_uint64());
assign<array<uint64_t>, const const_array<uint64_t>>(db.outputs.a_uint64_array(), db.inputs.a_uint64_array());
assign<double[3], const double[3]>(db.outputs.a_vectord_3(), db.inputs.a_vectord_3());
assign<float[3], const float[3]>(db.outputs.a_vectorf_3(), db.inputs.a_vectorf_3());
assign<pxr::GfVec3h, const pxr::GfVec3h>(db.outputs.a_vectorh_3(), db.inputs.a_vectorh_3());
assign<array<double[3]>, const const_array<double[3]>>(db.outputs.a_vectord_3_array(), db.inputs.a_vectord_3_array());
assign<array<float[3]>, const const_array<float[3]>>(db.outputs.a_vectorf_3_array(), db.inputs.a_vectorf_3_array());
assign<array<pxr::GfVec3h>, const const_array<pxr::GfVec3h>>(db.outputs.a_vectorh_3_array(), db.inputs.a_vectorh_3_array());
return true;
}
};
REGISTER_OGN_NODE()
} // namespace test
} // namespace graph
} // namespace omni
| 13,082 |
C++
| 71.683333 | 142 | 0.660755 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/nodes/OgnPerturbPointsGpu.cpp
|
// Copyright (c) 2021 NVIDIA CORPORATION. All rights reserved.
//
// NVIDIA CORPORATION and its licensors retain all intellectual property
// and proprietary rights in and to this software, related documentation
// and any modifications thereto. Any use, reproduction, disclosure or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA CORPORATION is strictly prohibited.
//
#include <OgnPerturbPointsGpuDatabase.h>
#include <cstdlib>
namespace omni {
namespace graph {
namespace test {
extern "C" void applyPerturbGpu(outputs::points_t outputPoints,
inputs::points_t inputPoints,
inputs::minimum_t minimum,
inputs::maximum_t maximum,
inputs::percentModified_t percentModified,
size_t numberOfPoints);
// This is the implementation of the OGN node defined in OgnPerturbPointsGpu.ogn
class OgnPerturbPointsGpu
{
public:
// Perturb an array of points by random amounts within the limits of the bounding cube formed by the diagonal
// corners "minimum" and "maximum" using CUDA code on stolen GPU data.
static bool compute(OgnPerturbPointsGpuDatabase& db)
{
// No points mean nothing to perturb. Getting the size is something that can be safely done here since the
// size information is not stored on the GPU.
size_t pointCount = db.inputs.points.size();
if (pointCount == 0)
{
return true;
}
// Data stealing happens on this end since it just redirects the lookup location
db.outputs.points = db.inputs.points;
CARB_PROFILE_ZONE(carb::profiler::kCaptureMaskDefault, "Perturbing Data");
applyPerturbGpu(db.outputs.points(), db.inputs.points(), db.inputs.minimum(), db.inputs.maximum(), db.inputs.percentModified(), pointCount);
return true;
}
};
REGISTER_OGN_NODE()
} // namespace test
} // namespace graph
} // namespace omni
| 2,073 |
C++
| 37.407407 | 148 | 0.671008 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/nodes/OgnPerturbPointsPy.py
|
"""
This is the implementation of the OGN node defined in OgnPerturbPoints.ogn
"""
from contextlib import suppress
import numpy as np
class OgnPerturbPointsPy:
"""
Perturb an array of points by random amounts within a proscribed limit
"""
@staticmethod
def compute(db) -> bool:
"""Compute the outputs from the current input"""
# No points mean nothing to perturb
point_count = len(db.inputs.points)
if point_count == 0:
return True
range_size = db.inputs.maximum - db.inputs.minimum
percent_modified = max(0.0, min(100.0, db.inputs.percentModified))
points_to_modify = int(percent_modified * point_count / 100.0)
# Steal the input to modify directly as output
db.move(db.attributes.outputs.points, db.attributes.inputs.points)
db.outputs.points[0:points_to_modify] = (
db.outputs.points[0:points_to_modify]
+ range_size * np.random.random_sample((points_to_modify, 3))
+ db.inputs.minimum
)
# If the dynamic inputs and outputs exist then they will steal data
with suppress(AttributeError):
db.move(db.attributes.outputs.stolen, db.attributes.inputs.stealMe)
return True
| 1,272 |
Python
| 30.04878 | 79 | 0.646226 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/nodes/OgnPerturbBundlePoints.cpp
|
// Copyright (c) 2021 NVIDIA CORPORATION. All rights reserved.
//
// NVIDIA CORPORATION and its licensors retain all intellectual property
// and proprietary rights in and to this software, related documentation
// and any modifications thereto. Any use, reproduction, disclosure or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA CORPORATION is strictly prohibited.
//
#include <OgnPerturbBundlePointsDatabase.h>
#include <cstdlib>
namespace omni {
namespace graph {
namespace test {
// This is the implementation of the OGN node defined in OgnPerturbBundlePoints.ogn
class OgnPerturbBundlePoints
{
static auto& copyBundle(OgnPerturbBundlePointsDatabase& db)
{
CARB_PROFILE_ZONE(carb::profiler::kCaptureMaskDefault, "Acquiring Data");
db.outputs.bundle = db.inputs.bundle;
return db.outputs.bundle();
}
public:
// Perturb a bundles of arrays of points by random amounts within the limits of the bounding cube formed by the
// diagonal corners "minimum" and "maximum".
static bool compute(OgnPerturbBundlePointsDatabase& db)
{
const auto& minimum = db.inputs.minimum();
GfVec3f rangeSize = db.inputs.maximum() - minimum;
// No bundle members mean nothing to perturb
const auto& inputBundle = db.inputs.bundle();
if (inputBundle.attributeCount() == 0)
{
db.outputs.bundle().clear();
return true;
}
// How much of the surface should be perturbed
auto percentModified = db.inputs.percentModified();
percentModified = (percentModified > 100.0f ? 100.0f : (percentModified < 0.0f ? 0.0f : percentModified));
// Steal the bundle contents, then walk all of the members and perturb any points arrays found
auto& outputBundle = copyBundle(db);
CARB_PROFILE_ZONE(carb::profiler::kCaptureMaskDefault, "Perturbing Data");
for (auto& bundledAttribute : outputBundle)
{
auto pointArrayData = bundledAttribute.get<float[][3]>();
if (pointArrayData)
{
auto& pointArray = *pointArrayData;
size_t pointsToModify = (size_t)((percentModified * (float)pointArray.size()) / 100.0f);
size_t index{ 0 };
while (index < pointsToModify)
{
auto& point = pointArray[index++];
point[0] += minimum[0] + static_cast<float>(rand()) / (static_cast<float>(RAND_MAX/(rangeSize[0])));
point[1] += minimum[1] + static_cast<float>(rand()) / (static_cast<float>(RAND_MAX/(rangeSize[1])));
point[2] += minimum[2] + static_cast<float>(rand()) / (static_cast<float>(RAND_MAX/(rangeSize[2])));
}
}
}
return true;
}
};
REGISTER_OGN_NODE()
} // namespace test
} // namespace graph
} // namespace omni
| 2,970 |
C++
| 38.092105 | 120 | 0.63569 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/nodes/OgnTestTupleArrays.py
|
"""
Test node multiplying tuple arrays by a constant
"""
import numpy as np
class OgnTestTupleArrays:
"""Exercise a sample of complex data types through a Python OmniGraph node"""
@staticmethod
def compute(db) -> bool:
"""Multiply every value in a tuple array by a constant."""
multiplier = db.inputs.multiplier
input_array = db.inputs.float3Array
input_array_size = len(db.inputs.float3Array)
db.outputs.float3Array_size = input_array_size
# If the input array is empty then the output is empty and does not need any computing
if input_array.shape[0] == 0:
db.outputs.float3Array = []
assert db.outputs.float3Array.shape == (0, 3)
return True
db.outputs.float3Array = np.multiply(input_array, multiplier)
return True
| 846 |
Python
| 28.206896 | 94 | 0.650118 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/nodes/OgnTestCppKeywords.cpp
|
// Copyright (c) 2022-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.
//
#include <OgnTestCppKeywordsDatabase.h>
namespace omni {
namespace graph {
namespace test {
// This class does not have to do anything as it only exists to verify that generated
// code is legal.
class OgnTestCppKeywords
{
public:
static bool compute(OgnTestCppKeywordsDatabase& db)
{
db.outputs.verify() = true;
return true;
}
};
REGISTER_OGN_NODE()
} // test
} // namespace graph
} // namespace omni
| 874 |
C++
| 26.343749 | 85 | 0.744851 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/nodes/OgnTestCyclesSerial.cpp
|
// Copyright (c) 2023, NVIDIA CORPORATION. All rights reserved.
//
// NVIDIA CORPORATION and its licensors retain all intellectual property
// and proprietary rights in and to this software, related documentation
// and any modifications thereto. Any use, reproduction, disclosure or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA CORPORATION is strictly prohibited.
//
#include <OgnTestCyclesSerialDatabase.h>
namespace omni
{
namespace graph
{
namespace test
{
class OgnTestCyclesSerial
{
public:
static bool compute(OgnTestCyclesSerialDatabase& db)
{
if (db.state.count() > 10000)
{
db.state.count() = 0;
}
else
{
++db.state.count();
}
return true;
}
};
REGISTER_OGN_NODE()
} // test
} // namespace graph
} // namespace omni
| 888 |
C++
| 21.224999 | 77 | 0.676802 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/nodes/OgnComputeErrorPy.py
|
"""
This node generates compute() errors for testing purposes.
"""
import omni.graph.core as og
class OgnComputeErrorPy:
@staticmethod
def initialize(graph_context, node):
attr = node.get_attribute("inputs:deprecatedInInit")
# We would not normally deprecate an attribute this way. It would be done through the .ogn file.
# This is just for testing purposes.
og._internal.deprecate_attribute(attr, "Use 'dummyIn' instead.") # noqa: PLW0212
@staticmethod
def compute(db) -> bool:
db.outputs.dummyOut = db.inputs.dummyIn
severity = db.inputs.severity
if severity == "warning":
db.log_warning(db.inputs.message)
elif severity == "error":
db.log_error(db.inputs.message)
return not db.inputs.failCompute
| 819 |
Python
| 29.370369 | 104 | 0.655678 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/nodes/OgnAdd2IntArray.cpp
|
// Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved.
//
// NVIDIA CORPORATION and its licensors retain all intellectual property
// and proprietary rights in and to this software, related documentation
// and any modifications thereto. Any use, reproduction, disclosure or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA CORPORATION is strictly prohibited.
//
#include <OgnAdd2IntArrayDatabase.h>
#include <algorithm>
#include <numeric>
class OgnAdd2IntArray
{
public:
static bool compute(OgnAdd2IntArrayDatabase& db)
{
const auto& a = db.inputs.a();
const auto& b = db.inputs.b();
auto& output = db.outputs.output();
// If either array has only a single member that value will be added to all members of the other array.
// The case when both have size 1 is handled by the first "if".
if (a.size() == 1)
{
output = b;
std::for_each(output.begin(), output.end(), [a](int& value) { value += a[0]; });
}
else if (b.size() == 1)
{
output = a;
std::for_each(output.begin(), output.end(), [b](int& value) { value += b[0]; });
}
else if (a.size() != b.size())
{
db.logWarning("Attempted to add arrays of different sizes - %zu and %zu", a.size(), b.size());
return false;
}
else if (a.size() > 0)
{
output.resize(a.size());
std::transform(a.begin(), a.end(), b.begin(), output.begin(), std::plus<int>());
}
return true;
}
};
REGISTER_OGN_NODE()
| 1,668 |
C++
| 33.061224 | 111 | 0.589928 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/nodes/OgnBundlePropertiesPy.py
|
"""
This node is designed to test bundle properties.
"""
class OgnBundlePropertiesPy:
@staticmethod
def compute(db) -> bool:
bundle_contents = db.inputs.bundle
db.outputs.valid = bundle_contents.valid
| 227 |
Python
| 19.727271 | 48 | 0.682819 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/nodes/OgnBundleChildProducerPy.py
|
"""
This node is designed to shallow copy input bundle as a child in the output.
"""
class OgnBundleChildProducerPy:
@staticmethod
def compute(db) -> bool:
input_bundle = db.inputs.bundle
output_bundle = db.outputs.bundle
# store number of children from the input
db.outputs.numChildren = input_bundle.bundle.get_child_bundle_count()
# create child bundle in the output and shallow copy input
output_bundle.bundle.clear_contents()
output_surfaces = output_bundle.bundle.create_child_bundle("surfaces")
output_surfaces.copy_bundle(input_bundle.bundle)
| 627 |
Python
| 32.05263 | 78 | 0.69378 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/nodes/OgnRandomBundlePoints.cpp
|
// Copyright (c) 2021 NVIDIA CORPORATION. All rights reserved.
//
// NVIDIA CORPORATION and its licensors retain all intellectual property
// and proprietary rights in and to this software, related documentation
// and any modifications thereto. Any use, reproduction, disclosure or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA CORPORATION is strictly prohibited.
//
#include <OgnRandomBundlePointsDatabase.h>
#include <cstdlib>
#include <omni/graph/core/Type.h>
// This is the implementation of the OGN node defined in OgnRandomBundlePoints.ogn
namespace omni {
namespace graph {
using core::Type;
using core::BaseDataType;
using core::AttributeRole;
namespace test {
class OgnRandomBundlePoints
{
public:
// Generate a bundle of "bundleSize" arrays of "pointCount" points at random locations within the bounding cube,
// delineated by the corner points "minimum" and "maximum".
static bool compute(OgnRandomBundlePointsDatabase& db)
{
const auto& minimum = db.inputs.minimum();
GfVec3f rangeSize = db.inputs.maximum() - minimum;
// No points mean nothing to generate
const auto& pointCount = db.inputs.pointCount();
if (pointCount == 0)
{
return true;
}
// Bundle size of zero means nothing to generate
const auto& bundleSize = db.inputs.bundleSize();
if (bundleSize == 0)
{
return true;
}
// Start with an empty bundle
auto& outputBundle = db.outputs.bundle();
outputBundle.clear();
// Type definition for attributes that will be added to the bundle.
Type pointsType{ BaseDataType::eFloat, 3, 1, AttributeRole::ePosition };
// For each attribute to be added to the bundle create a unique array of random points
for (size_t element=0; element < size_t(bundleSize); ++element)
{
std::string attributeName = std::string{"points"} + std::to_string(element);
auto&& newAttribute = outputBundle.addAttribute(db.stringToToken(attributeName.c_str()), pointsType);
auto pointsArray = newAttribute.get<float[][3]>();
if (pointsArray)
{
pointsArray.resize(pointCount);
for (auto& point : *pointsArray)
{
point[0] = minimum[0] + static_cast<float>(rand()) /( static_cast<float>(RAND_MAX/(rangeSize[0])));
point[1] = minimum[1] + static_cast<float>(rand()) /( static_cast<float>(RAND_MAX/(rangeSize[1])));
point[2] = minimum[2] + static_cast<float>(rand()) /( static_cast<float>(RAND_MAX/(rangeSize[2])));
}
}
else
{
db.logWarning("Could not get a reference to the constructed points attribute");
return false;
}
}
return true;
}
};
REGISTER_OGN_NODE()
} // test
} // namespace graph
} // namespace omni
| 3,057 |
C++
| 34.97647 | 119 | 0.625777 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/nodes/OgnBundleConsumer.cpp
|
// Copyright (c) 2023, NVIDIA CORPORATION. All rights reserved.
//
// NVIDIA CORPORATION and its licensors retain all intellectual property
// and proprietary rights in and to this software, related documentation
// and any modifications thereto. Any use, reproduction, disclosure or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA CORPORATION is strictly prohibited.
//
#include <OgnBundleConsumerDatabase.h>
namespace omni::graph::test {
class OgnBundleConsumer
{
public:
static bool compute(OgnBundleConsumerDatabase& db)
{
if (auto bundleChanges = db.inputs.bundle.changes())
{
db.outputs.bundle() = db.inputs.bundle();
db.outputs.hasOutputBundleChanged() = true;
}
else
{
db.outputs.hasOutputBundleChanged() = false;
}
return true;
}
};
REGISTER_OGN_NODE()
}
| 937 |
C++
| 25.799999 | 77 | 0.685165 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/nodes/OgnRandomPoints.cpp
|
// Copyright (c) 2021 NVIDIA CORPORATION. All rights reserved.
//
// NVIDIA CORPORATION and its licensors retain all intellectual property
// and proprietary rights in and to this software, related documentation
// and any modifications thereto. Any use, reproduction, disclosure or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA CORPORATION is strictly prohibited.
//
#include <OgnRandomPointsDatabase.h>
#include <cstdlib>
// This is the implementation of the OGN node defined in OgnRandomPoints.ogn
namespace omni {
namespace graph {
namespace test {
class OgnRandomPoints
{
public:
// Create an array of "pointCount" points at random locations within the bounding cube,
// delineated by the corner points "minimum" and "maximum".
static bool compute(OgnRandomPointsDatabase& db)
{
const auto& minimum = db.inputs.minimum();
GfVec3f rangeSize = db.inputs.maximum() - minimum;
// No points mean nothing to generate
const auto& pointCount = db.inputs.pointCount();
if (pointCount == 0)
{
return true;
}
auto& outputPoints = db.outputs.points();
outputPoints.resize(pointCount);
for (size_t i=0; i<pointCount; ++i)
{
outputPoints[i] = GfVec3f{
minimum[0] + static_cast<float>(rand()) /( static_cast<float>(RAND_MAX/(rangeSize[0]))),
minimum[1] + static_cast<float>(rand()) /( static_cast<float>(RAND_MAX/(rangeSize[1]))),
minimum[2] + static_cast<float>(rand()) /( static_cast<float>(RAND_MAX/(rangeSize[2])))
};
}
return true;
}
};
REGISTER_OGN_NODE()
} // test
} // namespace graph
} // namespace omni
| 1,786 |
C++
| 31.490909 | 104 | 0.652856 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/nodes/OgnFakeTutorialTupleData.cpp
|
// Copyright (c) 2020-2023, NVIDIA CORPORATION. All rights reserved.
//
// NVIDIA CORPORATION and its licensors retain all intellectual property
// and proprietary rights in and to this software, related documentation
// and any modifications thereto. Any use, reproduction, disclosure or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA CORPORATION is strictly prohibited.
//
#include <OgnFakeTutorialTupleDataDatabase.h>
#include <algorithm>
class OgnFakeTutorialTupleData
{
public:
static bool compute(OgnFakeTutorialTupleDataDatabase& db)
{
db.outputs.a_double3() = db.inputs.a_double3() + GfVec3d(1.0, 1.0, 1.0);
return true;
}
};
REGISTER_OGN_NODE()
| 749 |
C++
| 31.608694 | 80 | 0.751669 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/nodes/OgnTestDeformer.cpp
|
// Copyright (c) 2019-2021, NVIDIA CORPORATION. All rights reserved.
//
// NVIDIA CORPORATION and its licensors retain all intellectual property
// and proprietary rights in and to this software, related documentation
// and any modifications thereto. Any use, reproduction, disclosure or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA CORPORATION is strictly prohibited.
//
#include "OgnTestDeformerDatabase.h"
#include <omni/graph/core/CppWrappers.h>
#include <cmath>
namespace omni
{
namespace graph
{
namespace test
{
namespace
{
class PointComputeArgs
{
public:
PointComputeArgs(const GfVec3f& inputPoint, float height, float width, float freq, GfVec3f& outputPoint)
: m_inputPoint(inputPoint), m_height(height), m_width(width), m_freq(freq), m_outputPoint(outputPoint)
{
}
const GfVec3f& m_inputPoint;
float m_height;
float m_width;
float m_freq;
GfVec3f& m_outputPoint;
};
}
// minimal compute node example that reads one float and writes one float
// e.g. out value = 3.0f * in value
class OgnTestDeformer
{
public:
static bool compute(OgnTestDeformerDatabase& db)
{
const auto& points = db.inputs.points();
const auto& multiplier = db.inputs.multiplier();
const auto& wavelength = db.inputs.wavelength();
auto& outputPoints = db.outputs.points();
size_t numPoints = points.size();
// If there are no points to deform then we can bail early
if (numPoints == 0)
{
return true;
}
// allocate output data
outputPoints.resize(numPoints);
float width = wavelength;
float height = 10.0f * multiplier;
float freq = 10.0f;
// compute deformation
std::transform(points.begin(), points.end(), outputPoints.begin(), [=](const GfVec3f& point) -> GfVec3f {
float tx = freq * (point[0] - width) / width;
float ty = 1.5f * freq * (point[1] - width) / width;
float z = point[2] + height * (sin(tx) + cos(ty));
return { point[0], point[1], z };
});
return true;
}
};
REGISTER_OGN_NODE()
} // namespace examples
} // namespace graph
} // namespace omni
| 2,279 |
C++
| 25.823529 | 113 | 0.648091 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.