GitCorner

Code

ossartcrafttexturecraft🌐
d84914ef1e5a
//! Displacement for the path tracers: the mesh's dense copy (the one the viewport displaces in its
//! vertex shader) moved along its normals by the height channel, as the viewport moves it, so
//! Rendering mode shows the same silhouettes and the displaced surface casts its own shadows.

use std::sync::Arc;

use texturecraft_core::Channel;
use texturecraft_core::project::DisplaySettings;
use texturecraft_geom::glam::{Vec2, Vec3, Vec4};
use texturecraft_geom::{Bvh, Mesh, SubMesh};

use crate::subdivide::{self, Draw, Vertex};
use crate::trace::TraceSet;

/// The geometry the path tracers trace for `display`: displaced when the display displaces and a
/// set has height to displace by, else `mesh` and `bvh` as they are.
pub fn trace_geometry(mesh: &Arc<Mesh>, bvh: &Arc<Bvh>, sets: &[TraceSet], display: &DisplaySettings) -> (Arc<Mesh>, Arc<Bvh>) {
    match display.displacement.then(|| displaced(mesh, sets)).flatten() {
        Some(m) => {
            let bvh = Arc::new(Bvh::new(&m));
            (Arc::new(m), bvh)
        }
        None => (mesh.clone(), bvh.clone()),
    }
}

/// `mesh` subdivided like the viewport's dense copy and displaced by the height of the set over
/// each material (None when no set has height and a height strength).
pub fn displaced(mesh: &Mesh, sets: &[TraceSet]) -> Option<Mesh> {
    if !sets.iter().any(|s| s.height_strength != 0.0 && s.composite.channels.contains_key(&Channel::Height)) {
        return None;
    }
    let verts = subdivide::vertices(mesh);
    let draws: Vec<Draw> = if mesh.submeshes.is_empty() {
        vec![(0, u32::try_from(mesh.indices.len()).ok()?, 0)]
    } else {
        mesh.submeshes.iter().map(|s| (s.start, s.count, s.material)).collect()
    };
    let (lo, hi) = mesh.bounds();
    let world_per_uv = subdivide::world_per_uv(&verts, &mesh.indices).unwrap_or(((hi - lo).length() * 0.5).max(1e-3));
    let (dense, indices, dense_draws) = subdivide::subdivide(&verts, &mesh.indices, &draws, subdivide::level_for(mesh.triangle_count()));
    // UV distance between neighbouring vertices: the viewport samples the mip that matches it.
    let spacing = 1.0 / ((indices.len() / 3).max(1) as f32 * 0.5).sqrt();
    let heights: Vec<Option<Heights>> = sets.iter().map(|s| Heights::new(s, spacing)).collect();
    // Every dense vertex belongs to one triangle grid, so to one draw.
    let mut material = vec![usize::MAX; dense.len()];
    for &(start, count, m) in &dense_draws {
        for i in indices.get(start as usize..(start as usize).saturating_add(count as usize)).unwrap_or_default() {
            if let Some(slot) = material.get_mut(*i as usize) {
                *slot = m;
            }
        }
    }
    let lift = |v: &Vertex, m: usize| -> Vec3 {
        let p = Vec3::from(v.pos);
        let Some((set, h)) = sets.iter().zip(&heights).find(|(s, _)| s.material == m) else { return p };
        let n = Vec3::from(v.nrm).normalize_or_zero();
        p + n * (h.as_ref().map_or(0.0, |h| h.sample(Vec2::from(v.uv))) * set.height_strength * world_per_uv / 16.0)
    };
    let positions: Vec<Vec3> = dense.iter().zip(&material).map(|(v, m)| lift(v, *m)).collect();
    let names = |m: usize| mesh.submeshes.iter().find(|s| s.material == m).map(|s| s.name.clone()).unwrap_or_default();
    Some(Mesh {
        positions,
        normals: dense.iter().map(|v| Vec3::from(v.nrm)).collect(),
        tangents: dense.iter().map(|v| Vec4::from(v.tan)).collect(),
        uvs: dense.iter().map(|v| Vec2::from(v.uv)).collect(),
        colors: Vec::new(),
        submeshes: if mesh.submeshes.is_empty() {
            Vec::new()
        } else {
            dense_draws.iter().map(|&(start, count, m)| SubMesh { name: names(m), material: m, start, count }).collect()
        },
        indices,
        materials: mesh.materials.clone(),
        diagonals: Vec::new(),
    })
}

