@forgeax/engine-render 0.1.32 → 0.1.34

package/dist/{chunk-GWCEMDVR.mjs → chunk-UINHLCZA.mjs}

@@ -1,7 +1,7 @@
-import { RenderIntentInvalidError, DynamicResolutionRequiresTaaError, ShadowInvalidConfigError, VolumeOwnerConflictError, VolumeDensityShapeMismatchError, VolumeInvalidBoundsError, VolumeInvalidParametersError, DynamicResolutionInvalidParameterError } from './chunk-6TFBXLRJ.mjs';
-import { defineComponent, Entity } from '@forgeax/engine-ecs';
-import { TONEMAP_SHADER_MODE } from '@forgeax/engine-shader';
+import { RenderIntentInvalidError, DynamicResolutionRequiresTaaError, ShadowInvalidConfigError, VolumeDensityShapeMismatchError, VolumeInvalidBoundsError, VolumeInvalidParametersError, EnvironmentSourceConflictError, FogCardinalityError, VolumeOwnerConflictError, BarrelDistortionInvalidParameterError, DynamicResolutionInvalidParameterError, AtmosphereInvalidParameterError } from './chunk-WEX45HKH.mjs';
+import { defineComponent, Entity, Time } from '@forgeax/engine-ecs';
 import { R_MIN, err, ok } from '@forgeax/engine-types';
+import { TONEMAP_SHADER_MODE } from '@forgeax/engine-shader';
 import { SpawnLightInvalidBoundsError } from '@forgeax/engine-ecs/projection';
 import { Transform, projectHierarchy } from '@forgeax/engine-scene';
 import { mat4 } from '@forgeax/engine-math';
@@ -11,8 +11,41 @@ var Atmosphere = defineComponent("Atmosphere", {
   rayleigh: { type: "f32", default: 1 },
   mieCoefficient: { type: "f32", default: 5e-3 },
   mieDirectionalG: { type: "f32", default: 0.8 },
-  sunAngularRadius: { type: "f32", default: 4675e-6 }
+  sunAngularRadius: { type: "f32", default: 4675e-6 },
+  /** Independent multiplier for the analytic circumsolar lobe. */
+  circumsolarStrength: { type: "f32", default: 1 },
+  /** Relative angular width of the analytic circumsolar lobe. */
+  circumsolarWidth: { type: "f32", default: 1 }
+});
+var BarrelDistortion = defineComponent("BarrelDistortion", {
+  strength: { type: "f32", default: 0 },
+  centerX: { type: "f32", default: 0.5 },
+  centerY: { type: "f32", default: 0.5 }
+});
+var DEFAULT_BARREL_DISTORTION = Object.freeze({
+  strength: 0,
+  centerX: 0.5,
+  centerY: 0.5
 });
+function invalid(field, value, expected) {
+  return new BarrelDistortionInvalidParameterError({ field, value, expected });
+}
+function validateBarrelDistortionParameters(input) {
+  const value = input ?? {};
+  const strength = value.strength ?? DEFAULT_BARREL_DISTORTION.strength;
+  const centerX = value.centerX ?? DEFAULT_BARREL_DISTORTION.centerX;
+  const centerY = value.centerY ?? DEFAULT_BARREL_DISTORTION.centerY;
+  if (!Number.isFinite(strength) || strength < 0 || strength > 0.35) {
+    return err(invalid("strength", strength, "finite and in [0, 0.35]"));
+  }
+  if (!Number.isFinite(centerX) || centerX < 0 || centerX > 1) {
+    return err(invalid("centerX", centerX, "finite and in [0, 1]"));
+  }
+  if (!Number.isFinite(centerY) || centerY < 0 || centerY > 1) {
+    return err(invalid("centerY", centerY, "finite and in [0, 1]"));
+  }
+  return ok(Object.freeze({ strength, centerX, centerY }));
+}
 var CAMERA_PROJECTION_PERSPECTIVE = 0;
 var CAMERA_PROJECTION_ORTHOGRAPHIC = 1;
 var CAMERA_EXPOSURE_MODE_MANUAL = 0;
@@ -199,6 +232,14 @@ function antialiasFromF32(value) {
 }
 var BLOOM_DISABLED = 0;
 var BLOOM_ENABLED = 1;
+var CAMERA_BLOOM_INTENSITY_MIN = 0;
+var CAMERA_BLOOM_INTENSITY_MAX = 8;
+var CAMERA_BLOOM_THRESHOLD_MIN = 0;
+var CAMERA_BLOOM_THRESHOLD_MAX = 65504;
+var CAMERA_BLOOM_SOFT_KNEE_MIN = 0;
+var CAMERA_BLOOM_SOFT_KNEE_MAX = 1;
+var CAMERA_BLOOM_SCATTER_MIN = 0;
+var CAMERA_BLOOM_SCATTER_MAX = 0.95;
 function bloomEnabledFromF32(value) {
   if (value === BLOOM_DISABLED) return "off";
   if (value === BLOOM_ENABLED) return "on";
@@ -210,6 +251,40 @@ function bloomEnabledFromF32(value) {
     "select Camera bloom off or on"
   );
 }
