unit_test_m.usda

#usda 1.0
(
    customLayerData = {
        dictionary audioSettings = {
            double dopplerLimit = 2
            double dopplerScale = 1
            token enableDistanceDelay = "off"
            token enableDoppler = "off"
            token enableInterauralDelay = "off"
            double nonSpatialTimeScale = 1
            double spatialTimeScale = 1
            double speedOfSound = 340
        }
        dictionary cameraSettings = {
            dictionary Front = {
                double3 position = (0, 0, 500000)
                double radius = 500
            }
            dictionary Perspective = {
                double3 position = (1.0299848869416002, 2.1790824378175864, 1.9797997936648388)
                double3 target = (-3.5368629802690066e-8, 4.360646954637559e-9, 1.095603718859195e-8)
            }
            dictionary Right = {
                double3 position = (-500000, 0, 0)
                double radius = 500
            }
            dictionary Top = {
                double3 position = (0, 500000, 0)
                double radius = 500
            }
            string boundCamera = "/OmniverseKit_Persp"
        }
        dictionary omni_layer = {
            dictionary muteness = {
            }
        }
        dictionary renderSettings = {
            float3 "rtx:debugView:pixelDebug:textColor" = (0, 1e18, 0)
            float3 "rtx:dynamicDiffuseGI:probeCounts" = (6, 6, 6)
            float3 "rtx:dynamicDiffuseGI:probeGridOrigin" = (-210, -250, -10)
            float3 "rtx:dynamicDiffuseGI:volumeSize" = (600, 440, 300)
            float3 "rtx:fog:fogColor" = (0.75, 0.75, 0.75)
            float3 "rtx:lightspeed:material:overrideAlbedo" = (0.5, 0.5, 0.5)
            float3 "rtx:lightspeed:material:overrideEmissiveColor" = (0.5, 0.5, 0.5)
            float3 "rtx:post:backgroundZeroAlpha:backgroundDefaultColor" = (0, 0, 0)
            float3 "rtx:post:colorcorr:contrast" = (1, 1, 1)
            float3 "rtx:post:colorcorr:gain" = (1, 1, 1)
            float3 "rtx:post:colorcorr:gamma" = (1, 1, 1)
            float3 "rtx:post:colorcorr:offset" = (0, 0, 0)
            float3 "rtx:post:colorcorr:saturation" = (1, 1, 1)
            float3 "rtx:post:colorgrad:blackpoint" = (0, 0, 0)
            float3 "rtx:post:colorgrad:contrast" = (1, 1, 1)
            float3 "rtx:post:colorgrad:gain" = (1, 1, 1)
            float3 "rtx:post:colorgrad:gamma" = (1, 1, 1)
            float3 "rtx:post:colorgrad:lift" = (0, 0, 0)
            float3 "rtx:post:colorgrad:multiply" = (1, 1, 1)
            float3 "rtx:post:colorgrad:offset" = (0, 0, 0)
            float3 "rtx:post:colorgrad:whitepoint" = (1, 1, 1)
            float3 "rtx:post:lensDistortion:lensFocalLengthArray" = (10, 30, 50)
            float3 "rtx:post:lensFlares:anisoFlareFalloffX" = (450, 475, 500)
            float3 "rtx:post:lensFlares:anisoFlareFalloffY" = (10, 10, 10)
            float3 "rtx:post:lensFlares:cutoffPoint" = (2, 2, 2)
            float3 "rtx:post:lensFlares:haloFlareFalloff" = (10, 10, 10)
            float3 "rtx:post:lensFlares:haloFlareRadius" = (75, 75, 75)
            float3 "rtx:post:lensFlares:isotropicFlareFalloff" = (50, 50, 50)
            float3 "rtx:post:tonemap:whitepoint" = (1, 1, 1)
            bool "rtx:raytracing:fractionalCutoutOpacity" = 1
            float3 "rtx:raytracing:inscattering:singleScatteringAlbedo" = (0.9, 0.9, 0.9)
            float3 "rtx:raytracing:inscattering:transmittanceColor" = (0.5, 0.5, 0.5)
            float3 "rtx:sceneDb:ambientLightColor" = (0.1, 0.1, 0.1)
        }
    }
    defaultPrim = "World"
    endTimeCode = 0
    metersPerUnit = 1
    startTimeCode = 0
    upAxis = "Y"
)

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

    def Scope "Looks"
    {
        def Material "mat1"
        {
            token outputs:mdl:displacement.connect = </World/Looks/mat1/mat1.outputs:out>
            token outputs:mdl:surface.connect = </World/Looks/mat1/mat1.outputs:out>
            token outputs:mdl:volume.connect = </World/Looks/mat1/mat1.outputs:out>

            def Shader "mat1"
            {
                uniform token info:implementationSource = "sourceAsset"
                uniform asset info:mdl:sourceAsset = @OmniPBR.mdl@
                uniform token info:mdl:sourceAsset:subIdentifier = "OmniPBR"
                color3f inputs:diffuse_color_constant = (1, 1, 1) (
                    customData = {
                        float3 default = (0, 0, 0)
                        dictionary range = {
                            float3 max = (1, 1, 1)
                            float3 min = (0, 0, 0)
                        }
                    }
                    displayGroup = "Albedo"
                    displayName = "Base Color"
                )
                color3f inputs:emissive_color = (1, 1, 1) (
                    customData = {
                        float3 default = (1, 1, 1)
                        dictionary range = {
                            float3 max = (10000, 10000, 10000)
                            float3 min = (0, 0, 0)
                        }
                    }
                    displayGroup = "Emissive"
                    displayName = "Emissive Color"
                )
                float inputs:emissive_intensity = 10000 (
                    customData = {
                        float default = 40
                        dictionary range = {
                            float max = 100000
                            float min = 0
                        }
                    }
                    displayGroup = "Emissive"
                    displayName = "Emissive Intensity"
                )
                bool inputs:enable_emission = 0 (
                    customData = {
                        bool default = 0
                    }
                    displayGroup = "Emissive"
                    displayName = "Enable Emission"
                )
                bool inputs:enable_opacity = 1 (
                    customData = {
                        bool default = 0
                    }
                    displayGroup = "Opacity"
                    displayName = "Enable Opacity"
                )
                bool inputs:enable_opacity_texture = 0 (
                    customData = {
                        bool default = 0
                    }
                    displayGroup = "Opacity"
                    displayName = "Enable Opacity Texture"
                )
                float inputs:opacity_constant = 1 (
                    customData = {
                        float default = 1
                        dictionary range = {
                            float max = 1
                            float min = 0
                        }
                    }
                    displayGroup = "Opacity"
                    displayName = "Opacity Amount"
                )
                int inputs:opacity_mode = 1 (
                    customData = {
                        int default = 1
                        dictionary range = {
                            int max = 3
                            int min = 0
                        }
                    }
                    displayGroup = "Opacity"
                    displayName = "Opacity Mono Source"
                    renderType = "::base::mono_mode"
                    sdrMetadata = {
                        string __SDR__enum_value = "mono_average"
                        string options = "mono_alpha:0|mono_average:1|mono_luminance:2|mono_maximum:3"
                    }
                )
                float inputs:opacity_threshold = 0 (
                    customData = {
                        float default = 0
                        dictionary range = {
                            float max = 1
                            float min = 0
                        }
                    }
                    displayGroup = "Opacity"
                    displayName = "Opacity Threshold"
                )
                float inputs:texture_rotate = 0 (
                    customData = {
                        float default = 0
                        dictionary range = {
                            float max = 360
                            float min = 0
                        }
                    }
                    displayGroup = "UV"
                    displayName = "Texture Rotate"
                )
                float2 inputs:texture_scale = (1, 1) (
                    customData = {
                        float2 default = (1, 1)
                    }
                    displayGroup = "UV"
                    displayName = "Texture Scale"
                )
                float2 inputs:texture_translate = (0, 0) (
                    customData = {
                        float2 default = (0, 0)
                    }
                    displayGroup = "UV"
                    displayName = "Texture Translate"
                )
                token outputs:out
            }
        }
    }

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

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

            def Mesh "plane_1m_x_1m"
            {
                float3[] extent = [(-0.5, 0, -0.5), (0.5, 0, 0.5)]
                int[] faceVertexCounts = [4]
                int[] faceVertexIndices = [0, 2, 3, 1]
                rel material:binding = </World/Looks/mat1>
                normal3f[] normals = [(0, 1, 0), (0, 1, 0), (0, 1, 0), (0, 1, 0)] (
                    interpolation = "faceVarying"
                )
                point3f[] points = [(0.5, 0, 0.5), (-0.5, 0, 0.5), (0.5, 0, -0.5), (-0.5, 0, -0.5)]
                float2[] primvars:st = [(1, 0), (1, 1), (0, 1), (0, 0)] (
                    interpolation = "faceVarying"
                )
                uniform token subdivisionScheme = "none"
            }
        }
    }
}