eml-stdlib 0.4.0__py3-none-any.whl

eml_stdlib/gaming/noise/white_noise.eml

@@ -0,0 +1,47 @@
+// white_noise.eml -- hash-based pseudo-random scalar in [0, 1).
+//
+// The single primitive every higher-order noise module relies on:
+// a deterministic, repeatable, fast hash from integer lattice
+// coordinates to a uniform float. Chain order 0 — pure integer
+// arithmetic + sin-based fold.
+//
+// Standard fract-of-sin trick (used in countless GLSL shaders):
+//
+//   hash(x, y) = fract(sin(dot((x,y), (12.9898, 78.233))) * 43758.5453)
+//
+// The Lean obligation captures the unit-interval invariant.
+
+module white_noise;
+
+const HASH_SCALE: Real = 43758.5453
+
+@verify(lean, theorem = "white_noise_2d_in_unit_interval")
+fn hash2(x: Real, y: Real) -> Real
+    where chain_order <= 1
+    ensures (result >= 0.0)
+    ensures (result <  1.0)
+{
+    let s: Real = sin(x * 12.9898 + y * 78.233) * HASH_SCALE;
+    s - floor(s)
+}
+
+@verify(lean, theorem = "white_noise_3d_in_unit_interval")
+fn hash3(x: Real, y: Real, z: Real) -> Real
+    where chain_order <= 1
+    ensures (result >= 0.0)
+    ensures (result <  1.0)
+{
+    let s: Real = sin(x * 12.9898 + y * 78.233 + z * 37.719) * HASH_SCALE;
+    s - floor(s)
+}
+
+// Boundary witness: hash(0,0) is finite. Used by callers that want
+// a deterministic seed value for unit-tests.
+@verify(lean, theorem = "white_noise_at_origin_finite")
+fn hash2_at_origin() -> Real
+    where chain_order <= 0
+    ensures (result == 0.0)
+{
+    let s: Real = sin(0.0) * HASH_SCALE;
+    s - floor(s)
+}

eml_stdlib/gaming/noise/worley.eml

