aether-engine 1.0.0

package/src/components/Collider.ts

@@ -0,0 +1,16 @@
+import { vec3 } from "gl-matrix";
+
+export class Collider {
+	public type: "AABB" | "Sphere" = "AABB";
+
+	public size: vec3 = vec3.fromValues(1, 1, 1); // For AABB
+	public radius: number = 0.5; // For Sphere
+	public centerOffset: vec3 = vec3.create();
+
+	public isTrigger: boolean = false;
+
+	// Collision state tracking
+	public collisions: number[] = []; // Entity IDs we currently overlap
+	public enterCollisions: number[] = []; // Entity IDs we just started overlapping this frame
+	public exitCollisions: number[] = []; // Entity IDs we just stopped overlapping this frame
+}

package/src/components/Components.test.ts

@@ -0,0 +1,68 @@
+import { describe, expect, test } from "bun:test";
+import { BitmapText } from "./BitmapText";
+import { Collider } from "./Collider";
+import { Light } from "./Light";
+import { MeshRenderer } from "./MeshRenderer";
+import { ParticleEmitter } from "./ParticleEmitter";
+import { RigidBody } from "./RigidBody";
+
+describe("ECS Components", () => {
+	test("RigidBody defaults", () => {
+		const rb = new RigidBody();
+		expect(rb.velocity[0]).toBe(0);
+		expect(rb.isKinematic).toBe(false);
+		expect(rb.mass).toBe(1.0);
+	});
+
+	test("Collider intersection mapping", () => {
+		const c1 = new Collider();
+		c1.size[0] = 10;
+		c1.size[1] = 10;
+		expect(c1.size[0]).toBe(10);
+		expect(c1.size[1]).toBe(10);
+		expect(c1.isTrigger).toBe(false);
+	});
+
+	test("Light types and parameters", () => {
+		const l = new Light("Ambient");
+		expect(l.type).toBe("Ambient");
+		expect(l.intensity).toBe(1.0);
+
+		const l2 = new Light("Point");
+		expect(l2.type).toBe("Point");
+		expect(l2.radius).toBe(100.0);
+	});
+
+	test("ParticleEmitter initializes buffers correctly", () => {
+		const pe = new ParticleEmitter(500);
+		expect(pe.maxParticles).toBe(500);
+		expect(pe.pLife.length).toBe(500);
+		expect(pe.pPosX.length).toBe(500);
+	});
+
+	test("BitmapText sets dirty flag on text change", () => {
+		const bt = new BitmapText("Hello", "font1");
+		bt.isDirty = false;
+		bt.text = "World";
+		expect(bt.isDirty).toBe(true);
+		expect(bt.text).toBe("World");
+
+		// Setting same string should not dirty
+		bt.isDirty = false;
+		bt.text = "World";
+		expect(bt.isDirty).toBe(false);
+	});
+
+	test("MeshRenderer processes advanced geometry arrays", () => {
+		const positions = [0, 0, 0, 1, 0, 0, 1, 1, 0];
+		const uvs = [0, 0, 1, 0, 1, 1];
+		const indices = [0, 1, 2];
+		const colors = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+
+		const mesh = new MeshRenderer(positions, undefined, colors, uvs, indices);
+		expect(mesh.vertexCount).toBe(3);
+		expect(mesh.indexCount).toBe(3);
+		expect(mesh.uvs?.length).toBe(6);
+		expect(mesh.indices?.length).toBe(3);
+	});
+});

package/src/components/Light.ts

@@ -0,0 +1,15 @@
+import { Color } from "../math/Color";
+
+export class Light {
+	public type: "Point" | "Ambient" | "Directional" = "Point";
+	public color: Color = Color.White();
+	public intensity: number = 1.0;
+	public radius: number = 100.0; // Falloff for point lights
+	public elevation: number = 0.0; // Z-axis physical offset from its transform base
+	public positionOffset: [number, number, number] = [0, 0, 0]; // Visual screen-space offset
+	public flickerIntensity: number = 0.0; // Mixes in procedural flicker
+
+	constructor(type: "Point" | "Ambient" | "Directional" = "Point") {
+		this.type = type;
+	}
+}

package/src/components/MeshRenderer.ts

