Float

Bases: Float

Source code in core/sock_float.py

class Float(generated.Float):

    SOCKET_TYPE = 'VALUE'

    def __init__(self,
        value   = None,
        name    : str = None,
        min     : float = -3.40282e+38,
        max     : float = 3.40282e+38,
        tip     : str = '',
        panel   : str = "",
        **props):
        """ > Float Input

        New Float input with subtype 'NONE'.

        Use methods Percentage, Factor, Angle, Time, TimeAbsolute, Distance, WaveLength, ColorTemperature or Frequency
        to create input sockets with a subtype.

        Parameters
        ----------
        value : object, default=0.0
            Default value

        name : str, default='Float'
            Input socket name

        min : float, default=-3.40282e+38
            Property min_value

        max : float, default=3.40282e+38
            Property max_value

        tip : str, default=''
            Property description

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

        props : dict
            properties


        Returns
        -------
        Float
        """
        super().__init__(value, name, min=min, max=max, tip=tip, panel=panel, **props)

    # ====================================================================================================
    # Methods

    # ----- Mix

    def mix(self, factor=None, other=None, clamp_factor=None):
        """ > Mix

        > Node Mix

        Parameters
        ----------
        factor : Float
            socket 'Factor' (Factor_Float)

        other : Socket
            socket 'B' (B_Float)

        clamp_factor : bool
            Node.clamp_factor

        Returns
        -------
        Socket
        """
        return Float(Node('Mix', {'Factor': factor, 'A': self, 'B': other}, clamp_factor=clamp_factor, data_type='FLOAT')._out)

    def color_ramp(self, stops=None, interpolation='LINEAR'):
        """ > Color Ramp

        > Node Color Ramp

        Parameters
        ----------

        stops : list[tuple[float, tuple]]
            Stops made of (float, color as tuple of floats)

        interpolation : {'EASE', 'CARDINAL', 'LINEAR', 'B_SPLINE', 'CONSTANT'}


        Returns
        -------
        Color
        """
        return ColorRamp(fac=self, stops=stops, interpolation=interpolation)._out

    # ====================================================================================================
    # Float curve

    def curve(self, factor=None, curve=None):
        """ > Node Float Curve

        A curve is defined by a list of 3-tuples (not list):

        - x (float) : x position
        - y (float) : y position
        - handle_type (str) : handle type in ('AUTO', 'AUTO_CLAMPED', 'VECTOR'), default='AUTO'

        Information
        -----------
        - Socket 'Value' : self

        Parameters
        ----------
        factor : Float
            socket 'Factor' (id: Factor)

        curve : list[tuple[float, float, str]]
            Curve points

        Returns
        -------
        Float
        """
        node = NodeCurves('Float Curve', named_sockets={'Value': self, 'Factor': factor})
        node.set_curves(curve)
        return node._out

    # ====================================================================================================
    # Operations

    # ----- Neg

    def __neg__(self):
        return self.multiply(-1)

    # ----- Abs

    def __abs__(self):
        return self.abs()

    # ----- Addition

    def __add__(self, other):
        from .sock_vector import Vector
        if utils.is_vector_like(other):
            return Vector(self).add(other)
        return self.add(other)

    def __radd__(self, other):
        from .sock_vector import Vector
        if utils.is_vector_like(other):
            return Vector(other).add(self)
        return self.add(other)

    def __iadd__(self, other):
        return self._jump(self.add(other))

    # ----- Subtraction

    def __sub__(self, other):
        from .sock_vector import Vector
        if utils.is_vector_like(other):
            return Vector(self).subtract(other)
        return self.subtract(other)

    def __rsub__(self, other):
        from .sock_vector import Vector
        if utils.is_vector_like(other):
            return Vector(other).subtract(self)
        return Float(other).subtract(self)

    def __isub__(self, other):
        return self._jump(self.subtract(other))

    # ----- Multiplication

    def __mul__(self, other):
        from .sock_vector import Vector
        if utils.is_vector_like(other):
            return Vector(other).scale(self)
        return self.multiply(other)

    def __rmul__(self, other):
        from .sock_vector import Vector
        if utils.is_vector_like(other):
            return Vector(other).scale(self)
        return self.multiply(other)

    def __imul__(self, other):
        return self._jump(self.multiply(other))

    # ----- Division

    def __truediv__(self, other):
        from .sock_vector import Vector
        if utils.is_vector_like(other):
            return Vector(other).divide(self)
        return self.divide(other)

    def __rtruediv__(self, other):
        from .sock_vector import Vector
        if utils.is_vector_like(other):
            return Vector(other).divide(self)
        return Float(other).divide(self)

    def __itruediv__(self, other):
        return self._jump(self.divide(other))

    # ----- Modulo

    def __mod__(self, other):
        from .sock_vector import Vector
        if utils.is_vector_like(other):
            return Vector(self).modulo(other)
        return self.modulo(other)

    def __rmod__(self, other):
        from .sock_vector import Vector
        if utils.is_vector_like(other):
            return Vector(other).modulo(self)
        return Float(other).modulo(self)

    def __imod__(self, other):
        return self._jump(self.modulo( other))

    # ----- Power

    def __pow__(self, other):
        return self.power(other)

    def __rpow__(self, other):
        return Float(other).power(self)

    def __ipow__(self, other):
        return self._jump(self.power(other))

    # ----- Operations

    def __round__(self):
        return self.round()

    def __trunc__(self):
        return self.trunc()

    def __floor__(self):
        return self.floor()

    def __ceil__(self):
        return self.ceil()

    # =============================================================================================================================
    # Comparison
    # __eq__ __ne__ __lt__ __gt__ __le__ __ge__

    def __ge__(self, other):
        return self.greater_equal(other)

    def __gt__(self, other):
        return self.greater_than(other)

    def __le__(self, other):
        return self.less_equal(other)

    def __lt__(self, other):
        return self.less_than(other)

    def __eq__(self, other):
        return self.equal(other)

    def __ne__(self, other):
        return self.not_equal(other)

    # ====================================================================================================
    # Output

    def out(self, name=None, **props):
        """ > Connect to output

        !!! important "Behavior"

            - Geometry Nodes : create a group output socket with the provided name
            - Shader : create a node AOV Output
        """
        if self._tree._btree.bl_idname == 'ShaderNodeTree' and not self._tree._is_group:
            if name is None:
                self._tree.set_thickness(self)
            else:
                self._tree.aov_output(name=name, value=self)
        else:
            super().out(name=name, **props)

    def thickness_out(self, target='ALL'):
        self._tree.set_thickness(self, target=target)

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

    @classmethod
    def _class_test(cls):

        from geonodes import GeoNodes, Mesh, Layout, Float

        with GeoNodes("Float Test"):

            with Layout("Base"):
                a = Float(3.14)
                a += Float(name="Your entry")
                a *= Float(1., name="Mul (1 def)")

            with Layout("Named Attribute"):
                g = Mesh()
                g.points.A_Float = a

                b = Float("A Float") - a
                g.faces.store("Another float", b)

            with Layout("Grid Attribute"):
                vol = g.to_volume()
                vol.store_named_grid("Float A", a)

            vol.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

_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').

node_color property writable

Node color

Returns:

Type	Description
SysColor

node_label property writable

Node Label

Returns:

Type	Description
str

Angle(value=0.0, name='Angle', min=-3.40282e+38, max=3.40282e+38, tip='', panel='', optional_label=False, hide_value=False, hide_in_modifier=False, default_attribute='', shape='AUTO') classmethod

Angle Input

New Float input with subtype 'ANGLE'.

Parameters:

Name	Type	Description	Default
value	object	Default value	`0.0`
name	str	Input socket name	`Angle`
min	float	Property min_value	`-3.40282e+38`
max	float	Property max_value	`3.40282e+38`
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`
default_attribute	str	Property default_attribute_name	`''`
shape	str	Property structure_type in ('AUTO', 'SINGLE')	`'AUTO'`

Returns:

Type	Description
Float

Source code in core/generated/float.py

@classmethod
def Angle(cls,
    value: object = 0.0,
    name: str = 'Angle',
    min: float = -3.40282e+38,
    max: float = 3.40282e+38,
    tip: str = '',
    panel: str = "",
    optional_label: bool = False,
    hide_value: bool = False,
    hide_in_modifier: bool = False,
    default_attribute: str = '',
    shape: Literal['AUTO', 'SINGLE'] = 'AUTO',
     ):
    """ > Angle Input

    New Float input with subtype 'ANGLE'.

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

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

    min : float, default=`-3.40282e+38`
        Property min_value

    max : float, default=`3.40282e+38`
        Property max_value

    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

    default_attribute : str, default=`''`
        Property default_attribute_name

    shape : str, default=`'AUTO'`
        Property structure_type in ('AUTO', 'SINGLE')


    Returns
    -------
    Float
    """
    return cls(value=value, name=name, min=min, max=max, tip=tip, panel=panel,
        optional_label=optional_label, hide_value=hide_value, hide_in_modifier=hide_in_modifier,
        default_attribute=default_attribute, shape=shape, subtype='ANGLE')

ColorTemperature(value=0.0, name='ColorTemperature', min=-3.40282e+38, max=3.40282e+38, tip='', panel='', optional_label=False, hide_value=False, hide_in_modifier=False, default_attribute='', shape='AUTO') classmethod

ColorTemperature Input

New Float input with subtype 'COLOR_TEMPERATURE'.

Parameters:

Name	Type	Description	Default
value	object	Default value	`0.0`
name	str	Input socket name	`ColorTemperature`
min	float	Property min_value	`-3.40282e+38`
max	float	Property max_value	`3.40282e+38`
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`
default_attribute	str	Property default_attribute_name	`''`
shape	str	Property structure_type in ('AUTO', 'SINGLE')	`'AUTO'`

Returns:

Type	Description
Float

Source code in core/generated/float.py

