@nodetool-ai/gpu 0.8.1

package/dist/shaders/color/channelShuffle/v1/module.js

@@ -0,0 +1,94 @@
+/**
+ * `color.channelShuffle@1` — permute / rebroadcast source channels onto the
+ * output.
+ *
+ * Four integer indices (`rFrom`, `gFrom`, `bFrom`, `aFrom`) pick which input
+ * channel feeds each output channel: `0` R, `1` G, `2` B, `3` A. The
+ * identity permutation `(0, 1, 2, 3)` is passthrough; common swaps include
+ * RGB↔BGR (`2, 1, 0, 3`) and "alpha to grayscale" (`3, 3, 3, 3`).
+ *
+ * Premultiplication: the pool's contract is that alpha is premultiplied
+ * between modules, so the shader un-premultiplies the source's RGB by its
+ * original alpha before picking, then re-premultiplies the result by the
+ * shuffled output alpha. That keeps the canonical premultiplied invariant
+ * intact regardless of which input channel `aFrom` points at.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const ChannelShuffleParams = d.struct({
+    rFrom: d.f32,
+    gFrom: d.f32,
+    bFrom: d.f32,
+    aFrom: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: ChannelShuffleParams },
+    source: { texture: "float" },
+    samp: { sampler: "filtering" }
+});
+const samplerDescriptor = {
+    magFilter: "linear",
+    minFilter: "linear",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge"
+};
+export const colorChannelShuffleV1 = defineModule({
+    id: "color.channelShuffle",
+    version: 1,
+    surface: "internal",
+    category: "color",
+    linearity: "nonlinear-in-rgb",
+    kind: "fragment",
+    params: ChannelShuffleParams,
+    paramDefaults: { rFrom: 0, gFrom: 1, bFrom: 2, aFrom: 3 },
+    paramUi: {
+        rFrom: { min: 0, max: 3, step: 1, label: "R ← channel", notes: "0 R / 1 G / 2 B / 3 A" },
+        gFrom: { min: 0, max: 3, step: 1, label: "G ← channel", notes: "0 R / 1 G / 2 B / 3 A" },
+        bFrom: { min: 0, max: 3, step: 1, label: "B ← channel", notes: "0 R / 1 G / 2 B / 3 A" },
+        aFrom: { min: 0, max: 3, step: 1, label: "A ← channel", notes: "0 R / 1 G / 2 B / 3 A" }
+    },
+    layout,
+    samplers: { samp: samplerDescriptor },
+    wgsl: /* wgsl */ `
+fn pick(src: vec4f, idx: i32) -> f32 {
+  if (idx == 0) { return src.r; }
+  if (idx == 1) { return src.g; }
+  if (idx == 2) { return src.b; }
+  return src.a;
+}
+
+@fragment
+fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {
+  let src = textureSample(layout.$.source, layout.$.samp, uv);
+  let p = layout.$.params;
+  // Un-premultiply by the source alpha so channels are picked in straight
+  // space, then re-premultiply by the chosen output alpha — keeps the pool's
+  // premultiplied-between-modules invariant regardless of aFrom.
+  let safeA = max(src.a, 0.0001);
+  let straight = vec4f(src.rgb / safeA, src.a);
+  let outA = pick(straight, i32(round(p.aFrom)) & 3);
+  let outR = pick(straight, i32(round(p.rFrom)) & 3) * outA;
+  let outG = pick(straight, i32(round(p.gFrom)) & 3) * outA;
+  let outB = pick(straight, i32(round(p.bFrom)) & 3) * outA;
+  return vec4f(outR, outG, outB, outA);
+}
+`,
+    io: {
+        inputs: {
+            source: {
+                colorSpace: "linear",
+                alpha: "premultiplied",
+                bindingKinds: ["texture_2d"]
+            }
+        },
+        output: {
+            colorSpace: "linear",
+            alpha: "premultiplied",
+            format: "rgba8unorm",
+            dimensions: "same-as:source"
+        },
+        rod: "same-as:source"
+    }
+});
+//# sourceMappingURL=module.js.map