/// A set's height, box-filtered by `k` texels (the mip level the viewport samples).
struct Heights {
    w: usize,
    h: usize,
    data: Vec<f32>,
}

impl Heights {
    fn new(s: &TraceSet, spacing: f32) -> Option<Heights> {
        if s.height_strength == 0.0 || !s.composite.channels.contains_key(&Channel::Height) {
            return None;
        }
        let (w0, h0) = (s.composite.resolution.max(1), s.composite.height.max(1));
        let mip = (w0 as f32 * spacing).max(1.0).log2().floor().clamp(0.0, 6.0) as u32;
        let k = 1u32 << mip;
        let (w, h) = ((w0 / k).max(1), (h0 / k).max(1));
        let mut data = Vec::with_capacity((w * h) as usize);
        for y in 0..h {
            for x in 0..w {
                let mut sum = 0.0;
                for dy in 0..k {
                    for dx in 0..k {
                        sum += s.composite.value(Channel::Height, (x * k + dx).min(w0 - 1), (y * k + dy).min(h0 - 1))[0];
                    }
                }
                data.push(sum / (k * k) as f32);
            }
        }
        Some(Heights { w: w as usize, h: h as usize, data })
    }

    /// Bilinear at `uv`, clamped at the edges (the viewport's height sampler).
    fn sample(&self, uv: Vec2) -> f32 {
        let at = |x: isize, y: isize| {
            let (x, y) = (x.clamp(0, self.w as isize - 1) as usize, y.clamp(0, self.h as isize - 1) as usize);
            self.data.get(y * self.w + x).copied().unwrap_or(0.0)
        };
        let (fx, fy) = (uv.x * self.w as f32 - 0.5, uv.y * self.h as f32 - 0.5);
        if !(fx.is_finite() && fy.is_finite()) {
            return 0.0;
        }
        let (x0, y0) = (fx.floor(), fy.floor());
        let (tx, ty) = (fx - x0, fy - y0);
        let (x0, y0) = (x0 as isize, y0 as isize);
        let top = at(x0, y0) * (1.0 - tx) + at(x0 + 1, y0) * tx;
        let bottom = at(x0, y0 + 1) * (1.0 - tx) + at(x0 + 1, y0 + 1) * tx;
        top * (1.0 - ty) + bottom * ty
    }
}

#[cfg(test)]
mod tests {
    use texturecraft_compose::Composite;
    use texturecraft_geom::primitives;

    use super::*;

    /// A plane's set with a uniform height.
    fn set(height: f32, strength: f32) -> TraceSet {
        let mut composite = Composite::new(&[Channel::BaseColor, Channel::Height], 64);
        if let Some(img) = composite.channels.get_mut(&Channel::Height) {
            for (x, y) in texturecraft_compose::all_tiles(64, 64) {
                img.tile_mut(x, y, &[texturecraft_texel::to_u16_signed(height)]);
            }
        }
        TraceSet { material: 0, composite, height_strength: strength }
    }

    #[test]
    fn uniform_height_lifts_the_dense_plane_along_its_normal() {
        let plane = primitives::plane(2.0, 1);
        assert!(displaced(&plane, &[set(0.5, 0.0)]).is_none(), "no strength, nothing to displace");
        assert!(displaced(&plane, &[]).is_none());
        let m = displaced(&plane, &[set(0.5, 2.0)]).unwrap();
        assert!(m.triangle_count() > plane.triangle_count());
        assert_eq!((m.positions.len(), m.uvs.len(), m.normals.len()), (m.tangents.len(), m.positions.len(), m.positions.len()));
        // world per UV is 2 (a 2 × 2 plane over the UV square): 0.5 × 2 × 2 / 16.
        let n = plane.normals[0];
        let lift = m.positions.iter().map(|p| p.dot(n)).collect::<Vec<f32>>();
        assert!(lift.iter().all(|d| (d - 0.125).abs() < 1e-3), "{:?}", &lift[..4]);
        let off = DisplaySettings::default();
        let (mesh, bvh) = (Arc::new(plane), Arc::new(Bvh::new(&primitives::plane(2.0, 1))));
        assert!(Arc::ptr_eq(&trace_geometry(&mesh, &bvh, &[set(0.5, 2.0)], &off).0, &mesh), "off unless the display displaces");
        let on = DisplaySettings { displacement: true, ..DisplaySettings::default() };
        assert!(!Arc::ptr_eq(&trace_geometry(&mesh, &bvh, &[set(0.5, 2.0)], &on).0, &mesh));
    }
}