Remeshing processor

The RemeshingProcessor takes an input scene and replaces it with a lightweight proxy geometry that resembles the original, but does not share vertex data or parts of the original mesh data. The remeshed object is created and optimized for a certain on-screen pixel size - which means that holes and parts that are close to each other will have their gaps filled if the distance is below a pixel. At default settings, the proxy mesh is assumed to be viewed from the outside. Any interior mesh that cannot be seen is removed. The result is a very light-weight mesh that is highly optimized for real-time viewing, or to speed up off-line rendering of small objects. Simplygon is capable of remeshing arbitrary geometry, including non-manifold surfaces.

Two separate processors are currently availible, RemeshingProcessor and RemeshingLegacyProcessor, where RemeshingProcessor generally preserves more sharp detail at lower triangle counts and contains newer functionality that is not availible in the Legacy equivalent, like HoleFilling, automatic inside-out remeshing and support for very high OnscreenSize settings at the cost of slightly slower processing at lower OnScreenSizes.

The RemeshingLegacyProcessor is the same as the RemeshingProcessor from Simplygon 8.3.

The remesher has fewer settings than the reducer, and in most cases the generated Mapping image is used to reproduce details on the geometry using baked textures. Most of the time, only the onScreenSize setting needs to be adjusted, apart from the mapping image settings to choose texture quality.

Remeshing processors settings

Simplygon is capable of remeshing arbitrary geometry, including non-manifold surfaces. The resulting geometry is guaranteed to be a closed 2-manifold. The settings contained in the remeshing settings control the parameters of the new mesh that is to be generated.

Following settings objects are available in remeshing processor:

• Geometry culling settings
• Mapping image settings
• Bone reduction settings
• Visibility settings - Only in LegacyRemeshingProcessor for now, will be added to RemeshingProcessor shortly.

Example

This example shows how to use the Remeshing processor.

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

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


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

	// Create the remeshing processor. 
	Simplygon::spRemeshingProcessor sgRemeshingProcessor = sg->CreateRemeshingProcessor();

	sgRemeshingProcessor->SetScene( sgScene );

	Simplygon::spRemeshingSettings sgRemeshingSettings = sgRemeshingProcessor->GetRemeshingSettings();

	// Set on-screen size target for remeshing. 
	sgRemeshingSettings->SetOnScreenSize( 300 );

	// Start the remeshing process. 
	sgRemeshingProcessor->RunProcessing();

	// Remove original materials and textures from the scene as the remeshed object has a new UV. 
	sgScene->GetTextureTable()->Clear();
	sgScene->GetMaterialTable()->Clear();

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

}

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

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

            // Create the remeshing processor. 
            using (Simplygon.spRemeshingProcessor sgRemeshingProcessor = sg.CreateRemeshingProcessor())
            {
                sgRemeshingProcessor.SetScene( sgScene );

                using (Simplygon.spRemeshingSettings sgRemeshingSettings = sgRemeshingProcessor.GetRemeshingSettings())
                {
                    // Set on-screen size target for remeshing. 
                    sgRemeshingSettings.SetOnScreenSize( 300 );

                }
                // Start the remeshing process. 
                sgRemeshingProcessor.RunProcessing();

                // Remove original materials and textures from the scene as the remeshed object has a new UV. 
                sgScene.GetTextureTable().Clear();
                sgScene.GetMaterialTable().Clear();

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

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

    # Create the remeshing processor. 
    sgRemeshingProcessor = sg.CreateRemeshingProcessor()

    sgRemeshingProcessor.SetScene( sgScene )

    sgRemeshingSettings = sgRemeshingProcessor.GetRemeshingSettings()

    # Set on-screen size target for remeshing. 
    sgRemeshingSettings.SetOnScreenSize( 300 )

    # Start the remeshing process. 
    sgRemeshingProcessor.RunProcessing()

    # Remove original materials and textures from the scene as the remeshed object has a new UV. 
    sgScene.GetTextureTable().Clear()
    sgScene.GetMaterialTable().Clear()

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


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

    RunRemeshing(sg)

    sg = None
    gc.collect()