Aspose.3D FOSS
TypeScript
Comment optimiser les modèles 3D en TypeScript

Comment optimiser les modèles 3D en TypeScript

Aspose.3D FOSS pour TypeScript propose plusieurs stratégies pour réduire la taille des fichiers de sortie et améliorer le débit de traitement. Ce guide couvre la sélection du format, l’intégration binaire, les pipelines en mémoire et les optimisations au niveau de Node.js.

Guide étape par étape

Étape 1 : Choisissez le bon format de sortie

GLB (binary glTF) produit la sortie la plus compacte avec un bon support d’outils. OBJ est basé sur du texte et plus volumineux. STL est compact pour les flux de travail uniquement géométriques.

FormatTailleInclut les matériauxInclut l’animationMeilleure utilisation
GLBPetitOui (intégré)OuiWeb, jeux, échange général
glTFMoyenOui (séparé)OuiDéveloppement, inspection
STLPetitNonNon3D printing, geometry-only
OBJGrand.mtl séparéNonOutils hérités, compatibilité étendue
FBXMoyenNon*Non*Importer/exporter existe mais n’est pas relié à la détection automatique
3MFPetitOuiNonImpression 3D moderne

Étape 2 : Exporter en GLB binaire

Lors de l’enregistrement au format GLB, définissez GltfSaveOptions.binaryMode = true pour produire un fichier binaire autonome unique. Cela évite le .bin sidecar et est requis pour de nombreux visionneuses 3D :

import { Scene } from '@aspose/3d';
import { ObjLoadOptions } from '@aspose/3d/formats/obj';
import { GltfSaveOptions } from '@aspose/3d/formats/gltf';

const scene = new Scene();
scene.open('complex-model.obj', new ObjLoadOptions());

const opts = new GltfSaveOptions();
opts.binaryMode = true;

scene.save('optimized.glb', opts);
console.log('Saved compact binary GLB');

Étape 3 : Utilisez les entrées/sorties par tampon pour les pipelines en mémoire

Lors du traitement des fichiers dans un service web, utilisez openFromBuffer et saveToBuffer pour éviter d’écrire sur le système de fichiers :

import { Scene } from '@aspose/3d';
import { ObjLoadOptions } from '@aspose/3d/formats/obj';

function convertInMemory(inputBuffer: Buffer): Buffer {
    const scene = new Scene();
    scene.openFromBuffer(inputBuffer, new ObjLoadOptions());
    return scene.saveToBuffer('glb');
}

Étape 4 : Traitement par lots des fichiers avec des threads de travail

Pour les gros travaux de conversion, répartissez le travail sur les threads de travail Node.js afin d’utiliser plusieurs cœurs CPU :

// worker.ts
import { workerData, parentPort } from 'worker_threads';
import { Scene } from '@aspose/3d';
import { ObjLoadOptions } from '@aspose/3d/formats/obj';

const { inputPath, outputPath } = workerData;

const scene = new Scene();
scene.open(inputPath, new ObjLoadOptions());
scene.save(outputPath);

parentPort?.postMessage({ done: true, output: outputPath });
// main.ts: dispatch files to workers
import { Worker } from 'worker_threads';
import * as fs from 'fs';
import * as path from 'path';

const files = fs.readdirSync('./input').filter(f => f.endsWith('.obj'));

for (const file of files) {
    const inputPath = path.join('./input', file);
    const outputPath = path.join('./output', file.replace('.obj', '.glb'));

    const worker = new Worker('./dist/worker.js', {
        workerData: { inputPath, outputPath }
    });

    worker.on('message', msg => console.log(`Converted: ${msg.output}`));
    worker.on('error', err => console.error(`Error: ${err}`));
}

Étape 5 : Surveillez la mémoire pour les modèles volumineux

Pour les fichiers de plus de 50 Mo, surveillez l’utilisation du tas et traitez les fichiers séquentiellement si la mémoire est limitée :

function logMemory(label: string) {
    const used = process.memoryUsage();
    console.log(`[${label}] heapUsed: ${Math.round(used.heapUsed / 1024 / 1024)} MB`);
}

logMemory('before load');
const scene = new Scene();
scene.open('large-model.obj');
logMemory('after load');
scene.save('output.glb');
logMemory('after save');

Augmentez le tas Node.js pour les modèles très volumineux :

node --max-old-space-size=8192 convert.js

Foire aux questions

Quel est le format de sortie le plus compact ?

GLB (binary glTF) avec des ressources intégrées produit la sortie monofichier la plus compacte pour les scènes contenant des matériaux et des textures. STL est plus compact pour le contenu uniquement géométrique.

Est-ce que @aspose/3d applique la simplification de maillage ou le LOD ?

Non. La bibliothèque lit et écrit la géométrie source sans modifier la topologie du maillage. La simplification de maillage (réduction de sommets, génération de LOD) n’est pas prise en charge.

Puis-je supprimer les matériaux pour réduire la taille du fichier ?

Définir ObjSaveOptions.enableMaterials = false lors de l’enregistrement au format OBJ. Pour glTF, toutes les données de matériau sont toujours incluses ; utilisez STL pour une sortie uniquement géométrique.

Voir aussi

 Français