ilusha/blender
1
0
Fork 0
mirror of https://github.com/blender/blender synced 2026-09-29 04:37:17 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions

Nodes: add boilerplate for multiple new data-block socket types

Browse source 
This adds the boilerplate to support various new socket types. None if the types
is exposed in the UI yet. This is just preparation for future features using
these sockets.

The newly added socket types are:
* `Font`: Allows exposing the font in the String to Curves node.
* `Scene`: Useful for the Compositor to select view layers which belong to
  scenes, also see #143195.
* `Text`: For use with e.g. Geometry Nodes to support getting text input from
  text data-blocks (or maybe even writing debug data to text data-blocks at some
  point).
* `Mask`: Allows exposing the mask data-block of the Mask node in the
  compositor.
* `Sound`: Allows accessing sound data in geometry nodes (useful when finishing
  up #122228).

It's generally more efficient to add socket types in bulk when a few types are
planned around the same time, because each type requires many but very similar
changes. Adding them separately results in many merge conflicts are potential
inconsistencies between new socket types because some place is forgotten.

The sockets are currently just black, so their color has to be chosen when they
are actually exposed.

Pull Request: https://projects.blender.org/blender/blender/pulls/151429
This commit is contained in:
Jacques Lucke 2025-12-12 11:36:12 +01:00
parent 82e094b352
commit 6108f85de3
31 changed files with 1230 additions and 149 deletions
Download patch file Download diff file Expand all files Collapse all files

4
source/blender/blenkernel/BKE_node.hh
View file

@ -550,12 +550,16 @@ struct bNodeTreeType {
* \{ */
bNodeTreeType *node_tree_type_find(StringRef idname);
bNodeTreeType *node_tree_type_find_builtin(const int tree_type);
void node_tree_type_add(bNodeTreeType &nt);
void node_tree_type_free_link(const bNodeTreeType &nt);
bool node_tree_is_registered(const bNodeTree &ntree);
Span<bNodeTreeType *> node_tree_types_get();
bool node_tree_type_supports_socket_type_static(const int ntree_type,
const eNodeSocketDatatype socket_type);
/**
* Try to initialize all type-info in a node tree.
*

20
source/blender/blenkernel/BKE_node_tree_interface.hh
View file

@ -243,6 +243,11 @@ static const bNodeSocketStaticTypeInfo node_socket_subtypes[] = {
{"NodeSocketMenu", "NodeTreeInterfaceSocketMenu", SOCK_MENU, PROP_NONE},
{"NodeSocketBundle", "NodeTreeInterfaceSocketBundle", SOCK_BUNDLE, PROP_NONE},
{"NodeSocketClosure", "NodeTreeInterfaceSocketClosure", SOCK_CLOSURE, PROP_NONE},
{"NodeSocketFont", "NodeTreeInterfaceSocketFont", SOCK_FONT, PROP_NONE},
{"NodeSocketScene", "NodeTreeInterfaceSocketScene", SOCK_SCENE, PROP_NONE},
{"NodeSocketText", "NodeTreeInterfaceSocketText", SOCK_TEXT_ID, PROP_NONE},
{"NodeSocketMask", "NodeTreeInterfaceSocketMask", SOCK_MASK, PROP_NONE},
{"NodeSocketSound", "NodeTreeInterfaceSocketSound", SOCK_SOUND, PROP_NONE},
};
template<typename Fn> bool socket_data_to_static_type(const eNodeSocketDatatype type, const Fn &fn)
@ -284,6 +289,21 @@ template<typename Fn> bool socket_data_to_static_type(const eNodeSocketDatatype
case SOCK_MATERIAL:
fn.template operator()<bNodeSocketValueMaterial>();
return true;
case SOCK_FONT:
fn.template operator()<bNodeSocketValueFont>();
return true;
case SOCK_SCENE:
fn.template operator()<bNodeSocketValueScene>();
return true;
case SOCK_TEXT_ID:
fn.template operator()<bNodeSocketValueText>();
return true;
case SOCK_MASK:
fn.template operator()<bNodeSocketValueMask>();
return true;
case SOCK_SOUND:
fn.template operator()<bNodeSocketValueSound>();
return true;
case SOCK_MENU:
fn.template operator()<bNodeSocketValueMenu>();
return true;

10
source/blender/blenkernel/intern/cpp_types.cc
View file

@ -34,6 +34,11 @@ BLI_CPP_TYPE_MAKE(Collection *, CPPTypeFlags::BasicType)
BLI_CPP_TYPE_MAKE(Tex *, CPPTypeFlags::BasicType)
BLI_CPP_TYPE_MAKE(Image *, CPPTypeFlags::BasicType)
BLI_CPP_TYPE_MAKE(Material *, CPPTypeFlags::BasicType)
BLI_CPP_TYPE_MAKE(VFont *, CPPTypeFlags::BasicType)
BLI_CPP_TYPE_MAKE(Scene *, CPPTypeFlags::BasicType)
BLI_CPP_TYPE_MAKE(Text *, CPPTypeFlags::BasicType)
BLI_CPP_TYPE_MAKE(Mask *, CPPTypeFlags::BasicType)
BLI_CPP_TYPE_MAKE(bSound *, CPPTypeFlags::BasicType)
BLI_CPP_TYPE_MAKE(MStringProperty, CPPTypeFlags::None);
BLI_CPP_TYPE_MAKE(blender::nodes::MenuValue,
@ -63,6 +68,11 @@ void BKE_cpp_types_init()
BLI_CPP_TYPE_REGISTER(Tex *);
BLI_CPP_TYPE_REGISTER(Image *);
BLI_CPP_TYPE_REGISTER(Material *);
BLI_CPP_TYPE_REGISTER(VFont *);
BLI_CPP_TYPE_REGISTER(Scene *);
BLI_CPP_TYPE_REGISTER(Text *);
BLI_CPP_TYPE_REGISTER(Mask *);
BLI_CPP_TYPE_REGISTER(bSound *);
BLI_CPP_TYPE_REGISTER(MStringProperty);
BLI_CPP_TYPE_REGISTER(blender::nodes::MenuValue);

209
source/blender/blenkernel/intern/node.cc
View file

@ -22,11 +22,15 @@
#include "DNA_gpencil_legacy_types.h"
#include "DNA_light_types.h"
#include "DNA_linestyle_types.h"
#include "DNA_mask_types.h"
#include "DNA_material_types.h"
#include "DNA_node_types.h"
#include "DNA_scene_types.h"
#include "DNA_sound_types.h"
#include "DNA_text_types.h"
#include "DNA_texture_types.h"
#include "DNA_userdef_types.h"
#include "DNA_vfont_types.h"
#include "DNA_world_types.h"
#include "BLI_color.hh"
@ -339,6 +343,31 @@ static void library_foreach_node_socket(bNodeSocket *sock, LibraryForeachIDData
BKE_LIB_FOREACHID_PROCESS_IDSUPER(data, default_value.value, IDWALK_CB_USER);
break;
}
case SOCK_FONT: {
bNodeSocketValueFont &default_value = *sock->default_value_typed<bNodeSocketValueFont>();
BKE_LIB_FOREACHID_PROCESS_IDSUPER(data, default_value.value, IDWALK_CB_USER);
break;
}
case SOCK_SCENE: {
bNodeSocketValueScene &default_value = *sock->default_value_typed<bNodeSocketValueScene>();
BKE_LIB_FOREACHID_PROCESS_IDSUPER(data, default_value.value, IDWALK_CB_USER);
break;
}
case SOCK_TEXT_ID: {
bNodeSocketValueText &default_value = *sock->default_value_typed<bNodeSocketValueText>();
BKE_LIB_FOREACHID_PROCESS_IDSUPER(data, default_value.value, IDWALK_CB_USER);
break;
}
case SOCK_MASK: {
bNodeSocketValueMask &default_value = *sock->default_value_typed<bNodeSocketValueMask>();
BKE_LIB_FOREACHID_PROCESS_IDSUPER(data, default_value.value, IDWALK_CB_USER);
break;
}
case SOCK_SOUND: {
bNodeSocketValueSound &default_value = *sock->default_value_typed<bNodeSocketValueSound>();
BKE_LIB_FOREACHID_PROCESS_IDSUPER(data, default_value.value, IDWALK_CB_USER);
break;
}
case SOCK_FLOAT:
case SOCK_VECTOR:
case SOCK_RGBA:
@ -1005,6 +1034,21 @@ static void write_node_socket_default_value(BlendWriter *writer, const bNodeSock
case SOCK_MATERIAL:
BLO_write_struct(writer, bNodeSocketValueMaterial, sock->default_value);
break;
case SOCK_FONT:
BLO_write_struct(writer, bNodeSocketValueFont, sock->default_value);
break;
case SOCK_SCENE:
BLO_write_struct(writer, bNodeSocketValueScene, sock->default_value);
break;
case SOCK_TEXT_ID:
BLO_write_struct(writer, bNodeSocketValueText, sock->default_value);
break;
case SOCK_MASK:
BLO_write_struct(writer, bNodeSocketValueMask, sock->default_value);
break;
case SOCK_SOUND:
BLO_write_struct(writer, bNodeSocketValueSound, sock->default_value);
break;
case SOCK_ROTATION:
BLO_write_struct(writer, bNodeSocketValueRotation, sock->default_value);
break;
@ -1243,6 +1287,11 @@ static bool is_node_socket_supported(const bNodeSocket *sock)
case SOCK_COLLECTION:
case SOCK_TEXTURE:
case SOCK_MATERIAL:
case SOCK_FONT:
case SOCK_SCENE:
case SOCK_TEXT_ID:
case SOCK_MASK:
case SOCK_SOUND:
case SOCK_ROTATION:
case SOCK_MENU:
case SOCK_MATRIX:
@ -1433,6 +1482,21 @@ static void direct_link_node_socket_default_value(BlendDataReader *reader, bNode
case SOCK_MATERIAL:
BLO_read_struct(reader, bNodeSocketValueMaterial, &sock->default_value);
break;
case SOCK_FONT:
BLO_read_struct(reader, bNodeSocketValueFont, &sock->default_value);
break;
case SOCK_SCENE:
BLO_read_struct(reader, bNodeSocketValueScene, &sock->default_value);
break;
case SOCK_TEXT_ID:
BLO_read_struct(reader, bNodeSocketValueText, &sock->default_value);
break;
case SOCK_MASK:
BLO_read_struct(reader, bNodeSocketValueMask, &sock->default_value);
break;
case SOCK_SOUND:
BLO_read_struct(reader, bNodeSocketValueSound, &sock->default_value);
break;
case SOCK_ROTATION:
BLO_read_struct(reader, bNodeSocketValueRotation, &sock->default_value);
break;
@ -1609,6 +1673,12 @@ static void direct_link_node_socket_default_value(BlendDataReader *reader, bNode
case SOCK_CUSTOM:
/* Custom node sockets where default_value is defined were using custom properties for
* storage. */
case SOCK_FONT:
case SOCK_SCENE:
case SOCK_TEXT_ID:
case SOCK_MASK:
case SOCK_SOUND:
/* Those data-block types did not exist in the older version. */
case SOCK_SHADER:
case SOCK_GEOMETRY:
case SOCK_BUNDLE:
@ -2327,6 +2397,16 @@ bNodeTreeType *node_tree_type_find(const StringRef idname)
return *value;
}
bNodeTreeType *node_tree_type_find_builtin(const int tree_type)
{
for (bNodeTreeType *type : get_node_tree_type_map()) {
if (type->type == tree_type) {
return type;
}
}
return nullptr;
}
static void defer_free_tree_type(bNodeTreeType *tree_type)
{
static ResourceScope scope;
@ -2673,6 +2753,31 @@ static void socket_id_user_increment(bNodeSocket *sock)
id_us_plus(reinterpret_cast<ID *>(default_value.value));
break;
}
case SOCK_FONT: {
bNodeSocketValueFont &default_value = *sock->default_value_typed<bNodeSocketValueFont>();
id_us_plus(id_cast<ID *>(default_value.value));
break;
}
case SOCK_SCENE: {
bNodeSocketValueScene &default_value = *sock->default_value_typed<bNodeSocketValueScene>();
id_us_plus(id_cast<ID *>(default_value.value));
break;
}
case SOCK_TEXT_ID: {
bNodeSocketValueText &default_value = *sock->default_value_typed<bNodeSocketValueText>();
id_us_plus(id_cast<ID *>(default_value.value));
break;
}
case SOCK_MASK: {
bNodeSocketValueMask &default_value = *sock->default_value_typed<bNodeSocketValueMask>();
id_us_plus(id_cast<ID *>(default_value.value));
break;
}
case SOCK_SOUND: {
bNodeSocketValueSound &default_value = *sock->default_value_typed<bNodeSocketValueSound>();
id_us_plus(id_cast<ID *>(default_value.value));
break;
}
case SOCK_FLOAT:
case SOCK_VECTOR:
case SOCK_RGBA:
@ -2723,6 +2828,31 @@ static bool socket_id_user_decrement(bNodeSocket *sock)
id_us_min(reinterpret_cast<ID *>(default_value.value));
return default_value.value != nullptr;
}
case SOCK_FONT: {
bNodeSocketValueFont &default_value = *sock->default_value_typed<bNodeSocketValueFont>();
id_us_min(id_cast<ID *>(default_value.value));
return default_value.value != nullptr;
}
case SOCK_SCENE: {
bNodeSocketValueScene &default_value = *sock->default_value_typed<bNodeSocketValueScene>();
id_us_min(id_cast<ID *>(default_value.value));
return default_value.value != nullptr;
}
case SOCK_TEXT_ID: {
bNodeSocketValueText &default_value = *sock->default_value_typed<bNodeSocketValueText>();
id_us_min(id_cast<ID *>(default_value.value));
return default_value.value != nullptr;
}
case SOCK_MASK: {
bNodeSocketValueMask &default_value = *sock->default_value_typed<bNodeSocketValueMask>();
id_us_min(id_cast<ID *>(default_value.value));
return default_value.value != nullptr;
}
case SOCK_SOUND: {
bNodeSocketValueSound &default_value = *sock->default_value_typed<bNodeSocketValueSound>();
id_us_min(id_cast<ID *>(default_value.value));
return default_value.value != nullptr;
}
case SOCK_FLOAT:
case SOCK_VECTOR:
case SOCK_RGBA:
@ -2794,6 +2924,11 @@ void node_modify_socket_type(bNodeTree &ntree,
case SOCK_COLLECTION:
case SOCK_TEXTURE:
case SOCK_MATERIAL:
case SOCK_FONT:
case SOCK_SCENE:
case SOCK_TEXT_ID:
case SOCK_MASK:
case SOCK_SOUND:
case SOCK_MENU:
case SOCK_BUNDLE:
case SOCK_CLOSURE:
@ -2998,6 +3133,16 @@ std::optional<StringRefNull> node_static_socket_type(const int type,
return "NodeSocketTexture";
case SOCK_MATERIAL:
return "NodeSocketMaterial";
case SOCK_FONT:
return "NodeSocketFont";
case SOCK_SCENE:
return "NodeSocketScene";
case SOCK_TEXT_ID:
return "NodeSocketText";
case SOCK_MASK:
return "NodeSocketMask";
case SOCK_SOUND:
return "NodeSocketSound";
case SOCK_MENU:
return "NodeSocketMenu";
case SOCK_BUNDLE:
@ -3155,6 +3300,16 @@ std::optional<StringRefNull> node_static_socket_interface_type_new(
return "NodeTreeInterfaceSocketTexture";
case SOCK_MATERIAL:
return "NodeTreeInterfaceSocketMaterial";
case SOCK_FONT:
return "NodeTreeInterfaceSocketFont";
case SOCK_SCENE:
return "NodeTreeInterfaceSocketScene";
case SOCK_TEXT_ID:
return "NodeTreeInterfaceSocketText";
case SOCK_MASK:
return "NodeTreeInterfaceSocketMask";
case SOCK_SOUND:
return "NodeTreeInterfaceSocketSound";
case SOCK_MENU:
return "NodeTreeInterfaceSocketMenu";
case SOCK_BUNDLE:
@ -3200,6 +3355,16 @@ std::optional<StringRefNull> node_static_socket_label(const int type, const int
return "Texture";
case SOCK_MATERIAL:
return "Material";
case SOCK_FONT:
return "Font";
case SOCK_SCENE:
return "Scene";
case SOCK_TEXT_ID:
return "Text";
case SOCK_MASK:
return "Mask";
case SOCK_SOUND:
return "Sound";
case SOCK_MENU:
return "Menu";
case SOCK_BUNDLE:
@ -3717,6 +3882,16 @@ static void *socket_value_storage(bNodeSocket &socket)
return &socket.default_value_typed<bNodeSocketValueObject>()->value;
case SOCK_MATERIAL:
return &socket.default_value_typed<bNodeSocketValueMaterial>()->value;
case SOCK_FONT:
return &socket.default_value_typed<bNodeSocketValueFont>()->value;
case SOCK_SCENE:
return &socket.default_value_typed<bNodeSocketValueScene>()->value;
case SOCK_TEXT_ID:
return &socket.default_value_typed<bNodeSocketValueText>()->value;
case SOCK_MASK:
return &socket.default_value_typed<bNodeSocketValueMask>()->value;
case SOCK_SOUND:
return &socket.default_value_typed<bNodeSocketValueSound>()->value;
case SOCK_ROTATION:
return &socket.default_value_typed<bNodeSocketValueRotation>()->value_euler;
case SOCK_MENU:
@ -3808,7 +3983,12 @@ void node_socket_move_default_value(Main & /*bmain*/,
SOCK_IMAGE,
SOCK_MATERIAL,
SOCK_TEXTURE,
SOCK_OBJECT))
SOCK_OBJECT,
SOCK_FONT,
SOCK_SCENE,
SOCK_TEXT_ID,
SOCK_MASK,
SOCK_SOUND))
{
src_type.value_initialize(src_value);
}
@ -5316,6 +5496,21 @@ std::optional<eNodeSocketDatatype> geo_nodes_base_cpp_type_to_socket_type(const
if (type.is<Image *>()) {
return SOCK_IMAGE;
}
if (type.is<VFont *>()) {
return SOCK_FONT;
}
if (type.is<Scene *>()) {
return SOCK_SCENE;
}
if (type.is<Text *>()) {
return SOCK_TEXT_ID;
}
if (type.is<Mask *>()) {
return SOCK_MASK;
}
if (type.is<bSound *>()) {
return SOCK_SOUND;
}
return std::nullopt;
}
@ -5565,4 +5760,16 @@ void node_tree_remove_layer_n(bNodeTree *ntree, Scene *scene, const int layer_in
}
}
bool node_tree_type_supports_socket_type_static(const int ntree_type,
const eNodeSocketDatatype socket_type)
{
if (bke::bNodeTreeType *ttype = bke::node_tree_type_find_builtin(ntree_type)) {
bke::bNodeSocketType *stype = bke::node_socket_type_find_static(socket_type);
if (ttype->valid_socket_type) {
return ttype->valid_socket_type(ttype, stype);
}
}
return false;
}
} // namespace blender::bke