@classmethod
def ColorTemperature(cls,
    value: object = 0.0,
    name: str = 'ColorTemperature',
    min: float = -3.40282e+38,
    max: float = 3.40282e+38,
    tip: str = '',
    panel: str = "",
    optional_label: bool = False,
    hide_value: bool = False,
    hide_in_modifier: bool = False,
    default_attribute: str = '',
    shape: Literal['AUTO', 'SINGLE'] = 'AUTO',
     ):
    """ > ColorTemperature Input

    New Float input with subtype 'COLOR_TEMPERATURE'.

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

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

    min : float, default=`-3.40282e+38`
        Property min_value

    max : float, default=`3.40282e+38`
        Property max_value

    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

    default_attribute : str, default=`''`
        Property default_attribute_name

    shape : str, default=`'AUTO'`
        Property structure_type in ('AUTO', 'SINGLE')


    Returns
    -------
    Float
    """
    return cls(value=value, name=name, min=min, max=max, tip=tip, panel=panel,
        optional_label=optional_label, hide_value=hide_value, hide_in_modifier=hide_in_modifier,
        default_attribute=default_attribute, shape=shape, subtype='COLOR_TEMPERATURE')

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(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(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('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':
        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':
        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}"

Distance(value=0.0, name='Distance', min=-3.40282e+38, max=3.40282e+38, tip='', panel='', optional_label=False, hide_value=False, hide_in_modifier=False, default_attribute='', shape='AUTO') classmethod

Distance Input

New Float input with subtype 'DISTANCE'.

Parameters:

Name	Type	Description	Default
value	object	Default value	`0.0`
name	str	Input socket name	`Distance`
min	float	Property min_value	`-3.40282e+38`
max	float	Property max_value	`3.40282e+38`
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`
default_attribute	str	Property default_attribute_name	`''`
shape	str	Property structure_type in ('AUTO', 'SINGLE')	`'AUTO'`

Returns:

Type	Description
Float

Source code in core/generated/float.py

@classmethod
def Distance(cls,
    value: object = 0.0,
    name: str = 'Distance',
    min: float = -3.40282e+38,
    max: float = 3.40282e+38,
    tip: str = '',
    panel: str = "",
    optional_label: bool = False,
    hide_value: bool = False,
    hide_in_modifier: bool = False,
    default_attribute: str = '',
    shape: Literal['AUTO', 'SINGLE'] = 'AUTO',
     ):
    """ > Distance Input

    New Float input with subtype 'DISTANCE'.

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

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

    min : float, default=`-3.40282e+38`
        Property min_value

    max : float, default=`3.40282e+38`
        Property max_value

    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

    default_attribute : str, default=`''`
        Property default_attribute_name

    shape : str, default=`'AUTO'`
        Property structure_type in ('AUTO', 'SINGLE')


    Returns
    -------
    Float
    """
    return cls(value=value, name=name, min=min, max=max, tip=tip, panel=panel,
        optional_label=optional_label, hide_value=hide_value, hide_in_modifier=hide_in_modifier,
        default_attribute=default_attribute, shape=shape, subtype='DISTANCE')

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(cls.SOCKET_TYPE).get_default_from_value(value)
    return socket

Factor(value=0.0, name='Factor', min=-3.40282e+38, max=3.40282e+38, tip='', panel='', optional_label=False, hide_value=False, hide_in_modifier=False, default_attribute='', shape='AUTO') classmethod

Factor Input

New Float input with subtype 'FACTOR'.

Parameters:

Name	Type	Description	Default
value	object	Default value	`0.0`
name	str	Input socket name	`Factor`
min	float	Property min_value	`-3.40282e+38`
max	float	Property max_value	`3.40282e+38`
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`
default_attribute	str	Property default_attribute_name	`''`
shape	str	Property structure_type in ('AUTO', 'SINGLE')	`'AUTO'`

Returns:

Type	Description
Float

Source code in core/generated/float.py

@classmethod
def Factor(cls,
    value: object = 0.0,
    name: str = 'Factor',
    min: float = -3.40282e+38,
    max: float = 3.40282e+38,
    tip: str = '',
    panel: str = "",
    optional_label: bool = False,
    hide_value: bool = False,
    hide_in_modifier: bool = False,
    default_attribute: str = '',
    shape: Literal['AUTO', 'SINGLE'] = 'AUTO',
     ):
    """ > Factor Input

    New Float input with subtype 'FACTOR'.

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

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

    min : float, default=`-3.40282e+38`
        Property min_value

    max : float, default=`3.40282e+38`
        Property max_value

    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

    default_attribute : str, default=`''`
        Property default_attribute_name

    shape : str, default=`'AUTO'`
        Property structure_type in ('AUTO', 'SINGLE')


    Returns
    -------
    Float
    """
    return cls(value=value, name=name, min=min, max=max, tip=tip, panel=panel,
        optional_label=optional_label, hide_value=hide_value, hide_in_modifier=hide_in_modifier,
        default_attribute=default_attribute, shape=shape, subtype='FACTOR')

Frequency(value=0.0, name='Frequency', min=-3.40282e+38, max=3.40282e+38, tip='', panel='', optional_label=False, hide_value=False, hide_in_modifier=False, default_attribute='', shape='AUTO') classmethod

Frequency Input

New Float input with subtype 'FREQUENCY'.

Parameters:

Name	Type	Description	Default
value	object	Default value	`0.0`
name	str	Input socket name	`Frequency`
min	float	Property min_value	`-3.40282e+38`
max	float	Property max_value	`3.40282e+38`
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`
default_attribute	str	Property default_attribute_name	`''`
shape	str	Property structure_type in ('AUTO', 'SINGLE')	`'AUTO'`

Returns:

Type	Description
Float

Source code in core/generated/float.py

@classmethod
def Frequency(cls,
    value: object = 0.0,
    name: str = 'Frequency',
    min: float = -3.40282e+38,
    max: float = 3.40282e+38,
    tip: str = '',
    panel: str = "",
    optional_label: bool = False,
    hide_value: bool = False,
    hide_in_modifier: bool = False,
    default_attribute: str = '',
    shape: Literal['AUTO', 'SINGLE'] = 'AUTO',
     ):
    """ > Frequency Input

    New Float input with subtype 'FREQUENCY'.

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

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

    min : float, default=`-3.40282e+38`
        Property min_value

    max : float, default=`3.40282e+38`
        Property max_value

    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

    default_attribute : str, default=`''`
        Property default_attribute_name

    shape : str, default=`'AUTO'`
        Property structure_type in ('AUTO', 'SINGLE')


    Returns
    -------
    Float
    """
    return cls(value=value, name=name, min=min, max=max, tip=tip, panel=panel,
        optional_label=optional_label, hide_value=hide_value, hide_in_modifier=hide_in_modifier,
        default_attribute=default_attribute, shape=shape, subtype='FREQUENCY')

Gabor(vector=None, scale=None, frequency=None, anisotropy=None, orientation=None, gabor_type='2D') classmethod

Node Gabor Texture

Parameters:

Name	Type	Description	Default
vector	Vector	socket 'Vector' (id: Vector)	None
scale	Float	socket 'Scale' (id: Scale)	None
frequency	Float	socket 'Frequency' (id: Frequency)	None
anisotropy	Float	socket 'Anisotropy' (id: Anisotropy)	None
orientation	Float	socket 'Orientation' (id: Orientation 2D)	None
gabor_type	Literal['2D', '3D']	parameter gabor_type	'2D'

Returns:

Type	Description
Float

Source code in core/generated/float.py

@classmethod
def Gabor(cls,
                vector: Vector = None,
                scale: Float = None,
                frequency: Float = None,
                anisotropy: Float = None,
                orientation: Float = None,
                gabor_type: Literal['2D', '3D'] = '2D'):
    """ > Node Gabor Texture

    Parameters
    ----------
    vector : Vector, optional
        socket 'Vector' (id: Vector)

    scale : Float, optional
        socket 'Scale' (id: Scale)

    frequency : Float, optional
        socket 'Frequency' (id: Frequency)

    anisotropy : Float, optional
        socket 'Anisotropy' (id: Anisotropy)

    orientation : Float, optional
        socket 'Orientation' (id: Orientation 2D)

    gabor_type : Literal['2D', '3D']
        parameter `gabor_type`


    Returns
    -------
    Float
    """
    utils.check_enum_arg('Gabor Texture', 'gabor_type', gabor_type, 'Gabor', ('2D', '3D'))
    node = Node('Gabor Texture', {'Vector': vector, 'Scale': scale, 'Frequency': frequency, 'Anisotropy': anisotropy, 'Orientation 2D': orientation}, gabor_type=gabor_type)
    return cls(node._out)

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
    """
    #return IndexSwitchNode(*values, index=index, data_type=cls.input_type())._out
    return MenuNode('Index Switch', 
                    {str(i): value for i, value in enumerate(values)}, 
                    data_type=cls.SOCKET_TYPE, 
                    Index=index,
                    default_menu = default_index)._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(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

Mass(value=0.0, name='Mass', min=-3.40282e+38, max=3.40282e+38, tip='', panel='', optional_label=False, hide_value=False, hide_in_modifier=False, default_attribute='', shape='AUTO') classmethod

Mass Input

New Float input with subtype 'MASS'.

Parameters:

Name	Type	Description	Default
value	object	Default value	`0.0`
name	str	Input socket name	`Mass`
min	float	Property min_value	`-3.40282e+38`
max	float	Property max_value	`3.40282e+38`
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`
default_attribute	str	Property default_attribute_name	`''`
shape	str	Property structure_type in ('AUTO', 'SINGLE')	`'AUTO'`

Returns:

Type	Description
Float

Source code in core/generated/float.py

@classmethod
def Mass(cls,
    value: object = 0.0,
    name: str = 'Mass',
    min: float = -3.40282e+38,
    max: float = 3.40282e+38,
    tip: str = '',
    panel: str = "",
    optional_label: bool = False,
    hide_value: bool = False,
    hide_in_modifier: bool = False,
    default_attribute: str = '',
    shape: Literal['AUTO', 'SINGLE'] = 'AUTO',
     ):
    """ > Mass Input

    New Float input with subtype 'MASS'.

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

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

    min : float, default=`-3.40282e+38`
        Property min_value

    max : float, default=`3.40282e+38`
        Property max_value

    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

    default_attribute : str, default=`''`
        Property default_attribute_name

    shape : str, default=`'AUTO'`
        Property structure_type in ('AUTO', 'SINGLE')


    Returns
    -------
    Float
    """
    return cls(value=value, name=name, min=min, max=max, tip=tip, panel=panel,
        optional_label=optional_label, hide_value=hide_value, hide_in_modifier=hide_in_modifier,
        default_attribute=default_attribute, shape=shape, subtype='MASS')

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 = MenuNode('Menu Switch',
            named_sockets = named_sockets,
            data_type = SocketType(cls.SOCKET_TYPE).type,
            default_menu = default_menu,
            **sockets)

    return cls(node._out)

Named(name=None) classmethod

Node Named Attribute

Fixed values

Kind	Name	Value
Parameter	data_type	'FLOAT'

Parameters:

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

Returns:

Type	Description
Float

Source code in core/generated/float.py

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

    **Fixed values**

    | Kind      | Name        | Value     |
    | --------- | ----------- | --------- |
    | Parameter | `data_type` | `'FLOAT'` |

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


    Returns
    -------
    Float
    """
    node = Node('Named Attribute', {'Name': name}, data_type='FLOAT')
    return cls(node._out)

NamedAttribute(name=None) classmethod

Node Named Attribute

Fixed values

Kind	Name	Value
Parameter	data_type	'FLOAT'

Parameters:

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

Returns:

Type	Description
Float

Source code in core/generated/float.py

@classmethod
def NamedAttribute(cls, name: String = None):
    """ > Node Named Attribute

    **Fixed values**

    | Kind      | Name        | Value     |
    | --------- | ----------- | --------- |
    | Parameter | `data_type` | `'FLOAT'` |

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


    Returns
    -------
    Float
    """
    node = Node('Named Attribute', {'Name': name}, data_type='FLOAT')
    return cls(node._out)

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(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(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(cls.SOCKET_TYPE).socket_id,
        name         = name,
        tip          = tip,
        panel        = panel,
        **props))

Noise(vector=None, scale=None, detail=None, roughness=None, lacunarity=None, distortion=None, noise_dimensions='3D', noise_type='FBM', normalize=True) classmethod

Node Noise Texture

Parameters:

Name	Type	Description	Default
vector	Vector	socket 'Vector' (id: Vector)	None
scale	Float	socket 'Scale' (id: Scale)	None
detail	Float	socket 'Detail' (id: Detail)	None
roughness	Float	socket 'Roughness' (id: Roughness)	None
lacunarity	Float	socket 'Lacunarity' (id: Lacunarity)	None
distortion	Float	socket 'Distortion' (id: Distortion)	None
noise_dimensions	Literal['1D', '2D', '3D', '4D']	parameter noise_dimensions	'3D'
noise_type	Literal['Multifractal', 'Ridged Multifractal', 'Hybrid Multifractal', 'fBM', 'Hetero Terrain']	parameter noise_type	'FBM'
normalize	bool	parameter normalize	True

Returns:

Type	Description
Float

Source code in core/generated/float.py

@classmethod
def Noise(cls,
                vector: Vector = None,
                scale: Float = None,
                detail: Float = None,
                roughness: Float = None,
                lacunarity: Float = None,
                distortion: Float = None,
                noise_dimensions: Literal['1D', '2D', '3D', '4D'] = '3D',
                noise_type: Literal['MULTIFRACTAL', 'RIDGED_MULTIFRACTAL', 'HYBRID_MULTIFRACTAL', 'FBM', 'HETERO_TERRAIN'] = 'FBM',
                normalize = True):
    """ > Node Noise Texture

    Parameters
    ----------
    vector : Vector, optional
        socket 'Vector' (id: Vector)

    scale : Float, optional
        socket 'Scale' (id: Scale)

    detail : Float, optional
        socket 'Detail' (id: Detail)

    roughness : Float, optional
        socket 'Roughness' (id: Roughness)

    lacunarity : Float, optional
        socket 'Lacunarity' (id: Lacunarity)

    distortion : Float, optional
        socket 'Distortion' (id: Distortion)

    noise_dimensions : Literal['1D', '2D', '3D', '4D']
        parameter `noise_dimensions`

    noise_type : Literal['Multifractal', 'Ridged Multifractal', 'Hybrid Multifractal', 'fBM', 'Hetero Terrain']
        parameter `noise_type`

    normalize : bool
        parameter `normalize`


    Returns
    -------
    Float
    """
    utils.check_enum_arg('Noise Texture', 'noise_dimensions', noise_dimensions, 'Noise', ('1D', '2D', '3D', '4D'))
    utils.check_enum_arg('Noise Texture', 'noise_type', noise_type, 'Noise', ('MULTIFRACTAL', 'RIDGED_MULTIFRACTAL', 'HYBRID_MULTIFRACTAL', 'FBM', 'HETERO_TERRAIN'))
    node = Node('Noise Texture', {'Vector': vector, 'Scale': scale, 'Detail': detail, 'Roughness': roughness, 'Lacunarity': lacunarity, 'Distortion': distortion}, noise_dimensions=noise_dimensions, noise_type=noise_type, normalize=normalize)
    return cls(node._out)

Percentage(value=0.0, name='Percentage', min=-3.40282e+38, max=3.40282e+38, tip='', panel='', optional_label=False, hide_value=False, hide_in_modifier=False, default_attribute='', shape='AUTO') classmethod

Percentage Input

New Float input with subtype 'PERCENTAGE'.

Parameters:

Name	Type	Description	Default
value	object	Default value	`0.0`
name	str	Input socket name	`Percentage`
min	float	Property min_value	`-3.40282e+38`
max	float	Property max_value	`3.40282e+38`
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`
default_attribute	str	Property default_attribute_name	`''`
shape	str	Property structure_type in ('AUTO', 'SINGLE')	`'AUTO'`

Returns:

Type	Description
Float

Source code in core/generated/float.py

@classmethod
def Percentage(cls,
    value: object = 0.0,
    name: str = 'Percentage',
    min: float = -3.40282e+38,
    max: float = 3.40282e+38,
    tip: str = '',
    panel: str = "",
    optional_label: bool = False,
    hide_value: bool = False,
    hide_in_modifier: bool = False,
    default_attribute: str = '',
    shape: Literal['AUTO', 'SINGLE'] = 'AUTO',
     ):
    """ > Percentage Input

    New Float input with subtype 'PERCENTAGE'.

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

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

    min : float, default=`-3.40282e+38`
        Property min_value

    max : float, default=`3.40282e+38`
        Property max_value

    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

    default_attribute : str, default=`''`
        Property default_attribute_name

    shape : str, default=`'AUTO'`
        Property structure_type in ('AUTO', 'SINGLE')


    Returns
    -------
    Float
    """
    return cls(value=value, name=name, min=min, max=max, tip=tip, panel=panel,
        optional_label=optional_label, hide_value=hide_value, hide_in_modifier=hide_in_modifier,
        default_attribute=default_attribute, shape=shape, subtype='PERCENTAGE')

Random(min=None, max=None, id=None, seed=None) classmethod

Node Random Value

Fixed values

Kind	Name	Value
Parameter	data_type	'FLOAT'

Parameters:

Name	Type	Description	Default
min	Float	socket 'Min' (id: Min_001)	None
max	Float	socket 'Max' (id: Max_001)	None
id	Integer	socket 'ID' (id: ID)	None
seed	Integer	socket 'Seed' (id: Seed)	None

Returns:

Type	Description
Float

Source code in core/generated/float.py

@classmethod
def Random(cls,
                min: Float = None,
                max: Float = None,
                id: Integer = None,
                seed: Integer = None):
    """ > Node Random Value

    **Fixed values**

    | Kind      | Name        | Value     |
    | --------- | ----------- | --------- |
    | Parameter | `data_type` | `'FLOAT'` |

    Parameters
    ----------
    min : Float, optional
        socket 'Min' (id: Min_001)

    max : Float, optional
        socket 'Max' (id: Max_001)

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

    seed : Integer, optional
        socket 'Seed' (id: Seed)


    Returns
    -------
    Float
    """
    node = Node('Random Value', {'Min_001': min, 'Max_001': max, 'ID': id, 'Seed': seed}, data_type='FLOAT')
    return cls(node._out)

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

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
    """
    input_type = SocketType(cls.SOCKET_TYPE).items_type
    return Node('Switch', {'Switch': condition, 'False': false, 'True': true}, input_type=input_type)._out

Time(value=0.0, name='Time', min=-3.40282e+38, max=3.40282e+38, tip='', panel='', optional_label=False, hide_value=False, hide_in_modifier=False, default_attribute='', shape='AUTO') classmethod

Time Input

New Float input with subtype 'TIME'.

Parameters:

Name	Type	Description	Default
value	object	Default value	`0.0`
name	str	Input socket name	`Time`
min	float	Property min_value	`-3.40282e+38`
max	float	Property max_value	`3.40282e+38`
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`
default_attribute	str	Property default_attribute_name	`''`
shape	str	Property structure_type in ('AUTO', 'SINGLE')	`'AUTO'`

Returns:

Type	Description
Float

Source code in core/generated/float.py

@classmethod
def Time(cls,
    value: object = 0.0,
    name: str = 'Time',
    min: float = -3.40282e+38,
    max: float = 3.40282e+38,
    tip: str = '',
    panel: str = "",
    optional_label: bool = False,
    hide_value: bool = False,
    hide_in_modifier: bool = False,
    default_attribute: str = '',
    shape: Literal['AUTO', 'SINGLE'] = 'AUTO',
     ):
    """ > Time Input

    New Float input with subtype 'TIME'.

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

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

    min : float, default=`-3.40282e+38`
        Property min_value

    max : float, default=`3.40282e+38`
        Property max_value

    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

    default_attribute : str, default=`''`
        Property default_attribute_name

    shape : str, default=`'AUTO'`
        Property structure_type in ('AUTO', 'SINGLE')


    Returns
    -------
    Float
    """
    return cls(value=value, name=name, min=min, max=max, tip=tip, panel=panel,
        optional_label=optional_label, hide_value=hide_value, hide_in_modifier=hide_in_modifier,
        default_attribute=default_attribute, shape=shape, subtype='TIME')

TimeAbsolute(value=0.0, name='TimeAbsolute', min=-3.40282e+38, max=3.40282e+38, tip='', panel='', optional_label=False, hide_value=False, hide_in_modifier=False, default_attribute='', shape='AUTO') classmethod

TimeAbsolute Input

New Float input with subtype 'TIME_ABSOLUTE'.

Parameters:

Name	Type	Description	Default
value	object	Default value	`0.0`
name	str	Input socket name	`TimeAbsolute`
min	float	Property min_value	`-3.40282e+38`
max	float	Property max_value	`3.40282e+38`
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`
default_attribute	str	Property default_attribute_name	`''`
shape	str	Property structure_type in ('AUTO', 'SINGLE')	`'AUTO'`

Returns:

Type	Description
Float

Source code in core/generated/float.py

@classmethod
def TimeAbsolute(cls,
    value: object = 0.0,
    name: str = 'TimeAbsolute',
    min: float = -3.40282e+38,
    max: float = 3.40282e+38,
    tip: str = '',
    panel: str = "",
    optional_label: bool = False,
    hide_value: bool = False,
    hide_in_modifier: bool = False,
    default_attribute: str = '',
    shape: Literal['AUTO', 'SINGLE'] = 'AUTO',
     ):
    """ > TimeAbsolute Input

    New Float input with subtype 'TIME_ABSOLUTE'.

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

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

    min : float, default=`-3.40282e+38`
        Property min_value

    max : float, default=`3.40282e+38`
        Property max_value

    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

    default_attribute : str, default=`''`
        Property default_attribute_name

    shape : str, default=`'AUTO'`
        Property structure_type in ('AUTO', 'SINGLE')


    Returns
    -------
    Float
    """
    return cls(value=value, name=name, min=min, max=max, tip=tip, panel=panel,
        optional_label=optional_label, hide_value=hide_value, hide_in_modifier=hide_in_modifier,
        default_attribute=default_attribute, shape=shape, subtype='TIME_ABSOLUTE')

Voronoi(vector=None, scale=None, detail=None, roughness=None, lacunarity=None, randomness=None, distance='EUCLIDEAN', feature='F1', normalize=False, voronoi_dimensions='3D') classmethod

Node Voronoi Texture

Parameters:

Name	Type	Description	Default
vector	Vector	socket 'Vector' (id: Vector)	None
scale	Float	socket 'Scale' (id: Scale)	None
detail	Float	socket 'Detail' (id: Detail)	None
roughness	Float	socket 'Roughness' (id: Roughness)	None
lacunarity	Float	socket 'Lacunarity' (id: Lacunarity)	None
randomness	Float	socket 'Randomness' (id: Randomness)	None
distance	Literal['Euclidean', 'Manhattan', 'Chebychev', 'Minkowski']	parameter distance	'EUCLIDEAN'
feature	Literal['F1', 'F2', 'Smooth F1', 'Distance to Edge', 'N-Sphere Radius']	parameter feature	'F1'
normalize	bool	parameter normalize	False
voronoi_dimensions	Literal['1D', '2D', '3D', '4D']	parameter voronoi_dimensions	'3D'

Returns:

Type	Description
Float

Source code in core/generated/float.py

@classmethod
def Voronoi(cls,
                vector: Vector = None,
                scale: Float = None,
                detail: Float = None,
                roughness: Float = None,
                lacunarity: Float = None,
                randomness: Float = None,
                distance: Literal['EUCLIDEAN', 'MANHATTAN', 'CHEBYCHEV', 'MINKOWSKI'] = 'EUCLIDEAN',
                feature: Literal['F1', 'F2', 'SMOOTH_F1', 'DISTANCE_TO_EDGE', 'N_SPHERE_RADIUS'] = 'F1',
                normalize = False,
                voronoi_dimensions: Literal['1D', '2D', '3D', '4D'] = '3D'):
    """ > Node Voronoi Texture

    Parameters
    ----------
    vector : Vector, optional
        socket 'Vector' (id: Vector)

    scale : Float, optional
        socket 'Scale' (id: Scale)

    detail : Float, optional
        socket 'Detail' (id: Detail)

    roughness : Float, optional
        socket 'Roughness' (id: Roughness)

    lacunarity : Float, optional
        socket 'Lacunarity' (id: Lacunarity)

    randomness : Float, optional
        socket 'Randomness' (id: Randomness)

    distance : Literal['Euclidean', 'Manhattan', 'Chebychev', 'Minkowski']
        parameter `distance`

    feature : Literal['F1', 'F2', 'Smooth F1', 'Distance to Edge', 'N-Sphere Radius']
        parameter `feature`

    normalize : bool
        parameter `normalize`

    voronoi_dimensions : Literal['1D', '2D', '3D', '4D']
        parameter `voronoi_dimensions`


    Returns
    -------
    Float
    """
    utils.check_enum_arg('Voronoi Texture', 'distance', distance, 'Voronoi', ('EUCLIDEAN', 'MANHATTAN', 'CHEBYCHEV', 'MINKOWSKI'))
    utils.check_enum_arg('Voronoi Texture', 'feature', feature, 'Voronoi', ('F1', 'F2', 'SMOOTH_F1', 'DISTANCE_TO_EDGE', 'N_SPHERE_RADIUS'))
    utils.check_enum_arg('Voronoi Texture', 'voronoi_dimensions', voronoi_dimensions, 'Voronoi', ('1D', '2D', '3D', '4D'))
    node = Node('Voronoi Texture', {'Vector': vector, 'Scale': scale, 'Detail': detail, 'Roughness': roughness, 'Lacunarity': lacunarity, 'Randomness': randomness}, distance=distance, feature=feature, normalize=normalize, voronoi_dimensions=voronoi_dimensions)
    return cls(node._out)

Wavelength(value=0.0, name='Wavelength', min=-3.40282e+38, max=3.40282e+38, tip='', panel='', optional_label=False, hide_value=False, hide_in_modifier=False, default_attribute='', shape='AUTO') classmethod

Wavelength Input

New Float input with subtype 'WAVELENGTH'.

Parameters:

Name	Type	Description	Default
value	object	Default value	`0.0`
name	str	Input socket name	`Wavelength`
min	float	Property min_value	`-3.40282e+38`
max	float	Property max_value	`3.40282e+38`
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`
default_attribute	str	Property default_attribute_name	`''`
shape	str	Property structure_type in ('AUTO', 'SINGLE')	`'AUTO'`

Returns:

Type	Description
Float

Source code in core/generated/float.py

@classmethod
def Wavelength(cls,
    value: object = 0.0,
    name: str = 'Wavelength',
    min: float = -3.40282e+38,
    max: float = 3.40282e+38,
    tip: str = '',
    panel: str = "",
    optional_label: bool = False,
    hide_value: bool = False,
    hide_in_modifier: bool = False,
    default_attribute: str = '',
    shape: Literal['AUTO', 'SINGLE'] = 'AUTO',
     ):
    """ > Wavelength Input

    New Float input with subtype 'WAVELENGTH'.

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

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

    min : float, default=`-3.40282e+38`
        Property min_value

    max : float, default=`3.40282e+38`
        Property max_value

    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

    default_attribute : str, default=`''`
        Property default_attribute_name

    shape : str, default=`'AUTO'`
        Property structure_type in ('AUTO', 'SINGLE')


    Returns
    -------
    Float
    """
    return cls(value=value, name=name, min=min, max=max, tip=tip, panel=panel,
        optional_label=optional_label, hide_value=hide_value, hide_in_modifier=hide_in_modifier,
        default_attribute=default_attribute, shape=shape, subtype='WAVELENGTH')

WhiteNoise(vector=None, noise_dimensions='3D') classmethod

Node White Noise Texture

Parameters:

Name	Type	Description	Default
vector	Vector	socket 'Vector' (id: Vector)	None
noise_dimensions	Literal['1D', '2D', '3D', '4D']	parameter noise_dimensions	'3D'

Returns:

Type	Description
Float

Source code in core/generated/float.py

@classmethod
def WhiteNoise(cls,
                vector: Vector = None,
                noise_dimensions: Literal['1D', '2D', '3D', '4D'] = '3D'):
    """ > Node White Noise Texture

    Parameters
    ----------
    vector : Vector, optional
        socket 'Vector' (id: Vector)

    noise_dimensions : Literal['1D', '2D', '3D', '4D']
        parameter `noise_dimensions`


    Returns
    -------
    Float
    """
    utils.check_enum_arg('White Noise Texture', 'noise_dimensions', noise_dimensions, 'WhiteNoise', ('1D', '2D', '3D', '4D'))
    node = Node('White Noise Texture', {'Vector': vector}, noise_dimensions=noise_dimensions)
    return cls(node._out)

__init__(value=None, name=None, min=-3.40282e+38, max=3.40282e+38, tip='', panel='', **props)

Float Input

New Float input with subtype 'NONE'.

Use methods Percentage, Factor, Angle, Time, TimeAbsolute, Distance, WaveLength, ColorTemperature or Frequency to create input sockets with a subtype.

Parameters:

Name	Type	Description	Default
value	object	Default value	0.0
name	str	Input socket name	'Float'
min	float	Property min_value	-3.40282e+38
max	float	Property max_value	3.40282e+38
tip	str	Property description	''
panel	str	Panel name default="".	''
props	dict	properties	{}

Returns:

Type	Description
Float

Source code in core/sock_float.py

def __init__(self,
    value   = None,
    name    : str = None,
    min     : float = -3.40282e+38,
    max     : float = 3.40282e+38,
    tip     : str = '',
    panel   : str = "",
    **props):
    """ > Float Input

    New Float input with subtype 'NONE'.

    Use methods Percentage, Factor, Angle, Time, TimeAbsolute, Distance, WaveLength, ColorTemperature or Frequency
    to create input sockets with a subtype.

    Parameters
    ----------
    value : object, default=0.0
        Default value

    name : str, default='Float'
        Input socket name

    min : float, default=-3.40282e+38
        Property min_value

    max : float, default=3.40282e+38
        Property max_value

    tip : str, default=''
        Property description

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

    props : dict
        properties


    Returns
    -------
    Float
    """
    super().__init__(value, name, min=min, max=max, tip=tip, panel=panel, **props)

_create_input_socket(value=0.0, name='Float', min=-3.40282e+38, max=3.40282e+38, tip='', panel='', optional_label=False, hide_value=False, hide_in_modifier=False, default_attribute='', shape='AUTO', subtype='NONE') classmethod

Float Input

New Float input with subtype 'NONE'.

Parameters:

Name	Type	Description	Default
value	object	Default value	`0.0`
name	str	Input socket name	`Float`
min	float	Property min_value	`-3.40282e+38`
max	float	Property max_value	`3.40282e+38`
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`
default_attribute	str	Property default_attribute_name	`''`
shape	str	Property structure_type in ('AUTO', 'SINGLE')	`'AUTO'`
subtype	str	Socket sub type in ('NONE', 'PERCENTAGE', 'FACTOR', 'MASS', 'ANGLE', 'TIME', 'TIME_ABSOLUTE', 'DISTANCE', 'WAVELENGTH', 'COLOR_TEMPERATURE', 'FREQUENCY')	`NONE`

Returns:

Type	Description
Float

Source code in core/generated/float.py

@classmethod
def _create_input_socket(cls,
    value: object = 0.0,
    name: str = 'Float',
    min: float = -3.40282e+38,
    max: float = 3.40282e+38,
    tip: str = '',
    panel: str = "",
    optional_label: bool = False,
    hide_value: bool = False,
    hide_in_modifier: bool = False,
    default_attribute: str = '',
    shape: Literal['AUTO', 'SINGLE'] = 'AUTO',
    subtype: str = 'NONE',
     ):
    """ > Float Input

    New Float input with subtype 'NONE'.

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

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

    min : float, default=`-3.40282e+38`
        Property min_value

    max : float, default=`3.40282e+38`
        Property max_value

    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

    default_attribute : str, default=`''`
        Property default_attribute_name

    shape : str, default=`'AUTO'`
        Property structure_type in ('AUTO', 'SINGLE')

    subtype : str, default=`NONE`
        Socket sub type in ('NONE', 'PERCENTAGE', 'FACTOR', 'MASS', 'ANGLE', 'TIME', 'TIME_ABSOLUTE', 'DISTANCE', 'WAVELENGTH', 'COLOR_TEMPERATURE', 'FREQUENCY')


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

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

    return Tree.current_tree().create_input_socket('NodeSocketFloat', default_value = defval, name=name,
        min=min, max=max, tip=tip, panel=panel, optional_label=optional_label, hide_value=hide_value,
        hide_in_modifier=hide_in_modifier, default_attribute=default_attribute, shape=shape,
        subtype=subtype)

_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

abs(use_clamp=False)

Node Math

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	operation	'ABSOLUTE'

Parameters:

Name	Type	Description	Default
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def abs(self, use_clamp = False):
    """ > Node Math

    **Fixed values**

    | Kind      | Name        | Value        |
    | --------- | ----------- | ------------ |
    | Socket    | Value       | `self`       |
    | Parameter | `operation` | `'ABSOLUTE'` |

    Parameters
    ----------
    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    node = Node('Math', {'Value': self}, operation='ABSOLUTE', use_clamp=use_clamp)
    return node._out

acos(use_clamp=False)

Node Math

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	operation	'ARCCOSINE'

Parameters:

Name	Type	Description	Default
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def acos(self, use_clamp = False):
    """ > Node Math

    **Fixed values**

    | Kind      | Name        | Value         |
    | --------- | ----------- | ------------- |
    | Socket    | Value       | `self`        |
    | Parameter | `operation` | `'ARCCOSINE'` |

    Parameters
    ----------
    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    node = Node('Math', {'Value': self}, operation='ARCCOSINE', use_clamp=use_clamp)
    return node._out

add(value=None, use_clamp=False)

Node Math

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	operation	'ADD'

Parameters:

Name	Type	Description	Default
value	Float	socket 'Value' (id: Value_001)	None
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def add(self, value: Float = None, use_clamp = False):
    """ > Node Math

    **Fixed values**

    | Kind      | Name        | Value   |
    | --------- | ----------- | ------- |
    | Socket    | Value       | `self`  |
    | Parameter | `operation` | `'ADD'` |

    Parameters
    ----------
    value : Float, optional
        socket 'Value' (id: Value_001)

    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    node = Node('Math', {'Value': self, 'Value_001': value}, operation='ADD', use_clamp=use_clamp)
    return node._out

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)

advect_grid(velocity=None, time_step=None, integration_scheme=None, limiter=None)

Node Advect Grid

Fixed values

Kind	Name	Value
Socket	Grid	self
Parameter	data_type	'FLOAT'

Parameters:

Name	Type	Description	Default
velocity	Vector	socket 'Velocity' (id: Velocity)	None
time_step	Float	socket 'Time Step' (id: Time Step)	None
integration_scheme	menu='Runge-Kutta 3'	('Semi-Lagrangian', 'Midpoint', 'Runge-Kutta 3', 'Runge-Kutta 4', 'MacCormack', 'BFECC')	None
limiter	menu='Clamp'	('None', 'Clamp', 'Revert')	None

Returns:

Type	Description
Float

Source code in core/generated/float.py

def advect_grid(self,
                velocity: Vector = None,
                time_step: Float = None,
                integration_scheme: Literal['Semi-Lagrangian', 'Midpoint', 'Runge-Kutta 3', 'Runge-Kutta 4', 'MacCormack', 'BFECC'] = None,
                limiter: Literal['None', 'Clamp', 'Revert'] = None):
    """ > Node Advect Grid

    **Fixed values**

    | Kind      | Name        | Value     |
    | --------- | ----------- | --------- |
    | Socket    | Grid        | `self`    |
    | Parameter | `data_type` | `'FLOAT'` |

    Parameters
    ----------
    velocity : Vector, optional
        socket 'Velocity' (id: Velocity)

    time_step : Float, optional
        socket 'Time Step' (id: Time Step)

    integration_scheme : menu='Runge-Kutta 3', optional
        ('Semi-Lagrangian', 'Midpoint', 'Runge-Kutta 3', 'Runge-Kutta 4', 'MacCormack', 'BFECC')

    limiter : menu='Clamp', optional
        ('None', 'Clamp', 'Revert')


    Returns
    -------
    Float
    """
    node = Node('Advect Grid', {'Grid': self, 'Velocity': velocity, 'Time Step': time_step, 'Integration Scheme': integration_scheme, 'Limiter': limiter}, data_type='FLOAT')
    return node._out

arctangent(use_clamp=False)

Node Math

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	operation	'ARCTANGENT'

Parameters:

Name	Type	Description	Default
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def arctangent(self, use_clamp = False):
    """ > Node Math

    **Fixed values**

    | Kind      | Name        | Value          |
    | --------- | ----------- | -------------- |
    | Socket    | Value       | `self`         |
    | Parameter | `operation` | `'ARCTANGENT'` |

    Parameters
    ----------
    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    node = Node('Math', {'Value': self}, operation='ARCTANGENT', use_clamp=use_clamp)
    return node._out

asin(use_clamp=False)

Node Math

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	operation	'ARCSINE'

Parameters:

Name	Type	Description	Default
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def asin(self, use_clamp = False):
    """ > Node Math

    **Fixed values**

    | Kind      | Name        | Value       |
    | --------- | ----------- | ----------- |
    | Socket    | Value       | `self`      |
    | Parameter | `operation` | `'ARCSINE'` |

    Parameters
    ----------
    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    node = Node('Math', {'Value': self}, operation='ARCSINE', use_clamp=use_clamp)
    return node._out

atan2(value=None, use_clamp=False)

Node Math

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	operation	'ARCTAN2'

Parameters:

Name	Type	Description	Default
value	Float	socket 'Value' (id: Value_001)	None
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def atan2(self, value: Float = None, use_clamp = False):
    """ > Node Math

    **Fixed values**

    | Kind      | Name        | Value       |
    | --------- | ----------- | ----------- |
    | Socket    | Value       | `self`      |
    | Parameter | `operation` | `'ARCTAN2'` |

    Parameters
    ----------
    value : Float, optional
        socket 'Value' (id: Value_001)

    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    node = Node('Math', {'Value': self, 'Value_001': value}, operation='ARCTAN2', use_clamp=use_clamp)
    return node._out

bevel(normal=None, samples=4)

Node Bevel

Fixed values

Kind	Name	Value
Socket	Radius	self

Parameters:

Name	Type	Description	Default
normal	Vector	socket 'Normal' (id: Normal)	None
samples	int	parameter samples	4

Returns:

Type	Description
Vector

Source code in core/generated/float.py

def bevel(self, normal: Vector = None, samples = 4):
    """ > Node Bevel

    **Fixed values**

    | Kind   | Name   | Value  |
    | ------ | ------ | ------ |
    | Socket | Radius | `self` |

    Parameters
    ----------
    normal : Vector, optional
        socket 'Normal' (id: Normal)

    samples : int
        parameter `samples`


    Returns
    -------
    Vector
    """
    node = Node('Bevel', {'Radius': self, 'Normal': normal}, samples=samples)
    return node._out

blur(iterations=None, weight=None)

Node Blur Attribute

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	data_type	'FLOAT'

Parameters:

Name	Type	Description	Default
iterations	Integer	socket 'Iterations' (id: Iterations)	None
weight	Float	socket 'Weight' (id: Weight)	None

Returns:

Type	Description
Float

Source code in core/generated/float.py

def blur(self, iterations: Integer = None, weight: Float = None):
    """ > Node Blur Attribute

    **Fixed values**

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

    Parameters
    ----------
    iterations : Integer, optional
        socket 'Iterations' (id: Iterations)

    weight : Float, optional
        socket 'Weight' (id: Weight)


    Returns
    -------
    Float
    """
    node = Node('Blur Attribute', {'Value': self, 'Iterations': iterations, 'Weight': weight}, data_type='FLOAT')
    return node._out

bump(distance=None, filter_width=None, height=None, normal=None, invert=False)

Node Bump

Fixed values

Kind	Name	Value
Socket	Strength	self

Parameters:

Name	Type	Description	Default
distance	Float	socket 'Distance' (id: Distance)	None
filter_width	Float	socket 'Filter Width' (id: Filter Width)	None
height	Float	socket 'Height' (id: Height)	None
normal	Vector	socket 'Normal' (id: Normal)	None
invert	bool	parameter invert	False

Returns:

Type	Description
Vector

Source code in core/generated/float.py

def bump(self,
                distance: Float = None,
                filter_width: Float = None,
                height: Float = None,
                normal: Vector = None,
                invert = False):
    """ > Node Bump

    **Fixed values**

    | Kind   | Name     | Value  |
    | ------ | -------- | ------ |
    | Socket | Strength | `self` |

    Parameters
    ----------
    distance : Float, optional
        socket 'Distance' (id: Distance)

    filter_width : Float, optional
        socket 'Filter Width' (id: Filter Width)

    height : Float, optional
        socket 'Height' (id: Height)

    normal : Vector, optional
        socket 'Normal' (id: Normal)

    invert : bool
        parameter `invert`


    Returns
    -------
    Vector
    """
    node = Node('Bump', {'Strength': self, 'Distance': distance, 'Filter Width': filter_width, 'Height': height, 'Normal': normal}, invert=invert)
    return node._out

ceil(use_clamp=False)

Node Math

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	operation	'CEIL'

Parameters:

Name	Type	Description	Default
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def ceil(self, use_clamp = False):
    """ > Node Math

    **Fixed values**

    | Kind      | Name        | Value    |
    | --------- | ----------- | -------- |
    | Socket    | Value       | `self`   |
    | Parameter | `operation` | `'CEIL'` |

    Parameters
    ----------
    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    node = Node('Math', {'Value': self}, operation='CEIL', use_clamp=use_clamp)
    return node._out

clamp(min=None, max=None, clamp_type='MINMAX')

Node Clamp

Fixed values

Kind	Name	Value
Socket	Value	self

Parameters:

Name	Type	Description	Default
min	Float	socket 'Min' (id: Min)	None
max	Float	socket 'Max' (id: Max)	None
clamp_type	Literal['Min Max', 'Range']	parameter clamp_type	'MINMAX'

Returns:

Type	Description
Float

Source code in core/generated/float.py

def clamp(self,
                min: Float = None,
                max: Float = None,
                clamp_type: Literal['MINMAX', 'RANGE'] = 'MINMAX'):
    """ > Node Clamp

    **Fixed values**

    | Kind   | Name  | Value  |
    | ------ | ----- | ------ |
    | Socket | Value | `self` |

    Parameters
    ----------
    min : Float, optional
        socket 'Min' (id: Min)

    max : Float, optional
        socket 'Max' (id: Max)

    clamp_type : Literal['Min Max', 'Range']
        parameter `clamp_type`


    Returns
    -------
    Float
    """
    utils.check_enum_arg('Clamp', 'clamp_type', clamp_type, 'clamp', ('MINMAX', 'RANGE'))
    node = Node('Clamp', {'Value': self, 'Min': min, 'Max': max}, clamp_type=clamp_type)
    return node._out

clamp_minmax(min=None, max=None)

Node Clamp

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	clamp_type	'MINMAX'

Parameters:

Name	Type	Description	Default
min	Float	socket 'Min' (id: Min)	None
max	Float	socket 'Max' (id: Max)	None

Returns:

Type	Description
Float

Source code in core/generated/float.py

def clamp_minmax(self, min: Float = None, max: Float = None):
    """ > Node Clamp

    **Fixed values**

    | Kind      | Name         | Value      |
    | --------- | ------------ | ---------- |
    | Socket    | Value        | `self`     |
    | Parameter | `clamp_type` | `'MINMAX'` |

    Parameters
    ----------
    min : Float, optional
        socket 'Min' (id: Min)

    max : Float, optional
        socket 'Max' (id: Max)


    Returns
    -------
    Float
    """
    node = Node('Clamp', {'Value': self, 'Min': min, 'Max': max}, clamp_type='MINMAX')
    return node._out

clamp_range(min=None, max=None)

Node Clamp

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	clamp_type	'RANGE'

Parameters:

Name	Type	Description	Default
min	Float	socket 'Min' (id: Min)	None
max	Float	socket 'Max' (id: Max)	None

Returns:

Type	Description
Float

Source code in core/generated/float.py

def clamp_range(self, min: Float = None, max: Float = None):
    """ > Node Clamp

    **Fixed values**

    | Kind      | Name         | Value     |
    | --------- | ------------ | --------- |
    | Socket    | Value        | `self`    |
    | Parameter | `clamp_type` | `'RANGE'` |

    Parameters
    ----------
    min : Float, optional
        socket 'Min' (id: Min)

    max : Float, optional
        socket 'Max' (id: Max)


    Returns
    -------
    Float
    """
    node = Node('Clamp', {'Value': self, 'Min': min, 'Max': max}, clamp_type='RANGE')
    return node._out

clip_grid(min_x=None, min_y=None, min_z=None, max_x=None, max_y=None, max_z=None)

Node Clip Grid

Fixed values

Kind	Name	Value
Socket	Grid	self
Parameter	data_type	'FLOAT'

Parameters:

Name	Type	Description	Default
min_x	Integer	socket 'Min X' (id: Min X)	None
min_y	Integer	socket 'Min Y' (id: Min Y)	None
min_z	Integer	socket 'Min Z' (id: Min Z)	None
max_x	Integer	socket 'Max X' (id: Max X)	None
max_y	Integer	socket 'Max Y' (id: Max Y)	None
max_z	Integer	socket 'Max Z' (id: Max Z)	None

Returns:

Type	Description
Float

Source code in core/generated/float.py

def clip_grid(self,
                min_x: Integer = None,
                min_y: Integer = None,
                min_z: Integer = None,
                max_x: Integer = None,
                max_y: Integer = None,
                max_z: Integer = None):
    """ > Node Clip Grid

    **Fixed values**

    | Kind      | Name        | Value     |
    | --------- | ----------- | --------- |
    | Socket    | Grid        | `self`    |
    | Parameter | `data_type` | `'FLOAT'` |

    Parameters
    ----------
    min_x : Integer, optional
        socket 'Min X' (id: Min X)

    min_y : Integer, optional
        socket 'Min Y' (id: Min Y)

    min_z : Integer, optional
        socket 'Min Z' (id: Min Z)

    max_x : Integer, optional
        socket 'Max X' (id: Max X)

    max_y : Integer, optional
        socket 'Max Y' (id: Max Y)

    max_z : Integer, optional
        socket 'Max Z' (id: Max Z)


    Returns
    -------
    Float
    """
    node = Node('Clip Grid', {'Grid': self, 'Min X': min_x, 'Min Y': min_y, 'Min Z': min_z, 'Max X': max_x, 'Max Y': max_y, 'Max Z': max_z}, data_type='FLOAT')
    return node._out

color_ramp(stops=None, interpolation='LINEAR')

Color Ramp

Node Color Ramp

Parameters:

Name	Type	Description	Default
stops	list[tuple[float, tuple]]	Stops made of (float, color as tuple of floats)	None
interpolation	(EASE, CARDINAL, LINEAR, B_SPLINE, CONSTANT)		'EASE'

Returns:

Type	Description
Color

Source code in core/sock_float.py

def color_ramp(self, stops=None, interpolation='LINEAR'):
    """ > Color Ramp

    > Node Color Ramp

    Parameters
    ----------

    stops : list[tuple[float, tuple]]
        Stops made of (float, color as tuple of floats)

    interpolation : {'EASE', 'CARDINAL', 'LINEAR', 'B_SPLINE', 'CONSTANT'}


    Returns
    -------
    Color
    """
    return ColorRamp(fac=self, stops=stops, interpolation=interpolation)._out

combine_color(green=None, blue=None, mode='RGB')

Node Combine Color

Fixed values

Kind	Name	Value
Socket	Red	self

Parameters:

Name	Type	Description	Default
green	Float	socket 'Green' (id: Green)	None
blue	Float	socket 'Blue' (id: Blue)	None
mode	Literal['RGB', 'HSV', 'HSL']	parameter mode	'RGB'

Returns:

Type	Description
Color

Source code in core/generated/float.py

def combine_color(self,
                green: Float = None,
                blue: Float = None,
                mode: Literal['RGB', 'HSV', 'HSL'] = 'RGB'):
    """ > Node Combine Color

    **Fixed values**

    | Kind   | Name | Value  |
    | ------ | ---- | ------ |
    | Socket | Red  | `self` |

    Parameters
    ----------
    green : Float, optional
        socket 'Green' (id: Green)

    blue : Float, optional
        socket 'Blue' (id: Blue)

    mode : Literal['RGB', 'HSV', 'HSL']
        parameter `mode`


    Returns
    -------
    Color
    """
    utils.check_enum_arg('Combine Color', 'mode', mode, 'combine_color', ('RGB', 'HSV', 'HSL'))
    node = Node('Combine Color', {'Red': self, 'Green': green, 'Blue': blue}, mode=mode)
    return node._out

combine_color_HSL(saturation=None, lightness=None)

Node Combine Color

Fixed values

Kind	Name	Value
Socket	Hue	self
Parameter	mode	'HSL'

Parameters:

Name	Type	Description	Default
saturation	Float	socket 'Saturation' (id: Green)	None
lightness	Float	socket 'Lightness' (id: Blue)	None

Returns:

Type	Description
Color

Source code in core/generated/float.py

def combine_color_HSL(self, saturation: Float = None, lightness: Float = None):
    """ > Node Combine Color

    **Fixed values**

    | Kind      | Name   | Value   |
    | --------- | ------ | ------- |
    | Socket    | Hue    | `self`  |
    | Parameter | `mode` | `'HSL'` |

    Parameters
    ----------
    saturation : Float, optional
        socket 'Saturation' (id: Green)

    lightness : Float, optional
        socket 'Lightness' (id: Blue)


    Returns
    -------
    Color
    """
    node = Node('Combine Color', {'Red': self, 'Green': saturation, 'Blue': lightness}, mode='HSL')
    return node._out

combine_color_HSV(saturation=None, value=None)

Node Combine Color

Fixed values

Kind	Name	Value
Socket	Hue	self
Parameter	mode	'HSV'

Parameters:

Name	Type	Description	Default
saturation	Float	socket 'Saturation' (id: Green)	None
value	Float	socket 'Value' (id: Blue)	None

Returns:

Type	Description
Color

Source code in core/generated/float.py

def combine_color_HSV(self, saturation: Float = None, value: Float = None):
    """ > Node Combine Color

    **Fixed values**

    | Kind      | Name   | Value   |
    | --------- | ------ | ------- |
    | Socket    | Hue    | `self`  |
    | Parameter | `mode` | `'HSV'` |

    Parameters
    ----------
    saturation : Float, optional
        socket 'Saturation' (id: Green)

    value : Float, optional
        socket 'Value' (id: Blue)


    Returns
    -------
    Color
    """
    node = Node('Combine Color', {'Red': self, 'Green': saturation, 'Blue': value}, mode='HSV')
    return node._out

combine_color_RGB(green=None, blue=None)

Node Combine Color

Fixed values

Kind	Name	Value
Socket	Red	self
Parameter	mode	'RGB'

Parameters:

Name	Type	Description	Default
green	Float	socket 'Green' (id: Green)	None
blue	Float	socket 'Blue' (id: Blue)	None

Returns:

Type	Description
Color

Source code in core/generated/float.py

def combine_color_RGB(self, green: Float = None, blue: Float = None):
    """ > Node Combine Color

    **Fixed values**

    | Kind      | Name   | Value   |
    | --------- | ------ | ------- |
    | Socket    | Red    | `self`  |
    | Parameter | `mode` | `'RGB'` |

    Parameters
    ----------
    green : Float, optional
        socket 'Green' (id: Green)

    blue : Float, optional
        socket 'Blue' (id: Blue)


    Returns
    -------
    Color
    """
    node = Node('Combine Color', {'Red': self, 'Green': green, 'Blue': blue}, mode='RGB')
    return node._out

compare(value=None, epsilon=None, use_clamp=False)

Node Math

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	operation	'COMPARE'

Parameters:

Name	Type	Description	Default
value	Float	socket 'Value' (id: Value_001)	None
epsilon	Float	socket 'Epsilon' (id: Value_002)	None
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def compare(self, value: Float = None, epsilon: Float = None, use_clamp = False):
    """ > Node Math

    **Fixed values**

    | Kind      | Name        | Value       |
    | --------- | ----------- | ----------- |
    | Socket    | Value       | `self`      |
    | Parameter | `operation` | `'COMPARE'` |

    Parameters
    ----------
    value : Float, optional
        socket 'Value' (id: Value_001)

    epsilon : Float, optional
        socket 'Epsilon' (id: Value_002)

    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    node = Node('Math', {'Value': self, 'Value_001': value, 'Value_002': epsilon}, operation='COMPARE', use_clamp=use_clamp)
    return node._out

cos(use_clamp=False)

Node Math

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	operation	'COSINE'

Parameters:

Name	Type	Description	Default
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def cos(self, use_clamp = False):
    """ > Node Math

    **Fixed values**

    | Kind      | Name        | Value      |
    | --------- | ----------- | ---------- |
    | Socket    | Value       | `self`     |
    | Parameter | `operation` | `'COSINE'` |

    Parameters
    ----------
    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    node = Node('Math', {'Value': self}, operation='COSINE', use_clamp=use_clamp)
    return node._out

cosh(use_clamp=False)

Node Math

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	operation	'COSH'

Parameters:

Name	Type	Description	Default
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def cosh(self, use_clamp = False):
    """ > Node Math

    **Fixed values**

    | Kind      | Name        | Value    |
    | --------- | ----------- | -------- |
    | Socket    | Value       | `self`   |
    | Parameter | `operation` | `'COSH'` |

    Parameters
    ----------
    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    node = Node('Math', {'Value': self}, operation='COSH', use_clamp=use_clamp)
    return node._out

curve(factor=None, curve=None)

Node Float Curve

A curve is defined by a list of 3-tuples (not list):

• x (float) : x position
• y (float) : y position
• handle_type (str) : handle type in ('AUTO', 'AUTO_CLAMPED', 'VECTOR'), default='AUTO'

Information

• Socket 'Value' : self

Parameters:

Name	Type	Description	Default
factor	Float	socket 'Factor' (id: Factor)	None
curve	list[tuple[float, float, str]]	Curve points	None

Returns:

Type	Description
Float

Source code in core/sock_float.py

def curve(self, factor=None, curve=None):
    """ > Node Float Curve

    A curve is defined by a list of 3-tuples (not list):

    - x (float) : x position
    - y (float) : y position
    - handle_type (str) : handle type in ('AUTO', 'AUTO_CLAMPED', 'VECTOR'), default='AUTO'

    Information
    -----------
    - Socket 'Value' : self

    Parameters
    ----------
    factor : Float
        socket 'Factor' (id: Factor)

    curve : list[tuple[float, float, str]]
        Curve points

    Returns
    -------
    Float
    """
    node = NodeCurves('Float Curve', named_sockets={'Value': self, 'Factor': factor})
    node.set_curves(curve)
    return node._out

degrees(use_clamp=False)

Node Math

Fixed values

Kind	Name	Value
Socket	Radians	self
Parameter	operation	'DEGREES'

Parameters:

Name	Type	Description	Default
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def degrees(self, use_clamp = False):
    """ > Node Math

    **Fixed values**

    | Kind      | Name        | Value       |
    | --------- | ----------- | ----------- |
    | Socket    | Radians     | `self`      |
    | Parameter | `operation` | `'DEGREES'` |

    Parameters
    ----------
    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    node = Node('Math', {'Value': self}, operation='DEGREES', use_clamp=use_clamp)
    return node._out

dial_gizmo(*value, position=None, up=None, screen_space=None, radius=None, color_id='PRIMARY')

Node Dial Gizmo

Parameters:

Name	Type	Description	Default
value	Float	socket 'Value' (id: Value)	()
position	Vector	socket 'Position' (id: Position)	None
up	Vector	socket 'Up' (id: Up)	None
screen_space	Boolean	socket 'Screen Space' (id: Screen Space)	None
radius	Float	socket 'Radius' (id: Radius)	None
color_id	Literal['Primary', 'Secondary', 'X', 'Y', 'Z']	parameter color_id	'PRIMARY'

Returns:

Type	Description
Geometry

Source code in core/generated/float.py

def dial_gizmo(self,
                *value: Float,
                position: Vector = None,
                up: Vector = None,
                screen_space: Boolean = None,
                radius: Float = None,
                color_id: Literal['PRIMARY', 'SECONDARY', 'X', 'Y', 'Z'] = 'PRIMARY'):
    """ > Node Dial Gizmo

    Parameters
    ----------
    value : Float, optional
        socket 'Value' (id: Value)

    position : Vector, optional
        socket 'Position' (id: Position)

    up : Vector, optional
        socket 'Up' (id: Up)

    screen_space : Boolean, optional
        socket 'Screen Space' (id: Screen Space)

    radius : Float, optional
        socket 'Radius' (id: Radius)

    color_id : Literal['Primary', 'Secondary', 'X', 'Y', 'Z']
        parameter `color_id`


    Returns
    -------
    Geometry
    """
    utils.check_enum_arg('Dial Gizmo', 'color_id', color_id, 'dial_gizmo', ('PRIMARY', 'SECONDARY', 'X', 'Y', 'Z'))
    node = Node('Dial Gizmo', {'Value': [self] + list(value), 'Position': position, 'Up': up, 'Screen Space': screen_space, 'Radius': radius}, color_id=color_id)
    return node._out

displacement(midlevel=None, scale=None, normal=None, space='OBJECT')

Node Displacement

Fixed values

Kind	Name	Value
Socket	Height	self

Parameters:

Name	Type	Description	Default
midlevel	Float	socket 'Midlevel' (id: Midlevel)	None
scale	Float	socket 'Scale' (id: Scale)	None
normal	Vector	socket 'Normal' (id: Normal)	None
space	Literal['Object Space', 'World Space']	parameter space	'OBJECT'

Returns:

Type	Description
Vector

Source code in core/generated/float.py

def displacement(self,
                midlevel: Float = None,
                scale: Float = None,
                normal: Vector = None,
                space: Literal['OBJECT', 'WORLD'] = 'OBJECT'):
    """ > Node Displacement

    **Fixed values**

    | Kind   | Name   | Value  |
    | ------ | ------ | ------ |
    | Socket | Height | `self` |

    Parameters
    ----------
    midlevel : Float, optional
        socket 'Midlevel' (id: Midlevel)

    scale : Float, optional
        socket 'Scale' (id: Scale)

    normal : Vector, optional
        socket 'Normal' (id: Normal)

    space : Literal['Object Space', 'World Space']
        parameter `space`


    Returns
    -------
    Vector
    """
    utils.check_enum_arg('Displacement', 'space', space, 'displacement', ('OBJECT', 'WORLD'))
    node = Node('Displacement', {'Height': self, 'Midlevel': midlevel, 'Scale': scale, 'Normal': normal}, space=space)
    return node._out

distribute_points_in_grid(density=None, seed=None, mode='DENSITY_RANDOM')

Node Distribute Points in Grid

Fixed values

Kind	Name	Value
Socket	Grid	self

Parameters:

Name	Type	Description	Default
density	Float	socket 'Density' (id: Density)	None
seed	Integer	socket 'Seed' (id: Seed)	None
mode	Literal['Random', 'Grid']	parameter mode	'DENSITY_RANDOM'

Returns:

Type	Description
Cloud

Source code in core/generated/float.py

def distribute_points_in_grid(self,
                density: Float = None,
                seed: Integer = None,
                mode: Literal['DENSITY_RANDOM', 'DENSITY_GRID'] = 'DENSITY_RANDOM'):
    """ > Node Distribute Points in Grid

    **Fixed values**

    | Kind   | Name | Value  |
    | ------ | ---- | ------ |
    | Socket | Grid | `self` |

    Parameters
    ----------
    density : Float, optional
        socket 'Density' (id: Density)

    seed : Integer, optional
        socket 'Seed' (id: Seed)

    mode : Literal['Random', 'Grid']
        parameter `mode`


    Returns
    -------
    Cloud
    """
    utils.check_enum_arg('Distribute Points in Grid', 'mode', mode, 'distribute_points_in_grid', ('DENSITY_RANDOM', 'DENSITY_GRID'))
    node = Node('Distribute Points in Grid', {'Grid': self, 'Density': density, 'Seed': seed}, mode=mode)
    return node._out

distribute_points_in_grid_density_grid(spacing=None, threshold=None)

Node Distribute Points in Grid

Fixed values

Kind	Name	Value
Socket	Grid	self
Parameter	mode	'DENSITY_GRID'

Parameters:

Name	Type	Description	Default
spacing	Vector	socket 'Spacing' (id: Spacing)	None
threshold	Float	socket 'Threshold' (id: Threshold)	None

Returns:

Type	Description
Cloud

Source code in core/generated/float.py

def distribute_points_in_grid_density_grid(self, spacing: Vector = None, threshold: Float = None):
    """ > Node Distribute Points in Grid

    **Fixed values**

    | Kind      | Name   | Value            |
    | --------- | ------ | ---------------- |
    | Socket    | Grid   | `self`           |
    | Parameter | `mode` | `'DENSITY_GRID'` |

    Parameters
    ----------
    spacing : Vector, optional
        socket 'Spacing' (id: Spacing)

    threshold : Float, optional
        socket 'Threshold' (id: Threshold)


    Returns
    -------
    Cloud
    """
    node = Node('Distribute Points in Grid', {'Grid': self, 'Spacing': spacing, 'Threshold': threshold}, mode='DENSITY_GRID')
    return node._out

distribute_points_in_grid_density_random(density=None, seed=None)

Node Distribute Points in Grid

Fixed values

Kind	Name	Value
Socket	Grid	self
Parameter	mode	'DENSITY_RANDOM'

Parameters:

Name	Type	Description	Default
density	Float	socket 'Density' (id: Density)	None
seed	Integer	socket 'Seed' (id: Seed)	None

Returns:

Type	Description
Cloud

Source code in core/generated/float.py

def distribute_points_in_grid_density_random(self, density: Float = None, seed: Integer = None):
    """ > Node Distribute Points in Grid

    **Fixed values**

    | Kind      | Name   | Value              |
    | --------- | ------ | ------------------ |
    | Socket    | Grid   | `self`             |
    | Parameter | `mode` | `'DENSITY_RANDOM'` |

    Parameters
    ----------
    density : Float, optional
        socket 'Density' (id: Density)

    seed : Integer, optional
        socket 'Seed' (id: Seed)


    Returns
    -------
    Cloud
    """
    node = Node('Distribute Points in Grid', {'Grid': self, 'Density': density, 'Seed': seed}, mode='DENSITY_RANDOM')
    return node._out

divide(value=None, use_clamp=False)

Node Math

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	operation	'DIVIDE'

Parameters:

Name	Type	Description	Default
value	Float	socket 'Value' (id: Value_001)	None
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def divide(self, value: Float = None, use_clamp = False):
    """ > Node Math

    **Fixed values**

    | Kind      | Name        | Value      |
    | --------- | ----------- | ---------- |
    | Socket    | Value       | `self`     |
    | Parameter | `operation` | `'DIVIDE'` |

    Parameters
    ----------
    value : Float, optional
        socket 'Value' (id: Value_001)

    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    node = Node('Math', {'Value': self, 'Value_001': value}, operation='DIVIDE', use_clamp=use_clamp)
    return node._out

enable_output(enable=None)

Node Enable Output

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	data_type	'FLOAT'

Parameters:

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

Returns:

Type	Description
Float

Source code in core/generated/float.py

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

    **Fixed values**

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

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


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

equal(b=None, epsilon=None)

Node Compare

Fixed values

Kind	Name	Value
Socket	A	self
Parameter	data_type	'FLOAT'
Parameter	mode	'ELEMENT'
Parameter	operation	'EQUAL'

Parameters:

Name	Type	Description	Default
b	Float	socket 'B' (id: B)	None
epsilon	Float	socket 'Epsilon' (id: Epsilon)	None

Returns:

Type	Description
Boolean

Source code in core/generated/float.py

def equal(self, b: Float = None, epsilon: Float = None):
    """ > Node Compare

    **Fixed values**

    | Kind      | Name        | Value       |
    | --------- | ----------- | ----------- |
    | Socket    | A           | `self`      |
    | Parameter | `data_type` | `'FLOAT'`   |
    | Parameter | `mode`      | `'ELEMENT'` |
    | Parameter | `operation` | `'EQUAL'`   |

    Parameters
    ----------
    b : Float, optional
        socket 'B' (id: B)

    epsilon : Float, optional
        socket 'Epsilon' (id: Epsilon)


    Returns
    -------
    Boolean
    """
    node = Node('Compare', {'A': self, 'B': b, 'Epsilon': epsilon}, data_type='FLOAT', mode='ELEMENT', operation='EQUAL')
    return node._out

exp(use_clamp=False)

Node Math

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	operation	'EXPONENT'

Parameters:

Name	Type	Description	Default
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def exp(self, use_clamp = False):
    """ > Node Math

    **Fixed values**

    | Kind      | Name        | Value        |
    | --------- | ----------- | ------------ |
    | Socket    | Value       | `self`       |
    | Parameter | `operation` | `'EXPONENT'` |

    Parameters
    ----------
    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    node = Node('Math', {'Value': self}, operation='EXPONENT', use_clamp=use_clamp)
    return node._out

field_to_grid(named_sockets={}, **sockets)

Node Field to Grid

Fixed values

Kind	Name	Value
Socket	Topology	self
Parameter	data_type	'FLOAT'

Parameters:

Name	Type	Description	Default
named_sockets	dict	Sockets created with string names	{}
sockets	dict	Socket created with python name attributes	{}

Returns:

Type	Description
None

Source code in core/generated/float.py

def field_to_grid(self, named_sockets: dict = {}, **sockets):
    """ > Node Field to Grid

    **Fixed values**

    | Kind      | Name        | Value     |
    | --------- | ----------- | --------- |
    | Socket    | Topology    | `self`    |
    | Parameter | `data_type` | `'FLOAT'` |

    Parameters
    ----------
    named_sockets : dict, default={}
        Sockets created with string names

    sockets : dict, default={}
        Socket created with python name attributes

    Returns
    -------
    None
    """
    node = Node('Field to Grid', {'Topology': self, **named_sockets}, data_type='FLOAT', **sockets)
    return node._out

floor(use_clamp=False)

Node Math

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	operation	'FLOOR'

Parameters:

Name	Type	Description	Default
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def floor(self, use_clamp = False):
    """ > Node Math

    **Fixed values**

    | Kind      | Name        | Value     |
    | --------- | ----------- | --------- |
    | Socket    | Value       | `self`    |
    | Parameter | `operation` | `'FLOOR'` |

    Parameters
    ----------
    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    node = Node('Math', {'Value': self}, operation='FLOOR', use_clamp=use_clamp)
    return node._out

floored_modulo(value=None, use_clamp=False)

Node Math

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	operation	'FLOORED_MODULO'

Parameters:

Name	Type	Description	Default
value	Float	socket 'Value' (id: Value_001)	None
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def floored_modulo(self, value: Float = None, use_clamp = False):
    """ > Node Math

    **Fixed values**

    | Kind      | Name        | Value              |
    | --------- | ----------- | ------------------ |
    | Socket    | Value       | `self`             |
    | Parameter | `operation` | `'FLOORED_MODULO'` |

    Parameters
    ----------
    value : Float, optional
        socket 'Value' (id: Value_001)

    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    node = Node('Math', {'Value': self, 'Value_001': value}, operation='FLOORED_MODULO', use_clamp=use_clamp)
    return node._out

fract(use_clamp=False)

Node Math

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	operation	'FRACT'

Parameters:

Name	Type	Description	Default
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def fract(self, use_clamp = False):
    """ > Node Math

    **Fixed values**

    | Kind      | Name        | Value     |
    | --------- | ----------- | --------- |
    | Socket    | Value       | `self`    |
    | Parameter | `operation` | `'FRACT'` |

    Parameters
    ----------
    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    node = Node('Math', {'Value': self}, operation='FRACT', use_clamp=use_clamp)
    return node._out

frame()

Node Scene Time

Returns:

Type	Description
frame

Source code in core/generated/float.py

@utils.classproperty
def frame(cls):
    """ > Node Scene Time

    Returns
    -------
    frame
    """
    node = Node('Scene Time', )
    return node.frame

fresnel(normal=None)

Node Fresnel

Fixed values

Kind	Name	Value
Socket	IOR	self

Parameters:

Name	Type	Description	Default
normal	Vector	socket 'Normal' (id: Normal)	None

Returns:

Type	Description
Float

Source code in core/generated/float.py

def fresnel(self, normal: Vector = None):
    """ > Node Fresnel

    **Fixed values**

    | Kind   | Name | Value  |
    | ------ | ---- | ------ |
    | Socket | IOR  | `self` |

    Parameters
    ----------
    normal : Vector, optional
        socket 'Normal' (id: Normal)


    Returns
    -------
    Float
    """
    node = Node('Fresnel', {'IOR': self, 'Normal': normal})
    return node._out

greater_equal(b=None)

Node Compare

Fixed values

Kind	Name	Value
Socket	A	self
Parameter	data_type	'FLOAT'
Parameter	mode	'ELEMENT'
Parameter	operation	'GREATER_EQUAL'

Parameters:

Name	Type	Description	Default
b	Float	socket 'B' (id: B)	None

Returns:

Type	Description
Boolean

Source code in core/generated/float.py

def greater_equal(self, b: Float = None):
    """ > Node Compare

    **Fixed values**

    | Kind      | Name        | Value             |
    | --------- | ----------- | ----------------- |
    | Socket    | A           | `self`            |
    | Parameter | `data_type` | `'FLOAT'`         |
    | Parameter | `mode`      | `'ELEMENT'`       |
    | Parameter | `operation` | `'GREATER_EQUAL'` |

    Parameters
    ----------
    b : Float, optional
        socket 'B' (id: B)


    Returns
    -------
    Boolean
    """
    node = Node('Compare', {'A': self, 'B': b}, data_type='FLOAT', mode='ELEMENT', operation='GREATER_EQUAL')
    return node._out

greater_than(b=None)

Node Compare

Fixed values

Kind	Name	Value
Socket	A	self
Parameter	data_type	'FLOAT'
Parameter	mode	'ELEMENT'
Parameter	operation	'GREATER_THAN'

Parameters:

Name	Type	Description	Default
b	Float	socket 'B' (id: B)	None

Returns:

Type	Description
Boolean

Source code in core/generated/float.py

def greater_than(self, b: Float = None):
    """ > Node Compare

    **Fixed values**

    | Kind      | Name        | Value            |
    | --------- | ----------- | ---------------- |
    | Socket    | A           | `self`           |
    | Parameter | `data_type` | `'FLOAT'`        |
    | Parameter | `mode`      | `'ELEMENT'`      |
    | Parameter | `operation` | `'GREATER_THAN'` |

    Parameters
    ----------
    b : Float, optional
        socket 'B' (id: B)


    Returns
    -------
    Boolean
    """
    node = Node('Compare', {'A': self, 'B': b}, data_type='FLOAT', mode='ELEMENT', operation='GREATER_THAN')
    return node._out

grid_dilate_erode(connectivity=None, tiles=None, steps=None)

Node Grid Dilate & Erode

Fixed values

Kind	Name	Value
Socket	Grid	self
Parameter	data_type	'FLOAT'

Parameters:

Name	Type	Description	Default
connectivity	menu='Face'	('Face', 'Edge', 'Vertex')	None
tiles	menu='Preserve'	('Ignore', 'Expand', 'Preserve')	None
steps	Integer	socket 'Steps' (id: Steps)	None

Returns:

Type	Description
Float

Source code in core/generated/float.py

def grid_dilate_erode(self,
                connectivity: Literal['Face', 'Edge', 'Vertex'] = None,
                tiles: Literal['Ignore', 'Expand', 'Preserve'] = None,
                steps: Integer = None):
    """ > Node Grid Dilate & Erode

    **Fixed values**

    | Kind      | Name        | Value     |
    | --------- | ----------- | --------- |
    | Socket    | Grid        | `self`    |
    | Parameter | `data_type` | `'FLOAT'` |

    Parameters
    ----------
    connectivity : menu='Face', optional
        ('Face', 'Edge', 'Vertex')

    tiles : menu='Preserve', optional
        ('Ignore', 'Expand', 'Preserve')

    steps : Integer, optional
        socket 'Steps' (id: Steps)


    Returns
    -------
    Float
    """
    node = Node('Grid Dilate & Erode', {'Grid': self, 'Connectivity': connectivity, 'Tiles': tiles, 'Steps': steps}, data_type='FLOAT')
    return node._out

grid_gradient()

Node Grid Gradient

Fixed values

Kind	Name	Value
Socket	Grid	self

Returns:

Type	Description
Vector

Source code in core/generated/float.py

def grid_gradient(self):
    """ > Node Grid Gradient

    **Fixed values**

    | Kind   | Name | Value  |
    | ------ | ---- | ------ |
    | Socket | Grid | `self` |

    Returns
    -------
    Vector
    """
    node = Node('Grid Gradient', {'Grid': self})
    return node._out

grid_info()

Node Grid Info

Fixed values

Kind	Name	Value
Socket	Grid	self
Parameter	data_type	'FLOAT'

Returns:

Type	Description
Matrix	peer sockets: background_value_ (Float)

Source code in core/generated/float.py

def grid_info(self):
    """ > Node Grid Info

    **Fixed values**

    | Kind      | Name        | Value     |
    | --------- | ----------- | --------- |
    | Socket    | Grid        | `self`    |
    | Parameter | `data_type` | `'FLOAT'` |

    Returns
    -------
    Matrix
        peer sockets: background_value_ (Float)

    """
    node = Node('Grid Info', {'Grid': self}, data_type='FLOAT')
    return node._out

grid_laplacian()

Node Grid Laplacian

Fixed values

Kind	Name	Value
Socket	Grid	self

Returns:

Type	Description
Float

Source code in core/generated/float.py

def grid_laplacian(self):
    """ > Node Grid Laplacian

    **Fixed values**

    | Kind   | Name | Value  |
    | ------ | ---- | ------ |
    | Socket | Grid | `self` |

    Returns
    -------
    Float
    """
    node = Node('Grid Laplacian', {'Grid': self})
    return node._out

grid_mean(width=None, iterations=None)

Node Grid Mean

Fixed values

Kind	Name	Value
Socket	Grid	self
Parameter	data_type	'FLOAT'

Parameters:

Name	Type	Description	Default
width	Integer	socket 'Width' (id: Width)	None
iterations	Integer	socket 'Iterations' (id: Iterations)	None

Returns:

Type	Description
Float

Source code in core/generated/float.py

def grid_mean(self, width: Integer = None, iterations: Integer = None):
    """ > Node Grid Mean

    **Fixed values**

    | Kind      | Name        | Value     |
    | --------- | ----------- | --------- |
    | Socket    | Grid        | `self`    |
    | Parameter | `data_type` | `'FLOAT'` |

    Parameters
    ----------
    width : Integer, optional
        socket 'Width' (id: Width)

    iterations : Integer, optional
        socket 'Iterations' (id: Iterations)


    Returns
    -------
    Float
    """
    node = Node('Grid Mean', {'Grid': self, 'Width': width, 'Iterations': iterations}, data_type='FLOAT')
    return node._out

grid_median(width=None, iterations=None)

Node Grid Median

Fixed values

Kind	Name	Value
Socket	Grid	self
Parameter	data_type	'FLOAT'

Parameters:

Name	Type	Description	Default
width	Integer	socket 'Width' (id: Width)	None
iterations	Integer	socket 'Iterations' (id: Iterations)	None

Returns:

Type	Description
Float

Source code in core/generated/float.py

def grid_median(self, width: Integer = None, iterations: Integer = None):
    """ > Node Grid Median

    **Fixed values**

    | Kind      | Name        | Value     |
    | --------- | ----------- | --------- |
    | Socket    | Grid        | `self`    |
    | Parameter | `data_type` | `'FLOAT'` |

    Parameters
    ----------
    width : Integer, optional
        socket 'Width' (id: Width)

    iterations : Integer, optional
        socket 'Iterations' (id: Iterations)


    Returns
    -------
    Float
    """
    node = Node('Grid Median', {'Grid': self, 'Width': width, 'Iterations': iterations}, data_type='FLOAT')
    return node._out

grid_to_mesh(threshold=None, adaptivity=None)

Node Grid to Mesh

Fixed values

Kind	Name	Value
Socket	Grid	self

Parameters:

Name	Type	Description	Default
threshold	Float	socket 'Threshold' (id: Threshold)	None
adaptivity	Float	socket 'Adaptivity' (id: Adaptivity)	None

Returns:

Type	Description
Mesh

Source code in core/generated/float.py

def grid_to_mesh(self, threshold: Float = None, adaptivity: Float = None):
    """ > Node Grid to Mesh

    **Fixed values**

    | Kind   | Name | Value  |
    | ------ | ---- | ------ |
    | Socket | Grid | `self` |

    Parameters
    ----------
    threshold : Float, optional
        socket 'Threshold' (id: Threshold)

    adaptivity : Float, optional
        socket 'Adaptivity' (id: Adaptivity)


    Returns
    -------
    Mesh
    """
    node = Node('Grid to Mesh', {'Grid': self, 'Threshold': threshold, 'Adaptivity': adaptivity})
    return node._out

grid_to_points()

Node Grid to Points

Fixed values

Kind	Name	Value
Socket	Grid	self
Parameter	data_type	'FLOAT'

Returns:

Type	Description
Cloud	peer sockets: value_ (Float), x_ (Integer), y_ (Integer), z_ (Integer), is_tile_ (Boolean), extent_ (Integer)

Source code in core/generated/float.py

def grid_to_points(self):
    """ > Node Grid to Points

    **Fixed values**

    | Kind      | Name        | Value     |
    | --------- | ----------- | --------- |
    | Socket    | Grid        | `self`    |
    | Parameter | `data_type` | `'FLOAT'` |

    Returns
    -------
    Cloud
        peer sockets: value_ (Float), x_ (Integer), y_ (Integer), z_ (Integer), is_tile_ (Boolean), extent_ (Integer)

    """
    node = Node('Grid to Points', {'Grid': self}, data_type='FLOAT')
    return node._out

hash_value(seed=None)

Node Hash Value

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	data_type	'FLOAT'

Parameters:

Name	Type	Description	Default
seed	Integer	socket 'Seed' (id: Seed)	None

Returns:

Type	Description
Integer

Source code in core/generated/float.py

def hash_value(self, seed: Integer = None):
    """ > Node Hash Value

    **Fixed values**

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

    Parameters
    ----------
    seed : Integer, optional
        socket 'Seed' (id: Seed)


    Returns
    -------
    Integer
    """
    node = Node('Hash Value', {'Value': self, 'Seed': seed}, data_type='FLOAT')
    return node._out

hue_saturation_value(saturation=None, value=None, color=None, factor=None)

Node Hue/Saturation/Value

Fixed values

Kind	Name	Value
Socket	Hue	self

Parameters:

Name	Type	Description	Default
saturation	Float	socket 'Saturation' (id: Saturation)	None
value	Float	socket 'Value' (id: Value)	None
color	Color	socket 'Color' (id: Color)	None
factor	Float	socket 'Factor' (id: Fac)	None

Returns:

Type	Description
Color

Source code in core/generated/float.py

def hue_saturation_value(self,
                saturation: Float = None,
                value: Float = None,
                color: Color = None,
                factor: Float = None):
    """ > Node Hue/Saturation/Value

    **Fixed values**

    | Kind   | Name | Value  |
    | ------ | ---- | ------ |
    | Socket | Hue  | `self` |

    Parameters
    ----------
    saturation : Float, optional
        socket 'Saturation' (id: Saturation)

    value : Float, optional
        socket 'Value' (id: Value)

    color : Color, optional
        socket 'Color' (id: Color)

    factor : Float, optional
        socket 'Factor' (id: Fac)


    Returns
    -------
    Color
    """
    node = Node('Hue/Saturation/Value', {'Hue': self, 'Saturation': saturation, 'Value': value, 'Color': color, 'Fac': factor})
    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)

inverse_sqrt(use_clamp=False)

Node Math

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	operation	'INVERSE_SQRT'

Parameters:

Name	Type	Description	Default
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def inverse_sqrt(self, use_clamp = False):
    """ > Node Math

    **Fixed values**

    | Kind      | Name        | Value            |
    | --------- | ----------- | ---------------- |
    | Socket    | Value       | `self`           |
    | Parameter | `operation` | `'INVERSE_SQRT'` |

    Parameters
    ----------
    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    node = Node('Math', {'Value': self}, operation='INVERSE_SQRT', use_clamp=use_clamp)
    return node._out

layer_weight(normal=None)

Node Layer Weight

Fixed values

Kind	Name	Value
Socket	Blend	self

Parameters:

Name	Type	Description	Default
normal	Vector	socket 'Normal' (id: Normal)	None

Returns:

Type	Description
Float	peer sockets: facing_ (Float)

Source code in core/generated/float.py

def layer_weight(self, normal: Vector = None):
    """ > Node Layer Weight

    **Fixed values**

    | Kind   | Name  | Value  |
    | ------ | ----- | ------ |
    | Socket | Blend | `self` |

    Parameters
    ----------
    normal : Vector, optional
        socket 'Normal' (id: Normal)


    Returns
    -------
    Float
        peer sockets: facing_ (Float)

    """
    node = Node('Layer Weight', {'Blend': self, 'Normal': normal})
    return node._out

less_equal(b=None)

Node Compare

Fixed values

Kind	Name	Value
Socket	A	self
Parameter	data_type	'FLOAT'
Parameter	mode	'ELEMENT'
Parameter	operation	'LESS_EQUAL'

Parameters:

Name	Type	Description	Default
b	Float	socket 'B' (id: B)	None

Returns:

Type	Description
Boolean

Source code in core/generated/float.py

def less_equal(self, b: Float = None):
    """ > Node Compare

    **Fixed values**

    | Kind      | Name        | Value          |
    | --------- | ----------- | -------------- |
    | Socket    | A           | `self`         |
    | Parameter | `data_type` | `'FLOAT'`      |
    | Parameter | `mode`      | `'ELEMENT'`    |
    | Parameter | `operation` | `'LESS_EQUAL'` |

    Parameters
    ----------
    b : Float, optional
        socket 'B' (id: B)


    Returns
    -------
    Boolean
    """
    node = Node('Compare', {'A': self, 'B': b}, data_type='FLOAT', mode='ELEMENT', operation='LESS_EQUAL')
    return node._out

less_than(b=None)

Node Compare

Fixed values

Kind	Name	Value
Socket	A	self
Parameter	data_type	'FLOAT'
Parameter	mode	'ELEMENT'
Parameter	operation	'LESS_THAN'

Parameters:

Name	Type	Description	Default
b	Float	socket 'B' (id: B)	None

Returns:

Type	Description
Boolean

Source code in core/generated/float.py

def less_than(self, b: Float = None):
    """ > Node Compare

    **Fixed values**

    | Kind      | Name        | Value         |
    | --------- | ----------- | ------------- |
    | Socket    | A           | `self`        |
    | Parameter | `data_type` | `'FLOAT'`     |
    | Parameter | `mode`      | `'ELEMENT'`   |
    | Parameter | `operation` | `'LESS_THAN'` |

    Parameters
    ----------
    b : Float, optional
        socket 'B' (id: B)


    Returns
    -------
    Boolean
    """
    node = Node('Compare', {'A': self, 'B': b}, data_type='FLOAT', mode='ELEMENT', operation='LESS_THAN')
    return node._out

light_falloff(smooth=None)

Node Light Falloff

Fixed values

Kind	Name	Value
Socket	Strength	self

Parameters:

Name	Type	Description	Default
smooth	Float	socket 'Smooth' (id: Smooth)	None

Returns:

Type	Description
Float	peer sockets: linear_ (Float), constant_ (Float)

Source code in core/generated/float.py

def light_falloff(self, smooth: Float = None):
    """ > Node Light Falloff

    **Fixed values**

    | Kind   | Name     | Value  |
    | ------ | -------- | ------ |
    | Socket | Strength | `self` |

    Parameters
    ----------
    smooth : Float, optional
        socket 'Smooth' (id: Smooth)


    Returns
    -------
    Float
        peer sockets: linear_ (Float), constant_ (Float)

    """
    node = Node('Light Falloff', {'Strength': self, 'Smooth': smooth})
    return node._out

linear_gizmo(*value, position=None, direction=None, color_id='PRIMARY', draw_style='ARROW')

Node Linear Gizmo

Parameters:

Name	Type	Description	Default
value	Float	socket 'Value' (id: Value)	()
position	Vector	socket 'Position' (id: Position)	None
direction	Vector	socket 'Direction' (id: Direction)	None
color_id	Literal['Primary', 'Secondary', 'X', 'Y', 'Z']	parameter color_id	'PRIMARY'
draw_style	Literal['Arrow', 'Cross', 'Box']	parameter draw_style	'ARROW'

Returns:

Type	Description
Geometry

Source code in core/generated/float.py

def linear_gizmo(self,
                *value: Float,
                position: Vector = None,
                direction: Vector = None,
                color_id: Literal['PRIMARY', 'SECONDARY', 'X', 'Y', 'Z'] = 'PRIMARY',
                draw_style: Literal['ARROW', 'CROSS', 'BOX'] = 'ARROW'):
    """ > Node Linear Gizmo

    Parameters
    ----------
    value : Float, optional
        socket 'Value' (id: Value)

    position : Vector, optional
        socket 'Position' (id: Position)

    direction : Vector, optional
        socket 'Direction' (id: Direction)

    color_id : Literal['Primary', 'Secondary', 'X', 'Y', 'Z']
        parameter `color_id`

    draw_style : Literal['Arrow', 'Cross', 'Box']
        parameter `draw_style`


    Returns
    -------
    Geometry
    """
    utils.check_enum_arg('Linear Gizmo', 'color_id', color_id, 'linear_gizmo', ('PRIMARY', 'SECONDARY', 'X', 'Y', 'Z'))
    utils.check_enum_arg('Linear Gizmo', 'draw_style', draw_style, 'linear_gizmo', ('ARROW', 'CROSS', 'BOX'))
    node = Node('Linear Gizmo', {'Value': [self] + list(value), 'Position': position, 'Direction': direction}, color_id=color_id, draw_style=draw_style)
    return node._out

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

log(base=None, use_clamp=False)

Node Math

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	operation	'LOGARITHM'

Parameters:

Name	Type	Description	Default
base	Float	socket 'Base' (id: Value_001)	None
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def log(self, base: Float = None, use_clamp = False):
    """ > Node Math

    **Fixed values**

    | Kind      | Name        | Value         |
    | --------- | ----------- | ------------- |
    | Socket    | Value       | `self`        |
    | Parameter | `operation` | `'LOGARITHM'` |

    Parameters
    ----------
    base : Float, optional
        socket 'Base' (id: Value_001)

    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    node = Node('Math', {'Value': self, 'Value_001': base}, operation='LOGARITHM', use_clamp=use_clamp)
    return node._out

map_range(from_min=None, from_max=None, to_min=None, to_max=None, clamp=True, interpolation_type='LINEAR')

Node Map Range

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	data_type	from from_min type

Parameters:

Name	Type	Description	Default
from_min	Float | Vector	socket 'From Min' (id: From Min)	None
from_max	Float | Vector	socket 'From Max' (id: From Max)	None
to_min	Float | Vector	socket 'To Min' (id: To Min)	None
to_max	Float | Vector	socket 'To Max' (id: To Max)	None
clamp	bool	parameter clamp	True
interpolation_type	Literal['Linear', 'Stepped Linear', 'Smooth Step', 'Smoother Step']	parameter interpolation_type	'LINEAR'

Returns:

Type	Description
Float

Source code in core/generated/float.py

def map_range(self,
                from_min: Float | Vector = None,
                from_max: Float | Vector = None,
                to_min: Float | Vector = None,
                to_max: Float | Vector = None,
                clamp = True,
                interpolation_type: Literal['LINEAR', 'STEPPED', 'SMOOTHSTEP', 'SMOOTHERSTEP'] = 'LINEAR'):
    """ > Node Map Range

    **Fixed values**

    | Kind      | Name        | Value                |
    | --------- | ----------- | -------------------- |
    | Socket    | Value       | `self`               |
    | Parameter | `data_type` | from `from_min` type |

    Parameters
    ----------
    from_min : Float | Vector, optional
        socket 'From Min' (id: From Min)

    from_max : Float | Vector, optional
        socket 'From Max' (id: From Max)

    to_min : Float | Vector, optional
        socket 'To Min' (id: To Min)

    to_max : Float | Vector, optional
        socket 'To Max' (id: To Max)

    clamp : bool
        parameter `clamp`

    interpolation_type : Literal['Linear', 'Stepped Linear', 'Smooth Step', 'Smoother Step']
        parameter `interpolation_type`


    Returns
    -------
    Float
    """
    utils.check_enum_arg('Map Range', 'interpolation_type', interpolation_type, 'map_range', ('LINEAR', 'STEPPED', 'SMOOTHSTEP', 'SMOOTHERSTEP'))
    data_type = SocketType.get_data_type_for_node(from_min, 'ShaderNodeMapRange')
    node = Node('Map Range', {'Value': self, 'From Min': from_min, 'From Max': from_max, 'To Min': to_min, 'To Max': to_max}, clamp=clamp, data_type=data_type, interpolation_type=interpolation_type)
    return node._out

map_range_linear(from_min=None, from_max=None, to_min=None, to_max=None, clamp=True)

Node Map Range

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	data_type	from from_min type
Parameter	interpolation_type	'LINEAR'

Parameters:

Name	Type	Description	Default
from_min	Float | Vector	socket 'From Min' (id: From Min)	None
from_max	Float | Vector	socket 'From Max' (id: From Max)	None
to_min	Float | Vector	socket 'To Min' (id: To Min)	None
to_max	Float | Vector	socket 'To Max' (id: To Max)	None
clamp	bool	parameter clamp	True

Returns:

Type	Description
Float

Source code in core/generated/float.py

def map_range_linear(self,
                from_min: Float | Vector = None,
                from_max: Float | Vector = None,
                to_min: Float | Vector = None,
                to_max: Float | Vector = None,
                clamp = True):
    """ > Node Map Range

    **Fixed values**

    | Kind      | Name                 | Value                |
    | --------- | -------------------- | -------------------- |
    | Socket    | Value                | `self`               |
    | Parameter | `data_type`          | from `from_min` type |
    | Parameter | `interpolation_type` | `'LINEAR'`           |

    Parameters
    ----------
    from_min : Float | Vector, optional
        socket 'From Min' (id: From Min)

    from_max : Float | Vector, optional
        socket 'From Max' (id: From Max)

    to_min : Float | Vector, optional
        socket 'To Min' (id: To Min)

    to_max : Float | Vector, optional
        socket 'To Max' (id: To Max)

    clamp : bool
        parameter `clamp`


    Returns
    -------
    Float
    """
    data_type = SocketType.get_data_type_for_node(from_min, 'ShaderNodeMapRange')
    node = Node('Map Range', {'Value': self, 'From Min': from_min, 'From Max': from_max, 'To Min': to_min, 'To Max': to_max}, clamp=clamp, data_type=data_type, interpolation_type='LINEAR')
    return node._out

map_range_smooth_step(from_min=None, from_max=None, to_min=None, to_max=None, clamp=True)

Node Map Range

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	data_type	from from_min type
Parameter	interpolation_type	'SMOOTHSTEP'

Parameters:

Name	Type	Description	Default
from_min	Float | Vector	socket 'From Min' (id: From Min)	None
from_max	Float | Vector	socket 'From Max' (id: From Max)	None
to_min	Float | Vector	socket 'To Min' (id: To Min)	None
to_max	Float | Vector	socket 'To Max' (id: To Max)	None
clamp	bool	parameter clamp	True

Returns:

Type	Description
Float

Source code in core/generated/float.py

def map_range_smooth_step(self,
                from_min: Float | Vector = None,
                from_max: Float | Vector = None,
                to_min: Float | Vector = None,
                to_max: Float | Vector = None,
                clamp = True):
    """ > Node Map Range

    **Fixed values**

    | Kind      | Name                 | Value                |
    | --------- | -------------------- | -------------------- |
    | Socket    | Value                | `self`               |
    | Parameter | `data_type`          | from `from_min` type |
    | Parameter | `interpolation_type` | `'SMOOTHSTEP'`       |

    Parameters
    ----------
    from_min : Float | Vector, optional
        socket 'From Min' (id: From Min)

    from_max : Float | Vector, optional
        socket 'From Max' (id: From Max)

    to_min : Float | Vector, optional
        socket 'To Min' (id: To Min)

    to_max : Float | Vector, optional
        socket 'To Max' (id: To Max)

    clamp : bool
        parameter `clamp`


    Returns
    -------
    Float
    """
    data_type = SocketType.get_data_type_for_node(from_min, 'ShaderNodeMapRange')
    node = Node('Map Range', {'Value': self, 'From Min': from_min, 'From Max': from_max, 'To Min': to_min, 'To Max': to_max}, clamp=clamp, data_type=data_type, interpolation_type='SMOOTHSTEP')
    return node._out

map_range_smoother_step(from_min=None, from_max=None, to_min=None, to_max=None, clamp=True)

Node Map Range

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	data_type	from from_min type
Parameter	interpolation_type	'SMOOTHERSTEP'

Parameters:

Name	Type	Description	Default
from_min	Float | Vector	socket 'From Min' (id: From Min)	None
from_max	Float | Vector	socket 'From Max' (id: From Max)	None
to_min	Float | Vector	socket 'To Min' (id: To Min)	None
to_max	Float | Vector	socket 'To Max' (id: To Max)	None
clamp	bool	parameter clamp	True

Returns:

Type	Description
Float

Source code in core/generated/float.py

def map_range_smoother_step(self,
                from_min: Float | Vector = None,
                from_max: Float | Vector = None,
                to_min: Float | Vector = None,
                to_max: Float | Vector = None,
                clamp = True):
    """ > Node Map Range

    **Fixed values**

    | Kind      | Name                 | Value                |
    | --------- | -------------------- | -------------------- |
    | Socket    | Value                | `self`               |
    | Parameter | `data_type`          | from `from_min` type |
    | Parameter | `interpolation_type` | `'SMOOTHERSTEP'`     |

    Parameters
    ----------
    from_min : Float | Vector, optional
        socket 'From Min' (id: From Min)

    from_max : Float | Vector, optional
        socket 'From Max' (id: From Max)

    to_min : Float | Vector, optional
        socket 'To Min' (id: To Min)

    to_max : Float | Vector, optional
        socket 'To Max' (id: To Max)

    clamp : bool
        parameter `clamp`


    Returns
    -------
    Float
    """
    data_type = SocketType.get_data_type_for_node(from_min, 'ShaderNodeMapRange')
    node = Node('Map Range', {'Value': self, 'From Min': from_min, 'From Max': from_max, 'To Min': to_min, 'To Max': to_max}, clamp=clamp, data_type=data_type, interpolation_type='SMOOTHERSTEP')
    return node._out

map_range_stepped(from_min=None, from_max=None, to_min=None, to_max=None, steps=None, clamp=True)

Node Map Range

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	data_type	from from_min type
Parameter	interpolation_type	'STEPPED'

Parameters:

Name	Type	Description	Default
from_min	Float | Vector	socket 'From Min' (id: From Min)	None
from_max	Float | Vector	socket 'From Max' (id: From Max)	None
to_min	Float | Vector	socket 'To Min' (id: To Min)	None
to_max	Float | Vector	socket 'To Max' (id: To Max)	None
steps	Float	socket 'Steps' (id: Steps)	None
clamp	bool	parameter clamp	True

Returns:

Type	Description
Float

Source code in core/generated/float.py

def map_range_stepped(self,
                from_min: Float | Vector = None,
                from_max: Float | Vector = None,
                to_min: Float | Vector = None,
                to_max: Float | Vector = None,
                steps: Float = None,
                clamp = True):
    """ > Node Map Range

    **Fixed values**

    | Kind      | Name                 | Value                |
    | --------- | -------------------- | -------------------- |
    | Socket    | Value                | `self`               |
    | Parameter | `data_type`          | from `from_min` type |
    | Parameter | `interpolation_type` | `'STEPPED'`          |

    Parameters
    ----------
    from_min : Float | Vector, optional
        socket 'From Min' (id: From Min)

    from_max : Float | Vector, optional
        socket 'From Max' (id: From Max)

    to_min : Float | Vector, optional
        socket 'To Min' (id: To Min)

    to_max : Float | Vector, optional
        socket 'To Max' (id: To Max)

    steps : Float, optional
        socket 'Steps' (id: Steps)

    clamp : bool
        parameter `clamp`


    Returns
    -------
    Float
    """
    data_type = SocketType.get_data_type_for_node(from_min, 'ShaderNodeMapRange')
    node = Node('Map Range', {'Value': self, 'From Min': from_min, 'From Max': from_max, 'To Min': to_min, 'To Max': to_max, 'Steps': steps}, clamp=clamp, data_type=data_type, interpolation_type='STEPPED')
    return node._out

max(value=None, use_clamp=False)

Node Math

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	operation	'MAXIMUM'

Parameters:

Name	Type	Description	Default
value	Float	socket 'Value' (id: Value_001)	None
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def max(self, value: Float = None, use_clamp = False):
    """ > Node Math

    **Fixed values**

    | Kind      | Name        | Value       |
    | --------- | ----------- | ----------- |
    | Socket    | Value       | `self`      |
    | Parameter | `operation` | `'MAXIMUM'` |

    Parameters
    ----------
    value : Float, optional
        socket 'Value' (id: Value_001)

    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    node = Node('Math', {'Value': self, 'Value_001': value}, operation='MAXIMUM', use_clamp=use_clamp)
    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)

