reimplement working OSC control

1 files changed, 41 insertions, 29 deletions

diff --git a/src/control.zig b/src/control.zig
index cec6f80..b48feab 100644
--- a/src/control.zig
+++ b/src/control.zig
@@ -7,11 +7,13 @@ const param_prefix = "/param/";
 
 pub const ControlServer = struct {
     server: c.lo_server,
-    shader: gl.ShaderProgram,
+    cache: *gl.UniformCache,
 
-    pub fn init(allocator: *std.mem.Allocator, config: cfg.OSCConfig) !*ControlServer {
+    pub fn init(allocator: *std.mem.Allocator, config: cfg.OSCConfig, cache: *gl.UniformCache) !*ControlServer {
         var self: *ControlServer = try allocator.create(ControlServer);
 
+        self.cache = cache;
+
         switch (config) {
             .Manual => |conf| {
                 var port = [_]u8{0} ** 6;
@@ -40,8 +42,7 @@ pub const ControlServer = struct {
         return self;
     }
 
-    pub fn update(self: *ControlServer, shader: gl.ShaderProgram) void {
-        self.shader = shader;
+    pub fn update(self: *ControlServer) void {
         while (c.lo_server_recv_noblock(self.server, 0) > 0) {}
     }
 
@@ -64,31 +65,42 @@ pub const ControlServer = struct {
                 return 1;
             }
 
-            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});
-            // }
+            const param_name = path["/param/".len .. path.len - "/set".len];
+            var buffer: [256]u8 = undefined;
+            std.mem.copy(u8, buffer[0..], param_name);
+            buffer[param_name.len] = 0;
+
+            if (self.cache.get(buffer[0 .. param_name.len + 1]) catch null) |uniform| {
+                if (std.mem.eql(u8, types, "f")) {
+                    uniform.value.FLOAT = argv[0].*.f;
+                } else if (std.mem.eql(u8, types, "ff")) {
+                    for (uniform.value.FLOAT_VEC2) |*dest, i|
+                        dest.* = argv[i].*.f;
+                } else if (std.mem.eql(u8, types, "fff")) {
+                    for (uniform.value.FLOAT_VEC3) |*dest, i|
+                        dest.* = argv[i].*.f;
+                } else if (std.mem.eql(u8, types, "ffff")) {
+                    for (uniform.value.FLOAT_VEC4) |*dest, i|
+                        dest.* = argv[i].*.f;
+                } else if (std.mem.eql(u8, types, "i")) {
+                    uniform.value.INT = argv[0].*.i;
+                } else if (std.mem.eql(u8, types, "ii")) {
+                    for (uniform.value.INT_VEC2) |*dest, i|
+                        dest.* = argv[i].*.i;
+                } else if (std.mem.eql(u8, types, "iii")) {
+                    for (uniform.value.INT_VEC3) |*dest, i|
+                        dest.* = argv[i].*.i;
+                } else if (std.mem.eql(u8, types, "iiii")) {
+                    for (uniform.value.INT_VEC4) |*dest, i|
+                        dest.* = argv[i].*.i;
+                } else {
+                    std.debug.warn("unsupported types: {s}\n", .{types});
+                    return 0;
+                }
+                uniform.setShaderValue(self.cache.shader.*);
+            } else {
+                std.debug.warn("param {s} doesn't exist\n", .{param_name});
+            }
             return 0;
         }