@woosh/meep-engine 3.64.1 → 3.65.0

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

@@ -0,0 +1,145 @@
+/**
+ * Grass blades on the device: the constants and records every pass over them shares.
+ *
+ * No blade is kept. Each frame, for each view, every baked slot of the grass surfaces' pool
+ * (`GRASS_SURFACE.js`) is a **cell**: it counts the blades it can owe the view, the counts are summed, and
+ * a thread a counted blade makes the blade or drops it. The blades that are made are a **blade list**, in
+ * no order, which the blade draw and the blade resolve read by a blade's place in it.
+ */
+/**
+ * Words in a blade's record (`chunk_grass_blade_record`).
+ *
+ * @type {number}
+ */
+export const GRASS_BLADE_RECORD_WORDS: number;
+/**
+ * Words at the front of a blade list, ahead of its records.
+ *
+ * @type {number}
+ */
+export const GRASS_BLADE_LIST_HEADER_WORDS: number;
+/**
+ * Blade list word: how many blades asked for a place. It can pass the places the list has, and the list
+ * then holds its first `blade_capacity` only.
+ *
+ * @type {number}
+ */
+export const GRASS_BLADE_LIST_COUNT: number;
+/**
+ * Blade list word: the view's focal length in pixels, the bits of a `f32`, for the draw.
+ *
+ * @type {number}
+ */
+export const GRASS_BLADE_LIST_FOCAL: number;
+/**
+ * Blade list word: the least width a blade is drawn at, in pixels, the bits of a `f32`, for the draw.
+ *
+ * @type {number}
+ */
+export const GRASS_BLADE_LIST_NARROWEST: number;
+/**
+ * Segments a blade is drawn with along its length.
+ *
+ * @type {number}
+ */
+export const GRASS_BLADE_SEGMENTS: number;
+/**
+ * Vertices of a blade's triangle strip: a pair an end of a segment but the last, which is the tip.
+ *
+ * @type {number}
+ */
+export const GRASS_BLADE_VERTICES: number;
+/**
+ * Format of the blade id target: for each pixel a blade covers, which blade and where on it.
+ *
+ * @type {GPUTextureFormat}
+ */
+export const GRASS_BLADE_ID_FORMAT: GPUTextureFormat;
+/**
+ * What the id target holds where no blade is.
+ *
+ * @type {number}
+ */
+export const GRASS_BLADE_ID_NONE: number;
+/**
+ * Bits of an id that say where across the blade's width the pixel is.
+ *
+ * @type {number}
+ */
+export const GRASS_BLADE_ID_ACROSS_BITS: number;
+/**
+ * Bits of an id that say where along the blade's length the pixel is.
+ *
+ * @type {number}
+ */
+export const GRASS_BLADE_ID_ALONG_BITS: number;
+/**
+ * The most blades a list can hold: an id's remaining bits name a blade's place plus one.
+ *
+ * @type {number}
+ */
+export const GRASS_BLADE_CAPACITY_LIMIT: number;
+/**
+ * Cell flag: no baked tile of the next level up covers the cell, so it also makes the blades past its
+ * level's ring.
+ *
+ * @type {number}
+ */
+export const GRASS_CELL_PARENT_MISSING: number;
+/**
+ * Cell flag, shifted left by a quarter's number (x's half, plus two for z's): no baked tile of the level
+ * below covers that quarter of the cell, so it also makes that quarter's blades nearer than its ring.
+ *
+ * @type {number}
+ */
+export const GRASS_CELL_CHILD_MISSING: number;
+/**
+ * Bit a cell's `flags` hold its surface's lattice bits from, eight of them.
+ *
+ * @type {number}
+ */
+export const GRASS_CELL_LATTICE_SHIFT: number;
+/**
+ * A cell: what a blade's thread needs of a slot of the grass surfaces' pool, written by the frame's cell
+ * count for a view. The cell of slot `s` is element `s`.
+ *
+ * - `rank`: the bits every rank in the cell's block ends with (`grass_population_block_rank`).
+ * - `flags`: `GRASS_CELL_*`.
+ * - `surface`: the surface's `transforms` row.
+ * - `level_layer`: the slot record's word of that name.
+ * - `tile`: the slot's tile.
+ * - `ring`: the distances from the view the cell's level serves, inner then outer.
+ *
+ * @type {WebGPUStruct}
+ */
+export const GRASS_CELL_STRUCT: WebGPUStruct;
+/**
+ * Words in a {@link GRASS_CELL_STRUCT}.
+ *
+ * @type {number}
+ */
+export const GRASS_CELL_WORDS: number;
+/**
+ * A species of grass on the device, element `i` of the species list the species `i`.
+ *
+ * - `shape`: blade length and blade width in metres, blades a square metre, roughness.
+ * - `root`: the blade's colour at its root, linear; and how much of its length a blade can lack, 0 to 1.
+ * - `tip`: the blade's colour at its tip, linear; and the most a blade leans from upright at its root, radians.
+ * - `more`: the most a blade's tip turns further than its root leans, radians; how far a blade's colour
+ *   strays from its species'; how far a blade's normal turns towards its edges; one word unused.
+ * - `wind`: the species' wind compliance per blade length cubed (`grass_blade_compliance`); its sway
+ *   frequency times blade length squared (`grass_blade_frequency`); how unsteady the wind a blade feels
+ *   is, as a share of its speed; and the seconds in which a blade that was pressed down stands back up by
+ *   a factor of `e`.
+ *
+ * @type {WebGPUStruct}
+ */
+export const GRASS_SPECIES_STRUCT: WebGPUStruct;
+/**
+ * Words in a {@link GRASS_SPECIES_STRUCT}.
+ *
+ * @type {number}
+ */
+export const GRASS_SPECIES_WORDS: number;
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+//# sourceMappingURL=GRASS_BLADE.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"GRASS_BLADE.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/grass/blade/GRASS_BLADE.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AAEH;;;;GAIG;AACH,uCAFU,MAAM,CAE2B;AAE3C;;;;GAIG;AACH,4CAFU,MAAM,CAE+B;AAE/C;;;;;GAKG;AACH,qCAFU,MAAM,CAEwB;AAExC;;;;GAIG;AACH,qCAFU,MAAM,CAEwB;AAExC;;;;GAIG;AACH,yCAFU,MAAM,CAE4B;AAE5C;;;;GAIG;AACH,mCAFU,MAAM,CAEsB;AAEtC;;;;GAIG;AACH,mCAFU,MAAM,CAEiD;AAEjE;;;;GAIG;AACH,qDAA+C;AAE/C;;;;GAIG;AACH,kCAFU,MAAM,CAEqB;AAErC;;;;GAIG;AACH,yCAFU,MAAM,CAE4B;AAE5C;;;;GAIG;AACH,wCAFU,MAAM,CAE2B;AAE3C;;;;GAIG;AACH,yCAFU,MAAM,CAEiG;AAEjH;;;;;GAKG;AACH,wCAFU,MAAM,CAE2B;AAE3C;;;;;GAKG;AACH,uCAFU,MAAM,CAE0B;AAE1C;;;;GAIG;AACH,uCAFU,MAAM,CAE0B;AAE1C;;;;;;;;;;;;GAYG;AACH,gCAFU,YAAY,CAUN;AAEhB;;;;GAIG;AACH,+BAFU,MAAM,CAEkB;AAElC;;;;;;;;;;;;;;GAcG;AACH,mCAFU,YAAY,CAQG;AAEzB;;;;GAIG;AACH,kCAFU,MAAM,CAEsB;6BAjLT,mCAAmC"}

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

