aether-engine 1.0.0

package/src/math/Color.ts

@@ -0,0 +1,100 @@
+import { vec4 } from "gl-matrix";
+
+export class Color {
+	public raw: vec4;
+
+	constructor(
+		r: number = 255,
+		g: number = 255,
+		b: number = 255,
+		a: number = 255,
+	) {
+		this.raw = vec4.fromValues(r / 255, g / 255, b / 255, a / 255);
+	}
+
+	get r() {
+		return this.raw[0] * 255;
+	}
+	set r(v) {
+		this.raw[0] = v / 255;
+	}
+
+	get g() {
+		return this.raw[1] * 255;
+	}
+	set g(v) {
+		this.raw[1] = v / 255;
+	}
+
+	get b() {
+		return this.raw[2] * 255;
+	}
+	set b(v) {
+		this.raw[2] = v / 255;
+	}
+
+	get a() {
+		return this.raw[3] * 255;
+	}
+	set a(v) {
+		this.raw[3] = v / 255;
+	}
+
+	get rNorm() {
+		return this.raw[0];
+	}
+	get gNorm() {
+		return this.raw[1];
+	}
+	get bNorm() {
+		return this.raw[2];
+	}
+	get aNorm() {
+		return this.raw[3];
+	}
+
+	set(r: number, g: number, b: number, a: number = 255): this {
+		vec4.set(this.raw, r / 255, g / 255, b / 255, a / 255);
+		return this;
+	}
+
+	clone(): Color {
+		return new Color(this.r, this.g, this.b, this.a);
+	}
+
+	static Red() {
+		return new Color(255, 0, 0, 255);
+	}
+	static Green() {
+		return new Color(0, 255, 0, 255);
+	}
+	static Blue() {
+		return new Color(0, 0, 255, 255);
+	}
+	static White() {
+		return new Color(255, 255, 255, 255);
+	}
+	static Black() {
+		return new Color(0, 0, 0, 255);
+	}
+	static Transparent() {
+		return new Color(0, 0, 0, 0);
+	}
+
+	static fromHex(hex: string): Color {
+		let h = hex.replace("#", "");
+		if (h.length === 3)
+			h = h
+				.split("")
+				.map((c) => c + c)
+				.join("");
+		if (h.length === 6) h += "FF";
+		const val = parseInt(h, 16);
+		return new Color(
+			(val >> 24) & 255,
+			(val >> 16) & 255,
+			(val >> 8) & 255,
+			val & 255,
+		);
+	}
+}

package/src/math/Vector2.ts

@@ -0,0 +1,96 @@
+import { vec2 } from "gl-matrix";
+
+export class Vector2 {
+	public raw: vec2;
+
+	private static _pool: Vector2[] = [];
+
+	public static obtain(x: number = 0, y: number = 0): Vector2 {
+		if (Vector2._pool.length > 0) {
+			return Vector2._pool.pop()?.set(x, y);
+		}
+		return new Vector2(x, y);
+	}
+
+	public free() {
+		Vector2._pool.push(this);
+	}
+
+	constructor(x: number = 0, y: number = 0) {
+		this.raw = vec2.fromValues(x, y);
+	}
+
+	get x() {
+		return this.raw[0];
+	}
+	set x(v) {
+		this.raw[0] = v;
+	}
+
+	get y() {
+		return this.raw[1];
+	}
+	set y(v) {
+		this.raw[1] = v;
+	}
+
+	set(x: number, y: number): this {
+		vec2.set(this.raw, x, y);
+		return this;
+	}
+
+	copy(other: Vector2): this {
+		vec2.copy(this.raw, other.raw);
+		return this;
+	}
+
+	add(other: Vector2): this {
+		vec2.add(this.raw, this.raw, other.raw);
+		return this;
+	}
+
+	sub(other: Vector2): this {
+		vec2.sub(this.raw, this.raw, other.raw);
+		return this;
+	}
+
+	multiply(other: Vector2): this {
+		vec2.multiply(this.raw, this.raw, other.raw);
+		return this;
+	}
+
+	divide(other: Vector2): this {
+		vec2.divide(this.raw, this.raw, other.raw);
+		return this;
+	}
+
+	scale(scalar: number): this {
+		vec2.scale(this.raw, this.raw, scalar);
+		return this;
+	}
+
+	distance(other: Vector2): number {
+		return vec2.dist(this.raw, other.raw);
+	}
+
+	magnitude(): number {
+		return vec2.length(this.raw);
+	}
+
+	length(): number {
+		return vec2.length(this.raw);
+	}
+
+	normalize(): this {
+		vec2.normalize(this.raw, this.raw);
+		return this;
+	}
+
+	clone(): Vector2 {
+		return new Vector2(this.x, this.y);
+	}
+
+	static Zero(): Vector2 {
+		return new Vector2(0, 0);
+	}
+}

