# Impostor processor

Impostor processor overview in optimization concepts

# Impostor processor settings

This settings object contains the settings for the impostor generation that is performed by the impostor processor. These settings include parameters for choosing the impostor type and fetching the settings for that impostor type.

Billboard cloud settings, the settings controlling the billboard cloud generation
Flip book settings, the settings controlling the flip book generation
Impostor from single view settings, the settings controlling the single view impostor generation

Following settings objects are available in impostor processor:

Mapping image settings

# Examples

The following examples shows how to use the different impostor types.

# Billboard cloud, mode: Foliage

This example shows how to use the Impostor processor type: Billboard cloud with mode: Foliage.

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

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


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

	// For all materials in the scene set the blend mode to blend (instead of opaque) 
	int materialCount = (int)sgScene->GetMaterialTable()->GetMaterialsCount();
	for (int i = 0; i < materialCount; ++i)
	{
		sgScene->GetMaterialTable()->GetMaterial(i)->SetBlendMode(Simplygon::EMaterialBlendMode::Blend);
	}

	// Create the Impostor processor. 
	Simplygon::spImpostorProcessor sgImpostorProcessor = sg->CreateImpostorProcessor();

	sgImpostorProcessor->SetScene( sgScene );

	Simplygon::spImpostorSettings sgImpostorSettings = sgImpostorProcessor->GetImpostorSettings();

	// Set impostor type to Billboard cloud. 
	sgImpostorSettings->SetImpostorType( Simplygon::EImpostorType::BillboardCloud );

	Simplygon::spBillboardCloudSettings sgBillboardCloudSettings = sgImpostorSettings->GetBillboardCloudSettings();

	// Set billboard cloud mode to Foliage. 
	sgBillboardCloudSettings->SetBillboardMode( Simplygon::EBillboardMode::Foliage );
	sgBillboardCloudSettings->SetBillboardDensity( 0.5f );
	sgBillboardCloudSettings->SetGeometricComplexity( 0.9f );
	sgBillboardCloudSettings->SetMaxPlaneCount( 10 );
	sgBillboardCloudSettings->SetTwoSided( true );

	Simplygon::spFoliageSettings sgFoliageSettings = sgBillboardCloudSettings->GetFoliageSettings();

	// Set the parameters for separating foliage and trunk. 
	sgFoliageSettings->SetSeparateTrunkAndFoliage( true );
	sgFoliageSettings->SetSeparateFoliageTriangleRatio( 0.5f );
	sgFoliageSettings->SetSeparateFoliageTriangleThreshold( 10 );
	sgFoliageSettings->SetSeparateFoliageAreaThreshold( 0.1f );
	sgFoliageSettings->SetSeparateFoliageSizeThreshold( 0.1f );
	sgFoliageSettings->SetTrunkReductionRatio( 0.5f );

	Simplygon::spMappingImageSettings sgMappingImageSettings = sgImpostorProcessor->GetMappingImageSettings();

	sgMappingImageSettings->SetMaximumLayers( 10 );

	Simplygon::spMappingImageOutputMaterialSettings sgOutputMaterialSettings = sgMappingImageSettings->GetOutputMaterialSettings(0);

	// Setting the size of the output material for the mapping image. This will be the output size of the 
	// textures when we do material casting in a later stage. 
	sgOutputMaterialSettings->SetTextureWidth( 1024 );
	sgOutputMaterialSettings->SetTextureHeight( 1024 );
	sgOutputMaterialSettings->SetMultisamplingLevel( 2 );

	// Start the impostor process. 
	sgImpostorProcessor->RunProcessing();

	// Setup and run the diffuse material casting. 
	Simplygon::spColorCaster sgDiffuseCaster = sg->CreateColorCaster();
	sgDiffuseCaster->SetMappingImage( sgImpostorProcessor->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 );
	sgDiffuseCasterSettings->SetBakeOpacityInAlpha( false );
	sgDiffuseCasterSettings->SetOutputPixelFormat( Simplygon::EPixelFormat::R8G8B8 );
	sgDiffuseCasterSettings->SetDilation( 10 );
	sgDiffuseCasterSettings->SetFillMode( Simplygon::EAtlasFillMode::Interpolate );

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

	// Setup and run the specular material casting. 
	Simplygon::spColorCaster sgSpecularCaster = sg->CreateColorCaster();
	sgSpecularCaster->SetMappingImage( sgImpostorProcessor->GetMappingImage() );
	sgSpecularCaster->SetSourceMaterials( sgScene->GetMaterialTable() );
	sgSpecularCaster->SetSourceTextures( sgScene->GetTextureTable() );
	sgSpecularCaster->SetOutputFilePath( "SpecularTexture" );

	Simplygon::spColorCasterSettings sgSpecularCasterSettings = sgSpecularCaster->GetColorCasterSettings();
	sgSpecularCasterSettings->SetMaterialChannel( "Specular" );
	sgSpecularCasterSettings->SetOutputImageFileFormat( Simplygon::EImageOutputFormat::PNG );
	sgSpecularCasterSettings->SetDilation( 10 );
	sgSpecularCasterSettings->SetFillMode( Simplygon::EAtlasFillMode::Interpolate );

	sgSpecularCaster->RunProcessing();
	std::string specularTextureFilePath = sgSpecularCaster->GetOutputFilePath();

	// Setup and run the normals material casting. 
	Simplygon::spNormalCaster sgNormalsCaster = sg->CreateNormalCaster();
	sgNormalsCaster->SetMappingImage( sgImpostorProcessor->GetMappingImage() );
	sgNormalsCaster->SetSourceMaterials( sgScene->GetMaterialTable() );
	sgNormalsCaster->SetSourceTextures( sgScene->GetTextureTable() );
	sgNormalsCaster->SetOutputFilePath( "NormalsTexture" );

	Simplygon::spNormalCasterSettings sgNormalsCasterSettings = sgNormalsCaster->GetNormalCasterSettings();
	sgNormalsCasterSettings->SetMaterialChannel( "Normals" );
	sgNormalsCasterSettings->SetGenerateTangentSpaceNormals( true );
	sgNormalsCasterSettings->SetOutputImageFileFormat( Simplygon::EImageOutputFormat::PNG );
	sgNormalsCasterSettings->SetOutputPixelFormat( Simplygon::EPixelFormat::R8G8B8 );
	sgNormalsCasterSettings->SetDilation( 10 );
	sgNormalsCasterSettings->SetFillMode( Simplygon::EAtlasFillMode::Interpolate );

	sgNormalsCaster->RunProcessing();
	std::string normalsTextureFilePath = sgNormalsCaster->GetOutputFilePath();

	// Setup and run the opacity material casting. Make sure the there is no dilation or fill. 
	Simplygon::spOpacityCaster sgOpacityCaster = sg->CreateOpacityCaster();
	sgOpacityCaster->SetMappingImage( sgImpostorProcessor->GetMappingImage() );
	sgOpacityCaster->SetSourceMaterials( sgScene->GetMaterialTable() );
	sgOpacityCaster->SetSourceTextures( sgScene->GetTextureTable() );
	sgOpacityCaster->SetOutputFilePath( "OpacityTexture" );

	Simplygon::spOpacityCasterSettings sgOpacityCasterSettings = sgOpacityCaster->GetOpacityCasterSettings();
	sgOpacityCasterSettings->SetMaterialChannel( "Opacity" );
	sgOpacityCasterSettings->SetOutputImageFileFormat( Simplygon::EImageOutputFormat::PNG );
	sgOpacityCasterSettings->SetDilation( 0 );
	sgOpacityCasterSettings->SetFillMode( Simplygon::EAtlasFillMode::NoFill );
	sgOpacityCasterSettings->SetOutputPixelFormat( Simplygon::EPixelFormat::R8 );

	sgOpacityCaster->RunProcessing();
	std::string opacityTextureFilePath = sgOpacityCaster->GetOutputFilePath();

	// Update scene with new casted textures. 
	Simplygon::spMaterialTable sgMaterialTable = sgScene->GetMaterialTable();
	Simplygon::spTextureTable sgTextureTable = sgScene->GetTextureTable();
	Simplygon::spMaterial sgMaterial = sgMaterialTable->GetMaterial(sgImpostorProcessor->GetBillboardCloudMaterialId());

	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 );

	Simplygon::spTexture sgSpecularTexture = sg->CreateTexture();
	sgSpecularTexture->SetName( "Specular" );
	sgSpecularTexture->SetFilePath( specularTextureFilePath.c_str() );
	sgTextureTable->AddTexture( sgSpecularTexture );

	Simplygon::spShadingTextureNode sgSpecularTextureShadingNode = sg->CreateShadingTextureNode();
	sgSpecularTextureShadingNode->SetTexCoordLevel( 0 );
	sgSpecularTextureShadingNode->SetTextureName( "Specular" );
	sgMaterial->AddMaterialChannel( "Specular" );
	sgMaterial->SetShadingNetwork( "Specular", sgSpecularTextureShadingNode );

	Simplygon::spTexture sgNormalsTexture = sg->CreateTexture();
	sgNormalsTexture->SetName( "Normals" );
	sgNormalsTexture->SetFilePath( normalsTextureFilePath.c_str() );
	sgTextureTable->AddTexture( sgNormalsTexture );

	Simplygon::spShadingTextureNode sgNormalsTextureShadingNode = sg->CreateShadingTextureNode();
	sgNormalsTextureShadingNode->SetTexCoordLevel( 0 );
	sgNormalsTextureShadingNode->SetTextureName( "Normals" );
	sgMaterial->AddMaterialChannel( "Normals" );
	sgMaterial->SetShadingNetwork( "Normals", sgNormalsTextureShadingNode );

	Simplygon::spTexture sgOpacityTexture = sg->CreateTexture();
	sgOpacityTexture->SetName( "Opacity" );
	sgOpacityTexture->SetFilePath( opacityTextureFilePath.c_str() );
	sgTextureTable->AddTexture( sgOpacityTexture );

	Simplygon::spShadingTextureNode sgOpacityTextureShadingNode = sg->CreateShadingTextureNode();
	sgOpacityTextureShadingNode->SetTexCoordLevel( 0 );
	sgOpacityTextureShadingNode->SetTextureName( "Opacity" );
	sgMaterial->AddMaterialChannel( "Opacity" );
	sgMaterial->SetShadingNetwork( "Opacity", sgOpacityTextureShadingNode );

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

}

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

	RunBillboardCloudFoliage(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 void RunBillboardCloudFoliage(Simplygon.ISimplygon sg)
    {
        using (Simplygon.spSceneImporter sgSceneImporter = sg.CreateSceneImporter())
        {
            sgSceneImporter.SetImportFilePath( "../Assets/Tree/Tree.obj" );
            if(!sgSceneImporter.RunImport())
                throw new System.Exception("Failed to load Tree/Tree.obj.");
            Simplygon.spScene sgScene = sgSceneImporter.GetScene();

            // For all materials in the scene set the blend mode to blend (instead of opaque) 
            int materialCount = (int)sgScene.GetMaterialTable().GetMaterialsCount();
            for (int i = 0; i < materialCount; ++i)
            {
                sgScene.GetMaterialTable().GetMaterial(i).SetBlendMode(Simplygon.EMaterialBlendMode.Blend);
            }

            {
            }
            // Create the Impostor processor. 
            using (Simplygon.spImpostorProcessor sgImpostorProcessor = sg.CreateImpostorProcessor())
            {
                sgImpostorProcessor.SetScene( sgScene );

                using (Simplygon.spImpostorSettings sgImpostorSettings = sgImpostorProcessor.GetImpostorSettings())
                {
                    // Set impostor type to Billboard cloud. 
                    sgImpostorSettings.SetImpostorType( Simplygon.EImpostorType.BillboardCloud );

                    using (Simplygon.spBillboardCloudSettings sgBillboardCloudSettings = sgImpostorSettings.GetBillboardCloudSettings())
                    {
                        // Set billboard cloud mode to Foliage. 
                        sgBillboardCloudSettings.SetBillboardMode( Simplygon.EBillboardMode.Foliage );
                        sgBillboardCloudSettings.SetBillboardDensity( 0.5f );
                        sgBillboardCloudSettings.SetGeometricComplexity( 0.9f );
                        sgBillboardCloudSettings.SetMaxPlaneCount( 10 );
                        sgBillboardCloudSettings.SetTwoSided( true );

                        using (Simplygon.spFoliageSettings sgFoliageSettings = sgBillboardCloudSettings.GetFoliageSettings())
                        {
                            // Set the parameters for separating foliage and trunk. 
                            sgFoliageSettings.SetSeparateTrunkAndFoliage( true );
                            sgFoliageSettings.SetSeparateFoliageTriangleRatio( 0.5f );
                            sgFoliageSettings.SetSeparateFoliageTriangleThreshold( 10 );
                            sgFoliageSettings.SetSeparateFoliageAreaThreshold( 0.1f );
                            sgFoliageSettings.SetSeparateFoliageSizeThreshold( 0.1f );
                            sgFoliageSettings.SetTrunkReductionRatio( 0.5f );

                        }
                    }
                    using (Simplygon.spMappingImageSettings sgMappingImageSettings = sgImpostorProcessor.GetMappingImageSettings())
                    {
                        sgMappingImageSettings.SetMaximumLayers( 10 );

                        using (Simplygon.spMappingImageOutputMaterialSettings sgOutputMaterialSettings = sgMappingImageSettings.GetOutputMaterialSettings(0))
                        {
                            // Setting the size of the output material for the mapping image. This will be the output size of the 
                            // textures when we do material casting in a later stage. 
                            sgOutputMaterialSettings.SetTextureWidth( 1024 );
                            sgOutputMaterialSettings.SetTextureHeight( 1024 );
                            sgOutputMaterialSettings.SetMultisamplingLevel( 2 );

                        }
                    }
                }
                // Start the impostor process. 
                sgImpostorProcessor.RunProcessing();

                // Setup and run the diffuse material casting. 
                string diffuseTextureFilePath;
                using (Simplygon.spColorCaster sgDiffuseCaster = sg.CreateColorCaster())
                {
                    sgDiffuseCaster.SetMappingImage( sgImpostorProcessor.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 );
                        sgDiffuseCasterSettings.SetBakeOpacityInAlpha( false );
                        sgDiffuseCasterSettings.SetOutputPixelFormat( Simplygon.EPixelFormat.R8G8B8 );
                        sgDiffuseCasterSettings.SetDilation( 10 );
                        sgDiffuseCasterSettings.SetFillMode( Simplygon.EAtlasFillMode.Interpolate );
                    }

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

                // Setup and run the specular material casting. 
                string specularTextureFilePath;
                using (Simplygon.spColorCaster sgSpecularCaster = sg.CreateColorCaster())
                {
                    sgSpecularCaster.SetMappingImage( sgImpostorProcessor.GetMappingImage() );
                    sgSpecularCaster.SetSourceMaterials( sgScene.GetMaterialTable() );
                    sgSpecularCaster.SetSourceTextures( sgScene.GetTextureTable() );
                    sgSpecularCaster.SetOutputFilePath( "SpecularTexture" );

                    using (Simplygon.spColorCasterSettings sgSpecularCasterSettings = sgSpecularCaster.GetColorCasterSettings())
                    {
                        sgSpecularCasterSettings.SetMaterialChannel( "Specular" );
                        sgSpecularCasterSettings.SetOutputImageFileFormat( Simplygon.EImageOutputFormat.PNG );
                        sgSpecularCasterSettings.SetDilation( 10 );
                        sgSpecularCasterSettings.SetFillMode( Simplygon.EAtlasFillMode.Interpolate );
                    }

                    sgSpecularCaster.RunProcessing();
                    specularTextureFilePath = sgSpecularCaster.GetOutputFilePath();
                }

                // Setup and run the normals material casting. 
                string normalsTextureFilePath;
                using (Simplygon.spNormalCaster sgNormalsCaster = sg.CreateNormalCaster())
                {
                    sgNormalsCaster.SetMappingImage( sgImpostorProcessor.GetMappingImage() );
                    sgNormalsCaster.SetSourceMaterials( sgScene.GetMaterialTable() );
                    sgNormalsCaster.SetSourceTextures( sgScene.GetTextureTable() );
                    sgNormalsCaster.SetOutputFilePath( "NormalsTexture" );

                    using (Simplygon.spNormalCasterSettings sgNormalsCasterSettings = sgNormalsCaster.GetNormalCasterSettings())
                    {
                        sgNormalsCasterSettings.SetMaterialChannel( "Normals" );
                        sgNormalsCasterSettings.SetGenerateTangentSpaceNormals( true );
                        sgNormalsCasterSettings.SetOutputImageFileFormat( Simplygon.EImageOutputFormat.PNG );
                        sgNormalsCasterSettings.SetOutputPixelFormat( Simplygon.EPixelFormat.R8G8B8 );
                        sgNormalsCasterSettings.SetDilation( 10 );
                        sgNormalsCasterSettings.SetFillMode( Simplygon.EAtlasFillMode.Interpolate );
                    }

                    sgNormalsCaster.RunProcessing();
                    normalsTextureFilePath = sgNormalsCaster.GetOutputFilePath();
                }

                // Setup and run the opacity material casting. Make sure the there is no dilation or fill. 
                string opacityTextureFilePath;
                using (Simplygon.spOpacityCaster sgOpacityCaster = sg.CreateOpacityCaster())
                {
                    sgOpacityCaster.SetMappingImage( sgImpostorProcessor.GetMappingImage() );
                    sgOpacityCaster.SetSourceMaterials( sgScene.GetMaterialTable() );
                    sgOpacityCaster.SetSourceTextures( sgScene.GetTextureTable() );
                    sgOpacityCaster.SetOutputFilePath( "OpacityTexture" );

                    using (Simplygon.spOpacityCasterSettings sgOpacityCasterSettings = sgOpacityCaster.GetOpacityCasterSettings())
                    {
                        sgOpacityCasterSettings.SetMaterialChannel( "Opacity" );
                        sgOpacityCasterSettings.SetOutputImageFileFormat( Simplygon.EImageOutputFormat.PNG );
                        sgOpacityCasterSettings.SetDilation( 0 );
                        sgOpacityCasterSettings.SetFillMode( Simplygon.EAtlasFillMode.NoFill );
                        sgOpacityCasterSettings.SetOutputPixelFormat( Simplygon.EPixelFormat.R8 );
                    }

                    sgOpacityCaster.RunProcessing();
                    opacityTextureFilePath = sgOpacityCaster.GetOutputFilePath();
                }

                // Update scene with new casted textures. 
                using (Simplygon.spMaterialTable sgMaterialTable = sgScene.GetMaterialTable())
                using (Simplygon.spTextureTable sgTextureTable = sgScene.GetTextureTable())
                using (Simplygon.spMaterial sgMaterial = sgMaterialTable.GetMaterial(sgImpostorProcessor.GetBillboardCloudMaterialId()))
                {

                    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 );
                    }

                    using(Simplygon.spTexture sgSpecularTexture = sg.CreateTexture())
                    {
                        sgSpecularTexture.SetName( "Specular" );
                        sgSpecularTexture.SetFilePath( specularTextureFilePath );
                        sgTextureTable.AddTexture( sgSpecularTexture );
                    }

                    using(Simplygon.spShadingTextureNode sgSpecularTextureShadingNode = sg.CreateShadingTextureNode())
                    {
                        sgSpecularTextureShadingNode.SetTexCoordLevel( 0 );
                        sgSpecularTextureShadingNode.SetTextureName( "Specular" );

                        sgMaterial.AddMaterialChannel( "Specular" );
                        sgMaterial.SetShadingNetwork( "Specular", sgSpecularTextureShadingNode );
                    }

                    using(Simplygon.spTexture sgNormalsTexture = sg.CreateTexture())
                    {
                        sgNormalsTexture.SetName( "Normals" );
                        sgNormalsTexture.SetFilePath( normalsTextureFilePath );
                        sgTextureTable.AddTexture( sgNormalsTexture );
                    }

                    using(Simplygon.spShadingTextureNode sgNormalsTextureShadingNode = sg.CreateShadingTextureNode())
                    {
                        sgNormalsTextureShadingNode.SetTexCoordLevel( 0 );
                        sgNormalsTextureShadingNode.SetTextureName( "Normals" );

                        sgMaterial.AddMaterialChannel( "Normals" );
                        sgMaterial.SetShadingNetwork( "Normals", sgNormalsTextureShadingNode );
                    }

                    using(Simplygon.spTexture sgOpacityTexture = sg.CreateTexture())
                    {
                        sgOpacityTexture.SetName( "Opacity" );
                        sgOpacityTexture.SetFilePath( opacityTextureFilePath );
                        sgTextureTable.AddTexture( sgOpacityTexture );
                    }

                    using(Simplygon.spShadingTextureNode sgOpacityTextureShadingNode = sg.CreateShadingTextureNode())
                    {
                        sgOpacityTextureShadingNode.SetTexCoordLevel( 0 );
                        sgOpacityTextureShadingNode.SetTextureName( "Opacity" );

                        sgMaterial.AddMaterialChannel( "Opacity" );
                        sgMaterial.SetShadingNetwork( "Opacity", sgOpacityTextureShadingNode );
                    }

                }

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

            }
        }
    }
    static int Main(string[] args)
    {
        using (var sg = Simplygon.Loader.InitSimplygon(out var errorCode, out var errorMessage))
        {
            if (errorCode != Simplygon.EErrorCodes.NoError)
                return (int)errorCode;
            RunBillboardCloudFoliage(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 simplygon import simplygon_loader
from simplygon import Simplygon


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

    # For all materials in the scene set the blend mode to blend (instead of opaque) 
    materialCount = sgScene.GetMaterialTable().GetMaterialsCount()
    for i in range(0, materialCount):
        sgScene.GetMaterialTable().GetMaterial(i).SetBlendMode(Simplygon.EMaterialBlendMode_Blend)

    # Create the Impostor processor. 
    sgImpostorProcessor = sg.CreateImpostorProcessor()

    sgImpostorProcessor.SetScene( sgScene )

    sgImpostorSettings = sgImpostorProcessor.GetImpostorSettings()

    # Set impostor type to Billboard cloud. 
    sgImpostorSettings.SetImpostorType( Simplygon.EImpostorType_BillboardCloud )

    sgBillboardCloudSettings = sgImpostorSettings.GetBillboardCloudSettings()

    # Set billboard cloud mode to Foliage. 
    sgBillboardCloudSettings.SetBillboardMode( Simplygon.EBillboardMode_Foliage )
    sgBillboardCloudSettings.SetBillboardDensity( 0.5 )
    sgBillboardCloudSettings.SetGeometricComplexity( 0.9 )
    sgBillboardCloudSettings.SetMaxPlaneCount( 10 )
    sgBillboardCloudSettings.SetTwoSided( True )

    sgFoliageSettings = sgBillboardCloudSettings.GetFoliageSettings()

    # Set the parameters for separating foliage and trunk. 
    sgFoliageSettings.SetSeparateTrunkAndFoliage( True )
    sgFoliageSettings.SetSeparateFoliageTriangleRatio( 0.5 )
    sgFoliageSettings.SetSeparateFoliageTriangleThreshold( 10 )
    sgFoliageSettings.SetSeparateFoliageAreaThreshold( 0.1 )
    sgFoliageSettings.SetSeparateFoliageSizeThreshold( 0.1 )
    sgFoliageSettings.SetTrunkReductionRatio( 0.5 )

    sgMappingImageSettings = sgImpostorProcessor.GetMappingImageSettings()

    sgMappingImageSettings.SetMaximumLayers( 10 )

    sgOutputMaterialSettings = sgMappingImageSettings.GetOutputMaterialSettings(0)

    # Setting the size of the output material for the mapping image. This will be the output size of the 
    # textures when we do material casting in a later stage. 
    sgOutputMaterialSettings.SetTextureWidth( 1024 )
    sgOutputMaterialSettings.SetTextureHeight( 1024 )
    sgOutputMaterialSettings.SetMultisamplingLevel( 2 )

    # Start the impostor process. 
    sgImpostorProcessor.RunProcessing()

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

    sgDiffuseCasterSettings = sgDiffuseCaster.GetColorCasterSettings()
    sgDiffuseCasterSettings.SetMaterialChannel( 'Diffuse' )
    sgDiffuseCasterSettings.SetOutputImageFileFormat( Simplygon.EImageOutputFormat_PNG )
    sgDiffuseCasterSettings.SetBakeOpacityInAlpha( False )
    sgDiffuseCasterSettings.SetOutputPixelFormat( Simplygon.EPixelFormat_R8G8B8 )
    sgDiffuseCasterSettings.SetDilation( 10 )
    sgDiffuseCasterSettings.SetFillMode( Simplygon.EAtlasFillMode_Interpolate )

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

    # Setup and run the specular material casting. 
    sgSpecularCaster = sg.CreateColorCaster()
    sgSpecularCaster.SetMappingImage( sgImpostorProcessor.GetMappingImage() )
    sgSpecularCaster.SetSourceMaterials( sgScene.GetMaterialTable() )
    sgSpecularCaster.SetSourceTextures( sgScene.GetTextureTable() )
    sgSpecularCaster.SetOutputFilePath( 'SpecularTexture' )

    sgSpecularCasterSettings = sgSpecularCaster.GetColorCasterSettings()
    sgSpecularCasterSettings.SetMaterialChannel( 'Specular' )
    sgSpecularCasterSettings.SetOutputImageFileFormat( Simplygon.EImageOutputFormat_PNG )
    sgSpecularCasterSettings.SetDilation( 10 )
    sgSpecularCasterSettings.SetFillMode( Simplygon.EAtlasFillMode_Interpolate )

    sgSpecularCaster.RunProcessing()
    specularTextureFilePath = sgSpecularCaster.GetOutputFilePath()

    # Setup and run the normals material casting. 
    sgNormalsCaster = sg.CreateNormalCaster()
    sgNormalsCaster.SetMappingImage( sgImpostorProcessor.GetMappingImage() )
    sgNormalsCaster.SetSourceMaterials( sgScene.GetMaterialTable() )
    sgNormalsCaster.SetSourceTextures( sgScene.GetTextureTable() )
    sgNormalsCaster.SetOutputFilePath( 'NormalsTexture' )

    sgNormalsCasterSettings = sgNormalsCaster.GetNormalCasterSettings()
    sgNormalsCasterSettings.SetMaterialChannel( 'Normals' )
    sgNormalsCasterSettings.SetGenerateTangentSpaceNormals( True )
    sgNormalsCasterSettings.SetOutputImageFileFormat( Simplygon.EImageOutputFormat_PNG )
    sgNormalsCasterSettings.SetOutputPixelFormat( Simplygon.EPixelFormat_R8G8B8 )
    sgNormalsCasterSettings.SetDilation( 10 )
    sgNormalsCasterSettings.SetFillMode( Simplygon.EAtlasFillMode_Interpolate )

    sgNormalsCaster.RunProcessing()
    normalsTextureFilePath = sgNormalsCaster.GetOutputFilePath()

    # Setup and run the opacity material casting. Make sure the there is no dilation or fill. 
    sgOpacityCaster = sg.CreateOpacityCaster()
    sgOpacityCaster.SetMappingImage( sgImpostorProcessor.GetMappingImage() )
    sgOpacityCaster.SetSourceMaterials( sgScene.GetMaterialTable() )
    sgOpacityCaster.SetSourceTextures( sgScene.GetTextureTable() )
    sgOpacityCaster.SetOutputFilePath( 'OpacityTexture' )

    sgOpacityCasterSettings = sgOpacityCaster.GetOpacityCasterSettings()
    sgOpacityCasterSettings.SetMaterialChannel( 'Opacity' )
    sgOpacityCasterSettings.SetOutputImageFileFormat( Simplygon.EImageOutputFormat_PNG )
    sgOpacityCasterSettings.SetDilation( 0 )
    sgOpacityCasterSettings.SetFillMode( Simplygon.EAtlasFillMode_NoFill )
    sgOpacityCasterSettings.SetOutputPixelFormat( Simplygon.EPixelFormat_R8 )

    sgOpacityCaster.RunProcessing()
    opacityTextureFilePath = sgOpacityCaster.GetOutputFilePath()

    # Update scene with new casted textures. 
    sgMaterialTable = sgScene.GetMaterialTable()
    sgTextureTable = sgScene.GetTextureTable()
    sgMaterial = sgMaterialTable.GetMaterial(sgImpostorProcessor.GetBillboardCloudMaterialId())

    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 )

    sgSpecularTexture = sg.CreateTexture()
    sgSpecularTexture.SetName( 'Specular' )
    sgSpecularTexture.SetFilePath( specularTextureFilePath )
    sgTextureTable.AddTexture( sgSpecularTexture )

    sgSpecularTextureShadingNode = sg.CreateShadingTextureNode()
    sgSpecularTextureShadingNode.SetTexCoordLevel( 0 )
    sgSpecularTextureShadingNode.SetTextureName( 'Specular' )

    sgMaterial.AddMaterialChannel( 'Specular' )
    sgMaterial.SetShadingNetwork( 'Specular', sgSpecularTextureShadingNode )

    sgNormalsTexture = sg.CreateTexture()
    sgNormalsTexture.SetName( 'Normals' )
    sgNormalsTexture.SetFilePath( normalsTextureFilePath )
    sgTextureTable.AddTexture( sgNormalsTexture )

    sgNormalsTextureShadingNode = sg.CreateShadingTextureNode()
    sgNormalsTextureShadingNode.SetTexCoordLevel( 0 )
    sgNormalsTextureShadingNode.SetTextureName( 'Normals' )

    sgMaterial.AddMaterialChannel( 'Normals' )
    sgMaterial.SetShadingNetwork( 'Normals', sgNormalsTextureShadingNode )

    sgOpacityTexture = sg.CreateTexture()
    sgOpacityTexture.SetName( 'Opacity' )
    sgOpacityTexture.SetFilePath( opacityTextureFilePath )
    sgTextureTable.AddTexture( sgOpacityTexture )

    sgOpacityTextureShadingNode = sg.CreateShadingTextureNode()
    sgOpacityTextureShadingNode.SetTexCoordLevel( 0 )
    sgOpacityTextureShadingNode.SetTextureName( 'Opacity' )

    sgMaterial.AddMaterialChannel( 'Opacity' )
    sgMaterial.SetShadingNetwork( 'Opacity', sgOpacityTextureShadingNode )

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


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

    RunBillboardCloudFoliage(sg)

    sg = None
    gc.collect()

# Billboard cloud, mode: Outer shell

This example shows how to use the Impostor processor type: Billboard cloud with mode: OuterShell.

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

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


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

	// For all materials in the scene set the blend mode to blend (instead of opaque) 
	int materialCount = (int)sgScene->GetMaterialTable()->GetMaterialsCount();
	for (int i = 0; i < materialCount; ++i)
	{
		sgScene->GetMaterialTable()->GetMaterial(i)->SetBlendMode(Simplygon::EMaterialBlendMode::Blend);
	}

	// Create the Impostor processor. 
	Simplygon::spImpostorProcessor sgImpostorProcessor = sg->CreateImpostorProcessor();

	sgImpostorProcessor->SetScene( sgScene );

	Simplygon::spImpostorSettings sgImpostorSettings = sgImpostorProcessor->GetImpostorSettings();

	// Set impostor type to Billboard cloud. 
	sgImpostorSettings->SetImpostorType( Simplygon::EImpostorType::BillboardCloud );

	Simplygon::spBillboardCloudSettings sgBillboardCloudSettings = sgImpostorSettings->GetBillboardCloudSettings();

	// Set billboard cloud mode to OuterShell. 
	sgBillboardCloudSettings->SetBillboardMode( Simplygon::EBillboardMode::OuterShell );
	sgBillboardCloudSettings->SetBillboardDensity( 0.5f );
	sgBillboardCloudSettings->SetGeometricComplexity( 0.9f );
	sgBillboardCloudSettings->SetMaxPlaneCount( 20 );
	sgBillboardCloudSettings->SetTwoSided( false );

	Simplygon::spMappingImageSettings sgMappingImageSettings = sgImpostorProcessor->GetMappingImageSettings();

	Simplygon::spMappingImageOutputMaterialSettings sgOutputMaterialSettings = sgMappingImageSettings->GetOutputMaterialSettings(0);

	// Setting the size of the output material for the mapping image. This will be the output size of the 
	// textures when we do material casting in a later stage. 
	sgOutputMaterialSettings->SetTextureWidth( 1024 );
	sgOutputMaterialSettings->SetTextureHeight( 1024 );
	sgOutputMaterialSettings->SetMultisamplingLevel( 2 );

	// Start the impostor process. 
	sgImpostorProcessor->RunProcessing();

	// Setup and run the diffuse material casting. 
	Simplygon::spColorCaster sgDiffuseCaster = sg->CreateColorCaster();
	sgDiffuseCaster->SetMappingImage( sgImpostorProcessor->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 );
	sgDiffuseCasterSettings->SetBakeOpacityInAlpha( false );
	sgDiffuseCasterSettings->SetOutputPixelFormat( Simplygon::EPixelFormat::R8G8B8 );
	sgDiffuseCasterSettings->SetDilation( 10 );
	sgDiffuseCasterSettings->SetFillMode( Simplygon::EAtlasFillMode::Interpolate );

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

	// Setup and run the specular material casting. 
	Simplygon::spColorCaster sgSpecularCaster = sg->CreateColorCaster();
	sgSpecularCaster->SetMappingImage( sgImpostorProcessor->GetMappingImage() );
	sgSpecularCaster->SetSourceMaterials( sgScene->GetMaterialTable() );
	sgSpecularCaster->SetSourceTextures( sgScene->GetTextureTable() );
	sgSpecularCaster->SetOutputFilePath( "SpecularTexture" );

	Simplygon::spColorCasterSettings sgSpecularCasterSettings = sgSpecularCaster->GetColorCasterSettings();
	sgSpecularCasterSettings->SetMaterialChannel( "Specular" );
	sgSpecularCasterSettings->SetOutputImageFileFormat( Simplygon::EImageOutputFormat::PNG );
	sgSpecularCasterSettings->SetDilation( 10 );
	sgSpecularCasterSettings->SetFillMode( Simplygon::EAtlasFillMode::Interpolate );

	sgSpecularCaster->RunProcessing();
	std::string specularTextureFilePath = sgSpecularCaster->GetOutputFilePath();

	// Setup and run the normals material casting. 
	Simplygon::spNormalCaster sgNormalsCaster = sg->CreateNormalCaster();
	sgNormalsCaster->SetMappingImage( sgImpostorProcessor->GetMappingImage() );
	sgNormalsCaster->SetSourceMaterials( sgScene->GetMaterialTable() );
	sgNormalsCaster->SetSourceTextures( sgScene->GetTextureTable() );
	sgNormalsCaster->SetOutputFilePath( "NormalsTexture" );

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

	sgNormalsCaster->RunProcessing();
	std::string normalsTextureFilePath = sgNormalsCaster->GetOutputFilePath();

	// Setup and run the opacity material casting. Make sure the there is no dilation or fill. 
	Simplygon::spOpacityCaster sgOpacityCaster = sg->CreateOpacityCaster();
	sgOpacityCaster->SetMappingImage( sgImpostorProcessor->GetMappingImage() );
	sgOpacityCaster->SetSourceMaterials( sgScene->GetMaterialTable() );
	sgOpacityCaster->SetSourceTextures( sgScene->GetTextureTable() );
	sgOpacityCaster->SetOutputFilePath( "OpacityTexture" );

	Simplygon::spOpacityCasterSettings sgOpacityCasterSettings = sgOpacityCaster->GetOpacityCasterSettings();
	sgOpacityCasterSettings->SetMaterialChannel( "Opacity" );
	sgOpacityCasterSettings->SetOutputImageFileFormat( Simplygon::EImageOutputFormat::PNG );
	sgOpacityCasterSettings->SetDilation( 0 );
	sgOpacityCasterSettings->SetFillMode( Simplygon::EAtlasFillMode::NoFill );
	sgOpacityCasterSettings->SetOutputPixelFormat( Simplygon::EPixelFormat::R8 );

	sgOpacityCaster->RunProcessing();
	std::string opacityTextureFilePath = sgOpacityCaster->GetOutputFilePath();

	// Update scene with new casted textures. 
	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 );
	Simplygon::spTexture sgSpecularTexture = sg->CreateTexture();
	sgSpecularTexture->SetName( "Specular" );
	sgSpecularTexture->SetFilePath( specularTextureFilePath.c_str() );
	sgTextureTable->AddTexture( sgSpecularTexture );

	Simplygon::spShadingTextureNode sgSpecularTextureShadingNode = sg->CreateShadingTextureNode();
	sgSpecularTextureShadingNode->SetTexCoordLevel( 0 );
	sgSpecularTextureShadingNode->SetTextureName( "Specular" );

	sgMaterial->AddMaterialChannel( "Specular" );
	sgMaterial->SetShadingNetwork( "Specular", sgSpecularTextureShadingNode );
	Simplygon::spTexture sgNormalsTexture = sg->CreateTexture();
	sgNormalsTexture->SetName( "Normals" );
	sgNormalsTexture->SetFilePath( normalsTextureFilePath.c_str() );
	sgTextureTable->AddTexture( sgNormalsTexture );

	Simplygon::spShadingTextureNode sgNormalsTextureShadingNode = sg->CreateShadingTextureNode();
	sgNormalsTextureShadingNode->SetTexCoordLevel( 0 );
	sgNormalsTextureShadingNode->SetTextureName( "Normals" );

	sgMaterial->AddMaterialChannel( "Normals" );
	sgMaterial->SetShadingNetwork( "Normals", sgNormalsTextureShadingNode );
	Simplygon::spTexture sgOpacityTexture = sg->CreateTexture();
	sgOpacityTexture->SetName( "Opacity" );
	sgOpacityTexture->SetFilePath( opacityTextureFilePath.c_str() );
	sgTextureTable->AddTexture( sgOpacityTexture );

	Simplygon::spShadingTextureNode sgOpacityTextureShadingNode = sg->CreateShadingTextureNode();
	sgOpacityTextureShadingNode->SetTexCoordLevel( 0 );
	sgOpacityTextureShadingNode->SetTextureName( "Opacity" );

	sgMaterial->AddMaterialChannel( "Opacity" );
	sgMaterial->SetShadingNetwork( "Opacity", sgOpacityTextureShadingNode );

	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( "OuterShellOutput.obj" );
	if(!sgSceneExporter->RunExport())
		throw std::exception("Failed to save OuterShellOutput.obj.");

}

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

	RunBillboardCloudOuterShell(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 void RunBillboardCloudOuterShell(Simplygon.ISimplygon sg)
    {
        using (Simplygon.spSceneImporter sgSceneImporter = sg.CreateSceneImporter())
        {
            sgSceneImporter.SetImportFilePath( "../Assets/Cages/Cages.obj" );
            if(!sgSceneImporter.RunImport())
                throw new System.Exception("Failed to load Cages/Cages.obj.");
            Simplygon.spScene sgScene = sgSceneImporter.GetScene();

            // For all materials in the scene set the blend mode to blend (instead of opaque) 
            int materialCount = (int)sgScene.GetMaterialTable().GetMaterialsCount();
            for (int i = 0; i < materialCount; ++i)
            {
                sgScene.GetMaterialTable().GetMaterial(i).SetBlendMode(Simplygon.EMaterialBlendMode.Blend);
            }

            {
            }
            // Create the Impostor processor. 
            using (Simplygon.spImpostorProcessor sgImpostorProcessor = sg.CreateImpostorProcessor())
            {
                sgImpostorProcessor.SetScene( sgScene );

                using (Simplygon.spImpostorSettings sgImpostorSettings = sgImpostorProcessor.GetImpostorSettings())
                {
                    // Set impostor type to Billboard cloud. 
                    sgImpostorSettings.SetImpostorType( Simplygon.EImpostorType.BillboardCloud );

                    using (Simplygon.spBillboardCloudSettings sgBillboardCloudSettings = sgImpostorSettings.GetBillboardCloudSettings())
                    {
                        // Set billboard cloud mode to OuterShell. 
                        sgBillboardCloudSettings.SetBillboardMode( Simplygon.EBillboardMode.OuterShell );
                        sgBillboardCloudSettings.SetBillboardDensity( 0.5f );
                        sgBillboardCloudSettings.SetGeometricComplexity( 0.9f );
                        sgBillboardCloudSettings.SetMaxPlaneCount( 20 );
                        sgBillboardCloudSettings.SetTwoSided( false );

                    }
                    using (Simplygon.spMappingImageSettings sgMappingImageSettings = sgImpostorProcessor.GetMappingImageSettings())
                    {
                        using (Simplygon.spMappingImageOutputMaterialSettings sgOutputMaterialSettings = sgMappingImageSettings.GetOutputMaterialSettings(0))
                        {
                            // Setting the size of the output material for the mapping image. This will be the output size of the 
                            // textures when we do material casting in a later stage. 
                            sgOutputMaterialSettings.SetTextureWidth( 1024 );
                            sgOutputMaterialSettings.SetTextureHeight( 1024 );
                            sgOutputMaterialSettings.SetMultisamplingLevel( 2 );

                        }
                    }
                }
                // Start the impostor process. 
                sgImpostorProcessor.RunProcessing();

                // Setup and run the diffuse material casting. 
                string diffuseTextureFilePath;
                using (Simplygon.spColorCaster sgDiffuseCaster = sg.CreateColorCaster())
                {
                    sgDiffuseCaster.SetMappingImage( sgImpostorProcessor.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 );
                        sgDiffuseCasterSettings.SetBakeOpacityInAlpha( false );
                        sgDiffuseCasterSettings.SetOutputPixelFormat( Simplygon.EPixelFormat.R8G8B8 );
                        sgDiffuseCasterSettings.SetDilation( 10 );
                        sgDiffuseCasterSettings.SetFillMode( Simplygon.EAtlasFillMode.Interpolate );
                    }

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

                // Setup and run the specular material casting. 
                string specularTextureFilePath;
                using (Simplygon.spColorCaster sgSpecularCaster = sg.CreateColorCaster())
                {
                    sgSpecularCaster.SetMappingImage( sgImpostorProcessor.GetMappingImage() );
                    sgSpecularCaster.SetSourceMaterials( sgScene.GetMaterialTable() );
                    sgSpecularCaster.SetSourceTextures( sgScene.GetTextureTable() );
                    sgSpecularCaster.SetOutputFilePath( "SpecularTexture" );

                    using (Simplygon.spColorCasterSettings sgSpecularCasterSettings = sgSpecularCaster.GetColorCasterSettings())
                    {
                        sgSpecularCasterSettings.SetMaterialChannel( "Specular" );
                        sgSpecularCasterSettings.SetOutputImageFileFormat( Simplygon.EImageOutputFormat.PNG );
                        sgSpecularCasterSettings.SetDilation( 10 );
                        sgSpecularCasterSettings.SetFillMode( Simplygon.EAtlasFillMode.Interpolate );
                    }

                    sgSpecularCaster.RunProcessing();
                    specularTextureFilePath = sgSpecularCaster.GetOutputFilePath();
                }

                // Setup and run the normals material casting. 
                string normalsTextureFilePath;
                using (Simplygon.spNormalCaster sgNormalsCaster = sg.CreateNormalCaster())
                {
                    sgNormalsCaster.SetMappingImage( sgImpostorProcessor.GetMappingImage() );
                    sgNormalsCaster.SetSourceMaterials( sgScene.GetMaterialTable() );
                    sgNormalsCaster.SetSourceTextures( sgScene.GetTextureTable() );
                    sgNormalsCaster.SetOutputFilePath( "NormalsTexture" );

                    using (Simplygon.spNormalCasterSettings sgNormalsCasterSettings = sgNormalsCaster.GetNormalCasterSettings())
                    {
                        sgNormalsCasterSettings.SetMaterialChannel( "Normals" );
                        sgNormalsCasterSettings.SetGenerateTangentSpaceNormals( true );
                        sgNormalsCasterSettings.SetOutputImageFileFormat( Simplygon.EImageOutputFormat.PNG );
                        sgNormalsCasterSettings.SetDilation( 10 );
                        sgNormalsCasterSettings.SetFillMode( Simplygon.EAtlasFillMode.Interpolate );
                    }

                    sgNormalsCaster.RunProcessing();
                    normalsTextureFilePath = sgNormalsCaster.GetOutputFilePath();
                }

                // Setup and run the opacity material casting. Make sure the there is no dilation or fill. 
                string opacityTextureFilePath;
                using (Simplygon.spOpacityCaster sgOpacityCaster = sg.CreateOpacityCaster())
                {
                    sgOpacityCaster.SetMappingImage( sgImpostorProcessor.GetMappingImage() );
                    sgOpacityCaster.SetSourceMaterials( sgScene.GetMaterialTable() );
                    sgOpacityCaster.SetSourceTextures( sgScene.GetTextureTable() );
                    sgOpacityCaster.SetOutputFilePath( "OpacityTexture" );

                    using (Simplygon.spOpacityCasterSettings sgOpacityCasterSettings = sgOpacityCaster.GetOpacityCasterSettings())
                    {
                        sgOpacityCasterSettings.SetMaterialChannel( "Opacity" );
                        sgOpacityCasterSettings.SetOutputImageFileFormat( Simplygon.EImageOutputFormat.PNG );
                        sgOpacityCasterSettings.SetDilation( 0 );
                        sgOpacityCasterSettings.SetFillMode( Simplygon.EAtlasFillMode.NoFill );
                        sgOpacityCasterSettings.SetOutputPixelFormat( Simplygon.EPixelFormat.R8 );
                    }

                    sgOpacityCaster.RunProcessing();
                    opacityTextureFilePath = sgOpacityCaster.GetOutputFilePath();
                }

                // Update scene with new casted textures. 
                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 );
                    }
                    using(Simplygon.spTexture sgSpecularTexture = sg.CreateTexture())
                    {
                        sgSpecularTexture.SetName( "Specular" );
                        sgSpecularTexture.SetFilePath( specularTextureFilePath );
                        sgTextureTable.AddTexture( sgSpecularTexture );
                    }

                    using(Simplygon.spShadingTextureNode sgSpecularTextureShadingNode = sg.CreateShadingTextureNode())
                    {
                        sgSpecularTextureShadingNode.SetTexCoordLevel( 0 );
                        sgSpecularTextureShadingNode.SetTextureName( "Specular" );

                        sgMaterial.AddMaterialChannel( "Specular" );
                        sgMaterial.SetShadingNetwork( "Specular", sgSpecularTextureShadingNode );
                    }
                    using(Simplygon.spTexture sgNormalsTexture = sg.CreateTexture())
                    {
                        sgNormalsTexture.SetName( "Normals" );
                        sgNormalsTexture.SetFilePath( normalsTextureFilePath );
                        sgTextureTable.AddTexture( sgNormalsTexture );
                    }

                    using(Simplygon.spShadingTextureNode sgNormalsTextureShadingNode = sg.CreateShadingTextureNode())
                    {
                        sgNormalsTextureShadingNode.SetTexCoordLevel( 0 );
                        sgNormalsTextureShadingNode.SetTextureName( "Normals" );

                        sgMaterial.AddMaterialChannel( "Normals" );
                        sgMaterial.SetShadingNetwork( "Normals", sgNormalsTextureShadingNode );
                    }
                    using(Simplygon.spTexture sgOpacityTexture = sg.CreateTexture())
                    {
                        sgOpacityTexture.SetName( "Opacity" );
                        sgOpacityTexture.SetFilePath( opacityTextureFilePath );
                        sgTextureTable.AddTexture( sgOpacityTexture );
                    }

                    using(Simplygon.spShadingTextureNode sgOpacityTextureShadingNode = sg.CreateShadingTextureNode())
                    {
                        sgOpacityTextureShadingNode.SetTexCoordLevel( 0 );
                        sgOpacityTextureShadingNode.SetTextureName( "Opacity" );

                        sgMaterial.AddMaterialChannel( "Opacity" );
                        sgMaterial.SetShadingNetwork( "Opacity", sgOpacityTextureShadingNode );
                    }

                    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( "OuterShellOutput.obj" );
                if(!sgSceneExporter.RunExport())
                    throw new System.Exception("Failed to save OuterShellOutput.obj.");

            }
        }
    }
    static int Main(string[] args)
    {
        using (var sg = Simplygon.Loader.InitSimplygon(out var errorCode, out var errorMessage))
        {
            if (errorCode != Simplygon.EErrorCodes.NoError)
                return (int)errorCode;
            RunBillboardCloudOuterShell(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 simplygon import simplygon_loader
from simplygon import Simplygon


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

    # For all materials in the scene set the blend mode to blend (instead of opaque) 
    materialCount = sgScene.GetMaterialTable().GetMaterialsCount()
    for i in range(0, materialCount):
        sgScene.GetMaterialTable().GetMaterial(i).SetBlendMode(Simplygon.EMaterialBlendMode_Blend)

    # Create the Impostor processor. 
    sgImpostorProcessor = sg.CreateImpostorProcessor()

    sgImpostorProcessor.SetScene( sgScene )

    sgImpostorSettings = sgImpostorProcessor.GetImpostorSettings()

    # Set impostor type to Billboard cloud. 
    sgImpostorSettings.SetImpostorType( Simplygon.EImpostorType_BillboardCloud )

    sgBillboardCloudSettings = sgImpostorSettings.GetBillboardCloudSettings()

    # Set billboard cloud mode to OuterShell. 
    sgBillboardCloudSettings.SetBillboardMode( Simplygon.EBillboardMode_OuterShell )
    sgBillboardCloudSettings.SetBillboardDensity( 0.5 )
    sgBillboardCloudSettings.SetGeometricComplexity( 0.9 )
    sgBillboardCloudSettings.SetMaxPlaneCount( 20 )
    sgBillboardCloudSettings.SetTwoSided( False )

    sgMappingImageSettings = sgImpostorProcessor.GetMappingImageSettings()

    sgOutputMaterialSettings = sgMappingImageSettings.GetOutputMaterialSettings(0)

    # Setting the size of the output material for the mapping image. This will be the output size of the 
    # textures when we do material casting in a later stage. 
    sgOutputMaterialSettings.SetTextureWidth( 1024 )
    sgOutputMaterialSettings.SetTextureHeight( 1024 )
    sgOutputMaterialSettings.SetMultisamplingLevel( 2 )

    # Start the impostor process. 
    sgImpostorProcessor.RunProcessing()

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

    sgDiffuseCasterSettings = sgDiffuseCaster.GetColorCasterSettings()
    sgDiffuseCasterSettings.SetMaterialChannel( 'Diffuse' )
    sgDiffuseCasterSettings.SetOutputImageFileFormat( Simplygon.EImageOutputFormat_PNG )
    sgDiffuseCasterSettings.SetBakeOpacityInAlpha( False )
    sgDiffuseCasterSettings.SetOutputPixelFormat( Simplygon.EPixelFormat_R8G8B8 )
    sgDiffuseCasterSettings.SetDilation( 10 )
    sgDiffuseCasterSettings.SetFillMode( Simplygon.EAtlasFillMode_Interpolate )

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

    # Setup and run the specular material casting. 
    sgSpecularCaster = sg.CreateColorCaster()
    sgSpecularCaster.SetMappingImage( sgImpostorProcessor.GetMappingImage() )
    sgSpecularCaster.SetSourceMaterials( sgScene.GetMaterialTable() )
    sgSpecularCaster.SetSourceTextures( sgScene.GetTextureTable() )
    sgSpecularCaster.SetOutputFilePath( 'SpecularTexture' )

    sgSpecularCasterSettings = sgSpecularCaster.GetColorCasterSettings()
    sgSpecularCasterSettings.SetMaterialChannel( 'Specular' )
    sgSpecularCasterSettings.SetOutputImageFileFormat( Simplygon.EImageOutputFormat_PNG )
    sgSpecularCasterSettings.SetDilation( 10 )
    sgSpecularCasterSettings.SetFillMode( Simplygon.EAtlasFillMode_Interpolate )

    sgSpecularCaster.RunProcessing()
    specularTextureFilePath = sgSpecularCaster.GetOutputFilePath()

    # Setup and run the normals material casting. 
    sgNormalsCaster = sg.CreateNormalCaster()
    sgNormalsCaster.SetMappingImage( sgImpostorProcessor.GetMappingImage() )
    sgNormalsCaster.SetSourceMaterials( sgScene.GetMaterialTable() )
    sgNormalsCaster.SetSourceTextures( sgScene.GetTextureTable() )
    sgNormalsCaster.SetOutputFilePath( 'NormalsTexture' )

    sgNormalsCasterSettings = sgNormalsCaster.GetNormalCasterSettings()
    sgNormalsCasterSettings.SetMaterialChannel( 'Normals' )
    sgNormalsCasterSettings.SetGenerateTangentSpaceNormals( True )
    sgNormalsCasterSettings.SetOutputImageFileFormat( Simplygon.EImageOutputFormat_PNG )
    sgNormalsCasterSettings.SetDilation( 10 )
    sgNormalsCasterSettings.SetFillMode( Simplygon.EAtlasFillMode_Interpolate )

    sgNormalsCaster.RunProcessing()
    normalsTextureFilePath = sgNormalsCaster.GetOutputFilePath()

    # Setup and run the opacity material casting. Make sure the there is no dilation or fill. 
    sgOpacityCaster = sg.CreateOpacityCaster()
    sgOpacityCaster.SetMappingImage( sgImpostorProcessor.GetMappingImage() )
    sgOpacityCaster.SetSourceMaterials( sgScene.GetMaterialTable() )
    sgOpacityCaster.SetSourceTextures( sgScene.GetTextureTable() )
    sgOpacityCaster.SetOutputFilePath( 'OpacityTexture' )

    sgOpacityCasterSettings = sgOpacityCaster.GetOpacityCasterSettings()
    sgOpacityCasterSettings.SetMaterialChannel( 'Opacity' )
    sgOpacityCasterSettings.SetOutputImageFileFormat( Simplygon.EImageOutputFormat_PNG )
    sgOpacityCasterSettings.SetDilation( 0 )
    sgOpacityCasterSettings.SetFillMode( Simplygon.EAtlasFillMode_NoFill )
    sgOpacityCasterSettings.SetOutputPixelFormat( Simplygon.EPixelFormat_R8 )

    sgOpacityCaster.RunProcessing()
    opacityTextureFilePath = sgOpacityCaster.GetOutputFilePath()

    # Update scene with new casted textures. 
    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 )
    sgSpecularTexture = sg.CreateTexture()
    sgSpecularTexture.SetName( 'Specular' )
    sgSpecularTexture.SetFilePath( specularTextureFilePath )
    sgTextureTable.AddTexture( sgSpecularTexture )

    sgSpecularTextureShadingNode = sg.CreateShadingTextureNode()
    sgSpecularTextureShadingNode.SetTexCoordLevel( 0 )
    sgSpecularTextureShadingNode.SetTextureName( 'Specular' )

    sgMaterial.AddMaterialChannel( 'Specular' )
    sgMaterial.SetShadingNetwork( 'Specular', sgSpecularTextureShadingNode )
    sgNormalsTexture = sg.CreateTexture()
    sgNormalsTexture.SetName( 'Normals' )
    sgNormalsTexture.SetFilePath( normalsTextureFilePath )
    sgTextureTable.AddTexture( sgNormalsTexture )

    sgNormalsTextureShadingNode = sg.CreateShadingTextureNode()
    sgNormalsTextureShadingNode.SetTexCoordLevel( 0 )
    sgNormalsTextureShadingNode.SetTextureName( 'Normals' )

    sgMaterial.AddMaterialChannel( 'Normals' )
    sgMaterial.SetShadingNetwork( 'Normals', sgNormalsTextureShadingNode )
    sgOpacityTexture = sg.CreateTexture()
    sgOpacityTexture.SetName( 'Opacity' )
    sgOpacityTexture.SetFilePath( opacityTextureFilePath )
    sgTextureTable.AddTexture( sgOpacityTexture )

    sgOpacityTextureShadingNode = sg.CreateShadingTextureNode()
    sgOpacityTextureShadingNode.SetTexCoordLevel( 0 )
    sgOpacityTextureShadingNode.SetTextureName( 'Opacity' )

    sgMaterial.AddMaterialChannel( 'Opacity' )
    sgMaterial.SetShadingNetwork( 'Opacity', sgOpacityTextureShadingNode )

    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( 'OuterShellOutput.obj' )
    if not sgSceneExporter.RunExport():
        raise Exception('Failed to save OuterShellOutput.obj.')


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

    RunBillboardCloudOuterShell(sg)

    sg = None
    gc.collect()

# Flip book

This example shows how to use the Impostor processor type: Flip book.

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

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


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

	// For all materials in the scene set the blend mode to blend (instead of opaque) 
	int materialCount = (int)sgScene->GetMaterialTable()->GetMaterialsCount();
	for (int i = 0; i < materialCount; ++i)
	{
		sgScene->GetMaterialTable()->GetMaterial(i)->SetBlendMode(Simplygon::EMaterialBlendMode::Blend);
	}

	// Create the Impostor processor. 
	Simplygon::spImpostorProcessor sgImpostorProcessor = sg->CreateImpostorProcessor();

	sgImpostorProcessor->SetScene( sgScene );

	Simplygon::spImpostorSettings sgImpostorSettings = sgImpostorProcessor->GetImpostorSettings();

	// Set impostor type to From single view. 
	sgImpostorSettings->SetImpostorType( Simplygon::EImpostorType::Flipbook );

	Simplygon::spFlipbookSettings sgFlipbookSettings = sgImpostorSettings->GetFlipbookSettings();

	sgFlipbookSettings->SetNumberOfViews( 9 );
	sgFlipbookSettings->SetViewDirectionX( 1.0f );
	sgFlipbookSettings->SetViewDirectionY( 0.0f );
	sgFlipbookSettings->SetViewDirectionZ( 0.0f );
	sgFlipbookSettings->SetUpVectorX( 0.0f );
	sgFlipbookSettings->SetUpVectorY( 1.0f );
	sgFlipbookSettings->SetUpVectorZ( 0.0f );

	Simplygon::spMappingImageSettings sgMappingImageSettings = sgImpostorProcessor->GetMappingImageSettings();

	sgMappingImageSettings->SetMaximumLayers( 10 );

	Simplygon::spMappingImageOutputMaterialSettings sgOutputMaterialSettings = sgMappingImageSettings->GetOutputMaterialSettings(0);

	// Setting the size of the output material for the mapping image. This will be the output size of the 
	// textures when we do material casting in a later stage. 
	sgOutputMaterialSettings->SetTextureWidth( 256 );
	sgOutputMaterialSettings->SetTextureHeight( 256 );
	sgOutputMaterialSettings->SetMultisamplingLevel( 2 );

	// Start the impostor process. 
	sgImpostorProcessor->RunProcessing();

	// Setup and run the diffuse material casting. 
	Simplygon::spColorCaster sgDiffuseCaster = sg->CreateColorCaster();
	sgDiffuseCaster->SetMappingImage( sgImpostorProcessor->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 );
	sgDiffuseCasterSettings->SetBakeOpacityInAlpha( false );
	sgDiffuseCasterSettings->SetOutputPixelFormat( Simplygon::EPixelFormat::R8G8B8 );
	sgDiffuseCasterSettings->SetDilation( 10 );
	sgDiffuseCasterSettings->SetFillMode( Simplygon::EAtlasFillMode::Interpolate );

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

	// Setup and run the specular material casting. 
	Simplygon::spColorCaster sgSpecularCaster = sg->CreateColorCaster();
	sgSpecularCaster->SetMappingImage( sgImpostorProcessor->GetMappingImage() );
	sgSpecularCaster->SetSourceMaterials( sgScene->GetMaterialTable() );
	sgSpecularCaster->SetSourceTextures( sgScene->GetTextureTable() );
	sgSpecularCaster->SetOutputFilePath( "SpecularTexture" );

	Simplygon::spColorCasterSettings sgSpecularCasterSettings = sgSpecularCaster->GetColorCasterSettings();
	sgSpecularCasterSettings->SetMaterialChannel( "Specular" );
	sgSpecularCasterSettings->SetOutputImageFileFormat( Simplygon::EImageOutputFormat::PNG );
	sgSpecularCasterSettings->SetDilation( 10 );
	sgSpecularCasterSettings->SetFillMode( Simplygon::EAtlasFillMode::Interpolate );

	sgSpecularCaster->RunProcessing();
	std::string specularTextureFilePath = sgSpecularCaster->GetOutputFilePath();

	// Setup and run the normals material casting. 
	Simplygon::spNormalCaster sgNormalsCaster = sg->CreateNormalCaster();
	sgNormalsCaster->SetMappingImage( sgImpostorProcessor->GetMappingImage() );
	sgNormalsCaster->SetSourceMaterials( sgScene->GetMaterialTable() );
	sgNormalsCaster->SetSourceTextures( sgScene->GetTextureTable() );
	sgNormalsCaster->SetOutputFilePath( "NormalsTexture" );

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

	sgNormalsCaster->RunProcessing();
	std::string normalsTextureFilePath = sgNormalsCaster->GetOutputFilePath();

	// Setup and run the opacity material casting. Make sure the there is no dilation or fill. 
	Simplygon::spOpacityCaster sgOpacityCaster = sg->CreateOpacityCaster();
	sgOpacityCaster->SetMappingImage( sgImpostorProcessor->GetMappingImage() );
	sgOpacityCaster->SetSourceMaterials( sgScene->GetMaterialTable() );
	sgOpacityCaster->SetSourceTextures( sgScene->GetTextureTable() );
	sgOpacityCaster->SetOutputFilePath( "OpacityTexture" );

	Simplygon::spOpacityCasterSettings sgOpacityCasterSettings = sgOpacityCaster->GetOpacityCasterSettings();
	sgOpacityCasterSettings->SetMaterialChannel( "Opacity" );
	sgOpacityCasterSettings->SetOutputImageFileFormat( Simplygon::EImageOutputFormat::PNG );
	sgOpacityCasterSettings->SetDilation( 0 );
	sgOpacityCasterSettings->SetFillMode( Simplygon::EAtlasFillMode::NoFill );
	sgOpacityCasterSettings->SetOutputPixelFormat( Simplygon::EPixelFormat::R8 );

	sgOpacityCaster->RunProcessing();
	std::string opacityTextureFilePath = sgOpacityCaster->GetOutputFilePath();

	// Update scene with new casted textures. 
	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 );
	Simplygon::spTexture sgSpecularTexture = sg->CreateTexture();
	sgSpecularTexture->SetName( "Specular" );
	sgSpecularTexture->SetFilePath( specularTextureFilePath.c_str() );
	sgTextureTable->AddTexture( sgSpecularTexture );

	Simplygon::spShadingTextureNode sgSpecularTextureShadingNode = sg->CreateShadingTextureNode();
	sgSpecularTextureShadingNode->SetTexCoordLevel( 0 );
	sgSpecularTextureShadingNode->SetTextureName( "Specular" );

	sgMaterial->AddMaterialChannel( "Specular" );
	sgMaterial->SetShadingNetwork( "Specular", sgSpecularTextureShadingNode );
	Simplygon::spTexture sgNormalsTexture = sg->CreateTexture();
	sgNormalsTexture->SetName( "Normals" );
	sgNormalsTexture->SetFilePath( normalsTextureFilePath.c_str() );
	sgTextureTable->AddTexture( sgNormalsTexture );

	Simplygon::spShadingTextureNode sgNormalsTextureShadingNode = sg->CreateShadingTextureNode();
	sgNormalsTextureShadingNode->SetTexCoordLevel( 0 );
	sgNormalsTextureShadingNode->SetTextureName( "Normals" );

	sgMaterial->AddMaterialChannel( "Normals" );
	sgMaterial->SetShadingNetwork( "Normals", sgNormalsTextureShadingNode );
	Simplygon::spTexture sgOpacityTexture = sg->CreateTexture();
	sgOpacityTexture->SetName( "Opacity" );
	sgOpacityTexture->SetFilePath( opacityTextureFilePath.c_str() );
	sgTextureTable->AddTexture( sgOpacityTexture );

	Simplygon::spShadingTextureNode sgOpacityTextureShadingNode = sg->CreateShadingTextureNode();
	sgOpacityTextureShadingNode->SetTexCoordLevel( 0 );
	sgOpacityTextureShadingNode->SetTextureName( "Opacity" );

	sgMaterial->AddMaterialChannel( "Opacity" );
	sgMaterial->SetShadingNetwork( "Opacity", sgOpacityTextureShadingNode );

	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( "FlipbookOutput.obj" );
	if(!sgSceneExporter->RunExport())
		throw std::exception("Failed to save FlipbookOutput.obj.");

}

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

	RunFlipbook(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 void RunFlipbook(Simplygon.ISimplygon sg)
    {
        using (Simplygon.spSceneImporter sgSceneImporter = sg.CreateSceneImporter())
        {
            sgSceneImporter.SetImportFilePath( "../Assets/Tree/Tree.obj" );
            if(!sgSceneImporter.RunImport())
                throw new System.Exception("Failed to load Tree/Tree.obj.");
            Simplygon.spScene sgScene = sgSceneImporter.GetScene();

            // For all materials in the scene set the blend mode to blend (instead of opaque) 
            int materialCount = (int)sgScene.GetMaterialTable().GetMaterialsCount();
            for (int i = 0; i < materialCount; ++i)
            {
                sgScene.GetMaterialTable().GetMaterial(i).SetBlendMode(Simplygon.EMaterialBlendMode.Blend);
            }

            {
            }
            // Create the Impostor processor. 
            using (Simplygon.spImpostorProcessor sgImpostorProcessor = sg.CreateImpostorProcessor())
            {
                sgImpostorProcessor.SetScene( sgScene );

                using (Simplygon.spImpostorSettings sgImpostorSettings = sgImpostorProcessor.GetImpostorSettings())
                {
                    // Set impostor type to From single view. 
                    sgImpostorSettings.SetImpostorType( Simplygon.EImpostorType.Flipbook );

                    using (Simplygon.spFlipbookSettings sgFlipbookSettings = sgImpostorSettings.GetFlipbookSettings())
                    {
                        sgFlipbookSettings.SetNumberOfViews( 9 );
                        sgFlipbookSettings.SetViewDirectionX( 1.0f );
                        sgFlipbookSettings.SetViewDirectionY( 0.0f );
                        sgFlipbookSettings.SetViewDirectionZ( 0.0f );
                        sgFlipbookSettings.SetUpVectorX( 0.0f );
                        sgFlipbookSettings.SetUpVectorY( 1.0f );
                        sgFlipbookSettings.SetUpVectorZ( 0.0f );

                        using (Simplygon.spMappingImageSettings sgMappingImageSettings = sgImpostorProcessor.GetMappingImageSettings())
                        {
                            sgMappingImageSettings.SetMaximumLayers( 10 );

                            using (Simplygon.spMappingImageOutputMaterialSettings sgOutputMaterialSettings = sgMappingImageSettings.GetOutputMaterialSettings(0))
                            {
                                // Setting the size of the output material for the mapping image. This will be the output size of the 
                                // textures when we do material casting in a later stage. 
                                sgOutputMaterialSettings.SetTextureWidth( 256 );
                                sgOutputMaterialSettings.SetTextureHeight( 256 );
                                sgOutputMaterialSettings.SetMultisamplingLevel( 2 );

                            }
                        }
                    }
                }
                // Start the impostor process. 
                sgImpostorProcessor.RunProcessing();

                // Setup and run the diffuse material casting. 
                string diffuseTextureFilePath;
                using (Simplygon.spColorCaster sgDiffuseCaster = sg.CreateColorCaster())
                {
                    sgDiffuseCaster.SetMappingImage( sgImpostorProcessor.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 );
                        sgDiffuseCasterSettings.SetBakeOpacityInAlpha( false );
                        sgDiffuseCasterSettings.SetOutputPixelFormat( Simplygon.EPixelFormat.R8G8B8 );
                        sgDiffuseCasterSettings.SetDilation( 10 );
                        sgDiffuseCasterSettings.SetFillMode( Simplygon.EAtlasFillMode.Interpolate );
                    }

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

                // Setup and run the specular material casting. 
                string specularTextureFilePath;
                using (Simplygon.spColorCaster sgSpecularCaster = sg.CreateColorCaster())
                {
                    sgSpecularCaster.SetMappingImage( sgImpostorProcessor.GetMappingImage() );
                    sgSpecularCaster.SetSourceMaterials( sgScene.GetMaterialTable() );
                    sgSpecularCaster.SetSourceTextures( sgScene.GetTextureTable() );
                    sgSpecularCaster.SetOutputFilePath( "SpecularTexture" );

                    using (Simplygon.spColorCasterSettings sgSpecularCasterSettings = sgSpecularCaster.GetColorCasterSettings())
                    {
                        sgSpecularCasterSettings.SetMaterialChannel( "Specular" );
                        sgSpecularCasterSettings.SetOutputImageFileFormat( Simplygon.EImageOutputFormat.PNG );
                        sgSpecularCasterSettings.SetDilation( 10 );
                        sgSpecularCasterSettings.SetFillMode( Simplygon.EAtlasFillMode.Interpolate );
                    }

                    sgSpecularCaster.RunProcessing();
                    specularTextureFilePath = sgSpecularCaster.GetOutputFilePath();
                }

                // Setup and run the normals material casting. 
                string normalsTextureFilePath;
                using (Simplygon.spNormalCaster sgNormalsCaster = sg.CreateNormalCaster())
                {
                    sgNormalsCaster.SetMappingImage( sgImpostorProcessor.GetMappingImage() );
                    sgNormalsCaster.SetSourceMaterials( sgScene.GetMaterialTable() );
                    sgNormalsCaster.SetSourceTextures( sgScene.GetTextureTable() );
                    sgNormalsCaster.SetOutputFilePath( "NormalsTexture" );

                    using (Simplygon.spNormalCasterSettings sgNormalsCasterSettings = sgNormalsCaster.GetNormalCasterSettings())
                    {
                        sgNormalsCasterSettings.SetMaterialChannel( "Normals" );
                        sgNormalsCasterSettings.SetGenerateTangentSpaceNormals( true );
                        sgNormalsCasterSettings.SetOutputImageFileFormat( Simplygon.EImageOutputFormat.PNG );
                        sgNormalsCasterSettings.SetDilation( 10 );
                        sgNormalsCasterSettings.SetFillMode( Simplygon.EAtlasFillMode.Interpolate );
                    }

                    sgNormalsCaster.RunProcessing();
                    normalsTextureFilePath = sgNormalsCaster.GetOutputFilePath();
                }

                // Setup and run the opacity material casting. Make sure the there is no dilation or fill. 
                string opacityTextureFilePath;
                using (Simplygon.spOpacityCaster sgOpacityCaster = sg.CreateOpacityCaster())
                {
                    sgOpacityCaster.SetMappingImage( sgImpostorProcessor.GetMappingImage() );
                    sgOpacityCaster.SetSourceMaterials( sgScene.GetMaterialTable() );
                    sgOpacityCaster.SetSourceTextures( sgScene.GetTextureTable() );
                    sgOpacityCaster.SetOutputFilePath( "OpacityTexture" );

                    using (Simplygon.spOpacityCasterSettings sgOpacityCasterSettings = sgOpacityCaster.GetOpacityCasterSettings())
                    {
                        sgOpacityCasterSettings.SetMaterialChannel( "Opacity" );
                        sgOpacityCasterSettings.SetOutputImageFileFormat( Simplygon.EImageOutputFormat.PNG );
                        sgOpacityCasterSettings.SetDilation( 0 );
                        sgOpacityCasterSettings.SetFillMode( Simplygon.EAtlasFillMode.NoFill );
                        sgOpacityCasterSettings.SetOutputPixelFormat( Simplygon.EPixelFormat.R8 );
                    }

                    sgOpacityCaster.RunProcessing();
                    opacityTextureFilePath = sgOpacityCaster.GetOutputFilePath();
                }

                // Update scene with new casted textures. 
                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 );
                    }
                    using(Simplygon.spTexture sgSpecularTexture = sg.CreateTexture())
                    {
                        sgSpecularTexture.SetName( "Specular" );
                        sgSpecularTexture.SetFilePath( specularTextureFilePath );
                        sgTextureTable.AddTexture( sgSpecularTexture );
                    }

                    using(Simplygon.spShadingTextureNode sgSpecularTextureShadingNode = sg.CreateShadingTextureNode())
                    {
                        sgSpecularTextureShadingNode.SetTexCoordLevel( 0 );
                        sgSpecularTextureShadingNode.SetTextureName( "Specular" );

                        sgMaterial.AddMaterialChannel( "Specular" );
                        sgMaterial.SetShadingNetwork( "Specular", sgSpecularTextureShadingNode );
                    }
                    using(Simplygon.spTexture sgNormalsTexture = sg.CreateTexture())
                    {
                        sgNormalsTexture.SetName( "Normals" );
                        sgNormalsTexture.SetFilePath( normalsTextureFilePath );
                        sgTextureTable.AddTexture( sgNormalsTexture );
                    }

                    using(Simplygon.spShadingTextureNode sgNormalsTextureShadingNode = sg.CreateShadingTextureNode())
                    {
                        sgNormalsTextureShadingNode.SetTexCoordLevel( 0 );
                        sgNormalsTextureShadingNode.SetTextureName( "Normals" );

                        sgMaterial.AddMaterialChannel( "Normals" );
                        sgMaterial.SetShadingNetwork( "Normals", sgNormalsTextureShadingNode );
                    }
                    using(Simplygon.spTexture sgOpacityTexture = sg.CreateTexture())
                    {
                        sgOpacityTexture.SetName( "Opacity" );
                        sgOpacityTexture.SetFilePath( opacityTextureFilePath );
                        sgTextureTable.AddTexture( sgOpacityTexture );
                    }

                    using(Simplygon.spShadingTextureNode sgOpacityTextureShadingNode = sg.CreateShadingTextureNode())
                    {
                        sgOpacityTextureShadingNode.SetTexCoordLevel( 0 );
                        sgOpacityTextureShadingNode.SetTextureName( "Opacity" );

                        sgMaterial.AddMaterialChannel( "Opacity" );
                        sgMaterial.SetShadingNetwork( "Opacity", sgOpacityTextureShadingNode );
                    }

                    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( "FlipbookOutput.obj" );
                if(!sgSceneExporter.RunExport())
                    throw new System.Exception("Failed to save FlipbookOutput.obj.");

            }
        }
    }
    static int Main(string[] args)
    {
        using (var sg = Simplygon.Loader.InitSimplygon(out var errorCode, out var errorMessage))
        {
            if (errorCode != Simplygon.EErrorCodes.NoError)
                return (int)errorCode;
            RunFlipbook(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 simplygon import simplygon_loader
from simplygon import Simplygon


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

    # For all materials in the scene set the blend mode to blend (instead of opaque) 
    materialCount = sgScene.GetMaterialTable().GetMaterialsCount()
    for i in range(0, materialCount):
        sgScene.GetMaterialTable().GetMaterial(i).SetBlendMode(Simplygon.EMaterialBlendMode_Blend)

    # Create the Impostor processor. 
    sgImpostorProcessor = sg.CreateImpostorProcessor()

    sgImpostorProcessor.SetScene( sgScene )

    sgImpostorSettings = sgImpostorProcessor.GetImpostorSettings()

    # Set impostor type to From single view. 
    sgImpostorSettings.SetImpostorType( Simplygon.EImpostorType_Flipbook )

    sgFlipbookSettings = sgImpostorSettings.GetFlipbookSettings()

    sgFlipbookSettings.SetNumberOfViews( 9 )
    sgFlipbookSettings.SetViewDirectionX( 1.0 )
    sgFlipbookSettings.SetViewDirectionY( 0.0 )
    sgFlipbookSettings.SetViewDirectionZ( 0.0 )
    sgFlipbookSettings.SetUpVectorX( 0.0 )
    sgFlipbookSettings.SetUpVectorY( 1.0 )
    sgFlipbookSettings.SetUpVectorZ( 0.0 )

    sgMappingImageSettings = sgImpostorProcessor.GetMappingImageSettings()

    sgMappingImageSettings.SetMaximumLayers( 10 )

    sgOutputMaterialSettings = sgMappingImageSettings.GetOutputMaterialSettings(0)

    # Setting the size of the output material for the mapping image. This will be the output size of the 
    # textures when we do material casting in a later stage. 
    sgOutputMaterialSettings.SetTextureWidth( 256 )
    sgOutputMaterialSettings.SetTextureHeight( 256 )
    sgOutputMaterialSettings.SetMultisamplingLevel( 2 )

    # Start the impostor process. 
    sgImpostorProcessor.RunProcessing()

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

    sgDiffuseCasterSettings = sgDiffuseCaster.GetColorCasterSettings()
    sgDiffuseCasterSettings.SetMaterialChannel( 'Diffuse' )
    sgDiffuseCasterSettings.SetOutputImageFileFormat( Simplygon.EImageOutputFormat_PNG )
    sgDiffuseCasterSettings.SetBakeOpacityInAlpha( False )
    sgDiffuseCasterSettings.SetOutputPixelFormat( Simplygon.EPixelFormat_R8G8B8 )
    sgDiffuseCasterSettings.SetDilation( 10 )
    sgDiffuseCasterSettings.SetFillMode( Simplygon.EAtlasFillMode_Interpolate )

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

    # Setup and run the specular material casting. 
    sgSpecularCaster = sg.CreateColorCaster()
    sgSpecularCaster.SetMappingImage( sgImpostorProcessor.GetMappingImage() )
    sgSpecularCaster.SetSourceMaterials( sgScene.GetMaterialTable() )
    sgSpecularCaster.SetSourceTextures( sgScene.GetTextureTable() )
    sgSpecularCaster.SetOutputFilePath( 'SpecularTexture' )

    sgSpecularCasterSettings = sgSpecularCaster.GetColorCasterSettings()
    sgSpecularCasterSettings.SetMaterialChannel( 'Specular' )
    sgSpecularCasterSettings.SetOutputImageFileFormat( Simplygon.EImageOutputFormat_PNG )
    sgSpecularCasterSettings.SetDilation( 10 )
    sgSpecularCasterSettings.SetFillMode( Simplygon.EAtlasFillMode_Interpolate )

    sgSpecularCaster.RunProcessing()
    specularTextureFilePath = sgSpecularCaster.GetOutputFilePath()

    # Setup and run the normals material casting. 
    sgNormalsCaster = sg.CreateNormalCaster()
    sgNormalsCaster.SetMappingImage( sgImpostorProcessor.GetMappingImage() )
    sgNormalsCaster.SetSourceMaterials( sgScene.GetMaterialTable() )
    sgNormalsCaster.SetSourceTextures( sgScene.GetTextureTable() )
    sgNormalsCaster.SetOutputFilePath( 'NormalsTexture' )

    sgNormalsCasterSettings = sgNormalsCaster.GetNormalCasterSettings()
    sgNormalsCasterSettings.SetMaterialChannel( 'Normals' )
    sgNormalsCasterSettings.SetGenerateTangentSpaceNormals( True )
    sgNormalsCasterSettings.SetOutputImageFileFormat( Simplygon.EImageOutputFormat_PNG )
    sgNormalsCasterSettings.SetDilation( 10 )
    sgNormalsCasterSettings.SetFillMode( Simplygon.EAtlasFillMode_Interpolate )

    sgNormalsCaster.RunProcessing()
    normalsTextureFilePath = sgNormalsCaster.GetOutputFilePath()

    # Setup and run the opacity material casting. Make sure the there is no dilation or fill. 
    sgOpacityCaster = sg.CreateOpacityCaster()
    sgOpacityCaster.SetMappingImage( sgImpostorProcessor.GetMappingImage() )
    sgOpacityCaster.SetSourceMaterials( sgScene.GetMaterialTable() )
    sgOpacityCaster.SetSourceTextures( sgScene.GetTextureTable() )
    sgOpacityCaster.SetOutputFilePath( 'OpacityTexture' )

    sgOpacityCasterSettings = sgOpacityCaster.GetOpacityCasterSettings()
    sgOpacityCasterSettings.SetMaterialChannel( 'Opacity' )
    sgOpacityCasterSettings.SetOutputImageFileFormat( Simplygon.EImageOutputFormat_PNG )
    sgOpacityCasterSettings.SetDilation( 0 )
    sgOpacityCasterSettings.SetFillMode( Simplygon.EAtlasFillMode_NoFill )
    sgOpacityCasterSettings.SetOutputPixelFormat( Simplygon.EPixelFormat_R8 )

    sgOpacityCaster.RunProcessing()
    opacityTextureFilePath = sgOpacityCaster.GetOutputFilePath()

    # Update scene with new casted textures. 
    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 )
    sgSpecularTexture = sg.CreateTexture()
    sgSpecularTexture.SetName( 'Specular' )
    sgSpecularTexture.SetFilePath( specularTextureFilePath )
    sgTextureTable.AddTexture( sgSpecularTexture )

    sgSpecularTextureShadingNode = sg.CreateShadingTextureNode()
    sgSpecularTextureShadingNode.SetTexCoordLevel( 0 )
    sgSpecularTextureShadingNode.SetTextureName( 'Specular' )

    sgMaterial.AddMaterialChannel( 'Specular' )
    sgMaterial.SetShadingNetwork( 'Specular', sgSpecularTextureShadingNode )
    sgNormalsTexture = sg.CreateTexture()
    sgNormalsTexture.SetName( 'Normals' )
    sgNormalsTexture.SetFilePath( normalsTextureFilePath )
    sgTextureTable.AddTexture( sgNormalsTexture )

    sgNormalsTextureShadingNode = sg.CreateShadingTextureNode()
    sgNormalsTextureShadingNode.SetTexCoordLevel( 0 )
    sgNormalsTextureShadingNode.SetTextureName( 'Normals' )

    sgMaterial.AddMaterialChannel( 'Normals' )
    sgMaterial.SetShadingNetwork( 'Normals', sgNormalsTextureShadingNode )
    sgOpacityTexture = sg.CreateTexture()
    sgOpacityTexture.SetName( 'Opacity' )
    sgOpacityTexture.SetFilePath( opacityTextureFilePath )
    sgTextureTable.AddTexture( sgOpacityTexture )

    sgOpacityTextureShadingNode = sg.CreateShadingTextureNode()
    sgOpacityTextureShadingNode.SetTexCoordLevel( 0 )
    sgOpacityTextureShadingNode.SetTextureName( 'Opacity' )

    sgMaterial.AddMaterialChannel( 'Opacity' )
    sgMaterial.SetShadingNetwork( 'Opacity', sgOpacityTextureShadingNode )

    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( 'FlipbookOutput.obj' )
    if not sgSceneExporter.RunExport():
        raise Exception('Failed to save FlipbookOutput.obj.')


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

    RunFlipbook(sg)

    sg = None
    gc.collect()

# From single view

This example shows how to use the Impostor processor type: Impostor from single view.

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

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


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

	// For all materials in the scene set the blend mode to blend (instead of opaque) 
	int materialCount = (int)sgScene->GetMaterialTable()->GetMaterialsCount();
	for (int i = 0; i < materialCount; ++i)
	{
		sgScene->GetMaterialTable()->GetMaterial(i)->SetBlendMode(Simplygon::EMaterialBlendMode::Blend);
	}

	// Create the Impostor processor. 
	Simplygon::spImpostorProcessor sgImpostorProcessor = sg->CreateImpostorProcessor();

	sgImpostorProcessor->SetScene( sgScene );

	Simplygon::spImpostorSettings sgImpostorSettings = sgImpostorProcessor->GetImpostorSettings();

	// Set impostor type to From single view. 
	sgImpostorSettings->SetImpostorType( Simplygon::EImpostorType::FromSingleView );

	Simplygon::real viewDir[] = {0.0f, 0.0f, -1.0f};

	Simplygon::spImpostorFromSingleViewSettings sgImpostorFromSingleViewSettings = sgImpostorSettings->GetImpostorFromSingleViewSettings();

	sgImpostorFromSingleViewSettings->SetUseTightFitting( true );
	sgImpostorFromSingleViewSettings->SetTightFittingDepthOffset( 1.0f );
	sgImpostorFromSingleViewSettings->SetTexCoordPadding( 0.01f );
	sgImpostorFromSingleViewSettings->SetViewDirection( viewDir );

	// Once geometry and settings are set, you can calculate the aspect ratio for the textures.
	Simplygon::real aspect = sgImpostorProcessor->GetSingleViewAspectRatio();
	if (aspect < 0.0f)
		throw std::exception("Failed to compute aspect ratio!");
	int xDim = int(aspect * 512);
	int yDim = int(1.f * 512);

	Simplygon::spMappingImageSettings sgMappingImageSettings = sgImpostorProcessor->GetMappingImageSettings();

	sgMappingImageSettings->SetMaximumLayers( 10 );

	Simplygon::spMappingImageOutputMaterialSettings sgOutputMaterialSettings = sgMappingImageSettings->GetOutputMaterialSettings(0);

	// Setting the size of the output material for the mapping image. This will be the output size of the 
	// textures when we do material casting in a later stage. 
	sgOutputMaterialSettings->SetTextureWidth( xDim );
	sgOutputMaterialSettings->SetTextureHeight( yDim );
	sgOutputMaterialSettings->SetMultisamplingLevel( 2 );

	// Start the impostor process. 
	sgImpostorProcessor->RunProcessing();

	// Setup and run the diffuse material casting. 
	Simplygon::spColorCaster sgDiffuseCaster = sg->CreateColorCaster();
	sgDiffuseCaster->SetMappingImage( sgImpostorProcessor->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 );
	sgDiffuseCasterSettings->SetBakeOpacityInAlpha( false );
	sgDiffuseCasterSettings->SetOutputPixelFormat( Simplygon::EPixelFormat::R8G8B8 );
	sgDiffuseCasterSettings->SetDilation( 10 );
	sgDiffuseCasterSettings->SetFillMode( Simplygon::EAtlasFillMode::Interpolate );

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

	// Setup and run the specular material casting. 
	Simplygon::spColorCaster sgSpecularCaster = sg->CreateColorCaster();
	sgSpecularCaster->SetMappingImage( sgImpostorProcessor->GetMappingImage() );
	sgSpecularCaster->SetSourceMaterials( sgScene->GetMaterialTable() );
	sgSpecularCaster->SetSourceTextures( sgScene->GetTextureTable() );
	sgSpecularCaster->SetOutputFilePath( "SpecularTexture" );

	Simplygon::spColorCasterSettings sgSpecularCasterSettings = sgSpecularCaster->GetColorCasterSettings();
	sgSpecularCasterSettings->SetMaterialChannel( "Specular" );
	sgSpecularCasterSettings->SetOutputImageFileFormat( Simplygon::EImageOutputFormat::PNG );
	sgSpecularCasterSettings->SetDilation( 10 );
	sgSpecularCasterSettings->SetFillMode( Simplygon::EAtlasFillMode::Interpolate );

	sgSpecularCaster->RunProcessing();
	std::string specularTextureFilePath = sgSpecularCaster->GetOutputFilePath();

	// Setup and run the normals material casting. 
	Simplygon::spNormalCaster sgNormalsCaster = sg->CreateNormalCaster();
	sgNormalsCaster->SetMappingImage( sgImpostorProcessor->GetMappingImage() );
	sgNormalsCaster->SetSourceMaterials( sgScene->GetMaterialTable() );
	sgNormalsCaster->SetSourceTextures( sgScene->GetTextureTable() );
	sgNormalsCaster->SetOutputFilePath( "NormalsTexture" );

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

	sgNormalsCaster->RunProcessing();
	std::string normalsTextureFilePath = sgNormalsCaster->GetOutputFilePath();

	// Setup and run the opacity material casting. Make sure the there is no dilation or fill. 
	Simplygon::spOpacityCaster sgOpacityCaster = sg->CreateOpacityCaster();
	sgOpacityCaster->SetMappingImage( sgImpostorProcessor->GetMappingImage() );
	sgOpacityCaster->SetSourceMaterials( sgScene->GetMaterialTable() );
	sgOpacityCaster->SetSourceTextures( sgScene->GetTextureTable() );
	sgOpacityCaster->SetOutputFilePath( "OpacityTexture" );

	Simplygon::spOpacityCasterSettings sgOpacityCasterSettings = sgOpacityCaster->GetOpacityCasterSettings();
	sgOpacityCasterSettings->SetMaterialChannel( "Opacity" );
	sgOpacityCasterSettings->SetOutputImageFileFormat( Simplygon::EImageOutputFormat::PNG );
	sgOpacityCasterSettings->SetDilation( 0 );
	sgOpacityCasterSettings->SetFillMode( Simplygon::EAtlasFillMode::NoFill );
	sgOpacityCasterSettings->SetOutputPixelFormat( Simplygon::EPixelFormat::R8 );

	sgOpacityCaster->RunProcessing();
	std::string opacityTextureFilePath = sgOpacityCaster->GetOutputFilePath();

	// Update scene with new casted textures. 
	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 );
	Simplygon::spTexture sgSpecularTexture = sg->CreateTexture();
	sgSpecularTexture->SetName( "Specular" );
	sgSpecularTexture->SetFilePath( specularTextureFilePath.c_str() );
	sgTextureTable->AddTexture( sgSpecularTexture );

	Simplygon::spShadingTextureNode sgSpecularTextureShadingNode = sg->CreateShadingTextureNode();
	sgSpecularTextureShadingNode->SetTexCoordLevel( 0 );
	sgSpecularTextureShadingNode->SetTextureName( "Specular" );

	sgMaterial->AddMaterialChannel( "Specular" );
	sgMaterial->SetShadingNetwork( "Specular", sgSpecularTextureShadingNode );
	Simplygon::spTexture sgNormalsTexture = sg->CreateTexture();
	sgNormalsTexture->SetName( "Normals" );
	sgNormalsTexture->SetFilePath( normalsTextureFilePath.c_str() );
	sgTextureTable->AddTexture( sgNormalsTexture );

	Simplygon::spShadingTextureNode sgNormalsTextureShadingNode = sg->CreateShadingTextureNode();
	sgNormalsTextureShadingNode->SetTexCoordLevel( 0 );
	sgNormalsTextureShadingNode->SetTextureName( "Normals" );

	sgMaterial->AddMaterialChannel( "Normals" );
	sgMaterial->SetShadingNetwork( "Normals", sgNormalsTextureShadingNode );
	Simplygon::spTexture sgOpacityTexture = sg->CreateTexture();
	sgOpacityTexture->SetName( "Opacity" );
	sgOpacityTexture->SetFilePath( opacityTextureFilePath.c_str() );
	sgTextureTable->AddTexture( sgOpacityTexture );

	Simplygon::spShadingTextureNode sgOpacityTextureShadingNode = sg->CreateShadingTextureNode();
	sgOpacityTextureShadingNode->SetTexCoordLevel( 0 );
	sgOpacityTextureShadingNode->SetTextureName( "Opacity" );

	sgMaterial->AddMaterialChannel( "Opacity" );
	sgMaterial->SetShadingNetwork( "Opacity", sgOpacityTextureShadingNode );

	sgMaterialTable->AddMaterial( sgMaterial );

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

	Simplygon::spScene sgImpostorScene = sg->CreateScene();
	Simplygon::spGeometryData sgImpostorGeometry = sgImpostorProcessor->GetImpostorGeometryFromSingleView();
	sgImpostorScene->GetRootNode()->CreateChildMesh(sgImpostorGeometry);
	sgImpostorScene->GetMaterialTable()->Copy(sgScene->GetMaterialTable());
	sgImpostorScene->GetTextureTable()->Copy(sgScene->GetTextureTable());

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

}

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

	RunImpostorFromSingleView(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 void RunImpostorFromSingleView(Simplygon.ISimplygon sg)
    {
        using (Simplygon.spSceneImporter sgSceneImporter = sg.CreateSceneImporter())
        {
            sgSceneImporter.SetImportFilePath( "../Assets/Wall/Wall.obj" );
            if(!sgSceneImporter.RunImport())
                throw new System.Exception("Failed to load Wall/Wall.obj.");
            Simplygon.spScene sgScene = sgSceneImporter.GetScene();

            // For all materials in the scene set the blend mode to blend (instead of opaque) 
            int materialCount = (int)sgScene.GetMaterialTable().GetMaterialsCount();
            for (int i = 0; i < materialCount; ++i)
            {
                sgScene.GetMaterialTable().GetMaterial(i).SetBlendMode(Simplygon.EMaterialBlendMode.Blend);
            }

            {
            }
            // Create the Impostor processor. 
            using (Simplygon.spImpostorProcessor sgImpostorProcessor = sg.CreateImpostorProcessor())
            {
                sgImpostorProcessor.SetScene( sgScene );

                using (Simplygon.spImpostorSettings sgImpostorSettings = sgImpostorProcessor.GetImpostorSettings())
                {
                    // Set impostor type to From single view. 
                    sgImpostorSettings.SetImpostorType( Simplygon.EImpostorType.FromSingleView );

                    float[] viewDir = {0.0f, 0.0f, -1.0f};

                    using (Simplygon.spImpostorFromSingleViewSettings sgImpostorFromSingleViewSettings = sgImpostorSettings.GetImpostorFromSingleViewSettings())
                    {
                        sgImpostorFromSingleViewSettings.SetUseTightFitting( true );
                        sgImpostorFromSingleViewSettings.SetTightFittingDepthOffset( 1.0f );
                        sgImpostorFromSingleViewSettings.SetTexCoordPadding( 0.01f );
                        sgImpostorFromSingleViewSettings.SetViewDirection( viewDir );

                    }
                    // Once geometry and settings are set, you can calculate the aspect ratio for the textures.
                    float aspect = sgImpostorProcessor.GetSingleViewAspectRatio();
                    if (aspect < 0.0f)
                        throw new System.Exception("Failed to compute aspect ratio!");
                    uint xDim = (uint)(aspect * 512);
                    uint yDim = (uint)(1.0f * 512);
                    using (Simplygon.spMappingImageSettings sgMappingImageSettings = sgImpostorProcessor.GetMappingImageSettings())
                    {
                        sgMappingImageSettings.SetMaximumLayers( 10 );

                        using (Simplygon.spMappingImageOutputMaterialSettings sgOutputMaterialSettings = sgMappingImageSettings.GetOutputMaterialSettings(0))
                        {
                            // Setting the size of the output material for the mapping image. This will be the output size of the 
                            // textures when we do material casting in a later stage. 
                            sgOutputMaterialSettings.SetTextureWidth( xDim );
                            sgOutputMaterialSettings.SetTextureHeight( yDim );
                            sgOutputMaterialSettings.SetMultisamplingLevel( 2 );

                        }
                    }
                }
                // Start the impostor process. 
                sgImpostorProcessor.RunProcessing();

                // Setup and run the diffuse material casting. 
                string diffuseTextureFilePath;
                using (Simplygon.spColorCaster sgDiffuseCaster = sg.CreateColorCaster())
                {
                    sgDiffuseCaster.SetMappingImage( sgImpostorProcessor.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 );
                        sgDiffuseCasterSettings.SetBakeOpacityInAlpha( false );
                        sgDiffuseCasterSettings.SetOutputPixelFormat( Simplygon.EPixelFormat.R8G8B8 );
                        sgDiffuseCasterSettings.SetDilation( 10 );
                        sgDiffuseCasterSettings.SetFillMode( Simplygon.EAtlasFillMode.Interpolate );
                    }

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

                // Setup and run the specular material casting. 
                string specularTextureFilePath;
                using (Simplygon.spColorCaster sgSpecularCaster = sg.CreateColorCaster())
                {
                    sgSpecularCaster.SetMappingImage( sgImpostorProcessor.GetMappingImage() );
                    sgSpecularCaster.SetSourceMaterials( sgScene.GetMaterialTable() );
                    sgSpecularCaster.SetSourceTextures( sgScene.GetTextureTable() );
                    sgSpecularCaster.SetOutputFilePath( "SpecularTexture" );

                    using (Simplygon.spColorCasterSettings sgSpecularCasterSettings = sgSpecularCaster.GetColorCasterSettings())
                    {
                        sgSpecularCasterSettings.SetMaterialChannel( "Specular" );
                        sgSpecularCasterSettings.SetOutputImageFileFormat( Simplygon.EImageOutputFormat.PNG );
                        sgSpecularCasterSettings.SetDilation( 10 );
                        sgSpecularCasterSettings.SetFillMode( Simplygon.EAtlasFillMode.Interpolate );
                    }

                    sgSpecularCaster.RunProcessing();
                    specularTextureFilePath = sgSpecularCaster.GetOutputFilePath();
                }

                // Setup and run the normals material casting. 
                string normalsTextureFilePath;
                using (Simplygon.spNormalCaster sgNormalsCaster = sg.CreateNormalCaster())
                {
                    sgNormalsCaster.SetMappingImage( sgImpostorProcessor.GetMappingImage() );
                    sgNormalsCaster.SetSourceMaterials( sgScene.GetMaterialTable() );
                    sgNormalsCaster.SetSourceTextures( sgScene.GetTextureTable() );
                    sgNormalsCaster.SetOutputFilePath( "NormalsTexture" );

                    using (Simplygon.spNormalCasterSettings sgNormalsCasterSettings = sgNormalsCaster.GetNormalCasterSettings())
                    {
                        sgNormalsCasterSettings.SetMaterialChannel( "Normals" );
                        sgNormalsCasterSettings.SetGenerateTangentSpaceNormals( true );
                        sgNormalsCasterSettings.SetOutputImageFileFormat( Simplygon.EImageOutputFormat.PNG );
                        sgNormalsCasterSettings.SetDilation( 10 );
                        sgNormalsCasterSettings.SetFillMode( Simplygon.EAtlasFillMode.Interpolate );
                    }

                    sgNormalsCaster.RunProcessing();
                    normalsTextureFilePath = sgNormalsCaster.GetOutputFilePath();
                }

                // Setup and run the opacity material casting. Make sure the there is no dilation or fill. 
                string opacityTextureFilePath;
                using (Simplygon.spOpacityCaster sgOpacityCaster = sg.CreateOpacityCaster())
                {
                    sgOpacityCaster.SetMappingImage( sgImpostorProcessor.GetMappingImage() );
                    sgOpacityCaster.SetSourceMaterials( sgScene.GetMaterialTable() );
                    sgOpacityCaster.SetSourceTextures( sgScene.GetTextureTable() );
                    sgOpacityCaster.SetOutputFilePath( "OpacityTexture" );

                    using (Simplygon.spOpacityCasterSettings sgOpacityCasterSettings = sgOpacityCaster.GetOpacityCasterSettings())
                    {
                        sgOpacityCasterSettings.SetMaterialChannel( "Opacity" );
                        sgOpacityCasterSettings.SetOutputImageFileFormat( Simplygon.EImageOutputFormat.PNG );
                        sgOpacityCasterSettings.SetDilation( 0 );
                        sgOpacityCasterSettings.SetFillMode( Simplygon.EAtlasFillMode.NoFill );
                        sgOpacityCasterSettings.SetOutputPixelFormat( Simplygon.EPixelFormat.R8 );
                    }

                    sgOpacityCaster.RunProcessing();
                    opacityTextureFilePath = sgOpacityCaster.GetOutputFilePath();
                }

                // Update scene with new casted textures. 
                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 );
                    }
                    using(Simplygon.spTexture sgSpecularTexture = sg.CreateTexture())
                    {
                        sgSpecularTexture.SetName( "Specular" );
                        sgSpecularTexture.SetFilePath( specularTextureFilePath );
                        sgTextureTable.AddTexture( sgSpecularTexture );
                    }

                    using(Simplygon.spShadingTextureNode sgSpecularTextureShadingNode = sg.CreateShadingTextureNode())
                    {
                        sgSpecularTextureShadingNode.SetTexCoordLevel( 0 );
                        sgSpecularTextureShadingNode.SetTextureName( "Specular" );

                        sgMaterial.AddMaterialChannel( "Specular" );
                        sgMaterial.SetShadingNetwork( "Specular", sgSpecularTextureShadingNode );
                    }
                    using(Simplygon.spTexture sgNormalsTexture = sg.CreateTexture())
                    {
                        sgNormalsTexture.SetName( "Normals" );
                        sgNormalsTexture.SetFilePath( normalsTextureFilePath );
                        sgTextureTable.AddTexture( sgNormalsTexture );
                    }

                    using(Simplygon.spShadingTextureNode sgNormalsTextureShadingNode = sg.CreateShadingTextureNode())
                    {
                        sgNormalsTextureShadingNode.SetTexCoordLevel( 0 );
                        sgNormalsTextureShadingNode.SetTextureName( "Normals" );

                        sgMaterial.AddMaterialChannel( "Normals" );
                        sgMaterial.SetShadingNetwork( "Normals", sgNormalsTextureShadingNode );
                    }
                    using(Simplygon.spTexture sgOpacityTexture = sg.CreateTexture())
                    {
                        sgOpacityTexture.SetName( "Opacity" );
                        sgOpacityTexture.SetFilePath( opacityTextureFilePath );
                        sgTextureTable.AddTexture( sgOpacityTexture );
                    }

                    using(Simplygon.spShadingTextureNode sgOpacityTextureShadingNode = sg.CreateShadingTextureNode())
                    {
                        sgOpacityTextureShadingNode.SetTexCoordLevel( 0 );
                        sgOpacityTextureShadingNode.SetTextureName( "Opacity" );

                        sgMaterial.AddMaterialChannel( "Opacity" );
                        sgMaterial.SetShadingNetwork( "Opacity", sgOpacityTextureShadingNode );
                    }

                    sgMaterialTable.AddMaterial( sgMaterial );

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

                using (Simplygon.spScene sgImpostorScene = sg.CreateScene())
                using (Simplygon.spGeometryData sgImpostorGeometry = sgImpostorProcessor.GetImpostorGeometryFromSingleView())
                {
                    sgImpostorScene.GetRootNode().CreateChildMesh(sgImpostorGeometry);
                    sgImpostorScene.GetMaterialTable().Copy(sgScene.GetMaterialTable());
                    sgImpostorScene.GetTextureTable().Copy(sgScene.GetTextureTable());
                    using (Simplygon.spSceneExporter sgSceneExporter = sg.CreateSceneExporter())
                    {
                        sgSceneExporter.SetScene(sgImpostorScene);
                        sgSceneExporter.SetExportFilePath( "ImpostorFromSingleViewOutput.obj" );
                        if(!sgSceneExporter.RunExport())
                            throw new System.Exception("Failed to save ImpostorFromSingleViewOutput.obj.");

                    }
                }
            }
        }
    }
    static int Main(string[] args)
    {
        using (var sg = Simplygon.Loader.InitSimplygon(out var errorCode, out var errorMessage))
        {
            if (errorCode != Simplygon.EErrorCodes.NoError)
                return (int)errorCode;
            RunImpostorFromSingleView(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 simplygon import simplygon_loader
from simplygon import Simplygon


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

    # For all materials in the scene set the blend mode to blend (instead of opaque) 
    materialCount = sgScene.GetMaterialTable().GetMaterialsCount()
    for i in range(0, materialCount):
        sgScene.GetMaterialTable().GetMaterial(i).SetBlendMode(Simplygon.EMaterialBlendMode_Blend)

    # Create the Impostor processor. 
    sgImpostorProcessor = sg.CreateImpostorProcessor()

    sgImpostorProcessor.SetScene( sgScene )

    sgImpostorSettings = sgImpostorProcessor.GetImpostorSettings()

    # Set impostor type to From single view. 
    sgImpostorSettings.SetImpostorType( Simplygon.EImpostorType_FromSingleView )

    viewDir = [0.0, 0.0, -1.0]

    sgImpostorFromSingleViewSettings = sgImpostorSettings.GetImpostorFromSingleViewSettings()

    sgImpostorFromSingleViewSettings.SetUseTightFitting( True )
    sgImpostorFromSingleViewSettings.SetTightFittingDepthOffset( 1.0 )
    sgImpostorFromSingleViewSettings.SetTexCoordPadding( 0.01 )
    sgImpostorFromSingleViewSettings.SetViewDirection( viewDir )

    # Once geometry and settings are set, you can calculate the aspect ratio for your textures.
    aspect = sgImpostorProcessor.GetSingleViewAspectRatio()
    if aspect < 0.0:
        raise Exception('Failed to compute aspect ratio!.')
    xDim = int(aspect * 512)
    yDim = int(1.0 * 512)

    sgMappingImageSettings = sgImpostorProcessor.GetMappingImageSettings()

    sgMappingImageSettings.SetMaximumLayers( 10 )

    sgOutputMaterialSettings = sgMappingImageSettings.GetOutputMaterialSettings(0)

    # Setting the size of the output material for the mapping image. This will be the output size of the 
    # textures when we do material casting in a later stage. 
    sgOutputMaterialSettings.SetTextureWidth( xDim )
    sgOutputMaterialSettings.SetTextureHeight( yDim )
    sgOutputMaterialSettings.SetMultisamplingLevel( 2 )

    # Start the impostor process. 
    sgImpostorProcessor.RunProcessing()

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

    sgDiffuseCasterSettings = sgDiffuseCaster.GetColorCasterSettings()
    sgDiffuseCasterSettings.SetMaterialChannel( 'Diffuse' )
    sgDiffuseCasterSettings.SetOutputImageFileFormat( Simplygon.EImageOutputFormat_PNG )
    sgDiffuseCasterSettings.SetBakeOpacityInAlpha( False )
    sgDiffuseCasterSettings.SetOutputPixelFormat( Simplygon.EPixelFormat_R8G8B8 )
    sgDiffuseCasterSettings.SetDilation( 10 )
    sgDiffuseCasterSettings.SetFillMode( Simplygon.EAtlasFillMode_Interpolate )

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

    # Setup and run the specular material casting. 
    sgSpecularCaster = sg.CreateColorCaster()
    sgSpecularCaster.SetMappingImage( sgImpostorProcessor.GetMappingImage() )
    sgSpecularCaster.SetSourceMaterials( sgScene.GetMaterialTable() )
    sgSpecularCaster.SetSourceTextures( sgScene.GetTextureTable() )
    sgSpecularCaster.SetOutputFilePath( 'SpecularTexture' )

    sgSpecularCasterSettings = sgSpecularCaster.GetColorCasterSettings()
    sgSpecularCasterSettings.SetMaterialChannel( 'Specular' )
    sgSpecularCasterSettings.SetOutputImageFileFormat( Simplygon.EImageOutputFormat_PNG )
    sgSpecularCasterSettings.SetDilation( 10 )
    sgSpecularCasterSettings.SetFillMode( Simplygon.EAtlasFillMode_Interpolate )

    sgSpecularCaster.RunProcessing()
    specularTextureFilePath = sgSpecularCaster.GetOutputFilePath()

    # Setup and run the normals material casting. 
    sgNormalsCaster = sg.CreateNormalCaster()
    sgNormalsCaster.SetMappingImage( sgImpostorProcessor.GetMappingImage() )
    sgNormalsCaster.SetSourceMaterials( sgScene.GetMaterialTable() )
    sgNormalsCaster.SetSourceTextures( sgScene.GetTextureTable() )
    sgNormalsCaster.SetOutputFilePath( 'NormalsTexture' )

    sgNormalsCasterSettings = sgNormalsCaster.GetNormalCasterSettings()
    sgNormalsCasterSettings.SetMaterialChannel( 'Normals' )
    sgNormalsCasterSettings.SetGenerateTangentSpaceNormals( True )
    sgNormalsCasterSettings.SetOutputImageFileFormat( Simplygon.EImageOutputFormat_PNG )
    sgNormalsCasterSettings.SetDilation( 10 )
    sgNormalsCasterSettings.SetFillMode( Simplygon.EAtlasFillMode_Interpolate )

    sgNormalsCaster.RunProcessing()
    normalsTextureFilePath = sgNormalsCaster.GetOutputFilePath()

    # Setup and run the opacity material casting. Make sure the there is no dilation or fill. 
    sgOpacityCaster = sg.CreateOpacityCaster()
    sgOpacityCaster.SetMappingImage( sgImpostorProcessor.GetMappingImage() )
    sgOpacityCaster.SetSourceMaterials( sgScene.GetMaterialTable() )
    sgOpacityCaster.SetSourceTextures( sgScene.GetTextureTable() )
    sgOpacityCaster.SetOutputFilePath( 'OpacityTexture' )

    sgOpacityCasterSettings = sgOpacityCaster.GetOpacityCasterSettings()
    sgOpacityCasterSettings.SetMaterialChannel( 'Opacity' )
    sgOpacityCasterSettings.SetOutputImageFileFormat( Simplygon.EImageOutputFormat_PNG )
    sgOpacityCasterSettings.SetDilation( 0 )
    sgOpacityCasterSettings.SetFillMode( Simplygon.EAtlasFillMode_NoFill )
    sgOpacityCasterSettings.SetOutputPixelFormat( Simplygon.EPixelFormat_R8 )

    sgOpacityCaster.RunProcessing()
    opacityTextureFilePath = sgOpacityCaster.GetOutputFilePath()

    # Update scene with new casted textures. 
    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 )
    sgSpecularTexture = sg.CreateTexture()
    sgSpecularTexture.SetName( 'Specular' )
    sgSpecularTexture.SetFilePath( specularTextureFilePath )
    sgTextureTable.AddTexture( sgSpecularTexture )

    sgSpecularTextureShadingNode = sg.CreateShadingTextureNode()
    sgSpecularTextureShadingNode.SetTexCoordLevel( 0 )
    sgSpecularTextureShadingNode.SetTextureName( 'Specular' )

    sgMaterial.AddMaterialChannel( 'Specular' )
    sgMaterial.SetShadingNetwork( 'Specular', sgSpecularTextureShadingNode )
    sgNormalsTexture = sg.CreateTexture()
    sgNormalsTexture.SetName( 'Normals' )
    sgNormalsTexture.SetFilePath( normalsTextureFilePath )
    sgTextureTable.AddTexture( sgNormalsTexture )

    sgNormalsTextureShadingNode = sg.CreateShadingTextureNode()
    sgNormalsTextureShadingNode.SetTexCoordLevel( 0 )
    sgNormalsTextureShadingNode.SetTextureName( 'Normals' )

    sgMaterial.AddMaterialChannel( 'Normals' )
    sgMaterial.SetShadingNetwork( 'Normals', sgNormalsTextureShadingNode )
    sgOpacityTexture = sg.CreateTexture()
    sgOpacityTexture.SetName( 'Opacity' )
    sgOpacityTexture.SetFilePath( opacityTextureFilePath )
    sgTextureTable.AddTexture( sgOpacityTexture )

    sgOpacityTextureShadingNode = sg.CreateShadingTextureNode()
    sgOpacityTextureShadingNode.SetTexCoordLevel( 0 )
    sgOpacityTextureShadingNode.SetTextureName( 'Opacity' )

    sgMaterial.AddMaterialChannel( 'Opacity' )
    sgMaterial.SetShadingNetwork( 'Opacity', sgOpacityTextureShadingNode )

    sgMaterialTable.AddMaterial( sgMaterial )

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

    sgImpostorScene = sg.CreateScene()
    sgImpostorGeometry = sgImpostorProcessor.GetImpostorGeometryFromSingleView()
    sgImpostorScene.GetRootNode().CreateChildMesh(sgImpostorGeometry)
    sgImpostorScene.GetMaterialTable().Copy(sgScene.GetMaterialTable())
    sgImpostorScene.GetTextureTable().Copy(sgScene.GetTextureTable())

    sgSceneExporter = sg.CreateSceneExporter()
    sgSceneExporter.SetScene(sgImpostorScene)
    sgSceneExporter.SetExportFilePath( 'ImpostorFromSingleViewOutput.obj' )
    if not sgSceneExporter.RunExport():
        raise Exception('Failed to save ImpostorFromSingleViewOutput.obj.')


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

    RunImpostorFromSingleView(sg)

    sg = None
    gc.collect()

← Aggregation processor Occlusion mesh processor →