nodeutils.py

# Copyright (C) 2021 Victor Soupday
# This file is part of CC/iC Blender Tools <https://github.com/soupday/cc_blender_tools>
#
# CC/iC Blender Tools is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# CC/iC Blender Tools is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with CC/iC Blender Tools.  If not, see <https://www.gnu.org/licenses/>.

import os

import bpy
import mathutils

from . import utils, vars

cursor = mathutils.Vector((0,0))
cursor_top = mathutils.Vector((0,0))
max_cursor = mathutils.Vector((0,0))
new_nodes = []


def clear_cursor():
    cursor_top.x = 0
    cursor_top.y = 0
    cursor.x = 0
    cursor.y = 0
    max_cursor.x = 0
    max_cursor.y = 0
    new_nodes.clear()


def reset_cursor():
    cursor_top.y = max_cursor.y
    cursor_top.x = 0
    cursor.x = 0
    cursor.y = cursor_top.y


def advance_cursor(scale = 1.0):
    cursor.y = cursor_top.y - cursor_top.x
    cursor.x += vars.GRID_SIZE * scale
    if (cursor.x > max_cursor.x):
        max_cursor.x = cursor.x


def drop_cursor(scale = 1.0):
    cursor.y -= vars.GRID_SIZE * scale
    if cursor.y < max_cursor.y:
        max_cursor.y = cursor.y


def step_cursor(scale = 1.0, drop = 0.25):
    cursor_top.x += vars.GRID_SIZE * drop
    cursor.y = cursor_top.y - cursor_top.x
    cursor.x += vars.GRID_SIZE * scale
    if (cursor.x > max_cursor.x):
        max_cursor.x = cursor.x


def step_cursor_if(thing, scale = 1.0, drop = 0.25):
    if thing is not None:
        step_cursor(scale, drop)


def move_new_nodes(dx, dy):

    width = max_cursor.x
    height = -max_cursor.y - vars.GRID_SIZE

    for node in new_nodes:
        node.location.x += (dx) - width
        node.location.y += (dy) + (height / 2)

    clear_cursor()


def make_shader_node(nodes, type, scale = 1.0):
    shader_node = nodes.new(type)
    shader_node.location = cursor
    new_nodes.append(shader_node)
    drop_cursor(scale)
    return shader_node


## color_space: Non-Color, sRGB
def make_image_node(nodes, image, name, scale = 1.0):
    if image is None:
        return None
    image_node = make_shader_node(nodes, "ShaderNodeTexImage", scale)
    image_node.image = image
    image_node.name = utils.unique_name(name)
    return image_node


def make_separate_rgb_node(nodes, label, name):
    value_node = make_shader_node(nodes, "ShaderNodeSeparateRGB")
    value_node.label = label
    value_node.name = utils.unique_name(name)
    return value_node


def make_value_node(nodes, label, name, value = 0.0):
    value_node = make_shader_node(nodes, "ShaderNodeValue", 0.4)
    value_node.label = label
    value_node.name = utils.unique_name(name)
    set_node_output_value(value_node, "Value", value)
    return value_node


def make_mixrgb_node(nodes, blend_type):
    mix_node = make_shader_node(nodes, "ShaderNodeMixRGB", 0.8)
    mix_node.blend_type = blend_type
    return mix_node


def make_math_node(nodes, operation, value1 = 0.5, value2 = 0.5):
    math_node = make_shader_node(nodes, "ShaderNodeMath", 0.6)
    math_node.operation = operation
    math_node.inputs[0].default_value = value1
    math_node.inputs[1].default_value = value2
    return math_node


def make_bump_node(nodes, strength, distance):
    bump_node : bpy.types.ShaderNodeBump = make_shader_node(nodes, "ShaderNodeBump")
    set_node_input_value(bump_node, "Strength", strength)
    set_node_input_value(bump_node, "Distance", distance)
    return bump_node


def make_normal_map_node(nodes, strength):
    normal_map_node : bpy.types.ShaderNodeBump = make_shader_node(nodes, "ShaderNodeNormalMap")
    set_node_input_value(normal_map_node, "Strength", strength)
    return normal_map_node


def make_rgb_node(nodes, label, value = [1.0, 1.0, 1.0, 1.0]):
    rgb_node = make_shader_node(nodes, "ShaderNodeRGB", 0.8)
    rgb_node.label = label
    set_node_output_value(rgb_node, "Color", value)
    return rgb_node


def make_vectormath_node(nodes, operation):
    vm_node = make_shader_node(nodes, "ShaderNodeVectorMath", 0.6)
    vm_node.operation = operation
    return vm_node


