alice-sdf 4.1.0

//! Mesh conversion for SDFs (Deep Fried Edition v2)
//!
//! Convert between polygon meshes and SDF representations.
//!
//! # Deep Fried Optimizations
//! - **Z-Slab Parallelization**: Marching Cubes processes Z-layers in parallel.
//! - **Edge Deduplication**: Mesh-to-SDF uses HashSet to halve capsule count.
//! - **BVH Acceleration**: O(log n) distance queries for exact mesh SDF.
//! - **Forced Inlining**: All hot-path functions use `#[inline(always)]`.
//!
//! # Conversion Strategies
//!
//! - **Capsule Approximation** (`mesh_to_sdf`): Fast but approximate. Creates an
//!   SdfNode tree by representing edges as capsules.
//!
//! - **BVH Exact** (`mesh_to_sdf_exact`): Accurate signed distance using BVH.
//!   Cannot be converted to shaders but provides exact mesh distance queries.
//!
//! # Advanced Features
//!
//! - **Hermite Data** (`hermite`): Extract position + normal data for Dual Contouring.
//!
//! - **Primitive Fitting** (`primitive_fitting`): Detect and fit geometric primitives
//!   (sphere, box, cylinder) to mesh data for CSG reconstruction.
//!
//! - **Nanite Clusters** (`nanite`): Generate UE5 Nanite-compatible hierarchical clusters.
//!
//! - **LOD Generation** (`lod`): Generate level-of-detail chains for efficient rendering.
//!
//! Author: Moroya Sakamoto

/// Caller-supplied input rejected by a mesh codec / stripifier `try_*` entry point.
///
/// The panicking counterparts (`stripify`, `encode_index_buffer`,
/// `encode_filter_oct_i16`, ...) keep their 1.x signature and forward to the
/// `try_*` form; FFI / engine hosts should call the `try_*` form so that bad
/// input is an error code rather than a process abort.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct MeshInputError {
    /// Why the input was rejected.
    pub reason: &'static str,
}

impl std::fmt::Display for MeshInputError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.reason)
    }
}

impl std::error::Error for MeshInputError {}

pub mod bvh;
pub mod collision;
pub mod decimate;
pub mod dual_contouring;
pub mod hermite;
pub mod lightmap;
pub mod lod;
pub mod lod_persist;
pub mod manifold;
pub mod mesh_codec;
pub mod mesh_sign;
mod mesh_to_sdf;
pub mod meshlet;
pub mod meshopt_filter;
pub mod meshopt_index_codec;
pub mod meshopt_vertex_codec;
pub mod nanite;
pub mod optimize;
pub mod overdraw;
pub mod point_cloud_sdf;
pub mod primitive_fitting;
pub mod quantization;
mod sdf_to_mesh;
pub mod spatial_order;
pub mod stripifier;
pub mod uv_unwrap;

#[cfg(feature = "gpu")]
pub mod gpu_marching_cubes;
#[cfg(feature = "gpu")]
pub mod gpu_mc_shaders;