package/dist/shaders/color/channelShuffle/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/color/channelShuffle/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,IAAI,MAAM,SAAS,CAAC;AAC3B,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAClC,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAErD,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC3C,KAAK,EAAE,CAAC,CAAC,GAAG;IACZ,KAAK,EAAE,CAAC,CAAC,GAAG;IACZ,KAAK,EAAE,CAAC,CAAC,GAAG;IACZ,KAAK,EAAE,CAAC,CAAC,GAAG;CACb,CAAC,CAAC;AAEH,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC;IAClC,MAAM,EAAE,EAAE,OAAO,EAAE,oBAAoB,EAAE;IACzC,MAAM,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE;IAC5B,IAAI,EAAE,EAAE,OAAO,EAAE,WAAW,EAAE;CAC/B,CAAC,CAAC;AAEH,MAAM,iBAAiB,GAAyB;IAC9C,SAAS,EAAE,QAAQ;IACnB,SAAS,EAAE,QAAQ;IACnB,YAAY,EAAE,eAAe;IAC7B,YAAY,EAAE,eAAe;CAC9B,CAAC;AAEF,MAAM,CAAC,MAAM,qBAAqB,GAAG,YAAY,CAAC;IAChD,EAAE,EAAE,sBAAsB;IAC1B,OAAO,EAAE,CAAC;IACV,OAAO,EAAE,UAAU;IACnB,QAAQ,EAAE,OAAO;IACjB,SAAS,EAAE,kBAAkB;IAC7B,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,oBAAoB;IAC5B,aAAa,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE;IACzD,OAAO,EAAE;QACP,KAAK,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,uBAAuB,EAAE;QACxF,KAAK,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,uBAAuB,EAAE;QACxF,KAAK,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,uBAAuB,EAAE;QACxF,KAAK,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,uBAAuB,EAAE;KACzF;IACD,MAAM;IACN,QAAQ,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE;IACrC,IAAI,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;CAuBlB;IACC,EAAE,EAAE;QACF,MAAM,EAAE;YACN,MAAM,EAAE;gBACN,UAAU,EAAE,QAAQ;gBACpB,KAAK,EAAE,eAAe;gBACtB,YAAY,EAAE,CAAC,YAAY,CAAC;aAC7B;SACF;QACD,MAAM,EAAE;YACN,UAAU,EAAE,QAAQ;YACpB,KAAK,EAAE,eAAe;YACtB,MAAM,EAAE,YAAY;YACpB,UAAU,EAAE,gBAAgB;SAC7B;QACD,GAAG,EAAE,gBAAgB;KACtB;CACF,CAAC,CAAC"}

package/dist/shaders/color/channelSplit/v1/module.d.ts

@@ -0,0 +1,18 @@
+/**
+ * `color.channelSplit@1` — output a single channel of the source as
+ * opaque grayscale RGB.
+ *
+ * `mode = 0` red, `1` green, `2` blue, `3` alpha, `4` luminance
+ * (`0.299R + 0.587G + 0.114B`). The selected value is broadcast to all three
+ * output RGB channels and the alpha is forced to `1.0`, so the result is a
+ * standard grayscale visualization safe to chain into any RGBA consumer.
+ * Pairs with `color.channelMerge` to build per-channel pipelines.
+ */
+import * as d from "typegpu/data";
+export declare const ChannelSplitParams: d.WgslStruct<{
+    mode: d.F32;
+}>;
+export declare const colorChannelSplitV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    mode: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

package/dist/shaders/color/channelSplit/v1/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/shaders/color/channelSplit/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAGlC,eAAO,MAAM,kBAAkB;;EAE7B,CAAC;AAeH,eAAO,MAAM,mBAAmB;;GA6D9B,CAAC"}

package/dist/shaders/color/channelSplit/v1/module.js

