eml-stdlib 0.4.0__py3-none-any.whl

eml_stdlib/gaming/shading/pbr_diffuse.eml

@@ -0,0 +1,41 @@
+// pbr_diffuse.eml -- Lambertian diffuse shading.
+//
+//   L = albedo * max(0, n · l) / π
+//
+// The 1/π factor is the energy-conservation normalisation; many
+// real-time shaders fold it into the light intensity instead.
+// Both forms are provided.
+
+module pbr_diffuse;
+
+const PI: Real = 3.141592653589793
+const INV_PI: Real = 0.31830988618379
+
+@verify(lean, theorem = "lambert_in_unit_interval")
+fn lambert(n_dot_l: Real) -> Real
+    where chain_order <= 0
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    clamp(n_dot_l, 0.0, 1.0)
+}
+
+@verify(lean, theorem = "lambert_normalised_nonneg")
+fn lambert_normalised(n_dot_l: Real) -> Real
+    where chain_order <= 0
+    ensures (result >= 0.0)
+{
+    clamp(n_dot_l, 0.0, 1.0) * INV_PI
+}
+
+// Half-Lambert (Valve trick): wrap-around term for soft skin /
+// foliage shading. Maps n·l ∈ [-1, 1] to [0.25, 1].
+@verify(lean, theorem = "half_lambert_in_unit_interval")
+fn half_lambert(n_dot_l: Real) -> Real
+    where chain_order <= 0
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    let s: Real = 0.5 * n_dot_l + 0.5;
+    s * s
+}

eml_stdlib/gaming/shading/pbr_specular.eml

@@ -0,0 +1,75 @@
+// pbr_specular.eml -- Cook-Torrance microfacet specular BRDF.
+//
+//   f_spec = (D * F * G) / (4 * (n·v) * (n·l))
+//
+// Where:
+//   D = GGX (Trowbridge-Reitz) normal distribution
+//   F = Schlick Fresnel
+//   G = Smith geometry term (height-correlated GGX visibility)
+//
+// All sub-terms are bounded ∈ [0, 1]; the caller multiplies by the
+// light radiance and integrates over the hemisphere.
+
+module pbr_specular;
+
+use stdlib::gaming::shading::fresnel;
+
+const PI: Real = 3.141592653589793
+
+// GGX distribution.
+@verify(lean, theorem = "ggx_in_unit_interval_for_unit_alpha")
+fn d_ggx(n_dot_h: Real, alpha: Real) -> Real
+    where chain_order <= 0,
+          domain: alpha > 0.0
+    ensures (result >= 0.0)
+{
+    let a2: Real = alpha * alpha;
+    let nh2: Real = clamp(n_dot_h, 0.0, 1.0) * clamp(n_dot_h, 0.0, 1.0);
+    let denom: Real = nh2 * (a2 - 1.0) + 1.0;
+    a2 / (PI * denom * denom + 1.0e-7)
+}
+
+// Smith geometry term, height-correlated GGX visibility.
+@verify(lean, theorem = "smith_visibility_in_unit_interval")
+fn v_smith(n_dot_v: Real, n_dot_l: Real, alpha: Real) -> Real
+    where chain_order <= 1,
+          domain: alpha > 0.0
+    ensures (result >= 0.0)
+{
+    let a2: Real = alpha * alpha;
+    let nv: Real = clamp(n_dot_v, 1.0e-4, 1.0);
+    let nl: Real = clamp(n_dot_l, 1.0e-4, 1.0);
+    let lambda_v: Real = nl * sqrt(nv * nv * (1.0 - a2) + a2);
+    let lambda_l: Real = nv * sqrt(nl * nl * (1.0 - a2) + a2);
+    0.5 / (lambda_v + lambda_l + 1.0e-7)
+}
+
+// Composite Cook-Torrance specular.
+@verify(lean, theorem = "cook_torrance_nonneg")
+fn specular(n_dot_l: Real, n_dot_v: Real, n_dot_h: Real,
+            v_dot_h: Real, f0: Real, alpha: Real) -> Real
+    where chain_order <= 1,
+          domain: alpha > 0.0
+    requires (f0 >= 0.0)
+    requires (f0 <= 1.0)
+    ensures (result >= 0.0)
+{
+    let d: Real = d_ggx(n_dot_h, alpha);
+    let f: Real = fresnel::schlick(f0, v_dot_h);
+    let v: Real = v_smith(n_dot_v, n_dot_l, alpha);
+    d * f * v
+}
+
+// Roughness → α = roughness² is the standard remap; clamped away
+// from 0 to keep D_GGX well-defined.
+@verify(lean, theorem = "roughness_to_alpha_in_band")
+fn roughness_to_alpha(roughness: Real) -> Real
+    where chain_order <= 0
+    requires (roughness >= 0.0)
+    requires (roughness <= 1.0)
+    ensures (result >= 1.0e-4)
+    ensures (result <= 1.0)
+{
+    let r: Real = clamp(roughness, 0.0, 1.0);
+    clamp(r * r, 1.0e-4, 1.0)
+}

