sparcoon 0.0.1

package/dist/elements/FXEmitter.js

@@ -0,0 +1,154 @@
+import { Object3D, Vector2 } from 'three';
+import { FXInstancedParticle } from '../instancedParticle/FXInstancedParticle.js';
+import { collectProperties, collectUniforms } from '../instancedParticle/FXInstancedParticle.Internal.js';
+import { resolveGLSLTypeInfo } from '../instancedParticle/shared.js';
+import { BUILTIN_OFFSET_AGE, BUILTIN_OFFSET_POSITION_X, BUILTIN_OFFSET_VELOCITY_X, BUILTIN_OFFSET_POSITION_Y, BUILTIN_OFFSET_VELOCITY_Y, BUILTIN_OFFSET_ROTATION, BUILTIN_OFFSET_TORQUE, BUILTIN_OFFSET_RANDOM_A, BUILTIN_OFFSET_RANDOM_B, BUILTIN_OFFSET_RANDOM_C } from '../miscellaneous/miscellaneous.js';
+import { EMITTER_DEFAULT_EXPECTED_CAPACITY, EMITTER_DEFAULT_CAPACITY_STEP, EMITTER_DEFAULT_AUTOMATICALLY_DESTROY_MODULES } from './FXEmitter.Internal.js';
+
+const INSTANCES = new Array();
+class FXEmitter extends Object3D {
+    constructor(_private_spawnSequence, _private_behaviorSequence, _private_renderingSequence, options = {}) {
+        super();
+        this._private_spawnSequence = _private_spawnSequence;
+        this._private_behaviorSequence = _private_behaviorSequence;
+        this._private_renderingSequence = _private_renderingSequence;
+        this._private_emissionRate = 0;
+        this._private_emissionAccumulator = 0;
+        this._private_emissionDuration = Infinity;
+        this._private_emissionElapsed = 0;
+        this._private_onRendering = (deltaTime) => {
+            {
+                const { builtin } = this._private_mesh.propertyBuffers;
+                const { array, itemSize } = builtin;
+                for (let i = 0; i < this._private_mesh.instanceCount; i++) {
+                    array[i * itemSize + BUILTIN_OFFSET_AGE] += deltaTime;
+                }
+                builtin.needsUpdate = true;
+                this._private_mesh.removeDeadParticles();
+            }
+            if (this._private_emissionRate > 0) {
+                this._private_emissionElapsed += deltaTime;
+                if (this._private_emissionElapsed >= this._private_emissionDuration) {
+                    this.stop();
+                }
+                else {
+                    this._private_emissionAccumulator += this._private_emissionRate * deltaTime;
+                    const particlesToSpawn = Math.floor(this._private_emissionAccumulator);
+                    if (particlesToSpawn > 0) {
+                        this.burst(particlesToSpawn);
+                        this._private_emissionAccumulator -= particlesToSpawn;
+                    }
+                }
+            }
+            if (this._private_mesh.instanceCount === 0) {
+                return;
+            }
+            {
+                const { propertyBuffers, instanceCount } = this._private_mesh;
+                for (const module of this._private_behaviorSequence) {
+                    module.update(propertyBuffers, instanceCount, deltaTime);
+                }
+            }
+            const { builtin } = this._private_mesh.propertyBuffers;
+            const { array, itemSize } = builtin;
+            {
+                for (let i = 0; i < this._private_mesh.instanceCount; i++) {
+                    const itemOffset = i * itemSize;
+                    array[itemOffset + BUILTIN_OFFSET_POSITION_X] +=
+                        array[itemOffset + BUILTIN_OFFSET_VELOCITY_X] * deltaTime;
+                    array[itemOffset + BUILTIN_OFFSET_POSITION_Y] +=
+                        array[itemOffset + BUILTIN_OFFSET_VELOCITY_Y] * deltaTime;
+                }
+                builtin.needsUpdate = true;
+            }
+            {
+                for (let i = 0; i < this._private_mesh.instanceCount; i++) {
+                    const itemOffset = i * itemSize;
+                    array[itemOffset + BUILTIN_OFFSET_ROTATION] +=
+                        array[itemOffset + BUILTIN_OFFSET_TORQUE] * deltaTime;
+                }
+                builtin.needsUpdate = true;
+            }
+        };
+        const collectedProperties = {
+            builtin: resolveGLSLTypeInfo("Matrix4"),
+            // 0, 1   positionX, positionY
+            // 2, 3   velocityX, velocityY
+            // 4, 5   scaleX, scaleY
+            // 6, 7   rotation, torque
+            // 8, 9   lifetime, age
+            // 10, 11, 12   randomX, randomY, randomZ
+            // 13, 14, 16   reservedX, reservedY, reservedZ
+        };
+        collectProperties(collectedProperties, _private_spawnSequence, "UIEmitter.constructor.spawnSequence:");
+        collectProperties(collectedProperties, _private_behaviorSequence, "UIEmitter.constructor.behaviorSequence");
+        collectProperties(collectedProperties, _private_renderingSequence, "UIEmitter.constructor.renderingSequence");
+        const collectedUniforms = {
+            origin: { value: new Vector2(), glslTypeInfo: resolveGLSLTypeInfo("Vector2") },
+        };
+        collectUniforms(collectedUniforms, _private_renderingSequence, "UIEmitter.constructor.renderingSequence");
+        this._private_mesh = new FXInstancedParticle(this._private_renderingSequence.map((module) => module.source), collectedUniforms, collectedProperties, options.expectedCapacity ?? EMITTER_DEFAULT_EXPECTED_CAPACITY, options.capacityStep ?? EMITTER_DEFAULT_CAPACITY_STEP);
+        this.automaticallyDestroyModules =
+            options.automaticallyDestroyModules ?? EMITTER_DEFAULT_AUTOMATICALLY_DESTROY_MODULES;
+        this.add(this._private_mesh);
+        INSTANCES.push(this);
+    }
+    destroy() {
+        const index = INSTANCES.indexOf(this);
+        if (index !== -1) {
+            INSTANCES.splice(index, 1);
+        }
+        if (this.automaticallyDestroyModules) {
+            for (const module of this._private_spawnSequence) {
+                module.destroy?.();
+            }
+            for (const module of this._private_behaviorSequence) {
+                module.destroy?.();
+            }
+            for (const module of this._private_renderingSequence) {
+                module.destroy?.();
+            }
+        }
+    }
+    burst(count) {
+        const instanceBegin = this._private_mesh.instanceCount;
+        this._private_mesh.createInstances(count);
+        const instanceEnd = this._private_mesh.instanceCount;
+        {
+            const { builtin } = this._private_mesh.propertyBuffers;
+            const { array, itemSize } = builtin;
+            for (let i = instanceBegin; i < instanceEnd; i++) {
+                const itemOffset = i * itemSize;
+                array[itemOffset + BUILTIN_OFFSET_RANDOM_A] = Math.random();
+                array[itemOffset + BUILTIN_OFFSET_RANDOM_B] = Math.random();
+                array[itemOffset + BUILTIN_OFFSET_RANDOM_C] = Math.random();
+            }
+            builtin.needsUpdate = true;
+        }
+        for (const spawnModule of this._private_spawnSequence) {
+            spawnModule.spawn(this._private_mesh.propertyBuffers, instanceBegin, instanceEnd);
+        }
+    }
+    reset() {
+        this._private_mesh.drop();
+    }
+    play(rate, options = {}) {
+        this._private_emissionRate = rate;
+        this._private_emissionAccumulator = 0;
+        this._private_emissionDuration = options.duration ?? Infinity;
+        this._private_emissionElapsed = 0;
+    }
+    stop() {
+        this._private_emissionRate = 0;
+        this._private_emissionAccumulator = 0;
+        this._private_emissionDuration = Infinity;
+        this._private_emissionElapsed = 0;
+    }
+}
+FXEmitter.onWillRender = (deltaTime) => {
+    for (const instance of INSTANCES) {
+        instance._private_onRendering(deltaTime);
+    }
+};
+
+export { FXEmitter };

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+export { FXBehaviorDirectionalGravity } from "./behaviorModules/FXBehaviorDirectionalGravity";
+export { FXBehaviorPointGravity } from "./behaviorModules/FXBehaviorPointGravity";
+export { FXBehaviorScaleOverLife } from "./behaviorModules/FXBehaviorScaleOverLife";
+export { FXBehaviorTorqueDamping } from "./behaviorModules/FXBehaviorTorqueDamping";
+export { FXBehaviorTorqueNoise } from "./behaviorModules/FXBehaviorTorqueNoise";
+export { FXBehaviorVelocityDamping } from "./behaviorModules/FXBehaviorVelocityDamping";
+export { FXBehaviorVelocityNoise } from "./behaviorModules/FXBehaviorVelocityNoise";
+export { FXEmitter } from "./elements/FXEmitter";
+export { FXRenderingColorOverLife } from "./renderingModules/FXRenderingColorOverLife";
+export { FXRenderingColorOverVelocity } from "./renderingModules/FXRenderingColorOverVelocity";
+export { FXTextureRenderingModule } from "./renderingModules/FXRenderingTexture";
+export { FXSpawnBox } from "./spawnModules/FXSpawnBox";
+export { FXSpawnOffset } from "./spawnModules/FXSpawnOffset";
+export { FXSpawnRandomLifetime } from "./spawnModules/FXSpawnRandomLifetime";
+export { FXSpawnRandomRotation } from "./spawnModules/FXSpawnRandomRotation";
+export { FXSpawnRandomScale } from "./spawnModules/FXSpawnRandomScale";
+export { FXSpawnRandomTorque } from "./spawnModules/FXSpawnRandomTorque";
+export { FXSpawnRandomVelocity } from "./spawnModules/FXSpawnRandomVelocity";

