@forgeax/engine-render 0.1.27 → 0.1.29

package/src/__tests__/standard-pipeline.integration.test.ts

@@ -8,6 +8,7 @@ import { createRenderSurfaceError, type RenderSurfaceExpectedError } from '../er
 import { prepareStandardLighting } from '../pipeline/standard-lighting/prepare';
 import { deriveStandardTopologyInput } from '../pipeline/standard-lighting/topology';
 import { selectStandardClusterTransport } from '../pipeline/standard-lighting/transport';
+import { createStandardOutputPlan } from '../pipeline/standard-output/graph';
 import { standardPipeline } from '../pipeline/standard-pipeline';
 import {
   DEFAULT_STANDARD_PROFILE,
@@ -16,6 +17,7 @@ import {
 } from '../pipeline/standard-profile';
 import type { RenderPipelineFrame, RenderPipelineTopology } from '../render-pipeline';
 import type { SurfaceProfile } from '../render-system';
+import { admitSsrSpatial } from '../ssr/admission';
 
 const rawOnlyProfile: SurfaceProfile = {
   kind: 'raw-only',
@@ -110,13 +112,84 @@ function standardLightingFor(resolvedTopology: RenderPipelineTopology) {
 async function build(profile: StandardProfile, overrides?: Partial<RenderPipelineTopology>) {
   const graph = new RenderGraphBuilder<RenderPipelineFrame>();
   const resolvedTopology = topology(profile, overrides);
+  const histogram = graph.createBuffer('standard-auto-exposure-histogram', { size: 1024 });
+  const state = graph.createBuffer('standard-auto-exposure-state', { size: 32 });
+  const candidate = graph.createBuffer('standard-auto-exposure-candidate', { size: 16 });
+  const parameters = graph.createBuffer('standard-auto-exposure-parameters', { size: 32 });
+  const lutTexture = graph.createTexture('standard-color-lut-source', {
+    format: 'rgba16float',
+    size: { width: 2, height: 2, depthOrArrayLayers: 2 },
+    dimension: '3d',
+  });
+  if (!histogram.ok || !state.ok || !candidate.ok || !parameters.ok || !lutTexture.ok)
+    throw new Error('standard output test resources could not be declared');
+  if (overrides?.output?.autoExposure === true) {
+    const parametersInit = graph.addComputePass('standard-auto-exposure-parameters-init', {
+      accesses: [{ resource: parameters.value, usage: 'storage-write' }],
+      encode: () => undefined,
+    });
+    if (!parametersInit.ok) throw parametersInit.error;
+  }
+  const lutView = graph.view(lutTexture.value, { dimension: '3d' });
+  if (!lutView.ok) throw lutView.error;
+  const lutInit = graph.addComputePass('standard-color-lut-test-init', {
+    accesses: [{ resource: lutView.value, usage: 'storage-write' }],
+    encode: () => undefined,
+  });
+  if (!lutInit.ok) throw lutInit.error;
+  const lutSampler = device.createSampler({ minFilter: 'linear', magFilter: 'linear' });
+  if (!lutSampler.ok) throw lutSampler.error;
+  const lutGpuTexture = device
+    .createTexture({
+      label: 'standard-output-test-lut',
+      format: 'rgba16float',
+      size: { width: 2, height: 2, depthOrArrayLayers: 2 },
+      dimension: '3d',
+      usage: 0x04,
+      textureBindingViewDimension: undefined,
+    })
+    .unwrap();
+  const lutGpuView = device.createTextureView(lutGpuTexture, { dimension: '3d' }).unwrap();
+  const lutBindGroupLayout = device
+    .createBindGroupLayout({
+      entries: [
+        { binding: 0, visibility: 0x2, texture: { sampleType: 'float', viewDimension: '3d' } },
+        { binding: 1, visibility: 0x2, sampler: { type: 'filtering' } },
+      ],
+    })
+    .unwrap();
+  const lutBindGroup = device
+    .createBindGroup({
+      layout: lutBindGroupLayout,
+      entries: [
+        { binding: 0, resource: { kind: 'textureView', value: lutGpuView } },
+        { binding: 1, resource: { kind: 'sampler', value: lutSampler.value } },
+      ],
+    })
+    .unwrap();
   const standardLighting = standardLightingFor(resolvedTopology);
   if (!standardLighting.ok) return standardLighting;
   const built = standardPipeline.build(
     {
       graph,
       standardLighting: standardLighting.value,
+      standardOutput: {
+        autoExposure: {
+          histogram: histogram.value,
+          state: state.value,
+          candidate: candidate.value,
+          parameters: parameters.value,
+        },
+        colorLut: {
+          view: lutView.value,
+          sampler: lutSampler.value,
+          strength: 1,
+          bindGroupLayout: lutBindGroupLayout,
+          bindGroup: lutBindGroup,
+        },
+      },
       encodeTransmissionMip: ({ pass }) => pass.draw(3, 1, 0, 0),
+      capabilities: { rgba16floatRenderable: true },
       projectGpuDriven: () => ok(undefined),
       contributeFeatures: () => ok(undefined),
     },
@@ -133,10 +206,10 @@ async function build(profile: StandardProfile, overrides?: Partial<RenderPipelin
 }
 
 function importedTaaHistory(graph: RenderGraphBuilder<RenderPipelineFrame>) {
-  const target = (label: string) => {
+  const target = (label: string, format: 'rgba16float' | 'r8unorm' = 'rgba16float') => {
     const texture = graph.importTexture(
       label,
-      { format: 'rgba16float', size: 'surface', usage: 0x17 },
+      { format, size: 'surface', usage: 0x17 },
       (frame) => frame.currentTexture,
     );
     if (!texture.ok) throw texture.error;
@@ -145,7 +218,7 @@ function importedTaaHistory(graph: RenderGraphBuilder<RenderPipelineFrame>) {
     return {
       texture: texture.value,
       view: view.value,
-      format: 'rgba16float' as const,
+      format,
       sampleCount: 1 as const,
     };
   };
@@ -154,6 +227,8 @@ function importedTaaHistory(graph: RenderGraphBuilder<RenderPipelineFrame>) {
     previousColor: target('taa-history-previous-color'),
     currentTemporal: target('taa-history-current-temporal'),
     previousTemporal: target('taa-history-previous-temporal'),
+    currentStability: target('taa-history-current-stability', 'r8unorm'),
+    previousStability: target('taa-history-previous-stability', 'r8unorm'),
   };
 }
 
@@ -179,12 +254,168 @@ async function buildTaa(profile: StandardProfile, overrides?: Partial<RenderPipe
 }
 
 describe('forgeax::standard graph', () => {
+  it('builds auto exposure and positive LUT with prepared live producers', async () => {
+    const result = await build(DEFAULT_STANDARD_PROFILE, {
+      output: {
+        autoExposure: true,
+        colorLut: true,
+        colorLutStrength: 1,
+        lutSourceKey: 'asset-guid:lut',
+      },
+    });
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    const info = result.value.inspect();
+    const names = info.passes.map((pass) => pass.name);
+    const tone = names.indexOf('standard-tone');
+    const lut = names.indexOf('standard-color-lut');
+    const fxaa = names.indexOf('fxaa');
+    const encoding = names.indexOf('standard-output-encoding');
+    expect(tone).toBeGreaterThanOrEqual(0);
+    expect(lut).toBeGreaterThan(tone);
+    expect(fxaa).toBeGreaterThan(lut);
+    expect(encoding).toBeGreaterThan(fxaa);
+    expect(info.resources).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          label: 'standard-tone-output',
+          descriptor: expect.objectContaining({ format: 'rgba16float', domain: 'linear-ldr' }),
+        }),
+        expect.objectContaining({
+          label: 'standard-color-lut',
+          descriptor: expect.objectContaining({ format: 'rgba16float', domain: 'linear-ldr' }),
+        }),
+        expect.objectContaining({
+          label: 'standard-fxaa-output',
+          descriptor: expect.objectContaining({ format: 'rgba16float', domain: 'linear-ldr' }),
+        }),
+      ]),
+    );
+  });
+
+  it('splits auto exposure without a LUT into tone, linear-LDR, and final encoding stages', async () => {
+    const result = await build(DEFAULT_STANDARD_PROFILE, {
+      camera: { tonemap: 'aces-filmic', antialias: 'none', bloom: 'off' },
+      output: { autoExposure: true, colorLut: false, colorLutStrength: 0 },
+    });
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    const info = result.value.inspect();
+    const names = info.passes.map((pass) => pass.name);
+    const tone = names.indexOf('standard-tone');
+    const encoding = names.indexOf('standard-output-encoding');
+    expect(tone).toBeGreaterThanOrEqual(0);
+    expect(encoding).toBeGreaterThan(tone);
+    expect(names).not.toContain('output-transform');
+    expect(names).not.toContain('standard-color-lut');
+    expect(names).toEqual(
+      expect.arrayContaining([
+        'linear-hdr-observation',
+        'linear-ldr-observation',
+        'final-srgb-observation',
+      ]),
+    );
+    expect(info.resources).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          label: 'standard-tone-output',
+          descriptor: expect.objectContaining({ format: 'rgba16float', domain: 'linear-ldr' }),
+        }),
+      ]),
+    );
+  });
+
+  it('routes non-neutral Camera white balance through the shared linear-HDR stage', async () => {
+    const result = await build(DEFAULT_STANDARD_PROFILE, {
+      camera: { tonemap: 'aces-filmic', antialias: 'none', bloom: 'off' },
+      output: {
+        autoExposure: false,
+        whiteBalance: true,
+        temperature: 5000,
+        tint: 0.2,
+        colorLut: false,
+        colorLutStrength: 0,
+      },
+    });
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    const names = result.value.inspect().passes.map((pass) => pass.name);
+    const wb = names.indexOf('standard-exposure-white-balance');
+    const tone = names.indexOf('standard-tone');
+    const encoding = names.indexOf('standard-output-encoding');
+    expect(wb).toBeGreaterThanOrEqual(0);
+    expect(tone).toBeGreaterThan(wb);
+    expect(encoding).toBeGreaterThan(tone);
+  });
+
+  it('keeps LUT0 on the combined output transform single pass', async () => {
+    const result = await build(DEFAULT_STANDARD_PROFILE, {
+      camera: { tonemap: 'aces-filmic', antialias: 'none', bloom: 'off' },
+      output: { autoExposure: false, colorLut: false, colorLutStrength: 0 },
+    });
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    const names = result.value.inspect().passes.map((pass) => pass.name);
+    expect(names.filter((name) => name === 'output-transform')).toHaveLength(1);
+    expect(names).not.toContain('standard-tone');
+    expect(names).not.toContain('standard-color-lut');
+    expect(names).not.toContain('standard-output-encoding');
+  });
+
   it('does not admit an unsupported four-light budget', async () => {
     const profile = { ...DEFAULT_STANDARD_PROFILE, lightCount: 4 } as unknown as StandardProfile;
     const result = await build(profile);
     expect(result.ok).toBe(false);
   });
 
