working towards shader intergration

actions.py

@@ -3,6 +3,12 @@ import tracemalloc
 import data_centre.length_setter as length_setter
 import sys
 import os
+from pythonosc import osc_message_builder
+from pythonosc import dispatcher
+from pythonosc import osc_server
+from pythonosc import dispatcher
+import threading
+import argparse
 
 class Actions(object):
     def __init__(self, tk, message_handler, data, video_driver, capture, shaders, display):
@@ -13,6 +19,7 @@ class Actions(object):
         self.capture = capture
         self.shaders = shaders
         self.display = display
+        self.server = self.setup_osc_server()
         
 
     def move_browser_selection_down(self):
@@ -39,6 +46,15 @@ class Actions(object):
                 else:
                     getattr(self, setting['action'])(setting['value'])
 
+    def move_shaders_selection_down(self):
+        self.shaders.shaders_menu.navigate_menu_down()
+
+    def move_shaders_selection_up(self):
+        self.shaders.shaders_menu.navigate_menu_up()
+
+    def enter_on_shaders_selection(self):
+        self.shaders.enter_on_shaders_selection()
+
     def clear_all_slots(self):
         self.data.clear_all_slots()
         self.display.browser_menu.generate_browser_list()
@@ -81,10 +97,8 @@ class Actions(object):
         self.video_driver.switch_players_and_start_video()
 
     def cycle_display_mode(self):
-        self.display.top_menu_index = 0
-        self.display.selected_list_index = self.display.top_menu_index
         if self.data.settings['other']['VIDEO_BACKEND']['value'] == 'openframeworks':
-            display_modes = [["BROWSER",'NAV_BROWSER'],["SETTINGS",'NAV_SETTINGS'],[ "SAMPLER",'PLAYER'],["SHADERS",'SHAD_BROWSER']]
+            display_modes = [["BROWSER",'NAV_BROWSER'],["SETTINGS",'NAV_SETTINGS'],[ "SAMPLER",'PLAYER'],["SHADERS",'NAV_SHADERS']]
         else:
             display_modes = [["BROWSER",'NAV_BROWSER'],["SETTINGS",'NAV_SETTINGS'],[ "SAMPLER",'PLAYER']]
 
@@ -194,6 +208,12 @@ class Actions(object):
         else:
             self.message_handler.set_message('INFO', 'cant mirror in dev mode')
 
+    def toggle_shaders(self):
+        if self.shaders.selected_status == 'RUNNING':
+            self.shaders.stop_selected_shader()
+        else:
+            self.shaders.start_selected_shader()
+
     def toggle_player_mode(self):
         if self.data.player_mode == 'now':
             self.data.player_mode = 'next'
@@ -345,7 +365,7 @@ class Actions(object):
 
     def quit_the_program(self):
         self.video_driver.exit_all_players()
-        self.video_driver.exit_osc_server('','')
+        self.exit_osc_server('','')
         self.toggle_x_autorepeat()
         self.tk.destroy()
 
@@ -371,7 +391,30 @@ class Actions(object):
         self.display.settings_menu.generate_settings_list()
 
 
+    def setup_osc_server(self):
+        server_parser = argparse.ArgumentParser()
+        server_parser.add_argument("--ip", default="127.0.0.1", help="the ip")
+        server_parser.add_argument("--port", type=int, default=9000, help="the port")
 
+        server_args = server_parser.parse_args()
+
+        this_dispatcher = dispatcher.Dispatcher()
+        this_dispatcher.map("/player/a/position", self.video_driver.receive_position, "a.a")
+        this_dispatcher.map("/player/b/position", self.video_driver.receive_position, "b.b")
+        this_dispatcher.map("/player/c/position", self.video_driver.receive_position, "c.c")
+        this_dispatcher.map("/player/a/status", self.video_driver.receive_status, "a.a")
+        this_dispatcher.map("/player/b/status", self.video_driver.receive_status, "b.b")
+        this_dispatcher.map("/player/c/status", self.video_driver.receive_status, "c.c")
+        this_dispatcher.map("/shutdown", self.exit_osc_server)
+        #this_dispatcher.map("/player/a/status", self.set_status)
+
+        server = osc_server.ThreadingOSCUDPServer((server_args.ip, server_args.port), this_dispatcher)
+        server_thread = threading.Thread(target=server.serve_forever)
+        server_thread.start()
+        return server
+
+    def exit_osc_server(self, unused_addr, args):
+        self.server.shutdown()
 
         
         

display_centre/display.py

