@tushar-br/editing-pack 1.0.188 → 1.0.190

package/staging_area/Blender/5.0/scripts/addons_core/node_wrangler/utils/draw.py

@@ -1,219 +0,0 @@
-# SPDX-FileCopyrightText: 2023 Blender Foundation
-#
-# SPDX-License-Identifier: GPL-2.0-or-later
-
-import bpy
-import gpu
-from gpu_extras.batch import batch_for_shader
-from math import cos, sin, pi
-
-from .nodes import get_nodes_links, prefs_line_width, abs_node_location, dpi_fac
-
-
-def draw_line(x1, y1, x2, y2, size, colour=(1.0, 1.0, 1.0, 0.7)):
-    shader = gpu.shader.from_builtin('POLYLINE_SMOOTH_COLOR')
-    shader.uniform_float("viewportSize", gpu.state.viewport_get()[2:])
-    shader.uniform_float("lineWidth", size * prefs_line_width())
-
-    vertices = ((x1, y1), (x2, y2))
-    vertex_colors = ((colour[0] + (1.0 - colour[0]) / 4,
-                      colour[1] + (1.0 - colour[1]) / 4,
-                      colour[2] + (1.0 - colour[2]) / 4,
-                      colour[3] + (1.0 - colour[3]) / 4),
-                     colour)
-
-    batch = batch_for_shader(shader, 'LINE_STRIP', {"pos": vertices, "color": vertex_colors})
-    batch.draw(shader)
-
-
-def draw_circle_2d_filled(mx, my, radius, colour=(1.0, 1.0, 1.0, 0.7)):
-    radius = radius * prefs_line_width()
-    sides = 12
-    vertices = [(radius * cos(i * 2 * pi / sides) + mx,
-                 radius * sin(i * 2 * pi / sides) + my)
-                for i in range(sides + 1)]
-
-    shader = gpu.shader.from_builtin('UNIFORM_COLOR')
-    shader.uniform_float("color", colour)
-    batch = batch_for_shader(shader, 'TRI_FAN', {"pos": vertices})
-    batch.draw(shader)
-
-
-def draw_rounded_node_border(node, radius=8, colour=(1.0, 1.0, 1.0, 0.7)):
-    area_width = bpy.context.area.width
-    sides = 16
-    radius *= prefs_line_width()
-
-    nlocx, nlocy = abs_node_location(node)
-
-    nlocx = (nlocx + 1) * dpi_fac()
-    nlocy = (nlocy + 1) * dpi_fac()
-    ndimx = node.dimensions.x
-    ndimy = node.dimensions.y
-
-    if node.hide:
-        nlocx += -1
-        nlocy += 5
-    if node.type == 'REROUTE':
-        # nlocx += 1
-        nlocy -= 1
-        ndimx = 0
-        ndimy = 0
-        radius += 6
-
-    shader = gpu.shader.from_builtin('UNIFORM_COLOR')
-    shader.uniform_float("color", colour)
-
-    # Top left corner
-    mx, my = bpy.context.region.view2d.view_to_region(nlocx, nlocy, clip=False)
-    vertices = [(mx, my)]
-    for i in range(sides + 1):
-        if (4 <= i <= 8):
-            if mx < area_width:
-                cosine = radius * cos(i * 2 * pi / sides) + mx
-                sine = radius * sin(i * 2 * pi / sides) + my
-                vertices.append((cosine, sine))
-
-    batch = batch_for_shader(shader, 'TRI_FAN', {"pos": vertices})
-    batch.draw(shader)
-
-    # Top right corner
-    mx, my = bpy.context.region.view2d.view_to_region(nlocx + ndimx, nlocy, clip=False)
-    vertices = [(mx, my)]
-    for i in range(sides + 1):
-        if (0 <= i <= 4):
-            if mx < area_width:
-                cosine = radius * cos(i * 2 * pi / sides) + mx
-                sine = radius * sin(i * 2 * pi / sides) + my
-                vertices.append((cosine, sine))
-
-    batch = batch_for_shader(shader, 'TRI_FAN', {"pos": vertices})
-    batch.draw(shader)
-
-    # Bottom left corner
-    mx, my = bpy.context.region.view2d.view_to_region(nlocx, nlocy - ndimy, clip=False)
-    vertices = [(mx, my)]
-    for i in range(sides + 1):
-        if (8 <= i <= 12):
-            if mx < area_width:
-                cosine = radius * cos(i * 2 * pi / sides) + mx
-                sine = radius * sin(i * 2 * pi / sides) + my
-                vertices.append((cosine, sine))
-
-    batch = batch_for_shader(shader, 'TRI_FAN', {"pos": vertices})
-    batch.draw(shader)
-
-    # Bottom right corner
-    mx, my = bpy.context.region.view2d.view_to_region(nlocx + ndimx, nlocy - ndimy, clip=False)
-    vertices = [(mx, my)]
-    for i in range(sides + 1):
-        if (12 <= i <= 16):
-            if mx < area_width:
-                cosine = radius * cos(i * 2 * pi / sides) + mx
-                sine = radius * sin(i * 2 * pi / sides) + my
-                vertices.append((cosine, sine))
-
-    batch = batch_for_shader(shader, 'TRI_FAN', {"pos": vertices})
-    batch.draw(shader)
-
-    # prepare drawing all edges in one batch
-    vertices = []
-    indices = []
-    id_last = 0
-
-    # Left edge
-    m1x, m1y = bpy.context.region.view2d.view_to_region(nlocx, nlocy, clip=False)
-    m2x, m2y = bpy.context.region.view2d.view_to_region(nlocx, nlocy - ndimy, clip=False)
-    if m1x < area_width and m2x < area_width:
-        vertices.extend([(m2x - radius, m2y), (m2x, m2y),
-                         (m1x, m1y), (m1x - radius, m1y)])
-        indices.extend([(id_last, id_last + 1, id_last + 3),
-                        (id_last + 3, id_last + 1, id_last + 2)])
-        id_last += 4
-
-    # Top edge
-    m1x, m1y = bpy.context.region.view2d.view_to_region(nlocx, nlocy, clip=False)
-    m2x, m2y = bpy.context.region.view2d.view_to_region(nlocx + ndimx, nlocy, clip=False)
-    m1x = min(m1x, area_width)
-    m2x = min(m2x, area_width)
-    vertices.extend([(m1x, m1y), (m2x, m1y),
-                     (m2x, m1y + radius), (m1x, m1y + radius)])
-    indices.extend([(id_last, id_last + 1, id_last + 3),
-                    (id_last + 3, id_last + 1, id_last + 2)])
-    id_last += 4
-
-    # Right edge
-    m1x, m1y = bpy.context.region.view2d.view_to_region(nlocx + ndimx, nlocy, clip=False)
-    m2x, m2y = bpy.context.region.view2d.view_to_region(nlocx + ndimx, nlocy - ndimy, clip=False)
-    if m1x < area_width and m2x < area_width:
-        vertices.extend([(m1x, m2y), (m1x + radius, m2y),
-                         (m1x + radius, m1y), (m1x, m1y)])
-        indices.extend([(id_last, id_last + 1, id_last + 3),
-                        (id_last + 3, id_last + 1, id_last + 2)])
-        id_last += 4
-
-    # Bottom edge
-    m1x, m1y = bpy.context.region.view2d.view_to_region(nlocx, nlocy - ndimy, clip=False)
-    m2x, m2y = bpy.context.region.view2d.view_to_region(nlocx + ndimx, nlocy - ndimy, clip=False)
-    m1x = min(m1x, area_width)
-    m2x = min(m2x, area_width)
-    vertices.extend([(m1x, m2y), (m2x, m2y),
-                     (m2x, m1y - radius), (m1x, m1y - radius)])
-    indices.extend([(id_last, id_last + 1, id_last + 3),
-                    (id_last + 3, id_last + 1, id_last + 2)])
-
-    # now draw all edges in one batch
-    if len(vertices) != 0:
-        batch = batch_for_shader(shader, 'TRIS', {"pos": vertices}, indices=indices)
-        batch.draw(shader)
-
-
-def draw_callback_nodeoutline(self, context, mode):
-    if self.mouse_path:
-        gpu.state.blend_set('ALPHA')
-
-        nodes, _links = get_nodes_links(context)
-
-        if mode == "LINK":
-            col_outer = (1.0, 0.2, 0.2, 0.4)
-            col_inner = (0.0, 0.0, 0.0, 0.5)
-            col_circle_inner = (0.3, 0.05, 0.05, 1.0)
-        elif mode == "LINKMENU":
-            col_outer = (0.4, 0.6, 1.0, 0.4)
-            col_inner = (0.0, 0.0, 0.0, 0.5)
-            col_circle_inner = (0.08, 0.15, .3, 1.0)
-        elif mode == "MIX":
-            col_outer = (0.2, 1.0, 0.2, 0.4)
-            col_inner = (0.0, 0.0, 0.0, 0.5)
-            col_circle_inner = (0.05, 0.3, 0.05, 1.0)
-
-        m1x = self.mouse_path[0][0]
-        m1y = self.mouse_path[0][1]
-        m2x = self.mouse_path[-1][0]
-        m2y = self.mouse_path[-1][1]
-
-        n1 = nodes[context.scene.NWLazySource]
-        n2 = nodes[context.scene.NWLazyTarget]
-
-        if n1 == n2:
-            col_outer = (0.4, 0.4, 0.4, 0.4)
-            col_inner = (0.0, 0.0, 0.0, 0.5)
-            col_circle_inner = (0.2, 0.2, 0.2, 1.0)
-
-        draw_rounded_node_border(n1, radius=6, colour=col_outer)  # outline
-        draw_rounded_node_border(n1, radius=5, colour=col_inner)  # inner
-        draw_rounded_node_border(n2, radius=6, colour=col_outer)  # outline
-        draw_rounded_node_border(n2, radius=5, colour=col_inner)  # inner
-
-        draw_line(m1x, m1y, m2x, m2y, 5, col_outer)  # line outline
-        draw_line(m1x, m1y, m2x, m2y, 2, col_inner)  # line inner
-
-        # circle outline
-        draw_circle_2d_filled(m1x, m1y, 7, col_outer)
-        draw_circle_2d_filled(m2x, m2y, 7, col_outer)
-
-        # circle inner
-        draw_circle_2d_filled(m1x, m1y, 5, col_circle_inner)
-        draw_circle_2d_filled(m2x, m2y, 5, col_circle_inner)
-
-        gpu.state.blend_set('NONE')