@@ -0,0 +1,90 @@
+/**
+ * `color.channelSplit@1` — output a single channel of the source as
+ * opaque grayscale RGB.
+ *
+ * `mode = 0` red, `1` green, `2` blue, `3` alpha, `4` luminance
+ * (`0.299R + 0.587G + 0.114B`). The selected value is broadcast to all three
+ * output RGB channels and the alpha is forced to `1.0`, so the result is a
+ * standard grayscale visualization safe to chain into any RGBA consumer.
+ * Pairs with `color.channelMerge` to build per-channel pipelines.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const ChannelSplitParams = d.struct({
+    mode: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: ChannelSplitParams },
+    source: { texture: "float" },
+    samp: { sampler: "filtering" }
+});
+const samplerDescriptor = {
+    magFilter: "linear",
+    minFilter: "linear",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge"
+};
+export const colorChannelSplitV1 = defineModule({
+    id: "color.channelSplit",
+    version: 1,
+    surface: "internal",
+    category: "color",
+    linearity: "nonlinear-in-rgb",
+    kind: "fragment",
+    params: ChannelSplitParams,
+    paramDefaults: { mode: 0 },
+    paramUi: {
+        mode: {
+            min: 0,
+            max: 4,
+            step: 1,
+            label: "Channel",
+            notes: "0 R / 1 G / 2 B / 3 A / 4 luma"
+        }
+    },
+    layout,
+    samplers: { samp: samplerDescriptor },
+    wgsl: /* wgsl */ `
+@fragment
+fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {
+  let src = textureSample(layout.$.source, layout.$.samp, uv);
+  // Un-premultiply so the reported channel/luma reflects the underlying
+  // straight colour. Reading premultiplied rgb directly under-reports every
+  // channel on partial-alpha pixels (e.g. a 50%-transparent mid-grey reads at
+  // half its true value).
+  let straight = src.rgb / max(src.a, 1.0 / 255.0);
+  let mode = i32(round(layout.$.params.mode));
+  var v: f32 = 0.0;
+  if (mode == 0) {
+    v = straight.r;
+  } else if (mode == 1) {
+    v = straight.g;
+  } else if (mode == 2) {
+    v = straight.b;
+  } else if (mode == 3) {
+    v = src.a;
+  } else {
+    v = dot(straight, vec3f(0.299, 0.587, 0.114));
+  }
+  return vec4f(v, v, v, 1.0);
+}
+`,
+    io: {
+        inputs: {
+            source: {
+                colorSpace: "linear",
+                alpha: "premultiplied",
+                bindingKinds: ["texture_2d"]
+            }
+        },
+        output: {
+            colorSpace: "linear",
+            alpha: "premultiplied",
+            format: "rgba8unorm",
+            dimensions: "same-as:source"
+        },
+        rod: "same-as:source"
+    }
+});
+//# sourceMappingURL=module.js.map

package/dist/shaders/color/channelSplit/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/color/channelSplit/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,IAAI,MAAM,SAAS,CAAC;AAC3B,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAClC,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAErD,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC;IACzC,IAAI,EAAE,CAAC,CAAC,GAAG;CACZ,CAAC,CAAC;AAEH,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC;IAClC,MAAM,EAAE,EAAE,OAAO,EAAE,kBAAkB,EAAE;IACvC,MAAM,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE;IAC5B,IAAI,EAAE,EAAE,OAAO,EAAE,WAAW,EAAE;CAC/B,CAAC,CAAC;AAEH,MAAM,iBAAiB,GAAyB;IAC9C,SAAS,EAAE,QAAQ;IACnB,SAAS,EAAE,QAAQ;IACnB,YAAY,EAAE,eAAe;IAC7B,YAAY,EAAE,eAAe;CAC9B,CAAC;AAEF,MAAM,CAAC,MAAM,mBAAmB,GAAG,YAAY,CAAC;IAC9C,EAAE,EAAE,oBAAoB;IACxB,OAAO,EAAE,CAAC;IACV,OAAO,EAAE,UAAU;IACnB,QAAQ,EAAE,OAAO;IACjB,SAAS,EAAE,kBAAkB;IAC7B,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,kBAAkB;IAC1B,aAAa,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE;IAC1B,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,GAAG,EAAE,CAAC;YACN,GAAG,EAAE,CAAC;YACN,IAAI,EAAE,CAAC;YACP,KAAK,EAAE,SAAS;YAChB,KAAK,EAAE,gCAAgC;SACxC;KACF;IACD,MAAM;IACN,QAAQ,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE;IACrC,IAAI,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;CAwBlB;IACC,EAAE,EAAE;QACF,MAAM,EAAE;YACN,MAAM,EAAE;gBACN,UAAU,EAAE,QAAQ;gBACpB,KAAK,EAAE,eAAe;gBACtB,YAAY,EAAE,CAAC,YAAY,CAAC;aAC7B;SACF;QACD,MAAM,EAAE;YACN,UAAU,EAAE,QAAQ;YACpB,KAAK,EAAE,eAAe;YACtB,MAAM,EAAE,YAAY;YACpB,UAAU,EAAE,gBAAgB;SAC7B;QACD,GAAG,EAAE,gBAAgB;KACtB;CACF,CAAC,CAAC"}

package/dist/shaders/color/colorBalance/v1/module.d.ts

@@ -0,0 +1,18 @@
+/**
+ * `color.colorBalance@1` — white-balance temperature / tint shift.
+ *
+ * Ported verbatim from the CPU `lib.image.color_grading.ColorBalance` loop:
+ * temperature pushes red up and blue down (warmer), tint trades green against
+ * magenta. Both knobs are scaled by `0.3` then applied additively to straight
+ * RGB. Fragment, with the canonical optional mask slot.
+ */
+import * as d from "typegpu/data";
+export declare const ColorBalanceParams: d.WgslStruct<{
+    temperature: d.F32;
+    tint: d.F32;
+}>;
+export declare const colorColorBalanceV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    temperature: d.F32;
+    tint: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

