aether-engine 1.0.0

package/src/systems/Animation3DSystem.ts

@@ -0,0 +1,148 @@
+import { System } from "../ecs/System";
+import { Animator3D } from "../components/Animator3D";
+import { Transform } from "../components/Transform";
+import { mat4, quat, vec3 } from "gl-matrix";
+import { GLTFNode } from "../utils/GLTFLoader";
+
+export class Animation3DSystem extends System {
+	update(dt: number): void {
+		const animators = this.world.query(Animator3D);
+
+		for (const entity of animators) {
+			const animator = this.world.getComponent(entity, Animator3D)!;
+			const rootTransform = this.world.getComponent(entity, Transform);
+
+			if (animator.isPlaying && animator.currentAnimation) {
+				const anim = animator.animations.get(animator.currentAnimation);
+				if (anim) {
+					// Advance time
+					animator.time += dt * animator.speed;
+					
+					if (animator.time > anim.duration) {
+						if (animator.loop) {
+							animator.time %= anim.duration;
+						} else {
+							animator.time = anim.duration;
+							animator.isPlaying = false;
+						}
+					}
+
+			// 1. Evaluate keyframe splines and apply to node Base TRS
+			for (const channel of anim.channels) {
+				const node = animator.nodes[channel.node];
+				if (!node) continue;
+
+				// Binary search / scan for current timestamp bounds
+				let frameIdx = 0;
+				for (let i = 0; i < channel.timestamps.length - 1; i++) {
+					if (animator.time >= channel.timestamps[i] && animator.time <= channel.timestamps[i + 1]) {
+						frameIdx = i;
+						break;
+					}
+				}
+
+				if (frameIdx >= channel.timestamps.length - 1) {
+					// Clamp to end
+					const lastIdx = channel.timestamps.length - 1;
+					if (channel.path === "translation") {
+						const offset = lastIdx * 3;
+						vec3.set(node.translation, channel.values[offset], channel.values[offset+1], channel.values[offset+2]);
+					} else if (channel.path === "rotation") {
+						const offset = lastIdx * 4;
+						quat.set(node.rotation, channel.values[offset], channel.values[offset+1], channel.values[offset+2], channel.values[offset+3]);
+					} else if (channel.path === "scale") {
+						const offset = lastIdx * 3;
+						vec3.set(node.scale, channel.values[offset], channel.values[offset+1], channel.values[offset+2]);
+					}
+					continue;
+				}
+
+				// Interpolate
+				const t0 = channel.timestamps[frameIdx];
+				const t1 = channel.timestamps[frameIdx + 1];
+				const factor = (animator.time - t0) / (t1 - t0);
+
+				if (channel.path === "translation") {
+					const o1 = frameIdx * 3;
+					const o2 = (frameIdx + 1) * 3;
+					vec3.lerp(
+						node.translation,
+						vec3.fromValues(channel.values[o1], channel.values[o1+1], channel.values[o1+2]),
+						vec3.fromValues(channel.values[o2], channel.values[o2+1], channel.values[o2+2]),
+						factor
+					);
+				} else if (channel.path === "rotation") {
+					const o1 = frameIdx * 4;
+					const o2 = (frameIdx + 1) * 4;
+					quat.slerp(
+						node.rotation,
+						quat.fromValues(channel.values[o1], channel.values[o1+1], channel.values[o1+2], channel.values[o1+3]),
+						quat.fromValues(channel.values[o2], channel.values[o2+1], channel.values[o2+2], channel.values[o2+3]),
+						factor
+					);
+					} else if (channel.path === "scale") {
+						const o1 = frameIdx * 3;
+						const o2 = (frameIdx + 1) * 3;
+						vec3.lerp(
+							node.scale,
+							vec3.fromValues(channel.values[o1], channel.values[o1+1], channel.values[o1+2]),
+							vec3.fromValues(channel.values[o2], channel.values[o2+1], channel.values[o2+2]),
+							factor
+						);
+					}
+				}
+				} // End of if (anim)
+			} // End of if (isPlaying)
+
+			// 2. Compute local matrices
+			for (let i = 0; i < animator.nodes.length; i++) {
+				const node = animator.nodes[i];
+				mat4.fromRotationTranslationScale(animator.localTransforms[i], node.rotation, node.translation, node.scale);
+			}
+
+			// 3. Compute global hierarchical matrices
+			// Find root nodes (parent === -1)
+			const roots = animator.nodes.filter(n => n.parent === -1);
+			for (const r of roots) {
+				this.traverseHierarchy(r, rootTransform ? rootTransform.matrix : mat4.create(), animator);
+			}
+
+			// 4. Calculate Final Joint Matrices for shader skinning
+			// Assume single skin for now
+			if (animator.skins.length > 0) {
+				const skin = animator.skins[0];
+				
+				for (let j = 0; j < skin.joints.length; j++) {
+					const nodeIdx = skin.joints[j];
+					const globalMat = animator.nodes[nodeIdx].globalMatrix;
+					const ibm = skin.inverseBindMatrices[j];
+					
+					// copy into finalJointMat
+					const finalJointMat = mat4.create();
+					mat4.multiply(finalJointMat, globalMat, ibm);
+					
+					// If the entity itself has a transform, we must remove it from the final bone calculation because the vertex shader multiplies by uModelMatrix automatically.
+					if (rootTransform && rootTransform.matrix) {
+						const invModel = mat4.create();
+						mat4.invert(invModel, rootTransform.matrix);
+						mat4.multiply(finalJointMat, invModel, finalJointMat);
+					}
+
+					// Copy into Float32Array
+					for (let f = 0; f < 16; f++) {
+						animator.jointMatrices[j * 16 + f] = finalJointMat[f];
+					}
+				}
+			}
+		}
+	}
+
+	private traverseHierarchy(node: GLTFNode, parentGlobalMat: mat4, animator: Animator3D) {
+		const localMat = animator.localTransforms[node.id];
+		mat4.multiply(node.globalMatrix, parentGlobalMat, localMat);
+
+		for (const childId of node.children) {
+			this.traverseHierarchy(animator.nodes[childId], node.globalMatrix, animator);
+		}
+	}
+}

