@woosh/meep-engine 3.68.0 → 3.70.0

package/src/shade/renderer/wind/chunk_wind_field_sample_cascades.js

@@ -1,6 +1,7 @@
 import { chunk_clipmap_select_finest } from "../shader/chunk/clipmap/chunk_clipmap_select_finest.js";
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 import { WIND_FIELD_BAND_WIDTH, WIND_FIELD_CASCADE_LIMIT } from "./WIND_FIELD.js";
+import { chunk_fluid_turbulence } from "./chunk_fluid_turbulence.js";
 import { WIND_FIELD_STRUCT } from "./WIND_FIELD_STRUCT.js";
 
 /**
@@ -8,21 +9,24 @@ import { WIND_FIELD_STRUCT } from "./WIND_FIELD_STRUCT.js";
  * `chunk_wind_field_sample` links for a field as it is ({@link WIND_FIELD_UNIFORM} `false`), any
  * number of cascades, none included.
  *
- * Reads `wind_field` ({@link WIND_FIELD_STRUCT}), `wind_field_atlas` and `wind_field_sampler`, as
- * {@link wind_field_add_resources} declares them. `wind_field_sample_in(field, position_ws)` is the
+ * Reads `wind_field` ({@link WIND_FIELD_STRUCT}), `wind_field_atlas`, `wind_field_sampler` and the
+ * turbulence tile, as {@link wind_field_add_resources} declares them. `wind_field_sample_in(field, position_ws)` is the
  * same read through any table over that atlas, the previous frame's for one.
  *
  * **The read:**
  * - the cascades' windows are walked finest first, each by `clipmap_level_select`, and the first holding
  *   the point answers, with how far into its edge band of {@link WIND_FIELD_BAND_WIDTH} cells the point is;
- * - a cascade's read is the atmosphere identity, `v_far(t) + tap · k_c`: one trilinear tap of its tile,
- *   which holds `v − v_far(t_s,c)` at cell centres, times its decay;
+ * - the far field at the point, `v_far(t, p)`: its mean, plus its turbulence's one tap when it has any
+ *   (`wind_field_far`), band-limited inside a cascade to the cascade's cell, as the cascade's own far
+ *   field is, and whole beyond every cascade;
+ * - a cascade's read is the atmosphere identity, `v_far(t, p) + tap · k_c`: one trilinear tap of its
+ *   tile, which holds `v − v_far(t_s,c)` at cell centres, times its decay;
  * - in the band, a second read blends in linearly, all of it on the window's face: the parent's
- *   identity read, or `v_far(t)` for the coarsest; deeper than the band, one read;
- * - outside every cascade, `v_far(t)`.
+ *   identity read, or `v_far(t, p)` for the coarsest; deeper than the band, one read;
+ * - outside every cascade, `v_far(t, p)`.
  *
  * The blend and the decay are taken now, at the sample, so a cascade that last stepped ticks ago reads
- * the far field's current gust and drag. Air at the far field publishes a deviation of 0 and reads
+ * the far field's current mean, turbulence and drag. Air at the far field publishes a deviation of 0 and reads
  * back `v_far(t)` exactly, on every cascade, in every band, at every instant: the blend is written as
  * `inner + (outer − inner)·w`, which leaves equal reads as they are.
  *
@@ -46,10 +50,26 @@ export const chunk_wind_field_sample_cascades = CodeChunk.from(
     `
 const WIND_FIELD_BAND_WIDTH: f32 = ${WIND_FIELD_BAND_WIDTH}.0;
 
-// cascade c's identity read at a world point its window holds
+// the far field at a world point, band-limited to what a lattice of that cell holds: its mean, and its
+// turbulence there when it has any; a cell of 0 reads the tile whole
+fn wind_field_far(field: ptr<uniform, ${WIND_FIELD_STRUCT.wgsl_ref}>, position_ws: vec3<f32>, cell: f32) -> vec3<f32> {
+    let sigma = (*field).turbulence_sigma;
+
+    if (sigma == 0.0) {
+        return (*field).far_velocity;
+    }
+
+    let lod = fluid_turbulence_lod(cell, (*field).turbulence_inverse_texel);
+
+    return (*field).far_velocity + sigma * fluid_turbulence_at(position_ws * (*field).turbulence_scale + (*field).turbulence_origin, lod);
+}
+
+// cascade c's identity read at a world point its window holds: its far field at its own level, which is
+// what its tile is a deviation from
 fn wind_field_cascade_read(field: ptr<uniform, ${WIND_FIELD_STRUCT.wgsl_ref}>, c: u32, position_ws: vec3<f32>) -> vec3<f32> {
     let level = (*field).levels[c];
     let cascade = (*field).cascades[c];
+    let far = wind_field_far(field, position_ws, level.cell_size);
 
     // window-local position in the cascade's cells, which is a texel offset from the tile's content
     let local = position_ws / level.cell_size - vec3<f32>(level.corner);
@@ -57,7 +77,7 @@ fn wind_field_cascade_read(field: ptr<uniform, ${WIND_FIELD_STRUCT.wgsl_ref}>, c
 
     let deviation = textureSampleLevel(wind_field_atlas, wind_field_sampler, uvw, 0.0).xyz;
 
-    return (*field).far_velocity + deviation * cascade.decay;
+    return far + deviation * cascade.decay;
 }
 
 fn wind_field_sample_in(field: ptr<uniform, ${WIND_FIELD_STRUCT.wgsl_ref}>, position_ws: vec3<f32>) -> vec3<f32> {
@@ -75,7 +95,7 @@ fn wind_field_sample_in(field: ptr<uniform, ${WIND_FIELD_STRUCT.wgsl_ref}>, posi
     }
 
     if (selection.level == CLIPMAP_LEVEL_NONE) {
-        return (*field).far_velocity;
+        return wind_field_far(field, position_ws, 0.0);
     }
 
     let inner = wind_field_cascade_read(field, selection.level, position_ws);
@@ -86,10 +106,12 @@ fn wind_field_sample_in(field: ptr<uniform, ${WIND_FIELD_STRUCT.wgsl_ref}>, posi
 
     let parent = selection.level + 1u;
 
-    var outer = (*field).far_velocity;
+    var outer: vec3<f32>;
 
     if (parent < count) {
         outer = wind_field_cascade_read(field, parent, position_ws);
+    } else {
+        outer = wind_field_far(field, position_ws, 0.0);
     }
 
     // mix's form, written so that equal reads blend to themselves exactly
@@ -102,5 +124,6 @@ fn wind_field_sample(position_ws: vec3<f32>) -> vec3<f32> {
 `, [
         WIND_FIELD_STRUCT.declaration_chunk,
         chunk_clipmap_select_finest,
+        chunk_fluid_turbulence,
     ]
 );

package/src/shade/renderer/wind/chunk_wind_field_sample_uniform.d.ts

@@ -1,7 +1,7 @@
 /**
  * `wind_field_sample(position_ws)` in a uniform field ({@link WIND_FIELD_UNIFORM} `true`): one with no
- * cascades, where the wind is `v_far(t)` at every point, which is what the cascaded read returns there,
- * exactly, having found no window that holds the point.
+ * cascades and no turbulence, where the wind is `v_far(t)` at every point, which is what the cascaded
+ * read returns there, exactly, having found no window that holds the point.
  *
  * Reads `wind_field.far_velocity` and nothing else; the atlas and its sampler stay bound and unread.
  * `wind_field_sample_in(field, position_ws)` is the same read of any table with no cascades.

package/src/shade/renderer/wind/chunk_wind_field_sample_uniform.js

@@ -3,8 +3,8 @@ import { WIND_FIELD_STRUCT } from "./WIND_FIELD_STRUCT.js";
 
 /**
  * `wind_field_sample(position_ws)` in a uniform field ({@link WIND_FIELD_UNIFORM} `true`): one with no
- * cascades, where the wind is `v_far(t)` at every point, which is what the cascaded read returns there,
- * exactly, having found no window that holds the point.
+ * cascades and no turbulence, where the wind is `v_far(t)` at every point, which is what the cascaded
+ * read returns there, exactly, having found no window that holds the point.
  *
  * Reads `wind_field.far_velocity` and nothing else; the atlas and its sampler stay bound and unread.
  * `wind_field_sample_in(field, position_ws)` is the same read of any table with no cascades.

package/src/shade/renderer/wind/wind_field_add_resources.d.ts

@@ -3,10 +3,12 @@
  * `chunk_wind_field_sample` reads:
  * - `wind_field`: the uniform {@link WIND_FIELD_STRUCT};
  * - `wind_field_atlas`: the tiles, `texture_3d<f32>`, filterable;
- * - `wind_field_sampler`: linear and clamped, by default the field's own, so a host binds only the
- *   other two (`GPUSceneWind.bind`).
+ * - `wind_field_sampler`: linear and clamped, by default the field's own;
+ * - `fluid_turbulence`, `fluid_turbulence_sampler`: the far field's turbulence tile and its repeating
+ *   sampler (`fluid_turbulence_add_resources`), the sampler by default.
  *
- * One uniform, one texture, one sampler, and no storage buffer.
+ * A host binds the uniform and the two textures (`GPUSceneWind.bind`). One uniform, two textures, two
+ * samplers, and no storage buffer.
  *
  * @param {import("../shader/resource/ShaderResourceGroupDescriptor.js").ShaderResourceGroupDescriptor} group
  * @returns {import("../shader/resource/ShaderResourceGroupDescriptor.js").ShaderResourceGroupDescriptor} group
@@ -17,7 +19,7 @@ export function wind_field_add_resources(group: import("../shader/resource/Shade
  * samples both (`chunk_wind_field_sample_previous`): `wind_field_previous`, a second uniform
  * {@link WIND_FIELD_STRUCT} over the same atlas. `GPUSceneWind.bind_history` fills them.
  *
- * Two uniforms, one texture, one sampler, and no storage buffer.
+ * Two uniforms, two textures, two samplers, and no storage buffer.
  *
  * @param {import("../shader/resource/ShaderResourceGroupDescriptor.js").ShaderResourceGroupDescriptor} group
  * @returns {import("../shader/resource/ShaderResourceGroupDescriptor.js").ShaderResourceGroupDescriptor} group

package/src/shade/renderer/wind/wind_field_add_resources.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wind_field_add_resources.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/wind/wind_field_add_resources.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AACH,gDAHW,OAAO,qDAAqD,EAAE,6BAA6B,GACzF,OAAO,qDAAqD,EAAE,6BAA6B,CAOvG;AAED;;;;;;;;;GASG;AACH,wDAHW,OAAO,qDAAqD,EAAE,6BAA6B,GACzF,OAAO,qDAAqD,EAAE,6BAA6B,CAKvG"}
+{"version":3,"file":"wind_field_add_resources.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/wind/wind_field_add_resources.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;GAcG;AACH,gDAHW,OAAO,qDAAqD,EAAE,6BAA6B,GACzF,OAAO,qDAAqD,EAAE,6BAA6B,CAOvG;AAED;;;;;;;;;GASG;AACH,wDAHW,OAAO,qDAAqD,EAAE,6BAA6B,GACzF,OAAO,qDAAqD,EAAE,6BAA6B,CAKvG"}

package/src/shade/renderer/wind/wind_field_add_resources.js

@@ -1,3 +1,4 @@
+import { fluid_turbulence_add_resources } from "./chunk_fluid_turbulence.js";
 import { WIND_FIELD_SAMPLER_DESCRIPTOR } from "./WIND_FIELD.js";
 import { WIND_FIELD_STRUCT } from "./WIND_FIELD_STRUCT.js";
 
@@ -6,19 +7,21 @@ import { WIND_FIELD_STRUCT } from "./WIND_FIELD_STRUCT.js";
  * `chunk_wind_field_sample` reads:
  * - `wind_field`: the uniform {@link WIND_FIELD_STRUCT};
  * - `wind_field_atlas`: the tiles, `texture_3d<f32>`, filterable;
- * - `wind_field_sampler`: linear and clamped, by default the field's own, so a host binds only the
- *   other two (`GPUSceneWind.bind`).
+ * - `wind_field_sampler`: linear and clamped, by default the field's own;
+ * - `fluid_turbulence`, `fluid_turbulence_sampler`: the far field's turbulence tile and its repeating
+ *   sampler (`fluid_turbulence_add_resources`), the sampler by default.
  *
- * One uniform, one texture, one sampler, and no storage buffer.
+ * A host binds the uniform and the two textures (`GPUSceneWind.bind`). One uniform, two textures, two
+ * samplers, and no storage buffer.
  *
  * @param {import("../shader/resource/ShaderResourceGroupDescriptor.js").ShaderResourceGroupDescriptor} group
  * @returns {import("../shader/resource/ShaderResourceGroupDescriptor.js").ShaderResourceGroupDescriptor} group
  */
 export function wind_field_add_resources(group) {
-    return group
+    return fluid_turbulence_add_resources(group
         .addUniform("wind_field", WIND_FIELD_STRUCT)
         .addTexture("wind_field_atlas", "float", "3d")
-        .addSampler("wind_field_sampler", "filtering", WIND_FIELD_SAMPLER_DESCRIPTOR);
+        .addSampler("wind_field_sampler", "filtering", WIND_FIELD_SAMPLER_DESCRIPTOR));
 }
 
 /**
@@ -26,7 +29,7 @@ export function wind_field_add_resources(group) {
  * samples both (`chunk_wind_field_sample_previous`): `wind_field_previous`, a second uniform
  * {@link WIND_FIELD_STRUCT} over the same atlas. `GPUSceneWind.bind_history` fills them.
  *
- * Two uniforms, one texture, one sampler, and no storage buffer.
+ * Two uniforms, two textures, two samplers, and no storage buffer.
  *
  * @param {import("../shader/resource/ShaderResourceGroupDescriptor.js").ShaderResourceGroupDescriptor} group
  * @returns {import("../shader/resource/ShaderResourceGroupDescriptor.js").ShaderResourceGroupDescriptor} group

package/src/engine/graphics/ecs/trail3d/advance_trail.d.ts

@@ -1,18 +0,0 @@
-/**
- * Age a trail by one frame and put its head where the entity is.
- *
- * **Renderer-neutral**, like {@link seed_trail_tube}: what a backend does afterwards is turn the
- * knots into vertices, and the knots themselves are the same either way.
- *
- * {@link Trail3DFlags.BoundsNeedUpdate} is left set for the caller, because what wants bounds
- * differs by renderer — the legacy path keeps a CPU BVH of trails and Shade culls on the GPU.
- *
- * @param {Trail3D} trail
- * @param {Transform} transform
- * @param {number} timeDelta seconds
- * @param {TubeXFixedPhysicsSimulator} simulator ages the knots and fades them; stateless, so whose
- * it is does not matter, only that the caller owns one
- * @returns {void}
- */
-export function advance_trail(trail: Trail3D, transform: Transform, timeDelta: number, simulator: TubeXFixedPhysicsSimulator): void;
-//# sourceMappingURL=advance_trail.d.ts.map

