@multiplekex/shallot 0.1.0

package/src/standard/transforms/index.ts

@@ -0,0 +1,184 @@
+import { Hierarchy, Not, Wildcard } from "bitecs";
+import {
+    ChildOf,
+    MAX_ENTITIES,
+    rotateQuaternion,
+    eulerToQuaternion,
+    quaternionToEuler,
+    type State,
+    type System,
+    type Plugin,
+} from "../../core";
+import { setTraits } from "../../core/component";
+import * as wasm from "./wasm";
+
+export function rotate(eid: number, dx: number, dy: number, dz: number): void {
+    const q = rotateQuaternion(
+        Transform.quatX[eid],
+        Transform.quatY[eid],
+        Transform.quatZ[eid],
+        Transform.quatW[eid],
+        dx,
+        dy,
+        dz
+    );
+    Transform.quatX[eid] = q.x;
+    Transform.quatY[eid] = q.y;
+    Transform.quatZ[eid] = q.z;
+    Transform.quatW[eid] = q.w;
+}
+
+interface EulerProxy extends Array<number> {
+    get(eid: number): number;
+    set(eid: number, value: number): void;
+}
+
+function eulerProxy(axis: "x" | "y" | "z"): EulerProxy {
+    function getValue(eid: number): number {
+        const e = quaternionToEuler(
+            Transform.quatX[eid],
+            Transform.quatY[eid],
+            Transform.quatZ[eid],
+            Transform.quatW[eid]
+        );
+        return e[axis];
+    }
+
+    function setValue(eid: number, value: number): void {
+        const e = quaternionToEuler(
+            Transform.quatX[eid],
+            Transform.quatY[eid],
+            Transform.quatZ[eid],
+            Transform.quatW[eid]
+        );
+        e[axis] = value;
+        const q = eulerToQuaternion(e.x, e.y, e.z);
+        Transform.quatX[eid] = q.x;
+        Transform.quatY[eid] = q.y;
+        Transform.quatZ[eid] = q.z;
+        Transform.quatW[eid] = q.w;
+    }
+
+    return new Proxy([] as unknown as EulerProxy, {
+        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;
+        },
+    });
+}
+
+export const Transform: {
+    posX: Float32Array;
+    posY: Float32Array;
+    posZ: Float32Array;
+    quatX: Float32Array;
+    quatY: Float32Array;
+    quatZ: Float32Array;
+    quatW: Float32Array;
+    scaleX: Float32Array;
+    scaleY: Float32Array;
+    scaleZ: Float32Array;
+    eulerX: EulerProxy;
+    eulerY: EulerProxy;
+    eulerZ: EulerProxy;
+} = {
+    posX: new Float32Array(MAX_ENTITIES),
+    posY: new Float32Array(MAX_ENTITIES),
+    posZ: new Float32Array(MAX_ENTITIES),
+    quatX: new Float32Array(MAX_ENTITIES),
+    quatY: new Float32Array(MAX_ENTITIES),
+    quatZ: new Float32Array(MAX_ENTITIES),
+    quatW: new Float32Array(MAX_ENTITIES),
+    scaleX: new Float32Array(MAX_ENTITIES),
+    scaleY: new Float32Array(MAX_ENTITIES),
+    scaleZ: new Float32Array(MAX_ENTITIES),
+    eulerX: eulerProxy("x"),
+    eulerY: eulerProxy("y"),
+    eulerZ: eulerProxy("z"),
+};
+
+export const WorldTransform: { data: Float32Array } = {
+    data: new Float32Array(MAX_ENTITIES * 16),
+};
+
+setTraits(Transform, {
+    defaults: () => ({
+        posX: 0,
+        posY: 0,
+        posZ: 0,
+        quatX: 0,
+        quatY: 0,
+        quatZ: 0,
+        quatW: 1,
+        scaleX: 1,
+        scaleY: 1,
+        scaleZ: 1,
+    }),
+    accessors: {
+        eulerX: Transform.eulerX,
+        eulerY: Transform.eulerY,
+        eulerZ: Transform.eulerZ,
+    },
+});
+
+async function init(): Promise<void> {
+    await wasm.init();
+
+    Transform.posX = wasm.posX;
+    Transform.posY = wasm.posY;
+    Transform.posZ = wasm.posZ;
+    Transform.quatX = wasm.quatX;
+    Transform.quatY = wasm.quatY;
+    Transform.quatZ = wasm.quatZ;
+    Transform.quatW = wasm.quatW;
+    Transform.scaleX = wasm.scaleX;
+    Transform.scaleY = wasm.scaleY;
+    Transform.scaleZ = wasm.scaleZ;
+    WorldTransform.data = wasm.matrices;
+}
+
+const TransformSystem: System = {
+    group: "simulation",
+    last: true,
+
+    update(state: State) {
+        for (const eid of state.query([Transform, Not(WorldTransform)])) {
+            state.addComponent(eid, WorldTransform);
+        }
+
+        let count = 0;
+
+        for (const eid of state.query([Transform, Not(ChildOf.relation(Wildcard))])) {
+            wasm.indices[count] = eid;
+            wasm.parents[count] = wasm.NoParent;
+            count++;
+        }
+
+        for (const eid of state.query([
+            Transform,
+            ChildOf.relation(Wildcard),
+            Hierarchy(ChildOf.relation),
+        ])) {
+            wasm.indices[count] = eid;
+            wasm.parents[count] = state.getRelationTargets(eid, ChildOf)[0];
+            count++;
+        }
+
+        wasm.compute(count);
+    },
+};
+
+export const TransformsPlugin: Plugin = {
+    systems: [TransformSystem],
+    components: { Transform, WorldTransform },
+    initialize: init,
+};

