aether-engine 1.0.0

package/src/systems/PhysicsSystem.ts

@@ -0,0 +1,211 @@
+import { vec3 } from "gl-matrix";
+import { Collider } from "../components/Collider";
+import { RigidBody } from "../components/RigidBody";
+import { Transform } from "../components/Transform";
+import { System } from "../ecs/System";
+
+const GRAVITY = -9.81;
+
+export class PhysicsSystem extends System {
+	update(dt: number) {
+		const bodies = this.world.query(Transform, RigidBody);
+
+		for (const entity of bodies) {
+			const rb = this.world.getComponent(entity, RigidBody)!;
+			const transform = this.world.getComponent(entity, Transform)!;
+
+			if (rb.isKinematic) continue;
+
+			rb.acceleration[1] = GRAVITY * rb.gravityScale;
+
+			rb.velocity[0] += rb.acceleration[0] * dt;
+			rb.velocity[1] += rb.acceleration[1] * dt;
+			rb.velocity[2] += rb.acceleration[2] * dt;
+
+			transform.localPosition[0] += rb.velocity[0] * dt;
+			transform.localPosition[1] += rb.velocity[1] * dt;
+			transform.localPosition[2] += rb.velocity[2] * dt;
+
+			transform.updateMatrix();
+		}
+
+		const collidersEntities = this.world.query(Transform, Collider);
+
+		// Track previous collisions and clear current state
+		const previousCollisionsMap = new Map<number, number[]>();
+		for (const entity of collidersEntities) {
+			const collider = this.world.getComponent(entity, Collider)!;
+			previousCollisionsMap.set(entity, [...collider.collisions]);
+			collider.collisions.length = 0;
+			collider.enterCollisions.length = 0;
+			collider.exitCollisions.length = 0;
+		}
+		for (let i = 0; i < collidersEntities.length; i++) {
+			const e1 = collidersEntities[i];
+			const t1 = this.world.getComponent(e1, Transform)!;
+			const c1 = this.world.getComponent(e1, Collider)!;
+			const r1 = this.world.getComponent(e1, RigidBody);
+
+			for (let j = i + 1; j < collidersEntities.length; j++) {
+				const e2 = collidersEntities[j];
+				const t2 = this.world.getComponent(e2, Transform)!;
+				const c2 = this.world.getComponent(e2, Collider)!;
+				const r2 = this.world.getComponent(e2, RigidBody);
+
+				if (c1.type === "AABB" && c2.type === "AABB") {
+					// Skip static-to-static overlap checks. Overlaps are only relevant if at least one is dynamic.
+					if (!r1 && !r2) continue;
+
+					if (this.checkAABBOverlap(t1, c1, t2, c2)) {
+						c1.collisions.push(e2);
+						c2.collisions.push(e1);
+
+						// Only resolve if NEITHER is a trigger and at least one is dynamic
+						if (!c1.isTrigger && !c2.isTrigger) {
+							if ((!r1 || r1.isKinematic) && (!r2 || r2.isKinematic)) continue;
+							this.resolveAABBOverlap(t1, c1, r1, t2, c2, r2);
+						}
+					}
+				}
+			}
+		}
+
+		// Compute enter and exit collisions
+		for (const entity of collidersEntities) {
+			const collider = this.world.getComponent(entity, Collider)!;
+			const prev = previousCollisionsMap.get(entity) || [];
+
+			for (const colEntity of collider.collisions) {
+				if (!prev.includes(colEntity)) {
+					collider.enterCollisions.push(colEntity);
+				}
+			}
+
+			for (const oldColEntity of prev) {
+				if (!collider.collisions.includes(oldColEntity)) {
+					collider.exitCollisions.push(oldColEntity);
+				}
+			}
+		}
+	}
+
+	private checkAABBOverlap(
+		t1: Transform,
+		c1: Collider,
+		t2: Transform,
+		c2: Collider,
+	): boolean {
+		const p1 = vec3.create();
+		vec3.add(p1, t1.position, c1.centerOffset);
+
+		const p2 = vec3.create();
+		vec3.add(p2, t2.position, c2.centerOffset);
+
+		const h1x = (c1.size[0] * Math.abs(t1.scale[0])) / 2;
+		const h1y = (c1.size[1] * Math.abs(t1.scale[1])) / 2;
+		const h1z = (c1.size[2] * Math.abs(t1.scale[2])) / 2;
+
+		const h2x = (c2.size[0] * Math.abs(t2.scale[0])) / 2;
+		const h2y = (c2.size[1] * Math.abs(t2.scale[1])) / 2;
+		const h2z = (c2.size[2] * Math.abs(t2.scale[2])) / 2;
+
+		const dx = p1[0] - p2[0];
+		const dy = p1[1] - p2[1];
+		const dz = p1[2] - p2[2];
+
+		const ox = h1x + h2x - Math.abs(dx);
+		const oy = h1y + h2y - Math.abs(dy);
+		const oz = h1z + h2z - Math.abs(dz);
+
+		return ox > 0 && oy > 0 && oz > 0;
+	}
+
+	private resolveAABBOverlap(
+		t1: Transform,
+		c1: Collider,
+		r1: RigidBody | undefined,
+		t2: Transform,
+		c2: Collider,
+		r2: RigidBody | undefined,
+	) {
+		const p1 = vec3.create();
+		vec3.add(p1, t1.position, c1.centerOffset);
+
+		const p2 = vec3.create();
+		vec3.add(p2, t2.position, c2.centerOffset);
+
+		const h1x = (c1.size[0] * Math.abs(t1.scale[0])) / 2;
+		const h1y = (c1.size[1] * Math.abs(t1.scale[1])) / 2;
+		const h1z = (c1.size[2] * Math.abs(t1.scale[2])) / 2;
+
+		const h2x = (c2.size[0] * Math.abs(t2.scale[0])) / 2;
+		const h2y = (c2.size[1] * Math.abs(t2.scale[1])) / 2;
+		const h2z = (c2.size[2] * Math.abs(t2.scale[2])) / 2;
+
+		const dx = p1[0] - p2[0];
+		const dy = p1[1] - p2[1];
+		const dz = p1[2] - p2[2];
+
+		const ox = h1x + h2x - Math.abs(dx);
+		const oy = h1y + h2y - Math.abs(dy);
+		const oz = h1z + h2z - Math.abs(dz);
+
+		if (ox > 0 && oy > 0 && oz > 0) {
+			let pushX = 0,
+				pushY = 0,
+				pushZ = 0;
+			if (ox < oy && ox < oz) {
+				pushX = dx > 0 ? ox : -ox;
+			} else if (oy < ox && oy < oz) {
+				pushY = dy > 0 ? oy : -oy;
+			} else {
+				pushZ = dz > 0 ? oz : -oz;
+			}
+
+			const m1 = r1 && !r1.isKinematic ? r1.mass : Number.POSITIVE_INFINITY;
+			const m2 = r2 && !r2.isKinematic ? r2.mass : Number.POSITIVE_INFINITY;
+
+			const totalMass =
+				(m1 === Number.POSITIVE_INFINITY ? 0 : m1) +
+				(m2 === Number.POSITIVE_INFINITY ? 0 : m2);
+			if (totalMass === 0) return;
+
+			const ratio1 =
+				m1 === Number.POSITIVE_INFINITY
+					? 0
+					: m2 === Number.POSITIVE_INFINITY
+						? 1
+						: m2 / totalMass;
+			const ratio2 =
+				m2 === Number.POSITIVE_INFINITY
+					? 0
+					: m1 === Number.POSITIVE_INFINITY
+						? 1
+						: m1 / totalMass;
+
+			if (r1 && !r1.isKinematic) {
+				t1.localPosition[0] += pushX * ratio1;
+				t1.localPosition[1] += pushY * ratio1;
+				t1.localPosition[2] += pushZ * ratio1;
+
+				if (pushX !== 0) r1.velocity[0] = 0;
+				if (pushY !== 0) r1.velocity[1] = 0;
+				if (pushZ !== 0) r1.velocity[2] = 0;
+
+				t1.updateMatrix();
+			}
+
+			if (r2 && !r2.isKinematic) {
+				t2.localPosition[0] -= pushX * ratio2;
+				t2.localPosition[1] -= pushY * ratio2;
+				t2.localPosition[2] -= pushZ * ratio2;
+
+				if (pushX !== 0) r2.velocity[0] = 0;
+				if (pushY !== 0) r2.velocity[1] = 0;
+				if (pushZ !== 0) r2.velocity[2] = 0;
+
+				t2.updateMatrix();
+			}
+		}
+	}
+}

