Updated DFS scene traversal to handle more cases

This fixes a number of bugs related to BSP building and copy-paste functionality.

This DFS implementation was lifted from our PSK/PSA addon.

Author: cmbasnett

bdk_addon/__init__.py

@@ -6,6 +6,7 @@
     importlib.reload(constants)
     importlib.reload(property_group_helpers)
     importlib.reload(node_helpers)
+    importlib.reload(dfs)
 
     importlib.reload(actor_properties)
 
@@ -91,6 +92,7 @@
 else:
     from . import data as bdk_data
     from . import helpers as bdk_helpers
+    from . import dfs as dfs
 
     from .actor import properties as actor_properties
 

bdk_addon/bsp/operators.py

@@ -2,9 +2,11 @@
 from bmesh.types import BMFace
 from mathutils import Vector, Matrix
 
+from ..dfs import dfs_view_layer_objects
+
 from .builder import ensure_bdk_brush_uv_node_tree, create_bsp_brush_polygon, apply_level_to_brush_mapping, \
     ensure_bdk_level_visibility_modifier
-from ..helpers import should_show_bdk_developer_extras, dfs_view_layer_objects, humanize_time
+from ..helpers import should_show_bdk_developer_extras, humanize_time
 from .data import bsp_optimization_items, ORIGIN_ATTRIBUTE_NAME, TEXTURE_U_ATTRIBUTE_NAME, TEXTURE_V_ATTRIBUTE_NAME, \
     POLY_FLAGS_ATTRIBUTE_NAME, BRUSH_INDEX_ATTRIBUTE_NAME, BRUSH_POLYGON_INDEX_ATTRIBUTE_NAME, \
     MATERIAL_INDEX_ATTRIBUTE_NAME, READ_ONLY_ATTRIBUTE_NAME, bsp_surface_attributes
@@ -756,9 +758,10 @@ def brush_object_filter(obj: Object, instance_objects: list[Object]):
                 elif not obj.visible_get():
                     return False
             return True
+    
+        assert context.view_layer is not None
 
-        brush_objects = [(obj, instance_objects, matrix_world) for (obj, instance_objects, matrix_world) in
-                         dfs_view_layer_objects(context.view_layer) if brush_object_filter(obj, instance_objects)]
+        brush_objects = [x for x in dfs_view_layer_objects(context.view_layer) if brush_object_filter(x.obj, x.instance_objects)]
 
         # This is a list of the materials used for the brushes. It is populated as we iterate over the brush objects.
         # We then use this at the end to create the materials for the level object.
@@ -774,8 +777,10 @@ def _get_or_add_material(material: Material | None) -> int:
         # Add the brushes to the level object.
         level_object.bdk.level.brushes.clear()
 
-        for brush_index, (brush_object, instance_collections, _) in enumerate(brush_objects):
-            is_instanced_brush = len(instance_collections) > 0
+        for brush_index, dfs_object in enumerate(brush_objects):
+            brush_object = dfs_object.obj
+            instance_objects = dfs_object.instance_objects
+            is_instanced_brush = len(instance_objects) > 0
             if is_instanced_brush:
                 # Skip brushes that are instanced, as we cannot change their texturing.
                 continue
@@ -791,10 +796,13 @@ def _get_or_add_material(material: Material | None) -> int:
         instanced_brush_indices = []
 
         brushes: list[Brush] = []
-        for brush_index, (brush_object, asset_instances, matrix_world) in enumerate(brush_objects):
+        for brush_index, dfs_object in enumerate(brush_objects):
 
-            if asset_instances:
+            if dfs_object.instance_objects:
                 instanced_brush_indices.append(brush_index)
+            
+            brush_object = dfs_object.obj
+            matrix_world = dfs_object.matrix_world
 
             # Create a new Poly object for each face of the brush.
             polys = []

bdk_addon/dfs.py

