@woosh/meep-engine 3.68.0 → 3.70.0

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

@@ -1,575 +0,0 @@
-import { assert } from "../../../../core/assert.js";
-import { RowFirstTable } from "../../../../core/collection/table/RowFirstTable.js";
-import { aabb3_array_set } from "../../../../core/geom/3d/aabb/aabb3_array_set.js";
-import { v3_orthonormal_matrix_from_normal } from "../../../../core/geom/vec3/v3_orthonormal_matrix_from_normal.js";
-import { max2 } from "../../../../core/math/max2.js";
-import { min2 } from "../../../../core/math/min2.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,
-    tube_attributes_spec
-} from "./tube_attributes_spec.js";
-
-/**
- * Default number of radial subdivisions around the tube. Overridable per-tube
- * via {@link TubeX#setCount}; never hard-coded into the geometry.
- * @type {number}
- */
-const DEFAULT_RADIAL_SEGMENTS = 8;
-
-/**
- * Scratch for the arbitrary default frame written at build time; module-static so
- * setCount stays allocation-free on the data path.
- * @type {Float64Array}
- */
-const m3_default_frame = new Float64Array(9);
-
-/**
- * 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 {
-
-    /**
-     * @type {RowFirstTable}
-     */
-    #data = new RowFirstTable(tube_attributes_spec);
-
-    /**
-     * @type {Uint32Array}
-     */
-    #indices = new Uint32Array(0);
-
-    /**
-     * Bumped by every write to knot data. A consumer that has copied or uploaded the
-     * rows compares its own against this to know whether it still holds the truth.
-     *
-     * @type {number}
-     */
-    #data_version = 0;
-
-    /**
-     * Bumped by every write to the index array, which after the build is
-     * {@link rotate} and nothing else.
-     *
-     * @type {number}
-     */
-    #index_version = 0;
-
-    /**
-     * Bumped by {@link setCount}, which is the only thing that moves the buffers
-     * themselves rather than their contents — a consumer holding views over them
-     * has to build new ones.
-     *
-     * @type {number}
-     */
-    #layout_version = 0;
-
-    /**
-     * Knot index at the END (oldest) of the tube.
-     * @type {number}
-     */
-    #tail_index = 0;
-
-    /**
-     * Knot index at the START (newest) of the tube.
-     * @type {number}
-     */
-    #head_index = 0;
-
-    /**
-     * Index of the segment (knot-to-knot span of `radial` quads) currently at the
-     * tail; recycled by {@link rotate}.
-     * @type {number}
-     */
-    #tail_segment_index = 0;
-
-    /**
-     * Number of knots.
-     * @type {number}
-     */
-    #count = 0;
-
-    /**
-     * Number of radial subdivisions. Ring vertex count per knot = radial + 1.
-     * @type {number}
-     */
-    #radial = DEFAULT_RADIAL_SEGMENTS;
-
-    /**
-     * 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() {
-        return this.#data;
-    }
-
-    /**
-     * Triangle indices over the ring vertices, sized by {@link setCount} and
-     * rewritten one segment at a time by {@link rotate}.
-     *
-     * @returns {Uint32Array}
-     */
-    get indices() {
-        return this.#indices;
-    }
-
-    /**
-     * @returns {number} bytes one ring vertex occupies in {@link table}
-     */
-    get bytes_per_vertex() {
-        return this.#data.spec.bytesPerRecord;
-    }
-
-    /**
-     * @returns {number} ring vertices across the whole tube — `count * (radial + 1)`
-     */
-    get vertex_count() {
-        return this.#count * this.#ring_vertex_count;
-    }
-
-    /**
-     * @returns {number}
-     */
-    get data_version() {
-        return this.#data_version;
-    }
-
-    /**
-     * @returns {number}
-     */
-    get index_version() {
-        return this.#index_version;
-    }
-
-    /**
-     * @returns {number}
-     */
-    get layout_version() {
-        return this.#layout_version;
-    }
-
-    /**
-     * @returns {number} number of knots
-     */
-    getCount() {
-        return this.#count;
-    }
-
-    /**
-     * @returns {number} radial subdivisions
-     */
-    getRadialSegments() {
-        return this.#radial;
-    }
-
-    getHeadIndex() {
-        return this.#head_index;
-    }
-
-    getTailIndex() {
-        return this.#tail_index;
-    }
-
-    /**
-     * Number of vertices in a single knot ring (includes the duplicated seam vertex).
-     * @returns {number}
-     */
-    get #ring_vertex_count() {
-        return this.#radial + 1;
-    }
-
-    /**
-     * Write the static angular `off` coordinate (uv.x) for every ring vertex. The
-     * value goes 0 → 1 across the `radial + 1` vertices; vertex `radial` lands on
-     * 1.0 so its shader angle is 2π — co-incident with vertex 0's angle 0, closing
-     * the seam without a wrap-around index.
-     */
-    #initialize_off() {
-        const data = this.#data;
-        const count = this.#count;
-        const radial = this.#radial;
-        const v = this.#ring_vertex_count;
-
-        for (let k = 0; k < count; k++) {
-            const base = k * v;
-            for (let j = 0; j <= radial; j++) {
-                data.writeCellValue(base + j, TUBE_ATTRIBUTE_ADDRESS_OFF, j / radial);
-            }
-        }
-    }
-
-    /**
-     * Seed every knot with a valid (arbitrary) orthonormal frame so the geometry is
-     * well-formed from the moment it is built, before any head movement supplies a
-     * real tangent. Without this the frames would be zero-initialised and the
-     * transport's degeneracy fallback would have to cover the fresh-tube case; a
-     * concrete default keeps the invariant "every knot frame is unit + orthonormal"
-     * unconditionally true (read e.g. by getKnotNormal during transport).
-     */
-    #initialize_frame() {
-        v3_orthonormal_matrix_from_normal(m3_default_frame, 0, 0, 1, 0);
-
-        const nx = m3_default_frame[0], ny = m3_default_frame[1], nz = m3_default_frame[2];
-        const bx = m3_default_frame[3], by = m3_default_frame[4], bz = m3_default_frame[5];
-
-        const count = this.#count;
-
-        for (let k = 0; k < count; k++) {
-            this.setKnotFrame(k, nx, ny, nz, bx, by, bz);
-        }
-    }
-
-    /**
-     * Write the `radial` quads (2 triangles each) bridging the ring of knot `lo`
-     * to the ring of knot `hi`, starting at `address` in the index array.
-     * Winding matches the engine's static tube mesher (make_ring_faces).
-     * @param {number} address index-array offset (in index entries)
-     * @param {number} lo knot index whose ring is the "left" edge
-     * @param {number} hi knot index whose ring is the "right" edge
-     */
-    #write_segment_indices(address, lo, hi) {
-        const indices = this.#indices;
-        const radial = this.#radial;
-        const v = this.#ring_vertex_count;
-
-        const lo_base = lo * v;
-        const hi_base = hi * v;
-
-        for (let r = 0; r < radial; r++) {
-            const a = lo_base + r;
-            const b = hi_base + r;
-            const c = hi_base + r + 1;
-            const d = lo_base + r + 1;
-
-            const ci = address + r * 6;
-
-            indices[ci] = a;
-            indices[ci + 1] = b;
-            indices[ci + 2] = d;
-
-            indices[ci + 3] = b;
-            indices[ci + 4] = c;
-            indices[ci + 5] = d;
-        }
-    }
-
-    /**
-     * Build the index buffer as a linear strip of `count - 1` segments.
-     */
-    #initialize_index() {
-        const segment_count = this.#count - 1;
-        const indices_per_segment = this.#radial * 6;
-
-        for (let s = 0; s < segment_count; s++) {
-            this.#write_segment_indices(s * indices_per_segment, s, s + 1);
-        }
-    }
-
-    /**
-     * @param {number[]|Float32Array|Float64Array} result
-     * @param {number} knot_index
-     */
-    getKnotPosition(result, knot_index) {
-        const row = knot_index * this.#ring_vertex_count;
-        const data = this.#data;
-
-        result[0] = data.readCellValue(row, TUBE_ATTRIBUTE_ADDRESS_POSITION);
-        result[1] = data.readCellValue(row, TUBE_ATTRIBUTE_ADDRESS_POSITION + 1);
-        result[2] = data.readCellValue(row, TUBE_ATTRIBUTE_ADDRESS_POSITION + 2);
-    }
-
-    /**
-     * 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, knot_index) {
-        const row = knot_index * this.#ring_vertex_count;
-        const data = this.#data;
-
-        result[0] = data.readCellValue(row, TUBE_ATTRIBUTE_ADDRESS_NORMAL);
-        result[1] = data.readCellValue(row, TUBE_ATTRIBUTE_ADDRESS_NORMAL + 1);
-        result[2] = data.readCellValue(row, TUBE_ATTRIBUTE_ADDRESS_NORMAL + 2);
-    }
-
-    /**
-     * Read the stored ring binormal of a knot.
-     * @param {number[]|Float32Array|Float64Array} result
-     * @param {number} knot_index
-     */
-    getKnotBinormal(result, knot_index) {
-        const row = knot_index * this.#ring_vertex_count;
-        const data = this.#data;
-
-        result[0] = data.readCellValue(row, TUBE_ATTRIBUTE_ADDRESS_BINORMAL);
-        result[1] = data.readCellValue(row, TUBE_ATTRIBUTE_ADDRESS_BINORMAL + 1);
-        result[2] = data.readCellValue(row, TUBE_ATTRIBUTE_ADDRESS_BINORMAL + 2);
-    }
-
-    /**
-     * 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, attribute_index) {
-        return this.#data.readCellValue(knot_index * this.#ring_vertex_count, attribute_index);
-    }
-
-    /**
-     * 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, attribute_index, x, y, z) {
-        const data = this.#data;
-        const v = this.#ring_vertex_count;
-        const base = knot_index * v;
-
-        for (let j = 0; j < v; j++) {
-            const row = base + j;
-            data.writeCellValue(row, attribute_index, x);
-            data.writeCellValue(row, attribute_index + 1, y);
-            data.writeCellValue(row, attribute_index + 2, z);
-        }
-
-        this.#data_version++;
-    }
-
-    /**
-     * 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, attribute_index, value) {
-        const data = this.#data;
-        const v = this.#ring_vertex_count;
-        const base = knot_index * v;
-
-        for (let j = 0; j < v; j++) {
-            data.writeCellValue(base + j, attribute_index, value);
-        }
-
-        this.#data_version++;
-    }
-
-    /**
-     * 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, attribute_index, delta) {
-        const data = this.#data;
-        const v = this.#ring_vertex_count;
-        const base = knot_index * v;
-
-        const value = data.readCellValue(base, attribute_index) + delta;
-
-        for (let j = 0; j < v; j++) {
-            data.writeCellValue(base + j, attribute_index, value);
-        }
-
-        this.#data_version++;
-
-        return value;
-    }
-
-    /**
-     * @param {number} knot_index
-     * @param {number} x
-     * @param {number} y
-     * @param {number} z
-     */
-    setKnotPosition(knot_index, x, y, z) {
-        assert.isNonNegativeInteger(knot_index, 'knot_index');
-
-        this.setKnotAttribute_Vector3(knot_index, TUBE_ATTRIBUTE_ADDRESS_POSITION, x, y, z);
-    }
-
-    /**
-     * 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, nx, ny, nz, bx, by, bz) {
-        this.setKnotAttribute_Vector3(knot_index, TUBE_ATTRIBUTE_ADDRESS_NORMAL, nx, ny, nz);
-        this.setKnotAttribute_Vector3(knot_index, TUBE_ATTRIBUTE_ADDRESS_BINORMAL, bx, by, bz);
-    }
-
-    /**
-     * 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, r, g, b) {
-        assert.isNonNegativeInteger(knot_index, 'knot_index');
-
-        this.setKnotAttribute_Vector3(knot_index, TUBE_ATTRIBUTE_ADDRESS_COLOR, r, g, b);
-    }
-
-    /**
-     * @param {number} knot_index
-     * @param {number} value
-     */
-    setKnotAlpha(knot_index, value) {
-        this.setKnotAttribute_Scalar(knot_index, TUBE_ATTRIBUTE_ADDRESS_ALPHA, value);
-    }
-
-    /**
-     * @param {number} knot_index
-     * @param {number} value tube diameter
-     */
-    setKnotThickness(knot_index, value) {
-        this.setKnotAttribute_Scalar(knot_index, TUBE_ATTRIBUTE_ADDRESS_THICKNESS, value);
-    }
-
-    /**
-     * @param {number} count number of knots (>= 2)
-     * @param {number} [radial] radial subdivisions (>= 3)
-     */
-    setCount(count, radial = DEFAULT_RADIAL_SEGMENTS) {
-        assert.greaterThanOrEqual(count, 2, 'a tube needs at least 2 knots (one segment)');
-        assert.isNonNegativeInteger(count, 'count');
-        assert.greaterThanOrEqual(radial, 3, 'a tube ring needs at least 3 radial segments');
-        assert.isNonNegativeInteger(radial, 'radial');
-
-        this.#radial = radial;
-
-        const v = radial + 1;
-        const vertex_count = count * v;
-
-        if (this.#data.length > vertex_count) {
-            this.#data.removeRows(vertex_count, this.#data.length - vertex_count);
-        }
-
-        this.#data.setCapacity(vertex_count);
-        this.#data.length = vertex_count;
-
-        const segment_count = count - 1;
-        const triangle_count = segment_count * radial * 2;
-
-        // Uint32 (not Uint16): vertex count = count * (radial + 1) easily exceeds 65535 for a long
-        // tube with high radial resolution.
-        this.#indices = new Uint32Array(triangle_count * 3);
-
-        this.#head_index = 0;
-        this.#tail_index = count - 1;
-        this.#tail_segment_index = segment_count - 1;
-
-        this.#count = count;
-
-        this.#initialize_off();
-        this.#initialize_frame();
-        this.#initialize_index();
-
-        this.#layout_version++;
-        this.#index_version++;
-    }
-
-    /**
-     * NOTE: takes tube thickness into account.
-     * @param {AABB3|ArrayLike<number>} result
-     */
-    computeBoundingBox(result) {
-        const count = this.#count;
-        const v = this.#ring_vertex_count;
-        const data = this.#data;
-
-        let _x0 = Infinity, _y0 = Infinity, _z0 = Infinity;
-        let _x1 = -Infinity, _y1 = -Infinity, _z1 = -Infinity;
-
-        for (let k = 0; k < count; k++) {
-            const row = k * v;
-
-            const half_thickness = data.readCellValue(row, TUBE_ATTRIBUTE_ADDRESS_THICKNESS) * 0.5;
-
-            const x = data.readCellValue(row, TUBE_ATTRIBUTE_ADDRESS_POSITION);
-            const y = data.readCellValue(row, TUBE_ATTRIBUTE_ADDRESS_POSITION + 1);
-            const z = data.readCellValue(row, TUBE_ATTRIBUTE_ADDRESS_POSITION + 2);
-
-            _x0 = min2(_x0, x - half_thickness);
-            _y0 = min2(_y0, y - half_thickness);
-            _z0 = min2(_z0, z - half_thickness);
-            _x1 = max2(_x1, x + half_thickness);
-            _y1 = max2(_y1, y + half_thickness);
-            _z1 = max2(_z1, z + half_thickness);
-        }
-
-        aabb3_array_set(result, 0, _x0, _y0, _z0, _x1, _y1, _z1);
-    }
-
-    /**
-     * 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() {
-        const old_tail = this.#tail_index;
-        const old_head = this.#head_index;
-
-        const max_index = this.#count - 1;
-
-        // The recycled slot (old tail) becomes the new head: head and tail step
-        // back in lockstep so head stays exactly one slot ahead of tail.
-        this.#tail_index = old_tail <= 0 ? max_index : old_tail - 1;
-        this.#head_index = old_head <= 0 ? max_index : old_head - 1;
-
-        const old_segment = this.#tail_segment_index;
-        const address = old_segment * this.#radial * 6;
-
-        this.#tail_segment_index = old_segment > 0 ? old_segment - 1 : this.#count - 2;
-
-        // Bridge old head -> new head (== old tail slot) with a fresh segment. The new head (old_tail slot)
-        // is the more head-ward knot, so it takes the `lo` position to match #initialize_index's winding
-        // convention (lo = more head-ward); swapping the two would invert this segment's triangle winding.
-        this.#write_segment_indices(address, old_tail, old_head);
-
-        this.#index_version++;
-    }
-}
-
-TubeX.DEFAULT_RADIAL_SEGMENTS = DEFAULT_RADIAL_SEGMENTS;

package/src/engine/graphics/trail/tube/simulator/TubeXFixedPhysicsSimulator.d.ts

@@ -1,16 +0,0 @@
-/**
- * Fixed-function simulation for {@link TubeX} tubes — the 3D analogue of
- * {@link RibbonXFixedPhysicsSimulator}. Ages every knot, sets its alpha to `alpha` times the `fade`
- * curve at its age relative to `max_age`, and flows the along-tube UV coordinate with age.
- */
-export class TubeXFixedPhysicsSimulator {
-    /**
-     * @param {TubeX} tube
-     * @param {number} max_age
-     * @param {number} timeDelta
-     * @param {number} alpha base alpha of a knot; the fade scales it
-     * @param {AnimationCurve} fade opacity over the knot's age relative to `max_age`, `0..1`
-     */
-    update(tube: TubeX, max_age: number, timeDelta: number, alpha: number, fade: AnimationCurve): void;
-}
-//# sourceMappingURL=TubeXFixedPhysicsSimulator.d.ts.map

