@aethervtt/shard-particles 0.0.1 → 0.2.0

package/dist/plugin.js

@@ -1,5 +1,5 @@
 import { Last } from "@aethervtt/shard-core";
-import { Graph, RenderDescribers, RenderSet } from "@aethervtt/shard-render";
+import { addRenderFeatures, Graph, RenderDescribers, RenderSet } from "@aethervtt/shard-render";
 import { definePlugin } from "@aethervtt/shard-runtime";
 import { OriginShift } from "@aethervtt/shard-transform";
 import * as componentsModule from "./components.js";
@@ -29,7 +29,15 @@ const particlesPlugin = definePlugin({
   },
   ready(app) {
     const graph = app.world.resource(Graph);
-    graph.addNode("particles/simulate", simulateNode());
+    addRenderFeatures(app.world, {
+      name: "particles",
+      description: "Particle simulation, depth sort and drawing.",
+      nodes: ["particles/simulate", "particles"],
+      baseline: {
+        strategy: "CPU simulation and depth sort for every system; particles in data textures"
+      }
+    });
+    graph.addNode("particles/simulate", simulateNode(app.world));
     graph.addNode("particles", drawNode());
     app.world.initResource(RenderDescribers).set("particles", (w) => describeParticles(w));
   }

package/dist/preview-render.js

@@ -60,6 +60,7 @@ async function renderEffectPreview(world, path, width, height) {
     const image = await shot;
     return { width: image.width, height: image.height, data: image.data };
   } finally {
+    await app.dispose();
     target.destroy();
   }
 }

package/dist/shaders.js

@@ -208,9 +208,9 @@ struct Draw {
   mode: vec4u,
 }
 
-@group(1) @binding(0) var<storage, read> particles: array<Particle>;
+@data @group(1) @binding(0) var<storage, read> particles: array<Particle>;
 @group(1) @binding(1) var<uniform> draw: Draw;
-@group(1) @binding(2) var<storage, read> order: array<u32>;
+@data @group(1) @binding(2) var<storage, read> order: array<u32>;
 @group(2) @binding(0) var sprite: texture_2d<f32>;
 @group(2) @binding(1) var sprite_sampler: sampler;
 @group(2) @binding(2) var scene_depth: texture_depth_2d;

package/dist/sim.d.ts

@@ -1,6 +1,6 @@
 import { type Entity, type World } from '@aethervtt/shard-core';
 import { GpuBuffer, type GpuContext } from '@aethervtt/shard-gpu';
-import { type CameraData, type NodeDescriptor } from '@aethervtt/shard-render';
+import { type CameraData, DataStore, type NodeDescriptor } from '@aethervtt/shard-render';
 import { type EmitterDef, type ParticleEffect } from './effect.js';
 /** Alpha emitters up to this capacity sort by depth; larger ones draw unsorted. */
 export declare const MAX_SORTED = 65536;
