@forgeax/engine-render 0.1.31 → 0.1.33

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

@@ -1,4 +1,4 @@
-import { RenderIntentInvalidError, DynamicResolutionRequiresTaaError, ShadowInvalidConfigError, VolumeOwnerConflictError, VolumeDensityShapeMismatchError, VolumeInvalidBoundsError, VolumeInvalidParametersError, DynamicResolutionInvalidParameterError } from './chunk-JRBDO2KB.mjs';
+import { RenderIntentInvalidError, DynamicResolutionRequiresTaaError, ShadowInvalidConfigError, EnvironmentSourceConflictError, FogCardinalityError, VolumeOwnerConflictError, VolumeDensityShapeMismatchError, VolumeInvalidBoundsError, VolumeInvalidParametersError, DynamicResolutionInvalidParameterError, AtmosphereInvalidParameterError } from './chunk-NB2S7ZRX.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';
@@ -11,7 +11,11 @@ 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 CAMERA_PROJECTION_PERSPECTIVE = 0;
 var CAMERA_PROJECTION_ORTHOGRAPHIC = 1;
@@ -199,6 +203,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 +222,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 +282,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.
@@ -390,6 +437,36 @@ var CubeCamera = defineComponent("CubeCamera", {
   requestVersion: { type: "u32", default: 0 },
   faceBudget: { type: "u32", default: 1 }
 });
+var DepthOfFieldQualityValue = Object.freeze({
+  low: 0,
+  medium: 1,
+  high: 2
+});
+var DepthOfFieldSideValue = Object.freeze({
+  both: 0,
+  near: 1,
+  far: 2
+});
+var DepthOfField = defineComponent("DepthOfField", {
+  focusDistance: { type: "f32", default: 8 },
+  fStop: { type: "f32", default: 2.8 },
+  sensorHeight: { type: "f32", default: 0.024 },
+  maxRadiusPixels: { type: "f32", default: 16 },
+  quality: { type: "f32", default: DepthOfFieldQualityValue.medium },
+  blurSide: { type: "f32", default: DepthOfFieldSideValue.both }
+});
+function depthOfFieldQualityFromF32(value) {
+  if (value === DepthOfFieldQualityValue.low) return "low";
+  if (value === DepthOfFieldQualityValue.medium) return "medium";
+  if (value === DepthOfFieldQualityValue.high) return "high";
+  return void 0;
+}
+function depthOfFieldSideFromF32(value) {
+  if (value === DepthOfFieldSideValue.both) return "both";
+  if (value === DepthOfFieldSideValue.near) return "near";
+  if (value === DepthOfFieldSideValue.far) return "far";
+  return void 0;
+}
 
 // src/components/directional-shadow-filter.ts
 var DirectionalShadowFilterValue = Object.freeze({
@@ -747,7 +824,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
@@ -943,6 +1021,528 @@ var Visibility = defineComponent(
     }
   }
 );
