@multiplekex/shallot 0.1.7 → 0.1.10

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@multiplekex/shallot",
-    "version": "0.1.7",
+    "version": "0.1.10",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",
@@ -25,9 +25,9 @@
         "@napi-rs/canvas": "^0.1.88",
         "@types/bun": "latest",
         "@types/three": "^0.182.0",
+        "bun-webgpu": "^0.1.4",
         "three": "^0.182.0",
         "troika-three-text": "^0.52.4",
-        "webgpu": "^0.3.8",
         "wgpu-matrix": "^3.4.0"
     },
     "peerDependencies": {

package/src/core/component.ts

@@ -1,14 +1,8 @@
-import type { State } from "./state";
 import { toKebabCase } from "./strings";
 
 export type ComponentArray = number[] | Float32Array | Uint32Array;
 export type ComponentData = Record<string, ComponentArray>;
-
-export interface ParseContext {
-    readonly currentEid: number;
-    getEntityByName(name: string): number | null;
-    setName(name: string, eid: number): void;
-}
+export type ComponentLike = Record<string, unknown>;
 
 export interface FieldAccessor {
     get(eid: number): number;
@@ -17,33 +11,29 @@ export interface FieldAccessor {
 
 export interface ComponentTraits {
     defaults?: () => Record<string, number>;
-    adapter?: (
-        attrs: Record<string, string>,
-        state: State,
-        context: ParseContext
-    ) => Record<string, number>;
+    adapter?: (attrs: Record<string, string>, eid: number) => Record<string, number>;
     accessors?: Record<string, FieldAccessor>;
 }
 
-const traitsMap = new WeakMap<ComponentData, ComponentTraits>();
+const traitsMap = new WeakMap<ComponentLike, ComponentTraits>();
 
-export function setTraits(component: ComponentData, traits: ComponentTraits): void {
+export function setTraits(component: ComponentLike, traits: ComponentTraits): void {
     traitsMap.set(component, traits);
 }
 
-export function getTraits(component: ComponentData): ComponentTraits | undefined {
+export function getTraits(component: ComponentLike): ComponentTraits | undefined {
     return traitsMap.get(component);
 }
 
 export interface RegisteredComponent {
-    readonly component: ComponentData;
+    readonly component: ComponentLike;
     readonly name: string;
     readonly traits?: ComponentTraits;
 }
 
 const registry = new Map<string, RegisteredComponent>();
 
-export function registerComponent(name: string, component: ComponentData): void {
+export function registerComponent(name: string, component: ComponentLike): void {
     const kebabName = toKebabCase(name);
     const traits = traitsMap.get(component);
     registry.set(kebabName, { component, name: kebabName, traits });

package/src/core/index.ts

@@ -43,9 +43,9 @@ export {
     getTraits,
     setTraits,
     directAccessor,
-    type ParseContext,
     type ComponentTraits,
     type ComponentData,
+    type ComponentLike,
     type RegisteredComponent,
     type FieldAccessor,
 } from "./component";
@@ -89,4 +89,5 @@ export {
     type ParseError,
     type LoadResult,
     type PostLoadHook,
+    type PostLoadContext,
 } from "./xml";

package/src/core/math.ts

@@ -20,6 +20,12 @@ export function slerp(
     toW: number,
     t: number
 ): { x: number; y: number; z: number; w: number } {
+    if (!Number.isFinite(t) || !Number.isFinite(fromW) || !Number.isFinite(toW)) {
+        throw new Error(
+            `slerp received NaN: from=[${fromX},${fromY},${fromZ},${fromW}], to=[${toX},${toY},${toZ},${toW}], t=${t}`
+        );
+    }
+
     let dot = fromX * toX + fromY * toY + fromZ * toZ + fromW * toW;
 
     if (dot < 0) {
@@ -154,6 +160,19 @@ export function lookAt(
     upY = 1,
     upZ = 0
 ): { x: number; y: number; z: number; w: number } {
+    if (
+        !Number.isFinite(eyeX) ||
+        !Number.isFinite(eyeY) ||
+        !Number.isFinite(eyeZ) ||
+        !Number.isFinite(targetX) ||
+        !Number.isFinite(targetY) ||
+        !Number.isFinite(targetZ)
+    ) {
+        throw new Error(
+            `lookAt received NaN: eye=[${eyeX},${eyeY},${eyeZ}], target=[${targetX},${targetY},${targetZ}]`
+        );
+    }
+
     let zx = eyeX - targetX;
     let zy = eyeY - targetY;
     let zz = eyeZ - targetZ;
@@ -173,7 +192,7 @@ export function lookAt(
     let xz = upX * zy - upY * zx;
     let xLen = Math.sqrt(xx * xx + xy * xy + xz * xz);
 
-    if (xLen === 0) {
+    if (xLen < 1e-6) {
         if (Math.abs(zz) > Math.abs(zx)) {
             upX += 1e-4;
         } else {
@@ -185,10 +204,16 @@ export function lookAt(
         xLen = Math.sqrt(xx * xx + xy * xy + xz * xz);
     }
 
-    xLen = 1 / xLen;
-    xx *= xLen;
-    xy *= xLen;
-    xz *= xLen;
+    if (xLen < 1e-6) {
+        xx = 1;
+        xy = 0;
+        xz = 0;
+    } else {
+        xLen = 1 / xLen;
+        xx *= xLen;
+        xy *= xLen;
+        xz *= xLen;
+    }
 
     const yx = zy * xz - zz * xy;
     const yy = zz * xx - zx * xz;

package/src/core/state.ts

@@ -37,6 +37,7 @@ 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;
@@ -140,6 +141,7 @@ export class State {
         if (eid >= MAX_ENTITIES) {
             throw new Error(`Entity limit exceeded: ${eid} >= ${MAX_ENTITIES}`);
         }
+        if (eid > this.maxEid) this.maxEid = eid;
         return eid;
     }
 
@@ -268,9 +270,9 @@ export class State {
         }
 
         const array = registered.component[camelPath];
-        if (array == null) return null;
+        if (array == null || !(ArrayBuffer.isView(array) || Array.isArray(array))) return null;
 
-        const accessor = directAccessor(array, 1, 0);
+        const accessor = directAccessor(array as number[], 1, 0);
         this.ensureFieldAccessors().set(bindingId, accessor);
         return accessor;
     }

package/src/core/types.ts

@@ -1,11 +1,11 @@
 import type { System } from "./scheduler";
-import type { ComponentData } from "./component";
+import type { ComponentLike } from "./component";
 import type { RelationDef } from "./relation";
 import type { State } from "./state";
 
 export interface Plugin {
     readonly systems?: readonly System[];
-    readonly components?: Record<string, ComponentData>;
+    readonly components?: Record<string, ComponentLike>;
     readonly relations?: readonly RelationDef[];
     readonly dependencies?: readonly Plugin[];
     readonly initialize?: (state: State) => void | Promise<void>;

package/src/core/xml.ts

@@ -1,12 +1,7 @@
 import { XMLParser } from "fast-xml-parser";
 import { addComponent, Pair } from "bitecs";
 import type { State } from "./state";
-import {
-    getRegisteredComponent,
-    type ParseContext,
-    type ComponentData,
-    type RegisteredComponent,
-} from "./component";
+import { getRegisteredComponent, type ComponentLike, type RegisteredComponent } from "./component";
 import { getRelationDef, ChildOf } from "./relation";
 import { toKebabCase, toCamelCase } from "./strings";
 
@@ -100,6 +95,13 @@ export interface ParseError {
     readonly path?: string;
 }
 
+export interface PendingFieldRef {
+    readonly eid: number;
+    readonly component: ComponentLike;
+    readonly field: string;
+    readonly targetName: string;
+}
+
 export function parseXml(xml: string): ParseResult {
     const errors: ParseError[] = [];
     const warnings: string[] = [];
@@ -276,7 +278,11 @@ export interface LoadResult {
     readonly errors: readonly ParseError[];
 }
 
-export type PostLoadHook = (state: State, context: ParseContext) => void;
+export interface PostLoadContext {
+    getEntityByName(name: string): number | null;
+}
+
+export type PostLoadHook = (state: State, context: PostLoadContext) => void;
 
 const postLoadHooks: PostLoadHook[] = [];
 
@@ -289,17 +295,8 @@ export function unregisterPostLoadHook(hook: PostLoadHook): void {
     if (idx !== -1) postLoadHooks.splice(idx, 1);
 }
 
-class LoadParseContext implements ParseContext {
+class LoadParseContext implements PostLoadContext {
     private readonly nameToEntity = new Map<string, number>();
-    private _currentEid = 0;
-
-    get currentEid(): number {
-        return this._currentEid;
-    }
-
-    setCurrentEid(eid: number): void {
-        this._currentEid = eid;
-    }
 
     getEntityByName(name: string): number | null {
         return this.nameToEntity.get(name) ?? null;
@@ -343,6 +340,7 @@ function instantiateScene(
     const errors: ParseError[] = [...parseErrors];
     const queue: QueuedEntity[] = [];
     const roots: number[] = [];
+    const pendingFieldRefs: PendingFieldRef[] = [];
 
     for (const entityDef of entityDefs) {
         const eid = createEntityTree(state, entityDef, context, undefined, queue);
@@ -359,10 +357,19 @@ function instantiateScene(
         }
 
         for (const compDef of def.components) {
-            applyComponent(state, eid, compDef, context, errors);
+            applyComponent(state, eid, compDef, context, errors, pendingFieldRefs);
         }
     }
 
+    for (const ref of pendingFieldRefs) {
+        const targetEid = context.getEntityByName(ref.targetName);
+        if (targetEid === null) {
+            errors.push({ message: `Unknown entity: "@${ref.targetName}"` });
+            continue;
+        }
+        setFieldValue(ref.component, ref.field, ref.eid, targetEid);
+    }
+
     for (const hook of postLoadHooks) {
         hook(state, context);
     }
@@ -423,7 +430,8 @@ function applyComponent(
     eid: number,
     compDef: ComponentDef,
     context: LoadParseContext,
-    errors: ParseError[]
+    errors: ParseError[],
+    pendingFieldRefs: PendingFieldRef[]
 ): void {
     const { def, attrs } = compDef;
     const { component, name, traits } = def;
@@ -436,13 +444,14 @@ function applyComponent(
     }
 
     let values: Record<string, number>;
+    let entityRefs: FieldEntityRef[] = [];
 
-    context.setCurrentEid(eid);
     if (traits?.adapter) {
-        values = traits.adapter(attrs, state, context) as Record<string, number>;
+        values = traits.adapter(attrs, eid);
     } else {
         const result = parseAttrs(def, attrs);
         values = result.values;
+        entityRefs = result.entityRefs;
         for (const err of result.errors) {
             errors.push({ message: `<${name}> ${err}` });
         }
@@ -451,19 +460,33 @@ function applyComponent(
     for (const [field, value] of Object.entries(values)) {
         setFieldValue(component, field, eid, value);
     }
+
+    for (const ref of entityRefs) {
+        pendingFieldRefs.push({
+            eid,
+            component,
+            field: ref.field,
+            targetName: ref.targetName,
+        });
+    }
+}
+
+interface ParseAttrsResult {
+    values: Record<string, number>;
+    entityRefs: FieldEntityRef[];
+    errors: string[];
 }
 
-function parseAttrs(
-    def: RegisteredComponent,
-    attrs: Record<string, string>
-): { values: Record<string, number>; errors: string[] } {
+function parseAttrs(def: RegisteredComponent, attrs: Record<string, string>): ParseAttrsResult {
     const allValues: Record<string, number> = {};
+    const allEntityRefs: FieldEntityRef[] = [];
     const allErrors: string[] = [];
 
     if (attrs._value) {
         if (isCSSAttrSyntax(attrs._value)) {
             const result = parsePropertyString(def.name, attrs._value, def.component);
             Object.assign(allValues, result.values);
+            allEntityRefs.push(...result.entityRefs);
             allErrors.push(...result.errors);
         }
     }
@@ -475,6 +498,7 @@ function parseAttrs(
         if (isCSSAttrSyntax(attrValue)) {
             const result = parsePropertyString(def.name, attrValue, def.component);
             Object.assign(allValues, result.values);
+            allEntityRefs.push(...result.entityRefs);
             allErrors.push(...result.errors);
         } else {
             const result = parsePropertyString(
@@ -483,34 +507,41 @@ function parseAttrs(
                 def.component
             );
             Object.assign(allValues, result.values);
+            allEntityRefs.push(...result.entityRefs);
             allErrors.push(...result.errors);
         }
     }
 
-    return { values: allValues, errors: allErrors };
+    return { values: allValues, entityRefs: allEntityRefs, errors: allErrors };
 }
 
-function setFieldValue(component: ComponentData, field: string, eid: number, value: number): void {
+function setFieldValue(component: ComponentLike, field: string, eid: number, value: number): void {
     const arr = component[field];
     if (arr != null && (ArrayBuffer.isView(arr) || Array.isArray(arr))) {
-        arr[eid] = value;
+        (arr as number[])[eid] = value;
     }
 }
 
+interface FieldEntityRef {
+    readonly field: string;
+    readonly targetName: string;
+}
+
 interface PropertyParseResult {
     readonly values: Record<string, number>;
+    readonly entityRefs: readonly FieldEntityRef[];
     readonly errors: readonly string[];
 }
 
-function detectVec2(component: ComponentData, base: string): boolean {
+function detectVec2(component: ComponentLike, base: string): boolean {
     return `${base}X` in component && `${base}Y` in component;
 }
 
-function detectVec3(component: ComponentData, base: string): boolean {
+function detectVec3(component: ComponentLike, base: string): boolean {
     return detectVec2(component, base) && `${base}Z` in component;
 }
 
-function detectVec4(component: ComponentData, base: string): boolean {
+function detectVec4(component: ComponentLike, base: string): boolean {
     return detectVec3(component, base) && `${base}W` in component;
 }
 
@@ -565,9 +596,10 @@ function splitProperties(str: string): string[] {
 function parsePropertyString(
     componentName: string,
     propertyString: string,
-    component: ComponentData
+    component: ComponentLike
 ): PropertyParseResult {
     const values: Record<string, number> = {};
+    const entityRefs: FieldEntityRef[] = [];
     const errors: string[] = [];
 
     const properties = splitProperties(propertyString);
@@ -588,6 +620,24 @@ function parsePropertyString(
         }
 
         const name = toCamelCase(rawName);
+
+        if (valueStr.startsWith("@") && valueStr.length > 1) {
+            if (name in component) {
+                entityRefs.push({ field: name, targetName: valueStr.slice(1) });
+            } else {
+                const fieldNames = Object.keys(component);
+                const suggestion = findClosestMatch(rawName, fieldNames);
+                if (suggestion) {
+                    errors.push(
+                        `${componentName}: unknown field "${rawName}", did you mean "${toKebabCase(suggestion)}"?`
+                    );
+                } else {
+                    errors.push(`${componentName}: unknown field "${rawName}"`);
+                }
+            }
+            continue;
+        }
+
         const parsed = parseValues(valueStr);
 
         if (parsed.some((v) => v === null)) {
@@ -668,7 +718,7 @@ function parsePropertyString(
         }
     }
 
-    return { values, errors };
+    return { values, entityRefs, errors };
 }
 
 function isCSSAttrSyntax(value: string): boolean {