@@ -148,27 +148,25 @@ class Display(object):
         self.display_text.tag_add("DISPLAY_MODE", 4.19, 4.28)
         ## showing current shader info:
         shader = self.shaders.selected_shader
-        self.display_text.insert(END, '{<6}:{<1}{<2} {^26} {<4}:{^5} \n'.format \
+        self.display_text.insert(END, '{:<6}:{:<1}{:<2} {:^10} '.format \
-            (self.shaders.selected_status,shader[shad_type], \
+            (self.shaders.selected_status,shader['shad_type'], \
-            shader[shad_index], shader[name][0:26], '--:--' ))
+            shader['shad_index'], shader['name'][0:26] ))
-        for i in range(shader[param_number]):
+        for i in range(min(4,shader['param_number'])):
-            self.display_text.insert(END, 'x{}{<2} '.format(i, self.shaders.selected_param_values[i]))
+            self.display_text.insert(END, 'x{}:{:<2} '.format(i, self.shaders.selected_param_values[i]))
         self.display_text.insert(END,'\n')
-        self.display_text.tag_add("COLUMN_NAME", 5.0, 7.0)
+        self.display_text.tag_add("COLUMN_NAME", 5.0, 6.0)
         ## showing list of other shaders:
         shaders_list = self.shaders.shaders_menu_list
         number_of_shader_items = len(shaders_list)
-        shader_menu_height = self.MENU_HEIGHT - 1
         for index in range(number_of_shader_items):
-            if line_count > shader_menu_height :
+            if line_count > self.MENU_HEIGHT :
                 break
             if index >= self.shaders.shaders_menu.top_menu_index:
                 shader_line = shaders_list[index]
-                self.display_text.insert(END, '{:<30} {<2}'.format(shader_line['name'][0:30], shader_line['shad_type']))
+                self.display_text.insert(END, '{:<40} {:<5} \n'.format(shader_line['name'][0:30], shader_line['shad_type']))
                 line_count = line_count + 1
-        for index in range(shader_menu_height - number_of_shader_items):
+        for index in range(self.MENU_HEIGHT - number_of_shader_items):
             self.display_text.insert(END, '\n')        
-
         self._highlight_this_row(self.shaders.shaders_menu.selected_list_index - self.shaders.shaders_menu.top_menu_index)
 
 
@@ -250,7 +248,7 @@ class Display(object):
             banner_list[0] = '<'
         elif position > end:
             banner_list[max] = '>'
-        elif end - start != 0 and position:
+        elif end - start != 0 and not math.isnan(position) :
             print('start value is {}, end value is {}, position is {}'.format(start, end, position))
             marker = int(math.floor(float(position - start) /
                                     float(end - start) * (max - 1)) + 1)

display_centre/menu.py

@@ -171,6 +171,8 @@ class ShadersMenu(Menu):
 
     def __init__(self, data, message_handler, menu_height):
         Menu.__init__(self, data, message_handler, menu_height)
+        #self.top_menu_index = 1
+        #self.selected_list_index = 1
 
     def generate_raw_shaders_list(self):
         ######## starts the recursive process of listing all folders and shader files to display ########
@@ -192,7 +194,7 @@ class ShadersMenu(Menu):
             if (is_open):
                 next_path = '{}/{}'.format(root, folder)
                 next_level = current_level + 1
-                self._add_folder_to_shader_list(next_path, next_level)
+                self._add_folder_to_shaders_list(next_path, next_level)
 
         for f in files:
             split_name = os.path.splitext(f)

json_objects/keypad_action_mapping.json

@@ -3,18 +3,21 @@
 		"NAV_BROWSER": ["move_browser_selection_up"],
 		"PLAYER": ["seek_back_on_player"],
 		"NAV_SETTINGS": ["move_settings_selection_up"],
