@multiplekex/shallot 0.1.12 → 0.2.1

package/package.json

@@ -1,11 +1,12 @@
 {
     "name": "@multiplekex/shallot",
-    "version": "0.1.12",
+    "version": "0.2.1",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",
     "exports": {
         ".": "./src/index.ts",
+        "./editor": "./src/editor/index.ts",
         "./extras": "./src/extras/index.ts"
     },
     "files": [
@@ -17,9 +18,7 @@
         "test": "bun test"
     },
     "dependencies": {
-        "@mapbox/tiny-sdf": "^2.0.7",
-        "bitecs": "^0.4.0",
-        "fast-xml-parser": "^5.3.3"
+        "bitecs": "^0.4.0"
     },
     "devDependencies": {
         "@napi-rs/canvas": "^0.1.88",

package/src/core/builder.ts

@@ -1,12 +1,32 @@
 import { State } from "./state";
-import type { Plugin, Loading } from "./types";
 import { toposort, type System } from "./scheduler";
-import { registerComponent } from "./component";
+import { registerComponent, type ComponentLike } from "./component";
 import { initRuntime } from "./runtime";
+import type { RelationDef } from "./relation";
+
+export interface Plugin {
+    readonly systems?: readonly System[];
+    readonly components?: Record<string, ComponentLike>;
+    readonly relations?: readonly RelationDef[];
+    readonly dependencies?: readonly Plugin[];
+    readonly initialize?: (
+        state: State,
+        onProgress?: (progress: number) => void
+    ) => void | Promise<void>;
+    readonly warm?: (state: State, onProgress?: (progress: number) => void) => void | Promise<void>;
+}
+
+export interface Loading {
+    show(): (() => void) | void;
+    update(progress: number): void;
+}
+
+export const NoLoading: Loading = { show: () => {}, update: () => {} };
 
 export class StateBuilder {
     static defaultPlugins: readonly Plugin[] = [];
-    static loading: ((canvas: HTMLCanvasElement) => Loading) | null = null;
+    static initCanvas: ((state: State, canvas: HTMLCanvasElement) => void) | null = null;
+    static defaultLoading: ((canvas: HTMLCanvasElement) => Loading) | null = null;
 
     private readonly _plugins: Plugin[] = [];
     private readonly _systems: System[] = [];
@@ -14,13 +34,18 @@ export class StateBuilder {
     private readonly _excludedPlugins = new Set<Plugin>();
     private _useDefaultPlugins = true;
     private _canvas: HTMLCanvasElement | null = null;
-    private _loading: Loading | null | undefined = undefined;
+    private _loading: Loading | null = null;
 
     withCanvas(canvas: HTMLCanvasElement): this {
         this._canvas = canvas;
         return this;
     }
 
+    withLoading(loading: Loading): this {
+        this._loading = loading;
+        return this;
+    }
+
     withPlugins(...plugins: Plugin[]): this {
         this._plugins.push(...plugins);
         return this;
@@ -51,20 +76,16 @@ export class StateBuilder {
         return this;
     }
 
-    withLoading(loading: Loading | null): this {
-        this._loading = loading;
-        return this;
-    }
-
     async build(): Promise<State> {
-        const loading =
-            this._loading === undefined && this._canvas
-                ? (StateBuilder.loading?.(this._canvas) ?? null)
-                : this._loading;
+        const state = new State();
 
-        const cleanup = loading?.show();
+        if (this._canvas && StateBuilder.initCanvas) {
+            StateBuilder.initCanvas(state, this._canvas);
+        }
 
-        const state = new State(this._canvas);
+        const loading =
+            this._loading ?? (this._canvas && StateBuilder.defaultLoading?.(this._canvas));
+        const cleanup = loading?.show();
 
         const pluginSet = new Set<Plugin>();
 
@@ -105,13 +126,15 @@ export class StateBuilder {
         }
         const sorted = toposort(allPlugins, edges);
 
-        let completed = 0;
-        const total = sorted.length;
+        const total = sorted.length * 2 + this._scenes.length;
 
-        for (const plugin of sorted) {
-            await plugin.initialize?.(state);
-            completed++;
-            loading?.update(completed / total);
+        for (let i = 0; i < sorted.length; i++) {
+            const plugin = sorted[i];
+            const onProgress = loading
+                ? (progress: number) => loading.update((i + progress) / total)
+                : undefined;
+            await plugin.initialize?.(state, onProgress);
+            loading?.update((i + 1) / total);
         }
 
         for (const system of this._systems) {
@@ -119,21 +142,37 @@ export class StateBuilder {
         }
 
         if (this._scenes.length > 0) {
-            const { loadSceneFile } = await import("./xml");
+            const { parse, load } = await import("./xml");
             const runtime = await initRuntime();
-            for (const scenePath of this._scenes) {
-                const result = await loadSceneFile(
-                    state,
-                    scenePath,
-                    runtime.readFile.bind(runtime)
-                );
-                if (result.errors.length > 0) {
-                    console.warn(`Scene "${scenePath}" loaded with errors:`, result.errors);
-                }
+            for (let i = 0; i < this._scenes.length; i++) {
+                const xml = await runtime.readFile(this._scenes[i]);
+                const nodes = parse(xml);
+                load(nodes, state);
+                loading?.update((sorted.length + i + 1) / total);
             }
         }
 
-        cleanup?.();
+        const warmable = sorted.filter((p) => p.warm);
+        let warmDone = 0;
+        const warmBase = sorted.length + this._scenes.length;
+
+        const warmPromises = warmable.map(async (plugin) => {
+            await plugin.warm!(state, (progress: number) => {
+                if (loading) {
+                    loading.update((warmBase + warmDone + progress) / total);
+                }
+            });
+            warmDone++;
+            loading?.update((warmBase + warmDone) / total);
+        });
+
+        await Promise.all(warmPromises);
+
+        if (cleanup) {
+            loading?.update(1);
+            await new Promise((r) => setTimeout(r, 200));
+            cleanup();
+        }
 
         return state;
     }

package/src/core/component.ts

@@ -12,7 +12,6 @@ export interface FieldAccessor {
 export interface ComponentTraits {
     defaults?: () => Record<string, number>;
     adapter?: (attrs: Record<string, string>, eid: number) => Record<string, number>;
-    accessors?: Record<string, FieldAccessor>;
 }
 
 const traitsMap = new WeakMap<ComponentLike, ComponentTraits>();
@@ -47,15 +46,30 @@ export function clearRegistry(): void {
     registry.clear();
 }
 
-export function directAccessor(
-    data: ComponentArray,
-    stride: number,
-    offset: number
-): FieldAccessor {
-    return {
-        get: (eid) => data[eid * stride + offset],
-        set: (eid, v) => {
-            data[eid * stride + offset] = v;
+export interface FieldProxy extends Array<number>, FieldAccessor {}
+
+export function createFieldProxy(data: Float32Array, stride: number, offset: number): FieldProxy {
+    function getValue(eid: number): number {
+        return data[eid * stride + offset];
+    }
+
+    function setValue(eid: number, value: number): void {
+        data[eid * stride + offset] = value;
+    }
+
+    return new Proxy([] as unknown as FieldProxy, {
+        get(_, prop) {
+            if (prop === "get") return getValue;
+            if (prop === "set") return setValue;
+            const eid = Number(prop);
+            if (Number.isNaN(eid)) return undefined;
+            return getValue(eid);
+        },
+        set(_, prop, value) {
+            const eid = Number(prop);
+            if (Number.isNaN(eid)) return false;
+            setValue(eid, value);
+            return true;
         },
-    };
+    });
 }

package/src/core/index.ts

@@ -24,7 +24,7 @@ export {
 } from "bitecs";
 
 export { State, MAX_ENTITIES } from "./state";
-export { StateBuilder } from "./builder";
+export { StateBuilder, NoLoading, type Plugin, type Loading } from "./builder";
 export { resource, type ResourceKey } from "./resource";
 export {
     Scheduler,
@@ -42,12 +42,13 @@ export {
     clearRegistry,
     getTraits,
     setTraits,
-    directAccessor,
+    createFieldProxy,
     type ComponentTraits,
     type ComponentData,
     type ComponentLike,
     type RegisteredComponent,
     type FieldAccessor,
+    type FieldProxy,
 } from "./component";
 
 export {
@@ -59,8 +60,6 @@ export {
     type RelationOptions,
 } from "./relation";
 
-export type { Plugin, Loading, InputState, MouseState, RenderContext } from "./types";
-
 export {
     clamp,
     lerp,
@@ -69,6 +68,11 @@ export {
     eulerToQuaternion,
     quaternionToEuler,
     lookAt,
+    perspective,
+    orthographic,
+    multiply,
+    invert,
+    extractFrustumPlanes,
 } from "./math";
 
 export { toKebabCase, toCamelCase } from "./strings";
@@ -76,18 +80,15 @@ export { toKebabCase, toCamelCase } from "./strings";
 export { initRuntime, getRuntime, resetRuntime, type Runtime, type RuntimeTarget } from "./runtime";
 
 export {
-    parseXml,
-    loadScene,
-    loadSceneFile,
+    parse,
+    serialize,
+    load,
     registerPostLoadHook,
     unregisterPostLoadHook,
-    type ParsedElement,
-    type EntityDef,
-    type EntityRef,
-    type ComponentDef,
-    type ParseResult,
+    type Node,
+    type Attr,
+    type Ref,
     type ParseError,
-    type LoadResult,
     type PostLoadHook,
     type PostLoadContext,
 } from "./xml";

package/src/core/math.ts

@@ -149,6 +149,141 @@ export function quaternionToEuler(
     }
 }
 
+export function perspective(fov: number, aspect: number, near: number, far: number): Float32Array {
+    if (fov <= 0) throw new Error(`Invalid FOV: ${fov} (must be > 0)`);
+    if (aspect <= 0) throw new Error(`Invalid aspect ratio: ${aspect} (must be > 0)`);
+    if (near === far) throw new Error(`Invalid depth planes: near === far (${near})`);
+    const f = 1 / Math.tan((fov * Math.PI) / 360);
+    const nf = 1 / (near - far);
+    return new Float32Array([
+        f / aspect,
+        0,
+        0,
+        0,
+        0,
+        f,
+        0,
+        0,
+        0,
+        0,
+        far * nf,
+        -1,
+        0,
+        0,
+        far * near * nf,
+        0,
+    ]);
+}
+
+export function orthographic(
+    size: number,
+    aspect: number,
+    near: number,
+    far: number
+): Float32Array {
+    if (size <= 0) throw new Error(`Invalid orthographic size: ${size} (must be > 0)`);
+    if (aspect <= 0) throw new Error(`Invalid aspect ratio: ${aspect} (must be > 0)`);
+    if (near === far) throw new Error(`Invalid depth planes: near === far (${near})`);
+    const lr = 1 / (size * aspect);
+    const bt = 1 / size;
+    const nf = 1 / (near - far);
+    return new Float32Array([lr, 0, 0, 0, 0, bt, 0, 0, 0, 0, nf, 0, 0, 0, near * nf, 1]);
+}
+
+export function multiply(a: Float32Array, b: Float32Array): Float32Array {
+    const out = new Float32Array(16);
+    for (let i = 0; i < 4; i++) {
+        for (let j = 0; j < 4; j++) {
+            out[j * 4 + i] =
+                a[i] * b[j * 4] +
+                a[i + 4] * b[j * 4 + 1] +
+                a[i + 8] * b[j * 4 + 2] +
+                a[i + 12] * b[j * 4 + 3];
+        }
+    }
+    return out;
+}
+
+export function invert(m: Float32Array): Float32Array {
+    const out = new Float32Array(16);
+    const r00 = m[0],
+        r01 = m[1],
+        r02 = m[2];
+    const r10 = m[4],
+        r11 = m[5],
+        r12 = m[6];
+    const r20 = m[8],
+        r21 = m[9],
+        r22 = m[10];
+    const tx = m[12],
+        ty = m[13],
+        tz = m[14];
+
+    out[0] = r00;
+    out[1] = r10;
+    out[2] = r20;
+    out[3] = 0;
+    out[4] = r01;
+    out[5] = r11;
+    out[6] = r21;
+    out[7] = 0;
+    out[8] = r02;
+    out[9] = r12;
+    out[10] = r22;
+    out[11] = 0;
+    out[12] = -(r00 * tx + r01 * ty + r02 * tz);
+    out[13] = -(r10 * tx + r11 * ty + r12 * tz);
+    out[14] = -(r20 * tx + r21 * ty + r22 * tz);
+    out[15] = 1;
+
+    return out;
+}
+
+export function extractFrustumPlanes(viewProj: Float32Array): Float32Array {
+    const planes = new Float32Array(24);
+    const m = viewProj;
+
+    planes[0] = m[3] + m[0];
+    planes[1] = m[7] + m[4];
+    planes[2] = m[11] + m[8];
+    planes[3] = m[15] + m[12];
+
+    planes[4] = m[3] - m[0];
+    planes[5] = m[7] - m[4];
+    planes[6] = m[11] - m[8];
+    planes[7] = m[15] - m[12];
+
+    planes[8] = m[3] + m[1];
+    planes[9] = m[7] + m[5];
+    planes[10] = m[11] + m[9];
+    planes[11] = m[15] + m[13];
+
+    planes[12] = m[3] - m[1];
+    planes[13] = m[7] - m[5];
+    planes[14] = m[11] - m[9];
+    planes[15] = m[15] - m[13];
+
+    planes[16] = m[2];
+    planes[17] = m[6];
+    planes[18] = m[10];
+    planes[19] = m[14];
+
+    planes[20] = m[3] - m[2];
+    planes[21] = m[7] - m[6];
+    planes[22] = m[11] - m[10];
+    planes[23] = m[15] - m[14];
+    for (let i = 0; i < 6; i++) {
+        const len = Math.hypot(planes[i * 4], planes[i * 4 + 1], planes[i * 4 + 2]);
+        if (len > 0) {
+            planes[i * 4] /= len;
+            planes[i * 4 + 1] /= len;
+            planes[i * 4 + 2] /= len;
+            planes[i * 4 + 3] /= len;
+        }
+    }
+    return planes;
+}
+
 export function lookAt(
     eyeX: number,
     eyeY: number,

package/src/core/runtime.ts

@@ -99,7 +99,6 @@ function isWebviewResource(path: string): boolean {
     return path.startsWith("/") || path.startsWith("./") || path.startsWith("../");
 }
 
-// Dynamic import path to prevent bundler static analysis
 const TAURI_FS_MODULE = "@tauri-apps/" + "plugin-fs";
 
 function createStandaloneRuntime(): Runtime {

package/src/core/state.ts

@@ -17,34 +17,23 @@ import {
 } from "bitecs";
 import { Scheduler, Time, type GameTime, type System } from "./scheduler";
 import type { RelationDef } from "./relation";
-import type { Plugin } from "./types";
-import type { StateBuilder } from "./builder";
+import type { Plugin, StateBuilder } from "./builder";
 import { initRuntime, type Runtime } from "./runtime";
-import {
-    registerComponent,
-    getTraits,
-    getRegisteredComponent,
-    directAccessor,
-    type ComponentData,
-    type FieldAccessor,
-} from "./component";
+import { registerComponent, getTraits, type ComponentData } from "./component";
 import { type ResourceKey } from "./resource";
-import { toCamelCase } from "./strings";
 
 export const MAX_ENTITIES = 65536;
 
 export class State {
     readonly world: World;
     readonly scheduler = new Scheduler();
-    readonly canvas: HTMLCanvasElement | null;
-    maxEid = 0;
 
     private _resources = new Map<symbol, unknown>();
     private _disposed = false;
     private _running = false;
     private _runtime: Runtime | null = null;
     private _lastTime = 0;
-    private _fieldAccessors: Map<number, FieldAccessor> | null = null;
+    private _maxEid = 0;
 
     get time(): Readonly<GameTime> {
         return this.scheduler.time;
@@ -54,6 +43,10 @@ export class State {
         return this._running;
     }
 
+    get maxEid(): number {
+        return this._maxEid;
+    }
+
     static Builder: (new () => StateBuilder) | null = null;
 
     static new(): StateBuilder {
@@ -63,9 +56,8 @@ export class State {
         return new State.Builder();
     }
 
-    constructor(canvas: HTMLCanvasElement | null = null) {
+    constructor() {
         this.world = createWorld();
-        this.canvas = canvas;
     }
 
     setResource<T>(key: ResourceKey<T>, value: T): void {
@@ -141,12 +133,11 @@ export class State {
         if (eid >= MAX_ENTITIES) {
             throw new Error(`Entity limit exceeded: ${eid} >= ${MAX_ENTITIES}`);
         }
-        if (eid > this.maxEid) this.maxEid = eid;
+        if (eid > this._maxEid) this._maxEid = eid;
         return eid;
     }
 
     removeEntity(eid: number): void {
-        this._fieldAccessors?.delete(eid);
         removeEntity(this.world, eid);
     }
 
@@ -236,59 +227,9 @@ export class State {
         return targets.length > 0 ? targets[0] : -1;
     }
 
-    private ensureFieldAccessors(): Map<number, FieldAccessor> {
-        if (!this._fieldAccessors) {
-            this._fieldAccessors = new Map();
-        }
-        return this._fieldAccessors;
-    }
-
-    resolveFieldPath(path: string): { component: string; field: string } | null {
-        const dotIndex = path.lastIndexOf(".");
-        if (dotIndex === -1) return null;
-        return {
-            component: path.slice(0, dotIndex),
-            field: path.slice(dotIndex + 1),
-        };
-    }
-
-    bindFieldAccessor(
-        bindingId: number,
-        componentName: string,
-        fieldPath: string
-    ): FieldAccessor | null {
-        const registered = getRegisteredComponent(componentName);
-        if (!registered) return null;
-
-        const camelPath = toCamelCase(fieldPath);
-
-        const traits = getTraits(registered.component);
-        if (traits?.accessors?.[camelPath]) {
-            const accessor = traits.accessors[camelPath];
-            this.ensureFieldAccessors().set(bindingId, accessor);
-            return accessor;
-        }
-
-        const array = registered.component[camelPath];
-        if (array == null || !(ArrayBuffer.isView(array) || Array.isArray(array))) return null;
-
-        const accessor = directAccessor(array as number[], 1, 0);
-        this.ensureFieldAccessors().set(bindingId, accessor);
-        return accessor;
-    }
-
-    getFieldAccessor(bindingId: number): FieldAccessor | undefined {
-        return this._fieldAccessors?.get(bindingId);
-    }
-
-    removeFieldAccessor(bindingId: number): boolean {
-        return this._fieldAccessors?.delete(bindingId) ?? false;
-    }
-
     dispose(): void {
         if (this._disposed) return;
         this.stop();
-        this._fieldAccessors = null;
         for (const system of this.scheduler.systems) {
             system.dispose?.(this);
         }