import bpy import re from bpy.types import Operator from bpy.props import (StringProperty, BoolProperty, ) from .. import fn # region renumber outputs def delete_numbering(fo): # padding=3 '''Delete prefix numbering on all slots on passed file output''' if fo.type != 'OUTPUT_FILE': return if fo.format.file_format == 'OPEN_EXR_MULTILAYER': slots = fo.layer_slots field_attr = 'name' else: slots = fo.file_slots field_attr = 'path' for fs in slots: elems = getattr(fs, field_attr).split('/') for i, e in enumerate(elems): elems[i] = re.sub(r'^\d{3}_', '', e) new = '/'.join(elems) setattr(fs, field_attr, new) ## Add - Insert prefix incrementation in fileoutput def get_numbered_output(out, slot_name): '''Return output slot name without looking for numbering ???_ ''' pattern = r'^(?:\d{3}_)?' # optional non capture group of 3 digits + _ pattern = f'{pattern}{slot_name}' for inp in out.inputs: if re.match(pattern, inp.name): return inp def add_fileslot_number(fs, number): field_attr = 'name' if hasattr(fs, 'name') else 'path' elems = getattr(fs, field_attr).split('/') for i, e in enumerate(elems): if re.match(r'^\d{3}_', e): elems[i] = re.sub(r'^(\d{3})', lambda x: str(number).zfill(3), e) else: elems[i] = f'{str(number).zfill(3)}_{e}' new = '/'.join(elems) setattr(fs, field_attr, new) return new def renumber(fo, offset=10): '''Force renumber all the slots with a 3''' if fo.type != 'OUTPUT_FILE': return ct = 10 # start at 10 slots = fo.layer_slots if fo.format.file_format == 'OPEN_EXR_MULTILAYER' else fo.file_slots for fs in slots: add_fileslot_number(fs, ct) ct += offset def get_num(string) -> int: '''get a tring or a file_slot object return leading number or None ''' if not isinstance(string, str): if hasattr(string, 'path'): string = string.path else: string = string.name num = re.search(r'^(\d{3})_', string) if num: return int(num.group(1)) def reverse_fileout_inputs(fo): count = len(fo.inputs) for i in range(count): fo.inputs.move(count-1, i) def renumber_keep_existing(fo, offset=10, invert=True): '''Renumber by keeping existing numbers and inserting new one whenever possible Big and ugly function that do the trick nonetheless... ''' if fo.type != 'OUTPUT_FILE': return ct = 10 if invert: reverse_fileout_inputs(fo) fsl = fo.layer_slots if fo.format.file_format == 'OPEN_EXR_MULTILAYER' else fo.file_slots last_idx = len(fsl) - 1 prev = None prev_num = None for idx, fs in enumerate(fsl): # print('-->', idx, fs.path) if idx == last_idx: # handle last if get_num(fs) is not None: break if idx > 0: prev = fsl[idx-1] num = get_num(prev) if num is not None: add_fileslot_number(fs, num + offset) else: add_fileslot_number(fs, ct) else: add_fileslot_number(fs, 10) # there is only one slot (maybe don't number ?) break # update the ct with the current taken number if any number = get_num(fs) if number is not None: prev = fs ct = number + offset continue # skip already numbered # analyse all next slots until there is numbered divider = 0 # print(f'range(1, {len(fsl) - idx}') for i in range(1, len(fsl) - idx): next_num = get_num(fsl[idx + i]) if next_num is not None: divider = i+1 break if idx == 0: # handle first prev_num = 0 prev = None if next_num is None: add_fileslot_number(fs, 0) elif next_num == 0: print(f'Cannot insert value before 0 to {fsl.path}') continue else: add_fileslot_number(fs, int(next_num / 2)) else: prev = fsl[idx-1] test_prev = get_num(prev) if test_prev is not None: prev_num = test_prev if not divider: if prev_num is not None: add_fileslot_number(fs, prev_num + offset) else: add_fileslot_number(fs, ct) else: if prev_num is not None: # iterate rename gap_inc = int((next_num - prev_num) / divider) if gap_inc < 1: # same values ! print(f'cannot insert a median value at {fs.path} between {prev_num} and {next_num}') continue ct = prev_num for temp_id in range(idx, idx+i): ct += gap_inc add_fileslot_number(fsl[temp_id], ct) else: print("what's going on ?\n") # first check if it has a number (if not bas) prev = fs ct += offset if invert: reverse_fileout_inputs(fo) class RT_OT_number_outputs(Operator): bl_idname = "rt.number_outputs" bl_label = "Number Outputs" bl_description = "(Re)Number the outputs to have ordered file by name in export directories\ \nCtrl+Clic : Delete numbering" bl_options = {"REGISTER"} @classmethod def poll(cls, context): return True mode : StringProperty(default='SELECTED', options={'SKIP_SAVE'}) clear : BoolProperty(default=False, options={'SKIP_SAVE'}) def invoke(self, context, event): # use clear with Ctrl + Click if event.ctrl: self.clear = True return self.execute(context) def execute(self, context): scn = context.scene ct = 0 nodes = scn.node_tree.nodes for fo in nodes: if fo.type != 'OUTPUT_FILE': continue if self.mode == 'SELECTED' and not fo.select: continue # print(f'numbering {fo.name}') ct += 1 if self.clear: delete_numbering(fo) else: renumber_keep_existing(fo) txt = 'de-numbered' if self.clear else 're-numbered' if ct: self.report({'INFO'}, f'{ct} output nodes {txt}') else: self.report({'ERROR'}, f'No output nodes {txt}') return {"FINISHED"} # region file output class RT_OT_mute_toggle_output_nodes(Operator): bl_idname = "rt.mute_toggle_output_nodes" bl_label = "Mute Toggle output nodes" bl_description = "Mute / Unmute all output nodes" bl_options = {"REGISTER"} mute : BoolProperty(default=True, options={'SKIP_SAVE'}) def execute(self, context): ct = 0 for n in context.scene.node_tree.nodes: if n.type != 'OUTPUT_FILE': continue n.mute = self.mute ct += 1 state = 'muted' if self.mute else 'unmuted' self.report({"INFO"}, f'{ct} nodes {state}') return {"FINISHED"} class RT_OT_set_output_node_format(Operator): bl_idname = "rt.set_output_node_format" bl_label = "Set file output node format from active" bl_description = "Change all selected file output node format to match active" bl_options = {"REGISTER"} mute : BoolProperty(default=True, options={'SKIP_SAVE'}) def execute(self, context): nodes = context.scene.node_tree.nodes if not nodes.active or nodes.active.type != 'OUTPUT_FILE': self.report({"ERROR"}, f'Active node should be an output file to use as reference for output format') return {"CANCELLED"} ref = nodes.active # file_format = ref.format.file_format # color_mode = ref.format.color_mode # color_depth = ref.format.color_depth # compression = ref.format.compression ct = 0 for n in nodes: if n.type != 'OUTPUT_FILE' or n == ref or not n.select: continue for attr in dir(ref.format): if attr.startswith('__') or attr in {'rna_type','bl_rna', 'view_settings', 'display_settings','stereo_3d_format'}: # views_format continue try: setattr(n.format, attr, getattr(ref.format, attr)) except Exception as e: print(f"can't set attribute : {attr}") # n.format.file_format = file_format # n.format.color_mode = color_mode # n.format.color_depth = color_depth # n.format.compression = compression ct += 1 # state = 'muted' if self.mute else 'unmuted' self.report({"INFO"}, f'{ct} output format copied from {ref.name}') return {"FINISHED"} class RT_OT_set_active_file_output_slot_to_composite(bpy.types.Operator): bl_idname = "rt.set_active_file_output_slot_to_composite" bl_label = "Set Active File Output Slot To Composite" bl_description = "Use active slot of active file output node to set scene output settings (swap connection)" bl_options = {"REGISTER"} @classmethod def poll(cls, context): return context.scene.use_nodes\ and context.scene.node_tree\ and context.scene.node_tree.nodes.active\ and context.scene.node_tree.nodes.active.type == 'OUTPUT_FILE' relink_composite : bpy.props.BoolProperty( name='Relink Composite', default=True, description='In case file slot is linked, swap link to Composite file', options={'SKIP_SAVE'}, ) def invoke(self, context, event): self.fo = context.scene.node_tree.nodes.active if not len(self.fo.file_slots): self.report({'ERROR'}, 'no slots in active file output') return {'CANCELLED'} # check if active slot has a source if not self.fo.inputs[self.fo.active_input_index].is_linked: return self.execute(context) # check if composite linked out = context.scene.node_tree.nodes.get('Composite') if not out or not out.inputs[0].is_linked: self.compo_out_from_link = '' return self.execute(context) # compo linked, pop panel to choose replace or not self.compo_out_from_link = out.inputs[0].links[0].from_node.name return context.window_manager.invoke_props_dialog(self) def draw(self, context): layout = self.layout col = layout.column() col.label(text=f'Composite node connected to: {self.compo_out_from_link}') col.label(text=f'Would you like to replace by file output slot source ?') layout.prop(self, 'relink_composite') def execute(self, context): # if comp fn.set_scene_output_from_active_fileout_item() idx = self.fo.active_input_index sl = self.fo.file_slots[idx] sk = self.fo.inputs[idx] if not sk.is_linked: self.report({'INFO'}, f'Outut changed to match {sl.path} (slot was not linked)') return {'FINISHED'} ## If linked replace links to Composite node if not self.relink_composite: return {'FINISHED'} ntree = context.scene.node_tree links = context.scene.node_tree.links nodes = context.scene.node_tree.nodes out = nodes.get('Composite') if not out: out = fn.create_node('COMPOSITE', tree=ntree) fo_loc = fn.real_loc(self.fo) out.location = (fo_loc.x, fo_loc.y + 160) # if out.inputs[0].is_linked: # self.report({'WARNING'}, f'Outut changed to match {sl.path} (Composite node already linked)') lnk = sk.links[0] from_sk = sk.links[0].from_socket links.remove(lnk) links.new(from_sk, out.inputs[0]) return {"FINISHED"} classes = ( RT_OT_number_outputs, RT_OT_mute_toggle_output_nodes, RT_OT_set_output_node_format, RT_OT_set_active_file_output_slot_to_composite, ) def register(): for cls in classes: bpy.utils.register_class(cls) def unregister(): for cls in reversed(classes): bpy.utils.unregister_class(cls)