@forgeax/engine-render 0.1.21 → 0.1.23

package/dist/{chunk-6OPXDQ2E.mjs → chunk-QODA5UKU.mjs}

@@ -1,58 +1,5 @@
-import { err, ok } from '@forgeax/engine-types';
 import { cubeArrayDepthDescriptor, comparisonSamplerDescriptor, cubeArrayDepthFaceView } from '@forgeax/engine-rhi';
 
-// src/ibl/kernel-cache.ts
-var REFLECTION_PROBE_IBL_STAGES = ["raw", "filtered", "publish"];
-var kernelCaches = /* @__PURE__ */ new Map();
-function createIblKernelCache(generation) {
-  const existing = kernelCaches.get(generation);
-  if (existing !== void 0) return existing;
-  const created = {
-    generation,
-    pipelineIdentity: {},
-    samplerIdentity: {},
-    brdfLutIdentity: {}
-  };
-  kernelCaches.set(generation, created);
-  return created;
-}
-function createProbeIblOutput(input) {
-  return {
-    ...input,
-    raw: {},
-    filtered: {},
-    rawGeneration: 0,
-    filteredGeneration: 0,
-    lkg: true
-  };
-}
-function beginProbeIblUpdate(output) {
-  return {
-    ...output,
-    stages: REFLECTION_PROBE_IBL_STAGES,
-    nextStage: "raw",
-    candidateGeneration: output.filteredGeneration + 1
-  };
-}
-function publishProbeIblOutput(update, result) {
-  if (!result.ok || result.stage !== update.nextStage) return update;
-  if (result.stage === "raw") {
-    return {
-      ...update,
-      rawGeneration: update.candidateGeneration
-    };
-  }
-  if (result.stage === "filtered") return update;
-  return {
-    ...update,
-    filteredGeneration: update.candidateGeneration,
-    lkg: true
-  };
-}
-function resetIblKernelCaches() {
-  kernelCaches.clear();
-}
-
 // src/errors/render.ts
 var LifecycleConstructionError = class extends Error {
   code = "lifecycle-construction-failed";
@@ -65,6 +12,33 @@ var LifecycleConstructionError = class extends Error {
     this.detail = detail;
   }
 };
+var LightResourceUnavailableError = class extends Error {
+  code = "light-resource-unavailable";
+  expected;
+  hint;
+  detail;
+  constructor(detail, expected, actual, hint) {
+    super(`light-resource-unavailable: ${detail.feature} ${actual}`);
+    this.name = "LightResourceUnavailableError";
+    this.expected = expected;
+    this.hint = hint;
+    this.detail = detail;
+  }
+};
+function createLightResourceUnavailable(input) {
+  return new LightResourceUnavailableError(
+    {
+      entity: input.entity,
+      feature: input.feature,
+      generation: input.generation,
+      sourceKey: input.sourceKey,
+      reason: input.reason
+    },
+    input.expected,
+    input.actual,
+    input.hint
+  );
+}
 var TemporalFrameSubmitError = class extends Error {
   code = "temporal-frame-submit-rejected";
   expected = "the staged frame is accepted by queue.submit before temporal facts advance";
@@ -800,244 +774,6 @@ var VolumeInvalidParametersError = class extends Error {
   }
 };
 