@@ -0,0 +1,148 @@
+"""
+Depth-first object iterator functions for Blender collections and view layers.
+
+These functions are used to iterate over objects in a collection or view layer in a depth-first manner, including
+instances. This is useful for exporters that need to traverse the object hierarchy in a predictable order.
+"""
+
+from typing import Optional, Set, Iterable, List
+
+from bpy.types import Collection, Object, ViewLayer, LayerCollection
+from mathutils import Matrix
+
+
+class DfsObject:
+    """
+    Represents an object in a depth-first search.
+    """
+    def __init__(self, obj: Object, instance_objects: List[Object], matrix_world: Matrix):
+        self.obj = obj
+        self.instance_objects = instance_objects
+        self.matrix_world = matrix_world
+
+    @property
+    def is_visible(self) -> bool:
+        """
+        Check if the object is visible.
+
+        @return: True if the object is visible, False otherwise.
+        """
+        if self.instance_objects:
+            return self.instance_objects[-1].visible_get()
+        return self.obj.visible_get()
+
+    @property
+    def is_selected(self) -> bool:
+        """
+        Check if the object is selected.
+        @return: True if the object is selected, False otherwise.
+        """
+        if self.instance_objects:
+            return self.instance_objects[-1].select_get()
+        return self.obj.select_get()
+
+
+def _dfs_object_children(obj: Object, collection: Collection) -> Iterable[Object]:
+    """
+    Construct a list of objects in hierarchy order from `collection.objects`, only keeping those that are in the
+    collection.
+
+    @param obj: The object to start the search from.
+    @param collection:  The collection to search in.
+    @return: An iterable of objects in hierarchy order.
+    """
+    yield obj
+    for child in obj.children:
+        if child.name in collection.objects:
+            yield from _dfs_object_children(child, collection)
+
+
+def dfs_objects_in_collection(collection: Collection) -> Iterable[Object]:
+    """
+    Returns a depth-first iterator over all objects in a collection, only keeping those that are directly in the
+    collection.
+
+    @param collection: The collection to search in.
+    @return: An iterable of objects in hierarchy order.
+    """
+    objects_hierarchy = []
+    for obj in collection.objects:
+        if obj.parent is None or obj.parent not in set(collection.objects):
+            objects_hierarchy.append(obj)
+    for obj in objects_hierarchy:
+        yield from _dfs_object_children(obj, collection)
+
+
+def dfs_collection_objects(collection: Collection) -> Iterable[DfsObject]:
+    """
+    Depth-first search of objects in a collection, including recursing into instances.
+
+    @param collection: The collection to search in.
+    @return: An iterable of tuples containing the object, the instance objects, and the world matrix.
+    """
+    yield from _dfs_collection_objects_recursive(collection)
+
+
+def _dfs_collection_objects_recursive(
+        collection: Collection,
+        instance_objects: Optional[List[Object]] = None,
+        matrix_world: Matrix = Matrix.Identity(4),
+        visited: Optional[Set[Object]]=None
+) -> Iterable[DfsObject]:
+    """
+    Depth-first search of objects in a collection, including recursing into instances.
+    This is a recursive function.
+
+    @param collection: The collection to search in.
+    @param instance_objects: The running hierarchy of instance objects.
+    @param matrix_world: The world matrix of the current object.
+    @param visited: A set of visited object-instance pairs.
+    @return: An iterable of tuples containing the object, the instance objects, and the world matrix.
+    """
+
+    # We want to also yield the top-level instance object so that callers can inspect the selection status etc.
+    if visited is None:
+        visited = set()
+
+    if instance_objects is None:
+        instance_objects = list()
+
+    # First, yield all objects in child collections.
+    for child in collection.children:
+        yield from _dfs_collection_objects_recursive(child, instance_objects, matrix_world.copy(), visited)
+
+    # Then, evaluate all objects in this collection.
+    for obj in dfs_objects_in_collection(collection):
+        visited_pair = (obj, instance_objects[-1] if instance_objects else None)
+        if visited_pair in visited:
+            continue
+        # If this an instance, we need to recurse into it.
+        if obj.instance_collection is not None:
+            # Calculate the instance transform.
+            instance_offset_matrix = Matrix.Translation(-obj.instance_collection.instance_offset)
+            # Recurse into the instance collection.
+            yield from _dfs_collection_objects_recursive(obj.instance_collection,
+                                                         instance_objects + [obj],
+                                                         matrix_world @ (obj.matrix_world @ instance_offset_matrix),
+                                                         visited)
+        else:
+            # Object is not an instance, yield it.
+            yield DfsObject(obj, instance_objects, matrix_world @ obj.matrix_world)
+            visited.add(visited_pair)
+
+
+def dfs_view_layer_objects(view_layer: ViewLayer) -> Iterable[DfsObject]:
+    """
+    Depth-first iterator over all objects in a view layer, including recursing into instances.
+
+    @param view_layer: The view layer to inspect.
+    @return: An iterable of tuples containing the object, the instance objects, and the world matrix.
+    """
+    visited = set()
+    def layer_collection_objects_recursive(layer_collection: LayerCollection):
+        for child in layer_collection.children:
+            yield from layer_collection_objects_recursive(child)
+        # Iterate only the top-level objects in this collection first.
+        yield from _dfs_collection_objects_recursive(layer_collection.collection, visited=visited)
+
+    yield from layer_collection_objects_recursive(view_layer.layer_collection)

bdk_addon/t3d/operators.py

@@ -22,7 +22,8 @@
 from pathlib import Path
 from .importer import import_t3d
 from .writer import T3DWriter
-from ..helpers import dfs_view_layer_objects, sanitize_name_for_unreal, humanize_size
+from ..helpers import sanitize_name_for_unreal, humanize_size
+from ..dfs import dfs_view_layer_objects
 
 
 class BDK_OT_t3d_import_from_clipboard(Operator):
@@ -40,6 +41,7 @@ def poll(cls, context: Context):
         return True
 
     def execute(self, context: Context):
+        assert context.window_manager is not None
         try:
             import_t3d(context.window_manager, context.window_manager.clipboard, context)
             self.report({'INFO'}, f'Imported actors from clipboard')
@@ -407,19 +409,13 @@ def poll(cls, context: Context):
 
     def execute(self, context: Context):
         # Use the depth-first iterator to get all the objects in the view layer.
+        assert context.view_layer is not None
         dfs_objects = list(dfs_view_layer_objects(context.view_layer))
 
         # Filter only the selected objects.
         selected_objects: list[tuple[Object, Matrix]] = list()
-        for obj, instance_objects, matrix_world in dfs_objects:
-            if instance_objects:
-                if instance_objects[0].select_get():
-                    selected_objects.append((obj, matrix_world))
-            else:
-                if obj.select_get():
-                    selected_objects.append((obj, matrix_world))
-
-        # selected_objects = list(filter(lambda obj: obj[0].select_get() or (obj[1] is not None and obj[1].select_get()), dfs_objects))
+        for dfs_object in filter(lambda x: x.is_selected, dfs_objects):
+            selected_objects.append((dfs_object.obj, dfs_object.matrix_world))
 
         # Start a progress bar.
         wm = context.window_manager