@forgeax/engine-render 0.1.6 → 0.1.19

package/dist/{chunk-SCRSAK5B.mjs → chunk-YTQ5C7YQ.mjs}

@@ -1,8 +1,16 @@
-import { defineComponent, Entity } from '@forgeax/engine-ecs';
+import { PointsLinesBudgetExceededError, PointsLinesStyleUnsupportedError, PointsLinesMaterialUnsupportedError, PointsLinesInvalidStyleError, PointsLinesTopologyMismatchError } from './chunk-LOSO4CTV.mjs';
+import { defineComponent } from '@forgeax/engine-ecs';
 import { TONEMAP_SHADER_MODE } from '@forgeax/engine-shader';
+import { err, ok } from '@forgeax/engine-types';
 import { projectHierarchy } from '@forgeax/engine-scene';
 
-// src/components/camera.ts
+var Atmosphere = defineComponent("Atmosphere", {
+  turbidity: { type: "f32", default: 2 },
+  rayleigh: { type: "f32", default: 1 },
+  mieCoefficient: { type: "f32", default: 5e-3 },
+  mieDirectionalG: { type: "f32", default: 0.8 },
+  sunAngularRadius: { type: "f32", default: 4675e-6 }
+});
 var CAMERA_PROJECTION_PERSPECTIVE = 0;
 var CAMERA_PROJECTION_ORTHOGRAPHIC = 1;
 function cameraProjectionFromF32(value) {
@@ -182,18 +190,43 @@ var DirectionalLight = defineComponent("DirectionalLight", {
   shadowDistance: { type: "f32", default: 200 },
   pcfKernelSize: { type: "f32", default: 3 }
 });
+var Fog = defineComponent("Fog", {
+  color: { type: "array<f32, 3>", default: new Float32Array([0.5, 0.5, 0.5]) },
+  density: { type: "f32", default: 0.01 },
+  heightFalloff: { type: "f32", default: 0 },
+  maxOpacity: { type: "f32", default: 1 }
+});
 var Instances = defineComponent("Instances", {
   transforms: { type: "array<f32>" }
 });
 var Layer = defineComponent("Layer", {
   value: { type: "i32", default: 0 }
 });
+var Lines = defineComponent(
+  "Lines",
+  {
+    widthPx: { type: "f32", default: 1 }
+  },
+  {
+    meta: {
+      quickStart: "Attach Lines to render line-list MeshAsset pairs in screen pixels.",
+      diagnostics: "Inspect widthPx at the points-lines admission boundary.",
+      recovery: "Use points-lines-invalid-style for non-finite or non-positive widthPx values.",
+      boundaries: "Lines owns raster width only; MeshFilter and MeshRenderer own geometry and material."
+    }
+  }
+);
 var MeshFilter = defineComponent("MeshFilter", {
   assetHandle: { type: "shared<MeshAsset>" }
 });
 var MeshRenderer = defineComponent("MeshRenderer", {
   materials: { type: "array<shared<MaterialAsset>>", default: [] }
 });
+var MotionBlur = defineComponent("MotionBlur", {
+  shutterAngle: { type: "f32", default: 180 },
+  maxRadiusPixels: { type: "f32", default: 32 },
+  sampleCount: { type: "f32", default: 8 }
+});
 var PointLight = defineComponent("PointLight", {
   // color carries an explicit layer-2 default [1,1,1] (white); the array
   // layer-3 fallback is all-zero, so the default MUST be explicit (D-5).
@@ -209,6 +242,35 @@ var PointLightShadow = defineComponent("PointLightShadow", {
   farPlane: { type: "f32", default: 25 },
   pcfKernelSize: { type: "f32", default: 3 }
 });
+var PointShapeValue = Object.freeze({
+  square: 0,
+  circle: 1
+});
+function pointShapeFromU32(value) {
+  switch (value) {
+    case PointShapeValue.square:
+      return "square";
+    case PointShapeValue.circle:
+      return "circle";
+    default:
+      return void 0;
+  }
+}
+var Points = defineComponent(
+  "Points",
+  {
+    sizePx: { type: "f32", default: 4 },
+    shape: { type: "enum", default: PointShapeValue.square, labels: PointShapeValue }
+  },
+  {
+    meta: {
+      quickStart: "Attach Points to render point-list MeshAsset vertices in screen pixels.",
+      diagnostics: "Inspect sizePx and decode shape with pointShapeFromU32.",
+      recovery: "Use points-lines-invalid-style for non-finite or non-positive sizePx values.",
+      boundaries: "Points owns raster size and shape only; MeshFilter and MeshRenderer own geometry and material."
+    }
+  }
+);
 var schema = {
   shader: "string",
   data: "buffer"
@@ -303,139 +365,181 @@ var Visibility = defineComponent(
     }
   }
 );
-
-// src/pipeline/standard-profile.ts
-var STANDARD_PIPELINE_ID = "forgeax::standard";
-var STANDARD_LIGHT_COUNTS = [1, 32, 256];
-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;
-var DEFAULT_STANDARD_PROFILE = Object.freeze({
-  pipelineId: STANDARD_PIPELINE_ID,
-  lightCount: 32,
-  lighting: "direct",
-  shadows: "filtered",
-  pbr: true,
-  ibl: true,
-  ssao: false,
-  bloom: true,
-  tone: "aces-filmic",
-  antialias: "fxaa",
-  sky: true,
-  fallback: "native",
-  postStages: ["transparent-blend", "bloom", "tone", "fxaa", "output"]
-});
-function resolveStandardLane(profile, capabilities) {
-  if (!capabilities.compute || !capabilities.storageBuffer) return "cpu-webgl2";
-  return profile.lighting;
+function invalidStyle(input, component, field, value, expected) {
+  return err(new PointsLinesInvalidStyleError({ entity: input.entity, component, field, value, expected }));
+}
+function topologyMismatch(input, submesh, expected, actual) {
+  return err(new PointsLinesTopologyMismatchError({ entity: input.entity, submesh, expected, actual }));
+}
+function checkStyle(input) {
+  const hasPoints = input.points !== void 0;
+  const hasLines = input.lines !== void 0;
+  if (hasPoints && hasLines) {
+    return invalidStyle(
+      input,
+      "Points/Lines",
+      "components",
+      "Points + Lines",
+      "exactly one style component"
+    );
+  }
+  if (!hasPoints && !hasLines) {
+    return invalidStyle(input, "Points/Lines", "components", void 0, "one style component");
+  }
+  if (hasPoints) {
+    const sizePx = input.points?.sizePx ?? 4;
+    const shapeValue = input.points?.shape ?? PointShapeValue.square;
+    const shape = pointShapeFromU32(shapeValue);
+    if (!Number.isFinite(sizePx) || sizePx <= 0) {
+      return invalidStyle(input, "Points", "sizePx", sizePx, "finite sizePx > 0");
+    }
+    if (shape === void 0) {
+      return invalidStyle(input, "Points", "shape", shapeValue, "shape is 'square' or 'circle'");
+    }
+    return ok({ component: "Points", shape, sizePx });
+  }
+  const widthPx = input.lines?.widthPx ?? 1;
+  if (!Number.isFinite(widthPx) || widthPx <= 0) {
+    return invalidStyle(input, "Lines", "widthPx", widthPx, "finite widthPx > 0");
+  }
+  return ok({ component: "Lines", widthPx });
+}
+function checkTopology(input, component) {
+  const expected = component === "Points" ? "point-list" : "line-list";
+  let pointCount = 0;
+  let segmentCount = 0;
+  const acceptedSubmeshes = [];
+  let sawNonEmpty = false;
+  for (const [submeshIndex, submesh] of input.mesh.submeshes.entries()) {
+    const indexed = input.mesh.indices !== void 0 && submesh.indexCount > 0;
+    const elementCount = indexed ? submesh.indexCount : submesh.vertexCount;
+    if (elementCount === 0) continue;
+    sawNonEmpty = true;
+    if (component === "Lines" && submesh.topology === "line-strip") {
+      return err(
+        new PointsLinesStyleUnsupportedError({
+          lane: "admission",
+          field: "topology",
+          member: "line-strip",
+          supported: ["line-list"]
+        })
+      );
+    }
+    if (submesh.topology !== expected) {
+      return topologyMismatch(input, submeshIndex, expected, submesh.topology);
+    }
+    if (component === "Lines" && elementCount % 2 !== 0) {
+      return topologyMismatch(input, submeshIndex, "line-list pairs", "line-list odd tail");
+    }
+    acceptedSubmeshes.push(submeshIndex);
+    if (component === "Points") pointCount += elementCount;
+    else segmentCount += elementCount / 2;
+  }
+  if (!sawNonEmpty) return topologyMismatch(input, 0, expected, "empty-range");
+  return ok({ pointCount, segmentCount, submeshes: acceptedSubmeshes });
+}
+function checkMaterial(input) {
+  const passes = input.material.passes ?? [];
+  const unlitModules = /* @__PURE__ */ new Set(["forgeax_material::unlit", "forgeax::default-unlit"]);
+  if (passes.length !== 1 || passes[0] === void 0) {
+    const pass2 = passes.find(
+      (candidate) => candidate.name === "deferred" || candidate.name === "shadow-caster"
+    ) ?? passes[0];
+    return err(
+      new PointsLinesMaterialUnsupportedError({
+        entity: input.entity,
+        material: input.materialId ?? "<anonymous>",
+        pass: pass2?.name ?? "<empty>",
+        module: pass2?.program.module ?? "<empty>",
+        reason: "points-lines admission requires one unlit forward pass"
+      })
+    );
+  }
+  const pass = passes[0];
+  const lightMode = pass.renderState?.tags?.LightMode;
+  if (!unlitModules.has(pass.program.module) || pass.name !== "forward" || lightMode === "ShadowCaster") {
+    return err(
+      new PointsLinesMaterialUnsupportedError({
+        entity: input.entity,
+        material: input.materialId ?? "<anonymous>",
+        pass: pass.name,
+        module: pass.program.module,
+        reason: "points-lines admission requires an engine-owned unlit forward pass"
+      })
+    );
+  }
+  return ok(void 0);
+}
+function admitPointsLines(input) {
+  const style = checkStyle(input);
+  if (!style.ok) return style;
+  const topology = checkTopology(input, style.value.component);
+  if (!topology.ok) return topology;
+  const material = checkMaterial(input);
+  if (!material.ok) return material;
+  if (style.value.component === "Points" && input.limits?.maxPoints !== void 0) {
+    if (topology.value.pointCount > input.limits.maxPoints) {
+      return err(
+        new PointsLinesBudgetExceededError({
+          lane: "admission",
+          requested: topology.value.pointCount,
+          limit: input.limits.maxPoints,
+          unit: "points"
+        })
+      );
+    }
+  }
+  if (style.value.component === "Lines" && input.limits?.maxSegments !== void 0) {
+    if (topology.value.segmentCount > input.limits.maxSegments) {
+      return err(
+        new PointsLinesBudgetExceededError({
+          lane: "admission",
+          requested: topology.value.segmentCount,
+          limit: input.limits.maxSegments,
+          unit: "segments"
+        })
+      );
+    }
+  }
+  return ok({ ...style.value, ...topology.value });
 }
-
-// src/render-contract.ts
-var STANDARD_TONEMAP_FEATURE_ID = "forgeax::standard::tonemap";
-var RENDER_GRAPH_EXECUTION_PHASE_CATALOG = [
-  "record/graph-execute/point-shadow",
-  "record/graph-execute/cluster-binner-upload",
-  "record/graph-execute/g-buffer",
-  "record/graph-execute/g-buffer/geometry-loop",
-  "record/graph-execute/g-buffer/material-bind-groups",
-  "record/graph-execute/g-buffer/pipeline-selection",
-  "record/graph-execute/g-buffer/draw-submit",
-  "record/graph-execute/ssao-calc",
-  "record/graph-execute/ssao-blur",
-  "record/graph-execute/lighting",
-  "record/graph-execute/forward",
-  "record/graph-execute/forward/geometry-loop",
-  "record/graph-execute/forward/material-bind-groups",
-  "record/graph-execute/forward/pipeline-selection",
-  "record/graph-execute/forward/draw-submit",
-  "record/graph-execute/tonemap",
-  "record/graph-execute/debug-overlay",
-  "record/graph-execute/shadow",
-  "record/graph-execute/spot-shadow",
-  "record/graph-execute/skybox",
-  "record/graph-execute/main",
-  "record/graph-execute/fxaa",
-  "record/graph-execute/bloom-bright",
-  "record/graph-execute/bloom-blur-h",
-  "record/graph-execute/bloom-blur-v",
-  "record/graph-execute/bloom-composite",
-  "record/graph-execute/other"
-];
-var RENDER_HDRP_BINNER_PHASE_CATALOG = [
-  "record/scene-state/hdrp-cluster/binner/light-bounds-and-occupancy",
-  "record/scene-state/hdrp-cluster/binner/light-bounds-and-occupancy/light-aabb",
-  "record/scene-state/hdrp-cluster/binner/light-bounds-and-occupancy/cluster-occupancy",
-  "record/scene-state/hdrp-cluster/binner/cluster-reserve",
-  "record/scene-state/hdrp-cluster/binner/input-preparation",
-  "record/scene-state/hdrp-cluster/binner/bin-core",
-  "record/scene-state/hdrp-cluster/binner/light-index-write",
-  "record/scene-state/hdrp-cluster/binner/light-index-write/bounds-read",
-  "record/scene-state/hdrp-cluster/binner/light-index-write/cluster-write"
-];
-var RENDER_HDRP_CLUSTER_PHASE_CATALOG = [
-  "record/scene-state/hdrp-cluster/binner",
-  ...RENDER_HDRP_BINNER_PHASE_CATALOG,
-  "record/scene-state/hdrp-cluster/payload-packing",
-  "record/scene-state/hdrp-cluster/buffer-upload"
-];
-var RENDER_SCENE_STATE_PHASE_CATALOG = [
-  "record/scene-state/fold-buckets",
-  "record/scene-state/lighting-prep",
-  "record/scene-state/ambient-resolution",
-  "record/scene-state/directional-shadow-cache",
-  "record/scene-state/hdrp-cluster",
-  ...RENDER_HDRP_CLUSTER_PHASE_CATALOG
-];
-var RENDER_RECORD_PHASE_CATALOG = [
-  "record/scene-state",
-  ...RENDER_SCENE_STATE_PHASE_CATALOG,
-  "record/swapchain",
-  "record/render-graph",
-  "record/target-views",
-  "record/validation",
-  "record/dispatch-plan",
-  "record/uploads",
-  "record/bind-groups",
-  "record/graph-execute",
-  ...RENDER_GRAPH_EXECUTION_PHASE_CATALOG
-];
-var RENDER_PHASE_CATALOG = [
-  "extract",
-  "bind-groups",
-  "features",
-  "sort",
-  "record",
-  ...RENDER_RECORD_PHASE_CATALOG
-];
 function resolveVisibility(world, hierarchy = projectHierarchy(world)) {
-  const query = world.query({ read: [Entity], optional: [Visibility] });
+  const query = world.query({ read: [Visibility] });
+  const visitVisibilityRows = (visit) => {
+    if (!query.ok) return;
+    const spans = query.value.spans();
+    if (spans.ok) {
+      for (const span of spans.value) {
+        const states = span.get(Visibility).state;
+        for (let index = 0; index < span.length; index += 1) {
+          visit(span.entities[index], states[index] ?? 0);
+        }
+      }
+      return;
+    }
+    for (const row of query.value) {
+      visit(row.entity, row.get(Visibility).state);
+    }
+  };
   let intentCount = 0;
   let hasAnyHiddenIntent = false;
-  if (query.ok) {
-    for (const row of query.value) {
-      const visibility = row.get(Visibility);
-      if (visibility === void 0) continue;
-      intentCount += 1;
-      if (visibility.state === VisibilityStateValue.hidden) {
-        hasAnyHiddenIntent = true;
-      }
+  visitVisibilityRows((_entity, rawState) => {
+    intentCount += 1;
+    if (rawState === VisibilityStateValue.hidden) {
+      hasAnyHiddenIntent = true;
     }
-  }
+  });
   let resolveEntity;
   let hasIntent;
   const ensureResolver = () => {
     if (resolveEntity !== void 0) return;
     const intentByEntity = /* @__PURE__ */ new Map();
-    if (query.ok) {
-      for (const row of query.value) {
-        const raw = row.get(Visibility);
-        const intent = raw === void 0 ? void 0 : visibilityStateFromU32(raw.state);
-        if (intent !== void 0) {
-          intentByEntity.set(row.entity, intent);
-        }
+    visitVisibilityRows((entity, rawState) => {
+      const intent = visibilityStateFromU32(rawState);
+      if (intent !== void 0) {
+        intentByEntity.set(entity, intent);
       }
-    }
+    });
     hasIntent = (entity) => intentByEntity.has(entity);
     const resolved = /* @__PURE__ */ new Map();
     const resolving = /* @__PURE__ */ new Set();
@@ -475,6 +579,6 @@ function resolveVisibility(world, hierarchy = projectHierarchy(world)) {
   };
 }
 
-export { ANTIALIAS_FXAA, ANTIALIAS_MSAA, ANTIALIAS_NONE, BLOOM_DISABLED, BLOOM_ENABLED, CAMERA_PROJECTION_ORTHOGRAPHIC, CAMERA_PROJECTION_PERSPECTIVE, CLUSTER_GRID_STRIDE_U32, Camera, DEFAULT_CLUSTER_GRID, DEFAULT_STANDARD_PROFILE, DirectionalLight, Instances, LIGHT_INDEX_LIST_CAPACITY, Layer, MAX_LIGHTS, MeshFilter, MeshRenderer, PointLight, PointLightShadow, PostProcessParams, RENDER_PHASE_CATALOG, SKYBOX_MODE_CUBEMAP, STANDARD_LIGHT_COUNTS, STANDARD_PIPELINE_ID, STANDARD_TONEMAP_FEATURE_ID, 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, antialiasFromF32, bloomEnabledFromF32, cameraProjectionFromF32, orthographic, perspective, resolveStandardLane, resolveVisibility, tonemapFromF32, tonemapToU32, visibilityStateFromU32 };
-//# sourceMappingURL=chunk-SCRSAK5B.mjs.map
-//# sourceMappingURL=chunk-SCRSAK5B.mjs.map
+export { ANTIALIAS_FXAA, ANTIALIAS_MSAA, ANTIALIAS_NONE, ANTIALIAS_TAA, Atmosphere, BLOOM_DISABLED, BLOOM_ENABLED, CAMERA_PROJECTION_ORTHOGRAPHIC, CAMERA_PROJECTION_PERSPECTIVE, Camera, DirectionalLight, Fog, Instances, Layer, Lines, MeshFilter, MeshRenderer, MotionBlur, PointLight, PointLightShadow, PointShapeValue, Points, PostProcessParams, 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, admitPointsLines, antialiasFromF32, bloomEnabledFromF32, cameraProjectionFromF32, orthographic, perspective, pointShapeFromU32, resolveVisibility, tonemapFromF32, tonemapToU32, visibilityStateFromU32 };
+//# sourceMappingURL=chunk-YTQ5C7YQ.mjs.map
+//# sourceMappingURL=chunk-YTQ5C7YQ.mjs.map