nodebpy 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

nodebpy/nodes/interface.py

@@ -2,14 +2,12 @@ from typing import Literal
 
 import bpy
 
-from nodebpy.builder import NodeBuilder, SocketLinker
-
-from .types import (
+from ..builder import NodeBuilder, SocketLinker
+from ..types import (
     TYPE_INPUT_BOOLEAN,
-    TYPE_INPUT_MATRIX,
     TYPE_INPUT_STRING,
     TYPE_INPUT_ROTATION,
-    LINKABLE,
+    TYPE_INPUT_MATRIX,
     TYPE_INPUT_VALUE,
     TYPE_INPUT_VECTOR,
 )
@@ -18,18 +16,18 @@ from .types import (
 class DialGizmo(NodeBuilder):
     """Show a dial gizmo in the viewport for a value"""
 
-    name = "GeometryNodeGizmoDial"
+    _bl_idname = "GeometryNodeGizmoDial"
     node: bpy.types.GeometryNodeGizmoDial
 
     def __init__(
         self,
         value: TYPE_INPUT_VALUE = 0.0,
-        position: TYPE_INPUT_VECTOR = (0.0, 0.0, 0.0),
-        up: TYPE_INPUT_VECTOR = (0.0, 0.0, 1.0),
+        position: TYPE_INPUT_VECTOR = None,
+        up: TYPE_INPUT_VECTOR = None,
         screen_space: TYPE_INPUT_BOOLEAN = True,
         radius: TYPE_INPUT_VALUE = 1.0,
+        *,
         color_id: Literal["PRIMARY", "SECONDARY", "X", "Y", "Z"] = "PRIMARY",
-        pin_gizmo: bool = False,
     ):
         super().__init__()
         key_args = {
@@ -40,18 +38,8 @@ class DialGizmo(NodeBuilder):
             "Radius": radius,
         }
         self.color_id = color_id
-        self.pin_gizmo = pin_gizmo
         self._establish_links(**key_args)
 
-    @property
-    def pin_gizmo(self) -> bool:
-        """Pin the gizmo to the viewport"""
-        return self.node.inputs[0].pin_gizmo
-
-    @pin_gizmo.setter
-    def pin_gizmo(self, value: bool):
-        self.node.inputs[0].pin_gizmo = value
-
     @property
     def i_value(self) -> SocketLinker:
         """Input socket: Value"""
@@ -91,37 +79,239 @@ class DialGizmo(NodeBuilder):
         self.node.color_id = value
 
 
+class EnableOutput(NodeBuilder):
+    """Either pass through the input value or output the fallback value"""
+
+    _bl_idname = "NodeEnableOutput"
+    node: bpy.types.Node
+
+    def __init__(
+        self,
+        enable: TYPE_INPUT_BOOLEAN = False,
+        value: TYPE_INPUT_VALUE = 0.0,
+        *,
+        data_type: Literal[
+            "FLOAT",
+            "INT",
+            "BOOLEAN",
+            "VECTOR",
+            "RGBA",
+            "ROTATION",
+            "MATRIX",
+            "STRING",
+            "MENU",
+            "OBJECT",
+            "IMAGE",
+            "GEOMETRY",
+            "COLLECTION",
+            "MATERIAL",
+            "BUNDLE",
+            "CLOSURE",
+        ] = "FLOAT",
+    ):
+        super().__init__()
+        key_args = {"Enable": enable, "Value": value}
+        self.data_type = data_type
+        self._establish_links(**key_args)
+
+    @classmethod
+    def float(cls, enable: TYPE_INPUT_BOOLEAN = False) -> "EnableOutput":
+        """Create Enable Output with operation 'Float'."""
+        return cls(data_type="FLOAT", enable=enable)
+
+    @classmethod
+    def integer(cls, enable: TYPE_INPUT_BOOLEAN = False) -> "EnableOutput":
+        """Create Enable Output with operation 'Integer'."""
+        return cls(data_type="INT", enable=enable)
+
+    @classmethod
+    def boolean(cls, enable: TYPE_INPUT_BOOLEAN = False) -> "EnableOutput":
+        """Create Enable Output with operation 'Boolean'."""
+        return cls(data_type="BOOLEAN", enable=enable)
+
+    @classmethod
+    def vector(cls, enable: TYPE_INPUT_BOOLEAN = False) -> "EnableOutput":
+        """Create Enable Output with operation 'Vector'."""
+        return cls(data_type="VECTOR", enable=enable)
+
+    @classmethod
+    def color(cls, enable: TYPE_INPUT_BOOLEAN = False) -> "EnableOutput":
+        """Create Enable Output with operation 'Color'."""
+        return cls(data_type="RGBA", enable=enable)
+
+    @classmethod
+    def rotation(cls, enable: TYPE_INPUT_BOOLEAN = False) -> "EnableOutput":
+        """Create Enable Output with operation 'Rotation'."""
+        return cls(data_type="ROTATION", enable=enable)
+
+    @classmethod
+    def matrix(cls, enable: TYPE_INPUT_BOOLEAN = False) -> "EnableOutput":
+        """Create Enable Output with operation 'Matrix'."""
+        return cls(data_type="MATRIX", enable=enable)
+
+    @classmethod
+    def string(cls, enable: TYPE_INPUT_BOOLEAN = False) -> "EnableOutput":
+        """Create Enable Output with operation 'String'."""
+        return cls(data_type="STRING", enable=enable)
+
+    @classmethod
+    def menu(cls, enable: TYPE_INPUT_BOOLEAN = False) -> "EnableOutput":
+        """Create Enable Output with operation 'Menu'."""
+        return cls(data_type="MENU", enable=enable)
+
+    @classmethod
+    def object(cls, enable: TYPE_INPUT_BOOLEAN = False) -> "EnableOutput":
+        """Create Enable Output with operation 'Object'."""
+        return cls(data_type="OBJECT", enable=enable)
+
+    @classmethod
+    def image(cls, enable: TYPE_INPUT_BOOLEAN = False) -> "EnableOutput":
+        """Create Enable Output with operation 'Image'."""
+        return cls(data_type="IMAGE", enable=enable)
+
+    @classmethod
+    def geometry(cls, enable: TYPE_INPUT_BOOLEAN = False) -> "EnableOutput":
+        """Create Enable Output with operation 'Geometry'."""
+        return cls(data_type="GEOMETRY", enable=enable)
+
+    @classmethod
+    def collection(cls, enable: TYPE_INPUT_BOOLEAN = False) -> "EnableOutput":
+        """Create Enable Output with operation 'Collection'."""
+        return cls(data_type="COLLECTION", enable=enable)
+
+    @classmethod
+    def material(cls, enable: TYPE_INPUT_BOOLEAN = False) -> "EnableOutput":
+        """Create Enable Output with operation 'Material'."""
+        return cls(data_type="MATERIAL", enable=enable)
+
+    @classmethod
+    def bundle(cls, enable: TYPE_INPUT_BOOLEAN = False) -> "EnableOutput":
+        """Create Enable Output with operation 'Bundle'."""
+        return cls(data_type="BUNDLE", enable=enable)
+
+    @classmethod
+    def closure(cls, enable: TYPE_INPUT_BOOLEAN = False) -> "EnableOutput":
+        """Create Enable Output with operation 'Closure'."""
+        return cls(data_type="CLOSURE", enable=enable)
+
+    @property
+    def i_enable(self) -> SocketLinker:
+        """Input socket: Enable"""
+        return self._input("Enable")
+
+    @property
+    def i_value(self) -> SocketLinker:
+        """Input socket: Value"""
+        return self._input("Value")
+
+    @property
+    def o_value(self) -> SocketLinker:
+        """Output socket: Value"""
+        return self._output("Value")
+
+    @property
+    def data_type(
+        self,
+    ) -> Literal[
+        "FLOAT",
+        "INT",
+        "BOOLEAN",
+        "VECTOR",
+        "RGBA",
+        "ROTATION",
+        "MATRIX",
+        "STRING",
+        "MENU",
+        "OBJECT",
+        "IMAGE",
+        "GEOMETRY",
+        "COLLECTION",
+        "MATERIAL",
+        "BUNDLE",
+        "CLOSURE",
+    ]:
+        return self.node.data_type
+
+    @data_type.setter
+    def data_type(
+        self,
+        value: Literal[
+            "FLOAT",
+            "INT",
+            "BOOLEAN",
+            "VECTOR",
+            "RGBA",
+            "ROTATION",
+            "MATRIX",
+            "STRING",
+            "MENU",
+            "OBJECT",
+            "IMAGE",
+            "GEOMETRY",
+            "COLLECTION",
+            "MATERIAL",
+            "BUNDLE",
+            "CLOSURE",
+        ],
+    ):
+        self.node.data_type = value
+
+
+class GroupInput(NodeBuilder):
+    """Expose connected data from inside a node group as inputs to its interface"""
+
+    _bl_idname = "NodeGroupInput"
+    node: bpy.types.Node
+
+    def __init__(self):
+        super().__init__()
+        key_args = {}
+
+        self._establish_links(**key_args)
+
+
+class GroupOutput(NodeBuilder):
+    """Output data from inside of a node group"""
+
+    _bl_idname = "NodeGroupOutput"
+    node: bpy.types.Node
+
+    def __init__(self, is_active_output: bool = False):
+        super().__init__()
+        key_args = {}
+        self.is_active_output = is_active_output
+        self._establish_links(**key_args)
+
+    @property
+    def is_active_output(self) -> bool:
+        return self.node.is_active_output
+
+    @is_active_output.setter
+    def is_active_output(self, value: bool):
+        self.node.is_active_output = value
+
+
 class LinearGizmo(NodeBuilder):
     """Show a linear gizmo in the viewport for a value"""
 
-    name = "GeometryNodeGizmoLinear"
+    _bl_idname = "GeometryNodeGizmoLinear"
     node: bpy.types.GeometryNodeGizmoLinear
 
     def __init__(
         self,
         value: TYPE_INPUT_VALUE = 0.0,
-        position: TYPE_INPUT_VECTOR = (0.0, 0.0, 0.0),
-        direction: TYPE_INPUT_VECTOR = (0.0, 0.0, 1.0),
+        position: TYPE_INPUT_VECTOR = None,
+        direction: TYPE_INPUT_VECTOR = None,
+        *,
         color_id: Literal["PRIMARY", "SECONDARY", "X", "Y", "Z"] = "PRIMARY",
         draw_style: Literal["ARROW", "CROSS", "BOX"] = "ARROW",
-        pin_gizmo: bool = False,
     ):
         super().__init__()
         key_args = {"Value": value, "Position": position, "Direction": direction}
         self.color_id = color_id
         self.draw_style = draw_style
-        self.pin_gizmo = pin_gizmo
         self._establish_links(**key_args)
 
-    @property
-    def pin_gizmo(self) -> bool:
-        """Input socket: Pin Gizmo"""
-        return self.node.inputs[0].pin_gizmo
-
-    @pin_gizmo.setter
-    def pin_gizmo(self, value: bool):
-        self.node.inputs[0].pin_gizmo = value
-
     @property
     def i_value(self) -> SocketLinker:
         """Input socket: Value"""
@@ -162,29 +352,27 @@ class LinearGizmo(NodeBuilder):
 class TransformGizmo(NodeBuilder):
     """Show a transform gizmo in the viewport"""
 
-    name = "GeometryNodeGizmoTransform"
+    _bl_idname = "GeometryNodeGizmoTransform"
     node: bpy.types.GeometryNodeGizmoTransform
 
     def __init__(
         self,
         value: TYPE_INPUT_MATRIX = None,
-        position: TYPE_INPUT_VECTOR = (0.0, 0.0, 0.0),
-        rotation: TYPE_INPUT_ROTATION = (0.0, 0.0, 0.0),
+        position: TYPE_INPUT_VECTOR = None,
+        rotation: TYPE_INPUT_ROTATION = None,
         *,
-        pin_gizmo: bool = False,
-        use_translation_x: bool = True,
-        use_translation_y: bool = True,
-        use_translation_z: bool = True,
-        use_rotation_x: bool = True,
-        use_rotation_y: bool = True,
-        use_rotation_z: bool = True,
-        use_scale_x: bool = True,
-        use_scale_y: bool = True,
-        use_scale_z: bool = True,
+        use_translation_x: bool = False,
+        use_translation_y: bool = False,
+        use_translation_z: bool = False,
+        use_rotation_x: bool = False,
+        use_rotation_y: bool = False,
+        use_rotation_z: bool = False,
+        use_scale_x: bool = False,
+        use_scale_y: bool = False,
+        use_scale_z: bool = False,
     ):
         super().__init__()
         key_args = {"Value": value, "Position": position, "Rotation": rotation}
-        self.pin_gizmo = pin_gizmo
         self.use_translation_x = use_translation_x
         self.use_translation_y = use_translation_y
         self.use_translation_z = use_translation_z
@@ -196,14 +384,6 @@ class TransformGizmo(NodeBuilder):
         self.use_scale_z = use_scale_z
         self._establish_links(**key_args)
 
-    @property
-    def pin_gizmo(self) -> bool:
-        return self.node.inputs[0].pin_gizmo
-
-    @pin_gizmo.setter
-    def pin_gizmo(self, value: bool):
-        self.node.inputs[0].pin_gizmo = value
-
     @property
     def i_value(self) -> SocketLinker:
         """Input socket: Value"""
@@ -297,71 +477,10 @@ class TransformGizmo(NodeBuilder):
         self.node.use_scale_z = value
 
 
-class Viewer(NodeBuilder):
-    """Display the input data in the Spreadsheet Editor"""
-
-    name = "GeometryNodeViewer"
-    node: bpy.types.GeometryNodeViewer
-
-    def __init__(
-        self,
-        extend: LINKABLE | None = None,
-        ui_shortcut: int = 0,
-        active_index: int = 0,
-        domain: Literal[
-            "AUTO", "POINT", "EDGE", "FACE", "CORNER", "CURVE", "INSTANCE", "LAYER"
-        ] = "AUTO",
-    ):
-        super().__init__()
-        key_args = {"__extend__": extend}
-        self.ui_shortcut = ui_shortcut
-        self.active_index = active_index
-        self.domain = domain
-        self._establish_links(**key_args)
-
-    @property
-    def i_input_socket(self) -> SocketLinker:
-        """Input socket:"""
-        return self._input("__extend__")
-
-    @property
-    def ui_shortcut(self) -> int:
-        return self.node.ui_shortcut
-
-    @ui_shortcut.setter
-    def ui_shortcut(self, value: int):
-        self.node.ui_shortcut = value
-
-    @property
-    def active_index(self) -> int:
-        return self.node.active_index  # type: ignore
-
-    @active_index.setter
-    def active_index(self, value: int):
-        self.node.active_index = value
-
-    @property
-    def domain(
-        self,
-    ) -> Literal[
-        "AUTO", "POINT", "EDGE", "FACE", "CORNER", "CURVE", "INSTANCE", "LAYER"
-    ]:
-        return self.node.domain
-
-    @domain.setter
-    def domain(
-        self,
-        value: Literal[
-            "AUTO", "POINT", "EDGE", "FACE", "CORNER", "CURVE", "INSTANCE", "LAYER"
-        ],
-    ):
-        self.node.domain = value
-
-
 class Warning(NodeBuilder):
     """Create custom warnings in node groups"""
 
-    name = "GeometryNodeWarning"
+    _bl_idname = "GeometryNodeWarning"
     node: bpy.types.GeometryNodeWarning
 
     def __init__(