eml-stdlib 0.4.0__py3-none-any.whl

eml_stdlib/control/kalman_1d.eml

@@ -0,0 +1,53 @@
+// kalman_1d.eml -- one-step 1-D Kalman filter.
+//
+// State:    estimate (scalar), variance P (scalar)
+// Inputs:   measurement z, measurement variance R, process variance Q
+//
+// The two functions update / predict the state. Caller chains them
+// each frame. All chain order 0 -- pure rational arithmetic.
+//
+// The 1-D Kalman is the workhorse for IMU heading, RC battery state
+// of charge, and any single-channel "noisy sensor + smooth dynamics"
+// fusion.
+
+module kalman_1d;
+
+// Predict step: drift the variance forward by Q.
+@verify(lean, theorem = "kalman1d_predict_variance_grows")
+fn kalman1d_predict(estimate: Real, p: Real, q: Real) -> (Real, Real)
+    where chain_order <= 0
+    requires (p >= 0.0)
+    requires (q >= 0.0)
+{
+    (estimate, p + q)
+}
+
+// Update step: combine with measurement z.
+@verify(lean, theorem = "kalman1d_update_variance_shrinks")
+fn kalman1d_update(estimate: Real, p: Real, z: Real, r: Real) -> (Real, Real)
+    where chain_order <= 0
+    requires (p >= 0.0)
+    requires (r > 0.0)
+{
+    let k       = p / (p + r);
+    let new_est = estimate + k * (z - estimate);
+    let new_p   = (1.0 - k) * p;
+    (new_est, new_p)
+}
+
+// Combined predict-then-update in one call -- the form most
+// users want when running on a fixed sample rate.
+@verify(lean, theorem = "kalman1d_step_variance_bounded")
+fn kalman1d_step(estimate: Real, p: Real, z: Real, q: Real, r: Real)
+    -> (Real, Real)
+    where chain_order <= 0
+    requires (p >= 0.0)
+    requires (q >= 0.0)
+    requires (r > 0.0)
+{
+    let p_pred  = p + q;
+    let k       = p_pred / (p_pred + r);
+    let new_est = estimate + k * (z - estimate);
+    let new_p   = (1.0 - k) * p_pred;
+    (new_est, new_p)
+}

eml_stdlib/control/lqr_1d.eml

@@ -0,0 +1,47 @@
+// lqr_1d.eml -- 1-D infinite-horizon LQR.
+//
+// For a scalar plant
+//   x' = a*x + b*u
+// with cost  J = sum  q*x^2 + r*u^2
+// the optimal control is  u = -k*x  with
+//   k = (b*p) / r
+//   p = solution of the algebraic Riccati equation
+//       p = q + a^2*p - (a*b*p)^2 / (r + b^2*p)
+//
+// For the closed-form 1-D scalar Riccati this simplifies to the
+// quadratic
+//   b^2 * p^2 - (b^2 * q / r + a^2 - 1) * p - q = 0
+// which has one positive root.
+
+module lqr_1d;
+
+// Closed-form solution of the scalar discrete-time ARE,
+// returning the Riccati P > 0.
+@verify(lean, theorem = "lqr_1d_riccati_positive")
+fn riccati(a: Real, b: Real, q: Real, r: Real) -> Real
+    where chain_order <= 1,
+          domain: r > 0.0 && q >= 0.0 && b != 0.0
+    ensures (result >= 0.0)
+{
+    let alpha = b * b / r;
+    let beta  = a * a - 1.0;
+    let disc  = (beta + alpha * q) * (beta + alpha * q) + 4.0 * alpha * q;
+    (beta + alpha * q + sqrt(disc)) / (2.0 * alpha)
+}
+
+// Optimal feedback gain k from the Riccati P.
+@verify(lean, theorem = "lqr_1d_gain_positive_for_positive_b")
+fn lqr_gain(b: Real, p: Real, r: Real) -> Real
+    where chain_order <= 0,
+          domain: r > 0.0 && p >= 0.0
+{
+    b * p / r
+}
+
+// Closed-loop control law u = -k * x.
+@verify(lean, theorem = "lqr_1d_control_proportional_to_state")
+fn lqr_control(x: Real, k: Real) -> Real
+    where chain_order <= 0
+{
+    -k * x
+}