package/src/engine/graphics/ecs/trail3d/advance_trail.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"advance_trail.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/trail3d/advance_trail.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;GAeG;AACH,+EALW,MAAM,0CAGJ,IAAI,CAiBhB"}

package/src/engine/graphics/ecs/trail3d/advance_trail.js

@@ -1,42 +0,0 @@
-import Vector3 from "../../../../core/geom/Vector3.js";
-import { max2 } from "../../../../core/math/max2.js";
-import { compute_trail_head_position } from "./trail_head_position.js";
-import { Trail3DFlags } from "./Trail3DFlags.js";
-
-/**
- * @type {Vector3}
- */
-const v3_head = new Vector3();
-
-/**
- * Age a trail by one frame and put its head where the entity is.
- *
- * **Renderer-neutral**, like {@link seed_trail_tube}: what a backend does afterwards is turn the
- * knots into vertices, and the knots themselves are the same either way.
- *
- * {@link Trail3DFlags.BoundsNeedUpdate} is left set for the caller, because what wants bounds
- * differs by renderer — the legacy path keeps a CPU BVH of trails and Shade culls on the GPU.
- *
- * @param {Trail3D} trail
- * @param {Transform} transform
- * @param {number} timeDelta seconds
- * @param {TubeXFixedPhysicsSimulator} simulator ages the knots and fades them; stateless, so whose
- * it is does not matter, only that the caller owns one
- * @returns {void}
- */
-export function advance_trail(trail, transform, timeDelta, simulator) {
-    const tube = trail.tube;
-
-    compute_trail_head_position(v3_head, trail, transform);
-
-    trail.timeSinceLastUpdate += timeDelta;
-    trail.time += timeDelta;
-
-    const age_offset = max2(0, trail.maxAge - trail.time);
-
-    simulator.update(tube, trail.maxAge, timeDelta, trail.color.w, trail.fade);
-
-    if (trail.getFlag(Trail3DFlags.Spawning)) {
-        trail.updateHead(v3_head.x, v3_head.y, v3_head.z, age_offset);
-    }
-}