package/src/math/Vector3.ts

@@ -0,0 +1,103 @@
+import { vec3 } from "gl-matrix";
+
+export class Vector3 {
+	public raw: vec3;
+
+	private static _pool: Vector3[] = [];
+
+	public static obtain(x: number = 0, y: number = 0, z: number = 0): Vector3 {
+		if (Vector3._pool.length > 0) {
+			return Vector3._pool.pop()?.set(x, y, z);
+		}
+		return new Vector3(x, y, z);
+	}
+
+	public free() {
+		Vector3._pool.push(this);
+	}
+
+	constructor(x: number = 0, y: number = 0, z: number = 0) {
+		this.raw = vec3.fromValues(x, y, z);
+	}
+
+	get x() {
+		return this.raw[0];
+	}
+	set x(v) {
+		this.raw[0] = v;
+	}
+
+	get y() {
+		return this.raw[1];
+	}
+	set y(v) {
+		this.raw[1] = v;
+	}
+
+	get z() {
+		return this.raw[2];
+	}
+	set z(v) {
+		this.raw[2] = v;
+	}
+
+	set(x: number, y: number, z: number): this {
+		vec3.set(this.raw, x, y, z);
+		return this;
+	}
+
+	copy(other: Vector3): this {
+		vec3.copy(this.raw, other.raw);
+		return this;
+	}
+
+	add(other: Vector3): this {
+		vec3.add(this.raw, this.raw, other.raw);
+		return this;
+	}
+
+	sub(other: Vector3): this {
+		vec3.sub(this.raw, this.raw, other.raw);
+		return this;
+	}
+
+	multiply(other: Vector3): this {
+		vec3.multiply(this.raw, this.raw, other.raw);
+		return this;
+	}
+
+	divide(other: Vector3): this {
+		vec3.divide(this.raw, this.raw, other.raw);
+		return this;
+	}
+
+	scale(scalar: number): this {
+		vec3.scale(this.raw, this.raw, scalar);
+		return this;
+	}
+
+	distance(other: Vector3): number {
+		return vec3.dist(this.raw, other.raw);
+	}
+
+	magnitude(): number {
+		return vec3.length(this.raw);
+	}
+
+	length(): number {
+		return vec3.length(this.raw);
+	}
+
+	normalize(): this {
+		vec3.normalize(this.raw, this.raw);
+		return this;
+	}
+
+	clone(): Vector3 {
+		return new Vector3(this.x, this.y, this.z);
+	}
+
+	static Zero(): Vector3 {
+		return new Vector3(0, 0, 0);
+	}
+}

package/src/math/math.test.ts