@@ -9,9 +9,14 @@ export interface EmitterState {
     def: EmitterDef;
     key: string;
     capacity: number;
-    particles: GpuBuffer;
+    /** Storage on the full tier, a data texture on baseline (0064). */
+    particles: DataStore;
     /** CPU backend: the particles, uploaded whole each frame. */
     cpu: Float32Array | undefined;
+    /** `cpu` as u32 (seeds). */
+    cpuBits: Uint32Array | undefined;
+    /** CPU backend, sorted emitters: order-preserving key bits and slot, packed per particle. */
+    cpuSort: Float64Array | undefined;
     sim: GpuBuffer;
     draw: GpuBuffer;
     counter: GPUBuffer;
@@ -29,10 +34,12 @@ export interface EmitterState {
     backlog: number;
     /** Alive particles from the last readback (a frame or two late). */
     alive: number;
+    /** System time of the last spawn: its particles live until lifetime max after it. */
+    lastSpawn: number;
     /** Sorting (alpha, small enough): keys, order, and per-step uniforms. */
     sort: {
         keys: GPUBuffer;
-        order: GPUBuffer;
+        order: DataStore;
         steps: GPUBuffer;
         count: number;
         n: number;
@@ -56,6 +63,8 @@ export interface SystemState {
     seed: number;
     local: boolean;
     cpu: boolean;
+    /** The CPU backend because the device runs the baseline tier (0064), not by choice. */
+    forced: boolean;
     model: Float32Array;
     /** Bounding sphere (world) of the system, for culling. */
     center: Float32Array;
@@ -103,12 +112,12 @@ interface Caches {
     }>;
     white?: GPUTexture;
     noDepth?: GPUTexture;
-    noOrder?: GPUBuffer;
+    noOrder?: DataStore;
     sampler?: GPUSampler;
 }
 export declare const ParticleCaches: import("@aethervtt/shard-core").ResourceDef<Caches>;
 /** Spawn, update, and (alpha emitters) depth sort, for the primary camera's view. */
-export declare function simulateNode(): NodeDescriptor;
+export declare function simulateNode(world: World): NodeDescriptor;
 /** Particles over the resolved HDR image, depth-tested against the scene without writing depth. */
 export declare function drawNode(): NodeDescriptor;
 /** Reads an emitter's particle buffer (tests: determinism, CPU vs GPU). */
@@ -125,6 +134,7 @@ export declare function describeParticles(world: World): {
     systems: {
         entity: number;
         backend: string;
+        backendReason?: string | undefined;
         emitters: {
             name: string;
             alive: number;

package/dist/sim.js

@@ -8,15 +8,20 @@ import { GpuBuffer } from "@aethervtt/shard-gpu";
 import {
   ComputedVisibility,
   cameraOf,
+  clearUnsupported,
+  DataStore,
+  dataEntry,
+  depthReadEntry,
   ForwardStateResource,
   Gpu,
   GpuAssetsResource,
   Meshes,
   RenderPhase,
+  reportUnsupported,
   Shaders,
   Views
 } from "@aethervtt/shard-render";
-import { Time } from "@aethervtt/shard-runtime";
+import { FrameDemand, Time } from "@aethervtt/shard-runtime";
 import { Textures } from "@aethervtt/shard-texture";
 import { GlobalTransform } from "@aethervtt/shard-transform";
 import { ParticleEmitterOverrides, ParticleSystem } from "./components.js";
@@ -69,8 +74,24 @@ const cpuParticle = {
   rotSpeed: 0,
   seed: 0
 };
+function randomDirection(seed, k0, out) {
+  const z = rand(seed, k0) * 2 - 1;
+  const phi = 6.2831853 * rand(seed, k0 + 1);
+  const r = Math.sqrt(Math.max(1 - z * z, 0));
+  out[0] = r * Math.cos(phi);
+  out[1] = z;
+  out[2] = r * Math.sin(phi);
+}
+function mixRange(r, t) {
+  return r[0] + (r[1] - r[0]) * t;
+}
+const spawnDirection = new Float32Array(3);
+const cpuSteps = [];
+const cpuStepParams = [];
 function simulateCpu(e, sys, dt) {
   const d = e.cpu;
+  if (!e.cpuBits || e.cpuBits.buffer !== d.buffer) e.cpuBits = new Uint32Array(d.buffer);
+  const u = e.cpuBits;
   const def = e.def;
   const s = def.shape;
   const init = def.init;
@@ -84,17 +105,14 @@ function simulateCpu(e, sys, dt) {
     let dx = 0;
     let dy = 1;
     let dz = 0;
-    const dir = (k0) => {
-      const z = rand(seed, k0) * 2 - 1;
-      const phi = 6.2831853 * rand(seed, k0 + 1);
-      const r = Math.sqrt(Math.max(1 - z * z, 0));
-      dx = r * Math.cos(phi);
-      dy = z;
-      dz = r * Math.sin(phi);
-    };
-    if (s.type === "point") dir(6);
-    else if (s.type === "sphere") {
-      dir(6);
+    if (s.type === "point" || s.type === "sphere") {
+      randomDirection(seed, 6, spawnDirection);
+      dx = spawnDirection[0];
+      dy = spawnDirection[1];
+      dz = spawnDirection[2];
+    }
+    if (s.type === "point") {
+    } else if (s.type === "sphere") {
       const r = s.radius * rand(seed, 9) ** 0.3333333;
       px = dx * r;
       py = dy * r;
@@ -113,8 +131,7 @@ function simulateCpu(e, sys, dt) {
       py = (rand(seed, 7) - 0.5) * s.size[1];
       pz = (rand(seed, 8) - 0.5) * s.size[2];
     }
-    const mix = (r, t) => r[0] + (r[1] - r[0]) * t;
-    const speed = mix(init.speed, rand(seed, 1));
+    const speed = mixRange(init.speed, rand(seed, 1));
     const p = cpuParticle;
     p.pos[0] = px;
     p.pos[1] = py;
@@ -122,7 +139,7 @@ function simulateCpu(e, sys, dt) {
     p.vel[0] = dx * speed;
     p.vel[1] = dy * speed;
     p.vel[2] = dz * speed;
-    p.life = Math.max(mix(init.lifetime, rand(seed, 2)), 1e-3);
+    p.life = Math.max(mixRange(init.lifetime, rand(seed, 2)), 1e-3);
     p.seed = seed;
     p.rotSpeed = 0;
     for (const m of def.update) MODULES[m.module].cpuInit?.(m, p);
@@ -144,15 +161,23 @@ function simulateCpu(e, sys, dt) {
     d[o + 3] = 0;
     d.set(p.vel, o + 4);
     d[o + 7] = p.life;
-    d[o + 8] = mix(init.size, rand(seed, 3));
-    d[o + 9] = mix(init.rotation, rand(seed, 4)) * Math.PI / 180;
+    d[o + 8] = mixRange(init.size, rand(seed, 3));
+    d[o + 9] = mixRange(init.rotation, rand(seed, 4)) * Math.PI / 180;
     d[o + 10] = p.rotSpeed;
-    new Uint32Array(d.buffer, (o + 11) * 4, 1)[0] = seed;
+    u[o + 11] = seed;
     const c = rand(seed, 5);
     for (let a = 0; a < 4; a++)
       d[o + 12 + a] = init.color[0][a] + (init.color[1][a] - init.color[0][a]) * c;
   }
-  const u = new Uint32Array(d.buffer);
+  let steps = 0;
+  for (const m of def.update) {
+    const step = MODULES[m.module].cpu;
+    if (!step) continue;
+    cpuSteps[steps] = step;
+    cpuStepParams[steps] = m;
+    steps++;
+  }
+  const time = sys.time;
   let alive = 0;
   for (let i = 0; i < e.capacity; i++) {
     const o = i * PARTICLE_FLOATS;
@@ -172,10 +197,16 @@ function simulateCpu(e, sys, dt) {
     p.rot = d[o + 9];
     p.rotSpeed = d[o + 10];
     p.seed = u[o + 11];
-    for (const m of def.update) MODULES[m.module].cpu?.(m, p, dt, sys.time);
-    for (let a = 0; a < 3; a++) d[o + a] = p.pos[a] + p.vel[a] * dt;
+    for (let k = 0; k < steps; k++) cpuSteps[k](cpuStepParams[k], p, dt, time);
+    const vel = p.vel;
+    const pos = p.pos;
+    d[o] = pos[0] + vel[0] * dt;
+    d[o + 1] = pos[1] + vel[1] * dt;
+    d[o + 2] = pos[2] + vel[2] * dt;
     d[o + 3] = p.age;
-    d.set(p.vel, o + 4);
+    d[o + 4] = vel[0];
+    d[o + 5] = vel[1];
+    d[o + 6] = vel[2];
     d[o + 9] = p.rot;
     if (p.age < life) alive++;
   }
@@ -198,12 +229,14 @@ function createEmitter(gpu, entity, def, cpu, previous) {
     def,
     key: emitterKey(def),
     capacity: def.capacity,
-    particles: keep ? previous.particles : new GpuBuffer(gpu, {
+    particles: keep ? previous.particles : new DataStore(gpu, {
       label,
-      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
+      usage: GPUBufferUsage.COPY_SRC,
       size: def.capacity * PARTICLE_BYTES
     }),
     cpu: cpu ? keep && previous.cpu ? previous.cpu : new Float32Array(def.capacity * PARTICLE_FLOATS) : void 0,
+    cpuBits: void 0,
+    cpuSort: cpu && sortable ? new Float64Array(def.capacity) : void 0,
     sim: previous?.sim ?? new GpuBuffer(gpu, { label: `${label}/sim`, usage: GPUBufferUsage.UNIFORM, size: SIM_BYTES }),
     draw: previous?.draw ?? new GpuBuffer(gpu, {
       label: `${label}/draw`,
@@ -229,17 +262,14 @@ function createEmitter(gpu, entity, def, cpu, previous) {
     spawnCount: 0,
     backlog: 0,
     alive: keep ? previous.alive : 0,
+    lastSpawn: keep ? previous.lastSpawn : Number.NEGATIVE_INFINITY,
     sort: sortable ? {
       keys: gpu.device.createBuffer({
         label: `${label}/keys`,
         size: n * 4,
         usage: GPUBufferUsage.STORAGE
       }),
-      order: gpu.device.createBuffer({
-        label: `${label}/order`,
-        size: n * 4,
-        usage: GPUBufferUsage.STORAGE
-      }),
+      order: new DataStore(gpu, { label: `${label}/order`, size: n * 4 }),
       steps: gpu.device.createBuffer({
         label: `${label}/steps`,
         size: (steps + 1) * 256,
@@ -306,6 +336,7 @@ const prepareParticles = defineSystem({
     store.primary = primary?.name;
     store.primaryCamera = primary ? cameraOf(primary) : void 0;
     const cam = store.primaryCamera;
+    let live = false;
     for (const table of q.tables) {
       const effectRefs = table.column(ParticleSystem, "effect");
       const playing = table.column(ParticleSystem, "playing");
@@ -320,7 +351,8 @@ const prepareParticles = defineSystem({
         const entity = table.entities[i];
         const effect = effects.get(effectRefs[i]);
         if (!effect || !vis[i]) continue;
-        const cpu = backends[i] === 1;
+        const forced = gpu.tier === "baseline" && backends[i] !== 1;
+        const cpu = backends[i] === 1 || forced;
         let sys = store.systems.get(entity);
         if (!sys || sys.effect !== effect || sys.version !== effect.version || sys.cpu !== cpu) {
           const old = sys;
@@ -342,6 +374,7 @@ const prepareParticles = defineSystem({
             seed: seeds[i],
             local: spaces[i] === 1,
             cpu,
+            forced,
             model: new Float32Array(16),
             center: new Float32Array(3),
             radius: reach(effect),
@@ -398,12 +431,16 @@ const prepareParticles = defineSystem({
             e.backlog + (e.dt > 0 ? spawnCount(e, sys.time, e.dt, rate) : 0)
           );
           e.backlog = e.spawnCount;
+          if (e.spawnCount > 0) e.lastSpawn = sys.time;
+          if (dt > 0 && (rate > 0 || burstPending(e) || sys.time - e.lastSpawn <= e.def.init.lifetime[1]))
+            live = true;
           writeUniforms(e, sys, cam);
           if (sys.cpu && e.cpu) {
             simulateCpu(e, sys, e.dt);
             e.particles.write(e.cpu);
             e.spawned += e.spawnCount;
             e.backlog = 0;
+            if (e.sort && e.cpuSort && cam) sortCpu(e, sys, cam.view);
           }
         }
       }
@@ -411,8 +448,90 @@ const prepareParticles = defineSystem({
     for (const [entity, sys] of store.systems) {
       if (sys.seen !== store.frame) store.systems.delete(entity);
     }
+    world.tryResource(FrameDemand)?.set("particles", live);
+    if (gpu.tier === "baseline") reportCpuOnly(world, store);
   }
 });
+const keyFloat = new Float32Array(1);
+const keyBits = new Uint32Array(keyFloat.buffer);
+function sortCpu(e, sys, view) {
+  const d = e.cpu;
+  const packed = e.cpuSort;
+  const m = sys.model;
+  for (let i = 0; i < e.capacity; i++) {
+    const o = i * PARTICLE_FLOATS;
+    let key = 3e38;
+    if (d[o + 7] > 0 && d[o + 3] < d[o + 7]) {
+      let x = d[o];
+      let y = d[o + 1];
+      let z = d[o + 2];
+      if (sys.local) {
+        const wx = m[0] * x + m[4] * y + m[8] * z + m[12];
+        const wy = m[1] * x + m[5] * y + m[9] * z + m[13];
+        const wz = m[2] * x + m[6] * y + m[10] * z + m[14];
+        x = wx;
+        y = wy;
+        z = wz;
+      }
+      key = view[2] * x + view[6] * y + view[10] * z + view[14];
+    }
+    keyFloat[0] = key;
+    const bits = keyBits[0];
+    const ordered = bits & 2147483648 ? ~bits >>> 0 : (bits | 2147483648) >>> 0;
+    packed[i] = ordered * 65536 + i;
+  }
+  packed.sort();
+  const order = sortScratch(e.capacity);
+  for (let i = 0; i < e.capacity; i++) order[i] = packed[i] % 65536;
+  e.sort.order.write(order, 0, 0, e.capacity);
+}
+let orderScratch = new Uint32Array(1024);
+function sortScratch(n) {
+  if (orderScratch.length < n) orderScratch = new Uint32Array(n);
+  return orderScratch;
+}
+const reportedModules = /* @__PURE__ */ new WeakMap();
+const usedModules = /* @__PURE__ */ new Set();
+function reportCpuOnly(world, store) {
+  let reported = reportedModules.get(world);
+  if (!reported) {
+    reported = /* @__PURE__ */ new Set();
+    reportedModules.set(world, reported);
+  }
+  usedModules.clear();
+  for (const sys of store.systems.values()) {
+    if (!sys.forced) continue;
+    for (const e of sys.emitters) {
+      for (const m of e.def.update) {
+        const def = MODULES[m.module];
+        if (def.update && !def.cpu) usedModules.add(m.module);
+      }
+    }
+  }
+  for (const name of usedModules) {
+    if (reported.has(name)) continue;
+    reported.add(name);
+    reportUnsupported(
+      world,
+      `particles/${name}`,
+      `The particle module "${name}" runs on the GPU backend only; the baseline tier runs particles on the CPU, without it`
+    );
+  }
+  for (const name of reported) {
+    if (usedModules.has(name)) continue;
+    reported.delete(name);
+    clearUnsupported(world, `particles/${name}`);
+  }
+}
+function burstPending(e) {
+  const bursts = e.def.spawn.bursts;
+  for (let i = 0; i < bursts.length; i++) {
+    const b = bursts[i];
+    const fired = e.fired[i] ?? 0;
+    if ((fired === 0 || b.interval > 0) && (b.cycles === 0 || fired < b.cycles)) return true;
+  }
+  return false;
+}
 function sphereVisible(planes, c, r) {
   for (let p = 0; p < 6; p++) {
     const d = planes[p * 4] * c[0] + planes[p * 4 + 1] * c[1] + planes[p * 4 + 2] * c[2] + planes[p * 4 + 3];
@@ -511,9 +630,9 @@ function caches(world, gpu) {
       data: gpu.layouts.bindGroupLayout({
         label: "particles/data",
         entries: [
-          { binding: 0, visibility: V, buffer: { type: "read-only-storage" } },
+          dataEntry(gpu, 0, V),
           { binding: 1, visibility: V | F, buffer: { type: "uniform" } },
-          { binding: 2, visibility: V, buffer: { type: "read-only-storage" } }
+          dataEntry(gpu, 2, V)
         ]
       }),
       texture: gpu.layouts.bindGroupLayout({
@@ -521,7 +640,7 @@ function caches(world, gpu) {
         entries: [
           { binding: 0, visibility: F, texture: { sampleType: "float" } },
           { binding: 1, visibility: F, sampler: { type: "filtering" } },
-          { binding: 2, visibility: F, texture: { sampleType: "depth" } }
+          depthReadEntry(gpu, 2, F)
         ]
       }),
       view: gpu.layouts.bindGroupLayout({
@@ -549,11 +668,7 @@ function caches(world, gpu) {
       format: "depth32float",
       usage: GPUTextureUsage.TEXTURE_BINDING
     });
-    c.noOrder = gpu.device.createBuffer({
-      label: "particles/no-order",
-      size: 16,
-      usage: GPUBufferUsage.STORAGE
-    });
+    c.noOrder = new DataStore(gpu, { label: "particles/no-order", size: 16 });
     c.sampler = gpu.device.createSampler({
       label: "particles",
       magFilter: "linear",
@@ -628,11 +743,12 @@ function sortPipelines(ctx, c) {
   c.sort = { keys, sort };
   return c.sort;
 }
-function simulateNode() {
+function simulateNode(world) {
   return {
     kind: "raw",
     phase: RenderPhase.Resolve + 10,
-    enabled: (view) => cameraOf(view) !== void 0,
+    // Compute is the full tier's: on baseline every system runs the CPU backend in prepare.
+    enabled: (view) => cameraOf(view) !== void 0 && world.resource(Gpu).tier === "full",
     reads: ["depth"],
     sideEffects: true,
     run: (ctx) => {
@@ -656,10 +772,10 @@ function simulateNode() {
               gpu,
               c,
               `sim/${sys.entity}/${e.def.name}`,
-              `${idOf(e.particles.buffer)}/${idOf(e.sim.buffer)}/${idOf(depth)}`,
+              `${idOf(e.particles.gpuBuffer)}/${idOf(e.sim.buffer)}/${idOf(depth)}`,
               c.layouts.sim,
               () => [
-                { binding: 0, resource: { buffer: e.particles.buffer } },
+                { binding: 0, resource: { buffer: e.particles.gpuBuffer } },
                 { binding: 1, resource: { buffer: e.sim.buffer } },
                 { binding: 2, resource: depth.createView() },
                 { binding: 3, resource: { buffer: e.counter } }
@@ -714,13 +830,13 @@ function sortEmitter(ctx, c, pass, sys, e, viewBuffer) {
     gpu,
     c,
     `sort/${sys.entity}/${e.def.name}/${i}`,
-    `${idOf(e.particles.buffer)}/${idOf(viewBuffer)}/${idOf(s.keys)}`,
+    `${idOf(e.particles.gpuBuffer)}/${idOf(viewBuffer)}/${idOf(s.keys)}`,
     c.layouts.sort,
     () => [
       { binding: 0, resource: { buffer: viewBuffer } },
-      { binding: 10, resource: { buffer: e.particles.buffer } },
+      { binding: 10, resource: { buffer: e.particles.gpuBuffer } },
       { binding: 11, resource: { buffer: s.keys } },
-      { binding: 12, resource: { buffer: s.order } },
+      { binding: 12, resource: { buffer: s.order.gpuBuffer } },
       { binding: 13, resource: { buffer: s.steps, offset: i * 256, size: 16 } },
       // The draw uniform starts with the model matrix: particles in local space sort in world.
       {
@@ -738,18 +854,16 @@ function sortEmitter(ctx, c, pass, sys, e, viewBuffer) {
     pass.dispatchWorkgroups(Math.ceil(s.n / 64));
   }
 }
-let identityBuf;
 function identityBuffer(gpu, _c) {
-  if (!identityBuf || identityBuf.generation !== gpu.generation) {
-    const buffer = gpu.device.createBuffer({
+  return gpu.shared("particles/identity", (device) => {
+    const buffer = device.createBuffer({
       label: "particles/identity",
       size: 64,
       usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
     });
-    gpu.device.queue.writeBuffer(buffer, 0, identity);
-    identityBuf = { buffer, generation: gpu.generation };
-  }
-  return identityBuf.buffer;
+    device.queue.writeBuffer(buffer, 0, identity);
+    return buffer;
+  });
 }
 const ADDITIVE = {
   color: { srcFactor: "one", dstFactor: "one", operation: "add" },
@@ -852,12 +966,12 @@ function drawNode() {
               gpu,
               c,
               `data/${sys.entity}/${e.def.name}`,
-              `${idOf(e.particles.buffer)}/${idOf(e.draw.buffer)}/${idOf(order)}`,
+              `${idOf(e.particles)}:${e.particles.version}/${idOf(e.draw.buffer)}/${idOf(order)}:${order.version}`,
               c.layouts.data,
               () => [
-                { binding: 0, resource: { buffer: e.particles.buffer } },
+                { binding: 0, resource: e.particles.resource() },
                 { binding: 1, resource: { buffer: e.draw.buffer } },
-                { binding: 2, resource: { buffer: order } }
+                { binding: 2, resource: order.resource() }
               ]
             )
           );
@@ -894,13 +1008,14 @@ function drawNode() {
   };
 }
 async function readParticles(gpu, e) {
+  if (e.particles.textured) return e.cpu.slice(0, e.capacity * PARTICLE_FLOATS);
   const size = e.capacity * PARTICLE_BYTES;
   const staging = gpu.device.createBuffer({
     size,
     usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
   });
   const encoder = gpu.device.createCommandEncoder();
-  encoder.copyBufferToBuffer(e.particles.buffer, 0, staging, 0, size);
+  encoder.copyBufferToBuffer(e.particles.gpuBuffer, 0, staging, 0, size);
   gpu.device.queue.submit([encoder.finish()]);
   await staging.mapAsync(GPUMapMode.READ);
   const out = new Float32Array(staging.getMappedRange().slice(0));
@@ -936,6 +1051,7 @@ function describeParticles(world) {
     systems: [...store.systems.values()].map((sys) => ({
       entity: sys.entity,
       backend: sys.cpu ? "cpu" : "gpu",
+      ...sys.forced ? { backendReason: "the baseline tier has no compute" } : {},
       emitters: sys.emitters.map((e) => ({
         name: e.def.name,
         alive: e.alive,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aethervtt/shard-particles",
-  "version": "0.0.1",
+  "version": "0.2.0",
   "license": "MIT",
   "type": "module",
   "sideEffects": false,
@@ -16,14 +16,14 @@
     "README.md"
   ],
   "dependencies": {
-    "@aethervtt/shard-assets": "0.0.1",
-    "@aethervtt/shard-core": "0.0.1",
-    "@aethervtt/shard-gpu": "0.0.1",
-    "@aethervtt/shard-mesh": "0.0.1",
-    "@aethervtt/shard-render": "0.0.1",
-    "@aethervtt/shard-runtime": "0.0.1",
-    "@aethervtt/shard-texture": "0.0.1",
-    "@aethervtt/shard-transform": "0.0.1"
+    "@aethervtt/shard-assets": "0.2.0",
+    "@aethervtt/shard-core": "0.2.0",
+    "@aethervtt/shard-gpu": "0.2.0",
+    "@aethervtt/shard-mesh": "0.2.0",
+    "@aethervtt/shard-render": "0.2.0",
+    "@aethervtt/shard-runtime": "0.2.0",
+    "@aethervtt/shard-texture": "0.2.0",
+    "@aethervtt/shard-transform": "0.2.0"
   },
   "repository": {
     "type": "git",
@@ -35,6 +35,6 @@
     "provenance": true
   },
   "shard": {
-    "buildSha": "d6c5c6aef4675575c878b02cf2c8f738b4190229"
+    "buildSha": "32c22a3944ed23f5d1baa90bf7cc9fae724f5fd8"
   }
 }