@call-me-sensei/toonlab 0.4.21 → 0.4.23

package/src/shaders-tsl/chunks/projected-water-caustics.js

@@ -104,6 +104,9 @@ const causticTexture = createCausticCellTexture();
 
 export const projectedWaterCausticUniforms = {
   map: texture(causticTexture),
+  surfaceMap: texture(causticTexture),
+  useSurfaceMap: uniform(0),
+  surfaceRegion: uniform(new THREE.Vector4(0,0,1,1)),
   enabled: uniform(0.0),
   time: uniform(0.0),
   waterLevel: uniform(0.0),
@@ -147,9 +150,14 @@ export function updateProjectedWaterCaustics({
   flowDirection,
   waveDistortion,
   depthAttenuation,
+  surfaceMap = null,
+  surfaceRegion = null,
 } = {}) {
   const u = projectedWaterCausticUniforms;
   u.enabled.value = enabled ? 1 : 0;
+  u.useSurfaceMap.value = surfaceMap ? 1 : 0;
+  if (surfaceMap) u.surfaceMap.value = surfaceMap;
+  if (surfaceRegion) u.surfaceRegion.value.copy(surfaceRegion);
   if (Number.isFinite(time)) u.time.value = time;
   if (Number.isFinite(waterLevel)) u.waterLevel.value = waterLevel;
   if ([centerX, centerZ, halfWidth, halfDepth].every(Number.isFinite)) {
@@ -227,13 +235,17 @@ export function projectedWaterCaustics(worldPosition, worldNormal) {
   const cellA = u.map.sample(uvA).level(0).r;
   const cellB = u.map.sample(uvB).level(0).r;
   const web = min(cellA, cellB).oneMinus();
-  const strands = smoothstep(0.2, 0.9, web).pow(1.7);
+  const fieldUv = worldPosition.xz.sub(u.surfaceRegion.xy).div(u.surfaceRegion.zw.mul(2.0)).add(0.5);
+  const edge = smoothstep(vec2(0.0), vec2(0.08), fieldUv)
+    .mul(smoothstep(vec2(0.92), vec2(1.0), fieldUv).oneMinus());
+  const solvedLight = u.surfaceMap.sample(clamp(fieldUv, vec2(0.0), vec2(1.0))).level(0).r.mul(edge.x).mul(edge.y);
+  const strands = mix(smoothstep(0.2, 0.9, web).pow(1.7), solvedLight, u.useSurfaceMap);
   const pulse = sin(phase.mul(0.9).add(worldPosition.x.mul(0.11)))
     .mul(0.5).add(0.5);
   return u.color
     .mul(u.intensity)
     .mul(strands)
-    .mul(mix(0.76, 1.0, pulse))
+    .mul(mix(mix(0.76, 1.0, pulse), 1.0, u.useSurfaceMap))
     .mul(submerged)
     .mul(depthFade)
     .mul(receivingFace)

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

@@ -26,8 +26,8 @@ export function createWaterFoamChunk({ u, foamOctaves }) {
   const shoreFoam = (columnDepth, viewDepthDiff, restXZ, time, pierce) => {
     const result = float(0.0).toVar();
     If(u.uUseSceneDepth.greaterThanEqual(0.5), () => {
-      const flowOffset = u.uFlowDirection.mul(time).mul(u.uFlowSpeed).mul(0.35).toVar();
-      const breakup = waterFbm(restXZ.mul(u.uFoamNoiseScale).add(flowOffset), foamOctaves).toVar();
+      const flowOffset = u.uFlowDirection.mul(time).mul(u.uFlowSpeed).toVar();
+      const breakup = waterFbm(restXZ.sub(flowOffset).mul(u.uFoamNoiseScale), foamOctaves).toVar();
 
       // A tight ungated core keeps a crisp waterline rim on any contact.
       const contactTight = smoothstep(0.0, min(u.uFoamContactDistance.mul(0.5), 0.07), columnDepth).oneMinus();
@@ -51,7 +51,7 @@ export function createWaterFoamChunk({ u, foamOctaves }) {
       const line = smoothstep(0.8, 0.93, lineBand)
         .mul(smoothstep(0.93, 1.0, lineBand).oneMinus()).toVar();
       const lineFalloff = smoothstep(1.3, 2.4, columnDepth.div(max(u.uFoamLineSpacing, 1e-3))).oneMinus();
-      const dashes = waterValueNoise(restXZ.mul(u.uFoamNoiseScale).mul(2.6).add(flowOffset.mul(1.7)));
+      const dashes = waterValueNoise(restXZ.sub(flowOffset).mul(u.uFoamNoiseScale).mul(2.6));
       line.mulAssign(lineFalloff.mul(smoothstep(0.36, 0.6, breakup)).mul(smoothstep(0.3, 0.55, dashes)));
 
       result.assign(clamp(
@@ -68,8 +68,8 @@ export function createWaterFoamChunk({ u, foamOctaves }) {
   const whitecaps = (crest, gerstnerNormalY, restXZ, time) => {
     const result = float(0.0).toVar();
     If(u.uWhitecapAmount.greaterThan(0.002), () => {
-      const drift = u.uFlowDirection.mul(time).mul(u.uFlowSpeed.mul(0.4).add(0.35));
-      const patches = waterFbm(restXZ.mul(u.uFoamNoiseScale).mul(0.6).add(drift), foamOctaves).toVar();
+      const drift = u.uFlowDirection.mul(time).mul(u.uFlowSpeed);
+      const patches = waterFbm(restXZ.sub(drift).mul(u.uFoamNoiseScale).mul(0.6), foamOctaves).toVar();
       const steepness = clamp(gerstnerNormalY.oneMinus().mul(9.0), 0.0, 1.0);
       const energy = crest.mul(steepness.mul(0.45).add(0.55)).mul(patches.mul(0.85).add(0.45)).toVar();
       const threshold = mix(float(0.985), float(0.32), clamp(u.uWhitecapAmount, 0.0, 1.0)).toVar();
@@ -82,7 +82,7 @@ export function createWaterFoamChunk({ u, foamOctaves }) {
   // foam edges read as hand-drawn dots rather than a soft alpha gradient.
   const foamShape = (rawMask, restXZ, time) => {
     const dotNoise = waterValueNoise(
-      restXZ.mul(u.uFoamNoiseScale).mul(5.2).add(u.uFlowDirection.mul(time).mul(u.uFlowSpeed).mul(0.6)),
+      restXZ.sub(u.uFlowDirection.mul(time).mul(u.uFlowSpeed)).mul(u.uFoamNoiseScale).mul(5.2),
     );
     const solid = waterToonStep(0.56, 0.12, rawMask);
     const dots = waterToonStep(0.74, 0.06, rawMask.mul(dotNoise.mul(0.75).add(0.35)));

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

@@ -10,6 +10,7 @@
 
 import {
   clamp,
+  float,
   dot,
   If,
   fract,
@@ -27,21 +28,43 @@ import {
 
 import { waterHash12, waterToonStep, waterVoronoi2 } from './water-common.js';
 
-export function createWaterLightingChunk({ u }) {
+export function createWaterLightingChunk({ u, physicalSurface = false }) {
+  const reference = u.uReferenceView ?? float(0.0);
   // Schlick-style fresnel with a stylized floor: uFresnelBias keeps some sky
   // reflection alive even looking straight down.
   const fresnelFactor = (viewDir, surfaceNormal) => {
     const facing = clamp(dot(viewDir, surfaceNormal), 0.0, 1.0);
-    return clamp(
+    const stylized = clamp(
       u.uFresnelBias.add(pow(facing.oneMinus(), u.uFresnelPower).mul(u.uFresnelStrength)),
       0.0,
       1.0,
     );
+    const eta = u.uIndexOfRefraction ?? float(1.333);
+    const f0 = eta.sub(1.0).div(eta.add(1.0)).pow2();
+    const physical = f0.add(f0.oneMinus().mul(pow(facing.oneMinus(), 5.0)));
+    return physicalSurface ? physical : mix(stylized, physical, reference);
   };
 
   // Toon-banded Blinn-Phong glint. The normal is anisotropically squashed
   // along the sun azimuth so low sun angles draw the long sparkling sun path.
   const specular = (viewDir, surfaceNormal, shadowFactor) => {
+    if (physicalSurface) {
+      const half = normalize(viewDir.add(u.uSunDirection));
+      const nv = max(dot(surfaceNormal, viewDir), 0.001);
+      const nl = max(dot(surfaceNormal, u.uSunDirection), 0.0);
+      const nh = max(dot(surfaceNormal, half), 0.0);
+      const vh = max(dot(viewDir, half), 0.0);
+      const roughness = clamp(float(2.0).div(u.uSpecularShininess.add(2.0)).sqrt(), 0.055, 0.35);
+      const alpha2 = roughness.mul(roughness).toVar();
+      const denominator = nh.mul(nh).mul(alpha2.sub(1.0)).add(1.0);
+      const distribution = alpha2.div(max(denominator.mul(denominator).mul(Math.PI), 1e-5));
+      const masking = (cosine) => cosine.mul(2.0).div(max(cosine.add(alpha2.add(alpha2.oneMinus().mul(cosine.mul(cosine))).sqrt()), 1e-4));
+      const eta = u.uIndexOfRefraction ?? float(1.333);
+      const f0 = eta.sub(1.0).div(eta.add(1.0)).pow2();
+      const fresnel = f0.add(f0.oneMinus().mul(vh.oneMinus().pow(5)));
+      const specularBRDF = distribution.mul(masking(nv)).mul(masking(nl)).mul(fresnel).div(max(nv.mul(4.0), 1e-4));
+      return u.uSunColor.mul(specularBRDF).mul(u.uSpecularStrength).mul(shadowFactor);
+    }
     const sunAzimuth = normalize(u.uSunDirection.xz.add(vec2(1e-5, 0.0))).toVar();
     const sunPerp = vec2(sunAzimuth.y.negate(), sunAzimuth.x).toVar();
     const stretched = sunAzimuth.mul(dot(surfaceNormal.xz, sunAzimuth))
@@ -52,7 +75,7 @@ export function createWaterLightingChunk({ u }) {
     const alignment = pow(max(dot(glintNormal, halfDir), 0.0), u.uSpecularShininess).toVar();
     const core = waterToonStep(0.5, 0.1, alignment);
     const halo = waterToonStep(0.18, 0.16, alignment).mul(0.3);
-    return u.uSunColor.mul(u.uSpecularStrength).mul(core.add(halo)).mul(shadowFactor);
+    return u.uSunColor.mul(u.uSpecularStrength).mul(mix(core.add(halo), alignment, reference)).mul(shadowFactor);
   };
 
   // Twinkling star glints: sparse voronoi feature points with per-cell phase.
@@ -78,7 +101,7 @@ export function createWaterLightingChunk({ u }) {
           .mul(alignment).mul(distanceFade).mul(3.2),
       );
     });
-    return result;
+    return result.mul(reference.oneMinus());
   };
 
   // Procedural sky used when no planar reflection target is bound: a vertical
@@ -105,7 +128,7 @@ export function createWaterLightingChunk({ u }) {
           const planar = u.uReflectionMap.sample(reflectionUv).level(0).rgb;
           // Milky painterly reflections: soften the mirror image toward the
           // smooth procedural sky instead of showing a sharp flipped scene.
-          result.assign(mix(planar, fallback, clamp(u.uReflectionSoftness, 0.0, 1.0)));
+          result.assign(mix(planar, fallback, clamp(u.uReflectionSoftness, 0.0, 1.0).mul(reference.oneMinus()).mul(physicalSurface ? 0.25 : 1.0)));
         });
       });
     });

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

@@ -3,6 +3,8 @@
 
 import {
   clamp,
+  float,
+  mix,
   smoothstep,
   vec2,
 } from 'three/tsl';
@@ -19,7 +21,8 @@ export function createWaterShoreStateChunk({ u }) {
     // edge when a world uses a finite shore-state tile.
     const border = smoothstep(vec2(0.0), vec2(0.02), fieldUv)
       .mul(smoothstep(vec2(0.98), vec2(1.0), fieldUv).oneMinus());
-    const mask = border.x.mul(border.y).mul(u.uUseShoreState).toVar();
+    const side = mix(border.x,1.0,u.uContinueShoreAlongX ?? float(0));
+    const mask = side.mul(border.y).mul(u.uUseShoreState).toVar();
     return u.uShoreStateMap
       .sample(clamp(fieldUv, vec2(0.0), vec2(1.0)))
       .level(0)
@@ -31,7 +34,7 @@ export function createWaterShoreStateChunk({ u }) {
     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 mix(border.x,1.0,u.uContinueShoreAlongX ?? float(0)).mul(border.y).mul(u.uUseShoreState).toVar();
   };
 
   return { shoreStateCoverage, shoreStateSample, shoreStateUv };

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

@@ -24,6 +24,8 @@ import {
   float,
   fract,
   mix,
+  length,
+  max,
   normalize,
   sin,
   vec3,
@@ -85,7 +87,7 @@ export function createWaterWavesChunk({ wavesA, wavesB, waveCount }) {
       const cosTheta = cos(theta);
       displacement.y.addAssign(amplitude.mul(sinTheta));
       displacement.xz.addAssign(
-        phaseFrame.orbitDirection.mul(steepness.mul(amplitude).mul(cosTheta)),
+        phaseFrame.orbitDirection.mul(steepness.div(max(length(phaseFrame.gradient), 1.0)).mul(amplitude).mul(cosTheta)),
       );
     }
     return displacement;
@@ -139,22 +141,25 @@ export function createWaterWavesChunk({ wavesA, wavesB, waveCount }) {
         .sub(omega.mul(time)).add(phase).toVar();
       const sinTheta = sin(theta).toVar();
       const cosTheta = cos(theta).toVar();
+      // Shortening wavelength must not amplify horizontal compression.
+      // Match the orbital reduction in the displacement evaluation.
+      const localSteepness = steepness.div(max(length(phaseFrame.gradient), 1.0));
       const waveKA = waveNumber.mul(amplitude).toVar();
       const phaseGradient = phaseFrame.gradient;
       const orbitDirection = phaseFrame.orbitDirection;
       tangent.x.subAssign(
-        steepness.mul(orbitDirection.x).mul(phaseGradient.x).mul(waveKA).mul(sinTheta),
+        localSteepness.mul(orbitDirection.x).mul(phaseGradient.x).mul(waveKA).mul(sinTheta),
       );
       tangent.y.addAssign(phaseGradient.x.mul(waveKA).mul(cosTheta));
       tangent.z.subAssign(
-        steepness.mul(orbitDirection.y).mul(phaseGradient.x).mul(waveKA).mul(sinTheta),
+        localSteepness.mul(orbitDirection.y).mul(phaseGradient.x).mul(waveKA).mul(sinTheta),
       );
       bitangent.x.subAssign(
-        steepness.mul(orbitDirection.x).mul(phaseGradient.y).mul(waveKA).mul(sinTheta),
+        localSteepness.mul(orbitDirection.x).mul(phaseGradient.y).mul(waveKA).mul(sinTheta),
       );
       bitangent.y.addAssign(phaseGradient.y.mul(waveKA).mul(cosTheta));
       bitangent.z.subAssign(
-        steepness.mul(orbitDirection.y).mul(phaseGradient.y).mul(waveKA).mul(sinTheta),
+        localSteepness.mul(orbitDirection.y).mul(phaseGradient.y).mul(waveKA).mul(sinTheta),
       );
       const crestPeak = sinTheta.mul(0.5).add(0.5).toVar();
       crestSum.addAssign(crestWeight.mul(amplitude).mul(crestPeak).mul(crestPeak));

package/src/shaders-tsl/flower.js

@@ -112,6 +112,8 @@ function shadeFlowerHead({
   );
   const styledPetalColor = petalBaseColor.mul(flowerTint);
   const styledCenterColor = centerBaseColor.mul(flowerTint);
+  // Shadow-side lift is reflected light, distinct from authored emission.
+  const sceneFill = clamp(u.uSunIntensity.add(u.uSkyIntensity).mul(0.5), 0, 1.5);
   const petal = shadeVegetationSurface({
     baseColor: styledPetalColor,
     bandSoftness: u.uStyleFlowerBandSoftness,
@@ -133,7 +135,8 @@ function shadeFlowerHead({
     worldPosition,
   });
   petal.color.addAssign(
-    styledPetalColor.mul(petal.band.oneMinus()).mul(u.uStyleFlowerUnlitPetalLift),
+    styledPetalColor.mul(petal.band.oneMinus()).mul(u.uStyleFlowerUnlitPetalLift)
+      .mul(sceneFill),
   );
 
   // Centers are opaque botanical structures, not thin petals. They share the
@@ -163,7 +166,7 @@ function shadeFlowerHead({
     worldPosition,
   });
   const centerColor = mix(
-    styledCenterColor,
+    styledCenterColor.mul(sceneFill),
     center.color,
     u.uStyleFlowerCenterLightResponse,
   );
@@ -174,7 +177,7 @@ function shadeFlowerHead({
   const highlight = pow(
     clamp(dot(normal, halfVector), 0, 1),
     highlightPower,
-  ).mul(sceneShadow).mul(u.uStyleFlowerSpecularStrength);
+  ).mul(sceneShadow).mul(u.uStyleFlowerSpecularStrength).mul(u.uSunIntensity);
   result.addAssign(u.uSunColor.mul(highlight));
   result.addAssign(
     mix(styledPetalColor, styledCenterColor, centerMask)
@@ -549,7 +552,7 @@ export function createFlowerStemNodeMaterial({
       clamp(dot(normal, halfVector), 0, 1),
       highlightPower,
     ).mul(u.uStyleStemSpecularStrength);
-    shaded.color.addAssign(u.uSunColor.mul(highlight));
+    shaded.color.addAssign(u.uSunColor.mul(highlight).mul(u.uSunIntensity));
     shaded.color.addAssign(stemColor.mul(u.uStyleStemEmissiveStrength));
     return vec4(shaded.color, 1.0);
   })();

package/src/shaders-tsl/grass.js

@@ -337,7 +337,8 @@ export function createGrassNodeMaterial(
 
     const sheen = smoothstep(u.uStyleGrassGustSheenThreshold, 1.0, vGust).mul(tipMix);
     shaded.color.addAssign(
-      u.uSunColor.mul(sheen).mul(u.uStyleGrassGustSheenStrength).mul(shaded.band),
+      u.uSunColor.mul(sheen).mul(u.uStyleGrassGustSheenStrength).mul(shaded.band)
+        .mul(u.uSunIntensity),
     );
     const viewDirection = normalize(cameraPosition.sub(vWorldPosition));
     const halfVector = normalize(sunDirection.add(viewDirection));
@@ -345,7 +346,7 @@ export function createGrassNodeMaterial(
     const highlight = pow(
       clamp(dot(normal, halfVector), 0, 1),
       highlightPower,
-    ).mul(sceneShadow).mul(u.uStyleGrassSpecularStrength);
+    ).mul(sceneShadow).mul(u.uStyleGrassSpecularStrength).mul(u.uSunIntensity);
     shaded.color.addAssign(u.uSunColor.mul(highlight));
     shaded.color.addAssign(color.mul(u.uStyleGrassEmissiveStrength));
 
@@ -368,7 +369,7 @@ export function createGrassNodeMaterial(
     // flat ground albedo here would undo the shared scene-light response a
     // second time.
     const washTarget = shaded.color.mul(1.18).add(
-      u.uSunColor.mul(0.035).mul(groundCoverage.oneMinus()),
+      u.uSunColor.mul(0.035).mul(groundCoverage.oneMinus()).mul(u.uSunIntensity),
     );
     shaded.color.assign(mix(shaded.color, washTarget, u.uWashLift));
     const strokeAlpha = mix(

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

@@ -277,12 +277,13 @@ export function createWaterShoreStateSimulationNodeMaterial({
         )
         .mul(u.uSwashEdgeShape.z)
         .toVar();
+      const swashActivity = smoothstep(0.0, 0.05, u.uWaveEnergy).toVar();
       const edgeOffset = edgeTilt.add(edgeScallop).mul(edgeEnvelope)
-        .add(macroBase.mul(macroEnvelope)).toVar();
+        .add(macroBase.mul(macroEnvelope)).mul(swashActivity).toVar();
       const edgeOffsetSpeed = scallopSpeed.mul(edgeEnvelope)
         .add(edgeTilt.add(edgeScallop).mul(envelopeSpeed))
         .add(macroBase.mul(macroEnvelopeSpeed))
-        .toVar();
+        .mul(swashActivity).toVar();
 
       // In automatic mode the horizontal distance contains 1/slope, so its
       // vertical head reduces to shorelineRunup * energy * progress.