@3driseai/3drise-viewer 0.1.7 → 0.1.8

package/dist/shaders/terrain/TerrainMaterial.js

@@ -0,0 +1,291 @@
+import * as THREE from 'three';
+import { extend } from '@react-three/fiber';
+import { skyLib } from '../glsl/cloudCore.glsl.js';
+import { terrainFull } from '../glsl/terrainCore.glsl.js';
+/**
+ * The terrain surface material. Used by all four landforms — they are one height
+ * field with different shaping operators, not four shaders.
+ *
+ * ## Why this is not drei's `shaderMaterial`
+ *
+ * Every other material in this package is built with `shaderMaterial()` from
+ * drei, and that is still the house convention. This one cannot be, and the
+ * reason is the requirement: terrain has to RECEIVE the scene's shadows, so an
+ * object standing on it casts onto it. That needs `lights: true`, which is what
+ * makes the renderer populate `directionalShadowMap`, `directionalShadowMatrix`
+ * and `directionalLightShadows`, and it needs those uniform blocks merged in from
+ * `UniformsLib`. drei's helper builds neither. Everything else about the
+ * convention is kept: `u_`-prefixed uniforms, a typed Uniforms interface, a
+ * defaults export, `/* glsl *\/` template strings, `extend()` and the
+ * `ThreeElements` augmentation, so it is consumed as a JSX element like the rest.
+ *
+ * ## Two shadow systems, deliberately
+ *
+ * - **Terrain on terrain** is an analytic march down the sun vector, in
+ *   `terrainSunShadow`. A 2048 shadow map stretched across 25 km is 12 m per
+ *   texel, so a ridge shadow would be a staircase; the march has no resolution to
+ *   run out of and costs a fixed handful of coarse height samples.
+ * - **Objects on terrain** is three's ordinary shadow map, through
+ *   `getShadowMask()`. That one is sized for objects and is correct for them.
+ *
+ * The terrain does not cast INTO that map. The sun's shadow camera is framed
+ * around the scene's objects, and pushing a 25 km surface through it would waste
+ * the whole map to produce a mountain shadow one texel wide. See the terrain doc
+ * for what that would take.
+ */
+const vertex = /* glsl */ `
+#include <common>
+#include <shadowmap_pars_vertex>
+#include <fog_pars_vertex>
+
+// three's <common> already supplies PI and saturate. cloudCommon must NOT be
+// included beside it: redefining PI with a different literal is a compile error,
+// which is why the sky helpers are pulled in without it.
+${skyLib}
+${terrainFull}
+
+/** World size of this vertex's cell. Per-vertex rather than per-mesh so one
+ *  material serves every clipmap ring. */
+attribute float aCell;
+/** 0 in the body of a ring, ramping to 1 across its outer band. */
+attribute float aMorph;
+/** Offset from this vertex to its parent-grid neighbour. Zero on even indices. */
+attribute vec2 aCoarse;
+
+varying vec3  vWorld;
+varying float vCell;
+varying float vDist;
+varying float vShadow;
+
+void main(){
+  // Geomorph. Across the outer band of each ring, odd vertices slide onto their
+  // even neighbours, so by the ring boundary the edge polyline is EXACTLY the
+  // coarser ring's edge polyline. That is what removes the T-junction cracks
+  // between levels, and it removes the pop at the same time: the transition is
+  // continuous rather than a swap.
+  vec2 local = position.xz + aCoarse * aMorph;
+
+  // The mesh carries translation only - the clipmap follows the camera and has no
+  // orientation of its own - so a local Y offset is a world Y offset, and the
+  // height field can be sampled directly in world XZ.
+  vec3 flatPos = vec3(local.x, 0.0, local.y);
+  vec2 wxz = (modelMatrix * vec4(flatPos, 1.0)).xz;
+
+  // The LOD cell morphs with the vertex. Level l's outer edge ends up sampling at
+  // 2 x its own cell, which is exactly level l+1's cell at its inner edge - so the
+  // two rings agree on the height at the seam. Without this the geomorph closes the
+  // T-junction and the octave cut-off reopens it as a one-pixel crack.
+  float cellLod = aCell * (1.0 + aMorph);
+
+  vec2 grad;
+  float h = terrainSample(wxz, cellLod, grad);
+
+  // The cast shadow, marched HERE rather than per fragment.
+  //
+  // This was the single most expensive thing in the renderer: up to twenty height
+  // evaluations on every shaded pixel. Per vertex it is two orders of magnitude
+  // cheaper and looks all but identical, because what it produces is a soft
+  // occlusion factor that interpolates cleanly - and because the terminator does
+  // not come from here. terrainLight takes N.L from the fragment's own analytic
+  // normal, so the lit/unlit edge stays per-pixel and only the cast shadow is
+  // interpolated. Coarse rings march at their own cell size, so distant rings run
+  // fewer octaves per step as well as fewer vertices.
+  vec3 wp = vec3(wxz.x, h, wxz.y);
+  float camDist = distance(wp, cameraPosition);
+  vShadow = terrainShadowAt(wp, terrainNormal(grad), cellLod, camDist);
+
+  // Planetary curvature, applied here and ONLY here. It is a view-relative bend,
+  // so folding it into the height field would make the ground move when the
+  // camera does - and the shadow march samples that same field.
+  vec2 fromCam = wxz - cameraPosition.xz;
+  float drop = u_curvature * dot(fromCam, fromCam);
+
+  vec3 transformed = vec3(local.x, h - drop, local.y);
+
+  // Up is close enough for the shadow-map normal bias; the real normal is
+  // computed per fragment, and this only nudges the depth lookup.
+  vec3 objectNormal = vec3(0.0, 1.0, 0.0);
+  vec3 transformedNormal = normalMatrix * objectNormal;
+
+  vWorld = vec3(wxz.x, h, wxz.y);
+  vCell = cellLod;
+  vDist = length(vec3(wxz.x, h - drop, wxz.y) - cameraPosition);
+
+  vec4 mvPosition = modelViewMatrix * vec4(transformed, 1.0);
+  gl_Position = projectionMatrix * mvPosition;
+
+  #include <worldpos_vertex>
+  #include <shadowmap_vertex>
+  #include <fog_vertex>
+}
+`;
+const fragment = /* glsl */ `
+#include <common>
+#include <packing>
+#include <fog_pars_fragment>
+// lights_pars_begin is what declares the bool uniform receiveShadow, which
+// shadowmask_pars_fragment reads. Include the shadow chunks without it and the
+// fragment shader fails with 'undeclared identifier: receiveShadow' - the
+// material then renders black with nothing but a console error to say why.
+#include <lights_pars_begin>
+#include <shadowmap_pars_fragment>
+#include <shadowmask_pars_fragment>
+
+${skyLib}
+${terrainFull}
+
+uniform float u_receiveShadows;
+
+varying vec3  vWorld;
+varying float vCell;
+varying float vDist;
+varying float vShadow;
+
+void main(){
+  vec3 viewDir = normalize(vWorld - cameraPosition);
+
+  // The shading footprint. Finer than the mesh cell, because a ridge 5 km out
+  // lands on a 256 m clipmap cell but still covers only a few pixels - clamping
+  // to vCell is what makes distant terrain read as a smooth dome however many
+  // octaves are configured. But not arbitrarily finer either: a pixel lands on
+  // the flat triangle, so the world XZ it reports is a point on that
+  // approximation rather than on the true surface, and shading a field far finer
+  // than the mesh turns that parallax error into chevrons along every triangle
+  // edge. A quarter of the mesh cell keeps most of the detail and stays inside
+  // the error the mesh already has.
+  float lod = max(max(u_cellSize, vCell * 0.25), vDist * 0.0015);
+
+  // ONE height evaluation. The gradient comes back with it, so the normal is free
+  // - a central difference would need four more, and this shader used to pay for
+  // them on every pixel.
+  vec2 grad;
+  float shadeHeight = terrainSample(vWorld.xz, lod, grad);
+  vec3 n = terrainNormal(grad);
+  n = terrainDetailNormal(n, vWorld, vDist);
+
+  // Shade against the analytically evaluated surface, not the interpolated mesh
+  // vertex. The mesh is a coarse approximation of this field and its height is
+  // piecewise linear, so splatting off it draws every threshold along triangle
+  // edges.
+  vec3 surface = vec3(vWorld.x, shadeHeight, vWorld.z);
+
+  // Slope as a fraction of vertical, not as 1 - n.y. The naive form is badly
+  // compressed at the angles that matter - a 30 degree hillside reads 0.13 and a
+  // 45 degree one 0.29 - so every slope threshold ends up crowded into the top of
+  // its range and rock never appears where it should. This way 0.5 IS 45 degrees.
+  float slope = acos(clamp(n.y, -1.0, 1.0)) * 0.6366197724;
+  float h01 = saturate((shadeHeight - u_seaLevel) / max(u_elevation, 1e-3));
+
+  vec3 albedo = terrainAlbedo(surface, h01, slope);
+
+  float selfShadow = mix(1.0, saturate(vShadow), saturate(u_sunShadow));
+
+  float sceneShadow = 1.0;
+  #ifdef USE_SHADOWMAP
+    sceneShadow = mix(1.0, getShadowMask(), u_receiveShadows);
+  #endif
+
+  vec3 col = terrainLight(albedo, n, viewDir, selfShadow, sceneShadow);
+  col = terrainAerial(col, viewDir, vDist, shadeHeight);
+  col *= u_exposure;
+
+  gl_FragColor = vec4(col, 1.0);
+
+  #include <tonemapping_fragment>
+  #include <colorspace_fragment>
+  #include <fog_fragment>
+}
+`;
+/** Uniform-space defaults. Config units are converted by `applyTerrainUniforms`;
+ *  these are only what the material holds before anything is applied. */
+export const terrainMaterialDefaults = {
+    u_terrainType: 2,
+    u_elevation: 180,
+    u_seaLevel: 0,
+    u_baseScale: 1 / 2600,
+    u_octaves: 8,
+    u_lacunarity: 2.06,
+    u_gain: 0.46,
+    u_ridge: 0.05,
+    u_warpStrength: 0.35,
+    u_warpScale: 0.6,
+    u_erosion: 0.45,
+    u_terraces: 0,
+    u_terraceSharp: 0.6,
+    u_bearingDir: new THREE.Vector2(0.978, 0.208),
+    u_duneFreq: (2 * Math.PI) / 340,
+    u_duneAsym: 0.62,
+    u_plateau: 0,
+    u_valleyDepth: 0,
+    u_valleyWidth: 0.25,
+    u_cellSize: 2,
+    u_curvature: 1 / (2 * 6371000),
+    u_lowColor: new THREE.Color('#3f5326'),
+    u_midColor: new THREE.Color('#55663a'),
+    u_rockColor: new THREE.Color('#7a7266'),
+    u_peakColor: new THREE.Color('#8d9a6a'),
+    u_slopeRockStart: 0.5,
+    u_slopeRockEnd: 0.78,
+    u_peakLevel: 0.78,
+    u_peakBlend: 0.2,
+    u_peakSlopeFalloff: 1.4,
+    u_macroVariation: 0.3,
+    u_macroScale: 1 / 1400,
+    u_detailStrength: 0.5,
+    u_detailScale: 1 / 6,
+    u_detailFade: 1 / 900,
+    u_roughness: 0.9,
+    u_specular: 0.03,
+    u_ambient: 1,
+    u_bounce: 0.35,
+    u_sunShadow: 1,
+    u_shadowSoftness: 12,
+    u_shadowDistance: 5000,
+    u_fogDensity: 0.000028,
+    u_exposure: 1,
+    u_shadowSteps: 20,
+    u_receiveShadows: 1,
+    // Shared with the cloud materials, and set by the same applySunUniforms().
+    u_sunDir: new THREE.Vector3(0.35, 0.42, 0.84).normalize(),
+    u_sunColor: new THREE.Color(1, 1, 1),
+    // Set by applySunUniforms from useCloudSun, same as the clouds. Constant per
+    // frame, so the shader reads them instead of calling skyRadiance per pixel.
+    u_skyAmbient: new THREE.Color(0.6, 0.9, 1.6),
+    u_groundAmbient: new THREE.Color(0.45, 0.42, 0.37),
+    u_sunIntensity: 1,
+    u_turbidity: 2,
+    u_rayleigh: 1,
+    u_mieCoefficient: 0.005,
+    u_mieG: 0.76,
+};
+function buildUniforms() {
+    const own = {};
+    for (const [key, value] of Object.entries(terrainMaterialDefaults)) {
+        own[key] = { value };
+    }
+    return THREE.UniformsUtils.merge([
+        THREE.UniformsLib.lights,
+        THREE.UniformsLib.fog,
+        own,
+    ]);
+}
+/**
+ * `UniformsUtils.merge` clones by `Uniform.clone()`, which deep-copies Colors and
+ * Vectors but turns a plain object into a shallow copy — fine here, since every
+ * own uniform is a number, Color or Vector. The lights block must come first so
+ * a name collision would resolve to ours; there are none, because everything of
+ * ours is `u_`-prefixed.
+ */
+export class TerrainMaterial extends THREE.ShaderMaterial {
+    constructor() {
+        super({
+            uniforms: buildUniforms(),
+            vertexShader: vertex,
+            fragmentShader: fragment,
+            lights: true,
+            fog: true,
+        });
+        this.side = THREE.FrontSide;
+    }
+}
+extend({ TerrainMaterial });

