Struct Import 

pub struct Import {
    pub document: Document,
    pub resources: ResourceStore,
    pub input_format: GltfContainerFormat,
    /* private fields */
}

Lossless glTF document plus its resolved resources.

Fields

document: Document

Lossless parsed glTF document.

resources: ResourceStore

Resolved buffer resources indexed by document buffer index.

input_format: GltfContainerFormat

Container format from which this import was read.

Implementations

impl Import

pub fn compress_primitive( &mut self, mesh: MeshIndex, primitive: usize, options: CompressionOptions, ) -> Result<CompressionReport>

Compresses one ordinary triangle primitive atomically.

The document and resolved resources are updated only after encoding, validation, reference remapping, and output-limit checks all succeed. In CompressionMode::DracoOnly the operation rejects unregistered extensions whose binary references cannot be remapped safely.

Examples found in repository

examples/gltf_tool.rs (line 55)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut args = std::env::args_os().skip(1);
    let input = PathBuf::from(args.next().ok_or_else(|| {
        io::Error::new(
            io::ErrorKind::InvalidInput,
            "usage: gltf_tool <input.gltf|input.glb> [output.glb]",
        )
    })?);
    let output = args.next().map(PathBuf::from);
    if args.next().is_some() {
        return Err(io::Error::new(io::ErrorKind::InvalidInput, "too many arguments").into());
    }

    let mut import = draco_gltf::import(&input)?;
    if let Some(output) = output {
        let report = import.compress_primitive(MeshIndex(0), 0, CompressionOptions::default())?;
        let bytes = import.to_bytes(OutputFormat::GlbV2)?;
        std::fs::write(output, bytes)?;
        println!("compression_report={report:?}");
    } else {
        let (primitives, faces) = decoded_draco_stats(&import)?;
        println!("decoded_draco_primitives={primitives} decoded_faces={faces}");
    }
    Ok(())
}

impl Import

pub fn write_primitive( &mut self, primitive: PrimitiveIndex, geometry: &PackedGeometry, options: GeometryWriteOptions, ) -> Result<GeometryWriteReport>

Replaces one primitive’s geometry atomically.

Raw storage is the default. The existing material, extras, morph targets with the same vertex count, and unrelated extensions remain on the primitive. Shared source accessors are never modified in place.

pub fn push_primitive( &mut self, mesh: MeshIndex, geometry: &PackedGeometry, options: GeometryWriteOptions, ) -> Result<PrimitiveIndex>

Appends packed geometry to an existing mesh atomically.

Returns the stable location accepted by Import::read_primitive and Import::write_primitive.

pub fn from_geometry( geometry: &PackedGeometry, profile: ValidationProfile, options: GeometryWriteOptions, ) -> Result<Self>

Creates a minimal scene containing one packed primitive.

use draco_gltf::{
    ComponentType, GeometryWriteOptions, Import, PackedAttribute,
    PackedGeometry, PrimitiveMode, ValidationProfile,
};

let position = PackedAttribute::new(
    "POSITION", 1, 3, ComponentType::F32, false, vec![0; 12],
)?;
let geometry = PackedGeometry::new(PrimitiveMode::Points, vec![position], None)?;
let scene = Import::from_geometry(
    &geometry,
    ValidationProfile::Gltf20,
    GeometryWriteOptions::default(),
)?;
assert_eq!(scene.document.meshes().len(), 1);

impl Import

pub fn validate(&self, extensions: &ExtensionRegistry) -> Result<()>

Validates the document and all registered extension handlers.

With strict-validation, this also checks the complete scene graph.

pub fn draco_primitives(&self) -> impl Iterator<Item = PrimitiveRef<'_>> + '_

Iterates primitives carrying the built-in Draco extension.

Examples found in repository

examples/gltf_tool.rs (line 11)

fn decoded_draco_stats(import: &Import) -> Result<(usize, usize), Box<dyn std::error::Error>> {
    let mut primitives = 0usize;
    let mut faces = 0usize;
    for primitive in import.draco_primitives() {
        let mesh = import.decode_draco_primitive(primitive)?;
        if mesh.num_faces() == 0 {
            return Err(io::Error::new(
                io::ErrorKind::InvalidData,
                "Draco primitive decoded to zero faces",
            )
            .into());
        }
        primitives = primitives.checked_add(1).ok_or_else(|| {
            io::Error::new(
                io::ErrorKind::InvalidData,
                "decoded primitive count overflow",
            )
        })?;
        faces = faces.checked_add(mesh.num_faces()).ok_or_else(|| {
            io::Error::new(io::ErrorKind::InvalidData, "decoded face count overflow")
        })?;
    }
    if primitives == 0 || faces == 0 {
        return Err(io::Error::new(
            io::ErrorKind::InvalidData,
            "document contains no decodable Draco triangle faces",
        )
        .into());
    }
    Ok((primitives, faces))
}

