@lovo/matter 0.6.0 → 2.0.0

package/CHANGELOG.md

@@ -1,5 +1,36 @@
 # @lovo/matter
 
+## 2.0.0
+
+### Major Changes
+
+- 945657f: Rework the `<Vignette>` component. Its props are renamed for clarity — `radius` is now `falloff` and `softness` is now `feather` — and the overlay blend gains `colorSpace` (default `oklab`) and `hueInterpolation` (default `shorter`), so the vignette can darken and tint in a chosen perceptual space rather than only in linear space. Defaults shift to `intensity` 0.3, `feather` 0.6, and a dark wide-gamut `oklch()` color.
+
+  This is a breaking change for anyone using `radius` or `softness`, or relying on the previous linear default blend.
+
+## 1.0.0
+
+### Major Changes
+
+- 8d9d4ad: Rename the `filmGrain` primitive to `grain`.
+
+  The `filmGrain(intensity, timeOffset?)` primitive is now exported as `grain` with
+  an identical signature and behavior. The Tier 1 `<FilmGrain>` component (delivered
+  via the CLI) is likewise renamed to `<Grain>`, and its `film-grain` registry slug
+  is now `grain`.
+
+  **Migration:** one-pass find-and-replace.
+
+  ```ts
+  // Before
+  import { filmGrain } from '@lovo/matter';
+  const g = filmGrain(0.08);
+
+  // After
+  import { grain } from '@lovo/matter';
+  const g = grain(0.08);
+  ```
+
 ## 0.6.0
 
 ### Minor Changes
@@ -24,7 +55,7 @@
   - `time` → `elapsedTime`
   - `Vec2` → `Vector2`
 
-  `TSLNode`, `voronoi`, `colorRamp`, `quantize`, `displace`, `cursorRipple`, and `filmGrain` are unchanged.
+  `TSLNode`, `voronoi`, `colorRamp`, `quantize`, `displace`, `cursorRipple`, and `grain` are unchanged.
 
   **Migration:** one-pass find-and-replace in your imports and call sites. No behavioral changes.
 
@@ -50,21 +81,21 @@
 
 ### Minor Changes
 
