@pixerate/editor 0.137.0 → 0.139.0

package/dist/{chunk-HUO3TI4C.js → chunk-CPSMARTX.js}

@@ -4,20 +4,23 @@ import {
   DEFAULT_BRUSH,
   DEFAULT_MIXER,
   DEFAULT_SMUDGE,
+  GRAIN_PATTERNS,
   PaintGradientSampler,
+  PaperGrain,
   TIP_GRADIENT_STEPS,
   TileMedium,
   dabRect,
+  grainCatch,
   hash2,
-  mix32,
   normalizeBlender,
   normalizeBrush,
   normalizeMixer,
   normalizeSmudge,
   rand01,
+  randSigned,
   rasterizeDab,
   readPaintSource
-} from "./chunk-5FSRTP6E.js";
+} from "./chunk-PQFVLOMR.js";
 import {
   TILE,
   TiledSurface,
@@ -25,79 +28,8 @@ import {
   tileKey
 } from "./chunk-3G6J7UFV.js";
 
-// src/paint-editor/noise.ts
-function randSigned(seed, index, stream) {
-  return rand01(seed, index, stream) * 2 - 1;
-}
-function seedFromString(text) {
-  let h = 2166136261;
-  for (let i = 0; i < text.length; i++) {
-    h ^= text.charCodeAt(i);
-    h = Math.imul(h, 16777619);
-  }
-  return mix32(h >>> 0);
-}
-var smooth = (t) => t * t * (3 - 2 * t);
-var Lattice = class {
-  constructor(px, py, salt) {
-    this.px = px;
-    this.py = py;
-    this.values = new Float32Array(px * py);
-    for (let j = 0; j < py; j++) for (let i = 0; i < px; i++) this.values[j * px + i] = hash2(i, j, salt);
-  }
-  px;
-  py;
-  values;
-  /** Value noise at (x, y) in lattice cells; wraps every `px` / `py` cells. */
-  at(x, y) {
-    const { px, py } = this;
-    const x0 = Math.floor(x);
-    const y0 = Math.floor(y);
-    const tx = smooth(x - x0);
-    const ty = smooth(y - y0);
-    const i0 = (x0 % px + px) % px;
-    const j0 = (y0 % py + py) % py;
-    const i1 = (i0 + 1) % px;
-    const j1 = (j0 + 1) % py;
-    const v = this.values;
-    const a = v[j0 * px + i0] + (v[j0 * px + i1] - v[j0 * px + i0]) * tx;
-    const b = v[j1 * px + i0] + (v[j1 * px + i1] - v[j1 * px + i0]) * tx;
-    return a + (b - a) * ty;
-  }
-};
-var TileableNoise = class {
-  constructor(size, cellsX, cellsY, octaves, salt) {
-    this.size = size;
-    let cx = Math.max(1, Math.round(cellsX));
-    let cy = Math.max(1, Math.round(cellsY));
-    for (let o = 0; o < octaves; o++) {
-      this.octaves.push(new Lattice(cx, cy, salt + o * 7919 | 0));
-      cx *= 2;
-      cy *= 2;
-    }
-  }
-  size;
-  octaves = [];
-  /** Fractal noise at pixel (x, y). */
-  at(x, y) {
-    let sum = 0;
-    let amp = 1;
-    let norm = 0;
-    const u = x / this.size;
-    const v = y / this.size;
-    for (const l of this.octaves) {
-      sum += l.at(u * l.px, v * l.py) * amp;
-      norm += amp;
-      amp *= 0.5;
-    }
-    return norm > 0 ? sum / norm : 0.5;
-  }
-};
-
 // src/paint-editor/paper.ts
-var GRAIN_PATTERNS = ["smooth", "cold-pressed", "hot-pressed", "rough", "vellum", "laid", "ingres", "sanded", "canvas", "linen", "gesso"];
 var PAPER_FAMILIES = ["watercolor", "drawing", "pastel", "canvas", "panel", "smooth"];
-var GRAIN_TILE = 256;
 var unit = (v, d) => typeof v === "number" && Number.isFinite(v) ? Math.min(1, Math.max(0, v)) : d;
 var clampNum = (v, lo, hi, d) => typeof v === "number" && Number.isFinite(v) ? Math.min(hi, Math.max(lo, v)) : d;
 var HEX = /^#[0-9a-f]{6}$/i;
@@ -169,165 +101,6 @@ function normalizePaper(raw = {}, base) {
     ...unit(r.metallic, b.metallic ?? 0) > 0 ? { metallic: unit(r.metallic, b.metallic ?? 0) } : {}
   };
 }
-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;
-  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";
-  }
-  /** 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.scale - 0.5;
-    const v = y / 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 hexToRgb8(hex) {
   const n = parseInt(hex.slice(1, 7), 16);
   return [n >> 16 & 255, n >> 8 & 255, n & 255];
@@ -2001,20 +1774,12 @@ function parseBrushLibrary(raw, problems = []) {
 }
 
 export {
-  randSigned,
-  seedFromString,
-  TileableNoise,
-  GRAIN_PATTERNS,
   PAPER_FAMILIES,
-  GRAIN_TILE,
   PAPER_LIBRARY,
   DEFAULT_PAPER,
   paperPreset,
   clonePaper,
   normalizePaper,
-  grainHeights,
-  PaperGrain,
-  grainCatch,
   hexToRgb8,
   renderPaper,
   penOrientation,
@@ -2073,4 +1838,4 @@ export {
   brushToJSON,
   parseBrushLibrary
 };
-//# sourceMappingURL=chunk-HUO3TI4C.js.map
+//# sourceMappingURL=chunk-CPSMARTX.js.map