@@ -0,0 +1,179 @@
+import { f32, u32, vec2i, vec4f } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+
+/**
+ * Grass blades on the device: the constants and records every pass over them shares.
+ *
+ * No blade is kept. Each frame, for each view, every baked slot of the grass surfaces' pool
+ * (`GRASS_SURFACE.js`) is a **cell**: it counts the blades it can owe the view, the counts are summed, and
+ * a thread a counted blade makes the blade or drops it. The blades that are made are a **blade list**, in
+ * no order, which the blade draw and the blade resolve read by a blade's place in it.
+ */
+
+/**
+ * Words in a blade's record (`chunk_grass_blade_record`).
+ *
+ * @type {number}
+ */
+export const GRASS_BLADE_RECORD_WORDS = 10;
+
+/**
+ * Words at the front of a blade list, ahead of its records.
+ *
+ * @type {number}
+ */
+export const GRASS_BLADE_LIST_HEADER_WORDS = 4;
+
+/**
+ * Blade list word: how many blades asked for a place. It can pass the places the list has, and the list
+ * then holds its first `blade_capacity` only.
+ *
+ * @type {number}
+ */
+export const GRASS_BLADE_LIST_COUNT = 0;
+
+/**
+ * Blade list word: the view's focal length in pixels, the bits of a `f32`, for the draw.
+ *
+ * @type {number}
+ */
+export const GRASS_BLADE_LIST_FOCAL = 1;
+
+/**
+ * Blade list word: the least width a blade is drawn at, in pixels, the bits of a `f32`, for the draw.
+ *
+ * @type {number}
+ */
+export const GRASS_BLADE_LIST_NARROWEST = 2;
+
+/**
+ * Segments a blade is drawn with along its length.
+ *
+ * @type {number}
+ */
+export const GRASS_BLADE_SEGMENTS = 3;
+
+/**
+ * Vertices of a blade's triangle strip: a pair an end of a segment but the last, which is the tip.
+ *
+ * @type {number}
+ */
+export const GRASS_BLADE_VERTICES = 2 * GRASS_BLADE_SEGMENTS + 1;
+
+/**
+ * Format of the blade id target: for each pixel a blade covers, which blade and where on it.
+ *
+ * @type {GPUTextureFormat}
+ */
+export const GRASS_BLADE_ID_FORMAT = "r32uint";
+
+/**
+ * What the id target holds where no blade is.
+ *
+ * @type {number}
+ */
+export const GRASS_BLADE_ID_NONE = 0;
+
+/**
+ * Bits of an id that say where across the blade's width the pixel is.
+ *
+ * @type {number}
+ */
+export const GRASS_BLADE_ID_ACROSS_BITS = 4;
+
+/**
+ * Bits of an id that say where along the blade's length the pixel is.
+ *
+ * @type {number}
+ */
+export const GRASS_BLADE_ID_ALONG_BITS = 6;
+
+/**
+ * The most blades a list can hold: an id's remaining bits name a blade's place plus one.
+ *
+ * @type {number}
+ */
+export const GRASS_BLADE_CAPACITY_LIMIT = 2 ** (32 - GRASS_BLADE_ID_ACROSS_BITS - GRASS_BLADE_ID_ALONG_BITS) - 1;
+
+/**
+ * Cell flag: no baked tile of the next level up covers the cell, so it also makes the blades past its
+ * level's ring.
+ *
+ * @type {number}
+ */
+export const GRASS_CELL_PARENT_MISSING = 1;
+
+/**
+ * Cell flag, shifted left by a quarter's number (x's half, plus two for z's): no baked tile of the level
+ * below covers that quarter of the cell, so it also makes that quarter's blades nearer than its ring.
+ *
+ * @type {number}
+ */
+export const GRASS_CELL_CHILD_MISSING = 2;
+
+/**
+ * Bit a cell's `flags` hold its surface's lattice bits from, eight of them.
+ *
+ * @type {number}
+ */
+export const GRASS_CELL_LATTICE_SHIFT = 8;
+
+/**
+ * A cell: what a blade's thread needs of a slot of the grass surfaces' pool, written by the frame's cell
+ * count for a view. The cell of slot `s` is element `s`.
+ *
+ * - `rank`: the bits every rank in the cell's block ends with (`grass_population_block_rank`).
+ * - `flags`: `GRASS_CELL_*`.
+ * - `surface`: the surface's `transforms` row.
+ * - `level_layer`: the slot record's word of that name.
+ * - `tile`: the slot's tile.
+ * - `ring`: the distances from the view the cell's level serves, inner then outer.
+ *
+ * @type {WebGPUStruct}
+ */
+export const GRASS_CELL_STRUCT = WebGPUStruct.from({
+    rank: u32,
+    flags: u32,
+    surface: u32,
+    level_layer: u32,
+    tile: vec2i,
+    ring_inner: f32,
+    ring_outer: f32,
+}, "GrassCell");
+
+/**
+ * Words in a {@link GRASS_CELL_STRUCT}.
+ *
+ * @type {number}
+ */
+export const GRASS_CELL_WORDS = 8;
+
+/**
+ * A species of grass on the device, element `i` of the species list the species `i`.
+ *
+ * - `shape`: blade length and blade width in metres, blades a square metre, roughness.
+ * - `root`: the blade's colour at its root, linear; and how much of its length a blade can lack, 0 to 1.
+ * - `tip`: the blade's colour at its tip, linear; and the most a blade leans from upright at its root, radians.
+ * - `more`: the most a blade's tip turns further than its root leans, radians; how far a blade's colour
+ *   strays from its species'; how far a blade's normal turns towards its edges; one word unused.
+ * - `wind`: the species' wind compliance per blade length cubed (`grass_blade_compliance`); its sway
+ *   frequency times blade length squared (`grass_blade_frequency`); how unsteady the wind a blade feels
+ *   is, as a share of its speed; and the seconds in which a blade that was pressed down stands back up by
+ *   a factor of `e`.
+ *
+ * @type {WebGPUStruct}
+ */
+export const GRASS_SPECIES_STRUCT = WebGPUStruct.from({
+    shape: vec4f,
+    root: vec4f,
+    tip: vec4f,
+    more: vec4f,
+    wind: vec4f,
+}, "GrassSpeciesRecord");
+
+/**
+ * Words in a {@link GRASS_SPECIES_STRUCT}.
+ *
+ * @type {number}
+ */
+export const GRASS_SPECIES_WORDS = 20;

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