@@ -0,0 +1,168 @@
+import { describe, expect, test } from "bun:test";
+import { Color } from "./Color";
+import { Vector2 } from "./Vector2";
+import { Vector3 } from "./Vector3";
+
+describe("Math API", () => {
+	test("Vector2 object pooling", () => {
+		const v1 = Vector2.obtain(10, 20);
+		expect(v1.x).toBe(10);
+		expect(v1.y).toBe(20);
+
+		v1.free();
+
+		const v2 = Vector2.obtain(5, 5);
+		expect(v2).toBe(v1); // Should be the same object reference
+		expect(v2.x).toBe(5);
+		expect(v2.y).toBe(5);
+	});
+
+	test("Vector3 chaining and operations", () => {
+		const v = new Vector3(1, 2, 3);
+		const result = v.add(new Vector3(1, 1, 1)).scale(2);
+
+		expect(result).toBe(v); // Chain should return itself
+		expect(v.x).toBe(4);
+		expect(v.y).toBe(6);
+		expect(v.z).toBe(8);
+	});
+
+	test("Color normalization", () => {
+		const c = new Color(255, 127.5, 0, 255);
+		expect(c.rNorm).toBe(1);
+		expect(c.gNorm).toBeCloseTo(0.5);
+		expect(c.bNorm).toBe(0);
+		expect(c.aNorm).toBe(1);
+	});
+
+	test("Color statics and hex parsing", () => {
+		const c1 = Color.White();
+		expect(c1.r).toBe(255);
+		const c2 = Color.Black();
+		expect(c2.r).toBe(0);
+
+		const c3 = Color.fromHex("#FF00FF");
+		expect(c3.r).toBe(255);
+		expect(c3.g).toBe(0);
+		expect(c3.b).toBe(255);
+
+		const c4 = Color.fromHex("00ff00ff");
+		expect(c4.g).toBe(255);
+
+		c4.r = 100;
+		c4.g = 100;
+		c4.b = 100;
+		c4.a = 100;
+		expect(c4.r).toBeCloseTo(100);
+		expect(c4.g).toBeCloseTo(100);
+		expect(c4.b).toBeCloseTo(100);
+		expect(c4.a).toBeCloseTo(100);
+
+		c4.set(50, 50, 50, 50);
+		expect(c4.r).toBeCloseTo(50);
+	});
+
+	test("Vector2 math operations", () => {
+		const v1 = new Vector2(10, 10);
+		const v2 = new Vector2(2, 2);
+
+		v1.add(v2);
+		expect(v1.x).toBe(12);
+
+		v1.sub(v2);
+		expect(v1.x).toBe(10);
+
+		v1.multiply(v2);
+		expect(v1.x).toBe(20);
+
+		v1.divide(v2);
+		expect(v1.x).toBe(10);
+
+		v1.scale(0.5);
+		expect(v1.x).toBe(5);
+
+		const len = v1.length();
+		expect(len).toBeCloseTo(Math.sqrt(50));
+
+		const mag = v1.magnitude();
+		expect(mag).toBe(len);
+
+		v1.normalize();
+		expect(v1.x).toBeCloseTo(Math.SQRT1_2);
+
+		const dist = v1.distance(new Vector2(0, 0));
+		expect(dist).toBeCloseTo(1);
+
+		const clone = v1.clone();
+		expect(clone.x).toBe(v1.x);
+
+		v1.set(100, 100);
+		expect(v1.x).toBe(100);
+		expect(v1.y).toBe(100);
+
+		const v3 = new Vector2();
+		v3.x = 7;
+		v3.y = 8;
+		expect(v3.x).toBe(7);
+		expect(v3.y).toBe(8);
+
+		const v4 = new Vector2().copy(v3);
+		expect(v4.x).toBe(7);
+	});
+
+	test("Vector3 full math operations", () => {
+		const v1 = new Vector3(10, 10, 10);
+		const v2 = new Vector3(2, 2, 2);
+
+		v1.add(v2);
+		expect(v1.x).toBe(12);
+
+		v1.sub(v2);
+		expect(v1.x).toBe(10);
+
+		v1.multiply(v2);
+		expect(v1.x).toBe(20);
+
+		v1.divide(v2);
+		expect(v1.x).toBe(10);
+
+		v1.scale(2);
+		expect(v1.x).toBe(20);
+
+		const len = v1.length();
+		expect(len).toBeCloseTo(Math.sqrt(1200));
+
+		const mag = v1.magnitude();
+		expect(mag).toBe(len);
+
+		v1.normalize();
+		expect(v1.x).toBeCloseTo(0.577);
+
+		expect(v1.distance(new Vector3(0, 0, 0))).toBeCloseTo(1);
+
+		v1.set(5, 5, 5);
+		expect(v1.x).toBe(5);
+
+		const clone = v1.clone();
+		expect(clone.y).toBe(v1.y);
+
+		const pooled = Vector3.obtain(1, 2, 3);
+		expect(pooled.x).toBe(1);
+		expect(pooled.y).toBe(2);
+		expect(pooled.z).toBe(3);
+
+		pooled.x = 9;
+		pooled.y = 8;
+		pooled.z = 7;
+		expect(pooled.x).toBe(9);
+		expect(pooled.y).toBe(8);
+		expect(pooled.z).toBe(7);
+
+		const copyCat = new Vector3().copy(pooled);
+		expect(copyCat.z).toBe(7);
+
+		pooled.free();
+		const p2 = Vector3.obtain(2, 2, 2);
+		expect(p2).toBe(pooled);
+	});
+});

