@multiplekex/shallot 0.1.12 → 0.2.0

package/src/standard/render/triangle.ts

@@ -0,0 +1,84 @@
+import type { MeshData } from "./mesh";
+import type { Vec3, Triangle } from "./bvh/structs";
+
+export type { Triangle };
+
+export interface FlatTriangle {
+    v0x: number;
+    v0y: number;
+    v0z: number;
+    v1x: number;
+    v1y: number;
+    v1z: number;
+    v2x: number;
+    v2y: number;
+    v2z: number;
+    n0x: number;
+    n0y: number;
+    n0z: number;
+    n1x: number;
+    n1y: number;
+    n1z: number;
+    n2x: number;
+    n2y: number;
+    n2z: number;
+    entityId: number;
+}
+
+function transformPoint(x: number, y: number, z: number, m: Float32Array): Vec3 {
+    return {
+        x: m[0] * x + m[4] * y + m[8] * z + m[12],
+        y: m[1] * x + m[5] * y + m[9] * z + m[13],
+        z: m[2] * x + m[6] * y + m[10] * z + m[14],
+    };
+}
+
+function transformNormal(nx: number, ny: number, nz: number, m: Float32Array): Vec3 {
+    const x = m[0] * nx + m[4] * ny + m[8] * nz;
+    const y = m[1] * nx + m[5] * ny + m[9] * nz;
+    const z = m[2] * nx + m[6] * ny + m[10] * nz;
+    const len = Math.sqrt(x * x + y * y + z * z);
+    if (len === 0) return { x: 0, y: 0, z: 0 };
+    return { x: x / len, y: y / len, z: z / len };
+}
+
+export function extractTriangles(
+    mesh: MeshData,
+    entityId: number,
+    transform?: Float32Array
+): Triangle[] {
+    const triangles: Triangle[] = [];
+    const { vertices, indices } = mesh;
+    const stride = 6;
+
+    for (let i = 0; i < indices.length; i += 3) {
+        const i0 = indices[i] * stride;
+        const i1 = indices[i + 1] * stride;
+        const i2 = indices[i + 2] * stride;
+
+        let v0: Vec3 = { x: vertices[i0], y: vertices[i0 + 1], z: vertices[i0 + 2] };
+        let n0: Vec3 = { x: vertices[i0 + 3], y: vertices[i0 + 4], z: vertices[i0 + 5] };
+
+        let v1: Vec3 = { x: vertices[i1], y: vertices[i1 + 1], z: vertices[i1 + 2] };
+        let n1: Vec3 = { x: vertices[i1 + 3], y: vertices[i1 + 4], z: vertices[i1 + 5] };
+
+        let v2: Vec3 = { x: vertices[i2], y: vertices[i2 + 1], z: vertices[i2 + 2] };
+        let n2: Vec3 = { x: vertices[i2 + 3], y: vertices[i2 + 4], z: vertices[i2 + 5] };
+
+        if (transform) {
+            v0 = transformPoint(v0.x, v0.y, v0.z, transform);
+            v1 = transformPoint(v1.x, v1.y, v1.z, transform);
+            v2 = transformPoint(v2.x, v2.y, v2.z, transform);
+            n0 = transformNormal(n0.x, n0.y, n0.z, transform);
+            n1 = transformNormal(n1.x, n1.y, n1.z, transform);
+            n2 = transformNormal(n2.x, n2.y, n2.z, transform);
+        }
+
+        const e1: Vec3 = { x: v1.x - v0.x, y: v1.y - v0.y, z: v1.z - v0.z };
+        const e2: Vec3 = { x: v2.x - v0.x, y: v2.y - v0.y, z: v2.z - v0.z };
+
+        triangles.push({ v0, e1, e2, n0, n1, n2, entityId });
+    }
+
+    return triangles;
+}

package/src/standard/transforms/index.ts

@@ -123,11 +123,6 @@ setTraits(Transform, {
         scaleY: 1,
         scaleZ: 1,
     }),