@@ -0,0 +1,63 @@
+/**
+ * A blade of grass: its record, its shape, and how many of them a view is shown.
+ *
+ * ```wgsl
+ * struct GrassBlade {
+ *     root: vec3<f32>,     // where it stands, in its surface's frame
+ *     surface: u32,        // the surface's transforms row, under 2^22
+ *     species: u32,        // its species' place in the species list, under 2^10
+ *     length: f32,         // from root to tip along the blade, as drawn
+ *     width: f32,          // at the root, as grown
+ *     facing: f32,         // the way it leans, an angle about the frame's up axis from +x towards +z, [0, 2π)
+ *     lean: f32,           // how far from upright it is at the root, towards its facing, [-π/2, π/2]
+ *     curl: f32,           // how much further its tip has turned, [-π, π]
+ *     ground: vec3<f32>,   // the ground's normal under it, unit, in the frame
+ *     thinning: f32,       // 1 where it stands for itself, towards 0 as it stands for more blades left out
+ *     seed: u32,           // eight bits that are the blade's own
+ *     facing_previous: f32,   // facing, lean and curl as they were a frame ago
+ *     lean_previous: f32,
+ *     curl_previous: f32,
+ * }
+ *
+ * fn grass_blade_pack(blade: GrassBlade) -> array<u32, 10>
+ * fn grass_blade_unpack(words: array<u32, 10>) -> GrassBlade
+ * fn grass_blade_previous(blade: GrassBlade) -> GrassBlade
+ * fn grass_blade_point(blade: GrassBlade, along: f32) -> vec3<f32>
+ * fn grass_blade_tangent(blade: GrassBlade, along: f32) -> vec3<f32>
+ * fn grass_blade_across(blade: GrassBlade) -> vec3<f32>
+ * fn grass_blade_taper(along: f32) -> f32
+ * fn grass_blade_drawn_width(view: GrassSurfaceViewSettings, width: f32, distance: f32) -> f32
+ * fn grass_blade_density(view: GrassSurfaceViewSettings, content: f32, width: f32, length: f32, distance: f32, sin_elevation: f32, ground_up: f32) -> f32
+ * fn grass_blade_fade(view: GrassSurfaceViewSettings, length: f32, distance: f32) -> f32
+ * ```
+ *
+ * **Shape.** A blade is an arc of its length, in the plane of the frame's up axis and its facing: upright
+ * but for `lean` at the root, and turned by `curl` more at the tip, evenly along it, so bending never
+ * stretches it. A record keeps the arc twice, as it is and as it was a frame ago; `grass_blade_previous`
+ * is the blade as it was, for where each of its points has come from. The two arcs are packed alike, so
+ * a blade that has not moved unpacks as the same arc twice. `grass_blade_point` is the point `along` of the way from root (0) to tip (1), in the frame;
+ * `grass_blade_tangent` the unit direction the blade runs there; `grass_blade_across` the unit direction
+ * of its width, level in the frame. `grass_blade_taper` is the blade's width at a point as a share of its
+ * root's.
+ *
+ * **How many.** `grass_blade_density` is the blades a square metre of ground a view is shown, of grass
+ * that grows `content` a square metre, each `width` wide and `length` long, `distance` from the view. It
+ * is the least of three:
+ *
+ * - what grows;
+ * - no blade is drawn narrower than `view.narrowest_blade` pixels (`grass_blade_drawn_width`), and where
+ *   blades are drawn wider than they are there are as many fewer, so the ground they cover is the same;
+ * - a view ray crosses no more than `view.canopy_opacity` blades: it runs `length * ground_up /
+ *   tan(elevation)` over the ground inside grass of that height, and meets the blades whose drawn width
+ *   that run crosses. `sin_elevation` is the sine of the angle between the ray and the ground, and
+ *   `ground_up` how upright the ground's normal is, its component along the frame's up axis.
+ *
+ * **How long.** `grass_blade_fade` is the share of its length a blade is drawn at: all of it while its
+ * length spans twice `view.shortest_blade` pixels or more, none once it spans that or less, and in between
+ * as much as the span is past it.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_grass_blade: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_grass_blade.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_grass_blade.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/grass/blade/chunk_grass_blade.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,gCAFU,SAAS,CAmLjB;0BAjPwB,oCAAoC"}

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

@@ -0,0 +1,244 @@
+import { chunk_decode_vertex_normal } from "../../shader/chunk/geometry/normal/chunk_decode_vertex_normal.js";
+import { chunk_encode_vertex_normal } from "../../shader/chunk/geometry/normal/chunk_encode_vertex_normal.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { GRASS_SURFACE_VIEW_SETTINGS } from "../surface/GRASS_SURFACE_VIEW.js";
+import { GRASS_BLADE_RECORD_WORDS } from "./GRASS_BLADE.js";
+
+/**
+ * A blade of grass: its record, its shape, and how many of them a view is shown.
+ *
+ * ```wgsl
+ * struct GrassBlade {
+ *     root: vec3<f32>,     // where it stands, in its surface's frame
+ *     surface: u32,        // the surface's transforms row, under 2^22
+ *     species: u32,        // its species' place in the species list, under 2^10
+ *     length: f32,         // from root to tip along the blade, as drawn
+ *     width: f32,          // at the root, as grown
+ *     facing: f32,         // the way it leans, an angle about the frame's up axis from +x towards +z, [0, 2π)
+ *     lean: f32,           // how far from upright it is at the root, towards its facing, [-π/2, π/2]
+ *     curl: f32,           // how much further its tip has turned, [-π, π]
+ *     ground: vec3<f32>,   // the ground's normal under it, unit, in the frame
+ *     thinning: f32,       // 1 where it stands for itself, towards 0 as it stands for more blades left out
+ *     seed: u32,           // eight bits that are the blade's own
+ *     facing_previous: f32,   // facing, lean and curl as they were a frame ago
+ *     lean_previous: f32,
+ *     curl_previous: f32,
+ * }
+ *
+ * fn grass_blade_pack(blade: GrassBlade) -> array<u32, 10>
+ * fn grass_blade_unpack(words: array<u32, 10>) -> GrassBlade
+ * fn grass_blade_previous(blade: GrassBlade) -> GrassBlade
+ * fn grass_blade_point(blade: GrassBlade, along: f32) -> vec3<f32>
+ * fn grass_blade_tangent(blade: GrassBlade, along: f32) -> vec3<f32>
+ * fn grass_blade_across(blade: GrassBlade) -> vec3<f32>
+ * fn grass_blade_taper(along: f32) -> f32
+ * fn grass_blade_drawn_width(view: GrassSurfaceViewSettings, width: f32, distance: f32) -> f32
+ * fn grass_blade_density(view: GrassSurfaceViewSettings, content: f32, width: f32, length: f32, distance: f32, sin_elevation: f32, ground_up: f32) -> f32
+ * fn grass_blade_fade(view: GrassSurfaceViewSettings, length: f32, distance: f32) -> f32
+ * ```
+ *
+ * **Shape.** A blade is an arc of its length, in the plane of the frame's up axis and its facing: upright
+ * but for `lean` at the root, and turned by `curl` more at the tip, evenly along it, so bending never
+ * stretches it. A record keeps the arc twice, as it is and as it was a frame ago; `grass_blade_previous`
+ * is the blade as it was, for where each of its points has come from. The two arcs are packed alike, so
+ * a blade that has not moved unpacks as the same arc twice. `grass_blade_point` is the point `along` of the way from root (0) to tip (1), in the frame;
+ * `grass_blade_tangent` the unit direction the blade runs there; `grass_blade_across` the unit direction
+ * of its width, level in the frame. `grass_blade_taper` is the blade's width at a point as a share of its
+ * root's.
+ *
+ * **How many.** `grass_blade_density` is the blades a square metre of ground a view is shown, of grass
+ * that grows `content` a square metre, each `width` wide and `length` long, `distance` from the view. It
+ * is the least of three:
+ *
+ * - what grows;
+ * - no blade is drawn narrower than `view.narrowest_blade` pixels (`grass_blade_drawn_width`), and where
+ *   blades are drawn wider than they are there are as many fewer, so the ground they cover is the same;
+ * - a view ray crosses no more than `view.canopy_opacity` blades: it runs `length * ground_up /
+ *   tan(elevation)` over the ground inside grass of that height, and meets the blades whose drawn width
+ *   that run crosses. `sin_elevation` is the sine of the angle between the ray and the ground, and
+ *   `ground_up` how upright the ground's normal is, its component along the frame's up axis.
+ *
+ * **How long.** `grass_blade_fade` is the share of its length a blade is drawn at: all of it while its
+ * length spans twice `view.shortest_blade` pixels or more, none once it spans that or less, and in between
+ * as much as the span is past it.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_grass_blade = CodeChunk.from(
+    //language=WGSL
+    `
+struct GrassBlade {
+    root: vec3<f32>,
+    surface: u32,
+    species: u32,
+    length: f32,
+    width: f32,
+    facing: f32,
+    lean: f32,
+    curl: f32,
+    ground: vec3<f32>,
+    thinning: f32,
+    seed: u32,
+    facing_previous: f32,
+    lean_previous: f32,
+    curl_previous: f32,
+}
+
+const GRASS_BLADE_TAU = 6.283185307179586;
+
+// the least a record's lean can change by: half a turn over sixteen bits
+const GRASS_BLADE_LEAN_STEP = 4.7937028972077485e-5;
+
+// a facing in sixteen bits of a turn
+fn grass_blade_pack_facing(facing: f32) -> u32 {
+    return u32(fract(facing / GRASS_BLADE_TAU) * 65535.0 + 0.5);
+}
+
+// a lean in [-π/2, π/2] and a curl in [-π, π], sixteen bits each
+fn grass_blade_pack_bend(lean: f32, curl: f32) -> u32 {
+    let l = u32(saturate(lean * 2.0 / GRASS_BLADE_TAU + 0.5) * 65535.0 + 0.5);
+    let c = u32(saturate(curl / GRASS_BLADE_TAU + 0.5) * 65535.0 + 0.5);
+
+    return l | (c << 16u);
+}
+
+fn grass_blade_unpack_facing(word: u32) -> f32 {
+    return f32(word & 0xFFFFu) / 65535.0 * GRASS_BLADE_TAU;
+}
+
+fn grass_blade_unpack_bend(word: u32) -> vec2<f32> {
+    return vec2<f32>(
+        (f32(word & 0xFFFFu) / 65535.0 - 0.5) * GRASS_BLADE_TAU * 0.5,
+        (f32(word >> 16u) / 65535.0 - 0.5) * GRASS_BLADE_TAU,
+    );
+}
+
+fn grass_blade_pack(blade: GrassBlade) -> array<u32, ${GRASS_BLADE_RECORD_WORDS}> {
+    return array<u32, ${GRASS_BLADE_RECORD_WORDS}>(
+        bitcast<u32>(blade.root.x),
+        bitcast<u32>(blade.root.y),
+        bitcast<u32>(blade.root.z),
+        (blade.surface & 0x3FFFFFu) | (blade.species << 22u),
+        pack2x16float(vec2<f32>(blade.length, blade.width)),
+        grass_blade_pack_facing(blade.facing) | (u32(saturate(blade.thinning) * 255.0 + 0.5) << 16u) | ((blade.seed & 0xFFu) << 24u),
+        encode_vertex_normal(blade.ground),
+        grass_blade_pack_bend(blade.lean, blade.curl),
+        grass_blade_pack_facing(blade.facing_previous),
+        grass_blade_pack_bend(blade.lean_previous, blade.curl_previous),
+    );
+}
+
+fn grass_blade_unpack(words: array<u32, ${GRASS_BLADE_RECORD_WORDS}>) -> GrassBlade {
+    var blade: GrassBlade;
+
+    blade.root = vec3<f32>(bitcast<f32>(words[0]), bitcast<f32>(words[1]), bitcast<f32>(words[2]));
+    blade.surface = words[3] & 0x3FFFFFu;
+    blade.species = words[3] >> 22u;
+
+    let size = unpack2x16float(words[4]);
+
+    blade.length = size.x;
+    blade.width = size.y;
+    blade.facing = grass_blade_unpack_facing(words[5]);
+    blade.thinning = f32((words[5] >> 16u) & 0xFFu) / 255.0;
+    blade.seed = words[5] >> 24u;
+    blade.ground = decode_vertex_normal(words[6]);
+
+    let bend = grass_blade_unpack_bend(words[7]);
+
+    blade.lean = bend.x;
+    blade.curl = bend.y;
+    blade.facing_previous = grass_blade_unpack_facing(words[8]);
+
+    let bend_previous = grass_blade_unpack_bend(words[9]);
+
+    blade.lean_previous = bend_previous.x;
+    blade.curl_previous = bend_previous.y;
+
+    return blade;
+}
+
+fn grass_blade_previous(blade: GrassBlade) -> GrassBlade {
+    var before = blade;
+
+    before.facing = blade.facing_previous;
+    before.lean = blade.lean_previous;
+    before.curl = blade.curl_previous;
+
+    return before;
+}
+
+fn grass_blade_point(blade: GrassBlade, along: f32) -> vec3<f32> {
+    let facing = vec2<f32>(cos(blade.facing), sin(blade.facing));
+
+    // the blade's angle from upright runs from lean to lean + curl; its point is that direction summed along it
+    let turned = blade.curl * along;
+
+    var out: f32;
+    var up: f32;
+
+    if (abs(blade.curl) < 1e-3) {
+        // straight, to the precision of what follows
+        out = sin(blade.lean) * along;
+        up = cos(blade.lean) * along;
+    } else {
+        out = (cos(blade.lean) - cos(blade.lean + turned)) / blade.curl;
+        up = (sin(blade.lean + turned) - sin(blade.lean)) / blade.curl;
+    }
+
+    return blade.root + blade.length * vec3<f32>(facing.x * out, up, facing.y * out);
+}
+
+fn grass_blade_tangent(blade: GrassBlade, along: f32) -> vec3<f32> {
+    let angle = blade.lean + blade.curl * along;
+    let out = sin(angle);
+
+    return vec3<f32>(cos(blade.facing) * out, cos(angle), sin(blade.facing) * out);
+}
+
+fn grass_blade_across(blade: GrassBlade) -> vec3<f32> {
+    return vec3<f32>(-sin(blade.facing), 0.0, cos(blade.facing));
+}
+
+fn grass_blade_taper(along: f32) -> f32 {
+    return 1.0 - along * along;
+}
+
+fn grass_blade_drawn_width(view: ${GRASS_SURFACE_VIEW_SETTINGS.wgsl_ref}, width: f32, distance: f32) -> f32 {
+    return max(width, view.narrowest_blade * distance / view.focal);
+}
+
+fn grass_blade_density(
+    view: ${GRASS_SURFACE_VIEW_SETTINGS.wgsl_ref},
+    content: f32,
+    width: f32,
+    length: f32,
+    distance: f32,
+    sin_elevation: f32,
+    ground_up: f32,
+) -> f32 {
+    let drawn = grass_blade_drawn_width(view, width, distance);
+
+    // as many fewer as each is drawn wider
+    let covering = content * width / drawn;
+
+    let s = min(abs(sin_elevation), 1.0);
+    let tan_elevation = s / sqrt(max(1.0 - s * s, 1e-12));
+
+    // the blades a ray crosses are those within the drawn width of its run over the ground inside the grass
+    let opaque = view.canopy_opacity * tan_elevation / max(drawn * length * max(ground_up, 1e-3), 1e-12);
+
+    return min(covering, opaque);
+}
+
+fn grass_blade_fade(view: ${GRASS_SURFACE_VIEW_SETTINGS.wgsl_ref}, length: f32, distance: f32) -> f32 {
+    let pixels = length * view.focal / max(distance, 1e-6);
+
+    return saturate(pixels / view.shortest_blade - 1.0);
+}
+`, [
+        GRASS_SURFACE_VIEW_SETTINGS.declaration_chunk,
+        chunk_encode_vertex_normal,
+        chunk_decode_vertex_normal,
+    ]
+);