@babylonjs-toolkit/next 9.34.10 → 9.34.100

package/lib/scenemanager.js

@@ -143,7 +143,7 @@ import { UnityScrollBar } from './unityscrollbar';
 import { UnityDropdownMenu } from './unitydropdownmenu';
 import { RectAreaLight } from '@babylonjs/core/Lights/rectAreaLight';
 export class SceneManager {
-    static get Version() { return "9.34.10 - R1"; }
+    static get Version() { return "9.34.100 - R1"; }
     static get Copyright() { return "All rights reserved (c) 2024 Mackey Kinard"; }
     static IsPrecompilingShaders() {
         return SceneManager.PrecompileShaders !== false;
@@ -9198,7 +9198,6 @@ export class CVTOOLS_unity_metadata {
                     return;
                 const levels = [];
                 const rendererCounts = [];
-                let multiRenderer = false;
                 let totalMeshes = 0;
                 for (let index = 0; index < levelCount; index++) {
                     const entry = lodentries[index];
@@ -9212,8 +9211,6 @@ export class CVTOOLS_unity_metadata {
                             meshes.push(lodnode);
                         }
                     });
-                    if (meshes.length > 1)
-                        multiRenderer = true;
                     totalMeshes += meshes.length;
                     rendererCounts.push(meshes.length);
                     levels.push({ distance: thresholds[index], meshes: meshes });
@@ -9221,14 +9218,15 @@ export class CVTOOLS_unity_metadata {
                 if (totalMeshes === 0)
                     return;
                 const fadeMode = UnityLodGroups.ParseFadeMode(metadata.fademode);
-                const nativeCandidate = (useDistances === false && multiRenderer === false && fadeMode === UnityLodGroups.FADE_NONE
+                const requiresSwitcher = UnityLodGroups.RequiresSwitcher(levels.map((level) => level.meshes), fadeMode);
+                const nativeCandidate = (useDistances === false && requiresSwitcher === false
                     && levels[0].meshes.length === 1 && levels[0].meshes[0] instanceof Mesh && !(levels[0].meshes[0] instanceof InstancedMesh));
                 if (nativeCandidate === true && this._setupNativeCoverageLevelOfDetail(scene, transform, levels, lodBias, metadata) === true) {
                 }
                 else if (useDistances === false) {
                     this._setupLevelOfDetailSwitcher(scene, transform, levels, rendererCounts, UnityLodGroups.MODE_COVERAGE, lodBias, metadata);
                 }
-                else if (multiRenderer === true || fadeMode !== UnityLodGroups.FADE_NONE) {
+                else if (requiresSwitcher === true) {
                     this._setupLevelOfDetailSwitcher(scene, transform, levels, rendererCounts, UnityLodGroups.MODE_DISTANCE, lodBias, metadata);
                 }
                 else {
@@ -9735,10 +9733,14 @@ export class CVTOOLS_unity_metadata {
                         return { mesh: skyboxMesh, texture: skyboxTexture };
                     };
                     const pbSkyClass = HdrpPhysicallyBasedSky;
-                    const hdrpSkyType = (HdrpRendering.IsParityExport(metadata) === true && metadata.hdrp.sky != null && typeof metadata.hdrp.sky.type === "string") ? metadata.hdrp.sky.type.toLowerCase() : null;
+                    const physicalSky = PhysicalSkyBlock.SkyOf(metadata);
+                    const hdrpSkyType = (physicalSky != null && typeof physicalSky.type === "string") ? physicalSky.type.toLowerCase() : null;
                     const liveSky = (pbSkyClass != null && hdrpSkyType === "physicallybased")
                         ? pbSkyClass.TryCreate(babylonScene, metadata, root, { rendergroup: rendergroup, bakedSky: hasBakedSkyFaces ? (() => buildBakedSky().mesh) : null })
                         : null;
+                    const volumetricClouds = VolumetricClouds;
+                    if (volumetricClouds != null)
+                        volumetricClouds.TryCreate(babylonScene, metadata, root);
                     const graphSky = (liveSky == null && hdrpSkyType !== "none" && typeof skybox.customMaterial === "string" && skybox.bags != null && ShaderGraphSky != null)
                         ? ShaderGraphSky.CreateGraphSkybox(babylonScene, skybox.bags, { size: skysize, rendergroup: rendergroup, skyfog: skyfog, tags: skytags, environment: (skybox.environment == null && babylonScene.environmentTexture == null) })
                         : null;
@@ -9845,8 +9847,10 @@ export class CVTOOLS_unity_metadata {
             const hasDiffuseIbl = Array.isArray(environment.sh) && environment.sh.length === 27;
             const useUnitySH = (mode === 0 && hasDiffuseIbl === true);
             const environmentLevel = (useUnitySH ? (specIbl * scale * SPECULAR_SCALE) : specIbl * SPECULAR_SCALE) * HdrpRendering.Indirect(babylonScene).reflection;
+            const hasEnvironmentFile = (envinfo != null && envinfo !== "");
+            const ambientScale = LightingConversions.EnvironmentAmbientScale(diffuseIbl, hasEnvironmentFile ? environmentLevel : null, units, HdrpRendering.IsParity(babylonScene));
             if (useUnitySH)
-                this.generateSphericalHarmonics(babylonScene, environment.sh, diffuseIbl, (envinfo != null && envinfo !== "") ? environmentLevel : null);
+                this.generateSphericalHarmonics(babylonScene, environment.sh, ambientScale, hasEnvironmentFile ? environmentLevel : null);
             if (envinfo != null && envinfo !== "") {
                 try {
                     const root = (this._rootUrl != null) ? this._rootUrl : "/";
@@ -9954,6 +9958,8 @@ export class CVTOOLS_unity_metadata {
             }
             if (metadata.shaderglobals != null)
                 ShaderGlobals.LoadSceneGlobals(babylonScene, metadata.shaderglobals);
+            ShaderGlobals.LoadSceneDrivers(babylonScene, metadata.shaderglobaldrivers);
+            ShaderGraphRuntime.RecordExportReport(babylonScene, metadata.exportreport);
             if (metadata.lights2d != null && Light2DTexture != null)
                 Light2DTexture.Load(babylonScene, metadata.lights2d);
             if (metadata.renderfeatures != null && ShaderGraphPass != null)
@@ -15431,6 +15437,8 @@ export class LightingConversions {
     static UnityLinearLightColor(light) {
         if (light == null || light.diffuse == null)
             return new Color3(0.0, 0.0, 0.0);
+        if (light.metadata != null && light.metadata.toolkit != null && light.metadata.toolkit.linearDiffuse === true)
+            return light.diffuse.clone();
         const rider = (light.metadata != null && light.metadata.toolkit != null) ? light.metadata.toolkit.colorTemperature : null;
         const d = light.diffuse;
         const channel = (value, factor) => {
@@ -15443,6 +15451,18 @@ export class LightingConversions {
         const tb = (rider != null) ? rider.b : 1.0;
         return new Color3(channel(d.r, tr), channel(d.g, tg), channel(d.b, tb));
     }
+    static LinearizeLightColor(light, scene) {
+        const sceneMetadata = (scene != null && scene.metadata != null) ? scene.metadata.toolkit : null;
+        const toolkit = (light != null && light.metadata != null) ? light.metadata.toolkit : null;
+        if (sceneMetadata == null || toolkit == null || toolkit.linearDiffuse === true)
+            return false;
+        const isLinearProject = sceneMetadata.colorspace != null && ("" + sceneMetadata.colorspace).toLowerCase() === "linear";
+        if (!isLinearProject || HdrpRendering.IsParityExport(sceneMetadata) === true)
+            return false;
+        light.diffuse = LightingConversions.UnityLinearLightColor(light);
+        toolkit.linearDiffuse = true;
+        return true;
+    }
     static SetShadowFade(scene, fade) {
         if (scene == null || !Array.isArray(fade) || fade.length < 2)
             return;
@@ -15898,6 +15918,10 @@ export class LightingConversions {
             return Math.max(0.0, reflection);
         return Math.min(levelMax, Math.max(0.0, reflection));
     }
+    static EnvironmentAmbientScale(ambientIntensity, environmentLevel, units, isParity) {
+        const isNormalised = units === LightingConversions.PhysicalUnits && environmentLevel != null && environmentLevel > 0;
+        return (isNormalised && isParity !== true) ? ambientIntensity / environmentLevel : ambientIntensity;
+    }
     static WarnBakedSkyWithoutEnvironment(skybox) {
         if (skybox == null || skybox.bakedsky !== true || skybox.environment != null)
             return false;
@@ -17610,6 +17634,7 @@ export class MetadataParser {
                 babylonLight.metadata.toolkit.hdrpSky = component.hdrpsky;
             babylonLight.metadata.toolkit.intensityFactor = intensityFactor;
             babylonLight.metadata.toolkit.colorTemperature = (component.colortemperature != null) ? Utilities.ParseColor3(component.colortemperature, Color3.White()) : null;
+            LightingConversions.LinearizeLightColor(babylonLight, scene);
             if (component.cookie != null)
                 UnityLightCookies.Apply(scene, babylonLight, entity, component.cookie);
             babylonLight.shadowEnabled = false;
@@ -18098,6 +18123,10 @@ export class OpaqueSceneColor {
         }
         return all;
     }
+    static CopyConversionFor(imageProcessing) {
+        const isEncodedByMaterials = imageProcessing != null && imageProcessing.isEnabled === true && imageProcessing.applyByPostProcess !== true;
+        return isEncodedByMaterials ? OpaqueSceneColor.COPY_TO_LINEAR : OpaqueSceneColor.COPY_PLAIN;
+    }
     static QueueSamples(subMeshes, materials) {
         if (subMeshes == null || materials == null || materials.size === 0)
             return false;
@@ -18168,7 +18197,7 @@ export class OpaqueSceneColor {
         if (!copier.isReady())
             return;
         engine.unBindFramebuffer(current, true);
-        copier.copy(current.texture, destination);
+        copier.copy(current.texture, destination, OpaqueSceneColor.CopyConversionFor(scene.imageProcessingConfiguration));
         if (target.__tkMips === true && target.getInternalTexture() != null && typeof engine.generateMipmaps === "function")
             engine.generateMipmaps(target.getInternalTexture());
         engine.bindFramebuffer(current, undefined, undefined, undefined, true);
@@ -18179,6 +18208,27 @@ export class OpaqueSceneColor {
 OpaqueSceneColor.Ratio = null;
 OpaqueSceneColor.StoreKey = "__tkOpaqueSceneColor";
 OpaqueSceneColor.UseCopy = true;
+OpaqueSceneColor.COPY_PLAIN = 0;
+OpaqueSceneColor.COPY_TO_LINEAR = 1;
+export class PhysicalSkyBlock {
+    static UrpBlock(metadata) {
+        const block = (metadata != null) ? metadata.urp : null;
+        return (block != null && typeof block.version === "number" && block.version >= PhysicalSkyBlock.UrpBlockVersion) ? block : null;
+    }
+    static SkyOf(metadata) {
+        if (HdrpRendering.IsParityExport(metadata) === true)
+            return metadata.hdrp.sky;
+        const block = PhysicalSkyBlock.UrpBlock(metadata);
+        return (block != null) ? block.sky : null;
+    }
+    static FogOf(metadata) {
+        if (HdrpRendering.IsParityExport(metadata) === true)
+            return metadata.hdrp.fog;
+        const block = PhysicalSkyBlock.UrpBlock(metadata);
+        return (block != null) ? block.fog : null;
+    }
+}
+PhysicalSkyBlock.UrpBlockVersion = 1;
 export class FixedStepClock {
     constructor(fixedDeltaTime = FixedStepClock.DEFAULT_FIXED_DELTA_TIME, maximumDeltaTime = FixedStepClock.DEFAULT_MAXIMUM_DELTA_TIME) {
         this.accumulatedTime = 0;
@@ -19447,7 +19497,9 @@ export class SceneShaderWarmup {
                 SceneShaderWarmup.SkipFrustumClipping(scene, frustumState);
             const drawHidden = drawWholeScene && ownPipelines && options.includeHiddenMeshes === true && SceneShaderWarmup.DrawHiddenMeshesOnReveal === true;
             const shownHiddenMeshes = drawHidden ? SceneShaderWarmup.ShowHiddenMeshesForDraws(scene) : [];
-            const punctualShadowDraws = (drawWholeScene && ownPipelines) ? SceneShaderWarmup.DrawPunctualShadowMapsFully(scene) : [];
+            const fullShadowDraws = (drawWholeScene && ownPipelines) ? SceneShaderWarmup.DrawShadowMapsFully(scene) : [];
+            const lodCycle = (drawWholeScene && ownPipelines) ? SceneShaderWarmup.CycleNativeLodLevels(scene) : null;
+            const settleFrames = Math.max(SceneShaderWarmup.PIPELINE_SETTLE_FRAMES, (lodCycle != null) ? lodCycle.length : 0);
             const shadowListWraps = SceneShaderWarmup.KeepHiddenCastersInShadowMaps(scene, shownHiddenMeshes);
             const scaleVariantDraw = (drawWholeScene && ownPipelines) ? SceneShaderWarmup.AlternateScaleVariants(scene) : null;
             const materialVariantDraw = (drawWholeScene && ownPipelines) ? SceneShaderWarmup.AlternateMaterialVariants(scene) : null;
@@ -19458,10 +19510,11 @@ export class SceneShaderWarmup {
                 const stageFraction = (requested > startRequested) ? (compiled - startCompiled) / (requested - startRequested) : 0;
                 const pipelineStep = { step: "pipelines", ready: compiled - startCompiled, total: requested - startRequested };
                 report(effects.ready + compiled - startCompiled, effects.total + requested - startRequested + 1, effectShare + (1 - effectShare) * stageFraction * 0.99, pipelineStep);
-            }).then((timedOut) => {
+            }, settleFrames).then((timedOut) => {
                 SceneShaderWarmup.RestoreFrustumClipping(scene, frustumState);
                 SceneShaderWarmup.RestoreShadowCasterLists(shadowListWraps);
-                SceneShaderWarmup.RestorePunctualShadowMaps(punctualShadowDraws);
+                SceneShaderWarmup.RestoreFullShadowMaps(fullShadowDraws);
+                SceneShaderWarmup.RestoreNativeLodLevels(scene, lodCycle);
                 SceneShaderWarmup.RestoreHiddenMeshes(scene, shownHiddenMeshes);
                 SceneShaderWarmup.RestoreScaleVariants(scene, scaleVariantDraw);
                 SceneShaderWarmup.RestoreMaterialVariants(scene, materialVariantDraw);
@@ -21181,13 +21234,15 @@ export class SceneShaderWarmup {
                 wrap.shadowMap.getCustomRenderList = wrap.customList;
         }
     }
-    static DrawPunctualShadowMapsFully(scene) {
+    static DrawShadowMapsFully(scene) {
         const draws = [];
         for (const shadowMap of SceneShaderWarmup.CollectShadowMaps(scene)) {
             const renderGate = shadowMap;
-            if (renderGate._tkSkipInvisible !== true)
+            const isGated = renderGate._tkSkipInvisible === true;
+            if (!isGated && !SceneShaderWarmup.HasCasterCullingList(shadowMap))
                 continue;
-            renderGate._tkPrewarmDrawAll = true;
+            if (isGated)
+                renderGate._tkPrewarmDrawAll = true;
             draws.push({ shadowMap: shadowMap, customList: shadowMap.getCustomRenderList });
             shadowMap.getCustomRenderList = null;
             try {
@@ -21197,7 +21252,11 @@ export class SceneShaderWarmup {
         }
         return draws;
     }
-    static RestorePunctualShadowMaps(draws) {
+    static HasCasterCullingList(shadowMap) {
+        const customList = shadowMap.getCustomRenderList;
+        return customList != null && (customList.tkCasterCulling === true || customList.tkTerrainCulling === true);
+    }
+    static RestoreFullShadowMaps(draws) {
         for (const draw of draws) {
             draw.shadowMap._tkPrewarmDrawAll = false;
             if (draw.shadowMap.getCustomRenderList == null)
@@ -21429,6 +21488,53 @@ export class SceneShaderWarmup {
         draw.frameObserver = null;
         SceneShaderWarmup.SetScaleVariantForced(draw.entries, false);
     }
+    static NativeLodSequence(mesh) {
+        if (!(mesh instanceof Mesh) || mesh.isDisposed())
+            return [];
+        const levels = mesh.getLODLevels();
+        if (levels == null || levels.length === 0)
+            return [];
+        const sequence = [mesh];
+        for (const level of levels) {
+            if (level.mesh != null && !level.mesh.isDisposed() && sequence.indexOf(level.mesh) < 0)
+                sequence.push(level.mesh);
+        }
+        return (sequence.length > 1) ? sequence : [];
+    }
+    static CycleNativeLodLevels(scene) {
+        if (SceneShaderWarmup.WarmNativeLodLevelsOnReveal !== true)
+            return null;
+        const sequences = new Map();
+        let length = 0;
+        for (const mesh of scene.meshes) {
+            const sequence = SceneShaderWarmup.NativeLodSequence(mesh);
+            if (sequence.length === 0)
+                continue;
+            sequences.set(mesh, sequence);
+            length = Math.max(length, sequence.length);
+        }
+        if (sequences.size === 0)
+            return null;
+        const previousSelector = scene.customLODSelector || null;
+        const cycle = { sequences: sequences, length: length, frameIndex: 0, previousSelector: previousSelector, selector: null, frameObserver: null };
+        cycle.selector = (mesh, camera) => {
+            const sequence = sequences.get(mesh);
+            if (sequence != null)
+                return sequence[cycle.frameIndex % sequence.length];
+            return (previousSelector != null) ? previousSelector(mesh, camera) : mesh.getLOD(camera);
+        };
+        cycle.frameObserver = scene.onAfterRenderObservable.add(() => { cycle.frameIndex++; });
+        scene.customLODSelector = cycle.selector;
+        return cycle;
+    }
+    static RestoreNativeLodLevels(scene, cycle) {
+        if (cycle == null)
+            return;
+        scene.onAfterRenderObservable.remove(cycle.frameObserver);
+        cycle.frameObserver = null;
+        if (scene.customLODSelector === cycle.selector)
+            scene.customLODSelector = cycle.previousSelector;
+    }
     static SetScaleVariantForced(entries, forced) {
         const prototypeUpdate = AbstractMesh.prototype._updateNonUniformScalingState;
         for (const entry of entries) {
@@ -21572,8 +21678,8 @@ export class SceneShaderWarmup {
         }
         return phases;
     }
-    static WaitForPipelinesPerCamera(scene, pipelines, deadline, phases, onProgress) {
-        return SceneShaderWarmup.RunCameraPhasesAsync(scene, phases, false, () => SceneShaderWarmup.WaitForPipelines(scene, pipelines, deadline, onProgress), (timedOut) => timedOut);
+    static WaitForPipelinesPerCamera(scene, pipelines, deadline, phases, onProgress, settleFrames = SceneShaderWarmup.PIPELINE_SETTLE_FRAMES) {
+        return SceneShaderWarmup.RunCameraPhasesAsync(scene, phases, false, () => SceneShaderWarmup.WaitForPipelines(scene, pipelines, deadline, onProgress, settleFrames), (timedOut) => timedOut);
     }
     static RunCameraPhasesAsync(scene, phases, noPhaseRun, runStep, isTimedOut) {
         const runPhase = (phaseIndex, previous) => {
@@ -21591,7 +21697,7 @@ export class SceneShaderWarmup {
         };
         return runPhase(0, noPhaseRun);
     }
-    static WaitForPipelines(scene, pipelines, deadline, onProgress) {
+    static WaitForPipelines(scene, pipelines, deadline, onProgress, settleFrames = SceneShaderWarmup.PIPELINE_SETTLE_FRAMES) {
         return new Promise((resolve) => {
             let quietFrames = 0;
             let lastRequested = -1;
@@ -21622,7 +21728,7 @@ export class SceneShaderWarmup {
                 quietFrames = quiet ? quietFrames + 1 : 0;
                 if (onProgress != null)
                     onProgress(pipelines.compiled, pipelines.requested);
-                if (quietFrames >= SceneShaderWarmup.PIPELINE_SETTLE_FRAMES)
+                if (quietFrames >= settleFrames)
                     finish(false);
             });
             timer = setTimeout(() => finish(true), Math.max(0, deadline - SceneShaderWarmup.NowMs()));
@@ -22179,6 +22285,7 @@ SceneShaderWarmup.BuildScenePipelinesOnReveal = true;
 SceneShaderWarmup.DrawHiddenMeshesOnReveal = true;
 SceneShaderWarmup.WarmEmptyThinInstancesOnReveal = true;
 SceneShaderWarmup.WarmScaleVariantsOnReveal = true;
+SceneShaderWarmup.WarmNativeLodLevelsOnReveal = true;
 SceneShaderWarmup.OPTIONAL_UNIT_GRACE_MS = 3000;
 SceneShaderWarmup.GIVEN_UP_NAMES_SHOWN = 10;
 SceneShaderWarmup.LateCompileReporting = null;
@@ -23815,6 +23922,27 @@ export class ShaderGlobals {
                     ShaderGlobals._keywords.add(k);
         ShaderGlobals._version++;
     }
+    static LoadSceneDrivers(scene, drivers) {
+        if (scene == null || drivers == null || drivers.length === 0)
+            return;
+        const observer = scene.onBeforeRenderObservable.add(() => {
+            const deltaSeconds = ShaderGlobals.GetClock(scene).deltaTime;
+            for (const driver of drivers)
+                ShaderGlobals.AdvanceDriver(driver, deltaSeconds);
+        });
+        scene.onDisposeObservable.addOnce(() => { scene.onBeforeRenderObservable.remove(observer); });
+    }
+    static AdvanceDriver(driver, deltaSeconds) {
+        const entry = ShaderGlobals._vectors.get(driver.name);
+        if (entry == null)
+            return;
+        const componentName = ShaderGlobals.DriverComponentNames[driver.component];
+        let advancedValue = entry.value[componentName] + driver.rate * deltaSeconds;
+        if (driver.wrap > 0 && advancedValue > driver.wrap)
+            advancedValue -= driver.wrap;
+        entry.value[componentName] = advancedValue;
+        ShaderGlobals._version++;
+    }
     static GetClock(scene) {
         if (scene == null)
             return { time: 0, deltaTime: 0, smoothDeltaTime: 0, frame: 0 };
@@ -23849,6 +23977,7 @@ export class ShaderGlobals {
         return clock;
     }
 }
+ShaderGlobals.DriverComponentNames = ["x", "y", "z", "w"];
 ShaderGlobals._version = 0;
 ShaderGlobals._floats = new Map();
 ShaderGlobals._vectors = new Map();
@@ -25073,6 +25202,23 @@ export class ShaderGraphRuntime {
                     loadTexture(textures[k], (texture) => { clone.setTextureValue(k, texture); });
         return clone;
     }
+    static RecordExportReport(scene, entries) {
+        if (entries == null || entries.length === 0)
+            return;
+        const record = ShaderGraphRuntime.Record(scene);
+        if (record == null)
+            return;
+        record.exportReport = entries;
+        ShaderGraphRuntime.ScheduleSceneSummary(scene);
+    }
+    static PrintExportReport(record) {
+        const entries = record.exportReport;
+        console.groupCollapsed("Export report: " + entries.length + " items not carried");
+        for (const entry of entries)
+            console.log(entry.feature + " - " + entry.reason + ": " + entry.items.join(", "));
+        console.groupEnd();
+        record.exportReport = null;
+    }
     static FlushSceneSummary(scene) {
         const record = ShaderGraphRuntime._records.get(scene != null ? scene.uniqueId : -1);
         if (record == null || record.scene !== scene)
@@ -25092,6 +25238,8 @@ export class ShaderGraphRuntime {
         const report = (ShaderGraphRuntime.ReportDeviations != null) ? ShaderGraphRuntime.ReportDeviations
             : (SceneManager != null && typeof SceneManager.IsDebugMode === "function" ? SceneManager.IsDebugMode() : true);
         const n = record.materials.size, m = record.lastResorts.size;
+        if (report && record.exportReport != null)
+            ShaderGraphRuntime.PrintExportReport(record);
         if (report && (n > 0 || m > 0)) {
             console.groupCollapsed("Shader Graph: " + n + " materials with deviations, " + m + " last resort" + (record.flushed ? " (built after the scene summary)" : ""));
             record.materials.forEach((entry, name) => {
@@ -29818,8 +29966,9 @@ export class UnityLodGroups {
     static ExportedSize(root, metadata) {
         if (root == null || metadata == null || !(metadata.lodsize > 0))
             return null;
-        const c = metadata.lodcenter;
-        const localPoint = (Array.isArray(c) && c.length >= 3) ? new Vector3(c[0], c[1], c[2]) : Vector3.Zero();
+        const exportedCenter = metadata.lodcenter;
+        const hasCenter = (Array.isArray(exportedCenter) && exportedCenter.length >= 3);
+        const localPoint = hasCenter ? new Vector3(0 - exportedCenter[0], exportedCenter[1], exportedCenter[2]) : Vector3.Zero();
         const scale = new Vector3();
         root.computeWorldMatrix(true).decompose(scale, null, null);
         const largest = Math.max(Math.abs(scale.x), Math.abs(scale.y), Math.abs(scale.z));
@@ -29830,6 +29979,35 @@ export class UnityLodGroups {
         const useDistances = !hasCoverages && (distances != null && distances.length > 0);
         return { useDistances: useDistances, thresholds: useDistances ? distances : (hasCoverages ? coverages : null) };
     }
+    static LevelsShareTransform(master, details) {
+        const masterMatrix = master.computeWorldMatrix(true);
+        for (const detail of details) {
+            if (UnityLodGroups.MatricesShareTransform(masterMatrix, detail.computeWorldMatrix(true)) === false)
+                return false;
+        }
+        return true;
+    }
+    static MatricesShareTransform(first, second) {
+        const offset = Vector3.Distance(first.getTranslation(), second.getTranslation());
+        if (offset > UnityLodGroups.NATIVE_TRANSFORM_TOLERANCE_METERS)
+            return false;
+        for (const element of UnityLodGroups.BASIS_ELEMENTS) {
+            if (Math.abs(first.m[element] - second.m[element]) > UnityLodGroups.NATIVE_BASIS_TOLERANCE)
+                return false;
+        }
+        return true;
+    }
+    static RequiresSwitcher(meshLevels, fadeMode) {
+        if (fadeMode !== UnityLodGroups.FADE_NONE)
+            return true;
+        if (meshLevels.some((meshes) => meshes.length > 1))
+            return true;
+        const master = meshLevels[0][0];
+        if (master == null)
+            return false;
+        const details = meshLevels.slice(1).map((meshes) => meshes[0]).filter((mesh) => mesh != null);
+        return UnityLodGroups.LevelsShareTransform(master, details) === false;
+    }
     static ParseFadeMode(mode) {
         const m = (mode != null) ? String(mode).toLowerCase() : "";
         if (m === "crossfade")
@@ -29992,21 +30170,25 @@ export class UnityLodGroups {
     addNativeGroup(master, details, coverages, worldSize) {
         if (!(master instanceof Mesh) || master instanceof InstancedMesh || coverages == null)
             return false;
-        const n = Math.min(coverages.length, details.length + 1);
-        if (n <= 0)
+        if (master.instances.length > 0)
+            return false;
+        const levelCount = Math.min(coverages.length, details.length + 1);
+        if (levelCount <= 0)
             return false;
-        for (let k = 0; k < n - 1; k++) {
-            const d = details[k];
-            if (!(d instanceof Mesh) || d instanceof InstancedMesh || d === master || d._masterMesh != null || details.indexOf(d) !== k)
+        for (let k = 0; k < levelCount - 1; k++) {
+            const detail = details[k];
+            if (!(detail instanceof Mesh) || detail instanceof InstancedMesh || detail === master || detail._masterMesh != null || details.indexOf(detail) !== k)
                 return false;
         }
-        for (let k = 1; k < n; k++)
+        if (UnityLodGroups.LevelsShareTransform(master, details.slice(0, levelCount - 1)) === false)
+            return false;
+        for (let k = 1; k < levelCount; k++)
             master.addLODLevel(1e6 + k, details[k - 1]);
-        master.addLODLevel(1e6 + n, null);
+        master.addLODLevel(1e6 + levelCount, null);
         const all = master.getLODLevels();
         const entries = [];
-        for (let i = 0; i < n; i++) {
-            const mesh = (i < n - 1) ? details[i] : null;
+        for (let i = 0; i < levelCount; i++) {
+            const mesh = (i < levelCount - 1) ? details[i] : null;
             let found = null;
             for (const level of all) {
                 if (level.mesh === mesh && entries.indexOf(level) === -1) {
@@ -30016,7 +30198,7 @@ export class UnityLodGroups {
             }
             entries.push(found);
         }
-        this._native.push({ master: master, entries: entries, coverages: coverages.slice(0, n), worldSize: worldSize });
+        this._native.push({ master: master, entries: entries, coverages: coverages.slice(0, levelCount), worldSize: worldSize });
         this._nativeKey[0] = NaN;
         return true;
     }
@@ -30266,6 +30448,9 @@ UnityLodGroups.FADE_NONE = 0;
 UnityLodGroups.FADE_CROSSFADE = 1;
 UnityLodGroups.FADE_SPEEDTREE = 2;
 UnityLodGroups.FADE_SECONDS = 0.5;
+UnityLodGroups.NATIVE_TRANSFORM_TOLERANCE_METERS = 0.005;
+UnityLodGroups.NATIVE_BASIS_TOLERANCE = 0.001;
+UnityLodGroups.BASIS_ELEMENTS = [0, 1, 2, 4, 5, 6, 8, 9, 10];
 UnityLodGroups.DeferLoadFadeClones = true;
 UnityLodGroups.FadeCloneSliceMs = 8;
 UnityLodGroups._cloneQueues = new Map();
@@ -69897,16 +70082,36 @@ export class HdrpFogPass {
         return HdrpFogPass.Uniforms.concat((S != null && Array.isArray(S.AtmosphereUniforms)) ? S.AtmosphereUniforms : [], ["scale"]);
     }
     static FogBlock(scene) {
-        const block = (HdrpRendering != null) ? HdrpRendering.Block(scene) : null;
+        if (HdrpRendering == null)
+            return null;
+        const fog = PhysicalSkyBlock.FogOf(HdrpRendering.SceneMetadata(scene));
+        if (fog != null && typeof fog.enabled === "boolean")
+            return fog;
+        const block = HdrpRendering.Block(scene);
         return (block != null && block.fog != null && typeof block.fog === "object") ? block.fog : null;
     }
     static SkyOf(scene) {
         const live = (HdrpPhysicallyBasedSky != null) ? HdrpPhysicallyBasedSky.Get(scene) : null;
         if (live != null)
             return live;
-        const block = (HdrpRendering != null) ? HdrpRendering.Block(scene) : null;
+        if (HdrpRendering == null)
+            return null;
+        const sky = PhysicalSkyBlock.SkyOf(HdrpRendering.SceneMetadata(scene));
+        if (sky != null)
+            return sky;
+        const block = HdrpRendering.Block(scene);
         return (block != null) ? block.sky : null;
     }
+    static BindChain(effect, scene, fog) {
+        if (HdrpRendering.IsParity(scene) === true) {
+            effect.setFloat4("fogChain", 0, 0, 0, 0);
+            return;
+        }
+        const water = (MeshWaterSurface != null) ? MeshWaterSurface.Get(scene) : null;
+        const isDisplayEncoded = scene.imageProcessingConfiguration.applyByPostProcess !== true;
+        const isFogOn = fog != null && fog.enabled === true;
+        effect.setFloat4("fogChain", isDisplayEncoded ? 1 : 0, (water != null) ? 1 : 0, (water != null) ? water.getSurfaceHeight() : 0, isFogOn ? 1 : 0);
+    }
     static Frame(scene, fog) {
         const s = scene;
         const renderId = scene.getRenderId();
@@ -70204,6 +70409,113 @@ fn hdrpFogAmbient(dir: vec3f) -> vec3f {
         + uniforms.fogAmb4.rgb * (d.x * d.y) + uniforms.fogAmb5.rgb * (d.y * d.z) + uniforms.fogAmb6.rgb * (3.0 * d.z * d.z - 1.0)
         + uniforms.fogAmb7.rgb * (d.x * d.z) + uniforms.fogAmb8.rgb * (d.x * d.x - d.y * d.y);
 }
+`;
+    }
+    static AerialPerspectiveGlsl() {
+        return `
+vec3 fogRescaledChapman(vec2 z, vec2 Z, float c) {
+    float sinTheta = sqrt(clamp(1.0 - c * c, 0.0, 1.0));
+    vec2 ch = vec2(pbChapmanUpper(z.x, abs(c)) * exp(Z.x - z.x), pbChapmanUpper(z.y, abs(c)) * exp(Z.y - z.y));
+    if (c < 0.0) {
+        vec2 z0 = z * sinTheta;
+        ch = vec2(2.0 * pbChapmanHorizontal(z0.x) * exp(Z.x - z0.x), 2.0 * pbChapmanHorizontal(z0.y) * exp(Z.y - z0.y)) - ch;
+    }
+    return vec3(ch, 0.0);
+}
+vec3 fogApOpticalDepth(vec3 O, vec3 V, float t) {
+    float R = pbAtmo0.x;
+    vec2 n = vec2(pbAtmo1.x, pbAtmo1.z);
+    vec2 H = vec2(pbAtmo1.y, pbAtmo1.w);
+    float r = length(O);
+    vec3 N = O / r;
+    float cosChi = dot(N, V);
+    vec2 Z = R * n;
+    vec3 P1 = O + t * V;
+    float r1 = length(P1);
+    float cosChi1 = dot(P1, V) / r1;
+    float cosChi0 = (cosChi1 >= 0.0) ? cosChi : -cosChi;
+    vec2 ch0 = fogRescaledChapman(r * n, Z, cosChi0).xy;
+    vec2 z1 = r1 * n;
+    vec2 ch1 = vec2(pbChapmanUpper(z1.x, abs(cosChi1)) * exp(Z.x - z1.x), pbChapmanUpper(z1.y, abs(cosChi1)) * exp(Z.y - z1.y));
+    vec2 od = abs(ch0 - ch1) * H;
+    float ozone = pbOzoneOpticalDepth(r, cosChi, t);
+    return od.x * pbAirExt.xyz + od.y * pbAirExt.w + ozone * pbOzone0.xyz;
+}
+void fogAerialPerspective(vec2 uv, vec3 O, vec3 dir, float tFrag, out vec3 apColor, out vec3 apOpacity) {
+    float r = length(O);
+    float cosChi = dot(O / r, dir);
+    float tAp = min(tFrag, 128000.0);
+    float off = 1.0 / 128.0;
+    float s = sqrt(max(tAp / 128000.0 - off * off, 0.0)) - off;
+    float layer = clamp(s * 64.0 - 0.5, 0.0, 63.0);
+    float l0 = floor(layer);
+    float l1 = min(l0 + 1.0, 63.0);
+    apColor = mix(textureLod(apLut, vec3(uv, l0), 0.0).rgb, textureLod(apLut, vec3(uv, l1), 0.0).rgb, layer - l0);
+    apOpacity = vec3(1.0) - exp(-fogApOpticalDepth(O, dir, tAp));
+    apOpacity = pbDesaturate(apOpacity, pbZenith.w) * pbArt.x;
+    float chi = acos(clamp(cosChi, -1.0, 1.0));
+    float hor = acos(clamp(pbCosHorizon(r), -1.0, 1.0));
+    float nrm = clamp(1.0 - chi / max(hor, 0.0001), 0.0, 1.0);
+    float te = exp(pbArt.y * nrm) * pbArt.z - pbArt.z;
+    apColor *= mix(pbHorizon.xyz, pbZenith.xyz, te);
+}
+`;
+    }
+    static AerialPerspectiveWgsl() {
+        return `
+fn fogRescaledChapman(z: vec2f, Z: vec2f, c: f32) -> vec2f {
+    let sinTheta: f32 = sqrt(clamp(1.0 - c * c, 0.0, 1.0));
+    var ch: vec2f = vec2f(pbChapmanUpper(z.x, abs(c)) * exp(Z.x - z.x), pbChapmanUpper(z.y, abs(c)) * exp(Z.y - z.y));
+    if (c < 0.0) {
+        let z0: vec2f = z * sinTheta;
+        ch = vec2f(2.0 * pbChapmanHorizontal(z0.x) * exp(Z.x - z0.x), 2.0 * pbChapmanHorizontal(z0.y) * exp(Z.y - z0.y)) - ch;
+    }
+    return ch;
+}
+fn fogApOpticalDepth(O: vec3f, V: vec3f, t: f32) -> vec3f {
+    let R: f32 = uniforms.pbAtmo0.x;
+    let n: vec2f = vec2f(uniforms.pbAtmo1.x, uniforms.pbAtmo1.z);
+    let H: vec2f = vec2f(uniforms.pbAtmo1.y, uniforms.pbAtmo1.w);
+    let r: f32 = length(O);
+    let N: vec3f = O / r;
+    let cosChi: f32 = dot(N, V);
+    let Z: vec2f = R * n;
+    let P1: vec3f = O + t * V;
+    let r1: f32 = length(P1);
+    let cosChi1: f32 = dot(P1, V) / r1;
+    let cosChi0: f32 = select(-cosChi, cosChi, cosChi1 >= 0.0);
+    let ch0: vec2f = fogRescaledChapman(r * n, Z, cosChi0);
+    let z1: vec2f = r1 * n;
+    let ch1: vec2f = vec2f(pbChapmanUpper(z1.x, abs(cosChi1)) * exp(Z.x - z1.x), pbChapmanUpper(z1.y, abs(cosChi1)) * exp(Z.y - z1.y));
+    let od: vec2f = abs(ch0 - ch1) * H;
+    let ozone: f32 = pbOzoneOpticalDepth(r, cosChi, t);
+    return od.x * uniforms.pbAirExt.xyz + od.y * uniforms.pbAirExt.w + ozone * uniforms.pbOzone0.xyz;
+}
+struct FogAerial {
+    color: vec3f,
+    opacity: vec3f,
+};
+fn fogAerialPerspective(uv: vec2f, O: vec3f, dir: vec3f, tFrag: f32) -> FogAerial {
+    let r: f32 = length(O);
+    let cosChi: f32 = dot(O / r, dir);
+    let tAp: f32 = min(tFrag, 128000.0);
+    let off: f32 = 1.0 / 128.0;
+    let s: f32 = sqrt(max(tAp / 128000.0 - off * off, 0.0)) - off;
+    let layer: f32 = clamp(s * 64.0 - 0.5, 0.0, 63.0);
+    let l0: f32 = floor(layer);
+    let l1: f32 = min(l0 + 1.0, 63.0);
+    let c0: vec3f = textureSampleLevel(apLut, apLutSampler, uv, i32(l0), 0.0).rgb;
+    let c1: vec3f = textureSampleLevel(apLut, apLutSampler, uv, i32(l1), 0.0).rgb;
+    var apColor: vec3f = mix(c0, c1, vec3f(layer - l0));
+    var apOpacity: vec3f = vec3f(1.0) - exp(-fogApOpticalDepth(O, dir, tAp));
+    apOpacity = pbDesaturate(apOpacity, uniforms.pbZenith.w) * uniforms.pbArt.x;
+    let chi: f32 = acos(clamp(cosChi, -1.0, 1.0));
+    let hor: f32 = acos(clamp(pbCosHorizon(r), -1.0, 1.0));
+    let nrm: f32 = clamp(1.0 - chi / max(hor, 0.0001), 0.0, 1.0);
+    let te: f32 = exp(uniforms.pbArt.y * nrm) * uniforms.pbArt.z - uniforms.pbArt.z;
+    apColor *= mix(uniforms.pbHorizon.xyz, uniforms.pbZenith.xyz, vec3f(te));
+    return FogAerial(apColor, apOpacity);
+}
 `;
     }
     static GlslHelpers(prefix) {
@@ -70251,6 +70563,7 @@ fn ${prefix}PhaseHG(g: f32, c: f32) -> f32 {
 precision highp sampler2DArray;
 #endif
 precision highp float;
+#define FOG_DISPLAY_GAMMA 2.2
 varying vec2 vUV;
 uniform sampler2D textureSampler;
 uniform sampler2D depthSampler;
@@ -70270,40 +70583,14 @@ ${HdrpFogPass.AmbientDeclarations(false)}uniform vec4 fogEye;
 uniform vec4 fogForward;
 uniform vec4 fogViewport;
 uniform vec4 fogInput;
+uniform vec4 fogChain;
 uniform mat4 fogInvViewProj;
 uniform mat4 fogEnvMatrix;
 #ifdef HDRP_FOG_AP
 uniform sampler2DArray apLut;
 uniform vec4 fogApCamera;
 ${ap}
-vec3 fogRescaledChapman(vec2 z, vec2 Z, float c) {
-    float sinTheta = sqrt(clamp(1.0 - c * c, 0.0, 1.0));
-    vec2 ch = vec2(pbChapmanUpper(z.x, abs(c)) * exp(Z.x - z.x), pbChapmanUpper(z.y, abs(c)) * exp(Z.y - z.y));
-    if (c < 0.0) {
-        vec2 z0 = z * sinTheta;
-        ch = vec2(2.0 * pbChapmanHorizontal(z0.x) * exp(Z.x - z0.x), 2.0 * pbChapmanHorizontal(z0.y) * exp(Z.y - z0.y)) - ch;
-    }
-    return vec3(ch, 0.0);
-}
-vec3 fogApOpticalDepth(vec3 O, vec3 V, float t) {
-    float R = pbAtmo0.x;
-    vec2 n = vec2(pbAtmo1.x, pbAtmo1.z);
-    vec2 H = vec2(pbAtmo1.y, pbAtmo1.w);
-    float r = length(O);
-    vec3 N = O / r;
-    float cosChi = dot(N, V);
-    vec2 Z = R * n;
-    vec3 P1 = O + t * V;
-    float r1 = length(P1);
-    float cosChi1 = dot(P1, V) / r1;
-    float cosChi0 = (cosChi1 >= 0.0) ? cosChi : -cosChi;
-    vec2 ch0 = fogRescaledChapman(r * n, Z, cosChi0).xy;
-    vec2 z1 = r1 * n;
-    vec2 ch1 = vec2(pbChapmanUpper(z1.x, abs(cosChi1)) * exp(Z.x - z1.x), pbChapmanUpper(z1.y, abs(cosChi1)) * exp(Z.y - z1.y));
-    vec2 od = abs(ch0 - ch1) * H;
-    float ozone = pbOzoneOpticalDepth(r, cosChi, t);
-    return od.x * pbAirExt.xyz + od.y * pbAirExt.w + ozone * pbOzone0.xyz;
-}
+${HdrpFogPass.AerialPerspectiveGlsl()}
 #endif
 ${HdrpFogPass.AmbientGlsl()}${HdrpFogPass.GlslHelpers("hdrpFog")}${HdrpFogPass.LocalGlsl()}
 vec3 hdrpFogColor(vec3 dir, float dist) {
@@ -70356,29 +70643,28 @@ void main(void) {
         opacity = vec3(1.0 - trCamera);
     }
 #ifdef HDRP_FOG_AP
-    if (!isSky && fogApCamera.w > 0.5 && fogEye.w > 0.5) {
-        vec3 O = fogApCamera.xyz;
-        float r = length(O);
-        float cosChi = dot(O / r, dir);
-        float tAp = min(tFrag, 128000.0);
-        float off = 1.0 / 128.0;
-        float s = sqrt(max(tAp / 128000.0 - off * off, 0.0)) - off;
-        float layer = clamp(s * 64.0 - 0.5, 0.0, 63.0);
-        float l0 = floor(layer);
-        float l1 = min(l0 + 1.0, 63.0);
-        vec3 apColor = mix(textureLod(apLut, vec3(vUV, l0), 0.0).rgb, textureLod(apLut, vec3(vUV, l1), 0.0).rgb, layer - l0);
-        vec3 apOpacity = vec3(1.0) - exp(-fogApOpticalDepth(O, dir, tAp));
-        apOpacity = pbDesaturate(apOpacity, pbZenith.w) * pbArt.x;
-        float chi = acos(clamp(cosChi, -1.0, 1.0));
-        float hor = acos(clamp(pbCosHorizon(r), -1.0, 1.0));
-        float nrm = clamp(1.0 - chi / max(hor, 0.0001), 0.0, 1.0);
-        float te = exp(pbArt.y * nrm) * pbArt.z - pbArt.z;
-        apColor *= mix(pbHorizon.xyz, pbZenith.xyz, te);
+    // fogChain.w: a URP sky with its fog on gives sky pixels aerial perspective up to the fog distance, as Unity's opaque pass does
+    if ((!isSky || fogChain.w > 0.5) && fogApCamera.w > 0.5 && fogEye.w > 0.5) {
+        vec3 apColor = vec3(0.0);
+        vec3 apOpacity = vec3(0.0);
+        fogAerialPerspective(vUV, fogApCamera.xyz, dir, tFrag, apColor, apOpacity);
         color = color + (vec3(1.0) - opacity) * apColor;
         opacity = opacity + (vec3(1.0) - opacity) * apOpacity;
     }
 #endif
-    gl_FragColor = vec4(src.rgb * (vec3(1.0) - opacity) + color, src.a);
+    // fogChain.yz: a URP sky fogs before transparents, so a ray that meets the water before the opaque depth keeps its colour
+    if (fogChain.y > 0.5 && dir.y < 0.0 && fogEye.y > fogChain.z) {
+        float tWater = (fogChain.z - fogEye.y) / dir.y;
+        if (isSky || tWater < tFrag) {
+            color = vec3(0.0);
+            opacity = vec3(0.0);
+        }
+    }
+    // fogChain.x: the chain holds display values, so the fog composites in linear and encodes again
+    vec3 scene = (fogChain.x > 0.5) ? pow(src.rgb, vec3(FOG_DISPLAY_GAMMA)) : src.rgb;
+    vec3 fogged = scene * (vec3(1.0) - opacity) + color;
+    if (fogChain.x > 0.5) fogged = pow(clamp(fogged, vec3(0.0), vec3(1.0)), vec3(1.0 / FOG_DISPLAY_GAMMA));
+    gl_FragColor = vec4(fogged, src.a);
 }
 `;
     }
@@ -70386,6 +70672,7 @@ void main(void) {
         const S = HdrpPbSkyShaders;
         const ap = (S != null) ? (S.WgslUniforms() + S.WgslCommon()) : "";
         return `varying vUV: vec2f;
+const FOG_DISPLAY_GAMMA: f32 = 2.2;
 var textureSamplerSampler: sampler;
 var textureSampler: texture_2d<f32>;
 var depthSamplerSampler: sampler;
@@ -70407,6 +70694,7 @@ ${HdrpFogPass.AmbientDeclarations(true)}uniform fogEye: vec4f;
 uniform fogForward: vec4f;
 uniform fogViewport: vec4f;
 uniform fogInput: vec4f;
+uniform fogChain: vec4f;
 uniform fogInvViewProj: mat4x4f;
 uniform fogEnvMatrix: mat4x4f;
 #ifdef HDRP_FOG_AP
@@ -70414,34 +70702,7 @@ var apLutSampler: sampler;
 var apLut: texture_2d_array<f32>;
 uniform fogApCamera: vec4f;
 ${ap}
-fn fogRescaledChapman(z: vec2f, Z: vec2f, c: f32) -> vec2f {
-    let sinTheta: f32 = sqrt(clamp(1.0 - c * c, 0.0, 1.0));
-    var ch: vec2f = vec2f(pbChapmanUpper(z.x, abs(c)) * exp(Z.x - z.x), pbChapmanUpper(z.y, abs(c)) * exp(Z.y - z.y));
-    if (c < 0.0) {
-        let z0: vec2f = z * sinTheta;
-        ch = vec2f(2.0 * pbChapmanHorizontal(z0.x) * exp(Z.x - z0.x), 2.0 * pbChapmanHorizontal(z0.y) * exp(Z.y - z0.y)) - ch;
-    }
-    return ch;
-}
-fn fogApOpticalDepth(O: vec3f, V: vec3f, t: f32) -> vec3f {
-    let R: f32 = uniforms.pbAtmo0.x;
-    let n: vec2f = vec2f(uniforms.pbAtmo1.x, uniforms.pbAtmo1.z);
-    let H: vec2f = vec2f(uniforms.pbAtmo1.y, uniforms.pbAtmo1.w);
-    let r: f32 = length(O);
-    let N: vec3f = O / r;
-    let cosChi: f32 = dot(N, V);
-    let Z: vec2f = R * n;
-    let P1: vec3f = O + t * V;
-    let r1: f32 = length(P1);
-    let cosChi1: f32 = dot(P1, V) / r1;
-    let cosChi0: f32 = select(-cosChi, cosChi, cosChi1 >= 0.0);
-    let ch0: vec2f = fogRescaledChapman(r * n, Z, cosChi0);
-    let z1: vec2f = r1 * n;
-    let ch1: vec2f = vec2f(pbChapmanUpper(z1.x, abs(cosChi1)) * exp(Z.x - z1.x), pbChapmanUpper(z1.y, abs(cosChi1)) * exp(Z.y - z1.y));
-    let od: vec2f = abs(ch0 - ch1) * H;
-    let ozone: f32 = pbOzoneOpticalDepth(r, cosChi, t);
-    return od.x * uniforms.pbAirExt.xyz + od.y * uniforms.pbAirExt.w + ozone * uniforms.pbOzone0.xyz;
-}
+${HdrpFogPass.AerialPerspectiveWgsl()}
 #endif
 ${HdrpFogPass.AmbientWgsl()}${HdrpFogPass.WgslHelpers("hdrpFog")}${HdrpFogPass.LocalWgsl()}
 fn hdrpFogColor(dir: vec3f, dist: f32) -> vec3f {
@@ -70497,31 +70758,29 @@ fn main(input: FragmentInputs) -> FragmentOutputs {
         opacity = vec3f(1.0 - trCamera);
     }
 #ifdef HDRP_FOG_AP
-    if (!isSky && uniforms.fogApCamera.w > 0.5 && uniforms.fogEye.w > 0.5) {
-        let O: vec3f = uniforms.fogApCamera.xyz;
-        let r: f32 = length(O);
-        let cosChi: f32 = dot(O / r, dir);
-        let tAp: f32 = min(tFrag, 128000.0);
-        let off: f32 = 1.0 / 128.0;
-        let s: f32 = sqrt(max(tAp / 128000.0 - off * off, 0.0)) - off;
-        let layer: f32 = clamp(s * 64.0 - 0.5, 0.0, 63.0);
-        let l0: f32 = floor(layer);
-        let l1: f32 = min(l0 + 1.0, 63.0);
-        let c0: vec3f = textureSampleLevel(apLut, apLutSampler, uv, i32(l0), 0.0).rgb;
-        let c1: vec3f = textureSampleLevel(apLut, apLutSampler, uv, i32(l1), 0.0).rgb;
-        var apColor: vec3f = mix(c0, c1, vec3f(layer - l0));
-        var apOpacity: vec3f = vec3f(1.0) - exp(-fogApOpticalDepth(O, dir, tAp));
-        apOpacity = pbDesaturate(apOpacity, uniforms.pbZenith.w) * uniforms.pbArt.x;
-        let chi: f32 = acos(clamp(cosChi, -1.0, 1.0));
-        let hor: f32 = acos(clamp(pbCosHorizon(r), -1.0, 1.0));
-        let nrm: f32 = clamp(1.0 - chi / max(hor, 0.0001), 0.0, 1.0);
-        let te: f32 = exp(uniforms.pbArt.y * nrm) * uniforms.pbArt.z - uniforms.pbArt.z;
-        apColor *= mix(uniforms.pbHorizon.xyz, uniforms.pbZenith.xyz, vec3f(te));
+    // fogChain.w: a URP sky with its fog on gives sky pixels aerial perspective up to the fog distance, as Unity's opaque pass does
+    if ((!isSky || uniforms.fogChain.w > 0.5) && uniforms.fogApCamera.w > 0.5 && uniforms.fogEye.w > 0.5) {
+        let aerial: FogAerial = fogAerialPerspective(uv, uniforms.fogApCamera.xyz, dir, tFrag);
+        let apColor: vec3f = aerial.color;
+        let apOpacity: vec3f = aerial.opacity;
         color = color + (vec3f(1.0) - opacity) * apColor;
         opacity = opacity + (vec3f(1.0) - opacity) * apOpacity;
     }
 #endif
-    fragmentOutputs.color = vec4f(src.rgb * (vec3f(1.0) - opacity) + color, src.a);
+    // fogChain.yz: a URP sky fogs before transparents, so a ray that meets the water before the opaque depth keeps its colour
+    if (uniforms.fogChain.y > 0.5 && dir.y < 0.0 && uniforms.fogEye.y > uniforms.fogChain.z) {
+        let tWater: f32 = (uniforms.fogChain.z - uniforms.fogEye.y) / dir.y;
+        if (isSky || tWater < tFrag) {
+            color = vec3f(0.0);
+            opacity = vec3f(0.0);
+        }
+    }
+    // fogChain.x: the chain holds display values, so the fog composites in linear and encodes again
+    var scene: vec3f = src.rgb;
+    if (uniforms.fogChain.x > 0.5) { scene = pow(src.rgb, vec3f(FOG_DISPLAY_GAMMA)); }
+    var fogged: vec3f = scene * (vec3f(1.0) - opacity) + color;
+    if (uniforms.fogChain.x > 0.5) { fogged = pow(clamp(fogged, vec3f(0.0), vec3f(1.0)), vec3f(1.0 / FOG_DISPLAY_GAMMA)); }
+    fragmentOutputs.color = vec4f(fogged, src.a);
 }
 `;
     }
@@ -70602,6 +70861,7 @@ fn main(input: FragmentInputs) -> FragmentOutputs {
             effect.setFloat4("fogE", frame.e[0], frame.e[1], frame.e[2], frame.e[3]);
             effect.setFloat4("fogSunDir", frame.sunDir[0], frame.sunDir[1], frame.sunDir[2], frame.sunDir[3]);
             effect.setFloat4("fogSun", frame.sun[0], frame.sun[1], frame.sun[2], frame.sun[3]);
+            HdrpFogPass.BindChain(effect, scene, state.fog);
             effect.setFloat4("fogEnv", frame.env[0], frame.env[1], frame.env[2], frame.env[3]);
             effect.setFloat4("fogSky", frame.sky[0], frame.sky[1], frame.sky[2], frame.sky[3]);
             for (let i = 0; i < HdrpFogPass.AmbientVectors; i++)
@@ -70633,7 +70893,7 @@ fn main(input: FragmentInputs) -> FragmentOutputs {
     }
 }
 HdrpFogPass.ShaderName = "toolkitHdrpFog";
-HdrpFogPass.Uniforms = ["fogA", "fogB", "fogC", "fogD", "fogE", "fogSunDir", "fogSun", "fogEnv", "fogSky", "fogAmb0", "fogAmb1", "fogAmb2", "fogAmb3", "fogAmb4", "fogAmb5", "fogAmb6", "fogAmb7", "fogAmb8", "fogEye", "fogForward", "fogViewport", "fogInput", "fogInvViewProj", "fogEnvMatrix", "fogApCamera"];
+HdrpFogPass.Uniforms = ["fogA", "fogB", "fogC", "fogD", "fogE", "fogSunDir", "fogSun", "fogEnv", "fogSky", "fogAmb0", "fogAmb1", "fogAmb2", "fogAmb3", "fogAmb4", "fogAmb5", "fogAmb6", "fogAmb7", "fogAmb8", "fogEye", "fogForward", "fogViewport", "fogInput", "fogInvViewProj", "fogEnvMatrix", "fogApCamera", "fogChain"];
 HdrpFogPass.Samplers = ["depthSampler", "fogEnvSampler", "apLut"];
 HdrpFogPass.AmbientVectors = 9;
 HdrpFogPass.registered = false;
@@ -71258,6 +71518,8 @@ export class HdrpPbSkyShaders {
 #define PB_TWO_PI 6.28318530718
 #define PB_HALF_PI 1.57079632679
 #define PB_INV_PI 0.31830988618
+#define PB_DISPLAY_GAMMA 0.45454545454
+#define PB_NO_BODY_HIT 3.0e38
 #define PB_FLT_MIN 1.175494351e-38
 #define PB_FLT_EPS 5.960464478e-8
 float pbSat(float x) { return clamp(x, 0.0, 1.0); }
@@ -71687,6 +71949,10 @@ vec2 pbCloudLighting${X}(vec2 uv) {
 ` + HdrpPbSkyShaders.GlslCloudUniforms() + `#ifdef PB_CLOUDS
 uniform sampler2D cloudTex;
 #endif
+#ifdef PBSKY_SPACE_EMISSION
+uniform samplerCube spaceCube;
+uniform vec4 pbSpace;
+#endif
 ` + HdrpPbSkyShaders.GlslCommon() + `
 vec2 pbMapSkyView(float cosChi, vec3 V) {
     float coord = pbFastACos(cosChi) / PB_HALF_PI;
@@ -71781,6 +72047,12 @@ vec3 pbRenderSky(vec3 d) {
             }
         }
     }
+#ifdef PBSKY_SPACE_EMISSION
+    if (lookAbove && tFrag >= PB_NO_BODY_HIT) {
+        vec3 spaceDirection = vec3((pbSpace.y * d.x - pbSpace.z * d.z) * pbSpace.w, d.y, pbSpace.z * d.x + pbSpace.y * d.z);
+        radiance += textureLod(spaceCube, spaceDirection, 0.0).rgb * pbSpace.x;
+    }
+#endif
     vec3 skyColor = vec3(0.0);
     vec3 skyOpacity = vec3(0.0);
     if (lookAbove) {
@@ -71803,7 +72075,12 @@ vec3 pbRenderSky(vec3 d) {
 }
 void main(void) {
     vec3 d = normalize(vDir);
-    gl_FragColor = vec4(pbRenderSky(d) * pbArt.w, 1.0);
+    // pbCounts.w: a URP sky on an LDR camera. Its world has no ground below the horizon, where the sky pass has no in-scatter
+    if (pbCounts.w > 0.5) d.y = max(d.y, 0.0);
+    vec3 color = pbRenderSky(normalize(d)) * pbArt.w;
+    // the same flag: the camera has no HDR chain, so the sky encodes for display as materials do
+    if (pbCounts.w > 0.5) color = pow(clamp(color, vec3(0.0), vec3(1.0)), vec3(PB_DISPLAY_GAMMA));
+    gl_FragColor = vec4(color, 1.0);
 }
 `;
     }
@@ -71830,6 +72107,8 @@ const PB_PI: f32 = 3.14159265359;
 const PB_TWO_PI: f32 = 6.28318530718;
 const PB_HALF_PI: f32 = 1.57079632679;
 const PB_INV_PI: f32 = 0.31830988618;
+const PB_DISPLAY_GAMMA: f32 = 0.45454545454;
+const PB_NO_BODY_HIT: f32 = 3.0e38;
 const PB_FLT_MIN: f32 = 1.175494351e-38;
 const PB_FLT_EPS: f32 = 5.960464478e-8;
 fn pbSat(x: f32) -> f32 { return clamp(x, 0.0, 1.0); }
@@ -72272,6 +72551,11 @@ fn pbCloudLighting${X}(uv: vec2f) -> vec2f {
 var cloudTexSampler: sampler;
 var cloudTex: texture_2d<f32>;
 #endif
+#ifdef PBSKY_SPACE_EMISSION
+var spaceCubeSampler: sampler;
+var spaceCube: texture_cube<f32>;
+uniform pbSpace: vec4f;
+#endif
 ` + HdrpPbSkyShaders.WgslCommon() + `
 fn pbMapSkyView(cosChi: f32, V: vec3f) -> vec2f {
     let coord: f32 = pbFastACos(cosChi) / PB_HALF_PI;
@@ -72367,6 +72651,12 @@ fn pbRenderSky(d: vec3f) -> vec3f {
             }
         }
     }
+#ifdef PBSKY_SPACE_EMISSION
+    if (lookAbove && tFrag >= PB_NO_BODY_HIT) {
+        let spaceDirection: vec3f = vec3f((uniforms.pbSpace.y * d.x - uniforms.pbSpace.z * d.z) * uniforms.pbSpace.w, d.y, uniforms.pbSpace.z * d.x + uniforms.pbSpace.y * d.z);
+        radiance += textureSampleLevel(spaceCube, spaceCubeSampler, spaceDirection, 0.0).rgb * uniforms.pbSpace.x;
+    }
+#endif
     var skyColor: vec3f = vec3f(0.0);
     var skyOpacity: vec3f = vec3f(0.0);
     if (lookAbove) {
@@ -72389,8 +72679,13 @@ fn pbRenderSky(d: vec3f) -> vec3f {
 }
 @fragment
 fn main(input: FragmentInputs) -> FragmentOutputs {
-    let d: vec3f = normalize(fragmentInputs.vDir);
-    fragmentOutputs.color = vec4f(pbRenderSky(d) * uniforms.pbArt.w, 1.0);
+    var d: vec3f = normalize(fragmentInputs.vDir);
+    // pbCounts.w: a URP sky on an LDR camera. Its world has no ground below the horizon, where the sky pass has no in-scatter
+    if (uniforms.pbCounts.w > 0.5) { d.y = max(d.y, 0.0); }
+    var color: vec3f = pbRenderSky(normalize(d)) * uniforms.pbArt.w;
+    // the same flag: the camera has no HDR chain, so the sky encodes for display as materials do
+    if (uniforms.pbCounts.w > 0.5) { color = pow(clamp(color, vec3f(0.0), vec3f(1.0)), vec3f(PB_DISPLAY_GAMMA)); }
+    fragmentOutputs.color = vec4f(color, 1.0);
 }
 `;
     }
@@ -72643,17 +72938,16 @@ export class HdrpPhysicallyBasedSky {
         return (sky != null && sky.disposed !== true) ? sky : null;
     }
     static Decide(metadata, engine) {
-        if (HdrpRendering.IsParityExport(metadata) === false)
-            return { live: false, key: null, reason: "not an HDRP parity export" };
-        const sky = metadata.hdrp.sky;
+        const sky = PhysicalSkyBlock.SkyOf(metadata);
+        const isUrp = PhysicalSkyBlock.UrpBlock(metadata) != null && !HdrpRendering.IsParityExport(metadata);
         if (sky == null)
-            return { live: false, key: null, reason: "no hdrp.sky block (export older than the live sky)" };
+            return { live: false, key: null, reason: "no physical sky block" };
         const type = (typeof sky.type === "string") ? sky.type.toLowerCase() : "";
         if (type !== "physicallybased")
             return { live: false, key: null, reason: "sky type " + (type || "unknown") };
         if (HdrpPhysicallyBasedSky.IsSupported(engine) === false)
             return { live: false, key: "hdrp:pbsky:unsupported", reason: "no WebGL2 / WebGPU half-float render target" };
-        if (sky.volumetricclouds === true)
+        if (isUrp === false && sky.volumetricclouds === true)
             return { live: false, key: "hdrp:pbsky:volumetricclouds", reason: "an active VolumetricClouds is not ported (the bake carries it)" };
         return { live: true, key: null, reason: "live" };
     }
@@ -72665,11 +72959,12 @@ export class HdrpPhysicallyBasedSky {
             if (decision.key != null)
                 LightingConversions.WarnOnce(decision.key, "HDRP PhysicallyBasedSky: " + decision.reason + " - the baked sky is used");
             if (decision.key != null)
-                HdrpPhysicallyBasedSky.AttachBakedSkySunAttenuation(scene, metadata.hdrp.sky);
+                HdrpPhysicallyBasedSky.AttachBakedSkySunAttenuation(scene, PhysicalSkyBlock.SkyOf(metadata));
             return null;
         }
         try {
-            return HdrpPhysicallyBasedSky.Create(scene, metadata.hdrp.sky, null, { root: root, bakedSky: (options != null) ? options.bakedSky : null, rendergroup: (options != null) ? options.rendergroup : 0, environmentSh: (metadata.skybox != null && metadata.skybox.environment != null) ? metadata.skybox.environment.sh : null });
+            const environment = (metadata.skybox != null) ? metadata.skybox.environment : null;
+            return HdrpPhysicallyBasedSky.Create(scene, PhysicalSkyBlock.SkyOf(metadata), null, { root: root, bakedSky: (options != null) ? options.bakedSky : null, rendergroup: (options != null) ? options.rendergroup : 0, environmentSh: (environment != null) ? environment.sh : null });
         }
         catch (e) {
             LightingConversions.WarnOnce("hdrp:pbsky:create", "HDRP PhysicallyBasedSky could not be created (" + ((e && e.message) ? e.message : e) + ") - the baked sky is used");
@@ -72755,6 +73050,13 @@ export class HdrpPhysicallyBasedSky {
         }
         return precomputationHash !== state.lastPrecompute || lightHash !== state.lastLight || state.requested === true;
     }
+    static ProbeRenderOutcome(capturing, pendingFilter, drewSky) {
+        if (capturing === true)
+            return (drewSky === true) ? HdrpPhysicallyBasedSky.ProbeCaptureAccepted : HdrpPhysicallyBasedSky.ProbeCaptureRetry;
+        if (pendingFilter === true && drewSky !== true)
+            return HdrpPhysicallyBasedSky.ProbeCaptureRetry;
+        return HdrpPhysicallyBasedSky.ProbeRenderKept;
+    }
     static SelectAmbientSh(skyAmbientMode, readback, exported) {
         if (skyAmbientMode === 1)
             return (readback != null) ? readback : exported;
@@ -72843,6 +73145,7 @@ export class HdrpPhysicallyBasedSky {
         this.filtering = null;
         this.pendingFilter = false;
         this.capturing = false;
+        this.probeDrawsSky = false;
         this.shReading = false;
         this.readbackHarmonics = null;
         this.exportedHarmonics = null;
@@ -72857,6 +73160,7 @@ export class HdrpPhysicallyBasedSky {
         this.startTime = Date.now();
         this.scene = scene;
         this.sky = sky || {};
+        this.sunIntensityScale = (typeof this.sky.sunintensityscale === "number") ? this.sky.sunintensityscale : 1;
         this.options = options;
         this.fixedLights = lights;
         this.coefficients = HdrpPbSkyMath.Coefficients(this.sky);
@@ -72907,16 +73211,23 @@ export class HdrpPhysicallyBasedSky {
             defines.push("#define PB_CLOUDS");
         if (layers.length >= 2)
             defines.push("#define PB_CLOUDS2");
+        this.spaceCube = this.loadSpaceEmission();
+        if (this.spaceCube != null)
+            defines.push("#define PBSKY_SPACE_EMISSION");
         const material = new ShaderMaterial("HDRP PBSky Material", scene, { vertex: HdrpPbSkyShaders.SkyName, fragment: HdrpPbSkyShaders.SkyName }, {
             attributes: ["position"],
-            uniforms: ["world", "viewProjection"].concat(HdrpPbSkyShaders.AtmosphereUniforms, HdrpPbSkyShaders.CloudUniforms),
-            samplers: ["skyViewLut", "cloudTex"],
+            uniforms: ["world", "viewProjection", "pbSpace"].concat(HdrpPbSkyShaders.AtmosphereUniforms, HdrpPbSkyShaders.CloudUniforms),
+            samplers: ["skyViewLut", "cloudTex", "spaceCube"],
             defines: defines,
             shaderLanguage: language
         });
         material.backFaceCulling = false;
         material.disableDepthWrite = true;
         material.setTexture("skyViewLut", this.skyViewLut);
+        if (this.spaceCube != null) {
+            material.setTexture("spaceCube", this.spaceCube);
+            material.setVector4("pbSpace", this.spaceEmissionUniform());
+        }
         if (layers.length > 0) {
             for (let i = 0; i < layers.length; i++)
                 this.cloudMaps.push(this.loadCloudMap(layers[i]));
@@ -73055,7 +73366,7 @@ export class HdrpPhysicallyBasedSky {
         let exposure = 1;
         const body = new Array(HdrpPbSkyShaders.BodyVec4s * HdrpPbSkyShaders.MaxBodies * 4).fill(0);
         const peSafe = (pe > 0) ? pe : 1;
-        const lux = (l) => l.intensity / peSafe;
+        const lux = (l) => (l.intensity * this.sunIntensityScale) / peSafe;
         const sunFor = (self) => {
             let best = null, max = 0;
             for (const l of this.scene.lights)
@@ -73128,7 +73439,7 @@ export class HdrpPhysicallyBasedSky {
         U.pbHorizon = [horizon[0], horizon[1], horizon[2], (typeof p.colorsaturation === "number") ? p.colorsaturation : 1];
         U.pbZenith = [zenith[0], zenith[1], zenith[2], (typeof p.alphasaturation === "number") ? p.alphasaturation : 1];
         U.pbArt = [(typeof p.alphamultiplier === "number") ? p.alphamultiplier : 1, exp[0], exp[1], pe];
-        U.pbCounts = [lightCount, lights.length, 1, 0];
+        U.pbCounts = [lightCount, lights.length, 1, this.encodesForDisplay() ? 1 : 0];
         U.pbBody = body;
         this.writeCloudUniforms(lights);
     }
@@ -73163,14 +73474,16 @@ export class HdrpPhysicallyBasedSky {
         }
     }
     cloudAmbient() {
-        const down = new Vector3(0, -1, 0);
+        return this.ambientAt(new Vector3(0, -1, 0));
+    }
+    ambientAt(direction) {
         if (this.ambientPolynomial != null)
-            return HdrpPbSkyMath.EvaluatePolynomial(this.ambientPolynomial, down);
+            return HdrpPbSkyMath.EvaluatePolynomial(this.ambientPolynomial, direction);
         if (this.exportedHarmonics == null)
             this.exportedHarmonics = this.parseExportedAmbient();
         if (this.exportedHarmonics == null)
             return new Color3(0, 0, 0);
-        return HdrpPbSkyMath.EvaluatePolynomial(LightingConversions.PolynomialFromPreScaled(this.exportedHarmonics, 1), down);
+        return HdrpPbSkyMath.EvaluatePolynomial(LightingConversions.PolynomialFromPreScaled(this.exportedHarmonics, 1), direction);
     }
     cloudLayers() {
         const cl = this.sky.cloudlayer;
@@ -73178,6 +73491,22 @@ export class HdrpPhysicallyBasedSky {
             return [];
         return cl.layerlist.filter((l) => l != null && l.cloudmap != null && typeof l.cloudmap.url === "string").slice(0, 2);
     }
+    loadSpaceEmission() {
+        const url = (this.sky.params != null) ? this.sky.params.spaceemissionurl : null;
+        if (typeof url !== "string")
+            return null;
+        const root = (typeof this.options.root === "string") ? this.options.root : "";
+        const cube = new CubeTexture(root + url, this.scene, null, false, null, null, null, Constants.TEXTUREFORMAT_RGBA, false, ".env");
+        cube.name = "HDRP PBSky Space Emission";
+        return cube;
+    }
+    spaceEmissionUniform() {
+        const params = this.sky.params;
+        const rotation = Array.isArray(params.spacerotation) ? params.spacerotation : [0, 0, 0];
+        const radians = Tools.ToRadians(rotation[1]);
+        const multiplier = (typeof params.spaceemissionmultiplier === "number") ? params.spaceemissionmultiplier : 1;
+        return new Vector4(multiplier, Math.cos(radians), Math.sin(radians), this.scene.useRightHandedSystem ? -1 : 1);
+    }
     loadCloudMap(layer) {
         const url = ((typeof this.options.root === "string") ? this.options.root : "") + layer.cloudmap.url;
         const tex = new Texture(url, this.scene, true, true, Texture.BILINEAR_SAMPLINGMODE);
@@ -73209,7 +73538,10 @@ export class HdrpPhysicallyBasedSky {
             this.applyMaterialUniforms();
             return;
         }
-        this.material.setVector4("pbCounts", new Vector4(counts[0], counts[1], (this.sky.includesuninbaking === true) ? 1 : 0, counts[3]));
+        this.material.setVector4("pbCounts", new Vector4(counts[0], counts[1], (this.sky.includesuninbaking === true) ? 1 : 0, 0));
+    }
+    encodesForDisplay() {
+        return HdrpRendering.IsParity(this.scene) !== true && this.scene.imageProcessingConfiguration.applyByPostProcess !== true;
     }
     applyMaterialUniforms() {
         const m = this.material;
@@ -73238,7 +73570,7 @@ export class HdrpPhysicallyBasedSky {
         const p = this.sky.params || {};
         if (p.renderingmode === 1)
             LightingConversions.WarnOnce("hdrp:pbsky:material", "HDRP PhysicallyBasedSky: the Material rendering mode (a Shader Graph sky) renders the default live atmosphere");
-        if (p.hasgroundtextures === true || p.hasspaceemission === true)
+        if (p.hasgroundtextures === true || (p.hasspaceemission === true && typeof p.spaceemissionurl !== "string"))
             LightingConversions.WarnOnce("hdrp:pbsky:textures", "HDRP PhysicallyBasedSky: ground / space emission textures are not rendered");
         for (const layer of this.cloudLayers())
             if (typeof layer.distortion === "number" && layer.distortion !== 0)
@@ -73271,20 +73603,28 @@ export class HdrpPhysicallyBasedSky {
         scene.customRenderTargets.push(probe.cubeTexture);
         const p = this.sky.params || {};
         probe.cubeTexture.onBeforeRenderObservable.add(() => {
-            if (this.capturing !== true)
-                return;
+            const subMesh = (this.mesh.subMeshes != null) ? this.mesh.subMeshes[0] : null;
+            this.probeDrawsSky = (subMesh != null) ? this.material.isReadyForSubMesh(this.mesh, subMesh) : this.material.isReady(this.mesh);
             const art = this.uniforms.pbArt, counts = this.uniforms.pbCounts;
             if (art != null)
                 this.material.setVector4("pbArt", new Vector4(art[0], art[1], art[2], 1));
             if (counts != null)
-                this.material.setVector4("pbCounts", new Vector4(counts[0], counts[1], (this.sky.includesuninbaking === true) ? 1 : 0, counts[3]));
+                this.material.setVector4("pbCounts", new Vector4(counts[0], counts[1], (this.sky.includesuninbaking === true) ? 1 : 0, 0));
         });
         probe.cubeTexture.onAfterRenderObservable.add((faceIndex) => {
-            if (this.capturing !== true || (typeof faceIndex === "number" && faceIndex < 5))
+            if (typeof faceIndex === "number" && faceIndex < 5)
                 return;
-            this.capturing = false;
             this.applyMaterialUniforms();
-            this.pendingFilter = true;
+            const state = HdrpPhysicallyBasedSky.ProbeRenderOutcome(this.capturing, this.pendingFilter, this.probeDrawsSky);
+            if (state === HdrpPhysicallyBasedSky.ProbeCaptureAccepted) {
+                this.capturing = false;
+                this.pendingFilter = true;
+            }
+            else if (state === HdrpPhysicallyBasedSky.ProbeCaptureRetry) {
+                this.capturing = true;
+                this.pendingFilter = false;
+                probe.cubeTexture.resetRefreshCounter();
+            }
         });
         this.exportedHarmonics = this.parseExportedAmbient();
     }
@@ -73487,6 +73827,8 @@ export class HdrpPhysicallyBasedSky {
             this.apTarget = engine.createRenderTargetTexture({ width: size[0], height: size[1], layers: size[2] }, { generateMipMaps: false, type: this.textureType, samplingMode: Constants.TEXTURE_BILINEAR_SAMPLINGMODE, format: Constants.TEXTUREFORMAT_RGBA, generateDepthBuffer: false, generateStencilBuffer: false, label: "HDRP PBSky Aerial Perspective" });
             this.apTexture = new BaseTexture(scene, this.apTarget.texture);
             this.apTexture.name = "HDRP PBSky Aerial Perspective";
+            this.apTexture.wrapU = Constants.TEXTURE_CLAMP_ADDRESSMODE;
+            this.apTexture.wrapV = Constants.TEXTURE_CLAMP_ADDRESSMODE;
             LightingConversions.WarnOnce("hdrp:pbsky:aerialshadow", "HDRP PhysicallyBasedSky: the aerial perspective has no shadowed in-scatter (the sun shadow map is not sampled)");
         }
         if (!this.apPass.isReady())
@@ -73575,7 +73917,7 @@ export class HdrpPhysicallyBasedSky {
         catch (e) { }
         for (const light of this.attenuated)
             HdrpPhysicallyBasedSky.RestoreLight(light);
-        const disposables = [this.msPass, this.viewPass, this.cloudPass, this.renderer, this.msLut, this.skyViewLut, this.cloudTex, this.material, this.mesh].concat(this.cloudMaps);
+        const disposables = [this.msPass, this.viewPass, this.cloudPass, this.renderer, this.msLut, this.skyViewLut, this.cloudTex, this.spaceCube, this.material, this.mesh].concat(this.cloudMaps);
         for (const d of disposables) {
             try {
                 if (d != null)
@@ -73594,6 +73936,9 @@ HdrpPhysicallyBasedSky.AerialPerspectiveSize = [32, 32, 64];
 HdrpPhysicallyBasedSky.AerialMaxDistance = 128000;
 HdrpPhysicallyBasedSky.MeshName = "HDRP Physically Based Sky";
 HdrpPhysicallyBasedSky.OnEnvironmentUpdated = new Observable();
+HdrpPhysicallyBasedSky.ProbeRenderKept = 0;
+HdrpPhysicallyBasedSky.ProbeCaptureAccepted = 1;
+HdrpPhysicallyBasedSky.ProbeCaptureRetry = 2;
 HdrpPhysicallyBasedSky.RealtimeMinFrames = 9;
 HdrpPhysicallyBasedSky.ShProjectionFaceSize = 64;
 HdrpPhysicallyBasedSky.CaptureFaceCount = 6;
@@ -91904,6 +92249,238 @@ LightProbeNetwork.DebugProbeSize = 0.1;
 LightProbeNetwork.InspectorSection = true;
 LightProbeNetwork.OnNetworkChangedObservable = new Observable();
 LightProbeNetwork.Sections = ["positions", "probesh", "tetraindices", "tetraadjacency", "renderersh", "rendererocclusion", "rendereranchor"];
+export class MeshWaterSurface extends ScriptComponent {
+    constructor(transform, scene, properties = {}, alias = "TOOLKIT.MeshWaterSurface") {
+        super(transform, scene, properties, alias);
+        this.waterProperties = null;
+        this.isUnderwater = false;
+        this.fogColorChannels = [0, 0, 0];
+        this.surfaceFogColor = new Color3(0, 0, 0);
+        this.surfaceFogDensity = 0;
+        this.surfaceFogStart = 0;
+        this.surfaceFogEnd = 0;
+        this.shownNodes = [];
+        this.shownParticles = [];
+        this.volumeNodes = [];
+        this.flippedNodes = [];
+        this.followers = [];
+        this.followPosition = new Vector3(0, 0, 0);
+    }
+    static Get(scene) {
+        if (scene == null)
+            return null;
+        return MeshWaterSurface.Registry.get(scene.uniqueId) ?? null;
+    }
+    awake() {
+        this.waterProperties = this.getProperties();
+        if (MeshWaterSurface.Registry.has(this.scene.uniqueId)) {
+            Tools.Warn("MeshWaterSurface: '" + this.transform.name + "' replaces the scene's first water surface");
+        }
+        MeshWaterSurface.Registry.set(this.scene.uniqueId, this);
+    }
+    ready() {
+        const properties = this.getProperties();
+        if (properties.underwater == null)
+            return;
+        for (const node of this.findNodes(properties.underwater.shownodes)) {
+            for (const component of SceneManager.GetComponents(node) ?? [])
+                ScriptComponent.AwakeInstance(component);
+        }
+    }
+    start() {
+        const underwater = this.waterProperties.underwater;
+        if (underwater == null)
+            return;
+        this.shownNodes = this.findNodes(underwater.shownodes);
+        this.shownParticles = this.findParticles(this.shownNodes);
+        this.volumeNodes = this.findNodes(underwater.volumenodes);
+        this.flippedNodes = this.findNodes(underwater.flipnodes).map((node) => this.prepareFlip(node));
+        this.followers = this.prepareFollowers(underwater.follownodes);
+        this.update();
+    }
+    update() {
+        if (this.waterProperties == null || this.waterProperties.underwater == null)
+            return;
+        const camera = this.scene.activeCamera;
+        if (camera == null)
+            return;
+        const isCameraUnder = this.isCameraUnderwater(camera);
+        if (isCameraUnder !== this.isUnderwater) {
+            this.isUnderwater = isCameraUnder;
+            if (isCameraUnder)
+                this.enterUnderwater();
+            else
+                this.leaveUnderwater();
+        }
+        if (!isCameraUnder)
+            return;
+        this.updateFog(this.waterProperties.underwater.sealevel - camera.globalPosition.y);
+        this.updateFollowers(camera);
+    }
+    destroy() {
+        if (this.isUnderwater)
+            this.leaveUnderwater();
+        this.isUnderwater = false;
+        if (MeshWaterSurface.Registry.get(this.scene.uniqueId) === this)
+            MeshWaterSurface.Registry.delete(this.scene.uniqueId);
+    }
+    getSeaLevel() {
+        return this.waterProperties.sealevel;
+    }
+    getSurfaceHeight() {
+        const properties = this.waterProperties;
+        const clockSeconds = ShaderGlobals.GetClock(this.scene).time;
+        return properties.sealevel + Math.sin(clockSeconds * properties.wavespeed) * properties.waveamplitude;
+    }
+    getCameraHeight(camera) {
+        if (camera == null)
+            return 0;
+        return camera.globalPosition.y - this.getSurfaceHeight();
+    }
+    isCameraUnderwater(camera) {
+        if (camera == null)
+            return false;
+        const underwater = this.waterProperties.underwater;
+        const crossingHeight = (underwater != null) ? underwater.sealevel : this.getSurfaceHeight();
+        return camera.globalPosition.y <= crossingHeight;
+    }
+    ProjectPointOnWaterSurface(searchParameters) {
+        if (searchParameters == null || searchParameters.targetPositionWS == null)
+            return null;
+        const target = searchParameters.targetPositionWS;
+        const targetX = Array.isArray(target) ? target[0] : target.x;
+        const targetZ = Array.isArray(target) ? target[2] : target.z;
+        const projectedPosition = new Vector3(targetX, this.getSurfaceHeight(), targetZ);
+        return {
+            projectedPositionWS: projectedPosition,
+            normalWS: Vector3.Up(),
+            candidateLocationWS: projectedPosition.clone(),
+            currentDirectionWS: Vector3.Zero(),
+            numIterations: 1,
+            error: 0
+        };
+    }
+    FindWaterSurfaceHeight(searchParameters) {
+        return this.ProjectPointOnWaterSurface(searchParameters);
+    }
+    findNodes(nodeIds) {
+        const nodes = [];
+        for (const nodeId of nodeIds ?? []) {
+            const node = SceneManager.GetTransformNodeByID(this.scene, nodeId);
+            if (node != null)
+                nodes.push(node);
+        }
+        return nodes;
+    }
+    findParticles(nodes) {
+        const particles = [];
+        for (const node of nodes) {
+            const system = SceneManager.GetComponent(node, MeshWaterSurface.PARTICLES_CLASS);
+            if (system != null)
+                particles.push(system);
+        }
+        return particles;
+    }
+    prepareFlip(node) {
+        if (node.isWorldMatrixFrozen)
+            node.unfreezeWorldMatrix();
+        if (node.rotationQuaternion == null)
+            node.rotationQuaternion = Quaternion.FromEulerVector(node.rotation);
+        const surfaceRotation = node.rotationQuaternion.clone();
+        const flipRotation = Quaternion.FromEulerAngles(Math.PI, 0, 0);
+        return { node: node, surfaceRotation: surfaceRotation, underwaterRotation: flipRotation.multiply(surfaceRotation) };
+    }
+    prepareFollowers(follownodes) {
+        const followers = [];
+        for (const follower of follownodes ?? []) {
+            const node = SceneManager.GetTransformNodeByID(this.scene, follower.node);
+            if (node == null)
+                continue;
+            if (follower.scale != null)
+                node.scaling.set(follower.scale[0], follower.scale[1], follower.scale[2]);
+            followers.push({ node: node, offset: Vector3.FromArray(follower.offset) });
+        }
+        return followers;
+    }
+    enterUnderwater() {
+        const underwater = this.waterProperties.underwater;
+        if (underwater.fogcolors.length > 0)
+            this.writeUnderwaterFog(underwater);
+        for (const node of this.shownNodes)
+            node.setEnabled(true);
+        for (const particles of this.shownParticles)
+            particles.play();
+        this.setVolumesEnabled(true);
+        for (const flipped of this.flippedNodes)
+            flipped.node.rotationQuaternion.copyFrom(flipped.underwaterRotation);
+    }
+    leaveUnderwater() {
+        if (this.waterProperties.underwater.fogcolors.length > 0)
+            this.restoreSurfaceFog();
+        for (const particles of this.shownParticles)
+            particles.stop(true, MeshWaterSurface.STOP_AND_CLEAR);
+        for (const node of this.shownNodes)
+            node.setEnabled(false);
+        this.setVolumesEnabled(false);
+        for (const flipped of this.flippedNodes)
+            flipped.node.rotationQuaternion.copyFrom(flipped.surfaceRotation);
+    }
+    writeUnderwaterFog(underwater) {
+        const scene = this.scene;
+        this.surfaceFogColor.copyFrom(scene.fogColor);
+        this.surfaceFogDensity = scene.fogDensity;
+        this.surfaceFogStart = scene.fogStart;
+        this.surfaceFogEnd = scene.fogEnd;
+        const isExponentialSquared = scene.fogMode === Scene.FOGMODE_EXP2;
+        const densityScale = isExponentialSquared ? SceneManager.FogExp2DensityScale : SceneManager.FogExpDensityScale;
+        scene.fogDensity = underwater.fogdensity * densityScale;
+        scene.fogStart = underwater.fogstart;
+        scene.fogEnd = underwater.fogend * MeshWaterSurface.LINEAR_FOG_END_SCALE;
+    }
+    restoreSurfaceFog() {
+        const scene = this.scene;
+        scene.fogColor.copyFrom(this.surfaceFogColor);
+        scene.fogDensity = this.surfaceFogDensity;
+        scene.fogStart = this.surfaceFogStart;
+        scene.fogEnd = this.surfaceFogEnd;
+    }
+    setVolumesEnabled(enabled) {
+        for (const node of this.volumeNodes) {
+            node.setEnabled(enabled);
+            const volume = SceneManager.GetComponent(node, MeshWaterSurface.POST_PROCESSOR_CLASS);
+            if (volume != null)
+                volume.SetVolumeEnabled(enabled);
+        }
+    }
+    updateFog(depthMeters) {
+        const underwater = this.waterProperties.underwater;
+        if (underwater.fogcolors.length === 0)
+            return;
+        const depthFraction = Scalar.Clamp(depthMeters / underwater.fogdepth, 0, 1);
+        const keyPosition = depthFraction * (underwater.fogcolors.length - 1);
+        const lowerKey = Math.floor(keyPosition);
+        const upperKey = Math.min(lowerKey + 1, underwater.fogcolors.length - 1);
+        const keyBlend = keyPosition - lowerKey;
+        for (let channel = 0; channel < 3; channel++) {
+            const gradientValue = Scalar.Lerp(underwater.fogcolors[lowerKey][channel], underwater.fogcolors[upperKey][channel], keyBlend);
+            const litValue = gradientValue * underwater.suncolor[channel];
+            const addedValue = underwater.fogcolormultiplier[channel];
+            this.fogColorChannels[channel] = (addedValue >= 0) ? Scalar.Clamp(litValue + addedValue, 0, 1) : litValue;
+        }
+        this.scene.fogColor.set(this.fogColorChannels[0], this.fogColorChannels[1], this.fogColorChannels[2]);
+    }
+    updateFollowers(camera) {
+        for (const follower of this.followers) {
+            camera.globalPosition.addToRef(follower.offset, this.followPosition);
+            follower.node.setAbsolutePosition(this.followPosition);
+        }
+    }
+}
+MeshWaterSurface.POST_PROCESSOR_CLASS = "TOOLKIT.PostProcessor";
+MeshWaterSurface.PARTICLES_CLASS = "TOOLKIT.ShurikenParticles";
+MeshWaterSurface.STOP_AND_CLEAR = 1;
+MeshWaterSurface.LINEAR_FOG_END_SCALE = 2;
+MeshWaterSurface.Registry = new Map();
 export class NavigationAgent extends ScriptComponent {
     isReady() { return this.m_agentReady; }
     isNavigating() { return (this.m_navStatus === NavMoveStatus.Moving); }
@@ -108703,6 +109280,7 @@ export class PostProcessor extends ScriptComponent {
         const props = this.getProperties();
         this.cameraOwner = PostProcessingContract.isCameraOwner(props);
         this.volumeProperties = this.cameraOwner ? null : PostProcessingContract.parseVolume(props);
+        this.volumeEnabled = !this.isSwitchedVolume();
         this.volumeLayer = SceneManager.GetTransformLayer(this.transform);
         PostProcessor.Registry.push(this);
         if (PostProcessor.GlobalInstance == null)
@@ -108939,7 +109517,8 @@ export class PostProcessor extends ScriptComponent {
             PostProcessor.warnOnce("cameras:" + selection.mode, selection.warning);
         const hasLocal = entries.some(e => e.properties.isglobal === false && e.properties.bounds != null);
         const hasCinemachine = volumes.some((volume) => volume.isCinemachineVolume());
-        const liveBlend = hasLocal || hasCinemachine;
+        const hasSwitched = volumes.some((volume) => volume.isSwitchedVolume());
+        const liveBlend = hasLocal || hasCinemachine || hasSwitched;
         const localLuts = liveBlend ? entries.map((e) => {
             const lut = PostProcessingContract.normalise(e.properties).lut;
             return (lut != null && lut.identity !== true && typeof lut.url === "string" && lut.url !== "") ? lut : null;
@@ -109034,6 +109613,9 @@ export class PostProcessor extends ScriptComponent {
     isCinemachineVolume() {
         return this.volumeProperties != null && this.volumeProperties.role === PostProcessingContract.CINEMACHINE_VOLUME_ROLE;
     }
+    isSwitchedVolume() {
+        return this.volumeProperties != null && this.volumeProperties.role === PostProcessingContract.SWITCHED_VOLUME_ROLE;
+    }
     IsVolumeEnabled() {
         if (this.volumeEnabled === false)
             return false;
@@ -109648,7 +110230,7 @@ export class PostProcessor extends ScriptComponent {
     applyHdrpFog(camera, textureType) {
         if (camera == null || this.scene == null || HdrpRendering == null || HdrpFogPass == null)
             return;
-        if (HdrpRendering.IsParity(this.scene) !== true)
+        if (HdrpRendering.IsParity(this.scene) !== true && PhysicalSkyBlock.UrpBlock(HdrpRendering.SceneMetadata(this.scene)) == null)
             return;
         const fog = HdrpFogPass.FogBlock(this.scene);
         if (!HdrpFogMath.PassNeeded(fog, HdrpFogPass.SkyOf(this.scene)))
@@ -115080,6 +115662,7 @@ export class PostProcessingContract {
 }
 PostProcessingContract.VOLUME_TYPES = ["BuiltIn", "URP", "HDRP"];
 PostProcessingContract.CINEMACHINE_VOLUME_ROLE = "cinemachine";
+PostProcessingContract.SWITCHED_VOLUME_ROLE = "switched";
 PostProcessingContract.GRADING_MODES = ["LowDefinitionRange", "HighDefinitionRange", "External"];
 PostProcessingContract.RENDERING_PATH_DEFERRED = "DeferredShading";
 PostProcessingContract.RENDERING_PATH_FORWARD = "Forward";
@@ -130843,6 +131426,20 @@ export class RigidbodyPhysics extends ScriptComponent {
         RigidbodyPhysics.ConfigRigidbodyPhysics(scene, entity, false, false, physics, mass, centerOfMass);
         return body;
     }
+    static MarkCompoundChildForDisposal(entity) {
+        if (RigidbodyPhysics.RendersItself(entity) === false) {
+            Utilities.AddLoaderItemMarkedForDisposal(entity);
+            return;
+        }
+        const colliderMesh = SceneManager.FindChildTransformNode(entity, (entity.name + ".Collider"), SearchType.ExactMatch, true);
+        if (colliderMesh != null)
+            Utilities.AddLoaderItemMarkedForDisposal(colliderMesh);
+    }
+    static RendersItself(node) {
+        if (!(node instanceof AbstractMesh) || node.getTotalVertices() <= 0 || node.name.endsWith(".Collider"))
+            return false;
+        return node.metadata != null && node.metadata.toolkit != null && node.metadata.toolkit.renderer != null;
+    }
     static CreateCompoundPhysicsShapeAndBody(scene, root, entity, element, impostortype, staticfriction, dynamicfriction, restitution, fcombine, rcombine, sitems, item, center, complex, trigger, persist, layer, filter) {
         let center_xx = 0;
         let center_yy = 0;
@@ -130853,7 +131450,7 @@ export class RigidbodyPhysics extends ScriptComponent {
         const rootScale = RigidbodyPhysics.GetColliderScale(root);
         const entityScale = (entity === root) ? rootScale : RigidbodyPhysics.RoundColliderScale(entity.scaling);
         if (persist === false && complex === true)
-            Utilities.AddLoaderItemMarkedForDisposal(entity);
+            RigidbodyPhysics.MarkCompoundChildForDisposal(entity);
         if (impostortype == RigidbodyPhysics.ConvexHullImpostor) {
             let convexHullMesh = SceneManager.FindChildTransformNode(entity, (entity.name + ".Collider"), SearchType.ExactMatch, true);
             if (convexHullMesh != null) {
@@ -133691,7 +134288,7 @@ export class ShurikenParticles extends ScriptComponent {
     }
     canBeginWarmupDraw() {
         const particleSystem = this._prtSystem;
-        if (particleSystem == null || particleSystem.isDisposed || this._prtState == null || this._prtProps == null || this._prtProps.enabled === false)
+        if (particleSystem == null || particleSystem.isDisposed || this._prtState == null || this._prtProps == null)
             return false;
         if (this._prtWarming || this._prtPrewarmJob != null)
             return false;
@@ -141523,6 +142120,7 @@ export class TerrainBuilder extends ScriptComponent {
             if (heights == null)
                 throw new Error("heights block has no data");
             hf = new TerrainHeightfield(props, heights);
+            hf.setEdgeNeighbors(this.resolveEdgeNeighbors());
             this._heightfield = hf;
         }
         catch (e) {
@@ -141715,6 +142313,45 @@ export class TerrainBuilder extends ScriptComponent {
         this._isBuilt = true;
         this.onBuiltObservable.notifyObservers(this);
     }
+    resolveEdgeNeighbors() {
+        const contract = this._contract;
+        const tiles = TerrainBuilder.GetTerrains(this.scene);
+        const ids = contract.neighbors;
+        const hasIds = ids != null && (ids.left != null || ids.right != null || ids.top != null || ids.bottom != null);
+        const neighbors = {
+            left: this.edgeNeighborFor(tiles, hasIds ? ids.left : null, hasIds, -1, 0),
+            right: this.edgeNeighborFor(tiles, hasIds ? ids.right : null, hasIds, 1, 0),
+            top: this.edgeNeighborFor(tiles, hasIds ? ids.top : null, hasIds, 0, 1),
+            bottom: this.edgeNeighborFor(tiles, hasIds ? ids.bottom : null, hasIds, 0, -1),
+        };
+        const anyNeighbor = neighbors.left != null || neighbors.right != null || neighbors.top != null || neighbors.bottom != null;
+        return anyNeighbor ? neighbors : null;
+    }
+    edgeNeighborFor(tiles, neighborId, useIds, offsetX, offsetZ) {
+        for (const other of tiles) {
+            if (other === this || !this.canShareEdgeWith(other))
+                continue;
+            const isNeighbor = useIds ? other.transform.id === neighborId : this.isAdjacentTile(other, offsetX, offsetZ);
+            if (!isNeighbor)
+                continue;
+            const heights = TerrainContract.GetBlock(other.contract, "heights", "u16");
+            return (heights != null) ? { heights: heights, heightScale: other.contract.size[1] } : null;
+        }
+        return null;
+    }
+    canShareEdgeWith(other) {
+        const contract = this._contract, otherContract = other.contract;
+        return otherContract.heightresolution === contract.heightresolution && otherContract.size[0] === contract.size[0] && otherContract.size[2] === contract.size[2];
+    }
+    isAdjacentTile(other, offsetX, offsetZ) {
+        const contract = this._contract, otherContract = other.contract;
+        if (contract.allowautoconnect !== true || otherContract.allowautoconnect !== true || otherContract.groupingid !== contract.groupingid)
+            return false;
+        this.transform.computeWorldMatrix(true);
+        const offset = this.worldToUnityUV(other.transform.getAbsolutePosition());
+        const toleranceU = TERRAIN_EDGE_TOLERANCE_METERS / contract.size[0], toleranceV = TERRAIN_EDGE_TOLERANCE_METERS / contract.size[2];
+        return Math.abs(offset[0] - offsetX) <= toleranceU && Math.abs(offset[1] - offsetZ) <= toleranceV;
+    }
     applyTreesAndFoliageVisibility() {
         if (this._trees != null)
             this._trees.setVisible(this._drawTreesAndFoliage);
@@ -142299,12 +142936,21 @@ export class TerrainBuilder extends ScriptComponent {
     worldToUnityUV(worldPosition) {
         if (this._contract == null || worldPosition == null)
             return null;
-        const inv = Matrix.Invert(this.transform.getWorldMatrix());
-        const local = Vector3.TransformCoordinates(worldPosition, inv);
+        this.transform.getWorldMatrix().invertToRef(TerrainBuilder.ScratchInverse);
+        const local = TerrainBuilder.ScratchLocal;
+        Vector3.TransformCoordinatesToRef(worldPosition, TerrainBuilder.ScratchInverse, local);
         const size = this._contract.size;
         const ux = TerrainMath.UnityToLocalX(local.x, this._contract.handedness);
         return [ux / size[0], local.z / size[2]];
     }
+    containsWorldPosition(worldPosition, tolerance) {
+        const uv = this.worldToUnityUV(worldPosition);
+        if (uv == null)
+            return false;
+        const size = this._contract.size;
+        const slackU = tolerance / size[0], slackV = tolerance / size[2];
+        return uv[0] >= -slackU && uv[0] <= 1 + slackU && uv[1] >= -slackV && uv[1] <= 1 + slackV;
+    }
     SampleHeight(worldPosition) {
         if (this._heightfield == null)
             return 0;
@@ -142373,6 +143019,10 @@ export class TerrainBuilder extends ScriptComponent {
             if (list[i]._heightfield != null && list[i].WorldToTerrainUV(worldPosition) != null)
                 return list[i];
         }
+        for (let i = list.length - 1; i >= 0; i--) {
+            if (list[i]._heightfield != null && list[i].containsWorldPosition(worldPosition, TERRAIN_EDGE_TOLERANCE_METERS))
+                return list[i];
+        }
         return null;
     }
     static GetWorldHeightAt(scene, worldPosition) {
@@ -142390,6 +143040,8 @@ export class TerrainBuilder extends ScriptComponent {
     }
 }
 TerrainBuilder._registry = new Map();
+TerrainBuilder.ScratchInverse = new Matrix();
+TerrainBuilder.ScratchLocal = new Vector3();
 TerrainBuilder.OnLoadProgressObservable = new Observable();
 TerrainBuilder.PRELOAD_TIMEOUT_MS = 120000;
 TerrainBuilder.SETTLE_MS = 30000;
@@ -142810,7 +143462,7 @@ export class TerrainDetails {
         }
         const F = TerrainFoliagePlugin;
         const layer = rt.data;
-        const sway = layer.sway;
+        const sway = F.GraphOwnsMotion(source) ? null : layer.sway;
         const urp = ((this._owner.contract != null && this._owner.contract.flavour) || "urp") === "urp";
         const modes = F.MODE_FADE | ((sway != null) ? F.MODE_SWAY : 0) | ((layer.rendermode === "Grass") ? F.MODE_GRASSWAVE : 0) | (urp ? F.MODE_URPSPECULAR : 0);
         const swayKey = (sway != null) ? (sway.amount + "," + sway.speed + "," + sway.wavelength) : "-";
@@ -143087,19 +143739,12 @@ export class TerrainDetails {
         rt.mainMatrices = matrices;
         rt.mainColors = colors;
         rt.main.thinInstanceSetBuffer("matrix", matrices, 16, false);
-        TerrainDetails.ResizePreviousMatrices(rt.main, matrices);
+        TerrainTrees.ResizePreviousMatrices(rt.main, matrices);
         if (colors != null)
             rt.main.thinInstanceSetBuffer(TerrainDetails.TintBuffer(rt), colors, 4, false);
         if (ShaderGraphRuntime != null)
             ShaderGraphRuntime.EnsureThinInstanceBuffers(rt.main);
     }
-    static ResizePreviousMatrices(mesh, matrices) {
-        const storage = mesh._thinInstanceDataStorage;
-        if (storage == null || storage.previousMatrixBuffer == null || storage.previousMatrixData != null)
-            return;
-        storage.previousMatrixBuffer.dispose();
-        storage.previousMatrixBuffer = mesh._thinInstanceCreateMatrixBuffer("previousWorld", matrices, false);
-    }
     static TintBuffer(rt) { return (rt.grass != null) ? "tkGrassTint" : "color"; }
     chunkDistance(c, x, z, size) {
         const x0 = c.cx * this._cw, x1 = Math.min((c.cx + 1) * this._cw, size[0]);
@@ -143693,6 +144338,9 @@ export class TerrainFoliagePlugin extends MaterialPluginBase {
         const shader = m.getShaderName();
         return shader != null && shader !== "UniversalShaderMaterial" && shader !== "CustomShaderMaterial";
     }
+    static GraphOwnsMotion(material) {
+        return TerrainFoliagePlugin.IsGraphMaterial(material) && material.__speedTreeWind == null;
+    }
     getClassName() {
         return "TerrainFoliagePlugin";
     }
@@ -144865,6 +145513,7 @@ export class TerrainHeightfield {
         this._errors = null;
         this._minH = null;
         this._maxH = null;
+        this.edgeNeighbors = null;
         this.R = contract.heightresolution;
         this.size = [contract.size[0], contract.size[1], contract.size[2]];
         this.handedness = (contract.handedness != null) ? contract.handedness : 1;
@@ -144893,9 +145542,12 @@ export class TerrainHeightfield {
         return this.heights[z * this.R + x] / 65535 * this.size[1];
     }
     normalAt(u, v, out) {
-        TerrainMath.SampleNormal(this.heights, this.R, this.size, u, v, out);
+        TerrainMath.SampleNormal(this.heights, this.R, this.size, u, v, out, this.edgeNeighbors);
         out[0] *= (this.handedness === 0 ? -1 : 1);
     }
+    setEdgeNeighbors(neighbors) {
+        this.edgeNeighbors = neighbors;
+    }
     setHoles(pixels, width) {
         const n = this.R - 1;
         const height = (width > 0) ? Math.floor(pixels.length / 4 / width) : 0;
@@ -145174,15 +145826,31 @@ export class TerrainMath {
         const b = h01 + (h11 - h01) * tx;
         return TerrainMath.DecodeHeight(a + (b - a) * tz, sizeY);
     }
-    static SampleNormal(h, R, size, u, v, out) {
+    static SampleNormal(h, R, size, u, v, out, neighbors = null) {
         const i = Math.round(TerrainMath.Clamp01(u) * (R - 1));
         const k = Math.round(TerrainMath.Clamp01(v) * (R - 1));
         const iL = Math.max(i - 1, 0), iR = Math.min(i + 1, R - 1);
         const kD = Math.max(k - 1, 0), kU = Math.min(k + 1, R - 1);
         const cellX = size[0] / (R - 1), cellZ = size[2] / (R - 1);
         const sy = size[1];
-        const dhdx = (iR > iL) ? (TerrainMath.DecodeHeight(h[k * R + iR], sy) - TerrainMath.DecodeHeight(h[k * R + iL], sy)) / ((iR - iL) * cellX) : 0;
-        const dhdz = (kU > kD) ? (TerrainMath.DecodeHeight(h[kU * R + i], sy) - TerrainMath.DecodeHeight(h[kD * R + i], sy)) / ((kU - kD) * cellZ) : 0;
+        let dhdx = (iR > iL) ? (TerrainMath.DecodeHeight(h[k * R + iR], sy) - TerrainMath.DecodeHeight(h[k * R + iL], sy)) / ((iR - iL) * cellX) : 0;
+        let dhdz = (kU > kD) ? (TerrainMath.DecodeHeight(h[kU * R + i], sy) - TerrainMath.DecodeHeight(h[kD * R + i], sy)) / ((kU - kD) * cellZ) : 0;
+        if (i === 0 && neighbors?.left != null) {
+            const outsideHeight = TerrainMath.DecodeHeight(neighbors.left.heights[k * R + (R - 2)], neighbors.left.heightScale);
+            dhdx = (TerrainMath.DecodeHeight(h[k * R + 1], sy) - outsideHeight) / (2 * cellX);
+        }
+        else if (i === R - 1 && neighbors?.right != null) {
+            const outsideHeight = TerrainMath.DecodeHeight(neighbors.right.heights[k * R + 1], neighbors.right.heightScale);
+            dhdx = (outsideHeight - TerrainMath.DecodeHeight(h[k * R + (R - 2)], sy)) / (2 * cellX);
+        }
+        if (k === 0 && neighbors?.bottom != null) {
+            const outsideHeight = TerrainMath.DecodeHeight(neighbors.bottom.heights[(R - 2) * R + i], neighbors.bottom.heightScale);
+            dhdz = (TerrainMath.DecodeHeight(h[1 * R + i], sy) - outsideHeight) / (2 * cellZ);
+        }
+        else if (k === R - 1 && neighbors?.top != null) {
+            const outsideHeight = TerrainMath.DecodeHeight(neighbors.top.heights[1 * R + i], neighbors.top.heightScale);
+            dhdz = (outsideHeight - TerrainMath.DecodeHeight(h[(R - 2) * R + i], sy)) / (2 * cellZ);
+        }
         const nx = -dhdx, ny = 1, nz = -dhdz;
         const len = Math.sqrt(nx * nx + ny * ny + nz * nz);
         out[0] = nx / len;
@@ -146441,6 +147109,7 @@ export class TerrainTrees {
         this._colliderShapes = [];
         this._distance = 2000;
         this._built = false;
+        this._warnedUniqueHost = false;
         this._n = 0;
         this._proto = null;
         this._local = null;
@@ -146533,13 +147202,21 @@ export class TerrainTrees {
         return casters;
     }
     getStats() {
-        let drawn = 0, visibleHosts = 0;
+        let drawn = 0, visibleHosts = 0, capacity = 0;
         for (let i = 0; i < this._hosts.length; i++) {
-            drawn += this._hosts[i].count;
-            if (this._hosts[i].count > 0)
+            const host = this._hosts[i];
+            drawn += host.count;
+            if (host.count > 0)
                 visibleHosts++;
+            capacity += host.matrices.length / 16;
+            for (let slotIndex = 0; slotIndex < host.slots.length; slotIndex++)
+                capacity += host.slots[slotIndex].matrices.length / 16;
         }
-        return { hosts: this._hosts.length, instances: this._n, drawn: drawn, visibleHosts: visibleHosts, colliders: this._colliderBody != null };
+        return { hosts: this._hosts.length, instances: this._n, drawn: drawn, visibleHosts: visibleHosts, colliders: this._colliderBody != null, capacity: capacity };
+    }
+    static PreparedHostCount(scene) {
+        const prepared = TerrainTrees.PreparedHosts.get(scene.uniqueId);
+        return (prepared != null) ? prepared.size : 0;
     }
     build() {
         const owner = this._owner;
@@ -146597,43 +147274,44 @@ export class TerrainTrees {
         this._built = true;
         this._dirty = true;
     }
-    buildPrototype(p, tpl, cap) {
-        const lods = Array.isArray(p.lods) ? p.lods : [];
-        const runtime = { data: p, heights: lods.map((l) => (l != null && l.height != null) ? l.height : 0), lodHosts: [], fade: (p.fademode > 0 && p.animatecrossfade === true) };
-        const tplWorldInv = Matrix.Invert(tpl.computeWorldMatrix(true));
-        let any = false;
-        for (let l = 0; l < lods.length; l++) {
-            const list = [];
-            runtime.lodHosts.push(list);
-            const renderers = (lods[l] != null && Array.isArray(lods[l].renderers)) ? lods[l].renderers : [];
-            for (let r = 0; r < renderers.length; r++) {
-                const node = this._scene.getNodeById(renderers[r]);
+    buildPrototype(prototype, template, instanceCount) {
+        const prototypeLods = Array.isArray(prototype.lods) ? prototype.lods : [];
+        const runtime = { data: prototype, heights: prototypeLods.map((prototypeLod) => (prototypeLod != null && prototypeLod.height != null) ? prototypeLod.height : 0), lodHosts: [], fade: (prototype.fademode > 0 && prototype.animatecrossfade === true) };
+        const templateWorldInverse = Matrix.Invert(template.computeWorldMatrix(true));
+        const initialCapacity = Math.min(instanceCount, TREE_INITIAL_CAPACITY);
+        let hasHost = false;
+        for (let lodIndex = 0; lodIndex < prototypeLods.length; lodIndex++) {
+            const lodHostIndices = [];
+            runtime.lodHosts.push(lodHostIndices);
+            const renderers = (prototypeLods[lodIndex] != null && Array.isArray(prototypeLods[lodIndex].renderers)) ? prototypeLods[lodIndex].renderers : [];
+            for (let rendererIndex = 0; rendererIndex < renderers.length; rendererIndex++) {
+                const node = this._scene.getNodeById(renderers[rendererIndex]);
                 if (node == null)
                     continue;
                 let sources = [];
                 if (node instanceof AbstractMesh && TerrainTrees.HasGeometry(node))
                     sources = [node];
                 else
-                    sources = node.getChildMeshes(true).filter((m) => TerrainTrees.HasGeometry(m));
-                const flags = (lods[l] != null) ? lods[l].lightprobes : null;
-                const probeLit = TerrainTrees.RendererUsesProbes(flags, r) && TerrainProbePlugin != null;
-                for (let s = 0; s < sources.length; s++) {
-                    const matrices = new Float32Array(16 * cap), fades = new Float32Array(cap);
-                    const cast = !(lods[l] != null && lods[l].billboard === true) && TerrainTrees.RendererCastsShadows(sources[s], node);
-                    const host = this.createHost(p, l, sources[s], tplWorldInv, matrices, fades);
+                    sources = node.getChildMeshes(true).filter((mesh) => TerrainTrees.HasGeometry(mesh));
+                const flags = (prototypeLods[lodIndex] != null) ? prototypeLods[lodIndex].lightprobes : null;
+                const probeLit = TerrainTrees.RendererUsesProbes(flags, rendererIndex) && TerrainProbePlugin != null;
+                for (let sourceIndex = 0; sourceIndex < sources.length; sourceIndex++) {
+                    const matrices = new Float32Array(16 * initialCapacity), fades = new Float32Array(initialCapacity);
+                    const cast = !(prototypeLods[lodIndex] != null && prototypeLods[lodIndex].billboard === true) && TerrainTrees.RendererCastsShadows(sources[sourceIndex], node);
+                    const host = this.createHost(prototype, lodIndex, sources[sourceIndex], templateWorldInverse, matrices, fades);
                     if (host == null)
                         continue;
                     if (probeLit)
                         this._probeHosts++;
-                    list.push(this._hosts.length);
-                    this._hosts.push({ mesh: host, matrices: matrices, fades: fades, count: 0, lastCount: -1, cast: cast, box: new Float32Array(6), boxMin: new Vector3(), boxMax: new Vector3(), probes: null, probeBuffer: null, probeLit: probeLit, slots: [] });
+                    lodHostIndices.push(this._hosts.length);
+                    this._hosts.push({ mesh: host, matrices: matrices, fades: fades, count: 0, lastCount: -1, cast: cast, box: new Float32Array(6), boxMin: new Vector3(), boxMax: new Vector3(), probes: null, probeBuffer: null, probeLit: probeLit, slots: [], capacityCeiling: instanceCount, grown: false });
                     if (cast)
-                        this.createCasterSlots(this._hosts[this._hosts.length - 1], cap);
-                    any = true;
+                        this.createCasterSlots(this._hosts[this._hosts.length - 1], initialCapacity);
+                    hasHost = true;
                 }
             }
         }
-        return any ? runtime : null;
+        return hasHost ? runtime : null;
     }
     static RendererUsesProbes(flags, index) {
         if (!Array.isArray(flags) || index < 0 || index >= flags.length)
@@ -146641,20 +147319,32 @@ export class TerrainTrees {
         return flags[index] !== false;
     }
     static AttachProbeBuffer(host, probes) {
-        const P = TerrainProbePlugin;
-        for (let o = 0; o < probes.length; o += P.STRIDE)
-            probes[o] = -1;
-        const buffer = new Buffer(host.getEngine(), probes, true, P.STRIDE, false, true);
-        for (let k = 0; k < 3; k++)
-            host.setVerticesBuffer(buffer.createVertexBuffer(P.ATTRIBUTES[k], 4 * k, 4, P.STRIDE, true));
-        host.onDisposeObservable.addOnce(() => { buffer.dispose(); });
+        const probePlugin = TerrainProbePlugin;
+        for (let recordOffset = 0; recordOffset < probes.length; recordOffset += probePlugin.STRIDE)
+            probes[recordOffset] = -1;
+        const buffer = TerrainTrees.CreateProbeBuffer(host, probes);
+        TerrainTrees.ProbeBuffers.set(host, buffer);
+        host.onDisposeObservable.addOnce(() => { TerrainTrees.ProbeBuffers.get(host).dispose(); });
         const material = host.material;
-        const subs = (material != null && material.subMaterials != null) ? material.subMaterials : [material];
-        for (let i = 0; i < subs.length; i++)
-            if (subs[i] != null)
-                P.Attach(subs[i]);
+        const subMaterials = (material != null && material.subMaterials != null) ? material.subMaterials : [material];
+        for (let i = 0; i < subMaterials.length; i++)
+            if (subMaterials[i] != null)
+                probePlugin.Attach(subMaterials[i]);
         return buffer;
     }
+    static CreateProbeBuffer(host, probes) {
+        const probePlugin = TerrainProbePlugin;
+        const buffer = new Buffer(host.getEngine(), probes, true, probePlugin.STRIDE, false, true);
+        for (let viewIndex = 0; viewIndex < 3; viewIndex++)
+            host.setVerticesBuffer(buffer.createVertexBuffer(probePlugin.ATTRIBUTES[viewIndex], 4 * viewIndex, 4, probePlugin.STRIDE, true));
+        return buffer;
+    }
+    static ResizeProbeBuffer(host) {
+        const buffer = TerrainTrees.CreateProbeBuffer(host.mesh, host.probes);
+        host.probeBuffer.dispose();
+        host.probeBuffer = buffer;
+        TerrainTrees.ProbeBuffers.set(host.mesh, buffer);
+    }
     sampleProbes(network) {
         if (network == null || typeof network.sampleInto !== "function" || !TerrainTrees.NetworkLightsProbes(network))
             return false;
@@ -146810,31 +147500,85 @@ export class TerrainTrees {
             throw error;
         }
     }
-    createHost(p, lod, src, tplWorldInv, matrices, fades) {
-        const geo = (src instanceof InstancedMesh) ? src.sourceMesh : src;
-        const host = geo.clone(p.name + ".L" + lod + "." + src.name, null, true);
-        if (host == null)
+    static BakeHostGeometry(source, templateWorldInverse, name) {
+        const geometrySource = (source instanceof InstancedMesh) ? source.sourceMesh : source;
+        const mesh = geometrySource.clone(name, null, true);
+        if (mesh == null)
+            return null;
+        mesh.metadata = null;
+        mesh.makeGeometryUnique();
+        const rendererToTemplate = source.computeWorldMatrix(true).multiply(templateWorldInverse);
+        mesh.position.setAll(0);
+        mesh.rotationQuaternion = null;
+        mesh.rotation.setAll(0);
+        mesh.scaling.setAll(1);
+        mesh.bakeTransformIntoVertices(rendererToTemplate);
+        TerrainTrees.InterleaveVertexData(mesh);
+        return mesh;
+    }
+    prepareHostGeometry(prototype, lod, source, templateWorldInverse) {
+        const scene = this._scene;
+        const sceneKey = scene.uniqueId;
+        let prepared = TerrainTrees.PreparedHosts.get(sceneKey);
+        if (prepared == null) {
+            const hosts = new Map();
+            prepared = hosts;
+            TerrainTrees.PreparedHosts.set(sceneKey, hosts);
+            scene.onDisposeObservable.addOnce(() => {
+                TerrainTrees.PreparedHosts.delete(sceneKey);
+                hosts.forEach((mesh) => { mesh.dispose(false, false); });
+            });
+        }
+        const key = prototype.templateid + "|" + lod + "|" + source.uniqueId;
+        const existing = prepared.get(key);
+        if (existing != null)
+            return existing;
+        const mesh = TerrainTrees.BakeHostGeometry(source, templateWorldInverse, prototype.name + ".L" + lod + "." + source.name + ".Prepared");
+        if (mesh == null)
             return null;
-        host.metadata = null;
-        host.makeGeometryUnique();
-        const rel = src.computeWorldMatrix(true).multiply(tplWorldInv);
-        host.position.setAll(0);
-        host.rotationQuaternion = null;
-        host.rotation.setAll(0);
-        host.scaling.setAll(1);
-        host.bakeTransformIntoVertices(rel);
+        mesh.setEnabled(false);
+        mesh.isVisible = false;
+        mesh.isPickable = false;
+        prepared.set(key, mesh);
+        return mesh;
+    }
+    createUniqueHost(source, templateWorldInverse, name, reason) {
+        if (!this._warnedUniqueHost) {
+            this._warnedUniqueHost = true;
+            Tools.Warn("[TerrainBuilder] " + this._owner.transform.name + ": tree hosts cannot share gpu buffers, copying geometry per tile — " + reason);
+        }
+        const host = TerrainTrees.BakeHostGeometry(source, templateWorldInverse, name);
+        if (host != null)
+            host.setEnabled(true);
+        return host;
+    }
+    createHost(prototype, lod, source, templateWorldInverse, matrices, fades) {
+        const prepared = this.prepareHostGeometry(prototype, lod, source, templateWorldInverse);
+        if (prepared == null)
+            return null;
+        const name = prototype.name + ".L" + lod + "." + source.name;
+        let host = null;
+        try {
+            host = TerrainTrees.CreateSharedHost(this._scene, prepared, name);
+            for (const key of TerrainTrees.HOST_DRAW_STATE)
+                host[key] = prepared[key];
+        }
+        catch (error) {
+            host = this.createUniqueHost(source, templateWorldInverse, name, String(error));
+            if (host == null)
+                return null;
+        }
+        const sourceMaterial = prepared.material;
         host.parent = this._root;
-        host.setEnabled(true);
         host.isVisible = false;
         host.isPickable = false;
         host.receiveShadows = true;
         host.alwaysSelectAsActiveMesh = true;
         host.doNotSyncBoundingInfo = true;
-        TerrainTrees.InterleaveVertexData(host);
         host.thinInstanceSetBuffer("matrix", matrices, 16, false);
         host.thinInstanceSetBuffer("tkLodFade", fades, 1, false);
         host.thinInstanceCount = 0;
-        host.material = this.hostMaterial(p, lod, geo.material, TerrainTrees.HasSpeedTreeWindVertexData(host));
+        host.material = this.hostMaterial(prototype, lod, sourceMaterial, TerrainTrees.HasSpeedTreeWindVertexData(prepared));
         if (ShaderGraphRuntime != null)
             ShaderGraphRuntime.EnsureThinInstanceBuffers(host);
         return host;
@@ -146862,7 +147606,7 @@ export class TerrainTrees {
                     ShaderGraphRuntime.EnsureThinInstanceBuffers(mesh);
                 if (TerrainBuilder != null)
                     TerrainBuilder.SetCasterSlot(mesh, slotIndex);
-                slots.push({ mesh: mesh, matrices: matrices, fades: fades, probes: null, count: 0, lastCount: -1, box: new Float32Array(6), boxMin: new Vector3(), boxMax: new Vector3() });
+                slots.push({ mesh: mesh, matrices: matrices, fades: fades, probes: null, count: 0, lastCount: -1, box: new Float32Array(6), boxMin: new Vector3(), boxMax: new Vector3(), capacityCeiling: host.capacityCeiling, grown: false });
             }
             host.slots = slots;
         }
@@ -146903,7 +147647,8 @@ export class TerrainTrees {
         const hue = (info != null && Array.isArray(info.hue) && info.hue.length >= 4) ? info.hue : null;
         const F = TerrainFoliagePlugin;
         const urp = (this._owner.contract != null && (this._owner.contract.flavour || "urp") === "urp");
-        const bend = ownWind ? 0 : F.MODE_TREE;
+        const graphMoves = p.speedtree !== true && F.GraphOwnsMotion(source);
+        const bend = (ownWind || graphMoves) ? 0 : F.MODE_TREE;
         const plugin = F.Attach(entry.material, bend | F.MODE_CROSSFADE | (billboard ? F.MODE_BILLBOARD : 0) | (hue != null ? F.MODE_HUE : 0) | (urp ? F.MODE_URPSPECULAR : 0));
         if (plugin != null) {
             plugin.params.bendFactor = (p.bendfactor != null) ? p.bendfactor : 0;
@@ -147608,7 +148353,7 @@ export class TerrainTrees {
     }
     appendInstance(target, instanceIndex, fade) {
         const count = target.count;
-        if (16 * (count + 1) > target.matrices.length)
+        if (16 * (count + 1) > target.matrices.length && !TerrainTrees.GrowTarget(target, target.capacityCeiling))
             return;
         const sourceOffset = 16 * instanceIndex;
         const targetOffset = 16 * count;
@@ -147646,6 +148391,26 @@ export class TerrainTrees {
         if (z + radius > box[5])
             box[5] = z + radius;
     }
+    static GrowTarget(target, ceiling) {
+        const capacity = target.matrices.length / 16;
+        if (capacity >= ceiling)
+            return false;
+        const grownCapacity = Math.min(ceiling, Math.max(target.count + 1, Math.ceil(capacity * TREE_GROWTH_FACTOR)));
+        const matrices = new Float32Array(16 * grownCapacity);
+        matrices.set(target.matrices.subarray(0, 16 * target.count));
+        target.matrices = matrices;
+        const fades = new Float32Array(grownCapacity);
+        fades.set(target.fades.subarray(0, target.count));
+        target.fades = fades;
+        if (target.probes != null) {
+            const stride = TerrainProbePlugin.STRIDE;
+            const probes = new Float32Array(stride * grownCapacity);
+            probes.set(target.probes.subarray(0, stride * target.count));
+            target.probes = probes;
+        }
+        target.grown = true;
+        return true;
+    }
     static LodCasts(hosts, proto, lod) {
         if (lod < 0 || lod >= proto.lodHosts.length)
             return false;
@@ -147683,16 +148448,39 @@ export class TerrainTrees {
             }
         }
     }
+    static RebindGrownTarget(target) {
+        const mesh = target.mesh;
+        mesh.thinInstanceSetBuffer("matrix", target.matrices, 16, false);
+        TerrainTrees.ResizePreviousMatrices(mesh, target.matrices);
+        mesh.thinInstanceSetBuffer("tkLodFade", target.fades, 1, false);
+        if (target.probes != null)
+            TerrainTrees.ResizeProbeBuffer(target);
+        if (ShaderGraphRuntime != null)
+            ShaderGraphRuntime.EnsureThinInstanceBuffers(mesh);
+        target.grown = false;
+    }
+    static ResizePreviousMatrices(mesh, matrices) {
+        const storage = mesh._thinInstanceDataStorage;
+        if (storage == null || storage.previousMatrixBuffer == null || storage.previousMatrixData != null)
+            return;
+        storage.previousMatrixBuffer.dispose();
+        storage.previousMatrixBuffer = mesh._thinInstanceCreateMatrixBuffer("previousWorld", matrices, false);
+    }
     uploadTarget(target, probeBuffer, isSlot) {
         const mesh = target.mesh;
         if (target.count > 0) {
             if (isSlot && target.lastCount <= 0)
                 mesh.setEnabled(true);
+            const grown = target.grown;
+            if (grown)
+                TerrainTrees.RebindGrownTarget(target);
             mesh.thinInstanceCount = target.count;
-            mesh.thinInstancePartialBufferUpdate("matrix", target.count, 0);
-            mesh.thinInstancePartialBufferUpdate("tkLodFade", target.count, 0);
-            if (probeBuffer != null)
-                probeBuffer.updateDirectly(target.probes, 0, target.count);
+            if (!grown) {
+                mesh.thinInstancePartialBufferUpdate("matrix", target.count, 0);
+                mesh.thinInstancePartialBufferUpdate("tkLodFade", target.count, 0);
+                if (probeBuffer != null)
+                    probeBuffer.updateDirectly(target.probes, 0, target.count);
+            }
             target.boxMin.set(target.box[0], target.box[1], target.box[2]);
             target.boxMax.set(target.box[3], target.box[4], target.box[5]);
             mesh.getBoundingInfo().reConstruct(target.boxMin, target.boxMax, mesh.computeWorldMatrix(isSlot));
@@ -147816,6 +148604,9 @@ TerrainTrees.CASTER_SLOTS = 4;
 TerrainTrees.SLOT_MARGIN = 4;
 TerrainTrees.NO_PROBE_RECORD = -1;
 TerrainTrees.LIGHT_TURN_DOT = 0.99996192;
+TerrainTrees.HOST_DRAW_STATE = ["sideOrientation", "renderingGroupId", "layerMask", "alphaIndex", "hasVertexAlpha", "useVertexColors", "numBoneInfluencers", "skeleton"];
+TerrainTrees.PreparedHosts = new Map();
+TerrainTrees.ProbeBuffers = new WeakMap();
 TerrainTrees._materials = new Map();
 TerrainTrees.ProbeSampleHeight = 0;
 TerrainTrees.SUBSURFACE_FIELDS = ["isTranslucencyEnabled", "isScatteringEnabled", "translucencyIntensity", "legacyTranslucency", "useGltfStyleTextures",
@@ -166744,6 +167535,1531 @@ export class VisualEffectSpawner {
 }
 VisualEffectSpawner.COUNT_EPSILON = 1e-6;
 VisualEffectSpawner.MAX_PHASE_CHANGES_PER_STEP = 64;
+export class VolumetricCloudsMath {
+    static ShellInterval(rayOrigin, rayDirection, innerRadius, outerRadius, planetRadius) {
+        const radialDistance = Math.hypot(rayOrigin[0], rayOrigin[1], rayOrigin[2]);
+        if (radialDistance <= 0)
+            return null;
+        const cosChi = (rayOrigin[0] * rayDirection[0] + rayOrigin[1] * rayDirection[1] + rayOrigin[2] * rayDirection[2]) / radialDistance;
+        const inner = VolumetricCloudsMath.IntersectSphere(innerRadius, cosChi, radialDistance);
+        const outer = VolumetricCloudsMath.IntersectSphere(outerRadius, cosChi, radialDistance);
+        if (inner[0] < 0 && inner[1] >= 0) {
+            const radius = (typeof planetRadius === "number") ? planetRadius : innerRadius;
+            const sinHorizon = Math.min(1, radius / radialDistance);
+            const horizonCosine = -Math.sqrt(Math.max(0, 1 - sinHorizon * sinHorizon));
+            return (cosChi >= horizonCosine) ? [inner[1], outer[1]] : null;
+        }
+        if (outer[1] < 0)
+            return null;
+        return [Math.max(outer[0], 0), (inner[0] >= 0) ? inner[0] : outer[1]];
+    }
+    static StepSize(shellLength, steps, maximumStep) {
+        return Math.min(shellLength / Math.max(1, steps), maximumStep);
+    }
+    static MaximumStep(altitudeRange, authoredSteps, tierSteps) {
+        const stretch = (typeof authoredSteps === "number" && tierSteps > 0) ? Math.min(Math.max(1, authoredSteps / tierSteps), CLOUD_MAX_STEP_STRETCH) : 1;
+        return altitudeRange / CLOUD_MAX_STEP_DIVISOR * stretch;
+    }
+    static TierSettings(tier, authored) {
+        const block = authored || {};
+        const positiveOr = (value, fallback) => (typeof value === "number" && value > 0) ? value : fallback;
+        const caps = CLOUD_TIER_CAPS[Math.max(0, Math.min(VolumetricCloudsMath.LowestTier, Math.floor(tier)))];
+        return {
+            resolutionScale: Math.min(positiveOr(block.resolutionscale, CLOUD_DEFAULT_SETTINGS.resolutionScale), caps.resolutionScale),
+            primarySteps: Math.min(positiveOr(block.numprimarysteps, CLOUD_DEFAULT_SETTINGS.primarySteps), caps.primarySteps),
+            longRayMultiplier: Math.min(positiveOr(block.longraysamplemultiplier, CLOUD_DEFAULT_SETTINGS.longRayMultiplier), caps.longRayMultiplier),
+            lightSteps: Math.min(positiveOr(block.numlightsteps, CLOUD_DEFAULT_SETTINGS.lightSteps), caps.lightSteps)
+        };
+    }
+    static StartTier(maximumTextureSize, viewportCssWidth) {
+        if (maximumTextureSize < CLOUD_WEAK_GPU_TEXTURE_SIZE || viewportCssWidth < CLOUD_PHONE_WIDTH_CSS_PX)
+            return 1;
+        return 0;
+    }
+    static IsCameraCut(previousPosition, currentPosition) {
+        if (previousPosition == null)
+            return true;
+        const distance = Math.hypot(currentPosition[0] - previousPosition[0], currentPosition[1] - previousPosition[1], currentPosition[2] - previousPosition[2]);
+        return distance > CLOUD_CAMERA_CUT_METERS;
+    }
+    static PackCurves(density, erosion, ambientOcclusion) {
+        const texels = new Float32Array(CLOUD_CURVE_SAMPLES * 4);
+        const hasCurves = Array.isArray(density) && density.length >= CLOUD_CURVE_SAMPLES;
+        const clamp01 = (value) => Math.max(0, Math.min(1, (typeof value === "number") ? value : 0));
+        for (let i = 0; i < CLOUD_CURVE_SAMPLES; i++) {
+            const isEnd = (i === 0 || i === CLOUD_CURVE_SAMPLES - 1);
+            texels[i * 4] = !hasCurves ? 1 : (isEnd ? 0 : clamp01(density[i]));
+            texels[i * 4 + 1] = (!hasCurves || !Array.isArray(erosion)) ? 1 : clamp01(erosion[i]);
+            texels[i * 4 + 2] = (!hasCurves || !Array.isArray(ambientOcclusion)) ? 1 : clamp01(1 - ambientOcclusion[i]);
+            texels[i * 4 + 3] = 1;
+        }
+        return texels;
+    }
+    static IntersectSphere(sphereRadius, cosChi, radialDistance) {
+        const ratio = sphereRadius / radialDistance;
+        const discriminant = ratio * ratio - Math.max(0, Math.min(1, 1 - cosChi * cosChi));
+        if (discriminant < 0)
+            return [discriminant, discriminant];
+        const root = Math.sqrt(discriminant);
+        return [radialDistance * (-cosChi - root), radialDistance * (-cosChi + root)];
+    }
+}
+VolumetricCloudsMath.LowestTier = 2;
+export class VolumetricCloudsTier {
+    constructor(startTier) {
+        this.isSettled = false;
+        this.windowMilliseconds = 0;
+        this.windowFrames = 0;
+        this.meanBeforeStep = 0;
+        this.previousMean = 0;
+        this.tier = Math.max(0, Math.min(VolumetricCloudsMath.LowestTier, startTier));
+    }
+    addFrame(frameMilliseconds) {
+        this.windowMilliseconds += frameMilliseconds;
+        this.windowFrames++;
+        if (this.windowFrames < CLOUD_TIER_WINDOW_FRAMES)
+            return false;
+        const meanMilliseconds = this.windowMilliseconds / this.windowFrames;
+        this.windowMilliseconds = 0;
+        this.windowFrames = 0;
+        if (this.meanBeforeStep > 0) {
+            const savedEnough = meanMilliseconds <= this.meanBeforeStep * (1 - CLOUD_TIER_MINIMUM_SAVING);
+            this.meanBeforeStep = 0;
+            if (!savedEnough) {
+                this.tier--;
+                this.isSettled = true;
+                return true;
+            }
+        }
+        const previousMean = this.previousMean;
+        this.previousMean = meanMilliseconds;
+        const isSteady = previousMean > 0 && meanMilliseconds > previousMean * (1 - CLOUD_TIER_MINIMUM_SAVING);
+        if (this.isSettled || !isSteady || meanMilliseconds <= CLOUD_TIER_BUDGET_MS || this.tier >= VolumetricCloudsMath.LowestTier)
+            return false;
+        this.tier++;
+        this.meanBeforeStep = meanMilliseconds;
+        return true;
+    }
+}
+export class VolumetricClouds {
+    static TryCreate(scene, metadata, root) {
+        const block = PhysicalSkyBlock.UrpBlock(metadata);
+        const clouds = (block != null) ? block.clouds : null;
+        if (clouds == null || clouds.state === false || scene == null)
+            return null;
+        if (HdrpPhysicallyBasedSky == null || !HdrpPhysicallyBasedSky.IsSupported(scene.getEngine()))
+            return null;
+        const existing = VolumetricClouds.Get(scene);
+        if (existing != null)
+            return existing;
+        return new VolumetricClouds(scene, clouds, block.sky, (typeof root === "string") ? root : "");
+    }
+    static Get(scene) {
+        if (scene == null)
+            return null;
+        const clouds = scene._tkVolumetricClouds;
+        return (clouds != null && clouds.disposed !== true) ? clouds : null;
+    }
+    constructor(scene, block, sky, root) {
+        this.disposed = false;
+        this.tier = 0;
+        this.hasAerial = false;
+        this.placeholderAerial = null;
+        this.worleyTexture = null;
+        this.erosionTexture = null;
+        this.curveTexture = null;
+        this.placeholderDepth = null;
+        this.marchTarget = null;
+        this.renderer = null;
+        this.marchPass = null;
+        this.temporalPass = null;
+        this.historyTargets = [];
+        this.historyIndex = 0;
+        this.hasHistory = false;
+        this.compositeMesh = null;
+        this.compositeMaterial = null;
+        this.isReady = false;
+        this.isPending = false;
+        this.preExposure = 1;
+        this.preExposureBinding = null;
+        this.frameSeed = 0;
+        this.windOffset = [0, 0];
+        this.verticalShapeOffset = 0;
+        this.verticalErosionOffset = 0;
+        this.sceneDepth = null;
+        this.beforeRenderObserver = null;
+        this.afterRenderObserver = null;
+        this.tierTracker = null;
+        this.targetWidth = 1;
+        this.targetHeight = 1;
+        this.lastCamera = null;
+        this.sunLight = null;
+        this.ambientSource = null;
+        this.ambientCaptureCount = -1;
+        this.previousEye = [0, 0, 0];
+        this.currentEye = [0, 0, 0];
+        this.hasPreviousEye = false;
+        this.beforeTargetsObserver = null;
+        this.afterTargetsObserver = null;
+        this.disposeObserver = null;
+        this.mirror = Matrix.Identity();
+        this.inverseViewProjection = new Matrix();
+        this.previousViewProjection = new Matrix();
+        this.previousViewProjectionUnity = new Matrix();
+        this.sunDirection = new Vector3();
+        this.cameraForward = new Vector3();
+        this.ambientTop = new Color3();
+        this.ambientBottom = new Color3();
+        this.scene = scene;
+        this.block = block;
+        this.sky = sky;
+        this.root = root;
+        scene._tkVolumetricClouds = this;
+        const planet = (sky != null) ? sky.planet : null;
+        this.isLocal = (planet != null && typeof planet.renderingspace === "number") ? planet.renderingspace === 1 : block.localclouds === true;
+        const curvature = (typeof block.earthcurvature === "number") ? block.earthcurvature : 0;
+        this.planetRadius = (planet != null && typeof planet.radius === "number" && planet.radius > 0) ? planet.radius : Scalar.Lerp(1, CLOUD_MINIMUM_CURVATURE_SCALE, curvature) * CLOUD_EARTH_RADIUS_METERS;
+        this.planetCenter = (this.isLocal && planet != null && Array.isArray(planet.center)) ? Vector3.FromArray(planet.center) : new Vector3(0, -this.planetRadius, 0);
+        this.scatteringTint = VolumetricClouds.LinearScatteringTint(block.scatteringtint);
+        if (scene.useRightHandedSystem === true)
+            Matrix.ScalingToRef(-1, 1, 1, this.mirror);
+        this.localForward = new Vector3(0, 0, (scene.useRightHandedSystem === true) ? -1 : 1);
+        this.tier = VolumetricCloudsMath.StartTier(scene.getEngine().getCaps().maxTextureSize, VolumetricClouds.CanvasCssWidth(scene));
+        this.tierTracker = new VolumetricCloudsTier(this.tier);
+        this.settings = VolumetricCloudsMath.TierSettings(this.tier, block);
+        this.reportLoweredSettings();
+        this.isPending = true;
+        scene.addPendingData(this);
+        this.preExposureBinding = HdrpRendering.Bind(scene, 1, 1, (scaled) => { this.preExposure = scaled; });
+        this.disposeObserver = scene.onDisposeObservable.add(() => this.dispose());
+        this.createPasses();
+        this.loadNoise().then((loaded) => {
+            if (this.disposed)
+                return;
+            if (!loaded) {
+                this.releasePending();
+                return;
+            }
+            this.waitUntilReady();
+        });
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        const scene = this.scene;
+        this.releasePending();
+        if (this.beforeRenderObserver != null)
+            scene.onBeforeRenderObservable.remove(this.beforeRenderObserver);
+        if (this.afterRenderObserver != null)
+            scene.onAfterRenderObservable.remove(this.afterRenderObserver);
+        if (this.beforeTargetsObserver != null)
+            scene.onBeforeRenderTargetsRenderObservable.remove(this.beforeTargetsObserver);
+        if (this.afterTargetsObserver != null)
+            scene.onAfterRenderTargetsRenderObservable.remove(this.afterTargetsObserver);
+        if (this.disposeObserver != null)
+            scene.onDisposeObservable.remove(this.disposeObserver);
+        if (this.preExposureBinding != null)
+            HdrpRendering.Unbind(scene, this.preExposureBinding);
+        const disposables = [this.compositeMesh, this.compositeMaterial, this.marchPass, this.temporalPass, this.renderer, this.marchTarget, this.worleyTexture, this.erosionTexture, this.curveTexture, this.placeholderDepth, this.placeholderAerial].concat(this.historyTargets);
+        for (const disposable of disposables) {
+            try {
+                if (disposable != null)
+                    disposable.dispose();
+            }
+            catch (error) { }
+        }
+        const sceneWithClouds = scene;
+        if (sceneWithClouds._tkVolumetricClouds === this)
+            sceneWithClouds._tkVolumetricClouds = null;
+    }
+    createPasses() {
+        const scene = this.scene;
+        const engine = scene.getEngine();
+        const isWebGPU = engine.isWebGPU === true;
+        const language = isWebGPU ? ShaderLanguage.WGSL : ShaderLanguage.GLSL;
+        const defines = [];
+        if (this.isLocal)
+            defines.push("#define CLOUD_LOCAL");
+        if (this.block.microerosion === true && this.block.microerosionfactor > 0)
+            defines.push("#define CLOUD_MICRO_EROSION");
+        const liveSky = HdrpPhysicallyBasedSky.Get(scene);
+        this.hasAerial = liveSky != null && HdrpFogMath != null && HdrpFogMath.HasAerialPerspective(liveSky);
+        const marchUniforms = VolumetricCloudsShaders.MarchUniforms.slice();
+        const marchSamplers = VolumetricCloudsShaders.MarchSamplers.slice();
+        if (this.hasAerial) {
+            defines.push("#define CLOUD_AERIAL");
+            marchUniforms.push(VolumetricCloudsShaders.AerialCameraUniform, ...HdrpPbSkyShaders.AtmosphereUniforms);
+            marchSamplers.push(VolumetricCloudsShaders.AerialSampler);
+            this.placeholderAerial = new RawTexture2DArray(new Uint8Array(4), 1, 1, 1, Constants.TEXTUREFORMAT_RGBA, scene, false, false, Texture.NEAREST_SAMPLINGMODE, Constants.TEXTURETYPE_UNSIGNED_BYTE);
+            this.placeholderAerial.name = "Volumetric Clouds Aerial Placeholder";
+        }
+        VolumetricCloudsShaders.Register();
+        this.curveTexture = this.createCurveTexture();
+        this.placeholderDepth = new RawTexture(new Float32Array([0]), 1, 1, Constants.TEXTUREFORMAT_R, scene, false, false, Texture.NEAREST_SAMPLINGMODE, Constants.TEXTURETYPE_FLOAT);
+        this.placeholderDepth.name = "Volumetric Clouds Depth Placeholder";
+        const textureType = (engine.getCaps().textureHalfFloatRender === true) ? Constants.TEXTURETYPE_HALF_FLOAT : Constants.TEXTURETYPE_FLOAT;
+        this.updateTargetSize();
+        this.marchTarget = this.createCloudTarget("Volumetric Clouds Lighting", textureType);
+        this.historyTargets.push(this.createCloudTarget("Volumetric Clouds History A", textureType), this.createCloudTarget("Volumetric Clouds History B", textureType));
+        this.renderer = new EffectRenderer(engine);
+        this.marchPass = new EffectWrapper({
+            engine: engine, name: VolumetricCloudsShaders.MarchName, fragmentShader: VolumetricCloudsShaders.MarchName, useShaderStore: true,
+            uniformNames: marchUniforms, samplerNames: marchSamplers,
+            defines: defines.join("\n"), shaderLanguage: language
+        });
+        this.marchPass.onApplyObservable.add(() => this.bindMarch(this.marchPass.effect));
+        this.temporalPass = new EffectWrapper({
+            engine: engine, name: VolumetricCloudsShaders.TemporalName, fragmentShader: VolumetricCloudsShaders.TemporalName, useShaderStore: true,
+            uniformNames: VolumetricCloudsShaders.TemporalUniforms.slice(), samplerNames: VolumetricCloudsShaders.TemporalSamplers.slice(),
+            defines: defines.join("\n"), shaderLanguage: language
+        });
+        this.temporalPass.onApplyObservable.add(() => this.bindTemporal(this.temporalPass.effect));
+        this.createCompositeMesh(language);
+    }
+    createCloudTarget(name, textureType) {
+        const target = new RenderTargetTexture(name, { width: this.targetWidth, height: this.targetHeight }, this.scene, false, true, textureType, false, Texture.BILINEAR_SAMPLINGMODE, false, false, false, Constants.TEXTUREFORMAT_RGBA);
+        target.wrapU = Texture.CLAMP_ADDRESSMODE;
+        target.wrapV = Texture.CLAMP_ADDRESSMODE;
+        target.anisotropicFilteringLevel = 1;
+        return target;
+    }
+    createCurveTexture() {
+        const curves = this.block.curves || {};
+        const texels = VolumetricCloudsMath.PackCurves(curves.density, curves.erosion, curves.ambientocclusion);
+        const halfTexels = new Uint16Array(texels.length);
+        for (let i = 0; i < texels.length; i++)
+            halfTexels[i] = TextureTools.ToHalfFloat(texels[i]);
+        const texture = new RawTexture(halfTexels, CLOUD_CURVE_SAMPLES, 1, Constants.TEXTUREFORMAT_RGBA, this.scene, false, false, Texture.BILINEAR_SAMPLINGMODE, Constants.TEXTURETYPE_HALF_FLOAT);
+        texture.name = "Volumetric Clouds Curves";
+        texture.wrapU = Texture.WRAP_ADDRESSMODE;
+        texture.wrapV = Texture.CLAMP_ADDRESSMODE;
+        return texture;
+    }
+    createCompositeMesh(language) {
+        const scene = this.scene;
+        const mesh = new Mesh(VolumetricClouds.MeshName, scene);
+        const vertexData = new VertexData();
+        vertexData.positions = [-1, -1, 0, 1, -1, 0, 1, 1, 0, -1, 1, 0];
+        vertexData.indices = [0, 1, 2, 0, 2, 3];
+        vertexData.applyToMesh(mesh, false);
+        const material = new ShaderMaterial("Volumetric Clouds Composite", scene, { vertex: VolumetricCloudsShaders.CompositeName, fragment: VolumetricCloudsShaders.CompositeName }, { attributes: ["position"], uniforms: ["cloudDisplayEncoded"], samplers: ["cloudLighting"], needAlphaBlending: true, shaderLanguage: language });
+        material.alphaMode = Constants.ALPHA_PREMULTIPLIED;
+        material.disableDepthWrite = true;
+        material.depthFunction = Constants.ALWAYS;
+        material.backFaceCulling = false;
+        material.setTexture("cloudLighting", this.marchTarget);
+        material.setFloat("cloudDisplayEncoded", this.isDisplayEncoded() ? 1 : 0);
+        mesh.material = material;
+        mesh.renderingGroupId = Utilities.DefaultRenderGroup();
+        mesh.alphaIndex = CLOUD_ALPHA_INDEX;
+        mesh.alwaysSelectAsActiveMesh = true;
+        mesh.isPickable = false;
+        mesh.doNotSyncBoundingInfo = true;
+        mesh.applyFog = false;
+        mesh.setEnabled(false);
+        this.compositeMesh = mesh;
+        this.compositeMaterial = material;
+        this.beforeTargetsObserver = scene.onBeforeRenderTargetsRenderObservable.add(() => { mesh.isVisible = false; });
+        this.afterTargetsObserver = scene.onAfterRenderTargetsRenderObservable.add(() => { mesh.isVisible = true; });
+    }
+    async loadNoise() {
+        const noise = this.block.noise;
+        if (noise == null || noise.worley == null || noise.erosion == null) {
+            LightingConversions.WarnOnce("urp:clouds:nonoise", "Volumetric clouds: the export carries no cloud noise, so the clouds do not draw");
+            return false;
+        }
+        try {
+            const buffers = await Promise.all([
+                Tools.LoadFileAsync(this.root + noise.worley.url, true),
+                Tools.LoadFileAsync(this.root + noise.erosion.url, true)
+            ]);
+            if (this.disposed)
+                return false;
+            this.worleyTexture = this.createNoiseTexture("Volumetric Clouds Worley Noise", buffers[0], noise.worley.size);
+            this.erosionTexture = this.createNoiseTexture("Volumetric Clouds Erosion Noise", buffers[1], noise.erosion.size);
+            return this.worleyTexture != null && this.erosionTexture != null;
+        }
+        catch (error) {
+            LightingConversions.WarnOnce("urp:clouds:noiseload", "Volumetric clouds: a cloud noise file failed to load, so the clouds do not draw (" + error + ")");
+            return false;
+        }
+    }
+    createNoiseTexture(name, buffer, size) {
+        if (buffer == null || buffer.byteLength !== size * size * size) {
+            LightingConversions.WarnOnce("urp:clouds:noisesize", "Volumetric clouds: " + name + " is not " + size + "³ bytes, so the clouds do not draw");
+            return null;
+        }
+        const texture = new RawTexture3D(new Uint8Array(buffer), size, size, size, Constants.TEXTUREFORMAT_R, this.scene, true, false, Texture.TRILINEAR_SAMPLINGMODE, Constants.TEXTURETYPE_UNSIGNED_BYTE);
+        texture.name = name;
+        texture.wrapU = Texture.WRAP_ADDRESSMODE;
+        texture.wrapV = Texture.WRAP_ADDRESSMODE;
+        texture.wrapR = Texture.WRAP_ADDRESSMODE;
+        return texture;
+    }
+    waitUntilReady() {
+        if (this.disposed)
+            return;
+        const camera = this.scene.activeCamera;
+        if (camera != null && this.sceneDepth == null)
+            this.sceneDepth = CameraDepthCopy.AcquireForSampler(this.scene, camera, this);
+        const noiseReady = this.worleyTexture.isReady() && this.erosionTexture.isReady() && this.curveTexture.isReady();
+        const compositeReady = this.compositeMaterial.isReady(this.compositeMesh);
+        if (!noiseReady || !this.marchPass.isReady() || !this.temporalPass.isReady() || !compositeReady || camera == null) {
+            setTimeout(() => this.waitUntilReady(), CLOUD_READY_POLL_MS);
+            return;
+        }
+        this.isReady = true;
+        this.compositeMesh.setEnabled(true);
+        this.beforeRenderObserver = this.scene.onBeforeRenderObservable.add(() => this.render());
+        this.releasePending();
+        SceneManager.WhenSceneRevealed(this.scene).then((revealed) => {
+            if (!revealed || this.disposed)
+                return;
+            this.afterRenderObserver = this.scene.onAfterRenderObservable.add(() => this.updateTier());
+        });
+    }
+    releasePending() {
+        if (!this.isPending)
+            return;
+        this.isPending = false;
+        this.scene.removePendingData(this);
+    }
+    render() {
+        const camera = this.scene.activeCamera;
+        if (!this.isReady || this.disposed || camera == null)
+            return;
+        this.advanceWind(this.scene.getEngine().getDeltaTime() / 1000);
+        this.resizeTargets();
+        this.frameSeed = (this.frameSeed + 1) % 65536;
+        this.sceneDepth = CameraDepthCopy.AcquireForSampler(this.scene, camera, this);
+        this.trackCamera(camera);
+        this.renderer.render(this.marchPass, this.marchTarget);
+        const accumulation = (typeof this.block.temporalaccumulationfactor === "number") ? this.block.temporalaccumulationfactor : 0;
+        if (accumulation < CLOUD_MINIMUM_ACCUMULATION) {
+            this.compositeMaterial.setTexture("cloudLighting", this.marchTarget);
+        }
+        else {
+            this.historyIndex = 1 - this.historyIndex;
+            this.renderer.render(this.temporalPass, this.historyTargets[this.historyIndex]);
+            this.compositeMaterial.setTexture("cloudLighting", this.historyTargets[this.historyIndex]);
+            this.hasHistory = true;
+        }
+        this.compositeMaterial.setFloat("cloudDisplayEncoded", this.isDisplayEncoded() ? 1 : 0);
+        this.previousViewProjection.copyFrom(camera.getTransformationMatrix());
+    }
+    isDisplayEncoded() {
+        return HdrpRendering.IsParity(this.scene) !== true && this.scene.imageProcessingConfiguration.applyByPostProcess !== true;
+    }
+    trackCamera(camera) {
+        const eye = camera.globalPosition;
+        this.currentEye[0] = eye.x;
+        this.currentEye[1] = eye.y;
+        this.currentEye[2] = eye.z;
+        const isCut = camera !== this.lastCamera || VolumetricCloudsMath.IsCameraCut(this.hasPreviousEye ? this.previousEye : null, this.currentEye);
+        if (isCut)
+            this.hasHistory = false;
+        this.lastCamera = camera;
+        this.previousEye[0] = eye.x;
+        this.previousEye[1] = eye.y;
+        this.previousEye[2] = eye.z;
+        this.hasPreviousEye = true;
+    }
+    updateTier() {
+        if (this.disposed || !this.tierTracker.addFrame(this.scene.getEngine().getDeltaTime()))
+            return;
+        this.tier = this.tierTracker.tier;
+        this.settings = VolumetricCloudsMath.TierSettings(this.tier, this.block);
+        if (this.tierTracker.isSettled) {
+            LightingConversions.WarnOnce("urp:clouds:restored", "Volumetric clouds: a lower tier saved under " + (CLOUD_TIER_MINIMUM_SAVING * 100) + " % of the frame time, so tier " + this.tier + " is kept");
+            return;
+        }
+        LightingConversions.WarnOnce("urp:clouds:tier" + this.tier, "Volumetric clouds: frames ran over " + CLOUD_TIER_BUDGET_MS + " ms, trying tier " + this.tier
+            + " (resolution " + this.settings.resolutionScale + ", " + this.settings.primarySteps + " primary steps, " + this.settings.lightSteps + " light steps)");
+    }
+    reportLoweredSettings() {
+        const block = this.block;
+        const settings = this.settings;
+        if (typeof block.numprimarysteps === "number" && settings.primarySteps < block.numprimarysteps) {
+            LightingConversions.WarnOnce("urp:clouds:primarysteps:" + this.tier, "Volumetric clouds: " + block.numprimarysteps + " primary steps are capped at " + settings.primarySteps + " in the browser (tier " + this.tier + ")");
+        }
+        if (typeof block.longraysamplemultiplier === "number" && settings.longRayMultiplier < block.longraysamplemultiplier) {
+            LightingConversions.WarnOnce("urp:clouds:longray:" + this.tier, "Volumetric clouds: long ray sample multiplier " + block.longraysamplemultiplier + " is capped at " + settings.longRayMultiplier + " in the browser (tier " + this.tier + ")");
+        }
+        if (typeof block.numlightsteps === "number" && settings.lightSteps < block.numlightsteps) {
+            LightingConversions.WarnOnce("urp:clouds:lightsteps:" + this.tier, "Volumetric clouds: " + block.numlightsteps + " light steps are capped at " + settings.lightSteps + " (tier " + this.tier + ")");
+        }
+        if (typeof block.resolutionscale === "number" && settings.resolutionScale < block.resolutionscale) {
+            LightingConversions.WarnOnce("urp:clouds:resolution:" + this.tier, "Volumetric clouds: resolution scale " + block.resolutionscale + " is lowered to " + settings.resolutionScale + " (tier " + this.tier + ")");
+        }
+    }
+    advanceWind(deltaSeconds) {
+        const block = this.block;
+        const signedDelta = Math.min(Math.max(deltaSeconds, 0), 1) * CLOUD_WIND_KMH_TO_MS;
+        const theta = Tools.ToRadians(block.globalorientation || 0);
+        const speed = block.globalspeed || 0;
+        this.windOffset[0] = (this.windOffset[0] + signedDelta * speed * Math.cos(theta)) % CLOUD_WIND_WRAP_METERS;
+        this.windOffset[1] = (this.windOffset[1] + signedDelta * speed * Math.sin(theta)) % CLOUD_WIND_WRAP_METERS;
+        this.verticalShapeOffset = (this.verticalShapeOffset + signedDelta * (block.verticalshapewindspeed || 0)) % CLOUD_WIND_WRAP_METERS;
+        this.verticalErosionOffset = (this.verticalErosionOffset + signedDelta * (block.erosionspeedmultiplier || 0)) % CLOUD_WIND_WRAP_METERS;
+    }
+    resizeTargets() {
+        if (!this.updateTargetSize())
+            return;
+        const size = { width: this.targetWidth, height: this.targetHeight };
+        this.marchTarget.resize(size);
+        for (const history of this.historyTargets)
+            history.resize(size);
+        this.hasHistory = false;
+    }
+    updateTargetSize() {
+        const engine = this.scene.getEngine();
+        const scale = this.settings.resolutionScale;
+        const width = Math.max(1, Math.round(engine.getRenderWidth() * scale));
+        const height = Math.max(1, Math.round(engine.getRenderHeight() * scale));
+        if (width === this.targetWidth && height === this.targetHeight)
+            return false;
+        this.targetWidth = width;
+        this.targetHeight = height;
+        return true;
+    }
+    bindMarch(effect) {
+        const scene = this.scene;
+        const camera = scene.activeCamera;
+        if (camera == null)
+            return;
+        const block = this.block;
+        const settings = this.settings;
+        const mirrorX = this.mirror.m[0];
+        camera.getTransformationMatrix().invertToRef(this.inverseViewProjection);
+        this.inverseViewProjection.multiplyToRef(this.mirror, this.inverseViewProjection);
+        effect.setMatrix("cloudInvViewProj", this.inverseViewProjection);
+        const eye = camera.globalPosition;
+        effect.setFloat4("cloudEye", eye.x * mirrorX, eye.y, eye.z, 0);
+        camera.getDirectionToRef(this.localForward, this.cameraForward);
+        effect.setFloat4("cloudForward", this.cameraForward.x * mirrorX, this.cameraForward.y, this.cameraForward.z, mirrorX);
+        const hasDepth = this.sceneDepth != null;
+        effect.setTexture("sceneDepth", hasDepth ? this.sceneDepth : this.placeholderDepth);
+        effect.setFloat4("cloudCamera", (camera.maxZ > 0) ? camera.maxZ : Number.MAX_VALUE, hasDepth ? 1 : 0, this.frameSeed, this.preExposure);
+        if (this.hasAerial)
+            this.bindAerial(effect);
+        const center = this.planetCenter;
+        const bottomRadius = this.planetRadius + (block.bottomaltitude || 0);
+        const altitudeRange = block.altituderange || 1;
+        effect.setFloat4("cloudPlanet", center.x * mirrorX, center.y, center.z, this.planetRadius);
+        effect.setFloat4("cloudLayer", bottomRadius, bottomRadius + altitudeRange, VolumetricCloudsMath.MaximumStep(altitudeRange, block.numprimarysteps, settings.primarySteps), settings.primarySteps);
+        const isAutomaticFade = block.fadeinmode !== CLOUD_FADE_MODE_MANUAL;
+        const fadeStart = isAutomaticFade ? Math.max(altitudeRange * CLOUD_AUTO_FADE_START_FRACTION, camera.minZ) : Math.max(block.fadeinstart || 0, camera.minZ);
+        const fadeDistance = isAutomaticFade ? altitudeRange * CLOUD_AUTO_FADE_DISTANCE_FRACTION : (block.fadeindistance || 0);
+        effect.setFloat4("cloudSteps", settings.longRayMultiplier, settings.lightSteps, fadeStart, fadeDistance);
+        effect.setFloat4("cloudShape", block.shapescale, block.shapefactor, block.erosionscale, block.erosionfactor);
+        const density = block.densitymultiplier * block.densitymultiplier * CLOUD_DENSITY_SCALE;
+        effect.setFloat4("cloudDetail", block.erosionocclusion, block.microerosionscale, block.microerosionfactor, density);
+        const shapeOffset = Array.isArray(block.shapeoffset) ? block.shapeoffset : [0, 0, 0];
+        effect.setFloat4("cloudShapeOffset", shapeOffset[0], shapeOffset[2], shapeOffset[1], block.altitudedistortion * CLOUD_ALTITUDE_DISTORTION_SCALE);
+        const theta = Tools.ToRadians(block.globalorientation || 0);
+        effect.setFloat4("cloudWind", -Math.cos(theta), -Math.sin(theta), this.windOffset[0], this.windOffset[1]);
+        effect.setFloat4("cloudWindSpeed", block.shapespeedmultiplier, block.erosionspeedmultiplier, this.verticalShapeOffset, this.verticalErosionOffset);
+        const coverageInverseSize = 1 / Math.max(CLOUD_MINIMUM_COVERAGE_PATTERN_METERS, block.coveragepatternsize || CLOUD_DEFAULT_COVERAGE_PATTERN_METERS);
+        const coverageGap = (typeof block.coveragegapamount === "number") ? block.coveragegapamount : CLOUD_DEFAULT_COVERAGE_GAP;
+        effect.setFloat4("cloudCoverage", block.coveragevariation || 0, coverageInverseSize, coverageGap, 0);
+        const coverageOffset = Array.isArray(block.coveragepatternoffset) ? block.coveragepatternoffset : [0, 0];
+        effect.setFloat4("cloudCoverageOffset", coverageOffset[0], coverageOffset[1], 0, 0);
+        effect.setFloat4("cloudScattering", 1 - block.multiscattering * CLOUD_MULTI_SCATTERING_SCALE, block.powdereffectintensity, 0, 0);
+        effect.setFloat4("cloudTint", this.scatteringTint.r, this.scatteringTint.g, this.scatteringTint.b, 0);
+        this.bindLighting(effect, mirrorX);
+        effect.setTexture("worleyNoise", this.worleyTexture);
+        effect.setTexture("erosionNoise", this.erosionTexture);
+        effect.setTexture("cloudCurves", this.curveTexture);
+    }
+    bindLighting(effect, mirrorX) {
+        const block = this.block;
+        const sun = this.resolveSun();
+        const sunScale = (this.sky != null && typeof this.sky.sunintensityscale === "number") ? this.sky.sunintensityscale : 1;
+        const dimmer = (typeof block.sunlightdimmer === "number") ? block.sunlightdimmer : 1;
+        if (sun != null) {
+            const direction = this.sunDirection;
+            const strength = sun.intensity * sunScale * dimmer;
+            effect.setFloat4("cloudSunDirection", -direction.x * mirrorX, -direction.y, -direction.z, 0);
+            effect.setFloat4("cloudSunColor", sun.diffuse.r * strength, sun.diffuse.g * strength, sun.diffuse.b * strength, 0);
+        }
+        else {
+            effect.setFloat4("cloudSunDirection", 0, 1, 0, 0);
+            effect.setFloat4("cloudSunColor", 0, 0, 0, 0);
+        }
+        this.refreshAmbient();
+        const ambientDimmer = (typeof block.ambientlightprobedimmer === "number") ? block.ambientlightprobedimmer : 1;
+        effect.setFloat4("cloudAmbientTop", this.ambientTop.r * ambientDimmer, this.ambientTop.g * ambientDimmer, this.ambientTop.b * ambientDimmer, 0);
+        effect.setFloat4("cloudAmbientBottom", this.ambientBottom.r * ambientDimmer, this.ambientBottom.g * ambientDimmer, this.ambientBottom.b * ambientDimmer, 0);
+    }
+    bindAerial(effect) {
+        const sky = HdrpPhysicallyBasedSky.Get(this.scene);
+        const isBound = sky != null && sky.bindAerialPerspective(effect, VolumetricCloudsShaders.AerialSampler, VolumetricCloudsShaders.AerialCameraUniform);
+        if (isBound)
+            return;
+        effect.setTexture(VolumetricCloudsShaders.AerialSampler, this.placeholderAerial);
+        effect.setFloat4(VolumetricCloudsShaders.AerialCameraUniform, 0, 0, 1, 0);
+    }
+    resolveSun() {
+        if (this.sunLight == null || this.sunLight.isDisposed() || !this.sunLight.isEnabled()) {
+            const lights = HdrpPhysicallyBasedSky.InteractingLights(this.scene.lights);
+            this.sunLight = (lights.length > 0) ? lights[0] : null;
+        }
+        const sun = this.sunLight;
+        if (sun == null)
+            return null;
+        sun.computeTransformedInformation();
+        const transformed = sun.transformedDirection;
+        this.sunDirection.copyFrom((transformed != null && sun.parent != null) ? transformed : sun.direction).normalize();
+        return sun;
+    }
+    refreshAmbient() {
+        const sky = HdrpPhysicallyBasedSky.Get(this.scene);
+        const source = (sky != null) ? sky : this.scene.environmentTexture;
+        const captureCount = (sky != null) ? sky.captureCount : 0;
+        if (source === this.ambientSource && captureCount === this.ambientCaptureCount && source != null)
+            return;
+        this.ambientSource = source;
+        this.ambientCaptureCount = captureCount;
+        if (sky != null) {
+            this.ambientTop.copyFrom(sky.ambientAt(Vector3.UpReadOnly));
+            this.ambientBottom.copyFrom(sky.ambientAt(Vector3.DownReadOnly));
+            return;
+        }
+        const environment = this.scene.environmentTexture;
+        const polynomial = (environment != null) ? environment.sphericalPolynomial : null;
+        if (polynomial != null) {
+            this.ambientTop.copyFrom(HdrpPbSkyMath.EvaluatePolynomial(polynomial, Vector3.UpReadOnly));
+            this.ambientBottom.copyFrom(HdrpPbSkyMath.EvaluatePolynomial(polynomial, Vector3.DownReadOnly));
+            return;
+        }
+        this.ambientTop.copyFrom(this.scene.ambientColor);
+        this.ambientBottom.copyFrom(this.scene.ambientColor);
+    }
+    bindTemporal(effect) {
+        const camera = this.scene.activeCamera;
+        if (camera == null)
+            return;
+        const mirrorX = this.mirror.m[0];
+        this.mirror.multiplyToRef(this.previousViewProjection, this.previousViewProjectionUnity);
+        effect.setMatrix("cloudInvViewProj", this.inverseViewProjection);
+        effect.setMatrix("cloudPrevViewProj", this.previousViewProjectionUnity);
+        const eye = camera.globalPosition;
+        effect.setFloat4("cloudEye", eye.x * mirrorX, eye.y, eye.z, 0);
+        effect.setFloat4("cloudForward", this.cameraForward.x * mirrorX, this.cameraForward.y, this.cameraForward.z, 0);
+        const hasDepth = this.sceneDepth != null;
+        effect.setTexture("sceneDepth", hasDepth ? this.sceneDepth : this.placeholderDepth);
+        const accumulation = this.block.temporalaccumulationfactor;
+        effect.setFloat4("cloudCamera", (camera.maxZ > 0) ? camera.maxZ : Number.MAX_VALUE, hasDepth ? 1 : 0, this.hasHistory ? 1 : 0, accumulation);
+        const center = this.planetCenter;
+        const bottomRadius = this.planetRadius + (this.block.bottomaltitude || 0);
+        const altitudeRange = this.block.altituderange || 1;
+        effect.setFloat4("cloudPlanet", center.x * mirrorX, center.y, center.z, this.planetRadius);
+        effect.setFloat4("cloudLayer", bottomRadius, bottomRadius + altitudeRange, altitudeRange / CLOUD_MAX_STEP_DIVISOR, this.settings.primarySteps);
+        effect.setFloat4("cloudTexel", 1 / this.targetWidth, 1 / this.targetHeight, 0, 0);
+        effect.setTexture("cloudCurrent", this.marchTarget);
+        effect.setTexture("cloudHistory", this.historyTargets[1 - this.historyIndex]);
+    }
+    static LinearScatteringTint(tint) {
+        const source = Array.isArray(tint) ? tint : [0, 0, 0];
+        return new Color3(1 - source[0] * CLOUD_SCATTERING_TINT_SCALE, 1 - source[1] * CLOUD_SCATTERING_TINT_SCALE, 1 - source[2] * CLOUD_SCATTERING_TINT_SCALE).toLinearSpace();
+    }
+    static CanvasCssWidth(scene) {
+        const engine = scene.getEngine();
+        const canvas = engine.getRenderingCanvas();
+        if (canvas != null && typeof canvas.clientWidth === "number" && canvas.clientWidth > 0)
+            return canvas.clientWidth;
+        return engine.getRenderWidth();
+    }
+}
+VolumetricClouds.MeshName = "Volumetric Clouds";
+export class VolumetricCloudsShaders {
+    static Register() {
+        if (VolumetricCloudsShaders.registered === true)
+            return;
+        const glsl = ShaderStore.ShadersStore;
+        const wgsl = ShaderStore.ShadersStoreWGSL;
+        const shaders = VolumetricCloudsShaders;
+        glsl[shaders.MarchName + "FragmentShader"] = shaders.GlslMarch();
+        glsl[shaders.CompositeName + "VertexShader"] = shaders.GlslCompositeVertex();
+        glsl[shaders.CompositeName + "FragmentShader"] = shaders.GlslCompositeFragment();
+        glsl[shaders.TemporalName + "FragmentShader"] = shaders.GlslTemporal();
+        wgsl[shaders.MarchName + "FragmentShader"] = shaders.WgslMarch();
+        wgsl[shaders.CompositeName + "VertexShader"] = shaders.WgslCompositeVertex();
+        wgsl[shaders.CompositeName + "FragmentShader"] = shaders.WgslCompositeFragment();
+        wgsl[shaders.TemporalName + "FragmentShader"] = shaders.WgslTemporal();
+        VolumetricCloudsShaders.registered = true;
+    }
+    static AllSources() {
+        const shaders = VolumetricCloudsShaders;
+        return [
+            shaders.GlslMarch(), shaders.GlslCompositeVertex(), shaders.GlslCompositeFragment(), shaders.GlslTemporal(),
+            shaders.WgslMarch(), shaders.WgslCompositeVertex(), shaders.WgslCompositeFragment(), shaders.WgslTemporal()
+        ];
+    }
+    static GlslMarchUniforms() {
+        return VolumetricCloudsShaders.MarchUniforms.map((name) => (name === "cloudInvViewProj") ? "uniform mat4 " + name + ";" : "uniform vec4 " + name + ";").join("\n") + "\n";
+    }
+    static GlslConstants() {
+        return `const float CLOUD_DENSITY_THRESHOLD = 0.001;
+const int EMPTY_STEPS_BEFORE_LARGE_STEPS = 8;
+const float FORWARD_ECCENTRICITY = 0.7;
+const float BACKWARD_ECCENTRICITY = 0.7;
+const float MIN_EROSION_DISTANCE = 3000.0;
+const float MAX_EROSION_DISTANCE = 100000.0;
+const float NOISE_NORMALIZATION = 100000.0;
+const float MAX_SKYBOX_DISTANCE = 200000.0;
+const float LIGHT_STEP_MAXIMAL_SIZE = 1000.0;
+const float CLOUD_PI = 3.14159265359;
+const int MAX_PRIMARY_STEPS = 1024;
+const int MAX_LIGHT_STEPS = 16;
+`;
+    }
+    static GlslGeometry() {
+        return `vec2 cloudIntersectSphere(float sphereRadius, float cosChi, float radialDistance) {
+    float ratio = sphereRadius / radialDistance;
+    float d = ratio * ratio - clamp(1.0 - cosChi * cosChi, 0.0, 1.0);
+    return (d < 0.0) ? vec2(d) : radialDistance * vec2(-cosChi - sqrt(d), -cosChi + sqrt(d));
+}
+float cloudHorizonCosine(float radialDistance) {
+    float sinHorizon = cloudPlanet.w / radialDistance;
+    return -sqrt(clamp(1.0 - sinHorizon * sinHorizon, 0.0, 1.0));
+}
+bool cloudIntersectVolume(vec3 originPS, vec3 direction, out float entry, out float exitDistance) {
+    float radialDistance = length(originPS);
+    float cosChi = dot(originPS, direction) / radialDistance;
+    vec2 inner = cloudIntersectSphere(cloudLayer.x, cosChi, radialDistance);
+    vec2 outer = cloudIntersectSphere(cloudLayer.y, cosChi, radialDistance);
+    if (inner.x < 0.0 && inner.y >= 0.0) {
+        entry = inner.y;
+        exitDistance = outer.y;
+        return cosChi >= cloudHorizonCosine(radialDistance);
+    }
+    entry = max(outer.x, 0.0);
+    exitDistance = (inner.x >= 0.0) ? inner.x : outer.y;
+    return outer.y >= 0.0;
+}
+int cloudRaySphere(vec3 startWS, vec3 direction, float radius, out vec2 result) {
+    vec3 startPS = startWS + vec3(0.0, cloudPlanet.w, 0.0);
+    float a = dot(direction, direction);
+    float b = 2.0 * dot(direction, startPS);
+    float c = dot(startPS, startPS) - radius * radius;
+    float d = b * b - 4.0 * a * c;
+    result = vec2(0.0);
+    int solutions = 0;
+    if (d >= 0.0) {
+        float q = -0.5 * (b + ((b >= 0.0) ? 1.0 : -1.0) * sqrt(d));
+        result = vec2(c / q, q / a);
+        solutions = 2;
+        if (result.x < 0.0) { solutions--; result.x = result.y; }
+        if (result.y < 0.0) solutions--;
+    }
+    return solutions;
+}
+bool cloudRange(vec3 originWS, vec3 direction, out float rangeStart, out float rangeEnd) {
+#ifdef CLOUD_LOCAL
+    return cloudIntersectVolume(originWS - cloudPlanet.xyz, direction, rangeStart, rangeEnd);
+#else
+    vec2 inner = vec2(0.0);
+    vec2 outer = vec2(0.0);
+    cloudRaySphere(originWS, direction, cloudLayer.x, inner);
+    cloudRaySphere(originWS, direction, cloudLayer.y, outer);
+    rangeStart = inner.x;
+    rangeEnd = outer.x;
+    return true;
+#endif
+}
+`;
+    }
+    static GlslDensity() {
+        return `struct CloudProperties {
+    float density;
+    float ambientOcclusion;
+    float height;
+    float sigmaT;
+};
+float cloudRemap(float x, float a, float b, float c, float d) {
+    return (((x - a) / (b - a)) * (d - c)) + c;
+}
+float cloudNormalizedHeight(vec3 positionPS) {
+    return clamp((length(positionPS) - cloudLayer.x) / (cloudLayer.y - cloudLayer.x), 0.0, 1.0);
+}
+vec3 cloudAnimateShape(vec3 positionPS) {
+    vec3 position = positionPS;
+    position.y += position.x / 3.0 + position.z / 7.0;
+    return position + vec3(cloudWind.z, 0.0, cloudWind.w) * cloudWindSpeed.x + vec3(0.0, cloudWindSpeed.z, 0.0);
+}
+vec3 cloudAnimateErosion(vec3 positionPS) {
+    return positionPS + vec3(cloudWind.z, 0.0, cloudWind.w) * cloudWindSpeed.y + vec3(0.0, cloudWindSpeed.w, 0.0);
+}
+float cloudCoverageHash(vec2 cell) {
+    vec3 p = fract(vec3(cell.x, cell.y, cell.x) * 0.1031);
+    p += dot(p, p.yzx + 33.33);
+    return fract((p.x + p.y) * p.z);
+}
+float cloudCoverageNoise(vec2 position) {
+    vec2 cell = floor(position);
+    vec2 blend = fract(position);
+    blend = blend * blend * (3.0 - 2.0 * blend);
+    float bottom = mix(cloudCoverageHash(cell), cloudCoverageHash(cell + vec2(1.0, 0.0)), blend.x);
+    float top = mix(cloudCoverageHash(cell + vec2(0.0, 1.0)), cloudCoverageHash(cell + vec2(1.0, 1.0)), blend.x);
+    return mix(bottom, top, blend.y);
+}
+vec2 cloudCoverageAt(vec3 positionPS) {
+    float coverage = 0.9;
+    float shapeFill = 0.0;
+    if (cloudCoverage.x != 0.0) {
+        vec2 coordinates = (positionPS.xz + cloudWind.zw * cloudWindSpeed.x + cloudCoverageOffset.xy) * cloudCoverage.y;
+        float coverageNoise = cloudCoverageNoise(coordinates) * 0.7 + cloudCoverageNoise(coordinates * 2.03 + vec2(17.13, 43.71)) * 0.3;
+        float threshold = mix(-0.15, 1.15, cloudCoverage.z);
+        float mask = smoothstep(threshold - 0.12, threshold + 0.12, coverageNoise);
+        if (cloudCoverage.x > 0.0) {
+            coverage *= mix(1.0, mask, cloudCoverage.x);
+        } else {
+            shapeFill = clamp(-cloudCoverage.x, 0.0, 1.0) * (1.0 - mask);
+            coverage = mix(coverage, 1.0, shapeFill);
+        }
+    }
+    return vec2(coverage, shapeFill);
+}
+CloudProperties cloudPropertiesAt(vec3 samplePositionPS, float noiseMip, float erosionMip, bool cheapVersion, bool lightSampling) {
+    CloudProperties properties = CloudProperties(0.0, 0.0, 0.0, 0.0);
+    vec3 positionPS = samplePositionPS;
+#ifndef CLOUD_LOCAL
+    if (positionPS.y < cloudPlanet.w) return properties;
+#endif
+    properties.ambientOcclusion = 1.0;
+    properties.height = cloudNormalizedHeight(positionPS);
+#ifndef CLOUD_LOCAL
+    positionPS.xz += cloudEye.xz;
+#endif
+    vec3 baseCoordinates = (cloudAnimateShape(positionPS).xzy / NOISE_NORMALIZATION) * cloudShape.x - cloudShapeOffset.xyz;
+    baseCoordinates += properties.height * vec3(cloudWind.x, cloudWind.y, 0.0) * cloudShapeOffset.w;
+    float lowFrequencyNoise = textureLod(worleyNoise, baseCoordinates, noiseMip).r;
+    vec2 coverage = cloudCoverageAt(positionPS);
+    if (coverage.x <= CLOUD_DENSITY_THRESHOLD) return properties;
+    vec3 curves = textureLod(cloudCurves, vec2(properties.height, 0.5), 0.0).xyz;
+    float shapeFactor = mix(0.1, 1.0, cloudShape.y * (1.0 - coverage.y)) * curves.y;
+    float erosionFactor = cloudShape.w * curves.y;
+    float microDetailFactor = cloudDetail.z * curves.y;
+    lowFrequencyNoise = mix(1.0, lowFrequencyNoise, shapeFactor);
+    float baseCloud = 1.0 - curves.x * coverage.x * (1.0 - shapeFactor);
+    baseCloud = clamp(cloudRemap(lowFrequencyNoise, baseCloud, 1.0, 0.0, 1.0), 0.0, 1.0) * coverage.x * coverage.x;
+    properties.sigmaT = 0.04;
+    float occlusionBlend = clamp(1.0 - max(erosionFactor, shapeFactor) * 0.5, 0.0, 1.0);
+    properties.ambientOcclusion = mix(1.0, curves.z, occlusionBlend);
+    if (!cheapVersion) {
+        vec3 erosionCoordinates = cloudAnimateErosion(positionPS) / NOISE_NORMALIZATION * cloudShape.z;
+        float erosionValue = 1.0 - textureLod(erosionNoise, erosionCoordinates, erosionMip).r;
+        erosionValue = mix(0.0, erosionValue, erosionFactor * 0.75 * coverage.x);
+        properties.ambientOcclusion = clamp(properties.ambientOcclusion - sqrt(erosionValue * cloudDetail.x), 0.0, 1.0);
+        baseCloud = cloudRemap(baseCloud, erosionValue, 1.0, 0.0, 1.0);
+#ifdef CLOUD_MICRO_EROSION
+        vec3 fineCoordinates = cloudAnimateErosion(positionPS) / NOISE_NORMALIZATION * cloudDetail.y;
+        float fineValue = 1.0 - textureLod(erosionNoise, fineCoordinates, erosionMip).r;
+        fineValue = mix(0.0, fineValue, microDetailFactor * 0.5 * coverage.x);
+        baseCloud = cloudRemap(baseCloud, fineValue, 1.0, 0.0, 1.0);
+#endif
+    }
+    if (lightSampling) {
+        baseCloud -= erosionFactor * 0.1;
+#ifdef CLOUD_MICRO_EROSION
+        baseCloud -= microDetailFactor * 0.15;
+#endif
+    }
+    properties.density = max(0.0, baseCloud) * cloudDetail.w;
+    return properties;
+}
+`;
+    }
+    static GlslLighting() {
+        return `float cloudPhase(float anisotropy, float cosTheta) {
+    float denominator = 1.0 + anisotropy * anisotropy - 2.0 * anisotropy * cosTheta;
+    float falloff = inversesqrt(max(denominator, 1e-6));
+    return (1.0 / (4.0 * CLOUD_PI)) * (1.0 - anisotropy * anisotropy) * falloff * falloff * falloff;
+}
+float cloudPowder(float density, float cosAngle, float intensity) {
+    float powder = clamp((1.0 - exp(-density * 4.0)) * 2.0, 0.0, 1.0);
+    return mix(1.0, mix(1.0, powder, smoothstep(0.5, -0.5, cosAngle)), intensity);
+}
+vec3 cloudSunTransmittance(vec3 positionPS, vec3 sunDirection, vec2 phase) {
+    float radialDistance = length(positionPS);
+    float cosChi = dot(positionPS, sunDirection) / radialDistance;
+    vec3 transmittance = vec3(0.0);
+    if (cosChi < cloudHorizonCosine(radialDistance)) return transmittance;
+    float lightSteps = cloudSteps.y;
+    float totalLightDistance = clamp(cloudIntersectSphere(cloudLayer.y, cosChi, radialDistance).y, 0.0, lightSteps * LIGHT_STEP_MAXIMAL_SIZE) + 5.0;
+    float intervalSize = totalLightDistance / lightSteps;
+    float opticalDepth = 0.0;
+    for (int j = 0; j < MAX_LIGHT_STEPS; j++) {
+        if (float(j) >= lightSteps) break;
+        float distanceAlongLight = intervalSize * (0.25 + float(j));
+        CloudProperties lightProperties = cloudPropertiesAt(positionPS + sunDirection * distanceAlongLight, 3.0 * float(j) / lightSteps, 0.0, true, true);
+        opticalDepth += lightProperties.density * lightProperties.sigmaT;
+    }
+    vec3 extinction = intervalSize * opticalDepth * cloudTint.rgb;
+    transmittance += exp(-extinction) * phase.x;
+    transmittance += exp(-extinction * cloudScattering.x) * (phase.y * cloudScattering.x);
+    return transmittance;
+}
+`;
+    }
+    static GlslAerial() {
+        const skyShaders = HdrpPbSkyShaders;
+        const fogPass = HdrpFogPass;
+        if (skyShaders == null || fogPass == null)
+            return "";
+        return "#ifdef CLOUD_AERIAL\nprecision highp sampler2DArray;\nuniform sampler2DArray apLut;\nuniform vec4 cloudApCamera;\n"
+            + skyShaders.GlslUniforms() + skyShaders.GlslCommon() + fogPass.AerialPerspectiveGlsl() + "#endif\n";
+    }
+    static GlslMarch() {
+        const shaders = VolumetricCloudsShaders;
+        return "precision highp float;\nprecision highp sampler3D;\nvarying vec2 vUV;\nuniform sampler3D worleyNoise;\nuniform sampler3D erosionNoise;\nuniform sampler2D cloudCurves;\nuniform sampler2D sceneDepth;\n"
+            + shaders.GlslMarchUniforms() + shaders.GlslConstants() + shaders.GlslGeometry() + shaders.GlslDensity() + shaders.GlslLighting() + shaders.GlslAerial() + `
+uint cloudJenkins(uint value) {
+    uint x = value;
+    x += (x << 10u);
+    x ^= (x >> 6u);
+    x += (x << 3u);
+    x ^= (x >> 11u);
+    x += (x << 15u);
+    return x;
+}
+float cloudRandom(vec2 pixel, float seed) {
+    uvec3 v = uvec3(uvec2(pixel), uint(seed));
+    uint hash = cloudJenkins(v.x ^ cloudJenkins(v.y ^ cloudJenkins(v.z)));
+    return uintBitsToFloat((hash & 0x007FFFFFu) | 0x3F800000u) - 1.0;
+}
+void main(void) {
+    gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);
+    vec4 farPoint = cloudInvViewProj * vec4(vUV * 2.0 - 1.0, 1.0, 1.0);
+    vec3 direction = normalize(farPoint.xyz / farPoint.w - cloudEye.xyz);
+    float maxRayLength = MAX_SKYBOX_DISTANCE;
+    if (cloudCamera.y > 0.5) {
+        float viewDepth = textureLod(sceneDepth, vUV, 0.0).r;
+        if (viewDepth < cloudCamera.x * 0.999) {
+#ifdef CLOUD_LOCAL
+            maxRayLength = viewDepth / max(dot(direction, cloudForward.xyz), 0.0001);
+#else
+            return;
+#endif
+        }
+    }
+#ifdef CLOUD_LOCAL
+    vec3 originWS = cloudEye.xyz;
+#else
+    vec3 originWS = vec3(0.0);
+#endif
+    float rangeStart = 0.0;
+    float rangeEnd = 0.0;
+    if (!cloudRange(originWS, direction, rangeStart, rangeEnd)) return;
+    if (maxRayLength < rangeStart) return;
+    float integrationNoise = cloudRandom(gl_FragCoord.xy, cloudCamera.z);
+    float primarySteps = cloudLayer.w;
+    float totalDistance = min(rangeEnd, maxRayLength) - rangeStart;
+    float stepSize = min(totalDistance / primarySteps, cloudLayer.z);
+    totalDistance = stepSize * primarySteps;
+    float layerThickness = max(1.0, cloudLayer.y - cloudLayer.x);
+    float sampleMultiplier = min(max(1.0, totalDistance / layerThickness), max(1.0, cloudSteps.x));
+    int primaryStepCount = min(int(ceil(primarySteps * sampleMultiplier)), MAX_PRIMARY_STEPS);
+    stepSize = totalDistance / float(max(1, primaryStepCount));
+    vec3 sunDirection = cloudSunDirection.xyz;
+    float cosAngle = dot(direction, sunDirection);
+    vec2 phase = vec2(
+        cloudPhase(FORWARD_ECCENTRICITY, cosAngle) + cloudPhase(-BACKWARD_ECCENTRICITY, cosAngle),
+        cloudPhase(FORWARD_ECCENTRICITY * cloudScattering.x, cosAngle) + cloudPhase(-BACKWARD_ECCENTRICITY * cloudScattering.x, cosAngle));
+    vec3 scattering = vec3(0.0);
+    float ambient = 0.0;
+    float transmittance = 1.0;
+    float meanDistance = 0.0;
+    float meanDistanceDivider = 0.0;
+    float currentDistance = integrationNoise;
+    vec3 currentPositionWS = originWS + (rangeStart + currentDistance) * direction;
+    bool activeSampling = true;
+    int sequentialEmptySamples = 0;
+    int currentIndex = 0;
+    for (int iteration = 0; iteration < MAX_PRIMARY_STEPS * 2; iteration++) {
+        if (currentIndex >= primaryStepCount || currentDistance >= totalDistance) break;
+        float cameraDistance = rangeStart + currentDistance;
+        float densityFade = clamp((cameraDistance - cloudSteps.z) / (cloudSteps.z + cloudSteps.w), 0.0, 1.0);
+        float erosionMip = mix(0.0, 4.0, clamp((cameraDistance - MIN_EROSION_DISTANCE) / (MAX_EROSION_DISTANCE - MIN_EROSION_DISTANCE), 0.0, 1.0));
+        vec3 currentPositionPS = currentPositionWS - cloudPlanet.xyz;
+        if (activeSampling) {
+            CloudProperties properties = cloudPropertiesAt(currentPositionPS, 0.0, erosionMip, false, false);
+            properties.density *= densityFade;
+            if (properties.density > CLOUD_DENSITY_THRESHOLD) {
+                float transmittanceDensity = transmittance * properties.density;
+                meanDistance += cameraDistance * transmittanceDensity;
+                meanDistanceDivider += transmittanceDensity;
+                float stepTransmittance = exp(-properties.density * properties.sigmaT * stepSize);
+                float powder = cloudPowder(properties.density, cosAngle, cloudScattering.y);
+                vec3 sunLuminance = cloudSunTransmittance(currentPositionPS, sunDirection, phase) * powder;
+                float absorbed = transmittance - transmittance * stepTransmittance;
+                scattering += sunLuminance * absorbed;
+                ambient += properties.ambientOcclusion * absorbed;
+                transmittance *= stepTransmittance;
+                if (transmittance < 0.003) {
+                    transmittance = 0.0;
+                    break;
+                }
+                sequentialEmptySamples = 0;
+            } else {
+                sequentialEmptySamples++;
+            }
+            if (sequentialEmptySamples == EMPTY_STEPS_BEFORE_LARGE_STEPS) activeSampling = false;
+            float relativeStepSize = mix(integrationNoise, 1.0, clamp(float(currentIndex), 0.0, 1.0));
+            currentPositionWS += direction * stepSize * relativeStepSize;
+            currentDistance += stepSize * relativeStepSize;
+        } else {
+            CloudProperties properties = cloudPropertiesAt(currentPositionPS, 1.0, 0.0, true, false);
+            properties.density *= densityFade;
+            if (properties.density < CLOUD_DENSITY_THRESHOLD) {
+                currentPositionWS += direction * stepSize * 2.0;
+                currentDistance += stepSize * 2.0;
+            } else {
+                currentPositionWS -= direction * stepSize;
+                currentDistance -= stepSize;
+                currentIndex -= 1;
+                activeSampling = true;
+                sequentialEmptySamples = 0;
+            }
+        }
+        currentIndex++;
+    }
+    if (meanDistance == 0.0) return;
+    meanDistance = min(meanDistance / meanDistanceDivider, maxRayLength);
+    float relativeHeight = cloudNormalizedHeight(originWS - cloudPlanet.xyz + meanDistance * direction);
+    vec3 ambientColor = max(vec3(0.0), mix(cloudAmbientBottom.rgb, cloudAmbientTop.rgb, relativeHeight));
+    vec3 color = (cloudSunColor.rgb * scattering + ambientColor * ambient) * cloudCamera.w;
+#ifdef CLOUD_AERIAL
+    if (cloudApCamera.w > 0.5) {
+        vec3 apDirection = vec3(direction.x * cloudForward.w, direction.y, direction.z);
+        vec3 apColor = vec3(0.0);
+        vec3 apOpacity = vec3(0.0);
+        fogAerialPerspective(vUV, cloudApCamera.xyz, apDirection, meanDistance, apColor, apOpacity);
+        color = apColor * (1.0 - transmittance) + (vec3(1.0) - apOpacity) * color;
+    }
+#endif
+    gl_FragColor = vec4(color, transmittance);
+}
+`;
+    }
+    static GlslCompositeVertex() {
+        return `precision highp float;
+attribute vec3 position;
+varying vec2 vUV;
+void main(void) {
+    vUV = position.xy * 0.5 + 0.5;
+    gl_Position = vec4(position.xy, 0.0, 1.0);
+}
+`;
+    }
+    static GlslCompositeFragment() {
+        return `precision highp float;
+varying vec2 vUV;
+uniform sampler2D cloudLighting;
+uniform float cloudDisplayEncoded;
+const float CLOUD_DISPLAY_GAMMA = 2.2;
+const vec3 CLOUD_LUMINANCE = vec3(0.2126, 0.7152, 0.0722);
+void main(void) {
+    vec4 cloud = texture2D(cloudLighting, vUV);
+    vec3 scattering = cloud.rgb;
+    float throughput = cloud.a;
+    if (cloudDisplayEncoded > 0.5) {
+        float encodeExponent = 1.0 / CLOUD_DISPLAY_GAMMA;
+        float scatteringLuminance = clamp(dot(scattering, CLOUD_LUMINANCE), 0.0, 1.0);
+        throughput = pow(min(cloud.a + scatteringLuminance, 1.0), encodeExponent) - pow(scatteringLuminance, encodeExponent);
+        scattering = pow(clamp(scattering, vec3(0.0), vec3(1.0)), vec3(encodeExponent));
+    }
+    gl_FragColor = vec4(scattering, 1.0 - throughput);
+}
+`;
+    }
+    static GlslTemporal() {
+        const shaders = VolumetricCloudsShaders;
+        return "precision highp float;\nvarying vec2 vUV;\nuniform sampler2D cloudCurrent;\nuniform sampler2D cloudHistory;\nuniform sampler2D sceneDepth;\n"
+            + shaders.TemporalUniforms.map((name) => (name.indexOf("ViewProj") >= 0) ? "uniform mat4 " + name + ";" : "uniform vec4 " + name + ";").join("\n") + "\n"
+            + shaders.GlslGeometry() + `
+float cloudReprojectionDistance(vec3 direction) {
+    float distanceToCloud = 0.0;
+    float exitDistance = 0.0;
+#ifdef CLOUD_LOCAL
+    if (!cloudIntersectVolume(cloudEye.xyz - cloudPlanet.xyz, direction, distanceToCloud, exitDistance)) distanceToCloud = exitDistance;
+#else
+    cloudRange(vec3(0.0), direction, distanceToCloud, exitDistance);
+#endif
+    distanceToCloud = max(distanceToCloud, 1.0);
+    if (cloudCamera.y > 0.5) {
+        float viewDepth = textureLod(sceneDepth, vUV, 0.0).r;
+        if (viewDepth < cloudCamera.x * 0.999) distanceToCloud = min(distanceToCloud, viewDepth / max(dot(direction, cloudForward.xyz), 0.0001));
+    }
+    return distanceToCloud;
+}
+void main(void) {
+    vec4 current = textureLod(cloudCurrent, vUV, 0.0);
+    gl_FragColor = current;
+    if (cloudCamera.z < 0.5 || current.a >= 1.0) return;
+    vec3 boxMin = current.rgb;
+    vec3 boxMax = current.rgb;
+    vec3 neighbour = textureLod(cloudCurrent, vUV + vec2(0.0, -cloudTexel.y), 0.0).rgb;
+    boxMin = min(boxMin, neighbour);
+    boxMax = max(boxMax, neighbour);
+    neighbour = textureLod(cloudCurrent, vUV + vec2(-cloudTexel.x, 0.0), 0.0).rgb;
+    boxMin = min(boxMin, neighbour);
+    boxMax = max(boxMax, neighbour);
+    neighbour = textureLod(cloudCurrent, vUV + vec2(cloudTexel.x, 0.0), 0.0).rgb;
+    boxMin = min(boxMin, neighbour);
+    boxMax = max(boxMax, neighbour);
+    neighbour = textureLod(cloudCurrent, vUV + vec2(0.0, cloudTexel.y), 0.0).rgb;
+    boxMin = min(boxMin, neighbour);
+    boxMax = max(boxMax, neighbour);
+    vec4 farPoint = cloudInvViewProj * vec4(vUV * 2.0 - 1.0, 1.0, 1.0);
+    vec3 direction = normalize(farPoint.xyz / farPoint.w - cloudEye.xyz);
+    vec3 worldPosition = cloudEye.xyz + direction * cloudReprojectionDistance(direction);
+    vec4 previousClip = cloudPrevViewProj * vec4(worldPosition, 1.0);
+    vec2 previousUV = previousClip.xy / previousClip.w * 0.5 + 0.5;
+    vec2 velocity = previousUV - vUV;
+    if (previousUV.x > 1.0 || previousUV.x < 0.0 || previousUV.y > 1.0 || previousUV.y < 0.0) return;
+    vec3 previous = clamp(textureLod(cloudHistory, previousUV, 0.0).rgb, boxMin, boxMax);
+    float accumulation = cloudCamera.w;
+    float intensity = clamp(min(accumulation - abs(velocity.x) * accumulation, accumulation - abs(velocity.y) * accumulation), 0.0, 1.0);
+    gl_FragColor = vec4(mix(current.rgb, previous, intensity), current.a);
+}
+`;
+    }
+    static WgslMarchUniforms() {
+        return VolumetricCloudsShaders.MarchUniforms.map((name) => (name === "cloudInvViewProj") ? "uniform " + name + ": mat4x4f;" : "uniform " + name + ": vec4f;").join("\n") + "\n";
+    }
+    static WgslConstants() {
+        return `const CLOUD_DENSITY_THRESHOLD: f32 = 0.001;
+const EMPTY_STEPS_BEFORE_LARGE_STEPS: i32 = 8;
+const FORWARD_ECCENTRICITY: f32 = 0.7;
+const BACKWARD_ECCENTRICITY: f32 = 0.7;
+const MIN_EROSION_DISTANCE: f32 = 3000.0;
+const MAX_EROSION_DISTANCE: f32 = 100000.0;
+const NOISE_NORMALIZATION: f32 = 100000.0;
+const MAX_SKYBOX_DISTANCE: f32 = 200000.0;
+const LIGHT_STEP_MAXIMAL_SIZE: f32 = 1000.0;
+const CLOUD_PI: f32 = 3.14159265359;
+const MAX_PRIMARY_STEPS: i32 = 1024;
+const MAX_LIGHT_STEPS: i32 = 16;
+`;
+    }
+    static WgslGeometry() {
+        return `struct CloudRange {
+    hit: bool,
+    entryDistance: f32,
+    exitDistance: f32,
+};
+fn cloudIntersectSphere(sphereRadius: f32, cosChi: f32, radialDistance: f32) -> vec2f {
+    let ratio: f32 = sphereRadius / radialDistance;
+    let d: f32 = ratio * ratio - clamp(1.0 - cosChi * cosChi, 0.0, 1.0);
+    if (d < 0.0) { return vec2f(d); }
+    return radialDistance * vec2f(-cosChi - sqrt(d), -cosChi + sqrt(d));
+}
+fn cloudHorizonCosine(radialDistance: f32) -> f32 {
+    let sinHorizon: f32 = uniforms.cloudPlanet.w / radialDistance;
+    return -sqrt(clamp(1.0 - sinHorizon * sinHorizon, 0.0, 1.0));
+}
+fn cloudIntersectVolume(originPS: vec3f, direction: vec3f) -> CloudRange {
+    let radialDistance: f32 = length(originPS);
+    let cosChi: f32 = dot(originPS, direction) / radialDistance;
+    let inner: vec2f = cloudIntersectSphere(uniforms.cloudLayer.x, cosChi, radialDistance);
+    let outer: vec2f = cloudIntersectSphere(uniforms.cloudLayer.y, cosChi, radialDistance);
+    if (inner.x < 0.0 && inner.y >= 0.0) {
+        return CloudRange(cosChi >= cloudHorizonCosine(radialDistance), inner.y, outer.y);
+    }
+    return CloudRange(outer.y >= 0.0, max(outer.x, 0.0), select(outer.y, inner.x, inner.x >= 0.0));
+}
+fn cloudRaySphere(startWS: vec3f, direction: vec3f, radius: f32) -> vec2f {
+    let startPS: vec3f = startWS + vec3f(0.0, uniforms.cloudPlanet.w, 0.0);
+    let a: f32 = dot(direction, direction);
+    let b: f32 = 2.0 * dot(direction, startPS);
+    let c: f32 = dot(startPS, startPS) - radius * radius;
+    let d: f32 = b * b - 4.0 * a * c;
+    var result: vec2f = vec2f(0.0);
+    if (d >= 0.0) {
+        let q: f32 = -0.5 * (b + select(-1.0, 1.0, b >= 0.0) * sqrt(d));
+        result = vec2f(c / q, q / a);
+        if (result.x < 0.0) { result.x = result.y; }
+    }
+    return result;
+}
+fn cloudRange(originWS: vec3f, direction: vec3f) -> CloudRange {
+#ifdef CLOUD_LOCAL
+    return cloudIntersectVolume(originWS - uniforms.cloudPlanet.xyz, direction);
+#else
+    let inner: vec2f = cloudRaySphere(originWS, direction, uniforms.cloudLayer.x);
+    let outer: vec2f = cloudRaySphere(originWS, direction, uniforms.cloudLayer.y);
+    return CloudRange(true, inner.x, outer.x);
+#endif
+}
+`;
+    }
+    static WgslDensity() {
+        return `struct CloudProperties {
+    density: f32,
+    ambientOcclusion: f32,
+    height: f32,
+    sigmaT: f32,
+};
+fn cloudRemap(x: f32, a: f32, b: f32, c: f32, d: f32) -> f32 {
+    return (((x - a) / (b - a)) * (d - c)) + c;
+}
+fn cloudNormalizedHeight(positionPS: vec3f) -> f32 {
+    return clamp((length(positionPS) - uniforms.cloudLayer.x) / (uniforms.cloudLayer.y - uniforms.cloudLayer.x), 0.0, 1.0);
+}
+fn cloudAnimateShape(positionPS: vec3f) -> vec3f {
+    var position: vec3f = positionPS;
+    position.y = position.y + position.x / 3.0 + position.z / 7.0;
+    return position + vec3f(uniforms.cloudWind.z, 0.0, uniforms.cloudWind.w) * uniforms.cloudWindSpeed.x + vec3f(0.0, uniforms.cloudWindSpeed.z, 0.0);
+}
+fn cloudAnimateErosion(positionPS: vec3f) -> vec3f {
+    return positionPS + vec3f(uniforms.cloudWind.z, 0.0, uniforms.cloudWind.w) * uniforms.cloudWindSpeed.y + vec3f(0.0, uniforms.cloudWindSpeed.w, 0.0);
+}
+fn cloudCoverageHash(cell: vec2f) -> f32 {
+    var p: vec3f = fract(vec3f(cell.x, cell.y, cell.x) * 0.1031);
+    p = p + vec3f(dot(p, p.yzx + vec3f(33.33)));
+    return fract((p.x + p.y) * p.z);
+}
+fn cloudCoverageNoise(position: vec2f) -> f32 {
+    let cell: vec2f = floor(position);
+    var blend: vec2f = fract(position);
+    blend = blend * blend * (vec2f(3.0) - 2.0 * blend);
+    let bottom: f32 = mix(cloudCoverageHash(cell), cloudCoverageHash(cell + vec2f(1.0, 0.0)), blend.x);
+    let top: f32 = mix(cloudCoverageHash(cell + vec2f(0.0, 1.0)), cloudCoverageHash(cell + vec2f(1.0, 1.0)), blend.x);
+    return mix(bottom, top, blend.y);
+}
+fn cloudCoverageAt(positionPS: vec3f) -> vec2f {
+    var coverage: f32 = 0.9;
+    var shapeFill: f32 = 0.0;
+    if (uniforms.cloudCoverage.x != 0.0) {
+        let coordinates: vec2f = (positionPS.xz + uniforms.cloudWind.zw * uniforms.cloudWindSpeed.x + uniforms.cloudCoverageOffset.xy) * uniforms.cloudCoverage.y;
+        let coverageNoise: f32 = cloudCoverageNoise(coordinates) * 0.7 + cloudCoverageNoise(coordinates * 2.03 + vec2f(17.13, 43.71)) * 0.3;
+        let threshold: f32 = mix(-0.15, 1.15, uniforms.cloudCoverage.z);
+        let mask: f32 = smoothstep(threshold - 0.12, threshold + 0.12, coverageNoise);
+        if (uniforms.cloudCoverage.x > 0.0) {
+            coverage = coverage * mix(1.0, mask, uniforms.cloudCoverage.x);
+        } else {
+            shapeFill = clamp(-uniforms.cloudCoverage.x, 0.0, 1.0) * (1.0 - mask);
+            coverage = mix(coverage, 1.0, shapeFill);
+        }
+    }
+    return vec2f(coverage, shapeFill);
+}
+fn cloudPropertiesAt(samplePositionPS: vec3f, noiseMip: f32, erosionMip: f32, cheapVersion: bool, lightSampling: bool) -> CloudProperties {
+    var properties: CloudProperties = CloudProperties(0.0, 0.0, 0.0, 0.0);
+    var positionPS: vec3f = samplePositionPS;
+#ifndef CLOUD_LOCAL
+    if (positionPS.y < uniforms.cloudPlanet.w) { return properties; }
+#endif
+    properties.ambientOcclusion = 1.0;
+    properties.height = cloudNormalizedHeight(positionPS);
+#ifndef CLOUD_LOCAL
+    positionPS = vec3f(positionPS.x + uniforms.cloudEye.x, positionPS.y, positionPS.z + uniforms.cloudEye.z);
+#endif
+    var baseCoordinates: vec3f = (cloudAnimateShape(positionPS).xzy / NOISE_NORMALIZATION) * uniforms.cloudShape.x - uniforms.cloudShapeOffset.xyz;
+    baseCoordinates = baseCoordinates + properties.height * vec3f(uniforms.cloudWind.x, uniforms.cloudWind.y, 0.0) * uniforms.cloudShapeOffset.w;
+    var lowFrequencyNoise: f32 = textureSampleLevel(worleyNoise, worleyNoiseSampler, baseCoordinates, noiseMip).r;
+    let coverage: vec2f = cloudCoverageAt(positionPS);
+    if (coverage.x <= CLOUD_DENSITY_THRESHOLD) { return properties; }
+    let curves: vec3f = textureSampleLevel(cloudCurves, cloudCurvesSampler, vec2f(properties.height, 0.5), 0.0).xyz;
+    let shapeFactor: f32 = mix(0.1, 1.0, uniforms.cloudShape.y * (1.0 - coverage.y)) * curves.y;
+    let erosionFactor: f32 = uniforms.cloudShape.w * curves.y;
+    let microDetailFactor: f32 = uniforms.cloudDetail.z * curves.y;
+    lowFrequencyNoise = mix(1.0, lowFrequencyNoise, shapeFactor);
+    var baseCloud: f32 = 1.0 - curves.x * coverage.x * (1.0 - shapeFactor);
+    baseCloud = clamp(cloudRemap(lowFrequencyNoise, baseCloud, 1.0, 0.0, 1.0), 0.0, 1.0) * coverage.x * coverage.x;
+    properties.sigmaT = 0.04;
+    let occlusionBlend: f32 = clamp(1.0 - max(erosionFactor, shapeFactor) * 0.5, 0.0, 1.0);
+    properties.ambientOcclusion = mix(1.0, curves.z, occlusionBlend);
+    if (!cheapVersion) {
+        let erosionCoordinates: vec3f = cloudAnimateErosion(positionPS) / NOISE_NORMALIZATION * uniforms.cloudShape.z;
+        var erosionValue: f32 = 1.0 - textureSampleLevel(erosionNoise, erosionNoiseSampler, erosionCoordinates, erosionMip).r;
+        erosionValue = mix(0.0, erosionValue, erosionFactor * 0.75 * coverage.x);
+        properties.ambientOcclusion = clamp(properties.ambientOcclusion - sqrt(erosionValue * uniforms.cloudDetail.x), 0.0, 1.0);
+        baseCloud = cloudRemap(baseCloud, erosionValue, 1.0, 0.0, 1.0);
+#ifdef CLOUD_MICRO_EROSION
+        let fineCoordinates: vec3f = cloudAnimateErosion(positionPS) / NOISE_NORMALIZATION * uniforms.cloudDetail.y;
+        var fineValue: f32 = 1.0 - textureSampleLevel(erosionNoise, erosionNoiseSampler, fineCoordinates, erosionMip).r;
+        fineValue = mix(0.0, fineValue, microDetailFactor * 0.5 * coverage.x);
+        baseCloud = cloudRemap(baseCloud, fineValue, 1.0, 0.0, 1.0);
+#endif
+    }
+    if (lightSampling) {
+        baseCloud = baseCloud - erosionFactor * 0.1;
+#ifdef CLOUD_MICRO_EROSION
+        baseCloud = baseCloud - microDetailFactor * 0.15;
+#endif
+    }
+    properties.density = max(0.0, baseCloud) * uniforms.cloudDetail.w;
+    return properties;
+}
+`;
+    }
+    static WgslLighting() {
+        return `fn cloudPhase(anisotropy: f32, cosTheta: f32) -> f32 {
+    let denominator: f32 = 1.0 + anisotropy * anisotropy - 2.0 * anisotropy * cosTheta;
+    let falloff: f32 = inverseSqrt(max(denominator, 1e-6));
+    return (1.0 / (4.0 * CLOUD_PI)) * (1.0 - anisotropy * anisotropy) * falloff * falloff * falloff;
+}
+fn cloudPowder(density: f32, cosAngle: f32, intensity: f32) -> f32 {
+    let powder: f32 = clamp((1.0 - exp(-density * 4.0)) * 2.0, 0.0, 1.0);
+    return mix(1.0, mix(1.0, powder, smoothstep(0.5, -0.5, cosAngle)), intensity);
+}
+fn cloudSunTransmittance(positionPS: vec3f, sunDirection: vec3f, phase: vec2f) -> vec3f {
+    let radialDistance: f32 = length(positionPS);
+    let cosChi: f32 = dot(positionPS, sunDirection) / radialDistance;
+    var transmittance: vec3f = vec3f(0.0);
+    if (cosChi < cloudHorizonCosine(radialDistance)) { return transmittance; }
+    let lightSteps: f32 = uniforms.cloudSteps.y;
+    let totalLightDistance: f32 = clamp(cloudIntersectSphere(uniforms.cloudLayer.y, cosChi, radialDistance).y, 0.0, lightSteps * LIGHT_STEP_MAXIMAL_SIZE) + 5.0;
+    let intervalSize: f32 = totalLightDistance / lightSteps;
+    var opticalDepth: f32 = 0.0;
+    for (var j: i32 = 0; j < MAX_LIGHT_STEPS; j++) {
+        if (f32(j) >= lightSteps) { break; }
+        let distanceAlongLight: f32 = intervalSize * (0.25 + f32(j));
+        let lightProperties: CloudProperties = cloudPropertiesAt(positionPS + sunDirection * distanceAlongLight, 3.0 * f32(j) / lightSteps, 0.0, true, true);
+        opticalDepth = opticalDepth + lightProperties.density * lightProperties.sigmaT;
+    }
+    let extinction: vec3f = intervalSize * opticalDepth * uniforms.cloudTint.rgb;
+    transmittance = transmittance + exp(-extinction) * phase.x;
+    transmittance = transmittance + exp(-extinction * uniforms.cloudScattering.x) * (phase.y * uniforms.cloudScattering.x);
+    return transmittance;
+}
+`;
+    }
+    static WgslAerial() {
+        const skyShaders = HdrpPbSkyShaders;
+        const fogPass = HdrpFogPass;
+        if (skyShaders == null || fogPass == null)
+            return "";
+        return "#ifdef CLOUD_AERIAL\nvar apLutSampler: sampler;\nvar apLut: texture_2d_array<f32>;\nuniform cloudApCamera: vec4f;\n"
+            + skyShaders.WgslUniforms() + skyShaders.WgslCommon() + fogPass.AerialPerspectiveWgsl() + "#endif\n";
+    }
+    static WgslMarch() {
+        const shaders = VolumetricCloudsShaders;
+        return "varying vUV: vec2f;\nvar worleyNoiseSampler: sampler;\nvar worleyNoise: texture_3d<f32>;\nvar erosionNoiseSampler: sampler;\nvar erosionNoise: texture_3d<f32>;\nvar cloudCurvesSampler: sampler;\nvar cloudCurves: texture_2d<f32>;\nvar sceneDepthSampler: sampler;\nvar sceneDepth: texture_2d<f32>;\n"
+            + shaders.WgslMarchUniforms() + shaders.WgslConstants() + shaders.WgslGeometry() + shaders.WgslDensity() + shaders.WgslLighting() + shaders.WgslAerial() + `
+fn cloudJenkins(value: u32) -> u32 {
+    var x: u32 = value;
+    x = x + (x << 10u);
+    x = x ^ (x >> 6u);
+    x = x + (x << 3u);
+    x = x ^ (x >> 11u);
+    x = x + (x << 15u);
+    return x;
+}
+fn cloudRandom(pixel: vec2f, seed: f32) -> f32 {
+    let v: vec3u = vec3u(u32(pixel.x), u32(pixel.y), u32(seed));
+    let hash: u32 = cloudJenkins(v.x ^ cloudJenkins(v.y ^ cloudJenkins(v.z)));
+    return bitcast<f32>((hash & 0x007FFFFFu) | 0x3F800000u) - 1.0;
+}
+@fragment
+fn main(input: FragmentInputs) -> FragmentOutputs {
+    fragmentOutputs.color = vec4f(0.0, 0.0, 0.0, 1.0);
+    let uv: vec2f = fragmentInputs.vUV;
+    let farPoint: vec4f = uniforms.cloudInvViewProj * vec4f(uv * 2.0 - vec2f(1.0), 1.0, 1.0);
+    let direction: vec3f = normalize(farPoint.xyz / farPoint.w - uniforms.cloudEye.xyz);
+    var maxRayLength: f32 = MAX_SKYBOX_DISTANCE;
+    let viewDepth: f32 = textureSampleLevel(sceneDepth, sceneDepthSampler, uv, 0.0).r;
+    if (uniforms.cloudCamera.y > 0.5 && viewDepth < uniforms.cloudCamera.x * 0.999) {
+#ifdef CLOUD_LOCAL
+        maxRayLength = viewDepth / max(dot(direction, uniforms.cloudForward.xyz), 0.0001);
+#else
+        return fragmentOutputs;
+#endif
+    }
+#ifdef CLOUD_LOCAL
+    let originWS: vec3f = uniforms.cloudEye.xyz;
+#else
+    let originWS: vec3f = vec3f(0.0);
+#endif
+    let marchRange: CloudRange = cloudRange(originWS, direction);
+    if (!marchRange.hit || maxRayLength < marchRange.entryDistance) { return fragmentOutputs; }
+    let rangeStart: f32 = marchRange.entryDistance;
+    let integrationNoise: f32 = cloudRandom(fragmentInputs.position.xy, uniforms.cloudCamera.z);
+    let primarySteps: f32 = uniforms.cloudLayer.w;
+    var totalDistance: f32 = min(marchRange.exitDistance, maxRayLength) - rangeStart;
+    var stepSize: f32 = min(totalDistance / primarySteps, uniforms.cloudLayer.z);
+    totalDistance = stepSize * primarySteps;
+    let layerThickness: f32 = max(1.0, uniforms.cloudLayer.y - uniforms.cloudLayer.x);
+    let sampleMultiplier: f32 = min(max(1.0, totalDistance / layerThickness), max(1.0, uniforms.cloudSteps.x));
+    let primaryStepCount: i32 = min(i32(ceil(primarySteps * sampleMultiplier)), MAX_PRIMARY_STEPS);
+    stepSize = totalDistance / f32(max(1, primaryStepCount));
+    let sunDirection: vec3f = uniforms.cloudSunDirection.xyz;
+    let cosAngle: f32 = dot(direction, sunDirection);
+    let phase: vec2f = vec2f(
+        cloudPhase(FORWARD_ECCENTRICITY, cosAngle) + cloudPhase(-BACKWARD_ECCENTRICITY, cosAngle),
+        cloudPhase(FORWARD_ECCENTRICITY * uniforms.cloudScattering.x, cosAngle) + cloudPhase(-BACKWARD_ECCENTRICITY * uniforms.cloudScattering.x, cosAngle));
+    var scattering: vec3f = vec3f(0.0);
+    var ambient: f32 = 0.0;
+    var transmittance: f32 = 1.0;
+    var meanDistance: f32 = 0.0;
+    var meanDistanceDivider: f32 = 0.0;
+    var currentDistance: f32 = integrationNoise;
+    var currentPositionWS: vec3f = originWS + (rangeStart + currentDistance) * direction;
+    var activeSampling: bool = true;
+    var sequentialEmptySamples: i32 = 0;
+    var currentIndex: i32 = 0;
+    for (var iteration: i32 = 0; iteration < MAX_PRIMARY_STEPS * 2; iteration++) {
+        if (currentIndex >= primaryStepCount || currentDistance >= totalDistance) { break; }
+        let cameraDistance: f32 = rangeStart + currentDistance;
+        let densityFade: f32 = clamp((cameraDistance - uniforms.cloudSteps.z) / (uniforms.cloudSteps.z + uniforms.cloudSteps.w), 0.0, 1.0);
+        let erosionMip: f32 = mix(0.0, 4.0, clamp((cameraDistance - MIN_EROSION_DISTANCE) / (MAX_EROSION_DISTANCE - MIN_EROSION_DISTANCE), 0.0, 1.0));
+        let currentPositionPS: vec3f = currentPositionWS - uniforms.cloudPlanet.xyz;
+        if (activeSampling) {
+            var properties: CloudProperties = cloudPropertiesAt(currentPositionPS, 0.0, erosionMip, false, false);
+            properties.density = properties.density * densityFade;
+            if (properties.density > CLOUD_DENSITY_THRESHOLD) {
+                let transmittanceDensity: f32 = transmittance * properties.density;
+                meanDistance = meanDistance + cameraDistance * transmittanceDensity;
+                meanDistanceDivider = meanDistanceDivider + transmittanceDensity;
+                let stepTransmittance: f32 = exp(-properties.density * properties.sigmaT * stepSize);
+                let powder: f32 = cloudPowder(properties.density, cosAngle, uniforms.cloudScattering.y);
+                let sunLuminance: vec3f = cloudSunTransmittance(currentPositionPS, sunDirection, phase) * powder;
+                let absorbed: f32 = transmittance - transmittance * stepTransmittance;
+                scattering = scattering + sunLuminance * absorbed;
+                ambient = ambient + properties.ambientOcclusion * absorbed;
+                transmittance = transmittance * stepTransmittance;
+                if (transmittance < 0.003) {
+                    transmittance = 0.0;
+                    break;
+                }
+                sequentialEmptySamples = 0;
+            } else {
+                sequentialEmptySamples = sequentialEmptySamples + 1;
+            }
+            if (sequentialEmptySamples == EMPTY_STEPS_BEFORE_LARGE_STEPS) { activeSampling = false; }
+            let relativeStepSize: f32 = mix(integrationNoise, 1.0, clamp(f32(currentIndex), 0.0, 1.0));
+            currentPositionWS = currentPositionWS + direction * stepSize * relativeStepSize;
+            currentDistance = currentDistance + stepSize * relativeStepSize;
+        } else {
+            var properties: CloudProperties = cloudPropertiesAt(currentPositionPS, 1.0, 0.0, true, false);
+            properties.density = properties.density * densityFade;
+            if (properties.density < CLOUD_DENSITY_THRESHOLD) {
+                currentPositionWS = currentPositionWS + direction * stepSize * 2.0;
+                currentDistance = currentDistance + stepSize * 2.0;
+            } else {
+                currentPositionWS = currentPositionWS - direction * stepSize;
+                currentDistance = currentDistance - stepSize;
+                currentIndex = currentIndex - 1;
+                activeSampling = true;
+                sequentialEmptySamples = 0;
+            }
+        }
+        currentIndex = currentIndex + 1;
+    }
+    if (meanDistance == 0.0) { return fragmentOutputs; }
+    meanDistance = min(meanDistance / meanDistanceDivider, maxRayLength);
+    let relativeHeight: f32 = cloudNormalizedHeight(originWS - uniforms.cloudPlanet.xyz + meanDistance * direction);
+    let ambientColor: vec3f = max(vec3f(0.0), mix(uniforms.cloudAmbientBottom.rgb, uniforms.cloudAmbientTop.rgb, relativeHeight));
+    var color: vec3f = (uniforms.cloudSunColor.rgb * scattering + ambientColor * ambient) * uniforms.cloudCamera.w;
+#ifdef CLOUD_AERIAL
+    if (uniforms.cloudApCamera.w > 0.5) {
+        let apDirection: vec3f = vec3f(direction.x * uniforms.cloudForward.w, direction.y, direction.z);
+        let aerial: FogAerial = fogAerialPerspective(uv, uniforms.cloudApCamera.xyz, apDirection, meanDistance);
+        color = aerial.color * (1.0 - transmittance) + (vec3f(1.0) - aerial.opacity) * color;
+    }
+#endif
+    fragmentOutputs.color = vec4f(color, transmittance);
+}
+`;
+    }
+    static WgslCompositeVertex() {
+        return `attribute position: vec3f;
+varying vUV: vec2f;
+@vertex
+fn main(input: VertexInputs) -> FragmentInputs {
+    vertexOutputs.vUV = vertexInputs.position.xy * 0.5 + vec2f(0.5);
+    vertexOutputs.position = vec4f(vertexInputs.position.xy, 0.0, 1.0);
+}
+`;
+    }
+    static WgslCompositeFragment() {
+        return `varying vUV: vec2f;
+var cloudLightingSampler: sampler;
+var cloudLighting: texture_2d<f32>;
+uniform cloudDisplayEncoded: f32;
+const CLOUD_DISPLAY_GAMMA: f32 = 2.2;
+const CLOUD_LUMINANCE: vec3f = vec3f(0.2126, 0.7152, 0.0722);
+@fragment
+fn main(input: FragmentInputs) -> FragmentOutputs {
+    let cloud: vec4f = textureSample(cloudLighting, cloudLightingSampler, fragmentInputs.vUV);
+    var scattering: vec3f = cloud.rgb;
+    var throughput: f32 = cloud.a;
+    if (uniforms.cloudDisplayEncoded > 0.5) {
+        let encodeExponent: f32 = 1.0 / CLOUD_DISPLAY_GAMMA;
+        let scatteringLuminance: f32 = clamp(dot(scattering, CLOUD_LUMINANCE), 0.0, 1.0);
+        throughput = pow(min(cloud.a + scatteringLuminance, 1.0), encodeExponent) - pow(scatteringLuminance, encodeExponent);
+        scattering = pow(clamp(scattering, vec3f(0.0), vec3f(1.0)), vec3f(encodeExponent));
+    }
+    fragmentOutputs.color = vec4f(scattering, 1.0 - throughput);
+}
+`;
+    }
+    static WgslTemporal() {
+        const shaders = VolumetricCloudsShaders;
+        return "varying vUV: vec2f;\nvar cloudCurrentSampler: sampler;\nvar cloudCurrent: texture_2d<f32>;\nvar cloudHistorySampler: sampler;\nvar cloudHistory: texture_2d<f32>;\nvar sceneDepthSampler: sampler;\nvar sceneDepth: texture_2d<f32>;\n"
+            + shaders.TemporalUniforms.map((name) => (name.indexOf("ViewProj") >= 0) ? "uniform " + name + ": mat4x4f;" : "uniform " + name + ": vec4f;").join("\n") + "\n"
+            + shaders.WgslGeometry() + `
+fn cloudReprojectionDistance(direction: vec3f, viewDepth: f32) -> f32 {
+#ifdef CLOUD_LOCAL
+    let layerRange: CloudRange = cloudIntersectVolume(uniforms.cloudEye.xyz - uniforms.cloudPlanet.xyz, direction);
+    var distanceToCloud: f32 = select(layerRange.exitDistance, layerRange.entryDistance, layerRange.hit);
+#else
+    let layerRange: CloudRange = cloudRange(vec3f(0.0), direction);
+    var distanceToCloud: f32 = layerRange.entryDistance;
+#endif
+    distanceToCloud = max(distanceToCloud, 1.0);
+    if (uniforms.cloudCamera.y > 0.5 && viewDepth < uniforms.cloudCamera.x * 0.999) {
+        distanceToCloud = min(distanceToCloud, viewDepth / max(dot(direction, uniforms.cloudForward.xyz), 0.0001));
+    }
+    return distanceToCloud;
+}
+@fragment
+fn main(input: FragmentInputs) -> FragmentOutputs {
+    let uv: vec2f = fragmentInputs.vUV;
+    let current: vec4f = textureSampleLevel(cloudCurrent, cloudCurrentSampler, uv, 0.0);
+    let viewDepth: f32 = textureSampleLevel(sceneDepth, sceneDepthSampler, uv, 0.0).r;
+    var north: vec3f = textureSampleLevel(cloudCurrent, cloudCurrentSampler, uv + vec2f(0.0, -uniforms.cloudTexel.y), 0.0).rgb;
+    var west: vec3f = textureSampleLevel(cloudCurrent, cloudCurrentSampler, uv + vec2f(-uniforms.cloudTexel.x, 0.0), 0.0).rgb;
+    var east: vec3f = textureSampleLevel(cloudCurrent, cloudCurrentSampler, uv + vec2f(uniforms.cloudTexel.x, 0.0), 0.0).rgb;
+    var south: vec3f = textureSampleLevel(cloudCurrent, cloudCurrentSampler, uv + vec2f(0.0, uniforms.cloudTexel.y), 0.0).rgb;
+    fragmentOutputs.color = current;
+    if (uniforms.cloudCamera.z < 0.5 || current.a >= 1.0) { return fragmentOutputs; }
+    let boxMin: vec3f = min(min(min(current.rgb, north), min(west, east)), south);
+    let boxMax: vec3f = max(max(max(current.rgb, north), max(west, east)), south);
+    let farPoint: vec4f = uniforms.cloudInvViewProj * vec4f(uv * 2.0 - vec2f(1.0), 1.0, 1.0);
+    let direction: vec3f = normalize(farPoint.xyz / farPoint.w - uniforms.cloudEye.xyz);
+    let worldPosition: vec3f = uniforms.cloudEye.xyz + direction * cloudReprojectionDistance(direction, viewDepth);
+    let previousClip: vec4f = uniforms.cloudPrevViewProj * vec4f(worldPosition, 1.0);
+    let previousUV: vec2f = previousClip.xy / previousClip.w * 0.5 + vec2f(0.5);
+    let velocity: vec2f = previousUV - uv;
+    let history: vec3f = textureSampleLevel(cloudHistory, cloudHistorySampler, clamp(previousUV, vec2f(0.0), vec2f(1.0)), 0.0).rgb;
+    if (previousUV.x > 1.0 || previousUV.x < 0.0 || previousUV.y > 1.0 || previousUV.y < 0.0) { return fragmentOutputs; }
+    let previous: vec3f = clamp(history, boxMin, boxMax);
+    let accumulation: f32 = uniforms.cloudCamera.w;
+    let intensity: f32 = clamp(min(accumulation - abs(velocity.x) * accumulation, accumulation - abs(velocity.y) * accumulation), 0.0, 1.0);
+    fragmentOutputs.color = vec4f(mix(current.rgb, previous, intensity), current.a);
+}
+`;
+    }
+}
+VolumetricCloudsShaders.MarchName = "tkCloudMarch";
+VolumetricCloudsShaders.CompositeName = "tkCloudComposite";
+VolumetricCloudsShaders.TemporalName = "tkCloudTemporal";
+VolumetricCloudsShaders.TemporalUniforms = ["cloudInvViewProj", "cloudPrevViewProj", "cloudEye", "cloudForward", "cloudCamera", "cloudPlanet", "cloudLayer", "cloudTexel"];
+VolumetricCloudsShaders.TemporalSamplers = ["cloudCurrent", "cloudHistory", "sceneDepth"];
+VolumetricCloudsShaders.MarchUniforms = [
+    "cloudInvViewProj", "cloudEye", "cloudForward", "cloudCamera", "cloudPlanet", "cloudLayer", "cloudSteps", "cloudShape",
+    "cloudDetail", "cloudShapeOffset", "cloudWind", "cloudWindSpeed", "cloudCoverage", "cloudCoverageOffset", "cloudScattering",
+    "cloudTint", "cloudSunDirection", "cloudSunColor", "cloudAmbientTop", "cloudAmbientBottom"
+];
+VolumetricCloudsShaders.MarchSamplers = ["worleyNoise", "erosionNoise", "cloudCurves", "sceneDepth"];
+VolumetricCloudsShaders.AerialSampler = "apLut";
+VolumetricCloudsShaders.AerialCameraUniform = "cloudApCamera";
+VolumetricCloudsShaders.registered = false;
 export class WebVideoPlayer extends ScriptComponent {
     getVideoMaterial() { return this.m_videoMaterial; }
     getVideoTexture() { return this.m_videoTexture; }
@@ -167098,6 +169414,7 @@ SceneManager.RegisterClass("TOOLKIT.HdrpWaterDecalSurface", HdrpWaterDecalSurfac
 SceneManager.RegisterClass("TOOLKIT.LensFlareComponentSRP", LensFlareComponentSRP);
 SceneManager.RegisterClass("TOOLKIT.LegacyLensFlare", LegacyLensFlare);
 SceneManager.RegisterClass("TOOLKIT.LightProbeNetwork", LightProbeNetwork);
+SceneManager.RegisterClass("TOOLKIT.MeshWaterSurface", MeshWaterSurface);
 SceneManager.RegisterClass("TOOLKIT.NavigationAgent", NavigationAgent);
 Object.defineProperty(PlayerRef, "None", { value: new PlayerRef(0), writable: false });
 Object.defineProperty(PlayerRef, "MasterClient", { value: new PlayerRef(-1), writable: false });
@@ -167129,11 +169446,14 @@ SceneManager.RegisterClass("TOOLKIT.ShurikenParticles", ShurikenParticles);
 SceneManager.RegisterClass("TOOLKIT.SkinTextureArray", SkinTextureArray);
 SceneManager.RegisterClass(SplineAnimate.ClassName, SplineAnimate);
 SceneManager.RegisterClass(SplineContainer.ClassName, SplineContainer);
+const TERRAIN_EDGE_TOLERANCE_METERS = 0.01;
 SceneManager.RegisterClass("TOOLKIT.TerrainBuilder", TerrainBuilder);
 SceneManager.RegisterClass("TOOLKIT.TreeBranchMaterial", TreeBranchMaterial);
 SceneManager.RegisterClass("TOOLKIT.GrassStandardMaterial", GrassStandardMaterial);
 SceneManager.RegisterClass("TOOLKIT.GrassBillboardMaterial", GrassBillboardMaterial);
 SceneManager.RegisterClass("TOOLKIT.TerrainGrassPlugin", TerrainGrassPlugin);
+const TREE_INITIAL_CAPACITY = 64;
+const TREE_GROWTH_FACTOR = 1.5;
 SceneManager.RegisterClass("TOOLKIT.TextureAtlasSkin", TextureAtlasSkin);
 SceneManager.RegisterClass(ThirdPersonController.ClassName, ThirdPersonController);
 SceneManager.RegisterClass("BABYLON.GUI.UnitySlider", UnitySlider);
@@ -167143,4 +169463,36 @@ SceneManager.RegisterClass("TOOLKIT.UserInterface", UserInterface);
 SceneManager.RegisterClass("TOOLKIT.VisualEffect", VisualEffect);
 const VFX_EPSILON = 1e-5;
 const VFX_FLT_MIN = 1.175494351e-38;
+const CLOUD_ALPHA_INDEX = -1000000;
+const CLOUD_TIER_WINDOW_FRAMES = 120;
+const CLOUD_TIER_BUDGET_MS = 33;
+const CLOUD_TIER_MINIMUM_SAVING = 0.1;
+const CLOUD_MAX_STEP_STRETCH = 4;
+const CLOUD_CAMERA_CUT_METERS = 50;
+const CLOUD_CURVE_SAMPLES = 64;
+const CLOUD_EARTH_RADIUS_METERS = 6378100;
+const CLOUD_MINIMUM_CURVATURE_SCALE = 0.025;
+const CLOUD_WIND_KMH_TO_MS = -0.277778;
+const CLOUD_WIND_WRAP_METERS = 100000;
+const CLOUD_MAX_STEP_DIVISOR = 8;
+const CLOUD_PHONE_WIDTH_CSS_PX = 800;
+const CLOUD_WEAK_GPU_TEXTURE_SIZE = 8192;
+const CLOUD_READY_POLL_MS = 16;
+const CLOUD_MINIMUM_ACCUMULATION = 0.01;
+const CLOUD_AUTO_FADE_START_FRACTION = 0.2;
+const CLOUD_AUTO_FADE_DISTANCE_FRACTION = 0.3;
+const CLOUD_FADE_MODE_MANUAL = 1;
+const CLOUD_DENSITY_SCALE = 2;
+const CLOUD_ALTITUDE_DISTORTION_SCALE = 0.25;
+const CLOUD_MULTI_SCATTERING_SCALE = 0.95;
+const CLOUD_SCATTERING_TINT_SCALE = 0.75;
+const CLOUD_MINIMUM_COVERAGE_PATTERN_METERS = 100;
+const CLOUD_DEFAULT_COVERAGE_PATTERN_METERS = 10000;
+const CLOUD_DEFAULT_COVERAGE_GAP = 0.45;
+const CLOUD_DEFAULT_SETTINGS = { resolutionScale: 0.5, primarySteps: 32, longRayMultiplier: 1, lightSteps: 2 };
+const CLOUD_TIER_CAPS = [
+    { resolutionScale: Infinity, primarySteps: 64, longRayMultiplier: 2, lightSteps: Infinity },
+    { resolutionScale: 0.35, primarySteps: 64, longRayMultiplier: 1, lightSteps: 2 },
+    { resolutionScale: 0.25, primarySteps: 64, longRayMultiplier: 1, lightSteps: 1 }
+];
 SceneManager.RegisterClass("TOOLKIT.WebVideoPlayer", WebVideoPlayer);