-    accessors: {
-        eulerX: Transform.eulerX,
-        eulerY: Transform.eulerY,
-        eulerZ: Transform.eulerZ,
-    },
 });
 
 async function init(): Promise<void> {
@@ -180,5 +175,8 @@ const TransformSystem: System = {
 export const TransformsPlugin: Plugin = {
     systems: [TransformSystem],
     components: { Transform, WorldTransform },
-    initialize: init,
+    async initialize(_state, onProgress) {
+        await init();
+        onProgress?.(1);
+    },
 };

package/src/standard/tween/index.ts

@@ -8,6 +8,15 @@ export {
     type TweenOptions,
 } from "./tween";
 
-export { Sequence, SequenceState, Pause, finalizeSequences } from "./sequence";
+export {
+    Sequence,
+    SequenceState,
+    Pause,
+    updateSequences,
+    resolveAll,
+    resolveSequence,
+    resetSequence,
+    checkCompletion,
+} from "./sequence";
 
 export { EASING_FUNCTIONS, getEasing, getEasingIndex, type EasingFn } from "./easing";

package/src/standard/tween/sequence.ts

@@ -1,6 +1,6 @@
 import { Pair } from "bitecs";
 import { setTraits } from "../../core/component";
-import { ChildOf, type State, type PostLoadContext } from "../../core";
+import { ChildOf, type State } from "../../core";
 import { Tween, TweenState, ensureResolved, captureFromValue } from "./tween";
 
 const compareNumbers = (a: number, b: number) => a - b;
@@ -35,9 +35,7 @@ setTraits(Sequence, {
     }),
 });
 
