Node Groups

BlenderMalt/MaltMaterial.py

@@ -51,6 +51,12 @@ def get_source_path(self):
         else:
             return ''
 
+    def get_parameters(self, overrides, proxys):
+        parameters = self.parameters.get_parameters(overrides, proxys)
+        if self.shader_nodes:
+            parameters.update(self.shader_nodes.get_group_parameters(overrides, proxys))
+        return parameters
+
     def draw_ui(self, layout, extension, material_parameters):
         layout.active = self.id_data.library is None #only local data can be edited
         layout.prop_search(self, 'material_type', bpy.context.scene.world.malt, 'material_types')

BlenderMalt/MaltNodes/MaltNodeTree.py

@@ -42,6 +42,7 @@ def poll_material(self, material):
         return material.malt.shader_nodes is self
 
     def update_graph_type(self, context):
+        self.is_group_type = self.graph_type.endswith(' (Group)')
         graph = self.get_pipeline_graph()
         if graph and graph.default_graph_path and len(self.nodes) == 0:
             blend_path, tree_name = graph.default_graph_path
@@ -59,9 +60,14 @@ def update_graph_type(self, context):
             self.user_remap(copy)
             bpy.data.node_groups.remove(self)
             copy.name = name
+        else:
+            self.reload_nodes()
+            self.update_ext(force_update=True)
 
     graph_type: bpy.props.StringProperty(name='Type', update=update_graph_type,
         options={'LIBRARY_EDITABLE'}, override={'LIBRARY_OVERRIDABLE'})
+    is_group_type : bpy.props.BoolProperty(default=False,
+        options={'SKIP_SAVE','LIBRARY_EDITABLE'}, override={'LIBRARY_OVERRIDABLE'})
 
     #deprecated
     library_source : bpy.props.StringProperty(name="Local Library", subtype='FILE_PATH',
@@ -83,6 +89,55 @@ def update_graph_type(self, context):
 
     def is_active(self):
         return self.get_pipeline_graph() is not None
+
+    def is_group(self):
+        return self.is_group_type
+
+    def get_group_source_name(self):
+        name = self.get_transpiler().get_source_name(self.name, prefix='').upper()
+        return name
+
+    def get_group_function(self, force_update=False):
+        if force_update == False and self.get('group_function'):
+            return self['group_function']
+        parameters = []
+        for node in self.nodes:
+            if node.bl_idname == 'MaltIONode':
+                sockets = node.inputs if node.is_output else node.outputs
+                for socket in sockets:
+                    parameters.append({
+                        'meta': {
+                            'label': socket.name,    
+                        },
+                        'name': socket.get_source_reference(),
+                        'type': socket.data_type,
+                        'size': socket.array_size,
+                        'io': 'out' if node.is_output else 'in'
+                    })
+        parameter_signature = ', '.join([f"{p['io']} {p['type']} {p['name']}" for p in parameters])
+        signature = f'void {self.get_group_source_name()}({parameter_signature})'
+        self['group_function'] = {
+            'meta': {},
+            'name': self.get_group_source_name(),
+            'type': 'void',
+            'parameters': parameters,
+            'signature': signature,
+        }
+        return self['group_function']
+
+    def get_group_parameters(self, overrides, proxys):
+        groups = []
+        parameters = {}
+        def get_groups(tree):
+            for node in tree.nodes:
+                if node.bl_idname == 'MaltGroupNode' and node.group is not None:
+                    if node.group not in groups:
+                        groups.append(node.group)
+                        get_groups(node.group)
+        get_groups(self)
+        for group in groups:
+            parameters.update(group.malt_parameters.get_parameters(overrides, proxys))
+        return parameters
 
     def get_source_language(self):
         return self.get_pipeline_graph().language
@@ -242,7 +297,13 @@ def get_source(output):
         for node in linked_nodes:
             if hasattr(node, 'get_source_global_parameters'):
                 shader['GLOBAL'] += node.get_source_global_parameters(transpiler)
-        self['source'] = pipeline_graph.generate_source(shader)
+        if self.is_group():
+            shader['SKIP INCLUDES'] = True
+            shader['INCLUDE GUARD'] = self.get_group_source_name() + '_GLSL'
+        source = pipeline_graph.generate_source(shader)
+        if self.is_group():
+            source = source.replace('void NODE_GROUP_FUNCTION()', self.get_group_function()['signature'])
+        self['source'] = source
         return self['source']
 
     def reload_nodes(self):
@@ -254,10 +315,21 @@ def reload_nodes(self):
             for node in self.nodes:
                 if hasattr(node, 'update'):
                     node.update()
+            self.get_group_function(force_update=True)
         except:
             import traceback
             traceback.print_exc()
         self.disable_updates = False
+
+    def on_name_change(self, old_src_name):
+        if self.is_group():
+            new_src_name = self.get_group_source_name()
+            for key in list(self.malt_parameters.get_rna().keys()):
+                if old_src_name in key:
+                    self.malt_parameters.rename_property(key, key.replace(old_src_name, new_src_name))
+            bpy.msgbus.clear_by_owner(self)
+            self.subscribed = False
+        self.update_ext(force_update=True)
 
     def update(self):
         if self.is_active():
@@ -272,7 +344,7 @@ def update_ext(self, force_track_shader_changes=True, force_update=False):
 
         if self.subscribed == False:
             bpy.msgbus.subscribe_rna(key=self.path_resolve('name', False),
-                owner=self, args=(None,), notify=lambda _ : self.update_ext(force_update=True))
+                owner=self, args=(self.get_group_source_name(),), notify=lambda arg : self.on_name_change(arg))
             self.subscribed = True
 
         links_str = ''
