@beeintel/batch-image 0.0.0-stage → 1.0.0

package/dist/chunks/gpu-CScw5MNG.js

@@ -0,0 +1,231 @@
+class n extends Error {
+  constructor(r) {
+    super(`Material GPU: ${r}`), this.reason = r, this.name = "MaterialGpuError";
+  }
+}
+const q = (
+  /* wgsl */
+  `
+struct Params {
+  size: vec2f, radius: f32, dark: f32,
+  refraction: f32, edgeWidth: f32, transmission: f32, blur: f32,
+  highlight: f32, uvOrigin: vec2f, uvSize: vec2f,
+  meanLuminance: f32, localLuminance: f32, edgeDensity: f32, textDensity: f32,
+  pointer: vec2f, pointerStrength: f32, pressStrength: f32
+}
+@group(0) @binding(0) var image: texture_2d<f32>;
+@group(0) @binding(1) var imageSampler: sampler;
+@group(0) @binding(2) var<uniform> params: Params;
+struct Vertex { @builtin(position) position: vec4f, @location(0) uv: vec2f }
+@vertex fn vertex(@builtin(vertex_index) index: u32) -> Vertex {
+  let positions = array<vec2f, 3>(vec2f(-1., -1.), vec2f(3., -1.), vec2f(-1., 3.));
+  let p = positions[index];
+  var result: Vertex;
+  result.position = vec4f(p, 0., 1.);
+  result.uv = vec2f((p.x + 1.) * .5, (1. - p.y) * .5);
+  return result;
+}
+@fragment fn fragment(input: Vertex) -> @location(0) vec4f {
+  let halfSize = params.size * .5;
+  let p = (input.uv - .5) * params.size;
+  let radius = min(params.radius, min(halfSize.x, halfSize.y));
+  let q = abs(p) - halfSize + radius;
+  let distance = length(max(q, vec2f(0.))) + min(max(q.x, q.y), 0.) - radius;
+  let edge = 1. - smoothstep(0., params.edgeWidth, -distance);
+  let normal = normalize(p / max(halfSize, vec2f(1.)) + vec2f(.0001));
+  let pointerDelta = input.uv - params.pointer;
+  let pointerGlow = exp(-dot(pointerDelta, pointerDelta) * 18.) * params.pointerStrength;
+  let bend = edge * params.refraction / max(params.size, vec2f(1.));
+  let uv = clamp(params.uvOrigin + input.uv * params.uvSize - normal * bend + pointerDelta * pointerGlow * .02, vec2f(0.), vec2f(1.));
+  let offset = params.blur / max(params.size, vec2f(1.));
+  var sampleColor = textureSampleLevel(image, imageSampler, uv, 0.).rgb * .25;
+  sampleColor += textureSampleLevel(image, imageSampler, uv + vec2f(offset.x, 0.), 0.).rgb * .125;
+  sampleColor += textureSampleLevel(image, imageSampler, uv - vec2f(offset.x, 0.), 0.).rgb * .125;
+  sampleColor += textureSampleLevel(image, imageSampler, uv + vec2f(0., offset.y), 0.).rgb * .125;
+  sampleColor += textureSampleLevel(image, imageSampler, uv - vec2f(0., offset.y), 0.).rgb * .125;
+  let tint = mix(vec3f(.96, .97, .99), vec3f(.035, .042, .055), params.dark);
+  let localDim = clamp((.52 - params.localLuminance) * .12 + params.edgeDensity * .04, -.04, .08);
+  let color = clamp(mix(tint, sampleColor, params.transmission) + localDim, vec3f(0.), vec3f(1.));
+  let highlight = pow(edge, 3.) * params.highlight * mix(1., .45, params.dark) * (.65 - normal.y * .35) + pointerGlow * .08 + params.pressStrength * edge * .05;
+  let alpha = 1. - smoothstep(-1., 0., distance);
+  return vec4f((color + highlight) * alpha, alpha);
+}
+`
+);
+function B(i) {
+  const r = i.params ?? i.material, p = i.sceneUV ?? { x: 0, y: 0, width: 1, height: 1 }, o = i.environment, t = o?.pointer;
+  return new Float32Array([
+    i.cssWidth,
+    i.cssHeight,
+    i.radiusCssPx,
+    Number(i.dark),
+    r.refractionCssPx,
+    r.edgeWidthCssPx,
+    r.transmission,
+    r.blurCssPx,
+    r.highlight,
+    0,
+    p.x,
+    p.y,
+    p.width,
+    p.height,
+    o?.meanLuminance ?? 0.5,
+    o?.localLuminance ?? 0.5,
+    o?.edgeDensity ?? 0,
+    o?.textDensity ?? 0,
+    t?.x ?? 0.5,
+    t?.y ?? 0.5,
+    t?.strength ?? 0,
+    o?.pressStrength ?? 0,
+    0,
+    0
+  ]);
+}
+async function F(i, r) {
+  if (typeof navigator > "u" || !navigator.gpu) throw new n("unsupported");
+  const p = navigator.gpu;
+  let o;
+  try {
+    o = r === "no-adapter" ? null : await p.requestAdapter({ powerPreference: "low-power" });
+  } catch {
+    throw new n("no-adapter");
+  }
+  if (!o) throw new n("no-adapter");
+  let t;
+  try {
+    if (r === "no-device") throw new n("no-device");
+    t = await o.requestDevice();
+  } catch {
+    throw new n("no-device");
+  }
+  let h = !0, y = "device-lost";
+  const d = /* @__PURE__ */ new Map(), f = /* @__PURE__ */ new Set();
+  let S, s;
+  const b = () => {
+    if (h) {
+      h = !1, t.removeEventListener("uncapturederror", E), s && (s.destroy(), f.delete(s)), s = void 0, S = void 0;
+      for (const e of f) e.destroy();
+      f.clear();
+      for (const e of d.values()) e.unconfigure();
+      d.clear(), t.destroy();
+    }
+  }, D = (e) => {
+    h && (y = e, b(), i(e));
+  }, E = () => D("render-failed");
+  t.addEventListener("uncapturederror", E), t.lost.then(() => D("device-lost"));
+  const v = () => {
+    if (!h) throw new n(y);
+  }, C = p.getPreferredCanvasFormat();
+  let P;
+  t.pushErrorScope("validation");
+  let G = !0;
+  try {
+    const e = t.createShaderModule({
+      code: r === "compile-failed" ? "invalid WGSL" : q
+    });
+    if (P = await t.createRenderPipelineAsync({
+      layout: "auto",
+      vertex: { module: e, entryPoint: "vertex" },
+      fragment: { module: e, entryPoint: "fragment", targets: [{ format: C }] },
+      primitive: { topology: "triangle-list" }
+    }), G = !1, await t.popErrorScope()) throw new n("compile-failed");
+    v();
+  } catch {
+    G && await t.popErrorScope().catch(() => {
+    });
+    const e = h ? "compile-failed" : y;
+    throw b(), new n(e);
+  }
+  const M = t.createSampler({
+    minFilter: "linear",
+    magFilter: "linear"
+  });
+  let T = Promise.resolve();
+  const L = (e) => {
+    if (v(), S === e && s) return s;
+    if (s && (s.destroy(), f.delete(s)), S = e, !e.width || !e.height || e.width > t.limits.maxTextureDimension2D || e.height > t.limits.maxTextureDimension2D)
+      throw new n("render-failed");
+    const l = t.createTexture({
+      size: [e.width, e.height],
+      format: "rgba8unorm",
+      usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT
+    });
+    return s = l, f.add(l), t.queue.copyExternalImageToTexture({ source: e }, { texture: l }, [
+      e.width,
+      e.height
+    ]), l;
+  }, U = async (e, l, a) => {
+    if (v(), !Number.isFinite(a.cssWidth) || a.cssWidth <= 0 || !Number.isFinite(a.cssHeight) || a.cssHeight <= 0 || !Number.isFinite(a.radiusCssPx) || a.radiusCssPx < 0)
+      throw new n("render-failed");
+    let u = d.get(e);
+    if (!u) {
+      if (d.size >= 4) return { kind: "local-fallback", reason: "context-budget" };
+      const c = e.getContext("webgpu");
+      if (!c) return { kind: "local-fallback", reason: "context-unavailable" };
+      u = c, d.set(e, u);
+    }
+    let m, x;
+    t.pushErrorScope("out-of-memory"), t.pushErrorScope("internal"), t.pushErrorScope("validation");
+    try {
+      const c = L(l), g = Math.max(1, typeof devicePixelRatio == "number" ? devicePixelRatio : 1);
+      e.width = Math.max(1, Math.round(a.cssWidth * g)), e.height = Math.max(1, Math.round(a.cssHeight * g)), u.configure({ device: t, format: C, alphaMode: "premultiplied" }), m = t.createBuffer({
+        size: 96,
+        usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+      }), f.add(m), t.queue.writeBuffer(m, 0, B(a));
+      const k = t.createBindGroup({
+        layout: P.getBindGroupLayout(0),
+        entries: [
+          { binding: 0, resource: c.createView() },
+          { binding: 1, resource: M },
+          { binding: 2, resource: { buffer: m } }
+        ]
+      }), z = t.createCommandEncoder(), w = z.beginRenderPass({
+        colorAttachments: [
+          {
+            view: u.getCurrentTexture().createView(),
+            clearValue: { r: 0, g: 0, b: 0, a: 0 },
+            loadOp: "clear",
+            storeOp: "store"
+          }
+        ]
+      });
+      w.setPipeline(P), w.setBindGroup(0, k), w.draw(3), w.end(), t.queue.submit([z.finish()]), await t.queue.onSubmittedWorkDone();
+    } catch (c) {
+      x = c;
+    } finally {
+      for (let c = 0; c < 3; c++)
+        try {
+          const g = await t.popErrorScope();
+          g && (x = g);
+        } catch (g) {
+          x = g;
+        }
+      m && (m.destroy(), f.delete(m));
+    }
+    if (v(), x) throw new n("render-failed");
+    return { kind: "painted" };
+  };
+  return {
+    paint(e, l, a) {
+      const u = T.then(() => U(e, l, a));
+      return T = u.then(
+        () => {
+        },
+        () => {
+        }
+      ), u;
+    },
+    release(e) {
+      d.get(e)?.unconfigure(), d.delete(e);
+    },
+    loseDevice() {
+      h && t.destroy();
+    },
+    dispose: b
+  };
+}
+export {
+  n as MaterialGpuError,
+  F as createGpuMaterialSession,
+  B as packMaterialFrame
+};