alice-sdf 5.1.0

//! Godot GDExtension integration for ALICE-SDF
//!
//! Provides native Godot 4.x nodes for SDF modeling and mesh generation.
//!
//! # Nodes
//! - `AliceSdfNode`: SDF tree builder exposed as a Godot Node3D
//! - `AliceSdfMeshInstance`: Auto-generates mesh from SDF with LOD support
//! - `AliceSdfResource`: Serializable SDF resource for the Godot inspector
//!
//! # Usage
//! ```gdscript
//! var sdf = AliceSdfNode.new()
//! sdf.set_shape("sphere", {"radius": 1.0})
//! sdf.boolean_union(other_sdf)
//! var mesh_inst = AliceSdfMeshInstance.new()
//! mesh_inst.set_sdf(sdf)
//! mesh_inst.resolution = 64
//! add_child(mesh_inst)
//! ```
//!
//! Author: Moroya Sakamoto

use godot::classes::{
    ArrayMesh, CollisionShape3D, ConvexPolygonShape3D, IMeshInstance3D, INode3D, IResource,
    MeshInstance3D, Node3D, Resource,
};
use godot::prelude::*;
use std::sync::Arc;

use crate::compiled::{eval_compiled_batch_parallel, CompiledSdf};
use crate::mesh::{sdf_to_mesh, MarchingCubesConfig};
use crate::types::SdfNode;

/// GDExtension entry point
struct AliceSdfExtension;

// SAFETY: `AliceSdfExtension` is an empty unit struct with no state.
// The `#[gdextension]` macro generates the GDExtension entry-point callbacks
// (init, deinit, get_minimum_library_level) that Godot calls exactly once
// during plugin load/unload. No thread-safety or aliasing concerns arise
// because the struct carries no data and the callbacks are invoked
// sequentially by the Godot engine's main thread.
#[gdextension]
unsafe impl ExtensionLibrary for AliceSdfExtension {}

// ============================================================
// AliceSdfResource — Serializable SDF for Godot inspector
// ============================================================

/// A serializable SDF resource that can be saved/loaded in Godot
#[derive(GodotClass)]
#[class(base=Resource, tool)]
pub struct AliceSdfResource {
    base: Base<Resource>,

    /// Internal SDF node (not directly exposed to GDScript)
    #[var]
    shape_type: GString,

    /// Shape parameters as JSON string (for Godot serialization)
    #[var]
    shape_params_json: GString,

    /// Cached SDF node
    sdf_cache: Option<SdfNode>,
}

#[godot_api]
impl IResource for AliceSdfResource {
    fn init(base: Base<Resource>) -> Self {
        Self {
            base,
            shape_type: "sphere".into(),
            shape_params_json: r#"{"radius":1.0}"#.into(),
            sdf_cache: None,
        }
    }
}

#[godot_api]
impl AliceSdfResource {
    /// Set shape type and parameters
    #[func]
    fn set_shape(&mut self, shape_type: GString, params_json: GString) {
        self.shape_type = shape_type;
        self.shape_params_json = params_json;
        self.sdf_cache = None; // invalidate cache
    }

    /// Build the SdfNode from current parameters
    #[func]
    fn build_sdf(&mut self) -> bool {
        let shape = self.shape_type.to_string();
        let params = self.shape_params_json.to_string();

        let node = match build_sdf_from_params(&shape, &params) {
            Some(n) => n,
            None => return false,
        };

        self.sdf_cache = Some(node);
        true
    }

    /// Get available shape types
    #[func]
    fn get_available_shapes() -> PackedStringArray {
        let shapes = vec![
            // Basic primitives (10)
            "sphere",
            "box",
            "cylinder",
            "torus",
            "plane",
            "capsule",
            "cone",
            "ellipsoid",
            "rounded_cone",
            "pyramid",
            // Platonic & Archimedean solids (10)
            "octahedron",
            "hex_prism",
            "tetrahedron",
            "dodecahedron",
            "icosahedron",
            "truncated_octahedron",
            "truncated_icosahedron",
            "link",
            "triangle",
            "bezier",
            // Rounded & capped shapes (10)
            "rounded_box",
            "capped_cone",
            "capped_torus",
            "rounded_cylinder",
            "triangular_prism",
            "cut_sphere",
            "cut_hollow_sphere",
            "death_star",
            "solid_angle",
            "rhombus",
            // Organic & curved shapes (10)
            "horseshoe",
            "vesica",
            "heart",
            "tube",
            "barrel",
            "diamond",
            "egg",
            "moon",
            "cross_shape",
            "blobby_cross",
            // TPMS (triply periodic minimal surfaces) (10)
            "gyroid",
            "schwarz_p",
            "diamond_surface",
            "neovius",
            "lidinoid",
            "iwp",
            "frd",
            "fischer_koch_s",
            "pmy",
            "chamfered_cube",
            // Geometric extrusions (10)
            "superellipsoid",
            "rounded_x",
            "pie",
            "trapezoid",
            "parallelogram",
            "tunnel",
            "uneven_capsule",
            "arc_shape",
            "parabola_segment",
            "regular_polygon",
            // Advanced shapes (10)
            "star_polygon",
            "stairs",
            "helix",
            "box_frame",
            "infinite_cylinder",
            "infinite_cone",
            "circle_2d",
            "rect_2d",
            "segment_2d",
            "polygon_2d",
            // 2D primitives (2)
            "rounded_rect_2d",
            "annular_2d",
        ];
        let mut arr = PackedStringArray::new();
        for s in shapes {
            arr.push(&GString::from(s));
        }
        arr
    }
}

// ============================================================
// AliceSdfNode — SDF tree builder as Node3D
// ============================================================

/// A Node3D that represents an SDF shape in the scene tree
#[derive(GodotClass)]
#[class(base=Node3D, tool)]
pub struct AliceSdfNode {
    base: Base<Node3D>,

    /// Shape type
    #[var]
    shape: GString,

    /// Radius (for sphere, torus, etc.)
    #[var]
    radius: f32,

    /// Half extents (for box)
    #[var]
    half_extents: Vector3,

    /// Height (for cylinder, cone)
    #[var]
    height: f32,

    /// Smoothing factor for boolean operations
    #[var]
    smooth_k: f32,

    /// Built SDF node
    sdf_node: Option<SdfNode>,
}

#[godot_api]
impl INode3D for AliceSdfNode {
    fn init(base: Base<Node3D>) -> Self {
        Self {
            base,
            shape: "sphere".into(),
            radius: 1.0,
            half_extents: Vector3::new(0.5, 0.5, 0.5),
            height: 2.0,
            smooth_k: 0.0,
            sdf_node: None,
        }
    }
}

#[godot_api]
impl AliceSdfNode {
    /// Build the SDF from current node properties
    #[func]
    fn build(&mut self) -> bool {
        let node = match self.shape.to_string().as_str() {
            // Basic primitives
            "sphere" => SdfNode::sphere(self.radius),
            "box" => SdfNode::box3d(
                self.half_extents.x * 2.0,
                self.half_extents.y * 2.0,
                self.half_extents.z * 2.0,
            ),
            "cylinder" => SdfNode::cylinder(self.radius, self.height),
            "torus" => SdfNode::torus(self.radius, self.radius * 0.3),
            "capsule" => {
                let a = glam::Vec3::new(0.0, -self.height * 0.5, 0.0);
                let b = glam::Vec3::new(0.0, self.height * 0.5, 0.0);
                SdfNode::capsule(a, b, self.radius)
            }
            "cone" => SdfNode::cone(self.radius, self.height),
            "ellipsoid" => SdfNode::ellipsoid(
                self.half_extents.x,
                self.half_extents.y,
                self.half_extents.z,
            ),
            "rounded_box" => SdfNode::rounded_box(
                self.half_extents.x,
                self.half_extents.y,
                self.half_extents.z,
                self.radius * 0.1,
            ),
            "pyramid" => SdfNode::pyramid(self.height),
            "octahedron" => SdfNode::octahedron(self.radius),
            "hex_prism" => SdfNode::hex_prism(self.radius, self.height),
            "gyroid" => SdfNode::gyroid(self.radius, 0.1),
            "schwarz_p" => SdfNode::schwarz_p(self.radius, 0.1),
            "heart" => SdfNode::heart(self.radius),
            "tube" => SdfNode::tube(self.radius, self.radius * 0.2, self.height),
            "barrel" => SdfNode::barrel(self.radius, self.height, self.radius * 0.1),
            "diamond" => SdfNode::diamond(self.radius, self.height),
            "helix" => SdfNode::helix(
                self.radius,
                self.radius * 0.2,
                self.height * 0.5,
                self.height,
            ),
            "superellipsoid" => SdfNode::superellipsoid(
                self.half_extents.x * 2.0,
                self.half_extents.y * 2.0,
                self.half_extents.z * 2.0,
                0.5,
                0.5,
            ),
            "star_polygon" => SdfNode::star_polygon(self.radius, 5, self.radius * 0.5, self.height),
            _ => return false,
        };
        self.sdf_node = Some(node);
        true
    }

