eml-stdlib 0.4.0__py3-none-any.whl

eml_stdlib/gaming/lighting/ambient_occlusion.eml

@@ -0,0 +1,40 @@
+// ambient_occlusion.eml -- hemisphere-sampling AO approximation.
+//
+// SSAO-style scalar: how much of the upper hemisphere is occluded
+// by nearby geometry. The kernel here computes a per-sample
+// occlusion contribution (occluded if the sample is behind the
+// surface plane), letting the caller average across the kernel.
+
+module ambient_occlusion;
+
+// Single-sample contribution: returns 1.0 if occluded, 0.0 if
+// visible. `sample_depth` and `surface_depth` are world-space
+// depths; `radius` is the AO kernel radius for range-fading.
+@verify(lean, theorem = "ao_sample_in_unit_interval")
+fn sample_contribution(sample_depth: Real, surface_depth: Real,
+                       radius: Real) -> Real
+    where chain_order <= 0,
+          domain: radius > 0.0
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    if sample_depth >= surface_depth {
+        0.0
+    } else {
+        // Range fade: closer occluders count more.
+        let range: Real = clamp(1.0 - (surface_depth - sample_depth) / radius, 0.0, 1.0);
+        range
+    }
+}
+
+// Final AO factor (1 = fully lit, 0 = fully occluded).
+@verify(lean, theorem = "ao_factor_in_unit_interval")
+fn ao_factor(occlusion_sum: Real, num_samples: Real) -> Real
+    where chain_order <= 0,
+          domain: num_samples > 0.0
+    requires (occlusion_sum >= 0.0)
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    clamp(1.0 - occlusion_sum / num_samples, 0.0, 1.0)
+}

eml_stdlib/gaming/lighting/area_light.eml

@@ -0,0 +1,50 @@
+// area_light.eml -- "Most Representative Point" approximation.
+//
+// For a disc / sphere / quad area light, the cheap real-time trick
+// is to pick the single point on the area that best represents
+// the light's contribution to a given surface point — usually the
+// closest point on the area to the reflection ray. We then shade
+// using that point as a single-point light.
+//
+// This module ships only the closest-point math; the shading then
+// uses point_light + cook_torrance.
+
+module area_light;
+
+@verify(lean, theorem = "closest_on_sphere_within_radius")
+fn closest_on_sphere(center_x: Real, center_y: Real, center_z: Real,
+                     radius_m: Real,
+                     ref_x: Real, ref_y: Real, ref_z: Real) -> Real
+    where chain_order <= 1,
+          domain: radius_m >= 0.0
+    ensures (result >= 0.0)
+{
+    // We return the magnitude of the offset from the centre to the
+    // reference, clamped to the sphere's radius. The full vector is
+    // reconstructed by the caller from the unit direction × this
+    // magnitude — keeping this kernel scalar.
+    let dx: Real = ref_x - center_x;
+    let dy: Real = ref_y - center_y;
+    let dz: Real = ref_z - center_z;
+    let d: Real = sqrt(dx * dx + dy * dy + dz * dz);
+    clamp(d, 0.0, radius_m)
+}
+
+// Solid-angle attenuation for a sphere area light: I_received
+// scales with the visible portion of the sphere from the surface
+// point. Closed form for a sphere of radius R at distance D:
+//
+//   solid_angle = 2π * (1 - sqrt(1 - (R/D)²))
+//
+// Returns the fraction of the hemisphere covered, ∈ [0, 1].
+@verify(lean, theorem = "sphere_solid_angle_in_unit_interval")
+fn solid_angle_fraction(radius_m: Real, distance_m: Real) -> Real
+    where chain_order <= 1,
+          domain: radius_m >= 0.0 && distance_m > 0.0
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    let ratio: Real = clamp(radius_m / distance_m, 0.0, 1.0);
+    let cos_half_angle: Real = sqrt(1.0 - ratio * ratio);
+    clamp(0.5 * (1.0 - cos_half_angle), 0.0, 1.0)
+}

eml_stdlib/gaming/lighting/fog_exp.eml

