all  /  full_assets  / StandardShaderBall  / layers  / environment .usda

Overview

This scene is designed to be a comprehensive test of a broad array of material properties in a single render. It is a scene built completely from scratch but intended to replicate much of the details found in the excellent “Simball” or “Material Preview”, originally authored by Thomas Anagnostou and created while testing NextLimit’s Maxwell Render. In 2019 the original scene definition was released under a Creative Commons Attribution-Share Alike (CC BY-SA) licence and can be found here:

http://rayflectar.com/p05-Misc/misc.html

This reimplementation is intended to use modern modelling and material standards — geometry is expressed using Universal Scene Description (USD), materials are defined using MaterialX, texture maps are provided in OpenEXR format and encoded using the Academy Color Encoding System ACEScg colour-space. In the opinion of the authors, this scene exercises the broadest range of material properties of any publicly available render test and the hope is that this can become an industry standard.

Quickstart

Once USD has been built, and is available in your PATH, the scene can be opened with the following command:

usdview –camera camera full_assets/StandardShaderBall/standard_shader_ball_scene.usda

Upon initially opening the scene it may appear over-exposed. After disabling View > Enable Scene Lights, usdview should look something like this:

In usdview, if you have a render delegate that supports UsdMaterialX, the following should result in an image similar to the screenshot below:

  • View > Complexity > Highest, to get nice subdivision surfaces

  • View > Enable Scene Lights, to get the lights back, if you’ve turned them off

  • Select your renderer under View > Hydra Renderer.

Note: The renders in this doc were produced from Houdini using Karma.

Scene Overview

The scene consists of four main elements, each with well-defined dimensions:

  • The main object (shader_ball) with two parts:

    • The material surfaces comprise a modified sphere and a truncated rim at its base. These objects are designed to exercise the target material properties in specific ways.

    • The neutral objects, which are placed inside the sphere and rim. These are rendered with a diffuse 18% grey material. In some configurations the core sphere can be partially removed to reveal an internal light.

  • There are lights both external and internal to these objects that are designed to exercise various material properties.

  • The enclosing environment provides a standard setting for render comparisons. It is a box, with easily identifiable neutral textures on the walls, floor and ceiling.

  • The render camera has a specific location, orientation and field of view that when combined with the lights, enclosing environment and render test object, expose other important material properties.

Render Characteristics

Broadly speaking, this scene is designed to test two classes of materials, those that are purely reflective, and those that can also transmit light.

Reflective Materials

Reflective features:

  1. Emitter reflection is useful for judging specular reflectivity and roughness.

  2. Reflective caustic areas.

  3. Triangular cutout provides flat reflective surfaces.

  4. Light trap that causes recursive reflections.

  5. Fresnel checkpoint (63° reflectance)

  6. Shell thickness of 9.83mm.

  7. Neutral core, 18% grey.

  8. Rim thickness of 6.25mm.

  9. Fresnel checkpoint 45° reflectance.

Transmissive Materials

Transmissive features:

  1. Reflections on both outside and inside surfaces with an air bubble in between.

  2. Refracted internal core.

  3. Subsurface objects.

  4. Air bubbles.

  5. Refractive caustic area.

  6. Refracted environment.

  7. Attenuation indication with varying transmission distance.

  8. Core emission mode. ◯ ribbon emitter. ● Bulb emitter. ⦿ Both emitters active.

  9. Neutral core, 18% grey.

  10. Each grid is 4cm×4cm with unique numbers from 001 to 625.

As an additional aid to exercise transmissive behaviour, geometry has been placed under the surface to act as an opaque occluder. This is useful for observing the paths of refracted light, as well as the behaviour of volumetric interaction, e.g. subsurface scattering and absorption.

Subsurface features:

  1. Subsurface bar object.

  2. Variable material thickness above subsurface bar.

  3. Shallow region.

Shader Ball

The primary surfaces used for material evaluation are a modified sphere and a truncated rim around the base. Secondary diffuse surfaces are provided to receive various types of indirect illumination.