def make_node_group_node(nodes, group, label, name):
    group_node = make_shader_node(nodes, "ShaderNodeGroup")
    group_node.node_tree = group
    group_node.label = label
    group_node.width = 240
    group_node.name = utils.unique_name("(" + name + ")")
    return group_node


def make_gltf_settings_node(nodes):
    gltf_group : bpy.types.NodeGroup = None
    for group in bpy.data.node_groups:
        if group.name == "glTF Settings":
            gltf_group = group
    if not gltf_group:
        if utils.B400():
            gltf_group = bpy.data.node_groups.new("glTF Material Output", "ShaderNodeTree")
            gltf_group.interface.new_socket("Occlusion", in_out="INPUT", socket_type="NodeSocketColor")
            gltf_group.interface.new_socket("Thickness", in_out="INPUT", socket_type="NodeSocketFloat")
            gltf_group.interface.new_socket("Specular", in_out="INPUT", socket_type="NodeSocketFloat")
            gltf_group.interface.new_socket("Specular Color", in_out="INPUT", socket_type="NodeSocketColor")
        else:
            gltf_group = bpy.data.node_groups.new("glTF Settings", "ShaderNodeTree")
            gltf_group.inputs.new("NodeSocketColor", "Occlusion")
            gltf_group.inputs.new("NodeSocketFloat", "Thickness")
            gltf_group.inputs.new("NodeSocketFloat", "Specular")
            gltf_group.inputs.new("NodeSocketColor", "Specular Color")
    return make_node_group_node(nodes, gltf_group, "glTF Settings", "glTF Settings")


## Node Socket Functions
#


def safe_node_output_socket(node, socket_or_name_or_number):
    """Return the node's socket or named output socket."""

    try:
        if type(socket_or_name_or_number) == str:
            return output_socket(node, socket_or_name_or_number)
        elif type(socket_or_name_or_number) == int:
            return node.outputs[socket_or_name_or_number]
        else:
            return socket_or_name_or_number
    except:
        return None


def safe_node_input_socket(node, socket_or_name_or_number):
    """Return the node's socket or named input socket."""

    try:
        if type(socket_or_name_or_number) == str:
            return input_socket(node, socket_or_name_or_number)
        elif type(socket_or_name_or_number) == int:
            return node.inputs[socket_or_name_or_number]
        else:
            return socket_or_name_or_number
    except:
        return None


def safe_socket_name(socket_or_name):
    """Return the supplied name or socket's name."""

    try:
        if type(socket_or_name) == str:
            return socket_or_name
        elif type(socket_or_name) == int:
            return int(socket_or_name)
        else:
            return socket_or_name.name
    except:
        return None


def get_node_input_value(node : bpy.types.Node, socket, default = None):
    """Returns the node's socket or named input sockets default value
       or if linked to, the connecting node's default output value.\n
       Returns the supplied default value if node/socket is invalid."""

    socket = safe_node_input_socket(node, socket)
    if node and socket:
        try:
            if socket.is_linked:
                connecting_node, connecting_socket = get_node_and_socket_connected_to_input(node, socket)
                return get_node_output_value(connecting_node, connecting_socket, default)
            return socket.default_value
        except:
            pass
    return default


def get_node_output_value(node, socket, default):
    """Returns the node's socket or named output sockets default value.\n
       Returns the supplied default value if node/socket is invalid."""

    socket = safe_node_output_socket(node, socket)
    if node and socket:
        try:
            return socket.default_value
        except:
            return default
    return default


def set_node_input_value(node, socket, value):
    """Sets the node's socket or named input socket's default value.\n
       If the socket's value is multidimensional the value will be set in each dimension."""

    socket = safe_node_input_socket(node, socket)
    if node and socket:
        try:
            socket.default_value = utils.match_dimensions(socket.default_value, value)
        except:
            utils.log_detail("Unable to set input: " + node.name + "[" + str(socket) + "]")


def set_node_output_value(node, socket, value):
    """Sets the node's socket or named output socket's default value.\n
       If the socket's value is multidimensional the value will be set in each dimension."""

    socket = safe_node_output_socket(node, socket)
    if node and socket:
        try:
            socket.default_value = utils.match_dimensions(socket.default_value, value)
        except:
            utils.log_detail("Unable to set output: " + node.name + "[" + str(socket) + "]")