package/dist/shaders/color/colorBalance/v1/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/shaders/color/colorBalance/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAGlC,eAAO,MAAM,kBAAkB;;;EAG7B,CAAC;AAgBH,eAAO,MAAM,mBAAmB;;;GAyD9B,CAAC"}

package/dist/shaders/color/colorBalance/v1/module.js

@@ -0,0 +1,86 @@
+/**
+ * `color.colorBalance@1` — white-balance temperature / tint shift.
+ *
+ * Ported verbatim from the CPU `lib.image.color_grading.ColorBalance` loop:
+ * temperature pushes red up and blue down (warmer), tint trades green against
+ * magenta. Both knobs are scaled by `0.3` then applied additively to straight
+ * RGB. Fragment, with the canonical optional mask slot.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const ColorBalanceParams = d.struct({
+    temperature: d.f32,
+    tint: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: ColorBalanceParams },
+    source: { texture: "float" },
+    mask: { texture: "float" },
+    samp: { sampler: "filtering" }
+});
+const samplerDescriptor = {
+    magFilter: "linear",
+    minFilter: "linear",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge"
+};
+export const colorColorBalanceV1 = defineModule({
+    id: "color.colorBalance",
+    version: 1,
+    surface: "internal",
+    category: "color",
+    linearity: "nonlinear-in-rgb",
+    kind: "fragment",
+    params: ColorBalanceParams,
+    paramDefaults: { temperature: 0, tint: 0 },
+    paramUi: {
+        temperature: { min: -1, max: 1, step: 0.01, label: "Temperature" },
+        tint: { min: -1, max: 1, step: 0.01, label: "Tint" }
+    },
+    layout,
+    samplers: { samp: samplerDescriptor },
+    wgsl: /* wgsl */ `
+@fragment
+fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {
+  let src = textureSample(layout.$.source, layout.$.samp, uv);
+  let coverage = textureSample(layout.$.mask, layout.$.samp, uv).a;
+  let p = layout.$.params;
+  // Operate on straight color so the additive shifts act on the underlying
+  // colour, not the premultiplied magnitude. Re-premultiply on store.
+  let safeA = max(src.a, 1.0 / 255.0);
+  let straight = src.rgb / safeA;
+  let tempShift = p.temperature * 0.3;
+  let tintShift = p.tint * 0.3;
+  var rgb = straight;
+  rgb.r = rgb.r + tempShift + tintShift * 0.5;
+  rgb.g = rgb.g - tintShift;
+  rgb.b = rgb.b - tempShift + tintShift * 0.5;
+  let mixed = mix(straight, rgb, coverage);
+  return vec4f(clamp(mixed, vec3f(0.0), vec3f(1.0)) * src.a, src.a);
+}
+`,
+    io: {
+        inputs: {
+            source: {
+                colorSpace: "srgb",
+                alpha: "premultiplied",
+                bindingKinds: ["texture_2d"]
+            },
+            mask: {
+                colorSpace: "srgb",
+                alpha: "premultiplied",
+                bindingKinds: ["texture_2d"],
+                optional: true
+            }
+        },
+        output: {
+            colorSpace: "srgb",
+            alpha: "premultiplied",
+            format: "rgba8unorm",
+            dimensions: "same-as:source"
+        },
+        rod: "same-as:source"
+    }
+});
+//# sourceMappingURL=module.js.map

