@forgeax/engine-render 0.1.2

package/dist/render-graph-primitives.d.ts

@@ -0,0 +1,424 @@
+import type { RenderGraph, ResolveContext } from '@forgeax/engine-render-graph';
+import { type RhiRenderPassEncoder, type TextureView } from '@forgeax/engine-rhi';
+import type { PassSelector } from '@forgeax/engine-types';
+import type { _InternalRenderPipelineContext, RenderPipelineContext } from './render-pipeline-context';
+import { type ResolvedSsaoParameters } from './ssao-config';
+/**
+ * Selects which passes of a material asset are rendered by addScenePass / addShadowPass.
+ *
+ * An empty selector `{}` matches every pass. The selector is pipeline-specific:
+ * the built-in URP uses `{ LightMode: ['Forward'] }` / `{ LightMode: ['ShadowCaster'] }`;
+ * a custom pipeline can define its own tag keys and values.
+ *
+ * Matching rule: every key in the selector must exist in the pass's `tags` and the
+ * pass's tag value must be in the selector's value list.
+ */
+export interface AddScenePassOptions {
+    /** Graph colour target to write (declared via g.addColorTarget). */
+    readonly color: string;
+    /** Graph depth target to write (declared via g.addColorTarget). */
+    readonly depth: string;
+    /**
+     * Optional single-sample resolve target for a multisample colour target.
+     * When `_routeFromOpts` is true and the active camera has MSAA enabled,
+     * `recordMainPass` resolves `color` into this graph-owned target before a
+     * downstream fullscreen pass samples it. Pass `null` to explicitly disable
+     * the default resolve in a custom-pipeline falsifier; omit it for
+     * single-sample scenes or to preserve the URP-owned resolve.
+     */
+    readonly resolve?: string | null | undefined;
+    /** Resource keys this pass samples (typically 'shadowDepth' + an upstream colour). */
+    readonly reads?: readonly string[] | undefined;
+    /**
+     * Pass selector — a pipeline-specific filter for which material passes are
+     * rendered. An empty selector `{}` matches every pass. The built-in URP uses
+     * `{ LightMode: ['Forward'] }`; a custom pipeline defines its own tag keys.
+     */
+    readonly selector: PassSelector;
+    /**
+     * @internal — feat-20260609 framebuffers demo M5 / T-12-a opt-in flag.
+     *
+     * When `true`, the pass execute closure resolves `opts.color` / `opts.depth`
+     * through the graph's resolveCtx and overrides the recordMainPass ctx so
+     * the geometry pass renders into those graph-owned views. When `false` (or
+     * unset, the default), recordMainPass picks the per-frame
+     * `geometryColorView` / `geometryDepthView` set by recordFrame's URP
+     * state-machine — this preserves byte-equivalence for urp-pipeline,
+     * which encodes its own MSAA / LDR-no-MSAA / HDR routing in recordFrame
+     * (where opts.color is a logical ordering token, not the physical write
+     * target).
+     *
+     * AI-user-defined custom pipelines declaring their own offscreen RT (the
+     * AC-11 "render scene to graph-owned colour + depth" contract) MUST set
+     * this flag to opt out of the URP state-machine and route opts.color
+     * directly. A future feat that migrates urp-pipeline off the recordFrame
+     * state-machine flips the default and removes this flag.
+     */
+    readonly _routeFromOpts?: boolean | undefined;
+}
+/**
+ * AC-11: render the ECS scene into a graph-owned colour + depth target.
+ *
+ * Adds a graph pass that, when executed, walks the per-frame validated
+ * renderable list and dispatches geometry into `opts.color` (with `opts.depth`
+ * as the depth attachment). The implementation detail (4-BGL chain, per-entity
+ * material UBO packing, pipeline cache lookup, MSAA variant selection) is
+ * package-private (`recordMainPass`); plan-strategy D-5 keeps it inside runtime
+ * so the render-graph package stays RHI-pure.
+ *
+ * The `reads` array threads dependency edges into the graph (so shadow ->
+ * skybox -> main is expressed in declaration order). The two writes are `opts.color`
+ * and `opts.depth`.
+ */
+export declare function addScenePass(graph: RenderGraph<RenderPipelineContext>, name: string, opts: AddScenePassOptions): void;
+export interface AddShadowPassOptions {
+    /** Graph depth target to write (declared via g.addColorTarget with depth format). */
+    readonly depth: string;
+    /**
+     * Pass selector — a pipeline-specific filter for which material passes are
+     * rendered as shadow casters. The built-in URP uses
+     * `{ LightMode: ['ShadowCaster'] }`.
+     */
+    readonly selector: PassSelector;
+    /**
+     * Optional viewport for the shadow render pass. When set, the pass calls
+     * `setViewport(x, y, w, h, 0, 1)` before dispatch so the depth rasterization
+     * is clipped to the given sub-rectangle of the depth target. Undefined
+     * preserves the pre-CSM behavior (full-RT viewport). Used by the cascaded
+     * shadow map atlas: each cascade pass writes to one tile.
+     *
+     * @example viewport: { x: 0, y: 0, w: 2048, h: 2048 }
+     */
+    readonly viewport?: {
+        readonly x: number;
+        readonly y: number;
+        readonly w: number;
+        readonly h: number;
+    } | undefined;
+    /**
+     * Cascade index this pass renders into (0..3). The runtime writes the
+     * value to `shadowCasterCascadeBuffer` immediately before submit; the
+     * shadow_caster vertex shader reads it to pick the matching
+     * `view.lightViewProj_X`. Defaults to 0 when unset (preserves the
+     * single-cascade pre-CSM behaviour for any caller still calling
+     * addShadowPass without the field; the URP per-cascade loop sets it
+     * explicitly).
+     *
+     * @example cascadeIndex: 0  // first cascade (lightViewProj_A)
+     */
+    readonly cascadeIndex?: number;
+}
+/**
+ * Render shadow casters into a depth-only graph target. Implementation detail:
+ * `recordShadowPass` (package-private) iterates DirectionalLight + caster
+ * renderables under their light-view + light-proj and writes the depth-32-float
+ * target consumed by `addScenePass.reads`.
+ */
+export declare function addShadowPass(graph: RenderGraph<RenderPipelineContext>, name: string, opts: AddShadowPassOptions): void;
+/**
+ * feat-20260612-point-light-shadows-urp-hdrp M3 / T-M3-4 (plan-strategy §D-1
+ * + AC-04 + AC-09). Render the 6 x N point-light shadow caster passes into
+ * the cube_array atlas owned by `frameState.pointShadowAtlas`. Implementation
+ * detail: `recordPointShadowPass` (package-private) iterates
+ * `frameState.pointShadowSnapshots` and emits one independent render pass
+ * per (layer, face), opening / submitting each on its own command encoder
+ * (RD-4 manual barrier between depth-write and the URP forward pass's
+ * cube_array sample).
+ *
+ * Resource model: the cube_array atlas is a runtime-owned resource (NOT a
+ * graph color target) because its size is `4 * 6 * faceSize^2` and per-face
+ * 2D views must be created with explicit `baseArrayLayer` indexing — the
+ * existing `addColorTarget` vocabulary is single-attachment-only. The pass
+ * therefore declares no `writes` (the dependency between this pass and the
+ * URP forward pass is enforced by the `addScenePass.reads` order — both
+ * sample shadowAtlas, and graph declaration order keeps shadow before
+ * forward). A future render-graph extension may model the cube_array as a
+ * first-class resource; for now the manual command-encoder boundary is the
+ * synchronization point.
+ *
+ * AC-09 zero-shadow zero-pass: the URP `buildGraph` gates the call to
+ * `addPointShadowPass` on `frameState.pointShadowSnapshots.length > 0` so
+ * the graph itself never declares the pass when no PointLightShadow exists.
+ * `recordPointShadowPass` re-checks at execute time as defence in depth.
+ */
+export declare function addPointShadowPass(graph: RenderGraph<RenderPipelineContext>, name: string): void;
+export interface AddSpotShadowPassOptions {
+    /** Graph depth target (depth32float 2x2 tile atlas) the spot casters write. */
+    readonly depth: string;
+}
+/**
+ * feat-20260625-spot-light-shadow-mapping M2 / w9 + w11 (D-1 + D-2). Render the
+ * spot-light shadow caster passes into the graph-owned `spotShadowDepth` atlas
+ * (a single 2D depth32float texture of 2x2 tiles — NOT a 2d-array). One graph
+ * pass NODE; the execute closure (`recordSpotShadowPass`) loops the per-frame
+ * `frameState.spotShadowSnapshots`, rendering each castShadow spot's perspective
+ * depth into its tile (viewport keyed on `shadowAtlasTile`) with first-tile
+ * clear / rest load (independent of the directional cascadeIndex; D-2). Unlike
+ * `addPointShadowPass` the spot atlas IS a graph color target, so the pass
+ * declares `writes: [opts.depth]` — `addScenePass.reads` lists the same key to
+ * order spot-shadow -> main. The single-node-with-internal-loop shape keeps the
+ * memoized graph from rebuilding on spot-count drift (AC-03 zero-spot scenes
+ * record zero passes via the early-return inside recordSpotShadowPass).
+ */
+export declare function addSpotShadowPass(graph: RenderGraph<RenderPipelineContext>, name: string, opts: AddSpotShadowPassOptions): void;
+export interface AddSkyboxPassOptions {
+    /** Graph colour target the skybox writes (typically the same target the scene pass writes). */
+    readonly color: string;
+}
+/**
+ * Render a skybox cube into the declared colour target. Implementation detail:
+ * `recordSkyboxPass` (package-private) emits a single cube draw with a
+ * skybox-view matrix derived from the camera. Writes `opts.color` so the
+ * scene pass can declare it under `reads` to enforce skybox -> main order.
+ */
+export declare function addSkyboxPass(graph: RenderGraph<RenderPipelineContext>, name: string, opts: AddSkyboxPassOptions): void;
+export interface AddBloomPassesOptions {
+    /** HDR colour target the bright-extract reads + the composite reads back. */
+    readonly hdrColor: string;
+    /** Logical key the composite WRITES (typically an alias of hdrColor). */
+    readonly hdrComposited: string;
+    /** Half-res bright target. */
+    readonly bright: string;
+    /** Half-res H blur target. */
+    readonly blurH: string;
+    /** Half-res V blur target. */
+    readonly blurV: string;
+}
+/**
+ * Wire the 4-pass bloom chain (bright -> blur-h -> blur-v -> composite). All
+ * intermediate targets are half-resolution; the composite reads hdrColor +
+ * blurV and writes the alias `hdrComposited` (declared via
+ * `g.addColorTargetAlias` to fold onto the actual hdrColor texture, KB-1).
+ */
+export declare function addBloomPasses(graph: RenderGraph<RenderPipelineContext>, opts: AddBloomPassesOptions): void;
+/**
+ * feat-20260612-hdrp-ssao M3 / w15: SSAO pass parameters.
+ *
+ * Defaults: radius=0.5, bias=0.025, intensity=1.0.
+ * Non-positive radius or negative bias triggers fail-fast PostProcessError
+ * inside the per-frame record closure (w16 boundary impl).
+ */
+export interface AddSsaoPassesParams {
+    /** SSAO sample radius in view-space units (default 0.5). */
+    readonly radius?: number | undefined;
+    /** SSAO depth bias to avoid self-occlusion (default 0.025). */
+    readonly bias?: number | undefined;
+    /** SSAO intensity blend factor (default 1.0). */
+    readonly intensity?: number | undefined;
+}
+export type { ResolvedSsaoParameters, SsaoParameterConfig } from './ssao-config';
+/**
+ * Options for `addSsaoPasses` (plan-strategy D-5, D-2).
+ *
+ * The caller (hdrp-pipeline.buildGraph) declares the color targets
+ * (ssaoRaw / ssaoBlurred as half-swapchain r8unorm) and passes their
+ * graph resource keys here. `gbuf0` and `hdrDepth` are g-buffer
+ * resources declared by the pipeline.
+ */
+export interface AddSsaoPassesOptions {
+    /** G-buffer RT0 (normal.rgb + roughness.a), rgba16float, swapchain. */
+    readonly gbuf0: string;
+    /** Hardware depth target, depth24plus-stencil8, swapchain. */
+    readonly hdrDepth: string;
+    /** SSAO calc output: half-res r8unorm transient target. */
+    readonly ssaoRaw: string;
+    /** SSAO blur output: half-res r8unorm transient target. */
+    readonly ssaoBlurred: string;
+    /** SSAO parameters (radius, bias, intensity). */
+    readonly params?: AddSsaoPassesParams | undefined;
+    /** Pipeline context for lazy SSAO buffer resolution. */
+    readonly ctx: RenderPipelineContext;
+}
+/**
+ * Wire the 2-pass SSAO chain (calc -> blur) into the render graph.
+ *
+ * plan-strategy D-2: exactly 2 pass (ssao-calc + ssao-blur).
+ * plan-strategy D-4: g-buffer missing -> graph-level skip.
+ * plan-strategy D-5: signature matches addBloomPasses pattern.
+ *
+ * ssao-calc: reads gbuf0 + hdrDepth + ssao-noise + ssao-kernel + ssao-uniform,
+ *   writes ssaoRaw (half-res r8unorm).
+ * ssao-blur: reads ssaoRaw, writes ssaoBlurred (half-res r8unorm).
+ *
+ * Fail-fast: when SSAO buffers are unavailable (g-buffer not declared or
+ * kernel/noise generation fails), the
+ * function returns without wiring any pass nodes (graph-level skip).
+ * Param validation happens in the record closure (w16 boundary impl).
+ */
+export declare function addSsaoPasses(graph: RenderGraph<RenderPipelineContext>, opts: AddSsaoPassesOptions): void;
+/**
+ * Lazy-allocate the three constant SSAO record companions the first time the
+ * calc / blur closure runs: a filtering sampler (binding 3 + 8), a
+ * non-filtering depth sampler (binding 6, paired with hdr_depth — WebGPU
+ * validation rejects depth + filtering), and a 1x1 r8unorm fallback view bound
+ * at ssaoRaw (binding 7) in the calc pass (the calc shader never samples
+ * ssaoRaw, but the BGL still requires a valid view).
+ *
+ * Returns null if any underlying allocation fires a structured error onto
+ * runtime.errorRegistry; the caller then skips the pass.
+ */
+/**
+ * Resolve a depth-only view of a graph color target by key.
+ *
+ * On dawn the BindGroup validation rejects a default-view (aspect=all on a
+ * depth+stencil texture) with "Multiple aspects (Depth|Stencil) selected".
+ * A separate createTextureView({aspect:'depth-only'}) is required.
+ *
+ * @param internals - internal render pipeline context
+ * @param key - graph color-target key to resolve depth from
+ * @param label - debug label for the depth-only TextureView
+ * @returns a depth-only TextureView, or null if the graph / texture is absent
+ *   or creation fires a structured error
+ */
+export declare function resolveDepthOnlyView(internals: _InternalRenderPipelineContext, key: string, label: string, preferredKey?: string | null): TextureView | null;
+/**
+ * recordSsaoCalcPass — fullscreen SSAO occlusion calculation (M8 / w38).
+ *
+ * Resolves the graph-owned half-resolution ssaoRaw color target, writes the
+ * 256 B SSAO uniform (view/proj/invProj/intensity) once per frame, then runs
+ * a 3-vertex fullscreen-triangle draw with fs_ssao_calc.
+ *
+ * Bind group entries (must match the 9-entry SSAO BGL declared in
+ * createRenderer.ts; see hdrp-ssao.wgsl §BGL layout):
+ *   0 ssao_uniform UBO            5 hdr_depth view
+ *   1 ssao_kernel UBO             6 ssao_depth_sampler (non-filtering)
+ *   2 ssao_noise_texture          7 fallback ssaoRaw view (calc never samples)
+ *   3 ssao_noise_sampler          8 ssaoSampler (unused by calc, BGL slot)
+ *   4 gbuffer_normal view
+ *
+ * Skips with no GPU work when the optional SSAO pipelines are unavailable
+ * (manifest without hdrp-ssao.wgsl), when the dedicated BGL is null, when
+ * the SSAO buffers fail to allocate, or when the graph cannot resolve the
+ * required views.
+ */
+export interface SsaoCalcPassViews {
+    readonly output: TextureView;
+    readonly normal: TextureView;
+    readonly depth: TextureView;
+    readonly depthCacheKey: TextureView;
+}
+export declare function recordSsaoCalcPass(_c: _InternalRenderPipelineContext, resolveCtx?: ResolveContext, ssaoRawKey?: string, gbuf0Key?: string, hdrDepthKey?: string, graphPass?: RhiRenderPassEncoder, graphViews?: SsaoCalcPassViews, parameters?: ResolvedSsaoParameters): void;
+/**
+ * recordSsaoBlurPass — fullscreen SSAO 4x4 box blur (M8 / w38).
+ *
+ * Reads the half-resolution ssaoRaw (R8), applies a 16-tap box blur, writes
+ * the blurred result to ssaoBlurred. The BGL is the same 9-entry SSAO BGL
+ * as the calc pass; the only difference is binding 7 carries the real
+ * ssaoRaw view (vs the 1x1 fallback the calc pass binds).
+ */
+export interface SsaoBlurPassViews extends SsaoCalcPassViews {
+    readonly raw: TextureView;
+}
+export declare function recordSsaoBlurPass(_c: _InternalRenderPipelineContext, resolveCtx?: ResolveContext, ssaoBlurredKey?: string, ssaoRawKey?: string, gbuf0Key?: string, hdrDepthKey?: string, graphPass?: RhiRenderPassEncoder, graphViews?: SsaoBlurPassViews): void;
+export interface AddTonemapPassOptions {
+    /** Logical HDR resource tonemap reads when bloom is on (the bloom composite output). */
+    readonly hdrComposited: string;
+    /**
+     * Logical HDR resource tonemap reads when bloom is OFF (the bloom composite
+     * pass is gated off and never writes hdrComposited). Defaults to
+     * `hdrComposited` for pipelines where the two are the same texture (e.g.
+     * HDRP passes `hdrColor` for both). URP passes `hdrColor` here so that with
+     * bloom off, tonemap reads the main-rendered scene directly instead of an
+     * unwritten hdrComposited target (bug-20260625).
+     */
+    readonly hdrColorWhenBloomOff?: string;
+    /** Logical LDR output; defaults to the swap-chain. */
+    readonly color?: string;
+    /** Run the final linear-LDR -> display-encoded output without tone mapping. */
+    readonly outputOnly?: boolean;
+}
+/**
+ * Reserved post-process id for the engine built-in tonemap (feat-20260621 M-A3
+ * / D-5). Registered at boot via `postProcess.register(TONEMAP_POST_PROCESS_ID,
+ * { source, params })`; the extract stage bridges `Camera.exposure / whitePoint
+ * / tonemap` onto the params channel under this key (render-system-extract.ts).
+ */
+export declare const TONEMAP_POST_PROCESS_ID = "forgeax::tonemap";
+/**
+ * HDR -> LDR tonemap fullscreen pass. feat-20260621 M-A3 (D-5): the built-in
+ * tonemap now flows through the SAME unified fullscreen post-process channel as
+ * any custom post-process — registered at boot via `postProcess.register(
+ * 'forgeax::tonemap', { source, params })`, its exposure/whitePoint/mode bridged
+ * onto the per-frame params channel by the extract stage, and dispatched here
+ * through `dispatchFullscreenPass`. This wrapper preserves two behaviours the
+ * generic `addFullscreenPass` lacks:
+ *   - the per-frame `tonemapActive` gate (`camera.tonemap === 'none'` ->
+ *     zero-overhead skip), and
+ *   - graceful degradation (charter §9) on the empty-manifest path: when
+ *     `forgeax::tonemap` was never registered (Camera-only world, no manifest)
+ *     fire a structured `shader-compile-failed` instead of letting the
+ *     dispatcher throw `post-process-not-found`.
+ * The output is a graph resource when FXAA is active, otherwise the reserved
+ * `'swapchain'` key resolves to the current surface view.
+ */
+export declare function addTonemapPass(graph: RenderGraph<RenderPipelineContext>, name: string, opts: AddTonemapPassOptions): void;
+export interface AddFullscreenPassOptions {
+    /**
+     * Registered post-process shader id (via renderer.postProcess.register). The
+     * built-in `'fxaa'` id is a hardwired dispatcher branch; any other id is an
+     * AI-user effect whose WGSL declares `vs_main` + `fs_main` and samples the
+     * input at `@group(1) @binding(0)` texture + `@binding(1)` sampler. With
+     * `compositeOverSwapchain` this is how an effect layers over URP's final image
+     * (see RenderPipelineAsset.config.postEffects).
+     */
+    readonly shader: string;
+    /** Graph resource key the pass writes (intermediate scratch RT for FXAA / the composite scratch). */
+    readonly color: string;
+    /** Graph resource keys the pass samples. Empty = use the current surface view. */
+    readonly reads?: readonly string[] | undefined;
+    /**
+     * feat-20260621 M4': composite-over-swap-chain mode. When true, the pass
+     * copies the CURRENT swap-chain into the `color` scratch target (so the effect
+     * samples the already-composited final image), samples that scratch, then
+     * writes the result back into the swap-chain through its non-srgb storage view
+     * (R-COLORSPACE: the swap-chain is already sRGB-encoded, so writing through the
+     * srgb view would double-encode). This is the generalisation of the built-in
+     * `'fxaa'` copy idiom to AI-user effects — the mechanism that lets a built-in
+     * pipeline layer a registered effect on top of its final image WITHOUT
+     * replacing the pipeline (and dropping its shadow / tonemap passes). `color`
+     * MUST be a `graph.addColorTarget` declared with the swap-chain storage format
+     * + COPY_DST | TEXTURE_BINDING usage (it is both copy dst and sampled input);
+     * `reads` stays empty.
+     *
+     * WebGPU backend only: the mid-frame swap-chain copy + non-srgb storage-view
+     * write are not supported on the WebGL2 fallback swap-chain (no COPY_SRC, no
+     * non-srgb reinterpret view) — the same constraint `recordFxaaPass` carries.
+     */
+    readonly compositeOverSwapchain?: boolean | undefined;
+}
+/**
+ * AC-06 / AC-07: declare a generic fullscreen post-process pass. The shader is
+ * looked up from `renderer.postProcess.register(shader, …)`; the primitive
+ * builds the input-texture BGL + sampler + pipeline + ping-pong wiring. For
+ * the FXAA case the implementation detail is `recordFxaaPass`
+ * (package-private), which owns the graph-input-to-surface-output attachment
+ * route.
+ *
+ * If `opts.reads` is empty the pass uses the current surface view (default).
+ * Post-processes that read a graph-owned texture
+ * (e.g. tonemap rebuilt as a fullscreen pass, OOS-3) will declare reads
+ * explicitly.
+ *
+ * F-3 topology refactor (2026-06-08): the FXAA path now flows through this
+ * dispatcher (`addFullscreenPass(g, 'fxaa', ...)` -> `dispatchFullscreenPass` ->
+ * `recordFxaaPass`). The two-branch dispatcher is the load-bearing AC-09
+ * "FXAA refactored as the first post-process instance" claim: at the
+ * topology layer FXAA is a special-cased shader id; at the record layer
+ * recordFxaaPass owns the backend-aware output attachment. The
+ * dispatcher is extracted as a named function (`dispatchFullscreenPass`)
+ * so an AI user reading the per-pass execute closure sees a single call
+ * site — the if/else fan-out is in one place, not duplicated across
+ * future fullscreen passes.
+ */
+export declare function addFullscreenPass(graph: RenderGraph<RenderPipelineContext>, name: string, opts: AddFullscreenPassOptions): void;
+export declare function encodeFullscreenPass(ctx: RenderPipelineContext, pass: RhiRenderPassEncoder, input: {
+    readonly name: string;
+    readonly shader: string;
+    readonly color: string;
+    readonly reads: readonly string[];
+    readonly resolve: ResolveContext;
+    readonly outputFormat: GPUTextureFormat;
+    readonly rawSwapchainOutput?: boolean | undefined;
+    readonly depthView?: TextureView | undefined;
+}): void;
+//# sourceMappingURL=render-graph-primitives.d.ts.map

package/dist/render-graph-primitives.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-graph-primitives.d.ts","sourceRoot":"","sources":["../src/render-graph-primitives.ts"],"names":[],"mappings":"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"}