@@ -310,7 +382,26 @@ def update_ext(self, force_track_shader_changes=True, force_update=False):
             pathlib.Path(source_dir).mkdir(parents=True, exist_ok=True)
             with open(source_path,'w') as f:
                 f.write(source)
+
             if force_track_shader_changes:
+                if self.is_group():
+                    from pathlib import Path
+                    visited_trees = set()
+                    def recompile_users(updated_tree):
+                        visited_trees.add(updated_tree)
+                        if updated_tree.is_group():
+                            for tree in bpy.data.node_groups:
+                                if tree.bl_idname == 'MaltTree' and tree not in visited_trees:
+                                    for node in tree.nodes:
+                                        if node.bl_idname == 'MaltGroupNode' and node.group is updated_tree:
+                                            recompile_users(tree)
+                                            break
+                        else:
+                            #Touch the file to force a recompilation
+                            Path(updated_tree.get_generated_source_path()).touch()
+                            return
+                    recompile_users(self)
+
                 from BlenderMalt import MaltMaterial
                 MaltMaterial.track_shader_changes()
         except:
@@ -334,7 +425,10 @@ def setup_node_trees():
     for tree in bpy.data.node_groups:
         if tree.bl_idname == 'MaltTree' and tree.is_active():
             tree.reload_nodes()
+    for tree in bpy.data.node_groups:
+        if tree.bl_idname == 'MaltTree' and tree.is_active():
             tree.update_ext(force_track_shader_changes=False, force_update=True)
+
     from BlenderMalt import MaltMaterial
     MaltMaterial.track_shader_changes()
 
@@ -370,6 +464,8 @@ def track_library_changes(force_update=False, is_initial_setup=False):
     updated_graphs = []
     if is_initial_setup == False:
         for name, graph in graphs.items():
+            if '(Group)' in name:
+                continue
             if graph.needs_reload():
                 updated_graphs.append(name)
         if len(updated_graphs) > 0:        
@@ -486,7 +582,7 @@ def draw_nothing(self, layout, _context):
             super().__init__(nodetype, category, label=label, settings=settings, poll=poll, draw=draw_nothing)
 
 
-    category_id = f'BLENDERMALT_{graph.name.upper()}'
+    category_id = f'MALT{graph.name.upper()}'
 
     try:
         unregister_node_categories(category_id) # you could also check the hidden <nodeitems_utils._node_categories>
