"""Support for simplified access to data on nodes of type omni.syntheticdata.SdPostCompRenderVarTextures

Synthetic Data node to compose a front renderVar texture into a back renderVar texture
"""

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 OgnSdPostCompRenderVarTexturesDatabase(og.Database):
    """Helper class providing simplified access to data on nodes of type omni.syntheticdata.SdPostCompRenderVarTextures

    Class Members:
        node: Node being evaluated

    Attribute Value Properties:
        Inputs:
            inputs.cudaPtr
            inputs.format
            inputs.gpu
            inputs.height
            inputs.mode
            inputs.parameters
            inputs.renderVar
            inputs.rp
            inputs.width

    Predefined Tokens:
        tokens.line
        tokens.grid
    """

    # 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:cudaPtr', 'uint64', 0, None, 'Front texture CUDA pointer', {}, True, 0, False, ''),
        ('inputs:format', 'uint64', 0, None, 'Front texture format', {}, True, 0, False, ''),
        ('inputs:gpu', 'uint64', 0, 'gpuFoundations', 'Pointer to shared context containing gpu foundations', {}, True, 0, False, ''),
        ('inputs:height', 'uint', 0, None, 'Front texture height', {}, True, 0, False, ''),
        ('inputs:mode', 'token', 0, None, 'Mode : grid, line', {ogn.MetadataKeys.DEFAULT: '"line"'}, True, "line", False, ''),
        ('inputs:parameters', 'float3', 0, None, 'Parameters', {ogn.MetadataKeys.DEFAULT: '[0, 0, 0]'}, True, [0, 0, 0], False, ''),
        ('inputs:renderVar', 'token', 0, None, 'Name of the back RenderVar', {ogn.MetadataKeys.DEFAULT: '"LdrColor"'}, True, "LdrColor", False, ''),
        ('inputs:rp', 'uint64', 0, 'renderProduct', 'Pointer to render product for this view', {}, True, 0, False, ''),
        ('inputs:width', 'uint', 0, None, 'Front texture width', {}, True, 0, False, ''),
    ])

    class tokens:
        line = "line"
        grid = "grid"

    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 cudaPtr(self):
            data_view = og.AttributeValueHelper(self._attributes.cudaPtr)
            return data_view.get()

        @cudaPtr.setter
        def cudaPtr(self, value):
            if self._setting_locked:
                raise og.ReadOnlyError(self._attributes.cudaPtr)
            data_view = og.AttributeValueHelper(self._attributes.cudaPtr)
            data_view.set(value)

        @property
        def format(self):
            data_view = og.AttributeValueHelper(self._attributes.format)
            return data_view.get()

        @format.setter
        def format(self, value):
            if self._setting_locked:
                raise og.ReadOnlyError(self._attributes.format)
            data_view = og.AttributeValueHelper(self._attributes.format)
            data_view.set(value)

        @property
        def gpu(self):
            data_view = og.AttributeValueHelper(self._attributes.gpu)
            return data_view.get()

        @gpu.setter
        def gpu(self, value):
            if self._setting_locked:
                raise og.ReadOnlyError(self._attributes.gpu)
            data_view = og.AttributeValueHelper(self._attributes.gpu)
            data_view.set(value)

        @property
        def height(self):
            data_view = og.AttributeValueHelper(self._attributes.height)
            return data_view.get()

        @height.setter
        def height(self, value):
            if self._setting_locked:
                raise og.ReadOnlyError(self._attributes.height)
            data_view = og.AttributeValueHelper(self._attributes.height)
            data_view.set(value)

        @property
        def mode(self):
            data_view = og.AttributeValueHelper(self._attributes.mode)
            return data_view.get()

        @mode.setter
        def mode(self, value):
            if self._setting_locked:
                raise og.ReadOnlyError(self._attributes.mode)
            data_view = og.AttributeValueHelper(self._attributes.mode)
            data_view.set(value)

        @property
        def parameters(self):
            data_view = og.AttributeValueHelper(self._attributes.parameters)
            return data_view.get()

        @parameters.setter
        def parameters(self, value):
            if self._setting_locked:
                raise og.ReadOnlyError(self._attributes.parameters)
            data_view = og.AttributeValueHelper(self._attributes.parameters)
            data_view.set(value)

        @property
        def renderVar(self):
            data_view = og.AttributeValueHelper(self._attributes.renderVar)
            return data_view.get()

        @renderVar.setter
        def renderVar(self, value):
            if self._setting_locked:
                raise og.ReadOnlyError(self._attributes.renderVar)
            data_view = og.AttributeValueHelper(self._attributes.renderVar)
            data_view.set(value)

        @property
        def rp(self):
            data_view = og.AttributeValueHelper(self._attributes.rp)
            return data_view.get()

        @rp.setter
        def rp(self, value):
            if self._setting_locked:
                raise og.ReadOnlyError(self._attributes.rp)
            data_view = og.AttributeValueHelper(self._attributes.rp)
            data_view.set(value)

        @property
        def width(self):
            data_view = og.AttributeValueHelper(self._attributes.width)
            return data_view.get()

        @width.setter
        def width(self, value):
            if self._setting_locked:
                raise og.ReadOnlyError(self._attributes.width)
            data_view = og.AttributeValueHelper(self._attributes.width)
            data_view.set(value)

        def _prefetch(self):
            readAttributes = self._batchedReadAttributes
            newValues = _og._prefetch_input_attributes_data(readAttributes)
            if len(readAttributes) == len(newValues):
                self._batchedReadValues = newValues

    class ValuesForOutputs(og.DynamicAttributeAccess):
        LOCAL_PROPERTY_NAMES = { }
        """Helper class that creates natural hierarchical access to output attributes"""
        def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
            """Initialize simplified access for the attribute data"""
            context = node.get_graph().get_default_graph_context()
            super().__init__(context, node, attributes, dynamic_attributes)
            self._batchedWriteValues = { }

        def _commit(self):
            _og._commit_output_attributes_data(self._batchedWriteValues)
            self._batchedWriteValues = { }

    class ValuesForState(og.DynamicAttributeAccess):
        """Helper class that creates natural hierarchical access to state attributes"""
        def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
            """Initialize simplified access for the attribute data"""
            context = node.get_graph().get_default_graph_context()
            super().__init__(context, node, attributes, dynamic_attributes)

    def __init__(self, node):
        super().__init__(node)
        dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_INPUT)
        self.inputs = OgnSdPostCompRenderVarTexturesDatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
        dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
        self.outputs = OgnSdPostCompRenderVarTexturesDatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
        dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
        self.state = OgnSdPostCompRenderVarTexturesDatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