package/src/renderer/GlowMaterial.ts

@@ -0,0 +1,66 @@
+import { Material } from "./Material";
+
+export const GLOW_VS = `
+  attribute vec4 aVertexPosition;
+  attribute vec2 aTextureCoord;
+
+  uniform mat4 uModelMatrix;
+  uniform mat4 uModelViewMatrix;
+  uniform mat4 uProjectionMatrix;
+  
+  varying highp vec2 vTextureCoord;
+
+  void main(void) {
+    gl_Position = uProjectionMatrix * uModelViewMatrix * aVertexPosition;
+    vTextureCoord = aTextureCoord;
+  }
+`;
+
+export const GLOW_FS = `
+  precision mediump float;
+  
+  varying highp vec2 vTextureCoord;
+  uniform lowp vec4 uColor;
+
+  void main(void) {
+    // Distance from the center of the quad
+    vec2 center = vec2(0.5, 0.5);
+    float dist = distance(vTextureCoord, center);
+    
+    // Zelda-like sharp, warm core with a very soft ambient scatter edge
+    // CRITICAL: smoothstep(0.5, 0.0) is mathematically UNDEFINED in basic GLSL. 
+    // Always use edge0 < edge1, and invert algebraically!
+    float glow = 1.0 - smoothstep(0.0, 0.5, dist);
+    
+    // Core hot spot for realism (toned down to prevent blinding white center)
+    // Avoid pow() completely to bypass catastrophic macOS fractional exp2 driver traps!
+    float glow2 = glow * glow;
+    float glow4 = glow2 * glow2;
+    float hotspot = glow4 * 0.7;
+    
+    // Outer atmospheric scattering (approx glow^2.5)
+    float scatter = glow2 * sqrt(glow) * 0.3;
+    
+    float finalAlpha = clamp((hotspot + scatter) * uColor.a, 0.0, 1.0);
+    
+    // Discard completely transparent pixels to absolutely maximize fillrate hardware performance
+    if (finalAlpha < 0.01) {
+        discard;
+    }
+    
+    // Pre-multiply color natively because Screen blending uses (ONE, ONE_MINUS_SRC_COLOR) directly!
+    // The GL Fixed Function ALU no longer applies an implicit SRC_ALPHA weight for us.
+    gl_FragColor = vec4(uColor.rgb * finalAlpha, finalAlpha);
+  }
+`;
+
+export class GlowMaterial extends Material {
+	constructor() {
+		super(GLOW_VS, GLOW_FS);
+		// We dynamically use Screen blending to output additive luminosity while inherently securely capping 
+		// maximum bounds at 1.0, neutralizing aggressive macOS GPU Additive integer wrap artifacts!
+		this.blendMode = "Screen"; 
+		this.depthTest = true; // Eclipsed by taller solid things
+		this.depthWrite = false; // Soft particles shouldn't interact natively into depth buffer
+	}
+}