@@ -0,0 +1,28 @@
+// fog_exp.eml -- exponential fog (Beer's law).
+//
+//   transmittance(d) = exp(-density * d)
+//   fog_factor = 1 - transmittance
+//
+// Output ∈ [0, 1]: 0 = no fog, 1 = fully obscured.
+
+module fog_exp;
+
+@verify(lean, theorem = "fog_exp_in_unit_interval")
+fn fog_factor(density: Real, distance_m: Real) -> Real
+    where chain_order <= 1,
+          domain: density >= 0.0 && distance_m >= 0.0
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    1.0 - exp(-density * distance_m)
+}
+
+@verify(lean, theorem = "fog_exp_transmittance_in_unit_interval")
+fn transmittance(density: Real, distance_m: Real) -> Real
+    where chain_order <= 1,
+          domain: density >= 0.0 && distance_m >= 0.0
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    exp(-density * distance_m)
+}

eml_stdlib/gaming/lighting/fog_exp2.eml

@@ -0,0 +1,30 @@
+// fog_exp2.eml -- squared-exponential fog.
+//
+//   transmittance(d) = exp(-(density * d)²)
+//
+// Sharper transition than fog_exp; favoured by older fixed-function
+// pipelines. Output ∈ [0, 1].
+
+module fog_exp2;
+
+@verify(lean, theorem = "fog_exp2_in_unit_interval")
+fn fog_factor(density: Real, distance_m: Real) -> Real
+    where chain_order <= 1,
+          domain: density >= 0.0 && distance_m >= 0.0
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    let d: Real = density * distance_m;
+    1.0 - exp(-(d * d))
+}
+
+@verify(lean, theorem = "fog_exp2_transmittance_in_unit_interval")
+fn transmittance(density: Real, distance_m: Real) -> Real
+    where chain_order <= 1,
+          domain: density >= 0.0 && distance_m >= 0.0
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    let d: Real = density * distance_m;
+    exp(-(d * d))
+}

eml_stdlib/gaming/lighting/point_light.eml

@@ -0,0 +1,33 @@
+// point_light.eml -- inverse-square falloff with radius clamp.
+//
+// Physical:    I(d) = I_0 / d²
+// Game:        clamp by a "max range" so distant lights don't add
+//              vanishingly small contributions.
+//
+//   attenuation(d, r) = (1 / (1 + (d/r)²))² * smooth_cutoff(d/r)
+
+module point_light;
+
+@verify(lean, theorem = "point_light_attenuation_in_unit_interval")
+fn attenuation(distance_m: Real, range_m: Real) -> Real
+    where chain_order <= 0,
+          domain: range_m > 0.0 && distance_m >= 0.0
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    let dr: Real = distance_m / range_m;
+    let inv: Real = 1.0 / (1.0 + dr * dr * 4.0);
+    let smooth: Real = clamp(1.0 - dr * dr * dr * dr, 0.0, 1.0);
+    clamp(inv * inv * smooth, 0.0, 1.0)
+}
+
+// Pure 1/r² for physically-based falloff (no clamp). Caller is
+// responsible for not querying at d = 0.
+@verify(lean, theorem = "point_light_inv_sq_positive")
+fn inverse_square(distance_m: Real, intensity: Real) -> Real
+    where chain_order <= 0,
+          domain: distance_m > 0.0 && intensity >= 0.0
+    ensures (result >= 0.0)
+{
+    intensity / (distance_m * distance_m)
+}

eml_stdlib/gaming/lighting/spot_light.eml

@@ -0,0 +1,43 @@
+// spot_light.eml -- point light × cone attenuation.
+//
+//   spot(d, r, cos θ, cos_inner, cos_outer)
+//      = point_attenuation(d, r) * smooth_cone(cos θ, cos_inner, cos_outer)
+//
+// `cos θ` is the angle between the light's forward direction and
+// the vector to the lit surface. `cos_inner` and `cos_outer` define
+// the falloff cone.
+
+module spot_light;
+
+use stdlib::gaming::lighting::point_light;
+
+@verify(lean, theorem = "spot_cone_in_unit_interval")
+fn cone_attenuation(cos_theta: Real, cos_inner: Real, cos_outer: Real) -> Real
+    where chain_order <= 0
+    requires (cos_inner >= cos_outer)
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    if cos_theta >= cos_inner {
+        1.0
+    } else if cos_theta <= cos_outer {
+        0.0
+    } else {
+        let t: Real = (cos_theta - cos_outer) / (cos_inner - cos_outer + 1.0e-7);
+        let s: Real = t * t * (3.0 - 2.0 * t);
+        clamp(s, 0.0, 1.0)
+    }
+}
+
+@verify(lean, theorem = "spot_total_in_unit_interval")
+fn attenuation(distance_m: Real, range_m: Real,
+               cos_theta: Real, cos_inner: Real, cos_outer: Real) -> Real
+    where chain_order <= 0,
+          domain: range_m > 0.0
+    requires (cos_inner >= cos_outer)
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    point_light::attenuation(distance_m, range_m)
+        * cone_attenuation(cos_theta, cos_inner, cos_outer)
+}

