griefith/test
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Node panels: RNA for node group interfaces

Browse Source 
Part 2/3 of #109135, #110272

Defines the RNA API for the new node tree interfaces.

The bulk of the RNA definition lives in `rna_node_tree_interface.cc`. The legacy socket interfaces remain in place and will be removed later.

Since the socket items share the `bNodeSocketValueXXX` structs with the `bNodeSocket` types they also use the same RNA. The `rna_def_node_socket_interface_subtypes` function is exposed so that when defining the interface RNA it can use the same code as the regular socket RNA.

Pull Request: https://projects.blender.org/blender/blender/pulls/110952
This commit is contained in:
Lukas Tönne
2023-08-21 15:40:19 +02:00
parent f052b18a65
commit ea3d85b9d7
8 changed files with 1802 additions and 135 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
source/blender/makesrna/RNA_enum_items.hh
View File

@@ -174,6 +174,8 @@ DEF_ENUM(rna_enum_navigation_mode_items)
DEF_ENUM(rna_enum_node_socket_in_out_items)
DEF_ENUM(rna_enum_node_socket_type_items)
DEF_ENUM(rna_enum_node_tree_interface_item_type_items)
DEF_ENUM(rna_enum_node_math_items)
DEF_ENUM(rna_enum_mapping_type_items)
DEF_ENUM(rna_enum_node_vec_math_items)

1
source/blender/makesrna/RNA_enum_types.hh
View File

@@ -46,6 +46,7 @@ const EnumPropertyItem *rna_node_tree_type_itemf(void *data,
bool (*poll)(void *data, struct bNodeTreeType *),
bool *r_free);
int rna_node_socket_idname_to_enum(const char *idname);
struct bNodeSocketType *rna_node_socket_type_from_enum(int value);
const EnumPropertyItem *rna_node_socket_type_itemf(
void *data, bool (*poll)(void *data, struct bNodeSocketType *), bool *r_free);

1
source/blender/makesrna/intern/CMakeLists.txt
View File