+  it('uses one output plan for direct and clustered lanes', () => {
+    const request = {
+      temporal: true,
+      meter: true,
+      bloom: true,
+      exposure: true,
+      whiteBalance: true,
+      lut: true,
+      fxaa: true,
+      outputEncoding: 'explicit-oetf' as const,
+    };
+    const direct = createStandardOutputPlan({ ...request, lane: 'direct' });
+    const clustered = createStandardOutputPlan({ ...request, lane: 'clustered' });
+    expect(clustered.logicalStages).toEqual(direct.logicalStages);
+    expect(clustered.physicalStages).toEqual(direct.physicalStages);
+    expect(clustered.finalWriterCount).toBe(direct.finalWriterCount);
+  });
+
+  it('accounts for admitted LUT bindings without adding work to the zero-strength path', () => {
+    const baseline = createStandardOutputPlan({
+      lane: 'direct',
+      temporal: false,
+      meter: false,
+      bloom: false,
+      exposure: false,
+      whiteBalance: false,
+      lut: false,
+      fxaa: false,
+      outputEncoding: 'explicit-oetf',
+    });
+    const lut = createStandardOutputPlan({
+      lane: 'direct',
+      temporal: false,
+      meter: false,
+      bloom: false,
+      exposure: false,
+      whiteBalance: false,
+      lut: true,
+      fxaa: false,
+      outputEncoding: 'explicit-oetf',
+    });
+
+    expect(baseline.incrementalResources).toEqual([]);
+    expect(baseline.incrementalBindings).toBe(0);
+    expect(lut.incrementalResources).toContain('standard-color-lut');
+    expect(lut.incrementalBindings).toBeGreaterThan(0);
+  });
+
   it('keeps the last-known-good graph for each explicit surface failure', () => {
     let activeGraph = 'last-known-good';
     const failures = ['allocation', 'attachment', 'sampled-read', 'raw-endpoint'] as const;
@@ -206,6 +437,92 @@ describe('forgeax::standard graph', () => {
     expect(activeGraph).toBe('candidate');
   });
 
+  it('keeps SSR out of the Standard graph without admitted dependencies', async () => {
+    const result = await build({ ...DEFAULT_STANDARD_PROFILE, renderPath: 'deferred' });
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    const info = result.value.inspect();
+    expect(info.passes.map((pass) => pass.name).some((name) => name.startsWith('ssr'))).toBe(false);
+    expect(
+      info.resources.map((resource) => resource.label).some((label) => label.startsWith('ssr')),
+    ).toBe(false);
+  });
+
+  it('projects the admitted SSR spatial chain into the deferred Standard graph', async () => {
+    const result = await build(
+      { ...DEFAULT_STANDARD_PROFILE, renderPath: 'deferred' },
+      {
+        reflectionFallback: { enabled: true },
+        ssr: admitSsrSpatial({
+          camera: {
+            projection: 'perspective',
+            near: 0.1,
+            far: 100,
+            screenSpaceReflection: {
+              maxDistance: 40,
+              thickness: 0.2,
+              maxRoughness: 0.6,
+            },
+          },
+          environment: {
+            lane: 'deferred',
+            m0: { status: 'admitted' },
+            sceneInputs: true,
+            temporal: true,
+            reflectionFallback: true,
+            capabilities: {
+              compute: true,
+              storageTexture: true,
+              rgba16floatRenderable: true,
+              r32floatSampledStorage: true,
+            },
+          },
+        }),
+      },
+    );
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    const names = result.value.inspect().passes.map((pass) => pass.name);
+    expect(names).toContain('ssr-hiz-seed');
+    expect(names).toContain('ssr-trace');
+    expect(names).toContain('standard-scene-data');
+    expect(names).toContain('ssr-compose');
+    expect(names.indexOf('skybox')).toBeLessThan(names.indexOf('lighting'));
+    expect(names.indexOf('lighting')).toBeLessThan(names.indexOf('ssr-hiz-seed'));
+    expect(names.indexOf('ssr-compose')).toBeLessThan(names.indexOf('forward'));
+    expect(names).toContain('reflection-fallback-observation');
+    expect(result.value.inspect().resources.map((resource) => resource.label)).toEqual(
+      expect.arrayContaining(['ssr-hiz', 'ssr-trace', 'reflection-fallback-linear-hdr']),
+    );
+  });
+
+  it('keeps the deferred reflection fallback producer observable without SSR', async () => {
+    const result = await build(
+      { ...DEFAULT_STANDARD_PROFILE, renderPath: 'deferred' },
+      { reflectionFallback: { enabled: true } },
+    );
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    const names = result.value.inspect().passes.map((pass) => pass.name);
+    expect(names).toContain('reflection-fallback-observation');
+    expect(result.value.inspect().resources.map((resource) => resource.label)).toContain(
+      'reflection-fallback-linear-hdr',
+    );
+    expect(names.some((name) => name.startsWith('ssr-'))).toBe(false);
+    expect(
+      result.value.inspect().passes.find((pass) => pass.name === 'lighting')?.accesses,
+    ).toContainEqual({
+      resource: 'reflection-fallback-linear-hdr',
+      usage: 'color-attachment',
+    });
+    expect(
+      result.value.inspect().passes.find((pass) => pass.name === 'g-buffer')?.accesses,
+    ).not.toContainEqual({
+      resource: 'reflection-fallback-linear-hdr',
+      usage: 'color-attachment',
+    });
+  });
+
   it.each([
     ['forward-1', { ...DEFAULT_STANDARD_PROFILE, lightCount: 1, renderPath: 'forward' }],
     ['forward-32', { ...DEFAULT_STANDARD_PROFILE, lightCount: 32, renderPath: 'forward' }],

package/src/__tests__/standard-profile-oracle.unit.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, it } from 'vitest';
+import { AUTO_EXPOSURE_PRESET_V1 } from '../pipeline/standard-output/auto-exposure/preset';
 import {
   DEFAULT_STANDARD_PROFILE,
   STANDARD_LIGHT_COUNTS,
@@ -54,4 +55,25 @@ describe('Standard profile oracle', () => {
       'present',
     ]);
   });
+  it('keeps current-main post-processing defaults in the Standard profile', () => {
+    expect(DEFAULT_STANDARD_PROFILE).toMatchObject({
+      renderPath: 'forward',
+      postStages: [
+        'transparent-blend',
+        'bloom',
+        'output-transform',
+        'fxaa',
+        'post-effect',
+        'present',
+      ],
+    });
+    expect(DEFAULT_STANDARD_PROFILE).not.toHaveProperty('tone');
+    expect(DEFAULT_STANDARD_PROFILE).not.toHaveProperty('antialias');
+    expect(DEFAULT_STANDARD_PROFILE).not.toHaveProperty('sky');
+  });
+
+  it('binds the Standard profile to the versioned auto-exposure oracle preset', () => {
+    expect(AUTO_EXPOSURE_PRESET_V1.version).toBe('auto-exposure-v1');
+    expect(AUTO_EXPOSURE_PRESET_V1.histogramBins).toBe(256);
+  });
 });

