@multiplekex/shallot 0.1.7 → 0.1.10

package/src/standard/render/surface/structs.ts

@@ -0,0 +1,50 @@
+export const WGSL_STRUCTS = /* wgsl */ `
+struct VertexInput {
+    @location(0) position: vec3<f32>,
+    @location(1) normal: vec3<f32>,
+    @builtin(instance_index) instance: u32,
+}
+
+struct VertexOutput {
+    @builtin(position) position: vec4<f32>,
+    @location(0) color: vec4<f32>,
+    @location(1) worldNormal: vec3<f32>,
+    @location(2) @interpolate(flat) entityId: u32,
+    @location(3) worldPos: vec3<f32>,
+}
+
+struct SurfaceData {
+    baseColor: vec3<f32>,
+    roughness: f32,
+    metallic: f32,
+    emission: vec3<f32>,
+    normal: vec3<f32>,
+    worldPos: vec3<f32>,
+}
+
+struct FragmentOutput {
+    @location(0) color: vec4<f32>,
+    @location(1) entityId: u32,
+}
+
+struct Scene {
+    viewProj: mat4x4<f32>,
+    cameraWorld: mat4x4<f32>,
+    ambientColor: vec4<f32>,
+    sunDirection: vec4<f32>,
+    sunColor: vec4<f32>,
+    cameraMode: f32,
+    cameraSize: f32,
+    viewport: vec2<f32>,
+    frustumPlanes: array<vec4<f32>, 6>,
+}
+
+@group(0) @binding(0) var<uniform> scene: Scene;
+@group(0) @binding(1) var<storage, read> entityIds: array<u32>;
+@group(0) @binding(2) var<storage, read> matrices: array<mat4x4<f32>>;
+@group(0) @binding(3) var<storage, read> colors: array<vec4<f32>>;
+@group(0) @binding(4) var<storage, read> sizes: array<vec4<f32>>;
+@group(0) @binding(5) var<storage, read> pbr: array<vec4<f32>>;
+@group(0) @binding(6) var<storage, read> emission: array<vec4<f32>>;
+@group(0) @binding(7) var<storage, read> shapes: array<u32>;
+`;

package/src/standard/render/transparent.ts

@@ -0,0 +1,91 @@
+import type { State } from "../../core";
+import type { ComputeNode, ExecutionContext } from "../compute";
+import { MASK_FORMAT } from "./scene";
+import { Pass, getDrawsByPass, type DrawContext, type SharedPassContext } from "./pass";
+
+export { MASK_FORMAT };
+
+export interface TransparentNodeConfig {
+    state: State;
+}
+
+export function createTransparentNode(config: TransparentNodeConfig): ComputeNode {
+    return {
+        id: "transparent",
+        pass: Pass.Transparent,
+        inputs: [{ id: "depth", access: "read" }],
+        outputs: [
+            { id: "scene", access: "write" },
+            { id: "mask", access: "write" },
+        ],
+
+        execute(ctx: ExecutionContext) {
+            const { device, encoder, format, context } = ctx;
+            const targetView = ctx.getTextureView("scene") ?? ctx.canvasView;
+            const depthView = ctx.getTextureView("depth")!;
+            const maskView = ctx.getTextureView("mask")!;
+            const entityIdView = ctx.getTextureView("entityId")!;
+
+            const drawCtx: DrawContext = {
+                device,
+                encoder,
+                format,
+                width: context.canvas.width,
+                height: context.canvas.height,
+                sceneView: targetView,
+                depthView,
+                entityIdView,
+                maskView,
+                canvasView: ctx.canvasView,
+            };
+
+            const beforeTransparents = getDrawsByPass(config.state, Pass.BeforeTransparent);
+            for (const draw of beforeTransparents) {
+                draw.execute(drawCtx);
+            }
+
+            const draws = getDrawsByPass(config.state, Pass.Transparent);
+            if (draws.length > 0) {
+                const pass = 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 sharedCtx: SharedPassContext = {
+                    device,
+                    format,
+                    maskFormat: MASK_FORMAT,
+                };
+
+                for (const draw of draws) {
+                    if (draw.draw) {
+                        draw.draw(pass, sharedCtx);
+                    }
+                }
+
+                pass.end();
+            }
+
+            const afterTransparents = getDrawsByPass(config.state, Pass.AfterTransparent);
+            for (const draw of afterTransparents) {
+                draw.execute(drawCtx);
+            }
+        },
+    };
+}

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 = duration === 0 ? 1 : 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);
         }