@@ -0,0 +1,58 @@
+import {
+	DEFAULT_MESH_FS,
+	DEFAULT_MESH_VS,
+	Material,
+} from "../renderer/Material";
+
+export class MeshRenderer {
+	public positions: Float32Array;
+	public normals?: Float32Array;
+	public colors?: Float32Array;
+	public uvs?: Float32Array;
+	public indices?: Uint16Array;
+
+	public positionBuffer?: WebGLBuffer;
+	public normalBuffer?: WebGLBuffer;
+	public colorBuffer?: WebGLBuffer;
+	public uvBuffer?: WebGLBuffer;
+	public indexBuffer?: WebGLBuffer;
+
+	public vertexCount: number = 0;
+	public indexCount: number = 0;
+	public isDirty: boolean = false;
+
+	public material: Material;
+
+	constructor(
+		positions: number[],
+		normals?: number[],
+		colors?: number[],
+		uvs?: number[],
+		indices?: number[],
+		material?: Material,
+	) {
+		this.material = material || new Material(DEFAULT_MESH_VS, DEFAULT_MESH_FS);
+		this.positions = new Float32Array(positions);
+		this.vertexCount = Math.floor(positions.length / 3);
+
+		if (normals) {
+			this.normals = new Float32Array(normals);
+		}
+
+		if (colors) {
+			if (colors.length / 4 !== this.vertexCount) {
+				console.warn("Color array length does not match vertex count expected");
+			}
+			this.colors = new Float32Array(colors);
+		}
+
+		if (uvs) {
+			this.uvs = new Float32Array(uvs);
+		}
+
+		if (indices) {
+			this.indices = new Uint16Array(indices);
+			this.indexCount = indices.length;
+		}
+	}
+}

package/src/components/ParticleEmitter.ts

@@ -0,0 +1,59 @@
+import { Color } from "../math/Color";
+import { Material } from "../renderer/Material";
+
+export class ParticleEmitter {
+	public maxParticles: number;
+	public emissionRate: number = 100;
+	public emitAccumulator: number = 0;
+
+	public minSpeed: number = 2.0;
+	public maxSpeed: number = 5.0;
+	public lifespan: number = 1.0;
+
+	public startColor: Color = Color.White();
+	public endColor: Color = Color.White();
+	public startSize: number = 0.5;
+	public endSize: number = 0.1;
+
+	// Tailored Tweakable Options
+	public material?: Material;
+	public billboard: boolean = true;
+	public shape: "square" | "circle" = "square";
+	public depthWrite: boolean = false;
+	public blendMode: "Alpha" | "Additive" = "Additive";
+
+	public lightRadius: number = 2.236; // Default to old hardcoded ~2.236 radius (radiusSq = 5)
+	
+	public activeCount: number = 0;
+
+	public useSuperformula: boolean = false;
+	public superformulaMode: "velocity" | "position" = "velocity";
+	public superformula = {
+		m: 5,
+		n1: 1,
+		n2: 1,
+		n3: 1,
+		a: 1,
+		b: 1,
+	};
+
+	public pLife: Float32Array;
+	public pPosX: Float32Array;
+	public pPosY: Float32Array;
+	public pPosZ: Float32Array;
+	public pVelX: Float32Array;
+	public pVelY: Float32Array;
+	public pVelZ: Float32Array;
+
+	constructor(maxParticles: number = 1000) {
+		this.maxParticles = maxParticles;
+
+		this.pLife = new Float32Array(maxParticles);
+		this.pPosX = new Float32Array(maxParticles);
+		this.pPosY = new Float32Array(maxParticles);
+		this.pPosZ = new Float32Array(maxParticles);
+		this.pVelX = new Float32Array(maxParticles);
+		this.pVelY = new Float32Array(maxParticles);
+		this.pVelZ = new Float32Array(maxParticles);
+	}
+}

package/src/components/RigidBody.ts

@@ -0,0 +1,9 @@
+import { vec3 } from "gl-matrix";
+
+export class RigidBody {
+	public velocity: vec3 = vec3.create();
+	public acceleration: vec3 = vec3.create();
+	public mass: number = 1.0;
+	public gravityScale: number = 1.0;
+	public isKinematic: boolean = false;
+}

package/src/components/ShadowCaster.ts

@@ -0,0 +1,3 @@
+export class ShadowCaster {
+	// A pure marker component signifying this entity blocks light rays
+}