eml_stdlib/control/pid.eml

@@ -0,0 +1,38 @@
+// pid_controller.eml -- the textbook PID controller.
+//
+//   output = Kp * error + Ki * integral + Kd * derivative
+//
+// Universal control loop: heating, motors, robots, drones,
+// rockets. Chain order 0 (a linear combination of the inputs).
+// The interesting part is the @verify contract: the output is
+// always clamped to the actuator's physical range.
+//
+// Phase F migration: the three single-variable input bounds that
+// were previously expressed as `requires (abs(x) <= 100.0)` clauses
+// are now refinement types directly on the parameters. Semantics
+// are equivalent -- every backend lowers refinements to the same
+// guard form (`assert`, `require`, hypothesis, ...) the old
+// `requires` produced -- but the contract now lives at the type,
+// where dimensional + value bounds belong, instead of trailing
+// the signature.
+
+module pid_controller;
+
+const Kp: Real = 1.5
+const Ki: Real = 0.4
+const Kd: Real = 0.05
+
+const OUT_MIN: Real = -1.0
+const OUT_MAX: Real =  1.0
+
+@verify(lean, theorem = "pid_output_clamped")
+fn pid(error:      Real{e | abs(e) <= 100.0},
+       integral:   Real{i | abs(i) <= 100.0},
+       derivative: Real{d | abs(d) <= 100.0}) -> Real
+    where chain_order <= 0
+    ensures  (result >= OUT_MIN)
+    ensures  (result <= OUT_MAX)
+{
+    let raw = Kp * error + Ki * integral + Kd * derivative;
+    clamp(raw, OUT_MIN, OUT_MAX)
+}

eml_stdlib/gaming/animation/bounce.eml

@@ -0,0 +1,39 @@
+// bounce.eml -- piecewise parabolic bounce-out curve.
+//
+// The standard easing-functions bounce-out: four parabolic
+// segments of decreasing amplitude. Output ∈ [0, 1].
+
+module bounce;
+
+@verify(lean, theorem = "bounce_out_in_unit_interval")
+fn bounce_out(t: Real) -> Real
+    where chain_order <= 0
+    requires (t >= 0.0)
+    requires (t <= 1.0)
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    if t < 0.36364 {                                       // 1 / 2.75
+        7.5625 * t * t
+    } else if t < 0.72727 {                                // 2 / 2.75
+        let u: Real = t - 0.54545;                         // 1.5 / 2.75
+        7.5625 * u * u + 0.75
+    } else if t < 0.90909 {                                // 2.5 / 2.75
+        let u: Real = t - 0.81818;                         // 2.25 / 2.75
+        7.5625 * u * u + 0.9375
+    } else {
+        let u: Real = t - 0.95455;                         // 2.625 / 2.75
+        7.5625 * u * u + 0.984375
+    }
+}
+
+@verify(lean, theorem = "bounce_in_in_unit_interval")
+fn bounce_in(t: Real) -> Real
+    where chain_order <= 0
+    requires (t >= 0.0)
+    requires (t <= 1.0)
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    1.0 - bounce_out(1.0 - t)
+}

eml_stdlib/gaming/animation/ease_in.eml

@@ -0,0 +1,27 @@
+// ease_in.eml -- quadratic ease-in: t².
+//
+// t ∈ [0, 1] → result ∈ [0, 1], starts slow, accelerates.
+
+module ease_in;
+
+@verify(lean, theorem = "ease_in_in_unit_interval")
+fn ease_in_quad(t: Real) -> Real
+    where chain_order <= 0
+    requires (t >= 0.0)
+    requires (t <= 1.0)
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    t * t
+}
+
+@verify(lean, theorem = "ease_in_cubic_in_unit_interval")
+fn ease_in_cubic(t: Real) -> Real
+    where chain_order <= 0
+    requires (t >= 0.0)
+    requires (t <= 1.0)
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    t * t * t
+}

