@woosh/meep-engine 3.64.1 → 3.67.0

package/src/shade/renderer/grass/blade/chunk_grass_blade_wind.d.ts

@@ -0,0 +1,58 @@
+/**
+ * The scene's clock as the blades' pass reads it, at this frame and at the frame before: whole seconds,
+ * and the rest of a second in [0, 1). Kept apart so that a blade's sway is formed exactly however long the
+ * scene has run.
+ *
+ * @type {WebGPUStruct}
+ */
+export const GRASS_BLADE_CLOCK_STRUCT: WebGPUStruct;
+/**
+ * How a blade of grass stands in a wind: the arc `chunk_grass_blade` draws, bent.
+ *
+ * ```wgsl
+ * struct GrassBladeBend {
+ *     facing: f32,   // the way the blade leans, as GrassBlade's
+ *     lean: f32,     // signed: a blade can lean back from the way its tip has gone
+ *     curl: f32,
+ * }
+ *
+ * fn grass_blade_sway(frequency: f32, whole: u32, fraction: f32) -> f32
+ * fn grass_blade_bend(rest: GrassBladeBend, blade_length: f32, wind: vec3<f32>, species_wind: vec4<f32>, sway: f32, offsets: vec2<f32>, pushed: vec3<f32>) -> GrassBladeBend
+ * ```
+ *
+ * **The bend** is the tree rig's drag law (`chunk_foliage_wind_step`) on a blade that stands upright in
+ * its surface's frame. `wind` is the air's velocity in that frame, m/s. The blade's tip turns towards
+ * where the wind goes over the ground by half the blade's compliance times the wind's speed times its
+ * speed across the blade; the compliance is `species_wind.x` times the blade's length cubed
+ * (`grass_blade_compliance`). The turn is held under a quarter turn the way the rig holds a joint under
+ * its limit, `θ m / (m + θ)`: a blade lying along the wind is pushed no further.
+ *
+ * The turn is shared between the blade's lean and its curl as a loaded beam shares it
+ * (`GRASS_BLADE_WIND_LEAN_SHARE`, `GRASS_BLADE_WIND_CURL_SHARE`), each added to the blade's own in still
+ * air as a direction over the ground. A blade is one flat arc, so the two are then read along the way its
+ * tip has gone: that way is the bent blade's `facing`. In still air, with nothing pushing, the answer is
+ * `rest`, bit for bit.
+ *
+ * **A push** is something that leaves the blade no room to stand (`chunk_grass_press`): `pushed.z` is
+ * the angle from upright the line from the blade's root to its tip is held at, at least, and
+ * `pushed.xy` the velocity over the ground, in the surface's frame, of what holds it. A blade its own
+ * lean and the wind already have that far over, whichever way, is not moved. One that is not is leant
+ * further until it is: the way its tip has gone already, or the way it faces if it has gone nowhere, when
+ * what holds it stands still; the way that goes when it slides; and between the two by their speeds, the
+ * blade's tip's as it sways, its length times its frequency, against the other's. Zero for no push.
+ *
+ * **The sway** stands in for the ringing a blade with no memory cannot have. The wind a blade feels is
+ * unsteadier than the scene's wind resolves, by `species_wind.z` of its speed: along the wind and across
+ * it, each a sine at the blade's own frequency, `species_wind.y` over its length squared
+ * (`grass_blade_frequency`), from where in a turn `offsets` start it. That unsteadiness is added to the
+ * wind before the law above, so it bends the blade as wind does: twice as much along the wind as across.
+ * `sway` is how far through a turn the blade is, [0, 1), which `grass_blade_sway` gives for a clock: the
+ * frequency is held to 2⁻¹⁶ Hz and multiplied by the whole seconds in integers, so the turn is exact at
+ * any age of the scene.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_grass_blade_wind: CodeChunk;
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_grass_blade_wind.d.ts.map

package/src/shade/renderer/grass/blade/chunk_grass_blade_wind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_grass_blade_wind.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/grass/blade/chunk_grass_blade_wind.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,uCAFU,YAAY,CAOA;AAEtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,qCAFU,SAAS,CA8GjB;6BA3K2B,mCAAmC;0BAFtC,oCAAoC"}

package/src/shade/renderer/grass/blade/chunk_grass_blade_wind.js

@@ -0,0 +1,174 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { f32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { GRASS_BLADE_WIND_CURL_SHARE, GRASS_BLADE_WIND_LEAN_SHARE } from "./grass_blade_mechanics.js";
+
+/**
+ * The scene's clock as the blades' pass reads it, at this frame and at the frame before: whole seconds,
+ * and the rest of a second in [0, 1). Kept apart so that a blade's sway is formed exactly however long the
+ * scene has run.
+ *
+ * @type {WebGPUStruct}
+ */
+export const GRASS_BLADE_CLOCK_STRUCT = WebGPUStruct.from({
+    whole: u32,
+    fraction: f32,
+    previous_whole: u32,
+    previous_fraction: f32,
+}, "GrassBladeClock");
+
+/**
+ * How a blade of grass stands in a wind: the arc `chunk_grass_blade` draws, bent.
+ *
+ * ```wgsl
+ * struct GrassBladeBend {
+ *     facing: f32,   // the way the blade leans, as GrassBlade's
+ *     lean: f32,     // signed: a blade can lean back from the way its tip has gone
+ *     curl: f32,
+ * }
+ *
+ * fn grass_blade_sway(frequency: f32, whole: u32, fraction: f32) -> f32
+ * fn grass_blade_bend(rest: GrassBladeBend, blade_length: f32, wind: vec3<f32>, species_wind: vec4<f32>, sway: f32, offsets: vec2<f32>, pushed: vec3<f32>) -> GrassBladeBend
+ * ```
+ *
+ * **The bend** is the tree rig's drag law (`chunk_foliage_wind_step`) on a blade that stands upright in
+ * its surface's frame. `wind` is the air's velocity in that frame, m/s. The blade's tip turns towards
+ * where the wind goes over the ground by half the blade's compliance times the wind's speed times its
+ * speed across the blade; the compliance is `species_wind.x` times the blade's length cubed
+ * (`grass_blade_compliance`). The turn is held under a quarter turn the way the rig holds a joint under
+ * its limit, `θ m / (m + θ)`: a blade lying along the wind is pushed no further.
+ *
+ * The turn is shared between the blade's lean and its curl as a loaded beam shares it
+ * (`GRASS_BLADE_WIND_LEAN_SHARE`, `GRASS_BLADE_WIND_CURL_SHARE`), each added to the blade's own in still
+ * air as a direction over the ground. A blade is one flat arc, so the two are then read along the way its
+ * tip has gone: that way is the bent blade's `facing`. In still air, with nothing pushing, the answer is
+ * `rest`, bit for bit.
+ *
+ * **A push** is something that leaves the blade no room to stand (`chunk_grass_press`): `pushed.z` is
+ * the angle from upright the line from the blade's root to its tip is held at, at least, and
+ * `pushed.xy` the velocity over the ground, in the surface's frame, of what holds it. A blade its own
+ * lean and the wind already have that far over, whichever way, is not moved. One that is not is leant
+ * further until it is: the way its tip has gone already, or the way it faces if it has gone nowhere, when
+ * what holds it stands still; the way that goes when it slides; and between the two by their speeds, the
+ * blade's tip's as it sways, its length times its frequency, against the other's. Zero for no push.
+ *
+ * **The sway** stands in for the ringing a blade with no memory cannot have. The wind a blade feels is
+ * unsteadier than the scene's wind resolves, by `species_wind.z` of its speed: along the wind and across
+ * it, each a sine at the blade's own frequency, `species_wind.y` over its length squared
+ * (`grass_blade_frequency`), from where in a turn `offsets` start it. That unsteadiness is added to the
+ * wind before the law above, so it bends the blade as wind does: twice as much along the wind as across.
+ * `sway` is how far through a turn the blade is, [0, 1), which `grass_blade_sway` gives for a clock: the
+ * frequency is held to 2⁻¹⁶ Hz and multiplied by the whole seconds in integers, so the turn is exact at
+ * any age of the scene.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_grass_blade_wind = CodeChunk.from(
+    //language=WGSL
+    `
+struct GrassBladeBend {
+    facing: f32,
+    lean: f32,
+    curl: f32,
+}
+
+const GRASS_BLADE_WIND_TAU = 6.283185307179586;
+
+// a quarter turn: a blade lying along the wind
+const GRASS_BLADE_WIND_LIMIT = 1.5707963267948966;
+
+const GRASS_BLADE_WIND_LEAN_SHARE: f32 = ${GRASS_BLADE_WIND_LEAN_SHARE};
+const GRASS_BLADE_WIND_CURL_SHARE: f32 = ${GRASS_BLADE_WIND_CURL_SHARE};
+
+fn grass_blade_sway(frequency: f32, whole: u32, fraction: f32) -> f32 {
+    // sixteen bits below a hertz
+    let steps = u32(frequency / GRASS_BLADE_WIND_TAU * 65536.0 + 0.5);
+
+    // turns over the whole seconds, of which only the part of a turn is kept: exact in integers
+    let turned = (steps * whole) & 0xFFFFu;
+
+    return fract((f32(turned) + f32(steps) * fraction) / 65536.0);
+}
+
+fn grass_blade_bend(
+    rest: GrassBladeBend,
+    blade_length: f32,
+    wind: vec3<f32>,
+    species_wind: vec4<f32>,
+    sway: f32,
+    offsets: vec2<f32>,
+    pushed: vec3<f32>,
+) -> GrassBladeBend {
+    // the unsteadiness the blade's own sway stands for, along the wind over the ground and across it
+    let along = sin((sway + offsets.x) * GRASS_BLADE_WIND_TAU) * species_wind.z;
+    let across = sin((sway + offsets.y) * GRASS_BLADE_WIND_TAU) * species_wind.z;
+
+    let level = wind.xz * (1.0 + along) + vec2<f32>(-wind.z, wind.x) * across;
+
+    let across_speed = length(level);
+    let speed = length(vec3<f32>(level.x, wind.y, level.y));
+
+    let raw = 0.5 * species_wind.x * blade_length * blade_length * blade_length * speed * across_speed;
+
+    let held = pushed.z;
+
+    if (raw <= 0.0 && held <= 0.0) {
+        return rest;
+    }
+
+    let facing = vec2<f32>(cos(rest.facing), sin(rest.facing));
+
+    var lean = facing * rest.lean;
+    var curl = facing * rest.curl;
+
+    if (raw > 0.0) {
+        let turn = raw * GRASS_BLADE_WIND_LIMIT / (GRASS_BLADE_WIND_LIMIT + raw);
+
+        let downwind = level / across_speed;
+
+        lean = facing * rest.lean + downwind * (turn * GRASS_BLADE_WIND_LEAN_SHARE);
+        curl = facing * rest.curl + downwind * (turn * GRASS_BLADE_WIND_CURL_SHARE);
+    }
+
+    if (held > 0.0) {
+        // the line from root to tip is half the curl past the lean
+        let line = lean + 0.5 * curl;
+        let over = dot(line, line);
+
+        if (over < held * held) {
+            // the blade's own way, at the speed of its tip, against the way of what holds it
+            let reach = sqrt(over);
+            let own_way = select(facing, line * (1.0 / max(reach, 1e-12)), reach > 1e-6);
+
+            let going = own_way * (species_wind.y / max(blade_length, 1e-6)) + pushed.xy;
+            let speed = length(going);
+            let push_way = select(own_way, going * (1.0 / max(speed, 1e-12)), speed > 1e-6);
+
+            // leant on that way until the line is as far over as it is held
+            let along = dot(line, push_way);
+
+            lean += push_way * (sqrt(along * along + held * held - over) - along);
+        }
+    }
+
+    // where the tip has gone over the ground, to first order: the one way a flat arc can face
+    let tip = lean + 0.5 * curl;
+    let reach = length(tip);
+
+    if (reach <= 1e-6) {
+        return rest;
+    }
+
+    let way = tip / reach;
+
+    var bent: GrassBladeBend;
+
+    bent.facing = atan2(way.y, way.x);
+    bent.facing += select(0.0, GRASS_BLADE_WIND_TAU, bent.facing < 0.0);
+    bent.lean = dot(lean, way);
+    bent.curl = dot(curl, way);
+
+    return bent;
+}
+`
+);

package/src/shade/renderer/grass/blade/grass_blade_id_draw.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The bindings of {@link GRASS_BLADE_ID_PIPELINE}: `camera`, `scene_database`, and `grass_blades`, a blade
+ * list closed by `shader_grass_blade_draw_args`.
+ *
+ * @type {ShaderResourceSetDescriptor}
+ */
+export const GRASS_BLADE_ID_RESOURCES: ShaderResourceSetDescriptor;
+/**
+ * Draws a blade list into the blade id target, under the scene's depth, which it writes.
+ *
+ * An instance is a blade and its vertices a strip along it (`GRASS_BLADE_VERTICES`): the arc of
+ * `chunk_grass_blade` in `GRASS_BLADE_SEGMENTS` segments, as wide as the blade tapers, and never drawn
+ * narrower at its root than the view's least width in pixels. A blade seen edge on is drawn at that least
+ * width. Both faces are drawn.
+ *
+ * A covered pixel's id is the blade's place in the list plus one, above `GRASS_BLADE_ID_ALONG_BITS` bits
+ * of how far along the blade the pixel is and `GRASS_BLADE_ID_ACROSS_BITS` of how far across, each from 0
+ * to all ones. Draw with the indirect arguments `shader_grass_blade_draw_args` wrote.
+ *
+ * @type {RenderPipelineDescriptor}
+ */
+export const GRASS_BLADE_ID_PIPELINE: RenderPipelineDescriptor;
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { RenderPipelineDescriptor } from "../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
+//# sourceMappingURL=grass_blade_id_draw.d.ts.map

