This example shows how to use the ClusteredMeshletOptimizer to generate a mesh suitable form meshlet rendering.

cpp

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

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


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

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

void RunClusteredMeshletOptimizer(Simplygon::ISimplygon* sg)
{
	// Load scene to process. 	
	printf("%s\n", "Load scene to process.");
	Simplygon::spScene sgScene = LoadScene(sg, "../../../Assets/QuadFace/SgFace.obj");
	
	// Get geometry from scene.  
	// Notice that the geometry needs to be in packed format for the ClusteredMeshletOptimizer to be 
	// able to process it. 
	Simplygon::spSceneNode sgNode = sgScene->GetNodeFromPath("Root/default");
	Simplygon::spSceneMesh sgSceneMesh = Simplygon::spSceneMesh::SafeCast(sgNode);
	Simplygon::spPackedGeometryData sgPackedGeometryData = sgSceneMesh->GetGeometry()->NewPackedCopy();
	
	// Create the meshlet optimizer. 
	Simplygon::spClusteredMeshletOptimizer sgClusteredMeshletOptimizer = sg->CreateClusteredMeshletOptimizer();
	
	// Configure the meshlet optimizer and set the geometry as input. 
	// MaxVerticesPerMeshlet: The maximum number of vertices allowed in each meshlet. 
	// MaxTrianglesPerMeshlet: The maximum number of triangles allowed in each meshlet. 
	// SplitMeshletsByMaterial: If true, meshlets will not contain triangles from different 
	// materials.UseNonContiguousGrouping: If true, triangles in a meshlet can be non-contiguous 
	// (not sharing a continuous outer edge). This allows for better packing of triangles into 
	// meshlets. 
	sgClusteredMeshletOptimizer->SetMaxVerticesPerMeshlet( 256 );
	sgClusteredMeshletOptimizer->SetMaxTrianglesPerMeshlet( 128 );
	sgClusteredMeshletOptimizer->SetSplitMeshletsByMaterial( false );
	sgClusteredMeshletOptimizer->SetUseNonContiguousGrouping( true );
	sgClusteredMeshletOptimizer->SetGeometry( sgPackedGeometryData );
	
	// Run the meshlet optimizer. 
	sgClusteredMeshletOptimizer->Run();
	
	// Fetch some meshlet data structures from the processed geometry. 
	Simplygon::spValueArray sgMeshletTrianglesRaw = sgPackedGeometryData->GetCustomFields()->FindValueArray("cmo:MeshletTriangles");
	Simplygon::spValueArray sgLevelMeshletsRaw = sgPackedGeometryData->GetCustomFields()->FindValueArray("cmo:LevelMeshlets");
	Simplygon::spUnsignedIntArray sgMeshletTriangles = Simplygon::spUnsignedIntArray::SafeCast(sgMeshletTrianglesRaw);
	Simplygon::spUnsignedIntArray sgLevelMeshlets = Simplygon::spUnsignedIntArray::SafeCast(sgLevelMeshletsRaw);
	
	// This test does not implement any rendering of the generated meshlets. We will have to settle 
	// with just printing out some information about the generated meshlets to verify that the 
	// process ran. 
	auto meshletCount = sgMeshletTriangles->GetTupleCount();
	std::string meshletInfo = std::string("Number of generated meshlets: ") + std::string(std::to_string(meshletCount).c_str());
	printf("%s\n", meshletInfo.c_str());
	auto levelCount = sgLevelMeshlets->GetTupleCount();
	std::string levelInfo = std::string("Number of generated levels: ") + std::string(std::to_string(levelCount).c_str());
	printf("%s\n", levelInfo.c_str());
	
	// Check log for any warnings or errors. 
	CheckLog(sg);
}

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

	RunClusteredMeshletOptimizer(sg);

	Simplygon::Deinitialize(sg);

	return 0;
}