mgreater_than(threshold=None, use_clamp=False)

Node Math

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	operation	'GREATER_THAN'

Parameters:

Name	Type	Description	Default
threshold	Float	socket 'Threshold' (id: Value_001)	None
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def mgreater_than(self, threshold: Float = None, use_clamp = False):
    """ > Node Math

    **Fixed values**

    | Kind      | Name        | Value            |
    | --------- | ----------- | ---------------- |
    | Socket    | Value       | `self`           |
    | Parameter | `operation` | `'GREATER_THAN'` |

    Parameters
    ----------
    threshold : Float, optional
        socket 'Threshold' (id: Value_001)

    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    node = Node('Math', {'Value': self, 'Value_001': threshold}, operation='GREATER_THAN', use_clamp=use_clamp)
    return node._out

min(value=None, use_clamp=False)

Node Math

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	operation	'MINIMUM'

Parameters:

Name	Type	Description	Default
value	Float	socket 'Value' (id: Value_001)	None
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def min(self, value: Float = None, use_clamp = False):
    """ > Node Math

    **Fixed values**

    | Kind      | Name        | Value       |
    | --------- | ----------- | ----------- |
    | Socket    | Value       | `self`      |
    | Parameter | `operation` | `'MINIMUM'` |

    Parameters
    ----------
    value : Float, optional
        socket 'Value' (id: Value_001)

    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    node = Node('Math', {'Value': self, 'Value_001': value}, operation='MINIMUM', use_clamp=use_clamp)
    return node._out