package/src/standard/transforms/wasm.ts

@@ -0,0 +1,61 @@
+import wasmInit, {
+    get_pos_x_ptr,
+    get_pos_y_ptr,
+    get_pos_z_ptr,
+    get_quat_x_ptr,
+    get_quat_y_ptr,
+    get_quat_z_ptr,
+    get_quat_w_ptr,
+    get_scale_x_ptr,
+    get_scale_y_ptr,
+    get_scale_z_ptr,
+    get_matrices_ptr,
+    get_indices_ptr,
+    get_parents_ptr,
+    get_max_entities,
+    get_no_parent,
+    init_data,
+    compute_transforms,
+} from "../../../rust/transforms/pkg/shallot_transforms.js";
+
+export let posX: Float32Array;
+export let posY: Float32Array;
+export let posZ: Float32Array;
+export let quatX: Float32Array;
+export let quatY: Float32Array;
+export let quatZ: Float32Array;
+export let quatW: Float32Array;
+export let scaleX: Float32Array;
+export let scaleY: Float32Array;
+export let scaleZ: Float32Array;
+export let matrices: Float32Array;
+export let indices: Uint32Array;
+export let parents: Uint32Array;
+export let NoParent: number;
+
+export async function init(): Promise<void> {
+    if (posX) return;
+    const wasm = await wasmInit();
+    init_data();
+    const buffer = wasm.memory.buffer;
+    const maxEntities = get_max_entities();
+
+    posX = new Float32Array(buffer, get_pos_x_ptr(), maxEntities);
+    posY = new Float32Array(buffer, get_pos_y_ptr(), maxEntities);
+    posZ = new Float32Array(buffer, get_pos_z_ptr(), maxEntities);
+    quatX = new Float32Array(buffer, get_quat_x_ptr(), maxEntities);
+    quatY = new Float32Array(buffer, get_quat_y_ptr(), maxEntities);
+    quatZ = new Float32Array(buffer, get_quat_z_ptr(), maxEntities);
+    quatW = new Float32Array(buffer, get_quat_w_ptr(), maxEntities);
+    scaleX = new Float32Array(buffer, get_scale_x_ptr(), maxEntities);
+    scaleY = new Float32Array(buffer, get_scale_y_ptr(), maxEntities);
+    scaleZ = new Float32Array(buffer, get_scale_z_ptr(), maxEntities);
+    matrices = new Float32Array(buffer, get_matrices_ptr(), maxEntities * 16);
+    indices = new Uint32Array(buffer, get_indices_ptr(), maxEntities);
+    parents = new Uint32Array(buffer, get_parents_ptr(), maxEntities);
+    NoParent = get_no_parent();
+}
+
+export function compute(count: number): void {
+    compute_transforms(count);
+}

package/src/standard/tween/easing.ts

