@aethervtt/shard-render 0.1.0 → 0.2.0

package/dist/testing.js

@@ -3,6 +3,10 @@ import { dirname, join } from "node:path";
 import { deflateSync } from "node:zlib";
 import { Culler } from "./culling.js";
 import { captureView, Gpu, Shaders } from "./plugin.js";
+import {
+  expectScenario,
+  measureScenario
+} from "./scenario.js";
 async function settle(app, frames = 40) {
   const gpu = app.world.resource(Gpu);
   for (let i = 0; i < frames; i++) {
@@ -149,7 +153,9 @@ function meanDifference(a, b) {
 export {
   compareGolden,
   comparePng,
+  expectScenario,
   meanDifference,
+  measureScenario,
   pixel,
   pngBytes,
   renderView,

package/dist/timer.d.ts

@@ -11,6 +11,15 @@ export declare class GpuTimer {
     frameMs: number;
     /** Frames measured so far: changes when `frameMs` does. */
     frameSamples: number;
+    /**
+     * Every pass time so far was a whole number of 100 µs: the browser quantizes timestamps
+     * (0074's `gpuQuantized`). Decided after a few dozen passes.
+     */
+    quantized: boolean;
+    private passTimes;
+    private unquantized;
+    /** Each query slot's stamps at the last readback: a slot that still holds them is left over. */
+    private readonly lastStamps;
     private querySet;
     private resolveBuffer;
     private readonly readbacks;
@@ -24,7 +33,13 @@ export declare class GpuTimer {
     /** Timestamp writes for the next pass, or undefined when timing is off or full. */
     allocate(name: string): GPURenderPassTimestampWrites | undefined;
     private pendingCopy;
+    /** Pass `i`'s slot still holds the stamps it had at the last readback: the GPU skipped it. */
+    private stale;
     resolve(encoder: GPUCommandEncoder): void;
-    /** Call after submit. Records timings when the copy lands. */
+    /**
+     * Call after submit. Records timings when the copy lands: aggregates per name, and (during a
+     * capture) GPU-track spans placed from this frame's submit time, since WebGPU's clock isn't the
+     * CPU's (0074).
+     */
     readback(world: World): void;
 }

package/dist/timer.js

@@ -1,17 +1,36 @@
-import { ProfilerResource } from "@aethervtt/shard-core";
+import { ProfilerResource, TRACK } from "@aethervtt/shard-core";
 const MAX_PASSES = 96;
-const STALE_NS = 1000000000n;
 const SPANS = [
   ["gpu:span/post", (n) => n.startsWith("post/") || n === "tonemap"],
   ["gpu:span/ssao", (n) => n === "ssao" || n.startsWith("ssao/")]
 ];
 const READBACK_BUFFERS = 3;
+const QUANTUM_NS = 100000n;
+const QUANTIZED_AFTER = 32;
+const gpuNames = /* @__PURE__ */ new Map();
+function gpuName(node) {
+  let name = gpuNames.get(node);
+  if (name === void 0) {
+    name = `gpu:${node}`;
+    gpuNames.set(node, name);
+  }
+  return name;
+}
 class GpuTimer {
   enabled;
   /** The latest frame's GPU span in ms (first pass start to last pass end), once one landed. */
   frameMs = 0;
   /** Frames measured so far: changes when `frameMs` does. */
   frameSamples = 0;
+  /**
+   * Every pass time so far was a whole number of 100 µs: the browser quantizes timestamps
+   * (0074's `gpuQuantized`). Decided after a few dozen passes.
+   */
+  quantized = false;
+  passTimes = 0;
+  unquantized = false;
+  /** Each query slot's stamps at the last readback: a slot that still holds them is left over. */
+  lastStamps = new BigUint64Array(MAX_PASSES * 2);
   querySet;
   resolveBuffer;
   readbacks = [];
@@ -32,6 +51,7 @@ class GpuTimer {
     this.names = [];
     if (!this.enabled || this.generation === this.gpu.generation) return;
     this.generation = this.gpu.generation;
+    this.lastStamps.fill(0n);
     const device = this.gpu.device;
     this.querySet = device.createQuerySet({
       label: "gpu-timer",
@@ -52,7 +72,9 @@ class GpuTimer {
           usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
         }),
         busy: false,
-        names: []
+        names: [],
+        frame: 0,
+        submitAt: 0
       });
     }
   }
@@ -68,6 +90,11 @@ class GpuTimer {
     };
   }
   pendingCopy;
+  /** Pass `i`'s slot still holds the stamps it had at the last readback: the GPU skipped it. */
+  stale(times, i) {
+    const last = this.lastStamps;
+    return times[i * 2] === last[i * 2] && times[i * 2 + 1] === last[i * 2 + 1];
+  }
   resolve(encoder) {
     this.pendingCopy = void 0;
     if (!this.enabled || this.names.length === 0) return;
@@ -80,36 +107,54 @@ class GpuTimer {
     target.names = this.names;
     this.pendingCopy = target;
   }
-  /** Call after submit. Records timings when the copy lands. */
+  /**
+   * Call after submit. Records timings when the copy lands: aggregates per name, and (during a
+   * capture) GPU-track spans placed from this frame's submit time, since WebGPU's clock isn't the
+   * CPU's (0074).
+   */
   readback(world) {
+    const profiler = world.tryResource(ProfilerResource);
+    if (profiler) profiler.gpu.status = this.enabled ? "available" : "unavailable";
     const target = this.pendingCopy;
     if (!target) return;
     this.pendingCopy = void 0;
+    target.frame = profiler?.frame ?? 0;
+    target.submitAt = profiler ? profiler.now() : 0;
     const generation = this.generation;
     target.buffer.mapAsync(GPUMapMode.READ).then(
       () => {
         if (generation !== this.gpu.generation) return;
         const times = new BigUint64Array(target.buffer.getMappedRange());
-        const profiler = world.tryResource(ProfilerResource);
         const totals = /* @__PURE__ */ new Map();
-        let latest = 0n;
-        for (let i = 0; i < target.names.length; i++) {
-          const end = times[i * 2 + 1];
-          if (end > latest) latest = end;
-        }
-        const stale = latest - STALE_NS;
+        const count = target.names.length * 2;
         let first = 0n;
-        let last = 0n;
+        let lastEnd = 0n;
         for (let i = 0; i < target.names.length; i++) {
           const begin = times[i * 2];
           const end = times[i * 2 + 1];
-          if (begin === 0n || end < begin || begin < stale) continue;
+          if (begin === 0n || end < begin || this.stale(times, i)) continue;
           const name = target.names[i];
           totals.set(name, (totals.get(name) ?? 0) + Number(end - begin) / 1e6);
           if (first === 0n || begin < first) first = begin;
-          if (end > last) last = end;
+          if (end > lastEnd) lastEnd = end;
+          if (end > begin) {
+            if ((end - begin) % QUANTUM_NS !== 0n) this.unquantized = true;
+            this.passTimes++;
+          }
+        }
+        if (this.passTimes >= QUANTIZED_AFTER) this.quantized = !this.unquantized;
+        if (profiler) profiler.gpu.quantized = this.quantized;
+        for (const [name, ms] of totals) profiler?.sample(gpuName(name), ms);
+        const at = (stamp) => target.submitAt + Number(stamp - first) / 1e6;
+        if (profiler?.capturing && first !== 0n) {
+          for (let i = 0; i < target.names.length; i++) {
+            const begin = times[i * 2];
+            const end = times[i * 2 + 1];
+            if (begin === 0n || end < begin || this.stale(times, i)) continue;
+            const ms = Number(end - begin) / 1e6;
+            profiler.event(gpuName(target.names[i]), TRACK.gpu, at(begin), ms, target.frame);
+          }
         }
-        for (const [name, ms] of totals) profiler?.record(`gpu:${name}`, ms);
         for (let g = 0; g < SPANS.length; g++) {
           const [label, match] = SPANS[g];
           let a = 0n;
@@ -117,17 +162,19 @@ class GpuTimer {
           for (let i = 0; i < target.names.length; i++) {
             const begin = times[i * 2];
             const end = times[i * 2 + 1];
-            if (begin === 0n || end < begin || begin < stale || !match(target.names[i])) continue;
+            if (begin === 0n || end < begin || this.stale(times, i) || !match(target.names[i]))
+              continue;
             if (a === 0n || begin < a) a = begin;
             if (end > b) b = end;
           }
-          if (b > a) profiler?.record(label, Number(b - a) / 1e6);
+          if (b > a) profiler?.record(label, Number(b - a) / 1e6, TRACK.gpu, at(a), target.frame);
         }
         if (first !== 0n) {
-          this.frameMs = Number(last - first) / 1e6;
+          this.frameMs = Number(lastEnd - first) / 1e6;
           this.frameSamples++;
-          profiler?.record("gpu:frame", this.frameMs);
+          profiler?.record("gpu:frame", this.frameMs, TRACK.gpu, target.submitAt, target.frame);
         }
+        for (let k = 0; k < count; k++) this.lastStamps[k] = times[k];
         target.buffer.unmap();
         target.busy = false;
       },

package/dist/vfx-draw.d.ts

@@ -0,0 +1,37 @@
+import type { World } from '@aethervtt/shard-core';
+import { GpuBuffer } from '@aethervtt/shard-gpu';
+import { type NodeDescriptor } from './graph.js';
+import type { VfxRecord } from './vfx-state.js';
+export declare const VFX_SHADERS: {
+    'shard::vfx::ribbon': string;
+};
+interface DrawRecord {
+    source: VfxRecord;
+    view: string;
+    vertices: GpuBuffer;
+    uniform: GpuBuffer;
+    data: Float32Array;
+    group: GPUBindGroup | undefined;
+    texture: GPUTextureView | undefined;
+    version: number;
+    generation: number;
+}
+/** Per-world, per-view uniforms: two cameras never overwrite one another before submit. */
+export declare class VfxRenderer {
+    readonly draws: DrawRecord[];
+    private generation;
+    private layout;
+    private pipelines;
+    private white;
+    private whiteView;
+    private sampler;
+    private readonly decal;
+    private readonly records;
+    constructor(records: VfxRecord[], decal: boolean);
+    dispose(): void;
+    prune(world: World): void;
+    private init;
+    node(): NodeDescriptor;
+    private draw;
+}
+export {};

package/dist/vfx-draw.js

@@ -0,0 +1,291 @@
+import { assetServer } from "@aethervtt/shard-assets";
+import { GpuBuffer } from "@aethervtt/shard-gpu";
+import { Textures } from "@aethervtt/shard-texture";
+import { GpuAssetsResource } from "./gpu-assets.js";
+import { RenderPhase } from "./graph.js";
+import { InstanceSlot } from "./instances.js";
+import { Shaders, Views } from "./plugin.js";
+import { bindingDimension } from "./tier.js";
+import { cameraOf } from "./view.js";
+const VFX_SHADERS = {
+  "shard::vfx::ribbon": `
+struct View { vp: mat4x4f, eye: vec4f, forward: vec4f, params: vec4f, tint: vec4f }
+@group(0) @binding(0) var<uniform> view: View;
+@group(0) @binding(1) var image: texture_2d<f32>;
+@group(0) @binding(2) var image_sampler: sampler;
+struct Input {
+ @location(0) position: vec3f,
+ @location(1) tangent: vec3f,
+ @location(2) uv: vec2f,
+ @location(3) color: vec4f,
+ @location(4) width_side: vec2f,
+}
+struct Output { @builtin(position) position: vec4f, @location(0) uv: vec2f, @location(1) color: vec4f }
+@vertex fn vs(in: Input) -> Output {
+ var out: Output;
+ var pos = in.position;
+ if (in.width_side.x > 0.0) {
+   var toward = view.eye.xyz - pos;
+   if (view.eye.w > 0.5) { toward = -view.forward.xyz; }
+   var side = cross(in.tangent, toward);
+   if (dot(side, side) < 1e-12) { side = cross(in.tangent, vec3f(0.0, 1.0, 0.0)); }
+   if (dot(side, side) < 1e-12) { side = vec3f(1.0, 0.0, 0.0); }
+   pos += normalize(side) * in.width_side.x * in.width_side.y;
+ }
+ out.position = view.vp * vec4f(pos, 1.0);
+ out.uv = in.uv;
+ out.color = in.color * view.tint;
+ return out;
+}
+@fragment fn fs(in: Output) -> @location(0) vec4f {
+ let c = textureSample(image, image_sampler, in.uv) * in.color;
+ let alpha = c.a * view.params.x;
+ if (alpha <= 0.00001) { discard; }
+ return vec4f(c.rgb * alpha, alpha);
+}`
+};
+const OVER = {
+  color: { srcFactor: "one", dstFactor: "one-minus-src-alpha" },
+  alpha: { srcFactor: "one", dstFactor: "one-minus-src-alpha" }
+};
+const ADD = {
+  color: { srcFactor: "one", dstFactor: "one" },
+  alpha: { srcFactor: "zero", dstFactor: "one" }
+};
+const BUFFERS = [
+  {
+    arrayStride: 56,
+    attributes: [
+      { shaderLocation: 0, offset: 0, format: "float32x3" },
+      { shaderLocation: 1, offset: 12, format: "float32x3" },
+      { shaderLocation: 2, offset: 24, format: "float32x2" },
+      { shaderLocation: 3, offset: 32, format: "float32x4" },
+      { shaderLocation: 4, offset: 48, format: "float32x2" }
+    ]
+  }
+];
+class VfxRenderer {
+  draws = [];
+  generation = -1;
+  layout;
+  pipelines = [void 0, void 0];
+  white;
+  whiteView;
+  sampler;
+  decal;
+  records;
+  constructor(records, decal) {
+    this.records = records;
+    this.decal = decal;
+  }
+  dispose() {
+    for (let i = 0; i < this.draws.length; i++) {
+      this.draws[i].vertices.destroy();
+      this.draws[i].uniform.destroy();
+    }
+    this.draws.length = 0;
+    this.white?.destroy();
+    this.white = void 0;
+    this.whiteView = void 0;
+  }
+  prune(world) {
+    const views = world.resource(Views).list;
+    for (let i = this.draws.length - 1; i >= 0; i--) {
+      const d = this.draws[i];
+      let view = false;
+      for (let j = 0; j < views.length; j++)
+        if (views[j].name === d.view) {
+          view = true;
+          break;
+        }
+      if (!view || !d.source.count || !this.records.includes(d.source)) {
+        d.vertices.destroy();
+        d.uniform.destroy();
+        this.draws.splice(i, 1);
+      }
+    }
+  }
+  init(gpu) {
+    if (this.generation === gpu.generation) return;
+    this.dispose();
+    this.generation = gpu.generation;
+    this.pipelines[0] = void 0;
+    this.pipelines[1] = void 0;
+    this.layout = gpu.layouts.bindGroupLayout({
+      label: "vfx",
+      entries: [
+        {
+          binding: 0,
+          visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT,
+          buffer: { type: "uniform" }
+        },
+        { binding: 1, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "float" } },
+        { binding: 2, visibility: GPUShaderStage.FRAGMENT, sampler: { type: "filtering" } }
+      ]
+    });
+    this.white = gpu.device.createTexture({
+      label: "vfx/white",
+      size: [1, 1],
+      format: "rgba8unorm",
+      usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST,
+      ...bindingDimension(gpu, "2d")
+    });
+    gpu.device.queue.writeTexture(
+      { texture: this.white },
+      new Uint8Array([255, 255, 255, 255]),
+      { bytesPerRow: 4 },
+      [1, 1]
+    );
+    this.whiteView = this.white.createView();
+    this.sampler = gpu.device.createSampler({
+      magFilter: "linear",
+      minFilter: "linear",
+      addressModeU: this.decal ? "clamp-to-edge" : "repeat",
+      addressModeV: "clamp-to-edge"
+    });
+  }
+  node() {
+    return {
+      kind: "render",
+      phase: RenderPhase.Resolve + (this.decal ? 5 : 15),
+      reads: ["depth"],
+      writes: ["hdr"],
+      color: [{ resource: "hdr" }],
+      depth: { resource: "depth", readOnly: true },
+      enabled: (view) => {
+        const cam = cameraOf(view);
+        if (!cam) return false;
+        for (let i = 0; i < this.records.length; i++) {
+          const r = this.records[i];
+          if (r.count && r.visible && r.opacity > 0 && r.layers & cam.layers) return true;
+        }
+        return false;
+      },
+      run: (ctx) => this.draw(ctx)
+    };
+  }
+  draw(ctx) {
+    const gpu = ctx.gpu, cam = cameraOf(ctx.view), pass = ctx.renderPass;
+    this.init(gpu);
+    const textures = ctx.world.resource(Textures), assets = ctx.world.resource(GpuAssetsResource);
+    for (let i = 0; i < this.records.length; i++) {
+      const r = this.records[i];
+      if (!r.count || !r.visible || r.opacity <= 0 || !(r.layers & cam.layers)) continue;
+      const index = r.additive ? 1 : 0;
+      let pipeline = this.pipelines[index];
+      if (!pipeline) {
+        const module = ctx.world.resource(Shaders).module(gpu, { root: "shard::vfx::ribbon" });
+        if (!module) {
+          gpu.pipelines.skipped++;
+          continue;
+        }
+        pipeline = gpu.pipelines.render({
+          label: index ? "vfx/additive" : "vfx/alpha",
+          layout: gpu.layouts.pipelineLayout({ bindGroupLayouts: [this.layout] }),
+          vertex: { module, entryPoint: "vs", buffers: BUFFERS },
+          fragment: {
+            module,
+            entryPoint: "fs",
+            targets: [{ format: "rgba16float", blend: index ? ADD : OVER }]
+          },
+          primitive: { topology: "triangle-list", cullMode: "none" },
+          depthStencil: {
+            format: "depth32float",
+            depthWriteEnabled: false,
+            depthCompare: "greater-equal",
+            // Resolved MSAA depth comes from a subsample, not the fragment center.
+            // Positive reversed-Z slope bias keeps coplanar decals visible on every adapter.
+            depthBias: this.decal ? 1 : 0,
+            depthBiasSlopeScale: this.decal ? 1 : 0
+          }
+        });
+        if (!pipeline) {
+          gpu.pipelines.skipped++;
+          continue;
+        }
+        this.pipelines[index] = pipeline;
+      }
+      let d;
+      for (let j = 0; j < this.draws.length; j++)
+        if (this.draws[j].source === r && this.draws[j].view === ctx.view.name) {
+          d = this.draws[j];
+          break;
+        }
+      if (!d) {
+        d = {
+          source: r,
+          view: ctx.view.name,
+          vertices: new GpuBuffer(gpu, {
+            label: "vfx/vertices",
+            usage: GPUBufferUsage.VERTEX,
+            size: r.vertices.byteLength
+          }),
+          uniform: new GpuBuffer(gpu, {
+            label: "vfx/view",
+            usage: GPUBufferUsage.UNIFORM,
+            size: 128
+          }),
+          data: new Float32Array(32),
+          group: void 0,
+          texture: void 0,
+          version: -1,
+          generation: gpu.generation
+        };
+        this.draws.push(d);
+      }
+      if (d.version !== r.version) {
+        d.vertices.write(r.vertices, 0, 0, r.count * 14);
+        d.version = r.version;
+      }
+      const texture = r.texture ? textures.get(r.texture) : void 0, gt = texture ? assets.texture(texture) : void 0;
+      r.textureState = !r.texture ? "none" : gt ? "ready" : assetServer(ctx.world).entry(r.texture) ? "loading" : "missing";
+      const image = gt ? texture.usage === "color" ? gt.srgb : gt.linear : this.whiteView;
+      if (!d.group || d.texture !== image) {
+        d.texture = image;
+        d.group = gpu.device.createBindGroup({
+          label: "vfx/draw",
+          layout: this.layout,
+          entries: [
+            { binding: 0, resource: { buffer: d.uniform.buffer } },
+            { binding: 1, resource: image },
+            { binding: 2, resource: this.sampler }
+          ]
+        });
+      }
+      d.data.set(cam.viewProj);
+      d.data.set(cam.position, 16);
+      d.data[19] = cam.orthographic ? 1 : 0;
+      d.data.set(cam.forward, 20);
+      d.data[24] = r.opacity;
+      if (this.decal) {
+        const colors = r.columns.color;
+        for (let k = 0; k < 4; k++) d.data[28 + k] = colors[r.row * 4 + k];
+      } else {
+        d.data[28] = 1;
+        d.data[29] = 1;
+        d.data[30] = 1;
+        d.data[31] = 1;
+      }
+      d.uniform.write(d.data);
+      pass.setPipeline(pipeline);
+      pass.setBindGroup(0, d.group);
+      pass.setVertexBuffer(0, d.vertices.buffer);
+      if (this.decal) {
+        const ranges = r.ranges;
+        for (let j = 0; j < ranges.length; j++) {
+          const range = ranges[j];
+          if (!(range.layers & cam.layers)) continue;
+          if (cam.hidden && ctx.world.has(range.entity, InstanceSlot)) {
+            const table = ctx.world.entityTableUnchecked(range.entity), row = ctx.world.entityRowUnchecked(range.entity), slot = table.column(InstanceSlot, "slot")[row] - 1;
+            if (slot >= 0 && (cam.hidden.bits[slot >> 5] ?? 0) & 1 << (slot & 31)) continue;
+          }
+          pass.draw(range.count, 1, range.start);
+        }
+      } else pass.draw(r.count);
+    }
+  }
+}
+export {
+  VFX_SHADERS,
+  VfxRenderer
+};

package/dist/vfx-state.d.ts

@@ -0,0 +1,42 @@
+import type { AssetRef, ComponentDef, Entity, Table, TypedArray, World } from '@aethervtt/shard-core';
+export declare const VFX_STRIDE = 14;
+export interface VfxRecord {
+    entity: Entity;
+    def: ComponentDef;
+    kind: 'trail' | 'beam' | 'decal';
+    table: Table;
+    row: number;
+    columns: Record<string, TypedArray | unknown[]>;
+    matrix: Float64Array;
+    vertices: Float32Array;
+    count: number;
+    version: number;
+    age: number;
+    wasPlaying: boolean;
+    error: string | null;
+    seen: number;
+    opacity: number;
+    texture: AssetRef<'Texture'> | null;
+    layers: number;
+    additive: boolean;
+    textureState: string;
+    visible: boolean;
+}
+export declare function createRecord(world: World, entity: Entity, def: ComponentDef, kind: VfxRecord['kind'], vertices: number): VfxRecord;
+export declare function refreshRecord(world: World, r: VfxRecord): void;
+export declare function number(r: VfxRecord, field: string): number;
+export declare function matrixChanged(world: World, entity: Entity, out: Float64Array): boolean;
+export declare function point(out: Float64Array, at: number, m: ArrayLike<number>, x: number, y: number, z: number): void;
+export declare function recordDescription(r: VfxRecord): {
+    entity: number;
+    kind: "beam" | "decal" | "trail";
+    vertices: number;
+    age: number;
+    opacity: number;
+    error: string | null;
+    visible: boolean;
+    cpuBytes: number;
+    texture: string;
+    playing: boolean;
+    paused: boolean;
+};

package/dist/vfx-state.js

@@ -0,0 +1,81 @@
+import { GlobalTransform } from "@aethervtt/shard-transform";
+import { ComputedVisibility } from "./visibility.js";
+const VFX_STRIDE = 14;
+function createRecord(world, entity, def, kind, vertices) {
+  const table = world.entityTable(entity);
+  return {
+    entity,
+    def,
+    kind,
+    table,
+    row: world.entityRow(entity),
+    columns: table.storage(def).byName,
+    matrix: new Float64Array(12),
+    vertices: new Float32Array(vertices * VFX_STRIDE),
+    count: 0,
+    version: 0,
+    age: 0,
+    wasPlaying: false,
+    error: null,
+    seen: 0,
+    opacity: 1,
+    texture: null,
+    layers: 1,
+    additive: false,
+    textureState: "none",
+    visible: true
+  };
+}
+function refreshRecord(world, r) {
+  r.table = world.entityTableUnchecked(r.entity);
+  r.row = world.entityRowUnchecked(r.entity);
+  r.columns = r.table.storage(r.def).byName;
+  r.texture = r.columns.texture[r.row];
+  r.opacity = number(r, "opacity");
+  r.layers = number(r, "layers");
+  r.additive = number(r, "blend") === 1;
+  r.visible = !r.table.has(ComputedVisibility) || r.table.column(ComputedVisibility, "visible")[r.row] !== 0;
+}
+function number(r, field) {
+  return r.columns[field][r.row];
+}
+function matrixChanged(world, entity, out) {
+  const t = world.entityTableUnchecked(entity), row = world.entityRowUnchecked(entity);
+  const m = t.column(GlobalTransform, "matrix");
+  let changed = false;
+  for (let i = 0; i < 12; i++) {
+    const v = m[row * 12 + i];
+    if (out[i] !== v) changed = true;
+    out[i] = v;
+  }
+  return changed;
+}
+function point(out, at, m, x, y, z) {
+  out[at] = m[0] * x + m[1] * y + m[2] * z + m[3];
+  out[at + 1] = m[4] * x + m[5] * y + m[6] * z + m[7];
+  out[at + 2] = m[8] * x + m[9] * y + m[10] * z + m[11];
+}
+function recordDescription(r) {
+  return {
+    entity: r.entity,
+    kind: r.kind,
+    vertices: r.count,
+    age: r.age,
+    opacity: r.opacity,
+    error: r.error,
+    visible: r.visible,
+    cpuBytes: r.vertices.byteLength,
+    texture: r.textureState,
+    playing: !!number(r, "playing"),
+    paused: !!number(r, "paused")
+  };
+}
+export {
+  VFX_STRIDE,
+  createRecord,
+  matrixChanged,
+  number,
+  point,
+  recordDescription,
+  refreshRecord
+};