The surface_geometry VariantSet allows the above elements to be defined by either subdivision or triangulated polygon surfaces. Both variants are intended to provide equivalent geometry and dimensions.

  • subdiv

    • Quad-mesh, which is also marked as a catmullClark subdivision surface.

    • Care has been taken to create a UV layout that can be used both to exercise spatially varying materials (e.g. surface textures) and also provide a coordinate frame for anisotropic specular roughness.

    • Air bubbles are represented as inverted faces inside of the mesh.

  • triangulated

    • A tessellated version of subdiv, which has Loop-subdivision applied to produce the triangulated topology.

    • The UV layout should be equivalent to subdiv.

    • Includes authored per-vertex normals attribute to address polygonal facetting.

Comparison of the Catmull Clark surfaces and their triangular tessellations.

A UV layout has been crafted that both aligns with the sphere’s coordinate axes and attempts to minimise surface distortion.

Surface texture and anisotropic roughness applied to exercise the UV layout.

External Illumination

Two external emitters are present in the scene. One is to the camera-left side of the render test object with the intention to produce a specular highlight that can be examined for reflectivity and roughness, both isotropic and anisotropic. A second light is placed above the render test object with the intention of creating highlights on and casting caustics from the bevelled edges of the triangular cutout area.

Internal Illumination

In addition to the transmissive properties exercised by the external lights, the interior geometry of the primary material test objects can be illuminated. Parts of the grey inner core object can be optionally removed to reveal an interior spherical light. There are three configurations:

  • Ribbon emission removes a strip of the inner sphere which follows the shape of the triangular cutout,

  • Bulb emission removes the back facing surfaces of the inner sphere, and

  • Both the ribbon and bulb modes can be activated simultaneously.

A texture map on the visible front face of the inner core to indicate which illumination mode is active. By default this internal illumination is disabled.

This is particularly useful when exercising transmissive materials that contain visible interior volumetric scattering.

Internal emission features, from left to right:

  1. No internal emission

  2. Ribbon emission ◯

  3. Bulb emission ●

  4. Bulb and Ribbon emission ⦿

Enclosing Environment

The render test object is enclosed by a box with a base of 100cm×100cm and height of 75cm. The ground plane, walls and ceiling have unique textures designed to allow easy identification of reflected or transmitted rays. On the ground plane is a texture with unique numbers from 001 to 625 with a grid of 4cm×4cm. The walls and top are each marked with unique letters as well as a label to indicate which wall is represented, allowing easy identification of ray paths.

Material Definitions

USDShade is used to define the materials on the scene objects. Two render contexts are provided:

  • usdPreviewSurface: a basic implementation that should work in any standard USD implementation, and

  • MaterialX: a more sophisticated implementation that uses the MaterialX definition of Autodesk Standard Surface.

All materials except for those applied to the primary material test surfaces are intended to be Lambertian diffuse. In the Autodesk Standard Surface case, this means that roughness is set to 0, which should revert the included Oren-Nayar model to Lambertian.

Scene Dimensions

The scene adopts the convention of one scene unit equals 1cm. There is layer metadata to indicate this (metersPerUnit = 0.01).

The dimensions for the geometry in this scene are derived from the original scene geometry.

  • Sphere: Ø7.53cm diameter, 9.83mm thickness.

  • Rim: Ø8.92cm diameter, 6.25mm thickness.

  • Floor: 100cm×100cm, tile size 4cm×4cm.

  • Walls: 100cm wide, 75cm high.

Variants

