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

[ChristaChandler01]

Hi Jeroen,

I have been doing a lot of research on this. There doesn't seem to be a publicly available tool yet.

Since not all of the Arnold nodes have a direct replacement in MaterialX, many of those shaders need to be baked before they can be used as a map for MaterialX. They aiLayer and aiMix shaders need to be flattened and combined outside of Maya, such as Nuke, to render a flattened baked map, then read that back into Maya prior to the MaterialX conversion. What we are talking about here, is a very large cross DCC pipeline script.

I need to practice doing this conversion manually, but I believe I can make the tool. I have part of the process already figured out with the slap comp GUI I made for my final project in scripting class. It can be opened in any Maya scene, user choses their paths, render settings, if they want grade or glow, and those nodes settings, then click Go! and it automates the whole slap comp process even with AOVs and shuffle nodes and the whole bit. So, I believe I could do a simplified version for flattening the layer and mix shaders to be read back in by Maya for MaterialX conversion. That is only one small piece of the puzzle though. It will take time to run manual tests then get the script going.

These convert 1:1

• base
• base_color
• specular
• specular_roughness
• metalness
• transmission
• subsurface
• subsurface_color
• emission
• emission_color

These need baked:

• aiNoise
• aiCellNoise
• aiRange
• aiColorCorrect

These need cross DCC flattening:

• aiMixShader
• aiLayerShader

[syntheticperson]

Hi @ChristaChandler01. Thanks for looking into this. Helpful to know.
Very cool.

[ChristaChandler01]

@syntheticperson You're welcome. I'm happy to help. My cross DCC pipeline script I mentioned is already on my GitHub if you want to take a look at it for reference. Like I said, that workflow is only one small piece of the puzzle though. However, we are on the right track and have already identified the bottle necks. 😁

[ChristaChandler01]

@syntheticperson I found this page this morning: https://deepwiki.com/Autodesk/arnold-usd/7.5-materialx-integration?utm_source=copilot.com

While it is talking about converting MaterialX into Arnold, the reverse of what we need to do for your project... It does contain some helpful information that might be useful in the process. Also, it might help solve some render farm issues with Houdini later on. Houdini renders are not supported on our render farm. I hear farm licensing for Houdini is extremely expensive. So, to solve this, FX should be sent back to Maya to be rendered with the scene's CG, especially if there is any image-based lighting... From my research, studios solve this by using HDA and .ass files. But it explains why MaterialX to Arnold has been researched more than Arnold to MaterialX.

The following information may be useful, though it will need to be constructed with the reverse logic of Arnold to MaterialX in mind.

Parameter Retrieval
The GetShaderInput() method searches the MaterialX network for shader nodes and their parameters:

bool GetShaderInput(const SdfPath& shaderPath, const TfToken& param,
VtValue& value, TfToken& shaderId) override
{
for (const auto& node : _network.nodes) {
if (node.path != shaderPath) continue;
shaderId = node.identifier;
for (const auto& paramIt : node.parameters) {
if (paramIt.first != param) continue;
value = paramIt.second;
return (!value.IsEmpty());
}
return false;
}
return false;
}
Sources:
[libs/render_delegate/node_graph.cpp
95-121] (https://github.com/Autodesk/arnold-usd/blob/8643134c/libs/render_delegate/node_graph.cpp#L95-L121)

File Path Reference Table

Component File Path Key Functions/Classes

Render Delegate MaterialX Setup libs/render_delegate/render_delegate.cpp 587-592 HdArnoldRenderDelegate constructor

MaterialX Path Access libs/render_delegate/render_delegate.h 477-480 GetPxrMtlxPath()

Node Graph Translation libs/render_delegate/node_graph.cpp 69-165 HdArnoldNodeGraph, MaterialHydraReader

Node Graph Header libs/render_delegate/node_graph.h 48-92
Class declarations

MaterialX Constants libs/common/constant_strings.h 372 libs/common/constant_strings.h 391 MATERIALX_NODE_DEFINITIONS, mtlx

USD Reader Integration libs/translator/reader/reader.cpp 252-256 Material reading in procedural

Changelog References
CHANGELOG.md 179-184

CHANGELOG.md 219

CHANGELOG.md 418-419

CHANGELOG.md 458

Feature history

[ChristaChandler01]

@syntheticperson
I found out that with the LookDevX tool that Maya now has... some of my previous statements are outdated. More will transfer than we think. I'm looking into the LoodDevX tool, how to use it, and what will transfer.

I also stumbled upon Derek Flood's video on the topic: A Lookdev Artist’s Guide to Creating USD Sets in Maya. Universal Scene Description (OpenUSD)
And he has already created some tools: VFX-software-prefs/Maya/scripts at main · sharktacos/VFX-software-prefs
I have not tried them yet to know how well they work... but I am looking into it.
I've reviewed some of the script... I might still try a little different approach. Still, there is something to work with / from and you now have that information. 🙂