@pixerate/editor 0.267.0 → 0.268.0

package/dist/{chunk-GCVFEPJG.js → chunk-ACTHSQOI.js}

@@ -1,4 +1,6 @@
 import {
+  TileableNoise,
+  hash2,
   rand01
 } from "./chunk-4D6KP5BV.js";
 import {
@@ -1078,6 +1080,180 @@ function coverageTileCoord(key) {
   return tileCoord(key);
 }
 
+// src/paint/grain.ts
+var GRAIN_PATTERNS = ["smooth", "cold-pressed", "hot-pressed", "rough", "vellum", "laid", "ingres", "sanded", "canvas", "linen", "gesso"];
+var GRAIN_TILE = 256;
+var clamp01 = (v) => v < 0 ? 0 : v > 1 ? 1 : v;
+function patternHeights(pattern, n, seed) {
+  const out = new Float32Array(n * n);
+  const salt = Math.imul(seed | 0, 2654435761) + 17;
+  if (pattern === "smooth") return out.fill(1);
+  const noise = (cx, cy, oct, s = 0) => new TileableNoise(n, cx, cy, oct, salt + s);
+  const k = n / GRAIN_TILE;
+  switch (pattern) {
+    case "cold-pressed": {
+      const base = noise(20 * k, 20 * k, 4);
+      const fine = noise(64 * k, 64 * k, 2, 3);
+      for (let y = 0; y < n; y++)
+        for (let x = 0; x < n; x++) out[y * n + x] = clamp01((base.at(x, y) - 0.5) * 1.8 + 0.5 + (fine.at(x, y) - 0.5) * 0.5 + (hash2(x, y, salt) - 0.5) * 0.12);
+      break;
+    }
+    case "hot-pressed": {
+      const base = noise(40 * k, 40 * k, 3);
+      for (let y = 0; y < n; y++) for (let x = 0; x < n; x++) out[y * n + x] = clamp01((base.at(x, y) - 0.5) * 1.1 + 0.6 + (hash2(x, y, salt) - 0.5) * 0.08);
+      break;
+    }
+    case "rough": {
+      const base = noise(10 * k, 10 * k, 5);
+      const blot = noise(28 * k, 28 * k, 2, 5);
+      for (let y = 0; y < n; y++)
+        for (let x = 0; x < n; x++) out[y * n + x] = clamp01((base.at(x, y) - 0.5) * 2.4 + 0.5 + (blot.at(x, y) - 0.5) * 0.7 + (hash2(x, y, salt) - 0.5) * 0.15);
+      break;
+    }
+    case "vellum": {
+      const base = noise(40 * k, 40 * k, 3);
+      for (let y = 0; y < n; y++) for (let x = 0; x < n; x++) out[y * n + x] = clamp01((base.at(x, y) - 0.5) * 1.6 + 0.55 + (hash2(x, y, salt) - 0.5) * 0.2);
+      break;
+    }
+    case "laid": {
+      const pulp = noise(32 * k, 32 * k, 3);
+      const chain = n / 8;
+      for (let y = 0; y < n; y++) {
+        const laid = 0.5 + 0.5 * Math.cos(2 * Math.PI * y / 4);
+        for (let x = 0; x < n; x++) {
+          const c = Math.abs((x + 0.5) % chain - chain / 2) / (chain / 2);
+          const chainLine = c > 0.94 ? -0.35 : 0;
+          out[y * n + x] = clamp01(0.3 + 0.5 * laid + chainLine + (pulp.at(x, y) - 0.5) * 0.6);
+        }
+      }
+      break;
+    }
+    case "ingres": {
+      const fibres = noise(64 * k, 12 * k, 3);
+      const base = noise(16 * k, 16 * k, 3, 7);
+      for (let y = 0; y < n; y++)
+        for (let x = 0; x < n; x++) {
+          const g = hash2(x, y, salt ^ 85);
+          out[y * n + x] = clamp01((fibres.at(x, y) - 0.5) * 1.5 + (base.at(x, y) - 0.5) * 0.7 + 0.55 + (g < 0.1 ? -0.3 : 0));
+        }
+      break;
+    }
+    case "sanded": {
+      const grit = noise(96 * k, 96 * k, 2);
+      for (let y = 0; y < n; y++)
+        for (let x = 0; x < n; x++) {
+          const h = hash2(x, y, salt);
+          out[y * n + x] = clamp01((grit.at(x, y) - 0.5) * 2.4 + 0.5 + (h - 0.5) * 0.7);
+        }
+      break;
+    }
+    case "canvas":
+    case "linen": {
+      const period = (pattern === "canvas" ? 8 : 5) * k;
+      const threads = Math.max(2, 2 * Math.round(n / period / 2));
+      const p = n / threads;
+      const slub = noise(threads, threads, 2, 11);
+      for (let y = 0; y < n; y++)
+        for (let x = 0; x < n; x++) {
+          const fx = (x + 0.5) / p;
+          const fy = (y + 0.5) / p;
+          const cx = Math.floor(fx);
+          const cy = Math.floor(fy);
+          const warp = Math.sin(Math.PI * (fx - cx));
+          const weft = Math.sin(Math.PI * (fy - cy));
+          const top = (cx + cy) % 2 === 0 ? warp : weft;
+          const irregular = pattern === "linen" ? (slub.at(x, y) - 0.5) * 0.5 : 0;
+          out[y * n + x] = clamp01(0.2 + 0.7 * top + irregular + (hash2(x, y, salt) - 0.5) * 0.15);
+        }
+      break;
+    }
+    case "gesso": {
+      const streaks = noise(2 * k, 28 * k, 3);
+      const tooth = noise(64 * k, 64 * k, 2, 13);
+      for (let y = 0; y < n; y++)
+        for (let x = 0; x < n; x++) out[y * n + x] = clamp01((streaks.at(x, y) - 0.5) * 1.8 + (tooth.at(x, y) - 0.5) * 0.9 + 0.55);
+      break;
+    }
+  }
+  return out;
+}
+var rawCache = /* @__PURE__ */ new Map();
+function grainHeights(pattern, seed, size = GRAIN_TILE) {
+  const key = `${pattern}:${seed}:${size}`;
+  let h = rawCache.get(key);
+  if (!h) {
+    h = patternHeights(pattern, size, seed);
+    if (rawCache.size > 32) rawCache.delete(rawCache.keys().next().value);
+    rawCache.set(key, h);
+  }
+  return h;
+}
+var PaperGrain = class {
+  size = GRAIN_TILE;
+  heights;
+  scale;
+  mirror;
+  ox;
+  oy;
+  flat;
+  constructor(paper, media = "dry") {
+    const raw = grainHeights(paper.pattern, paper.seed);
+    const t = paper[media];
+    this.flat = paper.pattern === "smooth";
+    if (t.contrast === 1 && !t.invert) this.heights = raw;
+    else {
+      const out = new Float32Array(raw.length);
+      for (let i = 0; i < raw.length; i++) {
+        const v = clamp01((raw[i] - 0.5) * t.contrast + 0.5);
+        out[i] = t.invert ? 1 - v : v;
+      }
+      this.heights = out;
+    }
+    this.scale = paper.scale;
+    this.mirror = paper.tiling === "mirror";
+    this.ox = paper.offset?.x ?? 0;
+    this.oy = paper.offset?.y ?? 0;
+  }
+  /** Tile cell index for a coordinate in grain pixels (mirrored on odd tiles when mirroring). */
+  wrap(v) {
+    const n = this.size;
+    if (!this.mirror) return (v % n + n) % n;
+    const p = (v % (2 * n) + 2 * n) % (2 * n);
+    return p < n ? p : 2 * n - 1 - p;
+  }
+  /** Height 0..1 at document position (x, y). */
+  at(x, y) {
+    const u = (x - this.ox) / this.scale - 0.5;
+    const v = (y - this.oy) / this.scale - 0.5;
+    const x0 = Math.floor(u);
+    const y0 = Math.floor(v);
+    const fx = u - x0;
+    const fy = v - y0;
+    const n = this.size;
+    const h = this.heights;
+    const a = this.wrap(x0);
+    const b = this.wrap(x0 + 1);
+    const c = this.wrap(y0) * n;
+    const d = this.wrap(y0 + 1) * n;
+    const top = h[c + a] + (h[c + b] - h[c + a]) * fx;
+    const bot = h[d + a] + (h[d + b] - h[d + a]) * fx;
+    return top + (bot - top) * fy;
+  }
+};
+function grainCatch(h, depth, pressure) {
+  if (depth <= 0) return 1;
+  const t = depth * (0.75 - 0.65 * Math.min(1, Math.max(0, pressure)));
+  const u = clamp01((h - t + 0.18) / 0.36);
+  return 1 - depth + depth * u * u * (3 - 2 * u);
+}
+function strokeGrainCatch(h, depth, pressure) {
+  if (depth <= 0) return 1;
+  const p = Math.min(1, Math.max(0, pressure));
+  const amount = Math.min(1, depth * (1.4 - 0.6 * p));
+  const u = clamp01((h - 0.2 - 0.25 * (1 - p)) / 0.5);
+  return 1 - amount + amount * u * u * (3 - 2 * u);
+}
+
 // src/paint/exchange.ts
 var MIXING_MODELS = ["rgb", "pigment"];
 var EMPTY_MIXER_LOAD = { reservoir: null, amount: 0, pickup: null };
@@ -1741,6 +1917,12 @@ export {
   applyStrokeToTile,
   applyStrokeToDeepTile,
   coverageTileCoord,
+  GRAIN_PATTERNS,
+  GRAIN_TILE,
+  grainHeights,
+  PaperGrain,
+  grainCatch,
+  strokeGrainCatch,
   MIXING_MODELS,
   EMPTY_MIXER_LOAD,
   MIXER_PICKUP_RATE,