Arnold-usd MaterialX USD Support Request

[syntheticperson]

Hi, I'd like to be able to do the following:

• Convert Arnold standard surface shaders to MaterialX
• Export to a USD file such that the MaterialX material can be read by other Hydra Render delegates. e.g. Houdini Karma

Currently, Arnold-USD exports to its own "flavor" of MaterialX USD. i.e. it includes Arnold operators, which cannot be interpreted by other render engines.
See below a Houdini 19 MaterialX USD example for comparison.

Alternatively, is there a way to convert from an Arnold MaterialX USD definition to a Houdini 19 MaterialX USD definition?

Thanks

---

#usda 1.0
(
defaultPrim = "sopcreate1"
endTimeCode = 1
framesPerSecond = 24
metersPerUnit = 1
startTimeCode = 1
timeCodesPerSecond = 24
upAxis = "Y"
)

def Xform "sopcreate1" (
kind = "component"
)
{
matrix4d xformOp:transform:xform = ( (1, 0, 0, 0), (0, 1, 0, 0), (0, 0, 1, 0), (0, 0, 0, 1) )
uniform token[] xformOpOrder = ["xformOp:transform:xform"]

def Mesh "mesh_0" (
    prepend apiSchemas = ["MaterialBindingAPI"]
)
{
    float3[] extent = [(-0.5, -0.5, -0.5), (0.5, 0.5, 0.5)]
    int[] faceVertexCounts = [4, 4, 4, 4, 4, 4]
    int[] faceVertexIndices = [0, 1, 3, 2, 4, 5, 7, 6, 6, 7, 2, 3, 5, 4, 1, 0, 5, 0, 2, 7, 1, 4, 6, 3]
    rel material:binding = </materials/mtlxstandard_surface1>
    uniform token orientation = "leftHanded"
    point3f[] points = [(0.5, -0.5, 0.5), (-0.5, -0.5, 0.5), (0.5, 0.5, 0.5), (-0.5, 0.5, 0.5), (-0.5, -0.5, -0.5), (0.5, -0.5, -0.5), (-0.5, 0.5, -0.5), (0.5, 0.5, -0.5)] (
        interpolation = "vertex"
    )
    uniform token subdivisionScheme = "none"
}

}

def Scope "materials"
{
def Material "mtlxstandard_surface1"
{
token outputs:mtlx:surface.connect = </materials/mtlxstandard_surface1/mtlxstandard_surface1.outputs:out>
token outputs:surface.connect = </materials/mtlxstandard_surface1/mtlxstandard_surface1_preview.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 = (1, 0.5, 0) (
            customData = {
                dictionary HoudiniPreviewTags = {
                    double3 default_value = (0.8, 0.8, 0.8)
                    string ogl_diff = "1"
                }
            }
        )
        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 (
            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 "mtlxstandard_surface1_preview" (
        customData = {
            bool HoudiniIsAutoCreatedShader = 1
        }
    )
    {
        uniform token info:id = "UsdPreviewSurface"
        float inputs:clearcoatRoughness = 0.1
        color3f inputs:diffuseColor = (1, 0.5, 0)
        float inputs:roughness = 0.2
        color3f inputs:specularColor = (1, 1, 1)
        token outputs:surface
    }
}

}

[sebastienblor]

Hi @syntheticperson , sorry for the lack of reply, we're just finding this discussions section now....

So, recent changes in #1195 and #1201 now allow arnold to render such materialx shaders coming from houdini, as well as arnold-specific shaders in materialx files, as generated by Arnold. This hasn't been released yet with Arnold, but it's on its way.

However, for your question about whether arnold shaders could export materialx files that can be read with other renderers, it's not that simple unfortunately. If your input scene has arnold shaders, then these shaders won't be magically rendered by other renderers unless they know how to do it. If you want something that is renderer-agnostic, in the future you would have to use materialx shaders from the standard library (like those created in Houdini 19 MaterialX USD) and expect the different renderers to support them.

Cheers

[jlapreviz]

Thanks for the update. Good to know. Many thanks