package/dist/index.js

@@ -0,0 +1,18 @@
+export { FXBehaviorDirectionalGravity } from './behaviorModules/FXBehaviorDirectionalGravity.js';
+export { FXBehaviorPointGravity } from './behaviorModules/FXBehaviorPointGravity.js';
+export { FXBehaviorScaleOverLife } from './behaviorModules/FXBehaviorScaleOverLife.js';
+export { FXBehaviorTorqueDamping } from './behaviorModules/FXBehaviorTorqueDamping.js';
+export { FXBehaviorTorqueNoise } from './behaviorModules/FXBehaviorTorqueNoise.js';
+export { FXBehaviorVelocityDamping } from './behaviorModules/FXBehaviorVelocityDamping.js';
+export { FXBehaviorVelocityNoise } from './behaviorModules/FXBehaviorVelocityNoise.js';
+export { FXEmitter } from './elements/FXEmitter.js';
+export { FXRenderingColorOverLife } from './renderingModules/FXRenderingColorOverLife.js';
+export { FXRenderingColorOverVelocity } from './renderingModules/FXRenderingColorOverVelocity.js';
+export { FXTextureRenderingModule } from './renderingModules/FXRenderingTexture.js';
+export { FXSpawnBox } from './spawnModules/FXSpawnBox.js';
+export { FXSpawnOffset } from './spawnModules/FXSpawnOffset.js';
+export { FXSpawnRandomLifetime } from './spawnModules/FXSpawnRandomLifetime.js';
+export { FXSpawnRandomRotation } from './spawnModules/FXSpawnRandomRotation.js';
+export { FXSpawnRandomScale } from './spawnModules/FXSpawnRandomScale.js';
+export { FXSpawnRandomTorque } from './spawnModules/FXSpawnRandomTorque.js';
+export { FXSpawnRandomVelocity } from './spawnModules/FXSpawnRandomVelocity.js';

