@call-me-sensei/toonlab 0.3.1 → 0.4.20

package/src/shaders-tsl/chunks/scene-depth-color-pass.js

@@ -0,0 +1,273 @@
+// Per-material scene depth-as-color pass for post effects.
+//
+// A scene.overrideMaterial depth pass cannot preserve a source NodeMaterial's
+// color-depth output, alpha mask, WPO, and cull state at the same time: Three
+// treats an isShadowPassMaterial override as a native ShadowCaster material,
+// replaces its color node, and flips one-sided culling. Material swaps avoid
+// that renderer ambiguity and let exact sources provide one coupled variant.
+
+import * as THREE from 'three';
+
+import { createPassDepthColorMaterial } from './pass-depth-color.js';
+
+const normalizeMaterials = (material) => (
+  Array.isArray(material) ? material : [material]
+);
+
+function sourceCutoff(material) {
+  const value = material?.uniforms?.aCutoff?.value
+    ?? material?.uniforms?.alphaCutoff?.value
+    ?? (material?.alphaTest > 0 ? material.alphaTest : -1);
+  const result = Number(value);
+  return Number.isFinite(result) && result > 0 ? result : 0;
+}
+
+function sourceMap(material) {
+  return material?.uniforms?.base?.value
+    ?? material?.uniforms?.baseMap?.value
+    ?? material?.map
+    ?? null;
+}
+
+/**
+ * Create a reusable camera-depth pass. Exact NodeMaterials should expose
+ * `userData.createDepthColorVariant`; generic materials retain any directly
+ * available position/mask nodes and report that fallback explicitly.
+ */
+export function createSceneDepthColorPass({ scene } = {}) {
+  if (!scene?.traverse) throw new TypeError('createSceneDepthColorPass requires a Three Scene.');
+
+  const materialCache = new WeakMap();
+  const materialVariants = new Set();
+  const meshSwapCache = new WeakMap();
+  const materialRestores = [];
+  const visibilityRestores = [];
+  const clearColor = new THREE.Color();
+  const emptyMaterial = createPassDepthColorMaterial();
+  emptyMaterial.name = 'SceneDepthColor:Empty';
+  emptyMaterial.visible = false;
+  materialVariants.add(emptyMaterial);
+  let disposed = false;
+
+  const counters = {
+    coupledVariantCreateCount: 0,
+    genericMaskNodeCount: 0,
+    genericPositionNodeCount: 0,
+    genericVariantCreateCount: 0,
+    hiddenDerivedMeshCount: 0,
+    hiddenNonDepthMeshCount: 0,
+    renderCount: 0,
+    swappedMeshCount: 0,
+  };
+
+  function createVariant(material) {
+    let depthMaterial;
+    const coupledFactory = material?.userData?.createDepthColorVariant;
+    if (typeof coupledFactory === 'function') {
+      depthMaterial = coupledFactory();
+      counters.coupledVariantCreateCount += 1;
+    } else {
+      const alphaTest = sourceCutoff(material);
+      depthMaterial = createPassDepthColorMaterial({
+        alphaTest,
+        map: alphaTest > 0 ? sourceMap(material) : null,
+        side: material?.side ?? THREE.FrontSide,
+      });
+      counters.genericVariantCreateCount += 1;
+      // Preserve the subset the renderer can prove from a generic
+      // NodeMaterial. A family with custom vertexNode/fragmentNode logic must
+      // expose createDepthColorVariant to be classified exact.
+      if (material?.positionNode?.isNode) {
+        depthMaterial.positionNode = material.positionNode;
+        counters.genericPositionNodeCount += 1;
+      }
+      const maskNode = material?.maskNode?.isNode ? material.maskNode : null;
+      if (maskNode) {
+        depthMaterial.maskNode = maskNode;
+        depthMaterial.maskShadowNode = material.maskShadowNode?.isNode
+          ? material.maskShadowNode
+          : maskNode;
+        counters.genericMaskNodeCount += 1;
+      }
+    }
+    if (!depthMaterial?.isMaterial) {
+      throw new TypeError(
+        `${material?.name || 'Material'}.createDepthColorVariant() must return a Three Material.`,
+      );
+    }
+    depthMaterial.name ||= `${material?.name || 'Material'}:SceneDepthColor`;
+    depthMaterial.fog = false;
+    depthMaterial.side = material?.side ?? depthMaterial.side;
+    depthMaterial.shadowSide = depthMaterial.side;
+    depthMaterial.forceSinglePass = material?.forceSinglePass ?? depthMaterial.forceSinglePass;
+    depthMaterial.depthTest = material?.depthTest !== false;
+    depthMaterial.depthWrite = true;
+    depthMaterial.transparent = false;
+    depthMaterial.userData.sceneDepthColorPass = {
+      coupled: typeof coupledFactory === 'function',
+      exact: Boolean(
+        depthMaterial.userData?.toonLabPassCoupling?.exact
+        || material?.userData?.toonLabPassCoupling?.exact,
+      ),
+      maskSource: depthMaterial.maskNode?.isNode ? 'source-node' : 'opaque-or-alpha-test',
+      positionSource: depthMaterial.positionNode?.isNode ? 'source-node' : 'authored-position',
+      sourceMaterialName: material?.name || null,
+      sourceMaterialUuid: material?.uuid ?? null,
+      sourceSide: material?.side ?? THREE.FrontSide,
+      sourceVersion: material?.version ?? 0,
+    };
+    materialVariants.add(depthMaterial);
+    return depthMaterial;
+  }
+
+  function depthMaterialFor(material) {
+    if (!material?.isMaterial) return emptyMaterial;
+    let cached = materialCache.get(material);
+    if (!cached || cached.version !== material.version) {
+      if (cached) {
+        cached.material.dispose();
+        materialVariants.delete(cached.material);
+      }
+      cached = {
+        material: createVariant(material),
+        version: material.version,
+      };
+      materialCache.set(material, cached);
+    }
+    cached.material.visible = material.visible !== false && material.depthWrite !== false;
+    return cached.material;
+  }
+
+  function swappedMaterials(source) {
+    return Array.isArray(source)
+      ? source.map((material) => depthMaterialFor(material))
+      : depthMaterialFor(source);
+  }
+
+  function refreshSwap(mesh) {
+    const source = mesh.material;
+    let swap = meshSwapCache.get(mesh);
+    if (!swap || swap.source !== source) {
+      swap = { source, swapped: swappedMaterials(source) };
+      meshSwapCache.set(mesh, swap);
+    } else if (Array.isArray(source)) {
+      for (let index = 0; index < source.length; index += 1) {
+        swap.swapped[index] = depthMaterialFor(source[index]);
+      }
+    } else {
+      swap.swapped = depthMaterialFor(source);
+    }
+    return swap.swapped;
+  }
+
+  function restoreScene() {
+    for (const { material, mesh } of materialRestores) mesh.material = material;
+    for (const object of visibilityRestores) object.visible = true;
+    materialRestores.length = 0;
+    visibilityRestores.length = 0;
+  }
+
+  function render(renderer, camera, target) {
+    if (disposed) throw new Error('Scene depth-color pass is disposed.');
+    if (!renderer?.render || !renderer?.setRenderTarget) {
+      throw new TypeError('A Three renderer is required.');
+    }
+    if (!camera?.isCamera) throw new TypeError('A Three Camera is required.');
+    if (!target?.isRenderTarget) throw new TypeError('A Three RenderTarget is required.');
+
+    materialRestores.length = 0;
+    visibilityRestores.length = 0;
+    let hiddenDerivedMeshCount = 0;
+    let hiddenNonDepthMeshCount = 0;
+    let swappedMeshCount = 0;
+
+    const previousTarget = renderer.getRenderTarget();
+    const previousBackground = scene.background;
+    const previousFog = scene.fog;
+    const previousOverrideMaterial = scene.overrideMaterial;
+    renderer.getClearColor(clearColor);
+    const previousClearAlpha = renderer.getClearAlpha();
+    const previousShadowEnabled = renderer.shadowMap?.enabled;
+    try {
+      scene.traverseVisible((object) => {
+        const renderable = object.isMesh || object.isPoints || object.isLine || object.isSprite;
+        if (!renderable) return;
+        if (!object.isMesh || object.userData?.isToonOutline || object.userData?.isToonFurShell) {
+          object.visible = false;
+          visibilityRestores.push(object);
+          hiddenDerivedMeshCount += 1;
+          return;
+        }
+        const sourceMaterials = normalizeMaterials(object.material);
+        const participates = sourceMaterials.some((material) => (
+          material?.visible !== false && material?.depthWrite !== false
+        ));
+        if (!participates) {
+          object.visible = false;
+          visibilityRestores.push(object);
+          hiddenNonDepthMeshCount += 1;
+          return;
+        }
+        materialRestores.push({ material: object.material, mesh: object });
+        object.material = refreshSwap(object);
+        swappedMeshCount += 1;
+      });
+
+      scene.background = null;
+      scene.fog = null;
+      scene.overrideMaterial = null;
+      if (renderer.shadowMap) renderer.shadowMap.enabled = false;
+      renderer.setRenderTarget(target);
+      renderer.setClearColor(0xffffff, 1);
+      renderer.clear();
+      renderer.render(scene, camera);
+    } finally {
+      restoreScene();
+      scene.background = previousBackground;
+      scene.fog = previousFog;
+      scene.overrideMaterial = previousOverrideMaterial;
+      renderer.setRenderTarget(previousTarget);
+      renderer.setClearColor(clearColor, previousClearAlpha);
+      if (renderer.shadowMap) renderer.shadowMap.enabled = previousShadowEnabled;
+    }
+
+    counters.hiddenDerivedMeshCount = hiddenDerivedMeshCount;
+    counters.hiddenNonDepthMeshCount = hiddenNonDepthMeshCount;
+    counters.renderCount += 1;
+    counters.swappedMeshCount = swappedMeshCount;
+    return report();
+  }
+
+  function report() {
+    const liveVariants = [...materialVariants].filter((material) => material !== emptyMaterial);
+    const coupledVariantCount = liveVariants.filter((material) => (
+      material.userData?.sceneDepthColorPass?.coupled === true
+    )).length;
+    const genericVariantCount = liveVariants.length - coupledVariantCount;
+    return Object.freeze({
+      ...counters,
+      coupledVariantCount,
+      exactVariantCount: liveVariants.filter((material) => (
+        material.userData?.sceneDepthColorPass?.exact === true
+      )).length,
+      genericVariantCount,
+      materialVariantCount: liveVariants.length,
+      remainingGenericVariantCount: genericVariantCount,
+    });
+  }
+
+  function dispose() {
+    if (disposed) return;
+    disposed = true;
+    restoreScene();
+    for (const material of materialVariants) material.dispose();
+    materialVariants.clear();
+  }
+
+  return Object.freeze({
+    depthMaterialFor,
+    dispose,
+    render,
+    report,
+  });
+}