mix(factor=None, other=None, clamp_factor=None)

Mix

Node Mix

Parameters:

Name	Type	Description	Default
factor	Float	socket 'Factor' (Factor_Float)	None
other	Socket	socket 'B' (B_Float)	None
clamp_factor	bool	Node.clamp_factor	None

Returns:

Type	Description
Socket

Source code in core/sock_float.py

def mix(self, factor=None, other=None, clamp_factor=None):
    """ > Mix

    > Node Mix

    Parameters
    ----------
    factor : Float
        socket 'Factor' (Factor_Float)

    other : Socket
        socket 'B' (B_Float)

    clamp_factor : bool
        Node.clamp_factor

    Returns
    -------
    Socket
    """
    return Float(Node('Mix', {'Factor': factor, 'A': self, 'B': other}, clamp_factor=clamp_factor, data_type='FLOAT')._out)

mless_than(threshold=None, use_clamp=False)

Node Math

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	operation	'LESS_THAN'

Parameters:

Name	Type	Description	Default
threshold	Float	socket 'Threshold' (id: Value_001)	None
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def mless_than(self, threshold: Float = None, use_clamp = False):
    """ > Node Math

    **Fixed values**

    | Kind      | Name        | Value         |
    | --------- | ----------- | ------------- |
    | Socket    | Value       | `self`        |
    | Parameter | `operation` | `'LESS_THAN'` |

    Parameters
    ----------
    threshold : Float, optional
        socket 'Threshold' (id: Value_001)

    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    node = Node('Math', {'Value': self, 'Value_001': threshold}, operation='LESS_THAN', use_clamp=use_clamp)
    return node._out

modulo(value=None, use_clamp=False)

Node Math

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	operation	'MODULO'

Parameters:

Name	Type	Description	Default
value	Float	socket 'Value' (id: Value_001)	None
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def modulo(self, value: Float = None, use_clamp = False):
    """ > Node Math

    **Fixed values**

    | Kind      | Name        | Value      |
    | --------- | ----------- | ---------- |
    | Socket    | Value       | `self`     |
    | Parameter | `operation` | `'MODULO'` |

    Parameters
    ----------
    value : Float, optional
        socket 'Value' (id: Value_001)

    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    node = Node('Math', {'Value': self, 'Value_001': value}, operation='MODULO', use_clamp=use_clamp)
    return node._out