package/dist/instancedParticle/FXInstancedParticle.Internal.d.ts

@@ -0,0 +1,13 @@
+import { InstancedBufferGeometry, ShaderMaterial } from "three";
+import type { GLProperty, GLTypeInfo } from "./shared";
+import { type FXProperty, type FXPropertyName } from "./shared";
+export declare const INSTANCED_PARTICLE_GEOMETRY: InstancedBufferGeometry;
+export declare function collectProperties(keeper: Record<string, GLTypeInfo>, modules: readonly {
+    requiredProperties?: Record<string, FXPropertyName>;
+}[], debugContext: string): void;
+export declare function collectUniforms(keeper: Record<string, GLProperty>, modules: readonly {
+    requiredUniforms: Record<string, FXProperty>;
+}[], debugContext: string): void;
+export declare function buildParticleVertexShader(uniformDeclarations: string[], attributeDeclarations: string[], varyingDeclarations: string[], vertexAssignments: string[]): string;
+export declare function buildParticleFragmentShader(uniformDeclarations: string[], varyingDeclarations: string[], sources: string[]): string;
+export declare function buildParticleMaterial(sources: string[], uniformProperties: Record<string, GLProperty>, varyingProperties: Record<string, GLTypeInfo>): ShaderMaterial;

package/dist/instancedParticle/FXInstancedParticle.Internal.js

