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 Auswahl des Formats, 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 mit 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-Druck, nur Geometrie
OBJGroßSeparate .mtlNeinLegacy-Tools, breite Kompatibilität
FBXMittelNein*Nein*Importer/Exporter vorhanden, aber nicht in die automatische Erkennung eingebunden
3MFKleinJaNeinModerner 3D-Druck

Schritt 2: Export in das binäre GLB

Beim Speichern als GLB setzen Sie GltfSaveOptions.binaryMode = true, um eine einzelne, eigenständige Binärdatei zu erzeugen. Dies vermeidet die separate .bin‑Sidecar‑Datei und ist für viele 3D‑Betrachter 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 Webdienst verwenden Sie 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 über 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: Speicher für große Modelle überwachen

Bei Dateien über 50 MB den Heap-Verbrauch ü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

Was 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‑Simplifizierung (Vertex‑Reduktion, LOD‑Erzeugung) wird nicht unterstützt.

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

Setzen Sie ObjSaveOptions.enableMaterials = false beim Speichern in OBJ. Bei glTF werden alle Materialdaten immer eingeschlossen; verwenden Sie STL für eine rein geometrische Ausgabe.

Siehe auch

 Deutsch