package/src/engine/graphics/ecs/trail3d/seed_trail_tube.d.ts

@@ -1,14 +0,0 @@
-/**
- * Build a trail's knots and collapse them onto the head, ready to be drawn by whichever renderer
- * owns the entity.
- *
- * **Renderer-neutral on purpose.** A trail is a simulation with a picture attached, and the
- * simulation is the same one under either backend — what differs is only what the knots are turned
- * into. Two copies of this would be two trails that age differently.
- *
- * @param {Trail3D} trail
- * @param {Transform} transform
- * @returns {void}
- */
-export function seed_trail_tube(trail: Trail3D, transform: Transform): void;
-//# sourceMappingURL=seed_trail_tube.d.ts.map

package/src/engine/graphics/ecs/trail3d/seed_trail_tube.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"seed_trail_tube.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/trail3d/seed_trail_tube.js"],"names":[],"mappings":"AAwBA;;;;;;;;;;;GAWG;AACH,uEAFa,IAAI,CAwChB"}

package/src/engine/graphics/ecs/trail3d/seed_trail_tube.js

@@ -1,75 +0,0 @@
-import Vector3 from "../../../../core/geom/Vector3.js";
-import { clamp } from "../../../../core/math/clamp.js";
-import { TUBE_ATTRIBUTE_ADDRESS_AGE, TUBE_ATTRIBUTE_ADDRESS_UV_V } from "../../trail/tube/tube_attributes_spec.js";
-import { compute_trail_head_position } from "./trail_head_position.js";
-import { Trail3DFlags } from "./Trail3DFlags.js";
-
-/**
- * Knots laid down per second of trail life. The tube is a fixed-capacity ring, so this is what
- * turns an age into a length.
- *
- * @type {number}
- */
-const SEGMENTS_PER_SECOND = 60;
-
-/**
- * @type {number}
- */
-const MAX_SEGMENTS = 1024;
-
-/**
- * @type {Vector3}
- */
-const v3_head = new Vector3();
-
-/**
- * Build a trail's knots and collapse them onto the head, ready to be drawn by whichever renderer
- * owns the entity.
- *
- * **Renderer-neutral on purpose.** A trail is a simulation with a picture attached, and the
- * simulation is the same one under either backend — what differs is only what the knots are turned
- * into. Two copies of this would be two trails that age differently.
- *
- * @param {Trail3D} trail
- * @param {Transform} transform
- * @returns {void}
- */
-export function seed_trail_tube(trail, transform) {
-    const segment_count = Math.ceil(clamp(trail.maxAge * SEGMENTS_PER_SECOND, 2, MAX_SEGMENTS));
-
-    trail.build(segment_count);
-
-    const tube = trail.tube;
-
-    trail.time = 0;
-    trail.trailingIndex = 0;
-    trail.timeSinceLastUpdate = 0;
-    trail.distanceSinceLastUpdate = 0;
-
-    // seed exactly where the per-frame update will place the head, or the first head move bridges
-    // the gap with a visible segment
-    compute_trail_head_position(v3_head, trail, transform);
-
-    const position_x = v3_head.x;
-    const position_y = v3_head.y;
-    const position_z = v3_head.z;
-
-    const color = trail.color;
-
-    // initialize knots. setCount has already seeded a valid default frame on every knot, so the
-    // freshly built (collapsed) tube is well-formed — a zero-length, invisible point — until the
-    // head starts moving and supplies real tangents.
-    for (let i = 0; i < segment_count; i++) {
-        const f = i / (segment_count - 1);
-
-        tube.setKnotColor(i, color.x, color.y, color.z);
-        tube.setKnotPosition(i, position_x, position_y, position_z);
-        tube.setKnotThickness(i, trail.width);
-        tube.setKnotAttribute_Scalar(i, TUBE_ATTRIBUTE_ADDRESS_UV_V, f);
-        // seeded age = maxAge means "already expired", so alpha follows the fade law: 0
-        tube.setKnotAlpha(i, 0);
-        tube.setKnotAttribute_Scalar(i, TUBE_ATTRIBUTE_ADDRESS_AGE, trail.maxAge);
-    }
-
-    trail.setFlag(Trail3DFlags.Built);
-}

