This example shows how to use attribute tessellation in a remeshing processing pipeline, to generate tessellated displacement data. The output is a glTF file with supporting NVidia Micromesh displacement data, as well as a tessellated scene.

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

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


Simplygon::spScene LoadScene(Simplygon::ISimplygon* sg, const char* path)
{
	// Create scene importer 
	Simplygon::spSceneImporter sgSceneImporter = sg->CreateSceneImporter();
	sgSceneImporter->SetImportFilePath(path);
	
	// Run scene importer. 
	auto importResult = sgSceneImporter->Run();
	if (Simplygon::Failed(importResult))
	{
		throw std::exception("Failed to load scene.");
	}
	Simplygon::spScene sgScene = sgSceneImporter->GetScene();
	return sgScene;
}

void SaveScene(Simplygon::ISimplygon* sg, Simplygon::spScene sgScene, const char* path)
{
	// Create scene exporter. 
	Simplygon::spSceneExporter sgSceneExporter = sg->CreateSceneExporter();
	std::string outputScenePath = std::string("output\\") + std::string("AttributeTessellation") + std::string("_") + std::string(path);
	sgSceneExporter->SetExportFilePath(outputScenePath.c_str());
	sgSceneExporter->SetScene(sgScene);
	
	// Run scene exporter. 
	auto exportResult = sgSceneExporter->Run();
	if (Simplygon::Failed(exportResult))
	{
		throw std::exception("Failed to save scene.");
	}
}

void CheckLog(Simplygon::ISimplygon* sg)
{
	// Check if any errors occurred. 
	bool hasErrors = sg->ErrorOccurred();
	if (hasErrors)
	{
		Simplygon::spStringArray errors = sg->CreateStringArray();
		sg->GetErrorMessages(errors);
		auto errorCount = errors->GetItemCount();
		if (errorCount > 0)
		{
			printf("%s\n", "Errors:");
			for (auto errorIndex = 0U; errorIndex < errorCount; ++errorIndex)
			{
				Simplygon::spString errorString = errors->GetItem((int)errorIndex);
				printf("%s\n", errorString.c_str());
			}
			sg->ClearErrorMessages();
		}
	}
	else
	{
		printf("%s\n", "No errors.");
	}
	
	// Check if any warnings occurred. 
	bool hasWarnings = sg->WarningOccurred();
	if (hasWarnings)
	{
		Simplygon::spStringArray warnings = sg->CreateStringArray();
		sg->GetWarningMessages(warnings);
		auto warningCount = warnings->GetItemCount();
		if (warningCount > 0)
		{
			printf("%s\n", "Warnings:");
			for (auto warningIndex = 0U; warningIndex < warningCount; ++warningIndex)
			{
				Simplygon::spString warningString = warnings->GetItem((int)warningIndex);
				printf("%s\n", warningString.c_str());
			}
			sg->ClearWarningMessages();
		}
	}
	else
	{
		printf("%s\n", "No warnings.");
	}
}

