diff --git a/data_centre/plugin_collection.py b/data_centre/plugin_collection.py index 56dd144..d162097 100644 --- a/data_centre/plugin_collection.py +++ b/data_centre/plugin_collection.py @@ -3,6 +3,7 @@ import os import pkgutil import re +from plugins.frame_manager import FrameManager, Frame class Plugin(object): """Base class that each plugin must inherit from. within this class @@ -210,16 +211,16 @@ class DisplayPlugin(Plugin): def __init__(self, plugin_collection): super().__init__(plugin_collection) - def is_handled(self, name): + def is_handled(self, name): raise NotImplementedError - def get_display_modes(self): + def get_display_modes(self): raise NotImplementedError - def show_plugin(self, display): - from tkinter import Text, END - #display_text.insert(END, 'test from DisplayPlugin') - display.display_text.insert(END, '{} \n'.format(display.body_title)) + def show_plugin(self, display): + from tkinter import Text, END + #display_text.insert(END, 'test from DisplayPlugin') + display.display_text.insert(END, '{} \n'.format(display.body_title)) class ModulationReceiverPlugin(Plugin): def __init__(self, plugin_collection): @@ -259,6 +260,8 @@ class PluginCollection(object): #self.actions = message_handler.actions self.reload_plugins() + self.fm = FrameManager(self) + def read_json(self, file_name): return self.data._read_plugin_json(file_name) def update_json(self, file_name, data): diff --git a/plugins/ShaderLoopRecordPlugin.py b/plugins/ShaderLoopRecordPlugin.py index 65dc369..c986610 100644 --- a/plugins/ShaderLoopRecordPlugin.py +++ b/plugins/ShaderLoopRecordPlugin.py @@ -1,16 +1,36 @@ import data_centre.plugin_collection from data_centre.plugin_collection import ActionsPlugin, SequencePlugin +from plugins.frame_manager import Frame class ShaderLoopRecordPlugin(ActionsPlugin,SequencePlugin): disabled = False MAX_CLIPS = 8 + frames = [] def __init__(self, plugin_collection): super().__init__(plugin_collection) self.PRESET_FILE_NAME = "ShaderLoopRecordPlugin/frames.json" - self.frames = self.load_presets() + #TODO: this doesnt work + """self.frames = [ + [ + Frame(self.pc).store_copy(f) + for f in [ + z for z in [ + frame for frame in [ + clip for clip in self.load_presets() + ] + ] + ] + ] + ]""" + for clip in self.load_presets(): + c = [] + for frame in clip: + c.append(Frame(self.pc).store_copy(frame)) + self.frames.append(c) + self.reset_ignored() def load_presets(self): @@ -71,7 +91,7 @@ class ShaderLoopRecordPlugin(ActionsPlugin,SequencePlugin): self.save_presets() def get_empty_clip(self, duration = 2000): - return [{}] * (int(duration / self.frequency)) + return [None] * (int(duration / self.frequency)) def get_factory_reset(self): return [ self.get_empty_clip(self.duration) for i in range(self.MAX_CLIPS) ] @@ -99,10 +119,10 @@ class ShaderLoopRecordPlugin(ActionsPlugin,SequencePlugin): def reset_ignored(self): # print("!!!!resetting ignored") - self.ignored = { 'shader_params': [[None]*4,[None]*4,[None]*4] } + self.ignored = Frame(self.pc).store_copy({ 'shader_params': [[None]*4,[None]*4,[None]*4] }) def is_ignoring(self): - return not self.pc.shaders.is_frame_empty(self.ignored) + return not self.pc.fm.is_frame_empty(self.ignored) def select_clip(self, clip): self.selected_clip = clip @@ -128,7 +148,7 @@ class ShaderLoopRecordPlugin(ActionsPlugin,SequencePlugin): if self.DEBUG_FRAMES: print (">>>>>>>>>>>>>>frame at %i%%: %i" % (position*100, current_frame_index)) #print("got frame index %s" % current_frame_index) - current_frame = self.pc.shaders.get_live_frame().copy() + current_frame = self.pc.fm.get_live_frame() #.copy() selected_clip = self.selected_clip if self.DEBUG_FRAMES: print("current_frame copy before recall is %s" % current_frame['shader_params']) @@ -141,25 +161,26 @@ class ShaderLoopRecordPlugin(ActionsPlugin,SequencePlugin): for selected_clip in self.running_clips: saved_frame = self.frames[selected_clip][current_frame_index] if not self.recording or (selected_clip!=self.selected_clip): - self.pc.shaders.recall_frame(saved_frame) + self.pc.fm.recall_frame(saved_frame) if self.recording and selected_clip==self.selected_clip: if self.last_frame is None: self.last_frame = current_frame if self.DEBUG_FRAMES: print("last frame is \t\t%s" % self.last_frame['shader_params']) if self.DEBUG_FRAMES: print("current f is \t\t%s" % current_frame['shader_params']) - diff = self.pc.shaders.get_frame_diff(self.last_frame,current_frame) + diff = self.pc.fm.get_frame_diff(self.last_frame,current_frame) if self.DEBUG_FRAMES: print("diffed frame is \t%s" % diff['shader_params']) if self.overdub and saved_frame: # add the params tweaked this frame to the params to be ignored by recall if self.DEBUG_FRAMES: print("saved frame is \t%s" % saved_frame['shader_params']) - self.ignored = self.pc.shaders.merge_frames(self.ignored, diff) - diff = self.pc.shaders.merge_frames( - self.pc.shaders.get_frame_ignored(saved_frame, self.ignored), + self.ignored = self.pc.fm.merge_frames(self.ignored, diff) + print("about to call get_ignored_frames with %s\n and\n %s" % (saved_frame.f, self.ignored.f)) + diff = self.pc.fm.merge_frames( + self.pc.fm.get_frame_ignored(saved_frame, self.ignored), diff ) #diff = self.pc.shaders.merge_frames(self.pc.shaders.get_live_frame(), diff) - self.pc.shaders.recall_frame(diff) + self.pc.fm.recall_frame(diff) if self.DEBUG_FRAMES: print("after diff2 is: \t%s" % diff['shader_params']) if self.DEBUG_FRAMES: print("||||saving frame \t%s" % (diff['shader_params'])) self.frames[selected_clip][current_frame_index] = diff #self.get_frame_diff(self.last_frame,current_frame) @@ -170,7 +191,7 @@ class ShaderLoopRecordPlugin(ActionsPlugin,SequencePlugin): if self.DEBUG_FRAMES:print("backfilling frame %s" % ((self.last_saved_index+i+1)%len(self.frames[selected_clip]))) self.frames[selected_clip][(self.last_saved_index+i+1)%len(self.frames[selected_clip])] = diff self.last_saved_index = current_frame_index - self.last_frame = self.pc.shaders.get_live_frame() #diff + self.last_frame = self.pc.fm.get_live_frame() #diff if self.DEBUG_FRAMES: print("<<<<<<<<<<<<<< frame at %s" % current_frame_index) """def recall_frame_index(self, index): diff --git a/plugins/ShaderQuickPresetPlugin.py b/plugins/ShaderQuickPresetPlugin.py index 3724760..dfb359e 100644 --- a/plugins/ShaderQuickPresetPlugin.py +++ b/plugins/ShaderQuickPresetPlugin.py @@ -1,6 +1,7 @@ import data_centre.plugin_collection from data_centre.plugin_collection import ActionsPlugin, SequencePlugin import copy +from plugins.frame_manager import Frame class ShaderQuickPresetPlugin(ActionsPlugin): #,SequencePlugin): disabled = False @@ -19,7 +20,7 @@ class ShaderQuickPresetPlugin(ActionsPlugin): #,SequencePlugin): def load_presets(self): print("trying load presets? %s " % self.PRESET_FILE_NAME) - return self.pc.read_json(self.PRESET_FILE_NAME) or ([None]*self.MAX_PRESETS) + return [ Frame(self.pc).store_copy(x) for x in (self.pc.read_json(self.PRESET_FILE_NAME) or ([None]*self.MAX_PRESETS)) ] def save_presets(self): self.pc.update_json(self.PRESET_FILE_NAME, self.presets) @@ -57,7 +58,7 @@ class ShaderQuickPresetPlugin(ActionsPlugin): #,SequencePlugin): if self.selected_preset is None: self.selected_preset = 0 insert_position = self.selected_preset - self.presets[insert_position] = self.pc.shaders.get_live_frame() + self.presets[insert_position] = self.pc.fm.get_live_frame() #print ("stored %s at position %s" % (self.presets[insert_position], insert_position)) self.selected_preset = insert_position self.last_recalled = insert_position @@ -80,5 +81,5 @@ class ShaderQuickPresetPlugin(ActionsPlugin): #,SequencePlugin): preset = self.presets[preset] print ("recalled preset %s" % preset) - self.pc.shaders.recall_frame(preset) + self.pc.fm.recall_frame(preset) diff --git a/plugins/frame_manager.py b/plugins/frame_manager.py new file mode 100644 index 0000000..829f91d --- /dev/null +++ b/plugins/frame_manager.py @@ -0,0 +1,278 @@ +import copy +import json +from json import JSONEncoder + +def _default(self, obj): + if getattr(obj.__class__,'to_json'): + #return _default.default(obj.to_json()) + return obj.to_json() + else: + return _default.default(obj) + +_default.default = JSONEncoder().default +JSONEncoder.default = _default + +class Frame: + f = { 'shader_params': [[None]*4,[None]*4,[None]*4] } + pc = None + + DEBUG_FRAMES = False#True + + def __init__(self, pc): + import copy #from copy import deepcopy + self.pc = pc + + def to_json(self): + return self.f #{ 'f': self.f } + + def store_live(self): + frame = { + 'selected_shader_slots': [ shader.get('slot',None) for shader in self.pc.shaders.selected_shader_list ], + 'shader_params': copy.deepcopy(self.pc.shaders.selected_param_list), + 'layer_active_status': copy.deepcopy(self.pc.shaders.selected_status_list), + 'feedback_active': self.pc.shaders.data.feedback_active, + 'x3_as_speed': self.pc.shaders.data.settings['shader']['X3_AS_SPEED']['value'], + 'shader_speeds': copy.deepcopy(self.pc.shaders.selected_speed_list), + 'strobe_amount': self.pc.shaders.data.settings['shader']['STROBE_AMOUNT']['value'] / 10.0 + } + self.f = frame + #print("built frame: %s" % frame['shader_params']) + return self + + def store_copy(self, f): + print("told to store_copy %s" % f) + if f is not None: + if f.get('f') is not None: #isinstance(f, Frame): + f = f.get('f') + return self.store_copy(f.get('f')) + self.f = f + else: + self.f = {} + return self + + def recall_frame_params(self): + #print("recall_frame_params got: %s" % preset.get('shader_params')) + for (layer, param_list) in enumerate(self.f.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.pc.actions.call_method_name('set_the_shader_param_%s_layer_%s_continuous' % (param,layer), value) + + if self.f.get('feedback_active') is not None: + self.pc.data.feedback_active = self.f.get('feedback_active',self.pc.data.feedback_active) + if self.pc.data.feedback_active: + self.pc.actions.call_method_name('enable_feedback') + else: + self.pc.actions.call_method_name('disable_feedback') + + if self.f.get('x3_as_speed') is not None: + self.pc.data.settings['shader']['X3_AS_SPEED']['value'] = self.f.get('x3_as_speed',self.pc.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(self.f.get('shader_speeds',[])): + if speed is not None: + self.pc.actions.call_method_name('set_shader_speed_layer_%s_amount' % layer, speed) + + if self.f.get('strobe_amount') is not None: + self.pc.actions.set_strobe_amount_continuous(self.f.get('strobe_amount')) + + def recall_frame(self): + preset = self + + if preset.f is None: + return + + self.pc.data.settings['shader']['X3_AS_SPEED']['value'] = preset.f.get('x3_as_speed') + + # x3_as_speed affects preset recall, so do that first + self.recall_frame_params() + + for (layer, slot) in enumerate(preset.f.get('selected_shader_slots',[])): + if slot is not None: + #print("setting layer %s to slot %s" % (layer, slot)) + self.pc.actions.call_method_name('play_shader_%s_%s' % (layer, slot)) + + for (layer, active) in enumerate(preset.f.get('layer_active_status',[])): + # print ("got %s layer with status %s " % (layer,active)) + if active=='▶': + self.pc.actions.call_method_name('start_shader_layer_%s' % layer) + else: + self.pc.actions.call_method_name('stop_shader_layer_%s' % layer) + + def merge(self, frame2): + from copy import deepcopy + f = deepcopy(self.f) #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.f.get('shader_params')): + for i2,p in enumerate(f2): + if p is not None: + if 'shader_params' not in f: + f['shader_params'] = [[None]*4,[None]*4,[None]*4] + f['shader_params'][i][i2] = p + + if frame2.f.get('feedback_active') is not None: + f['feedback_active'] = frame2['feedback_active'] + + if frame2.f.get('x3_as_speed') is not None: + f['x3_as_speed'] = frame2.f.get('x3_as_speed') + + if f.get('shader_speeds') is None: + if 'shader_speeds' in frame2.f: + f['shader_speeds'] = frame2.f.get('shader_speeds') + else: + for i,s in enumerate(frame2.f.get('shader_speeds')): + if s is not None: + f['shader_speeds'][i] = s + + if frame2.f.get('strobe_amount'): + f['strobe_amount'] = frame2.f.get('strobe_amount') + + if self.DEBUG_FRAMES: print("merge_frames: got return\t%s" % f) + return Frame(self.pc).store_copy(f) + + def get_ignored(self, ignored): + from copy import deepcopy + f = deepcopy(self.f) #frame1.copy() + frame = self.f + ignored = ignored.f + if self.DEBUG_FRAMES: print("get_frame_ignored: got frame\t%s" % self.f) + for i,f2 in enumerate(frame.get('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') is not None: + 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 Frame(self.pc).store_copy(f) + + def is_empty(self): + #from copy import deepcopy + #f = deepcopy(frame) #frame1.copy() + frame = self.f + 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_diff(self, current_frame): + #if not last_frame: return current_frame + current_frame = current_frame.f + last_frame = self.f + + 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 Frame(self.pc).store_copy(diff) + + + + + +class FrameManager: + pc = None + + def __init__(self, pc): + self.pc = pc + + def get_live_frame(self): + return Frame(self.pc).store_live() + + def recall_frame_params(self, preset): + if preset is None: + return + preset.recall_frame_params() + + def recall_frame(self, preset): + if preset is None: + return + preset.recall_frame() + + # overlay frame2 on frame1 + def merge_frames(self, frame1, frame2): + return frame1.merge(frame2) + + def get_frame_ignored(self, frame, ignored): + return frame.get_ignored(ignored) + + def is_frame_empty(self, frame): + return frame.is_empty() + + def get_frame_diff(self, last_frame, current_frame): + return last_frame.get_diff(current_frame) + diff --git a/video_centre/shaders.py b/video_centre/shaders.py index 0b97db0..a9bbf26 100644 --- a/video_centre/shaders.py +++ b/video_centre/shaders.py @@ -268,203 +268,3 @@ class Shaders(object): self.osc_client.send_message("/shader/{}/speed".format(str(layer)), amount ) self.selected_speed_list[layer] = amount - # 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 -