This is a cry for help

Author: OliveThePuffin

examples/custom-renderer/Renderer.zig

@@ -56,7 +56,7 @@ pub fn init(
     const uniform_buffer = device.createBuffer(&.{
         .label = label ++ " uniform buffer",
         .usage = .{ .copy_dst = true, .uniform = true },
-        .size = @sizeOf(UniformBufferObject) * uniform_offset * num_bind_groups,
+        .size = ((@sizeOf(UniformBufferObject) / uniform_offset) + 1) * uniform_offset * num_bind_groups,
         .mapped_at_creation = .false,
     });
 
@@ -122,8 +122,9 @@ pub fn renderFrame(
 
     // Grab the back buffer of the swapchain
     // TODO(Core)
-    const back_buffer_view = window.swap_chain.getCurrentTextureView().?;
-    defer back_buffer_view.release();
+    const back_buffer_view = window.swap_chain.getCurrentTextureView();
+    if (back_buffer_view == null) return;
+    defer back_buffer_view.?.release();
 
     // Create a command encoder
     const label = @tagName(mach_module) ++ ".tick";
@@ -146,7 +147,7 @@ pub fn renderFrame(
     // Begin render pass
     const sky_blue_background = gpu.Color{ .r = 0.776, .g = 0.988, .b = 1, .a = 1 };
     const color_attachments = [_]gpu.RenderPassColorAttachment{.{
-        .view = back_buffer_view,
+        .view = back_buffer_view.?,
         .clear_value = sky_blue_background,
         .load_op = .clear,
         .store_op = .store,

src/Core.zig

@@ -12,7 +12,7 @@ const EventQueue = std.fifo.LinearFifo(Event, .Dynamic);
 
 pub const mach_module = .mach_core;
 
-pub const mach_systems = .{ .main, .init, .tick, .presentFrame, .deinit };
+pub const mach_systems = .{ .main, .init, .tick, .presentFrame, .renewSwapChain, .deinit };
 
 // Set track_fields to true so that when these field values change, we know about it
 // and can update the platform windows.
@@ -249,6 +249,27 @@ pub fn presentFrame(core: *Core, core_mod: mach.Mod(Core)) !void {
         .deinitializing => {},
         .exited => @panic("application not running"),
     }
+    core_mod.call(.renewSwapChain);
+}
+
+pub fn renewSwapChain(core: *Core) !void {
+    var windows = core.windows.slice();
+    while (windows.next()) |window_id| {
+        var core_window = core.windows.getValue(window_id);
+        if (core_window.swap_chain.isStale() or
+            core.windows.updated(window_id, .width) or
+            core.windows.updated(window_id, .height))
+        {
+            core_window.framebuffer_width = core_window.width;
+            core_window.framebuffer_height = core_window.height;
+            core_window.swap_chain_descriptor.height = core_window.framebuffer_height;
+            core_window.swap_chain_descriptor.width = core_window.framebuffer_width;
+
+            core_window.swap_chain.destroy();
+            core_window.swap_chain = core_window.device.createSwapChain(core_window.surface, &core_window.swap_chain_descriptor);
+            core.windows.setValueRaw(window_id, core_window);
+        }
+    }
 }
 
 pub fn main(core: *Core, core_mod: mach.Mod(Core)) !void {

src/core/Linux.zig

@@ -72,6 +72,10 @@ pub fn tick(core: *Core) !void {
             if (core.windows.updated(window_id, .title)) {
                 setTitle(&native, core_window.title);
             }
+            if (core.windows.updated(window_id, .display_mode) or core.windows.updated(window_id, .decorated)) {
+                setDisplayMode(&native, core_window.display_mode, core_window.decorated);
+                setBorder(&native, core_window.decorated);
+            }
             // check for display server events
             switch (native) {
                 .x11 => try X11.tick(window_id),
@@ -178,16 +182,14 @@ fn setTitle(native: *const Native, title: [:0]const u8) void {
     }
 }
 
-pub fn setDisplayMode(linux: *Linux, display_mode: DisplayMode) void {
-    // const old_display_mode = linux.display_mode;
-    linux.display_mode = display_mode;
-    switch (linux.backend) {
-        .wayland => linux.backend.wayland.setDisplayMode(display_mode),
-        .x11 => linux.backend.x11.setDisplayMode(linux, display_mode),
+fn setDisplayMode(native: *const Native, display_mode: DisplayMode, decorated: bool) void {
+    switch (native.*) {
+        .wayland => Wayland.setDisplayMode(&native.wayland, display_mode),
+        .x11 => X11.setDisplayMode(&native.x11, display_mode, decorated),
     }
 }
 
-pub fn setBorder(_: *Linux, _: bool) void {
+fn setBorder(_: *const Native, _: bool) void {
     return;
 }
 

src/core/linux/Wayland.zig

@@ -240,7 +240,7 @@ pub fn setTitle(wl: *const Native, title: [:0]const u8) void {
     c.xdg_toplevel_set_title(wl.toplevel, title);
 }
 
-pub fn setDisplayMode(wl: *Wayland, display_mode: DisplayMode) void {
+pub fn setDisplayMode(wl: *const Native, display_mode: DisplayMode) void {
     _ = wl;
     _ = display_mode;
 }

src/core/linux/X11.zig

@@ -266,20 +266,20 @@ pub fn setDisplayMode(x11: *const Native, display_mode: DisplayMode, border: boo
                 @ptrCast(atoms.slice()),
                 @intCast(atoms.len),
             );
-            x11.setFullscreen(false);
-            x11.setDecorated(border);
-            x11.setFloating(false);
+            setFullscreen(x11, false);
+            setDecorated(x11, border);
+            setFloating(x11, false);
             _ = libx11.?.XMapWindow(x11.display, x11.window);
             _ = libx11.?.XFlush(x11.display);
         },
         .fullscreen => {
-            x11.setFullscreen(true);
+            setFullscreen(x11, true);
             _ = libx11.?.XFlush(x11.display);
         },
         .fullscreen_borderless => {
-            x11.setDecorated(false);
-            x11.setFloating(true);
-            x11.setFullscreen(false);
+            setDecorated(x11, false);
+            setFloating(x11, true);
+            setFullscreen(x11, false);
             _ = libx11.?.XResizeWindow(
                 x11.display,
                 x11.window,
@@ -294,7 +294,7 @@ pub fn setDisplayMode(x11: *const Native, display_mode: DisplayMode, border: boo
 fn setFullscreen(x11: *const Native, enabled: bool) void {
     const wm_state = libx11.?.XInternAtom(x11.display, "_NET_WM_STATE", c.False);
     const wm_fullscreen = libx11.?.XInternAtom(x11.display, "_NET_WM_STATE_FULLSCREEN", c.False);
-    x11.sendEventToWM(wm_state, &.{ @intFromBool(enabled), @intCast(wm_fullscreen), 0, 1 });
+    sendEventToWM(x11, wm_state, &.{ @intFromBool(enabled), @intCast(wm_fullscreen), 0, 1 });
     // Force composition OFF to reduce overhead
     const compositing_disable_on: c_long = @intFromBool(enabled);
     const bypass_compositor = libx11.?.XInternAtom(x11.display, "_NET_WM_BYPASS_COMPOSITOR", c.False);
@@ -318,7 +318,7 @@ fn setFloating(x11: *const Native, enabled: bool) void {
     const net_wm_state_remove = 0;
     const net_wm_state_add = 1;
     const action: c_long = if (enabled) net_wm_state_add else net_wm_state_remove;
-    x11.sendEventToWM(wm_state, &.{ action, @intCast(wm_above), 0, 1 });
+    sendEventToWM(x11, wm_state, &.{ action, @intCast(wm_above), 0, 1 });
 }
 
 fn sendEventToWM(x11: *const Native, message_type: c.Atom, data: []const c_long) void {
@@ -703,9 +703,6 @@ fn processEvent(window_id: mach.ObjectID, event: *c.XEvent) void {
                 core_window.width = @intCast(event.xconfigure.width);
                 core_window.height = @intCast(event.xconfigure.height);
 
-                // FIX: What is the Mach Object System way of doing this?
-                // core_ptr.swap_chain_update.set();
-
                 core_ptr.pushEvent(.{
                     .window_resize = .{
                         .size = Core.Size{

src/sysgpu/d3d12.zig

@@ -1533,6 +1533,15 @@ pub const SwapChain = struct {
         try queue.signal();
         swapchain.fence_values[swapchain.buffer_index] = queue.fence_value;
     }
+
+    pub fn isStale(sc: *SwapChain) bool {
+        _ = sc;
+        return false;
+    }
+
+    pub fn setStale(sc: *SwapChain) void {
+        _ = sc;
+    }
 };
 
 pub const Resource = struct {

src/sysgpu/main.zig

@@ -1250,6 +1250,11 @@ pub const Impl = sysgpu.Interface(struct {
         @panic("unimplemented");
     }
 
+    pub inline fn swapChainDestroy(swap_chain_raw: *sysgpu.SwapChain) void {
+        const swap_chain: *impl.SwapChain = @ptrCast(@alignCast(swap_chain_raw));
+        swap_chain.deinit();
+    }
+
     pub inline fn swapChainGetCurrentTexture(swap_chain: *sysgpu.SwapChain) ?*sysgpu.Texture {
         _ = swap_chain;
         @panic("unimplemented");
@@ -1261,6 +1266,11 @@ pub const Impl = sysgpu.Interface(struct {
         return @ptrCast(texture_view);
     }
 
+    pub inline fn swapChainIsStale(swap_chain_raw: *sysgpu.SwapChain) bool {
+        const swap_chain: *impl.SwapChain = @ptrCast(@alignCast(swap_chain_raw));
+        return swap_chain.isStale();
+    }
+
     pub inline fn swapChainPresent(swap_chain_raw: *sysgpu.SwapChain) void {
         const swap_chain: *impl.SwapChain = @ptrCast(@alignCast(swap_chain_raw));
         swap_chain.present() catch @panic("api error");
@@ -1276,6 +1286,11 @@ pub const Impl = sysgpu.Interface(struct {
         swap_chain.manager.release();
     }
 
+    pub inline fn swapChainSetStale(swap_chain_raw: *sysgpu.SwapChain) void {
+        const swap_chain: *impl.SwapChain = @ptrCast(@alignCast(swap_chain_raw));
+        return swap_chain.setStale();
+    }
+
     pub inline fn textureCreateView(texture_raw: *sysgpu.Texture, descriptor: ?*const sysgpu.TextureView.Descriptor) *sysgpu.TextureView {
         const texture: *impl.Texture = @ptrCast(@alignCast(texture_raw));
         const texture_view = texture.createView(descriptor orelse &sysgpu.TextureView.Descriptor{}) catch @panic("api error");

src/sysgpu/metal.zig

@@ -269,6 +269,10 @@ pub const Device = struct {
         return Texture.init(device, desc);
     }
 
+    pub fn destroySwapChain(swapchain: *const sysgpu.SwapChain.Descriptor) void {
+        return SwapChain.deinit(swapchain);
+    }
+
     pub fn getQueue(device: *Device) !*Queue {
         if (device.queue == null) {
             device.queue = try Queue.init(device);
@@ -493,6 +497,15 @@ pub const SwapChain = struct {
             }
         }
     }
+
+    pub fn isStale(sc: *SwapChain) bool {
+        _ = sc;
+        return false;
+    }
+
+    pub fn setStale(sc: *SwapChain) void {
+        _ = sc;
+    }
 };
 
 pub const Buffer = struct {

src/sysgpu/opengl.zig

@@ -636,6 +636,15 @@ pub const SwapChain = struct {
         if (c.SwapBuffers(swapchain.hdc) == c.FALSE)
             return error.SwapBuffersFailed;
     }
+
+    pub fn isStale(sc: *SwapChain) bool {
+        _ = sc;
+        return false;
+    }
+
+    pub fn setStale(sc: *SwapChain) void {
+        _ = sc;
+    }
 };
 
 pub const Buffer = struct {

src/sysgpu/sysgpu/interface.zig

@@ -275,6 +275,7 @@ pub fn Interface(comptime T: type) type {
     assertDecl(T, "swapChainPresent", fn (swap_chain: *sysgpu.SwapChain) callconv(.Inline) void);
     assertDecl(T, "swapChainReference", fn (swap_chain: *sysgpu.SwapChain) callconv(.Inline) void);
     assertDecl(T, "swapChainRelease", fn (swap_chain: *sysgpu.SwapChain) callconv(.Inline) void);
+    assertDecl(T, "swapChainDestroy", fn (swap_chain: *sysgpu.SwapChain) callconv(.Inline) void);
 
     // sysgpu.Texture
     assertDecl(T, "textureCreateView", fn (texture: *sysgpu.Texture, descriptor: ?*const sysgpu.TextureView.Descriptor) callconv(.Inline) *sysgpu.TextureView);
@@ -1271,6 +1272,11 @@ pub fn Export(comptime T: type) type {
             T.surfaceRelease(surface);
         }
 
+        // SYSGPU_EXPORT WGPUSwapChain sysgpuSwapChainDestroy(WGPUSwapChain const * swapchain);
+        export fn sysgpuSwapChainDestroy(swap_chain: *sysgpu.SwapChain) void {
+            return T.swapChainDestroy(swap_chain);
+        }
+
         // SYSGPU_EXPORT WGPUTexture sysgpuSwapChainGetCurrentTexture(WGPUSwapChain swapChain);
         export fn sysgpuSwapChainGetCurrentTexture(swap_chain: *sysgpu.SwapChain) ?*sysgpu.Texture {
             return T.swapChainGetCurrentTexture(swap_chain);
@@ -2581,6 +2587,11 @@ pub const StubInterface = Interface(struct {
         unreachable;
     }
 
+    pub inline fn swapChainDestroy(swap_chain: *sysgpu.SwapChain) void {
+        _ = swap_chain;
+        unreachable;
+    }
+
     pub inline fn swapChainGetCurrentTexture(swap_chain: *sysgpu.SwapChain) ?*sysgpu.Texture {
         _ = swap_chain;
         unreachable;
@@ -2591,6 +2602,11 @@ pub const StubInterface = Interface(struct {
         unreachable;
     }
 
+    pub inline fn swapChainIsStale(swap_chain: *sysgpu.SwapChain) bool {
+        _ = swap_chain;
+        unreachable;
+    }
+
     pub inline fn swapChainPresent(swap_chain: *sysgpu.SwapChain) void {
         _ = swap_chain;
         unreachable;
@@ -2606,6 +2622,11 @@ pub const StubInterface = Interface(struct {
         unreachable;
     }
 
+    pub inline fn swapChainSetStale(swap_chain: *sysgpu.SwapChain) void {
+        _ = swap_chain;
+        unreachable;
+    }
+
     pub inline fn textureCreateView(texture: *sysgpu.Texture, descriptor: ?*const sysgpu.TextureView.Descriptor) *sysgpu.TextureView {
         _ = texture;
         _ = descriptor;