eml_stdlib/gaming/shading/subsurface.eml

@@ -0,0 +1,52 @@
+// subsurface.eml -- Christensen-Burley subsurface scattering approx.
+//
+// For real-time skin / wax / leaves: light entering through a thin
+// region scatters and emerges in a halo of the material's albedo.
+// Burley's approximation is a sum of two exponentials in distance,
+// integrated against the surface normal:
+//
+//   sss(n, l, k_back) = k_back + (1 - k_back) * max(0, n · l)
+//
+// Plus a wrap-around term for the back-lit hemisphere. Chain order 1.
+
+module subsurface;
+
+@verify(lean, theorem = "sss_wrap_in_unit_interval")
+fn wrap(n_dot_l: Real, wrap_amount: Real) -> Real
+    where chain_order <= 0
+    requires (wrap_amount >= 0.0)
+    requires (wrap_amount <= 1.0)
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    let s: Real = (n_dot_l + wrap_amount) / (1.0 + wrap_amount);
+    clamp(s, 0.0, 1.0)
+}
+
+// Burley back-scatter term: (l ∙ -v + 1) raised to a hardness.
+@verify(lean, theorem = "sss_back_in_unit_interval")
+fn back_scatter(l_dot_neg_v: Real, hardness: Real) -> Real
+    where chain_order <= 1,
+          domain: hardness >= 0.0
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    let s: Real = clamp(0.5 * l_dot_neg_v + 0.5, 0.0, 1.0);
+    pow(s, hardness)
+}
+
+// Composite SSS contribution. albedo handled by caller.
+@verify(lean, theorem = "sss_total_nonneg")
+fn sss_total(n_dot_l: Real, l_dot_neg_v: Real,
+             wrap_amount: Real, hardness: Real,
+             back_strength: Real) -> Real
+    where chain_order <= 1,
+          domain: back_strength >= 0.0
+    requires (wrap_amount >= 0.0 && wrap_amount <= 1.0)
+    requires (hardness >= 0.0)
+    ensures (result >= 0.0)
+{
+    let lit: Real = wrap(n_dot_l, wrap_amount);
+    let back: Real = back_scatter(l_dot_neg_v, hardness);
+    lit + back_strength * back
+}

eml_stdlib/gaming/shading/toon.eml

@@ -0,0 +1,30 @@
+// toon.eml -- step-based cel shading.
+//
+// Banded diffuse: take n·l, quantise into K levels.
+// Output ∈ [0, 1].
+
+module toon;
+
+@verify(lean, theorem = "toon_in_unit_interval")
+fn cel_diffuse(n_dot_l: Real, levels: Real) -> Real
+    where chain_order <= 0,
+          domain: levels >= 1.0
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    let v: Real = clamp(n_dot_l, 0.0, 1.0);
+    let q: Real = floor(v * levels) / levels;
+    clamp(q, 0.0, 1.0)
+}
+
+// Rim-light for outline emphasis: high near grazing angles.
+@verify(lean, theorem = "toon_rim_in_unit_interval")
+fn rim_light(n_dot_v: Real, rim_power: Real) -> Real
+    where chain_order <= 1,
+          domain: rim_power >= 0.0
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    let edge: Real = clamp(1.0 - n_dot_v, 0.0, 1.0);
+    pow(edge, rim_power)
+}

