@zephyr3d/scene 0.9.26 → 0.10.0

package/dist/utility/serialization/scene/scene.js

@@ -1,8 +1,9 @@
 import { Scene } from '../../../scene/scene.js';
 import { defineProps } from '../types.js';
-import { Vector3, Vector4 } from '@zephyr3d/base';
+import { Vector3, Vector4, Vector2 } from '@zephyr3d/base';
 import { JSONData, JSONArray } from '../json.js';
 import { ScriptAttachment, normalizeScriptAttachmentConfig } from '../../../scene/script_attachment.js';
+import { ScenePhysicsSettings } from '../../../scene/physics_settings.js';
 
 /** @internal */ function getSceneClass(manager) {
     return {
@@ -41,6 +42,293 @@ import { ScriptAttachment, normalizeScriptAttachmentConfig } from '../../../scen
                         this.lightingMode = value.str[0];
                     }
                 },
+                {
+                    name: 'SDFEnabled',
+                    description: 'Track the meshes with a baked signed distance field and stream their fields in around the camera, for the effects and simulations that read the scene SDF.',
+                    type: 'bool',
+                    default: false,
+                    options: {
+                        group: 'SDF'
+                    },
+                    get (value) {
+                        value.bool[0] = this.sdf.enabled;
+                    },
+                    set (value) {
+                        this.sdf.enabled = value.bool[0];
+                    }
+                },
+                {
+                    name: 'SDFStreamRadius',
+                    description: 'Distance from the camera within which mesh fields are kept loaded.',
+                    type: 'float',
+                    default: 256,
+                    options: {
+                        group: 'SDF',
+                        minValue: 1,
+                        maxValue: 100000
+                    },
+                    isHidden () {
+                        return !this.sdf.enabled;
+                    },
+                    get (value) {
+                        value.num[0] = this.sdf.streamRadius;
+                    },
+                    set (value) {
+                        this.sdf.streamRadius = Math.max(1, value.num[0]);
+                    }
+                },
+                {
+                    name: 'SDFAtlasSize',
+                    description: 'Voxels per axis of the texture that holds the loaded mesh fields. When meshes near the camera are missing from the distance field view and the console warns that the atlas is full, raise it; each axis costs memory, 512×256×256 is 64 MB.',
+                    type: 'int3',
+                    default: [
+                        512,
+                        256,
+                        256
+                    ],
+                    options: {
+                        group: 'SDF',
+                        minValue: 64,
+                        maxValue: 2048
+                    },
+                    isHidden () {
+                        return !this.sdf.enabled;
+                    },
+                    get (value) {
+                        const size = this.sdf.atlasSize;
+                        value.num[0] = size[0];
+                        value.num[1] = size[1];
+                        value.num[2] = size[2];
+                    },
+                    set (value) {
+                        this.sdf.atlasSize = [
+                            value.num[0],
+                            value.num[1],
+                            value.num[2]
+                        ];
+                    }
+                },
+                {
+                    name: 'GIEnabled',
+                    description: 'Build the voxel scene the global illumination reads: the static meshes with a baked distance field are rasterized into a material atlas around the camera, giving the field surfaces their colour and glow. Turns SDFEnabled on. WebGPU only; nothing changes on WebGL2.',
+                    type: 'bool',
+                    default: false,
+                    options: {
+                        group: 'Global Illumination'
+                    },
+                    get (value) {
+                        value.bool[0] = this.gi.enabled;
+                    },
+                    set (value) {
+                        this.gi.enabled = value.bool[0];
+                    }
+                },
+                {
+                    name: 'GIVoxelizeBudget',
+                    description: 'Meshes voxelized per frame. Higher fills the voxel scene sooner after loading or moving far, at the cost of a longer frame while it does.',
+                    type: 'int',
+                    default: 8,
+                    options: {
+                        group: 'Global Illumination',
+                        minValue: 1,
+                        maxValue: 64
+                    },
+                    isHidden () {
+                        return !this.gi.enabled;
+                    },
+                    get (value) {
+                        value.num[0] = this.gi.voxelizeBudget;
+                    },
+                    set (value) {
+                        this.gi.voxelizeBudget = value.num[0];
+                    }
+                },
+                {
+                    name: 'GISunShadowConeAngle',
+                    description: 'Softness of the sun shadow in the bounced light, as the half angle in degrees of the cone traced through the distance field; the default is the size of the sun. Wider blurs the shadow edges in the indirect light but darkens floors lit through narrow openings; narrower sharpens them.',
+                    type: 'float',
+                    default: 0.5357,
+                    options: {
+                        group: 'Global Illumination',
+                        minValue: 0.1,
+                        maxValue: 45
+                    },
+                    isHidden () {
+                        return !this.gi.enabled;
+                    },
+                    get (value) {
+                        value.num[0] = this.gi.sunShadowConeAngle;
+                    },
+                    set (value) {
+                        this.gi.sunShadowConeAngle = value.num[0];
+                    }
+                },
+                {
+                    name: 'GILocalLightShadows',
+                    description: 'Let point, spot and rect lights that cast shadows also cast them in the bounced light, so objects block the light they bounce. Applies to the eight lights nearest the camera; turn off to save GPU time in scenes with many shadowed lights.',
+                    type: 'bool',
+                    default: true,
+                    options: {
+                        group: 'Global Illumination'
+                    },
+                    isHidden () {
+                        return !this.gi.enabled;
+                    },
+                    get (value) {
+                        value.bool[0] = this.gi.localLightShadows;
+                    },
+                    set (value) {
+                        this.gi.localLightShadows = value.bool[0];
+                    }
+                },
+                {
+                    name: 'GIIntensity',
+                    description: 'Strength of the bounced light the probes add. 1 is physically consistent with the direct lighting; raise to exaggerate colour bleeding, lower to tone it down.',
+                    type: 'float',
+                    default: 1,
+                    options: {
+                        group: 'Global Illumination',
+                        minValue: 0,
+                        maxValue: 10
+                    },
+                    isHidden () {
+                        return !this.gi.enabled;
+                    },
+                    get (value) {
+                        value.num[0] = this.gi.intensity;
+                    },
+                    set (value) {
+                        this.gi.intensity = value.num[0];
+                    }
+                },
+                {
+                    name: 'GIProbeSpacing',
+                    description: 'Distance in world units between light probes. Smaller resolves indirect light in tighter spaces and leaks less through thin walls, but the volume covers less distance around the camera and takes longer to refresh.',
+                    type: 'float',
+                    default: 1,
+                    options: {
+                        group: 'Global Illumination',
+                        minValue: 0.25,
+                        maxValue: 16
+                    },
+                    isHidden () {
+                        return !this.gi.enabled;
+                    },
+                    get (value) {
+                        value.num[0] = this.gi.probeSpacing;
+                    },
+                    set (value) {
+                        this.gi.probeSpacing = value.num[0];
+                    }
+                },
+                {
+                    name: 'GIProbeBudget',
+                    description: 'Light probes updated per frame. Higher makes bounced light follow moving lights and the camera sooner, at more GPU time per frame.',
+                    type: 'int',
+                    default: 4096,
+                    options: {
+                        group: 'Global Illumination',
+                        minValue: 64,
+                        maxValue: 16384
+                    },
+                    isHidden () {
+                        return !this.gi.enabled;
+                    },
+                    get (value) {
+                        value.num[0] = this.gi.probeBudget;
+                    },
+                    set (value) {
+                        this.gi.probeBudget = value.num[0];
+                    }
+                },
+                {
+                    name: 'GIProbeRays',
+                    description: 'Rays each probe traces per update. More gives smoother, less flickering bounced light at more GPU time per frame.',
+                    type: 'int',
+                    default: 128,
+                    options: {
+                        group: 'Global Illumination',
+                        minValue: 16,
+                        maxValue: 512
+                    },
+                    isHidden () {
+                        return !this.gi.enabled;
+                    },
+                    get (value) {
+                        value.num[0] = this.gi.probeRays;
+                    },
+                    set (value) {
+                        this.gi.probeRays = value.num[0];
+                    }
+                },
+                {
+                    name: 'GIProbeHysteresis',
+                    description: 'How long bounced light holds on to what it showed before. Higher keeps it steadier in a still view but slower to follow a light or camera change; lower follows sooner with more flicker.',
+                    type: 'float',
+                    default: 0.97,
+                    options: {
+                        group: 'Global Illumination',
+                        minValue: 0.5,
+                        maxValue: 0.99
+                    },
+                    isHidden () {
+                        return !this.gi.enabled;
+                    },
+                    get (value) {
+                        value.num[0] = this.gi.probeHysteresis;
+                    },
+                    set (value) {
+                        this.gi.probeHysteresis = value.num[0];
+                    }
+                },
+                {
+                    name: 'GIProbeLevels',
+                    description: 'Nested probe volumes around the camera, each twice as coarse and as wide as the one inside it. More levels carry bounced light farther out, each adding as many probes as the finest, so every probe is refreshed less often; one level covers only the finest volume.',
+                    type: 'int',
+                    default: 4,
+                    options: {
+                        group: 'Global Illumination',
+                        minValue: 1,
+                        maxValue: 4
+                    },
+                    isHidden () {
+                        return !this.gi.enabled;
+                    },
+                    get (value) {
+                        value.num[0] = this.gi.probeLevels;
+                    },
+                    set (value) {
+                        this.gi.probeLevels = value.num[0];
+                    }
+                },
+                {
+                    name: 'GIUpdateMode',
+                    description: 'Continuous keeps the bounced light following the sun, the lights and the camera. Frozen stops it where it is: cheaper, and right for a scene whose lighting does not change, but the volume no longer follows the camera.',
+                    type: 'string',
+                    default: 'continuous',
+                    options: {
+                        group: 'Global Illumination',
+                        enum: {
+                            labels: [
+                                'Continuous',
+                                'Frozen'
+                            ],
+                            values: [
+                                'continuous',
+                                'frozen'
+                            ]
+                        }
+                    },
+                    isHidden () {
+                        return !this.gi.enabled;
+                    },
+                    get (value) {
+                        value.str[0] = this.gi.updateMode;
+                    },
+                    set (value) {
+                        this.gi.updateMode = value.str[0];
+                    }
+                },
                 {
                     name: 'MetersPerUnit',
                     description: 'Physical meters represented by one scene unit',
@@ -538,7 +826,7 @@ import { ScriptAttachment, normalizeScriptAttachmentConfig } from '../../../scen
                 },
                 {
                     name: 'HeightFogEndDistance',
-                    description: 'Distance from the camera where height fog reaches full effect',
+                    description: 'Horizontal distance beyond which height fog stops getting thicker. 0 lets it keep accumulating to any distance',
                     type: 'float',
                     default: 10000,
                     options: {
@@ -641,17 +929,59 @@ import { ScriptAttachment, normalizeScriptAttachmentConfig } from '../../../scen
                         this.env.sky.heightFogDirColor = new Vector3(value.num[0], value.num[1], value.num[2]);
                     }
                 },
