@downdraft/engine 0.3.0 → 0.3.1

package/dist/modules/devtools/src/init.js

@@ -5,10 +5,10 @@
 //   1. Creating an IDevToolsDataRenderer adapter
 //   2. Instantiating DevToolsDataBridge (or BaseSceneInspector)
 //   3. Calling init()
-//   4. Wiring sim stats provider, panel extensions, overlay toggles, etc.
+//   4. Wiring sim stats provider, debug overlay provider, etc.
 //
-// Also merges globally-registered panels/feeds/commands from the `devtools`
-// singleton (registered by plugins via ctx.devtools.registerPanel() etc.)
+// Also merges globally-registered feeds/commands from the `devtools`
+// singleton (registered by plugins via ctx.devtools.registerDataFeed() etc.)
 // and from worker manifests (via syncWorkerManifests).
 //
 // Returns the bridge instance for games that need post-init calls
@@ -22,7 +22,7 @@ import { BaseSceneInspector } from "./scene-inspector.js";
 import { syncWorkerManifests } from "./worker-sync.js";
 /**
  * Initialize DevTools with one call. Creates the bridge, wires all providers,
-  merges globally-registered panels/feeds/commands, syncs worker manifests,
+ * merges globally-registered feeds/commands, syncs worker manifests,
  * and exposes the API on window.__sceneInspector.
  *
  * Returns the bridge instance.
@@ -34,19 +34,7 @@ export async function initDevTools(renderer, options = {}) {
     const useSceneInspector = options.sceneInspector
         || !!options.bridgeClass
         || isSceneRenderer(renderer);
-    // 3. Register game-declared panels/toggles into the global registry
-    //    (these merge with plugin-registered ones)
-    if (options.panels) {
-        options.panels.forEach((panel) => {
-            devtools.registerPanel(panel);
-        });
-    }
-    if (options.overlayToggles) {
-        options.overlayToggles.forEach((toggle) => {
-            devtools.registerOverlayToggle(toggle);
-        });
-    }
-    // 4. Sync worker manifests (fetches panels/feeds/commands from sim workers)
+    // 4. Sync worker manifests (fetches feeds/commands from sim workers)
     if (options.workerHosts && options.workerHosts.length > 0) {
         await syncWorkerManifests(options.workerHosts);
     }
@@ -85,10 +73,8 @@ export async function initDevTools(renderer, options = {}) {
     if (options.performanceMetricsProvider) {
         wirePerformanceMetricsProvider(bridge, options.performanceMetricsProvider);
     }
-    // 7. Merge globally-registered panels/toggles/feeds/commands into the bridge
-    //    The bridge's getPanelExtensions()/getOverlayToggles() already returns
-    //    game-declared ones; we augment the __sceneInspector API with
-    //    plugin-registered data feeds and commands.
+    // 7. Merge globally-registered feeds/commands/SAB stats into the bridge —
+    //    augments the __sceneInspector API with plugin-registered methods.
     mergeGlobalRegistrations(bridge);
     // 8. Initialize the profiling system (if enabled)
     if (options.profiling) {
@@ -134,35 +120,15 @@ function wirePerformanceMetricsProvider(bridge, provider) {
     bridge.getPerformanceMetricsProvider = () => provider;
 }
 /**
- * Merge globally-registered panels, data feeds, and commands from the `devtools`
+ * Merge globally-registered data feeds and commands from the `devtools`
  * singleton into the bridge's __sceneInspector API.
  *
- * - Panels: merged into getPanelExtensions() (game panels + plugin panels)
  * - Data feeds: added as methods on __sceneInspector (called synchronously)
  * - Commands: added as methods on __sceneInspector (forwarded to worker or called directly)
  * - SAB stats: added as methods on __sceneInspector (read from SAB)
  */
 function mergeGlobalRegistrations(bridge) {
     const manifest = devtools.getManifest();
-    // Augment getPanelExtensions to merge global registry panels
-    const originalGetPanels = bridge.getPanelExtensions?.bind(bridge);
-    bridge.getPanelExtensions = () => {
-        const gamePanels = originalGetPanels?.() ?? [];
-        // Merge: game panels take precedence on id collisions
-        const merged = new Map();
-        manifest.panels.forEach((p) => { merged.set(p.id, p); ; });
-        gamePanels.forEach((p) => { merged.set(p.id, p); ; });
-        return Array.from(merged.values()).sort((a, b) => (a.order ?? 100) - (b.order ?? 100));
-    };
-    // Augment getOverlayToggles to merge global registry toggles
-    const originalGetToggles = bridge.getOverlayToggles?.bind(bridge);
-    bridge.getOverlayToggles = () => {
-        const gameToggles = originalGetToggles?.() ?? [];
-        const merged = new Map();
-        manifest.toggles.forEach((t) => { merged.set(t.id, t); ; });
-        gameToggles.forEach((t) => { merged.set(t.id, t); ; });
-        return Array.from(merged.values());
-    };
     // Add data feed methods to the __sceneInspector API
     // These are called synchronously by the panel via callInspector()
     const api = window.__sceneInspector;

package/dist/modules/devtools/src/scene-inspector.js

@@ -27,7 +27,6 @@ export class BaseSceneInspector extends DevToolsDataBridge {
     getDebugOverlayProvider() {
         return null;
     }
-    // getPanelExtensions() and getOverlayToggles() inherited from DevToolsDataBridge.
     // --- Init ---
     init(renderer) {
         super.init(renderer);
@@ -510,9 +509,7 @@ export class BaseSceneInspector extends DevToolsDataBridge {
             const cosY = Math.cos(angleY), sinY = Math.sin(angleY);
             const cosX = Math.cos(angleX), sinX = Math.sin(angleX);
             const THUMB_SIZE = 192;
-            const canvas = document.createElement("canvas");
-            canvas.width = THUMB_SIZE;
-            canvas.height = THUMB_SIZE;
+            const canvas = new OffscreenCanvas(THUMB_SIZE, THUMB_SIZE);
             const ctx = canvas.getContext("2d");
             if (!ctx)
                 return null;

package/dist/modules/devtools/src/worker-sync.js

@@ -1,14 +1,13 @@
 // ============================================================================
 // Renderer-side worker manifest sync — fetches the devtools manifest from
-// one or more sim workers via worker RPC, then wires the worker-registered panels,
-// data feeds, and commands into the renderer-side __sceneInspector API.
+// one or more sim workers via worker RPC, then wires the worker-registered
+// data feeds and commands into the renderer-side __sceneInspector API.
 //
 // Data feeds from workers are read from the devtools SAB (zero-copy).
 // Commands are forwarded via worker RPC.
-// Panel declarations are merged into the global registry.
 // ============================================================================
 import { createLogger } from "@downdraft/engine/util/logger";
-import { _devtoolsImpl, devtools } from "./api.js";
+import { _devtoolsImpl } from "./api.js";
 const log = createLogger("info");
 /**
  * Sync manifests from one or more workers into the renderer-side devtools
@@ -54,13 +53,6 @@ async function syncOneWorker(entry) {
             // Worker may not have a devtools SAB (older workers)
         }
     }
-    // Register panels (namespaced by prefix to avoid collisions)
-    manifest.panels.forEach((panel) => {
-        const namespaced = prefix
-            ? { ...panel, id: `${prefix}:${panel.id}` }
-            : panel;
-        devtools.registerPanel(namespaced);
-    });
     // Register data feed readers — these read from the SAB synchronously
     // We register them as main-realm data feeds that read from the worker SAB
     if (sab) {

package/dist/test/src/vision-test.js

@@ -155,9 +155,7 @@ export class VisionTest {
     }
     async screenshotToDataURL(texture, width, height) {
         const data = await this.captureTexture(texture, width, height);
-        const canvas = document.createElement("canvas");
-        canvas.width = width;
-        canvas.height = height;
+        const canvas = new OffscreenCanvas(width, height);
         const ctx = canvas.getContext("2d");
         const imageData = ctx.createImageData(width, height);
         imageData.data.set(data);

package/libraries/blitz-ui/src/native-module.ts

@@ -169,7 +169,14 @@ export function createBlitzUiNativeModule<S>(options: BlitzUiNativeOptions<S>):
                 const device = ctx.getDevice();
                 const view = ensureTexture(device);
                 const context = ctx.getSurface().getContext("webgpu");
-                const targetTex = context?.getCurrentTexture();
+                // Join the in-flight frame, never start one: on a frame the
+                // game skipped (dirty-tracking), acquiring the surface here
+                // would present the UI blit over a blank swapchain image.
+                const peek = (context as { peekCurrentTexture?: () => GPUTexture | null } | null)
+                    ?.peekCurrentTexture;
+                const targetTex = typeof peek === "function"
+                    ? peek.call(context)
+                    : context?.getCurrentTexture() ?? null;
                 const target = targetTex?.createView();
                 if (!view || !target || !targetTex) return;
 

package/libraries/devtools/src/native-providers.ts

@@ -525,8 +525,6 @@ async function collectWorkers(ctx: EngineProviderContext): Promise<PanelSnapshot
                     kind: "kv",
                     name: `Worker manifest (v${m.manifestVersion ?? "?"})`,
                     rows: [
-                        kv("Panels", (m.panels ?? []).map((p: any) => p.id ?? p.name ?? "?").join(", ") || "(none)"),
-                        kv("Toggles", (m.toggles ?? []).map((t: any) => t.id ?? "?").join(", ") || "(none)"),
                         kv("Data feeds", (m.dataFeeds ?? []).map((f: any) => `${f.name}@${f.writeRateHz}hz`).join(", ") || "(none)"),
                         kv("Commands", (m.commands ?? []).join(", ") || "(none)"),
                     ],

package/libraries/entities/src/model-renderer.ts

@@ -86,9 +86,11 @@ export class ModelRenderer {
   private reusableUniformsU32 = new Uint32Array(this.reusableUniforms.buffer);
   private textureLoadVersion = new Map<string, number>();
 
-  // Skinning: a shared storage buffer of bone matrices (MAX_BONES * mat4),
-  // updated per-frame via updateSkinMatrices. Bound at @group(1) for skinned
-  // draws only.
+  // Skinning: a shared storage buffer of bone matrices (mat4 each), updated
+  // per-frame via updateSkinMatrices/updateSkinMatricesFor. Bound at @group(1)
+  // for skinned draws only. Each skinned nodeId owns a region of the buffer —
+  // the draw's `boneBase` uniform selects it so multiple skinned models can be
+  // animated independently in one frame.
   private skinMatrixBuffer: GPUBuffer | null = null;
   private skinBindGroupLayout: GPUBindGroupLayout | null = null;
   private skinBindGroup: GPUBindGroup | null = null;
@@ -96,6 +98,16 @@ export class ModelRenderer {
   private skinBindGroupSetThisFrame = false;
   /** Current bone capacity (number of mat4s the skin buffer can hold). Grows on demand. */
   private boneCapacity = ModelRenderer.INITIAL_BONE_CAPACITY;
+  /** nodeId → reserved bone region (offset+count in bones). */
+  private skinRegions = new Map<string, { offset: number; count: number }>();
+  /** nodeId → bone base index used by the skinning shader for that draw. */
+  private skinBaseByNode = new Map<string, number>();
+  /** Freed bone regions available for reuse (first-fit). */
+  private skinFreeList: Array<{ offset: number; count: number }> = [];
+  /** Next never-allocated bone index (high-water mark). */
+  private nextBoneOffset = 0;
+  /** Legacy caller region — updateSkinMatrices(m) without a nodeId. */
+  private static readonly DEFAULT_SKIN_NODE = "__skin_default";
 
   // Bindless deps
   private bindless: ModelRendererBindlessDeps | null = null;
@@ -822,6 +834,7 @@ export class ModelRenderer {
   }
 
   removeModel(nodeId: string): void {
+    this.releaseSkinRegion(nodeId);
     const resources = this.modelResources.get(nodeId);
     if (resources) {
       for (let i = 0; i < resources.length; i++) {
@@ -1082,43 +1095,85 @@ export class ModelRenderer {
   }
 
   /**
-   * Upload bone skin matrices for the current frame. The `matrices` buffer is
-   * a flat Float32Array of boneCount * 16 floats (column-major mat4s). It is
-   * copied into the shared skin matrix storage buffer. If the buffer is too
-   * small for the current skeleton, it is recreated (grown) automatically.
-   * Call once per frame before render() for skinned models.
+   * Upload bone skin matrices for the current frame into the shared default
+   * region. Kept for single-avatar callers — equivalent to
+   * updateSkinMatricesFor("__skin_default", matrices).
    */
   updateSkinMatrices(matrices: Float32Array): void {
+    this.updateSkinMatricesFor(ModelRenderer.DEFAULT_SKIN_NODE, matrices);
+  }
+
+  /**
+   * Upload bone skin matrices for one nodeId's reserved region. The region is
+   * (re)allocated automatically — freed regions from removeModel() are reused
+   * first-fit. Render() looks up the node's region offset and passes it to the
+   * skinning shader via the `boneBase` uniform, so multiple skinned models
+   * animate independently.
+   */
+  updateSkinMatricesFor(nodeId: string, matrices: Float32Array): void {
     if (!this.skinMatrixBuffer) return;
 
     const requiredBones = matrices.length / 16;
-    if (requiredBones > this.boneCapacity) {
-      // Grow the skin matrix buffer to fit the larger skeleton.
-      // Round up to the next power of 2 to reduce reallocations.
-      const newCapacity = Math.max(requiredBones, this.boneCapacity * 2);
-      this.skinMatrixBuffer.destroy();
-      this.skinMatrixBuffer = this.device.createBuffer({
-        size: newCapacity * 64,
-        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
-      });
-      this.boneCapacity = newCapacity;
-      // Recreate the bind group with the new buffer
-      if (this.skinBindGroupLayout) {
-        this.skinBindGroup = this.device.createBindGroup({
-          layout: this.skinBindGroupLayout,
-          entries: [{ binding: 0, resource: { buffer: this.skinMatrixBuffer } }],
-        });
-      }
-      this.skinBindGroupSetThisFrame = false; // force re-bind
+    let region = this.skinRegions.get(nodeId);
+    if (!region || region.count < requiredBones) {
+      if (region) this.skinFreeList.push(region);
+      region = this.allocSkinRegion(requiredBones);
+      this.skinRegions.set(nodeId, region);
     }
+    this.skinBaseByNode.set(nodeId, region.offset);
 
     this.device.queue.writeBuffer(
       this.skinMatrixBuffer,
-      0,
+      region.offset * 64,
       matrices as Float32Array<ArrayBuffer>,
     );
   }
 
+  /** Allocate a bone region for `count` bones — free-list first, then bump
+   *  allocation; grows the shared buffer when the capacity is exceeded. */
+  private allocSkinRegion(count: number): { offset: number; count: number } {
+    for (let i = 0; i < this.skinFreeList.length; i++) {
+      const f = this.skinFreeList[i];
+      if (f.count >= count) {
+        this.skinFreeList.splice(i, 1);
+        return { offset: f.offset, count: f.count };
+      }
+    }
+    const needed = this.nextBoneOffset + count;
+    if (needed > this.boneCapacity) this.growSkinBuffer(needed);
+    const region = { offset: this.nextBoneOffset, count };
+    this.nextBoneOffset += count;
+    return region;
+  }
+
+  /** Recreate the skin matrix buffer at a larger capacity and rebind group(1).
+   *  Region offsets stay valid — callers rewrite their matrices next frame. */
+  private growSkinBuffer(minBones: number): void {
+    const newCapacity = Math.max(minBones, this.boneCapacity * 2);
+    this.skinMatrixBuffer?.destroy();
+    this.skinMatrixBuffer = this.device.createBuffer({
+      size: newCapacity * 64,
+      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+    });
+    this.boneCapacity = newCapacity;
+    if (this.skinBindGroupLayout) {
+      this.skinBindGroup = this.device.createBindGroup({
+        layout: this.skinBindGroupLayout,
+        entries: [{ binding: 0, resource: { buffer: this.skinMatrixBuffer } }],
+      });
+    }
+    this.skinBindGroupSetThisFrame = false; // force re-bind
+  }
+
+  /** Release a node's bone region back to the free list. */
+  releaseSkinRegion(nodeId: string): void {
+    const region = this.skinRegions.get(nodeId);
+    if (!region) return;
+    this.skinRegions.delete(nodeId);
+    this.skinBaseByNode.delete(nodeId);
+    this.skinFreeList.push(region);
+  }
+
   render(
     passEncoder: GPURenderPassEncoder,
     nodeId: string,
@@ -1221,6 +1276,12 @@ export class ModelRenderer {
       // fs_outline). Defaults: 0 width, black color.
       uniforms[39] = 0.0;
       uniforms[40] = 0.0; uniforms[41] = 0.0; uniforms[42] = 0.0;
+      // boneBase (u32, slot 44) — index of this node's bone region inside the
+      // shared skinMatrices storage buffer. Only read by vs_skinned.
+      this.reusableUniformsU32[44] =
+        this.skinBaseByNode.get(nodeId)
+        ?? this.skinBaseByNode.get(ModelRenderer.DEFAULT_SKIN_NODE)
+        ?? 0;
 
       this.device.queue.writeBuffer(
         this.uniformBuffer,

package/libraries/entities/src/shaders/model.wgsl

@@ -22,6 +22,14 @@ struct Uniforms {
   // Inverted-hull outline parameters (used by vs_outline / fs_outline only).
   outlineWidth: f32,
   outlineColor: vec3<f32>,
+  // Base index of this draw's bone region inside the shared skinMatrices
+  // storage buffer (group(1)). Written by ModelRenderer from the node's
+  // reserved region — lets multiple skinned models animate independently.
+  // Only read by vs_skinned.
+  boneBase: u32,
+  _padSkin0: u32,
+  _padSkin1: u32,
+  _padSkin2: u32,
 };
 
 @group(0) @binding(0) var<uniform> uniforms: Uniforms;
@@ -165,10 +173,11 @@ fn qrotate(q: vec4<f32>, v: vec3<f32>) -> vec3<f32> {
 // If all weights are zero (vertex has no bone assignment), return identity so
 // the vertex renders at its baked position instead of collapsing to the origin.
 fn skinMatrix(j: vec4<u32>, w: vec4<f32>) -> mat4x4<f32> {
-  let m = skinMatrices[j.x] * w.x
-        + skinMatrices[j.y] * w.y
-        + skinMatrices[j.z] * w.z
-        + skinMatrices[j.w] * w.w;
+  let base = uniforms.boneBase;
+  let m = skinMatrices[base + j.x] * w.x
+        + skinMatrices[base + j.y] * w.y
+        + skinMatrices[base + j.z] * w.z
+        + skinMatrices[base + j.w] * w.w;
   let wsum = w.x + w.y + w.z + w.w;
   if (wsum < 0.001) {
     return mat4x4<f32>(

package/libraries/networking/src/index.ts

@@ -43,3 +43,7 @@ export type { NetworkingLibConfig } from "./library";
 
 export { LanDiscovery, MdnsBrowser } from "./discovery";
 export type { LanBeacon, LanDiscoveryOptions, LanPeer, MdnsBrowseOptions, MdnsService } from "./discovery";
+
+export { createWebSocketServer } from "./ws-server";
+export type { WebSocketServerHandlers, WebSocketServerOptions, WsServer, WsServerConnection } from "./ws-server";
+