@@ -527,6 +623,9 @@ def draw_nothing(self, layout, _context):
         categories['Other'].append(NodeItem('MaltArrayIndexNode', label='Array Element', settings={
             'name' : repr('Array Element')
         }))
+        categories['Other'].append(NodeItem('MaltGroupNode', label='Node Group', settings={
+            'name' : repr('Node Group')
+        }))
 
     subcategories = set()
 
@@ -635,6 +734,7 @@ def duplicate():
         context.space_data.node_tree = node_tree.get_copy()
     self.layout.operator('wm.malt_callback', text='', icon='DUPLICATE').callback.set(duplicate, 'Duplicate')
     def recompile():
+        node_tree.reload_nodes()
         node_tree.update_ext(force_update=True)
     self.layout.operator("wm.malt_callback", text='', icon='FILE_REFRESH').callback.set(recompile, 'Recompile')
     self.layout.prop_search(node_tree, 'graph_type', context.scene.world.malt, 'graph_types',text='')
@@ -666,7 +766,11 @@ def set_node_tree(context, node_tree, node = None):
             locked_spaces[0].node_tree = node_tree
 
 
+SKIP_MATERIAL_UPDATE = False
 def active_material_update(dummy=None):
+    global SKIP_MATERIAL_UPDATE
+    if SKIP_MATERIAL_UPDATE:
+        return
     try:
         material = bpy.context.object.active_material
         node_tree = material.malt.shader_nodes

BlenderMalt/MaltNodes/MaltNodeUITools.py

@@ -117,8 +117,8 @@ def execute( self, context ):
         node = context.active_node
         space_path = context.space_data.path
         node_tree = None
-        if node and hasattr(node, 'get_pass_node_tree'):
-            node_tree = node.get_pass_node_tree()
+        if node and hasattr(node, 'get_linked_node_tree'):
+            node_tree = node.get_linked_node_tree()
         if node_tree:
             space_path.append(node_tree, node = node)
         else:
@@ -343,13 +343,89 @@ def execute(self, context: bpy.types.Context):
             bpy.ops.wm.malt_cycle_sub_categories('INVOKE_DEFAULT')
         return{'FINISHED'}
 