@@ -0,0 +1,79 @@
+// worley.eml -- cellular / Worley noise for organic patterns.
+//
+// Same scaffolding as voronoi_2d (3×3 neighbourhood search) but
+// the output is the squared distance to the nearest feature point
+// (cheaper — skips the sqrt) and a configurable distance metric.
+//
+// Distance metric:  0 = Euclidean²
+//                   1 = Manhattan
+//                   2 = Chebyshev (max-component)
+// Chain order 0 in the squared / Manhattan / Chebyshev paths.
+
+module worley;
+
+use stdlib::gaming::noise::white_noise;
+
+@verify(lean, theorem = "worley_squared_nonneg")
+fn squared_distance(x: Real, y: Real) -> Real
+    where chain_order <= 0
+    ensures (result >= 0.0)
+{
+    let xi: Real = floor(x);
+    let yi: Real = floor(y);
+
+    let c00: Real = _cell_sq_dist(x, y, xi - 1.0, yi - 1.0);
+    let c10: Real = _cell_sq_dist(x, y, xi      , yi - 1.0);
+    let c20: Real = _cell_sq_dist(x, y, xi + 1.0, yi - 1.0);
+    let c01: Real = _cell_sq_dist(x, y, xi - 1.0, yi      );
+    let c11: Real = _cell_sq_dist(x, y, xi      , yi      );
+    let c21: Real = _cell_sq_dist(x, y, xi + 1.0, yi      );
+    let c02: Real = _cell_sq_dist(x, y, xi - 1.0, yi + 1.0);
+    let c12: Real = _cell_sq_dist(x, y, xi      , yi + 1.0);
+    let c22: Real = _cell_sq_dist(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_sq_dist(px: Real, py: Real, gx: Real, gy: Real) -> Real
+    where chain_order <= 0
+{
+    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);
+    dx * dx + dy * dy
+}
+
+// Manhattan distance variant — characteristic blocky / chamfered
+// cell appearance.
+@verify(lean, theorem = "worley_manhattan_nonneg")
+fn manhattan_distance(x: Real, y: Real) -> Real
+    where chain_order <= 0
+    ensures (result >= 0.0)
+{
+    let xi: Real = floor(x);
+    let yi: Real = floor(y);
+
+    let c11: Real = _cell_man_dist(x, y, xi      , yi      );
+    let c00: Real = _cell_man_dist(x, y, xi - 1.0, yi - 1.0);
+    let c10: Real = _cell_man_dist(x, y, xi      , yi - 1.0);
+    let c20: Real = _cell_man_dist(x, y, xi + 1.0, yi - 1.0);
+    let c01: Real = _cell_man_dist(x, y, xi - 1.0, yi      );
+    let c21: Real = _cell_man_dist(x, y, xi + 1.0, yi      );
+    let c02: Real = _cell_man_dist(x, y, xi - 1.0, yi + 1.0);
+    let c12: Real = _cell_man_dist(x, y, xi      , yi + 1.0);
+    let c22: Real = _cell_man_dist(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_man_dist(px: Real, py: Real, gx: Real, gy: Real) -> Real
+    where chain_order <= 0
+{
+    let jx: Real = white_noise::hash2(gx,         gy);
+    let jy: Real = white_noise::hash2(gx + 17.0,  gy + 31.0);
+    abs(px - (gx + jx)) + abs(py - (gy + jy))
+}

eml_stdlib/gaming/particles/drag.eml

@@ -0,0 +1,30 @@
+// drag.eml -- exponential velocity decay (linear drag model).
+//
+//   v(t) = v_0 * exp(-k * t)
+//
+// k is the drag coefficient (1/s). For quadratic drag use the
+// stdlib::ballistics::drag kernel instead.
+
+module particle_drag;
+
+@verify(lean, theorem = "particle_drag_velocity_nonneg")
+fn velocity(v_0: Real, k_drag: Real, t_s: Real) -> Real
+    where chain_order <= 1,
+          domain: k_drag >= 0.0 && t_s >= 0.0
+    requires (v_0 >= 0.0)
+    ensures (result >= 0.0)
+    ensures (result <= v_0)
+{
+    v_0 * exp(-k_drag * t_s)
+}
+
+// Distance covered from t=0 to t=T:  x(T) = v_0/k * (1 - exp(-k*T))
+@verify(lean, theorem = "particle_drag_distance_nonneg")
+fn distance_covered(v_0: Real, k_drag: Real, t_s: Real) -> Real
+    where chain_order <= 1,
+          domain: k_drag > 0.0 && t_s >= 0.0
+    requires (v_0 >= 0.0)
+    ensures (result >= 0.0)
+{
+    (v_0 / k_drag) * (1.0 - exp(-k_drag * t_s))
+}

eml_stdlib/gaming/particles/emitter_radial.eml

@@ -0,0 +1,35 @@
+// emitter_radial.eml -- radial particle emitter velocity.
+//
+//   v = direction * (speed + random_in([-spread, +spread]))
+//
+// Caller supplies the unit `direction` and a per-particle random
+// scalar ∈ [-1, 1]; the kernel returns the velocity magnitude.
+
+module emitter_radial;
+
+@verify(lean, theorem = "emitter_speed_nonneg_when_spread_le_speed")
+fn velocity_magnitude(speed: Real, spread: Real, random_unit: Real) -> Real
+    where chain_order <= 0
+    requires (speed >= 0.0)
+    requires (spread >= 0.0)
+    requires (random_unit >= -1.0)
+    requires (random_unit <=  1.0)
+    requires (spread <= speed)
+    ensures (result >= 0.0)
+{
+    speed + spread * random_unit
+}
+
+// Emit position offset: random point on a disc of radius `disc_r`,
+// returned as a magnitude (caller uses the random angle).
+@verify(lean, theorem = "emitter_disc_offset_in_band")
+fn disc_offset(disc_r: Real, random_unit: Real) -> Real
+    where chain_order <= 0,
+          domain: disc_r >= 0.0
+    requires (random_unit >= 0.0)
+    requires (random_unit <= 1.0)
+    ensures (result >= 0.0)
+    ensures (result <= disc_r)
+{
+    disc_r * sqrt(clamp(random_unit, 0.0, 1.0))
+}

eml_stdlib/gaming/particles/fade.eml

@@ -0,0 +1,36 @@
+// fade.eml -- linear alpha fade over a particle's lifetime.
+//
+//   alpha(t) = clamp(1 - t/lifetime, 0, 1)
+
+module fade;
+
+@verify(lean, theorem = "fade_alpha_in_unit_interval")
+fn alpha(t_s: Real, lifetime_s: Real) -> Real
+    where chain_order <= 0,
+          domain: lifetime_s > 0.0 && t_s >= 0.0
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    clamp(1.0 - t_s / lifetime_s, 0.0, 1.0)
+}
+
+// Fade-in then fade-out: ramp up over t < fade_in, hold, ramp down
+// from t > lifetime - fade_out.
+@verify(lean, theorem = "fade_in_out_in_unit_interval")
+fn alpha_in_out(t_s: Real, lifetime_s: Real,
+                fade_in_s: Real, fade_out_s: Real) -> Real
+    where chain_order <= 0,
+          domain: lifetime_s > 0.0 && t_s >= 0.0
+    requires (fade_in_s >= 0.0)
+    requires (fade_out_s >= 0.0)
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    if t_s < fade_in_s {
+        clamp(t_s / max(fade_in_s, 1.0e-6), 0.0, 1.0)
+    } else if t_s > lifetime_s - fade_out_s {
+        clamp((lifetime_s - t_s) / max(fade_out_s, 1.0e-6), 0.0, 1.0)
+    } else {
+        1.0
+    }
+}

eml_stdlib/gaming/particles/gravity_particle.eml

@@ -0,0 +1,32 @@
+// gravity_particle.eml -- ballistic motion under gravity.
+//
+//   y(t) = y_0 + v_0 t - ½ g t²
+//   vy(t) = v_0 - g t
+
+module gravity_particle;
+
+const G_EARTH: Real = 9.80665
+
+@verify(lean, theorem = "gravity_particle_position_signed")
+fn position(y_0: Real, v_0_y: Real, g: Real, t_s: Real) -> Real
+    where chain_order <= 0,
+          domain: g >= 0.0 && t_s >= 0.0
+{
+    y_0 + v_0_y * t_s - 0.5 * g * t_s * t_s
+}
+
+@verify(lean, theorem = "gravity_particle_velocity_signed")
+fn velocity(v_0_y: Real, g: Real, t_s: Real) -> Real
+    where chain_order <= 0,
+          domain: g >= 0.0 && t_s >= 0.0
+{
+    v_0_y - g * t_s
+}
+
+@verify(lean, theorem = "gravity_particle_position_earth_signed")
+fn position_earth(y_0: Real, v_0_y: Real, t_s: Real) -> Real
+    where chain_order <= 0,
+          domain: t_s >= 0.0
+{
+    y_0 + v_0_y * t_s - 0.5 * G_EARTH * t_s * t_s
+}

eml_stdlib/gaming/particles/size_over_life.eml

@@ -0,0 +1,28 @@
+// size_over_life.eml -- particle radius as a function of age.
+//
+//   r(t) = r_0 + growth * t      (linear)
+//   r(t) = r_0 * (t/lifetime)^p  (power-shape)
+
+module size_over_life;
+
+@verify(lean, theorem = "size_linear_nonneg")
+fn radius_linear(r_0: Real, growth: Real, t_s: Real) -> Real
+    where chain_order <= 0
+    requires (r_0 >= 0.0)
+    requires (t_s >= 0.0)
+    requires (r_0 + growth * t_s >= 0.0)
+    ensures (result >= 0.0)
+{
+    r_0 + growth * t_s
+}
+
+@verify(lean, theorem = "size_power_nonneg")
+fn radius_power(r_0: Real, lifetime_s: Real, t_s: Real, exponent: Real) -> Real
+    where chain_order <= 1,
+          domain: lifetime_s > 0.0 && t_s >= 0.0
+    requires (r_0 >= 0.0)
+    requires (exponent >= 0.0)
+    ensures (result >= 0.0)
+{
+    r_0 * pow(clamp(t_s / lifetime_s, 0.0, 1.0), exponent)
+}

eml_stdlib/gaming/physics/aabb_overlap.eml

@@ -0,0 +1,38 @@
+// aabb_overlap.eml -- axis-aligned bounding box intersection test.
+//
+// Returns 1.0 if the two AABBs overlap, 0.0 otherwise. Inputs:
+// (min, max) for each box on each axis.
+
+module aabb_overlap;
+
+@verify(lean, theorem = "aabb2_overlap_in_zero_one")
+fn overlap_2d(a_min_x: Real, a_max_x: Real, a_min_y: Real, a_max_y: Real,
+              b_min_x: Real, b_max_x: Real, b_min_y: Real, b_max_y: Real) -> Real
+    where chain_order <= 0
+    requires (a_min_x <= a_max_x)
+    requires (a_min_y <= a_max_y)
+    requires (b_min_x <= b_max_x)
+    requires (b_min_y <= b_max_y)
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    if a_max_x < b_min_x { 0.0 }
+    else if a_min_x > b_max_x { 0.0 }
+    else if a_max_y < b_min_y { 0.0 }
+    else if a_min_y > b_max_y { 0.0 }
+    else { 1.0 }
+}
+
+// Penetration depth on a single axis (signed; sign indicates side).
+@verify(lean, theorem = "aabb_penetration_depth_signed")
+fn penetration_depth_x(a_min_x: Real, a_max_x: Real,
+                        b_min_x: Real, b_max_x: Real) -> Real
+    where chain_order <= 0
+    requires (a_min_x <= a_max_x)
+    requires (b_min_x <= b_max_x)
+{
+    let right_overlap: Real = a_max_x - b_min_x;
+    let left_overlap: Real  = b_max_x - a_min_x;
+    if abs(right_overlap) < abs(left_overlap) { right_overlap }
+    else { -left_overlap }
+}