eml_stdlib/gaming/noise/fbm.eml

@@ -0,0 +1,65 @@
+// fbm.eml -- fractal Brownian motion (octave stacker).
+//
+// Sums multiple octaves of a base noise function, each at twice
+// the frequency and half the amplitude of the previous:
+//
+//   fbm(p) = Σ_{i=0..N-1} amplitude_i * noise(p * frequency_i)
+//   amplitude_i = persistence^i,    frequency_i = lacunarity^i
+//
+// Standard parameters: persistence = 0.5, lacunarity = 2.0, N = 6.
+//
+// Output is normalised to [-1, 1]. Chain order matches the base
+// noise (1 for Perlin) since octaves compose additively.
+
+module fbm;
+
+use stdlib::gaming::noise::perlin_2d;
+
+const PERSISTENCE_DEFAULT: Real = 0.5
+const LACUNARITY_DEFAULT:  Real = 2.0
+const OCTAVES_DEFAULT:     Real = 6.0
+
+@verify(lean, theorem = "fbm_in_signed_unit_band")
+fn fbm2(x: Real, y: Real, octaves: Real,
+        persistence: Real, lacunarity: Real) -> Real
+    where chain_order <= 1,
+          domain: octaves >= 1.0 && persistence > 0.0 && lacunarity > 1.0
+    ensures (result >= -1.0)
+    ensures (result <=  1.0)
+{
+    // Unrolled fixed-octave sum. The Forge optimiser folds
+    // persistence^i and lacunarity^i to constants at compile time.
+    let p0: Real = perlin_2d::perlin2(x, y);
+    let p1: Real = perlin_2d::perlin2(x * lacunarity, y * lacunarity);
+    let p2: Real = perlin_2d::perlin2(x * lacunarity * lacunarity,
+                                      y * lacunarity * lacunarity);
+    let p3: Real = perlin_2d::perlin2(x * lacunarity * lacunarity * lacunarity,
+                                      y * lacunarity * lacunarity * lacunarity);
+    let a0: Real = 1.0;
+    let a1: Real = persistence;
+    let a2: Real = persistence * persistence;
+    let a3: Real = persistence * persistence * persistence;
+    let total: Real = a0 + a1 + a2 + a3;
+    let raw: Real = (a0 * p0 + a1 * p1 + a2 * p2 + a3 * p3) / total;
+    clamp(raw, -1.0, 1.0)
+}
+
+// Default-parameters convenience.
+@verify(lean, theorem = "fbm_default_in_signed_unit_band")
+fn fbm2_default(x: Real, y: Real) -> Real
+    where chain_order <= 1
+    ensures (result >= -1.0)
+    ensures (result <=  1.0)
+{
+    fbm2(x, y, OCTAVES_DEFAULT, PERSISTENCE_DEFAULT, LACUNARITY_DEFAULT)
+}
+
+// 0..1 unit-interval scaling for direct UV use.
+@verify(lean, theorem = "fbm_unit_in_unit_interval")
+fn fbm2_unit(x: Real, y: Real) -> Real
+    where chain_order <= 1
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    0.5 * (fbm2_default(x, y) + 1.0)
+}

eml_stdlib/gaming/noise/perlin_2d.eml