package/src/components/SkinnedMeshRenderer.ts

@@ -0,0 +1,25 @@
+import { Material } from "../renderer/Material";
+import { MeshRenderer } from "./MeshRenderer";
+
+export class SkinnedMeshRenderer extends MeshRenderer {
+	public joints: Float32Array;
+	public weights: Float32Array;
+
+	public jointBuffer?: WebGLBuffer;
+	public weightBuffer?: WebGLBuffer;
+
+	constructor(
+		positions: number[],
+		normals: number[],
+		colors: number[] | undefined,
+		uvs: number[],
+		indices: number[] | undefined,
+		joints: number[],
+		weights: number[],
+		material?: Material,
+	) {
+		super(positions, normals, colors, uvs, indices, material);
+		this.joints = new Float32Array(joints);
+		this.weights = new Float32Array(weights);
+	}
+}

package/src/components/SpriteAnimator.ts

@@ -0,0 +1,42 @@
+export type AnimationDefinition = {
+	name: string;
+	frames: number[]; // Array of frame indices via flattened grid (0 to cols*rows - 1)
+	fps: number;
+};
+
+export class SpriteAnimator {
+	public columns: number = 1;
+	public rows: number = 1;
+	public atlasFrames?: { x: number; y: number; w: number; h: number }[];
+	public atlasSize?: { w: number; h: number };
+
+	public flipX: boolean = false;
+
+	public animations = new Map<string, AnimationDefinition>();
+
+	public currentAnimation: string = "";
+	public currentFrameIndex: number = 0; // The active frame index within the mapped animation's frames array
+	public isPlaying: boolean = true;
+	public timeAccumulator: number = 0;
+
+	constructor(columns: number = 1, rows: number = 1) {
+		this.columns = columns;
+		this.rows = rows;
+	}
+
+	addAnimation(name: string, frames: number[], fps: number) {
+		this.animations.set(name, { name, frames, fps });
+		if (!this.currentAnimation) {
+			this.play(name);
+		}
+	}
+
+	play(name: string) {
+		if (this.currentAnimation !== name) {
+			this.currentAnimation = name;
+			this.currentFrameIndex = 0;
+			this.timeAccumulator = 0;
+		}
+		this.isPlaying = true;
+	}
+}

package/src/components/SpriteRenderer.ts

@@ -0,0 +1,26 @@
+import {
+	DEFAULT_SPRITE_FS,
+	DEFAULT_SPRITE_VS,
+	Material,
+} from "../renderer/Material";
+
+export class SpriteRenderer {
+	public texture?: WebGLTexture;
+	public imageSrc: string;
+	public color: Float32Array = new Float32Array([1, 1, 1, 1]); // Tint
+
+	// UV mapping for sprite sheets
+	public uvOffset: Float32Array = new Float32Array([0, 0]);
+	public uvScale: Float32Array = new Float32Array([1, 1]);
+
+	public material: Material;
+
+	// WebGL specific tracking
+	public _loaded: boolean = false;
+
+	constructor(imageSrc: string, material?: Material) {
+		this.imageSrc = imageSrc;
+		this.material =
+			material || new Material(DEFAULT_SPRITE_VS, DEFAULT_SPRITE_FS);
+	}
+}

package/src/components/Transform.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, test } from "bun:test";
+import { quat, vec3 } from "gl-matrix";
+import { Transform } from "./Transform";
+
+describe("Transform Hierarchy", () => {
+	test("Parent child global position transformation", () => {
+		const root = new Transform();
+		vec3.set(root.localPosition, 10, 0, 0);
+		root.updateMatrix();
+
+		const child = new Transform();
+		child.setParent(root);
+		vec3.set(child.localPosition, 5, 0, 0);
+
+		// Update root which propagates to children
+		root.updateMatrix();
+
+		expect(root.position[0]).toBe(10);
+		expect(child.position[0]).toBe(15);
+	});
+
+	test("Parent child global rotation transformation", () => {
+		const root = new Transform();
+		// Rotate 90 degrees on Y axis
+		quat.setAxisAngle(root.localRotation, [0, 1, 0], Math.PI / 2);
+
+		const child = new Transform();
+		child.setParent(root);
+		// Move child by 5 units on X in local space
+		vec3.set(child.localPosition, 5, 0, 0);
+
+		root.updateMatrix();
+
+		// In global space, 5 units on X rotated 90 deg around Y should result in 5 units on -Z
+		expect(child.position[0]).toBeCloseTo(0, 5);
+		expect(child.position[1]).toBeCloseTo(0, 5);
+		expect(child.position[2]).toBeCloseTo(-5, 5);
+	});
+});

