@multiplekex/shallot 0.1.0

package/src/core/index.ts

@@ -0,0 +1,92 @@
+export {
+    observe,
+    onAdd,
+    onRemove,
+    onGet,
+    onSet,
+    And,
+    Or,
+    Not,
+    Any,
+    All,
+    None,
+    Hierarchy,
+    Cascade,
+    createRelation,
+    getRelationTargets,
+    Wildcard,
+    IsA,
+    Pair,
+    type World,
+    type EntityId,
+    type ComponentRef,
+    type Relation,
+} from "bitecs";
+
+export { State, MAX_ENTITIES } from "./state";
+export { StateBuilder } from "./builder";
+export { resource, type ResourceKey } from "./resource";
+export {
+    Scheduler,
+    Time,
+    CycleError,
+    OrderingError,
+    type System,
+    type SystemGroup,
+    type GameTime,
+} from "./scheduler";
+
+export {
+    registerComponent,
+    getRegisteredComponent,
+    clearRegistry,
+    getTraits,
+    setTraits,
+    directAccessor,
+    type ParseContext,
+    type ComponentTraits,
+    type ComponentData,
+    type RegisteredComponent,
+    type FieldAccessor,
+} from "./component";
+
+export {
+    defineRelation,
+    getRelationDef,
+    clearRelationDefs,
+    ChildOf,
+    type RelationDef,
+    type RelationOptions,
+} from "./relation";
+
+export type { Plugin, Loading, InputState, MouseState, RenderContext } from "./types";
+
+export {
+    clamp,
+    lerp,
+    slerp,
+    rotateQuaternion,
+    eulerToQuaternion,
+    quaternionToEuler,
+    lookAt,
+} from "./math";
+
+export { toKebabCase, toCamelCase } from "./strings";
+
+export { initRuntime, getRuntime, resetRuntime, type Runtime, type RuntimeTarget } from "./runtime";
+
+export {
+    parseXml,
+    loadScene,
+    loadSceneFile,
+    registerPostLoadHook,
+    unregisterPostLoadHook,
+    type ParsedElement,
+    type EntityDef,
+    type EntityRef,
+    type ComponentDef,
+    type ParseResult,
+    type ParseError,
+    type LoadResult,
+    type PostLoadHook,
+} from "./xml";

package/src/core/math.ts