+                {
+                    name: 'HeightFogSkyLightStrength',
+                    description: 'Makes distant fog take the color of the environment behind it instead of one flat color, removing the dark band at the horizon. Needs an IBL environment light',
+                    type: 'float',
+                    options: {
+                        group: 'HeightFog',
+                        label: 'SkyLightStrength',
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    default: 0,
+                    isValid () {
+                        return this.env.sky.fogType === 'height_fog';
+                    },
+                    get (value) {
+                        value.num[0] = this.env.sky.heightFogSkyLightStrength;
+                    },
+                    set (value) {
+                        this.env.sky.heightFogSkyLightStrength = value.num[0];
+                    }
+                },
+                {
+                    name: 'HeightFogSkyLightRoughness',
+                    description: 'Blurriness of the environment seen through the fog. Higher values give a softer, more uniform fog color',
+                    type: 'float',
+                    options: {
+                        group: 'HeightFog',
+                        label: 'SkyLightRoughness',
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    default: 0.15,
+                    isValid () {
+                        return this.env.sky.fogType === 'height_fog';
+                    },
+                    get (value) {
+                        value.num[0] = this.env.sky.heightFogSkyLightRoughness;
+                    },
+                    set (value) {
+                        this.env.sky.heightFogSkyLightRoughness = value.num[0];
+                    }
+                },
                 {
                     name: 'AerialPerspectiveDistance',
-                    description: 'Distance scale for aerial perspective in the scattering sky model',
+                    description: 'How far the atmosphere keeps hazing distant objects toward the sky color. Beyond this distance the haze stops getting thicker',
                     type: 'float',
                     phase: 1,
                     options: {
                         animatable: true,
                         minValue: 1,
-                        maxValue: 50000
+                        maxValue: 200000
                     },
-                    default: 1,
+                    default: 96000,
                     get (value) {
                         value.num[0] = this.env.sky.aerialPerspectiveDistance;
                     },
@@ -663,123 +993,1275 @@ import { ScriptAttachment, normalizeScriptAttachmentConfig } from '../../../scen
                     }
                 },
                 {
-                    name: 'CameraHeightScale',
-                    description: 'Scale factor applied to camera height in atmospheric scattering',
+                    name: 'AerialPerspectiveViewDistanceScale',
+                    description: 'Strength of the atmospheric haze on distant objects. Higher values make them fade into the sky color sooner; the sky itself does not change',
                     type: 'float',
                     phase: 1,
                     options: {
                         animatable: true,
-                        minValue: 1,
-                        maxValue: 1000
+                        minValue: 0,
+                        maxValue: 10
                     },
                     default: 1,
                     get (value) {
-                        value.num[0] = this.env.sky.cameraHeightScale;
+                        value.num[0] = this.env.sky.aerialPerspectiveViewDistanceScale;
                     },
                     set (value) {
-                        this.env.sky.cameraHeightScale = value.num[0];
+                        this.env.sky.aerialPerspectiveViewDistanceScale = value.num[0];
                     },
                     isValid () {
                         return this.env.sky.skyType === 'scatter';
                     }
                 },
                 {
-                    name: 'AtmosphereExposure',
-                    description: 'Exposure multiplier for atmospheric scattering and sky rendering',
+                    name: 'AerialPerspectiveStartDepth',
+                    description: 'Distance from the camera, in meters, where the atmospheric haze starts. Anything nearer stays completely clear',
                     type: 'float',
+                    phase: 1,
                     options: {
                         animatable: true,
                         minValue: 0,
-                        maxValue: 8
+                        maxValue: 10000
                     },
-                    default: 1,
+                    default: 100,
                     get (value) {
-                        value.num[0] = this.env.sky.atmosphereExposure;
+                        value.num[0] = this.env.sky.aerialPerspectiveStartDepth;
                     },
                     set (value) {
-                        this.env.sky.atmosphereExposure = value.num[0];
+                        this.env.sky.aerialPerspectiveStartDepth = value.num[0];
                     },
                     isValid () {
                         return this.env.sky.skyType === 'scatter';
                     }
                 },
                 {
-                    name: 'Cloudy',
-                    description: 'Cloud coverage amount for the procedural sky',
+                    name: 'CameraHeightScale',
+                    description: 'How many meters of atmosphere one world unit stands for. Larger values make the camera climb faster through the sky and distant objects haze sooner',
                     type: 'float',
-                    default: 0.6,
                     phase: 1,
                     options: {
                         animatable: true,
-                        minValue: 0,
-                        maxValue: 1
+                        minValue: 0.001,
+                        maxValue: 1000
                     },
+                    default: 1,
                     get (value) {
-                        value.num[0] = this.env.sky.cloudy;
+                        value.num[0] = this.env.sky.cameraHeightScale;
                     },
                     set (value) {
-                        this.env.sky.cloudy = value.num[0];
+                        this.env.sky.cameraHeightScale = value.num[0];
                     },
                     isValid () {
                         return this.env.sky.skyType === 'scatter';
                     }
                 },
                 {
-                    name: 'CloudIntensity',
-                    description: 'Brightness of procedural clouds',
+                    name: 'AtmosphereRebakeAltitudeRatio',
+                    description: 'How much the camera must climb or descend, as a fraction of its altitude, before the environment lighting from the sky is updated. Smaller values follow the sky more closely while flying but cost more',
                     type: 'float',
-                    default: 40,
                     phase: 1,
                     options: {
-                        animatable: true,
                         minValue: 0,
-                        maxValue: 200
+                        maxValue: 1
                     },
+                    default: 0.05,
                     get (value) {
-                        value.num[0] = this.env.sky.cloudIntensity;
+                        value.num[0] = this.env.sky.atmosphereRebakeAltitudeRatio;
                     },
                     set (value) {
-                        this.env.sky.cloudIntensity = value.num[0];
+                        this.env.sky.atmosphereRebakeAltitudeRatio = value.num[0];
                     },
                     isValid () {
                         return this.env.sky.skyType === 'scatter';
                     }
                 },
                 {
-                    name: 'Wind',
-                    description: 'Wind direction and speed used by the procedural sky',
-                    type: 'vec2',
-                    default: [
-                        0,
-                        0
-                    ],
+                    name: 'AtmosphereRebakeAngle',
+                    description: 'How far, in degrees of planet curvature, the camera must travel before the environment lighting from the sky is updated. 0.5 degrees is about 55 km on Earth',
+                    type: 'float',
                     phase: 1,
                     options: {
-                        animatable: true,
-                        minValue: -100,
-                        maxValue: 100
+                        minValue: 0,
+                        maxValue: 10
                     },
+                    default: 0.5,
                     get (value) {
-                        value.num[0] = this.env.sky.wind.x;
-                        value.num[1] = this.env.sky.wind.y;
+                        value.num[0] = this.env.sky.atmosphereRebakeAngle;
                     },
                     set (value) {
-                        this.env.sky.wind.setXY(value.num[0], value.num[1]);
+                        this.env.sky.atmosphereRebakeAngle = value.num[0];
                     },
                     isValid () {
                         return this.env.sky.skyType === 'scatter';
                     }
                 },
                 {
-                    name: 'SkyBoxRotation',
-                    description: 'Euler rotation of the skybox',
-                    type: 'vec3',
+                    name: 'GroundAlbedo',
+                    description: 'Color of the ground seen below the horizon where no geometry covers the sky. It also reflects light back up and brightens the sky slightly',
+                    type: 'rgb',
+                    phase: 1,
                     default: [
-                        0,
-                        0,
-                        0
+                        0.401978,
+                        0.401978,
+                        0.401978
                     ],
-                    phase: 1,
+                    get (value) {
+                        value.num[0] = this.env.sky.groundAlbedo.x;
+                        value.num[1] = this.env.sky.groundAlbedo.y;
+                        value.num[2] = this.env.sky.groundAlbedo.z;
+                    },
+                    set (value) {
+                        this.env.sky.groundAlbedo = new Vector3(value.num[0], value.num[1], value.num[2]);
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter';
+                    }
+                },
+                {
+                    name: 'LowerHemisphereIsBlack',
+                    description: 'Keeps the ground below the horizon out of the environment lighting, so objects are not lit from below as if standing on an endless plain. The ground stays visible in the sky itself',
+                    type: 'bool',
+                    phase: 1,
+                    default: true,
+                    get (value) {
+                        value.bool[0] = this.env.sky.lowerHemisphereIsBlack;
+                    },
+                    set (value) {
+                        this.env.sky.lowerHemisphereIsBlack = value.bool[0];
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter';
+                    }
+                },
+                {
+                    name: 'AtmosphereExposure',
+                    description: 'Exposure multiplier for atmospheric scattering and sky rendering',
+                    type: 'float',
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 8
+                    },
+                    default: 1,
+                    get (value) {
+                        value.num[0] = this.env.sky.atmosphereExposure;
+                    },
+                    set (value) {
+                        this.env.sky.atmosphereExposure = value.num[0];
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter';
+                    }
+                },
+                {
+                    name: 'Cloudy',
+                    description: 'Cloud coverage amount for the procedural sky',
+                    type: 'float',
+                    default: 0.6,
+                    phase: 1,
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.env.sky.cloudy;
+                    },
+                    set (value) {
+                        this.env.sky.cloudy = value.num[0];
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter';
+                    }
+                },
+                {
+                    name: 'CloudIntensity',
+                    description: 'Brightness of procedural clouds',
+                    type: 'float',
+                    default: 40,
+                    phase: 1,
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 200
+                    },
+                    get (value) {
+                        value.num[0] = this.env.sky.cloudIntensity;
+                    },
+                    set (value) {
+                        this.env.sky.cloudIntensity = value.num[0];
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter';
+                    }
+                },
+                {
+                    name: 'CloudMode',
+                    description: 'Procedural draws a flat cloud layer; Volumetric draws lit 3D clouds (WebGPU only, falls back to Procedural elsewhere)',
+                    type: 'string',
+                    phase: 1,
+                    options: {
+                        enum: {
+                            labels: [
+                                'Procedural',
+                                'Volumetric'
+                            ],
+                            values: [
+                                'procedural',
+                                'volumetric'
+                            ]
+                        }
+                    },
+                    default: 'procedural',
+                    get (value) {
+                        value.str[0] = this.env.sky.cloudMode;
+                    },
+                    set (value) {
+                        this.env.sky.cloudMode = value.str[0];
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter';
+                    }
+                },
+                {
+                    name: 'VolumetricCloudLayerBottomAltitude',
+                    description: 'Raises the cloud base: higher clouds look smaller and farther away',
+                    type: 'float',
+                    default: 1500,
+                    phase: 2,
+                    options: {
+                        group: 'VolumetricClouds',
+                        label: 'LayerBottomAltitude',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 20000
+                    },
+                    get (value) {
+                        value.num[0] = this.env.sky.volumetricCloud.layerBottomAltitude;
+                    },
+                    set (value) {
+                        this.env.sky.volumetricCloud.layerBottomAltitude = value.num[0];
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter' && this.env.sky.cloudMode === 'volumetric';
+                    }
+                },
+                {
+                    name: 'VolumetricCloudLayerHeight',
+                    description: 'Lets clouds tower higher above their base',
+                    type: 'float',
+                    default: 4000,
+                    phase: 2,
+                    options: {
+                        group: 'VolumetricClouds',
+                        label: 'LayerHeight',
+                        animatable: true,
+                        minValue: 100,
+                        maxValue: 20000
+                    },
+                    get (value) {
+                        value.num[0] = this.env.sky.volumetricCloud.layerHeight;
+                    },
+                    set (value) {
+                        this.env.sky.volumetricCloud.layerHeight = value.num[0];
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter' && this.env.sky.cloudMode === 'volumetric';
+                    }
+                },
+                {
+                    name: 'VolumetricCloudBaseHeightVariation',
+                    description: 'Maximum local rise of cloud undersides above the layer base, in meters',
+                    type: 'float',
+                    default: 700,
+                    phase: 2,
+                    options: {
+                        group: 'VolumetricClouds',
+                        label: 'BaseHeightVariation',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 2000
+                    },
+                    get (value) {
+                        value.num[0] = this.env.sky.volumetricCloud.baseHeightVariation;
+                    },
+                    set (value) {
+                        this.env.sky.volumetricCloud.baseHeightVariation = value.num[0];
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter' && this.env.sky.cloudMode === 'volumetric';
+                    }
+                },
+                {
+                    name: 'VolumetricCloudCoverage',
+                    description: 'Weather coverage: higher grows cloud fields; zero removes all clouds',
+                    type: 'float',
+                    default: 0.55,
+                    phase: 2,
+                    options: {
+                        group: 'VolumetricClouds',
+                        label: 'Coverage',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.env.sky.volumetricCloud.coverage;
+                    },
+                    set (value) {
+                        this.env.sky.volumetricCloud.coverage = value.num[0];
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter' && this.env.sky.cloudMode === 'volumetric';
+                    }
+                },
+                {
+                    name: 'VolumetricCloudDensity',
+                    description: 'Makes clouds more opaque and their shadowed sides darker',
+                    type: 'float',
+                    default: 0.03,
+                    phase: 2,
+                    options: {
+                        group: 'VolumetricClouds',
+                        label: 'Density',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 0.5
+                    },
+                    get (value) {
+                        value.num[0] = this.env.sky.volumetricCloud.density;
+                    },
+                    set (value) {
+                        this.env.sky.volumetricCloud.density = value.num[0];
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter' && this.env.sky.cloudMode === 'volumetric';
+                    }
+                },
+                {
+                    name: 'VolumetricCloudWeatherMapScale',
+                    description: 'Spreads cloud fields wider apart; lower packs more, smaller cloud fields into the sky',
+                    type: 'float',
+                    default: 64000,
+                    phase: 2,
+                    options: {
+                        group: 'VolumetricClouds',
+                        label: 'WeatherMapScale',
+                        animatable: true,
+                        minValue: 1000,
+                        maxValue: 500000
+                    },
+                    get (value) {
+                        value.num[0] = this.env.sky.volumetricCloud.weatherMapScale;
+                    },
+                    set (value) {
+                        this.env.sky.volumetricCloud.weatherMapScale = value.num[0];
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter' && this.env.sky.cloudMode === 'volumetric';
+                    }
+                },
+                {
+                    name: 'VolumetricCloudBaseNoiseScale',
+                    description: 'Size of the large billows that shape each cloud',
+                    type: 'float',
+                    default: 8000,
+                    phase: 2,
+                    options: {
+                        group: 'VolumetricClouds',
+                        label: 'BaseNoiseScale',
+                        animatable: true,
+                        minValue: 100,
+                        maxValue: 100000
+                    },
+                    get (value) {
+                        value.num[0] = this.env.sky.volumetricCloud.baseNoiseScale;
+                    },
+                    set (value) {
+                        this.env.sky.volumetricCloud.baseNoiseScale = value.num[0];
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter' && this.env.sky.cloudMode === 'volumetric';
+                    }
+                },
+                {
+                    name: 'VolumetricCloudShapeStrength',
+                    description: 'Strength of the large noise billows; lower keeps cloud bodies fuller and more connected',
+                    type: 'float',
+                    default: 1,
+                    phase: 2,
+                    options: {
+                        group: 'VolumetricClouds',
+                        label: 'ShapeStrength',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.env.sky.volumetricCloud.shapeStrength;
+                    },
+                    set (value) {
+                        this.env.sky.volumetricCloud.shapeStrength = value.num[0];
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter' && this.env.sky.cloudMode === 'volumetric';
+                    }
+                },
+                {
+                    name: 'VolumetricCloudDetailNoiseScale',
+                    description: 'Size of the small wisps along cloud edges',
+                    type: 'float',
+                    default: 600,
+                    phase: 2,
+                    options: {
+                        group: 'VolumetricClouds',
+                        label: 'DetailNoiseScale',
+                        animatable: true,
+                        minValue: 10,
+                        maxValue: 10000
+                    },
+                    get (value) {
+                        value.num[0] = this.env.sky.volumetricCloud.detailNoiseScale;
+                    },
+                    set (value) {
+                        this.env.sky.volumetricCloud.detailNoiseScale = value.num[0];
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter' && this.env.sky.cloudMode === 'volumetric';
+                    }
+                },
+                {
+                    name: 'VolumetricCloudFormation',
+                    description: 'Isolated: separate island-like clouds with persistent gaps. Connected: cloud fields that merge as Coverage rises',
+                    type: 'string',
+                    default: 'isolated',
+                    phase: 2,
+                    options: {
+                        group: 'VolumetricClouds',
+                        label: 'Formation',
+                        enum: {
+                            labels: [
+                                'Isolated',
+                                'Connected'
+                            ],
+                            values: [
+                                'isolated',
+                                'connected'
+                            ]
+                        }
+                    },
+                    get (value) {
+                        value.str[0] = this.env.sky.volumetricCloud.formation;
+                    },
+                    set (value) {
+                        this.env.sky.volumetricCloud.formation = value.str[0];
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter' && this.env.sky.cloudMode === 'volumetric';
+                    }
+                },
+                {
+                    name: 'VolumetricCloudAnvilBias',
+                    description: 'Spreads the tops of tall clouds out into anvils',
+                    type: 'float',
+                    default: 0,
+                    phase: 2,
+                    options: {
+                        group: 'VolumetricClouds',
+                        label: 'AnvilBias',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.env.sky.volumetricCloud.anvilBias;
+                    },
+                    set (value) {
+                        this.env.sky.volumetricCloud.anvilBias = value.num[0];
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter' && this.env.sky.cloudMode === 'volumetric';
+                    }
+                },
+                {
+                    name: 'VolumetricCloudDetailErosion',
+                    description: 'Higher gives raggeder, wispier cloud edges',
+                    type: 'float',
+                    default: 0.35,
+                    phase: 2,
+                    options: {
+                        group: 'VolumetricClouds',
+                        label: 'DetailErosion',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.env.sky.volumetricCloud.detailErosion;
+                    },
+                    set (value) {
+                        this.env.sky.volumetricCloud.detailErosion = value.num[0];
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter' && this.env.sky.cloudMode === 'volumetric';
+                    }
+                },
+                {
+                    name: 'VolumetricCloudDetailBottomErosion',
+                    description: 'Detail erosion at the cloud base relative to the full amount; lower keeps the base flatter',
+                    type: 'float',
+                    default: 0.1,
+                    phase: 2,
+                    options: {
+                        group: 'VolumetricClouds',
+                        label: 'DetailBottomErosion',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.env.sky.volumetricCloud.detailBottomErosion;
+                    },
+                    set (value) {
+                        this.env.sky.volumetricCloud.detailBottomErosion = value.num[0];
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter' && this.env.sky.cloudMode === 'volumetric';
+                    }
+                },
+                {
+                    name: 'VolumetricCloudPhaseG',
+                    description: 'Tightens and brightens the silver lining around the sun',
+                    type: 'float',
+                    default: 0.8,
+                    phase: 2,
+                    options: {
+                        group: 'VolumetricClouds',
+                        label: 'PhaseG',
+                        animatable: true,
+                        minValue: -0.999,
+                        maxValue: 0.999
+                    },
+                    get (value) {
+                        value.num[0] = this.env.sky.volumetricCloud.phaseG;
+                    },
+                    set (value) {
+                        this.env.sky.volumetricCloud.phaseG = value.num[0];
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter' && this.env.sky.cloudMode === 'volumetric';
+                    }
+                },
+                {
+                    name: 'VolumetricCloudPhaseG2',
+                    description: 'Negative values brighten clouds when looking away from the sun',
+                    type: 'float',
+                    default: -0.3,
+                    phase: 2,
+                    options: {
+                        group: 'VolumetricClouds',
+                        label: 'PhaseG2',
+                        animatable: true,
+                        minValue: -0.999,
+                        maxValue: 0.999
+                    },
+                    get (value) {
+                        value.num[0] = this.env.sky.volumetricCloud.phaseG2;
+                    },
+                    set (value) {
+                        this.env.sky.volumetricCloud.phaseG2 = value.num[0];
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter' && this.env.sky.cloudMode === 'volumetric';
+                    }
+                },
+                {
+                    name: 'VolumetricCloudPhaseBlend',
+                    description: 'Moves the look from the sun-facing lobe (0) to the second lobe (1)',
+                    type: 'float',
+                    default: 0.5,
+                    phase: 2,
+                    options: {
+                        group: 'VolumetricClouds',
+                        label: 'PhaseBlend',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.env.sky.volumetricCloud.phaseBlend;
+                    },
+                    set (value) {
+                        this.env.sky.volumetricCloud.phaseBlend = value.num[0];
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter' && this.env.sky.cloudMode === 'volumetric';
+                    }
+                },
+                {
+                    name: 'VolumetricCloudMultiScatteringOctaves',
+                    description: 'More bounces make thick clouds glow brighter and softer',
+                    type: 'int',
+                    default: 2,
+                    phase: 2,
+                    options: {
+                        group: 'VolumetricClouds',
+                        label: 'MultiScatteringOctaves',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 2
+                    },
+                    get (value) {
+                        value.num[0] = this.env.sky.volumetricCloud.msOctaves;
+                    },
+                    set (value) {
+                        this.env.sky.volumetricCloud.msOctaves = value.num[0];
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter' && this.env.sky.cloudMode === 'volumetric';
+                    }
+                },
+                {
+                    name: 'VolumetricCloudMultiScatteringContribution',
+                    description: 'Brightness of the bounced light inside clouds',
+                    type: 'float',
+                    default: 0.5,
+                    phase: 2,
+                    options: {
+                        group: 'VolumetricClouds',
+                        label: 'MultiScatteringContribution',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.env.sky.volumetricCloud.msContribution;
+                    },
+                    set (value) {
+                        this.env.sky.volumetricCloud.msContribution = value.num[0];
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter' && this.env.sky.cloudMode === 'volumetric';
+                    }
+                },
+                {
+                    name: 'VolumetricCloudMultiScatteringOcclusion',
+                    description: 'Lower lets bounced light reach deeper into thick clouds',
+                    type: 'float',
+                    default: 0.5,
+                    phase: 2,
+                    options: {
+                        group: 'VolumetricClouds',
+                        label: 'MultiScatteringOcclusion',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.env.sky.volumetricCloud.msOcclusion;
+                    },
+                    set (value) {
+                        this.env.sky.volumetricCloud.msOcclusion = value.num[0];
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter' && this.env.sky.cloudMode === 'volumetric';
+                    }
+                },
+                {
+                    name: 'VolumetricCloudMultiScatteringEccentricity',
+                    description: 'Lower spreads bounced light evenly instead of around the sun',
+                    type: 'float',
+                    default: 0.5,
+                    phase: 2,
+                    options: {
+                        group: 'VolumetricClouds',
+                        label: 'MultiScatteringEccentricity',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.env.sky.volumetricCloud.msEccentricity;
+                    },
+                    set (value) {
+                        this.env.sky.volumetricCloud.msEccentricity = value.num[0];
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter' && this.env.sky.cloudMode === 'volumetric';
+                    }
+                },
+                {
+                    name: 'VolumetricCloudGroundAlbedo',
+                    description: 'Brightens cloud undersides with light bounced off the ground',
+                    type: 'float',
+                    default: 0.4,
+                    phase: 2,
+                    options: {
+                        group: 'VolumetricClouds',
+                        label: 'GroundAlbedo',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.env.sky.volumetricCloud.groundAlbedo;
+                    },
+                    set (value) {
+                        this.env.sky.volumetricCloud.groundAlbedo = value.num[0];
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter' && this.env.sky.cloudMode === 'volumetric';
+                    }
+                },
+                {
+                    name: 'VolumetricCloudSkyLightBottomOcclusion',
+                    description: 'Darkens the sky light on cloud undersides',
+                    type: 'float',
+                    default: 0.5,
+                    phase: 2,
+                    options: {
+                        group: 'VolumetricClouds',
+                        label: 'SkyLightBottomOcclusion',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.env.sky.volumetricCloud.skyLightCloudBottomOcclusion;
+                    },
+                    set (value) {
+                        this.env.sky.volumetricCloud.skyLightCloudBottomOcclusion = value.num[0];
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter' && this.env.sky.cloudMode === 'volumetric';
+                    }
+                },
+                {
+                    name: 'VolumetricCloudTracingMaxDistance',
+                    description: 'How far into the layer clouds are still drawn; lower drops distant clouds',
+                    type: 'float',
+                    default: 50000,
+                    phase: 2,
+                    options: {
+                        group: 'VolumetricClouds',
+                        label: 'TracingMaxDistance',
+                        animatable: true,
+                        minValue: 1000,
+                        maxValue: 500000
+                    },
+                    get (value) {
+                        value.num[0] = this.env.sky.volumetricCloud.tracingMaxDistance;
+                    },
+                    set (value) {
+                        this.env.sky.volumetricCloud.tracingMaxDistance = value.num[0];
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter' && this.env.sky.cloudMode === 'volumetric';
+                    }
+                },
+                {
+                    name: 'VolumetricCloudViewSampleCountScale',
+                    description: 'Finer cloud detail at a higher cost',
+                    type: 'float',
+                    default: 2,
+                    phase: 2,
+                    options: {
+                        group: 'VolumetricClouds',
+                        label: 'ViewSampleCountScale',
+                        animatable: true,
+                        minValue: 0.05,
+                        maxValue: 8
+                    },
+                    get (value) {
+                        value.num[0] = this.env.sky.volumetricCloud.viewSampleCountScale;
+                    },
+                    set (value) {
+                        this.env.sky.volumetricCloud.viewSampleCountScale = value.num[0];
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter' && this.env.sky.cloudMode === 'volumetric';
+                    }
+                },
+                {
+                    name: 'VolumetricCloudShadowSampleCountScale',
+                    description: 'Smoother self-shadowing inside clouds at a higher cost',
+                    type: 'float',
+                    default: 1,
+                    phase: 2,
+                    options: {
+                        group: 'VolumetricClouds',
+                        label: 'ShadowSampleCountScale',
+                        animatable: true,
+                        minValue: 0.05,
+                        maxValue: 8
+                    },
+                    get (value) {
+                        value.num[0] = this.env.sky.volumetricCloud.shadowSampleCountScale;
+                    },
+                    set (value) {
+                        this.env.sky.volumetricCloud.shadowSampleCountScale = value.num[0];
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter' && this.env.sky.cloudMode === 'volumetric';
+                    }
+                },
+                {
+                    name: 'VolumetricCloudShadowTracingDistance',
+                    description: 'How far towards the sun clouds look for cloud that shades them',
+                    type: 'float',
+                    default: 8000,
+                    phase: 2,
+                    options: {
+                        group: 'VolumetricClouds',
+                        label: 'ShadowTracingDistance',
+                        animatable: true,
+                        minValue: 100,
+                        maxValue: 50000
+                    },
+                    get (value) {
+                        value.num[0] = this.env.sky.volumetricCloud.shadowTracingDistance;
+                    },
+                    set (value) {
+                        this.env.sky.volumetricCloud.shadowTracingDistance = value.num[0];
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter' && this.env.sky.cloudMode === 'volumetric';
+                    }
+                },
+                {
+                    name: 'VolumetricCloudStopTracingTransmittance',
+                    description: 'Lower is slightly more exact behind dense clouds but slower',
+                    type: 'float',
+                    default: 0.005,
+                    phase: 2,
+                    options: {
+                        group: 'VolumetricClouds',
+                        label: 'StopTracingTransmittance',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.env.sky.volumetricCloud.stopTracingTransmittanceThreshold;
+                    },
+                    set (value) {
+                        this.env.sky.volumetricCloud.stopTracingTransmittanceThreshold = value.num[0];
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter' && this.env.sky.cloudMode === 'volumetric';
+                    }
+                },
+                {
+                    name: 'VolumetricCloudNoiseSeed',
+                    description: 'Picks a different generated cloud pattern',
+                    type: 'int',
+                    default: 0,
+                    phase: 2,
+                    options: {
+                        group: 'VolumetricClouds',
+                        label: 'NoiseSeed',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1000
+                    },
+                    get (value) {
+                        value.num[0] = this.env.sky.volumetricCloud.noiseSeed;
+                    },
+                    set (value) {
+                        this.env.sky.volumetricCloud.noiseSeed = value.num[0];
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter' && this.env.sky.cloudMode === 'volumetric';
+                    }
+                },
+                {
+                    name: 'VolumetricCloudFramesPerUpdate',
+                    description: 'Fewer frames let clouds and sunlight change faster but cost more per frame',
+                    type: 'int',
+                    default: 64,
+                    phase: 2,
+                    options: {
+                        group: 'VolumetricClouds',
+                        label: 'FramesPerUpdate',
+                        animatable: true,
+                        minValue: 4,
+                        maxValue: 256
+                    },
+                    get (value) {
+                        value.num[0] = this.env.sky.volumetricCloud.framesPerUpdate;
+                    },
+                    set (value) {
+                        this.env.sky.volumetricCloud.framesPerUpdate = value.num[0];
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter' && this.env.sky.cloudMode === 'volumetric';
+                    }
+                },
+                {
+                    name: 'VolumetricCloudCacheResolution',
+                    description: 'Keeps clouds sharp at narrow fields of view at a higher memory cost',
+                    type: 'int',
+                    default: 768,
+                    phase: 2,
+                    options: {
+                        group: 'VolumetricClouds',
+                        label: 'CacheResolution',
+                        animatable: true,
+                        minValue: 128,
+                        maxValue: 2048
+                    },
+                    get (value) {
+                        value.num[0] = this.env.sky.volumetricCloud.cacheResolution;
+                    },
+                    set (value) {
+                        this.env.sky.volumetricCloud.cacheResolution = value.num[0];
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter' && this.env.sky.cloudMode === 'volumetric';
+                    }
+                },
+                {
+                    name: 'VolumetricCloudPerSampleSunTransmittance',
+                    description: 'Reddens the sunlight inside clouds by the air between each point and the sun; matters most at sunrise and sunset',
+                    type: 'bool',
+                    default: false,
+                    phase: 2,
+                    options: {
+                        group: 'VolumetricClouds',
+                        label: 'PerSampleSunTransmittance'
+                    },
+                    get (value) {
+                        value.bool[0] = this.env.sky.volumetricCloud.perSampleAtmosphericLightTransmittance;
+                    },
+                    set (value) {
+                        this.env.sky.volumetricCloud.perSampleAtmosphericLightTransmittance = value.bool[0];
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter' && this.env.sky.cloudMode === 'volumetric';
+                    }
+                },
+                {
+                    name: 'VolumetricCloudAlbedo',
+                    description: 'Tint of the light clouds scatter; lower values make clouds greyer',
+                    type: 'rgb',
+                    default: [
+                        1,
+                        1,
+                        1
+                    ],
+                    phase: 2,
+                    options: {
+                        group: 'VolumetricClouds',
+                        label: 'Albedo',
+                        animatable: true
+                    },
+                    get (value) {
+                        const c = this.env.sky.volumetricCloud.albedo;
+                        value.num[0] = c.x;
+                        value.num[1] = c.y;
+                        value.num[2] = c.z;
+                    },
+                    set (value) {
+                        this.env.sky.volumetricCloud.albedo = new Vector3(value.num[0], value.num[1], value.num[2]);
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter' && this.env.sky.cloudMode === 'volumetric';
+                    }
+                },
+                {
+                    name: 'VolumetricCloudWind',
+                    description: 'Direction and speed the clouds drift with, in meters per second',
+                    type: 'vec2',
+                    default: [
+                        10,
+                        0
+                    ],
+                    phase: 2,
+                    options: {
+                        group: 'VolumetricClouds',
+                        label: 'Wind',
+                        animatable: true,
+                        minValue: -100,
+                        maxValue: 100
+                    },
+                    get (value) {
+                        const w = this.env.sky.volumetricCloud.wind;
+                        value.num[0] = w.x;
+                        value.num[1] = w.y;
+                    },
+                    set (value) {
+                        this.env.sky.volumetricCloud.wind = new Vector2(value.num[0], value.num[1]);
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter' && this.env.sky.cloudMode === 'volumetric';
+                    }
+                },
+                {
+                    name: 'VolumetricCloudWeatherMap',
+                    description: 'Where clouds form: R Connected footprints, G Isolated footprints (higher values fill first as Coverage rises), B cloud type (0 stratus to 1 cumulus). Empty generates one',
+                    type: 'object',
+                    default: null,
+                    phase: 2,
+                    options: {
+                        group: 'VolumetricClouds',
+                        label: 'WeatherMap',
+                        mimeTypes: [
+                            'image/png',
+                            'image/tga',
+                            'image/webp',
+                            'image/ktx2',
+                            'image/x-dds'
+                        ]
+                    },
+                    isNullable () {
+                        return true;
+                    },
+                    get (value) {
+                        value.str[0] = manager.getAssetId(this.env.sky.cloudWeatherMap) ?? '';
+                    },
+                    async set (value) {
+                        if (!value || !value.str[0]) {
+                            this.env.sky.cloudWeatherMap = null;
+                            return;
+                        }
+                        let tex = null;
+                        try {
+                            // Data, not color: no sRGB decoding
+                            tex = await manager.fetchTexture(value.str[0], {
+                                linearColorSpace: true
+                            });
+                        } catch (err) {
+                            console.error(`Load asset failed: ${value.str[0]}: ${err}`);
+                        }
+                        if (tex?.isTexture2D()) {
+                            this.env.sky.cloudWeatherMap = tex;
+                        } else {
+                            console.error('Invalid texture type');
+                        }
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter' && this.env.sky.cloudMode === 'volumetric';
+                    }
+                },
+                {
+                    name: 'VolumetricCloudBaseNoise',
+                    description: 'Shape of the large billows, as a 2D atlas of the slices of a cubic volume (e.g. 128^3 as 2048x1024). Empty generates one',
+                    type: 'object',
+                    default: null,
+                    phase: 2,
+                    options: {
+                        group: 'VolumetricClouds',
+                        label: 'BaseNoise',
+                        mimeTypes: [
+                            'image/png',
+                            'image/tga',
+                            'image/webp',
+                            'image/ktx2',
+                            'image/x-dds'
+                        ]
+                    },
+                    isNullable () {
+                        return true;
+                    },
+                    get (value) {
+                        value.str[0] = manager.getAssetId(this.env.sky.cloudBaseNoise) ?? '';
+                    },
+                    async set (value) {
+                        if (!value || !value.str[0]) {
+                            this.env.sky.cloudBaseNoise = null;
+                            return;
+                        }
+                        let tex = null;
+                        try {
+                            // Data, not color: no sRGB decoding
+                            tex = await manager.fetchTexture(value.str[0], {
+                                linearColorSpace: true
+                            });
+                        } catch (err) {
+                            console.error(`Load asset failed: ${value.str[0]}: ${err}`);
+                        }
+                        if (tex?.isTexture2D()) {
+                            this.env.sky.cloudBaseNoise = tex;
+                        } else {
+                            console.error('Invalid texture type');
+                        }
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter' && this.env.sky.cloudMode === 'volumetric';
+                    }
+                },
+                {
+                    name: 'VolumetricCloudDetailNoise',
+                    description: 'Shape of the small edge wisps, as a 2D atlas of the slices of a cubic volume (e.g. 32^3 as 256x128). Empty generates one',
+                    type: 'object',
+                    default: null,
+                    phase: 2,
+                    options: {
+                        group: 'VolumetricClouds',
+                        label: 'DetailNoise',
+                        mimeTypes: [
+                            'image/png',
+                            'image/tga',
+                            'image/webp',
+                            'image/ktx2',
+                            'image/x-dds'
+                        ]
+                    },
+                    isNullable () {
+                        return true;
+                    },
+                    get (value) {
+                        value.str[0] = manager.getAssetId(this.env.sky.cloudDetailNoise) ?? '';
+                    },
+                    async set (value) {
+                        if (!value || !value.str[0]) {
+                            this.env.sky.cloudDetailNoise = null;
+                            return;
+                        }
+                        let tex = null;
+                        try {
+                            // Data, not color: no sRGB decoding
+                            tex = await manager.fetchTexture(value.str[0], {
+                                linearColorSpace: true
+                            });
+                        } catch (err) {
+                            console.error(`Load asset failed: ${value.str[0]}: ${err}`);
+                        }
+                        if (tex?.isTexture2D()) {
+                            this.env.sky.cloudDetailNoise = tex;
+                        } else {
+                            console.error('Invalid texture type');
+                        }
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter' && this.env.sky.cloudMode === 'volumetric';
+                    }
+                },
+                {
+                    name: 'VolumetricCloudDebugView',
+                    description: 'Shows a cloud resource, height profile or density section over the sky for inspection',
+                    type: 'string',
+                    default: 'none',
+                    phase: 2,
+                    options: {
+                        group: 'VolumetricClouds',
+                        label: 'DebugView',
+                        enum: {
+                            labels: [
+                                'None',
+                                'WeatherMap',
+                                'BaseNoise',
+                                'DetailNoise',
+                                'HeightProfileXY',
+                                'HeightProfileXZ',
+                                'BaseDensityXY',
+                                'BaseDensityXZ',
+                                'DensityXY',
+                                'DensityXZ'
+                            ],
+                            values: [
+                                'none',
+                                'weather',
+                                'baseNoise',
+                                'detailNoise',
+                                'profileXY',
+                                'profileXZ',
+                                'baseDensityXY',
+                                'baseDensityXZ',
+                                'densityXY',
+                                'densityXZ'
+                            ]
+                        }
+                    },
+                    get (value) {
+                        value.str[0] = this.env.sky.cloudDebugView;
+                    },
+                    set (value) {
+                        this.env.sky.cloudDebugView = value.str[0];
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter' && this.env.sky.cloudMode === 'volumetric';
+                    }
+                },
+                {
+                    name: 'VolumetricCloudDebugSlice',
+                    description: 'Noise slice depth, normalized Z of XY sections, or normalized layer height of XZ sections',
+                    type: 'float',
+                    default: 0,
+                    phase: 2,
+                    options: {
+                        group: 'VolumetricClouds',
+                        label: 'DebugSlice',
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.env.sky.cloudDebugSlice;
+                    },
+                    set (value) {
+                        this.env.sky.cloudDebugSlice = value.num[0];
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter' && this.env.sky.cloudMode === 'volumetric';
+                    }
+                },
+                {
+                    name: 'VolumetricCloudDebugChannel',
+                    description: 'Channel shown by DebugView: 0 color, 1-4 R, G, B or A as grey',
+                    type: 'int',
+                    default: 0,
+                    phase: 2,
+                    options: {
+                        group: 'VolumetricClouds',
+                        label: 'DebugChannel',
+                        minValue: 0,
+                        maxValue: 4
+                    },
+                    get (value) {
+                        value.num[0] = this.env.sky.cloudDebugChannel;
+                    },
+                    set (value) {
+                        this.env.sky.cloudDebugChannel = value.num[0];
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter' && this.env.sky.cloudMode === 'volumetric';
+                    }
+                },
+                {
+                    name: 'Wind',
+                    description: 'Wind direction and speed used by the procedural sky',
+                    type: 'vec2',
+                    default: [
+                        0,
+                        0
+                    ],
+                    phase: 1,
+                    options: {
+                        animatable: true,
+                        minValue: -100,
+                        maxValue: 100
+                    },
+                    get (value) {
+                        value.num[0] = this.env.sky.wind.x;
+                        value.num[1] = this.env.sky.wind.y;
+                    },
+                    set (value) {
+                        this.env.sky.wind.setXY(value.num[0], value.num[1]);
+                    },
+                    isValid () {
+                        return this.env.sky.skyType === 'scatter';
+                    }
+                },
+                {
+                    name: 'SkyBoxRotation',
+                    description: 'Euler rotation of the skybox',
+                    type: 'vec3',
+                    default: [
+                        0,
+                        0,
+                        0
+                    ],
+                    phase: 1,
                     options: {
                         label: 'Rotation',
                         edit: 'quaternion',
@@ -832,6 +2314,139 @@ import { ScriptAttachment, normalizeScriptAttachmentConfig } from '../../../scen
                         return this.env.sky.skyType === 'skybox';
                     }
                 },