package/src/systems/Systems.test.ts

@@ -0,0 +1,165 @@
+import { beforeEach, describe, expect, test } from "bun:test";
+import { Collider } from "../components/Collider";
+import { Light } from "../components/Light";
+import { MeshRenderer } from "../components/MeshRenderer";
+import { ParticleEmitter } from "../components/ParticleEmitter";
+import { RigidBody } from "../components/RigidBody";
+import { Transform } from "../components/Transform";
+import { World } from "../ecs/World";
+import { LightingSystem } from "./LightingSystem";
+import { ParticleSystem } from "./ParticleSystem";
+import { PhysicsSystem } from "./PhysicsSystem";
+
+describe("ECS Systems", () => {
+	let world: World;
+
+	beforeEach(() => {
+		world = new World();
+	});
+
+	test("PhysicsSystem applies gravity to RigidBodies", () => {
+		const physics = new PhysicsSystem(world);
+		const e1 = world.createEntity();
+		world.addComponent(e1, Transform);
+		const rb = world.addComponent(e1, RigidBody);
+
+		physics.update(1.0); // 1 second
+		expect(rb.velocity[1]).toBeCloseTo(-9.81);
+	});
+
+	test("PhysicsSystem AABB collision resolution", () => {
+		const physics = new PhysicsSystem(world);
+
+		const e1 = world.createEntity();
+		const t1 = world.addComponent(e1, Transform);
+		const rb1 = world.addComponent(e1, RigidBody);
+		const c1 = world.addComponent(e1, Collider); // 1x1 default
+		t1.localPosition[0] = 0;
+
+		const e2 = world.createEntity();
+		const t2 = world.addComponent(e2, Transform);
+		const _rb2 = world.addComponent(e2, RigidBody);
+		const c2 = world.addComponent(e2, Collider); // 1x1 default
+		t2.localPosition[0] = 0.5; // Overlapping by 0.5
+
+		t1.updateMatrix();
+		t2.updateMatrix();
+
+		physics.update(0); // dt 0, just test resolution separation
+
+		// They should push each other apart by 0.25 (since equal mass)
+		expect(t1.localPosition[0]).toBeCloseTo(-0.25);
+		expect(t2.localPosition[0]).toBeCloseTo(0.75);
+
+		// Test Trigger logic
+		c1.isTrigger = true;
+		t1.localPosition[0] = 0;
+		t2.localPosition[0] = 0.5;
+		t1.updateMatrix();
+		t2.updateMatrix();
+		physics.update(0);
+		expect(t1.localPosition[0]).toBe(0); // Ignored since isTrigger
+		c1.isTrigger = false;
+
+		// Test Kinematic logic
+		rb1.isKinematic = true;
+		t1.localPosition[0] = 0;
+		t2.localPosition[0] = 0.5;
+		t1.updateMatrix();
+		t2.updateMatrix();
+		physics.update(0);
+		// Kinematic doesn't move, e2 takes full push (0.5)
+		expect(t1.localPosition[0]).toBe(0);
+		expect(t2.localPosition[0]).toBeCloseTo(1);
+
+		// Reset for Y test
+		rb1.isKinematic = false;
+		c1.size[0] = 100;
+		c2.size[0] = 100; // X overlap huge
+		c1.size[2] = 100;
+		c2.size[2] = 100; // Z overlap huge
+		c1.size[1] = 1;
+		c2.size[1] = 1; // Y overlap small
+		t1.localPosition[0] = 0;
+		t1.localPosition[1] = 0;
+		t1.localPosition[2] = 0;
+		t2.localPosition[0] = 0;
+		t2.localPosition[1] = 0.5;
+		t2.localPosition[2] = 0;
+		t1.updateMatrix();
+		t2.updateMatrix();
+		physics.update(0);
+		expect(t2.localPosition[1]).toBeCloseTo(0.75); // Resolves along Y axis
+
+		// Reset for Z test
+		c1.size[1] = 100;
+		c2.size[1] = 100; // Y overlap huge
+		c1.size[2] = 1;
+		c2.size[2] = 1; // Z overlap small
+		t1.localPosition[0] = 0;
+		t1.localPosition[1] = 0;
+		t1.localPosition[2] = 0;
+		t2.localPosition[0] = 0;
+		t2.localPosition[1] = 0;
+		t2.localPosition[2] = -0.5; // push negative
+		t1.updateMatrix();
+		t2.updateMatrix();
+		physics.update(0);
+		expect(t2.localPosition[2]).toBeCloseTo(-0.75); // Resolves along Z axis
+	});
+
+	test("LightingSystem correctly aggregates global lighting buffers", () => {
+		const lightSys = new LightingSystem(world);
+
+		const e1 = world.createEntity();
+		const t1 = world.addComponent(e1, Transform);
+		t1.localPosition[0] = 10;
+		t1.localPosition[1] = 20;
+		t1.localPosition[2] = 30;
+		world.addComponent(e1, Light, "Point");
+
+		const e2 = world.createEntity();
+		world.addComponent(e2, Transform);
+		const ambient = world.addComponent(e2, Light, "Ambient");
+		ambient.intensity = 0.5;
+
+		lightSys.update(0.1);
+
+		expect(LightingSystem.activePointLights).toBe(1);
+
+		// Point Light transform translation should exist in uniform array
+		// (Assuming mat4 defaults to identity and translate modifies [12,13,14])
+		// In local Transform initialization, it builds matrix from pos.
+		expect(LightingSystem.lightPositions[0]).toBe(10);
+		expect(LightingSystem.lightPositions[1]).toBe(20);
+		expect(LightingSystem.lightPositions[2]).toBe(30);
+
+		// Ambient should sum up
+		expect(LightingSystem.ambientColor[0]).toBe(0.5); // white default
+	});
+
+	test("ParticleSystem spawning logic", () => {
+		const ps = new ParticleSystem(world);
+		const e1 = world.createEntity();
+		world.addComponent(e1, Transform);
+		const emitter = world.addComponent(e1, ParticleEmitter, 100);
+		emitter.emissionRate = 10;
+
+		ps.update(0.5); // 0.5s @ 10/s = 5 particles
+
+		expect(emitter.activeCount).toBe(5);
+		expect(emitter.pLife[0]).toBe(0.5);
+
+		// The mesh renderer should be automatically added
+		const mesh = world.getComponent(e1, MeshRenderer);
+		expect(mesh).toBeDefined();
+		// 5 active particles * 6 indices each = 30 indices to draw
+		expect(mesh?.indexCount).toBe(30);
+		expect(mesh?.isDirty).toBe(true);
+
+		// Force particle death by expiring life natively
+		emitter.pLife[0] = -1;
+		ps.update(0.1); // Advances sim and kills the trailing particle
+		expect(emitter.activeCount).toBe(5); // 5 existed, 1 died, wait, 0.1s spawned 1 more. So 5 - 1 + 1 = 5
+	});
+});

