zgpu

main.zig (10560B)

---

 const builtin = @import("builtin");
 const std = @import("std");
 
 const glfw = @import("glfw");
 const wgpu = @import("wgpu");
 
 const Callback1 = wgpu.Callback1;
 const DeviceCallback = wgpu.DeviceCallback;
 const CommandBuffer = wgpu.CommandBuffer;
 const Device = wgpu.Device;
 const Instance = wgpu.Instance;
 const StringView = wgpu.StringView;
 
 fn zgpu_log_callback(level: wgpu.LogLevel, message: []const u8) void {
     switch (level) {
         .@"error" => {
             std.log.err("[wgpu] {s}", .{message});
         },
         .warn => {
             std.log.warn("[wgpu] {s}", .{message});
         },
         .info => {
             std.log.debug("[wgpu] {s}", .{message});
         },
         .debug, .trace => {
             std.log.debug("[wgpu] {s}", .{message});
         },
         .off => unreachable,
     }
 }
 
 fn zgpu_error_callback(
     error_type: wgpu.ErrorType,
     message: []const u8,
 ) void {
     std.log.err("[wgpu - {}] {s}", .{ error_type, message });
 }
 
 fn zgpu_device_lost_callback(
     reason: wgpu.DeviceLostReason,
     message: []const u8,
 ) void {
     std.log.err("[wgpu - {}] {s}", .{ reason, message });
 }
 
 pub fn main() !void {
     try glfw.init();
     defer glfw.terminate();
 
     glfw.windowHint(.client_api, glfw.ClientApi.no_api);
     const window = try glfw.Window.create(640, 480, "Example", null, null);
     defer window.destroy();
 
     wgpu.setLogCallback(Callback1(zgpu_log_callback));
     wgpu.setLogLevel(.warn);
 
     const desc = Instance.Descriptor{
         .next = .{
             .extras = &.{
                 .backends = .primary,
                 .flags = .validation,
                 .dx12_compiler = .undefined,
                 .gles3_minor_version = .automatic,
                 .gl_fence_behavior = .normal,
                 .dxil_path = null,
                 .dxc_path = null,
                 .dxc_max_shader_model = .dxc_max_shader_model_v6_0,
             },
         },
         .features = .{
             .timed_wait_any_enable = false,
             .timed_wait_any_max_count = 0,
         },
     };
 
     const instance = Instance.create(&desc) orelse {
         std.log.err("failed to create GPU instance", .{});
         std.process.exit(1);
     };
     defer instance.release();
 
     const surface = switch (builtin.target.os.tag) {
         .linux => instance.createSurface(&.{
             .next = .{
                 .from_xlib_window = &.{
                     .window = try glfw.native.getX11Window(window)(),
                     .display = try glfw.native.getX11Display(),
                 },
             },
             .label = StringView.fromSlice("Example Surface"),
         }),
         .macos => instance.createSurface(&.{
             .next = .{
                 .from_metal_layer = &.{
                     .layer = glfw.native.getMetalLayer(window),
                 },
             },
             .label = StringView.fromSlice("Example Surface"),
         }),
         else => @compileError("Unsupported OS"),
     } orelse {
         std.log.err("failed to create GPU surface", .{});
         std.process.exit(1);
     };
     defer surface.release();
 
 
     const adapter = switch (builtin.target.os.tag) {
         .linux => try instance.requestAdapter(&.{
             .feature_level = .core,
             .power_preference = .high_performance,
             .backend_type = .vulkan,
             .force_fallback_adapter = false,
             .compatible_surface = surface,
         }),
         .macos => try instance.requestAdapter(&.{
             .feature_level = .core,
             .power_preference = .high_performance,
             .backend_type = .metal,
             .force_fallback_adapter = false,
             // the adapter seems to be compatible, but when I request that it
             // is it can't find one
             .compatible_surface = null,
         }),
         else => @compileError("Unsupported OS"),
     };
     defer adapter.release();
 
     const device = try adapter.requestDevice(&.{
         .label = StringView.fromSlice("Example Device"),
         .required_feature_count = 0,
         .required_features = null,
         .required_limits = null,
         .default_queue = .{
             .label = StringView.fromSlice("Example Default Queue"),
         },
         .device_lost_callback_info = .{
             .callback = DeviceCallback(zgpu_device_lost_callback),
             .mode = .allow_spontaneous,
             .userdata1 = null,
             .userdata2 = null,
         },
         .uncaptured_error_callback_info = .{
             .callback = DeviceCallback(zgpu_error_callback),
             .userdata1 = null,
             .userdata2 = null,
         },
     });
     defer device.release();
 
     const queue = device.getQueue();
     defer queue.release();
 
     surface.configure(&.{
         .device = device,
         .format = .bgra8_unorm,
         .usage = .{ .render_attachment = true },
         .width = 640,
         .height = 480,
         .view_format_count = 0,
         .view_formats = null,
         .alpha_mode = .auto,
         .present_mode = .fifo,
     });
 
     const vs =
         \\ @vertex fn main(
         \\     @builtin(vertex_index) vtx_idx : u32
         \\ ) -> @builtin(position) vec4<f32> {
         \\     let x = f32(i32(vtx_idx) - 1);
         \\     let y = f32(i32(vtx_idx & 1u) * 2 - 1);
         \\     return vec4<f32>(x, y, 0.0, 1.0);
         \\ }
     ;
     const vs_module = device.createShaderModule(&.{
         .next = .{ .wgsl = &.{ .code = StringView.fromSlice(vs) } },
         .label = StringView.fromSlice("Example Vertex Shader"),
     }) orelse {
         std.log.err("failed to compile vertex shader", .{});
         std.process.exit(1);
     };
     defer vs_module.release();
 
     const fs =
         \\ @fragment fn main() -> @location(0) vec4<f32> {
         \\     return vec4<f32>(1.0, 0.0, 0.0, 1.0);
         \\ }
     ;
     const fs_module = device.createShaderModule(&.{
         .next = .{ .wgsl = &.{ .code = StringView.fromSlice(fs) } },
         .label = StringView.fromSlice("Example Fragment Shader"),
     }) orelse {
         std.log.err("failed to compile fragment shader", .{});
         std.process.exit(1);
     };
     defer fs_module.release();
 
     const pipeline_layout = device.createPipelineLayout(&.{
         .label = StringView.fromSlice("Example Pipeline Layout"),
         .bind_group_layout_count = 0,
         .bind_group_layouts = null,
     }).?;
     defer pipeline_layout.release();
 
     const pipeline = device.createRenderPipeline(&.{
         .label = StringView.fromSlice("Example Render Pipeline"),
         .layout = pipeline_layout,
         .vertex = .{
             .module = vs_module,
             .entry_point = StringView.fromSlice("main"),
             .constant_count = 0,
             .constants = null,
             .buffer_count = 0,
             .buffers = null,
         },
         .primitive = .{
             .topology = .triangle_list,
             .strip_index_format = .undefined,
             .front_face = .ccw,
             .cull_mode = .none,
             .unclipped_depth = false,
         },
         .depth_stencil = null,
         .multisample = .{
             .count = 1,
             .mask = 0xFFFFFFFF,
             .alpha_to_coverage_enabled = false,
         },
         .fragment_state = &.{
             .module = fs_module,
             .entry_point = StringView.fromSlice("main"),
             .constant_count = 0,
             .constants = null,
             .target_count = 1,
             .targets = &.{
                 .{
                     .format = .bgra8_unorm,
                     .blend = &.{
                         .color = .{
                             .operation = .add,
                             .src_factor = .one,
                             .dst_factor = .zero,
                         },
                         .alpha = .{
                             .operation = .add,
                             .src_factor = .one,
                             .dst_factor = .zero,
                         },
                     },
                     .write_mask = .{
                         .red = true,
                         .green = true,
                         .blue = true,
                         .alpha = true,
                     },
                 },
             },
         },
     }) orelse {
         std.log.err("failed to create render pipeline", .{});
         std.process.exit(1);
     };
     defer pipeline.release();
 
     while (!window.shouldClose()) {
         glfw.pollEvents();
         const current_texture = surface.getCurrentTexture();
         const texture = current_texture.texture;
         defer texture.release();
         const view = texture.createView(&.{
             .label = StringView.fromSlice("Example View"),
             .format = .bgra8_unorm,
             .dimension = .@"2d",
             .base_mip_level = 0,
             .mip_level_count = 1,
             .base_array_layer = 0,
             .array_layer_count = 1,
             .aspect = .all,
             .usage = .{ .render_attachment = true },
         }).?;
         defer view.release();
         {
             const encoder = device.createCommandEncoder(&.{
                 .label = StringView.fromSlice("Example Encoder"),
             }).?;
             defer encoder.release();
             {
                 const pass = encoder.beginRenderPass(&.{
                     .label = StringView.fromSlice("Example Render Pass"),
                     .color_attachment_count = 1,
                     .color_attachments = &.{
                         .{
                             .view = view,
                             .resolve_target = null,
                             .load_op = .clear,
                             .store_op = .store,
                             .clear_value = .{ .r = 1, .g = 1, .b = 1, .a = 1 },
                         },
                     },
                     .depth_stencil_attachment = null,
                     .occlusion_query_set = null,
                     .timestamp_writes = null,
                 });
 
                 pass.setPipeline(pipeline);
                 pass.draw(3, 1, 0, 0);
 
                 defer pass.release();
                 defer pass.end();
             }
             {
                 var command = encoder.finish(&.{
                     .label = StringView.fromSlice("Example Command Buffer"),
                 }).?;
                 defer command.release();
                 queue.submit(&[_]*CommandBuffer{command});
             }
         }
         switch (surface.present()) {
             .success => {},
             .@"error" => std.log.err("surface presentation failed", .{}),
         }
     }
 }