rpuzonas/sokoban-v2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add input handling

Browse Source
This commit is contained in:
Rokas Puzonas 2026-07-06 20:03:00 +03:00
parent 98f59a30bd
commit 5512be7d9e
3 changed files with 584 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
src/app.zig
View File

@ -3,17 +3,20 @@ const CLI = @import("./cli.zig");
const Platform = @import("./platform.zig");
const log = std.log.scoped(.app);
const Math = @import("math");
const Vec2 = Math.Vec2;
const App = @This();
bg: Platform.Color,
show_first_window: bool,
check: bool,
player_x: f32,
player_pos: Vec2,
pub fn init(self: *App, plt: Platform.Init) !?u8 {
self.* = App{
.bg = .black,
.player_x = 0,
.player_pos = .init(100, 100),
.show_first_window = true,
.check = false,
};
@ -24,7 +27,25 @@ pub fn init(self: *App, plt: Platform.Init) !?u8 {
pub fn frame(self: *App, plt: *Platform.Frame) !void {
const gfx = plt.gfx;
gfx.drawRectangle(.init(self.player_x + 100, 100), .init(100, 100), .rgb(200, 0, 0));
const dt = plt.deltaTime();
var dir: Vec2 = .init(0, 0);
if (plt.input.isKeyDown(.S)) {
dir.y += 1;
}
if (plt.input.isKeyDown(.W)) {
dir.y -= 1;
}
if (plt.input.isKeyDown(.D)) {
dir.x += 1;
}
if (plt.input.isKeyDown(.A)) {
dir.x -= 1;
}
dir = dir.normalized();
self.player_pos = self.player_pos.add(dir.multiplyScalar(50 * dt));
gfx.drawRectangle(self.player_pos, .init(100, 100), .rgb(200, 0, 0));
if (plt.imgui) |imgui| {
if (imgui.beginWindow(.{
@ -34,18 +55,10 @@ pub fn frame(self: *App, plt: *Platform.Frame) !void {
})) {
defer imgui.endWindow();
imgui.text("Hello", .{});
imgui.text("Player pos: {}", .{self.player_pos});
if (imgui.button("foo")) {
std.debug.print("pressed\n", .{});
}
if (imgui.slider(.{
.label = "player x",
.value = &self.player_x,
.min = 0,
.max = 100
})) {
std.debug.print("player x changed\n", .{});
}
if (imgui.checkbox("Hello", &self.check)) {
std.debug.print("checkbox changed\n", .{});
}

38
src/imgui.zig
View File

@ -14,6 +14,8 @@ pub const State = struct {
const simgui = sokol.imgui;
const ig = @import("cimgui");
enabled: bool,
commands_buffer: [128]Command,
strings_buffer: [Math.bytes_per_kib * 16]u8,
id_stack_buffer: [64]WidgetId,
@ -31,6 +33,7 @@ pub const State = struct {
}
self.* = @This(){
.enabled = true,
.widget_results = .{},
.commands_buffer = undefined,
.strings_buffer = undefined,
@ -44,11 +47,18 @@ pub const State = struct {
}
pub fn event(self: State, e: sapp.Event) bool {
_ = self; // autofix
if (self.enabled) {
return simgui.handleEvent(e);
}
return false;
}
pub fn render(self: *State, gpa: Allocator, imgui: *Interface) !void {
if (!self.enabled) {
return;
}
simgui.newFrame(.{
.width = sapp.width(),
.height = sapp.height(),
@ -57,8 +67,8 @@ pub const State = struct {
});
const viewport = ig.igGetMainViewport();
ig.igSetNextWindowPos(viewport[0].Pos, ig.ImGuiCond_Always);
ig.igSetNextWindowSize(viewport[0].Size, ig.ImGuiCond_Always);
ig.igSetNextWindowPos(viewport[0].WorkPos, ig.ImGuiCond_Always);
ig.igSetNextWindowSize(viewport[0].WorkSize, ig.ImGuiCond_Always);
ig.igSetNextWindowViewport(viewport[0].ID);
const window_flags =
@ -92,6 +102,8 @@ pub const State = struct {
ig.igSetNextWindowSize(.{ .x = size.x, .y = size.y }, ig.ImGuiCond_Once);
}
ig.igSetNextWindowBgAlpha(1);
const name = imgui.getString(opts.name);
var open: bool = true;
@ -181,12 +193,24 @@ pub const State = struct {
}
}
// TODO:
// if (ig.igBegin("Game", null, ig.ImGuiWindowFlags_None)) {
// // std.debug.print("{}\n", .{ig.igGetContentRegionAvail()});
// }
// ig.igEnd();
ig.igEnd();
// TODO:
// if (ig.igBeginMainMenuBar()) {
// ig.igEndMainMenuBar();
// }
if (ig.igBeginMainMenuBar()) {
defer ig.igEndMainMenuBar();
if (ig.igBeginMenu("foo")) {
defer ig.igEndMenu();
if (ig.igMenuItem("bar")) {
}
}
}
simgui.render();
}

554
src/platform.zig
View File

@ -24,16 +24,209 @@ const shd = @import("shader");
const ImGUI = @import("./imgui.zig");
pub const KeyCode = enum(std.math.IntFittingRange(0, sokol.app.max_keycodes-1)) {
SPACE = 32,
APOSTROPHE = 39,
COMMA = 44,
MINUS = 45,
PERIOD = 46,
SLASH = 47,
_0 = 48,
_1 = 49,
_2 = 50,
_3 = 51,
_4 = 52,
_5 = 53,
_6 = 54,
_7 = 55,
_8 = 56,
_9 = 57,
SEMICOLON = 59,
EQUAL = 61,
A = 65,
B = 66,
C = 67,
D = 68,
E = 69,
F = 70,
G = 71,
H = 72,
I = 73,
J = 74,
K = 75,
L = 76,
M = 77,
N = 78,
O = 79,
P = 80,
Q = 81,
R = 82,
S = 83,
T = 84,
U = 85,
V = 86,
W = 87,
X = 88,
Y = 89,
Z = 90,
LEFT_BRACKET = 91,
BACKSLASH = 92,
RIGHT_BRACKET = 93,
GRAVE_ACCENT = 96,
WORLD_1 = 161,
WORLD_2 = 162,
ESCAPE = 256,
ENTER = 257,
TAB = 258,
BACKSPACE = 259,
INSERT = 260,
DELETE = 261,
RIGHT = 262,
LEFT = 263,
DOWN = 264,
UP = 265,
PAGE_UP = 266,
PAGE_DOWN = 267,
HOME = 268,
END = 269,
CAPS_LOCK = 280,
SCROLL_LOCK = 281,
NUM_LOCK = 282,
PRINT_SCREEN = 283,
PAUSE = 284,
F1 = 290,
F2 = 291,
F3 = 292,
F4 = 293,
F5 = 294,
F6 = 295,
F7 = 296,
F8 = 297,
F9 = 298,
F10 = 299,
F11 = 300,
F12 = 301,
F13 = 302,
F14 = 303,
F15 = 304,
F16 = 305,
F17 = 306,
F18 = 307,
F19 = 308,
F20 = 309,
F21 = 310,
F22 = 311,
F23 = 312,
F24 = 313,
F25 = 314,
KP_0 = 320,
KP_1 = 321,
KP_2 = 322,
KP_3 = 323,
KP_4 = 324,
KP_5 = 325,
KP_6 = 326,
KP_7 = 327,
KP_8 = 328,
KP_9 = 329,
KP_DECIMAL = 330,
KP_DIVIDE = 331,
KP_MULTIPLY = 332,
KP_SUBTRACT = 333,
KP_ADD = 334,
KP_ENTER = 335,
KP_EQUAL = 336,
LEFT_SHIFT = 340,
LEFT_CONTROL = 341,
LEFT_ALT = 342,
LEFT_SUPER = 343,
RIGHT_SHIFT = 344,
RIGHT_CONTROL = 345,
RIGHT_ALT = 346,
RIGHT_SUPER = 347,
MENU = 348,
};
pub const MouseButton = enum {
left,
right,
middle,
pub fn fromSokol(mouse_button: sokol.app.Mousebutton) ?MouseButton {
return switch(mouse_button) {
.LEFT => .left,
.RIGHT => .right,
.MIDDLE => .middle,
else => null
};
}
};
pub const Event = union(enum) {
mouse_pressed: MouseButton,
mouse_released: MouseButton,
mouse_move: Vec2,
mouse_enter: Vec2,
mouse_leave,
mouse_scroll: Vec2,
key_pressed: KeyCode,
key_released: KeyCode,
char: u21,
window_resize: Vec2,
focused,
unfocused,
};
fn KeyStateType(T: type) type {
return struct {
pressed: std.EnumSet(T),
released: std.EnumSet(T),
down: std.EnumSet(T),
pub const empty = @This(){
.pressed = .empty,
.released = .empty,
.down = .empty,
};
pub fn press(self: *@This(), key: T) void {
self.pressed.insert(key);
self.down.insert(key);
}
pub fn release(self: *@This(), key: T) void {
self.released.insert(key);
self.down.remove(key);
}
pub fn releaseAll(self: *@This()) void {
var iter = self.down.iterator();
while (iter.next()) |key| {
self.release(key);
}
}
};
}
fn PlatformType(App: type) type {
const GraphicsState = struct {
const max_quads = 2048;
pipeline: sg.Pipeline = .{},
bindings: sg.Bindings = .{},
screen_size: Vec2,
pipeline: sg.Pipeline,
bindings: sg.Bindings,
quads_buffer: [max_quads]Quad,
fn init(self: *@This()) void {
self.* = @This(){
.quads_buffer = undefined,
.pipeline = .{},
.bindings = .{},
.screen_size = .init(sapp.widthf(), sapp.heightf())
};
sg.setup(.{
.environment = sglue.environment(),
.logger = .{ .func = sokolLogCallback },
@ -101,7 +294,7 @@ fn PlatformType(App: type) type {
fn getInterface(self: *@This()) Graphics {
return .{
.clear_color = .black,
.canvas_size = .init(320, 180),
.screen_size = self.screen_size,
.quads = .initBuffer(&self.quads_buffer)
};
}
@ -111,6 +304,7 @@ fn PlatformType(App: type) type {
const Self = @This();
gpa: Allocator,
io: Io,
cli_args: []const [:0]const u8,
app: *App,
@ -118,9 +312,21 @@ fn PlatformType(App: type) type {
gfx: GraphicsState,
imgui: if (build_options.has_imgui) ImGUI.State else void,
started_at: Io.Timestamp,
last_frame_at: Io.Timestamp,
events_buffer: [256]Event,
events_overflow: bool,
last_key_press_is_repeat: bool,
input: Input,
next_input: Input,
fn sokolInit(user_data: ?*anyopaque) callconv(.c) void {
const self: *Self = @ptrCast(@alignCast(user_data));
self.started_at = Io.Timestamp.now(self.io, .awake);
self.last_frame_at = self.started_at;
self.gfx.init();
if (build_options.has_imgui) {
self.imgui.init(.{
@ -136,31 +342,20 @@ fn PlatformType(App: type) type {
}
}
fn createProjectionMatrix(screen_size: Vec2, canvas_size: Vec2) Mat4 {
const scale_x = screen_size.x/canvas_size.x;
const scale_y = screen_size.y/canvas_size.y;
const min_scale = @min(scale_x, scale_y);
const offscreen_canvas_size = canvas_size.multiply(.{
.x = scale_x / min_scale,
.y = scale_y / min_scale
});
fn createProjectionMatrix(screen_size: Vec2) Mat4 {
return Mat4.initIdentity()
// Convert normalized [-1; 1] coordinates to [0; 1]
.multiply(Mat4.initTranslate(.{ .x = -1, .y = -1, .z = 0 }))
.multiply(Mat4.initScale(.{ .x = 2, .y = 2, .z = 0 }))
// Make the top-left corner (0,0)
.multiply(Mat4.initTranslate(.{ .x = 0, .y = 1, .z = 0 }))
.multiply(Mat4.initScale(.{ .x = 1, .y = -1, .z = 0 }))
// Scretch [0; 1] so that they map 1-to-1 on to screen coordinates.
.multiply(Mat4.initScale(.{
.x = 1/offscreen_canvas_size.x,
.y = 1/offscreen_canvas_size.y,
.z = 0
}))
.multiply(Mat4.initTranslate(.{
.x = (offscreen_canvas_size.x - canvas_size.x)/2,
.y = (offscreen_canvas_size.y - canvas_size.y)/2,
.x = 1/screen_size.x,
.y = 1/screen_size.y,
.z = 0
}));
}
@ -168,11 +363,28 @@ fn PlatformType(App: type) type {
fn frame(self: *Self) !void {
tracy.frameMark();
if (!self.events_overflow) {
self.input = self.next_input;
}
if (build_options.has_imgui) {
if (self.input.keyboard.pressed.contains(.F4)) {
self.imgui.enabled = !self.imgui.enabled;
}
}
const now = Io.Timestamp.now(self.io, .awake);
var gfx = self.gfx.getInterface();
var plt = Frame{
.t = self.started_at.durationTo(now),
.dt = self.last_frame_at.durationTo(now),
.gfx = &gfx,
.imgui = undefined
.input = &self.input,
.imgui = null
};
self.last_frame_at = now;
var imgui: ImGUI.Interface = undefined;
if (build_options.has_imgui) {
imgui = self.imgui.getInterface();
@ -192,8 +404,10 @@ fn PlatformType(App: type) type {
const screen_size = Vec2.init(sapp.widthf(), sapp.heightf());
var vs_params: shd.VsParams = .{
// TODO: Maybe 'view' matrix is not needed.
// We probably should only have a combined 'mvp' matrix
.view = .initIdentity(),
.projection = createProjectionMatrix(screen_size, gfx.canvas_size)
.projection = createProjectionMatrix(screen_size)
};
var pass_action: sg.PassAction = .{};
@ -206,12 +420,21 @@ fn PlatformType(App: type) type {
sg.applyPipeline(self.gfx.pipeline);
sg.applyBindings(self.gfx.bindings);
sg.applyUniforms(shd.UB_vs_params, sg.asRange(&vs_params));
sg.draw(0, 6, 1);
sg.draw(0, @intCast(gfx.quads.items.len * 6), 1);
if (build_options.has_imgui) {
try self.imgui.render(self.gpa, &imgui);
}
sg.endPass();
sg.commit();
self.events_overflow = false;
inline for (&.{ &self.input, &self.next_input }) |input| {
input.events.clearRetainingCapacity();
input.keyboard.pressed = .empty;
input.keyboard.released = .empty;
input.mouse_buttons.pressed = .empty;
input.mouse_buttons.released = .empty;
}
}
fn sokolFrame(user_data: ?*anyopaque) callconv(.c) void {
@ -225,10 +448,215 @@ fn PlatformType(App: type) type {
};
}
fn processEvent(input: *Input, e: Event) void {
switch (e) {
.key_pressed => |key| {
assert(!input.isKeyDown(key));
input.keyboard.press(key);
},
.key_released => |key| {
assert(input.isKeyDown(key));
input.keyboard.release(key);
},
.mouse_pressed => |button| {
assert(input.mouse_position != null);
assert(!input.isMouseDown(button));
input.mouse_buttons.press(button);
},
.mouse_released => |button| {
assert(input.mouse_position != null);
assert(input.isMouseDown(button));
input.mouse_buttons.release(button);
},
.mouse_enter => |pos| {
assert(input.mouse_position == null);
input.mouse_position = pos;
},
.mouse_move => |pos| {
assert(input.mouse_position != null);
input.mouse_position = pos;
},
.mouse_leave => {
assert(input.mouse_position != null);
input.mouse_position = null;
},
.char => |char| {
const last_event = input.events.getLast();
assert(last_event == .key_pressed);
input.key_code_mapping.put(last_event.key_pressed, char);
},
.mouse_scroll => |offset| {
assert(input.mouse_position != null);
input.mouse_scroll = input.mouse_scroll.add(offset);
},
.window_resize => {},
.focused => {},
.unfocused => {
assert(input.mouse_position == null);
assert(input.keyboard.down.eql(.empty));
assert(input.mouse_buttons.down.eql(.empty));
}
}
}
fn appendEvent(self: *Self, e: Event) void {
const input = &self.next_input;
if (input.events.capacity == input.events.items.len) {
if (!self.events_overflow) {
log.warn("too many events, limit: {}", .{input.events.capacity});
}
self.events_overflow = true;
return;
}
Self.processEvent(input, e);
input.events.appendAssumeCapacity(e);
}
fn pushEvent(self: *Self, e: Event) void {
const input = &self.next_input;
if (input.focused) {
if (e == .focused) {
return;
}
if (e == .key_pressed and input.isKeyDown(e.key_pressed)) {
return;
}
if (e == .key_released and !input.isKeyDown(e.key_released)) {
return;
}
if (e == .mouse_move and input.mouse_position.?.eql(e.mouse_move)) {
return;
}
if (e == .unfocused) {
var key_iter = input.keyboard.down.iterator();
while (key_iter.next()) |key| {
self.appendEvent(.{ .key_released = key });
}
var mouse_buttons_iter = input.mouse_buttons.down.iterator();
while (mouse_buttons_iter.next()) |button| {
self.appendEvent(.{ .mouse_released = button });
}
if (input.mouse_position != null) {
self.appendEvent(.{ .mouse_leave = {} });
}
input.focused = false;
}
} else {
if (e == .unfocused) {
return;
}
if (e != .focused) {
self.appendEvent(.focused);
if (e == .mouse_move) {
self.appendEvent(.{ .mouse_enter = e.mouse_move });
}
}
input.focused = true;
}
self.appendEvent(e);
}
fn event(self: *Self, e: sapp.Event) !bool {
if (build_options.has_imgui) {
if (self.imgui.event(e)) {
self.pushEvent(.{
.unfocused = {}
});
return true;
}
}
switch (e.type) {
.MOUSE_DOWN => {
self.pushEvent(.{
.mouse_pressed = MouseButton.fromSokol(e.mouse_button) orelse return false,
});
},
.MOUSE_UP => {
self.pushEvent(.{
.mouse_released = MouseButton.fromSokol(e.mouse_button) orelse return false,
});
},
.MOUSE_MOVE => {
self.pushEvent(.{
.mouse_move = .init(e.mouse_x, e.mouse_y)
});
},
.MOUSE_ENTER => {
self.pushEvent(.{
.mouse_enter = .init(e.mouse_x, e.mouse_y)
});
},
.MOUSE_LEAVE => {
self.pushEvent(.{
.mouse_leave = {}
});
},
.MOUSE_SCROLL => {
self.pushEvent(.{
.mouse_scroll = .init(e.scroll_x, e.scroll_y)
});
},
.KEY_DOWN => {
self.last_key_press_is_repeat = e.key_repeat;
if (!e.key_repeat) {
self.pushEvent(.{
.key_pressed = @enumFromInt(@intFromEnum(e.key_code))
});
}
},
.KEY_UP => {
self.pushEvent(.{
.key_released = @enumFromInt(@intFromEnum(e.key_code)),
});
},
.CHAR => {
if (!self.last_key_press_is_repeat) {
self.pushEvent(.{
.char = @intCast(e.char_code)
});
}
},
.FOCUSED => {
self.pushEvent(.{
.focused = {}
});
},
.UNFOCUSED => {
self.pushEvent(.{
.unfocused = {}
});
},
else => {}
}
return true;
}
fn sokolEvent(ev: [*c]const sapp.Event, user_data: ?*anyopaque) callconv(.c) void {
const self: *Self = @ptrCast(@alignCast(user_data));
if (build_options.has_imgui) {
_ = self.imgui.event(ev.*);
const consumed_event = self.event(ev.*) catch |err| blk: {
log.err("event() error: {}", .{err});
if (@errorReturnTrace()) |trace| {
std.debug.dumpErrorReturnTrace(trace);
}
sapp.quit();
break :blk false;
};
if (consumed_event) {
sapp.consumeEvent();
}
}
@ -265,7 +693,7 @@ pub const Quad = [4]Vertex;
pub const Graphics = struct {
clear_color: Color,
canvas_size: Vec2,
screen_size: Vec2,
quads: std.ArrayList(Quad),
pub fn drawQuad(self: *Graphics, quad: Quad) void {
@ -333,9 +761,73 @@ pub const Graphics = struct {
pub const Init = struct {
};
pub const Input = struct {
key_code_mapping: std.EnumMap(KeyCode, u21),
focused: bool,
keyboard: KeyStateType(KeyCode),
mouse_buttons: KeyStateType(MouseButton),
mouse_position: ?Vec2,
mouse_scroll: Vec2,
events: std.ArrayList(Event),
fn init(events_buffer: []Event) Input {
return .{
.events = .initBuffer(events_buffer),
.key_code_mapping = .{},
.keyboard = .empty,
.mouse_buttons = .empty,
.mouse_position = null,
.mouse_scroll = .init(0, 0),
.focused = false
};
}
pub fn isKeyPressed(self: Input, key: KeyCode) bool {
return self.keyboard.pressed.contains(key);
}
pub fn isKeyReleased(self: Input, key: KeyCode) bool {
return self.keyboard.released.contains(key);
}
pub fn isKeyDown(self: Input, key: KeyCode) bool {
return self.keyboard.down.contains(key);
}
pub fn isMousePressed(self: Input, button: MouseButton) bool {
return self.mouse_buttons.pressed.contains(button);
}
pub fn iMouseReleased(self: Input, button: MouseButton) bool {
return self.mouse_buttons.released.contains(button);
}
pub fn isMouseDown(self: Input, button: MouseButton) bool {
return self.mouse_buttons.down.contains(button);
}
};
pub const Frame = struct {
t: Io.Duration,
dt: Io.Duration,
gfx: *Graphics,
input: *Input,
imgui: ?*ImGUI.Interface,
fn nanosecondsToSeconds(nanoseconds: i96) f32 {
return @floatCast(@as(f64, @floatFromInt(nanoseconds)) / std.time.ns_per_s);
}
pub fn deltaTime(self: Frame) f32 {
return nanosecondsToSeconds(self.dt.nanoseconds);
}
pub fn time(self: Frame) f32 {
return nanosecondsToSeconds(self.t.nanoseconds);
}
};
pub fn run(App: type, opts: RunOptions) void {
@ -346,10 +838,18 @@ pub fn run(App: type, opts: RunOptions) void {
const plt = arena.create(PlatformApp) catch @panic("OOM");
plt.* = PlatformApp{
.gpa = gpa,
.io = opts.init.io,
.cli_args = opts.init.minimal.args.toSlice(arena) catch @panic("OOM"),
.app = gpa.create(App) catch @panic("OOM"),
.gfx = undefined,
.imgui = undefined
.imgui = undefined,
.events_buffer = undefined,
.events_overflow = false,
.input = .init(&[0]Event{}),
.next_input = .init(&plt.events_buffer),
.started_at = undefined,
.last_frame_at = undefined,
.last_key_press_is_repeat = false,
};
var icon: sapp.IconDesc = .{};