    /// Perform smooth union with another AliceSdfNode
    #[func]
    fn boolean_union(&mut self, other: Gd<AliceSdfNode>) {
        let other_sdf = {
            let other_ref = other.bind();
            other_ref.sdf_node.clone()
        };
        if let (Some(a), Some(b)) = (self.sdf_node.take(), other_sdf) {
            self.sdf_node = Some(if self.smooth_k > 0.0 {
                a.smooth_union(b, self.smooth_k)
            } else {
                a.union(b)
            });
        }
    }

    /// Perform smooth subtraction with another AliceSdfNode
    #[func]
    fn boolean_subtract(&mut self, other: Gd<AliceSdfNode>) {
        let other_sdf = {
            let other_ref = other.bind();
            other_ref.sdf_node.clone()
        };
        if let (Some(a), Some(b)) = (self.sdf_node.take(), other_sdf) {
            self.sdf_node = Some(if self.smooth_k > 0.0 {
                a.smooth_subtract(b, self.smooth_k)
            } else {
                a.subtract(b)
            });
        }
    }

    /// Perform smooth intersection with another AliceSdfNode
    #[func]
    fn boolean_intersect(&mut self, other: Gd<AliceSdfNode>) {
        let other_sdf = {
            let other_ref = other.bind();
            other_ref.sdf_node.clone()
        };
        if let (Some(a), Some(b)) = (self.sdf_node.take(), other_sdf) {
            self.sdf_node = Some(if self.smooth_k > 0.0 {
                a.smooth_intersection(b, self.smooth_k)
            } else {
                a.intersection(b)
            });
        }
    }

    /// Evaluate the SDF distance at a point
    #[func]
    fn eval_distance(&self, point: Vector3) -> f32 {
        match &self.sdf_node {
            Some(node) => crate::eval::eval(node, glam::Vec3::new(point.x, point.y, point.z)),
            None => f32::MAX,
        }
    }

    /// Apply twist modifier
    #[func]
    fn apply_twist(&mut self, strength: f32) {
        if let Some(node) = self.sdf_node.take() {
            self.sdf_node = Some(node.twist(strength));
        }
    }

    /// Apply bend modifier
    #[func]
    fn apply_bend(&mut self, curvature: f32) {
        if let Some(node) = self.sdf_node.take() {
            self.sdf_node = Some(node.bend(curvature));
        }
    }

    /// Apply mirror modifier
    #[func]
    fn apply_mirror(&mut self, axis: Vector3) {
        if let Some(node) = self.sdf_node.take() {
            self.sdf_node = Some(node.mirror(axis.x > 0.5, axis.y > 0.5, axis.z > 0.5));
        }
    }

    /// Apply onion (shell) modifier
    #[func]
    fn apply_onion(&mut self, thickness: f32) {
        if let Some(node) = self.sdf_node.take() {
            self.sdf_node = Some(node.onion(thickness));
        }
    }

    /// Apply round modifier
    #[func]
    fn apply_round(&mut self, radius: f32) {
        if let Some(node) = self.sdf_node.take() {
            self.sdf_node = Some(node.round(radius));
        }
    }

    /// Apply icosahedral symmetry (120-fold)
    #[func]
    fn apply_icosahedral_symmetry(&mut self) {
        if let Some(node) = self.sdf_node.take() {
            self.sdf_node = Some(node.icosahedral_symmetry());
        }
    }

    /// Apply surface roughness
    #[func]
    fn apply_surface_roughness(&mut self, frequency: f32, amplitude: f32, octaves: i32) {
        if let Some(node) = self.sdf_node.take() {
            self.sdf_node =
                Some(node.surface_roughness(frequency, amplitude, octaves.max(1) as u32));
        }
    }

    /// Apply noise displacement
    #[func]
    fn apply_noise(&mut self, amplitude: f32, frequency: f32, seed: i32) {
        if let Some(node) = self.sdf_node.take() {
            self.sdf_node = Some(node.noise(amplitude, frequency, seed as u32));
        }
    }

    /// Apply polar repeat around Y axis
    #[func]
    fn apply_polar_repeat(&mut self, count: i32) {
        if let Some(node) = self.sdf_node.take() {
            self.sdf_node = Some(node.polar_repeat(count.max(1) as u32));
        }
    }

    /// Apply octant mirror (48-fold symmetry)
    #[func]
    fn apply_octant_mirror(&mut self) {
        if let Some(node) = self.sdf_node.take() {
            self.sdf_node = Some(node.octant_mirror());
        }
    }

    /// Export SDF to GLSL shader code
    #[func]
    fn to_glsl(&self) -> GString {
        #[cfg(feature = "glsl")]
        {
            use crate::compiled::glsl::{GlslShader, GlslTranspileMode};
            match &self.sdf_node {
                Some(node) => {
                    GString::from(GlslShader::transpile(node, GlslTranspileMode::Hardcoded).source)
                }
                None => GString::new(),
            }
        }
        #[cfg(not(feature = "glsl"))]
        {
            GString::from("GLSL feature not enabled")
        }
    }
}

// ============================================================
// AliceSdfMeshInstance — Auto mesh generation from SDF
// ============================================================

/// A MeshInstance3D that automatically generates a mesh from an SDF
#[derive(GodotClass)]
#[class(base=MeshInstance3D, tool)]
pub struct AliceSdfMeshInstance {
    base: Base<MeshInstance3D>,

    /// Marching Cubes resolution
    #[var]
    resolution: i32,

    /// Bounds size (half-extent of the evaluation volume)
    #[var]
    bounds_size: f32,

    /// Auto-rebuild mesh when SDF changes
    #[var]
    auto_rebuild: bool,

    /// Cached SDF for mesh generation
    cached_sdf: Option<SdfNode>,
}

#[godot_api]
impl IMeshInstance3D for AliceSdfMeshInstance {
    fn init(base: Base<MeshInstance3D>) -> Self {
        Self {
            base,
            resolution: 32,
            bounds_size: 2.0,
            auto_rebuild: true,
            cached_sdf: None,
        }
    }
}

#[godot_api]
impl AliceSdfMeshInstance {
    /// Set the SDF source from an AliceSdfNode
    #[func]
    fn set_sdf_from_node(&mut self, node: Gd<AliceSdfNode>) {
        let sdf = {
            let node_ref = node.bind();
            node_ref.sdf_node.clone()
        };
        self.cached_sdf = sdf;
        if self.auto_rebuild {
            self.rebuild_mesh();
        }
    }

    /// Set the SDF source from an AliceSdfResource
    #[func]
    fn set_sdf_from_resource(&mut self, mut resource: Gd<AliceSdfResource>) {
        {
            let mut res = resource.bind_mut();
            res.build_sdf();
        }
        let sdf = {
            let res = resource.bind();
            res.sdf_cache.clone()
        };
        self.cached_sdf = sdf;
        if self.auto_rebuild {
            self.rebuild_mesh();
        }
    }

    /// Rebuild the mesh from the current SDF
    #[func]
    fn rebuild_mesh(&mut self) {
        let sdf = match &self.cached_sdf {
            Some(s) => s,
            None => return,
        };

        let bounds = self.bounds_size;
        let min_bounds = glam::Vec3::splat(-bounds);
        let max_bounds = glam::Vec3::splat(bounds);

        let config = MarchingCubesConfig {
            resolution: self.resolution.max(4) as usize,
            ..Default::default()
        };

        let mesh = sdf_to_mesh(sdf, min_bounds, max_bounds, &config);

        if mesh.vertices.is_empty() {
            return;
        }

        // Convert to Godot ArrayMesh
        let godot_mesh = alice_mesh_to_godot(&mesh);
        self.base_mut()
            .set_mesh(&godot_mesh.upcast::<godot::classes::Mesh>());
    }

    /// Get vertex count of the current mesh
    #[func]
    fn get_vertex_count(&self) -> i32 {
        if let Some(mesh) = self.base().get_mesh() {
            if let Ok(array_mesh) = mesh.try_cast::<ArrayMesh>() {
                let mut total = 0i32;
                for i in 0..array_mesh.get_surface_count() {
                    let arrays = array_mesh.surface_get_arrays(i);
                    if let Some(verts) = arrays.get(0) {
                        if let Ok(packed) = verts.try_to::<PackedVector3Array>() {
                            total += packed.len() as i32;
                        }
                    }
                }
                return total;
            }
        }
        0
    }
}

// ============================================================
// Helper functions
// ============================================================

