wgpu-kit 0.9.11 → 1.0.1

package/dist/life.js

@@ -1,1407 +0,0 @@
-// src/core/errors.ts
-var WgpuKitError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = new.target.name;
-  }
-};
-var WebGPUUnavailableError = class extends WgpuKitError {
-  constructor(reason) {
-    super(
-      `\u5F53\u524D\u73AF\u5883\u4E0D\u53EF\u7528 WebGPU: ${reason}
-  \u6392\u67E5:\u2460 \u6D4F\u89C8\u5668\u9700 Chrome/Edge 113+ \u6216 Safari 18+;\u2461 \u65E0\u5934\u73AF\u5883\u9700\u5F00\u542F WebGPU;\u2462 \u68C0\u67E5 GPU \u9A71\u52A8\u4E0E\u786C\u4EF6\u52A0\u901F\u8BBE\u7F6E\u3002
-  \u53EF\u7528 navigator.gpu \u662F\u5426\u5B58\u5728\u5FEB\u901F\u5224\u65AD\u3002`
-    );
-  }
-};
-var CompileError = class extends WgpuKitError {
-  constructor(kernelName, messages, userCodeOffset) {
-    const mapped = messages.map((m) => {
-      const userLine = m.line - userCodeOffset;
-      const where = userLine > 0 ? `\u7528\u6237\u4EE3\u7801\u7B2C ${userLine} \u884C` : `\u751F\u6210\u4EE3\u7801\u7B2C ${m.line} \u884C(\u5E93\u7684\u95EE\u9898,\u6B22\u8FCE\u62A5 issue)`;
-      return `  ${where}: ${m.msg}`;
-    }).join("\n");
-    super(`kernel "${kernelName}" WGSL \u7F16\u8BD1\u5931\u8D25:
-${mapped}`);
-  }
-};
-var UsageError = class extends WgpuKitError {
-};
-
-// src/core/context.ts
-var GpuContext = class _GpuContext {
-  device;
-  adapterInfo;
-  constructor(device, adapterInfo) {
-    this.device = device;
-    this.adapterInfo = adapterInfo;
-  }
-  static #singleton = null;
-  static get() {
-    if (!_GpuContext.#singleton) {
-      _GpuContext.#singleton = _GpuContext.#create().catch((e) => {
-        _GpuContext.#singleton = null;
-        throw e;
-      });
-    }
-    return _GpuContext.#singleton;
-  }
-  static async #create() {
-    if (typeof navigator === "undefined" || !("gpu" in navigator) || !navigator.gpu) {
-      throw new WebGPUUnavailableError("navigator.gpu \u4E0D\u5B58\u5728");
-    }
-    const adapter = await navigator.gpu.requestAdapter({ powerPreference: "high-performance" });
-    if (!adapter) throw new WebGPUUnavailableError("requestAdapter() \u8FD4\u56DE null");
-    const info = adapter.info;
-    const label = info ? [info.vendor, info.architecture, info.description].filter(Boolean).join(" / ") || "unknown" : "unknown";
-    const requiredLimits = {};
-    const want = [
-      "maxStorageBuffersPerShaderStage",
-      "maxStorageBuffersInVertexStage",
-      "maxStorageBufferBindingSize"
-    ];
-    for (const key of want) {
-      const supported = adapter.limits[key];
-      if (typeof supported === "number") requiredLimits[key] = supported;
-    }
-    const device = await adapter.requestDevice({ label: "wgpu-kit", requiredLimits });
-    return new _GpuContext(device, label);
-  }
-  /** device lost 时 reject;调用方可 await 做清理/提示 */
-  get lost() {
-    return this.device.lost;
-  }
-  /** 等待队列中已提交的全部 GPU 工作完成(测试/读回前同步用) */
-  async sync() {
-    await this.device.queue.onSubmittedWorkDone();
-  }
-};
-
-// src/core/layout.ts
-var TYPES = {
-  f32: { size: 4, align: 4, comps: 1, typed: "Float32Array", wgsl: "f32" },
-  i32: { size: 4, align: 4, comps: 1, typed: "Int32Array", wgsl: "i32" },
-  u32: { size: 4, align: 4, comps: 1, typed: "Uint32Array", wgsl: "u32" },
-  vec2f: { size: 8, align: 8, comps: 2, typed: "Float32Array", wgsl: "vec2f" },
-  vec2i: { size: 8, align: 8, comps: 2, typed: "Int32Array", wgsl: "vec2i" },
-  vec2u: { size: 8, align: 8, comps: 2, typed: "Uint32Array", wgsl: "vec2u" },
-  vec3f: { size: 12, align: 16, comps: 3, typed: "Float32Array", wgsl: "vec3f" },
-  vec4f: { size: 16, align: 16, comps: 4, typed: "Float32Array", wgsl: "vec4f" }
-};
-
-// src/core/buffer.ts
-var TYPED_CTORS = {
-  Float32Array,
-  Int32Array,
-  Uint32Array
-};
-var Buffer = class _Buffer {
-  kind;
-  length;
-  gpuBuffer;
-  #ctx;
-  #byteLength;
-  #staging = null;
-  constructor(ctx, kind, length, gpuBuffer) {
-    this.#ctx = ctx;
-    this.kind = kind;
-    this.length = length;
-    this.gpuBuffer = gpuBuffer;
-    this.#byteLength = length * TYPES[kind].size;
-  }
-  static async create(kind, length) {
-    if (!Number.isInteger(length) || length <= 0) {
-      throw new UsageError(`Buffer \u957F\u5EA6\u5FC5\u987B\u662F\u6B63\u6574\u6570,\u6536\u5230: ${String(length)}`);
-    }
-    const def = TYPES[kind];
-    if (!def) throw new UsageError(`\u672A\u77E5\u7C7B\u578B "${String(kind)}",\u53EF\u7528: ${Object.keys(TYPES).join(", ")}`);
-    const ctx = await GpuContext.get();
-    const gpuBuffer = ctx.device.createBuffer({
-      size: length * def.size,
-      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
-      label: `wgpu-kit Buffer<${kind}>[${length}]`
-    });
-    return new _Buffer(ctx, kind, length, gpuBuffer);
-  }
-  /** 校验并写入(CPU → GPU) */
-  write(data) {
-    const ctor = TYPED_CTORS[TYPES[this.kind].typed];
-    if (!(data instanceof ctor)) {
-      throw new UsageError(`Buffer<${this.kind}>.write \u9700\u8981 ${TYPES[this.kind].typed},\u6536\u5230 ${data.constructor?.name ?? typeof data}`);
-    }
-    const expected = this.length * TYPES[this.kind].comps;
-    if (data.length !== expected) {
-      throw new UsageError(`Buffer<${this.kind}>[${this.length}].write \u9700\u8981 ${expected} \u4E2A\u5206\u91CF,\u6536\u5230 ${data.length}`);
-    }
-    this.#ctx.device.queue.writeBuffer(this.gpuBuffer, 0, data);
-  }
-  /** GPU → CPU:内部 staging buffer + mapAsync,mapAsync 的异步陷阱由库承担 */
-  async read() {
-    const def = TYPES[this.kind];
-    if (!this.#staging) {
-      this.#staging = this.#ctx.device.createBuffer({
-        size: this.#byteLength,
-        usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
-        label: `wgpu-kit staging[${this.length}]`
-      });
-    }
-    const enc = this.#ctx.device.createCommandEncoder();
-    enc.copyBufferToBuffer(this.gpuBuffer, 0, this.#staging, 0, this.#byteLength);
-    this.#ctx.device.queue.submit([enc.finish()]);
-    await this.#staging.mapAsync(GPUMapMode.READ);
-    const ab = this.#staging.getMappedRange().slice(0);
-    this.#staging.unmap();
-    if (def.typed === "Float32Array") return new Float32Array(ab);
-    if (def.typed === "Int32Array") return new Int32Array(ab);
-    return new Uint32Array(ab);
-  }
-  destroy() {
-    if (this.#staging) {
-      this.#staging.destroy();
-      this.#staging = null;
-    }
-    this.gpuBuffer.destroy();
-  }
-};
-
-// src/core/pingpong.ts
-var PingPong = class _PingPong {
-  #sides;
-  #names;
-  #length;
-  #kinds;
-  #index = 0;
-  constructor(names, kinds, length, a, b) {
-    this.#names = names;
-    this.#kinds = kinds;
-    this.#length = length;
-    this.#sides = [a, b];
-  }
-  static async create(kinds, length) {
-    const names = Object.keys(kinds);
-    if (names.length === 0) throw new Error("PingPong \u81F3\u5C11\u9700\u8981\u4E00\u4E2A\u5B57\u6BB5");
-    const make = async () => {
-      const side = {};
-      for (const name of names) side[name] = await Buffer.create(kinds[name], length);
-      return side;
-    };
-    return new _PingPong(names, kinds, length, await make(), await make());
-  }
-  /** 当前帧的数据侧(渲染/读回用) */
-  get current() {
-    return this.#sides[this.#index];
-  }
-  /** 另一侧(kernel 写入目标) */
-  get other() {
-    return this.#sides[1 - this.#index];
-  }
-  /** 帧末翻转 */
-  swap() {
-    this.#index = 1 - this.#index;
-  }
-  /** 以 (写侧, 读侧) 调用 fn 后自动 swap 的语法糖 */
-  async runWith(fn) {
-    await fn(this.other, this.current);
-    this.swap();
-  }
-  destroy() {
-    for (const side of this.#sides) for (const b of Object.values(side)) b.destroy();
-  }
-  /** 克隆一份同构 PingPong(同字段同长度) */
-  async clone() {
-    return _PingPong.create(this.#kinds, this.#length);
-  }
-  get names() {
-    return this.#names;
-  }
-};
-
-// src/packs/life/map.ts
-var COLORMAPS = {
-  mono: "vec3f(v)",
-  amber: `vec3f(
-    1.35 * v * v,
-    0.9 * v * v * v + 0.25 * v * (1.0 - v),
-    0.15 * v * v * v
-  )`,
-  ice: `vec3f(0.15 * v * v, 0.55 * v * v + 0.2 * v, 1.1 * v)`,
-  duotone: `mix(vec3f(0.02, 0.03, 0.08), vec3f(0.42, 0.78, 1.0), v) + vec3f(0.9, 0.6, 0.25) * v * v * v * 0.6`
-};
-function mapFragment(colormap) {
-  return (
-    /* wgsl */
-    `
-struct VsOut {
-  @builtin(position) pos: vec4f,
-  @location(0) uv: vec2f,
-};
-@group(0) @binding(0) var<uniform> vp: vec4f; // w, h, maxV, gamma
-@group(0) @binding(1) var<storage, read> map: array<f32>;
-
-@vertex
-fn vs(@builtin(vertex_index) v: u32) -> VsOut {
-  var p = array<vec2f, 3>(vec2f(-1.0, -1.0), vec2f(3.0, -1.0), vec2f(-1.0, 3.0));
-  var out: VsOut;
-  out.pos = vec4f(p[v], 0.0, 1.0);
-  out.uv = (p[v] + vec2f(1.0)) * 0.5;
-  out.uv = vec2f(out.uv.x, 1.0 - out.uv.y); // buffer \u884C 0 = \u753B\u9762\u9876\u90E8
-  return out;
-}
-
-@fragment
-fn fs(in: VsOut) -> @location(0) vec4f {
-  let w = u32(vp.x);
-  let x = min(u32(in.uv.x * vp.x), w - 1u);
-  let y = min(u32(in.uv.y * vp.y), u32(vp.y) - 1u);
-  let v = pow(clamp(abs(map[y * w + x]) * vp.z, 0.0, 1.0), vp.w);
-  let c = ${COLORMAPS[colormap]};
-  return vec4f(c, 1.0);
-}
-`
-  );
-}
-var MapRenderer = class _MapRenderer {
-  #ctx;
-  #gpuCtx;
-  #pipeline;
-  #uniform;
-  #bgCache = /* @__PURE__ */ new Map();
-  #ids = /* @__PURE__ */ new WeakMap();
-  constructor(ctx, gpuCtx, pipeline, uniform) {
-    this.#ctx = ctx;
-    this.#gpuCtx = gpuCtx;
-    this.#pipeline = pipeline;
-    this.#uniform = uniform;
-  }
-  static async create(canvas, opts) {
-    const ctx = await GpuContext.get();
-    const gpuCtx = canvas.getContext("webgpu");
-    if (!gpuCtx) throw new Error('canvas.getContext("webgpu") \u8FD4\u56DE\u7A7A');
-    const format = navigator.gpu.getPreferredCanvasFormat();
-    gpuCtx.configure({ device: ctx.device, format, alphaMode: "opaque" });
-    const module = ctx.device.createShaderModule({ code: mapFragment(opts.colormap), label: "life-map-render" });
-    const info = await module.getCompilationInfo();
-    const errors = info.messages.filter((m) => m.type === "error");
-    if (errors.length > 0) throw new CompileError("life-map-render", errors.map((m) => ({ line: m.lineNum, msg: m.message })), 0);
-    const pipeline = ctx.device.createRenderPipeline({
-      layout: "auto",
-      vertex: { module, entryPoint: "vs" },
-      fragment: { module, entryPoint: "fs", targets: [{ format }] },
-      primitive: { topology: "triangle-list" }
-    });
-    const uniform = ctx.device.createBuffer({ size: 16, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
-    ctx.device.queue.writeBuffer(uniform, 0, new Float32Array([opts.width, opts.height, opts.maxV, opts.gamma ?? 1]));
-    return new _MapRenderer(ctx, gpuCtx, pipeline, uniform);
-  }
-  render(map) {
-    let id = this.#ids.get(map.gpuBuffer);
-    if (id === void 0) {
-      id = this.#bgCache.size + 1;
-      this.#ids.set(map.gpuBuffer, id);
-    }
-    let bg = this.#bgCache.get(id);
-    if (!bg) {
-      bg = this.#ctx.device.createBindGroup({
-        layout: this.#pipeline.getBindGroupLayout(0),
-        entries: [
-          { binding: 0, resource: { buffer: this.#uniform } },
-          { binding: 1, resource: { buffer: map.gpuBuffer } }
-        ]
-      });
-      this.#bgCache.set(id, bg);
-    }
-    const enc = this.#ctx.device.createCommandEncoder();
-    const pass = enc.beginRenderPass({
-      colorAttachments: [{
-        view: this.#gpuCtx.getCurrentTexture().createView(),
-        clearValue: { r: 0, g: 0, b: 0, a: 1 },
-        loadOp: "clear",
-        storeOp: "store"
-      }]
-    });
-    pass.setPipeline(this.#pipeline);
-    pass.setBindGroup(0, bg);
-    pass.draw(3);
-    pass.end();
-    this.#ctx.device.queue.submit([enc.finish()]);
-  }
-};
-
-// src/packs/particles/presets.ts
-function mulberry32(seed) {
-  let s = seed | 0;
-  return () => {
-    s = s + 1831565813 | 0;
-    let t = Math.imul(s ^ s >>> 15, 1 | s);
-    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
-    return ((t ^ t >>> 14) >>> 0) / 4294967296;
-  };
-}
-
-// src/packs/life/turing.ts
-var PRESETS = {
-  coral: { f: 0.0545, k: 0.062 },
-  mitosis: { f: 0.0367, k: 0.0649 },
-  spots: { f: 0.03, k: 0.062 },
-  waves: { f: 0.014, k: 0.045 }
-};
-var USIZE = 32;
-async function turing(config = {}) {
-  const size = config.size ?? 512;
-  const preset = config.preset ?? "coral";
-  const p = preset === "custom" ? { f: config.feed ?? 0.037, k: config.kill ?? 0.06 } : PRESETS[preset];
-  const steps = config.steps ?? 12;
-  const seedHash = typeof config.seed === "string" ? hashStr(config.seed) : config.seed ?? 42;
-  const colormap = config.colormap ?? "duotone";
-  const ctx = await GpuContext.get();
-  const device = ctx.device;
-  const state = await PingPong.create({ st: "vec2f" }, size * size);
-  const sideA = state.current.st;
-  const sideB = state.other.st;
-  {
-    const rand = mulberry32(seedHash);
-    const init = new Float32Array(size * size * 2);
-    for (let i = 0; i < size * size; i++) init[i * 2] = 1;
-    for (let s = 0; s < 10; s++) {
-      const cx = 40 + Math.floor(rand() * (size - 80));
-      const cy = 40 + Math.floor(rand() * (size - 80));
-      const r = 3 + Math.floor(rand() * 6);
-      for (let y = cy - r; y <= cy + r; y++) {
-        for (let x = cx - r; x <= cx + r; x++) {
-          const idx = (y + size) % size * size + (x + size) % size;
-          init[idx * 2] = 0.5;
-          init[idx * 2 + 1] = 0.25;
-        }
-      }
-    }
-    sideA.write(init);
-  }
-  const uniform = device.createBuffer({ size: USIZE, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
-  const params = { f: p.f, k: p.k, dA: 1, dB: 0.5, dt: 1 };
-  const writeUniform = () => {
-    const buf = new ArrayBuffer(USIZE);
-    const v = new DataView(buf);
-    v.setUint32(0, size, true);
-    v.setUint32(4, size, true);
-    v.setFloat32(8, params.f, true);
-    v.setFloat32(12, params.k, true);
-    v.setFloat32(16, params.dA, true);
-    v.setFloat32(20, params.dB, true);
-    v.setFloat32(24, params.dt, true);
-    device.queue.writeBuffer(uniform, 0, buf);
-  };
-  writeUniform();
-  const module = device.createShaderModule({ code: updateWgsl(), label: "turing-update" });
-  const info = await module.getCompilationInfo();
-  const errors = info.messages.filter((m) => m.type === "error");
-  if (errors.length > 0) throw new CompileError("turing-update", errors.map((m) => ({ line: m.lineNum, msg: m.message })), 0);
-  const pipeline = device.createComputePipeline({ layout: "auto", compute: { module, entryPoint: "main" } });
-  const bg = (read, write) => device.createBindGroup({
-    layout: pipeline.getBindGroupLayout(0),
-    entries: [
-      { binding: 0, resource: { buffer: uniform } },
-      { binding: 1, resource: { buffer: read.gpuBuffer } },
-      { binding: 2, resource: { buffer: write.gpuBuffer } }
-    ]
-  });
-  const bgAB = bg(sideA, sideB);
-  const bgBA = bg(sideB, sideA);
-  let renderer = null;
-  let frame = 0;
-  let lastFps = 0;
-  let fFrames = 0;
-  let fAcc = 0;
-  let fLast = performance.now();
-  return {
-    config: { size, preset, feed: params.f, kill: params.k, steps },
-    async attach(canvas) {
-      const dpr = Math.min(window.devicePixelRatio || 1, 2);
-      canvas.width = Math.max(1, Math.floor(canvas.clientWidth * dpr));
-      canvas.height = Math.max(1, Math.floor(canvas.clientHeight * dpr));
-      renderer = await MapRenderer.create(canvas, { width: size, height: size, maxV: 0.9, gamma: 0.85, colormap });
-    },
-    tick() {
-      const base = frame * steps;
-      const enc = device.createCommandEncoder();
-      const pass = enc.beginComputePass();
-      pass.setPipeline(pipeline);
-      for (let s = 0; s < steps; s++) {
-        pass.setBindGroup(0, (base + s) % 2 === 0 ? bgAB : bgBA);
-        pass.dispatchWorkgroups(Math.ceil(size * size / 64));
-      }
-      pass.end();
-      device.queue.submit([enc.finish()]);
-      renderer?.render((base + steps - 1) % 2 === 0 ? sideB : sideA);
-      for (let s = 0; s < steps; s++) state.swap();
-      frame++;
-      fFrames++;
-      const now = performance.now();
-      fAcc += now - fLast;
-      fLast = now;
-      if (fAcc >= 500) {
-        lastFps = fFrames / (fAcc / 1e3);
-        fFrames = 0;
-        fAcc = 0;
-      }
-    },
-    sprinkle(count = 6) {
-      const rand = mulberry32(seedHash + frame >>> 0);
-      const patch = new Float32Array(size * size * 2);
-      for (let s = 0; s < count; s++) {
-        const cx = Math.floor(rand() * size);
-        const cy = Math.floor(rand() * size);
-        const r = 2 + Math.floor(rand() * 5);
-        for (let y = cy - r; y <= cy + r; y++) {
-          for (let x = cx - r; x <= cx + r; x++) {
-            const idx = (y + size) % size * size + (x + size) % size;
-            patch[idx * 2] = 0.5;
-            patch[idx * 2 + 1] = 0.25;
-          }
-        }
-      }
-      device.queue.writeBuffer(state.current.st.gpuBuffer, 0, patch);
-    },
-    stats() {
-      return { fps: lastFps };
-    },
-    async sampleB() {
-      const data = await state.current.st.read();
-      const out = new Float32Array(size * size);
-      for (let i = 0; i < out.length; i++) out[i] = data[i * 2 + 1] ?? 0;
-      return out;
-    },
-    destroy() {
-      state.destroy();
-      uniform.destroy();
-    }
-  };
-}
-function updateWgsl() {
-  return (
-    /* wgsl */
-    `
-struct Params {
-  w: u32, h: u32,
-  f: f32, k: f32, dA: f32, dB: f32, dt: f32,
-};
-@group(0) @binding(0) var<uniform> params: Params;
-@group(0) @binding(1) var<storage, read> src: array<vec2f>;
-@group(0) @binding(2) var<storage, read_write> dst: array<vec2f>;
-
-fn at(x: i32, y: i32) -> vec2f {
-  let w = i32(params.w);
-  let h = i32(params.h);
-  let xi = (x + w) % w;
-  let yi = (y + h) % h;
-  return src[u32(yi) * u32(w) + u32(xi)];
-}
-
-@compute @workgroup_size(64)
-fn main(@builtin(global_invocation_id) gid: vec3u) {
-  let i = gid.x;
-  if (i >= params.w * params.h) { return; }
-  let x = i32(i % params.w);
-  let y = i32(i / params.w);
-
-  // 9 \u70B9 Laplacian:\u6B63\u4EA4 0.2,\u5BF9\u89D2 0.05
-  var lapA = -1.0 * at(x, y).x;
-  var lapB = -1.0 * at(x, y).y;
-  for (var dy = -1; dy <= 1; dy++) {
-    for (var dx = -1; dx <= 1; dx++) {
-      if (dx == 0 && dy == 0) { continue; }
-      let s = at(x + dx, y + dy);
-      let wgt = select(0.05, 0.2, dx == 0 || dy == 0);
-      lapA = lapA + wgt * s.x;
-      lapB = lapB + wgt * s.y;
-    }
-  }
-
-  let a = at(x, y).x;
-  let b = at(x, y).y;
-  var a2 = a + (params.dA * lapA - a * b * b + params.f * (1.0 - a)) * params.dt;
-  var b2 = b + (params.dB * lapB + a * b * b - (params.k + params.f) * b) * params.dt;
-  a2 = clamp(a2, 0.0, 1.0);
-  b2 = clamp(b2, 0.0, 1.0);
-  dst[i] = vec2f(a2, b2);
-}
-`
-  );
-}
-function hashStr(s) {
-  let h = 2166136261;
-  for (let i = 0; i < s.length; i++) {
-    h ^= s.charCodeAt(i);
-    h = Math.imul(h, 16777619);
-  }
-  return h >>> 0;
-}
-
-// src/packs/life/physarum.ts
-var AWG = 32;
-async function physarum(config = {}) {
-  const {
-    agents: N = 1e5,
-    mapSize = 1024,
-    sensorAngle = 0.5,
-    sensorDist = 0.012,
-    turnAngle = 0.45,
-    step = 3e-3,
-    decay = 0.06,
-    seed = "physarum",
-    colormap = "amber"
-  } = config;
-  const seedHash = typeof seed === "string" ? hashStr2(seed) : seed ?? 7;
-  const ctx = await GpuContext.get();
-  const device = ctx.device;
-  const posBuf = await Buffer.create("vec2f", N);
-  const angBuf = await Buffer.create("f32", N);
-  {
-    const rand = mulberry32(seedHash);
-    const p = new Float32Array(N * 2);
-    const a = new Float32Array(N);
-    for (let i = 0; i < N; i++) {
-      const t = rand() * Math.PI * 2;
-      const r = Math.sqrt(rand()) * 0.08;
-      p[i * 2] = Math.cos(t) * r;
-      p[i * 2 + 1] = Math.sin(t) * r;
-      a[i] = t;
-    }
-    posBuf.write(p);
-    angBuf.write(a);
-  }
-  const trail = await PingPong.create({ t: "f32" }, mapSize * mapSize);
-  const trailA = trail.current.t;
-  const trailB = trail.other.t;
-  const uniform = device.createBuffer({ size: AWG, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
-  const writeUniform = () => {
-    const buf = new ArrayBuffer(AWG);
-    const v = new DataView(buf);
-    v.setUint32(0, N, true);
-    v.setUint32(4, 0, true);
-    v.setFloat32(8, sensorAngle, true);
-    v.setFloat32(12, sensorDist, true);
-    v.setFloat32(16, turnAngle, true);
-    v.setFloat32(20, step, true);
-    v.setFloat32(24, 1, true);
-    v.setFloat32(28, 1, true);
-    device.queue.writeBuffer(uniform, 0, buf);
-  };
-  writeUniform();
-  const diffuseUniform = device.createBuffer({ size: 16, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
-  device.queue.writeBuffer(diffuseUniform, 0, new Uint32Array([mapSize, mapSize]));
-  device.queue.writeBuffer(diffuseUniform, 8, new Float32Array([1 - decay, 0]));
-  const compile = async (code, label) => {
-    const m = device.createShaderModule({ code, label });
-    const info = await m.getCompilationInfo();
-    const errors = info.messages.filter((x) => x.type === "error");
-    if (errors.length > 0) throw new CompileError(label, errors.map((x) => ({ line: x.lineNum, msg: x.message })), 0);
-    return m;
-  };
-  const mAgent = await compile(agentWgsl(mapSize), "physarum-agent");
-  const mDiffuse = await compile(diffuseWgsl(), "physarum-diffuse");
-  const pAgent = device.createComputePipeline({ layout: "auto", compute: { module: mAgent, entryPoint: "main" } });
-  const pDiffuse = device.createComputePipeline({ layout: "auto", compute: { module: mDiffuse, entryPoint: "main" } });
-  const bgAgent = (t) => device.createBindGroup({
-    layout: pAgent.getBindGroupLayout(0),
-    entries: [
-      { binding: 0, resource: { buffer: uniform } },
-      { binding: 1, resource: { buffer: posBuf.gpuBuffer } },
-      { binding: 2, resource: { buffer: angBuf.gpuBuffer } },
-      { binding: 3, resource: { buffer: t.gpuBuffer } }
-    ]
-  });
-  const bgDiffuse = (read, write) => device.createBindGroup({
-    layout: pDiffuse.getBindGroupLayout(0),
-    entries: [
-      { binding: 0, resource: { buffer: diffuseUniform } },
-      { binding: 1, resource: { buffer: read.gpuBuffer } },
-      { binding: 2, resource: { buffer: write.gpuBuffer } }
-    ]
-  });
-  let renderer = null;
-  let frame = 0;
-  let lastFps = 0;
-  let fFrames = 0;
-  let fAcc = 0;
-  let fLast = performance.now();
-  return {
-    async attach(canvas) {
-      const dpr = Math.min(window.devicePixelRatio || 1, 2);
-      canvas.width = Math.max(1, Math.floor(canvas.clientWidth * dpr));
-      canvas.height = Math.max(1, Math.floor(canvas.clientHeight * dpr));
-      renderer = await MapRenderer.create(canvas, { width: mapSize, height: mapSize, maxV: 6, gamma: 0.6, colormap });
-    },
-    tick() {
-      const readT = trail.current.t;
-      const writeT = trail.other.t;
-      const enc = device.createCommandEncoder();
-      const pass = enc.beginComputePass();
-      pass.setPipeline(pAgent);
-      pass.setBindGroup(0, bgAgent(readT));
-      pass.dispatchWorkgroups(Math.ceil(N / 64));
-      pass.setPipeline(pDiffuse);
-      pass.setBindGroup(0, bgDiffuse(readT, writeT));
-      pass.dispatchWorkgroups(Math.ceil(mapSize * mapSize / 64));
-      pass.end();
-      device.queue.submit([enc.finish()]);
-      renderer?.render(writeT);
-      trail.swap();
-      frame++;
-      fFrames++;
-      const now = performance.now();
-      fAcc += now - fLast;
-      fLast = now;
-      if (fAcc >= 500) {
-        lastFps = fFrames / (fAcc / 1e3);
-        fFrames = 0;
-        fAcc = 0;
-      }
-    },
-    stats() {
-      return { fps: lastFps };
-    },
-    async sampleTrail() {
-      return await trail.current.t.read();
-    },
-    destroy() {
-      posBuf.destroy();
-      angBuf.destroy();
-      trail.destroy();
-      uniform.destroy();
-      diffuseUniform.destroy();
-    }
-  };
-}
-function agentWgsl(trailW) {
-  return (
-    /* wgsl */
-    `
-const TRAIL_W: u32 = ${trailW}u;
-const TRAIL_MASK: u32 = ${trailW - 1}u;
-struct Params {
-  count: u32, _pad: u32,
-  sensorAngle: f32, sensorDist: f32, turnAngle: f32, step: f32,
-  deposit: f32, worldHalf: f32,
-};
-@group(0) @binding(0) var<uniform> params: Params;
-@group(0) @binding(1) var<storage, read_write> pos: array<vec2f>;
-@group(0) @binding(2) var<storage, read_write> ang: array<f32>;
-@group(0) @binding(3) var<storage, read_write> trail: array<f32>;
-
-fn texel(p: vec2f) -> u32 {
-  let x = min(u32((p.x * 0.5 + 0.5) * f32(TRAIL_W)), TRAIL_MASK);
-  let y = min(u32((p.y * 0.5 + 0.5) * f32(TRAIL_W)), TRAIL_MASK);
-  return y * TRAIL_W + x;
-}
-
-fn sense(p: vec2f, a: f32) -> f32 {
-  return trail[texel(p + vec2f(cos(a), sin(a)) * params.sensorDist)];
-}
-
-@compute @workgroup_size(64)
-fn main(@builtin(global_invocation_id) gid: vec3u) {
-  let i = gid.x;
-  if (i >= params.count) { return; }
-  let p = pos[i];
-  var a = ang[i];
-
-  let fwd = sense(p, a);
-  let left = sense(p, a - params.sensorAngle);
-  let right = sense(p, a + params.sensorAngle);
-
-  let jitter = (f32((i * 2654435761u + 1u) % 100u) / 100.0 - 0.5) * 0.1;
-  if (fwd > left && fwd > right) {
-    // \u76F4\u884C
-  } else if (left > right) {
-    a = a - params.turnAngle;
-  } else if (right > left) {
-    a = a + params.turnAngle;
-  }
-  a = a + jitter * 0.1;
-
-  var np = p + vec2f(cos(a), sin(a)) * params.step;
-  let h = params.worldHalf;
-  if (abs(np.x) > h || abs(np.y) > h) {
-    np = clamp(np, vec2f(-h), vec2f(h));
-    a = a + 3.14159265; // \u649E\u5899\u6389\u5934
-  }
-  pos[i] = np;
-  ang[i] = a;
-  let t = texel(np);
-  trail[t] = trail[t] + params.deposit;
-}
-`
-  );
-}
-function diffuseWgsl() {
-  return (
-    /* wgsl */
-    `
-@group(0) @binding(0) var<uniform> vp: vec4f; // w, h, keep(1-decay), pad
-@group(0) @binding(1) var<storage, read> src: array<f32>;
-@group(0) @binding(2) var<storage, read_write> dst: array<f32>;
-
-@compute @workgroup_size(64)
-fn main(@builtin(global_invocation_id) gid: vec3u) {
-  let i = gid.x;
-  let w = u32(vp.x);
-  let h = u32(vp.y);
-  if (i >= w * h) { return; }
-  let x = i32(i % w);
-  let y = i32(i / w);
-
-  // 4 \u90BB\u57DF + \u81EA\u8EAB \u6DF7\u5408(\u6269\u6563),\u518D\u4E58 keep(\u8870\u51CF)
-  let c = src[i];
-  var s = c * 2.0;
-  s = s + src[u32(clamp(y - 1, 0, i32(h) - 1)) * w + u32(clamp(x, 0, i32(w) - 1))];
-  s = s + src[u32(clamp(y + 1, 0, i32(h) - 1)) * w + u32(clamp(x, 0, i32(w) - 1))];
-  s = s + src[u32(clamp(y, 0, i32(h) - 1)) * w + u32(clamp(x - 1, 0, i32(w) - 1))];
-  s = s + src[u32(clamp(y, 0, i32(h) - 1)) * w + u32(clamp(x + 1, 0, i32(w) - 1))];
-  let blurred = s / 6.0;
-  dst[i] = mix(blurred, c, 0.5) * vp.z;
-}
-`
-  );
-}
-function hashStr2(s) {
-  let h = 2166136261;
-  for (let i = 0; i < s.length; i++) {
-    h ^= s.charCodeAt(i);
-    h = Math.imul(h, 16777619);
-  }
-  return h >>> 0;
-}
-
-// src/packs/life/boids.ts
-var WG = 64;
-async function boids(config = {}) {
-  const {
-    count: N = 3e3,
-    perception = 0.05,
-    maxSpeed = 0.012,
-    wSep = 1.6,
-    wAli = 1,
-    wCoh = 0.8,
-    size = 9e-3,
-    seed = "boids"
-  } = config;
-  const seedHash = typeof seed === "string" ? hashStr3(seed) : seed ?? 3;
-  const gridSize = Math.max(4, Math.ceil(2 / perception));
-  const ctx = await GpuContext.get();
-  const device = ctx.device;
-  const pp = await PingPong.create({ pos: "vec2f", vel: "vec2f" }, N);
-  const sideA = { pos: pp.current.pos, vel: pp.current.vel };
-  const sideB = { pos: pp.other.pos, vel: pp.other.vel };
-  {
-    const rand = mulberry32(seedHash);
-    const p = new Float32Array(N * 2);
-    const v = new Float32Array(N * 2);
-    for (let i = 0; i < N; i++) {
-      const t = rand() * Math.PI * 2;
-      const r = Math.sqrt(rand()) * 0.6;
-      p[i * 2] = Math.cos(t) * r;
-      p[i * 2 + 1] = Math.sin(t) * r;
-      const va = rand() * Math.PI * 2;
-      v[i * 2] = Math.cos(va) * maxSpeed * 0.6;
-      v[i * 2 + 1] = Math.sin(va) * maxSpeed * 0.6;
-    }
-    sideA.pos.write(p);
-    sideA.vel.write(v);
-  }
-  const USIZE3 = 48;
-  const uniform = device.createBuffer({ size: USIZE3, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
-  const writeUniform = () => {
-    const b = new ArrayBuffer(USIZE3);
-    const v = new DataView(b);
-    v.setUint32(0, N, true);
-    v.setUint32(4, gridSize, true);
-    v.setFloat32(8, perception, true);
-    v.setFloat32(12, maxSpeed, true);
-    v.setFloat32(16, wSep, true);
-    v.setFloat32(20, wAli, true);
-    v.setFloat32(24, wCoh, true);
-    v.setFloat32(28, 1 / 60, true);
-    v.setFloat32(32, 1, true);
-    device.queue.writeBuffer(uniform, 0, b);
-  };
-  writeUniform();
-  const cells = gridSize * gridSize;
-  const cellCount = await Buffer.create("u32", cells);
-  const cellStart = await Buffer.create("u32", cells);
-  const cellFill = await Buffer.create("u32", cells);
-  const order = await Buffer.create("u32", N);
-  cellCount.write(new Uint32Array(cells));
-  const module = device.createShaderModule({ code: boidsWgsl(size), label: "boids" });
-  const info = await module.getCompilationInfo();
-  const errors = info.messages.filter((m) => m.type === "error");
-  if (errors.length > 0) throw new CompileError("boids", errors.map((m) => ({ line: m.lineNum, msg: m.message })), 0);
-  const pCounts = device.createComputePipeline({ layout: "auto", compute: { module, entryPoint: "main_counts" } });
-  const pScan = device.createComputePipeline({ layout: "auto", compute: { module, entryPoint: "main_scan" } });
-  const pScatter = device.createComputePipeline({ layout: "auto", compute: { module, entryPoint: "main_scatter" } });
-  const pForce = device.createComputePipeline({ layout: "auto", compute: { module, entryPoint: "main_force" } });
-  const pRender = device.createRenderPipeline({
-    layout: "auto",
-    vertex: { module, entryPoint: "vs" },
-    fragment: { module, entryPoint: "fs", targets: [{ format: navigator.gpu.getPreferredCanvasFormat() }] },
-    primitive: { topology: "triangle-list" }
-  });
-  const bgCounts = (read) => device.createBindGroup({
-    layout: pCounts.getBindGroupLayout(0),
-    entries: [
-      { binding: 0, resource: { buffer: uniform } },
-      { binding: 1, resource: { buffer: read.pos.gpuBuffer } },
-      { binding: 2, resource: { buffer: cellCount.gpuBuffer } }
-    ]
-  });
-  const bgScan = device.createBindGroup({
-    layout: pScan.getBindGroupLayout(0),
-    entries: [
-      { binding: 0, resource: { buffer: uniform } },
-      { binding: 2, resource: { buffer: cellCount.gpuBuffer } },
-      { binding: 3, resource: { buffer: cellStart.gpuBuffer } },
-      { binding: 4, resource: { buffer: cellFill.gpuBuffer } }
-    ]
-  });
-  const bgScatter = (read) => device.createBindGroup({
-    layout: pScatter.getBindGroupLayout(0),
-    entries: [
-      { binding: 0, resource: { buffer: uniform } },
-      { binding: 1, resource: { buffer: read.pos.gpuBuffer } },
-      { binding: 4, resource: { buffer: cellFill.gpuBuffer } },
-      { binding: 5, resource: { buffer: order.gpuBuffer } }
-    ]
-  });
-  const bgForce = (read, write) => device.createBindGroup({
-    layout: pForce.getBindGroupLayout(0),
-    entries: [
-      { binding: 0, resource: { buffer: uniform } },
-      { binding: 1, resource: { buffer: read.pos.gpuBuffer } },
-      { binding: 6, resource: { buffer: read.vel.gpuBuffer } },
-      { binding: 7, resource: { buffer: write.pos.gpuBuffer } },
-      { binding: 8, resource: { buffer: write.vel.gpuBuffer } },
-      { binding: 3, resource: { buffer: cellStart.gpuBuffer } },
-      { binding: 4, resource: { buffer: cellFill.gpuBuffer } },
-      { binding: 5, resource: { buffer: order.gpuBuffer } }
-    ]
-  });
-  const bgRender = (read) => device.createBindGroup({
-    layout: pRender.getBindGroupLayout(0),
-    entries: [
-      { binding: 0, resource: { buffer: uniform } },
-      { binding: 1, resource: { buffer: read.pos.gpuBuffer } },
-      { binding: 6, resource: { buffer: read.vel.gpuBuffer } }
-    ]
-  });
-  let gpuCtx = null;
-  let frame = 0;
-  let lastFps = 0;
-  let fFrames = 0;
-  let fAcc = 0;
-  let fLast = performance.now();
-  return {
-    async attach(canvas) {
-      const dpr = Math.min(window.devicePixelRatio || 1, 2);
-      canvas.width = Math.max(1, Math.floor(canvas.clientWidth * dpr));
-      canvas.height = Math.max(1, Math.floor(canvas.clientHeight * dpr));
-      const c = canvas.getContext("webgpu");
-      if (!c) throw new Error('canvas.getContext("webgpu") \u8FD4\u56DE\u7A7A');
-      c.configure({ device, format: navigator.gpu.getPreferredCanvasFormat(), alphaMode: "opaque" });
-      gpuCtx = c;
-    },
-    tick() {
-      const useAB = frame % 2 === 0;
-      const read = useAB ? sideA : sideB;
-      const write = useAB ? sideB : sideA;
-      const enc = device.createCommandEncoder();
-      const pass = enc.beginComputePass();
-      pass.setPipeline(pCounts);
-      pass.setBindGroup(0, bgCounts(read));
-      pass.dispatchWorkgroups(Math.ceil(N / WG));
-      pass.setPipeline(pScan);
-      pass.setBindGroup(0, bgScan);
-      pass.dispatchWorkgroups(1);
-      pass.setPipeline(pScatter);
-      pass.setBindGroup(0, bgScatter(read));
-      pass.dispatchWorkgroups(Math.ceil(N / WG));
-      pass.setPipeline(pForce);
-      pass.setBindGroup(0, bgForce(read, write));
-      pass.dispatchWorkgroups(Math.ceil(N / WG));
-      pass.end();
-      device.queue.submit([enc.finish()]);
-      if (gpuCtx) {
-        const bg = bgRender(write);
-        const re = enc2(device, gpuCtx, pRender, bg, N);
-        device.queue.submit([re]);
-      }
-      pp.swap();
-      frame++;
-      fFrames++;
-      const now = performance.now();
-      fAcc += now - fLast;
-      fLast = now;
-      if (fAcc >= 500) {
-        lastFps = fFrames / (fAcc / 1e3);
-        fFrames = 0;
-        fAcc = 0;
-      }
-    },
-    stats() {
-      return { fps: lastFps };
-    },
-    buffers() {
-      return { pos: pp.current.pos, vel: pp.current.vel };
-    },
-    destroy() {
-      pp.destroy();
-      cellCount.destroy();
-      cellStart.destroy();
-      cellFill.destroy();
-      order.destroy();
-      uniform.destroy();
-    }
-  };
-}
-function enc2(device, gpuCtx, pipeline, bg, n) {
-  const enc = device.createCommandEncoder();
-  const pass = enc.beginRenderPass({
-    colorAttachments: [{
-      view: gpuCtx.getCurrentTexture().createView(),
-      clearValue: { r: 0.012, g: 0.016, b: 0.03, a: 1 },
-      loadOp: "clear",
-      storeOp: "store"
-    }]
-  });
-  pass.setPipeline(pipeline);
-  pass.setBindGroup(0, bg);
-  pass.draw(3, n);
-  pass.end();
-  return enc.finish();
-}
-function boidsWgsl(pointSize) {
-  return (
-    /* wgsl */
-    `
-struct Params {
-  count: u32, gridSize: u32,
-  perception: f32, maxSpeed: f32, wSep: f32, wAli: f32, wCoh: f32,
-  dt: f32, worldHalf: f32, _p: f32,
-};
-// \u7EDF\u4E00\u7ED1\u5B9A\u5E03\u5C40(\u6A21\u5757\u7EA7\u552F\u4E00\u58F0\u660E,\u56DB\u4E2A\u5165\u53E3\u6309\u9700\u5F15\u7528):
-// 0 uniform | 1 posIn | 2 cellCount(atomic) | 3 cellStart | 4 cellFill(atomic)
-// 5 order   | 6 velIn | 7 posOut | 8 velOut
-@group(0) @binding(0) var<uniform> params: Params;
-@group(0) @binding(1) var<storage, read> posIn: array<vec2f>;
-@group(0) @binding(2) var<storage, read_write> cellCount: array<atomic<u32>>;
-@group(0) @binding(3) var<storage, read_write> cellStart: array<u32>;
-@group(0) @binding(4) var<storage, read_write> cellFill: array<atomic<u32>>;
-@group(0) @binding(5) var<storage, read_write> order: array<u32>;
-@group(0) @binding(6) var<storage, read> velIn: array<vec2f>;
-@group(0) @binding(7) var<storage, read_write> posOut: array<vec2f>;
-@group(0) @binding(8) var<storage, read_write> velOut: array<vec2f>;
-
-fn cellOf(p: vec2f) -> u32 {
-  let g = i32(params.gridSize);
-  let span = params.worldHalf * 2.0;
-  let cx = clamp(i32(floor((p.x + params.worldHalf) / span * f32(g))), 0, g - 1);
-  let cy = clamp(i32(floor((p.y + params.worldHalf) / span * f32(g))), 0, g - 1);
-  return u32(cy) * u32(g) + u32(cx);
-}
-
-@compute @workgroup_size(${WG})
-fn main_counts(@builtin(global_invocation_id) gid: vec3u) {
-  let i = gid.x;
-  if (i >= params.count) { return; }
-  atomicAdd(&cellCount[cellOf(posIn[i])], 1u);
-}
-
-var<workgroup> partial: array<u32, 256>;
-@compute @workgroup_size(256)
-fn main_scan(@builtin(local_invocation_id) lid: vec3u) {
-  let tid = lid.x;
-  let cells = params.gridSize * params.gridSize;
-  let chunks = (cells + 255u) / 256u;
-  var local = 0u;
-  for (var c = 0u; c < chunks; c++) {
-    let idx = c * 256u + tid;
-    if (idx < cells) { local = local + atomicLoad(&cellCount[idx]); }
-  }
-  partial[tid] = local;
-  workgroupBarrier();
-  var offset = 1u;
-  loop {
-    if (offset >= 256u) { break; }
-    var v = 0u;
-    if (tid >= offset) { v = partial[tid - offset]; }
-    workgroupBarrier();
-    if (tid >= offset) { partial[tid] = partial[tid] + v; }
-    workgroupBarrier();
-    offset = offset << 1u;
-  }
-  var run = 0u;
-  if (tid > 0u) { run = partial[tid - 1u]; }
-  for (var c = 0u; c < chunks; c++) {
-    let idx = c * 256u + tid;
-    if (idx < cells) {
-      cellStart[idx] = run;
-      atomicStore(&cellFill[idx], run);
-      run = run + atomicLoad(&cellCount[idx]);
-      atomicStore(&cellCount[idx], 0u);
-    }
-  }
-}
-
-@compute @workgroup_size(${WG})
-fn main_scatter(@builtin(global_invocation_id) gid: vec3u) {
-  let i = gid.x;
-  if (i >= params.count) { return; }
-  let slot = atomicAdd(&cellFill[cellOf(posIn[i])], 1u);
-  order[slot] = i;
-}
-
-@compute @workgroup_size(${WG})
-fn main_force(@builtin(global_invocation_id) gid: vec3u) {
-  let i = gid.x;
-  if (i >= params.count) { return; }
-  let myPos = posIn[i];
-  let myVel = velIn[i];
-  var sep = vec2f(0.0);
-  var ali = vec2f(0.0);
-  var coh = vec2f(0.0);
-  var n = 0u;
-  let g = i32(params.gridSize);
-  let cellSize = params.worldHalf * 2.0 / f32(g);
-  var cx = clamp(i32(floor((myPos.x + params.worldHalf) / cellSize)), 0, g - 1);
-  var cy = clamp(i32(floor((myPos.y + params.worldHalf) / cellSize)), 0, g - 1);
-  let p2 = params.perception * params.perception;
-
-  for (var dy = -1; dy <= 1; dy++) {
-    for (var dx = -1; dx <= 1; dx++) {
-      let nx = cx + dx;
-      let ny = cy + dy;
-      if (nx < 0 || ny < 0 || nx >= g || ny >= g) { continue; }
-      let c = u32(ny) * u32(g) + u32(nx);
-      let s = cellStart[c];
-      let e = atomicLoad(&cellFill[c]);
-      for (var k = s; k < e; k++) {
-        let j = order[k];
-        if (j == i) { continue; }
-        let rel = posIn[j] - myPos;
-        let d2 = dot(rel, rel);
-        if (d2 > p2) { continue; }
-        let d = sqrt(d2) + 1e-5;
-        sep = sep + (myPos - posIn[j]) / d;
-        ali = ali + velIn[j];
-        coh = coh + posIn[j];
-        n = n + 1u;
-      }
-    }
-  }
-
-  var vel = myVel;
-  if (n > 0u) {
-    let nf = f32(n);
-    ali = ali / nf;
-    coh = coh / nf - myPos;
-    vel = myVel + (sep * params.wSep + ali * params.wAli + coh * params.wCoh) * 0.016;
-  }
-  let sp = length(vel);
-  if (sp > params.maxSpeed) { vel = vel / sp * params.maxSpeed; }
-  if (sp < params.maxSpeed * 0.35) { vel = vel / max(sp, 1e-5) * params.maxSpeed * 0.35; }
-
-  var pos = myPos + vel;
-  let h = params.worldHalf;
-  pos = ((pos + h) % (2.0 * h) + 2.0 * h) % (2.0 * h) - h;
-  posOut[i] = pos;
-  velOut[i] = vel;
-}
-
-// ---- \u6E32\u67D3:\u671D\u5411\u901F\u5EA6\u65B9\u5411\u7684\u4E09\u89D2 ----
-struct VsOut {
-  @builtin(position) clip: vec4f,
-  @location(0) color: vec3f,
-};
-
-@vertex
-fn vs(@builtin(vertex_index) v: u32, @builtin(instance_index) inst: u32) -> VsOut {
-  var shape = array<vec2f, 3>(vec2f(${(pointSize * 1.6).toFixed(4)}, 0.0), vec2f(${(-pointSize).toFixed(4)}, ${(pointSize * 0.45).toFixed(4)}), vec2f(${(-pointSize).toFixed(4)}, ${(-pointSize * 0.45).toFixed(4)}));
-  let a = atan2(velIn[inst].y, velIn[inst].x);
-  let c = cos(a);
-  let s = sin(a);
-  let l = shape[v];
-  var out: VsOut;
-  out.clip = vec4f(posIn[inst] + vec2f(l.x * c - l.y * s, l.x * s + l.y * c), 0.0, 1.0);
-  let sp = length(velIn[inst]) / params.maxSpeed;
-  out.color = mix(vec3f(0.12, 0.2, 0.45), vec3f(0.4, 0.9, 1.0), clamp(sp, 0.0, 1.0));
-  return out;
-}
-
-@fragment
-fn fs(in: VsOut) -> @location(0) vec4f {
-  return vec4f(in.color, 1.0);
-}
-`
-  );
-}
-function hashStr3(s) {
-  let h = 2166136261;
-  for (let i = 0; i < s.length; i++) {
-    h ^= s.charCodeAt(i);
-    h = Math.imul(h, 16777619);
-  }
-  return h >>> 0;
-}
-
-// src/packs/life/tentacles.ts
-var USIZE2 = 32;
-async function tentacles(config = {}) {
-  const {
-    chains = 48,
-    segments = 64,
-    segLen = 0.018,
-    gravity = 35e-5,
-    damping = 0.985,
-    iterations = 10,
-    thickness = 6e-3,
-    colorCycle = 0.35
-  } = config;
-  const N = chains * segments;
-  const ctx = await GpuContext.get();
-  const device = ctx.device;
-  const pp = await PingPong.create({ pos: "vec2f" }, N);
-  const prev = await Buffer.create("vec2f", N);
-  {
-    const p = new Float32Array(N * 2);
-    pp.current.pos.write(p);
-    prev.write(p);
-  }
-  const uniform = device.createBuffer({ size: USIZE2, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
-  let time = 0;
-  const writeUniform = () => {
-    const b = new ArrayBuffer(USIZE2);
-    const v = new DataView(b);
-    v.setUint32(0, N, true);
-    v.setUint32(4, segments, true);
-    v.setFloat32(8, segLen, true);
-    v.setFloat32(12, gravity, true);
-    v.setFloat32(16, damping, true);
-    v.setFloat32(20, time, true);
-    v.setFloat32(24, 0.45, true);
-    v.setUint32(28, iterations, true);
-    device.queue.writeBuffer(uniform, 0, b);
-  };
-  const module = device.createShaderModule({ code: tentaclesWgsl(thickness, colorCycle), label: "tentacles" });
-  const info = await module.getCompilationInfo();
-  const errors = info.messages.filter((m) => m.type === "error");
-  if (errors.length > 0) throw new CompileError("tentacles", errors.map((m) => ({ line: m.lineNum, msg: m.message })), 0);
-  const pIntegrate = device.createComputePipeline({ layout: "auto", compute: { module, entryPoint: "main_integrate" } });
-  const pConstraint = device.createComputePipeline({ layout: "auto", compute: { module, entryPoint: "main_constraint" } });
-  const pRender = device.createRenderPipeline({
-    layout: "auto",
-    vertex: { module, entryPoint: "vs" },
-    fragment: { module, entryPoint: "fs", targets: [{ format: navigator.gpu.getPreferredCanvasFormat() }] },
-    primitive: { topology: "triangle-list" }
-  });
-  const bgIntegrate = (read, write) => device.createBindGroup({
-    layout: pIntegrate.getBindGroupLayout(0),
-    entries: [
-      { binding: 0, resource: { buffer: uniform } },
-      { binding: 1, resource: { buffer: read.gpuBuffer } },
-      { binding: 2, resource: { buffer: prev.gpuBuffer } },
-      { binding: 3, resource: { buffer: write.gpuBuffer } }
-    ]
-  });
-  const bgConstraint = (read, write) => device.createBindGroup({
-    layout: pConstraint.getBindGroupLayout(0),
-    entries: [
-      { binding: 0, resource: { buffer: uniform } },
-      { binding: 1, resource: { buffer: read.gpuBuffer } },
-      { binding: 2, resource: { buffer: write.gpuBuffer } }
-    ]
-  });
-  const bgRenderCache = /* @__PURE__ */ new Map();
-  const ids = /* @__PURE__ */ new WeakMap();
-  const bgRender = (pos) => {
-    let id = ids.get(pos.gpuBuffer);
-    if (id === void 0) {
-      id = bgRenderCache.size + 1;
-      ids.set(pos.gpuBuffer, id);
-    }
-    let bg = bgRenderCache.get(id);
-    if (!bg) {
-      bg = device.createBindGroup({
-        layout: pRender.getBindGroupLayout(0),
-        entries: [
-          { binding: 0, resource: { buffer: uniform } },
-          { binding: 1, resource: { buffer: pos.gpuBuffer } }
-        ]
-      });
-      bgRenderCache.set(id, bg);
-    }
-    return bg;
-  };
-  let gpuCtx = null;
-  let frame = 0;
-  let lastFps = 0;
-  let fFrames = 0;
-  let fAcc = 0;
-  let fLast = performance.now();
-  return {
-    async attach(canvas) {
-      const dpr = Math.min(window.devicePixelRatio || 1, 2);
-      canvas.width = Math.max(1, Math.floor(canvas.clientWidth * dpr));
-      canvas.height = Math.max(1, Math.floor(canvas.clientHeight * dpr));
-      const c = canvas.getContext("webgpu");
-      if (!c) throw new Error('canvas.getContext("webgpu") \u8FD4\u56DE\u7A7A');
-      c.configure({ device, format: navigator.gpu.getPreferredCanvasFormat(), alphaMode: "opaque" });
-      gpuCtx = c;
-    },
-    tick() {
-      time += 1 / 60;
-      writeUniform();
-      const enc = device.createCommandEncoder();
-      const pass = enc.beginComputePass();
-      pass.setPipeline(pIntegrate);
-      pass.setBindGroup(0, bgIntegrate(pp.current.pos, pp.other.pos));
-      pass.dispatchWorkgroups(Math.ceil(N / 64));
-      pass.end();
-      device.queue.submit([enc.finish()]);
-      pp.swap();
-      const enc22 = device.createCommandEncoder();
-      const pass2 = enc22.beginComputePass();
-      pass2.setPipeline(pConstraint);
-      for (let r = 0; r < iterations; r++) {
-        pass2.setBindGroup(0, bgConstraint(pp.current.pos, pp.other.pos));
-        pass2.dispatchWorkgroups(Math.ceil(N / 64));
-        pp.swap();
-      }
-      pass2.end();
-      device.queue.submit([enc22.finish()]);
-      if (gpuCtx) {
-        const re = device.createCommandEncoder();
-        const rp = re.beginRenderPass({
-          colorAttachments: [{
-            view: gpuCtx.getCurrentTexture().createView(),
-            clearValue: { r: 0.012, g: 0.016, b: 0.03, a: 1 },
-            loadOp: "clear",
-            storeOp: "store"
-          }]
-        });
-        rp.setPipeline(pRender);
-        rp.setBindGroup(0, bgRender(pp.current.pos));
-        rp.draw(6, N);
-        rp.end();
-        device.queue.submit([re.finish()]);
-      }
-      frame++;
-      fFrames++;
-      const now = performance.now();
-      fAcc += now - fLast;
-      fLast = now;
-      if (fAcc >= 500) {
-        lastFps = fFrames / (fAcc / 1e3);
-        fFrames = 0;
-        fAcc = 0;
-      }
-    },
-    stats() {
-      return { fps: lastFps };
-    },
-    buffers() {
-      return { pos: pp.current.pos };
-    },
-    destroy() {
-      pp.destroy();
-      prev.destroy();
-      uniform.destroy();
-    }
-  };
-}
-function tentaclesWgsl(thickness, colorCycle) {
-  return (
-    /* wgsl */
-    `
-struct Params {
-  count: u32, segments: u32,
-  segLen: f32, gravity: f32, damping: f32, time: f32,
-  anchorR: f32, iterations: u32,
-};
-@group(0) @binding(0) var<uniform> params: Params;
-@group(0) @binding(1) var<storage, read> posIn: array<vec2f>;
-@group(0) @binding(2) var<storage, read_write> posOut: array<vec2f>;
-@group(0) @binding(3) var<storage, read_write> prev: array<vec2f>;
-
-fn anchorPos(chain: u32, t: f32) -> vec2f {
-  let phase = f32(chain) * 2.399963; // \u9EC4\u91D1\u89D2:\u94FE\u4E0E\u94FE\u6C38\u4E0D\u91CD\u53E0\u6392\u5E03
-  let x = cos(t * 0.7 + phase) * params.anchorR;
-  let y = sin(t * 1.13 + phase * 1.7) * params.anchorR * 0.55;
-  return vec2f(x, y);
-}
-
-@compute @workgroup_size(64)
-fn main_integrate(@builtin(global_invocation_id) gid: vec3u) {
-  let i = gid.x;
-  if (i >= params.count) { return; }
-  let segs = params.segments;
-  let k = i % segs;
-  let chain = i / segs;
-  if (k == 0u) {
-    let anchor = anchorPos(chain, params.time);
-    posOut[i] = anchor;
-    prev[i] = anchor;
-    return;
-  }
-  let vel = (posIn[i] - prev[i]) * params.damping;
-  prev[i] = posIn[i];
-  posOut[i] = posIn[i] + vel + vec2f(0.0, -params.gravity);
-}
-
-// \u8DDF\u968F\u7EA6\u675F:\u8BFB posIn \u5199 posOut(\u5355\u7EBF\u7A0B\u5355\u6570\u636E,\u96F6\u7ADE\u6001)
-@compute @workgroup_size(64)
-fn main_constraint(@builtin(global_invocation_id) gid: vec3u) {
-  let i = gid.x;
-  if (i >= params.count) { return; }
-  let segs = params.segments;
-  let k = i % segs;
-  if (k == 0u) { posOut[i] = posIn[i]; return; }
-  let d = posIn[i] - posIn[i - 1u];
-  let l = length(d) + 1e-6;
-  posOut[i] = posIn[i - 1u] + d / l * params.segLen;
-}
-
-struct VsOut {
-  @builtin(position) clip: vec4f,
-  @location(0) color: vec3f,
-};
-@group(0) @binding(0) var<uniform> vp: Params;
-@group(0) @binding(1) var<storage, read> posR: array<vec2f>;
-
-@vertex
-fn vs(@builtin(vertex_index) v: u32, @builtin(instance_index) inst: u32) -> VsOut {
-  let segs = vp.segments;
-  let k = inst % segs;
-  let chain = inst / segs;
-  let taper = 1.0 - f32(k) / f32(segs);
-  let r = ${(thickness * 1.1).toFixed(5)} * (0.25 + 0.75 * taper);
-  var corner = array<vec2f, 6>(
-    vec2f(-r, -r), vec2f(r, -r), vec2f(-r, r),
-    vec2f(-r, r), vec2f(r, -r), vec2f(r, r)
-  );
-  var out: VsOut;
-  out.clip = vec4f(posR[inst] + corner[v], 0.0, 1.0);
-  out.color = 0.5 + 0.5 * cos(f32(chain) * ${colorCycle.toFixed(3)} + vec3f(0.0, 2.1, 4.2)) * (0.4 + 0.6 * taper);
-  return out;
-}
-
-@fragment
-fn fs(in: VsOut) -> @location(0) vec4f {
-  return vec4f(in.color, 1.0);
-}
-`
-  );
-}
-export {
-  boids,
-  physarum,
-  tentacles,
-  turing
-};