70
source/blender/blenkernel/intern/node_socket_value.cc
View file

@ -89,6 +89,21 @@ template<typename T> static std::optional<eNodeSocketDatatype> static_type_to_so
if constexpr (is_same_any_v<T, Material *>) {
return SOCK_MATERIAL;
}
if constexpr (is_same_any_v<T, VFont *>) {
return SOCK_FONT;
}
if constexpr (is_same_any_v<T, Scene *>) {
return SOCK_SCENE;
}
if constexpr (is_same_any_v<T, Text *>) {
return SOCK_TEXT_ID;
}
if constexpr (is_same_any_v<T, Mask *>) {
return SOCK_MASK;
}
if constexpr (is_same_any_v<T, bSound *>) {
return SOCK_SOUND;
}
if constexpr (is_same_any_v<T, bke::GeometrySet>) {
return SOCK_GEOMETRY;
}
@ -134,6 +149,16 @@ static bool static_type_is_base_socket_type(const eNodeSocketDatatype socket_typ
return std::is_same_v<T, Image *>;
case SOCK_MATERIAL:
return std::is_same_v<T, Material *>;
case SOCK_FONT:
return std::is_same_v<T, VFont *>;
case SOCK_SCENE:
return std::is_same_v<T, Scene *>;
case SOCK_TEXT_ID:
return std::is_same_v<T, Text *>;
case SOCK_MASK:
return std::is_same_v<T, Mask *>;
case SOCK_SOUND:
return std::is_same_v<T, bSound *>;
case SOCK_GEOMETRY:
return std::is_same_v<T, bke::GeometrySet>;
case SOCK_CUSTOM:
@ -345,6 +370,26 @@ void SocketValueVariant::store_single(const eNodeSocketDatatype socket_type, con
value_.emplace<Material *>(*static_cast<Material *const *>(value));
break;
}
case SOCK_FONT: {
value_.emplace<VFont *>(*static_cast<VFont *const *>(value));
break;
}
case SOCK_SCENE: {
value_.emplace<Scene *>(*static_cast<Scene *const *>(value));
break;
}
case SOCK_TEXT_ID: {
value_.emplace<Text *>(*static_cast<Text *const *>(value));
break;
}
case SOCK_MASK: {
value_.emplace<Mask *>(*static_cast<Mask *const *>(value));
break;
}
case SOCK_SOUND: {
value_.emplace<bSound *>(*static_cast<bSound *const *>(value));
break;
}
case SOCK_GEOMETRY: {
value_.emplace<bke::GeometrySet>(*static_cast<const bke::GeometrySet *>(value));
break;
@ -465,6 +510,16 @@ void *SocketValueVariant::allocate_single(const eNodeSocketDatatype socket_type)
return value_.allocate<Image *>();
case SOCK_MATERIAL:
return value_.allocate<Material *>();
case SOCK_FONT:
return value_.allocate<VFont *>();
case SOCK_SCENE:
return value_.allocate<Scene *>();
case SOCK_TEXT_ID:
return value_.allocate<Text *>();
case SOCK_MASK:
return value_.allocate<Mask *>();
case SOCK_SOUND:
return value_.allocate<bSound *>();
case SOCK_GEOMETRY:
return value_.allocate<bke::GeometrySet>();
default: {
@ -494,6 +549,11 @@ void SocketValueVariant::ensure_owns_direct_data()
case SOCK_TEXTURE:
case SOCK_IMAGE:
case SOCK_MATERIAL:
case SOCK_FONT:
case SOCK_SCENE:
case SOCK_TEXT_ID:
case SOCK_MASK:
case SOCK_SOUND:
case SOCK_CLOSURE: {
break;
}
@ -546,6 +606,11 @@ bool SocketValueVariant::owns_direct_data() const
case SOCK_TEXTURE:
case SOCK_IMAGE:
case SOCK_MATERIAL:
case SOCK_FONT:
case SOCK_SCENE:
case SOCK_TEXT_ID:
case SOCK_MASK:
case SOCK_SOUND:
case SOCK_CLOSURE: {
return true;
}
@ -636,6 +701,11 @@ INSTANTIATE(Collection *)
INSTANTIATE(Tex *)
INSTANTIATE(Image *)
INSTANTIATE(Material *)
INSTANTIATE(VFont *)
INSTANTIATE(Scene *)
INSTANTIATE(Text *)
INSTANTIATE(Mask *)
INSTANTIATE(bSound *)
INSTANTIATE(float4x4)
INSTANTIATE(fn::Field<float4x4>)

104
source/blender/blenkernel/intern/node_tree_interface.cc
View file

@ -19,9 +19,13 @@
#include "BLO_read_write.hh"
#include "DNA_collection_types.h"
#include "DNA_mask_types.h"
#include "DNA_material_types.h"
#include "DNA_node_tree_interface_types.h"
#include "DNA_node_types.h"
#include "DNA_sound_types.h"
#include "DNA_text_types.h"
#include "DNA_vfont_types.h"
#include "NOD_node_declaration.hh"
#include "NOD_socket_declarations.hh"
@ -80,6 +84,26 @@ template<> void socket_data_id_user_increment(bNodeSocketValueMaterial &data)
{
id_us_plus(reinterpret_cast<ID *>(data.value));
}
template<> void socket_data_id_user_increment(bNodeSocketValueFont &data)
{
id_us_plus(reinterpret_cast<ID *>(data.value));
}
template<> void socket_data_id_user_increment(bNodeSocketValueScene &data)
{
id_us_plus(reinterpret_cast<ID *>(data.value));
}
template<> void socket_data_id_user_increment(bNodeSocketValueText &data)
{
id_us_plus(reinterpret_cast<ID *>(data.value));
}
template<> void socket_data_id_user_increment(bNodeSocketValueMask &data)
{
id_us_plus(reinterpret_cast<ID *>(data.value));
}
template<> void socket_data_id_user_increment(bNodeSocketValueSound &data)
{
id_us_plus(reinterpret_cast<ID *>(data.value));
}
/** \} */
@ -108,6 +132,26 @@ template<> void socket_data_id_user_decrement(bNodeSocketValueMaterial &data)
{
id_us_min(reinterpret_cast<ID *>(data.value));
}
template<> void socket_data_id_user_decrement(bNodeSocketValueFont &data)
{
id_us_min(reinterpret_cast<ID *>(data.value));
}
template<> void socket_data_id_user_decrement(bNodeSocketValueScene &data)
{
id_us_min(reinterpret_cast<ID *>(data.value));
}
template<> void socket_data_id_user_decrement(bNodeSocketValueText &data)
{
id_us_min(reinterpret_cast<ID *>(data.value));
}
template<> void socket_data_id_user_decrement(bNodeSocketValueMask &data)
{
id_us_min(reinterpret_cast<ID *>(data.value));
}
template<> void socket_data_id_user_decrement(bNodeSocketValueSound &data)
{
id_us_min(reinterpret_cast<ID *>(data.value));
}
/** \} */
@ -174,6 +218,26 @@ template<> void socket_data_init_impl(bNodeSocketValueMaterial &data)
{
data.value = nullptr;
}
template<> void socket_data_init_impl(bNodeSocketValueFont &data)
{
data.value = nullptr;
}
template<> void socket_data_init_impl(bNodeSocketValueScene &data)
{
data.value = nullptr;
}
template<> void socket_data_init_impl(bNodeSocketValueText &data)
{
data.value = nullptr;
}
template<> void socket_data_init_impl(bNodeSocketValueMask &data)
{
data.value = nullptr;
}
template<> void socket_data_init_impl(bNodeSocketValueSound &data)
{
data.value = nullptr;
}
template<> void socket_data_init_impl(bNodeSocketValueMenu &data)
{
data.value = -1;
@ -328,6 +392,26 @@ inline void socket_data_write_impl(BlendWriter *writer, bNodeSocketValueMaterial
{
BLO_write_struct(writer, bNodeSocketValueMaterial, &data);
}
inline void socket_data_write_impl(BlendWriter *writer, bNodeSocketValueFont &data)
{
BLO_write_struct(writer, bNodeSocketValueFont, &data);
}
inline void socket_data_write_impl(BlendWriter *writer, bNodeSocketValueScene &data)
{
BLO_write_struct(writer, bNodeSocketValueScene, &data);
}
inline void socket_data_write_impl(BlendWriter *writer, bNodeSocketValueText &data)
{
BLO_write_struct(writer, bNodeSocketValueText, &data);
}
inline void socket_data_write_impl(BlendWriter *writer, bNodeSocketValueMask &data)
{
BLO_write_struct(writer, bNodeSocketValueMask, &data);
}
inline void socket_data_write_impl(BlendWriter *writer, bNodeSocketValueSound &data)
{
BLO_write_struct(writer, bNodeSocketValueSound, &data);
}
inline void socket_data_write_impl(BlendWriter *writer, bNodeSocketValueMenu &data)
{
BLO_write_struct(writer, bNodeSocketValueMenu, &data);
@ -410,6 +494,26 @@ void socket_data_foreach_id_impl(LibraryForeachIDData *cb, bNodeSocketValueMater
{
BKE_LIB_FOREACHID_PROCESS_IDSUPER(cb, data.value, IDWALK_CB_USER);
}
template<> void socket_data_foreach_id_impl(LibraryForeachIDData *cb, bNodeSocketValueFont &data)
{
BKE_LIB_FOREACHID_PROCESS_IDSUPER(cb, data.value, IDWALK_CB_USER);
}
template<> void socket_data_foreach_id_impl(LibraryForeachIDData *cb, bNodeSocketValueScene &data)
{
BKE_LIB_FOREACHID_PROCESS_IDSUPER(cb, data.value, IDWALK_CB_USER);
}
template<> void socket_data_foreach_id_impl(LibraryForeachIDData *cb, bNodeSocketValueText &data)
{
BKE_LIB_FOREACHID_PROCESS_IDSUPER(cb, data.value, IDWALK_CB_USER);
}
template<> void socket_data_foreach_id_impl(LibraryForeachIDData *cb, bNodeSocketValueMask &data)
{
BKE_LIB_FOREACHID_PROCESS_IDSUPER(cb, data.value, IDWALK_CB_USER);
}
template<> void socket_data_foreach_id_impl(LibraryForeachIDData *cb, bNodeSocketValueSound &data)
{
BKE_LIB_FOREACHID_PROCESS_IDSUPER(cb, data.value, IDWALK_CB_USER);
}
static void socket_data_foreach_id(LibraryForeachIDData *data, bNodeTreeInterfaceSocket &socket)
{

15
source/blender/depsgraph/intern/builder/deg_builder_nodes.cc
View file

@ -1961,6 +1961,21 @@ void DepsgraphNodeBuilder::build_nodetree_socket(bNodeSocket *socket)
else if (socket->type == SOCK_MATERIAL) {
build_id((ID *)((bNodeSocketValueMaterial *)socket->default_value)->value);
}
else if (socket->type == SOCK_FONT) {
build_id((ID *)((bNodeSocketValueFont *)socket->default_value)->value);
}
else if (socket->type == SOCK_SCENE) {
build_id((ID *)((bNodeSocketValueScene *)socket->default_value)->value);
}
else if (socket->type == SOCK_TEXT_ID) {
/* Text data-blocks don't use the depsgraph. */
}
else if (socket->type == SOCK_MASK) {
build_id((ID *)((bNodeSocketValueMask *)socket->default_value)->value);
}
else if (socket->type == SOCK_SOUND) {
build_id((ID *)((bNodeSocketValueSound *)socket->default_value)->value);
}
}
void DepsgraphNodeBuilder::build_nodetree(bNodeTree *ntree)

27
source/blender/depsgraph/intern/builder/deg_builder_relations.cc
View file

@ -2988,6 +2988,33 @@ void DepsgraphRelationBuilder::build_nodetree_socket(bNodeSocket *socket)
build_material(material);
}
}
else if (socket->type == SOCK_FONT) {
VFont *font = ((bNodeSocketValueFont *)socket->default_value)->value;
if (font != nullptr) {
build_vfont(font);
}
}
else if (socket->type == SOCK_SCENE) {
Scene *scene = ((bNodeSocketValueScene *)socket->default_value)->value;
if (scene != nullptr) {
build_scene_parameters(scene);
}
}
else if (socket->type == SOCK_TEXT_ID) {
/* Text data-blocks don't use the depsgraph. */
}
else if (socket->type == SOCK_MASK) {
Mask *mask = ((bNodeSocketValueMask *)socket->default_value)->value;
if (mask != nullptr) {
build_mask(mask);
}
}
else if (socket->type == SOCK_SOUND) {
bSound *sound = ((bNodeSocketValueSound *)socket->default_value)->value;
if (sound != nullptr) {
build_sound(sound);
}
}
}
void DepsgraphRelationBuilder::build_nodetree(bNodeTree *ntree)

10
source/blender/editors/geometry/node_group_operator.cc
View file

@ -749,6 +749,16 @@ static std::optional<ID_Type> socket_type_to_id_type(const eNodeSocketDatatype s
return ID_TE;
case SOCK_MATERIAL:
return ID_MA;
case SOCK_FONT:
return ID_VF;
case SOCK_SCENE:
return ID_SCE;
case SOCK_TEXT_ID:
return ID_TXT;
case SOCK_MASK:
return ID_MSK;
case SOCK_SOUND:
return ID_SO;
}
return std::nullopt;
}

5
source/blender/editors/include/UI_icons.hh
View file

@ -1153,6 +1153,11 @@ DEF_ICON_VECTOR(NODE_SOCKET_MENU)
DEF_ICON_VECTOR(NODE_SOCKET_MATRIX)
DEF_ICON_VECTOR(NODE_SOCKET_BUNDLE)
DEF_ICON_VECTOR(NODE_SOCKET_CLOSURE)
DEF_ICON_VECTOR(NODE_SOCKET_FONT)
DEF_ICON_VECTOR(NODE_SOCKET_SCENE)
DEF_ICON_VECTOR(NODE_SOCKET_TEXT)
DEF_ICON_VECTOR(NODE_SOCKET_MASK)
DEF_ICON_VECTOR(NODE_SOCKET_SOUND)
/* add as needed. */

10
source/blender/editors/interface/interface_icons.cc
View file

@ -605,6 +605,11 @@ DEF_ICON_NODE_SOCKET_DRAW(geometry, eNodeSocketDatatype::SOCK_GEOMETRY)
DEF_ICON_NODE_SOCKET_DRAW(collection, eNodeSocketDatatype::SOCK_COLLECTION)
DEF_ICON_NODE_SOCKET_DRAW(texture, eNodeSocketDatatype::SOCK_TEXTURE)
DEF_ICON_NODE_SOCKET_DRAW(material, eNodeSocketDatatype::SOCK_MATERIAL)
DEF_ICON_NODE_SOCKET_DRAW(font, eNodeSocketDatatype::SOCK_FONT)
DEF_ICON_NODE_SOCKET_DRAW(scene, eNodeSocketDatatype::SOCK_SCENE)
DEF_ICON_NODE_SOCKET_DRAW(text, eNodeSocketDatatype::SOCK_TEXT_ID)
DEF_ICON_NODE_SOCKET_DRAW(mask, eNodeSocketDatatype::SOCK_MASK)
DEF_ICON_NODE_SOCKET_DRAW(sound, eNodeSocketDatatype::SOCK_SOUND)
DEF_ICON_NODE_SOCKET_DRAW(rotation, eNodeSocketDatatype::SOCK_ROTATION)
DEF_ICON_NODE_SOCKET_DRAW(menu, eNodeSocketDatatype::SOCK_MENU)
DEF_ICON_NODE_SOCKET_DRAW(matrix, eNodeSocketDatatype::SOCK_MATRIX)
@ -998,6 +1003,11 @@ static void init_internal_icons()
def_internal_vicon(ICON_NODE_SOCKET_MATRIX, icon_node_socket_draw_matrix);
def_internal_vicon(ICON_NODE_SOCKET_BUNDLE, icon_node_socket_draw_bundle);
def_internal_vicon(ICON_NODE_SOCKET_CLOSURE, icon_node_socket_draw_closure);
def_internal_vicon(ICON_NODE_SOCKET_FONT, icon_node_socket_draw_font);
def_internal_vicon(ICON_NODE_SOCKET_SCENE, icon_node_socket_draw_scene);
def_internal_vicon(ICON_NODE_SOCKET_TEXT, icon_node_socket_draw_text);
def_internal_vicon(ICON_NODE_SOCKET_MASK, icon_node_socket_draw_mask);
def_internal_vicon(ICON_NODE_SOCKET_SOUND, icon_node_socket_draw_sound);
}
#else

23
source/blender/editors/space_node/drawnode.cc
View file

@ -993,6 +993,11 @@ static const float std_node_socket_colors[][4] = {
{0.72, 0.20, 0.52, 1.0}, /* SOCK_MATRIX */
{0.30, 0.50, 0.50, 1.0}, /* SOCK_BUNDLE */
{0.49, 0.49, 0.23, 1.0}, /* SOCK_CLOSURE */
{0, 0, 0, 1}, /* SOCK_FONT */
{0, 0, 0, 1}, /* SOCK_SCENE */
{0, 0, 0, 1}, /* SOCK_TEXT_ID */
{0, 0, 0, 1}, /* SOCK_MASK */
{0, 0, 0, 1}, /* SOCK_SOUND */
};
void std_node_socket_colors_get(int socket_type, float *r_color)
@ -1029,7 +1034,9 @@ static const SocketColorFn std_node_socket_color_funcs[] = {
std_node_socket_color_fn<SOCK_TEXTURE>, std_node_socket_color_fn<SOCK_MATERIAL>,
std_node_socket_color_fn<SOCK_ROTATION>, std_node_socket_color_fn<SOCK_MENU>,
std_node_socket_color_fn<SOCK_MATRIX>, std_node_socket_color_fn<SOCK_BUNDLE>,
std_node_socket_color_fn<SOCK_CLOSURE>,
std_node_socket_color_fn<SOCK_CLOSURE>, std_node_socket_color_fn<SOCK_FONT>,
std_node_socket_color_fn<SOCK_SCENE>, std_node_socket_color_fn<SOCK_TEXT_ID>,
std_node_socket_color_fn<SOCK_MASK>, std_node_socket_color_fn<SOCK_SOUND>,
};
static bool socket_needs_attribute_search(bNode &node, bNodeSocket &socket)
@ -1327,7 +1334,12 @@ static void std_node_socket_draw(
}
case SOCK_COLLECTION:
case SOCK_OBJECT:
case SOCK_MATERIAL: {
case SOCK_MATERIAL:
case SOCK_FONT:
case SOCK_SCENE:
case SOCK_TEXT_ID:
case SOCK_MASK:
case SOCK_SOUND: {
if (optional_label) {
layout->prop(ptr,
RNA_struct_find_property(ptr, "default_value"),
@ -1446,7 +1458,12 @@ static void std_node_socket_interface_draw(ID *id,
case SOCK_COLLECTION:
case SOCK_IMAGE:
case SOCK_TEXTURE:
case SOCK_MATERIAL: {
case SOCK_MATERIAL:
case SOCK_FONT:
case SOCK_SCENE:
case SOCK_TEXT_ID:
case SOCK_MASK:
case SOCK_SOUND: {
col->prop(&ptr, "default_value", DEFAULT_FLAGS, IFACE_("Default"), ICON_NONE);
break;
}

5
source/blender/editors/space_node/node_relationships.cc
View file

@ -2811,6 +2811,11 @@ static int get_main_socket_priority(const bNodeSocket *socket)
case SOCK_COLLECTION:
case SOCK_TEXTURE:
case SOCK_MATERIAL:
case SOCK_FONT:
case SOCK_SCENE:
case SOCK_TEXT_ID:
case SOCK_MASK:
case SOCK_SOUND:
case SOCK_BUNDLE:
case SOCK_CLOSURE:
return 7;

29
source/blender/editors/space_node/node_select.cc
View file

@ -12,9 +12,13 @@
#include "DNA_collection_types.h"
#include "DNA_image_types.h"
#include "DNA_mask_types.h"
#include "DNA_material_types.h"
#include "DNA_node_types.h"
#include "DNA_object_types.h"
#include "DNA_sound_types.h"
#include "DNA_text_types.h"
#include "DNA_vfont_types.h"
#include "DNA_windowmanager_types.h"
#include "BLI_lasso_2d.hh"
@ -1550,6 +1554,31 @@ static void node_find_update_fn(const bContext *C,
*node, id_cast<ID *>(socket->default_value_typed<bNodeSocketValueImage>()->value));
break;
}
case SOCK_FONT: {
add_data_block_item(
*node, id_cast<ID *>(socket->default_value_typed<bNodeSocketValueFont>()->value));
break;
}
case SOCK_SCENE: {
add_data_block_item(
*node, id_cast<ID *>(socket->default_value_typed<bNodeSocketValueScene>()->value));
break;
}
case SOCK_TEXT_ID: {
add_data_block_item(
*node, id_cast<ID *>(socket->default_value_typed<bNodeSocketValueText>()->value));
break;
}
case SOCK_MASK: {
add_data_block_item(
*node, id_cast<ID *>(socket->default_value_typed<bNodeSocketValueMask>()->value));
break;
}
case SOCK_SOUND: {
add_data_block_item(
*node, id_cast<ID *>(socket->default_value_typed<bNodeSocketValueSound>()->value));
break;
}
}
}
}

26
source/blender/makesdna/DNA_node_types.h
View file

@ -320,6 +320,12 @@ typedef enum eNodeSocketDatatype {
SOCK_MATRIX = 16,
SOCK_BUNDLE = 17,
SOCK_CLOSURE = 18,
SOCK_FONT = 19,
SOCK_SCENE = 20,
/** Has _ID suffix to avoid using it instead of SOCK_STRING accidentally. */
SOCK_TEXT_ID = 21,
SOCK_MASK = 22,
SOCK_SOUND = 23,
} eNodeSocketDatatype;
/** Socket shape. */
@ -1039,6 +1045,26 @@ typedef struct bNodeSocketValueMaterial {
struct Material *value;
} bNodeSocketValueMaterial;
typedef struct bNodeSocketValueFont {
struct VFont *value;
} bNodeSocketValueFont;
typedef struct bNodeSocketValueScene {
struct Scene *value;
} bNodeSocketValueScene;
typedef struct bNodeSocketValueText {
struct Text *value;
} bNodeSocketValueText;
typedef struct bNodeSocketValueMask {
struct Mask *value;
} bNodeSocketValueMask;
typedef struct bNodeSocketValueSound {
struct bSound *value;
} bNodeSocketValueSound;
typedef struct bNodeSocketValueMenu {
/* Default input enum identifier. */
int value;

250
source/blender/makesrna/intern/rna_node_socket.cc
View file

@ -38,6 +38,11 @@ const EnumPropertyItem rna_enum_node_socket_type_items[] = {
{SOCK_MENU, "MENU", ICON_NODE_SOCKET_MENU, "Menu", ""},
{SOCK_BUNDLE, "BUNDLE", ICON_NODE_SOCKET_BUNDLE, "Bundle", ""},
{SOCK_CLOSURE, "CLOSURE", ICON_NODE_SOCKET_CLOSURE, "Closure", ""},
{SOCK_FONT, "FONT", ICON_NODE_SOCKET_FONT, "Font", ""},
{SOCK_SCENE, "SCENE", ICON_NODE_SOCKET_SCENE, "Scene", ""},
{SOCK_TEXT_ID, "TEXT", ICON_NODE_SOCKET_TEXT, "Text", ""},
{SOCK_MASK, "MASK", ICON_NODE_SOCKET_MASK, "Mask", ""},
{SOCK_SOUND, "SOUND", ICON_NODE_SOCKET_SOUND, "Sound", ""},
{0, nullptr, 0, nullptr, nullptr},
};
@ -1912,6 +1917,216 @@ static void rna_def_node_socket_interface_material(BlenderRNA *brna, const char
rna_def_node_tree_interface_socket_builtin(srna);
}
static void rna_def_node_socket_font(BlenderRNA *brna, const char *identifier)
{
StructRNA *srna;
PropertyRNA *prop;
srna = RNA_def_struct(brna, identifier, "NodeSocketStandard");
RNA_def_struct_ui_text(srna, "Font Node Socket", "Font socket of a node");
RNA_def_struct_sdna(srna, "bNodeSocket");
RNA_def_struct_sdna_from(srna, "bNodeSocketValueFont", "default_value");
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, "VectorFont");
RNA_def_property_ui_name_func(prop, "rna_NodeSocketStandard_name_func");
RNA_def_property_ui_description_func(prop, "rna_NodeSocketStandard_description_func");
RNA_def_property_update(
prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_and_relation_update");
RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_REFCOUNT | PROP_CONTEXT_UPDATE);
RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
}
static void rna_def_node_socket_interface_font(BlenderRNA *brna, const char *identifier)
{
StructRNA *srna;
PropertyRNA *prop;
srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
RNA_def_struct_ui_text(srna, "Font Node Socket Interface", "Font socket of a node");
RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
RNA_def_struct_sdna_from(srna, "bNodeSocketValueFont", "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, "VectorFont");
RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_REFCOUNT);
RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
}
static void rna_def_node_socket_scene(BlenderRNA *brna, const char *identifier)
{
StructRNA *srna;
PropertyRNA *prop;
srna = RNA_def_struct(brna, identifier, "NodeSocketStandard");
RNA_def_struct_ui_text(srna, "Scene Node Socket", "Scene socket of a node");
RNA_def_struct_sdna(srna, "bNodeSocket");
RNA_def_struct_sdna_from(srna, "bNodeSocketValueScene", "default_value");
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, "Scene");
RNA_def_property_ui_name_func(prop, "rna_NodeSocketStandard_name_func");
RNA_def_property_ui_description_func(prop, "rna_NodeSocketStandard_description_func");
RNA_def_property_update(
prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_and_relation_update");
RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_REFCOUNT | PROP_CONTEXT_UPDATE);
RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
}
static void rna_def_node_socket_interface_scene(BlenderRNA *brna, const char *identifier)
{
StructRNA *srna;
PropertyRNA *prop;
srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
RNA_def_struct_ui_text(srna, "Scene Node Socket Interface", "Scene socket of a node");
RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
RNA_def_struct_sdna_from(srna, "bNodeSocketValueScene", "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, "Scene");
RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_REFCOUNT);
RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
}
static void rna_def_node_socket_text(BlenderRNA *brna, const char *identifier)
{
StructRNA *srna;
PropertyRNA *prop;
srna = RNA_def_struct(brna, identifier, "NodeSocketStandard");
RNA_def_struct_ui_text(srna, "Text Node Socket", "Text socket of a node");
RNA_def_struct_sdna(srna, "bNodeSocket");
RNA_def_struct_sdna_from(srna, "bNodeSocketValueText", "default_value");
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, "Text");
RNA_def_property_ui_name_func(prop, "rna_NodeSocketStandard_name_func");
RNA_def_property_ui_description_func(prop, "rna_NodeSocketStandard_description_func");
RNA_def_property_update(
prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_and_relation_update");
RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_REFCOUNT | PROP_CONTEXT_UPDATE);
RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
}
static void rna_def_node_socket_interface_text(BlenderRNA *brna, const char *identifier)
{
StructRNA *srna;
PropertyRNA *prop;
srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
RNA_def_struct_ui_text(srna, "Text Node Socket Interface", "Text socket of a node");
RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
RNA_def_struct_sdna_from(srna, "bNodeSocketValueText", "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, "Text");
RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_REFCOUNT);
RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
}
static void rna_def_node_socket_mask(BlenderRNA *brna, const char *identifier)
{
StructRNA *srna;
PropertyRNA *prop;
srna = RNA_def_struct(brna, identifier, "NodeSocketStandard");
RNA_def_struct_ui_text(srna, "Mask Node Socket", "Mask socket of a node");
RNA_def_struct_sdna(srna, "bNodeSocket");
RNA_def_struct_sdna_from(srna, "bNodeSocketValueMask", "default_value");
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, "Mask");
RNA_def_property_ui_name_func(prop, "rna_NodeSocketStandard_name_func");
RNA_def_property_ui_description_func(prop, "rna_NodeSocketStandard_description_func");
RNA_def_property_update(
prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_and_relation_update");
RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_REFCOUNT | PROP_CONTEXT_UPDATE);
RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
}
static void rna_def_node_socket_interface_mask(BlenderRNA *brna, const char *identifier)
{
StructRNA *srna;
PropertyRNA *prop;
srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
RNA_def_struct_ui_text(srna, "Mask Node Socket Interface", "Mask socket of a node");
RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
RNA_def_struct_sdna_from(srna, "bNodeSocketValueMask", "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, "Mask");
RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_REFCOUNT);
RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
}
static void rna_def_node_socket_sound(BlenderRNA *brna, const char *identifier)
{
StructRNA *srna;
PropertyRNA *prop;
srna = RNA_def_struct(brna, identifier, "NodeSocketStandard");
RNA_def_struct_ui_text(srna, "Sound Node Socket", "Sound socket of a node");
RNA_def_struct_sdna(srna, "bNodeSocket");
RNA_def_struct_sdna_from(srna, "bNodeSocketValueSound", "default_value");
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, "Sound");
RNA_def_property_ui_name_func(prop, "rna_NodeSocketStandard_name_func");
RNA_def_property_ui_description_func(prop, "rna_NodeSocketStandard_description_func");
RNA_def_property_update(
prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_and_relation_update");
RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_REFCOUNT | PROP_CONTEXT_UPDATE);
RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
}
static void rna_def_node_socket_interface_sound(BlenderRNA *brna, const char *identifier)
{
StructRNA *srna;
PropertyRNA *prop;
srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
RNA_def_struct_ui_text(srna, "Sound Node Socket Interface", "Sound socket of a node");
RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
RNA_def_struct_sdna_from(srna, "bNodeSocketValueSound", "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, "Sound");
RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_REFCOUNT);
RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
}
static void rna_def_node_socket_virtual(BlenderRNA *brna, const char *identifier)
{
StructRNA *srna;
@ -2066,6 +2281,11 @@ static const bNodeSocketStaticTypeInfo node_socket_subtypes[] = {
{"NodeSocketMenu", "NodeTreeInterfaceSocketMenu", SOCK_MENU, PROP_NONE},
{"NodeSocketBundle", "NodeTreeInterfaceSocketBundle", SOCK_BUNDLE, PROP_NONE},
{"NodeSocketClosure", "NodeTreeInterfaceSocketClosure", SOCK_CLOSURE, PROP_NONE},
{"NodeSocketFont", "NodeTreeInterfaceSocketFont", SOCK_FONT, PROP_NONE},
{"NodeSocketScene", "NodeTreeInterfaceSocketScene", SOCK_SCENE, PROP_NONE},
{"NodeSocketText", "NodeTreeInterfaceSocketText", SOCK_TEXT_ID, PROP_NONE},
{"NodeSocketMask", "NodeTreeInterfaceSocketMask", SOCK_MASK, PROP_NONE},
{"NodeSocketSound", "NodeTreeInterfaceSocketSound", SOCK_SOUND, PROP_NONE},
};
static void rna_def_node_socket_subtypes(BlenderRNA *brna)
@ -2136,6 +2356,21 @@ static void rna_def_node_socket_subtypes(BlenderRNA *brna)
case SOCK_CLOSURE:
rna_def_node_socket_closure(brna, identifier);
break;
case SOCK_FONT:
rna_def_node_socket_font(brna, identifier);
break;
case SOCK_SCENE:
rna_def_node_socket_scene(brna, identifier);
break;
case SOCK_TEXT_ID:
rna_def_node_socket_text(brna, identifier);
break;
case SOCK_MASK:
rna_def_node_socket_mask(brna, identifier);
break;
case SOCK_SOUND:
rna_def_node_socket_sound(brna, identifier);
break;
case SOCK_CUSTOM:
break;
@ -2217,6 +2452,21 @@ void rna_def_node_socket_interface_subtypes(BlenderRNA *brna)
case SOCK_CLOSURE:
rna_def_node_socket_interface_closure(brna, identifier);
break;
case SOCK_FONT:
rna_def_node_socket_interface_font(brna, identifier);
break;
case SOCK_SCENE:
rna_def_node_socket_interface_scene(brna, identifier);
break;
case SOCK_TEXT_ID:
rna_def_node_socket_interface_text(brna, identifier);
break;
case SOCK_MASK:
rna_def_node_socket_interface_mask(brna, identifier);
break;
case SOCK_SOUND:
rna_def_node_socket_interface_sound(brna, identifier);
break;
case SOCK_CUSTOM:
break;

5
source/blender/makesrna/intern/rna_nodetree.cc
View file

@ -63,6 +63,11 @@ const EnumPropertyItem rna_enum_node_socket_data_type_items[] = {
{SOCK_MATERIAL, "MATERIAL", ICON_NODE_SOCKET_MATERIAL, "Material", ""},
{SOCK_BUNDLE, "BUNDLE", ICON_NODE_SOCKET_BUNDLE, "Bundle", ""},
{SOCK_CLOSURE, "CLOSURE", ICON_NODE_SOCKET_CLOSURE, "Closure", ""},
{SOCK_FONT, "FONT", ICON_NODE_SOCKET_FONT, "Font", ""},
{SOCK_SCENE, "SCENE", ICON_NODE_SOCKET_SCENE, "Scene", ""},
{SOCK_TEXT_ID, "TEXT", ICON_NODE_SOCKET_TEXT, "Text", ""},
{SOCK_MASK, "MASK", ICON_NODE_SOCKET_MASK, "Mask", ""},
{SOCK_SOUND, "SOUND", ICON_NODE_SOCKET_SOUND, "Sound", ""},
{0, nullptr, 0, nullptr, nullptr},
};

55
source/blender/nodes/NOD_socket_declarations.hh
View file

@ -373,6 +373,51 @@ class Image : public IDSocketDeclaration {
Image();
};
class Font : public IDSocketDeclaration {
public:
static constexpr eNodeSocketDatatype static_socket_type = SOCK_FONT;
using Builder = IDSocketDeclarationBuilder<Font>;
Font();
};
class Scene : public IDSocketDeclaration {
public:
static constexpr eNodeSocketDatatype static_socket_type = SOCK_SCENE;
using Builder = IDSocketDeclarationBuilder<Scene>;
Scene();
};
class Text : public IDSocketDeclaration {
public:
static constexpr eNodeSocketDatatype static_socket_type = SOCK_TEXT_ID;
using Builder = IDSocketDeclarationBuilder<Text>;
Text();
};
class Mask : public IDSocketDeclaration {
public:
static constexpr eNodeSocketDatatype static_socket_type = SOCK_MASK;
using Builder = IDSocketDeclarationBuilder<Mask>;
Mask();
};
class Sound : public IDSocketDeclaration {
public:
static constexpr eNodeSocketDatatype static_socket_type = SOCK_SOUND;
using Builder = IDSocketDeclarationBuilder<Sound>;
Sound();
};
class ShaderBuilder;
class Shader : public SocketDeclaration {
@ -643,6 +688,16 @@ inline Texture::Texture() : IDSocketDeclaration("NodeSocketTexture") {}
inline Image::Image() : IDSocketDeclaration("NodeSocketImage") {}
inline Font::Font() : IDSocketDeclaration("NodeSocketFont") {}
inline Scene::Scene() : IDSocketDeclaration("NodeSocketScene") {}
inline Text::Text() : IDSocketDeclaration("NodeSocketText") {}
inline Mask::Mask() : IDSocketDeclaration("NodeSocketMask") {}
inline Sound::Sound() : IDSocketDeclaration("NodeSocketSound") {}
/** \} */
/* -------------------------------------------------------------------- */

31
source/blender/nodes/geometry/include/NOD_geo_bundle.hh
View file

@ -13,36 +13,7 @@ namespace blender::nodes {
inline bool socket_type_supported_in_bundle(const eNodeSocketDatatype socket_type,
const int ntree_type)
{
switch (ntree_type) {
case NTREE_GEOMETRY:
return ELEM(socket_type,
SOCK_FLOAT,
SOCK_VECTOR,
SOCK_RGBA,
SOCK_BOOLEAN,
SOCK_ROTATION,
SOCK_MATRIX,
SOCK_INT,
SOCK_STRING,
SOCK_GEOMETRY,
SOCK_OBJECT,
SOCK_MATERIAL,
SOCK_IMAGE,
SOCK_COLLECTION,
SOCK_BUNDLE,
SOCK_CLOSURE);
case NTREE_SHADER:
return ELEM(socket_type,
SOCK_FLOAT,
SOCK_VECTOR,
SOCK_RGBA,
SOCK_SHADER,
SOCK_BUNDLE,
SOCK_CLOSURE,
SOCK_INT);
default:
return false;
}
return bke::node_tree_type_supports_socket_type_static(ntree_type, socket_type);
}
struct CombineBundleItemsAccessor : public socket_items::SocketItemsAccessorDefaults {

33
source/blender/nodes/geometry/include/NOD_geo_closure.hh
View file

@ -8,41 +8,14 @@
#include "NOD_socket_items.hh"
#include "BKE_node.hh"
namespace blender::nodes {
inline bool socket_type_supported_in_closure(const eNodeSocketDatatype socket_type,
const int ntree_type)
{
switch (ntree_type) {
case NTREE_GEOMETRY:
return ELEM(socket_type,
SOCK_FLOAT,
SOCK_VECTOR,
SOCK_RGBA,
SOCK_BOOLEAN,
SOCK_ROTATION,
SOCK_MATRIX,
SOCK_INT,
SOCK_STRING,
SOCK_GEOMETRY,
SOCK_OBJECT,
SOCK_MATERIAL,
SOCK_IMAGE,
SOCK_COLLECTION,
SOCK_BUNDLE,
SOCK_CLOSURE);
case NTREE_SHADER:
return ELEM(socket_type,
SOCK_FLOAT,
SOCK_VECTOR,
SOCK_RGBA,
SOCK_SHADER,
SOCK_BUNDLE,
SOCK_CLOSURE,
SOCK_INT);
default:
return false;
}
return bke::node_tree_type_supports_socket_type_static(ntree_type, socket_type);
}
struct ClosureInputItemsAccessor : public socket_items::SocketItemsAccessorDefaults {

31
source/blender/nodes/geometry/include/NOD_geo_repeat.hh
View file

@ -66,36 +66,7 @@ struct RepeatItemsAccessor : public socket_items::SocketItemsAccessorDefaults {
static bool supports_socket_type(const eNodeSocketDatatype socket_type, const int ntree_type)
{
switch (ntree_type) {
case NTREE_GEOMETRY:
return ELEM(socket_type,
SOCK_FLOAT,
SOCK_VECTOR,
SOCK_RGBA,
SOCK_BOOLEAN,
SOCK_ROTATION,
SOCK_MATRIX,
SOCK_INT,
SOCK_STRING,
SOCK_GEOMETRY,
SOCK_OBJECT,
SOCK_MATERIAL,
SOCK_IMAGE,
SOCK_COLLECTION,
SOCK_BUNDLE,
SOCK_CLOSURE);
case NTREE_SHADER:
return ELEM(socket_type,
SOCK_FLOAT,
SOCK_VECTOR,
SOCK_RGBA,
SOCK_SHADER,
SOCK_BUNDLE,
SOCK_CLOSURE,
SOCK_INT);
default:
return false;
}
return bke::node_tree_type_supports_socket_type_static(ntree_type, socket_type);
}
static void init_with_socket_type_and_name(bNode &node,

19
source/blender/nodes/geometry/include/NOD_geo_viewer.hh
View file

@ -76,24 +76,9 @@ struct GeoViewerItemsAccessor : public socket_items::SocketItemsAccessorDefaults
socket_items::set_item_name_and_make_unique<GeoViewerItemsAccessor>(node, item, name);
}
static bool supports_socket_type(const eNodeSocketDatatype socket_type, const int /*ntree_type*/)
static bool supports_socket_type(const eNodeSocketDatatype socket_type, const int ntree_type)
{
return ELEM(socket_type,
SOCK_FLOAT,
SOCK_VECTOR,
SOCK_RGBA,
SOCK_BOOLEAN,
SOCK_ROTATION,
SOCK_MATRIX,
SOCK_INT,
SOCK_STRING,
SOCK_GEOMETRY,
SOCK_OBJECT,
SOCK_MATERIAL,
SOCK_IMAGE,
SOCK_COLLECTION,
SOCK_BUNDLE,
SOCK_CLOSURE);
return bke::node_tree_type_supports_socket_type_static(ntree_type, socket_type);
}
static std::string socket_identifier_for_item(const NodeGeometryViewerItem &item)

11
source/blender/nodes/geometry/nodes/node_geo_index_switch.cc
View file

@ -118,7 +118,16 @@ static void node_declare(NodeDeclarationBuilder &b)
input.supports_field();
}
/* Labels are ugly in combination with data-block pickers and are usually disabled. */
input.optional_label(ELEM(data_type, SOCK_OBJECT, SOCK_IMAGE, SOCK_COLLECTION, SOCK_MATERIAL));
input.optional_label(ELEM(data_type,
SOCK_OBJECT,
SOCK_IMAGE,
SOCK_COLLECTION,
SOCK_MATERIAL,
SOCK_FONT,
SOCK_SCENE,
SOCK_TEXT_ID,
SOCK_MASK,
SOCK_SOUND));
input.structure_type(value_structure_type);
}

11
source/blender/nodes/geometry/nodes/node_geo_menu_switch.cc
View file

@ -101,7 +101,16 @@ static void node_declare(blender::nodes::NodeDeclarationBuilder &b)
input.supports_field();
}
/* Labels are ugly in combination with data-block pickers and are usually disabled. */
input.optional_label(ELEM(data_type, SOCK_OBJECT, SOCK_IMAGE, SOCK_COLLECTION, SOCK_MATERIAL));
input.optional_label(ELEM(data_type,
SOCK_OBJECT,
SOCK_IMAGE,
SOCK_COLLECTION,
SOCK_MATERIAL,
SOCK_FONT,
SOCK_SCENE,
SOCK_TEXT_ID,
SOCK_MASK,
SOCK_SOUND));
input.structure_type(value_structure_type);
auto &item_output = b.add_output<decl::Bool>(enum_item.name, std::move(identifier))
.align_with_previous()

48
source/blender/nodes/geometry/nodes/node_geo_switch.cc
View file

@ -236,37 +236,23 @@ static const bNodeSocket *node_internally_linked_input(const bNodeTree & /*tree*
static void node_rna(StructRNA *srna)
{
RNA_def_node_enum(
srna,
"input_type",
"Input Type",
"",
rna_enum_node_socket_data_type_items,
NOD_storage_enum_accessors(input_type),
SOCK_GEOMETRY,
[](bContext * /*C*/, PointerRNA * /*ptr*/, PropertyRNA * /*prop*/, bool *r_free) {
*r_free = true;
return enum_items_filter(rna_enum_node_socket_data_type_items,
[](const EnumPropertyItem &item) -> bool {
return ELEM(item.value,
SOCK_FLOAT,
SOCK_INT,
SOCK_BOOLEAN,
SOCK_ROTATION,
SOCK_MATRIX,
SOCK_VECTOR,
SOCK_STRING,
SOCK_RGBA,
SOCK_GEOMETRY,
SOCK_OBJECT,
SOCK_COLLECTION,
SOCK_MATERIAL,
SOCK_IMAGE,
SOCK_MENU,
SOCK_BUNDLE,
SOCK_CLOSURE);
});
});
RNA_def_node_enum(srna,
"input_type",
"Input Type",
"",
rna_enum_node_socket_data_type_items,
NOD_storage_enum_accessors(input_type),
SOCK_GEOMETRY,
[](bContext * /*C*/, PointerRNA *ptr, PropertyRNA * /*prop*/, bool *r_free) {
*r_free = true;
const bNodeTree &ntree = *id_cast<const bNodeTree *>(ptr->owner_id);
return enum_items_filter(
rna_enum_node_socket_data_type_items,
[&](const EnumPropertyItem &item) -> bool {
return bke::node_tree_type_supports_socket_type_static(
ntree.type, eNodeSocketDatatype(item.value));
});
});
}
static void register_node()

20
source/blender/nodes/intern/geometry_nodes_caller_ui.cc
View file

@ -537,6 +537,26 @@ static void draw_property_for_socket(DrawGroupInputsContext &ctx,
row.prop_search(ctx.properties_ptr, rna_path, ctx.bmain_ptr, "textures", name, ICON_TEXTURE);
break;
}
case SOCK_FONT: {
row.prop_search(ctx.properties_ptr, rna_path, ctx.bmain_ptr, "fonts", name, ICON_FONT_DATA);
break;
}
case SOCK_SCENE: {
row.prop_search(ctx.properties_ptr, rna_path, ctx.bmain_ptr, "scenes", name, ICON_SCENE);
break;
}
case SOCK_TEXT_ID: {
row.prop_search(ctx.properties_ptr, rna_path, ctx.bmain_ptr, "texts", name, ICON_TEXT);
break;
}
case SOCK_MASK: {
row.prop_search(ctx.properties_ptr, rna_path, ctx.bmain_ptr, "masks", name, ICON_NONE);
break;
}
case SOCK_SOUND: {
row.prop_search(ctx.properties_ptr, rna_path, ctx.bmain_ptr, "sounds", name, ICON_SOUND);
break;
}
case SOCK_IMAGE: {
PropertyRNA *prop = RNA_struct_find_property(ctx.properties_ptr, rna_path.c_str());
if (prop && RNA_property_type(prop) == PROP_POINTER) {

30
source/blender/nodes/intern/geometry_nodes_dependencies.cc
View file

@ -108,6 +108,36 @@ static void add_eval_dependencies_from_socket(const bNodeSocket &socket,
}
break;
}
case SOCK_FONT: {
if (VFont *font = static_cast<bNodeSocketValueFont *>(socket.default_value)->value) {
deps.add_generic_id(reinterpret_cast<ID *>(font));
}
break;
}
case SOCK_SCENE: {
if (Scene *scene = static_cast<bNodeSocketValueScene *>(socket.default_value)->value) {
deps.add_generic_id(reinterpret_cast<ID *>(scene));
}
break;
}
case SOCK_TEXT_ID: {
if (Text *text = static_cast<bNodeSocketValueText *>(socket.default_value)->value) {
deps.add_generic_id(reinterpret_cast<ID *>(text));
}
break;
}
case SOCK_MASK: {
if (Mask *mask = static_cast<bNodeSocketValueMask *>(socket.default_value)->value) {
deps.add_generic_id(reinterpret_cast<ID *>(mask));
}
break;
}
case SOCK_SOUND: {
if (bSound *sound = static_cast<bNodeSocketValueSound *>(socket.default_value)->value) {
deps.add_generic_id(reinterpret_cast<ID *>(sound));
}
break;
}
}
}

60
source/blender/nodes/intern/geometry_nodes_execute.cc
View file

@ -258,6 +258,36 @@ std::unique_ptr<IDProperty, bke::idprop::IDPropertyDeleter> id_property_create_f
ID *id = reinterpret_cast<ID *>(value->value);
return id_name_or_value_prop(identifier, id, ID_MA, use_name_for_ids);
}
case SOCK_FONT: {
const bNodeSocketValueFont *value = static_cast<const bNodeSocketValueFont *>(
socket.socket_data);
ID *id = reinterpret_cast<ID *>(value->value);
return id_name_or_value_prop(identifier, id, ID_VF, use_name_for_ids);
}
case SOCK_SCENE: {
const bNodeSocketValueScene *value = static_cast<const bNodeSocketValueScene *>(
socket.socket_data);
ID *id = reinterpret_cast<ID *>(value->value);
return id_name_or_value_prop(identifier, id, ID_SCE, use_name_for_ids);
}
case SOCK_TEXT_ID: {
const bNodeSocketValueText *value = static_cast<const bNodeSocketValueText *>(
socket.socket_data);
ID *id = reinterpret_cast<ID *>(value->value);
return id_name_or_value_prop(identifier, id, ID_TXT, use_name_for_ids);
}
case SOCK_MASK: {
const bNodeSocketValueMask *value = static_cast<const bNodeSocketValueMask *>(
socket.socket_data);
ID *id = reinterpret_cast<ID *>(value->value);
return id_name_or_value_prop(identifier, id, ID_MSK, use_name_for_ids);
}
case SOCK_SOUND: {
const bNodeSocketValueSound *value = static_cast<const bNodeSocketValueSound *>(
socket.socket_data);
ID *id = reinterpret_cast<ID *>(value->value);
return id_name_or_value_prop(identifier, id, ID_SO, use_name_for_ids);
}
case SOCK_MATRIX:
case SOCK_CUSTOM:
case SOCK_GEOMETRY:
@ -433,6 +463,11 @@ static bool old_id_property_type_matches_socket_convert_to_new(
case SOCK_TEXTURE:
case SOCK_IMAGE:
case SOCK_MATERIAL:
case SOCK_FONT:
case SOCK_SCENE:
case SOCK_TEXT_ID:
case SOCK_MASK:
case SOCK_SOUND:
if (use_name_for_ids) {
return old_id_property_type_matches_socket_convert_to_new_string(old_property,
new_property);
@ -581,6 +616,31 @@ static bke::SocketValueVariant init_socket_cpp_value_from_property(
Material *material = (id && GS(id->name) == ID_MA) ? (Material *)id : nullptr;
return bke::SocketValueVariant::From(material);
}
case SOCK_FONT: {
ID *id = IDP_ID_get(&property);
VFont *font = (id && GS(id->name) == ID_VF) ? (VFont *)id : nullptr;
return bke::SocketValueVariant::From(font);
}
case SOCK_SCENE: {
ID *id = IDP_ID_get(&property);
Scene *scene = (id && GS(id->name) == ID_SCE) ? (Scene *)id : nullptr;
return bke::SocketValueVariant::From(scene);
}
case SOCK_TEXT_ID: {
ID *id = IDP_ID_get(&property);
Text *text = (id && GS(id->name) == ID_TXT) ? (Text *)id : nullptr;
return bke::SocketValueVariant::From(text);
}
case SOCK_MASK: {
ID *id = IDP_ID_get(&property);
Mask *mask = (id && GS(id->name) == ID_MSK) ? (Mask *)id : nullptr;
return bke::SocketValueVariant::From(mask);
}
case SOCK_SOUND: {
ID *id = IDP_ID_get(&property);
bSound *sound = (id && GS(id->name) == ID_SO) ? (bSound *)id : nullptr;
return bke::SocketValueVariant::From(sound);
}
default: {
BLI_assert_unreachable();
return {};

25
source/blender/nodes/intern/node_common.cc
View file

@ -370,6 +370,31 @@ static BaseSocketDeclarationBuilder &build_interface_socket_declaration(
.default_value_fn(get_default_id_getter(tree.tree_interface, io_socket));
break;
}
case SOCK_FONT: {
decl = &b.add_socket<decl::Font>(name, identifier, in_out)
.default_value_fn(get_default_id_getter(tree.tree_interface, io_socket));
break;
}
case SOCK_SCENE: {
decl = &b.add_socket<decl::Scene>(name, identifier, in_out)
.default_value_fn(get_default_id_getter(tree.tree_interface, io_socket));
break;
}
case SOCK_TEXT_ID: {
decl = &b.add_socket<decl::Text>(name, identifier, in_out)
.default_value_fn(get_default_id_getter(tree.tree_interface, io_socket));
break;
}
case SOCK_MASK: {
decl = &b.add_socket<decl::Mask>(name, identifier, in_out)
.default_value_fn(get_default_id_getter(tree.tree_interface, io_socket));
break;
}
case SOCK_SOUND: {
decl = &b.add_socket<decl::Sound>(name, identifier, in_out)
.default_value_fn(get_default_id_getter(tree.tree_interface, io_socket));
break;
}
case SOCK_BUNDLE: {
decl = &b.add_socket<decl::Bundle>(name, identifier, in_out);
break;

15
source/blender/nodes/intern/node_declaration.cc
View file

@ -354,6 +354,21 @@ static bool socket_type_to_static_decl_type(const eNodeSocketDatatype socket_typ
case SOCK_MATERIAL:
fn(TypeTag<decl::Material>());
return true;
case SOCK_FONT:
fn(TypeTag<decl::Font>());
return true;
case SOCK_SCENE:
fn(TypeTag<decl::Scene>());
return true;
case SOCK_TEXT_ID:
fn(TypeTag<decl::Text>());
return true;
case SOCK_MASK:
fn(TypeTag<decl::Mask>());
return true;
case SOCK_SOUND:
fn(TypeTag<decl::Sound>());
return true;
case SOCK_MENU:
fn(TypeTag<decl::Menu>());
return true;

168
source/blender/nodes/intern/node_socket.cc
View file

@ -29,7 +29,11 @@
#include "BKE_node_tree_update.hh"
#include "DNA_collection_types.h"
#include "DNA_mask_types.h"
#include "DNA_material_types.h"
#include "DNA_sound_types.h"
#include "DNA_text_types.h"
#include "DNA_vfont_types.h"
#include "RNA_access.hh"
@ -552,6 +556,11 @@ bool socket_type_always_single(const eNodeSocketDatatype socket_type)
case SOCK_CLOSURE:
case SOCK_BUNDLE:
case SOCK_STRING:
case SOCK_FONT:
case SOCK_SCENE:
case SOCK_TEXT_ID:
case SOCK_MASK:
case SOCK_SOUND:
return true;
case SOCK_CUSTOM:
case SOCK_FLOAT:
@ -712,6 +721,36 @@ void node_socket_init_default_value_data(eNodeSocketDatatype datatype, int subty
*data = dval;
break;
}
case SOCK_FONT: {
bNodeSocketValueFont *dval = MEM_callocN<bNodeSocketValueFont>("node socket value font");
dval->value = nullptr;
*data = dval;
break;
}
case SOCK_SCENE: {
bNodeSocketValueScene *dval = MEM_callocN<bNodeSocketValueScene>("node socket value scene");
dval->value = nullptr;
*data = dval;
break;
}
case SOCK_TEXT_ID: {
bNodeSocketValueText *dval = MEM_callocN<bNodeSocketValueText>("node socket value text");
dval->value = nullptr;
*data = dval;
break;
}
case SOCK_MASK: {
bNodeSocketValueMask *dval = MEM_callocN<bNodeSocketValueMask>("node socket value mask");
dval->value = nullptr;
*data = dval;
break;
}
case SOCK_SOUND: {
bNodeSocketValueSound *dval = MEM_callocN<bNodeSocketValueSound>("node socket value sound");
dval->value = nullptr;
*data = dval;
break;
}
case SOCK_CUSTOM:
case SOCK_GEOMETRY:
@ -813,6 +852,41 @@ void node_socket_copy_default_value_data(eNodeSocketDatatype datatype, void *to,
id_us_plus(reinterpret_cast<ID *>(toval->value));
break;
}
case SOCK_FONT: {
bNodeSocketValueFont *toval = (bNodeSocketValueFont *)to;
bNodeSocketValueFont *fromval = (bNodeSocketValueFont *)from;
*toval = *fromval;
id_us_plus(id_cast<ID *>(toval->value));
break;
}
case SOCK_SCENE: {
bNodeSocketValueScene *toval = (bNodeSocketValueScene *)to;
bNodeSocketValueScene *fromval = (bNodeSocketValueScene *)from;
*toval = *fromval;
id_us_plus(id_cast<ID *>(toval->value));
break;
}
case SOCK_TEXT_ID: {
bNodeSocketValueText *toval = (bNodeSocketValueText *)to;
bNodeSocketValueText *fromval = (bNodeSocketValueText *)from;
*toval = *fromval;
id_us_plus(id_cast<ID *>(toval->value));
break;
}
case SOCK_MASK: {
bNodeSocketValueMask *toval = (bNodeSocketValueMask *)to;
bNodeSocketValueMask *fromval = (bNodeSocketValueMask *)from;
*toval = *fromval;
id_us_plus(id_cast<ID *>(toval->value));
break;
}
case SOCK_SOUND: {
bNodeSocketValueSound *toval = (bNodeSocketValueSound *)to;
bNodeSocketValueSound *fromval = (bNodeSocketValueSound *)from;
*toval = *fromval;
id_us_plus(id_cast<ID *>(toval->value));
break;
}
case SOCK_CUSTOM:
case SOCK_GEOMETRY:
@ -1238,6 +1312,89 @@ static bke::bNodeSocketType *make_socket_type_material()
return socktype;
}
static bke::bNodeSocketType *make_socket_type_font()
{
bke::bNodeSocketType *socktype = make_standard_socket_type(SOCK_FONT, PROP_NONE);
socktype->base_cpp_type = &blender::CPPType::get<VFont *>();
socktype->get_base_cpp_value = [](const void *socket_value, void *r_value) {
*(VFont **)r_value = ((bNodeSocketValueFont *)socket_value)->value;
};
socktype->get_geometry_nodes_cpp_value = [](const void *socket_value) {
VFont *font = static_cast<const bNodeSocketValueFont *>(socket_value)->value;
return SocketValueVariant::From(font);
};
static SocketValueVariant default_value = SocketValueVariant::From(
static_cast<VFont *>(nullptr));
socktype->geometry_nodes_default_value = &default_value;
return socktype;
}
static bke::bNodeSocketType *make_socket_type_scene()
{
bke::bNodeSocketType *socktype = make_standard_socket_type(SOCK_SCENE, PROP_NONE);
socktype->base_cpp_type = &blender::CPPType::get<Scene *>();
socktype->get_base_cpp_value = [](const void *socket_value, void *r_value) {
*(Scene **)r_value = ((bNodeSocketValueScene *)socket_value)->value;
};
socktype->get_geometry_nodes_cpp_value = [](const void *socket_value) {
Scene *scene = static_cast<const bNodeSocketValueScene *>(socket_value)->value;
return SocketValueVariant::From(scene);
};
static SocketValueVariant default_value = SocketValueVariant::From(
static_cast<Scene *>(nullptr));
socktype->geometry_nodes_default_value = &default_value;
return socktype;
}
static bke::bNodeSocketType *make_socket_type_text()
{
bke::bNodeSocketType *socktype = make_standard_socket_type(SOCK_TEXT_ID, PROP_NONE);
socktype->base_cpp_type = &blender::CPPType::get<Text *>();
socktype->get_base_cpp_value = [](const void *socket_value, void *r_value) {
*(Text **)r_value = ((bNodeSocketValueText *)socket_value)->value;
};
socktype->get_geometry_nodes_cpp_value = [](const void *socket_value) {
Text *text = static_cast<const bNodeSocketValueText *>(socket_value)->value;
return SocketValueVariant::From(text);
};
static SocketValueVariant default_value = SocketValueVariant::From(static_cast<Text *>(nullptr));
socktype->geometry_nodes_default_value = &default_value;
return socktype;
}
static bke::bNodeSocketType *make_socket_type_mask()
{
bke::bNodeSocketType *socktype = make_standard_socket_type(SOCK_MASK, PROP_NONE);
socktype->base_cpp_type = &blender::CPPType::get<Mask *>();
socktype->get_base_cpp_value = [](const void *socket_value, void *r_value) {
*(Mask **)r_value = ((bNodeSocketValueMask *)socket_value)->value;
};
socktype->get_geometry_nodes_cpp_value = [](const void *socket_value) {
Mask *mask = static_cast<const bNodeSocketValueMask *>(socket_value)->value;
return SocketValueVariant::From(mask);
};
static SocketValueVariant default_value = SocketValueVariant::From(static_cast<Mask *>(nullptr));
socktype->geometry_nodes_default_value = &default_value;
return socktype;
}
static bke::bNodeSocketType *make_socket_type_sound()
{
bke::bNodeSocketType *socktype = make_standard_socket_type(SOCK_SOUND, PROP_NONE);
socktype->base_cpp_type = &blender::CPPType::get<bSound *>();
socktype->get_base_cpp_value = [](const void *socket_value, void *r_value) {
*(bSound **)r_value = ((bNodeSocketValueSound *)socket_value)->value;
};
socktype->get_geometry_nodes_cpp_value = [](const void *socket_value) {
bSound *sound = static_cast<const bNodeSocketValueSound *>(socket_value)->value;
return SocketValueVariant::From(sound);
};
static SocketValueVariant default_value = SocketValueVariant::From(
static_cast<bSound *>(nullptr));
socktype->geometry_nodes_default_value = &default_value;
return socktype;
}
void register_standard_node_socket_types()
{
/* Draw callbacks are set in `drawnode.cc` to avoid bad-level calls. */
@ -1302,17 +1459,18 @@ void register_standard_node_socket_types()
bke::node_register_socket_type(*make_standard_socket_type(SOCK_SHADER, PROP_NONE));
bke::node_register_socket_type(*make_socket_type_object());
bke::node_register_socket_type(*make_socket_type_geometry());
bke::node_register_socket_type(*make_socket_type_object());
bke::node_register_socket_type(*make_socket_type_collection());
bke::node_register_socket_type(*make_socket_type_texture());
bke::node_register_socket_type(*make_socket_type_image());
bke::node_register_socket_type(*make_socket_type_material());
bke::node_register_socket_type(*make_socket_type_font());
bke::node_register_socket_type(*make_socket_type_scene());
bke::node_register_socket_type(*make_socket_type_text());
bke::node_register_socket_type(*make_socket_type_mask());
bke::node_register_socket_type(*make_socket_type_sound());
bke::node_register_socket_type(*make_socket_type_bundle());
bke::node_register_socket_type(*make_socket_type_closure());