Material

Bases: Material

Material texture

You can refer to an existing material using its name in bpy.data.materials.

from geonodes import GeoNodes, Material, nd, Mesh, ShaderNodes, Shader, Input, Menu

# ---------------------------------------------------------------------------
# Building 3 materials
# ---------------------------------------------------------------------------

with ShaderNodes("Red"):
    ped = Shader.Principled(base_color='red')
    ped.out()

with ShaderNodes("Green"):
    ped = Shader.Principled(base_color='#00FF00FF')
    ped.out()

with ShaderNodes("Blue"):
    ped = Shader.Principled(base_color=(0, 0, 1))
    ped.out()

# ---------------------------------------------------------------------------
# Playing with materials
# ---------------------------------------------------------------------------

with GeoNodes("Material Test"):

    gs = Node('Menu Switch', menu=Input("Pick Geometry"))

    with gs:            
        g = Mesh.IcoSphere()
        mat0 = Material("Red")
        g.material = mat0
        g.out("Full Red")

    with gs:                
        mat1 = Material("Blue", name="Your Material")
        g[3:10].material = mat1
        g.out("Your material in 3:10")

    with gs:
        g.replace_material(mat0, "Green")
        g.out("Replace Red by Green")

    with gs:
        g.replace_material(mat0, "Green")
        g.out("Replace Red by Green")

    with gs:
        g[nd.material_index.equal(1)].material = "Red"
        g.out("Replace mat index 1 by Red")


    gs._out.out()

Source code in core/sock_material.py

class Material(generated.Material):
    """ Material texture

    You can refer to an existing material using its name in `bpy.data.materials`.

    ``` python
    from geonodes import GeoNodes, Material, nd, Mesh, ShaderNodes, Shader, Input, Menu

    # ---------------------------------------------------------------------------
    # Building 3 materials
    # ---------------------------------------------------------------------------

    with ShaderNodes("Red"):
        ped = Shader.Principled(base_color='red')
        ped.out()

    with ShaderNodes("Green"):
        ped = Shader.Principled(base_color='#00FF00FF')
        ped.out()

    with ShaderNodes("Blue"):
        ped = Shader.Principled(base_color=(0, 0, 1))
        ped.out()

    # ---------------------------------------------------------------------------
    # Playing with materials
    # ---------------------------------------------------------------------------

    with GeoNodes("Material Test"):

        gs = Node('Menu Switch', menu=Input("Pick Geometry"))

        with gs:            
            g = Mesh.IcoSphere()
            mat0 = Material("Red")
            g.material = mat0
            g.out("Full Red")

        with gs:                
            mat1 = Material("Blue", name="Your Material")
            g[3:10].material = mat1
            g.out("Your material in 3:10")

        with gs:
            g.replace_material(mat0, "Green")
            g.out("Replace Red by Green")

        with gs:
            g.replace_material(mat0, "Green")
            g.out("Replace Red by Green")

        with gs:
            g[nd.material_index.equal(1)].material = "Red"
            g.out("Replace mat index 1 by Red")


        gs._out.out()
    ```
    """

    SOCKET_TYPE = 'MATERIAL'


    # ====================================================================================================
    # Class test    
    # ====================================================================================================

    @classmethod
    def _class_test(cls):

        from geonodes import GeoNodes, Material, nd, Mesh, ShaderNodes, Shader, Input, Node

        # ---------------------------------------------------------------------------
        # Building 3 materials
        # ---------------------------------------------------------------------------

        with ShaderNodes("Red"):
            ped = Shader.Principled(base_color='red')
            ped.out()

        with ShaderNodes("Green"):
            ped = Shader.Principled(base_color='#00FF00FF')
            ped.out()

        with ShaderNodes("Blue"):
            ped = Shader.Principled(base_color=(0, 0, 1))
            ped.out()

        # ---------------------------------------------------------------------------
        # Playing with materials
        # ---------------------------------------------------------------------------

        with GeoNodes("Material Test"):

            gs = Node('Menu Switch', menu=Input("Pick Geometry"))

            with gs:            
                g = Mesh.IcoSphere()
                mat0 = Material("Red")
                g.material = mat0
                g.out("Full Red")

            with gs:                
                mat1 = Material("Blue", name="Your Material")
                g[3:10].material = mat1
                g.out("Your material in 3:10")

            with gs:
                g.replace_material(mat0, "Green")
                g.out("Replace Red by Green")

            with gs:
                g.replace_material(mat0, "Green")
                g.out("Replace Red by Green")

            with gs:
                g[nd.material_index.equal(1)].material = "Red"
                g.out("Replace mat index 1 by Red")


            gs._out.out()

_interface_socket property

Return the interface socket if exists

An interface socket exists when the socket a tree input or output socket or when it is the socket of a group

Returns:

Type	Description
Interface Socket

_is_list property

bool property

Returns True if socket is a list

_name property

Return the name or the label

Returns:

Type	Description
str	default is ""

_panel_name property

Return the name of the panel

Returns:

Type	Description
str	default is ""

is_grid property

bool property

Returns True if socket is a grid (inferred_structure_type == 'GRID').

len property

Short cut for 'self.list_length()'

node_color property writable

Node color

Returns:

Type	Description
SysColor

node_label property writable

Node Label

Returns:

Type	Description
str

Constant(value, user_label='') classmethod

Create an input socket from a constant Node.

Parameters:

Name	Type	Description	Default
value	Any	constant default value default=None.	required
user_label	str	socket name (used to rename nodes if not None) default="".	''

Source code in core/socket_class.py