package/src/systems/AnimationSystem.ts

@@ -0,0 +1,58 @@
+import { SpriteAnimator } from "../components/SpriteAnimator";
+import { SpriteRenderer } from "../components/SpriteRenderer";
+import { System } from "../ecs/System";
+
+export class AnimationSystem extends System {
+	update(dt: number) {
+		const entities = this.world.query(SpriteRenderer, SpriteAnimator);
+
+		for (const entity of entities) {
+			const renderer = this.world.getComponent(entity, SpriteRenderer)!;
+			const animator = this.world.getComponent(entity, SpriteAnimator)!;
+
+			if (!animator.currentAnimation) continue;
+
+			const anim = animator.animations.get(animator.currentAnimation);
+			if (!anim) continue;
+
+			if (animator.isPlaying && anim.frames.length > 1) {
+				animator.timeAccumulator += dt;
+				const frameDuration = 1.0 / anim.fps;
+
+				while (animator.timeAccumulator >= frameDuration) {
+					animator.timeAccumulator -= frameDuration;
+					animator.currentFrameIndex =
+						(animator.currentFrameIndex + 1) % anim.frames.length;
+				}
+			}
+
+			// Update SpriteRenderer UVs
+			const frameData = anim.frames[animator.currentFrameIndex];
+
+			if (animator.atlasFrames && animator.atlasSize) {
+				const rect = animator.atlasFrames[frameData];
+				renderer.uvScale[0] = rect.w / animator.atlasSize.w;
+				renderer.uvScale[1] = rect.h / animator.atlasSize.h;
+
+				renderer.uvOffset[0] = rect.x / animator.atlasSize.w;
+				renderer.uvOffset[1] = rect.y / animator.atlasSize.h;
+			} else {
+				const col = frameData % animator.columns;
+				const row = Math.floor(frameData / animator.columns);
+
+				const uvW = 1.0 / animator.columns;
+				const uvH = 1.0 / animator.rows;
+
+				renderer.uvScale[0] = uvW;
+				renderer.uvScale[1] = uvH;
+				renderer.uvOffset[0] = col * uvW;
+				renderer.uvOffset[1] = row * uvH;
+			}
+
+			if (animator.flipX) {
+				renderer.uvOffset[0] += renderer.uvScale[0];
+				renderer.uvScale[0] *= -1;
+			}
+		}
+	}
+}

