Changed if/elif to match blocks where appropriate

Author: cmbasnett

bdk_addon/bdk/repository/operators.py

@@ -832,14 +832,15 @@ def execute(self, context):
         addon_prefs = get_addon_preferences(context)
         repository = addon_prefs.repositories[addon_prefs.repositories_index]
 
-        if self.direction == 'UP':
-            if repository.rules_index > 0:
-                repository.rules.move(repository.rules_index, repository.rules_index - 1)
-                repository.rules_index -= 1
-        elif self.direction == 'DOWN':
-            if repository.rules_index < len(repository.rules) - 1:
-                repository.rules.move(repository.rules_index, repository.rules_index + 1)
-                repository.rules_index += 1
+        match self.direction:
+            case 'UP':
+                if repository.rules_index > 0:
+                    repository.rules.move(repository.rules_index, repository.rules_index - 1)
+                    repository.rules_index -= 1
+            case 'DOWN':
+                if repository.rules_index < len(repository.rules) - 1:
+                    repository.rules.move(repository.rules_index, repository.rules_index + 1)
+                    repository.rules_index += 1
 
         repository_metadata_write(repository)
         repository_runtime_packages_update_rule_exclusions(repository)

bdk_addon/bsp/operators.py

@@ -487,13 +487,13 @@ def execute(self, context):
             self.report({'ERROR'}, f'Found {len(object_errors)} brush(es) with errors')
             for obj, errors in object_errors.items():
                 for (error, index) in errors:
-                    print(error, index)
-                    if error == BspBrushError.NOT_MANIFOLD:
-                        self.report({'ERROR'}, f'{obj.name}: Edge {index} is not manifold')
-                    elif error == BspBrushError.NOT_CONVEX:
-                        self.report({'ERROR'}, f'{obj.name}: Edge {index} is not convex')
-                    elif error == BspBrushError.TWISTED_FACE:
-                        self.report({'ERROR'}, f'{obj.name}: Face {index} is twisted')
+                    match error:
+                        case BspBrushError.NOT_MANIFOLD:
+                            self.report({'ERROR'}, f'{obj.name}: Edge {index} is not manifold')
+                        case BspBrushError.NOT_CONVEX:
+                            self.report({'ERROR'}, f'{obj.name}: Edge {index} is not convex')
+                        case BspBrushError.TWISTED_FACE:
+                            self.report({'ERROR'}, f'{obj.name}: Face {index} is twisted')
             if self.deselect_ok:
                 # Go through all selected objects and deselect those that don't have errors.
                 for obj in context.selected_objects:

bdk_addon/material/importer.py

