switch to /uniform/* paths

1 files changed, 56 insertions, 101 deletions

diff --git a/src/control.zig b/src/control.zig
index 2c272db..4db7cf1 100644
--- a/src/control.zig
+++ b/src/control.zig
@@ -138,9 +138,9 @@ pub const ControlServer = struct {
         if (self.server == null)
             return error.serverInitializationError;
 
-        _ = c.lo_server_add_method(self.server, "/-/shader", "s", handle_shader, @as(*anyopaque, @ptrCast(self)));
-        // _ = c.lo_server_add_method(self.server, "/-/reload", "", handle_reload, @as(*anyopaque, @ptrCast(self)));
-        _ = c.lo_server_add_method(self.server, "/*", null, handle_uniform, @as(*anyopaque, @ptrCast(self)));
+        _ = c.lo_server_add_method(self.server, "/shader", "s", wrapCallback(handle_shader), @as(*anyopaque, @ptrCast(self)));
+        // _ = c.lo_server_add_method(self.server, "/reload", "", handle_reload, @as(*anyopaque, @ptrCast(self)));
+        _ = c.lo_server_add_method(self.server, "/uniform/*", null, wrapCallback(handle_uniform), @as(*anyopaque, @ptrCast(self)));
 
         return self;
     }
@@ -160,24 +160,37 @@ pub const ControlServer = struct {
         );
     }
 
-    fn set_uniform(
-        self: *ControlServer,
-        path: []const u8,
-        argv: [][*c]c.lo_arg,
-        types: []const u8,
-    ) !void {
+    fn handle_shader(self: *ControlServer, path: []const u8, types: []const u8, argv: [][*c]c.lo_arg) !bool {
+        _ = path;
+        _ = types;
+
+        const code: [*:0]const u8 = @ptrCast(&argv[0].*.s);
+        try self.cache.shader.loadString(std.mem.span(code));
+        try self.cache.refresh();
+        return true;
+    }
+
+    fn handle_reload(self: *ControlServer, path: []const u8, types: []const u8, argv: [][*c]c.lo_arg) !bool {
+        _ = path;
+        _ = types;
+        _ = argv;
+
+        try self.cache.shader.loadFile(self.config.fragment, 2048);
+        try self.cache.refresh();
+        return true;
+    }
+
+    fn handle_uniform(self: *ControlServer, path: []const u8, types: []const u8, argv: [][*c]c.lo_arg) !bool {
         var parts = std.mem.tokenizeScalar(u8, path, '/');
-        var uniform: *gl.CachedUniform = undefined;
 
-        if (parts.next()) |uniform_name| {
+        _ = parts.next(); // skip /uniform
+        const uniform = blk: {
+            const uniform_name = parts.next() orelse return error.invalidMessage;
             const nameZ = try self.allocator.dupeZ(u8, uniform_name);
             defer self.allocator.free(nameZ);
 
-            const res = try self.cache.get(nameZ);
-            uniform = res orelse return error.notFound;
-        } else {
-            return error.invalidMessage;
-        }
+            break :blk try self.cache.get(nameZ) orelse return false;
+        };
 
         var value = (uniform.value orelse unreachable).getPointer();
         while (parts.next()) |component| {
@@ -257,93 +270,35 @@ pub const ControlServer = struct {
         };
 
         uniform.setShaderValue(self.cache.shader.*);
+        return true;
     }
 
-    fn handle_shader(
-        path: [*c]const u8,
-        types: [*c]const u8,
-        argv: [*c][*c]c.lo_arg,
-        argc: c_int,
-        msg: c.lo_message,
-        userdata: ?*anyopaque,
-    ) callconv(.C) c_int {
-        const self: *ControlServer = @ptrCast(@alignCast(userdata.?));
-        const code: [*:0]const u8 = @ptrCast(&argv[0].*.s);
-
-        _ = path;
-        _ = types;
-        _ = argc;
-        _ = msg;
-
-        _ = e: {
-            self.cache.shader.loadString(std.mem.span(code)) catch |err| break :e err;
-            self.cache.refresh() catch |err| break :e err;
-        } catch |err| {
-            std.debug.print("{} while loading shader from OSC\n", .{err});
-        };
-
-        return 0;
-    }
-
-    fn handle_reload(
-        path: [*c]const u8,
-        types: [*c]const u8,
-        argv: [*c][*c]c.lo_arg,
-        argc: c_int,
-        msg: c.lo_message,
-        userdata: ?*anyopaque,
-    ) callconv(.C) c_int {
-        const self: *ControlServer = @ptrCast(@alignCast(userdata.?));
-
-        _ = path;
-        _ = types;
-        _ = argc;
-        _ = argv;
-        _ = msg;
-
-        _ = e: {
-            self.cache.shader.loadFile(self.config.fragment, 2048) catch |err| break :e err;
-            self.cache.refresh() catch |err| break :e err;
-        } catch |err| {
-            std.debug.print("{} while reloading shader from file\n", .{err});
-        };
-
-        return 0;
-    }
-
-    fn handle_uniform(
-        _path: [*c]const u8,
-        _types: [*c]const u8,
-        _argv: [*c][*c]c.lo_arg,
-        argc: c_int,
-        msg: c.lo_message,
-        userdata: ?*anyopaque,
-    ) callconv(.C) c_int {
-        _ = msg;
-
-        const self: *ControlServer = @ptrCast(@alignCast(userdata.?));
-        const path = _path[0..c.strlen(_path)];
-        const argv: [][*c]c.lo_arg = _argv[0..@intCast(argc)];
-        const types = _types[0..@intCast(argc)];
-
-        self.set_uniform(path, argv, types) catch |err| {
-            if (err != error.notFound) {
-                std.debug.print("{} while processing {s}\n", .{ err, path });
+    const ZigCallback = fn (*ControlServer, []const u8, []const u8, [][*c]c.lo_arg) anyerror!bool;
+    const CCallback = fn ([*c]const u8, [*c]const u8, [*c][*c]c.lo_arg, c_int, c.lo_message, ?*anyopaque) callconv(.C) c_int;
+
+    fn wrapCallback(comptime inner: ZigCallback) CCallback {
+        return struct {
+            fn wrapped(
+                _path: ?[*:0]const u8,
+                _types: ?[*:0]const u8,
+                _argv: [*c][*c]c.lo_arg,
+                argc: c_int,
+                msg: c.lo_message,
+                userdata: ?*anyopaque,
+            ) callconv(.C) c_int {
+                const self: *ControlServer = @ptrCast(@alignCast(userdata.?));
+                const path = std.mem.span(_path.?);
+                const types = std.mem.span(_types.?);
+                const args = _argv[0..@intCast(argc)];
+
+                _ = msg;
+
+                const res = inner(self, path, types, args) catch |err| {
+                    std.debug.print("Error handling {s}: {}\n", .{ path, err });
+                    return 1;
+                };
+                return if (res) 0 else 1;
             }
-            return 1;
-        };
-
-        return 0;
-    }
-
-    fn handle_bundle_start(time: c.lo_timetag, userdata: ?*anyopaque) callconv(.C) c_int {
-        _ = time;
-        _ = userdata;
-        return 1;
-    }
-
-    fn handle_bundle_end(userdata: ?*anyopaque) callconv(.C) c_int {
-        _ = userdata;
-        return 1;
+        }.wrapped;
     }
 };