package/dist/shaders/color/colorBalance/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/color/colorBalance/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,IAAI,MAAM,SAAS,CAAC;AAC3B,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAClC,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAErD,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC;IACzC,WAAW,EAAE,CAAC,CAAC,GAAG;IAClB,IAAI,EAAE,CAAC,CAAC,GAAG;CACZ,CAAC,CAAC;AAEH,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC;IAClC,MAAM,EAAE,EAAE,OAAO,EAAE,kBAAkB,EAAE;IACvC,MAAM,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE;IAC5B,IAAI,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE;IAC1B,IAAI,EAAE,EAAE,OAAO,EAAE,WAAW,EAAE;CAC/B,CAAC,CAAC;AAEH,MAAM,iBAAiB,GAAyB;IAC9C,SAAS,EAAE,QAAQ;IACnB,SAAS,EAAE,QAAQ;IACnB,YAAY,EAAE,eAAe;IAC7B,YAAY,EAAE,eAAe;CAC9B,CAAC;AAEF,MAAM,CAAC,MAAM,mBAAmB,GAAG,YAAY,CAAC;IAC9C,EAAE,EAAE,oBAAoB;IACxB,OAAO,EAAE,CAAC;IACV,OAAO,EAAE,UAAU;IACnB,QAAQ,EAAE,OAAO;IACjB,SAAS,EAAE,kBAAkB;IAC7B,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,kBAAkB;IAC1B,aAAa,EAAE,EAAE,WAAW,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE;IAC1C,OAAO,EAAE;QACP,WAAW,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,aAAa,EAAE;QAClE,IAAI,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE;KACrD;IACD,MAAM;IACN,QAAQ,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE;IACrC,IAAI,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;CAmBlB;IACC,EAAE,EAAE;QACF,MAAM,EAAE;YACN,MAAM,EAAE;gBACN,UAAU,EAAE,MAAM;gBAClB,KAAK,EAAE,eAAe;gBACtB,YAAY,EAAE,CAAC,YAAY,CAAC;aAC7B;YACD,IAAI,EAAE;gBACJ,UAAU,EAAE,MAAM;gBAClB,KAAK,EAAE,eAAe;gBACtB,YAAY,EAAE,CAAC,YAAY,CAAC;gBAC5B,QAAQ,EAAE,IAAI;aACf;SACF;QACD,MAAM,EAAE;YACN,UAAU,EAAE,MAAM;YAClB,KAAK,EAAE,eAAe;YACtB,MAAM,EAAE,YAAY;YACpB,UAAU,EAAE,gBAAgB;SAC7B;QACD,GAAG,EAAE,gBAAgB;KACtB;CACF,CAAC,CAAC"}

package/dist/shaders/color/cubeLut/v1/module.d.ts

@@ -0,0 +1,14 @@
+import * as d from "typegpu/data";
+export declare const CubeLutParams: d.WgslStruct<{
+    size: d.F32;
+    intensity: d.F32;
+    domainMin: d.Vec4f;
+    domainMax: d.Vec4f;
+}>;
+export declare const colorCubeLutV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    size: d.F32;
+    intensity: d.F32;
+    domainMin: d.Vec4f;
+    domainMax: d.Vec4f;
+}>>;
+//# sourceMappingURL=module.d.ts.map

package/dist/shaders/color/cubeLut/v1/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/shaders/color/cubeLut/v1/module.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAGlC,eAAO,MAAM,aAAa;;;;;EAKxB,CAAC;AAUH,eAAO,MAAM,cAAc;;;;;GA4DzB,CAAC"}

package/dist/shaders/color/cubeLut/v1/module.js

@@ -0,0 +1,78 @@
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const CubeLutParams = d.struct({
+    size: d.f32,
+    intensity: d.f32,
+    domainMin: d.vec4f,
+    domainMax: d.vec4f
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: CubeLutParams },
+    source: { texture: "float" },
+    lut: { texture: "float" },
+    mask: { texture: "float" },
+    samp: { sampler: "filtering" }
+});
+export const colorCubeLutV1 = defineModule({
+    id: "color.cubeLut",
+    version: 1,
+    surface: "internal",
+    category: "color",
+    linearity: "nonlinear-in-rgb",
+    kind: "fragment",
+    params: CubeLutParams,
+    paramDefaults: {
+        size: 2,
+        intensity: 1,
+        domainMin: d.vec4f(0, 0, 0, 0),
+        domainMax: d.vec4f(1, 1, 1, 0)
+    },
+    layout,
+    samplers: { samp: { magFilter: "linear", minFilter: "linear", addressModeU: "clamp-to-edge", addressModeV: "clamp-to-edge" } },
+    wgsl: /* wgsl */ `
+fn lookup(r: i32, g: i32, b: i32, size: i32) -> vec3f {
+  return textureLoad(layout.$.lut, vec2i(b * size + r, g), 0).rgb;
+}
+
+@fragment
+fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {
+  let p = layout.$.params;
+  let src = textureSample(layout.$.source, layout.$.samp, uv);
+  let coverage = textureSample(layout.$.mask, layout.$.samp, uv).a;
+  let size = i32(round(p.size));
+  let straight = src.rgb / max(src.a, 1.0 / 255.0);
+  let domain = max(p.domainMax.xyz - p.domainMin.xyz, vec3f(0.000001));
+  let coordinate = clamp((straight - p.domainMin.xyz) / domain, vec3f(0.0), vec3f(1.0)) * f32(size - 1);
+  let lo = vec3i(floor(coordinate));
+  let hi = min(lo + vec3i(1), vec3i(size - 1));
+  let f = fract(coordinate);
+  var graded = vec3f(0.0);
+  for (var bz = 0; bz <= 1; bz = bz + 1) {
+    for (var gy = 0; gy <= 1; gy = gy + 1) {
+      for (var rx = 0; rx <= 1; rx = rx + 1) {
+        let r = select(lo.x, hi.x, rx == 1);
+        let g = select(lo.y, hi.y, gy == 1);
+        let b = select(lo.z, hi.z, bz == 1);
+        let weight = select(1.0 - f.x, f.x, rx == 1)
+          * select(1.0 - f.y, f.y, gy == 1)
+          * select(1.0 - f.z, f.z, bz == 1);
+        graded = graded + lookup(r, g, b, size) * weight;
+      }
+    }
+  }
+  let mixAmount = clamp(p.intensity * coverage, 0.0, 1.0);
+  return vec4f(clamp(mix(straight, graded, mixAmount), vec3f(0.0), vec3f(1.0)) * src.a, src.a);
+}
+`,
+    io: {
+        inputs: {
+            source: { colorSpace: "srgb", alpha: "premultiplied", bindingKinds: ["texture_2d"] },
+            lut: { colorSpace: "srgb", alpha: "premultiplied", bindingKinds: ["texture_2d"] },
+            mask: { colorSpace: "srgb", alpha: "premultiplied", bindingKinds: ["texture_2d"], optional: true }
+        },
+        output: { colorSpace: "srgb", alpha: "premultiplied", format: "rgba8unorm", dimensions: "same-as:source" },
+        rod: "same-as:source"
+    }
+});
+//# sourceMappingURL=module.js.map

