@forgeax/engine-render 0.1.30 → 0.1.32

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

@@ -1,4 +1,4 @@
-import { RenderIntentInvalidError, DynamicResolutionRequiresTaaError, ShadowInvalidConfigError, VolumeOwnerConflictError, VolumeDensityShapeMismatchError, VolumeInvalidBoundsError, VolumeInvalidParametersError, DynamicResolutionInvalidParameterError } from './chunk-JRBDO2KB.mjs';
+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 { R_MIN, err, ok } from '@forgeax/engine-types';
@@ -390,6 +390,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({
@@ -943,6 +973,351 @@ var Visibility = defineComponent(
     }
   }
 );
+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 +1470,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 +1677,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_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