@multiplekex/shallot 0.2.4 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@multiplekex/shallot",
-    "version": "0.2.4",
+    "version": "0.3.0",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",

package/src/core/component.ts

@@ -11,7 +11,7 @@ export interface FieldAccessor {
 
 export interface ComponentTraits {
     defaults?: () => Record<string, number>;
-    adapter?: (attrs: Record<string, string>, eid: number) => Record<string, number>;
+    parse?: Record<string, (value: string) => number | undefined>;
 }
 
 const traitsMap = new WeakMap<ComponentLike, ComponentTraits>();

package/src/core/index.ts

@@ -79,16 +79,4 @@ export { toKebabCase, toCamelCase } from "./strings";
 
 export { initRuntime, getRuntime, resetRuntime, type Runtime, type RuntimeTarget } from "./runtime";
 
-export {
-    parse,
-    serialize,
-    load,
-    registerPostLoadHook,
-    unregisterPostLoadHook,
-    type Node,
-    type Attr,
-    type Ref,
-    type ParseError,
-    type PostLoadHook,
-    type PostLoadContext,
-} from "./xml";
+export { parse, serialize, load, type Node, type Attr, type Ref, type ParseError } from "./xml";

package/src/core/math.ts

@@ -284,6 +284,192 @@ export function extractFrustumPlanes(viewProj: Float32Array): Float32Array {
     return planes;
 }
 
+export function lookAtMatrix(
+    eyeX: number,
+    eyeY: number,
+    eyeZ: number,
+    targetX: number,
+    targetY: number,
+    targetZ: number,
+    upX = 0,
+    upY = 1,
+    upZ = 0
+): Float32Array {
+    let zx = eyeX - targetX;
+    let zy = eyeY - targetY;
+    let zz = eyeZ - targetZ;
+    let zLen = Math.sqrt(zx * zx + zy * zy + zz * zz);
+
+    if (zLen < 1e-6) {
+        zx = 0;
+        zy = 0;
+        zz = 1;
+    } else {
+        zLen = 1 / zLen;
+        zx *= zLen;
+        zy *= zLen;
+        zz *= zLen;
+    }
+
+    let xx = upY * zz - upZ * zy;
+    let xy = upZ * zx - upX * zz;
+    let xz = upX * zy - upY * zx;
+    let xLen = Math.sqrt(xx * xx + xy * xy + xz * xz);
+
+    if (xLen < 1e-6) {
+        if (Math.abs(zy) > 0.9) {
+            xx = 1;
+            xy = 0;
+            xz = 0;
+        } else {
+            xx = -zz;
+            xy = 0;
+            xz = zx;
+        }
+        xLen = Math.sqrt(xx * xx + xy * xy + xz * xz);
+    }
+
+    xLen = 1 / xLen;
+    xx *= xLen;
+    xy *= xLen;
+    xz *= xLen;
+
+    const yx = zy * xz - zz * xy;
+    const yy = zz * xx - zx * xz;
+    const yz = zx * xy - zy * xx;
+
+    const tx = -(xx * eyeX + xy * eyeY + xz * eyeZ);
+    const ty = -(yx * eyeX + yy * eyeY + yz * eyeZ);
+    const tz = -(zx * eyeX + zy * eyeY + zz * eyeZ);
+
+    return new Float32Array([xx, yx, zx, 0, xy, yy, zy, 0, xz, yz, zz, 0, tx, ty, tz, 1]);
+}
+
+export function orthographicBounds(
+    left: number,
+    right: number,
+    bottom: number,
+    top: number,
+    near: number,
+    far: number
+): Float32Array {
+    const lr = 1 / (right - left);
+    const bt = 1 / (top - bottom);
+    const nf = 1 / (near - far);
+
+    return new Float32Array([
+        2 * lr,
+        0,
+        0,
+        0,
+        0,
+        2 * bt,
+        0,
+        0,
+        0,
+        0,
+        nf,
+        0,
+        -(right + left) * lr,
+        -(top + bottom) * bt,
+        near * nf,
+        1,
+    ]);
+}
+
+export function extractFrustumCorners(
+    invViewProj: Float32Array,
+    nearZ: number,
+    farZ: number
+): Float32Array {
+    const corners = new Float32Array(24);
+    const ndcCorners = [
+        [-1, -1, nearZ],
+        [1, -1, nearZ],
+        [-1, 1, nearZ],
+        [1, 1, nearZ],
+        [-1, -1, farZ],
+        [1, -1, farZ],
+        [-1, 1, farZ],
+        [1, 1, farZ],
+    ];
+
+    for (let i = 0; i < 8; i++) {
+        const [nx, ny, nz] = ndcCorners[i];
+        const m = invViewProj;
+
+        const wx = m[0] * nx + m[4] * ny + m[8] * nz + m[12];
+        const wy = m[1] * nx + m[5] * ny + m[9] * nz + m[13];
+        const wz = m[2] * nx + m[6] * ny + m[10] * nz + m[14];
+        const ww = m[3] * nx + m[7] * ny + m[11] * nz + m[15];
+
+        corners[i * 3] = wx / ww;
+        corners[i * 3 + 1] = wy / ww;
+        corners[i * 3 + 2] = wz / ww;
+    }
+
+    return corners;
+}
+
+export function invertMatrix(m: Float32Array): Float32Array {
+    const out = new Float32Array(16);
+
+    const a00 = m[0],
+        a01 = m[1],
+        a02 = m[2],
+        a03 = m[3];
+    const a10 = m[4],
+        a11 = m[5],
+        a12 = m[6],
+        a13 = m[7];
+    const a20 = m[8],
+        a21 = m[9],
+        a22 = m[10],
+        a23 = m[11];
+    const a30 = m[12],
+        a31 = m[13],
+        a32 = m[14],
+        a33 = m[15];
+
+    const b00 = a00 * a11 - a01 * a10;
+    const b01 = a00 * a12 - a02 * a10;
+    const b02 = a00 * a13 - a03 * a10;
+    const b03 = a01 * a12 - a02 * a11;
+    const b04 = a01 * a13 - a03 * a11;
+    const b05 = a02 * a13 - a03 * a12;
+    const b06 = a20 * a31 - a21 * a30;
+    const b07 = a20 * a32 - a22 * a30;
+    const b08 = a20 * a33 - a23 * a30;
+    const b09 = a21 * a32 - a22 * a31;
+    const b10 = a21 * a33 - a23 * a31;
+    const b11 = a22 * a33 - a23 * a32;
+
+    let det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+    if (Math.abs(det) < 1e-10) {
+        return out;
+    }
+    det = 1 / det;
+
+    out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;
+    out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det;
+    out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det;
+    out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det;
+    out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det;
+    out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det;
+    out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det;
+    out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det;
+    out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det;
+    out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det;
+    out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det;
+    out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det;
+    out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det;
+    out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det;
+    out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det;
+    out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det;
+
+    return out;
+}
+
 export function lookAt(
     eyeX: number,
     eyeY: number,

package/src/core/state.ts

@@ -20,7 +20,7 @@ import type { RelationDef } from "./relation";
 import type { Plugin, StateBuilder } from "./builder";
 import { initRuntime, type Runtime } from "./runtime";
 import { registerComponent, getTraits, type ComponentData } from "./component";
-import { type ResourceKey } from "./resource";
+import type { ResourceKey } from "./resource";
 
 export const MAX_ENTITIES = 65536;
 

package/src/core/xml.ts

@@ -1,6 +1,11 @@
 import { addComponent, Pair } from "bitecs";
 import type { State } from "./state";
-import { getRegisteredComponent, type ComponentLike, type RegisteredComponent } from "./component";
+import {
+    getRegisteredComponent,
+    getTraits,
+    type ComponentLike,
+    type RegisteredComponent,
+} from "./component";
 import { getRelationDef, ChildOf } from "./relation";
 import { toKebabCase, toCamelCase } from "./strings";
 
@@ -136,7 +141,7 @@ function tokenize(xml: string): Token[] {
 
 function parseTagAttrs(tag: string): Record<string, string> {
     const attrs: Record<string, string> = {};
-    const attrRegex = /([^\s=<>\/]+)(?:\s*=\s*"([^"]*)")?/g;
+    const attrRegex = /([^\s=<>/]+)(?:\s*=\s*"([^"]*)")?/g;
     const inner = tag.replace(/^<\s*\w+/, "").replace(/\/?>$/, "");
     let match: RegExpExecArray | null;
 
@@ -312,23 +317,6 @@ function parseNodeFromTokens(
     };
 }
 
-export interface PostLoadContext {
-    getEntityByName(name: string): number | null;
-}
-
-export type PostLoadHook = (state: State, context: PostLoadContext) => void;
-
-const postLoadHooks: PostLoadHook[] = [];
-
-export function registerPostLoadHook(hook: PostLoadHook): void {
-    postLoadHooks.push(hook);
-}
-
-export function unregisterPostLoadHook(hook: PostLoadHook): void {
-    const idx = postLoadHooks.indexOf(hook);
-    if (idx !== -1) postLoadHooks.splice(idx, 1);
-}
-
 interface QueuedEntity {
     node: Node;
     eid: number;
@@ -376,13 +364,6 @@ export function load(nodes: Node[], state: State): Map<Node, number> {
         setFieldValue(ref.component, ref.field, ref.eid, targetEid);
     }
 
-    const context: PostLoadContext = {
-        getEntityByName: (name) => nameToEntity.get(name) ?? null,
-    };
-    for (const hook of postLoadHooks) {
-        hook(state, context);
-    }
-
     if (errors.length > 0) {
         throw new Error(errors.map((e) => e.message).join("\n"));
     }
@@ -487,24 +468,22 @@ function applyComponent(
         props["_value"] = value;
     }
 
-    let values: Record<string, number>;
-    let entityRefs: { field: string; targetName: string }[] = [];
-
-    if (traits?.adapter) {
-        values = traits.adapter(props, eid);
-    } else {
-        const result = parseAttrs(def, props);
-        values = result.values;
-        entityRefs = result.entityRefs;
-        for (const err of result.errors) {
-            errors.push({ message: `<${name}> ${err}` });
-        }
+    const result = parseAttrs(def, props);
+    const values = result.values;
+    const strings = result.strings;
+    const entityRefs = result.entityRefs;
+    for (const err of result.errors) {
+        errors.push({ message: `<${name}> ${err}` });
     }
 
     for (const [field, val] of Object.entries(values)) {
         setFieldValue(component, field, eid, val);
     }
 
+    for (const [field, val] of Object.entries(strings)) {
+        setString(component, field, eid, val);
+    }
+
     for (const ref of entityRefs) {
         pendingFieldRefs.push({
             eid,
@@ -520,10 +499,12 @@ function parseAttrs(
     props: Record<string, string>
 ): {
     values: Record<string, number>;
+    strings: Record<string, string>;
     entityRefs: { field: string; targetName: string }[];
     errors: string[];
 } {
     const allValues: Record<string, number> = {};
+    const allStrings: Record<string, string> = {};
     const allEntityRefs: { field: string; targetName: string }[] = [];
     const allErrors: string[] = [];
 
@@ -531,6 +512,7 @@ function parseAttrs(
         if (isCSSAttrSyntax(props._value)) {
             const result = parsePropertyString(def.name, props._value, def.component);
             Object.assign(allValues, result.values);
+            Object.assign(allStrings, result.strings);
             allEntityRefs.push(...result.entityRefs);
             allErrors.push(...result.errors);
         }
@@ -543,6 +525,7 @@ function parseAttrs(
         if (isCSSAttrSyntax(propValue)) {
             const result = parsePropertyString(def.name, propValue, def.component);
             Object.assign(allValues, result.values);
+            Object.assign(allStrings, result.strings);
             allEntityRefs.push(...result.entityRefs);
             allErrors.push(...result.errors);
         } else {
@@ -552,12 +535,13 @@ function parseAttrs(
                 def.component
             );
             Object.assign(allValues, result.values);
+            Object.assign(allStrings, result.strings);
             allEntityRefs.push(...result.entityRefs);
             allErrors.push(...result.errors);
         }
     }
 
-    return { values: allValues, entityRefs: allEntityRefs, errors: allErrors };
+    return { values: allValues, strings: allStrings, entityRefs: allEntityRefs, errors: allErrors };
 }
 
 function setFieldValue(component: ComponentLike, field: string, eid: number, value: number): void {
@@ -567,6 +551,17 @@ function setFieldValue(component: ComponentLike, field: string, eid: number, val
     }
 }
 
+function isStringField(component: ComponentLike, field: string): boolean {
+    const val = component[field];
+    if (val == null) return false;
+    if (ArrayBuffer.isView(val) || Array.isArray(val)) return false;
+    return typeof val === "object";
+}
+
+function setString(component: ComponentLike, field: string, eid: number, value: string): void {
+    (component[field] as Record<number, string>)[eid] = value;
+}
+
 function detectVec2(component: ComponentLike, base: string): boolean {
     return `${base}X` in component && `${base}Y` in component;
 }
@@ -594,7 +589,7 @@ function parseNumber(value: string): number | null {
     if (value === "false") return 0;
 
     const num = parseFloat(value);
-    return isNaN(num) ? null : num;
+    return Number.isNaN(num) ? null : num;
 }
 
 function parseValues(valueStr: string): (number | null)[] {
@@ -633,10 +628,12 @@ function parsePropertyString(
     component: ComponentLike
 ): {
     values: Record<string, number>;
+    strings: Record<string, string>;
     entityRefs: { field: string; targetName: string }[];
     errors: string[];
 } {
     const values: Record<string, number> = {};
+    const strings: Record<string, string> = {};
     const entityRefs: { field: string; targetName: string }[] = [];
     const errors: string[] = [];
 
@@ -679,6 +676,24 @@ function parsePropertyString(
         const parsed = parseValues(valueStr);
 
         if (parsed.some((v) => v === null)) {
+            const rawValue = valueStr.trim();
+
+            if (name in component && isStringField(component, name)) {
+                strings[name] = rawValue;
+                continue;
+            }
+
+            if (parsed.length === 1) {
+                const traits = getTraits(component);
+                const parseFn = traits?.parse?.[name];
+                if (parseFn) {
+                    const resolved = parseFn(rawValue);
+                    if (resolved !== undefined) {
+                        values[name] = resolved;
+                        continue;
+                    }
+                }
+            }
             errors.push(`Invalid number in "${prop}"`);
             continue;
         }
@@ -756,7 +771,7 @@ function parsePropertyString(
         }
     }
 
-    return { values, entityRefs, errors };
+    return { values, strings, entityRefs, errors };
 }
 
 function isCSSAttrSyntax(value: string): boolean {

package/src/extras/arrows/index.ts

@@ -17,8 +17,8 @@ import {
     type Draw,
     type SharedPassContext,
 } from "../../standard/render";
-import { DEPTH_FORMAT } from "../../standard/render/scene";
-import { SCENE_STRUCT_WGSL } from "../../standard/render/shaders";
+import { Z_FORMAT } from "../../standard/render/scene";
+import { SCENE_STRUCT_WGSL } from "../../standard/render/surface/structs";
 import { Transform } from "../../standard/transforms";
 import { Line, Lines, LinesPlugin } from "../lines";
 
@@ -198,7 +198,7 @@ export function createArrowsPipeline(
             topology: "triangle-list",
         },
         depthStencil: {
-            format: DEPTH_FORMAT,
+            format: Z_FORMAT,
             depthCompare: "less",
             depthWriteEnabled: false,
         },

package/src/extras/caustic.ts

@@ -0,0 +1,37 @@
+import { surface } from "../standard/render/surface";
+
+export const Caustic = surface({
+    fragment: `
+    let uv = (*surface).worldPos.xz;
+    let t = scene.time * 0.5;
+
+    // Fine caustic network
+    let f1 = sin(uv.x * 4.0 + t * 1.3 + sin(uv.y * 3.0 + t * 0.9) * 0.6);
+    let f2 = sin(uv.y * 5.0 - t * 1.1 + sin(uv.x * 3.5 - t * 0.7) * 0.5);
+    let f3 = sin((uv.x + uv.y) * 3.5 + t * 0.8);
+    let f4 = sin((uv.x - uv.y) * 4.0 - t * 1.2);
+    let f5 = sin(uv.x * 6.0 - uv.y * 2.5 + t * 1.5);
+    let f6 = sin(uv.y * 6.5 + uv.x * 2.0 - t * 1.0);
+
+    // Medium detail layer
+    let m1 = sin(uv.x * 2.5 + t * 0.7 + sin(uv.y * 1.5 + t * 0.5) * 0.4);
+    let m2 = sin(uv.y * 2.8 - t * 0.6 + sin(uv.x * 2.0 - t * 0.4) * 0.3);
+
+    // Sharp caustic lines using high power
+    let c1 = pow(max(0.0, 1.0 - abs(f1)), 12.0);
+    let c2 = pow(max(0.0, 1.0 - abs(f2)), 12.0);
+    let c3 = pow(max(0.0, 1.0 - abs(f3)), 10.0);
+    let c4 = pow(max(0.0, 1.0 - abs(f4)), 10.0);
+    let c5 = pow(max(0.0, 1.0 - abs(f5)), 14.0);
+    let c6 = pow(max(0.0, 1.0 - abs(f6)), 14.0);
+    let c7 = pow(max(0.0, 1.0 - abs(m1)), 8.0);
+    let c8 = pow(max(0.0, 1.0 - abs(m2)), 8.0);
+
+    // Combine layers with variation
+    let fine = (c1 + c2 + c3 + c4 + c5 + c6) * 0.12;
+    let medium = (c7 + c8) * 0.15;
+    let caustic = fine + medium;
+
+    let light = scene.sunColor.rgb * caustic * 0.3;
+    (*surface).baseColor += light;`,
+});