#usda 1.0
(
    customLayerData = {
        dictionary cameraSettings = {
            dictionary Front = {
                double3 position = (0, 0, 50000)
                double radius = 500
            }
            dictionary Perspective = {
                double3 position = (500.0000000000001, 500.0000000000001, 499.9999999999998)
                double3 target = (0, 0, 0)
            }
            dictionary Right = {
                double3 position = (-50000, 0, -1.1102230246251565e-11)
                double radius = 500
            }
            dictionary Top = {
                double3 position = (-4.329780281177466e-12, 50000, 1.1102230246251565e-11)
                double radius = 500
            }
            string boundCamera = "/OmniverseKit_Persp"
        }
        dictionary omni_layer = {
            dictionary muteness = {
            }
        }
        dictionary renderSettings = {
        }
    }
    defaultPrim = "World"
    endTimeCode = 100
    metersPerUnit = 0.01
    startTimeCode = 0
    timeCodesPerSecond = 24
    upAxis = "Y"
)

def Xform "World"
{
    def DistantLight "defaultLight" (
        prepend apiSchemas = ["ShapingAPI"]
    )
    {
        float angle = 1
        float intensity = 3000
        float shaping:cone:angle = 180
        float shaping:cone:softness
        float shaping:focus
        color3f shaping:focusTint
        asset shaping:ies:file
        double3 xformOp:rotateXYZ = (315, 0, 0)
        double3 xformOp:scale = (1, 1, 1)
        double3 xformOp:translate = (0, 0, 0)
        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
    }

    def ComputeGraph "ActionGraph"
    {
        def ComputeGraphSettings "computegraphSettings"
        {
            custom token evaluator:type = "execution"
            custom int2 fileFormatVersion = (1, 3)
            custom token flatCacheBacking = "Shared"
            custom token pipelineStage = "pipelineStageSimulation"
        }

        def ComputeNode "execinputenabledtest" (
            prepend apiSchemas = ["NodeGraphNodeAPI"]
        )
        {
            custom uint inputs:execInA = 0
            prepend uint inputs:execInA.connect = </World/ActionGraph/on_impulse_event_A1.outputs:execOut>
            custom uint inputs:execInB = 0
            prepend uint inputs:execInB.connect = </World/ActionGraph/on_impulse_event_B.outputs:execOut>
            custom token node:type = "omni.graph.test.ExecInputEnabledTest"
            custom int node:typeVersion = 1
            custom uint outputs:execOutA (
                customData = {
                    bool isExecution = 1
                }
            )
            custom uint outputs:execOutB (
                customData = {
                    bool isExecution = 1
                }
            )
            uniform token ui:nodegraph:node:expansionState = "open"
            uniform float2 ui:nodegraph:node:pos = (265, 127)
        }

        def ComputeNode "on_impulse_event_A1" (
            prepend apiSchemas = ["NodeGraphNodeAPI"]
        )
        {
            custom bool inputs:onlyPlayback = 0
            custom token node:type = "omni.graph.action.OnImpulseEvent"
            custom int node:typeVersion = 2
            custom uint outputs:execOut = 0 (
                customData = {
                    bool isExecution = 1
                }
            )
            custom bool state:enableImpulse = 0
            uniform token ui:nodegraph:node:expansionState = "open"
            uniform float2 ui:nodegraph:node:pos = (-1, 43)
        }

        def ComputeNode "on_impulse_event_A2" (
            prepend apiSchemas = ["NodeGraphNodeAPI"]
        )
        {
            custom bool inputs:onlyPlayback = 0
            custom token node:type = "omni.graph.action.OnImpulseEvent"
            custom int node:typeVersion = 2
            custom uint outputs:execOut = 0 (
                customData = {
                    bool isExecution = 1
                }
            )
            custom bool state:enableImpulse = 0
            uniform token ui:nodegraph:node:expansionState = "open"
            uniform float2 ui:nodegraph:node:pos = (0, 154)
        }

        def ComputeNode "on_impulse_event_B" (
            prepend apiSchemas = ["NodeGraphNodeAPI"]
        )
        {
            custom bool inputs:onlyPlayback = 0
            custom token node:type = "omni.graph.action.OnImpulseEvent"
            custom int node:typeVersion = 2
            custom uint outputs:execOut = 0 (
                customData = {
                    bool isExecution = 1
                }
            )
            custom bool state:enableImpulse = 0
            uniform token ui:nodegraph:node:expansionState = "open"
            uniform float2 ui:nodegraph:node:pos = (-2, 270)
        }

        def ComputeNode "counter_A" (
            prepend apiSchemas = ["NodeGraphNodeAPI"]
        )
        {
            custom uint inputs:execIn = 0
            prepend uint inputs:execIn.connect = </World/ActionGraph/execinputenabledtest.outputs:execOutA>
            custom uint inputs:reset
            custom token node:type = "omni.graph.action.Counter"
            custom int node:typeVersion = 1
            custom int outputs:count
            custom uint outputs:execOut (
                customData = {
                    bool isExecution = 1
                }
            )
            custom int state:count
            uniform token ui:nodegraph:node:expansionState = "open"
            uniform float2 ui:nodegraph:node:pos = (525, 73)
        }

        def ComputeNode "counter_B" (
            prepend apiSchemas = ["NodeGraphNodeAPI"]
        )
        {
            custom uint inputs:execIn = 0
            prepend uint inputs:execIn.connect = </World/ActionGraph/execinputenabledtest.outputs:execOutB>
            custom uint inputs:reset
            custom token node:type = "omni.graph.action.Counter"
            custom int node:typeVersion = 1
            custom int outputs:count
            custom uint outputs:execOut (
                customData = {
                    bool isExecution = 1
                }
            )
            custom int state:count
            uniform token ui:nodegraph:node:expansionState = "open"
            uniform float2 ui:nodegraph:node:pos = (528, 238)
        }
    }
}