BLENDER_4_SOCKET_REDIRECT = {
    "BSDF_PRINCIPLED": {
        "Subsurface": "Subsurface Weight",
        "Specular": "Specular IOR Level",
        "Sheen": "Sheen Weight",
        "Emission": "Emission Color",
        "Transmission": "Transmission Weight",
        "Clearcoat": "Coat Weight",
        "Clearcoat Roughness": "Coat Roughness",
    }
}

def input_socket(node, socket_name: str):
    try:
        if utils.B400():
            if type(socket_name) is str:
                if node and node.type in BLENDER_4_SOCKET_REDIRECT:
                    mappings = BLENDER_4_SOCKET_REDIRECT[node.type]
                    socket_name = safe_socket_name(socket_name)
                    if socket_name in mappings:
                        blender_4_socket = mappings[socket_name]
                        if node.inputs and blender_4_socket in node.inputs:
                            return node.inputs[blender_4_socket]
        if type(socket_name) == str or type(socket_name) == int:
            return node.inputs[socket_name]
        else:
            return socket_name
    except:
        return None

def output_socket(node, socket_name: str):
    try:
        if utils.B400():
            if type(socket_name) is str:
                if node and node.type in BLENDER_4_SOCKET_REDIRECT:
                    mappings = BLENDER_4_SOCKET_REDIRECT[node.type]
                    socket_name = safe_socket_name(socket_name)
                    if socket_name in mappings:
                        blender_4_socket = mappings[socket_name]
                        if node.outputs and blender_4_socket in node.outputs:
                            return node.outputs[blender_4_socket]
        if type(socket_name) == str or type(socket_name) == int:
            return node.outputs[socket_name]
        else:
            return socket_name
    except:
        return None


def link_nodes(links, from_node, from_socket, to_node, to_socket):
    """Create's a link between the supplied from_node and to_node's sockets (or named sockets)."""

    if from_node and to_node:
        try:
            from_socket = safe_node_output_socket(from_node, from_socket)
            to_socket = safe_node_input_socket(to_node, to_socket)
            if from_socket and to_socket:
                links.new(from_socket, to_socket)
        except:
            utils.log_detail(f"Unable to link: {from_node.name} [{str(from_socket)}] to {to_node.name} [{str(to_socket)}]")


def unlink_node_output(links, node, *sockets):
    """Removes the link from the socket (or the node's named output socket)."""

    for socket in sockets:
        socket = safe_node_output_socket(node, socket)
        if node and socket:
            try:
                for link in socket.links:
                    if link is not None:
                        links.remove(link)
            except:
                utils.log_info("Unable to remove links from: " + node.name + "[" + str(socket) + "]")


def unlink_node_input(links, node, *sockets):
    """Removes the link from the socket (or the node's named output socket)."""

    for socket in sockets:
        socket = safe_node_input_socket(node, socket)
        if node and socket:
            try:
                for link in socket.links:
                    if link is not None:
                        links.remove(link)
            except:
                utils.log_info("Unable to remove links from: " + node.name + "[" + str(socket) + "]")


def get_socket_connected_to_output(node, *sockets):
    """Returns the *first* linked socket connected from the supplied node's output socket (or named output socket)."""

    for socket in sockets:
        try:
            socket = safe_node_output_socket(node, socket)
            if socket:
                return socket.links[0].to_socket
        except:
            pass
    return None


def get_socket_connected_to_input(node, *sockets):
    """Returns the linked socket connected to the supplied node's input socket (or named input socket)."""

    for socket in sockets:
        try:
            socket = safe_node_input_socket(node, socket)
            if socket:
                return socket.links[0].from_socket
        except:
            pass
    return None


def get_node_connected_to_output(node, *sockets):
    """Returns the *first* linked node connected from the supplied node's input socket (or named input socket)."""

    for socket in sockets:
        try:
            socket = safe_node_output_socket(node, socket)
            if socket:
                return socket.links[0].to_node
        except:
            pass
    return None


def get_node_connected_to_input(node, *sockets):
    """Returns the linked node connected to the supplied node's input socket (or named input socket)."""

    for socket in sockets:
        try:
            socket = safe_node_input_socket(node, socket)
            if socket:
                return socket.links[0].from_node
        except:
            pass
    return None


def get_node_and_socket_connected_to_output(node, *sockets):
    """Returns the *first* linked node and socket connected from the supplied node's output socket
       (or named output socket)."""

    for socket in sockets:
        try:
            socket = safe_node_output_socket(node, socket)
            if socket:
                return socket.links[0].to_node, socket.links[0].to_socket
        except:
            pass
    return None, None


