procfunc 0.30.0__py3-none-any.whl

procfunc/nodes/func.py

@@ -0,0 +1,1417 @@
+"""
+Auto-generated Function Node bindings for Blender
+"""
+
+import logging
+from typing import Any, Literal, NamedTuple, TypeVar
+
+import numpy as np
+
+from procfunc import types as pt
+from procfunc.nodes import types as nt
+from procfunc.nodes.bindings_util import (
+    ContextualNode,
+    RuntimeResolveDataType,
+    raise_io_error,
+)
+from procfunc.nodes.bpy_node_info import NodeDataType
+
+logger = logging.getLogger(__name__)
+
+TConstant = TypeVar("TConstant", int, float, bool, pt.Vector, pt.Euler, pt.Color)
+
+
+def constant(
+    value: TConstant,
+) -> nt.ProcNode[TConstant]:
+    """
+    Replaces all nodes which just store a constant
+    e.g. ShaderNodeValue, ShaderNodeRGB, FunctionNodeInput*, etc
+    """
+    if isinstance(value, (float, int)):
+        return nt.ProcNode.from_nodetype(
+            node_type="ShaderNodeValue", inputs={}, attrs={"value": value}
+        )
+    elif isinstance(value, (pt.Vector, pt.Euler, tuple)):
+        x, y, z = value
+        return combine_xyz(x=float(x), y=float(y), z=float(z))
+    elif isinstance(value, bool):
+        return nt.ProcNode.from_nodetype(
+            node_type="FunctionNodeBoolean", inputs={}, attrs={"boolean": value}
+        )
+    elif isinstance(value, pt.Color):
+        return nt.ProcNode.from_nodetype(
+            node_type="ShaderNodeRGB", inputs={}, attrs={"value": value}
+        )
+    elif isinstance(value, str):
+        return nt.ProcNode.from_nodetype(
+            node_type="FunctionNodeInputString", inputs={}, attrs={"value": value}
+        )
+    else:
+        raise ValueError(f"Unsupported constant type: {type(value)}")
+
+
+def align_euler_to_vector(
+    rotation: nt.SocketOrVal[pt.Vector] = (0, 0, 0),
+    factor: nt.SocketOrVal[float] = 1.0,
+    vector: nt.SocketOrVal[pt.Vector] = (0, 0, 1),
+    axis: Literal["X", "Y", "Z"] = "X",
+    pivot_axis: Literal["AUTO", "X", "Y", "Z"] = "AUTO",
+) -> nt.ProcNode[pt.Vector]:
+    """
+    Uses a AlignEulerToVector Function Node.
+
+    See: http://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/rotation/align_euler_to_vector.html
+    """
+    return nt.ProcNode.from_nodetype(
+        node_type="FunctionNodeAlignEulerToVector",
+        inputs={"Rotation": rotation, "Factor": factor, "Vector": vector},
+        attrs={"axis": axis, "pivot_axis": pivot_axis},
+    )
+
+
+def align_rotation_to_vector(
+    rotation: Any = (0, 0, 0),
+    factor: nt.SocketOrVal[float] = 1.0,
+    vector: nt.SocketOrVal[pt.Vector] = (0, 0, 1),
+    axis: Literal["X", "Y", "Z"] = "Z",
+    pivot_axis: Literal["AUTO", "X", "Y", "Z"] = "AUTO",
+) -> nt.ProcNode[pt.Vector]:
+    """
+    Uses a AlignRotationToVector Function Node.
+
+    See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/rotation/align_rotation_to_vector.html
+    """
+    return nt.ProcNode.from_nodetype(
+        node_type="FunctionNodeAlignRotationToVector",
+        inputs={"Rotation": rotation, "Factor": factor, "Vector": vector},
+        attrs={"axis": axis, "pivot_axis": pivot_axis},
+    )
+
+
+def axes_to_rotation(
+    primary_axis_vector: nt.SocketOrVal[pt.Vector] = (0, 0, 1),
+    secondary_axis_vector: nt.SocketOrVal[pt.Vector] = (1, 0, 0),
+    primary_axis: Literal["X", "Y", "Z"] = "X",
+    secondary_axis: Literal["X", "Y", "Z"] = "Y",
+) -> nt.ProcNode[pt.Vector]:
+    """
+    Uses a AxesToRotation Function Node.
+
+    See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/rotation/axis_to_rotation.html
+    """
+    return nt.ProcNode.from_nodetype(
+        node_type="FunctionNodeAxesToRotation",
+        inputs={
+            "Primary Axis": primary_axis_vector,
+            "Secondary Axis": secondary_axis_vector,
+        },
+        attrs={"primary_axis": primary_axis, "secondary_axis": secondary_axis},
+    )
+
+
+def axis_angle_to_rotation(
+    axis: nt.SocketOrVal[pt.Vector] = (0, 0, 1), angle: nt.SocketOrVal[float] = 0.0
+) -> nt.ProcNode[pt.Vector]:
+    """
+    Uses a AxisAngleToRotation Function Node.
+
+    See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/rotation/axis_angle_to_rotation.html
+    """
+    return nt.ProcNode.from_nodetype(
+        node_type="FunctionNodeAxisAngleToRotation",
+        inputs={"Axis": axis, "Angle": angle},
+        attrs={},
+    )
+
+
+def boolean_or(
+    a: nt.SocketOrVal[bool] = False,
+    b: nt.SocketOrVal[bool] = False,
+) -> nt.ProcNode[bool]:
+    return nt.ProcNode.from_nodetype(
+        node_type="FunctionNodeBooleanMath",
+        inputs={("Boolean", 0): a, ("Boolean", 1): b},
+        attrs={"operation": "OR"},
+    )
+
+
+def boolean_and(
+    a: nt.SocketOrVal[bool] = False,
+    b: nt.SocketOrVal[bool] = False,
+) -> nt.ProcNode[bool]:
+    return nt.ProcNode.from_nodetype(
+        node_type="FunctionNodeBooleanMath",
+        inputs={("Boolean", 0): a, ("Boolean", 1): b},
+        attrs={"operation": "AND"},
+    )
+
+
+def boolean_xor(
+    a: nt.SocketOrVal[bool] = False,
+    b: nt.SocketOrVal[bool] = False,
+) -> nt.ProcNode[bool]:
+    return nt.ProcNode.from_nodetype(
+        node_type="FunctionNodeBooleanMath",
+        inputs={("Boolean", 0): a, ("Boolean", 1): b},
+        attrs={"operation": "XOR"},
+    )
+
+
+def boolean_not(
+    a: nt.SocketOrVal[bool] = False,
+) -> nt.ProcNode[bool]:
+    """
+    Uses a BooleanNot Function Node.
+
+    See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/math/boolean_math.html
+    """
+    return nt.ProcNode.from_nodetype(
+        node_type="FunctionNodeBooleanMath",
+        inputs={("Boolean", 0): a},
+        attrs={"operation": "NOT"},
+    )
+
+
+def combine_matrix(
+    column_1_row_1: nt.SocketOrVal[float] = 1.0,
+    column_1_row_2: nt.SocketOrVal[float] = 0.0,
+    column_1_row_3: nt.SocketOrVal[float] = 0.0,
+    column_1_row_4: nt.SocketOrVal[float] = 0.0,
+    column_2_row_1: nt.SocketOrVal[float] = 0.0,
+    column_2_row_2: nt.SocketOrVal[float] = 1.0,
+    column_2_row_3: nt.SocketOrVal[float] = 0.0,
+    column_2_row_4: nt.SocketOrVal[float] = 0.0,
+    column_3_row_1: nt.SocketOrVal[float] = 0.0,
+    column_3_row_2: nt.SocketOrVal[float] = 0.0,
+    column_3_row_3: nt.SocketOrVal[float] = 1.0,
+    column_3_row_4: nt.SocketOrVal[float] = 0.0,
+    column_4_row_1: nt.SocketOrVal[float] = 0.0,
+    column_4_row_2: nt.SocketOrVal[float] = 0.0,
+    column_4_row_3: nt.SocketOrVal[float] = 0.0,
+    column_4_row_4: nt.SocketOrVal[float] = 1.0,
+) -> nt.ProcNode[pt.Matrix]:
+    """
+    Uses a CombineMatrix Function Node.
+
+    See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/matrix/combine_matrix.html
+    """
+    return nt.ProcNode.from_nodetype(
+        node_type="FunctionNodeCombineMatrix",
+        inputs={
+            "Column 1 Row 1": column_1_row_1,
+            "Column 1 Row 2": column_1_row_2,
+            "Column 1 Row 3": column_1_row_3,
+            "Column 1 Row 4": column_1_row_4,
+            "Column 2 Row 1": column_2_row_1,
+            "Column 2 Row 2": column_2_row_2,
+            "Column 2 Row 3": column_2_row_3,
+            "Column 2 Row 4": column_2_row_4,
+            "Column 3 Row 1": column_3_row_1,
+            "Column 3 Row 2": column_3_row_2,
+            "Column 3 Row 3": column_3_row_3,
+            "Column 3 Row 4": column_3_row_4,
+            "Column 4 Row 1": column_4_row_1,
+            "Column 4 Row 2": column_4_row_2,
+            "Column 4 Row 3": column_4_row_3,
+            "Column 4 Row 4": column_4_row_4,
+        },
+        attrs={},
+    )
+
+
+def combine_transform(
+    translation: nt.SocketOrVal[pt.Vector] = (0, 0, 0),
+    rotation: Any = (0, 0, 0),
+    scale: nt.SocketOrVal[pt.Vector] = (1, 1, 1),
+) -> nt.ProcNode[pt.Matrix]:
+    """
+    Uses a CombineTransform Function Node.
+
+    See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/matrix/combine_transform.html
+    """
+    return nt.ProcNode.from_nodetype(
+        node_type="FunctionNodeCombineTransform",
+        inputs={"Translation": translation, "Rotation": rotation, "Scale": scale},
+        attrs={},
+    )
+
+
+TCompare = TypeVar(
+    "TCompare",
+    nt.SocketOrVal[int],
+    nt.SocketOrVal[pt.Color],
+    nt.SocketOrVal[str],
+    nt.SocketOrVal[float],
+    nt.SocketOrVal[pt.Vector],
+)
+
+TCompareOperation = Literal[
+    "LESS_THAN", "LESS_EQUAL", "GREATER_THAN", "GREATER_EQUAL", "EQUAL", "NOT_EQUAL"
+]
+
+
+def _compare(
+    a: TCompare = None,
+    b: TCompare = None,
+    epsilon: nt.SocketOrVal[float] | None = None,
+    operation: TCompareOperation = "EQUAL",
+    data_type: NodeDataType | RuntimeResolveDataType | None = None,
+) -> nt.ProcNode[bool]:
+    """
+    Uses a Compare Function Node.
+
+    See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/math/compare.html
+    """
+
+    # TODO merge with math.less_than etc
+
+    if data_type is None:
+        data_type = RuntimeResolveDataType(
+            [
+                NodeDataType.INT,
+                NodeDataType.FLOAT,
+                NodeDataType.RGBA,
+                NodeDataType.STRING,
+                NodeDataType.FLOAT_VECTOR,
+            ],
+            ["A", "B"],
+        )
+    return nt.ProcNode.from_nodetype(
+        node_type="FunctionNodeCompare",
+        inputs={"A": a, "B": b, "Epsilon": epsilon},
+        attrs={
+            "operation": operation,
+            "data_type": data_type,
+        },
+    )
+
+
+TCompareNumeric = TypeVar("TCompareNumeric", nt.SocketOrVal[int], nt.SocketOrVal[float])
+
+
+def less_than(
+    a: TCompareNumeric = None,
+    b: TCompareNumeric = None,
+) -> nt.ProcNode[bool]:
+    return _compare(a, b, operation="LESS_THAN")
+
+
+def less_equal(
+    a: TCompareNumeric = None,
+    b: TCompareNumeric = None,
+) -> nt.ProcNode[bool]:
+    return _compare(a, b, operation="LESS_EQUAL")
+
+
+def greater_than(
+    a: TCompareNumeric = None,
+    b: TCompareNumeric = None,
+) -> nt.ProcNode[bool]:
+    return _compare(a, b, operation="GREATER_THAN")
+
+
+def greater_equal(
+    a: TCompareNumeric = None,
+    b: TCompareNumeric = None,
+) -> nt.ProcNode[bool]:
+    return _compare(a, b, operation="GREATER_EQUAL")
+
+
+TCompareEqual = TypeVar(
+    "TCompareEqual",
+    nt.SocketOrVal[int],
+    nt.SocketOrVal[float],
+)
+
+
+def equal(
+    a: TCompareEqual = None,
+    b: TCompareEqual = None,
+    epsilon: nt.SocketOrVal[float] | None = None,
+) -> nt.ProcNode[bool]:
+    return _compare(a, b, epsilon, operation="EQUAL")
+
+
+def not_equal(
+    a: TCompareEqual = None,
+    b: TCompareEqual = None,
+    epsilon: nt.SocketOrVal[float] | None = None,
+) -> nt.ProcNode[bool]:
+    return _compare(a, b, epsilon, operation="NOT_EQUAL")
+
+
+def vector_compare_elementwise(
+    a: nt.SocketOrVal[pt.Vector] = (0, 0, 0),
+    b: nt.SocketOrVal[pt.Vector] = (0, 0, 0),
+    epsilon: nt.SocketOrVal[float] = 0.001,
+    operation: TCompareOperation = "EQUAL",
+) -> nt.ProcNode[bool]:
+    # TODO merge with math.less_than etc
+
+    return nt.ProcNode.from_nodetype(
+        node_type="FunctionNodeCompare",
+        inputs={"A": a, "B": b, "Epsilon": epsilon},
+        attrs={
+            "operation": operation,
+            "data_type": NodeDataType.FLOAT_VECTOR,
+            "mode": "ELEMENT_WISE",
+        },
+    )
+
+
+def compare_color(
+    a: nt.SocketOrVal[pt.Color],
+    b: nt.SocketOrVal[pt.Color],
+    operation: Literal["EQUAL", "NOT_EQUAL", "BRIGHTER", "DARKER"],
+    epsilon: nt.SocketOrVal[float] = 0.001,
+) -> nt.ProcNode[bool]:
+    return nt.ProcNode.from_nodetype(
+        node_type="FunctionNodeCompare",
+        inputs={"A": a, "B": b, "Epsilon": epsilon},
+        attrs={"operation": operation},
+    )
+
+
+def euler_to_rotation(
+    euler: nt.SocketOrVal[pt.Vector] = (0, 0, 0),
+) -> nt.ProcNode[pt.Vector]:
+    """
+    Uses a EulerToRotation Function Node.
+
+    See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/rotation/euler_to_rotation.html
+    """
+    return nt.ProcNode.from_nodetype(
+        node_type="FunctionNodeEulerToRotation",
+        inputs={"Euler": euler},
+        attrs={},
+    )
+
+
+def float_to_int(
+    float: nt.SocketOrVal[float] = 0.0,
+    rounding_mode: Literal["ROUND", "FLOOR", "CEILING", "TRUNCATE"] = "ROUND",
+) -> nt.ProcNode[int]:
+    """
+    Uses a FloatToInt Function Node.
+
+    See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/math/float_to_integer.html
+    """
+    return nt.ProcNode.from_nodetype(
+        node_type="FunctionNodeFloatToInt",
+        inputs={"Float": float},
+        attrs={"rounding_mode": rounding_mode},
+    )
+
+
+'''
+def input_bool(boolean: bool = False) -> t.ProcNode[bool]:
+    """
+    Uses a InputBool Function Node.
+
+    See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/input/constant/boolean.html
+    """
+
+    raise_io_error("input_bool", logger=logger)
+
+    return t.ProcNode.from_nodetype(
+        node_type="FunctionNodeInputBool",
+        inputs={},
+        attrs={"boolean": boolean},
+    )
+
+
+def input_color(value: tuple = (0.5, 0.5, 0.5, 1.0)) -> t.ProcNode[pt.Color]:
+    """
+    Uses a InputColor Function Node.
+
+    See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/input/constant/color.html
+    """
+
+    raise_io_error("input_color", logger=logger)
+
+    return t.ProcNode.from_nodetype(
+        node_type="FunctionNodeInputColor",
+        inputs={},
+        attrs={"value": value},
+    )
+
+
+def input_int(integer: int = 0) -> t.ProcNode[int]:
+    """
+    Uses a InputInt Function Node.
+
+    See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/input/constant/integer.html
+    """
+
+    raise_io_error("input_int", logger=logger)
+
+    return t.ProcNode.from_nodetype(
+        node_type="FunctionNodeInputInt",
+        inputs={},
+        attrs={"integer": integer},
+    )
+
+
+def input_rotation(rotation_euler: tuple = (0.0, 0.0, 0.0)) -> t.ProcNode[pt.Vector]:
+    """
+    Uses a InputRotation Function Node.
+
+    See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/input/constant/rotation.html
+    """
+
+    raise_io_error("input_rotation", logger=logger)
+
+    return t.ProcNode.from_nodetype(
+        node_type="FunctionNodeInputRotation",
+        inputs={},
+        attrs={"rotation_euler": rotation_euler},
+    )
+'''
+
+
+class InputSpecialCharactersResult(NamedTuple):
+    line_break: nt.ProcNode[str]
+    tab: nt.ProcNode[str]
+
+
+def input_special_characters() -> InputSpecialCharactersResult:
+    """
+    Uses a InputSpecialCharacters Function Node.
+
+    See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/text/special_characters.html
+    """
+
+    raise_io_error("input_special_characters", logger=logger)
+
+    node = nt.ProcNode.from_nodetype(
+        node_type="FunctionNodeInputSpecialCharacters",
+        inputs={},
+        attrs={},
+    )
+    return InputSpecialCharactersResult(
+        node._output_socket("line_break"), node._output_socket("tab")
+    )
+
+
+def input_string(string: str = "") -> nt.ProcNode[str]:
+    """
+    Uses a InputString Function Node.
+
+    See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/input/constant/string.html
+    """
+
+    raise_io_error("input_string", logger=logger)
+
+    return nt.ProcNode.from_nodetype(
+        node_type="FunctionNodeInputString",
+        inputs={},
+        attrs={"string": string},
+    )
+
+
+def input_vector(vector: tuple = (0.0, 0.0, 0.0)) -> nt.ProcNode[pt.Vector]:
+    """
+    Uses a InputVector Function Node.
+
+    See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/input/constant/vector.html
+    """
+
+    raise_io_error("input_vector", logger=logger)
+
+    return nt.ProcNode.from_nodetype(
+        node_type="FunctionNodeInputVector",
+        inputs={},
+        attrs={"vector": vector},
+    )
+
+
+class InvertMatrixResult(NamedTuple):
+    matrix: nt.ProcNode[pt.Matrix]
+    invertible: nt.ProcNode[bool]
+
+
+def invert_matrix(matrix: nt.SocketOrVal[pt.Matrix] = None) -> InvertMatrixResult:
+    """
+    Uses a InvertMatrix Function Node.
+
+    See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/matrix/invert_matrix.html
+    """
+    node = nt.ProcNode.from_nodetype(
+        node_type="FunctionNodeInvertMatrix",
+        inputs={"Matrix": matrix},
+        attrs={},
+    )
+    return InvertMatrixResult(
+        node._output_socket("matrix"), node._output_socket("invertible")
+    )
+
+
+def invert_rotation(
+    rotation: nt.SocketOrVal[pt.Vector] = (0, 0, 0),
+) -> nt.ProcNode[pt.Vector]:
+    """
+    Uses a InvertRotation Function Node.
+
+    See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/rotation/invert_rotation.html
+    """
+    return nt.ProcNode.from_nodetype(
+        node_type="FunctionNodeInvertRotation",
+        inputs={"Rotation": rotation},
+        attrs={},
+    )
+
+
+def matrix_multiply(
+    matrix_0: nt.SocketOrVal[pt.Matrix] = None,
+    matrix_1: nt.SocketOrVal[pt.Matrix] = None,
+) -> nt.ProcNode[pt.Matrix]:
+    """
+    Uses a MatrixMultiply Function Node.
+
+    See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/matrix/multiply_matrices.html
+    """
+    return nt.ProcNode.from_nodetype(
+        node_type="FunctionNodeMatrixMultiply",
+        inputs={("Matrix", 0): matrix_0, ("Matrix", 1): matrix_1},
+        attrs={},
+    )
+
+
+def project_point(
+    vector: nt.SocketOrVal[pt.Vector] = (0, 0, 0),
+    transform: nt.SocketOrVal[pt.Matrix] = None,
+) -> nt.ProcNode[pt.Vector]:
+    """
+    Uses a ProjectPoint Function Node.
+
+    See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/matrix/project_point.html
+    """
+    return nt.ProcNode.from_nodetype(
+        node_type="FunctionNodeProjectPoint",
+        inputs={"Vector": vector, "Transform": transform},
+        attrs={},
+    )
+
+
+def quaternion_to_rotation(
+    w: nt.SocketOrVal[float] = 1.0,
+    x: nt.SocketOrVal[float] = 0.0,
+    y: nt.SocketOrVal[float] = 0.0,
+    z: nt.SocketOrVal[float] = 0.0,
+) -> nt.ProcNode[pt.Vector]:
+    """
+    Uses a QuaternionToRotation Function Node.
+
+    See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/rotation/quaternion_to_rotation.html
+    """
+    return nt.ProcNode.from_nodetype(
+        node_type="FunctionNodeQuaternionToRotation",
+        inputs={"W": w, "X": x, "Y": y, "Z": z},
+        attrs={},
+    )
+
+
+TRandomValue = TypeVar("TRandomValue", int, float, pt.Vector, pt.Color)
+
+
+def random_value(
+    min: nt.SocketOrVal[TRandomValue] = 0.0,
+    max: nt.SocketOrVal[TRandomValue] = 1.0,
+    id: nt.SocketOrVal[int] = 0,
+    seed: nt.SocketOrVal[int] = 0,
+    data_type: NodeDataType | RuntimeResolveDataType | None = None,
+) -> nt.ProcNode[TRandomValue]:
+    """
+    Uses a RandomValue Function Node.
+
+    See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/random_value.html
+    """
+
+    if data_type is None:
+        data_type = RuntimeResolveDataType(
+            [
+                NodeDataType.INT,
+                NodeDataType.FLOAT,
+                NodeDataType.FLOAT_VECTOR,
+                NodeDataType.RGBA,
+            ],
+            ["Min", "Max"],
+        )
+
+    return nt.ProcNode.from_nodetype(
+        node_type="FunctionNodeRandomValue",
+        inputs={
+            "ID": id,
+            "Max": max,
+            "Min": min,
+            "Seed": seed,
+        },
+        attrs={"data_type": data_type},
+    )
+
+
+def random_boolean(
+    probability: nt.SocketOrVal[float] = 0.5,
+    id: nt.SocketOrVal[int] = 0,
+    seed: nt.SocketOrVal[int] = 0,
+) -> nt.ProcNode[bool]:
+    """
+    Uses a RandomBoolean Function Node.
+    """
+    return nt.ProcNode.from_nodetype(
+        node_type="FunctionNodeRandomValue",
+        inputs={"ID": id, "Probability": probability, "Seed": seed},
+        attrs={"data_type": NodeDataType.BOOLEAN},
+    )
+
+
+def replace_string(
+    string: nt.SocketOrVal[str] = "",
+    find: nt.SocketOrVal[str] = "",
+    replace: nt.SocketOrVal[str] = "",
+) -> nt.ProcNode[str]:
+    """
+    Uses a ReplaceString Function Node.
+
+    See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/text/replace_string.html
+    """
+    return nt.ProcNode.from_nodetype(
+        node_type="FunctionNodeReplaceString",
+        inputs={"String": string, "Find": find, "Replace": replace},
+        attrs={},
+    )
+
+
+def rotate_euler(
+    rotation: nt.SocketOrVal[pt.Vector] = (0, 0, 0),
+    rotate_by: nt.SocketOrVal[pt.Vector] = (0, 0, 0),
+    rotation_type: Literal["EULER", "AXIS_ANGLE"] = "EULER",
+    space: Literal["OBJECT", "LOCAL"] = "OBJECT",
+) -> nt.ProcNode[pt.Vector]:
+    """
+    Uses a RotateEuler Function Node.
+
+    See: http://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/rotation/rotate_euler.html
+    """
+    return nt.ProcNode.from_nodetype(
+        node_type="FunctionNodeRotateEuler",
+        inputs={"Rotation": rotation, "Rotate By": rotate_by},
+        attrs={"rotation_type": rotation_type, "space": space},
+    )
+
+
+def rotate_rotation(
+    rotation: Any = (0, 0, 0),
+    rotate_by: Any = (0, 0, 0),
+    rotation_space: Literal["GLOBAL", "LOCAL"] = "GLOBAL",
+) -> nt.ProcNode[pt.Vector]:
+    """
+    Uses a RotateRotation Function Node.
+
+    See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/rotation/rotate_rotation.html
+    """
+    return nt.ProcNode.from_nodetype(
+        node_type="FunctionNodeRotateRotation",
+        inputs={"Rotation": rotation, "Rotate By": rotate_by},
+        attrs={"rotation_space": rotation_space},
+    )
+
+
+def rotate_vector(
+    vector: nt.SocketOrVal[pt.Vector] = (0, 0, 0), rotation: Any = (0, 0, 0)
+) -> nt.ProcNode[pt.Vector]:
+    """
+    Uses a RotateVector Function Node.
+
+    See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/rotation/rotate_vector.html
+    """
+    return nt.ProcNode.from_nodetype(
+        node_type="FunctionNodeRotateVector",
+        inputs={"Vector": vector, "Rotation": rotation},
+        attrs={},
+    )
+
+
+class RotationToAxisAngleResult(NamedTuple):
+    axis: nt.ProcNode[pt.Vector]
+    angle: nt.ProcNode[float]
+
+
+def rotation_to_axis_angle(
+    rotation: nt.SocketOrVal[pt.Vector] = (0, 0, 0),
+) -> RotationToAxisAngleResult:
+    """
+    Uses a RotationToAxisAngle Function Node.
+
+    See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/rotation/axis_angle_to_rotation.html
+    """
+    node = nt.ProcNode.from_nodetype(
+        node_type="FunctionNodeRotationToAxisAngle",
+        inputs={"Rotation": rotation},
+        attrs={},
+    )
+    return RotationToAxisAngleResult(
+        node._output_socket("axis"), node._output_socket("angle")
+    )
+
+
+def rotation_to_euler(
+    rotation: nt.SocketOrVal[pt.Vector] = (0, 0, 0),
+) -> nt.ProcNode[pt.Vector]:
+    """
+    Uses a RotationToEuler Function Node.
+
+    See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/rotation/rotation_to_euler.html
+    """
+    return nt.ProcNode.from_nodetype(
+        node_type="FunctionNodeRotationToEuler",
+        inputs={"Rotation": rotation},
+        attrs={},
+    )
+
+
+class RotationToQuaternionResult(NamedTuple):
+    w: nt.ProcNode[float]
+    x: nt.ProcNode[float]
+    y: nt.ProcNode[float]
+    z: nt.ProcNode[float]
+
+
+def rotation_to_quaternion(
+    rotation: nt.SocketOrVal[pt.Vector] = (0, 0, 0),
+) -> RotationToQuaternionResult:
+    """
+    Uses a RotationToQuaternion Function Node.
+
+    See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/rotation/rotation_to_quaternion.html
+    """
+    node = nt.ProcNode.from_nodetype(
+        node_type="FunctionNodeRotationToQuaternion",
+        inputs={"Rotation": rotation},
+        attrs={},
+    )
+    return RotationToQuaternionResult(
+        node._output_socket("w"),
+        node._output_socket("x"),
+        node._output_socket("y"),
+        node._output_socket("z"),
+    )
+
+
+class SeparateColorResult(NamedTuple):
+    red: nt.ProcNode[float]
+    green: nt.ProcNode[float]
+    blue: nt.ProcNode[float]
+    alpha: nt.ProcNode[float]
+
+
+def separate_color(
+    color: nt.SocketOrVal[pt.Color] = (1, 1, 1, 1),
+    mode: Literal["RGB", "HSV", "HSL"] = "RGB",
+    ycc_mode: Literal["ITUBT601", "ITUBT709", "JFIF"] = "ITUBT709",
+) -> SeparateColorResult:
+    """
+    Uses a SeparateColor Function Node.
+
+    Context mapping:
+    - Shader: ShaderNodeSeparateColor (input: Color, outputs: red/green/blue, mode: RGB only)
+    - Compositor: CompositorNodeSeparateColor (input: Image, outputs: red/green/blue/alpha, modes: RGB/HSV/HSL/YCC/YUV, ycc_mode param)
+    - Texture: TextureNodeSeparateColor (input: Color, modes: RGB/HSV/HSL)
+    - Function: FunctionNodeSeparateColor (input: Color, outputs: red/green/blue/alpha)
+
+    See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/color/separate_color.html
+    """
+    res = nt.ProcNode.from_nodetype(
+        node_type=ContextualNode.SEPARATE_COLOR.value,
+        inputs={"Color": color},
+        attrs={"mode": mode},
+    )
+    return SeparateColorResult(
+        red=res._output_socket("red"),
+        green=res._output_socket("green"),
+        blue=res._output_socket("blue"),
+        alpha=res._output_socket("alpha"),
+    )
+
+
+"""
+def separate_matrix(matrix: t.SocketOrVal[pt.Matrix] = None) -> t.ProcNode[pt.Matrix]:
+ 
+    return t.ProcNode.from_nodetype(
+        node_type="FunctionNodeSeparateMatrix",
+        inputs={"Matrix": matrix},
+        attrs={},
+            "column_1_row_1",
+            "column_1_row_2",
+            "column_1_row_3",
+            "column_1_row_4",
+            "column_2_row_1",
+            "column_2_row_2",
+            "column_2_row_3",
+            "column_2_row_4",
+            "column_3_row_1",
+            "column_3_row_2",
+            "column_3_row_3",
+            "column_3_row_4",
+            "column_4_row_1",
+            "column_4_row_2",
+            "column_4_row_3",
+            "column_4_row_4",
+        ],
+    )
+"""
+
+
+class SeparateTransformResult(NamedTuple):
+    translation: nt.ProcNode[pt.Vector]
+    rotation: nt.ProcNode[pt.Vector]
+    scale: nt.ProcNode[pt.Vector]
+
+
+def separate_transform(
+    transform: nt.SocketOrVal[pt.Matrix] = None,
+) -> SeparateTransformResult:
+    """
+    Uses a SeparateTransform Function Node.
+
+    See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/matrix/separate_transform.html
+    """
+    node = nt.ProcNode.from_nodetype(
+        node_type="FunctionNodeSeparateTransform",
+        inputs={"Transform": transform},
+        attrs={},
+    )
+    return SeparateTransformResult(
+        node._output_socket("translation"),
+        node._output_socket("rotation"),
+        node._output_socket("scale"),
+    )
+
+
+def slice_string(
+    string: nt.SocketOrVal[str] = "",
+    position: nt.SocketOrVal[int] = 0,
+    length: nt.SocketOrVal[int] = 10,
+) -> nt.ProcNode[str]:
+    """
+    Uses a SliceString Function Node.
+
+    See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/text/slice_string.html
+    """
+    return nt.ProcNode.from_nodetype(
+        node_type="FunctionNodeSliceString",
+        inputs={"String": string, "Position": position, "Length": length},
+        attrs={},
+    )
+
+
+def string_length(string: nt.SocketOrVal[str] = "") -> nt.ProcNode[int]:
+    """
+    Uses a StringLength Function Node.
+
+    See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/text/string_length.html
+    """
+    return nt.ProcNode.from_nodetype(
+        node_type="FunctionNodeStringLength",
+        inputs={"String": string},
+        attrs={},
+    )
+
+
+def transform_direction(
+    direction: nt.SocketOrVal[pt.Vector] = (0, 0, 0),
+    transform: nt.SocketOrVal[pt.Matrix] = None,
+) -> nt.ProcNode[pt.Vector]:
+    """
+    Uses a TransformDirection Function Node.
+
+    See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/matrix/transform_direction.html
+    """
+    return nt.ProcNode.from_nodetype(
+        node_type="FunctionNodeTransformDirection",
+        inputs={"Direction": direction, "Transform": transform},
+        attrs={},
+    )
+
+
+def transform_point(
+    vector: nt.SocketOrVal[pt.Vector] = (0, 0, 0),
+    transform: nt.SocketOrVal[pt.Matrix] = None,
+) -> nt.ProcNode[pt.Vector]:
+    """
+    Uses a TransformPoint Function Node.
+
+    See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/matrix/transform_point.html
+    """
+    return nt.ProcNode.from_nodetype(
+        node_type="FunctionNodeTransformPoint",
+        inputs={"Vector": vector, "Transform": transform},
+        attrs={},
+    )
+
+
+def transpose_matrix(
+    matrix: nt.SocketOrVal[pt.Matrix] = None,
+) -> nt.ProcNode[pt.Matrix]:
+    """
+    Uses a TransposeMatrix Function Node.
+
+    See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/matrix/transpose_matrix.html
+    """
+    return nt.ProcNode.from_nodetype(
+        node_type="FunctionNodeTransposeMatrix",
+        inputs={"Matrix": matrix},
+        attrs={},
+    )
+
+
+def value_to_string(
+    value: nt.SocketOrVal[float] = 0.0, decimals: nt.SocketOrVal[int] = 0
+) -> nt.ProcNode[str]:
+    """
+    Uses a ValueToString Function Node.
+
+    See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/text/value_to_string.html
+    """
+    return nt.ProcNode.from_nodetype(
+        node_type="FunctionNodeValueToString",
+        inputs={"Value": value, "Decimals": decimals},
+        attrs={},
+    )
+
+
+TMix = TypeVar("TMix", nt.SocketOrVal[float], nt.SocketOrVal[pt.Vector])
+
+
+def mix(
+    a: TMix | None = None,
+    b: TMix | None = None,
+    factor: nt.SocketOrVal[float] = 0.5,
+    clamp_factor: bool = True,
+    factor_mode: Literal["UNIFORM", "NON_UNIFORM"] = "UNIFORM",
+    data_type: NodeDataType | RuntimeResolveDataType | None = None,
+) -> nt.ProcNode[TMix]:
+    """
+    Uses MixNode to mix float or vector fields
+
+    NOTE: procfunc forces all colors to be mixed via mix_rgb, since setting this function
+    to type Color adds extra args & exactly matches the interface of mix_rgb
+
+    """
+
+    if data_type is None:
+        data_type = RuntimeResolveDataType(
+            [NodeDataType.RGBA, NodeDataType.FLOAT, NodeDataType.FLOAT_VECTOR],
+            ["A", "B"],
+        )
+    return nt.ProcNode.from_nodetype(
+        node_type="ShaderNodeMix",
+        inputs={"A": a, "B": b, "Factor": factor},
+        attrs={
+            "blend_type": "MIX",
+            "clamp_factor": clamp_factor,
+            "clamp_result": False,
+            "factor_mode": factor_mode,
+            "data_type": data_type,
+        },
+    )
+
+
+TColorMixType = Literal[
+    "MIX",
+    "DARKEN",
+    "MULTIPLY",
+    "BURN",
+    "LIGHTEN",
+    "SCREEN",
+    "DODGE",
+    "ADD",
+    "OVERLAY",
+    "SOFT_LIGHT",
+    "LINEAR_LIGHT",
+    "DIFFERENCE",
+    "EXCLUSION",
+    "SUBTRACT",
+    "DIVIDE",
+    "HUE",
+    "SATURATION",
+    "COLOR",
+    "VALUE",
+]
+
+
+def mix_rgb(
+    factor: nt.SocketOrVal[float] = 0.5,
+    a: nt.SocketOrVal[pt.Color] = (0.5, 0.5, 0.5, 1),
+    b: nt.SocketOrVal[pt.Color] = (0.5, 0.5, 0.5, 1),
+    blend_type: TColorMixType = "MIX",
+    clamp_result: bool = False,
+    clamp_factor: bool = True,
+) -> nt.ProcNode[pt.Color]:
+    """
+    Uses a Mix Node with datatype Color
+
+    NOTE: separated from float/vector mix() due to extra arguments
+
+    See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/color/mix.html
+    """
+    return nt.ProcNode.from_nodetype(
+        node_type="ShaderNodeMix",
+        inputs={"Factor": factor, "A": a, "B": b},
+        attrs={
+            "blend_type": blend_type,
+            "clamp_result": clamp_result,
+            "clamp_factor": clamp_factor,
+            "data_type": NodeDataType.RGBA,
+        },
+    )
+
+
+def rgb_curve(
+    fac: nt.SocketOrVal[float] = 1.0,
+    color: nt.SocketOrVal[pt.Color] = (1, 1, 1, 1),
+    curves: list[np.ndarray] | None = None,
+) -> nt.ProcNode:
+    """
+    Uses a RGBCurve Shader Node.
+
+    See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/color/rgb_curves.html
+    """
+    return nt.ProcNode.from_nodetype(
+        node_type="ShaderNodeRGBCurve",
+        inputs={"Fac": fac, "Color": color},
+        attrs={"curves": curves},
+    )
+
+
+def combine_color(
+    red: nt.SocketOrVal[float] = 0.0,
+    green: nt.SocketOrVal[float] = 0.0,
+    blue: nt.SocketOrVal[float] = 0.0,
+    mode: Literal["RGB", "HSV", "HSL"] = "RGB",
+) -> nt.ProcNode[pt.Color]:
+    """
+    Uses a CombineColor Shader Node.
+
+    See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/converter/combine_color.html
+    """
+    return nt.ProcNode.from_nodetype(
+        node_type=ContextualNode.COMBINE_COLOR.value,
+        inputs={"Red": red, "Green": green, "Blue": blue},
+        attrs={"mode": mode},
+    )
+
+
+def combine_rgb(
+    red: nt.SocketOrVal[float] = 0.0,
+    green: nt.SocketOrVal[float] = 0.0,
+    blue: nt.SocketOrVal[float] = 0.0,
+    mode: Literal["RGB", "HSV", "HSL"] = "RGB",
+) -> nt.ProcNode[pt.Color]:
+    """
+    Uses a CombineColor Shader Node.
+
+    See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/converter/combine_color.html
+    """
+    return nt.ProcNode.from_nodetype(
+        node_type=ContextualNode.COMBINE_COLOR.value,
+        inputs={"Red": red, "Green": green, "Blue": blue},
+        attrs={"mode": mode},
+    )
+
+
+def combine_hsv(
+    hue: nt.SocketOrVal[float] = 0.0,
+    saturation: nt.SocketOrVal[float] = 0.0,
+    value: nt.SocketOrVal[float] = 0.0,
+) -> nt.ProcNode[pt.Color]:
+    """
+    Uses a CombineColor Shader Node.
+
+    See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/converter/combine_color.html
+    """
+    return nt.ProcNode.from_nodetype(
+        node_type=ContextualNode.COMBINE_COLOR.value,
+        inputs={"Hue": hue, "Saturation": saturation, "Value": value},
+        attrs={"mode": "HSV"},
+    )
+
+
+def combine_hsl(
+    hue: nt.SocketOrVal[float] = 0.0,
+    saturation: nt.SocketOrVal[float] = 0.0,
+    lightness: nt.SocketOrVal[float] = 0.0,
+) -> nt.ProcNode[pt.Color]:
+    """
+    Uses a CombineHSV Shader Node.
+
+    See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/converter/combine_color.html
+    """
+    return nt.ProcNode.from_nodetype(
+        node_type=ContextualNode.COMBINE_COLOR.value,
+        inputs={"Hue": hue, "Saturation": saturation, "Lightness": lightness},
+        attrs={"mode": "HSL"},
+    )
+
+
+def combine_xyz(
+    x: nt.SocketOrVal[float] = 0.0,
+    y: nt.SocketOrVal[float] = 0.0,
+    z: nt.SocketOrVal[float] = 0.0,
+) -> nt.ProcNode[pt.Vector]:
+    """
+    Uses a CombineXYZ Shader Node.
+
+    See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/converter/combine_xyz.html
+    """
+    return nt.ProcNode.from_nodetype(
+        node_type="ShaderNodeCombineXYZ",
+        inputs={"X": x, "Y": y, "Z": z},
+        attrs={},
+    )
+
+
+class SeparateHsvResult(NamedTuple):
+    h: nt.ProcNode[float]
+    s: nt.ProcNode[float]
+    v: nt.ProcNode[float]
+
+
+def separate_hsv(
+    color: nt.SocketOrVal[pt.Color] = (0.8, 0.8, 0.8, 1),
+) -> SeparateHsvResult:
+    """
+    Uses a SeparateHSV Shader Node.
+
+    See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/converter/separate_color.html
+    """
+    res = nt.ProcNode.from_nodetype(
+        node_type="ShaderNodeSeparateHSV",
+        inputs={"Color": color},
+        attrs={},
+    )
+    return SeparateHsvResult(
+        h=res._output_socket("h"),
+        s=res._output_socket("s"),
+        v=res._output_socket("v"),
+    )
+
+
+class SeparateRgbResult(NamedTuple):
+    r: nt.ProcNode[float]
+    g: nt.ProcNode[float]
+    b: nt.ProcNode[float]
+
+
+def separate_rgb(
+    image: nt.SocketOrVal[pt.Color] = (0.8, 0.8, 0.8, 1),
+) -> SeparateRgbResult:
+    """
+    Uses a SeparateRGB Shader Node.
+
+    See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/converter/separate_color.html
+    """
+    res = nt.ProcNode.from_nodetype(
+        node_type="ShaderNodeSeparateRGB",
+        inputs={"Image": image},
+        attrs={},
+    )
+    return SeparateRgbResult(
+        r=res._output_socket("r"),
+        g=res._output_socket("g"),
+        b=res._output_socket("b"),
+    )
+
+
+class SeparateXyzResult(NamedTuple):
+    x: nt.ProcNode[float]
+    y: nt.ProcNode[float]
+    z: nt.ProcNode[float]
+
+
+def separate_xyz(vector: nt.SocketOrVal[pt.Vector] = (0, 0, 0)) -> SeparateXyzResult:
+    """
+    Uses a SeparateXYZ Shader Node.
+
+    See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/converter/separate_xyz.html
+    """
+    node = nt.ProcNode.from_nodetype(
+        node_type="ShaderNodeSeparateXYZ",
+        inputs={"Vector": vector},
+        attrs={},
+    )
+    return SeparateXyzResult(
+        node._output_socket("x"), node._output_socket("y"), node._output_socket("z")
+    )
+
+
+TInterpolationType = Literal["LINEAR", "STEPPED_LINEAR", "SMOOTHSTEP", "SMOOTHERSTEP"]
+
+
+def map_range(
+    value: nt.SocketOrVal[float] = 1.0,
+    from_max: nt.SocketOrVal[float] = 1.0,
+    from_min: nt.SocketOrVal[float] = 0.0,
+    to_max: nt.SocketOrVal[float] = 1.0,
+    to_min: nt.SocketOrVal[float] = 0.0,
+    clamp: bool = True,
+    interpolation_type: TInterpolationType = "LINEAR",
+    data_type: NodeDataType | RuntimeResolveDataType | None = None,
+) -> nt.ProcNode:
+    """
+    Uses a MapRange Shader Node.
+
+    See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/converter/map_range.html
+    """
+
+    if data_type is None:
+        data_type = RuntimeResolveDataType(
+            [NodeDataType.FLOAT, NodeDataType.FLOAT_VECTOR],
+            ["From Max", "From Min", "To Max", "To Min", "Value"],
+        )
+
+    return nt.ProcNode.from_nodetype(
+        node_type="ShaderNodeMapRange",
+        inputs={
+            "From Max": from_max,
+            "From Min": from_min,
+            "To Max": to_max,
+            "To Min": to_min,
+            "Value": value,
+        },
+        attrs={
+            "clamp": clamp,
+            "interpolation_type": interpolation_type,
+            "data_type": data_type,
+        },
+    )
+
+
+def float_curve(
+    factor: nt.SocketOrVal[float] = 1.0,
+    value: nt.SocketOrVal[float] = 1.0,
+    curve: np.ndarray | None = None,
+    handle_type: str = "AUTO",
+    use_clip: bool = True,
+) -> nt.ProcNode[float]:
+    """
+    Uses a FloatCurve Shader Node.
+
+    See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/converter/float_curve.html
+    """
+    return nt.ProcNode.from_nodetype(
+        node_type="ShaderNodeFloatCurve",
+        inputs={"Factor": factor, "Value": value},
+        attrs={"mapping": curve, "handle_type": handle_type, "use_clip": use_clip},
+    )
+
+
+def vector_curve(
+    fac: nt.SocketOrVal[float] = 1.0,
+    vector: nt.SocketOrVal[pt.Vector] = (0, 0, 0),
+    curves: np.ndarray | None = None,
+) -> nt.ProcNode[pt.Vector]:
+    """
+    Uses a VectorCurve Shader Node.
+
+    See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/vector/curves.html
+    """
+    return nt.ProcNode.from_nodetype(
+        node_type="ShaderNodeVectorCurve",
+        inputs={"Fac": fac, "Vector": vector},
+        attrs={"curves": curves},
+    )
+
+
+TIndexSwitch = TypeVar(
+    "TIndexSwitch",
+    nt.SocketOrVal[bool],
+    nt.SocketOrVal[int],
+    nt.SocketOrVal[pt.Color],
+    nt.SocketOrVal[str],
+    nt.SocketOrVal[float],
+    nt.SocketOrVal[nt.pt.Vector],
+)
+
+
+def index_switch(
+    val_0: TIndexSwitch = 0,
+    val_1: TIndexSwitch = 0,
+    index: nt.SocketOrVal[int] = 0,
+    data_type: NodeDataType | RuntimeResolveDataType | None = None,
+) -> nt.ProcNode:
+    """
+    Uses a IndexSwitch Geometry Node.
+
+    See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/index_switch.html
+    """
+    if data_type is None:
+        data_type = RuntimeResolveDataType(
+            [
+                NodeDataType.BOOLEAN,
+                NodeDataType.INT,
+                NodeDataType.RGBA,
+                NodeDataType.STRING,
+                NodeDataType.FLOAT,
+                NodeDataType.FLOAT_VECTOR,
+            ],
+            ["0", "1"],
+        )
+    return nt.ProcNode.from_nodetype(
+        node_type="GeometryNodeIndexSwitch",
+        inputs={"0": val_0, "1": val_1, "Index": index},
+        attrs={
+            "data_type": data_type,
+        },
+    )
+
+
+TSwitchArgType = TypeVar(
+    "TAnyDataVal",
+    int,
+    float,
+    bool,
+    str,
+    pt.Vector,
+    pt.Color,
+    pt.Matrix,
+    pt.Quaternion,
+    nt.Geometry,
+)
+
+_SWITCH_DATA_TYPES = [
+    NodeDataType.BOOLEAN,
+    NodeDataType.INT,
+    NodeDataType.FLOAT,
+    NodeDataType.STRING,
+    NodeDataType.FLOAT_VECTOR,
+    NodeDataType.RGBA,
+    NodeDataType.FLOAT_MATRIX,
+    NodeDataType.GEOMETRY,
+]
+
+
+def switch(
+    switch: nt.SocketOrVal[bool] = False,
+    a: nt.SocketOrVal[TSwitchArgType] | None = None,
+    b: nt.SocketOrVal[TSwitchArgType] | None = None,
+    data_type: NodeDataType | RuntimeResolveDataType | None = None,
+) -> nt.ProcNode[TSwitchArgType]:
+    """
+    Uses a Switch Geometry Node.
+
+    See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/switch.html
+    """
+
+    if data_type is None:
+        data_type = RuntimeResolveDataType(
+            _SWITCH_DATA_TYPES,
+            ["False", "True"],
+        )
+
+    return nt.ProcNode.from_nodetype(
+        node_type="GeometryNodeSwitch",
+        inputs={"Switch": switch, "False": a, "True": b},
+        attrs={"input_type": data_type},
+    )