@forgeax/engine-render 0.1.27 → 0.1.29

package/src/__tests__/material-contract-inventory.unit.test.ts

@@ -38,7 +38,11 @@ describe('vertex color does not change the material contract', () => {
 
   it('keeps the standard authoring parameters derived from the shared schema', () => {
     const material = Materials.standard({ baseColor: [1, 1, 1, 1] });
-    expect(material.parameters?.map((parameter) => parameter.name)).toEqual([
+    expect(
+      material.parameters
+        ?.filter((parameter) => parameter.type !== 'texture')
+        .map((parameter) => parameter.name),
+    ).toEqual([
       'baseColor',
       'metallic',
       'roughness',
@@ -54,11 +58,6 @@ describe('vertex color does not change the material contract', () => {
       'specularColor',
       'normalScale',
       'ior',
-      'baseColorTexture',
-      'metallicRoughnessTexture',
-      'normalTexture',
-      'emissiveTexture',
-      'occlusionTexture',
     ]);
     expect(material.values).not.toHaveProperty('transmission');
     expect(material.values).toHaveProperty('ior', 1.5);

package/src/__tests__/material-dispatch-shader-id.unit.test.ts

@@ -0,0 +1,51 @@
+import type { EntityHandle } from '@forgeax/engine-ecs';
+import type { MaterialPass } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import { appendMaterialDispatchEntries, type DispatchEntry } from '../render-system-extract';
+
+const passes: readonly MaterialPass[] = [
+  {
+    name: 'forward',
+    program: {
+      module: 'forgeax_material::standard',
+      vertexEntry: 'vs_main',
+      fragmentEntry: 'fs_main',
+    },
+    renderState: { tags: { LightMode: 'Forward' }, queue: 2000 },
+  },
+  {
+    name: 'deferred',
+    program: {
+      module: 'forgeax_material::standard',
+      vertexEntry: 'vs_main',
+      fragmentEntry: 'fs_gbuffer',
+    },
+    renderState: { tags: { LightMode: 'Deferred' }, queue: 2000 },
+  },
+  {
+    name: 'shadow-caster',
+    program: {
+      module: 'forgeax_material::standard',
+      vertexEntry: 'vs_main',
+      fragmentEntry: 'fs_shadow',
+    },
+    renderState: { tags: { LightMode: 'ShadowCaster' }, queue: 2000 },
+  },
+];
+
+describe('material dispatch shader identity', () => {
+  it('uses the published Pass specialization for every authored pass', () => {
+    const dispatch: DispatchEntry[] = [];
+    appendMaterialDispatchEntries(dispatch, passes, 0 as EntityHandle, 17, 0, 0, {}, 0, {
+      forward: 'forgeax::surface-variant::rusted-iron',
+      deferred: 'forgeax::surface-variant::rusted-iron',
+      'shadow-caster': 'forgeax::surface-variant::rusted-iron-shadow',
+    });
+
+    expect(dispatch.map((entry) => entry.materialShaderId)).toEqual([
+      'forgeax::surface-variant::rusted-iron',
+      'forgeax::surface-variant::rusted-iron',
+      'forgeax::surface-variant::rusted-iron-shadow',
+    ]);
+  });
+});

package/src/__tests__/material-lane-selection.unit.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, it } from 'vitest';
+import {
+  buildMatchedMaterialHandlesByRenderable,
+  filterDispatchBySelector,
+} from '../record/shadow-pass';
+import type { DispatchEntry } from '../render-system-extract';
+
+function entry(renderableIndex: number, materialHandle: number, lightMode: string): DispatchEntry {
+  return {
+    entityIndex: renderableIndex,
+    renderableIndex,
+    materialHandle,
+    passIndex: 0,
+    queue: 2000,
+    layer: 0,
+    tags: { LightMode: lightMode },
+    renderState: undefined,
+    defines: undefined,
+    vertexEntry: 'vs_main',
+    fragmentEntry: lightMode === 'Deferred' ? 'fs_gbuffer' : 'fs_main',
+    materialShaderId: 'forgeax::default-standard-pbr',
+    paramSnapshot: undefined,
+  };
+}
+
+describe('material membership across graph lanes', () => {
+  const dispatch = [
+    entry(0, 1, 'Forward'),
+    entry(0, 1, 'Deferred'),
+    entry(0, 2, 'Forward'),
+    entry(1, 2, 'Deferred'),
+    entry(1, 3, 'Forward'),
+  ];
+  it('selects Forward entries only for the same renderable/material that wrote Deferred', () => {
+    const selected = buildMatchedMaterialHandlesByRenderable(
+      dispatch,
+      { LightMode: ['Forward'] },
+      undefined,
+      { LightMode: ['Deferred'] },
+    );
+    expect([...(selected ?? [])].map(([index, handles]) => [index, [...handles]])).toEqual([
+      [0, [1]],
+    ]);
+    const draws = filterDispatchBySelector(dispatch, { LightMode: ['Forward'] }).filter((draw) =>
+      selected?.get(draw.renderableIndex)?.has(draw.materialHandle),
+    );
+    expect(draws.map((draw) => draw.fragmentEntry)).toEqual(['fs_main']);
+  });
+  it('keeps the later Forward-only lane disjoint from Deferred membership', () => {
+    const selected = buildMatchedMaterialHandlesByRenderable(
+      dispatch,
+      { LightMode: ['Forward'] },
+      { LightMode: ['Deferred'] },
+    );
+    expect([...(selected ?? [])].map(([index, handles]) => [index, [...handles]])).toEqual([
+      [0, [2]],
+      [1, [3]],
+    ]);
+  });
+});

package/src/__tests__/material-numeric-upload.unit.test.ts

@@ -0,0 +1,53 @@
+import type { ParamSchemaEntry } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import {
+  applyParamSchemaDefaultsToUbo,
+  applyParamSnapshotToUbo,
+} from '../record/main-pass-material';
+
+describe('material numeric upload', () => {
+  it.each([
+    'buffer',
+    'bytes',
+    'floats',
+  ] as const)('preserves WGSL integer bits in a %s payload', (kind) => {
+    const storage = new ArrayBuffer(48);
+    new Uint8Array(storage).fill(0xcd);
+    const payload =
+      kind === 'buffer'
+        ? storage
+        : kind === 'bytes'
+          ? new Uint8Array(storage, 16, 16)
+          : new Float32Array(storage, 16, 4);
+    const offset = kind === 'buffer' ? 0 : 16;
+    const schema: readonly ParamSchemaEntry[] = [
+      { name: 'signed', type: 'i32' },
+      { name: 'unsigned', type: 'u32' },
+      { name: 'gain', type: 'f32' },
+    ];
+    applyParamSnapshotToUbo(payload, schema, { signed: -7, unsigned: 0xfedcba98, gain: 0.25 });
+    const view = new DataView(storage, offset, 16);
+    expect(view.getInt32(0, true)).toBe(-7);
+    expect(view.getUint32(4, true)).toBe(0xfedcba98);
+    expect(view.getFloat32(8, true)).toBe(0.25);
+    expect(view.getUint32(12, true)).toBe(0xcdcdcdcd);
+    if (kind !== 'buffer')
+      expect(new Uint8Array(storage).slice(0, 16)).toEqual(new Uint8Array(16).fill(0xcd));
+  });
+
+  it('seeds prepared payloads from numeric schema defaults before authored overlays', () => {
+    const payload = new Uint8Array(64);
+    const schema: readonly ParamSchemaEntry[] = [
+      { name: 'roughness', type: 'f32', default: 0.5 },
+      { name: 'tint', type: 'vec3', default: [1, 0.5, 0.25] },
+      { name: 'ignoredTexture', type: 'texture2d' },
+    ];
+    applyParamSchemaDefaultsToUbo(payload, schema);
+    const seeded = new Float32Array(payload.buffer, payload.byteOffset, payload.byteLength / 4);
+    expect(seeded[0]).toBe(0.5);
+    expect([...seeded.slice(4, 7)]).toEqual([1, 0.5, 0.25]);
+    applyParamSnapshotToUbo(payload, schema, { roughness: 0.25 });
+    expect(seeded[0]).toBe(0.25);
+    expect([...seeded.slice(4, 7)]).toEqual([1, 0.5, 0.25]);
+  });
+});

package/src/__tests__/material-texture-handles.unit.test.ts

@@ -0,0 +1,18 @@
+import type { Handle } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import { materialTextureHandlesForResidency } from '../render-system';
+
+type TextureHandle = Handle<'TextureAsset', 'shared'>;
+
+describe('material texture residency handles', () => {
+  it('drops the zero missing-reference sentinel before GPU resolution', () => {
+    const missing = 0 as TextureHandle;
+    const first = 7 as TextureHandle;
+    const duplicate = 7 as TextureHandle;
+    const second = 11 as TextureHandle;
+
+    expect(
+      materialTextureHandlesForResidency([undefined, missing, first, duplicate, second]),
+    ).toEqual([first, second]);
+  });
+});

package/src/__tests__/material-texture-source.unit.test.ts

@@ -0,0 +1,87 @@
+import { World } from '@forgeax/engine-ecs';
+import { describe, expect, it } from 'vitest';
+import {
+  collectMaterialTextureSources,
+  type MaterialTextureSourceCache,
+  materialTextureSourceFields,
+} from '../render-system-extract';
+import type { RenderTargetDescriptor } from '../targets/contracts';
+import {
+  createRenderTargetMaterialSource,
+  resolveRenderTargetMaterialSource,
+} from '../targets/material-source';
+import { createRenderTargetOwner } from '../targets/owner';
+
+const descriptor: RenderTargetDescriptor = {
+  shape: '2d',
+  width: 8,
+  height: 8,
+  format: 'rgba8unorm',
+  mipLevels: 1,
+  sampleCount: 1,
+  sampled: true,
+  readback: false,
+};
+
+describe('material texture source projection', () => {
+  it('admits only schema-declared texture fields for numeric source handles', () => {
+    const world = new World();
+    const owner = createRenderTargetOwner({
+      rendererId: Symbol('material-source'),
+      initialGeneration: 1,
+    });
+    const target = owner.create(descriptor);
+    expect(target.ok).toBe(true);
+    if (!target.ok) return;
+    const binding = createRenderTargetMaterialSource(target.value, descriptor, {
+      aspect: 'color',
+      dimension: '2d',
+      mipLevel: 0,
+      generation: 1,
+    });
+    expect(binding.ok).toBe(true);
+    if (!binding.ok) return;
+    const handle = world.internSharedRef('RenderTargetTextureSource', binding.value.source);
+    const stats = {
+      sourceFieldsVisited: 0,
+      numericSharedRefProbes: 0,
+      sourceCacheHits: 0,
+      sourceCacheMisses: 0,
+      producerRoutes: {},
+    };
+    const cache: MaterialTextureSourceCache = new Map();
+    const sources = collectMaterialTextureSources(
+      { roughness: Number(handle), baseColorTexture: Number(handle) },
+      world,
+      new Set(['baseColorTexture']),
+      stats,
+      cache,
+    );
+    collectMaterialTextureSources(
+      { baseColorTexture: Number(handle) },
+      world,
+      new Set(['baseColorTexture']),
+      stats,
+      cache,
+    );
+    expect(sources.get('baseColorTexture')).toBe(binding.value.source);
+    expect(sources.has('roughness')).toBe(false);
+    expect(stats).toMatchObject({
+      sourceFieldsVisited: 2,
+      numericSharedRefProbes: 2,
+      sourceCacheMisses: 1,
+      sourceCacheHits: 1,
+    });
+    expect(resolveRenderTargetMaterialSource(binding.value.source)).toBeDefined();
+  });
+
+  it('derives source fields from the published param schema', () => {
+    const fields = materialTextureSourceFields([
+      { name: 'roughness', type: 'f32' },
+      { name: 'albedo', type: 'texture2d' },
+      { name: 'normal', type: 'texture2d_array' },
+      { name: 'sampler', type: 'sampler' },
+    ]);
+    expect([...(fields ?? [])]).toEqual(['albedo', 'normal']);
+  });
+});

package/src/__tests__/materials-authoring-validation.unit.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it } from 'vitest';
+import { MaterialAuthoringContractError, Materials } from '../materials';
+
+describe('Materials.standard authoring validation', () => {
+  it.each([
+    [-0.01, 'range'],
+    [1.01, 'range'],
+    [Number.NaN, 'non-finite'],
+    [Number.POSITIVE_INFINITY, 'non-finite'],
+  ] as const)('rejects alphaCutoff=%s with a narrow structured error', (alphaCutoff, reason) => {
+    expect(() => Materials.standard({ baseColor: [1, 1, 1, 1], alphaCutoff })).toThrow(
+      MaterialAuthoringContractError,
+    );
+    try {
+      Materials.standard({ baseColor: [1, 1, 1, 1], alphaCutoff });
+    } catch (error) {
+      expect(error).toMatchObject({
+        name: 'MaterialAuthoringContractError',
+        code: 'material-authoring-contract-invalid',
+        expected: expect.stringContaining('finite'),
+        hint: expect.stringContaining('alphaCutoff'),
+        detail: {
+          code: 'material-authoring-contract-invalid',
+          material: 'Standard',
+          parameter: 'alphaCutoff',
+          reason,
+          actual: alphaCutoff,
+        },
+      });
+    }
+  });
+
+  it('keeps the closed interval as a valid Standard authoring value', () => {
+    expect(Materials.standard({ baseColor: [1, 1, 1, 1], alphaCutoff: 0 }).values).toMatchObject({
+      alphaCutoff: 0,
+    });
+    expect(Materials.standard({ baseColor: [1, 1, 1, 1], alphaCutoff: 1 }).values).toMatchObject({
+      alphaCutoff: 1,
+    });
+  });
+});

package/src/__tests__/materials-standard-contract.unit.test.ts

@@ -1,9 +1,59 @@
 import type { Buffer, Sampler, TextureView } from '@forgeax/engine-rhi';
+import { STANDARD_MATERIAL_PARAM_SCHEMA, standardSurfaceParameters } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
 import { assembleMaterialWithSkylightEntries } from '../ibl/skylight-bind-group.js';
 import { Materials } from '../materials.js';
+import { materialStandardTextureMask } from '../render-system-extract';
 
 describe('Materials.standard clearcoat public contract', () => {
+  it('samples only authored textures while preserving the shared Surface slot contract', () => {
+    const maps = STANDARD_MATERIAL_PARAM_SCHEMA.filter(
+      (parameter) => parameter.type === 'texture2d',
+    );
+    const base = Materials.standard({ baseColor: [1, 1, 1, 1] });
+    const surfaceSlots = standardSurfaceParameters([]).filter(
+      (parameter) => parameter.type === 'texture',
+    );
+    expect(base.parameters?.filter((parameter) => parameter.type === 'texture')).toEqual(
+      surfaceSlots,
+    );
+    expect(
+      materialStandardTextureMask(
+        base.parameters,
+        'forgeax::default-standard-pbr',
+        base.values ?? {},
+      ),
+    ).toBe(0);
+    for (const [index, map] of maps.entries()) {
+      const material = Materials.standard({ baseColor: [1, 1, 1, 1], [map.name]: 1 });
+      expect(
+        material.parameters
+          ?.filter((parameter) => parameter.type === 'texture')
+          .map((parameter) => parameter.name)
+          .sort(),
+      ).toEqual([...new Set([...surfaceSlots.map((slot) => slot.name), map.name])].sort());
+      expect(material.values?.[map.name]).toBe(1);
+      expect(
+        materialStandardTextureMask(
+          material.parameters,
+          'forgeax::default-standard-pbr',
+          material.values ?? {},
+        ),
+      ).toBe(2 ** index);
+      for (const parameters of [undefined, []]) {
+        expect(
+          materialStandardTextureMask(parameters, 'forgeax::default-standard-pbr', {
+            [map.name]: 1,
+          }),
+        ).toBe(2 ** index);
+      }
+    }
+  });
+  it('retains parameter defaults without specializing custom shader roots', () => {
+    const parameters = [{ name: 'normalTexture', type: 'texture' as const, default: 1 }];
+    expect(materialStandardTextureMask(parameters, 'forgeax::default-standard-pbr', {})).toBe(4);
+    expect(materialStandardTextureMask(parameters, 'app::custom-pbr', {})).toBeUndefined();
+  });
   it('declares clearcoat only when the physical root is authored', () => {
     const base = Materials.standard({ baseColor: [1, 1, 1, 1] });
     const zero = Materials.standard({ baseColor: [1, 1, 1, 1], clearcoat: 0 });
@@ -65,8 +115,8 @@ describe('Materials.standard clearcoat public contract', () => {
       clearcoatTexture: 1,
     });
     const names = material.parameters?.map((parameter) => parameter.name) ?? [];
-    expect(names.indexOf('clearcoat')).toBeLessThan(names.indexOf('baseColorTexture'));
-    expect(names.indexOf('clearcoatRoughness')).toBeLessThan(names.indexOf('baseColorTexture'));
+    expect(names.indexOf('clearcoat')).toBeLessThan(names.indexOf('clearcoatTexture'));
+    expect(names.indexOf('clearcoatRoughness')).toBeLessThan(names.indexOf('clearcoatTexture'));
   });
 
   it('keeps authored clearcoat map pairs contiguous after the material ABI', () => {

package/src/__tests__/mesh-buffer-usage-surface.unit.test.ts

@@ -47,6 +47,10 @@ const featureBufferSources = [
     source: readFileSync(new URL('../record/main-pass-sprite-draws.ts', import.meta.url), 'utf8'),
     names: ['GPU_BUFFER_USAGE_STORAGE', 'GPU_BUFFER_USAGE_UNIFORM', 'GPU_BUFFER_USAGE_COPY_DST'],
   },
+  {
+    source: readFileSync(new URL('../record/shadow-pass.ts', import.meta.url), 'utf8'),
+    names: ['GPU_BUFFER_USAGE_STORAGE', 'GPU_BUFFER_USAGE_UNIFORM', 'GPU_BUFFER_USAGE_COPY_DST'],
+  },
   {
     source: readFileSync(new URL('../systems/skin-palette-allocator.ts', import.meta.url), 'utf8'),
     names: ['GPU_BUFFER_USAGE_STORAGE', 'GPU_BUFFER_USAGE_UNIFORM', 'GPU_BUFFER_USAGE_COPY_DST'],

package/src/__tests__/mesh-submission-lifetime.unit.test.ts

@@ -0,0 +1,53 @@
+import { World } from '@forgeax/engine-ecs';
+import { createBoxGeometry } from '@forgeax/engine-geometry';
+import { rhi } from '@forgeax/engine-rhi-null';
+import { expect, it } from 'vitest';
+import { GpuResidencyCache } from '../device/gpu-residency';
+
+it('fences ordinary mesh submissions independently of candidates, including reversed completion', async () => {
+  const device = (await (await rhi.requestAdapter()).unwrap().requestDevice()).unwrap();
+  const store = new GpuResidencyCache();
+  store.configureGpuDevice(
+    device,
+    undefined,
+    () => {
+      throw new Error('no cubemap');
+    },
+    device.caps,
+  );
+  const world = new World();
+  const mesh = createBoxGeometry(1, 1, 1).unwrap();
+  const handle = world.allocSharedRef('MeshAsset', mesh);
+  store.ensureResident(handle, mesh, world).unwrap();
+  const original = store.getMeshGpuHandles(handle, world);
+  if (original === undefined) throw new Error('mesh residency missing');
+  let finishFirst!: () => void;
+  let finishSecond!: () => void;
+  const first = new Promise<void>((resolve) => {
+    finishFirst = resolve;
+  });
+  const second = new Promise<void>((resolve) => {
+    finishSecond = resolve;
+  });
+  store.trackMeshSubmission(first);
+  store.trackMeshSubmission(second);
+  const lease = store.retainMeshResidency(handle, world);
+  if (lease === undefined) throw new Error('residency lease missing');
+  store.invalidateMesh(handle, world);
+  lease.release(true);
+  expect(original.vertexBuffer.isDestroyed).toBe(false);
+  // The same cache key can upload its replacement before old work completes.
+  store.ensureResident(handle, mesh, world).unwrap();
+  const replacement = store.getMeshGpuHandles(handle, world);
+  if (replacement === undefined) throw new Error('replacement residency missing');
+  expect(replacement).not.toBe(original);
+  finishSecond();
+  await second;
+  expect(original.vertexBuffer.isDestroyed).toBe(false);
+  finishFirst();
+  await first;
+  expect(original.vertexBuffer.isDestroyed).toBe(true);
+  expect(store.getMeshGpuHandles(handle, world)).toBe(replacement);
+  expect(replacement.vertexBuffer.isDestroyed).toBe(false);
+  store.destroyAll();
+});

package/src/__tests__/normal-fallback.dawn.test.ts

@@ -0,0 +1,122 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { createShaderModuleImmediate, rhi } from '@forgeax/engine-rhi-webgpu';
+import { expect, it } from 'vitest';
+import { GPU_SHADER_STAGE_COMPUTE } from '../gpu-stage';
+import {
+  GPU_TEXTURE_USAGE_COPY_DST,
+  GPU_TEXTURE_USAGE_TEXTURE_BINDING,
+} from '../gpu-texture-usage';
+import {
+  GPU_BUFFER_USAGE_COPY_DST,
+  GPU_BUFFER_USAGE_COPY_SRC,
+  GPU_BUFFER_USAGE_MAP_READ,
+  GPU_BUFFER_USAGE_STORAGE,
+} from '../gpu-usage';
+import { FALLBACK_BYTES_PER_ROW } from '../ibl/skylight-bind-group';
+
+it('samples the actual renderer fallback payload as an exactly neutral tangent normal', async () => {
+  const owner = readFileSync(
+    resolve(process.cwd(), 'packages/render/src/assembly/webgpu-ready.ts'),
+    'utf8',
+  );
+  const construction = owner.slice(
+    owner.indexOf('const fallbackNormalTextureResult ='),
+    owner.indexOf('const fallbackNormalTextureViewResult ='),
+  );
+  const format = construction.match(/format: '([^']+)'/)?.[1];
+  if (format !== 'rgba8unorm' && format !== 'rgba16float')
+    throw new Error('Unexpected normal fallback format');
+  const payloadSource = construction.slice(
+    construction.indexOf('const fallbackNormalPixel ='),
+    construction.indexOf('const fallbackNormalWriteResult ='),
+  );
+  const bytes = new Function(
+    'FALLBACK_BYTES_PER_ROW',
+    `${payloadSource}; return fallbackNormalPixel;`,
+  )(FALLBACK_BYTES_PER_ROW) as Uint8Array;
+  const source = readFileSync(
+    resolve(process.cwd(), 'packages/shader/src/tbn.wgsl'),
+    'utf8',
+  ).replace(/^#define_import_path.*$/gm, '');
+  const device = (await (await rhi.requestAdapter()).unwrap().requestDevice()).unwrap();
+  const texture = device
+    .createTexture({
+      size: { width: 1, height: 1, depthOrArrayLayers: 1 },
+      format,
+      textureBindingViewDimension: '2d',
+      usage: GPU_TEXTURE_USAGE_COPY_DST | GPU_TEXTURE_USAGE_TEXTURE_BINDING,
+    })
+    .unwrap();
+  const view = device.createTextureView(texture, {}).unwrap();
+  const sampler = device.createSampler({ minFilter: 'linear', magFilter: 'linear' }).unwrap();
+  const output = device
+    .createBuffer({ size: 16, usage: GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_SRC })
+    .unwrap();
+  const readback = device
+    .createBuffer({ size: 16, usage: GPU_BUFFER_USAGE_MAP_READ | GPU_BUFFER_USAGE_COPY_DST })
+    .unwrap();
+  try {
+    device.queue
+      .writeTexture(
+        { texture, mipLevel: 0, origin: [0, 0, 0] },
+        bytes,
+        { offset: 0, bytesPerRow: FALLBACK_BYTES_PER_ROW, rowsPerImage: 1 },
+        { width: 1, height: 1, depthOrArrayLayers: 1 },
+      )
+      .unwrap();
+    const module = createShaderModuleImmediate(device, {
+      code: `${source}
+@group(0) @binding(0) var normalTexture: texture_2d<f32>;
+@group(0) @binding(1) var normalSampler: sampler;
+@group(0) @binding(2) var<storage, read_write> result: vec4<f32>;
+@compute @workgroup_size(1) fn probe() {
+  let encoded = textureSampleLevel(normalTexture, normalSampler, vec2<f32>(0.37, 0.61), 0.0);
+  result = vec4<f32>(decodeTangentSpaceNormalRg(encoded.rg), encoded.a);
+}`,
+    }).unwrap();
+    const groupLayout = device
+      .createBindGroupLayout({
+        entries: [
+          {
+            binding: 0,
+            visibility: GPU_SHADER_STAGE_COMPUTE,
+            texture: { sampleType: 'float', viewDimension: '2d' },
+          },
+          { binding: 1, visibility: GPU_SHADER_STAGE_COMPUTE, sampler: { type: 'filtering' } },
+          { binding: 2, visibility: GPU_SHADER_STAGE_COMPUTE, buffer: { type: 'storage' } },
+        ],
+      })
+      .unwrap();
+    const layout = device.createPipelineLayout({ bindGroupLayouts: [groupLayout] }).unwrap();
+    const pipeline = device
+      .createComputePipeline({ layout, compute: { module, entryPoint: 'probe' } })
+      .unwrap();
+    const group = device
+      .createBindGroup({
+        layout: groupLayout,
+        entries: [
+          { binding: 0, resource: { kind: 'textureView', value: view } },
+          { binding: 1, resource: { kind: 'sampler', value: sampler } },
+          { binding: 2, resource: { kind: 'buffer', value: { buffer: output } } },
+        ],
+      })
+      .unwrap();
+    const encoder = device.createCommandEncoder().unwrap();
+    const pass = encoder.beginComputePass();
+    pass.setPipeline(pipeline);
+    pass.setBindGroup(0, group);
+    pass.dispatchWorkgroups(1);
+    pass.end();
+    encoder.copyBufferToBuffer(output, 0, readback, 0, 16);
+    device.queue.submit([encoder.finish().unwrap()]).unwrap();
+    const mapped = (await readback.mapAsync(GPU_BUFFER_USAGE_MAP_READ)).unwrap();
+    const result = Array.from(new Float32Array(mapped.getMappedRange().unwrap().slice(0)));
+    mapped.unmap();
+    expect(result).toEqual([0, 0, 1, 1]);
+  } finally {
+    device.destroyTexture(texture).unwrap();
+    device.destroyBuffer(output).unwrap();
+    device.destroyBuffer(readback).unwrap();
+  }
+});