eml_stdlib/gaming/terrain/biome_select.eml

@@ -0,0 +1,41 @@
+// biome_select.eml -- temperature × moisture biome classification.
+//
+// Whittaker's biome diagram: each biome is a region of
+// (temperature, moisture) space. Returns an integer biome id ∈
+// [0, 7]:
+//
+//   0 = tundra        (cold, dry)
+//   1 = boreal        (cold, wet)
+//   2 = grassland     (temperate, dry)
+//   3 = temperate_forest (temperate, mid)
+//   4 = rainforest    (temperate/hot, wet)
+//   5 = desert        (hot, dry)
+//   6 = savanna       (hot, mid)
+//   7 = tropical_dry  (hot, very dry)
+//
+// Inputs in [0, 1]. Pure piecewise.
+
+module biome_select;
+
+@verify(lean, theorem = "biome_id_in_band")
+fn biome_id(temperature: Real, moisture: Real) -> Real
+    where chain_order <= 0
+    requires (temperature >= 0.0)
+    requires (temperature <= 1.0)
+    requires (moisture >= 0.0)
+    requires (moisture <= 1.0)
+    ensures (result >= 0.0)
+    ensures (result <= 7.0)
+{
+    if temperature < 0.30 {
+        if moisture < 0.30 { 0.0 } else { 1.0 }   // tundra / boreal
+    } else if temperature < 0.65 {
+        if moisture < 0.30 { 2.0 }                // grassland
+        else if moisture < 0.65 { 3.0 }           // temperate_forest
+        else { 4.0 }                              // rainforest
+    } else {
+        if moisture < 0.20 { 5.0 }                // desert
+        else if moisture < 0.55 { 6.0 }           // savanna
+        else { 4.0 }                              // tropical rainforest
+    }
+}

eml_stdlib/gaming/terrain/cliff_detect.eml

@@ -0,0 +1,35 @@
+// cliff_detect.eml -- gradient-magnitude cliff detection.
+//
+// Given a heightmap sampled at four neighbours of a centre point,
+// the gradient magnitude is the slope. If it exceeds the threshold
+// the cell is "cliff" (1.0); below, "non-cliff" (0.0).
+//
+//   gradient_magnitude = sqrt((dh/dx)² + (dh/dy)²)
+//   is_cliff = gradient_magnitude > threshold
+
+module cliff_detect;
+
+@verify(lean, theorem = "cliff_gradient_magnitude_nonneg")
+fn gradient_magnitude(h_left: Real, h_right: Real,
+                      h_down: Real, h_up: Real, dx_m: Real) -> Real
+    where chain_order <= 1,
+          domain: dx_m > 0.0
+    ensures (result >= 0.0)
+{
+    let dhx: Real = (h_right - h_left) / (2.0 * dx_m);
+    let dhy: Real = (h_up - h_down) / (2.0 * dx_m);
+    sqrt(dhx * dhx + dhy * dhy)
+}
+
+@verify(lean, theorem = "cliff_classification_in_zero_one")
+fn is_cliff(h_left: Real, h_right: Real,
+            h_down: Real, h_up: Real, dx_m: Real,
+            slope_threshold: Real) -> Real
+    where chain_order <= 1,
+          domain: dx_m > 0.0 && slope_threshold >= 0.0
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    let mag: Real = gradient_magnitude(h_left, h_right, h_down, h_up, dx_m);
+    if mag > slope_threshold { 1.0 } else { 0.0 }
+}

eml_stdlib/gaming/terrain/erosion_hydraulic.eml