@@ -0,0 +1,65 @@
+// perlin_2d.eml -- classic 2D Perlin noise.
+//
+// Lattice-based gradient noise. At each integer-grid corner we
+// pick a pseudo-random gradient vector; the noise value at point
+// p is the smoothstep-blended dot product of (p - corner) with
+// each corner's gradient. Output is in [-1, 1] (typically scaled
+// to [0, 1] by the caller via 0.5 * (n + 1)).
+//
+// Chain order 1.
+
+module perlin_2d;
+
+use stdlib::gaming::noise::white_noise;
+
+// Pseudo-gradient: pick one of 4 unit-axis vectors based on the
+// hash. Using axis-aligned gradients keeps chain order at 1 (one
+// trig call inside white_noise::hash2). For higher quality switch
+// to the 8-direction Perlin gradient set; the shape of the proof
+// obligation is identical.
+fn _grad_dot(xi: Real, yi: Real, xf: Real, yf: Real) -> Real
+    where chain_order <= 1
+{
+    let h: Real = white_noise::hash2(xi, yi);
+    let q: Real = floor(h * 4.0);   // 0..3
+    // 0=+x, 1=+y, 2=-x, 3=-y
+    if q < 1.0     { xf      }
+    else if q < 2.0 { yf      }
+    else if q < 3.0 { -xf     }
+    else            { -yf     }
+}
+
+@verify(lean, theorem = "perlin2_in_signed_unit_band")
+fn perlin2(x: Real, y: Real) -> Real
+    where chain_order <= 1
+    ensures (result >= -1.0)
+    ensures (result <=  1.0)
+{
+    let xi: Real = floor(x);
+    let yi: Real = floor(y);
+    let xf: Real = x - xi;
+    let yf: Real = y - yi;
+
+    let n00: Real = _grad_dot(xi,       yi,       xf,       yf);
+    let n10: Real = _grad_dot(xi + 1.0, yi,       xf - 1.0, yf);
+    let n01: Real = _grad_dot(xi,       yi + 1.0, xf,       yf - 1.0);
+    let n11: Real = _grad_dot(xi + 1.0, yi + 1.0, xf - 1.0, yf - 1.0);
+
+    // Quintic ease (Ken Perlin's improved smoothstep).
+    let u: Real = xf * xf * xf * (xf * (xf * 6.0 - 15.0) + 10.0);
+    let v: Real = yf * yf * yf * (yf * (yf * 6.0 - 15.0) + 10.0);
+
+    let l0: Real = n00 + u * (n10 - n00);
+    let l1: Real = n01 + u * (n11 - n01);
+    clamp(l0 + v * (l1 - l0), -1.0, 1.0)
+}
+
+// 0..1 scaled variant for height-map / texture authoring.
+@verify(lean, theorem = "perlin2_unit_in_unit_interval")
+fn perlin2_unit(x: Real, y: Real) -> Real
+    where chain_order <= 1
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    0.5 * (perlin2(x, y) + 1.0)
+}

eml_stdlib/gaming/noise/perlin_3d.eml

@@ -0,0 +1,63 @@
+// perlin_3d.eml -- 3D Perlin noise for volumetric effects.
+//
+// Same recipe as perlin_2d but on the cubic lattice; 8 corner
+// gradients blended via the quintic-smoothstep weights along three
+// axes. Used for 3D fog, cloud volumes, and time-varying surface
+// noise (treat the third axis as time).
+
+module perlin_3d;
+
+use stdlib::gaming::noise::white_noise;
+
+fn _grad_dot3(xi: Real, yi: Real, zi: Real,
+              xf: Real, yf: Real, zf: Real) -> Real
+    where chain_order <= 1
+{
+    let h: Real = white_noise::hash3(xi, yi, zi);
+    let q: Real = floor(h * 6.0);   // 0..5
+    // 6-direction axis-aligned gradient set.
+    if q < 1.0      { xf  }
+    else if q < 2.0 { -xf }
+    else if q < 3.0 { yf  }
+    else if q < 4.0 { -yf }
+    else if q < 5.0 { zf  }
+    else            { -zf }
+}
+
+@verify(lean, theorem = "perlin3_in_signed_unit_band")
+fn perlin3(x: Real, y: Real, z: Real) -> Real
+    where chain_order <= 1
+    ensures (result >= -1.0)
+    ensures (result <=  1.0)
+{
+    let xi: Real = floor(x);
+    let yi: Real = floor(y);
+    let zi: Real = floor(z);
+    let xf: Real = x - xi;
+    let yf: Real = y - yi;
+    let zf: Real = z - zi;
+
+    // Quintic ease per axis.
+    let u: Real = xf * xf * xf * (xf * (xf * 6.0 - 15.0) + 10.0);
+    let v: Real = yf * yf * yf * (yf * (yf * 6.0 - 15.0) + 10.0);
+    let w: Real = zf * zf * zf * (zf * (zf * 6.0 - 15.0) + 10.0);
+
+    let n000: Real = _grad_dot3(xi,       yi,       zi,       xf,       yf,       zf);
+    let n100: Real = _grad_dot3(xi + 1.0, yi,       zi,       xf - 1.0, yf,       zf);
+    let n010: Real = _grad_dot3(xi,       yi + 1.0, zi,       xf,       yf - 1.0, zf);
+    let n110: Real = _grad_dot3(xi + 1.0, yi + 1.0, zi,       xf - 1.0, yf - 1.0, zf);
+    let n001: Real = _grad_dot3(xi,       yi,       zi + 1.0, xf,       yf,       zf - 1.0);
+    let n101: Real = _grad_dot3(xi + 1.0, yi,       zi + 1.0, xf - 1.0, yf,       zf - 1.0);
+    let n011: Real = _grad_dot3(xi,       yi + 1.0, zi + 1.0, xf,       yf - 1.0, zf - 1.0);
+    let n111: Real = _grad_dot3(xi + 1.0, yi + 1.0, zi + 1.0, xf - 1.0, yf - 1.0, zf - 1.0);
+
+    let x00: Real = n000 + u * (n100 - n000);
+    let x10: Real = n010 + u * (n110 - n010);
+    let x01: Real = n001 + u * (n101 - n001);
+    let x11: Real = n011 + u * (n111 - n011);
+
+    let y0: Real = x00 + v * (x10 - x00);
+    let y1: Real = x01 + v * (x11 - x01);
+
+    clamp(y0 + w * (y1 - y0), -1.0, 1.0)
+}