eml_stdlib/gaming/animation/ease_in_out.eml

@@ -0,0 +1,29 @@
+// ease_in_out.eml -- smoothstep: 3t² - 2t³.
+
+module ease_in_out;
+
+@verify(lean, theorem = "smoothstep_in_unit_interval")
+fn smoothstep(t: Real) -> Real
+    where chain_order <= 0
+    requires (t >= 0.0)
+    requires (t <= 1.0)
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    3.0 * t * t - 2.0 * t * t * t
+}
+
+// Quintic smootherstep — 6t⁵ - 15t⁴ + 10t³, C² continuous.
+@verify(lean, theorem = "smootherstep_in_unit_interval")
+fn smootherstep(t: Real) -> Real
+    where chain_order <= 0
+    requires (t >= 0.0)
+    requires (t <= 1.0)
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    let t3: Real = t * t * t;
+    let t4: Real = t3 * t;
+    let t5: Real = t4 * t;
+    6.0 * t5 - 15.0 * t4 + 10.0 * t3
+}

eml_stdlib/gaming/animation/ease_out.eml

@@ -0,0 +1,27 @@
+// ease_out.eml -- quadratic ease-out: 1 - (1 - t)².
+
+module ease_out;
+
+@verify(lean, theorem = "ease_out_in_unit_interval")
+fn ease_out_quad(t: Real) -> Real
+    where chain_order <= 0
+    requires (t >= 0.0)
+    requires (t <= 1.0)
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    let one_minus_t: Real = 1.0 - t;
+    1.0 - one_minus_t * one_minus_t
+}
+
+@verify(lean, theorem = "ease_out_cubic_in_unit_interval")
+fn ease_out_cubic(t: Real) -> Real
+    where chain_order <= 0
+    requires (t >= 0.0)
+    requires (t <= 1.0)
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    let one_minus_t: Real = 1.0 - t;
+    1.0 - one_minus_t * one_minus_t * one_minus_t
+}

eml_stdlib/gaming/animation/ik_2bone.eml

@@ -0,0 +1,57 @@
+// ik_2bone.eml -- two-bone inverse kinematics via law of cosines.
+//
+// Given an upper bone of length L1 and a lower bone of length L2,
+// reach a target at distance D from the shoulder. Compute the
+// shoulder + elbow joint angles:
+//
+//   cos(elbow) = (L1² + L2² - D²) / (2 * L1 * L2)
+//   cos(α)    = (L1² + D² - L2²) / (2 * L1 * D)   // shoulder, target-relative
+//
+// Returns the elbow angle (rad) and the shoulder offset angle (rad)
+// as separate functions so the caller can compose with the
+// shoulder-to-target azimuth.
+
+module ik_2bone;
+
+@verify(lean, theorem = "elbow_angle_in_pi_band")
+fn elbow_angle(l1: Real, l2: Real, distance: Real) -> Real
+    where chain_order <= 1,
+          domain: l1 > 0.0 && l2 > 0.0 && distance > 0.0
+    ensures (result >= 0.0)
+    ensures (result <= 3.141592653589793)
+{
+    let cos_e: Real = clamp(
+        (l1 * l1 + l2 * l2 - distance * distance) / (2.0 * l1 * l2),
+        -1.0, 1.0
+    );
+    acos(cos_e)
+}
+
+@verify(lean, theorem = "shoulder_angle_in_half_pi_band")
+fn shoulder_offset(l1: Real, l2: Real, distance: Real) -> Real
+    where chain_order <= 1,
+          domain: l1 > 0.0 && l2 > 0.0 && distance > 0.0
+    ensures (result >= 0.0)
+    ensures (result <= 1.5707963267948966)
+{
+    let cos_a: Real = clamp(
+        (l1 * l1 + distance * distance - l2 * l2) / (2.0 * l1 * distance),
+        -1.0, 1.0
+    );
+    acos(cos_a)
+}
+
+// Reachability: returns 1.0 if the target is reachable, 0.0 if not.
+@verify(lean, theorem = "ik_reachable_in_zero_one")
+fn reachable(l1: Real, l2: Real, distance: Real) -> Real
+    where chain_order <= 0,
+          domain: l1 > 0.0 && l2 > 0.0 && distance >= 0.0
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    let max_reach: Real = l1 + l2;
+    let min_reach: Real = abs(l1 - l2);
+    if distance > max_reach { 0.0 }
+    else if distance < min_reach { 0.0 }
+    else { 1.0 }
+}