@@ -0,0 +1,169 @@
+export type EasingFn = (t: number) => number;
+
+const linear: EasingFn = (t) => t;
+
+const easeInQuad: EasingFn = (t) => t * t;
+const easeOutQuad: EasingFn = (t) => t * (2 - t);
+const easeInOutQuad: EasingFn = (t) => (t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t);
+
+const easeInCubic: EasingFn = (t) => t * t * t;
+const easeOutCubic: EasingFn = (t) => --t * t * t + 1;
+const easeInOutCubic: EasingFn = (t) =>
+    t < 0.5 ? 4 * t * t * t : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
+
+const easeInQuart: EasingFn = (t) => t * t * t * t;
+const easeOutQuart: EasingFn = (t) => 1 - --t * t * t * t;
+const easeInOutQuart: EasingFn = (t) => (t < 0.5 ? 8 * t * t * t * t : 1 - 8 * --t * t * t * t);
+
+const easeInQuint: EasingFn = (t) => t * t * t * t * t;
+const easeOutQuint: EasingFn = (t) => 1 + --t * t * t * t * t;
+const easeInOutQuint: EasingFn = (t) =>
+    t < 0.5 ? 16 * t * t * t * t * t : 1 + 16 * --t * t * t * t * t;
+
+const easeInSine: EasingFn = (t) => 1 - Math.cos((t * Math.PI) / 2);
+const easeOutSine: EasingFn = (t) => Math.sin((t * Math.PI) / 2);
+const easeInOutSine: EasingFn = (t) => -(Math.cos(Math.PI * t) - 1) / 2;
+
+const easeInExpo: EasingFn = (t) => (t === 0 ? 0 : Math.pow(2, 10 * t - 10));
+const easeOutExpo: EasingFn = (t) => (t === 1 ? 1 : 1 - Math.pow(2, -10 * t));
+const easeInOutExpo: EasingFn = (t) =>
+    t === 0
+        ? 0
+        : t === 1
+          ? 1
+          : t < 0.5
+            ? Math.pow(2, 20 * t - 10) / 2
+            : (2 - Math.pow(2, -20 * t + 10)) / 2;
+
+const easeInCirc: EasingFn = (t) => 1 - Math.sqrt(1 - t * t);
+const easeOutCirc: EasingFn = (t) => Math.sqrt(1 - --t * t);
+const easeInOutCirc: EasingFn = (t) =>
+    t < 0.5
+        ? (1 - Math.sqrt(1 - 4 * t * t)) / 2
+        : (Math.sqrt(1 - (-2 * t + 2) * (-2 * t + 2)) + 1) / 2;
+
+const easeInBack: EasingFn = (t) => {
+    const c = 1.70158;
+    return (c + 1) * t * t * t - c * t * t;
+};
+const easeOutBack: EasingFn = (t) => {
+    const c = 1.70158;
+    return 1 + (c + 1) * Math.pow(t - 1, 3) + c * Math.pow(t - 1, 2);
+};
+const easeInOutBack: EasingFn = (t) => {
+    const c = 1.70158 * 1.525;
+    return t < 0.5
+        ? (Math.pow(2 * t, 2) * ((c + 1) * 2 * t - c)) / 2
+        : (Math.pow(2 * t - 2, 2) * ((c + 1) * (t * 2 - 2) + c) + 2) / 2;
+};
+
+const easeInElastic: EasingFn = (t) =>
+    t === 0
+        ? 0
+        : t === 1
+          ? 1
+          : -Math.pow(2, 10 * t - 10) * Math.sin((t * 10 - 10.75) * ((2 * Math.PI) / 3));
+const easeOutElastic: EasingFn = (t) =>
+    t === 0
+        ? 0
+        : t === 1
+          ? 1
+          : Math.pow(2, -10 * t) * Math.sin((t * 10 - 0.75) * ((2 * Math.PI) / 3)) + 1;
+const easeInOutElastic: EasingFn = (t) =>
+    t === 0
+        ? 0
+        : t === 1
+          ? 1
+          : t < 0.5
+            ? -(Math.pow(2, 20 * t - 10) * Math.sin((20 * t - 11.125) * ((2 * Math.PI) / 4.5))) / 2
+            : (Math.pow(2, -20 * t + 10) * Math.sin((20 * t - 11.125) * ((2 * Math.PI) / 4.5))) /
+                  2 +
+              1;
+
+const easeOutBounce: EasingFn = (t) => {
+    const n1 = 7.5625;
+    const d1 = 2.75;
+    if (t < 1 / d1) return n1 * t * t;
+    if (t < 2 / d1) return n1 * (t -= 1.5 / d1) * t + 0.75;
+    if (t < 2.5 / d1) return n1 * (t -= 2.25 / d1) * t + 0.9375;
+    return n1 * (t -= 2.625 / d1) * t + 0.984375;
+};
+const easeInBounce: EasingFn = (t) => 1 - easeOutBounce(1 - t);
+const easeInOutBounce: EasingFn = (t) =>
+    t < 0.5 ? (1 - easeOutBounce(1 - 2 * t)) / 2 : (1 + easeOutBounce(2 * t - 1)) / 2;
+
+export const EASING_FUNCTIONS: readonly EasingFn[] = [
+    linear,
+    easeInQuad,
+    easeOutQuad,
+    easeInOutQuad,
+    easeInCubic,
+    easeOutCubic,
+    easeInOutCubic,
+    easeInQuart,
+    easeOutQuart,
+    easeInOutQuart,
+    easeInQuint,
+    easeOutQuint,
+    easeInOutQuint,
+    easeInSine,
+    easeOutSine,
+    easeInOutSine,
+    easeInExpo,
+    easeOutExpo,
+    easeInOutExpo,
+    easeInCirc,
+    easeOutCirc,
+    easeInOutCirc,
+    easeInBack,
+    easeOutBack,
+    easeInOutBack,
+    easeInElastic,
+    easeOutElastic,
+    easeInOutElastic,
+    easeInBounce,
+    easeOutBounce,
+    easeInOutBounce,
+] as const;
+
+const EASING_INDEX: Record<string, number> = {
+    linear: 0,
+    "ease-in-quad": 1,
+    "ease-out-quad": 2,
+    "ease-in-out-quad": 3,
+    "ease-in-cubic": 4,
+    "ease-out-cubic": 5,
+    "ease-in-out-cubic": 6,
+    "ease-in-quart": 7,
+    "ease-out-quart": 8,
+    "ease-in-out-quart": 9,
+    "ease-in-quint": 10,
+    "ease-out-quint": 11,
+    "ease-in-out-quint": 12,
+    "ease-in-sine": 13,
+    "ease-out-sine": 14,
+    "ease-in-out-sine": 15,
+    "ease-in-expo": 16,
+    "ease-out-expo": 17,
+    "ease-in-out-expo": 18,
+    "ease-in-circ": 19,
+    "ease-out-circ": 20,
+    "ease-in-out-circ": 21,
+    "ease-in-back": 22,
+    "ease-out-back": 23,
+    "ease-in-out-back": 24,
+    "ease-in-elastic": 25,
+    "ease-out-elastic": 26,
+    "ease-in-out-elastic": 27,
+    "ease-in-bounce": 28,
+    "ease-out-bounce": 29,
+    "ease-in-out-bounce": 30,
+};
+
+export function getEasingIndex(name: string): number {
+    return EASING_INDEX[name] ?? 0;
+}
+
+export function getEasing(index: number): EasingFn {
+    return EASING_FUNCTIONS[index] ?? linear;
+}