package/src/__tests__/standard-surface-lighting.unit.test.ts

@@ -0,0 +1,41 @@
+import type { BindGroupEntry, BindGroupLayout } from '@forgeax/engine-rhi';
+import { rhi } from '@forgeax/engine-rhi-null';
+import { expect, it, vi } from 'vitest';
+import {
+  createStandardSurfaceLightingBindGroup,
+  getOrCreateHdrpBuffers,
+  resetHdrpBuffers,
+} from '../hdrp-buffers';
+import type { RenderSystemRuntime } from '../record/render-context';
+
+it('binds the current Standard cluster allocation without a scene mesh or palette', async () => {
+  const adapter = (await rhi.requestAdapter()).unwrap();
+  const device = (await adapter.requestDevice()).unwrap();
+  const fire = vi.fn();
+  const runtime = { device, errorRegistry: { fire } } as unknown as RenderSystemRuntime;
+  const grid = { x: 32, y: 16, z: 32 };
+  const prepared = getOrCreateHdrpBuffers(runtime, grid);
+  if (prepared === null) throw new Error('Standard allocation failed');
+  const entries: BindGroupEntry[][] = [];
+  const create = device.createBindGroup.bind(device);
+  device.createBindGroup = (descriptor) => {
+    entries.push([...descriptor.entries]);
+    return create(descriptor);
+  };
+  expect(
+    createStandardSurfaceLightingBindGroup(runtime, {} as BindGroupLayout, grid),
+  ).not.toBeNull();
+  expect(entries).toHaveLength(1);
+  expect(entries[0]?.map((entry) => entry.binding)).toEqual([3, 4, 5, 6, 7, 8]);
+  expect(entries[0]?.slice(0, 4).map((entry) => entry.resource)).toEqual(
+    [
+      prepared.lightDataBuffer,
+      prepared.clusterGridBuffer,
+      prepared.lightIndexListBuffer,
+      prepared.clusterUniformBuffer,
+    ].map((buffer) => ({ kind: 'buffer', value: { buffer } })),
+  );
+  expect(getOrCreateHdrpBuffers(runtime, grid)).toBe(prepared);
+  expect(fire).not.toHaveBeenCalled();
+  resetHdrpBuffers(runtime);
+});