package/src/engine/graphics/ecs/trail3d/trail_head_position.d.ts

@@ -1,17 +0,0 @@
-/**
- * World point the trail's head tracks: the component's {@link Trail3D#offset}, which lives in the
- * entity's LOCAL frame, carried through the entity's full transform — so it rides the entity's
- * rotation and scales with it.
- *
- * Seeding and the per-frame head update must agree on this, whichever renderer is drawing. If they
- * disagree, the freshly built tube sits collapsed somewhere the head never visits, and the head's
- * first move draws a segment bridging the two — a one-frame streak as long as the disagreement, in
- * a direction fixed by the offset rather than by travel.
- *
- * @param {Vector3} result
- * @param {Trail3D} trail
- * @param {Transform} transform
- * @returns {void}
- */
-export function compute_trail_head_position(result: Vector3, trail: Trail3D, transform: Transform): void;
-//# sourceMappingURL=trail_head_position.d.ts.map

package/src/engine/graphics/ecs/trail3d/trail_head_position.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"trail_head_position.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/trail3d/trail_head_position.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,oGAFa,IAAI,CAKhB"}

package/src/engine/graphics/ecs/trail3d/trail_head_position.js

@@ -1,19 +0,0 @@
-/**
- * World point the trail's head tracks: the component's {@link Trail3D#offset}, which lives in the
- * entity's LOCAL frame, carried through the entity's full transform — so it rides the entity's
- * rotation and scales with it.
- *
- * Seeding and the per-frame head update must agree on this, whichever renderer is drawing. If they
- * disagree, the freshly built tube sits collapsed somewhere the head never visits, and the head's
- * first move draws a segment bridging the two — a one-frame streak as long as the disagreement, in
- * a direction fixed by the offset rather than by travel.
- *
- * @param {Vector3} result
- * @param {Trail3D} trail
- * @param {Transform} transform
- * @returns {void}
- */
-export function compute_trail_head_position(result, trail, transform) {
-    result.copy(trail.offset);
-    result.applyMatrix4(transform.matrix);
-}