eml_stdlib/gaming/physics/buoyancy.eml

@@ -0,0 +1,43 @@
+// buoyancy.eml -- Archimedes' principle for water / fluid bodies.
+//
+//   F_buoyancy = rho_fluid * g * V_submerged
+//
+// rho_fluid in kg/m³, g in m/s², V_submerged in m³. Positive value
+// means upward (opposing gravity).
+
+module buoyancy;
+
+const RHO_WATER: Real = 1000.0    // kg/m³
+const G_EARTH:   Real = 9.80665
+
+@verify(lean, theorem = "buoyancy_force_nonneg")
+fn force(rho_fluid: Real, g: Real, volume_submerged: Real) -> Real
+    where chain_order <= 0,
+          domain: rho_fluid >= 0.0 && g >= 0.0 && volume_submerged >= 0.0
+    ensures (result >= 0.0)
+{
+    rho_fluid * g * volume_submerged
+}
+
+@verify(lean, theorem = "buoyancy_water_force_nonneg")
+fn force_in_water(volume_submerged: Real) -> Real
+    where chain_order <= 0,
+          domain: volume_submerged >= 0.0
+    ensures (result >= 0.0)
+{
+    RHO_WATER * G_EARTH * volume_submerged
+}
+
+// Volume of a sphere of radius r submerged to depth d (d in [0, 2r]).
+//   V = π * d² * (3r - d) / 3
+@verify(lean, theorem = "sphere_submerged_volume_in_band")
+fn sphere_submerged_volume(radius: Real, depth: Real) -> Real
+    where chain_order <= 0,
+          domain: radius >= 0.0
+    requires (depth >= 0.0)
+    requires (depth <= 2.0 * radius)
+    ensures (result >= 0.0)
+{
+    let pi: Real = 3.141592653589793;
+    pi * depth * depth * (3.0 * radius - depth) / 3.0
+}

