webgpu: rename to just "gpu"

It's nicer to refer to this in code as `gpu`. Additionally, `webgpu` as a name
gives the impression this is for web only which is absolutely not true but could
understandably be very confusing to newcomers.

Solve both problems by renaming to just `gpu`, and (next) updating the README to
indicate what it does and why, then explain it's WebGPU after as more of an
implementation detail.

Signed-off-by: Stephen Gutekanst <stephen@hexops.com>

gpu/src/dawn/hello_triangle.zig

@@ -0,0 +1,164 @@
+const std = @import("std");
+const sample_utils = @import("sample_utils.zig");
+const c = @import("c.zig").c;
+const glfw = @import("glfw");
+
+// #include "utils/SystemUtils.h"
+// #include "utils/WGPUHelpers.h"
+
+// WGPUSwapChain swapchain;
+// WGPURenderPipeline pipeline;
+
+// WGPUTextureFormat swapChainFormat;
+
+pub fn main() !void {
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var allocator = &gpa.allocator;
+
+    const setup = try sample_utils.setup();
+    const queue = c.wgpuDeviceGetQueue(setup.device);
+
+    var descriptor = std.mem.zeroes(c.WGPUSwapChainDescriptor);
+    descriptor.implementation = c.machUtilsBackendBinding_getSwapChainImplementation(setup.binding);
+    const swap_chain = c.wgpuDeviceCreateSwapChain(setup.device, null, &descriptor);
+
+    const swap_chain_format = c.machUtilsBackendBinding_getPreferredSwapChainTextureFormat(setup.binding);
+    c.wgpuSwapChainConfigure(swap_chain, swap_chain_format, c.WGPUTextureUsage_RenderAttachment, 640, 480);
+
+    const vs =
+        \\ [[stage(vertex)]] fn main(
+        \\     [[builtin(vertex_index)]] VertexIndex : u32
+        \\ ) -> [[builtin(position)]] vec4<f32> {
+        \\     var pos = array<vec2<f32>, 3>(
+        \\         vec2<f32>( 0.0,  0.5),
+        \\         vec2<f32>(-0.5, -0.5),
+        \\         vec2<f32>( 0.5, -0.5)
+        \\     );
+        \\     return vec4<f32>(pos[VertexIndex], 0.0, 1.0);
+        \\ }
+    ;
+    var vs_wgsl_descriptor = try allocator.create(c.WGPUShaderModuleWGSLDescriptor);
+    vs_wgsl_descriptor.chain.next = null;
+    vs_wgsl_descriptor.chain.sType = c.WGPUSType_ShaderModuleWGSLDescriptor;
+    vs_wgsl_descriptor.source = vs;
+    const vs_shader_descriptor = c.WGPUShaderModuleDescriptor{
+        .nextInChain = @ptrCast(*const c.WGPUChainedStruct, vs_wgsl_descriptor),
+        .label = "my vertex shader",
+    };
+    const vs_module = c.wgpuDeviceCreateShaderModule(setup.device, &vs_shader_descriptor);
+
+    const fs =
+        \\ [[stage(fragment)]] fn main() -> [[location(0)]] vec4<f32> {
+        \\     return vec4<f32>(1.0, 0.0, 0.0, 1.0);
+        \\ }
+    ;
+    var fs_wgsl_descriptor = try allocator.create(c.WGPUShaderModuleWGSLDescriptor);
+    fs_wgsl_descriptor.chain.next = null;
+    fs_wgsl_descriptor.chain.sType = c.WGPUSType_ShaderModuleWGSLDescriptor;
+    fs_wgsl_descriptor.source = fs;
+    const fs_shader_descriptor = c.WGPUShaderModuleDescriptor{
+        .nextInChain = @ptrCast(*const c.WGPUChainedStruct, fs_wgsl_descriptor),
+        .label = "my fragment shader",
+    };
+    const fs_module = c.wgpuDeviceCreateShaderModule(setup.device, &fs_shader_descriptor);
+
+    // Fragment state
+    var blend = std.mem.zeroes(c.WGPUBlendState);
+    blend.color.operation = c.WGPUBlendOperation_Add;
+    blend.color.srcFactor = c.WGPUBlendFactor_One;
+    blend.color.dstFactor = c.WGPUBlendFactor_One;
+    blend.alpha.operation = c.WGPUBlendOperation_Add;
+    blend.alpha.srcFactor = c.WGPUBlendFactor_One;
+    blend.alpha.dstFactor = c.WGPUBlendFactor_One;
+
+    var color_target = std.mem.zeroes(c.WGPUColorTargetState);
+    color_target.format = swap_chain_format;
+    color_target.blend = &blend;
+    color_target.writeMask = c.WGPUColorWriteMask_All;
+
+    var fragment = std.mem.zeroes(c.WGPUFragmentState);
+    fragment.module = fs_module;
+    fragment.entryPoint = "main";
+    fragment.targetCount = 1;
+    fragment.targets = &color_target;
+
+    var pipeline_descriptor = std.mem.zeroes(c.WGPURenderPipelineDescriptor);
+    pipeline_descriptor.fragment = &fragment;
+
+    // Other state
+    pipeline_descriptor.layout = null;
+    pipeline_descriptor.depthStencil = null;
+
+    pipeline_descriptor.vertex.module = vs_module;
+    pipeline_descriptor.vertex.entryPoint = "main";
+    pipeline_descriptor.vertex.bufferCount = 0;
+    pipeline_descriptor.vertex.buffers = null;
+
+    pipeline_descriptor.multisample.count = 1;
+    pipeline_descriptor.multisample.mask = 0xFFFFFFFF;
+    pipeline_descriptor.multisample.alphaToCoverageEnabled = false;
+
+    pipeline_descriptor.primitive.frontFace = c.WGPUFrontFace_CCW;
+    pipeline_descriptor.primitive.cullMode = c.WGPUCullMode_None;
+    pipeline_descriptor.primitive.topology = c.WGPUPrimitiveTopology_TriangleList;
+    pipeline_descriptor.primitive.stripIndexFormat = c.WGPUIndexFormat_Undefined;
+
+    const pipeline = c.wgpuDeviceCreateRenderPipeline(setup.device, &pipeline_descriptor);
+
+    c.wgpuShaderModuleRelease(vs_module);
+    c.wgpuShaderModuleRelease(fs_module);
+
+    while (!setup.window.shouldClose()) {
+        try frame(.{
+            .device = setup.device,
+            .swap_chain = swap_chain,
+            .pipeline = pipeline,
+            .queue = queue,
+        });
+        std.time.sleep(16000);
+    }
+}
+
+const FrameParams = struct {
+    device: c.WGPUDevice,
+    swap_chain: c.WGPUSwapChain,
+    pipeline: c.WGPURenderPipeline,
+    queue: c.WGPUQueue,
+};
+
+fn frame(params: FrameParams) !void {
+    const back_buffer_view = c.wgpuSwapChainGetCurrentTextureView(params.swap_chain);
+    var render_pass_info = std.mem.zeroes(c.WGPURenderPassDescriptor);
+    var color_attachment = std.mem.zeroes(c.WGPURenderPassColorAttachment);
+    color_attachment.view = back_buffer_view;
+    color_attachment.resolveTarget = null;
+    color_attachment.clearColor = c.WGPUColor{ .r = 0.0, .g = 0.0, .b = 0.0, .a = 0.0 };
+    color_attachment.loadOp = c.WGPULoadOp_Clear;
+    color_attachment.storeOp = c.WGPUStoreOp_Store;
+    render_pass_info.colorAttachmentCount = 1;
+    render_pass_info.colorAttachments = &color_attachment;
+    render_pass_info.depthStencilAttachment = null;
+
+    const encoder = c.wgpuDeviceCreateCommandEncoder(params.device, null);
+    const pass = c.wgpuCommandEncoderBeginRenderPass(encoder, &render_pass_info);
+    c.wgpuRenderPassEncoderSetPipeline(pass, params.pipeline);
+    c.wgpuRenderPassEncoderDraw(pass, 3, 1, 0, 0);
+    c.wgpuRenderPassEncoderEndPass(pass);
+    c.wgpuRenderPassEncoderRelease(pass);
+
+    const commands = c.wgpuCommandEncoderFinish(encoder, null);
+    c.wgpuCommandEncoderRelease(encoder);
+
+    c.wgpuQueueSubmit(params.queue, 1, &commands);
+    c.wgpuCommandBufferRelease(commands);
+    c.wgpuSwapChainPresent(params.swap_chain);
+    c.wgpuTextureViewRelease(back_buffer_view);
+
+    //     if (cmdBufType == CmdBufType::Terrible) {
+    //         bool c2sSuccess = c2sBuf->Flush();
+    //         bool s2cSuccess = s2cBuf->Flush();
+
+    //         ASSERT(c2sSuccess && s2cSuccess);
+    //     }
+    try glfw.pollEvents();
+}