@classmethod
def Constant(cls, value: None, user_label: str = ""):
    """ Create an input socket from a constant Node.

    Parameters
    ----------
    value : Any, optional
        constant default value default=None.

    user_label : str, optional
        socket name (used to rename nodes if not None) default="".
    """

    # ---------------------------------------------------------------------------
    # Ensure array
    # ---------------------------------------------------------------------------

    def get_shaped(v, *shapes):
        r = np.ravel(v)
        shape = np.shape(r)
        if shape in shapes:
            return tuple(r)

        if shape == (1,):
            return tuple(np.resize(r, shapes[0]))

        raise NodeError(
            f"The value <{v}> can't be transformed in a valid initial value for {SocketType.from_type(cls.SOCKET_TYPE).class_name}."
        )

    # ---------------------------------------------------------------------------
    # Does the array contain sockets
    # ---------------------------------------------------------------------------

    def has_sockets(a):
        for v in a:
            if SocketType.get_bsocket(v) is not None:
                return True
        return False

    # ---------------------------------------------------------------------------
    # Default value
    # ---------------------------------------------------------------------------

    socket_type = SocketType.from_type(cls.SOCKET_TYPE)
    if cls.SOCKET_TYPE not in ['RGBA', 'VECTOR', 'ROTATION', 'MATRIX']:
        def_val = socket_type.get_default_from_value(value)

    # ---------------------------------------------------------------------------
    # Depending on the socket type
    # ---------------------------------------------------------------------------

    if cls.SOCKET_TYPE == 'BOOLEAN':
        return Node('Boolean', boolean=def_val)._out._ul(user_label)

    elif cls.SOCKET_TYPE == 'BUNDLE':
        return Node("Combine Bundle")._out._ul(user_label)

    elif cls.SOCKET_TYPE == 'CLOSURE':
        socket = ZoneNode.Closure().closure
        socket._use_layout = False
        return socket._ul(user_label)

    elif cls.SOCKET_TYPE == 'COLLECTION':
        return Node('Collection', collection=def_val)._out._ul(user_label)

    elif cls.SOCKET_TYPE == 'RGBA':

        if value is None:
            a = (0, 0, 0, 1)
        elif isinstance(value, str):
            #a = colors.to_color(value)
            a = SysColor(value).rgba
        else:
            a = get_shaped(value, (4,), (3,))

        if has_sockets(a):
            if Tree.is_geonodes():
                node = Node('Combine Color', {0: a[0], 1: a[1], 2:a[2]})
                if len(a) == 4:
                    node.alpha = a[3]
                return node._out._ul(user_label)
            else:
                return Node('Combine Color', {0: a[0], 1: a[1], 2:a[2]})._out._ul(user_label)

        else:
            def_val = SocketType.from_type('COLOR').get_default_from_value(a)
            if Tree.is_geonodes():
                return Node('Color', value=def_val)._out._ul(user_label)

            else:
                socket = Node('Color')._out
                socket._bsocket.default_value = def_val
                return socket._ul(user_label)

    elif cls.SOCKET_TYPE == 'IMAGE':
        return Node('Image', image=def_val)._out._ul(user_label)

    elif cls.SOCKET_TYPE == 'INT':
        return Node('Integer', integer=def_val)._out._ul(user_label)

    elif cls.SOCKET_TYPE == 'MATERIAL':
        return Node('Material', material=def_val)._out._ul(user_label)

    elif cls.SOCKET_TYPE == 'MATRIX':

        if value is None:
            a = (1, 0, 0, 0,   0, 1, 0, 0,   0, 0, 1, 0,   0, 0, 0, 1)
        else:
            a = get_shaped(value, (16,))

        return Node('Combine Matrix', named_sockets = {i: a[i] for i in range(16)})._out._ul(user_label)

    elif cls.SOCKET_TYPE == 'MENU':
        if True: # V5.2
            from .generated.static_nd import ND
            return ND.menu(value)
            #return Node('Menu', value=value)._out._ul(user_label)
        else:
            return Node('Menu Switch')._out._ul(user_label)

    elif cls.SOCKET_TYPE == 'OBJECT':
        return Node('Object', object=def_val)._out._ul(user_label)

    elif cls.SOCKET_TYPE == 'FONT':
        if True: # V5.2
            return Node('Font', font=def_val)._out._ul(user_label)
        else:
            return cls.NewInput("Font", value)

    elif cls.SOCKET_TYPE == 'ROTATION':

        if value is None:
            a = (0, 0, 0)
        else:
            a = get_shaped(value, (3,))

        if has_sockets(a):
            return Node('Combine XYZ', x=a[0], y=a[1], z=a[2])._out.to_rotation()._ul(user_label)
        else:
            return Node('Rotation', rotation_euler=a)._out._ul(user_label)

    elif cls.SOCKET_TYPE == 'STRING':
        return Node('String', string=def_val)._out._ul(user_label)

    elif cls.SOCKET_TYPE == 'VALUE':
        node = Node('Value')
        node._bnode.outputs[0].default_value = def_val
        return node._out._ul(user_label)

    elif cls.SOCKET_TYPE == 'VECTOR':

        if value is None:
            a = (0, 0, 0)
        else:
            a = get_shaped(value, (3,))

        if has_sockets(a):
            return Node('Combine XYZ', x=a[0], y=a[1], z=a[2])._out._ul(user_label)
        else:
            return Node('Vector', vector=a)._out._ul(user_label)

    elif cls.SOCKET_TYPE == 'GEOMETRY':
        raise NodeError(f"There is no node to create a Geometry. Use explicit constructors such as 'Mesh.Cube()', 'Curve.Spiral()' or 'Cloud.Points().")

    else:
        assert False, f"Shouldn't happen {socket_type}"

Empty(value=None) classmethod

Create an empty socket.

An empty socket is used temporarily as an input for nodes with dynamic sockets:

Parameters:

Name	Type	Description	Default
value	Any	default value default=None.	None

Source code in core/socket_class.py

@classmethod
def Empty(cls, value = None):
    """ Create an empty socket.

    An empty socket is used temporarily as an input for nodes with dynamic sockets:

    Parameters
    ----------
    value : Any, optional
        default value default=None.

    """
    socket = cls(constants.EMPTY_SOCKET)
    socket._bsocket = SocketType.from_type(cls.SOCKET_TYPE).get_default_from_value(value)
    return socket

IndexSwitch(*values, index=None, default_index=0) classmethod

Node Index Switch

with GeoNodes("IndexSwitch demo"):

    # Create some geometries
    geo    = Geometry()
    cube   = Mesh.Cube()
    sphere = Mesh.IcoSphere()
    cone   = Mesh.Cone()

    # Pick in this list
    pick_geo = Geometry.IndexSwitch(geo, cube, sphere, cone, index=tree.new_input("Geometry index", default_value=2))

    # Plug the result to the output
    pick_geo.out()

Parameters:

Name	Type	Description	Default
*values	Any	List of Sockets to select into	()
index	Integer	socket 'Index' (Index) default=None.	None
default_index	int	default idex default=0.	0

Returns:

Type	Description
Socket

Source code in core/socket_class.py

@classmethod
def IndexSwitch(cls, *values, index = None, default_index: int = 0):
    """ > Node Index Switch

    ``` python
    with GeoNodes("IndexSwitch demo"):

        # Create some geometries
        geo    = Geometry()
        cube   = Mesh.Cube()
        sphere = Mesh.IcoSphere()
        cone   = Mesh.Cone()

        # Pick in this list
        pick_geo = Geometry.IndexSwitch(geo, cube, sphere, cone, index=tree.new_input("Geometry index", default_value=2))

        # Plug the result to the output
        pick_geo.out()
    ```

    Parameters
    ----------
    *values : Any
        List of Sockets to select into

    index : Integer, optional
        socket 'Index' (Index) default=None.

    default_index : int, optional
        default idex default=0.


    Returns
    -------
    Socket
    """
    node = Node('Index Switch', 
                    {str(i): value for i, value in enumerate(values)}, 
                    data_type=cls.SOCKET_TYPE, 
                    Index=index)
    return cls(node._out)

Input(name, panel='', halt=True) classmethod

Get an exist input socket from its name and panel.

Note

The "input" socket here is an "output" socket of the current input node

To create a input socket use NewInput.

If the 'name' argument is None, the first socket of the proper type is returned.

Raises:

Type	Description
- NodeError if socket is not found and halt is requested

Parameters:

Name	Type	Description	Default
name	str | None	socket name	required
panel	str	panel name default="".	''
halt	bool	raises an error if not found default=True.	True

Returns:

Type	Description
Socket

Source code in core/socket_class.py

@classmethod
def Input(cls, name: str, panel: str = "", halt: bool = True):
    """ Get an exist input socket from its name and panel.

    !!! note
        The "input" socket here is an "output" socket of the current input node

    To create a input socket use NewInput.

    If the 'name' argument is None, the first socket of the proper type is returned.

    Raises
    ------
    - NodeError if socket is not found and halt is requested

    Parameters
    ----------
    name : str | None
        socket name

    panel : str, optional
        panel name default="".

    halt : bool, optional
        raises an error if not found default=True.


    Returns
    -------
    Socket
    """
    in_node = Tree.current_tree().get_input_node()

    include = None if name is None else [name]
    bsockets = in_node.get_sockets('OUTPUT', include=include, panel=panel)

    for _, bsock in bsockets:
        if SocketType(bsock).type == cls.SOCKET_TYPE: # and utils.snake_case(sock_name) == utils.snake_case(name):
            return cls(bsock._bsocket)._ul(name)

    if halt:
        sname = "" if name is None else f" named '{name}'"
        raise NodeError(
            f"There is no {SocketType.from_type(cls.SOCKET_TYPE).class_name} input socket{sname}.\n"
            f"Available sockets are : {[bsock[0] for bsock in in_node.get_sockets('OUTPUT')]}.")

    return None

List(*items, name='') classmethod

Create a Blender List from items.

Parameters:

Name	Type	Description	Default
items	Any	Items to put in the list.	()
name	str	socket name default="".	''

Returns:

Type	Description
- Socket List

Source code in core/socket_class.py

