@call-me-sensei/toonlab 0.4.19 → 0.4.21

package/src/vegetation/stylizedTreeFoliage.js

@@ -156,6 +156,78 @@ export function traceLeafShapePath(ctx, shape, length, width, outline = null) {
       if (i === 0) ctx.moveTo(x, y);
       else ctx.lineTo(x, y);
     }
+  } else if (shape === 'palmate') {
+    // Acer palmatum. Seven deeply divided lobes, sinuses cutting almost to
+    // the petiole, each lobe lanceolate with a serrated margin.
+    //
+    // This is NOT a variant of 'maple' above: that outline is a five-point
+    // sugar-maple star with blunt lobes and shallow sinuses, which is a
+    // correct Acer saccharum and a wrong Acer palmatum. The Japanese maple's
+    // whole identity is that the crown reads as lace rather than as a mass of
+    // leaf blades, and at 85 mm the difference between a five-point star and
+    // a seven-lobe dissected leaf is the difference between the species.
+    // The fan is nearly a full circle: on a real A. palmatum the outer pair of
+    // lobes swings back past horizontal, almost touching the petiole, which is
+    // what gives the leaf its star read rather than a hand read. A narrow fan
+    // is the single most common way a stylized "maple" ends up looking like a
+    // palm frond instead.
+    const lobes = 7;
+    const spread = 4.9;                       // full fan, radians (~281 deg)
+    const sinus = 0.11;                       // sinus depth, as a radial fraction
+    const half = (spread / (lobes - 1)) * 0.34;
+    const steps = 10;                         // even → symmetric serration
+    let started = false;
+    const emit = (angle, radial) => {
+      const x = Math.sin(angle) * width * radial;
+      const y = -Math.cos(angle) * length * radial;
+      if (started) ctx.lineTo(x, y);
+      else { ctx.moveTo(x, y); started = true; }
+    };
+    for (let i = 0; i < lobes; i += 1) {
+      const axis = ((i / (lobes - 1)) * 2 - 1) * spread * 0.5;
+      for (let side = -1; side <= 1; side += 2) {
+        for (let k = 0; k <= steps; k += 1) {
+          // Left margin runs outward, right margin runs back in, so the
+          // outline stays a single continuous closed loop.
+          const step = side < 0 ? k : steps - k;
+          const t = step / steps;
+          // Lanceolate profile: pinched at the sinus, widest around 40% out,
+          // drawn to a point at the tip.
+          const body = Math.sin(Math.PI * Math.min(1, 0.08 + t * 0.9)) ** 0.62;
+          // Alternating teeth along the margin.
+          const tooth = step % 2 === 0 ? 1 : 0.74;
+          emit(axis + side * half * body * tooth, sinus + (0.5 - sinus) * t);
+        }
+      }
+    }
+  } else if (shape === 'needle-fascicle') {
+    // Pinus thunbergii. A black pine's foliage unit is a FASCICLE: two stiff
+    // needles bound at a common sheath, diverging into a narrow V. Drawing a
+    // pine from single 'needle' blades gives a scatter of loose hairs; the
+    // paired V is what makes a card read as pine rather than as fur, and it
+    // is also what carries the species' characteristic stiffness.
+    // Black pine needles are 6-12 cm long and about 1.5 mm across, held stiff
+    // and nearly parallel — the pair diverges by well under 20 deg. A wide V
+    // reads as a grass tussock, not as a conifer.
+    //
+    // The thickness is deliberately far above botanical scale. A card that is
+    // 0.5 m across renders about 40 px tall at the distance a garden pine is
+    // actually seen from, and a true-scale needle is then a quarter of a pixel:
+    // the mip chain averages it below the alpha cutoff and the whole card
+    // collapses into a soft lobed blob — which is exactly what the first
+    // version did, and it made the pine read as a broadleaf. Stylized conifers
+    // exaggerate needle width for the same reason hand-painted ones do.
+    const t = width * 0.23;
+    const reach = width * 0.17;
+    const sheathTop = length * 0.3;
+    ctx.moveTo(-t * 1.7, length * 0.5);
+    ctx.lineTo(-reach - t * 0.3, -length * 0.5);
+    ctx.lineTo(-reach + t * 0.3, -length * 0.48);
+    ctx.lineTo(-t * 0.3, sheathTop);
+    ctx.lineTo(t * 0.3, sheathTop);
+    ctx.lineTo(reach - t * 0.3, -length * 0.48);
+    ctx.lineTo(reach + t * 0.3, -length * 0.5);
+    ctx.lineTo(t * 1.7, length * 0.5);
   } else if (shape === 'gingko' || shape === 'fan') {
     // Fan: narrow stem base opening to a wide notched top edge.
     ctx.moveTo(0, length * 0.5);
@@ -173,9 +245,22 @@ export function traceLeafShapePath(ctx, shape, length, width, outline = null) {
 }
 
 export const LEAF_SHAPE_PRESETS = Object.freeze([
-  'teardrop', 'round', 'oak', 'maple', 'gingko', 'needle',
+  'teardrop', 'round', 'oak', 'maple', 'palmate', 'gingko', 'needle',
+  'needle-fascicle',
 ]);
 
+/**
+ * Shapes whose card is a needle spray rather than a broadleaf cluster.
+ *
+ * Needles are an order of magnitude longer than they are wide, and on a real
+ * shoot they radiate from the twig rather than facing every direction at
+ * once. Painting them with the broadleaf arrangement below gives a fuzzy
+ * felted disc; keying the arrangement off the shape keeps every existing
+ * broadleaf sprite byte-identical while letting a conifer card look like a
+ * conifer.
+ */
+export const NEEDLE_LEAF_SHAPES = Object.freeze(['needle', 'needle-fascicle']);
+
 export function createLeafSpriteTexture({
   size = 512,
   leafCount = 170,
@@ -202,6 +287,76 @@ export function createLeafSpriteTexture({
     ctx.restore();
   };
 
+  const needleSpray = NEEDLE_LEAF_SHAPES.includes(shape);
+
+  if (needleSpray) {
+    // A conifer card is not a scatter of organs over a disc. Needles are borne
+    // on SHOOTS: each year's growth is a short candle, and the fascicles stand
+    // out from that candle along its own axis. Distributing them over a disc
+    // and pointing each one at the card centre — the broadleaf arrangement —
+    // gives a sea-urchin starburst, which is what the first version of this
+    // card looked like. Building a handful of shoots and hanging needles off
+    // each one is what turns the card back into a bough.
+    // Enough shoots, started at enough different radii, that their needle
+    // masses OVERLAP. Six evenly spaced candles left visible sky between them
+    // and the card read as an asterisk of brushes; a real bough is a
+    // continuous mass with structure inside it, not a ring of separate
+    // brooms.
+    const shootCount = 9;
+    const shoots = Array.from({ length: shootCount }, (_, index) => ({
+      axis: (index / shootCount) * Math.PI * 2 + (rng() - 0.5) * 0.9,
+      base: size * (-0.02 + rng() * 0.14),
+      reach: size * (0.2 + rng() * 0.2),
+      // Shoots nearer the rim carry the crisp, bright silhouette needles.
+      lift: rng(),
+    }));
+    // Fewer, bolder fascicles. Packing the card with hundreds of hairline
+    // needles reads as felt once mipped; a stylized bough wants a countable
+    // number of confident strokes.
+    const perShoot = Math.max(5, Math.round((leafCount * 0.5) / shootCount));
+    const needles = [];
+    for (const shoot of shoots) {
+      for (let i = 0; i < perShoot; i += 1) {
+        // Along the candle, packed toward its outer half the way a real
+        // year's growth is.
+        const along = Math.pow(rng(), 0.72);
+        const radius = shoot.base + along * shoot.reach;
+        // Fascicles stand out from the shoot at a shallow angle, alternating
+        // to either side, so the candle keeps a visible axis.
+        const side = i % 2 === 0 ? 1 : -1;
+        const flare = (0.24 + rng() * 0.42) * side;
+        const lateral = (rng() - 0.5) * size * 0.07;
+        needles.push({
+          x: center + Math.cos(shoot.axis) * radius - Math.sin(shoot.axis) * lateral,
+          y: center + Math.sin(shoot.axis) * radius + Math.cos(shoot.axis) * lateral,
+          orientation: shoot.axis - Math.PI / 2 + flare,
+          depth: radius,
+          edgeT: Math.min(radius / (size * 0.4), 1),
+          pick: rng(),
+          spin: rng(),
+          shade: rng(),
+          lift: shoot.lift,
+        });
+      }
+    }
+    needles.sort((a, b) => a.depth - b.depth);
+    for (const needle of needles) {
+      const length = size * (0.24 + needle.pick * 0.16);
+      const width = length * (0.4 + needle.spin * 0.16);
+      const luminance = THREE.MathUtils.lerp(
+        0.46 + needle.shade * 0.2,
+        0.74 + needle.shade * 0.26,
+        Math.min(1, needle.edgeT * 0.7 + needle.lift * 0.4),
+      );
+      drawLeaf(needle.x, needle.y, length, width, needle.orientation, luminance);
+    }
+    const texture = new THREE.CanvasTexture(canvas);
+    texture.name = `ToonLabLeafSprite.${shape}`;
+    texture.colorSpace = THREE.NoColorSpace;
+    texture.anisotropy = 4;
+    return texture;
+  }
+
   const leaves = [];
   for (let i = 0; i < leafCount; i += 1) {
     const angle = rng() * Math.PI * 2;
@@ -231,6 +386,7 @@ export function createLeafSpriteTexture({
   });
 
   const texture = new THREE.CanvasTexture(canvas);
+  texture.name = `ToonLabLeafSprite.${shape}`;
   texture.colorSpace = THREE.NoColorSpace;
   texture.anisotropy = 4;
   return texture;
@@ -464,6 +620,31 @@ export function createTreeFoliageGeometry({
   sprayLayers = 3,
   spraySpread = 0.8,
   sprayThickness = 0.18,
+  // layered-sprays only. 0 (the default, and every historical tree) builds
+  // each spray disc ACROSS THE TWIG: the disc's thickness axis is the branch
+  // growth direction, so a twig rising at 50 deg carries a disc tilted at
+  // 50 deg. Summed over a few hundred tips that is a dome of randomly tilted
+  // discs — which is the correct read for most broadleaves.
+  //
+  // It is the wrong read for a tree whose identity IS horizontality. An Acer
+  // palmatum, a dogwood, a layered Japanese hornbeam: the leaf layer is flat
+  // WITH THE GROUND, not with the twig that carries it. 1 rotates each spray
+  // basis all the way to world horizontal, so every tuft becomes a flat plate
+  // however its twig is oriented, and the crown reads as stacked layers you
+  // can see between instead of a shell you cannot.
+  //
+  // Only the DISC is realigned. Placement along the twig (the tuft's offset
+  // from its attachment) still follows the branch, so foliage stays where the
+  // wood puts it and the skeleton keeps its authority over the silhouette.
+  plateAlignment = 0,
+  // Drops the OUTER edge of each spray disc, as a fraction of the disc's own
+  // radius, on a quadratic falloff from its centre. A perfectly flat plate is
+  // a machined shelf: it is what a Cornus controversa or an acacia reads as,
+  // and the reason a plated crown can look manufactured rather than grown.
+  // Real tiers sag under their own weight and their outer twigs hang, so the
+  // tier has a soft drooping edge instead of a cut one. 0 keeps the plate
+  // flat, which is every historical tree.
+  plateDroop = 0,
   whorlArms = 6,
   whorlRadius = 0.48,
   frondCount = 7,
@@ -741,6 +922,41 @@ export function createTreeFoliageGeometry({
         : new THREE.Vector3(0, 1, 0);
       const branchRight = new THREE.Vector3().crossVectors(growth, basisReference).normalize();
       const branchForward = new THREE.Vector3().crossVectors(branchRight, growth).normalize();
+      // The spray disc's own basis. At plateAlignment 0 these are exactly the
+      // branch vectors above and nothing moves; at 1 the disc normal is world
+      // up and the tuft is a horizontal plate. The blend is on the NORMAL, so
+      // partial values tilt the plate rather than shearing it.
+      const tuftPlateAlignment = THREE.MathUtils.clamp(
+        override?.plateAlignment ?? attachment.plateAlignment ?? plateAlignment,
+        0,
+        1,
+      );
+      const tuftPlateDroop = Math.max(
+        override?.plateDroop ?? attachment.plateDroop ?? plateDroop,
+        0,
+      );
+      let sprayNormal = growth;
+      let sprayRight = branchRight;
+      let sprayForward = branchForward;
+      if (tuftPlateAlignment > 0) {
+        const worldUp = new THREE.Vector3(0, growth.y < 0 ? -1 : 1, 0);
+        sprayNormal = growth.clone().lerp(worldUp, tuftPlateAlignment);
+        // growth and worldUp are antipodal only when the twig points exactly
+        // down, which the sign flip above already rules out; a degenerate
+        // lerp result can still appear at float precision.
+        if (sprayNormal.lengthSq() < 1e-8) sprayNormal.copy(worldUp);
+        sprayNormal.normalize();
+        // The plate's long axis follows its own limb's heading, so a plate is
+        // elongated ALONG the branch that carries it (which is what a real
+        // layered crown does) instead of every plate sharing one world axis —
+        // a squash direction repeated over 300 tufts is visible as a grain.
+        sprayRight = new THREE.Vector3(growth.x, 0, growth.z);
+        if (sprayRight.lengthSq() < 1e-6) sprayRight.copy(branchRight);
+        sprayRight.projectOnPlane(sprayNormal);
+        if (sprayRight.lengthSq() < 1e-6) sprayRight.copy(branchRight).projectOnPlane(sprayNormal);
+        sprayRight.normalize();
+        sprayForward = new THREE.Vector3().crossVectors(sprayRight, sprayNormal).normalize();
+      }
       for (let i = 0; i < tuftCards; i += 1) {
         let cardSizeScale = 1;
         let cardShape = [1, 1];
@@ -754,17 +970,23 @@ export function createTreeFoliageGeometry({
           const angle = tuftRng() * Math.PI * 2;
           cardCenter.copy(attachment.position)
             .addScaledVector(
-              branchRight,
+              sprayRight,
               Math.cos(angle) * radialT * spraySpread * foliageSprayScale,
             )
             .addScaledVector(
-              branchForward,
+              sprayForward,
               Math.sin(angle) * radialT * spraySpread * foliageSprayScale * 0.62,
             )
-            .addScaledVector(
-              growth,
-              layerT * sprayThickness * foliageSprayScale + tuftRadius * 0.16,
-            );
+            .addScaledVector(sprayNormal, layerT * sprayThickness * foliageSprayScale)
+            // Placement along the twig stays on the BRANCH axis whatever the
+            // disc is aligned to: the tuft sits at the end of its own shoot.
+            .addScaledVector(growth, tuftRadius * 0.16);
+          if (tuftPlateDroop > 0) {
+            // Quadratic in the radial coordinate, so the plate is level over
+            // its inner half and only the rim hangs.
+            cardCenter.y -= tuftPlateDroop * radialT * radialT
+              * spraySpread * foliageSprayScale;
+          }
           cardSizeScale = (0.88 + tuftRng() * 0.2)
             * (0.88 + foliageSprayScale * 0.12);
           if (individualBroadleafCards && organType === 'broad-leaf') {

package/src/vegetation/treeSurfaceTextures.js

@@ -25,6 +25,74 @@ export const TREE_SURFACE_PROFILES = Object.freeze({
     textureVersion: TREE_SURFACE_TEXTURE_VERSION,
     uvRepeat: Object.freeze([1.5, 1]),
   }),
+  // Smooth-barked broadleaf. Beech has no fissures at all: the read is soft
+  // mottled patches and faint vertical shading on a pale grey-green ground,
+  // which is why it needs its own generator rather than a re-tinted oak.
+  // Softer light bands than the fissured profiles, because there is no deep
+  // relief for a hard terminator to sit in.
+  'beech-smooth-v1': Object.freeze({
+    id: 'beech-smooth-v1',
+    label: 'Stylized smooth beech',
+    shader: Object.freeze({
+      bandSoftness: 0.115,
+      shadowFloor: 0.54,
+      skyFillStrength: 0.07,
+    }),
+    textureVersion: TREE_SURFACE_TEXTURE_VERSION,
+    uvRepeat: Object.freeze([1.25, 1]),
+  }),
+  // Papery pale bark with dark horizontal lenticel dashes and the occasional
+  // shed-limb patch. The lenticels are the entire silhouette read, so they
+  // stay high-contrast and the ground stays near-white.
+  'birch-papery-v1': Object.freeze({
+    id: 'birch-papery-v1',
+    label: 'Stylized papery birch',
+    shader: Object.freeze({
+      bandSoftness: 0.13,
+      shadowFloor: 0.6,
+      skyFillStrength: 0.085,
+    }),
+    textureVersion: TREE_SURFACE_TEXTURE_VERSION,
+    uvRepeat: Object.freeze([1.25, 1]),
+  }),
+  // Acer palmatum. The read is a fine-grained, cool grey-brown cylinder
+  // carrying close vertical striae and scattered pale lenticels, with only a
+  // shallow fissure where an old multi-stem trunk has started to split. It is
+  // neither smooth like beech nor plated like oak, and a re-tinted oak reads
+  // far too coarse on a 4 m tree standing 3 m from the lens.
+  'maple-striated-v1': Object.freeze({
+    id: 'maple-striated-v1',
+    label: 'Stylized striated Japanese maple',
+    shader: Object.freeze({
+      bandSoftness: 0.1,
+      shadowFloor: 0.5,
+      skyFillStrength: 0.065,
+    }),
+    textureVersion: TREE_SURFACE_TEXTURE_VERSION,
+    uvRepeat: Object.freeze([1.35, 1]),
+  }),
+  // Pinus thunbergii. Black pine bark is the opposite of a ridge-and-furrow
+  // profile: thick irregular PLATES, blocky in both axes, separated by deep
+  // near-black fissures, with warm ochre showing in the splits. The plate
+  // boundaries are cellular, not sinusoidal, which is why this needs its own
+  // generator rather than a darker oak — a warped sine gives long vertical
+  // ridges and reads as elm at any distance the garden camera works at.
+  'pine-plated-v1': Object.freeze({
+    id: 'pine-plated-v1',
+    label: 'Stylized plated Japanese black pine',
+    shader: Object.freeze({
+      bandSoftness: 0.065,
+      // Higher than a dark bark would suggest, on purpose. A cloud-pruned
+      // pine's bare limbs cross its own crown in full view, and they are
+      // thin: at the default floor a dark plated bark on a 3 cm twig turned
+      // shadow-side goes to near-black and reads as a crack scribbled across
+      // the foliage rather than as wood.
+      shadowFloor: 0.6,
+      skyFillStrength: 0.1,
+    }),
+    textureVersion: TREE_SURFACE_TEXTURE_VERSION,
+    uvRepeat: Object.freeze([1.6, 1.15]),
+  }),
   'bamboo-waxy-v1': Object.freeze({
     id: 'bamboo-waxy-v1',
     label: 'Stylized waxy bamboo culm',
@@ -64,6 +132,45 @@ export const TREE_SURFACE_PROFILE_DEFAULTS = Object.freeze({
   call_me_sensei: 'call-me-sensei-bark-v1',
 });
 
+/**
+ * Short bark names an author actually reaches for, mapped onto profile ids.
+ *
+ * Tree Lab has always spoken in species words ('beech', 'birch', 'oak'), and
+ * recipes get authored in the same vocabulary. Without this table those names
+ * resolve to nothing and the trunk silently ships bare, so the alias set is
+ * part of the contract rather than a convenience.
+ */
+export const TREE_SURFACE_PROFILE_ALIASES = Object.freeze({
+  beech: 'beech-smooth-v1',
+  birch: 'birch-papery-v1',
+  oak: 'oak-fissured-v1',
+  maple: 'maple-striated-v1',
+  acer: 'maple-striated-v1',
+  'japanese-maple': 'maple-striated-v1',
+  pine: 'pine-plated-v1',
+  'black-pine': 'pine-plated-v1',
+  'japanese-black-pine': 'pine-plated-v1',
+  bamboo: 'bamboo-waxy-v1',
+  yucca: 'yucca-fibrous-v1',
+  saguaro: 'saguaro-waxy-v1',
+  classic: 'call-me-sensei-bark-v1',
+  call_me_sensei: 'call-me-sensei-bark-v1',
+  'call-me-sensei': 'call-me-sensei-bark-v1',
+});
+
+/**
+ * Resolve a bark reference — a profile id or a short alias — to a profile id.
+ * Returns null for anything unregistered so callers can fall back to their own
+ * default instead of throwing on a caller-owned asset string.
+ */
+export function resolveTreeSurfaceProfileId(reference) {
+  if (typeof reference !== 'string') return null;
+  const key = reference.trim();
+  if (!key) return null;
+  if (TREE_SURFACE_PROFILES[key]) return key;
+  return TREE_SURFACE_PROFILE_ALIASES[key.toLowerCase()] ?? null;
+}
+
 export function getTreeSurfaceProfileOptions() {
   return Object.values(TREE_SURFACE_PROFILES).map(({ id, label }) => ({
     id,
@@ -122,6 +229,45 @@ function quantize(value, steps) {
     / Math.max(steps - 1, 1);
 }
 
+/**
+ * Tiling cellular (Worley) noise on a jittered lattice.
+ *
+ * Returns the nearest and second-nearest feature distances plus a stable
+ * per-cell id. Plated bark — pine, and the plated end of the oak family — is
+ * a *cellular* pattern: irregular blocks bounded on all sides, each block
+ * weathered to its own tone. Warped sine bands cannot express that; they only
+ * ever produce long ridges. Periodic in both axes so the trunk tile still
+ * wraps, which the sine-based generators above already rely on.
+ */
+function periodicCellular(x, y, periodX, periodY, seed) {
+  const xi = Math.floor(x);
+  const yi = Math.floor(y);
+  let best = Infinity;
+  let second = Infinity;
+  let bestId = 0;
+  for (let dy = -1; dy <= 1; dy += 1) {
+    for (let dx = -1; dx <= 1; dx += 1) {
+      const cx = xi + dx;
+      const cy = yi + dy;
+      const wx = ((cx % periodX) + periodX) % periodX;
+      const wy = ((cy % periodY) + periodY) % periodY;
+      const jx = hash2d(wx, wy, seed);
+      const jy = hash2d(wx, wy, seed + 911);
+      const fx = cx + 0.15 + jx * 0.7;
+      const fy = cy + 0.15 + jy * 0.7;
+      const distance = Math.hypot(x - fx, y - fy);
+      if (distance < best) {
+        second = best;
+        best = distance;
+        bestId = hash2d(wx, wy, seed + 1733);
+      } else if (distance < second) {
+        second = distance;
+      }
+    }
+  }
+  return { edge: second - best, first: best, id: bestId };
+}
+
 function oakFissuredPixel(u, v, seed) {
   // Large vertical plates and a small number of cross-breaks carry the
   // silhouette-scale bark read. Fine photographic pores are intentionally
@@ -155,6 +301,184 @@ function oakFissuredPixel(u, v, seed) {
   ];
 }
 
+function beechSmoothPixel(u, v, seed) {
+  // Fagus bark is smooth: no fissures, no plates, no cross-breaks. What reads
+  // at silhouette scale is soft overlapping mottle patches on a pale grey
+  // ground, a faint vertical grain from the trunk's own taper, and sparse
+  // darker healed scars. Quantized like the other profiles so it stays inside
+  // ToonLab's broad stylized light bands.
+  const broad = periodicValueNoise(u * 3, v * 4, 3, 4, seed + 229);
+  const mottle = periodicValueNoise(u * 6, v * 5, 6, 5, seed + 233);
+  const fine = periodicValueNoise(u * 13, v * 9, 13, 9, seed + 239);
+
+  // Faint vertical shading bands — a smooth cylinder, not a carved one.
+  const grainWarp = (broad - 0.5) * 0.22;
+  const grain = (Math.sin((u * 4 + grainWarp) * Math.PI * 2) * 0.5 + 0.5) * 0.06;
+
+  // Sparse healed scars: small, soft, and far apart. They are the only dark
+  // marks on a smooth trunk, so they are deliberately rare.
+  const scarNoise = periodicValueNoise(u * 9, v * 11, 9, 11, seed + 241);
+  const scar = THREE.MathUtils.smoothstep(scarNoise, 0.87, 0.98) * 0.16;
+
+  const tone = quantize(0.46 + broad * 0.28 + mottle * 0.18 + fine * 0.06, 5);
+  const shade = THREE.MathUtils.clamp(0.74 + tone * 0.34 + grain - scar, 0.62, 1.04);
+  // Pale grey-green ground: green and blue close together, red held under both.
+  const coolLift = quantize(periodicValueNoise(u * 2, v * 3, 2, 3, seed + 251), 4);
+  return [
+    (0.62 + coolLift * 0.035) * shade,
+    (0.63 + coolLift * 0.03) * shade,
+    (0.58 + coolLift * 0.04) * shade,
+  ];
+}
+
+function birchPaperyPixel(u, v, seed) {
+  // Betula reads as a near-white papery ground carrying dark horizontal
+  // lenticel dashes. The dashes are the whole identity, so they keep hard
+  // edges and high contrast while the ground stays almost flat.
+  const broad = periodicValueNoise(u * 4, v * 3, 4, 3, seed + 257);
+  const paper = periodicValueNoise(u * 11, v * 7, 11, 7, seed + 263);
+
+  // Lenticels: short horizontal strokes, banded in v, broken up in u so they
+  // do not run all the way around the trunk.
+  const bandNoise = periodicValueNoise(u * 5, v * 13, 5, 13, seed + 269);
+  const bandPhase = Math.abs(
+    ((v * 14 + (bandNoise - 0.5) * 0.5) % 1 + 1) % 1 - 0.5,
+  ) * 2;
+  const bandMask = 1 - THREE.MathUtils.smoothstep(bandPhase, 0.05, 0.16);
+  const breakNoise = periodicValueNoise(u * 17, v * 13, 17, 13, seed + 271);
+  const lenticel = bandMask * THREE.MathUtils.smoothstep(breakNoise, 0.36, 0.6);
+
+  // Occasional large dark patch where a limb was shed.
+  const shedNoise = periodicValueNoise(u * 3, v * 5, 3, 5, seed + 277);
+  const shed = THREE.MathUtils.smoothstep(shedNoise, 0.84, 0.99);
+
+  const tone = quantize(0.78 + broad * 0.12 + paper * 0.1, 4);
+  const shade = THREE.MathUtils.clamp(
+    0.86 + tone * 0.22 - lenticel * 0.52 - shed * 0.3,
+    0.3,
+    1.05,
+  );
+  // Warm-white paper; the dashes darken all three channels together so they
+  // read as value, not as a hue shift.
+  const warmLift = quantize(periodicValueNoise(u * 2, v * 4, 2, 4, seed + 281), 3);
+  return [
+    (0.89 + warmLift * 0.03) * shade,
+    (0.87 + warmLift * 0.025) * shade,
+    (0.81 + warmLift * 0.02) * shade,
+  ];
+}
+
+function mapleStriatedPixel(u, v, seed) {
+  // Acer palmatum. Three things carry the read and nothing else should
+  // compete with them: close vertical striae (fine pale lines, ~2 mm apart on
+  // the real thing), a soft grey-brown mottle underneath, and scattered pale
+  // lenticels. A single shallow fissure family is allowed for the old
+  // multi-stem trunks the garden uses, but at a fraction of oak's depth —
+  // maple is a fine-grained bark and reading it as fissured is the classic
+  // way a stylized maple ends up looking like a small oak.
+  const broad = periodicValueNoise(u * 3, v * 4, 3, 4, seed + 307);
+  const mottle = periodicValueNoise(u * 7, v * 6, 7, 6, seed + 311);
+
+  // Close vertical striae. Two incommensurate frequencies keep them from
+  // reading as a comb; the warp keeps them from reading as a ruled grid.
+  const striaWarp = (broad - 0.5) * 0.28 + Math.sin(v * Math.PI * 6) * 0.02;
+  const striaA = Math.sin((u * 26 + striaWarp) * Math.PI * 2) * 0.5 + 0.5;
+  const striaB = Math.sin((u * 41 - striaWarp * 0.7) * Math.PI * 2) * 0.5 + 0.5;
+  const stria = striaA * 0.68 + striaB * 0.32;
+
+  // Shallow age fissures: sparse, narrow, and much weaker than oak's.
+  const fissureWarp = (mottle - 0.5) * 0.4;
+  const fissureCoordinate = u * 7 + fissureWarp;
+  const fissurePhase = Math.abs(
+    (fissureCoordinate - Math.floor(fissureCoordinate)) - 0.5,
+  ) * 2;
+  const fissure = (1 - THREE.MathUtils.smoothstep(fissurePhase, 0.03, 0.1))
+    * THREE.MathUtils.smoothstep(broad, 0.52, 0.86);
+
+  // Lenticels: small pale flecks, brighter than the ground, sparse.
+  const lenticelNoise = periodicValueNoise(u * 15, v * 19, 15, 19, seed + 313);
+  const lenticel = THREE.MathUtils.smoothstep(lenticelNoise, 0.9, 0.99) * 0.2;
+
+  const tone = quantize(0.3 + broad * 0.24 + mottle * 0.18 + stria * 0.2, 5);
+  const shade = THREE.MathUtils.clamp(
+    0.6 + tone * 0.42 + stria * 0.14 + lenticel - fissure * 0.26,
+    0.42,
+    1.02,
+  );
+  // Cool grey-brown, and genuinely dark: an Acer palmatum trunk is a middle
+  // value, not a pale one. A washed-out ground was the first version's real
+  // failure — against the deep-green field of §2 a pale trunk pulls the eye
+  // to the wood instead of to the autumn canopy it is supposed to support.
+  // Red only a little above green, blue held back but not starved, which is
+  // what separates maple from both the warm oak family and the near-neutral
+  // beech.
+  const warmLift = quantize(periodicValueNoise(u * 2, v * 3, 2, 3, seed + 317), 4);
+  return [
+    (0.52 + warmLift * 0.05) * shade,
+    (0.46 + warmLift * 0.035) * shade,
+    (0.42 + warmLift * 0.035) * shade,
+  ];
+}
+
+function pinePlatedPixel(u, v, seed) {
+  // Pinus thunbergii. Thick irregular plates, blocky in BOTH axes, separated
+  // by deep near-black fissures with warm ochre showing in the splits. The
+  // plates are cellular, so they come from periodicCellular rather than from
+  // a warped band; each cell is weathered to its own tone, which is the whole
+  // close-camera read. A second, finer cellular pass breaks the large plates
+  // into the scaly sub-plates the species is named for.
+  const broad = periodicValueNoise(u * 4, v * 5, 4, 5, seed + 331);
+  const warpX = (broad - 0.5) * 0.55;
+  const warpY = (periodicValueNoise(u * 5, v * 4, 5, 4, seed + 337) - 0.5) * 0.45;
+
+  // Large plates. The lattice is sampled at 7 x 6 over a tile that is itself
+  // 1:2, so a cell spans roughly twice the trunk height it spans in
+  // circumference and the plates come out clearly ELONGATED along the trunk.
+  // Equal periods gave near-round cells, which read as dried mud rather than
+  // as pine, and that was the first version's real failure.
+  const plate = periodicCellular(u * 7 + warpX, v * 6 + warpY, 7, 6, seed + 347);
+  // Scales inside each plate.
+  const scale = periodicCellular(u * 15 + warpX * 0.5, v * 13 + warpY * 0.5, 15, 13, seed + 353);
+
+  // Fissure = the cell boundary. Deep and hard-edged for the plate network,
+  // shallow and soft for the scale network. Narrower than the first version:
+  // a black pine's fissures are deep, not wide, and widening them turns the
+  // plate network into a grout grid.
+  const plateFissure = 1 - THREE.MathUtils.smoothstep(plate.edge, 0.02, 0.1);
+  const scaleFissure = (1 - THREE.MathUtils.smoothstep(scale.edge, 0.015, 0.075)) * 0.36;
+  const fissure = Math.min(1, plateFissure + scaleFissure * (1 - plateFissure));
+
+  // Per-plate weathering. Quantized hard so plates group into ToonLab's broad
+  // value bands instead of dissolving into per-pixel grain.
+  const plateTone = quantize(plate.id, 4);
+  const scaleTone = quantize(scale.id, 3);
+  const grain = periodicValueNoise(u * 21, v * 27, 21, 27, seed + 359);
+
+  // The tile is a MULTIPLIER, not a final colour: the woody material takes
+  // `map x trunk.color` and then tone-maps it. Authoring black pine at the
+  // absolute value real black pine bark reads at put the tile around byte 76
+  // — half the value of every other profile in this file — and the trunk came
+  // out a featureless black cylinder in which none of the plate work was
+  // visible at 85 mm. The plate-to-fissure CONTRAST is what carries the
+  // species; the overall level has to sit with its neighbours.
+  const shade = THREE.MathUtils.clamp(
+    0.72 + plateTone * 0.34 + scaleTone * 0.1 + grain * 0.07 - fissure * 0.46,
+    0.32,
+    1.12,
+  );
+  // Dark grey-charcoal plate faces; the fissures let a little warm brown
+  // through, so red is lifted exactly where the value drops. Without any
+  // warmth the trunk reads as wet slate — but the first version overdid it
+  // and the fissure network glowed orange like fired brick, so the lift is
+  // now a fraction of what it was and stays under the value drop.
+  const ochre = fissure * (0.35 + plateTone * 0.4);
+  return [
+    (0.45 + ochre * 0.17) * shade,
+    (0.44 + ochre * 0.08) * shade,
+    (0.43 + ochre * 0.02) * shade,
+  ];
+}
+
 function bambooWaxyPixel(u, v, seed) {
   // Moso culms read as smooth gray-green cylinders with restrained vertical
   // striation and irregular wax bloom. Nodes remain semantic ring geometry;
@@ -244,6 +568,10 @@ function surfacePixel(profileId, u, v, seed) {
   if (profileId === 'call-me-sensei-bark-v1' || profileId === 'oak-fissured-v1') {
     return oakFissuredPixel(u, v, seed);
   }
+  if (profileId === 'beech-smooth-v1') return beechSmoothPixel(u, v, seed);
+  if (profileId === 'birch-papery-v1') return birchPaperyPixel(u, v, seed);
+  if (profileId === 'maple-striated-v1') return mapleStriatedPixel(u, v, seed);
+  if (profileId === 'pine-plated-v1') return pinePlatedPixel(u, v, seed);
   if (profileId === 'bamboo-waxy-v1') return bambooWaxyPixel(u, v, seed);
   if (profileId === 'yucca-fibrous-v1') return yuccaFibrousPixel(u, v, seed);
   if (profileId === 'saguaro-waxy-v1') return saguaroWaxyPixel(u, v, seed);

package/src/version.js

@@ -1,3 +1,3 @@
 // Single runtime source of truth for package consumers and ToonLab Pro/MCP.
 // Keep this value synchronized with package.json during release preparation.
-export const TOONLAB_VERSION = '0.4.19';
+export const TOONLAB_VERSION = '0.4.21';