Rendering della Scena e Esportazione

@aspose/3d è una libreria di elaborazione e conversione, e non esegue il rendering GPU né produce file immagine. “Rendering” nel contesto di questa libreria significa esportare una scena in un formato che un renderer a valle, un motore di gioco o un visualizzatore possa consumare.

Questa pagina copre tutti i percorsi di esportazione: salvataggio su file, output su buffer in memoria, opzioni specifiche per formato e come preparare le scene per i target a valle più comuni (Three.js, Babylon.js, visualizzatori di modelli e motori di gioco).

Esportazione di base

Chiama scene.save() con un percorso file. La libreria deduce il formato di output dall’estensione del file:

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

const scene = new Scene();
scene.open('input.obj');  // use a supported format (OBJ, glTF, GLB, STL, 3MF, COLLADA)

scene.save('output.glb');    // GLB (binary glTF)
scene.save('output.stl');    // STL
scene.save('output.dae');    // COLLADA
scene.save('output.3mf');    // 3MF

Esportazione in GLB (Consigliato per Web e Giochi)

GLB (binary glTF 2.0) è un unico file autonomo che incorpora tutti i dati della mesh, i materiali e le texture. È il formato di output consigliato per i visualizzatori web (Three.js, Babylon.js, model-viewer) e i motori di gioco (Godot, Unity tramite importatore):

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

const scene = new Scene();
scene.open('source.obj');

const opts = new GltfSaveOptions();
opts.binaryMode = true;    // produce .glb instead of .gltf + .bin

scene.save('output.glb', opts);
console.log('GLB export complete');

Imposta binaryMode = true per produrre un file GLB autonomo. Quando false, l’output è un .gltf file JSON con un .bin buffer sidecar.

Esportazione in glTF (Formato JSON per Ispezione)

La variante JSON (.gltf + .bin) è utile durante lo sviluppo perché il JSON è leggibile dall’uomo:

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

const scene = new Scene();
scene.open('input.dae');  // COLLADA is fully supported; FBX is not wired into scene.open()

const opts = new GltfSaveOptions();
opts.binaryMode = false;  // JSON + .bin sidecar

scene.save('output.gltf', opts);

Esportazione in STL (Flussi di lavoro per stampa 3D)

STL contiene solo geometria (nessun materiale, nessuna animazione). È il formato di scambio standard per i slicer di stampa 3D:

import { Scene } from '@aspose/3d';
import { StlSaveOptions } from '@aspose/3d/formats/stl';

const scene = new Scene();
scene.open('model.obj');

const opts = new StlSaveOptions();
opts.binaryMode = true;   // binary STL is more compact than ASCII

scene.save('output.stl', opts);

Imposta binaryMode = false per produrre STL ASCII, che è leggibile come testo ma più grande.

Esportazione in FBX (Flussi di lavoro con strumenti DCC)

Nota: le classi importatore ed esportatore FBX esistono nella libreria, ma il rilevamento automatico del formato FBX non è integrato in scene.open() o scene.save(). Chiamata scene.save('output.fbx', opts) non invocherà l’esportatore FBX — il .fbx l’estensione non è riconosciuta dal dispatcher di salvataggio e la chiamata tornerà all’output OBJ. Usa il FbxExporter classe direttamente se hai bisogno di I/O FBX. La tabella di supporto dei formati indica FBX come No* per questo motivo.

Se hai bisogno di esportare in un formato accettato da Blender, Maya o Unreal Engine, usa GLB o COLLADA invece — entrambi sono completamente integrati in scene.save():

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

const scene = new Scene();
scene.open('input.dae');

// GLB is fully supported and widely accepted by DCC tools
const opts = new GltfSaveOptions();
opts.binaryMode = true;
scene.save('output.glb', opts);

Esportazione in memoria con saveToBuffer()

Per funzioni serverless, risposte HTTP e pipeline di streaming, esporta direttamente a un Buffer senza scrivere su disco:

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

function convertToGlbBuffer(inputPath: string): Buffer {
    const scene = new Scene();
    scene.open(inputPath);

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

    return scene.saveToBuffer('glb', opts);
}

// Express.js / HTTP response example
// const glbBuffer = convertToGlbBuffer('model.obj');
// res.setHeader('Content-Type', 'model/gltf-binary');
// res.send(glbBuffer);

saveToBuffer() accetta una stringa di formato come primo argomento (ad es. 'glb', 'stl', 'obj') e gli stessi oggetti di opzioni di save().

Combinando openFromBuffer() e saveToBuffer()

Una pipeline di conversione interamente in memoria senza I/O su disco in nessuna fase:

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

function objBufferToGlbBuffer(objData: Buffer): Buffer {
    const scene = new Scene();

    const loadOpts = new ObjLoadOptions();
    loadOpts.enableMaterials = true;
    scene.openFromBuffer(objData, loadOpts);

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

    return scene.saveToBuffer('glb', saveOpts);
}

Preparazione delle scene per renderer specifici

Three.js / Babylon.js (Web)

Questi renderer caricano nativamente file GLB. Esporta con binaryMode = true. Se le texture sono referenziate dal file OBJ di origine, assicurati che il .mtl e i file immagine siano collocati insieme durante il caricamento.

model-viewer (Web Component)

Accetta .glb direttamente. Stesse impostazioni di esportazione di Three.js.

Godot Engine

Importa GLB tramite l’importatore di Godot (Project → Import). Usa binaryMode = true. Godot supporta nativamente i materiali PBR da glTF 2.0.

Blender

Per la massima fedeltà di importazione usa glTF (output.gltf + output.bin) o GLB (output.glb). L’importatore glTF 2.0 di Blender gestisce i materiali PBR e l’animazione. Nota: l’output FBX tramite scene.save() non è supportato — il rilevamento automatico del formato FBX non è integrato nel dispatcher di salvataggio.

3D Printing (Slicers: Cura, PrusaSlicer, Bambu Studio)

Esporta in STL o 3MF. Usa 3MF quando è necessario preservare colore o metadati del materiale. Usa STL per la massima compatibilità.

Confronto dei formati di esportazione

Problemi comuni di esportazione

Vedi anche

• Caricamento del modello: caricamento di file 3D da disco e buffer
• Grafico della scena: creazione e modifica della scena prima dell’esportazione
• Supporto dei formati: matrice completa di lettura/scrittura
• Panoramica API: tutte le classi e le enumerazioni