@classmethod
def List(cls, *items, name: str = ""):
    """ Create a Blender List from items.

    Parameters
    ----------
    items : Any, optional
        Items to put in the list.

    name : str, optional
        socket name  default="".

    Returns
    -------
    - Socket List
    """

    from .sock_closure import Closure
    from .sock_integer import Integer

    with Closure() as cl:

        idx = Integer(0, "Index")

        if True:
            value = cls.IndexSwitch(*items, index=idx)
        else:
            with cls.IndexSwitch(index=idx) as value:
                for item in items:
                    cls(item).out()

        if name == "":
            name = cls.__name__
        value.out(name)

    return cls(cl.to_list(count=len(items)))

MenuSwitch(named_sockets={}, default_menu=None, **sockets) classmethod

Node Menu Switch

The items of the Menu Switch node are provided in the 'items' dict.

Parameters:

Name	Type	Description	Default
named_sockets	dict	sockets to create default={}.	{}
default_menu	str	default menu value default=None.	None
sockets	dict	items	{}

Returns:

Type	Description
Socket

Source code in core/socket_class.py

@classmethod
def MenuSwitch(cls, 
               named_sockets    : dict = {},
               default_menu     : str = None,
               **sockets):
    """ > Node Menu Switch

    The items of the Menu Switch node are provided in the 'items' dict.

    Parameters
    ----------
    named_sockets : dict, optional
        sockets to create default={}.

    default_menu : str, optional
        default menu value default=None.

    sockets : dict
        items


    Returns
    -------
    Socket
    """
    node = Node('Menu Switch',
            named_sockets = named_sockets,
            data_type = SocketType.from_type(cls.SOCKET_TYPE).type,
            #default_menu = default_menu,
            **sockets)
    node._default_menu = default_menu

    return cls(node._out)

Named(name) classmethod

Node Named Attribute

Information

• Parameter 'data_type' : 'BOOLEAN'

Parameters:

Name	Type	Description	Default
name	String	socket 'Name' (id: Name)	required

Returns:

Type	Description
Boolean

Source code in core/socket_class.py

@classmethod
def Named(cls, name):
    """ > Node Named Attribute

    Information
    -----------
    - Parameter 'data_type' : 'BOOLEAN'

    Parameters
    ----------
    name : String
        socket 'Name' (id: Name)


    Returns
    -------
    Boolean
    """
    if SocketType.from_type(cls.SOCKET_TYPE).class_name not in constants.ATTRIBUTE_CLASSES:
        raise NodeError(
            f"The class {SocketType.from_type(cls.SOCKET_TYPE).class_name} is not an attribute.\n"
            f"Attribute classes are: {constants.ATTRIBUTE_CLASSES}")

    node = Node('Named Attribute', name=name)
    data_type = SocketType.from_type(cls.SOCKET_TYPE).get_node_data_type(
        tree_type = node._tree._btree.bl_idname,
        bl_idname = node._bnode.bl_idname,
        halt = True)

    node.set_parameter('data_type', data_type)

    return node._out._ul(name)

NewInput(name, value=None, tip='', panel='', **props) classmethod

Create an new input socket

Note

The "input" socket here is an "output" socket of the current input node

To get an existing input socket use Input.

Raises:

Type	Description
- NodeError if socket is not found

Parameters:

Name	Type	Description	Default
name	str	socket name	required
value	Any	default_value default=None.	None
tip	str	description default="".	''
panel	str: None	panel name	''

Returns:

Type	Description
Socket

Source code in core/socket_class.py

@classmethod
def NewInput(cls,
        name: str, 
        value       = None, 
        tip: str    = "", 
        panel: str  = "", 
        **props):
    """ Create an new input socket

    !!! note
        The "input" socket here is an "output" socket of the current input node

    To get an existing input socket use Input.

    Raises
    ------
    - NodeError if socket is not found

    Parameters
    ----------
    name : str
        socket name

    value : Any, optional
        default_value default=None.

    tip : str, optional
        description default="".

    panel : str: None
        panel name


    Returns
    -------
    Socket
    """
    if value is None:
        defval = None
    else:
        defval = SocketType.from_type(cls.SOCKET_TYPE).get_default_from_value(value)
        new_props = {**props}

        if 'default' in new_props:
            new_props['default'] = defval

        elif 'default_value' in new_props:
            new_props['default_value'] = defval

        else:
            if 'default' not in constants.SOCKETS[cls.SOCKET_TYPE]['props']:
                raise NodeError(f"The {SocketType.from_type(cls.SOCKET_TYPE).class_name} socket doesn't accept a default value. Value argument <{value}> is invalid.")

            new_props['default_value'] = defval

        props = new_props

    return cls(Tree.current_tree().create_input_socket(
        SocketType.from_type(cls.SOCKET_TYPE).socket_id,
        name         = name,
        tip          = tip,
        panel        = panel,
        **props))

Out(value, name=None, panel='', **props) classmethod

Send a value to the current group or zone output.

Constants are assigned directly to the output node's input, without creating a constant node. Socket.Out infers the type; subclasses such as Float.Out explicitly select the output type.

Socket.Out(3.14, "Pi")
Float.Out(1, "Factor")
Socket.Out(value, "Result")

Parameters:

Name	Type	Description	Default
value	Any	Constant or socket to output.	required
name	str	Output socket name.	None
panel	str	Output panel.	''
**props		Properties used when creating the output socket.	{}

Returns:

Type	Description
None

Source code in core/socket_class.py

@classmethod
def Out(cls, value, name: str = None, panel: str = "", **props):
    """Send a value to the current group or zone output.

    Constants are assigned directly to the output node's input, without
    creating a constant node. Socket.Out infers the type; subclasses such
    as Float.Out explicitly select the output type.

    ``` python
    Socket.Out(3.14, "Pi")
    Float.Out(1, "Factor")
    Socket.Out(value, "Result")
    ```

    Parameters
    ----------
    value : Any
        Constant or socket to output.
    name : str, optional
        Output socket name.
    panel : str, optional
        Output panel.
    **props
        Properties used when creating the output socket.

    Returns
    -------
    None
    """
    tree = Tree.current_tree()
    if tree is None:
        raise NodeError("Socket.Out requires an active tree.")

    if isinstance(value, Socket):
        value._is_empty(f"Impossible to link an empty socket (name: '{name}').")

    out_node = tree.get_output_node()
    if cls.SOCKET_TYPE is None:
        if name is None and utils.get_bsocket(value) is None:
            name = SocketType(value).class_name
        out_node.set_input_socket(name=name, value=value, create=True, panel=panel, **props)
        return

    socket_type = SocketType.from_type(cls.SOCKET_TYPE)
    full_name = None if name is None else (ItemPath(panel) + name).path
    socket = out_node.get_socket('INPUT', full_name, socket_type,
                                 free_only=True, halt=False)
    if socket is None:
        if name is None:
            name = socket_type.class_name
        socket = out_node.create_socket('INPUT', socket_type, name=name, panel=panel, **props)
    out_node.set_input_socket_value(socket, value)

Switch(condition=None, false=None, true=None) classmethod

Node Switch

with GeoNodes("Switch demo"):

    # Two possible geometries
    cube   = Mesh.Cube()
    sphere = Mesh.IcoSphere()

    # Select
    geo = Geometry.Switch(Boolean(True, "Use Sphere"), cube, sphere)

    # To group output
    geo.out()

Parameters:

Name	Type	Description	Default
condition	Boolean	socket 'Switch' (Switch)	None
false		socket 'False' (False)	None
true		socket 'True' (True)	None

Returns:

Type	Description
Socket	Socket wrapped in the calling class (for example, Mesh.Switch returns Mesh).

Source code in core/socket_class.py

