nodebpy 0.1.0__py3-none-any.whl

nodebpy/nodes/manually_specified.py

@@ -0,0 +1,1356 @@
+"""
+Some of the nodes need to be manually specified because they are a bit tricky to generate automatically.
+"""
+
+from __future__ import annotations
+
+import bpy
+from bpy.types import NodeSocketFloat, NodeSocketVector
+from typing import Iterable, Literal
+
+from ..builder import (
+    NodeBuilder,
+    NodeSocket,
+    source_socket,
+    SocketLinker,
+)
+from . import types
+from .types import LINKABLE, TYPE_INPUT_BOOLEAN, TYPE_INPUT_VECTOR, _AttributeDomains
+
+_RANDOM_VALUE_DATA_TYPES = Literal["FLOAT", "INT", "BOOLEAN", "FLOAT_VECTOR"]
+
+
+class RandomValue(NodeBuilder):
+    """Random Value node"""
+
+    name = "FunctionNodeRandomValue"
+    node: bpy.types.FunctionNodeRandomValue
+    _default_input_id = "ID"
+
+    def __init__(
+        self,
+        data_type: _RANDOM_VALUE_DATA_TYPES,
+        id: int | LINKABLE | None = None,
+        seed: int | LINKABLE | None = None,
+        **kwargs,
+    ):
+        super().__init__()
+        self.node.data_type = data_type
+        key_args = {
+            "ID": id,
+            "Seed": seed,
+        }
+        key_args.update(kwargs)
+
+        self._establish_links(**key_args)
+
+    @property
+    def data_type(self) -> _RANDOM_VALUE_DATA_TYPES:
+        return self.node.data_type  # type: ignore
+
+    @data_type.setter
+    def data_type(self, value: _RANDOM_VALUE_DATA_TYPES):
+        self.node.data_type = value
+
+    @property
+    def o_value(self) -> NodeSocket:
+        """Output socket: Value"""
+        match self.data_type:
+            case "FLOAT":
+                return self._output("Value_001")
+            case "INT":
+                return self._output("Value_002")
+            case "BOOLEAN":
+                return self._output("Value_003")
+            case "FLOAT_VECTOR":
+                return self._output("Value")
+
+    def i_min(self) -> NodeSocket:
+        """Input socket: Minimum"""
+        match self.data_type:
+            case "FLOAT":
+                return self._input("Min_001")
+            case "INT":
+                return self._input("Min_002")
+            case "BOOLEAN":
+                raise ValueError(
+                    "Boolean data type does not support minimum value, use 'Probability'"
+                )
+            case "FLOAT_VECTOR":
+                return self._input("Min")
+
+    def i_max(self) -> NodeSocket:
+        """Input socket: Maximum"""
+        match self.data_type:
+            case "FLOAT":
+                return self._input("Max_001")
+            case "INT":
+                return self._input("Max_002")
+            case "BOOLEAN":
+                raise ValueError(
+                    "Boolean data type does not support maximum value, use 'Probability'"
+                )
+            case "FLOAT_VECTOR":
+                return self._input("Max")
+
+    def i_probability(self) -> NodeSocket:
+        """Input socket: Probability"""
+        if self.data_type != "BOOLEAN":
+            raise ValueError(
+                f"Probability socket is only supported for boolean data types, not for data type: {self.data_type}"
+            )
+
+        return self._input("Probability")
+
+    @classmethod
+    def float(
+        cls,
+        min: float | LINKABLE = 0.0,
+        max: float | LINKABLE = 1.0,
+        id: int | LINKABLE | None = None,
+        seed: int | LINKABLE = 1,
+    ) -> NodeBuilder:
+        buidler = cls(Min_001=min, Max_001=max, id=id, seed=seed, data_type="FLOAT")
+        buidler._default_output_id = "Value_001"
+        return buidler
+
+    @classmethod
+    def integer(
+        cls,
+        min: int | LINKABLE = 0,
+        max: int | LINKABLE = 1,
+        id: int | LINKABLE | None = None,
+        seed: int | LINKABLE = 1,
+    ) -> NodeBuilder:
+        buidler = cls(Min_002=min, Max_002=max, id=id, seed=seed, data_type="INT")
+        buidler._default_output_id = "Value_002"
+        return buidler
+
+    @classmethod
+    def boolean(
+        cls,
+        probability: float | LINKABLE = 0.5,
+        id: int | LINKABLE | None = None,
+        seed: int | LINKABLE = 1,
+    ) -> NodeBuilder:
+        builder = cls(Probability=probability, id=id, seed=seed, data_type="BOOLEAN")
+        builder._default_output_id = "Value_003"
+        return builder
+
+    @classmethod
+    def vector(
+        cls,
+        min: tuple[float, float, float] | list[float] | LINKABLE = (0.0, 0.0, 0.0),
+        max: tuple[float, float, float] | list[float] | LINKABLE = (1.0, 1.0, 1.0),
+        id: int | LINKABLE | None = None,
+        seed: int | LINKABLE = 1,
+    ) -> NodeBuilder:
+        buidler = cls(Min=min, Max=max, id=id, seed=seed, data_type="FLOAT_VECTOR")
+        buidler._default_output_id = "Value"
+        return buidler
+
+
+class SeparateXYZ(NodeBuilder):
+    """Split a vector into its X, Y, and Z components"""
+
+    name = "ShaderNodeSeparateXYZ"
+    node: bpy.types.ShaderNodeSeparateXYZ  # type: ignore
+
+    def __init__(self, vector: TYPE_INPUT_VECTOR | None = None):
+        super().__init__()
+        self._establish_links(**{"Vector": vector})
+
+    @property
+    def i_vector(self) -> NodeSocket:
+        """Input socket: Vector"""
+        return self._input("Vector")
+
+    @property
+    def o_x(self) -> NodeSocket:
+        """Output socket: X"""
+        return self._output("X")
+
+    @property
+    def o_y(self) -> NodeSocket:
+        """Output socket: Y"""
+        return self._output("Y")
+
+    @property
+    def o_z(self) -> NodeSocket:
+        """Output socket: Z"""
+        return self._output("Z")
+
+
+class CombineXYZ(NodeBuilder):
+    """Create a vector from X, Y, and Z components"""
+
+    name = "ShaderNodeCombineXYZ"
+    node: bpy.types.ShaderNodeCombineXYZ  # type: ignore
+
+    def __init__(
+        self,
+        x: float | LINKABLE = 0.0,
+        y: float | LINKABLE = 0.0,
+        z: float | LINKABLE = 0.0,
+    ):
+        super().__init__()
+        self._establish_links(**{"X": x, "Y": y, "Z": z})
+
+    @property
+    def o_vector(self) -> NodeSocket:
+        """Output socket: Vector"""
+        return self._output("Vector")
+
+    @property
+    def i_x(self) -> NodeSocket:
+        """Input socket: X"""
+        return self._input("X")
+
+    @property
+    def i_y(self) -> NodeSocket:
+        """Input socket: Y"""
+        return self._input("Y")
+
+    @property
+    def i_z(self) -> NodeSocket:
+        """Input socket: Z"""
+        return self._input("Z")
+
+
+_MIX_VALUE_DATA_TYPES = Literal["FLOAT", "VECTOR", "COLOR", "ROTATION"]
+
+
+class Mix(NodeBuilder):
+    """Mix values by a factor"""
+
+    name = "ShaderNodeMix"
+    node: bpy.types.ShaderNodeMix  # type: ignore
+
+    def __init__(
+        self,
+        data_type: _MIX_VALUE_DATA_TYPES = "FLOAT",
+        **kwargs,
+    ):
+        super().__init__()
+        self._default_input_id = f"A_{data_type.title()}"
+        self._default_output_id = f"Result_{data_type.title()}"
+        self.node.data_type = "RGBA" if data_type == "COLOR" else data_type
+        key_args = {}
+        key_args.update(kwargs)
+        self._establish_links(**key_args)
+
+    @property
+    def data_type(self) -> str:
+        return self.node.data_type
+
+    @data_type.setter
+    def data_type(self, value: _MIX_VALUE_DATA_TYPES):
+        self.node.data_type = value  # type: ignore
+
+    @property
+    def factor_mode(self) -> Literal["UNIFORM", "NON_UNIFORM"]:
+        return self.node.factor_mode
+
+    @factor_mode.setter
+    def factor_mode(self, value: Literal["NON_UNIFORM", "UNIFORM"]):
+        self.node.factor_mode = value
+
+    @property
+    def o_result(self) -> NodeSocket:
+        """Output socket: Result"""
+        return self._default_output_socket
+
+    @property
+    def i_factor(self) -> NodeSocket:
+        """Input socket: Factor"""
+        match self.data_type:
+            case "FLOAT":
+                name = "Factor_Float"
+            case "VECTOR":
+                name = (
+                    "Factor_Float" if self.factor_mode == "UNIFORM" else "Factor_Vector"
+                )
+            case "RGBA":
+                name = "Factor_Color"
+            case "ROTATION":
+                name = "Factor_Rotation"
+            case _:
+                raise ValueError(f"Unsupported data type: {self.data_type}")
+
+        idx = self._input_idx(name)
+        return self.node.inputs[idx]
+
+    @property
+    def i_value_a(self) -> NodeSocket:
+        """Input socket: Value A"""
+        type_name = "Color" if self.data_type == "RGBA" else self.data_type
+        name = f"A_{type_name}"
+        idx = self._input_idx(name)
+        return self.node.inputs[idx]
+
+    @property
+    def i_value_b(self) -> NodeSocket:
+        """Input socket: Value B"""
+        type_name = "Color" if self.data_type == "RGBA" else self.data_type
+        name = f"B_{type_name}"
+        idx = self._input_idx(name)
+        return self.node.inputs[idx]
+
+    @classmethod
+    def float(
+        cls,
+        factor: float | LINKABLE = 0.5,
+        a: float | LINKABLE = 0.0,
+        b: float | LINKABLE = 0.0,
+        clamp_factor: bool | LINKABLE = True,
+    ) -> Mix:
+        builder = cls(
+            Factor_Float=factor,
+            A_Float=a,
+            B_Float=b,
+            data_type="COLOR",
+        )
+        builder.node.clamp_factor = clamp_factor
+        return builder
+
+    @classmethod
+    def vector(
+        cls,
+        factor: float | LINKABLE = 0.5,
+        a: tuple[float, float, float] | list[float] | LINKABLE = (0.0, 0.0, 0.0),
+        b: tuple[float, float, float] | list[float] | LINKABLE = (1.0, 1.0, 1.0),
+        clamp_factor: bool = True,
+        factor_mode: Literal["UNIFORM", "NON_UNIFORM"] = "UNIFORM",
+    ) -> Mix:
+        match factor_mode:
+            case "UNIFORM":
+                builder = cls(
+                    Factor_Float=factor,
+                    A_Vector=a,
+                    B_Vector=b,
+                    data_type="VECTOR",
+                )
+            case "NON_UNIFORM":
+                builder = cls(
+                    Factor_Vector=factor,
+                    A_Vector=a,
+                    B_Vector=b,
+                    data_type="VECTOR",
+                )
+
+        builder.node.clamp_factor = clamp_factor
+        return builder
+
+    @classmethod
+    def color(
+        cls,
+        factor: float | LINKABLE = 0.5,
+        a: tuple[float, float, float] | list[float] | LINKABLE = (0.0, 0.0, 0.0),
+        b: tuple[float, float, float] | list[float] | LINKABLE = (1.0, 1.0, 1.0),
+        blend_type: str = "add",
+        clamp_factor: bool = True,
+        clamp_result: bool = True,
+    ) -> Mix:
+        builder = cls(
+            Factor_Float=factor,
+            A_Color=a,
+            B_Color=b,
+            data_type="COLOR",
+        )
+        builder.node.blend_type = blend_type.capitalize()
+        builder.node.clamp_factor = clamp_factor
+        builder.node.clamp_result = clamp_result
+        return builder
+
+    @classmethod
+    def rotation(
+        cls,
+        a: tuple[float, float, float, float] | list[float] | LINKABLE | None = None,
+        b: tuple[float, float, float, float] | list[float] | LINKABLE | None = None,
+        factor: float | LINKABLE = 0.5,
+        clamp_factor: bool = True,
+    ) -> Mix:
+        builder = cls(
+            Factor_Float=factor,
+            A_Rotation=a,
+            B_Rotation=b,
+            data_type="ROTATION",
+        )
+        builder.node.clamp_factor = clamp_factor
+        return builder
+
+
+_AttributeDataTypes = Literal[
+    "FLOAT", "INT", "BOOLEAN", "VECTOR", "RGBA", "ROTATION", "MATRIX"
+]
+
+
+class CaptureAttribute(NodeBuilder):
+    """Store the result of a field on a geometry and output the data as a node socket. Allows remembering or interpolating data as the geometry changes, such as positions before deformation"""
+
+    name = "GeometryNodeCaptureAttribute"
+    node: bpy.types.GeometryNodeCaptureAttribute
+
+    def __init__(
+        self,
+        geometry: LINKABLE = None,
+        domain: _AttributeDomains = "POINT",
+        **kwargs,
+    ):
+        super().__init__()
+        key_args = {"Geometry": geometry}
+        key_args.update(kwargs)
+        self.domain = domain
+        self._establish_links(**key_args)
+
+    def capture(
+        self,
+        value: LINKABLE,
+        name: str | None = None,
+        data_type: _AttributeDataTypes | None = None,
+    ):
+        """Capture the value to store in the attribute"""
+        source = source_socket(value)
+        if name is None:
+            name = source.name
+        if data_type is None:
+            data_type = source.type  # type: ignore
+
+        item = self._add_item(name, data_type)  # type: ignore
+        self._establish_links(**{item.name: value})
+        return SocketLinker(self.node.outputs[item.name])
+
+    def _add_item(
+        self, name: str, data_type: _AttributeDataTypes = "FLOAT"
+    ) -> bpy.types.NodeGeometryCaptureAttributeItem:
+        """Add a new output socket to capture additional attributes"""
+        return self._items.new(data_type, name)
+
+    @property
+    def _items(self) -> bpy.types.NodeGeometryCaptureAttributeItems:
+        return self.node.capture_items
+
+    @property
+    def i_geometry(self) -> NodeSocket:
+        """Input socket: Geometry"""
+        return self._input("Geometry")
+
+    @property
+    def o_geometry(self) -> NodeSocket:
+        """Output socket: Geometry"""
+        return self._output("Geometry")
+
+    @property
+    def domain(
+        self,
+    ) -> _AttributeDomains:
+        return self.node.domain
+
+    @domain.setter
+    def domain(
+        self,
+        value: _AttributeDomains,
+    ):
+        self.node.domain = value
+
+
+class JoinGeometry(NodeBuilder):
+    """Merge separately generated geometries into a single one"""
+
+    name = "GeometryNodeJoinGeometry"
+    node: bpy.types.GeometryNodeJoinGeometry
+
+    def __init__(self, geometry: NodeBuilder | Iterable[NodeBuilder] | None = None):
+        super().__init__()
+        if geometry is None:
+            return
+        elif isinstance(geometry, NodeBuilder):
+            geometry = [geometry]
+        for source in reversed(geometry):
+            self.link_from(source, self)
+
+    @property
+    def i_geometry(self) -> NodeSocket:
+        """Input socket: Geometry"""
+        return self._input("Geometry")
+
+    @property
+    def o_geometry(self) -> NodeSocket:
+        """Output socket: Geometry"""
+        return self._output("Geometry")
+
+
+class Math(NodeBuilder):
+    """Perform math operations"""
+
+    name = "ShaderNodeMath"
+    node: bpy.types.ShaderNodeMath  # type: ignore
+
+    def __init__(
+        self,
+        operation: types.NodeMathItems = "ADD",
+        use_clamp: bool = False,
+        **kwargs,
+    ):
+        super().__init__()
+        self.operation = operation
+        self.use_clamp = use_clamp
+        self._establish_links(**kwargs)
+
+    @property
+    def operation(self) -> types.NodeMathItems:
+        return self.node.operation
+
+    @operation.setter
+    def operation(self, value: types.NodeMathItems):
+        self.node.operation = value
+
+    @property
+    def use_clamp(self) -> bool:
+        return self.node.use_clamp
+
+    @use_clamp.setter
+    def use_clamp(self, value: bool):
+        self.node.use_clamp = value
+
+    @property
+    def o_value(self) -> NodeSocketFloat:
+        return self._output("Value")  # type: ignore
+
+    def _input(self, identifier: str) -> NodeSocketFloat:
+        return self._input(identifier)
+
+    @property
+    def i_value(self) -> NodeSocketFloat:
+        return self._input("Value")
+
+    @property
+    def i_value_001(self) -> NodeSocketFloat:
+        return self._input("Value_001")
+
+    @property
+    def i_value_002(self) -> NodeSocketFloat:
+        return self._input("Value_002")
+
+    @classmethod
+    def add(
+        cls,
+        a: float | LINKABLE = 0.5,
+        b: float | LINKABLE = 0.5,
+    ) -> "Math":
+        """Create Math with operation of `a + b`."""
+        return cls(operation="ADD", Value=a, Value_001=b)
+
+    @classmethod
+    def subtract(
+        cls,
+        a: float | LINKABLE = 0.5,
+        b: float | LINKABLE = 0.5,
+    ) -> "Math":
+        """Create Math with operation of `a - b`."""
+        return cls(operation="SUBTRACT", Value=a, Value_001=b)
+
+    @classmethod
+    def multiply(
+        cls,
+        a: float | LINKABLE = 0.5,
+        b: float | LINKABLE = 0.5,
+    ) -> "Math":
+        """Create Math with operation of `a * b`."""
+        return cls(operation="MULTIPLY", Value=a, Value_001=b)
+
+    @classmethod
+    def divide(
+        cls,
+        a: float | LINKABLE = 0.5,
+        b: float | LINKABLE = 0.5,
+    ) -> "Math":
+        """Create Math with operation of `a / b`."""
+        return cls(operation="DIVIDE", Value=a, Value_001=b)
+
+    @classmethod
+    def multiply_add(
+        cls,
+        a: float | LINKABLE = 0.5,
+        b: float | LINKABLE = 0.5,
+        c: float | LINKABLE = 0.5,
+    ) -> "Math":
+        """Create Math with operation `a * b + c`."""
+        return cls(operation="MULTIPLY_ADD", Value=a, Value_001=b, value_002=c)
+
+    @classmethod
+    def power(
+        cls,
+        base: float | LINKABLE = 0.5,
+        exponent: float | LINKABLE = 0.5,
+    ) -> "Math":
+        """Create Math with operation `base ** exponent`."""
+        return cls(operation="POWER", Value=base, Value_001=exponent)
+
+    @classmethod
+    def logarithm(
+        cls,
+        value: float | LINKABLE = 0.5,
+        base: float | LINKABLE = 0.5,
+    ) -> "Math":
+        """Create Math with operation `log(value, base)`."""
+        return cls(operation="LOGARITHM", Value=value, Value_001=base)
+
+    @classmethod
+    def sqrt(
+        cls,
+        value: float | LINKABLE = 0.5,
+    ) -> "Math":
+        """Create Math with operation `sqrt(value)`."""
+        return cls(operation="SQRT", Value=value)
+
+    @classmethod
+    def inverse_sqrt(
+        cls,
+        value: float | LINKABLE = 0.5,
+    ) -> "Math":
+        """Create Math with operation `inverse_sqrt(value)`."""
+        return cls(operation="INVERSE_SQRT", Value=value)
+
+    @classmethod
+    def absolute(
+        cls,
+        value: float | LINKABLE = 0.5,
+    ) -> "Math":
+        """Create Math with operation `abs(value)`."""
+        return cls(operation="ABSOLUTE", Value=value)
+
+    @classmethod
+    def exponent(
+        cls,
+        value: float | LINKABLE = 0.5,
+    ) -> "Math":
+        """Create Math with operation `exp(value)`."""
+        return cls(operation="EXPONENT", Value=value)
+
+    @classmethod
+    def minimum(
+        cls,
+        a: float | LINKABLE = 0.5,
+        b: float | LINKABLE = 0.5,
+    ) -> "Math":
+        """Create Math with operation `min(a, b)`."""
+        return cls(operation="MINIMUM", Value=a, Value_001=b)
+
+    @classmethod
+    def maximum(
+        cls,
+        a: float | LINKABLE = 0.5,
+        b: float | LINKABLE = 0.5,
+    ) -> "Math":
+        """Create Math with operation `max(a, b)`."""
+        return cls(operation="MAXIMUM", Value=a, Value_001=b)
+
+    @classmethod
+    def less_than(
+        cls,
+        value: float | LINKABLE = 0.5,
+        threshold: float | LINKABLE = 0.5,
+    ) -> "Math":
+        """Create Math with operation `value < threshold` returning 1 or 0."""
+        return cls(operation="LESS_THAN", Value=value, Value_001=threshold)
+
+    @classmethod
+    def greater_than(
+        cls,
+        value: float | LINKABLE = 0.5,
+        threshold: float | LINKABLE = 0.5,
+    ) -> "Math":
+        """Create Math with operation `value > threshold` returning 1 or 0."""
+        return cls(operation="GREATER_THAN", Value=value, Value_001=threshold)
+
+    @classmethod
+    def sign(
+        cls,
+        value: float | LINKABLE = 0.5,
+    ) -> "Math":
+        """Create Math with operation `sign(value)` returning -1, 0, or 1."""
+        return cls(operation="SIGN", Value=value)
+
+    @classmethod
+    def compare(
+        cls,
+        a: float | LINKABLE = 0.5,
+        b: float | LINKABLE = 0.5,
+        epsilon: float | LINKABLE = 0.5,
+    ) -> "Math":
+        """Create Math with operation `compare(a, b, epsilon)` returning -1, 0, or 1."""
+        return cls(operation="COMPARE", Value=a, Value_001=b, value_002=epsilon)
+
+    @classmethod
+    def smooth_min(
+        cls,
+        a: float | LINKABLE = 0.5,
+        b: float | LINKABLE = 0.5,
+        distance: float | LINKABLE = 0.5,
+    ) -> "Math":
+        """Create Math with operation `smooth_min(a, b, distance)`."""
+        return cls(operation="SMOOTH_MIN", Value=a, Value_001=b, value_002=distance)
+
+    @classmethod
+    def smooth_max_(
+        cls,
+        a: float | LINKABLE = 0.5,
+        b: float | LINKABLE = 0.5,
+        distance: float | LINKABLE = 0.5,
+    ) -> "Math":
+        """Create Math with operation `smooth_max(a, b, distance)`."""
+        return cls(operation="SMOOTH_MAX", Value=a, Value_001=b, value_002=distance)
+
+    @classmethod
+    def round(
+        cls,
+        value: float | LINKABLE = 0.5,
+    ) -> "Math":
+        """Round A to the nearest integer. Round up if 0.5 or greater."""
+        return cls(operation="ROUND", Value=value)
+
+    @classmethod
+    def floor(
+        cls,
+        value: float | LINKABLE = 0.5,
+    ) -> "Math":
+        """The largest integer smaller than or equal to `value`"""
+        return cls(operation="FLOOR", Value=value)
+
+    @classmethod
+    def ceil(
+        cls,
+        value: float | LINKABLE = 0.5,
+    ) -> "Math":
+        """The smallest integer greater than or equal to `value`"""
+        return cls(operation="CEIL", Value=value)
+
+    @classmethod
+    def truncate(
+        cls,
+        value: float | LINKABLE = 0.5,
+    ) -> "Math":
+        """The integer part of `value` removing the fractional part"""
+        return cls(operation="TRUNC", Value=value)
+
+    @classmethod
+    def fraction(
+        cls,
+        value: float | LINKABLE = 0.5,
+    ) -> "Math":
+        """The fractional part of `value`"""
+        return cls(operation="FRACT", Value=value)
+
+    @classmethod
+    def truncated_modulo(
+        cls,
+        a: float | LINKABLE = 0.5,
+        b: float | LINKABLE = 0.5,
+    ) -> "Math":
+        """The remained of truncated division using fmod(a, b)"""
+        return cls(operation="MODULO", Value=a, Value_001=b)
+
+    @classmethod
+    def floored_modulo(
+        cls,
+        a: float | LINKABLE = 0.5,
+        b: float | LINKABLE = 0.5,
+    ) -> "Math":
+        """The remained of floored division"""
+        return cls(operation="FLOORED_MODULO", Value=a, Value_001=b)
+
+    @classmethod
+    def wrap(
+        cls,
+        value: float | LINKABLE = 0.5,
+        max: float | LINKABLE = 0.5,
+        min: float | LINKABLE = 0.5,
+    ) -> "Math":
+        """Wrap value to range, wrap(value, max, min)"""
+        return cls(operation="WRAP", Value=value, Value_001=max, value_002=min)
+
+    @classmethod
+    def snap(
+        cls,
+        value: float | LINKABLE = 0.5,
+        increment: float | LINKABLE = 0.5,
+    ) -> "Math":
+        """Snap to increment of `snap(value, increment)`"""
+        return cls(operation="SNAP", Value=value, Value_001=increment)
+
+    @classmethod
+    def ping_pong(
+        cls,
+        value: float | LINKABLE = 0.5,
+        scale: float | LINKABLE = 0.5,
+    ) -> "Math":
+        """Wraps a value and reverses every other cycle"""
+        return cls(operation="PINGPONG", Value=value, Value_001=scale)
+
+    @classmethod
+    def sine(
+        cls,
+        value: float | LINKABLE = 0.5,
+    ) -> "Math":
+        """Create Math with operation 'sin(value)'."""
+        return cls(operation="SINE", Value=value)
+
+    @classmethod
+    def cosine(
+        cls,
+        value: float | LINKABLE = 0.5,
+    ) -> "Math":
+        """Create Math with operation 'cos(value)'."""
+        return cls(operation="COSINE", Value=value)
+
+    @classmethod
+    def tangent(
+        cls,
+        value: float | LINKABLE = 0.5,
+    ) -> "Math":
+        """Create Math with operation 'tan(value)'."""
+        return cls(operation="TANGENT", Value=value)
+
+    @classmethod
+    def arcsine(
+        cls,
+        value: float | LINKABLE = 0.5,
+    ) -> "Math":
+        """Create Math with operation `arcsin(value)'."""
+        return cls(operation="ARCSINE", Value=value)
+
+    @classmethod
+    def arccosine(
+        cls,
+        value: float | LINKABLE = 0.5,
+    ) -> "Math":
+        """Create Math with operation 'arccos(value)'."""
+        return cls(operation="ARCCOSINE", Value=value)
+
+    @classmethod
+    def arctangent(
+        cls,
+        value: float | LINKABLE = 0.5,
+    ) -> "Math":
+        """Create Math with operation 'arctan(value)'."""
+        return cls(operation="ARCTANGENT", Value=value)
+
+    @classmethod
+    def arctan2(
+        cls,
+        a: float | LINKABLE = 0.5,
+        b: float | LINKABLE = 0.5,
+    ) -> "Math":
+        """Create Math with operation 'arctan(a / b)'."""
+        return cls(operation="ARCTAN2", Value=a, Value_001=b)
+
+    @classmethod
+    def sinh(
+        cls,
+        value: float | LINKABLE = 0.5,
+    ) -> "Math":
+        """Create Math with operation `sinh(value)`."""
+        return cls(operation="SINH", Value=value)
+
+    @classmethod
+    def cosh(
+        cls,
+        value: float | LINKABLE = 0.5,
+    ) -> "Math":
+        """Create Math with operation `cosh(value)`."""
+        return cls(operation="COSH", Value=value)
+
+    @classmethod
+    def tanh(
+        cls,
+        value: float | LINKABLE = 0.5,
+    ) -> "Math":
+        """Create Math with operation `tanh(value)`."""
+        return cls(operation="TANH", Value=value)
+
+    @classmethod
+    def radians(
+        cls,
+        degrees: float | LINKABLE = 0.5,
+    ) -> "Math":
+        """Create Math with operation `radians(degrees)`."""
+        return cls(operation="RADIANS", Value=degrees)
+
+    @classmethod
+    def degrees(
+        cls,
+        radians: float | LINKABLE = 0.5,
+    ) -> "Math":
+        """Create Math with operation 'To Degrees'."""
+        return cls(operation="DEGREES", Value=radians)
+
+
+class BooleanMath(NodeBuilder):
+    """Boolean Math node"""
+
+    name = "FunctionNodeBooleanMath"
+    node: bpy.types.FunctionNodeBooleanMath
+
+    def __init__(self, operation: types.NodeBooleanMathItems = "AND", **kwargs):
+        super().__init__()
+        self.operator = operation
+        self._establish_links(**kwargs)
+
+    @property
+    def operation(self) -> types.NodeBooleanMathItems:
+        return self.node.operation
+
+    @operation.setter
+    def operation(self, value: types.NodeBooleanMathItems):
+        self.node.operation = value
+
+    @property
+    def i_boolean(self) -> bpy.types.NodeSocketBool:
+        return self._input("Boolean")  # type: ignore
+
+    @property
+    def i_boolean_001(self) -> bpy.types.NodeSocketBool:
+        return self._input("Boolean_001")  # type: ignore
+
+    @property
+    def o_boolean(self) -> bpy.types.NodeSocketBool:
+        return self._output("Boolean")  # type: ignore
+
+    @classmethod
+    def l_and(
+        cls,
+        boolean: TYPE_INPUT_BOOLEAN = False,
+        boolean_001: TYPE_INPUT_BOOLEAN = False,
+    ) -> "BooleanMath":
+        """Create Boolean Math with operation 'AND'."""
+        return cls(operation="AND", Boolean=boolean, Boolean_001=boolean_001)
+
+    @classmethod
+    def l_or(
+        cls,
+        boolean: TYPE_INPUT_BOOLEAN = False,
+        boolean_001: TYPE_INPUT_BOOLEAN = False,
+    ) -> "BooleanMath":
+        """Create Boolean Math with operation 'OR'."""
+        return cls(operation="OR", Boolean=boolean, Boolean_001=boolean_001)
+
+    @classmethod
+    def l_not(cls, boolean: TYPE_INPUT_BOOLEAN = False) -> "BooleanMath":
+        """Create Boolean Math with operation 'NOT'."""
+        return cls(operation="NOT", Boolean=boolean)
+
+    @classmethod
+    def l_not_and(
+        cls,
+        boolean: TYPE_INPUT_BOOLEAN = False,
+        boolean_001: TYPE_INPUT_BOOLEAN = False,
+    ) -> "BooleanMath":
+        """Create Boolean Math with operation 'NAND'."""
+        return cls(operation="NAND", Boolean=boolean, Boolean_001=boolean_001)
+
+    @classmethod
+    def l_nor(
+        cls,
+        boolean: TYPE_INPUT_BOOLEAN = False,
+        boolean_001: TYPE_INPUT_BOOLEAN = False,
+    ) -> "BooleanMath":
+        """Create Boolean Math with operation 'NOR'."""
+        return cls(operation="NOR", Boolean=boolean, Boolean_001=boolean_001)
+
+    @classmethod
+    def l_equal(
+        cls,
+        boolean: TYPE_INPUT_BOOLEAN = False,
+        boolean_001: TYPE_INPUT_BOOLEAN = False,
+    ) -> "BooleanMath":
+        """Create Boolean Math with operation 'XNOR'."""
+        return cls(operation="XNOR", Boolean=boolean, Boolean_001=boolean_001)
+
+    @classmethod
+    def l_not_equal(
+        cls,
+        boolean: TYPE_INPUT_BOOLEAN = False,
+        boolean_001: TYPE_INPUT_BOOLEAN = False,
+    ) -> "BooleanMath":
+        """Create Boolean Math with operation 'XOR'."""
+        return cls(operation="XOR", Boolean=boolean, Boolean_001=boolean_001)
+
+    @classmethod
+    def l_imply(
+        cls,
+        boolean: TYPE_INPUT_BOOLEAN = False,
+        boolean_001: TYPE_INPUT_BOOLEAN = False,
+    ) -> "BooleanMath":
+        """Create Boolean Math with operation 'IMPLY'."""
+        return cls(operation="IMPLY", Boolean=boolean, Boolean_001=boolean_001)
+
+    @classmethod
+    def l_subtract(
+        cls,
+        boolean: TYPE_INPUT_BOOLEAN = False,
+        boolean_001: TYPE_INPUT_BOOLEAN = False,
+    ) -> "BooleanMath":
+        """Create Boolean Math with operation 'NIMPLY'."""
+        return cls(operation="NIMPLY", Boolean=boolean, Boolean_001=boolean_001)
+
+
+_VectorMathOperations = Literal[
+    "ADD",
+    "SUBTRACT",
+    "MULTIPLY",
+    "DIVIDE",
+    "MULTIPLY_ADD",
+    "CROSS_PRODUCT",
+    "PROJECT",
+    "REFLECT",
+    "REFRACT",
+    "FACEFORWARD",
+    "DOT_PRODUCT",
+    "DISTANCE",
+    "LENGTH",
+    "SCALE",
+    "NORMALIZE",
+    "ABSOLUTE",
+    "POWER",
+    "SIGN",
+    "MINIMUM",
+    "MAXIMUM",
+    "FLOOR",
+    "CEIL",
+    "FRACTION",
+    "MODULO",
+    "WRAP",
+    "SNAP",
+    "SINE",
+    "COSINE",
+    "TANGENT",
+]
+
+
+class VectorMath(NodeBuilder):
+    """Perform vector math operation"""
+
+    name = "ShaderNodeVectorMath"
+    node: bpy.types.ShaderNodeVectorMath
+
+    def __init__(
+        self,
+        operation: _VectorMathOperations = "ADD",
+        **kwargs,
+    ):
+        super().__init__()
+        self.operation = operation
+        self._establish_links(**kwargs)
+
+    @property
+    def i_vector(self) -> bpy.types.NodeSocketVector:
+        """Input socket: Vector"""
+        return self._input("Vector")
+
+    @property
+    def i_vector_001(self) -> bpy.types.NodeSocketVector:
+        """Input socket: Vector"""
+        return self._input("Vector_001")
+
+    @property
+    def o_vector(self) -> bpy.types.NodeSocketVector:
+        """Output socket: Vector"""
+        if self.operation in {"DOT_PRODUCT", "DISTANCE", "LENGTH"}:
+            raise RuntimeError(
+                f"Output 'Vector' is not available for operation '{self.operation}'"
+            )
+        return self._output("Vector")
+
+    def o_value(self) -> bpy.types.NodeSocketFloat:
+        """Output socket: Value"""
+        if self.operation not in {"DOT_PRODUCT", "DISTANCE", "LENGTH"}:
+            raise RuntimeError(
+                f"Output 'Value' is not available for operation '{self.operation}'"
+            )
+        return self._output("Value")
+
+    @property
+    def _default_output_socket(self) -> NodeSocketFloat | NodeSocketVector:
+        match self.operation:
+            case "DOT_PRODUCT" | "DISTANCE" | "LENGTH":
+                return self.o_value
+            case _:
+                return self.o_vector
+
+    @property
+    def operation(
+        self,
+    ) -> _VectorMathOperations:
+        return self.node.operation
+
+    @operation.setter
+    def operation(
+        self,
+        value: _VectorMathOperations,
+    ):
+        self.node.operation = value
+
+    @classmethod
+    def add(
+        cls,
+        a: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+        b: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+    ) -> "VectorMath":
+        """Create Vector Math with operation `a + b`."""
+        return cls(operation="ADD", Vector=a, Vector_001=b)
+
+    @classmethod
+    def subtract(
+        cls,
+        a: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+        b: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+    ) -> "VectorMath":
+        """Create Vector Math with operation `a - b`."""
+        return cls(operation="SUBTRACT", Vector=a, Vector_001=b)
+
+    @classmethod
+    def multiply(
+        cls,
+        a: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+        b: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+    ) -> "VectorMath":
+        """Create Vector Math with operation `a * b` element-wise."""
+        return cls(operation="MULTIPLY", Vector=a, Vector_001=b)
+
+    @classmethod
+    def divide(
+        cls,
+        a: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+        b: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+    ) -> "VectorMath":
+        """Create Vector Math with operation 'Divide'."""
+        return cls(operation="DIVIDE", Vector=a, Vector_001=b)
+
+    @classmethod
+    def multiply_add(
+        cls,
+        vector: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+        multiplier: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+        addend: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+    ) -> "VectorMath":
+        """Create Vector Math with operation 'Multiply Add'."""
+        return cls(
+            operation="MULTIPLY_ADD",
+            Vector=vector,
+            Vector_001=multiplier,
+            Vector_002=addend,
+        )
+
+    @classmethod
+    def cross_product(
+        cls,
+        a: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+        b: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+    ) -> "VectorMath":
+        """Create Vector Math with operation 'Cross Product'."""
+        return cls(operation="CROSS_PRODUCT", Vector=a, Vector_001=b)
+
+    @classmethod
+    def project(
+        cls,
+        a: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+        b: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+    ) -> "VectorMath":
+        """Project A onto B."""
+        return cls(operation="PROJECT", Vector=a, Vector_001=b)
+
+    @classmethod
+    def reflect(
+        cls,
+        a: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+        b: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+    ) -> "VectorMath":
+        """Reflect A around the normal B. B does not need to be normalized."""
+        return cls(operation="REFLECT", Vector=a, Vector_001=b)
+
+    @classmethod
+    def refract(
+        cls,
+        a: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+        b: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+        ior: LINKABLE | float = 1.0,
+    ) -> "VectorMath":
+        """For a given incident vector and surface normal (b) with an index of refraction (ior), return the refraction vector"""
+        return cls(operation="REFRACT", Vector=a, Vector_001=b, Scale=ior)
+
+    @classmethod
+    def face_forward(
+        cls,
+        vector: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+        incidence: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+        reference: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+    ) -> "VectorMath":
+        """Orients a vector to face away from a surface (incidence) defined by it's normal (reference)"""
+        return cls(
+            operation="FACEFORWARD",
+            Vector=vector,
+            Vector_001=incidence,
+            Vector_002=reference,
+        )
+
+    @classmethod
+    def dot_product(
+        cls,
+        a: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+        b: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+    ) -> "VectorMath":
+        """Create Vector Math with operation 'Dot Product'."""
+        return cls(operation="DOT_PRODUCT", Vector=a, Vector_001=b)
+
+    @classmethod
+    def distance(
+        cls,
+        a: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+        b: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+    ) -> "VectorMath":
+        """Create Vector Math with operation 'Distance'."""
+        return cls(operation="DISTANCE", Vector=a, Vector_001=b)
+
+    @classmethod
+    def length(
+        cls,
+        vector: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+    ) -> "VectorMath":
+        """Create Vector Math with operation 'Length'."""
+        return cls(operation="LENGTH", Vector=vector)
+
+    @classmethod
+    def scale(
+        cls,
+        vector: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+        scale: LINKABLE | float = 1.0,
+    ) -> "VectorMath":
+        """Create Vector Math with operation 'Scale'."""
+        return cls(operation="SCALE", Vector=vector, Scale=scale)
+
+    @classmethod
+    def normalize(
+        cls,
+        vector: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+    ) -> "VectorMath":
+        """Create Vector Math with operation 'Normalize'."""
+        return cls(operation="NORMALIZE", Vector=vector)
+
+    @classmethod
+    def absolute(
+        cls,
+        vector: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+    ) -> "VectorMath":
+        """Create Vector Math with operation 'Absolute'."""
+        return cls(operation="ABSOLUTE", Vector=vector)
+
+    @classmethod
+    def power(
+        cls,
+        base: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+        exponent: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+    ) -> "VectorMath":
+        """Create Vector Math with operation 'Power'."""
+        return cls(operation="POWER", Vector=base, Vector_001=exponent)
+
+    @classmethod
+    def sign(
+        cls,
+        vector: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+    ) -> "VectorMath":
+        """Create Vector Math with operation 'Sign'."""
+        return cls(operation="SIGN", Vector=vector)
+
+    @classmethod
+    def minimum(
+        cls,
+        a: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+        b: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+    ) -> "VectorMath":
+        """Create Vector Math with operation 'Minimum'."""
+        return cls(operation="MINIMUM", Vector=a, Vector_001=b)
+
+    @classmethod
+    def maximum(
+        cls,
+        a: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+        b: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+    ) -> "VectorMath":
+        """Create Vector Math with operation 'Maximum'."""
+        return cls(operation="MAXIMUM", Vector=a, Vector_001=b)
+
+    @classmethod
+    def floor(
+        cls,
+        vector: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+    ) -> "VectorMath":
+        """Create Vector Math with operation 'Floor'."""
+        return cls(operation="FLOOR", Vector=vector)
+
+    @classmethod
+    def ceil(
+        cls,
+        vector: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+    ) -> "VectorMath":
+        """Create Vector Math with operation 'Ceil'."""
+        return cls(operation="CEIL", Vector=vector)
+
+    @classmethod
+    def fraction(
+        cls,
+        vector: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+    ) -> "VectorMath":
+        """Create Vector Math with operation 'Fraction'."""
+        return cls(operation="FRACTION", Vector=vector)
+
+    @classmethod
+    def modulo(
+        cls,
+        vector: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+    ) -> "VectorMath":
+        """Create Vector Math with operation 'Modulo'."""
+        return cls(operation="MODULO", Vector=vector)
+
+    @classmethod
+    def wrap(
+        cls,
+        vector: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+        min: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+        max: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+    ) -> "VectorMath":
+        """Create Vector Math with operation 'Wrap'."""
+        return cls(operation="WRAP", Vector=vector, Vector_001=min, Vector_002=max)
+
+    @classmethod
+    def snap(
+        cls,
+        vector: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+        increment: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+    ) -> "VectorMath":
+        """Create Vector Math with operation 'Snap'."""
+        return cls(operation="SNAP", Vector=vector, Vector_001=increment)
+
+    @classmethod
+    def sine(
+        cls,
+        vector: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+    ) -> "VectorMath":
+        """Create Vector Math with operation 'Sine'."""
+        return cls(operation="SINE", Vector=vector)
+
+    @classmethod
+    def cosine(
+        cls,
+        vector: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+    ) -> "VectorMath":
+        """Create Vector Math with operation 'Cosine'."""
+        return cls(operation="COSINE", Vector=vector)
+
+    @classmethod
+    def tangent(
+        cls,
+        vector: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
+    ) -> "VectorMath":
+        """Create Vector Math with operation 'Tangent'."""
+        return cls(operation="TANGENT", Vector=vector)