Extended handling for invalid geometry

Fixed variable naming for non-comb variable restore in the combined plugin.
Added skipping for geometry-less meshes.
Added rotation preprocessing (with Metashape option) to GUI and combined plugin.
Added normal transfer from the original to sliced mesh to prevent flipped normals.
Wrapped slicing face creation in a try-except block in case the source geometry has multiple faces that share the exact same verticies.

Author: gojushin

enviro_lod_tools/addons/ds_blender_baker_plug.py

@@ -10,7 +10,7 @@
 bl_info = {
     "name": "Baker Plugin",
     "author": "Nico Breycha",
-    "version": (0, 0, 2),
+    "version": (0, 0, 3),
     "blender": (4, 0, 0),
     "location": "View3D > Sidebar > Tool Tab",
     "description": "Bakes the base color of a defined mesh onto one or multiple selected meshes.",
@@ -135,6 +135,10 @@ def execute(self, context):
 
         # Bake the Lowpoly Meshes one by one.
         for lowpoly in lowpolys:
+            # Skip empty meshes
+            if len(lowpoly.data.polygons) == 0:
+                continue
+
             print(f"Progress: {progress_cnt}/{lowpoly_cnt}")
             bake(highpoly, lowpoly, settings)
             progress_cnt += 1

enviro_lod_tools/addons/ds_blender_combined_plugin.py

@@ -1,5 +1,6 @@
 import os
 import copy
+import math
 
 import bpy
 
@@ -12,7 +13,7 @@
 bl_info = {
     "name": "Automated LOD Generation Tool",
     "author": "Nico Breycha",
-    "version": (0, 0, 2),
+    "version": (0, 0, 3),
     "blender": (4, 0, 0),
     "location": "View3D > Sidebar > Tool Tab",
     "description": "Combines the Operator from all the other plugins.",
@@ -39,6 +40,9 @@ def _select_all_except_original():
         import_fp_comb = context.scene.import_fp_comb
         export_fp_comb = context.scene.export_fp_comb
 
+        # Preprocessing
+        rot_correction_comb = context.scene.rot_correction_comb
+
         # Cleanup Properties
         initial_reduction_comb = context.scene.initial_reduction_comb
         loose_threshold_comb = context.scene.loose_threshold_comb
@@ -63,19 +67,19 @@ def _select_all_except_original():
 
         restore_dict = {
             "initial_reduction": context.scene.initial_reduction,
-            "loose_threshold_comb": context.scene.loose_threshold,
+            "loose_threshold": context.scene.loose_threshold,
             "boundary_length": context.scene.boundary_length,
             "merge_threshold": context.scene.merge_threshold,
             "number_of_modules": context.scene.number_of_modules,
             "lod_count": context.scene.lod_count,
             "reduction_percentage": context.scene.reduction_percentage,
-            "baker_settings_comb": context.scene.baker_settings
+            "baker_settings": context.scene.baker_settings
                          }
 
         # Preserve the original values of the properties with shallow copy.
         restore_dict = copy.copy(restore_dict)
 
-        # Override Operator Properties
+        # Override Operator Properties for non-comb components
         context.scene.initial_reduction = initial_reduction_comb
         context.scene.loose_threshold = loose_threshold_comb
         context.scene.boundary_length = boundary_length_comb
@@ -102,6 +106,20 @@ def _select_all_except_original():
                 bpy.context.view_layer.objects.active = obj
 
         bpy.ops.object.join()
+        bpy.ops.object.transform_apply(location=True, rotation=True, scale=True)
+
+        # Apply rotation correction if needed
+        obj = bpy.context.active_object
+
+        if rot_correction_comb[0] != 0:
+            obj.rotation_euler[0] = math.radians(rot_correction_comb[0])
+        if rot_correction_comb[1] != 0:
+            obj.rotation_euler[1] = math.radians(rot_correction_comb[1])
+        if rot_correction_comb[2] != 0:
+            obj.rotation_euler[2] = math.radians(rot_correction_comb[2])
+
+        bpy.ops.object.transform_apply(location=True, rotation=True, scale=True)
+
 
         # Rename the original mesh. We will use it later for baking.
         original_mesh = bpy.context.active_object
@@ -128,6 +146,7 @@ def _select_all_except_original():
         print("Starting Slicing")
         launch_operator_by_name(SLICE_IDNAME)
 
+
         # Ensure Target Polycount set by the user as intial polycount.
         parts = []
 
@@ -177,18 +196,18 @@ def _select_all_except_original():
 
         # Restore Operator Properties
         context.scene.initial_reduction = restore_dict["initial_reduction"]
-        context.scene.loose_threshold = restore_dict["loose_threshold_comb"]
+        context.scene.loose_threshold = restore_dict["loose_threshold"]
         context.scene.boundary_length = restore_dict["boundary_length"]
         context.scene.merge_threshold = restore_dict["merge_threshold"]
         context.scene.number_of_modules = restore_dict["number_of_modules"]
         context.scene.lod_count = restore_dict["lod_count"]
         context.scene.reduction_percentage = restore_dict["reduction_percentage"]
 
-        context.scene.baker_settings.highpoly_mesh_name = restore_dict["baker_settings_comb"].highpoly_mesh_name
-        context.scene.baker_settings.ray_distance = restore_dict["baker_settings_comb"].ray_distance
-        context.scene.baker_settings.texture_resolution = restore_dict["baker_settings_comb"].texture_resolution
-        context.scene.baker_settings.texture_margin = restore_dict["baker_settings_comb"].texture_margin
-        context.scene.baker_settings.save_path = restore_dict["baker_settings_comb"].save_path
+        context.scene.baker_settings.highpoly_mesh_name = restore_dict["baker_settings"].highpoly_mesh_name
+        context.scene.baker_settings.ray_distance = restore_dict["baker_settings"].ray_distance
+        context.scene.baker_settings.texture_resolution = restore_dict["baker_settings"].texture_resolution
+        context.scene.baker_settings.texture_margin = restore_dict["baker_settings"].texture_margin
+        context.scene.baker_settings.save_path = restore_dict["baker_settings"].save_path
 
         # Save .blend File
         bpy.ops.wm.save_as_mainfile(filepath=blend_file_path, check_existing=False, compress=True)
@@ -211,6 +230,7 @@ def draw(self, context):
 
         io_box = layout.box()
         io_box.prop(scene, "import_fp_comb", text="Import Filepath")
+        io_box.prop(scene, "rot_correction_comb", text="Rotation Correction")
         io_box.prop(scene, "export_fp_comb", text="Export Filepath")
 
         # Create a box for Cleanup Properties and add labeled properties
@@ -257,6 +277,10 @@ def register():
     for cls in classes:
         register_class(cls)
 
+    # Preprocessing Properties
+    bpy.types.Scene.rot_correction_comb = bpy.props.FloatVectorProperty(name="Initial Rotation Correction",
+                                                                        default=(0.0, 0.0, 0.0), subtype="EULER")
+
     # Cleanup Properties
     bpy.types.Scene.initial_reduction_comb = bpy.props.IntProperty(name="Initial Reduction", default=1000000)
     bpy.types.Scene.loose_threshold_comb = bpy.props.IntProperty(name="Loose Component Vertex Thr", default=1000)
@@ -288,6 +312,7 @@ def unregister():
         unregister_class(cls)
 
     # Cleanup Properties
+    del bpy.types.Scene.rot_correction_comb
     del bpy.types.Scene.initial_reduction_comb
     del bpy.types.Scene.baker_settings_comb
     del bpy.types.Scene.loose_threshold_comb

enviro_lod_tools/addons/ds_blender_lod_plug.py

@@ -6,7 +6,7 @@
 bl_info = {
     "name": "LOD Generator",
     "author": "Nico Breycha",
-    "version": (0, 0, 3),
+    "version": (0, 0, 4),
     "blender": (4, 0, 0),
     "location": "View3D > Sidebar > Tool Tab",
     "description": "Generates levels of detail (LODs) for selected mesh objects.",
@@ -45,6 +45,11 @@ def generate_lods(self, context):
 
         for obj in context.selected_objects:
             if obj.type == 'MESH':
+                # Skip objects with no polygons
+                if len(obj.data.polygons) == 0:
+                    continue
+
+                # Create LODs for the object
                 self._create_lods_for_object(obj, context)
 
     def _create_lods_for_object(self, obj, context):

enviro_lod_tools/addons/ds_blender_slice_plug.py

@@ -14,7 +14,7 @@
 bl_info = {
     "name": "Mesh Slicer",
     "author": "Nico Breycha",
-    "version": (0, 1, 1),
+    "version": (0, 1, 2),
     "blender": (4, 0, 0),
     "location": "View3D > Sidebar > Tool Tab",
     "description": "Cut's a Mesh into a user-defined amount of square slices, "
@@ -256,15 +256,32 @@ def better_bisect(mesh, cut_pos, direction, middle_point=None):
     pos_map = {vert.index: bm_pos.verts.new(vert.co) for vert in verts_pos}
     neg_map = {vert.index: bm_neg.verts.new(vert.co) for vert in verts_neg}
 
+    # Store original vertex normals
+    original_normals = {v.index: v.normal.copy() for v in bm.verts}
+
+    # Transfer Normals. NOTE: From here on we should not call "recalculate_normals" anymore!!
+    for old_index, new_vert in pos_map.items():
+        new_vert.normal = original_normals[old_index]
+
+    for old_index, new_vert in neg_map.items():
+        new_vert.normal = original_normals[old_index]
+
+    double_faces = 0
+
     # Recreate the faces in bm_pos and bm_neg
     for face in bm.faces:
-        pos_face_verts = [pos_map[v.index] for v in face.verts if v.index in pos_map]
-        neg_face_verts = [neg_map[v.index] for v in face.verts if v.index in neg_map]
+        pos_face_verts = [pos_map[vert.index] for vert in face.verts if vert.index in pos_map]
+        neg_face_verts = [neg_map[vert.index] for vert in face.verts if vert.index in neg_map]
 
-        if len(pos_face_verts) == len(face.verts):
-            bm_pos.faces.new(pos_face_verts)
-        elif len(neg_face_verts) == len(face.verts):
-            bm_neg.faces.new(neg_face_verts)
+        try:
+            if len(pos_face_verts) == len(face.verts):
+                bm_pos.faces.new(pos_face_verts)
+            elif len(neg_face_verts) == len(face.verts):
+                bm_neg.faces.new(neg_face_verts)
+        except ValueError as err:
+            print(f"Failed to create face {face.index}: {err}")
+            double_faces += 1
+            pass
 
     bm.free()
     del verts_pos
@@ -397,8 +414,6 @@ def execute(self, context):
             suffix = f"_{i + 1:03d}"
             part.name = part.name + suffix
 
-            self.recalculate_normals(part.data)
-
         self.report({'INFO'}, "Slicing completed")
         return {'FINISHED'}
 

enviro_lod_tools/addons/ds_blender_xatlas_plug.py

@@ -14,7 +14,7 @@
 bl_info = {
     "name": "XAtlas Unwrapper",
     "author": "Nico Breycha",
-    "version": (0, 0, 1),
+    "version": (0, 0, 2),
     "blender": (4, 0, 0),
     "location": "View3D > Sidebar > Tool Tab",
     "description": "Unwraps the model using xatals.",
@@ -77,8 +77,14 @@ def execute(self, context):
                 cnt_fail += 1
                 continue
 
-            # Get mesh data from the object
             mesh = obj.data
+
+            # Skip valid meshes with 0 polygons
+            if len(mesh.polygons) == 0:
+                self.report({'INFO'}, f"Skipping {obj.name}: empty mesh")
+                continue
+
+            # Get mesh data from the object
             cnt_succ += 1
 
             # Create a bmesh object and load the mesh data into it

enviro_tools_gui.py

@@ -77,6 +77,15 @@ def __init__(self):
         io_layout.addLayout(highpoly_layout)
         io_layout.addWidget(self.polycount_label)
 
+        # Rotate Highpoly Input
+        rotate_layout = QHBoxLayout()
+        self.rotate_label = QLabel("Rotate Highpoly Input:")
+        self.rotation_correction = QComboBox()
+        self.rotation_correction.addItems(["No Rotation", "-90 on X (Metashape)"])
+        rotate_layout.addWidget(self.rotate_label)
+        rotate_layout.addWidget(self.rotation_correction)
+        io_layout.addLayout(rotate_layout)
+
         # Horizontal Line as Separator
         h_line = QFrame()
         h_line.setFrameShape(QFrame.HLine)
@@ -363,6 +372,7 @@ def setup_blender(self, values):
 
         # Run the pipeline
         bpy.types.Scene.import_fp_comb = values["highpoly_model_path"]
+        bpy.types.Scene.rot_correction_comb = values["rot_correction"]
         bpy.types.Scene.export_fp_comb = values["export_path"]
 
         bpy.types.Scene.initial_reduction_comb = values["initial_reduction_polycount"]
@@ -392,6 +402,12 @@ def start_pipeline(self):
             return
 
         highpoly_model_path = self.highpoly_model_line_edit.text()
+        rot_correction = self.rotation_correction.currentText()
+        if rot_correction == "No Rotation":
+            rot_correction = [0, 0, 0]
+        elif rot_correction == "-90 on X (Metashape)":
+            rot_correction = [-90, 0, 0]
+
         export_path = self.export_path_line_edit.text()
 
         if not os.path.isfile(highpoly_model_path):
@@ -423,7 +439,8 @@ def start_pipeline(self):
             "num_lods": num_lods,
             "reduction_percentage": reduction_percentage,
             "texture_resolution": texture_resolution,
-            "ray_distance": ray_distance
+            "ray_distance": ray_distance,
+            "rot_correction": rot_correction
         }
 
         self.setup_blender(values)