multiply(value=None, use_clamp=False)

Node Math

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	operation	'MULTIPLY'

Parameters:

Name	Type	Description	Default
value	Float	socket 'Value' (id: Value_001)	None
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def multiply(self, value: Float = None, use_clamp = False):
    """ > Node Math

    **Fixed values**

    | Kind      | Name        | Value        |
    | --------- | ----------- | ------------ |
    | Socket    | Value       | `self`       |
    | Parameter | `operation` | `'MULTIPLY'` |

    Parameters
    ----------
    value : Float, optional
        socket 'Value' (id: Value_001)

    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    node = Node('Math', {'Value': self, 'Value_001': value}, operation='MULTIPLY', use_clamp=use_clamp)
    return node._out

multiply_add(multiplier=None, addend=None, use_clamp=False)

Node Math

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	operation	'MULTIPLY_ADD'

Parameters:

Name	Type	Description	Default
multiplier	Float	socket 'Multiplier' (id: Value_001)	None
addend	Float	socket 'Addend' (id: Value_002)	None
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def multiply_add(self, multiplier: Float = None, addend: Float = None, use_clamp = False):
    """ > Node Math

    **Fixed values**

    | Kind      | Name        | Value            |
    | --------- | ----------- | ---------------- |
    | Socket    | Value       | `self`           |
    | Parameter | `operation` | `'MULTIPLY_ADD'` |

    Parameters
    ----------
    multiplier : Float, optional
        socket 'Multiplier' (id: Value_001)

    addend : Float, optional
        socket 'Addend' (id: Value_002)

    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    node = Node('Math', {'Value': self, 'Value_001': multiplier, 'Value_002': addend}, operation='MULTIPLY_ADD', use_clamp=use_clamp)
    return node._out

