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

Synthetic Data node to copy the input aov texture into the corresponding visualization 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 OgnSdPostRenderVarDisplayTextureDatabase(og.Database):
    """Helper class providing simplified access to data on nodes of type omni.syntheticdata.SdPostRenderVarDisplayTexture

    Class Members:
        node: Node being evaluated

    Attribute Value Properties:
        Inputs:
            inputs.cameraFisheyeParams
            inputs.cameraModel
            inputs.cameraNearFar
            inputs.exec
            inputs.gpu
            inputs.instanceMapSDCudaPtr
            inputs.instanceMappingInfoSDPtr
            inputs.metersPerSceneUnit
            inputs.mode
            inputs.parameters
            inputs.renderVar
            inputs.renderVarDisplay
            inputs.rp
            inputs.sdDisplayHeight
            inputs.sdDisplayWidth
            inputs.sdSemBBox3dCamCornersCudaPtr
            inputs.sdSemBBox3dCamExtentCudaPtr
            inputs.sdSemBBoxExtentCudaPtr
            inputs.sdSemBBoxInfosCudaPtr
            inputs.semanticLabelTokenSDCudaPtr
            inputs.semanticMapSDCudaPtr
            inputs.semanticPrimTokenSDCudaPtr
            inputs.semanticWorldTransformSDCudaPtr
        Outputs:
            outputs.cudaPtr
            outputs.exec
            outputs.format
            outputs.height
            outputs.renderVarDisplay
            outputs.width

    Predefined Tokens:
        tokens.LdrColorSD
        tokens.Camera3dPositionSD
        tokens.DistanceToImagePlaneSD
        tokens.DistanceToCameraSD
        tokens.InstanceSegmentationSD
        tokens.SemanticSegmentationSD
        tokens.NormalSD
        tokens.TargetMotionSD
        tokens.BoundingBox2DTightSD
        tokens.BoundingBox2DLooseSD
        tokens.BoundingBox3DSD
        tokens.OcclusionSD
        tokens.TruncationSD
        tokens.CrossCorrespondenceSD
        tokens.SemanticBoundingBox2DExtentTightSD
        tokens.SemanticBoundingBox2DInfosTightSD
        tokens.SemanticBoundingBox2DExtentLooseSD
        tokens.SemanticBoundingBox2DInfosLooseSD
        tokens.SemanticBoundingBox3DExtentSD
        tokens.SemanticBoundingBox3DInfosSD
        tokens.SemanticBoundingBox3DCamCornersSD
        tokens.SemanticBoundingBox3DDisplayAxesSD
        tokens.autoMode
        tokens.colorMode
        tokens.scaled3dVectorMode
        tokens.clippedValueMode
        tokens.normalized3dVectorMode
        tokens.segmentationMapMode
        tokens.instanceMapMode
        tokens.semanticPathMode
        tokens.semanticLabelMode
        tokens.semanticBoundingBox2dMode
        tokens.rawBoundingBox2dMode
        tokens.semanticProjBoundingBox3dMode
        tokens.semanticBoundingBox3dMode
        tokens.rawBoundingBox3dMode
        tokens.pinhole
        tokens.perspective
        tokens.orthographic
        tokens.fisheyePolynomial
    """

    # 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:cameraFisheyeParams', 'float[]', 0, None, 'Camera fisheye projection parameters', {}, True, [], False, ''),
        ('inputs:cameraModel', 'int', 0, None, 'Camera model (pinhole or fisheye models)', {}, True, 0, False, ''),
        ('inputs:cameraNearFar', 'float2', 0, None, 'Camera near/far clipping range', {}, True, [0.0, 0.0], False, ''),
        ('inputs:exec', 'execution', 0, None, 'Trigger', {}, True, None, False, ''),
        ('inputs:gpu', 'uint64', 0, 'gpuFoundations', 'Pointer to shared context containing gpu foundations', {}, True, 0, False, ''),
        ('inputs:instanceMapSDCudaPtr', 'uint64', 0, None, 'cuda uint16_t buffer pointer of size numInstances containing the instance parent semantic index', {}, True, 0, False, ''),
        ('inputs:instanceMappingInfoSDPtr', 'uint64', 0, None, 'uint buffer pointer containing the following information : [numInstances, minInstanceId, numSemantics, minSemanticId, numProtoSemantic]', {}, True, 0, False, ''),
        ('inputs:metersPerSceneUnit', 'float', 0, None, 'Scene units to meters scale', {}, True, 0.0, False, ''),
        ('inputs:mode', 'token', 0, None, 'Display mode', {ogn.MetadataKeys.DEFAULT: '"autoMode"'}, True, "autoMode", False, ''),
        ('inputs:parameters', 'float4', 0, None, 'Display parameters', {ogn.MetadataKeys.DEFAULT: '[0.0, 5.0, 0.33, 0.27]'}, True, [0.0, 5.0, 0.33, 0.27], False, ''),
        ('inputs:renderVar', 'token', 0, None, 'Name of the input RenderVar to display', {}, True, "", False, ''),
        ('inputs:renderVarDisplay', 'token', 0, None, 'Name of the output display RenderVar', {}, True, "", False, ''),
        ('inputs:rp', 'uint64', 0, 'renderProduct', 'Pointer to render product for this view', {}, True, 0, False, ''),
        ('inputs:sdDisplayHeight', 'uint', 0, None, 'Visualization texture Height', {}, True, 0, False, ''),
        ('inputs:sdDisplayWidth', 'uint', 0, None, 'Visualization texture width', {}, True, 0, False, ''),
        ('inputs:sdSemBBox3dCamCornersCudaPtr', 'uint64', 0, None, 'Cuda buffer containing the projection of the 3d bounding boxes on the camera plane represented as a float3=(u,v,z,a) for each bounding box corners', {}, True, 0, False, ''),
        ('inputs:sdSemBBox3dCamExtentCudaPtr', 'uint64', 0, None, 'Cuda buffer containing the 2d extent of the 3d bounding boxes on the camera plane represented as a float6=(u_min,u_max,v_min,v_max,z_min,z_max)', {}, True, 0, False, ''),
        ('inputs:sdSemBBoxExtentCudaPtr', 'uint64', 0, None, 'Cuda buffer containing the extent of the bounding boxes as a float4=(u_min,v_min,u_max,v_max) for 2D or a float6=(xmin,ymin,zmin,xmax,ymax,zmax) in object space for 3D', {}, True, 0, False, ''),
        ('inputs:sdSemBBoxInfosCudaPtr', 'uint64', 0, None, 'Cuda buffer containing valid bounding boxes infos', {}, True, 0, False, ''),
        ('inputs:semanticLabelTokenSDCudaPtr', 'uint64', 0, None, 'cuda uint64_t buffer pointer of size numSemantics containing the semantic label token', {}, True, 0, False, ''),
        ('inputs:semanticMapSDCudaPtr', 'uint64', 0, None, 'cuda uint16_t buffer pointer of size numSemantics containing the semantic parent semantic index', {}, True, 0, False, ''),
        ('inputs:semanticPrimTokenSDCudaPtr', 'uint64', 0, None, 'cuda uint64_t buffer pointer of size numSemantics containing the semantic path token', {}, True, 0, False, ''),
        ('inputs:semanticWorldTransformSDCudaPtr', 'uint64', 0, None, 'cuda float44 buffer pointer of size numSemantics containing the world semantic transform', {}, True, 0, False, ''),
        ('outputs:cudaPtr', 'uint64', 0, None, 'Display texture CUDA pointer', {}, True, None, False, ''),
        ('outputs:exec', 'execution', 0, None, 'Trigger', {}, True, None, False, ''),
        ('outputs:format', 'uint64', 0, None, 'Display texture format', {}, True, None, False, ''),
        ('outputs:height', 'uint', 0, None, 'Display texture height', {}, True, None, False, ''),
        ('outputs:renderVarDisplay', 'token', 0, None, 'Name of the output display RenderVar', {}, True, None, False, ''),
        ('outputs:width', 'uint', 0, None, 'Display texture width', {}, True, None, False, ''),
    ])

    class tokens:
        LdrColorSD = "LdrColorSD"
        Camera3dPositionSD = "Camera3dPositionSD"
        DistanceToImagePlaneSD = "DistanceToImagePlaneSD"
        DistanceToCameraSD = "DistanceToCameraSD"
        InstanceSegmentationSD = "InstanceSegmentationSD"
        SemanticSegmentationSD = "SemanticSegmentationSD"
        NormalSD = "NormalSD"
        TargetMotionSD = "TargetMotionSD"
        BoundingBox2DTightSD = "BoundingBox2DTightSD"
        BoundingBox2DLooseSD = "BoundingBox2DLooseSD"
        BoundingBox3DSD = "BoundingBox3DSD"
        OcclusionSD = "OcclusionSD"
        TruncationSD = "TruncationSD"
        CrossCorrespondenceSD = "CrossCorrespondenceSD"
        SemanticBoundingBox2DExtentTightSD = "SemanticBoundingBox2DExtentTightSD"
        SemanticBoundingBox2DInfosTightSD = "SemanticBoundingBox2DInfosTightSD"
        SemanticBoundingBox2DExtentLooseSD = "SemanticBoundingBox2DExtentLooseSD"
        SemanticBoundingBox2DInfosLooseSD = "SemanticBoundingBox2DInfosLooseSD"
        SemanticBoundingBox3DExtentSD = "SemanticBoundingBox3DExtentSD"
        SemanticBoundingBox3DInfosSD = "SemanticBoundingBox3DInfosSD"
        SemanticBoundingBox3DCamCornersSD = "SemanticBoundingBox3DCamCornersSD"
        SemanticBoundingBox3DDisplayAxesSD = "SemanticBoundingBox3DDisplayAxesSD"
        autoMode = "autoMode"
        colorMode = "colorMode"
        scaled3dVectorMode = "scaled3dVectorMode"
        clippedValueMode = "clippedValueMode"
        normalized3dVectorMode = "normalized3dVectorMode"
        segmentationMapMode = "segmentationMapMode"
        instanceMapMode = "instanceMapMode"
        semanticPathMode = "semanticPathMode"
        semanticLabelMode = "semanticLabelMode"
        semanticBoundingBox2dMode = "semanticBoundingBox2dMode"
        rawBoundingBox2dMode = "rawBoundingBox2dMode"
        semanticProjBoundingBox3dMode = "semanticProjBoundingBox3dMode"
        semanticBoundingBox3dMode = "semanticBoundingBox3dMode"
        rawBoundingBox3dMode = "rawBoundingBox3dMode"
        pinhole = "pinhole"
        perspective = "perspective"
        orthographic = "orthographic"
        fisheyePolynomial = "fisheyePolynomial"

    @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.exec = og.AttributeRole.EXECUTION
        role_data.outputs.exec = og.AttributeRole.EXECUTION
        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 cameraFisheyeParams(self):
            data_view = og.AttributeValueHelper(self._attributes.cameraFisheyeParams)
            return data_view.get()

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

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

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

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

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

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

        @exec.setter
        def exec(self, value):
            if self._setting_locked:
                raise og.ReadOnlyError(self._attributes.exec)
            data_view = og.AttributeValueHelper(self._attributes.exec)
            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 instanceMapSDCudaPtr(self):
            data_view = og.AttributeValueHelper(self._attributes.instanceMapSDCudaPtr)
            return data_view.get()

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

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

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

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

        @metersPerSceneUnit.setter
        def metersPerSceneUnit(self, value):
            if self._setting_locked:
                raise og.ReadOnlyError(self._attributes.metersPerSceneUnit)
            data_view = og.AttributeValueHelper(self._attributes.metersPerSceneUnit)
            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 renderVarDisplay(self):
            data_view = og.AttributeValueHelper(self._attributes.renderVarDisplay)
            return data_view.get()

        @renderVarDisplay.setter
        def renderVarDisplay(self, value):
            if self._setting_locked:
                raise og.ReadOnlyError(self._attributes.renderVarDisplay)
            data_view = og.AttributeValueHelper(self._attributes.renderVarDisplay)
            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 sdDisplayHeight(self):
            data_view = og.AttributeValueHelper(self._attributes.sdDisplayHeight)
            return data_view.get()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        @semanticWorldTransformSDCudaPtr.setter
        def semanticWorldTransformSDCudaPtr(self, value):
            if self._setting_locked:
                raise og.ReadOnlyError(self._attributes.semanticWorldTransformSDCudaPtr)
            data_view = og.AttributeValueHelper(self._attributes.semanticWorldTransformSDCudaPtr)
            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 cudaPtr(self):
            data_view = og.AttributeValueHelper(self._attributes.cudaPtr)
            return data_view.get()

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

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

        @exec.setter
        def exec(self, value):
            data_view = og.AttributeValueHelper(self._attributes.exec)
            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):
            data_view = og.AttributeValueHelper(self._attributes.format)
            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):
            data_view = og.AttributeValueHelper(self._attributes.height)
            data_view.set(value)

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

        @renderVarDisplay.setter
        def renderVarDisplay(self, value):
            data_view = og.AttributeValueHelper(self._attributes.renderVarDisplay)
            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):
            data_view = og.AttributeValueHelper(self._attributes.width)
            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 = OgnSdPostRenderVarDisplayTextureDatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
        dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
        self.outputs = OgnSdPostRenderVarDisplayTextureDatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
        dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
        self.state = OgnSdPostRenderVarDisplayTextureDatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