def get_node_and_socket_connected_to_input(node, *sockets):
    """Returns the linked node and socket connected to the the supplied node's input socket
       (or named input socket)."""

    for socket in sockets:
        try:
            socket = safe_node_input_socket(node, socket)
            if socket:
                return socket.links[0].from_node, socket.links[0].from_socket
        except:
            pass
    return None, None


def has_input(node, *sockets):
    for socket in sockets:
        try:
            socket = safe_node_input_socket(node, socket)
            if socket:
                return True
        except:
            pass
    return False


def has_connected_input(node, *sockets):
    """Returns True if the node's input socket (or named input socket) is linked to from another node."""

    for socket in sockets:
        try:
            socket = safe_node_input_socket(node, socket)
            if socket.is_linked:
                return True
        except:
            pass
    return False


def has_connected_output(node, *sockets):
    """Returns True if the node's input socket (or named input socket) is linked to from another node."""

    for socket in sockets:
        try:
            socket = safe_node_output_socket(node, socket)
            if socket.is_linked:
                return True
        except:
            pass
    return False


def is_mixer_connected(node : bpy.types.Node, socket):
    socket = safe_node_input_socket(node, socket)
    try:
        mixer = get_node_connected_to_input(node, socket)
        if mixer and mixer.type == "GROUP":
            if vars.NODE_PREFIX in mixer.name and "rl_mixer" in mixer.name:
                return True
    except:
        pass
    return False


def is_image_node_connected_to_node(node, image, done):
    """Returns True if there is a linked image node with the supplied image connecting the this node."""

    for socket in node.inputs:
        if socket.is_linked:
            found = is_image_node_connected_to_socket(node, socket, image, done)
            if found:
                return True
    return False


def is_image_node_connected_to_socket(node, socket, image, done):
    """Returns True if there is a linked image node with the supplied image connecting the this node and socket."""

    connected_node = get_node_connected_to_input(node, socket)
    if not connected_node or connected_node in done:
        return False

    done.append(connected_node)

    if connected_node.type == "TEX_IMAGE" and connected_node.image == image:
        return True
    else:
        return is_image_node_connected_to_node(node, image, done)


def get_node_by_id(nodes, id_string):
    """Find a node with a particular id string."""

    for node in nodes:
        if vars.NODE_PREFIX in node.name and id_string in node.name:
            return node
    return None


def get_node_by_id_and_type(nodes, id, type):
    """Find a node with a particular id string and node type."""

    for node in nodes:
        if vars.NODE_PREFIX in node.name and id in node.name and node.type == type:
            return node
    return None