normal_map(color=None, base='DISPLACED', convention='OPENGL', space='TANGENT', uv_map='')

Node Normal Map

Fixed values

Kind	Name	Value
Socket	Strength	self

Parameters:

Name	Type	Description	Default
color	Color	socket 'Color' (id: Color)	None
base	Literal['Original Base', 'Displaced Base']	parameter base	'DISPLACED'
convention	Literal['OpenGL', 'DirectX']	parameter convention	'OPENGL'
space	Literal['Tangent Space', 'Object Space', 'World Space', 'Blender Object Space', 'Blender World Space']	parameter space	'TANGENT'
uv_map	str	parameter uv_map	''

Returns:

Type	Description
Vector

Source code in core/generated/float.py

def normal_map(self,
                color: Color = None,
                base: Literal['ORIGINAL', 'DISPLACED'] = 'DISPLACED',
                convention: Literal['OPENGL', 'DIRECTX'] = 'OPENGL',
                space: Literal['TANGENT', 'OBJECT', 'WORLD', 'BLENDER_OBJECT', 'BLENDER_WORLD'] = 'TANGENT',
                uv_map = ''):
    """ > Node Normal Map

    **Fixed values**

    | Kind   | Name     | Value  |
    | ------ | -------- | ------ |
    | Socket | Strength | `self` |

    Parameters
    ----------
    color : Color, optional
        socket 'Color' (id: Color)

    base : Literal['Original Base', 'Displaced Base']
        parameter `base`

    convention : Literal['OpenGL', 'DirectX']
        parameter `convention`

    space : Literal['Tangent Space', 'Object Space', 'World Space', 'Blender Object Space', 'Blender World Space']
        parameter `space`

    uv_map : str
        parameter `uv_map`


    Returns
    -------
    Vector
    """
    utils.check_enum_arg('Normal Map', 'base', base, 'normal_map', ('ORIGINAL', 'DISPLACED'))
    utils.check_enum_arg('Normal Map', 'convention', convention, 'normal_map', ('OPENGL', 'DIRECTX'))
    utils.check_enum_arg('Normal Map', 'space', space, 'normal_map', ('TANGENT', 'OBJECT', 'WORLD', 'BLENDER_OBJECT', 'BLENDER_WORLD'))
    node = Node('Normal Map', {'Strength': self, 'Color': color}, base=base, convention=convention, space=space, uv_map=uv_map)
    return node._out

