@call-me-sensei/toonlab 0.4.21 → 0.4.23

package/src/catalog/officialCatalogPlacement.js

@@ -20,7 +20,8 @@ import {
   resolveCatalogQualityOptions,
   resolveSceneQualityProfile,
 } from '../styles/sceneQualityProfiles.js';
-import { createCatalogLodRuntime } from './officialCatalogLod.js';
+import { createDenseFieldRockLodRuntime } from '../rockgen/lod/rockDenseFieldPolicy.js';
+import { collectCatalogLodBindings, createCatalogLodRuntime } from './officialCatalogLod.js';
 
 function vector3(value, fallback = [0, 0, 0]) {
   if (Array.isArray(value)) {
@@ -39,6 +40,17 @@ function rotation3(value) {
   return [0, Number(value) || 0, 0];
 }
 
+function mergeSettings(base, patch) {
+  if (!patch || typeof patch !== 'object' || Array.isArray(patch)) return base;
+  const output = { ...(base ?? {}) };
+  for (const [key, value] of Object.entries(patch)) {
+    output[key] = value && typeof value === 'object' && !Array.isArray(value)
+      ? mergeSettings(output[key], value)
+      : value;
+  }
+  return output;
+}
+
 /**
  * Validates caller-supplied style textures without reclassifying the asset's
  * own UV-space maps as triplanar detail maps. applyRockShader reads the full
@@ -54,13 +66,13 @@ function catalogRockTextures(overrides = {}) {
   };
 }
 
-function styleAdapterFor(asset, root, { textures: overrides, variation }) {
+function styleAdapterFor(asset, root, { settings: assetSettings, textures: overrides, variation }) {
   if (asset.domain !== 'natural.rock') return null;
   const resolved = catalogRockTextures(overrides);
   const report = { rejectedTextures: resolved.rejected };
   return Object.freeze({
     apply(subject, settings) {
-      const result = applyRockShader(subject, settings, {
+      const result = applyRockShader(subject, mergeSettings(settings, assetSettings), {
         name: `ToonLab · ${asset.label}`,
         textures: resolved.textures,
         variation,
@@ -124,6 +136,7 @@ export async function loadOfficialCatalogAsset({
   styleBundle,
   targetId = null,
   textures = {},
+  usePublishedRockSurface = true,
   variation = 0,
 } = {}) {
   if (!assetRuntime?.acquireAsset) {
@@ -153,6 +166,7 @@ export async function loadOfficialCatalogAsset({
   let lod = null;
   let collisionRegistration = null;
   let inspectorRegistration = null;
+  let publishedRockSurface = null;
   try {
     metadata = collisionMetadataFor(asset, collision, collisionAdapter);
     labelStyleTarget(root, createStyleTargetLabel(asset.domain, {
@@ -160,17 +174,33 @@ export async function loadOfficialCatalogAsset({
       collision: metadata,
       targetId: id,
     }));
-    adapter = styleAdapterFor(asset, root, { textures, variation });
+    if (usePublishedRockSurface
+      && asset.domain === 'natural.rock'
+      && typeof assetRuntime.getRockShaderInput === 'function') {
+      publishedRockSurface = await assetRuntime.getRockShaderInput(asset);
+    }
+    adapter = styleAdapterFor(asset, root, {
+      settings: publishedRockSurface?.settings,
+      textures: { ...(publishedRockSurface?.textures ?? {}), ...textures },
+      variation,
+    });
     style = await applyStyleBundle(styleBundle, {
       targets: [createStyleTarget(id, asset.domain, root, { adapter })],
     });
-    lod = createCatalogLodRuntime(root, {
-      distances: resolveCatalogLodDistancesForQuality(
-        qualityProfile,
-        asset.lod?.distances,
-      ),
-      maxLevel: maxLodLevel,
-    });
+    const authoredLodLevels = [...new Set(
+      collectCatalogLodBindings(root).map(({ level }) => level),
+    )];
+    const usesDenseFieldRockLods = asset.domain === 'natural.rock'
+      && authoredLodLevels.includes(4);
+    lod = usesDenseFieldRockLods
+      ? createDenseFieldRockLodRuntime(root, { maxLevel: maxLodLevel })
+      : createCatalogLodRuntime(root, {
+        distances: resolveCatalogLodDistancesForQuality(
+          qualityProfile,
+          asset.lod?.distances,
+        ),
+        maxLevel: maxLodLevel,
+      });
     if (metadata.kind !== 'none') {
       collisionRegistration = await registerCollisionTarget({
         adapter: collisionAdapter,
@@ -191,6 +221,8 @@ export async function loadOfficialCatalogAsset({
             lod: {
               availableLevels: lod.availableLevels,
               enabled: true,
+              cullBelowPixels: lod.cullBelowPixels,
+              pixelThresholds: lod.pixelThresholds,
               thresholds: lod.thresholds,
             },
           },
@@ -221,6 +253,7 @@ export async function loadOfficialCatalogAsset({
     lod,
     normalization,
     object: root,
+    publishedRockSurface,
     quality: qualityProfile,
     /** Detail maps the artifact shipped that were too small to be usable. */
     get rejectedTextures() { return adapter?.report?.rejectedTextures ?? []; },
@@ -238,6 +271,13 @@ export async function loadOfficialCatalogAsset({
     get released() { return released; },
     style,
     targetId: id,
-    updateLod(options) { return lod.update(options); },
+    updateLod(options = {}) {
+      if (!lod.pixelThresholds || options.projectedPixels !== undefined) return lod.update(options);
+      return lod.update({
+        ...options,
+        viewportHeight: options.viewportHeight
+          ?? (typeof globalThis.innerHeight === 'number' ? globalThis.innerHeight : 1080),
+      });
+    },
   });
 }

package/src/catalog/officialCatalogProvider.js

@@ -10,8 +10,21 @@ export const OFFICIAL_CATALOG_PROVIDER_TRANSPORTS = Object.freeze([
   'public-rock',
 ]);
 
-const ROCK_ID = /^rock-\d{4}$/u;
+const LEGACY_ROCK_ID = /^rock-\d{4}$/u;
+const NATURE_REFERENCE_ROCK_ID = /^rock-c8-[a-z0-9]+(?:-[a-z0-9]+)*$/u;
 const ROCK_RECIPE_KIND = 'toonlab/rock-recipe';
+const ROCK_GALLERY_RECIPE_SCHEMA = 'toonlab/rock-gallery-recipe';
+
+function isRockId(value) {
+  return LEGACY_ROCK_ID.test(value) || NATURE_REFERENCE_ROCK_ID.test(value);
+}
+
+function isRockRecipe(value) {
+  return isRecord(value) && (
+    value.kind === ROCK_RECIPE_KIND
+    || value.schema === ROCK_GALLERY_RECIPE_SCHEMA
+  );
+}
 
 function isRecord(value) {
   return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
@@ -61,6 +74,15 @@ function artifactName(artifact) {
   return String(artifact?.name ?? artifact?.relative_path ?? artifact?.relativePath ?? '');
 }
 
+function artifactKey(value) {
+  return String(value ?? '').trim().replace(/^\.\//u, '').toLowerCase();
+}
+
+function artifactByName(artifacts, ...names) {
+  const wanted = new Set(names.map(artifactKey));
+  return artifacts.find((artifact) => wanted.has(artifactKey(artifactName(artifact)))) ?? null;
+}
+
 function isModelArtifact(artifact) {
   const name = artifactName(artifact).toLowerCase();
   const contentType = String(artifact?.contentType ?? artifact?.content_type ?? '').toLowerCase();
@@ -107,7 +129,7 @@ export function normalizeOfficialCatalogAsset(rawAsset, {
   const source = String(rawAsset.source ?? metadata.source ?? expectedSource ?? '').trim();
   const kind = String(rawAsset.kind ?? 'model').trim();
   const catalog = String(metadata.catalog ?? rawAsset.catalog ?? (
-    recipe?.kind === ROCK_RECIPE_KIND ? 'rocks' : ''
+    isRockRecipe(recipe) ? 'rocks' : ''
   )).trim().toLowerCase();
   const revision = Number(rawAsset.revision ?? metadata.revision);
   const recipeHash = String(rawAsset.recipeHash ?? metadata.recipeHash ?? '').trim();
@@ -115,7 +137,7 @@ export function normalizeOfficialCatalogAsset(rawAsset, {
     ...(Array.isArray(rawAsset.artifacts) ? rawAsset.artifacts : []),
     ...(Array.isArray(rawAsset.files) ? rawAsset.files : []),
   ].filter(isRecord);
-  const modelArtifact = artifacts.find((entry) => artifactName(entry) === 'rock.glb')
+  const modelArtifact = artifactByName(artifacts, 'rock.glb')
     ?? artifacts.find(isModelArtifact)
     ?? null;
   const modelReference = rawAsset.download_url
@@ -137,9 +159,11 @@ export function normalizeOfficialCatalogAsset(rawAsset, {
   if (kind !== 'model') errors.push(`kind must be model, received ${kind || '(empty)'}`);
   if (!modelReference) errors.push('a model download URL is required');
   if (source === 'toonlab-rock') {
-    if (!ROCK_ID.test(id)) errors.push('ToonLab rock id must match rock-0001');
+    if (!isRockId(id)) errors.push('ToonLab rock id must match rock-0001 or rock-c8-geology-subtype');
     if (catalog !== 'rocks') errors.push(`catalog must be rocks, received ${catalog || '(empty)'}`);
-    if (recipe?.kind !== ROCK_RECIPE_KIND) errors.push(`recipe kind must be ${ROCK_RECIPE_KIND}`);
+    if (!isRockRecipe(recipe)) {
+      errors.push(`recipe must use ${ROCK_RECIPE_KIND} or ${ROCK_GALLERY_RECIPE_SCHEMA}`);
+    }
     if (!Number.isInteger(revision) || revision < 1) errors.push('positive integer revision is required');
     if (!recipeHash) errors.push('recipeHash is required');
   }
@@ -157,15 +181,61 @@ export function normalizeOfficialCatalogAsset(rawAsset, {
     sha256: String(artifact.sha256 ?? ''),
     url: resolveOfficialCatalogUrl(artifactUrl(artifact), baseUrl),
   }));
+  const artifactMap = Object.freeze(Object.fromEntries(normalizedArtifacts
+    .filter((artifact) => artifact.name && artifact.url)
+    .map((artifact) => [artifact.name, artifact])));
+  const artifactUrlByName = (...names) => {
+    const artifact = artifactByName(normalizedArtifacts, ...names);
+    return artifact?.url ?? null;
+  };
   const release = String(rawAsset.release ?? metadata.release ?? releaseFromUrl(modelUrl) ?? '').trim() || null;
   const domain = catalog === 'rocks' ? 'natural.rock' : String(metadata.domain ?? '').trim() || null;
-  const lod = isRecord(recipe?.lod) ? frozenCopy(recipe.lod) : null;
+  const recipeLod = isRecord(recipe?.lod) ? recipe.lod : null;
+  const metadataLod = isRecord(rawAsset.lod ?? metadata.lod) ? rawAsset.lod ?? metadata.lod : null;
+  const lodLevels = Array.isArray(recipe?.output?.lods)
+    ? recipe.output.lods.map(String)
+    : Array.isArray(metadataLod?.levels)
+      ? metadataLod.levels.map(String)
+      : [];
+  const lodUrls = Object.freeze(Array.from({ length: 5 }, (_, level) => (
+    artifactUrlByName(`lod${level}.glb`, `lod/LOD${level}.glb`)
+  )));
+  const hasLodPackage = lodUrls.some(Boolean) || lodLevels.length > 0;
+  const lod = recipeLod || metadataLod || hasLodPackage
+    ? Object.freeze({
+      ...frozenCopy(recipeLod ?? metadataLod ?? {}),
+      cullBelowPixels: Number(
+        recipe?.output?.cullBelowPixels
+        ?? metadataLod?.cullBelowPixels
+        ?? 0,
+      ) || 0,
+      levels: Object.freeze(lodLevels),
+      urls: lodUrls,
+    })
+    : null;
+  const packageFiles = Object.freeze({
+    collisionModelUrl: artifactUrlByName('collision.glb'),
+    controlModelUrl: artifactUrlByName('control.glb'),
+    lodModelUrls: lodUrls,
+    manifestUrl: artifactUrlByName('manifest.json'),
+    materialConfigUrl: artifactUrlByName('material-config.json'),
+    natureProvenanceUrl: artifactUrlByName('nature-provenance.json', 'nature/provenance.json'),
+    natureReferenceUrl: artifactUrlByName('nature-reference.jpg', 'nature/reference.jpg'),
+    realisticModelUrl: modelUrl,
+    realisticPreviewUrl: artifactUrlByName('realistic-preview.png'),
+    recipeUrl: artifactUrlByName('recipe.json'),
+    retainedHighModelUrl: artifactUrlByName('retained-high.glb', 'high.glb'),
+    stylizedModelUrl: artifactUrlByName('rock-stylized.glb'),
+    stylizedPreviewUrl: artifactUrlByName('stylized-preview.png'),
+  });
+  const collisionMetadata = rawAsset.collision ?? metadata.collision;
 
   return Object.freeze({
     artifacts: Object.freeze(normalizedArtifacts),
+    artifactMap,
     catalog,
-    collision: isRecord(rawAsset.collision ?? metadata.collision)
-      ? frozenCopy(rawAsset.collision ?? metadata.collision)
+    collision: isRecord(collisionMetadata) && typeof collisionMetadata.kind === 'string'
+      ? frozenCopy(collisionMetadata)
       : null,
     domain,
     id,
@@ -175,6 +245,7 @@ export function normalizeOfficialCatalogAsset(rawAsset, {
     lod,
     metadata: frozenCopy(metadata),
     modelUrl,
+    packageFiles,
     provider,
     provenance: Object.freeze({
       modelSha256: String(modelArtifact?.sha256 ?? metadata.modelSha256 ?? ''),

package/src/catalog/officialCatalogRockPackage.js

@@ -0,0 +1,172 @@
+import {
+  LinearFilter,
+  LinearMipmapLinearFilter,
+  NoColorSpace,
+  RepeatWrapping,
+  SRGBColorSpace,
+  TextureLoader,
+} from 'three';
+
+export const OFFICIAL_ROCK_GALLERY_RECIPE_SCHEMA = 'toonlab/rock-gallery-recipe';
+export const OFFICIAL_ROCK_MATERIAL_SCHEMA = 'toonlab.pro-rock-material';
+
+function isRecord(value) {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function frozenCopy(value) {
+  if (Array.isArray(value)) return Object.freeze(value.map(frozenCopy));
+  if (!isRecord(value)) return value;
+  return Object.freeze(Object.fromEntries(
+    Object.entries(value).map(([key, entry]) => [key, frozenCopy(entry)]),
+  ));
+}
+
+function artifactName(value) {
+  return String(value ?? '').trim().replace(/^\.\//u, '').toLowerCase();
+}
+
+export function findOfficialCatalogArtifact(asset, ...names) {
+  const wanted = new Set(names.map(artifactName));
+  return asset?.artifacts?.find((artifact) => wanted.has(artifactName(artifact.name))) ?? null;
+}
+
+export function getOfficialCatalogArtifactUrl(asset, ...names) {
+  return findOfficialCatalogArtifact(asset, ...names)?.url ?? null;
+}
+
+async function fetchJson(fetchImpl, url, label) {
+  if (!url) return null;
+  if (typeof fetchImpl !== 'function') throw new TypeError(`${label} requires fetch().`);
+  const response = await fetchImpl(url, { headers: { accept: 'application/json' } });
+  if (!response?.ok) {
+    throw new Error(`${label} returned HTTP ${response?.status ?? 'unknown'}: ${url}`);
+  }
+  try {
+    return await response.json();
+  } catch (cause) {
+    throw new Error(`${label} returned invalid JSON: ${url}`, { cause });
+  }
+}
+
+function validateRecipe(asset, recipe) {
+  if (!recipe) return null;
+  if (recipe.schema !== OFFICIAL_ROCK_GALLERY_RECIPE_SCHEMA || recipe.version !== 1) {
+    throw new Error(`${asset.id} has an unsupported editable rock recipe.`);
+  }
+  if (recipe.generator?.unit !== 'metre') {
+    throw new Error(`${asset.id} editable recipe must use metres.`);
+  }
+  return frozenCopy(recipe);
+}
+
+function validateMaterialConfig(asset, materialConfig) {
+  if (!materialConfig) return null;
+  if (materialConfig.schema !== OFFICIAL_ROCK_MATERIAL_SCHEMA || materialConfig.version !== 2) {
+    throw new Error(`${asset.id} has an unsupported Call Me Sensei material package.`);
+  }
+  if (materialConfig.assetId !== asset.id || materialConfig.shader?.preset !== 'call_me_sensei') {
+    throw new Error(`${asset.id} material package failed identity or preset validation.`);
+  }
+  if (!isRecord(materialConfig.textures)) {
+    throw new Error(`${asset.id} material package has no texture bindings.`);
+  }
+  return frozenCopy(materialConfig);
+}
+
+/**
+ * Load the immutable documents associated with a nature-reference rock.
+ * Legacy 480 rocks remain valid and simply return null for documents they do
+ * not publish.
+ */
+export async function loadOfficialCatalogRockPackage(asset, {
+  fetchImpl = globalThis.fetch?.bind(globalThis),
+  includeManifest = false,
+  includeNatureProvenance = false,
+} = {}) {
+  if (!asset || asset.domain !== 'natural.rock') {
+    throw new TypeError('Official rock package loading requires a normalized natural.rock asset.');
+  }
+  const files = asset.packageFiles ?? {};
+  const [recipeDocument, materialDocument, manifest, natureProvenance] = await Promise.all([
+    files.recipeUrl ? fetchJson(fetchImpl, files.recipeUrl, `${asset.id} recipe`) : asset.recipe,
+    fetchJson(fetchImpl, files.materialConfigUrl, `${asset.id} material package`),
+    includeManifest ? fetchJson(fetchImpl, files.manifestUrl, `${asset.id} manifest`) : null,
+    includeNatureProvenance
+      ? fetchJson(fetchImpl, files.natureProvenanceUrl, `${asset.id} nature provenance`)
+      : null,
+  ]);
+  const recipe = recipeDocument?.schema === OFFICIAL_ROCK_GALLERY_RECIPE_SCHEMA
+    ? validateRecipe(asset, recipeDocument)
+    : frozenCopy(asset.recipe);
+  const materialConfig = validateMaterialConfig(asset, materialDocument);
+  return Object.freeze({
+    asset,
+    files,
+    manifest: frozenCopy(manifest),
+    materialConfig,
+    natureProvenance: frozenCopy(natureProvenance),
+    recipe,
+  });
+}
+
+function configureRockTexture(texture, descriptor, role) {
+  texture.name = `ToonLab ${role} · ${descriptor.url}`;
+  texture.colorSpace = descriptor.srgb === true ? SRGBColorSpace : NoColorSpace;
+  texture.flipY = false;
+  texture.wrapS = RepeatWrapping;
+  texture.wrapT = RepeatWrapping;
+  texture.magFilter = LinearFilter;
+  texture.minFilter = LinearMipmapLinearFilter;
+  texture.generateMipmaps = true;
+  texture.userData.toonlabOfficialRockRole = role;
+  texture.userData.toonlabOfficialRockUrl = descriptor.url;
+  texture.needsUpdate = true;
+  return texture;
+}
+
+/** Load the exact texture slots consumed by applyRockShader(). */
+export async function loadOfficialCatalogRockShaderInput(rockPackage, {
+  textureLoader = new TextureLoader(),
+} = {}) {
+  const config = rockPackage?.materialConfig;
+  if (!config) return null;
+  const textures = {};
+  await Promise.all(Object.entries(config.textures).map(async ([role, descriptor]) => {
+    if (!descriptor?.url) throw new Error(`${config.assetId}/${role} has no immutable texture URL.`);
+    const texture = await textureLoader.loadAsync(descriptor.url);
+    textures[role] = configureRockTexture(texture, descriptor, role);
+  }));
+  return Object.freeze({
+    materialConfig: config,
+    settings: frozenCopy(config.shader?.settings ?? {}),
+    textures: Object.freeze(textures),
+  });
+}
+
+/**
+ * Portable hand-off for Rock Lab or another editor. Geometry derivatives are
+ * deliberately separate: edits target control.glb, while retained high, LODs,
+ * collision, and baked/runtime outputs can be regenerated or replaced.
+ */
+export function createOfficialCatalogRockEditorDescriptor(asset, rockPackage = null) {
+  if (!asset || asset.domain !== 'natural.rock') {
+    throw new TypeError('Official rock editor descriptors require a normalized natural.rock asset.');
+  }
+  const recipe = rockPackage?.recipe ?? asset.recipe;
+  const files = asset.packageFiles ?? {};
+  if (recipe?.schema !== OFFICIAL_ROCK_GALLERY_RECIPE_SCHEMA) return null;
+  return Object.freeze({
+    assetId: asset.id,
+    controlModelUrl: files.controlModelUrl,
+    cullBelowPixels: asset.lod?.cullBelowPixels ?? recipe.output?.cullBelowPixels ?? 0,
+    editing: frozenCopy(recipe.editing ?? {}),
+    lodModelUrls: asset.lod?.urls ?? files.lodModelUrls ?? Object.freeze([]),
+    materialConfigUrl: files.materialConfigUrl,
+    recipe: frozenCopy(recipe),
+    recipeUrl: files.recipeUrl,
+    retainedHighModelUrl: files.retainedHighModelUrl,
+    collisionModelUrl: files.collisionModelUrl,
+    worldUnitMetres: recipe.generator?.unit === 'metre' ? 1 : null,
+  });
+}

package/src/cloud/cloudReprojection.js

@@ -97,7 +97,7 @@ function createMrtTarget(width, height, name, distanceName) {
 
   const distance = target.textures[1];
   distance.name = distanceName;
-  distance.format = THREE.RedFormat;
+  distance.format = THREE.RGFormat;
   distance.type = THREE.HalfFloatType;
   distance.minFilter = THREE.NearestFilter;
   distance.magFilter = THREE.NearestFilter;
@@ -157,6 +157,7 @@ export function createCloudReprojection({
   cloudMaterial = cloudVolume?.material ?? null,
   cloudUniforms = cloudVolume?.uniforms ?? null,
   shape,
+  wind = null,
   fade = null,
   historyDiv = 2,
   width = 1,
@@ -205,6 +206,7 @@ export function createCloudReprojection({
     previousCameraPosition: uniform(new THREE.Vector3()),
     historyValid: uniform(0),
     cameraStatic: uniform(1),
+    windDelta: uniform(new THREE.Vector3()),
     sourceSize: uniform(new THREE.Vector2(lowWidth, lowHeight)),
     historySize: uniform(new THREE.Vector2(historyWidth, historyHeight)),
     freshSlot: uniform(new THREE.Vector2()),
@@ -218,6 +220,7 @@ export function createCloudReprojection({
   const historyTexture = texture(historyRead.textures[0]);
   const historyDistanceTexture = texture(historyRead.textures[1]);
   const temporalHitDistance = property('float', 'toonlabTemporalHitDistance');
+  const temporalSceneDistance = property('float', 'toonlabTemporalSceneDistance');
 
   const resolveMaterial = new NodeMaterial();
   resolveMaterial.name = `${name}Resolve`;
@@ -239,6 +242,11 @@ export function createCloudReprojection({
     const freshSample = marchTexture.sample(srcCenter).toVar();
     const fallback = marchTexture.sample(uvNode).toVar();
     const currentHitDistance = marchDistanceTexture.sample(srcCenter).x.toVar();
+    const currentSceneDistance = cloudVolume?.sceneDepthNode
+      ? select(cloudUniforms.sceneDepthEnabled.greaterThan(0.5),
+        min(cloudVolume.sceneDepthNode.sample(uvNode).r, 65000), float(65000)).toVar()
+      : float(65000);
+    temporalSceneDistance.assign(currentSceneDistance);
 
     const neighborhoodMin = vec4(freshSample).toVar();
     const neighborhoodMax = vec4(freshSample).toVar();
@@ -305,6 +313,7 @@ export function createCloudReprojection({
       const rayDirection = uniforms.rayBasis.mul(vec3(ndc, 1)).normalize().toVar();
       const worldHit = uniforms.cameraPosition
         .add(rayDirection.mul(reprojectionDistance))
+        .sub(uniforms.windDelta)
         .toVar();
       const previousClip = uniforms.previousViewProjection.mul(vec4(worldHit, 1)).toVar();
       const previousNdc = previousClip.xy.div(max(abs(previousClip.w), 1e-6)).toVar();
@@ -335,11 +344,17 @@ export function createCloudReprojection({
       uniforms.historySize,
     ).toVar();
     const previousHitDistance = historyDistanceTexture.sample(previousUv).x.toVar();
+    const previousSceneDistance = historyDistanceTexture.sample(previousUv).y;
     history.assign(vec4(max(history.rgb, vec3(0)), clamp(history.a, 0, 1)));
 
+    const depthMatches = abs(expectedPreviousDistance.sub(previousHitDistance))
+      .lessThanEqual(float(REJECT_THRESHOLD).mul(max(expectedPreviousDistance, 1)));
     const historyUsable = inBounds
       .and(uniforms.historyValid.greaterThan(0.5))
       .and(carriedSelfDistance.greaterThanEqual(MIN_CARRIED_DISTANCE))
+      .and(gateBypass.or(depthMatches))
+      .and(abs(previousSceneDistance.sub(currentSceneDistance))
+        .lessThanEqual(max(currentSceneDistance.mul(0.02), 10)))
       .toVar();
     const clampedHistory = select(
       uniforms.cameraStatic.greaterThan(0.5),
@@ -350,6 +365,11 @@ export function createCloudReprojection({
 
     const currentIsMiss = currentHitDistance
       .greaterThanEqual(CLOUD_HIT_DISTANCE_MISS_THRESHOLD);
+    const opacityConfidence = select(
+      uniforms.cameraStatic.greaterThan(0.5),
+      float(1),
+      saturate(abs(history.a.sub(freshSample.a)).mul(2).oneMinus()),
+    );
     const freshHistoryWeight = select(
       currentIsMiss,
       float(FRESH_HISTORY_WEIGHT_NEAR),
@@ -362,7 +382,7 @@ export function createCloudReprojection({
           currentHitDistance,
         ),
       ),
-    );
+    ).mul(opacityConfidence);
     const freshResolve = select(
       historyUsable,
       mix(freshSample, clampedHistory, freshHistoryWeight),
@@ -370,8 +390,6 @@ export function createCloudReprojection({
     ).toVar();
     const result = select(isFresh, freshResolve, staleResolve).toVar();
 
-    const depthMatches = abs(expectedPreviousDistance.sub(previousHitDistance))
-      .lessThanEqual(float(REJECT_THRESHOLD).mul(expectedPreviousDistance));
     const distanceTrusted = historyUsable.and(gateBypass.or(depthMatches));
     temporalHitDistance.assign(select(
       isFresh,
@@ -384,11 +402,12 @@ export function createCloudReprojection({
 
   resolveMaterial.fragmentNode = mrt({
     output: resolveColor,
-    hitDistHistory: vec4(temporalHitDistance, 0, 0, 1),
+    hitDistHistory: vec4(temporalHitDistance, temporalSceneDistance, 0, 1),
   });
 
   const quad = new QuadMesh(resolveMaterial);
   const previousViewProjection = new THREE.Matrix4();
+  const previousProjection = new THREE.Matrix4();
   const previousCameraPosition = new THREE.Vector3();
   const previousQuaternion = new THREE.Quaternion();
   const currentPosition = new THREE.Vector3();
@@ -396,6 +415,9 @@ export function createCloudReprojection({
   const currentForward = new THREE.Vector3();
   const rightScratch = new THREE.Vector3();
   const upScratch = new THREE.Vector3();
+  const previousWindOffset = new THREE.Vector3();
+  const previousEvolutionOffset = new THREE.Vector3();
+  const previousForward = new THREE.Vector3();
   let hasPreviousView = false;
   let frame = 0;
   let framesSinceReset = 0;
@@ -438,10 +460,18 @@ export function createCloudReprojection({
     const cameraMoved = hasPreviousView
       && (currentPosition.distanceToSquared(previousCameraPosition) >= 1e-8
         || currentQuaternion.angleTo(previousQuaternion) >= 1e-6);
+    const offset = wind?.offset?.value;
+    const evolution = wind?.evolutionOffset?.value;
+    uniforms.windDelta.value.set(0, 0, 0);
+    if (hasPreviousView && offset) uniforms.windDelta.value.subVectors(offset, previousWindOffset);
+    const fieldMoved = uniforms.windDelta.value.lengthSq() > 1e-8
+      || (hasPreviousView && evolution && evolution.distanceToSquared(previousEvolutionOffset) > 1e-8);
     const cut = !hasPreviousView
+      || !previousProjection.equals(camera.projectionMatrix)
       || currentPosition.distanceTo(previousCameraPosition) > CLOUD_HISTORY_CUT_DISTANCE
+      || uniforms.windDelta.value.length() > CLOUD_HISTORY_CUT_DISTANCE
       || (hasPreviousView
-        && currentForward.dot(new THREE.Vector3(0, 0, -1).applyQuaternion(previousQuaternion))
+        && currentForward.dot(previousForward.set(0, 0, -1).applyQuaternion(previousQuaternion))
           < CLOUD_HISTORY_CUT_COSINE);
     if (cut) reset();
 
@@ -461,7 +491,7 @@ export function createCloudReprojection({
 
     uniforms.cameraPosition.value.copy(currentPosition);
     uniforms.previousCameraPosition.value.copy(previousCameraPosition);
-    uniforms.cameraStatic.value = cameraMoved ? 0 : 1;
+    uniforms.cameraStatic.value = cameraMoved || fieldMoved ? 0 : 1;
     uniforms.freshSlot.value.set(cellX, cellY);
     uniforms.previousViewProjection.value.copy(previousViewProjection);
 
@@ -501,8 +531,11 @@ export function createCloudReprojection({
     previousViewProjection
       .copy(camera.projectionMatrix)
       .multiply(camera.matrixWorldInverse);
+    previousProjection.copy(camera.projectionMatrix);
     previousCameraPosition.copy(currentPosition);
     previousQuaternion.copy(currentQuaternion);
+    if (offset) previousWindOffset.copy(offset);
+    if (evolution) previousEvolutionOffset.copy(evolution);
     hasPreviousView = true;
     uniforms.historyValid.value = 1;
     frame += 1;