@woosh/meep-engine 3.68.0 → 3.69.0

package/src/engine/graphics/trail/tube/tube_attributes_spec.js

@@ -1,70 +0,0 @@
-import { EndianType } from "../../../../core/binary/EndianType.js";
-import { BinaryDataType } from "../../../../core/binary/type/BinaryDataType.js";
-import { RowFirstTableSpec } from "../../../../core/collection/table/RowFirstTableSpec.js";
-
-/**
- * Per-vertex attribute layout for a {@link TubeX}.
- *
- * Unlike {@link RibbonX} (which extrudes in screen space and therefore stores
- * the neighbouring positions to derive a 2D normal), the tube extrudes in WORLD
- * space inside the vertex shader using a per-knot tangent frame. Every vertex of
- * a knot's ring shares the same centre/frame/colour/etc and differs only by `off`
- * (its angular position around the ring), so the heavy per-frame work is just
- * writing the knot centre + frame to the ring's `radial+1` rows.
- *
- * Layout is floats-first then a float16 colour triple, padded to a 4-byte multiple
- * so the interleaved Float32 view (stride = bytesPerRecord >> 2) stays aligned —
- * the same trick {@link ribbon_attributes_spec} relies on. The colour is linear and
- * not limited to 0..1, so a trail can be brighter than white.
- */
-export const tube_attributes_spec = new RowFirstTableSpec([
-    // age (CPU-side bookkeeping for the simulator; NOT a GPU attribute)
-    BinaryDataType.Float32,
-
-    // position (ring centre, world space)
-    BinaryDataType.Float32,
-    BinaryDataType.Float32,
-    BinaryDataType.Float32,
-
-    // frame normal (ring basis axis 1, world space, unit)
-    BinaryDataType.Float32,
-    BinaryDataType.Float32,
-    BinaryDataType.Float32,
-
-    // frame binormal (ring basis axis 2, world space, unit)
-    BinaryDataType.Float32,
-    BinaryDataType.Float32,
-    BinaryDataType.Float32,
-
-    // off (angular position around the ring, 0..1; STATIC per radial index = uv.x)
-    BinaryDataType.Float32,
-
-    // uv_v (position along the tube; DYNAMIC = uv.y)
-    BinaryDataType.Float32,
-
-    // alpha
-    BinaryDataType.Float32,
-
-    // thickness (tube diameter; radius = thickness * 0.5)
-    BinaryDataType.Float32,
-
-    // color (linear, unbounded)
-    BinaryDataType.Float16,
-    BinaryDataType.Float16,
-    BinaryDataType.Float16,
-
-    // padding -> bytesPerRecord = 64 (divisible by 4, keeps the Float32 view aligned)
-    BinaryDataType.Uint16,
-
-], EndianType.LittleEndian);
-
-// Column indices into {@link tube_attributes_spec} for RowFirstTable read/write.
-export const TUBE_ATTRIBUTE_ADDRESS_AGE = 0;
-export const TUBE_ATTRIBUTE_ADDRESS_POSITION = 1;
-export const TUBE_ATTRIBUTE_ADDRESS_NORMAL = 4;
-export const TUBE_ATTRIBUTE_ADDRESS_BINORMAL = 7;
-export const TUBE_ATTRIBUTE_ADDRESS_OFF = 10;
-export const TUBE_ATTRIBUTE_ADDRESS_UV_V = 11;
-export const TUBE_ATTRIBUTE_ADDRESS_ALPHA = 12;
-export const TUBE_ATTRIBUTE_ADDRESS_THICKNESS = 13;
-export const TUBE_ATTRIBUTE_ADDRESS_COLOR = 14;

package/src/engine/graphics3/trail/trail_tube_write_geometry.d.ts

