| export const description = ` |
| Test the result of writing textures through texture views with various options. |
| |
| Reads value from a shader array, writes the value via various write methods. |
| Check the texture result with the expected texel view. |
| |
| All x= every possible view write method: { |
| - storage write {fragment, compute} |
| - render pass store |
| - render pass resolve |
| } |
| |
| Format reinterpretation is not tested here. It is in format_reinterpretation.spec.ts. |
| |
| TODO: Write helper for this if not already available (see resource_init, buffer_sync_test for related code). |
| `; |
| |
| import { makeTestGroup } from '../../../../common/framework/test_group.js'; |
| import { unreachable } from '../../../../common/util/util.js'; |
| import { |
| getTextureFormatType, |
| kRegularTextureFormats, |
| RegularTextureFormat, |
| } from '../../../format_info.js'; |
| import { AllFeaturesMaxLimitsGPUTest, GPUTest } from '../../../gpu_test.js'; |
| import * as ttu from '../../../texture_test_utils.js'; |
| import { kFullscreenQuadVertexShaderCode } from '../../../util/shader.js'; |
| import { TexelView } from '../../../util/texture/texel_view.js'; |
| |
| export const g = makeTestGroup(AllFeaturesMaxLimitsGPUTest); |
| |
| const kTextureViewWriteMethods = [ |
| 'storage-write-fragment', |
| 'storage-write-compute', |
| 'render-pass-store', |
| 'render-pass-resolve', |
| ] as const; |
| type TextureViewWriteMethod = (typeof kTextureViewWriteMethods)[number]; |
| |
| const kTextureViewUsageMethods = ['inherit', 'minimal'] as const; |
| type TextureViewUsageMethod = (typeof kTextureViewUsageMethods)[number]; |
| |
| // Src color values to read from a shader array. |
| const kColorsFloat = [ |
| { R: 1.0, G: 0.0, B: 0.0, A: 0.8 }, |
| { R: 0.0, G: 1.0, B: 0.0, A: 0.7 }, |
| { R: 0.0, G: 0.0, B: 0.0, A: 0.6 }, |
| { R: 0.0, G: 0.0, B: 0.0, A: 0.5 }, |
| { R: 1.0, G: 1.0, B: 1.0, A: 0.4 }, |
| { R: 0.7, G: 0.0, B: 0.0, A: 0.3 }, |
| { R: 0.0, G: 0.8, B: 0.0, A: 0.2 }, |
| { R: 0.0, G: 0.0, B: 0.9, A: 0.1 }, |
| { R: 0.1, G: 0.2, B: 0.0, A: 0.3 }, |
| { R: 0.4, G: 0.3, B: 0.6, A: 0.8 }, |
| ]; |
| |
| function floatToIntColor(c: number) { |
| return Math.floor(c * 100); |
| } |
| |
| const kColorsInt = kColorsFloat.map(c => { |
| return { |
| R: floatToIntColor(c.R), |
| G: floatToIntColor(c.G), |
| B: floatToIntColor(c.B), |
| A: floatToIntColor(c.A), |
| }; |
| }); |
| |
| const kTextureSize = 16; |
| |
| function writeTextureAndGetExpectedTexelView( |
| t: GPUTest, |
| method: TextureViewWriteMethod, |
| view: GPUTextureView, |
| format: RegularTextureFormat, |
| sampleCount: number |
| ) { |
| const type = getTextureFormatType(format); |
| const isFloatType = type === 'float' || type === 'unfilterable-float'; |
| const kColors = isFloatType ? kColorsFloat : kColorsInt; |
| const expectedTexelView = TexelView.fromTexelsAsColors( |
| format, |
| coords => { |
| const pixelPos = coords.y * kTextureSize + coords.x; |
| return kColors[pixelPos % kColors.length]; |
| }, |
| { clampToFormatRange: true } |
| ); |
| const vecType = isFloatType ? 'vec4f' : type === 'sint' ? 'vec4i' : 'vec4u'; |
| const kColorArrayShaderString = `array<${vecType}, ${kColors.length}>( |
| ${kColors.map(t => `${vecType}(${t.R}, ${t.G}, ${t.B}, ${t.A}) `).join(',')} |
| )`; |
| |
| switch (method) { |
| case 'storage-write-compute': |
| { |
| const pipeline = t.device.createComputePipeline({ |
| layout: 'auto', |
| compute: { |
| module: t.device.createShaderModule({ |
| code: ` |
| @group(0) @binding(0) var dst: texture_storage_2d<${format}, write>; |
| @compute @workgroup_size(1, 1) fn main( |
| @builtin(global_invocation_id) global_id: vec3<u32>, |
| ) { |
| const src = ${kColorArrayShaderString}; |
| let coord = vec2u(global_id.xy); |
| let idx = coord.x + coord.y * ${kTextureSize}; |
| textureStore(dst, coord, src[idx % ${kColors.length}]); |
| }`, |
| }), |
| entryPoint: 'main', |
| }, |
| }); |
| const commandEncoder = t.device.createCommandEncoder(); |
| const pass = commandEncoder.beginComputePass(); |
| pass.setPipeline(pipeline); |
| pass.setBindGroup( |
| 0, |
| t.device.createBindGroup({ |
| layout: pipeline.getBindGroupLayout(0), |
| entries: [ |
| { |
| binding: 0, |
| resource: view, |
| }, |
| ], |
| }) |
| ); |
| pass.dispatchWorkgroups(kTextureSize, kTextureSize); |
| pass.end(); |
| t.device.queue.submit([commandEncoder.finish()]); |
| } |
| break; |
| |
| case 'storage-write-fragment': |
| { |
| // Create a placeholder color attachment texture, |
| // The size of which equals that of format texture we are testing, |
| // so that we have the same number of fragments and texels. |
| const kPlaceholderTextureFormat = 'rgba8unorm'; |
| const placeholderTexture = t.createTextureTracked({ |
| format: kPlaceholderTextureFormat, |
| size: [kTextureSize, kTextureSize], |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| |
| const pipeline = t.device.createRenderPipeline({ |
| layout: 'auto', |
| vertex: { |
| module: t.device.createShaderModule({ |
| code: kFullscreenQuadVertexShaderCode, |
| }), |
| }, |
| fragment: { |
| module: t.device.createShaderModule({ |
| code: ` |
| @group(0) @binding(0) var dst: texture_storage_2d<${format}, write>; |
| @fragment fn main( |
| @builtin(position) fragCoord: vec4<f32>, |
| ) { |
| const src = ${kColorArrayShaderString}; |
| let coord = vec2u(fragCoord.xy); |
| let idx = coord.x + coord.y * ${kTextureSize}; |
| textureStore(dst, coord, src[idx % ${kColors.length}]); |
| }`, |
| }), |
| // Set writeMask to 0 as the fragment shader has no output. |
| targets: [ |
| { |
| format: kPlaceholderTextureFormat, |
| writeMask: 0, |
| }, |
| ], |
| }, |
| }); |
| const commandEncoder = t.device.createCommandEncoder(); |
| const pass = commandEncoder.beginRenderPass({ |
| colorAttachments: [ |
| { |
| view: placeholderTexture.createView(), |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }, |
| ], |
| }); |
| pass.setPipeline(pipeline); |
| pass.setBindGroup( |
| 0, |
| t.device.createBindGroup({ |
| layout: pipeline.getBindGroupLayout(0), |
| entries: [ |
| { |
| binding: 0, |
| resource: view, |
| }, |
| ], |
| }) |
| ); |
| pass.draw(6); |
| pass.end(); |
| t.device.queue.submit([commandEncoder.finish()]); |
| } |
| break; |
| |
| case 'render-pass-store': |
| case 'render-pass-resolve': |
| { |
| // Create a placeholder color attachment texture for the store target when tesing texture is used as resolve target. |
| const targetView = |
| method === 'render-pass-store' |
| ? view |
| : t |
| .createTextureTracked({ |
| format, |
| size: [kTextureSize, kTextureSize], |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| sampleCount: 4, |
| }) |
| .createView(); |
| const resolveView = method === 'render-pass-store' ? undefined : view; |
| const multisampleCount = method === 'render-pass-store' ? sampleCount : 4; |
| |
| const pipeline = t.device.createRenderPipeline({ |
| layout: 'auto', |
| vertex: { |
| module: t.device.createShaderModule({ |
| code: kFullscreenQuadVertexShaderCode, |
| }), |
| }, |
| fragment: { |
| module: t.device.createShaderModule({ |
| code: ` |
| @fragment fn main( |
| @builtin(position) fragCoord: vec4<f32>, |
| ) -> @location(0) ${vecType} { |
| const src = ${kColorArrayShaderString}; |
| let coord = vec2u(fragCoord.xy); |
| let idx = coord.x + coord.y * ${kTextureSize}; |
| return src[idx % ${kColors.length}]; |
| }`, |
| }), |
| targets: [ |
| { |
| format, |
| }, |
| ], |
| }, |
| multisample: { |
| count: multisampleCount, |
| }, |
| }); |
| const commandEncoder = t.device.createCommandEncoder(); |
| const pass = commandEncoder.beginRenderPass({ |
| colorAttachments: [ |
| { |
| view: targetView, |
| resolveTarget: resolveView, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }, |
| ], |
| }); |
| pass.setPipeline(pipeline); |
| pass.draw(6); |
| pass.end(); |
| t.device.queue.submit([commandEncoder.finish()]); |
| } |
| break; |
| default: |
| unreachable(); |
| } |
| |
| return expectedTexelView; |
| } |
| |
| function getTextureViewUsage( |
| viewUsageMethod: TextureViewUsageMethod, |
| minimalUsageForTest: GPUTextureUsageFlags |
| ) { |
| switch (viewUsageMethod) { |
| case 'inherit': |
| return 0; |
| |
| case 'minimal': |
| return minimalUsageForTest; |
| |
| default: |
| unreachable(); |
| } |
| } |
| |
| g.test('format') |
| .desc( |
| `Views of every allowed format. |
| |
| Read values from color array in the shader, and write it to the texture view via different write methods. |
| |
| - x= every texture format |
| - x= sampleCount {1, 4} if valid |
| - x= every possible view write method (see above) |
| - x= inherited or minimal texture view usage |
| |
| TODO: Test sampleCount > 1 for 'render-pass-store' after extending copySinglePixelTextureToBufferUsingComputePass |
| to read multiple pixels from multisampled textures. [1] |
| TODO: Test rgb10a2uint when TexelRepresentation.numericRange is made per-component. [2] |
| ` |
| ) |
| .params(u => |
| u // |
| .combine('method', kTextureViewWriteMethods) |
| .combine('format', kRegularTextureFormats) |
| .combine('sampleCount', [1, 4]) |
| .filter(({ format, method, sampleCount }) => { |
| // [2] |
| if (format === 'rgb10a2uint') { |
| return false; |
| } |
| |
| switch (method) { |
| case 'storage-write-compute': |
| case 'storage-write-fragment': |
| return sampleCount === 1; |
| case 'render-pass-resolve': |
| return sampleCount === 1; |
| case 'render-pass-store': |
| // [1] |
| if (sampleCount > 1) { |
| return false; |
| } |
| break; |
| } |
| |
| return true; |
| }) |
| .combine('viewUsageMethod', kTextureViewUsageMethods) |
| ) |
| .fn(t => { |
| const { format, method, sampleCount, viewUsageMethod } = t.params; |
| t.skipIfTextureFormatNotSupported(format); |
| if (sampleCount > 1) { |
| t.skipIfTextureFormatNotMultisampled(format); |
| } |
| |
| switch (method) { |
| case 'storage-write-compute': |
| case 'storage-write-fragment': |
| t.skipIfTextureFormatNotUsableWithStorageAccessMode('write-only', format); |
| break; |
| case 'render-pass-store': |
| t.skipIfTextureFormatNotUsableAsRenderAttachment(format); |
| break; |
| case 'render-pass-resolve': |
| // Requires multisample in `writeTextureAndGetExpectedTexelView` |
| t.skipIfTextureFormatNotUsableAsRenderAttachment(format); |
| t.skipIfTextureFormatNotResolvable(format); |
| break; |
| } |
| |
| t.skipIf( |
| t.isCompatibility && |
| method === 'storage-write-fragment' && |
| !(t.device.limits.maxStorageBuffersInFragmentStage! > 0), |
| `maxStorageBuffersInFragmentStage(${t.device.limits.maxStorageBuffersInFragmentStage}) < 1` |
| ); |
| |
| const textureUsageForMethod = method.includes('storage') |
| ? GPUTextureUsage.STORAGE_BINDING |
| : GPUTextureUsage.RENDER_ATTACHMENT; |
| const usage = GPUTextureUsage.COPY_SRC | textureUsageForMethod; |
| |
| const texture = t.createTextureTracked({ |
| format, |
| usage, |
| size: [kTextureSize, kTextureSize], |
| sampleCount, |
| }); |
| |
| const view = texture.createView({ |
| usage: getTextureViewUsage(viewUsageMethod, textureUsageForMethod), |
| }); |
| const expectedTexelView = writeTextureAndGetExpectedTexelView( |
| t, |
| method, |
| view, |
| format, |
| sampleCount |
| ); |
| |
| // [1] Use copySinglePixelTextureToBufferUsingComputePass to check multisampled texture. |
| ttu.expectTexelViewComparisonIsOkInTexture(t, { texture }, expectedTexelView, [ |
| kTextureSize, |
| kTextureSize, |
| ]); |
| }); |
| |
| g.test('dimension') |
| .desc( |
| `Views of every allowed dimension. |
| |
| - x= a representative subset of formats |
| - x= {every texture dimension} x {every valid view dimension} |
| (per gpuweb#79 no dimension-count reinterpretations, like 2d-array <-> 3d, are possible) |
| - x= sampleCount {1, 4} if valid |
| - x= every possible view write method (see above) |
| ` |
| ) |
| .unimplemented(); |
| |
| g.test('aspect') |
| .desc( |
| `Views of every allowed aspect of depth/stencil textures. |
| |
| - x= every depth/stencil format |
| - x= {"all", "stencil-only", "depth-only"} where valid for the format |
| - x= sampleCount {1, 4} if valid |
| - x= every possible view write method (see above) |
| ` |
| ) |
| .unimplemented(); |
