From 422574f1bf2e8bc3d640b7f6a50cbdd59f049bed Mon Sep 17 00:00:00 2001 From: pullusb Date: Wed, 30 Jul 2025 14:55:22 +0200 Subject: [PATCH] rename files and add output management - not exposed yet --- operators/__init__.py | 10 +- operators/output_management.py | 347 ++++++++++++++++++ ...eplace.py => output_search_and_replace.py} | 0 .../{outputs_setup.py => output_setup.py} | 0 ui.py | 2 + 5 files changed, 355 insertions(+), 4 deletions(-) create mode 100644 operators/output_management.py rename operators/{outputs_search_and_replace.py => output_search_and_replace.py} (100%) rename operators/{outputs_setup.py => output_setup.py} (100%) diff --git a/operators/__init__.py b/operators/__init__.py index d156440..4b2a26a 100755 --- a/operators/__init__.py +++ b/operators/__init__.py @@ -1,7 +1,8 @@ from . import ( utility, - outputs_setup, - outputs_search_and_replace, + output_search_and_replace, + output_setup, + output_management, visibility_conflicts, simplify_conflicts, store_visibility_states, @@ -11,8 +12,9 @@ from . import ( mods = ( utility, - outputs_setup, - outputs_search_and_replace, + output_setup, + output_search_and_replace, + output_management, visibility_conflicts, simplify_conflicts, store_visibility_states, diff --git a/operators/output_management.py b/operators/output_management.py new file mode 100644 index 0000000..bdf892f --- /dev/null +++ b/operators/output_management.py @@ -0,0 +1,347 @@ +import bpy +import re + +from bpy.types import Operator +from bpy.props import (StringProperty, + BoolProperty, + ) + + +# 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(bpy.types.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(bpy.types.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(bpy.types.Operator): + bl_idname = "rt.set_output_node_format" + bl_label = "Set output format from active" + bl_description = "Change all selected output node to match active output node format" + 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"} + + +# region view layers + +class RT_OT_enable_all_viewlayers(bpy.types.Operator): + bl_idname = "rt.enable_all_viewlayers" + bl_label = "Enable All Viewlayers" + bl_description = "Enable all View layers except those named 'exclude' 'View Layer'" + bl_options = {"REGISTER"} + + def execute(self, context): + scn = context.scene + + vl_list = [vl for vl in scn.view_layers if not vl.use and vl.name not in {'View Layer', 'exclude'}] + for v in vl_list: + v.use = True + + self.report({"INFO"}, f'{len(vl_list)} ViewLayers Reactivated') + return {"FINISHED"} + +class RT_OT_activate_only_selected_layers(bpy.types.Operator): + bl_idname = "rt.activate_only_selected_layers" + bl_label = "Activate Only Selected Layers" + bl_description = "Activate only selected node view layer , excluding all others" + bl_options = {"REGISTER"} + + def execute(self, context): + scn = context.scene + + nodes = scn.node_tree.nodes + + rlayers_nodes = [n for n in nodes if n.select and n.type == 'R_LAYERS'] + vls = [scn.view_layers.get(n.layer) for n in rlayers_nodes if scn.view_layers.get(n.layer)] + for v in scn.view_layers: + v.use = v in vls + + self.report({"INFO"}, f'Now only {len(vls)} viewlayer active (/{len(scn.view_layers)})') + return {"FINISHED"} + + +classes = ( + RT_OT_number_outputs, + RT_OT_mute_toggle_output_nodes, + RT_OT_set_output_node_format, + RT_OT_enable_all_viewlayers, + RT_OT_activate_only_selected_layers +) + +def register(): + for cls in classes: + bpy.utils.register_class(cls) + +def unregister(): + for cls in reversed(classes): + bpy.utils.unregister_class(cls) diff --git a/operators/outputs_search_and_replace.py b/operators/output_search_and_replace.py similarity index 100% rename from operators/outputs_search_and_replace.py rename to operators/output_search_and_replace.py diff --git a/operators/outputs_setup.py b/operators/output_setup.py similarity index 100% rename from operators/outputs_setup.py rename to operators/output_setup.py diff --git a/ui.py b/ui.py index 5033837..3c7d13b 100755 --- a/ui.py +++ b/ui.py @@ -15,6 +15,8 @@ class RT_PT_render_toolbox_ui(Panel): layout.operator("rt.create_output_layers", icon="NODE") layout.operator("rt.outputs_search_and_replace", text='Search and replace outputs', icon="BORDERMOVE") + # layout.separator() + # Base panel for drawing class RT_PT_visibility_check_ui_base(bpy.types.Panel): bl_space_type = "VIEW_3D"