package/staging_area/Blender/5.0/scripts/addons_core/node_wrangler/utils/nodes.py

@@ -1,299 +0,0 @@
-# SPDX-FileCopyrightText: 2023 Blender Foundation
-#
-# SPDX-License-Identifier: GPL-2.0-or-later
-
-import bpy
-from bpy_extras.node_utils import connect_sockets
-from math import hypot, inf
-from bpy.app.translations import pgettext_tip as tip_
-
-
-def force_update(context):
-    context.space_data.node_tree.update_tag()
-
-
-def dpi_fac():
-    prefs = bpy.context.preferences.system
-    return prefs.dpi / 72
-
-
-def prefs_line_width():
-    prefs = bpy.context.preferences.system
-    return prefs.pixel_size
-
-
-def node_mid_pt(node, axis):
-    if axis == 'x':
-        d = node.location.x + (node.dimensions.x / 2)
-    elif axis == 'y':
-        d = node.location.y - (node.dimensions.y / 2)
-    else:
-        d = 0
-    return d
-
-
-def autolink(node1, node2, links):
-    available_inputs = [inp for inp in node2.inputs if inp.enabled and not inp.hide]
-    available_outputs = [outp for outp in node1.outputs if outp.enabled and not outp.hide]
-    for outp in available_outputs:
-        for inp in available_inputs:
-            if not inp.is_linked and inp.name == outp.name:
-                connect_sockets(outp, inp)
-                return True
-
-    for outp in available_outputs:
-        for inp in available_inputs:
-            if not inp.is_linked and inp.type == outp.type:
-                connect_sockets(outp, inp)
-                return True
-
-    # force some connection even if the type doesn't match
-    if available_outputs:
-        for inp in available_inputs:
-            if not inp.is_linked:
-                connect_sockets(available_outputs[0], inp)
-                return True
-
-    # even if no sockets are open, force one of matching type
-    for outp in available_outputs:
-        for inp in available_inputs:
-            if inp.type == outp.type:
-                connect_sockets(outp, inp)
-                return True
-
-    # do something!
-    for outp in available_outputs:
-        for inp in available_inputs:
-            connect_sockets(outp, inp)
-            return True
-
-    print("Could not make a link from " + node1.name + " to " + node2.name)
-    return False
-
-
-def abs_node_location(node):
-    abs_location = node.location
-    if node.parent is None:
-        return abs_location
-    return abs_location + abs_node_location(node.parent)
-
-
-def node_at_pos(nodes, context, event):
-    nodes_under_mouse = []
-    target_node = None
-
-    store_mouse_cursor(context, event)
-    x, y = context.space_data.cursor_location
-
-    # Make a list of each corner (and middle of border) for each node.
-    # Will be sorted to find nearest point and thus nearest node
-    node_points_with_dist = []
-    for node in nodes:
-        skipnode = False
-        if node.type != 'FRAME':  # no point trying to link to a frame node
-            dimx = node.dimensions.x / dpi_fac()
-            dimy = node.dimensions.y / dpi_fac()
-            locx, locy = abs_node_location(node)
-
-            if not skipnode:
-                node_points_with_dist.append([node, hypot(x - locx, y - locy)])  # Top Left
-                node_points_with_dist.append([node, hypot(x - (locx + dimx), y - locy)])  # Top Right
-                node_points_with_dist.append([node, hypot(x - locx, y - (locy - dimy))])  # Bottom Left
-                node_points_with_dist.append([node, hypot(x - (locx + dimx), y - (locy - dimy))])  # Bottom Right
-
-                node_points_with_dist.append([node, hypot(x - (locx + (dimx / 2)), y - locy)])  # Mid Top
-                node_points_with_dist.append([node, hypot(x - (locx + (dimx / 2)), y - (locy - dimy))])  # Mid Bottom
-                node_points_with_dist.append([node, hypot(x - locx, y - (locy - (dimy / 2)))])  # Mid Left
-                node_points_with_dist.append([node, hypot(x - (locx + dimx), y - (locy - (dimy / 2)))])  # Mid Right
-
-    nearest_node = sorted(node_points_with_dist, key=lambda k: k[1])[0][0]
-
-    for node in nodes:
-        if node.type != 'FRAME' and skipnode == False:
-            locx, locy = abs_node_location(node)
-            dimx = node.dimensions.x / dpi_fac()
-            dimy = node.dimensions.y / dpi_fac()
-            if (locx <= x <= locx + dimx) and \
-               (locy - dimy <= y <= locy):
-                nodes_under_mouse.append(node)
-
-    if len(nodes_under_mouse) == 1:
-        if nodes_under_mouse[0] != nearest_node:
-            target_node = nodes_under_mouse[0]  # use the node under the mouse if there is one and only one
-        else:
-            target_node = nearest_node  # else use the nearest node
-    else:
-        target_node = nearest_node
-    return target_node
-
-
-def store_mouse_cursor(context, event):
-    space = context.space_data
-    v2d = context.region.view2d
-    tree = space.edit_tree
-
-    # convert mouse position to the View2D for later node placement
-    if context.region.type == 'WINDOW':
-        space.cursor_location_from_region(event.mouse_region_x, event.mouse_region_y)
-    else:
-        space.cursor_location = tree.view_center
-
-
-def get_nodes_links(context):
-    tree = context.space_data.edit_tree
-    return tree.nodes, tree.links
-
-
-def get_internal_socket(socket):
-    # get the internal socket from a socket inside or outside the group
-    node = socket.node
-    if node.type == 'GROUP_OUTPUT':
-        iterator = node.id_data.interface.items_tree
-    elif node.type == 'GROUP_INPUT':
-        iterator = node.id_data.interface.items_tree
-    elif hasattr(node, "node_tree"):
-        iterator = node.node_tree.interface.items_tree
-    else:
-        return None
-
-    for s in iterator:
-        if s.identifier == socket.identifier:
-            return s
-    return iterator[0]
-
-
-def get_group_output_node(tree, output_node_type='GROUP_OUTPUT'):
-    for node in tree.nodes:
-        if node.type == output_node_type and node.is_active_output:
-            return node
-
-
-def get_output_location(tree):
-    # get right-most location
-    sorted_by_xloc = (sorted(tree.nodes, key=lambda x: x.location.x))
-    max_xloc_node = sorted_by_xloc[-1]
-
-    # get average y location
-    sum_yloc = 0
-    for node in tree.nodes:
-        sum_yloc += node.location.y
-
-    loc_x = max_xloc_node.location.x + max_xloc_node.dimensions.x + 80
-    loc_y = sum_yloc / len(tree.nodes)
-    return loc_x, loc_y
-
-
-def get_viewer_image():
-    for img in bpy.data.images:
-        if (img.source == 'VIEWER'
-                and len(img.render_slots) == 0
-                and sum(img.size) > 0):
-            return img
-
-
-def nw_check(cls, context):
-    space = context.space_data
-    if space.type != 'NODE_EDITOR':
-        cls.poll_message_set("Current editor is not a node editor.")
-        return False
-    if space.node_tree is None:
-        cls.poll_message_set("No node tree was found in the current node editor.")
-        return False
-    if space.node_tree.library is not None:
-        cls.poll_message_set("Current node tree is linked from another .blend file.")
-        return False
-    return True
-
-
-def nw_check_not_empty(cls, context):
-    if not context.space_data.edit_tree.nodes:
-        cls.poll_message_set("Current node tree does not contain any nodes.")
-        return False
-    return True
-
-
-def nw_check_active(cls, context):
-    if context.active_node is None or not context.active_node.select:
-        cls.poll_message_set("No active node.")
-        return False
-    return True
-
-
-def nw_check_selected(cls, context, min=1, max=inf):
-    num_selected = len(context.selected_nodes)
-    if num_selected < min:
-        if min > 1:
-            poll_message = tip_("At least {:d} nodes must be selected.").format(min)
-        else:
-            poll_message = tip_("At least one node must be selected.")
-        cls.poll_message_set(poll_message)
-        return False
-    if num_selected > max:
-        poll_message = tip_("{:d} nodes are selected, but this operator can only work on {:d}.").format(
-            num_selected, max)
-        cls.poll_message_set(poll_message)
-        return False
-    return True
-
-
-def nw_check_space_type(cls, context, types):
-    if context.space_data.tree_type not in types:
-        tree_types_str = ", ".join(t.split('NodeTree')[0].lower() for t in sorted(types))
-        poll_message = tip_("Current node tree type not supported.\n"
-                            "Should be one of {:s}.").format(tree_types_str)
-        cls.poll_message_set(poll_message)
-        return False
-    return True
-
-
-def nw_check_node_type(cls, context, type, invert=False):
-    if invert and context.active_node.type == type:
-        poll_message = tip_("Active node should not be of type {:s}.").format(type)
-        cls.poll_message_set(poll_message)
-        return False
-    elif not invert and context.active_node.type != type:
-        poll_message = tip_("Active node should be of type {:s}.").format(type)
-        cls.poll_message_set(poll_message)
-        return False
-    return True
-
-
-def nw_check_visible_outputs(cls, context):
-    if not any(is_visible_socket(out) for out in context.active_node.outputs):
-        cls.poll_message_set("Current node has no visible outputs.")
-        return False
-    return True
-
-
-def nw_check_viewer_node(cls):
-    if get_viewer_image() is None:
-        cls.poll_message_set("Viewer image not found.")
-        return False
-    return True
-
-
-def get_first_enabled_output(node):
-    for output in node.outputs:
-        if output.enabled:
-            return output
-    else:
-        return node.outputs[0]
-
-
-def is_visible_socket(socket):
-    return not socket.hide and socket.enabled and socket.type != 'CUSTOM'
-
-
-class NWBase:
-    @classmethod
-    def poll(cls, context):
-        return nw_check(cls, context)
-
-
-class NWBaseMenu:
-    @classmethod
-    def poll(cls, context):
-        space = context.space_data
-        return (space.type == 'NODE_EDITOR'
-                and space.node_tree is not None
-                and space.node_tree.library is None)

