break OSC in favor of uniform caching

1 files changed, 33 insertions, 28 deletions

diff --git a/src/control.zig b/src/control.zig
index 3d36d8f..cec6f80 100644
--- a/src/control.zig
+++ b/src/control.zig
@@ -22,13 +22,13 @@ pub const ControlServer = struct {
                     .unix => c.LO_UNIX,
                     else => unreachable,
                 };
-                
-                std.debug.warn("listening for OSC messages on {} port {}\n", .{conf.protocol, conf.port});
-                self.server = c.lo_server_new_with_proto(&port[0], proto, handle_error);
+
+                std.debug.warn("listening for OSC messages on {} port {}\n", .{ conf.protocol, conf.port });
+                self.server = c.lo_server_new_with_proto(port[0..].ptr, proto, handle_error);
             },
             .URL => |url| {
                 std.debug.warn("listening for OSC messages at {s}\n", .{url});
-                self.server = c.lo_server_new_from_url(&url[0], handle_error);
+                self.server = c.lo_server_new_from_url(url[0..].ptr, handle_error);
             },
             else => unreachable,
         }
@@ -58,32 +58,37 @@ pub const ControlServer = struct {
         const path = _path[0..c.strlen(_path)];
         const types = _types[0..@intCast(u32, argc)];
 
-        if (std.mem.startsWith(u8, path, param_prefix)) {
-            const param_name = path[param_prefix.len..];
-
-            const uniform = self.shader.uniformLocation(@ptrCast([*]const u8, param_name.ptr)) catch {
-                std.debug.warn("param {s} doesn't exist\n", .{param_name});
-                return 0;
-            };
-
-            if (argc == 0) {
-                std.debug.warn("param get: {s}\n", .{param_name});
-                return 0;
+        if (std.mem.startsWith(u8, path, "/param/")) {
+            if (!std.mem.endsWith(u8, path, "/set")) {
+                std.debug.warn("unhandled OSC message {s} ({s})\n", .{ path, types });
+                return 1;
             }
 
-            if (std.mem.eql(u8, types, "f")) {
-                self.shader.setUniform1f(uniform, argv[0].*.f);
-            } else if (std.mem.eql(u8, types, "ff")) {
-                self.shader.setUniform2f(uniform, argv[0].*.f, argv[1].*.f);
-            } else if (std.mem.eql(u8, types, "fff")) {
-                self.shader.setUniform3f(uniform, argv[0].*.f, argv[1].*.f, argv[2].*.f);
-            } else if (std.mem.eql(u8, types, "ffff")) {
-                self.shader.setUniform4f(uniform, argv[0].*.f, argv[1].*.f, argv[2].*.f, argv[3].*.f);
-            } else if (std.mem.eql(u8, types, "i")) {
-                self.shader.setUniform1i(uniform, argv[0].*.i);
-            } else {
-                std.debug.warn("unsupported types: {s}\n", .{types});
-            }
+            const name_slice = path["/param/".len .. path.len - "/set".len];
+            // const uniform = self.shader.uniformLocation(name) catch {
+            //     std.debug.warn("param {s} doesn't exist\n", .{uniform_name});
+            //     return 0;
+            // };
+
+            // if (std.mem.eql(u8, types, "f")) {
+            //     self.shader.setUniform1f(uniform, argv[0].*.f);
+            // } else if (std.mem.eql(u8, types, "ff")) {
+            //     self.shader.setUniform2f(uniform, argv[0].*.f, argv[1].*.f);
+            // } else if (std.mem.eql(u8, types, "fff")) {
+            //     self.shader.setUniform3f(uniform, argv[0].*.f, argv[1].*.f, argv[2].*.f);
+            // } else if (std.mem.eql(u8, types, "ffff")) {
+            //     self.shader.setUniform4f(uniform, argv[0].*.f, argv[1].*.f, argv[2].*.f, argv[3].*.f);
+            // } else if (std.mem.eql(u8, types, "i")) {
+            //     self.shader.setUniform1i(uniform, argv[0].*.i);
+            // } else if (std.mem.eql(u8, types, "ii")) {
+            //     self.shader.setUniform2i(uniform, argv[0].*.i, argv[1].*.i);
+            // } else if (std.mem.eql(u8, types, "iii")) {
+            //     self.shader.setUniform3i(uniform, argv[0].*.i, argv[1].*.i, argv[2].*.i);
+            // } else if (std.mem.eql(u8, types, "iiii")) {
+            //     self.shader.setUniform4i(uniform, argv[0].*.i, argv[1].*.i, argv[2].*.i, argv[3].*.i);
+            // } else {
+            //     std.debug.warn("unsupported types: {s}\n", .{types});
+            // }
             return 0;
         }