# Normal calculation settings

After reduction has completed, the reducer can optionally generate new normals on the reduced geometry. These settings control how these new normals are calculated.

# Supported processors

Reduction processor

# Example - Use normal calculation settings

The following example shows how to use the normal calculation settings in the reducer.

# Example

This example shows how to use the Reduction processor with normal calculation settings.

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

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


void RunReduction(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 reduction processor. 
	Simplygon::spReductionProcessor sgReductionProcessor = sg->CreateReductionProcessor();

	sgReductionProcessor->SetScene( sgScene );

	Simplygon::spReductionSettings sgReductionSettings = sgReductionProcessor->GetReductionSettings();
	Simplygon::spNormalCalculationSettings sgNormalCalculationSettings = sgReductionProcessor->GetNormalCalculationSettings();

	// Set reduction target to triangle ratio with a ratio of 50%. 
	sgReductionSettings->SetReductionTargets( Simplygon::EStopCondition::All, true, false, false, false );
	sgReductionSettings->SetReductionTargetTriangleRatio( 0.5f );

	// The angle in degrees determing the normal smoothness. 
	sgNormalCalculationSettings->SetHardEdgeAngle( 75 );

	// Reorthogonalize the tangentspace after the reduction. 
	sgNormalCalculationSettings->SetReorthogonalizeTangentSpace( true );

	// Repair invalid normals. 
	sgNormalCalculationSettings->SetRepairInvalidNormals( true );

	// Don't generate new normals. However invalid normals will still be repaired. 
	sgNormalCalculationSettings->SetReplaceNormals( false );

	// Don't generate new tangents and bitangents. 
	sgNormalCalculationSettings->SetReplaceTangents( false );

	// Scale the vertex normal based on the triangle area. 
	sgNormalCalculationSettings->SetScaleByAngle( false );
	sgNormalCalculationSettings->SetScaleByArea( true );

	// Don't snap the normal to flat surfaces. 
	sgNormalCalculationSettings->SetSnapNormalsToFlatSurfaces( false );

	// Start the reduction process. 
	sgReductionProcessor->RunProcessing();

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

}

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

	RunReduction(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 RunReduction(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 reduction processor. 
            using (Simplygon.spReductionProcessor sgReductionProcessor = sg.CreateReductionProcessor())
            {
                sgReductionProcessor.SetScene( sgScene );

                using (Simplygon.spReductionSettings sgReductionSettings = sgReductionProcessor.GetReductionSettings())
                using (Simplygon.spNormalCalculationSettings sgNormalCalculationSettings = sgReductionProcessor.GetNormalCalculationSettings())
                {
                    // Set reduction target to triangle ratio with a ratio of 50%. 
                    sgReductionSettings.SetReductionTargets( Simplygon.EStopCondition.All, true, false, false, false );
                    sgReductionSettings.SetReductionTargetTriangleRatio( 0.5f );

                    // The angle in degrees determing the normal smoothness. 
                    sgNormalCalculationSettings.SetHardEdgeAngle( 75 );

                    // Reorthogonalize the tangentspace after the reduction. 
                    sgNormalCalculationSettings.SetReorthogonalizeTangentSpace( true );

                    // Repair invalid normals. 
                    sgNormalCalculationSettings.SetRepairInvalidNormals( true );

                    // Don't generate new normals. However invalid normals will still be repaired. 
                    sgNormalCalculationSettings.SetReplaceNormals( false );

                    // Don't generate new tangents and bitangents. 
                    sgNormalCalculationSettings.SetReplaceTangents( false );

                    // Scale the vertex normal based on the triangle area. 
                    sgNormalCalculationSettings.SetScaleByAngle( false );
                    sgNormalCalculationSettings.SetScaleByArea( true );

                    // Don't snap the normal to flat surfaces. 
                    sgNormalCalculationSettings.SetSnapNormalsToFlatSurfaces( false );

                }
                // Start the reduction process. 
                sgReductionProcessor.RunProcessing();

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

            }
        }
    }
    static void Main(string[] args)
    {
        using (var sg = Simplygon.Loader.InitSimplygon(out var errorCode, out var errorMessage))
        {
            if (errorCode != Simplygon.EErrorCodes.NoError)
                return;
            RunReduction(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 RunReduction(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 reduction processor. 
    sgReductionProcessor = sg.CreateReductionProcessor()

    sgReductionProcessor.SetScene( sgScene )

    sgReductionSettings = sgReductionProcessor.GetReductionSettings()
    sgNormalCalculationSettings = sgReductionProcessor.GetNormalCalculationSettings()

    # Set reduction target to triangle ratio with a ratio of 50%. 
    sgReductionSettings.SetReductionTargets( Simplygon.EStopCondition_All, True, False, False, False )
    sgReductionSettings.SetReductionTargetTriangleRatio( 0.5 )

    # The angle in degrees determing the normal smoothness. 
    sgNormalCalculationSettings.SetHardEdgeAngle( 75 )

    # Reorthogonalize the tangentspace after the reduction. 
    sgNormalCalculationSettings.SetReorthogonalizeTangentSpace( True )

    # Repair invalid normals. 
    sgNormalCalculationSettings.SetRepairInvalidNormals( True )

    # Don't generate new normals. However invalid normals will still be repaired. 
    sgNormalCalculationSettings.SetReplaceNormals( False )

    # Don't generate new tangents and bitangents. 
    sgNormalCalculationSettings.SetReplaceTangents( False )

    # Scale the vertex normal based on the triangle area. 
    sgNormalCalculationSettings.SetScaleByAngle( False )
    sgNormalCalculationSettings.SetScaleByArea( True )

    # Don't snap the normal to flat surfaces. 
    sgNormalCalculationSettings.SetSnapNormalsToFlatSurfaces( False )

    # Start the reduction process. 
    sgReductionProcessor.RunProcessing()

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


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

        RunReduction(sg)

    sg = None
    gc.collect()

← Repair settings Geometry culling settings →