package/src/__tests__/standard-texture-specialization.dawn.test.ts

@@ -0,0 +1,141 @@
+import { createShaderModuleImmediate, rhi } from '@forgeax/engine-rhi-webgpu';
+import {
+  DEFAULT_STANDARD_PBR_PARAM_SCHEMA,
+  STANDARD_TEXTURE_MASK_OVERRIDE,
+  standardTextureMask,
+} from '@forgeax/engine-shader';
+import { expect, it } from 'vitest';
+import { lowerStandardPhysicalBindings } from '../../../shader-compiler/src/material/lower-standard-contract';
+import { GPU_SHADER_STAGE_FRAGMENT } from '../gpu-stage';
+import {
+  GPU_TEXTURE_USAGE_COPY_DST,
+  GPU_TEXTURE_USAGE_COPY_SRC,
+  GPU_TEXTURE_USAGE_RENDER_ATTACHMENT,
+  GPU_TEXTURE_USAGE_TEXTURE_BINDING,
+} from '../gpu-texture-usage';
+import { GPU_BUFFER_USAGE_COPY_DST, GPU_BUFFER_USAGE_MAP_READ } from '../gpu-usage';
+import { buildPipelineForMaterialShader } from '../pipeline-builder';
+
+it('applies all schema-derived texture specialization bits through the real material PSO owner', async () => {
+  const fields = DEFAULT_STANDARD_PBR_PARAM_SCHEMA.filter((entry) => entry.type === 'texture2d');
+  const body = fields
+    .map((field, index) => {
+      const name = field.name[0]?.toUpperCase() + field.name.slice(1);
+      return `if (standardUses${name}()) { result += ${2 ** index}.0 * textureLoad(poison, vec2<i32>(0), 0).r; }`;
+    })
+    .join('\n');
+  // Use the compiler's real shared-entry projection and Render's real PSO
+  // builder. Omitting the fragment overrides turns every absent map on and
+  // makes the first (zero-map) readback fail, independent of image judgment.
+  const source = lowerStandardPhysicalBindings(
+    `
+@group(0) @binding(0) var poison: texture_2d<f32>;
+@vertex fn vs_main(@builtin(vertex_index) index: u32) -> @builtin(position) vec4<f32> {
+  let p = array<vec2<f32>, 3>(vec2<f32>(-1.0,-1.0), vec2<f32>(3.0,-1.0), vec2<f32>(-1.0,3.0));
+  return vec4<f32>(p[index], 0.0, 1.0);
+}
+@fragment fn fs_main() -> @location(0) vec4<f32> {
+  var result = 0.0;
+  ${body}
+  return vec4<f32>(result, 0.0, 0.0, 1.0);
+}`,
+    DEFAULT_STANDARD_PBR_PARAM_SCHEMA,
+    true,
+  );
+  const device = (await (await rhi.requestAdapter()).unwrap().requestDevice()).unwrap();
+  const input = device
+    .createTexture({
+      size: { width: 1, height: 1 },
+      format: 'rgba8unorm',
+      textureBindingViewDimension: '2d',
+      usage: GPU_TEXTURE_USAGE_COPY_DST | GPU_TEXTURE_USAGE_TEXTURE_BINDING,
+    })
+    .unwrap();
+  const output = device
+    .createTexture({
+      size: { width: 1, height: 1 },
+      format: 'rgba32float',
+      textureBindingViewDimension: '2d',
+      usage: GPU_TEXTURE_USAGE_COPY_SRC | GPU_TEXTURE_USAGE_RENDER_ATTACHMENT,
+    })
+    .unwrap();
+  const readback = device
+    .createBuffer({ size: 256, usage: GPU_BUFFER_USAGE_COPY_DST | GPU_BUFFER_USAGE_MAP_READ })
+    .unwrap();
+  try {
+    device.queue
+      .writeTexture(
+        { texture: input },
+        new Uint8Array([255, 0, 0, 255]),
+        { bytesPerRow: 4 },
+        { width: 1, height: 1 },
+      )
+      .unwrap();
+    const inputView = device.createTextureView(input, {}).unwrap();
+    const outputView = device.createTextureView(output, {}).unwrap();
+    const groupLayout = device
+      .createBindGroupLayout({
+        entries: [
+          {
+            binding: 0,
+            visibility: GPU_SHADER_STAGE_FRAGMENT,
+            texture: { sampleType: 'float', viewDimension: '2d' },
+          },
+        ],
+      })
+      .unwrap();
+    const layout = device.createPipelineLayout({ bindGroupLayouts: [groupLayout] }).unwrap();
+    const group = device
+      .createBindGroup({
+        layout: groupLayout,
+        entries: [{ binding: 0, resource: { kind: 'textureView', value: inputView } }],
+      })
+      .unwrap();
+    for (const mask of [
+      0,
+      ...fields.map((field) => standardTextureMask([field])),
+      standardTextureMask(fields),
+    ]) {
+      const pipeline = buildPipelineForMaterialShader(
+        `texture-mask-${mask}`,
+        { source, paramSchema: [] },
+        {
+          device,
+          shaderModuleFactory: {
+            createShaderModule: (descriptor) => createShaderModuleImmediate(device, descriptor),
+          },
+          pipelineLayout: layout,
+          colorFormat: 'rgba32float',
+          depthFormat: undefined,
+          vertexBuffers: [],
+          fragmentConstants: { [STANDARD_TEXTURE_MASK_OVERRIDE]: mask },
+        },
+        { cullMode: 'none' },
+      ).unwrap();
+      const encoder = device.createCommandEncoder().unwrap();
+      const pass = encoder.beginRenderPass({
+        colorAttachments: [
+          { view: outputView, loadOp: 'clear', storeOp: 'store', clearValue: [0, 0, 0, 0] },
+        ],
+      });
+      pass.setPipeline(pipeline);
+      pass.setBindGroup(0, group);
+      pass.draw(3);
+      pass.end();
+      encoder.copyTextureToBuffer(
+        { texture: output },
+        { buffer: readback, bytesPerRow: 256, rowsPerImage: 1 },
+        { width: 1, height: 1 },
+      );
+      device.queue.submit([encoder.finish().unwrap()]).unwrap();
+      const mapped = (await readback.mapAsync(GPU_BUFFER_USAGE_MAP_READ)).unwrap();
+      const values = Array.from(new Float32Array(mapped.getMappedRange().unwrap().slice(0, 16)));
+      mapped.unmap();
+      expect(values, `texture mask ${mask}`).toEqual([mask, 0, 0, 1]);
+    }
+  } finally {
+    device.destroyTexture(input).unwrap();
+    device.destroyTexture(output).unwrap();
+    device.destroyBuffer(readback).unwrap();
+  }
+});