eml_stdlib/gaming/animation/spring.eml

@@ -0,0 +1,39 @@
+// spring.eml -- damped harmonic oscillator response.
+//
+//   x(t) = A * exp(-ζ ω t) * cos(ω_d t + φ)
+//
+// where ω is natural frequency, ζ damping ratio, ω_d = ω√(1-ζ²)
+// the damped frequency. Underdamped (ζ < 1) is the case actually
+// useful for animation; critically damped (ζ = 1) is a smooth
+// follow.
+
+module spring;
+
+@verify(lean, theorem = "spring_underdamped_signed")
+fn underdamped(amplitude: Real, omega: Real, damping_ratio: Real,
+               phase: Real, t_s: Real) -> Real
+    where chain_order <= 1,
+          domain: omega > 0.0 && damping_ratio >= 0.0 && damping_ratio < 1.0 && t_s >= 0.0
+{
+    let omega_d: Real = omega * sqrt(1.0 - damping_ratio * damping_ratio);
+    amplitude * exp(-damping_ratio * omega * t_s) * cos(omega_d * t_s + phase)
+}
+
+// Critically damped: x(t) = A * (1 + ω t) * exp(-ω t)
+@verify(lean, theorem = "spring_critical_signed")
+fn critically_damped(amplitude: Real, omega: Real, t_s: Real) -> Real
+    where chain_order <= 1,
+          domain: omega > 0.0 && t_s >= 0.0
+{
+    amplitude * (1.0 + omega * t_s) * exp(-omega * t_s)
+}
+
+// Time constant τ = 1/(ζω) for underdamped exponential envelope.
+@verify(lean, theorem = "spring_tau_positive")
+fn time_constant(omega: Real, damping_ratio: Real) -> Real
+    where chain_order <= 0,
+          domain: omega > 0.0 && damping_ratio > 0.0
+    ensures (result > 0.0)
+{
+    1.0 / (damping_ratio * omega)
+}

eml_stdlib/gaming/audio/distance_attenuation.eml

@@ -0,0 +1,50 @@
+// distance_attenuation.eml -- 3D audio falloff models.
+//
+// Three common laws:
+//   inverse:    a = ref_dist / max(d, ref_dist)
+//   inv_square: a = ref_dist² / max(d, ref_dist)²       (physical)
+//   linear:     a = max(0, 1 - (d - ref_dist) / (max_dist - ref_dist))
+//
+// Output ∈ [0, 1]: 1 = full volume at ref_dist, 0 = silent at max_dist.
+
+module distance_attenuation;
+
+@verify(lean, theorem = "audio_attenuation_inverse_in_unit_interval")
+fn inverse(distance_m: Real, ref_distance_m: Real) -> Real
+    where chain_order <= 0,
+          domain: distance_m >= 0.0 && ref_distance_m > 0.0
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    let d: Real = max(distance_m, ref_distance_m);
+    ref_distance_m / d
+}
+
+@verify(lean, theorem = "audio_attenuation_inverse_square_in_unit_interval")
+fn inverse_square(distance_m: Real, ref_distance_m: Real) -> Real
+    where chain_order <= 0,
+          domain: distance_m >= 0.0 && ref_distance_m > 0.0
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    let d: Real = max(distance_m, ref_distance_m);
+    let ratio: Real = ref_distance_m / d;
+    ratio * ratio
+}
+
+@verify(lean, theorem = "audio_attenuation_linear_in_unit_interval")
+fn linear(distance_m: Real, ref_distance_m: Real, max_distance_m: Real) -> Real
+    where chain_order <= 0,
+          domain: distance_m >= 0.0 && max_distance_m > ref_distance_m
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    if distance_m <= ref_distance_m {
+        1.0
+    } else if distance_m >= max_distance_m {
+        0.0
+    } else {
+        clamp(1.0 - (distance_m - ref_distance_m) / (max_distance_m - ref_distance_m),
+              0.0, 1.0)
+    }
+}