package/src/engine/graphics/trail/tube/simulator/TubeXFixedPhysicsSimulator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"TubeXFixedPhysicsSimulator.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/trail/tube/simulator/TubeXFixedPhysicsSimulator.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH;IAEI;;;;;;OAMG;IACH,6BALW,MAAM,aACN,MAAM,SACN,MAAM,8BAkBhB;CACJ"}

package/src/engine/graphics/trail/tube/simulator/TubeXFixedPhysicsSimulator.js

@@ -1,34 +0,0 @@
-import { clamp01 } from "../../../../../core/math/clamp01.js";
-import { TUBE_ATTRIBUTE_ADDRESS_AGE, TUBE_ATTRIBUTE_ADDRESS_UV_V } from "../tube_attributes_spec.js";
-
-/**
- * Fixed-function simulation for {@link TubeX} tubes — the 3D analogue of
- * {@link RibbonXFixedPhysicsSimulator}. Ages every knot, sets its alpha to `alpha` times the `fade`
- * curve at its age relative to `max_age`, and flows the along-tube UV coordinate with age.
- */
-export class TubeXFixedPhysicsSimulator {
-
-    /**
-     * @param {TubeX} tube
-     * @param {number} max_age
-     * @param {number} timeDelta
-     * @param {number} alpha base alpha of a knot; the fade scales it
-     * @param {AnimationCurve} fade opacity over the knot's age relative to `max_age`, `0..1`
-     */
-    update(tube, max_age, timeDelta, alpha, fade) {
-
-        const n = tube.getCount();
-
-        for (let i = 0; i < n; i++) {
-            const age = tube.incrementKnotAttribute_Scalar(i, TUBE_ATTRIBUTE_ADDRESS_AGE, timeDelta);
-
-            const relative_age = clamp01(age / max_age);
-
-            // fade out with age
-            tube.setKnotAlpha(i, fade.evaluate(relative_age) * alpha);
-
-            // flow the along-tube UV with age
-            tube.setKnotAttribute_Scalar(i, TUBE_ATTRIBUTE_ADDRESS_UV_V, relative_age);
-        }
-    }
-}

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

@@ -1,27 +0,0 @@
-/**
- * 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: RowFirstTableSpec;
-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;
-import { RowFirstTableSpec } from "../../../../core/collection/table/RowFirstTableSpec.js";
-//# sourceMappingURL=tube_attributes_spec.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"tube_attributes_spec.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/trail/tube/tube_attributes_spec.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;GAcG;AACH,qDAuC4B;AAG5B,2CAA4C;AAC5C,gDAAiD;AACjD,8CAA+C;AAC/C,gDAAiD;AACjD,4CAA6C;AAC7C,6CAA8C;AAC9C,8CAA+C;AAC/C,kDAAmD;AACnD,8CAA+C;kCAnEb,wDAAwD"}