@woosh/meep-engine 3.68.0 → 3.70.0

package/src/shade/renderer/trails/shaders/chunk_trail_frame_transport.js

@@ -0,0 +1,57 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * Below this squared length the transported normal is degenerate — the previous normal was nearly
+ * parallel to the new tangent — and a fresh basis is built from the tangent instead.
+ * @type {number}
+ */
+export const TRAIL_FRAME_DEGENERATE_EPSILON_SQR = 1e-10;
+
+/**
+ * `trail_frame_transport(tangent, previous_normal) -> TrailFrame`: the rotation-minimising frame of a
+ * tube's ring, carried from the previous knot's normal onto the plane perpendicular to the unit
+ * `tangent` (Gram-Schmidt), with `binormal = tangent × normal`. The ring keeps its orientation as the
+ * tangent turns, with no twist.
+ *
+ * When the previous normal is (nearly) parallel to the tangent the projection collapses, and the frame
+ * is built from the tangent alone, by the construction `v3_orthonormal_matrix_from_normal` uses on the
+ * CPU, so both paths bootstrap the same frame.
+ *
+ * The same arithmetic as `tube_frame_transport`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_trail_frame_transport = CodeChunk.from(
+    //language=WGSL
+    `
+struct TrailFrame {
+    normal : vec3<f32>,
+    binormal : vec3<f32>,
+}
+
+fn trail_frame_transport(tangent : vec3<f32>, previous_normal : vec3<f32>) -> TrailFrame {
+    let projected = previous_normal - dot(previous_normal, tangent) * tangent;
+    let length_sqr = dot(projected, projected);
+
+    var frame : TrailFrame;
+
+    if (length_sqr > ${TRAIL_FRAME_DEGENERATE_EPSILON_SQR}) {
+        frame.normal = projected * inverseSqrt(length_sqr);
+    } else {
+        var o : vec3<f32>;
+
+        if (abs(tangent.x) > abs(tangent.z)) {
+            o = vec3<f32>(-tangent.y, tangent.x, 0.0);
+        } else {
+            o = vec3<f32>(0.0, -tangent.z, tangent.y);
+        }
+
+        frame.normal = normalize(o);
+    }
+
+    frame.binormal = cross(tangent, frame.normal);
+
+    return frame;
+}
+`
+);

package/src/shade/renderer/trails/shaders/chunk_trail_knot_alpha.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `trail_knot_alpha(record, head, live, address, now) -> f32`: the opacity a knot is drawn with — the
+ * trail's fade at the knot's age as a fraction of `maxAge`, clamped to 0..1, times the trail's base
+ * opacity. `head` and `live` are the trail's state; a knot past the live span is not asked its age and
+ * counts as at the end of its life, so a tick count that has wrapped is never read.
+ *
+ * The fade is evaluated exactly, as `AnimationCurve.evaluate` evaluates it, from the keys of the
+ * enclosing shader's `fade_keys` (`chunk_animation_curve_evaluate_keys`).
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_trail_knot_alpha: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_trail_knot_alpha.d.ts.map

package/src/shade/renderer/trails/shaders/chunk_trail_knot_alpha.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_trail_knot_alpha.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/trails/shaders/chunk_trail_knot_alpha.js"],"names":[],"mappings":"AAMA;;;;;;;;;;GAUG;AACH,qCAFU,SAAS,CAwBjB;0BAtCwB,oCAAoC"}

package/src/shade/renderer/trails/shaders/chunk_trail_knot_alpha.js

@@ -0,0 +1,40 @@
+import { chunk_animation_curve_evaluate_keys } from "../../animation/chunk_animation_curve_evaluate_keys.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_trail_knot_read } from "../data/TRAIL_KNOT.js";
+import { TRAIL_STRUCT } from "../data/TRAIL_RECORD.js";
+import { chunk_trail_common } from "./chunk_trail_update.js";
+
+/**
+ * `trail_knot_alpha(record, head, live, address, now) -> f32`: the opacity a knot is drawn with — the
+ * trail's fade at the knot's age as a fraction of `maxAge`, clamped to 0..1, times the trail's base
+ * opacity. `head` and `live` are the trail's state; a knot past the live span is not asked its age and
+ * counts as at the end of its life, so a tick count that has wrapped is never read.
+ *
+ * The fade is evaluated exactly, as `AnimationCurve.evaluate` evaluates it, from the keys of the
+ * enclosing shader's `fade_keys` (`chunk_animation_curve_evaluate_keys`).
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_trail_knot_alpha = CodeChunk.from(
+    //language=WGSL
+    `
+fn trail_knot_alpha(record : ${TRAIL_STRUCT.wgsl_ref}, head : u32, live : u32, address : u32, now : u32) -> f32 {
+    let count = record.knot_count;
+    let j = (address - record.knot_base + count - head) % count;
+
+    var relative = 1.0;
+
+    if (j < live) {
+        let age = f32(now - trail_knot_birth(address));
+
+        relative = clamp(age / f32(max(record.max_age_ticks, 1u)), 0.0, 1.0);
+    }
+
+    return animation_curve_evaluate_keys(&fade_keys, record.fade_first, record.fade_count, relative) * record.color.a;
+}
+`, [
+        chunk_trail_common,
+        chunk_trail_knot_read,
+        chunk_animation_curve_evaluate_keys,
+    ]
+);

package/src/shade/renderer/trails/shaders/chunk_trail_seed.d.ts

@@ -0,0 +1,18 @@
+/**
+ * A trail's seed, knot by knot and then its state:
+ *
+ * - `trail_seed_knot(record, row, i, head, now)` collapses knot `i` of the trail's run onto `head`,
+ *   born `max_age` ago, so it has faded and the first commit finds the ring empty. A build gives it the
+ *   frame a fresh tube starts with, the trail's width and its row; a `clear()`
+ *   ({@link TRAIL_FLAG.RESEED}) keeps the knot's frame, thickness and row.
+ * - `trail_seed_state(record, &state, now)` starts the simulation over from `now`: nothing live,
+ *   nothing travelled, the last commit now, the record's epoch seeded. A build also puts the head at
+ *   slot 0 and the trail's birth at `now`; a `clear()` keeps both, so the warm-up does not run again.
+ *
+ * The enclosing shader binds `knots` read-write.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_trail_seed: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_trail_seed.d.ts.map

package/src/shade/renderer/trails/shaders/chunk_trail_seed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_trail_seed.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/trails/shaders/chunk_trail_seed.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;GAcG;AACH,+BAFU,SAAS,CAyCjB;0BA/DwB,oCAAoC"}

package/src/shade/renderer/trails/shaders/chunk_trail_seed.js

@@ -0,0 +1,64 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_trail_knot_write } from "../data/TRAIL_KNOT.js";
+import { TRAIL_STRUCT } from "../data/TRAIL_RECORD.js";
+import { TRAIL_STATE_STRUCT } from "../data/TRAIL_STATE.js";
+import { chunk_trail_common } from "./chunk_trail_update.js";
+
+const RECORD = TRAIL_STRUCT.wgsl_ref;
+const STATE = TRAIL_STATE_STRUCT.wgsl_ref;
+
+/**
+ * A trail's seed, knot by knot and then its state:
+ *
+ * - `trail_seed_knot(record, row, i, head, now)` collapses knot `i` of the trail's run onto `head`,
+ *   born `max_age` ago, so it has faded and the first commit finds the ring empty. A build gives it the
+ *   frame a fresh tube starts with, the trail's width and its row; a `clear()`
+ *   ({@link TRAIL_FLAG.RESEED}) keeps the knot's frame, thickness and row.
+ * - `trail_seed_state(record, &state, now)` starts the simulation over from `now`: nothing live,
+ *   nothing travelled, the last commit now, the record's epoch seeded. A build also puts the head at
+ *   slot 0 and the trail's birth at `now`; a `clear()` keeps both, so the warm-up does not run again.
+ *
+ * The enclosing shader binds `knots` read-write.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_trail_seed = CodeChunk.from(
+    //language=WGSL
+    `
+fn trail_seed_knot(record : ${RECORD}, row : u32, i : u32, head : vec3<f32>, now : u32) {
+    let address = record.knot_base + i;
+
+    var knot : TrailKnot;
+
+    if ((record.flags & TRAIL_FLAG_RESEED) != 0u) {
+        knot = trail_knot_read(address);
+    } else {
+        knot.normal = vec3<f32>(0.0, 0.0, 1.0);
+        knot.binormal = vec3<f32>(1.0, 0.0, 0.0);
+        knot.thickness = record.width;
+        knot.trail = row;
+    }
+
+    knot.position = head;
+    knot.birth = now - record.max_age_ticks;
+
+    trail_knot_write(address, knot);
+}
+
+fn trail_seed_state(record : ${RECORD}, state : ptr<function, ${STATE}>, now : u32) {
+    if ((record.flags & TRAIL_FLAG_RESEED) == 0u) {
+        (*state).head = 0u;
+        (*state).birth = now;
+    }
+
+    (*state).live = 0u;
+    (*state).last_commit = now;
+    (*state).distance = 0.0;
+    (*state).seeded_epoch = record.seed_epoch;
+}
+`, [
+        TRAIL_STATE_STRUCT.declaration_chunk,
+        chunk_trail_common,
+        chunk_trail_knot_write,
+    ]
+);

package/src/shade/renderer/trails/shaders/chunk_trail_segment.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `trail_segment_bounds(record, head, live, segment, now, &box) -> bool`: whether segment `segment` of a
+ * trail (between the knots `segment` and `segment + 1` tailward of the head) can put anything on screen,
+ * and the box it does it in.
+ *
+ * A segment whose two ends have both faded to nothing (`trail_knot_alpha`) cannot, and `box` is left as
+ * it was. Any other is bounded by the capsule between its two rings: the box of the two knot centres,
+ * grown on every side by the thicker ring's radius, so both rings lie inside it whatever their frames.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_trail_segment: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_trail_segment.d.ts.map

package/src/shade/renderer/trails/shaders/chunk_trail_segment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_trail_segment.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/trails/shaders/chunk_trail_segment.js"],"names":[],"mappings":"AAKA;;;;;;;;;;GAUG;AACH,kCAFU,SAAS,CAoCjB;0BAjDwB,oCAAoC"}

package/src/shade/renderer/trails/shaders/chunk_trail_segment.js

@@ -0,0 +1,51 @@
+import { AABB3_STRUCT } from "../../shader/chunk/geometry/aabb3/AABB3_STRUCT.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { TRAIL_STRUCT } from "../data/TRAIL_RECORD.js";
+import { chunk_trail_knot_alpha } from "./chunk_trail_knot_alpha.js";
+
+/**
+ * `trail_segment_bounds(record, head, live, segment, now, &box) -> bool`: whether segment `segment` of a
+ * trail (between the knots `segment` and `segment + 1` tailward of the head) can put anything on screen,
+ * and the box it does it in.
+ *
+ * A segment whose two ends have both faded to nothing (`trail_knot_alpha`) cannot, and `box` is left as
+ * it was. Any other is bounded by the capsule between its two rings: the box of the two knot centres,
+ * grown on every side by the thicker ring's radius, so both rings lie inside it whatever their frames.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_trail_segment = CodeChunk.from(
+    //language=WGSL
+    `
+fn trail_segment_bounds(
+    record : ${TRAIL_STRUCT.wgsl_ref},
+    head : u32,
+    live : u32,
+    segment : u32,
+    now : u32,
+    box : ptr<function, ${AABB3_STRUCT.wgsl_ref}>,
+) -> bool {
+    let a0 = trail_knot_address(record, head, segment);
+    let a1 = trail_knot_address(record, head, segment + 1u);
+
+    if (trail_knot_alpha(record, head, live, a0, now) <= 0.0 && trail_knot_alpha(record, head, live, a1, now) <= 0.0) {
+        return false;
+    }
+
+    let k0 = trail_knot_read(a0);
+    let k1 = trail_knot_read(a1);
+
+    let radius = vec3<f32>(max(k0.thickness, k1.thickness) * 0.5);
+
+    *box = ${AABB3_STRUCT.make({
+        min: "min(k0.position, k1.position) - radius",
+        max: "max(k0.position, k1.position) + radius",
+    })};
+
+    return true;
+}
+`, [
+        AABB3_STRUCT.declaration_chunk,
+        chunk_trail_knot_alpha,
+    ]
+);

package/src/shade/renderer/trails/shaders/chunk_trail_update.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Below this distance from its predecessor the head has no direction yet, and keeps its frame: the
+ * engine's `EPSILON`.
+ * @type {number}
+ */
+export const TRAIL_TANGENT_EPSILON: number;
+/**
+ * Shared names for the trail passes: the {@link TRAIL_FLAG} bits as constants;
+ * `trail_knot_address(record, head, j)`, the knot `j` knots tailward of the head; and
+ * `trail_head_world(world, offset)`, where the head stands: the trail's offset, in the entity's own
+ * frame, carried through the entity's world matrix, so it turns and scales with the entity. The seed
+ * and the update both place the head by it, so a fresh trail is collapsed where its first update puts
+ * the head and that update bridges nothing.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_trail_common: CodeChunk;
+/**
+ * `trail_update(record, &state, head_position, now) -> u32`: one frame of a trail. Returns how many of
+ * the trail's segments can be visible.
+ *
+ * For a trail that is spawning:
+ *
+ * - The head moved if `head_position` is not where the head knot stands; the distance it moved is
+ *   added to the state's distance.
+ * - It commits a knot when one is due — `commit_ticks` since the last commit in time mode,
+ *   `spawn_distance` travelled in distance mode — and only if the head moved, at most one a frame. The
+ *   ring steps back a slot, the knot the head leaves keeps last frame's position, and both the time and
+ *   the distance start again from the commit.
+ * - If it moved, the head's ring frame is carried from its predecessor along the tangent between them
+ *   (`trail_frame_transport`), unless the two coincide, and the head knot takes the new position.
+ * - The head knot is born now, or, with the warm-up, as old as the time the trail has still to live
+ *   through its first `maxAge`; it takes the trail's width.
+ *
+ * Then the live span: the knots from the head that can still be visible. Ages grow from the head, so
+ * the first knot that has faded ends it, found by binary search over the knots last frame's span
+ * covered and the one committed since — at most `⌈log2(1025)⌉` probes. Only those are asked their
+ * age, so a tick count that has wrapped is never read. An authored trail's knots have ages of the
+ * author's, so every one of them is a candidate. A trail whose fade ends above zero draws its whole
+ * ring.
+ *
+ * The enclosing shader binds `knots` read-write.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_trail_update: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_trail_update.d.ts.map

package/src/shade/renderer/trails/shaders/chunk_trail_update.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_trail_update.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/trails/shaders/chunk_trail_update.js"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,oCAFU,MAAM,CAE8B;AAK9C;;;;;;;;;GASG;AACH,iCAFU,SAAS,CAsBjB;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,iCAFU,SAAS,CA0HjB;0BApMwB,oCAAoC"}

package/src/shade/renderer/trails/shaders/chunk_trail_update.js

@@ -0,0 +1,197 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_trail_knot_write } from "../data/TRAIL_KNOT.js";
+import { TRAIL_FLAG, TRAIL_STRUCT } from "../data/TRAIL_RECORD.js";
+import { TRAIL_STATE_STRUCT } from "../data/TRAIL_STATE.js";
+import { chunk_trail_frame_transport } from "./chunk_trail_frame_transport.js";
+
+/**
+ * Below this distance from its predecessor the head has no direction yet, and keeps its frame: the
+ * engine's `EPSILON`.
+ * @type {number}
+ */
+export const TRAIL_TANGENT_EPSILON = 0.000001;
+
+const RECORD = TRAIL_STRUCT.wgsl_ref;
+const STATE = TRAIL_STATE_STRUCT.wgsl_ref;
+
+/**
+ * Shared names for the trail passes: the {@link TRAIL_FLAG} bits as constants;
+ * `trail_knot_address(record, head, j)`, the knot `j` knots tailward of the head; and
+ * `trail_head_world(world, offset)`, where the head stands: the trail's offset, in the entity's own
+ * frame, carried through the entity's world matrix, so it turns and scales with the entity. The seed
+ * and the update both place the head by it, so a fresh trail is collapsed where its first update puts
+ * the head and that update bridges nothing.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_trail_common = CodeChunk.from(
+    //language=WGSL
+    `
+const TRAIL_FLAG_SPAWNING : u32 = ${TRAIL_FLAG.SPAWNING}u;
+const TRAIL_FLAG_DISTANCE : u32 = ${TRAIL_FLAG.DISTANCE}u;
+const TRAIL_FLAG_AUTHORED : u32 = ${TRAIL_FLAG.AUTHORED}u;
+const TRAIL_FLAG_WARMUP : u32 = ${TRAIL_FLAG.WARMUP}u;
+const TRAIL_FLAG_TAIL_VISIBLE : u32 = ${TRAIL_FLAG.TAIL_VISIBLE}u;
+const TRAIL_FLAG_RESEED : u32 = ${TRAIL_FLAG.RESEED}u;
+
+fn trail_knot_address(record : ${RECORD}, head : u32, j : u32) -> u32 {
+    return record.knot_base + (head + j) % record.knot_count;
+}
+
+fn trail_head_world(world : mat4x4<f32>, offset : vec3<f32>) -> vec3<f32> {
+    return (world * vec4<f32>(offset, 1.0)).xyz;
+}
+`, [
+        TRAIL_STRUCT.declaration_chunk,
+    ]
+);
+
+/**
+ * `trail_update(record, &state, head_position, now) -> u32`: one frame of a trail. Returns how many of
+ * the trail's segments can be visible.
+ *
+ * For a trail that is spawning:
+ *
+ * - The head moved if `head_position` is not where the head knot stands; the distance it moved is
+ *   added to the state's distance.
+ * - It commits a knot when one is due — `commit_ticks` since the last commit in time mode,
+ *   `spawn_distance` travelled in distance mode — and only if the head moved, at most one a frame. The
+ *   ring steps back a slot, the knot the head leaves keeps last frame's position, and both the time and
+ *   the distance start again from the commit.
+ * - If it moved, the head's ring frame is carried from its predecessor along the tangent between them
+ *   (`trail_frame_transport`), unless the two coincide, and the head knot takes the new position.
+ * - The head knot is born now, or, with the warm-up, as old as the time the trail has still to live
+ *   through its first `maxAge`; it takes the trail's width.
+ *
+ * Then the live span: the knots from the head that can still be visible. Ages grow from the head, so
+ * the first knot that has faded ends it, found by binary search over the knots last frame's span
+ * covered and the one committed since — at most `⌈log2(1025)⌉` probes. Only those are asked their
+ * age, so a tick count that has wrapped is never read. An authored trail's knots have ages of the
+ * author's, so every one of them is a candidate. A trail whose fade ends above zero draws its whole
+ * ring.
+ *
+ * The enclosing shader binds `knots` read-write.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_trail_update = CodeChunk.from(
+    //language=WGSL
+    `
+fn trail_update(record : ${RECORD}, state : ptr<function, ${STATE}>, head_position : vec3<f32>, now : u32) -> u32 {
+    let count = record.knot_count;
+    let spawning = (record.flags & TRAIL_FLAG_SPAWNING) != 0u;
+
+    var committed = false;
+
+    if (spawning) {
+        var head = (*state).head;
+
+        let previous = trail_knot_position(record.knot_base + head);
+        let moved = any(head_position != previous);
+
+        if (moved) {
+            (*state).distance = (*state).distance + distance(previous, head_position);
+        }
+
+        var due : bool;
+
+        if ((record.flags & TRAIL_FLAG_DISTANCE) != 0u) {
+            due = (*state).distance >= record.spawn_distance;
+        } else {
+            due = (now - (*state).last_commit) >= record.commit_ticks;
+        }
+
+        if (due && moved) {
+            (*state).last_commit = now;
+            (*state).distance = 0.0;
+
+            head = (head + count - 1u) % count;
+            (*state).head = head;
+
+            committed = true;
+        }
+
+        let address = record.knot_base + head;
+
+        var knot = trail_knot_read(address);
+
+        if (moved) {
+            let predecessor = trail_knot_read(trail_knot_address(record, head, 1u));
+            let toward = head_position - predecessor.position;
+            let toward_length = length(toward);
+
+            if (toward_length > ${TRAIL_TANGENT_EPSILON}) {
+                let frame = trail_frame_transport(toward / toward_length, predecessor.normal);
+
+                knot.normal = frame.normal;
+                knot.binormal = frame.binormal;
+            }
+
+            knot.position = head_position;
+        }
+
+        var age = 0u;
+
+        if ((record.flags & TRAIL_FLAG_WARMUP) != 0u) {
+            let lived = now - (*state).birth;
+
+            age = select(0u, record.max_age_ticks - lived, lived < record.max_age_ticks);
+        }
+
+        knot.birth = now - age;
+        knot.thickness = record.width;
+
+        trail_knot_write(address, knot);
+    }
+
+    var live = (*state).live;
+
+    if ((record.flags & TRAIL_FLAG_AUTHORED) != 0u) {
+        live = count;
+    } else {
+        if (committed) {
+            live = min(live + 1u, count);
+        }
+
+        if (spawning) {
+            // the head was just written, young or old
+            live = max(live, 1u);
+        }
+
+        // the first faded knot in [0, live): before it every knot is younger than maxAge
+        var low = 0u;
+        var high = live;
+
+        loop {
+            if (low >= high) {
+                break;
+            }
+
+            let middle = (low + high) >> 1u;
+            let born = trail_knot_birth(trail_knot_address(record, (*state).head, middle));
+
+            if ((now - born) >= record.max_age_ticks) {
+                high = middle;
+            } else {
+                low = middle + 1u;
+            }
+        }
+
+        live = low;
+    }
+
+    (*state).live = live;
+
+    if ((record.flags & TRAIL_FLAG_TAIL_VISIBLE) != 0u) {
+        return count - 1u;
+    }
+
+    return min(live, count - 1u);
+}
+`, [
+        TRAIL_STATE_STRUCT.declaration_chunk,
+        chunk_trail_common,
+        chunk_trail_knot_write,
+        chunk_trail_frame_transport,
+    ]
+);

package/src/shade/renderer/trails/shaders/chunk_trail_vertex.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The frame uniform: the clock the knots' ages are counted against.
+ */
+export const TRAIL_FRAME_STRUCT: WebGPUStruct;
+/**
+ * What the trails' vertex stage reads, the same group in the splat and the draw: the camera, the
+ * clock, the frame's segment list, the knots, the trail and state tables and the fade keys.
+ *
+ * @type {ShaderResourceGroupDescriptor}
+ */
+export const TRAIL_VERTEX_GROUP: ShaderResourceGroupDescriptor;
+/**
+ * `trail_vertex(vertex_index, instance_index) -> AVBOITUnlitVaryings`: one vertex of one segment of a
+ * trail's tube, extruded where the vertex shader runs instead of on the CPU.
+ *
+ * The instance is the segment: `segment_list[instance_index]` is its head-ward knot, and the knot
+ * names its trail, whose record and state it reads. `trail_ring_vertex(record, head, live, head_ward,
+ * vertex_index, now)` is the vertex itself: `vertex_index` runs over the two rings of `radial + 1`
+ * vertices, the head-ward ring first; the seam vertex closes each ring on its first.
+ *
+ * A ring vertex sits at its knot's centre displaced by `cos θ · normal + sin θ · binormal`, half the
+ * knot's thickness out, at `θ = 2π · r / radial`. Its colour is the trail's; its alpha is the knot's (`trail_knot_alpha`), clamped to 0..1 and
+ * split between the tube's two faces as `1 - √(1 - α)`, because a line of sight through the closed tube
+ * crosses two faces and the two together must cover `α`.
+ *
+ * The enclosing shader binds {@link TRAIL_VERTEX_GROUP}.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_trail_vertex: CodeChunk;
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { ShaderResourceGroupDescriptor } from "../../shader/resource/ShaderResourceGroupDescriptor.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_trail_vertex.d.ts.map

package/src/shade/renderer/trails/shaders/chunk_trail_vertex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_trail_vertex.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/trails/shaders/chunk_trail_vertex.js"],"names":[],"mappings":"AAYA;;GAEG;AACH,8CAEmB;AAEnB;;;;;GAKG;AACH,iCAFU,6BAA6B,CAE+B;AAUtE;;;;;;;;;;;;;;;;;GAiBG;AACH,iCAFU,SAAS,CA2DjB;6BAvG2B,mCAAmC;8CAHlB,wDAAwD;0BAD5E,oCAAoC"}