diff options
| -rw-r--r-- | BakeVertexData.py | 1657 |
1 files changed, 540 insertions, 1117 deletions
diff --git a/BakeVertexData.py b/BakeVertexData.py index f5ac764..dd8e3f5 100644 --- a/BakeVertexData.py +++ b/BakeVertexData.py @@ -1,6 +1,6 @@ bl_info = { "name": "Bake Vertex to Target Vector", - "blender": (3, 0, 0), + "blender": (4, 2, 0), "category": "Mesh", "version": (2, 3, 0), "author": "yum_food", @@ -13,6 +13,7 @@ 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): @@ -36,112 +37,237 @@ class BakeVertexSettings(PropertyGroup): ) -class MESH_OT_select_all_linked_submeshes(Operator): - bl_idname = "mesh.select_all_linked_submeshes" - bl_label = "Select All Linked Submeshes" - bl_description = "Select all vertices in any submesh that has at least one vertex selected" - bl_options = {'REGISTER', 'UNDO'} +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 - @classmethod - def poll(cls, context): - obj = context.active_object - return (obj is not None and - obj.type == 'MESH' and - context.mode == 'EDIT_MESH') + @staticmethod + def flood_fill(start_nodes, adjacency_func): + """Generic flood fill algorithm""" + visited = set() + result = set() + queue = deque(start_nodes) - def execute(self, context): - obj = context.active_object - mesh = obj.data + while queue: + current = queue.popleft() + if current in visited: + continue + visited.add(current) + result.add(current) - # Switch to object mode for reliable selection updates - bpy.ops.object.mode_set(mode='OBJECT') + for neighbor in adjacency_func(current): + if neighbor not in visited: + queue.append(neighbor) - # Get currently selected vertices - initially_selected = set() - for v in mesh.vertices: - if v.select: - initially_selected.add(v.index) + return result - if not initially_selected: - self.report({'WARNING'}, "No vertices selected") - bpy.ops.object.mode_set(mode='EDIT') - return {'CANCELLED'} + @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 - # Build adjacency from edges - adjacency = {i: set() for i in range(len(mesh.vertices))} + @staticmethod + def select_edges_and_faces(mesh): + """Select edges and faces based on selected vertices""" for edge in mesh.edges: v0, v1 = edge.vertices - adjacency[v0].add(v1) - adjacency[v1].add(v0) + if mesh.vertices[v0].select and mesh.vertices[v1].select: + edge.select = True - # Find all islands - all_indices = set(range(len(mesh.vertices))) - islands = [] - visited = set() + for face in mesh.polygons: + if all(mesh.vertices[v].select for v in face.vertices): + face.select = True - for start_idx in all_indices: - if start_idx in visited: - continue - island = set() - queue = [start_idx] +class BaseSubmeshOperator(Operator): + """Base class for submesh operations""" + bl_options = {'REGISTER', 'UNDO'} - while queue: - current = queue.pop(0) - if current in visited: - continue + @classmethod + def poll(cls, context): + obj = context.active_object + return obj and obj.type == 'MESH' and context.mode == 'EDIT_MESH' - visited.add(current) - island.add(current) + 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) - for neighbor in adjacency[current]: - if neighbor not in visited: - queue.append(neighbor) - islands.append(island) +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) - # Select vertices in islands that have any selected vertex expanded_count = 0 affected_islands = 0 for island in islands: - if island & initially_selected: # If island has any selected vertices + if island & initially_selected: new_selections = island - initially_selected - expanded_count += len(new_selections) if new_selections: + expanded_count += len(new_selections) affected_islands += 1 - # Select all vertices in this island for idx in island: mesh.vertices[idx].select = True - # Select edges where both vertices are selected - for edge in mesh.edges: - v0, v1 = edge.vertices - if mesh.vertices[v0].select and mesh.vertices[v1].select: - edge.select = True + MeshUtils.select_edges_and_faces(mesh) - # Select faces where all vertices are selected - for face in mesh.polygons: - all_verts_selected = all(mesh.vertices[v].select for v in face.vertices) - if all_verts_selected: - face.select = True + return True, { + 'affected_islands': affected_islands, + 'expanded_count': expanded_count + } - # Return to edit mode - bpy.ops.object.mode_set(mode='EDIT') - - self.report({'INFO'}, f"Expanded selection in {affected_islands} submeshes ({expanded_count} new vertices)") - return {'FINISHED'} + 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)" - def draw(self, context): - layout = self.layout - layout.prop(self, "contiguous_mode") + @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(Operator): +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" - bl_options = {'REGISTER', 'UNDO'} epsilon: FloatProperty( name="Location Tolerance", @@ -153,142 +279,74 @@ class MESH_OT_select_linked_across_boundaries(Operator): subtype='DISTANCE' ) - @classmethod - def poll(cls, context): - obj = context.active_object - return (obj is not None and - obj.type == 'MESH' and - context.mode == 'EDIT_MESH') - - def build_position_map(self, mesh, epsilon): - """Build a map of vertices that share the same position within epsilon""" - # Use integer hashing for much faster performance - if epsilon > 0: - scale = min(1.0 / epsilon, 1e7) # Cap scale to prevent overflow - else: - scale = 1e7 # Large scale for exact matching + 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)))) - position_map = {} + # Build position adjacency + scale = min(1.0 / self.epsilon, 1e7) if self.epsilon > 0 else 1e7 + position_map = defaultdict(list) - # Group vertices by their quantized positions for v in mesh.vertices: - # Quantize to integer grid - key = ( - int(v.co.x * scale), - int(v.co.y * scale), - int(v.co.z * scale) - ) - - if key not in position_map: - position_map[key] = [] + key = tuple(int(v.co[i] * scale) for i in range(3)) position_map[key].append(v.index) - # Create adjacency only for vertices we'll actually use - # This avoids creating empty sets for all vertices position_adjacency = {} - for vertices_at_pos in position_map.values(): if len(vertices_at_pos) > 1: - # For small groups, connect all to all - if len(vertices_at_pos) <= 10: - for i in range(len(vertices_at_pos)): - v1 = vertices_at_pos[i] - if v1 not in position_adjacency: - position_adjacency[v1] = set() - for j in range(i + 1, len(vertices_at_pos)): - v2 = vertices_at_pos[j] - if v2 not in position_adjacency: - position_adjacency[v2] = set() - position_adjacency[v1].add(v2) - position_adjacency[v2].add(v1) - else: - # For large groups, create a hub vertex to avoid O(n²) connections - hub = vertices_at_pos[0] - if hub not in position_adjacency: - position_adjacency[hub] = set() - for i in range(1, len(vertices_at_pos)): - v = vertices_at_pos[i] - if v not in position_adjacency: - position_adjacency[v] = set() - position_adjacency[hub].add(v) - position_adjacency[v].add(hub) - - return position_adjacency - - def execute(self, context): - obj = context.active_object - mesh = obj.data - - # Switch to object mode - bpy.ops.object.mode_set(mode='OBJECT') - - # Get initially selected vertices - initially_selected = {v.index for v in mesh.vertices if v.select} - - if not initially_selected: - self.report({'WARNING'}, "No vertices selected") - bpy.ops.object.mode_set(mode='EDIT') - return {'CANCELLED'} - - # Build edge adjacency only for vertices we might visit - edge_adjacency = {} - for edge in mesh.edges: - v0, v1 = edge.vertices - if v0 not in edge_adjacency: - edge_adjacency[v0] = set() - if v1 not in edge_adjacency: - edge_adjacency[v1] = set() - edge_adjacency[v0].add(v1) - edge_adjacency[v1].add(v0) - - # Build position adjacency - position_adjacency = self.build_position_map(mesh, self.epsilon) - - # Function to get combined neighbors efficiently - def get_neighbors(vertex_idx): + 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_idx in edge_adjacency: - neighbors.update(edge_adjacency[vertex_idx]) - if vertex_idx in position_adjacency: - neighbors.update(position_adjacency[vertex_idx]) + if vertex in edge_adjacency: + neighbors.update(edge_adjacency[vertex]) + if vertex in position_adjacency: + neighbors.update(position_adjacency[vertex]) return neighbors - # Flood fill from selected vertices using deque for better performance - from collections import deque - visited = set() - queue = deque(initially_selected) + return combined_adjacency - while queue: - current = queue.popleft() - if current in visited: - continue + def process_object(self, context, obj): + """Process a single object and return (success, stats)""" + mesh = obj.data + initially_selected = MeshUtils.get_selected_vertices(mesh) - visited.add(current) - mesh.vertices[current].select = True + if not initially_selected: + return False, {} - # Add all connected vertices to queue - for neighbor in get_neighbors(current): - if neighbor not in visited: - queue.append(neighbor) + combined_adjacency = self.build_combined_adjacency(mesh) + visited = MeshUtils.flood_fill(initially_selected, combined_adjacency) - # Select edges where both vertices are selected - for edge in mesh.edges: - v0, v1 = edge.vertices - if mesh.vertices[v0].select and mesh.vertices[v1].select: - edge.select = True + for idx in visited: + mesh.vertices[idx].select = True - # Select faces where all vertices are selected - for face in mesh.polygons: - all_verts_selected = all(mesh.vertices[v].select for v in face.vertices) - if all_verts_selected: - face.select = True + MeshUtils.select_edges_and_faces(mesh) + expanded_count = len(visited) - len(initially_selected) - # Return to edit mode - bpy.ops.object.mode_set(mode='EDIT') + return True, { + 'selected': len(visited), + 'expanded': expanded_count + } - expanded_count = len(visited) - len(initially_selected) - self.report({'INFO'}, f"Selected {len(visited)} vertices ({expanded_count} new)") - return {'FINISHED'} + 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 @@ -296,11 +354,10 @@ class MESH_OT_select_linked_across_boundaries(Operator): layout.label(text="Connects vertices at same location", icon='INFO') -class MESH_OT_deduplicate_submeshes(Operator): +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" - bl_options = {'REGISTER', 'UNDO'} tolerance: FloatProperty( name="Position Tolerance", @@ -311,141 +368,74 @@ class MESH_OT_deduplicate_submeshes(Operator): precision=6 ) - @classmethod - def poll(cls, context): - obj = context.active_object - return (obj is not None and - obj.type == 'MESH' and - context.mode == 'EDIT_MESH') - - def get_selected_vertex_islands(self, mesh): - """Find all contiguous groups of selected vertices in the mesh""" - # Get selected vertices - selected_indices = {v.index for v in mesh.vertices if v.select} - - if not selected_indices: - return [] - - # Build adjacency only for selected vertices - adjacency = {idx: set() for idx in selected_indices} - - for edge in mesh.edges: - v0, v1 = edge.vertices - if v0 in selected_indices and v1 in selected_indices: - adjacency[v0].add(v1) - adjacency[v1].add(v0) - - islands = [] - visited = set() - - for start_idx in selected_indices: - if start_idx in visited: - continue - - island = set() - queue = [start_idx] - - while queue: - current = queue.pop(0) - if current in visited: - continue - - visited.add(current) - island.add(current) - - for neighbor in adjacency[current]: - if neighbor not in visited: - queue.append(neighbor) - - islands.append(island) - - return islands - - def get_island_hash(self, mesh, island_indices): + def get_island_signature(self, mesh, island_indices): """Create a hash for an island based on vertex positions""" - # Round positions to handle tolerance 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 - # Round each component - rounded = ( - round(co.x, decimal_places), - round(co.y, decimal_places), - round(co.z, decimal_places) - ) + rounded = tuple(round(co[i], decimal_places) for i in range(3)) positions.append(rounded) - # Sort positions to ensure consistent ordering positions.sort() - - # Convert to tuple for hashing return tuple(positions) - def execute(self, context): - obj = context.active_object + def process_object(self, context, obj): + """Process a single object and return (success, stats)""" mesh = obj.data - - # Switch to object mode - bpy.ops.object.mode_set(mode='OBJECT') - - # Find all selected islands - islands = self.get_selected_vertex_islands(mesh) - - if not islands: - self.report({'WARNING'}, "No vertices selected") - bpy.ops.object.mode_set(mode='EDIT') - return {'CANCELLED'} + islands = self.get_selected_submeshes(mesh) if len(islands) <= 1: - self.report({'INFO'}, "No duplicate submeshes found in selection (only 1 submesh)") - bpy.ops.object.mode_set(mode='EDIT') - return {'FINISHED'} + return False, {} - # Group islands by their hash - island_groups = {} + # Group islands by signature + island_groups = defaultdict(list) for island in islands: - island_hash = self.get_island_hash(mesh, island) - if island_hash not in island_groups: - island_groups[island_hash] = [] - island_groups[island_hash].append(island) + signature = self.get_island_signature(mesh, island) + island_groups[signature].append(island) - # Find duplicates - duplicates_to_remove = [] + # Find duplicates to remove + vertices_to_delete = set() duplicate_count = 0 - for hash_key, group in island_groups.items(): + for group in island_groups.values(): if len(group) > 1: - # Keep the first island, mark others for removal for island in group[1:]: - duplicates_to_remove.append(island) + vertices_to_delete.update(island) duplicate_count += 1 - if not duplicates_to_remove: - self.report({'INFO'}, "No duplicate submeshes found in selection") - bpy.ops.object.mode_set(mode='EDIT') - return {'FINISHED'} + if not vertices_to_delete: + return False, {} - # Enter edit mode and select vertices to delete + # 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') - # Select all vertices in duplicate islands - vertices_to_delete = set() - for island in duplicates_to_remove: - vertices_to_delete.update(island) - for idx in vertices_to_delete: mesh.vertices[idx].select = True - # Delete selected vertices bpy.ops.object.mode_set(mode='EDIT') bpy.ops.mesh.delete(type='VERT') + bpy.ops.object.mode_set(mode='OBJECT') - self.report({'INFO'}, f"Removed {duplicate_count} duplicate submeshes from selection ({len(vertices_to_delete)} vertices)") - return {'FINISHED'} + 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 @@ -453,11 +443,10 @@ class MESH_OT_deduplicate_submeshes(Operator): layout.label(text="Set to 0 for exact matching", icon='INFO') -class MESH_OT_pack_uv_islands_by_submesh(Operator): - bl_idname = "mesh.pack_uv_islands_by_submesh" +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" - bl_options = {'REGISTER', 'UNDO'} padding: FloatProperty( name="Island Padding", @@ -470,7 +459,7 @@ class MESH_OT_pack_uv_islands_by_submesh(Operator): max_islands_per_row: IntProperty( name="Max Islands Per Row", - description="Maximum number of islands per row (use high value for width-based packing only)", + description="Maximum number of islands per row", default=100, min=1, max=1000 @@ -484,23 +473,21 @@ class MESH_OT_pack_uv_islands_by_submesh(Operator): skip_overlap_check: BoolProperty( name="Skip Overlap Check", - description="Skip overlap detection entirely for better performance on large meshes (overrides Lock Overlapping)", + description="Skip overlap detection for better performance", default=False ) @classmethod def poll(cls, context): obj = context.active_object - return (obj is not None and - obj.type == 'MESH' and - context.mode == 'EDIT_MESH' and - obj.data.uv_layers.active is not None) + 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""" - # Build UV edge connectivity - uv_vert_map = {} # Maps UV coordinates to vertex indices - uv_edges = set() # Set of UV edges as frozensets of UV coords + uv_vert_map = {} + uv_adjacency = defaultdict(set) for face in bm.faces: if not face.select: @@ -514,515 +501,171 @@ class MESH_OT_pack_uv_islands_by_submesh(Operator): if uv_key not in uv_vert_map: uv_vert_map[uv_key] = set() - uv_vert_map[uv_key].add(loop.vert.index) # Store index instead of BMVert + 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) - edge = frozenset([face_uvs[i], face_uvs[j]]) - uv_edges.add(edge) - - # Find UV islands using connected components - uv_adjacency = {uv: set() for uv in uv_vert_map} - - for edge in uv_edges: - uv_list = list(edge) - if len(uv_list) == 2: - uv_adjacency[uv_list[0]].add(uv_list[1]) - uv_adjacency[uv_list[1]].add(uv_list[0]) + uv_adjacency[face_uvs[i]].add(face_uvs[j]) + uv_adjacency[face_uvs[j]].add(face_uvs[i]) # Find connected components - visited = set() islands = [] - for start_uv in uv_vert_map: - if start_uv in visited: + if any(start_uv in island['uvs'] for island in islands): continue - island_uvs = set() - island_vert_indices = set() # Store indices instead of BMVerts - queue = [start_uv] - - while queue: - current_uv = queue.pop(0) - if current_uv in visited: - continue - - visited.add(current_uv) - island_uvs.add(current_uv) - island_vert_indices.update(uv_vert_map[current_uv]) - - for neighbor in uv_adjacency[current_uv]: - if neighbor not in visited: - queue.append(neighbor) + 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]) - # Store island data with vertex indices islands.append({ 'uvs': island_uvs, - 'vert_indices': island_vert_indices, # Store indices - 'loops': [] # Will be filled later + 'vert_indices': island_vert_indices, + 'loops': [] }) - # We'll assign loops later when we have a valid BMesh return islands - def get_island_bounds(self, island, uv_layer): - """Get bounding box of UV island""" - if not island['loops']: - return 0, 0, 0, 0 - - min_u = min_v = float('inf') - max_u = max_v = float('-inf') - - for loop in island['loops']: - uv = loop[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) - - return min_u, min_v, max_u, max_v - - def get_submesh_of_island(self, island_vert_indices, submeshes): - """Find which submesh an island belongs to""" - # island_vert_indices is already a set of indices - - # Find submesh with most overlap - best_submesh = None - best_overlap = 0 - - for i, submesh in enumerate(submeshes): - overlap = len(island_vert_indices & submesh) - if overlap > best_overlap: - best_overlap = overlap - best_submesh = i - - return best_submesh - - def get_submesh_of_island_fast(self, island_vert_indices, vertex_to_submesh): - """Find which submesh an island belongs to (optimized version)""" - # Count vertices per submesh - submesh_counts = {} - - for vert_idx in island_vert_indices: - if vert_idx in vertex_to_submesh: - submesh_idx = vertex_to_submesh[vert_idx] - submesh_counts[submesh_idx] = submesh_counts.get(submesh_idx, 0) + 1 - - # Find submesh with most vertices - if not submesh_counts: - return None - - best_submesh = max(submesh_counts.items(), key=lambda x: x[1]) - return best_submesh[0] - - def check_islands_overlap(self, island1, island2, uv_layer): - """Check if two UV islands overlap""" - # First check bounding box overlap - bounds1 = self.get_island_bounds(island1, uv_layer) - bounds2 = self.get_island_bounds(island2, uv_layer) - - # Check if bounding boxes don't overlap - if (bounds1[2] < bounds2[0] or bounds2[2] < bounds1[0] or - bounds1[3] < bounds2[1] or bounds2[3] < bounds1[1]): - return False - - # For precise overlap, check if any UV coordinates are shared - # This is sufficient for most use cases (exact overlapping vertices) - return bool(island1['uvs'] & island2['uvs']) - - def merge_overlapping_islands(self, islands, uv_layer): - """Merge overlapping UV islands into groups""" - if not self.lock_overlapping: - return islands - - num_islands = len(islands) - - # Skip for very large numbers of islands - if num_islands > 1000: - self.report({'WARNING'}, f"Skipping overlap detection for {num_islands} islands (too many)") - return islands - - # Pre-calculate bounds for all islands - island_bounds = [] - for island in islands: - bounds = self.get_island_bounds(island, uv_layer) - island_bounds.append(bounds) - - # Build overlap graph with bounding box pre-filtering - overlap_graph = {i: set() for i in range(num_islands)} - - # Use spatial subdivision for large island counts - if num_islands > 200: - # Create spatial grid for broad phase - grid_size = 10 - spatial_grid = {} - - for i, bounds in enumerate(island_bounds): - if bounds[0] == bounds[2] and bounds[1] == bounds[3]: - continue # Skip degenerate islands - - # Determine grid cells this island touches - min_x = int(bounds[0] * grid_size) - max_x = int(bounds[2] * grid_size) - min_y = int(bounds[1] * grid_size) - max_y = int(bounds[3] * grid_size) - - for gx in range(min_x, max_x + 1): - for gy in range(min_y, max_y + 1): - grid_key = (gx, gy) - if grid_key not in spatial_grid: - spatial_grid[grid_key] = [] - spatial_grid[grid_key].append(i) - - # Check overlaps only within same grid cells - checked_pairs = set() - for cell_islands in spatial_grid.values(): - for i, idx1 in enumerate(cell_islands): - for idx2 in cell_islands[i + 1:]: - pair = (min(idx1, idx2), max(idx1, idx2)) - if pair in checked_pairs: - continue - checked_pairs.add(pair) - - # Quick bounding box check - b1, b2 = island_bounds[idx1], island_bounds[idx2] - if not (b1[2] < b2[0] or b2[2] < b1[0] or - b1[3] < b2[1] or b2[3] < b1[1]): - # Detailed overlap check - if islands[idx1]['uvs'] & islands[idx2]['uvs']: - overlap_graph[idx1].add(idx2) - overlap_graph[idx2].add(idx1) - else: - # Original O(n²) algorithm for smaller counts - for i in range(num_islands): - for j in range(i + 1, num_islands): - # Quick bounding box check first - b1, b2 = island_bounds[i], island_bounds[j] - if not (b1[2] < b2[0] or b2[2] < b1[0] or - b1[3] < b2[1] or b2[3] < b1[1]): - # Detailed overlap check - if islands[i]['uvs'] & islands[j]['uvs']: - overlap_graph[i].add(j) - overlap_graph[j].add(i) - - # Find connected components (groups of overlapping islands) - visited = set() - merged_islands = [] - - for start_idx in range(num_islands): - if start_idx in visited: - continue - - # Find all islands connected to this one - group_indices = set() - queue = [start_idx] - - while queue: - current = queue.pop(0) - if current in visited: - continue - - visited.add(current) - group_indices.add(current) - - for neighbor in overlap_graph[current]: - if neighbor not in visited: - queue.append(neighbor) - - # Merge islands in this group - if len(group_indices) == 1: - # Single island, no merge needed - merged_islands.append(islands[start_idx]) - else: - # Merge multiple islands - merged_uvs = set() - merged_vert_indices = set() - merged_loops = [] - - for idx in group_indices: - island = islands[idx] - merged_uvs.update(island['uvs']) - merged_vert_indices.update(island['vert_indices']) - merged_loops.extend(island['loops']) - - merged_islands.append({ - 'uvs': merged_uvs, - 'vert_indices': merged_vert_indices, - 'loops': merged_loops - }) - - return merged_islands - - def get_submesh_avg_z(self, mesh, submesh_indices): - """Calculate average Z position of a submesh""" - if not submesh_indices: - return 0.0 - - total_z = 0.0 - for idx in submesh_indices: - total_z += mesh.vertices[idx].co.z - - return total_z / len(submesh_indices) - def execute(self, context): obj = context.active_object mesh = obj.data - # Get UV layer - uv_layer = mesh.uv_layers.active - if not uv_layer: - self.report({'ERROR'}, "No active UV layer") - return {'CANCELLED'} - - # Create BMesh bm = bmesh.from_edit_mesh(mesh) bm_uv_layer = bm.loops.layers.uv.active - # Get UV islands from selected faces + # Get UV islands uv_islands = self.get_uv_islands(bm, bm_uv_layer) - if not uv_islands: - self.report({'WARNING'}, "No UV islands found in selection") + self.report({'WARNING'}, "No UV islands found") return {'CANCELLED'} - # Performance warning for large meshes - if len(uv_islands) > 500 and self.lock_overlapping: - self.report({'WARNING'}, f"Processing {len(uv_islands)} islands with overlap detection may be slow") - - # Merge overlapping islands if requested - original_count = len(uv_islands) - if self.skip_overlap_check: - merged_count = 0 - else: - uv_islands = self.merge_overlapping_islands(uv_islands, bm_uv_layer) - merged_count = original_count - len(uv_islands) - - # Get submeshes (vertex islands) + # Get submeshes and their Z values bpy.ops.object.mode_set(mode='OBJECT') + submeshes = self.get_selected_submeshes(mesh) - # Get selected vertices for submesh detection - selected_indices = {v.index for v in mesh.vertices if v.select} - - # Build submeshes (reusing logic from other operators) - adjacency = {idx: set() for idx in selected_indices} - for edge in mesh.edges: - v0, v1 = edge.vertices - if v0 in selected_indices and v1 in selected_indices: - adjacency[v0].add(v1) - adjacency[v1].add(v0) - - submeshes = [] - visited = set() - - # Build vertex-to-submesh mapping for O(1) lookups - vertex_to_submesh = {} - submesh_idx = 0 - - for start_idx in selected_indices: - if start_idx in visited: - continue - - submesh = set() - queue = [start_idx] - - while queue: - current = queue.pop(0) - if current in visited: - continue - - visited.add(current) - submesh.add(current) - vertex_to_submesh[current] = submesh_idx - - for neighbor in adjacency[current]: - if neighbor not in visited: - queue.append(neighbor) - - submeshes.append(submesh) - submesh_idx += 1 - - # Calculate average Z for each submesh submesh_z_values = [] for submesh in submeshes: - avg_z = self.get_submesh_avg_z(mesh, submesh) + avg_z = sum(mesh.vertices[idx].co.z for idx in submesh) / len(submesh) submesh_z_values.append(avg_z) - # Return to edit mode to work with BMesh + # 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 once for all islands - uv_to_loops = {} + # Build UV to loops mapping + uv_to_loops = defaultdict(list) for face in bm.faces: - if not face.select: - continue - - for loop in face.loops: - uv = loop[bm_uv_layer].uv - uv_key = (round(uv.x, 6), round(uv.y, 6)) - - if uv_key not in uv_to_loops: - uv_to_loops[uv_key] = [] - uv_to_loops[uv_key].append(loop) + 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 to islands efficiently + # Assign loops and create island data + island_data = [] for island in uv_islands: island['loops'] = [] for uv_key in island['uvs']: - if uv_key in uv_to_loops: - island['loops'].extend(uv_to_loops[uv_key]) + island['loops'].extend(uv_to_loops.get(uv_key, [])) - # Assign UV islands to submeshes and get bounds - island_data = [] - for island in uv_islands: - submesh_idx = self.get_submesh_of_island_fast(island['vert_indices'], vertex_to_submesh) - if submesh_idx is not None and island['loops']: # Make sure we have loops - bounds = self.get_island_bounds(island, bm_uv_layer) - width = bounds[2] - bounds[0] - height = bounds[3] - bounds[1] - - # Skip degenerate islands - if width <= 0 or height <= 0: - continue + 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 - island_data.append({ - 'island': island, - 'submesh_idx': submesh_idx, - 'submesh_z': submesh_z_values[submesh_idx], - 'bounds': bounds, - 'width': width, - 'height': height, - 'min_u': bounds[0], - 'min_v': bounds[1] - }) - - # Sort islands by submesh Z (descending, so higher Z is at top of UV space) + 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 total area needed - total_area = 0 - max_island_size = 0 - for data in island_data: - area = (data['width'] + self.padding) * (data['height'] + self.padding) - total_area += area - max_island_size = max(max_island_size, max(data['width'], data['height'])) - - # Calculate optimal dimensions considering row constraints - num_islands = len(island_data) - min_rows_needed = math.ceil(num_islands / self.max_islands_per_row) - - # Calculate average island dimensions - avg_width = sum(data['width'] for data in island_data) / num_islands if num_islands > 0 else 0 - avg_height = sum(data['height'] for data in island_data) / num_islands if num_islands > 0 else 0 - - # Estimate dimensions based on constraints - if self.max_islands_per_row < 10: # User wants specific column layout - # Width based on max islands per row - estimated_width = self.max_islands_per_row * (avg_width + self.padding) - # Height based on minimum rows needed - estimated_height = min_rows_needed * (avg_height + self.padding) - # Use the larger dimension to maintain reasonable aspect ratio - target_size = max(estimated_width, math.sqrt(total_area) * 1.1) - else: - # Default behavior: aim for square packing - target_size = max(math.sqrt(total_area) * 1.2, max_island_size + 2 * self.padding) - - # Scale to fit in UV space (0-1) - if target_size > 1.0: - scale_factor = 0.95 / target_size # Leave some margin - # Scale all islands - for data in island_data: - data['width'] *= scale_factor - data['height'] *= scale_factor - # Update bounds to scaled values - data['scaled_min_u'] = data['min_u'] * scale_factor - data['scaled_min_v'] = data['min_v'] * scale_factor - data['scaled_max_v'] = (data['bounds'][3] - data['bounds'][1]) * scale_factor + data['scaled_min_v'] - target_size = 0.95 - else: - scale_factor = 1.0 - # Even without scaling, store the values for consistency - for data in island_data: - data['scaled_min_u'] = data['min_u'] - data['scaled_min_v'] = data['min_v'] - data['scaled_max_v'] = data['bounds'][3] - - # Pack islands using a simple shelf packing algorithm - rows = [] + # 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 = [] - current_row_height = 0 - current_row_width = 0 for data in island_data: - width = data['width'] - height = data['height'] - - # Check if island fits in current row (both width and count constraints) - fits_width = current_row_width + width + self.padding <= target_size or not current_row - under_max_count = len(current_row) < self.max_islands_per_row - - if fits_width and under_max_count: - # Add to current row - current_row.append(data) - current_row_width += width + self.padding - current_row_height = max(current_row_height, height) - else: - # Start new row (only append if current row is not empty) - if current_row: - rows.append((current_row, current_row_height)) - current_row = [data] - current_row_width = width + self.padding - current_row_height = height - - # Add last row - if current_row: - rows.append((current_row, current_row_height)) + width = data['width'] * scale_factor + height = data['height'] * scale_factor - # Calculate actual bounding box height - total_height = sum(row[1] for row in rows) + self.padding * (len(rows) + 1) + # 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) - # Center the packed result in UV space - start_u = (1.0 - target_size) / 2.0 - start_v = (1.0 - min(total_height, 1.0)) / 2.0 + min(total_height, 1.0) + 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 - # Place islands - current_v = start_v + 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 - for row_idx, (row_islands, row_height) in enumerate(rows): - # Center row horizontally - row_actual_width = sum(data['width'] for data in row_islands) + self.padding * (len(row_islands) - 1) - current_u = start_u + (target_size - row_actual_width) / 2.0 + current_u += row_data['width'] * scale_factor + self.padding - # Find the actual top of this row (highest point of any island) - row_top = current_v + current_v -= row_height + self.padding + current_row = [] - for data in row_islands: - # Calculate offset to position island at current location - # We want the TOP of the island's bounding box at row_top - offset_u = current_u - data['scaled_min_u'] - offset_v = row_top - data['scaled_max_v'] + current_row.append(data) - # Move all UVs in this island - for loop in data['island']['loops']: + # 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 += data['width'] + self.padding - - # Move down by the full height of the row plus extra spacing - current_v = row_top - row_height - self.padding + current_u += row_data['width'] * scale_factor + self.padding - # Update mesh bmesh.update_edit_mesh(mesh) - - # Report results - if self.lock_overlapping and merged_count > 0: - self.report({'INFO'}, f"Packed {len(island_data)} UV islands ({merged_count} overlapping merged) from {len(submeshes)} submeshes") - else: - self.report({'INFO'}, f"Packed {len(island_data)} UV islands from {len(submeshes)} submeshes") + self.report({'INFO'}, f"Packed {len(island_data)} UV islands from {len(submeshes)} submeshes") return {'FINISHED'} def draw(self, context): @@ -1032,24 +675,11 @@ class MESH_OT_pack_uv_islands_by_submesh(Operator): layout.prop(self, "lock_overlapping") layout.prop(self, "skip_overlap_check") - if self.skip_overlap_check and self.lock_overlapping: - layout.label(text="Skip Overlap overrides Lock Overlapping", icon='INFO') - - layout.label(text="Higher Z submeshes → Higher V position", icon='INFO') - # Performance hints - col = layout.column() - col.scale_y = 0.8 - col.label(text="Performance tips:", icon='TIME') - col.label(text="• Use Skip Overlap for >500 islands") - col.label(text="• Set Max Islands/Row for control") - - -class MESH_OT_merge_by_distance_in_submeshes(Operator): - bl_idname = "mesh.merge_by_distance_in_submeshes" +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" - bl_options = {'REGISTER', 'UNDO'} merge_distance: FloatProperty( name="Merge Distance", @@ -1061,187 +691,107 @@ class MESH_OT_merge_by_distance_in_submeshes(Operator): subtype='DISTANCE' ) - @classmethod - def poll(cls, context): - obj = context.active_object - return (obj is not None and - obj.type == 'MESH' and - context.mode == 'EDIT_MESH') - - def get_selected_vertex_islands(self, mesh): - """Find all contiguous groups of selected vertices - works like other operators""" - # Get selected vertices - selected_indices = {v.index for v in mesh.vertices if v.select} - - if not selected_indices: - return [] - - # Build adjacency only for selected vertices - adjacency = {idx: set() for idx in selected_indices} - - # Only check edges that might connect selected vertices - for edge in mesh.edges: - v0, v1 = edge.vertices - if v0 in selected_indices and v1 in selected_indices: - adjacency[v0].add(v1) - adjacency[v1].add(v0) - - islands = [] - visited = set() - - from collections import deque - - for start_idx in selected_indices: - if start_idx in visited: - continue - - island = set() - queue = deque([start_idx]) - - while queue: - current = queue.pop(0) - if current in visited: - continue - - visited.add(current) - island.add(current) - - for neighbor in adjacency[current]: - if neighbor not in visited: - queue.append(neighbor) - - islands.append(island) - - return islands - - def execute(self, context): - obj = context.active_object + def process_object(self, context, obj): + """Process a single object and return (success, stats)""" mesh = obj.data - - # Use the most efficient approach: single merge with island constraints bm = bmesh.from_edit_mesh(mesh) - # Get selected vertices selected_verts = [v for v in bm.verts if v.select] if not selected_verts: - self.report({'WARNING'}, "No vertices selected") - return {'CANCELLED'} + return False, {} - # Build islands using optimized algorithm + # Build islands using BMesh selected_set = set(selected_verts) - vert_to_island = {} - island_id = 0 + island_verts = [] + visited = set() - # Find islands with stack-based traversal - for v in selected_verts: - if v in vert_to_island: + for start_v in selected_verts: + if start_v in visited: continue - # Mark all vertices in this island - stack = [v] + # Find island + island = [] + stack = [start_v] + while stack: current = stack.pop() - if current in vert_to_island: + if current in visited: continue + visited.add(current) + island.append(current) - vert_to_island[current] = island_id - - # Add connected vertices for edge in current.link_edges: other = edge.other_vert(current) - if other in selected_set and other not in vert_to_island: + if other in selected_set and other not in visited: stack.append(other) - island_id += 1 + island_verts.append(island) - # Build merge mapping manually to avoid repeated operations + # Merge within each island merge_targets = {} - total_merged = 0 - islands_with_merges = 0 + merge_dist_sq = self.merge_distance ** 2 + merged_count = 0 - # For each island, find vertices to merge - from collections import defaultdict - island_verts = defaultdict(list) - for v, iid in vert_to_island.items(): - island_verts[iid].append(v) - - # Process each island - for island_id, verts in island_verts.items(): + for verts in island_verts: if len(verts) < 2: continue - # Build spatial hash for this island only - merge_dist_sq = self.merge_distance * self.merge_distance - merged_in_island = 0 - - # Simple O(n²) for small islands is often faster than spatial hashing - # Most submeshes have 10-50 verts, so this is actually efficient processed = set() for i, v1 in enumerate(verts): if v1 in merge_targets or v1 in processed: continue - processed.add(v1) - # Find vertices within merge distance for v2 in verts[i+1:]: if v2 in merge_targets or v2 in processed: continue - # Check distance - diff = v1.co - v2.co - if diff.length_squared <= merge_dist_sq: + if (v1.co - v2.co).length_squared <= merge_dist_sq: merge_targets[v2] = v1 processed.add(v2) - merged_in_island += 1 - - if merged_in_island > 0: - total_merged += merged_in_island - islands_with_merges += 1 + merged_count += 1 - # Now perform all merges in one go using BMesh weld + # Perform merges if merge_targets: - # Convert merge mapping to format expected by weld_verts targetmap = {v: merge_targets[v] for v in merge_targets if v.is_valid} - if targetmap: bmesh.ops.weld_verts(bm, targetmap=targetmap) - # Update the mesh bmesh.update_edit_mesh(mesh) - total_islands = len(island_verts) - multi_vert_islands = sum(1 for verts in island_verts.values() if len(verts) >= 2) - single_vert_islands = total_islands - multi_vert_islands + return merged_count > 0, {'merged': merged_count} - if total_merged > 0: - self.report({'INFO'}, f"Merged {total_merged} vertices in {islands_with_merges} of {multi_vert_islands} submeshes (skipped {single_vert_islands} single-vertex)") + 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: - self.report({'INFO'}, f"No vertices close enough to merge in {multi_vert_islands} submeshes") + return "No vertices close enough to merge" - return {'FINISHED'} + @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") - layout.label(text="Merges within submeshes only", icon='INFO') -class MESH_OT_bake_vertex_and_rotation_combined(Operator): - bl_idname = "mesh.bake_vertex_and_rotation_combined" - bl_label = "Bake Vectors & Rotation Combined" - bl_description = "Bake vertex vectors relative to orthonormal basis and orientation quaternions in one operation" - bl_options = {'REGISTER', 'UNDO'} +class MESH_OT_bake_vertex_and_rotation_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 of vertices separately with its own center and scale", + description="Process each contiguous group separately", default=True ) normal_epsilon: FloatProperty( name="Normal Epsilon", - description="Minimum angle difference (radians) between normals to consider them unique", + description="Minimum angle difference between normals", default=0.1, min=0.01, max=1.0, @@ -1250,72 +800,25 @@ class MESH_OT_bake_vertex_and_rotation_combined(Operator): use_cache: BoolProperty( name="Cache Identical Submeshes", - description="Optimize by caching calculations for identical submeshes (recommended for meshes with many repeated elements)", + description="Cache calculations for identical submeshes", default=True ) - @classmethod - def poll(cls, context): - obj = context.active_object - return (obj is not None and - obj.type == 'MESH' and - context.mode == 'EDIT_MESH') - - def get_vertex_islands(self, mesh, selected_indices): - """Find contiguous groups of vertices""" - from collections import deque - - # Build adjacency - adjacency = {idx: [] for idx in selected_indices} - for edge in mesh.edges: - v0, v1 = edge.vertices - if v0 in adjacency and v1 in adjacency: - adjacency[v0].append(v1) - adjacency[v1].append(v0) - - # Find islands - islands = [] - visited = set() - - for start_idx in selected_indices: - if start_idx in visited: - continue - - island = set() - queue = deque([start_idx]) - - while queue: - current = queue.popleft() - if current in visited: - continue - visited.add(current) - island.add(current) - - for neighbor in adjacency.get(current, []): - if neighbor not in visited: - queue.append(neighbor) - - islands.append(island) - - return islands - def calculate_island_data(self, mesh, island_indices): """Calculate center and scale for an island""" if not island_indices: return None, 1.0 - - # Calculate center + center = mathutils.Vector((0.0, 0.0, 0.0)) for idx in island_indices: center += mesh.vertices[idx].co center /= len(island_indices) - - # Calculate scale (1 / max distance from center) - max_dist = 0.0 - for idx in island_indices: - dist = max(abs(c - center[i]) for i, c in enumerate(mesh.vertices[idx].co)) - max_dist = max(max_dist, dist) - + + max_dist = max((abs(c - center[i]) + for idx in island_indices + for i, c in enumerate(mesh.vertices[idx].co)), + default=0) + scale = 1.0 / max_dist if max_dist > 0 else 1.0 return center, scale @@ -1323,113 +826,65 @@ class MESH_OT_bake_vertex_and_rotation_combined(Operator): """Build orthonormal basis from face normals""" if not face_indices: return mathutils.Matrix.Identity(3) - - # Get largest face normal as primary axis + + # 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 a second normal that's different enough - y_axis = None + + # 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 no good second normal, create perpendicular + 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() - - # Complete the basis + z_axis = x_axis.cross(y_axis) - - # Ensure right-handed coordinate system + 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, scale, tolerance=0.0001): - """Create a hash signature for a submesh based on its local geometry""" - # Collect local vertex positions (relative to center and normalized by scale) + def create_submesh_signature(self, mesh, island_indices, center, scale): + """Create signature for caching""" + tolerance = 0.0001 local_positions = [] + for idx in island_indices: local_pos = (mesh.vertices[idx].co - center) * scale - # Round to tolerance to handle floating point differences - rounded = ( - round(local_pos.x / tolerance) * tolerance, - round(local_pos.y / tolerance) * tolerance, - round(local_pos.z / tolerance) * tolerance - ) + rounded = tuple(round(local_pos[i] / tolerance) * tolerance for i in range(3)) local_positions.append(rounded) - - # Sort for consistent ordering + local_positions.sort() - - # Create signature from vertex count and positions - signature = (len(island_indices), tuple(local_positions)) - return signature - - def calculate_submesh_data(self, mesh, island, selected_faces, scale, correction): - """Calculate basis, quaternion, and inverted basis for a submesh""" - # Get faces for this island - island_faces = [f for f in selected_faces - if all(v in island for v in mesh.polygons[f].vertices)] - - # Build basis matrix - basis = self.build_basis_from_faces(mesh, island_faces, self.normal_epsilon) - - # Calculate quaternion - quat = basis.to_quaternion() - quat.normalize() - if quat.w < 0: - quat.negate() - quat = correction @ quat - - # Cache inverted basis - basis_inv = basis.inverted() - - return scale, basis, quat, basis_inv + return (len(island_indices), tuple(local_positions)) - def execute(self, context): - obj = context.active_object + def process_object(self, context, obj): + """Process a single object and return (success, stats)""" mesh = obj.data + selected = MeshUtils.get_selected_vertices(mesh) - # Switch to object mode - bpy.ops.object.mode_set(mode='OBJECT') - - # Get selected vertices - selected_indices = {v.index for v in mesh.vertices if v.select} - if not selected_indices: - self.report({'WARNING'}, "No vertices selected") - bpy.ops.object.mode_set(mode='EDIT') - return {'CANCELLED'} - - # Ensure mesh has faces - if not mesh.polygons: - self.report({'ERROR'}, "Mesh has no faces") - bpy.ops.object.mode_set(mode='EDIT') - return {'CANCELLED'} + 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") - uv_layer1 = mesh.uv_layers.get("BakedOriginAngle1") - if not uv_layer0: - uv_layer0 = mesh.uv_layers.new(name="BakedOriginAngle0") - if not uv_layer1: - uv_layer1 = mesh.uv_layers.new(name="BakedOriginAngle1") + 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 @@ -1438,68 +893,69 @@ class MESH_OT_bake_vertex_and_rotation_combined(Operator): ).to_quaternion() # Build vertex to loops mapping - vertex_loops = {} + vertex_loops = defaultdict(list) selected_faces = [] - + for poly in mesh.polygons: face_verts = set(poly.vertices) - if face_verts & selected_indices: # Face has selected vertices - if face_verts <= selected_indices: # All vertices selected + 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_indices: - vertex_loops.setdefault(vert_idx, []).append(loop_idx) + if vert_idx in selected: + vertex_loops[vert_idx].append(loop_idx) - # Get islands to process - if self.contiguous_mode: - islands = self.get_vertex_islands(mesh, selected_indices) - else: - islands = [selected_indices] # Single island with all selected + # 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 identical submeshes - stores (scale, basis, quaternion, basis_inv) submesh_cache = {} if self.use_cache else None - cache_hits = 0 - + for island in islands: - # Calculate island data center, scale = self.calculate_island_data(mesh, island) if center is None: continue - # Check if we should use caching + # Check cache if self.use_cache: - # Create signature for this submesh signature = self.create_submesh_signature(mesh, island, center, scale) - - # Check cache for identical submesh if signature in submesh_cache: - # Reuse cached data scale, basis, quat, basis_inv = submesh_cache[signature] - cache_hits += 1 else: - # Calculate new data and store in cache - data = self.calculate_submesh_data(mesh, island, selected_faces, scale, correction) - scale, basis, quat, basis_inv = data - submesh_cache[signature] = data + 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) + quat = basis.to_quaternion() + quat.normalize() + if quat.w < 0: + quat.negate() + quat = correction @ quat + basis_inv = basis.inverted() + + submesh_cache[signature] = (scale, basis, quat, basis_inv) else: - # No caching - calculate data directly - scale, basis, quat, basis_inv = self.calculate_submesh_data(mesh, island, selected_faces, scale, correction) - + 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) + quat = basis.to_quaternion() + quat.normalize() + if quat.w < 0: + quat.negate() + quat = correction @ quat + basis_inv = basis.inverted() + # Transform vertices center_world = world_matrix @ center - + for vert_idx in island: - # Calculate local position 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, @@ -1507,26 +963,31 @@ class MESH_OT_bake_vertex_and_rotation_combined(Operator): (local_pos.z * scale + 1.0) * 0.5, scale )) - - # Apply to all loops of this vertex + + # 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() - bpy.ops.object.mode_set(mode='EDIT') - # Report with cache information - if self.use_cache and submesh_cache: - unique_submeshes = len(submesh_cache) - if cache_hits > 0: - self.report({'INFO'}, f"Baked {len(islands)} islands ({unique_submeshes} unique, {cache_hits} cache hits) with {len(selected_indices)} vertices") - else: - self.report({'INFO'}, f"Baked {len(islands)} islands ({unique_submeshes} unique shapes) with {len(selected_indices)} vertices") - else: - self.report({'INFO'}, f"Baked {len(islands)} island(s) with {len(selected_indices)} vertices") - return {'FINISHED'} + 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 @@ -1542,15 +1003,10 @@ class MESH_OT_bake_vertex_and_rotation_combined(Operator): row.prop(settings, "correction_angle_y") row.prop(settings, "correction_angle_z") - layout.label(text="Vectors relative to orthonormal basis", icon='INFO') - layout.label(text="Stores quaternion in UV maps:", icon='INFO') - layout.label(text=" BakedOriginAngle0: X, Y components") - layout.label(text=" BakedOriginAngle1: Z, W components") - class MESH_PT_bake_vertex_panel(Panel): - bl_label = "Bake Vertex Vectors" - bl_idname = "MESH_PT_bake_vertex_vectors" + bl_label = "Bake Submesh Data" + bl_idname = "MESH_PT_bake_submesh_data" bl_space_type = 'VIEW_3D' bl_region_type = 'UI' bl_category = "Tool" @@ -1559,71 +1015,38 @@ class MESH_PT_bake_vertex_panel(Panel): layout = self.layout obj = context.active_object - col = layout.column() - - if obj and obj.type == 'MESH': - if context.mode == 'EDIT_MESH': - col.operator("mesh.select_all_linked_submeshes", 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_in_submeshes", icon='AUTOMERGE_ON') - col.operator("mesh.pack_uv_islands_by_submesh", icon='UV') - col.separator() - - # Correction settings - settings = context.scene.bake_vertex_settings - box = col.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") - - col.operator("mesh.bake_vertex_and_rotation_combined", icon='EXPORT', text="Bake Vectors & Rotation") - - box = col.box() - box.label(text="Info:", icon='INFO') - box.label(text="Select All Linked: Expand selection to full submeshes") - box.label(text="Select Linked Cross: Select linked across boundaries") - box.label(text="Deduplicate: Remove duplicate selected submeshes") - box.label(text="Merge: Merge vertices within submeshes") - box.label(text="Pack UV Islands: Sort UV islands by submesh Z position") - box.label(text="Bake Vectors & Rotation: Bake vectors relative to") - box.label(text=" orthonormal basis & orientation quaternions") - box.label(text="Toggle Contiguous Groups for separate islands") - box.label(text="Vectors stored in vertex colors, quaternions in UV maps") - box.label(text="Scale factor stored in alpha channel") - - mesh = obj.data - if mesh.vertex_colors and len(mesh.vertex_colors) > 0: - col.separator() - col.label(text=f"Active: {mesh.vertex_colors.active.name}", icon='GROUP_VCOL') - else: - col.label(text="Enter Edit Mode to bake vertices", icon='INFO') + 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: - col.label(text="Select a mesh object", icon='ERROR') + layout.label(text="Enter Edit Mode to use tools", icon='INFO') classes = [ BakeVertexSettings, - MESH_OT_bake_vertex_and_rotation_combined, - MESH_OT_select_all_linked_submeshes, + MESH_OT_select_all_linked, MESH_OT_select_linked_across_boundaries, MESH_OT_deduplicate_submeshes, - MESH_OT_pack_uv_islands_by_submesh, - MESH_OT_merge_by_distance_in_submeshes, + MESH_OT_pack_uv_islands_by_submesh_z, + MESH_OT_merge_by_distance_per_submesh, + MESH_OT_bake_vertex_and_rotation_combined, MESH_PT_bake_vertex_panel ] def menu_func(self, context): self.layout.separator() - self.layout.operator("mesh.select_all_linked_submeshes", icon='SELECT_EXTEND') + 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_in_submeshes", icon='AUTOMERGE_ON') - self.layout.operator("mesh.pack_uv_islands_by_submesh", icon='UV') - self.layout.operator("mesh.bake_vertex_and_rotation_combined", icon='EXPORT') + 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(): |