@@ -0,0 +1,128 @@
+import { quat, utils, mat4 } from "wgpu-matrix";
+
+const tempQuatA = quat.create();
+const tempQuatB = quat.create();
+const tempQuatOut = quat.create();
+const tempMat4 = mat4.create();
+const tempVec3A = new Float32Array(3);
+const tempVec3B = new Float32Array(3);
+const tempVec3C = new Float32Array(3);
+
+export function clamp(value: number, min: number, max: number): number {
+    return Math.max(min, Math.min(max, value));
+}
+
+export function lerp(a: number, b: number, t: number): number {
+    return a + (b - a) * t;
+}
+
+export function slerp(
+    fromX: number,
+    fromY: number,
+    fromZ: number,
+    fromW: number,
+    toX: number,
+    toY: number,
+    toZ: number,
+    toW: number,
+    t: number
+): { x: number; y: number; z: number; w: number } {
+    quat.set(fromX, fromY, fromZ, fromW, tempQuatA);
+    quat.set(toX, toY, toZ, toW, tempQuatB);
+    quat.slerp(tempQuatA, tempQuatB, t, tempQuatOut);
+    return { x: tempQuatOut[0], y: tempQuatOut[1], z: tempQuatOut[2], w: tempQuatOut[3] };
+}
+
+export function rotateQuaternion(
+    quatX: number,
+    quatY: number,
+    quatZ: number,
+    quatW: number,
+    dx: number,
+    dy: number,
+    dz: number
+): { x: number; y: number; z: number; w: number } {
+    quat.fromEuler(utils.degToRad(dx), utils.degToRad(dy), utils.degToRad(dz), "xyz", tempQuatA);
+    quat.set(quatX, quatY, quatZ, quatW, tempQuatB);
+    quat.multiply(tempQuatB, tempQuatA, tempQuatOut);
+    return { x: tempQuatOut[0], y: tempQuatOut[1], z: tempQuatOut[2], w: tempQuatOut[3] };
+}
+
+export function eulerToQuaternion(
+    x: number,
+    y: number,
+    z: number
+): { x: number; y: number; z: number; w: number } {
+    quat.fromEuler(utils.degToRad(x), utils.degToRad(y), utils.degToRad(z), "xyz", tempQuatOut);
+    return { x: tempQuatOut[0], y: tempQuatOut[1], z: tempQuatOut[2], w: tempQuatOut[3] };
+}
+
+export function quaternionToEuler(
+    x: number,
+    y: number,
+    z: number,
+    w: number
+): { x: number; y: number; z: number } {
+    const x2 = x + x,
+        y2 = y + y,
+        z2 = z + z;
+    const xx = x * x2,
+        xy = x * y2,
+        xz = x * z2;
+    const yy = y * y2,
+        yz = y * z2,
+        zz = z * z2;
+    const wx = w * x2,
+        wy = w * y2,
+        wz = w * z2;
+
+    const m11 = 1 - (yy + zz);
+    const m12 = xy - wz;
+    const m13 = xz + wy;
+    const m22 = 1 - (xx + zz);
+    const m23 = yz - wx;
+    const m32 = yz + wx;
+    const m33 = 1 - (xx + yy);
+
+    const ey = Math.asin(Math.max(-1, Math.min(1, m13)));
+    let ex: number, ez: number;
+
+    if (Math.abs(m13) < 0.9999999) {
+        ex = Math.atan2(-m23, m33);
+        ez = Math.atan2(-m12, m11);
+    } else {
+        ex = Math.atan2(m32, m22);
+        ez = 0;
+    }
+
+    return {
+        x: utils.radToDeg(ex),
+        y: utils.radToDeg(ey),
+        z: utils.radToDeg(ez),
+    };
+}
+
+export function lookAt(
+    eyeX: number,
+    eyeY: number,
+    eyeZ: number,
+    targetX: number,
+    targetY: number,
+    targetZ: number,
+    upX = 0,
+    upY = 1,
+    upZ = 0
+): { x: number; y: number; z: number; w: number } {
+    tempVec3A[0] = eyeX;
+    tempVec3A[1] = eyeY;
+    tempVec3A[2] = eyeZ;
+    tempVec3B[0] = targetX;
+    tempVec3B[1] = targetY;
+    tempVec3B[2] = targetZ;
+    tempVec3C[0] = upX;
+    tempVec3C[1] = upY;
+    tempVec3C[2] = upZ;
+    mat4.cameraAim(tempVec3A, tempVec3B, tempVec3C, tempMat4);
+    quat.fromMat(tempMat4, tempQuatOut);
+    return { x: tempQuatOut[0], y: tempQuatOut[1], z: tempQuatOut[2], w: tempQuatOut[3] };
+}

package/src/core/relation.ts

@@ -0,0 +1,46 @@
+import { createRelation as bitecsCreateRelation, type Relation } from "bitecs";
+import { toKebabCase } from "./strings";
+
+export interface RelationOptions {
+    readonly exclusive?: boolean;
+    readonly autoRemoveSubject?: boolean;
+}
+
+export interface RelationDef {
+    readonly name: string;
+    readonly relation: Relation<unknown>;
+    readonly exclusive?: boolean;
+    readonly autoRemoveSubject?: boolean;
+}
+
+const registry = new Map<string, RelationDef>();
+
+export function defineRelation(name: string, options?: RelationOptions): RelationDef {
+    const relation = bitecsCreateRelation({
+        exclusive: options?.exclusive,
+        autoRemoveSubject: options?.autoRemoveSubject,
+    });
+
+    const def: RelationDef = {
+        name: toKebabCase(name),
+        relation,
+        exclusive: options?.exclusive,
+        autoRemoveSubject: options?.autoRemoveSubject,
+    };
+
+    registry.set(def.name, def);
+    return def;
+}
+
+export function getRelationDef(name: string): RelationDef | undefined {
+    return registry.get(toKebabCase(name));
+}
+
+export function clearRelationDefs(): void {
+    registry.clear();
+}
+
+export const ChildOf = defineRelation("child-of", {
+    exclusive: true,
+    autoRemoveSubject: true,
+});