-// src/temporal/scene-data.ts
-var SCENE_DATA_TEMPORAL_V1_SCHEMA = "forgeax::scene-data::temporal-v1";
-var SCENE_DATA_TEMPORAL_V1_DESCRIPTOR = Object.freeze({
-  schema: SCENE_DATA_TEMPORAL_V1_SCHEMA,
-  format: "rgba16float",
-  sampleCount: 1,
-  extent: "render-resolution",
-  clearValue: [0, 0, -1, 1],
-  channels: Object.freeze({
-    motionUv: "rg",
-    viewDepth: "b-log2-1-plus-depth",
-    reactive: "a"
-  })
-});
-var targetOwners = /* @__PURE__ */ new WeakMap();
-function registerSceneDataTarget(target, owner) {
-  targetOwners.set(target, owner);
-}
-function sceneDataTargetOwner(target) {
-  return typeof target === "object" && target !== null ? targetOwners.get(target) : void 0;
-}
-function sceneDataTokenMismatch(operation, reason, owner, target) {
-  const detail = reason === "generation-mismatch" ? {
-    featureIdentity: owner.featureIdentity,
-    order: -1,
-    stage: "contribute",
-    operation,
-    resourceKind: "attachment",
-    reason,
-    expectedGeneration: owner.generation,
-    actualGeneration: targetOwners.get(target)?.generation ?? -1,
-    recovery: "renderer-recover"
-  } : reason === "foreign-feature" ? {
-    featureIdentity: owner.featureIdentity,
-    order: -1,
-    stage: "contribute",
-    operation,
-    resourceKind: "attachment",
-    reason,
-    expectedFeatureIdentity: owner.featureIdentity,
-    actualFeatureIdentity: targetOwners.get(target)?.featureIdentity ?? "unknown",
-    recovery: "next-frame"
-  } : reason === "foreign-kind" ? {
-    featureIdentity: owner.featureIdentity,
-    order: -1,
-    stage: "contribute",
-    operation,
-    resourceKind: "attachment",
-    reason,
-    expectedKind: "attachment",
-    actualKind: "pipeline",
-    recovery: "next-frame"
-  } : {
-    featureIdentity: owner.featureIdentity,
-    order: -1,
-    stage: "contribute",
-    operation,
-    resourceKind: "attachment",
-    reason,
-    expectedLayout: "sampled-read-temporal-v1",
-    actualLayout: target?.access ?? "unknown",
-    recovery: "next-frame"
-  };
-  return new RenderFeaturePreparedStateMismatchError(detail);
-}
-function isSceneDataTarget(value) {
-  if (value === null || typeof value !== "object") return false;
-  const candidate = value;
-  return candidate.kind === "scene-data" && candidate.schema === SCENE_DATA_TEMPORAL_V1_SCHEMA && candidate.access === "sampled-read" && candidate.format === "rgba16float" && candidate.sampleCount === 1 && candidate.extent === "render-resolution" && targetOwners.has(value);
-}
-function sceneDataTargetAsAttachment(_target) {
-  throw new TypeError("SceneDataTarget is sampled-read-only and cannot be used as an attachment");
-}
-function sceneDataError(error) {
-  return error;
-}
-function availability(options) {
-  if (options.recovering) return { status: "unavailable", reason: "renderer-recovering" };
-  if (!options.rgba16floatRenderable)
-    return { status: "unavailable", reason: "capability-missing" };
-  if (options.producerPresent === false)
-    return { status: "unavailable", reason: "producer-missing" };
-  if (options.coverageComplete === false)
-    return { status: "unavailable", reason: "coverage-incomplete" };
-  return {
-    status: "available",
-    completeness: options.reactiveFallback ? "exact-with-reactive-fallback" : "exact"
-  };
-}
-function createTarget(owner) {
-  const target = Object.freeze({
-    kind: "scene-data",
-    schema: SCENE_DATA_TEMPORAL_V1_SCHEMA,
-    access: "sampled-read",
-    format: "rgba16float",
-    sampleCount: 1,
-    extent: "render-resolution"
-  });
-  registerSceneDataTarget(target, {
-    featureIdentity: owner.featureIdentity,
-    planIdentity: owner.planIdentity,
-    generation: owner.generation
-  });
-  return target;
-}
-function tokenError(catalog, operation) {
-  return sceneDataTokenMismatch(
-    operation,
-    "foreign-kind",
-    {
-      featureIdentity: catalog.featureIdentity,
-      planIdentity: catalog.planIdentity,
-      generation: catalog.generation
-    },
-    void 0
-  );
-}
-function unavailableError(options, reason) {
-  const recovery = reason === "capability-missing" ? "enable-capability" : reason === "renderer-recovering" ? "renderer-recover" : "next-frame";
-  return new SceneDataUnavailableError({
-    featureIdentity: options.featureIdentity,
-    schema: SCENE_DATA_TEMPORAL_V1_SCHEMA,
-    lane: options.lane ?? "direct",
-    reason,
-    missingContributorIds: options.missingContributorIds ?? [],
-    omittedMissingContributorCount: 0,
-    recovery
-  });
-}
-function createSceneDataCatalog(options) {
-  const state = availability(options);
-  const owner = {
-    featureIdentity: options.featureIdentity,
-    planIdentity: options.planIdentity,
-    generation: options.generation
-  };
-  const missing = [...options.missingContributorIds ?? []];
-  const inspectionBase = {
-    schema: SCENE_DATA_TEMPORAL_V1_SCHEMA,
-    generation: options.generation,
-    planIdentity: options.planIdentity,
-    lane: options.lane ?? "direct",
-    missingContributorIds: Object.freeze(missing.slice(0, 32)),
-    omittedMissingContributorCount: Math.max(0, missing.length - 32)
-  };
-  return {
-    schema: SCENE_DATA_TEMPORAL_V1_SCHEMA,
-    generation: options.generation,
-    planIdentity: options.planIdentity,
-    availability: state,
-    require(schema) {
-      if (schema !== SCENE_DATA_TEMPORAL_V1_SCHEMA || state.status !== "available") {
-        if (state.status === "unavailable") throw unavailableError(options, state.reason);
-        throw tokenError(options, "require scene-data target");
-      }
-      return createTarget(options);
-    },
-    validate(target, generation = options.generation) {
-      const targetOwner = sceneDataTargetOwner(target);
-      if (targetOwner === void 0) {
-        return err(
-          sceneDataTokenMismatch("validate scene-data target", "foreign-feature", owner, target)
-        );
-      }
-      if (targetOwner.planIdentity !== owner.planIdentity || targetOwner.featureIdentity !== owner.featureIdentity) {
-        return err(
-          sceneDataTokenMismatch("validate scene-data target", "foreign-feature", owner, target)
-        );
-      }
-      if (generation !== owner.generation || targetOwner.generation !== owner.generation) {
-        return err(
-          sceneDataTokenMismatch(
-            "validate scene-data target",
-            "generation-mismatch",
-            owner,
-            target
-          )
-        );
-      }
-      if (target.access !== "sampled-read") {
-        return err(
-          sceneDataTokenMismatch("validate scene-data target", "layout-mismatch", owner, target)
-        );
-      }
-      return ok(target);
-    },
-    inspect() {
-      return Object.freeze(
-        state.status === "available" ? { ...inspectionBase, status: state.status, completeness: state.completeness } : { ...inspectionBase, status: state.status, reason: state.reason }
-      );
-    }
-  };
-}
-
-// src/pipeline/standard-lighting/layout.ts
-var DEFAULT_CLUSTER_GRID = { x: 16, y: 9, z: 24 };
-var CLUSTER_GRID_STRIDE_U32 = 2;
-var LIGHT_INDEX_LIST_CAPACITY = 1048576;
-var MAX_LIGHTS = 256;
-function createStandardClusterLayout(grid = DEFAULT_CLUSTER_GRID) {
-  const clusterCount = grid.x * grid.y * grid.z;
-  return Object.freeze({
-    grid,
-    clusterCount,
-    clusterGridStrideU32: CLUSTER_GRID_STRIDE_U32,
-    clusterGridU32Length: clusterCount * CLUSTER_GRID_STRIDE_U32,
-    lightIndexListCapacity: LIGHT_INDEX_LIST_CAPACITY,
-    lightDataSlotCount: MAX_LIGHTS,
-    lightBoundsInt32Length: MAX_LIGHTS * 6
-  });
-}
-createStandardClusterLayout();
-
-// src/pipeline/standard-profile.ts
-var STANDARD_PIPELINE_ID = "forgeax::standard";
-var STANDARD_LIGHT_COUNTS = [1, 32, 256];
-var STANDARD_POST_STAGE_NAMES = [
-  "transparent-blend",
-  "bloom",
-  "output-transform",
-  "fxaa",
-  "post-effect",
-  "present"
-];
-var DEFAULT_STANDARD_PROFILE = Object.freeze({
-  pipelineId: STANDARD_PIPELINE_ID,
-  lightCount: 32,
-  renderPath: "forward",
-  shadows: "filtered",
-  pbr: true,
-  ibl: true,
-  ssao: false,
-  postStages: STANDARD_POST_STAGE_NAMES
-});
-function resolveVolumetricFogProfile(profile) {
-  return profile.volumetricFog ?? { quality: "high", depth: 64, tileSize: 4 };
-}
-
 // src/gpu-texture-usage.ts
 var GPU_TEXTURE_USAGE_COPY_SRC = 1;
 var GPU_TEXTURE_USAGE_COPY_DST = 2;