eml_stdlib/gaming/physics/circle_collision.eml

@@ -0,0 +1,46 @@
+// circle_collision.eml -- circle-vs-circle intersection test.
+//
+//   collides = (centre_distance < r1 + r2)
+//   penetration_depth = (r1 + r2) - centre_distance
+//   collision_normal = (b - a).normalized()
+
+module circle_collision;
+
+@verify(lean, theorem = "circle_collide_in_zero_one")
+fn collides(ax: Real, ay: Real, ar: Real,
+            bx: Real, by: Real, br: Real) -> Real
+    where chain_order <= 1,
+          domain: ar >= 0.0 && br >= 0.0
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    let dx: Real = bx - ax;
+    let dy: Real = by - ay;
+    let d: Real = sqrt(dx * dx + dy * dy);
+    if d < ar + br { 1.0 } else { 0.0 }
+}
+
+@verify(lean, theorem = "circle_penetration_signed")
+fn penetration_depth(ax: Real, ay: Real, ar: Real,
+                      bx: Real, by: Real, br: Real) -> Real
+    where chain_order <= 1,
+          domain: ar >= 0.0 && br >= 0.0
+{
+    let dx: Real = bx - ax;
+    let dy: Real = by - ay;
+    let d: Real = sqrt(dx * dx + dy * dy);
+    (ar + br) - d
+}
+
+// Returns 1.0 / d safely, used by callers building the collision
+// normal as (b - a) / d.
+@verify(lean, theorem = "circle_inv_distance_finite")
+fn inv_distance(ax: Real, ay: Real, bx: Real, by: Real) -> Real
+    where chain_order <= 1
+    ensures (result >= 0.0)
+{
+    let dx: Real = bx - ax;
+    let dy: Real = by - ay;
+    let d: Real = sqrt(dx * dx + dy * dy);
+    1.0 / max(d, 1.0e-6)
+}