VariantSets provide simple switching mechanisms in the scene. All variants live on /standard_shader_ball_scene:

  • surface_geometry — different representations of shader_ball:

    • subdiv — subdivision surface with inverted faces for air bubbles.

    • triangulated — a triangulated version of the subdivision surface intended for rendering engines that do not support subdivision surfaces natively. Where possible the subdiv variant is preferred.

  • internal_emitter — illumination from inside the material surface:

    • off — no internal illumination, just the neutral grey.

    • ribbon ◯ — strip around the triangular opening for illumination.

    • bulb ● — the internal core is replaced with a bulb, except for the exposed face.

    • ribbon and bulb ⦿ — both ribbon and bulb areas are exposed.

  • example_material — some example materials for demonstrating different features of the scene:

    • none — no material is applied

    • mtlx_bubblegum — a material with subsurface scattering

    • mtlx_glass — a transmissive dielectric with a slight colour tint

    • mtlx_gold — a conductor with the appearance of gold

    • mtlx_plastic — diffuse material with a layered specular

    • uvgrid - simple material with the uvgrid texture

    • usdpreview_glass — a transmissive dielectric with a slight colour tint

    • usdpreview_gold — a conductor with the appearance of gold

    • usdpreview_plastic — diffuse plastic using the material with a layered specular

These examples not intended to represent “correct” materials. They are included for scene configuration testing convenience. Some USD Preview examples are also provided for render delegates without UsdMtlX support. See media/example_materials for renders of each material using Karma.

In usdview, variants can be set in the Meta Data tab, while /standard_material_scene is selected in the outliner.

Scene Implementation

The initial USD scene authoring was performed in Houdini. While the USD scene is sufficient to define the test environment, the original Houdini scene file is also included in the repository in order to facilitate reproducibility and future modification. The choice of Houdini is not intended to represent any software preferences on the part of the authors.

Differences from the Original

In the original material preview scene, lights were defined with radiometric units. Since there aren’t yet mechanisms in USD to define lights in this way, intensity values have been chosen to capture the intent of the original scene. Adopting physical units might be reconsidered in the future as more sophisticated lighting configuration becomes available in USD.

All of the curved surfaces in the scene geometry are now defined with crease-free subdivision surfaces when the subdiv variant is active. The original scene was constructed of densely tessellated triangles that were the result of procedural geometry operators and suffered from various inconsistencies. The authors are aware that subdivision surfaces cannot represent circular curves or spheres exactly, but the approximations here are considered adequate for material evaluation. A triangulated polygon version of the object is still provided but it is generated from the subdivision surface. The subdiv geometry should be considered the reference geometry and its use if preferred where possible.

All texture maps have been remade from scratch at higher resolutions and are encoded in ACEScg AP1 OpenEXR half textures. The original textures were published as uint8 PNGs with a gamma of 2.22.

The grey material of the render test object’s interior was originally defined to be 50% grey. We have replaced this with the VFX industry standard of 18% grey.

This implementation provides a surface UV layout that should allow the useful display of textured materials. The axes of this texture space can also serve as the principal directions of a local coordinate space when anisotropic roughnesses are being exercised.

Version History

1.0 2023-05-21 First release of USD scene packages with textures and this specification document.

Contributors

Geometry and textures: Chris Rydalch

Specification and validation: André Mazzone

Original scene, inspiration and consultation: Thomas Anagnostou

For support and questions please use the issues page.

https://github.com/usd-wg/assets/issues

Licence

Shield: CC BY 4.0

This work is licensed under a Creative Commons Attribution 4.0 International Licence.

CC BY 4.0


Edit this page

environment.usda

#usda 1.0
(
    customLayerData = {
        string License = "CC BY 4.0"
        string Version = "1.0"
    }
    defaultPrim = "standard_shader_ball_scene"
    framesPerSecond = 24
    metersPerUnit = 0.01
    timeCodesPerSecond = 24
    upAxis = "Y"
)