package/src/components/Transform.ts

@@ -0,0 +1,54 @@
+import { mat4, quat, vec3 } from "gl-matrix";
+
+export class Transform {
+	public position: vec3 = vec3.create();
+	public rotation: quat = quat.create();
+	public scale: vec3 = vec3.fromValues(1, 1, 1);
+
+	public localPosition: vec3 = vec3.create();
+	public localRotation: quat = quat.create();
+	public localScale: vec3 = vec3.fromValues(1, 1, 1);
+
+	public matrix: mat4 = mat4.create();
+	public localMatrix: mat4 = mat4.create();
+
+	public parent: Transform | null = null;
+	public children: Set<Transform> = new Set();
+
+	setParent(newParent: Transform | null) {
+		if (this.parent === newParent) return;
+
+		if (this.parent) {
+			this.parent.children.delete(this);
+		}
+
+		this.parent = newParent;
+
+		if (this.parent) {
+			this.parent.children.add(this);
+		}
+	}
+
+	updateMatrix() {
+		mat4.fromRotationTranslationScale(
+			this.localMatrix,
+			this.localRotation,
+			this.localPosition,
+			this.localScale,
+		);
+
+		if (this.parent) {
+			mat4.multiply(this.matrix, this.parent.matrix, this.localMatrix);
+		} else {
+			mat4.copy(this.matrix, this.localMatrix);
+		}
+
+		mat4.getTranslation(this.position, this.matrix);
+		mat4.getRotation(this.rotation, this.matrix);
+		mat4.getScaling(this.scale, this.matrix);
+
+		for (const child of this.children) {
+			child.updateMatrix();
+		}
+	}
+}

package/src/core/AssetManager.ts

@@ -0,0 +1,123 @@
+export class TextureAsset {
+	public image: HTMLImageElement;
+	public glTexture?: WebGLTexture;
+	public loaded: boolean = false;
+
+	constructor(public url: string) {
+		this.image = new Image();
+		this.image.crossOrigin = "anonymous";
+	}
+
+	async load(): Promise<this> {
+		return new Promise((resolve, reject) => {
+			if (this.loaded) {
+				return resolve(this);
+			}
+			this.image.onload = () => {
+				this.loaded = true;
+				resolve(this);
+			};
+			this.image.onerror = reject;
+			this.image.src = this.url;
+		});
+	}
+}
+
+export interface BMFontChar {
+	id: number;
+	x: number;
+	y: number;
+	width: number;
+	height: number;
+	xoffset: number;
+	yoffset: number;
+	xadvance: number;
+}
+
+export interface BMFontMetrics {
+	textureWidth: number;
+	textureHeight: number;
+	lineHeight: number;
+	base: number;
+	chars: Map<number, BMFontChar>;
+	textureAsset: TextureAsset;
+}
+
+export class AssetManagerImpl {
+	public textures = new Map<string, TextureAsset>();
+	public fonts = new Map<string, BMFontMetrics>();
+
+	public loadTexture(url: string): TextureAsset {
+		if (this.textures.has(url)) {
+			const asset = this.textures.get(url)!;
+			asset.load().catch(console.error);
+			return asset;
+		}
+		const tex = new TextureAsset(url);
+		this.textures.set(url, tex);
+		tex.load().catch(console.error);
+		return tex;
+	}
+
+	public getTexture(url: string): TextureAsset | undefined {
+		return this.textures.get(url);
+	}
+
+	public async loadBMFont(
+		fontId: string,
+		xmlUrl: string,
+		textureUrl: string,
+	): Promise<BMFontMetrics> {
+		let metrics = this.fonts.get(fontId);
+		if (metrics) return metrics;
+
+		const textureAsset = this.loadTexture(textureUrl);
+		await textureAsset.load();
+
+		const response = await fetch(xmlUrl);
+		const xmlText = await response.text();
+
+		const parser = new DOMParser();
+		const doc = parser.parseFromString(xmlText, "text/xml");
+
+		const common = doc.querySelector("common")!;
+		const textureWidth = parseInt(common.getAttribute("scaleW") || "256", 10);
+		const textureHeight = parseInt(common.getAttribute("scaleH") || "256", 10);
+		const lineHeight = parseInt(common.getAttribute("lineHeight") || "32", 10);
+		const base = parseInt(common.getAttribute("base") || "32", 10);
+
+		const charsMap = new Map<number, BMFontChar>();
+		const chars = doc.querySelectorAll("char");
+		for (let i = 0; i < chars.length; i++) {
+			const c = chars.item(i);
+			charsMap.set(parseInt(c.getAttribute("id")!, 10), {
+				id: parseInt(c.getAttribute("id")!, 10),
+				x: parseInt(c.getAttribute("x")!, 10),
+				y: parseInt(c.getAttribute("y")!, 10),
+				width: parseInt(c.getAttribute("width")!, 10),
+				height: parseInt(c.getAttribute("height")!, 10),
+				xoffset: parseInt(c.getAttribute("xoffset")!, 10),
+				yoffset: parseInt(c.getAttribute("yoffset")!, 10),
+				xadvance: parseInt(c.getAttribute("xadvance")!, 10),
+			});
+		}
+
+		metrics = {
+			textureWidth,
+			textureHeight,
+			lineHeight,
+			base,
+			chars: charsMap,
+			textureAsset,
+		};
+		this.fonts.set(fontId, metrics);
+		return metrics;
+	}
+
+	public getFont(fontId: string): BMFontMetrics | undefined {
+		return this.fonts.get(fontId);
+	}
+}
+
+export const GlobalAssets = new AssetManagerImpl();
+export class AssetManager extends AssetManagerImpl {}