@classmethod
def Switch(cls, condition=None, false=None, true=None):
    """ > Node Switch

    ``` python
    with GeoNodes("Switch demo"):

        # Two possible geometries
        cube   = Mesh.Cube()
        sphere = Mesh.IcoSphere()

        # Select
        geo = Geometry.Switch(Boolean(True, "Use Sphere"), cube, sphere)

        # To group output
        geo.out()
    ```

    Parameters
    ----------
    condition : Boolean
        socket 'Switch' (Switch)

    false
        socket 'False' (False)

    true
        socket 'True' (True)


    Returns
    -------
    Socket
        Socket wrapped in the calling class (for example, Mesh.Switch returns Mesh).
    """
    input_type = SocketType.from_type(cls.SOCKET_TYPE).items_type
    node = Node('Switch', {'Switch': condition, 'False': false, 'True': true}, input_type=input_type)
    return cls(node._out)

__init__(socket=None, name=None, tip='', panel='', user_label=None, **props)

Parameters:

Name	Type	Description	Default
socket	NodeSocket	the output socket to wrap default=None.	None
name	str	input name if not None default=None.	None
tip	str	description default="".	''
panel	str	panel name default="".	''
user_label	str	user label default=None.	None

Source code in core/socket_class.py

def __init__(self, 
        socket  = None, 
        name         : str = None, 
        tip          : str = "",
        panel        : str = "",
        user_label   : str = None,
        **props):
    """

    Parameters
    ----------
    socket : NodeSocket, optional
        the output socket to wrap default=None.

    name : str, optional
        input name if not None default=None.

    tip : str, optional
        description default="".

    panel : str, optional
        panel name default="".

    user_label : str, optional
        user label default=None.

    """

    # ---------------------------------------------------------------------------
    # Attributes
    # ---------------------------------------------------------------------------

    self._layout      = None
    self._use_layout  = True
    self._tree        = Tree.current_tree()
    if self._tree is not None and not self._tree._rebuild:
        raise Break()
    self._bsocket     = None

    self._reset()

    # ---------------------------------------------------------------------------
    # Socket is a Node
    # ---------------------------------------------------------------------------

    if isinstance(socket, Node):
        socket = socket._out

    # ---------------------------------------------------------------------------
    # Empty socket
    # ---------------------------------------------------------------------------

    if utils.request_empty(socket):
        return

    # ---------------------------------------------------------------------------
    # Socket is a string or a String socket
    # ---------------------------------------------------------------------------

    socktype = self._socket_type
    cname = socktype.class_name

    if socktype.is_attribute:
        # Literal color names remain constants; String sockets name attributes.
        if ((isinstance(socket, str) and cname != 'Color') or
                (isinstance(socket, Socket) and socket.SOCKET_TYPE == 'STRING')):
            self._bsocket = self.Named(socket)._bsocket
            return

    # ---------------------------------------------------------------------------
    # Let's get the socket
    # ---------------------------------------------------------------------------

    self._bsocket = utils.get_bsocket(socket)
    if self._bsocket is not None:

        if self._bsocket.type != self.SOCKET_TYPE:

            # "Bundle Get Item" like nodes : we change the data_type
            node = self.node

            blid = node._bnode.bl_idname
            if blid == 'NodeGetBundleItem'and self.SOCKET_TYPE in utils.get_node_param_enum(blid, 'socket_type'):
                node._bnode.socket_type = self.SOCKET_TYPE
                self._bsocket = utils.get_enabled_bsocket(node, 'Item')

        return

    # ---------------------------------------------------------------------------
    # No name: we create from a constant Node
    # The socket argument is the value to set
    # ---------------------------------------------------------------------------

    if name is None:
        if socktype == 'GEOMETRY':
            new_socket = self.Input(None, halt=False)
            if new_socket is None:
                new_socket = self.NewInput(type(self).__name__)
            self._bsocket = new_socket._bsocket
        else:
            self._bsocket = self.Constant(socket, user_label=user_label)._bsocket

    # ---------------------------------------------------------------------------
    # With a name, we request the creation from current input
    # ---------------------------------------------------------------------------

    else:
        # Font : make sure it is a font 
        if self.SOCKET_TYPE == 'FONT':
            socket = blender.get_font(socket)

        # Socket can be the default value
        if socket is not None:

            if 'default' not in constants.SOCKETS[self._socket_type.type]['props']:
                raise NodeError(f"The {self._socket_type()} socket doesn't accept default value. <{socket}> is not valid.")

            # Perhaps it is given in the props
            def_key = 'default' if 'default' in props else None
            if def_key is None:
                def_key = 'default_value' if 'default_value' in props else None

            if def_key is None:
                props = {'value': socket, **props}

        new_socket = self.NewInput(name, tip=tip, panel=panel, **props)
        self._bsocket = new_socket._bsocket
        self._use_layout = new_socket._use_layout

_create_input_socket(value=None, name='Material', tip='', panel='', optional_label=False, hide_value=False, hide_in_modifier=False) classmethod

Material Input

New Material input with subtype 'NONE'.

Parameters:

Name	Type	Description	Default
value	object	Default value	`None`
name	str	Input socket name	`Material`
tip	str	Property description	`''`
panel	str	Panel name	``
optional_label	bool	Property optional_label	`False`
hide_value	bool	Property hide_value	`False`
hide_in_modifier	bool	Property hide_in_modifier	`False`

Returns:

Type	Description
Material

Source code in core/generated/material.py

@classmethod
def _create_input_socket(cls,
    value: object = None,
    name: str = 'Material',
    tip: str = '',
    panel: str = "",
    optional_label: bool = False,
    hide_value: bool = False,
    hide_in_modifier: bool = False,
     ):
    """ > Material Input

    New Material input with subtype 'NONE'.

    Parameters
    ----------
    value : object, default=`None`
        Default value

    name : str, default=`Material`
        Input socket name

    tip : str, default=`''`
        Property description

    panel : str, default=``
        Panel name

    optional_label : bool, default=`False`
        Property optional_label

    hide_value : bool, default=`False`
        Property hide_value

    hide_in_modifier : bool, default=`False`
        Property hide_in_modifier


    Returns
    -------
    Material
    """
    from ..treeclass import Tree

    defval = utils.python_value_for_socket(value, cls.SOCKET_TYPE)

    return Tree.current_tree().create_input_socket('NodeSocketMaterial', default_value = defval,
        name=name, tip=tip, panel=panel, optional_label=optional_label, hide_value=hide_value,
        hide_in_modifier=hide_in_modifier)

_get_bsocket_from_input(name=None)

Get the availble input socket if any.

The socket is get a an OUTPUT socket of the current input.

Parameters:

Name	Type	Description	Default
name	str	name filter default=None.	None

Returns:

Type	Description
Socket	or None if not found

Source code in core/socket_class.py

def _get_bsocket_from_input(self, name: str = None) -> bpy.types.NodeSocket:
    """ Get the availble input socket if any.

    The socket is get a an OUTPUT socket of the current input.

    Parameters
    ----------
    name : str, optional
        name filter default=None.


    Returns
    -------
    Socket
        or None if not found

    """
    in_node = self._tree.get_input_node()

    include = None if name is None else [name]

    bsockets = in_node.get_sockets('OUTPUT', include=include)
    for _, bsock in bsockets:
        if SocketType(bsock).type == self.SOCKET_TYPE:
            return bsock._bsocket
    else:
        return None

_jump(socket, reset=True)

Change the wrapped output socket

When changing the socket, the description is copied to the new socket. The node color, if any, is also propagated.

Parameters:

Name	Type	Description	Default
socket	NodeSocket	the new output socket to jump to	required
reset	bool	reset the cache default=True.	True

Returns:

Type	Description
self

Source code in core/socket_class.py

def _jump(self, socket: bpy.types.NodeSocket, reset: bool = True):
    """ Change the wrapped output socket

    When changing the socket, the description is copied to the new socket.
    The node color, if any, is also propagated.

    Parameters
    ----------
    socket : bpy.types.NodeSocket
        the new output socket to jump to

    reset : bool, optional
        reset the cache default=True.


    Returns
    -------
    self
    """

    # Keep user label stored in socket description
    user_label = self.user_label

    bsocket = utils.get_bsocket(socket)
    if bsocket is None:
        raise NodeError(f"Socket error: Impossible to jump to socket {socket}")

    self._bsocket = bsocket
    if reset:
        self._reset()

    # Restore user label
    self.user_label = user_label

    return self

