| <!DOCTYPE html> |
| <meta charset="utf-8"> |
| <title>WebGPU Hello Triangles</title> |
| <meta name="assert" content="WebGPU correctly renders a green canvas."> |
| <link rel="match" href="buffer-resource-triangles-expected.html"> |
| <p>Pass if square canvas below is completely green.</p> |
| <canvas width="400" height="400"></canvas> |
| <script src="js/webgpu-functions.js"></script> |
| <script> |
| if (window.testRunner) |
| testRunner.waitUntilDone(); |
| |
| const shaderCode = ` |
| #include <metal_stdlib> |
| |
| using namespace metal; |
| |
| struct VertexInput { |
| float4 position [[attribute(0)]]; |
| }; |
| |
| struct Vertex { |
| float4 position [[position]]; |
| }; |
| |
| struct VertexArguments { |
| device Vertex* v0; |
| device Vertex* v1; |
| device Vertex* v2; |
| }; |
| |
| vertex Vertex vertex_main( |
| VertexInput input [[stage_in]], |
| const device VertexArguments& args0 [[buffer(0)]], |
| const device VertexArguments& args1 [[buffer(1)]], |
| uint vid [[vertex_id]]) |
| { |
| switch (vid) |
| { |
| case 0: |
| case 1: |
| case 2: { |
| Vertex out; |
| out.position = input.position; |
| return out; |
| } |
| case 3: return *args0.v0; |
| case 4: return *args0.v1; |
| case 5: return *args0.v2; |
| case 6: return *args1.v0; |
| case 7: return *args1.v1; |
| default: return *args1.v2; |
| } |
| } |
| |
| struct FragmentArguments { |
| device float4* color; |
| }; |
| |
| fragment float4 fragment_main(const device FragmentArguments& args [[buffer(0)]]) |
| { |
| return args.color[0]; |
| } |
| ` |
| |
| const bindingNums = { |
| UL: 0, |
| UM: 1, |
| UR: 2, |
| LL: 3, |
| LR: 4, |
| G: 5 |
| }; |
| |
| function createUniformBufferBindGroupLayout(bindNum, stage = GPUShaderStageBit.VERTEX) { |
| return { |
| binding: bindNum, |
| visibility: stage, |
| type: "uniform-buffer" |
| }; |
| } |
| |
| const vertexSize = 4 * 4; |
| function createAndUploadVerticesBuffer(device) { |
| const vertexArray = new Float32Array([ |
| 0, 1, 0, 1, |
| -1, -1, 0, 1, |
| 1, -1, 0, 1 |
| ]); |
| return createBufferWithData(device, { size: vertexArray.byteLength, usage: GPUBufferUsage.VERTEX }, vertexArray.buffer); |
| } |
| |
| function createFloat4Buffer(device, a, b, promises) { |
| const buffer = device.createBuffer({ size: vertexSize, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.MAP_WRITE }); |
| |
| const promise = buffer.mapWriteAsync().then(mapping => { |
| const mappedArray = new Float32Array(mapping); |
| mappedArray.set([a, b, 0, 1]); |
| buffer.unmap(); |
| }); |
| |
| promises.push(promise); |
| return buffer; |
| } |
| |
| function createBufferBinding(buffer) { |
| return { buffer: buffer, size: vertexSize }; |
| } |
| |
| async function test() { |
| const device = await getBasicDevice(); |
| const canvas = document.querySelector("canvas"); |
| const swapChain = createBasicSwapChain(canvas, device); |
| // FIXME: Replace with non-MSL shaders. |
| const shaderModule = device.createShaderModule({ code: shaderCode }); |
| |
| // Create vertex data GPUBuffers. |
| const verticesBuffer = createAndUploadVerticesBuffer(device); |
| |
| let bufferPromises = []; |
| const upperLeft = createFloat4Buffer(device, -1, 1, bufferPromises); |
| const upperMiddle = createFloat4Buffer(device, 0, 1, bufferPromises); |
| const upperRight = createFloat4Buffer(device, 1, 1, bufferPromises); |
| const lowerLeft = createFloat4Buffer(device, -1, -1, bufferPromises); |
| const lowerRight = createFloat4Buffer(device, 1, -1, bufferPromises); |
| |
| // Color data buffer. |
| const green = createFloat4Buffer(device, 0, 1, bufferPromises); |
| |
| // Create vertex input state. |
| const vertexInput = { |
| indexFormat: "uint32", |
| vertexBuffers: [{ |
| stride: vertexSize, |
| attributeSet: [{ |
| format: "float4", |
| shaderLocation: 0 |
| }] |
| }] |
| }; |
| |
| // Create buffer GPUBindGroupLayoutBindings. |
| const layoutUL = createUniformBufferBindGroupLayout(bindingNums.UL); |
| const layoutUM = createUniformBufferBindGroupLayout(bindingNums.UM); |
| const layoutUR = createUniformBufferBindGroupLayout(bindingNums.UR); |
| const layoutLL = createUniformBufferBindGroupLayout(bindingNums.LL); |
| const layoutLR = createUniformBufferBindGroupLayout(bindingNums.LR); |
| const layoutG = createUniformBufferBindGroupLayout(bindingNums.G, GPUShaderStageBit.FRAGMENT); |
| |
| // GPUBindGroupLayouts |
| const leftTriangleBGLayout = device.createBindGroupLayout({ bindings: [layoutUL, layoutUM, layoutLL, layoutG] }); |
| const rightTriangleBGLayout = device.createBindGroupLayout({ bindings: [layoutUR, layoutUM, layoutLR] }); |
| |
| // GPUPipelineLayout and GPURenderPipeline |
| const pipelineLayout = device.createPipelineLayout({ bindGroupLayouts: [leftTriangleBGLayout, rightTriangleBGLayout] }); |
| const pipeline = createBasicPipeline(shaderModule, device, null, pipelineLayout, vertexInput, null, "triangle-list"); |
| |
| // GPUBufferBindings |
| const bindingUL = createBufferBinding(upperLeft); |
| const bindingUM = createBufferBinding(upperMiddle); |
| const bindingUR = createBufferBinding(upperRight); |
| const bindingLL = createBufferBinding(lowerLeft); |
| const bindingLR = createBufferBinding(lowerRight); |
| const bindingG = createBufferBinding(green); |
| |
| // GPUBindGroupBindings |
| const bgBindingUL = { binding: bindingNums.UL, resource: bindingUL }; |
| const bgBindingUM = { binding: bindingNums.UM, resource: bindingUM }; |
| const bgBindingUR = { binding: bindingNums.UR, resource: bindingUR }; |
| const bgBindingLL = { binding: bindingNums.LL, resource: bindingLL }; |
| const bgBindingLR = { binding: bindingNums.LR, resource: bindingLR }; |
| const bgBindingG = { binding: bindingNums.G, resource: bindingG }; |
| |
| // GPUBindGroups |
| const leftTriangleBG = device.createBindGroup({ |
| layout: leftTriangleBGLayout, |
| bindings: [bgBindingUL, bgBindingUM, bgBindingLL, bgBindingG] |
| }); |
| const rightTriangleBG = device.createBindGroup({ |
| layout: rightTriangleBGLayout, |
| bindings: [bgBindingUR, bgBindingUM, bgBindingLR] |
| }); |
| |
| Promise.all(bufferPromises).then(() => { |
| const commandEncoder = device.createCommandEncoder(); |
| const passEncoder = beginBasicRenderPass(swapChain, commandEncoder); |
| passEncoder.setPipeline(pipeline); |
| |
| // Vertex data for upper triangles. |
| passEncoder.setBindGroup(0, leftTriangleBG); |
| passEncoder.setBindGroup(1, rightTriangleBG); |
| // Lower triangle. |
| passEncoder.setVertexBuffers(0, [verticesBuffer], [0]); |
| passEncoder.draw(9, 1, 0, 0); |
| |
| passEncoder.endPass(); |
| const queue = device.getQueue(); |
| queue.submit([commandEncoder.finish()]); |
| }); |
| } |
| |
| test().then(function() { |
| if (window.testRunner) |
| testRunner.notifyDone(); |
| }, function() { |
| if (window.testRunner) |
| testRunner.notifyDone(); |
| }); |
| </script> |
