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];
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':
{
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}]);
}`,
}),
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':
{
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 }) => {
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':
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':
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
);
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();