@@ -65,6 +65,7 @@ set(DEFSRC
rna_nla.cc
rna_nodetree.cc
rna_node_socket.cc
rna_node_tree_interface.cc
rna_object.cc
rna_object_force.cc
rna_packedfile.cc

1
source/blender/makesrna/intern/makesrna.cc
View File

@@ -4736,6 +4736,7 @@ static RNAProcessItem PROCESS_ITEMS[] = {
{"rna_nla.cc", nullptr, RNA_def_nla},
{"rna_nodetree.cc", nullptr, RNA_def_nodetree},
{"rna_node_socket.cc", nullptr, RNA_def_node_socket_subtypes},
{"rna_node_tree_interface.cc", nullptr, RNA_def_node_tree_interface},
{"rna_object.cc", "rna_object_api.cc", RNA_def_object},
{"rna_object_force.cc", nullptr, RNA_def_object_force},
{"rna_depsgraph.cc", nullptr, RNA_def_depsgraph},

4
source/blender/makesrna/intern/rna_internal.h
View File

@@ -175,6 +175,7 @@ void RNA_def_modifier(struct BlenderRNA *brna);
void RNA_def_nla(struct BlenderRNA *brna);
void RNA_def_nodetree(struct BlenderRNA *brna);
void RNA_def_node_socket_subtypes(struct BlenderRNA *brna);
void RNA_def_node_tree_interface(struct BlenderRNA *brna);
void RNA_def_object(struct BlenderRNA *brna);
void RNA_def_object_force(struct BlenderRNA *brna);
void RNA_def_packedfile(struct BlenderRNA *brna);
@@ -403,6 +404,9 @@ char *rna_TextureSlot_path(const struct PointerRNA *ptr);
char *rna_Node_ImageUser_path(const struct PointerRNA *ptr);
char *rna_CameraBackgroundImage_image_or_movieclip_user_path(const struct PointerRNA *ptr);
/* Node socket subtypes for group interface. */
void rna_def_node_socket_interface_subtypes(BlenderRNA *brna);
/* Set U.is_dirty and redraw. */
/**

867
source/blender/makesrna/intern/rna_node_socket.cc
View File

@@ -48,14 +48,12 @@ const EnumPropertyItem rna_enum_node_socket_type_items[] = {
# include "ED_node.hh"
extern "C" {
extern FunctionRNA rna_NodeSocket_draw_func;
extern FunctionRNA rna_NodeSocket_draw_color_func;
extern FunctionRNA rna_NodeSocketInterface_draw_func;
extern FunctionRNA rna_NodeSocketInterface_draw_color_func;
extern FunctionRNA rna_NodeSocketInterface_init_socket_func;
extern FunctionRNA rna_NodeSocketInterface_from_socket_func;
}
/* ******** Node Socket ******** */
@@ -558,8 +556,9 @@ static void rna_NodeSocketInterfaceStandard_draw_color(ID *id,
RNA_pointer_create(id, &RNA_NodeSocketInterface, sock, &ptr);
sock->typeinfo->interface_draw_color(C, &ptr, r_color);
}
/* ******** Node Socket Subtypes ******** */
static void rna_NodeSocketStandard_float_range(
void rna_NodeSocketStandard_float_range(
PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
{
bNodeSocket *sock = static_cast<bNodeSocket *>(ptr->data);
@@ -576,7 +575,7 @@ static void rna_NodeSocketStandard_float_range(
*softmax = dval->max;
}
static void rna_NodeSocketStandard_int_range(
void rna_NodeSocketStandard_int_range(
PointerRNA *ptr, int *min, int *max, int *softmin, int *softmax)
{
bNodeSocket *sock = static_cast<bNodeSocket *>(ptr->data);
@@ -593,7 +592,7 @@ static void rna_NodeSocketStandard_int_range(
*softmax = dval->max;
}
static void rna_NodeSocketStandard_vector_range(
void rna_NodeSocketStandard_vector_range(
PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
{
bNodeSocket *sock = static_cast<bNodeSocket *>(ptr->data);
@@ -623,8 +622,6 @@ static void rna_NodeSocketStandard_value_and_relation_update(bContext *C, Pointe
DEG_relations_tag_update(bmain);
}
/* ******** Node Socket Subtypes ******** */
bool rna_NodeSocketMaterial_default_value_poll(PointerRNA * /*ptr*/, PointerRNA value)
{
/* Do not show grease pencil materials for now. */
@@ -939,6 +936,93 @@ static void rna_def_node_socket_interface(BlenderRNA *brna)
RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
}
static void rna_def_node_socket_standard(BlenderRNA *brna)
{
/* XXX Workaround: Registered functions are not exposed in python by bpy,
* it expects them to be registered from python and use the native implementation.
* However, the standard socket types below are not registering these functions from python,
* so in order to call them in py scripts we need to overload and
* replace them with plain C callbacks.
* These types provide a usable basis for socket types defined in C.
*/
StructRNA *srna;
PropertyRNA *prop;
FunctionRNA *func;
PropertyRNA *parm;
static float default_draw_color[] = {0.0f, 0.0f, 0.0f, 1.0f};
srna = RNA_def_struct(brna, "NodeSocketStandard", "NodeSocket");
RNA_def_struct_sdna(srna, "bNodeSocket");
/* draw socket */
func = RNA_def_function(srna, "draw", "rna_NodeSocketStandard_draw");
RNA_def_function_flag(func, FUNC_USE_SELF_ID);
RNA_def_function_ui_description(func, "Draw socket");
parm = RNA_def_pointer(func, "context", "Context", "", "");
RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
parm = RNA_def_property(func, "layout", PROP_POINTER, PROP_NONE);
RNA_def_property_struct_type(parm, "UILayout");
RNA_def_property_ui_text(parm, "Layout", "Layout in the UI");
RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
parm = RNA_def_property(func, "node", PROP_POINTER, PROP_NONE);
RNA_def_property_struct_type(parm, "Node");
RNA_def_property_ui_text(parm, "Node", "Node the socket belongs to");
RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
parm = RNA_def_property(func, "text", PROP_STRING, PROP_NONE);
RNA_def_property_ui_text(parm, "Text", "Text label to draw alongside properties");
// RNA_def_property_string_default(parm, "");
RNA_def_parameter_flags(parm, PropertyFlag(0), PARM_REQUIRED);
func = RNA_def_function(srna, "draw_color", "rna_NodeSocketStandard_draw_color");
RNA_def_function_flag(func, FUNC_USE_SELF_ID);
RNA_def_function_ui_description(func, "Color of the socket icon");
parm = RNA_def_pointer(func, "context", "Context", "", "");
RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
parm = RNA_def_property(func, "node", PROP_POINTER, PROP_NONE);
RNA_def_property_struct_type(parm, "Node");
RNA_def_property_ui_text(parm, "Node", "Node the socket belongs to");
RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
parm = RNA_def_float_array(
func, "color", 4, default_draw_color, 0.0f, 1.0f, "Color", "", 0.0f, 1.0f);
RNA_def_function_output(func, parm);
/* Note: Legacy socket interface below.
* The new interface RNA is defined in a separate file,
* the NodeSocketInterface struct will be replaced. */
srna = RNA_def_struct(brna, "NodeSocketInterfaceStandard", "NodeSocketInterface");
RNA_def_struct_sdna(srna, "bNodeSocket");
/* for easier type comparison in python */
prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, nullptr, "typeinfo->type");
RNA_def_property_enum_items(prop, rna_enum_node_socket_type_items);
RNA_def_property_enum_default(prop, SOCK_FLOAT);
RNA_def_property_clear_flag(prop, PROP_EDITABLE);
RNA_def_property_ui_text(prop, "Type", "Data type");
func = RNA_def_function(srna, "draw", "rna_NodeSocketInterfaceStandard_draw");
RNA_def_function_flag(func, FUNC_USE_SELF_ID);
RNA_def_function_ui_description(func, "Draw template settings");
parm = RNA_def_pointer(func, "context", "Context", "", "");
RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
parm = RNA_def_property(func, "layout", PROP_POINTER, PROP_NONE);
RNA_def_property_struct_type(parm, "UILayout");
RNA_def_property_ui_text(parm, "Layout", "Layout in the UI");
RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
func = RNA_def_function(srna, "draw_color", "rna_NodeSocketInterfaceStandard_draw_color");
RNA_def_function_flag(func, FUNC_USE_SELF_ID);
RNA_def_function_ui_description(func, "Color of the socket icon");
parm = RNA_def_pointer(func, "context", "Context", "", "");
RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
parm = RNA_def_float_array(
func, "color", 4, default_draw_color, 0.0f, 1.0f, "Color", "", 0.0f, 1.0f);
RNA_def_function_output(func, parm);
}
static void rna_def_node_socket_float(BlenderRNA *brna,
const char *idname,
const char *interface_idname,
@@ -1525,167 +1609,684 @@ static void rna_def_node_socket_material(BlenderRNA *brna,
RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
}
static void rna_def_node_socket_standard_types(BlenderRNA *brna)
/* Common functions for all builtin socket interface types. */
static void rna_def_node_tree_interface_socket_builtin(StructRNA *srna)
{
/* XXX Workaround: Registered functions are not exposed in python by bpy,
* it expects them to be registered from python and use the native implementation.
* However, the standard socket types below are not registering these functions from python,
* so in order to call them in py scripts we need to overload and
* replace them with plain C callbacks.
* These types provide a usable basis for socket types defined in C.
FunctionRNA *func;
PropertyRNA *parm;
/* Override for functions, invoking the typeinfo callback directly
* instead of expecting an existing RNA registered function implementation.
*/
StructRNA *srna;
PropertyRNA *parm, *prop;
FunctionRNA *func;
static float default_draw_color[] = {0.0f, 0.0f, 0.0f, 1.0f};
srna = RNA_def_struct(brna, "NodeSocketStandard", "NodeSocket");
RNA_def_struct_sdna(srna, "bNodeSocket");
/* draw socket */
func = RNA_def_function(srna, "draw", "rna_NodeSocketStandard_draw");
func = RNA_def_function(srna, "draw", "rna_NodeTreeInterfaceSocket_draw_builtin");
RNA_def_function_flag(func, FUNC_USE_SELF_ID);
RNA_def_function_ui_description(func, "Draw socket");
RNA_def_function_ui_description(func, "Draw interface socket settings");
parm = RNA_def_pointer(func, "context", "Context", "", "");
RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
parm = RNA_def_property(func, "layout", PROP_POINTER, PROP_NONE);
RNA_def_property_struct_type(parm, "UILayout");
RNA_def_property_ui_text(parm, "Layout", "Layout in the UI");
RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
parm = RNA_def_property(func, "node", PROP_POINTER, PROP_NONE);
RNA_def_property_struct_type(parm, "Node");
RNA_def_property_ui_text(parm, "Node", "Node the socket belongs to");
RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
parm = RNA_def_property(func, "text", PROP_STRING, PROP_NONE);
RNA_def_property_ui_text(parm, "Text", "Text label to draw alongside properties");
// RNA_def_property_string_default(parm, "");
func = RNA_def_function(srna, "init_socket", "rna_NodeTreeInterfaceSocket_init_socket_builtin");
RNA_def_function_ui_description(func, "Initialize a node socket instance");
RNA_def_function_flag(func, FUNC_USE_SELF_ID | FUNC_ALLOW_WRITE);
parm = RNA_def_pointer(func, "node", "Node", "Node", "Node of the socket to initialize");
RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
parm = RNA_def_pointer(func, "socket", "NodeSocket", "Socket", "Socket to initialize");
RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
parm = RNA_def_string(
func, "data_path", nullptr, 0, "Data Path", "Path to specialized socket data");
RNA_def_parameter_flags(parm, PropertyFlag(0), PARM_REQUIRED);
func = RNA_def_function(srna, "draw_color", "rna_NodeSocketStandard_draw_color");
RNA_def_function_flag(func, FUNC_USE_SELF_ID);
RNA_def_function_ui_description(func, "Color of the socket icon");
parm = RNA_def_pointer(func, "context", "Context", "", "");
func = RNA_def_function(srna, "from_socket", "rna_NodeTreeInterfaceSocket_from_socket_builtin");
RNA_def_function_ui_description(func, "Setup template parameters from an existing socket");
RNA_def_function_flag(func, FUNC_USE_SELF_ID | FUNC_ALLOW_WRITE);
parm = RNA_def_pointer(func, "node", "Node", "Node", "Node of the original socket");
RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
parm = RNA_def_property(func, "node", PROP_POINTER, PROP_NONE);
RNA_def_property_struct_type(parm, "Node");
RNA_def_property_ui_text(parm, "Node", "Node the socket belongs to");
RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
parm = RNA_def_float_array(
func, "color", 4, default_draw_color, 0.0f, 1.0f, "Color", "", 0.0f, 1.0f);
RNA_def_function_output(func, parm);
srna = RNA_def_struct(brna, "NodeSocketInterfaceStandard", "NodeSocketInterface");
RNA_def_struct_sdna(srna, "bNodeSocket");
/* for easier type comparison in python */
prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, nullptr, "typeinfo->type");
RNA_def_property_enum_items(prop, rna_enum_node_socket_type_items);
RNA_def_property_enum_default(prop, SOCK_FLOAT);
RNA_def_property_clear_flag(prop, PROP_EDITABLE);
RNA_def_property_ui_text(prop, "Type", "Data type");
func = RNA_def_function(srna, "draw", "rna_NodeSocketInterfaceStandard_draw");
RNA_def_function_flag(func, FUNC_USE_SELF_ID);
RNA_def_function_ui_description(func, "Draw template settings");
parm = RNA_def_pointer(func, "context", "Context", "", "");
RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
parm = RNA_def_property(func, "layout", PROP_POINTER, PROP_NONE);
RNA_def_property_struct_type(parm, "UILayout");
RNA_def_property_ui_text(parm, "Layout", "Layout in the UI");
parm = RNA_def_pointer(func, "socket", "NodeSocket", "Socket", "Original socket");
RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
}
func = RNA_def_function(srna, "draw_color", "rna_NodeSocketInterfaceStandard_draw_color");
RNA_def_function_flag(func, FUNC_USE_SELF_ID);
RNA_def_function_ui_description(func, "Color of the socket icon");
parm = RNA_def_pointer(func, "context", "Context", "", "");
RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
parm = RNA_def_float_array(
func, "color", 4, default_draw_color, 0.0f, 1.0f, "Color", "", 0.0f, 1.0f);
RNA_def_function_output(func, parm);
static void rna_def_node_socket_interface_float(BlenderRNA *brna,
const char *identifier,
PropertySubType subtype)
{
StructRNA *srna;
PropertyRNA *prop;
float value_default;
/* XXX These types should eventually be registered at runtime.
* Then use the nodeStaticSocketType and nodeStaticSocketInterfaceType functions
* to get the idname strings from int type and subtype
* (see node_socket.cc, register_standard_node_socket_types).
*/
/* choose sensible common default based on subtype */
switch (subtype) {
case PROP_FACTOR:
value_default = 1.0f;
break;
case PROP_PERCENTAGE:
value_default = 100.0f;
break;
default:
value_default = 0.0f;
break;
}
rna_def_node_socket_float(brna, "NodeSocketFloat", "NodeSocketInterfaceFloat", PROP_NONE);
rna_def_node_socket_float(
brna, "NodeSocketFloatUnsigned", "NodeSocketInterfaceFloatUnsigned", PROP_UNSIGNED);
rna_def_node_socket_float(
brna, "NodeSocketFloatPercentage", "NodeSocketInterfaceFloatPercentage", PROP_PERCENTAGE);
rna_def_node_socket_float(
brna, "NodeSocketFloatFactor", "NodeSocketInterfaceFloatFactor", PROP_FACTOR);
rna_def_node_socket_float(
brna, "NodeSocketFloatAngle", "NodeSocketInterfaceFloatAngle", PROP_ANGLE);
rna_def_node_socket_float(
brna, "NodeSocketFloatTime", "NodeSocketInterfaceFloatTime", PROP_TIME);
rna_def_node_socket_float(brna,
"NodeSocketFloatTimeAbsolute",
"NodeSocketInterfaceFloatTimeAbsolute",
PROP_TIME_ABSOLUTE);
rna_def_node_socket_float(
brna, "NodeSocketFloatDistance", "NodeSocketInterfaceFloatDistance", PROP_DISTANCE);
srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
RNA_def_struct_ui_text(
srna, "Float Node Socket Interface", "Floating-point number socket of a node");
RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
rna_def_node_socket_int(brna, "NodeSocketInt", "NodeSocketInterfaceInt", PROP_NONE);
rna_def_node_socket_int(
brna, "NodeSocketIntUnsigned", "NodeSocketInterfaceIntUnsigned", PROP_UNSIGNED);
rna_def_node_socket_int(
brna, "NodeSocketIntPercentage", "NodeSocketInterfaceIntPercentage", PROP_PERCENTAGE);
rna_def_node_socket_int(
brna, "NodeSocketIntFactor", "NodeSocketInterfaceIntFactor", PROP_FACTOR);
RNA_def_struct_sdna_from(srna, "bNodeSocketValueFloat", "socket_data");
rna_def_node_socket_bool(brna, "NodeSocketBool", "NodeSocketInterfaceBool");
rna_def_node_socket_rotation(brna, "NodeSocketRotation", "NodeSocketInterfaceRotation");
prop = RNA_def_property(srna, "default_value", PROP_FLOAT, subtype);
RNA_def_property_float_sdna(prop, nullptr, "value");
RNA_def_property_float_default(prop, value_default);
RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
RNA_def_property_float_funcs(
prop, nullptr, nullptr, "rna_NodeTreeInterfaceSocketFloat_default_value_range");
RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceSocket_value_update");
rna_def_node_socket_vector(brna, "NodeSocketVector", "NodeSocketInterfaceVector", PROP_NONE);
rna_def_node_socket_vector(brna,
"NodeSocketVectorTranslation",
"NodeSocketInterfaceVectorTranslation",
PROP_TRANSLATION);
rna_def_node_socket_vector(
brna, "NodeSocketVectorDirection", "NodeSocketInterfaceVectorDirection", PROP_DIRECTION);
rna_def_node_socket_vector(
brna, "NodeSocketVectorVelocity", "NodeSocketInterfaceVectorVelocity", PROP_VELOCITY);
rna_def_node_socket_vector(brna,
"NodeSocketVectorAcceleration",
"NodeSocketInterfaceVectorAcceleration",
PROP_ACCELERATION);
rna_def_node_socket_vector(
brna, "NodeSocketVectorEuler", "NodeSocketInterfaceVectorEuler", PROP_EULER);
rna_def_node_socket_vector(
brna, "NodeSocketVectorXYZ", "NodeSocketInterfaceVectorXYZ", PROP_XYZ);
prop = RNA_def_property(srna, "min_value", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_sdna(prop, nullptr, "min");
RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
RNA_def_property_ui_text(prop, "Minimum Value", "Minimum value");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceSocket_value_update");
rna_def_node_socket_color(brna, "NodeSocketColor", "NodeSocketInterfaceColor");
prop = RNA_def_property(srna, "max_value", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_sdna(prop, nullptr, "max");
RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
RNA_def_property_ui_text(prop, "Maximum Value", "Maximum value");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceSocket_value_update");
rna_def_node_socket_string(brna, "NodeSocketString", "NodeSocketInterfaceString");
RNA_def_struct_sdna_from(srna, "bNodeTreeInterfaceSocket", nullptr);
rna_def_node_socket_shader(brna, "NodeSocketShader", "NodeSocketInterfaceShader");
rna_def_node_tree_interface_socket_builtin(srna);
}
static void rna_def_node_socket_interface_int(BlenderRNA *brna,
const char *identifier,
PropertySubType subtype)
{
StructRNA *srna;
PropertyRNA *prop;
srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
RNA_def_struct_ui_text(srna, "Integer Node Socket Interface", "Integer number socket of a node");
RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
RNA_def_struct_sdna_from(srna, "bNodeSocketValueInt", "socket_data");
prop = RNA_def_property(srna, "default_value", PROP_INT, subtype);
RNA_def_property_int_sdna(prop, nullptr, "value");
RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
RNA_def_property_int_funcs(
prop, nullptr, nullptr, "rna_NodeTreeInterfaceSocketInt_default_value_range");
RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceSocket_value_update");
prop = RNA_def_property(srna, "min_value", PROP_INT, PROP_NONE);
RNA_def_property_int_sdna(prop, nullptr, "min");
RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
RNA_def_property_ui_text(prop, "Minimum Value", "Minimum value");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceSocket_value_update");
prop = RNA_def_property(srna, "max_value", PROP_INT, PROP_NONE);
RNA_def_property_int_sdna(prop, nullptr, "max");
RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
RNA_def_property_ui_text(prop, "Maximum Value", "Maximum value");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceSocket_value_update");
RNA_def_struct_sdna_from(srna, "bNodeTreeInterfaceSocket", nullptr);
rna_def_node_tree_interface_socket_builtin(srna);
}
static void rna_def_node_socket_interface_bool(BlenderRNA *brna, const char *identifier)
{
StructRNA *srna;
PropertyRNA *prop;
srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
RNA_def_struct_ui_text(srna, "Boolean Node Socket Interface", "Boolean value socket of a node");
RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
RNA_def_struct_sdna_from(srna, "bNodeSocketValueBoolean", "socket_data");
prop = RNA_def_property(srna, "default_value", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, nullptr, "value", 1);
RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceSocket_value_update");
RNA_def_struct_sdna_from(srna, "bNodeTreeInterfaceSocket", nullptr);
rna_def_node_tree_interface_socket_builtin(srna);
}
static void rna_def_node_socket_interface_rotation(BlenderRNA *brna, const char *identifier)
{
StructRNA *srna;
PropertyRNA *prop;
srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
RNA_def_struct_ui_text(
srna, "Rotation Node Socket Interface", "Rotation value socket of a node");
RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
RNA_def_struct_sdna_from(srna, "bNodeSocketValueRotation", "socket_data");
prop = RNA_def_property(srna, "default_value", PROP_FLOAT, PROP_EULER);
RNA_def_property_float_sdna(prop, nullptr, "value_euler");
RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceSocket_value_update");
RNA_def_struct_sdna_from(srna, "bNodeTreeInterfaceSocket", nullptr);
rna_def_node_tree_interface_socket_builtin(srna);
}
static void rna_def_node_socket_interface_vector(BlenderRNA *brna,
const char *identifier,
PropertySubType subtype)
{
StructRNA *srna;
PropertyRNA *prop;
srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
RNA_def_struct_ui_text(srna, "Vector Node Socket Interface", "3D vector socket of a node");
RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
RNA_def_struct_sdna_from(srna, "bNodeSocketValueVector", "socket_data");
prop = RNA_def_property(srna, "default_value", PROP_FLOAT, subtype);
RNA_def_property_float_sdna(prop, nullptr, "value");
RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
RNA_def_property_float_funcs(
prop, nullptr, nullptr, "rna_NodeTreeInterfaceSocketVector_default_value_range");
RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceSocket_value_update");
prop = RNA_def_property(srna, "min_value", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_sdna(prop, nullptr, "min");
RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
RNA_def_property_ui_text(prop, "Minimum Value", "Minimum value");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceSocket_value_update");
prop = RNA_def_property(srna, "max_value", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_sdna(prop, nullptr, "max");
RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
RNA_def_property_ui_text(prop, "Maximum Value", "Maximum value");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceSocket_value_update");
RNA_def_struct_sdna_from(srna, "bNodeTreeInterfaceSocket", nullptr);
rna_def_node_tree_interface_socket_builtin(srna);
}
static void rna_def_node_socket_interface_color(BlenderRNA *brna, const char *identifier)
{
StructRNA *srna;
PropertyRNA *prop;
srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
RNA_def_struct_ui_text(srna, "Color Node Socket Interface", "RGBA color socket of a node");
RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
RNA_def_struct_sdna_from(srna, "bNodeSocketValueRGBA", "socket_data");
prop = RNA_def_property(srna, "default_value", PROP_FLOAT, PROP_COLOR);
RNA_def_property_float_sdna(prop, nullptr, "value");
RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceSocket_value_update");
RNA_def_struct_sdna_from(srna, "bNodeTreeInterfaceSocket", nullptr);
rna_def_node_tree_interface_socket_builtin(srna);
}
static void rna_def_node_socket_interface_string(BlenderRNA *brna, const char *identifier)
{
StructRNA *srna;
PropertyRNA *prop;
srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
RNA_def_struct_ui_text(srna, "String Node Socket Interface", "String socket of a node");
RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
RNA_def_struct_sdna_from(srna, "bNodeSocketValueString", "socket_data");
prop = RNA_def_property(srna, "default_value", PROP_STRING, PROP_NONE);
RNA_def_property_string_sdna(prop, nullptr, "value");
RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceSocket_value_update");
RNA_def_struct_sdna_from(srna, "bNodeTreeInterfaceSocket", nullptr);
rna_def_node_tree_interface_socket_builtin(srna);
}
static void rna_def_node_socket_interface_shader(BlenderRNA *brna, const char *identifier)
{
StructRNA *srna;
srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
RNA_def_struct_ui_text(srna, "Shader Node Socket Interface", "Shader socket of a node");
RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
rna_def_node_tree_interface_socket_builtin(srna);
}
static void rna_def_node_socket_interface_object(BlenderRNA *brna, const char *identifier)
{
StructRNA *srna;
PropertyRNA *prop;
srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
RNA_def_struct_ui_text(srna, "Object Node Socket Interface", "Object socket of a node");
RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
RNA_def_struct_sdna_from(srna, "bNodeSocketValueObject", "socket_data");
prop = RNA_def_property(srna, "default_value", PROP_POINTER, PROP_NONE);
RNA_def_property_pointer_sdna(prop, nullptr, "value");
RNA_def_property_struct_type(prop, "Object");
RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceSocket_value_update");
RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_REFCOUNT);
RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
rna_def_node_tree_interface_socket_builtin(srna);
}
static void rna_def_node_socket_interface_image(BlenderRNA *brna, const char *identifier)
{
StructRNA *srna;
PropertyRNA *prop;
srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
RNA_def_struct_ui_text(srna, "Image Node Socket Interface", "Image socket of a node");
RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
RNA_def_struct_sdna_from(srna, "bNodeSocketValueImage", "socket_data");
prop = RNA_def_property(srna, "default_value", PROP_POINTER, PROP_NONE);
RNA_def_property_pointer_sdna(prop, nullptr, "value");
RNA_def_property_struct_type(prop, "Image");
RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceSocket_value_update");
RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_REFCOUNT);
RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
rna_def_node_tree_interface_socket_builtin(srna);
}
static void rna_def_node_socket_interface_geometry(BlenderRNA *brna, const char *identifier)
{
StructRNA *srna;
srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
RNA_def_struct_ui_text(srna, "Geometry Node Socket Interface", "Geometry socket of a node");
RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
rna_def_node_tree_interface_socket_builtin(srna);
}
static void rna_def_node_socket_interface_collection(BlenderRNA *brna, const char *identifier)
{
StructRNA *srna;
PropertyRNA *prop;
srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
RNA_def_struct_ui_text(srna, "Collection Node Socket Interface", "Collection socket of a node");
RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
RNA_def_struct_sdna_from(srna, "bNodeSocketValueCollection", "socket_data");
prop = RNA_def_property(srna, "default_value", PROP_POINTER, PROP_NONE);
RNA_def_property_pointer_sdna(prop, nullptr, "value");
RNA_def_property_struct_type(prop, "Collection");
RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceSocket_value_update");
RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_REFCOUNT);
RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
rna_def_node_tree_interface_socket_builtin(srna);
}
static void rna_def_node_socket_interface_texture(BlenderRNA *brna, const char *identifier)
{
StructRNA *srna;
PropertyRNA *prop;
srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
RNA_def_struct_ui_text(srna, "Texture Node Socket Interface", "Texture socket of a node");
RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
RNA_def_struct_sdna_from(srna, "bNodeSocketValueTexture", "socket_data");
prop = RNA_def_property(srna, "default_value", PROP_POINTER, PROP_NONE);
RNA_def_property_pointer_sdna(prop, nullptr, "value");
RNA_def_property_struct_type(prop, "Texture");
RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceSocket_value_update");
RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_REFCOUNT);
RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
rna_def_node_tree_interface_socket_builtin(srna);
}
static void rna_def_node_socket_interface_material(BlenderRNA *brna, const char *identifier)
{
StructRNA *srna;
PropertyRNA *prop;
srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
RNA_def_struct_ui_text(srna, "Material Node Socket Interface", "Material socket of a node");
RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
RNA_def_struct_sdna_from(srna, "bNodeSocketValueMaterial", "socket_data");
prop = RNA_def_property(srna, "default_value", PROP_POINTER, PROP_NONE);
RNA_def_property_pointer_sdna(prop, nullptr, "value");
RNA_def_property_struct_type(prop, "Material");
RNA_def_property_pointer_funcs(
prop, nullptr, nullptr, nullptr, "rna_NodeTreeInterfaceSocketMaterial_default_value_poll");
RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceSocket_value_update");
RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_REFCOUNT);
RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
rna_def_node_tree_interface_socket_builtin(srna);
}
/* Info for generating static subtypes. */
struct bNodeSocketStaticTypeInfo {
const char *socket_identifier;
const char *interface_identifier_legacy;
const char *interface_identifier;
eNodeSocketDatatype type;
PropertySubType subtype;
const char *label;
};
/* Note: Socket and interface subtypes could be defined from a single central list,
* but makesrna cannot have a dependency on BKE, so this list would have to live in RNA itself,
* with BKE etc. accessing the RNA API to get the subtypes info. */
static const bNodeSocketStaticTypeInfo node_socket_subtypes[] = {
{"NodeSocketFloat",
"NodeSocketInterfaceFloat",
"NodeTreeInterfaceSocketFloat",
SOCK_FLOAT,
PROP_NONE},
{"NodeSocketFloatUnsigned",
"NodeSocketInterfaceFloatUnsigned",
"NodeTreeInterfaceSocketFloatUnsigned",
SOCK_FLOAT,
PROP_UNSIGNED},
{"NodeSocketFloatPercentage",
"NodeSocketInterfaceFloatPercentage",
"NodeTreeInterfaceSocketFloatPercentage",
SOCK_FLOAT,
PROP_PERCENTAGE},
{"NodeSocketFloatFactor",
"NodeSocketInterfaceFloatFactor",
"NodeTreeInterfaceSocketFloatFactor",
SOCK_FLOAT,
PROP_FACTOR},
{"NodeSocketFloatAngle",
"NodeSocketInterfaceFloatAngle",
"NodeTreeInterfaceSocketFloatAngle",
SOCK_FLOAT,
PROP_ANGLE},
{"NodeSocketFloatTime",
"NodeSocketInterfaceFloatTime",
"NodeTreeInterfaceSocketFloatTime",
SOCK_FLOAT,
PROP_TIME},
{"NodeSocketFloatTimeAbsolute",
"NodeSocketInterfaceFloatTimeAbsolute",
"NodeTreeInterfaceSocketFloatTimeAbsolute",
SOCK_FLOAT,
PROP_TIME_ABSOLUTE},
{"NodeSocketFloatDistance",
"NodeSocketInterfaceFloatDistance",
"NodeTreeInterfaceSocketFloatDistance",
SOCK_FLOAT,
PROP_DISTANCE},
{"NodeSocketInt", "NodeSocketInterfaceInt", "NodeTreeInterfaceSocketInt", SOCK_INT, PROP_NONE},
{"NodeSocketIntUnsigned",
"NodeSocketInterfaceIntUnsigned",
"NodeTreeInterfaceSocketIntUnsigned",
SOCK_INT,
PROP_UNSIGNED},
{"NodeSocketIntPercentage",
"NodeSocketInterfaceIntPercentage",
"NodeTreeInterfaceSocketIntPercentage",
SOCK_INT,
PROP_PERCENTAGE},
{"NodeSocketIntFactor",
"NodeSocketInterfaceIntFactor",
"NodeTreeInterfaceSocketIntFactor",
SOCK_INT,
PROP_FACTOR},
{"NodeSocketBool",
"NodeSocketInterfaceBool",
"NodeTreeInterfaceSocketBool",
SOCK_BOOLEAN,
PROP_NONE},
{"NodeSocketRotation",
"NodeSocketInterfaceRotation",
"NodeTreeInterfaceSocketRotation",
SOCK_ROTATION,
PROP_NONE},
{"NodeSocketVector",
"NodeSocketInterfaceVector",
"NodeTreeInterfaceSocketVector",
SOCK_VECTOR,
PROP_NONE},
{"NodeSocketVectorTranslation",
"NodeSocketInterfaceVectorTranslation",
"NodeTreeInterfaceSocketVectorTranslation",
SOCK_VECTOR,
PROP_TRANSLATION},
{"NodeSocketVectorDirection",
"NodeSocketInterfaceVectorDirection",
"NodeTreeInterfaceSocketVectorDirection",
SOCK_VECTOR,
PROP_DIRECTION},
{"NodeSocketVectorVelocity",
"NodeSocketInterfaceVectorVelocity",
"NodeTreeInterfaceSocketVectorVelocity",
SOCK_VECTOR,
PROP_VELOCITY},
{"NodeSocketVectorAcceleration",
"NodeSocketInterfaceVectorAcceleration",
"NodeTreeInterfaceSocketVectorAcceleration",
SOCK_VECTOR,
PROP_ACCELERATION},
{"NodeSocketVectorEuler",
"NodeSocketInterfaceVectorEuler",
"NodeTreeInterfaceSocketVectorEuler",
SOCK_VECTOR,
PROP_EULER},
{"NodeSocketVectorXYZ",
"NodeSocketInterfaceVectorXYZ",
"NodeTreeInterfaceSocketVectorXYZ",
SOCK_VECTOR,
PROP_XYZ},
{"NodeSocketColor",
"NodeSocketInterfaceColor",
"NodeTreeInterfaceSocketColor",
SOCK_RGBA,
PROP_NONE},
{"NodeSocketString",
"NodeSocketInterfaceString",
"NodeTreeInterfaceSocketString",
SOCK_STRING,
PROP_NONE},
{"NodeSocketShader",
"NodeSocketInterfaceShader",
"NodeTreeInterfaceSocketShader",
SOCK_SHADER,
PROP_NONE},
{"NodeSocketObject",
"NodeSocketInterfaceObject",
"NodeTreeInterfaceSocketObject",
SOCK_OBJECT,
PROP_NONE},
{"NodeSocketImage",
"NodeSocketInterfaceImage",
"NodeTreeInterfaceSocketImage",
SOCK_IMAGE,
PROP_NONE},
{"NodeSocketGeometry",
"NodeSocketInterfaceGeometry",
"NodeTreeInterfaceSocketGeometry",
SOCK_GEOMETRY,
PROP_NONE},
{"NodeSocketCollection",
"NodeSocketInterfaceCollection",
"NodeTreeInterfaceSocketCollection",
SOCK_COLLECTION,
PROP_NONE},
{"NodeSocketTexture",
"NodeSocketInterfaceTexture",
"NodeTreeInterfaceSocketTexture",
SOCK_TEXTURE,
PROP_NONE},
{"NodeSocketMaterial",
"NodeSocketInterfaceMaterial",
"NodeTreeInterfaceSocketMaterial",
SOCK_MATERIAL,
PROP_NONE},
};
static void rna_def_node_socket_subtypes(BlenderRNA *brna)
{
for (const bNodeSocketStaticTypeInfo &info : node_socket_subtypes) {
const char *identifier = info.socket_identifier;
const char *interface_identifier = info.interface_identifier_legacy;
switch (info.type) {
case SOCK_FLOAT:
rna_def_node_socket_float(brna, identifier, interface_identifier, info.subtype);
break;
case SOCK_INT:
rna_def_node_socket_int(brna, identifier, interface_identifier, info.subtype);
break;
case SOCK_BOOLEAN:
rna_def_node_socket_bool(brna, identifier, interface_identifier);
break;
case SOCK_ROTATION:
rna_def_node_socket_rotation(brna, identifier, interface_identifier);
break;
case SOCK_VECTOR:
rna_def_node_socket_vector(brna, identifier, interface_identifier, info.subtype);
break;
case SOCK_RGBA:
rna_def_node_socket_color(brna, identifier, interface_identifier);
break;
case SOCK_STRING:
rna_def_node_socket_string(brna, identifier, interface_identifier);
break;
case SOCK_SHADER:
rna_def_node_socket_shader(brna, identifier, interface_identifier);
break;
case SOCK_OBJECT:
rna_def_node_socket_object(brna, identifier, interface_identifier);
break;
case SOCK_IMAGE:
rna_def_node_socket_image(brna, identifier, interface_identifier);
break;
case SOCK_GEOMETRY:
rna_def_node_socket_geometry(brna, identifier, interface_identifier);
break;
case SOCK_COLLECTION:
rna_def_node_socket_collection(brna, identifier, interface_identifier);
break;
case SOCK_TEXTURE:
rna_def_node_socket_texture(brna, identifier, interface_identifier);
break;
case SOCK_MATERIAL:
rna_def_node_socket_material(brna, identifier, interface_identifier);
break;
case SOCK_CUSTOM:
break;
}
}
rna_def_node_socket_virtual(brna, "NodeSocketVirtual");
}
rna_def_node_socket_object(brna, "NodeSocketObject", "NodeSocketInterfaceObject");
/* Note: interface items are defined outside this file.
* The subtypes must be defined after the base type, so this function
* is called from the interface rna file to ensure correct order. */
void rna_def_node_socket_interface_subtypes(BlenderRNA *brna)
{
for (const bNodeSocketStaticTypeInfo &info : node_socket_subtypes) {
const char *identifier = info.interface_identifier;
rna_def_node_socket_image(brna, "NodeSocketImage", "NodeSocketInterfaceImage");
switch (info.type) {
case SOCK_FLOAT:
rna_def_node_socket_interface_float(brna, identifier, info.subtype);
break;
case SOCK_INT:
rna_def_node_socket_interface_int(brna, identifier, info.subtype);
break;
case SOCK_BOOLEAN:
rna_def_node_socket_interface_bool(brna, identifier);
break;
case SOCK_ROTATION:
rna_def_node_socket_interface_rotation(brna, identifier);
break;
case SOCK_VECTOR:
rna_def_node_socket_interface_vector(brna, identifier, info.subtype);
break;
case SOCK_RGBA:
rna_def_node_socket_interface_color(brna, identifier);
break;
case SOCK_STRING:
rna_def_node_socket_interface_string(brna, identifier);
break;
case SOCK_SHADER:
rna_def_node_socket_interface_shader(brna, identifier);
break;
case SOCK_OBJECT:
rna_def_node_socket_interface_object(brna, identifier);
break;
case SOCK_IMAGE:
rna_def_node_socket_interface_image(brna, identifier);
break;
case SOCK_GEOMETRY:
rna_def_node_socket_interface_geometry(brna, identifier);
break;
case SOCK_COLLECTION:
rna_def_node_socket_interface_collection(brna, identifier);
break;
case SOCK_TEXTURE:
rna_def_node_socket_interface_texture(brna, identifier);
break;
case SOCK_MATERIAL:
rna_def_node_socket_interface_material(brna, identifier);
break;
rna_def_node_socket_geometry(brna, "NodeSocketGeometry", "NodeSocketInterfaceGeometry");
rna_def_node_socket_collection(brna, "NodeSocketCollection", "NodeSocketInterfaceCollection");
rna_def_node_socket_texture(brna, "NodeSocketTexture", "NodeSocketInterfaceTexture");
rna_def_node_socket_material(brna, "NodeSocketMaterial", "NodeSocketInterfaceMaterial");
case SOCK_CUSTOM:
break;
}
}
}
void RNA_def_node_socket_subtypes(BlenderRNA *brna)
{
rna_def_node_socket(brna);
rna_def_node_socket_interface(brna);
rna_def_node_socket_standard(brna);
rna_def_node_socket_standard_types(brna);
rna_def_node_socket_subtypes(brna);
}
#endif

1045
source/blender/makesrna/intern/rna_node_tree_interface.cc Normal file
View File

@@ -0,0 +1,1045 @@
/* SPDX-FileCopyrightText: 2023 Blender Foundation
*
* SPDX-License-Identifier: GPL-2.0-or-later */
/** \file
* \ingroup RNA
*/
#include "DNA_node_tree_interface_types.h"
#include "RNA_define.hh"
#include "RNA_enum_types.hh"
#include "RNA_types.hh"
#include "rna_internal.h"
#include "WM_types.hh"
const EnumPropertyItem rna_enum_node_tree_interface_item_type_items[] = {
{NODE_INTERFACE_SOCKET, "SOCKET", 0, "Socket", ""},
{NODE_INTERFACE_PANEL, "PANEL", 0, "Panel", ""},
{0, nullptr, 0, nullptr, nullptr}};
#ifdef RNA_RUNTIME
# include "BKE_node.h"
# include "BKE_node_runtime.hh"
# include "BKE_node_tree_interface.hh"
# include "BKE_node_tree_update.h"
# include "DNA_material_types.h"
# include "ED_node.hh"
# include "WM_api.hh"
/* Internal RNA function declarations, used to invoke registered callbacks. */
extern FunctionRNA rna_NodeTreeInterfaceSocket_draw_func;
extern FunctionRNA rna_NodeTreeInterfaceSocket_init_socket_func;
extern FunctionRNA rna_NodeTreeInterfaceSocket_from_socket_func;
namespace node_interface = blender::bke::node_interface;
static void rna_NodeTreeInterfaceItem_update(Main *bmain, Scene * /*scene*/, PointerRNA *ptr)
{
bNodeTree *ntree = reinterpret_cast<bNodeTree *>(ptr->owner_id);
BKE_ntree_update_tag_interface(ntree);
ED_node_tree_propagate_change(nullptr, bmain, ntree);
}
static StructRNA *rna_NodeTreeInterfaceItem_refine(PointerRNA *ptr)
{
bNodeTreeInterfaceItem *item = static_cast<bNodeTreeInterfaceItem *>(ptr->data);
switch (item->item_type) {
case NODE_INTERFACE_SOCKET: {
bNodeTreeInterfaceSocket &socket = node_interface::get_item_as<bNodeTreeInterfaceSocket>(
*item);
bNodeSocketType *socket_typeinfo = nodeSocketTypeFind(socket.socket_type);
if (socket_typeinfo && socket_typeinfo->ext_interface.srna) {
return socket_typeinfo->ext_interface.srna;
}
return &RNA_NodeTreeInterfaceSocket;
}
case NODE_INTERFACE_PANEL:
return &RNA_NodeTreeInterfacePanel;
default:
return &RNA_NodeTreeInterfaceItem;
}
}
static char *rna_NodeTreeInterfaceItem_path(const PointerRNA *ptr)
{
bNodeTree *ntree = reinterpret_cast<bNodeTree *>(ptr->owner_id);
const bNodeTreeInterfaceItem *item = static_cast<const bNodeTreeInterfaceItem *>(ptr->data);
if (!ntree->runtime) {
return nullptr;
}
ntree->ensure_topology_cache();
UNUSED_VARS(item);
// Note: New API, will be enabled after new interface cache is added.
// const blender::bke::bNodeTreeInterfaceCache &cache = ntree->interface_cache();
// for (const int index : cache.items.index_range()) {
// if (cache.items[index] == item) {
// return BLI_sprintfN("interface.ui_items[%d]", index);
// }
// }
return nullptr;
}
static bool rna_NodeTreeInterfaceSocket_unregister(Main * /*bmain*/, StructRNA *type)
{
bNodeSocketType *st = static_cast<bNodeSocketType *>(RNA_struct_blender_type_get(type));
if (!st) {
return false;
}
RNA_struct_free_extension(type, &st->ext_interface);
RNA_struct_free(&BLENDER_RNA, type);
/* update while blender is running */
WM_main_add_notifier(NC_NODE | NA_EDITED, nullptr);
return true;
}
static void rna_NodeTreeInterfaceSocket_draw_builtin(ID *id,
bNodeTreeInterfaceSocket *interface_socket,
bContext *C,
uiLayout *layout)
{
bNodeSocketType *typeinfo = interface_socket->socket_typeinfo();
if (typeinfo && typeinfo->interface_draw) {
UNUSED_VARS(id, C, layout);
// Note: New API, will be enabled after typeinfo callbacks change.
// typeinfo->interface_draw(id, interface_socket, C, layout);
}
}
// Note: New API, interface draw callback used after changing callbacks.
static void UNUSED_FUNCTION(rna_NodeTreeInterfaceSocket_draw_custom)(
ID *id, bNodeTreeInterfaceSocket *interface_socket, bContext *C, uiLayout *layout)
{
bNodeSocketType *typeinfo = nodeSocketTypeFind(interface_socket->socket_type);
if (typeinfo == nullptr) {
return;
}
PointerRNA ptr;
RNA_pointer_create(id, &RNA_NodeTreeInterfaceSocket, interface_socket, &ptr);
FunctionRNA *func = &rna_NodeTreeInterfaceSocket_draw_func;
ParameterList list;
RNA_parameter_list_create(&list, &ptr, func);
RNA_parameter_set_lookup(&list, "context", &C);
RNA_parameter_set_lookup(&list, "layout", &layout);
typeinfo->ext_interface.call(C, &ptr, func, &list);
RNA_parameter_list_free(&list);
}
static void rna_NodeTreeInterfaceSocket_init_socket_builtin(
ID *id,
bNodeTreeInterfaceSocket *interface_socket,
bNode *node,
bNodeSocket *socket,
const char *data_path)
{
bNodeSocketType *typeinfo = interface_socket->socket_typeinfo();
if (typeinfo && typeinfo->interface_draw) {
// Note: New API, callback signatures change.
UNUSED_VARS(id, node, socket, data_path);
// typeinfo->interface_init_socket(id, interface_socket, node, socket, data_path);
}
}
// Note: New API, used when callbacks change.
static void UNUSED_FUNCTION(rna_NodeTreeInterfaceSocket_init_socket_custom)(
ID *id,
const bNodeTreeInterfaceSocket *interface_socket,
bNode *node,
bNodeSocket *socket,
const char *data_path)
{
bNodeSocketType *typeinfo = nodeSocketTypeFind(interface_socket->socket_type);
if (typeinfo == nullptr) {
return;
}
PointerRNA ptr, node_ptr, socket_ptr;
RNA_pointer_create(id,
&RNA_NodeTreeInterfaceSocket,
const_cast<bNodeTreeInterfaceSocket *>(interface_socket),
&ptr);
RNA_pointer_create(id, &RNA_Node, node, &node_ptr);
RNA_pointer_create(id, &RNA_NodeSocket, socket, &socket_ptr);
FunctionRNA *func = &rna_NodeTreeInterfaceSocket_init_socket_func;
ParameterList list;
RNA_parameter_list_create(&list, &ptr, func);
RNA_parameter_set_lookup(&list, "node", &node_ptr);
RNA_parameter_set_lookup(&list, "socket", &socket_ptr);
RNA_parameter_set_lookup(&list, "data_path", &data_path);
typeinfo->ext_interface.call(nullptr, &ptr, func, &list);
RNA_parameter_list_free(&list);
}
static void rna_NodeTreeInterfaceSocket_from_socket_builtin(
ID *id, bNodeTreeInterfaceSocket *interface_socket, bNode *node, bNodeSocket *socket)
{
bNodeSocketType *typeinfo = interface_socket->socket_typeinfo();
if (typeinfo && typeinfo->interface_draw) {
// Note: New API, callback signatures change.
UNUSED_VARS(id, node, socket);
// typeinfo->interface_from_socket(id, interface_socket, node, socket);
}
}
// Note: New API, used after callback signatures change.
static void UNUSED_FUNCTION(rna_NodeTreeInterfaceSocket_from_socket_custom)(
ID *id,
bNodeTreeInterfaceSocket *interface_socket,
const bNode *node,
const bNodeSocket *socket)
{
bNodeSocketType *typeinfo = nodeSocketTypeFind(interface_socket->socket_type);
if (typeinfo == nullptr) {
return;
}
PointerRNA ptr, node_ptr, socket_ptr;
RNA_pointer_create(id, &RNA_NodeTreeInterfaceSocket, interface_socket, &ptr);
RNA_pointer_create(id, &RNA_Node, const_cast<bNode *>(node), &node_ptr);
RNA_pointer_create(id, &RNA_NodeSocket, const_cast<bNodeSocket *>(socket), &socket_ptr);
FunctionRNA *func = &rna_NodeTreeInterfaceSocket_from_socket_func;
ParameterList list;
RNA_parameter_list_create(&list, &ptr, func);
RNA_parameter_set_lookup(&list, "node", &node_ptr);
RNA_parameter_set_lookup(&list, "socket", &socket_ptr);
typeinfo->ext_interface.call(nullptr, &ptr, func, &list);
RNA_parameter_list_free(&list);
}
static StructRNA *rna_NodeTreeInterfaceSocket_register(Main * /*bmain*/,
ReportList * /*reports*/,
void *data,
const char *identifier,
StructValidateFunc validate,
StructCallbackFunc call,
StructFreeFunc free)
{
bNodeTreeInterfaceSocket dummy_socket;
memset(&dummy_socket, 0, sizeof(bNodeTreeInterfaceSocket));
/* Set #item_type so that refining the type ends up with RNA_NodeTreeInterfaceSocket. */
dummy_socket.item.item_type = NODE_INTERFACE_SOCKET;
PointerRNA dummy_socket_ptr;
RNA_pointer_create(nullptr, &RNA_NodeTreeInterfaceSocket, &dummy_socket, &dummy_socket_ptr);
/* Validate the python class. */
bool have_function[3];
if (validate(&dummy_socket_ptr, data, have_function) != 0) {
return nullptr;
}
/* Check if we have registered this socket type before. */
bNodeSocketType *st = nodeSocketTypeFind(dummy_socket.socket_type);
if (st) {
/* Socket type registered before. */
}
else {
/* Create a new node socket type. */
st = MEM_cnew<bNodeSocketType>(__func__);
BLI_strncpy(st->idname, dummy_socket.socket_type, sizeof(st->idname));
nodeRegisterSocketType(st);
}
st->free_self = (void (*)(bNodeSocketType * stype)) MEM_freeN;
/* if RNA type is already registered, unregister first */
if (st->ext_interface.srna) {
StructRNA *srna = st->ext_interface.srna;
RNA_struct_free_extension(srna, &st->ext_interface);
RNA_struct_free(&BLENDER_RNA, srna);
}
st->ext_interface.srna = RNA_def_struct_ptr(
&BLENDER_RNA, identifier, &RNA_NodeTreeInterfaceSocket);
st->ext_interface.data = data;
st->ext_interface.call = call;
st->ext_interface.free = free;
RNA_struct_blender_type_set(st->ext_interface.srna, st);
// Note: New API callbacks.
// st->interface_draw = (have_function[0]) ? rna_NodeTreeInterfaceSocket_draw_custom : nullptr;
// st->interface_init_socket = (have_function[1]) ?
// rna_NodeTreeInterfaceSocket_init_socket_custom :
// nullptr;
// st->interface_from_socket = (have_function[2]) ?
// rna_NodeTreeInterfaceSocket_from_socket_custom :
// nullptr;
/* Cleanup local dummy type. */
MEM_SAFE_FREE(dummy_socket.socket_type);
/* Update while blender is running */
WM_main_add_notifier(NC_NODE | NA_EDITED, nullptr);
return st->ext_interface.srna;
}
static IDProperty **rna_NodeTreeInterfaceSocket_idprops(PointerRNA *ptr)
{
bNodeTreeInterfaceSocket *socket = static_cast<bNodeTreeInterfaceSocket *>(ptr->data);
return &socket->properties;
}
static void rna_NodeTreeInterfaceSocket_identifier_get(PointerRNA *ptr, char *value)
{
bNodeTreeInterfaceSocket *socket = static_cast<bNodeTreeInterfaceSocket *>(ptr->data);
strcpy(value, socket->identifier);
}
static int rna_NodeTreeInterfaceSocket_identifier_length(PointerRNA *ptr)
{
bNodeTreeInterfaceSocket *socket = static_cast<bNodeTreeInterfaceSocket *>(ptr->data);
return strlen(socket->identifier);
}
static int rna_NodeTreeInterfaceSocket_socket_type_get(PointerRNA *ptr)
{
bNodeTreeInterfaceSocket *socket = static_cast<bNodeTreeInterfaceSocket *>(ptr->data);
return rna_node_socket_idname_to_enum(socket->socket_type);
}
static void rna_NodeTreeInterfaceSocket_socket_type_set(PointerRNA *ptr, int value)
{
bNodeSocketType *typeinfo = rna_node_socket_type_from_enum(value);
if (typeinfo) {
bNodeTreeInterfaceSocket *socket = static_cast<bNodeTreeInterfaceSocket *>(ptr->data);
socket->set_socket_type(typeinfo->idname);
}
}
static bool is_socket_type_supported(bNodeTreeType *ntreetype, bNodeSocketType *socket_type)
{
/* Check if the node tree supports the socket type. */
if (ntreetype->valid_socket_type && !ntreetype->valid_socket_type(ntreetype, socket_type)) {
return false;
}
/* Only use basic socket types for this enum. */
if (socket_type->subtype != PROP_NONE) {
return false;
}
if (!U.experimental.use_rotation_socket && socket_type->type == SOCK_ROTATION) {
return false;
}
return true;
}
static bNodeSocketType *find_supported_socket_type(bNodeTreeType *ntree_type)
{
NODE_SOCKET_TYPES_BEGIN (socket_type) {
if (is_socket_type_supported(ntree_type, socket_type)) {
return socket_type;
}
}
NODE_SOCKET_TYPES_END;
return nullptr;
}
static bool rna_NodeTreeInterfaceSocket_socket_type_poll(void *userdata,
bNodeSocketType *socket_type)
{
bNodeTreeType *ntreetype = static_cast<bNodeTreeType *>(userdata);
return is_socket_type_supported(ntreetype, socket_type);
}
static const EnumPropertyItem *rna_NodeTreeInterfaceSocket_socket_type_itemf(
bContext * /*C*/, PointerRNA *ptr, PropertyRNA * /*prop*/, bool *r_free)
{
bNodeTree *ntree = reinterpret_cast<bNodeTree *>(ptr->owner_id);
if (!ntree) {
return DummyRNA_NULL_items;
}
return rna_node_socket_type_itemf(
ntree->typeinfo, rna_NodeTreeInterfaceSocket_socket_type_poll, r_free);
}
static PointerRNA rna_NodeTreeInterfaceItems_active_get(PointerRNA *ptr)
{
bNodeTreeInterface *interface = static_cast<bNodeTreeInterface *>(ptr->data);
PointerRNA r_ptr;
RNA_pointer_create(ptr->owner_id, &RNA_NodeTreeInterfaceItem, interface->active_item(), &r_ptr);
return r_ptr;
}
static void rna_NodeTreeInterfaceItems_active_set(PointerRNA *ptr,
PointerRNA value,
ReportList * /*reports*/)
{
bNodeTreeInterface *interface = static_cast<bNodeTreeInterface *>(ptr->data);
bNodeTreeInterfaceItem *item = static_cast<bNodeTreeInterfaceItem *>(value.data);
interface->active_item_set(item);
}
static bNodeTreeInterfaceSocket *rna_NodeTreeInterfaceItems_new_socket(
ID *id,
bNodeTreeInterface *interface,
Main *bmain,
ReportList *reports,
const char *name,
const char *description,
bool is_input,
bool is_output,
int socket_type_enum,
bNodeTreeInterfacePanel *parent)
{
if (parent != nullptr && !interface->find_item(parent->item)) {
BKE_report(reports, RPT_ERROR_INVALID_INPUT, "Parent is not part of the interface");
return nullptr;
}
bNodeTree *ntree = reinterpret_cast<bNodeTree *>(id);
bNodeSocketType *typeinfo = rna_node_socket_type_from_enum(socket_type_enum);
if (typeinfo == nullptr) {
BKE_report(reports, RPT_ERROR_INVALID_INPUT, "Unknown socket type");
return nullptr;
}
/* If data type is unsupported try to find a valid type. */
if (!is_socket_type_supported(ntree->typeinfo, typeinfo)) {
typeinfo = find_supported_socket_type(ntree->typeinfo);
if (typeinfo == nullptr) {
BKE_report(reports, RPT_ERROR, "Could not find supported socket type");
return nullptr;
}
}
const char *socket_type = typeinfo->idname;
eNodeTreeInterfaceSocketFlag flag = eNodeTreeInterfaceSocketFlag(0);
SET_FLAG_FROM_TEST(flag, is_input, NODE_INTERFACE_SOCKET_INPUT);
SET_FLAG_FROM_TEST(flag, is_output, NODE_INTERFACE_SOCKET_OUTPUT);
bNodeTreeInterfaceSocket *socket = interface->add_socket(name ? name : "",
description ? description : "",
socket_type ? socket_type : "",
flag,
parent);
if (socket == nullptr) {
BKE_report(reports, RPT_ERROR, "Unable to create socket");
}
else {
BKE_ntree_update_tag_interface(ntree);
ED_node_tree_propagate_change(nullptr, bmain, ntree);
WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
}
return socket;
}
static bNodeTreeInterfacePanel *rna_NodeTreeInterfaceItems_new_panel(
ID *id,
bNodeTreeInterface *interface,
Main *bmain,
ReportList *reports,
const char *name,
bNodeTreeInterfacePanel *parent)
{
if (parent != nullptr && !interface->find_item(parent->item)) {
BKE_report(reports, RPT_ERROR_INVALID_INPUT, "Parent is not part of the interface");
return nullptr;
}
bNodeTreeInterfacePanel *panel = interface->add_panel(name ? name : "", parent);
if (panel == nullptr) {
BKE_report(reports, RPT_ERROR, "Unable to create panel");
}
else {
bNodeTree *ntree = reinterpret_cast<bNodeTree *>(id);
BKE_ntree_update_tag_interface(ntree);
ED_node_tree_propagate_change(nullptr, bmain, ntree);
WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
}
return panel;
}
static bNodeTreeInterfaceItem *rna_NodeTreeInterfaceItems_copy_to_parent(
ID *id,
bNodeTreeInterface *interface,
Main *bmain,
ReportList *reports,
bNodeTreeInterfaceItem *item,
bNodeTreeInterfacePanel *parent)
{
if (parent != nullptr && !interface->find_item(parent->item)) {
BKE_report(reports, RPT_ERROR_INVALID_INPUT, "Parent is not part of the interface");
return nullptr;
}
if (parent == nullptr) {
parent = &interface->root_panel;
}
const int index = parent->items().as_span().first_index_try(item);
if (!parent->items().index_range().contains(index)) {
return nullptr;
}
bNodeTreeInterfaceItem *item_copy = interface->insert_item_copy(*item, parent, index + 1);
if (item_copy == nullptr) {
BKE_report(reports, RPT_ERROR, "Unable to copy item");
}
else {
bNodeTree *ntree = reinterpret_cast<bNodeTree *>(id);
BKE_ntree_update_tag_interface(ntree);
ED_node_tree_propagate_change(nullptr, bmain, ntree);
WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
}
return item_copy;
}
static bNodeTreeInterfaceItem *rna_NodeTreeInterfaceItems_copy(ID *id,
bNodeTreeInterface *interface,
Main *bmain,
ReportList *reports,
bNodeTreeInterfaceItem *item)
{
/* Copy to same parent as the item. */
bNodeTreeInterfacePanel *parent = interface->find_item_parent(*item);
if (parent == nullptr) {
return nullptr;
}
return rna_NodeTreeInterfaceItems_copy_to_parent(id, interface, bmain, reports, item, parent);
}
static void rna_NodeTreeInterfaceItems_remove(ID *id,
bNodeTreeInterface *interface,
Main *bmain,
bNodeTreeInterfaceItem *item,
bool move_content_to_parent)
{
interface->remove_item(*item, move_content_to_parent);
bNodeTree *ntree = reinterpret_cast<bNodeTree *>(id);
BKE_ntree_update_tag_interface(ntree);
ED_node_tree_propagate_change(nullptr, bmain, ntree);
WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
}
static void rna_NodeTreeInterfaceItems_clear(ID *id, bNodeTreeInterface *interface, Main *bmain)
{
interface->clear_items();
bNodeTree *ntree = reinterpret_cast<bNodeTree *>(id);
BKE_ntree_update_tag_interface(ntree);
ED_node_tree_propagate_change(nullptr, bmain, ntree);
WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
}
static void rna_NodeTreeInterfaceItems_move(
ID *id, bNodeTreeInterface *interface, Main *bmain, bNodeTreeInterfaceItem *item, int to_index)
{
interface->move_item(*item, to_index);
bNodeTree *ntree = reinterpret_cast<bNodeTree *>(id);
BKE_ntree_update_tag_interface(ntree);
ED_node_tree_propagate_change(nullptr, bmain, ntree);
WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
}
static void rna_NodeTreeInterfaceItems_move_to_parent(ID *id,
bNodeTreeInterface *interface,
Main *bmain,
bNodeTreeInterfaceItem *item,
bNodeTreeInterfacePanel *parent,
int to_index)
{
interface->move_item_to_parent(*item, parent, to_index);
bNodeTree *ntree = reinterpret_cast<bNodeTree *>(id);
BKE_ntree_update_tag_interface(ntree);
ED_node_tree_propagate_change(nullptr, bmain, ntree);
WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
}
/* ******** Node Socket Subtypes ******** */
void rna_NodeTreeInterfaceSocketFloat_default_value_range(
PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
{
bNodeTreeInterfaceSocket *socket = static_cast<bNodeTreeInterfaceSocket *>(ptr->data);
bNodeSocketValueFloat *dval = static_cast<bNodeSocketValueFloat *>(socket->socket_data);
bNodeSocketType *socket_typeinfo = nodeSocketTypeFind(socket->socket_type);
int subtype = socket_typeinfo ? socket_typeinfo->subtype : PROP_NONE;
if (dval->max < dval->min) {
dval->max = dval->min;
}
*min = (subtype == PROP_UNSIGNED ? 0.0f : -FLT_MAX);
*max = FLT_MAX;
*softmin = dval->min;
*softmax = dval->max;
}
void rna_NodeTreeInterfaceSocketInt_default_value_range(
PointerRNA *ptr, int *min, int *max, int *softmin, int *softmax)
{
bNodeTreeInterfaceSocket *socket = static_cast<bNodeTreeInterfaceSocket *>(ptr->data);
bNodeSocketValueInt *dval = static_cast<bNodeSocketValueInt *>(socket->socket_data);
bNodeSocketType *socket_typeinfo = nodeSocketTypeFind(socket->socket_type);
int subtype = socket_typeinfo ? socket_typeinfo->subtype : PROP_NONE;
if (dval->max < dval->min) {
dval->max = dval->min;
}
*min = (subtype == PROP_UNSIGNED ? 0 : INT_MIN);
*max = INT_MAX;
*softmin = dval->min;
*softmax = dval->max;
}
void rna_NodeTreeInterfaceSocketVector_default_value_range(
PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
{
bNodeTreeInterfaceSocket *socket = static_cast<bNodeTreeInterfaceSocket *>(ptr->data);
bNodeSocketValueVector *dval = static_cast<bNodeSocketValueVector *>(socket->socket_data);
if (dval->max < dval->min) {
dval->max = dval->min;
}
*min = -FLT_MAX;
*max = FLT_MAX;
*softmin = dval->min;
*softmax = dval->max;
}
/* using a context update function here, to avoid searching the node if possible */
static void rna_NodeTreeInterfaceSocket_value_update(Main *bmain, Scene *scene, PointerRNA *ptr)
{
/* default update */
rna_NodeTreeInterfaceItem_update(bmain, scene, ptr);
}
static bool rna_NodeTreeInterfaceSocketMaterial_default_value_poll(PointerRNA * /*ptr*/,
PointerRNA value)
{
/* Do not show grease pencil materials for now. */
Material *ma = static_cast<Material *>(value.data);
return ma->gp_style == nullptr;
}
static void rna_NodeTreeInterface_items_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
{
bNodeTree *ntree = reinterpret_cast<bNodeTree *>(ptr->owner_id);
if (!ntree->runtime) {
return;
}
ntree->ensure_topology_cache();
// Note: New API, enabled when interface cache is added.
UNUSED_VARS(iter);
// const blender::bke::bNodeTreeInterfaceCache &cache = ntree->interface_cache();
// rna_iterator_array_begin(iter,
// const_cast<bNodeTreeInterfaceItem **>(cache.items.data()),
// sizeof(bNodeTreeInterfaceItem *),
// cache.items.size(),
// false,
// nullptr);
}
static int rna_NodeTreeInterface_items_length(PointerRNA *ptr)
{
bNodeTree *ntree = reinterpret_cast<bNodeTree *>(ptr->owner_id);
if (!ntree->runtime) {
return 0;
}
ntree->ensure_topology_cache();
// Note: New API callbacks.
// return ntree->interface_cache().items.size();
return 0;
}
static int rna_NodeTreeInterface_items_lookup_int(PointerRNA *ptr, int index, PointerRNA *r_ptr)
{
bNodeTree *ntree = reinterpret_cast<bNodeTree *>(ptr->owner_id);
if (!ntree->runtime) {
return 0;
}
ntree->ensure_topology_cache();
// Note: New API, enabled when interface cache is added.
UNUSED_VARS(index, r_ptr);
// const blender::bke::bNodeTreeInterfaceCache &cache = ntree->interface_cache();
// if (!cache.items.index_range().contains(index)) {
// return false;
// }
// RNA_pointer_create(ptr->owner_id, &RNA_NodeTreeInterfaceItem, cache.items[index], r_ptr);
return true;
}
static int rna_NodeTreeInterface_items_lookup_string(struct PointerRNA *ptr,
const char *key,
struct PointerRNA *r_ptr)
{
bNodeTree *ntree = reinterpret_cast<bNodeTree *>(ptr->owner_id);
if (!ntree->runtime) {
return 0;
}
ntree->ensure_topology_cache();
// Note: New API, enabled when interface cache is added.
UNUSED_VARS(key, r_ptr);
// const blender::bke::bNodeTreeInterfaceCache &cache = ntree->interface_cache();
// for (bNodeTreeInterfaceItem *item : cache.items) {
// switch (item->item_type) {
// case NODE_INTERFACE_SOCKET: {
// bNodeTreeInterfaceSocket *socket = reinterpret_cast<bNodeTreeInterfaceSocket *>(item);
// if (STREQ(socket->name, key)) {
// RNA_pointer_create(ptr->owner_id, &RNA_NodeTreeInterfaceSocket, socket, r_ptr);
// return true;
// }
// break;
// }
// case NODE_INTERFACE_PANEL: {
// bNodeTreeInterfacePanel *panel = reinterpret_cast<bNodeTreeInterfacePanel *>(item);
// if (STREQ(panel->name, key)) {
// RNA_pointer_create(ptr->owner_id, &RNA_NodeTreeInterfacePanel, panel, r_ptr);
// return true;
// }
// break;
// }
// }
// }
return false;
}
#else
static void rna_def_node_interface_item(BlenderRNA *brna)
{
StructRNA *srna;
PropertyRNA *prop;
srna = RNA_def_struct(brna, "NodeTreeInterfaceItem", nullptr);
RNA_def_struct_ui_text(srna, "Node Tree Interface Item", "Item in a node tree interface");
RNA_def_struct_sdna(srna, "bNodeTreeInterfaceItem");
RNA_def_struct_refine_func(srna, "rna_NodeTreeInterfaceItem_refine");
RNA_def_struct_path_func(srna, "rna_NodeTreeInterfaceItem_path");
prop = RNA_def_property(srna, "item_type", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, nullptr, "item_type");
RNA_def_property_enum_items(prop, rna_enum_node_tree_interface_item_type_items);
RNA_def_property_clear_flag(prop, PROP_EDITABLE);
RNA_def_property_ui_text(prop, "Item Type", "Type of interface item");
}
static void rna_def_node_interface_socket(BlenderRNA *brna)
{
StructRNA *srna;
PropertyRNA *prop;
FunctionRNA *func;
PropertyRNA *parm;
srna = RNA_def_struct(brna, "NodeTreeInterfaceSocket", "NodeTreeInterfaceItem");
RNA_def_struct_ui_text(srna, "Node Tree Interface Socket", "Declaration of a node socket");
RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
RNA_def_struct_register_funcs(srna,
"rna_NodeTreeInterfaceSocket_register",
"rna_NodeTreeInterfaceSocket_unregister",
nullptr);
RNA_def_struct_idprops_func(srna, "rna_NodeTreeInterfaceSocket_idprops");
prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
RNA_def_property_ui_text(prop, "Name", "Socket name");
RNA_def_struct_name_property(srna, prop);
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
prop = RNA_def_property(srna, "identifier", PROP_STRING, PROP_NONE);
RNA_def_property_string_funcs(prop,
"rna_NodeTreeInterfaceSocket_identifier_get",
"rna_NodeTreeInterfaceSocket_identifier_length",
nullptr);
RNA_def_property_clear_flag(prop, PROP_EDITABLE);
RNA_def_property_ui_text(prop, "Identifier", "Unique identifier for mapping sockets");
prop = RNA_def_property(srna, "description", PROP_STRING, PROP_NONE);
RNA_def_property_string_sdna(prop, nullptr, "description");
RNA_def_property_ui_text(prop, "Description", "Socket description");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
prop = RNA_def_property(srna, "socket_type", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_items(prop, DummyRNA_DEFAULT_items);
RNA_def_property_enum_funcs(prop,
"rna_NodeTreeInterfaceSocket_socket_type_get",
"rna_NodeTreeInterfaceSocket_socket_type_set",
"rna_NodeTreeInterfaceSocket_socket_type_itemf");
RNA_def_property_ui_text(
prop, "Socket Type", "Type of the socket generated by this interface item");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
prop = RNA_def_property(srna, "is_input", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, nullptr, "flag", NODE_INTERFACE_SOCKET_INPUT);
RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
RNA_def_property_ui_text(prop, "Is Input", "Whether the socket is an input");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
prop = RNA_def_property(srna, "is_output", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, nullptr, "flag", NODE_INTERFACE_SOCKET_OUTPUT);
RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
RNA_def_property_ui_text(prop, "Is Output", "Whether the socket is an output");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
prop = RNA_def_property(srna, "hide_value", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, nullptr, "flag", NODE_INTERFACE_SOCKET_HIDE_VALUE);
RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
RNA_def_property_ui_text(
prop, "Hide Value", "Hide the socket input value even when the socket is not connected");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
prop = RNA_def_property(srna, "hide_in_modifier", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, nullptr, "flag", NODE_INTERFACE_SOCKET_HIDE_IN_MODIFIER);
RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
RNA_def_property_ui_text(prop,
"Hide in Modifier",
"Don't show the input value in the geometry nodes modifier interface");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
prop = RNA_def_property(srna, "attribute_domain", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_items(prop, rna_enum_attribute_domain_items);
RNA_def_property_ui_text(
prop,
"Attribute Domain",
"Attribute domain used by the geometry nodes modifier to create an attribute output");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
prop = RNA_def_property(srna, "default_attribute_name", PROP_STRING, PROP_NONE);
RNA_def_property_string_sdna(prop, nullptr, "default_attribute_name");
RNA_def_property_ui_text(prop,
"Default Attribute",
"The attribute name used by default when the node group is used by a "
"geometry nodes modifier");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
/* Registered properties and functions for custom socket types. */
prop = RNA_def_property(srna, "bl_socket_idname", PROP_STRING, PROP_NONE);
RNA_def_property_string_sdna(prop, nullptr, "socket_type");
RNA_def_property_flag(prop, PROP_REGISTER);
RNA_def_property_ui_text(prop, "Socket Type Name", "Name of the socket type");
func = RNA_def_function(srna, "draw", nullptr);
RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL | FUNC_USE_SELF_ID);
RNA_def_function_ui_description(func, "Draw properties of the socket interface");
parm = RNA_def_pointer(func, "context", "Context", "", "");
RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
parm = RNA_def_property(func, "layout", PROP_POINTER, PROP_NONE);
RNA_def_property_struct_type(parm, "UILayout");
RNA_def_property_ui_text(parm, "Layout", "Layout in the UI");
RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
func = RNA_def_function(srna, "init_socket", nullptr);
RNA_def_function_ui_description(func, "Initialize a node socket instance");
RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL | FUNC_USE_SELF_ID | FUNC_ALLOW_WRITE);
parm = RNA_def_pointer(func, "node", "Node", "Node", "Node of the socket to initialize");
RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
parm = RNA_def_pointer(func, "socket", "NodeSocket", "Socket", "Socket to initialize");
RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
parm = RNA_def_string(
func, "data_path", nullptr, 0, "Data Path", "Path to specialized socket data");
RNA_def_parameter_flags(parm, PropertyFlag(0), PARM_REQUIRED);
func = RNA_def_function(srna, "from_socket", nullptr);
RNA_def_function_ui_description(func, "Setup template parameters from an existing socket");
RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL | FUNC_USE_SELF_ID | FUNC_ALLOW_WRITE);
parm = RNA_def_pointer(func, "node", "Node", "Node", "Node of the original socket");
RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
parm = RNA_def_pointer(func, "socket", "NodeSocket", "Socket", "Original socket");
RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
}
static void rna_def_node_interface_panel(BlenderRNA *brna)
{
StructRNA *srna;
PropertyRNA *prop;
srna = RNA_def_struct(brna, "NodeTreeInterfacePanel", "NodeTreeInterfaceItem");
RNA_def_struct_ui_text(srna, "Node Tree Interface Item", "Declaration of a node panel");
RNA_def_struct_sdna(srna, "bNodeTreeInterfacePanel");
prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
RNA_def_property_ui_text(prop, "Name", "Panel name");
RNA_def_struct_name_property(srna, prop);
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
prop = RNA_def_property(srna, "interface_items", PROP_COLLECTION, PROP_NONE);
RNA_def_property_collection_sdna(prop, nullptr, "items_array", "items_num");
RNA_def_property_struct_type(prop, "NodeTreeInterfaceItem");
RNA_def_property_clear_flag(prop, PROP_EDITABLE);
RNA_def_property_ui_text(prop, "Items", "Items in the node panel");
}
static void rna_def_node_tree_interface_items_api(StructRNA *srna)
{
PropertyRNA *prop;
PropertyRNA *parm;
FunctionRNA *func;
prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
RNA_def_property_int_sdna(prop, nullptr, "active_index");
RNA_def_property_ui_text(prop, "Active Index", "Index of the active item");
RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
RNA_def_property_update(prop, NC_NODE, nullptr);
prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
RNA_def_property_struct_type(prop, "NodeTreeInterfaceItem");
RNA_def_property_flag(prop, PROP_EDITABLE);
RNA_def_property_pointer_funcs(prop,
"rna_NodeTreeInterfaceItems_active_get",
"rna_NodeTreeInterfaceItems_active_set",
nullptr,
nullptr);
RNA_def_property_ui_text(prop, "Active", "Active item");
RNA_def_property_update(prop, NC_NODE, nullptr);
func = RNA_def_function(srna, "new_socket", "rna_NodeTreeInterfaceItems_new_socket");
RNA_def_function_ui_description(func, "Add a new socket to the interface");
RNA_def_function_flag(func, FUNC_USE_SELF_ID | FUNC_USE_MAIN | FUNC_USE_REPORTS);
parm = RNA_def_string(func, "name", nullptr, 0, "Name", "Name of the socket");
RNA_def_parameter_flags(parm, PropertyFlag(0), PARM_REQUIRED);
RNA_def_string(func, "description", nullptr, 0, "Description", "Description of the socket");
RNA_def_boolean(func, "is_input", false, "Is Input", "Create an input socket");
RNA_def_boolean(func, "is_output", false, "Is Output", "Create an output socket");
parm = RNA_def_enum(func,
"socket_type",
DummyRNA_DEFAULT_items,
0,
"Socket Type",
"Type of socket generated on nodes");
/* Note: itemf callback works for the function parameter, it does not require a data pointer. */
RNA_def_property_enum_funcs(
parm, nullptr, nullptr, "rna_NodeTreeInterfaceSocket_socket_type_itemf");
RNA_def_pointer(
func, "parent", "NodeTreeInterfacePanel", "Parent", "Panel to add the socket in");
/* return value */
parm = RNA_def_pointer(func, "item", "NodeTreeInterfaceSocket", "Socket", "New socket");
RNA_def_function_return(func, parm);
func = RNA_def_function(srna, "new_panel", "rna_NodeTreeInterfaceItems_new_panel");
RNA_def_function_ui_description(func, "Add a new panel to the interface");
RNA_def_function_flag(func, FUNC_USE_SELF_ID | FUNC_USE_MAIN | FUNC_USE_REPORTS);
parm = RNA_def_string(func, "name", nullptr, 0, "Name", "Name of the new panel");
RNA_def_parameter_flags(parm, PropertyFlag(0), PARM_REQUIRED);
RNA_def_pointer(func,
"parent",
"NodeTreeInterfacePanel",
"Parent",
"Add panel as a child of the parent panel");
/* return value */
parm = RNA_def_pointer(func, "item", "NodeTreeInterfacePanel", "Panel", "New panel");
RNA_def_function_return(func, parm);
func = RNA_def_function(srna, "copy", "rna_NodeTreeInterfaceItems_copy");
RNA_def_function_ui_description(func, "Add a copy of an item to the interface");
RNA_def_function_flag(func, FUNC_USE_SELF_ID | FUNC_USE_MAIN | FUNC_USE_REPORTS);
parm = RNA_def_pointer(func, "item", "NodeTreeInterfaceItem", "Item", "Item to copy");
RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
/* return value */
parm = RNA_def_pointer(
func, "item_copy", "NodeTreeInterfaceItem", "Item Copy", "Copy of the item");
RNA_def_function_return(func, parm);
func = RNA_def_function(srna, "remove", "rna_NodeTreeInterfaceItems_remove");
RNA_def_function_ui_description(func, "Remove an item from the interface");
RNA_def_function_flag(func, FUNC_USE_SELF_ID | FUNC_USE_MAIN);
parm = RNA_def_pointer(func, "item", "NodeTreeInterfaceItem", "Item", "The item to remove");
RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
RNA_def_boolean(
func,
"move_content_to_parent",
true,
"Move Content",
"If the item is a panel, move the contents to the parent instead of deleting it");
func = RNA_def_function(srna, "clear", "rna_NodeTreeInterfaceItems_clear");
RNA_def_function_ui_description(func, "Remove all items from the interface");
RNA_def_function_flag(func, FUNC_USE_SELF_ID | FUNC_USE_MAIN);
func = RNA_def_function(srna, "move", "rna_NodeTreeInterfaceItems_move");
RNA_def_function_ui_description(func, "Move an item to another position");
RNA_def_function_flag(func, FUNC_USE_SELF_ID | FUNC_USE_MAIN);
parm = RNA_def_pointer(func, "item", "NodeTreeInterfaceItem", "Item", "The item to remove");
RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
parm = RNA_def_int(
func, "to_index", -1, 0, INT_MAX, "To Index", "Target index for the item", 0, 10000);
RNA_def_parameter_flags(parm, PropertyFlag(0), PARM_REQUIRED);
func = RNA_def_function(srna, "move_to_parent", "rna_NodeTreeInterfaceItems_move_to_parent");
RNA_def_function_ui_description(func, "Move an item to a new panel and/or position.");
RNA_def_function_flag(func, FUNC_USE_SELF_ID | FUNC_USE_MAIN);
parm = RNA_def_pointer(func, "item", "NodeTreeInterfaceItem", "Item", "The item to remove");
RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
parm = RNA_def_pointer(
func, "parent", "NodeTreeInterfacePanel", "Parent", "New parent of the item");
RNA_def_parameter_flags(parm, PropertyFlag(0), PARM_REQUIRED);
parm = RNA_def_int(
func, "to_index", -1, 0, INT_MAX, "To Index", "Target index for the item", 0, 10000);
RNA_def_parameter_flags(parm, PropertyFlag(0), PARM_REQUIRED);
}
static void rna_def_node_tree_interface(BlenderRNA *brna)
{
StructRNA *srna;
PropertyRNA *prop;
srna = RNA_def_struct(brna, "NodeTreeInterface", nullptr);
RNA_def_struct_ui_text(
srna, "Node Tree Interface", "Declaration of sockets and ui panels of a node group");
RNA_def_struct_sdna(srna, "bNodeTreeInterface");
prop = RNA_def_property(srna, "ui_items", PROP_COLLECTION, PROP_NONE);
RNA_def_property_collection_funcs(prop,
"rna_NodeTreeInterface_items_begin",
"rna_iterator_array_next",
"rna_iterator_array_end",
"rna_iterator_array_dereference_get",
"rna_NodeTreeInterface_items_length",
"rna_NodeTreeInterface_items_lookup_int",
"rna_NodeTreeInterface_items_lookup_string",
nullptr);
RNA_def_property_struct_type(prop, "NodeTreeInterfaceItem");
RNA_def_property_clear_flag(prop, PROP_EDITABLE);
RNA_def_property_ui_text(prop, "Items", "Items in the node interface");
rna_def_node_tree_interface_items_api(srna);
}
void RNA_def_node_tree_interface(BlenderRNA *brna)
{
rna_def_node_interface_item(brna);
rna_def_node_interface_socket(brna);
rna_def_node_interface_panel(brna);
rna_def_node_tree_interface(brna);
rna_def_node_socket_interface_subtypes(brna);
}
#endif

16
source/blender/makesrna/intern/rna_nodetree.cc
View File

@@ -604,7 +604,6 @@ static const EnumPropertyItem node_cryptomatte_layer_name_items[] = {
# include "DNA_scene_types.h"
# include "WM_api.hh"
extern "C" {
extern FunctionRNA rna_NodeTree_poll_func;
extern FunctionRNA rna_NodeTree_update_func;
extern FunctionRNA rna_NodeTree_get_from_context_func;
@@ -619,7 +618,6 @@ extern FunctionRNA rna_Node_free_func;
extern FunctionRNA rna_Node_draw_buttons_func;
extern FunctionRNA rna_Node_draw_buttons_ext_func;
extern FunctionRNA rna_Node_draw_label_func;
}
void rna_Node_socket_update(Main *bmain, Scene * /*scene*/, PointerRNA *ptr);
@@ -689,6 +687,20 @@ const EnumPropertyItem *rna_node_tree_type_itemf(void *data,
return item;
}
int rna_node_socket_idname_to_enum(const char *idname)
{
int i = 0, result = -1;
NODE_SOCKET_TYPES_BEGIN (stype) {
if (STREQ(stype->idname, idname)) {
result = i;
break;
}
i++;
}
NODE_SOCKET_TYPES_END;
return result;
}
bNodeSocketType *rna_node_socket_type_from_enum(int value)
{
int i = 0;