Custom nodes not working

[alicwyz]

Version:

UPBGE: 0.36
Logic Nodes: 2.3

Problem:

Custom nodes not appearing on the add menu after being imported

Description:

I was trying to code some custom OSC nodes to connect UPBGE to puredata (we were previously using python scripts with brick nodes, but that wasn't flexible enough or welcoming to beginners). But nothings seems to be working? Even the templates don't work.

If you try to import them they give "TypeError: Cannot create a consistent method resolution order (MRO)". Removing "bpy.types.nodes" from the class declaration fixes the issue, but still nothing happens and they don't appear anywhere? Is there some other way to add nodes?

Code:

• My "OSC Send" node:

# save in ./bgelogic/nodes/my_custom_nodes.py

import bpy
import bge_netlogic
import socket


#Sockets
NLParameterSocket = bge_netlogic.basicnodes.NLParameterSocket
NLConditionSocket = bge_netlogic.basicnodes.NLConditionSocket
NLIntegerFieldSocket = bge_netlogic.basicnodes.NLIntegerFieldSocket
NLQuotedStringFieldSocket = bge_netlogic.basicnodes.NLQuotedStringFieldSocket


#Nodes
NLParameterNode = bge_netlogic.basicnodes.NLParameterNode
NLConditionNode = bge_netlogic.basicnodes.NLConditionNode
NLActionNode = bge_netlogic.basicnodes.NLActionNode


#Send OSC Message
class OSCSendNode(NLActionNode):
    #id
    bl_idname = "OSCSendNode"
    #Título do Node
    bl_label = "Send OSC Message"
    
    #Initialize inputs x outputs
    def init(self, context):
        NLActionNode.init(self, context)
        
        #Inputs 
        self.inputs.new(NLConditionSocket.bl_idname, "Condition")

        self.inputs.new(NLQuotedStringFieldSocket.bl_idname, "IP")
        self.inputs[-1].value = socket.gethostbyname(socket.gethostname())
        
        self.inputs.new(NLIntegerFieldSocket.bl_idname, "Port")
        self.inputs[-1].value = 5005
        
        self.inputs.new(NLQuotedStringFieldSocket.bl_idname, "OSC Address")
        self.inputs[-1].value = "/game"
        
        self.inputs.new(NLParameterSocket.bl_idname, "Data")
        
        #Outputs
        self.outputs.new(NLConditionSocket.bl_idname, "Done")
    
    #Define Cell
    def get_netlogic_class_name(self):
        return "osc_cells.OSCSendCell"
    
    #Input sockets
    def get_input_sockets_field_names(self):
        return [
            "condition",
            "ip",
            "port",
            "osc",
            "data"
        ]
    
    #Output sockets
    def get_output_socket_varnames(self):
        return ['DONE']
    

bge_netlogic.register_nodes("OSC", OSCSendNode)

• My "OSC Send" cell:

# save to ./bgelogic/cells/my_custom_cells.py
# refresh imported nodes after changes have been applied to both custom cells
# and nodes

import bgelogic
import pythonosc.udp_client

ActionCell = bgelogic.ActionCell
ParameterCell = bgelogic.ParameterCell
LogicNetworkSubCell = bgelogic.LogicNetworkSubCell

class OSCSendCell(ActionCell):
    
    # Initializes the cell
    def __init__(self):
        ActionCell.__init__(self)
        
        #Inputs
        self.condition = None
        self.ip = None
        self.port = None
        self.osc = None
        self.data = None
        
        #Outputs
        self.DONE = LogicNetworkSubCell(self, self.set_output)
        
        #Internal
        self._done = False
        self._client = None
    
    #Ouput function
    def set_output(self):
        return self._done
    
    def evaluate(self):
        _condition = self.get_input(self.condition)
        if _condition is LogicNetworkSubCell.STATUS_WAITING:
            return
        
        _data = self.get_input(self.data)
        if _data is LogicNetworkSubCell.STATUS_WAITING:
            return
        
        _ip = self.get_input(self.ip)
        _port = self.get_input(self.port)
        _osc = self.get_input(self.osc)
        
        self._set_ready()
        
        if self.setup_server(_ip, _port):
            self._done = self.send_osc(_osc, _data)
    
    #Create OSC Server
    def setup_server(self, ip, port):
        if self._client is None:
            try:
                self._client = pythonosc.udp_client.SimpleUDPClient(
                    ip, 
                    port
                )
            except Exception as e:
                print(f"OSC Send Error: Could not create client - {e}")
                return False
        return True
        
    def send_osc(self, osc, data):
        try:
            # Send message with appropriate type handling
            self._client.send_message(osc, [data])
            return True
        except Exception as e:
            print(f"OSC Send Error: {e}")
            return False
    
    

[IzaZed]

This seems to be using the older template system which requires the files to be saved in a specific location and UPBGE to be restarted (that was implemented years ago)

There's a newer system in more recent releases that makes creating custom nodes a lot easier, I will try to make it so that the new release of Logic Nodes will be compatible with 0.36 as well

PS: I want to appreciate the format of this error report, thank you for that!

[IzaZed]

For reference, these are the new templates for custom nodes:

from bge_netlogic import custom_node
from bge_netlogic.editor.nodes.node import LogicNodeCustomType
from bge_netlogic.editor.sockets import *


# the @custom_node decorator automatically registers this node-type
# once it has been imported.
@custom_node
class LogicNodeCustomNode(LogicNodeCustomType):
    # `bl_idname` has to stay the same through later versions. Nodes
    # are registered under this ID, so if it changes, blender
    # cannot find nodes added by older versions
    bl_idname = 'LogicNodeCustomNode'
    bl_label = 'My Custom Node'
    bl_description = 'This is a custom node'

    # `nl_module` defines the module (python file) where the game-side
    # implementation of the node is found. In this case, the corresponding
    # file is a text block in the current .blend file, so we need to
    # locally import it by prefixing "."
    nl_module = '.mycustomnode'
    # `nl_class` defines the class to be instantiated and run in-game.
    nl_class = 'MyCustomNode'

    def init(self, context):
        # Add your inputs/outputs here like this:
        #    self.add_input(SOCKET_CLASS_NAME, SOCKET_DISPLAY_NAME, LOGIC_ATTRIBUTE_NAME)
        # SOCKET_CLASS_NAME: This defines the type of the socket
        # SOCKET_DISPLAY_NAME: This string will be shown next to the socket
        # LOGIC_ATTRIBUTE_NAME: This is the corresponding attribute name in the game-side implementation
        self.add_input(NodeSocketLogicObject, 'Object', 'game_object')
        self.add_output(NodeSocketLogicString, 'Name', 'NAME')

        # call the superclass constructor last, because this marks the
        # node as "ready" for the editor.
        LogicNodeCustomType.init(self, context)

from uplogic.nodes import LogicNodeCustom


class MyCustomNode(LogicNodeCustom):

    def __init__(self):
        # Call superclass (parent class) constructor
        super().__init__()

        # Initialize input socket values
        self.game_object = None

        # Initialize output sockets.
        # 'self.add_output()' needs the getter function which is called
        # when a linked socket requests a value.
        self.NAME = self.add_output(self.get_name)

    def get_name(self):
        # This getter function contains the logic that is executed
        # when the first linked socket requests data. Once calculated,
        # the value is stored to avoid re-calculation if there's more
        # than one linked socket.
        game_object = self.get_input(self.game_object)
        return game_object.name

    def evaluate(self):
        # This function is called every frame, regardless of whether the
        # node is needed or not. Keep this as slim as possible.
        pass

    def reset(self):
        # This is called at the end of each frame. Same as with 'evaluate()',
        # keep code in here to a minimum. At the very least you need to call
        # the superclass function though.
        super().reset()