+
+// 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 invalid3 = validateAtmosphereParameters(selected.atmosphere);
+    if (invalid3 !== void 0) return err(invalid3);
+  }
+  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);
+var MAX_LINEAR_DEPTH_RAW = Math.fround(1 - 2 ** -24);
+var DEFAULT_DEPTH_OF_FIELD_PARAMS = Object.freeze({
+  focusDistance: 8,
+  fStop: 2.8,
+  sensorHeight: 0.024,
+  maxRadiusPixels: 16,
+  quality: "medium",
+  blurSide: "both",
+  focalLength: 0
+});
+function quantizeF32(value) {
+  return Math.fround(value);
+}
+var DepthOfFieldValidationError = class extends Error {
+  code;
+  expected;
+  hint;
+  detail;
+  constructor(code, detail, expected, hint) {
+    super(`${code}: ${expected}`);
+    this.name = "DepthOfFieldValidationError";
+    this.code = code;
+    this.expected = expected;
+    this.hint = hint;
+    this.detail = detail;
+  }
+};
+function depthOfFieldRequestFailure(error) {
+  return Object.freeze({
+    code: error.code,
+    detail: error.detail,
+    expected: error.expected,
+    hint: error.hint
+  });
+}
+function resolveDepthOfFieldFrameParams(requested, requestFailure, accepted) {
+  if (requested !== void 0) return requested;
+  if (requestFailure === void 0 || requestFailure.code === "depth-of-field-orthographic-unsupported") {
+    return void 0;
+  }
+  return accepted;
+}
+function invalid2(field, value, expected, bound) {
+  return new DepthOfFieldValidationError(
+    "depth-of-field-invalid-params",
+    { field, value, expected, ...bound === void 0 ? {} : { bound } },
+    expected,
+    `set ${field} to ${expected}`
+  );
+}
+function focalLength(sensorHeight, fov) {
+  return sensorHeight / (2 * Math.tan(fov / 2));
+}
+function opticalCocScale(params) {
+  return params.focalLength / params.sensorHeight / (2 * params.fStop) * (params.focalLength / (params.focusDistance - params.focalLength));
+}
+function frameCocCoefficient(params, outputHeight) {
+  return quantizeF32(quantizeF32(outputHeight) * opticalCocScale(params));
+}
+function resolveDepthOfFieldFrameValues(params, input) {
+  const focusDistance = quantizeF32(params.focusDistance);
+  const fStop = quantizeF32(params.fStop);
+  const sensorHeight = quantizeF32(params.sensorHeight);
+  const focal = quantizeF32(params.focalLength);
+  const maxRadiusPixels = quantizeF32(params.maxRadiusPixels);
+  const outputHeight = quantizeF32(input.outputHeight);
+  const near = quantizeF32(input.near);
+  const far = quantizeF32(input.far);
+  const finitePositiveFields = [
+    ["focusDistance", focusDistance, params.focusDistance],
+    ["sensorHeight", sensorHeight, params.sensorHeight],
+    ["focalLength", focal, params.focalLength],
+    ["near", near, input.near],
+    ["far", far, input.far]
+  ];
+  for (const [field, value, raw] of finitePositiveFields) {
+    if (!Number.isFinite(value) || value <= 0) {
+      return err(invalid2(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])
+    );
+  }
+  if (!Number.isFinite(maxRadiusPixels) || maxRadiusPixels < 0 || maxRadiusPixels > 32) {
+    return err(
+      invalid2("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"));
+  }
+  if (far <= near) {
+    return err(invalid2("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"));
+  }
+  const depthRatio = quantizeF32(near / far);
+  if (!Number.isFinite(depthRatio) || depthRatio <= 0) {
+    return err(invalid2("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);
+    const weightedRatio = quantizeF32(raw * depthRatio);
+    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"));
+    }
+  }
+  const cocCoefficient = frameCocCoefficient(
+    {
+      focusDistance,
+      fStop,
+      sensorHeight,
+      focalLength: focal
+    },
+    outputHeight
+  );
+  if (!Number.isFinite(cocCoefficient) || cocCoefficient <= 0) {
+    return err(
+      invalid2("cocCoefficient", cocCoefficient, "a finite positive value representable as f32")
+    );
+  }
+  for (const [field, depth] of [
+    ["near", near],
+    ["far", far]
+  ]) {
+    const focusOverDepth = quantizeF32(focusDistance / depth);
+    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 ok({
+    focusDistance,
+    fStop,
+    sensorHeight,
+    focalLength: focal,
+    maxRadiusPixels,
+    outputHeight,
+    near,
+    far,
+    cocCoefficient
+  });
+}
+function validateDepthOfFieldFrameParams(params, input) {
+  const resolved = resolveDepthOfFieldFrameValues(params, input);
+  return resolved.ok ? ok(void 0) : resolved;
+}
+function validateDepthOfFieldParams(input, camera) {
+  if (camera?.projection === "orthographic") {
+    return err(
+      new DepthOfFieldValidationError(
+        "depth-of-field-orthographic-unsupported",
+        { projection: "orthographic" },
+        "DepthOfField requires a perspective Camera",
+        "use a perspective Camera or remove the DepthOfField component"
+      )
+    );
+  }
+  const value = input ?? {};
+  const focusDistance = quantizeF32(
+    value.focusDistance ?? DEFAULT_DEPTH_OF_FIELD_PARAMS.focusDistance
+  );
+  const fStop = quantizeF32(value.fStop ?? DEFAULT_DEPTH_OF_FIELD_PARAMS.fStop);
+  const sensorHeight = quantizeF32(
+    value.sensorHeight ?? DEFAULT_DEPTH_OF_FIELD_PARAMS.sensorHeight
+  );
+  const maxRadiusPixels = quantizeF32(
+    value.maxRadiusPixels ?? DEFAULT_DEPTH_OF_FIELD_PARAMS.maxRadiusPixels
+  );
+  const qualityValue = quantizeF32(value.quality ?? DepthOfFieldQualityValue.medium);
+  const blurSideValue = quantizeF32(value.blurSide ?? DepthOfFieldSideValue.both);
+  const quality = depthOfFieldQualityFromF32(qualityValue);
+  const blurSide = depthOfFieldSideFromF32(blurSideValue);
+  if (!Number.isFinite(focusDistance) || focusDistance <= 0) {
+    return err(
+      invalid2("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]", [
+        MIN_F_STOP,
+        MAX_F_STOP
+      ])
+    );
+  }
+  if (!Number.isFinite(sensorHeight) || sensorHeight <= 0) {
+    return err(
+      invalid2("sensorHeight", value.sensorHeight ?? sensorHeight, "a finite positive f32 value")
+    );
+  }
+  if (!Number.isFinite(maxRadiusPixels) || maxRadiusPixels < 0 || maxRadiusPixels > 32) {
+    return err(
+      invalid2(
+        "maxRadiusPixels",
+        value.maxRadiusPixels ?? maxRadiusPixels,
+        "a finite f32 value in [0, 32]",
+        [0, 32]
+      )
+    );
+  }
+  if (quality === void 0) {
+    return err(invalid2("quality", qualityValue, "DepthOfFieldQualityValue.low, medium, or high"));
+  }
+  if (blurSide === void 0) {
+    return err(invalid2("blurSide", blurSideValue, "DepthOfFieldSideValue.both, near, or far"));
+  }
+  let focal = DEFAULT_DEPTH_OF_FIELD_PARAMS.focalLength;
+  if (camera !== void 0) {
+    const fov = quantizeF32(camera.fov);
+    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)"));
+    }
+    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")
+      );
+    }
+    focal = quantizeF32(focalLength(sensorHeight, fov));
+    if (!Number.isFinite(focal) || focal <= 0) {
+      return err(invalid2("focalLength", focal, "a finite positive f32 value"));
+    }
+    if (focusDistance < near || focusDistance > far) {
+      return err(
+        invalid2("focusDistance", focusDistance, `a value in [${near}, ${far}]`, [near, far])
+      );
+    }
+    if (focusDistance <= focal) {
+      return err(
+        invalid2("focusDistance", focusDistance, `greater than focalLength in f32 (${focal})`)
+      );
+    }
+  }
+  return ok(
+    Object.freeze({
+      focusDistance,
+      fStop,
+      sensorHeight,
+      maxRadiusPixels,
+      quality,
+      blurSide,
+      focalLength: focal
+    })
+  );
+}
+function resolveDepthOfFieldParams(input, camera) {
+  if (input === void 0) return ok(void 0);
+  return validateDepthOfFieldParams(input, camera);
+}
+function depthOfFieldTapCount(quality) {
+  switch (quality) {
+    case "low":
+      return 16;
+    case "medium":
+      return 32;
+    case "high":
+      return 64;
+  }
+}
+function depthOfFieldSideCode(side) {
+  switch (side) {
+    case "both":
+      return DepthOfFieldSideValue.both;
+    case "near":
+      return DepthOfFieldSideValue.near;
+    case "far":
+      return DepthOfFieldSideValue.far;
+  }
+}
+function depthOfFieldQualityCode(quality) {
+  switch (quality) {
+    case "low":
+      return DepthOfFieldQualityValue.low;
+    case "medium":
+      return DepthOfFieldQualityValue.medium;
+    case "high":
+      return DepthOfFieldQualityValue.high;
+  }
+}
+function signedDepthOfFieldCoC(params, viewDepth, outputHeight) {
+  if (!Number.isFinite(viewDepth) || viewDepth <= 0 || !Number.isFinite(outputHeight) || outputHeight <= 0 || !Number.isFinite(params.focalLength) || params.focalLength <= 0 || !Number.isFinite(params.sensorHeight) || params.sensorHeight <= 0 || !Number.isFinite(params.fStop) || params.fStop <= 0 || !Number.isFinite(params.focusDistance) || params.focusDistance <= params.focalLength) {
+    return 0;
+  }
+  const focusDistance = quantizeF32(params.focusDistance);
+  const depth = quantizeF32(viewDepth);
+  const focalLength2 = quantizeF32(params.focalLength);
+  const sensorHeight = quantizeF32(params.sensorHeight);
+  const fStop = quantizeF32(params.fStop);
+  const coefficient = frameCocCoefficient(
+    { focusDistance, focalLength: focalLength2, sensorHeight, fStop },
+    outputHeight
+  );
+  const depthFactor = quantizeF32(1 - quantizeF32(focusDistance / depth));
+  const radius = quantizeF32(coefficient * depthFactor);
+  const limit = Number.isFinite(params.maxRadiusPixels) ? quantizeF32(params.maxRadiusPixels) : Number.POSITIVE_INFINITY;
+  return Math.max(-limit, Math.min(limit, Number.isFinite(radius) ? radius : 0));
+}
+function packDepthOfFieldParams(params, input) {
+  const frameValues = resolveDepthOfFieldFrameValues(params, input);
+  if (!frameValues.ok) throw frameValues.error;
+  const {
+    focusDistance,
+    fStop,
+    sensorHeight,
+    focalLength: focal,
+    outputHeight,
+    maxRadiusPixels,
+    near,
+    far,
+    cocCoefficient
+  } = frameValues.value;
+  const payload = new Float32Array(DEPTH_OF_FIELD_PARAMS_BYTE_SIZE / 4);
+  payload.set([
+    focusDistance,
+    fStop,
+    sensorHeight,
+    focal,
+    outputHeight,
+    maxRadiusPixels,
+    depthOfFieldSideCode(params.blurSide),
+    depthOfFieldQualityCode(params.quality),
+    near,
+    far,
+    input.useTemporalDepth ? 1 : 0,
+    0,
+    // row2.w reserved
+    cocCoefficient,
+    // row3.x / WGSL reserved.x
+    0,
+    0,
+    0
+  ]);
+  return new Uint8Array(payload.buffer);
+}
 function hasVolumetricFogCapability(caps, shaders) {
   return caps.compute && caps.storageTexture && shaders !== void 0;
 }