csharp

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

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

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

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

    static void RunClusteredMeshletOptimizer(Simplygon.ISimplygon sg)
    {
        // Load scene to process.         
        Console.WriteLine("Load scene to process.");
        Simplygon.spScene sgScene = LoadScene(sg, "../../../Assets/QuadFace/SgFace.obj");
        
        // Get geometry from scene.  
        // Notice that the geometry needs to be in packed format for the ClusteredMeshletOptimizer to be 
        // able to process it. 
        Simplygon.spSceneNode sgNode = sgScene.GetNodeFromPath("Root/default");
        Simplygon.spSceneMesh sgSceneMesh = Simplygon.spSceneMesh.SafeCast(sgNode);
        Simplygon.spPackedGeometryData sgPackedGeometryData = sgSceneMesh.GetGeometry().NewPackedCopy();
        
        // Create the meshlet optimizer. 
        using Simplygon.spClusteredMeshletOptimizer sgClusteredMeshletOptimizer = sg.CreateClusteredMeshletOptimizer();
        
        // Configure the meshlet optimizer and set the geometry as input. 
        // MaxVerticesPerMeshlet: The maximum number of vertices allowed in each meshlet. 
        // MaxTrianglesPerMeshlet: The maximum number of triangles allowed in each meshlet. 
        // SplitMeshletsByMaterial: If true, meshlets will not contain triangles from different 
        // materials.UseNonContiguousGrouping: If true, triangles in a meshlet can be non-contiguous 
        // (not sharing a continuous outer edge). This allows for better packing of triangles into 
        // meshlets. 
        sgClusteredMeshletOptimizer.SetMaxVerticesPerMeshlet( 256 );
        sgClusteredMeshletOptimizer.SetMaxTrianglesPerMeshlet( 128 );
        sgClusteredMeshletOptimizer.SetSplitMeshletsByMaterial( false );
        sgClusteredMeshletOptimizer.SetUseNonContiguousGrouping( true );
        sgClusteredMeshletOptimizer.SetGeometry( sgPackedGeometryData );
        
        // Run the meshlet optimizer. 
        sgClusteredMeshletOptimizer.Run();
        
        // Fetch some meshlet data structures from the processed geometry. 
        Simplygon.spValueArray sgMeshletTrianglesRaw = sgPackedGeometryData.GetCustomFields().FindValueArray("cmo:MeshletTriangles");
        Simplygon.spValueArray sgLevelMeshletsRaw = sgPackedGeometryData.GetCustomFields().FindValueArray("cmo:LevelMeshlets");
        Simplygon.spUnsignedIntArray sgMeshletTriangles = Simplygon.spUnsignedIntArray.SafeCast(sgMeshletTrianglesRaw);
        Simplygon.spUnsignedIntArray sgLevelMeshlets = Simplygon.spUnsignedIntArray.SafeCast(sgLevelMeshletsRaw);
        
        // This test does not implement any rendering of the generated meshlets. We will have to settle 
        // with just printing out some information about the generated meshlets to verify that the 
        // process ran. 
        var meshletCount = sgMeshletTriangles.GetTupleCount();
        string meshletInfo = string.Join("", new string[] { "Number of generated meshlets: ", meshletCount.ToString() });
        Console.WriteLine(meshletInfo);
        var levelCount = sgLevelMeshlets.GetTupleCount();
        string levelInfo = string.Join("", new string[] { "Number of generated levels: ", levelCount.ToString() });
        Console.WriteLine(levelInfo);
        
        // Check log for any warnings or errors. 
        CheckLog(sg);
    }

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

        return 0;
    }

}

python

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

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

from pathlib import Path
from simplygon10 import simplygon_loader
from simplygon10 import Simplygon


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

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

def RunClusteredMeshletOptimizer(sg: Simplygon.ISimplygon):
    # Load scene to process.     
    print("Load scene to process.")
    sgScene = LoadScene(sg, '../../../Assets/QuadFace/SgFace.obj')
    
    # Get geometry from scene.  
    # Notice that the geometry needs to be in packed format for the ClusteredMeshletOptimizer to be 
    # able to process it. 
    sgNode = sgScene.GetNodeFromPath('Root/default')
    sgSceneMesh = Simplygon.spSceneMesh.SafeCast(sgNode)
    sgPackedGeometryData = sgSceneMesh.GetGeometry().NewPackedCopy()
    
    # Create the meshlet optimizer. 
    sgClusteredMeshletOptimizer = sg.CreateClusteredMeshletOptimizer()
    
    # Configure the meshlet optimizer and set the geometry as input. 
    # MaxVerticesPerMeshlet: The maximum number of vertices allowed in each meshlet. 
    # MaxTrianglesPerMeshlet: The maximum number of triangles allowed in each meshlet. 
    # SplitMeshletsByMaterial: If true, meshlets will not contain triangles from different 
    # materials.UseNonContiguousGrouping: If true, triangles in a meshlet can be non-contiguous 
    # (not sharing a continuous outer edge). This allows for better packing of triangles into 
    # meshlets. 
    sgClusteredMeshletOptimizer.SetMaxVerticesPerMeshlet( 256 )
    sgClusteredMeshletOptimizer.SetMaxTrianglesPerMeshlet( 128 )
    sgClusteredMeshletOptimizer.SetSplitMeshletsByMaterial( False )
    sgClusteredMeshletOptimizer.SetUseNonContiguousGrouping( True )
    sgClusteredMeshletOptimizer.SetGeometry( sgPackedGeometryData )
    
    # Run the meshlet optimizer. 
    sgClusteredMeshletOptimizer.Run()
    
    # Fetch some meshlet data structures from the processed geometry. 
    sgMeshletTrianglesRaw = sgPackedGeometryData.GetCustomFields().FindValueArray('cmo:MeshletTriangles')
    sgLevelMeshletsRaw = sgPackedGeometryData.GetCustomFields().FindValueArray('cmo:LevelMeshlets')
    sgMeshletTriangles = Simplygon.spUnsignedIntArray.SafeCast(sgMeshletTrianglesRaw)
    sgLevelMeshlets = Simplygon.spUnsignedIntArray.SafeCast(sgLevelMeshletsRaw)
    
    # This test does not implement any rendering of the generated meshlets. We will have to settle 
    # with just printing out some information about the generated meshlets to verify that the 
    # process ran. 
    meshletCount = sgMeshletTriangles.GetTupleCount()
    meshletInfo = ''.join(['Number of generated meshlets: ', str(meshletCount)])
    print(meshletInfo)
    levelCount = sgLevelMeshlets.GetTupleCount()
    levelInfo = ''.join(['Number of generated levels: ', str(levelCount)])
    print(levelInfo)
    
    # Check log for any warnings or errors. 
    CheckLog(sg)

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

        RunClusteredMeshletOptimizer(sg)

        sg = None
        gc.collect()