refactor: src/app.zig

1 files changed, 0 insertions, 208 deletions

diff --git a/src/app.zig b/src/app.zig
deleted file mode 100644
index 51d55c4..0000000
--- a/src/app.zig
+++ /dev/null
@@ -1,208 +0,0 @@
-const std = @import("std");
-const math = @import("math.zig");
-const config = @import("config.zig");
-const c = @import("c.zig").c;
-
-const Vec2f = math.Vec2f;
-const Config = config.Config;
-
-pub const Camera = struct {
-    position: Vec2f = .{},
-    velocity: Vec2f = .{},
-    scale: f32 = 1.0,
-    delta_scale: f32 = 0.0,
-    scale_pivot: Vec2f = .{},
-};
-
-pub const Mouse = struct {
-    curr: Vec2f = .{},
-    prev: Vec2f = .{},
-    drag: bool = false,
-};
-
-pub const Flashlight = struct {
-    enabled: bool = false,
-    shadow: f32 = 0.0,
-    radius: f32 = 0.0,
-    delta_radius: f32 = 0.0,
-};
-
-pub const State = struct {
-    camera: Camera = .{},
-    mouse: Mouse = .{},
-    flashlight: Flashlight = .{},
-    dt: f32 = 0.0,
-    running: bool = true,
-    mirror: bool = false,
-};
-
-pub const App = struct {
-    config: Config = Config.default(),
-    state: State = .{},
-    config_path: ?[]const u8 = null,
-    allocator: std.mem.Allocator,
-
-    pub fn init(alloc: std.mem.Allocator, cfg_path: ?[]const u8) !App {
-        var app = App{
-            .allocator = alloc,
-            .config = Config.default(),
-        };
-
-        if (cfg_path) |p| {
-            app.config_path = try alloc.dupe(u8, p);
-            app.config.loadFromFile(p);
-        }
-
-        app.state.flashlight.radius = app.config.initial_radius;
-
-        return app;
-    }
-
-    pub fn deinit(self: *App) void {
-        if (self.config_path) |p| {
-            self.allocator.free(p);
-        }
-    }
-
-    pub fn cameraUpdate(self: *App, ws: Vec2f) void {
-        const cfg = &self.config;
-        const cam = &self.state.camera;
-        const m = &self.state.mouse;
-        const dt = self.state.dt;
-
-        if (@abs(cam.delta_scale) > cfg.scale_change_threshold) {
-            const half = ws.mul(0.5);
-            const sub = cam.scale_pivot.sub(half);
-            const p0 = sub.div(cam.scale);
-
-            cam.scale += cam.delta_scale * dt;
-            if (cam.scale < cfg.min_scale) cam.scale = cfg.min_scale;
-
-            const p1 = sub.div(cam.scale);
-            cam.position = cam.position.add(p0.sub(p1));
-            cam.delta_scale -= cam.delta_scale * dt * cfg.scale_friction;
-        }
-
-        if (!m.drag and cam.velocity.length() > cfg.velocity_threshold) {
-            cam.position = cam.position.add(cam.velocity.mul(dt));
-            cam.velocity = cam.velocity.sub(cam.velocity.mul(dt * cfg.drag_friction));
-        }
-    }
-
-    pub fn flashlightUpdate(self: *App) void {
-        const fl = &self.state.flashlight;
-        const dt = self.state.dt;
-        const cfg = &self.config;
-
-        fl.shadow = if (fl.enabled)
-            @min(fl.shadow + cfg.fade_speed * dt, cfg.max_shadow_opacity)
-        else
-            @max(fl.shadow - cfg.fade_speed * dt, 0.0);
-
-        if (@abs(fl.delta_radius) > cfg.radius_change_threshold) {
-            fl.radius = @max(0.0, fl.radius + fl.delta_radius * dt);
-            fl.delta_radius -= fl.delta_radius * cfg.radius_damping * dt;
-        }
-    }
-
-    fn worldPosition(camera: *Camera, pos: Vec2f) Vec2f {
-        return pos.div(camera.scale);
-    }
-
-    pub fn processEvents(self: *App, x11: anytype) void {
-        var ev: c.XEvent = undefined;
-        while (c.XPending(x11.display) != 0) {
-            _ = c.XNextEvent(x11.display, &ev);
-
-            switch (ev.type) {
-                c.KeyPress => self.handleKeypress(&ev.xkey),
-                c.MotionNotify => self.handleMousemove(&ev.xmotion, x11.refresh_rate),
-                c.ButtonPress => self.handleButtonpress(&ev.xbutton),
-                c.ButtonRelease => self.handleButtonrelease(&ev.xbutton),
-                c.ClientMessage => {
-                    if (@as(c.Atom, @bitCast(ev.xclient.data.l[0])) == x11.wm_delete_window)
-                        self.state.running = false;
-                },
-                else => {},
-            }
-        }
-    }
-
-    fn handleKeypress(self: *App, ke: *c.XKeyEvent) void {
-        const key = c.XLookupKeysym(ke, 0);
-
-        if (key == self.config.key_escape or key == c.XK_q)
-            self.state.running = false;
-
-        if (key == c.XK_r) {
-            if (self.config_path) |p| {
-                self.config.loadFromFile(p);
-            }
-        }
-
-        if (key == self.config.key_flashlight)
-            self.state.flashlight.enabled = !self.state.flashlight.enabled;
-
-        if (key == self.config.key_reset) {
-            self.state.camera = .{ .scale = 1.0 };
-            self.state.flashlight.shadow = 0.0;
-            self.state.flashlight.radius = self.config.initial_radius;
-            self.state.flashlight.delta_radius = 0.0;
-        }
-
-        if (key == self.config.key_mirror)
-            self.state.mirror = !self.state.mirror;
-
-        if (key == self.config.key_zoom_in) {
-            self.state.camera.delta_scale += self.config.scroll_speed;
-            self.state.camera.scale_pivot = self.state.mouse.curr;
-        }
-
-        if (key == self.config.key_zoom_out) {
-            self.state.camera.delta_scale -= self.config.scroll_speed;
-            self.state.camera.scale_pivot = self.state.mouse.curr;
-        }
-    }
-
-    fn handleMousemove(self: *App, motion: *c.XMotionEvent, rr: i32) void {
-        self.state.mouse.curr = .{ .x = @floatFromInt(motion.x), .y = @floatFromInt(motion.y) };
-
-        if (self.state.mouse.drag) {
-            const prev = worldPosition(&self.state.camera, self.state.mouse.prev);
-            const cur = worldPosition(&self.state.camera, self.state.mouse.curr);
-            self.state.camera.position = self.state.camera.position.add(prev.sub(cur));
-            self.state.camera.velocity = prev.sub(cur).mul(@floatFromInt(rr));
-        }
-
-        self.state.mouse.prev = self.state.mouse.curr;
-    }
-
-    fn handleButtonpress(self: *App, be: *c.XButtonEvent) void {
-        const ctrl_pressed = (be.state & self.config.modifier_flashlight) != 0;
-
-        if (be.button == self.config.button_drag) {
-            self.state.mouse.prev = self.state.mouse.curr;
-            self.state.mouse.drag = true;
-            self.state.camera.velocity = .{};
-        } else if (be.button == self.config.button_zoom_in) {
-            if (ctrl_pressed and self.state.flashlight.enabled) {
-                self.state.flashlight.delta_radius += self.config.initial_delta_radius;
-            } else {
-                self.state.camera.delta_scale += self.config.scroll_speed;
-                self.state.camera.scale_pivot = self.state.mouse.curr;
-            }
-        } else if (be.button == self.config.button_zoom_out) {
-            if (ctrl_pressed and self.state.flashlight.enabled) {
-                self.state.flashlight.delta_radius -= self.config.initial_delta_radius;
-            } else {
-                self.state.camera.delta_scale -= self.config.scroll_speed;
-                self.state.camera.scale_pivot = self.state.mouse.curr;
-            }
-        }
-    }
-
-    fn handleButtonrelease(self: *App, be: *c.XButtonEvent) void {
-        if (be.button == self.config.button_drag)
-            self.state.mouse.drag = false;
-    }
-};
\ No newline at end of file