pub fn decode_draco_primitive( &self, primitive: PrimitiveRef<'_>, ) -> Result<Mesh>

Decodes a primitive through the supplied extension registry.

Examples found in repository

examples/gltf_tool.rs (line 12)

fn decoded_draco_stats(import: &Import) -> Result<(usize, usize), Box<dyn std::error::Error>> {
    let mut primitives = 0usize;
    let mut faces = 0usize;
    for primitive in import.draco_primitives() {
        let mesh = import.decode_draco_primitive(primitive)?;
        if mesh.num_faces() == 0 {
            return Err(io::Error::new(
                io::ErrorKind::InvalidData,
                "Draco primitive decoded to zero faces",
            )
            .into());
        }
        primitives = primitives.checked_add(1).ok_or_else(|| {
            io::Error::new(
                io::ErrorKind::InvalidData,
                "decoded primitive count overflow",
            )
        })?;
        faces = faces.checked_add(mesh.num_faces()).ok_or_else(|| {
            io::Error::new(io::ErrorKind::InvalidData, "decoded face count overflow")
        })?;
    }
    if primitives == 0 || faces == 0 {
        return Err(io::Error::new(
            io::ErrorKind::InvalidData,
            "document contains no decodable Draco triangle faces",
        )
        .into());
    }
    Ok((primitives, faces))
}

pub fn read_primitive( &self, primitive: PrimitiveIndex, ) -> Result<PackedGeometry>

Reads one ordinary or Draco-compressed primitive into packed buffers.

Sparse overlays and byte strides are materialized without changing component types or normalization flags. Draco is decoded only when the draco-decode feature is enabled.

pub fn to_bytes(&self, output: OutputFormat) -> Result<Vec<u8>>

Serializes this import into the requested container format.

crate::OutputFormat::GltfJson is valid only when every materialized buffer already has an embedded or external URI. For transformed scenes that need newly generated companion buffers, use Import::to_gltf_output instead. GLB output embeds all resolved buffers in one binary chunk.

let scene = import_slice(input, None)?;
let glb = scene.to_bytes(OutputFormat::GlbV2)?;
assert_eq!(&glb[0..4], b"glTF");

Examples found in repository

examples/gltf_tool.rs (line 56)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut args = std::env::args_os().skip(1);
    let input = PathBuf::from(args.next().ok_or_else(|| {
        io::Error::new(
            io::ErrorKind::InvalidInput,
            "usage: gltf_tool <input.gltf|input.glb> [output.glb]",
        )
    })?);
    let output = args.next().map(PathBuf::from);
    if args.next().is_some() {
        return Err(io::Error::new(io::ErrorKind::InvalidInput, "too many arguments").into());
    }

    let mut import = draco_gltf::import(&input)?;
    if let Some(output) = output {
        let report = import.compress_primitive(MeshIndex(0), 0, CompressionOptions::default())?;
        let bytes = import.to_bytes(OutputFormat::GlbV2)?;
        std::fs::write(output, bytes)?;
        println!("compression_report={report:?}");
    } else {
        let (primitives, faces) = decoded_draco_stats(&import)?;
        println!("decoded_draco_primitives={primitives} decoded_faces={faces}");
    }
    Ok(())
}

pub fn to_gltf_output(&self) -> Result<GltfOutput>

Serializes a self-contained .gltf output bundle.

Unlike Import::to_bytes with crate::OutputFormat::GltfJson, this method returns companion buffer payloads as well. Buffers without a URI (for example a Draco payload appended during compression) receive a deterministic buffer-{index}.bin URI in the returned JSON.

let scene = import_slice(input, None)?;
let output = scene.to_gltf_output()?;
assert!(!output.json.is_empty());
assert!(output.resources.is_empty());

pub fn decompress_in_place(&mut self) -> Result<()>

Materializes all Draco primitives as ordinary indexed triangle geometry.

pub fn external_files(&self) -> impl Iterator<Item = FileIndex> + '_

Lists declared glTF 2.1 files entries without resolving them.

pub fn load_external_asset( &self, asset: ExternalAssetIndex, resolver: &dyn ResourceResolver, limits: &ResourceLimits, profile: ValidationProfile, extensions: &ExtensionRegistry, ) -> Result<Self>

Explicitly resolves and parses an external-asset model declaration.

pub fn provenance(&self) -> &[String]

URI chain leading to this import. It is intended for diagnostics and explicit cycle detection; it never triggers recursive loading itself.

pub fn load_asset( &self, file: FileIndex, resolver: &dyn ResourceResolver, limits: &ResourceLimits, profile: ValidationProfile, extensions: &ExtensionRegistry, ) -> Result<Self>

Explicitly resolves and parses one nested glTF file.

pub fn load_asset_with_depth( &self, file: FileIndex, resolver: &dyn ResourceResolver, limits: &ResourceLimits, profile: ValidationProfile, extensions: &ExtensionRegistry, max_depth: usize, ) -> Result<Self>

Explicitly loads one nested asset with a caller-selected graph depth limit.

Trait Implementations

impl Clone for Import

fn clone(&self) -> Import

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.