@@ -0,0 +1,57 @@
+// erosion_hydraulic.eml -- water flow + sediment transport step.
+//
+// Per cell: water arrives, picks up some sediment (capacity =
+// flow_speed * sediment_capacity), then flows to the lowest
+// neighbour. Excess sediment beyond capacity deposits.
+//
+// The full sim iterates this on a grid; this kernel is one cell's
+// per-step state update.
+
+module erosion_hydraulic;
+
+@verify(lean, theorem = "sediment_capacity_nonneg")
+fn capacity(flow_speed: Real, sediment_capacity_coeff: Real) -> Real
+    where chain_order <= 0,
+          domain: flow_speed >= 0.0 && sediment_capacity_coeff >= 0.0
+    ensures (result >= 0.0)
+{
+    flow_speed * sediment_capacity_coeff
+}
+
+// Erosion: how much new sediment the water lifts this step.
+//   eroded = (capacity - sediment) * erosion_rate    (when capacity > sediment)
+@verify(lean, theorem = "erosion_step_nonneg")
+fn eroded_amount(sediment: Real, capacity: Real, erosion_rate: Real) -> Real
+    where chain_order <= 0,
+          domain: erosion_rate >= 0.0
+    requires (sediment >= 0.0)
+    requires (capacity >= 0.0)
+    ensures (result >= 0.0)
+{
+    clamp((capacity - sediment) * erosion_rate, 0.0, 1.0e6)
+}
+
+// Deposition: when the water slows or sediment > capacity, drop the
+// excess back to the terrain.
+@verify(lean, theorem = "deposition_step_nonneg")
+fn deposited_amount(sediment: Real, capacity: Real, deposition_rate: Real) -> Real
+    where chain_order <= 0,
+          domain: deposition_rate >= 0.0
+    requires (sediment >= 0.0)
+    requires (capacity >= 0.0)
+    ensures (result >= 0.0)
+{
+    clamp((sediment - capacity) * deposition_rate, 0.0, 1.0e6)
+}
+
+// Water-volume update with evaporation.
+@verify(lean, theorem = "water_evaporation_in_band")
+fn updated_water(water: Real, evap_rate: Real, dt: Real) -> Real
+    where chain_order <= 0,
+          domain: evap_rate >= 0.0 && dt >= 0.0
+    requires (water >= 0.0)
+    ensures (result >= 0.0)
+    ensures (result <= water)
+{
+    clamp(water * (1.0 - evap_rate * dt), 0.0, water)
+}

eml_stdlib/gaming/terrain/erosion_thermal.eml

@@ -0,0 +1,44 @@
+// erosion_thermal.eml -- talus-angle thermal erosion step.
+//
+// Per cell: if the slope to the lowest neighbour exceeds the talus
+// angle, transfer some material from this cell to the neighbour.
+//
+//   delta = max(0, dh - talus_threshold) * fraction
+//
+// The full simulation iterates this for many cells; the kernel
+// here is one (cell, neighbour) update.
+
+module erosion_thermal;
+
+@verify(lean, theorem = "thermal_step_signed_balance")
+fn material_transfer(h_self: Real, h_neighbour: Real,
+                     talus_threshold: Real, fraction: Real) -> Real
+    where chain_order <= 0,
+          domain: talus_threshold >= 0.0
+    requires (fraction >= 0.0)
+    requires (fraction <= 1.0)
+    ensures (result >= 0.0)
+{
+    let dh: Real = h_self - h_neighbour;
+    let excess: Real = clamp(dh - talus_threshold, 0.0, 1.0e6);
+    excess * fraction
+}
+
+// Apply transfer to two cells: returns the new self height.
+@verify(lean, theorem = "thermal_apply_self_decreases")
+fn apply_self(h_self: Real, transfer: Real) -> Real
+    where chain_order <= 0
+    requires (transfer >= 0.0)
+    ensures (result <= h_self)
+{
+    h_self - transfer
+}
+
+@verify(lean, theorem = "thermal_apply_neighbour_increases")
+fn apply_neighbour(h_neighbour: Real, transfer: Real) -> Real
+    where chain_order <= 0
+    requires (transfer >= 0.0)
+    ensures (result >= h_neighbour)
+{
+    h_neighbour + transfer
+}

eml_stdlib/gaming/terrain/heightmap.eml