@@ -0,0 +1,216 @@
+import { InstancedBufferGeometry, BufferAttribute, Float32BufferAttribute, ShaderMaterial } from 'three';
+import { FXColor } from '../color/FXColor.js';
+import { checkSRGBSupport } from '../miscellaneous/webglCapabilities.js';
+import { resolveGLSLTypeInfo } from './shared.js';
+
+const INSTANCED_PARTICLE_GEOMETRY = (() => {
+    const geometry = new InstancedBufferGeometry();
+    const indices = new Uint16Array([0, 2, 1, 2, 3, 1]);
+    geometry.setIndex(new BufferAttribute(indices, 1));
+    const positions = new Float32Array([-0.5, 0.5, 0, 0.5, 0.5, 0, -0.5, -0.5, 0, 0.5, -0.5, 0]);
+    geometry.setAttribute("position", new Float32BufferAttribute(positions, 3));
+    const uvs = new Float32Array([0, 1, 1, 1, 0, 0, 1, 0]);
+    geometry.setAttribute("uv", new Float32BufferAttribute(uvs, 2));
+    return geometry;
+})();
+function collectProperties(keeper, modules, debugContext) {
+    for (const module of modules) {
+        if (module.requiredProperties === undefined) {
+            continue;
+        }
+        for (const key in module.requiredProperties) {
+            const existingTypeInfo = keeper[key];
+            const newTypeInfo = resolveGLSLTypeInfo(module.requiredProperties[key]);
+            if (existingTypeInfo === undefined) {
+                keeper[key] = newTypeInfo;
+            }
+            else if (existingTypeInfo.glslTypeName !== newTypeInfo.glslTypeName) {
+                throw new Error(`${debugContext}: property conflict for "${key}"`);
+            }
+        }
+    }
+}
+function collectUniforms(keeper, modules, debugContext) {
+    for (const module of modules) {
+        for (const key in module.requiredUniforms) {
+            const value = module.requiredUniforms[key];
+            const existingGLProperty = keeper[key];
+            const newPropertyTypeInfo = resolveGLSLTypeInfo(value);
+            if (existingGLProperty === undefined) {
+                keeper[key] = { value, glslTypeInfo: newPropertyTypeInfo };
+            }
+            else if (existingGLProperty.glslTypeInfo.glslTypeName !== newPropertyTypeInfo.glslTypeName) {
+                throw new Error(`${debugContext}: property conflict for "${key}"`);
+            }
+        }
+    }
+}
+function buildParticleVertexShader(uniformDeclarations, attributeDeclarations, varyingDeclarations, vertexAssignments) {
+    return `
+    #define PARTICLE_POSITION_X p_builtin[0][0]
+    #define PARTICLE_POSITION_Y p_builtin[0][1]
+    #define PARTICLE_POSITION_Z p_builtin[0][2]
+
+    #define PARTICLE_VELOCITY_X p_builtin[0][3]
+    #define PARTICLE_VELOCITY_Y p_builtin[1][0]
+    #define PARTICLE_VELOCITY_Z p_builtin[1][1]
+
+    #define PARTICLE_SCALE_X p_builtin[1][2]
+    #define PARTICLE_SCALE_Y p_builtin[1][3]
+    #define PARTICLE_SCALE_Z p_builtin[2][0]
+
+    #define PARTICLE_ROTATION p_builtin[2][1]
+    #define PARTICLE_TORQUE p_builtin[2][2]
+
+    #define PARTICLE_LIFETIME p_builtin[2][3]
+    #define PARTICLE_AGE p_builtin[3][0]
+
+    #define PARTICLE_RANDOM_A p_builtin[3][1]
+    #define PARTICLE_RANDOM_B p_builtin[3][2]
+    #define PARTICLE_RANDOM_C p_builtin[3][3]
+
+    // User attributes
+    ${attributeDeclarations.join("\n")}
+
+    // Uniforms
+    ${uniformDeclarations.join("\n")}
+
+    // Builtin varyings
+    varying vec2 p_uv;
+
+    // User varyings
+    ${varyingDeclarations.join("\n")}
+
+    void main() {
+      ${vertexAssignments.join("\n")}
+
+      p_uv = uv;
+
+      vec2 transformedPosition = position.xy;
+      transformedPosition.x *= PARTICLE_SCALE_X;
+      transformedPosition.y *= PARTICLE_SCALE_Y;
+
+      float cosR = cos(PARTICLE_ROTATION);
+      float sinR = sin(PARTICLE_ROTATION);
+
+      transformedPosition = vec2(
+        transformedPosition.x * cosR - transformedPosition.y * sinR,
+        transformedPosition.x * sinR + transformedPosition.y * cosR
+      );
+
+      vec3 center = vec3(
+        PARTICLE_POSITION_X,
+        PARTICLE_POSITION_Y,
+        PARTICLE_POSITION_Z
+      );
+
+      vec4 mvCenter = modelViewMatrix * vec4(center, 1.0);
+
+      mvCenter.xy += transformedPosition;
+
+      gl_Position = projectionMatrix * mvCenter;
+    }
+  `;
+}
+function buildParticleFragmentShader(uniformDeclarations, varyingDeclarations, sources) {
+    const renamedSources = sources.map((source, index) => {
+        return source.replace(/vec4\s+draw\s*\(\s*\)/g, `vec4 draw${index}()`);
+    });
+    let drawCalls = "";
+    for (let i = 0; i < sources.length; i++) {
+        drawCalls += i !== 0 ? " * " : "";
+        drawCalls += `draw${i}()`;
+    }
+    return `
+    // Defines
+    #define PI 3.14159265359
+    #define SRGB_SUPPORTED ${checkSRGBSupport() ? "1" : "0"}
+
+    #define PARTICLE_POSITION_X p_builtin[0][0]
+    #define PARTICLE_POSITION_Y p_builtin[0][1]
+    #define PARTICLE_POSITION_Z p_builtin[0][2]
+
+    #define PARTICLE_VELOCITY_X p_builtin[0][3]
+    #define PARTICLE_VELOCITY_Y p_builtin[1][0]
+    #define PARTICLE_VELOCITY_Z p_builtin[1][1]
+
+    #define PARTICLE_SCALE_X p_builtin[1][2]
+    #define PARTICLE_SCALE_Y p_builtin[1][3]
+    #define PARTICLE_SCALE_Z p_builtin[2][0]
+
+    #define PARTICLE_ROTATION p_builtin[2][1]
+    #define PARTICLE_TORQUE p_builtin[2][2]
+
+    #define PARTICLE_LIFETIME p_builtin[2][3]
+    #define PARTICLE_AGE p_builtin[3][0]
+
+    #define PARTICLE_RANDOM_A p_builtin[3][1]
+    #define PARTICLE_RANDOM_B p_builtin[3][2]
+    #define PARTICLE_RANDOM_C p_builtin[3][3]
+
+    // Uniforms
+    ${uniformDeclarations.join("\n")}
+
+    // Builtin varyings
+    varying vec2 p_uv;
+
+    // User varyings
+    ${varyingDeclarations.join("\n")}
+
+    #include <alphahash_pars_fragment>
+
+    // sRGB decode helper
+    vec4 srgbTexture2D(sampler2D textureSampler, vec2 uv) {
+      #if SRGB_SUPPORTED
+        return texture2D(textureSampler, uv);
+      #else
+        vec4 textureValue = texture2D(textureSampler, uv);
+        return vec4(pow(textureValue.rgb, vec3(2.2)), textureValue.a);
+      #endif
+    }
+
+    // Source must define vec4 draw() function
+    ${renamedSources.join("\n")}
+
+    void main() {
+      vec4 diffuseColor = ${drawCalls};
+      if (diffuseColor.a < 0.0035) {
+        discard;
+      }
+      #ifdef USE_ALPHAHASH
+        if (diffuseColor.a < getAlphaHashThreshold(p_position)) {
+          discard;
+        }
+      #endif
+      gl_FragColor = linearToOutputTexel(diffuseColor);
+    }
+  `;
+}
+function buildParticleMaterial(sources, uniformProperties, varyingProperties) {
+    const uniforms = {};
+    const uniformDeclarations = [];
+    const attributeDeclarations = [];
+    const varyingDeclarations = [];
+    const vertexAssignments = [];
+    for (const name in uniformProperties) {
+        const { value, glslTypeInfo } = uniformProperties[name];
+        uniforms[`p_${name}`] = { value: value instanceof FXColor ? value.toGLSLColor() : value };
+        uniformDeclarations.push(`uniform ${glslTypeInfo.glslTypeName} p_${name};`);
+    }
+    for (const name in varyingProperties) {
+        const { glslTypeName } = varyingProperties[name];
+        attributeDeclarations.push(`attribute ${glslTypeName} a_${name};`);
+        varyingDeclarations.push(`varying ${glslTypeName} p_${name};`);
+        vertexAssignments.push(`p_${name} = a_${name};`);
+    }
+    return new ShaderMaterial({
+        uniforms,
+        vertexShader: buildParticleVertexShader(uniformDeclarations, attributeDeclarations, varyingDeclarations, vertexAssignments),
+        fragmentShader: buildParticleFragmentShader(uniformDeclarations, varyingDeclarations, sources),
+        transparent: true,
+        depthWrite: false,
+        depthTest: true,
+    });
+}
+
+export { INSTANCED_PARTICLE_GEOMETRY, buildParticleFragmentShader, buildParticleMaterial, buildParticleVertexShader, collectProperties, collectUniforms };