void RunRemeshingWithTessellatedAttributes(Simplygon::ISimplygon* sg)
{
	// Load scene to process. 	
	printf("%s\n", "Load scene to process.");
	Simplygon::spScene sgScene = LoadScene(sg, "../../../Assets/SimplygonMan/SimplygonMan.obj");
	
	// Create the remeshing pipeline. 
	Simplygon::spRemeshingPipeline sgRemeshingPipeline = sg->CreateRemeshingPipeline();
	
	// Fetch all the needed settings objects for the processing, including the attribute 
	// tessellation settings, which we will use to set up the attribute tessellation on the processed 
	// mesh. 
	Simplygon::spRemeshingSettings sgRemeshingSettings = sgRemeshingPipeline->GetRemeshingSettings();
	Simplygon::spAttributeTessellationSettings sgAttributeTessellationSettings = sgRemeshingPipeline->GetAttributeTessellationSettings();
	Simplygon::spMappingImageSettings sgMappingImageSettings = sgRemeshingPipeline->GetMappingImageSettings();
	
	// Set on-screen size target for remeshing. 
	sgRemeshingSettings->SetOnScreenSize( 500 );
	sgRemeshingSettings->SetGeometricalAccuracy( 2.0f );
	
	// Get the attribute tessellation settings. The displacement data will be cast into a 
	// tessellated displacement attribute. In this example we use relative area as the density 
	// setting, which means that triangles are tessellated based on the size of the triangle, so that 
	// the tessellated attributes roughly take up the same area. The value is normalized and scale 
	// independent, so the total area of all the subvalues will add up to the normalized value 1. We set 
	// the maximum area per value to 1/1000000, which means that there will be at least 1000000 values 
	// total in the scene, unless we cap the total number of values with MaxTotalValuesCount or 
	// MaxTessellationLevel. 
	sgAttributeTessellationSettings->SetEnableAttributeTessellation( true );
	sgAttributeTessellationSettings->SetAttributeTessellationDensityMode( Simplygon::EAttributeTessellationDensityMode::RelativeArea );
	sgAttributeTessellationSettings->SetMaxAreaOfTessellatedValue( 0.000001f );
	sgAttributeTessellationSettings->SetOnlyAllowOneLevelOfDifference( true );
	sgAttributeTessellationSettings->SetMinTessellationLevel( 0 );
	sgAttributeTessellationSettings->SetMaxTessellationLevel( 5 );
	sgAttributeTessellationSettings->SetMaxTotalValuesCount( 1000000 );
	
	// Set up the process to generate a mapping image which will be used after the reduction to cast new 
	// materials to the new reduced object, and also to cast the displacement data from the original 
	// object into the tessellated attributes of the processed mesh. 
	sgMappingImageSettings->SetGenerateMappingImage( true );
	sgMappingImageSettings->SetGenerateTexCoords( true );
	sgMappingImageSettings->SetApplyNewMaterialIds( true );
	sgMappingImageSettings->SetGenerateTangents( true );
	sgMappingImageSettings->SetUseFullRetexturing( true );
	sgMappingImageSettings->SetTexCoordGeneratorType( Simplygon::ETexcoordGeneratorType::ChartAggregator );
	Simplygon::spMappingImageOutputMaterialSettings sgOutputMaterialSettings = sgMappingImageSettings->GetOutputMaterialSettings(0);
	
	// Set the size of the mapping image in the output material. This will be the output size of the 
	// textures when we do the material casting in the pipeline. 
	sgOutputMaterialSettings->SetTextureWidth( 2048 );
	sgOutputMaterialSettings->SetTextureHeight( 2048 );
	sgOutputMaterialSettings->SetMultisamplingLevel( 2 );
	
	// Add a diffuse texture caster to the pipeline. This will cast the diffuse color (aka base 
	// color/albedo) in the original scene into a texture map in the output scene. 
	Simplygon::spColorCaster sgDiffuseCaster = sg->CreateColorCaster();

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

	sgRemeshingPipeline->AddMaterialCaster( sgDiffuseCaster, 0 );
	
	// Add a normals texture caster to the pipeline. This will cast the normals in the original scene 
	// into a normal map in the output scene. 
	Simplygon::spNormalCaster sgNormalsCaster = sg->CreateNormalCaster();

	Simplygon::spNormalCasterSettings sgNormalsCasterSettings = sgNormalsCaster->GetNormalCasterSettings();
	sgNormalsCasterSettings->SetMaterialChannel( "Normals" );
	sgNormalsCasterSettings->SetGenerateTangentSpaceNormals( true );
	sgNormalsCasterSettings->SetOutputImageFileFormat( Simplygon::EImageOutputFormat::PNG );

	sgRemeshingPipeline->AddMaterialCaster( sgNormalsCaster, 0 );
	
	// Add a displacement caster to the pipeline. This will cast the displacement values, but instead 
	// of casting to a texture, it will cast into the tessellated attributes. 
	Simplygon::spDisplacementCaster sgDisplacementCaster = sg->CreateDisplacementCaster();

	sgDisplacementCaster->SetScene( sgScene );
	Simplygon::spDisplacementCasterSettings sgDisplacementCasterSettings = sgDisplacementCaster->GetDisplacementCasterSettings();
	sgDisplacementCasterSettings->SetMaterialChannel( "Displacement" );
	sgDisplacementCasterSettings->SetDilation( 10 );
	sgDisplacementCasterSettings->SetOutputToTessellatedAttributes( true );
	sgDisplacementCasterSettings->GetAttributeTessellationSamplingSettings()->SetSourceMaterialId( 0 );
	sgDisplacementCasterSettings->GetAttributeTessellationSamplingSettings()->SetAttributeFormat( Simplygon::EAttributeFormat::U16 );
	sgDisplacementCasterSettings->GetAttributeTessellationSamplingSettings()->SetSupersamplingCount( 16 );
	sgDisplacementCasterSettings->GetAttributeTessellationSamplingSettings()->SetBlendOperation( Simplygon::EBlendOperation::Mean );

	sgRemeshingPipeline->AddMaterialCaster( sgDisplacementCaster, 0 );
	
	// Start the remeshing pipeline. 	
	printf("%s\n", "Start the remeshing pipeline.");
	sgRemeshingPipeline->RunScene(sgScene, Simplygon::EPipelineRunMode::RunInThisProcess);
	
	// Save processed scene. 	
	printf("%s\n", "Save processed scene.");
	SaveScene(sg, sgScene, "RemeshedOutput.gltf");
	
	// Create an attribute tessellation tool object. 
	Simplygon::spAttributeTessellation sgAttributeTessellation = sg->CreateAttributeTessellation();
	
	// Generate a tessellated copy of the scene. 	
	printf("%s\n", "Generate a tessellated copy of the scene.");
	Simplygon::spScene sgTessellatedScene = sgAttributeTessellation->NewTessellatedScene(sgScene);
	
	// Save the tessellated copy of the scene. 	
	printf("%s\n", "Save the tessellated copy of the scene.");
	SaveScene(sg, sgTessellatedScene, "RemeshedTessellatedOutput.obj");
	
	// Check log for any warnings or errors. 	
	printf("%s\n", "Check log for any warnings or errors.");
	CheckLog(sg);
}

