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 Verringerung der Ausgabe-Dateigröße und Verbesserung des Prozessdurchsatzes. Dieser Leitfaden umfasst die Formatwahl, binäre Einbettung, In-Memory Pipelines und Optimierungen auf Node.js-Ebene.

Schritt für Schritte

Schritt 1: Wählen Sie das richtige Ausgabeformat aus

GLB (binärer glTF) erzeugt die kompakte Ausgabe mit guter Werkzeugunterstützung. OBJ ist textbasiert und größer. STL ist kompakt für geometrische Workflows.

Format der DatenbankGrößeInhalte enthaltenAnimation enthaltenBeste Verwendung
GLBKleineJa (eingebettet)- Ja , das ist gut .Internet, Spiele und allgemeiner Austausch
GFT-SystemeMittelmäßigJa (getrennt)- Ja , das ist gut .Entwicklung, Inspektion
STLKleine- Nein .- Nein .3D printing, geometry-only
OBJGroßesSeparate .mtl-Dateien- Nein .Alte Werkzeuge, breite Kompatibilität
FBXMittelmäßigNicht verfügbar*Nicht verfügbar*Importeur/Exporter existiert, ist aber nicht mit der automatischen Erkennung verbunden.
3MFKleine- Ja , das ist gut .- Nein .Moderne 3D-Drucktechnik

Schritt 2: Export in die binäre GLB

Bei der Einsparung auf GLB wird die GltfSaveOptions.binaryMode = true Die Daten werden in einer einzelnen binären Datei erstellt, wodurch die getrennte .bin Seitenauto 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: Buffer-E/A für Inmemory-Pipelines verwenden

Bei der Verarbeitung von Dateien in einem Webdienst verwenden Sie die Funktion “Datenverarbeitungs- und -überwachung” (WEB openFromBuffer und . saveToBuffer Um das Datensystem nicht zu schreiben:

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: Batch-Prozessdateien mit Arbeiterthreads

Für große Konvertierungsarbeiten verteilen Sie die Arbeit über Node.js-Workertreads, um mehrere CPU-Kerne zu verwenden:

// 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 das Speicher für große Modelle

Für Dateien über 50 MB, die Heap-Nutzung zu überwachen und Sequenzdateien verarbeiten, wenn der Speicher eingeschränkt 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');

Erweitern 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 kompakte Ausgabeformat?

GLB (binärer glTF) mit eingebetteten Assets erzeugt den kompakten Single-File Output für Szenen mit Materialien und Texturen. STL ist kompakterer für nur geometrische Inhalte.

Wird die Maschenvereinfachung oder LOD von @aspose/3d angewendet?

Die Bibliothek liest und schreibt die Quellgeometrie, ohne die Maschentopologie zu ändern.

Kann ich Material entfernen, um die Dateigröße zu verringern?

Setz ObjSaveOptions.enableMaterials = false bei der Speicherung auf OBJ. Für glTF sind immer alle Materialdaten enthalten; für die Ausgabe nur Geometrie verwendet STL.

Siehe auch:

 Deutsch