Aspose.3D FOSS
TypeScript
Wie man 3D-Modelle in TypeScript optimiert

Wie man 3D-Modelle in TypeScript optimiert

Aspose.3D FOSS für TypeScript bietet mehrere Strategien zur Reduzierung der Ausgabedateigröße und zur Verbesserung des Verarbeitungsthroughputs. Dieser Leitfaden behandelt die Formatwahl, das Einbetten von Binärdaten, In-Memory-Pipelines und Optimierungen auf Node.js-Ebene.

Schritt-für-Schritt-Anleitung

Schritt 1: Wählen Sie das richtige Ausgabeformat

GLB (binary glTF) erzeugt die kompakteste Ausgabe bei guter Tool-Unterstützung. OBJ ist textbasiert und größer. STL ist kompakt für rein geometrische Workflows.

FormatGrößeEnthält MaterialienEnthält AnimationBeste Verwendung
GLBKleinJa (eingebettet)JaWeb, Spiele, allgemeiner Austausch
glTFMittelJa (separat)JaEntwicklung, Inspektion
STLKleinNeinNein3D printing, geometry-only
OBJGroßSeparate .mtlNeinLegacy-Tools, breite Kompatibilität
FBXMittelNein*Nein*Importer/exporter existieren, sind aber nicht in die automatische Erkennung eingebunden
3MFKleinJaNeinModerne 3D-Druck

Schritt 2: Exportieren Sie zu Binary GLB

Beim Speichern in GLB, setze GltfSaveOptions.binaryMode = true um eine einzelne, eigenständige Binärdatei zu erzeugen. Dies vermeidet die separate .bin Sidecar und ist für viele 3D-Viewer erforderlich:

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

Schritt 3: Verwenden Sie Buffer-I/O für In-Memory-Pipelines

Beim Verarbeiten von Dateien in einem Webservice, verwende openFromBuffer und saveToBuffer um das Schreiben auf das Dateisystem zu vermeiden:

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

Schritt 4: Stapelverarbeitung von Dateien mit Worker-Threads

Für große Konvertierungsaufgaben verteilen Sie die Arbeit auf Node.js-Worker-Threads, um mehrere CPU-Kerne zu nutzen:

// 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}`));
}

Schritt 5: Überwachen Sie den Speicher für große Modelle

Bei Dateien über 50 MB sollten Sie die Heap-Nutzung überwachen und Dateien sequenziell verarbeiten, wenn der Speicher begrenzt ist:

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

Erhöhen Sie den Node.js-Heap für sehr große Modelle:

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

Häufig gestellte Fragen

Welches ist das kompakteste Ausgabeformat?

GLB (binary glTF) mit eingebetteten Assets erzeugt die kompakteste Einzeldateiausgabe für Szenen mit Materialien und Texturen. STL ist kompakter für rein geometrische Inhalte.

Wendet @aspose/3d Mesh‑Vereinfachung oder LOD an?

Nein. Die Bibliothek liest und schreibt die Quellgeometrie, ohne die Mesh-Topologie zu verändern. Mesh‑Vereinfachung (Vertex‑Reduktion, LOD‑Erzeugung) wird nicht unterstützt.

Kann ich Materialien entfernen, um die Dateigröße zu reduzieren?

Setzen ObjSaveOptions.enableMaterials = false beim Speichern als OBJ. Für glTF werden immer alle Materialdaten eingeschlossen; verwenden Sie STL für eine reine Geometrieausgabe.

Siehe auch

 Deutsch