#usda 1.0
(
    customLayerData = {
        dictionary cameraSettings = {
            string boundCamera = "/CameraRoot/Camera"
        }
        dictionary renderSettings = {
            int "rtx:post:dlss:execMode" = 0
            bool "rtx:translucency:enabled" = 0
        }
    }
    defaultPrim = "World"
    endTimeCode = 36000
    metersPerUnit = 0.01
    startTimeCode = 0
    timeCodesPerSecond = 60
    upAxis = "Y"
)

def Xform "World"
{
    def OmniGraph "ActionGraph"
    {
        token evaluationMode = "Automatic"
        token evaluator:type = "execution"
        token fabricCacheBacking = "Shared"
        int2 fileFormatVersion = (1, 7)
        token pipelineStage = "pipelineStageSimulation"

        def OmniGraphNode "on_loaded" (
            prepend apiSchemas = ["NodeGraphNodeAPI"]
        )
        {
            token node:type = "omni.graph.action.OnLoaded"
            int node:typeVersion = 1
            custom uint outputs:execOut (
                customData = {
                    bool isExecution = 1
                }
            )
            uniform token ui:nodegraph:node:expansionState = "minimized"
            uniform float2 ui:nodegraph:node:pos = (430, -120)
        }

        def OmniGraphNode "on_tick" (
            prepend apiSchemas = ["NodeGraphNodeAPI"]
        )
        {
            custom uint inputs:framePeriod = 0
            custom bool inputs:onlyPlayback = 1
            token node:type = "omni.graph.action.OnTick"
            int node:typeVersion = 1
            custom double outputs:absoluteSimTime
            custom double outputs:deltaSeconds
            custom double outputs:frame
            custom bool outputs:isPlaying
            custom uint outputs:tick (
                customData = {
                    bool isExecution = 1
                }
            )
            custom double outputs:time
            custom double outputs:timeSinceStart
            custom double state:accumulatedSeconds = 0
            custom uint state:frameCount = 0
            uniform token ui:nodegraph:node:expansionState = "minimized"
            uniform float2 ui:nodegraph:node:pos = (490, 40)
        }

        def OmniGraphNode "read_xform" (
            prepend apiSchemas = ["NodeGraphNodeAPI"]
        )
        {
            custom rel inputs:prim = </World/Cloth> (
                customData = {
                    dictionary omni = {
                        dictionary graph = {
                            string relType = "target"
                        }
                    }
                }
            )
            custom token inputs:primPath = ""
            custom bool inputs:usePath = 0
            token node:type = "omni.graph.nodes.GetPrimLocalToWorldTransform"
            int node:typeVersion = 2
            custom matrix4d outputs:localToWorldTransform
            uniform token ui:nodegraph:node:expansionState = "minimized"
            uniform float2 ui:nodegraph:node:pos = (500, -250)
        }

        def OmniGraphNode "read_collider" (
            prepend apiSchemas = ["NodeGraphNodeAPI"]
        )
        {
            custom int inputs:_debugStamp
            custom bool inputs:applySkelBinding = 0
            custom string inputs:attrNamesToImport = "*"
            custom bool inputs:computeBoundingBox = 0
            custom bool inputs:enableBundleChangeTracking = 1
            custom bool inputs:enableChangeTracking
            custom string inputs:pathPattern = ""
            custom rel inputs:prims = </World/Collider/Bunny> (
                customData = {
                    dictionary omni = {
                        dictionary graph = {
                            string relType = "target"
                        }
                    }
                }
            )
            custom string inputs:typePattern = "*"
            custom timecode inputs:usdTimecode = nan
            token node:type = "omni.graph.nodes.ReadPrimsV2"
            int node:typeVersion = 1
            custom bool state:applySkelBinding = 0
            custom string state:attrNamesToImport
            custom bool state:computeBoundingBox = 0
            custom bool state:enableBundleChangeTracking
            custom bool state:enableChangeTracking
            custom uint64[] state:inputPrimPaths = []
            custom string state:pathPattern
            custom uint64[] state:primPaths = []
            custom string state:typePattern
            custom timecode state:usdTimecode = -1
            uniform token ui:nodegraph:node:expansionState = "minimized"
            uniform float2 ui:nodegraph:node:pos = (800, 190)

            def Output "outputs_primsBundle"
            {
            }
        }

        def OmniGraphNode "grid_create" (
            prepend apiSchemas = ["NodeGraphNodeAPI"]
        )
        {
            custom int2 inputs:dims = (64, 64)
            custom uint inputs:execIn
            prepend uint inputs:execIn.connect = [
                </World/ActionGraph/on_loaded.outputs:execOut>,
                </World/ActionGraph/on_tick.outputs:tick>,
            ]
            custom float2 inputs:size = (100, 100)
            custom matrix4d inputs:transform
            prepend matrix4d inputs:transform.connect = </World/ActionGraph/read_xform.outputs:localToWorldTransform>
            token node:type = "omni.warp.WarpGridCreate"
            int node:typeVersion = 1
            custom uint outputs:execOut (
                customData = {
                    bool isExecution = 1
                }
            )
            uniform token ui:nodegraph:node:expansionState = "minimized"
            uniform float2 ui:nodegraph:node:pos = (810, -56)

            def Output "outputs_mesh"
            {
            }
        }

        def OmniGraphNode "cloth_simulate" (
            prepend apiSchemas = ["NodeGraphNodeAPI"]
        )
        {
            custom rel inputs:cloth
            prepend rel inputs:cloth = </World/ActionGraph/grid_create/outputs_mesh>
            custom float inputs:clothDensity = 100
            custom float inputs:clothEdgeBendingStiffness = 0.01
            custom float inputs:clothEdgeDampingStiffness = 0
            custom float inputs:clothTriAreaStiffness = 1000000
            custom float inputs:clothTriDampingStiffness = 100
            custom float inputs:clothTriElasticStiffness = 1000000
            custom rel inputs:collider
            prepend rel inputs:collider = </World/ActionGraph/read_collider/outputs_primsBundle>
            custom float inputs:colliderContactDistance = 5
            custom float inputs:colliderContactQueryRange = 100
            custom float inputs:contactDampingStiffness = 10000
            custom float inputs:contactElasticStiffness = 500000
            custom float inputs:contactFrictionCoeff = 0.75
            custom float inputs:contactFrictionStiffness = 10000
            custom bool inputs:enabled = 1
            custom uint inputs:execIn
            prepend uint inputs:execIn.connect = </World/ActionGraph/grid_create.outputs:execOut>
            custom float inputs:globalScale = 100
            custom vector3f inputs:gravity = (0, -980, 0)
            custom float inputs:groundAltitude = 8
            custom bool inputs:groundEnabled = 1
            custom int inputs:substepCount = 32
            custom double inputs:time = 0
            prepend double inputs:time.connect = </World/ActionGraph/on_tick.outputs:time>
            token node:type = "omni.warp.WarpClothSimulate"
            int node:typeVersion = 1
            custom uint outputs:execOut (
                customData = {
                    bool isExecution = 1
                }
            )
            uniform token ui:nodegraph:node:expansionState = "minimized"
            uniform float2 ui:nodegraph:node:pos = (1117, 11)

            def Output "outputs_cloth"
            {
            }
        }

        def OmniGraphNode "bundle_inspect_changes" (
            prepend apiSchemas = ["NodeGraphNodeAPI"]
        )
        {
            custom rel inputs:bundle
            prepend rel inputs:bundle = </World/ActionGraph/cloth_simulate/outputs_cloth>
            custom uint inputs:execIn
            prepend uint inputs:execIn.connect = </World/ActionGraph/cloth_simulate.outputs:execOut>
            token node:type = "omni.warp.WarpOgnBundleInspectChanges"
            int node:typeVersion = 1
            custom string outputs:attrsChanged
            custom uint outputs:execOut (
                customData = {
                    bool isExecution = 1
                }
            )
            custom bool outputs:topologyChanged
            uniform token ui:nodegraph:node:expansionState = "minimized"
            uniform float2 ui:nodegraph:node:pos = (1385, 25)

            def Output "outputs_bundle"
            {
            }
        }

        def OmniGraphNode "write_prims" (
            prepend apiSchemas = ["NodeGraphNodeAPI"]
        )
        {
            custom string inputs:attrNamesToExport = "*"
            prepend string inputs:attrNamesToExport.connect = </World/ActionGraph/bundle_inspect_changes.outputs:attrsChanged>
            custom uint inputs:execIn
            prepend uint inputs:execIn.connect = </World/ActionGraph/bundle_inspect_changes.outputs:execOut>
            custom token inputs:layerIdentifier
            custom string inputs:pathPattern = "*"
            custom rel inputs:prims = </World/Cloth> (
                customData = {
                    dictionary omni = {
                        dictionary graph = {
                            string relType = "target"
                        }
                    }
                }
            )
            custom rel inputs:primsBundle
            prepend rel inputs:primsBundle = </World/ActionGraph/bundle_inspect_changes/outputs_bundle>
            custom bool inputs:scatterUnderTargets = 0
            custom string inputs:typePattern = "*"
            custom bool inputs:usdWriteBack = 1
            prepend bool inputs:usdWriteBack.connect = </World/ActionGraph/bundle_inspect_changes.outputs:topologyChanged>
            token node:type = "omni.graph.nodes.WritePrimsV2"
            int node:typeVersion = 1
            custom uint outputs:execOut (
                customData = {
                    bool isExecution = 1
                }
            )
            custom string state:attrNamesToExport = "*"
            custom token state:layerIdentifier
            custom string state:pathPattern = "*"
            custom uint64 state:primBundleDirtyId
            custom uint64[] state:prims = []
            custom bool state:scatterUnderTargets = 0
            custom string state:typePattern = "*"
            custom bool state:usdWriteBack = 1
            uniform token ui:nodegraph:node:expansionState = "minimized"
            uniform float2 ui:nodegraph:node:pos = (1670, 50)
        }
    }

    def Scope "Looks"
    {
        def "CeramicMaterial" (
            prepend payload = @./assets/materials/ceramic_material.usda@
        )
        {
            over "CeramicMaterial"
            {
                over "Shader"
                {
                    color3f inputs:diffuse_reflection_color = (0.75, 0.75, 0.75) (
                        customData = {
                            float3 default = (0.2, 0.2, 0.2)
                        }
                        displayGroup = "Albedo"
                        displayName = "Albedo Color"
                        doc = "This is the albedo base color"
                        hidden = false
                        renderType = "color"
                    )
                }
            }
        }

        def "ClothMaterial" (
            prepend payload = @./assets/materials/cloth_material.usda@
        )
        {
            over "ClothMaterial"
            {
                over "Shader"
                {
                    color3f inputs:diffuse_reflection_color = (0.8, 0.35, 0.125) (
                        customData = {
                            float3 default = (0.2, 0.2, 0.2)
                        }
                        displayGroup = "Albedo"
                        displayName = "Albedo Color"
                        doc = "This is the albedo base color"
                        hidden = false
                        renderType = "color"
                    )
                }
            }
        }
    }

    def Mesh "Cloth" (
        prepend apiSchemas = ["MaterialBindingAPI"]
    )
    {
        rel material:binding = </World/Looks/ClothMaterial/ClothMaterial> (
            bindMaterialAs = "weakerThanDescendants"
        )
        float3 xformOp:rotateXYZ = (0, 0, 0)
        float3 xformOp:scale = (1, 1, 1)
        double3 xformOp:translate = (0, 100, 0)
        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
    }

    def "Collider" (
        prepend payload = @./assets/geometries/bunny.usd@
    )
    {
        float3 xformOp:rotateXYZ = (0, 0, 0)
        float3 xformOp:scale = (1, 1, 1)
        double3 xformOp:translate = (0, 25, 0)
        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]

        over "Bunny" (
            prepend apiSchemas = ["MaterialBindingAPI"]
        )
        {
            rel material:binding = </World/Looks/CeramicMaterial/CeramicMaterial> (
                bindMaterialAs = "weakerThanDescendants"
            )
        }
    }
}

def Xform "Environment"
{
    double3 xformOp:rotateXYZ = (0, 0, 0)
    double3 xformOp:scale = (1, 1, 1)
    double3 xformOp:translate = (0, 0, 0)
    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]

    def "Stage" (
        prepend payload = @./assets/environments/stage.usda@
    )
    {
    }
}

def Xform "CameraRoot"
{
    double3 xformOp:rotateXYZ = (-20, 10, 0)
    double3 xformOp:scale = (1, 1, 1)
    double3 xformOp:translate = (0, 30, 0)
    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]

    def Camera "Camera"
    {
        float2 clippingRange = (1, 10000000)
        float focalLength = 25
        float focusDistance = 375
        float fStop = 0
        bool omni:kit:cameraLock = 0
        double3 xformOp:rotateYXZ = (0, 0, 0)
        double3 xformOp:scale = (1, 1, 1)
        double3 xformOp:translate = (0, 0, 400)
        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateYXZ", "xformOp:scale"]
    }
}