e071288ab2
Part 3/3 of #109135, #110272 Switch to new node group interfaces and deprecate old DNA and API. This completes support for panels in node drawing and in node group interface declarations in particular. The new node group interface DNA and RNA code has been added in parts 1 and 2 (#110885, #110952) but has not be enabled yet. This commit completes the integration by * enabling the new RNA API * using the new API in UI * read/write new interfaces from blend files * add versioning for backward compatibility * add forward-compatible writing code to reconstruct old interfaces All places accessing node group interface declarations should now be using the new API. A runtime cache has been added that allows simple linear access to socket inputs and outputs even when a panel hierarchy is used. Old DNA has been deprecated and should only be accessed for versioning (inputs/outputs renamed to inputs_legacy/outputs_legacy to catch errors). Versioning code ensures both backward and forward compatibility of existing files. The API for old interfaces is removed. The new API is very similar but is defined on the `ntree.interface` instead of the `ntree` directly. Breaking change notifications and detailed instructions for migrating will be added. A python test has been added for the node group API functions. This includes new functionality such as creating panels and moving items between different levels. This patch does not yet contain panel representations in the modifier UI. This has been tested in a separate branch and will be added with a later PR (#108565). Pull Request: https://projects.blender.org/blender/blender/pulls/111348
201 lines
6.5 KiB
Python
201 lines
6.5 KiB
Python
import bpy
|
|
from bpy.types import NodeTree, Node, NodeSocket, NodeTreeInterfaceSocket
|
|
|
|
# Implementation of custom nodes from Python
|
|
|
|
|
|
# Derived from the NodeTree base type, similar to Menu, Operator, Panel, etc.
|
|
class MyCustomTree(NodeTree):
|
|
# Description string
|
|
'''A custom node tree type that will show up in the editor type list'''
|
|
# Optional identifier string. If not explicitly defined, the python class name is used.
|
|
bl_idname = 'CustomTreeType'
|
|
# Label for nice name display
|
|
bl_label = "Custom Node Tree"
|
|
# Icon identifier
|
|
bl_icon = 'NODETREE'
|
|
|
|
|
|
# Custom socket type
|
|
class MyCustomSocket(NodeSocket):
|
|
# Description string
|
|
"""Custom node socket type"""
|
|
# Optional identifier string. If not explicitly defined, the python class name is used.
|
|
bl_idname = 'CustomSocketType'
|
|
# Label for nice name display
|
|
bl_label = "Custom Node Socket"
|
|
|
|
input_value: bpy.props.FloatProperty(
|
|
name="Value",
|
|
description="Value when the socket is not connected",
|
|
)
|
|
|
|
# Optional function for drawing the socket input value
|
|
def draw(self, context, layout, node, text):
|
|
if self.is_output or self.is_linked:
|
|
layout.label(text=text)
|
|
else:
|
|
layout.prop(self, "input_value", text=text)
|
|
|
|
# Socket color
|
|
@classmethod
|
|
def draw_color_simple(cls):
|
|
return (1.0, 0.4, 0.216, 0.5)
|
|
|
|
|
|
# Customizable interface properties to generate a socket from.
|
|
class MyCustomInterfaceSocket(NodeTreeInterfaceSocket):
|
|
# The type of socket that is generated.
|
|
bl_socket_idname = 'CustomSocketType'
|
|
|
|
default_value: bpy.props.FloatProperty(default=1.0, description="Default input value for new sockets",)
|
|
|
|
def draw(self, context, layout):
|
|
# Display properties of the interface.
|
|
layout.prop(self, "default_value")
|
|
|
|
# Set properties of newly created sockets
|
|
def init_socket(self, node, socket, data_path):
|
|
socket.input_value = self.default_value
|
|
|
|
# Use an existing socket to initialize the group interface
|
|
def from_socket(self, node, socket):
|
|
# Current value of the socket becomes the default
|
|
self.default_value = socket.input_value
|
|
|
|
|
|
# Mix-in class for all custom nodes in this tree type.
|
|
# Defines a poll function to enable instantiation.
|
|
class MyCustomTreeNode:
|
|
@classmethod
|
|
def poll(cls, ntree):
|
|
return ntree.bl_idname == 'CustomTreeType'
|
|
|
|
|
|
# Derived from the Node base type.
|
|
class MyCustomNode(MyCustomTreeNode, Node):
|
|
# === Basics ===
|
|
# Description string
|
|
'''A custom node'''
|
|
# Optional identifier string. If not explicitly defined, the python class name is used.
|
|
bl_idname = 'CustomNodeType'
|
|
# Label for nice name display
|
|
bl_label = "Custom Node"
|
|
# Icon identifier
|
|
bl_icon = 'SOUND'
|
|
|
|
# === Custom Properties ===
|
|
# These work just like custom properties in ID data blocks
|
|
# Extensive information can be found under
|
|
# https://docs.blender.org/api/current/bpy.props.html
|
|
my_string_prop: bpy.props.StringProperty()
|
|
my_float_prop: bpy.props.FloatProperty(default=3.1415926)
|
|
|
|
# === Optional Functions ===
|
|
# Initialization function, called when a new node is created.
|
|
# This is the most common place to create the sockets for a node, as shown below.
|
|
# NOTE: this is not the same as the standard __init__ function in Python, which is
|
|
# a purely internal Python method and unknown to the node system!
|
|
def init(self, context):
|
|
self.inputs.new('CustomSocketType', "Hello")
|
|
self.inputs.new('NodeSocketFloat', "World")
|
|
self.inputs.new('NodeSocketVector', "!")
|
|
|
|
self.outputs.new('NodeSocketColor', "How")
|
|
self.outputs.new('NodeSocketColor', "are")
|
|
self.outputs.new('NodeSocketFloat', "you")
|
|
|
|
# Copy function to initialize a copied node from an existing one.
|
|
def copy(self, node):
|
|
print("Copying from node ", node)
|
|
|
|
# Free function to clean up on removal.
|
|
def free(self):
|
|
print("Removing node ", self, ", Goodbye!")
|
|
|
|
# Additional buttons displayed on the node.
|
|
def draw_buttons(self, context, layout):
|
|
layout.label(text="Node settings")
|
|
layout.prop(self, "my_float_prop")
|
|
|
|
# Detail buttons in the sidebar.
|
|
# If this function is not defined, the draw_buttons function is used instead
|
|
def draw_buttons_ext(self, context, layout):
|
|
layout.prop(self, "my_float_prop")
|
|
# my_string_prop button will only be visible in the sidebar
|
|
layout.prop(self, "my_string_prop")
|
|
|
|
# Optional: custom label
|
|
# Explicit user label overrides this, but here we can define a label dynamically
|
|
def draw_label(self):
|
|
return "I am a custom node"
|
|
|
|
|
|
### Node Categories ###
|
|
# Node categories are a python system for automatically
|
|
# extending the Add menu, toolbar panels and search operator.
|
|
# For more examples see scripts/startup/nodeitems_builtins.py
|
|
|
|
import nodeitems_utils
|
|
from nodeitems_utils import NodeCategory, NodeItem
|
|
|
|
# our own base class with an appropriate poll function,
|
|
# so the categories only show up in our own tree type
|
|
|
|
|
|
class MyNodeCategory(NodeCategory):
|
|
@classmethod
|
|
def poll(cls, context):
|
|
return context.space_data.tree_type == 'CustomTreeType'
|
|
|
|
|
|
# all categories in a list
|
|
node_categories = [
|
|
# identifier, label, items list
|
|
MyNodeCategory('SOMENODES', "Some Nodes", items=[
|
|
# our basic node
|
|
NodeItem("CustomNodeType"),
|
|
]),
|
|
MyNodeCategory('OTHERNODES', "Other Nodes", items=[
|
|
# the node item can have additional settings,
|
|
# which are applied to new nodes
|
|
# NOTE: settings values are stored as string expressions,
|
|
# for this reason they should be converted to strings using repr()
|
|
NodeItem("CustomNodeType", label="Node A", settings={
|
|
"my_string_prop": repr("Lorem ipsum dolor sit amet"),
|
|
"my_float_prop": repr(1.0),
|
|
}),
|
|
NodeItem("CustomNodeType", label="Node B", settings={
|
|
"my_string_prop": repr("consectetur adipisicing elit"),
|
|
"my_float_prop": repr(2.0),
|
|
}),
|
|
]),
|
|
]
|
|
|
|
classes = (
|
|
MyCustomTree,
|
|
MyCustomSocket,
|
|
MyCustomInterfaceSocket,
|
|
MyCustomNode,
|
|
)
|
|
|
|
|
|
def register():
|
|
from bpy.utils import register_class
|
|
for cls in classes:
|
|
register_class(cls)
|
|
|
|
nodeitems_utils.register_node_categories('CUSTOM_NODES', node_categories)
|
|
|
|
|
|
def unregister():
|
|
nodeitems_utils.unregister_node_categories('CUSTOM_NODES')
|
|
|
|
from bpy.utils import unregister_class
|
|
for cls in reversed(classes):
|
|
unregister_class(cls)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
register()
|