Merge pull request #22 from PassiveModding/feature/bake

Feature/bake

Author: PassiveModding

MeddleTools/bake/Bake Guide.md

@@ -0,0 +1,5 @@
+Bake Guide
+- Reproject and retile
+- Bake
+- Atlas
+- Export

MeddleTools/bake/__init__.py

@@ -0,0 +1,13 @@
+from .bake import RunBake
+from .panel import MeddleBakePanel
+from .atlas import RunAtlas
+from .export_fbx import ExportFBX
+from .reproject_retile import ReprojectRetile
+
+classes = [
+	RunBake,
+	MeddleBakePanel,
+	RunAtlas,
+	ExportFBX,
+	ReprojectRetile,
+]

MeddleTools/bake/atlas.py

@@ -0,0 +1,98 @@
+import bpy
+    
+def require_mesh_or_armature_selected(context):
+    """Check if operation can be executed"""
+    # Require at least one mesh or armature selected
+    return any(obj.type in {'MESH', 'ARMATURE'} for obj in context.selected_objects)
+
+def get_selected_armatures(context):
+    """Get selected armature objects"""
+    return [obj for obj in context.selected_objects if obj.type == 'ARMATURE']
+
+def get_selected_meshes(context):
+    """Get selected mesh objects"""
+    return [obj for obj in context.selected_objects if obj.type == 'MESH']
+
+def get_all_selected_meshes(context):
+    """Get all selected mesh objects, including those parented to selected armatures"""
+    selected_armatures = get_selected_armatures(context)
+    selected_meshes = get_selected_meshes(context)
+    
+    # Include meshes parented to selected armatures
+    for armature in selected_armatures:
+        for child in armature.children:
+            if child.type == 'MESH' and child not in selected_meshes:
+                selected_meshes.append(child)
+    
+    return selected_meshes
+
+def get_uv_islands(mesh):
+    visited = set()
+    islands = []
+    
+    # Build adjacency map based on UV edges
+    # Two loops are connected if they share an edge with matching UVs
+    # def build_uv_adjacency():
+    #     adjacency = {}
+    #     for poly in mesh.polygons:
+    #         loop_indices = list(poly.loop_indices)
+    #         for i, li in enumerate(loop_indices):
+    #             next_li = loop_indices[(i + 1) % len(loop_indices)]
+    #             if li not in adjacency:
+    #                 adjacency[li] = []
+    #             if next_li not in adjacency:
+    #                 adjacency[next_li] = []
+    #             adjacency[li].append(next_li)
+    #             adjacency[next_li].append(li)
+    #     return adjacency
+    uv_layer = mesh.uv_layers.active
+    if uv_layer is None:
+        return []
+    
+    def build_uv_adjacency():
+        # Map UV coordinates to loop indices
+        uv_to_loops = {}
+        for loop_index, uv in enumerate(uv_layer.data):
+            uv_coord = (round(uv.uv.x, 6), round(uv.uv.y, 6))  # Round to handle float precision
+            if uv_coord not in uv_to_loops:
+                uv_to_loops[uv_coord] = []
+            uv_to_loops[uv_coord].append(loop_index)
+        
+        # Build adjacency based on shared UV coordinates
+        adjacency = {}
+        for loops in uv_to_loops.values():
+            for li in loops:
+                if li not in adjacency:
+                    adjacency[li] = []
+                # Connect all loops that share this UV coordinate
+                adjacency[li].extend([other_li for other_li in loops if other_li != li])
+        
+        return adjacency
+    
+    adjacency = build_uv_adjacency()
+    
+    def get_connected_loops(start_loop_index):
+        to_visit = [start_loop_index]
+        island_loops = set()
+        while to_visit:
+            loop_index = to_visit.pop()
+            if loop_index in visited:
+                continue
+            visited.add(loop_index)
+            island_loops.add(loop_index)
+            
+            # Add adjacent loops (within same polygon)
+            if loop_index in adjacency:
+                for adjacent_li in adjacency[loop_index]:
+                    if adjacent_li not in visited:
+                        to_visit.append(adjacent_li)
+        return island_loops
+    
+    # Find all islands
+    for poly in mesh.polygons:
+        for loop_index in poly.loop_indices:
+            if loop_index not in visited:
+                island_loops = get_connected_loops(loop_index)
+                islands.append(island_loops)
+                
+    return islands

MeddleTools/bake/bake.py

