This example shows how to use the Aggregation pipeline with a visibility camera.

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

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


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

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

	Simplygon::spAggregationSettings sgAggregationSettings = sgAggregationPipeline->GetAggregationSettings();
	Simplygon::spVisibilitySettings sgVisibilitySettings = sgAggregationPipeline->GetVisibilitySettings();

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

	// Add a camera to the scene. We'll use this later as a visibility camera. 
	Simplygon::spSelectionSetTable sgSceneSelectionSetTable = sgScene->GetSelectionSetTable();
	Simplygon::spSelectionSet sgCameraSelectionSet = sg->CreateSelectionSet();
	sgCameraSelectionSet->SetName("Camera");
	Simplygon::spSceneCamera sgCameraSceneCamera = sg->CreateSceneCamera();
	sgCameraSceneCamera->SetCustomSphereCameraPath(4, 90, 180, 90);
	sgScene->GetRootNode()->AddChild(sgCameraSceneCamera);
	sgCameraSelectionSet->AddItem(sgCameraSceneCamera->GetNodeGUID());
	sgSceneSelectionSetTable->AddSelectionSet(sgCameraSelectionSet);

	// Use the camera previously added. 
	sgVisibilitySettings->SetCameraSelectionSetName( "Camera" );

	// Enabled GPU based visibility calculations. 
	sgVisibilitySettings->SetComputeVisibilityMode( Simplygon::EComputeVisibilityMode::DirectX );

	// Disabled conservative mode. 
	sgVisibilitySettings->SetConservativeMode( false );

	// Remove all non visible geometry. 
	sgVisibilitySettings->SetCullOccludedGeometry( true );

	// Skip filling nonvisible regions. 
	sgVisibilitySettings->SetFillNonVisibleAreaThreshold( 0.0f );

	// Don't remove non occluding triangles. 
	sgVisibilitySettings->SetRemoveTrianglesNotOccludingOtherTriangles( false );

	// Remove all back facing triangles. 
	sgVisibilitySettings->SetUseBackfaceCulling( true );

	// Don't use visibility weights. 
	sgVisibilitySettings->SetUseVisibilityWeightsInReducer( false );

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

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

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

                    // Add a camera to the scene. We'll use this later as a visibility camera. 
                    using (Simplygon.spSelectionSetTable sgSceneSelectionSetTable = sgScene.GetSelectionSetTable())
                    using (Simplygon.spSelectionSet sgCameraSelectionSet = sg.CreateSelectionSet())
                    {
                        sgCameraSelectionSet.SetName("Camera");
                        using (Simplygon.spSceneCamera sgCameraSceneCamera = sg.CreateSceneCamera())
                        {
                            sgCameraSceneCamera.SetCustomSphereCameraPath(4, 90, 180, 90);
                            sgScene.GetRootNode().AddChild(sgCameraSceneCamera);
                            sgCameraSelectionSet.AddItem(sgCameraSceneCamera.GetNodeGUID());
                        }
                        sgSceneSelectionSetTable.AddSelectionSet(sgCameraSelectionSet);
                    }

                    // Use the camera previously added. 
                    sgVisibilitySettings.SetCameraSelectionSetName( "Camera" );

                    // Enabled GPU based visibility calculations. 
                    sgVisibilitySettings.SetComputeVisibilityMode( Simplygon.EComputeVisibilityMode.DirectX );

                    // Disabled conservative mode. 
                    sgVisibilitySettings.SetConservativeMode( false );

                    // Remove all non visible geometry. 
                    sgVisibilitySettings.SetCullOccludedGeometry( true );

                    // Skip filling nonvisible regions. 
                    sgVisibilitySettings.SetFillNonVisibleAreaThreshold( 0.0f );

                    // Don't remove non occluding triangles. 
                    sgVisibilitySettings.SetRemoveTrianglesNotOccludingOtherTriangles( false );

                    // Remove all back facing triangles. 
                    sgVisibilitySettings.SetUseBackfaceCulling( true );

                    // Don't use visibility weights. 
                    sgVisibilitySettings.SetUseVisibilityWeightsInReducer( false );

                }
                // 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;
            RunAggregation(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 RunAggregation(sg: Simplygon.ISimplygon):
    sgSceneImporter = sg.CreateSceneImporter()
    sgSceneImporter.SetImportFilePath( '../Assets/ObscuredTeapot/Teapot.obj' )
    if not sgSceneImporter.RunImport():
        raise Exception('Failed to load ObscuredTeapot/Teapot.obj.')
    sgScene = sgSceneImporter.GetScene()

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

    sgAggregationSettings = sgAggregationPipeline.GetAggregationSettings()
    sgVisibilitySettings = sgAggregationPipeline.GetVisibilitySettings()

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

    # Add a camera to the scene. We'll use this later as a visibility camera. 
    sgSceneSelectionSetTable = sgScene.GetSelectionSetTable()
    sgCameraSelectionSet = sg.CreateSelectionSet()
    sgCameraSelectionSet.SetName('Camera')
    sgCameraSceneCamera = sg.CreateSceneCamera()
    sgCameraSceneCamera.SetCustomSphereCameraPath(4, 90, 180, 90)
    sgScene.GetRootNode().AddChild(sgCameraSceneCamera)
    sgCameraSelectionSet.AddItem(sgCameraSceneCamera.GetNodeGUID())
    sgSceneSelectionSetTable.AddSelectionSet(sgCameraSelectionSet)

    # Use the camera previously added. 
    sgVisibilitySettings.SetCameraSelectionSetName( "Camera" )

    # Enabled GPU based visibility calculations. 
    sgVisibilitySettings.SetComputeVisibilityMode( Simplygon.EComputeVisibilityMode_DirectX )

    # Disabled conservative mode. 
    sgVisibilitySettings.SetConservativeMode( False )

    # Remove all non visible geometry. 
    sgVisibilitySettings.SetCullOccludedGeometry( True )

    # Skip filling nonvisible regions. 
    sgVisibilitySettings.SetFillNonVisibleAreaThreshold( 0.0 )

    # Don't remove non occluding triangles. 
    sgVisibilitySettings.SetRemoveTrianglesNotOccludingOtherTriangles( False )

    # Remove all back facing triangles. 
    sgVisibilitySettings.SetUseBackfaceCulling( True )

    # Don't use visibility weights. 
    sgVisibilitySettings.SetUseVisibilityWeightsInReducer( False )

    # 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()
    if sg is not None:

        RunAggregation(sg)

    sg = None
    gc.collect()