def reset_shader(mat_cache, nodes, links, shader_label, shader_name, shader_group, mix_shader_group, custom_bsdf = None):
    prefs = vars.prefs()
    shader_id = "(" + str(shader_name) + ")"
    bsdf_id = "(" + str(shader_name) + "_BSDF)"
    mix_id = "(" + str(shader_name) + "_MIX)"
    wrinkle_id = "(rl_wrinkle_shader)"

    group_node: bpy.types.Node = None
    mix_node: bpy.types.Node = None
    bsdf_node: bpy.types.Node = None
    output_node: bpy.types.Node = None
    wrinkle_node: bpy.types.Node = None

    has_group_node = shader_group is not None and shader_group != ""
    has_bsdf = has_group_node
    has_mix_node = mix_shader_group is not None and mix_shader_group != ""

    links.clear()

    for n in nodes:

        if not custom_bsdf and n.type == "BSDF_PRINCIPLED" and has_bsdf and shader_name in n.name:

            if not bsdf_node:
                utils.log_info("Keeping old BSDF: " + n.name)
                bsdf_node = n
            else:
                nodes.remove(n)

        elif custom_bsdf and n.type == "GROUP" and custom_bsdf in n.node_tree.name and has_bsdf and shader_name in n.name:

            if not bsdf_node:
                utils.log_info("Keeping old custom BSDF: " + n.name)
                bsdf_node = n
            else:
                nodes.remove(n)

        elif n.type == "GROUP" and n.node_tree and shader_name in n.name and vars.VERSION_STRING in n.node_tree.name:

            if wrinkle_id in n.node_tree.name:
                utils.log_info("Keeping old wrinkle shader group: " + n.name)
                wrinkle_node = n

            elif has_group_node and shader_group in n.node_tree.name:
                if not group_node:
                    utils.log_info("Keeping old shader group: " + n.name)
                    group_node = n
                else:
                    nodes.remove(n)

            elif has_mix_node and mix_shader_group in n.node_tree.name:
                if not mix_node:
                    utils.log_info("Keeping old mix shader group: " + n.name)
                    mix_node = n
                else:
                    nodes.remove(n)

            else:
                nodes.remove(n)

        elif n.type == "OUTPUT_MATERIAL":

            if output_node:
                nodes.remove(n)
            else:
                output_node = n

        elif n.type == "TEX_IMAGE":

            if vars.NODE_PREFIX in n.name:
                # keep images
                pass

            elif not mat_cache.user_added:
                # keep all images if it is a user added material
                nodes.remove(n)

        else:
            nodes.remove(n)

    if has_group_node and not group_node:
        group = get_node_group(shader_group)
        group_node = nodes.new("ShaderNodeGroup")
        group_node.node_tree = group
        group_node.name = utils.unique_name(shader_id)
        group_node.label = shader_label
        group_node.width = 240
        utils.log_info("Creating new shader group: " + group_node.name)

    if has_mix_node and not mix_node:
        group = get_node_group(mix_shader_group)
        mix_node = nodes.new("ShaderNodeGroup")
        mix_node.node_tree = group
        mix_node.name = utils.unique_name(mix_id)
        mix_node.label = shader_label
        mix_node.width = 240
        utils.log_info("Creating new mix shader group: " + mix_node.name)

    # if the mix node has no BSDF input, then it doesn't need the Principled BSDF to mix:
    if has_mix_node and has_bsdf:
        if "BSDF" not in mix_node.inputs:
            has_bsdf = False
            if bsdf_node:
                nodes.remove(bsdf_node)
                bsdf_node = None

    if has_bsdf and not bsdf_node:
        if custom_bsdf:
            template_group = get_node_group(custom_bsdf)
            # single user copy of template group:
            group = template_group.copy()
            bsdf_node = nodes.new("ShaderNodeGroup")
            bsdf_node.node_tree = group
            bsdf_node.name = utils.unique_name(bsdf_id)
            bsdf_node.label = shader_label
            bsdf_node.width = 240
            utils.log_info(f"Created new custom BSDF: {bsdf_node.name} ({custom_bsdf})")
        else:
            bsdf_node = nodes.new("ShaderNodeBsdfPrincipled")
            bsdf_node.name = utils.unique_name(bsdf_id)
            bsdf_node.label = shader_label
            bsdf_node.width = 240
            utils.log_info(f"Created new BSDF: {bsdf_node.name}")

    if not output_node:
        output_node = nodes.new("ShaderNodeOutputMaterial")

    if has_bsdf:
        if has_group_node:
            bsdf_node.location = (200, 400)
        else:
            bsdf_node.location = (0,0)

    if has_group_node:
        group_node.location = (-400, 0)

    if has_mix_node:
        mix_node.location = (500, -500)

    output_node.location = (900, -400)

    blocked_bsdf_sockets = []
    if prefs.render_target != "CYCLES":
        blocked_bsdf_sockets.append("Subsurface Radius")
        blocked_bsdf_sockets.append("Subsurface Color")

    # connect all group_node outputs to BSDF inputs:
    if has_group_node and has_bsdf:
        for socket in group_node.outputs:
            if socket.name not in blocked_bsdf_sockets:
                to_socket = input_socket(bsdf_node, socket.name)
                link_nodes(links, group_node, socket.name, bsdf_node, to_socket)
    link_nodes(links, group_node, "Transmission Alpha", bsdf_node, "Alpha")

    if utils.B400():
        set_node_input_value(bsdf_node, "Subsurface Scale", 1.0)
        set_node_input_value(bsdf_node, "Sheen Roughness", 0.05)
        if has_connected_input(bsdf_node, "Emission Color"):
            set_node_input_value(bsdf_node, "Emission Strength", 1.0)

    if prefs.render_target != "CYCLES" and not utils.B400():
        link_nodes(links, group_node, "Base Color", bsdf_node, "Subsurface Color")

    # connect group_node outputs to any mix_node inputs:
    if has_mix_node and has_group_node:
        for socket in mix_node.inputs:
            link_nodes(links, group_node, socket.name, mix_node, socket.name)

    # connect up the BSDF to the mix_node:
    if has_mix_node and has_bsdf:
        link_nodes(links, bsdf_node, "BSDF", mix_node, "BSDF")

    # connect the shader to the output
    if has_mix_node:
        link_nodes(links, mix_node, "BSDF", output_node, "Surface")
    elif has_bsdf:
        link_nodes(links, bsdf_node, "BSDF", output_node, "Surface")

    # connect any displacement and/or thickness to the output
    if has_group_node:
        link_nodes(links, group_node, "Displacement", output_node, "Displacement")
        link_nodes(links, group_node, "Thickness", output_node, "Thickness")

    # don't do anything with the old wrinkle shader node yet

    return bsdf_node, group_node


