Function parse_glb

native/watchos/src/models.rs:160–321

(bytes: &[u8])

const CHUNK_BIN: u32 = 0x004E4942; // "BIN\0"

fn parse_glb(bytes: &[u8]) -> Option<Model> {
    if bytes.len() < 12 { return None; }
    if u32_le(bytes, 0) != GLB_MAGIC { return None; }
    let _version = u32_le(bytes, 4);
    let _total_len = u32_le(bytes, 8);

    // Walk chunks. Expect JSON first, then BIN.
    let mut off = 12usize;
    let mut json_bytes: &[u8] = &[];
    let mut bin_bytes: &[u8] = &[];
    while off + 8 <= bytes.len() {
        let chunk_len = u32_le(bytes, off) as usize;
        let chunk_type = u32_le(bytes, off + 4);
        let data_start = off + 8;
        let data_end = data_start + chunk_len;
        if data_end > bytes.len() { break; }
        let data = &bytes[data_start..data_end];
        match chunk_type {
            CHUNK_JSON => json_bytes = data,
            CHUNK_BIN => bin_bytes = data,
            _ => {}
        }
        off = data_end;
    }
    if json_bytes.is_empty() { return None; }

    let json = std::str::from_utf8(json_bytes).ok()?;
    let root = json_parse(json)?;

    let meshes_js = root.get("meshes")?.arr()?;
    let accessors = root.get("accessors")?.arr()?;
    let buf_views = root.get("bufferViews")?.arr()?;

    let mut meshes: Vec<Mesh> = Vec::with_capacity(meshes_js.len());
    for mesh_js in meshes_js {
        let prims_js = match mesh_js.get("primitives").and_then(|v| v.arr()) {
            Some(p) => p,
            None => continue,
        };
        let mut primitives: Vec<Primitive> = Vec::with_capacity(prims_js.len());
        for prim in prims_js {
            if let Some(p) = parse_primitive(prim, &root, accessors, buf_views, bin_bytes) {
                primitives.push(p);
            }
        }
        meshes.push(Mesh { primitives });
    }
    if meshes.is_empty() { return None; }

    // Parse nodes + scenes (glTF hierarchy).
    let mut nodes: Vec<Node> = Vec::new();
    if let Some(nodes_js) = root.get("nodes").and_then(|v| v.arr()) {
        nodes.reserve(nodes_js.len());
        for n in nodes_js {
            nodes.push(parse_node(n));
        }
    }
    let mut scene_roots: Vec<usize> = Vec::new();