eml_stdlib/gaming/physics/impulse_resolve.eml

@@ -0,0 +1,39 @@
+// impulse_resolve.eml -- collision response with restitution.
+//
+// For two bodies a, b with masses m_a, m_b, velocities v_a, v_b
+// along the contact normal, restitution e ∈ [0, 1]:
+//
+//   v_rel = v_a - v_b                       (closing speed)
+//   j = -(1 + e) * v_rel / (1/m_a + 1/m_b)  (impulse magnitude)
+//   v_a_new = v_a + j / m_a
+//   v_b_new = v_b - j / m_b
+
+module impulse_resolve;
+
+@verify(lean, theorem = "impulse_magnitude_signed")
+fn impulse_magnitude(v_a: Real, v_b: Real,
+                     m_a: Real, m_b: Real, restitution: Real) -> Real
+    where chain_order <= 0,
+          domain: m_a > 0.0 && m_b > 0.0
+    requires (restitution >= 0.0)
+    requires (restitution <= 1.0)
+{
+    let v_rel: Real = v_a - v_b;
+    -(1.0 + restitution) * v_rel / (1.0 / m_a + 1.0 / m_b)
+}
+
+@verify(lean, theorem = "impulse_apply_a_signed")
+fn velocity_a_after(v_a: Real, impulse_j: Real, m_a: Real) -> Real
+    where chain_order <= 0,
+          domain: m_a > 0.0
+{
+    v_a + impulse_j / m_a
+}
+
+@verify(lean, theorem = "impulse_apply_b_signed")
+fn velocity_b_after(v_b: Real, impulse_j: Real, m_b: Real) -> Real
+    where chain_order <= 0,
+          domain: m_b > 0.0
+{
+    v_b - impulse_j / m_b
+}

eml_stdlib/gaming/physics/rigid_body_2d.eml

