eessppeelllloo/r_e_c_u_r
1
0
Fork 0
mirror of https://github.com/cyberboy666/r_e_c_u_r.git synced 2025-12-15 04:40:08 +01:00
Code Issues Packages Projects Releases Wiki Activity

working towards shader intergration

Browse Source
This commit is contained in:
langolierz
2018-09-27 16:13:52 +00:00
parent 92a4ced2b8
commit 14d6e4b8bd
8 changed files with 116 additions and 83 deletions
Download Patch File Download Diff File Expand all files Collapse all files

53
actions.py
View File

@@ -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()

22
display_centre/display.py
View File

@@ -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.shaders.selected_status,shader[shad_type], \
shader[shad_index], shader[name][0:26], '--:--' ))
for i in range(shader[param_number]):
self.display_text.insert(END, 'x{}{<2} '.format(i, self.shaders.selected_param_values[i]))
self.display_text.insert(END, '{:<6}:{:<1}{:<2} {:^10} '.format \
(self.shaders.selected_status,shader['shad_type'], \
shader['shad_index'], shader['name'][0:26] ))
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,'\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)

4
display_centre/menu.py
View File

@@ -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)

5
json_objects/keypad_action_mapping.json
View File

@@ -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"]

20
r_e_c_u_r.py
View File

@@ -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)
capture = Capture(tk, message_handler, data)
shaders = Shaders(tk, message_handler, data)
video_driver = VideoDriver(tk, osc_client, message_handler, data)
capture = Capture(tk, osc_client, 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

3
video_centre/capture.py
View File

@@ -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

43
video_centre/shaders.py
View File

@@ -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.generate_shaders_list()
self.shaders_menu.update_open_folders(name)
self.shaders_menu_list = self.generate_shaders_list()

49
video_centre/video_driver.py
View File

@@ -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