def clean_unused_image_nodes(nodes):
    to_remove = []
    for node in nodes:
        if node.type == "TEX_IMAGE":
            is_linked = False
            for output in node.outputs:
                if output.is_linked:
                    is_linked = True
            if not is_linked:
                to_remove.append(node)

    for node in to_remove:
        utils.log_info("Removing unused image node: " + node.name)
        nodes.remove(node)


def is_texture_pack_system(node):
    if (vars.PACK_DIFFUSEROUGHNESS_ID in node.name or
        vars.PACK_DIFFUSEROUGHNESSBLEND1_ID in node.name or
        vars.PACK_DIFFUSEROUGHNESSBLEND2_ID in node.name or
        vars.PACK_DIFFUSEROUGHNESSBLEND3_ID in node.name or
        vars.PACK_DIFFUSEALPHA_ID in node.name or
        vars.PACK_MRSO_ID in node.name or
        vars.PACK_SSTM_ID in node.name or
        vars.PACK_MSMNAO_ID in node.name or
        vars.PACK_WRINKLEROUGHNESS_ID in node.name or
        vars.PACK_ROOTID_ID in node.name or
        vars.PACK_SSTMMNM_ID in node.name or
        "PACK_SPLIT" in node.name):
        return True
    else:
        return False


def get_node_group(name):
    for group in bpy.data.node_groups:
        if vars.NODE_PREFIX in group.name and name in group.name:
            if vars.VERSION_STRING in group.name:
                return group
    return fetch_node_group(name)


def get_lib_image(name):
    for image in bpy.data.images:
        if vars.NODE_PREFIX in image.name and name in image.name:
            if vars.VERSION_STRING in image.name:
                return image
    return fetch_lib_image(name)


def check_node_groups():
    for name in vars.NODE_GROUPS:
        get_node_group(name)


def remove_all_groups():
    for group in bpy.data.node_groups:
        if vars.NODE_PREFIX in group.name:
            bpy.data.node_groups.remove(group)


def rebuild_node_groups():
    remove_all_groups()
    check_node_groups()
    return


def find_node_by_keywords(nodes, *keywords):
    for node in nodes:
        match = True
        for keyword in keywords:
            if not keyword in node.name:
                match = False
                break
        if match:
            return node
    return None


def find_node_by_type(nodes, type):
    for n in nodes:
        if n.type == type:
            return n
    return None


def find_node_by_image(nodes, image):
    for n in nodes:
        if n.type == "TEX_IMAGE" and n.image == image:
            return n
    return None


def find_node_by_type_and_keywords(nodes, type, *keywords):
    for node in nodes:
        if node.type == type:
            match = True
            for keyword in keywords:
                if not keyword in node.name:
                    match = False
                    break
            if match:
                return node
    return None


def find_node_group_by_keywords(nodes, *keywords):
    for node in nodes:
        if node.type == "GROUP" and node.node_tree and node.node_tree.nodes:
            match = True
            for keyword in keywords:
                if not keyword in node.node_tree.name:
                    match = False
                    break
            if match:
                return node
    return None


def get_image_node_mapping(image_node):
    """Returns the location offset, rotation and scale vectors of any attached mapping node to the image node."""

    location = (0,0,0)
    rotation = (0,0,0)
    scale = (1,1,1)
    if image_node and image_node.type == "TEX_IMAGE":
        mapping_node = get_node_connected_to_input(image_node, "Vector")
        if mapping_node:
            if mapping_node.type == "MAPPING":
                location = get_node_input_value(mapping_node, "Location", (0,0,0))
                rotation = get_node_input_value(mapping_node, "Rotation", (0,0,0))
                scale = get_node_input_value(mapping_node, "Scale", (1,1,1))
            elif mapping_node.type == "GROUP": # custom mapping group
                location = get_node_input_value(mapping_node, "Offset", (0,0,0))
                scale = get_node_input_value(mapping_node, "Tiling", (1,1,1))
    return location, rotation, scale