package/src/systems/TextSystem.ts

@@ -0,0 +1,153 @@
+import { BitmapText } from "../components/BitmapText";
+import { MeshRenderer } from "../components/MeshRenderer";
+import { Transform } from "../components/Transform";
+import { GlobalAssets } from "../core/AssetManager";
+import { System } from "../ecs/System";
+import { Material } from "../renderer/Material";
+
+export const TEXT_VS = `
+  attribute vec4 aVertexPosition;
+  attribute vec2 aTextureCoord;
+  attribute vec4 aVertexColor;
+  uniform mat4 uModelViewMatrix;
+  uniform mat4 uProjectionMatrix;
+  varying highp vec2 vTextureCoord;
+  varying lowp vec4 vColor;
+  void main(void) {
+    gl_Position = uProjectionMatrix * uModelViewMatrix * aVertexPosition;
+    vTextureCoord = aTextureCoord;
+    vColor = aVertexColor;
+  }
+`;
+
+export const TEXT_FS = `
+  varying highp vec2 vTextureCoord;
+  varying lowp vec4 vColor;
+  uniform sampler2D uSampler;
+  void main(void) {
+    gl_FragColor = texture2D(uSampler, vTextureCoord) * vColor;
+  }
+`;
+
+export class TextSystem extends System {
+	update(_dt: number) {
+		const texts = this.world.query(Transform, BitmapText);
+
+		for (const entity of texts) {
+			const bt = this.world.getComponent(entity, BitmapText)!;
+			if (!bt.isDirty) continue;
+
+			const font = GlobalAssets.getFont(bt.fontId);
+			if (!font?.textureAsset.loaded) continue;
+
+			let mesh = this.world.getComponent(entity, MeshRenderer);
+
+			const len = bt.text.length;
+			const positions = new Float32Array(len * 4 * 3);
+			const colors = new Float32Array(len * 4 * 4);
+			const uvs = new Float32Array(len * 4 * 2);
+			const indices = new Uint16Array(len * 6);
+
+			let cursorX = 0;
+			let cursorY = 0;
+
+			const cr = bt.color.rNorm;
+			const cg = bt.color.gNorm;
+			const cb = bt.color.bNorm;
+			const ca = bt.color.aNorm;
+
+			for (let i = 0; i < len; i++) {
+				const charCode = bt.text.charCodeAt(i);
+				if (charCode === 10) {
+					cursorY += font.lineHeight;
+					cursorX = 0;
+					continue;
+				}
+
+				const charData = font.chars.get(charCode);
+				if (!charData) continue;
+
+				const x = cursorX + charData.xoffset;
+				const y = cursorY + charData.yoffset;
+				const w = charData.width;
+				const h = charData.height;
+
+				const baseV = i * 12;
+				positions[baseV] = x;
+				positions[baseV + 1] = y;
+				positions[baseV + 2] = 0;
+				positions[baseV + 3] = x + w;
+				positions[baseV + 4] = y;
+				positions[baseV + 5] = 0;
+				positions[baseV + 6] = x + w;
+				positions[baseV + 7] = y + h;
+				positions[baseV + 8] = 0;
+				positions[baseV + 9] = x;
+				positions[baseV + 10] = y + h;
+				positions[baseV + 11] = 0;
+
+				const tw = font.textureWidth;
+				const th = font.textureHeight;
+				const u0 = charData.x / tw;
+				const v0 = charData.y / th;
+				const u1 = (charData.x + w) / tw;
+				const v1 = (charData.y + h) / th;
+
+				const baseU = i * 8;
+				uvs[baseU] = u0;
+				uvs[baseU + 1] = v0;
+				uvs[baseU + 2] = u1;
+				uvs[baseU + 3] = v0;
+				uvs[baseU + 4] = u1;
+				uvs[baseU + 5] = v1;
+				uvs[baseU + 6] = u0;
+				uvs[baseU + 7] = v1;
+
+				const baseC = i * 16;
+				for (let v = 0; v < 4; v++) {
+					colors[baseC + v * 4] = cr;
+					colors[baseC + v * 4 + 1] = cg;
+					colors[baseC + v * 4 + 2] = cb;
+					colors[baseC + v * 4 + 3] = ca;
+				}
+
+				const baseI = i * 6;
+				const ix = i * 4;
+				indices[baseI] = ix;
+				indices[baseI + 1] = ix + 1;
+				indices[baseI + 2] = ix + 2;
+				indices[baseI + 3] = ix;
+				indices[baseI + 4] = ix + 2;
+				indices[baseI + 5] = ix + 3;
+
+				cursorX += charData.xadvance;
+			}
+
+			if (!mesh) {
+				const material = new Material(TEXT_VS, TEXT_FS);
+				material.transparent = true;
+				material.setUniform("uSampler", font.textureAsset);
+
+				mesh = this.world.addComponent(
+					entity,
+					MeshRenderer,
+					Array.from(positions),
+					Array.from(colors),
+					Array.from(uvs),
+					Array.from(indices),
+					material,
+				);
+			} else {
+				mesh.positions = positions;
+				mesh.colors = colors;
+				mesh.uvs = uvs;
+				mesh.indices = indices;
+				mesh.vertexCount = positions.length / 3;
+				mesh.indexCount = indices.length;
+				mesh.isDirty = true;
+			}
+
+			bt.isDirty = false;
+		}
+	}
+}