zgpu

main.zig (7931B)

---

 const builtin = @import("builtin");
 const std = @import("std");
 
 const glfw = @import("glfw");
 const wgpu = @import("wgpu");
 const math = @import("math");
 
 const Callback1 = wgpu.Callback1;
 const DeviceCallback = wgpu.DeviceCallback;
 const CommandBuffer = wgpu.CommandBuffer;
 const Device = wgpu.Device;
 const Instance = wgpu.Instance;
 const StringView = wgpu.StringView;
 
 const PerspectiveCamera = @import("camera.zig").PerspectiveCamera;
 const RenderPipeline = @import("render_pipeline.zig").RenderPipeline;
 const TriangleRenderPipeline = @import("render_pipeline.zig").TriangleRenderPipeline;
 
 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,
     });
 
 
     var triangle_rp = try TriangleRenderPipeline.init(device);
 
     const camera = PerspectiveCamera{
         .yaw = 100.0,
         .pitch = -10.0,
     };
     const uniform_data = TriangleRenderPipeline.UniformData{
         .view_matrix = camera.view(),
         .proj_matrix = camera.proj(),
     };
     triangle_rp.setUniform(queue, &uniform_data);
 
     const pipelines = [_]RenderPipeline{
         triangle_rp.renderPipeline(),
     };
 
     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,
                 });
 
                 for (pipelines) |pipeline| {
                     pipeline.frame(pass);
                 }
 
                 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", .{}),
         }
     }
 }