def Xform "standard_shader_ball_scene" (
    kind = "group"
    variants = {
        string scene_lights = "on"
    }
    prepend variantSets = "scene_lights"
)
{
    def Xform "ground" (
        prepend apiSchemas = ["MaterialBindingAPI"]
        kind = "component"
    )
    {
        rel material:binding = </standard_shader_ball_scene/materials/ground>
        matrix4d xformOp:transform:tweak_box_position = ( (1, 0, 0, 0), (0, 1, 0, 0), (0, 0, 1, 0), (3.25, 0, 0.3, 1) )
        uniform token[] xformOpOrder = ["xformOp:transform:tweak_box_position"]

        def Mesh "grid"
        {
            float3[] extent = [(-50, 0, -50), (50, 0, 50)]
            int[] faceVertexCounts = [3, 3]
            int[] faceVertexIndices = [0, 1, 3, 3, 2, 0]
            uniform token orientation = "leftHanded"
            point3f[] points = [(-50, 0, -50), (50, 0, -50), (-50, 0, 50), (50, 0, 50)] (
                interpolation = "vertex"
            )
            texCoord2f[] primvars:st = [(0, 0), (1, 0), (1, -1), (1, -1), (0, -1), (0, 0)] (
                interpolation = "faceVarying"
            )
            int[] primvars:st:indices = None
            uniform token subdivisionScheme = "none"
        }
    }

    def Scope "lights"
    {
        def Xform "emitterLeft"
        {
            float height = 0
            float intensity = 0
            float width = 0
            matrix4d xformOp:transform = ( (1, 0, 0, 0), (0, 1, 0, 0), (0, 0, 1, 0), (-41.367698669433594, 17.881999969482422, 17.304800033569336, 1) )
            matrix4d xformOp:transform:tweak_lights_position = ( (1, 0, 0, 0), (0, 1, 0, 0), (0, 0, 1, 0), (0, 2, 3, 1) )
            uniform token[] xformOpOrder = ["xformOp:transform", "xformOp:transform:tweak_lights_pos... (truncated)]

            def RectLight "light" (
                prepend apiSchemas = ["KarmaLightSettingsAPI"]
            )
            {
                float3[] extent = [(-7.4800005, -7.4800005, -0), (7.4800005, 7.4800005, 0)]
                float inputs:height = 14.960001
                float inputs:intensity = 9
                float inputs:width = 14.960001
                bool karma:light:renderlightgeo = 1
                rel light:filters = None
                matrix4d xformOp:transform = ( (-0, 0, 1, 0), (0, 1, 0, 0), (-1, 0, 0, 0), (0.0010000000474974513, 0, 0, 1) )
                uniform token[] xformOpOrder = ["xformOp:transform"]
            }

            def Mesh "backplane"
            {
                float3[] extent = [(0, -10.311456, -10.311456), (0, 10.311456, 10.311456)]
                int[] faceVertexCounts = [3, 3]
                int[] faceVertexIndices = [0, 1, 3, 3, 2, 0]
                float[] height = [0, 0, 0, 0] (
                    interpolation = "vertex"
                )
                float[] intensity = [0, 0, 0, 0] (
                    interpolation = "vertex"
                )
                normal3f[] normals = [(1, 0, 0), (1, 0, 0), (1, 0, 0), (1, 0, 0)] (
                    interpolation = "vertex"
                )
                uniform token orientation = "leftHanded"
                point3f[] points = [(0, -10.311456, -10.311456), (0, -10.311456, 10.311456), (0, 10.... (truncated)]
                    interpolation = "vertex"
                )
                color3f[] primvars:displayColor = [(0.502, 0.502, 0.502), (0.502, 0.502, 0.502)] (
                    interpolation = "uniform"
                )
                int[] primvars:displayColor:indices = None
                uniform token subdivisionScheme = "none"
                float[] width = [0, 0, 0, 0] (
                    interpolation = "vertex"
                )
            }
        }

        def Xform "emitterTop"
        {
            float height = 0
            float intensity = 0
            float width = 0
            matrix4d xformOp:transform = ( (1, 0, 0, 0), (0, 1, 0, 0), (0, 0, 1, 0), (16.426599502563477, 60.9463996887207, 3.2356600761413574, 1) )
            matrix4d xformOp:transform:tweak_lights_position = ( (1, 0, 0, 0), (0, 1, 0, 0), (0, 0, 1, 0), (0, 2, 3, 1) )
            uniform token[] xformOpOrder = ["xformOp:transform", "xformOp:transform:tweak_lights_pos... (truncated)]

            def RectLight "light3" (
                prepend apiSchemas = ["KarmaLightSettingsAPI"]
            )
            {
                float3[] extent = [(-12.18, -12.18, -0), (12.18, 12.18, 0)]
                float inputs:height = 24.36
                float inputs:intensity = 6
                float inputs:width = 24.36
                bool karma:light:renderlightgeo = 1
                rel light:filters = None
                matrix4d xformOp:transform = ( (1, 0, 0, 0), (0, 0, -1, 0), (0, 1, 0, 0), (14.300071716308594, -0.00009999999747378752, -15.162029266357422, 1) )
                uniform token[] xformOpOrder = ["xformOp:transform"]
            }

            def RectLight "light2" (
                prepend apiSchemas = ["KarmaLightSettingsAPI"]
            )
            {
                float3[] extent = [(-12.18, -12.18, -0), (12.18, 12.18, 0)]
                float inputs:height = 24.36
                float inputs:intensity = 6
                float inputs:width = 24.36
                bool karma:light:renderlightgeo = 1
                rel light:filters = None
                matrix4d xformOp:transform = ( (1, 0, 0, 0), (0, 0, -1, 0), (0, 1, 0, 0), (-15.162029266357422, -0.00009999999747378752, -14.300069808959961, 1) )
                uniform token[] xformOpOrder = ["xformOp:transform"]
            }

            def RectLight "light1" (
                prepend apiSchemas = ["KarmaLightSettingsAPI"]
            )
            {
                float3[] extent = [(-12.18, -12.18, -0), (12.18, 12.18, 0)]
                float inputs:height = 24.36
                float inputs:intensity = 6
                float inputs:width = 24.36
                bool karma:light:renderlightgeo = 1
                rel light:filters = None
                matrix4d xformOp:transform = ( (1, 0, 0, 0), (0, 0, -1, 0), (0, 1, 0, 0), (15.162029266357422, -0.00009999999747378752, 14.300069808959961, 1) )
                uniform token[] xformOpOrder = ["xformOp:transform"]
            }

            def RectLight "light0" (
                prepend apiSchemas = ["KarmaLightSettingsAPI"]
            )
            {
                float3[] extent = [(-12.18, -12.18, -0), (12.18, 12.18, 0)]
                float inputs:height = 24.36
                float inputs:intensity = 6
                float inputs:width = 24.36
                bool karma:light:renderlightgeo = 1
                rel light:filters = None
                matrix4d xformOp:transform = ( (1, 0, 0, 0), (0, 0, -1, 0), (0, 1, 0, 0), (-14.300070762634277, -0.00009999999747378752, 15.162029266357422, 1) )
                uniform token[] xformOpOrder = ["xformOp:transform"]
            }

            def Mesh "backplane"
            {
                float3[] extent = [(-31.54725, 0, -31.6542), (31.54725, 0, 31.6542)]
                int[] faceVertexCounts = [3, 3]
                int[] faceVertexIndices = [0, 1, 3, 3, 2, 0]
                float[] height = [0, 0, 0, 0] (
                    interpolation = "vertex"
                )
                float[] intensity = [0, 0, 0, 0] (
                    interpolation = "vertex"
                )
                normal3f[] normals = [(0, 1, 0), (0, 1, 0), (0, 1, 0), (0, 1, 0)] (
                    interpolation = "vertex"
                )
                uniform token orientation = "leftHanded"
                point3f[] points = [(-31.54725, 0, -31.6542), (31.54725, 0, -31.6542), (-31.54725, 0... (truncated)]
                    interpolation = "vertex"
                )
                color3f[] primvars:displayColor = [(0.502, 0.502, 0.502), (0.502, 0.502, 0.502)] (
                    interpolation = "uniform"
                )
                int[] primvars:displayColor:indices = None
                uniform token subdivisionScheme = "none"
                float[] width = [0, 0, 0, 0] (
                    interpolation = "vertex"
                )
            }
        }
    }

    def Xform "box" (
        kind = "component"
    )
    {
        matrix4d xformOp:transform:tweak_box_position = ( (1, 0, 0, 0), (0, 1, 0, 0), (0, 0, 1, 0), (3.25, 0, 0.3, 1) )
        uniform token[] xformOpOrder = ["xformOp:transform:tweak_box_position"]

        def Mesh "back" (
            prepend apiSchemas = ["MaterialBindingAPI"]
        )
        {
            float3[] extent = [(-50, 0, 50), (50, 75.8639, 50)]
            int[] faceVertexCounts = [3, 3]
            int[] faceVertexIndices = [0, 1, 3, 3, 2, 0]
            rel material:binding:full = </standard_shader_ball_scene/materials/back>
            uniform token orientation = "leftHanded"
            point3f[] points = [(50, 75.8639, 50), (-50, 75.8639, 50), (50, 0, 50), (-50, 0, 50)] (
                interpolation = "vertex"
            )
            texCoord2f[] primvars:st = [(0, 0), (1, 0), (1, -1), (1, -1), (0, -1), (0, 0)] (
                interpolation = "faceVarying"
            )
            int[] primvars:st:indices = None
            uniform token subdivisionScheme = "none"
        }

        def Mesh "right" (
            prepend apiSchemas = ["MaterialBindingAPI"]
        )
        {
            float3[] extent = [(50, 0, -50), (50, 75.8639, 50)]
            int[] faceVertexCounts = [3, 3]
            int[] faceVertexIndices = [0, 1, 3, 3, 2, 0]
            rel material:binding:full = </standard_shader_ball_scene/materials/right>
            uniform token orientation = "leftHanded"
            point3f[] points = [(50, 75.8639, -50), (50, 75.8639, 50), (50, 0, -50), (50, 0, 50)] (
                interpolation = "vertex"
            )
            texCoord2f[] primvars:st = [(0, 0), (1, 0), (1, -1), (1, -1), (0, -1), (0, 0)] (
                interpolation = "faceVarying"
            )
            int[] primvars:st:indices = None
            uniform token subdivisionScheme = "none"
        }

        def Mesh "top" (
            prepend apiSchemas = ["MaterialBindingAPI"]
        )
        {
            float3[] extent = [(-50, 75.8639, -50), (50, 75.8639, 50)]
            int[] faceVertexCounts = [3, 3]
            int[] faceVertexIndices = [0, 2, 3, 3, 1, 0]
            rel material:binding:full = </standard_shader_ball_scene/materials/top>
            uniform token orientation = "leftHanded"
            point3f[] points = [(-50, 75.8639, -50), (50, 75.8639, -50), (-50, 75.8639, 50), (50, 75... (truncated)]
                interpolation = "vertex"
            )
            texCoord2f[] primvars:st = [(0, 0), (0, -1), (1, -1), (1, -1), (1, 0), (0, 0)] (
                interpolation = "faceVarying"
            )
            int[] primvars:st:indices = None
            uniform token subdivisionScheme = "none"
        }

        def Mesh "front" (
            prepend apiSchemas = ["MaterialBindingAPI"]
        )
        {
            float3[] extent = [(-50, 0, -50), (50, 75.8639, -50)]
            int[] faceVertexCounts = [3, 3]
            int[] faceVertexIndices = [0, 1, 3, 3, 2, 0]
            rel material:binding:full = </standard_shader_ball_scene/materials/front>
            uniform token orientation = "leftHanded"
            point3f[] points = [(-50, 75.8639, -50), (50, 75.8639, -50), (-50, 0, -50), (50, 0, -50)... (truncated)]
                interpolation = "vertex"
            )
            texCoord2f[] primvars:st = [(0, 0), (1, 0), (1, -1), (1, -1), (0, -1), (0, 0)] (
                interpolation = "faceVarying"
            )
            int[] primvars:st:indices = None
            uniform token subdivisionScheme = "none"
        }

        def Mesh "left" (
            prepend apiSchemas = ["MaterialBindingAPI"]
        )
        {
            float3[] extent = [(-50, 0, -50), (-50, 75.8639, 50)]
            int[] faceVertexCounts = [3, 3]
            int[] faceVertexIndices = [0, 1, 3, 3, 2, 0]
            rel material:binding:full = </standard_shader_ball_scene/materials/left>
            uniform token orientation = "leftHanded"
            point3f[] points = [(-50, 75.8639, 50), (-50, 75.8639, -50), (-50, 0, 50), (-50, 0, -50)... (truncated)]
                interpolation = "vertex"
            )
            texCoord2f[] primvars:st = [(0, 0), (1, 0), (1, -1), (1, -1), (0, -1), (0, 0)] (
                interpolation = "faceVarying"
            )
            int[] primvars:st:indices = None
            uniform token subdivisionScheme = "none"
        }
    }

    def Scope "materials"
    {
        def Material "box_base"
        {
            token outputs:mtlx:surface.connect = </standard_shader_ball_scene/materials/box_base/mtlxstandard_surface1.outputs:out>
            token outputs:surface.connect = </standard_shader_ball_scene/materials/box_base/usdpreviewsurface1.outputs:surface>

            def Shader "mtlxstandard_surface1"
            {
                uniform token info:id = "ND_standard_surface_surfaceshader"
                float inputs:base (
                    customData = {
                        dictionary HoudiniPreviewTags = {
                            double default_value = 1
                            string ogl_diff_intensity = "1"
                        }
                    }
                )
                color3f inputs:base_color (
                    customData = {
                        dictionary HoudiniPreviewTags = {
                            double3 default_value = (0.8, 0.8, 0.8)
                            string ogl_diff = "1"
                        }
                    }
                )
                color3f inputs:base_color.connect = </standard_shader_ball_scene/materials/box_base/mtlximage1.outputs:out>
                float inputs:coat (
                    customData = {
                        dictionary HoudiniPreviewTags = {
                            double default_value = 0
                            string ogl_coat_intensity = "1"
                        }
                    }
                )
                float inputs:coat_roughness (
                    customData = {
                        dictionary HoudiniPreviewTags = {
                            double default_value = 0.1
                            string ogl_coat_rough = "1"
                        }
                    }
                )
                float inputs:emission (
                    customData = {
                        dictionary HoudiniPreviewTags = {
                            double default_value = 0
                            string ogl_emit_intensity = "1"
                        }
                    }
                )
                color3f inputs:emission_color (
                    customData = {
                        dictionary HoudiniPreviewTags = {
                            double3 default_value = (1, 1, 1)
                            string ogl_emit = "1"
                        }
                    }
                )
                float inputs:metalness (
                    customData = {
                        dictionary HoudiniPreviewTags = {
                            double default_value = 0
                            string ogl_metallic = "1"
                        }
                    }
                )
                float inputs:specular = 0 (
                    customData = {
                        dictionary HoudiniPreviewTags = {
                            double default_value = 1
                            string ogl_spec_intensity = "1"
                        }
                    }
                )
                color3f inputs:specular_color (
                    customData = {
                        dictionary HoudiniPreviewTags = {
                            double3 default_value = (1, 1, 1)
                            string ogl_spec = "1"
                        }
                    }
                )
                float inputs:specular_IOR (
                    customData = {
                        dictionary HoudiniPreviewTags = {
                            double default_value = 1.5
                            string ogl_ior = "1"
                        }
                    }
                )
                float inputs:specular_roughness (
                    customData = {
                        dictionary HoudiniPreviewTags = {
                            double default_value = 0.2
                            string ogl_rough = "1"
                        }
                    }
                )
                float inputs:transmission (
                    customData = {
                        dictionary HoudiniPreviewTags = {
                            double default_value = 0
                            string ogl_transparency = "1"
                        }
                    }
                )
                token outputs:out
            }

            def Shader "mtlximage1"
            {
                uniform token info:id = "ND_image_color3"
                float2 inputs:texcoord.connect = </standard_shader_ball_scene/materials/box_base/mtlxtexcoord1.outputs:out>
                color3f outputs:out
            }

            def Shader "mtlxtexcoord1"
            {
                uniform token info:id = "ND_texcoord_vector2"
                float2 outputs:out
            }

            def Shader "usdpreviewsurface1"
            {
                uniform token info:id = "UsdPreviewSurface"
                color3f inputs:diffuseColor.connect = </standard_shader_ball_scene/materials/box_base/usduvtexture1.outputs:rgb>
                float inputs:roughness = 1
                token outputs:surface
            }

            def Shader "usduvtexture1"
            {
                uniform token info:id = "UsdUVTexture"
                float2 inputs:st.connect = </standard_shader_ball_scene/materials/box_base/usdprimvarreader1.outputs:result>
                vector3f outputs:rgb
            }

            def Shader "usdprimvarreader1"
            {
                uniform token info:id = "UsdPrimvarReader_float2"
                string inputs:varname = "st"
                float2 outputs:result
            }
        }

        def "back" (
            prepend references = </standard_shader_ball_scene/materials/box_base>
        )
        {
            over "mtlximage1"
            {
                asset inputs:file = @../maps/wall_back.ACEScg.exr@
            }

            over "usduvtexture1"
            {
                asset inputs:file = @../maps/wall_back.ACEScg.exr@
            }
        }

        def "front" (
            prepend references = </standard_shader_ball_scene/materials/box_base>
        )
        {
            over "mtlximage1"
            {
                asset inputs:file = @../maps/wall_front.ACEScg.exr@
            }

            over "usduvtexture1"
            {
                asset inputs:file = @../maps/wall_front.ACEScg.exr@
            }
        }

        def "ground" (
            prepend references = </standard_shader_ball_scene/materials/box_base>
        )
        {
            over "mtlximage1"
            {
                asset inputs:file = @../maps/ground.ACEScg.exr@
            }

            over "usduvtexture1"
            {
                asset inputs:file = @../maps/ground.ACEScg.exr@
            }
        }

        def "left" (
            prepend references = </standard_shader_ball_scene/materials/box_base>
        )
        {
            over "mtlximage1"
            {
                asset inputs:file = @../maps/wall_left.ACEScg.exr@
            }

            over "usduvtexture1"
            {
                asset inputs:file = @../maps/wall_left.ACEScg.exr@
            }
        }

        def "right" (
            prepend references = </standard_shader_ball_scene/materials/box_base>
        )
        {
            over "mtlximage1"
            {
                asset inputs:file = @../maps/wall_right.ACEScg.exr@
            }

            over "usduvtexture1"
            {
                asset inputs:file = @../maps/wall_right.ACEScg.exr@
            }
        }

        def "top" (
            prepend references = </standard_shader_ball_scene/materials/box_base>
        )
        {
            over "mtlximage1"
            {
                asset inputs:file = @../maps/wall_top.ACEScg.exr@
            }

            over "usduvtexture1"
            {
                asset inputs:file = @../maps/wall_top.ACEScg.exr@
            }
        }
    }
    variantSet "scene_lights" = {
        "left" {
            over "lights"
            {
                over "emitterTop" (
                    active = false
                )
                {
                }
            }

        }
        "off" {
            over "lights"
            {
                over "emitterLeft" (
                    active = false
                )
                {
                }

                over "emitterTop" (
                    active = false
                )
                {
                }
            }

        }
        "on" {

        }
        "top" {
            over "lights"
            {
                over "emitterLeft" (
                    active = false
                )
                {
                }
            }

        }
    }
}

Data from usd-wg/assets

Made by @hybridherbst from Needle and prefrontal cortex