This example shows how to use Simplygon shading network.

// Copyright (c) Microsoft Corporation. 
// Licensed under the MIT license. 

#include <string>
#include <stdlib.h>
#include <filesystem>
#include <future>
#include "SimplygonLoader.h"


void RunReductionWithShadingNetworks(Simplygon::ISimplygon* sg)
{
	Simplygon::spSceneImporter sgSceneImporter = sg->CreateSceneImporter();
	sgSceneImporter->SetImportFilePath( "../Assets/SimplygonMan/SimplygonMan.obj" );
	if(!sgSceneImporter->RunImport())
		throw std::exception("Failed to load SimplygonMan/SimplygonMan.obj.");
	Simplygon::spScene sgScene = sgSceneImporter->GetScene();

	Simplygon::spReductionProcessor sgReductionProcessor = sg->CreateReductionProcessor();

	sgReductionProcessor->SetScene( sgScene );

	Simplygon::spReductionSettings sgReductionSettings = sgReductionProcessor->GetReductionSettings();
	Simplygon::spMappingImageSettings sgMappingImageSettings = sgReductionProcessor->GetMappingImageSettings();

	// Generates a mapping image which is used after the reduction to cast new materials to the new 
	// reduced object. 
	sgMappingImageSettings->SetGenerateMappingImage( true );
	sgMappingImageSettings->SetApplyNewMaterialIds( true );
	sgMappingImageSettings->SetGenerateTangents( true );
	sgMappingImageSettings->SetUseFullRetexturing( true );

	// Inject a sepia filter into the shading network for the diffuse channel for each material in the 
	// scene. 
	int materialCount = (int)sgScene->GetMaterialTable()->GetMaterialsCount();
	for (int i = 0; i < materialCount; ++i)
	{
		Simplygon::spMaterial sgMaterial = sgScene->GetMaterialTable()->GetMaterial(i);

		Simplygon::spShadingNode sgMaterialShadingNode = sgMaterial->GetShadingNetwork("Diffuse");
		Simplygon::spShadingColorNode sgSepiaColor1 = sg->CreateShadingColorNode();
		Simplygon::spShadingColorNode sgSepiaColor2 = sg->CreateShadingColorNode();
		Simplygon::spShadingColorNode sgSepiaColor3 = sg->CreateShadingColorNode();
		Simplygon::spShadingColorNode sgRedFilter = sg->CreateShadingColorNode();
		Simplygon::spShadingColorNode sgGreenFilter = sg->CreateShadingColorNode();
		Simplygon::spShadingColorNode sgBlueFilter = sg->CreateShadingColorNode();
		Simplygon::spShadingDot3Node sgSepiaDot1 = sg->CreateShadingDot3Node();
		Simplygon::spShadingDot3Node sgSepiaDot2 = sg->CreateShadingDot3Node();
		Simplygon::spShadingDot3Node sgSepiaDot3 = sg->CreateShadingDot3Node();
		Simplygon::spShadingMultiplyNode sgSepiaMul1 = sg->CreateShadingMultiplyNode();
		Simplygon::spShadingMultiplyNode sgSepiaMul2 = sg->CreateShadingMultiplyNode();
		Simplygon::spShadingMultiplyNode sgSepiaMul3 = sg->CreateShadingMultiplyNode();
		Simplygon::spShadingAddNode sgSepiaAdd1 = sg->CreateShadingAddNode();
		Simplygon::spShadingAddNode sgSepiaAdd2 = sg->CreateShadingAddNode();

		sgSepiaColor1->SetColor(0.393f, 0.769f, 0.189f, 1.0f);
		sgSepiaColor2->SetColor(0.349f, 0.686f, 0.168f, 1.0f);
		sgSepiaColor3->SetColor(0.272f, 0.534f, 0.131f, 1.0f);
		sgRedFilter->SetColor(1.0f, 0.0f, 0.0f, 1.0f);
		sgGreenFilter->SetColor(0.0f, 1.0f, 0.0f, 1.0f);
		sgBlueFilter->SetColor(0.0f, 0.0f, 1.0f, 1.0f);

		sgSepiaDot1->SetInput(0, sgSepiaColor1);
		sgSepiaDot1->SetInput(1, sgMaterialShadingNode);
		sgSepiaDot2->SetInput(0, sgSepiaColor2);
		sgSepiaDot2->SetInput(1, sgMaterialShadingNode);
		sgSepiaDot3->SetInput(0, sgSepiaColor3);
		sgSepiaDot3->SetInput(1, sgMaterialShadingNode);
		sgSepiaMul1->SetInput(0, sgSepiaDot1);
		sgSepiaMul1->SetInput(1, sgRedFilter);
		sgSepiaMul2->SetInput(0, sgSepiaDot2);
		sgSepiaMul2->SetInput(1, sgGreenFilter);
		sgSepiaMul3->SetInput(0, sgSepiaDot3);
		sgSepiaMul3->SetInput(1, sgBlueFilter);
		sgSepiaAdd1->SetInput(0, sgSepiaMul1);
		sgSepiaAdd1->SetInput(1, sgSepiaMul2);
		sgSepiaAdd2->SetInput(0, sgSepiaAdd1);
		sgSepiaAdd2->SetInput(1, sgSepiaMul3);

		sgMaterial->SetShadingNetwork("Diffuse", sgSepiaAdd2);

	}

	// Start the reduction process. 
	sgReductionProcessor->RunProcessing();

	// Setup and run the diffuse material casting. 
	Simplygon::spColorCaster sgDiffuseCaster = sg->CreateColorCaster();
	sgDiffuseCaster->SetMappingImage( sgReductionProcessor->GetMappingImage() );
	sgDiffuseCaster->SetSourceMaterials( sgScene->GetMaterialTable() );
	sgDiffuseCaster->SetSourceTextures( sgScene->GetTextureTable() );
	sgDiffuseCaster->SetOutputFilePath( "DiffuseTexture" );

	Simplygon::spColorCasterSettings sgDiffuseCasterSettings = sgDiffuseCaster->GetColorCasterSettings();
	sgDiffuseCasterSettings->SetMaterialChannel( "Diffuse" );
	sgDiffuseCasterSettings->SetOutputImageFileFormat( Simplygon::EImageOutputFormat::PNG );

	sgDiffuseCaster->RunProcessing();
	std::string diffuseTextureFilePath = sgDiffuseCaster->GetOutputFilePath();

	// Update scene with new casted texture. 
	Simplygon::spMaterialTable sgMaterialTable = sg->CreateMaterialTable();
	Simplygon::spTextureTable sgTextureTable = sg->CreateTextureTable();
	Simplygon::spMaterial sgMaterial = sg->CreateMaterial();
	Simplygon::spTexture sgDiffuseTexture = sg->CreateTexture();
	sgDiffuseTexture->SetName( "Diffuse" );
	sgDiffuseTexture->SetFilePath( diffuseTextureFilePath.c_str() );
	sgTextureTable->AddTexture( sgDiffuseTexture );

	Simplygon::spShadingTextureNode sgDiffuseTextureShadingNode = sg->CreateShadingTextureNode();
	sgDiffuseTextureShadingNode->SetTexCoordLevel( 0 );
	sgDiffuseTextureShadingNode->SetTextureName( "Diffuse" );

	sgMaterial->AddMaterialChannel( "Diffuse" );
	sgMaterial->SetShadingNetwork( "Diffuse", sgDiffuseTextureShadingNode );

	sgMaterialTable->AddMaterial( sgMaterial );

	sgScene->GetTextureTable()->Clear();
	sgScene->GetMaterialTable()->Clear();
	sgScene->GetTextureTable()->Copy(sgTextureTable);
	sgScene->GetMaterialTable()->Copy(sgMaterialTable);

	Simplygon::spSceneExporter  sgSceneExporter = sg->CreateSceneExporter();
	sgSceneExporter->SetScene(sgScene);
	sgSceneExporter->SetExportFilePath( "ReductionOutput.fbx" );
	if(!sgSceneExporter->RunExport())
		throw std::exception("Failed to save ReductionOutput.fbx.");

}