+		"NAV_SHADERS": ["move_shaders_selection_up"],
         "LENGTH_SET": ["return_to_default_control_mode"]
 	},
 	"b": {
 		"NAV_BROWSER": ["move_browser_selection_down"],
 		"PLAYER": ["seek_forward_on_player"],
 		"NAV_SETTINGS": ["move_settings_selection_down"],
+		"NAV_SHADERS": ["move_shaders_selection_down"],
         "LENGTH_SET": ["return_to_default_control_mode"]
 	},
 	"c": {
 		"NAV_BROWSER": ["enter_on_browser_selection"],
 		"PLAYER": ["toggle_action_on_player","toggle_show_on_player"],
 		"NAV_SETTINGS": ["enter_on_settings_selection"],
+		"NAV_SHADERS": ["enter_on_shaders_selection"],
         "LENGTH_SET": ["record_fixed_length"]
 	},
 	"d": {
@@ -53,7 +56,7 @@
 		"DEFAULT": ["load_slot_5_into_next_player","toggle_screen_mirror"]
 	},
 	"p": {
-		"DEFAULT": ["load_slot_6_into_next_player"]
+		"DEFAULT": ["load_slot_6_into_next_player","toggle_shaders"]
 	},
 	"q": {
 		"DEFAULT": ["load_slot_7_into_next_player"]

r_e_c_u_r.py

@@ -4,6 +4,8 @@ import traceback
 from tkinter import Tk, Frame
 import sys
 import tracemalloc
+import argparse
+from pythonosc import udp_client
 
 from actions import Actions
 from data_centre.data import Data
@@ -29,10 +31,20 @@ message_handler = MessageHandler()
 
 data = Data(message_handler)
 
+def setup_osc_client():
+    client_parser = argparse.ArgumentParser()
+    client_parser.add_argument("--ip", default="127.0.0.1", help="the ip")
+    client_parser.add_argument("--port", type=int, default=8000, help="the port")
+
+    client_args = client_parser.parse_args()
+
+    return udp_client.SimpleUDPClient(client_args.ip, client_args.port)
+
+osc_client = setup_osc_client()
 # setup the video driver
-video_driver = VideoDriver(tk, message_handler, data)
+video_driver = VideoDriver(tk, osc_client, message_handler, data)
-capture = Capture(tk, message_handler, data)
+capture = Capture(tk, osc_client, message_handler, data)
-shaders = Shaders(tk, message_handler, data)
+shaders = Shaders(tk, osc_client, message_handler, data)
 
 # setup the display
 display = Display(tk, video_driver, capture, shaders, message_handler, data)
@@ -55,6 +67,8 @@ def handle_error(exc, val, tb):
     print('traceback for error : {}'.format(traceback.format_exc()))
     message_handler.set_message('ERROR', val, traceback.format_exc())
 
+
+
 tk.report_callback_exception = handle_error
 
 

video_centre/capture.py

@@ -7,8 +7,9 @@ import fractions
 class Capture(object):
     PREVIEW_LAYER = 255
 
-    def __init__(self, root, message_handler, data):
+    def __init__(self, root, osc_client, message_handler, data):
         self.root = root
+        self.osc_client = osc_client
         self.message_handler = message_handler
         self.data = data
         

video_centre/shaders.py

@@ -2,22 +2,23 @@ import display_centre.menu as menu
 import os
 
 class Shaders(object):
-    MENU_HEIGHT = 9
+    MENU_HEIGHT = 10
     EMPTY_SHADER = dict(name='none',is_shader=True,shad_type='-',param_number=0,path='-',shad_index=0)
-    def __init__(self, root, message_handler, data):
+    def __init__(self, root, osc_client, message_handler, data):
         self.root = root
+        self.osc_client = osc_client
         self.message_handler = message_handler
         self.data = data
-        self.shaders_menu = menu.ShadersMenu(self.data, self.message_handler, self.MENU_HEIGHT)
+        self.shaders_menu = menu.ShadersMenu(self.data, self.message_handler, self.MENU_HEIGHT )
         self.selected_shader = self.EMPTY_SHADER
         self.shaders_menu_list = self.generate_shaders_list()
-        print('shader list is {}'.format(self.shaders_menu_list))
+        print(self.shaders_menu_list)
-
+        if self.shaders_menu_list is not None:
-        #
+            pass
-        
+                 
         self.selected_status = '-'
         self.selected_param_values = [0,0,0,0,0,0,0,0]
-        self.load_selected_shader()
+        #self.load_selected_shader()
 
     def generate_shaders_list(self):
         shaders_menu_list = []
@@ -32,7 +33,7 @@ class Shaders(object):
                 shaders_menu_list.append(dict(name=line['name'],is_shader=True,shad_type=shad_type,param_number=parameter_number,path=path,shad_index=shad_i))
                 shad_i = shad_i +1
             else:
-                shaders_menu_list.append(dict(name=line[name],is_shader=False,is_proc=None,param_number=None,path=None))
+                shaders_menu_list.append(dict(name=line['name'],is_shader=False,shad_type='',param_number=None,path=None,shad_index=None))
         return shaders_menu_list
 
 
@@ -45,19 +46,31 @@ class Shaders(object):
         return False, ''
 
     def determine_if_shader_file_is_processing(self, path):
-        pass
+        return True
 
     def determine_shader_parameter_number(self, path):
-        pass
+        return 4
 
     def load_selected_shader(self):
-        pass
+        print(self.selected_shader)
+        is_proc = self.selected_shader['shad_type'] == 'p'
+        self.osc_client.send_message("/shader/load", [self.selected_shader['path'],is_proc,self.selected_shader['param_number']])
+
+    def start_selected_shader(self):
+        self.osc_client.send_message("/shader/start", True)
+        self.selected_status = 'RUNNING'
+
+    def stop_selected_shader(self):
+        self.osc_client.send_message("/shader/stop", True)
+        self.selected_status = 'READY'
 
     def enter_on_shaders_selection(self):
+        index = self.shaders_menu.selected_list_index
         is_file, name = self.shaders_menu.extract_file_type_and_name_from_menu_format(
-            self.menu_list[self.selected_list_index]['name'])
+            self.shaders_menu_list[index]['name'])
         if is_file:
