insomni 0.2.0-alpha.0

package/dist/pipeline-BWCAZTKx.mjs

@@ -0,0 +1,470 @@
+import tgpu, { d } from "typegpu";
+//#region src/core/context.ts
+const DEPTH_FORMAT = "depth24plus";
+function safeSize(width, height) {
+	return [Math.max(width, 1), Math.max(height, 1)];
+}
+function createBackbuffer(root, width, height, format) {
+	const texture = root.device.createTexture({
+		label: "insomni-backbuffer",
+		size: safeSize(width, height),
+		format,
+		sampleCount: 1,
+		usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC
+	});
+	return {
+		texture,
+		view: texture.createView()
+	};
+}
+function createDepth(root, width, height, sampleCount) {
+	const depthTexture = root.device.createTexture({
+		label: "insomni-depth",
+		size: safeSize(width, height),
+		format: DEPTH_FORMAT,
+		sampleCount,
+		usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING
+	});
+	return {
+		depthTexture,
+		depthView: depthTexture.createView()
+	};
+}
+function createMsaaColor(root, width, height, format, sampleCount) {
+	if (sampleCount <= 1) return null;
+	const texture = root.device.createTexture({
+		label: "insomni-color-msaa",
+		size: safeSize(width, height),
+		format,
+		sampleCount,
+		usage: GPUTextureUsage.RENDER_ATTACHMENT
+	});
+	return {
+		texture,
+		view: texture.createView()
+	};
+}
+function createCanvasContext(root, canvas, sampleCount = 1, persistent = false) {
+	const format = navigator.gpu.getPreferredCanvasFormat();
+	const gpuContext = root.configureContext({
+		canvas,
+		format,
+		alphaMode: "premultiplied",
+		...persistent ? { usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_DST } : {}
+	});
+	const depth = createDepth(root, canvas.width, canvas.height, sampleCount);
+	const msaa = createMsaaColor(root, canvas.width, canvas.height, format, sampleCount);
+	const back = persistent ? createBackbuffer(root, canvas.width, canvas.height, format) : null;
+	return {
+		canvas,
+		gpuContext,
+		format,
+		width: canvas.width,
+		height: canvas.height,
+		sampleCount,
+		colorTexture: msaa?.texture ?? null,
+		colorView: msaa?.view ?? null,
+		depthTexture: depth.depthTexture,
+		depthView: depth.depthView,
+		persistent,
+		backbuffer: back?.texture ?? null,
+		backbufferView: back?.view ?? null
+	};
+}
+function resizeCanvas(ctx, root, width, height) {
+	const w = Math.max(0, Math.floor(width));
+	const h = Math.max(0, Math.floor(height));
+	ctx.canvas.width = w;
+	ctx.canvas.height = h;
+	ctx.width = w;
+	ctx.height = h;
+	ctx.depthTexture.destroy();
+	const depth = createDepth(root, width, height, ctx.sampleCount);
+	ctx.depthTexture = depth.depthTexture;
+	ctx.depthView = depth.depthView;
+	if (ctx.colorTexture) ctx.colorTexture.destroy();
+	const msaa = createMsaaColor(root, width, height, ctx.format, ctx.sampleCount);
+	ctx.colorTexture = msaa?.texture ?? null;
+	ctx.colorView = msaa?.view ?? null;
+	if (ctx.persistent) {
+		if (ctx.backbuffer) ctx.backbuffer.destroy();
+		const back = createBackbuffer(root, width, height, ctx.format);
+		ctx.backbuffer = back.texture;
+		ctx.backbufferView = back.view;
+	}
+}
+//#endregion
+//#region src/math/scalar.ts
+const TAU = Math.PI * 2;
+const PI = Math.PI;
+const HALF_PI = Math.PI / 2;
+const DEG_TO_RAD = Math.PI / 180;
+const RAD_TO_DEG = 180 / Math.PI;
+function clamp(value, min, max) {
+	return value < min ? min : value > max ? max : value;
+}
+function clamp01(value) {
+	return value < 0 ? 0 : value > 1 ? 1 : value;
+}
+function lerp(a, b, t) {
+	return a + (b - a) * t;
+}
+/** Inverse of `lerp`: where does `value` sit between `a` and `b`? */
+function inverseLerp(a, b, value) {
+	return a === b ? 0 : (value - a) / (b - a);
+}
+/** Map `value` from `[a0, a1]` to `[b0, b1]` (unclamped). */
+function remap(value, a0, a1, b0, b1) {
+	return b0 + (value - a0) * (b1 - b0) / (a1 - a0);
+}
+/** Hermite smoothstep. `t` is clamped to `[edge0, edge1]`. */
+function smoothstep(edge0, edge1, value) {
+	const t = clamp01((value - edge0) / (edge1 - edge0));
+	return t * t * (3 - 2 * t);
+}
+/** Ken Perlin's 5th-order smoothstep — zero 1st & 2nd derivatives at edges. */
+function smootherstep(edge0, edge1, value) {
+	const t = clamp01((value - edge0) / (edge1 - edge0));
+	return t * t * t * (t * (t * 6 - 15) + 10);
+}
+function degToRad(deg) {
+	return deg * DEG_TO_RAD;
+}
+function radToDeg(rad) {
+	return rad * RAD_TO_DEG;
+}
+/** Wraps `value` into `[0, modulus)` (handles negatives, unlike `%`). */
+function wrap(value, modulus) {
+	return (value % modulus + modulus) % modulus;
+}
+function sign(value) {
+	return value < 0 ? -1 : value > 0 ? 1 : 0;
+}
+function approxEqual(a, b, epsilon = 1e-6) {
+	return Math.abs(a - b) <= epsilon;
+}
+//#endregion
+//#region src/shared/pipeline.ts
+const ALPHA_BLEND = {
+	color: {
+		srcFactor: "one",
+		dstFactor: "one-minus-src-alpha",
+		operation: "add"
+	},
+	alpha: {
+		srcFactor: "one",
+		dstFactor: "one-minus-src-alpha",
+		operation: "add"
+	}
+};
+const OPAQUE_ALPHA_THRESHOLD = .5;
+/**
+* Depth attachment uses `less` compare. Z is assigned in scene order — lower Z
+* is closer to the camera. Opaque shapes are drawn front-to-back (lowest Z
+* first) with depth write enabled; transparent shapes draw back-to-front with
+* depth write disabled but depth test still rejecting fragments occluded by
+* opaque content.
+*/
+const DEPTH_COMPARE = "less";
+const CameraSchema = d.struct({
+	vpCol0: d.vec2f,
+	vpCol1: d.vec2f,
+	vpCol2: d.vec2f,
+	viewport: d.vec2f,
+	dpr: d.f32,
+	_pad: d.f32
+});
+/**
+* Per-draw-call uniform supplying the Z slot range this draw occupies.
+* `baseZ` is the Z value for the shape whose `instance_index === firstInstance`;
+* subsequent instances step by `zStep`. Shader:
+*   z = baseZ + zStep * f32(instance_index - firstInstance)
+*/
+const DrawSchema = d.struct({
+	baseZ: d.f32,
+	zStep: d.f32,
+	firstInstance: d.u32,
+	_pad: d.u32
+});
+/**
+* Per-instance shape record. 32 B, bit-packed. Byte-identical to the CPU-side
+* layout in `pack.ts`:
+*   pos         @ 0   vec2f
+*   sizePacked  @ 8   u32  — `pack2x16float(sizeX, sizeY)`
+*   fillBits    @ 12  u32  — `pack4x8unorm(fill)`
+*   strokeBits  @ 16  u32
+*   rsPacked    @ 20  u32  — `pack2x16float(rotation, strokeWidth)`
+*   crPacked    @ 24  u32  — `pack2x16float(cornerRadius, _)`
+*   shapeType   @ 28  u32
+*
+* Shaders `unpack4x8unorm` / `unpack2x16float` on access.
+*/
+const ShapeSchema = d.struct({
+	pos: d.vec2f,
+	sizePacked: d.u32,
+	fillBits: d.u32,
+	strokeBits: d.u32,
+	rsPacked: d.u32,
+	crPacked: d.u32,
+	shapeType: d.u32
+});
+const TriangleSchema = d.struct({
+	p1: d.vec2f,
+	p2: d.vec2f,
+	p3: d.vec2f,
+	fill: d.vec4f
+});
+const CameraLayout = tgpu.bindGroupLayout({ camera: {
+	uniform: CameraSchema,
+	visibility: ["vertex"]
+} });
+const ShapeBufferLayout = tgpu.bindGroupLayout({ shapes: {
+	storage: d.arrayOf(ShapeSchema),
+	access: "readonly",
+	visibility: ["vertex", "fragment"]
+} });
+const TriangleBufferLayout = tgpu.bindGroupLayout({ triangles: {
+	storage: d.arrayOf(TriangleSchema),
+	access: "readonly",
+	visibility: ["vertex"]
+} });
+const DrawLayout = tgpu.bindGroupLayout({ draw: {
+	uniform: DrawSchema,
+	visibility: ["vertex"]
+} });
+CameraLayout.bound.camera;
+ShapeBufferLayout.bound.shapes;
+TriangleBufferLayout.bound.triangles;
+DrawLayout.bound.draw;
+tgpu.bindGroupLayout({ clearColor: {
+	uniform: d.vec4f,
+	visibility: ["fragment"]
+} }).bound.clearColor;
+tgpu.fn([d.vec2f, d.f32], d.vec2f)`(v, a) {
+  let c = cos(a);
+  let s = sin(a);
+  return vec2f(c * v.x - s * v.y, s * v.x + c * v.y);
+}`;
+tgpu.fn([
+	d.vec2f,
+	d.vec2f,
+	d.f32
+], d.f32)`(p, b, r) {
+  let q = abs(p) - b + r;
+  return length(max(q, vec2f(0.0))) + min(max(q.x, q.y), 0.0) - r;
+}`;
+tgpu.fn([d.vec2f, d.f32], d.f32)`(p, r) {
+  return length(p) - r;
+}`;
+tgpu.fn([d.vec2f, d.vec2f], d.f32)`(p, ab) {
+  let k1 = length(p / ab);
+  let k2 = length(p / (ab * ab));
+  return k1 * (k1 - 1.0) / k2;
+}`;
+const SpriteSchema = d.struct({
+	pos: d.vec2f,
+	size: d.vec2f,
+	uvMin: d.vec2f,
+	uvMax: d.vec2f,
+	tint: d.vec4f,
+	anchor: d.vec2f,
+	rotation: d.f32,
+	_pad: d.f32
+});
+const SpriteBufferLayout = tgpu.bindGroupLayout({ sprites: {
+	storage: d.arrayOf(SpriteSchema),
+	access: "readonly",
+	visibility: ["vertex"]
+} });
+const TextureSamplerLayout = tgpu.bindGroupLayout({
+	spriteTexture: {
+		texture: "float",
+		visibility: ["fragment"]
+	},
+	spriteSampler: {
+		sampler: "filtering",
+		visibility: ["fragment"]
+	}
+});
+SpriteBufferLayout.bound.sprites;
+TextureSamplerLayout.bound.spriteTexture;
+TextureSamplerLayout.bound.spriteSampler;
+/**
+* Per-instance segment record. 24 B:
+*   start: vec2f @ 0
+*   end:   vec2f @ 8
+*   color: u32   @ 16  (unorm8x4)
+*   width: f32   @ 20  (layer-local units)
+* Byte-identical to the CPU layout in `pack.ts` (`SEGMENT_FLOATS = 6`).
+*/
+const SegmentSchema = d.struct({
+	start: d.vec2f,
+	end: d.vec2f,
+	colorBits: d.u32,
+	width: d.f32
+});
+tgpu.bindGroupLayout({ segments: {
+	storage: d.arrayOf(SegmentSchema),
+	access: "readonly",
+	visibility: ["vertex", "fragment"]
+} }).bound.segments;
+/**
+* Per-instance curve record. 48 B, 16-B-aligned for storage buffer arrays:
+*   p0:           vec2f @ 0
+*   p1:           vec2f @ 8
+*   p2:           vec2f @ 16
+*   p3:           vec2f @ 24
+*   colorBits:    u32   @ 32  (unorm8x4)
+*   widthPacked:  u32   @ 36  (pack2x16float(widthStart, widthEnd))
+*   flagsBits:    u32   @ 40  (cap style in low 2 bits)
+*   _pad:         u32   @ 44
+* Byte-identical to the CPU layout in `pack.ts` (`CURVE_FLOATS = 12`).
+*/
+const CurveSchema = d.struct({
+	p0: d.vec2f,
+	p1: d.vec2f,
+	p2: d.vec2f,
+	p3: d.vec2f,
+	colorBits: d.u32,
+	widthPacked: d.u32,
+	flagsBits: d.u32,
+	_pad: d.u32
+});
+tgpu.bindGroupLayout({ curves: {
+	storage: d.arrayOf(CurveSchema),
+	access: "readonly",
+	visibility: ["vertex", "fragment"]
+} }).bound.curves;
+tgpu.fn([
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32
+], d.vec2f)`(c0, c1, c2, c3) {
+  var mn = min(c0, c3);
+  var mx = max(c0, c3);
+  let alpha = -c0 + 3.0 * c1 - 3.0 * c2 + c3;
+  let beta = c0 - 2.0 * c1 + c2;
+  let gamma = -c0 + c1;
+  if (abs(alpha) < 1e-6) {
+    if (abs(beta) > 1e-6) {
+      let t = -gamma / (2.0 * beta);
+      if (t > 0.0 && t < 1.0) {
+        let u = 1.0 - t;
+        let v = u * u * u * c0 + 3.0 * u * u * t * c1 + 3.0 * u * t * t * c2 + t * t * t * c3;
+        mn = min(mn, v);
+        mx = max(mx, v);
+      }
+    }
+  } else {
+    let disc = beta * beta - alpha * gamma;
+    if (disc >= 0.0) {
+      let s = sqrt(disc);
+      let t1 = (-beta + s) / alpha;
+      if (t1 > 0.0 && t1 < 1.0) {
+        let u = 1.0 - t1;
+        let v = u * u * u * c0 + 3.0 * u * u * t1 * c1 + 3.0 * u * t1 * t1 * c2 + t1 * t1 * t1 * c3;
+        mn = min(mn, v);
+        mx = max(mx, v);
+      }
+      let t2 = (-beta - s) / alpha;
+      if (t2 > 0.0 && t2 < 1.0) {
+        let u = 1.0 - t2;
+        let v = u * u * u * c0 + 3.0 * u * u * t2 * c1 + 3.0 * u * t2 * t2 * c2 + t2 * t2 * t2 * c3;
+        mn = min(mn, v);
+        mx = max(mx, v);
+      }
+    }
+  }
+  return vec2f(mn, mx);
+}`;
+/**
+* Per-instance arc record. 32 B (16-B aligned for storage struct arrays):
+*   center:     vec2f @ 0
+*   radius:     f32   @ 8
+*   theta0:     f32   @ 12   start angle (radians)
+*   theta1:     f32   @ 16   end angle (radians)
+*   width:      f32   @ 20   stroke thickness (layer-local units)
+*   colorBits:  u32   @ 24   unorm8x4 RGBA, unpremultiplied
+*   _pad:       u32   @ 28
+*
+* Arc is the short path from `theta0` to `theta1`; direction is irrelevant
+* to the rendered geometry. CPU normalises so the absolute span is ≤ 2π;
+* spans ≥ 2π render as a full ring. Caps are butt (perpendicular at each
+* endpoint).
+*/
+const ArcSchema = d.struct({
+	center: d.vec2f,
+	radius: d.f32,
+	theta0: d.f32,
+	theta1: d.f32,
+	width: d.f32,
+	colorBits: d.u32,
+	_pad: d.u32
+});
+tgpu.bindGroupLayout({ arcs: {
+	storage: d.arrayOf(ArcSchema),
+	access: "readonly",
+	visibility: ["vertex", "fragment"]
+} }).bound.arcs;
+tgpu.fn([
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32
+], d.vec4f)`(r, halfAng, halfW, pad) {
+  let outer = r + halfW + pad;
+  let innerRaw = r - halfW - pad;
+  let inner = select(0.0, innerRaw, innerRaw > 0.0);
+  let ch = cos(halfAng);
+  let sh = sin(halfAng);
+  // +X axis (angle 0) is always inside the wedge → x_max = outer.
+  let xMax = outer;
+  var xMin: f32;
+  var yMax: f32;
+  var yMin: f32;
+  let PI = 3.141592653589793;
+  let HALF_PI = 1.5707963267948966;
+  if (halfAng >= PI) {
+    xMin = -outer;
+    yMax = outer;
+    yMin = -outer;
+  } else if (halfAng >= HALF_PI) {
+    // Wedge crosses ±π/2 → y reaches ±outer; x_min at the wedge boundary.
+    yMax = outer;
+    yMin = -outer;
+    xMin = outer * ch;
+  } else {
+    // Narrow wedge: y extrema come from the outer-ring endpoints; x_min
+    // comes from the inner-ring endpoints.
+    yMax = outer * sh;
+    yMin = -yMax;
+    xMin = inner * ch;
+  }
+  return vec4f(xMin, yMin, xMax, yMax);
+}`;
+tgpu.fn([
+	d.vec2f,
+	d.f32,
+	d.f32,
+	d.f32
+], d.f32)`(p, r, mid, halfAng) {
+  let c = cos(mid);
+  let s = sin(mid);
+  // Rotate by -mid so the arc spans [-halfAng, halfAng] around +X.
+  let q = vec2f(c * p.x + s * p.y, -s * p.x + c * p.y);
+  // Reflect to upper half — the arc is symmetric in y.
+  let qa = vec2f(q.x, abs(q.y));
+  let ch = cos(halfAng);
+  let sh = sin(halfAng);
+  // qa is outside the wedge (angle > halfAng) iff cross > 0.
+  let cross = ch * qa.y - sh * qa.x;
+  if (cross <= 0.0) {
+    return abs(length(qa) - r);
+  }
+  // Outside the wedge: nearest point on the arc is the upper endpoint.
+  let endpoint = vec2f(r * ch, r * sh);
+  return length(qa - endpoint);
+}`;
+//#endregion
+export { DEPTH_FORMAT as A, lerp as C, smootherstep as D, sign as E, resizeCanvas as M, smoothstep as O, inverseLerp as S, remap as T, TAU as _, OPAQUE_ALPHA_THRESHOLD as a, clamp01 as b, SpriteBufferLayout as c, TriangleBufferLayout as d, TriangleSchema as f, RAD_TO_DEG as g, PI as h, DEPTH_COMPARE as i, createCanvasContext as j, wrap as k, SpriteSchema as l, HALF_PI as m, CameraLayout as n, ShapeBufferLayout as o, DEG_TO_RAD as p, CameraSchema as r, ShapeSchema as s, ALPHA_BLEND as t, TextureSamplerLayout as u, approxEqual as v, radToDeg as w, degToRad as x, clamp as y };