-- 3856367: Add `filmGrain` primitive — hash-based, centered film grain for shader compositions.
+- 3856367: Add `grain` primitive — hash-based, centered film grain for shader compositions.
 
   ```ts
-  import { filmGrain, time } from "@lovo/matter";
+  import { grain, time } from "@lovo/matter";
   import { uv } from "three/tsl";
 
   // Static grain:
-  const grain = filmGrain(uv(), 0.08);
+  const grainValue = grain(uv(), 0.08);
 
   // Twinkling grain — caller controls the shutter rate. floor() quantizes
   // time to a discrete cadence; the hash is so sensitive that a continuous
   // time input gives no perceptible speed control.
-  const grain = filmGrain(uv(), 0.08, time.mul(speed).mul(60).floor());
+  const grainValue = grain(uv(), 0.08, time.mul(speed).mul(60).floor());
 
-  material.colorNode = vec4(color.add(grain), 1);
+  material.colorNode = vec4(color.add(grainValue), 1);
   ```
 
   Output is centered around zero (mean of `length(vec2(u, v))` for uniform

package/dist/index.cjs

@@ -31,15 +31,16 @@ __export(index_exports, {
   displace: () => displace,
   dither: () => dither,
   elapsedTime: () => elapsedTime,
-  filmGrain: () => filmGrain,
   fractalNoise: () => fractalNoise,
   getReducedMotionPolicy: () => getReducedMotionPolicy,
   getReducedMotionTimeScale: () => getReducedMotionTimeScale,
+  grain: () => grain,
   mixColor: () => mixColor,
   oklabToLinearSrgb: () => oklabToLinearSrgb,
   oklchToLinearSrgb: () => oklchToLinearSrgb,
   parseColorString: () => parseColorString,
   quantize: () => quantize,
+  resetRendererClock: () => resetRendererClock,
   setReducedMotionPolicy: () => setReducedMotionPolicy,
   signedDistanceFieldCircle: () => signedDistanceFieldCircle,
   simplexNoise: () => simplexNoise,
@@ -719,25 +720,55 @@ function cursorRipple(p, center, opts = {}) {
   return wave.mul(amplitude).mul(decay);
 }
 
-// src/primitives/film-grain/film-grain.ts
+// src/runtime/clock/reset-clock.ts
+function getNodeFrame(renderer) {
+  const candidate = renderer;
+  if (!(typeof candidate === "object" && candidate !== null && "_nodes" in candidate)) {
+    return void 0;
+  }
+  const nodes = candidate._nodes;
+  if (!(typeof nodes === "object" && nodes !== null && "nodeFrame" in nodes)) {
+    return void 0;
+  }
+  const frame = nodes.nodeFrame;
+  if (typeof frame !== "object" || frame === null) return void 0;
+  return frame;
+}
+function resetRendererClock(renderer) {
+  const nodeFrame = getNodeFrame(renderer);
+  if (!nodeFrame) return;
+  nodeFrame.time = 0;
+  nodeFrame.deltaTime = 0;
+  nodeFrame.lastTime = void 0;
+}
+
+// src/primitives/grain/grain.ts
 var import_tsl19 = require("three/tsl");
-function filmGrain(intensity, timeOffset = 0) {
+function grain(intensity, timeOffset = 0) {
   const pixel = import_tsl19.screenCoordinate.xy.floor();
-  const seed = pixel.x.toUint().mul(1973).add(pixel.y.toUint().mul(9277)).add((0, import_tsl19.mul)(timeOffset, 26699).toUint());
+  const column = pixel.x.toUint();
+  const row = pixel.y.toUint();
+  const frameHash = (0, import_tsl19.hash)((0, import_tsl19.float)(timeOffset)).mul(16777215).toUint();
+  const rowHash = (0, import_tsl19.hash)(row.add(frameHash)).mul(16777215).toUint();
+  const seed = column.add(rowHash);
   return (0, import_tsl19.hash)(seed).sub(0.5).mul(intensity);
 }
 
 // src/primitives/dither/dither.ts
 var import_tsl20 = require("three/tsl");
-function hash21(coord) {
-  return (0, import_tsl20.fract)((0, import_tsl20.sin)((0, import_tsl20.dot)(coord, (0, import_tsl20.vec2)(12.9898, 78.233))).mul(43758.5453));
+function bayer2(coord) {
+  const cell = (0, import_tsl20.floor)(coord);
+  return (0, import_tsl20.fract)(cell.x.mul(0.5).add(cell.y.mul(cell.y).mul(0.75)));
+}
+function bayer4(coord) {
+  return bayer2(coord.mul(0.5)).mul(0.25).add(bayer2(coord));
+}
+function bayer8(coord) {
+  return bayer4(coord.mul(0.5)).mul(0.25).add(bayer2(coord));
 }
-function dither(color, coord, amount = 1 / 255) {
-  const pixelCoord = (0, import_tsl20.vec2)(coord);
-  const firstHash = hash21(pixelCoord);
-  const secondHash = hash21(pixelCoord.add((0, import_tsl20.vec2)(0.5, 0.5)));
-  const triangularNoise = firstHash.sub(secondHash).mul(0.5);
-  return (0, import_tsl20.vec3)(color).add(triangularNoise.mul(amount));
+function dither(color, amount = 1 / 255) {
+  const threshold = bayer8((0, import_tsl20.vec2)(import_tsl20.screenCoordinate.xy)).sub(0.5);
+  return (0, import_tsl20.vec4)((0, import_tsl20.vec3)(color).add(threshold.mul(amount)), (0, import_tsl20.vec4)(color).a);
 }
 
 // src/runtime/visibility/visibility.ts
@@ -818,7 +849,7 @@ var FrameScheduler = class {
   // Reference-counted idle voting. The scheduler is idle only when at least
   // one component has voted idle AND no component has voted animated. This
   // prevents a static component (e.g. LinearGradient speed=0) from halting
-  // the loop while an animated overlay (e.g. FilmGrain) is still running.
+  // the loop while an animated overlay (e.g. Grain) is still running.
   idleVotes = 0;
   animatedVotes = 0;
   /** True when all participating components prefer idle and none need animation. */
@@ -953,15 +984,16 @@ var FrameScheduler = class {
   displace,
   dither,
   elapsedTime,
-  filmGrain,
   fractalNoise,
   getReducedMotionPolicy,
   getReducedMotionTimeScale,
+  grain,
   mixColor,
   oklabToLinearSrgb,
   oklchToLinearSrgb,
   parseColorString,
   quantize,
+  resetRendererClock,
   setReducedMotionPolicy,
   signedDistanceFieldCircle,
   simplexNoise,