@@ -0,0 +1,33 @@
+// heightmap.eml -- FBM-driven heightmap generation.
+//
+//   h(x, y) = fbm(x * scale, y * scale) * amplitude + base_elevation
+//
+// Output is a scalar height in metres. Caller passes the FBM scale
+// (lower = larger features) and amplitude (peak-to-trough range).
+
+module heightmap;
+
+use stdlib::gaming::noise::fbm;
+
+@verify(lean, theorem = "heightmap_in_band")
+fn height(x: Real, y: Real, scale: Real,
+          amplitude: Real, base_elevation: Real) -> Real
+    where chain_order <= 1,
+          domain: scale > 0.0 && amplitude >= 0.0
+    ensures (result >= base_elevation - amplitude)
+    ensures (result <= base_elevation + amplitude)
+{
+    base_elevation + amplitude * fbm::fbm2_default(x * scale, y * scale)
+}
+
+// Ridged variant: 1 - |fbm| produces sharp ridges (mountains).
+@verify(lean, theorem = "ridged_heightmap_in_band")
+fn ridged_height(x: Real, y: Real, scale: Real,
+                 amplitude: Real, base_elevation: Real) -> Real
+    where chain_order <= 1,
+          domain: scale > 0.0 && amplitude >= 0.0
+    ensures (result >= base_elevation)
+    ensures (result <= base_elevation + amplitude)
+{
+    base_elevation + amplitude * (1.0 - abs(fbm::fbm2_default(x * scale, y * scale)))
+}

eml_stdlib/gaming/textures/brick.eml

@@ -0,0 +1,27 @@
+// brick.eml -- modular brick grid with mortar gap + per-row offset.
+//
+// Returns 1.0 inside a brick, 0.0 inside the mortar joint. The
+// offset alternates each row, which is the visual signature of
+// running-bond brickwork.
+
+module brick;
+
+@verify(lean, theorem = "brick_pattern_in_unit_interval")
+fn pattern(u: Real, v: Real, brick_w: Real, brick_h: Real,
+           mortar_thickness: Real) -> Real
+    where chain_order <= 0,
+          domain: brick_w > 0.0 && brick_h > 0.0 && mortar_thickness >= 0.0
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    let row: Real = floor(v / brick_h);
+    let row_offset: Real = if (row - 2.0 * floor(row * 0.5)) < 0.5 { 0.0 } else { brick_w * 0.5 };
+    let lx: Real = u + row_offset;
+    let frac_u: Real = lx / brick_w - floor(lx / brick_w);
+    let frac_v: Real = v / brick_h - floor(v / brick_h);
+    let edge_u: Real = mortar_thickness / brick_w;
+    let edge_v: Real = mortar_thickness / brick_h;
+    let in_brick_u: Real = if frac_u > edge_u && frac_u < 1.0 - edge_u { 1.0 } else { 0.0 };
+    let in_brick_v: Real = if frac_v > edge_v && frac_v < 1.0 - edge_v { 1.0 } else { 0.0 };
+    in_brick_u * in_brick_v
+}

eml_stdlib/gaming/textures/caustics.eml

@@ -0,0 +1,25 @@
+// caustics.eml -- refracted-light interference pattern.
+//
+// Cheap caustics for pool / sea-floor effects: two perpendicular
+// sine waves perturbed by Perlin noise, multiplied. Result ∈ [0, 1].
+
+module caustics;
+
+use stdlib::gaming::noise::perlin_2d;
+
+const PI: Real = 3.141592653589793
+
+@verify(lean, theorem = "caustics_in_unit_interval")
+fn intensity(x: Real, y: Real, time_s: Real, scale: Real) -> Real
+    where chain_order <= 1,
+          domain: scale > 0.0
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    let n: Real = perlin_2d::perlin2(x * 0.5, y * 0.5);
+    let s_a: Real = sin(2.0 * PI * scale * (x + 0.3 * n) + time_s * 1.3);
+    let s_b: Real = sin(2.0 * PI * scale * (y - 0.3 * n) + time_s * 1.7);
+    let raw: Real = s_a * s_b;
+    let highlit: Real = raw * raw;
+    clamp(highlit, 0.0, 1.0)
+}

eml_stdlib/gaming/textures/checkerboard.eml