def store_texture_mapping(image_node, mat_cache, texture_type):
    if image_node and image_node.type == "TEX_IMAGE":
        location, rotation, scale = get_image_node_mapping(image_node)
        texture_path = bpy.path.abspath(image_node.image.filepath)
        embedded = image_node.image.packed_file is not None
        image = image_node.image
        mat_cache.set_texture_mapping(texture_type, texture_path, embedded, image, location, rotation, scale)
        utils.log_info("Storing texture Mapping for: " + mat_cache.material.name + " texture: " + texture_type)
        image_id = "(" + texture_type + ")"
        image_node.name = utils.unique_name(image_id)


# link utils

def append_node_group(path, object_name):
    if utils.B341():
        filename = "_LIB341.blend"
    else:
        filename = "_LIB293.blend"
    datablock = "NodeTree"
    file = os.path.join(path, filename)
    appended_group = None

    if os.path.exists(file):
        bpy.ops.wm.append(directory=os.path.join(path, filename, datablock), filename=object_name, set_fake=False, link=False)

        for g in bpy.data.node_groups:
            if object_name in g.name and vars.NODE_PREFIX not in g.name:
                appended_group = g
                g.name = utils.unique_name(object_name)

    return appended_group


def fetch_node_group(name):
    paths = []
    local_path = utils.local_path()
    if local_path:
        paths.append(local_path)
    paths.append(os.path.dirname(os.path.realpath(__file__)))

    for path in paths:
        utils.log_info("Trying to append: " + path + " > " + name)
        if os.path.exists(path):
            group = append_node_group(path, name)
            if group is not None:
                return group
    utils.log_error("Trying to append group: " + name + ", _LIB.blend library file not found?")
    raise ValueError(f"Unable to append node group: {name} from library file!")


def append_lib_image(path, object_name):
    if utils.B341():
        filename = "_LIB341.blend"
    else:
        filename = "_LIB293.blend"
    datablock = "Image"
    file = os.path.join(path, filename)
    appended_image = None

    if os.path.exists(file):
        bpy.ops.wm.append(directory=os.path.join(path, filename, datablock), filename=object_name, set_fake=False, link=False)

        for i in bpy.data.images:
            if object_name in i.name and vars.NODE_PREFIX not in i.name:
                utils.log_info("Trying to append image: " + path + " > " + object_name)
                appended_image = i
                i.name = utils.unique_name(object_name)

    return appended_image


def fetch_lib_image(name):
    paths = []
    local_path = utils.local_path()
    if local_path:
        paths.append(local_path)
    paths.append(os.path.dirname(os.path.realpath(__file__)))

    for path in paths:
        if os.path.exists(path):
            image = append_lib_image(path, name)
            if image:
                return image
    utils.log_error("Trying to append image: " + name + ", _LIB.blend library file not found?")
    raise ValueError("Unable to append iamge from library file!")


def get_shader_node(nodes):
    for n in nodes:
        if n.type == "GROUP" and "(rl_" in n.name and "_shader)" in n.name:
            name = n.node_tree.name
            if vars.NODE_PREFIX in name and "_rl_" in name and "_shader_" in name:
                return n
    return None


def get_shader_nodes(mat, shader_name = None):
    if mat and mat.node_tree:
        nodes = mat.node_tree.nodes
        if shader_name:
            shader_id = "(" + str(shader_name) + ")"
            bsdf_id = "(" + str(shader_name) + "_BSDF)"
            mix_id = "(" + str(shader_name) + "_MIX)"
        else:
            shader_id = "_shader)"
            bsdf_id = "_BSDF)"
            mix_id = "_MIX)"
        shader_node = bsdf_node = mix_node = None
        for node in nodes:
            if vars.NODE_PREFIX in node.name:
                if shader_id in node.name:
                    shader_node = node
                elif bsdf_id in node.name:
                    bsdf_node = node
                elif mix_id in node.name:
                    mix_node = node
        return bsdf_node, shader_node, mix_node
    return None, None, None


def get_bsdf_node(mat):
    if mat and mat.node_tree:
        nodes = mat.node_tree.nodes
        for node in nodes:
            if node.type == "BSDF_PRINCIPLED":
                return node
        for node in nodes:
            if node.type == "GROUP" and "_BSDF)" in node.name:
                return node
    return None


def get_custom_bsdf_nodes(mat_or_node):
    bsdf_nodes = []
    bsdf_node = None
    if type(mat_or_node) is bpy.types.Material:
        bsdf_node = get_bsdf_node(mat_or_node)
    else:
        bsdf_node = mat_or_node
    if bsdf_node:
        if bsdf_node.type == "GROUP":
            for node in bsdf_node.node_tree.nodes:
                if node.type == "BSDF_PRINCIPLED":
                    bsdf_nodes.append(node)
        else:
            bsdf_nodes.append(bsdf_node)
    return bsdf_nodes