package/dist/shaders/color/cubeLut/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/color/cubeLut/v1/module.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,SAAS,CAAC;AAC3B,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAClC,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAErD,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC;IACpC,IAAI,EAAE,CAAC,CAAC,GAAG;IACX,SAAS,EAAE,CAAC,CAAC,GAAG;IAChB,SAAS,EAAE,CAAC,CAAC,KAAK;IAClB,SAAS,EAAE,CAAC,CAAC,KAAK;CACnB,CAAC,CAAC;AAEH,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC;IAClC,MAAM,EAAE,EAAE,OAAO,EAAE,aAAa,EAAE;IAClC,MAAM,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE;IAC5B,GAAG,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE;IACzB,IAAI,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE;IAC1B,IAAI,EAAE,EAAE,OAAO,EAAE,WAAW,EAAE;CAC/B,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,cAAc,GAAG,YAAY,CAAC;IACzC,EAAE,EAAE,eAAe;IACnB,OAAO,EAAE,CAAC;IACV,OAAO,EAAE,UAAU;IACnB,QAAQ,EAAE,OAAO;IACjB,SAAS,EAAE,kBAAkB;IAC7B,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,aAAa;IACrB,aAAa,EAAE;QACb,IAAI,EAAE,CAAC;QACP,SAAS,EAAE,CAAC;QACZ,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;QAC9B,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;KAC/B;IACD,MAAM;IACN,QAAQ,EAAE,EAAE,IAAI,EAAE,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAE,QAAQ,EAAE,YAAY,EAAE,eAAe,EAAE,YAAY,EAAE,eAAe,EAAE,EAAE;IAC9H,IAAI,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkClB;IACC,EAAE,EAAE;QACF,MAAM,EAAE;YACN,MAAM,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe,EAAE,YAAY,EAAE,CAAC,YAAY,CAAC,EAAE;YACpF,GAAG,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe,EAAE,YAAY,EAAE,CAAC,YAAY,CAAC,EAAE;YACjF,IAAI,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe,EAAE,YAAY,EAAE,CAAC,YAAY,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE;SACnG;QACD,MAAM,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe,EAAE,MAAM,EAAE,YAAY,EAAE,UAAU,EAAE,gBAAgB,EAAE;QAC1G,GAAG,EAAE,gBAAgB;KACtB;CACF,CAAC,CAAC"}

package/dist/shaders/color/curves/v1/module.d.ts

@@ -0,0 +1,31 @@
+/**
+ * `color.curves@1` — black/white-point levels plus shadow / midtone /
+ * highlight tonal bends, with per-channel midtone gamma.
+ *
+ * Ported verbatim from the CPU `lib.image.color_grading.Curves` loop:
+ * remap `[blackPoint, whitePoint]` to `[0, 1]`, apply a parametric shadow lift,
+ * a global midtone gamma, a highlight roll, then a per-channel midtone gamma.
+ * Fragment, with the canonical optional mask slot.
+ */
+import * as d from "typegpu/data";
+export declare const CurvesParams: d.WgslStruct<{
+    blackPoint: d.F32;
+    whitePoint: d.F32;
+    shadows: d.F32;
+    midtones: d.F32;
+    highlights: d.F32;
+    redMidtones: d.F32;
+    greenMidtones: d.F32;
+    blueMidtones: d.F32;
+}>;
+export declare const colorCurvesV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    blackPoint: d.F32;
+    whitePoint: d.F32;
+    shadows: d.F32;
+    midtones: d.F32;
+    highlights: d.F32;
+    redMidtones: d.F32;
+    greenMidtones: d.F32;
+    blueMidtones: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