+class OT_MaltAddNodeGroup(bpy.types.Operator):
+    bl_idname = 'wm.malt_add_node_group'
+    bl_label = 'Add Node Group'
+    bl_description = 'Add a new node group to a group node'
+    bl_options = {'UNDO'}
+
+    @classmethod
+    def poll(cls, context: bpy.types.Context):
+        from BlenderMalt.MaltNodes.Nodes import MaltGroupNode
+        return (
+            is_malt_tree_context(context)
+            and isinstance(context.active_node, MaltGroupNode.MaltGroupNode)
+        )
+
+    def execute(self, context: bpy.types.Context):
+        from BlenderMalt.MaltNodes.Nodes import MaltGroupNode
+        node: MaltGroupNode.MaltGroupNode = context.active_node
+        node.create_new_group()
+        return {'FINISHED'}
+
+    @classmethod
+    def draw_ui(cls, layout: bpy.types.UILayout, node: bpy.types.Node, **layout_args):
+        layout.context_pointer_set('active_node', node)
+        layout.operator(cls.bl_idname, **layout_args)
+
+class OT_MaltNodesToGroup(bpy.types.Operator):
+    bl_idname = 'wm.malt_nodes_to_group'
+    bl_label = 'Convert Nodes to Group'
+    bl_description = 'Copies selected nodes and converts them into a new node group'
+
+    @classmethod
+    def poll(cls, context: bpy.types.Context):
+        return (
+            is_malt_tree_context(context)
+            and len(context.selected_nodes) > 0
+        )
+
+    def execute(self, context: bpy.types.Context):
+        from BlenderMalt.MaltNodes.Nodes.MaltGroupNode import MaltGroupNode
+        from BlenderMalt.MaltNodes.MaltNodeTree import set_node_tree
+        from BlenderMalt.MaltNodes import MaltNodeTree
+        from mathutils import Vector
+        MaltNodeTree.SKIP_MATERIAL_UPDATE = True
+        sd: bpy.types.SpaceNodeEditor = context.space_data
+        initial_tree = sd.edit_tree
+        for n in context.selected_nodes:
+            if n.bl_idname == 'MaltIONode':
+                n.select = False
+        selected: list[bpy.types.Node] = context.selected_nodes
+        avg_loc = Vector((0.0, 0.0))
+        for node in selected:
+            avg_loc += Vector(get_absolute_node_position(node))
+        avg_loc /= len(selected)
+
+        bpy.ops.node.clipboard_copy()
+        new_group_node: MaltGroupNode = sd.edit_tree.nodes.new(MaltGroupNode.bl_idname)
+        new_nt = new_group_node.create_new_group()
+        new_group_node.location = avg_loc
+        sd.edit_tree.active = new_group_node
+        for n in sd.edit_tree.nodes:
+            n.select = n == new_group_node
+        set_node_tree(context, new_nt, new_group_node)
+        bpy.ops.node.clipboard_paste()
+        for n in new_nt.nodes.values():
+            n.location = Vector(n.location) - avg_loc
+        for n in selected:
+            initial_tree.nodes.remove(n)
+        MaltNodeTree.SKIP_MATERIAL_UPDATE = False
+        return {'FINISHED'}
+
+def get_absolute_node_position(node: bpy.types.Node):
+    if node.parent is None:
+        return node.location
+    return get_absolute_node_position(node.parent) + node.location
 
 classes = [
     NodeTreePreview,
     OT_MaltEditNodeTree,
     OT_MaltSetTreePreview,
     OT_MaltConnectTreePreview,
     OT_MaltCycleSubCategories,
+    OT_MaltAddNodeGroup,
+    OT_MaltNodesToGroup,
     NODE_OT_add_malt_subcategory_node,
 ]
 
@@ -445,6 +521,7 @@ def add_shortcut(keymaps: list, operator: bpy.types.Operator, *, type: str, valu
         add_shortcut(keymaps, OT_MaltEditNodeTree, type='TAB', value='PRESS')
         add_shortcut(keymaps, OT_MaltSetTreePreview, type='LEFTMOUSE', value='PRESS', shift=True, alt=True)
         add_shortcut(keymaps, OT_MaltConnectTreePreview, type='LEFTMOUSE', value='PRESS', shift=True, ctrl=True)
+        add_shortcut(keymaps, OT_MaltNodesToGroup, type='G', value='PRESS', ctrl=True)
 
 def register():
     for _class in classes: bpy.utils.register_class(_class)

BlenderMalt/MaltNodes/MaltSocket.py

@@ -76,6 +76,8 @@ def get_source_global_reference(self):
         assert(self.active)
         transpiler = self.id_data.get_transpiler()
         result = transpiler.global_reference(self.node.get_source_name(), self.name)
+        if self.id_data.is_group():
+            result = result.replace('U_0_',f'_U_0_{self.id_data.get_group_source_name()}_')
         if len(result) > 63:
             #Blender dictionary keys are limited to 63 characters
             import xxhash

BlenderMalt/MaltNodes/Nodes/MaltFunctionNode.py

@@ -123,7 +123,7 @@ def get_pass_type(self):
                 return pass_type
         return ''
 
-    def get_pass_node_tree(self):
+    def get_linked_node_tree(self):
         if self.pass_graph_type != '':
             graph = self.id_data.get_pipeline_graph(self.pass_graph_type)
             if graph.graph_type == graph.GLOBAL_GRAPH:
@@ -179,6 +179,7 @@ def get_source_socket_reference(self, socket):
             return transpiler.parameter_reference(self.get_source_name(), socket.name, 'out' if socket.is_output else 'in')
         else:
             source = self.get_source_code(transpiler)
+            #TODO: Assumes return type, support out and inout parameters
             return source.splitlines()[-1].split('=')[-1].split(';')[0]
 
     def get_source_code(self, transpiler):