package/src/systems/AudioSystem.ts

@@ -0,0 +1,62 @@
+import { AudioEngine } from "../audio/AudioEngine";
+import { AudioSource } from "../components/AudioSource";
+import { System } from "../ecs/System";
+// Optional positional tracking with Transform
+// import { Transform } from "../components/Transform";
+
+export class AudioSystem extends System {
+	update(_dt: number) {
+		if (!AudioEngine.hasUserInteracted) return;
+
+		const entities = this.world.query(AudioSource);
+
+		for (const entity of entities) {
+			const source = this.world.getComponent(entity, AudioSource)!;
+
+			if (source.shouldPlay && !source.isPlaying) {
+				const buffer = AudioEngine.getBuffer(source.bufferName);
+				if (buffer) {
+					const ctx = AudioEngine.context!;
+					if (!ctx) continue;
+
+					const node = ctx.createBufferSource();
+					node.buffer = buffer;
+					node.loop = source.loop;
+
+					const gain = ctx.createGain();
+					gain.gain.value = source.volume;
+
+					node.connect(gain);
+					gain.connect(ctx.destination);
+
+					node.start();
+
+					source._sourceNode = node;
+					source._gainNode = gain;
+					source.isPlaying = true;
+
+					node.onended = () => {
+						// If loop is false, the track is over naturally
+						source.isPlaying = false;
+						source.shouldPlay = false;
+						source._sourceNode = undefined;
+						source._gainNode = undefined;
+					};
+				} else {
+					console.warn(
+						`Audio buffer '${source.bufferName}' not loaded in AudioEngine yet.`,
+					);
+				}
+			} else if (!source.shouldPlay && source.isPlaying) {
+				source._sourceNode?.stop();
+				source.isPlaying = false;
+				source._sourceNode = undefined;
+				source._gainNode = undefined;
+			}
+
+			if (source._gainNode) {
+				source._gainNode.gain.value = source.volume;
+			}
+		}
+	}
+}

package/src/systems/LightingSystem.ts

