@forgeax/engine-render 0.1.27 → 0.1.29

package/src/__tests__/ssr-graph-topology.unit.test.ts

@@ -0,0 +1,104 @@
+import { RenderGraphBuilder } from '@forgeax/engine-render-graph';
+import type { RhiCommandEncoder } from '@forgeax/engine-rhi';
+import { rhi } from '@forgeax/engine-rhi-null';
+import { describe, expect, it } from 'vitest';
+import { admitSsrSpatial } from '../ssr/admission';
+import { addSsrSpatialPasses } from '../ssr/graph';
+
+type Frame = { readonly encoder: RhiCommandEncoder };
+
+function admittedAdmission() {
+  return 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,
+      },
+    },
+  });
+}
+
+function input(
+  graph: RenderGraphBuilder<Frame>,
+  label: string,
+  format: 'rgba16float' | 'r32float',
+) {
+  const texture = graph.createTexture(label, { format, size: { width: 5, height: 3 } }).unwrap();
+  return graph.view(texture, { label: `${label}.view` }).unwrap();
+}
+
+describe('SSR typed spatial graph', () => {
+  it('declares one ordered graph with per-mip accesses and no synthetic composition passes', async () => {
+    const graph = new RenderGraphBuilder<Frame>();
+    const depth = input(graph, 'scene-depth', 'r32float');
+    const normal = input(graph, 'gbuffer-normal', 'rgba16float');
+    const scene = input(graph, 'scene-color', 'rgba16float');
+    const fallback = input(graph, 'reflection-fallback', 'rgba16float');
+    const currentTemporal = input(graph, 'scene-temporal', 'rgba16float');
+    const initialized = graph.addComputePass('seed-inputs', {
+      accesses: [
+        { resource: depth, usage: 'storage-write' },
+        { resource: normal, usage: 'storage-write' },
+        { resource: scene, usage: 'storage-write' },
+        { resource: fallback, usage: 'storage-write' },
+        { resource: currentTemporal, usage: 'storage-write' },
+      ],
+      encode: () => undefined,
+    });
+    expect(initialized.ok).toBe(true);
+
+    const result = addSsrSpatialPasses(graph, {
+      admission: admittedAdmission(),
+      width: 5,
+      height: 3,
+      depth,
+      normal,
+      scene,
+      fallback,
+      currentTemporal,
+    });
+    expect(result).toMatchObject({ ok: true, value: { enabled: true } });
+    if (!result.ok) return;
+
+    const adapter = (await rhi.requestAdapter()).unwrap();
+    const device = (await adapter.requestDevice()).unwrap();
+    const compiled = graph.compile({ device, surfaceSize: { width: 5, height: 3 } }).unwrap();
+    const info = compiled.inspect();
+    const names = info.passes.map((pass) => pass.name);
+    expect(names).toEqual(['seed-inputs', 'ssr-hiz-seed', 'ssr-hiz-reduce-1', 'ssr-trace']);
+    expect(info.resources.map((resource) => resource.label)).toEqual(
+      expect.arrayContaining(['ssr-hiz', 'ssr-trace', 'ssr-hit-reactivity']),
+    );
+    expect(info.passes.find((pass) => pass.name === 'ssr-trace')?.accesses).toEqual(
+      expect.arrayContaining([
+        { resource: 'scene-temporal', usage: 'sampled-read' },
+        { resource: 'ssr-hit-reactivity', usage: 'storage-write' },
+      ]),
+    );
+    expect(info.passes.find((pass) => pass.name === 'ssr-hiz-reduce-1')?.accesses).toEqual([
+      { resource: 'ssr-hiz', usage: 'sampled-read' },
+      { resource: 'ssr-hiz', usage: 'storage-write' },
+    ]);
+    expect(
+      info.resources.find((resource) => resource.label === 'ssr-hiz')?.descriptor,
+    ).toMatchObject({
+      format: 'r32float',
+      mipLevelCount: 2,
+    });
+    expect(names.indexOf('ssr-hiz-seed')).toBeLessThan(names.indexOf('ssr-trace'));
+    await compiled.retire();
+  });
+});