eml_stdlib/gaming/audio/doppler.eml

@@ -0,0 +1,39 @@
+// doppler.eml -- Doppler frequency shift.
+//
+//   f_observed = f_source * (v_sound + v_listener) / (v_sound + v_source)
+//
+// Sign convention: velocities are positive when the entity moves
+// AWAY FROM the listener / source (for the source) or TOWARD the
+// source (for the listener). Game engines typically supply velocity
+// vectors and project onto the source→listener direction.
+
+module doppler;
+
+const V_SOUND_AIR: Real = 343.0   // m/s
+
+@verify(lean, theorem = "doppler_observed_freq_positive")
+fn observed_frequency(f_source: Real, v_sound: Real,
+                       v_listener_toward_source: Real,
+                       v_source_away_from_listener: Real) -> Real
+    where chain_order <= 0,
+          domain: v_sound > 0.0
+    requires (f_source >= 0.0)
+    requires (v_sound + v_source_away_from_listener > 0.0)
+    ensures (result >= 0.0)
+{
+    f_source * (v_sound + v_listener_toward_source)
+            / (v_sound + v_source_away_from_listener)
+}
+
+@verify(lean, theorem = "doppler_air_default_freq_positive")
+fn observed_frequency_air(f_source: Real,
+                           v_listener_toward_source: Real,
+                           v_source_away_from_listener: Real) -> Real
+    where chain_order <= 0
+    requires (f_source >= 0.0)
+    requires (V_SOUND_AIR + v_source_away_from_listener > 0.0)
+    ensures (result >= 0.0)
+{
+    f_source * (V_SOUND_AIR + v_listener_toward_source)
+            / (V_SOUND_AIR + v_source_away_from_listener)
+}

eml_stdlib/gaming/audio/lowpass_audio.eml

@@ -0,0 +1,32 @@
+// lowpass_audio.eml -- first-order IIR low-pass for audio.
+//
+//   y[n] = α * x[n] + (1 - α) * y[n-1]
+//
+// Where α = dt / (RC + dt) maps cutoff frequency to coefficient.
+// Used for muffling audio behind walls, motion blur on sound,
+// or simulating a chest-cavity filter on bullet impacts.
+
+module lowpass_audio;
+
+const TWO_PI: Real = 6.283185307179586
+
+@verify(lean, theorem = "lowpass_alpha_in_unit_interval")
+fn alpha_from_cutoff(cutoff_hz: Real, sample_rate_hz: Real) -> Real
+    where chain_order <= 0,
+          domain: cutoff_hz > 0.0 && sample_rate_hz > 0.0
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    let dt: Real = 1.0 / sample_rate_hz;
+    let rc: Real = 1.0 / (TWO_PI * cutoff_hz);
+    clamp(dt / (rc + dt), 0.0, 1.0)
+}
+
+@verify(lean, theorem = "lowpass_step_signed_bounded")
+fn step(x_n: Real, y_prev: Real, alpha: Real) -> Real
+    where chain_order <= 0
+    requires (alpha >= 0.0)
+    requires (alpha <= 1.0)
+{
+    alpha * x_n + (1.0 - alpha) * y_prev
+}

