@forgeax/engine-render 0.1.28 → 0.1.30

package/dist/{chunk-JAASCMXA.mjs → chunk-S5UE2T5P.mjs}

@@ -1,9 +1,10 @@
-import { RenderIntentInvalidError, ShadowInvalidConfigError, VolumeOwnerConflictError, VolumeDensityShapeMismatchError, VolumeInvalidBoundsError, VolumeInvalidParametersError } from './chunk-J6KACNOH.mjs';
+import { RenderIntentInvalidError, DynamicResolutionRequiresTaaError, ShadowInvalidConfigError, VolumeOwnerConflictError, VolumeDensityShapeMismatchError, VolumeInvalidBoundsError, VolumeInvalidParametersError, DynamicResolutionInvalidParameterError } from './chunk-JRBDO2KB.mjs';
 import { defineComponent, Entity } from '@forgeax/engine-ecs';
 import { TONEMAP_SHADER_MODE } from '@forgeax/engine-shader';
 import { R_MIN, err, ok } from '@forgeax/engine-types';
 import { SpawnLightInvalidBoundsError } from '@forgeax/engine-ecs/projection';
 import { Transform, projectHierarchy } from '@forgeax/engine-scene';
+import { mat4 } from '@forgeax/engine-math';
 
 var Atmosphere = defineComponent("Atmosphere", {
   turbidity: { type: "f32", default: 2 },
@@ -14,6 +15,113 @@ var Atmosphere = defineComponent("Atmosphere", {
 });
 var CAMERA_PROJECTION_PERSPECTIVE = 0;
 var CAMERA_PROJECTION_ORTHOGRAPHIC = 1;
+var CAMERA_EXPOSURE_MODE_MANUAL = 0;
+var CAMERA_EXPOSURE_MODE_AUTO = 1;
+var CAMERA_TEMPERATURE_MIN = 1e3;
+var CAMERA_TEMPERATURE_MAX = 4e4;
+var CAMERA_TINT_MIN = -1;
+var CAMERA_TINT_MAX = 1;
+var CameraError = class extends Error {
+  code;
+  expected;
+  hint;
+  detail;
+  constructor(code, field, actual, expected, hint) {
+    super(`${code}: ${field}=${String(actual)}; expected ${expected}`);
+    this.name = "CameraError";
+    this.code = code;
+    this.expected = expected;
+    this.hint = hint;
+    this.detail = Object.freeze({ field, actual, expected });
+  }
+};
+function actualValue(value) {
+  if (typeof value === "number" || typeof value === "string") return value;
+  try {
+    return JSON.stringify(value) ?? String(value);
+  } catch {
+    return String(value);
+  }
+}
+function cameraError(code, field, actual, expected, hint) {
+  return new CameraError(code, field, actualValue(actual), expected, hint);
+}
+function finitePositive(value) {
+  return Number.isFinite(value) && value > 0;
+}
+function validateCameraExposure(exposure) {
+  if (typeof exposure !== "object" || exposure === null) {
+    throw cameraError(
+      "camera-exposure-invalid",
+      "value",
+      exposure,
+      "an object with kind manual or auto",
+      "choose one member of the CameraExposure union"
+    );
+  }
+  if (exposure.kind === "manual") {
+    if (!finitePositive(exposure.multiplier)) {
+      throw cameraError(
+        "camera-exposure-invalid",
+        "multiplier",
+        exposure.multiplier,
+        "a finite number greater than zero",
+        "set Camera.exposure to a positive finite manual multiplier"
+      );
+    }
+    return exposure;
+  }
+  if (exposure.kind === "auto") {
+    const [min, max] = exposure.rangeEv;
+    const [up, down] = exposure.rates;
+    if (!finitePositive(exposure.fallback) || !Number.isFinite(exposure.compensationEv) || !Number.isFinite(min) || !Number.isFinite(max) || min > max || !Number.isFinite(up) || !Number.isFinite(down) || up < 0 || down < 0) {
+      throw cameraError(
+        "camera-exposure-invalid",
+        "auto",
+        JSON.stringify(exposure),
+        "finite fallback/compensation, an ordered range, and non-negative rates",
+        "inspect fallback, compensationEv, rangeEv, and rates before rebuilding the camera"
+      );
+    }
+    return exposure;
+  }
+  throw cameraError(
+    "camera-exposure-invalid",
+    "kind",
+    exposure.kind,
+    "'manual' or 'auto'",
+    "choose one member of the CameraExposure union"
+  );
+}
+function validateCameraColorGrading(temperature, tint, colorLutStrength) {
+  if (!Number.isFinite(temperature) || temperature < CAMERA_TEMPERATURE_MIN || temperature > CAMERA_TEMPERATURE_MAX) {
+    throw cameraError(
+      "camera-color-grading-invalid",
+      "temperature",
+      temperature,
+      `a finite value in [${CAMERA_TEMPERATURE_MIN}, ${CAMERA_TEMPERATURE_MAX}]`,
+      "set Camera.temperature to a supported Kelvin value"
+    );
+  }
+  if (!Number.isFinite(tint) || tint < CAMERA_TINT_MIN || tint > CAMERA_TINT_MAX) {
+    throw cameraError(
+      "camera-color-grading-invalid",
+      "tint",
+      tint,
+      `a finite value in [${CAMERA_TINT_MIN}, ${CAMERA_TINT_MAX}]`,
+      "set Camera.tint to a normalized value between -1 and 1"
+    );
+  }
+  if (!Number.isFinite(colorLutStrength) || colorLutStrength < 0 || colorLutStrength > 1) {
+    throw cameraError(
+      "camera-color-grading-invalid",
+      "colorLutStrength",
+      colorLutStrength,
+      "a finite value in [0, 1]",
+      "set Camera.colorLutStrength to zero to disable the LUT or a blend in [0, 1]"
+    );
+  }
+}
 function cameraProjectionFromF32(value) {
   return value === CAMERA_PROJECTION_ORTHOGRAPHIC ? "orthographic" : "perspective";
 }
@@ -64,7 +172,13 @@ function tonemapToU32(mode) {
     case "none":
       return TONEMAP_NONE;
   }
-  throw new RangeError(`Invalid tonemap mode: ${String(mode)}.`);
+  throw cameraError(
+    "camera-tonemap-invalid",
+    "tonemap",
+    mode,
+    "one of the closed Tonemap values",
+    "select a supported Camera tonemap mode"
+  );
 }
 var ANTIALIAS_NONE = 0;
 var ANTIALIAS_FXAA = 1;
@@ -75,8 +189,12 @@ function antialiasFromF32(value) {
   if (value === ANTIALIAS_FXAA) return "fxaa";
   if (value === ANTIALIAS_MSAA) return "msaa";
   if (value === ANTIALIAS_TAA) return "taa";
-  throw new RangeError(
-    `Invalid antialias value: ${value}. Expected ${ANTIALIAS_NONE} (none), ${ANTIALIAS_FXAA} (fxaa), ${ANTIALIAS_MSAA} (msaa), or ${ANTIALIAS_TAA} (taa).`
+  throw cameraError(
+    "camera-antialias-invalid",
+    "antialias",
+    value,
+    `${ANTIALIAS_NONE}, ${ANTIALIAS_FXAA}, ${ANTIALIAS_MSAA}, or ${ANTIALIAS_TAA}`,
+    "select a supported Camera antialias mode"
   );
 }
 var BLOOM_DISABLED = 0;
@@ -84,8 +202,12 @@ var BLOOM_ENABLED = 1;
 function bloomEnabledFromF32(value) {
   if (value === BLOOM_DISABLED) return "off";
   if (value === BLOOM_ENABLED) return "on";
-  throw new RangeError(
-    `Invalid bloom value: ${value}. Expected ${BLOOM_DISABLED} (off) or ${BLOOM_ENABLED} (on).`
+  throw cameraError(
+    "camera-bloom-invalid",
+    "bloom",
+    value,
+    `${BLOOM_DISABLED} or ${BLOOM_ENABLED}`,
+    "select Camera bloom off or on"
   );
 }
 var Camera = defineComponent("Camera", {
@@ -100,7 +222,15 @@ var Camera = defineComponent("Camera", {
   top: { type: "f32", default: 1 },
   tonemap: { type: "f32", default: 0 },
   exposure: { type: "f32", default: 1 },
+  exposureMode: { type: "f32", default: CAMERA_EXPOSURE_MODE_MANUAL },
+  compensationEv: { type: "f32", default: 0 },
+  rangeEv: { type: "array<f32, 2>", default: new Float32Array([-8, 8]) },
+  rates: { type: "array<f32, 2>", default: new Float32Array([3, 1]) },
   whitePoint: { type: "f32", default: 4 },
+  temperature: { type: "f32", default: 6504 },
+  tint: { type: "f32", default: 0 },
+  colorLut: { type: "shared<TextureAsset>", default: 0 },
+  colorLutStrength: { type: "f32", default: 0 },
   antialias: { type: "f32", default: 0 },
   historyVersion: { type: "u32", default: 0 },
   bloom: { type: "f32", default: 0 },
@@ -133,6 +263,60 @@ var Camera = defineComponent("Camera", {
   // returns a raw 0/1 number (the `!== 0` always-true trap).
   autoAspect: { type: "bool", default: true }
 });
+function cameraExposureFromColumns(input) {
+  if (input.exposureMode === CAMERA_EXPOSURE_MODE_MANUAL) {
+    return validateCameraExposure({ kind: "manual", multiplier: input.exposure });
+  }
+  if (input.exposureMode === CAMERA_EXPOSURE_MODE_AUTO) {
+    return validateCameraExposure({
+      kind: "auto",
+      fallback: input.exposure,
+      compensationEv: input.compensationEv,
+      rangeEv: [input.rangeEv[0] ?? -8, input.rangeEv[1] ?? 8],
+      rates: [input.rates[0] ?? 3, input.rates[1] ?? 1]
+    });
+  }
+  throw cameraError(
+    "camera-exposure-mode-invalid",
+    "exposureMode",
+    input.exposureMode,
+    `${CAMERA_EXPOSURE_MODE_MANUAL} or ${CAMERA_EXPOSURE_MODE_AUTO}`,
+    "set Camera.exposureMode to the manual or auto encoding"
+  );
+}
+function cameraExposureColumns(exposure) {
+  const checked = validateCameraExposure(exposure);
+  if (checked.kind === "manual") {
+    return {
+      exposureMode: CAMERA_EXPOSURE_MODE_MANUAL,
+      exposure: checked.multiplier,
+      compensationEv: 0,
+      rangeEv: new Float32Array([-8, 8]),
+      rates: new Float32Array([3, 1])
+    };
+  }
+  return {
+    exposureMode: CAMERA_EXPOSURE_MODE_AUTO,
+    exposure: checked.fallback,
+    compensationEv: checked.compensationEv,
+    rangeEv: new Float32Array(checked.rangeEv),
+    rates: new Float32Array(checked.rates)
+  };
+}
+function cameraColorGradingColumns(opts) {
+  const exposure = opts.exposure ?? { kind: "manual", multiplier: 1 };
+  const temperature = opts.temperature ?? 6504;
+  const tint = opts.tint ?? 0;
+  const colorLutStrength = opts.colorLutStrength ?? 0;
+  validateCameraColorGrading(temperature, tint, colorLutStrength);
+  return {
+    ...cameraExposureColumns(exposure),
+    temperature,
+    tint,
+    colorLut: opts.colorLut ?? 0,
+    colorLutStrength
+  };
+}
 function cameraPodFromDefaults() {
   const base = {};
   for (const [key, field] of Object.entries(Camera.fields)) {
@@ -153,7 +337,8 @@ function perspective(opts) {
     near: opts.near ?? 0.1,
     far: opts.far ?? 100,
     projection: CAMERA_PROJECTION_PERSPECTIVE,
-    ...opts.autoAspect !== void 0 ? { autoAspect: opts.autoAspect } : {}
+    ...opts.autoAspect !== void 0 ? { autoAspect: opts.autoAspect } : {},
+    ...cameraColorGradingColumns(opts)
   };
 }
 function orthographic(opts) {
@@ -167,7 +352,8 @@ function orthographic(opts) {
     left: opts.left,
     right: opts.right,
     bottom: opts.bottom,
-    top: opts.top
+    top: opts.top,
+    ...cameraColorGradingColumns(opts)
   };
 }
 var CUBE_CAMERA_UPDATE_ONCE = 0;
@@ -255,7 +441,7 @@ var DirectionalLight = defineComponent("DirectionalLight", {
   splitLambda: { type: "f32", default: 0.75 },
   cascadeBlend: { type: "f32", default: 0.2 },
   mapSize: { type: "f32", default: 2048 },
-  depthBias: { type: "f32", default: 5e-3 },
+  depthBias: { type: "f32", default: 1e-5 },
   normalBias: { type: "f32", default: 0.05 },
   // Sole shadow coverage knob (feat replaces nearPlane/farPlane). The PSSM
   // near end derives from the active camera near; shadowDistance is the far
@@ -270,6 +456,47 @@ var DirectionalLight = defineComponent("DirectionalLight", {
   shadowAngularRadius: { type: "f32", default: 465e-5 },
   maxPenumbraTexels: { type: "f32", default: 32 }
 });
+var DynamicResolution = defineComponent("DynamicResolution", {
+  targetGpuMs: { type: "f32", default: 16.67 },
+  minScale: { type: "f32", default: 0.67 },
+  maxScale: { type: "f32", default: 1 }
+});
+var DEFAULT_DYNAMIC_RESOLUTION = Object.freeze({
+  targetGpuMs: 16.67,
+  minScale: 0.67,
+  maxScale: 1
+});
+function invalid(field, value, expected) {
+  return new DynamicResolutionInvalidParameterError({ field, value, expected });
+}
+function validateDynamicResolutionParameters(input) {
+  const value = input ?? {};
+  const targetGpuMs = value.targetGpuMs ?? DEFAULT_DYNAMIC_RESOLUTION.targetGpuMs;
+  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"));
+  }
+  if (!Number.isFinite(minScale) || minScale < 0.5 || minScale > 1) {
+    return err(invalid("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]"));
+  }
+  if (minScale > maxScale) {
+    return err(invalid("minScale", minScale, "less than or equal to maxScale"));
+  }
+  return ok(Object.freeze({ targetGpuMs, minScale, maxScale }));
+}
+function validateDynamicResolutionCamera(input, antialias) {
+  if (input === void 0) return ok(void 0);
+  const parameters = validateDynamicResolutionParameters(input);
+  if (!parameters.ok) return parameters;
+  if (antialias !== "taa") {
+    return err(new DynamicResolutionRequiresTaaError({ antialias }));
+  }
+  return parameters;
+}
 var Fog = defineComponent("Fog", {
   color: { type: "array<f32, 3>", default: new Float32Array([0.5, 0.5, 0.5]) },
   density: { type: "f32", default: 0.01 },
@@ -277,7 +504,7 @@ var Fog = defineComponent("Fog", {
   maxOpacity: { type: "f32", default: 1 }
 });
 var Instances = defineComponent("Instances", {
-  transforms: { type: "array<f32>" }
+  collectionId: { type: "u32", default: 0 }
 });
 var Layer = defineComponent("Layer", {
   value: { type: "i32", default: 0 }
@@ -360,7 +587,7 @@ function validateDirectionalLightData(data) {
         })
       );
     }
-    if (shadowAngularRadius < PCSS_RADIUS_MIN || shadowAngularRadius > PCSS_RADIUS_MAX) {
+    if (shadowAngularRadius < Math.fround(PCSS_RADIUS_MIN) || shadowAngularRadius > Math.fround(PCSS_RADIUS_MAX)) {
       return err(
         new ShadowInvalidConfigError("shadowAngularRadius", shadowAngularRadius, {
           kind: "range",
@@ -606,6 +833,7 @@ function reflectionProbeUpdateIntentToF32(intent) {
 var ReflectionProbe = defineComponent("ReflectionProbe", {
   halfExtents: { type: "array<f32, 3>", default: new Float32Array([1, 1, 1]) },
   priority: { type: "f32", default: 0 },
+  boxProjection: { type: "bool", default: false },
   intensity: { type: "f32", default: 1 },
   resolution: { type: "u32", default: 256 },
   updateIntent: { type: "f32", default: REFLECTION_PROBE_UPDATE_ONCE },
@@ -622,6 +850,11 @@ var SceneInstance = defineComponent(
   },
   { transient: true }
 );
+var ScreenSpaceReflection = defineComponent("ScreenSpaceReflection", {
+  maxDistance: { type: "f32", default: 40 },
+  thickness: { type: "f32", default: 0.2 },
+  maxRoughness: { type: "f32", default: 0.6 }
+});
 var SKYBOX_MODE_CUBEMAP = 0;
 var SkyboxBackground = defineComponent("SkyboxBackground", {
   // The GPU skybox projection is render-owned presentation state; restore
@@ -710,33 +943,6 @@ var Visibility = defineComponent(
     }
   }
 );
-
-// src/scene/visibility/budget.ts
-var DEFAULT_CONFIGURED_QUERY_BUDGET = 2048;
-var MAX_QUERY_BUDGET = 4096;
-var VISIBILITY_CANDIDATE_COUNT = 1e5;
-var VISIBILITY_OCCLUDED_COUNT = 9e4;
-function createVisibilityBudget(configuredQueryBudget = DEFAULT_CONFIGURED_QUERY_BUDGET) {
-  if (!Number.isSafeInteger(configuredQueryBudget) || configuredQueryBudget <= 0) {
-    throw new RangeError("configuredQueryBudget must be a positive safe integer");
-  }
-  const effectiveQueryBudget = Math.min(configuredQueryBudget, MAX_QUERY_BUDGET);
-  const oneSweepCandidates = oneSweep(VISIBILITY_CANDIDATE_COUNT, effectiveQueryBudget);
-  const oneSweepOccluded = oneSweep(VISIBILITY_OCCLUDED_COUNT, effectiveQueryBudget);
-  const retestSubmits = Math.max(6, oneSweepOccluded);
-  return Object.freeze({
-    configuredQueryBudget,
-    effectiveQueryBudget,
-    oneSweepCandidates,
-    oneSweepOccluded,
-    settleSubmits: 2 * oneSweepCandidates,
-    retestSubmits,
-    expirySubmits: Math.max(8, retestSubmits + oneSweepOccluded)
-  });
-}
-function oneSweep(candidateCount, effectiveQueryBudget) {
-  return Math.ceil(candidateCount / effectiveQueryBudget);
-}
 function hasVolumetricFogCapability(caps, shaders) {
   return caps.compute && caps.storageTexture && shaders !== void 0;
 }
@@ -823,6 +1029,48 @@ function resolveSelectedVolumetricLight(world, entity) {
 function resolveIntegratedVolumeConsumer(resource, consumer) {
   return { consumer, resource };
 }
+var FACE_ORIENTATION = [
+  { direction: [1, 0, 0], up: [0, 1, 0] },
+  { direction: [-1, 0, 0], up: [0, 1, 0] },
+  { direction: [0, 1, 0], up: [0, 0, -1] },
+  { direction: [0, -1, 0], up: [0, 0, 1] },
+  { direction: [0, 0, 1], up: [0, 1, 0] },
+  { direction: [0, 0, -1], up: [0, 1, 0] }
+];
+function assertRange(near, far) {
+  if (!Number.isFinite(near) || near <= 0 || !Number.isFinite(far) || far <= near) {
+    throw new RangeError("CubeCamera requires finite near > 0 and far > near.");
+  }
+}
+function buildCubeCameraFaceViews(input) {
+  assertRange(input.near, input.far);
+  const views = [];
+  for (const [index, face] of CUBE_CAMERA_FACE_ORDER.entries()) {
+    const orientation = FACE_ORIENTATION[index];
+    if (orientation === void 0)
+      throw new Error(`CubeCamera face orientation missing at ${index}`);
+    const target = [
+      (input.position[0] ?? 0) + orientation.direction[0],
+      (input.position[1] ?? 0) + orientation.direction[1],
+      (input.position[2] ?? 0) + orientation.direction[2]
+    ];
+    const view = mat4.lookAt(mat4.create(), input.position, target, orientation.up);
+    const projection = mat4.perspective(mat4.create(), Math.PI / 2, 1, input.near, input.far);
+    const viewProjection = mat4.multiply(mat4.create(), projection, view);
+    views.push({
+      position: input.position,
+      face,
+      direction: orientation.direction,
+      up: orientation.up,
+      near: input.near,
+      far: input.far,
+      view,
+      projection,
+      viewProjection
+    });
+  }
+  return views;
+}
 
 // src/mesh-material-bindings.ts
 var EMPTY_RESIDENCY = Object.freeze({
@@ -1053,6 +1301,6 @@ function extractVolumetricFog(inputs) {
   return ok({ status: "available", fog: validated.value });
 }
 
-export { ANTIALIAS_FXAA, ANTIALIAS_MSAA, ANTIALIAS_NONE, ANTIALIAS_TAA, Atmosphere, BLOOM_DISABLED, BLOOM_ENABLED, CAMERA_PROJECTION_ORTHOGRAPHIC, CAMERA_PROJECTION_PERSPECTIVE, CUBE_CAMERA_FACE_ORDER, CUBE_CAMERA_UPDATE_CONTINUOUS, CUBE_CAMERA_UPDATE_ONCE, CUBE_CAMERA_UPDATE_ON_DEMAND, Camera, CubeCamera, DirectionalLight, DirectionalShadowFilterValue, 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, 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, cameraProjectionFromF32, computeInvRangeSquared, createVisibilityBudget, cubeCameraUpdateIntentFromF32, cubeCameraUpdateIntentToF32, degToCos, directionalShadowQualityFromF32, extractVolumetricFog, hasVolumetricFogCapability, orthographic, perspective, pointShapeFromU32, projectMeshMaterialBindingObservation, reflectionProbeUpdateIntentFromF32, reflectionProbeUpdateIntentToF32, resolveIntegratedVolumeConsumer, resolveMeshMaterialBindings, resolveSelectedVolumetricLight, resolveVisibility, resolveVolumetricFogLightPair, summarizeMeshMaterialBindings, tonemapFromF32, tonemapToU32, validateDirection, validateDirectionalLightData, validateLightProbeData, validatePointLightData, validatePointLightShadowData, validateRectAreaLightData, validateSpotLightData, validateVolumetricFog, visibilityStateFromU32 };
-//# sourceMappingURL=chunk-JAASCMXA.mjs.map
-//# sourceMappingURL=chunk-JAASCMXA.mjs.map
+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, 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, directionalShadowQualityFromF32, extractVolumetricFog, hasVolumetricFogCapability, orthographic, perspective, pointShapeFromU32, projectMeshMaterialBindingObservation, reflectionProbeUpdateIntentFromF32, reflectionProbeUpdateIntentToF32, resolveIntegratedVolumeConsumer, resolveMeshMaterialBindings, resolveSelectedVolumetricLight, resolveVisibility, resolveVolumetricFogLightPair, summarizeMeshMaterialBindings, tonemapFromF32, tonemapToU32, validateCameraColorGrading, validateCameraExposure, validateDirection, validateDirectionalLightData, validateDynamicResolutionCamera, validateDynamicResolutionParameters, validateLightProbeData, validatePointLightData, validatePointLightShadowData, validateRectAreaLightData, validateSpotLightData, validateVolumetricFog, visibilityStateFromU32 };
+//# sourceMappingURL=chunk-S5UE2T5P.mjs.map
+//# sourceMappingURL=chunk-S5UE2T5P.mjs.map