diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/main.zig | 355 |
1 files changed, 226 insertions, 129 deletions
diff --git a/src/main.zig b/src/main.zig index 5f83b8e..4902176 100644 --- a/src/main.zig +++ b/src/main.zig @@ -6,112 +6,267 @@ const wayland = @import("wayland"); const wl = wayland.client.wl; const xdg = wayland.client.xdg; +/// Global Wayland registry context; contains pointers to the globals we expect +/// from the compositor. const RegistryContext = struct { - shm: ?*wl.Shm, - compositor: ?*wl.Compositor, - wm_base: ?*xdg.WmBase, + shm: ?*wl.Shm = null, + compositor: ?*wl.Compositor = null, + wm_base: ?*xdg.WmBase = null, }; -const Window = struct { - shm: *wl.Shm, +var registry_ctx = RegistryContext{}; + +/// A window's buffer data; we will paint the frames to these buffers. +const WindowBuffer = struct { + /// Wayland buffer + wl_buffer: *wl.Buffer, + /// Backing data slice from memory mapping for this buffer + map: []u8, + /// Are we being read by the compositor right now? + busy: bool = false, +}; + +/// A single Window (surface); data and methods we need to tell the compositor +/// to render a surface for us. +pub const Window = struct { + /// The allocator that we were allocated on, needed to destroy ourselves + allocator: mem.Allocator, + /// Wayland surface wl_surface: *wl.Surface, - width: i32, - height: i32, - offset: f32, - last_frame: u32, - run: bool, + /// XDG surface attached to the Wayland surface + xdg_surface: *xdg.Surface = undefined, + /// XDG toplevel data + xdg_toplevel: *xdg.Toplevel = undefined, + /// Buffers A and B; Wayland requires double-buffering + buffers: [2]WindowBuffer = undefined, + /// Memory mapped for both buffers + buffers_map: []align(mem.page_size) u8 = undefined, + /// This window's title + title: [*:0]const u8, + /// Width in pixels + width: i32 = 480, + /// Height in pixels + height: i32 = 360, + /// Offset of our checkerboard animation + offset: f32 = 0.0, + /// Last frame's timestamp in ms + last_frame: u32 = 0, + /// Should we keep this window open? + open: bool = true, + + /// Allocate a new window and all backing resources for it + pub fn create(allocator: mem.Allocator, title: [*:0]const u8) !*Window { + const compositor = registry_ctx.compositor orelse return error.NoWlCompositor; + const wm_base = registry_ctx.wm_base orelse return error.NoXdgWmBase; + + var win = try allocator.create(Window); + win.* = Window{ + .allocator = allocator, + .wl_surface = try compositor.createSurface(), + .title = title, + }; + win.xdg_surface = try wm_base.getXdgSurface(win.wl_surface); + win.xdg_toplevel = try win.xdg_surface.getToplevel(); + + try win.allocBuffers(); + + win.xdg_surface.setListener(*Window, xdgSurfaceListener, win); + win.xdg_toplevel.setListener(*Window, xdgToplevelListener, win); + + win.xdg_toplevel.setTitle(title); + + win.wl_surface.commit(); - pub fn drawFrame(state: *Window) !*wl.Buffer { - const stride = state.width * 4; - const size = stride * state.height; + const wl_cb = try win.wl_surface.frame(); + wl_cb.setListener(*Window, frameListener, win); + + return win; + } + + /// Destroy this window and all its associated resources + pub fn destroy(win: *Window) void { + win.destroyBuffers(); + win.xdg_toplevel.destroy(); + win.xdg_surface.destroy(); + win.wl_surface.destroy(); + win.allocator.destroy(win); + } + + /// Allocate new buffers for this window + fn allocBuffers(win: *Window) !void { + const stride = win.width * 4; + const buffer_size = stride * win.height; + const total_size = buffer_size * 2; // we need two buffers const fd = try posix.memfd_create("zigway", 0); defer posix.close(fd); - try posix.ftruncate(fd, @intCast(size)); - var data = try posix.mmap( + try posix.ftruncate(fd, @intCast(total_size)); + win.buffers_map = try posix.mmap( null, - @intCast(size), + @intCast(total_size), posix.PROT.READ | posix.PROT.WRITE, .{ .TYPE = .SHARED }, fd, 0, ); - defer posix.munmap(data); - const pool = try state.shm.createPool(fd, size); + const shm = registry_ctx.shm orelse return error.NoShm; + const pool = try shm.createPool(fd, total_size); defer pool.destroy(); - const buffer = try pool.createBuffer(0, state.width, state.height, stride, .argb8888); - - const canvas: *[]u32 = @ptrCast(&data); - const box_side = 12; - var offset: u32 = @intFromFloat(state.offset); - offset = @rem(offset, box_side); - const height: u32 = @intCast(state.height); - const width: u32 = @intCast(state.width); - for (0..height) |y| { - for (0..width) |x| { - if ((x + offset + (y + offset) / box_side * box_side) % (box_side * 2) < box_side) { - canvas.*[y * width + x] = 0xFF0E0E0E; - } else { - canvas.*[y * width + x] = 0xFF2F2F2F; - } + inline for (&win.buffers, 0..win.buffers.len) |*buffer, i| { + buffer.wl_buffer = try pool.createBuffer( + buffer_size *% @as(i32, i), + win.width, + win.height, + stride, + .argb8888, + ); + const bsize: usize = @intCast(buffer_size); + buffer.busy = false; + buffer.map = win.buffers_map[bsize *% i .. bsize *% (i + 1)]; + buffer.wl_buffer.setListener(*WindowBuffer, bufferListener, buffer); + } + } + + /// Destroy this window's buffers + fn destroyBuffers(win: *Window) void { + win.buffers[0].wl_buffer.destroy(); + win.buffers[1].wl_buffer.destroy(); + posix.munmap(win.buffers_map); + } + + /// Draw a new frame to the first free buffer and return it + pub fn drawFrame(win: *Window) !*wl.Buffer { + var buffer: *WindowBuffer = undefined; + if (!win.buffers[0].busy) { + buffer = &win.buffers[0]; + } else if (!win.buffers[1].busy) { + buffer = &win.buffers[1]; + } else { + return error.NoBuffersAvaiable; + } + + const canvas: *[]u32 = @ptrCast(&buffer.map); + const box_side = 16; + var offset: i32 = @intFromFloat(win.offset); + offset = @mod(offset, box_side); + var y: i32 = 0; + while (y < win.height) : (y += 1) { + var x: i32 = 0; + while (x < win.width) : (x += 1) { + const i: usize = @intCast(y * win.width + x); + const side = @mod( + x + offset + @divFloor(y + offset, box_side) * box_side, + (box_side * 2), + ); + canvas.*[i] = if (side < box_side) 0xFF0E0E0E else 0xFF2F2F2F; } } - buffer.setListener(?*void, bufferListener, null); - return buffer; + buffer.busy = true; + return buffer.wl_buffer; + } + + /// Resize this window and reallocate the buffers if needed + fn resize(win: *Window, width: i32, height: i32) !void { + win.height = if (height != 0) height else win.height; + win.width = if (width != 0) width else win.width; + if (width == 0 and height == 0) return; + win.destroyBuffers(); + try win.allocBuffers(); + } + + /// XDG Surface callbacks + fn xdgSurfaceListener(xdg_surface: *xdg.Surface, event: xdg.Surface.Event, win: *Window) void { + switch (event) { + .configure => |configure| { + xdg_surface.ackConfigure(configure.serial); + brk: { + const buffer = win.drawFrame() catch |err| { + std.debug.print("error drawing frame {}\n", .{err}); + break :brk; + }; + win.wl_surface.attach(buffer, 0, 0); + } + win.wl_surface.commit(); + }, + } + } + + /// XDG Toplevel callbacks + fn xdgToplevelListener(_: *xdg.Toplevel, event: xdg.Toplevel.Event, win: *Window) void { + switch (event) { + .configure => |configure| { + win.resize(configure.width, configure.height) catch |err| { + std.debug.print("error resizing window {}\n", .{err}); + return; + }; + }, + .close => win.open = false, + } + } + + /// Wayland buffer callbacks + fn bufferListener(_: *wl.Buffer, event: wl.Buffer.Event, buffer: *WindowBuffer) void { + switch (event) { + .release => { + buffer.busy = false; + }, + } + } + + /// Wayland frame callback + fn frameListener(wl_cb: *wl.Callback, event: wl.Callback.Event, win: *Window) void { + switch (event) { + .done => |done| { + wl_cb.destroy(); + const new_cb = win.wl_surface.frame() catch |err| { + std.debug.print("unable to get frame {}\n", .{err}); + win.open = false; + return; + }; + new_cb.setListener(*Window, frameListener, win); + + if (win.last_frame != 0) { + const elapsed: f32 = @floatFromInt(done.callback_data -% win.last_frame); + win.offset -= elapsed / 1000.0 * 32.0; + } + defer win.last_frame = done.callback_data; + + const wl_buffer = win.drawFrame() catch |err| { + std.debug.print("error drawing frame {}\n", .{err}); + return; + }; + win.wl_surface.attach(wl_buffer, 0, 0); + win.wl_surface.damageBuffer(0, 0, std.math.maxInt(i32), std.math.maxInt(i32)); + win.wl_surface.commit(); + }, + } } }; pub fn main() !void { + var gpa = std.heap.GeneralPurposeAllocator(.{}){}; + const allocator = gpa.allocator(); const display = try wl.Display.connect(null); defer display.disconnect(); const registry = try display.getRegistry(); - var ctx = RegistryContext{ - .shm = null, - .compositor = null, - .wm_base = null, - }; - - registry.setListener(*RegistryContext, registryListener, &ctx); + registry.setListener(*RegistryContext, registryListener, ®istry_ctx); if (display.roundtrip() != .SUCCESS) return error.RoundTripFailed; - const compositor = ctx.compositor orelse return error.NoWlCompositor; - const wm_base = ctx.wm_base orelse return error.NoXdgWmBase; - - var state = Window{ - .shm = ctx.shm orelse return error.NoWlShm, - .wl_surface = try compositor.createSurface(), - .width = 480, - .height = 360, - .offset = 0.0, - .last_frame = 0, - .run = true, - }; - defer state.wl_surface.destroy(); - - const xdg_surface = try wm_base.getXdgSurface(state.wl_surface); - defer xdg_surface.destroy(); - const xdg_toplevel = try xdg_surface.getToplevel(); - defer xdg_toplevel.destroy(); - - xdg_surface.setListener(*Window, xdgSurfaceListener, &state); - xdg_toplevel.setListener(*Window, xdgToplevelListener, &state); + const wm_base = registry_ctx.wm_base orelse return error.NoXdgWmBase; wm_base.setListener(?*void, xdgWmBaseListener, null); - xdg_toplevel.setTitle("Hello, wayland!"); - - state.wl_surface.commit(); + const win = try Window.create(allocator, "Hello, wayland!"); + defer win.destroy(); - const wl_cb = try state.wl_surface.frame(); - wl_cb.setListener(*Window, frameListener, &state); - - while (state.run) { + while (win.open) { if (display.dispatch() != .SUCCESS) return error.DispatchFailed; } } +/// Global registry callback fn registryListener(registry: *wl.Registry, event: wl.Registry.Event, ctx: *RegistryContext) void { switch (event) { .global => |global| { @@ -132,31 +287,7 @@ fn registryListener(registry: *wl.Registry, event: wl.Registry.Event, ctx: *Regi } } -fn xdgSurfaceListener(xdg_surface: *xdg.Surface, event: xdg.Surface.Event, state: *Window) void { - switch (event) { - .configure => |configure| { - xdg_surface.ackConfigure(configure.serial); - brk: { - const buffer = state.drawFrame() catch |err| { - std.debug.print("error drawing frame {}\n", .{err}); - break :brk; - }; - state.wl_surface.attach(buffer, 0, 0); - } - state.wl_surface.commit(); - }, - } -} - -fn xdgToplevelListener(_: *xdg.Toplevel, event: xdg.Toplevel.Event, state: *Window) void { - switch (event) { - .configure => |configure| { - state.height = if (configure.height != 0) configure.height else state.height; - state.width = if (configure.width != 0) configure.width else state.width; - }, - .close => state.run = false, - } -} +/// XDG Wm Base callback fn xdgWmBaseListener(wm_base: *xdg.WmBase, event: xdg.WmBase.Event, _: ?*void) void { switch (event) { .ping => |ping| { @@ -164,37 +295,3 @@ fn xdgWmBaseListener(wm_base: *xdg.WmBase, event: xdg.WmBase.Event, _: ?*void) v }, } } - -fn bufferListener(buffer: *wl.Buffer, event: wl.Buffer.Event, _: ?*void) void { - switch (event) { - .release => buffer.destroy(), - } -} - -fn frameListener(wl_cb: *wl.Callback, event: wl.Callback.Event, state: *Window) void { - switch (event) { - .done => |done| { - wl_cb.destroy(); - const new_cb = state.wl_surface.frame() catch |err| { - std.debug.print("unable to get frame {}\n", .{err}); - state.run = false; - return; - }; - new_cb.setListener(*Window, frameListener, state); - - if (state.last_frame != 0) { - const elapsed: f32 = @floatFromInt(done.callback_data -% state.last_frame); - state.offset += elapsed / 1000.0 * 48.0; - } - defer state.last_frame = done.callback_data; - - const buffer = state.drawFrame() catch |err| { - std.debug.print("error drawing frame {}\n", .{err}); - return; - }; - state.wl_surface.attach(buffer, 0, 0); - state.wl_surface.damageBuffer(0, 0, std.math.maxInt(i32), std.math.maxInt(i32)); - state.wl_surface.commit(); - }, - } -} |