void main()
{
	Simplygon::ISimplygon* sg = NULL;
	Simplygon::EErrorCodes initval = Simplygon::Initialize( &sg );
	if( initval != Simplygon::EErrorCodes::NoError )
	{
		return;
	}

	RunReductionWithShadingNetworks(sg);

	Simplygon::Deinitialize(sg);
}

// Copyright (c) Microsoft Corporation. 
// Licensed under the MIT license. 

using System;
using System.IO;
using System.Threading.Tasks;

public class Program
{
    static void RunReductionWithShadingNetworks(Simplygon.ISimplygon sg)
    {
        using (Simplygon.spSceneImporter sgSceneImporter = sg.CreateSceneImporter())
        {
            sgSceneImporter.SetImportFilePath( "../Assets/SimplygonMan/SimplygonMan.obj" );
            if(!sgSceneImporter.RunImport())
                throw new System.Exception("Failed to load SimplygonMan/SimplygonMan.obj.");
            Simplygon.spScene sgScene = sgSceneImporter.GetScene();

            using (Simplygon.spReductionProcessor sgReductionProcessor = sg.CreateReductionProcessor())
            {
                sgReductionProcessor.SetScene( sgScene );

                using (Simplygon.spReductionSettings sgReductionSettings = sgReductionProcessor.GetReductionSettings())
                using (Simplygon.spMappingImageSettings sgMappingImageSettings = sgReductionProcessor.GetMappingImageSettings())
                {
                    // Generates a mapping image which is used after the reduction to cast new materials to the new 
                    // reduced object. 
                    sgMappingImageSettings.SetGenerateMappingImage( true );
                    sgMappingImageSettings.SetApplyNewMaterialIds( true );
                    sgMappingImageSettings.SetGenerateTangents( true );
                    sgMappingImageSettings.SetUseFullRetexturing( true );

                }
                // Inject a sepia filter into the shading network for the diffuse channel for each material in the 
                // scene. 
                int materialCount = (int)sgScene.GetMaterialTable().GetMaterialsCount();
                for (int i = 0; i < materialCount; ++i)
                {
                    Simplygon.spMaterial sgMaterial = sgScene.GetMaterialTable().GetMaterial(i);

                    using (Simplygon.spShadingNode sgMaterialShadingNode = sgMaterial.GetShadingNetwork("Diffuse"))
                    using (Simplygon.spShadingColorNode sgSepiaColor1 = sg.CreateShadingColorNode())
                    using (Simplygon.spShadingColorNode sgSepiaColor2 = sg.CreateShadingColorNode())
                    using (Simplygon.spShadingColorNode sgSepiaColor3 = sg.CreateShadingColorNode())
                    using (Simplygon.spShadingColorNode sgRedFilter = sg.CreateShadingColorNode())
                    using (Simplygon.spShadingColorNode sgGreenFilter = sg.CreateShadingColorNode())
                    using (Simplygon.spShadingColorNode sgBlueFilter = sg.CreateShadingColorNode())
                    using (Simplygon.spShadingDot3Node sgSepiaDot1 = sg.CreateShadingDot3Node())
                    using (Simplygon.spShadingDot3Node sgSepiaDot2 = sg.CreateShadingDot3Node())
                    using (Simplygon.spShadingDot3Node sgSepiaDot3 = sg.CreateShadingDot3Node())
                    using (Simplygon.spShadingMultiplyNode sgSepiaMul1 = sg.CreateShadingMultiplyNode())
                    using (Simplygon.spShadingMultiplyNode sgSepiaMul2 = sg.CreateShadingMultiplyNode())
                    using (Simplygon.spShadingMultiplyNode sgSepiaMul3 = sg.CreateShadingMultiplyNode())
                    using (Simplygon.spShadingAddNode sgSepiaAdd1 = sg.CreateShadingAddNode())
                    using (Simplygon.spShadingAddNode sgSepiaAdd2 = sg.CreateShadingAddNode())
                    {

                        sgSepiaColor1.SetColor(0.393f, 0.769f, 0.189f, 1.0f);
                        sgSepiaColor2.SetColor(0.349f, 0.686f, 0.168f, 1.0f);
                        sgSepiaColor3.SetColor(0.272f, 0.534f, 0.131f, 1.0f);
                        sgRedFilter.SetColor(1.0f, 0.0f, 0.0f, 1.0f);
                        sgGreenFilter.SetColor(0.0f, 1.0f, 0.0f, 1.0f);
                        sgBlueFilter.SetColor(0.0f, 0.0f, 1.0f, 1.0f);

                        sgSepiaDot1.SetInput(0, sgSepiaColor1);
                        sgSepiaDot1.SetInput(1, sgMaterialShadingNode);
                        sgSepiaDot2.SetInput(0, sgSepiaColor2);
                        sgSepiaDot2.SetInput(1, sgMaterialShadingNode);
                        sgSepiaDot3.SetInput(0, sgSepiaColor3);
                        sgSepiaDot3.SetInput(1, sgMaterialShadingNode);
                        sgSepiaMul1.SetInput(0, sgSepiaDot1);
                        sgSepiaMul1.SetInput(1, sgRedFilter);
                        sgSepiaMul2.SetInput(0, sgSepiaDot2);
                        sgSepiaMul2.SetInput(1, sgGreenFilter);
                        sgSepiaMul3.SetInput(0, sgSepiaDot3);
                        sgSepiaMul3.SetInput(1, sgBlueFilter);
                        sgSepiaAdd1.SetInput(0, sgSepiaMul1);
                        sgSepiaAdd1.SetInput(1, sgSepiaMul2);
                        sgSepiaAdd2.SetInput(0, sgSepiaAdd1);
                        sgSepiaAdd2.SetInput(1, sgSepiaMul3);

                        sgMaterial.SetShadingNetwork("Diffuse", sgSepiaAdd2);
                    }

                }

                // Start the reduction process. 
                sgReductionProcessor.RunProcessing();

                // Setup and run the diffuse material casting. 
                string diffuseTextureFilePath;
                using (Simplygon.spColorCaster sgDiffuseCaster = sg.CreateColorCaster())
                {
                    sgDiffuseCaster.SetMappingImage( sgReductionProcessor.GetMappingImage() );
                    sgDiffuseCaster.SetSourceMaterials( sgScene.GetMaterialTable() );
                    sgDiffuseCaster.SetSourceTextures( sgScene.GetTextureTable() );
                    sgDiffuseCaster.SetOutputFilePath( "DiffuseTexture" );

                    using (Simplygon.spColorCasterSettings sgDiffuseCasterSettings = sgDiffuseCaster.GetColorCasterSettings())
                    {
                        sgDiffuseCasterSettings.SetMaterialChannel( "Diffuse" );
                        sgDiffuseCasterSettings.SetOutputImageFileFormat( Simplygon.EImageOutputFormat.PNG );
                    }

                    sgDiffuseCaster.RunProcessing();
                    diffuseTextureFilePath = sgDiffuseCaster.GetOutputFilePath();
                }

                // Update scene with new casted texture. 
                using (Simplygon.spMaterialTable sgMaterialTable = sg.CreateMaterialTable())
                using (Simplygon.spTextureTable sgTextureTable = sg.CreateTextureTable())
                using (Simplygon.spMaterial sgMaterial = sg.CreateMaterial())
                {
                    using(Simplygon.spTexture sgDiffuseTexture = sg.CreateTexture())
                    {
                        sgDiffuseTexture.SetName( "Diffuse" );
                        sgDiffuseTexture.SetFilePath( diffuseTextureFilePath );
                        sgTextureTable.AddTexture( sgDiffuseTexture );
                    }

                    using(Simplygon.spShadingTextureNode sgDiffuseTextureShadingNode = sg.CreateShadingTextureNode())
                    {
                        sgDiffuseTextureShadingNode.SetTexCoordLevel( 0 );
                        sgDiffuseTextureShadingNode.SetTextureName( "Diffuse" );

                        sgMaterial.AddMaterialChannel( "Diffuse" );
                        sgMaterial.SetShadingNetwork( "Diffuse", sgDiffuseTextureShadingNode );
                    }

                    sgMaterialTable.AddMaterial( sgMaterial );

                    sgScene.GetTextureTable().Clear();
                    sgScene.GetMaterialTable().Clear();
                    sgScene.GetTextureTable().Copy(sgTextureTable);
                    sgScene.GetMaterialTable().Copy(sgMaterialTable);
                }

            }
            using (Simplygon.spSceneExporter sgSceneExporter = sg.CreateSceneExporter())
            {
                sgSceneExporter.SetScene(sgScene);
                sgSceneExporter.SetExportFilePath( "ReductionOutput.fbx" );
                if(!sgSceneExporter.RunExport())
                    throw new System.Exception("Failed to save ReductionOutput.fbx.");

            }
        }
    }
    static void Main(string[] args)
    {
        using (var sg = Simplygon.Loader.InitSimplygon(out var errorCode, out var errorMessage))
        {
            if (errorCode != Simplygon.EErrorCodes.NoError)
                return;
            RunReductionWithShadingNetworks(sg);
        }
    }
}