package/dist/shaders/color/curves/v1/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/shaders/color/curves/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAGlC,eAAO,MAAM,YAAY;;;;;;;;;EASvB,CAAC;AAgBH,eAAO,MAAM,aAAa;;;;;;;;;GAkExB,CAAC"}

package/dist/shaders/color/curves/v1/module.js

@@ -0,0 +1,102 @@
+/**
+ * `color.curves@1` — black/white-point levels plus shadow / midtone /
+ * highlight tonal bends, with per-channel midtone gamma.
+ *
+ * Ported verbatim from the CPU `lib.image.color_grading.Curves` loop:
+ * remap `[blackPoint, whitePoint]` to `[0, 1]`, apply a parametric shadow lift,
+ * a global midtone gamma, a highlight roll, then a per-channel midtone gamma.
+ * Fragment, with the canonical optional mask slot.
+ */
+import tgpu from "typegpu";
+import * as d from "typegpu/data";
+import { defineModule } from "../../../../module.js";
+export const CurvesParams = d.struct({
+    blackPoint: d.f32,
+    whitePoint: d.f32,
+    shadows: d.f32,
+    midtones: d.f32,
+    highlights: d.f32,
+    redMidtones: d.f32,
+    greenMidtones: d.f32,
+    blueMidtones: d.f32
+});
+const layout = tgpu.bindGroupLayout({
+    params: { uniform: CurvesParams },
+    source: { texture: "float" },
+    mask: { texture: "float" },
+    samp: { sampler: "filtering" }
+});
+const samplerDescriptor = {
+    magFilter: "linear",
+    minFilter: "linear",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge"
+};
+export const colorCurvesV1 = defineModule({
+    id: "color.curves",
+    version: 1,
+    surface: "internal",
+    category: "color",
+    linearity: "nonlinear-in-rgb",
+    kind: "fragment",
+    params: CurvesParams,
+    paramDefaults: {
+        blackPoint: 0,
+        whitePoint: 1,
+        shadows: 0,
+        midtones: 0,
+        highlights: 0,
+        redMidtones: 0,
+        greenMidtones: 0,
+        blueMidtones: 0
+    },
+    layout,
+    samplers: { samp: samplerDescriptor },
+    wgsl: /* wgsl */ `
+@fragment
+fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {
+  let src = textureSample(layout.$.source, layout.$.samp, uv);
+  let coverage = textureSample(layout.$.mask, layout.$.samp, uv).a;
+  let p = layout.$.params;
+  let safeA = max(src.a, 1.0 / 255.0);
+  let straight = src.rgb / safeA;
+  let range = max(0.001, p.whitePoint - p.blackPoint);
+  let gammaAll = 1.0 / max(0.01, 1.0 + p.midtones);
+  let gammaPer = vec3f(
+    1.0 / max(0.01, 1.0 + p.redMidtones),
+    1.0 / max(0.01, 1.0 + p.greenMidtones),
+    1.0 / max(0.01, 1.0 + p.blueMidtones)
+  );
+  var rgb = clamp((straight - vec3f(p.blackPoint)) / range, vec3f(0.0), vec3f(1.0));
+  rgb = rgb + p.shadows * (vec3f(1.0) - rgb) * rgb;
+  rgb = pow(max(rgb, vec3f(0.0)), vec3f(gammaAll));
+  rgb = rgb + p.highlights * rgb * (vec3f(1.0) - rgb);
+  rgb = pow(max(rgb, vec3f(0.0)), gammaPer);
+  let mixed = mix(straight, rgb, coverage);
+  return vec4f(clamp(mixed, vec3f(0.0), vec3f(1.0)) * src.a, src.a);
+}
+`,
+    io: {
+        inputs: {
+            source: {
+                colorSpace: "srgb",
+                alpha: "premultiplied",
+                bindingKinds: ["texture_2d"]
+            },
+            mask: {
+                colorSpace: "srgb",
+                alpha: "premultiplied",
+                bindingKinds: ["texture_2d"],
+                optional: true
+            }
+        },
+        output: {
+            colorSpace: "srgb",
+            alpha: "premultiplied",
+            format: "rgba8unorm",
+            dimensions: "same-as:source"
+        },
+        rod: "same-as:source"
+    }
+});
+//# sourceMappingURL=module.js.map