+                {
+                    name: 'WindFieldDirection',
+                    description: 'Compass direction the wind blows toward, in degrees. Grass leans and gusts travel this way',
+                    type: 'float',
+                    default: 0,
+                    options: {
+                        group: 'Wind',
+                        label: 'Direction',
+                        animatable: true,
+                        minValue: -180,
+                        maxValue: 180
+                    },
+                    get (value) {
+                        value.num[0] = this.env.wind.direction;
+                    },
+                    set (value) {
+                        this.env.wind.direction = value.num[0];
+                    }
+                },
+                {
+                    name: 'WindFieldStrength',
+                    description: 'How hard the wind blows. 0 is still air; higher values bend grass further over',
+                    type: 'float',
+                    default: 0.3,
+                    options: {
+                        group: 'Wind',
+                        label: 'Strength',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 2
+                    },
+                    get (value) {
+                        value.num[0] = this.env.wind.strength;
+                    },
+                    set (value) {
+                        this.env.wind.strength = value.num[0];
+                    }
+                },
+                {
+                    name: 'WindFieldSpeed',
+                    description: 'How fast the gusts sweep across the ground, in units per second',
+                    type: 'float',
+                    default: 4,
+                    options: {
+                        group: 'Wind',
+                        label: 'GustSpeed',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 50
+                    },
+                    get (value) {
+                        value.num[0] = this.env.wind.speed;
+                    },
+                    set (value) {
+                        this.env.wind.speed = value.num[0];
+                    }
+                },
+                {
+                    name: 'WindFieldGustStrength',
+                    description: 'How strongly gusts come and go. 0 gives a steady wind; higher values make waves of stronger wind roll through fields',
+                    type: 'float',
+                    default: 0.6,
+                    options: {
+                        group: 'Wind',
+                        label: 'GustStrength',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 2
+                    },
+                    get (value) {
+                        value.num[0] = this.env.wind.gustStrength;
+                    },
+                    set (value) {
+                        this.env.wind.gustStrength = value.num[0];
+                    }
+                },
+                {
+                    name: 'WindFieldGustScale',
+                    description: 'Size of a gust on the ground, in units. Larger values give broad, slow-looking waves',
+                    type: 'float',
+                    default: 30,
+                    options: {
+                        group: 'Wind',
+                        label: 'GustSize',
+                        animatable: true,
+                        minValue: 0.1,
+                        maxValue: 500
+                    },
+                    get (value) {
+                        value.num[0] = this.env.wind.gustScale;
+                    },
+                    set (value) {
+                        this.env.wind.gustScale = value.num[0];
+                    }
+                },
+                {
+                    name: 'WindFieldDetailStrength',
+                    description: 'Amount of small, fast flutter on top of the gusts',
+                    type: 'float',
+                    default: 0.25,
+                    options: {
+                        group: 'Wind',
+                        label: 'TurbulenceStrength',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 2
+                    },
+                    get (value) {
+                        value.num[0] = this.env.wind.detailStrength;
+                    },
+                    set (value) {
+                        this.env.wind.detailStrength = value.num[0];
+                    }
+                },
+                {
+                    name: 'WindFieldDetailScale',
+                    description: 'Size of the small flutter patches, in units',
+                    type: 'float',
+                    default: 4,
+                    options: {
+                        group: 'Wind',
+                        label: 'TurbulenceSize',
+                        animatable: true,
+                        minValue: 0.1,
+                        maxValue: 100
+                    },
+                    get (value) {
+                        value.num[0] = this.env.wind.detailScale;
+                    },
+                    set (value) {
+                        this.env.wind.detailScale = value.num[0];
+                    }
+                },
                 {
                     name: 'NodeHierarchy',
                     description: 'Node tree of this scene',
@@ -987,6 +2602,27 @@ import { ScriptAttachment, normalizeScriptAttachmentConfig } from '../../../scen
                         this.scriptConfigs = data instanceof JSONArray ? data.data : Array.isArray(data) ? data : [];
                     }
                 },
+                {
+                    name: 'Physics',
+                    description: 'Gravity, step rate and collision layers used when the scene is simulated with physics; leave empty for defaults',
+                    type: 'object',
+                    default: null,
+                    options: {
+                        objectTypes: [
+                            ScenePhysicsSettings
+                        ]
+                    },
+                    isNullable () {
+                        return true;
+                    },
+                    get (value) {
+                        value.object[0] = this.physicsSettings;
+                    },
+                    set (value) {
+                        const settings = value?.object[0];
+                        this.physicsSettings = settings instanceof ScenePhysicsSettings ? settings : null;
+                    }
+                },
                 {
                     name: 'Metadata',
                     description: 'Meta data for this scene',