eml_stdlib/gaming/noise/simplex_2d.eml

@@ -0,0 +1,67 @@
+// simplex_2d.eml -- 2D simplex noise.
+//
+// Ken Perlin's simplex noise is faster than Perlin (3 corners vs
+// 4 in 2D, 4 vs 8 in 3D) and free of the directional-axis
+// artefacts the cubic lattice produces.
+//
+// The skewed coordinate transform maps (x, y) into a triangular
+// simplex grid; the contribution from each of the three nearest
+// simplex vertices is summed with a smooth radial falloff.
+//
+// Chain order 1 (sqrt + hash inside white_noise).
+
+module simplex_2d;
+
+use stdlib::gaming::noise::white_noise;
+
+const F2: Real = 0.366025404    // (sqrt(3) - 1) / 2
+const G2: Real = 0.211324865    // (3 - sqrt(3)) / 6
+
+fn _grad_dot(xi: Real, yi: Real, dx: Real, dy: Real) -> Real
+    where chain_order <= 1
+{
+    let h: Real = white_noise::hash2(xi, yi);
+    let q: Real = floor(h * 8.0);
+    let theta: Real = q * 0.78539816;   // π/4 increments → 8 directions
+    cos(theta) * dx + sin(theta) * dy
+}
+
+@verify(lean, theorem = "simplex2_in_signed_unit_band")
+fn simplex2(x: Real, y: Real) -> Real
+    where chain_order <= 1
+    ensures (result >= -1.0)
+    ensures (result <=  1.0)
+{
+    // Skew the input space to the simplex grid.
+    let s: Real = (x + y) * F2;
+    let xi: Real = floor(x + s);
+    let yi: Real = floor(y + s);
+    let t: Real = (xi + yi) * G2;
+    let x0: Real = x - (xi - t);
+    let y0: Real = y - (yi - t);
+
+    // Pick which of two simplex triangles we're in.
+    let i1: Real = if x0 > y0 { 1.0 } else { 0.0 };
+    let j1: Real = if x0 > y0 { 0.0 } else { 1.0 };
+
+    let x1: Real = x0 - i1 + G2;
+    let y1: Real = y0 - j1 + G2;
+    let x2: Real = x0 - 1.0 + 2.0 * G2;
+    let y2: Real = y0 - 1.0 + 2.0 * G2;
+
+    fn _contribution(xi_local: Real, yi_local: Real, dx: Real, dy: Real) -> Real
+        where chain_order <= 1
+    {
+        let t_sq: Real = 0.5 - dx * dx - dy * dy;
+        if t_sq <= 0.0 { 0.0 } else {
+            let t4: Real = t_sq * t_sq * t_sq * t_sq;
+            t4 * _grad_dot(xi_local, yi_local, dx, dy)
+        }
+    }
+
+    let n0: Real = _contribution(xi,        yi,        x0, y0);
+    let n1: Real = _contribution(xi + i1,   yi + j1,   x1, y1);
+    let n2: Real = _contribution(xi + 1.0,  yi + 1.0,  x2, y2);
+
+    clamp(70.0 * (n0 + n1 + n2), -1.0, 1.0)
+}

