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

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


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

	// Create the aggregation pipeline. 
	Simplygon::spAggregationPipeline sgAggregationPipeline = sg->CreateAggregationPipeline();

	Simplygon::spAggregationSettings sgAggregationSettings = sgAggregationPipeline->GetAggregationSettings();
	Simplygon::spMappingImageSettings sgMappingImageSettings = sgAggregationPipeline->GetMappingImageSettings();

	// Merge all geometries into a single geometry. 
	sgAggregationSettings->SetMergeGeometries( true );

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

	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( 2048 );
	sgOutputMaterialSettings->SetTextureHeight( 2048 );

	// Add diffuse material caster to pipeline. 
	Simplygon::spColorCaster sgDiffuseCaster = sg->CreateColorCaster();

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

	sgAggregationPipeline->AddMaterialCaster( sgDiffuseCaster, 0 );

	// Add normals material caster to pipeline. 
	Simplygon::spNormalCaster sgNormalsCaster = sg->CreateNormalCaster();

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

	sgAggregationPipeline->AddMaterialCaster( sgNormalsCaster, 0 );

	// Start the aggregation pipeline. 
	sgAggregationPipeline->RunScene(sgScene, Simplygon::EPipelineRunMode::RunInThisProcess);

	// Get the processed scene. 
	Simplygon::spScene sgProcessedScene = sgAggregationPipeline->GetProcessedScene();

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

}

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

	RunAggregationWithMaterialCasting(sg);

	Simplygon::Deinitialize(sg);
}

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

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

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

            // Create the aggregation pipeline. 
            using (Simplygon.spAggregationPipeline sgAggregationPipeline = sg.CreateAggregationPipeline())
            {
                using (Simplygon.spAggregationSettings sgAggregationSettings = sgAggregationPipeline.GetAggregationSettings())
                using (Simplygon.spMappingImageSettings sgMappingImageSettings = sgAggregationPipeline.GetMappingImageSettings())
                {
                    // Merge all geometries into a single geometry. 
                    sgAggregationSettings.SetMergeGeometries( true );

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

                    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( 2048 );
                        sgOutputMaterialSettings.SetTextureHeight( 2048 );

                    }
                }
                // Add diffuse material caster to pipeline. 
                using (Simplygon.spColorCaster sgDiffuseCaster = sg.CreateColorCaster())
                {
                    using (Simplygon.spColorCasterSettings sgDiffuseCasterSettings = sgDiffuseCaster.GetColorCasterSettings())
                    {
                        sgDiffuseCasterSettings.SetMaterialChannel( "Diffuse" );
                        sgDiffuseCasterSettings.SetOutputImageFileFormat( Simplygon.EImageOutputFormat.PNG );
                    }

                    sgAggregationPipeline.AddMaterialCaster( sgDiffuseCaster, 0 );
                }

                // Add normals material caster to pipeline. 
                using (Simplygon.spNormalCaster sgNormalsCaster = sg.CreateNormalCaster())
                {
                    using (Simplygon.spNormalCasterSettings sgNormalsCasterSettings = sgNormalsCaster.GetNormalCasterSettings())
                    {
                        sgNormalsCasterSettings.SetMaterialChannel( "Normals" );
                        sgNormalsCasterSettings.SetGenerateTangentSpaceNormals( true );
                        sgNormalsCasterSettings.SetOutputImageFileFormat( Simplygon.EImageOutputFormat.PNG );
                    }

                    sgAggregationPipeline.AddMaterialCaster( sgNormalsCaster, 0 );
                }

                // Start the aggregation pipeline. 
                sgAggregationPipeline.RunScene(sgScene, Simplygon.EPipelineRunMode.RunInThisProcess);

                // Get the processed scene. 
                using (Simplygon.spScene sgProcessedScene = sgAggregationPipeline.GetProcessedScene())
                {
                    using (Simplygon.spSceneExporter sgSceneExporter = sg.CreateSceneExporter())
                    {
                        sgSceneExporter.SetScene(sgProcessedScene);
                        sgSceneExporter.SetExportFilePath( "AggregationOutput.fbx" );
                        if(!sgSceneExporter.RunExport())
                            throw new System.Exception("Failed to save AggregationOutput.fbx.");

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

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

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

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


def RunAggregationWithMaterialCasting(sg: Simplygon.ISimplygon):
    sgSceneImporter = sg.CreateSceneImporter()
    sgSceneImporter.SetImportFilePath( "../Assets/RiggedSimplygonMan/RiggedSimplygonMan.fbx" )
    if not sgSceneImporter.RunImport():
        raise Exception("Failed to load RiggedSimplygonMan/RiggedSimplygonMan.fbx.")
    sgScene = sgSceneImporter.GetScene()

    # Create the aggregation pipeline. 
    sgAggregationPipeline = sg.CreateAggregationPipeline()

    sgAggregationSettings = sgAggregationPipeline.GetAggregationSettings()
    sgMappingImageSettings = sgAggregationPipeline.GetMappingImageSettings()

    # Merge all geometries into a single geometry. 
    sgAggregationSettings.SetMergeGeometries( True )

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

    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( 2048 )
    sgOutputMaterialSettings.SetTextureHeight( 2048 )

    # Add diffuse material caster to pipeline. 
    sgDiffuseCaster = sg.CreateColorCaster()
    sgDiffuseCasterSettings = sgDiffuseCaster.GetColorCasterSettings()
    sgDiffuseCasterSettings.SetMaterialChannel( "Diffuse" )
    sgDiffuseCasterSettings.SetOutputImageFileFormat( Simplygon.EImageOutputFormat_PNG )

    sgAggregationPipeline.AddMaterialCaster( sgDiffuseCaster, 0 )

    # Add normals material caster to pipeline. 
    sgNormalsCaster = sg.CreateNormalCaster()
    sgNormalsCasterSettings = sgNormalsCaster.GetNormalCasterSettings()
    sgNormalsCasterSettings.SetMaterialChannel( "Normals" )
    sgNormalsCasterSettings.SetGenerateTangentSpaceNormals( True )
    sgNormalsCasterSettings.SetOutputImageFileFormat( Simplygon.EImageOutputFormat_PNG )

    sgAggregationPipeline.AddMaterialCaster( sgNormalsCaster, 0 )

    # Start the aggregation pipeline. 
    sgAggregationPipeline.RunScene(sgScene, Simplygon.EPipelineRunMode_RunInThisProcess)

    # Get the processed scene. 
    sgProcessedScene = sgAggregationPipeline.GetProcessedScene()

    sgSceneExporter = sg.CreateSceneExporter()
    sgSceneExporter.SetScene(sgProcessedScene)
    sgSceneExporter.SetExportFilePath( "AggregationOutput.fbx" )
    if not sgSceneExporter.RunExport():
        raise Exception("Failed to save AggregationOutput.fbx.")


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

    RunAggregationWithMaterialCasting(sg)

    sg = None
    gc.collect()