_lc(label=None, color=None)

Set node label and color.

This method returns self to be chained to as socket:

with GeoNodes("Node label and color"):
    Geometry().out()

    a = Float(10)._lc("Var a")
    b = Float(10)._lc("Var b")
    c = (a + b)._lc("a + b", (1, 0, 0))

Parameters:

Name	Type	Description	Default
label	str	node label default=None.	None
color	SysColor	node color default=None.	None

Returns:

Type	Description
self

Source code in core/socket_class.py

def _lc(self, label: str = None, color: SysColor = None):
    """ Set node label and color.

    This method returns self to be chained to as socket:

    ``` python
    with GeoNodes("Node label and color"):
        Geometry().out()

        a = Float(10)._lc("Var a")
        b = Float(10)._lc("Var b")
        c = (a + b)._lc("a + b", (1, 0, 0))
    ```

    Parameters
    ----------
    label : str, optional
        node label default=None.

    color : SysColor, optional
        node color default=None.


    Returns
    -------
    self
    """

    if self.node._bnode.bl_idname == 'NodeGroupInput':
        return self

    self.node_label = label
    self.node_color = color
    self.user_label = label

    return self

_ul(label)

Set the user label

Parameters:

Name	Type	Description	Default
label	str	the label to append	required

Returns:

Type	Description
self

Source code in core/socket_class.py

def _ul(self, label : str):
    """ Set the user label

    Parameters
    ----------
    label : str
        the label to append


    Returns
    -------
    self
    """
    self.user_label = label
    return self

add_method(name=None, jump=False, ret_class=None, **fixed)

Add the current tree as a method of the Socket class.

Important

The socket instance must be an input socket of the Tree. This input plays the role of self argument.