def get_tiling_node(mat, shader_name, texture_type):
    if mat and mat.node_tree:
        nodes = mat.node_tree.nodes
        shader_id = "(tiling_" + shader_name + "_" + texture_type + "_mapping)"
        return get_node_by_id(nodes, shader_id)
    return None


def get_tiling_node_from_nodes(nodes, shader_name, texture_type):
    shader_id = "(tiling_" + shader_name + "_" + texture_type + "_mapping)"
    return get_node_by_id(nodes, shader_id)


def create_custom_image_node(nodes, node_name, image, location = (0, 0)):
    # find or create the bake image node
    image_node = find_node_by_type_and_keywords(nodes, "TEX_IMAGE", node_name)
    if not image_node:
        image_node = make_image_node(nodes, image, node_name)
    if image_node.image != image:
        image_node.image = image
    image_node.location = location
    return image_node


def find_shader_texture(nodes, texture_type):
    id = "(" + texture_type + ")"
    for node in nodes:
        if node.type == "TEX_IMAGE" and vars.NODE_PREFIX in node.name and id in node.name:
            return node
    return None


def get_tex_image_size(node):
    if node and node.image:
        return node.image.size[0], node.image.size[1]
    return 64, 64


def get_largest_image_size(*nodes):
    max_size = [0,0]
    for node in nodes:
        if node and node.image:
            size = get_tex_image_size(node)
            max_size[0] = max(max_size[0], size[0])
            max_size[1] = max(max_size[1], size[1])
    return max_size[0], max_size[1]


# e.g.
# Normal:Height
# Normal:Color
# Normal:Normal:Color
def trace_input_sockets(node, socket_trace : str):
    if node and socket_trace:
        socket_names = socket_trace.split(":")
        trace_node = None
        trace_socket = None
        try:
            if socket_names:
                trace_node : bpy.types.Node = node
                for socket_name in socket_names:
                    socket = input_socket(trace_node, socket_name)
                    if socket and socket.is_linked:
                        link = socket.links[0]
                        trace_node = link.from_node
                        trace_socket = link.from_socket
                    else:
                        trace_node = None
                        trace_socket = None
                        break
        except:
            trace_node = None
            trace_socket = None

    return trace_node, trace_socket


def trace_input_value(node, socket_trace, default_value):
    if node and socket_trace:
        socket_names = socket_trace.split(":")
        trace_node = None
        trace_socket = None
        try:
            value_socket_name = socket_names[-1]
            socket_names = socket_names[:-1]
            trace_node : bpy.types.Node = node
            if socket_names:
                for socket_name in socket_names:
                    socket = input_socket(trace_node, socket_name)
                    if socket and socket.is_linked:
                        link = socket.links[0]
                        trace_node = link.from_node
                        trace_socket = link.from_socket
                    else:
                        trace_node = None
                        trace_socket = None
                        break
            if trace_node:
                value_socket = input_socket(trace_node, value_socket_name)
                return get_node_input_value(trace_node, value_socket, default_value)
        except:
            pass
    return default_value


def set_trace_input_value(node, socket_trace, value):
    if node and socket_trace:
        socket_names = socket_trace.split(":")
        trace_node = None
        trace_socket = None
        try:
            value_socket_name = socket_names[-1]
            socket_names = socket_names[:-1]
            trace_node : bpy.types.Node = node
            if socket_names:
                for socket_name in socket_names:
                    socket = input_socket(trace_node, socket_name)
                    if socket and socket.is_linked:
                        link = socket.links[0]
                        trace_node = link.from_node
                        trace_socket = link.from_socket
                    else:
                        trace_node = None
                        trace_socket = None
                        break
            if trace_node:
                value_socket = input_socket(trace_node, value_socket_name)
                set_node_input_value(trace_node, value_socket, value)
                return True
        except:
            pass
    return False


def furthest_from(n0, dir, *nodes):
    dir.normalize()
    most = 0
    result = n0
    for n in nodes:
        if n and n0:
            dn = (n.location - n0.location)
            proj = dir.dot(dn)
            if proj > most:
                most = proj
                result = n
    return result


def closest_to(n0, dir, *nodes):
    dir.normalize()
    least = 9999
    result = n0
    for n in nodes:
        if n and n0:
            dn = (n.location - n0.location)
            proj = dir.dot(dn)
            if proj < least:
                least = proj
                result = n
    return result