Search Results for

    Show / Hide Table of Contents

    Shading networks

    Introduction

    Shading Networks is a fundamental part of Simplygon's material pipeline and is used to describe materials in a flexible node-based manner. Most shading nodes supported by the Simplygon API are supported by the plug-in and the input for the nodes matches the ones in the API.
    Shading Networks are generated automatically when sending an asset using standard materials, for DirectX shaders a Shading Network template is required for Simplygon to understand how to map certain parameters to shading nodes, for example material name, UV-set and textures. This documentation will focus on DirectX shaders and how to map them to and from Simplygon.

    Fundamentals

    A material in Simplygon can have several material channels, for example Ambient, Diffuse and Normals as well as custom channels. Each of these material channels has its own shading network which is Simplygon’s way of describing a material.
    Shading networks will be responsible for the visual representation of a material, as well as a description of what will be baked during processing. A shading network starts with one node, an exit node which can be of any (shading) node type, for example a texture-, add- or multiply node.

    Supported shading nodes

    Maya Name API Name No of Inputs Description
    TextureNode spShadingTextureNode 0 Points at a texture
    ColorNode spShadingColorNode 1 RGBA color
    AddNode spShadingAddNode 2 Adds two input nodes together
    SubtractNode spShadingSubtractNode 2 Subtracts input 1 from input 0
    MultiplyNode spShadingMuliplyNode 2 Multiplies input 1 with input 0
    DivideNode spShadingDivideNode 2 Divides input 0 with input 1
    InterpolateNode spShadingInterpolateNode 3 Interpolates input 0 and 1 based on 2
    ClampNode spShadingClampNode 3 Clamps input 0 based on 1 and 2
    SwizzlingNode spShadingSwizzlingNode 4 Swizzles the channels
    VertexColorNode spShadingVertexColorNode 0 Points at a vertex color set
    LayeredBlendNode spShadingLayeredBlendNode (internal) unlimited Blends textures together from start to end, based on blend mode
    PowNode spShadingPowNode 2 The power (input 1) of input 0
    StepNode spShadingStepNode 2 Steps up/down the values from input 0 based on input 1
    Normalize3Node spShadingNormalize3Node 1 Normalizes input 0
    SqrtNode spShadingSqrtNode 1 Sqrt of input 0
    Dot3Node spShadingDot3Node 2 Dot of input 0 and input 1
    Cross3Node spShadingCross3Node 2 Cross of input 0 and input 1
    CosNode spShadingCosNode 1 Cos of input 0
    SinNode spShadingSinNode 1 Sin of input 0
    MaxNode spShadingMaxNode 2 Max of input 0 and input 1
    MinNode spShadingMinNode 2 Min of input 0 and input 1
    EqualNode spShadingEqualNode 2 1.0f if value in input 0 equals the value in input 1, otherwise 0.0f
    NotEqualNode spShadingNotEqualNode 2 1.0f if value in input 0 does not equal the value in input 1, otherwise 0.0f
    GreaterThanNode spShadingGreaterThanNode 2 1.0f if value in input 0 is greater than the value in input 1, otherwise 0.0f
    LessThanNode spShadingLessThanNode 2 1.0f if value in input 0 is smaller than the value in input 1, otherwise 0.0f

    Relevant commands and flags

    All relevant commands and flags are listed below. The commands can be executed from both MEL and Python, this document is focusing mainly on MEL but there are some Python examples as well.

    Command
    SimplygonShadingNetwork
    Short Long Argument(s) Description
    -cn -CreateNode string materialName
    string nodeType
    string nodeName
    Creates a node of the given type.
    -si -SetInput string materialName
    string nodeName
    uint inputSlot
    string nodeNameToConnect
    Connects a node to another node’s input slot.
    -sd -SetDefault string materialName
    string nodeName
    uint inputSlot
    double A
    double B
    double C
    Sets default values for the given node input.
    -sd1 -SetDefault1f string materialName
    string nodeName
    uint inputSlot
    uint component
    double A
    Sets default value for the given node input on the given component [RGBA, 0-3].
    -sce -SetExitNode string materialName
    string channelName
    string nodeName
    Sets the exit node for the given material channel.
    -exf -ExportXML string materialName
    string channelName
    string filePath
    Exports shading network for the given material channel to file.
    -swz -Swizzle string materialName
    string nodeName
    uint inputSlot
    uint outputSlot
    Sets output slot for the given input slot for the specified swizzle node
    (RGBA -> 0, 1, 2, 3).
    -svn -SetVertexColorName string materialName
    string nodeName
    string colorSetName
    Sets which color set to sample from for the given vertex color node.
    -svc -SetVertCol string materialName
    string nodeName
    uint colorSet
    Sets which color set to sample from for the given vertex color node.
    -uva -SetUVAll string nodeName
    string uvSetName
    Sets the UV-set for the texture nodes matching the specified node name.
    -uvm -SetUVMaterial string materialName
    string nodeName
    string uvSetName
    Sets the UV-set for the texture nodes that matches the specified node name for the given material.
    -uvc -SetUVMaterialChannel string materialName
    string channelName
    string nodeName
    string uvSetName
    Sets the UV-set for the texture nodes that matches the specified node name for the given material channel.
    -sa -SetSRGBAll string nodeName
    bool isSRGB
    Sets the sRGB flag for the texture nodes matching the specified node name.
    -sm -SetSRGBMaterial string materialName
    string nodeName
    bool isSRGB
    Sets the sRGB flag for the texture nodes that matches the specified node name for the given material.
    -sc -SetSRGBMaterialChannel string materialName
    string channelName
    string nodeName
    bool isSRGB
    Sets the sRGB flag for the texture nodes that matches the specified node name for the given material channel.
    -tmc -SetUVTilingMaterialChannel string materialName
    string channelName
    string nodeName
    double uTiling
    double vTiling
    Sets u- and v-tiling for the given texture node.
    -omc -SetUVOffsetMaterialChannel string materialName
    string channelName
    string nodeName
    double uOffset
    double vOffset
    Sets u- and v-offset for the given texture node.
    Command
    SimplygonQuery
    Short Long Argument(s) Description
    -ver -Version <none> Gets the Simplygon SDK version.
    -gpm -GetProcessedMeshes <none> Returns a list of processed mesh names from the last run.
    -mrm -MeshReusesMaterial string meshName Returns material name if the material is shared, otherwise empty string.
    -rms -MeshReusesMaterials string meshName Return a list of material names if the material is shared, otherwise empty list. Use this if you expect multi-material meshes back from Simplygon.
    -gmm -GetMaterialForMesh string meshName Returns material name for the specified mesh. This can be used for single-material meshes, for example a mesh of which material has gone through material baking.
    -gmm -GetMaterialsForMesh string meshName Return a list of material names for the specified mesh. This can be used for both single- and multi-material meshes, can be used in combination with -gmi.
    -gmi -GetMaterialIdsForMesh string meshName Return a list of material ids for multi-material meshes that has not gone through material baking. Material baking will always result in one single material with material id 0 (the material returned by reuse, if any will cover the entire asset).
    -gm -GetMaterials <none> Returns a list of material names from the last run.
    -gcm -GetChannelsForMaterial string materialName Returns a list of material channel names for the specified material.
    -gtc -GetTexturePathForChannel string materialName
    string channelName
    Returns the texture path for the specified material channel.
    Command
    Simplygon
    Short Long Description Argument(s)
    -asm -AddShaderMaterial string materialNames Specifies which materials to override at the extraction stage. Material names are separated by "|". Ex: "redMaterial | blueMaterial".
    -ixf -ImportShaderXML string materialName
    string channelName
    string filePath
    Imports shading network for the given material channel.

    Examples

    This section contains some examples on how to setup shading networks through MEL and Python. We've left out some aprts of the scripts to keep things as simple as possible.

    • import maya.cmds as cmds must declared at the top of each Python script.
    • reductionPipeline settings-path must be declared for both MEL and Python scripts where it makes scense.
    • materialName is used as a place-holder for the name of the material we are currently working on.
    • a scene-selection is made before each Simplygon-command.

    Create node

    Creates two texture-nodes that points to the shader's Diffuse- and Normal-sampler.

    MEL

    SimplygonShadingNetwork
        -cn TextureNode "DiffuseSampler" 
        -cn TextureNode "NormalsSampler";
    

    Python

    cmds.SimplygonShadingNetwork(
        cn = [TextureNode "DiffuseSampler"], 
        cn = [TextureNode "NormalsSampler"])
    

    Set default values

    Sets the default values of for example a Multiply-node.

    MEL

    SimplygonShadingNetwork
        -sd  $materialName multiplyNode 0 1.00 1.00 1.00
        -sd  $materialName multiplyNode 1 0.25 0.25 0.25
        -sd1 $materialName multiplyNode 1 3.00 1.00;
    

    Python

    cmds.SimplygonShadingNetwork(
        sd  = [materialName, multiplyNode, 0, 1.00, 1.00, 1.00], 
        sd  = [materialName, multiplyNode, 1, 0.25, 0.25, 0.25],
        sd1 = [materialName, multiplyNode, 1, 3.00, 1.00])
    

    Set exit node

    Assigns a shading node to a material channel.

    MEL

    SimplygonShadingNetwork
        -sce $materialName Diffuse "DiffuseSampler";
    

    Python

    cmds.SimplygonShadingNetwork(
        sce = [materialName, Diffuse, "DiffuseSampler"])
    

    Set swizzle

    Reverses the color channels (RGBA -> ABGR).

    MEL

    SimplygonShadingNetwork
        -si $materialName swizzleNode 0 "DiffuseSampler"
        -si $materialName swizzleNode 1 "DiffuseSampler"
        -si $materialName swizzleNode 2 "DiffuseSampler"
        -si $materialName swizzleNode 3 "DiffuseSampler"
        -swz $materialName swizzleNode 0 3
        -swz $materialName swizzleNode 1 2
        -swz $materialName swizzleNode 2 1
        -swz $materialName swizzleNode 3 0;
    

    Python

    cmds.SimplygonShadingNetwork(
        si  = [materialName, swizzleNode, 0, "DiffuseSampler"],
        si  = [materialName, swizzleNode, 1, "DiffuseSampler"],
        si  = [materialName, swizzleNode, 2, "DiffuseSampler"],
        si  = [materialName, swizzleNode, 3, "DiffuseSampler"],
        swz = [materialName, swizzleNode, 0, 3],
        swz = [materialName, swizzleNode, 1, 2],
        swz = [materialName, swizzleNode, 2, 1],
        swz = [materialName, swizzleNode, 3, 0])
    

    Set vertex color set

    Assigns "colorSet1" to a vertex-color node.

    MEL

    SimplygonShadingNetwork
        -svn $materialName vertexColorNode "colorSet1";
    

    Python

    cmds.SimplygonShadingNetwork(
        svn = [materialName, vertexColorNode, "colorSet1"])
    

    Override UV-set

    Overrides a texture-node's UV-set (globally).

    MEL

    SimplygonShadingNetwork
        -uva DiffuseSampler "map1";
    

    Python

    cmds.SimplygonShadingNetwork(
        uva = [DiffuseSampler, "map1"])
    

    Override sRGB

    Overrides the sRGB-flag for Diffuse and Normals. MEL

    SimplygonShadingNetwork
        -sc $materialName Diffuse "DiffuseSampler" true
        -sc $materialName Normals "NormalsSampler" false;
    

    Python

    cmds.SimplygonShadingNetwork(
        sc = [materialName, Diffuse, "DiffuseSampler", True],
        sc = [materialName, Normals, "NormalsSampler", False])
    

    Override tiling/offset

    Overrides a texture-node's tiling and offset values for the Diffuse channel.

    MEL

    SimplygonShadingNetwork
        -tmc $materialName Diffuse "DiffuseSampler" 2.0 2.0
        -omc $materialName Diffuse "DiffuseSampler" 0.5 0.5;
    

    Python

    cmds.SimplygonShadingNetwork(
        tmc = [materialName, Diffuse, "DiffuseSampler", 2.0, 2.0],
        omc = [materialName, Normals, "DiffuseSampler", 0.5, 0.5])
    

    Export Shading Network XML

    Exports a shading network for the given material channel to XML.

    MEL

    SimplygonShadingNetwork
        -exf cgfx_leather Diffuse "c:\\ShadingNetworksTemp\\leather_diffuse.xml";
    

    Python

    cmds.SimplygonShadingNetwork(
        exf = [cgfx_leather, Diffuse, "c:\\ShadingNetworksTemp\\leather_diffuse.xml"])
    

    Import Shading Network XML

    Imports shading network XML through the Simplygon command.

    MEL

    // specify Pipeline settings path
    $reductionPipeline = "D:/Pipelines/ReductionPipelineWithBaking.json";
    
    Simplygon 
        -sf $reductionPipeline
        -asm cgfx_leather|cgfx_wood
        -ixf cgfx_leather Diffuse "c:\\ShadingNetworksTemp\\cgfx_leather_diffuse.xml"
        -ixf cgfx_wood Diffuse "c:\\ShadingNetworksTemp\\cgfx_wood_diffuse.xml";
    

    Python

    cmds.Simplygon(
        sf = pipelineFilePath,
        asm = "cgfx_leather|cgfx_wood",
        ixf = [cgfx_leather, Diffuse, "c:\\ShadingNetworksTemp\\cgfx_leather_diffuse.xml"],
        ixf = [cgfx_wood, Diffuse, "c:\\ShadingNetworksTemp\\cgfx_wood_diffuse.xml"])
    

    Setting up CGFX/DirectX material

    This section goes through how to set up a CGFX/DirectX (HLSL) material, how to export and import materials to/from Simplygon through scripting and shading networks. First, make sure the DLL for the specific material type is loaded in the plug-in manager (Windows -> Settings/Preferences -> Plug-in Manager) as in figure 1.

    Plug-in manager

    Figure 1: CGFX/DirectX plug-in loaded in the plug-in manager.

    Let’s create a cube as in figure 2. This cube will be the target for our soon to be created DirectX material.

    Cube

    Figure 2: A cube.

    To create a new material, go to Hypershade (Windows -> Rendering Editors -> Hypershade) and click either Cgfx or DirectX shader (figure 3).
    The following sections will focus more on the CGFX shader, and as most things are identical for DirectX shaders it would be redundant. Please see the examples for complete CGFX/DirectX import/export scripts.

    How to create CGFX material

    Figure 3: How to create CGFX material in Hypershade.

    In the panel (figure 3) there is a material name which we name MyMaterial in this example. There is an empty field labeled CgFX File below the name - click Open and navigate to the HLSL file you want to use. The Property Editor should now list various material properties depending on how the HLSL is written as well as the technique (figure 4).
    In this example we use a HLSL shader with slots matching a simple PBR material, the rendering is somewhat simplified to make this example easier to follow.

    CGFX material with properties

    Figure 4: CGFX material with properties.

    It is now time to assign the material to our asset: Select the asset, go to Hypershade, click and hold the right mouse button on the recently created shader followed by releasing the button when hovering assign to selection.

    Another way to do this is to simply drag the material from Hypershade (using the middle mouse button) and drop it onto the asset.

    If we close Hypershade and bring forth the attribute editor (ctrl + A), then the asset should render with the new material. We have already prepared some textures for this specific material to make it somewhat more describing (figure 5).

    Attribute editor

    Figure 5: Cube with CGFX material successfully applied.

    That is it, we now have an asset with a HLSL shader attached to it!

    Scripting

    To translate a CGFX/DirectX material to a Simplygon material you might want to extract certain properties from your shader, for example a texture. Below is a snippet of a DirectX shader defining a texture.

    texture DiffuseTexture : Diffuse
    <
        string ResourceType = "2D";
        string UIName =  "Diffuse Texture";
    >;
    sampler2D DiffuseSampler = sampler_state 
    {
        Texture = <DiffuseTexture>;
        MinFilter = LinearMipMapLinear;
        MagFilter = Linear;
    };
    

    The sampler will show up in the CGFX material as in figure 6.

    Diffuse texture slot

    Figure 6: Diffuse texture slot.

    Export

    The first thing we need to do is to create a (shading) texture node using the SimplygonShadingNetwork-command along with the cn-flag (CreateNode), the name of the material as well as the name of the texture sampler.

    SimplygonShadingNetwork
        -cn $materialName TextureNode "DiffuseSampler";
    

    To connect the shading network exit node to a material channel, in this case to a channel named Diffuse, we add another row to our script.

    SimplygonShadingNetwork
        -cn $materialName TextureNode "DiffuseSampler"
        -sce $materialName Diffuse "DiffuseSampler";
    

    Commands in Maya are not state based and does not share any information, so to be able to pass the shading network templates from SimplygonShadingNetwork to Simplygon we will store the information to disk (using the exf-flag). Let’s add another flag to the SimplygonShadingNetwork-command.

    SimplygonShadingNetwork
        -cn $materialName TextureNode "DiffuseSampler"
        -sce $materialName Diffuse "DiffuseSampler"
        -exf $materialName Diffuse ($xmlExportPath + $materialName + "_Diffuse.xml");
    

    Now, after running this script there should be a xml file in the specified output folder containing the shading network template for the specified material channel. We will now use the generated template as input when calling the "Simplygon"-command.

    First we need the material input arguments for the "Simplygon"-command, which in this case is the path to the xml we exported earlier. We import it using import xml file (ixf).

    string $arguments = " -ixf \"" + $materialName + "\" Diffuse \"" + ($xmlExportPath + $materialName + "_Diffuse.xml\"");
    

    When calling the Simplygon-command we can specify some optional parameters which in this case are:
    dgm to not generate standard blinn phong material when importing LOD) and tod to specify a texture output directory where the resulting textures shall end up after LOD import. Finally we add the required flag, add shader material (asm) followed by material name and the previous xml import path. Remember to select the asset before running the Simplygon-command - otherwise the command will be ignored.

    string $processedMeshes[] = eval("Simplygon -sf $pipelineFilePath -dgm -tod $textureOutputDirectory -asm $materialName " + $arguments);
    

    Let us add the NormalsSampler texture to the Normals channel, this should be fairly easy from what we have learned. Let us take a look at the definition in the HLSL shader.

    texture NormalTexture : Normal
    <
        string ResourceType = "2D";
        string UIName =  "Normal Texture";
    >;
    sampler2D NormalsSampler = sampler_state 
    {
        Texture = <NormalTexture>;
        MinFilter = LinearMipMapLinear;
        MagFilter = Linear;
    };
    

    We add similar rows for normals as for the diffuse texture.

    SimplygonShadingNetwork
        -cn $materialName TextureNode "DiffuseSampler"
        -cn $materialName TextureNode "NormalsSampler"
        -sce $materialName Diffuse "DiffuseSampler"
        -sce $materialName Normals "NormalsSampler"
        -exf $materialName Diffuse ($xmlExportPath + $materialName + "_Diffuse.xml")
        -exf $materialName Normals ($xmlExportPath + $materialName + "_Normals.xml");
    string $arguments = 
    " -ixf \"" + $materialName + "\" Diffuse \"" + ($xmlExportPath + $materialName + "_Diffuse.xml\"") +
    " -ixf \"" + $materialName + "\" Normals \"" + ($xmlExportPath + $materialName + "_Normals.xml\"");
    string $processedMeshes[] = eval("Simplygon -sf $pipelineFilePath -dgm -tod $textureOutputDirectory -asm $materialName " + $arguments);
    

    This is a short example of how to use shading networks to translate a custom HLSL shader. Please take a look at the tables above including shading nodes, commands and flags to see what is available. There are also a couple of examples at the end of this document which focusing more on shading nodes and hierarchy.

    This is the end of the export part and how to get the asset to Simplygon. What happens next is more dependent on the settings that is used for processing and what kind of LODs that come back.

    Import

    If we continue where we left off at the export step the return value of the Simplygon-command will contain the names of the processed meshes.

    string $processedMeshes[] = eval("Simplygon -sf $pipelineFilePath -dgm -tod $textureOutputDirectory -asm $materialName " + $arguments);
    

    The Simplygon Maya plug-in stores some material information from the last run to give the user a chance to manually setup materials via script. To access such information we will use the SimplygonQuery-command with the appropriate flags. We will start by asking the plug-in for the material name of a mesh, material channels as well as textures.

    for( $m in $processedMeshes )
    {
        $m = substituteAllString($m, "|", "");
        print ("\nMesh: " + $m + "\n"); 
        string $material;
        $material = `SimplygonQuery -gmm $m`;
        print ("  Material: " + $material + "\n");
        $channels = `SimplygonQuery -gcm $material`;
        for( $c in $channels )
        {
        print ("    Channel: " + $c + "\n");
        $filepath = `SimplygonQuery -gtc $material $c`;
        print ("      Texture: " + $filepath + "\n");
        }
    }
    

    What remains is to create a new CGFX/DirectX material and map back the information that was fetched from SimplygonQuery-command. However, we will spare you from that right now as it includes quite many lines and special conditions that may not belong in this section. Please take a look at the examples for a more complete script.

    Example scripts

    Simplygon PBR (CGFX)

    This script loops through all Simplygon PBR materials (HLSL connected to CGFX) and sets up shading networks accordingly. Then it sends the selected assets to Simplygon for processing. When the processing is done the LODs are returned to Maya where the script takes over and maps the LOD materials back to a HLSL shader.

    string $simplygonDocumentsPath[] = `SimplygonPreset -gsp`;
    string $rootPath = $simplygonDocumentsPath[0] + "\\Samples\\Maya\\SimplygonMan";
    
    // pipeline settings
    string $pipelineFilePath = $rootPath + "\\Pipelines\\ReductionWithBaking.json";
    
    // path to Simplygon PBR shader
    string $pbgShaderFile = $rootPath + "\\Shader\\SimplygonPBRShader.fx";
    
    // "" = default, "d:\\TextureOutputFolder\\" = custom
    string $textureOutputDirectory = $rootPath + "\\OutputTextures\\";
    
    // cube map path for all meshes with material baking
    string $cubeMapFilePath = $rootPath + "\\CubeMap\\cube_map.dds";
    
    // drive to store temporary xml files (c might be protected)
    string $xmlExportPath = $rootPath + "\\XMLTempFolder\\";
    
    // populate material list
    string $cgfxMaterials[] = `ls -type cgfxShader`;
    for( $cgfx_mat in $cgfxMaterials )
    {
        string $technique = `getAttr ($cgfx_mat + ".technique")`;
        if($technique != "PBR")
        {
            $cgfx_mat = "";
        }
    }
    
    // create shading networks for each cgfx material
    // and export template to xml (for later use)
    string $inputMaterialString = "";
    for( $cgfx_mat in $cgfxMaterials )
    {
        if(size ($cgfx_mat) == 0)
            continue;
    
        print ("\nSimplygon PBR Shader:\n Name: " + $cgfx_mat + "\n");
    
        string $normalMaps[] = `listConnections -type "file" ($cgfx_mat + ".NormalsSampler")`;
        for ( $nMap in $normalMaps ) 
        {
            string $filename = `getAttr($nMap + ".fileTextureName")`;
            print (" Normal map (" + $nMap + "): "  + $filename + "\n");
    
            // check color space for all textures connected to the normal map of this material
            string $currentColorSpace = `getAttr ($nMap + ".colorSpace")`;
            print (" Current color space: " + $currentColorSpace + "\n");
    
            if($currentColorSpace != "Raw")
            {
                string $availableColorSpaces[] = `colorManagementPrefs -q -inputSpaceNames`;
                if ( stringArrayContains("Raw", $availableColorSpaces) )
                {
                    setAttr ($nMap+".ignoreColorSpaceFileRules") 1;
                    setAttr ($nMap+".colorSpace") -type "string" "Raw";
                    print (" New color space: Raw\n");
                }
                else
                {
                    print ("Normal map with incorrect color space found but could not find a suitable color space, please check the color space setting for this texture!\n");
                }
            }
    
            int $NameBasedSearchWarning = false;
            string $result = `match "_n." $filename`;
            if($result == "_n.")
            {
                $NameBasedSearchWarning = true;
            }
            $result = `match "normals" $filename`;
            if($result == "normals")
            {
                $NameBasedSearchWarning = true;
            }
    
            if($NameBasedSearchWarning == true)
            {
                print (" Prediction (name based): most likely a normal map)\n");
            }
        }
    
        SimplygonShadingNetwork
        // create texture nodes
        -cn $cgfx_mat TextureNode DiffuseSampler
        -cn $cgfx_mat TextureNode SpecularSampler
        -cn $cgfx_mat TextureNode RoughnessSampler
        -cn $cgfx_mat TextureNode MetalnessSampler
        -cn $cgfx_mat TextureNode NormalsSampler
    
        // override uv channels
        -uva DiffuseSampler map1
        -uva SpecularSampler map1
        -uva RoughnessSampler map1
        -uva MetalnessSampler map1
        -uva NormalsSampler map1
    
        // override sRGB
        -sa DiffuseSampler true
        -sa SpecularSampler true
        -sa RoughnessSampler true
        -sa MetalnessSampler true
        -sa NormalsSampler false
    
        // connect textures to simplygon channels
        -sce $cgfx_mat Diffuse DiffuseSampler
        -sce $cgfx_mat Specular SpecularSampler
        -sce $cgfx_mat Roughness RoughnessSampler
        -sce $cgfx_mat Metalness MetalnessSampler
        -sce $cgfx_mat Normals NormalsSampler
    
        -tmc $cgfx_mat Diffuse DiffuseSampler 1.0 1.0
        -omc $cgfx_mat Diffuse DiffuseSampler 0.0 0.0
    
        // export material channel templates to xml for later use
        -exf $cgfx_mat Diffuse ($xmlExportPath + $cgfx_mat + "_Diffuse.xml")
        -exf $cgfx_mat Specular ($xmlExportPath + $cgfx_mat + "_Specular.xml")
        -exf $cgfx_mat Roughness ($xmlExportPath + $cgfx_mat + "_Roughness.xml")
        -exf $cgfx_mat Metalness ($xmlExportPath + $cgfx_mat + "_Metalness.xml")
        -exf $cgfx_mat Normals ($xmlExportPath + $cgfx_mat + "_Normals.xml");
    
        // append material name to string (for later use)
        $inputMaterialString += $cgfx_mat + "|";
    }
    
    // parse arguments
    string $arguments = "";
    for( $cgfx_material in $cgfxMaterials )
    {
        if(size ($cgfx_material) == 0)
            continue;
    
        $arguments += " -ixf \"" + $cgfx_material + "\" Diffuse \"" + ($xmlExportPath + $cgfx_material + "_Diffuse.xml\"");
        $arguments += " -ixf \"" + $cgfx_material + "\" Specular \"" + ($xmlExportPath + $cgfx_material + "_Specular.xml\"");
        $arguments += " -ixf \"" + $cgfx_material + "\" Roughness \"" + ($xmlExportPath + $cgfx_material + "_Roughness.xml\"");
        $arguments += " -ixf \"" + $cgfx_material + "\" Metalness \"" + ($xmlExportPath + $cgfx_material + "_Metalness.xml\"");
        $arguments += " -ixf \"" + $cgfx_material + "\" Normals \"" + ($xmlExportPath + $cgfx_material + "_Normals.xml\"");
    }
    
    // correct double slashes
    $arguments = substituteAllString($arguments, "\\", "\\\\");
    
    // launch Simplygon and fetch the result
    string $processedMeshes[];
    
    $processedMeshes = eval("Simplygon -dgm -tod $textureOutputDirectory -sf $pipelineFilePath -asm $inputMaterialString" + $arguments);
    
    // link cube map
    string $cubeMapNode = `shadingNode -isColorManaged -asTexture file`;
    setAttr -type "string" ( $cubeMapNode + ".fileTextureName" ) $cubeMapFilePath;
    
    // fetch lod names
    int $lodIndex = 0;
    string $materialNameArray[];
    string $SGNameArray[];
    
    //$processedMeshes = `SimplygonQuery -gpm`;
    for( $m in $processedMeshes )
    {
        // correct mesh names from Simplygon call
        $m = substituteAllString($m, "|", "");
        print ("\nMesh: " + $m + "\n");
    
        // offset new mesh along x-axis
        select -r $m;
        $transAttr = $m+".translateX";
        float $bbox[] = `exactWorldBoundingBox`;
        float $moveOffset = ($lodIndex+1)*($bbox[3]-$bbox[0])*1.1;
        setAttr -lock off $transAttr;
        move -r $moveOffset 0 0;
    
        string $material;
    
        // fetch material name for mesh, 
        // start with checking for reused materials
        $reuseMaterials = `SimplygonQuery -rms $m`;
        if(size ($reuseMaterials) == 0)
        {
            print ("  Not reusing material.\n");
            $material = `SimplygonQuery -gmm $m`;
        }
        else
        {
            int $currentMaterialIndex = 0;
            int $isReusingMaterial = false;
    
            for( $reuseMaterial in $reuseMaterials )
            {
                print ("  Checking material: " + $reuseMaterial + "\n");
                int $i = stringArrayFind( $reuseMaterial, 0, $materialNameArray );
                if($i < 0)
                {
                    print ("    Reusing original material!\n");
                    select -cl;
                    $materialIds = `SimplygonQuery -gmi $m`;
                    //print $materialIds;
    
                    int $tid = 0;
                    for( $mid in $materialIds )
                    {
                        if($mid == $currentMaterialIndex)
                        {
                            //print ("     Selecting triangle " + $tid + " for material " + $mid + "\n");
                            select -tgl ($m + ".f[" + $tid + "]");
                        }
                        $tid++;
                    }
    
                    print ("     Assigning material " + $reuseMaterial + " to selected triangles for mesh " + $m + "\n");
                    sets -e -forceElement $reuseMaterial;
                    select -cl;
    
                    $lodIndex++;
                    $currentMaterialIndex++;
                    $isReusingMaterial = true;
                    continue; 
                }
    
                // material was found in lod chain, continuing
                string $nameOfMaterialNode = $SGNameArray[$i];
    
                // assign material to selected mesh
                select -r $m;
                if(size ($nameOfMaterialNode) != 0)
                {    
                    sets -e -forceElement $nameOfMaterialNode;
                }
    
                // offset new mesh along x-axis
                $lodIndex++;
                $currentMaterialIndex++;
                $isReusingMaterial = true;
                continue;
            }
    
            // if reuse, exit here
            if($isReusingMaterial == true)
            {
                continue;
            }
        }
    
        print ("  Material: " + $material + "\n");
    
        // create cgfx shader and matching SG node
        string $shader = `shadingNode -asShader cgfxShader`;
        string $shaderSG = `sets -renderable true -noSurfaceShader true -empty -name ($shader + "SG")`;
    
        stringArrayInsertAtIndex($lodIndex, $SGNameArray, $shaderSG);
        stringArrayInsertAtIndex($lodIndex, $materialNameArray, $material);
    
        // connect shader to shaderSG
        connectAttr -f ( $shader + ".outColor" ) ( $shaderSG + ".surfaceShader" );
    
        // user Simplygon PBR shader with default PBR teqhnique
        cgfxShader -e -fx $pbgShaderFile $shader;
        setAttr -type "string" ($shader + ".technique") "PBR";
    
        // connect cube map
        connectAttr -force ($cubeMapNode + ".outColor") ($shader + ".CubemapSampler");
    
        // fetch channel names for mesh material
        $channels = `SimplygonQuery -gcm $material`;
        for( $c in $channels )
            {
                // fetch texture path for channel
                print ("    Channel: " + $c + "\n");
                $filepath = `SimplygonQuery -gtc $material $c`;
                print ("      Texture: " + $filepath + "\n");
    
                // create texture nodes and link textures
                string $fileNode = `shadingNode -isColorManaged -asTexture file`;
    
                setAttr -type "string" ( $fileNode + ".fileTextureName" ) $filepath;
                if($c == "Diffuse")
                {
                    connectAttr -force ($fileNode + ".outColor") ($shader + ".DiffuseSampler");
                }
                else if($c == "Specular")
                {
                    connectAttr -force ($fileNode + ".outColor") ($shader + ".SpecularSampler");
                }
                else if($c == "Roughness")
                {
                    connectAttr -force ($fileNode + ".outColor") ($shader + ".RoughnessSampler");
                }
                else if($c == "Metalness")
                {
                    connectAttr -force ($fileNode + ".outColor") ($shader + ".MetalnessSampler");
                }
                else if($c == "Normals")
                {
                    connectAttr -force ($fileNode + ".outColor") ($shader + ".NormalsSampler");
    
                    // force colorspace, if possible
                    string $currentColorSpace = `getAttr ($fileNode + ".colorSpace")`;
                    if($currentColorSpace != "Raw")
                    {
                        string $availableColorSpaces[] = `colorManagementPrefs -q -inputSpaceNames`;
                        if ( stringArrayContains("Raw", $availableColorSpaces) )
                        {
                            setAttr ($fileNode+".ignoreColorSpaceFileRules") 1;
                            setAttr ($fileNode+".colorSpace") -type "string" "Raw";
                        }
                        }
                }
                }
    
        // assign material to selected mesh
        select -r $m;
        sets -e -forceElement $shaderSG;
    
        // offset new mesh along x-axis
        $lodIndex++;
    }
    

    Simplygon PBR (DirectX)

    This script loops through all Simplygon PBR materials (HLSL connected to DirectX) and sets up shading networks accordingly. Then it sends the selected assets to Simplygon for processing. When the processing is done the LODs are returned to Maya where the script takes over and maps the LOD materials back to a HLSL shader.

    // DirectX export
    string $rootPath = "C:\\SimplygonExample\\";
    
    // pipeline settings
    string $pipelineFilePath = $rootPath + "\\Pipelines\\ReductionWithBaking.json";
    
    // path to Simplygon PBR shader
    string $pbrShaderFile = $rootPath + "\\Shader\\SimplygonPBRShaderDirectX.fx";
    
    // "" = default, "d:\\TextureOutputFolder\\" = custom
    string $textureOutputDirectory = $rootPath + "\\OutputTextures\\";
    
    // cube map path for all meshes with material baking
    string $cubeMapFilePath = $rootPath + "\\CubeMap\\cube_map.dds";
    
    // drive to store temporary xml files (c might be protected)
    string $xmlExportPath = $rootPath + "\\XMLTempFolder\\";
    
    // populate material list
    string $directxMaterials[] = `ls -type dx11Shader`;
    for( $directx_mat in $directxMaterials )
    {
        string $technique = `getAttr ($directx_mat + ".technique")`;
        if($technique != "PBR")
        {
            $directx_mat = "";
        }
    }
    
    // create shading networks for each DirectX11 material
    // and export template to xml (for later use)
    string $inputMaterialString = "";
    for( $directx_mat in $directxMaterials )
    {
        if(size ($directx_mat) == 0)
            continue;
    
        print ("\nDirectX11 Shader:\n Name: " + $directx_mat + "\n");
    
        string $normalNodes[] = `listConnections -type "bump2d" ($directx_mat + ".NormalTexture")`;
        string $normalMaps[] = `listConnections -type "file" ($directx_mat + ".NormalTexture")`;
    
        if(size($normalNodes) > 0)
        {
            string $furtherNormalMaps[] = `listConnections -type "file" $normalNodes[0]`;
            int $size = size($furtherNormalMaps);
            appendStringArray($normalMaps, $furtherNormalMaps, $size);
        }
    
        for ( $nMap in $normalMaps ) 
        {
            string $filename = `getAttr($nMap + ".fileTextureName")`;
            print (" Normal map (" + $nMap + "): "  + $filename + "\n");
    
            // check color space for all textures connected to the normal map of this material
            string $currentColorSpace = `getAttr ($nMap + ".colorSpace")`;
            print (" Current color space: " + $currentColorSpace + "\n");
    
            if($currentColorSpace != "Raw")
            {
                string $availableColorSpaces[] = `colorManagementPrefs -q -inputSpaceNames`;
                if ( stringArrayContains("Raw", $availableColorSpaces) )
                {
                    setAttr ($nMap+".ignoreColorSpaceFileRules") 1;
                    setAttr ($nMap+".colorSpace") -type "string" "Raw";
                    print (" New color space: Raw\n");
                }
                else
                {
                    print ("Normal map with incorrect color space found but could not find a suitable color space, please check the color space setting for this texture!\n");
                }
            }
    
            int $NameBasedSearchWarning = false;
            string $result = `match "_n." $filename`;
            if($result == "_n.")
            {
                $NameBasedSearchWarning = true;
            }
            $result = `match "normals" $filename`;
            if($result == "normals")
            {
                $NameBasedSearchWarning = true;
            }
    
            if($NameBasedSearchWarning == true)
            {
                print (" Prediction (name based): most likely a normal map)\n");
            }
        }
    
        SimplygonShadingNetwork
        // create texture nodes
        -cn $directx_mat TextureNode DiffuseTexture
        -cn $directx_mat TextureNode SpecularTexture
        -cn $directx_mat TextureNode RoughnessTexture
        -cn $directx_mat TextureNode MetalnessTexture
        -cn $directx_mat TextureNode NormalTexture
    
        // override uv channels
        -uva DiffuseTexture map1
        -uva SpecularTexture map1
        -uva RoughnessTexture map1
        -uva MetalnessTexture map1
        -uva NormalTexture map1
    
        // override sRGB
        -sa DiffuseTexture true
        -sa SpecularTexture true
        -sa RoughnessTexture true
        -sa MetalnessTexture true
        -sa NormalTexture false
    
        // connect textures to simplygon channels
        -sce $directx_mat Diffuse DiffuseTexture
        -sce $directx_mat Specular SpecularTexture
        -sce $directx_mat Roughness RoughnessTexture
        -sce $directx_mat Metalness MetalnessTexture
        -sce $directx_mat Normals NormalTexture
    
        -tmc $directx_mat Diffuse DiffuseTexture 1.0 1.0
        -omc $directx_mat Diffuse DiffuseTexture 0.0 0.0
    
        // export material channel templates to xml for later use
        -exf $directx_mat Diffuse ($xmlExportPath + $directx_mat + "_Diffuse.xml")
        -exf $directx_mat Specular ($xmlExportPath + $directx_mat + "_Specular.xml")
        -exf $directx_mat Roughness ($xmlExportPath + $directx_mat + "_Roughness.xml")
        -exf $directx_mat Metalness ($xmlExportPath + $directx_mat + "_Metalness.xml")
        -exf $directx_mat Normals ($xmlExportPath + $directx_mat + "_Normals.xml");
    
        // append material name to string (for later use)
        $inputMaterialString += $directx_mat + "|";
    }
    
    // parse arguments
    string $arguments = "";
    for( $directx_material in $directxMaterials )
    {
        if(size ($directx_material) == 0)
            continue;
    
        print ("\nDirectX11 Shader " + $directx_material + " has the following maps:\n");
    
        int $hasDiffuseTexture = false;
        string $diffuseMaps[] = `listConnections -type "file" ($directx_material + ".DiffuseTexture")`;
        for ( $dMap in $diffuseMaps ) 
        {
            string $filename = `getAttr($dMap + ".fileTextureName")`;
            $hasDiffuseTexture = size($filename) > 0;
            print (" Diffuse map (" + $dMap + "): "  + $filename + " (" + $hasDiffuseTexture + ")\n");
        }
    
        int $hasSpecularTexture = false;
        string $specularMaps[] = `listConnections -type "file" ($directx_material + ".SpecularTexture")`;
        for ( $sMap in $specularMaps ) 
        {
            string $filename = `getAttr($dMap + ".fileTextureName")`;
            $hasSpecularTexture = size($filename) > 0;
            print (" Specular map (" + $dMap + "): "  + $filename + " (" + $hasSpecularTexture + ")\n");
        }
    
        int $hasRoughnessTexture = false;
        string $roughnessMaps[] = `listConnections -type "file" ($directx_material + ".RoughnessTexture")`;
        for ( $rMap in $roughnessMaps ) 
        {
            string $filename = `getAttr($rMap + ".fileTextureName")`;
            $hasRoughnessTexture = size($filename) > 0;
            print (" Roughness map (" + $rMap + "): "  + $filename + " (" + $hasRoughnessTexture + ")\n");
        }
    
        int $hasMetalnessTexture = false;
        string $metalnessMaps[] = `listConnections -type "file" ($directx_material + ".MetallnessTexture")`;
        for ( $mMap in $metalnessMaps ) 
        {
            string $filename = `getAttr($mMap + ".fileTextureName")`;
            $hasMetalnessTexture = size($filename) > 0;
            print (" Metalness map (" + $mMap + "): "  + $filename + " (" + $hasMetalnessTexture + ")\n");
        }
    
        int $hasNormalTexture = false;
        string $normalNodes[] = `listConnections -type "bump2d" ($directx_material + ".NormalTexture")`;
        string $normalMaps[] = `listConnections -type "file" ($directx_material + ".NormalTexture")`;
    
        if(size($normalNodes) > 0)
        {
            string $furtherNormalMaps[] = `listConnections -type "file" $normalNodes[0]`;
            int $size = size($furtherNormalMaps);
            appendStringArray($normalMaps, $furtherNormalMaps, $size);
        }
    
        for ( $nMap in $normalMaps ) 
        {
            string $filename = `getAttr($nMap + ".fileTextureName")`;
            $hasNormalTexture = size($filename) > 0;
            print (" Normal map (" + $nMap + "): "  + $filename + " (" + $hasNormalTexture + ")\n");
        }
    
        if($hasDiffuseTexture == true)
        {
            $arguments += " -ixf \"" + $directx_material + "\" Diffuse \"" + ($xmlExportPath + $directx_material + "_Diffuse.xml\"");
        }
        if($hasSpecularTexture == true)
        {   
            $arguments += " -ixf \"" + $directx_material + "\" Specular \"" + ($xmlExportPath + $directx_material + "_Specular.xml\"");
        }
        if($hasRoughnessTexture == true)
        {   
            $arguments += " -ixf \"" + $directx_material + "\" Roughness \"" + ($xmlExportPath + $directx_material + "_Roughness.xml\"");
        }
        if($hasMetalnessTexture == true)
        {   
            $arguments += " -ixf \"" + $directx_material + "\" Metalness \"" + ($xmlExportPath + $directx_material + "_Metalness.xml\"");
        }
        if($hasNormalTexture == true)
        {   
            $arguments += " -ixf \"" + $directx_material + "\" Normals \"" + ($xmlExportPath + $directx_material + "_Normals.xml\"");
        }
    }
    
    // correct double slashes
    $arguments = substituteAllString($arguments, "\\", "\\\\");
    
    // launch Simplygon and fetch the result
    string $processedMeshes[] = eval("Simplygon -sf $pipelineFilePath -dgm -tod $textureOutputDirectory -asm $inputMaterialString" + $arguments);
    
    // link cube map
    string $cubeMapNode = `shadingNode -isColorManaged -asTexture file`;
    //setAttr -type "string" ( $cubeMapNode + ".fileTextureName" ) $cubeMapFilePath;
    
    // fetch lod names
    int $lodIndex = 0;
    string $materialNameArray[];
    string $SGNameArray[];
    
    //$processedMeshes = `SimplygonQuery -gpm`;
    for( $m in $processedMeshes )
    {
        // correct mesh names from Simplygon call
        $m = substituteAllString($m, "|", "");
        print ("\nMesh: " + $m + "\n");
    
        // offset new mesh along x-axis
        select -r $m;
        $transAttr = $m+".translateX";
        float $bbox[] = `exactWorldBoundingBox`;
        float $moveOffset = ($lodIndex+1)*($bbox[3]-$bbox[0])*1.1;
    
        setAttr -lock off $transAttr;
        move -r $moveOffset 0 0;
    
        string $material;
    
        // fetch material name for mesh, 
        // start with checking for reused materials
        $reuseMaterials = `SimplygonQuery -rms $m`;
        if(size ($reuseMaterials) == 0)
        {
            print ("  Not reusing material.\n");
            $material = `SimplygonQuery -gmm $m`;
        }
        else
        {
            int $currentMaterialIndex = 0;
            int $isReusingMaterial = false;
    
            for( $reuseMaterial in $reuseMaterials )
            {
                print ("  Checking material: " + $reuseMaterial + "\n");
                int $i = stringArrayFind( $reuseMaterial, 0, $materialNameArray );
                if($i < 0)
                {
                    print ("    Reusing original material!\n");
                    select -cl;
                    $materialIds = `SimplygonQuery -gmi $m`;
                    //print $materialIds;
    
                    int $tid = 0;
                    for( $mid in $materialIds )
                    {
                        if($mid == $currentMaterialIndex)
                        {
                            //print ("     Selecting triangle " + $tid + " for material " + $mid + "\n");
                            select -tgl ($m + ".f[" + $tid + "]");
                        }
                        $tid++;
                    }
    
                    print ("     Assigning material " + $reuseMaterial + " to selected triangles for mesh " + $m + "\n");
                    sets -e -forceElement $reuseMaterial;
                    select -cl;
    
                    $lodIndex++;
                    $currentMaterialIndex++;
                    $isReusingMaterial = true;
                    continue; 
                }
    
                // material was found in lod chain, continuing
                string $nameOfMaterialNode = $SGNameArray[$i];
    
                // assign material to selected mesh
                select -r $m;
                if(size ($nameOfMaterialNode) != 0)
                {    
                    sets -e -forceElement $nameOfMaterialNode;
                }
    
                // offset new mesh along x-axis
                $lodIndex++;
                $currentMaterialIndex++;
                $isReusingMaterial = true;
                continue;
            }
    
            // if reuse, exit here
            if($isReusingMaterial == true)
            {
                continue;
            }
        }
    
        // if not reuse, create new material
        print ("  Creating material: " + $material + "\n");
    
        // create DirectX11 shader and matching SG node
        string $shader = `shadingNode -asShader dx11Shader`;
        string $shaderSG = `sets -renderable true -noSurfaceShader true -empty -name ($shader + "SG")`;
    
        stringArrayInsertAtIndex($lodIndex, $SGNameArray, $shaderSG);
        stringArrayInsertAtIndex($lodIndex, $materialNameArray, $material);
    
        // connect shader to shaderSG
        connectAttr -f ( $shader + ".outColor" ) ( $shaderSG + ".surfaceShader" );
    
        // user Simplygon PBR shader with default PBR teqhnique
        setAttr -type "string" ($shader + ".shader") $pbrShaderFile;
        setAttr -type "string" ($shader + ".technique") "PBR";
    
        // assign UV-set to the shader
        string $currentUVSet[] = `polyUVSet -q -currentUVSet $m`;
        setAttr -type "string" ($shader + ".TexCoord0_Source") ("uv:" + $currentUVSet[0]);
        setAttr -type "string" ($shader + ".Tangent0_Source") ("tangent:" + $currentUVSet[0]);
    
        // connect cube map
        //connectAttr -force ($cubeMapNode + ".outColor") ($shader + ".CubemapSampler");
    
        // fetch channel names for mesh material
        $channels = `SimplygonQuery -gcm $material`;
        for( $c in $channels )
            {
                // fetch texture path for channel
                print ("    Channel: " + $c + "\n");
                $filepath = `SimplygonQuery -gtc $material $c`;
                print ("      Texture: " + $filepath + "\n");
    
                // create texture nodes and link textures
                string $fileNode = `shadingNode -isColorManaged -asTexture file`;
    
                setAttr -type "string" ( $fileNode + ".fileTextureName" ) $filepath;
                if($c == "Diffuse")
                {
                    connectAttr -force ($fileNode + ".outColor") ($shader + ".DiffuseTexture");
                }
                else if($c == "Specular")
                {
                    connectAttr -force ($fileNode + ".outColor") ($shader + ".SpecularTexture");
                }
                else if($c == "Roughness")
                {
                    connectAttr -force ($fileNode + ".outColor") ($shader + ".RoughnessTexture");
                }
                else if($c == "Metalness")
                {
                    connectAttr -force ($fileNode + ".outColor") ($shader + ".MetalnessTexture");
                }
                else if($c == "Normals")
                {
                    string $bNode =`shadingNode -asUtility bump2d`;
                    setAttr ($bNode + ".bumpInterp") 1;
                    connectAttr -f ($bNode + ".outNormal") ($shader + ".NormalTexture");
                    connectAttr -f ($fileNode + ".outAlpha") ($bNode + ".bumpValue");
    
                    // force colorspace, if possible
                    string $currentColorSpace = `getAttr ($fileNode + ".colorSpace")`;
                    if($currentColorSpace != "Raw")
                    {
                        string $availableColorSpaces[] = `colorManagementPrefs -q -inputSpaceNames`;
                        if ( stringArrayContains("Raw", $availableColorSpaces) )
                        {
                            setAttr ($fileNode+".ignoreColorSpaceFileRules") 1;
                            setAttr ($fileNode+".colorSpace") -type "string" "Raw";
                        }
                    }
                }
           }
    
        // assign material to selected mesh
        select -r $m;
        sets -e -forceElement $shaderSG;
    
        // offset new mesh along x-axis
        $lodIndex++;
    }
    

    Texture blending

    This script sets up two texture nodes that are blended using the InterpolateNode.

    string $pipelineFilePath = "D:\\Pipelines\\ReductionPipelineWithBaking.json";
    ...
    
    select -all;
    SimplygonShadingNetwork 
    -cn cgfx_mat VertexColorNode DiffuseColor1
    -cn cgfx_mat VertexColorNode DiffuseColor2
    -cn cgfx_mat VertexColorNode DiffuseColor3
    
    -svn cgfx_mat DiffuseColor1 redColorSet     // link red set
    -svn cgfx_mat DiffuseColor2 greenColorSet   // link green set
    -svn cgfx_mat DiffuseColor3 blendColorSet   // link blend set
    
    -cn cgfx_mat InterpolateNode VertexColorInterpolator
    
    -si cgfx_mat VertexColorInterpolator 0 DiffuseColor1    // red set -> 0
    -si cgfx_mat VertexColorInterpolator 1 DiffuseColor2    // green set -> 1
    -si cgfx_mat VertexColorInterpolator 2 DiffuseColor3    // blend set -> 2
    
    -sce cgfx_mat Diffuse VertexColorInterpolator
    
    -exf cgfx_mat Diffuse "D:\\diffuse.xml";
    
    Simplygon 
    -sf $pipelineFilePath
    -asm cgfx_mat
    -ixf cgfx_mat Diffuse "D:\\diffuse.xml";
    

    Blending with vertex colors

    This script sets up three vertex color nodes where the last one is used as blend weight. This example is based on the InterpolateNode.

    string $pipelineFilePath = "D:\\Pipelines\\ReductionPipelineWithBaking.json";
    ...
    
    select -all;
    SimplygonShadingNetwork 
    -cn cgfx_mat ColorNode DiffuseColor1
    -cn cgfx_mat ColorNode DiffuseColor2
    -cn cgfx_mat VertexColorNode BlendColor
    
    -sd cgfx_mat DiffuseColor1 0 1.0 0.0 0.0    // base 1, red
    -sd cgfx_mat DiffuseColor2 0 0.0 1.0 0.0    // base 2, green
    -svn cgfx_mat BlendColor blendColorSet      // link blend set
    
    -cn cgfx_mat InterpolateNode VertexColorInterpolator
    
    -si cgfx_mat VertexColorInterpolator 0 DiffuseColor1    // red -> 0
    -si cgfx_mat VertexColorInterpolator 1 DiffuseColor2    // green -> 1
    -si cgfx_mat VertexColorInterpolator 2 BlendColor       // vertex color -> 3
    
    -sce cgfx_mat Diffuse VertexColorInterpolator
    
    -exf cgfx_mat Diffuse "D:\\diffuse.xml";
    
    Simplygon
    -sf $pipelineFilePath
    -asm cgfx_mat
    -ixf cgfx_mat Diffuse "D:\\diffuse.xml";
    
    In This Article
    Back to top Terms of Use | Privacy and cookies | Trademarks | Copyright © 2019 Microsoft