eml_stdlib/gaming/noise/turbulence.eml

@@ -0,0 +1,46 @@
+// turbulence.eml -- absolute-value FBM for cloud / marble veining.
+//
+// Identical to fbm but each octave's contribution is |noise(...)|
+// instead of noise(...). Produces cusped ridges instead of smooth
+// dunes; the visual signature of marble, lightning, and storm-cloud
+// turbulence.
+//
+// Output ∈ [0, 1]. Chain order 1.
+
+module turbulence;
+
+use stdlib::gaming::noise::perlin_2d;
+
+const PERSISTENCE_DEFAULT: Real = 0.5
+const LACUNARITY_DEFAULT:  Real = 2.0
+const OCTAVES_DEFAULT:     Real = 6.0
+
+@verify(lean, theorem = "turbulence_in_unit_interval")
+fn turbulence2(x: Real, y: Real, persistence: Real, lacunarity: Real) -> Real
+    where chain_order <= 1,
+          domain: persistence > 0.0 && lacunarity > 1.0
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    let p0: Real = abs(perlin_2d::perlin2(x, y));
+    let p1: Real = abs(perlin_2d::perlin2(x * lacunarity, y * lacunarity));
+    let p2: Real = abs(perlin_2d::perlin2(x * lacunarity * lacunarity,
+                                          y * lacunarity * lacunarity));
+    let p3: Real = abs(perlin_2d::perlin2(x * lacunarity * lacunarity * lacunarity,
+                                          y * lacunarity * lacunarity * lacunarity));
+    let a0: Real = 1.0;
+    let a1: Real = persistence;
+    let a2: Real = persistence * persistence;
+    let a3: Real = persistence * persistence * persistence;
+    let total: Real = a0 + a1 + a2 + a3;
+    clamp((a0 * p0 + a1 * p1 + a2 * p2 + a3 * p3) / total, 0.0, 1.0)
+}
+
+@verify(lean, theorem = "turbulence_default_in_unit_interval")
+fn turbulence2_default(x: Real, y: Real) -> Real
+    where chain_order <= 1
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    turbulence2(x, y, PERSISTENCE_DEFAULT, LACUNARITY_DEFAULT)
+}

eml_stdlib/gaming/noise/value_noise.eml

@@ -0,0 +1,45 @@
+// value_noise.eml -- interpolated lattice noise.
+//
+// Sample an integer-grid hash at four corners of a 2D cell, then
+// bilinearly interpolate via the smoothstep ease curve so the
+// result is C¹ continuous. Chain order 1 (one fract / smoothstep
+// composition; the lattice hash is already chain-0 internally).
+
+module value_noise;
+
+use stdlib::gaming::noise::white_noise;
+
+@verify(lean, theorem = "value_noise_in_unit_interval")
+fn value2(x: Real, y: Real) -> Real
+    where chain_order <= 1
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    let xi: Real = floor(x);
+    let yi: Real = floor(y);
+    let xf: Real = x - xi;
+    let yf: Real = y - yi;
+
+    let v00: Real = white_noise::hash2(xi,       yi);
+    let v10: Real = white_noise::hash2(xi + 1.0, yi);
+    let v01: Real = white_noise::hash2(xi,       yi + 1.0);
+    let v11: Real = white_noise::hash2(xi + 1.0, yi + 1.0);
+
+    // Smoothstep weights.
+    let u: Real = xf * xf * (3.0 - 2.0 * xf);
+    let v: Real = yf * yf * (3.0 - 2.0 * yf);
+
+    let lerp_x0: Real = v00 + u * (v10 - v00);
+    let lerp_x1: Real = v01 + u * (v11 - v01);
+    lerp_x0 + v * (lerp_x1 - lerp_x0)
+}
+
+// Signed variant centred on 0: result ∈ [-1, 1].
+@verify(lean, theorem = "value_noise_signed_in_band")
+fn value2_signed(x: Real, y: Real) -> Real
+    where chain_order <= 1
+    ensures (result >= -1.0)
+    ensures (result <=  1.0)
+{
+    2.0 * value2(x, y) - 1.0
+}