@@ -0,0 +1,114 @@
+import { Light } from "../components/Light";
+import { ParticleEmitter } from "../components/ParticleEmitter";
+import { Transform } from "../components/Transform";
+import { System } from "../ecs/System";
+
+export class LightingSystem extends System {
+	// Globally accessible light data for Renderer to bind into uniform bounds
+	public static MAX_LIGHTS = 16;
+	public static lightPositions = new Float32Array(
+		LightingSystem.MAX_LIGHTS * 3,
+	);
+	public static lightColors = new Float32Array(LightingSystem.MAX_LIGHTS * 3);
+	public static lightParams = new Float32Array(LightingSystem.MAX_LIGHTS * 4); // [intensity, radius, elevation, flickerIntensity]
+	public static ambientColor = new Float32Array(3);
+	public static activePointLights = 0;
+
+	// High Performance Particle Light track
+	public static MAX_PARTICLE_LIGHTS = 64;
+	public static activeParticleLights = 0;
+	public static particleLightPositions = new Float32Array(LightingSystem.MAX_PARTICLE_LIGHTS * 4);
+	public static particleLightColors = new Float32Array(LightingSystem.MAX_PARTICLE_LIGHTS * 3);
+
+	update(_dt: number) {
+		const lights = this.world.query(Transform, Light);
+
+		LightingSystem.activePointLights = 0;
+		LightingSystem.ambientColor[0] = 0;
+		LightingSystem.ambientColor[1] = 0;
+		LightingSystem.ambientColor[2] = 0;
+
+		for (const entity of lights) {
+			const light = this.world.getComponent(entity, Light)!;
+			const transform = this.world.getComponent(entity, Transform)!;
+
+			if (light.type === "Ambient") {
+				LightingSystem.ambientColor[0] += light.color.rNorm * light.intensity;
+				LightingSystem.ambientColor[1] += light.color.gNorm * light.intensity;
+				LightingSystem.ambientColor[2] += light.color.bNorm * light.intensity;
+			} else if (light.type === "Point") {
+				if (LightingSystem.activePointLights >= LightingSystem.MAX_LIGHTS)
+					continue;
+
+				const i = LightingSystem.activePointLights;
+				transform.updateMatrix();
+
+				// Get absolute world position from matrix
+				const mat = transform.matrix;
+
+				LightingSystem.lightPositions[i * 3] = mat[12] + light.positionOffset[0];
+				LightingSystem.lightPositions[i * 3 + 1] = mat[13] + light.positionOffset[1];
+				LightingSystem.lightPositions[i * 3 + 2] = mat[14] + light.elevation + light.positionOffset[2];
+
+				LightingSystem.lightColors[i * 3] = light.color.rNorm;
+				LightingSystem.lightColors[i * 3 + 1] = light.color.gNorm;
+				LightingSystem.lightColors[i * 3 + 2] = light.color.bNorm;
+
+				LightingSystem.lightParams[i * 4] = light.intensity;
+				LightingSystem.lightParams[i * 4 + 1] = light.radius;
+				LightingSystem.lightParams[i * 4 + 2] = light.elevation;
+				LightingSystem.lightParams[i * 4 + 3] = light.flickerIntensity;
+
+				LightingSystem.activePointLights++;
+			}
+		}
+
+		// Process Particle Lights sequentially bounding at limits safely
+		LightingSystem.activeParticleLights = 0;
+		const emitters = this.world.query(Transform, ParticleEmitter);
+		
+		for (const entity of emitters) {
+			if (LightingSystem.activeParticleLights >= LightingSystem.MAX_PARTICLE_LIGHTS) break;
+			
+			const emitter = this.world.getComponent(entity, ParticleEmitter)!;
+			const transform = this.world.getComponent(entity, Transform)!;
+			transform.updateMatrix();
+			const mat = transform.matrix;
+			
+			// We iterate partially mapping a sub-sample of particles to illuminate local pools safely
+			for (let p = 0; p < emitter.activeCount; p++) {
+				if (LightingSystem.activeParticleLights >= LightingSystem.MAX_PARTICLE_LIGHTS) break;
+				
+				// Standard skip to reduce visual noise by skipping subsets of particles? No, map as many as limit allows!
+				const progress = 1.0 - emitter.pLife[p] / emitter.lifespan;
+				
+				// Grab colors
+				const r = emitter.startColor.rNorm + (emitter.endColor.rNorm - emitter.startColor.rNorm) * progress;
+				const g = emitter.startColor.gNorm + (emitter.endColor.gNorm - emitter.startColor.gNorm) * progress;
+				const b = emitter.startColor.bNorm + (emitter.endColor.bNorm - emitter.startColor.bNorm) * progress;
+				
+				// Calculate world pos of particle implicitly
+				const px = mat[12] + emitter.pPosX[p];
+				const py = mat[13] + emitter.pPosY[p];
+				const pz = mat[14] + emitter.pPosZ[p];
+				
+				const idxColor = LightingSystem.activeParticleLights * 3;
+				const idxPos = LightingSystem.activeParticleLights * 4;
+				LightingSystem.particleLightPositions[idxPos] = px;
+				LightingSystem.particleLightPositions[idxPos+1] = py;
+				// Fire flies slightly higher than local y, so track Z as actual physical coordinate correctly 
+				LightingSystem.particleLightPositions[idxPos+2] = pz; 
+				LightingSystem.particleLightPositions[idxPos+3] = emitter.lightRadius;
+				
+				// Multiply color by dynamic intensity to provide glow that fades slowly IN and formally OUT over life
+				const fade = 4.0 * progress * (1.0 - progress);
+				const intensity = Math.max(fade, 0.0) * 0.8;
+				LightingSystem.particleLightColors[idxColor] = r * intensity;
+				LightingSystem.particleLightColors[idxColor+1] = g * intensity;
+				LightingSystem.particleLightColors[idxColor+2] = b * intensity;
+				
+				LightingSystem.activeParticleLights++;
+			}
+		}
+	}
+}