package/src/shade/renderer/grass/blade/grass_blade_id_draw.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grass_blade_id_draw.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/grass/blade/grass_blade_id_draw.js"],"names":[],"mappings":"AA+FA;;;;;GAKG;AACH,uCAFU,2BAA2B,CAEa;AAElD;;;;;;;;;;;;;GAaG;AACH,sCAFU,wBAAwB,CAiB/B;4CA7HyC,sDAAsD;yCALzD,iEAAiE"}

package/src/shade/renderer/grass/blade/grass_blade_id_draw.js

@@ -0,0 +1,133 @@
+import { ColorTargetState } from "../../../descriptor/pipeline/render/ColorTargetState.js";
+import { DepthStencilState } from "../../../descriptor/pipeline/render/DepthStencilState.js";
+import { RenderPipelineDescriptor } from "../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
+import { CAMERA_RESOURCE } from "../../camera/CAMERA_RESOURCE.js";
+import { TRANSFORMS_TABLE } from "../../scene/chunk_scene_database_access.js";
+import { SCENE_DATABASE_RESOURCE } from "../../scene/SCENE_DATABASE_RESOURCE.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
+import { chunk_grass_surface_frame } from "../surface/chunk_grass_surface_frame.js";
+import { chunk_grass_blade } from "./chunk_grass_blade.js";
+import {
+    GRASS_BLADE_ID_ACROSS_BITS,
+    GRASS_BLADE_ID_ALONG_BITS,
+    GRASS_BLADE_ID_FORMAT,
+    GRASS_BLADE_SEGMENTS
+} from "./GRASS_BLADE.js";
+import { GRASS_BLADE_LIST_STRUCT_READ } from "./shader_grass_blade_expand.js";
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.createGroup()
+    .add(CAMERA_RESOURCE)
+    .add(SCENE_DATABASE_RESOURCE)
+    .addStorageBuffer("grass_blades", GRASS_BLADE_LIST_STRUCT_READ);
+
+const ALONG_STEPS = 2 ** GRASS_BLADE_ID_ALONG_BITS - 1;
+const ACROSS_STEPS = 2 ** GRASS_BLADE_ID_ACROSS_BITS - 1;
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+struct GrassBladeVertex {
+    @builtin(position) position: vec4<f32>,
+    @location(0) @interpolate(flat) blade: u32,
+    @location(1) along: f32,
+    @location(2) across: f32,
+}
+
+@vertex
+fn vs_main(@builtin(vertex_index) vertex: u32, @builtin(instance_index) instance: u32) -> GrassBladeVertex {
+    let blade = grass_blade_unpack(grass_blades.records[instance]);
+
+    let frame = grass_surface_frame(${TRANSFORMS_TABLE.marshalling_method_read_field('global')}(&scene_database, blade.surface));
+
+    // a pair of vertices an end of a segment, and one at the tip
+    let step = min(vertex >> 1u, ${GRASS_BLADE_SEGMENTS}u);
+    let along = f32(step) / ${GRASS_BLADE_SEGMENTS}.0;
+    let side = select(f32(vertex & 1u) * 2.0 - 1.0, 0.0, step == ${GRASS_BLADE_SEGMENTS}u);
+
+    let centre = (frame * vec4<f32>(grass_blade_point(blade, along), 1.0)).xyz;
+    let across = (frame * vec4<f32>(grass_blade_across(blade), 0.0)).xyz;
+
+    let clip = camera.view_projection_matrix * vec4<f32>(centre, 1.0);
+    let edge = camera.view_projection_matrix * vec4<f32>(centre + across * (0.5 * blade.width), 1.0);
+
+    // pixels a unit of normalised device coordinates spans along x and along y
+    let focal = bitcast<f32>(grass_blades.focal);
+    let pixels = vec2<f32>(focal / camera.projection_matrix[0][0], focal / camera.projection_matrix[1][1]);
+
+    // half the blade's width on screen as it is, in pixels, and the way it runs
+    let offset = (edge.xy / max(abs(edge.w), 1e-6) - clip.xy / max(abs(clip.w), 1e-6)) * pixels;
+    let real = length(offset);
+
+    // seen edge on, any way will do: the width is all floor
+    let way = select(vec2<f32>(1.0, 0.0), offset / max(real, 1e-12), real >= 1e-4);
+
+    // never narrower than the least a blade is drawn at
+    let drawn = max(real, 0.5 * bitcast<f32>(grass_blades.narrowest)) * grass_blade_taper(along);
+
+    var out: GrassBladeVertex;
+
+    out.position = clip + vec4<f32>(way * (drawn * side) / pixels * clip.w, 0.0, 0.0);
+    out.blade = instance;
+    out.along = along;
+    out.across = side;
+
+    return out;
+}
+
+@fragment
+fn fs_main(in: GrassBladeVertex) -> @location(0) u32 {
+    let along = u32(saturate(in.along) * ${ALONG_STEPS}.0 + 0.5);
+    let across = u32(saturate(in.across * 0.5 + 0.5) * ${ACROSS_STEPS}.0 + 0.5);
+
+    return ((in.blade + 1u) << ${GRASS_BLADE_ID_ALONG_BITS + GRASS_BLADE_ID_ACROSS_BITS}u) | (along << ${GRASS_BLADE_ID_ACROSS_BITS}u) | across;
+}
+`, [
+        chunk_grass_surface_frame,
+        chunk_grass_blade,
+        TRANSFORMS_TABLE.chunk_read_field('global'),
+    ]);
+
+const descriptor = ShaderDescriptor.from({ label: "Grass Blade Ids", body, resources });
+
+/**
+ * The bindings of {@link GRASS_BLADE_ID_PIPELINE}: `camera`, `scene_database`, and `grass_blades`, a blade
+ * list closed by `shader_grass_blade_draw_args`.
+ *
+ * @type {ShaderResourceSetDescriptor}
+ */
+export const GRASS_BLADE_ID_RESOURCES = resources;
+
+/**
+ * Draws a blade list into the blade id target, under the scene's depth, which it writes.
+ *
+ * An instance is a blade and its vertices a strip along it (`GRASS_BLADE_VERTICES`): the arc of
+ * `chunk_grass_blade` in `GRASS_BLADE_SEGMENTS` segments, as wide as the blade tapers, and never drawn
+ * narrower at its root than the view's least width in pixels. A blade seen edge on is drawn at that least
+ * width. Both faces are drawn.
+ *
+ * A covered pixel's id is the blade's place in the list plus one, above `GRASS_BLADE_ID_ALONG_BITS` bits
+ * of how far along the blade the pixel is and `GRASS_BLADE_ID_ACROSS_BITS` of how far across, each from 0
+ * to all ones. Draw with the indirect arguments `shader_grass_blade_draw_args` wrote.
+ *
+ * @type {RenderPipelineDescriptor}
+ */
+export const GRASS_BLADE_ID_PIPELINE = RenderPipelineDescriptor.from({
+    label: "Grass Blade Ids",
+    layout: resources.generatePipelineLayout(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT),
+    vertex: { module: { code: descriptor.source }, entryPoint: "vs_main" },
+    fragment: {
+        module: { code: descriptor.source },
+        entryPoint: "fs_main",
+        targets: [ColorTargetState.from({ format: GRASS_BLADE_ID_FORMAT })],
+    },
+    depthStencil: DepthStencilState.from({
+        format: "depth32float",
+        depthWriteEnabled: true,
+        depthCompare: "greater",
+    }),
+    primitive: { topology: "triangle-strip", cullMode: "none" },
+});

package/src/shade/renderer/grass/blade/grass_blade_mechanics.d.ts

@@ -0,0 +1,80 @@
+/**
+ * A species' wind compliance per blade length cubed, rad / (m/s)² / m³: a blade `L` long turns its tip by
+ * `0.5 · compliance · L³ · v²` in a wind of speed `v` across it, while the turn is small.
+ *
+ * @param {number} elastic_modulus Pa
+ * @param {number} depth of the blade's section, metres
+ * @returns {number}
+ */
+export function grass_blade_compliance(elastic_modulus: number, depth: number): number;
+/**
+ * A species' first-mode frequency times blade length squared, rad m² / s: a blade `L` long sways at
+ * `frequency / L²`. The single-degree-of-freedom estimate the tree rig takes for a branch
+ * (`tree_skeleton_compute_branch_frequency`), `sqrt(K / J)`: the blade's stiffness against turning under
+ * its own weight's moments, over its moment of inertia about its root. For this blade the moment of its
+ * weight about the root is `ρ t w L² / 4`, its turn under its weight per unit gravity `ρ L³ T / (E t²)`
+ * with `T` {@link GRASS_BLADE_TIP_TURN}, and its inertia `2 ρ t w L³ / 15`.
+ *
+ * @param {number} elastic_modulus Pa
+ * @param {number} depth of the blade's section, metres
+ * @returns {number}
+ */
+export function grass_blade_frequency(elastic_modulus: number, depth: number): number;
+/**
+ * How a blade of grass bends in wind, from what it is made of: the numbers `chunk_grass_blade_wind` bends
+ * a blade by, derived here once a species.
+ *
+ * A blade is a cantilever, clamped at its root: a flat strip of the species' section depth whose width
+ * tapers as `grass_blade_taper` does, `1 − u²` at the share `u` of its length. Wind loads it by drag on its
+ * own width, so the width cancels and what is left is the taper's shape:
+ *
+ * - bending moment at `u`, per unit of dynamic pressure, drag coefficient, root width and length squared:
+ *   `∫ᵤ¹ (1 − x²)(x − u) dx = (1 − u)³(3 + u) / 12`;
+ * - curvature there, per `q C_d L² / (E t³)`: that over the section's `(1 − u²) / 12`, which is
+ *   `(1 − u)²(3 + u) / (1 + u)`;
+ * - the tip's turn is the curvature summed along the blade, and the tip's sideways reach the curvature
+ *   times the length left past it, summed: {@link GRASS_BLADE_TIP_TURN} and {@link GRASS_BLADE_TIP_REACH}.
+ *
+ * It is the tree rig's drag law (`chunk_foliage_wind_step`): a deflection of half a compliance times the
+ * wind speed squared, the compliance carrying air density, drag coefficient and the beam's flexibility.
+ */
+/**
+ * Density of air at sea level, 15 C, kg/m³: the tree rig's.
+ * @type {number}
+ */
+export const GRASS_BLADE_AIR_DENSITY: number;
+/**
+ * Drag coefficient of a leaf, which folds and streamlines in wind (Vogel 1989): the tree rig's for foliage.
+ * @type {number}
+ */
+export const GRASS_BLADE_DRAG_COEFFICIENT: number;
+/**
+ * Density of fresh plant tissue, kg/m³: the tree rig's for green wood.
+ * @type {number}
+ */
+export const GRASS_BLADE_TISSUE_DENSITY: number;
+/**
+ * `∫₀¹ (1 − u)²(3 + u) / (1 + u) du`: the angle a blade's tip turns by, per `q C_d L³ / (E t³)`.
+ * @type {number}
+ */
+export const GRASS_BLADE_TIP_TURN: number;
+/**
+ * `∫₀¹ (1 − u)³(3 + u) / (1 + u) du`: how far a blade's tip moves sideways, per `q C_d L⁴ / (E t³)`.
+ * @type {number}
+ */
+export const GRASS_BLADE_TIP_REACH: number;
+/**
+ * The share of the tip's turn a blade shows as curl. A blade is drawn as an arc: a lean at its root and a
+ * curl spread evenly along it (`chunk_grass_blade`), whose tip turns by `lean + curl` and reaches
+ * `lean + curl / 2` lengths sideways. The two shares put the arc's tip where the beam's is and turn it as
+ * the beam's is turned.
+ *
+ * @type {number}
+ */
+export const GRASS_BLADE_WIND_CURL_SHARE: number;
+/**
+ * The share of the tip's turn a blade shows as lean at its root: the rest of it.
+ * @type {number}
+ */
+export const GRASS_BLADE_WIND_LEAN_SHARE: number;
+//# sourceMappingURL=grass_blade_mechanics.d.ts.map

package/src/shade/renderer/grass/blade/grass_blade_mechanics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grass_blade_mechanics.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/grass/blade/grass_blade_mechanics.js"],"names":[],"mappings":"AAiEA;;;;;;;GAOG;AACH,wDAJW,MAAM,SACN,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;;;;;;GAWG;AACH,uDAJW,MAAM,SACN,MAAM,GACJ,MAAM,CAIlB;AA3FD;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;GAGG;AACH,sCAFU,MAAM,CAE6B;AAE7C;;;GAGG;AACH,2CAFU,MAAM,CAEgC;AAEhD;;;GAGG;AACH,yCAFU,MAAM,CAE8B;AAE9C;;;GAGG;AACH,mCAFU,MAAM,CAE0C;AAE1D;;;GAGG;AACH,oCAFU,MAAM,CAE8C;AAE9D;;;;;;;GAOG;AACH,0CAFU,MAAM,CAEkF;AAElG;;;GAGG;AACH,0CAFU,MAAM,CAE2D"}

package/src/shade/renderer/grass/blade/grass_blade_mechanics.js

@@ -0,0 +1,92 @@
+/**
+ * How a blade of grass bends in wind, from what it is made of: the numbers `chunk_grass_blade_wind` bends
+ * a blade by, derived here once a species.
+ *
+ * A blade is a cantilever, clamped at its root: a flat strip of the species' section depth whose width
+ * tapers as `grass_blade_taper` does, `1 − u²` at the share `u` of its length. Wind loads it by drag on its
+ * own width, so the width cancels and what is left is the taper's shape:
+ *
+ * - bending moment at `u`, per unit of dynamic pressure, drag coefficient, root width and length squared:
+ *   `∫ᵤ¹ (1 − x²)(x − u) dx = (1 − u)³(3 + u) / 12`;
+ * - curvature there, per `q C_d L² / (E t³)`: that over the section's `(1 − u²) / 12`, which is
+ *   `(1 − u)²(3 + u) / (1 + u)`;
+ * - the tip's turn is the curvature summed along the blade, and the tip's sideways reach the curvature
+ *   times the length left past it, summed: {@link GRASS_BLADE_TIP_TURN} and {@link GRASS_BLADE_TIP_REACH}.
+ *
+ * It is the tree rig's drag law (`chunk_foliage_wind_step`): a deflection of half a compliance times the
+ * wind speed squared, the compliance carrying air density, drag coefficient and the beam's flexibility.
+ */
+
+/**
+ * Density of air at sea level, 15 C, kg/m³: the tree rig's.
+ * @type {number}
+ */
+export const GRASS_BLADE_AIR_DENSITY = 1.225;
+
+/**
+ * Drag coefficient of a leaf, which folds and streamlines in wind (Vogel 1989): the tree rig's for foliage.
+ * @type {number}
+ */
+export const GRASS_BLADE_DRAG_COEFFICIENT = 0.4;
+
+/**
+ * Density of fresh plant tissue, kg/m³: the tree rig's for green wood.
+ * @type {number}
+ */
+export const GRASS_BLADE_TISSUE_DENSITY = 900;
+
+/**
+ * `∫₀¹ (1 − u)²(3 + u) / (1 + u) du`: the angle a blade's tip turns by, per `q C_d L³ / (E t³)`.
+ * @type {number}
+ */
+export const GRASS_BLADE_TIP_TURN = 8 * Math.LN2 - 14 / 3;
+
+/**
+ * `∫₀¹ (1 − u)³(3 + u) / (1 + u) du`: how far a blade's tip moves sideways, per `q C_d L⁴ / (E t³)`.
+ * @type {number}
+ */
+export const GRASS_BLADE_TIP_REACH = 16 * Math.LN2 - 125 / 12;
+
+/**
+ * The share of the tip's turn a blade shows as curl. A blade is drawn as an arc: a lean at its root and a
+ * curl spread evenly along it (`chunk_grass_blade`), whose tip turns by `lean + curl` and reaches
+ * `lean + curl / 2` lengths sideways. The two shares put the arc's tip where the beam's is and turn it as
+ * the beam's is turned.
+ *
+ * @type {number}
+ */
+export const GRASS_BLADE_WIND_CURL_SHARE = 2 * (1 - GRASS_BLADE_TIP_REACH / GRASS_BLADE_TIP_TURN);
+
+/**
+ * The share of the tip's turn a blade shows as lean at its root: the rest of it.
+ * @type {number}
+ */
+export const GRASS_BLADE_WIND_LEAN_SHARE = 1 - GRASS_BLADE_WIND_CURL_SHARE;
+
+/**
+ * A species' wind compliance per blade length cubed, rad / (m/s)² / m³: a blade `L` long turns its tip by
+ * `0.5 · compliance · L³ · v²` in a wind of speed `v` across it, while the turn is small.
+ *
+ * @param {number} elastic_modulus Pa
+ * @param {number} depth of the blade's section, metres
+ * @returns {number}
+ */
+export function grass_blade_compliance(elastic_modulus, depth) {
+    return GRASS_BLADE_TIP_TURN * GRASS_BLADE_AIR_DENSITY * GRASS_BLADE_DRAG_COEFFICIENT / (elastic_modulus * depth * depth * depth);
+}
+
+/**
+ * A species' first-mode frequency times blade length squared, rad m² / s: a blade `L` long sways at
+ * `frequency / L²`. The single-degree-of-freedom estimate the tree rig takes for a branch
+ * (`tree_skeleton_compute_branch_frequency`), `sqrt(K / J)`: the blade's stiffness against turning under
+ * its own weight's moments, over its moment of inertia about its root. For this blade the moment of its
+ * weight about the root is `ρ t w L² / 4`, its turn under its weight per unit gravity `ρ L³ T / (E t²)`
+ * with `T` {@link GRASS_BLADE_TIP_TURN}, and its inertia `2 ρ t w L³ / 15`.
+ *
+ * @param {number} elastic_modulus Pa
+ * @param {number} depth of the blade's section, metres
+ * @returns {number}
+ */
+export function grass_blade_frequency(elastic_modulus, depth) {
+    return depth * Math.sqrt(elastic_modulus / GRASS_BLADE_TISSUE_DENSITY) * Math.sqrt(15 / (8 * GRASS_BLADE_TIP_TURN));
+}

package/src/shade/renderer/grass/blade/grass_blade_resolve.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The bindings of {@link GRASS_BLADE_RESOLVE_PIPELINE}: `camera`, `scene_database`, `grass_blades` (the
+ * list the ids were drawn from), `grass_species`, `grass_ids` (the blade id target), `scene_depth` (the
+ * depth the blades were drawn into), and the two matrices of `view_velocity_matrices`.
+ *
+ * @type {ShaderResourceSetDescriptor}
+ */
+export const GRASS_BLADE_RESOLVE_RESOURCES: ShaderResourceSetDescriptor;
+/**
+ * Turns the blade id target into the G-buffer's surface under every pixel a blade covers, and leaves every
+ * other pixel as it was: a full-screen triangle (three vertices) over six targets, loaded: the four
+ * G-buffer targets in `G_BUFFER_COLOR_TARGETS`' order, then the visibility buffer and the velocity buffer.
+ *
+ * A blade's pixel takes its species' colour from root to tip, tinted by the blade's own seed; the normal
+ * of the blade's face on the view's side, turned towards the edge the pixel is nearer; no metalness, no
+ * emission, and an occlusion of one. A blade drawn in place of many (`thinning` under one) moves its
+ * normal towards the ground's and its roughness towards one by as much.
+ *
+ * The pixel's visibility word becomes `VISIBILITY_NONE`: no meshlet is the surface there, and a reader that
+ * decoded the word would find the ground under the blade. Its velocity is the blade point's own, in the
+ * velocity buffer's units: where the point was a frame ago, on the blade as it was bent then
+ * (`grass_blade_previous`) and on its surface where that was.
+ *
+ * @type {RenderPipelineDescriptor}
+ */
+export const GRASS_BLADE_RESOLVE_PIPELINE: RenderPipelineDescriptor;
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { RenderPipelineDescriptor } from "../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
+//# sourceMappingURL=grass_blade_resolve.d.ts.map

package/src/shade/renderer/grass/blade/grass_blade_resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grass_blade_resolve.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/grass/blade/grass_blade_resolve.js"],"names":[],"mappings":"AAsIA;;;;;;GAMG;AACH,4CAFU,2BAA2B,CAEkB;AAEvD;;;;;;;;;;;;;;;;GAgBG;AACH,2CAFU,wBAAwB,CAgB/B;4CAjKyC,sDAAsD;yCAZzD,iEAAiE"}