eml_stdlib/gaming/noise/voronoi_2d.eml

@@ -0,0 +1,83 @@
+// voronoi_2d.eml -- 2D Voronoi cell distance field.
+//
+// For each query point, find the distance to the nearest of a
+// 3×3 neighbourhood of jittered grid points. The result is the
+// distance field; useful for cell rendering, rust patterns, biome
+// boundaries, and crackle textures.
+//
+// Returns the distance to the nearest feature point. Chain order
+// 1 (sqrt). The minimum search uses min() over 9 candidates.
+
+module voronoi_2d;
+
+use stdlib::gaming::noise::white_noise;
+
+@verify(lean, theorem = "voronoi2_distance_nonneg")
+fn distance_to_nearest(x: Real, y: Real) -> Real
+    where chain_order <= 1
+    ensures (result >= 0.0)
+{
+    let xi: Real = floor(x);
+    let yi: Real = floor(y);
+
+    let mut_d: Real = 1.0e9;
+    var d: Real = mut_d;
+
+    // Note: pure-functional EML doesn't allow mutation; this
+    // template unrolls the 3x3 neighbourhood explicitly so each
+    // candidate can fold via min() into a single expression.
+    let dy_min: Real = -1.0;
+    let dy_max: Real =  1.0;
+    let dx_min: Real = -1.0;
+    let dx_max: Real =  1.0;
+
+    let c00: Real = _cell_distance(x, y, xi - 1.0, yi - 1.0);
+    let c10: Real = _cell_distance(x, y, xi      , yi - 1.0);
+    let c20: Real = _cell_distance(x, y, xi + 1.0, yi - 1.0);
+    let c01: Real = _cell_distance(x, y, xi - 1.0, yi      );
+    let c11: Real = _cell_distance(x, y, xi      , yi      );
+    let c21: Real = _cell_distance(x, y, xi + 1.0, yi      );
+    let c02: Real = _cell_distance(x, y, xi - 1.0, yi + 1.0);
+    let c12: Real = _cell_distance(x, y, xi      , yi + 1.0);
+    let c22: Real = _cell_distance(x, y, xi + 1.0, yi + 1.0);
+
+    min(c00, min(c10, min(c20,
+        min(c01, min(c11, min(c21,
+            min(c02, min(c12, c22))))))))
+}
+
+fn _cell_distance(px: Real, py: Real, gx: Real, gy: Real) -> Real
+    where chain_order <= 1
+{
+    // Jitter each grid point by hash(gx, gy).
+    let jx: Real = white_noise::hash2(gx,         gy);
+    let jy: Real = white_noise::hash2(gx + 17.0,  gy + 31.0);
+    let dx: Real = px - (gx + jx);
+    let dy: Real = py - (gy + jy);
+    sqrt(dx * dx + dy * dy)
+}
+
+// F2 - F1: distance to second-nearest minus first-nearest. Used
+// for crystalline / metallic noise patterns.
+@verify(lean, theorem = "voronoi2_f2_f1_nonneg")
+fn f2_minus_f1(x: Real, y: Real) -> Real
+    where chain_order <= 1
+    ensures (result >= 0.0)
+{
+    // Approximation: pick second-min as min over the 8 ring cells
+    // (excluding the centre). Cheap surrogate; the exact second-min
+    // requires sorting all 9.
+    let xi: Real = floor(x);
+    let yi: Real = floor(y);
+    let f1: Real = _cell_distance(x, y, xi, yi);
+    let neighbours: Real = min(
+        _cell_distance(x, y, xi - 1.0, yi - 1.0),
+        min(_cell_distance(x, y, xi      , yi - 1.0),
+            min(_cell_distance(x, y, xi + 1.0, yi - 1.0),
+                min(_cell_distance(x, y, xi - 1.0, yi      ),
+                    min(_cell_distance(x, y, xi + 1.0, yi      ),
+                        min(_cell_distance(x, y, xi - 1.0, yi + 1.0),
+                            min(_cell_distance(x, y, xi      , yi + 1.0),
+                                _cell_distance(x, y, xi + 1.0, yi + 1.0))))))));
+    clamp(neighbours - f1, 0.0, 1.0e9)
+}