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

nodebpy/nodes/interface.py

@@ -14,7 +14,9 @@ from ..types import (
 
 
 class DialGizmo(NodeBuilder):
-    """Show a dial gizmo in the viewport for a value"""
+    """
+    Show a dial gizmo in the viewport for a value
+    """
 
     _bl_idname = "GeometryNodeGizmoDial"
     node: bpy.types.GeometryNodeGizmoDial
@@ -80,7 +82,9 @@ class DialGizmo(NodeBuilder):
 
 
 class EnableOutput(NodeBuilder):
-    """Either pass through the input value or output the fallback value"""
+    """
+    Either pass through the input value or output the fallback value
+    """
 
     _bl_idname = "NodeEnableOutput"
     node: bpy.types.Node
@@ -258,7 +262,9 @@ class EnableOutput(NodeBuilder):
 
 
 class GroupInput(NodeBuilder):
-    """Expose connected data from inside a node group as inputs to its interface"""
+    """
+    Expose connected data from inside a node group as inputs to its interface
+    """
 
     _bl_idname = "NodeGroupInput"
     node: bpy.types.Node
@@ -271,7 +277,9 @@ class GroupInput(NodeBuilder):
 
 
 class GroupOutput(NodeBuilder):
-    """Output data from inside of a node group"""
+    """
+    Output data from inside of a node group
+    """
 
     _bl_idname = "NodeGroupOutput"
     node: bpy.types.Node
@@ -292,7 +300,9 @@ class GroupOutput(NodeBuilder):
 
 
 class LinearGizmo(NodeBuilder):
-    """Show a linear gizmo in the viewport for a value"""
+    """
+    Show a linear gizmo in the viewport for a value
+    """
 
     _bl_idname = "GeometryNodeGizmoLinear"
     node: bpy.types.GeometryNodeGizmoLinear
@@ -350,7 +360,9 @@ class LinearGizmo(NodeBuilder):
 
 
 class TransformGizmo(NodeBuilder):
-    """Show a transform gizmo in the viewport"""
+    """
+    Show a transform gizmo in the viewport
+    """
 
     _bl_idname = "GeometryNodeGizmoTransform"
     node: bpy.types.GeometryNodeGizmoTransform
@@ -478,7 +490,9 @@ class TransformGizmo(NodeBuilder):
 
 
 class Warning(NodeBuilder):
-    """Create custom warnings in node groups"""
+    """
+    Create custom warnings in node groups
+    """
 
     _bl_idname = "GeometryNodeWarning"
     node: bpy.types.GeometryNodeWarning

nodebpy/nodes/manual.py

@@ -35,6 +35,9 @@ from ..types import (
     _is_default_value,
 )
 from .zone import (
+    ForEachGeometryElementInput,
+    ForEachGeometryElementOutput,
+    ForEachGeometryElementZone,
     RepeatInput,
     RepeatOutput,
     RepeatZone,
@@ -50,6 +53,9 @@ __all__ = (
     "SimulationInput",
     "SimulationOutput",
     "SimulationZone",
+    "ForEachGeometryElementInput",
+    "ForEachGeometryElementOutput",
+    "ForEachGeometryElementZone",
     "GeometryToInstance",
     "SDFGridBoolean",
     #
@@ -64,12 +70,6 @@ __all__ = (
     "Bake",
     "JoinStrings",
     "GeometryToInstance",
-    "RepeatInput",
-    "RepeatOutput",
-    "RepeatZone",
-    "SimulationInput",
-    "SimulationOutput",
-    "SimulationZone",
     "FormatString",
     "Value",
     "AccumulateField",

nodebpy/nodes/output.py

@@ -6,7 +6,9 @@ from ..builder import NodeBuilder
 
 
 class Viewer(NodeBuilder):
-    """Display the input data in the Spreadsheet Editor"""
+    """
+    Display the input data in the Spreadsheet Editor
+    """
 
     _bl_idname = "GeometryNodeViewer"
     node: bpy.types.GeometryNodeViewer
@@ -44,6 +46,11 @@ class Viewer(NodeBuilder):
         """Create Viewer with operation 'Face'."""
         return cls(domain="FACE")
 
+    @classmethod
+    def face_corner(cls) -> "Viewer":
+        """Create Viewer with operation 'Face Corner'."""
+        return cls(domain="CORNER")
+
     @classmethod
     def spline(cls) -> "Viewer":
         """Create Viewer with operation 'Spline'."""

nodebpy/nodes/texture.py

@@ -13,7 +13,9 @@ from ..types import (
 
 
 class BrickTexture(NodeBuilder):
-    """Generate a procedural texture producing bricks"""
+    """
+    Generate a procedural texture producing bricks
+    """
 
     _bl_idname = "ShaderNodeTexBrick"
     node: bpy.types.ShaderNodeTexBrick
@@ -149,7 +151,9 @@ class BrickTexture(NodeBuilder):
 
 
 class CheckerTexture(NodeBuilder):
-    """Generate a checkerboard texture"""
+    """
+    Generate a checkerboard texture
+    """
 
     _bl_idname = "ShaderNodeTexChecker"
     node: bpy.types.ShaderNodeTexChecker
@@ -203,7 +207,9 @@ class CheckerTexture(NodeBuilder):
 
 
 class GaborTexture(NodeBuilder):
-    """Generate Gabor noise"""
+    """
+    Generate Gabor noise
+    """
 
     _bl_idname = "ShaderNodeTexGabor"
     node: bpy.types.ShaderNodeTexGabor
@@ -286,7 +292,9 @@ class GaborTexture(NodeBuilder):
 
 
 class GradientTexture(NodeBuilder):
-    """Generate interpolated color and intensity values based on the input vector"""
+    """
+    Generate interpolated color and intensity values based on the input vector
+    """
 
     _bl_idname = "ShaderNodeTexGradient"
     node: bpy.types.ShaderNodeTexGradient
@@ -356,7 +364,9 @@ class GradientTexture(NodeBuilder):
 
 
 class ImageTexture(NodeBuilder):
-    """Sample values from an image texture"""
+    """
+    Sample values from an image texture
+    """
 
     _bl_idname = "GeometryNodeImageTexture"
     node: bpy.types.GeometryNodeImageTexture
@@ -419,7 +429,9 @@ class ImageTexture(NodeBuilder):
 
 
 class MagicTexture(NodeBuilder):
-    """Generate a psychedelic color texture"""
+    """
+    Generate a psychedelic color texture
+    """
 
     _bl_idname = "ShaderNodeTexMagic"
     node: bpy.types.ShaderNodeTexMagic
@@ -472,7 +484,9 @@ class MagicTexture(NodeBuilder):
 
 
 class NoiseTexture(NodeBuilder):
-    """Generate fractal Perlin noise"""
+    """
+    Generate fractal Perlin noise
+    """
 
     _bl_idname = "ShaderNodeTexNoise"
     node: bpy.types.ShaderNodeTexNoise
@@ -614,7 +628,9 @@ class NoiseTexture(NodeBuilder):
 
 
 class VoronoiTexture(NodeBuilder):
-    """Generate Worley noise based on the distance to random points. Typically used to generate textures such as stones, water, or biological cells"""
+    """
+    Generate Worley noise based on the distance to random points. Typically used to generate textures such as stones, water, or biological cells
+    """
 
     _bl_idname = "ShaderNodeTexVoronoi"
     node: bpy.types.ShaderNodeTexVoronoi
@@ -769,7 +785,9 @@ class VoronoiTexture(NodeBuilder):
 
 
 class WaveTexture(NodeBuilder):
-    """Generate procedural bands or rings with noise"""
+    """
+    Generate procedural bands or rings with noise
+    """
 
     _bl_idname = "ShaderNodeTexWave"
     node: bpy.types.ShaderNodeTexWave
@@ -884,7 +902,9 @@ class WaveTexture(NodeBuilder):
 
 
 class WhiteNoiseTexture(NodeBuilder):
-    """Calculate a random value or color based on an input seed"""
+    """
+    Calculate a random value or color based on an input seed
+    """
 
     _bl_idname = "ShaderNodeTexWhiteNoise"
     node: bpy.types.ShaderNodeTexWhiteNoise

nodebpy/nodes/vector.py

@@ -10,7 +10,9 @@ from ..types import (
 
 
 class RadialTiling(NodeBuilder):
-    """Transform Coordinate System for Radial Tiling"""
+    """
+    Transform Coordinate System for Radial Tiling
+    """
 
     _bl_idname = "ShaderNodeRadialTiling"
     node: bpy.types.ShaderNodeRadialTiling
@@ -73,7 +75,9 @@ class RadialTiling(NodeBuilder):
 
 
 class VectorCurves(NodeBuilder):
-    """Map input vector components with curves"""
+    """
+    Map input vector components with curves
+    """
 
     _bl_idname = "ShaderNodeVectorCurve"
     node: bpy.types.ShaderNodeVectorCurve
@@ -105,7 +109,9 @@ class VectorCurves(NodeBuilder):
 
 
 class VectorMath(NodeBuilder):
-    """Perform vector math operation"""
+    """
+    Perform vector math operation
+    """
 
     _bl_idname = "ShaderNodeVectorMath"
     node: bpy.types.ShaderNodeVectorMath
@@ -187,6 +193,28 @@ class VectorMath(NodeBuilder):
         """Create Vector Math with operation 'Divide'."""
         return cls(operation="DIVIDE", vector=vector, vector_001=vector_001)
 
+    @classmethod
+    def multiply_add(
+        cls,
+        vector: TYPE_INPUT_VECTOR = None,
+        vector_001: TYPE_INPUT_VECTOR = None,
+        vector_002: TYPE_INPUT_VECTOR = None,
+    ) -> "VectorMath":
+        """Create Vector Math with operation 'Multiply Add'."""
+        return cls(
+            operation="MULTIPLY_ADD",
+            vector=vector,
+            vector_001=vector_001,
+            vector_002=vector_002,
+        )
+
+    @classmethod
+    def cross_product(
+        cls, vector: TYPE_INPUT_VECTOR = None, vector_001: TYPE_INPUT_VECTOR = None
+    ) -> "VectorMath":
+        """Create Vector Math with operation 'Cross Product'."""
+        return cls(operation="CROSS_PRODUCT", vector=vector, vector_001=vector_001)
+
     @classmethod
     def project(
         cls, vector: TYPE_INPUT_VECTOR = None, vector_001: TYPE_INPUT_VECTOR = None
@@ -228,6 +256,13 @@ class VectorMath(NodeBuilder):
             vector_002=vector_002,
         )
 
+    @classmethod
+    def dot_product(
+        cls, vector: TYPE_INPUT_VECTOR = None, vector_001: TYPE_INPUT_VECTOR = None
+    ) -> "VectorMath":
+        """Create Vector Math with operation 'Dot Product'."""
+        return cls(operation="DOT_PRODUCT", vector=vector, vector_001=vector_001)
+
     @classmethod
     def distance(
         cls, vector: TYPE_INPUT_VECTOR = None, vector_001: TYPE_INPUT_VECTOR = None
@@ -447,7 +482,9 @@ class VectorMath(NodeBuilder):
 
 
 class VectorRotate(NodeBuilder):
-    """Rotate a vector around a pivot point (center)"""
+    """
+    Rotate a vector around a pivot point (center)
+    """
 
     _bl_idname = "ShaderNodeVectorRotate"
     node: bpy.types.ShaderNodeVectorRotate

nodebpy/nodes/zone.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Literal
+from typing import Iterable
 
 import bpy
 
@@ -16,8 +16,6 @@ from ..types import (
 
 
 class BaseZone(DynamicInputsMixin, NodeBuilder, ABC):
-    _items_attribute: Literal["state_items", "repeat_items"]
-
     @property
     @abstractmethod
     def _items_node(
@@ -72,7 +70,11 @@ class BaseZoneInput(BaseZone, NodeBuilder, ABC):
     @property
     def output(
         self,
-    ) -> bpy.types.GeometryNodeSimulationOutput | bpy.types.GeometryNodeRepeatOutput:
+    ) -> (
+        bpy.types.GeometryNodeSimulationOutput
+        | bpy.types.GeometryNodeRepeatOutput
+        | bpy.types.GeometryNodeForeachGeometryElementOutput
+    ):
         return self.node.paired_output  # type: ignore
 
     def _add_socket(self, name: str, type: _BakeDataTypes):
@@ -99,7 +101,6 @@ class BaseZoneOutput(BaseZone, NodeBuilder, ABC):
 
 
 class BaseSimulationZone(BaseZone):
-    _items_attribute = "state_items"
     _socket_data_types = (
         "VALUE",
         "INT",
@@ -168,7 +169,6 @@ class SimulationZone:
 
 
 class BaseRepeatZone(BaseZone):
-    _items_attribute = "repeat_items"
     _socket_data_types = (
         "FLOAT",
         "INT",
@@ -208,12 +208,6 @@ class RepeatInput(BaseRepeatZone, BaseZoneInput):
         """Output socket: Iteration"""
         return self._output("Iteration")
 
-    @property
-    def output_node(self) -> bpy.types.GeometryNodeRepeatOutput:
-        zone_output = self.node.paired_output  # type: ignore
-        assert zone_output is not None
-        return zone_output  # type: ignore
-
 
 class RepeatOutput(BaseRepeatZone, BaseZoneOutput):
     """Repeat Output node"""
@@ -253,25 +247,78 @@ class RepeatZone:
         return self.i, self.input, self.output
 
 
-class ForEachGeometryElementInput(NodeBuilder):
+class ForEachGeometryElementZone:
+    def __init__(
+        self,
+        geometry: TYPE_INPUT_GEOMETRY = None,
+        selection: TYPE_INPUT_BOOLEAN = True,
+        *,
+        domain: _AttributeDomains = "POINT",
+    ):
+        self.input = ForEachGeometryElementInput()
+        self.output = ForEachGeometryElementOutput()
+        self.input.node.pair_with_output(self.output.node)
+        self.output.domain = domain
+        self.input._establish_links(Geometry=geometry, Selection=selection)
+
+    @property
+    def index(self) -> SocketLinker:
+        return self.input.o_index
+
+    def __getitem__(self, index: int):
+        match index:
+            case 0:
+                return self.input
+            case 1:
+                return self.output
+            case _:
+                raise IndexError("ForEachZone has only two items")
+
+
+class ForEachGeometryElementInput(BaseZoneInput):
     """For Each Geometry Element Input node"""
 
+    _socket_data_types = (
+        "VALUE",
+        "INT",
+        "BOOLEAN",
+        "VECTOR",
+        "RGBA",
+        "ROTATION",
+        "MATRIX",
+        "MENU",
+    )
+    _type_map = {"VALUE": "FLOAT"}
+
     _bl_idname = "GeometryNodeForeachGeometryElementInput"
     node: bpy.types.GeometryNodeForeachGeometryElementInput
 
     def __init__(
-        self,
-        geometry: TYPE_INPUT_GEOMETRY = None,
-        selection: TYPE_INPUT_BOOLEAN = True,
-        extend: LINKABLE | None = None,
-        **kwargs,
+        self, geometry: TYPE_INPUT_GEOMETRY = None, selection: TYPE_INPUT_BOOLEAN = True
     ):
         super().__init__()
-        key_args = {"Geometry": geometry, "Selection": selection, "__extend__": extend}
-        key_args.update(kwargs)
-
+        key_args = {"Geometry": geometry, "Selection": selection}
         self._establish_links(**key_args)
 
+    def capture(
+        self, value: LINKABLE, domain: _AttributeDomains = "POINT"
+    ) -> SocketLinker:
+        """Capture something as an input to the simulation"""
+        item_dict = self._add_inputs(value)
+        self._establish_links(**item_dict)
+        new_output_idx = [o.identifier for o in self.node.outputs].index(
+            "__extend__"
+        ) - 1
+        print(f"{new_output_idx=}")
+        output = self.node.outputs[new_output_idx]
+        print(f"{output=} {output.type=}")
+
+        return SocketLinker(output)
+
+    @property
+    def items(self) -> bpy.types.NodeGeometryForeachGeometryElementInputItems:
+        return self.output.input_items
+
     @property
     def i_geometry(self) -> SocketLinker:
         """Input socket: Geometry"""
@@ -282,113 +329,100 @@ class ForEachGeometryElementInput(NodeBuilder):
         """Input socket: Selection"""
         return self._input("Selection")
 
-    @property
-    def i_input_socket(self) -> SocketLinker:
-        """Input socket:"""
-        return self._input("__extend__")
-
     @property
     def o_index(self) -> SocketLinker:
         """Output socket: Index"""
         return self._output("Index")
 
-    @property
-    def o_input_socket(self) -> SocketLinker:
-        """Output socket:"""
-        return self._output("__extend__")
-
 
-class ForEachGeometryElementOutput(NodeBuilder):
+class ForEachGeometryElementOutput(BaseZoneOutput):
     """For Each Geometry Element Output node"""
 
+    _socket_data_types = [
+        "VALUE",
+        "INT",
+        "BOOLEAN",
+        "VECTOR",
+        "RGBA",
+        "ROTATION",
+        "MATRIX",
+    ]
+    _type_map = {"VALUE": "FLOAT"}
+
     _bl_idname = "GeometryNodeForeachGeometryElementOutput"
     node: bpy.types.GeometryNodeForeachGeometryElementOutput
 
     def __init__(
         self,
-        extend_main: LINKABLE | None = None,
-        generation_0: LINKABLE = None,
-        extend_generation: LINKABLE | None = None,
-        active_input_index: int = 0,
-        active_generation_index: int = 0,
-        active_main_index: int = 0,
         domain: _AttributeDomains = "POINT",
-        inspection_index: int = 0,
         **kwargs,
     ):
         super().__init__()
-        key_args = {
-            "__extend__main": extend_main,
-            "Generation_0": generation_0,
-            "__extend__generation": extend_generation,
-        }
+        key_args = {}
         key_args.update(kwargs)
-        self.active_input_index = active_input_index
-        self.active_generation_index = active_generation_index
-        self.active_main_index = active_main_index
         self.domain = domain
-        self.inspection_index = inspection_index
         self._establish_links(**key_args)
 
     @property
-    def i_input_socket(self) -> SocketLinker:
-        """Input socket:"""
-        return self._input("__extend__main")
+    def items(self) -> bpy.types.NodeGeometryForeachGeometryElementMainItems:
+        return self.node.main_items
+
+    @property
+    def items_generated(
+        self,
+    ) -> bpy.types.NodeGeometryForeachGeometryElementGenerationItems:
+        return self.node.generation_items
+
+    def _latest(
+        self, suffix: str, sockets: Iterable[bpy.types.NodeSocket]
+    ) -> bpy.types.NodeSocket:
+        idx = [o.identifier for o in sockets].index(f"__extend__{suffix}") - 1
+        return sockets[idx]
+
+    def capture(
+        self, value: LINKABLE, domain: _AttributeDomains = "POINT"
+    ) -> SocketLinker:
+        """Capture something as an input to the simulation"""
+        item_dict = self._add_inputs(value)
+        self._establish_links(**item_dict)
+        return SocketLinker(self._latest("main", self.node.outputs))
+
+    def capture_generated(self, value: LINKABLE) -> SocketLinker:
+        self._socket_data_types = self._socket_data_types + ["GEOMETRY"]
+        self._add_socket = self._add_socket_generated
+        item_dict = self._add_inputs(value)
+        self._establish_links(**item_dict)
+        self._socket_data_types = list(
+            [x for x in self._socket_data_types if x != "GEOMETRY"]
+        )
+        self._add_socket = self._add_socket_main
+        return SocketLinker(self._latest("generation", self.node.outputs))
+
+    def _add_socket_main(self, name: str, type: _BakeDataTypes):
+        """Add a socket to the zone"""
+        _ = self.items.new(type, name)
+        return self._latest("main", self.node.inputs)
+
+    def _add_socket_generated(self, name: str, type: _BakeDataTypes):
+        """Add a socket to the zone"""
+        _ = self.items_generated.new(type, name)
+        return self._latest("generation", self.node.inputs)
 
     @property
     def i_geometry(self) -> SocketLinker:
         """Input socket: Geometry"""
         return self._input("Generation_0")
 
-    @property
-    def i_extend_generation(self) -> SocketLinker:
-        """Input socket:"""
-        return self._input("__extend__generation")
-
     @property
     def o_geometry(self) -> SocketLinker:
         """Output socket: Geometry"""
         return self._output("Geometry")
 
     @property
-    def o_input_socket(self) -> SocketLinker:
-        """Output socket:"""
-        return self._output("__extend__main")
-
-    @property
-    def o_generation_0(self) -> SocketLinker:
+    def o_generation(self) -> SocketLinker:
         """Output socket: Geometry"""
         return self._output("Generation_0")
 
-    @property
-    def o_extend_generation(self) -> SocketLinker:
-        """Output socket:"""
-        return self._output("__extend__generation")
-
-    @property
-    def active_input_index(self) -> int:
-        return self.node.active_input_index
-
-    @active_input_index.setter
-    def active_input_index(self, value: int):
-        self.node.active_input_index = value
-
-    @property
-    def active_generation_index(self) -> int:
-        return self.node.active_generation_index
-
-    @active_generation_index.setter
-    def active_generation_index(self, value: int):
-        self.node.active_generation_index = value
-
-    @property
-    def active_main_index(self) -> int:
-        return self.node.active_main_index
-
-    @active_main_index.setter
-    def active_main_index(self, value: int):
-        self.node.active_main_index = value
-
     @property
     def domain(
         self,
@@ -401,11 +435,3 @@ class ForEachGeometryElementOutput(NodeBuilder):
         value: _AttributeDomains,
     ):
         self.node.domain = value
-
-    @property
-    def inspection_index(self) -> int:
-        return self.node.inspection_index
-
-    @inspection_index.setter
-    def inspection_index(self, value: int):
-        self.node.inspection_index = value

{nodebpy-0.3.0.dist-info → nodebpy-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: nodebpy
-Version: 0.3.0
+Version: 0.3.1
 Summary: Build nodes in Blender with code
 Author: Brady Johnston
 Author-email: Brady Johnston <brady.johnston@me.com>
@@ -158,3 +158,13 @@ actually build.
   - `TransformGeometry.matrix(CombineTrasnsform(translation=(0, 0, 1))`
   - `TransformGeoemtry.components(translation=(0, 0, 1))`
   - `TransformGeometry(translation=(0, 0, 1))`
+
+## Building
+
+Most node classes are generated automatically with this. The nodes in
+`nodes/manual.py` are currently manually specified due to varying
+complexities of particular nodes (usually lergacy).
+
+``` bash
+uv run generate.py && ruff format && ruff check --fix --unsafe-fixes
+```