Function load_gltf_with_textures

native/shared/src/models.rs:1020–1404

(
    data: &[u8],
    renderer: &mut crate::renderer::Renderer,
    base_dir: Option<&std::path::Path>,
)

}

fn load_gltf_with_textures(
    data: &[u8],
    renderer: &mut crate::renderer::Renderer,
    base_dir: Option<&std::path::Path>,
) -> Option<ModelData> {
    let gltf = gltf::Gltf::from_slice(data).ok()?;

    // Get buffer data
    let mut buffer_data: Vec<Vec<u8>> = Vec::new();
    for buffer in gltf.buffers() {
        match buffer.source() {
            gltf::buffer::Source::Bin => {
                if let Some(blob) = gltf.blob.as_ref() { buffer_data.push(blob.clone()); }
            }
            gltf::buffer::Source::Uri(uri) => {
                if let Some(encoded) = uri.strip_prefix("data:application/octet-stream;base64,") {
                    let mut decoded = Vec::new();
                    let _ = base64_decode(encoded, &mut decoded);
                    buffer_data.push(decoded);
                } else if let Some(dir) = base_dir {
                    // External .bin file alongside the .gltf.
                    let path = dir.join(uri);
                    match std::fs::read(&path) {
                        Ok(bytes) => buffer_data.push(bytes),
                        Err(_) => buffer_data.push(Vec::new()),
                    }
                } else {
                    buffer_data.push(Vec::new());
                }
            }
        }
    }

    // Pre-walk materials to identify which image indices are normal
    // maps. They need LEADR-style vector-space mip generation and per-
    // mip variance baked into alpha; see register_texture_kind.
    let mut normal_image_set: std::collections::HashSet<usize> = Default::default();
    for mat in gltf.materials() {
        if let Some(nt) = mat.normal_texture() {
            normal_image_set.insert(nt.texture().source().index());
        }
    }

    // Extract and register textures
    let mut texture_indices: Vec<u32> = Vec::new(); // maps glTF image index -> renderer texture index
    for (image_idx, image) in gltf.images().enumerate() {
        let is_normal = normal_image_set.contains(&image_idx);
        match image.source() {
            gltf::image::Source::View { view, .. } => {
                let buf_idx = view.buffer().index();
                if buf_idx < buffer_data.len() {
                    let offset = view.offset();
                    let length = view.length();
                    if offset + length <= buffer_data[buf_idx].len() {
                        let img_data = &buffer_data[buf_idx][offset..offset + length];
                        // Decode image (PNG/JPEG)
                        if let Ok(img) = image::load_from_memory(img_data) {
                            let rgba = img.to_rgba8();