package/dist/instancedParticle/FXInstancedParticle.d.ts

@@ -0,0 +1,17 @@
+import { InstancedBufferAttribute, Mesh } from "three";
+import { type GLProperty, type GLTypeInfo } from "./shared";
+export declare class FXInstancedParticle extends Mesh {
+    private readonly capacityStep;
+    readonly propertyBuffers: Record<string, InstancedBufferAttribute>;
+    private readonly instancedGeometry;
+    private readonly shaderMaterial;
+    private capacity;
+    constructor(sources: string[], uniforms: Record<string, GLProperty>, varyings: Record<string, GLTypeInfo>, expectedCapacity: number, capacityStep: number);
+    get instanceCount(): number;
+    createInstances(count: number): void;
+    setOrigin(x: number, y: number): void;
+    removeDeadParticles(): void;
+    drop(): void;
+    destroy(): void;
+    private ensureCapacity;
+}

package/dist/instancedParticle/FXInstancedParticle.js

@@ -0,0 +1,93 @@
+import { Mesh, InstancedBufferAttribute, StreamDrawUsage } from 'three';
+import { BUILTIN_OFFSET_AGE, BUILTIN_OFFSET_LIFETIME } from '../miscellaneous/miscellaneous.js';
+import { INSTANCED_PARTICLE_GEOMETRY, buildParticleMaterial } from './FXInstancedParticle.Internal.js';
+import { resolvePropertyUniform } from './shared.js';
+
+class FXInstancedParticle extends Mesh {
+    constructor(sources, uniforms, varyings, expectedCapacity, _private_capacityStep) {
+        const instancedGeometry = INSTANCED_PARTICLE_GEOMETRY.clone();
+        const shaderMaterial = buildParticleMaterial(sources, uniforms, varyings);
+        super(instancedGeometry, shaderMaterial);
+        this._private_capacityStep = _private_capacityStep;
+        this.propertyBuffers = {};
+        this.frustumCulled = false;
+        this.matrixAutoUpdate = false;
+        this.matrixWorldAutoUpdate = false;
+        this._private_instancedGeometry = instancedGeometry;
+        this._private_instancedGeometry.instanceCount = 0;
+        this._private_shaderMaterial = shaderMaterial;
+        this._private_capacity = Math.max(Math.ceil(expectedCapacity / this._private_capacityStep) * this._private_capacityStep, this._private_capacityStep);
+        for (const name in varyings) {
+            const { bufferSize } = varyings[name];
+            const attribute = new InstancedBufferAttribute(new Float32Array(this._private_capacity * bufferSize), bufferSize);
+            attribute.setUsage(StreamDrawUsage);
+            this._private_instancedGeometry.setAttribute(`a_${name}`, attribute);
+            this.propertyBuffers[name] = attribute;
+        }
+    }
+    get instanceCount() {
+        return this._private_instancedGeometry.instanceCount;
+    }
+    createInstances(count) {
+        const currentInstanceCount = this._private_instancedGeometry.instanceCount;
+        this._private_ensureCapacity(currentInstanceCount + count);
+        this._private_instancedGeometry.instanceCount += count;
+    }
+    setOrigin(x, y) {
+        const uniform = resolvePropertyUniform("origin", this._private_shaderMaterial);
+        uniform.value.set(x, y);
+    }
+    removeDeadParticles() {
+        const builtinBuffer = this.propertyBuffers.builtin;
+        if (builtinBuffer === undefined) {
+            return;
+        }
+        const { array: builtinArray, itemSize: builtinItemSize } = builtinBuffer;
+        const { instanceCount } = this._private_instancedGeometry;
+        let writeIndex = 0;
+        for (let readIndex = 0; readIndex < instanceCount; readIndex++) {
+            const offset = readIndex * builtinItemSize;
+            if (builtinArray[offset + BUILTIN_OFFSET_AGE] < builtinArray[offset + BUILTIN_OFFSET_LIFETIME]) {
+                if (writeIndex !== readIndex) {
+                    for (const name in this.propertyBuffers) {
+                        const attribute = this.propertyBuffers[name];
+                        const { itemSize: dataItemSize, array: dataArray } = attribute;
+                        const srcOffset = readIndex * dataItemSize;
+                        const dstOffset = writeIndex * dataItemSize;
+                        dataArray.copyWithin(dstOffset, srcOffset, srcOffset + dataItemSize);
+                        attribute.needsUpdate = true;
+                    }
+                }
+                writeIndex++;
+            }
+        }
+        this._private_instancedGeometry.instanceCount = writeIndex;
+    }
+    drop() {
+        this._private_instancedGeometry.instanceCount = 0;
+    }
+    destroy() {
+        this._private_instancedGeometry.dispose();
+        this._private_shaderMaterial.dispose();
+    }
+    _private_ensureCapacity(requiredCapacity) {
+        if (requiredCapacity <= this._private_capacity) {
+            return;
+        }
+        const newCapacity = Math.ceil(requiredCapacity / this._private_capacityStep) * this._private_capacityStep;
+        for (const name in this.propertyBuffers) {
+            const { itemSize, array, usage } = this.propertyBuffers[name];
+            const newArray = new Float32Array(newCapacity * itemSize);
+            newArray.set(array);
+            const newAttribute = new InstancedBufferAttribute(newArray, itemSize);
+            newAttribute.setUsage(usage);
+            this._private_instancedGeometry.setAttribute(`a_${name}`, newAttribute);
+            this.propertyBuffers[name] = newAttribute;
+        }
+        this._private_capacity = newCapacity;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- old three.js compatibility fix
+        this._private_instancedGeometry._maxInstanceCount = newCapacity;
+    }
+}
+
+export { FXInstancedParticle };