package/src/__tests__/ssr-history-filter.dawn.test.ts

@@ -0,0 +1,198 @@
+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,
+  GPU_BUFFER_USAGE_UNIFORM,
+} from '../gpu-usage';
+
+it.each([
+  'plane',
+  'depth-edge',
+  'normal-edge',
+  'missing',
+  'partial-miss',
+  'confidence',
+] as const)('reconstructs subpixel SSR history without borrowing incompatible receivers (%s)', async (kind) => {
+  const compiler = await import(
+    /* @vite-ignore */ new URL('../../../shader-compiler/dist/index.mjs', import.meta.url).href
+  );
+  const source = readFileSync(resolve('packages/shader/src/ssr-temporal.wgsl'), 'utf8');
+  expect(source).toContain('sampleSsrHistory(historyUv, fullSize, priorClip.w, normal)');
+  const compiled = await compiler.compileShader(
+    `${source}
+@group(1) @binding(0) var<storage, read_write> result: array<vec4<f32>>;
+@compute @workgroup_size(1) fn probe_history() {
+  // Half-resolution history centers are full pixels 0.5 and 2.5. A
+  // half-full-pixel jitter change is a quarter-history-pixel displacement.
+  let coordinates = array<vec2<f32>, 5>(vec2<f32>(0.125), vec2<f32>(0.25, 0.125),
+    vec2<f32>(0.375), vec2<f32>(0.5, 0.125), vec2<f32>(0.625));
+  for (var i = 0u; i < 5u; i++) {
+    result[i] = sampleSsrHistory(coordinates[i], vec2<u32>(4u), 4.0, vec3<f32>(0.0, 0.0, 1.0));
+  }
+}`,
+    {
+      id: 'forgeax_ssr::temporal',
+      imports: {
+        'forgeax_view::common': readFileSync(resolve('packages/shader/src/common.wgsl'), 'utf8'),
+      },
+    },
+  );
+  if (!compiled.ok) throw compiled.error;
+  const device = (await (await rhi.requestAdapter()).unwrap().requestDevice()).unwrap();
+  const texture = () =>
+    device
+      .createTexture({
+        size: { width: 2, height: 2, depthOrArrayLayers: 1 },
+        format: 'rgba32float',
+        textureBindingViewDimension: '2d',
+        usage: GPU_TEXTURE_USAGE_COPY_DST | GPU_TEXTURE_USAGE_TEXTURE_BINDING,
+      })
+      .unwrap();
+  const history = texture(),
+    surface = texture();
+  const params = device
+    .createBuffer({ size: 32, usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST })
+    .unwrap();
+  const output = device
+    .createBuffer({ size: 80, usage: GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_SRC })
+    .unwrap();
+  const readback = device
+    .createBuffer({ size: 80, usage: GPU_BUFFER_USAGE_MAP_READ | GPU_BUFFER_USAGE_COPY_DST })
+    .unwrap();
+  try {
+    const upload = (target: typeof history, data: number[]) =>
+      device.queue
+        .writeTexture(
+          { texture: target },
+          new Float32Array(data),
+          { bytesPerRow: 32, rowsPerImage: 2 },
+          { width: 2, height: 2, depthOrArrayLayers: 1 },
+        )
+        .unwrap();
+    // Independent linear radiance field C(x,y)=(2+4x,4y,1), with x/y in history pixels.
+    upload(
+      history,
+      [0, 1, 2, 3].flatMap((i) => [
+        2 + 4 * (i % 2),
+        4 * Math.floor(i / 2),
+        1,
+        kind === 'depth-edge' && i % 2 === 1 ? 8 : 4,
+      ]),
+    );
+    upload(
+      surface,
+      [0, 1, 2, 3].flatMap((i) => [
+        0.5,
+        0.5,
+        kind === 'normal-edge' && i % 2 === 1 ? 0 : 1,
+        kind === 'missing'
+          ? 0
+          : kind === 'partial-miss'
+            ? i % 2 === 0
+              ? 1
+              : 0
+            : kind === 'confidence'
+              ? i % 2 === 0
+                ? 0.25
+                : 0.75
+              : 1,
+      ]),
+    );
+    device.queue.writeBuffer(params, 0, new Float32Array([1, 0.9, 0.02, 0.9, 0, 0, 0, 0])).unwrap();
+    const inputs = device
+      .createBindGroupLayout({
+        entries: [
+          ...[3, 9].map((binding) => ({
+            binding,
+            visibility: GPU_SHADER_STAGE_COMPUTE,
+            texture: { sampleType: 'unfilterable-float' as const, viewDimension: '2d' as const },
+          })),
+          { binding: 6, visibility: GPU_SHADER_STAGE_COMPUTE, buffer: { type: 'uniform' } },
+        ],
+      })
+      .unwrap();
+    const outputs = device
+      .createBindGroupLayout({
+        entries: [
+          { binding: 0, visibility: GPU_SHADER_STAGE_COMPUTE, buffer: { type: 'storage' } },
+        ],
+      })
+      .unwrap();
+    const module = createShaderModuleImmediate(device, { code: compiled.value.wgsl }).unwrap();
+    const pipeline = device
+      .createComputePipeline({
+        layout: device.createPipelineLayout({ bindGroupLayouts: [inputs, outputs] }).unwrap(),
+        compute: { module, entryPoint: 'probe_history' },
+      })
+      .unwrap();
+    const input = device
+      .createBindGroup({
+        layout: inputs,
+        entries: [
+          {
+            binding: 3,
+            resource: {
+              kind: 'textureView',
+              value: device.createTextureView(history, {}).unwrap(),
+            },
+          },
+          {
+            binding: 9,
+            resource: {
+              kind: 'textureView',
+              value: device.createTextureView(surface, {}).unwrap(),
+            },
+          },
+          { binding: 6, resource: { kind: 'buffer', value: { buffer: params } } },
+        ],
+      })
+      .unwrap();
+    const result = device
+      .createBindGroup({
+        layout: outputs,
+        entries: [{ binding: 0, resource: { kind: 'buffer', value: { buffer: output } } }],
+      })
+      .unwrap();
+    const encoder = device.createCommandEncoder().unwrap();
+    const pass = encoder.beginComputePass();
+    pass.setPipeline(pipeline);
+    pass.setBindGroup(0, input);
+    pass.setBindGroup(1, result);
+    pass.dispatchWorkgroups(1);
+    pass.end();
+    encoder.copyBufferToBuffer(output, 0, readback, 0, 80);
+    device.queue.submit([encoder.finish().unwrap()]).unwrap();
+    const mapped = (await readback.mapAsync(GPU_BUFFER_USAGE_MAP_READ)).unwrap();
+    const values = [...new Float32Array(mapped.getMappedRange().unwrap().slice(0))];
+    mapped.unmap();
+    const expected =
+      kind === 'plane'
+        ? [2, 0, 1, 1, 3, 0, 1, 1, 4, 2, 1, 1, 5, 0, 1, 1, 6, 4, 1, 1]
+        : kind === 'confidence'
+          ? [2, 0, 1, 0.25, 4, 0, 1, 0.375, 5, 2, 1, 0.5, 5.6, 0, 1, 0.625, 6, 4, 1, 0.75]
+          : kind === 'missing'
+            ? Array(20).fill(0)
+            : [2, 0, 1, 1, 2, 0, 1, 0.75, 2, 2, 1, 0.5, 2, 0, 1, 0.25, 0, 0, 0, 0];
+    values.forEach((value, index) => {
+      const target = expected[index];
+      if (target === undefined) throw new Error(`Unexpected output lane ${index}`);
+      expect(value, `${kind} lane ${index}`).toBeCloseTo(target, 5);
+    });
+  } finally {
+    device.destroyTexture(history).unwrap();
+    device.destroyTexture(surface).unwrap();
+    device.destroyBuffer(params).unwrap();
+    device.destroyBuffer(output).unwrap();
+    device.destroyBuffer(readback).unwrap();
+  }
+});

