@multiplekex/shallot 0.1.6 → 0.1.9

package/src/standard/render/transparent.ts

@@ -0,0 +1,94 @@
+import { resource, type State } from "../../core";
+import type { ComputeNode, ExecutionContext } from "../compute";
+import { MASK_FORMAT } from "./scene";
+
+export interface DrawContext {
+    readonly device: GPUDevice;
+    readonly format: GPUTextureFormat;
+    readonly maskFormat: GPUTextureFormat;
+}
+
+export interface DrawContributor {
+    readonly id: string;
+    readonly order: number;
+    draw(pass: GPURenderPassEncoder, ctx: DrawContext): void;
+}
+
+export interface TransparentPassState {
+    contributors: Map<string, DrawContributor>;
+}
+
+export const TransparentPass = resource<TransparentPassState>("transparent-pass");
+
+export function registerDrawContributor(state: State, contributor: DrawContributor): void {
+    const pass = TransparentPass.from(state);
+    if (pass) {
+        pass.contributors.set(contributor.id, contributor);
+    }
+}
+
+export function unregisterDrawContributor(state: State, id: string): void {
+    const pass = TransparentPass.from(state);
+    if (pass) {
+        pass.contributors.delete(id);
+    }
+}
+
+export interface TransparentNodeConfig {
+    getContributors: () => DrawContributor[];
+}
+
+export function createTransparentNode(config: TransparentNodeConfig): ComputeNode {
+    return {
+        id: "transparent",
+        phase: "transparent",
+        inputs: [{ id: "depth", access: "read" }],
+        outputs: [
+            { id: "scene", access: "write" },
+            { id: "mask", access: "write" },
+        ],
+
+        execute(ctx: ExecutionContext) {
+            const contributors = config.getContributors();
+            if (contributors.length === 0) return;
+
+            const targetView = ctx.getTextureView("scene") ?? ctx.canvasView;
+            const depthView = ctx.getTextureView("depth")!;
+            const maskView = ctx.getTextureView("mask")!;
+
+            const pass = ctx.encoder.beginRenderPass({
+                colorAttachments: [
+                    {
+                        view: targetView,
+                        loadOp: "load" as const,
+                        storeOp: "store" as const,
+                    },
+                    {
+                        view: maskView,
+                        clearValue: { r: 0, g: 0, b: 0, a: 0 },
+                        loadOp: "clear" as const,
+                        storeOp: "store" as const,
+                    },
+                ],
+                depthStencilAttachment: {
+                    view: depthView,
+                    depthLoadOp: "load" as const,
+                    depthStoreOp: "store" as const,
+                },
+            });
+
+            const drawCtx: DrawContext = {
+                device: ctx.device,
+                format: ctx.format,
+                maskFormat: MASK_FORMAT,
+            };
+
+            const sorted = [...contributors].sort((a, b) => a.order - b.order);
+            for (const contributor of sorted) {
+                contributor.draw(pass, drawCtx);
+            }
+
+            pass.end();
+        },
+    };
+}

package/src/standard/tween/sequence.ts

@@ -1,6 +1,6 @@
 import { Pair } from "bitecs";
 import { setTraits } from "../../core/component";
-import { ChildOf, type State, type ParseContext } from "../../core";
+import { ChildOf, type State, type PostLoadContext } from "../../core";
 import { Tween, TweenState, ensureResolved, captureFromValue } from "./tween";
 
 const compareNumbers = (a: number, b: number) => a - b;
@@ -35,7 +35,7 @@ setTraits(Sequence, {
     }),
 });
 