-export function finalizeSequences(_state: State, _context: PostLoadContext): void {}
-
-function getChildrenSorted(state: State, parentEid: number): number[] {
+function sortedChildren(state: State, parentEid: number): number[] {
     childrenBuffer.length = 0;
     for (const childEid of state.query([Pair(ChildOf.relation, parentEid)])) {
         childrenBuffer.push(childEid);
@@ -47,7 +45,7 @@ function getChildrenSorted(state: State, parentEid: number): number[] {
 }
 
 export function computeTweenDelays(state: State, seqEid: number): void {
-    const children = getChildrenSorted(state, seqEid);
+    const children = sortedChildren(state, seqEid);
     let cumulativeDelay = 0;
 
     for (const childEid of children) {
@@ -59,7 +57,7 @@ export function computeTweenDelays(state: State, seqEid: number): void {
     }
 }
 
-function updateSequencePlayheads(state: State, dt: number): void {
+export function updateSequences(state: State, dt: number): void {
     for (const seqEid of state.query([Sequence])) {
         if (Sequence.state[seqEid] !== SequenceState.PLAYING) continue;
 
@@ -87,7 +85,8 @@ function updateSequencePlayheads(state: State, dt: number): void {
     }
 }
 
-function ensureSequenceResolved(state: State, seqEid: number): void {
+function resolve(state: State, seqEid: number): void {
+    computeTweenDelays(state, seqEid);
     tweensBuffer.length = 0;
 
     for (const childEid of state.query([Pair(ChildOf.relation, seqEid), Tween])) {
@@ -110,15 +109,30 @@ function ensureSequenceResolved(state: State, seqEid: number): void {
     }
 }
 
-function ensureSequencesResolved(state: State): void {
+export function resolveSequence(state: State, seqEid: number): void {
+    if (Sequence.state[seqEid] === SequenceState.COMPLETE) return;
+    Sequence.state[seqEid] = SequenceState.COMPLETE;
+    resolve(state, seqEid);
+}
+
+export function resetSequence(state: State, seqEid: number): void {
+    Sequence.state[seqEid] = SequenceState.IDLE;
+    Sequence.elapsed[seqEid] = 0;
+    for (const childEid of state.query([Pair(ChildOf.relation, seqEid), Tween])) {
+        Tween.state[childEid] = TweenState.IDLE;
+        Tween.elapsed[childEid] = 0;
+    }
+}
+
+export function resolveAll(state: State): void {
     for (const seqEid of state.query([Sequence])) {
         if (Sequence.state[seqEid] === SequenceState.COMPLETE) {
-            ensureSequenceResolved(state, seqEid);
+            resolve(state, seqEid);
         }
     }
 }
 
-function checkSequenceCompletion(state: State): void {
+export function checkCompletion(state: State): void {
     for (const seqEid of state.query([Sequence])) {
         if (Sequence.state[seqEid] !== SequenceState.PLAYING) continue;
 
@@ -138,9 +152,3 @@ function checkSequenceCompletion(state: State): void {
         }
     }
 }
-
-export function updateSequences(state: State, dt: number): void {
-    updateSequencePlayheads(state, dt);
-}
-
-export { ensureSequencesResolved, checkSequenceCompletion };

package/src/standard/tween/tween.ts

@@ -1,20 +1,71 @@
 import {
     defineRelation,
     registerPostLoadHook,
+    toCamelCase,
     type State,
     type System,
     type Plugin,
     type PostLoadContext,
 } from "../../core";
-import { setTraits } from "../../core/component";
-import { getEasingIndex, getEasing } from "./easing";
 import {
-    Sequence,
-    Pause,
-    updateSequences,
-    ensureSequencesResolved,
-    checkSequenceCompletion,
-} from "./sequence";
+    setTraits,
+    getRegisteredComponent,
+    type FieldAccessor,
+    type ComponentLike,
+} from "../../core/component";
+import { getEasingIndex, getEasing } from "./easing";
+import { Sequence, Pause, updateSequences, resolveAll, checkCompletion } from "./sequence";
+
+const fieldAccessors = new Map<number, FieldAccessor>();
+
+function 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),
+    };
+}
+
+function bindFieldAccessor(
+    bindingId: number,
+    componentName: string,
+    fieldPath: string
+): FieldAccessor | null {
+    const registered = getRegisteredComponent(componentName);
+    if (!registered) return null;
+
+    const camelPath = toCamelCase(fieldPath);
+    const field = (registered.component as ComponentLike)[camelPath];
+    if (field == null) return null;
+
+    let accessor: FieldAccessor;
+
+    if (
+        typeof field === "object" &&
+        typeof (field as FieldAccessor).get === "function" &&
+        typeof (field as FieldAccessor).set === "function"
+    ) {
+        accessor = field as FieldAccessor;
+    } else if (ArrayBuffer.isView(field) || Array.isArray(field)) {
+        const data = field as number[];
+        accessor = {
+            get: (eid) => data[eid],
+            set: (eid, v) => {
+                data[eid] = v;
+            },
+        };
+    } else {
+        return null;
+    }
+
+    fieldAccessors.set(bindingId, accessor);
+    return accessor;
+}
+
+function getFieldAccessor(bindingId: number): FieldAccessor | undefined {
+    return fieldAccessors.get(bindingId);
+}
 
 function parseTweenAttrs(attrs: Record<string, string>): Record<string, string> {
     if (attrs._value) {
@@ -126,7 +177,7 @@ export function finalizePendingTweens(state: State, context: PostLoadContext): v
         const targetEid = context.getEntityByName(parsed.entity);
         if (targetEid === null) continue;
 
-        const binding = state.bindFieldAccessor(pending.tweenEid, parsed.component, parsed.field);
+        const binding = bindFieldAccessor(pending.tweenEid, parsed.component, parsed.field);
         if (!binding) continue;
 
         state.addRelation(pending.tweenEid, TweenTarget, targetEid);
@@ -144,7 +195,7 @@ export function finalizePendingTweens(state: State, context: PostLoadContext): v
 
 export function captureFromValue(state: State, tweenEid: number): void {
     const targetEid = state.getFirstRelationTarget(tweenEid, TweenTarget);
-    const binding = state.getFieldAccessor(tweenEid);
+    const binding = getFieldAccessor(tweenEid);
 
     if (binding && targetEid >= 0) {
         Tween.from[tweenEid] = binding.get(targetEid) ?? 0;
@@ -158,7 +209,7 @@ export function ensureResolved(state: State, tweenEid: number): void {
     if (elapsed >= duration) return;
 
     const targetEid = state.getFirstRelationTarget(tweenEid, TweenTarget);
-    const binding = state.getFieldAccessor(tweenEid);
+    const binding = getFieldAccessor(tweenEid);
 
     if (binding && targetEid >= 0) {
         const toValue = Tween.to[tweenEid];
@@ -184,7 +235,7 @@ function updateTweens(state: State, dt: number): void {
         if (tweenState !== TweenState.PLAYING) continue;
 
         const targetEid = state.getFirstRelationTarget(tweenEid, TweenTarget);
-        const binding = state.getFieldAccessor(tweenEid);
+        const binding = getFieldAccessor(tweenEid);
 
         if (Tween.elapsed[tweenEid] === 0 && binding && targetEid >= 0) {
             Tween.from[tweenEid] = binding.get(targetEid) ?? 0;
@@ -237,13 +288,13 @@ export function createTween(
     fieldPath: string,
     options: TweenOptions
 ): number | null {
-    const parsed = state.resolveFieldPath(fieldPath);
+    const parsed = resolveFieldPath(fieldPath);
     if (!parsed) return null;
 
     const tweenEid = state.addEntity();
     state.addComponent(tweenEid, Tween);
 
-    const binding = state.bindFieldAccessor(tweenEid, parsed.component, parsed.field);
+    const binding = bindFieldAccessor(tweenEid, parsed.component, parsed.field);
     if (!binding) {
         state.removeEntity(tweenEid);
         return null;
@@ -265,10 +316,10 @@ export const TweenSystem: System = {
     update(state: State) {
         const dt = state.time.deltaTime;
 
-        ensureSequencesResolved(state);
+        resolveAll(state);
         updateSequences(state, dt);
         updateTweens(state, dt);
-        checkSequenceCompletion(state);
+        checkCompletion(state);
     },
 };
 

package/src/core/types.ts

@@ -1,37 +0,0 @@
-import type { System } from "./scheduler";
-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, ComponentLike>;
-    readonly relations?: readonly RelationDef[];
-    readonly dependencies?: readonly Plugin[];
-    readonly initialize?: (state: State) => void | Promise<void>;
-}
-
-export interface Loading {
-    show(): (() => void) | void;
-    update(progress: number): void;
-}
-
-export interface MouseState {
-    deltaX: number;
-    deltaY: number;
-    scrollDelta: number;
-    left: boolean;
-    right: boolean;
-    middle: boolean;
-}
-
-export interface InputState {
-    readonly mouse: Readonly<MouseState>;
-    isKeyDown(code: string): boolean;
-    isKeyPressed(code: string): boolean;
-    isKeyReleased(code: string): boolean;
-}
-
-export interface RenderContext {
-    readonly gpu: unknown;
-}

package/src/standard/compute/inspect.ts

@@ -1,201 +0,0 @@
-import type { ComputeNode, NodeId, ResourceId, ResourceRef } from "./graph";
-import type { FrameTiming } from "./timing";
-import { Pass, PASS_ORDER } from "./pass";
-
-export interface NodeInfo {
-    readonly id: NodeId;
-    readonly pass: Pass;
-    readonly inputs: readonly ResourceRef[];
-    readonly outputs: readonly ResourceRef[];
-}
-
-export interface EdgeInfo {
-    readonly from: NodeId;
-    readonly to: NodeId;
-    readonly resource: ResourceId;
-}
-
-export interface GraphInspection {
-    readonly nodes: readonly NodeInfo[];
-    readonly edges: readonly EdgeInfo[];
-    readonly executionOrder: readonly NodeId[];
-    readonly byPass: ReadonlyMap<Pass, readonly NodeId[]>;
-}
-
-export function inspect(nodes: readonly ComputeNode[]): GraphInspection {
-    const nodeInfos: NodeInfo[] = nodes.map((n) => ({
-        id: n.id,
-        pass: n.pass ?? Pass.Opaque,
-        inputs: n.inputs,
-        outputs: n.outputs,
-    }));
-
-    const producers = new Map<ResourceId, NodeId>();
-    for (const n of nodes) {
-        for (const out of n.outputs) {
-            producers.set(out.id, n.id);
-        }
-    }
-
-    const edges: EdgeInfo[] = [];
-    for (const n of nodes) {
-        for (const inp of n.inputs) {
-            const producer = producers.get(inp.id);
-            if (producer) {
-                edges.push({
-                    from: producer,
-                    to: n.id,
-                    resource: inp.id,
-                });
-            }
-        }
-    }
-
-    const byPass = new Map<Pass, NodeId[]>();
-    for (const pass of PASS_ORDER) {
-        byPass.set(pass, []);
-    }
-    for (const n of nodeInfos) {
-        byPass.get(n.pass)!.push(n.id);
-    }
-
-    const executionOrder = topoSortIds(nodes);
-
-    return { nodes: nodeInfos, edges, executionOrder, byPass };
-}
-
-function topoSortIds(nodes: readonly ComputeNode[]): NodeId[] {
-    if (nodes.length === 0) return [];
-
-    const producers = new Map<ResourceId, ComputeNode>();
-    for (const node of nodes) {
-        for (const output of node.outputs) {
-            producers.set(output.id, node);
-        }
-    }
-
-    const byPass = new Map<Pass, ComputeNode[]>();
-    for (const pass of PASS_ORDER) {
-        byPass.set(pass, []);
-    }
-    for (const node of nodes) {
-        const pass = node.pass ?? Pass.Opaque;
-        byPass.get(pass)!.push(node);
-    }
-
-    const sorted: NodeId[] = [];
-    for (const pass of PASS_ORDER) {
-        const passNodes = byPass.get(pass)!;
-        const passInDegree = new Map<ComputeNode, number>();
-
-        for (const node of passNodes) {
-            let degree = 0;
-            for (const input of node.inputs) {
-                const producer = producers.get(input.id);
-                if (producer && passNodes.includes(producer)) {
-                    degree++;
-                }
-            }
-            passInDegree.set(node, degree);
-        }
-
-        const queue: ComputeNode[] = [];
-        for (const node of passNodes) {
-            if (passInDegree.get(node) === 0) {
-                queue.push(node);
-            }
-        }
-
-        let i = 0;
-        while (i < queue.length) {
-            const node = queue[i++];
-            sorted.push(node.id);
-
-            for (const dep of passNodes) {
-                for (const input of dep.inputs) {
-                    const producer = producers.get(input.id);
-                    if (producer === node) {
-                        const newDegree = passInDegree.get(dep)! - 1;
-                        passInDegree.set(dep, newDegree);
-                        if (newDegree === 0) {
-                            queue.push(dep);
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    return sorted;
-}
-
-export function formatGraph(info: GraphInspection, timing?: FrameTiming): string {
-    const lines: string[] = [];
-    lines.push("=== Compute Graph ===");
-    lines.push("");
-
-    const nodeMap = new Map(info.nodes.map((n) => [n.id, n]));
-    const timingMap = new Map(timing?.nodes.map((t) => [t.nodeId, t]));
-
-    for (const pass of PASS_ORDER) {
-        const nodeIds = info.byPass.get(pass) ?? [];
-        if (nodeIds.length === 0) continue;
-
-        lines.push(`[${Pass[pass]}]`);
-        for (const id of nodeIds) {
-            const node = nodeMap.get(id)!;
-            const ins = node.inputs.map((r) => r.id).join(", ") || "none";
-            const outs = node.outputs.map((r) => r.id).join(", ") || "none";
-            lines.push(`  ${id}: ${ins} -> ${outs}`);
-        }
-        lines.push("");
-    }
-
-    lines.push("Execution Order:");
-    info.executionOrder.forEach((id, i) => {
-        lines.push(`  ${i + 1}. ${id}`);
-    });
-
-    if (timing) {
-        lines.push("");
-        lines.push("Timing:");
-        for (const nodeId of info.executionOrder) {
-            const nodeTiming = timingMap.get(nodeId);
-            if (nodeTiming) {
-                lines.push(`  ${nodeId}: ${nodeTiming.cpuMs.toFixed(2)}ms`);
-            }
-        }
-        lines.push(`  Total: ${timing.totalCpuMs.toFixed(2)}ms`);
-    }
-
-    return lines.join("\n");
-}
-
-export function toDot(info: GraphInspection): string {
-    const lines: string[] = ["digraph ComputeGraph {"];
-    lines.push("  rankdir=LR;");
-    lines.push("  node [shape=box];");
-    lines.push("");
-
-    for (const pass of PASS_ORDER) {
-        const nodeIds = info.byPass.get(pass) ?? [];
-        if (nodeIds.length === 0) continue;
-
-        const passName = Pass[pass];
-        lines.push(`  subgraph cluster_${passName} {`);
-        lines.push(`    label="${passName}";`);
-        for (const id of nodeIds) {
-            lines.push(`    "${id}";`);
-        }
-        lines.push("  }");
-    }
-
-    lines.push("");
-
-    for (const edge of info.edges) {
-        lines.push(`  "${edge.from}" -> "${edge.to}" [label="${edge.resource}"];`);
-    }
-
-    lines.push("}");
-    return lines.join("\n");
-}

package/src/standard/compute/pass.ts

@@ -1,23 +0,0 @@
-export enum Pass {
-    BeforeOpaque,
-    Opaque,
-    AfterOpaque,
-    BeforeTransparent,
-    Transparent,
-    AfterTransparent,
-    BeforePost,
-    Post,
-    AfterPost,
-}
-
-export const PASS_ORDER: Pass[] = [
-    Pass.BeforeOpaque,
-    Pass.Opaque,
-    Pass.AfterOpaque,
-    Pass.BeforeTransparent,
-    Pass.Transparent,
-    Pass.AfterTransparent,
-    Pass.BeforePost,
-    Pass.Post,
-    Pass.AfterPost,
-];