@forgeax/engine-render 0.1.28 → 0.1.29

package/src/render-graph-primitives.ts

@@ -551,6 +551,7 @@ function dispatchFullscreenPass(
   graphOutputFormat?: GPUTextureFormat,
   graphDepthView?: TextureView,
   paramsOverride?: Uint8Array,
+  fragmentEntryPoint?: string,
 ): void {
   if (shader === 'fxaa') {
     if (resolveCtx === undefined) {
@@ -559,7 +560,7 @@ function dispatchFullscreenPass(
         detail: { readsKey: reads[0] ?? 'ldrColor', passName: name },
       });
     }
-    recordFxaaPass(requireRenderGraphRecordContext(ctx), resolveCtx, graphPass);
+    recordFxaaPass(requireRenderGraphRecordContext(ctx), resolveCtx, graphPass, paramsOverride);
     return;
   }
   const lookup = ctx.runtime.lookupPostProcess;
@@ -773,7 +774,8 @@ function dispatchFullscreenPass(
   const lookupPipeline = ctx.runtime.getPostProcessPipeline;
   if (lookupPipeline === undefined) return;
   const postColorFormat = writeFormat;
-  const pipeline = lookupPipeline(shader, built.bindGroupLayout, postColorFormat);
+  const pipelineEntry = fragmentEntryPoint === undefined ? entry : { ...entry, fragmentEntryPoint };
+  const pipeline = lookupPipeline(shader, built.bindGroupLayout, [postColorFormat], pipelineEntry);
   if (pipeline === null) return;
   const handle = built.createHandle(name, pipeline, paramsBuffer);
 
@@ -814,6 +816,7 @@ export function encodeFullscreenPass(
     readonly rawSwapchainOutput?: boolean | undefined;
     readonly depthView?: TextureView | undefined;
     readonly paramsOverride?: Uint8Array | undefined;
+    readonly fragmentEntryPoint?: string | undefined;
   },
 ): void {
   dispatchFullscreenPass(
@@ -829,5 +832,6 @@ export function encodeFullscreenPass(
     input.outputFormat,
     input.depthView,
     input.paramsOverride,
+    input.fragmentEntryPoint,
   );
 }

package/src/render-pipeline.ts

@@ -17,6 +17,7 @@
 import type {
   ColorValueDomain,
   GraphAccess,
+  GraphBuffer,
   GraphResourceResolver,
   GraphTexture,
   GraphTextureDescriptor,
@@ -28,6 +29,7 @@ import type {
 } from '@forgeax/engine-render-graph';
 import type {
   BindGroup,
+  Buffer,
   RhiCaps,
   RhiError,
   RhiRenderPassEncoder,
@@ -38,6 +40,7 @@ import type { Tonemap } from './components/camera';
 import type { DirectionalShadowFilterLabel } from './components/directional-shadow-filter';
 import type { RenderError } from './errors/render';
 import type { RenderFeatureTargetKind } from './features/targets';
+import type { ShadowViewIdentity, ShadowViewProjection } from './gpu-driven/shadow-views';
 import {
   GPU_TEXTURE_USAGE_COPY_SRC,
   GPU_TEXTURE_USAGE_RENDER_ATTACHMENT,
@@ -45,8 +48,9 @@ import {
 import type { StandardTopologyInputValue } from './pipeline/standard-lighting/topology';
 import { STANDARD_POST_STAGE_NAMES, type StandardProfile } from './pipeline/standard-profile';
 import type { SurfaceProfile } from './record/render-context';
-import type { RenderPipelineContext } from './render-contract';
+import type { FrameObservationDomain, RenderPipelineContext } from './render-contract';
 import type { OcclusionFrameProjection } from './scene/visibility/occlusion-runtime';
+import type { SsrSpatialAdmission } from './ssr/admission';
 import type { TransmissionDemand } from './transmission/projection';
 
 export type { RenderPipelineContext } from './render-contract';
@@ -216,6 +220,8 @@ export interface RenderPipelineTopology {
    * clear directly to the surface.
    */
   readonly clearOnly?: boolean | undefined;
+  /** Selected atmosphere requires the graph-owned sky producer and background. */
+  readonly atmosphere?: boolean | undefined;
   /** Whether Standard main draws carry the producer-owned fallback MRT. */
   readonly reflectionFallback?: { readonly enabled: boolean } | undefined;
   readonly surface: {
@@ -226,6 +232,19 @@ export interface RenderPipelineTopology {
     readonly profile?: SurfaceProfile | undefined;
   };
   readonly camera: Pick<RenderPipelineContext['camera'], 'tonemap' | 'antialias' | 'bloom'>;
+  /** Frame-stable Standard output policy; no raw RHI handles enter topology. */
+  readonly output?: {
+    readonly autoExposure: boolean;
+    /** Camera-owned Bradford white balance is part of the same output pass. */
+    readonly whiteBalance?: boolean;
+    readonly temperature?: number;
+    readonly tint?: number;
+    readonly colorLut: boolean;
+    readonly colorLutStrength: number;
+    readonly lutSourceKey?: string;
+  };
+  /** Detached spatial SSR admission; graph resources remain renderer-owned. */
+  readonly ssr?: SsrSpatialAdmission | undefined;
   readonly temporal?: {
     readonly taa: boolean;
     readonly motionBlur: boolean;
@@ -425,11 +444,25 @@ export interface RenderPipelineGpuDrivenProjection {
     viewBindGroup: BindGroup,
     pass: RhiRenderPassEncoder,
     resources: GraphResourceResolver,
+    frameResources: GpuDrivenStandardPbrFrameResources,
   ): void;
 }
 
+/** Producer-owned Standard PBR resources resolved during graph execution. */
+export interface GpuDrivenStandardPbrFrameResources {
+  readonly materialBindGroups: (BindGroup | undefined)[];
+  /** Frame-global material slots keyed by the retained scene entity identity. */
+  readonly materialSlotIndicesByEntity: Map<number, readonly number[]>;
+  readonly instancesBindGroup: BindGroup;
+  readonly materialStride: number;
+  /** Exact producer-owned numeric Material table consumed by scene-index PBR. */
+  readonly sceneMaterialBuffer: Buffer;
+}
+
 export interface RenderPipelineBuildContext<FrameCtx extends RenderPipelineFrame> {
   readonly graph: RenderGraphBuilder<FrameCtx>;
+  /** Explicit receipt-bound color domains requested for this frame. */
+  readonly observationCaptureDomains?: readonly FrameObservationDomain[] | undefined;
   /**
    * The single prepared Standard lighting projection for this frame.  The
    * Forward and Deferred adapters consume this value; they never inspect raw
@@ -442,6 +475,23 @@ export interface RenderPipelineBuildContext<FrameCtx extends RenderPipelineFrame
    * inferring rgba16float support from the selected surface format.
    */
   readonly capabilities?: Pick<RhiCaps, 'rgba16floatRenderable'>;
+  /** Prepared typed graph resources owned by RenderSystem/RenderFrameState. */
+  readonly standardOutput?: {
+    readonly autoExposure?: {
+      readonly histogram: GraphBuffer;
+      readonly state: GraphBuffer;
+      readonly candidate: GraphBuffer;
+      /** Authored camera/time parameters consumed by the GPU adapt stage. */
+      readonly parameters: GraphBuffer;
+    };
+    readonly colorLut?: {
+      readonly view: GraphTextureView;
+      readonly sampler: import('@forgeax/engine-rhi').Sampler;
+      readonly strength: number;
+      readonly bindGroupLayout: import('@forgeax/engine-rhi').BindGroupLayout;
+      readonly bindGroup: BindGroup;
+    };
+  };
   /**
    * Renderer-owned TAA history targets. The graph sees only imported typed
    * targets; opaque RHI handles remain inside RenderFrameState.
@@ -451,6 +501,16 @@ export interface RenderPipelineBuildContext<FrameCtx extends RenderPipelineFrame
     readonly previousColor: RenderPipelineTarget;
     readonly currentTemporal: RenderPipelineTarget;
     readonly previousTemporal: RenderPipelineTarget;
+    readonly currentStability: RenderPipelineTarget;
+    readonly previousStability: RenderPipelineTarget;
+  };
+  /** Renderer-owned SSR temporal history targets for the admitted spatial chain. */
+  readonly ssrHistory?: {
+    readonly previous: RenderPipelineTarget;
+    readonly output: RenderPipelineTarget;
+    readonly previousSurface: RenderPipelineTarget;
+    readonly outputSurface: RenderPipelineTarget;
+    readonly params: GraphBuffer;
   };
   /** Renderer-owned, prewarmed encoder for one graph mip level. */
   readonly encodeTransmissionMip?: (input: {
@@ -467,11 +527,20 @@ export interface RenderPipelineBuildContext<FrameCtx extends RenderPipelineFrame
     readonly format: TextureFormat;
     readonly sampleCount: 1 | 4;
   }): Result<RenderPipelineGpuDrivenProjection | undefined, RenderPipelineBuildError>;
+  projectGpuDrivenShadow?(
+    identity: ShadowViewIdentity,
+  ): Result<ShadowViewProjection | undefined, RenderGraphError>;
   contributeFeatures(
     targets: readonly RenderPipelineFeatureTarget[],
     semanticTargets?: readonly RenderPipelineTarget[],
     namedTargets?: Readonly<Record<string, RenderPipelineTarget>>,
+    standardSurfaceAccesses?: readonly GraphAccess[],
   ): Result<void, RenderPipelineBuildError>;
+  /** Prepare feature-owned shadow draws and their early compute producers once. */
+  contributeShadowFeatures?(): Result<
+    import('./features/render-graph-raster').RenderFeatureShadowDraws<FrameCtx> | undefined,
+    RenderPipelineBuildError
+  >;
   /** Add renderer-owned cube capture work to the active pipeline graph. */
   contributeCubeCaptures?(): Result<void, RenderPipelineBuildError>;
   /** Whether a producer-owned feature is installed for this graph build. */