package/src/engine/graphics/trail/tube/TubeX.d.ts

@@ -1,186 +0,0 @@
-/**
- * Dynamic, non-allocating 3D tube geometry — the volumetric analogue of
- * {@link RibbonX}.
- *
- * A tube is a ring buffer of `count` KNOTS along a centre-line. Each knot owns a
- * ring of `radial + 1` vertices: the extra vertex duplicates vertex 0 so the UV
- * seam (u = 0 meeting u = 1) closes cleanly when the texture wraps the tube.
- * Vertices are extruded in the vertex shader from the knot's stored tangent
- * frame, so the CPU only ever writes per-knot data (centre, frame, colour, …) —
- * never per-triangle.
- *
- * Like {@link RibbonX} the geometry is a fixed-capacity ring: {@link rotate}
- * recycles the oldest knot as the new head and rewrites a single segment's worth
- * of indices, so steady-state updates allocate nothing.
- *
- * **The knots are the tube; a drawable is what a renderer makes of them.** Nothing
- * here belongs to a renderer: {@link TubeXGeometry} wraps this data in three
- * attribute views for the legacy path, and the Shade path extrudes the same rows
- * into dynamic-mesh vertices. The three versions below are what tells either one
- * that its copy is stale.
- */
-export class TubeX {
-    /**
-     * The knot rows, interleaved per {@link tube_attributes_spec} — `vertex_count`
-     * records of `bytes_per_vertex` bytes, one per ring vertex.
-     *
-     * @returns {RowFirstTable}
-     */
-    get table(): RowFirstTable;
-    /**
-     * Triangle indices over the ring vertices, sized by {@link setCount} and
-     * rewritten one segment at a time by {@link rotate}.
-     *
-     * @returns {Uint32Array}
-     */
-    get indices(): Uint32Array;
-    /**
-     * @returns {number} bytes one ring vertex occupies in {@link table}
-     */
-    get bytes_per_vertex(): number;
-    /**
-     * @returns {number} ring vertices across the whole tube — `count * (radial + 1)`
-     */
-    get vertex_count(): number;
-    /**
-     * @returns {number}
-     */
-    get data_version(): number;
-    /**
-     * @returns {number}
-     */
-    get index_version(): number;
-    /**
-     * @returns {number}
-     */
-    get layout_version(): number;
-    /**
-     * @returns {number} number of knots
-     */
-    getCount(): number;
-    /**
-     * @returns {number} radial subdivisions
-     */
-    getRadialSegments(): number;
-    getHeadIndex(): number;
-    getTailIndex(): number;
-    /**
-     * @param {number[]|Float32Array|Float64Array} result
-     * @param {number} knot_index
-     */
-    getKnotPosition(result: number[] | Float32Array | Float64Array, knot_index: number): void;
-    /**
-     * Read the stored ring normal of a knot. Used by the head to parallel-transport
-     * its frame from the previous knot.
-     * @param {number[]|Float32Array|Float64Array} result
-     * @param {number} knot_index
-     */
-    getKnotNormal(result: number[] | Float32Array | Float64Array, knot_index: number): void;
-    /**
-     * Read the stored ring binormal of a knot.
-     * @param {number[]|Float32Array|Float64Array} result
-     * @param {number} knot_index
-     */
-    getKnotBinormal(result: number[] | Float32Array | Float64Array, knot_index: number): void;
-    /**
-     * Read a scalar attribute of a knot. Every vertex of the ring carries the same
-     * value, so the first one answers for the knot.
-     *
-     * @param {number} knot_index
-     * @param {number} attribute_index
-     * @returns {number}
-     */
-    getKnotAttribute_Scalar(knot_index: number, attribute_index: number): number;
-    /**
-     * Write a vec3 attribute to all ring vertices of a knot.
-     * @param {number} knot_index
-     * @param {number} attribute_index
-     * @param {number} x
-     * @param {number} y
-     * @param {number} z
-     */
-    setKnotAttribute_Vector3(knot_index: number, attribute_index: number, x: number, y: number, z: number): void;
-    /**
-     * Write a scalar attribute to all ring vertices of a knot.
-     * @param {number} knot_index
-     * @param {number} attribute_index
-     * @param {number} value
-     */
-    setKnotAttribute_Scalar(knot_index: number, attribute_index: number, value: number): void;
-    /**
-     * Add `delta` to a scalar attribute on every ring vertex of a knot.
-     * @param {number} knot_index
-     * @param {number} attribute_index
-     * @param {number} delta
-     * @returns {number} incremented value
-     */
-    incrementKnotAttribute_Scalar(knot_index: number, attribute_index: number, delta: number): number;
-    /**
-     * @param {number} knot_index
-     * @param {number} x
-     * @param {number} y
-     * @param {number} z
-     */
-    setKnotPosition(knot_index: number, x: number, y: number, z: number): void;
-    /**
-     * Set the orienting tangent frame of a knot. `nx,ny,nz` and `bx,by,bz` must be
-     * unit vectors, mutually orthogonal and perpendicular to the local tangent.
-     * @param {number} knot_index
-     * @param {number} nx
-     * @param {number} ny
-     * @param {number} nz
-     * @param {number} bx
-     * @param {number} by
-     * @param {number} bz
-     */
-    setKnotFrame(knot_index: number, nx: number, ny: number, nz: number, bx: number, by: number, bz: number): void;
-    /**
-     * Linear colour, stored at half precision. Not limited to 0..1: values above 1 are HDR.
-     *
-     * @param {number} knot_index
-     * @param {number} r
-     * @param {number} g
-     * @param {number} b
-     */
-    setKnotColor(knot_index: number, r: number, g: number, b: number): void;
-    /**
-     * @param {number} knot_index
-     * @param {number} value
-     */
-    setKnotAlpha(knot_index: number, value: number): void;
-    /**
-     * @param {number} knot_index
-     * @param {number} value tube diameter
-     */
-    setKnotThickness(knot_index: number, value: number): void;
-    /**
-     * @param {number} count number of knots (>= 2)
-     * @param {number} [radial] radial subdivisions (>= 3)
-     */
-    setCount(count: number, radial?: number): void;
-    /**
-     * NOTE: takes tube thickness into account.
-     * @param {AABB3|ArrayLike<number>} result
-     */
-    computeBoundingBox(result: AABB3 | ArrayLike<number>): void;
-    /**
-     * Recycle the oldest knot as the new head, in O(radial). Mirrors
-     * {@link RibbonX#rotate}: the head/tail pointers decrement together (preserving
-     * `head === (tail + 1) mod count`), and the single tail segment's indices are
-     * rewritten to bridge the previous head's ring to the recycled (new head) ring.
-     */
-    rotate(): void;
-    #private;
-}
-export namespace TubeX {
-    export { DEFAULT_RADIAL_SEGMENTS };
-}
-import { RowFirstTable } from "../../../../core/collection/table/RowFirstTable.js";
-/**
- * Default number of radial subdivisions around the tube. Overridable per-tube
- * via {@link TubeX#setCount}; never hard-coded into the geometry.
- * @type {number}
- */
-declare const DEFAULT_RADIAL_SEGMENTS: number;
-export {};
-//# sourceMappingURL=TubeX.d.ts.map

