@forgeax/engine-render 0.1.33 → 0.1.34

package/src/volume/passes.ts

@@ -25,6 +25,7 @@ import type {
   RenderPipelineTarget,
   RenderPipelineTopology,
 } from '../render-pipeline';
+import { MAX_VOLUMETRIC_FOG_OWNERS } from './component';
 import type { VolumetricFogResources } from './resources';
 import {
   createVolumetricFogResources,
@@ -80,6 +81,7 @@ export interface VolumetricFogPassInputs {
   readonly linearHdr: RenderPipelineTarget;
   readonly sceneDepth: GraphTextureView;
   readonly density: GraphTextureView;
+  readonly additionalDensities?: readonly GraphTextureView[];
   readonly params: GraphBuffer;
   readonly view: GraphBuffer;
   readonly directionalShadow?: GraphTextureView;
@@ -90,6 +92,8 @@ export interface VolumetricFogPassInputs {
   readonly clusterUniform: GraphBuffer;
   readonly selectedLightKind: 'directional' | 'point' | 'spot';
   readonly projector?: GraphTextureView;
+  /** Stable world-space cloud shadow map sampled at each volume point. */
+  readonly cloudShadow?: GraphTextureView;
 }
 function pipelineError(stage: string): RhiError {
   return new RhiError({
@@ -165,6 +169,7 @@ function importVolumeInputs(
   spotShadow: GraphTextureView,
   selectedLightKind: 'directional' | 'point' | 'spot' | undefined,
   clusterBuffers: StandardClusterGraphBuffers | null,
+  cloudShadow: GraphTextureView | undefined,
 ): Result<ImportedVolumeInputs | undefined, RenderGraphError> {
   const volume = topology.volumetricFog;
   if (volume?.enabled !== true || volume.format === undefined || volume.extent === undefined)
@@ -213,6 +218,39 @@ function importVolumeInputs(
     },
   );
   if (!density.ok) return density;
+  const additionalDensities: GraphTextureView[] = [];
+  for (const [index, member] of (volume.additional ?? []).entries()) {
+    const texture = graph.importTexture(
+      `volume-density-${index + 1}`,
+      {
+        format: member.format,
+        size: {
+          width: member.extent.width,
+          height: member.extent.height,
+          depthOrArrayLayers: member.extent.depth,
+        },
+        dimension: '3d',
+        usage: GPU_TEXTURE_USAGE_TEXTURE_BINDING,
+      },
+      (frame) => {
+        const value = frame.volumetricFog?.additional?.[index];
+        if (value === undefined) throw pipelineError('local density residency');
+        return value.densityTexture;
+      },
+    );
+    if (!texture.ok) return texture;
+    const view = graph.importView(
+      texture.value,
+      { label: `volume-density-${index + 1}.view`, dimension: '3d' },
+      (frame) => {
+        const value = frame.volumetricFog?.additional?.[index];
+        if (value === undefined) throw pipelineError('local density view residency');
+        return value.densityView;
+      },
+    );
+    if (!view.ok) return view;
+    additionalDensities.push(view.value);
+  }
   const params = graph.importBuffer(
     'volume-params',
     {
@@ -265,6 +303,7 @@ function importVolumeInputs(
     linearHdr,
     sceneDepth,
     density: density.value,
+    additionalDensities,
     params: params.value,
     view: view.value,
     ...(directionalShadow === undefined ? {} : { directionalShadow }),
@@ -273,6 +312,7 @@ function importVolumeInputs(
     clusterUniform: clusterBuffers.clusterUniform,
     selectedLightKind: selectedLightKind ?? 'directional',
     ...(projector === undefined ? {} : { projector }),
+    ...(cloudShadow === undefined ? {} : { cloudShadow }),
   });
 }
 export function addAuthoredVolumetricFogPasses(
@@ -283,6 +323,7 @@ export function addAuthoredVolumetricFogPasses(
   directionalShadow: GraphTextureView | undefined,
   spotShadow: GraphTextureView,
   clusterBuffers: StandardClusterGraphBuffers | null,
+  cloudShadow?: GraphTextureView,
 ): Result<void, RenderGraphError> {
   // A paired Point+Spot volume stores the Spot shadow lane as well. The
   // topology's primary light remains PointLight for radiance selection, but
@@ -301,6 +342,7 @@ export function addAuthoredVolumetricFogPasses(
     spotShadow,
     shadowLightKind,
     clusterBuffers,
+    cloudShadow,
   );
   if (!imported.ok) return imported;
   if (imported.value === undefined) return ok(undefined);
@@ -326,10 +368,7 @@ export function addVolumetricFogPasses(
   // 2D depth binding; use the always-present spot target as the inert binding
   // when directional shadows are disabled. Directional selection still uses
   // its own target whenever one exists, and spot selection uses spotShadow.
-  const shadowResource =
-    inputs.selectedLightKind === 'spot'
-      ? inputs.spotShadow
-      : (inputs.directionalShadow ?? inputs.spotShadow);
+  const shadowResource = inputs.directionalShadow ?? inputs.spotShadow;
   let inject: ComputeState | undefined;
   let integrate: ComputeState | undefined;
   let temporal: ComputeState | undefined;
@@ -349,6 +388,7 @@ export function addVolumetricFogPasses(
         ? []
         : [{ resource: inputs.projector, usage: 'sampled-read' as const }]),
       { resource: inputs.resources.froxelView, usage: 'storage-write' },
+      { resource: inputs.spotShadow, usage: 'sampled-read' },
     ],
     encode: ({ pass, frame, resources }) => {
       inject ??= computeState(frame, shaderSource(frame, 'inject'), 'volume_inject', [
@@ -367,8 +407,11 @@ export function addVolumetricFogPasses(
         },
         { binding: 7, visibility: 4, buffer: { type: 'read-only-storage' } },
         { binding: 8, visibility: 4, buffer: { type: 'uniform' } },
+        { binding: 9, visibility: 4, texture: { sampleType: 'depth', viewDimension: '2d' } },
       ]);
       const shadow = resources.textureView(shadowResource);
+      const spotShadow = resources.textureView(inputs.spotShadow);
+      if (!spotShadow.ok) throw spotShadow.error;
       const params = resources.buffer(inputs.params);
       const view = resources.buffer(inputs.view);
       const lightData = resources.buffer(inputs.lightData);
@@ -390,6 +433,7 @@ export function addVolumetricFogPasses(
         { binding: 6, resource: { kind: 'textureView', value: froxel.value as never } },
         { binding: 7, resource: { kind: 'buffer', value: { buffer: lightData.value } } },
         { binding: 8, resource: { kind: 'buffer', value: { buffer: clusterUniform.value } } },
+        { binding: 9, resource: { kind: 'textureView', value: spotShadow.value as never } },
       ]);
       pass.setPipeline(inject.pipeline);
       pass.setBindGroup(0, bindings);
@@ -402,6 +446,10 @@ export function addVolumetricFogPasses(
       { resource: inputs.resources.froxelView, usage: 'sampled-read' },
       { resource: inputs.sceneDepth, usage: 'sampled-read' },
       { resource: inputs.density, usage: 'sampled-read' },
+      ...(inputs.additionalDensities ?? []).map((resource) => ({
+        resource,
+        usage: 'sampled-read' as const,
+      })),
       { resource: inputs.resources.resolvedView, usage: 'storage-write' },
       { resource: inputs.resources.historyView, usage: 'storage-write' },
       { resource: inputs.resources.temporalView, usage: 'storage-write' },
@@ -412,6 +460,9 @@ export function addVolumetricFogPasses(
       ...(inputs.projector === undefined
         ? []
         : [{ resource: inputs.projector, usage: 'sampled-read' as const }]),
+      ...(inputs.cloudShadow === undefined
+        ? []
+        : [{ resource: inputs.cloudShadow, usage: 'sampled-read' as const }]),
     ],
     encode: ({ pass, frame, resources }) => {
       integrate ??= computeState(frame, shaderSource(frame, 'integrate'), 'volume_integrate', [
@@ -453,6 +504,13 @@ export function addVolumetricFogPasses(
         { binding: 11, visibility: 4, buffer: { type: 'uniform' } },
         { binding: 12, visibility: 4, texture: { sampleType: 'float', viewDimension: '2d' } },
         { binding: 13, visibility: 4, sampler: { type: 'filtering' } },
+        { binding: 16, visibility: 4, texture: { sampleType: 'float', viewDimension: '2d' } },
+        { binding: 17, visibility: 4, sampler: { type: 'filtering' } },
+        ...Array.from({ length: MAX_VOLUMETRIC_FOG_OWNERS - 1 }, (_, index) => ({
+          binding: 18 + index,
+          visibility: 4,
+          texture: { sampleType: 'float' as const, viewDimension: '3d' as const },
+        })),
       ]);
       const froxel = resources.textureView(inputs.resources.froxelView);
       const depth = resources.textureView(inputs.sceneDepth);
@@ -466,6 +524,8 @@ export function addVolumetricFogPasses(
       const clusterUniform = resources.buffer(inputs.clusterUniform);
       const projector =
         inputs.projector === undefined ? undefined : resources.textureView(inputs.projector);
+      const cloudShadow =
+        inputs.cloudShadow === undefined ? undefined : resources.textureView(inputs.cloudShadow);
       if (!froxel.ok) throw froxel.error;
       if (!depth.ok) throw depth.error;
       if (!density.ok) throw density.error;
@@ -477,6 +537,7 @@ export function addVolumetricFogPasses(
       if (!lightData.ok) throw lightData.error;
       if (!clusterUniform.ok) throw clusterUniform.error;
       if (projector !== undefined && !projector.ok) throw projector.error;
+      if (cloudShadow !== undefined && !cloudShadow.ok) throw cloudShadow.error;
       const sampler = frame.runtime.device.createSampler({
         minFilter: 'linear',
         magFilter: 'linear',
@@ -520,6 +581,28 @@ export function addVolumetricFogPasses(
             value: frame.volumetricFog?.projectorSampler ?? frame.pipelineState.defaultSampler,
           },
         },
+        {
+          binding: 16,
+          resource: {
+            kind: 'textureView',
+            value:
+              cloudShadow === undefined
+                ? frame.pipelineState.defaultWhiteTextureView
+                : (cloudShadow.value as never),
+          },
+        },
+        {
+          binding: 17,
+          resource: { kind: 'sampler', value: frame.pipelineState.defaultSampler },
+        },
+        ...Array.from({ length: MAX_VOLUMETRIC_FOG_OWNERS - 1 }, (_, index) => {
+          const view = resources.textureView(inputs.additionalDensities?.[index] ?? inputs.density);
+          if (!view.ok) throw view.error;
+          return {
+            binding: 18 + index,
+            resource: { kind: 'textureView' as const, value: view.value as never },
+          };
+        }),
       ]);
       pass.setPipeline(integrate.pipeline);
       pass.setBindGroup(0, bindings);

package/src/volume/resources.ts

@@ -8,6 +8,7 @@ import type {
 } from '@forgeax/engine-render-graph';
 import { ok, type Result } from '@forgeax/engine-types';
 import type { RenderPipelineFrame } from '../render-pipeline';
+import { MAX_VOLUMETRIC_FOG_OWNERS } from './component';
 
 export const VOLUME_FROXEL_FORMAT = 'rgba8unorm' as const;
 export const VOLUME_HISTORY_FORMAT = 'rgba16float' as const;
@@ -15,7 +16,7 @@ export const VOLUME_RESOLVED_FORMAT = 'rgba16float' as const;
 export const VOLUME_DEPTH_FORMAT = 'r32float' as const;
 export const VOLUME_PACKING_Z = 4;
 /** Renderer-owned parameter allocation shared by staging and inspection. */
-export const VOLUMETRIC_FOG_PARAMS_BYTES = 9 * 16;
+export const VOLUMETRIC_FOG_PARAMS_BYTES = (1 + MAX_VOLUMETRIC_FOG_OWNERS) * 9 * 16;
 
 export interface VolumetricFogExtent {
   readonly width: number;