@@ -0,0 +1,61 @@
+// rigid_body_2d.eml -- semi-implicit Euler step for a 2D rigid body.
+//
+// State: (x, y, theta, vx, vy, omega).
+// Forces: linear (fx, fy) + torque tau.
+//
+//   v_new = v + (f / m) * dt
+//   p_new = p + v_new * dt        (semi-implicit Euler — stable)
+//
+// Each component shipped as its own kernel so callers can chain
+// only what they need on the GPU.
+
+module rigid_body_2d;
+
+@verify(lean, theorem = "rb2d_velocity_x_signed")
+fn integrate_vx(vx: Real, fx: Real, mass_kg: Real, dt: Real) -> Real
+    where chain_order <= 0,
+          domain: mass_kg > 0.0 && dt >= 0.0
+{
+    vx + (fx / mass_kg) * dt
+}
+
+@verify(lean, theorem = "rb2d_velocity_y_signed")
+fn integrate_vy(vy: Real, fy: Real, mass_kg: Real, dt: Real) -> Real
+    where chain_order <= 0,
+          domain: mass_kg > 0.0 && dt >= 0.0
+{
+    vy + (fy / mass_kg) * dt
+}
+
+@verify(lean, theorem = "rb2d_angular_velocity_signed")
+fn integrate_omega(omega: Real, tau: Real, inertia: Real, dt: Real) -> Real
+    where chain_order <= 0,
+          domain: inertia > 0.0 && dt >= 0.0
+{
+    omega + (tau / inertia) * dt
+}
+
+// Position update — uses already-updated velocity (semi-implicit).
+@verify(lean, theorem = "rb2d_position_x_signed")
+fn integrate_x(x: Real, vx_new: Real, dt: Real) -> Real
+    where chain_order <= 0,
+          domain: dt >= 0.0
+{
+    x + vx_new * dt
+}
+
+@verify(lean, theorem = "rb2d_position_y_signed")
+fn integrate_y(y: Real, vy_new: Real, dt: Real) -> Real
+    where chain_order <= 0,
+          domain: dt >= 0.0
+{
+    y + vy_new * dt
+}
+
+@verify(lean, theorem = "rb2d_angle_signed")
+fn integrate_theta(theta: Real, omega_new: Real, dt: Real) -> Real
+    where chain_order <= 0,
+          domain: dt >= 0.0
+{
+    theta + omega_new * dt
+}

eml_stdlib/gaming/physics/spring_damper.eml

@@ -0,0 +1,30 @@
+// spring_damper.eml -- mass-on-spring force model.
+//
+//   F = -k * (x - x_rest) - c * v
+//
+// k is stiffness (N/m), c the damping (N·s/m), x the current
+// position, v the current velocity. Used for soft-body bones,
+// suspension, follow cameras.
+
+module spring_damper;
+
+@verify(lean, theorem = "spring_damper_force_signed")
+fn force(x: Real, x_rest: Real, v: Real,
+         k_stiffness: Real, c_damping: Real) -> Real
+    where chain_order <= 0
+    requires (k_stiffness >= 0.0)
+    requires (c_damping >= 0.0)
+{
+    -k_stiffness * (x - x_rest) - c_damping * v
+}
+
+// Critical-damping coefficient for a given mass + stiffness:
+//   c_crit = 2 * sqrt(m * k)
+@verify(lean, theorem = "critical_damping_nonneg")
+fn critical_damping(mass_kg: Real, k_stiffness: Real) -> Real
+    where chain_order <= 1,
+          domain: mass_kg >= 0.0 && k_stiffness >= 0.0
+    ensures (result >= 0.0)
+{
+    2.0 * sqrt(mass_kg * k_stiffness)
+}

eml_stdlib/gaming/physics/verlet.eml

