@call-me-sensei/toonlab 0.4.19 → 0.4.21

package/src/rock-shader/rockMaterial.js

@@ -8,6 +8,7 @@
 // material values, distance metrics, and PBR attribute semantics are not identical.
 
 import {
+  Color,
   ClampToEdgeWrapping,
   LinearFilter,
   LinearMipmapLinearFilter,
@@ -21,6 +22,7 @@ import {
   TextureLoader,
 } from 'three';
 import { MeshPhysicalNodeMaterial } from 'three/webgpu';
+import { mx_fractal_noise_float } from 'three/tsl';
 import {
   TBNViewMatrix,
   abs,
@@ -39,6 +41,7 @@ import {
   positionWorld,
   pow,
   sin,
+  smoothstep,
   step,
   texture,
   transformNormalByViewMatrix,
@@ -66,6 +69,10 @@ import {
   normalizeToonLabRockMaterialLibrarySchema,
 } from '../environment/toonLabRockMaterialResolver.js';
 import { installToonLabSurfaceLighting } from '../environment/toonLabSurfaceLighting.js';
+import {
+  ROCK_CAVITY_ATTRIBUTE,
+  ROCK_EXPOSURE_ATTRIBUTE,
+} from './rockGeometryDetail.js';
 
 export const TOONLAB_ROCK_MANIFEST_SCHEMA = 'toonlab.rock-material-library';
 export const TOONLAB_ROCK_MANIFEST_VERSION = 1;
@@ -153,8 +160,11 @@ export const TOONLAB_ROCK_PROFILE_DEFAULTS = Object.freeze({
   lighting: Object.freeze({
     exposure: 1,
     ambientFloor: 0.04,
+    skyColorInfluence: 0.35,
     skyFillStrength: 1,
     skyFillTint: Object.freeze([1, 1, 1]),
+    shadowFill: 0,
+    shadowFillTint: Object.freeze([1, 1, 1]),
   }),
   shoreline: Object.freeze({
     wetBandWidth: 0.8,
@@ -179,11 +189,61 @@ export const TOONLAB_ROCK_PROFILE_DEFAULTS = Object.freeze({
     colorPower: 1.3,
     lowColor: Object.freeze([0.2156862915, 0.3254902065, 0.1019607931]),
     highColor: Object.freeze([0.3333333433, 0.4078431726, 0.2470588386]),
+    // --- moss as a material rather than a tint -------------------------
+    // All three default to "off" so the shipped look is unchanged: a moss
+    // that only mixes color is exactly the previous behaviour.
+    //
+    // Moss is a matte cushion; stone is not. Leaving roughness alone is why
+    // moss reads as a stain *under* the stone's own specular rather than as
+    // a plant sitting on it. -1 disables the response.
+    roughness: -1,
+    // A moss cushion buries the relief it grows over. Flattening the rock's
+    // detail normal under the mask is what makes it sit ON the surface;
+    // without it the stone's crevices show straight through the moss.
+    relief: 0,
+    // Break-up of the coverage boundary. The mask is a smooth power curve,
+    // so its edge is an airbrushed gradient — the single strongest reason
+    // moss reads as paint. A high-frequency sample pushed through the
+    // threshold gives the ragged fringe real moss has.
+    fringe: 0,
+    fringeScale: 0.35,
+    // 0..1 blend of the coverage source from the moss albedo's luminance
+    // toward a constant, handing patch shape to the geometric moisture field.
+    formDriven: 0,
+    coverage: -1,
+    band: 0.18,
+    patchScale: 0.6,
+    patchStrength: 0.8,
+    patchOctaves: 3,
+    patchContrast: 1.6,
+    // --- value, form and depth (D19-210 … D19-213) ---------------------
+    // Inert defaults: -1 and 0 reproduce the shipped render byte for byte.
+    // Remap of the moss map's own luminance range onto the colour ramp. The
+    // shipped path uses the raw rgb sample, and the shipped moss albedo lives
+    // in a linear luminance band of 0.092-0.279, so the ramp coordinate never
+    // clears ~0.09 and `highColor` is unreachable.
+    patternFloor: -1,
+    patternCeiling: 1,
+    // Darkens stone across the wet field, so moss and stone meet at a close
+    // value the way they do in life instead of green-on-white.
+    damp: 0,
+    // Convex, weather-exposed form suppressing moss. Without it the support
+    // term can add moss to hollows but cannot take it off a crown.
+    exposure: 0,
+    // The moss cushion's own raised form, and the occlusion it casts where it
+    // meets bare stone.
+    cushion: 0,
+    contact: 0,
   }),
   layers: Object.freeze({
     maskEnabled: true,
     sharpness: 0.8,
     offset: 0.3,
+    heightStart: 0.48,
+    heightEnd: 0.88,
+    cavityStrength: 0,
+    exposureStrength: 0,
+    semanticMaskStrength: 1,
     grass: Object.freeze({
       enabled: true,
       useGroundShader: false,
@@ -191,6 +251,8 @@ export const TOONLAB_ROCK_PROFILE_DEFAULTS = Object.freeze({
       tint: Object.freeze([1, 1, 1]),
       saturation: 1,
       emission: 0,
+      roughness: -1,
+      metalness: -1,
     }),
     snow: Object.freeze({
       enabled: false,
@@ -198,6 +260,8 @@ export const TOONLAB_ROCK_PROFILE_DEFAULTS = Object.freeze({
       tint: Object.freeze([0, 0, 0]),
       saturation: 1,
       emission: 0,
+      roughness: -1,
+      metalness: -1,
     }),
     sand: Object.freeze({
       enabled: true,
@@ -206,6 +270,8 @@ export const TOONLAB_ROCK_PROFILE_DEFAULTS = Object.freeze({
       tint: Object.freeze([0, 0, 0]),
       saturation: 0,
       emission: 0,
+      roughness: -1,
+      metalness: -1,
       normalScale: 0,
       normalStrength: 1,
       normalRotationDegrees: 30,
@@ -243,6 +309,26 @@ function finite(value, fallback) {
   return Number.isFinite(result) ? result : fallback;
 }
 
+/**
+ * Numeric clamp for the JS-side normalizers.
+ *
+ * NOT `clamp` from `three/tsl`. That name is imported into this module for the
+ * shader graph, and calling it on a plain number returns a NODE, not a number —
+ * which is silently almost-correct, because a node operand is legal everywhere
+ * the graph consumes these values. It is catastrophically wrong everywhere JS
+ * does: `node > 0` is false, `node === 0.85` is false, `Number(node)` is NaN,
+ * and `JSON.stringify(node)` is not the value.
+ *
+ * That is not hypothetical. `vertexCavityStrength` was clamped with the TSL
+ * function and then gated with `> 0`, so the gate was permanently false and the
+ * `rockCavity` attribute never reached the moss mask at all — the support term
+ * that the whole patch model is built on was pure slope, which saturates. See
+ * D19-214. Four profile scalars were leaking nodes the same way.
+ */
+function clampNumber(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+
 function bool(value, fallback) {
   if (typeof value === 'boolean') return value;
   if (Number.isFinite(Number(value))) return Number(value) !== 0;
@@ -324,7 +410,7 @@ export function normalizeToonLabRockProfile(profile = {}) {
         finite(base.nearDetailScale, defaults.base.nearDetailScale),
         0.0001,
       ),
-      nearDetailStrength: clamp(
+      nearDetailStrength: clampNumber(
         finite(base.nearDetailStrength, defaults.base.nearDetailStrength),
         0,
         1,
@@ -365,34 +451,54 @@ export function normalizeToonLabRockProfile(profile = {}) {
     },
     lighting: {
       exposure: Math.max(finite(lighting.exposure, defaults.lighting.exposure), 0),
-      ambientFloor: clamp(
+      ambientFloor: clampNumber(
         finite(lighting.ambientFloor, defaults.lighting.ambientFloor),
         0,
         1,
       ),
+      skyColorInfluence: clampNumber(
+        finite(lighting.skyColorInfluence, defaults.lighting.skyColorInfluence),
+        0,
+        1,
+      ),
       skyFillStrength: Math.max(
         finite(lighting.skyFillStrength, defaults.lighting.skyFillStrength),
         0,
       ),
       skyFillTint: color3(lighting.skyFillTint, defaults.lighting.skyFillTint),
+      shadowFill: clampNumber(
+        finite(lighting.shadowFill, defaults.lighting.shadowFill),
+        0,
+        1,
+      ),
+      shadowFillTint: color3(
+        lighting.shadowFillTint,
+        defaults.lighting.shadowFillTint,
+      ),
     },
     shoreline: {
+      // Spread first, coerce after — the same shape the moss group uses. The
+      // entries below still clamp every field that has a meaningful range; the
+      // spread only ensures a field added to the schema later reaches the
+      // shader instead of being dropped silently between validation and use.
+      ...shoreline,
       wetBandWidth: Math.max(
         finite(shoreline.wetBandWidth, defaults.shoreline.wetBandWidth),
         0,
       ),
-      wetBandDarkening: clamp(
+      wetBandDarkening: clampNumber(
         finite(shoreline.wetBandDarkening, defaults.shoreline.wetBandDarkening),
         0,
         1,
       ),
-      wetRoughness: clamp(
+      wetRoughness: clampNumber(
         finite(shoreline.wetRoughness, defaults.shoreline.wetRoughness),
         0.02,
         1,
       ),
     },
     normals: {
+      ...normals,
       distance: finite(normals.distance, defaults.normals.distance),
       // Do not clamp: shipped Classic Rocks deliberately uses -0.1, producing
       // Normal Strength 1.1 in the source graph.
@@ -402,6 +508,10 @@ export function normalizeToonLabRockProfile(profile = {}) {
       normalGreenSign: finite(normals.normalGreenSign, defaults.normals.normalGreenSign),
     },
     moss: {
+      // Spread first so a field the settings schema gained still reaches the
+      // shader; the explicit entries below then coerce and default the ones
+      // the graph reads directly. See the note in `rockShaderSettingsToProfile`.
+      ...moss,
       enabled: bool(moss.enabled, defaults.moss.enabled),
       size: finite(moss.size, defaults.moss.size),
       sharpness: finite(moss.sharpness, defaults.moss.sharpness),
@@ -410,12 +520,39 @@ export function normalizeToonLabRockProfile(profile = {}) {
       colorPower: finite(moss.colorPower, defaults.moss.colorPower),
       lowColor: color3(moss.lowColor, defaults.moss.lowColor),
       highColor: color3(moss.highColor, defaults.moss.highColor),
+      roughness: finite(moss.roughness, defaults.moss.roughness),
+      relief: finite(moss.relief, defaults.moss.relief),
+      fringe: finite(moss.fringe, defaults.moss.fringe),
+      fringeScale: finite(moss.fringeScale, defaults.moss.fringeScale),
+      formDriven: finite(moss.formDriven, defaults.moss.formDriven),
+      coverage: finite(moss.coverage, defaults.moss.coverage),
+      band: finite(moss.band, defaults.moss.band),
+      patchScale: finite(moss.patchScale, defaults.moss.patchScale),
+      patchStrength: finite(moss.patchStrength, defaults.moss.patchStrength),
+      patchOctaves: finite(moss.patchOctaves, defaults.moss.patchOctaves),
+      patchContrast: finite(moss.patchContrast, defaults.moss.patchContrast),
+      patternFloor: finite(moss.patternFloor, defaults.moss.patternFloor),
+      patternCeiling: finite(moss.patternCeiling, defaults.moss.patternCeiling),
+      damp: finite(moss.damp, defaults.moss.damp),
+      exposure: finite(moss.exposure, defaults.moss.exposure),
+      cushion: finite(moss.cushion, defaults.moss.cushion),
+      contact: finite(moss.contact, defaults.moss.contact),
     },
     layers: {
       maskEnabled: bool(layers.maskEnabled, defaults.layers.maskEnabled),
       sharpness: finite(layers.sharpness, defaults.layers.sharpness),
       offset: finite(layers.offset, defaults.layers.offset),
+      heightStart: finite(layers.heightStart, defaults.layers.heightStart),
+      heightEnd: finite(layers.heightEnd, defaults.layers.heightEnd),
+      cavityStrength: finite(layers.cavityStrength, defaults.layers.cavityStrength),
+      exposureStrength: finite(layers.exposureStrength, defaults.layers.exposureStrength),
+      semanticMaskStrength: clampNumber(
+        finite(layers.semanticMaskStrength, defaults.layers.semanticMaskStrength),
+        0,
+        1,
+      ),
       grass: {
+        ...grass,
         enabled: bool(grass.enabled, defaults.layers.grass.enabled),
         useGroundShader: bool(
           grass.useGroundShader,
@@ -425,15 +562,21 @@ export function normalizeToonLabRockProfile(profile = {}) {
         tint: color3(grass.tint, defaults.layers.grass.tint),
         saturation: finite(grass.saturation, defaults.layers.grass.saturation),
         emission: finite(grass.emission, defaults.layers.grass.emission),
+        roughness: finite(grass.roughness, defaults.layers.grass.roughness),
+        metalness: finite(grass.metalness, defaults.layers.grass.metalness),
       },
       snow: {
+        ...snow,
         enabled: bool(snow.enabled, defaults.layers.snow.enabled),
         scale: finite(snow.scale, defaults.layers.snow.scale),
         tint: color3(snow.tint, defaults.layers.snow.tint),
         saturation: finite(snow.saturation, defaults.layers.snow.saturation),
         emission: finite(snow.emission, defaults.layers.snow.emission),
+        roughness: finite(snow.roughness, defaults.layers.snow.roughness),
+        metalness: finite(snow.metalness, defaults.layers.snow.metalness),
       },
       sand: {
+        ...sand,
         enabled: bool(sand.enabled, defaults.layers.sand.enabled),
         useGroundShader: bool(
           sand.useGroundShader,
@@ -443,6 +586,8 @@ export function normalizeToonLabRockProfile(profile = {}) {
         tint: color3(sand.tint, defaults.layers.sand.tint),
         saturation: finite(sand.saturation, defaults.layers.sand.saturation),
         emission: finite(sand.emission, defaults.layers.sand.emission),
+        roughness: finite(sand.roughness, defaults.layers.sand.roughness),
+        metalness: finite(sand.metalness, defaults.layers.sand.metalness),
         normalScale: finite(sand.normalScale, defaults.layers.sand.normalScale),
         normalStrength: finite(sand.normalStrength, defaults.layers.sand.normalStrength),
         normalRotationDegrees: finite(
@@ -606,6 +751,14 @@ export function toonLabRockProfileFromResolvedMaterial(materialEntry) {
       normalGreenSign: d.normals.normalGreenSign,
     },
     moss: {
+      // Spread the defaults first. No TOONLAB renderer property backs the
+      // ToonLab-added fields — they are capability, not Unity-shader parity —
+      // so they must resolve from the defaults and stay off unless a caller
+      // sets them. Naming them one by one meant every new field silently
+      // vanished from this path until someone remembered a fifth edit; the
+      // spread makes that structurally impossible. The entries below then
+      // override exactly the fields a renderer property does back.
+      ...d.moss,
       enabled: resolvedBool(r, '_Moss', d.moss.enabled),
       size: resolvedNumber(r, '_Moss_Size', d.moss.size),
       sharpness: resolvedNumber(r, '_Moss_Sharpness', d.moss.sharpness),
@@ -780,7 +933,7 @@ function toonLabTriplanarWeights(normalNode, blend) {
   return weights.div(max(weights.x.add(weights.y).add(weights.z), 0.000001));
 }
 
-function toonLabTriplanarColor(map, scale, blend = 1, coordinates = { zSign: 1 }) {
+export function toonLabTriplanarColor(map, scale, blend = 1, coordinates = { zSign: 1 }) {
   const mapNode = texture(map);
   const sourcePosition = toonLabSourcePosition(coordinates);
   const sourceNormal = toonLabSourceGeometryNormal(coordinates);
@@ -845,11 +998,11 @@ function worldNormalToTangent(worldNormal) {
   return normalize(transpose(TBNViewMatrix).mul(viewNormal));
 }
 
-function tangentNormalToView(tangentNormal) {
+export function tangentNormalToView(tangentNormal) {
   return normalize(TBNViewMatrix.mul(tangentNormal));
 }
 
-function toonLabTriplanarNormal(map, scale, blend, greenSign, coordinates) {
+export function toonLabTriplanarNormal(map, scale, blend, greenSign, coordinates) {
   const projected = toonLabSourcePosition(coordinates).div(safeScale(scale));
   const geometryNormal = toonLabSourceGeometryNormal(coordinates);
   const weights = toonLabTriplanarWeights(geometryNormal, blend);
@@ -903,7 +1056,7 @@ function toonLabSandNormal(map, layer, greenSign, coordinates) {
   return toonLabNormalStrength(decoded, layer.normalStrength);
 }
 
-function toonLabTopMask(profile, topMaskTexture) {
+function toonLabTopMask(profile, topMaskTexture, assetIntegration) {
   const denominator = Math.max(1 - profile.layers.offset, 0.000001);
   let mask = clamp(
     normalWorldGeometry.y
@@ -913,8 +1066,20 @@ function toonLabTopMask(profile, topMaskTexture) {
     0,
     1,
   );
+  if (assetIntegration.semanticMaskAttributes) {
+    const height = smoothstep(
+      float(profile.layers.heightStart),
+      float(Math.max(profile.layers.heightEnd, profile.layers.heightStart + 0.0001)),
+      attribute('rockHeight', 'float'),
+    );
+    const cavity = attribute('rockCavity', 'float').mul(profile.layers.cavityStrength);
+    const exposure = attribute('rockExposure', 'float').mul(profile.layers.exposureStrength);
+    const form = clamp(height.mul(float(1).add(cavity)).mul(float(1).sub(exposure)), 0, 1);
+    mask = mask.mul(form);
+  }
   if (profile.layers.maskEnabled && topMaskTexture) {
-    mask = mask.mul(texture(topMaskTexture).sample(uv()).r);
+    const authored = texture(topMaskTexture).sample(uv()).r;
+    mask = mask.mul(mix(1, authored, profile.layers.semanticMaskStrength));
   }
   return clamp(mask, 0, 1);
 }
@@ -1001,8 +1166,9 @@ function textureKeysForProfile(profile, { includeInactive = false } = {}) {
 }
 
 /**
- * Builds an opaque TSL material from a normalized profile and resolved
- * THREE.Texture objects. This ports the S_Rock graph inputs; final pixels still
+ * Builds a TSL material from a normalized profile and resolved THREE.Texture
+ * objects. Source alpha semantics are retained when an imported material uses
+ * masking or transparency. This ports the S_Rock graph inputs; final pixels still
  * depend on matching ToonLab's deferred BRDF, SSAO, shadows, ambient probe,
  * fog, TAA, and post-processing.
  */
@@ -1015,23 +1181,70 @@ export function createToonRockMaterial({
   const resolvedProfile = normalizeToonLabRockProfile(profile);
   validateTextures(resolvedProfile, textures);
   const resolvedAssetIntegration = {
-    sourceAlbedoStrength: clamp(
+    sourceAlbedoStrength: clampNumber(
       finite(assetIntegration?.sourceAlbedoStrength, 0),
       0,
       1,
     ),
-    sourceNormalStrength: clamp(
+    sourceNormalStrength: clampNumber(
       finite(assetIntegration?.sourceNormalStrength, 1),
       0,
       2,
     ),
-    sourceAoStrength: clamp(
+    sourceAoStrength: clampNumber(
       finite(assetIntegration?.sourceAoStrength, 1),
       0,
       2,
     ),
+    // glTF material factors are already linear working-space values. Keep
+    // them separate from ToonLab inspector colors, which require sRGB decode.
+    sourceColor: color3(assetIntegration?.sourceColor, [1, 1, 1]),
+    sourceEmissive: color3(assetIntegration?.sourceEmissive, [0, 0, 0]),
+    sourceEmissiveIntensity: Math.max(0, finite(assetIntegration?.sourceEmissiveIntensity, 1)),
+    sourceOpacity: clampNumber(finite(assetIntegration?.sourceOpacity, 1), 0, 1),
+    sourceAlphaTest: clampNumber(finite(assetIntegration?.sourceAlphaTest, 0), 0, 1),
+    sourceTransparent: Boolean(assetIntegration?.sourceTransparent),
+    sourceDepthWrite: assetIntegration?.sourceDepthWrite !== false,
+    sourceSide: Number.isInteger(assetIntegration?.sourceSide) ? assetIntegration.sourceSide : null,
+    sourceMetalnessFactor: clampNumber(finite(assetIntegration?.sourceMetalnessFactor, 0), 0, 1),
+    sourceRoughnessFactor: clampNumber(finite(assetIntegration?.sourceRoughnessFactor, 1), 0, 1),
+    sourceSpecularFactor: clampNumber(finite(assetIntegration?.sourceSpecularFactor, 1), 0, 1),
+    primaryNormalStrength: clampNumber(
+      finite(assetIntegration?.primaryNormalStrength, 1),
+      0,
+      2,
+    ),
+    primarySpecularStrength: clampNumber(
+      finite(assetIntegration?.primarySpecularStrength, 1),
+      0,
+      2,
+    ),
+    semanticMaskAttributes: Boolean(assetIntegration?.semanticMaskAttributes),
+    rockRegionAttributes: Boolean(assetIntegration?.rockRegionAttributes),
+    regionTintStrength: clampNumber(
+      finite(assetIntegration?.regionTintStrength, 0),
+      0,
+      1,
+    ),
+    regionBaseTint: color3(assetIntegration?.regionBaseTint, [1, 1, 1]),
+    regionShaftTint: color3(assetIntegration?.regionShaftTint, [1, 1, 1]),
+    regionNeckTint: color3(assetIntegration?.regionNeckTint, [1, 1, 1]),
+    regionCapTint: color3(assetIntegration?.regionCapTint, [1, 1, 1]),
+    regionNeckOverlayStrength: clampNumber(
+      finite(assetIntegration?.regionNeckOverlayStrength, 0),
+      0,
+      1,
+    ),
     vertexAoStrength: Math.max(0, finite(assetIntegration?.vertexAoStrength, 0)),
-    vertexColorStrength: clamp(
+    // Reads the `rockCavity` channel written by rockGeometryDetail. Gated the
+    // same way as the other optional vertex channels: 0 means the attribute is
+    // not required to exist, so meshes without geometry detail are unaffected.
+    vertexCavityStrength: clampNumber(
+      finite(assetIntegration?.vertexCavityStrength, 0),
+      0,
+      4,
+    ),
+    vertexColorStrength: clampNumber(
       finite(assetIntegration?.vertexColorStrength, 0),
       0,
       1,
@@ -1040,7 +1253,7 @@ export function createToonRockMaterial({
 
   const radialDistance = distance(cameraPosition, positionWorld);
   const authoredDistanceScale = resolvedProfile.coordinates.distanceScale;
-  const topMask = toonLabTopMask(resolvedProfile, textures.topMask);
+  const topMask = toonLabTopMask(resolvedProfile, textures.topMask, resolvedAssetIntegration);
   const rockProjection = toonLabRockProjection(textures.rock, resolvedProfile);
   let colorNode = toonLabContrast(
     toonLabSaturation(rockProjection, resolvedProfile.base.saturation),
@@ -1055,7 +1268,9 @@ export function createToonRockMaterial({
     // Imported catalog albedo is authored in mesh UV space. Re-projecting it
     // at the package macro scale erased precisely the baked cracks and strata
     // that the controlled blend is meant to retain.
-    const sourceProjection = texture(textures.sourceRock).sample(uv()).rgb;
+    const sourceProjection = texture(textures.sourceRock).sample(uv()).rgb.mul(
+      vec3(...resolvedAssetIntegration.sourceColor),
+    );
     colorNode = mix(
       colorNode,
       toonLabContrast(
@@ -1127,6 +1342,33 @@ export function createToonRockMaterial({
     );
   }
 
+  if (
+    resolvedAssetIntegration.rockRegionAttributes
+    && resolvedAssetIntegration.regionTintStrength > 0
+  ) {
+    const regions = attribute('_tl_rock_region', 'vec4');
+    const primaryTint = vec3(...resolvedAssetIntegration.regionBaseTint).mul(regions.x)
+      .add(vec3(...resolvedAssetIntegration.regionShaftTint).mul(regions.y))
+      .add(vec3(...resolvedAssetIntegration.regionCapTint).mul(regions.w));
+    const neckBlend = regions.z.mul(resolvedAssetIntegration.regionNeckOverlayStrength);
+    const geologicalTint = mix(
+      primaryTint,
+      vec3(...resolvedAssetIntegration.regionNeckTint),
+      neckBlend,
+    );
+    colorNode = colorNode.mul(mix(
+      vec3(1),
+      geologicalTint,
+      resolvedAssetIntegration.regionTintStrength,
+    ));
+  }
+
+  // Hoisted so the roughness and normal stages downstream can read the same
+  // coverage the color stage used. Moss that only tints is moss that cannot
+  // sit on the stone.
+  let mossMaskNode = null;
+  let mossDampNode = null;
+  let mossCushionNode = null;
   if (resolvedProfile.moss.enabled) {
     const mossSample = toonLabTriplanarColor(
       textures.moss,
@@ -1134,10 +1376,45 @@ export function createToonRockMaterial({
       1,
       resolvedProfile.coordinates,
     );
-    const mossPattern = pow(
-      max(mossSample, vec3(0)),
-      vec3(resolvedProfile.moss.colorPower),
-    );
+    const mossLuminance = dot(max(mossSample, vec3(0)), vec3(0.2126, 0.7152, 0.0722));
+    // --- colour ramp ----------------------------------------------------
+    //
+    // The shipped path feeds the raw rgb sample straight into the palette
+    // `mix()`. That silently assumes the moss map's channels span 0..1, and the
+    // shipped map does not come close: its linear luminance occupies
+    // 0.092-0.279 with 99.3% of texels inside one decile, and its channel means
+    // are r 0.079 / g 0.147 / b 0.041. Two things follow, and together they are
+    // most of why moss rendered as near-black-green camouflage on near-white
+    // stone (D19-210):
+    //
+    //   * the ramp coordinate never clears ~0.09, so moss resolves to
+    //     `lowColor` — the darkest working stop — essentially everywhere, and
+    //     `highColor` and the whole upper half of the authored palette are
+    //     unreachable. Five carefully chosen stops collapse to one flat dark
+    //     green with no internal variation for the eye to read as texture.
+    //   * the coordinate is a vec3, so each palette channel is driven by the
+    //     matching texture channel. The map's red is half its green, so the
+    //     ramp's red end stays pinned while green rises, skewing hue on top of
+    //     crushing value. The coverage mask below was already fixed for exactly
+    //     this cross-channel bug; the colour stage was not.
+    //
+    // A floor of 0 or more switches to a scalar coordinate remapped from the
+    // map's measured range, which reaches the full palette and fixes the hue
+    // skew at once. -1 keeps the shipped behaviour byte for byte.
+    let mossPattern;
+    if (resolvedProfile.moss.patternFloor >= 0) {
+      const floor = resolvedProfile.moss.patternFloor;
+      const ceiling = Math.max(floor + 1e-4, resolvedProfile.moss.patternCeiling);
+      mossPattern = pow(
+        clamp(mossLuminance.sub(floor).div(ceiling - floor), 0, 1),
+        float(resolvedProfile.moss.colorPower),
+      );
+    } else {
+      mossPattern = pow(
+        max(mossSample, vec3(0)),
+        vec3(resolvedProfile.moss.colorPower),
+      );
+    }
     const mossColor = mix(
       toonLabColorProperty(resolvedProfile.moss.lowColor),
       toonLabColorProperty(resolvedProfile.moss.highColor),
@@ -1152,13 +1429,255 @@ export function createToonRockMaterial({
     );
     // Coverage is scalar. Using RGB moss texels as the interpolation mask
     // cross-mixed color channels and could turn green source moss magenta.
-    const mossCoverage = dot(mossSample, vec3(0.2126, 0.7152, 0.0722));
-    const mossMask = clamp(
-      pow(mossCoverage.mul(resolvedProfile.moss.multiply).mul(slope), 2),
-      0,
-      1,
-    );
+    let mossCoverage = dot(mossSample, vec3(0.2126, 0.7152, 0.0722));
+    // The shader has no coverage-mask input: it reuses the moss ALBEDO as its
+    // own mask. That texture is a colour map, so its luminance is
+    // high-frequency, and pushing it through the gain needed to clear its dark
+    // average (D19-032) binarises the grain into pepper — isolated bright
+    // texels scattered over the stone. It reads as lichen spotting, which is
+    // fine for incidental weathering on a distant cliff and wrong wherever
+    // moss is supposed to be a continuous cushion.
+    //
+    // `formDriven` blends the coverage source toward a constant, handing the
+    // patch shape to the smooth geometric moisture field (slope + cavity)
+    // instead. The texture then modulates a continuous cap rather than
+    // defining it, and `fringe` supplies the ragged boundary. 0 is the shipped
+    // behaviour. See D19-193.
+    if (resolvedProfile.moss.formDriven > 0) {
+      mossCoverage = mix(
+        mossCoverage,
+        float(1),
+        float(Math.min(1, resolvedProfile.moss.formDriven)),
+      );
+    }
+    // Moisture, not slope. Slope alone puts moss on upward faces and nowhere
+    // else, which is why a slope-only mask reads as a flat tint painted onto
+    // ledges. Real moss follows where water lingers and light is indirect:
+    // crevices, hollows, and the shaded junctions between slabs. `rockCavity`
+    // carries that concavity per vertex, so it adds moisture on vertical and
+    // shaded surfaces that the slope term scores at zero — and because it is an
+    // interpolated geometric field rather than a threshold on a constant, the
+    // resulting boundary is irregular and follows the form.
+    let moisture = resolvedAssetIntegration.vertexCavityStrength > 0
+      ? clamp(
+        slope.add(
+          attribute(ROCK_CAVITY_ATTRIBUTE, 'float')
+            .mul(resolvedAssetIntegration.vertexCavityStrength),
+        ),
+        0,
+        1,
+      )
+      : slope;
+    // ...and the other half of the same fact. `rockCavity` says where water
+    // lingers; nothing said where it never does. Both terms above only ever
+    // ADD, and `slope` saturates hard — at the garden's resolved sharpness 2.19
+    // / offset -0.205 it reaches 1.0 by n.y = 0.36, which is roughly the top
+    // two-thirds of a boulder. Across that whole region the support field is a
+    // constant 1 and carries no information about the form at all, so the
+    // colonisation noise alone decides where moss lands. Noise uncorrelated
+    // with form is exactly what camouflage is, and it is why moss sat as
+    // happily on an exposed sunlit crown as in a shaded hollow (D19-212).
+    //
+    // `rockExposure` is the rectified negative curvature from the same
+    // estimator, so crowns, ridges and shoulders finally score above zero and
+    // can be subtracted back out. Bare crowns are not a side effect here —
+    // they are the single strongest cue that moss grew rather than was printed.
+    if (
+      resolvedProfile.moss.exposure > 0
+      && resolvedAssetIntegration.vertexCavityStrength > 0
+    ) {
+      moisture = clamp(
+        moisture.sub(
+          attribute(ROCK_EXPOSURE_ATTRIBUTE, 'float')
+            .mul(resolvedProfile.moss.exposure),
+        ),
+        0,
+        1,
+      );
+    }
+    let mossMask;
+    if (resolvedProfile.moss.coverage >= 0) {
+      // --- coverage-mask path -------------------------------------------
+      //
+      // The legacy expression below squares its product and clamps, which
+      // makes the transition band extremely narrow: coverage crosses from 0 to
+      // 1 over a sliver of the moisture range. Since moisture is dominated by
+      // the upward-slope term, the result is a near-horizontal waterline with
+      // uniform moss above and bare stone below — the stone reads as dip-dyed
+      // to a level rather than colonised.
+      //
+      // Real moss is patchy: dense in hollows and on shaded faces, thinning to
+      // bare crowns and exposed ridges, with an irregular broken edge and
+      // detached islands. That needs a second, independent field — WHERE it
+      // actually took hold — which the shader had no input for. This is it.
+      //
+      //   support = where moss CAN grow   (slope + rockCavity)
+      //   patch   = where it DID colonise (fractal noise, world space)
+      //   gate    = support gated by patch
+      //   mask    = smoothstep across a WIDE band, not a squared clamp
+      //
+      // Noise is evaluated in world space, so two placements of the same asset
+      // colonise differently without needing a per-asset uniform, and a stone
+      // does not swim when the scene moves it.
+      const patchNoise = mx_fractal_noise_float(
+        positionWorld.div(Math.max(resolvedProfile.moss.patchScale, 0.01)),
+        Math.max(1, Math.trunc(resolvedProfile.moss.patchOctaves)),
+        2,
+        0.5,
+        1,
+      );
+      // fBm returns roughly [-1, 1]; remap, then push contrast so cushions
+      // separate into distinct masses instead of a smooth cloud.
+      const patch = clamp(
+        patchNoise.mul(0.5).add(0.5).sub(0.5)
+          .mul(resolvedProfile.moss.patchContrast)
+          .add(0.5),
+        0,
+        1,
+      );
+      const gate = moisture.mul(
+        mix(float(1), patch, float(resolvedProfile.moss.patchStrength)),
+      );
+      // Threshold IS the coverage dial: at coverage 1 moss takes every
+      // supported surface, at 0.15 only the wettest, best-colonised pockets.
+      const threshold = Math.min(0.98, Math.max(0.02,
+        1 - resolvedProfile.moss.coverage));
+      const band = Math.max(0.001, resolvedProfile.moss.band);
+      mossMask = clamp(
+        smoothstep(float(threshold - band), float(threshold + band), gate),
+        0,
+        1,
+      );
+      // Damp stone. Moss and stone read at a close value in life for a physical
+      // reason: moss only grows where the stone stays wet, and wet stone is
+      // markedly darker than dry stone. The shipped shader had no term for it,
+      // so the only levers on the moss/stone value gap were the shared palette
+      // (which belongs to the ground and the props owner too) and the scene's
+      // global grade. This is the correct third lever, and it also leaves a
+      // damp halo just outside each cushion — moss does not begin at a dry
+      // edge. The halo comes free by taking the same gate at a threshold one
+      // band-width lower, so it always tracks the moss it surrounds.
+      if (resolvedProfile.moss.damp > 0) {
+        mossDampNode = clamp(
+          smoothstep(
+            float(threshold - (band * 3)),
+            float(threshold + band),
+            gate,
+          ),
+          0,
+          1,
+        );
+      }
+      // The cushion's own form. `relief` flattens the STONE's detail normal
+      // under the moss, which stops crevices showing through, but nothing ever
+      // raised the moss itself — so the patch stayed geometrically identical to
+      // the rock beneath it and read as a decal (D19-213). A cushion is a soft
+      // raised mass, and what makes the eye read "raised" is that its shading
+      // normal tilts away from the surface as the mass swells.
+      //
+      // The patch field is already a height field in all but name: high inside
+      // a cushion, low outside. Its world-space gradient is therefore the slope
+      // of the cushion's surface, and the finite differences below cost three
+      // extra fBm evaluations at the same period the mask already uses, so the
+      // relief lands exactly on the patches rather than as unrelated bumps.
+      if (resolvedProfile.moss.cushion > 0) {
+        const period = Math.max(resolvedProfile.moss.patchScale, 0.01);
+        // TWO octaves, not the mask's five, and a step sized to them. The
+        // cushion's shape is the MASS of the mound, which is the low-frequency
+        // part of the patch field; the high octaves are the fibrous margin the
+        // `fringe` term already owns. Differencing across all five aliases
+        // those fine octaves and returns a noisy gradient that reads as grain
+        // rather than as a swelling — which is why the first attempt at this
+        // was invisible at any strength.
+        const octaves = 2;
+        const step = 0.14;
+        const at = (dx, dy, dz) => mx_fractal_noise_float(
+          positionWorld.div(period).add(vec3(dx, dy, dz)),
+          octaves,
+          2,
+          0.5,
+          1,
+        );
+        const centre = at(0, 0, 0);
+        mossCushionNode = vec3(
+          at(step, 0, 0).sub(centre),
+          at(0, step, 0).sub(centre),
+          at(0, 0, step).sub(centre),
+        ).div(step);
+      }
+    } else {
+      mossMask = clamp(
+        pow(mossCoverage.mul(resolvedProfile.moss.multiply).mul(moisture), 2),
+        0,
+        1,
+      );
+    }
+    if (resolvedProfile.moss.fringe > 0) {
+      // The mask above is a smooth curve, so its boundary is an airbrushed
+      // gradient — moss fading politely to nothing. Real moss ends in a ragged
+      // margin that breaks into detached fragments. Pushing the mask through a
+      // high-frequency field breaks the contour without moving the coverage:
+      // values well inside a patch stay saturated because the perturbation is
+      // weighted by `edge`, which is zero except in the transition band.
+      //
+      // THE SOURCE HAD TO CHANGE. This sampled the moss ALBEDO at a smaller
+      // period and centred it on 0.5, which cannot work and never did: that
+      // texture's linear luminance is 0.092-0.279 with 99.3% of its texels
+      // inside a single decile, so the term evaluated to a near-constant -0.75
+      // and the "fringe" was a uniform erosion of the boundary — the contour
+      // moved inward and stayed just as smooth. The centring assumed a balanced
+      // noise map and got a flat dark colour map (D19-211).
+      //
+      // World-space fBm at a fraction of the patch period is an actual noise
+      // field: balanced about zero by construction, independent of whatever
+      // albedo happens to be bound, and coherent across the triplanar seams the
+      // texture sample was not.
+      const fringeNoise = mx_fractal_noise_float(
+        positionWorld.div(Math.max(
+          resolvedProfile.moss.patchScale * resolvedProfile.moss.fringeScale,
+          0.01,
+        )),
+        3,
+        2,
+        0.5,
+        1,
+      );
+      // `edge` peaks at 1 in the middle of the transition and vanishes at both
+      // ends, so the fringe chews the boundary and leaves the interior alone.
+      const edge = mossMask.mul(mossMask.oneMinus()).mul(4);
+      mossMask = clamp(
+        mossMask.add(
+          fringeNoise.mul(edge).mul(resolvedProfile.moss.fringe),
+        ),
+        0,
+        1,
+      );
+    }
+    mossMaskNode = mossMask;
+    // Damp the STONE before the moss is mixed over it, so the darkening lands
+    // on bare rock in the halo and is simply overwritten inside the patches.
+    if (mossDampNode) {
+      colorNode = colorNode.mul(
+        float(1).sub(mossDampNode.mul(resolvedProfile.moss.damp)),
+      );
+    }
     colorNode = mix(colorNode, mossColor, mossMask);
+    // Contact shading. A raised mass occludes the crease where it meets the
+    // surface it sits on; without that line the eye has no evidence the cushion
+    // has any thickness, which is the other half of why moss read as flat. The
+    // `edge` weighting confines it to the margin, so cushion interiors and open
+    // stone are both untouched.
+    if (resolvedProfile.moss.contact > 0) {
+      // Cubed, not linear. `mask·(1-mask)·4` peaks at 1 but falls off slowly,
+      // and once `fringe` has chewed the boundary the mask is in transition
+      // across a wide, noisy region — so a linear weight smears sooty lace over
+      // half the stone instead of drawing a crease. The cube pulls it back to a
+      // narrow line hugging the actual margin.
+      const margin = pow(mossMask.mul(mossMask.oneMinus()).mul(4), float(3));
+      colorNode = colorNode.mul(
+        float(1).sub(margin.mul(resolvedProfile.moss.contact)),
+      );
+    }
   }
 
   let layerState = {
@@ -1175,6 +1694,22 @@ export function createToonRockMaterial({
     resolvedProfile.coordinates,
   );
   const sceneWaterLevel = uniform(-10000);
+  const sceneSkyColor = uniform(new Color(1, 1, 1));
+  const skyPeak = max(
+    max(sceneSkyColor.r, sceneSkyColor.g),
+    max(sceneSkyColor.b, float(0.001)),
+  );
+  const skyChroma = sceneSkyColor.div(skyPeak);
+  const lowLightProbeBlend = float(1).sub(smoothstep(
+    float(0.45),
+    float(0.8),
+    skyPeak,
+  ));
+  const readabilityTint = mix(
+    vec3(1, 1, 1),
+    skyChroma,
+    resolvedProfile.lighting.skyColorInfluence,
+  );
   const wetBandMask = clamp(
     abs(positionWorld.y.sub(sceneWaterLevel)).div(max(
       resolvedProfile.shoreline.wetBandWidth,
@@ -1188,11 +1723,21 @@ export function createToonRockMaterial({
   );
   layerState = {
     color: layerState.color
-      .mul(resolvedProfile.lighting.exposure)
       .mul(wetColorScale),
     emission: layerState.emission
-      .mul(resolvedProfile.lighting.exposure)
-      .add(layerState.color.mul(resolvedProfile.lighting.ambientFloor))
+      // A small albedo-relative floor keeps deep faces legible, but its color
+      // is transient scene state. Feeding the active sky here means the same
+      // sandstone is cool under a daylight sky and warm at golden hour without
+      // baking either cast into its geological Base Color.
+      .add(mix(
+        layerState.color.mul(readabilityTint),
+        vec3(dot(layerState.color, vec3(0.2126, 0.7152, 0.0722)))
+          .mul(readabilityTint),
+        lowLightProbeBlend.mul(0.7),
+      ).mul(
+        float(resolvedProfile.lighting.ambientFloor)
+          .mul(lowLightProbeBlend.mul(3).add(1)),
+      ))
       .mul(wetColorScale),
   };
   layerState = applyToonLabSubLayer(
@@ -1240,7 +1785,12 @@ export function createToonRockMaterial({
     // glTF metallic-roughness textures store perceptual roughness in G.
     // Blend that authored breakup into the shared rock smoothness instead of
     // retaining a texture reference that the visible shader never consumes.
-    const sourceSmoothness = texture(textures.sourceRoughness).sample(uv()).g.oneMinus();
+    const sourceSmoothness = clamp(
+      texture(textures.sourceRoughness).sample(uv()).g
+        .mul(resolvedAssetIntegration.sourceRoughnessFactor),
+      0,
+      1,
+    ).oneMinus();
     rockSmoothness = mix(
       rockSmoothness,
       sourceSmoothness,
@@ -1286,7 +1836,10 @@ export function createToonRockMaterial({
     );
     combinedNormal = toonLabNormalBlend(
       stylizedNormal,
-      toonLabNormalStrength(crackNormal, float(1).sub(flatness)),
+      toonLabNormalStrength(
+        crackNormal,
+        float(1).sub(flatness).mul(resolvedAssetIntegration.primaryNormalStrength),
+      ),
     );
   }
   if (
@@ -1309,6 +1862,20 @@ export function createToonRockMaterial({
     );
   }
 
+  // A moss cushion buries the relief underneath it. Flattening the rock's
+  // detail normal toward the surface normal wherever moss is dense is what
+  // separates "moss growing on stone" from "green painted over stone" — with
+  // the stone's crevice normals still showing through, the eye reads one
+  // surface with a colour on it. Applied before the top-layer blend so a
+  // grass/snow layer still wins where it overlaps.
+  if (mossMaskNode && resolvedProfile.moss.relief > 0) {
+    combinedNormal = normalize(mix(
+      combinedNormal,
+      vec3(0, 0, 1),
+      mossMaskNode.mul(resolvedProfile.moss.relief),
+    ));
+  }
+
   const hasTopLayer = resolvedProfile.layers.grass.enabled
     || resolvedProfile.layers.snow.enabled
     || resolvedProfile.layers.sand.enabled;
@@ -1335,12 +1902,92 @@ export function createToonRockMaterial({
     && resolvedProfile.layers.sand.useGroundShader
   );
   let metalnessNode = clamp(float(resolvedProfile.base.metallic), 0, 1);
+  if (
+    resolvedAssetIntegration.sourceAlbedoStrength > 0
+    && textures.sourceMetalness?.isTexture
+  ) {
+    // glTF packs metalness in B and roughness in G.
+    const sourceMetalness = clamp(
+      texture(textures.sourceMetalness).sample(uv()).b
+        .mul(resolvedAssetIntegration.sourceMetalnessFactor),
+      0,
+      1,
+    );
+    metalnessNode = mix(
+      metalnessNode,
+      sourceMetalness,
+      resolvedAssetIntegration.sourceAlbedoStrength,
+    );
+  }
   let roughnessNode = mix(
     clamp(finalSmoothness.oneMinus(), 0, 1),
     resolvedProfile.shoreline.wetRoughness,
     wetBandMask,
   );
-  let specularIntensityNode = float(1);
+  // Moss is matte and stone is not. Without this the moss patch carries the
+  // stone's specular response and lights like wet rock, which is most of why
+  // it reads as a stain rather than a plant.
+  if (mossMaskNode && resolvedProfile.moss.roughness >= 0) {
+    roughnessNode = mix(
+      roughnessNode,
+      float(Math.min(1, Math.max(0, resolvedProfile.moss.roughness))),
+      mossMaskNode,
+    );
+  }
+  let specularIntensityNode = float(resolvedAssetIntegration.primarySpecularStrength);
+  if (
+    resolvedAssetIntegration.sourceAlbedoStrength > 0
+    && textures.sourceSpecular?.isTexture
+  ) {
+    // KHR_materials_specular stores dielectric intensity in alpha.
+    const sourceSpecular = clamp(
+      texture(textures.sourceSpecular).sample(uv()).a
+        .mul(resolvedAssetIntegration.sourceSpecularFactor),
+      0,
+      1,
+    );
+    specularIntensityNode = mix(
+      specularIntensityNode,
+      sourceSpecular,
+      resolvedAssetIntegration.sourceAlbedoStrength,
+    );
+  }
+  // Each replaceable top layer owns its complete surface response. Applying
+  // these in the same grass -> snow -> sand order as color guarantees that a
+  // sand selection cannot retain grass color, roughness, metalness, or normal.
+  for (const [layer, roughnessMap] of [
+    [resolvedProfile.layers.grass, textures.grassRoughness],
+    [resolvedProfile.layers.snow, null],
+    [resolvedProfile.layers.sand, null],
+  ]) {
+    if (!layer.enabled) continue;
+    let layerRoughness = layer.roughness >= 0
+      ? float(Math.min(1, Math.max(0, layer.roughness)))
+      : roughnessNode;
+    if (roughnessMap?.isTexture) {
+      layerRoughness = clamp(
+        toonLabTriplanarColor(
+          roughnessMap,
+          layer.scale,
+          1,
+          resolvedProfile.coordinates,
+        ).r,
+        0,
+        1,
+      );
+    }
+    roughnessNode = mix(roughnessNode, layerRoughness, topMask);
+    if (layer.metalness >= 0) {
+      metalnessNode = mix(
+        metalnessNode,
+        float(Math.min(1, Math.max(0, layer.metalness))),
+        topMask,
+      );
+    }
+    // Source sublayers expose no separate specular map; replacing the layer
+    // therefore resets dielectric intensity instead of leaking stone response.
+    specularIntensityNode = mix(specularIntensityNode, float(1), topMask);
+  }
   if (useGroundTopSurface) {
     const groundSurface = sampleGroundSurface(positionWorld);
     const groundSurfaceMask = topMask.mul(groundSurface.a);
@@ -1367,13 +2014,52 @@ export function createToonRockMaterial({
     || (resolvedProfile.normals.useSmoothed && Boolean(textures.stylizedNormal))
     || hasSandNormalResponse;
   if (hasNormalResponse) material.normalNode = tangentNormalToView(combinedNormal);
+  // The moss cushion's relief, applied in WORLD space after the tangent chain
+  // rather than inside it. The cushion field is world-space fBm and the mask is
+  // built from world-space terms, so expressing the tilt in tangent space would
+  // mean routing a world gradient through a TBN that some authored rock UV
+  // islands cannot supply — the same degenerate-tangent hazard the guard above
+  // exists for. Perturbing the geometric normal instead needs no tangents at
+  // all, which also lets the cushion be the sole normal response on an asset
+  // that binds no normal map.
+  if (mossMaskNode && mossCushionNode && resolvedProfile.moss.cushion > 0) {
+    const surface = normalWorldGeometry;
+    // Keep only the component of the gradient lying in the surface's tangent
+    // plane; the part along the normal would scale the normal rather than tilt
+    // it, which is not a slope.
+    const tangential = mossCushionNode.sub(
+      surface.mul(dot(mossCushionNode, surface)),
+    );
+    // Downhill on the height field means the surface tips that way, hence the
+    // subtraction. Scaled by the mask so bare stone is untouched and the tilt
+    // fades in exactly where the cushion swells.
+    const cushionWorld = normalize(
+      surface.sub(tangential.mul(
+        mossMaskNode.mul(resolvedProfile.moss.cushion * 1.6),
+      )),
+    );
+    // Two arguments, not one: the second is the matrix to transform BY. The
+    // cushion normal is world-space, so that is the camera view matrix.
+    const cushionView = transformNormalByViewMatrix(cushionWorld, cameraViewMatrix);
+    material.normalNode = hasNormalResponse
+      ? normalize(mix(material.normalNode, cushionView, mossMaskNode))
+      : cushionView;
+  }
   material.metalnessNode = metalnessNode;
   // TOONLAB exposes smoothness while Three exposes roughness.
   material.roughnessNode = roughnessNode;
   // TOONLAB metallic workflow's dielectric reflectance is 0.04, matching IOR 1.5.
   material.iorNode = float(1.5);
   material.specularIntensityNode = specularIntensityNode;
-  material.emissiveNode = layerState.emission;
+  const sourceEmission = textures.sourceEmissive?.isTexture
+    ? texture(textures.sourceEmissive).sample(uv()).rgb.mul(
+      vec3(...resolvedAssetIntegration.sourceEmissive),
+    ).mul(resolvedAssetIntegration.sourceEmissiveIntensity)
+    : vec3(...resolvedAssetIntegration.sourceEmissive)
+      .mul(resolvedAssetIntegration.sourceEmissiveIntensity);
+  material.emissiveNode = layerState.emission.add(
+    sourceEmission.mul(resolvedAssetIntegration.sourceAlbedoStrength),
+  );
   const vertexAoNode = resolvedAssetIntegration.vertexAoStrength > 0
     ? clamp(
       mix(
@@ -1385,27 +2071,55 @@ export function createToonRockMaterial({
       1,
     )
     : float(1);
+  const primaryAoNode = textures.rockAo?.isTexture
+    ? clamp(toonLabRockProjection(textures.rockAo, resolvedProfile).r, 0, 1)
+    : float(1);
+  const authoredAoNode = vertexAoNode.mul(primaryAoNode);
   material.aoNode = (
     resolvedAssetIntegration.sourceAoStrength > 0
     && textures.sourceAo?.isTexture
   )
-    ? vertexAoNode.mul(mix(
+    ? authoredAoNode.mul(mix(
       float(1),
       texture(textures.sourceAo).sample(uv()).r,
       resolvedAssetIntegration.sourceAoStrength,
     ))
-    : vertexAoNode;
-  material.transparent = false;
-  material.opacity = 1;
+    : authoredAoNode;
+  const usesSourceAlpha = resolvedAssetIntegration.sourceAlphaTest > 0
+    || resolvedAssetIntegration.sourceTransparent
+    || resolvedAssetIntegration.sourceOpacity < 1;
+  if (usesSourceAlpha) {
+    material.opacityNode = textures.sourceRock?.isTexture
+      ? texture(textures.sourceRock).sample(uv()).a.mul(resolvedAssetIntegration.sourceOpacity)
+      : float(resolvedAssetIntegration.sourceOpacity);
+    material.alphaTestNode = resolvedAssetIntegration.sourceAlphaTest > 0
+      ? float(resolvedAssetIntegration.sourceAlphaTest)
+      : null;
+  }
+  material.transparent = usesSourceAlpha && resolvedAssetIntegration.sourceTransparent;
+  material.opacity = usesSourceAlpha ? resolvedAssetIntegration.sourceOpacity : 1;
   material.alphaTest = 0;
-  material.depthWrite = true;
+  material.depthWrite = usesSourceAlpha ? resolvedAssetIntegration.sourceDepthWrite : true;
+  if (resolvedAssetIntegration.sourceSide !== null) material.side = resolvedAssetIntegration.sourceSide;
   material.userData.toonLabRockProfile = resolvedProfile;
   material.userData.toonLabRockSceneState = {
+    setSkyColor(value) {
+      const channels = value?.isColor
+        ? [value.r, value.g, value.b]
+        : Array.isArray(value) || ArrayBuffer.isView(value)
+          ? Array.from(value).slice(0, 3).map(Number)
+          : null;
+      if (channels?.length === 3 && channels.every(Number.isFinite)) {
+        sceneSkyColor.value.setRGB(...channels);
+      }
+      return sceneSkyColor.value.toArray();
+    },
     setWaterLevel(value) {
       const next = Number(value);
       if (Number.isFinite(next)) sceneWaterLevel.value = next;
       return sceneWaterLevel.value;
     },
+    skyColor: sceneSkyColor,
     waterLevel: sceneWaterLevel,
   };
   material.userData.toonLabRockAssetIntegration = resolvedAssetIntegration;
@@ -1450,9 +2164,38 @@ export function createToonRockMaterial({
     keepsTextures: true,
     vertexDeformation: false,
   });
+  const warmSkyBlend = smoothstep(
+    float(0),
+    float(0.25),
+    sceneSkyColor.r.sub(sceneSkyColor.b),
+  );
+  const preserveProbeChroma = max(warmSkyBlend, lowLightProbeBlend);
   installToonLabSurfaceLighting(material, {
+    // Keep geological Base Color invariant. The captured intensity-8 sun still
+    // needs the historical rock calibration, but applying it to albedo also
+    // crushed the sky probe and every shaded face. Direct light owns that
+    // calibration now; indirect light and the readability floor see the real
+    // material color.
+    directStrength: resolvedProfile.lighting.exposure,
     indirectStrength: resolvedProfile.lighting.skyFillStrength,
     indirectTint: resolvedProfile.lighting.skyFillTint,
+    // The scene probe supplies irradiance magnitude, while this live uniform
+    // supplies its visible time-of-day colour. This preserves geological Base
+    // Color and makes the same shaded face blue at noon, warm at sunset, and
+    // deep blue at night without rebuilding or retexturing the material.
+    // A bright neutral daytime probe receives visible-sky chroma. Low-light
+    // and warm-hour probes already contain their authored colour, so preserve
+    // them instead of multiplying that colour a second time. Double-tinting
+    // the dark-blue night probe crushed red sandstone almost to black.
+    indirectTintNode: mix(skyChroma, vec3(1), preserveProbeChroma)
+      .mul(vec3(...resolvedProfile.lighting.skyFillTint)),
+    indirectTintMode: 'multiply',
+    shadowFill: resolvedProfile.lighting.shadowFill,
+    shadowFillTint: resolvedProfile.lighting.shadowFillTint,
+    // Native directional shadows already cover these meshes. Re-sampling the
+    // package depth atlas here double-shadowed the full rock at sunset; cloud
+    // transmittance remains shared inside the lighting bridge.
+    useSharedSunShadow: false,
     workflow: 'metallic',
   });
   return material;