package/src/core/resource.ts

@@ -0,0 +1,18 @@
+export interface ResourceContainer {
+    getResource<T>(key: ResourceKey<T>): T | undefined;
+}
+
+export type ResourceKey<T> = symbol & {
+    __type?: T;
+    from(state: ResourceContainer): T | undefined;
+};
+
+export function resource<T>(name: string): ResourceKey<T> {
+    const key = Symbol(name) as symbol;
+    const resourceKey = Object.assign(key, {
+        from(state: ResourceContainer): T | undefined {
+            return state.getResource(resourceKey);
+        },
+    });
+    return resourceKey as ResourceKey<T>;
+}

package/src/core/runtime.ts

@@ -0,0 +1,185 @@
+export type RuntimeTarget = "headless" | "standalone" | "web";
+
+export interface Runtime {
+    readonly target: RuntimeTarget;
+    readFile(path: string): Promise<string>;
+    readBinary(path: string): Promise<ArrayBuffer>;
+    requestFrame(callback: () => void): void;
+    now(): number;
+}
+
+declare const __TAURI_INTERNALS__: unknown;
+declare const Bun: unknown;
+
+export function detectTarget(): RuntimeTarget {
+    if (typeof __TAURI_INTERNALS__ !== "undefined") {
+        return "standalone";
+    }
+
+    if (typeof Bun !== "undefined") {
+        return "headless";
+    }
+
+    if (typeof window !== "undefined" && typeof fetch === "function") {
+        return "web";
+    }
+
+    throw new Error("Unknown runtime environment");
+}
+
+function createWebRuntime(): Runtime {
+    return {
+        target: "web",
+
+        async readFile(path: string): Promise<string> {
+            const response = await fetch(path);
+            if (!response.ok) {
+                throw new Error(`Failed to load ${path}: ${response.status}`);
+            }
+            return response.text();
+        },
+
+        async readBinary(path: string): Promise<ArrayBuffer> {
+            const response = await fetch(path);
+            if (!response.ok) {
+                throw new Error(`Failed to load ${path}: ${response.status}`);
+            }
+            return response.arrayBuffer();
+        },
+
+        requestFrame(callback: () => void): void {
+            requestAnimationFrame(callback);
+        },
+
+        now(): number {
+            return performance.now();
+        },
+    };
+}
+
+function createHeadlessRuntime(): Runtime {
+    return {
+        target: "headless",
+
+        async readFile(path: string): Promise<string> {
+            const file = (
+                Bun as {
+                    file: (path: string) => {
+                        text: () => Promise<string>;
+                        arrayBuffer: () => Promise<ArrayBuffer>;
+                    };
+                }
+            ).file(path);
+            return file.text();
+        },
+
+        async readBinary(path: string): Promise<ArrayBuffer> {
+            const file = (
+                Bun as {
+                    file: (path: string) => {
+                        text: () => Promise<string>;
+                        arrayBuffer: () => Promise<ArrayBuffer>;
+                    };
+                }
+            ).file(path);
+            return file.arrayBuffer();
+        },
+
+        requestFrame(callback: () => void): void {
+            setTimeout(callback, 0);
+        },
+
+        now(): number {
+            return performance.now();
+        },
+    };
+}
+
+function isWebviewResource(path: string): boolean {
+    return path.startsWith("/") || path.startsWith("./") || path.startsWith("../");
+}
+
+function createStandaloneRuntime(): Runtime {
+    return {
+        target: "standalone",
+
+        async readFile(path: string): Promise<string> {
+            if (isWebviewResource(path)) {
+                const response = await fetch(path);
+                if (!response.ok) {
+                    throw new Error(`Failed to load ${path}: ${response.status}`);
+                }
+                return response.text();
+            }
+            const { readTextFile } = await import(/* @vite-ignore */ "@tauri-apps/plugin-fs");
+            return readTextFile(path);
+        },
+
+        async readBinary(path: string): Promise<ArrayBuffer> {
+            if (isWebviewResource(path)) {
+                const response = await fetch(path);
+                if (!response.ok) {
+                    throw new Error(`Failed to load ${path}: ${response.status}`);
+                }
+                return response.arrayBuffer();
+            }
+            const { readFile } = await import(/* @vite-ignore */ "@tauri-apps/plugin-fs");
+            const bytes = await readFile(path);
+            return bytes.buffer;
+        },
+
+        requestFrame(callback: () => void): void {
+            requestAnimationFrame(callback);
+        },
+
+        now(): number {
+            return performance.now();
+        },
+    };
+}
+
+let _runtime: Runtime | undefined;
+
+async function createRuntime(): Promise<Runtime> {
+    const target = detectTarget();
+
+    switch (target) {
+        case "headless":
+            return createHeadlessRuntime();
+        case "standalone":
+            return createStandaloneRuntime();
+        case "web":
+            return createWebRuntime();
+    }
+}
+
+let _initPromise: Promise<Runtime> | undefined;
+
+export function getRuntime(): Runtime {
+    if (_runtime) return _runtime;
+
+    if (!_initPromise) {
+        _initPromise = createRuntime().then((r) => {
+            _runtime = r;
+            return r;
+        });
+    }
+
+    throw new Error("Runtime not initialized. Call initRuntime() first.");
+}
+
+export async function initRuntime(): Promise<Runtime> {
+    if (_runtime) return _runtime;
+
+    if (!_initPromise) {
+        _initPromise = createRuntime();
+    }
+
+    _runtime = await _initPromise;
+    return _runtime;
+}
+
+export function resetRuntime(): void {
+    _runtime = undefined;
+    _initPromise = undefined;
+}