@@ -0,0 +1,27 @@
+// checkerboard.eml -- canonical checkerboard pattern.
+//
+//   checker(x, y) = mod(floor(x) + floor(y), 2)
+//
+// Returns 0.0 or 1.0 — caller maps to two colours. Chain order 0.
+
+module checkerboard;
+
+@verify(lean, theorem = "checker_returns_zero_or_one")
+fn checker(x: Real, y: Real) -> Real
+    where chain_order <= 0
+    ensures (result == 0.0 || result == 1.0)
+{
+    let s: Real = floor(x) + floor(y);
+    s - 2.0 * floor(s * 0.5)
+}
+
+// Tile-size-parameterised variant.
+@verify(lean, theorem = "checker_tiled_returns_zero_or_one")
+fn checker_tiled(x: Real, y: Real, tile_size: Real) -> Real
+    where chain_order <= 0,
+          domain: tile_size > 0.0
+    ensures (result == 0.0 || result == 1.0)
+{
+    let s: Real = floor(x / tile_size) + floor(y / tile_size);
+    s - 2.0 * floor(s * 0.5)
+}

eml_stdlib/gaming/textures/fire.eml

@@ -0,0 +1,26 @@
+// fire.eml -- noise-advection fire texture.
+//
+// Vertical advection of FBM noise produces flickering tongues of
+// flame; remap to a temperature-to-colour gradient.
+//
+// Output is a normalised intensity ∈ [0, 1] that the caller maps
+// to (orange, yellow, white, alpha) by table lookup.
+
+module fire;
+
+use stdlib::gaming::noise::fbm;
+
+@verify(lean, theorem = "fire_intensity_in_unit_interval")
+fn intensity(u: Real, v: Real, time_s: Real, rise_speed: Real) -> Real
+    where chain_order <= 1,
+          domain: rise_speed >= 0.0
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    // Advect upward with time.
+    let v_advected: Real = v + rise_speed * time_s;
+    let n: Real = fbm::fbm2_unit(u * 1.5, v_advected * 0.8);
+    // Vertical fall-off: hotter at the base, cools toward the tip.
+    let falloff: Real = clamp(1.0 - v, 0.0, 1.0);
+    clamp(n * falloff, 0.0, 1.0)
+}

eml_stdlib/gaming/textures/marble.eml

@@ -0,0 +1,24 @@
+// marble.eml -- turbulence-perturbed sine ramp.
+//
+//   marble(x, y) = (sin(2π * f * (x + amplitude * turbulence(x, y))) + 1) / 2
+//
+// The turbulence (absolute-value FBM) bends the sine bands into
+// the cusped vein patterns marble is known for. Caller maps the
+// scalar to a colour gradient.
+
+module marble;
+
+use stdlib::gaming::noise::turbulence;
+
+const PI: Real = 3.141592653589793
+
+@verify(lean, theorem = "marble_in_unit_interval")
+fn marble(x: Real, y: Real, frequency: Real, amplitude: Real) -> Real
+    where chain_order <= 1,
+          domain: frequency > 0.0 && amplitude >= 0.0
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    let t: Real = turbulence::turbulence2_default(x, y);
+    0.5 * (sin(2.0 * PI * frequency * (x + amplitude * t)) + 1.0)
+}

eml_stdlib/gaming/textures/rust.eml

@@ -0,0 +1,23 @@
+// rust.eml -- Voronoi-driven rust / oxidation mask.
+//
+// Combine Voronoi cells (irregular pitting) with FBM erosion (the
+// flow patterns where moisture pools). Output ∈ [0, 1] — pipe into
+// a brown-orange colour ramp.
+
+module rust;
+
+use stdlib::gaming::noise::voronoi_2d;
+use stdlib::gaming::noise::fbm;
+
+@verify(lean, theorem = "rust_mask_in_unit_interval")
+fn mask(x: Real, y: Real, pitting_strength: Real, flow_strength: Real) -> Real
+    where chain_order <= 1,
+          domain: pitting_strength >= 0.0 && flow_strength >= 0.0
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    let pit: Real = clamp(1.0 - voronoi_2d::distance_to_nearest(x * 0.5, y * 0.5),
+                          0.0, 1.0);
+    let flow: Real = fbm::fbm2_unit(x * 0.7, y * 0.7);
+    clamp(pitting_strength * pit + flow_strength * flow, 0.0, 1.0)
+}

eml_stdlib/gaming/textures/water_surface.eml