package/src/standard/tween/index.ts

@@ -0,0 +1,13 @@
+export {
+    Tween,
+    TweenState,
+    TweenTarget,
+    TweenSystem,
+    TweenPlugin,
+    createTween,
+    type TweenOptions,
+} from "./tween";
+
+export { Sequence, SequenceState, Pause, computeTweenDelays, finalizeSequences } from "./sequence";
+
+export { EASING_FUNCTIONS, getEasing, getEasingIndex, type EasingFn } from "./easing";

package/src/standard/tween/sequence.ts

@@ -0,0 +1,142 @@
+import { Pair } from "bitecs";
+import { setTraits } from "../../core/component";
+import { ChildOf, type State, type ParseContext } from "../../core";
+import { Tween, TweenState, ensureResolved, captureFromValue } from "./tween";
+
+const compareNumbers = (a: number, b: number) => a - b;
+const compareByEndTime = (a: { endTime: number }, b: { endTime: number }) => a.endTime - b.endTime;
+
+const childrenBuffer: number[] = [];
+const tweensBuffer: { eid: number; endTime: number }[] = [];
+
+export const Pause = {
+    duration: [] as number[],
+};
+
+setTraits(Pause, {
+    defaults: () => ({ duration: 0.5 }),
+});
+
+export const SequenceState = {
+    IDLE: 0,
+    PLAYING: 1,
+    COMPLETE: 2,
+} as const;
+
+export const Sequence = {
+    state: [] as number[],
+    elapsed: [] as number[],
+};
+
+setTraits(Sequence, {
+    defaults: () => ({
+        state: SequenceState.IDLE,
+        elapsed: 0,
+    }),
+});
+
+export function finalizeSequences(_state: State, _context: ParseContext): void {}
+
+function getChildrenSorted(state: State, parentEid: number): number[] {
+    childrenBuffer.length = 0;
+    for (const childEid of state.query([Pair(ChildOf.relation, parentEid)])) {
+        childrenBuffer.push(childEid);
+    }
+    childrenBuffer.sort(compareNumbers);
+    return childrenBuffer;
+}
+
+export function computeTweenDelays(state: State, seqEid: number): void {
+    const children = getChildrenSorted(state, seqEid);
+    let cumulativeDelay = 0;
+
+    for (const childEid of children) {
+        if (state.hasComponent(childEid, Pause)) {
+            cumulativeDelay += Pause.duration[childEid] ?? 0;
+        } else if (state.hasComponent(childEid, Tween)) {
+            Tween.delay[childEid] = cumulativeDelay;
+        }
+    }
+}
+
+function updateSequencePlayheads(state: State, dt: number): void {
+    for (const seqEid of state.query([Sequence])) {
+        if (Sequence.state[seqEid] !== SequenceState.PLAYING) continue;
+
+        const prevElapsed = Sequence.elapsed[seqEid] ?? 0;
+        const elapsed = prevElapsed + dt;
+        Sequence.elapsed[seqEid] = elapsed;
+
+        for (const childEid of state.query([Pair(ChildOf.relation, seqEid), Tween])) {
+            if (Tween.state[childEid] !== TweenState.IDLE) continue;
+
+            const delay = Tween.delay[childEid] ?? 0;
+            const shouldStart = elapsed >= delay;
+            const wasStarted = prevElapsed >= delay;
+
+            if (shouldStart) {
+                captureFromValue(state, childEid);
+                Tween.state[childEid] = TweenState.PLAYING;
+                Tween.elapsed[childEid] = wasStarted ? 0 : elapsed - delay - dt;
+            }
+        }
+    }
+}
+
+function ensureSequenceResolved(state: State, seqEid: number): void {
+    tweensBuffer.length = 0;
+
+    for (const childEid of state.query([Pair(ChildOf.relation, seqEid), Tween])) {
+        if (
+            Tween.state[childEid] === TweenState.COMPLETE &&
+            Tween.elapsed[childEid] >= Tween.duration[childEid]
+        ) {
+            continue;
+        }
+        const delay = Tween.delay[childEid] ?? 0;
+        const duration = Tween.duration[childEid] ?? 0;
+        tweensBuffer.push({ eid: childEid, endTime: delay + duration });
+    }
+
+    tweensBuffer.sort(compareByEndTime);
+
+    for (const { eid } of tweensBuffer) {
+        Tween.state[eid] = TweenState.COMPLETE;
+        ensureResolved(state, eid);
+    }
+}
+
+function ensureSequencesResolved(state: State): void {
+    for (const seqEid of state.query([Sequence])) {
+        if (Sequence.state[seqEid] === SequenceState.COMPLETE) {
+            ensureSequenceResolved(state, seqEid);
+        }
+    }
+}
+
+function checkSequenceCompletion(state: State): void {
+    for (const seqEid of state.query([Sequence])) {
+        if (Sequence.state[seqEid] !== SequenceState.PLAYING) continue;
+
+        let allComplete = true;
+        let hasChildren = false;
+
+        for (const childEid of state.query([Pair(ChildOf.relation, seqEid), Tween])) {
+            hasChildren = true;
+            if (Tween.state[childEid] !== TweenState.COMPLETE) {
+                allComplete = false;
+                break;
+            }
+        }
+
+        if (hasChildren && allComplete) {
+            Sequence.state[seqEid] = SequenceState.COMPLETE;
+        }
+    }
+}
+
+export function updateSequences(state: State, dt: number): void {
+    updateSequencePlayheads(state, dt);
+}
+
+export { ensureSequencesResolved, checkSequenceCompletion };