@@ -1,38 +0,0 @@
-/**
- * Extrude a {@link TubeX}'s knots into the geometry a {@link DynamicMesh} is already holding.
- *
- * **The ring is built here rather than in a shader, and that is what the path costs.** The legacy
- * renderer draws a tube through a material of its own, so its vertex stage can hold the knot's
- * frame and expand a ring from it; the dynamic path has one pipeline and one vertex layout —
- * position and colour (D11) — so the same expansion happens on the CPU, once per knot ring per
- * frame the trail moves. Widening the layout to carry a frame would mean a second pipeline for
- * every dynamic mesh in the engine, which is the trade D5/D11 already refused.
- *
- * The arithmetic is `TubeMaterialX`'s, exactly: a ring vertex sits at its knot's centre displaced
- * by `cos(angle) * normal + sin(angle) * binormal`, half a thickness out, at `angle = off * 2π`.
- *
- * **Written into rather than replaced.** GPU residency on the dynamic path is keyed on the geometry
- * and survives leaving the batch, so a trail that produced a fresh geometry each frame would strand
- * a vertex buffer per frame.
- *
- * Colour rides the vertices because that is what fades a trail along its length: the knot's own
- * half-float colour as is, unclamped so HDR survives, with its alpha — the simulator's age fade, already scaled by the trail's
- * base opacity — as the fourth channel. A knot that has aged out is written transparent rather than
- * dropped, which is what the index buffer expects, and blending takes it out of the picture.
- *
- * **A knot's alpha is the opacity of the tube as seen, not of one face of it.** The tube is a closed
- * hull drawn from both sides, so a line of sight through it crosses two faces, and the transparency
- * pipeline composes their transmittances: written as is, an alpha of 0.5 would cover 0.75, and a
- * linear fade would hold near solid for most of the trail's life and collapse at its tail. Each face
- * therefore takes half the optical depth, `1 - √(1 - α)`, and the two together cover exactly `α`.
- * This is the one place that knows the hull is crossed twice, so it is the one place that splits it;
- * a ray through a bend crosses the tube twice over, and that overlap is real and reads denser. The
- * alpha is clamped to `0..1` first, the range an opacity has — an authored fade curve may overshoot
- * it, and the square root has no answer above one.
- *
- * @param {Geometry} geometry
- * @param {TubeX} tube
- * @returns {void}
- */
-export function trail_tube_write_geometry(geometry: Geometry, tube: TubeX): void;
-//# sourceMappingURL=trail_tube_write_geometry.d.ts.map

package/src/engine/graphics3/trail/trail_tube_write_geometry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"trail_tube_write_geometry.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/trail/trail_tube_write_geometry.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,4EAFa,IAAI,CAiEhB"}

package/src/engine/graphics3/trail/trail_tube_write_geometry.js