package/dist/instancedParticle/shared.d.ts

@@ -0,0 +1,27 @@
+import type { IUniform, ShaderMaterial } from "three";
+import { Matrix3, Matrix4, Texture, Vector2, Vector3, Vector4 } from "three";
+import { FXColor } from "../color/FXColor";
+import type { FXTransparencyMode } from "../miscellaneous/FXTransparencyMode";
+export type FXProperty = Texture | FXColor | Vector2 | Vector3 | Vector4 | Matrix3 | Matrix4 | number;
+export type FXPropertyName = "Texture" | "UIColor" | "Vector2" | "Vector3" | "Vector4" | "Matrix3" | "Matrix4" | "number";
+export type FXPropertyConstructor = typeof Texture | typeof FXColor | typeof Vector2 | typeof Vector3 | typeof Vector4 | typeof Matrix3 | typeof Matrix4 | NumberConstructor;
+export type FXPropertyCopyTo = FXColor | Vector2 | Vector3 | Vector4 | Matrix3 | Matrix4;
+export type FXPropertyCopyFrom = FXColor & Vector2 & Vector3 & Vector4 & Matrix3 & Matrix4;
+export interface GLTypeInfo {
+    glslTypeName: string;
+    bufferSize: number;
+    instantiable: boolean;
+}
+export interface GLProperty {
+    value: FXProperty;
+    glslTypeInfo: GLTypeInfo;
+}
+export interface PlaneData {
+    source: string;
+    properties: Record<string, GLProperty>;
+    transform: Matrix4;
+    visibility: boolean;
+    transparency: FXTransparencyMode;
+}
+export declare function resolveGLSLTypeInfo(value: FXProperty | FXPropertyName | FXPropertyConstructor): GLTypeInfo;
+export declare function resolvePropertyUniform(name: string, material: ShaderMaterial): IUniform<FXProperty>;