@@ -0,0 +1,208 @@
+from . import bake_utils
+import bpy
+import logging
+from bpy.types import Operator
+import os
+
+logger = logging.getLogger(__name__)
+logger.addHandler(logging.NullHandler())
+
+class ExportFBX(Operator):
+    """Export selected mesh objects to FBX format with textures"""
+    bl_idname = "meddle.export_fbx"
+    bl_label = "Export FBX"
+    bl_description = "Export selected mesh objects to FBX format with textures in a subfolder"
+    bl_options = {'REGISTER', 'UNDO'}
+    
+    # Directory path for export
+    directory: bpy.props.StringProperty(
+        name="Export Directory",
+        description="Directory to export FBX and textures",
+        subtype='DIR_PATH'
+    )
+    
+    def invoke(self, context, event):
+        """Open file browser for directory selection"""
+        # Set default directory to blend file location or user home
+        if bpy.data.filepath:
+            self.directory = os.path.dirname(bpy.data.filepath)
+        else:
+            self.directory = os.path.expanduser("~")
+        
+        context.window_manager.fileselect_add(self)
+        return {'RUNNING_MODAL'}
+    
+    @classmethod
+    def poll(cls, context):
+        return bake_utils.require_mesh_or_armature_selected(context)
+        
+    def execute(self, context):
+        """Execute the FBX export operation"""
+        if not self.directory:
+            self.report({'ERROR'}, "No directory selected")
+            return {'CANCELLED'}
+        
+        try:
+            # Get selected objects
+            selected_objects = context.selected_objects
+            mesh_objects = [obj for obj in selected_objects if obj.type == 'MESH']
+            armature_objects = [obj for obj in selected_objects if obj.type == 'ARMATURE']
+            
+            # If armatures are selected, include their child meshes
+            for armature in armature_objects:
+                for obj in bpy.data.objects:
+                    if obj.type == 'MESH' and obj.parent == armature:
+                        if obj not in mesh_objects and obj not in selected_objects:
+                            selected_objects.append(obj)
+                        if obj not in mesh_objects:
+                            mesh_objects.append(obj)
+            
+            if not mesh_objects and not armature_objects:
+                self.report({'ERROR'}, "No mesh or armature objects selected")
+                return {'CANCELLED'}
+            
+            # Create textures subfolder
+            textures_folder = os.path.join(self.directory, "textures")
+            os.makedirs(textures_folder, exist_ok=True)
+            logger.info(f"Created textures folder: {textures_folder}")
+            
+            # Export images to textures folder
+            self.export_textures(context, mesh_objects, textures_folder)
+            
+            # Generate FBX filename
+            fbx_filename = self.generate_fbx_filename(context, selected_objects)
+            fbx_path = os.path.join(self.directory, fbx_filename)
+            
+            # Export FBX with packed images
+            self.export_fbx_file(context, selected_objects, fbx_path)
+            
+            self.report({'INFO'}, f"Successfully exported to {fbx_path}")
+            logger.info(f"Export complete: {fbx_path}")
+            
+            return {'FINISHED'}
+            
+        except Exception as e:
+            self.report({'ERROR'}, f"Export failed: {str(e)}")
+            logger.error(f"Export failed: {e}", exc_info=True)
+            return {'CANCELLED'}
+    
+    def export_textures(self, context, mesh_objects, textures_folder):
+        """Export all textures used by mesh materials to the textures folder"""
+        exported_images = set()
+        image_count = 0
+        
+        for mesh_obj in mesh_objects:
+            if not mesh_obj.data.materials:
+                continue
+            
+            for mat_slot in mesh_obj.data.materials:
+                if not mat_slot or not mat_slot.use_nodes:
+                    continue
+                
+                material = mat_slot
+                for node in material.node_tree.nodes:
+                    if node.type != 'TEX_IMAGE' or not node.image:
+                        continue
+                    
+                    image = node.image
+                    
+                    # Skip if already exported
+                    if image.name in exported_images:
+                        continue
+                    
+                    # Determine output filename
+                    if image.filepath:
+                        # Use existing filename
+                        base_name = os.path.basename(image.filepath)
+                        if not base_name:
+                            base_name = f"{image.name}.png"
+                    else:
+                        base_name = f"{image.name}.png"
+                    
+                    # Ensure .png extension
+                    if not base_name.lower().endswith('.png'):
+                        base_name = os.path.splitext(base_name)[0] + '.png'
+                    
+                    output_path = os.path.join(textures_folder, base_name)
+                    
+                    # Save the image
+                    try:
+                        # Save a copy of the image
+                        original_filepath = image.filepath_raw
+                        original_format = image.file_format
+                        
+                        image.filepath_raw = output_path
+                        image.file_format = 'PNG'
+                        image.save()
+                        
+                        # Restore original settings
+                        image.filepath_raw = original_filepath
+                        image.file_format = original_format
+                        
+                        logger.info(f"Exported texture: {base_name}")
+                        exported_images.add(image.name)
+                        image_count += 1
+                    except Exception as e:
+                        logger.warning(f"Failed to export texture {image.name}: {e}")
+        
+        self.report({'INFO'}, f"Exported {image_count} texture(s) to textures folder")
+        logger.info(f"Exported {image_count} textures to {textures_folder}")
+    
+    def generate_fbx_filename(self, context, selected_objects):
+        """Generate a filename for the FBX export"""
+        # Try to use armature name, or first mesh name, or default
+        armature = next((obj for obj in selected_objects if obj.type == 'ARMATURE'), None)
+        
+        if armature:
+            base_name = armature.name
+        elif selected_objects:
+            base_name = selected_objects[0].name
+        else:
+            base_name = "export"
+        
+        # Sanitize filename
+        base_name = "".join(c for c in base_name if c.isalnum() or c in (' ', '_', '-')).strip()
+        if not base_name:
+            base_name = "export"
+        
+        return f"{base_name}.fbx"
+    
+    def export_fbx_file(self, context, selected_objects, fbx_path):
+        """Export the FBX file with selected objects"""
+        # Ensure objects are selected
+        bpy.ops.object.select_all(action='DESELECT')
+        for obj in selected_objects:
+            obj.select_set(True)
+        
+        # Set active object
+        armature = next((obj for obj in selected_objects if obj.type == 'ARMATURE'), None)
+        if armature:
+            context.view_layer.objects.active = armature
+        elif selected_objects:
+            context.view_layer.objects.active = selected_objects[0]
+        
+        # Export FBX with appropriate settings
+        bpy.ops.export_scene.fbx(
+            filepath=fbx_path,
+            use_selection=True,
+            global_scale=1.0,
+            apply_unit_scale=True,
+            apply_scale_options='FBX_SCALE_NONE',
+            bake_space_transform=False,
+            object_types={'ARMATURE', 'MESH'},
+            use_mesh_modifiers=True,
+            use_mesh_modifiers_render=True,
+            mesh_smooth_type='FACE',
+            use_tspace=True,
+            use_custom_props=False,
+            add_leaf_bones=False,
+            primary_bone_axis='Y',
+            secondary_bone_axis='X',
+            armature_nodetype='NULL',
+            bake_anim=False,
+            path_mode='COPY',  # Copy textures to export location
+            embed_textures=True,  # Embed textures in FBX
+            batch_mode='OFF'
+        )
+        
+        logger.info(f"FBX exported to: {fbx_path}")

