sparcoon 0.0.2 → 0.0.4

package/dist/elements/FXEmitter.d.ts

@@ -8,6 +8,7 @@ export interface FXEmitterOptions {
     capacityStep: number;
     automaticallyDestroyModules: boolean;
     blending: Blending;
+    useAlphaHashing: boolean;
 }
 export declare class FXEmitter extends Object3D {
     private readonly spawnSequence;

package/dist/elements/FXEmitter.js

@@ -1,4 +1,4 @@
-import { Object3D, Vector2, NormalBlending } from 'three';
+import { Object3D, NormalBlending } from 'three';
 import { FXInstancedParticle } from '../instancedParticle/FXInstancedParticle.js';
 import { collectProperties, collectUniforms } from '../instancedParticle/FXInstancedParticle.Internal.js';
 import { resolveGLSLTypeInfo } from '../instancedParticle/shared.js';
@@ -76,11 +76,9 @@ class FXEmitter extends Object3D {
         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") },
-        };
+        const collectedUniforms = {};
         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, options.blending ?? NormalBlending);
+        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, options.blending ?? NormalBlending, options.useAlphaHashing ?? false);
         this.automaticallyDestroyModules =
             options.automaticallyDestroyModules ?? EMITTER_DEFAULT_AUTOMATICALLY_DESTROY_MODULES;
         this.add(this._private_mesh);

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

@@ -10,4 +10,4 @@ export declare function collectUniforms(keeper: Record<string, GLProperty>, modu
 }[], 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>, blending: Blending): ShaderMaterial;
+export declare function buildParticleMaterial(sources: string[], uniformProperties: Record<string, GLProperty>, varyingProperties: Record<string, GLTypeInfo>, blending: Blending, useAlphaHashing: boolean): ShaderMaterial;

package/dist/instancedParticle/FXInstancedParticle.Internal.js

@@ -185,7 +185,7 @@ function buildParticleFragmentShader(uniformDeclarations, varyingDeclarations, s
     }
   `;
 }
-function buildParticleMaterial(sources, uniformProperties, varyingProperties, blending) {
+function buildParticleMaterial(sources, uniformProperties, varyingProperties, blending, useAlphaHashing) {
     const uniforms = {};
     const uniformDeclarations = [];
     const attributeDeclarations = [];
@@ -209,6 +209,7 @@ function buildParticleMaterial(sources, uniformProperties, varyingProperties, bl
         transparent: true,
         depthWrite: false,
         depthTest: true,
+        alphaHash: useAlphaHashing,
         blending,
     });
 }

package/dist/instancedParticle/FXInstancedParticle.d.ts

@@ -1,16 +1,15 @@
 import type { Blending } from "three";
 import { InstancedBufferAttribute, Mesh } from "three";
-import { type GLProperty, type GLTypeInfo } from "./shared";
+import type { GLProperty, 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, blending: Blending);
+    constructor(sources: string[], uniforms: Record<string, GLProperty>, varyings: Record<string, GLTypeInfo>, expectedCapacity: number, capacityStep: number, blending: Blending, useAlphaHashing: boolean);
     get instanceCount(): number;
     createInstances(count: number): void;
-    setOrigin(x: number, y: number): void;
     removeDeadParticles(): void;
     drop(): void;
     destroy(): void;

package/dist/instancedParticle/FXInstancedParticle.js

@@ -1,18 +1,15 @@
 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, blending) {
+    constructor(sources, uniforms, varyings, expectedCapacity, _private_capacityStep, blending, useAlphaHashing) {
         const instancedGeometry = INSTANCED_PARTICLE_GEOMETRY.clone();
-        const shaderMaterial = buildParticleMaterial(sources, uniforms, varyings, blending);
+        const shaderMaterial = buildParticleMaterial(sources, uniforms, varyings, blending, useAlphaHashing);
         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;
@@ -33,10 +30,6 @@ class FXInstancedParticle extends Mesh {
         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) {

package/dist/instancedParticle/shared.js

@@ -112,12 +112,5 @@ function resolveGLSLTypeInfo(value) {
     }
     throw new Error(`resolveGLSLTypeInfo.value: unsupported property type`);
 }
-function resolvePropertyUniform(name, material) {
-    const uniform = material.uniforms[`p_${name}`];
-    if (uniform === undefined) {
-        throw new Error(`resolvePropertyUniform.name: unknown uniform`);
-    }
-    return uniform;
-}
 
-export { resolveGLSLTypeInfo, resolvePropertyUniform };
+export { resolveGLSLTypeInfo };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sparcoon",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "",
   "keywords": [
     "particles",