/// Convert ALICE Mesh to Godot ArrayMesh
fn alice_mesh_to_godot(mesh: &crate::mesh::Mesh) -> Gd<ArrayMesh> {
    use godot::classes::mesh::PrimitiveType;
    use godot::classes::rendering_server::ArrayType;

    let mut array_mesh = ArrayMesh::new_gd();

    let vert_count = mesh.vertices.len();
    let mut positions = PackedVector3Array::new();
    let mut normals = PackedVector3Array::new();
    let mut uvs = PackedVector2Array::new();
    let mut indices = PackedInt32Array::new();

    positions.resize(vert_count);
    normals.resize(vert_count);
    uvs.resize(vert_count);

    for (i, v) in mesh.vertices.iter().enumerate() {
        positions[i] = Vector3::new(v.position.x, v.position.y, v.position.z);
        normals[i] = Vector3::new(v.normal.x, v.normal.y, v.normal.z);
        uvs[i] = Vector2::new(v.uv.x, v.uv.y);
    }

    indices.resize(mesh.indices.len());
    for (i, &idx) in mesh.indices.iter().enumerate() {
        indices[i] = idx as i32;
    }

    let mut arrays = VariantArray::new();
    arrays.resize(ArrayType::MAX.ord() as usize, &Variant::nil());
    arrays.set(ArrayType::VERTEX.ord() as usize, &positions.to_variant());
    arrays.set(ArrayType::NORMAL.ord() as usize, &normals.to_variant());
    arrays.set(ArrayType::TEX_UV.ord() as usize, &uvs.to_variant());
    arrays.set(ArrayType::INDEX.ord() as usize, &indices.to_variant());

    array_mesh.add_surface_from_arrays(PrimitiveType::TRIANGLES, &arrays);

    array_mesh
}