+function validateBloomRange(field, value, min, max) {
+  if (!Number.isFinite(value) || value < min || value > max) {
+    throw cameraError(
+      "camera-bloom-invalid",
+      field,
+      value,
+      `a finite value in [${min}, ${max}]`,
+      `set Camera.${field} to a finite value in [${min}, ${max}]`
+    );
+  }
+}
+function validateCameraBloom(bloom, threshold, intensity, softKnee, scatter) {
+  const enabled = bloomEnabledFromF32(bloom);
+  validateBloomRange(
+    "bloomThreshold",
+    threshold,
+    CAMERA_BLOOM_THRESHOLD_MIN,
+    CAMERA_BLOOM_THRESHOLD_MAX
+  );
+  validateBloomRange(
+    "bloomIntensity",
+    intensity,
+    CAMERA_BLOOM_INTENSITY_MIN,
+    CAMERA_BLOOM_INTENSITY_MAX
+  );
+  validateBloomRange(
+    "bloomSoftKnee",
+    softKnee,
+    CAMERA_BLOOM_SOFT_KNEE_MIN,
+    CAMERA_BLOOM_SOFT_KNEE_MAX
+  );
+  validateBloomRange("bloomScatter", scatter, CAMERA_BLOOM_SCATTER_MIN, CAMERA_BLOOM_SCATTER_MAX);
+  return enabled;
+}
 var Camera = defineComponent("Camera", {
   fov: { type: "f32" },
   aspect: { type: "f32" },
@@ -236,7 +311,8 @@ var Camera = defineComponent("Camera", {
   bloom: { type: "f32", default: 0 },
   bloomThreshold: { type: "f32", default: 1 },
   bloomIntensity: { type: "f32", default: 1 },
-  bloomBlurRadius: { type: "f32", default: 4 },
+  bloomSoftKnee: { type: "f32", default: 0.5 },
+  bloomScatter: { type: "f32", default: 0.7 },
   // M1 target camera role: zero means this camera is eligible for display;
   // non-zero shared targets are auxiliary producers whose views and receipt
   // promotion remain owned by Renderer.
@@ -356,6 +432,37 @@ function orthographic(opts) {
     ...cameraColorGradingColumns(opts)
   };
 }
+var CloudQualityValue = Object.freeze({
+  low: 0,
+  medium: 1,
+  high: 2
+});
+var CloudLayer = defineComponent("CloudLayer", {
+  /** Stable integer seed for the periodic 3D density field. */
+  seed: { type: "u32", default: 1337 },
+  /** World-space lower edge of the layer, in metres. */
+  baseHeight: { type: "f32", default: 120 },
+  /** World-space thickness of the layer, in metres. */
+  thickness: { type: "f32", default: 80 },
+  /** Horizontal noise scale, in cycles per metre. */
+  scale: { type: "f32", default: 4e-3 },
+  /** Coverage threshold in [0, 1]. */
+  coverage: { type: "f32", default: 0.48 },
+  /** Extinction multiplier in inverse metres. */
+  density: { type: "f32", default: 1 },
+  /** World-space wind velocity in metres per second. */
+  wind: { type: "array<f32, 3>", default: new Float32Array([8, 0, 2]) },
+  /** Quality controls cache resolution and bounded ray steps. */
+  quality: { type: "f32", default: CloudQualityValue.medium },
+  /** Maximum world-space distance represented by the light-space shadow map. */
+  shadowRange: { type: "f32", default: 512 }
+});
+function cloudQualityFromF32(value) {
+  if (value === CloudQualityValue.low) return "low";
+  if (value === CloudQualityValue.medium) return "medium";
+  if (value === CloudQualityValue.high) return "high";
+  return void 0;
+}
 var CUBE_CAMERA_UPDATE_ONCE = 0;
 var CUBE_CAMERA_UPDATE_ON_DEMAND = 1;
 var CUBE_CAMERA_UPDATE_CONTINUOUS = 2;
@@ -496,7 +603,7 @@ var DEFAULT_DYNAMIC_RESOLUTION = Object.freeze({
   minScale: 0.67,
   maxScale: 1
 });
-function invalid(field, value, expected) {
+function invalid2(field, value, expected) {
   return new DynamicResolutionInvalidParameterError({ field, value, expected });
 }
 function validateDynamicResolutionParameters(input) {
@@ -505,16 +612,16 @@ function validateDynamicResolutionParameters(input) {
   const minScale = value.minScale ?? DEFAULT_DYNAMIC_RESOLUTION.minScale;
   const maxScale = value.maxScale ?? DEFAULT_DYNAMIC_RESOLUTION.maxScale;
   if (!Number.isFinite(targetGpuMs) || targetGpuMs <= 0) {
-    return err(invalid("targetGpuMs", targetGpuMs, "finite and greater than 0"));
+    return err(invalid2("targetGpuMs", targetGpuMs, "finite and greater than 0"));
   }
   if (!Number.isFinite(minScale) || minScale < 0.5 || minScale > 1) {
-    return err(invalid("minScale", minScale, "finite and in [0.5, 1.0]"));
+    return err(invalid2("minScale", minScale, "finite and in [0.5, 1.0]"));
   }
   if (!Number.isFinite(maxScale) || maxScale < 0.5 || maxScale > 1) {
-    return err(invalid("maxScale", maxScale, "finite and in [0.5, 1.0]"));
+    return err(invalid2("maxScale", maxScale, "finite and in [0.5, 1.0]"));
   }
   if (minScale > maxScale) {
-    return err(invalid("minScale", minScale, "less than or equal to maxScale"));
+    return err(invalid2("minScale", minScale, "less than or equal to maxScale"));
   }
   return ok(Object.freeze({ targetGpuMs, minScale, maxScale }));
 }
@@ -534,7 +641,7 @@ var Fog = defineComponent("Fog", {
   maxOpacity: { type: "f32", default: 1 }
 });
 var Instances = defineComponent("Instances", {
-  collectionId: { type: "u32", default: 0 }
+  transforms: { type: "array<f32>" }
 });
 var Layer = defineComponent("Layer", {
   value: { type: "i32", default: 0 }
@@ -777,7 +884,8 @@ var MeshRenderer = defineComponent("MeshRenderer", {
 var MotionBlur = defineComponent("MotionBlur", {
   shutterAngle: { type: "f32", default: 180 },
   maxRadiusPixels: { type: "f32", default: 32 },
-  sampleCount: { type: "f32", default: 8 }
+  sampleCount: { type: "f32", default: 8 },
+  targetFps: { type: "f32", default: 60 }
 });
 var PointLight = defineComponent("PointLight", {
   // color carries an explicit layer-2 default [1,1,1] (white); the array
@@ -973,6 +1081,576 @@ var Visibility = defineComponent(
     }
   }
 );
+var COMPUTED_UV_BOUNDARY_EPSILON = Number.EPSILON * 16;
+function freezeBarrelDistortionMapping(mapping) {
+  const camera = mapping.camera;
+  return Object.freeze({
+    ...mapping,
+    ...camera === void 0 ? {} : {
+      camera: Object.freeze({
+        projection: camera.projection,
+        far: camera.far,
+        viewMatrix: Object.freeze(Array.from(camera.viewMatrix)),
+        projectionMatrix: Object.freeze(Array.from(camera.projectionMatrix))
+      })
+    }
+  });
+}
+function attachBarrelDistortionCameraFrame(mapping, camera) {
+  return freezeBarrelDistortionMapping({
+    ...mapping,
+    camera: {
+      projection: camera.projection,
+      far: camera.far,
+      viewMatrix: camera.viewMatrix,
+      projectionMatrix: camera.projectionMatrix
+    }
+  });
+}
+function invalidExtent(field, value) {
+  return new BarrelDistortionInvalidParameterError({
+    field,
+    value,
+    expected: "finite and greater than 0"
+  });
+}
+function createBarrelDistortionMapping(width, height, input) {
+  if (!Number.isFinite(width) || width <= 0) return err(invalidExtent("width", width));
+  if (!Number.isFinite(height) || height <= 0) return err(invalidExtent("height", height));
+  const parameters = validateBarrelDistortionParameters(input);
+  if (!parameters.ok) return parameters;
+  const { strength, centerX, centerY } = parameters.value;
+  const aspect = width / height;
+  const radiusSquared = 4 * (aspect * aspect * Math.max(centerX, 1 - centerX) ** 2 + Math.max(centerY, 1 - centerY) ** 2);
+  return ok(
+    Object.freeze({
+      width,
+      height,
+      aspect,
+      strength,
+      centerX,
+      centerY,
+      radiusSquared
+    })
+  );
+}
+function displayToSceneScale(mapping, ux, uy) {
+  const px = 2 * mapping.aspect * (ux - mapping.centerX);
+  const py = 2 * (uy - mapping.centerY);
+  const t = (px * px + py * py) / mapping.radiusSquared;
+  return (1 - mapping.strength) / (1 - mapping.strength * t);
+}
+function normalizeComputedUv(out, x, y) {
+  if (!Number.isFinite(x) || !Number.isFinite(y)) return false;
+  if (x < -COMPUTED_UV_BOUNDARY_EPSILON || x > 1 + COMPUTED_UV_BOUNDARY_EPSILON || y < -COMPUTED_UV_BOUNDARY_EPSILON || y > 1 + COMPUTED_UV_BOUNDARY_EPSILON) {
+    return false;
+  }
+  out.x = Math.min(1, Math.max(0, x));
+  out.y = Math.min(1, Math.max(0, y));
+  return true;
+}
+function mapDisplayUvToSceneUv(out, mapping, ux, uy) {
+  if (!Number.isFinite(ux) || !Number.isFinite(uy) || ux < 0 || ux > 1 || uy < 0 || uy > 1)
+    return false;
+  if (mapping.strength === 0) {
+    out.x = ux;
+    out.y = uy;
+    return ux >= 0 && ux <= 1 && uy >= 0 && uy <= 1;
+  }
+  const scale = displayToSceneScale(mapping, ux, uy);
+  return normalizeComputedUv(
+    out,
+    mapping.centerX + (ux - mapping.centerX) * scale,
+    mapping.centerY + (uy - mapping.centerY) * scale
+  );
+}
+function mapSceneUvToDisplayUv(out, mapping, ux, uy) {
+  if (!Number.isFinite(ux) || !Number.isFinite(uy) || ux < 0 || ux > 1 || uy < 0 || uy > 1)
+    return false;
+  if (mapping.strength === 0) {
+    out.x = ux;
+    out.y = uy;
+    return ux >= 0 && ux <= 1 && uy >= 0 && uy <= 1;
+  }
+  const px = 2 * mapping.aspect * (ux - mapping.centerX);
+  const py = 2 * (uy - mapping.centerY);
+  const sourceRadius = Math.hypot(px, py);
+  if (sourceRadius === 0) {
+    out.x = mapping.centerX;
+    out.y = mapping.centerY;
+    return true;
+  }
+  const discriminant = (1 - mapping.strength) ** 2 + 4 * mapping.strength * sourceRadius * sourceRadius / mapping.radiusSquared;
+  const displayRadius = 2 * sourceRadius / (1 - mapping.strength + Math.sqrt(Math.max(0, discriminant)));
+  const scale = displayRadius / sourceRadius;
+  return normalizeComputedUv(
+    out,
+    mapping.centerX + (ux - mapping.centerX) * scale,
+    mapping.centerY + (uy - mapping.centerY) * scale
+  );
+}
+function validPixel(point) {
+  return Number.isFinite(point.x) && Number.isFinite(point.y);
+}
+function mapDisplayToScene(out, mapping, displayX, displayY) {
+  if (!Number.isFinite(displayX) || !Number.isFinite(displayY)) return false;
+  if (displayX < 0 || displayX > mapping.width || displayY < 0 || displayY > mapping.height) {
+    return false;
+  }
+  const scene = { x: 0, y: 0 };
+  if (!mapDisplayUvToSceneUv(scene, mapping, displayX / mapping.width, displayY / mapping.height)) {
+    return false;
+  }
+  out.x = scene.x * mapping.width;
+  out.y = scene.y * mapping.height;
+  return validPixel(out);
+}
+function mapSceneToDisplay(out, mapping, sceneX, sceneY) {
+  if (!Number.isFinite(sceneX) || !Number.isFinite(sceneY)) return false;
+  if (sceneX < 0 || sceneX > mapping.width || sceneY < 0 || sceneY > mapping.height) {
+    return false;
+  }
+  const display = { x: 0, y: 0 };
+  if (!mapSceneUvToDisplayUv(display, mapping, sceneX / mapping.width, sceneY / mapping.height)) {
+    return false;
+  }
+  out.x = display.x * mapping.width;
+  out.y = display.y * mapping.height;
+  return validPixel(out);
+}
+
+// src/errors/cloud.ts
+var CloudLayerInvalidParameterError = class extends Error {
+  code = "cloud-layer-invalid-parameter";
+  expected;
+  hint;
+  detail;
+  constructor(field, value, expected) {
+    super(`CloudLayer.${field} is invalid`);
+    this.name = "CloudLayerInvalidParameterError";
+    this.expected = `CloudLayer.${field} must be ${expected}`;
+    this.hint = `set CloudLayer.${field} to ${expected}`;
+    this.detail = { field, value, expected };
+  }
+};
+var CloudLayerOwnerConflictError = class extends Error {
+  code = "cloud-layer-owner-conflict";
+  expected = "at most one CloudLayer owns a World frame";
+  hint = "remove additional CloudLayer owners before extraction";
+  detail;
+  constructor(count) {
+    super(`CloudLayer owner cardinality is ${count}`);
+    this.name = "CloudLayerOwnerConflictError";
+    this.detail = { count };
+  }
+};
+var CloudLayerCacheInvalidError = class extends Error {
+  code = "cloud-layer-cache-invalid";
+  expected = "the density cache payload matches its reconstructible source";
+  hint = "discard the derived cache and rebuild it from CloudLayer source facts";
+  detail;
+  constructor(sourceKey, reason) {
+    super(`CloudLayer cache is invalid: ${reason}`);
+    this.name = "CloudLayerCacheInvalidError";
+    this.detail = { sourceKey, reason };
+  }
+};
+var CloudLayerCapabilityMissingError = class extends Error {
+  code = "cloud-layer-capability-missing";
+  expected = "the selected backend exposes the capability required by the cloud lane";
+  hint = "inspect the capability report, disable the cloud lane on this backend, or retry on a backend with the required capability";
+  detail;
+  constructor(capability) {
+    super(`CloudLayer capability is unavailable: ${capability}`);
+    this.name = "CloudLayerCapabilityMissingError";
+    this.detail = { capability };
+  }
+};
+var CloudLayerResourceFailureError = class extends Error {
+  code = "cloud-layer-resource-failed";
+  expected = "cloud resources are created, submitted and retired as one generation";
+  hint = "keep the last-known-good cloud generation and retry after recovery";
+  detail;
+  constructor(detail) {
+    super(`CloudLayer ${detail.stage} resource failed at generation ${detail.generation}`);
+    this.name = "CloudLayerResourceFailureError";
+    this.detail = detail;
+  }
+};
+var CLOUD_QUALITY_PROFILES = Object.freeze({
+  low: Object.freeze({
+    // Preserve low-profile ray counts while keeping separate puffs from
+    // collapsing into one bilinear cache smear.
+    cacheResolution: 32,
+    viewSteps: 40,
+    shadowSteps: 12,
+    historyWeight: 0.82,
+    viewDistance: 1600
+  }),
+  medium: Object.freeze({
+    cacheResolution: 40,
+    viewSteps: 64,
+    shadowSteps: 20,
+    historyWeight: 0.9,
+    viewDistance: 2400
+  }),
+  high: Object.freeze({
+    cacheResolution: 64,
+    viewSteps: 64,
+    shadowSteps: 32,
+    historyWeight: 0.94,
+    viewDistance: 4e3
+  })
+});
+function cloudShadowResolutionForQuality(qualityValue) {
+  return CLOUD_QUALITY_PROFILES[qualityValue].cacheResolution * 4;
+}
+function cloudViewDistanceForQuality(qualityValue) {
+  return CLOUD_QUALITY_PROFILES[qualityValue].viewDistance;
+}
+var CLOUD_EXTINCTION_COEFFICIENT = 0.03;
+var DEFAULT_CLOUD_LAYER = Object.freeze({
+  seed: 1337,
+  baseHeight: 120,
+  thickness: 80,
+  scale: 4e-3,
+  coverage: 0.48,
+  density: 1,
+  wind: Object.freeze([8, 0, 2]),
+  quality: "medium",
+  shadowRange: 512
+});
+function invalid3(field, value, expected) {
+  return err(new CloudLayerInvalidParameterError(field, value, expected));
+}
+function finiteRange(field, value, min, max = Number.POSITIVE_INFINITY) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < min || value > max) {
+    const expected = Number.isFinite(max) ? `finite and in [${min}, ${max}]` : `finite and >= ${min}`;
+    return invalid3(field, value, expected);
+  }
+  return ok(value);
+}
+function quality(value) {
+  if (typeof value === "string" && (value === "low" || value === "medium" || value === "high")) {
+    return ok(value);
+  }
+  if (typeof value === "number") {
+    const resolved = cloudQualityFromF32(value);
+    if (resolved !== void 0) return ok(resolved);
+  }
+  return invalid3(
+    "quality",
+    value,
+    `one of low, medium, high (codes ${CloudQualityValue.low}, ${CloudQualityValue.medium}, ${CloudQualityValue.high})`
+  );
+}
+function wind(value) {
+  if (value === void 0 || value === null || typeof value !== "object") {
+    return invalid3("wind", value, "three finite world-space components");
+  }
+  const source = value;
+  if (source.length !== 3) return invalid3("wind", value, "three finite world-space components");
+  const result = [
+    source[0] ?? Number.NaN,
+    source[1] ?? Number.NaN,
+    source[2] ?? Number.NaN
+  ];
+  if (result.some((entry) => !Number.isFinite(entry) || Math.abs(entry) > 1e3)) {
+    return invalid3("wind", value, "three finite components in [-1000, 1000]");
+  }
+  return ok(Object.freeze(result));
+}
+function validateCloudLayer(input) {
+  const value = input ?? {};
+  const seed = value.seed ?? DEFAULT_CLOUD_LAYER.seed;
+  if (typeof seed !== "number" || !Number.isInteger(seed) || seed < 0 || seed > 4294967295) {
+    return invalid3("seed", seed, "an integer in [0, 4294967295]");
+  }
+  const baseHeight = finiteRange(
+    "baseHeight",
+    value.baseHeight ?? DEFAULT_CLOUD_LAYER.baseHeight,
+    -1e5,
+    1e6
+  );
+  if (!baseHeight.ok) return baseHeight;
+  const thickness = finiteRange(
+    "thickness",
+    value.thickness ?? DEFAULT_CLOUD_LAYER.thickness,
+    1e-3,
+    1e6
+  );
+  if (!thickness.ok) return thickness;
+  const scale = finiteRange("scale", value.scale ?? DEFAULT_CLOUD_LAYER.scale, 1e-6, 10);
+  if (!scale.ok) return scale;
+  const coverage = finiteRange("coverage", value.coverage ?? DEFAULT_CLOUD_LAYER.coverage, 0, 1);
+  if (!coverage.ok) return coverage;
+  const density = finiteRange("density", value.density ?? DEFAULT_CLOUD_LAYER.density, 0, 32);
+  if (!density.ok) return density;
+  const resolvedWind = wind(value.wind ?? DEFAULT_CLOUD_LAYER.wind);
+  if (!resolvedWind.ok) return resolvedWind;
+  const resolvedQuality = quality(value.quality ?? DEFAULT_CLOUD_LAYER.quality);
+  if (!resolvedQuality.ok) return resolvedQuality;
+  const shadowRange = finiteRange(
+    "shadowRange",
+    value.shadowRange ?? DEFAULT_CLOUD_LAYER.shadowRange,
+    1e-3,
+    1e7
+  );
+  if (!shadowRange.ok) return shadowRange;
+  return ok(
+    Object.freeze({
+      seed,
+      baseHeight: baseHeight.value,
+      thickness: thickness.value,
+      scale: scale.value,
+      coverage: coverage.value,
+      density: density.value,
+      wind: resolvedWind.value,
+      quality: resolvedQuality.value,
+      shadowRange: shadowRange.value
+    })
+  );
+}
+function cloudLayerSourceKey(params) {
+  return [
+    "cloud-layer-v1",
+    params.seed,
+    params.baseHeight,
+    params.thickness,
+    params.scale,
+    params.coverage,
+    params.density,
+    params.wind[0],
+    params.wind[1],
+    params.wind[2],
+    params.quality,
+    params.shadowRange
+  ].join(":");
+}
+function cloudLayerFormationKey(params) {
+  return [
+    "cloud-formation-v5",
+    params.seed,
+    params.baseHeight,
+    params.thickness,
+    params.scale,
+    params.quality
+  ].join(":");
+}
+var MAX_VOLUMETRIC_FOG_OWNERS = 8;
+var VolumetricFogSamplingValue = { noise: 0, density: 1 };
+var VolumetricFog = defineComponent("VolumetricFog", {
+  light: { type: "entity" },
+  spotLight: { type: "entity" },
+  density: { type: "shared<TextureAsset>", simulationTransient: true },
+  boundsMin: { type: "array<f32, 3>" },
+  boundsMax: { type: "array<f32, 3>" },
+  extinction: { type: "array<f32, 3>" },
+  albedo: { type: "array<f32, 3>" },
+  emission: { type: "array<f32, 3>" },
+  anisotropy: { type: "f32", default: 0 },
+  maxDistance: { type: "f32", default: 100 },
+  sampling: { type: "enum", labels: VolumetricFogSamplingValue, default: 0 }
+});
+function finiteVector(value) {
+  return value.every(Number.isFinite);
+}
+function validBounds(bounds) {
+  if (!finiteVector(bounds.min) || !finiteVector(bounds.max)) return false;
+  return bounds.max.every((value, index) => value > (bounds.min[index] ?? value));
+}
+function validRange(value, min, max = Infinity) {
+  return value.every((entry) => Number.isFinite(entry) && entry >= min && entry <= max);
+}
+function validateVolumetricFog(input) {
+  if (input.density.shape.viewDimension !== "3d" || input.density.colorSpace === "srgb") {
+    return err(
+      new VolumeDensityShapeMismatchError(input.density.guid, input.density.shape.viewDimension)
+    );
+  }
+  if (!validBounds(input.bounds)) return err(new VolumeInvalidBoundsError(input.bounds));
+  if (!validRange(input.extinction, 0) || !validRange(input.albedo, 0, 1) || !validRange(input.emission, 0) || !Number.isFinite(input.anisotropy) || input.anisotropy <= -1 || input.anisotropy >= 1 || !Number.isFinite(input.maxDistance) || input.maxDistance <= 0 || input.sampling !== void 0 && input.sampling !== "noise" && input.sampling !== "density") {
+    return err(new VolumeInvalidParametersError(input));
+  }
+  return ok(input);
+}
+
+// src/environment/signature.ts
+function sorted(items) {
+  return [...items].sort((left, right) => left.entityKey - right.entityKey);
+}
+function environmentSignature(input) {
+  return JSON.stringify({
+    environments: sorted(input.environments),
+    fogs: sorted(input.fogs),
+    suns: sorted(input.suns)
+  });
+}
+function environmentOnlySignature(input) {
+  return JSON.stringify({
+    environments: sorted(input.environments),
+    suns: sorted(input.suns)
+  });
+}
+function fogOnlySignature(input) {
+  return JSON.stringify({ fogs: sorted(input.fogs) });
+}
+function environmentFactSignatures(input) {
+  return {
+    environmentSignature: environmentOnlySignature(input),
+    fogSignature: fogOnlySignature(input),
+    signature: environmentSignature(input)
+  };
+}
+
+// src/extract/environment.ts
+var ATMOSPHERE_PARAMETER_RANGES = Object.freeze({
+  turbidity: Object.freeze({ min: 1, max: 20 }),
+  rayleigh: Object.freeze({ min: 0, max: Number.POSITIVE_INFINITY }),
+  mieCoefficient: Object.freeze({ min: 0, max: Number.POSITIVE_INFINITY }),
+  mieDirectionalG: Object.freeze({ min: 0, max: 0.999 }),
+  sunAngularRadius: Object.freeze({ min: 0, max: Number.POSITIVE_INFINITY }),
+  circumsolarStrength: Object.freeze({ min: 0, max: 4 }),
+  circumsolarWidth: Object.freeze({ min: 0.25, max: 4 })
+});
+function validateFogParameters(candidate) {
+  if (candidate.color.length !== 3) {
+    return {
+      field: "color",
+      value: candidate.color.length,
+      expected: "exactly three finite channels in [0, 1]"
+    };
+  }
+  for (let index = 0; index < candidate.color.length; index += 1) {
+    const value = candidate.color[index];
+    if (value === void 0 || !Number.isFinite(value) || value < 0 || value > 1) {
+      return {
+        field: `color[${index}]`,
+        value: value ?? Number.NaN,
+        expected: "a finite number in [0, 1]"
+      };
+    }
+  }
+  if (!Number.isFinite(candidate.density) || candidate.density < 0) {
+    return { field: "density", value: candidate.density, expected: "a finite number >= 0" };
+  }
+  if (!Number.isFinite(candidate.heightFalloff) || candidate.heightFalloff < 0) {
+    return {
+      field: "heightFalloff",
+      value: candidate.heightFalloff,
+      expected: "a finite number >= 0"
+    };
+  }
+  if (!Number.isFinite(candidate.maxOpacity) || candidate.maxOpacity < 0 || candidate.maxOpacity > 1) {
+    return {
+      field: "maxOpacity",
+      value: candidate.maxOpacity,
+      expected: "a finite number in [0, 1]"
+    };
+  }
+  return void 0;
+}
+function validateAtmosphereParameters(parameters) {
+  for (const field of Object.keys(ATMOSPHERE_PARAMETER_RANGES)) {
+    const value = parameters[field];
+    const range = ATMOSPHERE_PARAMETER_RANGES[field];
+    if (!Number.isFinite(value) || value < range.min || value > range.max) {
+      return new AtmosphereInvalidParameterError(field, value, range);
+    }
+  }
+  return void 0;
+}
+
+// src/environment/frame.ts
+var SKYLIGHT_RECOVERY_FALLBACK = Object.freeze({
+  kind: "skylight",
+  active: false
+});
+var EnvironmentSelectionParameterError = class extends Error {
+  code = "environment-selection-invalid";
+  expected;
+  hint;
+  detail;
+  constructor(field, value, expected) {
+    super(`environment selection field ${field} is invalid`);
+    this.name = "EnvironmentSelectionParameterError";
+    this.expected = expected;
+    this.hint = `set ${field} to a finite value satisfying ${expected}`;
+    this.detail = { field, value };
+  }
+};
+var SunCardinalityError = class extends Error {
+  code = "sun-cardinality";
+  expected = "atmosphere has exactly one sun owner";
+  hint = "add exactly one DirectionalLight sun for the atmosphere owner";
+  detail;
+  constructor(value) {
+    super(`atmosphere sun cardinality is ${value}`);
+    this.name = "SunCardinalityError";
+    this.detail = { field: "sun", value };
+  }
+};
+function freezeCandidate(candidate) {
+  return Object.freeze(candidate);
+}
+function freezeFog(candidate) {
+  return Object.freeze({
+    ...candidate,
+    color: Object.freeze([...candidate.color])
+  });
+}
+function selectEnvironment(input) {
+  if (input.environments.length > 1) {
+    return err(
+      new EnvironmentSourceConflictError(
+        [...input.environments].sort((left, right) => left.entityKey - right.entityKey).map(({ kind, entityKey, sourceKey }) => ({ kind, entityKey, sourceKey }))
+      )
+    );
+  }
+  if (input.fogs.length > 1) return err(new FogCardinalityError(input.fogs.length));
+  const selectedFog = input.fogs[0];
+  if (selectedFog !== void 0) {
+    const issue = validateFogParameters(selectedFog);
+    if (issue !== void 0) {
+      return err(new EnvironmentSelectionParameterError(issue.field, issue.value, issue.expected));
+    }
+  }
+  const selected = input.environments[0];
+  if (selected?.kind === "atmosphere") {
+    const invalid5 = validateAtmosphereParameters(selected.atmosphere);
+    if (invalid5 !== void 0) return err(invalid5);
+  }
+  if (selected?.kind === "atmosphere" && input.suns.length !== 1) {
+    return err(new SunCardinalityError(input.suns.length));
+  }
+  const source = selected === void 0 ? { kind: "none" } : selected.kind === "atmosphere" ? {
+    kind: "atmosphere",
+    entityKey: selected.entityKey,
+    sourceKey: selected.sourceKey,
+    atmosphere: Object.freeze({ ...selected.atmosphere })
+  } : {
+    kind: "image",
+    entityKey: selected.entityKey,
+    sourceKey: selected.sourceKey
+  };
+  const sun = input.suns[0] === void 0 ? void 0 : freezeCandidate({ ...input.suns[0] });
+  const fog = selectedFog === void 0 ? void 0 : freezeFog(selectedFog);
+  const signatureInput = {
+    environments: selected === void 0 ? [] : [selected],
+    fogs: selectedFog === void 0 ? [] : [selectedFog],
+    suns: input.suns
+  };
+  const signatures = environmentFactSignatures(signatureInput);
+  const result = {
+    source: Object.freeze(source),
+    fog,
+    ...signatures,
+    revision: 0,
+    sun
+  };
+  Object.defineProperty(result, "lane", { value: input.lane, enumerable: false });
+  return ok(Object.freeze(result));
+}
 var DEPTH_OF_FIELD_PARAMS_BYTE_SIZE = 64;
 var MIN_F_STOP = Math.fround(0.7);
 var MAX_F_STOP = Math.fround(32);
@@ -1018,7 +1696,7 @@ function resolveDepthOfFieldFrameParams(requested, requestFailure, accepted) {
   }
   return accepted;
 }
-function invalid2(field, value, expected, bound) {
+function invalid4(field, value, expected, bound) {
   return new DepthOfFieldValidationError(
     "depth-of-field-invalid-params",
     { field, value, expected, ...bound === void 0 ? {} : { bound } },
@@ -1053,31 +1731,31 @@ function resolveDepthOfFieldFrameValues(params, input) {
   ];
   for (const [field, value, raw] of finitePositiveFields) {
     if (!Number.isFinite(value) || value <= 0) {
-      return err(invalid2(field, raw, "a finite positive f32 value"));
+      return err(invalid4(field, raw, "a finite positive f32 value"));
     }
   }
   if (!Number.isFinite(fStop) || fStop < MIN_F_STOP || fStop > MAX_F_STOP) {
     return err(
-      invalid2("fStop", params.fStop, "a finite f32 value in [0.7, 32]", [MIN_F_STOP, MAX_F_STOP])
+      invalid4("fStop", params.fStop, "a finite f32 value in [0.7, 32]", [MIN_F_STOP, MAX_F_STOP])
     );
   }
   if (!Number.isFinite(maxRadiusPixels) || maxRadiusPixels < 0 || maxRadiusPixels > 32) {
     return err(
-      invalid2("maxRadiusPixels", params.maxRadiusPixels, "a finite f32 value in [0, 32]", [0, 32])
+      invalid4("maxRadiusPixels", params.maxRadiusPixels, "a finite f32 value in [0, 32]", [0, 32])
     );
   }
   if (!Number.isFinite(outputHeight) || outputHeight <= 0) {
-    return err(invalid2("outputHeight", input.outputHeight, "a finite positive f32 value"));
+    return err(invalid4("outputHeight", input.outputHeight, "a finite positive f32 value"));
   }
   if (far <= near) {
-    return err(invalid2("near/far", [input.near, input.far], "finite f32 near > 0 and far > near"));
+    return err(invalid4("near/far", [input.near, input.far], "finite f32 near > 0 and far > near"));
   }
   if (focusDistance <= focal) {
-    return err(invalid2("focusDistance", params.focusDistance, "greater than focalLength in f32"));
+    return err(invalid4("focusDistance", params.focusDistance, "greater than focalLength in f32"));
   }
   const depthRatio = quantizeF32(near / far);
   if (!Number.isFinite(depthRatio) || depthRatio <= 0) {
-    return err(invalid2("near/far ratio", depthRatio, "a finite positive f32 value"));
+    return err(invalid4("near/far ratio", depthRatio, "a finite positive f32 value"));
   }
   for (const raw of [quantizeF32(2 ** -149), 0.5, MAX_LINEAR_DEPTH_RAW]) {
     const oneMinusRaw = quantizeF32(1 - raw);
@@ -1085,7 +1763,7 @@ function resolveDepthOfFieldFrameValues(params, input) {
     const denominator = quantizeF32(oneMinusRaw + weightedRatio);
     const distance = quantizeF32(near / denominator);
     if (!Number.isFinite(oneMinusRaw) || oneMinusRaw <= 0 || !Number.isFinite(weightedRatio) || !Number.isFinite(denominator) || denominator <= 0 || !Number.isFinite(distance) || distance <= 0) {
-      return err(invalid2("linearDepth", distance, "finite positive f32 reconstruction"));
+      return err(invalid4("linearDepth", distance, "finite positive f32 reconstruction"));
     }
   }
   const cocCoefficient = frameCocCoefficient(
@@ -1099,7 +1777,7 @@ function resolveDepthOfFieldFrameValues(params, input) {
   );
   if (!Number.isFinite(cocCoefficient) || cocCoefficient <= 0) {
     return err(
-      invalid2("cocCoefficient", cocCoefficient, "a finite positive value representable as f32")
+      invalid4("cocCoefficient", cocCoefficient, "a finite positive value representable as f32")
     );
   }
   for (const [field, depth] of [
@@ -1110,7 +1788,7 @@ function resolveDepthOfFieldFrameValues(params, input) {
     const depthFactor = quantizeF32(1 - focusOverDepth);
     const radius = quantizeF32(cocCoefficient * depthFactor);
     if (!Number.isFinite(focusOverDepth) || !Number.isFinite(depthFactor) || !Number.isFinite(radius)) {
-      return err(invalid2(`coc.${field}`, radius, "a finite value representable as f32"));
+      return err(invalid4(`coc.${field}`, radius, "a finite value representable as f32"));
     }
   }
   return ok({
@@ -1153,16 +1831,16 @@ function validateDepthOfFieldParams(input, camera) {
   );
   const qualityValue = quantizeF32(value.quality ?? DepthOfFieldQualityValue.medium);
   const blurSideValue = quantizeF32(value.blurSide ?? DepthOfFieldSideValue.both);
-  const quality = depthOfFieldQualityFromF32(qualityValue);
+  const quality2 = depthOfFieldQualityFromF32(qualityValue);
   const blurSide = depthOfFieldSideFromF32(blurSideValue);
   if (!Number.isFinite(focusDistance) || focusDistance <= 0) {
     return err(
-      invalid2("focusDistance", value.focusDistance ?? focusDistance, "a finite positive f32 value")
+      invalid4("focusDistance", value.focusDistance ?? focusDistance, "a finite positive f32 value")
     );
   }
   if (!Number.isFinite(fStop) || fStop < MIN_F_STOP || fStop > MAX_F_STOP) {
     return err(
-      invalid2("fStop", value.fStop ?? fStop, "a finite f32 value in [0.7, 32]", [
+      invalid4("fStop", value.fStop ?? fStop, "a finite f32 value in [0.7, 32]", [
         MIN_F_STOP,
         MAX_F_STOP
       ])
@@ -1170,12 +1848,12 @@ function validateDepthOfFieldParams(input, camera) {
   }
   if (!Number.isFinite(sensorHeight) || sensorHeight <= 0) {
     return err(
-      invalid2("sensorHeight", value.sensorHeight ?? sensorHeight, "a finite positive f32 value")
+      invalid4("sensorHeight", value.sensorHeight ?? sensorHeight, "a finite positive f32 value")
     );
   }
   if (!Number.isFinite(maxRadiusPixels) || maxRadiusPixels < 0 || maxRadiusPixels > 32) {
     return err(
-      invalid2(
+      invalid4(
         "maxRadiusPixels",
         value.maxRadiusPixels ?? maxRadiusPixels,
         "a finite f32 value in [0, 32]",
@@ -1183,11 +1861,11 @@ function validateDepthOfFieldParams(input, camera) {
       )
     );
   }
-  if (quality === void 0) {
-    return err(invalid2("quality", qualityValue, "DepthOfFieldQualityValue.low, medium, or high"));
+  if (quality2 === void 0) {
+    return err(invalid4("quality", qualityValue, "DepthOfFieldQualityValue.low, medium, or high"));
   }
   if (blurSide === void 0) {
-    return err(invalid2("blurSide", blurSideValue, "DepthOfFieldSideValue.both, near, or far"));
+    return err(invalid4("blurSide", blurSideValue, "DepthOfFieldSideValue.both, near, or far"));
   }
   let focal = DEFAULT_DEPTH_OF_FIELD_PARAMS.focalLength;
   if (camera !== void 0) {
@@ -1195,25 +1873,25 @@ function validateDepthOfFieldParams(input, camera) {
     const near = quantizeF32(camera.near);
     const far = quantizeF32(camera.far);
     if (!Number.isFinite(fov) || fov <= 0 || fov >= Math.PI) {
-      return err(invalid2("fov", camera.fov, "a finite f32 value in (0, PI)"));
+      return err(invalid4("fov", camera.fov, "a finite f32 value in (0, PI)"));
     }
     if (!Number.isFinite(near) || !Number.isFinite(far) || near <= 0 || far <= near) {
       return err(
-        invalid2("near/far", [camera.near, camera.far], "finite f32 near > 0 and far > near")
+        invalid4("near/far", [camera.near, camera.far], "finite f32 near > 0 and far > near")
       );
     }
     focal = quantizeF32(focalLength(sensorHeight, fov));
     if (!Number.isFinite(focal) || focal <= 0) {
-      return err(invalid2("focalLength", focal, "a finite positive f32 value"));
+      return err(invalid4("focalLength", focal, "a finite positive f32 value"));
     }
     if (focusDistance < near || focusDistance > far) {
       return err(
-        invalid2("focusDistance", focusDistance, `a value in [${near}, ${far}]`, [near, far])
+        invalid4("focusDistance", focusDistance, `a value in [${near}, ${far}]`, [near, far])
       );
     }
     if (focusDistance <= focal) {
       return err(
-        invalid2("focusDistance", focusDistance, `greater than focalLength in f32 (${focal})`)
+        invalid4("focusDistance", focusDistance, `greater than focalLength in f32 (${focal})`)
       );
     }
   }
@@ -1223,7 +1901,7 @@ function validateDepthOfFieldParams(input, camera) {
       fStop,
       sensorHeight,
       maxRadiusPixels,
-      quality,
+      quality: quality2,
       blurSide,
       focalLength: focal
     })
@@ -1233,8 +1911,8 @@ function resolveDepthOfFieldParams(input, camera) {
   if (input === void 0) return ok(void 0);
   return validateDepthOfFieldParams(input, camera);
 }
-function depthOfFieldTapCount(quality) {
-  switch (quality) {
+function depthOfFieldTapCount(quality2) {
+  switch (quality2) {
     case "low":
       return 16;
     case "medium":
@@ -1253,8 +1931,8 @@ function depthOfFieldSideCode(side) {
       return DepthOfFieldSideValue.far;
   }
 }
-function depthOfFieldQualityCode(quality) {
-  switch (quality) {
+function depthOfFieldQualityCode(quality2) {
+  switch (quality2) {
     case "low":
       return DepthOfFieldQualityValue.low;
     case "medium":
@@ -1633,50 +2311,79 @@ function resolveVisibility(world, hierarchy = projectHierarchy(world)) {
   };
   return snapshot;
 }
-var VolumetricFog = defineComponent("VolumetricFog", {
-  light: { type: "entity" },
-  spotLight: { type: "entity" },
-  density: { type: "shared<TextureAsset>", simulationTransient: true },
-  boundsMin: { type: "array<f32, 3>" },
-  boundsMax: { type: "array<f32, 3>" },
-  extinction: { type: "array<f32, 3>" },
-  albedo: { type: "array<f32, 3>" },
-  emission: { type: "array<f32, 3>" },
-  anisotropy: { type: "f32", default: 0 },
-  maxDistance: { type: "f32", default: 100 }
-});
-function finiteVector(value) {
-  return value.every(Number.isFinite);
-}
-function validBounds(bounds) {
-  if (!finiteVector(bounds.min) || !finiteVector(bounds.max)) return false;
-  return bounds.max.every((value, index) => value > (bounds.min[index] ?? value));
-}
-function validRange(value, min, max = Infinity) {
-  return value.every((entry) => Number.isFinite(entry) && entry >= min && entry <= max);
+function selectCloudLayerFrame(candidates, worldTimeSeconds = 0, sunDirection = void 0, sunRadiance = void 0) {
+  if (candidates.length === 0) return ok(void 0);
+  if (candidates.length > 1) return err(new CloudLayerOwnerConflictError(candidates.length));
+  const candidate = candidates[0];
+  if (candidate === void 0) return ok(void 0);
+  const validated = validateCloudLayer(candidate.data);
+  if (!validated.ok) return validated;
+  return ok(
+    Object.freeze({
+      status: "available",
+      entityKey: candidate.entityKey,
+      sourceKey: cloudLayerSourceKey(validated.value),
+      params: validated.value,
+      worldTimeSeconds: Number.isFinite(worldTimeSeconds) ? Math.max(0, worldTimeSeconds) : 0,
+      sunDirection: sunDirection === void 0 ? void 0 : Object.freeze([...sunDirection]),
+      sunRadiance: sunRadiance === void 0 ? void 0 : Object.freeze([...sunRadiance]),
+      revision: 1
+    })
+  );
 }
-function validateVolumetricFog(input) {
-  const ownerCount = input.ownerCount ?? 1;
-  if (ownerCount !== 1) return err(new VolumeOwnerConflictError(ownerCount));
-  if (input.density.shape.viewDimension !== "3d" || input.density.colorSpace === "srgb") {
-    return err(
-      new VolumeDensityShapeMismatchError(input.density.guid, input.density.shape.viewDimension)
-    );
+function extractCloudLayer(world) {
+  const candidates = [];
+  try {
+    const query = world.query({ read: [CloudLayer] });
+    if (!query.ok) return ok(void 0);
+    for (const row of query.value)
+      candidates.push({ entityKey: row.entity, data: row.get(CloudLayer) });
+  } catch {
+    return ok(void 0);
   }
-  if (!validBounds(input.bounds)) return err(new VolumeInvalidBoundsError(input.bounds));
-  if (!validRange(input.extinction, 0) || !validRange(input.albedo, 0, 1) || !validRange(input.emission, 0) || !Number.isFinite(input.anisotropy) || input.anisotropy <= -1 || input.anisotropy >= 1 || !Number.isFinite(input.maxDistance) || input.maxDistance <= 0) {
-    return err(new VolumeInvalidParametersError(input));
+  let sunDirection;
+  let sunRadiance;
+  try {
+    const query = world.query({ read: [DirectionalLight] });
+    if (query.ok) {
+      for (const row of query.value) {
+        const light = row.get(DirectionalLight);
+        const intensity = Number.isFinite(light.intensity) ? Math.max(0, light.intensity) : 0;
+        sunDirection = [
+          -(light.direction[0] ?? 0),
+          -(light.direction[1] ?? -1),
+          -(light.direction[2] ?? 0)
+        ];
+        sunRadiance = [
+          (light.color[0] ?? 1) * intensity,
+          (light.color[1] ?? 1) * intensity,
+          (light.color[2] ?? 1) * intensity
+        ];
+        break;
+      }
+    }
+  } catch {
   }
-  return ok({ ...input, ownerCount: 1 });
+  return selectCloudLayerFrame(
+    candidates,
+    world.getResource(Time).elapsed,
+    sunDirection,
+    sunRadiance
+  );
 }
 function extractVolumetricFog(inputs) {
   if (inputs.length === 0) return ok({ status: "off" });
-  if (inputs.length !== 1) return err(new VolumeOwnerConflictError(inputs.length));
-  const validated = validateVolumetricFog(inputs[0]);
-  if (!validated.ok) return validated;
-  return ok({ status: "available", fog: validated.value });
+  if (inputs.length > MAX_VOLUMETRIC_FOG_OWNERS)
+    return err(new VolumeOwnerConflictError(inputs.length));
+  const fogs = [];
+  for (const input of inputs) {
+    const validated = validateVolumetricFog(input);
+    if (!validated.ok) return validated;
+    fogs.push(validated.value);
+  }
+  return ok({ status: "available", fogs });
 }
 
-export { ANTIALIAS_FXAA, ANTIALIAS_MSAA, ANTIALIAS_NONE, ANTIALIAS_TAA, Atmosphere, BLOOM_DISABLED, BLOOM_ENABLED, CAMERA_EXPOSURE_MODE_AUTO, CAMERA_EXPOSURE_MODE_MANUAL, CAMERA_PROJECTION_ORTHOGRAPHIC, CAMERA_PROJECTION_PERSPECTIVE, CAMERA_TEMPERATURE_MAX, CAMERA_TEMPERATURE_MIN, CAMERA_TINT_MAX, CAMERA_TINT_MIN, CUBE_CAMERA_FACE_ORDER, CUBE_CAMERA_UPDATE_CONTINUOUS, CUBE_CAMERA_UPDATE_ONCE, CUBE_CAMERA_UPDATE_ON_DEMAND, Camera, CameraError, CubeCamera, DEFAULT_DEPTH_OF_FIELD_PARAMS, DEPTH_OF_FIELD_PARAMS_BYTE_SIZE, DepthOfField, DepthOfFieldQualityValue, DepthOfFieldSideValue, DepthOfFieldValidationError, DirectionalLight, DirectionalShadowFilterValue, DynamicResolution, Fog, Instances, Layer, LightProbe, Lines, MeshFilter, MeshRenderer, MotionBlur, PointLight, PointLightShadow, PointShapeValue, Points, PostProcessParams, REFLECTION_PROBE_UPDATE_CONTINUOUS, REFLECTION_PROBE_UPDATE_ONCE, REFLECTION_PROBE_UPDATE_ON_CHANGE, RectAreaLight, ReflectionProbe, SKYBOX_MODE_CUBEMAP, SceneInstance, ScreenSpaceReflection, SkyboxBackground, Skylight, SortKey, SpotLight, TONEMAP_ACES_FILMIC, TONEMAP_AGX, TONEMAP_CINEON, TONEMAP_LINEAR, TONEMAP_NEUTRAL, TONEMAP_NONE, TONEMAP_REINHARD, TONEMAP_REINHARD_EXTENDED, Visibility, VisibilityStateValue, VolumetricFog, antialiasFromF32, bloomEnabledFromF32, buildCubeCameraFaceViews, cameraExposureFromColumns, cameraProjectionFromF32, computeInvRangeSquared, cubeCameraUpdateIntentFromF32, cubeCameraUpdateIntentToF32, degToCos, depthOfFieldQualityCode, depthOfFieldQualityFromF32, depthOfFieldRequestFailure, depthOfFieldSideCode, depthOfFieldSideFromF32, depthOfFieldTapCount, directionalShadowQualityFromF32, extractVolumetricFog, hasVolumetricFogCapability, orthographic, packDepthOfFieldParams, perspective, pointShapeFromU32, projectMeshMaterialBindingObservation, reflectionProbeUpdateIntentFromF32, reflectionProbeUpdateIntentToF32, resolveDepthOfFieldFrameParams, resolveDepthOfFieldParams, resolveIntegratedVolumeConsumer, resolveMeshMaterialBindings, resolveSelectedVolumetricLight, resolveVisibility, resolveVolumetricFogLightPair, signedDepthOfFieldCoC, summarizeMeshMaterialBindings, tonemapFromF32, tonemapToU32, validateCameraColorGrading, validateCameraExposure, validateDepthOfFieldFrameParams, validateDepthOfFieldParams, validateDirection, validateDirectionalLightData, validateDynamicResolutionCamera, validateDynamicResolutionParameters, validateLightProbeData, validatePointLightData, validatePointLightShadowData, validateRectAreaLightData, validateSpotLightData, validateVolumetricFog, visibilityStateFromU32 };
-//# sourceMappingURL=chunk-GWCEMDVR.mjs.map
-//# sourceMappingURL=chunk-GWCEMDVR.mjs.map
+export { ANTIALIAS_FXAA, ANTIALIAS_MSAA, ANTIALIAS_NONE, ANTIALIAS_TAA, Atmosphere, BLOOM_DISABLED, BLOOM_ENABLED, BarrelDistortion, CAMERA_BLOOM_INTENSITY_MAX, CAMERA_BLOOM_INTENSITY_MIN, CAMERA_BLOOM_SCATTER_MAX, CAMERA_BLOOM_SCATTER_MIN, CAMERA_BLOOM_SOFT_KNEE_MAX, CAMERA_BLOOM_SOFT_KNEE_MIN, CAMERA_BLOOM_THRESHOLD_MAX, CAMERA_BLOOM_THRESHOLD_MIN, CAMERA_EXPOSURE_MODE_AUTO, CAMERA_EXPOSURE_MODE_MANUAL, CAMERA_PROJECTION_ORTHOGRAPHIC, CAMERA_PROJECTION_PERSPECTIVE, CAMERA_TEMPERATURE_MAX, CAMERA_TEMPERATURE_MIN, CAMERA_TINT_MAX, CAMERA_TINT_MIN, CLOUD_EXTINCTION_COEFFICIENT, CLOUD_QUALITY_PROFILES, CUBE_CAMERA_FACE_ORDER, CUBE_CAMERA_UPDATE_CONTINUOUS, CUBE_CAMERA_UPDATE_ONCE, CUBE_CAMERA_UPDATE_ON_DEMAND, Camera, CameraError, CloudLayer, CloudLayerCacheInvalidError, CloudLayerCapabilityMissingError, CloudLayerInvalidParameterError, CloudLayerOwnerConflictError, CloudLayerResourceFailureError, CloudQualityValue, CubeCamera, DEFAULT_CLOUD_LAYER, DEFAULT_DEPTH_OF_FIELD_PARAMS, DEPTH_OF_FIELD_PARAMS_BYTE_SIZE, DepthOfField, DepthOfFieldQualityValue, DepthOfFieldSideValue, DepthOfFieldValidationError, DirectionalLight, DirectionalShadowFilterValue, DynamicResolution, Fog, Instances, Layer, LightProbe, Lines, MAX_VOLUMETRIC_FOG_OWNERS, MeshFilter, MeshRenderer, MotionBlur, PointLight, PointLightShadow, PointShapeValue, Points, PostProcessParams, REFLECTION_PROBE_UPDATE_CONTINUOUS, REFLECTION_PROBE_UPDATE_ONCE, REFLECTION_PROBE_UPDATE_ON_CHANGE, RectAreaLight, ReflectionProbe, SKYBOX_MODE_CUBEMAP, SKYLIGHT_RECOVERY_FALLBACK, SceneInstance, ScreenSpaceReflection, SkyboxBackground, Skylight, SortKey, SpotLight, SunCardinalityError, TONEMAP_ACES_FILMIC, TONEMAP_AGX, TONEMAP_CINEON, TONEMAP_LINEAR, TONEMAP_NEUTRAL, TONEMAP_NONE, TONEMAP_REINHARD, TONEMAP_REINHARD_EXTENDED, Visibility, VisibilityStateValue, VolumetricFog, VolumetricFogSamplingValue, antialiasFromF32, attachBarrelDistortionCameraFrame, buildCubeCameraFaceViews, cameraExposureFromColumns, cameraProjectionFromF32, cloudLayerFormationKey, cloudLayerSourceKey, cloudQualityFromF32, cloudShadowResolutionForQuality, cloudViewDistanceForQuality, computeInvRangeSquared, createBarrelDistortionMapping, cubeCameraUpdateIntentFromF32, cubeCameraUpdateIntentToF32, degToCos, depthOfFieldQualityCode, depthOfFieldQualityFromF32, depthOfFieldRequestFailure, depthOfFieldSideCode, depthOfFieldSideFromF32, depthOfFieldTapCount, directionalShadowQualityFromF32, extractCloudLayer, extractVolumetricFog, freezeBarrelDistortionMapping, hasVolumetricFogCapability, mapDisplayToScene, mapDisplayUvToSceneUv, mapSceneToDisplay, mapSceneUvToDisplayUv, orthographic, packDepthOfFieldParams, perspective, pointShapeFromU32, projectMeshMaterialBindingObservation, reflectionProbeUpdateIntentFromF32, reflectionProbeUpdateIntentToF32, resolveDepthOfFieldFrameParams, resolveDepthOfFieldParams, resolveIntegratedVolumeConsumer, resolveMeshMaterialBindings, resolveSelectedVolumetricLight, resolveVisibility, resolveVolumetricFogLightPair, selectCloudLayerFrame, selectEnvironment, signedDepthOfFieldCoC, summarizeMeshMaterialBindings, tonemapFromF32, tonemapToU32, validateBarrelDistortionParameters, validateCameraBloom, validateCameraColorGrading, validateCameraExposure, validateCloudLayer, validateDepthOfFieldFrameParams, validateDepthOfFieldParams, validateDirection, validateDirectionalLightData, validateDynamicResolutionCamera, validateDynamicResolutionParameters, validateLightProbeData, validatePointLightData, validatePointLightShadowData, validateRectAreaLightData, validateSpotLightData, validateVolumetricFog, visibilityStateFromU32 };
+//# sourceMappingURL=chunk-UINHLCZA.mjs.map
+//# sourceMappingURL=chunk-UINHLCZA.mjs.map