int main()
{
	Simplygon::ISimplygon* sg = NULL;
	Simplygon::EErrorCodes initval = Simplygon::Initialize( &sg );
	if( initval != Simplygon::EErrorCodes::NoError )
	{
		printf( "Failed to initialize Simplygon: ErrorCode(%d)", (int)initval );
		return int(initval);
	}

	RunRemeshingWithTessellatedAttributes(sg);

	Simplygon::Deinitialize(sg);

	return 0;
}

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

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

public class Program
{
    static Simplygon.spScene LoadScene(Simplygon.ISimplygon sg, string path)
    {
        // Create scene importer 
        using Simplygon.spSceneImporter sgSceneImporter = sg.CreateSceneImporter();
        sgSceneImporter.SetImportFilePath(path);
        
        // Run scene importer. 
        var importResult = sgSceneImporter.Run();
        if (Simplygon.Simplygon.Failed(importResult))
        {
            throw new System.Exception("Failed to load scene.");
        }
        Simplygon.spScene sgScene = sgSceneImporter.GetScene();
        return sgScene;
    }

    static void SaveScene(Simplygon.ISimplygon sg, Simplygon.spScene sgScene, string path)
    {
        // Create scene exporter. 
        using Simplygon.spSceneExporter sgSceneExporter = sg.CreateSceneExporter();
        string outputScenePath = string.Join("", new string[] { "output\\", "AttributeTessellation", "_", path });
        sgSceneExporter.SetExportFilePath(outputScenePath);
        sgSceneExporter.SetScene(sgScene);
        
        // Run scene exporter. 
        var exportResult = sgSceneExporter.Run();
        if (Simplygon.Simplygon.Failed(exportResult))
        {
            throw new System.Exception("Failed to save scene.");
        }
    }

    static void CheckLog(Simplygon.ISimplygon sg)
    {
        // Check if any errors occurred. 
        bool hasErrors = sg.ErrorOccurred();
        if (hasErrors)
        {
            Simplygon.spStringArray errors = sg.CreateStringArray();
            sg.GetErrorMessages(errors);
            var errorCount = errors.GetItemCount();
            if (errorCount > 0)
            {
                Console.WriteLine("Errors:");
                for (uint errorIndex = 0; errorIndex < errorCount; ++errorIndex)
                {
                    string errorString = errors.GetItem((int)errorIndex);
                    Console.WriteLine(errorString);
                }
                sg.ClearErrorMessages();
            }
        }
        else
        {
            Console.WriteLine("No errors.");
        }
        
        // Check if any warnings occurred. 
        bool hasWarnings = sg.WarningOccurred();
        if (hasWarnings)
        {
            Simplygon.spStringArray warnings = sg.CreateStringArray();
            sg.GetWarningMessages(warnings);
            var warningCount = warnings.GetItemCount();
            if (warningCount > 0)
            {
                Console.WriteLine("Warnings:");
                for (uint warningIndex = 0; warningIndex < warningCount; ++warningIndex)
                {
                    string warningString = warnings.GetItem((int)warningIndex);
                    Console.WriteLine(warningString);
                }
                sg.ClearWarningMessages();
            }
        }
        else
        {
            Console.WriteLine("No warnings.");
        }
    }