package/src/shaders-tsl/chunks/vegetation-style.js

@@ -44,20 +44,28 @@ const FALLBACK = Object.freeze({
   }),
   grass: Object.freeze({
     backlitStrength: 0.4,
+    baseColor: Object.freeze([0.172518, 0.317708, 0.052621]),
     bandSoftness: 0.1,
     bandThreshold: 0.49,
     bendExponent: 2,
     cloudShadowResponse: 0.35,
     colorVariationStrength: 0.2,
+    emissiveStrength: 0,
     gustSheenStrength: 0.22,
     gustSheenThreshold: 0.78,
     interactionResponse: 1,
+    roughness: 0.5,
     rootOcclusionHeight: 0.62,
     rootOcclusionStrength: 0.36,
     sceneShadowResponse: 0.7,
     shadowFloor: 0.35,
+    specularStrength: 0.04,
+    styleColorStrength: 0,
+    tipBrightness: 0.1,
+    tipDesaturation: -0.5,
     tipGradientEnd: 0.95,
     tipGradientStart: 0.1,
+    tipHueShift: -0.06,
   }),
   foliage: Object.freeze({
     backlitStrength: 0.35,
@@ -68,8 +76,20 @@ const FALLBACK = Object.freeze({
     crestSoftness: 0.12,
     crestThreshold: 0.72,
     crownOcclusionStrength: 0.2,
+    emissiveStrength: 0.25,
+    gradientColor: Object.freeze([0.076185, 0.198069, 0.016807]),
+    gradientContrast: 0.821665,
+    gradientOffset: 0.088,
+    hueShift: 0,
+    hueVariation: 0.1,
+    mainColor: Object.freeze([0.040915, 0.135633, 0.015209]),
+    roughness: 0.75,
     sceneShadowResponse: 0.55,
+    specularStrength: 0.1,
     spriteLuminanceStrength: 0.36,
+    styleColorStrength: 0,
+    subsurfaceOpacity: 0.3,
+    subsurfaceStrength: 0.8,
     transmissionPowerMultiplier: 1,
   }),
   flower: Object.freeze({
@@ -79,25 +99,42 @@ const FALLBACK = Object.freeze({
     centerLightResponse: 0.8,
     centerShadowResponse: 1,
     cupDarkeningStrength: 0.1,
+    emissiveStrength: 0,
     petalTransmissionMultiplier: 1,
+    roughness: 0.5,
     sceneShadowResponse: 0.85,
+    specularStrength: 0.05,
+    subsurfaceOpacity: 0.08,
+    subsurfaceStrength: 0.3,
+    textureTint: Object.freeze([1, 1, 1]),
+    tintStrength: 1,
     unlitPetalLift: 0.35,
   }),
   bark: Object.freeze({
     bandCount: 3,
     bandSoftness: 0,
+    emissiveStrength: 0,
+    normalFlatness: 0,
     rimStrength: 0,
+    roughness: 1,
     shadowFloor: 0.35,
     skyFillStrength: 0.04,
     specularStrength: 0,
     sunTintStrength: 0.15,
+    tint: Object.freeze([0.938, 0.3752, 0]),
+    tintStrength: 0,
     verticalShadeStrength: 0,
   }),
   stem: Object.freeze({
     bandCount: 3,
     bandSoftness: 0.08,
+    color: Object.freeze([0.155926, 0.332452, 0.066626]),
+    colorStrength: 0,
+    emissiveStrength: 0,
+    roughness: 0.5,
     shadowFloor: 0.42,
     skyFillStrength: 0.06,
+    specularStrength: 0.05,
     transmissionStrength: 0.08,
     rimStrength: 0.02,
   }),
@@ -124,6 +161,11 @@ export function createVegetationStyleUniforms(profile = {}, role = null) {
   const u = {
     uSnowCover: uniform(0),
     uSnowRetention: uniform(1),
+    // Transient world illumination. These are deliberately outside the
+    // portable style schema: time of day changes them without modifying a
+    // Tree, Grass, or Flower profile.
+    uSkyIntensity: uniform(1),
+    uSunIntensity: uniform(1),
     uStyleLightingRimPower: uniform(value(settings, 'lighting', 'rimPower')),
     uStyleLightingRimStrength: uniform(value(settings, 'lighting', 'rimStrength')),
     uStyleLightingShadowTint: uniform(color(settings, 'lighting', 'shadowTint')),
@@ -150,20 +192,28 @@ export function createVegetationStyleUniforms(profile = {}, role = null) {
   });
   if (hasRole('grassBlade')) Object.assign(u, {
     uStyleGrassBacklitStrength: uniform(value(settings, 'grass', 'backlitStrength')),
+    uStyleGrassBaseColor: uniform(color(settings, 'grass', 'baseColor')),
     uStyleGrassBandSoftness: uniform(value(settings, 'grass', 'bandSoftness')),
     uStyleGrassBandThreshold: uniform(value(settings, 'grass', 'bandThreshold')),
     uStyleGrassBendExponent: uniform(value(settings, 'grass', 'bendExponent')),
     uStyleGrassCloudShadowResponse: uniform(value(settings, 'grass', 'cloudShadowResponse')),
     uStyleGrassColorVariationStrength: uniform(value(settings, 'grass', 'colorVariationStrength')),
+    uStyleGrassEmissiveStrength: uniform(value(settings, 'grass', 'emissiveStrength')),
     uStyleGrassGustSheenStrength: uniform(value(settings, 'grass', 'gustSheenStrength')),
     uStyleGrassGustSheenThreshold: uniform(value(settings, 'grass', 'gustSheenThreshold')),
     uStyleGrassInteractionResponse: uniform(value(settings, 'grass', 'interactionResponse')),
+    uStyleGrassRoughness: uniform(value(settings, 'grass', 'roughness')),
     uStyleGrassRootOcclusionHeight: uniform(value(settings, 'grass', 'rootOcclusionHeight')),
     uStyleGrassRootOcclusionStrength: uniform(value(settings, 'grass', 'rootOcclusionStrength')),
     uStyleGrassSceneShadowResponse: uniform(value(settings, 'grass', 'sceneShadowResponse')),
     uStyleGrassShadowFloor: uniform(value(settings, 'grass', 'shadowFloor')),
+    uStyleGrassSpecularStrength: uniform(value(settings, 'grass', 'specularStrength')),
+    uStyleGrassStyleColorStrength: uniform(value(settings, 'grass', 'styleColorStrength')),
+    uStyleGrassTipBrightness: uniform(value(settings, 'grass', 'tipBrightness')),
+    uStyleGrassTipDesaturation: uniform(value(settings, 'grass', 'tipDesaturation')),
     uStyleGrassTipGradientEnd: uniform(value(settings, 'grass', 'tipGradientEnd')),
     uStyleGrassTipGradientStart: uniform(value(settings, 'grass', 'tipGradientStart')),
+    uStyleGrassTipHueShift: uniform(value(settings, 'grass', 'tipHueShift')),
   });
   if (hasRole('foliageCard')) Object.assign(u, {
     uStyleFoliageBacklitStrength: uniform(value(settings, 'foliage', 'backlitStrength')),
@@ -174,19 +224,38 @@ export function createVegetationStyleUniforms(profile = {}, role = null) {
     uStyleFoliageCrestSoftness: uniform(value(settings, 'foliage', 'crestSoftness')),
     uStyleFoliageCrestThreshold: uniform(value(settings, 'foliage', 'crestThreshold')),
     uStyleFoliageCrownOcclusionStrength: uniform(value(settings, 'foliage', 'crownOcclusionStrength')),
+    uStyleFoliageEmissiveStrength: uniform(value(settings, 'foliage', 'emissiveStrength')),
+    uStyleFoliageGradientColor: uniform(color(settings, 'foliage', 'gradientColor')),
+    uStyleFoliageGradientContrast: uniform(value(settings, 'foliage', 'gradientContrast')),
+    uStyleFoliageGradientOffset: uniform(value(settings, 'foliage', 'gradientOffset')),
+    uStyleFoliageHueShift: uniform(value(settings, 'foliage', 'hueShift')),
+    uStyleFoliageHueVariation: uniform(value(settings, 'foliage', 'hueVariation')),
+    uStyleFoliageMainColor: uniform(color(settings, 'foliage', 'mainColor')),
+    uStyleFoliageRoughness: uniform(value(settings, 'foliage', 'roughness')),
     uStyleFoliageSceneShadowResponse: uniform(value(settings, 'foliage', 'sceneShadowResponse')),
+    uStyleFoliageSpecularStrength: uniform(value(settings, 'foliage', 'specularStrength')),
     uStyleFoliageSpriteLuminanceStrength: uniform(value(settings, 'foliage', 'spriteLuminanceStrength')),
+    uStyleFoliageStyleColorStrength: uniform(value(settings, 'foliage', 'styleColorStrength')),
+    uStyleFoliageSubsurfaceOpacity: uniform(value(settings, 'foliage', 'subsurfaceOpacity')),
+    uStyleFoliageSubsurfaceStrength: uniform(value(settings, 'foliage', 'subsurfaceStrength')),
     uStyleFoliageTransmissionPowerMultiplier: uniform(value(settings, 'foliage', 'transmissionPowerMultiplier')),
   });
   if (hasRole('flowerPetal', 'flowerCenter')) Object.assign(u, {
     uStyleFlowerBandSoftness: uniform(value(settings, 'flower', 'bandSoftness')),
     uStyleFlowerBandThreshold: uniform(value(settings, 'flower', 'bandThreshold')),
+    uStyleFlowerEmissiveStrength: uniform(value(settings, 'flower', 'emissiveStrength')),
+    uStyleFlowerRoughness: uniform(value(settings, 'flower', 'roughness')),
     uStyleFlowerSceneShadowResponse: uniform(value(settings, 'flower', 'sceneShadowResponse')),
+    uStyleFlowerSpecularStrength: uniform(value(settings, 'flower', 'specularStrength')),
+    uStyleFlowerTextureTint: uniform(color(settings, 'flower', 'textureTint')),
+    uStyleFlowerTintStrength: uniform(value(settings, 'flower', 'tintStrength')),
   });
   if (hasRole('flowerPetal')) Object.assign(u, {
     uStyleFlowerBacklitStrength: uniform(value(settings, 'flower', 'backlitStrength')),
     uStyleFlowerCupDarkeningStrength: uniform(value(settings, 'flower', 'cupDarkeningStrength')),
     uStyleFlowerPetalTransmissionMultiplier: uniform(value(settings, 'flower', 'petalTransmissionMultiplier')),
+    uStyleFlowerSubsurfaceOpacity: uniform(value(settings, 'flower', 'subsurfaceOpacity')),
+    uStyleFlowerSubsurfaceStrength: uniform(value(settings, 'flower', 'subsurfaceStrength')),
     uStyleFlowerUnlitPetalLift: uniform(value(settings, 'flower', 'unlitPetalLift')),
   });
   if (hasRole('flowerCenter')) Object.assign(u, {
@@ -196,19 +265,29 @@ export function createVegetationStyleUniforms(profile = {}, role = null) {
   if (hasRole('herbaceousStem')) Object.assign(u, {
     uStyleStemBandCount: uniform(value(settings, 'stem', 'bandCount')),
     uStyleStemBandSoftness: uniform(value(settings, 'stem', 'bandSoftness')),
+    uStyleStemColor: uniform(color(settings, 'stem', 'color')),
+    uStyleStemColorStrength: uniform(value(settings, 'stem', 'colorStrength')),
+    uStyleStemEmissiveStrength: uniform(value(settings, 'stem', 'emissiveStrength')),
+    uStyleStemRoughness: uniform(value(settings, 'stem', 'roughness')),
     uStyleStemShadowFloor: uniform(value(settings, 'stem', 'shadowFloor')),
     uStyleStemRimStrength: uniform(value(settings, 'stem', 'rimStrength')),
     uStyleStemSkyFillStrength: uniform(value(settings, 'stem', 'skyFillStrength')),
+    uStyleStemSpecularStrength: uniform(value(settings, 'stem', 'specularStrength')),
     uStyleStemTransmissionStrength: uniform(value(settings, 'stem', 'transmissionStrength')),
   });
   if (hasRole('woodySurface')) Object.assign(u, {
     uStyleBarkBandCount: uniform(value(settings, 'bark', 'bandCount')),
     uStyleBarkBandSoftness: uniform(value(settings, 'bark', 'bandSoftness')),
+    uStyleBarkEmissiveStrength: uniform(value(settings, 'bark', 'emissiveStrength')),
+    uStyleBarkNormalFlatness: uniform(value(settings, 'bark', 'normalFlatness')),
     uStyleBarkRimStrength: uniform(value(settings, 'bark', 'rimStrength')),
+    uStyleBarkRoughness: uniform(value(settings, 'bark', 'roughness')),
     uStyleBarkShadowFloor: uniform(value(settings, 'bark', 'shadowFloor')),
     uStyleBarkSkyFillStrength: uniform(value(settings, 'bark', 'skyFillStrength')),
     uStyleBarkSpecularStrength: uniform(value(settings, 'bark', 'specularStrength')),
     uStyleBarkSunTintStrength: uniform(value(settings, 'bark', 'sunTintStrength')),
+    uStyleBarkTint: uniform(color(settings, 'bark', 'tint')),
+    uStyleBarkTintStrength: uniform(value(settings, 'bark', 'tintStrength')),
     uStyleBarkVerticalShadeStrength: uniform(value(settings, 'bark', 'verticalShadeStrength')),
   });
   return u;
@@ -233,6 +312,7 @@ export function vegetationVisibility(
 /** Common thin-surface lighting. Family shaders can layer role bands on top. */
 export function shadeVegetationSurface({
   baseColor,
+  bandShadowColor = null,
   bandOverride = null,
   bandSoftness,
   bandThreshold,
@@ -277,7 +357,14 @@ export function shadeVegetationSurface({
   ).toVar();
   const band = (bandOverride ?? vegetationBand(wrap, bandThreshold, bandSoftness))
     .mul(visibility).toVar();
-  const colorNode = baseColor.mul(mix(shadowFloor, 1.0, band)).toVar();
+  // Most materials use a scalar floor. Foliage assets already author a
+  // semantic shadow palette, so they can supply it directly and let this one
+  // canonical band—not a second private band—control their full value range.
+  const colorNode = (
+    bandShadowColor
+      ? mix(bandShadowColor, baseColor, band)
+      : baseColor.mul(mix(shadowFloor, 1.0, band))
+  ).toVar();
 
   // An asset palette may carry its own shadow tone (grass and tree foliage
   // are the common cases). It establishes the material identity in shadow;
@@ -297,24 +384,34 @@ export function shadeVegetationSurface({
     clamp(shadowAmount, 0, 1),
   ));
   colorNode.mulAssign(mix(vec3(1), sunColor, band.mul(u.uStyleLightingSunTintStrength)));
-  colorNode.addAssign(skyColor.mul(band.oneMinus()).mul(skyFillStrength));
+  // Vegetation fill is reflected light from the authored surface, not a
+  // screen-space blue/white veil. Adding the sky color directly can exceed
+  // the albedo several times over once rim and transmission are also active,
+  // clipping saturated procedural palettes to pastel white.
+  colorNode.addAssign(
+    baseColor.mul(skyColor).mul(band.oneMinus()).mul(skyFillStrength),
+  );
 
   const viewDirection = normalize(cameraPosition.sub(worldPosition));
   const rim = pow(
     clamp(abs(dot(styledNormal, viewDirection)).oneMinus(), 0, 1),
     u.uStyleLightingRimPower,
   );
-  colorNode.addAssign(skyColor.mul(rim).mul(rimStrength));
+  colorNode.addAssign(
+    baseColor.mul(skyColor).mul(rim).mul(rimStrength),
+  );
   const transmission = pow(
     clamp(dot(viewDirection, sun.negate()), 0, 1),
     transmissionPower,
   ).mul(transmissionStrength).mul(transmissionMultiplier);
   colorNode.addAssign(
-    sunColor.mul(transmission).mul(mix(
-      transmissionShadowFloor,
-      1,
-      visibility,
-    )),
+    baseColor.mul(sunColor).mul(transmission).mul(
+      mix(
+        transmissionShadowFloor,
+        1,
+        visibility,
+      ),
+    ),
   );
 
   const wet = clamp(u.uWetness.mul(u.uWetnessResponse), 0, 1).toVar();
@@ -344,6 +441,17 @@ export function shadeVegetationSurface({
     visibility,
   ));
   colorNode.assign(mix(colorNode, snowTint, snow));
+  // The custom vegetation graph is intentionally self-shaded, so it does not
+  // receive renderer light intensity automatically. Combine the transient
+  // ambient and direct energies here; day remains the calibrated 1.0
+  // baseline, while night can actually fall into silhouette.
+  const sceneLight = clamp(
+    u.uSkyIntensity.mul(0.5)
+      .add(u.uSunIntensity.mul(0.5).mul(band)),
+    0,
+    1.5,
+  );
+  colorNode.mulAssign(sceneLight);
 
   return { band, color: colorNode, normal: styledNormal, visibility, viewDirection };
 }

package/src/shaders-tsl/chunks/water-color.js

@@ -34,18 +34,32 @@ import { waterRotate2d, waterVoronoi2 } from './water-common.js';
 
 export function createWaterColorChunk({ u, flags }) {
   const sceneRawDepth = (screenUv) => {
-    const raw = float(1.0).toVar();
+    // The pass texture is deliberately stored as canonical forward depth.
+    // Three's perspectiveDepthToViewZ and the camera inverse projection both
+    // follow the active renderer convention, so reverse the sampled value
+    // for reversed-depth hosts before either consumer sees it.
+    const stored = float(1.0).toVar();
     If(u.uUseSceneDepth.greaterThanEqual(0.5), () => {
-      raw.assign(u.uSceneDepth.sample(screenUv).level(0).r);
+      stored.assign(u.uSceneDepth.sample(screenUv).level(0).r);
     });
-    return raw;
+    return mix(
+      stored,
+      stored.oneMinus(),
+      clamp(u.uDepthTargetNeedsReverse, 0.0, 1.0),
+    ).toVar();
   };
 
+  const storedDepthHasGeometry = (projectedDepth) => mix(
+    projectedDepth,
+    projectedDepth.oneMinus(),
+    clamp(u.uDepthTargetNeedsReverse, 0.0, 1.0),
+  ).lessThan(0.99999);
+
   const viewDistanceFromDepth = (rawDepth) => {
     // perspectiveDepthToViewZ is an Fn() in r185 — keep it out of select()
     // operands (docs/tsl-conventions.md #2), hence the If shape.
     const distance = float(u.uCameraFar).toVar();
-    If(rawDepth.lessThan(0.99999), () => {
+    If(storedDepthHasGeometry(rawDepth), () => {
       distance.assign(perspectiveDepthToViewZ(rawDepth, u.uCameraNear, u.uCameraFar).negate());
     });
     return distance;
@@ -84,7 +98,7 @@ export function createWaterColorChunk({ u, flags }) {
   const pierceSample = (sampleUv, surfaceHeight) => {
     const pierce = float(0.0).toVar();
     const rawDepth = sceneRawDepth(sampleUv).toVar();
-    If(rawDepth.lessThan(0.99999), () => { // sky — nothing pierces here
+    If(storedDepthHasGeometry(rawDepth), () => { // sky — nothing pierces here
       const neighborWorld = worldFromDepth(sampleUv, rawDepth);
       pierce.assign(smoothstep(0.01, 0.05, neighborWorld.y.sub(surfaceHeight)));
     });

package/src/shaders-tsl/chunks/water-shore-state.js

@@ -27,5 +27,12 @@ export function createWaterShoreStateChunk({ u }) {
       .toVar();
   };
 
-  return { shoreStateSample, shoreStateUv };
+  const shoreStateCoverage = (worldXZ) => {
+    const fieldUv = shoreStateUv(worldXZ).toVar();
+    const border = smoothstep(vec2(0.0), vec2(0.02), fieldUv)
+      .mul(smoothstep(vec2(0.98), vec2(1.0), fieldUv).oneMinus());
+    return border.x.mul(border.y).mul(u.uUseShoreState).toVar();
+  };
+
+  return { shoreStateCoverage, shoreStateSample, shoreStateUv };
 }

package/src/shaders-tsl/chunks/world-noise.js

@@ -0,0 +1,30 @@
+// Cheap world-space 2D value noise for TSL materials — shared by the
+// terrain's noise-broken cliff transitions and the grass wind-color sheen.
+// Hash-based (no texture fetch), stable across backends, tileless.
+
+import { abs, add, dot, floor, fract, Fn, mix, sin, vec2 } from 'three/tsl';
+
+const hash2 = /*@__PURE__*/ Fn(([cell]) => {
+  return fract(sin(dot(cell, vec2(127.1, 311.7))).mul(43758.5453123));
+});
+
+/** Single-octave 2D value noise in [0, 1]; p is a world-XZ coordinate. */
+export const worldValueNoise2 = /*@__PURE__*/ Fn(([p]) => {
+  const cell = floor(p).toVar();
+  const f = fract(p).toVar();
+  // smoothstep fade per axis
+  const t = f.mul(f).mul(f.mul(-2.0).add(3.0)).toVar();
+  const a = hash2(cell);
+  const b = hash2(cell.add(vec2(1.0, 0.0)));
+  const c = hash2(cell.add(vec2(0.0, 1.0)));
+  const d = hash2(cell.add(vec2(1.0, 1.0)));
+  return mix(mix(a, b, t.x), mix(c, d, t.x), t.y);
+});
+
+/** Three-octave fbm in [0, 1]; p is a world-XZ coordinate (pre-scaled). */
+export const worldFbm2 = /*@__PURE__*/ Fn(([p]) => {
+  const n0 = worldValueNoise2(p);
+  const n1 = worldValueNoise2(p.mul(2.13).add(vec2(19.7, 41.3)));
+  const n2 = worldValueNoise2(p.mul(4.37).add(vec2(73.1, 7.9)));
+  return add(n0.mul(0.5714), add(n1.mul(0.2857), n2.mul(0.1429)));
+});