@@ -0,0 +1,49 @@
+// water_surface.eml -- sum-of-sines water height field.
+//
+// Three layered sine waves with different frequencies, directions
+// and phase speeds. Cheap, plausible water you can drop into any
+// shader. For real-time rendering the caller animates the `time`
+// parameter.
+
+module water_surface;
+
+const PI: Real = 3.141592653589793
+
+@verify(lean, theorem = "water_height_signed")
+fn height(x: Real, y: Real, time_s: Real,
+          amp_a: Real, amp_b: Real, amp_c: Real) -> Real
+    where chain_order <= 1
+    requires (amp_a >= 0.0)
+    requires (amp_b >= 0.0)
+    requires (amp_c >= 0.0)
+{
+    let w_a: Real = sin(2.0 * PI * (0.10 * x + 0.05 * y) + 1.4 * time_s);
+    let w_b: Real = sin(2.0 * PI * (0.07 * x - 0.13 * y) + 0.9 * time_s);
+    let w_c: Real = sin(2.0 * PI * (0.21 * x + 0.18 * y) + 2.3 * time_s);
+    amp_a * w_a + amp_b * w_b + amp_c * w_c
+}
+
+// Default parameter set good enough for most water shaders.
+@verify(lean, theorem = "water_height_default_signed")
+fn height_default(x: Real, y: Real, time_s: Real) -> Real
+    where chain_order <= 1
+{
+    height(x, y, time_s, 0.5, 0.3, 0.15)
+}
+
+// Approximate normal of the height field for shading.
+@verify(lean, theorem = "water_normal_unit_length")
+fn normal_y(x: Real, y: Real, time_s: Real, eps: Real) -> Real
+    where chain_order <= 1,
+          domain: eps > 0.0
+    ensures (result >= 0.0)
+{
+    let h_x_plus: Real  = height_default(x + eps, y,       time_s);
+    let h_x_minus: Real = height_default(x - eps, y,       time_s);
+    let h_y_plus: Real  = height_default(x,       y + eps, time_s);
+    let h_y_minus: Real = height_default(x,       y - eps, time_s);
+    let dhx: Real = (h_x_plus - h_x_minus) / (2.0 * eps);
+    let dhy: Real = (h_y_plus - h_y_minus) / (2.0 * eps);
+    let n_y: Real = 1.0 / sqrt(1.0 + dhx * dhx + dhy * dhy);
+    clamp(n_y, 0.0, 1.0)
+}

eml_stdlib/gaming/textures/wood.eml

@@ -0,0 +1,41 @@
+// wood.eml -- procedural wood-grain texture.
+//
+//   ring(x, y) = sin(2π * frequency * (radial_distance + warp))
+//
+// Radial distance from a virtual trunk axis modulated by Perlin
+// noise gives concentric tree rings. Output is a scalar grain
+// intensity in [0, 1] suitable for piping into a colour ramp.
+
+module wood;
+
+use stdlib::gaming::noise::perlin_2d;
+
+const PI: Real = 3.141592653589793
+
+@verify(lean, theorem = "wood_grain_in_unit_interval")
+fn grain(x: Real, y: Real, ring_frequency: Real, warp_amount: Real) -> Real
+    where chain_order <= 1,
+          domain: ring_frequency > 0.0
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    let r: Real = sqrt(x * x + y * y);
+    let warp: Real = warp_amount * perlin_2d::perlin2(x * 0.4, y * 0.4);
+    let s: Real = sin(2.0 * PI * ring_frequency * (r + warp));
+    0.5 * (s + 1.0)
+}
+
+// Knot-mask: returns a contribution that goes to 1 inside random
+// knot blobs scattered by Perlin noise. Multiplied with the grain
+// for visual depth.
+@verify(lean, theorem = "wood_knot_in_unit_interval")
+fn knot_mask(x: Real, y: Real, threshold: Real) -> Real
+    where chain_order <= 1
+    requires (threshold >= 0.0)
+    requires (threshold <= 1.0)
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    let n: Real = perlin_2d::perlin2_unit(x * 0.15, y * 0.15);
+    clamp((n - threshold) / (1.0 - threshold + 1.0e-3), 0.0, 1.0)
+}