Physical material to Simplygon material ​

The Physical Material is the new standard material in Max 2021 and later, and although we have a basic implementation for mapping most properties there might be a need for customizing material channels. This section goes through how to map Physical material properties to Simplygon and back through scripting and shading networks. It is recommended to read Shading network concepts and Simplygon Shading Network functions before proceeding.

Scripting ​

To translate a Physical material to a Simplygon material you would most likely want to extract certain properties from your material. To map a specific material property to Simplygon we need to identify the name of the Physical Material we want to override, as well as the material properties we are interested in, here's a list of "Physical Material" properties that we've gathered so far:

Now that we have all available material properties, let's head over to the export section and do some prototyping!

Export ​

The first thing we need to do to create a shading network is to specify the material name we want to override. The line below tells the Simplygon plug-in that there's a shading network available for the specific material.MaterialName in this case is the name of the Physical Material in the 3ds Max material browser/editor, usually something like '01 - default' for new materials.

MyPhysicalMaterial = sgsdk_CreateMaterialMetadata MaterialName

Simplygon's texture nodes maps directly to the Physical material's texture property via name, let's use base_color_map (Texmap*) from the table above for this tutorial.

MyBaseColorTexture = sgsdk_CreateShadingTextureNode "base_color_map"

Color nodes work pretty much in the same way, let's use base_color (Point4*). This line is just an illustration, we'll not use it in our shading network.

MyBaseColor = sgsdk_CreateShadingColorNode "base_color"

To connect the shading network to a material channel we will add another line to our script. A material channel can be named anything, but keep in mind that it directly maps to the channel name of the material caster in the settings, if you intend to cast the material channel to a texture that is.

sgsdk_ConnectNodeToChannel MyBaseColorTexture MyPhysicalMaterial "base_color"

Let's add the bump_map texture to the bump material channel, this should be fairly easy from what we have learned.

MyBumpTexture = sgsdk_CreateShadingTextureNode "bump_map"
sgsdk_ConnectNodeToChannel MyBumpTexture MyPhysicalMaterial "bump"

Before calling the Simplygon function there are some optional settings that can be set, for example texture output directory which can make life easier when importing / handling textures. Remember to select the asset before running the Simplygon command, otherwise the command will be ignored.

sgsdk_SetTextureOutputDirectory "D:\\CubeExample\\OutputTextures\\"
sgsdk_RunPipelineOnSelection reductionPipelineWithMaterialBaking

The final export script:

MyPhysicalMaterial = sgsdk_CreateMaterialMetadata "MyPhysicalMaterial"

MyBaseColorTexture = sgsdk_CreateShadingTextureNode "base_color_map"
MyBumpTexture = sgsdk_CreateShadingTextureNode "bump_map"

sgsdk_ConnectNodeToChannel MyBaseColorTexture MyPhysicalMaterial "base_color"
sgsdk_ConnectNodeToChannel MyBumpTexture MyPhysicalMaterial "bump"

sgsdk_SetTextureOutputDirectory "D:\\CubeExample\\OutputTextures\\"
sgsdk_RunPipelineOnSelection reductionPipelineWithMaterialBaking

For properties that are not automatically mapped, such as int, bool and float properties, these are accessible through the Physical Material via MaxScript / Python. We recommend setting up a material loop where the Physical Material type is identified and then translated using Simplygon Shading Nodes. Keep in mind that "empty" texture nodes are not allowed, make sure that a valid texture is and that the checkbox is enabled, otherwise it is recommended to ignore creating the node or replace it with a color node.

Here's a snippet that will loop through available scene materials and list all material properties.

-- loop all scene materials
for mat in scenematerials do
(
    print ("Material name: " + mat.name)

    -- get all material properties
    props = getPropNames  mat
    for i = 1 to props.count do
    (
        prop = getProperty  mat props[i]
        print ("\t\t\t." + props[i] + ": " + prop as string + "")
    )
    print ("\n")

    -- loop through all sub-materials
    subMatCount = getNumSubMtls mat
    print ("\tNum sub-materials: " + subMatCount as string)
    for i = 1  to subMatCount do
    (
        subMat = getSubMtl mat i
        print ("\t\tSub-material name: " + subMat.name)

        -- get all sub-material properties
        props = getPropNames subMat
        for i = 1 to props.count do
        (
            prop = getProperty subMat props[i]
            print ("\t\t\t." + props[i] + ": " + prop as string + "")
        )
        print ("\n")
    )
)

Which should give the following output:

This is a short tutorial on how to use shading networks to translate a Physical Material to Simplygon material.

Import ​

The Simplygon Max plug-in stores some material information from the last run which can be accessed via script. We will start by asking the plug-in for the material name of a mesh, material channels followed by textures.

...
sgsdk_RunPipelineOnSelection reductionPipelineWithMaterialBaking

processedMeshes = sgsdk_GetProcessedMeshes()
for mesh in processedMeshes do
(
    print ("\tMesh: " + mesh)
    materials = sgsdk_GetMaterialsForMesh mesh
    for material in materials do
    (
        print ("\n\t\tMaterial: " + material)
        reusingMaterials = sgsdk_GetMeshReusesMaterials mesh
        for reuseMaterial in reusingMaterials do
        (
            print ("\t\tReusing: " + reuseMaterial)
        )

        channels = sgsdk_GetChannelsForMaterial material
        for channel in channels do
        (
            print ("\t\t\tChannel: " + channel)
            texture = sgsdk_GetTexturePathForChannel material channel
            print ("\t\t\t\tTexture: " + texture)
            mappingChannel = sgsdk_GetMappingChannelForChannel material channel
            print ("\t\t\t\tMappingChannel: " + mappingChannel as string)
        )

        -- sub-materials
        materials = sgsdk_GetSubMaterials material
        for submaterial in materials do
        (
            print ("\n\t\t\tSubMaterial: " + submaterial)
            reusingMaterial = sgsdk_GetMaterialReusesSubMaterial material submaterial
            print ("\t\t\tReusing: " + reusingMaterial)

            channels = sgsdk_GetChannelsForMaterial submaterial
            for channel in channels do
            (
                print ("\t\t\tChannel: " + channel)
                texture = sgsdk_GetTexturePathForChannel submaterial channel
                print ("\t\t\t\tTexture: " + texture)
                mappingChannel = sgsdk_GetMappingChannelForChannel submaterial channel
                print ("\t\t\t\tMappingChannel: " + mappingChannel as string)
            )

            materialIndex = sgsdk_GetSubMaterialIndex material submaterial
            print ("\t\t\tIndex: " + materialIndex as string)
        )
    )
)

Simplygon's "Physical Material" implementation is based on a collection of material channels, if these material channels are identified at import then Simplygon will hook in the result automatically. If custom channels are used, then they have to be handled manually by querying the plug-in and create the target material(s) manually and map back the information that was fetched from sgsdk_GetMaterialsForMesh, sgsdk_GetChannelsForMaterial, sgsdk_GetTexturePathForChannel and sgsdk_GetMappingChannelForChannel. We've excluded the material creation part from this tutorial as there usually are many lines of code and special conditions that does not really contribute that much. See the Physical Material example for a more detailed example.

References ​

Get to know how to work with Shading Networks:

• Simplygon Shading Network functions

• Simplygon Shading Networks (API documentation)

• Physical Material example - Scripting