-            pass
+            self.selected_shader = self.shaders_menu_list[index]
+            self.load_selected_shader()
         else:
-            self.shader_menu.update_open_folders(name)
+            self.shaders_menu.update_open_folders(name)
-        self.generate_shaders_list()
+        self.shaders_menu_list = self.generate_shaders_list()

video_centre/video_driver.py

@@ -1,19 +1,13 @@
 from video_centre.video_player import VideoPlayer
 from video_centre.alt_video_player import AltVideoPlayer
 
-from pythonosc import osc_message_builder
-from pythonosc import udp_client
-from pythonosc import dispatcher
-from pythonosc import osc_server
-import argparse
-import threading
-
 class VideoDriver(object):
 
     MAX_LAYER = 254
 
-    def __init__(self, root, message_handler, data):
+    def __init__(self, root, osc_client, message_handler, data):
         self.root = root
+        self.osc_client = osc_client
         self.message_handler = message_handler
         self.data = data
         self.delay = 50
@@ -21,9 +15,6 @@ class VideoDriver(object):
         self.in_current_playing_cycle = False
         self.in_next_load_cycle = False
         
-        self.server = self.setup_osc_server()
-        self.osc_client = self.setup_osc_client()
-
         self.layer = self.MAX_LAYER
 
         if(self.data.settings['other']['VIDEO_BACKEND']['value'] == 'openframeworks'):
@@ -135,40 +126,6 @@ class VideoDriver(object):
     def exit_last_player_after_delay(self):
         self.root.after(100, self.last_player.exit)
 
-    def setup_osc_client(self):
-        client_parser = argparse.ArgumentParser()
-        client_parser.add_argument("--ip", default="127.0.0.1", help="the ip")
-        client_parser.add_argument("--port", type=int, default=8000, help="the port")
-
-        client_args = client_parser.parse_args()
-
-        return udp_client.SimpleUDPClient(client_args.ip, client_args.port)
-
-    def setup_osc_server(self):
-        server_parser = argparse.ArgumentParser()
-        server_parser.add_argument("--ip", default="127.0.0.1", help="the ip")
-        server_parser.add_argument("--port", type=int, default=9000, help="the port")
-
-        server_args = server_parser.parse_args()
-
-        this_dispatcher = dispatcher.Dispatcher()
-        this_dispatcher.map("/player/a/position", self.receive_position, "a.a")
-        this_dispatcher.map("/player/b/position", self.receive_position, "b.b")
-        this_dispatcher.map("/player/c/position", self.receive_position, "c.c")
-        this_dispatcher.map("/player/a/status", self.receive_status, "a.a")
-        this_dispatcher.map("/player/b/status", self.receive_status, "b.b")
-        this_dispatcher.map("/player/c/status", self.receive_status, "c.c")
-        this_dispatcher.map("/shutdown", self.exit_osc_server)
-        #this_dispatcher.map("/player/a/status", self.set_status)
-
-        server = osc_server.ThreadingOSCUDPServer((server_args.ip, server_args.port), this_dispatcher)
-        server_thread = threading.Thread(target=server.serve_forever)
-        server_thread.start()
-        return server
-
-    def exit_osc_server(self, unused_addr, args):
-        self.server.shutdown()
-
     def receive_position(self, unused_addr, player_name, args):
         print("the position of  player {} is set to {}".format(player_name,args))
         for player in [self.next_player, self.current_player, self.last_player]:
@@ -182,3 +139,5 @@ class VideoDriver(object):
             if player_name[0] in player.name:
                 player.status = args
                 break
+
+