    static void RunRemeshingWithTessellatedAttributes(Simplygon.ISimplygon sg)
    {
        // Load scene to process.         
        Console.WriteLine("Load scene to process.");
        Simplygon.spScene sgScene = LoadScene(sg, "../../../Assets/SimplygonMan/SimplygonMan.obj");
        
        // Create the remeshing pipeline. 
        using Simplygon.spRemeshingPipeline sgRemeshingPipeline = sg.CreateRemeshingPipeline();
        
        // Fetch all the needed settings objects for the processing, including the attribute 
        // tessellation settings, which we will use to set up the attribute tessellation on the processed 
        // mesh. 
        using Simplygon.spRemeshingSettings sgRemeshingSettings = sgRemeshingPipeline.GetRemeshingSettings();
        using Simplygon.spAttributeTessellationSettings sgAttributeTessellationSettings = sgRemeshingPipeline.GetAttributeTessellationSettings();
        using Simplygon.spMappingImageSettings sgMappingImageSettings = sgRemeshingPipeline.GetMappingImageSettings();
        
        // Set on-screen size target for remeshing. 
        sgRemeshingSettings.SetOnScreenSize( 500 );
        sgRemeshingSettings.SetGeometricalAccuracy( 2.0f );
        
        // Get the attribute tessellation settings. The displacement data will be cast into a 
        // tessellated displacement attribute. In this example we use relative area as the density 
        // setting, which means that triangles are tessellated based on the size of the triangle, so that 
        // the tessellated attributes roughly take up the same area. The value is normalized and scale 
        // independent, so the total area of all the subvalues will add up to the normalized value 1. We set 
        // the maximum area per value to 1/1000000, which means that there will be at least 1000000 values 
        // total in the scene, unless we cap the total number of values with MaxTotalValuesCount or 
        // MaxTessellationLevel. 
        sgAttributeTessellationSettings.SetEnableAttributeTessellation( true );
        sgAttributeTessellationSettings.SetAttributeTessellationDensityMode( Simplygon.EAttributeTessellationDensityMode.RelativeArea );
        sgAttributeTessellationSettings.SetMaxAreaOfTessellatedValue( 0.000001f );
        sgAttributeTessellationSettings.SetOnlyAllowOneLevelOfDifference( true );
        sgAttributeTessellationSettings.SetMinTessellationLevel( 0 );
        sgAttributeTessellationSettings.SetMaxTessellationLevel( 5 );
        sgAttributeTessellationSettings.SetMaxTotalValuesCount( 1000000 );
        
        // Set up the process to generate a mapping image which will be used after the reduction to cast new 
        // materials to the new reduced object, and also to cast the displacement data from the original 
        // object into the tessellated attributes of the processed mesh. 
        sgMappingImageSettings.SetGenerateMappingImage( true );
        sgMappingImageSettings.SetGenerateTexCoords( true );
        sgMappingImageSettings.SetApplyNewMaterialIds( true );
        sgMappingImageSettings.SetGenerateTangents( true );
        sgMappingImageSettings.SetUseFullRetexturing( true );
        sgMappingImageSettings.SetTexCoordGeneratorType( Simplygon.ETexcoordGeneratorType.ChartAggregator );
        using Simplygon.spMappingImageOutputMaterialSettings sgOutputMaterialSettings = sgMappingImageSettings.GetOutputMaterialSettings(0);
        
        // Set the size of the mapping image in the output material. This will be the output size of the 
        // textures when we do the material casting in the pipeline. 
        sgOutputMaterialSettings.SetTextureWidth( 2048 );
        sgOutputMaterialSettings.SetTextureHeight( 2048 );
        sgOutputMaterialSettings.SetMultisamplingLevel( 2 );
        
        // Add a diffuse texture caster to the pipeline. This will cast the diffuse color (aka base 
        // color/albedo) in the original scene into a texture map in the output scene. 
        using Simplygon.spColorCaster sgDiffuseCaster = sg.CreateColorCaster();

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

        sgRemeshingPipeline.AddMaterialCaster( sgDiffuseCaster, 0 );
        
        // Add a normals texture caster to the pipeline. This will cast the normals in the original scene 
        // into a normal map in the output scene. 
        using Simplygon.spNormalCaster sgNormalsCaster = sg.CreateNormalCaster();

        using Simplygon.spNormalCasterSettings sgNormalsCasterSettings = sgNormalsCaster.GetNormalCasterSettings();
        sgNormalsCasterSettings.SetMaterialChannel( "Normals" );
        sgNormalsCasterSettings.SetGenerateTangentSpaceNormals( true );
        sgNormalsCasterSettings.SetOutputImageFileFormat( Simplygon.EImageOutputFormat.PNG );

        sgRemeshingPipeline.AddMaterialCaster( sgNormalsCaster, 0 );
        
        // Add a displacement caster to the pipeline. This will cast the displacement values, but instead 
        // of casting to a texture, it will cast into the tessellated attributes. 
        using Simplygon.spDisplacementCaster sgDisplacementCaster = sg.CreateDisplacementCaster();

        sgDisplacementCaster.SetScene( sgScene );
        using Simplygon.spDisplacementCasterSettings sgDisplacementCasterSettings = sgDisplacementCaster.GetDisplacementCasterSettings();
        sgDisplacementCasterSettings.SetMaterialChannel( "Displacement" );
        sgDisplacementCasterSettings.SetDilation( 10 );
        sgDisplacementCasterSettings.SetOutputToTessellatedAttributes( true );
        sgDisplacementCasterSettings.GetAttributeTessellationSamplingSettings().SetSourceMaterialId( 0 );
        sgDisplacementCasterSettings.GetAttributeTessellationSamplingSettings().SetAttributeFormat( Simplygon.EAttributeFormat.U16 );
        sgDisplacementCasterSettings.GetAttributeTessellationSamplingSettings().SetSupersamplingCount( 16 );
        sgDisplacementCasterSettings.GetAttributeTessellationSamplingSettings().SetBlendOperation( Simplygon.EBlendOperation.Mean );

        sgRemeshingPipeline.AddMaterialCaster( sgDisplacementCaster, 0 );
        
        // Start the remeshing pipeline.         
        Console.WriteLine("Start the remeshing pipeline.");
        sgRemeshingPipeline.RunScene(sgScene, Simplygon.EPipelineRunMode.RunInThisProcess);
        
        // Save processed scene.         
        Console.WriteLine("Save processed scene.");
        SaveScene(sg, sgScene, "RemeshedOutput.gltf");
        
        // Create an attribute tessellation tool object. 
        using Simplygon.spAttributeTessellation sgAttributeTessellation = sg.CreateAttributeTessellation();
        
        // Generate a tessellated copy of the scene.         
        Console.WriteLine("Generate a tessellated copy of the scene.");
        using Simplygon.spScene sgTessellatedScene = sgAttributeTessellation.NewTessellatedScene(sgScene);
        
        // Save the tessellated copy of the scene.         
        Console.WriteLine("Save the tessellated copy of the scene.");
        SaveScene(sg, sgTessellatedScene, "RemeshedTessellatedOutput.obj");
        
        // Check log for any warnings or errors.         
        Console.WriteLine("Check log for any warnings or errors.");
        CheckLog(sg);
    }

