Aspose.3D FOSS
TypeScript
Cómo optimizar modelos 3D en TypeScript

Cómo optimizar modelos 3D en TypeScript

Aspose.3D FOSS para TypeScript ofrece varias estrategias para reducir el tamaño de los archivos de salida y mejorar el rendimiento del procesamiento. Esta guía cubre la selección de formato, la incrustación binaria, los pipelines en memoria y las optimizaciones a nivel de Node.js.

Guía paso a paso

Paso 1: Elija el formato de salida correcto

GLB (binary glTF) produce la salida más compacta con buen soporte de herramientas. OBJ es basado en texto y más grande. STL es compacto para flujos de trabajo solo de geometría.

FormatoTamañoIncluye materialesIncluye animaciónMejor uso
GLBPequeñoSí (embebido)SíWeb, juegos, intercambio general
glTFMedioSí (separado)SíDesarrollo, inspección
STLPequeñoNoNo3D printing, geometry-only
OBJGrandeSeparado .mtlNoHerramientas heredadas, amplia compatibilidad
FBXMedioNo*No*El importador/exportador existe pero no está conectado a la detección automática
3MFPequeñoSíNoImpresión 3D moderna

Paso 2: Exportar a GLB binario

Al guardar en GLB, establezca GltfSaveOptions.binaryMode = true para generar un único archivo binario autónomo. Esto evita el .bin archivo adjunto y es necesario para muchos visores 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');

Paso 3: Utilizar I/O de búfer para pipelines en memoria

Al procesar archivos en un servicio web, use openFromBuffer y saveToBuffer para evitar escribir en el sistema de archivos:

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');
}

Paso 4: Procesar archivos por lotes con hilos de trabajo

Para trabajos de conversión grandes, distribuya el trabajo entre hilos de trabajo de Node.js para usar múltiples núcleos de 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}`));
}

Paso 5: Monitorear la memoria para modelos grandes

Para archivos de más de 50 MB, monitoree el uso del heap y procese los archivos secuencialmente si la memoria es limitada:

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');

Aumente el heap de Node.js para modelos muy grandes:

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

Preguntas frecuentes

¿Cuál es el formato de salida más compacto?

GLB (binary glTF) con recursos incrustados produce la salida de un solo archivo más compacta para escenas con materiales y texturas. STL es más compacto para contenido solo de geometría.

¿@aspose/3d aplica simplificación de malla o LOD?

No. La biblioteca lee y escribe la geometría fuente sin modificar la topología de la malla. La simplificación de malla (reducción de vértices, generación de LOD) no está soportada.

¿Puedo eliminar los materiales para reducir el tamaño del archivo?

Establecer ObjSaveOptions.enableMaterials = false al guardar en OBJ. Para glTF, todos los datos de material siempre se incluyen; use STL para salida solo de geometría.

Ver también

 Español