/// Build SdfNode from shape name and JSON params
fn build_sdf_from_params(shape: &str, params_json: &str) -> Option<SdfNode> {
    let params: serde_json::Value = serde_json::from_str(params_json).ok()?;

    match shape {
        // === Basic Primitives ===
        "sphere" => {
            let radius = params.get("radius")?.as_f64()? as f32;
            Some(SdfNode::sphere(radius))
        }
        "box" => {
            let w = params.get("width")?.as_f64()? as f32;
            let h = params.get("height")?.as_f64()? as f32;
            let d = params.get("depth")?.as_f64()? as f32;
            Some(SdfNode::box3d(w, h, d))
        }
        "cylinder" => {
            let r = params.get("radius")?.as_f64()? as f32;
            let h = params.get("height")?.as_f64()? as f32;
            Some(SdfNode::cylinder(r, h))
        }
        "torus" => {
            let major = params.get("major_radius")?.as_f64()? as f32;
            let minor = params.get("minor_radius")?.as_f64()? as f32;
            Some(SdfNode::torus(major, minor))
        }
        "plane" => {
            let nx = params
                .get("normal_x")
                .and_then(|v| v.as_f64())
                .unwrap_or(0.0) as f32;
            let ny = params
                .get("normal_y")
                .and_then(|v| v.as_f64())
                .unwrap_or(1.0) as f32;
            let nz = params
                .get("normal_z")
                .and_then(|v| v.as_f64())
                .unwrap_or(0.0) as f32;
            let dist = params
                .get("distance")
                .and_then(|v| v.as_f64())
                .unwrap_or(0.0) as f32;
            Some(SdfNode::plane(glam::Vec3::new(nx, ny, nz), dist))
        }
        "capsule" => {
            let ax = params.get("ax").and_then(|v| v.as_f64()).unwrap_or(0.0) as f32;
            let ay = params.get("ay").and_then(|v| v.as_f64()).unwrap_or(-1.0) as f32;
            let az = params.get("az").and_then(|v| v.as_f64()).unwrap_or(0.0) as f32;
            let bx = params.get("bx").and_then(|v| v.as_f64()).unwrap_or(0.0) as f32;
            let by = params.get("by").and_then(|v| v.as_f64()).unwrap_or(1.0) as f32;
            let bz = params.get("bz").and_then(|v| v.as_f64()).unwrap_or(0.0) as f32;
            let r = params.get("radius")?.as_f64()? as f32;
            Some(SdfNode::capsule(
                glam::Vec3::new(ax, ay, az),
                glam::Vec3::new(bx, by, bz),
                r,
            ))
        }
        "cone" => {
            let r = params.get("radius")?.as_f64()? as f32;
            let h = params.get("height")?.as_f64()? as f32;
            Some(SdfNode::cone(r, h))
        }
        "ellipsoid" => {
            let rx = params.get("rx")?.as_f64()? as f32;
            let ry = params.get("ry")?.as_f64()? as f32;
            let rz = params.get("rz")?.as_f64()? as f32;
            Some(SdfNode::ellipsoid(rx, ry, rz))
        }
        "rounded_cone" => {
            let r1 = params.get("r1")?.as_f64()? as f32;
            let r2 = params.get("r2")?.as_f64()? as f32;
            let h = params.get("height")?.as_f64()? as f32;
            Some(SdfNode::rounded_cone(r1, r2, h))
        }
        "pyramid" => {
            let h = params.get("height")?.as_f64()? as f32;
            Some(SdfNode::pyramid(h))
        }

        // === Platonic & Archimedean Solids ===
        "octahedron" => {
            let size = params.get("size")?.as_f64()? as f32;
            Some(SdfNode::octahedron(size))
        }
        "hex_prism" => {
            let hex_radius = params.get("hex_radius")?.as_f64()? as f32;
            let h = params.get("height")?.as_f64()? as f32;
            Some(SdfNode::hex_prism(hex_radius, h))
        }
        "link" => {
            let length = params.get("length")?.as_f64()? as f32;
            let r1 = params.get("r1")?.as_f64()? as f32;
            let r2 = params.get("r2")?.as_f64()? as f32;
            Some(SdfNode::link(length, r1, r2))
        }
        "triangle" => {
            let ax = params.get("ax")?.as_f64()? as f32;
            let ay = params.get("ay")?.as_f64()? as f32;
            let az = params.get("az")?.as_f64()? as f32;
            let bx = params.get("bx")?.as_f64()? as f32;
            let by = params.get("by")?.as_f64()? as f32;
            let bz = params.get("bz")?.as_f64()? as f32;
            let cx = params.get("cx")?.as_f64()? as f32;
            let cy = params.get("cy")?.as_f64()? as f32;
            let cz = params.get("cz")?.as_f64()? as f32;
            Some(SdfNode::triangle(
                glam::Vec3::new(ax, ay, az),
                glam::Vec3::new(bx, by, bz),
                glam::Vec3::new(cx, cy, cz),
            ))
        }
        "bezier" => {
            let ax = params.get("ax")?.as_f64()? as f32;
            let ay = params.get("ay")?.as_f64()? as f32;
            let az = params.get("az")?.as_f64()? as f32;
            let bx = params.get("bx")?.as_f64()? as f32;
            let by = params.get("by")?.as_f64()? as f32;
            let bz = params.get("bz")?.as_f64()? as f32;
            let cx = params.get("cx")?.as_f64()? as f32;
            let cy = params.get("cy")?.as_f64()? as f32;
            let cz = params.get("cz")?.as_f64()? as f32;
            let r = params.get("radius")?.as_f64()? as f32;
            Some(SdfNode::bezier(
                glam::Vec3::new(ax, ay, az),
                glam::Vec3::new(bx, by, bz),
                glam::Vec3::new(cx, cy, cz),
                r,
            ))
        }

        // === Rounded & Capped Shapes ===
        "rounded_box" => {
            let hx = params.get("hx")?.as_f64()? as f32;
            let hy = params.get("hy")?.as_f64()? as f32;
            let hz = params.get("hz")?.as_f64()? as f32;
            let rr = params
                .get("round_radius")
                .and_then(|v| v.as_f64())
                .unwrap_or(0.1) as f32;
            Some(SdfNode::rounded_box(hx, hy, hz, rr))
        }
        "capped_cone" => {
            let h = params.get("height")?.as_f64()? as f32;
            let r1 = params.get("r1")?.as_f64()? as f32;
            let r2 = params.get("r2")?.as_f64()? as f32;
            Some(SdfNode::capped_cone(h, r1, r2))
        }
        "capped_torus" => {
            let major = params.get("major_radius")?.as_f64()? as f32;
            let minor = params.get("minor_radius")?.as_f64()? as f32;
            let cap = params
                .get("cap_angle")
                .and_then(|v| v.as_f64())
                .unwrap_or(1.57) as f32;
            Some(SdfNode::capped_torus(major, minor, cap))
        }
        "rounded_cylinder" => {
            let r = params.get("radius")?.as_f64()? as f32;
            let rr = params
                .get("round_radius")
                .and_then(|v| v.as_f64())
                .unwrap_or(0.1) as f32;
            let h = params.get("height")?.as_f64()? as f32;
            Some(SdfNode::rounded_cylinder(r, rr, h))
        }
        "triangular_prism" => {
            let w = params.get("width")?.as_f64()? as f32;
            let d = params.get("depth")?.as_f64()? as f32;
            Some(SdfNode::triangular_prism(w, d))
        }
        "cut_sphere" => {
            let r = params.get("radius")?.as_f64()? as f32;
            let ch = params.get("cut_height")?.as_f64()? as f32;
            Some(SdfNode::cut_sphere(r, ch))
        }
        "cut_hollow_sphere" => {
            let r = params.get("radius")?.as_f64()? as f32;
            let ch = params.get("cut_height")?.as_f64()? as f32;
            let t = params.get("thickness")?.as_f64()? as f32;
            Some(SdfNode::cut_hollow_sphere(r, ch, t))
        }
        "death_star" => {
            let ra = params.get("ra")?.as_f64()? as f32;
            let rb = params.get("rb")?.as_f64()? as f32;
            let d = params.get("d")?.as_f64()? as f32;
            Some(SdfNode::death_star(ra, rb, d))
        }
        "solid_angle" => {
            let angle = params.get("angle")?.as_f64()? as f32;
            let r = params.get("radius")?.as_f64()? as f32;
            Some(SdfNode::solid_angle(angle, r))
        }
        "rhombus" => {
            let la = params.get("la")?.as_f64()? as f32;
            let lb = params.get("lb")?.as_f64()? as f32;
            let h = params.get("height")?.as_f64()? as f32;
            let rr = params
                .get("round_radius")
                .and_then(|v| v.as_f64())
                .unwrap_or(0.0) as f32;
            Some(SdfNode::rhombus(la, lb, h, rr))
        }

        // === Organic & Curved Shapes ===
        "horseshoe" => {
            let angle = params.get("angle")?.as_f64()? as f32;
            let r = params.get("radius")?.as_f64()? as f32;
            let length = params.get("length")?.as_f64()? as f32;
            let w = params.get("width")?.as_f64()? as f32;
            let t = params.get("thickness")?.as_f64()? as f32;
            Some(SdfNode::horseshoe(angle, r, length, w, t))
        }
        "vesica" => {
            let r = params.get("radius")?.as_f64()? as f32;
            let dist = params.get("dist")?.as_f64()? as f32;
            Some(SdfNode::vesica(r, dist))
        }
        "infinite_cylinder" => {
            let r = params.get("radius")?.as_f64()? as f32;
            Some(SdfNode::infinite_cylinder(r))
        }
        "infinite_cone" => {
            let angle = params.get("angle")?.as_f64()? as f32;
            Some(SdfNode::infinite_cone(angle))
        }
        "heart" => {
            let size = params.get("size")?.as_f64()? as f32;
            Some(SdfNode::heart(size))
        }
        "tube" => {
            let outer_r = params.get("outer_radius")?.as_f64()? as f32;
            let t = params.get("thickness")?.as_f64()? as f32;
            let h = params.get("height")?.as_f64()? as f32;
            Some(SdfNode::tube(outer_r, t, h))
        }
        "barrel" => {
            let r = params.get("radius")?.as_f64()? as f32;
            let h = params.get("height")?.as_f64()? as f32;
            let bulge = params.get("bulge").and_then(|v| v.as_f64()).unwrap_or(0.1) as f32;
            Some(SdfNode::barrel(r, h, bulge))
        }
        "diamond" => {
            let r = params.get("radius")?.as_f64()? as f32;
            let h = params.get("height")?.as_f64()? as f32;
            Some(SdfNode::diamond(r, h))
        }
        "chamfered_cube" => {
            let w = params.get("width")?.as_f64()? as f32;
            let h = params.get("height")?.as_f64()? as f32;
            let d = params.get("depth")?.as_f64()? as f32;
            let chamfer = params
                .get("chamfer")
                .and_then(|v| v.as_f64())
                .unwrap_or(0.1) as f32;
            Some(SdfNode::chamfered_cube(w, h, d, chamfer))
        }
        "egg" => {
            let ra = params.get("ra")?.as_f64()? as f32;
            let rb = params.get("rb")?.as_f64()? as f32;
            Some(SdfNode::egg(ra, rb))
        }
        "moon" => {
            let d = params.get("d")?.as_f64()? as f32;
            let ra = params.get("ra")?.as_f64()? as f32;
            let rb = params.get("rb")?.as_f64()? as f32;
            let h = params.get("height")?.as_f64()? as f32;
            Some(SdfNode::moon(d, ra, rb, h))
        }
        "cross_shape" => {
            let length = params.get("length")?.as_f64()? as f32;
            let t = params.get("thickness")?.as_f64()? as f32;
            let rr = params
                .get("round_radius")
                .and_then(|v| v.as_f64())
                .unwrap_or(0.0) as f32;
            let h = params.get("height")?.as_f64()? as f32;
            Some(SdfNode::cross_shape(length, t, rr, h))
        }
        "blobby_cross" => {
            let size = params.get("size")?.as_f64()? as f32;
            let h = params.get("height")?.as_f64()? as f32;
            Some(SdfNode::blobby_cross(size, h))
        }

        // === TPMS (Triply Periodic Minimal Surfaces) ===
        "gyroid" => {
            let scale = params.get("scale").and_then(|v| v.as_f64()).unwrap_or(1.0) as f32;
            let thickness = params
                .get("thickness")
                .and_then(|v| v.as_f64())
                .unwrap_or(0.1) as f32;
            Some(SdfNode::gyroid(scale, thickness))
        }
        "schwarz_p" => {
            let scale = params.get("scale").and_then(|v| v.as_f64()).unwrap_or(1.0) as f32;
            let thickness = params
                .get("thickness")
                .and_then(|v| v.as_f64())
                .unwrap_or(0.1) as f32;
            Some(SdfNode::schwarz_p(scale, thickness))
        }
        "diamond_surface" => {
            let scale = params.get("scale").and_then(|v| v.as_f64()).unwrap_or(1.0) as f32;
            let thickness = params
                .get("thickness")
                .and_then(|v| v.as_f64())
                .unwrap_or(0.1) as f32;
            Some(SdfNode::diamond_surface(scale, thickness))
        }
        "neovius" => {
            let scale = params.get("scale").and_then(|v| v.as_f64()).unwrap_or(1.0) as f32;
            let thickness = params
                .get("thickness")
                .and_then(|v| v.as_f64())
                .unwrap_or(0.1) as f32;
            Some(SdfNode::neovius(scale, thickness))
        }
        "lidinoid" => {
            let scale = params.get("scale").and_then(|v| v.as_f64()).unwrap_or(1.0) as f32;
            let thickness = params
                .get("thickness")
                .and_then(|v| v.as_f64())
                .unwrap_or(0.1) as f32;
            Some(SdfNode::lidinoid(scale, thickness))
        }
        "iwp" => {
            let scale = params.get("scale").and_then(|v| v.as_f64()).unwrap_or(1.0) as f32;
            let thickness = params
                .get("thickness")
                .and_then(|v| v.as_f64())
                .unwrap_or(0.1) as f32;
            Some(SdfNode::iwp(scale, thickness))
        }
        "frd" => {
            let scale = params.get("scale").and_then(|v| v.as_f64()).unwrap_or(1.0) as f32;
            let thickness = params
                .get("thickness")
                .and_then(|v| v.as_f64())
                .unwrap_or(0.1) as f32;
            Some(SdfNode::frd(scale, thickness))
        }
        "fischer_koch_s" => {
            let scale = params.get("scale").and_then(|v| v.as_f64()).unwrap_or(1.0) as f32;
            let thickness = params
                .get("thickness")
                .and_then(|v| v.as_f64())
                .unwrap_or(0.1) as f32;
            Some(SdfNode::fischer_koch_s(scale, thickness))
        }
        "pmy" => {
            let scale = params.get("scale").and_then(|v| v.as_f64()).unwrap_or(1.0) as f32;
            let thickness = params
                .get("thickness")
                .and_then(|v| v.as_f64())
                .unwrap_or(0.1) as f32;
            Some(SdfNode::pmy(scale, thickness))
        }

        // === Geometric Extrusions ===
        "superellipsoid" => {
            let w = params.get("width")?.as_f64()? as f32;
            let h = params.get("height")?.as_f64()? as f32;
            let d = params.get("depth")?.as_f64()? as f32;
            let e1 = params.get("e1").and_then(|v| v.as_f64()).unwrap_or(0.5) as f32;
            let e2 = params.get("e2").and_then(|v| v.as_f64()).unwrap_or(0.5) as f32;
            Some(SdfNode::superellipsoid(w, h, d, e1, e2))
        }
        "rounded_x" => {
            let w = params.get("width")?.as_f64()? as f32;
            let rr = params
                .get("round_radius")
                .and_then(|v| v.as_f64())
                .unwrap_or(0.1) as f32;
            let h = params.get("height")?.as_f64()? as f32;
            Some(SdfNode::rounded_x(w, rr, h))
        }
        "pie" => {
            let angle = params.get("angle")?.as_f64()? as f32;
            let r = params.get("radius")?.as_f64()? as f32;
            let h = params.get("height")?.as_f64()? as f32;
            Some(SdfNode::pie(angle, r, h))
        }
        "trapezoid" => {
            let r1 = params.get("r1")?.as_f64()? as f32;
            let r2 = params.get("r2")?.as_f64()? as f32;
            let trap_height = params.get("trap_height")?.as_f64()? as f32;
            let d = params.get("depth")?.as_f64()? as f32;
            Some(SdfNode::trapezoid(r1, r2, trap_height, d))
        }
        "parallelogram" => {
            let w = params.get("width")?.as_f64()? as f32;
            let para_height = params.get("para_height")?.as_f64()? as f32;
            let skew = params.get("skew").and_then(|v| v.as_f64()).unwrap_or(0.0) as f32;
            let d = params.get("depth")?.as_f64()? as f32;
            Some(SdfNode::parallelogram(w, para_height, skew, d))
        }
        "tunnel" => {
            let w = params.get("width")?.as_f64()? as f32;
            let height_2d = params.get("height_2d")?.as_f64()? as f32;
            let d = params.get("depth")?.as_f64()? as f32;
            Some(SdfNode::tunnel(w, height_2d, d))
        }
        "uneven_capsule" => {
            let r1 = params.get("r1")?.as_f64()? as f32;
            let r2 = params.get("r2")?.as_f64()? as f32;
            let cap_height = params.get("cap_height")?.as_f64()? as f32;
            let d = params.get("depth")?.as_f64()? as f32;
            Some(SdfNode::uneven_capsule(r1, r2, cap_height, d))
        }
        "arc_shape" => {
            let aperture = params.get("aperture")?.as_f64()? as f32;
            let r = params.get("radius")?.as_f64()? as f32;
            let t = params.get("thickness")?.as_f64()? as f32;
            let h = params.get("height")?.as_f64()? as f32;
            Some(SdfNode::arc_shape(aperture, r, t, h))
        }
        "parabola_segment" => {
            let w = params.get("width")?.as_f64()? as f32;
            let para_height = params.get("para_height")?.as_f64()? as f32;
            let d = params.get("depth")?.as_f64()? as f32;
            Some(SdfNode::parabola_segment(w, para_height, d))
        }
        "regular_polygon" => {
            let r = params.get("radius")?.as_f64()? as f32;
            let n_sides = params
                .get("n_sides")
                .and_then(|v| v.as_f64())
                .unwrap_or(6.0) as u32;
            let h = params.get("height")?.as_f64()? as f32;
            Some(SdfNode::regular_polygon(r, n_sides, h))
        }

        // === Advanced Shapes ===
        "star_polygon" => {
            let r = params.get("radius")?.as_f64()? as f32;
            let n_points = params
                .get("n_points")
                .and_then(|v| v.as_f64())
                .unwrap_or(5.0) as u32;
            let m = params.get("m").and_then(|v| v.as_f64()).unwrap_or(0.5) as f32;
            let h = params.get("height")?.as_f64()? as f32;
            Some(SdfNode::star_polygon(r, n_points, m, h))
        }
        "stairs" => {
            let step_width = params.get("step_width")?.as_f64()? as f32;
            let step_height = params.get("step_height")?.as_f64()? as f32;
            let n_steps = params
                .get("n_steps")
                .and_then(|v| v.as_f64())
                .unwrap_or(5.0) as u32;
            let d = params.get("depth")?.as_f64()? as f32;
            Some(SdfNode::stairs(step_width, step_height, n_steps, d))
        }
        "helix" => {
            let major_r = params.get("major_r")?.as_f64()? as f32;
            let minor_r = params.get("minor_r")?.as_f64()? as f32;
            let pitch = params.get("pitch")?.as_f64()? as f32;
            let h = params.get("height")?.as_f64()? as f32;
            Some(SdfNode::helix(major_r, minor_r, pitch, h))
        }
        "tetrahedron" => {
            let size = params.get("size")?.as_f64()? as f32;
            Some(SdfNode::tetrahedron(size))
        }
        "dodecahedron" => {
            let r = params.get("radius")?.as_f64()? as f32;
            Some(SdfNode::dodecahedron(r))
        }
        "icosahedron" => {
            let r = params.get("radius")?.as_f64()? as f32;
            Some(SdfNode::icosahedron(r))
        }
        "truncated_octahedron" => {
            let r = params.get("radius")?.as_f64()? as f32;
            Some(SdfNode::truncated_octahedron(r))
        }
        "truncated_icosahedron" => {
            let r = params.get("radius")?.as_f64()? as f32;
            Some(SdfNode::truncated_icosahedron(r))
        }
        "box_frame" => {
            let hx = params.get("hx")?.as_f64()? as f32;
            let hy = params.get("hy")?.as_f64()? as f32;
            let hz = params.get("hz")?.as_f64()? as f32;
            let edge = params.get("edge").and_then(|v| v.as_f64()).unwrap_or(0.1) as f32;
            Some(SdfNode::box_frame(glam::Vec3::new(hx, hy, hz), edge))
        }

        // === 2D Primitives ===
        "circle_2d" => {
            let r = params.get("radius")?.as_f64()? as f32;
            let hh = params.get("half_height")?.as_f64()? as f32;
            Some(SdfNode::circle_2d(r, hh))
        }
        "rect_2d" => {
            let hw = params.get("half_w")?.as_f64()? as f32;
            let hh_rect = params.get("half_h")?.as_f64()? as f32;
            let hh = params.get("half_height")?.as_f64()? as f32;
            Some(SdfNode::rect_2d(hw, hh_rect, hh))
        }
        "segment_2d" => {
            let ax = params.get("ax")?.as_f64()? as f32;
            let ay = params.get("ay")?.as_f64()? as f32;
            let bx = params.get("bx")?.as_f64()? as f32;
            let by = params.get("by")?.as_f64()? as f32;
            let t = params.get("thickness")?.as_f64()? as f32;
            let hh = params.get("half_height")?.as_f64()? as f32;
            Some(SdfNode::segment_2d(ax, ay, bx, by, t, hh))
        }
        "polygon_2d" => {
            // Requires array parsing - simplified
            let hh = params.get("half_height")?.as_f64()? as f32;
            let verts = vec![
                glam::Vec2::new(1.0, 0.0),
                glam::Vec2::new(0.0, 1.0),
                glam::Vec2::new(-1.0, 0.0),
            ];
            Some(SdfNode::polygon_2d(verts, hh))
        }
        "rounded_rect_2d" => {
            let hw = params.get("half_w")?.as_f64()? as f32;
            let hh_rect = params.get("half_h")?.as_f64()? as f32;
            let rr = params
                .get("round_radius")
                .and_then(|v| v.as_f64())
                .unwrap_or(0.1) as f32;
            let hh = params.get("half_height")?.as_f64()? as f32;
            Some(SdfNode::rounded_rect_2d(hw, hh_rect, rr, hh))
        }
        "annular_2d" => {
            let outer_r = params.get("outer_radius")?.as_f64()? as f32;
            let t = params.get("thickness")?.as_f64()? as f32;
            let hh = params.get("half_height")?.as_f64()? as f32;
            Some(SdfNode::annular_2d(outer_r, t, hh))
        }

        _ => None,
    }
}