@@ -1095,6 +1695,7 @@ function projectMeshMaterialBindingObservation(input) {
   });
   return {
     worldId: input.worldId,
+    ...input.worldIdentity === void 0 ? {} : { worldIdentity: input.worldIdentity },
     entityKey: input.entityKey,
     bindings: Object.freeze([...input.bindings]),
     diagnostics: Object.freeze([...input.diagnostics]),
@@ -1301,6 +1902,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_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
+export { ANTIALIAS_FXAA, ANTIALIAS_MSAA, ANTIALIAS_NONE, ANTIALIAS_TAA, Atmosphere, BLOOM_DISABLED, BLOOM_ENABLED, 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, 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, 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, antialiasFromF32, 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, selectEnvironment, signedDepthOfFieldCoC, summarizeMeshMaterialBindings, tonemapFromF32, tonemapToU32, validateCameraBloom, validateCameraColorGrading, validateCameraExposure, validateDepthOfFieldFrameParams, validateDepthOfFieldParams, validateDirection, validateDirectionalLightData, validateDynamicResolutionCamera, validateDynamicResolutionParameters, validateLightProbeData, validatePointLightData, validatePointLightShadowData, validateRectAreaLightData, validateSpotLightData, validateVolumetricFog, visibilityStateFromU32 };
+//# sourceMappingURL=chunk-PLAXOOX5.mjs.map
+//# sourceMappingURL=chunk-PLAXOOX5.mjs.map