not_equal(b=None, epsilon=None)

Node Compare

Fixed values

Kind	Name	Value
Socket	A	self
Parameter	data_type	'FLOAT'
Parameter	mode	'ELEMENT'
Parameter	operation	'NOT_EQUAL'

Parameters:

Name	Type	Description	Default
b	Float	socket 'B' (id: B)	None
epsilon	Float	socket 'Epsilon' (id: Epsilon)	None

Returns:

Type	Description
Boolean

Source code in core/generated/float.py

def not_equal(self, b: Float = None, epsilon: Float = None):
    """ > Node Compare

    **Fixed values**

    | Kind      | Name        | Value         |
    | --------- | ----------- | ------------- |
    | Socket    | A           | `self`        |
    | Parameter | `data_type` | `'FLOAT'`     |
    | Parameter | `mode`      | `'ELEMENT'`   |
    | Parameter | `operation` | `'NOT_EQUAL'` |

    Parameters
    ----------
    b : Float, optional
        socket 'B' (id: B)

    epsilon : Float, optional
        socket 'Epsilon' (id: Epsilon)


    Returns
    -------
    Boolean
    """
    node = Node('Compare', {'A': self, 'B': b, 'Epsilon': epsilon}, data_type='FLOAT', mode='ELEMENT', operation='NOT_EQUAL')
    return node._out

out(name=None, **props)

Connect to output

Behavior

• Geometry Nodes : create a group output socket with the provided name
• Shader : create a node AOV Output

Source code in core/sock_float.py

def out(self, name=None, **props):
    """ > Connect to output

    !!! important "Behavior"

        - Geometry Nodes : create a group output socket with the provided name
        - Shader : create a node AOV Output
    """
    if self._tree._btree.bl_idname == 'ShaderNodeTree' and not self._tree._is_group:
        if name is None:
            self._tree.set_thickness(self)
        else:
            self._tree.aov_output(name=name, value=self)
    else:
        super().out(name=name, **props)

pingpong(scale=None, use_clamp=False)

Node Math

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	operation	'PINGPONG'

Parameters:

Name	Type	Description	Default
scale	Float	socket 'Scale' (id: Value_001)	None
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def pingpong(self, scale: Float = None, use_clamp = False):
    """ > Node Math

    **Fixed values**

    | Kind      | Name        | Value        |
    | --------- | ----------- | ------------ |
    | Socket    | Value       | `self`       |
    | Parameter | `operation` | `'PINGPONG'` |

    Parameters
    ----------
    scale : Float, optional
        socket 'Scale' (id: Value_001)

    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    node = Node('Math', {'Value': self, 'Value_001': scale}, operation='PINGPONG', use_clamp=use_clamp)
    return node._out

power(exponent=None, use_clamp=False)

Node Math

Fixed values

Kind	Name	Value
Socket	Base	self
Parameter	operation	'POWER'

Parameters:

Name	Type	Description	Default
exponent	Float	socket 'Exponent' (id: Value_001)	None
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def power(self, exponent: Float = None, use_clamp = False):
    """ > Node Math

    **Fixed values**

    | Kind      | Name        | Value     |
    | --------- | ----------- | --------- |
    | Socket    | Base        | `self`    |
    | Parameter | `operation` | `'POWER'` |

    Parameters
    ----------
    exponent : Float, optional
        socket 'Exponent' (id: Value_001)

    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    node = Node('Math', {'Value': self, 'Value_001': exponent}, operation='POWER', use_clamp=use_clamp)
    return node._out

prune_grid(mode=None, threshold=None)

Node Prune Grid

Fixed values

Kind	Name	Value
Socket	Grid	self
Parameter	data_type	'FLOAT'

Parameters:

Name	Type	Description	Default
mode	menu='Threshold'	('Inactive', 'Threshold', 'SDF')	None
threshold	Float	socket 'Threshold' (id: Threshold)	None

Returns:

Type	Description
Float

Source code in core/generated/float.py

def prune_grid(self,
                mode: Literal['Inactive', 'Threshold', 'SDF'] = None,
                threshold: Float = None):
    """ > Node Prune Grid

    **Fixed values**

    | Kind      | Name        | Value     |
    | --------- | ----------- | --------- |
    | Socket    | Grid        | `self`    |
    | Parameter | `data_type` | `'FLOAT'` |

    Parameters
    ----------
    mode : menu='Threshold', optional
        ('Inactive', 'Threshold', 'SDF')

    threshold : Float, optional
        socket 'Threshold' (id: Threshold)


    Returns
    -------
    Float
    """
    node = Node('Prune Grid', {'Grid': self, 'Mode': mode, 'Threshold': threshold}, data_type='FLOAT')
    return node._out

radians(use_clamp=False)

Node Math

Fixed values

Kind	Name	Value
Socket	Degrees	self
Parameter	operation	'RADIANS'

Parameters:

Name	Type	Description	Default
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def radians(self, use_clamp = False):
    """ > Node Math

    **Fixed values**

    | Kind      | Name        | Value       |
    | --------- | ----------- | ----------- |
    | Socket    | Degrees     | `self`      |
    | Parameter | `operation` | `'RADIANS'` |

    Parameters
    ----------
    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    node = Node('Math', {'Value': self}, operation='RADIANS', use_clamp=use_clamp)
    return node._out

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)

round(use_clamp=False)

Node Math

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	operation	'ROUND'

Parameters:

Name	Type	Description	Default
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def round(self, use_clamp = False):
    """ > Node Math

    **Fixed values**

    | Kind      | Name        | Value     |
    | --------- | ----------- | --------- |
    | Socket    | Value       | `self`    |
    | Parameter | `operation` | `'ROUND'` |

    Parameters
    ----------
    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    node = Node('Math', {'Value': self}, operation='ROUND', use_clamp=use_clamp)
    return node._out

sample_grid(position=None, interpolation=None)

Node Sample Grid

Fixed values

Kind	Name	Value
Socket	Grid	self
Parameter	data_type	'FLOAT'

Parameters:

Name	Type	Description	Default
position	Vector	socket 'Position' (id: Position)	None
interpolation	menu='Trilinear'	('Nearest Neighbor', 'Trilinear', 'Triquadratic')	None

Returns:

Type	Description
Float

Source code in core/generated/float.py

def sample_grid(self,
                position: Vector = None,
                interpolation: Literal['Nearest Neighbor', 'Trilinear', 'Triquadratic'] = None):
    """ > Node Sample Grid

    **Fixed values**

    | Kind      | Name        | Value     |
    | --------- | ----------- | --------- |
    | Socket    | Grid        | `self`    |
    | Parameter | `data_type` | `'FLOAT'` |

    Parameters
    ----------
    position : Vector, optional
        socket 'Position' (id: Position)

    interpolation : menu='Trilinear', optional
        ('Nearest Neighbor', 'Trilinear', 'Triquadratic')


    Returns
    -------
    Float
    """
    node = Node('Sample Grid', {'Grid': self, 'Position': position, 'Interpolation': interpolation}, data_type='FLOAT')
    return node._out

sample_grid_index(x=None, y=None, z=None)

Node Sample Grid Index

Fixed values

Kind	Name	Value
Socket	Grid	self
Parameter	data_type	'FLOAT'

Parameters:

Name	Type	Description	Default
x	Integer	socket 'X' (id: X)	None
y	Integer	socket 'Y' (id: Y)	None
z	Integer	socket 'Z' (id: Z)	None

Returns:

Type	Description
Float

Source code in core/generated/float.py

def sample_grid_index(self, x: Integer = None, y: Integer = None, z: Integer = None):
    """ > Node Sample Grid Index

    **Fixed values**

    | Kind      | Name        | Value     |
    | --------- | ----------- | --------- |
    | Socket    | Grid        | `self`    |
    | Parameter | `data_type` | `'FLOAT'` |

    Parameters
    ----------
    x : Integer, optional
        socket 'X' (id: X)

    y : Integer, optional
        socket 'Y' (id: Y)

    z : Integer, optional
        socket 'Z' (id: Z)


    Returns
    -------
    Float
    """
    node = Node('Sample Grid Index', {'Grid': self, 'X': x, 'Y': y, 'Z': z}, data_type='FLOAT')
    return node._out

scene_time()

Node Scene Time

Returns:

Type	Description
Float	peer sockets: frame_ (Float)

Source code in core/generated/float.py

@utils.classproperty
def scene_time(cls):
    """ > Node Scene Time

    Returns
    -------
    Float
        peer sockets: frame_ (Float)

    """
    node = Node('Scene Time', )
    return node._out

sdf_difference(*grid_2)

Node SDF Grid Boolean

Fixed values

Kind	Name	Value
Socket	Grid 1	self
Parameter	operation	'DIFFERENCE'

Parameters:

Name	Type	Description	Default
grid_2	Float	socket 'Grid 2' (id: Grid 2)	()

Returns:

Type	Description
Float

Source code in core/generated/float.py

def sdf_difference(self, *grid_2: Float):
    """ > Node SDF Grid Boolean

    **Fixed values**

    | Kind      | Name        | Value          |
    | --------- | ----------- | -------------- |
    | Socket    | Grid 1      | `self`         |
    | Parameter | `operation` | `'DIFFERENCE'` |

    Parameters
    ----------
    grid_2 : Float, optional
        socket 'Grid 2' (id: Grid 2)


    Returns
    -------
    Float
    """
    node = Node('SDF Grid Boolean', {'Grid 1': self, 'Grid 2': list(grid_2)}, operation='DIFFERENCE')
    return node._out

sdf_grid_boolean(*grid_2, operation='DIFFERENCE')

Node SDF Grid Boolean

Fixed values

Kind	Name	Value
Socket	Grid 1	self

Parameters:

Name	Type	Description	Default
grid_2	Float	socket 'Grid 2' (id: Grid 2)	()
operation	Literal['Intersect', 'Union', 'Difference']	parameter operation	'DIFFERENCE'

Returns:

Type	Description
Float

Source code in core/generated/float.py

def sdf_grid_boolean(self,
                *grid_2: Float,
                operation: Literal['INTERSECT', 'UNION', 'DIFFERENCE'] = 'DIFFERENCE'):
    """ > Node SDF Grid Boolean

    **Fixed values**

    | Kind   | Name   | Value  |
    | ------ | ------ | ------ |
    | Socket | Grid 1 | `self` |

    Parameters
    ----------
    grid_2 : Float, optional
        socket 'Grid 2' (id: Grid 2)

    operation : Literal['Intersect', 'Union', 'Difference']
        parameter `operation`


    Returns
    -------
    Float
    """
    utils.check_enum_arg('SDF Grid Boolean', 'operation', operation, 'sdf_grid_boolean', ('INTERSECT', 'UNION', 'DIFFERENCE'))
    node = Node('SDF Grid Boolean', {'Grid 1': self, 'Grid 2': list(grid_2)}, operation=operation)
    return node._out

sdf_grid_fillet(iterations=None)

Node SDF Grid Fillet

Fixed values

Kind	Name	Value
Socket	Grid	self

Parameters:

Name	Type	Description	Default
iterations	Integer	socket 'Iterations' (id: Iterations)	None

Returns:

Type	Description
Float

Source code in core/generated/float.py

def sdf_grid_fillet(self, iterations: Integer = None):
    """ > Node SDF Grid Fillet

    **Fixed values**

    | Kind   | Name | Value  |
    | ------ | ---- | ------ |
    | Socket | Grid | `self` |

    Parameters
    ----------
    iterations : Integer, optional
        socket 'Iterations' (id: Iterations)


    Returns
    -------
    Float
    """
    node = Node('SDF Grid Fillet', {'Grid': self, 'Iterations': iterations})
    return node._out

sdf_grid_laplacian(iterations=None)

Node SDF Grid Laplacian

Fixed values

Kind	Name	Value
Socket	Grid	self

Parameters:

Name	Type	Description	Default
iterations	Integer	socket 'Iterations' (id: Iterations)	None

Returns:

Type	Description
Float

Source code in core/generated/float.py

def sdf_grid_laplacian(self, iterations: Integer = None):
    """ > Node SDF Grid Laplacian

    **Fixed values**

    | Kind   | Name | Value  |
    | ------ | ---- | ------ |
    | Socket | Grid | `self` |

    Parameters
    ----------
    iterations : Integer, optional
        socket 'Iterations' (id: Iterations)


    Returns
    -------
    Float
    """
    node = Node('SDF Grid Laplacian', {'Grid': self, 'Iterations': iterations})
    return node._out

sdf_grid_mean(width=None, iterations=None)

Node SDF Grid Mean

Fixed values

Kind	Name	Value
Socket	Grid	self

Parameters:

Name	Type	Description	Default
width	Integer	socket 'Width' (id: Width)	None
iterations	Integer	socket 'Iterations' (id: Iterations)	None

Returns:

Type	Description
Float

Source code in core/generated/float.py

def sdf_grid_mean(self, width: Integer = None, iterations: Integer = None):
    """ > Node SDF Grid Mean

    **Fixed values**

    | Kind   | Name | Value  |
    | ------ | ---- | ------ |
    | Socket | Grid | `self` |

    Parameters
    ----------
    width : Integer, optional
        socket 'Width' (id: Width)

    iterations : Integer, optional
        socket 'Iterations' (id: Iterations)


    Returns
    -------
    Float
    """
    node = Node('SDF Grid Mean', {'Grid': self, 'Width': width, 'Iterations': iterations})
    return node._out