pub use bvh::{Aabb, BvhNode, MeshBvh, Triangle as BvhTriangle};
pub use collision::{
    compute_aabb, compute_bounding_sphere, compute_convex_hull, convex_decomposition,
    convex_hull_from_points, simplify_collision, BoundingSphere, CollisionAabb, CollisionMesh,
    ConvexDecomposition, ConvexHull, VhacdConfig,
};
pub use decimate::{decimate, DecimateConfig};
pub use dual_contouring::{dual_contouring, dual_contouring_compiled, DualContouringConfig};
#[cfg(feature = "gpu")]
pub use gpu_marching_cubes::{
    gpu_marching_cubes, gpu_marching_cubes_from_shader, GpuMarchingCubesConfig,
};
pub use hermite::{
    extract_edge_crossings, extract_hermite, EdgeCrossing, HermiteConfig, HermiteExtractor,
    HermitePoint,
};
pub use lightmap::{generate_lightmap_uvs, generate_lightmap_uvs_fast};
pub use lod::{
    generate_lod_chain, generate_lod_chain_decimated, ContinuousLod, DecimationLodConfig, LodChain,
    LodConfig, LodMesh, LodSelector,
};
pub use lod_persist::{
    load_lod_chain, load_lod_chain_metadata, save_lod_chain, save_lod_chain_metadata,
    LodChainConfig, LodChainPersist, LodChainSummary, LodLevelPersist,
};
pub use manifold::{compute_quality, validate_mesh, MeshQuality, MeshRepair, MeshValidation};
pub use mesh_sign::{ExteriorField, MeshSignMode};
pub use mesh_to_sdf::{
    mesh_to_sdf, mesh_to_sdf_exact, MeshSdf, MeshToSdfConfig, MeshToSdfStrategy,
    DEFAULT_SIGN_FLOOD_FILL_RESOLUTION,
};
pub use nanite::{
    generate_nanite_mesh, ClusterBounds, ClusterGroup, LodLevel, NaniteCluster, NaniteConfig,
    NaniteMesh, CLUSTER_MAX_TRIANGLES, CLUSTER_MAX_VERTICES,
};
pub use optimize::{
    compute_acmr, deduplicate_vertices, optimize_vertex_cache, remove_degenerate_triangles,
};
pub use point_cloud_sdf::{point_cloud_to_sdf, PointCloudSdf, PointCloudSdfConfig};
pub use primitive_fitting::{
    detect_primitive, fit_box, fit_cylinder, fit_plane, fit_sphere, primitives_to_csg,
    FittedPrimitive, FittingConfig, FittingResult, PrimitiveType,
};
pub use sdf_to_mesh::{
    adaptive_marching_cubes, adaptive_marching_cubes_compiled, marching_cubes,
    marching_cubes_compiled, sdf_to_mesh, sdf_to_mesh_compiled, AdaptiveConfig,
    MarchingCubesConfig, Mesh,
};
pub use uv_unwrap::{apply_uvs, uv_unwrap, UvChart, UvUnwrapConfig, UvUnwrapResult};

/// Vertex with position, normal, UV, tangent, color, and material ID
///
/// Compatible with standard game engine vertex formats (UE5, Unity, Godot).
/// Includes UV2 for lightmap coordinates.
#[derive(Debug, Clone, Copy, Default, serde::Serialize, serde::Deserialize)]
pub struct Vertex {
    /// Position in 3D space
    pub position: glam::Vec3,
    /// Surface normal (normalized)
    pub normal: glam::Vec3,
    /// Texture coordinates (triplanar projected)
    pub uv: glam::Vec2,
    /// Lightmap UV coordinates (UV channel 1)
    pub uv2: glam::Vec2,
    /// Tangent vector (xyz = direction, w = handedness sign)
    pub tangent: glam::Vec4,
    /// Vertex color (RGBA, linear space)
    pub color: [f32; 4],
    /// Material ID (indexes into MaterialLibrary)
    pub material_id: u32,
}

impl Vertex {
    /// Create a new vertex with position and normal (UV/tangent/color default)
    pub const fn new(position: glam::Vec3, normal: glam::Vec3) -> Self {
        Self {
            position,
            normal,
            uv: glam::Vec2::ZERO,
            uv2: glam::Vec2::ZERO,
            tangent: glam::Vec4::new(1.0, 0.0, 0.0, 1.0),
            color: [1.0, 1.0, 1.0, 1.0],
            material_id: 0,
        }
    }

    /// Create a vertex with all fields specified
    pub const fn with_all(
        position: glam::Vec3,
        normal: glam::Vec3,
        uv: glam::Vec2,
        uv2: glam::Vec2,
        tangent: glam::Vec4,
        color: [f32; 4],
        material_id: u32,
    ) -> Self {
        Self {
            position,
            normal,
            uv,
            uv2,
            tangent,
            color,
            material_id,
        }
    }
}

/// Triangle face indices
#[derive(Debug, Clone, Copy, serde::Serialize, serde::Deserialize)]
pub struct Triangle {
    /// First vertex index
    pub a: u32,
    /// Second vertex index
    pub b: u32,
    /// Third vertex index
    pub c: u32,
}

impl Triangle {
    /// Create a new triangle
    pub const fn new(a: u32, b: u32, c: u32) -> Self {
        Self { a, b, c }
    }
}