package/src/core/Input.test.ts

@@ -0,0 +1,67 @@
+import { beforeEach, describe, expect, test } from "bun:test";
+import { Input } from "./Input";
+
+describe("Input Manager", () => {
+	let listeners: Record<string, (...args: any[]) => void> = {};
+
+	beforeEach(() => {
+		listeners = {};
+		// Mock Window
+		globalThis.window = {
+			addEventListener: (type: string, fn: (...args: any[]) => void) => {
+				listeners[type] = fn;
+			},
+		} as any;
+		(Input as any)._initialized = false;
+		Input.initialize();
+	});
+
+	test("Action Mapping and binding", () => {
+		Input.bind("Jump", ["Space"]);
+		// Simulate keydown
+		(Input as any)._keys.add("Space");
+
+		expect(Input.isActionPressed("Jump")).toBe(true);
+	});
+
+	test("Edge detection logic", () => {
+		Input.bind("Fire", ["Enter"]);
+		(Input as any)._keys.add("Enter");
+
+		expect(Input.isActionJustPressed("Fire")).toBe(true);
+		expect(Input.isActionPressed("Fire")).toBe(true);
+
+		Input.update(); // End of Frame 1
+		expect(Input.isActionJustPressed("Fire")).toBe(false);
+		expect(Input.isActionPressed("Fire")).toBe(true);
+
+		(Input as any)._keys.delete("Enter");
+
+		expect(Input.isActionJustReleased("Fire")).toBe(true);
+		expect(Input.isActionPressed("Fire")).toBe(false);
+
+		Input.update(); // End of Frame 2
+		expect(Input.isActionJustReleased("Fire")).toBe(false);
+	});
+
+	test("Mouse interactions", () => {
+		listeners.mousemove({ clientX: 100, clientY: 200 });
+		expect(Input.getMousePosition().x).toBe(100);
+		expect(Input.getMousePosition().y).toBe(200);
+
+		listeners.mousedown();
+		expect(Input.isMouseDown()).toBe(true);
+		expect(Input.isMouseJustPressed()).toBe(true);
+
+		Input.update();
+		expect(Input.isMouseDown()).toBe(true);
+		expect(Input.isMouseJustPressed()).toBe(false);
+
+		listeners.mouseup();
+		expect(Input.isMouseDown()).toBe(false);
+		expect(Input.isMouseJustReleased()).toBe(true);
+
+		Input.update();
+		expect(Input.isMouseJustReleased()).toBe(false);
+	});
+});