@rzmps/rzmps 1.0.0

package/build/collision/ThreeCollisionBackend.js

@@ -0,0 +1,340 @@
+import * as THREE from 'three';
+import { Octree } from 'three/examples/jsm/math/Octree.js';
+import { Capsule } from 'three/examples/jsm/math/Capsule.js';
+import ParticleSystem from '../ParticleSystem';
+import { TRAIL_RENDERER_USER_DATA_KEY } from '../renderers/TrailRenderer';
+import { SPRITE_RENDERER_USER_DATA_KEY } from '../renderers/SpriteRenderer';
+var Classification;
+(function (Classification) {
+    Classification[Classification["Static"] = 0] = "Static";
+    Classification[Classification["Dynamic"] = 1] = "Dynamic";
+    Classification[Classification["Auto"] = 2] = "Auto";
+})(Classification || (Classification = {}));
+class ThreeCollisionBackend {
+    constructor(options = {}) {
+        var _a, _b, _c, _d;
+        this.staticOctree = new Octree();
+        this.dynamicOctree = new Octree();
+        this.trackedObjects = new Map();
+        this.elapsedTime = 0;
+        this.dynamicUpdateAccumulator = 0;
+        this.refreshAccumulator = 0;
+        this.world = options.world;
+        this.staticObjects = options.staticObjects;
+        this.dynamicObjects = options.dynamicObjects;
+        this.objectFilter = options.objectFilter;
+        this.staticObjectFilter = options.staticObjectFilter;
+        this.dynamicObjectFilter = options.dynamicObjectFilter;
+        this.staticAfter = (_a = options.staticAfter) !== null && _a !== void 0 ? _a : 2;
+        this.timeQuality = THREE.MathUtils.clamp((_b = options.timeQuality) !== null && _b !== void 0 ? _b : 1, Number.EPSILON, 1);
+        this.refreshQuality = THREE.MathUtils.clamp((_d = (_c = options.refreshQuality) !== null && _c !== void 0 ? _c : options.timeQuality) !== null && _d !== void 0 ? _d : 1, Number.EPSILON, 1);
+        this.initialize();
+    }
+    update(deltaTime) {
+        this.elapsedTime += deltaTime;
+        let staticMembershipChanged = false;
+        let dynamicMembershipChanged = false;
+        this.refreshAccumulator += this.refreshQuality;
+        if (this.refreshAccumulator >= 1) {
+            this.refreshAccumulator -= 1;
+            const changes = this.refreshObjects();
+            staticMembershipChanged || (staticMembershipChanged = changes.staticChanged);
+            dynamicMembershipChanged || (dynamicMembershipChanged = changes.dynamicChanged);
+        }
+        for (const tracked of this.trackedObjects.values()) {
+            tracked.object.updateWorldMatrix(true, false);
+            if (tracked.classification !== Classification.Auto)
+                continue;
+            const moved = this.matrixChanged(tracked.matrixWorld, tracked.object.matrixWorld);
+            if (moved) {
+                tracked.matrixWorld.copy(tracked.object.matrixWorld);
+                tracked.lastMovedAt = this.elapsedTime;
+                if (!tracked.dynamic) {
+                    tracked.dynamic = true;
+                    staticMembershipChanged = true;
+                    dynamicMembershipChanged = true;
+                }
+            }
+            else if (tracked.dynamic
+                && this.elapsedTime - tracked.lastMovedAt >= this.staticAfter) {
+                tracked.dynamic = false;
+                staticMembershipChanged = true;
+                dynamicMembershipChanged = true;
+            }
+        }
+        if (staticMembershipChanged) {
+            this.rebuildStaticOctree();
+        }
+        if (dynamicMembershipChanged) {
+            this.rebuildDynamicOctree();
+            this.dynamicUpdateAccumulator = 0;
+            return;
+        }
+        this.dynamicUpdateAccumulator += this.timeQuality;
+        if (this.dynamicUpdateAccumulator >= 1) {
+            this.dynamicUpdateAccumulator -= 1;
+            this.rebuildDynamicOctree();
+        }
+    }
+    collide(query) {
+        const capsule = new Capsule(query.start.clone(), query.end.clone(), Math.max(query.radius, Number.EPSILON));
+        const staticHit = this.staticOctree.capsuleIntersect(capsule);
+        const dynamicHit = this.dynamicOctree.capsuleIntersect(capsule);
+        if (!staticHit && !dynamicHit)
+            return null;
+        const collisionVector = new THREE.Vector3();
+        if (staticHit) {
+            collisionVector.addScaledVector(staticHit.normal, staticHit.depth);
+        }
+        if (dynamicHit) {
+            collisionVector.addScaledVector(dynamicHit.normal, dynamicHit.depth);
+        }
+        if (collisionVector.lengthSq() === 0)
+            return null;
+        const normal = collisionVector.clone().normalize();
+        const position = query.end
+            .clone()
+            .add(collisionVector);
+        const point = position
+            .clone()
+            .addScaledVector(normal, -query.radius);
+        return {
+            point,
+            normal,
+            position,
+        };
+    }
+    initialize() {
+        this.refreshObjects();
+        this.rebuildStaticOctree();
+        this.rebuildDynamicOctree();
+        this.dynamicUpdateAccumulator = 0;
+        this.refreshAccumulator = 0;
+    }
+    refreshObjects() {
+        const previous = this.trackedObjects;
+        const next = new Map();
+        if (this.hasExplicitLists()) {
+            this.collectExplicitObjects(next, previous);
+        }
+        else if (this.world) {
+            this.collectWorldObjects(next, previous);
+        }
+        let staticChanged = false;
+        let dynamicChanged = false;
+        const ids = new Set([
+            ...previous.keys(),
+            ...next.keys(),
+        ]);
+        for (const id of ids) {
+            const before = previous.get(id);
+            const after = next.get(id);
+            if (!before && after) {
+                if (after.dynamic)
+                    dynamicChanged = true;
+                else
+                    staticChanged = true;
+                continue;
+            }
+            if (before && !after) {
+                if (before.dynamic)
+                    dynamicChanged = true;
+                else
+                    staticChanged = true;
+                continue;
+            }
+            if (!before || !after)
+                continue;
+            if (before.dynamic !== after.dynamic) {
+                staticChanged = true;
+                dynamicChanged = true;
+            }
+        }
+        this.trackedObjects = next;
+        return {
+            staticChanged,
+            dynamicChanged,
+        };
+    }
+    hasExplicitLists() {
+        return this.staticObjects !== undefined
+            || this.dynamicObjects !== undefined;
+    }
+    collectExplicitObjects(target, previous) {
+        var _a, _b;
+        this.collectRoots((_a = this.staticObjects) !== null && _a !== void 0 ? _a : [], (mesh) => {
+            this.trackObject(target, previous, mesh, Classification.Static);
+        });
+        this.collectRoots((_b = this.dynamicObjects) !== null && _b !== void 0 ? _b : [], (mesh) => {
+            this.trackObject(target, previous, mesh, Classification.Dynamic);
+        });
+    }
+    collectWorldObjects(target, previous) {
+        if (!this.world)
+            return;
+        this.world.updateWorldMatrix(true, true);
+        this.world.traverse((object) => {
+            var _a, _b, _c, _d;
+            if (!(object instanceof THREE.Mesh))
+                return;
+            if (object instanceof ParticleSystem)
+                return;
+            // Ideally, we ignore all helpers here.
+            // Good god, what a mess
+            if (object instanceof THREE.BoxHelper)
+                return;
+            if (object instanceof THREE.Box3Helper)
+                return;
+            if (object instanceof THREE.AxesHelper)
+                return;
+            if (object instanceof THREE.GridHelper)
+                return;
+            if (object instanceof THREE.ArrowHelper)
+                return;
+            if (object instanceof THREE.PlaneHelper)
+                return;
+            if (object instanceof THREE.CameraHelper)
+                return;
+            if (object instanceof THREE.SkeletonHelper)
+                return;
+            if (object instanceof THREE.PolarGridHelper)
+                return;
+            if (object instanceof THREE.DirectionalLightHelper)
+                return;
+            if (object instanceof THREE.HemisphereLightHelper)
+                return;
+            if (object instanceof THREE.SpotLightHelper)
+                return;
+            if (object instanceof THREE.PointLightHelper)
+                return;
+            // Check for renderer object
+            if (object.userData[TRAIL_RENDERER_USER_DATA_KEY])
+                return;
+            if (object.userData[SPRITE_RENDERER_USER_DATA_KEY])
+                return;
+            if (this.objectFilter
+                && !this.objectFilter(object)) {
+                return;
+            }
+            const isDynamic = (_b = (_a = this.dynamicObjectFilter) === null || _a === void 0 ? void 0 : _a.call(this, object)) !== null && _b !== void 0 ? _b : false;
+            const isStatic = (_d = (_c = this.staticObjectFilter) === null || _c === void 0 ? void 0 : _c.call(this, object)) !== null && _d !== void 0 ? _d : false;
+            if (isDynamic) {
+                this.trackObject(target, previous, object, Classification.Dynamic);
+                return;
+            }
+            if (isStatic) {
+                this.trackObject(target, previous, object, Classification.Static);
+                return;
+            }
+            this.trackObject(target, previous, object, Classification.Auto);
+        });
+    }
+    collectRoots(roots, callback) {
+        roots.forEach((root) => {
+            root.updateWorldMatrix(true, true);
+            root.traverse((object) => {
+                if (!(object instanceof THREE.Mesh))
+                    return;
+                if (this.objectFilter
+                    && !this.objectFilter(object)) {
+                    return;
+                }
+                callback(object);
+            });
+        });
+    }
+    trackObject(target, previous, object, classification) {
+        const existing = target.get(object.uuid);
+        if ((existing === null || existing === void 0 ? void 0 : existing.classification) === Classification.Dynamic) {
+            return;
+        }
+        const previousTracked = previous.get(object.uuid);
+        object.updateWorldMatrix(true, false);
+        if (classification === Classification.Auto
+            && (previousTracked === null || previousTracked === void 0 ? void 0 : previousTracked.classification) === Classification.Auto) {
+            target.set(object.uuid, {
+                object,
+                classification,
+                dynamic: previousTracked.dynamic,
+                matrixWorld: previousTracked.matrixWorld.clone(),
+                lastMovedAt: previousTracked.lastMovedAt,
+            });
+            return;
+        }
+        target.set(object.uuid, {
+            object,
+            classification,
+            dynamic: classification === Classification.Dynamic,
+            matrixWorld: object.matrixWorld.clone(),
+            lastMovedAt: this.elapsedTime,
+        });
+    }
+    rebuildStaticOctree() {
+        const objects = Array.from(this.trackedObjects.values())
+            .filter((tracked) => !tracked.dynamic)
+            .map((tracked) => tracked.object);
+        this.staticOctree = this.buildOctree(objects);
+    }
+    rebuildDynamicOctree() {
+        const objects = Array.from(this.trackedObjects.values())
+            .filter((tracked) => tracked.dynamic)
+            .map((tracked) => tracked.object);
+        this.dynamicOctree = this.buildOctree(objects);
+    }
+    buildOctree(objects) {
+        const octree = new Octree();
+        let triangleCount = 0;
+        objects.forEach((object) => {
+            triangleCount += this.addMeshToOctree(octree, object);
+        });
+        if (triangleCount > 0) {
+            octree.build();
+        }
+        return octree;
+    }
+    addMeshToOctree(octree, object) {
+        object.updateWorldMatrix(true, false);
+        const sourceGeometry = object.geometry;
+        if (!(sourceGeometry instanceof THREE.BufferGeometry)) {
+            return 0;
+        }
+        let geometry = sourceGeometry;
+        let temporaryGeometry;
+        if (sourceGeometry.index !== null) {
+            temporaryGeometry = sourceGeometry.toNonIndexed();
+            geometry = temporaryGeometry;
+        }
+        const position = geometry.getAttribute('position');
+        if (!position) {
+            temporaryGeometry === null || temporaryGeometry === void 0 ? void 0 : temporaryGeometry.dispose();
+            return 0;
+        }
+        let count = 0;
+        for (let i = 0; i + 2 < position.count; i += 3) {
+            const a = new THREE.Vector3()
+                .fromBufferAttribute(position, i)
+                .applyMatrix4(object.matrixWorld);
+            const b = new THREE.Vector3()
+                .fromBufferAttribute(position, i + 1)
+                .applyMatrix4(object.matrixWorld);
+            const c = new THREE.Vector3()
+                .fromBufferAttribute(position, i + 2)
+                .applyMatrix4(object.matrixWorld);
+            octree.addTriangle(new THREE.Triangle(a, b, c));
+            count++;
+        }
+        temporaryGeometry === null || temporaryGeometry === void 0 ? void 0 : temporaryGeometry.dispose();
+        return count;
+    }
+    matrixChanged(previous, current) {
+        const a = previous.elements;
+        const b = current.elements;
+        for (let i = 0; i < 16; i++) {
+            if (Math.abs(a[i] - b[i]) > 1e-6) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+export default ThreeCollisionBackend;

package/build/enums/Axis.d.ts

@@ -0,0 +1,6 @@
+declare enum Axis {
+    x = "x",
+    y = "y",
+    z = "z"
+}
+export { Axis };

package/build/enums/Axis.js

@@ -0,0 +1,7 @@
+var Axis;
+(function (Axis) {
+    Axis["x"] = "x";
+    Axis["y"] = "y";
+    Axis["z"] = "z";
+})(Axis || (Axis = {}));
+export { Axis };

package/build/enums/DynamicValueType.d.ts

@@ -0,0 +1,6 @@
+declare enum DynamicValueType {
+    Constant = 0,
+    Curve = 1,
+    Between = 2
+}
+export default DynamicValueType;

package/build/enums/DynamicValueType.js

@@ -0,0 +1,7 @@
+var DynamicValueType;
+(function (DynamicValueType) {
+    DynamicValueType[DynamicValueType["Constant"] = 0] = "Constant";
+    DynamicValueType[DynamicValueType["Curve"] = 1] = "Curve";
+    DynamicValueType[DynamicValueType["Between"] = 2] = "Between";
+})(DynamicValueType || (DynamicValueType = {}));
+export default DynamicValueType;

package/build/enums/EmissionSource copy.d.ts

@@ -0,0 +1,7 @@
+declare enum EmissionSource {
+    Volume = "volume",
+    Surface = "surface",
+    Vertices = "vertices"
+}
+export type EmissionSourceValue = EmissionSource | `${EmissionSource}`;
+export { EmissionSource };

package/build/enums/EmissionSource copy.js

@@ -0,0 +1,7 @@
+var EmissionSource;
+(function (EmissionSource) {
+    EmissionSource["Volume"] = "volume";
+    EmissionSource["Surface"] = "surface";
+    EmissionSource["Vertices"] = "vertices";
+})(EmissionSource || (EmissionSource = {}));
+export { EmissionSource };

package/build/enums/EmissionSource.d.ts

@@ -0,0 +1,7 @@
+declare enum EmissionSource {
+    Volume = "volume",
+    Surface = "surface",
+    Vertices = "vertices"
+}
+export type EmissionSourceValue = EmissionSource | `${EmissionSource}`;
+export { EmissionSource };

package/build/enums/EmissionSource.js

@@ -0,0 +1,7 @@
+var EmissionSource;
+(function (EmissionSource) {
+    EmissionSource["Volume"] = "volume";
+    EmissionSource["Surface"] = "surface";
+    EmissionSource["Vertices"] = "vertices";
+})(EmissionSource || (EmissionSource = {}));
+export { EmissionSource };

package/build/enums/EndBehavior.d.ts

@@ -0,0 +1,6 @@
+declare enum EndBehavior {
+    None = "none",
+    Destroy = "destroy",
+    DestroyImmediate = "destroyImmediate"
+}
+export { EndBehavior };

package/build/enums/EndBehavior.js

@@ -0,0 +1,7 @@
+var EndBehavior;
+(function (EndBehavior) {
+    EndBehavior["None"] = "none";
+    EndBehavior["Destroy"] = "destroy";
+    EndBehavior["DestroyImmediate"] = "destroyImmediate";
+})(EndBehavior || (EndBehavior = {}));
+export { EndBehavior };

package/build/enums/SimulationSpace.d.ts

@@ -0,0 +1,5 @@
+declare enum SimulationSpace {
+    Local = "local",
+    World = "world"
+}
+export { SimulationSpace };

package/build/enums/SimulationSpace.js

@@ -0,0 +1,6 @@
+var SimulationSpace;
+(function (SimulationSpace) {
+    SimulationSpace["Local"] = "local";
+    SimulationSpace["World"] = "world";
+})(SimulationSpace || (SimulationSpace = {}));
+export { SimulationSpace };

package/build/enums/SpriteMaterialType.d.ts

@@ -0,0 +1,5 @@
+declare enum SpriteMaterialType {
+    Basic = "basic",
+    Unlit = "unlit"
+}
+export { SpriteMaterialType };

package/build/enums/SpriteMaterialType.js

@@ -0,0 +1,6 @@
+var SpriteMaterialType;
+(function (SpriteMaterialType) {
+    SpriteMaterialType["Basic"] = "basic";
+    SpriteMaterialType["Unlit"] = "unlit";
+})(SpriteMaterialType || (SpriteMaterialType = {}));
+export { SpriteMaterialType };

package/build/enums/TagSelectionMethod.d.ts

@@ -0,0 +1,6 @@
+declare enum TagSelectionMethod {
+    All = "all",
+    Random = "random",
+    Distribute = "distribute"
+}
+export { TagSelectionMethod };

package/build/enums/TagSelectionMethod.js

@@ -0,0 +1,7 @@
+var TagSelectionMethod;
+(function (TagSelectionMethod) {
+    TagSelectionMethod["All"] = "all";
+    TagSelectionMethod["Random"] = "random";
+    TagSelectionMethod["Distribute"] = "distribute";
+})(TagSelectionMethod || (TagSelectionMethod = {}));
+export { TagSelectionMethod };

package/build/enums/TrailMode copy.d.ts

@@ -0,0 +1,5 @@
+declare enum TrailMode {
+    Particle = "particle",
+    Ribbon = "ribbon"
+}
+export { TrailMode };

package/build/enums/TrailMode copy.js

@@ -0,0 +1,7 @@
+var TrailMode;
+(function (TrailMode) {
+    TrailMode["Particle"] = "particle";
+    TrailMode["Ribbon"] = "ribbon";
+})(TrailMode || (TrailMode = {}));
+;
+export { TrailMode };

package/build/enums/TrailMode.d.ts

@@ -0,0 +1,5 @@
+declare enum TrailMode {
+    Particle = "particle",
+    Ribbon = "ribbon"
+}
+export { TrailMode };

package/build/enums/TrailMode.js

@@ -0,0 +1,7 @@
+var TrailMode;
+(function (TrailMode) {
+    TrailMode["Particle"] = "particle";
+    TrailMode["Ribbon"] = "ribbon";
+})(TrailMode || (TrailMode = {}));
+;
+export { TrailMode };

package/build/enums/TrailTextureMode.d.ts

@@ -0,0 +1,7 @@
+declare enum TrailTextureMode {
+    Stretch = "stretch",
+    Tile = "tile",
+    RepeatPerSegment = "repeat",
+    DistributePerSegment = "distribute"
+}
+export { TrailTextureMode };

package/build/enums/TrailTextureMode.js

@@ -0,0 +1,9 @@
+var TrailTextureMode;
+(function (TrailTextureMode) {
+    TrailTextureMode["Stretch"] = "stretch";
+    TrailTextureMode["Tile"] = "tile";
+    TrailTextureMode["RepeatPerSegment"] = "repeat";
+    TrailTextureMode["DistributePerSegment"] = "distribute";
+})(TrailTextureMode || (TrailTextureMode = {}));
+;
+export { TrailTextureMode };

package/build/gpu/GpuDynamicValue.d.ts

@@ -0,0 +1,9 @@
+import * as THREE from 'three';
+import { DynamicValue, GpuDynamicValueOption } from '../types/DynamicValue';
+export declare const GPU_DYNAMIC_VALUE_SAMPLE_COUNT = 32;
+export declare function isGpuDynamicValue<T>(value: DynamicValue<T> | undefined): boolean;
+export declare function gpuDynamicNumber(value: DynamicValue<number> | undefined, time: any, seed: any, fallback?: number): any;
+export declare function gpuDynamicVector3(value: DynamicValue<THREE.Vector3> | undefined, time: any, seed: any, fallback?: THREE.Vector3): any;
+export declare function gpuDynamicColor(value: DynamicValue<THREE.Color> | undefined, time: any, seed: any, fallback?: THREE.Color): any;
+export declare function gpuDynamicValue<T>(cpu: DynamicValue<T>, tsl: GpuDynamicValueOption<T>['tsl']): GpuDynamicValueOption<T>;
+export declare function gpuDynamicColorAlpha(color: DynamicValue<THREE.Color> | undefined, alpha: DynamicValue<number> | undefined, time: any, seed: any): any;

package/build/gpu/GpuDynamicValue.js

@@ -0,0 +1,113 @@
+import * as THREE from 'three';
+import { clamp, float, mix, select, vec3, vec4, } from 'three/src/nodes/TSL.js';
+import { isGpuDynamicValueOption } from '../types/DynamicValue';
+export const GPU_DYNAMIC_VALUE_SAMPLE_COUNT = 32;
+export function isGpuDynamicValue(value) {
+    if (value === undefined)
+        return true;
+    if (isGpuDynamicValueOption(value))
+        return true;
+    if (typeof value === 'function') {
+        return sampleFunction(value)
+            .every((sample) => isGpuDynamicValue(sample));
+    }
+    if (Array.isArray(value)) {
+        return isGpuDynamicValue(value[0]) && isGpuDynamicValue(value[1]);
+    }
+    if (value instanceof Set) {
+        return Array.from(value).every((item) => isGpuDynamicValue(item));
+    }
+    return true;
+}
+export function gpuDynamicNumber(value, time, seed, fallback = 0) {
+    if (value === undefined)
+        return float(fallback);
+    if (isGpuDynamicValueOption(value))
+        return gpuDynamicOption(value, time, seed);
+    if (typeof value === 'function') {
+        return sampleDynamicValue(value, time, seed, fallback, gpuDynamicNumber);
+    }
+    if (Array.isArray(value)) {
+        return mix(gpuDynamicNumber(value[0], time, seed, fallback), gpuDynamicNumber(value[1], time, seed, fallback), seed);
+    }
+    if (value instanceof Set) {
+        return selectFromSet(Array.from(value), time, seed, fallback, gpuDynamicNumber);
+    }
+    return float(value);
+}
+export function gpuDynamicVector3(value, time, seed, fallback = new THREE.Vector3()) {
+    if (value === undefined)
+        return vec3(fallback.x, fallback.y, fallback.z);
+    if (isGpuDynamicValueOption(value))
+        return gpuDynamicOption(value, time, seed);
+    if (typeof value === 'function') {
+        return sampleDynamicValue(value, time, seed, fallback, gpuDynamicVector3);
+    }
+    if (Array.isArray(value)) {
+        return mix(gpuDynamicVector3(value[0], time, seed, fallback), gpuDynamicVector3(value[1], time, seed, fallback), seed);
+    }
+    if (value instanceof Set) {
+        return selectFromSet(Array.from(value), time, seed, fallback, gpuDynamicVector3);
+    }
+    return vec3(value.x, value.y, value.z);
+}
+export function gpuDynamicColor(value, time, seed, fallback = new THREE.Color()) {
+    if (value === undefined)
+        return vec3(fallback.r, fallback.g, fallback.b);
+    if (isGpuDynamicValueOption(value))
+        return gpuDynamicOption(value, time, seed);
+    if (typeof value === 'function') {
+        return sampleDynamicValue(value, time, seed, fallback, gpuDynamicColor);
+    }
+    if (Array.isArray(value)) {
+        return mix(gpuDynamicColor(value[0], time, seed, fallback), gpuDynamicColor(value[1], time, seed, fallback), seed);
+    }
+    if (value instanceof Set) {
+        return selectFromSet(Array.from(value), time, seed, fallback, gpuDynamicColor);
+    }
+    return vec3(value.r, value.g, value.b);
+}
+function sampleDynamicValue(value, time, seed, fallback, evaluate) {
+    const samples = sampleFunction(value);
+    if (samples.length === 0)
+        return evaluate(undefined, time, seed, fallback);
+    if (samples.length === 1)
+        return evaluate(samples[0], time, seed, fallback);
+    const clampedTime = clamp(time, 0, 1);
+    let result = evaluate(samples[samples.length - 1], clampedTime, seed, fallback);
+    for (let i = samples.length - 2; i >= 0; i -= 1) {
+        const segmentStart = i / (samples.length - 1);
+        const segmentEnd = (i + 1) / (samples.length - 1);
+        const segmentT = clamp(clampedTime.sub(segmentStart).div(segmentEnd - segmentStart), 0, 1);
+        result = select(clampedTime.lessThanEqual(segmentEnd), mix(evaluate(samples[i], clampedTime, seed, fallback), evaluate(samples[i + 1], clampedTime, seed, fallback), segmentT), result);
+    }
+    return result;
+}
+function sampleFunction(value) {
+    return Array.from({ length: GPU_DYNAMIC_VALUE_SAMPLE_COUNT }, (_, index) => {
+        const time = index / (GPU_DYNAMIC_VALUE_SAMPLE_COUNT - 1);
+        return value(time);
+    });
+}
+export function gpuDynamicValue(cpu, tsl) {
+    return { cpu, tsl };
+}
+function gpuDynamicOption(value, time, seed) {
+    return typeof value.tsl === 'function'
+        ? value.tsl(time, seed)
+        : value.tsl;
+}
+export function gpuDynamicColorAlpha(color, alpha, time, seed) {
+    const rgb = gpuDynamicColor(color, time, seed, new THREE.Color(1, 1, 1));
+    const a = gpuDynamicNumber(alpha, time, seed, 1);
+    return vec4(rgb.x, rgb.y, rgb.z, a);
+}
+function selectFromSet(values, time, seed, fallback, evaluate) {
+    if (values.length === 0)
+        return evaluate(undefined, time, seed, fallback);
+    let result = evaluate(values[values.length - 1], time, seed, fallback);
+    for (let i = values.length - 2; i >= 0; i -= 1) {
+        result = select(seed.lessThan((i + 1) / values.length), evaluate(values[i], time, seed, fallback), result);
+    }
+    return result;
+}

package/build/gpu/GpuMath.d.ts

@@ -0,0 +1,3 @@
+import { SpeedRange } from '../modules/ColorBySpeed';
+export declare function gpuSpeedRangeTime(speed: any, speedRange?: SpeedRange): any;
+export declare function gpuVectorLength(value: any): any;

package/build/gpu/GpuMath.js

@@ -0,0 +1,12 @@
+import { clamp, length, select, } from 'three/src/nodes/TSL.js';
+export function gpuSpeedRangeTime(speed, speedRange) {
+    var _a, _b;
+    const min = Array.isArray(speedRange) ? speedRange[0] : (_a = speedRange === null || speedRange === void 0 ? void 0 : speedRange.min) !== null && _a !== void 0 ? _a : 0;
+    const max = Array.isArray(speedRange) ? speedRange[1] : (_b = speedRange === null || speedRange === void 0 ? void 0 : speedRange.max) !== null && _b !== void 0 ? _b : 1;
+    if (max === min)
+        return select(speed.greaterThanEqual(max), 1, 0);
+    return clamp(speed.sub(min).div(max - min), 0, 1);
+}
+export function gpuVectorLength(value) {
+    return length(value);
+}