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-11 19:00:04 +01:00
Code Issues Packages Projects Releases Wiki Activity

Whitespace

Browse Source
This commit is contained in:
Ryan Jarvis
2020-05-01 11:28:50 -07:00
parent 9ebbb439cb
commit 81a37df50e
31 changed files with 1575 additions and 1600 deletions
Download Patch File Download Diff File Expand all files Collapse all files

133
video_centre/shaders.py
View File

@@ -7,7 +7,7 @@ from data_centre.plugin_collection import ModulationReceiverPlugin
class Shaders(object):
MENU_HEIGHT = 10
EMPTY_SHADER = dict(name='none',is_shader=True,shad_type='-',param_number=4,path='-')
EMPTY_SHADER = dict(name='none', is_shader=True, shad_type='-', param_number=4, path='-')
MAX_MOD_SLOTS = 4
@@ -17,27 +17,27 @@ class Shaders(object):
self.message_handler = message_handler
self.message_handler.shaders = self
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_list = [self.EMPTY_SHADER for i in range(3)]
self.focused_param = 0
self.shaders_menu_list = self.generate_shaders_list()
self.selected_modulation_slot = 0
self.selected_status_list = ['-','-','-'] ## going to try using symbols for this : '-' means empty, '▶' means running, '■' means not running, '!' means error
self.selected_param_list = [[0.0,0.0,0.0,0.0] for i in range(3)]
self.selected_status_list = ['-', '-', '-'] ## going to try using symbols for this : '-' means empty, '▶' means running, '■' means not running, '!' means error
self.selected_param_list = [[0.0, 0.0, 0.0, 0.0] for i in range(3)]
self.selected_speed_list = [1.0, 1.0, 1.0]
self.selected_modulation_slot = 0
#self.modulation_level = [[[0.0,0.0,0.0,0.0] for i in range(4)] for i in range(3)]
self.modulation_value = [0.0] * self.MAX_MOD_SLOTS #,0.0,0.0,0.0]
# self.modulation_level = [[[0.0,0.0,0.0,0.0] for i in range(4)] for i in range(3)]
self.modulation_value = [0.0] * self.MAX_MOD_SLOTS # ,0.0,0.0,0.0]
#self.load_selected_shader()
# self.load_selected_shader()
@property
def modulation_level(self):
return self.data.settings['shader'].setdefault('modulation_level',
[[[0.0,0.0,0.0,0.0] for i in range(4)] for i in range(3)])
return self.data.settings['shader'].setdefault('modulation_level',
[[[0.0, 0.0, 0.0, 0.0] for i in range(4)] for i in range(3)])
def set_modulation_levels(self, levels):
self.data.settings['shader']['modulation_level'] = levels
@@ -51,17 +51,16 @@ class Shaders(object):
has_path, path = self.get_path_for_shader(stripped_name)
shad_type = self.determine_shader_type(path)
parameter_number = self.determine_shader_parameter_number(path)
shaders_menu_list.append(dict(name=line['name'],is_shader=True,shad_type=shad_type,param_number=parameter_number,path=path))
else:
shaders_menu_list.append(dict(name=line['name'],is_shader=False,shad_type='',param_number=None,path=None))
return shaders_menu_list
shaders_menu_list.append(dict(name=line['name'], is_shader=True, shad_type=shad_type, param_number=parameter_number, path=path))
else:
shaders_menu_list.append(dict(name=line['name'], is_shader=False, shad_type='', param_number=None, path=None))
return shaders_menu_list
def get_path_for_shader(self, file_name):
######## returns full path for a given file name ########
for path in self.data.PATHS_TO_SHADERS:
for path in self.data.PATHS_TO_SHADERS:
for root, dirs, files in os.walk(path):
if file_name in files:
return True, '{}/{}'.format(root, file_name)
@@ -69,20 +68,19 @@ class Shaders(object):
def determine_shader_type(self, path):
with open(path, 'r', errors='ignore') as selected_shader:
shader_text = selected_shader.read()
if '//0-input' in shader_text:
return '0in'
elif '//1-input' in shader_text:
return '1in'
elif '//2-input' in shader_text:
return '2in'
else:
return '-'
shader_text = selected_shader.read()
if '//0-input' in shader_text:
return '0in'
elif '//1-input' in shader_text:
return '1in'
elif '//2-input' in shader_text:
return '2in'
else:
return '-'
def determine_shader_parameter_number(self, path):
max_amount = 4
if True: # for now always assume 4 params
if True: # for now always assume 4 params
return max_amount
with open(path, 'r') as selected_shader:
shader_text = selected_shader.read()
@@ -93,9 +91,9 @@ class Shaders(object):
def load_shader_layer(self, layer):
selected_shader = self.selected_shader_list[layer]
#self.selected_param_list[self.data.shader_layer] = [0.0,0.0,0.0,0.0]
# self.selected_param_list[self.data.shader_layer] = [0.0,0.0,0.0,0.0]
print("select shader: ", selected_shader)
self.osc_client.send_message("/shader/{}/load".format(str(layer)), [selected_shader['path'],selected_shader['shad_type'] == '2in',selected_shader['param_number']])
self.osc_client.send_message("/shader/{}/load".format(str(layer)), [selected_shader['path'], selected_shader['shad_type'] == '2in', selected_shader['param_number']])
if not self.selected_status_list[layer] == '▶':
self.selected_status_list[layer] = '■'
@@ -121,7 +119,7 @@ class Shaders(object):
def map_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.shaders_menu_list[index]['name'])
self.shaders_menu_list[index]['name'])
if is_file:
is_successful = self.data.create_new_shader_mapping_in_first_open(name)
if not is_successful:
@@ -133,7 +131,7 @@ class Shaders(object):
selected_shader = self.selected_shader_list[self.data.shader_layer]
index = self.shaders_menu.selected_list_index
is_file, name = self.shaders_menu.extract_file_type_and_name_from_menu_format(
self.shaders_menu_list[index]['name'])
self.shaders_menu_list[index]['name'])
is_selected_shader = False
if is_file and name == selected_shader['name'].lstrip():
is_selected_shader = True
@@ -152,7 +150,7 @@ class Shaders(object):
self.selected_shader_list[layer]['slot'] = slot
self.load_shader_layer(layer)
else:
self.message_handler.set_message('INFO', "shader slot %s:%s is empty"%(layer,slot))
self.message_handler.set_message('INFO', "shader slot %s:%s is empty" % (layer, slot))
def play_this_shader(self, slot):
print(self.data.shader_bank_data[self.data.shader_layer])
@@ -161,15 +159,15 @@ class Shaders(object):
def increase_this_param(self, amount_change):
param = self.focused_param
current_amount = self.selected_param_list[self.data.shader_layer][param]
amount = self.get_new_param_amount(current_amount,amount_change)
amount = self.get_new_param_amount(current_amount, amount_change)
self.set_param_to_amount(param, amount)
def decrease_this_param(self, amount_change):
param = self.focused_param
current_amount = self.selected_param_list[self.data.shader_layer][param]
amount = self.get_new_param_amount(current_amount,-amount_change)
amount = self.get_new_param_amount(current_amount, -amount_change)
self.set_param_to_amount(param, amount)
def toggle_shader_speed(self):
if self.selected_speed_list[self.data.shader_layer] > 0.62:
self.set_speed_to_amount(0.5)
@@ -190,11 +188,11 @@ class Shaders(object):
def select_previous_shader_modulation_slot(self):
self.selected_modulation_slot -= 1
if self.selected_modulation_slot < 0:
self.selected_modulation_slot = self.MAX_MOD_SLOTS-1
self.selected_modulation_slot = self.MAX_MOD_SLOTS - 1
def reset_modulation(self, slot):
for layer in self.modulation_level:
for layer,levels in enumerate(layer):
for layer, levels in enumerate(layer):
levels[slot] = 0.0
def reset_selected_modulation(self):
@@ -206,13 +204,13 @@ class Shaders(object):
return 1
elif current + change < 0:
return 0
else:
else:
return current + change
def set_param_to_amount(self, param, amount, layer_offset=None):
start_layer = self.data.shader_layer
if self.data.settings['shader']['FIX_PARAM_OFFSET_LAYER']['value'] == 'enabled':
start_layer = 0
start_layer = 0
if layer_offset is None:
start_layer = self.data.shader_layer
layer_offset = 0
@@ -222,45 +220,47 @@ class Shaders(object):
def set_param_layer_to_amount(self, param, layer, amount):
if self.data.settings['shader']['X3_AS_SPEED']['value'] == 'enabled' and param == 3:
self.set_speed_layer_to_amount(layer, amount) #layer_offset=layer-self.data.shader_layer)
else:
self.set_speed_layer_to_amount(layer, amount) # layer_offset=layer-self.data.shader_layer)
else:
self.selected_param_list[layer][param] = amount
self.update_param_layer(param,layer)
self.update_param_layer(param, layer)
def get_modulation_value_list(self, amount, values, levels):
l = []
for i,v in enumerate(values):
for i, v in enumerate(values):
l.append(self.get_modulation_value(amount, v, levels[i]))
#print ("got mean %s from amount %s with %s*%s" % (mean(l), amount, values, levels))
# print ("got mean %s from amount %s with %s*%s" % (mean(l), amount, values, levels))
return mean(l)
def get_modulation_value(self, amount, value, level):
if level==0:
if level == 0:
return amount
# TODO: read from list of input formulas, from plugins etc to modulate the value
temp_amount = amount + (value * level)
#print("from amount %s, modulation is %s, temp_amount is %s" % (amount, modulation, temp_amount))
if temp_amount < 0: temp_amount = 0 # input range is 0-1 so convert back
if temp_amount > 1: temp_amount = 1 # modulation however is -1 to +1
# print("from amount %s, modulation is %s, temp_amount is %s" % (amount, modulation, temp_amount))
if temp_amount < 0:
temp_amount = 0 # input range is 0-1 so convert back
if temp_amount > 1:
temp_amount = 1 # modulation however is -1 to +1
return temp_amount
def send_param_layer_amount_message(self, param, layer, amount):
self.osc_client.send_message("/shader/{}/param".format(str(layer)), [param, amount] )
self.osc_client.send_message("/shader/{}/param".format(str(layer)), [param, amount])
def modulate_param_to_amount(self, param, value):
# incoming data here should be in format 0 to 1; needs changing to -1 to +1
self.modulation_value[param] = (value-0.5)*2 # normalise to -1 to +1
self.modulation_value[param] = (value - 0.5) * 2 # normalise to -1 to +1
for plugin in self.data.plugins.get_plugins(ModulationReceiverPlugin):
plugin.set_modulation_value(param, self.modulation_value[param])
for layer,params in enumerate(self.selected_param_list):
for ip,p in enumerate(params):
for p2,v in enumerate(self.modulation_level[layer][ip]):
if v!=0:
self.update_param_layer(ip,layer)
break
for layer, params in enumerate(self.selected_param_list):
for ip, p in enumerate(params):
for p2, v in enumerate(self.modulation_level[layer][ip]):
if v != 0:
self.update_param_layer(ip, layer)
break
def set_param_layer_offset_modulation_level(self, param, layer, level):
layer = (self.data.shader_layer + layer) % 3
@@ -277,12 +277,12 @@ class Shaders(object):
# merge all applicable layers
self.send_param_layer_amount_message(param, layer,
self.get_modulation_value_list(
self.selected_param_list[layer][param],
self.modulation_value,#[0], #param],
self.modulation_level[layer][param]
)
)
self.get_modulation_value_list(
self.selected_param_list[layer][param],
self.modulation_value, # [0], #param],
self.modulation_level[layer][param]
)
)
def set_speed_offset_to_amount(self, layer_offset, amount):
self.set_speed_to_amount(amount, layer_offset)
@@ -290,8 +290,7 @@ class Shaders(object):
def set_speed_to_amount(self, amount, layer_offset=0):
layer = (self.data.shader_layer + layer_offset) % 3
self.set_speed_layer_to_amount(layer, amount)
def set_speed_layer_to_amount(self, layer, amount):
self.osc_client.send_message("/shader/{}/speed".format(str(layer)), amount )
self.osc_client.send_message("/shader/{}/speed".format(str(layer)), amount)
self.selected_speed_list[layer] = amount