@@ -1,119 +0,0 @@
-import { assert } from "../../../core/assert.js";
-import { clamp01 } from "../../../core/math/clamp01.js";
-import {
-    geometry_obtain_attribute,
-    geometry_obtain_index
-} from "../../../shade/renderer/geometry/geometry_obtain_attribute.js";
-import { StandardAttributes } from "../../../shade/renderer/geometry/StandardAttributes.js";
-import {
-    TUBE_ATTRIBUTE_ADDRESS_ALPHA,
-    TUBE_ATTRIBUTE_ADDRESS_BINORMAL,
-    TUBE_ATTRIBUTE_ADDRESS_COLOR,
-    TUBE_ATTRIBUTE_ADDRESS_NORMAL,
-    TUBE_ATTRIBUTE_ADDRESS_OFF,
-    TUBE_ATTRIBUTE_ADDRESS_POSITION,
-    TUBE_ATTRIBUTE_ADDRESS_THICKNESS
-} from "../../graphics/trail/tube/tube_attributes_spec.js";
-
-const TWO_PI = Math.PI * 2;
-
-/**
- * Extrude a {@link TubeX}'s knots into the geometry a {@link DynamicMesh} is already holding.
- *
- * **The ring is built here rather than in a shader, and that is what the path costs.** The legacy
- * renderer draws a tube through a material of its own, so its vertex stage can hold the knot's
- * frame and expand a ring from it; the dynamic path has one pipeline and one vertex layout —
- * position and colour (D11) — so the same expansion happens on the CPU, once per knot ring per
- * frame the trail moves. Widening the layout to carry a frame would mean a second pipeline for
- * every dynamic mesh in the engine, which is the trade D5/D11 already refused.
- *
- * The arithmetic is `TubeMaterialX`'s, exactly: a ring vertex sits at its knot's centre displaced
- * by `cos(angle) * normal + sin(angle) * binormal`, half a thickness out, at `angle = off * 2π`.
- *
- * **Written into rather than replaced.** GPU residency on the dynamic path is keyed on the geometry
- * and survives leaving the batch, so a trail that produced a fresh geometry each frame would strand
- * a vertex buffer per frame.
- *
- * Colour rides the vertices because that is what fades a trail along its length: the knot's own
- * half-float colour as is, unclamped so HDR survives, with its alpha — the simulator's age fade, already scaled by the trail's
- * base opacity — as the fourth channel. A knot that has aged out is written transparent rather than
- * dropped, which is what the index buffer expects, and blending takes it out of the picture.
- *
- * **A knot's alpha is the opacity of the tube as seen, not of one face of it.** The tube is a closed
- * hull drawn from both sides, so a line of sight through it crosses two faces, and the transparency
- * pipeline composes their transmittances: written as is, an alpha of 0.5 would cover 0.75, and a
- * linear fade would hold near solid for most of the trail's life and collapse at its tail. Each face
- * therefore takes half the optical depth, `1 - √(1 - α)`, and the two together cover exactly `α`.
- * This is the one place that knows the hull is crossed twice, so it is the one place that splits it;
- * a ray through a bend crosses the tube twice over, and that overlap is real and reads denser. The
- * alpha is clamped to `0..1` first, the range an opacity has — an authored fade curve may overshoot
- * it, and the square root has no answer above one.
- *
- * @param {Geometry} geometry
- * @param {TubeX} tube
- * @returns {void}
- */
-export function trail_tube_write_geometry(geometry, tube) {
-    assert.defined(geometry, 'geometry');
-    assert.defined(tube, 'tube');
-
-    const vertex_count = tube.vertex_count;
-
-    const positions = geometry_obtain_attribute(geometry, StandardAttributes.Position, 3, vertex_count);
-    const colors = geometry_obtain_attribute(geometry, StandardAttributes.Color, 4, vertex_count);
-
-    const table = tube.table;
-
-    // Views over the knot rows, not a copy of them. Every attribute up to the colour is a float, so
-    // a column index is also its offset in the float view; the colour is three half floats at the
-    // column that follows them.
-    const floats = new Float32Array(table.data);
-    const halves = new Float16Array(table.data);
-
-    const float_stride = tube.bytes_per_vertex >> 2;
-    const half_stride = tube.bytes_per_vertex >> 1;
-
-    const color_offset = TUBE_ATTRIBUTE_ADDRESS_COLOR * 2;
-
-    for (let i = 0; i < vertex_count; i++) {
-        const f = i * float_stride;
-
-        const angle = floats[f + TUBE_ATTRIBUTE_ADDRESS_OFF] * TWO_PI;
-
-        const c = Math.cos(angle);
-        const s = Math.sin(angle);
-
-        const radius = floats[f + TUBE_ATTRIBUTE_ADDRESS_THICKNESS] * 0.5;
-
-        const nx = floats[f + TUBE_ATTRIBUTE_ADDRESS_NORMAL];
-        const ny = floats[f + TUBE_ATTRIBUTE_ADDRESS_NORMAL + 1];
-        const nz = floats[f + TUBE_ATTRIBUTE_ADDRESS_NORMAL + 2];
-
-        const bx = floats[f + TUBE_ATTRIBUTE_ADDRESS_BINORMAL];
-        const by = floats[f + TUBE_ATTRIBUTE_ADDRESS_BINORMAL + 1];
-        const bz = floats[f + TUBE_ATTRIBUTE_ADDRESS_BINORMAL + 2];
-
-        const p = i * 3;
-
-        positions[p] = floats[f + TUBE_ATTRIBUTE_ADDRESS_POSITION] + (c * nx + s * bx) * radius;
-        positions[p + 1] = floats[f + TUBE_ATTRIBUTE_ADDRESS_POSITION + 1] + (c * ny + s * by) * radius;
-        positions[p + 2] = floats[f + TUBE_ATTRIBUTE_ADDRESS_POSITION + 2] + (c * nz + s * bz) * radius;
-
-        const h = i * half_stride + color_offset;
-        const o = i * 4;
-
-        colors[o] = halves[h];
-        colors[o + 1] = halves[h + 1];
-        colors[o + 2] = halves[h + 2];
-        // half the optical depth: the face behind this one carries the other half
-        colors[o + 3] = 1 - Math.sqrt(1 - clamp01(floats[f + TUBE_ATTRIBUTE_ADDRESS_ALPHA]));
-    }
-
-    const source_indices = tube.indices;
-
-    const indices = geometry_obtain_index(geometry, source_indices.length);
-
-    indices.set(source_indices);
-
-    geometry.needsUpdate = true;
-}