package/src/engine/graphics/trail/tube/TubeX.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"TubeX.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/trail/tube/TubeX.js"],"names":[],"mappings":"AA+BA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAoEI;;;;;OAKG;IACH,2BAEC;IAED;;;;;OAKG;IACH,2BAEC;IAED;;OAEG;IACH,+BAEC;IAED;;OAEG;IACH,2BAEC;IAED;;OAEG;IACH,2BAEC;IAED;;OAEG;IACH,4BAEC;IAED;;OAEG;IACH,6BAEC;IAED;;OAEG;IACH,YAFa,MAAM,CAIlB;IAED;;OAEG;IACH,qBAFa,MAAM,CAIlB;IAED,uBAEC;IAED,uBAEC;IAiGD;;;OAGG;IACH,wBAHW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,QAShB;IAED;;;;;OAKG;IACH,sBAHW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,QAShB;IAED;;;;OAIG;IACH,wBAHW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,QAShB;IAED;;;;;;;OAOG;IACH,oCAJW,MAAM,mBACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;OAOG;IACH,qCANW,MAAM,mBACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAehB;IAED;;;;;OAKG;IACH,oCAJW,MAAM,mBACN,MAAM,SACN,MAAM,QAYhB;IAED;;;;;;OAMG;IACH,0CALW,MAAM,mBACN,MAAM,SACN,MAAM,GACJ,MAAM,CAgBlB;IAED;;;;;OAKG;IACH,4BALW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAMhB;IAED;;;;;;;;;;OAUG;IACH,yBARW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAKhB;IAED;;;;;;;OAOG;IACH,yBALW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAMhB;IAED;;;OAGG;IACH,yBAHW,MAAM,SACN,MAAM,QAIhB;IAED;;;OAGG;IACH,6BAHW,MAAM,SACN,MAAM,QAIhB;IAED;;;OAGG;IACH,gBAHW,MAAM,WACN,MAAM,QAuChB;IAED;;;OAGG;IACH,2BAFW,QAAM,UAAU,MAAM,CAAC,QA4BjC;IAED;;;;;OAKG;IACH,eAsBC;;CACJ;;;;8BA3jB6B,oDAAoD;AAgBlF;;;;GAIG;AACH,uCAFU,MAAM,CAEkB"}