Method register_texture_kind

native/shared/src/renderer/mod.rs:11595–11766

Register a texture with optional normal-map preprocessing. For normal maps (is_normal_map=true), mip chain is built with vector-space averaging instead of scalar RGB averaging, and per-mip variance (1 - |vector_avg|²) is baked into the alpha channel. The shader reads alpha as a Toksvig-style σ² addition that accumulates normal-direction disagreement across the footprint the sampler ends up integr

(
        &mut self,
        width: u32,
        height: u32,
        data: &[u8],
        is_normal_map: bool,
    )

    /// scalar LEADR/LEAN filter. Alpha is unused by glTF normal maps
    /// (they carry (x,y,z) in RGB) so we can safely repurpose it.
    pub fn register_texture_kind(
        &mut self,
        width: u32,
        height: u32,
        data: &[u8],
        is_normal_map: bool,
    ) -> u32 {
        let max_dim = if width > height { width } else { height };
        // On Android/Vulkan, multi-level mipmap upload can fail silently.
        // Use single mip for 2D textures; only generate mipmaps on desktop.
        #[cfg(target_os = "android")]
        let mip_count = 1u32;
        #[cfg(not(target_os = "android"))]
        let mip_count = (max_dim as f32).log2().floor() as u32 + 1;

        // Generate mip chain data
        let mut mip_data = Vec::with_capacity(data.len() * 2); // overallocate
        if is_normal_map {
            // Level 0: normalize input RGB and clear alpha to 0 (no
            // variance at the finest level — each texel is assumed unit).
            mip_data.reserve(data.len());
            for i in 0..(width as usize * height as usize) {
                let r = data[i * 4];
                let g = data[i * 4 + 1];
                let b = data[i * 4 + 2];
                mip_data.push(r);
                mip_data.push(g);
                mip_data.push(b);
                mip_data.push(0);
            }
        } else {
            mip_data.extend_from_slice(data);
        }
        let mut mip_offsets = vec![0usize]; // byte offset of each mip level
        let mut mw = width;
        let mut mh = height;
        for _ in 1..mip_count {
            let prev_offset = *mip_offsets.last().unwrap();
            let pw = mw as usize; // previous width
            let ph = mh as usize; // previous height
            mw = if mw > 1 { mw / 2 } else { 1 };
            mh = if mh > 1 { mh / 2 } else { 1 };
            mip_offsets.push(mip_data.len());
            for y in 0..mh as usize {
                for x in 0..mw as usize {
                    let sx = x * 2;
                    let sy = y * 2;
                    let sx1 = (sx + 1).min(pw - 1);
                    let sy1 = (sy + 1).min(ph - 1);
                    if is_normal_map {
                        // Decode 4 children to signed [-1, 1] vectors
                        let dec = |r: u8, g: u8, b: u8| -> [f32; 3] {
                            [
                                r as f32 * (2.0 / 255.0) - 1.0,
                                g as f32 * (2.0 / 255.0) - 1.0,
                                b as f32 * (2.0 / 255.0) - 1.0,
                            ]
                        };