package/src/core/scheduler.ts

@@ -0,0 +1,238 @@
+import type { State } from "./state";
+
+export class CycleError extends Error {
+    constructor(message = "Circular dependency detected") {
+        super(message);
+        this.name = "CycleError";
+    }
+}
+
+export function toposort<T>(nodes: T[], edges: [T, T][]): T[] {
+    if (nodes.length === 0) return [];
+
+    const graph = new Map<T, Set<T>>();
+    const inDegree = new Map<T, number>();
+
+    for (const node of nodes) {
+        graph.set(node, new Set());
+        inDegree.set(node, 0);
+    }
+
+    for (const [from, to] of edges) {
+        if (!graph.has(from) || !graph.has(to)) continue;
+        graph.get(from)!.add(to);
+        inDegree.set(to, inDegree.get(to)! + 1);
+    }
+
+    detectCycle(nodes, graph);
+
+    const queue: T[] = [];
+    const sorted: T[] = [];
+
+    for (const node of nodes) {
+        if (inDegree.get(node) === 0) queue.push(node);
+    }
+
+    while (queue.length > 0) {
+        const node = queue.shift()!;
+        sorted.push(node);
+
+        for (const dep of graph.get(node)!) {
+            const newDegree = inDegree.get(dep)! - 1;
+            inDegree.set(dep, newDegree);
+            if (newDegree === 0) queue.push(dep);
+        }
+    }
+
+    return sorted;
+}
+
+function detectCycle<T>(nodes: T[], graph: Map<T, Set<T>>): void {
+    const visited = new Set<T>();
+    const stack = new Set<T>();
+
+    function hasCycle(node: T): boolean {
+        if (stack.has(node)) return true;
+        if (visited.has(node)) return false;
+
+        visited.add(node);
+        stack.add(node);
+
+        for (const dep of graph.get(node)!) {
+            if (hasCycle(dep)) return true;
+        }
+
+        stack.delete(node);
+        return false;
+    }
+
+    for (const node of nodes) {
+        if (hasCycle(node)) throw new CycleError();
+    }
+}
+
+export const Time = {
+    FIXED_DT: 1 / 50,
+    DEFAULT_DT: 1 / 60,
+} as const;
+
+export interface GameTime {
+    deltaTime: number;
+    fixedDeltaTime: number;
+    elapsed: number;
+}
+
+export type SystemGroup = "setup" | "fixed" | "simulation" | "draw";
+
+export interface System {
+    readonly update?: (state: State) => void;
+    readonly setup?: (state: State) => void;
+    readonly dispose?: (state: State) => void;
+    readonly group?: SystemGroup;
+    readonly first?: boolean;
+    readonly last?: boolean;
+    readonly before?: readonly System[];
+    readonly after?: readonly System[];
+}
+
+export class OrderingError extends Error {
+    constructor(message: string) {
+        super(message);
+        this.name = "OrderingError";
+    }
+}
+
+export class Scheduler {
+    private readonly _systems = new Set<System>();
+    private _systemsVersion = 0;
+    private _accumulator = 0;
+    private readonly _initialized = new WeakSet<System>();
+    private _cache = new Map<SystemGroup, System[]>();
+    private _cacheVersion = -1;
+    private _time: GameTime = {
+        deltaTime: 0,
+        fixedDeltaTime: Time.FIXED_DT,
+        elapsed: 0,
+    };
+
+    get systems(): ReadonlySet<System> {
+        return this._systems;
+    }
+
+    get systemsVersion(): number {
+        return this._systemsVersion;
+    }
+
+    get accumulator(): number {
+        return this._accumulator;
+    }
+
+    get time(): Readonly<GameTime> {
+        return this._time;
+    }
+
+    register(system: System): void {
+        this._systems.add(system);
+        this._systemsVersion++;
+    }
+
+    unregister(system: System): void {
+        if (this._systems.delete(system)) {
+            this._systemsVersion++;
+        }
+    }
+
+    step(state: State, deltaTime = Time.DEFAULT_DT): void {
+        const fixedDt = Time.FIXED_DT;
+
+        this._time.deltaTime = deltaTime;
+        this._time.elapsed += deltaTime;
+        this._accumulator += deltaTime;
+
+        this.runGroup(state, "setup");
+
+        while (this._accumulator >= fixedDt) {
+            this._time.deltaTime = fixedDt;
+            this.runGroup(state, "fixed");
+            this._accumulator -= fixedDt;
+        }
+
+        this._time.deltaTime = deltaTime;
+        this.runGroup(state, "simulation");
+        this.runGroup(state, "draw");
+    }
+
+    private runGroup(state: State, group: SystemGroup): void {
+        for (const system of this.getSorted(group)) {
+            if (!this._initialized.has(system)) {
+                system.setup?.(state);
+                this._initialized.add(system);
+            }
+            system.update?.(state);
+        }
+    }
+
+    private getSorted(group: SystemGroup): System[] {
+        if (this._systemsVersion !== this._cacheVersion) {
+            this._cache.clear();
+            this._cacheVersion = this._systemsVersion;
+        }
+
+        const cached = this._cache.get(group);
+        if (cached) return cached;
+
+        const all = Array.from(this._systems);
+        const filtered = all.filter((s) => (s.group ?? "simulation") === group);
+        const sorted = sortSystems(filtered, all);
+        this._cache.set(group, sorted);
+        return sorted;
+    }
+}
+
+function sortSystems(systems: System[], allSystems?: System[]): System[] {
+    const all = allSystems ?? systems;
+    validateSystems(systems, all);
+
+    const first = systems.filter((s) => s.first);
+    const last = systems.filter((s) => s.last);
+    const normal = systems.filter((s) => !s.first && !s.last);
+
+    return [
+        ...toposort(first, buildEdges(first)),
+        ...toposort(normal, buildEdges(normal)),
+        ...toposort(last, buildEdges(last)),
+    ];
+}
+
+function buildEdges(systems: System[]): [System, System][] {
+    const edges: [System, System][] = [];
+    for (const system of systems) {
+        for (const target of system.before ?? []) {
+            if (systems.includes(target)) edges.push([system, target]);
+        }
+        for (const target of system.after ?? []) {
+            if (systems.includes(target)) edges.push([target, system]);
+        }
+    }
+    return edges;
+}
+
+function validateSystems(systems: System[], all: System[]): void {
+    for (const s of systems) {
+        if (s.first && s.last) {
+            throw new OrderingError("System cannot have both first and last constraints");
+        }
+
+        const group = s.group ?? "simulation";
+        for (const ref of s.before ?? []) checkGroup(ref, group, all);
+        for (const ref of s.after ?? []) checkGroup(ref, group, all);
+    }
+}
+
+function checkGroup(ref: System, group: string, all: System[]): void {
+    if (!all.includes(ref)) return;
+    const refGroup = ref.group ?? "simulation";
+    if (refGroup !== group) {
+        throw new OrderingError(`Cross-group constraint: ${group} references ${refGroup}`);
+    }
+}