package/dist/pipeline-DE3a1Pnk.d.mts

@@ -0,0 +1,115 @@
+import * as _$typegpu from "typegpu";
+import { TgpuRoot, d } from "typegpu";
+
+//#region src/shared/pipeline.d.ts
+declare const CameraSchema: d.WgslStruct<{
+  vpCol0: d.Vec2f;
+  vpCol1: d.Vec2f;
+  vpCol2: d.Vec2f;
+  viewport: d.Vec2f;
+  dpr: d.F32;
+  _pad: d.F32;
+}>;
+/**
+ * Per-instance shape record. 32 B, bit-packed. Byte-identical to the CPU-side
+ * layout in `pack.ts`:
+ *   pos         @ 0   vec2f
+ *   sizePacked  @ 8   u32  — `pack2x16float(sizeX, sizeY)`
+ *   fillBits    @ 12  u32  — `pack4x8unorm(fill)`
+ *   strokeBits  @ 16  u32
+ *   rsPacked    @ 20  u32  — `pack2x16float(rotation, strokeWidth)`
+ *   crPacked    @ 24  u32  — `pack2x16float(cornerRadius, _)`
+ *   shapeType   @ 28  u32
+ *
+ * Shaders `unpack4x8unorm` / `unpack2x16float` on access.
+ */
+declare const ShapeSchema: d.WgslStruct<{
+  pos: d.Vec2f;
+  sizePacked: d.U32;
+  fillBits: d.U32;
+  strokeBits: d.U32;
+  rsPacked: d.U32;
+  crPacked: d.U32;
+  shapeType: d.U32;
+}>;
+declare const TriangleSchema: d.WgslStruct<{
+  p1: d.Vec2f;
+  p2: d.Vec2f;
+  p3: d.Vec2f;
+  fill: d.Vec4f;
+}>;
+declare const CameraLayout: _$typegpu.TgpuBindGroupLayout<{
+  camera: {
+    uniform: d.WgslStruct<{
+      vpCol0: d.Vec2f;
+      vpCol1: d.Vec2f;
+      vpCol2: d.Vec2f;
+      viewport: d.Vec2f;
+      dpr: d.F32;
+      _pad: d.F32;
+    }>;
+    visibility: "vertex"[];
+  };
+}>;
+declare const ShapeBufferLayout: _$typegpu.TgpuBindGroupLayout<{
+  shapes: {
+    storage: (elementCount: number) => d.WgslArray<d.WgslStruct<{
+      pos: d.Vec2f;
+      sizePacked: d.U32;
+      fillBits: d.U32;
+      strokeBits: d.U32;
+      rsPacked: d.U32;
+      crPacked: d.U32;
+      shapeType: d.U32;
+    }>>;
+    access: "readonly";
+    visibility: ("fragment" | "vertex")[];
+  };
+}>;
+declare const TriangleBufferLayout: _$typegpu.TgpuBindGroupLayout<{
+  triangles: {
+    storage: (elementCount: number) => d.WgslArray<d.WgslStruct<{
+      p1: d.Vec2f;
+      p2: d.Vec2f;
+      p3: d.Vec2f;
+      fill: d.Vec4f;
+    }>>;
+    access: "readonly";
+    visibility: "vertex"[];
+  };
+}>;
+declare const SpriteSchema: d.WgslStruct<{
+  pos: d.Vec2f;
+  size: d.Vec2f;
+  uvMin: d.Vec2f;
+  uvMax: d.Vec2f;
+  tint: d.Vec4f;
+  anchor: d.Vec2f;
+  rotation: d.F32;
+  _pad: d.F32;
+}>;
+declare const SpriteBufferLayout: _$typegpu.TgpuBindGroupLayout<{
+  sprites: {
+    storage: (elementCount: number) => d.WgslArray<d.WgslStruct<{
+      pos: d.Vec2f;
+      size: d.Vec2f;
+      uvMin: d.Vec2f;
+      uvMax: d.Vec2f;
+      tint: d.Vec4f;
+      anchor: d.Vec2f;
+      rotation: d.F32;
+      _pad: d.F32;
+    }>>;
+    access: "readonly";
+    visibility: "vertex"[];
+  };
+}>;
+declare const TextureSamplerLayout: _$typegpu.TgpuBindGroupLayout<{
+  spriteTexture: _$typegpu.TgpuLayoutTexture<d.WgslTexture2d<d.F32>>;
+  spriteSampler: {
+    sampler: "filtering";
+    visibility: "fragment"[];
+  };
+}>;
+//#endregion
+export { SpriteBufferLayout as a, TriangleBufferLayout as c, ShapeSchema as i, TriangleSchema as l, CameraSchema as n, SpriteSchema as o, ShapeBufferLayout as r, TextureSamplerLayout as s, CameraLayout as t };