package/src/systems/ParticleSystem.ts

@@ -0,0 +1,278 @@
+import { Camera } from "../components/Camera";
+import { MeshRenderer } from "../components/MeshRenderer";
+import { ParticleEmitter } from "../components/ParticleEmitter";
+import { Transform } from "../components/Transform";
+import { System } from "../ecs/System";
+import { ParticleMaterial } from "../renderer/ParticleMaterial";
+
+function evalSuperformula(
+	m: number,
+	n1: number,
+	n2: number,
+	n3: number,
+	a: number,
+	b: number,
+	phi: number,
+): number {
+	let t1 = Math.abs(Math.cos((m * phi) / 4) / a);
+	t1 = t1 ** n2;
+	let t2 = Math.abs(Math.sin((m * phi) / 4) / b);
+	t2 = t2 ** n3;
+	const r = (t1 + t2) ** (1 / n1);
+	if (Math.abs(r) === 0) {
+		return 0;
+	} else {
+		return 1 / r;
+	}
+}
+
+export class ParticleSystem extends System {
+	update(dt: number) {
+		const emitters = this.world.query(Transform, ParticleEmitter);
+		
+		let right = [1, 0, 0];
+		let up = [0, 1, 0];
+		
+		const cameras = this.world.query(Transform, Camera);
+		if (cameras.length > 0) {
+			const camTrans = this.world.getComponent(cameras[0], Transform)!;
+			camTrans.updateMatrix();
+			right = [camTrans.matrix[0], camTrans.matrix[1], camTrans.matrix[2]];
+			up = [camTrans.matrix[4], camTrans.matrix[5], camTrans.matrix[6]];
+		}
+
+		for (const entity of emitters) {
+			const emitter = this.world.getComponent(entity, ParticleEmitter)!;
+			// Lazy initialization of the backing MeshRenderer for drawing
+			let mesh = this.world.getComponent(entity, MeshRenderer);
+
+			if (!mesh) {
+				// Pre-calculate full buffers for up to maxParticles
+				// 4 vertices per quad, 3 floats per pos, 4 floats per color, 2 per UV
+				const positions = new Array(emitter.maxParticles * 4 * 3).fill(0);
+				const colors = new Array(emitter.maxParticles * 4 * 4).fill(1);
+				const uvs = new Array(emitter.maxParticles * 4 * 2).fill(0);
+				const indices = new Array(emitter.maxParticles * 6).fill(0);
+
+				for (let i = 0; i < emitter.maxParticles; i++) {
+					const ic = i * 4;
+					// standard quad CCW UVs
+					const iv = i * 8;
+					uvs[iv] = 0;
+					uvs[iv + 1] = 0;
+					uvs[iv + 2] = 1;
+					uvs[iv + 3] = 0;
+					uvs[iv + 4] = 1;
+					uvs[iv + 5] = 1;
+					uvs[iv + 6] = 0;
+					uvs[iv + 7] = 1;
+
+					const ii = i * 6;
+					indices[ii] = ic;
+					indices[ii + 1] = ic + 1;
+					indices[ii + 2] = ic + 2;
+					indices[ii + 3] = ic;
+					indices[ii + 4] = ic + 2;
+					indices[ii + 5] = ic + 3;
+				}
+
+				// Assign explicit material parameter passing from emitter configurations dynamically tailoring properties
+				let targetMat = emitter.material;
+				if (!targetMat) {
+					targetMat = new ParticleMaterial();
+					targetMat.blendMode = emitter.blendMode;
+					targetMat.depthWrite = emitter.depthWrite;
+					if (targetMat instanceof ParticleMaterial) {
+						targetMat.uniforms.uShape = new Int32Array([emitter.shape === "circle" ? 1 : 0]);
+					}
+				}
+
+				mesh = this.world.addComponent(
+					entity,
+					MeshRenderer,
+					positions,
+					undefined,
+					colors,
+					uvs,
+					indices,
+					targetMat
+				);
+			}
+
+			// Integration
+			const posData = mesh.positions;
+			const colData = mesh.colors!;
+
+			// 1. Spawning
+			if (emitter.emissionRate > 0) {
+				emitter.emitAccumulator += emitter.emissionRate * dt;
+				while (
+					emitter.emitAccumulator >= 1.0 &&
+					emitter.activeCount < emitter.maxParticles
+				) {
+					emitter.emitAccumulator -= 1.0;
+					// Spawn one
+					const i = emitter.activeCount;
+					emitter.pLife[i] = emitter.lifespan;
+
+					const angle = Math.random() * Math.PI * 2;
+					const speed =
+						emitter.minSpeed +
+						Math.random() * (emitter.maxSpeed - emitter.minSpeed);
+
+					let sfRadius = 1.0;
+					if (emitter.useSuperformula) {
+						sfRadius = evalSuperformula(
+							emitter.superformula.m,
+							emitter.superformula.n1,
+							emitter.superformula.n2,
+							emitter.superformula.n3,
+							emitter.superformula.a,
+							emitter.superformula.b,
+							angle,
+						);
+					}
+
+					if (
+						emitter.useSuperformula &&
+						emitter.superformulaMode === "position"
+					) {
+						emitter.pPosX[i] = Math.cos(angle) * sfRadius;
+						emitter.pPosY[i] = Math.sin(angle) * sfRadius;
+						emitter.pPosZ[i] = 0;
+
+						// In position mode, standard speed projects outwards
+						emitter.pVelX[i] = Math.cos(angle) * speed;
+						emitter.pVelY[i] = Math.sin(angle) * speed;
+						emitter.pVelZ[i] = 0;
+					} else {
+						emitter.pPosX[i] = 0;
+						emitter.pPosY[i] = 0;
+						emitter.pPosZ[i] = 0;
+
+						const appliedSpeed =
+							emitter.useSuperformula && emitter.superformulaMode === "velocity"
+								? speed * sfRadius
+								: speed;
+
+						emitter.pVelX[i] = Math.cos(angle) * appliedSpeed;
+						emitter.pVelY[i] = Math.sin(angle) * appliedSpeed;
+						emitter.pVelZ[i] = 0;
+					}
+
+					emitter.activeCount++;
+				}
+			}
+
+			// 2. Update logic & construct mesh arrays
+			for (let i = 0; i < emitter.activeCount; i++) {
+				emitter.pLife[i] -= dt;
+
+				if (emitter.pLife[i] <= 0) {
+					// Swap and pop
+					emitter.activeCount--;
+					const last = emitter.activeCount;
+					if (i !== last) {
+						emitter.pLife[i] = emitter.pLife[last];
+						emitter.pPosX[i] = emitter.pPosX[last];
+						emitter.pPosY[i] = emitter.pPosY[last];
+						emitter.pPosZ[i] = emitter.pPosZ[last];
+						emitter.pVelX[i] = emitter.pVelX[last];
+						emitter.pVelY[i] = emitter.pVelY[last];
+						emitter.pVelZ[i] = emitter.pVelZ[last];
+					}
+					i--; // check swapped item next
+					continue;
+				}
+
+				// Integration
+				emitter.pPosX[i] += emitter.pVelX[i] * dt;
+				emitter.pPosY[i] += emitter.pVelY[i] * dt;
+				emitter.pPosZ[i] += emitter.pVelZ[i] * dt;
+
+				// Build quads into Mesh
+				const progress = 1.0 - emitter.pLife[i] / emitter.lifespan;
+				const size =
+					emitter.startSize + (emitter.endSize - emitter.startSize) * progress;
+				const hs = size / 2;
+
+				const px = emitter.pPosX[i];
+				const py = emitter.pPosY[i];
+				const pz = emitter.pPosZ[i];
+
+				const baseV = i * 12; // 4 vertices * 3
+
+				if (emitter.billboard) {
+					const rx = right[0] * hs;
+					const ry = right[1] * hs;
+					const rz = right[2] * hs;
+
+					const ux = up[0] * hs;
+					const uy = up[1] * hs;
+					const uz = up[2] * hs;
+
+					posData[baseV] = px - rx - ux;
+					posData[baseV + 1] = py - ry - uy;
+					posData[baseV + 2] = pz - rz - uz;
+
+					posData[baseV + 3] = px + rx - ux;
+					posData[baseV + 4] = py + ry - uy;
+					posData[baseV + 5] = pz + rz - uz;
+
+					posData[baseV + 6] = px + rx + ux;
+					posData[baseV + 7] = py + ry + uy;
+					posData[baseV + 8] = pz + rz + uz;
+
+					posData[baseV + 9] = px - rx + ux;
+					posData[baseV + 10] = py - ry + uy;
+					posData[baseV + 11] = pz - rz + uz;
+				} else {
+					posData[baseV] = px - hs;
+					posData[baseV + 1] = py - hs;
+					posData[baseV + 2] = pz;
+					
+					posData[baseV + 3] = px + hs;
+					posData[baseV + 4] = py - hs;
+					posData[baseV + 5] = pz;
+					
+					posData[baseV + 6] = px + hs;
+					posData[baseV + 7] = py + hs;
+					posData[baseV + 8] = pz;
+					
+					posData[baseV + 9] = px - hs;
+					posData[baseV + 10] = py + hs;
+					posData[baseV + 11] = pz;
+				}
+
+				const sr = emitter.startColor.rNorm;
+				const sg = emitter.startColor.gNorm;
+				const sb = emitter.startColor.bNorm;
+				const sa = emitter.startColor.aNorm;
+				const er = emitter.endColor.rNorm;
+				const eg = emitter.endColor.gNorm;
+				const eb = emitter.endColor.bNorm;
+				const ea = emitter.endColor.aNorm;
+
+				const r = sr + (er - sr) * progress;
+				const g = sg + (eg - sg) * progress;
+				const b = sb + (eb - sb) * progress;
+				const a = sa + (ea - sa) * progress;
+
+				const baseC = i * 16;
+				for (let v = 0; v < 4; v++) {
+					const cOff = baseC + v * 4;
+					colData[cOff] = r;
+					colData[cOff + 1] = g;
+					colData[cOff + 2] = b;
+					colData[cOff + 3] = a;
+				}
+			}
+
+			// Update mesh draw count directly to draw only active quads
+			mesh.indexCount = emitter.activeCount * 6;
+
+			// Mark as dirty so WebGLRenderer pushes Float32Array into Buffer array
+			mesh.isDirty = true;
+		}
+	}
+}