package/dist/types/cloudConfigs.d.ts

@@ -0,0 +1,244 @@
+/**
+ * Config shapes for the volumetric cloud system that lives in this package.
+ *
+ * Declared locally rather than in `@3driseai/3drise-core`, alongside
+ * `gridConfigs.ts`, because the materials and the renderer are here and nothing
+ * outside the viewer needs to construct these by hand.
+ *
+ * A sky is a deck PLUS an optional ice layer, not one of four things — cirrus
+ * coexists with every other type in nature and in the renderer. So a cloud
+ * settings object carries two independent layer blocks.
+ */
+/** The three types the volumetric marcher renders. Cirrus has its own model. */
+export type CloudDeckType = 'cumulus' | 'stratocumulus' | 'cumulonimbus';
+/** Fields every deck shares, whatever its vertical profile. */
+export interface CloudDeckSurfaceConfig {
+    enabled: boolean;
+    /** Fraction of sky the deck occupies. The threshold window slides and narrows,
+     *  so 1.0 really is overcast rather than the ~0.5 a naive remap tops out at. */
+    coverage: number;
+    /** Multiplies the density field. Aim for optical depth 4-6 through a core;
+     *  past ~10 the multi-scatter octaves stop lifting the interior and it muddies. */
+    density: number;
+    /** Blends the three archetypal vertical profiles: 0 stratus, 0.5 cumulus,
+     *  1 cumulonimbus. The weather map biases it +/-0.15 per cell, so one sky
+     *  holds a spread of shapes rather than one repeated silhouette. */
+    profile: number;
+    /** Cloud base, in world units. */
+    baseAltitude: number;
+    /** Cloud top. Also sets the march's fine step, which is derived from depth
+     *  rather than from ray length — halving the depth roughly halves the cost. */
+    topAltitude: number;
+    /** Size of the primary cauliflower lobes, in world units. */
+    featureSize: number;
+    /** Size of the erosion detail that breaks up edges. Below ~2x the march step
+     *  this beats against the sampling and the far field speckles. */
+    detailSize: number;
+    /** How deeply the detail volume eats into the base shape. */
+    detailStrength: number;
+    /** Divergence-free warp on the erosion, strongest at the base where a cloud
+     *  shears out into wisps. */
+    curlStrength: number;
+    /** Size of the coverage cells that decide where clouds are at all. Too large
+     *  and a whole viewport sits inside one cell. */
+    weatherCellSize: number;
+    /** Downwind displacement per unit height — tilts the column so the top leads
+     *  the base, as it does under real shear. */
+    shear: number;
+    /** Lateral coverage growth above 70% height. Gated on profile, so a
+     *  fair-weather cumulus can never grow an anvil. */
+    anvil: number;
+    /** Drops scattering albedo toward the base. Large rain drops absorb far more
+     *  than small droplets, which is why a storm base is charcoal while its top
+     *  is white — extinction alone will not do it. */
+    precipitation: number;
+    /** Wind bearing in degrees. Drives advection, shear and the cirrus streak axis. */
+    windBearing: number;
+    windSpeed: number;
+    /** Vertical motion of the shape volume. Decoupling it from wind is what makes
+     *  clouds boil rather than slide. */
+    rise: number;
+    /** Independent vertical motion of the erosion layer — the third timescale. */
+    churn: number;
+    /** Slow oscillation of the coverage threshold. Cells genuinely appear and
+     *  dissipate rather than only drifting past. */
+    evolution: number;
+    /** Extinction coefficient, per world unit. Physically ~0.045 for cloud, but a
+     *  3-octave scattering approximation cannot carry that optical depth, so it is
+     *  tuned down and density scaled up to match. */
+    extinction: number;
+    /** Anisotropy of the forward Henyey-Greenstein lobe. This is the silver lining. */
+    forwardLobe: number;
+    /** Anisotropy of the small backward lobe. The glow when the sun is behind you. */
+    backLobe: number;
+    /** Per-octave extinction / energy / anisotropy scale in the multiple-scattering
+     *  approximation. Drop `msEnergy` to 0.15 and the cloud collapses to the flat
+     *  black of a single-scatter implementation. */
+    msExtinction: number;
+    msEnergy: number;
+    msPhase: number;
+    /** Dark-edge term. Applied only when looking away from the sun, or it
+     *  double-darkens the backlit rims that should be brightest. */
+    powder: number;
+    /** Extra forward-scatter boost near the sun disc, on top of the phase function. */
+    silverLining: number;
+    /** Weight of sky-above and ground-bounce fill. Too high and the cloud goes
+     *  flat; too low and shadowed sides crush to black. */
+    ambient: number;
+    /** Rate at which distant cloud fades into the sky it is seen through. The main
+     *  cue for how large the sky reads. */
+    aerialPerspective: number;
+}
+/**
+ * The deck, as the animation system sees it.
+ *
+ * `type` is 'clouds' — the OBJECT type — because that is the discriminant
+ * getAnimatableProperties() and detectAnimatableDomain() route on, exactly like
+ * light and rain configs. The meteorological model is `deckType`, which is what
+ * CloudsGenerator switches on. Collapsing the two onto one field would make the
+ * deck invisible to the keyframe and mouse-move panels.
+ */
+export type CloudDeckConfig = CloudDeckSurfaceConfig & {
+    type: 'clouds';
+    deckType: CloudDeckType;
+    /** Name of the preset the numbers came from, or '' once any of them is edited.
+     *  Purely a UI bookmark — the renderer never reads it. */
+    preset?: string;
+};
+/**
+ * High ice cloud. Not a volume: three samples through a thin slab, stretched hard
+ * along the shear vector, lit by a near-pure forward lobe.
+ */
+export interface CirrusLayerConfig {
+    enabled: boolean;
+    altitude: number;
+    thickness: number;
+    coverage: number;
+    /** Calibrated so 1.0 gives vertical optical depth around 0.5 — cirrus you can
+     *  see the sun through, which is the point. */
+    opticalDepth: number;
+    featureSize: number;
+    /** Compression along the wind axis. 1.0 gives round blobs; 0.1 gives the
+     *  drawn-out fibratus streaks cirrus is recognised by. */
+    anisotropy: number;
+    windBearing: number;
+    windSpeed: number;
+    /** Refraction minimum of a 60-degree hexagonal ice prism, visible within a few
+     *  degrees of 22 from the sun. The strongest single cue that this is ice. */
+    halo: number;
+    forwardLobe: number;
+    secondaryLobe: number;
+    ambient: number;
+    aerialPerspective: number;
+    /** Name of the preset the numbers came from, or '' once any of them is edited. */
+    preset?: string;
+}
+/** Cost knobs. Shared by both layers, since they share the pipeline. */
+export interface CloudsQualityConfig {
+    /** Fraction of full resolution the march runs at. 0.5 is the sweet spot. */
+    resolutionScale: number;
+    /** History weight when the camera is still. Higher converges further, ghosts more. */
+    temporalBlend: number;
+    /** Sets the fine step as depth/steps*2. Empty space is skipped 2.8x coarser
+     *  regardless, so this costs less than the number suggests. */
+    steps: number;
+    /** Samples toward the sun per shaded point, spread inside a cone so
+     *  self-shadowing is soft rather than banded. */
+    lightSteps: number;
+    /** First shadow step as a fraction of cloud depth, growing 1.62x each sample.
+     *  A fraction, not world units, so one value works for a shallow deck and a
+     *  9 km tower alike. */
+    lightStep: number;
+    /** Step size as a fraction of distance — the actual meaning of "constant
+     *  screen-space error". A near-horizontal ray can span a hundred kilometres
+     *  inside the deck; a fixed step exhausts the budget and the deck stops along a
+     *  straight line short of the horizon. */
+    stepGrowth: number;
+    /** Hard cap on how far one ray marches. Aerial perspective should hide the
+     *  cut-off before it is reached. */
+    maxSpan: number;
+    /** Distance over which high-frequency erosion fades out. Removes far-field
+     *  speckle and buys back most of its own cost. */
+    detailFadeDistance: number;
+    /** 1/(2R). Bends the ray so the deck meets a real horizon instead of running to
+     *  infinity as a flat slab would. Zero gives a flat deck. */
+    curvature: number;
+    exposure: number;
+    /** Set false when something downstream will tonemap instead. */
+    tonemap: boolean;
+}
+export declare const defaultCumulusConfig: CloudDeckConfig;
+export declare const defaultStratocumulusConfig: CloudDeckConfig;
+export declare const defaultCumulonimbusConfig: CloudDeckConfig;
+export declare const defaultCirrusConfig: CirrusLayerConfig;
+export declare const defaultCloudsQuality: CloudsQualityConfig;
+/** Per-type deck defaults, for the controller's type switcher. */
+export declare const CLOUD_DECK_DEFAULTS: Record<CloudDeckType, CloudDeckConfig>;
+export type CloudPropertyGroup = 'shape' | 'animation' | 'scattering' | 'lighting' | 'quality';
+/**
+ * Everything the controller needs to build a row and everything the AI context
+ * builder needs to know what a knob does and where it is safe. The runtime never
+ * reads this — defaults live in the config objects above.
+ */
+export interface CloudPropertySchema {
+    key: string;
+    label: string;
+    group: CloudPropertyGroup;
+    min?: number;
+    max?: number;
+    step?: number;
+    unit?: string;
+    description: string;
+    advanced?: boolean;
+    /** Only show for these deck types. Absent means all. */
+    types?: CloudDeckType[];
+}
+export declare const CLOUD_DECK_SCHEMA: CloudPropertySchema[];
+export declare const CIRRUS_SCHEMA: CloudPropertySchema[];
+export declare const CLOUD_QUALITY_SCHEMA: CloudPropertySchema[];
+import type { ObjectAnimations, MouseMoveInteractions } from '@3driseai/3drise-core';
+/**
+ * A sky, as stored. Two independent layers, because that is what a sky is:
+ * a deck, and an ice layer that coexists with any deck.
+ *
+ * There is deliberately no `meshSettings` and no `materialSettings`. A layer has
+ * no transform — altitude and thickness are config, not position — and its
+ * material is not swappable, so the Transform and Material tabs do not apply.
+ * `animations` and `mouseMove` reuse the existing `clouds` domain, so
+ * AminationsPanel and MouseMoveManagerPanel work unchanged.
+ */
+export interface VolumetricCloudsSettings {
+    id: string;
+    type: 'clouds';
+    /** The convective / stratiform deck. Named `config` because that is where the
+     *  animation and mouse-move systems look for an object's animatable domain. */
+    config: CloudDeckConfig;
+    /** High ice layer. Independent — it sits above whatever the deck is doing. */
+    cirrus: CirrusLayerConfig;
+    quality: CloudsQualityConfig;
+    /** Per-domain keyframe animations; the `clouds` domain drives deck properties. */
+    animations?: ObjectAnimations;
+    /** Per-domain mouse-move interactions; same `clouds` domain. */
+    mouseMove?: MouseMoveInteractions;
+}
+export declare const defaultVolumetricCloudsSettings: VolumetricCloudsSettings;
+/**
+ * Deck properties the `clouds` animation and mouse-move domains may target.
+ * Everything here is a scalar that can be interpolated per frame without
+ * rebuilding anything — altitudes and feature sizes are deliberately excluded,
+ * since changing them mid-animation restretches the whole density field.
+ */
+export declare const CLOUD_ANIMATABLE_PROPERTIES: readonly ["coverage", "density", "profile", "detailStrength", "curlStrength", "shear", "anvil", "precipitation", "windBearing", "windSpeed", "rise", "churn", "evolution", "extinction", "powder", "silverLining", "ambient"];
+export type CloudAnimatableProperty = (typeof CLOUD_ANIMATABLE_PROPERTIES)[number];
+/** Deck block merged over its type's defaults. Returns null when there is no deck
+ *  to render — including the retired flat CloudsSettings shape, which has no
+ *  `config` and should draw nothing rather than half a sky. */
+export declare function normalizeCloudDeck(raw: unknown): CloudDeckConfig | null;
+/** Cirrus block merged over its defaults, or null when the scene has no cirrus
+ *  block at all. Null rather than the defaults, because `defaultCirrusConfig` is
+ *  enabled: a project saved before this layer existed must not gain an ice sheet
+ *  it was never authored with. A block that exists but omits `enabled` is a
+ *  deliberate one and takes the default. */
+export declare function normalizeCirrus(raw: unknown): CirrusLayerConfig | null;
+export declare function normalizeCloudQuality(raw: unknown): CloudsQualityConfig;
+//# sourceMappingURL=cloudConfigs.d.ts.map

package/dist/types/cloudConfigs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloudConfigs.d.ts","sourceRoot":"","sources":["../../src/types/cloudConfigs.ts"],"names":[],"mappings":"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"}