package/src/__tests__/surface-adjacent-regressions.integration.test.ts

@@ -1,11 +1,11 @@
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
+import { STANDARD_PBR_ARTIFACT_RECEIPT } from '@forgeax/engine-shader';
 import { describe, expect, it } from 'vitest';
 import {
   projectStandardSurfacePasses,
   type StandardSurfaceProjectionOptions,
 } from '../assembly/material/surface-projection';
-import { GPU_DRIVEN_RIGID_UNLIT_WGSL } from '../gpu-driven/production-raster';
 
 function shaderSource(name: string): string {
   return readFileSync(
@@ -54,7 +54,10 @@ describe('Surface adjacent regressions', () => {
     const skinned = shaderSource('default-standard-pbr-skin.wgsl');
     expect(skinned).toContain('skinIndex');
     expect(skinned).toContain('skinWeight');
-    expect(GPU_DRIVEN_RIGID_UNLIT_WGSL).toContain('@builtin(instance_index)');
-    expect(GPU_DRIVEN_RIGID_UNLIT_WGSL).not.toContain('surface_v1');
+    expect(STANDARD_PBR_ARTIFACT_RECEIPT.directEntry).toBe('vs_main');
+    expect(STANDARD_PBR_ARTIFACT_RECEIPT.sceneIndexEntry).toBe('vs_scene_index');
+    expect(STANDARD_PBR_ARTIFACT_RECEIPT.resourceSlots.every((slot) => slot.group === 1)).toBe(
+      true,
+    );
   });
 });