eml_stdlib/gaming/audio/reverb_delay.eml

@@ -0,0 +1,41 @@
+// reverb_delay.eml -- single-tap delay line with feedback.
+//
+//   y[n] = x[n] + feedback * y[n - delay_samples]
+//
+// Feedback ∈ [0, 1) so the recursive sum converges. Used as the
+// elementary building block of comb-filter reverbs (chain N copies
+// in parallel with prime-number delays for natural decay).
+
+module reverb_delay;
+
+@verify(lean, theorem = "reverb_feedback_in_open_unit_interval")
+fn feedback_safe(coeff: Real) -> Real
+    where chain_order <= 0
+    requires (coeff >= 0.0)
+    requires (coeff < 1.0)
+    ensures (result >= 0.0)
+    ensures (result < 1.0)
+{
+    clamp(coeff, 0.0, 0.999)
+}
+
+// One step of a feedback delay line.
+@verify(lean, theorem = "delay_step_signed_bounded")
+fn delay_step(x_n: Real, y_delayed: Real, feedback: Real) -> Real
+    where chain_order <= 0
+    requires (feedback >= 0.0)
+    requires (feedback < 1.0)
+{
+    x_n + feedback * y_delayed
+}
+
+// Decay time for a feedback coefficient: T60 = 3 * delay_seconds / -log10(feedback)
+@verify(lean, theorem = "reverb_t60_positive")
+fn t60_seconds(delay_seconds: Real, feedback: Real) -> Real
+    where chain_order <= 1,
+          domain: delay_seconds > 0.0 && feedback > 0.0 && feedback < 1.0
+    ensures (result > 0.0)
+{
+    let log_term: Real = -ln(feedback) / 2.302585093;   // -log10(feedback)
+    3.0 * delay_seconds / log_term
+}

eml_stdlib/gaming/camera/dof_blur.eml

@@ -0,0 +1,30 @@
+// dof_blur.eml -- depth-of-field circle of confusion.
+//
+//   coc = aperture * |z_depth - z_focus| / z_depth
+//
+// `coc` is the circle of confusion radius in screen-space pixels;
+// the post-process samples a disc of that radius around each
+// fragment for the blur.
+
+module dof_blur;
+
+@verify(lean, theorem = "coc_nonneg")
+fn circle_of_confusion(aperture: Real, z_depth: Real, z_focus: Real) -> Real
+    where chain_order <= 0,
+          domain: aperture >= 0.0 && z_depth > 0.0
+    ensures (result >= 0.0)
+{
+    aperture * abs(z_depth - z_focus) / z_depth
+}
+
+// Clamp the COC to a maximum radius (texture sample budget).
+@verify(lean, theorem = "coc_clamped_in_band")
+fn circle_of_confusion_clamped(aperture: Real, z_depth: Real,
+                                z_focus: Real, max_radius_px: Real) -> Real
+    where chain_order <= 0,
+          domain: aperture >= 0.0 && z_depth > 0.0 && max_radius_px >= 0.0
+    ensures (result >= 0.0)
+    ensures (result <= max_radius_px)
+{
+    clamp(aperture * abs(z_depth - z_focus) / z_depth, 0.0, max_radius_px)
+}

eml_stdlib/gaming/camera/fov_projection.eml

