Organize scripts

1 files changed, 0 insertions, 1084 deletions

diff --git a/BakeVertexData.py b/BakeVertexData.py
deleted file mode 100644
index 3eecf05..0000000
--- a/BakeVertexData.py
+++ /dev/null
@@ -1,1084 +0,0 @@
-bl_info = {
-    "name": "Bake Vertex to Target Vector",
-    "blender": (4, 2, 0),
-    "category": "Mesh",
-    "version": (2, 3, 0),
-    "author": "yum_food",
-    "description": "Bake vertex vectors with automatic center and scale calculation in Edit Mode, with submesh deduplication"
-}
-
-import bpy
-import mathutils
-import bmesh
-import math
-from bpy.props import BoolProperty, FloatProperty, IntProperty, PointerProperty
-from bpy.types import Panel, Operator, PropertyGroup
-from collections import deque, defaultdict
-
-
-class BakeVertexSettings(PropertyGroup):
-    correction_angle_x: FloatProperty(
-        name="X",
-        description="Correction angle for the X-axis",
-        default=math.pi,
-        subtype='ANGLE'
-    )
-    correction_angle_y: FloatProperty(
-        name="Y",
-        description="Correction angle for the Y-axis",
-        default=0.0,
-        subtype='ANGLE'
-    )
-    correction_angle_z: FloatProperty(
-        name="Z",
-        description="Correction angle for the Z-axis",
-        default=0.0,
-        subtype='ANGLE'
-    )
-
-
-class MeshUtils:
-    """Utility functions for mesh operations"""
-
-    @staticmethod
-    def with_mode(mode):
-        """Decorator to handle mode switching"""
-        def decorator(func):
-            def wrapper(self, context, *args, **kwargs):
-                original_mode = context.mode
-                if mode == 'OBJECT' and context.mode != 'OBJECT':
-                    bpy.ops.object.mode_set(mode='OBJECT')
-                elif mode == 'EDIT' and context.mode != 'EDIT_MESH':
-                    bpy.ops.object.mode_set(mode='EDIT')
-
-                try:
-                    result = func(self, context, *args, **kwargs)
-                finally:
-                    if original_mode == 'EDIT_MESH' and context.mode != 'EDIT_MESH':
-                        bpy.ops.object.mode_set(mode='EDIT')
-                    elif original_mode == 'OBJECT' and context.mode != 'OBJECT':
-                        bpy.ops.object.mode_set(mode='OBJECT')
-
-                return result
-            return wrapper
-        return decorator
-
-    @staticmethod
-    def with_multi_object_support(process_func_name='process_object'):
-        """Decorator to add multi-object support to operators
-
-        The decorated execute method should return a tuple of (success, stats_dict)
-        where stats_dict contains the statistics to aggregate across objects.
-        """
-        def decorator(func):
-            def wrapper(self, context, *args, **kwargs):
-                # Store the original active object
-                original_active = context.active_object
-
-                # Get all selected mesh objects
-                selected_objects = [obj for obj in context.selected_objects if obj.type == 'MESH']
-                if not selected_objects:
-                    self.report({'WARNING'}, "No mesh objects selected")
-                    return {'CANCELLED'}
-
-                # Initialize aggregated stats
-                total_stats = {}
-                processed_count = 0
-
-                # Process each selected object
-                for obj in selected_objects:
-                    # Make this object active temporarily
-                    context.view_layer.objects.active = obj
-
-                    # Call the actual processing method
-                    if hasattr(self, process_func_name):
-                        success, stats = getattr(self, process_func_name)(context, obj)
-                    else:
-                        # Fallback to calling the decorated function
-                        result = func(self, context, obj, *args, **kwargs)
-                        if isinstance(result, tuple) and len(result) == 2:
-                            success, stats = result
-                        else:
-                            success, stats = (result == {'FINISHED'}), {}
-
-                    if success:
-                        processed_count += 1
-                        # Aggregate statistics
-                        for key, value in stats.items():
-                            if isinstance(value, (int, float)):
-                                total_stats[key] = total_stats.get(key, 0) + value
-                            else:
-                                # For non-numeric values, just store the last one
-                                total_stats[key] = value
-
-                # Restore original active object
-                context.view_layer.objects.active = original_active
-
-                # Report results
-                total_stats['object_count'] = processed_count
-                if hasattr(self, 'format_report'):
-                    message = self.format_report(total_stats)
-                else:
-                    # Default reporting
-                    if processed_count == 0:
-                        self.report({'WARNING'}, "No objects processed")
-                        return {'CANCELLED'}
-                    message = f"Processed {processed_count} object(s)"
-
-                if message:
-                    self.report({'INFO'}, message)
-
-                return {'FINISHED'}
-            return wrapper
-        return decorator
-
-    @staticmethod
-    def get_selected_vertices(mesh):
-        """Get indices of selected vertices"""
-        return {v.index for v in mesh.vertices if v.select}
-
-    @staticmethod
-    def build_adjacency(mesh, vertex_indices):
-        """Build adjacency list for given vertices"""
-        adjacency = {idx: set() for idx in vertex_indices}
-        for edge in mesh.edges:
-            v0, v1 = edge.vertices
-            if v0 in adjacency and v1 in adjacency:
-                adjacency[v0].add(v1)
-                adjacency[v1].add(v0)
-        return adjacency
-
-    @staticmethod
-    def flood_fill(start_nodes, adjacency_func):
-        """Generic flood fill algorithm"""
-        visited = set()
-        result = set()
-        queue = deque(start_nodes)
-
-        while queue:
-            current = queue.popleft()
-            if current in visited:
-                continue
-            visited.add(current)
-            result.add(current)
-
-            for neighbor in adjacency_func(current):
-                if neighbor not in visited:
-                    queue.append(neighbor)
-
-        return result
-
-    @staticmethod
-    def find_islands(nodes, adjacency_func):
-        """Find connected components"""
-        islands = []
-        visited = set()
-
-        for node in nodes:
-            if node in visited:
-                continue
-
-            island = MeshUtils.flood_fill([node], lambda n: adjacency_func.get(n, []))
-            visited.update(island)
-            islands.append(island)
-
-        return islands
-
-    @staticmethod
-    def select_edges_and_faces(mesh):
-        """Select edges and faces based on selected vertices"""
-        for edge in mesh.edges:
-            v0, v1 = edge.vertices
-            if mesh.vertices[v0].select and mesh.vertices[v1].select:
-                edge.select = True
-
-        for face in mesh.polygons:
-            if all(mesh.vertices[v].select for v in face.vertices):
-                face.select = True
-
-
-class BaseSubmeshOperator(Operator):
-    """Base class for submesh operations"""
-    bl_options = {'REGISTER', 'UNDO'}
-
-    @classmethod
-    def poll(cls, context):
-        obj = context.active_object
-        return obj and obj.type == 'MESH' and context.mode == 'EDIT_MESH'
-
-    def get_selected_submeshes(self, mesh):
-        """Get selected vertices grouped by submesh"""
-        selected = MeshUtils.get_selected_vertices(mesh)
-        if not selected:
-            return []
-        adjacency = MeshUtils.build_adjacency(mesh, selected)
-        return MeshUtils.find_islands(selected, adjacency)
-
-
-class MESH_OT_select_all_linked(BaseSubmeshOperator):
-    bl_idname = "mesh.select_all_linked"
-    bl_label = "Select All Linked Submeshes"
-    bl_description = "Select all vertices in any submesh that has at least one vertex selected"
-
-    def process_object(self, context, obj):
-        """Process a single object and return (success, stats)"""
-        mesh = obj.data
-        initially_selected = MeshUtils.get_selected_vertices(mesh)
-
-        if not initially_selected:
-            return False, {}
-
-        all_vertices = set(range(len(mesh.vertices)))
-        adjacency = MeshUtils.build_adjacency(mesh, all_vertices)
-        islands = MeshUtils.find_islands(all_vertices, adjacency)
-
-        expanded_count = 0
-        affected_islands = 0
-
-        for island in islands:
-            if island & initially_selected:
-                new_selections = island - initially_selected
-                if new_selections:
-                    expanded_count += len(new_selections)
-                    affected_islands += 1
-                for idx in island:
-                    mesh.vertices[idx].select = True
-
-        MeshUtils.select_edges_and_faces(mesh)
-
-        return True, {
-            'affected_islands': affected_islands,
-            'expanded_count': expanded_count
-        }
-
-    def format_report(self, stats):
-        """Format the aggregated statistics into a report message"""
-        if stats['object_count'] == 0:
-            return "No objects with selected vertices found"
-        return f"Expanded selection in {stats['affected_islands']} submeshes ({stats['expanded_count']} new vertices) across {stats['object_count']} object(s)"
-
-    @MeshUtils.with_mode('OBJECT')
-    @MeshUtils.with_multi_object_support('process_object')
-    def execute(self, context):
-        # The decorator handles everything
-        pass
-
-
-class MESH_OT_select_linked_across_boundaries(BaseSubmeshOperator):
-    bl_idname = "mesh.select_linked_across_boundaries"
-    bl_label = "Select Linked (Cross Boundaries)"
-    bl_description = "Select linked vertices, crossing submesh boundaries where vertices share locations"
-
-    epsilon: FloatProperty(
-        name="Location Tolerance",
-        description="Maximum distance for vertices to be considered at the same location",
-        default=0.0001,
-        min=0.0,
-        max=1.0,
-        precision=6,
-        subtype='DISTANCE'
-    )
-
-    def build_combined_adjacency(self, mesh):
-        """Build adjacency including both edges and position-based connections"""
-        edge_adjacency = MeshUtils.build_adjacency(mesh, set(range(len(mesh.vertices))))
-
-        # Build position adjacency
-        scale = min(1.0 / self.epsilon, 1e7) if self.epsilon > 0 else 1e7
-        position_map = defaultdict(list)
-
-        for v in mesh.vertices:
-            key = tuple(int(v.co[i] * scale) for i in range(3))
-            position_map[key].append(v.index)
-
-        position_adjacency = {}
-        for vertices_at_pos in position_map.values():
-            if len(vertices_at_pos) > 1:
-                for i, v1 in enumerate(vertices_at_pos):
-                    if v1 not in position_adjacency:
-                        position_adjacency[v1] = set()
-                    position_adjacency[v1].update(vertices_at_pos[i+1:])
-                    for v2 in vertices_at_pos[i+1:]:
-                        if v2 not in position_adjacency:
-                            position_adjacency[v2] = set()
-                        position_adjacency[v2].add(v1)
-
-        # Combine adjacencies
-        def combined_adjacency(vertex):
-            neighbors = set()
-            if vertex in edge_adjacency:
-                neighbors.update(edge_adjacency[vertex])
-            if vertex in position_adjacency:
-                neighbors.update(position_adjacency[vertex])
-            return neighbors
-
-        return combined_adjacency
-
-    def process_object(self, context, obj):
-        """Process a single object and return (success, stats)"""
-        mesh = obj.data
-        initially_selected = MeshUtils.get_selected_vertices(mesh)
-
-        if not initially_selected:
-            return False, {}
-
-        combined_adjacency = self.build_combined_adjacency(mesh)
-        visited = MeshUtils.flood_fill(initially_selected, combined_adjacency)
-
-        for idx in visited:
-            mesh.vertices[idx].select = True
-
-        MeshUtils.select_edges_and_faces(mesh)
-        expanded_count = len(visited) - len(initially_selected)
-
-        return True, {
-            'selected': len(visited),
-            'expanded': expanded_count
-        }
-
-    def format_report(self, stats):
-        """Format the aggregated statistics into a report message"""
-        if stats['object_count'] == 0:
-            return "No objects with selected vertices found"
-        return f"Selected {stats['selected']} vertices ({stats['expanded']} new) across {stats['object_count']} object(s)"
-
-    @MeshUtils.with_mode('OBJECT')
-    @MeshUtils.with_multi_object_support('process_object')
-    def execute(self, context):
-        # The decorator handles everything
-        pass
-
-    def draw(self, context):
-        layout = self.layout
-        layout.prop(self, "epsilon")
-        layout.label(text="Connects vertices at same location", icon='INFO')
-
-
-class MESH_OT_deduplicate_submeshes(BaseSubmeshOperator):
-    bl_idname = "mesh.deduplicate_submeshes"
-    bl_label = "Deduplicate Submeshes"
-    bl_description = "Remove duplicate submeshes from selection that have vertices at the same locations"
-
-    tolerance: FloatProperty(
-        name="Position Tolerance",
-        description="Maximum distance for vertices to be considered at the same position",
-        default=0.0001,
-        min=0.0,
-        max=1.0,
-        precision=6
-    )
-
-    def get_island_signature(self, mesh, island_indices):
-        """Create a hash for an island based on vertex positions"""
-        decimal_places = 6 if self.tolerance == 0 else max(0, int(-math.log10(self.tolerance)))
-
-        positions = []
-        for idx in island_indices:
-            co = mesh.vertices[idx].co
-            rounded = tuple(round(co[i], decimal_places) for i in range(3))
-            positions.append(rounded)
-
-        positions.sort()
-        return tuple(positions)
-
-    def process_object(self, context, obj):
-        """Process a single object and return (success, stats)"""
-        mesh = obj.data
-        islands = self.get_selected_submeshes(mesh)
-
-        if len(islands) <= 1:
-            return False, {}
-
-        # Group islands by signature
-        island_groups = defaultdict(list)
-        for island in islands:
-            signature = self.get_island_signature(mesh, island)
-            island_groups[signature].append(island)
-
-        # Find duplicates to remove
-        vertices_to_delete = set()
-        duplicate_count = 0
-
-        for group in island_groups.values():
-            if len(group) > 1:
-                for island in group[1:]:
-                    vertices_to_delete.update(island)
-                    duplicate_count += 1
-
-        if not vertices_to_delete:
-            return False, {}
-
-        # Select vertices to delete
-        bpy.ops.object.mode_set(mode='EDIT')
-        bpy.ops.mesh.select_all(action='DESELECT')
-        bpy.ops.object.mode_set(mode='OBJECT')
-
-        for idx in vertices_to_delete:
-            mesh.vertices[idx].select = True
-
-        bpy.ops.object.mode_set(mode='EDIT')
-        bpy.ops.mesh.delete(type='VERT')
-        bpy.ops.object.mode_set(mode='OBJECT')
-
-        return True, {
-            'duplicates': duplicate_count,
-            'vertices_deleted': len(vertices_to_delete)
-        }
-
-    def format_report(self, stats):
-        """Format the aggregated statistics into a report message"""
-        if stats['object_count'] == 0:
-            return "No duplicate submeshes found"
-        return f"Removed {stats['duplicates']} duplicate submeshes ({stats['vertices_deleted']} vertices) across {stats['object_count']} object(s)"
-
-    @MeshUtils.with_mode('OBJECT')
-    @MeshUtils.with_multi_object_support('process_object')
-    def execute(self, context):
-        # The decorator handles everything
-        pass
-
-    def draw(self, context):
-        layout = self.layout
-        layout.prop(self, "tolerance")
-        layout.label(text="Set to 0 for exact matching", icon='INFO')
-
-
-class MESH_OT_pack_uv_islands_by_submesh_z(BaseSubmeshOperator):
-    bl_idname = "mesh.pack_uv_islands_by_submesh_z"
-    bl_label = "Pack UV Islands by Submesh Z"
-    bl_description = "Pack UV islands vertically sorted by submesh Z position"
-
-    padding: FloatProperty(
-        name="Island Padding",
-        description="Padding between UV islands",
-        default=0.02,
-        min=0.0,
-        max=0.1,
-        precision=3
-    )
-
-    max_islands_per_row: IntProperty(
-        name="Max Islands Per Row",
-        description="Maximum number of islands per row",
-        default=100,
-        min=1,
-        max=1000
-    )
-
-    lock_overlapping: BoolProperty(
-        name="Lock Overlapping Islands",
-        description="Treat overlapping UV islands as a single island",
-        default=False
-    )
-
-    skip_overlap_check: BoolProperty(
-        name="Skip Overlap Check",
-        description="Skip overlap detection for better performance",
-        default=False
-    )
-
-    @classmethod
-    def poll(cls, context):
-        obj = context.active_object
-        return (obj and obj.type == 'MESH' and 
-                context.mode == 'EDIT_MESH' and 
-                obj.data.uv_layers.active)
-
-    def get_uv_islands(self, bm, uv_layer):
-        """Find all UV islands in the mesh"""
-        uv_vert_map = {}
-        uv_adjacency = defaultdict(set)
-
-        for face in bm.faces:
-            if not face.select:
-                continue
-
-            face_uvs = []
-            for loop in face.loops:
-                uv = loop[uv_layer].uv
-                uv_key = (round(uv.x, 6), round(uv.y, 6))
-                face_uvs.append(uv_key)
-
-                if uv_key not in uv_vert_map:
-                    uv_vert_map[uv_key] = set()
-                uv_vert_map[uv_key].add(loop.vert.index)
-
-            # Create UV edges
-            for i in range(len(face_uvs)):
-                j = (i + 1) % len(face_uvs)
-                uv_adjacency[face_uvs[i]].add(face_uvs[j])
-                uv_adjacency[face_uvs[j]].add(face_uvs[i])
-
-        # Find connected components
-        islands = []
-        for start_uv in uv_vert_map:
-            if any(start_uv in island['uvs'] for island in islands):
-                continue
-
-            island_uvs = MeshUtils.flood_fill([start_uv], lambda uv: uv_adjacency.get(uv, []))
-            island_vert_indices = set()
-            for uv in island_uvs:
-                island_vert_indices.update(uv_vert_map[uv])
-
-            islands.append({
-                'uvs': island_uvs,
-                'vert_indices': island_vert_indices,
-                'loops': []
-            })
-
-        return islands
-
-    def execute(self, context):
-        obj = context.active_object
-        mesh = obj.data
-
-        bm = bmesh.from_edit_mesh(mesh)
-        bm_uv_layer = bm.loops.layers.uv.active
-
-        # Get UV islands
-        uv_islands = self.get_uv_islands(bm, bm_uv_layer)
-        if not uv_islands:
-            self.report({'WARNING'}, "No UV islands found")
-            return {'CANCELLED'}
-
-        # Get submeshes and their Z values
-        bpy.ops.object.mode_set(mode='OBJECT')
-        submeshes = self.get_selected_submeshes(mesh)
-
-        submesh_z_values = []
-        for submesh in submeshes:
-            avg_z = sum(mesh.vertices[idx].co.z for idx in submesh) / len(submesh)
-            submesh_z_values.append(avg_z)
-
-        # Build vertex to submesh mapping
-        vertex_to_submesh = {}
-        for i, submesh in enumerate(submeshes):
-            for v in submesh:
-                vertex_to_submesh[v] = i
-
-        bpy.ops.object.mode_set(mode='EDIT')
-        bm = bmesh.from_edit_mesh(mesh)
-        bm_uv_layer = bm.loops.layers.uv.active
-
-        # Build UV to loops mapping
-        uv_to_loops = defaultdict(list)
-        for face in bm.faces:
-            if face.select:
-                for loop in face.loops:
-                    uv = loop[bm_uv_layer].uv
-                    uv_key = (round(uv.x, 6), round(uv.y, 6))
-                    uv_to_loops[uv_key].append(loop)
-
-        # Assign loops and create island data
-        island_data = []
-        for island in uv_islands:
-            island['loops'] = []
-            for uv_key in island['uvs']:
-                island['loops'].extend(uv_to_loops.get(uv_key, []))
-
-            if not island['loops']:
-                continue
-
-            # Find submesh
-            submesh_idx = None
-            for v_idx in island['vert_indices']:
-                if v_idx in vertex_to_submesh:
-                    submesh_idx = vertex_to_submesh[v_idx]
-                    break
-
-            if submesh_idx is not None:
-                # Get bounds
-                min_u = min_v = float('inf')
-                max_u = max_v = float('-inf')
-
-                for loop in island['loops']:
-                    uv = loop[bm_uv_layer].uv
-                    min_u = min(min_u, uv.x)
-                    max_u = max(max_u, uv.x)
-                    min_v = min(min_v, uv.y)
-                    max_v = max(max_v, uv.y)
-
-                width = max_u - min_u
-                height = max_v - min_v
-
-                if width > 0 and height > 0:
-                    island_data.append({
-                        'island': island,
-                        'submesh_z': submesh_z_values[submesh_idx],
-                        'bounds': (min_u, min_v, max_u, max_v),
-                        'width': width,
-                        'height': height
-                    })
-
-        # Sort by submesh Z
-        island_data.sort(key=lambda x: x['submesh_z'], reverse=True)
-
-        # Calculate scale
-        total_area = sum((d['width'] + self.padding) * (d['height'] + self.padding) 
-                        for d in island_data)
-        target_size = min(0.95, math.sqrt(total_area) * 1.2)
-        scale_factor = 0.95 / target_size if target_size > 1.0 else 1.0
-
-        # Pack islands
-        current_v = 0.95
-        current_row = []
-
-        for data in island_data:
-            width = data['width'] * scale_factor
-            height = data['height'] * scale_factor
-
-            # Start new row if needed
-            if current_row and (sum(d['width'] * scale_factor + self.padding for d in current_row) + width > target_size 
-                               or len(current_row) >= self.max_islands_per_row):
-                # Place current row
-                current_u = 0.025
-                row_height = max(d['height'] * scale_factor for d in current_row)
-
-                for row_data in current_row:
-                    offset_u = current_u - row_data['bounds'][0] * scale_factor
-                    offset_v = current_v - row_data['bounds'][3] * scale_factor
-
-                    for loop in row_data['island']['loops']:
-                        uv = loop[bm_uv_layer].uv
-                        uv.x = uv.x * scale_factor + offset_u
-                        uv.y = uv.y * scale_factor + offset_v
-
-                    current_u += row_data['width'] * scale_factor + self.padding
-
-                current_v -= row_height + self.padding
-                current_row = []
-
-            current_row.append(data)
-
-        # Place final row
-        if current_row:
-            current_u = 0.025
-            for row_data in current_row:
-                offset_u = current_u - row_data['bounds'][0] * scale_factor
-                offset_v = current_v - row_data['bounds'][3] * scale_factor
-
-                for loop in row_data['island']['loops']:
-                    uv = loop[bm_uv_layer].uv
-                    uv.x = uv.x * scale_factor + offset_u
-                    uv.y = uv.y * scale_factor + offset_v
-
-                current_u += row_data['width'] * scale_factor + self.padding
-
-        bmesh.update_edit_mesh(mesh)
-        self.report({'INFO'}, f"Packed {len(island_data)} UV islands from {len(submeshes)} submeshes")
-        return {'FINISHED'}
-
-    def draw(self, context):
-        layout = self.layout
-        layout.prop(self, "padding")
-        layout.prop(self, "max_islands_per_row")
-        layout.prop(self, "lock_overlapping")
-        layout.prop(self, "skip_overlap_check")
-
-
-class MESH_OT_merge_by_distance_per_submesh(BaseSubmeshOperator):
-    bl_idname = "mesh.merge_by_distance_per_submesh"
-    bl_label = "Merge by Distance (Per Submesh)"
-    bl_description = "Merge vertices by distance within each submesh separately"
-
-    merge_distance: FloatProperty(
-        name="Merge Distance",
-        description="Maximum distance for merging vertices",
-        default=0.001,
-        min=0.0,
-        max=1.0,
-        precision=6,
-        subtype='DISTANCE'
-    )
-
-    def process_object(self, context, obj):
-        """Process a single object and return (success, stats)"""
-        mesh = obj.data
-        bm = bmesh.from_edit_mesh(mesh)
-
-        selected_verts = [v for v in bm.verts if v.select]
-        if not selected_verts:
-            return False, {}
-
-        # Build islands using BMesh
-        selected_set = set(selected_verts)
-        island_verts = []
-        visited = set()
-
-        for start_v in selected_verts:
-            if start_v in visited:
-                continue
-
-            # Find island
-            island = []
-            stack = [start_v]
-
-            while stack:
-                current = stack.pop()
-                if current in visited:
-                    continue
-                visited.add(current)
-                island.append(current)
-
-                for edge in current.link_edges:
-                    other = edge.other_vert(current)
-                    if other in selected_set and other not in visited:
-                        stack.append(other)
-
-            island_verts.append(island)
-
-        # Merge within each island
-        merge_targets = {}
-        merge_dist_sq = self.merge_distance ** 2
-        merged_count = 0
-
-        for verts in island_verts:
-            if len(verts) < 2:
-                continue
-
-            processed = set()
-            for i, v1 in enumerate(verts):
-                if v1 in merge_targets or v1 in processed:
-                    continue
-                processed.add(v1)
-
-                for v2 in verts[i+1:]:
-                    if v2 in merge_targets or v2 in processed:
-                        continue
-
-                    if (v1.co - v2.co).length_squared <= merge_dist_sq:
-                        merge_targets[v2] = v1
-                        processed.add(v2)
-                        merged_count += 1
-
-        # Perform merges
-        if merge_targets:
-            targetmap = {v: merge_targets[v] for v in merge_targets if v.is_valid}
-            if targetmap:
-                bmesh.ops.weld_verts(bm, targetmap=targetmap)
-
-        bmesh.update_edit_mesh(mesh)
-
-        return merged_count > 0, {'merged': merged_count}
-
-    def format_report(self, stats):
-        """Format the aggregated statistics into a report message"""
-        if stats.get('merged', 0) > 0:
-            return f"Merged {stats['merged']} vertices across {stats['object_count']} object(s)"
-        else:
-            return "No vertices close enough to merge"
-
-    @MeshUtils.with_multi_object_support('process_object')
-    def execute(self, context):
-        # The decorator handles everything
-        pass
-
-    def draw(self, context):
-        layout = self.layout
-        layout.prop(self, "merge_distance")
-
-
-class MESH_OT_bake_origin_and_orientation_combined(BaseSubmeshOperator):
-    bl_idname = "mesh.bake_submesh_origin_and_orientation"
-    bl_label = "Bake Submesh Data"
-    bl_description = "Bake vertex vectors and orientation quaternions"
-
-    contiguous_mode: BoolProperty(
-        name="Contiguous Groups",
-        description="Process each contiguous group separately",
-        default=True
-    )
-
-    normal_epsilon: FloatProperty(
-        name="Normal Epsilon",
-        description="Minimum angle difference between normals",
-        default=0.1,
-        min=0.01,
-        max=1.0,
-        precision=3
-    )
-
-    use_cache: BoolProperty(
-        name="Cache Identical Submeshes",
-        description="Cache calculations for identical submeshes to avoid recomputing basis and scale",
-        default=True
-    )
-
-    def calculate_island_center(self, mesh, island_indices):
-        """Calculate center for an island"""
-        if not island_indices:
-            return None
-
-        center = mathutils.Vector((0.0, 0.0, 0.0))
-        for idx in island_indices:
-            center += mesh.vertices[idx].co
-        center /= len(island_indices)
-
-        return center
-    
-    def calculate_island_scale(self, mesh, island_indices, center, basis_inv):
-        """Calculate scale using L-infinity norm in rotated basis"""
-        if not island_indices:
-            return 1.0
-        
-        max_coord = 0.0
-        for idx in island_indices:
-            # Transform to local rotated basis
-            offset = mesh.vertices[idx].co - center
-            local_pos = basis_inv @ offset
-            
-            # L-infinity norm: max of absolute values
-            max_coord = max(max_coord, abs(local_pos.x), abs(local_pos.y), abs(local_pos.z))
-        
-        scale = 1.0 / max_coord if max_coord > 0 else 1.0
-        return scale
-
-    def build_basis_from_faces(self, mesh, face_indices, epsilon):
-        """Build orthonormal basis from face normals"""
-        if not face_indices:
-            return mathutils.Matrix.Identity(3)
-
-        # Get largest face normal
-        faces = sorted(face_indices, key=lambda i: mesh.polygons[i].area, reverse=True)
-        x_axis = mesh.polygons[faces[0]].normal.normalized()
-
-        # Find second normal
-        epsilon_cos = math.cos(epsilon)
-        y_axis = None
-
-        for face_idx in faces[1:]:
-            normal = mesh.polygons[face_idx].normal.normalized()
-            if abs(normal.dot(x_axis)) < epsilon_cos:
-                y_axis = normal - normal.dot(x_axis) * x_axis
-                y_axis.normalize()
-                break
-
-        if not y_axis:
-            if abs(x_axis.z) < 0.9:
-                y_axis = mathutils.Vector((-x_axis.y, x_axis.x, 0))
-            else:
-                y_axis = mathutils.Vector((0, -x_axis.z, x_axis.y))
-            y_axis.normalize()
-
-        z_axis = x_axis.cross(y_axis)
-
-        matrix = mathutils.Matrix((x_axis, y_axis, z_axis)).transposed()
-        if matrix.determinant() < 0:
-            matrix[2] = -matrix[2]
-
-        return matrix
-
-    def create_submesh_signature(self, mesh, island_indices, center):
-        """Create signature for caching - based on relative positions only"""
-        tolerance = 0.0001
-        relative_positions = []
-
-        for idx in island_indices:
-            relative_pos = mesh.vertices[idx].co - center
-            # Round to tolerance to handle floating point precision
-            rounded = tuple(round(relative_pos[i] / tolerance) * tolerance for i in range(3))
-            relative_positions.append(rounded)
-
-        relative_positions.sort()
-        return (len(island_indices), tuple(relative_positions))
-
-    def process_object(self, context, obj):
-        """Process a single object and return (success, stats)"""
-        mesh = obj.data
-        selected = MeshUtils.get_selected_vertices(mesh)
-
-        if not selected:
-            return False, {}
-
-        # Create/get data layers
-        if not mesh.vertex_colors:
-            mesh.vertex_colors.new(name="BakedVectors")
-        color_layer = mesh.vertex_colors.active
-
-        uv_layer0 = mesh.uv_layers.get("BakedOriginAngle0") or mesh.uv_layers.new(name="BakedOriginAngle0")
-        uv_layer1 = mesh.uv_layers.get("BakedOriginAngle1") or mesh.uv_layers.new(name="BakedOriginAngle1")
-
-        # Get correction quaternion
-        settings = context.scene.bake_vertex_settings
-        correction = mathutils.Euler(
-            (settings.correction_angle_x, settings.correction_angle_y, settings.correction_angle_z), 'XYZ'
-        ).to_quaternion()
-
-        # Build vertex to loops mapping
-        vertex_loops = defaultdict(list)
-        selected_faces = []
-
-        for poly in mesh.polygons:
-            face_verts = set(poly.vertices)
-            if face_verts & selected:
-                if face_verts <= selected:
-                    selected_faces.append(poly.index)
-
-                for loop_idx in poly.loop_indices:
-                    vert_idx = mesh.loops[loop_idx].vertex_index
-                    if vert_idx in selected:
-                        vertex_loops[vert_idx].append(loop_idx)
-
-        # Get islands
-        islands = self.get_selected_submeshes(mesh) if self.contiguous_mode else [selected]
-
-        # Process each island
-        world_matrix = obj.matrix_world
-        world_inv = world_matrix.inverted()
-        
-        # Cache for storing computed basis, scale, and quaternion for identical submeshes
-        # Key: geometry signature, Value: (scale, basis, quaternion, basis_inverse)
-        submesh_cache = {} if self.use_cache else None
-
-        for island in islands:
-            center = self.calculate_island_center(mesh, island)
-            if center is None:
-                continue
-
-            # Check cache first (if enabled)
-            cache_hit = False
-            if self.use_cache:
-                signature = self.create_submesh_signature(mesh, island, center)
-                if signature in submesh_cache:
-                    scale, basis, quat, basis_inv = submesh_cache[signature]
-                    cache_hit = True
-
-            # Only calculate if not in cache
-            if not cache_hit:
-                # Calculate basis (compute-intensive)
-                island_faces = [f for f in selected_faces 
-                              if all(v in island for v in mesh.polygons[f].vertices)]
-                basis = self.build_basis_from_faces(mesh, island_faces, self.normal_epsilon)
-                basis_inv = basis.inverted()
-                
-                # Calculate scale using L-infinity norm in rotated basis (compute-intensive)
-                scale = self.calculate_island_scale(mesh, island, center, basis_inv)
-                
-                # Calculate quaternion
-                quat = basis.to_quaternion()
-                quat.normalize()
-                if quat.w < 0:
-                    quat.negate()
-                quat = correction @ quat
-                
-                # Store in cache if enabled
-                if self.use_cache:
-                    submesh_cache[signature] = (scale, basis, quat, basis_inv)
-
-            # Transform vertices
-            center_world = world_matrix @ center
-
-            for vert_idx in island:
-                vert_world = world_matrix @ mesh.vertices[vert_idx].co
-                offset = world_inv.to_3x3() @ (vert_world - center_world)
-                local_pos = basis_inv @ offset
-
-                # Scale and convert to color
-                color = mathutils.Vector((
-                    (local_pos.x * scale + 1.0) * 0.5,
-                    (local_pos.y * scale + 1.0) * 0.5,
-                    (local_pos.z * scale + 1.0) * 0.5,
-                    scale
-                ))
-
-                # Apply to loops
-                for loop_idx in vertex_loops.get(vert_idx, []):
-                    color_layer.data[loop_idx].color = color
-                    uv_layer0.data[loop_idx].uv = (quat.x, quat.y)
-                    uv_layer1.data[loop_idx].uv = (quat.z, quat.w)
-
-        mesh.update()
-
-        return True, {
-            'islands': len(islands),
-            'vertices': len(selected)
-        }
-
-    def format_report(self, stats):
-        """Format the aggregated statistics into a report message"""
-        if stats['object_count'] == 0:
-            return "No objects with selected vertices found"
-        return f"Baked {stats['islands']} island(s) with {stats['vertices']} vertices across {stats['object_count']} object(s)"
-
-    @MeshUtils.with_mode('OBJECT')
-    @MeshUtils.with_multi_object_support('process_object')
-    def execute(self, context):
-        # The decorator handles everything
-        pass
-
-    def draw(self, context):
-        layout = self.layout
-        layout.prop(self, "contiguous_mode")
-        layout.prop(self, "use_cache")
-        layout.prop(self, "normal_epsilon")
-
-        settings = context.scene.bake_vertex_settings
-        box = layout.box()
-        box.label(text="Bake Rotation Correction (Degrees)")
-        row = box.row(align=True)
-        row.prop(settings, "correction_angle_x")
-        row.prop(settings, "correction_angle_y")
-        row.prop(settings, "correction_angle_z")
-
-
-class MESH_PT_bake_vertex_panel(Panel):
-    bl_label = "Bake Submesh Data"
-    bl_idname = "MESH_PT_bake_submesh_data"
-    bl_space_type = 'VIEW_3D'
-    bl_region_type = 'UI'
-    bl_category = "Tool"
-
-    def draw(self, context):
-        layout = self.layout
-        obj = context.active_object
-
-        if obj and obj.type == 'MESH' and context.mode == 'EDIT_MESH':
-            col = layout.column()
-            col.operator("mesh.bake_submesh_origin_and_orientation", icon='EXPORT')
-            col.operator("mesh.select_all_linked", icon='SELECT_EXTEND')
-            col.operator("mesh.select_linked_across_boundaries", icon='LINKED')
-            col.operator("mesh.deduplicate_submeshes", icon='DUPLICATE')
-            col.operator("mesh.merge_by_distance_per_submesh", icon='AUTOMERGE_ON')
-            col.operator("mesh.pack_uv_islands_by_submesh_z", icon='UV')
-        else:
-            layout.label(text="Enter Edit Mode to use tools", icon='INFO')
-
-
-classes = [
-    BakeVertexSettings,
-    MESH_OT_select_all_linked,
-    MESH_OT_select_linked_across_boundaries,
-    MESH_OT_deduplicate_submeshes,
-    MESH_OT_pack_uv_islands_by_submesh_z,
-    MESH_OT_merge_by_distance_per_submesh,
-    MESH_OT_bake_origin_and_orientation_combined,
-    MESH_PT_bake_vertex_panel
-]
-
-
-def menu_func(self, context):
-    self.layout.separator()
-    self.layout.operator("mesh.select_all_linked", icon='SELECT_EXTEND')
-    self.layout.operator("mesh.select_linked_across_boundaries", icon='LINKED')
-    self.layout.operator("mesh.deduplicate_submeshes", icon='DUPLICATE')
-    self.layout.operator("mesh.merge_by_distance_per_submesh", icon='AUTOMERGE_ON')
-    self.layout.operator("mesh.pack_uv_islands_by_submesh_z", icon='UV')
-    self.layout.operator("mesh.bake_submesh_origin_and_orientation", icon='EXPORT')
-
-
-def register():
-    for cls in classes:
-        bpy.utils.register_class(cls)
-    bpy.types.VIEW3D_MT_edit_mesh.append(menu_func)
-    bpy.types.Scene.bake_vertex_settings = PointerProperty(type=BakeVertexSettings)
-
-
-def unregister():
-    bpy.types.VIEW3D_MT_edit_mesh.remove(menu_func)
-    del bpy.types.Scene.bake_vertex_settings
-    for cls in reversed(classes):
-        bpy.utils.unregister_class(cls)
-
-
-if __name__ == "__main__":
-    register()