    static int Main(string[] args)
    {
        using var sg = Simplygon.Loader.InitSimplygon(out var errorCode, out var errorMessage);
        if (errorCode != Simplygon.EErrorCodes.NoError)
        {
            Console.WriteLine( $"Failed to initialize Simplygon: ErrorCode({(int)errorCode}) {errorMessage}" );
            return (int)errorCode;
        }
        RunRemeshingWithTessellatedAttributes(sg);

        return 0;
    }

}

# 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 simplygon10 import simplygon_loader
from simplygon10 import Simplygon


def LoadScene(sg: Simplygon.ISimplygon, path: str):
    # Create scene importer 
    sgSceneImporter = sg.CreateSceneImporter()
    sgSceneImporter.SetImportFilePath(path)
    
    # Run scene importer. 
    importResult = sgSceneImporter.Run()
    if Simplygon.Failed(importResult):
        raise Exception('Failed to load scene.')
    sgScene = sgSceneImporter.GetScene()
    return sgScene

def SaveScene(sg: Simplygon.ISimplygon, sgScene: Simplygon.spScene, path: str):
    # Create scene exporter. 
    sgSceneExporter = sg.CreateSceneExporter()
    outputScenePath = ''.join(['output\\', 'AttributeTessellation', '_', path])
    sgSceneExporter.SetExportFilePath(outputScenePath)
    sgSceneExporter.SetScene(sgScene)
    
    # Run scene exporter. 
    exportResult = sgSceneExporter.Run()
    if Simplygon.Failed(exportResult):
        raise Exception('Failed to save scene.')

