@call-me-sensei/toonlab 0.4.21 → 0.4.23

package/src/cloud/cloudVolume.js

@@ -1003,6 +1003,7 @@ export function marchCloud({
   moonRadiance,
   jitter,
   stepConeAngle = float(0.003),
+  surfaceLighting = float(1),
   steps = CLOUD_PRIMARY_MARCH_STEPS,
 }) {
   const scattered = vec3(0).toVar();
@@ -1027,7 +1028,8 @@ export function marchCloud({
     weight,
   }) => {
     If(
-      surfaceLightSet.lessThan(0.5).and(weight.greaterThan(CLOUD_SURFACE_LIGHT_MIN_WEIGHT)),
+      float(surfaceLighting).greaterThan(0).and(surfaceLightSet.lessThan(0.5))
+        .and(weight.greaterThan(CLOUD_SURFACE_LIGHT_MIN_WEIGHT)),
       () => {
         const radius = CLOUD_SURFACE_NORMAL_RADIUS;
         // Use the broad envelope for the lighting normal. Including the full
@@ -1136,11 +1138,11 @@ export function marchCloud({
               CLOUD_INTERIOR_COARSEN_FULL,
               opticalDepthAccum,
             ).toVar();
-            const coreStep = mix(
+            const coreStep = min(shell.tEnd.sub(t), mix(
               surfaceCoreStep,
               effectiveBaseStep.mul(CLOUD_INTERIOR_STEP_SCALE),
               interiorOpenness,
-            ).toVar();
+            )).toVar();
             stepSize.assign(coreStep);
             const cheapLight = step(0.3, transmittance).oneMinus().toVar();
             const lightOpticalDepth = lightDepthNode(
@@ -1231,11 +1233,11 @@ export function marchCloud({
             CLOUD_INTERIOR_COARSEN_FULL,
             opticalDepthAccum,
           ).toVar();
-          const coreStep = mix(
+          const coreStep = min(shell.tEnd.sub(t), mix(
             surfaceCoreStep,
             effectiveBaseStep.mul(CLOUD_INTERIOR_STEP_SCALE),
             interiorOpenness,
-          ).toVar();
+          )).toVar();
           stepSize.assign(coreStep);
           const cheapLight = step(0.3, transmittance).oneMinus().toVar();
           const lightOpticalDepth = lightDepthNode(
@@ -1403,6 +1405,11 @@ export function createCloudVolumeMaterial({
   const stepConeAngle = uniform(0.003);
   const baseShapeResolution = uniform(resolved.baseShape?.image?.width ?? 64);
   const rayHitDistance = property('float', 'toonlabCloudRayHitDistance');
+  const opaqueViewDistance = property('float', 'toonlabCloudOpaqueViewDistance');
+  const sceneDepthFallback = new THREE.DataTexture(new Float32Array([65000]), 1, 1, THREE.RedFormat, THREE.FloatType);
+  sceneDepthFallback.needsUpdate = true;
+  const sceneDepthNode = texture(sceneDepthFallback);
+  const sceneDepthEnabled = uniform(0);
   // A generated cirrus mask ships with the field; the 1x1 stand-in keeps the
   // graph stable when a host explicitly clears it. `cirrusEnabled` is the gate,
   // so setCirrusTexture(null) still removes the deck exactly.
@@ -1482,6 +1489,7 @@ export function createCloudVolumeMaterial({
     pixelJitter,
     rayBasis,
     stepConeAngle,
+    sceneDepthEnabled,
   };
 
   const material = new NodeMaterial();
@@ -1502,6 +1510,16 @@ export function createCloudVolumeMaterial({
       screenUV.y.mul(-2).add(1),
     ).add(pixelJitter).toVar();
     const viewDir = normalize(rayBasis.mul(vec3(ndc, 1))).toVar();
+    opaqueViewDistance.assign(65000);
+    If(sceneDepthEnabled.greaterThan(0.5), () => {
+      const depthUv = vec2(ndc.x.mul(0.5).add(0.5), ndc.y.mul(-0.5).add(0.5));
+      opaqueViewDistance.assign(min(max(sceneDepthNode.sample(depthUv).r, 0), 65000));
+    });
+    const opaqueRayDistance = select(
+      sceneDepthEnabled.greaterThan(0.5).and(opaqueViewDistance.lessThan(64000)),
+      opaqueViewDistance.mul(length(rayBasis.mul(vec3(ndc, 1)))),
+      float(1e20),
+    ).toVar();
     const cameraAltitude = max(cameraPositionUniform.y.sub(groundLevelUniform), 0.5).toVar();
 
     const baseAltitude = max(shape.altitude, 0).toVar();
@@ -1509,7 +1527,7 @@ export function createCloudVolumeMaterial({
     const shell = intersectCloudShell({
       baseAltitude,
       cameraAltitude,
-      maxDistance: fade.maxMarchDist,
+      maxDistance: min(fade.maxMarchDist, opaqueRayDistance),
       topAltitude,
       viewDir,
     });
@@ -1530,6 +1548,9 @@ export function createCloudVolumeMaterial({
 
     // --- the volumetric march ---------------------------------------------
     const march = marchCloud({
+      surfaceLighting: style?.surfaceLight
+        ? style.enabled.mul(style.amount).mul(style.surfaceLight.enabled).mul(style.surfaceLight.amount)
+        : float(0),
       cameraPosition: cameraPositionUniform,
       coarseDensityNode: field.sampleCoarseDensityNode,
       cosMoon,
@@ -1739,6 +1760,7 @@ export function createCloudVolumeMaterial({
     ).rgb.toVar();
 
     // Composite the cirrus/haze deck behind the volumetric layer.
+    deckOpacity.mulAssign(step(deckDistance, opaqueRayDistance));
     const deckTerm = deckRadiance.mul(deckOpacity).toVar();
     scattered.addAssign(deckTerm.mul(transmittance));
     transmittance.mulAssign(deckOpacity.oneMinus());
@@ -1754,7 +1776,7 @@ export function createCloudVolumeMaterial({
   // are matched by cloudReprojection's MRT render target.
   material.fragmentNode = mrt({
     output: cloudColorNode,
-    rayHitDist: vec4(rayHitDistance, 0, 0, 1),
+    rayHitDist: vec4(rayHitDistance, opaqueViewDistance, 0, 1),
   });
 
   const rightScratch = new THREE.Vector3();
@@ -1762,6 +1784,20 @@ export function createCloudVolumeMaterial({
   const forwardScratch = new THREE.Vector3();
 
   const api = {
+    sceneDepthNode,
+    /** Positive view-space depth (metres) in R; clear to >=65000. Host-owned. */
+    setSceneDepthTexture(map = null) {
+      if (map !== null && (!map?.isTexture || map.isDepthTexture)) {
+        throw new TypeError('Cloud scene depth must be a linear view-distance color texture, not hardware depth.');
+      }
+      if (map && (map.colorSpace !== THREE.NoColorSpace
+        || ![THREE.FloatType, THREE.HalfFloatType].includes(map.type)
+        || map.minFilter !== THREE.NearestFilter || map.magFilter !== THREE.NearestFilter)) {
+        throw new TypeError('Cloud scene depth requires a nearest-filtered float texture with NoColorSpace.');
+      }
+      sceneDepthNode.value = map ?? sceneDepthFallback;
+      sceneDepthEnabled.value = map ? 1 : 0;
+    },
     material,
     uniforms,
     marchBudget: budget,
@@ -1893,6 +1929,7 @@ export function createCloudVolumeMaterial({
     },
 
     dispose() {
+      sceneDepthFallback.dispose();
       cirrusFallback.dispose();
       material.dispose();
     },

package/src/cloud/noise/baseShapeVolume.js

@@ -1,3 +1,4 @@
+import { createCloudTextureCache } from './textureCache.js';
 // Cloud base-shape volume — packed inverted-Worley FBMs.
 //
 //   R  inverted Worley FBM at 4 / 8 / 16 cells
@@ -10,8 +11,9 @@
 // the Perlin-Worley + separate erosion-volume path used by the discarded lab.
 //
 // The hash has no author seed, so it produces one canonical field. The public
-// seed remains in metadata/cache keys for document compatibility, but does not
-// perturb these bytes.
+// seed remains in uncached bake metadata for document compatibility, but does
+// not perturb these bytes. Cached textures use canonical seed 0 and share one
+// texture and mip chain per resolution, independent of the authored seed.
 //
 // Every band is periodic over the unit tile and the texture wraps on all three
 // axes, so the field continues exactly across a repeat. Sampling is at texel
@@ -77,7 +79,7 @@ export const CLOUD_BASE_SHAPE_PLAN = Object.freeze({
   worleyTexelsPerCell: 1,
 });
 
-const volumeCache = new Map();
+const volumeCache = createCloudTextureCache('base-shape');
 
 // Fixed u32 hash and cellular sampler. These stay local rather than using the
 // seeded noise utilities because the canonical base-shape bake must remain
@@ -307,7 +309,7 @@ export function createCloudBaseShapeVolume({
 }
 
 /**
- * Cached base-shape volume, keyed by resolution and seed. A tier switch that
+ * Cached canonical base-shape volume, keyed by resolution. A tier switch that
  * returns to a resolution already baked pays nothing, and the shadow/env-map
  * bakes share the runtime's volumes.
  */
@@ -316,10 +318,10 @@ export function getCloudBaseShapeVolume({
   seed = 1,
 } = {}) {
   const size = resolveNoiseDims(dims, CLOUD_BASE_SHAPE_MASTER_DIM);
-  const key = noiseVolumeKey(size, hashSeed(seed));
+  const key = noiseVolumeKey(size, 0);
   const cached = volumeCache.get(key);
   if (cached) return cached;
-  const texture = createCloudBaseShapeVolume({ dims: size, seed });
+  const texture = createCloudBaseShapeVolume({ dims: size, seed: 0 });
   volumeCache.set(key, texture);
   return texture;
 }

package/src/cloud/noise/cirrusMap.js

@@ -1,3 +1,4 @@
+import { createCloudTextureCache } from './textureCache.js';
 // Procedural high-cloud mask for the thin cirrus deck.
 //
 // Cirrus is not a shallower version of the lower volumetric layer. Ice-crystal
@@ -17,7 +18,7 @@ export const CLOUD_CIRRUS_MAP_WIDTH = 1024;
 export const CLOUD_CIRRUS_MAP_HEIGHT = 512;
 export const CLOUD_CIRRUS_SEED_NAMESPACE = 'cloud-cirrus';
 
-const mapCache = new Map();
+const mapCache = createCloudTextureCache('cirrus');
 
 function smoothstep01(value) {
   const x = value < 0 ? 0 : value > 1 ? 1 : value;

package/src/cloud/noise/curlNoise.js

@@ -1,3 +1,4 @@
+import { createCloudTextureCache } from './textureCache.js';
 // Curl noise — the divergence-free vector field that advects cloud edges into
 // wisps. Displacing a sample position by an arbitrary noise vector pumps
 // density in and out of the cloud (the field has sources and sinks), so edges
@@ -68,7 +69,7 @@ const NORMALIZATION_PROBE_DIMS = 32;
 // 15%, resolveNoiseDims' 256³ ceiling included.
 const NORMALIZATION_HEADROOM = 1.15;
 
-const volumeCache = new Map();
+const volumeCache = createCloudTextureCache('curl');
 
 /**
  * Builds the divergence-free field.

package/src/cloud/noise/erosionVolume.js

@@ -1,3 +1,4 @@
+import { createCloudTextureCache } from './textureCache.js';
 // Cloud erosion volume — the high-frequency Worley detail field that carves
 // the cloud silhouette after the base shape has decided where cloud exists.
 //
@@ -66,7 +67,7 @@ export const CLOUD_EROSION_PLAN = Object.freeze({
   texelsPerCell: 2,
 });
 
-const volumeCache = new Map();
+const volumeCache = createCloudTextureCache('erosion');
 
 /**
  * Bakes the RGBA8 erosion field. Returned separately from the texture so

package/src/cloud/noise/textureCache.js

@@ -0,0 +1,77 @@
+// Bound cache-owned retention without disposing textures still used by a
+// renderer or host. Weak entries preserve identity for live consumers; the
+// browser can reclaim unreferenced textures after they leave the recent set.
+const recent = new Map();
+const entries = new Map();
+const MAX_BYTES = 64 * 1024 * 1024;
+const MAX_ENTRIES = 32;
+let retainedBytes = 0;
+const finalized = new FinalizationRegistry(({ key, ref }) => {
+  if (entries.get(key)?.ref === ref) entries.delete(key);
+});
+
+function forget(key) {
+  const item = recent.get(key);
+  if (item) retainedBytes -= item.bytes;
+  recent.delete(key);
+  const entry = entries.get(key);
+  if (entry) finalized.unregister(entry.ref);
+  entries.delete(key);
+}
+
+function retain(key, texture, bytes) {
+  const previous = recent.get(key);
+  if (previous) retainedBytes -= previous.bytes;
+  recent.delete(key);
+  recent.set(key, { texture, bytes });
+  retainedBytes += bytes;
+  while (retainedBytes > MAX_BYTES || recent.size > MAX_ENTRIES) {
+    const oldest = recent.keys().next().value;
+    retainedBytes -= recent.get(oldest).bytes;
+    recent.delete(oldest);
+  }
+}
+
+export function getCloudTextureCacheStats() {
+  return { retainedBytes, retainedEntries: recent.size, maxBytes: MAX_BYTES, maxEntries: MAX_ENTRIES };
+}
+
+export function createCloudTextureCache(namespace) {
+  const prefix = `${namespace}:`;
+  return {
+    get(key) {
+      const id = prefix + key;
+      const entry = entries.get(id);
+      const texture = entry?.ref.deref();
+      if (!texture) { forget(id); return undefined; }
+      retain(id, texture, entry.bytes);
+      return texture;
+    },
+    set(key, texture) {
+      const id = prefix + key;
+      forget(id);
+      const levels = texture.userData?.toonlabVolumeMipChain?.levels;
+      const bytes = levels
+        ? levels.reduce((sum, data) => sum + data.byteLength, 0)
+        : (texture.image?.data?.byteLength ?? 0);
+      const ref = new WeakRef(texture);
+      entries.set(id, { ref, bytes });
+      finalized.register(texture, { key: id, ref }, ref);
+      texture.addEventListener('dispose', () => {
+        if (entries.get(id)?.ref === ref) forget(id);
+      });
+      retain(id, texture, bytes);
+    },
+    *values() {
+      for (const [key, entry] of entries) {
+        if (key.startsWith(prefix)) {
+          const texture = entry.ref.deref();
+          if (texture) yield texture;
+        }
+      }
+    },
+    clear() {
+      for (const key of entries.keys()) if (key.startsWith(prefix)) forget(key);
+    },
+  };
+}

package/src/cloud/noise/weatherMap.js

@@ -1,3 +1,4 @@
+import { createCloudTextureCache } from './textureCache.js';
 // Weather map — the 2D field that decides *where* cloud exists, before any of
 // the 3D noise decides what shape it takes. CPU FBM, deterministic from a
 // seed, tiling in both axes, regenerated whenever the sky-cloud lab changes the
@@ -151,7 +152,7 @@ export const WEATHER_MAP_PROFILE_DEFAULTS = Object.freeze(
   ),
 );
 
-const mapCache = new Map();
+const mapCache = createCloudTextureCache('weather');
 
 /**
  * Normalizes any partial input into a complete WeatherMapProfile: every field

package/src/core/sha256.js

@@ -0,0 +1,83 @@
+const SHA256_INITIAL = Object.freeze([
+  0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
+  0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+]);
+
+const SHA256_ROUND = Object.freeze([
+  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+  0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+  0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+  0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+  0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+  0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]);
+
+function rotateRight(value, amount) {
+  return (value >>> amount) | (value << (32 - amount));
+}
+
+function inputBytes(value) {
+  if (typeof value === 'string') return new TextEncoder().encode(value);
+  if (value instanceof Uint8Array) return value;
+  if (ArrayBuffer.isView(value)) {
+    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  }
+  if (value instanceof ArrayBuffer) return new Uint8Array(value);
+  throw new TypeError('sha256Hex requires a string, ArrayBuffer, or typed-array input.');
+}
+
+/** Synchronous browser-safe SHA-256 used for portable document identities. */
+export function sha256Hex(value) {
+  const source = inputBytes(value);
+  const bitLength = BigInt(source.byteLength) * 8n;
+  const paddedLength = Math.ceil((source.byteLength + 9) / 64) * 64;
+  const bytes = new Uint8Array(paddedLength);
+  bytes.set(source);
+  bytes[source.byteLength] = 0x80;
+  const view = new DataView(bytes.buffer);
+  view.setUint32(paddedLength - 8, Number((bitLength >> 32n) & 0xffffffffn), false);
+  view.setUint32(paddedLength - 4, Number(bitLength & 0xffffffffn), false);
+
+  const state = [...SHA256_INITIAL];
+  const words = new Uint32Array(64);
+  for (let offset = 0; offset < paddedLength; offset += 64) {
+    for (let index = 0; index < 16; index += 1) {
+      words[index] = view.getUint32(offset + (index * 4), false);
+    }
+    for (let index = 16; index < 64; index += 1) {
+      const left = words[index - 15];
+      const right = words[index - 2];
+      const sigma0 = rotateRight(left, 7) ^ rotateRight(left, 18) ^ (left >>> 3);
+      const sigma1 = rotateRight(right, 17) ^ rotateRight(right, 19) ^ (right >>> 10);
+      words[index] = (words[index - 16] + sigma0 + words[index - 7] + sigma1) >>> 0;
+    }
+    let [a, b, c, d, e, f, g, h] = state;
+    for (let index = 0; index < 64; index += 1) {
+      const sum1 = rotateRight(e, 6) ^ rotateRight(e, 11) ^ rotateRight(e, 25);
+      const choose = (e & f) ^ (~e & g);
+      const temporary1 = (h + sum1 + choose + SHA256_ROUND[index] + words[index]) >>> 0;
+      const sum0 = rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22);
+      const majority = (a & b) ^ (a & c) ^ (b & c);
+      const temporary2 = (sum0 + majority) >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = (d + temporary1) >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = (temporary1 + temporary2) >>> 0;
+    }
+    state[0] = (state[0] + a) >>> 0;
+    state[1] = (state[1] + b) >>> 0;
+    state[2] = (state[2] + c) >>> 0;
+    state[3] = (state[3] + d) >>> 0;
+    state[4] = (state[4] + e) >>> 0;
+    state[5] = (state[5] + f) >>> 0;
+    state[6] = (state[6] + g) >>> 0;
+    state[7] = (state[7] + h) >>> 0;
+  }
+  return state.map((word) => word.toString(16).padStart(8, '0')).join('');
+}

package/src/ground-shader/groundShaderMaterial.js

@@ -239,6 +239,8 @@ export function createGroundShaderMaterial({
     uSceneGroundSnowDepth: uniform(0),
     uSceneGroundShadowDebug: uniform(0),
     uSceneGroundSunColor: uniform(new THREE.Color(0xfff0d2)),
+    uSceneGroundSunIntensity: uniform(1),
+    uSceneGroundSkyIntensity: uniform(1),
     uSceneGroundSunDirection: uniform(new THREE.Vector3(0.45, 0.75, 0.5).normalize()),
     uSceneGroundSkyColor: uniform(new THREE.Color(0xc7dcff)),
     uSceneGroundWaterLevel: uniform(-10000),
@@ -572,9 +574,12 @@ export function createGroundShaderMaterial({
       u('material', 'metalness'),
     );
     groundColor.addAssign(specularColor.mul(specularAmount));
-    groundColor.addAssign(
-      groundColor.mul(u('material', 'emissiveStrength')),
-    );
+    const emission = groundColor.mul(u('material', 'emissiveStrength')).toVar();
+    // Defaults of one preserve the authored look. Scene intensity remains
+    // transient, and can reach zero without erasing intentional emission.
+    groundColor.mulAssign(mix(sceneUniforms.uSceneGroundSkyIntensity,
+      sceneUniforms.uSceneGroundSunIntensity, smoothstep(0.06, 0.72, direct)));
+    groundColor.addAssign(emission);
 
     groundColor.assign(mix(
       groundColor,
@@ -617,7 +622,9 @@ export function createGroundShaderMaterial({
     snowDepth,
     sunColor,
     sunDirection,
+    sunIntensity,
     skyColor,
+    skyIntensity,
     shadowDebug,
     waterLevel,
     wetness,
@@ -639,6 +646,8 @@ export function createGroundShaderMaterial({
       sceneUniforms.uSceneGroundShadowDebug.value = shadowDebug ? 1 : 0;
     }
     if (sunColor !== undefined) sceneUniforms.uSceneGroundSunColor.value.set(sunColor);
+    if (Number.isFinite(sunIntensity)) sceneUniforms.uSceneGroundSunIntensity.value = Math.max(0, sunIntensity);
+    if (Number.isFinite(skyIntensity)) sceneUniforms.uSceneGroundSkyIntensity.value = Math.max(0, skyIntensity);
     if (Array.isArray(sunDirection) && sunDirection.length >= 3) {
       sceneUniforms.uSceneGroundSunDirection.value.set(...sunDirection).normalize();
     } else if (sunDirection?.isVector3) {