@@ -0,0 +1,47 @@
+// fov_projection.eml -- perspective projection matrix coefficients.
+//
+// Returns the four non-zero entries of a standard right-handed
+// perspective matrix (column-major):
+//
+//   m00 = 1 / (aspect * tan(fov/2))
+//   m11 = 1 / tan(fov/2)
+//   m22 = -(far + near) / (far - near)
+//   m23 = -(2 * far * near) / (far - near)
+
+module fov_projection;
+
+@verify(lean, theorem = "fov_m00_positive")
+fn m00(fov_y_rad: Real, aspect: Real) -> Real
+    where chain_order <= 2,
+          domain: fov_y_rad > 0.0 && fov_y_rad < 3.141 && aspect > 0.0
+    ensures (result > 0.0)
+{
+    1.0 / (aspect * tan(0.5 * fov_y_rad))
+}
+
+@verify(lean, theorem = "fov_m11_positive")
+fn m11(fov_y_rad: Real) -> Real
+    where chain_order <= 2,
+          domain: fov_y_rad > 0.0 && fov_y_rad < 3.141
+    ensures (result > 0.0)
+{
+    1.0 / tan(0.5 * fov_y_rad)
+}
+
+@verify(lean, theorem = "fov_m22_signed")
+fn m22(near: Real, far: Real) -> Real
+    where chain_order <= 0,
+          domain: near > 0.0 && far > near
+    ensures (result < 0.0)
+{
+    -(far + near) / (far - near)
+}
+
+@verify(lean, theorem = "fov_m23_signed")
+fn m23(near: Real, far: Real) -> Real
+    where chain_order <= 0,
+          domain: near > 0.0 && far > near
+    ensures (result < 0.0)
+{
+    -(2.0 * far * near) / (far - near)
+}

eml_stdlib/gaming/camera/orbit.eml

@@ -0,0 +1,48 @@
+// orbit.eml -- spherical-coordinates orbit camera.
+//
+//   x = r * cos(φ) * sin(θ)
+//   y = r * sin(φ)
+//   z = r * cos(φ) * cos(θ)
+//
+// θ = azimuth (around y-axis), φ = elevation (above XZ plane), r = radius.
+
+module orbit;
+
+@verify(lean, theorem = "orbit_x_in_band")
+fn position_x(r: Real, theta_rad: Real, phi_rad: Real) -> Real
+    where chain_order <= 1,
+          domain: r >= 0.0
+    ensures (abs(result) <= r)
+{
+    r * cos(phi_rad) * sin(theta_rad)
+}
+
+@verify(lean, theorem = "orbit_y_in_band")
+fn position_y(r: Real, phi_rad: Real) -> Real
+    where chain_order <= 1,
+          domain: r >= 0.0
+    ensures (abs(result) <= r)
+{
+    r * sin(phi_rad)
+}
+
+@verify(lean, theorem = "orbit_z_in_band")
+fn position_z(r: Real, theta_rad: Real, phi_rad: Real) -> Real
+    where chain_order <= 1,
+          domain: r >= 0.0
+    ensures (abs(result) <= r)
+{
+    r * cos(phi_rad) * cos(theta_rad)
+}
+
+// Pythagorean witness: x² + y² + z² = r²
+@verify(lean, theorem = "orbit_norm_witness")
+fn norm_witness(theta_rad: Real, phi_rad: Real) -> Real
+    where chain_order <= 1
+    ensures (result == 1.0)
+{
+    let cx: Real = cos(phi_rad) * sin(theta_rad);
+    let sy: Real = sin(phi_rad);
+    let cz: Real = cos(phi_rad) * cos(theta_rad);
+    cx * cx + sy * sy + cz * cz
+}

eml_stdlib/gaming/camera/shake.eml

@@ -0,0 +1,20 @@
+// shake.eml -- damped-noise camera shake.
+//
+//   shake(t) = magnitude * exp(-decay * t) * perlin(t * frequency, 0)
+//
+// Returns a 1D scalar offset; caller threads this into x and y
+// with two different time offsets to get a 2D displacement.
+
+module shake;
+
+use stdlib::gaming::noise::perlin_2d;
+
+@verify(lean, theorem = "shake_magnitude_in_band")
+fn shake1d(magnitude: Real, decay: Real, frequency: Real, t_s: Real) -> Real
+    where chain_order <= 1,
+          domain: decay >= 0.0 && frequency >= 0.0 && t_s >= 0.0
+{
+    let envelope: Real = magnitude * exp(-decay * t_s);
+    let noise: Real = perlin_2d::perlin2(t_s * frequency, 0.0);
+    envelope * noise
+}