Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

7.5 KB
Raw Blame
//! One read-only storage buffer: body lookup, planar records and linear RGBA mip chains.
use solidcore_record::Vec3;
use solidcraft_geom::prelude::*;
use solidcraft_render::job::{
    CancelToken, ErrorCode, JobError, Result,
    textures::{BaseColorMode, RuntimeTextures, TextureMap},
};
use solidcraft_render::texture_sampling::{
    TextureView,
    mips::{MAX_MIP_TAIL_BYTES, MipChain},
};

fn vector(a: [f64; 3]) -> Vec3 {
    Vec3::new(a[0], a[1], a[2])
}
fn write_word(bytes: &mut [u8], word: usize, value: u32) -> Result<()> {
    bytes
        .get_mut(word * 4..word * 4 + 4)
        .ok_or_else(|| JobError::new(ErrorCode::Internal, "texture record outside allocation"))?
        .copy_from_slice(&value.to_le_bytes());
    Ok(())
}
fn pixels(
    bytes: &mut Vec<u8>,
    map: Option<&TextureMap>,
    cancel: &CancelToken,
    shared: &mut std::collections::BTreeMap<([u8; 32], u8), (u32, [u32; 2])>,
) -> Result<(u32, [u32; 2])> {
    let Some(map) = map else {
        return Ok((0, [0; 2]));
    };
    cancel.check()?;
    if let Some(record) = shared.get(&map.identity()) {
        return Ok(*record);
    }
    let rgba = map.decode(cancel)?;
    let view = TextureView::new(&rgba, map.dimensions()).map_err(|error| JobError::new(ErrorCode::InvalidRequest, error.to_string()))?;
    // Decode roles before averaging: reflectance is linear sRGB; scalar and
    // tangent-normal channels remain linear data. Alpha never participates.
    // Existing temporary and saved built-in maps keep their level-zero sampler.
    // Do not generate or retain an unused tail for those legacy inputs.
    let mips = if map.gpu_mip_filtering() {
        Some(MipChain::prepare(view, MAX_MIP_TAIL_BYTES, || cancel.is_cancelled()).map_err(|error| {
            JobError::new(if cancel.is_cancelled() { ErrorCode::Cancelled } else { ErrorCode::InvalidRequest }, error.to_string())
        })?)
    } else {
        None
    };
    let level_count = mips.as_ref().map_or(1, MipChain::level_count);
    let offset = bytes.len() / 4;
    let descriptor_words = 4 + level_count * 4;
    bytes.resize(bytes.len() + descriptor_words * 4, 0);
    write_word(bytes, offset, level_count as u32)?;
    write_word(bytes, offset + 1, 2)?;
    write_word(bytes, offset + 2, u32::from(map.gpu_mip_filtering()))?;
    for level in 0..level_count {
        let (pixels, dimensions) = match &mips {
            Some(mips) => (
                mips.level(level).ok_or_else(|| JobError::new(ErrorCode::Internal, "missing prepared GPU mip pixels"))?,
                mips.dimensions(level).ok_or_else(|| JobError::new(ErrorCode::Internal, "missing prepared GPU mip dimensions"))?,
            ),
            None => (view, map.dimensions()),
        };
        let descriptor = offset + 4 + level * 4;
        let pixel_offset = u32::try_from(bytes.len() / 4).map_err(|_| JobError::new(ErrorCode::LimitExceeded, "GPU mip buffer offset overflow"))?;
        write_word(bytes, descriptor, pixel_offset)?;
        write_word(bytes, descriptor + 1, dimensions[0])?;
        write_word(bytes, descriptor + 2, dimensions[1])?;
        for (index, value) in pixels.rgba().iter().enumerate() {
            if index % 4096 == 0 {
                cancel.check()?;
            }
            bytes.extend_from_slice(&value.to_le_bytes());
        }
    }
    let record = (u32::try_from(offset).map_err(|_| JobError::new(ErrorCode::LimitExceeded, "texture buffer offset overflow"))?, map.dimensions());
    shared.insert(map.identity(), record);
    Ok(record)
}
pub(super) fn flatten(resources: Option<&RuntimeTextures>, body_count: usize, origin: Vec3, cancel: &CancelToken) -> Result<Vec<u8>> {
    let Some(resources) = resources else {
        return Ok(vec![0; 16]);
    };
    let header = (4 + body_count + 1).next_multiple_of(4);
    let record_words = resources.bindings().len() * 24;
    let capacity = usize::try_from(packed_bytes(resources, body_count))
        .map_err(|_| JobError::new(ErrorCode::LimitExceeded, "GPU mip buffer capacity overflow"))?;
    let mut bytes = super::scene::reserved(capacity)?;
    bytes.resize((header + record_words) * 4, 0);
    write_word(&mut bytes, 0, (body_count + 1) as u32)?;
    let mut shared = std::collections::BTreeMap::new();
    for (index, binding) in resources.bindings().iter().enumerate() {
        cancel.check()?;
        let record = header + index * 24;
        write_word(&mut bytes, 4 + binding.body_index + 1, record as u32)?;
        let delta = vector(binding.frame.origin) - origin;
        if [delta.x, delta.y, delta.z].iter().any(|v| v.abs() > 1e7) {
            return Err(JobError::new(ErrorCode::InvalidScene, "texture frame must be within 1e7 mm of camera target"));
        }
        let u = vector(binding.frame.u);
        let v = vector(binding.frame.v);
        for (offset, p) in [(0, delta), (4, u / u.len2()), (8, v / v.len2())] {
            for (k, c) in [p.x, p.y, p.z].into_iter().enumerate() {
                write_word(&mut bytes, record + offset + k, (c as f32).to_bits())?;
            }
        }
        let (base, base_size) = pixels(&mut bytes, binding.base_color.as_ref(), cancel, &mut shared)?;
        let (normal, normal_size) = pixels(&mut bytes, binding.normal.as_ref(), cancel, &mut shared)?;
        let (roughness, roughness_size) = pixels(&mut bytes, binding.roughness.as_ref(), cancel, &mut shared)?;
        let (metallic, metallic_size) = pixels(&mut bytes, binding.metallic.as_ref(), cancel, &mut shared)?;
        let roles = if metallic != 0 {
            4
        } else if roughness != 0 {
            3
        } else if normal != 0 {
            2
        } else {
            1
        };
        let flags = u32::from(binding.flip_v) | (u32::from(binding.base_color_mode == BaseColorMode::Replace) << 1);
        for (offset, value) in [
            (3, base),
            (7, base_size[0]),
            (11, base_size[1]),
            (12, normal),
            (13, normal_size[0]),
            (14, normal_size[1]),
            (15, (binding.normal_strength as f32).to_bits()),
            (16, roughness),
            (17, roughness_size[0]),
            (18, roughness_size[1]),
            (19, flags),
            (20, metallic),
            (21, metallic_size[0]),
            (22, metallic_size[1]),
            (23, roles),
        ] {
            write_word(&mut bytes, record + offset, value)?;
        }
    }
    cancel.check()?;
    Ok(bytes)
}

/// Exact packed storage admission for the admitted dimensions and filtering policy.
/// Count each content/role/policy once, including only level zero for legacy maps.
pub(super) fn packed_bytes(resources: &RuntimeTextures, body_count: usize) -> u64 {
    let bindings = resources.bindings().len() as u64;
    let mut bytes = 4 * ((5 + body_count as u64).next_multiple_of(4) + bindings * 24);
    let mut seen = std::collections::BTreeSet::new();
    for binding in resources.bindings() {
        for map in [&binding.base_color, &binding.normal, &binding.roughness, &binding.metallic].into_iter().flatten() {
            if !seen.insert(map.identity()) {
                continue;
            }
            let [mut width, mut height] = map.dimensions().map(u64::from);
            let mut levels = 1;
            let mut pixels = width * height;
            if map.gpu_mip_filtering() {
                while width > 1 || height > 1 {
                    width = (width / 2).max(1);
                    height = (height / 2).max(1);
                    pixels += width * height;
                    levels += 1;
                }
            }
            bytes += (4 + levels * 4) * 4 + pixels * 16;
        }
    }
    bytes
}