From 9739f4c03cc67005f3625ff18cc71efa6dc4367d Mon Sep 17 00:00:00 2001 From: Tristan Rowley Date: Tue, 10 Mar 2020 23:47:16 +0000 Subject: [PATCH] helper functions for getting variables from ManipulatePlugin into other parts of recur code --- data_centre/plugin_collection.py | 8 ++ plugins/ManipulatePlugin.py | 6 + plugins/SoundReactPlugin.py | 2 + plugins/WJSendPlugin.py | 15 ++- plugins/frame_manager.py.backup | 200 +++++++++++++++++++++++++++++++ 5 files changed, 227 insertions(+), 4 deletions(-) create mode 100644 plugins/frame_manager.py.backup diff --git a/data_centre/plugin_collection.py b/data_centre/plugin_collection.py index 5cf6fa7..c82855f 100644 --- a/data_centre/plugin_collection.py +++ b/data_centre/plugin_collection.py @@ -520,3 +520,11 @@ class PluginCollection(object): # For each sub directory, apply the walk_package method recursively for child_pkg in child_pkgs: self.walk_package(package + '.' + child_pkg)""" + + + ## helpers + def get_variable(self, varname, default=0.0): + from plugins.ManipulatePlugin import ManipulatePlugin + plugin = self.get_plugins(ManipulatePlugin) + if plugin is not None: + return plugin[0].get_variable(varname, default) diff --git a/plugins/ManipulatePlugin.py b/plugins/ManipulatePlugin.py index 4111f33..cf70d97 100644 --- a/plugins/ManipulatePlugin.py +++ b/plugins/ManipulatePlugin.py @@ -103,6 +103,12 @@ class ManipulatePlugin(ActionsPlugin,DisplayPlugin,ModulationReceiverPlugin): if self.DEBUG: print("ManipulatePlugin>> set_variable (%s) to %s" % (var_name, value)) self.variables[var_name] = value + def get_variable(self, var_name, default): + if var_name in self.variables: + return self.variables[var_name] + else: + return default + def recall_variable(self, var_name, action, *args): if self.DEBUG: print ("ManipulatePlugin>> recall_variable (%s) as %s" % (var_name,args)) self.pc.actions.call_method_name( diff --git a/plugins/SoundReactPlugin.py b/plugins/SoundReactPlugin.py index 6c1c151..c9ec03a 100644 --- a/plugins/SoundReactPlugin.py +++ b/plugins/SoundReactPlugin.py @@ -28,6 +28,8 @@ class SoundReactPlugin(ActionsPlugin,SequencePlugin,DisplayPlugin): config = {} + # TODO: save + reload current config + def __init__(self, plugin_collection): super().__init__(plugin_collection) diff --git a/plugins/WJSendPlugin.py b/plugins/WJSendPlugin.py index bb21cd2..356091e 100644 --- a/plugins/WJSendPlugin.py +++ b/plugins/WJSendPlugin.py @@ -10,6 +10,8 @@ class WJSendPlugin(ActionsPlugin, SequencePlugin, DisplayPlugin, ModulationRecei active = True + sleep = 0.0 + PRESET_FILE_NAME = "WJSendPlugin/presets.json" presets = {} # from http://depot.univ-nc.nc/sources/boxtream-0.9999/boxtream/switchers/panasonic.py @@ -117,9 +119,9 @@ class WJSendPlugin(ActionsPlugin, SequencePlugin, DisplayPlugin, ModulationRecei continue for queue,cmd in sorted(to_send.items(),reverse=True): - #self.send_buffered(cmd['queue'], cmd['form'], [x for x in [ cmd['arguments'][y] for y in cmd['arg_names'] ] ], record=False) + self.send_buffered(cmd['queue'], cmd['form'], [x for x in [ cmd['arguments'][y] for y in cmd['arg_names'] ] ], record=False) #with self.queue_lock: - self.send(cmd['queue'], cmd['form'], [x for x in [ cmd['arguments'][y] for y in cmd['arg_names'] ] ]) + #self.send(cmd['queue'], cmd['form'], [x for x in [ cmd['arguments'][y] for y in cmd['arg_names'] ] ]) #methods for DisplayPlugin def show_plugin(self, display, display_mode): @@ -187,10 +189,15 @@ class WJSendPlugin(ActionsPlugin, SequencePlugin, DisplayPlugin, ModulationRecei print("WJSendPlugin>> sending string %s " % string) output = b'\2' + string.encode('ascii') + b'\3' #with self.serial_lock: + #self.ser.write(b'\2\2\2\2\3\3\3\3') self.ser.write(output) #.encode()) # TODO: sleeping here seems to help serial response lag problem? - import time - time.sleep(0.02) + self.sleep = 0.25 #self.pc.get_variable('A') + print ("got sleep %s" % self.sleep) + if self.sleep>=0.1: + print("using sleep %s" % self.sleep) + import time + time.sleep(self.sleep/10.0) #yield from self.ser.drain() if self.DEBUG: print("send_serial_string: sent string '%s'" % output) #.encode('ascii')) diff --git a/plugins/frame_manager.py.backup b/plugins/frame_manager.py.backup new file mode 100644 index 0000000..be916d0 --- /dev/null +++ b/plugins/frame_manager.py.backup @@ -0,0 +1,200 @@ + # methods for helping dealing with storing and recalling shader parameter frame states + def get_live_frame(self): + #print("get_live_frame: %s" % self.pc.message_handler.shaders.selected_param_list) + import copy #from copy import deepcopy + frame = { + 'selected_shader_slots': [ shader.get('slot',None) for shader in self.selected_shader_list ], + 'shader_params': copy.deepcopy(self.selected_param_list), + 'layer_active_status': copy.deepcopy(self.selected_status_list), + 'feedback_active': self.data.feedback_active, + 'x3_as_speed': self.data.settings['shader']['X3_AS_SPEED']['value'], + 'shader_speeds': copy.deepcopy(self.selected_speed_list), + 'strobe_amount': self.data.settings['shader']['STROBE_AMOUNT']['value'] / 10.0 + } + #print("built frame: %s" % frame['shader_params']) + return frame + + def recall_frame_params(self, preset): + if preset is None: + return + #print("recall_frame_params got: %s" % preset.get('shader_params')) + for (layer, param_list) in enumerate(preset.get('shader_params',[])): + if param_list: + for param,value in enumerate(param_list): + #if (ignored is not None and ignored['shader_params'][layer][param] is not None): + # print ("ignoring %s,%s because value is %s" % (layer,param,ignored['shader_params'][layer][param])) + # continue + if (value is not None): + #print("recalling layer %s param %s: value %s" % (layer,param,value)) + self.data.plugins.actions.call_method_name('set_the_shader_param_%s_layer_%s_continuous' % (param,layer), value) + + if preset.get('feedback_active') is not None: + self.data.feedback_active = preset.get('feedback_active',self.data.feedback_active) + if self.data.feedback_active: + self.data.plugins.actions.call_method_name('enable_feedback') + else: + self.data.plugins.actions.call_method_name('disable_feedback') + + if preset.get('x3_as_speed') is not None: + self.data.settings['shader']['X3_AS_SPEED']['value'] = preset.get('x3_as_speed',self.data.settings['shader']['X3_AS_SPEED']['value']) + """if self.data.settings['shader']['X3_AS_SPEED']['value']: + self.data.plugins.actions.call_method_name('enable_x3_as_speed') + else: + self.data.plugins.actions.call_method_name('disable_x3_as_speed')""" + + for (layer, speed) in enumerate(preset.get('shader_speeds',[])): + if speed is not None: + self.data.plugins.actions.call_method_name('set_shader_speed_layer_%s_amount' % layer, speed) + + if preset.get('strobe_amount') is not None: + self.data.plugins.actions.set_strobe_amount_continuous(preset.get('strobe_amount')) + + def recall_frame(self, preset): + + self.data.settings['shader']['X3_AS_SPEED']['value'] = preset.get('x3_as_speed') + + # x3_as_speed affects preset recall, so do that first + self.recall_frame_params(preset) + + for (layer, slot) in enumerate(preset.get('selected_shader_slots',[])): + if slot is not None: + #print("setting layer %s to slot %s" % (layer, slot)) + self.data.plugins.actions.call_method_name('play_shader_%s_%s' % (layer, slot)) + + for (layer, active) in enumerate(preset.get('layer_active_status',[])): + # print ("got %s layer with status %s " % (layer,active)) + if active=='▶': + self.data.plugins.actions.call_method_name('start_shader_layer_%s' % layer) + else: + self.data.plugins.actions.call_method_name('stop_shader_layer_%s' % layer) + + DEBUG_FRAMES = False + + # overlay frame2 on frame1 + def merge_frames(self, frame1, frame2): + from copy import deepcopy + f = deepcopy(frame1) #frame1.copy() + if self.DEBUG_FRAMES: print("merge_frames: got frame1\t%s" % frame1) + if self.DEBUG_FRAMES: print("merge_frames: got frame2\t%s" % frame2) + for i,f2 in enumerate(frame2['shader_params']): + for i2,p in enumerate(f2): + if p is not None: + f['shader_params'][i][i2] = p + + if frame2['feedback_active'] is not None: + f['feedback_active'] = frame2['feedback_active'] + + if frame2['x3_as_speed'] is not None: + f['x3_as_speed'] = frame2['x3_as_speed'] + + if f.get('shader_speeds') is None: + f['shader_speeds'] = frame2.get('shader_speeds') + else: + for i,s in enumerate(frame2['shader_speeds']): + if s is not None: + f['shader_speeds'][i] = s + + if frame2.get('strobe_amount'): + f['strobe_amount'] = frame2.get('strobe_amount') + + if self.DEBUG_FRAMES: print("merge_frames: got return\t%s" % f) + return f + + def get_frame_ignored(self, frame, ignored): + from copy import deepcopy + f = deepcopy(frame) #frame1.copy() + if self.DEBUG_FRAMES: print("get_frame_ignored: got frame\t%s" % frame) + for i,f2 in enumerate(frame['shader_params']): + for i2,p in enumerate(f2): + if ignored['shader_params'][i][i2] is not None: + f['shader_params'][i][i2] = None + if ignored.get('feedback_active') is not None: + f['feedback_active'] = None + if ignored.get('x3_as_speed') is not None: + f['x3_as_speed'] = None + if ignored.get('shader_speeds') is not None and frame.get('shader_speeds'): + for i,s in enumerate(frame.get('shader_speeds')): + if ignored['shader_speeds'][i] is not None: + f['shader_speeds'][i] = None + if ignored.get('strobe_amount') is not None: + f['strobe_amount'] = None + if self.DEBUG_FRAMES: print("get_frame_ignored: got return\t%s" % f) + return f + + def is_frame_empty(self, frame): + #from copy import deepcopy + #f = deepcopy(frame) #frame1.copy() + if self.DEBUG_FRAMES: print("is_frame_empty: got frame\t%s" % frame) + + if frame.get('feedback_active') is not None: + return False + if frame.get('x3_as_speed') is not None: + return False + if frame.get('strobe_amount') is not None: + return False + + for i,f in enumerate(frame['shader_params']): + for i2,p in enumerate(f): + if p is not None: #ignored['shader_params'][i][i2] is not None: + return False + + if frame.get('shader_speeds') is not None: + for i,f in enumerate(frame['shader_speeds']): + if f is not None: + return False + + if self.DEBUG_FRAMES: print("is_frame_empty: got return true") + return True + + + def get_frame_diff(self, last_frame, current_frame): + if not last_frame: return current_frame + + if self.DEBUG_FRAMES: + print(">>>>get_frame_diff>>>>") + print("last_frame: \t%s" % last_frame['shader_params']) + print("current_frame: \t%s" % current_frame['shader_params']) + + param_values = [[None]*4,[None]*4,[None]*4] + for layer,params in enumerate(current_frame.get('shader_params',[[None]*4]*3)): + #if self.DEBUG_FRAMES: print("got layer %s params: %s" % (layer, params)) + for param,p in enumerate(params): + if p is not None and p != last_frame.get('shader_params')[layer][param]: + if self.DEBUG_FRAMES: print("setting layer %s param %s to %s" % (layer,param,p)) + param_values[layer][param] = p + + if current_frame['feedback_active'] is not None and last_frame['feedback_active'] != current_frame['feedback_active']: + feedback_active = current_frame['feedback_active'] + else: + feedback_active = None + + if current_frame['x3_as_speed'] is not None and last_frame['x3_as_speed'] != current_frame['x3_as_speed']: + x3_as_speed = current_frame['x3_as_speed'] + else: + x3_as_speed = None + + speed_values = [None]*3 + for layer,param in enumerate(current_frame.get('shader_speeds',[None]*3)): + if param is not None and param != last_frame['shader_speeds'][layer]: + speed_values[layer] = param + + if current_frame['strobe_amount'] is not None and last_frame['strobe_amount'] != current_frame['strobe_amount']: + strobe_amount = current_frame['strobe_amount'] + else: + strobe_amount = None + + if self.DEBUG_FRAMES: + print("param_values is\t%s" % param_values) + print("speed_values is\t%s" % speed_values) + + diff = { + 'shader_params': param_values, + 'feedback_active': feedback_active, + 'x3_as_speed': x3_as_speed, + 'shader_speeds': speed_values, + 'strobe_amount': strobe_amount, + } + if self.DEBUG_FRAMES: print("returning\t%s\n^^^^" % diff['shader_params']) + + return diff +