with GeoNodes("Translate"):
    geo = Geometry()
    v = Vector(0, "Translation)
    geo.transform(translation=v)

    geo.add_method(jump=True)

Once the modifier completed, it can be called as a method of geometry geo.translate(translation=(1, 2, 3))

Parameters:

Name	Type	Description	Default
name	str	replace the default name which is the snake case version of the group name default=None.	None
ret_class	type	transtype the default node output default=None.	None
jump	bool	the calling socket jumps to the node outpus after the call default=False.	False
ret_class	type	transtype the result with this class if not None default=None.	None

Source code in core/socket_class.py

def add_method(self, name: str = None, jump: bool = False, ret_class: type = None, **fixed):
    """ Add the current tree as a method of the Socket class.

    !!! important

        The socket instance must be an input socket of the Tree. This input plays the role of
        self argument.

    ``` python
    with GeoNodes("Translate"):
        geo = Geometry()
        v = Vector(0, "Translation)
        geo.transform(translation=v)

        geo.add_method(jump=True)
    ```

    Once the modifier completed, it can be called as a method of geometry ```geo.translate(translation=(1, 2, 3))```

    Parameters
    ----------
    name : str, optional
        replace the default name which is the snake case version of the group name default=None.

    ret_class : type, optional
        transtype the default node output default=None.

    jump : bool, optional
        the calling socket jumps to the node outpus after the call default=False.

    ret_class : type, optional
        transtype the result with this class if not None default=None.

    """

    if self.node._bnode.bl_idname != 'NodeGroupInput':
        raise NodeError(
            f"'add_method' can be called only from a 'Group Input' socket. "
            "This socket is used a 'self' argument when calling the method of {type(self).__name__}.")

    tree = Tree.current_tree()

    # ---------------------------------------------------------------------------
    # Method Body
    # ---------------------------------------------------------------------------

    socket_rank = self.node._outputs.get_socket_rank(self)
    socket_name = utils.snake_case(self._bsocket.name)


    def call(self_, *args, **kwargs):
        node = Group(tree._btree.name)
        if socket_rank >= len(args):
            new_args = args
            new_kwargs = {socket_name: self_, **kwargs}
        else:
            new_args = args[:socket_rank] + (self_,) + args[socket_rank:]
            new_kwargs = kwargs

        res = node.method_call(*new_args, ret_class=ret_class, **new_kwargs, **fixed)

        if jump:
            return self_._jump(res)
        else:
            return res

    # ---------------------------------------------------------------------------
    # Add the method to the class
    # ---------------------------------------------------------------------------

    if name is None:
        name = tree._btree.name[len(tree._prefix):].strip()
        name = utils.snake_case(name)

    class_ = type(self)
    if name in dir(class_):
        print(f"CAUTION: the method '{name}' (implementing group '{tree._btree.name}') already exists in class {class_}.")

    setattr(class_, name, call)

enable_output(enable=None)

Node Enable Output

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	data_type	'MATERIAL'

Parameters:

Name	Type	Description	Default
enable	Boolean	socket 'Enable' (id: Enable)	None

Returns:

Type	Description
Material

Source code in core/generated/material.py

def enable_output(self, enable: Boolean = None):
    """ > Node Enable Output

    **Fixed values**

    | Kind      | Name        | Value        |
    | --------- | ----------- | ------------ |
    | Socket    | Value       | `self`       |
    | Parameter | `data_type` | `'MATERIAL'` |

    Parameters
    ----------
    enable : Boolean, optional
        socket 'Enable' (id: Enable)


    Returns
    -------
    Material
    """
    node = Node('Enable Output', {'Enable': enable, 'Value': self}, data_type='MATERIAL')
    return node._out

field_to_list(count, **values)

Node Field to List

Create a list from this field and named lists from additional fields.

Parameters:

Name	Type	Description	Default
count	Integer	Number of items in each generated list.	required
values	dict	Named fields to evaluate. Each field creates an output socket with the same name.	{}

Returns:

Type	Description
Socket	First list output. The other outputs are available from its node or as peer sockets.

Source code in core/socket_class.py

def field_to_list(self, count, **values):
    """ > Node Field to List

    Create a list from this field and named lists from additional fields.

    Parameters
    ----------
    count : Integer
        Number of items in each generated list.

    values : dict
        Named fields to evaluate. Each field creates an output socket with
        the same name.

    Returns
    -------
    Socket
        First list output. The other outputs are available from its node
        or as peer sockets.
    """
    return Node(
        'Field to List',
        named_sockets={self._name: self},
        count=count,
        **values,
    )._out

filter_list(selection=None)

Node Filter List

Fixed values

Kind	Name	Value
Socket	List	self
Parameter	socket_type	'MATERIAL'

Parameters:

Name	Type	Description	Default
selection	Boolean	socket 'Selection' (id: Selection)	None

Returns:

Type	Description
Material	peer sockets: inverted_ (Material)

Source code in core/generated/material.py

def filter_list(self, selection: Boolean = None):
    """ > Node Filter List

    **Fixed values**

    | Kind      | Name          | Value        |
    | --------- | ------------- | ------------ |
    | Socket    | List          | `self`       |
    | Parameter | `socket_type` | `'MATERIAL'` |

    Parameters
    ----------
    selection : Boolean, optional
        socket 'Selection' (id: Selection)


    Returns
    -------
    Material
        peer sockets: inverted_ (Material)

    """
    node = Node('Filter List', {'List': self, 'Selection': selection}, socket_type='MATERIAL')
    return node._out

flatten_list()

Flatten one level of a rectangular nested list.

Every nested list must have the same length. This is notably the case for lists created by :meth:reshape_list. Items keep their original linear order.

values = Float.List(*range(16))
values.reshape_list((4, 4))
values.flatten_list()

Returns:

Type	Description
Socket	This socket, updated to point to the flattened list.

Raises:

Type	Description
NodeError	If this socket does not contain a list.

Source code in core/socket_class.py

def flatten_list(self):
    """Flatten one level of a rectangular nested list.

    Every nested list must have the same length. This is notably the case
    for lists created by :meth:`reshape_list`. Items keep their original
    linear order.

    ``` python
    values = Float.List(*range(16))
    values.reshape_list((4, 4))
    values.flatten_list()
    ```

    Returns
    -------
    Socket
        This socket, updated to point to the flattened list.

    Raises
    ------
    NodeError
        If this socket does not contain a list.
    """

    if not self._is_list:
        raise NodeError(f"Socket.flatten_list error: {self} is not a list.")

    from .sock_closure import Closure
    from .sock_integer import Integer

    with Layout("Socket.flatten_list"):

        source = self
        outer_length = source.list_length()
        inner_length = source[0].list_length()

        with Closure() as cl:
            index = Integer(0, "Index")

            outer_index = index // inner_length
            inner_index = index % inner_length

            source[outer_index][inner_index].out(self._name)

        self._jump(cl.to_list(outer_length * inner_length))
        return self

get_list_item(index=None, structure_type='AUTO')

Node Get List Item

Fixed values

Kind	Name	Value
Socket	List	self
Parameter	socket_type	'MATERIAL'

Parameters:

Name	Type	Description	Default
index	Integer	socket 'Index' (id: Index)	None
structure_type	Literal['Auto', 'Dynamic', 'Field', 'Grid', 'List', 'Single']	parameter structure_type	'AUTO'

Returns:

Type	Description
Material

Source code in core/generated/material.py

def get_list_item(self,
                index: Integer = None,
                structure_type: Literal['AUTO', 'DYNAMIC', 'FIELD', 'GRID', 'LIST', 'SINGLE'] = 'AUTO'):
    """ > Node Get List Item

    **Fixed values**

    | Kind      | Name          | Value        |
    | --------- | ------------- | ------------ |
    | Socket    | List          | `self`       |
    | Parameter | `socket_type` | `'MATERIAL'` |

    Parameters
    ----------
    index : Integer, optional
        socket 'Index' (id: Index)

    structure_type : Literal['Auto', 'Dynamic', 'Field', 'Grid', 'List', 'Single']
        parameter `structure_type`


    Returns
    -------
    Material
    """
    utils.check_enum_arg('Get List Item', 'structure_type', structure_type, 'get_list_item', ('AUTO', 'DYNAMIC', 'FIELD', 'GRID', 'LIST', 'SINGLE'))
    node = Node('Get List Item', {'List': self, 'Index': index}, socket_type='MATERIAL', structure_type=structure_type)
    return node._out

implicit_conversion(socket_idname='NodeSocketColor')

Node Implicit Conversion

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	data_type	'MATERIAL'

Parameters:

Name	Type	Description	Default
socket_idname	str	parameter socket_idname	'NodeSocketColor'

Returns:

Type	Description
Material

Source code in core/generated/material.py

def implicit_conversion(self, socket_idname = 'NodeSocketColor'):
    """ > Node Implicit Conversion

    **Fixed values**

    | Kind      | Name        | Value        |
    | --------- | ----------- | ------------ |
    | Socket    | Value       | `self`       |
    | Parameter | `data_type` | `'MATERIAL'` |

    Parameters
    ----------
    socket_idname : str
        parameter `socket_idname`


    Returns
    -------
    Material
    """
    node = Node('Implicit Conversion', {'Value': self}, data_type='MATERIAL', socket_idname=socket_idname)
    return node._out

index_switch(*values, index=None, default_index=0)

Node Index Switch

with GeoNodes("index_switch demo") as tree:

    # Create some geometries
    geo    = Geometry()
    cube   = Mesh.Cube()
    sphere = Mesh.IcoSphere()
    cone   = Mesh.Cone()

    # Pick in this list
    pick_geo = geo.index_switch(cube, sphere, cone, index=tree.new_input("Geometry index", default_value=2))

    # Plug the result to the output
    pick_geo.out()

Parameters:

Name	Type	Description	Default
*values	Any	List of Sockets to select into	()
index	Integer	socket 'Index' (Index)	None
default_index	int	default idex	0

Returns:

Type	Description
Socket

Source code in core/socket_class.py

def index_switch(self, *values, index = None, default_index: int = 0):
    """ > Node Index Switch

    ``` python
    with GeoNodes("index_switch demo") as tree:

        # Create some geometries
        geo    = Geometry()
        cube   = Mesh.Cube()
        sphere = Mesh.IcoSphere()
        cone   = Mesh.Cone()

        # Pick in this list
        pick_geo = geo.index_switch(cube, sphere, cone, index=tree.new_input("Geometry index", default_value=2))

        # Plug the result to the output
        pick_geo.out()
    ```

    Parameters
    ----------
    *values : Any
        List of Sockets to select into

    index : Integer, optional
        socket 'Index' (Index)

    default_index : int, default=0
        default idex

    Returns
    -------
    Socket
    """
    return self.IndexSwitch(self, *values, index=index, default_index=default_index)

link_inputs(from_node=None, from_panel='', *, include=None, exclude=[], panel='')

Link input sockets of the node

Allow to chain input sockets linking.

Source code in core/socket_class.py

def link_inputs(self,
    from_node   : Node = None,
    from_panel  : str = "",
    *,
    include     : list =  None,
    exclude     : list  = [],
    panel       : str = "",
    ):
    """ Link input sockets of the node

    Allow to chain input sockets linking.
    """
    self.node.link_inputs(from_node, from_panel=from_panel, include=include, exclude=exclude, panel=panel)
    return self

link_panel(panel, from_node=None)

Link panel input sockets of the node

Allow to chain input sockets linking.

Source code in core/socket_class.py

def link_panel(self, panel: str, from_node : Node = None):
    """ Link panel input sockets of the node

    Allow to chain input sockets linking.
    """
    self.node.link_panel(panel, from_node=from_node)
    return self

list_append(value)

Append a value or another list to this list.

If value is a list socket, all its items are appended. Otherwise, value is converted to the socket type and appended as one item. The socket is updated in place to point to the resulting list.

values = Float.List(1, 2, 3)
values.list_append(4)

other = Float.List(5, 6)
values.list_append(other)

Parameters:

Name	Type	Description	Default
value	Any | Socket	Single value or list socket to append.	required

Returns:

Type	Description
Socket	This socket, updated to point to the concatenated list.

Raises:

Type	Description
NodeError	If this socket does not contain a list.

Source code in core/socket_class.py

def list_append(self, value):
    """Append a value or another list to this list.

    If ``value`` is a list socket, all its items are appended. Otherwise,
    ``value`` is converted to the socket type and appended as one item.
    The socket is updated in place to point to the resulting list.

    ``` python
    values = Float.List(1, 2, 3)
    values.list_append(4)

    other = Float.List(5, 6)
    values.list_append(other)
    ```

    Parameters
    ----------
    value : Any | Socket
        Single value or list socket to append.

    Returns
    -------
    Socket
        This socket, updated to point to the concatenated list.

    Raises
    ------
    NodeError
        If this socket does not contain a list.
    """

    from .sock_closure import Closure
    from .sock_integer import Integer

    if not self._is_list:
        raise NodeError(f"Socket.list_append error: {self} is not a list.")

    with Layout("Socket.list_append"):

        # Turn the appended value into a closure indexed from zero.
        in_cl = None
        if isinstance(value, Socket) and value._is_list:
            n = value.list_length()
            with Closure() as cl:
                index = Integer(0, "Index")
                value[index].out("Value")
            in_cl = cl
        else:
            n = 1
            with Closure() as cl:
                index = Integer(0, "Index")
                type(self)(value).out("Value")
                index.out() # To avoid warning
            in_cl = cl

        cur_length = self.list_length()

        # Keep the current items first, then evaluate the appended value.
        with Closure() as cl:
            index = Integer(0, "Index")

            v = type(self).Switch(index.less_than(cur_length), 
                    in_cl.evaluate(index=index-cur_length).value,
                    self[index]
                    )
            v.out(self._name)

        # Replace the wrapped socket while preserving its Python identity.
        return self._jump(cl.to_list(cur_length + n))

list_length()

Node List Length

Fixed values

Kind	Name	Value
Socket	List	self
Parameter	data_type	'MATERIAL'

Returns:

Type	Description
Integer

Source code in core/generated/material.py

def list_length(self):
    """ > Node List Length

    **Fixed values**

    | Kind      | Name        | Value        |
    | --------- | ----------- | ------------ |
    | Socket    | List        | `self`       |
    | Parameter | `data_type` | `'MATERIAL'` |

    Returns
    -------
    Integer
    """
    node = Node('List Length', {'List': self}, data_type='MATERIAL')
    return node._out

menu_switch(self_name='Self', named_sockets={}, default_menu=None, **sockets)

Node Menu Switch

[&NO_JUMP]

Self is connected to the first menu item with the name provided as argument.

The items of the Menu Switch node are provided in the 'items' dict. An group input socket named after the 'name' argument is linked to menu selector.

Parameters:

Name	Type	Description	Default
named_sockets	dict	sockets to create default={}.	{}
default_menu	str	default menu value default=None.	None
sockets	dict	items	{}

Returns:

Type	Description
Socket

Source code in core/socket_class.py

def menu_switch(self,
            self_name       : str = 'Self', 
            named_sockets   : dict = {},
            default_menu    : str = None,
            **sockets):
    """ > Node Menu Switch

    [&NO_JUMP]

    Self is connected to the first menu item with the name provided as argument.

    The items of the Menu Switch node are provided in the 'items' dict.
    An group input socket named after the 'name' argument is linked to menu selector.

    Parameters
    ----------
    named_sockets : dict, optional
        sockets to create default={}.

    default_menu : str, optional
        default menu value default=None.

    sockets : dict
        items


    Returns
    -------
    Socket
    """        
    return self.MenuSwitch(named_sockets = {self_name: self, **named_sockets}, default_menu=default_menu, **sockets)

out(name=None, panel='', **props)

Plug the value to the Group Output Node.

with GeoNodes("Plug to group output"):
    # Create a cube
    geo = Mesh.Cube()
    # To Group Output geometry as socket named "Cube"
    geo.out("Cube")

The "Do nothing" modifier is simply Geometry().out()

Parameters:

Name	Type	Description	Default
name	str	socket name default=None.	None

Returns:

Type	Description
None

Source code in core/socket_class.py

def out(self, name: str = None, panel: str = "", **props):
    """ Plug the value to the Group Output Node.

    ``` python
    with GeoNodes("Plug to group output"):
        # Create a cube
        geo = Mesh.Cube()
        # To Group Output geometry as socket named "Cube"
        geo.out("Cube")
    ```

    The "Do nothing" modifier is simply ``` Geometry().out() ```

    Parameters
    ----------
    name : str, optional
        socket name default=None.


    Returns
    -------
    None
    """
    self._is_empty(f"Impossible to link an empty socket (name: '{name}').")

    out_node = self._tree.get_output_node()
    out_node.set_input_socket(name=name, value=self, create=True, panel=panel, **props)

repeat(iterations=1, named_sockets={}, **sockets)

Repeat zone

Parameters:

Name	Type	Description	Default
iterations	Integer	iteration socket	1
named_sockets	dict	named sockets	{}
sockets	dict	other sockets	{}

Returns:

Type	Description
ZoneIterator

Source code in core/socket_class.py

def repeat(self, iterations=1, named_sockets: dict={}, **sockets):
    """ Repeat zone

    Parameters
    ----------
    iterations : Integer, default=1
        iteration socket

    named_sockets : dict, default={}
        named sockets

    sockets : dict, optional
        other sockets


    Returns
    -------
    ZoneIterator
    """
    class_name = type(self).__name__
    node = ZoneNode("Repeat", named_sockets={class_name: self, **named_sockets}, Iterations=iterations, **sockets)
    return ZoneIterator(self, node)

reshape_list(shape)

Reshape a flat list into nested lists.

shape defines the length of each list level. Items keep their original linear order.

values = Float.List(*range(16))
matrix = values.reshape_list((4, 4))

first  = matrix[0][0]
last   = matrix[3][3]

Shapes with more than two dimensions are supported:

values = Float.List(*range(24))
blocks = values.reshape_list((2, 3, 4))

Dimensions can also be Integer sockets:

rows = Integer(name="Rows")
table = values.reshape_list((rows, 4))

A single dimension does not require a tuple:

values.reshape_list(16)
# Equivalent to values.reshape_list((16,))

A one-dimensional shape flattens one existing level of nested lists. A warning is emitted when the resulting length differs from the requested dimension.

Parameters:

Name	Type	Description	Default
shape	int | Integer | tuple[int | Integer]	Length of every dimension. A single integer is interpreted as a one-dimensional shape. Dimensions must be strictly positive.	required

Returns:

Type	Description
Socket	This socket, updated to point to the reshaped list.

Source code in core/socket_class.py

def reshape_list(self, shape):
    """Reshape a flat list into nested lists.

    ``shape`` defines the length of each list level. Items keep their
    original linear order.

    ``` python
    values = Float.List(*range(16))
    matrix = values.reshape_list((4, 4))

    first  = matrix[0][0]
    last   = matrix[3][3]
    ```

    Shapes with more than two dimensions are supported:

    ``` python
    values = Float.List(*range(24))
    blocks = values.reshape_list((2, 3, 4))
    ```

    Dimensions can also be Integer sockets:

    ``` python
    rows = Integer(name="Rows")
    table = values.reshape_list((rows, 4))
    ```

    A single dimension does not require a tuple:

    ``` python
    values.reshape_list(16)
    # Equivalent to values.reshape_list((16,))
    ```

    A one-dimensional shape flattens one existing level of nested lists.
    A warning is emitted when the resulting length differs from the
    requested dimension.

    Parameters
    ----------
    shape : int | Integer | tuple[int | Integer]
        Length of every dimension. A single integer is interpreted as a
        one-dimensional shape. Dimensions must be strictly positive.

    Returns
    -------
    Socket
        This socket, updated to point to the reshaped list.

    """

    if not hasattr(shape, '__len__'):
        shape = (shape,)

    shape = tuple(shape)

    ok_shape = True
    for d in shape:
        if isinstance(d, Socket):
            oK_shape = False

    shape_str = f"({shape})" if ok_shape else ""

    from .sock_closure import Closure
    from .sock_integer import Integer
    from .sock_string import String

    with Layout(f"Socket.reshape_list{shape_str}"):

        if len(shape) == 1:

            self.flatten_list()

            res_length = self.list_length()

            message = String.Join(
                f"{self._name}.reshape_list(" + Integer(shape[0]).to_string() + ")",
                "the resulting list length is",
                res_length.to_string(),
                delimiter = " ",
            )

            self.list_length().not_equal(shape[0]).warning(message)
            return self

        dimensions = [Integer(size) for size in shape]

        # ----- Build nested lists

        def build(level, linear_index=None):
            with Closure() as closure:
                index = Integer(0, "Index")

                if linear_index is None:
                    next_index = index
                else:
                    next_index = linear_index * dimensions[level] + index

                if level == len(dimensions) - 1:
                    value = self[next_index]
                else:
                    value = build(level + 1, next_index)

                value.out("Value")

            return closure.to_list(count=dimensions[level])

        self._jump(build(0))
        return self

simulation(named_sockets={}, **sockets)

Simulation zone

Parameters:

Name	Type	Description	Default
named_sockets	dict	named sockets	{}
sockets	dict	other sockets	{}

Returns:

Type	Description
ZoneIterator

Source code in core/socket_class.py

def simulation(self, named_sockets: dict={}, **sockets):
    """ Simulation zone

    Parameters
    ----------
    named_sockets : dict, default={}
        named sockets

    sockets : dict, optional
        other sockets

    Returns
    -------
    ZoneIterator
    """
    class_name = type(self).__name__
    node = ZoneNode("Simulation", named_sockets={class_name: self, **named_sockets}, **sockets)
    return ZoneIterator(self, node)

sort_list(selection=None, group_id=None, sort_weight=None)

Node Sort List

Fixed values

Kind	Name	Value
Socket	List	self
Parameter	socket_type	'MATERIAL'

Parameters:

Name	Type	Description	Default
selection	Boolean	socket 'Selection' (id: Selection)	None
group_id	Integer	socket 'Group ID' (id: Group ID)	None
sort_weight	Float	socket 'Sort Weight' (id: Sort Weight)	None

Returns:

Type	Description
Material

Source code in core/generated/material.py

def sort_list(self,
                selection: Boolean = None,
                group_id: Integer = None,
                sort_weight: Float = None):
    """ > Node Sort List

    **Fixed values**

    | Kind      | Name          | Value        |
    | --------- | ------------- | ------------ |
    | Socket    | List          | `self`       |
    | Parameter | `socket_type` | `'MATERIAL'` |

    Parameters
    ----------
    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    group_id : Integer, optional
        socket 'Group ID' (id: Group ID)

    sort_weight : Float, optional
        socket 'Sort Weight' (id: Sort Weight)


    Returns
    -------
    Material
    """
    node = Node('Sort List', {'List': self, 'Selection': selection, 'Group ID': group_id, 'Sort Weight': sort_weight}, socket_type='MATERIAL')
    return node._out

switch(condition=None, true=None)

Node Switch

Self is connected to 'false' socket.

Note

switch returns self if global constant SWITCH_JUMP = True (default) set SWITCH_JUMP = False for legacy behavior

with GeoNodes("Switch demo"):

    from geonodes import core_module
    constants = core_module.constants
    # Legacy behavior (default is True)
    constants.SWITCH_JUMP = False

    choice = Boolean(True, "Use Sphere")

    # Two possible geometries
    cube   = Mesh.Cube()
    sphere = Mesh.IcoSphere()

    # Select
    # Legacy behavior: cube is unchanged otherwise cube
    geo = cube.switch(choice, sphere)

    # To group output
    geo.out()

Information

• Socket 'False' : self

Parameters:

Name	Type	Description	Default
condition	Boolean	socket 'Switch' (Switch)	None
true		socket 'True' (True)	None

Returns:

Type	Description
Socket(self)

Source code in core/socket_class.py

def switch(self, condition=None, true=None):
    """ > Node Switch

    Self is connected to 'false' socket.

    !!! note
        switch returns self if global constant SWITCH_JUMP = True (default)
        set SWITCH_JUMP = False for legacy behavior

    ``` python
    with GeoNodes("Switch demo"):

        from geonodes import core_module
        constants = core_module.constants
        # Legacy behavior (default is True)
        constants.SWITCH_JUMP = False

        choice = Boolean(True, "Use Sphere")

        # Two possible geometries
        cube   = Mesh.Cube()
        sphere = Mesh.IcoSphere()

        # Select
        # Legacy behavior: cube is unchanged otherwise cube
        geo = cube.switch(choice, sphere)

        # To group output
        geo.out()
    ```

    Information
    -----------
    - Socket 'False' : self

    Parameters
    ----------
    condition : Boolean
        socket 'Switch' (Switch)

    true
        socket 'True' (True)


    Returns
    -------
    Socket (self)
    """
    res = self.Switch(condition=condition, false=self, true=true)
    if constants.SWITCH_JUMP:
        return self._jump(res)
    else:
        return res

switch_false(condition=None, false=None)

Node Switch

[&JUMP]

Self is connected to 'true' socket.

Important

This methods behaves the inverse of switch : self is connected to "True" socket and the argument to "False", socket

Note

This method is mainly provided to cover the case when 'False' socket is None

with GeoNodes("Switch demo"):

    geo = Geometry()

    show_geometry = Boolean(False, "Merge with Cube")

    cube = Mesh.Cube()

    geo += cube.switch_false(show_geometry)

    # Is equivalent to
    geo += Geometry.Switch(show_geometry, None, cube)

    # To group output
    geo.out()

Note

This method let self socket unchanged. To set self socket to the result

Information

• Socket 'True' : self

Parameters:

Name	Type	Description	Default
condition	Boolean	socket 'Switch' (Switch)	None
false		socket 'False' (False)	None

Returns:

Type	Description
Socket

Source code in core/socket_class.py

def switch_false(self, condition=None, false=None):
    """ > Node Switch

    [&JUMP]

    Self is connected to 'true' socket.

    !!! important
        This methods behaves the inverse of switch : self is connected to "True" socket and  the argument to "False", socket

    !!! note
        This method is mainly provided to cover the case when 'False' socket is None

    ``` python
    with GeoNodes("Switch demo"):

        geo = Geometry()

        show_geometry = Boolean(False, "Merge with Cube")

        cube = Mesh.Cube()

        geo += cube.switch_false(show_geometry)

        # Is equivalent to
        geo += Geometry.Switch(show_geometry, None, cube)

        # To group output
        geo.out()
    ```

    !!! note
        This method let self socket unchanged. To set self socket to the result

    Information
    -----------
    - Socket 'True' : self

    Parameters
    ----------
    condition : Boolean
        socket 'Switch' (Switch)

    false
        socket 'False' (False)


    Returns
    -------
    Socket
    """
    res = self.Switch(condition=condition, false=false, true=self)
    if constants.SWITCH_JUMP:
        return self._jump(res)
    else:
        return res

to_list(count=None)

Node Field to List

Shortcut for self.field_to_list(count) when only this field has to be converted to a list.

Parameters:

Name	Type	Description	Default
count	Integer	Number of items in the generated list.	None

Returns:

Type	Description
Socket	List containing the values obtained by evaluating this field.

Source code in core/socket_class.py

def to_list(self, count=None):
    """ > Node Field to List

    Shortcut for ``self.field_to_list(count)`` when only this field has
    to be converted to a list.

    Parameters
    ----------
    count : Integer, optional
        Number of items in the generated list.

    Returns
    -------
    Socket
        List containing the values obtained by evaluating this field.
    """
    return Node('Field to List', named_sockets={self._name: self}, count=count)._out

to_node_inputs(node, *names)

Connect successive list items to a node's inputs.

This is the natural socket-oriented shortcut for node._list_to_inputs(*names, socket_list=self).

When names is empty, all node inputs matching the type of the list items are fed, in their order on the node. Otherwise, only the named inputs are used.

separate = Node('Separate XYZ', vector=vector)
components = separate._outputs_to_list()

combine = Node('Combine XYZ')
components.to_node_inputs(combine)

Parameters:

Name	Type	Description	Default
node	Node	Node whose inputs are to be connected.	required
names	str	Optional names of the inputs to feed.	()

Returns:

Type	Description
Node	The target node.

Source code in core/socket_class.py

def to_node_inputs(self, node, *names):
    """Connect successive list items to a node's inputs.

    This is the natural socket-oriented shortcut for
    ``node._list_to_inputs(*names, socket_list=self)``.

    When ``names`` is empty, all node inputs matching the type of the list
    items are fed, in their order on the node. Otherwise, only the named
    inputs are used.

    ``` python
    separate = Node('Separate XYZ', vector=vector)
    components = separate._outputs_to_list()

    combine = Node('Combine XYZ')
    components.to_node_inputs(combine)
    ```

    Parameters
    ----------
    node : Node
        Node whose inputs are to be connected.

    names : str
        Optional names of the inputs to feed.

    Returns
    -------
    Node
        The target node.
    """
    return node._list_to_inputs(*names, socket_list=self)