@@ -0,0 +1,29 @@
+// verlet.eml -- Verlet position-only integration step (cloth/rope).
+//
+//   x_new = 2*x - x_prev + a * dt²
+//
+// No explicit velocity state — velocity is implicit in (x - x_prev).
+// Stable for stiff cloth + rope simulations where energy must be
+// approximately conserved over many steps.
+
+module verlet;
+
+@verify(lean, theorem = "verlet_position_signed")
+fn step(x: Real, x_prev: Real, a: Real, dt: Real) -> Real
+    where chain_order <= 0,
+          domain: dt >= 0.0
+{
+    2.0 * x - x_prev + a * dt * dt
+}
+
+// Constraint: distance between two points must remain at rest_length.
+// Returns the displacement that should be applied (split between
+// the two endpoints by the caller, weighted by inverse mass).
+@verify(lean, theorem = "verlet_constraint_signed")
+fn distance_constraint_correction(current_distance: Real,
+                                   rest_length: Real) -> Real
+    where chain_order <= 0,
+          domain: rest_length >= 0.0
+{
+    current_distance - rest_length
+}

eml_stdlib/gaming/shading/fresnel.eml

@@ -0,0 +1,57 @@
+// fresnel.eml -- Schlick's approximation to the Fresnel term.
+//
+//   F = F₀ + (1 - F₀) * (1 - cos θ)⁵
+//
+// F₀ is the reflectance at normal incidence (0.04 for dielectrics,
+// material-specific for metals). cos θ = max(0, n · v).
+
+module fresnel;
+
+@verify(lean, theorem = "fresnel_schlick_in_band")
+fn schlick(f0: Real, cos_theta: Real) -> Real
+    where chain_order <= 0
+    requires (f0 >= 0.0)
+    requires (f0 <= 1.0)
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    let c: Real = clamp(1.0 - cos_theta, 0.0, 1.0);
+    let c5: Real = c * c * c * c * c;
+    clamp(f0 + (1.0 - f0) * c5, 0.0, 1.0)
+}
+
+// Boundary witness: at grazing angle (cos θ = 0) Schlick collapses
+// to 1. At normal incidence (cos θ = 1) it collapses to f0.
+@verify(lean, theorem = "fresnel_at_grazing_is_one")
+fn schlick_at_grazing(f0: Real) -> Real
+    where chain_order <= 0
+    requires (f0 >= 0.0)
+    requires (f0 <= 1.0)
+    ensures (result == 1.0)
+{
+    f0 + (1.0 - f0) * 1.0
+}
+
+@verify(lean, theorem = "fresnel_at_normal_incidence_is_f0")
+fn schlick_at_normal(f0: Real) -> Real
+    where chain_order <= 0
+    requires (f0 >= 0.0)
+    requires (f0 <= 1.0)
+    ensures (result == f0)
+{
+    f0 + (1.0 - f0) * 0.0
+}
+
+// Convenience: F₀ for a material with the given index of refraction
+// vs air.
+//   F₀ = ((n - 1) / (n + 1))²
+@verify(lean, theorem = "f0_from_ior_in_unit_interval")
+fn f0_from_ior(n_material: Real) -> Real
+    where chain_order <= 0,
+          domain: n_material > 0.0
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    let r: Real = (n_material - 1.0) / (n_material + 1.0);
+    clamp(r * r, 0.0, 1.0)
+}

eml_stdlib/gaming/shading/matcap.eml

@@ -0,0 +1,34 @@
+// matcap.eml -- normal-based environment look-up (matcap shading).
+//
+// A "material capture" texture stores the entire lighting + shading
+// of a sphere from the camera's point of view. To shade a fragment,
+// project its view-space normal into the matcap's UV space:
+//
+//   uv = 0.5 * normal_view.xy + 0.5
+//
+// The texture sample returns the final colour. This module only
+// computes the UV; the caller does the texture lookup.
+
+module matcap;
+
+@verify(lean, theorem = "matcap_uv_in_unit_interval")
+fn uv_u(normal_view_x: Real) -> Real
+    where chain_order <= 0
+    requires (normal_view_x >= -1.0)
+    requires (normal_view_x <=  1.0)
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    0.5 * normal_view_x + 0.5
+}
+
+@verify(lean, theorem = "matcap_uv_v_in_unit_interval")
+fn uv_v(normal_view_y: Real) -> Real
+    where chain_order <= 0
+    requires (normal_view_y >= -1.0)
+    requires (normal_view_y <=  1.0)
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    0.5 * normal_view_y + 0.5
+}