package/src/__tests__/ssr-hit-color.dawn.test.ts

@@ -0,0 +1,273 @@
+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';
+
+it.each([
+  'covered',
+  'silhouette',
+  'backface',
+  'uncovered',
+] as const)('retains subpixel HDR radiance and source coverage at the production SSR hit sampler (%s)', async (coverageCase) => {
+  const compiler = await import(
+    /* @vite-ignore */ new URL('../../../shader-compiler/dist/index.mjs', import.meta.url).href
+  );
+  const source = readFileSync(resolve('packages/shader/src/ssr-trace.wgsl'), 'utf8');
+  expect(source).toContain(
+    'let hitSample = sampleSsrHitSample(hitResult.uv, reflectionDirection);',
+  );
+  expect(source).toContain('max(hitResult.reactivity, hitSample.reactivity)');
+  const compiled = await compiler.compileShader(
+    `${source}
+@group(1) @binding(0) var<storage, read_write> colors: array<vec4<f32>>;
+@compute @workgroup_size(1) fn probe_color() {
+  let uvs = array<vec2<f32>, 6>(vec2<f32>(0.5), vec2<f32>(0.49, 0.25), vec2<f32>(0.51, 0.25), vec2<f32>(0.0), vec2<f32>(1.0), vec2<f32>(0.25, 0.75));
+  for (var i = 0u; i < 6u; i++) {
+    let sample = sampleSsrHitSample(uvs[i], vec3<f32>(0.0, 0.0, -1.0));
+    colors[i] = sample.color;
+    colors[6u + i] = vec4<f32>(sample.reactivity);
+  }
+}`,
+    {
+      id: 'forgeax_ssr::trace',
+      imports: {
+        'forgeax_view::common': readFileSync(resolve('packages/shader/src/common.wgsl'), 'utf8'),
+      },
+    },
+  );
+  if (!compiled.ok) throw compiled.error;
+  const device = (await (await rhi.requestAdapter()).unwrap().requestDevice()).unwrap();
+  const color = device
+    .createTexture({
+      size: { width: 2, height: 2, depthOrArrayLayers: 1 },
+      format: 'rgba32float',
+      textureBindingViewDimension: '2d',
+      usage: GPU_TEXTURE_USAGE_COPY_DST | GPU_TEXTURE_USAGE_TEXTURE_BINDING,
+    })
+    .unwrap();
+  const output = device
+    .createBuffer({ size: 192, usage: GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_SRC })
+    .unwrap();
+  const coverage = device
+    .createTexture({
+      size: { width: 2, height: 2, depthOrArrayLayers: 1 },
+      format: 'rgba32float',
+      textureBindingViewDimension: '2d',
+      usage: GPU_TEXTURE_USAGE_COPY_DST | GPU_TEXTURE_USAGE_TEXTURE_BINDING,
+    })
+    .unwrap();
+  const normals = device
+    .createTexture({
+      size: { width: 2, height: 2, depthOrArrayLayers: 1 },
+      format: 'rgba32float',
+      textureBindingViewDimension: '2d',
+      usage: GPU_TEXTURE_USAGE_COPY_DST | GPU_TEXTURE_USAGE_TEXTURE_BINDING,
+    })
+    .unwrap();
+  const readback = device
+    .createBuffer({ size: 192, usage: GPU_BUFFER_USAGE_MAP_READ | GPU_BUFFER_USAGE_COPY_DST })
+    .unwrap();
+  const temporal = device
+    .createTexture({
+      size: { width: 2, height: 2, depthOrArrayLayers: 1 },
+      format: 'rgba32float',
+      textureBindingViewDimension: '2d',
+      usage: GPU_TEXTURE_USAGE_COPY_DST | GPU_TEXTURE_USAGE_TEXTURE_BINDING,
+    })
+    .unwrap();
+  try {
+    device.queue
+      .writeTexture(
+        { texture: temporal },
+        new Float32Array([1 / 128, 0, 2, 0, 0, 0, 2, 0.75, 0, 0, 2, 0, 0, 0, 2, 0]),
+        { bytesPerRow: 32, rowsPerImage: 2 },
+        { width: 2, height: 2, depthOrArrayLayers: 1 },
+      )
+      .unwrap();
+    device.queue
+      .writeTexture(
+        { texture: normals },
+        new Float32Array(
+          Array.from({ length: 4 }, (_, i) => [
+            0.5,
+            0.5,
+            coverageCase === 'backface' && i % 2 === 1 ? 0 : 1,
+            1,
+          ]).flat(),
+        ),
+        { bytesPerRow: 32, rowsPerImage: 2 },
+        { width: 2, height: 2, depthOrArrayLayers: 1 },
+      )
+      .unwrap();
+    const coverageValues =
+      coverageCase === 'covered' || coverageCase === 'backface'
+        ? [1, 1, 1, 1]
+        : coverageCase === 'silhouette'
+          ? [1, 0, 1, 0]
+          : [0, 0, 0, 0];
+    device.queue
+      .writeTexture(
+        { texture: coverage },
+        new Float32Array(coverageValues.flatMap((alpha) => [0, 0, 0, alpha])),
+        { bytesPerRow: 32, rowsPerImage: 2 },
+        { width: 2, height: 2, depthOrArrayLayers: 1 },
+      )
+      .unwrap();
+    device.queue
+      .writeTexture(
+        { texture: color },
+        new Float32Array([4, 0, 0, 1, 0, 2, 0, 1, 0, 0, 8, 1, 1, 1, 1, 1]),
+        { bytesPerRow: 32, rowsPerImage: 2 },
+        { width: 2, height: 2, depthOrArrayLayers: 1 },
+      )
+      .unwrap();
+    const inputs = device
+      .createBindGroupLayout({
+        entries: [
+          {
+            binding: 7,
+            visibility: GPU_SHADER_STAGE_COMPUTE,
+            texture: { sampleType: 'unfilterable-float', viewDimension: '2d' },
+          },
+          {
+            binding: 1,
+            visibility: GPU_SHADER_STAGE_COMPUTE,
+            texture: { sampleType: 'unfilterable-float', viewDimension: '2d' },
+          },
+          {
+            binding: 2,
+            visibility: GPU_SHADER_STAGE_COMPUTE,
+            texture: { sampleType: 'unfilterable-float', viewDimension: '2d' },
+          },
+          {
+            binding: 6,
+            visibility: GPU_SHADER_STAGE_COMPUTE,
+            texture: { sampleType: 'unfilterable-float', viewDimension: '2d' },
+          },
+        ],
+      })
+      .unwrap();
+    const outputs = device
+      .createBindGroupLayout({
+        entries: [
+          {
+            binding: 0,
+            visibility: GPU_SHADER_STAGE_COMPUTE,
+            buffer: { type: 'storage' },
+          },
+        ],
+      })
+      .unwrap();
+    const module = createShaderModuleImmediate(device, { code: compiled.value.wgsl }).unwrap();
+    const pipeline = device
+      .createComputePipeline({
+        layout: device.createPipelineLayout({ bindGroupLayouts: [inputs, outputs] }).unwrap(),
+        compute: { module, entryPoint: 'probe_color' },
+      })
+      .unwrap();
+    const input = device
+      .createBindGroup({
+        layout: inputs,
+        entries: [
+          {
+            binding: 7,
+            resource: {
+              kind: 'textureView',
+              value: device.createTextureView(temporal, {}).unwrap(),
+            },
+          },
+          {
+            binding: 2,
+            resource: { kind: 'textureView', value: device.createTextureView(color, {}).unwrap() },
+          },
+          {
+            binding: 1,
+            resource: {
+              kind: 'textureView',
+              value: device.createTextureView(normals, {}).unwrap(),
+            },
+          },
+          {
+            binding: 6,
+            resource: {
+              kind: 'textureView',
+              value: device.createTextureView(coverage, {}).unwrap(),
+            },
+          },
+        ],
+      })
+      .unwrap();
+    const result = device
+      .createBindGroup({
+        layout: outputs,
+        entries: [
+          {
+            binding: 0,
+            resource: { kind: 'buffer', value: { buffer: output } },
+          },
+        ],
+      })
+      .unwrap();
+    const encoder = device.createCommandEncoder().unwrap();
+    const pass = encoder.beginComputePass();
+    pass.setPipeline(pipeline);
+    pass.setBindGroup(0, input);
+    pass.setBindGroup(1, result);
+    pass.dispatchWorkgroups(1);
+    pass.end();
+    encoder.copyBufferToBuffer(output, 0, readback, 0, 192);
+    device.queue.submit([encoder.finish().unwrap()]).unwrap();
+    const mapped = (await readback.mapAsync(GPU_BUFFER_USAGE_MAP_READ)).unwrap();
+    const values = new Float32Array(mapped.getMappedRange().unwrap().slice(0));
+    mapped.unmap();
+    const reactive = Array.from({ length: 6 }, (_, i) => values[(6 + i) * 4]);
+    expect(reactive, 'only admitted color taps may invalidate reflection history').toEqual(
+      coverageCase === 'uncovered'
+        ? [0, 0, 0, 0, 0, 0]
+        : coverageCase === 'covered'
+          ? [0.75, 0.75, 0.75, 0.5, 0, 0]
+          : [0.5, 0.5, 0.5, 0.5, 0, 0],
+    );
+    if (coverageCase === 'uncovered') {
+      expect([...values], 'sky is not a covered reflection source').toEqual(Array(48).fill(0));
+      return;
+    }
+    if (coverageCase === 'silhouette' || coverageCase === 'backface') {
+      expect([...values.slice(0, 4)], 'only the covered red/blue column contributes').toEqual([
+        2, 0, 4, 0.5,
+      ]);
+      expect(values[4]).toBeCloseTo(4, 5);
+      expect(values[7]).toBeCloseTo(0.52, 5);
+      expect(values[8]).toBeCloseTo(4, 5);
+      expect(values[11]).toBeCloseTo(0.48, 5);
+      expect([...values.slice(12, 16)]).toEqual([4, 0, 0, 1]);
+      expect([...values.slice(16, 20)]).toEqual([0, 0, 0, 0]);
+      expect([...values.slice(20, 24)]).toEqual([0, 0, 8, 1]);
+      return;
+    }
+    expect([...values.slice(0, 4)], 'four-texel HDR interpolation').toEqual([1.25, 0.75, 2.25, 1]);
+    expect(values[4]).toBeCloseTo(2.08, 5);
+    expect(values[8]).toBeCloseTo(1.92, 5);
+    expect([...values.slice(12, 16)], 'clamped upper-left edge').toEqual([4, 0, 0, 1]);
+    expect([...values.slice(16, 20)], 'clamped lower-right edge').toEqual([1, 1, 1, 1]);
+    expect([...values.slice(20, 24)], 'exact texel center').toEqual([0, 0, 8, 1]);
+  } finally {
+    device.destroyTexture(color).unwrap();
+    device.destroyTexture(coverage).unwrap();
+    device.destroyTexture(normals).unwrap();
+    device.destroyTexture(temporal).unwrap();
+    device.destroyBuffer(output).unwrap();
+    device.destroyBuffer(readback).unwrap();
+  }
+});