konjure_sdk/

geometry.rs

use crate::{Diagnostic, Geometry, MAX_COORDINATE_M, Vec3};
use alloc::{format, vec, vec::Vec};
use serde::{Deserialize, Serialize};
#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
#[cfg_attr(feature = "typescript", derive(ts_rs::TS))]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
/// Owned triangle or line mesh generated from a built-in [`Geometry`].
///
/// Each vector has independently allocated storage. Triangle primitives use
/// counter-clockwise index triples when viewed from outside; [`Geometry::Line`] has
/// exactly two indices and zero normals.
pub struct Mesh {
    /// Vertex positions in local metres.
    pub positions: Vec<Vec3>,
    /// Per-vertex unit normals; line meshes use zero vectors.
    pub normals: Vec<Vec3>,
    /// Zero-based indices into [`Self::positions`].
    pub indices: Vec<u32>,
}
/// Tessellates a built-in geometry using fixed deterministic resolution.
///
/// The returned mesh owns newly allocated vertex and index buffers. It neither
/// reads assets nor calls a renderer.
///
/// # Errors
///
/// Returns an error for invalid dimensions, a group, or an adapter-owned mesh
/// asset that this core intentionally cannot resolve.
///
/// ```
/// use konjure_sdk::{tessellate, Geometry};
/// let mesh = tessellate(&Geometry::Sphere { radius_m: 0.5 })?;
/// assert_eq!(mesh.positions.len(), mesh.normals.len());
/// # Ok::<(), konjure_sdk::Diagnostic>(())
/// ```
pub fn tessellate(geometry: &Geometry) -> Result<Mesh, Diagnostic> {
    match geometry {
        Geometry::Group => Err(Diagnostic::plain("a group has no tessellated mesh")),
        Geometry::Sphere { radius_m } => sphere(*radius_m),
        Geometry::Torus {
            major_radius_m,
            minor_radius_m,
        } => torus(*major_radius_m, *minor_radius_m),
        Geometry::Box { size_m } => box_mesh(*size_m),
        Geometry::Cylinder { radius_m, height_m } => cylinder(*radius_m, *height_m),
        Geometry::Plane { width_m, depth_m } => plane(*width_m, *depth_m),
        Geometry::Line { from_m, to_m } => {
            valid_point(*from_m)?;
            valid_point(*to_m)?;
            Ok(Mesh {
                positions: vec![*from_m, *to_m],
                normals: vec![Vec3::ZERO; 2],
                indices: vec![0, 1],
            })
        }
        Geometry::Mesh { asset } => Err(Diagnostic::plain(format!(
            "mesh asset `{asset}` requires an adapter-provided mesh"
        ))),
    }
}
fn valid_point(point: Vec3) -> Result<(), Diagnostic> {
    if [point.x, point.y, point.z]
        .into_iter()
        .all(|value| value.is_finite() && value.abs() <= MAX_COORDINATE_M)
    {
        Ok(())
    } else {
        Err(Diagnostic::plain(
            "line endpoints must be finite and within coordinate bounds",
        ))
    }
}
pub(crate) fn finite_positive(v: f64, what: &str) -> Result<(), Diagnostic> {
    if v.is_finite() && (1e-6..=MAX_COORDINATE_M).contains(&v) {
        Ok(())
    } else {
        Err(Diagnostic::plain(format!(
            "{what} must be finite and between 0.000001 and {MAX_COORDINATE_M}"
        )))
    }
}
fn plane(w: f64, d: f64) -> Result<Mesh, Diagnostic> {
    finite_positive(w, "plane width")?;
    finite_positive(d, "plane depth")?;
    let x = w / 2.;
    let z = d / 2.;
    Ok(Mesh {
        positions: vec![
            Vec3 {
                x: -x,
                y: 0.,
                z: -z,
            },
            Vec3 { x, y: 0., z: -z },
            Vec3 { x, y: 0., z },
            Vec3 { x: -x, y: 0., z },
        ],
        normals: vec![
            Vec3 {
                x: 0.,
                y: 1.,
                z: 0.
            };
            4
        ],
        indices: vec![0, 2, 1, 0, 3, 2],
    })
}
fn box_mesh(s: Vec3) -> Result<Mesh, Diagnostic> {
    finite_positive(s.x, "box width")?;
    finite_positive(s.y, "box height")?;
    finite_positive(s.z, "box depth")?;
    let x = s.x / 2.;
    let y = s.y / 2.;
    let z = s.z / 2.;
    let faces = [
        (
            [
                Vec3 {
                    x: -x,
                    y: -y,
                    z: -z,
                },
                Vec3 { x: -x, y, z: -z },
                Vec3 { x, y, z: -z },
                Vec3 { x, y: -y, z: -z },
            ],
            Vec3 {
                x: 0.,
                y: 0.,
                z: -1.,
            },
        ),
        (
            [
                Vec3 { x: -x, y: -y, z },
                Vec3 { x, y: -y, z },
                Vec3 { x, y, z },
                Vec3 { x: -x, y, z },
            ],
            Vec3 {
                x: 0.,
                y: 0.,
                z: 1.,
            },
        ),
        (
            [
                Vec3 {
                    x: -x,
                    y: -y,
                    z: -z,
                },
                Vec3 { x: -x, y: -y, z },
                Vec3 { x: -x, y, z },
                Vec3 { x: -x, y, z: -z },
            ],
            Vec3 {
                x: -1.,
                y: 0.,
                z: 0.,
            },
        ),
        (
            [
                Vec3 { x, y: -y, z: -z },
                Vec3 { x, y, z: -z },
                Vec3 { x, y, z },
                Vec3 { x, y: -y, z },
            ],
            Vec3 {
                x: 1.,
                y: 0.,
                z: 0.,
            },
        ),
        (
            [
                Vec3 { x: -x, y, z: -z },
                Vec3 { x: -x, y, z },
                Vec3 { x, y, z },
                Vec3 { x, y, z: -z },
            ],
            Vec3 {
                x: 0.,
                y: 1.,
                z: 0.,
            },
        ),
        (
            [
                Vec3 {
                    x: -x,
                    y: -y,
                    z: -z,
                },
                Vec3 { x, y: -y, z: -z },
                Vec3 { x, y: -y, z },
                Vec3 { x: -x, y: -y, z },
            ],
            Vec3 {
                x: 0.,
                y: -1.,
                z: 0.,
            },
        ),
    ];
    let mut positions = Vec::with_capacity(24);
    let mut normals = Vec::with_capacity(24);
    let mut indices = Vec::with_capacity(36);
    for (face, normal) in faces {
        let start = positions.len() as u32;
        positions.extend_from_slice(&face);
        normals.extend_from_slice(&[normal; 4]);
        indices.extend_from_slice(&[start, start + 1, start + 2, start, start + 2, start + 3]);
    }
    Ok(Mesh {
        positions,
        normals,
        indices,
    })
}
fn sphere(r: f64) -> Result<Mesh, Diagnostic> {
    finite_positive(r, "sphere radius")?;
    let (rings, segments) = (16usize, 32usize);
    let mut p = Vec::with_capacity((rings + 1) * (segments + 1));
    let mut n = Vec::with_capacity(p.capacity());
    for y in 0..=rings {
        let v = y as f64 / rings as f64;
        let phi = v * core::f64::consts::PI;
        for x in 0..=segments {
            let u = x as f64 / segments as f64;
            let t = u * 2. * core::f64::consts::PI;
            let q = Vec3 {
                x: libm::sin(phi) * libm::cos(t),
                y: libm::cos(phi),
                z: libm::sin(phi) * libm::sin(t),
            };
            p.push(Vec3 {
                x: q.x * r,
                y: q.y * r,
                z: q.z * r,
            });
            n.push(q)
        }
    }
    let mut i = Vec::new();
    for y in 0..rings {
        for x in 0..segments {
            let a = (y * (segments + 1) + x) as u32;
            let b = a + segments as u32 + 1;
            i.extend_from_slice(&[a, a + 1, b, a + 1, b + 1, b])
        }
    }
    Ok(Mesh {
        positions: p,
        normals: n,
        indices: i,
    })
}
fn torus(major: f64, minor: f64) -> Result<Mesh, Diagnostic> {
    finite_positive(major, "torus major radius")?;
    finite_positive(minor, "torus minor radius")?;
    if minor >= major {
        return Err(Diagnostic::plain(
            "torus minor radius must be less than major radius",
        ));
    }
    let (rings, segments) = (48usize, 12usize);
    let mut positions = Vec::with_capacity((rings + 1) * (segments + 1));
    let mut normals = Vec::with_capacity(positions.capacity());
    for ring in 0..=rings {
        let u = ring as f64 / rings as f64 * 2. * core::f64::consts::PI;
        let (cu, su) = (libm::cos(u), libm::sin(u));
        for segment in 0..=segments {
            let v = segment as f64 / segments as f64 * 2. * core::f64::consts::PI;
            let (cv, sv) = (libm::cos(v), libm::sin(v));
            let normal = Vec3 {
                x: cu * cv,
                y: sv,
                z: su * cv,
            };
            positions.push(Vec3 {
                x: (major + minor * cv) * cu,
                y: minor * sv,
                z: (major + minor * cv) * su,
            });
            normals.push(normal);
        }
    }
    let mut indices = Vec::with_capacity(rings * segments * 6);
    for ring in 0..rings {
        for segment in 0..segments {
            let a = (ring * (segments + 1) + segment) as u32;
            let b = a + segments as u32 + 1;
            indices.extend_from_slice(&[a, a + 1, b, a + 1, b + 1, b]);
        }
    }
    Ok(Mesh {
        positions,
        normals,
        indices,
    })
}
fn cylinder(r: f64, h: f64) -> Result<Mesh, Diagnostic> {
    finite_positive(r, "cylinder radius")?;
    finite_positive(h, "cylinder height")?;
    let segments = 16usize;
    let mut p = Vec::with_capacity(2 * segments + 2);
    let mut n = Vec::with_capacity(p.capacity());
    for y in [-h / 2., h / 2.] {
        for x in 0..segments {
            let t = x as f64 / segments as f64 * 2. * core::f64::consts::PI;
            let q = Vec3 {
                x: libm::cos(t),
                y: 0.,
                z: libm::sin(t),
            };
            p.push(Vec3 {
                x: q.x * r,
                y,
                z: q.z * r,
            });
            n.push(q)
        }
    }
    let bottom = p.len() as u32;
    p.push(Vec3 {
        x: 0.,
        y: -h / 2.,
        z: 0.,
    });
    n.push(Vec3 {
        x: 0.,
        y: -1.,
        z: 0.,
    });
    let top = p.len() as u32;
    p.push(Vec3 {
        x: 0.,
        y: h / 2.,
        z: 0.,
    });
    n.push(Vec3 {
        x: 0.,
        y: 1.,
        z: 0.,
    });
    let mut i = Vec::new();
    for x in 0..segments {
        let next = (x + 1) % segments;
        i.extend_from_slice(&[
            x as u32,
            (x + segments) as u32,
            next as u32,
            next as u32,
            (x + segments) as u32,
            (next + segments) as u32,
            bottom,
            x as u32,
            next as u32,
            top,
            (next + segments) as u32,
            (x + segments) as u32,
        ]);
    }
    Ok(Mesh {
        positions: p,
        normals: n,
        indices: i,
    })
}