package/staging_area/Blender/5.0/scripts/addons_core/node_wrangler/utils/paths.py

@@ -1,169 +0,0 @@
-# SPDX-FileCopyrightText: 2023 Blender Foundation
-#
-# SPDX-License-Identifier: GPL-2.0-or-later
-
-from os import path
-import re
-
-
-def split_into_components(fname):
-    """
-    Split filename into components
-    'WallTexture_diff_2k.002.jpg' -> ['Wall', 'Texture', 'diff', 'k']
-    """
-    # Remove extension
-    fname = path.splitext(fname)[0]
-    # Remove digits
-    fname = "".join(i for i in fname if not i.isdigit())
-    # Separate CamelCase by space
-    fname = re.sub(r"([a-z])([A-Z])", r"\g<1> \g<2>", fname)
-    # Replace common separators with SPACE
-    separators = ["_", ".", "-", "__", "--", "#"]
-    for sep in separators:
-        fname = fname.replace(sep, " ")
-
-    components = fname.split(" ")
-    components = [c.lower() for c in components]
-    return components
-
-
-def remove_common_prefix(names_to_tag_lists):
-    """
-    Accepts a mapping of file names to tag lists that should be used for socket
-    matching.
-
-    This function modifies the provided mapping so that any common prefix
-    between all the tag lists is removed.
-
-    Returns true if some prefix was removed, false otherwise.
-    """
-    if not names_to_tag_lists:
-        return False
-    sample_tags = next(iter(names_to_tag_lists.values()))
-    if not sample_tags:
-        return False
-
-    common_prefix = sample_tags[0]
-    for tag_list in names_to_tag_lists.values():
-        if tag_list[0] != common_prefix:
-            return False
-
-    for name, tag_list in names_to_tag_lists.items():
-        names_to_tag_lists[name] = tag_list[1:]
-    return True
-
-
-def remove_common_suffix(names_to_tag_lists):
-    """
-    Accepts a mapping of file names to tag lists that should be used for socket
-    matching.
-
-    This function modifies the provided mapping so that any common suffix
-    between all the tag lists is removed.
-
-    Returns true if some suffix was removed, false otherwise.
-    """
-    if not names_to_tag_lists:
-        return False
-    sample_tags = next(iter(names_to_tag_lists.values()))
-    if not sample_tags:
-        return False
-
-    common_suffix = sample_tags[-1]
-    for tag_list in names_to_tag_lists.values():
-        if tag_list[-1] != common_suffix:
-            return False
-
-    for name, tag_list in names_to_tag_lists.items():
-        names_to_tag_lists[name] = tag_list[:-1]
-    return True
-
-
-def files_to_clean_file_names_for_sockets(files, sockets):
-    """
-    Accepts a list of files and a list of sockets.
-
-    Returns a mapping from file names to tag lists that should be used for
-    classification.
-
-    A file is something that we can do x.name on to figure out the file name.
-
-    A socket is a tuple containing:
-    * name
-    * list of tags
-    * a None field where the selected file name will go later. Ignored by us.
-    """
-
-    names_to_tag_lists = {}
-    for file in files:
-        names_to_tag_lists[file.name] = split_into_components(file.name)
-
-    all_tags = set()
-    for socket in sockets:
-        socket_tags = socket[1]
-        all_tags.update(socket_tags)
-
-    while len(names_to_tag_lists) > 1:
-        something_changed = False
-
-        # Common prefixes / suffixes provide zero information about what file
-        # should go to which socket, but they can confuse the mapping. So we get
-        # rid of them here.
-        something_changed |= remove_common_prefix(names_to_tag_lists)
-        something_changed |= remove_common_suffix(names_to_tag_lists)
-
-        # Names matching zero tags provide no value, remove those
-        names_to_remove = set()
-        for name, tag_list in names_to_tag_lists.items():
-            match_found = False
-            for tag in tag_list:
-                if tag in all_tags:
-                    match_found = True
-
-            if not match_found:
-                names_to_remove.add(name)
-
-        for name_to_remove in names_to_remove:
-            del names_to_tag_lists[name_to_remove]
-            something_changed = True
-
-        if not something_changed:
-            break
-
-    return names_to_tag_lists
-
-
-def match_files_to_socket_names(files, sockets):
-    """
-    Given a list of files and a list of sockets, match file names to sockets.
-
-    A file is something that you can get a file name out of using x.name.
-
-    After this function returns, all possible sockets have had their file names
-    filled in. Sockets without any matches will not get their file names
-    changed.
-
-    Sockets list format. Note that all file names are initially expected to be
-    None. Tags are strings, as are the socket names: [
-        [
-            socket_name, [tags], Optional[file_name]
-        ]
-    ]
-    """
-
-    names_to_tag_lists = files_to_clean_file_names_for_sockets(files, sockets)
-
-    for sname in sockets:
-        for name, tag_list in names_to_tag_lists.items():
-            if sname[0] == "Normal":
-                # Blender wants GL normals, not DX (DirectX) ones:
-                # https://www.reddit.com/r/blender/comments/rbuaua/texture_contains_normaldx_and_normalgl_files/
-                if 'dx' in tag_list:
-                    continue
-                if 'directx' in tag_list:
-                    continue
-
-            matches = set(sname[1]).intersection(set(tag_list))
-            if matches:
-                sname[2] = name
-                break