# Copyright (c) Microsoft Corporation. 
# Licensed under the MIT license. 

import math
import os
import sys
import glob
import gc
import threading

from pathlib import Path
from simplygon import simplygon_loader
from simplygon import Simplygon


def RunReductionWithShadingNetworks(sg: Simplygon.ISimplygon):
    sgSceneImporter = sg.CreateSceneImporter()
    sgSceneImporter.SetImportFilePath( '../Assets/SimplygonMan/SimplygonMan.obj' )
    if not sgSceneImporter.RunImport():
        raise Exception('Failed to load SimplygonMan/SimplygonMan.obj.')
    sgScene = sgSceneImporter.GetScene()

    sgReductionProcessor = sg.CreateReductionProcessor()

    sgReductionProcessor.SetScene( sgScene )

    sgReductionSettings = sgReductionProcessor.GetReductionSettings()
    sgMappingImageSettings = sgReductionProcessor.GetMappingImageSettings()

    # Generates a mapping image which is used after the reduction to cast new materials to the new 
    # reduced object. 
    sgMappingImageSettings.SetGenerateMappingImage( True )
    sgMappingImageSettings.SetApplyNewMaterialIds( True )
    sgMappingImageSettings.SetGenerateTangents( True )
    sgMappingImageSettings.SetUseFullRetexturing( True )

    # Inject a sepia filter into the shading network for the diffuse channel for each material in the 
    # scene. 
    materialCount = sgScene.GetMaterialTable().GetMaterialsCount()
    for i in range(0, materialCount):
        sgMaterial = sgScene.GetMaterialTable().GetMaterial(i)

        sgMaterialShadingNode = sgMaterial.GetShadingNetwork("Diffuse")
        sgSepiaColor1 = sg.CreateShadingColorNode()
        sgSepiaColor2 = sg.CreateShadingColorNode()
        sgSepiaColor3 = sg.CreateShadingColorNode()
        sgRedFilter = sg.CreateShadingColorNode()
        sgGreenFilter = sg.CreateShadingColorNode()
        sgBlueFilter = sg.CreateShadingColorNode()
        sgSepiaDot1 = sg.CreateShadingDot3Node()
        sgSepiaDot2 = sg.CreateShadingDot3Node()
        sgSepiaDot3 = sg.CreateShadingDot3Node()
        sgSepiaMul1 = sg.CreateShadingMultiplyNode()
        sgSepiaMul2 = sg.CreateShadingMultiplyNode()
        sgSepiaMul3 = sg.CreateShadingMultiplyNode()
        sgSepiaAdd1 = sg.CreateShadingAddNode()
        sgSepiaAdd2 = sg.CreateShadingAddNode()

        sgSepiaColor1.SetColor(0.393, 0.769, 0.189, 1.0)
        sgSepiaColor2.SetColor(0.349, 0.686, 0.168, 1.0)
        sgSepiaColor3.SetColor(0.272, 0.534, 0.131, 1.0)
        sgRedFilter.SetColor(1.0, 0.0, 0.0, 1.0)
        sgGreenFilter.SetColor(0.0, 1.0, 0.0, 1.0)
        sgBlueFilter.SetColor(0.0, 0.0, 1.0, 1.0)

        sgSepiaDot1.SetInput(0, sgSepiaColor1)
        sgSepiaDot1.SetInput(1, sgMaterialShadingNode)
        sgSepiaDot2.SetInput(0, sgSepiaColor2)
        sgSepiaDot2.SetInput(1, sgMaterialShadingNode)
        sgSepiaDot3.SetInput(0, sgSepiaColor3)
        sgSepiaDot3.SetInput(1, sgMaterialShadingNode)
        sgSepiaMul1.SetInput(0, sgSepiaDot1)
        sgSepiaMul1.SetInput(1, sgRedFilter)
        sgSepiaMul2.SetInput(0, sgSepiaDot2)
        sgSepiaMul2.SetInput(1, sgGreenFilter)
        sgSepiaMul3.SetInput(0, sgSepiaDot3)
        sgSepiaMul3.SetInput(1, sgBlueFilter)
        sgSepiaAdd1.SetInput(0, sgSepiaMul1)
        sgSepiaAdd1.SetInput(1, sgSepiaMul2)
        sgSepiaAdd2.SetInput(0, sgSepiaAdd1)
        sgSepiaAdd2.SetInput(1, sgSepiaMul3)

        sgMaterial.SetShadingNetwork('Diffuse', sgSepiaAdd2)


    # Start the reduction process. 
    sgReductionProcessor.RunProcessing()

    # Setup and run the diffuse material casting. 
    sgDiffuseCaster = sg.CreateColorCaster()
    sgDiffuseCaster.SetMappingImage( sgReductionProcessor.GetMappingImage() )
    sgDiffuseCaster.SetSourceMaterials( sgScene.GetMaterialTable() )
    sgDiffuseCaster.SetSourceTextures( sgScene.GetTextureTable() )
    sgDiffuseCaster.SetOutputFilePath( 'DiffuseTexture' )

    sgDiffuseCasterSettings = sgDiffuseCaster.GetColorCasterSettings()
    sgDiffuseCasterSettings.SetMaterialChannel( 'Diffuse' )
    sgDiffuseCasterSettings.SetOutputImageFileFormat( Simplygon.EImageOutputFormat_PNG )

    sgDiffuseCaster.RunProcessing()
    diffuseTextureFilePath = sgDiffuseCaster.GetOutputFilePath()

    # Update scene with new casted texture. 
    sgMaterialTable = sg.CreateMaterialTable()
    sgTextureTable = sg.CreateTextureTable()
    sgMaterial = sg.CreateMaterial()
    sgDiffuseTexture = sg.CreateTexture()
    sgDiffuseTexture.SetName( 'Diffuse' )
    sgDiffuseTexture.SetFilePath( diffuseTextureFilePath )
    sgTextureTable.AddTexture( sgDiffuseTexture )

    sgDiffuseTextureShadingNode = sg.CreateShadingTextureNode()
    sgDiffuseTextureShadingNode.SetTexCoordLevel( 0 )
    sgDiffuseTextureShadingNode.SetTextureName( 'Diffuse' )

    sgMaterial.AddMaterialChannel( 'Diffuse' )
    sgMaterial.SetShadingNetwork( 'Diffuse', sgDiffuseTextureShadingNode )

    sgMaterialTable.AddMaterial( sgMaterial )

    sgScene.GetTextureTable().Clear()
    sgScene.GetMaterialTable().Clear()
    sgScene.GetTextureTable().Copy(sgTextureTable)
    sgScene.GetMaterialTable().Copy(sgMaterialTable)

    sgSceneExporter = sg.CreateSceneExporter()
    sgSceneExporter.SetScene(sgScene)
    sgSceneExporter.SetExportFilePath( 'ReductionOutput.fbx' )
    if not sgSceneExporter.RunExport():
        raise Exception('Failed to save ReductionOutput.fbx.')


if __name__ == '__main__':
    sg = simplygon_loader.init_simplygon()
    if sg is not None:

        RunReductionWithShadingNetworks(sg)

    sg = None
    gc.collect()