// ============================================================
// AliceSdfCollisionGenerator — Collision shape from SDF
// ============================================================

/// Generates ConvexPolygonShape3D collision shapes from SDF meshes
#[derive(GodotClass)]
#[class(base=Node3D, tool)]
pub struct AliceSdfCollisionGenerator {
    base: Base<Node3D>,

    /// Resolution for collision mesh (lower than visual for performance)
    #[var]
    collision_resolution: i32,

    /// Bounds size (half-extent of the evaluation volume)
    #[var]
    bounds_size: f32,

    /// Maximum number of collision vertices (decimation target)
    #[var]
    max_collision_vertices: i32,
}

#[godot_api]
impl INode3D for AliceSdfCollisionGenerator {
    fn init(base: Base<Node3D>) -> Self {
        Self {
            base,
            collision_resolution: 16,
            bounds_size: 2.0,
            max_collision_vertices: 256,
        }
    }
}

#[godot_api]
impl AliceSdfCollisionGenerator {
    /// Generate a ConvexPolygonShape3D from an AliceSdfNode
    ///
    /// Returns a CollisionShape3D node that can be added as a child
    /// of a StaticBody3D or RigidBody3D.
    #[func]
    fn generate_collision_shape(&self, sdf_node: Gd<AliceSdfNode>) -> Option<Gd<CollisionShape3D>> {
        let sdf = {
            let node_ref = sdf_node.bind();
            node_ref.sdf_node.clone()
        }?;

        let bounds = self.bounds_size;
        let min_bounds = glam::Vec3::splat(-bounds);
        let max_bounds = glam::Vec3::splat(bounds);

        let config = MarchingCubesConfig {
            resolution: self.collision_resolution.max(4) as usize,
            compute_normals: false, // Normals not needed for collision
            ..Default::default()
        };

        let mesh = sdf_to_mesh(&sdf, min_bounds, max_bounds, &config);

        if mesh.vertices.is_empty() {
            return None;
        }

        // Convert vertices to PackedVector3Array for ConvexPolygonShape3D
        let mut points = PackedVector3Array::new();

        // Subsample if too many vertices
        let step = if mesh.vertices.len() > self.max_collision_vertices as usize {
            mesh.vertices.len() / self.max_collision_vertices as usize
        } else {
            1
        };

        for (i, v) in mesh.vertices.iter().enumerate() {
            if i % step == 0 {
                points.push(Vector3::new(v.position.x, v.position.y, v.position.z));
            }
        }

        let mut convex_shape = ConvexPolygonShape3D::new_gd();
        convex_shape.set_points(&points);

        let mut collision_shape = CollisionShape3D::new_alloc();
        collision_shape.set_shape(&convex_shape.upcast::<godot::classes::Shape3D>());

        Some(collision_shape)
    }
}

