@call-me-sensei/toonlab 0.4.19 → 0.4.21

package/src/styles/sceneStyleRuntime.js

@@ -13,6 +13,11 @@ import { createSkyParams } from '../sky/skyParams.js';
 import { environmentCloudShadow } from '../sky/cloudShadow.js';
 import { PRESETS as SKY_PRESETS } from '../sky/skyPresets.js';
 import { resolveSkySystemStyleSnapshot } from '../sky/skyStyleSnapshots.js';
+import {
+  azimuthOf,
+  elevationOf,
+  sunDirectionAt,
+} from '../sky/sunDriver.js';
 import { applyStyleBundle } from './styleApplication.js';
 import { applySceneQualityProfile } from './sceneQualityApplication.js';
 import { createStyleTarget } from './styleAdapters.js';
@@ -51,6 +56,22 @@ function sunDirectionFromFrame(frame) {
   return [x / length, y / length, z / length];
 }
 
+function alignSkyCloudShadowToLighting(sky, direction) {
+  sky?.setCloudShadowDirection?.(direction);
+}
+
+function skySunPoseForFrame(skyParams, frame) {
+  const direction = sunDirectionAt(
+    frame.hour / 24,
+    skyParams.time?.latitude,
+    skyParams.time?.azimuth,
+  );
+  return {
+    azimuth: azimuthOf(direction),
+    elevation: elevationOf(direction),
+  };
+}
+
 async function applySkySystemBundle(
   sky,
   settings,
@@ -62,7 +83,12 @@ async function applySkySystemBundle(
   const coordinated = {
     sun: {
       ...current.sun,
-      direction: sunDirectionFromFrame(lightingFrame),
+      // The SkySystem's sun must follow its real celestial arc so its Dawn,
+      // Day, Sunset, and Night palette weights can see the sun cross the
+      // horizon. The gameplay lighting frame deliberately keeps a blue night
+      // key above the ground; feeding that direction into the sky made every
+      // visible dome render as daytime cyan.
+      ...skySunPoseForFrame(current, lightingFrame),
     },
     time: {
       ...current.time,
@@ -87,6 +113,7 @@ async function applySkySystemBundle(
       ...(snapshot ? { style: snapshot.cloudStyle } : {}),
     },
   }));
+  alignSkyCloudShadowToLighting(sky, sunDirectionFromFrame(lightingFrame));
 }
 
 function lightingRequestsShadows(settings) {
@@ -341,7 +368,14 @@ export function createSceneStyleRuntime({
       shadows: {
         enabled: shadowsEnabled,
         native: renderer?.shadowMap?.enabled === true,
-        sharedPass: Boolean(shadowPass?.shadowTexture),
+        // `sharedPass` used to be `Boolean(shadowPass?.shadowTexture)`, which
+        // is true as soon as the pass allocates a target — so a scene with no
+        // shadow-casting sun, or no caster, reported healthy shadows and
+        // shipped with none (D19-041). It now reflects whether the pass has
+        // actually drawn casters into a published map, and `sharedPassHealth`
+        // says why not.
+        sharedPass: shadowPass?.health?.ok === true,
+        sharedPassHealth: shadowPass?.health ?? null,
         updatesPerSecond: qualityProfile.quality.shadows.maxUpdatesPerSecond,
       },
       sky: activeSky ? {
@@ -815,12 +849,25 @@ export function createSceneStyleRuntime({
       if (isSkySystem(activeSky)) {
         activeSky.setTimeOfDay(frame.hour, {
           autoAdvanceSecondsPerDay: 0,
-          sunDirection: sunDirectionFromFrame(frame),
         });
+        alignSkyCloudShadowToLighting(activeSky, sunDirectionFromFrame(frame));
       }
       return frame;
     },
 
+    setSunDirection(direction = null) {
+      const resolved = lighting.setSunDirection(direction);
+      if (isSkySystem(activeSky)) {
+        activeSky.setTimeOfDay(lighting.frame.hour, {
+          autoAdvanceSecondsPerDay: 0,
+          sunDirection: resolved,
+        });
+        alignSkyCloudShadowToLighting(activeSky, resolved);
+      }
+      shadowPass?.invalidate?.();
+      return resolved;
+    },
+
     /**
      * Replaces the physical SkySystem condition while preserving the active
      * style bundle's sky/cloud presentation and coordinated lighting frame.
@@ -842,8 +889,8 @@ export function createSceneStyleRuntime({
         } else {
           activeSky.setTimeOfDay(frame.hour, {
             autoAdvanceSecondsPerDay: 0,
-            sunDirection: sunDirectionFromFrame(frame),
           });
+          alignSkyCloudShadowToLighting(activeSky, sunDirectionFromFrame(frame));
         }
       }
       return activeSky.toParams?.() ?? null;

package/src/styles/styleAdapters.js

@@ -2,7 +2,7 @@ import { applyToonShader } from '../toon/toonMaterialAdapter.js';
 import { applyEnvironmentShader } from '../environment/environmentMaterialAdapter.js';
 import {
   applyUrbanPropShaderProfile,
-  classifyUrbanPropSurface,
+  classifyUrbanMaterial,
   createUrbanAnimePropMaterial,
   createUrbanAnimePropNodeMaterial,
   createUrbanPropShaderControls,
@@ -49,8 +49,19 @@ function applyManufacturedSurface(root, settings, { target } = {}) {
   root?.traverse?.((object) => {
     if (!object?.isMesh || !object.material) return;
     const materials = Array.isArray(object.material) ? object.material : [object.material];
+    // `classifyUrbanPropSurface` returns a PROFILE ID string, and the adapter's
+    // `classification` parameter takes a classification OBJECT. Passing the
+    // string meant `classificationForAdapter` saw a non-object, found no
+    // `surface` either, and fell all the way through to its
+    // `paintedMetal` default — so every material converted through the
+    // documented style-bundle path resolved to one profile regardless of its
+    // semantic role. §8 requires the opposite ("every material receives
+    // semantic ToonLab roles before the Manufactured Surface shader is
+    // applied"), and the manifest written by
+    // `applyManufacturedMaterialManifest` was reaching this call and then
+    // being discarded one frame later. See D19-080.
     const next = materials.map((material) => createMaterial(material, {
-      classification: classifyUrbanPropSurface(object, material),
+      classification: classifyUrbanMaterial(object, material),
       controls,
     }));
     object.material = Array.isArray(object.material) ? next : next[0];

package/src/styles/styleBundle.js

@@ -665,7 +665,7 @@ export async function fetchStyleBundle(ref, {
   if (firstParty) {
     return { document: firstParty, settings: resolveStyleBundleSettings(firstParty) };
   }
-  const url = /^https?:\/\//.test(ref)
+  const url = /^(?:https?:\/\/|\/)/.test(ref)
     ? ref
     : `${baseUrl.replace(/\/+$/, '')}/api/v1/bundles/${encodeURIComponent(ref)}`;
   const response = await fetchImpl(url, { headers: { accept: 'application/json' } });

package/src/texgen/evaluateTexture.js

@@ -10,7 +10,7 @@
 // color grading, glow, and all PBR derivation keep working on top. Decoding
 // stays the caller's job so this module remains DOM-free.
 
-import { hashCombine } from '../rockgen/noise/prng.js';
+import { hash3u, hashCombine } from '../rockgen/noise/prng.js';
 import { periodicFbm2 } from './noise2.js';
 import { compileTextureLayer } from './textureGenerators.js';
 import { createTextureSettings } from './textureSettings.js';
@@ -90,6 +90,15 @@ function overlayOp(a, b) {
   return a < 0.5 ? 2 * a * b : 1 - 2 * (1 - a) * (1 - b);
 }
 
+/**
+ * Independent [0, 1) draw from a pattern cell id. The legacy per-cell tint read
+ * two overlapping 16-bit slices of the same hash for hue and value, which tied a
+ * cell's hue to its brightness; a fresh salted hash per channel breaks that.
+ */
+function cellUnit(id, salt) {
+  return hash3u(salt, id | 0, (id >>> 16) | 0, 0) / 4294967296;
+}
+
 function blendHeight(mode, h, d) {
   switch (mode) {
     case 'add': return clamp01(h + (d - 0.5));
@@ -356,6 +365,12 @@ export async function evaluateTextureMaps(rawSettings, {
   const emissive = settings.emissive;
   const jitterSeed = hashCombine(seed, 0x11a77);
   const hueSeed = hashCombine(seed, 0x22b33);
+  // Per-cell tint variety (0 = legacy). Above 0 the cell's hue and value come
+  // from independent salted hashes and the painterly drift keeps running inside
+  // the cell, so N modules stop reading as N flat swatches (D19-057).
+  const cellVariety = Math.min(1, Math.max(0, color.jitterCellVariety ?? 0));
+  const cellValueSalt = hashCombine(seed, 0x33c1e);
+  const cellHueSalt = hashCombine(seed, 0x44d2f);
   const jitterScale = Math.max(2, Math.round(color.jitterScale));
   const cavityTint = toLinear(color.cavityTint);
   const sheenTint = toLinear(color.sheenTint);
@@ -443,7 +458,13 @@ export async function evaluateTextureMaps(rawSettings, {
         if (color.jitterValue > 0) {
           let jn;
           if (color.jitterCells && baseCell !== null) {
-            jn = ((baseCell >>> 8) & 0xffff) / 65536;
+            jn = cellVariety > 0
+              ? cellUnit(baseCell, cellValueSalt)
+              : ((baseCell >>> 8) & 0xffff) / 65536;
+            if (cellVariety > 0) {
+              const drift = periodicFbm2(jitterSeed, u * jitterScale, v * jitterScale, jitterScale, jitterScale, 2, 0.5) * 0.5 + 0.5;
+              jn = clamp01(jn + (drift - 0.5) * cellVariety * 0.6);
+            }
           } else {
             jn = periodicFbm2(jitterSeed, u * jitterScale, v * jitterScale, jitterScale, jitterScale, 2, 0.5) * 0.5 + 0.5;
           }
@@ -458,7 +479,13 @@ export async function evaluateTextureMaps(rawSettings, {
       if (color.jitterHue > 0) {
         let hn;
         if (color.jitterCells && baseCell !== null) {
-          hn = (baseCell & 0xffff) / 65536;
+          hn = cellVariety > 0
+            ? cellUnit(baseCell, cellHueSalt)
+            : (baseCell & 0xffff) / 65536;
+          if (cellVariety > 0) {
+            const drift = periodicFbm2(hueSeed, u * jitterScale, v * jitterScale, jitterScale, jitterScale, 2, 0.5) * 0.5 + 0.5;
+            hn = clamp01(hn + (drift - 0.5) * cellVariety * 0.6);
+          }
         } else {
           hn = periodicFbm2(hueSeed, u * jitterScale, v * jitterScale, jitterScale, jitterScale, 2, 0.5) * 0.5 + 0.5;
         }

package/src/texgen/textureGenerators.js

@@ -123,19 +123,49 @@ function makeCellular(project) {
 // Grid patterns (bricks, tiles, checker, weave, ...)
 // ---------------------------------------------------------------------------
 
-/** Distance-to-edge bevel profile for rectangular cells. */
-function faceProfile(lu, lv, gap, bevel) {
-  const d = Math.min(lu, 1 - lu, lv, 1 - lv);
-  const g = gap * 0.5;
-  return smoothstep(g, g + Math.max(0.004, bevel), d);
+/**
+ * Distance-to-edge bevel profile for rectangular cells.
+ *
+ * `gap` and `bevel` are cell-local fractions, so a non-square cell (a plank,
+ * a 200x100 subway tile, a clapboard) would otherwise get a joint whose world
+ * width differs per axis by the cell aspect ratio. `sx`/`sy` scale the joint
+ * per axis so an elongated module can carry an even mortar/groove line;
+ * authors drive them from the layer's existing `stretchX`/`stretchY` fields.
+ *
+ * At sx = sy = 1 this is exactly the original single-axis form: smoothstep is
+ * monotonic, so min(smoothstep(du), smoothstep(dv)) === smoothstep(min(du, dv)).
+ */
+function faceProfile(lu, lv, gap, bevel, sx = 1, sy = 1) {
+  const du = Math.min(lu, 1 - lu);
+  const dv = Math.min(lv, 1 - lv);
+  const gu = gap * 0.5 * sx;
+  const gv = gap * 0.5 * sy;
+  const bu = Math.max(0.004, bevel * sx);
+  const bv = Math.max(0.004, bevel * sy);
+  return Math.min(
+    smoothstep(gu, gu + bu, du),
+    smoothstep(gv, gv + bv, dv),
+  );
+}
+
+/**
+ * Joint anisotropy from a layer's stretch fields (1 = isotropic). The clamp
+ * mirrors the schema range for `stretchX`/`stretchY`; at 0.125 a module may run
+ * 8:1 (a 1.6 m deck board in a 200 mm run) and still carry an even joint.
+ */
+function jointAspect(params) {
+  const sx = Number.isFinite(params.stretchX) ? Math.min(16, Math.max(0.125, params.stretchX)) : 1;
+  const sy = Number.isFinite(params.stretchY) ? Math.min(16, Math.max(0.125, params.stretchY)) : 1;
+  return { sx, sy };
 }
 
 function compileBricks(params, seed, offsetMode) {
-  const cols = intIn(params.columns ?? 4, 1, 64, 4);
-  const rows = intIn(params.rows ?? 8, 1, 64, 8);
+  const cols = intIn(params.columns ?? 4, 1, 256, 4);
+  const rows = intIn(params.rows ?? 8, 1, 256, 8);
   const gap = Math.min(0.4, Math.max(0, params.gap ?? 0.06));
   const bevel = Math.min(0.5, Math.max(0, params.bevel ?? 0.12));
   const variation = clamp01(params.cellVariation ?? 0.35);
+  const { sx, sy } = jointAspect(params);
   return (u, v) => {
     const y = v * rows;
     const row = Math.floor(y);
@@ -143,14 +173,14 @@ function compileBricks(params, seed, offsetMode) {
     const x = u * cols + shift;
     const col = Math.floor(x);
     const id = hash3u(seed, ((col % cols) + cols) % cols, ((row % rows) + rows) % rows, 0);
-    const value = faceProfile(fract(x), fract(y), gap, bevel);
+    const value = faceProfile(fract(x), fract(y), gap, bevel, sx, sy);
     return { v: withCellVariation(value, id, variation, seed), cell: id };
   };
 }
 
 function compileChecker(params, seed) {
-  const cols = intIn(params.columns ?? 4, 1, 64, 4);
-  const rows = intIn(params.rows ?? 4, 1, 64, 4);
+  const cols = intIn(params.columns ?? 4, 1, 256, 4);
+  const rows = intIn(params.rows ?? 4, 1, 256, 4);
   return (u, v) => {
     const x = Math.floor(u * cols);
     const y = Math.floor(v * rows);
@@ -160,21 +190,21 @@ function compileChecker(params, seed) {
 }
 
 function compileGrid(params) {
-  const cols = intIn(params.columns ?? 8, 1, 64, 8);
-  const rows = intIn(params.rows ?? 8, 1, 64, 8);
+  const cols = intIn(params.columns ?? 8, 1, 256, 8);
+  const rows = intIn(params.rows ?? 8, 1, 256, 8);
   const gap = Math.min(0.4, Math.max(0.005, params.gap ?? 0.06));
   const bevel = Math.min(0.5, Math.max(0.004, params.bevel ?? 0.06));
+  const { sx, sy } = jointAspect(params);
   return (u, v) => {
     const lu = fract(u * cols);
     const lv = fract(v * rows);
-    const d = Math.min(lu, 1 - lu, lv, 1 - lv);
-    return { v: smoothstep(gap * 0.5, gap * 0.5 + bevel, d), cell: null };
+    return { v: faceProfile(lu, lv, gap, bevel, sx, sy), cell: null };
   };
 }
 
 function compileStripes(params, seed) {
-  const cols = intIn(params.columns ?? 8, 1, 64, 8);
-  const rows = intIn(params.rows ?? 8, 1, 64, 8);
+  const cols = intIn(params.columns ?? 8, 1, 256, 8);
+  const rows = intIn(params.rows ?? 8, 1, 256, 8);
   const variation = clamp01(params.cellVariation ?? 0);
   return (u, v) => {
     const y = v * rows;
@@ -197,8 +227,8 @@ function compileStripes(params, seed) {
 }
 
 function compileChevron(params) {
-  const cols = intIn(params.columns ?? 8, 1, 64, 8);
-  const rows = intIn(params.rows ?? 8, 1, 64, 8);
+  const cols = intIn(params.columns ?? 8, 1, 256, 8);
+  const rows = intIn(params.rows ?? 8, 1, 256, 8);
   return (u, v) => {
     const zig = Math.abs(fract(v * rows) * 2 - 1);
     const t = fract(u * cols + zig);
@@ -207,8 +237,8 @@ function compileChevron(params) {
 }
 
 function compileWeave(params, seed) {
-  const cols = intIn(params.columns ?? 10, 1, 64, 10);
-  const rows = intIn(params.rows ?? 10, 1, 64, 10);
+  const cols = intIn(params.columns ?? 10, 1, 256, 10);
+  const rows = intIn(params.rows ?? 10, 1, 256, 10);
   const gap = Math.min(0.45, Math.max(0.02, params.gap ?? 0.16));
   return (u, v) => {
     const x = u * cols;
@@ -231,8 +261,8 @@ function compileWeave(params, seed) {
 }
 
 function compileBasketWeave(params, seed) {
-  const cols = intIn(params.columns ?? 6, 1, 48, 6);
-  const rows = intIn(params.rows ?? 6, 1, 48, 6);
+  const cols = intIn(params.columns ?? 6, 1, 256, 6);
+  const rows = intIn(params.rows ?? 6, 1, 256, 6);
   const gap = Math.min(0.4, Math.max(0, params.gap ?? 0.08));
   const bevel = Math.min(0.5, Math.max(0.01, params.bevel ?? 0.1));
   const slats = 3;
@@ -257,7 +287,7 @@ function compileBasketWeave(params, seed) {
 }
 
 function compileHex(params, seed) {
-  const cols = intIn(params.columns ?? 6, 1, 48, 6);
+  const cols = intIn(params.columns ?? 6, 1, 256, 6);
   // A staggered lattice with 2:sqrt(3) aspect produces regular hexagons
   // out of plain nearest-center Voronoi. Rows derive from columns so the
   // lattice stays periodic in the unit tile.
@@ -299,8 +329,8 @@ function compileHex(params, seed) {
 }
 
 function compileScales(params, seed) {
-  const cols = intIn(params.columns ?? 8, 1, 48, 8);
-  const rows = intIn(params.rows ?? 12, 1, 64, 12);
+  const cols = intIn(params.columns ?? 8, 1, 256, 8);
+  const rows = intIn(params.rows ?? 12, 1, 256, 12);
   const variation = clamp01(params.cellVariation ?? 0.25);
   return (u, v) => {
     // Staggered rows of overlapping shingles: the row above clips the one
@@ -328,8 +358,8 @@ function compileScales(params, seed) {
 }
 
 function compileDots(params, seed) {
-  const cols = intIn(params.columns ?? 8, 1, 64, 8);
-  const rows = intIn(params.rows ?? 8, 1, 64, 8);
+  const cols = intIn(params.columns ?? 8, 1, 256, 8);
+  const rows = intIn(params.rows ?? 8, 1, 256, 8);
   const radius = Math.min(0.48, Math.max(0.02, 0.5 - (params.gap ?? 0.18)));
   const soft = Math.min(0.5, Math.max(0.01, params.bevel ?? 0.08));
   const jitter = clamp01(params.cellJitter ?? 0);
@@ -383,7 +413,7 @@ function compileMarble(params, seed) {
   const { px, py } = periods(params);
   const octaves = intIn(params.detail ?? 4, 1, 8, 4);
   const sharp = 0.5 + (params.grain ?? 0.5) * 6;
-  const veins = intIn(params.rings ?? 3, 1, 24, 3);
+  const veins = intIn(params.rings ?? 3, 1, 128, 3);
   return (u, v) => {
     const turb = periodicTurbulence2(seed, u * px, v * py, px, py, octaves, 0.55);
     const phase = fract(u * veins + turb * 1.35);
@@ -394,7 +424,7 @@ function compileMarble(params, seed) {
 
 function compileWoodGrain(params, seed) {
   const { px, py } = periods(params);
-  const rings = intIn(params.rings ?? 6, 1, 32, 6);
+  const rings = intIn(params.rings ?? 6, 1, 128, 6);
   const grain = clamp01(params.grain ?? 0.5);
   const octaves = intIn(params.detail ?? 3, 1, 8, 3);
   const streakSeed = hashCombine(seed, 0xbeef);
@@ -441,7 +471,9 @@ function compileFlat() {
 
 const NOISE_USES = ['scale', 'detail', 'detailGain', 'stretchX', 'stretchY', 'warp', 'warpScale'];
 const CELL_USES = ['scale', 'stretchX', 'stretchY', 'cellJitter', 'cellVariation', 'edgeWidth', 'warp', 'warpScale'];
-const GRID_USES = ['columns', 'rows', 'gap', 'bevel', 'cellVariation', 'warp', 'warpScale'];
+// stretchX/stretchY scale the joint width per axis so non-square modules
+// (planks, 200x100 subway tile) can carry an even mortar line.
+const GRID_USES = ['columns', 'rows', 'gap', 'bevel', 'cellVariation', 'stretchX', 'stretchY', 'warp', 'warpScale'];
 
 export const TEXTURE_GENERATORS = Object.freeze({
   fbm: { label: 'Soft noise (fbm)', category: 'noise', uses: NOISE_USES, compile: makeNoise(periodicFbm2, true) },
@@ -484,7 +516,7 @@ export const TEXTURE_GENERATORS = Object.freeze({
   tiles: { label: 'Tiles (stacked)', category: 'pattern', uses: GRID_USES, compile: (p, s) => compileBricks(p, s, 'stacked') },
   hex: { label: 'Hex tiles', category: 'pattern', uses: ['columns', 'gap', 'bevel', 'cellVariation', 'warp', 'warpScale'], compile: compileHex },
   checker: { label: 'Checker', category: 'pattern', uses: ['columns', 'rows', 'warp', 'warpScale'], compile: compileChecker },
-  grid: { label: 'Grid lines', category: 'pattern', uses: ['columns', 'rows', 'gap', 'bevel', 'warp', 'warpScale'], compile: compileGrid },
+  grid: { label: 'Grid lines', category: 'pattern', uses: ['columns', 'rows', 'gap', 'bevel', 'stretchX', 'stretchY', 'warp', 'warpScale'], compile: compileGrid },
   stripes: { label: 'Stripes', category: 'pattern', uses: ['columns', 'rows', 'cellVariation', 'warp', 'warpScale'], compile: compileStripes },
   chevron: { label: 'Chevron zigzag', category: 'pattern', uses: ['columns', 'rows', 'warp', 'warpScale'], compile: compileChevron },
   weave: { label: 'Cloth weave', category: 'pattern', uses: ['columns', 'rows', 'gap', 'warp', 'warpScale'], compile: compileWeave },

package/src/texgen/textureSettings.js

@@ -34,22 +34,31 @@ const generatorField = (defaultValue, description) => sel(
 // generator reads is declared in TEXTURE_GENERATORS[id].uses — UIs filter
 // on that so only meaningful sliders show.
 const layerParamFields = ({ advancedShape = false } = {}) => [
-  num('scale', 'Scale', 1, 64, 1, 6, 'Feature cells across the tile. Higher = finer features.'),
+  // Feature size is a property of the (scale, world tile) pairing, not of the
+  // map: a tile bound at T metres resolves features of T / scale. At the old
+  // cap of 64 a 2.4 m deck tile could not describe anything finer than 3.8 cm,
+  // which is coarser than plank grain, asphalt aggregate or paver texture — the
+  // cap, not the resolution, was setting the floor on feature size.
+  num('scale', 'Scale', 1, 256, 1, 6, 'Feature cells across the tile. Higher = finer features. At a 2 m world tile, 200 resolves 1 cm detail.'),
   bool('rotate90', 'Rotate 90°', false, 'Turns the pattern a quarter turn (planks run vertical, strata run horizontal). Tiling stays exact.', { advanced: true }),
   num('detail', 'Detail octaves', 1, 8, 1, 4, 'Fractal octaves layered into the noise.'),
   num('detailGain', 'Detail strength', 0.15, 0.85, 0.01, 0.5, 'How much each finer octave contributes.', { advanced: true }),
-  num('stretchX', 'Stretch X', 0.25, 8, 0.05, 1, 'Horizontal anisotropy (brushed metal, wood planks).', { advanced: true }),
-  num('stretchY', 'Stretch Y', 0.25, 8, 0.05, 1, 'Vertical anisotropy (drips, strata, fibers).', { advanced: true }),
+  // Naming note: these multiply the FEATURE PERIOD COUNT on each axis, so
+  // raising one makes features finer on that axis and therefore elongated
+  // along the other. stretchX > 1 reads as vertical streaks, not horizontal
+  // ones. The old labels claimed the opposite.
+  num('stretchX', 'X frequency', 0.125, 16, 0.05, 1, 'Multiplies feature periods across U. Higher = finer in U, so features elongate along V and read as VERTICAL streaks (drips, fibers, strata). On grid patterns it instead widens the joint on the U axis.', { advanced: true }),
+  num('stretchY', 'Y frequency', 0.125, 16, 0.05, 1, 'Multiplies feature periods down V. Higher = finer in V, so features elongate along U and read as HORIZONTAL streaks (brushed metal, boards lying across the frame). On grid patterns it instead widens the joint on the V axis.', { advanced: true }),
   num('warp', 'Warp', 0, 1, 0.01, 0, 'Domain warp: melts straight features into organic meanders.'),
   num('warpScale', 'Warp scale', 1, 32, 1, 3, 'Frequency of the warp field.', { advanced: true }),
-  num('columns', 'Columns', 1, 64, 1, 4, 'Pattern cells across the tile.', { advanced: advancedShape }),
-  num('rows', 'Rows', 1, 64, 1, 8, 'Pattern cells down the tile.', { advanced: advancedShape }),
+  num('columns', 'Columns', 1, 256, 1, 4, 'Pattern cells across the tile.', { advanced: advancedShape }),
+  num('rows', 'Rows', 1, 256, 1, 8, 'Pattern cells down the tile.', { advanced: advancedShape }),
   num('gap', 'Gap width', 0, 0.4, 0.005, 0.06, 'Mortar/groove width between pattern cells.', { advanced: advancedShape }),
   num('bevel', 'Bevel', 0, 0.5, 0.005, 0.12, 'Edge ramp from groove up to the cell face.', { advanced: advancedShape }),
   num('cellJitter', 'Cell jitter', 0, 1, 0.01, 1, 'Randomizes cell centers: 0 = perfect grid, 1 = organic.', { advanced: true }),
   num('cellVariation', 'Cell variation', 0, 1, 0.01, 0.35, 'Per-cell brightness variance (brick tint shifts).'),
   num('edgeWidth', 'Edge width', 0.01, 0.6, 0.005, 0.12, 'Width of cracks / caustic filaments / speckle chips.', { advanced: advancedShape }),
-  num('rings', 'Rings / veins', 1, 32, 1, 6, 'Ring or vein count across the tile (wood, marble).', { advanced: advancedShape }),
+  num('rings', 'Rings / veins', 1, 128, 1, 6, 'Ring or vein count across the tile (wood, marble).', { advanced: advancedShape }),
   num('grain', 'Grain', 0, 1, 0.01, 0.5, 'Streak amount (wood) or vein sharpness (marble).', { advanced: advancedShape }),
 ];
 
@@ -115,8 +124,16 @@ const RAW_FIELD_SCHEMA = {
     num('rampSmooth', 'Band smoothness', 0, 1, 0.01, 1, '1 = smooth gradient, 0 = hard cel bands between the five stops.'),
     num('jitterHue', 'Hue jitter', 0, 0.5, 0.005, 0.04, 'Painterly hue drift across the surface.'),
     num('jitterValue', 'Value jitter', 0, 0.5, 0.005, 0.08, 'Painterly brightness drift across the surface.'),
-    num('jitterScale', 'Jitter scale', 2, 64, 1, 24, 'Frequency of the painterly drift.', { advanced: true }),
-    bool('jitterCells', 'Jitter per cell', false, 'Applies drift per pattern cell (per brick / plank / scale) instead of smoothly.'),
+    num('jitterScale', 'Jitter scale', 2, 256, 1, 24, 'Frequency of the painterly drift.', { advanced: true }),
+    bool('jitterCells', 'Jitter per cell', false, 'Applies drift per pattern cell (per brick / plank / scale) instead of smoothly. Reads the BASE layer\'s cell id, so it is a no-op when the base pattern has no cells.'),
+    // A periodic tile can only ever hold `columns * rows` cell ids, and the
+    // legacy path derived hue and value from two overlapping 16-bit slices of
+    // the same hash — so a 4x4 paver tile showed 16 flat tints whose hue and
+    // value moved together. Raising this decorrelates hue from value with
+    // independent hashes and keeps the painterly drift alive inside each cell,
+    // so modules stop reading as N flat swatches. 0 keeps the legacy result
+    // byte-for-byte.
+    num('jitterCellVariety', 'Per-cell variety', 0, 1, 0.01, 0, 'Enriches per-cell drift: decorrelates each cell\'s hue from its value and keeps painterly drift running inside the cell, so a tile with N modules stops reading as N flat tints. 0 = legacy flat per-cell tint.'),
     num('cavity', 'Cavity shading', 0, 1, 0.01, 0.35, 'Darkens crevices toward the cavity tint — the hand-painted occlusion read.'),
     col('cavityTint', 'Cavity tint', [0.13, 0.09, 0.08], 'Color the crevices sink toward.', { advanced: true }),
     num('sheen', 'Ridge sheen', 0, 1, 0.01, 0.18, 'Screens the sheen tint over ridges and edges — worn highlight.'),

package/src/toon/toonSettings.js

@@ -77,6 +77,100 @@ export const TOON_PRESET_IDS = Object.freeze({
 
 const DEFAULT_TOON_PRESET_SETTINGS = Object.freeze({});
 
+/**
+ * The Call Me Sensei house look, authored against premium anime-game character
+ * rendering rather than left at the library baseline.
+ *
+ * The baseline is deliberately conservative: it has to look sane on any imported
+ * GLB/VRM, so its outlines are thin, its speculars are near-off and its shadows
+ * are close to neutral. That produces a character who is *cel shaded* but whose
+ * material families all read the same — skin, cloth, leather and metal separate
+ * only by albedo. This preset is the opposite trade: it assumes a hero character
+ * under art direction and spends contrast on telling those families apart.
+ *
+ * Every value below is a deliberate delta from `DEFAULT_*_SETTINGS`; anything not
+ * listed is intentionally inherited. The three axes that carry the separation:
+ *
+ * 1. **Outline weight by role.** Contour is the single strongest anime material
+ *    cue. Costume and metal carry a heavy near-neutral line, hair carries a
+ *    weighty warm-dark line (the baseline's 0.00055 is invisible past two metres),
+ *    skin carries a thin warm line, and the face carries none at all — a line
+ *    across a cel-shaded face reads as dirt, not drawing.
+ * 2. **Specular by role.** Cloth stays matte, hair takes a broad anisotropic
+ *    band, and metal takes a tight bright hit. Leather is reached per-material
+ *    through `specular.sourceMaskMode: 'source'` plus a `toonSpecularMaskMap`,
+ *    because a fifth family cannot be expressed through roles alone.
+ * 3. **Coloured shadow families.** Shadows shift blue-violet and gain saturation
+ *    instead of just going dark, and the terminator gains a warmer, more
+ *    saturated transition band — the value grouping §4 asks for.
+ */
+const CALL_ME_SENSEI_TOON_PRESET_SETTINGS = Object.freeze({
+  // Slightly earlier, slightly tighter terminator so the light/shadow split is a
+  // drawn shape with a clean edge rather than a soft gradient.
+  celShade: Object.freeze({
+    bodyCelMidPoint: 0.04,
+    bodyCelSoftness: 0.036,
+  }),
+  // Occlusion under collars, chins, cuffs and hems is what stops a toon character
+  // reading as a decal on the plate.
+  contactShadow: Object.freeze({
+    faceStrength: 0.46,
+    strength: 0.62,
+  }),
+  hairHighlight: Object.freeze({
+    intensity: 0.22,
+    shadowFloor: 0.32,
+    sideBandPower: 2.2,
+    strandPower: 8,
+  }),
+  outline: Object.freeze({
+    defaultLightingMix: 0.22,
+    defaultMaxBrightness: 0.3,
+    defaultMinBrightness: 0.035,
+    defaultTintColor: [0.22, 0.21, 0.28],
+    defaultWidth: 0.0024,
+    hairLightingMix: 0.1,
+    hairMaxBrightness: 0.42,
+    hairMinBrightness: 0.07,
+    hairTintColor: [0.3, 0.24, 0.27],
+    hairWidth: 0.0016,
+    metalLightingMix: 0.2,
+    metalMaxBrightness: 0.32,
+    metalTintColor: [0.2, 0.2, 0.26],
+    metalWidth: 0.0022,
+    skinTintColor: [0.55, 0.3, 0.3],
+    skinWidth: 0.0011,
+  }),
+  rimLight: Object.freeze({
+    defaultIntensity: 0.16,
+    defaultTintColor: [0.79, 0.88, 1],
+    hairIntensity: 0.3,
+    skinIntensity: 0.15,
+  }),
+  // Cloth stays matte (a low, broad, late-onset lobe), hair broadens, metal takes
+  // a bright tight hit. `sourceMaskMode: 'source'` is what lets a single costume
+  // role still contain a leather family: give that material a
+  // `userData.toonSpecularMaskMap` and it gets the highlight, its neighbours do not.
+  specular: Object.freeze({
+    defaultIntensity: 0.09,
+    defaultMidPoint: 0.74,
+    defaultPower: 48,
+    hairIntensity: 0.24,
+    hairPower: 44,
+    metalIntensity: 0.5,
+    sourceMaskMode: 'source',
+  }),
+  // Shadows move blue-violet and gain chroma rather than only losing value; the
+  // terminator keeps a warmer, more saturated band against them.
+  shadowColor: Object.freeze({
+    selfShadowAreaHueOffset: -0.022,
+    selfShadowAreaSaturationBoost: 0.34,
+    selfShadowAreaValueMul: 0.63,
+    transitionAreaHueOffset: 0.018,
+    transitionAreaSaturationBoost: 0.5,
+  }),
+});
+
 export const TOON_SETTING_DEFAULTS = Object.freeze({
   alpha: DEFAULT_ALPHA_SETTINGS,
   averageShadow: DEFAULT_AVERAGE_SHADOW_SETTINGS,
@@ -470,9 +564,9 @@ const BUILT_IN_TOON_PRESETS = Object.freeze({
     settings: DEFAULT_TOON_PRESET_SETTINGS,
   }),
   [TOON_PRESET_IDS.callMeSensei]: Object.freeze({
-    description: 'Team-maintained house style preset. It starts identical to Default and can evolve separately.',
+    description: 'Team-maintained house style. Role-weighted outlines, per-role specular and coloured shadow families so skin, hair, cloth, leather and metal read as distinct materials.',
     label: 'Call Me Sensei',
-    settings: { ...DEFAULT_TOON_PRESET_SETTINGS },
+    settings: CALL_ME_SENSEI_TOON_PRESET_SETTINGS,
   }),
   [TOON_PRESET_IDS.showcase]: Object.freeze({
     description: 'Every optional feature turned on with demo values — a one-click way to see the full feature set. Not a production look.',