sdf_grid_mean_curvature(iterations=None)

Node SDF Grid Mean Curvature

Fixed values

Kind	Name	Value
Socket	Grid	self

Parameters:

Name	Type	Description	Default
iterations	Integer	socket 'Iterations' (id: Iterations)	None

Returns:

Type	Description
Float

Source code in core/generated/float.py

def sdf_grid_mean_curvature(self, iterations: Integer = None):
    """ > Node SDF Grid Mean Curvature

    **Fixed values**

    | Kind   | Name | Value  |
    | ------ | ---- | ------ |
    | Socket | Grid | `self` |

    Parameters
    ----------
    iterations : Integer, optional
        socket 'Iterations' (id: Iterations)


    Returns
    -------
    Float
    """
    node = Node('SDF Grid Mean Curvature', {'Grid': self, 'Iterations': iterations})
    return node._out

sdf_grid_median(width=None, iterations=None)

Node SDF Grid Median

Fixed values

Kind	Name	Value
Socket	Grid	self

Parameters:

Name	Type	Description	Default
width	Integer	socket 'Width' (id: Width)	None
iterations	Integer	socket 'Iterations' (id: Iterations)	None

Returns:

Type	Description
Float

Source code in core/generated/float.py

def sdf_grid_median(self, width: Integer = None, iterations: Integer = None):
    """ > Node SDF Grid Median

    **Fixed values**

    | Kind   | Name | Value  |
    | ------ | ---- | ------ |
    | Socket | Grid | `self` |

    Parameters
    ----------
    width : Integer, optional
        socket 'Width' (id: Width)

    iterations : Integer, optional
        socket 'Iterations' (id: Iterations)


    Returns
    -------
    Float
    """
    node = Node('SDF Grid Median', {'Grid': self, 'Width': width, 'Iterations': iterations})
    return node._out

sdf_grid_offset(distance=None)

Node SDF Grid Offset

Fixed values

Kind	Name	Value
Socket	Grid	self

Parameters:

Name	Type	Description	Default
distance	Float	socket 'Distance' (id: Distance)	None

Returns:

Type	Description
Float

Source code in core/generated/float.py

def sdf_grid_offset(self, distance: Float = None):
    """ > Node SDF Grid Offset

    **Fixed values**

    | Kind   | Name | Value  |
    | ------ | ---- | ------ |
    | Socket | Grid | `self` |

    Parameters
    ----------
    distance : Float, optional
        socket 'Distance' (id: Distance)


    Returns
    -------
    Float
    """
    node = Node('SDF Grid Offset', {'Grid': self, 'Distance': distance})
    return node._out

sdf_intersect(*grid)

Node SDF Grid Boolean

Fixed values

Kind	Name	Value
Parameter	operation	'INTERSECT'

Parameters:

Name	Type	Description	Default
grid	Float	socket 'Grid' (id: Grid 2)	()

Returns:

Type	Description
Float

Source code in core/generated/float.py

def sdf_intersect(self, *grid: Float):
    """ > Node SDF Grid Boolean

    **Fixed values**

    | Kind      | Name        | Value         |
    | --------- | ----------- | ------------- |
    | Parameter | `operation` | `'INTERSECT'` |

    Parameters
    ----------
    grid : Float, optional
        socket 'Grid' (id: Grid 2)


    Returns
    -------
    Float
    """
    node = Node('SDF Grid Boolean', {'Grid 2': [self] + list(grid)}, operation='INTERSECT')
    return node._out

sdf_union(*grid)

Node SDF Grid Boolean

Fixed values

Kind	Name	Value
Parameter	operation	'UNION'

Parameters:

Name	Type	Description	Default
grid	Float	socket 'Grid' (id: Grid 2)	()

Returns:

Type	Description
Float

Source code in core/generated/float.py

def sdf_union(self, *grid: Float):
    """ > Node SDF Grid Boolean

    **Fixed values**

    | Kind      | Name        | Value     |
    | --------- | ----------- | --------- |
    | Parameter | `operation` | `'UNION'` |

    Parameters
    ----------
    grid : Float, optional
        socket 'Grid' (id: Grid 2)


    Returns
    -------
    Float
    """
    node = Node('SDF Grid Boolean', {'Grid 2': [self] + list(grid)}, operation='UNION')
    return node._out

seconds()

Node Scene Time

Returns:

Type	Description
seconds

Source code in core/generated/float.py

@utils.classproperty
def seconds(cls):
    """ > Node Scene Time

    Returns
    -------
    seconds
    """
    node = Node('Scene Time', )
    return node.seconds

set_grid_background(background=None, update_inactive=None)

Node Set Grid Background

Fixed values

Kind	Name	Value
Socket	Grid	self
Parameter	data_type	'FLOAT'

Parameters:

Name	Type	Description	Default
background	Float	socket 'Background' (id: Background)	None
update_inactive	Boolean	socket 'Update Inactive' (id: Update Inactive)	None

Returns:

Type	Description
Float

Source code in core/generated/float.py

def set_grid_background(self, background: Float = None, update_inactive: Boolean = None):
    """ > Node Set Grid Background

    **Fixed values**

    | Kind      | Name        | Value     |
    | --------- | ----------- | --------- |
    | Socket    | Grid        | `self`    |
    | Parameter | `data_type` | `'FLOAT'` |

    Parameters
    ----------
    background : Float, optional
        socket 'Background' (id: Background)

    update_inactive : Boolean, optional
        socket 'Update Inactive' (id: Update Inactive)


    Returns
    -------
    Float
    """
    node = Node('Set Grid Background', {'Grid': self, 'Background': background, 'Update Inactive': update_inactive}, data_type='FLOAT')
    return node._out

set_grid_transform(transform=None)

Node Set Grid Transform

Fixed values

Kind	Name	Value
Socket	Grid	self
Parameter	data_type	'FLOAT'

Parameters:

Name	Type	Description	Default
transform	Matrix	socket 'Transform' (id: Transform)	None

Returns:

Type	Description
Boolean	peer sockets: grid_ (Float)

Source code in core/generated/float.py

def set_grid_transform(self, transform: Matrix = None):
    """ > Node Set Grid Transform

    **Fixed values**

    | Kind      | Name        | Value     |
    | --------- | ----------- | --------- |
    | Socket    | Grid        | `self`    |
    | Parameter | `data_type` | `'FLOAT'` |

    Parameters
    ----------
    transform : Matrix, optional
        socket 'Transform' (id: Transform)


    Returns
    -------
    Boolean
        peer sockets: grid_ (Float)

    """
    node = Node('Set Grid Transform', {'Grid': self, 'Transform': transform}, data_type='FLOAT')
    return node._out

sign(use_clamp=False)

Node Math

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	operation	'SIGN'

Parameters:

Name	Type	Description	Default
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def sign(self, use_clamp = False):
    """ > Node Math

    **Fixed values**

    | Kind      | Name        | Value    |
    | --------- | ----------- | -------- |
    | Socket    | Value       | `self`   |
    | Parameter | `operation` | `'SIGN'` |

    Parameters
    ----------
    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    node = Node('Math', {'Value': self}, operation='SIGN', use_clamp=use_clamp)
    return node._out

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)

sin(use_clamp=False)

Node Math

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	operation	'SINE'

Parameters:

Name	Type	Description	Default
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def sin(self, use_clamp = False):
    """ > Node Math

    **Fixed values**

    | Kind      | Name        | Value    |
    | --------- | ----------- | -------- |
    | Socket    | Value       | `self`   |
    | Parameter | `operation` | `'SINE'` |

    Parameters
    ----------
    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    node = Node('Math', {'Value': self}, operation='SINE', use_clamp=use_clamp)
    return node._out

sinh(use_clamp=False)

Node Math

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	operation	'SINH'

Parameters:

Name	Type	Description	Default
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def sinh(self, use_clamp = False):
    """ > Node Math

    **Fixed values**

    | Kind      | Name        | Value    |
    | --------- | ----------- | -------- |
    | Socket    | Value       | `self`   |
    | Parameter | `operation` | `'SINH'` |

    Parameters
    ----------
    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    node = Node('Math', {'Value': self}, operation='SINH', use_clamp=use_clamp)
    return node._out

smooth_max(value=None, distance=None, use_clamp=False)

Node Math

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	operation	'SMOOTH_MAX'

Parameters:

Name	Type	Description	Default
value	Float	socket 'Value' (id: Value_001)	None
distance	Float	socket 'Distance' (id: Value_002)	None
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def smooth_max(self, value: Float = None, distance: Float = None, use_clamp = False):
    """ > Node Math

    **Fixed values**

    | Kind      | Name        | Value          |
    | --------- | ----------- | -------------- |
    | Socket    | Value       | `self`         |
    | Parameter | `operation` | `'SMOOTH_MAX'` |

    Parameters
    ----------
    value : Float, optional
        socket 'Value' (id: Value_001)

    distance : Float, optional
        socket 'Distance' (id: Value_002)

    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    node = Node('Math', {'Value': self, 'Value_001': value, 'Value_002': distance}, operation='SMOOTH_MAX', use_clamp=use_clamp)
    return node._out

smooth_min(value=None, distance=None, use_clamp=False)

Node Math

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	operation	'SMOOTH_MIN'

Parameters:

Name	Type	Description	Default
value	Float	socket 'Value' (id: Value_001)	None
distance	Float	socket 'Distance' (id: Value_002)	None
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def smooth_min(self, value: Float = None, distance: Float = None, use_clamp = False):
    """ > Node Math

    **Fixed values**

    | Kind      | Name        | Value          |
    | --------- | ----------- | -------------- |
    | Socket    | Value       | `self`         |
    | Parameter | `operation` | `'SMOOTH_MIN'` |

    Parameters
    ----------
    value : Float, optional
        socket 'Value' (id: Value_001)

    distance : Float, optional
        socket 'Distance' (id: Value_002)

    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    node = Node('Math', {'Value': self, 'Value_001': value, 'Value_002': distance}, operation='SMOOTH_MIN', use_clamp=use_clamp)
    return node._out

snap(increment=None, use_clamp=False)

Node Math

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	operation	'SNAP'

Parameters:

Name	Type	Description	Default
increment	Float	socket 'Increment' (id: Value_001)	None
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def snap(self, increment: Float = None, use_clamp = False):
    """ > Node Math

    **Fixed values**

    | Kind      | Name        | Value    |
    | --------- | ----------- | -------- |
    | Socket    | Value       | `self`   |
    | Parameter | `operation` | `'SNAP'` |

    Parameters
    ----------
    increment : Float, optional
        socket 'Increment' (id: Value_001)

    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    node = Node('Math', {'Value': self, 'Value_001': increment}, operation='SNAP', use_clamp=use_clamp)
    return node._out

sqrt(use_clamp=False)

Node Math

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	operation	'SQRT'

Parameters:

Name	Type	Description	Default
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def sqrt(self, use_clamp = False):
    """ > Node Math

    **Fixed values**

    | Kind      | Name        | Value    |
    | --------- | ----------- | -------- |
    | Socket    | Value       | `self`   |
    | Parameter | `operation` | `'SQRT'` |

    Parameters
    ----------
    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    node = Node('Math', {'Value': self}, operation='SQRT', use_clamp=use_clamp)
    return node._out

subtract(value=None, use_clamp=False)

Node Math

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	operation	'SUBTRACT'

Parameters:

Name	Type	Description	Default
value	Float	socket 'Value' (id: Value_001)	None
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def subtract(self, value: Float = None, use_clamp = False):
    """ > Node Math

    **Fixed values**

    | Kind      | Name        | Value        |
    | --------- | ----------- | ------------ |
    | Socket    | Value       | `self`       |
    | Parameter | `operation` | `'SUBTRACT'` |

    Parameters
    ----------
    value : Float, optional
        socket 'Value' (id: Value_001)

    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    node = Node('Math', {'Value': self, 'Value_001': value}, operation='SUBTRACT', use_clamp=use_clamp)
    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.core import 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.core import 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

tan(use_clamp=False)

Node Math

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	operation	'TANGENT'

Parameters:

Name	Type	Description	Default
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def tan(self, use_clamp = False):
    """ > Node Math

    **Fixed values**

    | Kind      | Name        | Value       |
    | --------- | ----------- | ----------- |
    | Socket    | Value       | `self`      |
    | Parameter | `operation` | `'TANGENT'` |

    Parameters
    ----------
    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    node = Node('Math', {'Value': self}, operation='TANGENT', use_clamp=use_clamp)
    return node._out

tanh(use_clamp=False)

Node Math

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	operation	'TANH'

Parameters:

Name	Type	Description	Default
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def tanh(self, use_clamp = False):
    """ > Node Math

    **Fixed values**

    | Kind      | Name        | Value    |
    | --------- | ----------- | -------- |
    | Socket    | Value       | `self`   |
    | Parameter | `operation` | `'TANH'` |

    Parameters
    ----------
    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    node = Node('Math', {'Value': self}, operation='TANH', use_clamp=use_clamp)
    return node._out

to_integer(rounding_mode='ROUND')

Node Float to Integer

Fixed values

Kind	Name	Value
Socket	Float	self

Parameters:

Name	Type	Description	Default
rounding_mode	Literal['Round', 'Floor', 'Ceiling', 'Truncate']	parameter rounding_mode	'ROUND'

Returns:

Type	Description
Integer

Source code in core/generated/float.py

def to_integer(self,
                rounding_mode: Literal['ROUND', 'FLOOR', 'CEILING', 'TRUNCATE'] = 'ROUND'):
    """ > Node Float to Integer

    **Fixed values**

    | Kind   | Name  | Value  |
    | ------ | ----- | ------ |
    | Socket | Float | `self` |

    Parameters
    ----------
    rounding_mode : Literal['Round', 'Floor', 'Ceiling', 'Truncate']
        parameter `rounding_mode`


    Returns
    -------
    Integer
    """
    utils.check_enum_arg('Float to Integer', 'rounding_mode', rounding_mode, 'to_integer', ('ROUND', 'FLOOR', 'CEILING', 'TRUNCATE'))
    node = Node('Float to Integer', {'Float': self}, rounding_mode=rounding_mode)
    return node._out

to_string(decimals=None)

Node Value to String

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	data_type	'FLOAT'

Parameters:

Name	Type	Description	Default
decimals	Integer	socket 'Decimals' (id: Decimals)	None

Returns:

Type	Description
String

Source code in core/generated/float.py

def to_string(self, decimals: Integer = None):
    """ > Node Value to String

    **Fixed values**

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

    Parameters
    ----------
    decimals : Integer, optional
        socket 'Decimals' (id: Decimals)


    Returns
    -------
    String
    """
    node = Node('Value to String', {'Value': self, 'Decimals': decimals}, data_type='FLOAT')
    return node._out

trunc(use_clamp=False)

Node Math

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	operation	'TRUNC'

Parameters:

Name	Type	Description	Default
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def trunc(self, use_clamp = False):
    """ > Node Math

    **Fixed values**

    | Kind      | Name        | Value     |
    | --------- | ----------- | --------- |
    | Socket    | Value       | `self`    |
    | Parameter | `operation` | `'TRUNC'` |

    Parameters
    ----------
    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    node = Node('Math', {'Value': self}, operation='TRUNC', use_clamp=use_clamp)
    return node._out

voxel_index() classmethod

Node Voxel Index

Returns:

Type	Description
Integer	peer sockets: y_ (Integer), z_ (Integer), is_tile_ (Boolean), extent_x_ (Integer), extent_y_ (Integer), extent_z_ (Integer)

Source code in core/generated/float.py

@classmethod
def voxel_index(cls):
    """ > Node Voxel Index

    Returns
    -------
    Integer
        peer sockets: y_ (Integer), z_ (Integer), is_tile_ (Boolean), extent_x_ (Integer), extent_y_ (Integer), extent_z_ (Integer)

    """
    node = Node('Voxel Index', )
    return node._out

voxelize_grid()

Node Voxelize Grid

Fixed values

Kind	Name	Value
Socket	Grid	self
Parameter	data_type	'FLOAT'

Returns:

Type	Description
Float

Source code in core/generated/float.py

def voxelize_grid(self):
    """ > Node Voxelize Grid

    **Fixed values**

    | Kind      | Name        | Value     |
    | --------- | ----------- | --------- |
    | Socket    | Grid        | `self`    |
    | Parameter | `data_type` | `'FLOAT'` |

    Returns
    -------
    Float
    """
    node = Node('Voxelize Grid', {'Grid': self}, data_type='FLOAT')
    return node._out

wavelength()

Node Wavelength

Fixed values

Kind	Name	Value
Socket	Wavelength	self

Returns:

Type	Description
Color

Source code in core/generated/float.py

def wavelength(self):
    """ > Node Wavelength

    **Fixed values**

    | Kind   | Name       | Value  |
    | ------ | ---------- | ------ |
    | Socket | Wavelength | `self` |

    Returns
    -------
    Color
    """
    node = Node('Wavelength', {'Wavelength': self})
    return node._out

wireframe(use_pixel_size=False)

Node Wireframe

Fixed values

Kind	Name	Value
Socket	Size	self

Parameters:

Name	Type	Description	Default
use_pixel_size	bool	parameter use_pixel_size	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def wireframe(self, use_pixel_size = False):
    """ > Node Wireframe

    **Fixed values**

    | Kind   | Name | Value  |
    | ------ | ---- | ------ |
    | Socket | Size | `self` |

    Parameters
    ----------
    use_pixel_size : bool
        parameter `use_pixel_size`


    Returns
    -------
    Float
    """
    node = Node('Wireframe', {'Size': self}, use_pixel_size=use_pixel_size)
    return node._out

wrap(max=None, min=None, use_clamp=False)

Node Math

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	operation	'WRAP'

Parameters:

Name	Type	Description	Default
max	Float	socket 'Max' (id: Value_001)	None
min	Float	socket 'Min' (id: Value_002)	None
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/float.py

def wrap(self, max: Float = None, min: Float = None, use_clamp = False):
    """ > Node Math

    **Fixed values**

    | Kind      | Name        | Value    |
    | --------- | ----------- | -------- |
    | Socket    | Value       | `self`   |
    | Parameter | `operation` | `'WRAP'` |

    Parameters
    ----------
    max : Float, optional
        socket 'Max' (id: Value_001)

    min : Float, optional
        socket 'Min' (id: Value_002)

    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    node = Node('Math', {'Value': self, 'Value_001': max, 'Value_002': min}, operation='WRAP', use_clamp=use_clamp)
    return node._out