feat: repeat zones

Author: BrendanParmer

compositor/node_settings.py

@@ -422,7 +422,7 @@
 
 
 
-    #UTILITIES
+    # UTILITIES
     'CompositorNodeMapRange'   : [("use_clamp", ST.BOOL)],
 
     'CompositorNodeMapValue'   : [("max",     ST.VEC1),

geometry/node_settings.py

@@ -367,7 +367,7 @@
     'FunctionNodeRandomValue' : [("data_type", ST.ENUM)],
 
     'GeometryNodeRepeatInput'  : [],
-    'GeometryNodeRepeatOutput' : [],
+    'GeometryNodeRepeatOutput' : [("inspection_index", ST.INT)],
 
     'GeometryNodeSwitch' : [("input_type", ST.ENUM)],
 

geometry/node_tree.py

@@ -1,8 +1,18 @@
-from bpy.types import GeometryNodeTree, GeometryNodeSimulationInput
+import bpy
+from bpy.types import GeometryNodeTree
+
+if bpy.app.version >= (3, 6, 0):
+    from bpy.types import GeometryNodeSimulationInput
+
+if bpy.app.version > (4, 0, 0):
+    from bpy.types import GeometryNodeRepeatInput
 
 from ..ntp_node_tree import NTP_NodeTree
 
 class NTP_GeoNodeTree(NTP_NodeTree):
     def __init__(self, node_tree: GeometryNodeTree, var: str):
         super().__init__(node_tree, var)
-        self.sim_inputs: list[GeometryNodeSimulationInput] = []
+        if bpy.app.version >= (3, 6, 0):
+            self.sim_inputs: list[GeometryNodeSimulationInput] = []
+        if bpy.app.version >= (4, 0, 0):
+            self.repeat_inputs: list[GeometryNodeRepeatInput] = []

geometry/operator.py

@@ -1,9 +1,14 @@
 import bpy
-from bpy.types import GeometryNodeSimulationInput
-from bpy.types import GeometryNodeSimulationOutput
-from bpy.types import GeometryNodeTree
+from bpy.types import GeometryNode, GeometryNodeTree
 from bpy.types import Node
 
+if bpy.app.version >= (3, 6, 0):
+    from bpy.types import GeometryNodeSimulationInput
+    from bpy.types import GeometryNodeSimulationOutput
+if bpy.app.version >= (4, 0, 0):
+    from bpy.types import GeometryNodeRepeatInput
+    from bpy.types import GeometryNodeRepeatOutput
+
 from io import StringIO
 
 from ..ntp_operator import NTP_Operator
@@ -30,21 +35,34 @@ def __init__(self):
         super().__init__()
         self._settings = geo_node_settings
 
-    def _process_sim_output_node(self, node: GeometryNodeSimulationOutput,
-                                 inner: str, node_var: str) -> None:
-        self._write(f"{inner}# Remove generated sim state items\n")
-        self._write(f"{inner}for item in {node_var}.state_items:\n")
-        self._write(f"{inner}\t{node_var}.state_items.remove(item)\n")
-
-        for i, si in enumerate(node.state_items):
-            socket_type = enum_to_py_str(si.socket_type)
-            name = str_to_py_str(si.name)
-            self._write(f"{inner}#create SSI {name}\n")
-            self._write((f"{inner}{node_var}.state_items.new"
-                         f"({socket_type}, {name})\n"))
-            si_var = f"{node_var}.state_items[{i}]"
-            attr_domain = enum_to_py_str(si.attribute_domain)
-            self._write((f"{inner}{si_var}.attribute_domain = {attr_domain}\n"))
+    if bpy.app.version >= (3, 6, 0):
+        def _process_zone_output_node(self, node: GeometryNode, inner: str,
+                                    node_var: str) -> None:
+            is_sim = False
+            if node.bl_idname == 'GeometryNodeSimulationOutput':
+                items = "state_items"
+                is_sim = True
+            elif node.bl_idname == 'GeometryNodeRepeatOutput':
+                items = "repeat_items"
+            else:
+                self.report({'WARNING'}, f"{node.bl_idname} is not recognized "
+                                         f" as avalid zone output")
+
+            self._write(f"{inner}# Remove generated {items}\n")
+            self._write(f"{inner}for item in {node_var}.{items}:\n")
+            self._write(f"{inner}\t{node_var}.{items}.remove(item)\n")
+
+            for i, item in enumerate(getattr(node, items)):
+                socket_type = enum_to_py_str(item.socket_type)
+                name = str_to_py_str(item.name)
+                self._write(f"{inner}# Create item {name}\n")
+                self._write(f"{inner}{node_var}.{items}.new"
+                            f"({socket_type}, {name})\n")
+                if is_sim:
+                    item_var = f"{node_var}.{items}[{i}]"
+                    attr_domain = enum_to_py_str(item.attribute_domain)
+                    self._write((f"{inner}{item_var}.attribute_domain = "
+                                f"{attr_domain}\n"))
 
     def _process_node(self, node: Node, ntp_node_tree: NTP_GeoNodeTree,
                       inner: str, level: int) -> None:
@@ -66,34 +84,42 @@ def _process_node(self, node: Node, ntp_node_tree: NTP_GeoNodeTree,
             ntp_node_tree.sim_inputs.append(node)
 
         elif node.bl_idname == 'GeometryNodeSimulationOutput':
-            self._process_sim_output_node(node, inner, node_var)
+            self._process_zone_output_node(node, inner, node_var)
+
+        elif node.bl_idname == 'GeometryNodeRepeatInput':
+            ntp_node_tree.repeat_inputs.append(node)
+        
+        elif node.bl_idname == 'GeometryNodeRepeatOutput':
+            self._process_zone_output_node(node, inner, node_var)
 
         self._hide_hidden_sockets(node, inner, node_var)
 
-        if node.bl_idname != 'GeometryNodeSimulationInput':
+        if node.bl_idname not in {'GeometryNodeSimulationInput', 'GeometryNodeRepeatInput'}:
             self._set_socket_defaults(node, node_var, inner)
 
-
-    def _process_sim_zones(self, sim_inputs: list[GeometryNodeSimulationInput], 
-                           inner: str) -> None:
-        """
-        Recreate simulation zones
-        sim_inputs (list[GeometryNodeSimulationInput]): list of 
-            simulation input nodes
-        inner (str): identation string
-        """
-        for sim_input in sim_inputs:
-            sim_output = sim_input.paired_output
-
-            sim_input_var = self._node_vars[sim_input]
-            sim_output_var = self._node_vars[sim_output]
-            self._write((f"{inner}{sim_input_var}.pair_with_output"
-                         f"({sim_output_var})\n"))
-
-            #must set defaults after paired with output
-            self._set_socket_defaults(sim_input, sim_input_var, inner)
-            self._set_socket_defaults(sim_output, sim_output_var, inner)
-
+    if bpy.app.version >= (3, 6, 0):
+        def _process_zones(self, zone_inputs: list[GeometryNode], 
+                            inner: str) -> None:
+            """
+            Recreates a zone
+            zone_inputs (list[GeometryNodeSimulationInput]): list of 
+                simulation input nodes
+            inner (str): identation string
+            """
+            for zone_input in zone_inputs:
+                zone_output = zone_input.paired_output
+
+                zone_input_var = self._node_vars[zone_input]
+                zone_output_var = self._node_vars[zone_output]
+
+                self._write(f"{inner}#Process zone input {zone_input.name}\n")
+                self._write((f"{inner}{zone_input_var}.pair_with_output"
+                            f"({zone_output_var})\n"))
+
+                #must set defaults after paired with output
+                self._set_socket_defaults(zone_input, zone_input_var, inner)
+                self._set_socket_defaults(zone_output, zone_output_var, inner)
+            self._write("\n")
 
     def _process_node_tree(self, node_tree: GeometryNodeTree, 
                                level: int) -> None:
@@ -145,8 +171,11 @@ def _process_node_tree(self, node_tree: GeometryNodeTree,
         for node in node_tree.nodes:
             self._process_node(node, ntp_nt, inner, level)
 
-        self._process_sim_zones(ntp_nt.sim_inputs, inner)
-        
+        if bpy.app.version >= (3, 6, 0):
+            self._process_zones(ntp_nt.sim_inputs, inner)
+        if bpy.app.version >= (4, 0, 0):
+            self._process_zones(ntp_nt.repeat_inputs, inner)
+
         #set look of nodes
         self._set_parents(node_tree, inner)
         self._set_locations(node_tree, inner)

ntp_operator.py

@@ -1069,8 +1069,7 @@ def _report_finished(self, object: str):
             location = "clipboard"
         else:
             location = self._dir
-        self.report({'INFO'},
-                    f"NodeToPython: Saved {object} to {location}")
+        self.report({'INFO'}, f"NodeToPython: Saved {object} to {location}")
 
     # ABSTRACT
     def execute(self):