// ============================================================
// AliceSdfLodManager — Camera-distance LOD switching
// ============================================================

/// Manages LOD switching based on camera distance for SDF meshes
#[derive(GodotClass)]
#[class(base=Node3D, tool)]
pub struct AliceSdfLodManager {
    base: Base<Node3D>,

    /// Number of LOD levels to generate
    #[var]
    num_lod_levels: i32,

    /// Base resolution for LOD 0 (highest detail)
    #[var]
    base_resolution: i32,

    /// Distance at which LOD 0 transitions to LOD 1
    #[var]
    lod0_distance: f32,

    /// Distance multiplier for each subsequent LOD level
    #[var]
    distance_multiplier: f32,

    /// Bounds size (half-extent of the evaluation volume)
    #[var]
    bounds_size: f32,

    /// Current active LOD level
    #[var]
    current_lod: i32,

    /// Cached LOD meshes
    lod_meshes: Vec<Gd<ArrayMesh>>,

    /// Cached SDF for mesh generation
    cached_sdf: Option<SdfNode>,
}

#[godot_api]
impl INode3D for AliceSdfLodManager {
    fn init(base: Base<Node3D>) -> Self {
        Self {
            base,
            num_lod_levels: 3,
            base_resolution: 64,
            lod0_distance: 10.0,
            distance_multiplier: 2.0,
            bounds_size: 2.0,
            current_lod: 0,
            lod_meshes: Vec::new(),
            cached_sdf: None,
        }
    }
}

#[godot_api]
impl AliceSdfLodManager {
    /// Set the SDF source and generate all LOD levels
    #[func]
    fn set_sdf(&mut self, sdf_node: Gd<AliceSdfNode>) {
        let sdf = {
            let node_ref = sdf_node.bind();
            node_ref.sdf_node.clone()
        };
        self.cached_sdf = sdf;
        self.generate_all_lods();
    }

    /// Generate all LOD level meshes
    #[func]
    fn generate_all_lods(&mut self) {
        let sdf = match &self.cached_sdf {
            Some(s) => s,
            None => return,
        };

        let bounds = self.bounds_size;
        let min_bounds = glam::Vec3::splat(-bounds);
        let max_bounds = glam::Vec3::splat(bounds);

        self.lod_meshes.clear();

        for level in 0..self.num_lod_levels {
            // Halve resolution per LOD level
            let res = (self.base_resolution >> level).max(4) as usize;

            let config = MarchingCubesConfig {
                resolution: res,
                compute_normals: true,
                ..Default::default()
            };

            let mesh = sdf_to_mesh(sdf, min_bounds, max_bounds, &config);

            if !mesh.vertices.is_empty() {
                self.lod_meshes.push(alice_mesh_to_godot(&mesh));
            }
        }
    }

    /// Update LOD based on distance to a given camera position
    ///
    /// Call this from `_process()` with the camera's global position.
    /// Returns the selected LOD level.
    #[func]
    fn update_lod(&mut self, camera_position: Vector3) -> i32 {
        if self.lod_meshes.is_empty() {
            return -1;
        }

        let self_pos = self.base().get_global_position();
        let distance = self_pos.distance_to(camera_position);

        // Determine LOD level from distance
        let mut level = 0i32;
        let mut threshold = self.lod0_distance;
        while level < (self.lod_meshes.len() as i32 - 1) && distance > threshold {
            level += 1;
            threshold *= self.distance_multiplier;
        }

        self.current_lod = level;
        level
    }

    /// Get the mesh for a specific LOD level
    #[func]
    fn get_lod_mesh(&self, level: i32) -> Option<Gd<ArrayMesh>> {
        self.lod_meshes.get(level as usize).cloned()
    }

    /// Get the number of generated LOD levels
    #[func]
    fn get_lod_count(&self) -> i32 {
        self.lod_meshes.len() as i32
    }

    /// Get vertex count for each LOD level (for debugging)
    #[func]
    fn get_lod_vertex_counts(&self) -> PackedInt32Array {
        let mut counts = PackedInt32Array::new();
        for mesh in &self.lod_meshes {
            let mut total = 0i32;
            for i in 0..mesh.get_surface_count() {
                let arrays = mesh.surface_get_arrays(i);
                if let Some(verts) = arrays.get(0) {
                    if let Ok(packed) = verts.try_to::<PackedVector3Array>() {
                        total += packed.len() as i32;
                    }
                }
            }
            counts.push(total);
        }
        counts
    }
}

// ============================================================
// AliceSdfBatchEvaluator — Batch SDF evaluation for GDScript
// ============================================================

/// High-performance batch SDF evaluation exposed to GDScript
///
/// Compiles the SDF once and evaluates many points using
/// SIMD + multi-threading (GIL-free Rust backend).
#[derive(GodotClass)]
#[class(base=RefCounted)]
pub struct AliceSdfBatchEvaluator {
    base: Base<RefCounted>,

    /// Compiled SDF for fast evaluation
    compiled: Option<Arc<CompiledSdf>>,
}

#[godot_api]
impl IRefCounted for AliceSdfBatchEvaluator {
    fn init(base: Base<RefCounted>) -> Self {
        Self {
            base,
            compiled: None,
        }
    }
}

#[godot_api]
impl AliceSdfBatchEvaluator {
    /// Compile an SDF for fast batch evaluation
    #[func]
    fn compile(&mut self, sdf_node: Gd<AliceSdfNode>) -> bool {
        let sdf = {
            let node_ref = sdf_node.bind();
            node_ref.sdf_node.clone()
        };
        match sdf {
            Some(node) => {
                self.compiled = Some(Arc::new(CompiledSdf::compile(&node)));
                true
            }
            None => false,
        }
    }

    /// Evaluate SDF distances at multiple points
    ///
    /// `points` is a PackedVector3Array of query positions.
    /// Returns a PackedFloat32Array of SDF distances.
    #[func]
    fn eval_batch(&self, points: PackedVector3Array) -> PackedFloat32Array {
        let compiled = match &self.compiled {
            Some(c) => c,
            None => return PackedFloat32Array::new(),
        };

        let len = points.len();
        let mut glam_points = Vec::with_capacity(len);
        for i in 0..len {
            let p = points[i];
            glam_points.push(glam::Vec3::new(p.x, p.y, p.z));
        }

        let distances = eval_compiled_batch_parallel(compiled, &glam_points);

        let mut result = PackedFloat32Array::new();
        result.resize(len);
        for (i, &d) in distances.iter().enumerate() {
            result[i] = d;
        }
        result
    }

    /// Check if a compiled SDF is available
    #[func]
    fn is_compiled(&self) -> bool {
        self.compiled.is_some()
    }

    /// Get the instruction count of the compiled SDF
    #[func]
    fn get_instruction_count(&self) -> i32 {
        self.compiled
            .as_ref()
            .map(|c| c.instruction_count() as i32)
            .unwrap_or(0)
    }
}

// ============================================================
// Oracles for the engine-free half of this binding
// ============================================================
//
// Everything above that touches `Gd<…>`, `GString` or `ArrayMesh` needs a live
// Godot engine and can only be exercised from a running editor. The one part
// that does not is `build_sdf_from_params`, which is also the part every
// GDScript caller goes through (`AliceSdfNode.build`,
// `AliceSdfResource.build_sdf`) and the part where a typo in a JSON key or a
// transposed argument silently produces a different shape. It had no test.
//
// These live here rather than in `tests/test_binding_oracle.rs` because
// `build_sdf_from_params` is private: making it `pub` to reach it from an
// integration test would add a public item to the crate's API, which is not a
// test's decision to make.
//
// Run with: cargo test --lib --features godot