package/dist/shaders/color/curves/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../src/shaders/color/curves/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,IAAI,MAAM,SAAS,CAAC;AAC3B,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAClC,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAErD,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC;IACnC,UAAU,EAAE,CAAC,CAAC,GAAG;IACjB,UAAU,EAAE,CAAC,CAAC,GAAG;IACjB,OAAO,EAAE,CAAC,CAAC,GAAG;IACd,QAAQ,EAAE,CAAC,CAAC,GAAG;IACf,UAAU,EAAE,CAAC,CAAC,GAAG;IACjB,WAAW,EAAE,CAAC,CAAC,GAAG;IAClB,aAAa,EAAE,CAAC,CAAC,GAAG;IACpB,YAAY,EAAE,CAAC,CAAC,GAAG;CACpB,CAAC,CAAC;AAEH,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC;IAClC,MAAM,EAAE,EAAE,OAAO,EAAE,YAAY,EAAE;IACjC,MAAM,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE;IAC5B,IAAI,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE;IAC1B,IAAI,EAAE,EAAE,OAAO,EAAE,WAAW,EAAE;CAC/B,CAAC,CAAC;AAEH,MAAM,iBAAiB,GAAyB;IAC9C,SAAS,EAAE,QAAQ;IACnB,SAAS,EAAE,QAAQ;IACnB,YAAY,EAAE,eAAe;IAC7B,YAAY,EAAE,eAAe;CAC9B,CAAC;AAEF,MAAM,CAAC,MAAM,aAAa,GAAG,YAAY,CAAC;IACxC,EAAE,EAAE,cAAc;IAClB,OAAO,EAAE,CAAC;IACV,OAAO,EAAE,UAAU;IACnB,QAAQ,EAAE,OAAO;IACjB,SAAS,EAAE,kBAAkB;IAC7B,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,YAAY;IACpB,aAAa,EAAE;QACb,UAAU,EAAE,CAAC;QACb,UAAU,EAAE,CAAC;QACb,OAAO,EAAE,CAAC;QACV,QAAQ,EAAE,CAAC;QACX,UAAU,EAAE,CAAC;QACb,WAAW,EAAE,CAAC;QACd,aAAa,EAAE,CAAC;QAChB,YAAY,EAAE,CAAC;KAChB;IACD,MAAM;IACN,QAAQ,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE;IACrC,IAAI,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;CAuBlB;IACC,EAAE,EAAE;QACF,MAAM,EAAE;YACN,MAAM,EAAE;gBACN,UAAU,EAAE,MAAM;gBAClB,KAAK,EAAE,eAAe;gBACtB,YAAY,EAAE,CAAC,YAAY,CAAC;aAC7B;YACD,IAAI,EAAE;gBACJ,UAAU,EAAE,MAAM;gBAClB,KAAK,EAAE,eAAe;gBACtB,YAAY,EAAE,CAAC,YAAY,CAAC;gBAC5B,QAAQ,EAAE,IAAI;aACf;SACF;QACD,MAAM,EAAE;YACN,UAAU,EAAE,MAAM;YAClB,KAAK,EAAE,eAAe;YACtB,MAAM,EAAE,YAAY;YACpB,UAAU,EAAE,gBAAgB;SAC7B;QACD,GAAG,EAAE,gBAAgB;KACtB;CACF,CAAC,CAAC"}

package/dist/shaders/color/exposure/v1/module.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `color.exposure@1` — multiplicative exposure in stops (`rgb *= pow(2, stops)`).
+ *
+ * `0` stops is passthrough; `+1` doubles, `-1` halves. Clamps output to
+ * `[0, 1]` since the working format is SDR; HDR exposure ships with the
+ * separate HDR pipeline plan. Fragment, with the canonical mask slot.
+ */
+import * as d from "typegpu/data";
+export declare const ExposureParams: d.WgslStruct<{
+    stops: d.F32;
+}>;
+export declare const colorExposureV1: import("../../../../module.js").ShaderModule<d.WgslStruct<{
+    stops: d.F32;
+}>>;
+//# sourceMappingURL=module.d.ts.map

package/dist/shaders/color/exposure/v1/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/shaders/color/exposure/v1/module.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAGlC,eAAO,MAAM,cAAc;;EAEzB,CAAC;AAgBH,eAAO,MAAM,eAAe;;GAmD1B,CAAC"}