@@ -151,29 +151,30 @@ def add_noise_type_switch_nodes(
         index_switch_node.index_switch_items.new()
 
     for index, noise_type in enumerate(noise_types):
-        if noise_type == 'PERLIN':
-            noise_node = node_tree.nodes.new(type='ShaderNodeTexNoise')
-            noise_node.noise_dimensions = '2D'
-            # NOTE: There is a bug with using normal fDM noise where values end up as NaN. Use multi-fractal instead.
-            noise_node.noise_type = 'MULTIFRACTAL'
-            noise_node.inputs['Scale'].default_value = 0.5
-            noise_node.inputs['Detail'].default_value = 16
-            noise_node.inputs['Distortion'].default_value = 0.5
-
-            if noise_distortion_socket:
-                node_tree.links.new(noise_distortion_socket, noise_node.inputs['Distortion'])
-
-            if noise_roughness_socket:
-                node_tree.links.new(noise_roughness_socket, noise_node.inputs['Roughness'])
-
-            node_tree.links.new(vector_socket, noise_node.inputs['Vector'])
-            noise_value_socket = noise_node.outputs['Fac']
-        elif noise_type == 'WHITE':
-            noise_node = node_tree.nodes.new(type='ShaderNodeTexWhiteNoise')
-            noise_node.noise_dimensions = '2D'
-            noise_value_socket = noise_node.outputs['Value']
-        else:
-            raise ValueError(f'Unknown noise type {noise_type}')
+        match noise_type:
+            case 'PERLIN':
+                noise_node = node_tree.nodes.new(type='ShaderNodeTexNoise')
+                noise_node.noise_dimensions = '2D'
+                # NOTE: There is a bug with using normal fDM noise where values end up as NaN. Use multi-fractal instead.
+                noise_node.noise_type = 'MULTIFRACTAL'
+                noise_node.inputs['Scale'].default_value = 0.5
+                noise_node.inputs['Detail'].default_value = 16
+                noise_node.inputs['Distortion'].default_value = 0.5
+
+                if noise_distortion_socket:
+                    node_tree.links.new(noise_distortion_socket, noise_node.inputs['Distortion'])
+
+                if noise_roughness_socket:
+                    node_tree.links.new(noise_roughness_socket, noise_node.inputs['Roughness'])
+
+                node_tree.links.new(vector_socket, noise_node.inputs['Vector'])
+                noise_value_socket = noise_node.outputs['Fac']
+            case 'WHITE':
+                noise_node = node_tree.nodes.new(type='ShaderNodeTexWhiteNoise')
+                noise_node.noise_dimensions = '2D'
+                noise_value_socket = noise_node.outputs['Value']
+            case _:
+                raise ValueError(f'Unknown noise type {noise_type}')
 
         node_tree.links.new(noise_value_socket, index_switch_node.inputs[f'{index}'])
 
@@ -298,10 +299,11 @@ def ensure_input_and_output_nodes(node_tree: NodeTree) -> Tuple[Node, Node]:
     input_node = None
     output_node = None
     for node in node_tree.nodes:
-        if node.bl_idname == 'NodeGroupInput':
-            input_node = node
-        elif node.bl_idname == 'NodeGroupOutput':
-            output_node = node
+        match node.bl_idname:
+            case 'NodeGroupInput':
+                input_node = node
+            case 'NodeGroupOutput':
+                output_node = node
 
     input_node = node_tree.nodes.new(type='NodeGroupInput') if input_node is None else input_node
     output_node = node_tree.nodes.new(type='NodeGroupOutput') if output_node is None else output_node

bdk_addon/node_helpers.py

@@ -414,13 +414,14 @@ def create_terrain_doodad_object(context: Context, terrain_info_object: Object,
 
     bpy_object = bpy.data.objects.new(name='Doodad', object_data=object_data)
 
-    if object_type == 'EMPTY':
-        bpy_object.empty_display_type = 'SPHERE'
-        bpy_object.empty_display_size = meters_to_unreal(1.0)
-        # Set the delta transform to the terrain info object's rotation.
-        bpy_object.delta_rotation_euler = (0, 0, 0)
-    elif object_type == 'MESH':
-        bpy_object.display_type = 'WIRE'
+    match object_type:
+        case 'EMPTY':
+            bpy_object.empty_display_type = 'SPHERE'
+            bpy_object.empty_display_size = meters_to_unreal(1.0)
+            # Set the delta transform to the terrain info object's rotation.
+            bpy_object.delta_rotation_euler = (0, 0, 0)
+        case 'MESH':
+            bpy_object.display_type = 'WIRE'
 
     # Set the location of the curve object to the 3D cursor.
     bpy_object.location = context.scene.cursor.location
@@ -692,14 +693,15 @@ def add_doodad_layer_driver(
     var.type = 'SINGLE_PROP'
     var.targets[0].id = layer.terrain_doodad_object
 
-    if layer_type == 'SCULPT':
-        data_path = f"bdk.terrain_doodad.sculpt_layers[{layer.index}].{data_path}"
-    elif layer_type == 'PAINT':
-        data_path = f"bdk.terrain_doodad.paint_layers[{layer.index}].{data_path}"
-    elif layer_type == 'DECO':
-        data_path = f"bdk.terrain_doodad.deco_layers[{layer.index}].{data_path}"
-    else:
-        raise Exception(f"Unknown layer type: {layer_type}")
+    match layer_type:
+        case 'SCULPT':
+            data_path = f"bdk.terrain_doodad.sculpt_layers[{layer.index}].{data_path}"
+        case 'PAINT':
+            data_path = f"bdk.terrain_doodad.paint_layers[{layer.index}].{data_path}"
+        case 'DECO':
+            data_path = f"bdk.terrain_doodad.deco_layers[{layer.index}].{data_path}"
+        case _:
+            raise Exception(f"Unknown layer type: {layer_type}")
 
     var.targets[0].data_path = data_path
 

bdk_addon/terrain/doodad/builder.py

@@ -131,14 +131,15 @@ def execute(self, context: Context):
 
 def get_terrain_doodad_paint_layer_nodes(doodad_paint_layer: 'BDK_PG_terrain_doodad_paint_layer'):
     terrain_info = doodad_paint_layer.terrain_doodad_object.bdk.terrain_doodad.terrain_info_object.bdk.terrain_info
-    if doodad_paint_layer.layer_type == 'PAINT':
-        # Get the terrain layer from the paint layer ID.
-        terrain_info_paint_layer = get_terrain_info_paint_layer_by_id(terrain_info, doodad_paint_layer.paint_layer_id)
-        return terrain_info_paint_layer.nodes if terrain_info_paint_layer is not None else None
-    elif doodad_paint_layer.layer_type == 'DECO':
-        # Get the terrain layer from the deco layer ID.
-        terrain_info_deco_layer = get_terrain_info_deco_layer_by_id(terrain_info, doodad_paint_layer.deco_layer_id)
-        return terrain_info_deco_layer.nodes if terrain_info_deco_layer is not None else None
+    match doodad_paint_layer.layer_type:
+        case 'PAINT':
+            # Get the terrain layer from the paint layer ID.
+            terrain_info_paint_layer = get_terrain_info_paint_layer_by_id(terrain_info, doodad_paint_layer.paint_layer_id)
+            return terrain_info_paint_layer.nodes if terrain_info_paint_layer is not None else None
+        case 'DECO':
+            # Get the terrain layer from the deco layer ID.
+            terrain_info_deco_layer = get_terrain_info_deco_layer_by_id(terrain_info, doodad_paint_layer.deco_layer_id)
+            return terrain_info_deco_layer.nodes if terrain_info_deco_layer is not None else None
     return None
 
 

bdk_addon/terrain/doodad/operators.py

@@ -41,12 +41,13 @@ def draw_item(self, context: Context, layout, data, item, icon, active_data, act
 class BDK_UL_terrain_doodad_paint_layers(UIList):
 
     def draw_item(self, context: Context, layout, data, item, icon, active_data, active_propname, index):
-        if item.layer_type == 'PAINT':
-            layout.label(text=item.paint_layer_name if item.paint_layer_name else '<no layer selected>', icon='BRUSH_DATA')
-        elif item.layer_type == 'DECO':
-            layout.label(text=item.deco_layer_name if item.deco_layer_name else '<no layer selected>', icon='MONKEY')
-        elif item.layer_type == 'ATTRIBUTE':
-            layout.label(text=item.attribute_layer_id if item.attribute_layer_id else '<no attribute>', icon='MODIFIER_DATA')
+        match item.layer_type:
+            case 'PAINT':
+                layout.label(text=item.paint_layer_name if item.paint_layer_name else '<no layer selected>', icon='BRUSH_DATA')
+            case 'DECO':
+                layout.label(text=item.deco_layer_name if item.deco_layer_name else '<no layer selected>', icon='MONKEY')
+            case 'ATTRIBUTE':
+                layout.label(text=item.attribute_layer_id if item.attribute_layer_id else '<no attribute>', icon='MODIFIER_DATA')
         layout.prop(item, 'operation', emboss=False, text='')
         layout.prop(item, 'mute', text='', icon='HIDE_ON' if item.mute else 'HIDE_OFF', emboss=False)
 
@@ -733,19 +734,21 @@ def draw(self, context: Context):
 
         flow.separator()
 
-        if scatter_layer_object.scale_mode == 'UNIFORM':
-            flow.prop(scatter_layer_object, 'scale_uniform', text='Scale')
-        elif scatter_layer_object.scale_mode == 'NON_UNIFORM':
-            flow.prop(scatter_layer_object, 'scale', text='Scale')
+        match scatter_layer_object.scale_mode:
+            case 'UNIFORM':
+                flow.prop(scatter_layer_object, 'scale_uniform', text='Scale')
+            case 'NON_UNIFORM':
+                flow.prop(scatter_layer_object, 'scale', text='Scale')
 
         flow.separator()
 
-        if scatter_layer_object.scale_mode == 'UNIFORM':
-            flow.prop(scatter_layer_object, 'scale_random_uniform_min', text='Random Scale Min')
-            flow.prop(scatter_layer_object, 'scale_random_uniform_max', text='Max')
-        elif scatter_layer_object.scale_mode == 'NON_UNIFORM':
-            flow.prop(scatter_layer_object, 'scale_random_min', text='Random Scale Min')
-            flow.prop(scatter_layer_object, 'scale_random_max', text='Max')
+        match scatter_layer_object.scale_mode:
+            case 'UNIFORM':
+                flow.prop(scatter_layer_object, 'scale_random_uniform_min', text='Random Scale Min')
+                flow.prop(scatter_layer_object, 'scale_random_uniform_max', text='Max')
+            case 'NON_UNIFORM':
+                flow.prop(scatter_layer_object, 'scale_random_min', text='Random Scale Min')
+                flow.prop(scatter_layer_object, 'scale_random_max', text='Max')
 
         flow.prop(scatter_layer_object, 'scale_seed', text='Seed')
 

bdk_addon/terrain/doodad/ui.py

@@ -99,14 +99,17 @@ def execute(self, context: Context):
         paint_layers = terrain_info.paint_layers
         paint_layers_index = terrain_info.paint_layers_index
 
-        if self.direction == 'UP' and paint_layers_index > 0:
-            paint_layers.move(paint_layers_index, paint_layers_index - 1)
-            terrain_info.paint_layers_index -= 1
-            build_terrain_material(active_object)
-        elif self.direction == 'DOWN' and paint_layers_index < len(paint_layers) - 1:
-            paint_layers.move(paint_layers_index, paint_layers_index + 1)
-            terrain_info.paint_layers_index += 1
-            build_terrain_material(active_object)
+        match self.direction:
+            case 'UP':
+                if paint_layers_index > 0:
+                    paint_layers.move(paint_layers_index, paint_layers_index - 1)
+                    terrain_info.paint_layers_index -= 1
+                    build_terrain_material(active_object)
+            case 'DOWN':
+                if paint_layers_index < len(paint_layers) - 1:
+                    paint_layers.move(paint_layers_index, paint_layers_index + 1)
+                    terrain_info.paint_layers_index += 1
+                    build_terrain_material(active_object)
 
         # The order of the paint layers changed. Therefore, we need to:
         # 1. Rebuild the paint layer node groups.
@@ -465,19 +468,20 @@ def add_terrain_layer_node(terrain_info_object: Object, nodes, type: str):
     node.terrain_info_object = terrain_info_object
     node.type = type
 
-    if type == 'PAINT':
-        # mesh_data = cast(Mesh, terrain_info_object.data)
-        # TODO: when we can paint non-color data, rewrite this!
-        # Add the density map attribute to the TerrainInfo mesh.
-        terrain_info_object.vertex_groups.new(name=node.id)
-        # attribute = mesh_data.attributes.get(node.id, None)
-        # vertex_count = len(attribute.data)
-        # color_data = numpy.ndarray(shape=(vertex_count, 4), dtype=float)
-        # color_data[:] = (0.0, 0.0, 0.0, 0.0)
-        # attribute.data.foreach_set('color', color_data.flatten())
-    elif type == 'FIELD':
-        mesh_data = cast(Mesh, terrain_info_object.data)
-        mesh_data.attributes.new(node.id, 'FLOAT', domain='POINT')
+    match type:
+        case 'PAINT':
+            # mesh_data = cast(Mesh, terrain_info_object.data)
+            # TODO: when we can paint non-color data, rewrite this!
+            # Add the density map attribute to the TerrainInfo mesh.
+            terrain_info_object.vertex_groups.new(name=node.id)
+            # attribute = mesh_data.attributes.get(node.id, None)
+            # vertex_count = len(attribute.data)
+            # color_data = numpy.ndarray(shape=(vertex_count, 4), dtype=float)
+            # color_data[:] = (0.0, 0.0, 0.0, 0.0)
+            # attribute.data.foreach_set('color', color_data.flatten())
+        case 'FIELD':
+            mesh_data = cast(Mesh, terrain_info_object.data)
+            mesh_data.attributes.new(node.id, 'FLOAT', domain='POINT')
 
     # Move the node to the top of the list.
     nodes.move(len(nodes) - 1, 0)
@@ -507,14 +511,15 @@ def remove_terrain_layer_node(terrain_info_object: Object, nodes, nodes_index: i
 
 
 def move_terrain_layer_node(direction: str, nodes, nodes_index: int) -> int:
-    if direction == 'UP':
-        if nodes_index > 0:
-            nodes.move(nodes_index, nodes_index - 1)
-            nodes_index -= 1
-    elif direction == 'DOWN':
-        if nodes_index < len(nodes) - 1:
-            nodes.move(nodes_index, nodes_index + 1)
-            nodes_index += 1
+    match direction:
+        case'UP':
+            if nodes_index > 0:
+                nodes.move(nodes_index, nodes_index - 1)
+                nodes_index -= 1
+        case 'DOWN':
+            if nodes_index < len(nodes) - 1:
+                nodes.move(nodes_index, nodes_index + 1)
+                nodes_index += 1
     return nodes_index