#[cfg(test)]
mod tests {
    use super::build_sdf_from_params;
    use crate::eval::eval;
    use crate::types::SdfNode;
    use glam::Vec3;

    /// Every shape name `AliceSdfResource.get_available_shapes` advertises.
    ///
    /// Duplicated here on purpose: the list inside that `#[func]` is a local
    /// `vec![]` returned as a `PackedStringArray`, so reading it needs a live
    /// engine. A name added there but not to `build_sdf_from_params` is
    /// therefore still invisible to this test — the pairing that *is* checked
    /// is "every name this list holds can be built", and the list was taken
    /// from `get_available_shapes` at 4.0.0.
    const ADVERTISED: [&str; 72] = [
        "sphere",
        "box",
        "cylinder",
        "torus",
        "plane",
        "capsule",
        "cone",
        "ellipsoid",
        "rounded_cone",
        "pyramid",
        "octahedron",
        "hex_prism",
        "tetrahedron",
        "dodecahedron",
        "icosahedron",
        "truncated_octahedron",
        "truncated_icosahedron",
        "link",
        "triangle",
        "bezier",
        "rounded_box",
        "capped_cone",
        "capped_torus",
        "rounded_cylinder",
        "triangular_prism",
        "cut_sphere",
        "cut_hollow_sphere",
        "death_star",
        "solid_angle",
        "rhombus",
        "horseshoe",
        "vesica",
        "heart",
        "tube",
        "barrel",
        "diamond",
        "egg",
        "moon",
        "cross_shape",
        "blobby_cross",
        "gyroid",
        "schwarz_p",
        "diamond_surface",
        "neovius",
        "lidinoid",
        "iwp",
        "frd",
        "fischer_koch_s",
        "pmy",
        "chamfered_cube",
        "superellipsoid",
        "rounded_x",
        "pie",
        "trapezoid",
        "parallelogram",
        "tunnel",
        "uneven_capsule",
        "arc_shape",
        "parabola_segment",
        "regular_polygon",
        "star_polygon",
        "stairs",
        "helix",
        "box_frame",
        "infinite_cylinder",
        "infinite_cone",
        "circle_2d",
        "rect_2d",
        "segment_2d",
        "polygon_2d",
        "rounded_rect_2d",
        "annular_2d",
    ];