-export function finalizeSequences(_state: State, _context: ParseContext): void {}
+export function finalizeSequences(_state: State, _context: PostLoadContext): void {}
 
 function getChildrenSorted(state: State, parentEid: number): number[] {
     childrenBuffer.length = 0;

package/src/standard/tween/tween.ts

@@ -3,8 +3,8 @@ import {
     registerPostLoadHook,
     type State,
     type System,
-    type ParseContext,
     type Plugin,
+    type PostLoadContext,
 } from "../../core";
 import { setTraits } from "../../core/component";
 import { getEasingIndex, getEasing } from "./easing";
@@ -57,7 +57,7 @@ setTraits(Tween, {
         delay: 0,
         easingIndex: 0,
     }),
-    adapter: (attrs: Record<string, string>, state: State, context: ParseContext) => {
+    adapter: (attrs: Record<string, string>, eid: number) => {
         const parsed = parseTweenAttrs(attrs);
         const result: Record<string, number> = {};
 
@@ -66,7 +66,7 @@ setTraits(Tween, {
         if (parsed.easing) result.easingIndex = getEasingIndex(parsed.easing);
 
         if (parsed.target) {
-            setupTweenFromXml(state, context, parsed, context.currentEid);
+            setupTweenFromXml(parsed, eid);
         }
 
         return result;
@@ -110,12 +110,7 @@ interface PendingTween {
 
 let pendingXmlTweens: PendingTween[] = [];
 
-function setupTweenFromXml(
-    _state: State,
-    _context: ParseContext,
-    attrs: Record<string, string>,
-    tweenEid: number
-): void {
+function setupTweenFromXml(attrs: Record<string, string>, tweenEid: number): void {
     pendingXmlTweens.push({
         tweenEid,
         target: attrs.target,
@@ -123,7 +118,7 @@ function setupTweenFromXml(
     });
 }
 
-export function finalizePendingTweens(state: State, context: ParseContext): void {
+export function finalizePendingTweens(state: State, context: PostLoadContext): void {
     for (const pending of pendingXmlTweens) {
         const parsed = parseTargetPath(pending.target);
         if (!parsed) continue;
@@ -135,7 +130,14 @@ export function finalizePendingTweens(state: State, context: ParseContext): void
         if (!binding) continue;
 
         state.addRelation(pending.tweenEid, TweenTarget, targetEid);
-        Tween.to[pending.tweenEid] = parseFloat(pending.to);
+        const toValue =
+            pending.to.startsWith("0x") || pending.to.startsWith("0X")
+                ? parseInt(pending.to, 16)
+                : parseFloat(pending.to);
+        if (!Number.isFinite(toValue)) {
+            throw new Error(`Tween has invalid 'to' value: "${pending.to}" (parsed as ${toValue})`);
+        }
+        Tween.to[pending.tweenEid] = toValue;
     }
     pendingXmlTweens = [];
 }
@@ -159,8 +161,12 @@ export function ensureResolved(state: State, tweenEid: number): void {
     const binding = state.getFieldAccessor(tweenEid);
 
     if (binding && targetEid >= 0) {
+        const toValue = Tween.to[tweenEid];
+        if (!Number.isFinite(toValue)) {
+            throw new Error(`Tween ${tweenEid} has invalid to value: ${toValue}`);
+        }
         Tween.from[tweenEid] = binding.get(targetEid) ?? 0;
-        binding.set(targetEid, Tween.to[tweenEid]);
+        binding.set(targetEid, toValue);
     }
 
     Tween.elapsed[tweenEid] = duration;
@@ -188,7 +194,13 @@ function updateTweens(state: State, dt: number): void {
 
         const elapsed = Tween.elapsed[tweenEid];
         const duration = Tween.duration[tweenEid];
-        const rawProgress = Math.min(elapsed / duration, 1);
+        const rawProgress = duration <= 0 ? 1 : Math.min(elapsed / duration, 1);
+
+        if (!Number.isFinite(rawProgress)) {
+            throw new Error(
+                `Tween ${tweenEid} invalid progress: elapsed=${elapsed}, duration=${duration}, dt=${dt}`
+            );
+        }
 
         const easingFn = getEasing(Tween.easingIndex[tweenEid]);
         const easedProgress = easingFn(rawProgress);
@@ -197,6 +209,12 @@ function updateTweens(state: State, dt: number): void {
         const to = Tween.to[tweenEid];
         const value = from + (to - from) * easedProgress;
 
+        if (!Number.isFinite(value)) {
+            throw new Error(
+                `Tween ${tweenEid} computed NaN: from=${from}, to=${to}, eased=${easedProgress}, raw=${rawProgress}`
+            );
+        }
+
         if (binding && targetEid >= 0) {
             binding.set(targetEid, value);
         }