@@ -1252,6 +988,8 @@ var RENDER_SCENE_STATE_PHASE_CATALOG = [
   ...RENDER_HDRP_CLUSTER_PHASE_CATALOG
 ];
 var RENDER_RECORD_PHASE_CATALOG = [
+  "record/occlusion-query-submit",
+  "record/occlusion-global-advance",
   "record/scene-state",
   ...RENDER_SCENE_STATE_PHASE_CATALOG,
   "record/swapchain",
@@ -1266,6 +1004,7 @@ var RENDER_RECORD_PHASE_CATALOG = [
 ];
 var RENDER_PHASE_CATALOG = [
   "extract",
+  "occlusion-prepare",
   "bind-groups",
   "features",
   "sort",
@@ -1273,6 +1012,6 @@ var RENDER_PHASE_CATALOG = [
   ...RENDER_RECORD_PHASE_CATALOG
 ];
 
-export { AtmosphereInvalidParameterError, CLUSTER_GRID_STRIDE_U32, DEFAULT_CLUSTER_GRID, DEFAULT_STANDARD_PROFILE, EnvironmentGenerationFailedError, EnvironmentSourceConflictError, EquirectProjectionFailedError, FXAA_POST_PROCESS_ID, FogCardinalityError, FrameReceiptStaleError, GPU_TEXTURE_USAGE_COPY_DST, GPU_TEXTURE_USAGE_COPY_SRC, GPU_TEXTURE_USAGE_RENDER_ATTACHMENT, GPU_TEXTURE_USAGE_RENDER_ATTACHMENT_AND_TEXTURE_BINDING, GPU_TEXTURE_USAGE_TEXTURE_BINDING, LIGHT_INDEX_LIST_CAPACITY, LifecycleConstructionError, MAX_LIGHTS, MaterialSkinAttrMissingError, ObservationUnavailableError, OwnerStageFailedError, PointShadowAtlasBoundsViolationError, PointShadowAtlasUninitializedError, PointsLinesBudgetExceededError, PointsLinesInvalidStyleError, PointsLinesMaterialUnsupportedError, PointsLinesPrepareFailedError, PointsLinesStyleUnsupportedError, PointsLinesTopologyMismatchError, REFLECTION_PROBE_IBL_STAGES, RENDER_PHASE_CATALOG, RenderFeatureCapabilityMissingError, RenderFeatureDrawRecordingFailedError, RenderFeaturePreparationFailedError, RenderFeaturePreparedStateMismatchError, RenderFeatureRegistrationConflictError, RenderFeatureStageFailedError, RenderIntentInvalidError, RenderTargetCapabilityMissingError, RenderTargetDescriptorInvalidError, RenderTargetOperationFailedError, RenderTargetStateInvalidError, RendererContractFailureError, RendererOperationError, SCENE_DATA_TEMPORAL_V1_DESCRIPTOR, SCENE_DATA_TEMPORAL_V1_SCHEMA, SHADOW_ATLAS_DEFAULT_FACE_SIZE, SHADOW_ATLAS_DEFAULT_LAYERS, STANDARD_LIGHT_COUNTS, STANDARD_OUTPUT_TRANSFORM_FEATURE_ID, STANDARD_PIPELINE_ID, STANDARD_POST_STAGE_NAMES, SceneDataUnavailableError, ShadowAtlas, ShadowInvalidConfigError, SkinMaterialMismatchError, SkinPaletteOverflowError, StandardClusterIndexOverflowError, StandardClusterTransportUnavailableError, StandardLightBudgetExceededError, StandardProfileInvalidError, TaaCapsInsufficientError, TemporalFrameSubmitError, TransmissionCapabilityMissingError, VertexColorVariantConflictError, VideoUploadUnsupportedError, VolumeDensityShapeMismatchError, VolumeInvalidBoundsError, VolumeInvalidParametersError, VolumeOwnerConflictError, beginProbeIblUpdate, createIblKernelCache, createProbeIblOutput, createSceneDataCatalog, createStandardClusterLayout, isSceneDataTarget, publishProbeIblOutput, registerSceneDataTarget, resetIblKernelCaches, resolveVolumetricFogProfile, sceneDataError, sceneDataTargetAsAttachment, sceneDataTargetOwner, sceneDataTokenMismatch };
-//# sourceMappingURL=chunk-6OPXDQ2E.mjs.map
-//# sourceMappingURL=chunk-6OPXDQ2E.mjs.map
+export { AtmosphereInvalidParameterError, EnvironmentGenerationFailedError, EnvironmentSourceConflictError, EquirectProjectionFailedError, FXAA_POST_PROCESS_ID, FogCardinalityError, FrameReceiptStaleError, GPU_TEXTURE_USAGE_COPY_DST, GPU_TEXTURE_USAGE_COPY_SRC, GPU_TEXTURE_USAGE_RENDER_ATTACHMENT, GPU_TEXTURE_USAGE_RENDER_ATTACHMENT_AND_TEXTURE_BINDING, GPU_TEXTURE_USAGE_TEXTURE_BINDING, LifecycleConstructionError, MaterialSkinAttrMissingError, ObservationUnavailableError, OwnerStageFailedError, PointShadowAtlasBoundsViolationError, PointShadowAtlasUninitializedError, PointsLinesBudgetExceededError, PointsLinesInvalidStyleError, PointsLinesMaterialUnsupportedError, PointsLinesPrepareFailedError, PointsLinesStyleUnsupportedError, PointsLinesTopologyMismatchError, RENDER_PHASE_CATALOG, RenderFeatureCapabilityMissingError, RenderFeatureDrawRecordingFailedError, RenderFeaturePreparationFailedError, RenderFeaturePreparedStateMismatchError, RenderFeatureRegistrationConflictError, RenderFeatureStageFailedError, RenderIntentInvalidError, RenderTargetCapabilityMissingError, RenderTargetDescriptorInvalidError, RenderTargetOperationFailedError, RenderTargetStateInvalidError, RendererContractFailureError, RendererOperationError, SHADOW_ATLAS_DEFAULT_FACE_SIZE, SHADOW_ATLAS_DEFAULT_LAYERS, STANDARD_OUTPUT_TRANSFORM_FEATURE_ID, SceneDataUnavailableError, ShadowAtlas, ShadowInvalidConfigError, SkinMaterialMismatchError, SkinPaletteOverflowError, StandardClusterIndexOverflowError, StandardClusterTransportUnavailableError, StandardLightBudgetExceededError, StandardProfileInvalidError, TaaCapsInsufficientError, TemporalFrameSubmitError, TransmissionCapabilityMissingError, VertexColorVariantConflictError, VideoUploadUnsupportedError, VolumeDensityShapeMismatchError, VolumeInvalidBoundsError, VolumeInvalidParametersError, VolumeOwnerConflictError, createLightResourceUnavailable };
+//# sourceMappingURL=chunk-QODA5UKU.mjs.map
+//# sourceMappingURL=chunk-QODA5UKU.mjs.map