{
    "nodes": {
        "omni.graph.tutorials.Empty": {
            "description": "This is a tutorial node. It does absolutely nothing and is only meant to  serve as an example to use for setting up your build.",
            "version": 1,
            "extension": "omni.graph.tutorials",
            "language": "C++"
        },
        "omni.graph.tutorials.SimpleDataPy": {
            "description": "This is a tutorial node. It creates both an input and output attribute of every simple  supported data type. The values are modified in a simple way so that the compute modifies values.  It is the same as node omni.graph.tutorials.SimpleData, except it is implemented in Python instead of C++.",
            "version": 1,
            "extension": "omni.graph.tutorials",
            "language": "Python"
        },
        "omni.graph.tutorials.ComplexDataPy": {
            "description": "This is a tutorial node written in Python. It will compute the point3f array by multiplying each element of the float array by the three element vector in the multiplier.",
            "version": 1,
            "extension": "omni.graph.tutorials",
            "language": "Python"
        },
        "omni.graph.tutorials.AbiPy": {
            "description": "This tutorial node shows how to override ABI methods on your Python node. The algorithm of the node converts an RGB color into HSV components.",
            "version": 1,
            "extension": "omni.graph.tutorials",
            "language": "Python"
        },
        "omni.graph.tutorials.StatePy": {
            "description": "This is a tutorial node. It makes use of internal state information to continuously increment an output.",
            "version": 1,
            "extension": "omni.graph.tutorials",
            "language": "Python"
        },
        "omni.graph.tutorials.Defaults": {
            "description": "This is a tutorial node. It will move the values of inputs to corresponding outputs. Inputs all have unspecified, and therefore empty, default values.",
            "version": 1,
            "extension": "omni.graph.tutorials",
            "language": "C++"
        },
        "omni.graph.tutorials.BundleManipulation": {
            "description": "This is a tutorial node. It exercises functionality for the manipulation of bundle attribute contents.",
            "version": 1,
            "extension": "omni.graph.tutorials",
            "language": "C++"
        },
        "omni.graph.tutorials.BundleManipulationPy": {
            "description": "This is a tutorial node. It exercises functionality for the manipulation of bundle attribute contents. The configuration is the same as omni.graph.tutorials.BundleManipulation except that the implementation language is Python",
            "version": 1,
            "extension": "omni.graph.tutorials",
            "language": "Python"
        },
        "omni.graph.tutorials.BundleData": {
            "description": "This is a tutorial node. It exercises functionality for access of data within bundle attributes.",
            "version": 1,
            "extension": "omni.graph.tutorials",
            "language": "C++"
        },
        "omni.graph.tutorials.BundleDataPy": {
            "description": "This is a tutorial node. It exercises functionality for access of data within bundle attributes. The configuration is the same as omni.graph.tutorials.BundleData except that the implementation language is Python",
            "version": 1,
            "extension": "omni.graph.tutorials",
            "language": "Python"
        },
        "omni.graph.tutorials.StateAttributesPy": {
            "description": "This is a tutorial node. It exercises state attributes to remember data from on evaluation to the next.",
            "version": 1,
            "extension": "omni.graph.tutorials",
            "language": "Python"
        },
        "omni.graph.tutorials.State": {
            "description": "This is a tutorial node. It makes use of internal state information to continuously increment an output.",
            "version": 1,
            "extension": "omni.graph.tutorials",
            "language": "C++"
        },
        "omni.graph.tutorials.ExtendedTypes": {
            "description": "This is a tutorial node. It exercises functionality for the manipulation of the extended attribute types.",
            "version": 1,
            "extension": "omni.graph.tutorials",
            "language": "C++"
        },
        "omni.graph.tutorials.ExtendedTypesPy": {
            "description": "This is a tutorial node. It exercises functionality for the manipulation of the extended attribute types. It is identical to OgnTutorialExtendedTypes.ogn, except the language of implementation is selected to be python.",
            "version": 1,
            "extension": "omni.graph.tutorials",
            "language": "Python"
        },
        "omni.graph.tutorials.SimpleData": {
            "description": "This is a tutorial node. It creates both an input and output attribute of every simple supported data type. The values are modified in a simple way so that the compute modifies values.",
            "version": 1,
            "extension": "omni.graph.tutorials",
            "language": "C++"
        },
        "omni.graph.tutorials.Tokens": {
            "description": "This is a tutorial node. It exercises the feature of providing hardcoded token values in the database after a node type has been initialized. It sets output booleans to the truth value of whether corresponding inputs appear in the hardcoded token list.",
            "version": 1,
            "extension": "omni.graph.tutorials",
            "language": "C++"
        },
        "omni.graph.tutorials.TokensPy": {
            "description": "This is a tutorial node. It exercises the feature of providing hardcoded token values in the database after a node type has been initialized. It sets output booleans to the truth value of whether corresponding inputs appear in the hardcoded token list.",
            "version": 1,
            "extension": "omni.graph.tutorials",
            "language": "Python"
        },
        "omni.graph.tutorials.BundleAddAttributes": {
            "description": "This is a tutorial node. It exercises functionality for adding and removing attributes on output bundles.",
            "version": 1,
            "extension": "omni.graph.tutorials",
            "language": "C++"
        },
        "omni.graph.tutorials.BundleAddAttributesPy": {
            "description": "This is a Python tutorial node. It exercises functionality for adding and removing attributes on output bundles.",
            "version": 1,
            "extension": "omni.graph.tutorials",
            "language": "Python"
        },
        "omni.graph.tutorials.CpuGpuBundles": {
            "description": "This is a tutorial node. It exercises functionality for accessing data in bundles that are on the GPU as well as bundles whose CPU/GPU location is decided at runtime. The compute looks for bundled attributes named 'points' and, if they are found, computes their dot products. If the bundle on the output contains an integer array type named 'dotProducts' then the results are placed there, otherwise a new attribute of that name and type is created on the output bundle to hold the results. This node is identical to OgnTutorialCpuGpuBundlesPy.ogn, except it is implemented in C++.",
            "version": 1,
            "extension": "omni.graph.tutorials",
            "language": "C++"
        },
        "omni.graph.tutorials.CpuGpuBundlesPy": {
            "description": "This is a tutorial node. It exercises functionality for accessing data in bundles that are on the GPU as well as bundles whose CPU/GPU location is decided at runtime. The compute looks for bundled attributes named 'points' and, if they are found, computes the dot products. If the bundle on the output contains an integer array type named 'dotProducts' then the results are placed there, otherwise a new attribute of that name and type is created on the output bundle to hold the results. This node is identical to OgnTutorialCpuGpuBundles.ogn, except is is implemented in Python.",
            "version": 1,
            "extension": "omni.graph.tutorials",
            "language": "Python"
        },
        "omni.graph.tutorials.CpuGpuExtended": {
            "description": "This is a tutorial node. It exercises functionality for accessing data in extended attributes that are on the GPU as well as those whose CPU/GPU location is decided at runtime. The compute adds the two inputs 'gpuData' and 'cpuData' together, placing the result in `cpuGpuSum`, whose memory location is determined by the 'gpu' flag. This node is identical to OgnTutorialCpuGpuExtendedPy.ogn, except is is implemented in C++.",
            "version": 1,
            "extension": "omni.graph.tutorials",
            "language": "C++"
        },
        "omni.graph.tutorials.CpuGpuExtendedPy": {
            "description": "This is a tutorial node. It exercises functionality for accessing data in extended attributes that are on the GPU as well as those whose CPU/GPU location is decided at runtime. The compute adds the two inputs 'gpuData' and 'cpuData' together, placing the result in `cpuGpuSum`, whose memory location is determined by the 'gpu' flag. This node is identical to OgnTutorialCpuGpuExtended.ogn, except is is implemented in Python.",
            "version": 1,
            "extension": "omni.graph.tutorials",
            "language": "Python"
        },
        "omni.graph.tutorials.OverrideType": {
            "description": "This is a tutorial node. It has an input and output of type float[3], an input and output of type double[3], and a type override specification that lets the node use Carbonite types for the generated data on the float[3] attributes only. Ordinarily all of the types would be defined in a seperate configuration file so that it can be shared for a project. In that case the type definition build flag would also be used so that this information does not have to be embedded in every .ogn file in the project. It is placed directly in the file here solely for instructional purposes.  The compute is just a rotation of components from x->y, y->z, and z->x, for each input type.",
            "version": 1,
            "extension": "omni.graph.tutorials",
            "language": "C++"
        },
        "omni.graph.tutorials.DynamicAttributes": {
            "description": "This is a Python node that exercises the ability to add and remove database attribute accessors for dynamic attributes. When the dynamic attribute is added the property will exist and be able to get/set the attribute values. When it does not the property will not exist. The dynamic attribute names are found in the tokens below. If neither exist then the input value is copied to the output directly. If 'firstBit' exists then the 'firstBit'th bit of the input is x-ored for the copy. If 'secondBit' exists then the 'secondBit'th bit of the input is x-ored for the copy. (Recall bitwise match xor(0,0)=0, xor(0,1)=1, xor(1,0)=1, and xor(1,1)=0.) For example, if 'firstBit' is present and set to 1 then the bitmask will be b0010, where bit 1 is set. If the input is 7, or b0111, then the xor operation will flip bit 1, yielding b0101, or 5 as the result. If on the next run 'secondBit' is also present and set to 2 then its bitmask will be b0100, where bit 2 is set. The input of 7 (b0111) flips bit 1 because firstBit=1 and flips bit 2 because secondBit=2, yielding a final result of 1 (b0001).",
            "version": 1,
            "extension": "omni.graph.tutorials",
            "language": "C++"
        },
        "omni.graph.tutorials.DynamicAttributesPy": {
            "description": "This is a Python node that exercises the ability to add and remove database attribute accessors for dynamic attributes. When the dynamic attribute is added the property will exist and be able to get/set the attribute values. When it does not the property will not exist. The dynamic attribute names are found in the tokens below. If neither exist then the input value is copied to the output directly. If 'firstBit' exists then the 'firstBit'th bit of the input is x-ored for the copy. If 'secondBit' exists then the 'secondBit'th bit of the input is x-ored for the copy. (Recall bitwise match xor(0,0)=0, xor(0,1)=1, xor(1,0)=1, and xor(1,1)=0.) For example, if 'firstBit' is present and set to 1 then the bitmask will be b0010, where bit 1 is set. If the input is 7, or b0111, then the xor operation will flip bit 1, yielding b0101, or 5 as the result. If on the next run 'secondBit' is also present and set to 2 then its bitmask will be b0100, where bit 2 is set. The input of 7 (b0111) flips bit 1 because firstBit=1 and flips bit 2 because secondBit=2, yielding a final result of 1 (b0001).",
            "version": 1,
            "extension": "omni.graph.tutorials",
            "language": "Python"
        },
        "omni.graph.tutorials.GenericMathNode": {
            "description": "This is a tutorial node. It is functionally equivalent to the built-in Multiply node, but written in python as a practical demonstration of using extended attributes to  write math nodes that work with any numeric types, including arrays and tuples.",
            "version": 1,
            "extension": "omni.graph.tutorials",
            "language": "Python"
        },
        "omni.graph.tutorials.CudaCpuArrays": {
            "description": "This is a tutorial node. It illustrates the alternative method of extracting pointers to GPU array data in which the pointer returned is a CPU pointer and can be dereferenced on the CPU side. Without the cudaPointers value set that pointer would be a GPU pointer to an array of GPU pointers and could only be dereferenced on the device.",
            "version": 1,
            "extension": "omni.graph.tutorials",
            "language": "C++"
        },
        "omni.graph.tutorials.CudaCpuArraysPy": {
            "description": "This is a tutorial node. It illustrates the alternative method of extracting pointers to GPU array data in which the pointer returned is a CPU pointer and can be dereferenced on the CPU side. Without the cudaPointers value set that pointer would be a GPU pointer to an array of GPU pointers and could only be dereferenced on the device. Both plain attribute and bundle attribute extraction are shown.",
            "version": 1,
            "extension": "omni.graph.tutorials",
            "language": "Python"
        },
        "omni.graph.tutorials.Abi": {
            "description": "This tutorial node shows how to override ABI methods on your node.",
            "version": 1,
            "extension": "omni.graph.tutorials",
            "language": "C++"
        },
        "omni.tutorials.TupleData": {
            "description": "This is a tutorial node. It creates both an input and output attribute of some of the supported  tuple types. The values are modified in a simple way so that the compute can be tested.",
            "version": 1,
            "extension": "omni.graph.tutorials",
            "language": "C++"
        },
        "omni.graph.tutorials.ArrayData": {
            "description": "This is a tutorial node. It will compute the array 'result' as the input array 'original'  with every element multiplied by the constant 'multiplier'.",
            "version": 1,
            "extension": "omni.graph.tutorials",
            "language": "C++"
        },
        "omni.graph.tutorials.TupleArrays": {
            "description": "This is a tutorial node. It will compute the float array 'result' as the elementwise dot  product of the input arrays 'a' and 'b'.",
            "version": 1,
            "extension": "omni.graph.tutorials",
            "language": "C++"
        },
        "omni.graph.tutorials.RoleData": {
            "description": "This is a tutorial node. It creates both an input and output attribute of every supported  role-based data type. The values are modified in a simple way so that the compute modifies values. ",
            "version": 1,
            "extension": "omni.graph.tutorials",
            "language": "C++"
        },
        "omni.graph.tutorials.CudaData": {
            "description": "This is a tutorial node. It performs different functions on the GPU to illustrate different types of data access. The first adds inputs 'a' and 'b' to yield output 'sum', all of which are on the GPU. The second is a sample expansion deformation that multiplies every point on a set of input points, stored on the GPU, by a constant value, stored on the CPU, to yield a set of output points, also on the GPU. The third is an assortment of different data types illustrating how different data is passed to the GPU. This particular node uses CUDA for its GPU computations, as indicated in the memory type value. Normal use case for GPU compute is large amounts of data. For testing purposes this node only handles a very small amount but the principle is the same.",
            "version": 1,
            "extension": "omni.graph.tutorials",
            "language": "C++"
        },
        "omni.graph.tutorials.CpuGpuData": {
            "description": "This is a tutorial node. It illustrates how to access data whose memory location, CPU or GPU, is  determined at runtime in the compute method. The data types are the same as for the purely CPU and  purely GPU tutorials, it is only the access method that changes. The input 'is_gpu' determines where  the data of the other attributes can be accessed.",
            "version": 1,
            "extension": "omni.graph.tutorials",
            "language": "C++"
        }
    }
}