def CheckLog(sg: Simplygon.ISimplygon):
    # Check if any errors occurred. 
    hasErrors = sg.ErrorOccurred()
    if hasErrors:
        errors = sg.CreateStringArray()
        sg.GetErrorMessages(errors)
        errorCount = errors.GetItemCount()
        if errorCount > 0:
            print('Errors:')
            for errorIndex in range(errorCount):
                errorString = errors.GetItem(errorIndex)
                print(errorString)
            sg.ClearErrorMessages()
    else:
        print('No errors.')
    
    # Check if any warnings occurred. 
    hasWarnings = sg.WarningOccurred()
    if hasWarnings:
        warnings = sg.CreateStringArray()
        sg.GetWarningMessages(warnings)
        warningCount = warnings.GetItemCount()
        if warningCount > 0:
            print('Warnings:')
            for warningIndex in range(warningCount):
                warningString = warnings.GetItem(warningIndex)
                print(warningString)
            sg.ClearWarningMessages()
    else:
        print('No warnings.')

def RunRemeshingWithTessellatedAttributes(sg: Simplygon.ISimplygon):
    # Load scene to process.     
    print("Load scene to process.")
    sgScene = LoadScene(sg, '../../../Assets/SimplygonMan/SimplygonMan.obj')
    
    # Create the remeshing pipeline. 
    sgRemeshingPipeline = sg.CreateRemeshingPipeline()
    
    # Fetch all the needed settings objects for the processing, including the attribute 
    # tessellation settings, which we will use to set up the attribute tessellation on the processed 
    # mesh. 
    sgRemeshingSettings = sgRemeshingPipeline.GetRemeshingSettings()
    sgAttributeTessellationSettings = sgRemeshingPipeline.GetAttributeTessellationSettings()
    sgMappingImageSettings = sgRemeshingPipeline.GetMappingImageSettings()
    
    # Set on-screen size target for remeshing. 
    sgRemeshingSettings.SetOnScreenSize( 500 )
    sgRemeshingSettings.SetGeometricalAccuracy( 2.0 )
    
    # Get the attribute tessellation settings. The displacement data will be cast into a 
    # tessellated displacement attribute. In this example we use relative area as the density 
    # setting, which means that triangles are tessellated based on the size of the triangle, so that 
    # the tessellated attributes roughly take up the same area. The value is normalized and scale 
    # independent, so the total area of all the subvalues will add up to the normalized value 1. We set 
    # the maximum area per value to 1/1000000, which means that there will be at least 1000000 values 
    # total in the scene, unless we cap the total number of values with MaxTotalValuesCount or 
    # MaxTessellationLevel. 
    sgAttributeTessellationSettings.SetEnableAttributeTessellation( True )
    sgAttributeTessellationSettings.SetAttributeTessellationDensityMode( Simplygon.EAttributeTessellationDensityMode_RelativeArea )
    sgAttributeTessellationSettings.SetMaxAreaOfTessellatedValue( 0.000001 )
    sgAttributeTessellationSettings.SetOnlyAllowOneLevelOfDifference( True )
    sgAttributeTessellationSettings.SetMinTessellationLevel( 0 )
    sgAttributeTessellationSettings.SetMaxTessellationLevel( 5 )
    sgAttributeTessellationSettings.SetMaxTotalValuesCount( 1000000 )
    
    # Set up the process to generate a mapping image which will be used after the reduction to cast new 
    # materials to the new reduced object, and also to cast the displacement data from the original 
    # object into the tessellated attributes of the processed mesh. 
    sgMappingImageSettings.SetGenerateMappingImage( True )
    sgMappingImageSettings.SetGenerateTexCoords( True )
    sgMappingImageSettings.SetApplyNewMaterialIds( True )
    sgMappingImageSettings.SetGenerateTangents( True )
    sgMappingImageSettings.SetUseFullRetexturing( True )
    sgMappingImageSettings.SetTexCoordGeneratorType( Simplygon.ETexcoordGeneratorType_ChartAggregator )
    sgOutputMaterialSettings = sgMappingImageSettings.GetOutputMaterialSettings(0)
    
    # Set the size of the mapping image in the output material. This will be the output size of the 
    # textures when we do the material casting in the pipeline. 
    sgOutputMaterialSettings.SetTextureWidth( 2048 )
    sgOutputMaterialSettings.SetTextureHeight( 2048 )
    sgOutputMaterialSettings.SetMultisamplingLevel( 2 )
    
    # Add a diffuse texture caster to the pipeline. This will cast the diffuse color (aka base 
    # color/albedo) in the original scene into a texture map in the output scene. 
    sgDiffuseCaster = sg.CreateColorCaster()
    sgDiffuseCasterSettings = sgDiffuseCaster.GetColorCasterSettings()
    sgDiffuseCasterSettings.SetMaterialChannel( "Diffuse" )
    sgDiffuseCasterSettings.SetOutputImageFileFormat( Simplygon.EImageOutputFormat_PNG )

    sgRemeshingPipeline.AddMaterialCaster( sgDiffuseCaster, 0 )
    
    # Add a normals texture caster to the pipeline. This will cast the normals in the original scene 
    # into a normal map in the output scene. 
    sgNormalsCaster = sg.CreateNormalCaster()
    sgNormalsCasterSettings = sgNormalsCaster.GetNormalCasterSettings()
    sgNormalsCasterSettings.SetMaterialChannel( "Normals" )
    sgNormalsCasterSettings.SetGenerateTangentSpaceNormals( True )
    sgNormalsCasterSettings.SetOutputImageFileFormat( Simplygon.EImageOutputFormat_PNG )

    sgRemeshingPipeline.AddMaterialCaster( sgNormalsCaster, 0 )
    
    # Add a displacement caster to the pipeline. This will cast the displacement values, but instead 
    # of casting to a texture, it will cast into the tessellated attributes. 
    sgDisplacementCaster = sg.CreateDisplacementCaster()
    sgDisplacementCaster.SetScene( sgScene )
    sgDisplacementCasterSettings = sgDisplacementCaster.GetDisplacementCasterSettings()
    sgDisplacementCasterSettings.SetMaterialChannel( "Displacement" )
    sgDisplacementCasterSettings.SetDilation( 10 )
    sgDisplacementCasterSettings.SetOutputToTessellatedAttributes( True )
    sgDisplacementCasterSettings.GetAttributeTessellationSamplingSettings().SetSourceMaterialId( 0 )
    sgDisplacementCasterSettings.GetAttributeTessellationSamplingSettings().SetAttributeFormat( Simplygon.EAttributeFormat_U16 )
    sgDisplacementCasterSettings.GetAttributeTessellationSamplingSettings().SetSupersamplingCount( 16 )
    sgDisplacementCasterSettings.GetAttributeTessellationSamplingSettings().SetBlendOperation( Simplygon.EBlendOperation_Mean )

    sgRemeshingPipeline.AddMaterialCaster( sgDisplacementCaster, 0 )
    
    # Start the remeshing pipeline.     
    print("Start the remeshing pipeline.")
    sgRemeshingPipeline.RunScene(sgScene, Simplygon.EPipelineRunMode_RunInThisProcess)
    
    # Save processed scene.     
    print("Save processed scene.")
    SaveScene(sg, sgScene, 'RemeshedOutput.gltf')
    
    # Create an attribute tessellation tool object. 
    sgAttributeTessellation = sg.CreateAttributeTessellation()
    
    # Generate a tessellated copy of the scene.     
    print("Generate a tessellated copy of the scene.")
    sgTessellatedScene = sgAttributeTessellation.NewTessellatedScene(sgScene)
    
    # Save the tessellated copy of the scene.     
    print("Save the tessellated copy of the scene.")
    SaveScene(sg, sgTessellatedScene, 'RemeshedTessellatedOutput.obj')
    
    # Check log for any warnings or errors.     
    print("Check log for any warnings or errors.")
    CheckLog(sg)

if __name__ == '__main__':
        sg = simplygon_loader.init_simplygon()
        if sg is None:
            exit(Simplygon.GetLastInitializationError())

        RunRemeshingWithTessellatedAttributes(sg)

        sg = None
        gc.collect()