MeddleTools/bake/bake_utils.py

@@ -0,0 +1,55 @@
+import bpy
+from .bake import RunBake
+from .atlas import RunAtlas
+from .export_fbx import ExportFBX
+from .reproject_retile import ReprojectRetile
+
+class MeddleBakePanel(bpy.types.Panel):
+    bl_idname = "OBJECT_PT_MeddleBakePanel"
+    bl_label = "Baking"
+    bl_space_type = 'VIEW_3D'
+    bl_region_type = 'UI'
+    bl_category = "Meddle Tools"
+    
+    def draw(self, context):
+        layout = self.layout
+        settings = context.scene.meddle_settings
+        
+        # UV Reproject and Retile Section
+        box = layout.box()
+        box.label(text="UV Operations", icon='UV')
+        box.operator(ReprojectRetile.bl_idname, text="Reproject and Retile UVs")
+        
+        # Baking Section
+        box = layout.box()
+        box.label(text="Baking", icon='RENDER_STILL')
+        
+        # Warning message in a sub-box
+        if True:  # Always show warning
+            col = box.column(align=True)
+            col.alert = True
+            col.label(text="Warning: Decals may bake incorrectly", icon='ERROR')
+            col.label(text="due to face symmetry. Disable UV1")
+            col.label(text="related layers before baking.")
+            box.separator(factor=0.5)
+        
+        # Project save warning
+        if not bpy.data.is_saved:
+            col = box.column(align=True)
+            col.alert = True
+            col.label(text="Save project before baking!", icon='ERROR')
+            box.separator(factor=0.5)
+        
+        box.prop(settings, "bake_samples")
+        box.operator(RunBake.bl_idname, text="Run Bake", icon='RENDER_STILL')
+        
+        # Texture Atlas Section
+        box = layout.box()
+        box.label(text="Texture Atlas", icon='TEXTURE')
+        box.prop(settings, "pack_alpha")
+        box.operator(RunAtlas.bl_idname, text="Create Atlas from Selection", icon='TEXTURE')
+        
+        # Export Section
+        box = layout.box()
+        box.label(text="Export", icon='EXPORT')
+        box.operator(ExportFBX.bl_idname, text="Export FBX with Textures", icon='EXPORT')