    /// One value per key name used anywhere in `build_sdf_from_params`, so a
    /// single JSON object satisfies every arm. Counts are integral and ≥ 3;
    /// the rest are pairwise distinct where an arm reads several of them, so a
    /// transposition changes the shape.
    fn every_param() -> String {
        r#"{
            "radius": 0.6, "width": 0.8, "height": 0.7, "depth": 0.5,
            "major_radius": 0.7, "minor_radius": 0.2,
            "normal_x": 0.0, "normal_y": 1.0, "normal_z": 0.0, "distance": 0.2,
            "ax": -0.5, "ay": 0.0, "az": 0.0,
            "bx": 0.5, "by": 0.2, "bz": 0.0,
            "cx": 0.1, "cy": 0.6, "cz": -0.2,
            "rx": 0.61, "ry": 0.43, "rz": 0.29,
            "r1": 0.4, "r2": 0.2, "ra": 0.5, "rb": 0.3, "d": 0.35,
            "size": 0.6, "hex_radius": 0.5, "length": 0.55,
            "hx": 0.31, "hy": 0.47, "hz": 0.59, "round_radius": 0.07,
            "cap_angle": 0.8, "cut_height": 0.2, "thickness": 0.1,
            "angle": 0.9, "la": 0.4, "lb": 0.3,
            "outer_radius": 0.5, "bulge": 0.15, "chamfer": 0.08,
            "scale": 2.0, "e1": 0.7, "e2": 1.3,
            "trap_height": 0.5, "para_height": 0.4, "skew": 0.2,
            "height_2d": 0.45, "cap_height": 0.35, "aperture": 0.8,
            "n_sides": 6.0, "n_points": 5.0, "m": 2.0,
            "step_width": 0.2, "step_height": 0.15, "n_steps": 4.0,
            "major_r": 0.5, "minor_r": 0.12, "pitch": 0.3, "edge": 0.05,
            "half_w": 0.4, "half_h": 0.3, "half_height": 0.3, "dist": 0.25
        }"#
        .to_string()
    }

    /// Every advertised shape builds, and the node it builds evaluates to a
    /// finite number at points inside, on and outside its bounds.
    ///
    /// This is the `corpus_covers_every_emitted_opcode` shape of gate for the
    /// Godot entry point: a shape offered in the inspector that returns `None`
    /// leaves `AliceSdfNode.build` reporting `false` with nothing to render,
    /// which is exactly the failure a GDScript user cannot debug.
    #[test]
    fn every_advertised_shape_builds_and_evaluates() {
        let params = every_param();
        let pts = [
            Vec3::ZERO,
            Vec3::new(0.25, 0.0, 0.0),
            Vec3::new(1.0, 0.0, 0.0),
            Vec3::new(-0.7, 0.3, 1.1),
            Vec3::new(2.5, -2.5, 2.5),
        ];
        let mut failures = Vec::new();
        for name in ADVERTISED {
            match build_sdf_from_params(name, &params) {
                None => failures.push(format!("{name}: build_sdf_from_params returned None")),
                Some(node) => {
                    for p in pts {
                        let d = eval(&node, p);
                        if !d.is_finite() {
                            failures.push(format!("{name} at {p:?}: eval returned {d}"));
                            break;
                        }
                    }
                }
            }
        }
        assert!(
            failures.is_empty(),
            "{} advertised shape(s) unusable:\n{}",
            failures.len(),
            failures.join("\n")
        );
    }

    /// Closed forms, written down by hand, for the shapes a Godot scene is
    /// most likely to hold. These pin the *meaning* of the JSON keys, which no
    /// amount of "it builds" can: `"height": 2.0` on a cylinder has to mean a
    /// cylinder 2 units tall (`SdfNode::cylinder` halves it), and
    /// `"width"/"height"/"depth"` on a box have to be full extents
    /// (`SdfNode::box3d` halves them). Reading either as a half-extent would
    /// double every shape in the scene, and `docs/GODOT_GUIDE.md` documents
    /// the full-extent reading.
    #[test]
    fn documented_shape_params_match_closed_forms() {
        let build = |shape: &str, json: &str| {
            build_sdf_from_params(shape, json).unwrap_or_else(|| panic!("{shape} did not build"))
        };

        // Unit sphere: d = |p| - 1.
        let s = build("sphere", r#"{"radius": 1.0}"#);
        assert_eq!(eval(&s, Vec3::new(0.5, 0.0, 0.0)), -0.5, "sphere inside");
        assert_eq!(eval(&s, Vec3::new(2.0, 0.0, 0.0)), 1.0, "sphere outside");

        // A 2x2x2 box (full extents) is the unit half-extent box: -1 at the
        // centre, +1 one unit off a face.
        let b = build("box", r#"{"width": 2.0, "height": 2.0, "depth": 2.0}"#);
        assert_eq!(eval(&b, Vec3::ZERO), -1.0, "box centre");
        assert_eq!(eval(&b, Vec3::new(2.0, 0.0, 0.0)), 1.0, "box face");
        let corner = eval(&b, Vec3::new(2.0, 2.0, 2.0));
        assert!(
            (corner - 3.0_f32.sqrt()).abs() < 1e-6,
            "box corner {corner} vs sqrt(3)"
        );

        // Distinct extents, so width / height / depth cannot be permuted: a
        // 2 x 1 x 0.5 box has half-extents (1, 0.5, 0.25), and each face sits
        // at a different distance.
        let b2 = build("box", r#"{"width": 2.0, "height": 1.0, "depth": 0.5}"#);
        assert_eq!(eval(&b2, Vec3::ZERO), -0.25, "flat box centre");
        assert_eq!(eval(&b2, Vec3::new(2.0, 0.0, 0.0)), 1.0, "flat box +X face");
        assert_eq!(eval(&b2, Vec3::new(0.0, 1.5, 0.0)), 1.0, "flat box +Y face");
        assert_eq!(
            eval(&b2, Vec3::new(0.0, 0.0, 0.75)),
            0.5,
            "flat box +Z face"
        );

        // A cylinder of radius 1 and height 2 reaches y = ±1, so the centre is
        // 1 from the side and 1 from each cap.
        let c = build("cylinder", r#"{"radius": 1.0, "height": 2.0}"#);
        assert_eq!(eval(&c, Vec3::ZERO), -1.0, "cylinder centre");
        assert_eq!(eval(&c, Vec3::new(2.0, 0.0, 0.0)), 1.0, "cylinder side");
        assert_eq!(eval(&c, Vec3::new(0.0, 2.0, 0.0)), 1.0, "cylinder cap");

        // Torus in XZ, major 1, minor 0.25.
        let t = build("torus", r#"{"major_radius": 1.0, "minor_radius": 0.25}"#);
        assert_eq!(eval(&t, Vec3::new(1.0, 0.0, 0.0)), -0.25, "torus tube");
        assert_eq!(eval(&t, Vec3::new(1.5, 0.0, 0.0)), 0.25, "torus outside");
        assert_eq!(eval(&t, Vec3::ZERO), 0.75, "torus hole");

        // Plane: the default normal is +Y and the default distance 0, so the
        // omitted-key path has to give d = p.y.
        let pl = build("plane", "{}");
        assert_eq!(eval(&pl, Vec3::new(0.0, 3.0, 0.0)), 3.0, "default plane");
        let pl2 = build(
            "plane",
            r#"{"normal_x": 1.0, "normal_y": 0.0, "distance": 0.5}"#,
        );
        assert_eq!(eval(&pl2, Vec3::new(2.0, 0.0, 0.0)), 1.5, "plane +X at 0.5");

        // Capsule from (0,-1,0) to (0,1,0), radius 0.5.
        let cap = build(
            "capsule",
            r#"{"ax":0.0,"ay":-1.0,"az":0.0,"bx":0.0,"by":1.0,"bz":0.0,"radius":0.5}"#,
        );
        assert_eq!(eval(&cap, Vec3::ZERO), -0.5, "capsule axis");
        assert_eq!(eval(&cap, Vec3::new(1.0, 0.0, 0.0)), 0.5, "capsule side");
        assert_eq!(eval(&cap, Vec3::new(0.0, 2.0, 0.0)), 0.5, "capsule cap");

        // Ellipsoid: the axis intercepts are exact for any ellipsoid bound.
        let e = build("ellipsoid", r#"{"rx": 1.0, "ry": 0.5, "rz": 0.25}"#);
        assert!(
            eval(&e, Vec3::new(1.0, 0.0, 0.0)).abs() < 1e-6,
            "ellipsoid +X"
        );
        assert!(
            eval(&e, Vec3::new(0.0, 0.5, 0.0)).abs() < 1e-6,
            "ellipsoid +Y"
        );
        assert!(
            eval(&e, Vec3::new(0.0, 0.0, 0.25)).abs() < 1e-6,
            "ellipsoid +Z"
        );
        // Distinct semi-axes, so a transposed argument moves the intercepts.
        assert!(
            eval(&e, Vec3::new(0.0, 1.0, 0.0)) > 0.1,
            "ellipsoid is not a sphere"
        );
    }

    /// The remaining arms are held to the native constructor they name, over a
    /// point spray, to the bit — the same parity contract the C ABI oracle
    /// uses. Only shapes whose JSON keys carry the same meaning as the
    /// constructor's parameters are listed; the closed forms above cover the
    /// ones where the key names differ from the parameter names.
    #[test]
    fn shape_params_forward_to_the_named_constructor() {
        let pts: Vec<Vec3> = {
            let mut state: u64 = 0x2545_f491_4f6c_dd1d;
            let mut next = move || {
                state = state
                    .wrapping_mul(6_364_136_223_846_793_005)
                    .wrapping_add(1_442_695_040_888_963_407);
                ((state >> 40) as f32) / ((1u64 << 24) as f32) * 6.0 - 3.0
            };
            (0..64).map(|_| Vec3::new(next(), next(), next())).collect()
        };

        let cases: Vec<(&str, &str, SdfNode)> = vec![
            ("sphere", r#"{"radius": 0.31}"#, SdfNode::sphere(0.31)),
            (
                "ellipsoid",
                r#"{"rx": 0.61, "ry": 0.43, "rz": 0.29}"#,
                SdfNode::ellipsoid(0.61, 0.43, 0.29),
            ),
            ("octahedron", r#"{"size": 0.6}"#, SdfNode::octahedron(0.6)),
            ("tetrahedron", r#"{"size": 0.6}"#, SdfNode::tetrahedron(0.6)),
            (
                "dodecahedron",
                r#"{"radius": 0.6}"#,
                SdfNode::dodecahedron(0.6),
            ),
            (
                "icosahedron",
                r#"{"radius": 0.6}"#,
                SdfNode::icosahedron(0.6),
            ),
            (
                "rounded_box",
                r#"{"hx": 0.31, "hy": 0.47, "hz": 0.59, "round_radius": 0.07}"#,
                SdfNode::rounded_box(0.31, 0.47, 0.59, 0.07),
            ),
            (
                "box_frame",
                r#"{"hx": 0.31, "hy": 0.47, "hz": 0.59, "edge": 0.05}"#,
                SdfNode::box_frame(Vec3::new(0.31, 0.47, 0.59), 0.05),
            ),
            (
                "death_star",
                r#"{"ra": 0.5, "rb": 0.3, "d": 0.35}"#,
                SdfNode::death_star(0.5, 0.3, 0.35),
            ),
            ("egg", r#"{"ra": 0.5, "rb": 0.3}"#, SdfNode::egg(0.5, 0.3)),
            (
                "gyroid",
                r#"{"scale": 2.0, "thickness": 0.1}"#,
                SdfNode::gyroid(2.0, 0.1),
            ),
            (
                "schwarz_p",
                r#"{"scale": 2.0, "thickness": 0.1}"#,
                SdfNode::schwarz_p(2.0, 0.1),
            ),
            (
                "neovius",
                r#"{"scale": 2.0, "thickness": 0.1}"#,
                SdfNode::neovius(2.0, 0.1),
            ),
            (
                "superellipsoid",
                r#"{"width": 0.8, "height": 0.7, "depth": 0.5, "e1": 0.7, "e2": 1.3}"#,
                SdfNode::superellipsoid(0.8, 0.7, 0.5, 0.7, 1.3),
            ),
            (
                "cut_sphere",
                r#"{"radius": 0.6, "cut_height": 0.2}"#,
                SdfNode::cut_sphere(0.6, 0.2),
            ),
            (
                "solid_angle",
                r#"{"angle": 0.9, "radius": 0.6}"#,
                SdfNode::solid_angle(0.9, 0.6),
            ),
            (
                "vesica",
                r#"{"radius": 0.6, "dist": 0.25}"#,
                SdfNode::vesica(0.6, 0.25),
            ),
            ("heart", r#"{"size": 0.6}"#, SdfNode::heart(0.6)),
            (
                "infinite_cylinder",
                r#"{"radius": 0.6}"#,
                SdfNode::infinite_cylinder(0.6),
            ),
            (
                "circle_2d",
                r#"{"radius": 0.6, "half_height": 0.3}"#,
                SdfNode::circle_2d(0.6, 0.3),
            ),
            (
                "rect_2d",
                r#"{"half_w": 0.4, "half_h": 0.3, "half_height": 0.3}"#,
                SdfNode::rect_2d(0.4, 0.3, 0.3),
            ),
            (
                "annular_2d",
                r#"{"outer_radius": 0.5, "thickness": 0.1, "half_height": 0.3}"#,
                SdfNode::annular_2d(0.5, 0.1, 0.3),
            ),
        ];

        let mut failures = Vec::new();
        for (shape, json, want_node) in &cases {
            let Some(got_node) = build_sdf_from_params(shape, json) else {
                failures.push(format!("{shape}: did not build"));
                continue;
            };
            for p in &pts {
                let got = eval(&got_node, *p);
                let want = eval(want_node, *p);
                if got.to_bits() != want.to_bits() {
                    failures.push(format!(
                        "{shape} at {p:?}: {got:e} ({:#010x}) vs constructor {want:e} ({:#010x})",
                        got.to_bits(),
                        want.to_bits()
                    ));
                    break;
                }
            }
        }
        assert!(
            failures.is_empty(),
            "{} shape(s) do not forward to the named constructor:\n{}",
            failures.len(),
            failures.join("\n")
        );
    }

    /// Bad input from GDScript must come back as `None`, never a panic: a
    /// panic here crosses the GDExtension boundary and takes the editor down.
    #[test]
    fn malformed_input_returns_none() {
        let params = every_param();
        assert!(
            build_sdf_from_params("not_a_shape", &params).is_none(),
            "unknown shape"
        );
        assert!(
            build_sdf_from_params("", &params).is_none(),
            "empty shape name"
        );
        assert!(
            build_sdf_from_params("sphere", "not json").is_none(),
            "malformed JSON"
        );
        assert!(
            build_sdf_from_params("sphere", "[]").is_none(),
            "JSON array"
        );
        assert!(
            build_sdf_from_params("sphere", "{}").is_none(),
            "missing radius"
        );
        assert!(
            build_sdf_from_params("sphere", r#"{"radius": "big"}"#).is_none(),
            "radius as a string"
        );
        assert!(
            build_sdf_from_params("sphere", r#"{"radius": null}"#).is_none(),
            "radius as null"
        );
        // Sphere is case-sensitive: the inspector sends lower case.
        assert!(
            build_sdf_from_params("Sphere", &params).is_none(),
            "wrong case"
        );
    }
}