Simplygon Grid

In Simplygon 9 we have simplified Grid and has removed a lot of overhead. Instead of a server/client based approch, Grid is now using mDNS broadcast to locate Grid agents. To submit a processing job to available Grid agents on your network, all you need to do is to create a pipeline using C++, C# or Python or use the Simplygon UI in our integrations and select Grid as the distribution target.
Here is an example of a simple batch script using Grid.

This example shows how to do batch processing using Simplygon Grid.

// 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, std::string inputFile, std::string outputFile)
{
	// Create the reduction pipeline. 
	Simplygon::spReductionPipeline sgReductionPipeline = sg->CreateReductionPipeline();

	Simplygon::spReductionSettings sgReductionSettings = sgReductionPipeline->GetReductionSettings();

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

	// Start the reduction pipeline. 
	sgReductionPipeline->RunSceneFromFile(inputFile.c_str(), outputFile.c_str(), Simplygon::EPipelineRunMode::RunDistributedUsingSimplygonGrid);

}

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

	std::vector<std::future<void>> jobs;
	for(auto& itr: std::filesystem::recursive_directory_iterator("../Assets/"))
	{
		if (itr.path().extension().compare(".gltf") != 0)
			continue;
		std::string inputFile = itr.path().generic_u8string();
		std::string outputFile = itr.path().stem().concat("_LOD").concat( itr.path().extension().generic_u8string() ).generic_u8string();

		jobs.push_back( std::async( [](Simplygon::ISimplygon * sg, std::string inputFile, std::string outputFile)
		{
			RunReduction(sg, inputFile, outputFile);
		}, sg, inputFile, outputFile ));

	}
	for(auto& job: jobs)
	{
		job.wait();
	}

	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 RunReduction(Simplygon.ISimplygon sg, string inputFile, string outputFile)
    {
        // Create the reduction pipeline. 
        using (Simplygon.spReductionPipeline sgReductionPipeline = sg.CreateReductionPipeline())
        {
            using (Simplygon.spReductionSettings sgReductionSettings = sgReductionPipeline.GetReductionSettings())
            {
                // Set reduction target to triangle ratio with a ratio of 50%. 
                sgReductionSettings.SetReductionTargets( Simplygon.EStopCondition.All, true, false, false, false );
                sgReductionSettings.SetReductionTargetTriangleRatio( 0.5f );

            }
            // Start the reduction pipeline. 
            sgReductionPipeline.RunSceneFromFile(inputFile, outputFile, Simplygon.EPipelineRunMode.RunDistributedUsingSimplygonGrid);

        }
    }
    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;
            var inputFiles = Directory.EnumerateFiles("../Assets/", "*.gltf", SearchOption.AllDirectories);
            Parallel.ForEach(inputFiles, (inputFile) =>
            {
                string outputFile = Path.Combine(Path.GetFileNameWithoutExtension(inputFile) + "_LOD" + Path.GetExtension(inputFile));
                RunReduction(sg, inputFile, outputFile);
            });
        }

        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 RunReduction(sg: Simplygon.ISimplygon, inputFile, outputFile):
    # Create the reduction pipeline. 
    sgReductionPipeline = sg.CreateReductionPipeline()

    sgReductionSettings = sgReductionPipeline.GetReductionSettings()

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

    # Start the reduction pipeline. 
    sgReductionPipeline.RunSceneFromFile(inputFile, outputFile, Simplygon.EPipelineRunMode_RunDistributedUsingSimplygonGrid)


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

    jobs = list()
    inputFiles = glob.glob('../Assets/' + '/**/*.gltf', recursive=True)
    for inputFile in inputFiles:
        outputFile = Path(inputFile).stem + '_LOD' + Path(inputFile).suffix
        job = threading.Thread(target=RunReduction, args=(sg, inputFile, outputFile))
        jobs.append(job)
        job.start()

    for job in jobs:
        job.join()

    sg = None
    gc.collect()