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