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

Cleanup: Move BKE_node to namespace

Browse source 
Move all header file into namespace.
Unnecessary namespaces was removed from implementations file.
Part of forward declarations in header was moved in the top part
of file just to do not have a lot of separate namespaces.

Pull Request: https://projects.blender.org/blender/blender/pulls/121637
This commit is contained in:
Iliya Katueshenock 2024-05-13 16:07:12 +02:00 • committed by Hans Goudey
parent 0d34f59854
commit 75d17b1db5
571 changed files with 3139 additions and 3137 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -47,6 +47,7 @@ struct World;
struct bContext;
struct bNode;
struct bNodeExecContext;
struct bNodeTreeExec;
struct bNodeExecData;
struct bNodeInstanceHash;
struct bNodeLink;
@ -57,6 +58,27 @@ struct bNodeTreeExec;
struct bNodeTreeType;
struct uiLayout;
namespace blender {
class CPPType;
namespace nodes {
class DNode;
class NodeMultiFunctionBuilder;
class GeoNodeExecParams;
class NodeDeclaration;
class NodeDeclarationBuilder;
class GatherAddNodeSearchParams;
class GatherLinkSearchOpParams;
struct NodeExtraInfoParams;
} // namespace nodes
namespace realtime_compositor {
class Context;
class NodeOperation;
class ShaderNode;
} // namespace realtime_compositor
} // namespace blender
namespace blender::bke {
/* -------------------------------------------------------------------- */
/** \name Node Type Definitions
* \{ */
@ -87,25 +109,6 @@ struct bNodeSocketTemplate {
/* Use `void *` for callbacks that require C++. This is rather ugly, but works well for now. This
* would not be necessary if we would use bNodeSocketType and bNodeType only in C++ code.
* However, achieving this requires quite a few changes currently. */
namespace blender {
class CPPType;
namespace nodes {
class DNode;
class NodeMultiFunctionBuilder;
class GeoNodeExecParams;
class NodeDeclaration;
class NodeDeclarationBuilder;
class GatherAddNodeSearchParams;
class GatherLinkSearchOpParams;
struct NodeExtraInfoParams;
} // namespace nodes
namespace realtime_compositor {
class Context;
class NodeOperation;
class ShaderNode;
} // namespace realtime_compositor
} // namespace blender
using NodeMultiFunctionBuildFunction = void (*)(blender::nodes::NodeMultiFunctionBuilder &builder);
using NodeGeometryExecFunction = void (*)(blender::nodes::GeoNodeExecParams params);
using NodeDeclareFunction = void (*)(blender::nodes::NodeDeclarationBuilder &builder);
@ -410,9 +413,8 @@ enum class NodeGroupColorTag {
Vector = 13,
};
struct bNodeTreeExec;
using bNodeClassCallback = void (*)(void *calldata, int nclass, const char *name);
struct bNodeTreeType {
int type; /* type identifier */
char idname[64]; /* identifier name */
@ -466,11 +468,12 @@ GHashIterator *ntreeTypeGetIterator();
/* Helper macros for iterating over tree types. */
#define NODE_TREE_TYPES_BEGIN(ntype) \
{ \
GHashIterator *__node_tree_type_iter__ = ntreeTypeGetIterator(); \
GHashIterator *__node_tree_type_iter__ = blender::bke::ntreeTypeGetIterator(); \
for (; !BLI_ghashIterator_done(__node_tree_type_iter__); \
BLI_ghashIterator_step(__node_tree_type_iter__)) \
{ \
bNodeTreeType *ntype = (bNodeTreeType *)BLI_ghashIterator_getValue(__node_tree_type_iter__);
blender::bke::bNodeTreeType *ntype = (blender::bke::bNodeTreeType *) \
BLI_ghashIterator_getValue(__node_tree_type_iter__);
#define NODE_TREE_TYPES_END \
} \
@ -562,10 +565,11 @@ GHashIterator *nodeTypeGetIterator();
/* Helper macros for iterating over node types. */
#define NODE_TYPES_BEGIN(ntype) \
{ \
GHashIterator *__node_type_iter__ = nodeTypeGetIterator(); \
GHashIterator *__node_type_iter__ = blender::bke::nodeTypeGetIterator(); \
for (; !BLI_ghashIterator_done(__node_type_iter__); \
BLI_ghashIterator_step(__node_type_iter__)) { \
bNodeType *ntype = (bNodeType *)BLI_ghashIterator_getValue(__node_type_iter__);
blender::bke::bNodeType *ntype = (blender::bke::bNodeType *)BLI_ghashIterator_getValue( \
__node_type_iter__);
#define NODE_TYPES_END \
} \
@ -587,12 +591,12 @@ const char *nodeStaticSocketLabel(int type, int subtype);
/* Helper macros for iterating over node types. */
#define NODE_SOCKET_TYPES_BEGIN(stype) \
{ \
GHashIterator *__node_socket_type_iter__ = nodeSocketTypeGetIterator(); \
GHashIterator *__node_socket_type_iter__ = blender::bke::nodeSocketTypeGetIterator(); \
for (; !BLI_ghashIterator_done(__node_socket_type_iter__); \
BLI_ghashIterator_step(__node_socket_type_iter__)) \
{ \
bNodeSocketType *stype = (bNodeSocketType *)BLI_ghashIterator_getValue( \
__node_socket_type_iter__);
blender::bke::bNodeSocketType *stype = (blender::bke::bNodeSocketType *) \
BLI_ghashIterator_getValue(__node_socket_type_iter__);
#define NODE_SOCKET_TYPES_END \
} \
@ -822,12 +826,12 @@ bool BKE_node_tree_iter_step(NodeTreeIterStore *ntreeiter, bNodeTree **r_nodetre
#define FOREACH_NODETREE_BEGIN(bmain, _nodetree, _id) \
{ \
NodeTreeIterStore _nstore; \
blender::bke::NodeTreeIterStore _nstore; \
bNodeTree *_nodetree; \
ID *_id; \
/* avoid compiler warning about unused variables */ \
BKE_node_tree_iter_init(&_nstore, bmain); \
while (BKE_node_tree_iter_step(&_nstore, &_nodetree, &_id) == true) { \
blender::bke::BKE_node_tree_iter_init(&_nstore, bmain); \
while (blender::bke::BKE_node_tree_iter_step(&_nstore, &_nodetree, &_id) == true) { \
if (_nodetree) {
#define FOREACH_NODETREE_END \
@ -1377,8 +1381,6 @@ void BKE_nodetree_remove_layer_n(bNodeTree *ntree, Scene *scene, int layer_index
void BKE_node_system_init();
void BKE_node_system_exit();
namespace blender::bke {
bNodeTree *ntreeAddTreeEmbedded(Main *bmain, ID *owner_id, const char *name, const char *idname);
/* Copy/free functions, need to manage ID users. */

8
source/blender/blenkernel/BKE_node_runtime.hh
View file

@ -23,7 +23,6 @@
struct bNode;
struct bNodeSocket;
struct bNodeTree;
struct bNodeType;
namespace blender::nodes {
struct FieldInferencingInterface;
@ -34,8 +33,9 @@ namespace anonymous_attribute_lifetime {
namespace aal = anonymous_attribute_lifetime;
} // namespace blender::nodes
namespace blender::bke {
struct bNodeType;
class bNodeTreeZones;
}
} // namespace blender::bke
namespace blender::bke::anonymous_attribute_inferencing {
struct AnonymousAttributeInferencingResult;
};
@ -414,14 +414,14 @@ inline const bNode *bNodeTree::node_by_id(const int32_t identifier) const
inline blender::Span<bNode *> bNodeTree::nodes_by_type(const blender::StringRefNull type_idname)
{
BLI_assert(blender::bke::node_tree_runtime::topology_cache_is_available(*this));
return this->runtime->nodes_by_type.lookup(nodeTypeFind(type_idname.c_str()));
return this->runtime->nodes_by_type.lookup(blender::bke::nodeTypeFind(type_idname.c_str()));
}
inline blender::Span<const bNode *> bNodeTree::nodes_by_type(
const blender::StringRefNull type_idname) const
{
BLI_assert(blender::bke::node_tree_runtime::topology_cache_is_available(*this));
return this->runtime->nodes_by_type.lookup(nodeTypeFind(type_idname.c_str()));
return this->runtime->nodes_by_type.lookup(blender::bke::nodeTypeFind(type_idname.c_str()));
}
inline blender::Span<const bNode *> bNodeTree::toposort_left_to_right() const

2
source/blender/blenkernel/intern/anim_data.cc
View file

@ -423,7 +423,7 @@ static void animdata_copy_id_action(Main *bmain,
BKE_id_copy(bmain, &adt->tmpact->id));
}
}
bNodeTree *ntree = ntreeFromID(id);
bNodeTree *ntree = blender::bke::ntreeFromID(id);
if (ntree) {
animdata_copy_id_action(bmain, &ntree->id, set_newid, do_linked_id);
}

4
source/blender/blenkernel/intern/bake_items_socket.cc
View file

@ -234,8 +234,8 @@ static void restore_data_blocks(const Span<GeometrySet *> geometries,
static void default_initialize_socket_value(const eNodeSocketDatatype socket_type, void *r_value)
{
const char *socket_idname = nodeStaticSocketType(socket_type, 0);
const bNodeSocketType *typeinfo = nodeSocketTypeFind(socket_idname);
const char *socket_idname = bke::nodeStaticSocketType(socket_type, 0);
const bke::bNodeSocketType *typeinfo = bke::nodeSocketTypeFind(socket_idname);
if (typeinfo->geometry_nodes_default_cpp_value) {
typeinfo->geometry_nodes_cpp_type->copy_construct(typeinfo->geometry_nodes_default_cpp_value,
r_value);

2
source/blender/blenkernel/intern/blender.cc
View file

@ -80,7 +80,7 @@ void BKE_blender_free()
BKE_ffmpeg_exit();
#endif
BKE_node_system_exit();
blender::bke::BKE_node_system_exit();
}
/** \} */

2
source/blender/blenkernel/intern/bpath.cc
View file

@ -103,7 +103,7 @@ void BKE_bpath_foreach_path_id(BPathForeachPathData *bpath_data, ID *id)
sizeof(id->library_weak_reference->library_filepath));
}
bNodeTree *embedded_node_tree = ntreeFromID(id);
bNodeTree *embedded_node_tree = blender::bke::ntreeFromID(id);
if (embedded_node_tree != nullptr) {
BKE_bpath_foreach_path_id(bpath_data, &embedded_node_tree->id);
}

102
source/blender/blenkernel/intern/grease_pencil_convert_legacy.cc
View file

@ -1052,7 +1052,7 @@ static bNodeTree *offset_radius_node_tree_add(ConversionData &conversion_data, L
using namespace blender;
/* NOTE: DO NOT translate this ID name, it is used to find a potentially already existing
* node-tree. */
bNodeTree *group = BKE_node_tree_add_in_lib(
bNodeTree *group = bke::BKE_node_tree_add_in_lib(
&conversion_data.bmain, library, OFFSET_RADIUS_NODETREE_NAME, "GeometryNodeTree");
if (!group->geometry_node_asset_traits) {
@ -1075,80 +1075,80 @@ static bNodeTree *offset_radius_node_tree_add(ConversionData &conversion_data, L
group->tree_interface.add_socket(
DATA_("Layer"), "", "NodeSocketString", NODE_INTERFACE_SOCKET_INPUT, nullptr);
bNode *group_output = nodeAddNode(nullptr, group, "NodeGroupOutput");
bNode *group_output = bke::nodeAddNode(nullptr, group, "NodeGroupOutput");
group_output->locx = 800;
group_output->locy = 160;
bNode *group_input = nodeAddNode(nullptr, group, "NodeGroupInput");
bNode *group_input = bke::nodeAddNode(nullptr, group, "NodeGroupInput");
group_input->locx = 0;
group_input->locy = 160;
bNode *set_curve_radius = nodeAddNode(nullptr, group, "GeometryNodeSetCurveRadius");
bNode *set_curve_radius = bke::nodeAddNode(nullptr, group, "GeometryNodeSetCurveRadius");
set_curve_radius->locx = 600;
set_curve_radius->locy = 160;
bNode *named_layer_selection = nodeAddNode(
bNode *named_layer_selection = bke::nodeAddNode(
nullptr, group, "GeometryNodeInputNamedLayerSelection");
named_layer_selection->locx = 200;
named_layer_selection->locy = 100;
bNode *input_radius = nodeAddNode(nullptr, group, "GeometryNodeInputRadius");
bNode *input_radius = bke::nodeAddNode(nullptr, group, "GeometryNodeInputRadius");
input_radius->locx = 0;
input_radius->locy = 0;
bNode *add = nodeAddNode(nullptr, group, "ShaderNodeMath");
bNode *add = bke::nodeAddNode(nullptr, group, "ShaderNodeMath");
add->custom1 = NODE_MATH_ADD;
add->locx = 200;
add->locy = 0;
bNode *clamp_radius = nodeAddNode(nullptr, group, "ShaderNodeClamp");
bNode *clamp_radius = bke::nodeAddNode(nullptr, group, "ShaderNodeClamp");
clamp_radius->locx = 400;
clamp_radius->locy = 0;
bNodeSocket *sock_max = nodeFindSocket(clamp_radius, SOCK_IN, "Max");
bNodeSocket *sock_max = bke::nodeFindSocket(clamp_radius, SOCK_IN, "Max");
static_cast<bNodeSocketValueFloat *>(sock_max->default_value)->value = FLT_MAX;
nodeAddLink(group,
group_input,
nodeFindSocket(group_input, SOCK_OUT, "Socket_0"),
set_curve_radius,
nodeFindSocket(set_curve_radius, SOCK_IN, "Curve"));
nodeAddLink(group,
set_curve_radius,
nodeFindSocket(set_curve_radius, SOCK_OUT, "Curve"),
group_output,
nodeFindSocket(group_output, SOCK_IN, "Socket_1"));
bke::nodeAddLink(group,
group_input,
bke::nodeFindSocket(group_input, SOCK_OUT, "Socket_0"),
set_curve_radius,
bke::nodeFindSocket(set_curve_radius, SOCK_IN, "Curve"));
bke::nodeAddLink(group,
set_curve_radius,
bke::nodeFindSocket(set_curve_radius, SOCK_OUT, "Curve"),
group_output,
bke::nodeFindSocket(group_output, SOCK_IN, "Socket_1"));
nodeAddLink(group,
group_input,
nodeFindSocket(group_input, SOCK_OUT, "Socket_3"),
named_layer_selection,
nodeFindSocket(named_layer_selection, SOCK_IN, "Name"));
nodeAddLink(group,
named_layer_selection,
nodeFindSocket(named_layer_selection, SOCK_OUT, "Selection"),
set_curve_radius,
nodeFindSocket(set_curve_radius, SOCK_IN, "Selection"));
bke::nodeAddLink(group,
group_input,
bke::nodeFindSocket(group_input, SOCK_OUT, "Socket_3"),
named_layer_selection,
bke::nodeFindSocket(named_layer_selection, SOCK_IN, "Name"));
bke::nodeAddLink(group,
named_layer_selection,
bke::nodeFindSocket(named_layer_selection, SOCK_OUT, "Selection"),
set_curve_radius,
bke::nodeFindSocket(set_curve_radius, SOCK_IN, "Selection"));
nodeAddLink(group,
group_input,
nodeFindSocket(group_input, SOCK_OUT, "Socket_2"),
add,
nodeFindSocket(add, SOCK_IN, "Value"));
nodeAddLink(group,
input_radius,
nodeFindSocket(input_radius, SOCK_OUT, "Radius"),
add,
nodeFindSocket(add, SOCK_IN, "Value_001"));
nodeAddLink(group,
add,
nodeFindSocket(add, SOCK_OUT, "Value"),
clamp_radius,
nodeFindSocket(clamp_radius, SOCK_IN, "Value"));
nodeAddLink(group,
clamp_radius,
nodeFindSocket(clamp_radius, SOCK_OUT, "Result"),
set_curve_radius,
nodeFindSocket(set_curve_radius, SOCK_IN, "Radius"));
bke::nodeAddLink(group,
group_input,
bke::nodeFindSocket(group_input, SOCK_OUT, "Socket_2"),
add,
bke::nodeFindSocket(add, SOCK_IN, "Value"));
bke::nodeAddLink(group,
input_radius,
bke::nodeFindSocket(input_radius, SOCK_OUT, "Radius"),
add,
bke::nodeFindSocket(add, SOCK_IN, "Value_001"));
bke::nodeAddLink(group,
add,
bke::nodeFindSocket(add, SOCK_OUT, "Value"),
clamp_radius,
bke::nodeFindSocket(clamp_radius, SOCK_IN, "Value"));
bke::nodeAddLink(group,
clamp_radius,
bke::nodeFindSocket(clamp_radius, SOCK_OUT, "Result"),
set_curve_radius,
bke::nodeFindSocket(set_curve_radius, SOCK_IN, "Radius"));
LISTBASE_FOREACH (bNode *, node, &group->nodes) {
nodeSetSelected(node, false);
bke::nodeSetSelected(node, false);
}
return group;
@ -2831,7 +2831,7 @@ static void legacy_gpencil_sanitize_annotations(Main &bmain)
ID *id_iter;
FOREACH_MAIN_ID_BEGIN (&bmain, id_iter) {
if (bNodeTree *node_tree = ntreeFromID(id_iter)) {
if (bNodeTree *node_tree = bke::ntreeFromID(id_iter)) {
sanitize_gpv2_annotation(&node_tree->gpd);
}
}

2
source/blender/blenkernel/intern/idtype.cc
View file

@ -380,7 +380,7 @@ void BKE_idtype_id_foreach_cache(ID *id,
}
/* Handle 'private IDs'. */
bNodeTree *nodetree = ntreeFromID(id);
bNodeTree *nodetree = blender::bke::ntreeFromID(id);
if (nodetree != nullptr) {
type_info = BKE_idtype_get_info_from_id(&nodetree->id);
if (type_info == nullptr) {

11
source/blender/blenkernel/intern/lib_id.cc
View file

@ -397,7 +397,7 @@ void BKE_id_newptr_and_tag_clear(ID *id)
if (key != nullptr) {
BKE_id_newptr_and_tag_clear(&key->id);
}
bNodeTree *ntree = ntreeFromID(id);
bNodeTree *ntree = blender::bke::ntreeFromID(id);
if (ntree != nullptr) {
BKE_id_newptr_and_tag_clear(&ntree->id);
}
@ -540,7 +540,8 @@ void BKE_lib_id_make_local_generic(Main *bmain, ID *id, const int flags)
if (key && key_new) {
ID_NEW_SET(key, key_new);
}
bNodeTree *ntree = ntreeFromID(id), *ntree_new = ntreeFromID(id_new);
bNodeTree *ntree = blender::bke::ntreeFromID(id),
*ntree_new = blender::bke::ntreeFromID(id_new);
if (ntree && ntree_new) {
ID_NEW_SET(ntree, ntree_new);
}
@ -879,8 +880,8 @@ static void id_swap(Main *bmain,
id_b->recalc = id_a_back.recalc;
}
id_embedded_swap((ID **)BKE_ntree_ptr_from_id(id_a),
(ID **)BKE_ntree_ptr_from_id(id_b),
id_embedded_swap((ID **)blender::bke::BKE_ntree_ptr_from_id(id_a),
(ID **)blender::bke::BKE_ntree_ptr_from_id(id_b),
do_full_id,
remapper_id_a,
remapper_id_b);
@ -1946,7 +1947,7 @@ void BKE_library_make_local(Main *bmain,
const bool do_skip = (id && !BKE_idtype_idcode_is_linkable(GS(id->name)));
for (; id; id = static_cast<ID *>(id->next)) {
ID *ntree = (ID *)ntreeFromID(id);
ID *ntree = (ID *)blender::bke::ntreeFromID(id);
id->tag &= ~LIB_TAG_DOIT;
if (ntree != nullptr) {

6
source/blender/blenkernel/intern/lib_override.cc
View file

@ -2210,7 +2210,7 @@ static bool lib_override_library_resync(Main *bmain,
reinterpret_cast<Scene *>(reference_id)->master_collection);
break;
case ID_NT:
reference_id = reinterpret_cast<ID *>(ntreeFromID(id));
reference_id = reinterpret_cast<ID *>(blender::bke::ntreeFromID(id));
break;
default:
break;
@ -3797,7 +3797,7 @@ void BKE_lib_override_library_make_local(Main *bmain, ID *id)
}
}
bNodeTree *node_tree = ntreeFromID(id);
bNodeTree *node_tree = blender::bke::ntreeFromID(id);
if (node_tree != nullptr) {
node_tree->id.flag &= ~LIB_EMBEDDED_DATA_LIB_OVERRIDE;
}
@ -4585,7 +4585,7 @@ void BKE_lib_override_library_main_operations_create(Main *bmain,
id->tag |= LIB_TAG_LIBOVERRIDE_AUTOREFRESH;
}
}
if (bNodeTree *ntree = ntreeFromID(id)) {
if (bNodeTree *ntree = blender::bke::ntreeFromID(id)) {
if (ntree->id.tag & LIB_TAG_LIBOVERRIDE_AUTOREFRESH) {
ntree->id.tag &= ~LIB_TAG_LIBOVERRIDE_AUTOREFRESH;
id->tag |= LIB_TAG_LIBOVERRIDE_AUTOREFRESH;

2
source/blender/blenkernel/intern/lib_query.cc
View file

@ -462,7 +462,7 @@ uint64_t BKE_library_id_can_use_filter_id(const ID *owner_id,
/* Casting to non const.
* TODO(jbakker): We should introduce a ntree_id_has_tree function as we are actually not
* interested in the result. */
if (ntreeFromID(const_cast<ID *>(owner_id))) {
if (blender::bke::ntreeFromID(const_cast<ID *>(owner_id))) {
return FILTER_ID_ALL;
}

4
source/blender/blenkernel/intern/lib_query_test.cc
View file

@ -126,7 +126,7 @@ template<typename TestData> class Context {
CLG_init();
BKE_idtype_init();
RNA_init();
BKE_node_system_init();
bke::BKE_node_system_init();
BKE_appdir_init();
IMB_init();
@ -137,7 +137,7 @@ template<typename TestData> class Context {
{
test_data.teardown();
BKE_node_system_exit();
bke::BKE_node_system_exit();
RNA_exit();
IMB_exit();
BKE_appdir_exit();

2
source/blender/blenkernel/intern/lib_remap.cc
View file

@ -426,7 +426,7 @@ static void libblock_remap_data_postprocess_obdata_relink(Main *bmain, Object *o
static void libblock_remap_data_postprocess_nodetree_update(Main *bmain, ID *new_id)
{
/* Update all group nodes using a node group. */
ntreeUpdateAllUsers(bmain, new_id);
blender::bke::ntreeUpdateAllUsers(bmain, new_id);
}
static void libblock_remap_data_update_tags(ID *old_id, ID *new_id, IDRemap *id_remap_data)

4
source/blender/blenkernel/intern/lib_remap_test.cc
View file

@ -134,7 +134,7 @@ template<typename TestData> class Context {
CLG_init();
BKE_idtype_init();
RNA_init();
BKE_node_system_init();
bke::BKE_node_system_init();
BKE_appdir_init();
IMB_init();
@ -145,7 +145,7 @@ template<typename TestData> class Context {
{
test_data.teardown();
BKE_node_system_exit();
bke::BKE_node_system_exit();
RNA_exit();
IMB_exit();
BKE_appdir_exit();

6
source/blender/blenkernel/intern/light.cc
View file

@ -69,7 +69,7 @@ static void light_copy_data(Main *bmain,
if (la_src->nodetree) {
if (is_localized) {
la_dst->nodetree = ntreeLocalize(la_src->nodetree, &la_dst->id);
la_dst->nodetree = blender::bke::ntreeLocalize(la_src->nodetree, &la_dst->id);
}
else {
BKE_id_copy_in_lib(bmain,
@ -95,7 +95,7 @@ static void light_free_data(ID *id)
/* is no lib link block, but light extension */
if (la->nodetree) {
ntreeFreeEmbeddedTree(la->nodetree);
blender::bke::ntreeFreeEmbeddedTree(la->nodetree);
MEM_freeN(la->nodetree);
la->nodetree = nullptr;
}
@ -142,7 +142,7 @@ static void light_blend_write(BlendWriter *writer, ID *id, const void *id_addres
temp_embedded_id_buffer, &la->nodetree->id, BLO_write_is_undo(writer));
BLO_write_struct_at_address(
writer, bNodeTree, la->nodetree, BLO_write_get_id_buffer_temp_id(temp_embedded_id_buffer));
ntreeBlendWrite(writer, (bNodeTree *)BLO_write_get_id_buffer_temp_id(temp_embedded_id_buffer));
blender::bke::ntreeBlendWrite(writer, (bNodeTree *)BLO_write_get_id_buffer_temp_id(temp_embedded_id_buffer));
BLO_write_destroy_id_buffer(&temp_embedded_id_buffer);
}

16
source/blender/blenkernel/intern/linestyle.cc
View file

@ -114,7 +114,7 @@ static void linestyle_free_data(ID *id)
/* is no lib link block, but linestyle extension */
if (linestyle->nodetree) {
ntreeFreeEmbeddedTree(linestyle->nodetree);
blender::bke::ntreeFreeEmbeddedTree(linestyle->nodetree);
MEM_freeN(linestyle->nodetree);
linestyle->nodetree = nullptr;
}
@ -450,7 +450,7 @@ static void linestyle_blend_write(BlendWriter *writer, ID *id, const void *id_ad
bNodeTree,
linestyle->nodetree,
BLO_write_get_id_buffer_temp_id(temp_embedded_id_buffer));
ntreeBlendWrite(
blender::bke::ntreeBlendWrite(
writer,
reinterpret_cast<bNodeTree *>(BLO_write_get_id_buffer_temp_id(temp_embedded_id_buffer)));
BLO_write_destroy_id_buffer(&temp_embedded_id_buffer);
@ -1940,30 +1940,30 @@ void BKE_linestyle_default_shader(const bContext *C, FreestyleLineStyle *linesty
ntree = blender::bke::ntreeAddTreeEmbedded(
nullptr, &linestyle->id, "stroke_shader", "ShaderNodeTree");
uv_along_stroke = nodeAddStaticNode(C, ntree, SH_NODE_UVALONGSTROKE);
uv_along_stroke = blender::bke::nodeAddStaticNode(C, ntree, SH_NODE_UVALONGSTROKE);
uv_along_stroke->locx = 0.0f;
uv_along_stroke->locy = 300.0f;
uv_along_stroke->custom1 = 0; /* use_tips */
input_texture = nodeAddStaticNode(C, ntree, SH_NODE_TEX_IMAGE);
input_texture = blender::bke::nodeAddStaticNode(C, ntree, SH_NODE_TEX_IMAGE);
input_texture->locx = 200.0f;
input_texture->locy = 300.0f;
output_linestyle = nodeAddStaticNode(C, ntree, SH_NODE_OUTPUT_LINESTYLE);
output_linestyle = blender::bke::nodeAddStaticNode(C, ntree, SH_NODE_OUTPUT_LINESTYLE);
output_linestyle->locx = 400.0f;
output_linestyle->locy = 300.0f;
output_linestyle->custom1 = MA_RAMP_BLEND;
output_linestyle->custom2 = 0; /* use_clamp */
nodeSetActive(ntree, input_texture);
blender::bke::nodeSetActive(ntree, input_texture);
fromsock = static_cast<bNodeSocket *>(BLI_findlink(&uv_along_stroke->outputs, 0)); /* UV */
tosock = static_cast<bNodeSocket *>(BLI_findlink(&input_texture->inputs, 0)); /* UV */
nodeAddLink(ntree, uv_along_stroke, fromsock, input_texture, tosock);
blender::bke::nodeAddLink(ntree, uv_along_stroke, fromsock, input_texture, tosock);
fromsock = static_cast<bNodeSocket *>(BLI_findlink(&input_texture->outputs, 0)); /* Color */
tosock = static_cast<bNodeSocket *>(BLI_findlink(&output_linestyle->inputs, 0)); /* Color */
nodeAddLink(ntree, input_texture, fromsock, output_linestyle, tosock);
blender::bke::nodeAddLink(ntree, input_texture, fromsock, output_linestyle, tosock);
BKE_ntree_update_main_tree(CTX_data_main(C), ntree, nullptr);
}

44
source/blender/blenkernel/intern/material.cc
View file

@ -107,7 +107,7 @@ static void material_copy_data(Main *bmain,
if (material_src->nodetree != nullptr) {
if (is_localized) {
material_dst->nodetree = ntreeLocalize(material_src->nodetree, &material_dst->id);
material_dst->nodetree = blender::bke::ntreeLocalize(material_src->nodetree, &material_dst->id);
}
else {
BKE_id_copy_in_lib(bmain,
@ -152,7 +152,7 @@ static void material_free_data(ID *id)
/* is no lib link block, but material extension */
if (material->nodetree) {
ntreeFreeEmbeddedTree(material->nodetree);
blender::bke::ntreeFreeEmbeddedTree(material->nodetree);
MEM_freeN(material->nodetree);
material->nodetree = nullptr;
}
@ -206,7 +206,7 @@ static void material_blend_write(BlendWriter *writer, ID *id, const void *id_add
temp_embedded_id_buffer, &ma->nodetree->id, BLO_write_is_undo(writer));
BLO_write_struct_at_address(
writer, bNodeTree, ma->nodetree, BLO_write_get_id_buffer_temp_id(temp_embedded_id_buffer));
ntreeBlendWrite(
blender::bke::ntreeBlendWrite(
writer,
reinterpret_cast<bNodeTree *>(BLO_write_get_id_buffer_temp_id(temp_embedded_id_buffer)));
BLO_write_destroy_id_buffer(&temp_embedded_id_buffer);
@ -1988,24 +1988,24 @@ static void material_default_surface_init(Material *ma)
nullptr, &ma->id, "Shader Nodetree", ntreeType_Shader->idname);
ma->use_nodes = true;
bNode *principled = nodeAddStaticNode(nullptr, ntree, SH_NODE_BSDF_PRINCIPLED);
bNodeSocket *base_color = nodeFindSocket(principled, SOCK_IN, "Base Color");
bNode *principled = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_BSDF_PRINCIPLED);
bNodeSocket *base_color = blender::bke::nodeFindSocket(principled, SOCK_IN, "Base Color");
copy_v3_v3(((bNodeSocketValueRGBA *)base_color->default_value)->value, &ma->r);
bNode *output = nodeAddStaticNode(nullptr, ntree, SH_NODE_OUTPUT_MATERIAL);
bNode *output = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_OUTPUT_MATERIAL);
nodeAddLink(ntree,
blender::bke::nodeAddLink(ntree,
principled,
nodeFindSocket(principled, SOCK_OUT, "BSDF"),
blender::bke::nodeFindSocket(principled, SOCK_OUT, "BSDF"),
output,
nodeFindSocket(output, SOCK_IN, "Surface"));
blender::bke::nodeFindSocket(output, SOCK_IN, "Surface"));
principled->locx = 10.0f;
principled->locy = 300.0f;
output->locx = 300.0f;
output->locy = 300.0f;
nodeSetActive(ntree, output);
blender::bke::nodeSetActive(ntree, output);
}
static void material_default_volume_init(Material *ma)
@ -2016,21 +2016,21 @@ static void material_default_volume_init(Material *ma)
nullptr, &ma->id, "Shader Nodetree", ntreeType_Shader->idname);
ma->use_nodes = true;
bNode *principled = nodeAddStaticNode(nullptr, ntree, SH_NODE_VOLUME_PRINCIPLED);
bNode *output = nodeAddStaticNode(nullptr, ntree, SH_NODE_OUTPUT_MATERIAL);
bNode *principled = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_VOLUME_PRINCIPLED);
bNode *output = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_OUTPUT_MATERIAL);
nodeAddLink(ntree,
blender::bke::nodeAddLink(ntree,
principled,
nodeFindSocket(principled, SOCK_OUT, "Volume"),
blender::bke::nodeFindSocket(principled, SOCK_OUT, "Volume"),
output,
nodeFindSocket(output, SOCK_IN, "Volume"));
blender::bke::nodeFindSocket(output, SOCK_IN, "Volume"));
principled->locx = 10.0f;
principled->locy = 300.0f;
output->locx = 300.0f;
output->locy = 300.0f;
nodeSetActive(ntree, output);
blender::bke::nodeSetActive(ntree, output);
}
static void material_default_holdout_init(Material *ma)
@ -2041,21 +2041,21 @@ static void material_default_holdout_init(Material *ma)
nullptr, &ma->id, "Shader Nodetree", ntreeType_Shader->idname);
ma->use_nodes = true;
bNode *holdout = nodeAddStaticNode(nullptr, ntree, SH_NODE_HOLDOUT);
bNode *output = nodeAddStaticNode(nullptr, ntree, SH_NODE_OUTPUT_MATERIAL);
bNode *holdout = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_HOLDOUT);
bNode *output = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_OUTPUT_MATERIAL);
nodeAddLink(ntree,
blender::bke::nodeAddLink(ntree,
holdout,
nodeFindSocket(holdout, SOCK_OUT, "Holdout"),
blender::bke::nodeFindSocket(holdout, SOCK_OUT, "Holdout"),
output,
nodeFindSocket(output, SOCK_IN, "Surface"));
blender::bke::nodeFindSocket(output, SOCK_IN, "Surface"));
holdout->locx = 10.0f;
holdout->locy = 300.0f;
output->locx = 300.0f;
output->locy = 300.0f;
nodeSetActive(ntree, output);
blender::bke::nodeSetActive(ntree, output);
}
Material *BKE_material_default_empty()

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

File diff suppressed because it is too large Load diff

4
source/blender/blenkernel/intern/node_runtime.cc
View file

@ -289,7 +289,7 @@ static Vector<const bNode *> get_implicit_origin_nodes(const bNodeTree &ntree, b
/* Can't use #zone_type.get_corresponding_input because that expects the topology cache to be
* build already, but we are still building it here. */
for (const bNode *input_node :
ntree.runtime->nodes_by_type.lookup(nodeTypeFind(zone_type.input_idname.c_str())))
ntree.runtime->nodes_by_type.lookup(bke::nodeTypeFind(zone_type.input_idname.c_str())))
{
if (zone_type.get_corresponding_output_id(*input_node) == node.identifier) {
origin_nodes.append(input_node);
@ -491,7 +491,7 @@ static void update_direct_frames_childrens(const bNodeTree &ntree)
static void update_group_output_node(const bNodeTree &ntree)
{
bNodeTreeRuntime &tree_runtime = *ntree.runtime;
const bNodeType *node_type = nodeTypeFind("NodeGroupOutput");
const bke::bNodeType *node_type = bke::nodeTypeFind("NodeGroupOutput");
const Span<bNode *> group_output_nodes = tree_runtime.nodes_by_type.lookup(node_type);
if (group_output_nodes.is_empty()) {
tree_runtime.group_output_node = nullptr;

4
source/blender/blenkernel/intern/node_tree_anonymous_attributes.cc
View file

@ -32,7 +32,7 @@ static const aal::RelationsInNode &get_relations_in_node(const bNode &node, Reso
if (node.is_group()) {
if (const bNodeTree *group = reinterpret_cast<const bNodeTree *>(node.id)) {
/* Undefined tree types have no relations. */
if (!ntreeIsRegistered(group)) {
if (!bke::ntreeIsRegistered(group)) {
return scope.construct<aal::RelationsInNode>();
}
/* It's possible that the inferencing failed on the group. */
@ -273,7 +273,7 @@ static AnonymousAttributeInferencingResult analyze_anonymous_attribute_usages(
/* Find input field and geometry sources. */
for (const int i : tree.interface_inputs().index_range()) {
const bNodeTreeInterfaceSocket &interface_socket = *tree.interface_inputs()[i];
const bNodeSocketType *typeinfo = nodeSocketTypeFind(interface_socket.socket_type);
const bNodeSocketType *typeinfo = bke::nodeSocketTypeFind(interface_socket.socket_type);
const eNodeSocketDatatype type = typeinfo ? eNodeSocketDatatype(typeinfo->type) : SOCK_CUSTOM;
if (type == SOCK_GEOMETRY) {
all_geometry_sources.append_and_get_index({InputGeometrySource{i}});

2
source/blender/blenkernel/intern/node_tree_field_inferencing.cc
View file

@ -117,7 +117,7 @@ static const FieldInferencingInterface &get_node_field_inferencing_interface(con
static const FieldInferencingInterface empty_interface;
return empty_interface;
}
if (!ntreeIsRegistered(group)) {
if (!bke::ntreeIsRegistered(group)) {
/* This can happen when there is a linked node group that was not found (see #92799). */
return get_dummy_field_inferencing_interface(node, scope);
}

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

@ -43,13 +43,13 @@ static const char *try_get_supported_socket_type(const StringRef socket_type)
{
/* Make a copy of the string for `.c_str()` until the socket type map uses C++ types. */
const std::string idname(socket_type);
const bNodeSocketType *typeinfo = nodeSocketTypeFind(idname.c_str());
const blender::bke::bNodeSocketType *typeinfo = bke::nodeSocketTypeFind(idname.c_str());
if (typeinfo == nullptr) {
return nullptr;
}
/* For builtin socket types only the base type is supported. */
if (nodeIsStaticSocketType(typeinfo)) {
return nodeStaticSocketType(typeinfo->type, PROP_NONE);
return bke::nodeStaticSocketType(typeinfo->type, PROP_NONE);
}
return typeinfo->idname;
}
@ -645,14 +645,14 @@ static Span<bNodeTreeInterfaceItem *> item_children(bNodeTreeInterfaceItem &item
using namespace blender::bke::node_interface;
bNodeSocketType *bNodeTreeInterfaceSocket::socket_typeinfo() const
blender::bke::bNodeSocketType *bNodeTreeInterfaceSocket::socket_typeinfo() const
{
return nodeSocketTypeFind(socket_type);
return blender::bke::nodeSocketTypeFind(socket_type);
}
blender::ColorGeometry4f bNodeTreeInterfaceSocket::socket_color() const
{
bNodeSocketType *typeinfo = this->socket_typeinfo();
blender::bke::bNodeSocketType *typeinfo = this->socket_typeinfo();
if (typeinfo && typeinfo->draw_color_simple) {
float color[4];
typeinfo->draw_color_simple(typeinfo, color);
@ -1070,7 +1070,7 @@ bNodeTreeInterfaceSocket *add_interface_socket_from_node(bNodeTree &ntree,
if (iosock == nullptr) {
return nullptr;
}
const bNodeSocketType *typeinfo = iosock->socket_typeinfo();
const blender::bke::bNodeSocketType *typeinfo = iosock->socket_typeinfo();
if (typeinfo->interface_from_socket) {
typeinfo->interface_from_socket(&ntree.id, iosock, &from_node, &from_sock);
UNUSED_VARS(from_sock);

4
source/blender/blenkernel/intern/node_tree_update.cc
View file

@ -564,9 +564,9 @@ class NodeTreeMainUpdater {
void update_individual_nodes(bNodeTree &ntree)
{
for (bNode *node : ntree.all_nodes()) {
blender::bke::nodeDeclarationEnsure(&ntree, node);
bke::nodeDeclarationEnsure(&ntree, node);
if (this->should_update_individual_node(ntree, *node)) {
bNodeType &ntype = *node->typeinfo;
bke::bNodeType &ntype = *node->typeinfo;
if (ntype.group_update_func) {
ntype.group_update_func(&ntree, node);
}

4
source/blender/blenkernel/intern/scene.cc
View file

@ -392,7 +392,7 @@ static void scene_free_data(ID *id)
/* is no lib link block, but scene extension */
if (scene->nodetree) {
ntreeFreeEmbeddedTree(scene->nodetree);
blender::bke::ntreeFreeEmbeddedTree(scene->nodetree);
MEM_freeN(scene->nodetree);
scene->nodetree = nullptr;
}
@ -1135,7 +1135,7 @@ static void scene_blend_write(BlendWriter *writer, ID *id, const void *id_addres
/* Set deprecated chunksize for forward compatibility. */
temp_nodetree->chunksize = 256;
BLO_write_struct_at_address(writer, bNodeTree, sce->nodetree, temp_nodetree);
ntreeBlendWrite(writer, temp_nodetree);
blender::bke::ntreeBlendWrite(writer, temp_nodetree);
}
BKE_color_managed_view_settings_blend_write(writer, &sce->view_settings);

6
source/blender/blenkernel/intern/texture.cc
View file

@ -92,7 +92,7 @@ static void texture_copy_data(Main *bmain,
}
if (is_localized) {
texture_dst->nodetree = ntreeLocalize(texture_src->nodetree, &texture_dst->id);
texture_dst->nodetree = blender::bke::ntreeLocalize(texture_src->nodetree, &texture_dst->id);
}
else {
BKE_id_copy_in_lib(bmain,
@ -122,7 +122,7 @@ static void texture_free_data(ID *id)
/* is no lib link block, but texture extension */
if (texture->nodetree) {
ntreeFreeEmbeddedTree(texture->nodetree);
blender::bke::ntreeFreeEmbeddedTree(texture->nodetree);
MEM_freeN(texture->nodetree);
texture->nodetree = nullptr;
}
@ -172,7 +172,7 @@ static void texture_blend_write(BlendWriter *writer, ID *id, const void *id_addr
bNodeTree,
tex->nodetree,
BLO_write_get_id_buffer_temp_id(temp_embedded_id_buffer));
ntreeBlendWrite(
blender::bke::ntreeBlendWrite(
writer,
reinterpret_cast<bNodeTree *>(BLO_write_get_id_buffer_temp_id(temp_embedded_id_buffer)));
BLO_write_destroy_id_buffer(&temp_embedded_id_buffer);

6
source/blender/blenkernel/intern/world.cc
View file

@ -51,7 +51,7 @@ static void world_free_data(ID *id)
/* is no lib link block, but world extension */
if (wrld->nodetree) {
ntreeFreeEmbeddedTree(wrld->nodetree);
blender::bke::ntreeFreeEmbeddedTree(wrld->nodetree);
MEM_freeN(wrld->nodetree);
wrld->nodetree = nullptr;
}
@ -97,7 +97,7 @@ static void world_copy_data(Main *bmain,
if (wrld_src->nodetree) {
if (is_localized) {
wrld_dst->nodetree = ntreeLocalize(wrld_src->nodetree, &wrld_dst->id);
wrld_dst->nodetree = blender::bke::ntreeLocalize(wrld_src->nodetree, &wrld_dst->id);
}
else {
BKE_id_copy_in_lib(bmain,
@ -160,7 +160,7 @@ static void world_blend_write(BlendWriter *writer, ID *id, const void *id_addres
bNodeTree,
wrld->nodetree,
BLO_write_get_id_buffer_temp_id(temp_embedded_id_buffer));
ntreeBlendWrite(writer, (bNodeTree *)BLO_write_get_id_buffer_temp_id(temp_embedded_id_buffer));
blender::bke::ntreeBlendWrite(writer, (bNodeTree *)BLO_write_get_id_buffer_temp_id(temp_embedded_id_buffer));
BLO_write_destroy_id_buffer(&temp_embedded_id_buffer);
}

4
source/blender/blenloader/intern/blend_validate.cc
View file

@ -218,7 +218,7 @@ void BLO_main_validate_embedded_liboverrides(Main *bmain, ReportList * /*reports
{
ID *id_iter;
FOREACH_MAIN_ID_BEGIN (bmain, id_iter) {
bNodeTree *node_tree = ntreeFromID(id_iter);
bNodeTree *node_tree = blender::bke::ntreeFromID(id_iter);
if (node_tree) {
if (node_tree->id.flag & LIB_EMBEDDED_DATA_LIB_OVERRIDE) {
if (!ID_IS_OVERRIDE_LIBRARY(id_iter)) {
@ -249,7 +249,7 @@ void BLO_main_validate_embedded_flag(Main *bmain, ReportList * /*reports*/)
id_iter->flag &= ~LIB_EMBEDDED_DATA;
}
bNodeTree *node_tree = ntreeFromID(id_iter);
bNodeTree *node_tree = blender::bke::ntreeFromID(id_iter);
if (node_tree) {
if ((node_tree->id.flag & LIB_EMBEDDED_DATA) == 0) {
CLOG_ERROR(&LOG,

6
source/blender/blenloader/intern/readfile.cc
View file

@ -1892,7 +1892,7 @@ static void after_liblink_id_embedded_id_process(BlendLibReader *reader, ID *id)
{
/* Handle 'private IDs'. */
bNodeTree *nodetree = ntreeFromID(id);
bNodeTree *nodetree = blender::bke::ntreeFromID(id);
if (nodetree != nullptr) {
after_liblink_id_process(reader, &nodetree->id);
@ -1971,13 +1971,13 @@ static void direct_link_id_embedded_id(BlendDataReader *reader,
ID *id_old)
{
/* Handle 'private IDs'. */
bNodeTree **nodetree = BKE_ntree_ptr_from_id(id);
bNodeTree **nodetree = blender::bke::BKE_ntree_ptr_from_id(id);
if (nodetree != nullptr && *nodetree != nullptr) {
BLO_read_struct(reader, bNodeTree, nodetree);
direct_link_id_common(reader,
current_library,
(ID *)*nodetree,
id_old != nullptr ? (ID *)ntreeFromID(id_old) : nullptr,
id_old != nullptr ? (ID *)blender::bke::ntreeFromID(id_old) : nullptr,
0);
blender::bke::ntreeBlendReadData(reader, id, *nodetree);
}

4
source/blender/blenloader/intern/versioning_250.cc
View file

@ -1035,7 +1035,7 @@ void blo_do_versions_250(FileData *fd, Library * /*lib*/, Main *bmain)
bNode *node = static_cast<bNode *>(ntree->nodes.first);
while (node) {
nodeUniqueName(ntree, node);
blender::bke::nodeUniqueName(ntree, node);
node = node->next;
}
@ -1876,7 +1876,7 @@ void blo_do_versions_250(FileData *fd, Library * /*lib*/, Main *bmain)
}
}
LISTBASE_FOREACH (bNodeSocket *, sock, &node->outputs) {
if (nodeCountSocketLinks(ntree, sock) == 0 &&
if (blender::bke::nodeCountSocketLinks(ntree, sock) == 0 &&
!((sock->flag & (SOCK_HIDDEN | SOCK_UNAVAIL)) != 0))
{
bNodeSocket *gsock = do_versions_node_group_add_socket_2_56_2(

26
source/blender/blenloader/intern/versioning_260.cc
View file

@ -315,8 +315,8 @@ static void do_versions_nodetree_multi_file_output_format_2_62_1(Scene *sce, bNo
}
}
nodeRemoveSocket(ntree, node, old_image);
nodeRemoveSocket(ntree, node, old_z);
blender::bke::nodeRemoveSocket(ntree, node, old_image);
blender::bke::nodeRemoveSocket(ntree, node, old_z);
if (old_data) {
MEM_freeN(old_data);
}
@ -861,28 +861,28 @@ static const char *node_socket_get_static_idname(bNodeSocket *sock)
switch (sock->type) {
case SOCK_FLOAT: {
bNodeSocketValueFloat *dval = sock->default_value_typed<bNodeSocketValueFloat>();
return nodeStaticSocketType(SOCK_FLOAT, dval->subtype);
return blender::bke::nodeStaticSocketType(SOCK_FLOAT, dval->subtype);
}
case SOCK_INT: {
bNodeSocketValueInt *dval = sock->default_value_typed<bNodeSocketValueInt>();
return nodeStaticSocketType(SOCK_INT, dval->subtype);
return blender::bke::nodeStaticSocketType(SOCK_INT, dval->subtype);
}
case SOCK_BOOLEAN: {
return nodeStaticSocketType(SOCK_BOOLEAN, PROP_NONE);
return blender::bke::nodeStaticSocketType(SOCK_BOOLEAN, PROP_NONE);
}
case SOCK_VECTOR: {
bNodeSocketValueVector *dval = sock->default_value_typed<bNodeSocketValueVector>();
return nodeStaticSocketType(SOCK_VECTOR, dval->subtype);
return blender::bke::nodeStaticSocketType(SOCK_VECTOR, dval->subtype);
}
case SOCK_RGBA: {
return nodeStaticSocketType(SOCK_RGBA, PROP_NONE);
return blender::bke::nodeStaticSocketType(SOCK_RGBA, PROP_NONE);
}
case SOCK_STRING: {
bNodeSocketValueString *dval = sock->default_value_typed<bNodeSocketValueString>();
return nodeStaticSocketType(SOCK_STRING, dval->subtype);
return blender::bke::nodeStaticSocketType(SOCK_STRING, dval->subtype);
}
case SOCK_SHADER: {
return nodeStaticSocketType(SOCK_SHADER, PROP_NONE);
return blender::bke::nodeStaticSocketType(SOCK_SHADER, PROP_NONE);
}
}
return "";
@ -1099,7 +1099,7 @@ static bNode *version_add_group_in_out_node(bNodeTree *ntree, const int type)
node->runtime = MEM_new<blender::bke::bNodeRuntime>(__func__);
BLI_addtail(&ntree->nodes, node);
nodeUniqueID(ntree, node);
blender::bke::nodeUniqueID(ntree, node);
/* Manual initialization of the node,
* node->typeinfo is only set after versioning. */
@ -2251,7 +2251,7 @@ void blo_do_versions_260(FileData *fd, Library * /*lib*/, Main *bmain)
}
LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
nodeUniqueName(ntree, node);
blender::bke::nodeUniqueName(ntree, node);
}
}
FOREACH_NODETREE_END;
@ -2344,7 +2344,7 @@ void blo_do_versions_260(FileData *fd, Library * /*lib*/, Main *bmain)
}
if (free_link) {
nodeRemLink(ntree, link);
blender::bke::nodeRemLink(ntree, link);
}
}
@ -2373,7 +2373,7 @@ void blo_do_versions_260(FileData *fd, Library * /*lib*/, Main *bmain)
{
next_link = link->next;
if (link->fromnode == nullptr || link->tonode == nullptr) {
nodeRemLink(ntree, link);
blender::bke::nodeRemLink(ntree, link);
}
}
}

18
source/blender/blenloader/intern/versioning_270.cc
View file

@ -280,18 +280,18 @@ static void do_version_hue_sat_node(bNodeTree *ntree, bNode *node)
/* Convert value from old storage to new sockets. */
NodeHueSat *nhs = static_cast<NodeHueSat *>(node->storage);
bNodeSocket *hue = nodeFindSocket(node, SOCK_IN, "Hue");
bNodeSocket *saturation = nodeFindSocket(node, SOCK_IN, "Saturation");
bNodeSocket *value = nodeFindSocket(node, SOCK_IN, "Value");
bNodeSocket *hue = blender::bke::nodeFindSocket(node, SOCK_IN, "Hue");
bNodeSocket *saturation = blender::bke::nodeFindSocket(node, SOCK_IN, "Saturation");
bNodeSocket *value = blender::bke::nodeFindSocket(node, SOCK_IN, "Value");
if (hue == nullptr) {
hue = nodeAddStaticSocket(ntree, node, SOCK_IN, SOCK_FLOAT, PROP_FACTOR, "Hue", "Hue");
hue = blender::bke::nodeAddStaticSocket(ntree, node, SOCK_IN, SOCK_FLOAT, PROP_FACTOR, "Hue", "Hue");
}
if (saturation == nullptr) {
saturation = nodeAddStaticSocket(
saturation = blender::bke::nodeAddStaticSocket(
ntree, node, SOCK_IN, SOCK_FLOAT, PROP_FACTOR, "Saturation", "Saturation");
}
if (value == nullptr) {
value = nodeAddStaticSocket(ntree, node, SOCK_IN, SOCK_FLOAT, PROP_FACTOR, "Value", "Value");
value = blender::bke::nodeAddStaticSocket(ntree, node, SOCK_IN, SOCK_FLOAT, PROP_FACTOR, "Value", "Value");
}
((bNodeSocketValueFloat *)hue->default_value)->value = nhs->hue;
@ -1064,7 +1064,7 @@ void blo_do_versions_270(FileData *fd, Library * /*lib*/, Main *bmain)
* Original commit (3fcf535d2e) forgot to handle embedded IDs. Fortunately, back then, the
* only embedded IDs that existed were the NodeTree ones, and the current API to access
* them should still be valid on code from 9 years ago. */
bNodeTree *node_tree = ntreeFromID(id);
bNodeTree *node_tree = blender::bke::ntreeFromID(id);
if (node_tree) {
node_tree->id.flag &= LIB_FAKEUSER;
}
@ -1459,7 +1459,7 @@ void blo_do_versions_270(FileData *fd, Library * /*lib*/, Main *bmain)
if (!DNA_struct_member_exists(fd->filesdna, "NodeGlare", "char", "star_45")) {
FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
if (ntree->type == NTREE_COMPOSIT) {
ntreeSetTypes(nullptr, ntree);
blender::bke::ntreeSetTypes(nullptr, ntree);
LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
if (node->type == CMP_NODE_GLARE) {
NodeGlare *ndg = static_cast<NodeGlare *>(node->storage);
@ -1611,7 +1611,7 @@ void do_versions_after_linking_270(Main *bmain)
if (!MAIN_VERSION_FILE_ATLEAST(bmain, 279, 0)) {
FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
if (ntree->type == NTREE_COMPOSIT) {
ntreeSetTypes(nullptr, ntree);
blender::bke::ntreeSetTypes(nullptr, ntree);
LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
if (node->type == CMP_NODE_HUE_SAT) {
do_version_hue_sat_node(ntree, node);

280
source/blender/blenloader/intern/versioning_280.cc
View file

@ -667,61 +667,61 @@ static void do_versions_material_convert_legacy_blend_mode(bNodeTree *ntree, cha
MA_BM_MULTIPLY = 2,
};
if (blend_method == MA_BM_ADD) {
nodeRemLink(ntree, link);
blender::bke::nodeRemLink(ntree, link);
bNode *add_node = nodeAddStaticNode(nullptr, ntree, SH_NODE_ADD_SHADER);
bNode *add_node = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_ADD_SHADER);
add_node->locx = 0.5f * (fromnode->locx + tonode->locx);
add_node->locy = 0.5f * (fromnode->locy + tonode->locy);
bNodeSocket *shader1_socket = static_cast<bNodeSocket *>(add_node->inputs.first);
bNodeSocket *shader2_socket = static_cast<bNodeSocket *>(add_node->inputs.last);
bNodeSocket *add_socket = nodeFindSocket(add_node, SOCK_OUT, "Shader");
bNodeSocket *add_socket = blender::bke::nodeFindSocket(add_node, SOCK_OUT, "Shader");
bNode *transp_node = nodeAddStaticNode(nullptr, ntree, SH_NODE_BSDF_TRANSPARENT);
bNode *transp_node = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_BSDF_TRANSPARENT);
transp_node->locx = add_node->locx;
transp_node->locy = add_node->locy - 110.0f;
bNodeSocket *transp_socket = nodeFindSocket(transp_node, SOCK_OUT, "BSDF");
bNodeSocket *transp_socket = blender::bke::nodeFindSocket(transp_node, SOCK_OUT, "BSDF");
/* Link to input and material output node. */
nodeAddLink(ntree, fromnode, fromsock, add_node, shader1_socket);
nodeAddLink(ntree, transp_node, transp_socket, add_node, shader2_socket);
nodeAddLink(ntree, add_node, add_socket, tonode, tosock);
blender::bke::nodeAddLink(ntree, fromnode, fromsock, add_node, shader1_socket);
blender::bke::nodeAddLink(ntree, transp_node, transp_socket, add_node, shader2_socket);
blender::bke::nodeAddLink(ntree, add_node, add_socket, tonode, tosock);
need_update = true;
}
else if (blend_method == MA_BM_MULTIPLY) {
nodeRemLink(ntree, link);
blender::bke::nodeRemLink(ntree, link);
bNode *transp_node = nodeAddStaticNode(nullptr, ntree, SH_NODE_BSDF_TRANSPARENT);
bNode *transp_node = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_BSDF_TRANSPARENT);
bNodeSocket *color_socket = nodeFindSocket(transp_node, SOCK_IN, "Color");
bNodeSocket *transp_socket = nodeFindSocket(transp_node, SOCK_OUT, "BSDF");
bNodeSocket *color_socket = blender::bke::nodeFindSocket(transp_node, SOCK_IN, "Color");
bNodeSocket *transp_socket = blender::bke::nodeFindSocket(transp_node, SOCK_OUT, "BSDF");
/* If incoming link is from a closure socket, we need to convert it. */
if (fromsock->type == SOCK_SHADER) {
transp_node->locx = 0.33f * fromnode->locx + 0.66f * tonode->locx;
transp_node->locy = 0.33f * fromnode->locy + 0.66f * tonode->locy;
bNode *shtorgb_node = nodeAddStaticNode(nullptr, ntree, SH_NODE_SHADERTORGB);
bNode *shtorgb_node = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_SHADERTORGB);
shtorgb_node->locx = 0.66f * fromnode->locx + 0.33f * tonode->locx;
shtorgb_node->locy = 0.66f * fromnode->locy + 0.33f * tonode->locy;
bNodeSocket *shader_socket = nodeFindSocket(shtorgb_node, SOCK_IN, "Shader");
bNodeSocket *rgba_socket = nodeFindSocket(shtorgb_node, SOCK_OUT, "Color");
bNodeSocket *shader_socket = blender::bke::nodeFindSocket(shtorgb_node, SOCK_IN, "Shader");
bNodeSocket *rgba_socket = blender::bke::nodeFindSocket(shtorgb_node, SOCK_OUT, "Color");
nodeAddLink(ntree, fromnode, fromsock, shtorgb_node, shader_socket);
nodeAddLink(ntree, shtorgb_node, rgba_socket, transp_node, color_socket);
blender::bke::nodeAddLink(ntree, fromnode, fromsock, shtorgb_node, shader_socket);
blender::bke::nodeAddLink(ntree, shtorgb_node, rgba_socket, transp_node, color_socket);
}
else {
transp_node->locx = 0.5f * (fromnode->locx + tonode->locx);
transp_node->locy = 0.5f * (fromnode->locy + tonode->locy);
nodeAddLink(ntree, fromnode, fromsock, transp_node, color_socket);
blender::bke::nodeAddLink(ntree, fromnode, fromsock, transp_node, color_socket);
}
/* Link to input and material output node. */
nodeAddLink(ntree, transp_node, transp_socket, tonode, tosock);
blender::bke::nodeAddLink(ntree, transp_node, transp_socket, tonode, tosock);
need_update = true;
}
@ -1026,25 +1026,25 @@ static void displacement_node_insert(bNodeTree *ntree)
}
/* Replace link with displacement node. */
nodeRemLink(ntree, link);
blender::bke::nodeRemLink(ntree, link);
/* Add displacement node. */
bNode *node = nodeAddStaticNode(nullptr, ntree, SH_NODE_DISPLACEMENT);
bNode *node = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_DISPLACEMENT);
node->locx = 0.5f * (fromnode->locx + tonode->locx);
node->locy = 0.5f * (fromnode->locy + tonode->locy);
bNodeSocket *scale_socket = nodeFindSocket(node, SOCK_IN, "Scale");
bNodeSocket *midlevel_socket = nodeFindSocket(node, SOCK_IN, "Midlevel");
bNodeSocket *height_socket = nodeFindSocket(node, SOCK_IN, "Height");
bNodeSocket *displacement_socket = nodeFindSocket(node, SOCK_OUT, "Displacement");
bNodeSocket *scale_socket = blender::bke::nodeFindSocket(node, SOCK_IN, "Scale");
bNodeSocket *midlevel_socket = blender::bke::nodeFindSocket(node, SOCK_IN, "Midlevel");
bNodeSocket *height_socket = blender::bke::nodeFindSocket(node, SOCK_IN, "Height");
bNodeSocket *displacement_socket = blender::bke::nodeFindSocket(node, SOCK_OUT, "Displacement");
/* Set default values for compatibility. */
*version_cycles_node_socket_float_value(scale_socket) = 0.1f;
*version_cycles_node_socket_float_value(midlevel_socket) = 0.0f;
/* Link to input and material output node. */
nodeAddLink(ntree, fromnode, fromsock, node, height_socket);
nodeAddLink(ntree, node, displacement_socket, tonode, tosock);
blender::bke::nodeAddLink(ntree, fromnode, fromsock, node, height_socket);
blender::bke::nodeAddLink(ntree, node, displacement_socket, tonode, tosock);
need_update = true;
}
@ -1086,15 +1086,15 @@ static void square_roughness_node_insert(bNodeTree *ntree)
bNode *tonode,
bNodeSocket *tosock) {
/* Add `sqrt` node. */
bNode *node = nodeAddStaticNode(nullptr, ntree, SH_NODE_MATH);
bNode *node = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_MATH);
node->custom1 = NODE_MATH_POWER;
node->locx = 0.5f * (fromnode->locx + tonode->locx);
node->locy = 0.5f * (fromnode->locy + tonode->locy);
/* Link to input and material output node. */
*version_cycles_node_socket_float_value(static_cast<bNodeSocket *>(node->inputs.last)) = 0.5f;
nodeAddLink(ntree, fromnode, fromsock, node, static_cast<bNodeSocket *>(node->inputs.first));
nodeAddLink(ntree, node, static_cast<bNodeSocket *>(node->outputs.first), tonode, tosock);
blender::bke::nodeAddLink(ntree, fromnode, fromsock, node, static_cast<bNodeSocket *>(node->inputs.first));
blender::bke::nodeAddLink(ntree, node, static_cast<bNodeSocket *>(node->outputs.first), tonode, tosock);
};
version_update_node_input(ntree, check_node, "Roughness", update_input, update_input_link);
@ -1143,7 +1143,7 @@ static void ambient_occlusion_node_relink(bNodeTree *ntree)
node->custom1 = 1; /* samples */
node->custom2 &= ~SHD_AO_LOCAL;
bNodeSocket *distance_socket = nodeFindSocket(node, SOCK_IN, "Distance");
bNodeSocket *distance_socket = blender::bke::nodeFindSocket(node, SOCK_IN, "Distance");
*version_cycles_node_socket_float_value(distance_socket) = 0.0f;
}
}
@ -1160,9 +1160,9 @@ static void ambient_occlusion_node_relink(bNodeTree *ntree)
}
/* Replace links with color socket. */
nodeRemLink(ntree, link);
bNodeSocket *color_socket = nodeFindSocket(fromnode, SOCK_OUT, "Color");
nodeAddLink(ntree, fromnode, color_socket, tonode, tosock);
blender::bke::nodeRemLink(ntree, link);
bNodeSocket *color_socket = blender::bke::nodeFindSocket(fromnode, SOCK_OUT, "Color");
blender::bke::nodeAddLink(ntree, fromnode, color_socket, tonode, tosock);
need_update = true;
}
@ -1229,8 +1229,8 @@ static void light_emission_node_to_energy(Light *light, float *energy, float col
}
/* Don't convert if anything is linked */
bNodeSocket *strength_socket = nodeFindSocket(emission_node, SOCK_IN, "Strength");
bNodeSocket *color_socket = nodeFindSocket(emission_node, SOCK_IN, "Color");
bNodeSocket *strength_socket = blender::bke::nodeFindSocket(emission_node, SOCK_IN, "Strength");
bNodeSocket *color_socket = blender::bke::nodeFindSocket(emission_node, SOCK_IN, "Color");
if ((strength_socket->flag & SOCK_IS_LINKED) || (color_socket->flag & SOCK_IS_LINKED)) {
return;
@ -1308,8 +1308,8 @@ static void update_math_node_single_operand_operators(bNodeTree *ntree)
bNodeSocket *sockA = static_cast<bNodeSocket *>(BLI_findlink(&node->inputs, 0));
bNodeSocket *sockB = static_cast<bNodeSocket *>(BLI_findlink(&node->inputs, 1));
if (!sockA->link && sockB->link) {
nodeAddLink(ntree, sockB->link->fromnode, sockB->link->fromsock, node, sockA);
nodeRemLink(ntree, sockB->link);
blender::bke::nodeAddLink(ntree, sockB->link->fromnode, sockB->link->fromsock, node, sockA);
blender::bke::nodeRemLink(ntree, sockB->link);
need_update = true;
}
}
@ -1341,38 +1341,38 @@ static void update_vector_math_node_add_and_subtract_operators(bNodeTree *ntree)
LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
if (node->type == SH_NODE_VECTOR_MATH) {
bNodeSocket *sockOutValue = nodeFindSocket(node, SOCK_OUT, "Value");
bNodeSocket *sockOutValue = blender::bke::nodeFindSocket(node, SOCK_OUT, "Value");
if (version_node_socket_is_used(sockOutValue) &&
ELEM(node->custom1, NODE_VECTOR_MATH_ADD, NODE_VECTOR_MATH_SUBTRACT))
{
bNode *absNode = nodeAddStaticNode(nullptr, ntree, SH_NODE_VECTOR_MATH);
bNode *absNode = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_VECTOR_MATH);
absNode->custom1 = NODE_VECTOR_MATH_ABSOLUTE;
absNode->locx = node->locx + node->width + 20.0f;
absNode->locy = node->locy;
bNode *dotNode = nodeAddStaticNode(nullptr, ntree, SH_NODE_VECTOR_MATH);
bNode *dotNode = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_VECTOR_MATH);
dotNode->custom1 = NODE_VECTOR_MATH_DOT_PRODUCT;
dotNode->locx = absNode->locx + absNode->width + 20.0f;
dotNode->locy = absNode->locy;
bNodeSocket *sockDotB = static_cast<bNodeSocket *>(BLI_findlink(&dotNode->inputs, 1));
bNodeSocket *sockDotOutValue = nodeFindSocket(dotNode, SOCK_OUT, "Value");
bNodeSocket *sockDotOutValue = blender::bke::nodeFindSocket(dotNode, SOCK_OUT, "Value");
copy_v3_fl(version_cycles_node_socket_vector_value(sockDotB), 1 / 3.0f);
LISTBASE_FOREACH_BACKWARD_MUTABLE (bNodeLink *, link, &ntree->links) {
if (link->fromsock == sockOutValue) {
nodeAddLink(ntree, dotNode, sockDotOutValue, link->tonode, link->tosock);
nodeRemLink(ntree, link);
blender::bke::nodeAddLink(ntree, dotNode, sockDotOutValue, link->tonode, link->tosock);
blender::bke::nodeRemLink(ntree, link);
}
}
bNodeSocket *sockAbsA = static_cast<bNodeSocket *>(BLI_findlink(&absNode->inputs, 0));
bNodeSocket *sockDotA = static_cast<bNodeSocket *>(BLI_findlink(&dotNode->inputs, 0));
bNodeSocket *sockOutVector = nodeFindSocket(node, SOCK_OUT, "Vector");
bNodeSocket *sockAbsOutVector = nodeFindSocket(absNode, SOCK_OUT, "Vector");
bNodeSocket *sockOutVector = blender::bke::nodeFindSocket(node, SOCK_OUT, "Vector");
bNodeSocket *sockAbsOutVector = blender::bke::nodeFindSocket(absNode, SOCK_OUT, "Vector");
nodeAddLink(ntree, node, sockOutVector, absNode, sockAbsA);
nodeAddLink(ntree, absNode, sockAbsOutVector, dotNode, sockDotA);
blender::bke::nodeAddLink(ntree, node, sockOutVector, absNode, sockAbsA);
blender::bke::nodeAddLink(ntree, absNode, sockAbsOutVector, dotNode, sockDotA);
need_update = true;
}
@ -1394,7 +1394,7 @@ static void update_vector_math_node_dot_product_operator(bNodeTree *ntree)
LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
if (node->type == SH_NODE_VECTOR_MATH) {
bNodeSocket *sockOutVector = nodeFindSocket(node, SOCK_OUT, "Vector");
bNodeSocket *sockOutVector = blender::bke::nodeFindSocket(node, SOCK_OUT, "Vector");
if (version_node_socket_is_used(sockOutVector) &&
node->custom1 == NODE_VECTOR_MATH_DOT_PRODUCT)
{
@ -1411,7 +1411,7 @@ static void update_vector_math_node_dot_product_operator(bNodeTree *ntree)
copy_v4_fl(version_cycles_node_socket_rgba_value(link->tosock), 0.0f);
break;
}
nodeRemLink(ntree, link);
blender::bke::nodeRemLink(ntree, link);
}
}
need_update = true;
@ -1436,30 +1436,30 @@ static void update_vector_math_node_cross_product_operator(bNodeTree *ntree)
LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
if (node->type == SH_NODE_VECTOR_MATH) {
if (node->custom1 == NODE_VECTOR_MATH_CROSS_PRODUCT) {
bNodeSocket *sockOutVector = nodeFindSocket(node, SOCK_OUT, "Vector");
bNodeSocket *sockOutVector = blender::bke::nodeFindSocket(node, SOCK_OUT, "Vector");
if (version_node_socket_is_used(sockOutVector)) {
bNode *normalizeNode = nodeAddStaticNode(nullptr, ntree, SH_NODE_VECTOR_MATH);
bNode *normalizeNode = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_VECTOR_MATH);
normalizeNode->custom1 = NODE_VECTOR_MATH_NORMALIZE;
normalizeNode->locx = node->locx + node->width + 20.0f;
normalizeNode->locy = node->locy;
bNodeSocket *sockNormalizeOut = nodeFindSocket(normalizeNode, SOCK_OUT, "Vector");
bNodeSocket *sockNormalizeOut = blender::bke::nodeFindSocket(normalizeNode, SOCK_OUT, "Vector");
LISTBASE_FOREACH_BACKWARD_MUTABLE (bNodeLink *, link, &ntree->links) {
if (link->fromsock == sockOutVector) {
nodeAddLink(ntree, normalizeNode, sockNormalizeOut, link->tonode, link->tosock);
nodeRemLink(ntree, link);
blender::bke::nodeAddLink(ntree, normalizeNode, sockNormalizeOut, link->tonode, link->tosock);
blender::bke::nodeRemLink(ntree, link);
}
}
bNodeSocket *sockNormalizeA = static_cast<bNodeSocket *>(
BLI_findlink(&normalizeNode->inputs, 0));
nodeAddLink(ntree, node, sockOutVector, normalizeNode, sockNormalizeA);
blender::bke::nodeAddLink(ntree, node, sockOutVector, normalizeNode, sockNormalizeA);
need_update = true;
}
bNodeSocket *sockOutValue = nodeFindSocket(node, SOCK_OUT, "Value");
bNodeSocket *sockOutValue = blender::bke::nodeFindSocket(node, SOCK_OUT, "Value");
if (version_node_socket_is_used(sockOutValue)) {
bNode *lengthNode = nodeAddStaticNode(nullptr, ntree, SH_NODE_VECTOR_MATH);
bNode *lengthNode = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_VECTOR_MATH);
lengthNode->custom1 = NODE_VECTOR_MATH_LENGTH;
lengthNode->locx = node->locx + node->width + 20.0f;
if (version_node_socket_is_used(sockOutVector)) {
@ -1468,17 +1468,17 @@ static void update_vector_math_node_cross_product_operator(bNodeTree *ntree)
else {
lengthNode->locy = node->locy;
}
bNodeSocket *sockLengthOut = nodeFindSocket(lengthNode, SOCK_OUT, "Value");
bNodeSocket *sockLengthOut = blender::bke::nodeFindSocket(lengthNode, SOCK_OUT, "Value");
LISTBASE_FOREACH_BACKWARD_MUTABLE (bNodeLink *, link, &ntree->links) {
if (link->fromsock == sockOutValue) {
nodeAddLink(ntree, lengthNode, sockLengthOut, link->tonode, link->tosock);
nodeRemLink(ntree, link);
blender::bke::nodeAddLink(ntree, lengthNode, sockLengthOut, link->tonode, link->tosock);
blender::bke::nodeRemLink(ntree, link);
}
}
bNodeSocket *sockLengthA = static_cast<bNodeSocket *>(
BLI_findlink(&lengthNode->inputs, 0));
nodeAddLink(ntree, node, sockOutVector, lengthNode, sockLengthA);
blender::bke::nodeAddLink(ntree, node, sockOutVector, lengthNode, sockLengthA);
need_update = true;
}
@ -1503,21 +1503,21 @@ static void update_vector_math_node_normalize_operator(bNodeTree *ntree)
LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
if (node->type == SH_NODE_VECTOR_MATH) {
bNodeSocket *sockOutValue = nodeFindSocket(node, SOCK_OUT, "Value");
bNodeSocket *sockOutValue = blender::bke::nodeFindSocket(node, SOCK_OUT, "Value");
if (node->custom1 == NODE_VECTOR_MATH_NORMALIZE && version_node_socket_is_used(sockOutValue))
{
bNodeSocket *sockOutVector = nodeFindSocket(node, SOCK_OUT, "Vector");
bNodeSocket *sockOutVector = blender::bke::nodeFindSocket(node, SOCK_OUT, "Vector");
if (version_node_socket_is_used(sockOutVector)) {
bNode *lengthNode = nodeAddStaticNode(nullptr, ntree, SH_NODE_VECTOR_MATH);
bNode *lengthNode = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_VECTOR_MATH);
lengthNode->custom1 = NODE_VECTOR_MATH_LENGTH;
lengthNode->locx = node->locx + node->width + 20.0f;
lengthNode->locy = node->locy;
bNodeSocket *sockLengthValue = nodeFindSocket(lengthNode, SOCK_OUT, "Value");
bNodeSocket *sockLengthValue = blender::bke::nodeFindSocket(lengthNode, SOCK_OUT, "Value");
LISTBASE_FOREACH_BACKWARD_MUTABLE (bNodeLink *, link, &ntree->links) {
if (link->fromsock == sockOutValue) {
nodeAddLink(ntree, lengthNode, sockLengthValue, link->tonode, link->tosock);
nodeRemLink(ntree, link);
blender::bke::nodeAddLink(ntree, lengthNode, sockLengthValue, link->tonode, link->tosock);
blender::bke::nodeRemLink(ntree, link);
}
}
bNodeSocket *sockA = static_cast<bNodeSocket *>(BLI_findlink(&node->inputs, 0));
@ -1525,7 +1525,7 @@ static void update_vector_math_node_normalize_operator(bNodeTree *ntree)
BLI_findlink(&lengthNode->inputs, 0));
if (sockA->link) {
bNodeLink *link = sockA->link;
nodeAddLink(ntree, link->fromnode, link->fromsock, lengthNode, sockLengthA);
blender::bke::nodeAddLink(ntree, link->fromnode, link->fromsock, lengthNode, sockLengthA);
}
else {
copy_v3_v3(version_cycles_node_socket_vector_value(sockLengthA),
@ -1593,30 +1593,30 @@ static void update_vector_math_node_average_operator(bNodeTree *ntree)
/* See update_vector_math_node_operators_enum_mapping. */
if (node->custom1 == -1) {
node->custom1 = NODE_VECTOR_MATH_ADD;
bNodeSocket *sockOutVector = nodeFindSocket(node, SOCK_OUT, "Vector");
bNodeSocket *sockOutVector = blender::bke::nodeFindSocket(node, SOCK_OUT, "Vector");
if (version_node_socket_is_used(sockOutVector)) {
bNode *normalizeNode = nodeAddStaticNode(nullptr, ntree, SH_NODE_VECTOR_MATH);
bNode *normalizeNode = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_VECTOR_MATH);
normalizeNode->custom1 = NODE_VECTOR_MATH_NORMALIZE;
normalizeNode->locx = node->locx + node->width + 20.0f;
normalizeNode->locy = node->locy;
bNodeSocket *sockNormalizeOut = nodeFindSocket(normalizeNode, SOCK_OUT, "Vector");
bNodeSocket *sockNormalizeOut = blender::bke::nodeFindSocket(normalizeNode, SOCK_OUT, "Vector");
LISTBASE_FOREACH_BACKWARD_MUTABLE (bNodeLink *, link, &ntree->links) {
if (link->fromsock == sockOutVector) {
nodeAddLink(ntree, normalizeNode, sockNormalizeOut, link->tonode, link->tosock);
nodeRemLink(ntree, link);
blender::bke::nodeAddLink(ntree, normalizeNode, sockNormalizeOut, link->tonode, link->tosock);
blender::bke::nodeRemLink(ntree, link);
}
}
bNodeSocket *sockNormalizeA = static_cast<bNodeSocket *>(
BLI_findlink(&normalizeNode->inputs, 0));
nodeAddLink(ntree, node, sockOutVector, normalizeNode, sockNormalizeA);
blender::bke::nodeAddLink(ntree, node, sockOutVector, normalizeNode, sockNormalizeA);
need_update = true;
}
bNodeSocket *sockOutValue = nodeFindSocket(node, SOCK_OUT, "Value");
bNodeSocket *sockOutValue = blender::bke::nodeFindSocket(node, SOCK_OUT, "Value");
if (version_node_socket_is_used(sockOutValue)) {
bNode *lengthNode = nodeAddStaticNode(nullptr, ntree, SH_NODE_VECTOR_MATH);
bNode *lengthNode = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_VECTOR_MATH);
lengthNode->custom1 = NODE_VECTOR_MATH_LENGTH;
lengthNode->locx = node->locx + node->width + 20.0f;
if (version_node_socket_is_used(sockOutVector)) {
@ -1625,17 +1625,17 @@ static void update_vector_math_node_average_operator(bNodeTree *ntree)
else {
lengthNode->locy = node->locy;
}
bNodeSocket *sockLengthOut = nodeFindSocket(lengthNode, SOCK_OUT, "Value");
bNodeSocket *sockLengthOut = blender::bke::nodeFindSocket(lengthNode, SOCK_OUT, "Value");
LISTBASE_FOREACH_BACKWARD_MUTABLE (bNodeLink *, link, &ntree->links) {
if (link->fromsock == sockOutValue) {
nodeAddLink(ntree, lengthNode, sockLengthOut, link->tonode, link->tosock);
nodeRemLink(ntree, link);
blender::bke::nodeAddLink(ntree, lengthNode, sockLengthOut, link->tonode, link->tosock);
blender::bke::nodeRemLink(ntree, link);
}
}
bNodeSocket *sockLengthA = static_cast<bNodeSocket *>(
BLI_findlink(&lengthNode->inputs, 0));
nodeAddLink(ntree, node, sockOutVector, lengthNode, sockLengthA);
blender::bke::nodeAddLink(ntree, node, sockOutVector, lengthNode, sockLengthA);
need_update = true;
}
@ -1750,16 +1750,16 @@ static void update_mapping_node_inputs_and_properties(bNodeTree *ntree)
node->custom1 = mapping->type;
node->width = 140.0f;
bNodeSocket *sockLocation = nodeFindSocket(node, SOCK_IN, "Location");
bNodeSocket *sockLocation = blender::bke::nodeFindSocket(node, SOCK_IN, "Location");
copy_v3_v3(version_cycles_node_socket_vector_value(sockLocation), mapping->loc);
bNodeSocket *sockRotation = nodeFindSocket(node, SOCK_IN, "Rotation");
bNodeSocket *sockRotation = blender::bke::nodeFindSocket(node, SOCK_IN, "Rotation");
copy_v3_v3(version_cycles_node_socket_vector_value(sockRotation), mapping->rot);
bNodeSocket *sockScale = nodeFindSocket(node, SOCK_IN, "Scale");
bNodeSocket *sockScale = blender::bke::nodeFindSocket(node, SOCK_IN, "Scale");
copy_v3_v3(version_cycles_node_socket_vector_value(sockScale), mapping->size);
bNode *maximumNode = nullptr;
if (mapping->flag & TEXMAP_CLIP_MIN) {
maximumNode = nodeAddStaticNode(nullptr, ntree, SH_NODE_VECTOR_MATH);
maximumNode = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_VECTOR_MATH);
maximumNode->custom1 = NODE_VECTOR_MATH_MAXIMUM;
if (mapping->flag & TEXMAP_CLIP_MAX) {
maximumNode->locx = node->locx + (node->width + 20.0f) * 2.0f;
@ -1771,19 +1771,19 @@ static void update_mapping_node_inputs_and_properties(bNodeTree *ntree)
bNodeSocket *sockMaximumB = static_cast<bNodeSocket *>(
BLI_findlink(&maximumNode->inputs, 1));
copy_v3_v3(version_cycles_node_socket_vector_value(sockMaximumB), mapping->min);
bNodeSocket *sockMappingResult = nodeFindSocket(node, SOCK_OUT, "Vector");
bNodeSocket *sockMappingResult = blender::bke::nodeFindSocket(node, SOCK_OUT, "Vector");
LISTBASE_FOREACH_BACKWARD_MUTABLE (bNodeLink *, link, &ntree->links) {
if (link->fromsock == sockMappingResult) {
bNodeSocket *sockMaximumResult = nodeFindSocket(maximumNode, SOCK_OUT, "Vector");
nodeAddLink(ntree, maximumNode, sockMaximumResult, link->tonode, link->tosock);
nodeRemLink(ntree, link);
bNodeSocket *sockMaximumResult = blender::bke::nodeFindSocket(maximumNode, SOCK_OUT, "Vector");
blender::bke::nodeAddLink(ntree, maximumNode, sockMaximumResult, link->tonode, link->tosock);
blender::bke::nodeRemLink(ntree, link);
}
}
if (!(mapping->flag & TEXMAP_CLIP_MAX)) {
bNodeSocket *sockMaximumA = static_cast<bNodeSocket *>(
BLI_findlink(&maximumNode->inputs, 0));
nodeAddLink(ntree, node, sockMappingResult, maximumNode, sockMaximumA);
blender::bke::nodeAddLink(ntree, node, sockMappingResult, maximumNode, sockMaximumA);
}
need_update = true;
@ -1791,7 +1791,7 @@ static void update_mapping_node_inputs_and_properties(bNodeTree *ntree)
bNode *minimumNode = nullptr;
if (mapping->flag & TEXMAP_CLIP_MAX) {
minimumNode = nodeAddStaticNode(nullptr, ntree, SH_NODE_VECTOR_MATH);
minimumNode = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_VECTOR_MATH);
minimumNode->custom1 = NODE_VECTOR_MATH_MINIMUM;
minimumNode->locx = node->locx + node->width + 20.0f;
minimumNode->locy = node->locy;
@ -1799,25 +1799,25 @@ static void update_mapping_node_inputs_and_properties(bNodeTree *ntree)
BLI_findlink(&minimumNode->inputs, 1));
copy_v3_v3(version_cycles_node_socket_vector_value(sockMinimumB), mapping->max);
bNodeSocket *sockMinimumResult = nodeFindSocket(minimumNode, SOCK_OUT, "Vector");
bNodeSocket *sockMappingResult = nodeFindSocket(node, SOCK_OUT, "Vector");
bNodeSocket *sockMinimumResult = blender::bke::nodeFindSocket(minimumNode, SOCK_OUT, "Vector");
bNodeSocket *sockMappingResult = blender::bke::nodeFindSocket(node, SOCK_OUT, "Vector");
if (maximumNode) {
bNodeSocket *sockMaximumA = static_cast<bNodeSocket *>(
BLI_findlink(&maximumNode->inputs, 0));
nodeAddLink(ntree, minimumNode, sockMinimumResult, maximumNode, sockMaximumA);
blender::bke::nodeAddLink(ntree, minimumNode, sockMinimumResult, maximumNode, sockMaximumA);
}
else {
LISTBASE_FOREACH_BACKWARD_MUTABLE (bNodeLink *, link, &ntree->links) {
if (link->fromsock == sockMappingResult) {
nodeAddLink(ntree, minimumNode, sockMinimumResult, link->tonode, link->tosock);
nodeRemLink(ntree, link);
blender::bke::nodeAddLink(ntree, minimumNode, sockMinimumResult, link->tonode, link->tosock);
blender::bke::nodeRemLink(ntree, link);
}
}
}
bNodeSocket *sockMinimumA = static_cast<bNodeSocket *>(
BLI_findlink(&minimumNode->inputs, 0));
nodeAddLink(ntree, node, sockMappingResult, minimumNode, sockMinimumA);
blender::bke::nodeAddLink(ntree, node, sockMappingResult, minimumNode, sockMinimumA);
need_update = true;
}
@ -1938,14 +1938,14 @@ static void update_voronoi_node_crackle(bNodeTree *ntree)
LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
if (node->type == SH_NODE_TEX_VORONOI && node->storage) {
NodeTexVoronoi *tex = (NodeTexVoronoi *)node->storage;
bNodeSocket *sockDistance = nodeFindSocket(node, SOCK_OUT, "Distance");
bNodeSocket *sockColor = nodeFindSocket(node, SOCK_OUT, "Color");
bNodeSocket *sockDistance = blender::bke::nodeFindSocket(node, SOCK_OUT, "Distance");
bNodeSocket *sockColor = blender::bke::nodeFindSocket(node, SOCK_OUT, "Color");
if (tex->feature == 4 &&
(version_node_socket_is_used(sockDistance) || version_node_socket_is_used(sockColor)))
{
tex->feature = SHD_VORONOI_F1;
bNode *voronoiNode = nodeAddStaticNode(nullptr, ntree, SH_NODE_TEX_VORONOI);
bNode *voronoiNode = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_TEX_VORONOI);
NodeTexVoronoi *texVoronoi = (NodeTexVoronoi *)voronoiNode->storage;
texVoronoi->feature = SHD_VORONOI_F2;
texVoronoi->distance = tex->distance;
@ -1953,14 +1953,14 @@ static void update_voronoi_node_crackle(bNodeTree *ntree)
voronoiNode->locx = node->locx + node->width + 20.0f;
voronoiNode->locy = node->locy;
bNodeSocket *sockVector = nodeFindSocket(node, SOCK_IN, "Vector");
bNodeSocket *sockScale = nodeFindSocket(node, SOCK_IN, "Scale");
bNodeSocket *sockExponent = nodeFindSocket(node, SOCK_IN, "Exponent");
bNodeSocket *sockVoronoiVector = nodeFindSocket(voronoiNode, SOCK_IN, "Vector");
bNodeSocket *sockVoronoiScale = nodeFindSocket(voronoiNode, SOCK_IN, "Scale");
bNodeSocket *sockVoronoiExponent = nodeFindSocket(voronoiNode, SOCK_IN, "Exponent");
bNodeSocket *sockVector = blender::bke::nodeFindSocket(node, SOCK_IN, "Vector");
bNodeSocket *sockScale = blender::bke::nodeFindSocket(node, SOCK_IN, "Scale");
bNodeSocket *sockExponent = blender::bke::nodeFindSocket(node, SOCK_IN, "Exponent");
bNodeSocket *sockVoronoiVector = blender::bke::nodeFindSocket(voronoiNode, SOCK_IN, "Vector");
bNodeSocket *sockVoronoiScale = blender::bke::nodeFindSocket(voronoiNode, SOCK_IN, "Scale");
bNodeSocket *sockVoronoiExponent = blender::bke::nodeFindSocket(voronoiNode, SOCK_IN, "Exponent");
if (sockVector->link) {
nodeAddLink(ntree,
blender::bke::nodeAddLink(ntree,
sockVector->link->fromnode,
sockVector->link->fromsock,
voronoiNode,
@ -1969,7 +1969,7 @@ static void update_voronoi_node_crackle(bNodeTree *ntree)
*version_cycles_node_socket_float_value(
sockVoronoiScale) = *version_cycles_node_socket_float_value(sockScale);
if (sockScale->link) {
nodeAddLink(ntree,
blender::bke::nodeAddLink(ntree,
sockScale->link->fromnode,
sockScale->link->fromsock,
voronoiNode,
@ -1978,35 +1978,35 @@ static void update_voronoi_node_crackle(bNodeTree *ntree)
*version_cycles_node_socket_float_value(
sockVoronoiExponent) = *version_cycles_node_socket_float_value(sockExponent);
if (sockExponent->link) {
nodeAddLink(ntree,
blender::bke::nodeAddLink(ntree,
sockExponent->link->fromnode,
sockExponent->link->fromsock,
voronoiNode,
sockVoronoiExponent);
}
bNode *subtractNode = nodeAddStaticNode(nullptr, ntree, SH_NODE_MATH);
bNode *subtractNode = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_MATH);
subtractNode->custom1 = NODE_MATH_SUBTRACT;
subtractNode->locx = voronoiNode->locx + voronoiNode->width + 20.0f;
subtractNode->locy = voronoiNode->locy;
bNodeSocket *sockSubtractOutValue = nodeFindSocket(subtractNode, SOCK_OUT, "Value");
bNodeSocket *sockSubtractOutValue = blender::bke::nodeFindSocket(subtractNode, SOCK_OUT, "Value");
LISTBASE_FOREACH_BACKWARD_MUTABLE (bNodeLink *, link, &ntree->links) {
if (link->fromnode == node) {
nodeAddLink(ntree, subtractNode, sockSubtractOutValue, link->tonode, link->tosock);
nodeRemLink(ntree, link);
blender::bke::nodeAddLink(ntree, subtractNode, sockSubtractOutValue, link->tonode, link->tosock);
blender::bke::nodeRemLink(ntree, link);
}
}
bNodeSocket *sockDistanceF1 = nodeFindSocket(node, SOCK_OUT, "Distance");
bNodeSocket *sockDistanceF2 = nodeFindSocket(voronoiNode, SOCK_OUT, "Distance");
bNodeSocket *sockDistanceF1 = blender::bke::nodeFindSocket(node, SOCK_OUT, "Distance");
bNodeSocket *sockDistanceF2 = blender::bke::nodeFindSocket(voronoiNode, SOCK_OUT, "Distance");
bNodeSocket *sockSubtractA = static_cast<bNodeSocket *>(
BLI_findlink(&subtractNode->inputs, 0));
bNodeSocket *sockSubtractB = static_cast<bNodeSocket *>(
BLI_findlink(&subtractNode->inputs, 1));
nodeAddLink(ntree, node, sockDistanceF1, subtractNode, sockSubtractB);
nodeAddLink(ntree, voronoiNode, sockDistanceF2, subtractNode, sockSubtractA);
blender::bke::nodeAddLink(ntree, node, sockDistanceF1, subtractNode, sockSubtractB);
blender::bke::nodeAddLink(ntree, voronoiNode, sockDistanceF2, subtractNode, sockSubtractA);
need_update = true;
}
@ -2035,20 +2035,20 @@ static void update_voronoi_node_coloring(bNodeTree *ntree)
if (node && node->type == SH_NODE_TEX_VORONOI && node->storage) {
NodeTexVoronoi *tex = (NodeTexVoronoi *)node->storage;
if (tex->coloring == 0) {
bNodeSocket *sockColor = nodeFindSocket(node, SOCK_OUT, "Color");
bNodeSocket *sockColor = blender::bke::nodeFindSocket(node, SOCK_OUT, "Color");
if (link->fromsock == sockColor) {
bNodeSocket *sockDistance = nodeFindSocket(node, SOCK_OUT, "Distance");
nodeAddLink(ntree, node, sockDistance, link->tonode, link->tosock);
nodeRemLink(ntree, link);
bNodeSocket *sockDistance = blender::bke::nodeFindSocket(node, SOCK_OUT, "Distance");
blender::bke::nodeAddLink(ntree, node, sockDistance, link->tonode, link->tosock);
blender::bke::nodeRemLink(ntree, link);
need_update = true;
}
}
else {
bNodeSocket *sockDistance = nodeFindSocket(node, SOCK_OUT, "Distance");
bNodeSocket *sockDistance = blender::bke::nodeFindSocket(node, SOCK_OUT, "Distance");
if (link->fromsock == sockDistance) {
bNodeSocket *sockColor = nodeFindSocket(node, SOCK_OUT, "Color");
nodeAddLink(ntree, node, sockColor, link->tonode, link->tosock);
nodeRemLink(ntree, link);
bNodeSocket *sockColor = blender::bke::nodeFindSocket(node, SOCK_OUT, "Color");
blender::bke::nodeAddLink(ntree, node, sockColor, link->tonode, link->tosock);
blender::bke::nodeRemLink(ntree, link);
need_update = true;
}
}
@ -2071,21 +2071,21 @@ static void update_voronoi_node_square_distance(bNodeTree *ntree)
LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
if (node->type == SH_NODE_TEX_VORONOI && node->storage) {
NodeTexVoronoi *tex = (NodeTexVoronoi *)node->storage;
bNodeSocket *sockDistance = nodeFindSocket(node, SOCK_OUT, "Distance");
bNodeSocket *sockDistance = blender::bke::nodeFindSocket(node, SOCK_OUT, "Distance");
if (tex->distance == SHD_VORONOI_EUCLIDEAN &&
ELEM(tex->feature, SHD_VORONOI_F1, SHD_VORONOI_F2) &&
version_node_socket_is_used(sockDistance))
{
bNode *multiplyNode = nodeAddStaticNode(nullptr, ntree, SH_NODE_MATH);
bNode *multiplyNode = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_MATH);
multiplyNode->custom1 = NODE_MATH_MULTIPLY;
multiplyNode->locx = node->locx + node->width + 20.0f;
multiplyNode->locy = node->locy;
bNodeSocket *sockValue = nodeFindSocket(multiplyNode, SOCK_OUT, "Value");
bNodeSocket *sockValue = blender::bke::nodeFindSocket(multiplyNode, SOCK_OUT, "Value");
LISTBASE_FOREACH_BACKWARD_MUTABLE (bNodeLink *, link, &ntree->links) {
if (link->fromsock == sockDistance) {
nodeAddLink(ntree, multiplyNode, sockValue, link->tonode, link->tosock);
nodeRemLink(ntree, link);
blender::bke::nodeAddLink(ntree, multiplyNode, sockValue, link->tonode, link->tosock);
blender::bke::nodeRemLink(ntree, link);
}
}
@ -2094,8 +2094,8 @@ static void update_voronoi_node_square_distance(bNodeTree *ntree)
bNodeSocket *sockMultiplyB = static_cast<bNodeSocket *>(
BLI_findlink(&multiplyNode->inputs, 1));
nodeAddLink(ntree, node, sockDistance, multiplyNode, sockMultiplyA);
nodeAddLink(ntree, node, sockDistance, multiplyNode, sockMultiplyB);
blender::bke::nodeAddLink(ntree, node, sockDistance, multiplyNode, sockMultiplyA);
blender::bke::nodeAddLink(ntree, node, sockDistance, multiplyNode, sockMultiplyB);
need_update = true;
}
@ -2119,14 +2119,14 @@ static void update_noise_and_wave_distortion(bNodeTree *ntree)
LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
if (ELEM(node->type, SH_NODE_TEX_NOISE, SH_NODE_TEX_WAVE)) {
bNodeSocket *sockDistortion = nodeFindSocket(node, SOCK_IN, "Distortion");
bNodeSocket *sockDistortion = blender::bke::nodeFindSocket(node, SOCK_IN, "Distortion");
float *distortion = version_cycles_node_socket_float_value(sockDistortion);
if (version_node_socket_is_used(sockDistortion) && sockDistortion->link != nullptr) {
bNode *distortionInputNode = sockDistortion->link->fromnode;
bNodeSocket *distortionInputSock = sockDistortion->link->fromsock;
bNode *mulNode = nodeAddStaticNode(nullptr, ntree, SH_NODE_MATH);
bNode *mulNode = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_MATH);
mulNode->custom1 = NODE_MATH_MULTIPLY;
mulNode->locx = node->locx;
mulNode->locy = node->locy - 240.0f;
@ -2134,11 +2134,11 @@ static void update_noise_and_wave_distortion(bNodeTree *ntree)
bNodeSocket *mulSockA = static_cast<bNodeSocket *>(BLI_findlink(&mulNode->inputs, 0));
bNodeSocket *mulSockB = static_cast<bNodeSocket *>(BLI_findlink(&mulNode->inputs, 1));
*version_cycles_node_socket_float_value(mulSockB) = 0.5f;
bNodeSocket *mulSockOut = nodeFindSocket(mulNode, SOCK_OUT, "Value");
bNodeSocket *mulSockOut = blender::bke::nodeFindSocket(mulNode, SOCK_OUT, "Value");
nodeRemLink(ntree, sockDistortion->link);
nodeAddLink(ntree, distortionInputNode, distortionInputSock, mulNode, mulSockA);
nodeAddLink(ntree, mulNode, mulSockOut, node, sockDistortion);
blender::bke::nodeRemLink(ntree, sockDistortion->link);
blender::bke::nodeAddLink(ntree, distortionInputNode, distortionInputSock, mulNode, mulSockA);
blender::bke::nodeAddLink(ntree, mulNode, mulSockOut, node, sockDistortion);
need_update = true;
}
@ -2172,7 +2172,7 @@ static void update_wave_node_directions_and_offset(bNodeTree *ntree)
tex->rings_direction = SHD_WAVE_RINGS_DIRECTION_SPHERICAL;
if (tex->wave_profile == SHD_WAVE_PROFILE_SIN) {
bNodeSocket *sockPhaseOffset = nodeFindSocket(node, SOCK_IN, "Phase Offset");
bNodeSocket *sockPhaseOffset = blender::bke::nodeFindSocket(node, SOCK_IN, "Phase Offset");
*version_cycles_node_socket_float_value(sockPhaseOffset) = M_PI_2;
}
}
@ -5415,7 +5415,7 @@ void blo_do_versions_280(FileData *fd, Library * /*lib*/, Main *bmain)
if (!MAIN_VERSION_FILE_ATLEAST(bmain, 281, 4)) {
ID *id;
FOREACH_MAIN_ID_BEGIN (bmain, id) {
bNodeTree *ntree = ntreeFromID(id);
bNodeTree *ntree = blender::bke::ntreeFromID(id);
if (ntree) {
ntree->id.flag |= LIB_EMBEDDED_DATA;
}

10
source/blender/blenloader/intern/versioning_290.cc
View file

@ -394,10 +394,10 @@ static void version_node_socket_duplicate(bNodeTree *ntree,
LISTBASE_FOREACH_MUTABLE (bNodeLink *, link, &ntree->links) {
if (link->tonode->type == node_type) {
bNode *node = link->tonode;
bNodeSocket *dest_socket = nodeFindSocket(node, SOCK_IN, new_name);
bNodeSocket *dest_socket = blender::bke::nodeFindSocket(node, SOCK_IN, new_name);
BLI_assert(dest_socket);
if (STREQ(link->tosock->name, old_name)) {
nodeAddLink(ntree, link->fromnode, link->fromsock, node, dest_socket);
blender::bke::nodeAddLink(ntree, link->fromnode, link->fromsock, node, dest_socket);
}
}
}
@ -405,8 +405,8 @@ static void version_node_socket_duplicate(bNodeTree *ntree,
/* Duplicate the default value from the old socket and assign it to the new socket. */
LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
if (node->type == node_type) {
bNodeSocket *source_socket = nodeFindSocket(node, SOCK_IN, old_name);
bNodeSocket *dest_socket = nodeFindSocket(node, SOCK_IN, new_name);
bNodeSocket *source_socket = blender::bke::nodeFindSocket(node, SOCK_IN, old_name);
bNodeSocket *dest_socket = blender::bke::nodeFindSocket(node, SOCK_IN, new_name);
BLI_assert(source_socket && dest_socket);
if (dest_socket->default_value) {
MEM_freeN(dest_socket->default_value);
@ -802,7 +802,7 @@ static void version_node_join_geometry_for_multi_input_socket(bNodeTree *ntree)
bNodeSocket *socket = static_cast<bNodeSocket *>(node->inputs.first);
socket->flag |= SOCK_MULTI_INPUT;
socket->limit = 4095;
nodeRemoveSocket(ntree, node, socket->next);
blender::bke::nodeRemoveSocket(ntree, node, socket->next);
}
}
}

130
source/blender/blenloader/intern/versioning_300.cc
View file

@ -552,75 +552,75 @@ static void version_geometry_nodes_add_realize_instance_nodes(bNodeTree *ntree)
*/
static bNodeTree *add_realize_node_tree(Main *bmain)
{
bNodeTree *node_tree = ntreeAddTree(bmain, "Realize Instances 2.93 Legacy", "GeometryNodeTree");
bNodeTree *node_tree = blender::bke::ntreeAddTree(bmain, "Realize Instances 2.93 Legacy", "GeometryNodeTree");
node_tree->tree_interface.add_socket(
"Geometry", "", "NodeSocketGeometry", NODE_INTERFACE_SOCKET_OUTPUT, nullptr);
node_tree->tree_interface.add_socket(
"Geometry", "", "NodeSocketGeometry", NODE_INTERFACE_SOCKET_INPUT, nullptr);
bNode *group_input = nodeAddStaticNode(nullptr, node_tree, NODE_GROUP_INPUT);
bNode *group_input = blender::bke::nodeAddStaticNode(nullptr, node_tree, NODE_GROUP_INPUT);
group_input->locx = -400.0f;
bNode *group_output = nodeAddStaticNode(nullptr, node_tree, NODE_GROUP_OUTPUT);
bNode *group_output = blender::bke::nodeAddStaticNode(nullptr, node_tree, NODE_GROUP_OUTPUT);
group_output->locx = 500.0f;
group_output->flag |= NODE_DO_OUTPUT;
bNode *join = nodeAddStaticNode(nullptr, node_tree, GEO_NODE_JOIN_GEOMETRY);
bNode *join = blender::bke::nodeAddStaticNode(nullptr, node_tree, GEO_NODE_JOIN_GEOMETRY);
join->locx = group_output->locx - 175.0f;
join->locy = group_output->locy;
bNode *conv = nodeAddStaticNode(nullptr, node_tree, GEO_NODE_POINTS_TO_VERTICES);
bNode *conv = blender::bke::nodeAddStaticNode(nullptr, node_tree, GEO_NODE_POINTS_TO_VERTICES);
conv->locx = join->locx - 175.0f;
conv->locy = join->locy - 70.0;
bNode *separate = nodeAddStaticNode(nullptr, node_tree, GEO_NODE_SEPARATE_COMPONENTS);
bNode *separate = blender::bke::nodeAddStaticNode(nullptr, node_tree, GEO_NODE_SEPARATE_COMPONENTS);
separate->locx = join->locx - 350.0f;
separate->locy = join->locy + 50.0f;
bNode *realize = nodeAddStaticNode(nullptr, node_tree, GEO_NODE_REALIZE_INSTANCES);
bNode *realize = blender::bke::nodeAddStaticNode(nullptr, node_tree, GEO_NODE_REALIZE_INSTANCES);
realize->locx = separate->locx - 200.0f;
realize->locy = join->locy;
nodeAddLink(node_tree,
blender::bke::nodeAddLink(node_tree,
group_input,
static_cast<bNodeSocket *>(group_input->outputs.first),
realize,
static_cast<bNodeSocket *>(realize->inputs.first));
nodeAddLink(node_tree,
blender::bke::nodeAddLink(node_tree,
realize,
static_cast<bNodeSocket *>(realize->outputs.first),
separate,
static_cast<bNodeSocket *>(separate->inputs.first));
nodeAddLink(node_tree,
blender::bke::nodeAddLink(node_tree,
conv,
static_cast<bNodeSocket *>(conv->outputs.first),
join,
static_cast<bNodeSocket *>(join->inputs.first));
nodeAddLink(node_tree,
blender::bke::nodeAddLink(node_tree,
separate,
static_cast<bNodeSocket *>(BLI_findlink(&separate->outputs, 3)),
join,
static_cast<bNodeSocket *>(join->inputs.first));
nodeAddLink(node_tree,
blender::bke::nodeAddLink(node_tree,
separate,
static_cast<bNodeSocket *>(BLI_findlink(&separate->outputs, 1)),
conv,
static_cast<bNodeSocket *>(conv->inputs.first));
nodeAddLink(node_tree,
blender::bke::nodeAddLink(node_tree,
separate,
static_cast<bNodeSocket *>(BLI_findlink(&separate->outputs, 2)),
join,
static_cast<bNodeSocket *>(join->inputs.first));
nodeAddLink(node_tree,
blender::bke::nodeAddLink(node_tree,
separate,
static_cast<bNodeSocket *>(separate->outputs.first),
join,
static_cast<bNodeSocket *>(join->inputs.first));
nodeAddLink(node_tree,
blender::bke::nodeAddLink(node_tree,
join,
static_cast<bNodeSocket *>(join->outputs.first),
group_output,
static_cast<bNodeSocket *>(group_output->inputs.first));
LISTBASE_FOREACH (bNode *, node, &node_tree->nodes) {
nodeSetSelected(node, false);
blender::bke::nodeSetSelected(node, false);
}
version_socket_update_is_used(node_tree);
@ -698,17 +698,17 @@ static void version_geometry_nodes_replace_transfer_attribute_node(bNodeTree *nt
using namespace blender;
using namespace blender::bke;
/* Otherwise `ntree->typeInfo` is null. */
ntreeSetTypes(nullptr, ntree);
blender::bke::ntreeSetTypes(nullptr, ntree);
LISTBASE_FOREACH_MUTABLE (bNode *, node, &ntree->nodes) {
if (node->type != GEO_NODE_TRANSFER_ATTRIBUTE_DEPRECATED) {
continue;
}
bNodeSocket *old_geometry_socket = nodeFindSocket(node, SOCK_IN, "Source");
bNodeSocket *old_geometry_socket = blender::bke::nodeFindSocket(node, SOCK_IN, "Source");
const NodeGeometryTransferAttribute *storage = (const NodeGeometryTransferAttribute *)
node->storage;
switch (storage->mode) {
case GEO_NODE_ATTRIBUTE_TRANSFER_NEAREST_FACE_INTERPOLATED: {
bNode *sample_nearest_surface = nodeAddStaticNode(
bNode *sample_nearest_surface = blender::bke::nodeAddStaticNode(
nullptr, ntree, GEO_NODE_SAMPLE_NEAREST_SURFACE);
sample_nearest_surface->parent = node->parent;
sample_nearest_surface->custom1 = storage->data_type;
@ -737,7 +737,7 @@ static void version_geometry_nodes_replace_transfer_attribute_node(bNodeTree *nt
AttrDomain(storage->domain);
/* Use a sample index node to retrieve the data with this node's index output. */
bNode *sample_index = nodeAddStaticNode(nullptr, ntree, GEO_NODE_SAMPLE_INDEX);
bNode *sample_index = blender::bke::nodeAddStaticNode(nullptr, ntree, GEO_NODE_SAMPLE_INDEX);
NodeGeometrySampleIndex *sample_storage = static_cast<NodeGeometrySampleIndex *>(
sample_index->storage);
sample_storage->data_type = storage->data_type;
@ -746,25 +746,25 @@ static void version_geometry_nodes_replace_transfer_attribute_node(bNodeTree *nt
sample_index->locx = node->locx + 25.0f;
sample_index->locy = node->locy;
if (old_geometry_socket->link) {
nodeAddLink(ntree,
blender::bke::nodeAddLink(ntree,
old_geometry_socket->link->fromnode,
old_geometry_socket->link->fromsock,
sample_index,
nodeFindSocket(sample_index, SOCK_IN, "Geometry"));
blender::bke::nodeFindSocket(sample_index, SOCK_IN, "Geometry"));
}
bNode *sample_nearest = nodeAddStaticNode(nullptr, ntree, GEO_NODE_SAMPLE_NEAREST);
bNode *sample_nearest = blender::bke::nodeAddStaticNode(nullptr, ntree, GEO_NODE_SAMPLE_NEAREST);
sample_nearest->parent = node->parent;
sample_nearest->custom1 = storage->data_type;
sample_nearest->custom2 = int8_t(domain);
sample_nearest->locx = node->locx - 25.0f;
sample_nearest->locy = node->locy;
if (old_geometry_socket->link) {
nodeAddLink(ntree,
blender::bke::nodeAddLink(ntree,
old_geometry_socket->link->fromnode,
old_geometry_socket->link->fromsock,
sample_nearest,
nodeFindSocket(sample_nearest, SOCK_IN, "Geometry"));
blender::bke::nodeFindSocket(sample_nearest, SOCK_IN, "Geometry"));
}
static auto sample_nearest_remap = []() {
Map<std::string, std::string> map;
@ -785,15 +785,15 @@ static void version_geometry_nodes_replace_transfer_attribute_node(bNodeTree *nt
}();
node_tree_relink_with_socket_id_map(*ntree, *node, *sample_index, sample_index_remap);
nodeAddLink(ntree,
blender::bke::nodeAddLink(ntree,
sample_nearest,
nodeFindSocket(sample_nearest, SOCK_OUT, "Index"),
blender::bke::nodeFindSocket(sample_nearest, SOCK_OUT, "Index"),
sample_index,
nodeFindSocket(sample_index, SOCK_IN, "Index"));
blender::bke::nodeFindSocket(sample_index, SOCK_IN, "Index"));
break;
}
case GEO_NODE_ATTRIBUTE_TRANSFER_INDEX: {
bNode *sample_index = nodeAddStaticNode(nullptr, ntree, GEO_NODE_SAMPLE_INDEX);
bNode *sample_index = blender::bke::nodeAddStaticNode(nullptr, ntree, GEO_NODE_SAMPLE_INDEX);
NodeGeometrySampleIndex *sample_storage = static_cast<NodeGeometrySampleIndex *>(
sample_index->storage);
sample_storage->data_type = storage->data_type;
@ -802,7 +802,7 @@ static void version_geometry_nodes_replace_transfer_attribute_node(bNodeTree *nt
sample_index->parent = node->parent;
sample_index->locx = node->locx;
sample_index->locy = node->locy;
const bool index_was_linked = nodeFindSocket(node, SOCK_IN, "Index")->link != nullptr;
const bool index_was_linked = blender::bke::nodeFindSocket(node, SOCK_IN, "Index")->link != nullptr;
static auto socket_remap = []() {
Map<std::string, std::string> map;
map.add_new("Attribute", "Value");
@ -818,22 +818,22 @@ static void version_geometry_nodes_replace_transfer_attribute_node(bNodeTree *nt
if (!index_was_linked) {
/* Add an index input node, since the new node doesn't use an implicit input. */
bNode *index = nodeAddStaticNode(nullptr, ntree, GEO_NODE_INPUT_INDEX);
bNode *index = blender::bke::nodeAddStaticNode(nullptr, ntree, GEO_NODE_INPUT_INDEX);
index->parent = node->parent;
index->locx = node->locx - 25.0f;
index->locy = node->locy - 25.0f;
nodeAddLink(ntree,
blender::bke::nodeAddLink(ntree,
index,
nodeFindSocket(index, SOCK_OUT, "Index"),
blender::bke::nodeFindSocket(index, SOCK_OUT, "Index"),
sample_index,
nodeFindSocket(sample_index, SOCK_IN, "Index"));
blender::bke::nodeFindSocket(sample_index, SOCK_IN, "Index"));
}
break;
}
}
/* The storage must be freed manually because the node type isn't defined anymore. */
MEM_freeN(node->storage);
nodeRemoveNode(nullptr, ntree, node, false);
blender::bke::nodeRemoveNode(nullptr, ntree, node, false);
}
}
@ -869,10 +869,10 @@ static void version_geometry_nodes_primitive_uv_maps(bNodeTree &ntree)
if (uv_map_output_socket != nullptr) {
continue;
}
uv_map_output_socket = nodeAddStaticSocket(
uv_map_output_socket = blender::bke::nodeAddStaticSocket(
&ntree, node, SOCK_OUT, SOCK_VECTOR, PROP_NONE, "UV Map", "UV Map");
bNode *store_attribute_node = nodeAddStaticNode(
bNode *store_attribute_node = blender::bke::nodeAddStaticNode(
nullptr, &ntree, GEO_NODE_STORE_NAMED_ATTRIBUTE);
new_nodes.append(store_attribute_node);
store_attribute_node->parent = node->parent;
@ -909,12 +909,12 @@ static void version_geometry_nodes_primitive_uv_maps(bNodeTree &ntree)
"uv_map";
STRNCPY(name_value->value, uv_map_name);
nodeAddLink(&ntree,
blender::bke::nodeAddLink(&ntree,
node,
primitive_output_socket,
store_attribute_node,
store_attribute_geometry_input);
nodeAddLink(
blender::bke::nodeAddLink(
&ntree, node, uv_map_output_socket, store_attribute_node, store_attribute_value_input);
}
@ -946,8 +946,8 @@ static void version_geometry_nodes_extrude_smooth_propagation(bNodeTree &ntree)
{
continue;
}
bNodeSocket *geometry_in_socket = nodeFindSocket(node, SOCK_IN, "Mesh");
bNodeSocket *geometry_out_socket = nodeFindSocket(node, SOCK_OUT, "Mesh");
bNodeSocket *geometry_in_socket = blender::bke::nodeFindSocket(node, SOCK_IN, "Mesh");
bNodeSocket *geometry_out_socket = blender::bke::nodeFindSocket(node, SOCK_OUT, "Mesh");
Map<bNodeSocket *, bNodeLink *> in_links_per_socket;
MultiValueMap<bNodeSocket *, bNodeLink *> out_links_per_socket;
@ -974,7 +974,7 @@ static void version_geometry_nodes_extrude_smooth_propagation(bNodeTree &ntree)
{
return false;
}
bNodeSocket *capture_in_socket = nodeFindSocket(capture_node, SOCK_IN, "Value_003");
bNodeSocket *capture_in_socket = blender::bke::nodeFindSocket(capture_node, SOCK_IN, "Value_003");
bNodeLink *capture_in_link = in_links_per_socket.lookup_default(capture_in_socket, nullptr);
if (!capture_in_link) {
return false;
@ -990,7 +990,7 @@ static void version_geometry_nodes_extrude_smooth_propagation(bNodeTree &ntree)
return false;
}
bNode *set_smooth_node = geometry_out_link->tonode;
bNodeSocket *smooth_in_socket = nodeFindSocket(set_smooth_node, SOCK_IN, "Shade Smooth");
bNodeSocket *smooth_in_socket = blender::bke::nodeFindSocket(set_smooth_node, SOCK_IN, "Shade Smooth");
bNodeLink *connecting_link = in_links_per_socket.lookup_default(smooth_in_socket, nullptr);
if (!connecting_link) {
return false;
@ -1004,7 +1004,7 @@ static void version_geometry_nodes_extrude_smooth_propagation(bNodeTree &ntree)
continue;
}
bNode *capture_node = nodeAddNode(nullptr, &ntree, "GeometryNodeCaptureAttribute");
bNode *capture_node = blender::bke::nodeAddNode(nullptr, &ntree, "GeometryNodeCaptureAttribute");
capture_node->parent = node->parent;
capture_node->locx = node->locx - 25;
capture_node->locy = node->locy;
@ -1013,45 +1013,45 @@ static void version_geometry_nodes_extrude_smooth_propagation(bNodeTree &ntree)
static_cast<NodeGeometryAttributeCapture *>(capture_node->storage)->domain = int8_t(
bke::AttrDomain::Face);
bNode *is_smooth_node = nodeAddNode(nullptr, &ntree, "GeometryNodeInputShadeSmooth");
bNode *is_smooth_node = blender::bke::nodeAddNode(nullptr, &ntree, "GeometryNodeInputShadeSmooth");
is_smooth_node->parent = node->parent;
is_smooth_node->locx = capture_node->locx - 25;
is_smooth_node->locy = capture_node->locy;
new_nodes.append(is_smooth_node);
nodeAddLink(&ntree,
blender::bke::nodeAddLink(&ntree,
is_smooth_node,
nodeFindSocket(is_smooth_node, SOCK_OUT, "Smooth"),
blender::bke::nodeFindSocket(is_smooth_node, SOCK_OUT, "Smooth"),
capture_node,
nodeFindSocket(capture_node, SOCK_IN, "Value"));
nodeAddLink(&ntree,
blender::bke::nodeFindSocket(capture_node, SOCK_IN, "Value"));
blender::bke::nodeAddLink(&ntree,
capture_node,
nodeFindSocket(capture_node, SOCK_OUT, "Geometry"),
blender::bke::nodeFindSocket(capture_node, SOCK_OUT, "Geometry"),
node,
geometry_in_socket);
geometry_in_link->tonode = capture_node;
geometry_in_link->tosock = nodeFindSocket(capture_node, SOCK_IN, "Geometry");
geometry_in_link->tosock = blender::bke::nodeFindSocket(capture_node, SOCK_IN, "Geometry");
bNode *set_smooth_node = nodeAddNode(nullptr, &ntree, "GeometryNodeSetShadeSmooth");
bNode *set_smooth_node = blender::bke::nodeAddNode(nullptr, &ntree, "GeometryNodeSetShadeSmooth");
set_smooth_node->parent = node->parent;
set_smooth_node->locx = node->locx + 25;
set_smooth_node->locy = node->locy;
new_nodes.append(set_smooth_node);
nodeAddLink(&ntree,
blender::bke::nodeAddLink(&ntree,
node,
geometry_out_socket,
set_smooth_node,
nodeFindSocket(set_smooth_node, SOCK_IN, "Geometry"));
blender::bke::nodeFindSocket(set_smooth_node, SOCK_IN, "Geometry"));
bNodeSocket *smooth_geometry_out = nodeFindSocket(set_smooth_node, SOCK_OUT, "Geometry");
bNodeSocket *smooth_geometry_out = blender::bke::nodeFindSocket(set_smooth_node, SOCK_OUT, "Geometry");
for (bNodeLink *link : geometry_out_links) {
link->fromnode = set_smooth_node;
link->fromsock = smooth_geometry_out;
}
nodeAddLink(&ntree,
blender::bke::nodeAddLink(&ntree,
capture_node,
nodeFindSocket(capture_node, SOCK_OUT, "Attribute"),
blender::bke::nodeFindSocket(capture_node, SOCK_OUT, "Attribute"),
set_smooth_node,
nodeFindSocket(set_smooth_node, SOCK_IN, "Shade Smooth"));
blender::bke::nodeFindSocket(set_smooth_node, SOCK_IN, "Shade Smooth"));
}
/* Move nodes to the front so that they are drawn behind existing nodes. */
@ -1511,9 +1511,9 @@ static bNodeSocket *do_version_replace_float_size_with_vector(bNodeTree *ntree,
{
const bNodeSocketValueFloat *socket_value = (const bNodeSocketValueFloat *)socket->default_value;
const float old_value = socket_value->value;
nodeRemoveSocket(ntree, node, socket);
bNodeSocket *new_socket = nodeAddSocket(
ntree, node, SOCK_IN, nodeStaticSocketType(SOCK_VECTOR, PROP_TRANSLATION), "Size", "Size");
blender::bke::nodeRemoveSocket(ntree, node, socket);
bNodeSocket *new_socket = blender::bke::nodeAddSocket(
ntree, node, SOCK_IN, blender::bke::nodeStaticSocketType(SOCK_VECTOR, PROP_TRANSLATION), "Size", "Size");
bNodeSocketValueVector *value_vector = (bNodeSocketValueVector *)new_socket->default_value;
copy_v3_fl(value_vector->value, old_value);
return new_socket;
@ -1720,7 +1720,7 @@ static void version_geometry_nodes_set_position_node_offset(bNodeTree *ntree)
}
/* Change identifier of old socket, so that the there is no name collision. */
STRNCPY(old_offset_socket->identifier, "Offset_old");
nodeAddStaticSocket(ntree, node, SOCK_IN, SOCK_VECTOR, PROP_TRANSLATION, "Offset", "Offset");
blender::bke::nodeAddStaticSocket(ntree, node, SOCK_IN, SOCK_VECTOR, PROP_TRANSLATION, "Offset", "Offset");
}
/* Relink links that were connected to Position while Offset was enabled. */
@ -1749,7 +1749,7 @@ static void version_geometry_nodes_set_position_node_offset(bNodeTree *ntree)
continue;
}
bNodeSocket *old_offset_socket = static_cast<bNodeSocket *>(BLI_findlink(&node->inputs, 3));
nodeRemoveSocket(ntree, node, old_offset_socket);
blender::bke::nodeRemoveSocket(ntree, node, old_offset_socket);
}
}
@ -2868,7 +2868,7 @@ void blo_do_versions_300(FileData *fd, Library * /*lib*/, Main *bmain)
bNodeSocket *new_socket = do_version_replace_float_size_with_vector(
ntree, node, socket);
nodeAddLink(ntree, link_fromnode, link_fromsock, node, new_socket);
blender::bke::nodeAddLink(ntree, link_fromnode, link_fromsock, node, new_socket);
}
}
}
@ -4168,7 +4168,7 @@ void blo_do_versions_300(FileData *fd, Library * /*lib*/, Main *bmain)
}
static_cast<NodeGeometryCurveSample *>(node->storage)->use_all_curves = true;
static_cast<NodeGeometryCurveSample *>(node->storage)->data_type = CD_PROP_FLOAT;
bNodeSocket *curve_socket = nodeFindSocket(node, SOCK_IN, "Curve");
bNodeSocket *curve_socket = blender::bke::nodeFindSocket(node, SOCK_IN, "Curve");
BLI_assert(curve_socket != nullptr);
STRNCPY(curve_socket->name, "Curves");
STRNCPY(curve_socket->identifier, "Curves");

324
source/blender/blenloader/intern/versioning_400.cc
View file

@ -358,17 +358,17 @@ static void versioning_replace_splitviewer(bNodeTree *ntree)
MEM_freeN(node->storage);
node->storage = nullptr;
bNode *viewer_node = nodeAddStaticNode(nullptr, ntree, CMP_NODE_VIEWER);
bNode *viewer_node = blender::bke::nodeAddStaticNode(nullptr, ntree, CMP_NODE_VIEWER);
/* Nodes are created stacked on top of each other, so separate them a bit. */
viewer_node->locx = node->locx + node->width + viewer_node->width / 4.0f;
viewer_node->locy = node->locy;
viewer_node->flag &= ~NODE_PREVIEW;
bNodeSocket *split_out_socket = nodeAddStaticSocket(
bNodeSocket *split_out_socket = blender::bke::nodeAddStaticSocket(
ntree, node, SOCK_OUT, SOCK_IMAGE, PROP_NONE, "Image", "Image");
bNodeSocket *viewer_in_socket = nodeFindSocket(viewer_node, SOCK_IN, "Image");
bNodeSocket *viewer_in_socket = blender::bke::nodeFindSocket(viewer_node, SOCK_IN, "Image");
nodeAddLink(ntree, node, split_out_socket, viewer_node, viewer_in_socket);
blender::bke::nodeAddLink(ntree, node, split_out_socket, viewer_node, viewer_in_socket);
}
}
@ -639,7 +639,7 @@ static void version_mesh_crease_generic(Main &bmain)
"GeometryNodeStoreNamedAttribute",
"GeometryNodeInputNamedAttribute"))
{
bNodeSocket *socket = nodeFindSocket(node, SOCK_IN, "Name");
bNodeSocket *socket = blender::bke::nodeFindSocket(node, SOCK_IN, "Name");
if (STREQ(socket->default_value_typed<bNodeSocketValueString>()->value, "crease")) {
STRNCPY(socket->default_value_typed<bNodeSocketValueString>()->value, "crease_edge");
}
@ -696,7 +696,7 @@ static void versioning_remove_microfacet_sharp_distribution(bNodeTree *ntree)
}
if (socket->link != nullptr) {
nodeRemLink(ntree, socket->link);
blender::bke::nodeRemLink(ntree, socket->link);
}
bNodeSocketValueFloat *socket_value = (bNodeSocketValueFloat *)socket->default_value;
socket_value->value = 0.0f;
@ -719,20 +719,20 @@ static void version_replace_texcoord_normal_socket(bNodeTree *ntree)
LISTBASE_FOREACH_MUTABLE (bNodeLink *, link, &ntree->links) {
if (link->fromnode->type == SH_NODE_TEX_COORD && STREQ(link->fromsock->identifier, "Normal")) {
if (geometry_node == nullptr) {
geometry_node = nodeAddStaticNode(nullptr, ntree, SH_NODE_NEW_GEOMETRY);
incoming_socket = nodeFindSocket(geometry_node, SOCK_OUT, "Incoming");
geometry_node = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_NEW_GEOMETRY);
incoming_socket = blender::bke::nodeFindSocket(geometry_node, SOCK_OUT, "Incoming");
transform_node = nodeAddStaticNode(nullptr, ntree, SH_NODE_VECT_TRANSFORM);
vec_in_socket = nodeFindSocket(transform_node, SOCK_IN, "Vector");
vec_out_socket = nodeFindSocket(transform_node, SOCK_OUT, "Vector");
transform_node = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_VECT_TRANSFORM);
vec_in_socket = blender::bke::nodeFindSocket(transform_node, SOCK_IN, "Vector");
vec_out_socket = blender::bke::nodeFindSocket(transform_node, SOCK_OUT, "Vector");
NodeShaderVectTransform *nodeprop = (NodeShaderVectTransform *)transform_node->storage;
nodeprop->type = SHD_VECT_TRANSFORM_TYPE_NORMAL;
nodeAddLink(ntree, geometry_node, incoming_socket, transform_node, vec_in_socket);
blender::bke::nodeAddLink(ntree, geometry_node, incoming_socket, transform_node, vec_in_socket);
}
nodeAddLink(ntree, transform_node, vec_out_socket, link->tonode, link->tosock);
nodeRemLink(ntree, link);
blender::bke::nodeAddLink(ntree, transform_node, vec_out_socket, link->tonode, link->tosock);
blender::bke::nodeRemLink(ntree, link);
}
}
}
@ -743,9 +743,9 @@ static void version_principled_transmission_roughness(bNodeTree *ntree)
if (node->type != SH_NODE_BSDF_PRINCIPLED) {
continue;
}
bNodeSocket *sock = nodeFindSocket(node, SOCK_IN, "Transmission Roughness");
bNodeSocket *sock = blender::bke::nodeFindSocket(node, SOCK_IN, "Transmission Roughness");
if (sock != nullptr) {
nodeRemoveSocket(ntree, node, sock);
blender::bke::nodeRemoveSocket(ntree, node, sock);
}
}
}
@ -757,7 +757,7 @@ static void version_replace_velvet_sheen_node(bNodeTree *ntree)
if (node->type == SH_NODE_BSDF_SHEEN) {
STRNCPY(node->idname, "ShaderNodeBsdfSheen");
bNodeSocket *sigmaInput = nodeFindSocket(node, SOCK_IN, "Sigma");
bNodeSocket *sigmaInput = blender::bke::nodeFindSocket(node, SOCK_IN, "Sigma");
if (sigmaInput != nullptr) {
node->custom1 = SHD_SHEEN_ASHIKHMIN;
STRNCPY(sigmaInput->identifier, "Roughness");
@ -772,16 +772,16 @@ static void version_principled_bsdf_sheen(bNodeTree *ntree)
{
auto check_node = [](const bNode *node) {
return (node->type == SH_NODE_BSDF_PRINCIPLED) &&
(nodeFindSocket(node, SOCK_IN, "Sheen Roughness") == nullptr);
(blender::bke::nodeFindSocket(node, SOCK_IN, "Sheen Roughness") == nullptr);
};
auto update_input = [ntree](bNode *node, bNodeSocket *input) {
/* Change socket type to Color. */
nodeModifySocketTypeStatic(ntree, node, input, SOCK_RGBA, 0);
blender::bke::nodeModifySocketTypeStatic(ntree, node, input, SOCK_RGBA, 0);
/* Account for the change in intensity between the old and new model.
* If the Sheen input is set to a fixed value, adjust it and set the tint to white.
* Otherwise, if it's connected, keep it as-is but set the tint to 0.2 instead. */
bNodeSocket *sheen = nodeFindSocket(node, SOCK_IN, "Sheen");
bNodeSocket *sheen = blender::bke::nodeFindSocket(node, SOCK_IN, "Sheen");
if (sheen != nullptr && sheen->link == nullptr) {
*version_cycles_node_socket_float_value(sheen) *= 0.2f;
@ -809,7 +809,7 @@ static void version_refraction_depth_to_thickness_value(bNodeTree *ntree, float
continue;
}
bNodeSocket *thickness_socket = nodeFindSocket(node, SOCK_IN, "Thickness");
bNodeSocket *thickness_socket = blender::bke::nodeFindSocket(node, SOCK_IN, "Thickness");
if (thickness_socket == nullptr) {
continue;
}
@ -825,15 +825,15 @@ static void version_refraction_depth_to_thickness_value(bNodeTree *ntree, float
if (has_link) {
continue;
}
bNode *value_node = nodeAddStaticNode(nullptr, ntree, SH_NODE_VALUE);
bNode *value_node = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_VALUE);
value_node->parent = node->parent;
value_node->locx = node->locx;
value_node->locy = node->locy - 160.0f;
bNodeSocket *socket_value = nodeFindSocket(value_node, SOCK_OUT, "Value");
bNodeSocket *socket_value = blender::bke::nodeFindSocket(value_node, SOCK_OUT, "Value");
*version_cycles_node_socket_float_value(socket_value) = thickness;
nodeAddLink(ntree, value_node, socket_value, node, thickness_socket);
blender::bke::nodeAddLink(ntree, value_node, socket_value, node, thickness_socket);
}
version_socket_update_is_used(ntree);
@ -848,7 +848,7 @@ static void versioning_update_noise_texture_node(bNodeTree *ntree)
(static_cast<NodeTexNoise *>(node->storage))->type = SHD_NOISE_FBM;
bNodeSocket *roughness_socket = nodeFindSocket(node, SOCK_IN, "Roughness");
bNodeSocket *roughness_socket = blender::bke::nodeFindSocket(node, SOCK_IN, "Roughness");
if (roughness_socket == nullptr) {
/* Noise Texture node was created before the Roughness input was added. */
continue;
@ -872,24 +872,24 @@ static void versioning_update_noise_texture_node(bNodeTree *ntree)
if (roughness_link != nullptr) {
/* Add Clamp node before Roughness input. */
bNode *clamp_node = nodeAddStaticNode(nullptr, ntree, SH_NODE_CLAMP);
bNode *clamp_node = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_CLAMP);
clamp_node->parent = node->parent;
clamp_node->custom1 = NODE_CLAMP_MINMAX;
clamp_node->locx = node->locx;
clamp_node->locy = node->locy - 300.0f;
clamp_node->flag |= NODE_HIDDEN;
bNodeSocket *clamp_socket_value = nodeFindSocket(clamp_node, SOCK_IN, "Value");
bNodeSocket *clamp_socket_min = nodeFindSocket(clamp_node, SOCK_IN, "Min");
bNodeSocket *clamp_socket_max = nodeFindSocket(clamp_node, SOCK_IN, "Max");
bNodeSocket *clamp_socket_out = nodeFindSocket(clamp_node, SOCK_OUT, "Result");
bNodeSocket *clamp_socket_value = blender::bke::nodeFindSocket(clamp_node, SOCK_IN, "Value");
bNodeSocket *clamp_socket_min = blender::bke::nodeFindSocket(clamp_node, SOCK_IN, "Min");
bNodeSocket *clamp_socket_max = blender::bke::nodeFindSocket(clamp_node, SOCK_IN, "Max");
bNodeSocket *clamp_socket_out = blender::bke::nodeFindSocket(clamp_node, SOCK_OUT, "Result");
*version_cycles_node_socket_float_value(clamp_socket_min) = 0.0f;
*version_cycles_node_socket_float_value(clamp_socket_max) = 1.0f;
nodeRemLink(ntree, roughness_link);
nodeAddLink(
blender::bke::nodeRemLink(ntree, roughness_link);
blender::bke::nodeAddLink(
ntree, roughness_from_node, roughness_from_socket, clamp_node, clamp_socket_value);
nodeAddLink(ntree, clamp_node, clamp_socket_out, node, roughness_socket);
blender::bke::nodeAddLink(ntree, clamp_node, clamp_socket_out, node, roughness_socket);
}
else {
*roughness = std::clamp(*roughness, 0.0f, 1.0f);
@ -953,11 +953,11 @@ static void versioning_replace_musgrave_texture_node(bNodeTree *ntree)
uint8_t noise_type = (static_cast<NodeTexNoise *>(node->storage))->type;
float locy_offset = 0.0f;
bNodeSocket *fac_socket = nodeFindSocket(node, SOCK_OUT, "Fac");
bNodeSocket *fac_socket = blender::bke::nodeFindSocket(node, SOCK_OUT, "Fac");
/* Clear label because Musgrave output socket label is set to "Height" instead of "Fac". */
fac_socket->label[0] = '\0';
bNodeSocket *detail_socket = nodeFindSocket(node, SOCK_IN, "Detail");
bNodeSocket *detail_socket = blender::bke::nodeFindSocket(node, SOCK_IN, "Detail");
float *detail = version_cycles_node_socket_float_value(detail_socket);
if (detail_link != nullptr) {
@ -965,7 +965,7 @@ static void versioning_replace_musgrave_texture_node(bNodeTree *ntree)
/* Add Minimum Math node and Subtract Math node before Detail input. */
bNode *min_node = nodeAddStaticNode(nullptr, ntree, SH_NODE_MATH);
bNode *min_node = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_MATH);
min_node->parent = node->parent;
min_node->custom1 = NODE_MATH_MINIMUM;
min_node->locx = node->locx;
@ -973,9 +973,9 @@ static void versioning_replace_musgrave_texture_node(bNodeTree *ntree)
min_node->flag |= NODE_HIDDEN;
bNodeSocket *min_socket_A = static_cast<bNodeSocket *>(BLI_findlink(&min_node->inputs, 0));
bNodeSocket *min_socket_B = static_cast<bNodeSocket *>(BLI_findlink(&min_node->inputs, 1));
bNodeSocket *min_socket_out = nodeFindSocket(min_node, SOCK_OUT, "Value");
bNodeSocket *min_socket_out = blender::bke::nodeFindSocket(min_node, SOCK_OUT, "Value");
bNode *sub1_node = nodeAddStaticNode(nullptr, ntree, SH_NODE_MATH);
bNode *sub1_node = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_MATH);
sub1_node->parent = node->parent;
sub1_node->custom1 = NODE_MATH_SUBTRACT;
sub1_node->locx = node->locx;
@ -983,22 +983,22 @@ static void versioning_replace_musgrave_texture_node(bNodeTree *ntree)
sub1_node->flag |= NODE_HIDDEN;
bNodeSocket *sub1_socket_A = static_cast<bNodeSocket *>(BLI_findlink(&sub1_node->inputs, 0));
bNodeSocket *sub1_socket_B = static_cast<bNodeSocket *>(BLI_findlink(&sub1_node->inputs, 1));
bNodeSocket *sub1_socket_out = nodeFindSocket(sub1_node, SOCK_OUT, "Value");
bNodeSocket *sub1_socket_out = blender::bke::nodeFindSocket(sub1_node, SOCK_OUT, "Value");
*version_cycles_node_socket_float_value(min_socket_B) = 14.0f;
*version_cycles_node_socket_float_value(sub1_socket_B) = 1.0f;
nodeRemLink(ntree, detail_link);
nodeAddLink(ntree, detail_from_node, detail_from_socket, sub1_node, sub1_socket_A);
nodeAddLink(ntree, sub1_node, sub1_socket_out, min_node, min_socket_A);
nodeAddLink(ntree, min_node, min_socket_out, node, detail_socket);
blender::bke::nodeRemLink(ntree, detail_link);
blender::bke::nodeAddLink(ntree, detail_from_node, detail_from_socket, sub1_node, sub1_socket_A);
blender::bke::nodeAddLink(ntree, sub1_node, sub1_socket_out, min_node, min_socket_A);
blender::bke::nodeAddLink(ntree, min_node, min_socket_out, node, detail_socket);
if (ELEM(noise_type, SHD_NOISE_RIDGED_MULTIFRACTAL, SHD_NOISE_HETERO_TERRAIN)) {
locy_offset -= 40.0f;
/* Add Greater Than Math node before Subtract Math node. */
bNode *greater_node = nodeAddStaticNode(nullptr, ntree, SH_NODE_MATH);
bNode *greater_node = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_MATH);
greater_node->parent = node->parent;
greater_node->custom1 = NODE_MATH_GREATER_THAN;
greater_node->locx = node->locx;
@ -1008,28 +1008,28 @@ static void versioning_replace_musgrave_texture_node(bNodeTree *ntree)
BLI_findlink(&greater_node->inputs, 0));
bNodeSocket *greater_socket_B = static_cast<bNodeSocket *>(
BLI_findlink(&greater_node->inputs, 1));
bNodeSocket *greater_socket_out = nodeFindSocket(greater_node, SOCK_OUT, "Value");
bNodeSocket *greater_socket_out = blender::bke::nodeFindSocket(greater_node, SOCK_OUT, "Value");
*version_cycles_node_socket_float_value(greater_socket_B) = 1.0f;
nodeAddLink(ntree, detail_from_node, detail_from_socket, greater_node, greater_socket_A);
nodeAddLink(ntree, greater_node, greater_socket_out, sub1_node, sub1_socket_B);
blender::bke::nodeAddLink(ntree, detail_from_node, detail_from_socket, greater_node, greater_socket_A);
blender::bke::nodeAddLink(ntree, greater_node, greater_socket_out, sub1_node, sub1_socket_B);
}
else {
/* Add Clamp node and Multiply Math node behind Fac output. */
bNode *clamp_node = nodeAddStaticNode(nullptr, ntree, SH_NODE_CLAMP);
bNode *clamp_node = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_CLAMP);
clamp_node->parent = node->parent;
clamp_node->custom1 = NODE_CLAMP_MINMAX;
clamp_node->locx = node->locx;
clamp_node->locy = node->locy + 40.0f;
clamp_node->flag |= NODE_HIDDEN;
bNodeSocket *clamp_socket_value = nodeFindSocket(clamp_node, SOCK_IN, "Value");
bNodeSocket *clamp_socket_min = nodeFindSocket(clamp_node, SOCK_IN, "Min");
bNodeSocket *clamp_socket_max = nodeFindSocket(clamp_node, SOCK_IN, "Max");
bNodeSocket *clamp_socket_out = nodeFindSocket(clamp_node, SOCK_OUT, "Result");
bNodeSocket *clamp_socket_value = blender::bke::nodeFindSocket(clamp_node, SOCK_IN, "Value");
bNodeSocket *clamp_socket_min = blender::bke::nodeFindSocket(clamp_node, SOCK_IN, "Min");
bNodeSocket *clamp_socket_max = blender::bke::nodeFindSocket(clamp_node, SOCK_IN, "Max");
bNodeSocket *clamp_socket_out = blender::bke::nodeFindSocket(clamp_node, SOCK_OUT, "Result");
bNode *mul_node = nodeAddStaticNode(nullptr, ntree, SH_NODE_MATH);
bNode *mul_node = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_MATH);
mul_node->parent = node->parent;
mul_node->custom1 = NODE_MATH_MULTIPLY;
mul_node->locx = node->locx;
@ -1037,7 +1037,7 @@ static void versioning_replace_musgrave_texture_node(bNodeTree *ntree)
mul_node->flag |= NODE_HIDDEN;
bNodeSocket *mul_socket_A = static_cast<bNodeSocket *>(BLI_findlink(&mul_node->inputs, 0));
bNodeSocket *mul_socket_B = static_cast<bNodeSocket *>(BLI_findlink(&mul_node->inputs, 1));
bNodeSocket *mul_socket_out = nodeFindSocket(mul_node, SOCK_OUT, "Value");
bNodeSocket *mul_socket_out = blender::bke::nodeFindSocket(mul_node, SOCK_OUT, "Value");
*version_cycles_node_socket_float_value(clamp_socket_min) = 0.0f;
*version_cycles_node_socket_float_value(clamp_socket_max) = 1.0f;
@ -1045,7 +1045,7 @@ static void versioning_replace_musgrave_texture_node(bNodeTree *ntree)
if (noise_type == SHD_NOISE_MULTIFRACTAL) {
/* Add Subtract Math node and Add Math node after Multiply Math node. */
bNode *sub2_node = nodeAddStaticNode(nullptr, ntree, SH_NODE_MATH);
bNode *sub2_node = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_MATH);
sub2_node->parent = node->parent;
sub2_node->custom1 = NODE_MATH_SUBTRACT;
sub2_node->custom2 = SHD_MATH_CLAMP;
@ -1056,9 +1056,9 @@ static void versioning_replace_musgrave_texture_node(bNodeTree *ntree)
BLI_findlink(&sub2_node->inputs, 0));
bNodeSocket *sub2_socket_B = static_cast<bNodeSocket *>(
BLI_findlink(&sub2_node->inputs, 1));
bNodeSocket *sub2_socket_out = nodeFindSocket(sub2_node, SOCK_OUT, "Value");
bNodeSocket *sub2_socket_out = blender::bke::nodeFindSocket(sub2_node, SOCK_OUT, "Value");
bNode *add_node = nodeAddStaticNode(nullptr, ntree, SH_NODE_MATH);
bNode *add_node = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_MATH);
add_node->parent = node->parent;
add_node->custom1 = NODE_MATH_ADD;
add_node->locx = node->locx;
@ -1068,33 +1068,33 @@ static void versioning_replace_musgrave_texture_node(bNodeTree *ntree)
BLI_findlink(&add_node->inputs, 0));
bNodeSocket *add_socket_B = static_cast<bNodeSocket *>(
BLI_findlink(&add_node->inputs, 1));
bNodeSocket *add_socket_out = nodeFindSocket(add_node, SOCK_OUT, "Value");
bNodeSocket *add_socket_out = blender::bke::nodeFindSocket(add_node, SOCK_OUT, "Value");
*version_cycles_node_socket_float_value(sub2_socket_A) = 1.0f;
LISTBASE_FOREACH_BACKWARD_MUTABLE (bNodeLink *, link, &ntree->links) {
if (link->fromsock == fac_socket) {
nodeAddLink(ntree, add_node, add_socket_out, link->tonode, link->tosock);
nodeRemLink(ntree, link);
blender::bke::nodeAddLink(ntree, add_node, add_socket_out, link->tonode, link->tosock);
blender::bke::nodeRemLink(ntree, link);
}
}
nodeAddLink(ntree, mul_node, mul_socket_out, add_node, add_socket_A);
nodeAddLink(ntree, detail_from_node, detail_from_socket, sub2_node, sub2_socket_B);
nodeAddLink(ntree, sub2_node, sub2_socket_out, add_node, add_socket_B);
blender::bke::nodeAddLink(ntree, mul_node, mul_socket_out, add_node, add_socket_A);
blender::bke::nodeAddLink(ntree, detail_from_node, detail_from_socket, sub2_node, sub2_socket_B);
blender::bke::nodeAddLink(ntree, sub2_node, sub2_socket_out, add_node, add_socket_B);
}
else {
LISTBASE_FOREACH_BACKWARD_MUTABLE (bNodeLink *, link, &ntree->links) {
if (link->fromsock == fac_socket) {
nodeAddLink(ntree, mul_node, mul_socket_out, link->tonode, link->tosock);
nodeRemLink(ntree, link);
blender::bke::nodeAddLink(ntree, mul_node, mul_socket_out, link->tonode, link->tosock);
blender::bke::nodeRemLink(ntree, link);
}
}
}
nodeAddLink(ntree, node, fac_socket, mul_node, mul_socket_A);
nodeAddLink(ntree, detail_from_node, detail_from_socket, clamp_node, clamp_socket_value);
nodeAddLink(ntree, clamp_node, clamp_socket_out, mul_node, mul_socket_B);
blender::bke::nodeAddLink(ntree, node, fac_socket, mul_node, mul_socket_A);
blender::bke::nodeAddLink(ntree, detail_from_node, detail_from_socket, clamp_node, clamp_socket_value);
blender::bke::nodeAddLink(ntree, clamp_node, clamp_socket_out, mul_node, mul_socket_B);
}
}
else {
@ -1102,7 +1102,7 @@ static void versioning_replace_musgrave_texture_node(bNodeTree *ntree)
if (!ELEM(noise_type, SHD_NOISE_RIDGED_MULTIFRACTAL, SHD_NOISE_HETERO_TERRAIN)) {
/* Add Multiply Math node behind Fac output. */
bNode *mul_node = nodeAddStaticNode(nullptr, ntree, SH_NODE_MATH);
bNode *mul_node = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_MATH);
mul_node->parent = node->parent;
mul_node->custom1 = NODE_MATH_MULTIPLY;
mul_node->locx = node->locx;
@ -1112,14 +1112,14 @@ static void versioning_replace_musgrave_texture_node(bNodeTree *ntree)
BLI_findlink(&mul_node->inputs, 0));
bNodeSocket *mul_socket_B = static_cast<bNodeSocket *>(
BLI_findlink(&mul_node->inputs, 1));
bNodeSocket *mul_socket_out = nodeFindSocket(mul_node, SOCK_OUT, "Value");
bNodeSocket *mul_socket_out = blender::bke::nodeFindSocket(mul_node, SOCK_OUT, "Value");
*version_cycles_node_socket_float_value(mul_socket_B) = *detail;
if (noise_type == SHD_NOISE_MULTIFRACTAL) {
/* Add an Add Math node after Multiply Math node. */
bNode *add_node = nodeAddStaticNode(nullptr, ntree, SH_NODE_MATH);
bNode *add_node = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_MATH);
add_node->parent = node->parent;
add_node->custom1 = NODE_MATH_ADD;
add_node->locx = node->locx;
@ -1129,29 +1129,29 @@ static void versioning_replace_musgrave_texture_node(bNodeTree *ntree)
BLI_findlink(&add_node->inputs, 0));
bNodeSocket *add_socket_B = static_cast<bNodeSocket *>(
BLI_findlink(&add_node->inputs, 1));
bNodeSocket *add_socket_out = nodeFindSocket(add_node, SOCK_OUT, "Value");
bNodeSocket *add_socket_out = blender::bke::nodeFindSocket(add_node, SOCK_OUT, "Value");
*version_cycles_node_socket_float_value(add_socket_B) = 1.0f - *detail;
LISTBASE_FOREACH_BACKWARD_MUTABLE (bNodeLink *, link, &ntree->links) {
if (link->fromsock == fac_socket) {
nodeAddLink(ntree, add_node, add_socket_out, link->tonode, link->tosock);
nodeRemLink(ntree, link);
blender::bke::nodeAddLink(ntree, add_node, add_socket_out, link->tonode, link->tosock);
blender::bke::nodeRemLink(ntree, link);
}
}
nodeAddLink(ntree, mul_node, mul_socket_out, add_node, add_socket_A);
blender::bke::nodeAddLink(ntree, mul_node, mul_socket_out, add_node, add_socket_A);
}
else {
LISTBASE_FOREACH_BACKWARD_MUTABLE (bNodeLink *, link, &ntree->links) {
if (link->fromsock == fac_socket) {
nodeAddLink(ntree, mul_node, mul_socket_out, link->tonode, link->tosock);
nodeRemLink(ntree, link);
blender::bke::nodeAddLink(ntree, mul_node, mul_socket_out, link->tonode, link->tosock);
blender::bke::nodeRemLink(ntree, link);
}
}
}
nodeAddLink(ntree, node, fac_socket, mul_node, mul_socket_A);
blender::bke::nodeAddLink(ntree, node, fac_socket, mul_node, mul_socket_A);
*detail = 0.0f;
}
@ -1161,9 +1161,9 @@ static void versioning_replace_musgrave_texture_node(bNodeTree *ntree)
}
}
bNodeSocket *roughness_socket = nodeFindSocket(node, SOCK_IN, "Roughness");
bNodeSocket *roughness_socket = blender::bke::nodeFindSocket(node, SOCK_IN, "Roughness");
float *roughness = version_cycles_node_socket_float_value(roughness_socket);
bNodeSocket *lacunarity_socket = nodeFindSocket(node, SOCK_IN, "Lacunarity");
bNodeSocket *lacunarity_socket = blender::bke::nodeFindSocket(node, SOCK_IN, "Lacunarity");
float *lacunarity = version_cycles_node_socket_float_value(lacunarity_socket);
*roughness = std::fmaxf(*roughness, 1e-5f);
@ -1173,7 +1173,7 @@ static void versioning_replace_musgrave_texture_node(bNodeTree *ntree)
/* Add Maximum Math node after output of roughness_from_node. Add Multiply Math node and
* Power Math node before Roughness input. */
bNode *max1_node = nodeAddStaticNode(nullptr, ntree, SH_NODE_MATH);
bNode *max1_node = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_MATH);
max1_node->parent = node->parent;
max1_node->custom1 = NODE_MATH_MAXIMUM;
max1_node->locx = node->locx;
@ -1181,9 +1181,9 @@ static void versioning_replace_musgrave_texture_node(bNodeTree *ntree)
max1_node->flag |= NODE_HIDDEN;
bNodeSocket *max1_socket_A = static_cast<bNodeSocket *>(BLI_findlink(&max1_node->inputs, 0));
bNodeSocket *max1_socket_B = static_cast<bNodeSocket *>(BLI_findlink(&max1_node->inputs, 1));
bNodeSocket *max1_socket_out = nodeFindSocket(max1_node, SOCK_OUT, "Value");
bNodeSocket *max1_socket_out = blender::bke::nodeFindSocket(max1_node, SOCK_OUT, "Value");
bNode *mul_node = nodeAddStaticNode(nullptr, ntree, SH_NODE_MATH);
bNode *mul_node = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_MATH);
mul_node->parent = node->parent;
mul_node->custom1 = NODE_MATH_MULTIPLY;
mul_node->locx = node->locx;
@ -1191,9 +1191,9 @@ static void versioning_replace_musgrave_texture_node(bNodeTree *ntree)
mul_node->flag |= NODE_HIDDEN;
bNodeSocket *mul_socket_A = static_cast<bNodeSocket *>(BLI_findlink(&mul_node->inputs, 0));
bNodeSocket *mul_socket_B = static_cast<bNodeSocket *>(BLI_findlink(&mul_node->inputs, 1));
bNodeSocket *mul_socket_out = nodeFindSocket(mul_node, SOCK_OUT, "Value");
bNodeSocket *mul_socket_out = blender::bke::nodeFindSocket(mul_node, SOCK_OUT, "Value");
bNode *pow_node = nodeAddStaticNode(nullptr, ntree, SH_NODE_MATH);
bNode *pow_node = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_MATH);
pow_node->parent = node->parent;
pow_node->custom1 = NODE_MATH_POWER;
pow_node->locx = node->locx;
@ -1201,22 +1201,22 @@ static void versioning_replace_musgrave_texture_node(bNodeTree *ntree)
pow_node->flag |= NODE_HIDDEN;
bNodeSocket *pow_socket_A = static_cast<bNodeSocket *>(BLI_findlink(&pow_node->inputs, 0));
bNodeSocket *pow_socket_B = static_cast<bNodeSocket *>(BLI_findlink(&pow_node->inputs, 1));
bNodeSocket *pow_socket_out = nodeFindSocket(pow_node, SOCK_OUT, "Value");
bNodeSocket *pow_socket_out = blender::bke::nodeFindSocket(pow_node, SOCK_OUT, "Value");
*version_cycles_node_socket_float_value(max1_socket_B) = -1e-5f;
*version_cycles_node_socket_float_value(mul_socket_B) = -1.0f;
*version_cycles_node_socket_float_value(pow_socket_A) = *lacunarity;
nodeRemLink(ntree, roughness_link);
nodeAddLink(ntree, roughness_from_node, roughness_from_socket, max1_node, max1_socket_A);
nodeAddLink(ntree, max1_node, max1_socket_out, mul_node, mul_socket_A);
nodeAddLink(ntree, mul_node, mul_socket_out, pow_node, pow_socket_B);
nodeAddLink(ntree, pow_node, pow_socket_out, node, roughness_socket);
blender::bke::nodeRemLink(ntree, roughness_link);
blender::bke::nodeAddLink(ntree, roughness_from_node, roughness_from_socket, max1_node, max1_socket_A);
blender::bke::nodeAddLink(ntree, max1_node, max1_socket_out, mul_node, mul_socket_A);
blender::bke::nodeAddLink(ntree, mul_node, mul_socket_out, pow_node, pow_socket_B);
blender::bke::nodeAddLink(ntree, pow_node, pow_socket_out, node, roughness_socket);
if (lacunarity_link != nullptr) {
/* Add Maximum Math node after output of lacunarity_from_node. */
bNode *max2_node = nodeAddStaticNode(nullptr, ntree, SH_NODE_MATH);
bNode *max2_node = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_MATH);
max2_node->parent = node->parent;
max2_node->custom1 = NODE_MATH_MAXIMUM;
max2_node->locx = node->locx;
@ -1226,21 +1226,21 @@ static void versioning_replace_musgrave_texture_node(bNodeTree *ntree)
BLI_findlink(&max2_node->inputs, 0));
bNodeSocket *max2_socket_B = static_cast<bNodeSocket *>(
BLI_findlink(&max2_node->inputs, 1));
bNodeSocket *max2_socket_out = nodeFindSocket(max2_node, SOCK_OUT, "Value");
bNodeSocket *max2_socket_out = blender::bke::nodeFindSocket(max2_node, SOCK_OUT, "Value");
*version_cycles_node_socket_float_value(max2_socket_B) = -1e-5f;
nodeRemLink(ntree, lacunarity_link);
nodeAddLink(ntree, lacunarity_from_node, lacunarity_from_socket, max2_node, max2_socket_A);
nodeAddLink(ntree, max2_node, max2_socket_out, pow_node, pow_socket_A);
nodeAddLink(ntree, max2_node, max2_socket_out, node, lacunarity_socket);
blender::bke::nodeRemLink(ntree, lacunarity_link);
blender::bke::nodeAddLink(ntree, lacunarity_from_node, lacunarity_from_socket, max2_node, max2_socket_A);
blender::bke::nodeAddLink(ntree, max2_node, max2_socket_out, pow_node, pow_socket_A);
blender::bke::nodeAddLink(ntree, max2_node, max2_socket_out, node, lacunarity_socket);
}
}
else if ((lacunarity_link != nullptr) && (roughness_link == nullptr)) {
/* Add Maximum Math node after output of lacunarity_from_node. Add Power Math node before
* Roughness input. */
bNode *max2_node = nodeAddStaticNode(nullptr, ntree, SH_NODE_MATH);
bNode *max2_node = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_MATH);
max2_node->parent = node->parent;
max2_node->custom1 = NODE_MATH_MAXIMUM;
max2_node->locx = node->locx;
@ -1248,9 +1248,9 @@ static void versioning_replace_musgrave_texture_node(bNodeTree *ntree)
max2_node->flag |= NODE_HIDDEN;
bNodeSocket *max2_socket_A = static_cast<bNodeSocket *>(BLI_findlink(&max2_node->inputs, 0));
bNodeSocket *max2_socket_B = static_cast<bNodeSocket *>(BLI_findlink(&max2_node->inputs, 1));
bNodeSocket *max2_socket_out = nodeFindSocket(max2_node, SOCK_OUT, "Value");
bNodeSocket *max2_socket_out = blender::bke::nodeFindSocket(max2_node, SOCK_OUT, "Value");
bNode *pow_node = nodeAddStaticNode(nullptr, ntree, SH_NODE_MATH);
bNode *pow_node = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_MATH);
pow_node->parent = node->parent;
pow_node->custom1 = NODE_MATH_POWER;
pow_node->locx = node->locx;
@ -1258,17 +1258,17 @@ static void versioning_replace_musgrave_texture_node(bNodeTree *ntree)
pow_node->flag |= NODE_HIDDEN;
bNodeSocket *pow_socket_A = static_cast<bNodeSocket *>(BLI_findlink(&pow_node->inputs, 0));
bNodeSocket *pow_socket_B = static_cast<bNodeSocket *>(BLI_findlink(&pow_node->inputs, 1));
bNodeSocket *pow_socket_out = nodeFindSocket(pow_node, SOCK_OUT, "Value");
bNodeSocket *pow_socket_out = blender::bke::nodeFindSocket(pow_node, SOCK_OUT, "Value");
*version_cycles_node_socket_float_value(max2_socket_B) = -1e-5f;
*version_cycles_node_socket_float_value(pow_socket_A) = *lacunarity;
*version_cycles_node_socket_float_value(pow_socket_B) = -(*roughness);
nodeRemLink(ntree, lacunarity_link);
nodeAddLink(ntree, lacunarity_from_node, lacunarity_from_socket, max2_node, max2_socket_A);
nodeAddLink(ntree, max2_node, max2_socket_out, pow_node, pow_socket_A);
nodeAddLink(ntree, max2_node, max2_socket_out, node, lacunarity_socket);
nodeAddLink(ntree, pow_node, pow_socket_out, node, roughness_socket);
blender::bke::nodeRemLink(ntree, lacunarity_link);
blender::bke::nodeAddLink(ntree, lacunarity_from_node, lacunarity_from_socket, max2_node, max2_socket_A);
blender::bke::nodeAddLink(ntree, max2_node, max2_socket_out, pow_node, pow_socket_A);
blender::bke::nodeAddLink(ntree, max2_node, max2_socket_out, node, lacunarity_socket);
blender::bke::nodeAddLink(ntree, pow_node, pow_socket_out, node, roughness_socket);
}
else {
*roughness = std::pow(*lacunarity, -(*roughness));
@ -1293,16 +1293,16 @@ static void version_principled_bsdf_subsurface(bNodeTree *ntree)
if (node->type != SH_NODE_BSDF_PRINCIPLED) {
continue;
}
if (nodeFindSocket(node, SOCK_IN, "Subsurface Scale")) {
if (blender::bke::nodeFindSocket(node, SOCK_IN, "Subsurface Scale")) {
/* Node is already updated. */
continue;
}
/* Add Scale input */
bNodeSocket *scale_in = nodeAddStaticSocket(
bNodeSocket *scale_in = blender::bke::nodeAddStaticSocket(
ntree, node, SOCK_IN, SOCK_FLOAT, PROP_DISTANCE, "Subsurface Scale", "Subsurface Scale");
bNodeSocket *subsurf = nodeFindSocket(node, SOCK_IN, "Subsurface");
bNodeSocket *subsurf = blender::bke::nodeFindSocket(node, SOCK_IN, "Subsurface");
float *subsurf_val = version_cycles_node_socket_float_value(subsurf);
if (!subsurf->link && *subsurf_val == 0.0f) {
@ -1318,40 +1318,40 @@ static void version_principled_bsdf_subsurface(bNodeTree *ntree)
}
/* Fix up Subsurface Color input */
bNodeSocket *base_col = nodeFindSocket(node, SOCK_IN, "Base Color");
bNodeSocket *subsurf_col = nodeFindSocket(node, SOCK_IN, "Subsurface Color");
bNodeSocket *base_col = blender::bke::nodeFindSocket(node, SOCK_IN, "Base Color");
bNodeSocket *subsurf_col = blender::bke::nodeFindSocket(node, SOCK_IN, "Subsurface Color");
float *base_col_val = version_cycles_node_socket_rgba_value(base_col);
float *subsurf_col_val = version_cycles_node_socket_rgba_value(subsurf_col);
/* If any of the three inputs is dynamic, we need a Mix node. */
if (subsurf->link || subsurf_col->link || base_col->link) {
bNode *mix = nodeAddStaticNode(nullptr, ntree, SH_NODE_MIX);
bNode *mix = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_MIX);
static_cast<NodeShaderMix *>(mix->storage)->data_type = SOCK_RGBA;
mix->locx = node->locx - 170;
mix->locy = node->locy - 120;
bNodeSocket *a_in = nodeFindSocket(mix, SOCK_IN, "A_Color");
bNodeSocket *b_in = nodeFindSocket(mix, SOCK_IN, "B_Color");
bNodeSocket *fac_in = nodeFindSocket(mix, SOCK_IN, "Factor_Float");
bNodeSocket *result_out = nodeFindSocket(mix, SOCK_OUT, "Result_Color");
bNodeSocket *a_in = blender::bke::nodeFindSocket(mix, SOCK_IN, "A_Color");
bNodeSocket *b_in = blender::bke::nodeFindSocket(mix, SOCK_IN, "B_Color");
bNodeSocket *fac_in = blender::bke::nodeFindSocket(mix, SOCK_IN, "Factor_Float");
bNodeSocket *result_out = blender::bke::nodeFindSocket(mix, SOCK_OUT, "Result_Color");
copy_v4_v4(version_cycles_node_socket_rgba_value(a_in), base_col_val);
copy_v4_v4(version_cycles_node_socket_rgba_value(b_in), subsurf_col_val);
*version_cycles_node_socket_float_value(fac_in) = *subsurf_val;
if (base_col->link) {
nodeAddLink(ntree, base_col->link->fromnode, base_col->link->fromsock, mix, a_in);
nodeRemLink(ntree, base_col->link);
blender::bke::nodeAddLink(ntree, base_col->link->fromnode, base_col->link->fromsock, mix, a_in);
blender::bke::nodeRemLink(ntree, base_col->link);
}
if (subsurf_col->link) {
nodeAddLink(ntree, subsurf_col->link->fromnode, subsurf_col->link->fromsock, mix, b_in);
nodeRemLink(ntree, subsurf_col->link);
blender::bke::nodeAddLink(ntree, subsurf_col->link->fromnode, subsurf_col->link->fromsock, mix, b_in);
blender::bke::nodeRemLink(ntree, subsurf_col->link);
}
if (subsurf->link) {
nodeAddLink(ntree, subsurf->link->fromnode, subsurf->link->fromsock, mix, fac_in);
nodeAddLink(ntree, subsurf->link->fromnode, subsurf->link->fromsock, node, scale_in);
nodeRemLink(ntree, subsurf->link);
blender::bke::nodeAddLink(ntree, subsurf->link->fromnode, subsurf->link->fromsock, mix, fac_in);
blender::bke::nodeAddLink(ntree, subsurf->link->fromnode, subsurf->link->fromsock, node, scale_in);
blender::bke::nodeRemLink(ntree, subsurf->link);
}
nodeAddLink(ntree, mix, result_out, node, base_col);
blender::bke::nodeAddLink(ntree, mix, result_out, node, base_col);
}
/* Mix the fixed values. */
interp_v4_v4v4(base_col_val, base_col_val, subsurf_col_val, *subsurf_val);
@ -1360,7 +1360,7 @@ static void version_principled_bsdf_subsurface(bNodeTree *ntree)
*subsurf_val = 1.0f;
/* Delete Subsurface Color input */
nodeRemoveSocket(ntree, node, subsurf_col);
blender::bke::nodeRemoveSocket(ntree, node, subsurf_col);
}
}
@ -1377,15 +1377,15 @@ static void version_principled_bsdf_emission(bNodeTree *ntree)
if (node->type != SH_NODE_BSDF_PRINCIPLED) {
continue;
}
if (!nodeFindSocket(node, SOCK_IN, "Emission")) {
if (!blender::bke::nodeFindSocket(node, SOCK_IN, "Emission")) {
/* Old enough to have neither, new defaults are fine. */
continue;
}
if (nodeFindSocket(node, SOCK_IN, "Emission Strength")) {
if (blender::bke::nodeFindSocket(node, SOCK_IN, "Emission Strength")) {
/* New enough to have both, no need to do anything. */
continue;
}
bNodeSocket *sock = nodeAddStaticSocket(
bNodeSocket *sock = blender::bke::nodeAddStaticSocket(
ntree, node, SOCK_IN, SOCK_FLOAT, PROP_NONE, "Emission Strength", "Emission Strength");
*version_cycles_node_socket_float_value(sock) = 1.0f;
}
@ -1447,14 +1447,14 @@ static void change_input_socket_to_rotation_type(bNodeTree &ntree,
/* Make versioning idempotent. */
continue;
}
bNode *convert = nodeAddNode(nullptr, &ntree, "FunctionNodeEulerToRotation");
bNode *convert = blender::bke::nodeAddNode(nullptr, &ntree, "FunctionNodeEulerToRotation");
convert->parent = node.parent;
convert->locx = node.locx - 40;
convert->locy = node.locy;
link->tonode = convert;
link->tosock = nodeFindSocket(convert, SOCK_IN, "Euler");
link->tosock = blender::bke::nodeFindSocket(convert, SOCK_IN, "Euler");
nodeAddLink(&ntree, convert, nodeFindSocket(convert, SOCK_OUT, "Rotation"), &node, &socket);
blender::bke::nodeAddLink(&ntree, convert, blender::bke::nodeFindSocket(convert, SOCK_OUT, "Rotation"), &node, &socket);
}
}
@ -1476,14 +1476,14 @@ static void change_output_socket_to_rotation_type(bNodeTree &ntree,
{ /* Make versioning idempotent. */
continue;
}
bNode *convert = nodeAddNode(nullptr, &ntree, "FunctionNodeRotationToEuler");
bNode *convert = blender::bke::nodeAddNode(nullptr, &ntree, "FunctionNodeRotationToEuler");
convert->parent = node.parent;
convert->locx = node.locx + 40;
convert->locy = node.locy;
link->fromnode = convert;
link->fromsock = nodeFindSocket(convert, SOCK_OUT, "Euler");
link->fromsock = blender::bke::nodeFindSocket(convert, SOCK_OUT, "Euler");
nodeAddLink(&ntree, &node, &socket, convert, nodeFindSocket(convert, SOCK_IN, "Rotation"));
blender::bke::nodeAddLink(&ntree, &node, &socket, convert, blender::bke::nodeFindSocket(convert, SOCK_IN, "Rotation"));
}
}
@ -1495,7 +1495,7 @@ static void version_geometry_nodes_use_rotation_socket(bNodeTree &ntree)
"GeometryNodeRotateInstances",
"GeometryNodeTransform"))
{
bNodeSocket *socket = nodeFindSocket(node, SOCK_IN, "Rotation");
bNodeSocket *socket = blender::bke::nodeFindSocket(node, SOCK_IN, "Rotation");
change_input_socket_to_rotation_type(ntree, *node, *socket);
}
if (STR_ELEM(node->idname,
@ -1503,7 +1503,7 @@ static void version_geometry_nodes_use_rotation_socket(bNodeTree &ntree)
"GeometryNodeObjectInfo",
"GeometryNodeInputInstanceRotation"))
{
bNodeSocket *socket = nodeFindSocket(node, SOCK_OUT, "Rotation");
bNodeSocket *socket = blender::bke::nodeFindSocket(node, SOCK_OUT, "Rotation");
change_output_socket_to_rotation_type(ntree, *node, *socket);
}
}
@ -1628,14 +1628,14 @@ static void version_principled_bsdf_coat(bNodeTree *ntree)
if (node->type != SH_NODE_BSDF_PRINCIPLED) {
continue;
}
if (nodeFindSocket(node, SOCK_IN, "Coat IOR") != nullptr) {
if (blender::bke::nodeFindSocket(node, SOCK_IN, "Coat IOR") != nullptr) {
continue;
}
bNodeSocket *coat_ior_input = nodeAddStaticSocket(
bNodeSocket *coat_ior_input = blender::bke::nodeAddStaticSocket(
ntree, node, SOCK_IN, SOCK_FLOAT, PROP_NONE, "Coat IOR", "Coat IOR");
/* Adjust for 4x change in intensity. */
bNodeSocket *coat_input = nodeFindSocket(node, SOCK_IN, "Clearcoat");
bNodeSocket *coat_input = blender::bke::nodeFindSocket(node, SOCK_IN, "Clearcoat");
*version_cycles_node_socket_float_value(coat_input) *= 0.25f;
/* When the coat input is dynamic, instead of inserting a *0.25 math node, set the Coat IOR
* to 1.2 instead - this also roughly quarters reflectivity compared to the 1.5 default. */
@ -1657,20 +1657,20 @@ static void version_principled_bsdf_specular_tint(bNodeTree *ntree)
if (node->type != SH_NODE_BSDF_PRINCIPLED) {
continue;
}
bNodeSocket *specular_tint_sock = nodeFindSocket(node, SOCK_IN, "Specular Tint");
bNodeSocket *specular_tint_sock = blender::bke::nodeFindSocket(node, SOCK_IN, "Specular Tint");
if (specular_tint_sock->type == SOCK_RGBA) {
/* Node is already updated. */
continue;
}
bNodeSocket *base_color_sock = nodeFindSocket(node, SOCK_IN, "Base Color");
bNodeSocket *metallic_sock = nodeFindSocket(node, SOCK_IN, "Metallic");
bNodeSocket *base_color_sock = blender::bke::nodeFindSocket(node, SOCK_IN, "Base Color");
bNodeSocket *metallic_sock = blender::bke::nodeFindSocket(node, SOCK_IN, "Metallic");
float specular_tint_old = *version_cycles_node_socket_float_value(specular_tint_sock);
float *base_color = version_cycles_node_socket_rgba_value(base_color_sock);
float metallic = *version_cycles_node_socket_float_value(metallic_sock);
/* Change socket type to Color. */
nodeModifySocketTypeStatic(ntree, node, specular_tint_sock, SOCK_RGBA, 0);
blender::bke::nodeModifySocketTypeStatic(ntree, node, specular_tint_sock, SOCK_RGBA, 0);
float *specular_tint = version_cycles_node_socket_rgba_value(specular_tint_sock);
/* The conversion logic here is that the new Specular Tint should be
@ -1698,26 +1698,26 @@ static void version_principled_bsdf_specular_tint(bNodeTree *ntree)
bNode *metallic_mix_node = nullptr;
if (metallic_sock->link || (base_color_sock->link && metallic > 0.0f)) {
/* Metallic Mix needs to be dynamically mixed. */
bNode *mix = nodeAddStaticNode(nullptr, ntree, SH_NODE_MIX);
bNode *mix = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_MIX);
static_cast<NodeShaderMix *>(mix->storage)->data_type = SOCK_RGBA;
mix->locx = node->locx - 270;
mix->locy = node->locy - 120;
bNodeSocket *a_in = nodeFindSocket(mix, SOCK_IN, "A_Color");
bNodeSocket *b_in = nodeFindSocket(mix, SOCK_IN, "B_Color");
bNodeSocket *fac_in = nodeFindSocket(mix, SOCK_IN, "Factor_Float");
metallic_mix_out = nodeFindSocket(mix, SOCK_OUT, "Result_Color");
bNodeSocket *a_in = blender::bke::nodeFindSocket(mix, SOCK_IN, "A_Color");
bNodeSocket *b_in = blender::bke::nodeFindSocket(mix, SOCK_IN, "B_Color");
bNodeSocket *fac_in = blender::bke::nodeFindSocket(mix, SOCK_IN, "Factor_Float");
metallic_mix_out = blender::bke::nodeFindSocket(mix, SOCK_OUT, "Result_Color");
metallic_mix_node = mix;
copy_v4_v4(version_cycles_node_socket_rgba_value(a_in), base_color);
if (base_color_sock->link) {
nodeAddLink(
blender::bke::nodeAddLink(
ntree, base_color_sock->link->fromnode, base_color_sock->link->fromsock, mix, a_in);
}
copy_v4_v4(version_cycles_node_socket_rgba_value(b_in), one);
*version_cycles_node_socket_float_value(fac_in) = metallic;
if (metallic_sock->link) {
nodeAddLink(
blender::bke::nodeAddLink(
ntree, metallic_sock->link->fromnode, metallic_sock->link->fromsock, mix, fac_in);
}
}
@ -1730,31 +1730,31 @@ static void version_principled_bsdf_specular_tint(bNodeTree *ntree)
/* Similar to above, if the Specular Tint input is dynamic, or fixed > 0 and metallic mix
* is dynamic, we need to insert a node to compute the new specular tint. */
if (specular_tint_sock->link || (metallic_mix_out && specular_tint_old > 0.0f)) {
bNode *mix = nodeAddStaticNode(nullptr, ntree, SH_NODE_MIX);
bNode *mix = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_MIX);
static_cast<NodeShaderMix *>(mix->storage)->data_type = SOCK_RGBA;
mix->locx = node->locx - 170;
mix->locy = node->locy - 120;
bNodeSocket *a_in = nodeFindSocket(mix, SOCK_IN, "A_Color");
bNodeSocket *b_in = nodeFindSocket(mix, SOCK_IN, "B_Color");
bNodeSocket *fac_in = nodeFindSocket(mix, SOCK_IN, "Factor_Float");
bNodeSocket *result_out = nodeFindSocket(mix, SOCK_OUT, "Result_Color");
bNodeSocket *a_in = blender::bke::nodeFindSocket(mix, SOCK_IN, "A_Color");
bNodeSocket *b_in = blender::bke::nodeFindSocket(mix, SOCK_IN, "B_Color");
bNodeSocket *fac_in = blender::bke::nodeFindSocket(mix, SOCK_IN, "Factor_Float");
bNodeSocket *result_out = blender::bke::nodeFindSocket(mix, SOCK_OUT, "Result_Color");
copy_v4_v4(version_cycles_node_socket_rgba_value(a_in), one);
copy_v4_v4(version_cycles_node_socket_rgba_value(b_in), metallic_mix);
if (metallic_mix_out) {
nodeAddLink(ntree, metallic_mix_node, metallic_mix_out, mix, b_in);
blender::bke::nodeAddLink(ntree, metallic_mix_node, metallic_mix_out, mix, b_in);
}
*version_cycles_node_socket_float_value(fac_in) = specular_tint_old;
if (specular_tint_sock->link) {
nodeAddLink(ntree,
blender::bke::nodeAddLink(ntree,
specular_tint_sock->link->fromnode,
specular_tint_sock->link->fromsock,
mix,
fac_in);
nodeRemLink(ntree, specular_tint_sock->link);
blender::bke::nodeRemLink(ntree, specular_tint_sock->link);
}
nodeAddLink(ntree, mix, result_out, node, specular_tint_sock);
blender::bke::nodeAddLink(ntree, mix, result_out, node, specular_tint_sock);
}
}
}
@ -2029,17 +2029,17 @@ static void fix_geometry_nodes_object_info_scale(bNodeTree &ntree)
if (node->type != GEO_NODE_OBJECT_INFO) {
continue;
}
bNodeSocket *scale = nodeFindSocket(node, SOCK_OUT, "Scale");
bNodeSocket *scale = blender::bke::nodeFindSocket(node, SOCK_OUT, "Scale");
const Span<bNodeLink *> links = out_links_per_socket.lookup(scale);
if (links.is_empty()) {
continue;
}
bNode *absolute_value = nodeAddNode(nullptr, &ntree, "ShaderNodeVectorMath");
bNode *absolute_value = blender::bke::nodeAddNode(nullptr, &ntree, "ShaderNodeVectorMath");
absolute_value->custom1 = NODE_VECTOR_MATH_ABSOLUTE;
absolute_value->parent = node->parent;
absolute_value->locx = node->locx + 100;
absolute_value->locy = node->locy - 50;
nodeAddLink(&ntree,
blender::bke::nodeAddLink(&ntree,
node,
scale,
absolute_value,

16
source/blender/blenloader/intern/versioning_common.cc
View file

@ -189,11 +189,11 @@ bNodeSocket *version_node_add_socket_if_not_exist(bNodeTree *ntree,
const char *identifier,
const char *name)
{
bNodeSocket *sock = nodeFindSocket(node, eNodeSocketInOut(in_out), identifier);
bNodeSocket *sock = blender::bke::nodeFindSocket(node, eNodeSocketInOut(in_out), identifier);
if (sock != nullptr) {
return sock;
}
return nodeAddStaticSocket(
return blender::bke::nodeAddStaticSocket(
ntree, node, eNodeSocketInOut(in_out), type, subtype, identifier, name);
}
@ -283,7 +283,7 @@ void node_tree_relink_with_socket_id_map(bNodeTree &ntree,
bNodeSocket *old_socket = link->tosock;
if (old_socket->is_available()) {
if (const std::string *new_identifier = map.lookup_ptr_as(old_socket->identifier)) {
bNodeSocket *new_socket = nodeFindSocket(&new_node, SOCK_IN, new_identifier->c_str());
bNodeSocket *new_socket = blender::bke::nodeFindSocket(&new_node, SOCK_IN, new_identifier->c_str());
link->tonode = &new_node;
link->tosock = new_socket;
old_socket->link = nullptr;
@ -294,7 +294,7 @@ void node_tree_relink_with_socket_id_map(bNodeTree &ntree,
bNodeSocket *old_socket = link->fromsock;
if (old_socket->is_available()) {
if (const std::string *new_identifier = map.lookup_ptr_as(old_socket->identifier)) {
bNodeSocket *new_socket = nodeFindSocket(&new_node, SOCK_OUT, new_identifier->c_str());
bNodeSocket *new_socket = blender::bke::nodeFindSocket(&new_node, SOCK_OUT, new_identifier->c_str());
link->fromnode = &new_node;
link->fromsock = new_socket;
old_socket->link = nullptr;
@ -327,11 +327,11 @@ void add_realize_instances_before_socket(bNodeTree *ntree,
return;
}
bNode *realize_node = nodeAddStaticNode(nullptr, ntree, GEO_NODE_REALIZE_INSTANCES);
bNode *realize_node = blender::bke::nodeAddStaticNode(nullptr, ntree, GEO_NODE_REALIZE_INSTANCES);
realize_node->parent = node->parent;
realize_node->locx = node->locx - 100;
realize_node->locy = node->locy;
nodeAddLink(ntree,
blender::bke::nodeAddLink(ntree,
link->fromnode,
link->fromsock,
realize_node,
@ -439,7 +439,7 @@ void version_update_node_input(
}
/* Replace links with updated equivalent */
nodeRemLink(ntree, link);
blender::bke::nodeRemLink(ntree, link);
update_input_link(fromnode, fromsock, tonode, tosock);
need_update = true;
@ -449,7 +449,7 @@ void version_update_node_input(
* Do this after the link update in case it changes the identifier. */
LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
if (check_node(node)) {
bNodeSocket *input = nodeFindSocket(node, SOCK_IN, socket_identifier);
bNodeSocket *input = blender::bke::nodeFindSocket(node, SOCK_IN, socket_identifier);
if (input != nullptr) {
update_input(node, input);
}

8
source/blender/blenloader/intern/versioning_defaults.cc
View file

@ -339,7 +339,7 @@ static void blo_update_defaults_scene(Main *bmain, Scene *scene)
/* Don't enable compositing nodes. */
if (scene->nodetree) {
ntreeFreeEmbeddedTree(scene->nodetree);
blender::bke::ntreeFreeEmbeddedTree(scene->nodetree);
MEM_freeN(scene->nodetree);
scene->nodetree = nullptr;
scene->use_nodes = false;
@ -689,11 +689,11 @@ void BLO_update_defaults_startup_blend(Main *bmain, const char *app_template)
if (ma->nodetree) {
for (bNode *node : ma->nodetree->all_nodes()) {
if (node->type == SH_NODE_BSDF_PRINCIPLED) {
bNodeSocket *roughness_socket = nodeFindSocket(node, SOCK_IN, "Roughness");
bNodeSocket *roughness_socket = blender::bke::nodeFindSocket(node, SOCK_IN, "Roughness");
*version_cycles_node_socket_float_value(roughness_socket) = 0.5f;
bNodeSocket *emission = nodeFindSocket(node, SOCK_IN, "Emission Color");
bNodeSocket *emission = blender::bke::nodeFindSocket(node, SOCK_IN, "Emission Color");
copy_v4_fl(version_cycles_node_socket_rgba_value(emission), 1.0f);
bNodeSocket *emission_strength = nodeFindSocket(node, SOCK_IN, "Emission Strength");
bNodeSocket *emission_strength = blender::bke::nodeFindSocket(node, SOCK_IN, "Emission Strength");
*version_cycles_node_socket_float_value(emission_strength) = 0.0f;
node->custom1 = SHD_GLOSSY_MULTI_GGX;

2
source/blender/blenloader/tests/blendfile_loading_base_test.cc
View file

@ -64,7 +64,7 @@ void BlendfileLoadingBaseTest::SetUpTestCase()
BKE_modifier_init();
DEG_register_node_types();
RNA_init();
BKE_node_system_init();
blender::bke::BKE_node_system_init();
BKE_callback_global_init();
BKE_vfont_builtin_register(datatoc_bfont_pfb, datatoc_bfont_pfb_size);
BLF_init();

2
source/blender/compositor/COM_profile.hh
View file

@ -52,7 +52,7 @@ class Profiler {
* per_node_execution_time_.
* Returns total execution time of the given node tree. */
timeit::Nanoseconds accumulate_node_group_times(
const bNodeTree &node_tree, const bNodeInstanceKey parent_key = NODE_INSTANCE_KEY_BASE);
const bNodeTree &node_tree, const bNodeInstanceKey parent_key = bke::NODE_INSTANCE_KEY_BASE);
};
} // namespace blender::compositor

8
source/blender/compositor/intern/COM_CompositorContext.h
View file

@ -10,7 +10,9 @@
#include "DNA_node_types.h"
#include "DNA_scene_types.h"
namespace blender::bke {
struct bNodeInstanceHash;
}
namespace blender::realtime_compositor {
class RenderContext;
@ -50,7 +52,7 @@ class CompositorContext {
* \brief Preview image hash table
* This field is initialized in ExecutionSystem and must only be read from that point on.
*/
bNodeInstanceHash *previews_;
bke::bNodeInstanceHash *previews_;
/**
* \brief active rendering view name
@ -129,7 +131,7 @@ class CompositorContext {
/**
* \brief set the preview image hash table
*/
void set_preview_hash(bNodeInstanceHash *previews)
void set_preview_hash(bke::bNodeInstanceHash *previews)
{
previews_ = previews;
}
@ -137,7 +139,7 @@ class CompositorContext {
/**
* \brief get the preview image hash table
*/
bNodeInstanceHash *get_preview_hash() const
bke::bNodeInstanceHash *get_preview_hash() const
{
return previews_;
}

2
source/blender/compositor/intern/COM_Node.cc
View file

@ -19,7 +19,7 @@ Node::Node(bNode *editor_node, bool create_sockets)
: editor_node_tree_(nullptr),
editor_node_(editor_node),
in_active_group_(false),
instance_key_(NODE_INSTANCE_KEY_NONE)
instance_key_(bke::NODE_INSTANCE_KEY_NONE)
{
if (create_sockets) {
bNodeSocket *input = (bNodeSocket *)editor_node->inputs.first;

8
source/blender/compositor/intern/COM_NodeGraph.cc
View file

@ -30,7 +30,7 @@ NodeGraph::~NodeGraph()
void NodeGraph::from_bNodeTree(const CompositorContext &context, bNodeTree *tree)
{
add_bNodeTree(context, 0, tree, NODE_INSTANCE_KEY_BASE);
add_bNodeTree(context, 0, tree, bke::NODE_INSTANCE_KEY_BASE);
}
bNodeSocket *NodeGraph::find_b_node_input(bNode *b_node, const char *identifier)
@ -87,7 +87,7 @@ void NodeGraph::add_bNodeTree(const CompositorContext &context,
/* add all nodes of the tree to the node list */
for (bNode *node = (bNode *)tree->nodes.first; node; node = node->next) {
bNodeInstanceKey key = BKE_node_instance_key(parent_key, tree, node);
bNodeInstanceKey key = bke::BKE_node_instance_key(parent_key, tree, node);
add_bNode(context, tree, node, key, is_active_group);
}
@ -211,7 +211,7 @@ void NodeGraph::add_proxies_group_inputs(bNode *b_node, bNode *b_node_io)
BLI_assert(b_group_tree); /* should have been checked in advance */
/* not important for proxies */
bNodeInstanceKey key = NODE_INSTANCE_KEY_BASE;
bNodeInstanceKey key = bke::NODE_INSTANCE_KEY_BASE;
bool is_active_group = false;
for (bNodeSocket *b_sock_io = (bNodeSocket *)b_node_io->outputs.first; b_sock_io;
@ -233,7 +233,7 @@ void NodeGraph::add_proxies_group_outputs(const CompositorContext & /*context*/,
BLI_assert(b_group_tree); /* should have been checked in advance */
/* not important for proxies */
bNodeInstanceKey key = NODE_INSTANCE_KEY_BASE;
bNodeInstanceKey key = bke::NODE_INSTANCE_KEY_BASE;
bool is_active_group = false;
for (bNodeSocket *b_sock_io = (bNodeSocket *)b_node_io->inputs.first; b_sock_io;

2
source/blender/compositor/intern/COM_NodeOperation.h
View file

@ -266,7 +266,7 @@ class NodeOperation {
private:
int id_;
std::string name_;
bNodeInstanceKey node_instance_key_{NODE_INSTANCE_KEY_NONE};
bNodeInstanceKey node_instance_key_{bke::NODE_INSTANCE_KEY_NONE};
Vector<NodeOperationInput> inputs_;
Vector<NodeOperationOutput> outputs_;

2
source/blender/compositor/intern/COM_NodeOperationBuilder.cc
View file

@ -207,7 +207,7 @@ PreviewOperation *NodeOperationBuilder::make_preview_operation() const
return nullptr;
}
bNodeInstanceHash *previews = context_->get_preview_hash();
bke::bNodeInstanceHash *previews = context_->get_preview_hash();
if (previews) {
Scene *scene = context_->get_scene();
PreviewOperation *operation = new PreviewOperation(

4
source/blender/compositor/intern/COM_profile.cc
View file

@ -19,7 +19,7 @@ void Profiler::add_operation_execution_time(const NodeOperation &operation,
const timeit::Nanoseconds execution_time = end - start;
const bNodeInstanceKey key = operation.get_node_instance_key();
if (key.value == NODE_INSTANCE_KEY_NONE.value) {
if (key.value == bke::NODE_INSTANCE_KEY_NONE.value) {
/* The operation does not come from any node. It was, for example, added to convert data type.
* Do not accumulate time from its execution. */
return;
@ -45,7 +45,7 @@ timeit::Nanoseconds Profiler::accumulate_node_group_times(const bNodeTree &node_
timeit::Nanoseconds tree_execution_time(0);
for (const bNode *node : node_tree.all_nodes()) {
const bNodeInstanceKey key = BKE_node_instance_key(parent_key, &node_tree, node);
const bNodeInstanceKey key = bke::BKE_node_instance_key(parent_key, &node_tree, node);
if (node->type != NODE_GROUP) {
/* Non-group node, no need to recurse into. Simply accumulate the node's execution time to

2
source/blender/compositor/operations/COM_PreviewOperation.cc
View file

@ -28,7 +28,7 @@ PreviewOperation::PreviewOperation(const ColorManagedViewSettings *view_settings
flags_.is_preview_operation = true;
}
void PreviewOperation::verify_preview(bNodeInstanceHash *previews, bNodeInstanceKey key)
void PreviewOperation::verify_preview(bke::bNodeInstanceHash *previews, bNodeInstanceKey key)
{
/* Size (0, 0) ensures the preview rect is not allocated in advance,
* this is set later in init_execution once the resolution is determined.

2
source/blender/compositor/operations/COM_PreviewOperation.h
View file

@ -32,7 +32,7 @@ class PreviewOperation : public MultiThreadedOperation {
const ColorManagedDisplaySettings *display_settings,
unsigned int default_width,
unsigned int default_height);
void verify_preview(bNodeInstanceHash *previews, bNodeInstanceKey key);
void verify_preview(bke::bNodeInstanceHash *previews, bNodeInstanceKey key);
bool is_output_operation(bool /*rendering*/) const override
{

2
source/blender/compositor/realtime_compositor/intern/utilities.cc
View file

@ -198,7 +198,7 @@ void compute_preview_from_result(Context &context, const DNode &node, Result &in
bNodeTree *root_tree = const_cast<bNodeTree *>(
&node.context()->derived_tree().root_context().btree());
if (!root_tree->previews) {
root_tree->previews = BKE_node_instance_hash_new("node previews");
root_tree->previews = bke::BKE_node_instance_hash_new("node previews");
}
const int2 preview_size = compute_preview_size(input_result.domain().size);

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

@ -1282,7 +1282,7 @@ void DepsgraphNodeBuilder::build_animation_images(ID *id)
* we have to check if they might be created during evaluation. */
bool has_image_animation = false;
if (ELEM(GS(id->name), ID_MA, ID_WO)) {
bNodeTree *ntree = *BKE_ntree_ptr_from_id(id);
bNodeTree *ntree = *bke::BKE_ntree_ptr_from_id(id);
if (ntree != nullptr && ntree->runtime->runtime_flag & NTREE_RUNTIME_FLAG_HAS_IMAGE_ANIMATION)
{
has_image_animation = true;

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

@ -1753,7 +1753,7 @@ void DepsgraphRelationBuilder::build_animation_images(ID *id)
/* See #DepsgraphNodeBuilder::build_animation_images. */
bool has_image_animation = false;
if (ELEM(GS(id->name), ID_MA, ID_WO)) {
bNodeTree *ntree = *BKE_ntree_ptr_from_id(id);
bNodeTree *ntree = *bke::BKE_ntree_ptr_from_id(id);
if (ntree != nullptr && ntree->runtime->runtime_flag & NTREE_RUNTIME_FLAG_HAS_IMAGE_ANIMATION)
{
has_image_animation = true;

2
source/blender/depsgraph/intern/depsgraph_query_iter.cc
View file

@ -413,7 +413,7 @@ static void DEG_iterator_ids_step(BLI_Iterator *iter, deg::IDNode *id_node, bool
if (only_updated && !(id_cow->recalc & ID_RECALC_ALL)) {
/* Node-tree is considered part of the data-block. */
bNodeTree *ntree = ntreeFromID(id_cow);
bNodeTree *ntree = blender::bke::ntreeFromID(id_cow);
if (ntree == nullptr) {
iter->skip = true;
return;

4
source/blender/depsgraph/intern/depsgraph_tag.cc
View file

@ -239,7 +239,7 @@ void depsgraph_tag_to_component_opcode(const ID *id,
void id_tag_update_ntree_special(
Main *bmain, Depsgraph *graph, ID *id, uint flags, eUpdateSource update_source)
{
bNodeTree *ntree = ntreeFromID(id);
bNodeTree *ntree = bke::ntreeFromID(id);
if (ntree == nullptr) {
return;
}
@ -937,7 +937,7 @@ void DEG_editors_update(Depsgraph *depsgraph, bool time)
static void deg_graph_clear_id_recalc_flags(ID *id)
{
id->recalc &= ~ID_RECALC_ALL;
bNodeTree *ntree = ntreeFromID(id);
bNodeTree *ntree = blender::bke::ntreeFromID(id);
/* Clear embedded node trees too. */
if (ntree) {
ntree->id.recalc &= ~ID_RECALC_ALL;

100
source/blender/draw/engines/eevee/eevee_shaders.cc
View file

@ -1042,19 +1042,19 @@ Material *EEVEE_material_default_diffuse_get()
nullptr, &ma->id, "Shader Nodetree", ntreeType_Shader->idname);
ma->use_nodes = true;
bNode *bsdf = nodeAddStaticNode(nullptr, ntree, SH_NODE_BSDF_DIFFUSE);
bNodeSocket *base_color = nodeFindSocket(bsdf, SOCK_IN, "Color");
bNode *bsdf = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_BSDF_DIFFUSE);
bNodeSocket *base_color = blender::bke::nodeFindSocket(bsdf, SOCK_IN, "Color");
copy_v3_fl(((bNodeSocketValueRGBA *)base_color->default_value)->value, 0.8f);
bNode *output = nodeAddStaticNode(nullptr, ntree, SH_NODE_OUTPUT_MATERIAL);
bNode *output = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_OUTPUT_MATERIAL);
nodeAddLink(ntree,
bsdf,
nodeFindSocket(bsdf, SOCK_OUT, "BSDF"),
output,
nodeFindSocket(output, SOCK_IN, "Surface"));
blender::bke::nodeAddLink(ntree,
bsdf,
blender::bke::nodeFindSocket(bsdf, SOCK_OUT, "BSDF"),
output,
blender::bke::nodeFindSocket(output, SOCK_IN, "Surface"));
nodeSetActive(ntree, output);
blender::bke::nodeSetActive(ntree, output);
e_data.diffuse_mat = ma;
}
return e_data.diffuse_mat;
@ -1069,21 +1069,21 @@ Material *EEVEE_material_default_glossy_get()
nullptr, &ma->id, "Shader Nodetree", ntreeType_Shader->idname);
ma->use_nodes = true;
bNode *bsdf = nodeAddStaticNode(nullptr, ntree, SH_NODE_BSDF_GLOSSY);
bNodeSocket *base_color = nodeFindSocket(bsdf, SOCK_IN, "Color");
bNode *bsdf = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_BSDF_GLOSSY);
bNodeSocket *base_color = blender::bke::nodeFindSocket(bsdf, SOCK_IN, "Color");
copy_v3_fl(((bNodeSocketValueRGBA *)base_color->default_value)->value, 1.0f);
bNodeSocket *roughness = nodeFindSocket(bsdf, SOCK_IN, "Roughness");
bNodeSocket *roughness = blender::bke::nodeFindSocket(bsdf, SOCK_IN, "Roughness");
((bNodeSocketValueFloat *)roughness->default_value)->value = 0.0f;
bNode *output = nodeAddStaticNode(nullptr, ntree, SH_NODE_OUTPUT_MATERIAL);
bNode *output = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_OUTPUT_MATERIAL);
nodeAddLink(ntree,
bsdf,
nodeFindSocket(bsdf, SOCK_OUT, "BSDF"),
output,
nodeFindSocket(output, SOCK_IN, "Surface"));
blender::bke::nodeAddLink(ntree,
bsdf,
blender::bke::nodeFindSocket(bsdf, SOCK_OUT, "BSDF"),
output,
blender::bke::nodeFindSocket(output, SOCK_IN, "Surface"));
nodeSetActive(ntree, output);
blender::bke::nodeSetActive(ntree, output);
e_data.glossy_mat = ma;
}
return e_data.glossy_mat;
@ -1099,19 +1099,19 @@ Material *EEVEE_material_default_error_get()
ma->use_nodes = true;
/* Use emission and output material to be compatible with both World and Material. */
bNode *bsdf = nodeAddStaticNode(nullptr, ntree, SH_NODE_EMISSION);
bNodeSocket *color = nodeFindSocket(bsdf, SOCK_IN, "Color");
bNode *bsdf = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_EMISSION);
bNodeSocket *color = blender::bke::nodeFindSocket(bsdf, SOCK_IN, "Color");
copy_v3_fl3(((bNodeSocketValueRGBA *)color->default_value)->value, 1.0f, 0.0f, 1.0f);
bNode *output = nodeAddStaticNode(nullptr, ntree, SH_NODE_OUTPUT_MATERIAL);
bNode *output = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_OUTPUT_MATERIAL);
nodeAddLink(ntree,
bsdf,
nodeFindSocket(bsdf, SOCK_OUT, "Emission"),
output,
nodeFindSocket(output, SOCK_IN, "Surface"));
blender::bke::nodeAddLink(ntree,
bsdf,
blender::bke::nodeFindSocket(bsdf, SOCK_OUT, "Emission"),
output,
blender::bke::nodeFindSocket(output, SOCK_IN, "Surface"));
nodeSetActive(ntree, output);
blender::bke::nodeSetActive(ntree, output);
e_data.error_mat = ma;
}
return e_data.error_mat;
@ -1121,22 +1121,23 @@ bNodeTree *EEVEE_shader_default_surface_nodetree(Material *ma)
{
/* WARNING: This function is not threadsafe. Which is not a problem for the moment. */
if (!e_data.surface.ntree) {
bNodeTree *ntree = ntreeAddTree(nullptr, "Shader Nodetree", ntreeType_Shader->idname);
bNode *bsdf = nodeAddStaticNode(nullptr, ntree, SH_NODE_BSDF_PRINCIPLED);
bNode *output = nodeAddStaticNode(nullptr, ntree, SH_NODE_OUTPUT_MATERIAL);
bNodeSocket *bsdf_out = nodeFindSocket(bsdf, SOCK_OUT, "BSDF");
bNodeSocket *output_in = nodeFindSocket(output, SOCK_IN, "Surface");
nodeAddLink(ntree, bsdf, bsdf_out, output, output_in);
nodeSetActive(ntree, output);
bNodeTree *ntree = blender::bke::ntreeAddTree(
nullptr, "Shader Nodetree", ntreeType_Shader->idname);
bNode *bsdf = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_BSDF_PRINCIPLED);
bNode *output = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_OUTPUT_MATERIAL);
bNodeSocket *bsdf_out = blender::bke::nodeFindSocket(bsdf, SOCK_OUT, "BSDF");
bNodeSocket *output_in = blender::bke::nodeFindSocket(output, SOCK_IN, "Surface");
blender::bke::nodeAddLink(ntree, bsdf, bsdf_out, output, output_in);
blender::bke::nodeSetActive(ntree, output);
e_data.surface.color_socket = static_cast<bNodeSocketValueRGBA *>(
nodeFindSocket(bsdf, SOCK_IN, "Base Color")->default_value);
blender::bke::nodeFindSocket(bsdf, SOCK_IN, "Base Color")->default_value);
e_data.surface.metallic_socket = static_cast<bNodeSocketValueFloat *>(
nodeFindSocket(bsdf, SOCK_IN, "Metallic")->default_value);
blender::bke::nodeFindSocket(bsdf, SOCK_IN, "Metallic")->default_value);
e_data.surface.roughness_socket = static_cast<bNodeSocketValueFloat *>(
nodeFindSocket(bsdf, SOCK_IN, "Roughness")->default_value);
blender::bke::nodeFindSocket(bsdf, SOCK_IN, "Roughness")->default_value);
e_data.surface.specular_socket = static_cast<bNodeSocketValueFloat *>(
nodeFindSocket(bsdf, SOCK_IN, "Specular IOR Level")->default_value);
blender::bke::nodeFindSocket(bsdf, SOCK_IN, "Specular IOR Level")->default_value);
e_data.surface.ntree = ntree;
}
/* Update */
@ -1152,16 +1153,17 @@ bNodeTree *EEVEE_shader_default_world_nodetree(World *wo)
{
/* WARNING: This function is not threadsafe. Which is not a problem for the moment. */
if (!e_data.world.ntree) {
bNodeTree *ntree = ntreeAddTree(nullptr, "Shader Nodetree", ntreeType_Shader->idname);
bNode *bg = nodeAddStaticNode(nullptr, ntree, SH_NODE_BACKGROUND);
bNode *output = nodeAddStaticNode(nullptr, ntree, SH_NODE_OUTPUT_WORLD);
bNodeSocket *bg_out = nodeFindSocket(bg, SOCK_OUT, "Background");
bNodeSocket *output_in = nodeFindSocket(output, SOCK_IN, "Surface");
nodeAddLink(ntree, bg, bg_out, output, output_in);
nodeSetActive(ntree, output);
bNodeTree *ntree = blender::bke::ntreeAddTree(
nullptr, "Shader Nodetree", ntreeType_Shader->idname);
bNode *bg = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_BACKGROUND);
bNode *output = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_OUTPUT_WORLD);
bNodeSocket *bg_out = blender::bke::nodeFindSocket(bg, SOCK_OUT, "Background");
bNodeSocket *output_in = blender::bke::nodeFindSocket(output, SOCK_IN, "Surface");
blender::bke::nodeAddLink(ntree, bg, bg_out, output, output_in);
blender::bke::nodeSetActive(ntree, output);
e_data.world.color_socket = static_cast<bNodeSocketValueRGBA *>(
nodeFindSocket(bg, SOCK_IN, "Color")->default_value);
blender::bke::nodeFindSocket(bg, SOCK_IN, "Color")->default_value);
e_data.world.ntree = ntree;
}
@ -1559,12 +1561,12 @@ void EEVEE_shaders_free()
e_data.error_mat = nullptr;
}
if (e_data.surface.ntree) {
ntreeFreeEmbeddedTree(e_data.surface.ntree);
blender::bke::ntreeFreeEmbeddedTree(e_data.surface.ntree);
MEM_freeN(e_data.surface.ntree);
e_data.surface.ntree = nullptr;
}
if (e_data.world.ntree) {
ntreeFreeEmbeddedTree(e_data.world.ntree);
blender::bke::ntreeFreeEmbeddedTree(e_data.world.ntree);
MEM_freeN(e_data.world.ntree);
e_data.world.ntree = nullptr;
}

43
source/blender/draw/engines/eevee_next/eevee_lookdev.cc
View file

@ -27,38 +27,39 @@ namespace blender::eevee {
LookdevWorld::LookdevWorld()
{
bNodeTree *ntree = ntreeAddTree(nullptr, "Lookdev World Nodetree", ntreeType_Shader->idname);
bNodeTree *ntree = bke::ntreeAddTree(
nullptr, "Lookdev World Nodetree", ntreeType_Shader->idname);
bNode *coordinate = nodeAddStaticNode(nullptr, ntree, SH_NODE_TEX_COORD);
bNodeSocket *coordinate_out = nodeFindSocket(coordinate, SOCK_OUT, "Generated");
bNode *coordinate = bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_TEX_COORD);
bNodeSocket *coordinate_out = bke::nodeFindSocket(coordinate, SOCK_OUT, "Generated");
bNode *rotate = nodeAddStaticNode(nullptr, ntree, SH_NODE_VECTOR_ROTATE);
bNode *rotate = bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_VECTOR_ROTATE);
rotate->custom1 = NODE_VECTOR_ROTATE_TYPE_AXIS_Z;
bNodeSocket *rotate_vector_in = nodeFindSocket(rotate, SOCK_IN, "Vector");
bNodeSocket *rotate_vector_in = bke::nodeFindSocket(rotate, SOCK_IN, "Vector");
angle_socket_ = static_cast<bNodeSocketValueFloat *>(
static_cast<void *>(nodeFindSocket(rotate, SOCK_IN, "Angle")->default_value));
bNodeSocket *rotate_out = nodeFindSocket(rotate, SOCK_OUT, "Vector");
static_cast<void *>(bke::nodeFindSocket(rotate, SOCK_IN, "Angle")->default_value));
bNodeSocket *rotate_out = bke::nodeFindSocket(rotate, SOCK_OUT, "Vector");
bNode *environment = nodeAddStaticNode(nullptr, ntree, SH_NODE_TEX_ENVIRONMENT);
bNode *environment = bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_TEX_ENVIRONMENT);
environment_node_ = environment;
NodeTexImage *environment_storage = static_cast<NodeTexImage *>(environment->storage);
bNodeSocket *environment_vector_in = nodeFindSocket(environment, SOCK_IN, "Vector");
bNodeSocket *environment_out = nodeFindSocket(environment, SOCK_OUT, "Color");
bNodeSocket *environment_vector_in = bke::nodeFindSocket(environment, SOCK_IN, "Vector");
bNodeSocket *environment_out = bke::nodeFindSocket(environment, SOCK_OUT, "Color");
bNode *background = nodeAddStaticNode(nullptr, ntree, SH_NODE_BACKGROUND);
bNodeSocket *background_out = nodeFindSocket(background, SOCK_OUT, "Background");
bNodeSocket *background_color_in = nodeFindSocket(background, SOCK_IN, "Color");
bNode *background = bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_BACKGROUND);
bNodeSocket *background_out = bke::nodeFindSocket(background, SOCK_OUT, "Background");
bNodeSocket *background_color_in = bke::nodeFindSocket(background, SOCK_IN, "Color");
intensity_socket_ = static_cast<bNodeSocketValueFloat *>(
static_cast<void *>(nodeFindSocket(background, SOCK_IN, "Strength")->default_value));
static_cast<void *>(bke::nodeFindSocket(background, SOCK_IN, "Strength")->default_value));
bNode *output = nodeAddStaticNode(nullptr, ntree, SH_NODE_OUTPUT_WORLD);
bNodeSocket *output_in = nodeFindSocket(output, SOCK_IN, "Surface");
bNode *output = bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_OUTPUT_WORLD);
bNodeSocket *output_in = bke::nodeFindSocket(output, SOCK_IN, "Surface");
nodeAddLink(ntree, coordinate, coordinate_out, rotate, rotate_vector_in);
nodeAddLink(ntree, rotate, rotate_out, environment, environment_vector_in);
nodeAddLink(ntree, environment, environment_out, background, background_color_in);
nodeAddLink(ntree, background, background_out, output, output_in);
nodeSetActive(ntree, output);
bke::nodeAddLink(ntree, coordinate, coordinate_out, rotate, rotate_vector_in);
bke::nodeAddLink(ntree, rotate, rotate_out, environment, environment_vector_in);
bke::nodeAddLink(ntree, environment, environment_out, background, background_color_in);
bke::nodeAddLink(ntree, background, background_out, output, output_in);
bke::nodeSetActive(ntree, output);
/* Create a dummy image data block to hold GPU textures generated by studio-lights. */
STRNCPY(image.id.name, "IMLookdev");

83
source/blender/draw/engines/eevee_next/eevee_material.cc
View file

@ -26,28 +26,29 @@ namespace blender::eevee {
DefaultSurfaceNodeTree::DefaultSurfaceNodeTree()
{
bNodeTree *ntree = ntreeAddTree(nullptr, "Shader Nodetree", ntreeType_Shader->idname);
bNode *bsdf = nodeAddStaticNode(nullptr, ntree, SH_NODE_BSDF_PRINCIPLED);
bNode *output = nodeAddStaticNode(nullptr, ntree, SH_NODE_OUTPUT_MATERIAL);
bNodeSocket *bsdf_out = nodeFindSocket(bsdf, SOCK_OUT, "BSDF");
bNodeSocket *output_in = nodeFindSocket(output, SOCK_IN, "Surface");
nodeAddLink(ntree, bsdf, bsdf_out, output, output_in);
nodeSetActive(ntree, output);
bNodeTree *ntree = bke::ntreeAddTree(nullptr, "Shader Nodetree", ntreeType_Shader->idname);
bNode *bsdf = bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_BSDF_PRINCIPLED);
bNode *output = bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_OUTPUT_MATERIAL);
bNodeSocket *bsdf_out = bke::nodeFindSocket(bsdf, SOCK_OUT, "BSDF");
bNodeSocket *output_in = bke::nodeFindSocket(output, SOCK_IN, "Surface");
bke::nodeAddLink(ntree, bsdf, bsdf_out, output, output_in);
bke::nodeSetActive(ntree, output);
color_socket_ =
(bNodeSocketValueRGBA *)nodeFindSocket(bsdf, SOCK_IN, "Base Color")->default_value;
(bNodeSocketValueRGBA *)bke::nodeFindSocket(bsdf, SOCK_IN, "Base Color")->default_value;
metallic_socket_ =
(bNodeSocketValueFloat *)nodeFindSocket(bsdf, SOCK_IN, "Metallic")->default_value;
(bNodeSocketValueFloat *)bke::nodeFindSocket(bsdf, SOCK_IN, "Metallic")->default_value;
roughness_socket_ =
(bNodeSocketValueFloat *)nodeFindSocket(bsdf, SOCK_IN, "Roughness")->default_value;
specular_socket_ =
(bNodeSocketValueFloat *)nodeFindSocket(bsdf, SOCK_IN, "Specular IOR Level")->default_value;
(bNodeSocketValueFloat *)bke::nodeFindSocket(bsdf, SOCK_IN, "Roughness")->default_value;
specular_socket_ = (bNodeSocketValueFloat *)bke::nodeFindSocket(
bsdf, SOCK_IN, "Specular IOR Level")
->default_value;
ntree_ = ntree;
}
DefaultSurfaceNodeTree::~DefaultSurfaceNodeTree()
{
ntreeFreeEmbeddedTree(ntree_);
bke::ntreeFreeEmbeddedTree(ntree_);
MEM_SAFE_FREE(ntree_);
}
@ -80,19 +81,19 @@ MaterialModule::MaterialModule(Instance &inst) : inst_(inst)
/* Use 0.18 as it is close to middle gray. Middle gray is typically defined as 18% reflectance
* of visible light and commonly used for VFX balls. */
bNode *bsdf = nodeAddStaticNode(nullptr, ntree, SH_NODE_BSDF_DIFFUSE);
bNodeSocket *base_color = nodeFindSocket(bsdf, SOCK_IN, "Color");
bNode *bsdf = bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_BSDF_DIFFUSE);
bNodeSocket *base_color = bke::nodeFindSocket(bsdf, SOCK_IN, "Color");
copy_v3_fl(((bNodeSocketValueRGBA *)base_color->default_value)->value, 0.18f);
bNode *output = nodeAddStaticNode(nullptr, ntree, SH_NODE_OUTPUT_MATERIAL);
bNode *output = bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_OUTPUT_MATERIAL);
nodeAddLink(ntree,
bsdf,
nodeFindSocket(bsdf, SOCK_OUT, "BSDF"),
output,
nodeFindSocket(output, SOCK_IN, "Surface"));
bke::nodeAddLink(ntree,
bsdf,
bke::nodeFindSocket(bsdf, SOCK_OUT, "BSDF"),
output,
bke::nodeFindSocket(output, SOCK_IN, "Surface"));
nodeSetActive(ntree, output);
bke::nodeSetActive(ntree, output);
}
{
metallic_mat = (::Material *)BKE_id_new_nomain(ID_MA, "EEVEE default metal");
@ -101,21 +102,21 @@ MaterialModule::MaterialModule(Instance &inst) : inst_(inst)
metallic_mat->use_nodes = true;
metallic_mat->surface_render_method = MA_SURFACE_METHOD_FORWARD;
bNode *bsdf = nodeAddStaticNode(nullptr, ntree, SH_NODE_BSDF_GLOSSY);
bNodeSocket *base_color = nodeFindSocket(bsdf, SOCK_IN, "Color");
bNode *bsdf = bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_BSDF_GLOSSY);
bNodeSocket *base_color = bke::nodeFindSocket(bsdf, SOCK_IN, "Color");
copy_v3_fl(((bNodeSocketValueRGBA *)base_color->default_value)->value, 1.0f);
bNodeSocket *roughness = nodeFindSocket(bsdf, SOCK_IN, "Roughness");
bNodeSocket *roughness = bke::nodeFindSocket(bsdf, SOCK_IN, "Roughness");
((bNodeSocketValueFloat *)roughness->default_value)->value = 0.0f;
bNode *output = nodeAddStaticNode(nullptr, ntree, SH_NODE_OUTPUT_MATERIAL);
bNode *output = bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_OUTPUT_MATERIAL);
nodeAddLink(ntree,
bsdf,
nodeFindSocket(bsdf, SOCK_OUT, "BSDF"),
output,
nodeFindSocket(output, SOCK_IN, "Surface"));
bke::nodeAddLink(ntree,
bsdf,
bke::nodeFindSocket(bsdf, SOCK_OUT, "BSDF"),
output,
bke::nodeFindSocket(output, SOCK_IN, "Surface"));
nodeSetActive(ntree, output);
bke::nodeSetActive(ntree, output);
}
{
error_mat_ = (::Material *)BKE_id_new_nomain(ID_MA, "EEVEE default error");
@ -124,19 +125,19 @@ MaterialModule::MaterialModule(Instance &inst) : inst_(inst)
error_mat_->use_nodes = true;
/* Use emission and output material to be compatible with both World and Material. */
bNode *bsdf = nodeAddStaticNode(nullptr, ntree, SH_NODE_EMISSION);
bNodeSocket *color = nodeFindSocket(bsdf, SOCK_IN, "Color");
bNode *bsdf = bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_EMISSION);
bNodeSocket *color = bke::nodeFindSocket(bsdf, SOCK_IN, "Color");
copy_v3_fl3(((bNodeSocketValueRGBA *)color->default_value)->value, 1.0f, 0.0f, 1.0f);
bNode *output = nodeAddStaticNode(nullptr, ntree, SH_NODE_OUTPUT_MATERIAL);
bNode *output = bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_OUTPUT_MATERIAL);
nodeAddLink(ntree,
bsdf,
nodeFindSocket(bsdf, SOCK_OUT, "Emission"),
output,
nodeFindSocket(output, SOCK_IN, "Surface"));
bke::nodeAddLink(ntree,
bsdf,
bke::nodeFindSocket(bsdf, SOCK_OUT, "Emission"),
output,
bke::nodeFindSocket(output, SOCK_IN, "Surface"));
nodeSetActive(ntree, output);
bke::nodeSetActive(ntree, output);
}
}

18
source/blender/draw/engines/eevee_next/eevee_world.cc
View file

@ -23,22 +23,22 @@ namespace blender::eevee {
DefaultWorldNodeTree::DefaultWorldNodeTree()
{
bNodeTree *ntree = ntreeAddTree(nullptr, "World Nodetree", ntreeType_Shader->idname);
bNode *background = nodeAddStaticNode(nullptr, ntree, SH_NODE_BACKGROUND);
bNode *output = nodeAddStaticNode(nullptr, ntree, SH_NODE_OUTPUT_WORLD);
bNodeSocket *background_out = nodeFindSocket(background, SOCK_OUT, "Background");
bNodeSocket *output_in = nodeFindSocket(output, SOCK_IN, "Surface");
nodeAddLink(ntree, background, background_out, output, output_in);
nodeSetActive(ntree, output);
bNodeTree *ntree = bke::ntreeAddTree(nullptr, "World Nodetree", ntreeType_Shader->idname);
bNode *background = bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_BACKGROUND);
bNode *output = bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_OUTPUT_WORLD);
bNodeSocket *background_out = bke::nodeFindSocket(background, SOCK_OUT, "Background");
bNodeSocket *output_in = bke::nodeFindSocket(output, SOCK_IN, "Surface");
bke::nodeAddLink(ntree, background, background_out, output, output_in);
bke::nodeSetActive(ntree, output);
color_socket_ =
(bNodeSocketValueRGBA *)nodeFindSocket(background, SOCK_IN, "Color")->default_value;
(bNodeSocketValueRGBA *)bke::nodeFindSocket(background, SOCK_IN, "Color")->default_value;
ntree_ = ntree;
}
DefaultWorldNodeTree::~DefaultWorldNodeTree()
{
ntreeFreeEmbeddedTree(ntree_);
bke::ntreeFreeEmbeddedTree(ntree_);
MEM_SAFE_FREE(ntree_);
}

2
source/blender/editors/animation/anim_filter.cc
View file

@ -1049,7 +1049,7 @@ static bool skip_fcurve_selected_data(bDopeSheet *ads, FCurve *fcu, ID *owner_id
BLI_str_quoted_substr(fcu->rna_path, "nodes[", node_name, sizeof(node_name)))
{
/* Get strip name, and check if this strip is selected. */
node = nodeFindNodebyName(ntree, node_name);
node = bke::nodeFindNodebyName(ntree, node_name);
/* Can only add this F-Curve if it is selected. */
if (node) {

16
source/blender/editors/curves/intern/curves_add.cc
View file

@ -70,7 +70,7 @@ void ensure_surface_deformation_node_exists(bContext &C, Object &curves_ob)
ModifierData *md = object::modifier_add(
nullptr, bmain, scene, &curves_ob, DATA_("Surface Deform"), eModifierType_Nodes);
NodesModifierData &nmd = *reinterpret_cast<NodesModifierData *>(md);
nmd.node_group = ntreeAddTree(bmain, DATA_("Surface Deform"), "GeometryNodeTree");
nmd.node_group = bke::ntreeAddTree(bmain, DATA_("Surface Deform"), "GeometryNodeTree");
if (!nmd.node_group->geometry_node_asset_traits) {
nmd.node_group->geometry_node_asset_traits = MEM_new<GeometryNodeAssetTraits>(__func__);
@ -83,20 +83,20 @@ void ensure_surface_deformation_node_exists(bContext &C, Object &curves_ob)
"Geometry", "", "NodeSocketGeometry", NODE_INTERFACE_SOCKET_OUTPUT, nullptr);
ntree->tree_interface.add_socket(
"Geometry", "", "NodeSocketGeometry", NODE_INTERFACE_SOCKET_INPUT, nullptr);
bNode *group_input = nodeAddStaticNode(&C, ntree, NODE_GROUP_INPUT);
bNode *group_output = nodeAddStaticNode(&C, ntree, NODE_GROUP_OUTPUT);
bNode *deform_node = nodeAddStaticNode(&C, ntree, GEO_NODE_DEFORM_CURVES_ON_SURFACE);
bNode *group_input = bke::nodeAddStaticNode(&C, ntree, NODE_GROUP_INPUT);
bNode *group_output = bke::nodeAddStaticNode(&C, ntree, NODE_GROUP_OUTPUT);
bNode *deform_node = bke::nodeAddStaticNode(&C, ntree, GEO_NODE_DEFORM_CURVES_ON_SURFACE);
ED_node_tree_propagate_change(&C, bmain, nmd.node_group);
nodeAddLink(ntree,
bke::nodeAddLink(ntree,
group_input,
static_cast<bNodeSocket *>(group_input->outputs.first),
deform_node,
nodeFindSocket(deform_node, SOCK_IN, "Curves"));
nodeAddLink(ntree,
bke::nodeFindSocket(deform_node, SOCK_IN, "Curves"));
bke::nodeAddLink(ntree,
deform_node,
nodeFindSocket(deform_node, SOCK_OUT, "Curves"),
bke::nodeFindSocket(deform_node, SOCK_OUT, "Curves"),
group_output,
static_cast<bNodeSocket *>(group_output->inputs.first));

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

@ -615,7 +615,7 @@ static void add_attribute_search_or_value_buttons(uiLayout *layout,
PointerRNA *md_ptr,
const bNodeTreeInterfaceSocket &socket)
{
bNodeSocketType *typeinfo = nodeSocketTypeFind(socket.socket_type);
bke::bNodeSocketType *typeinfo = bke::nodeSocketTypeFind(socket.socket_type);
const eNodeSocketDatatype socket_type = eNodeSocketDatatype(typeinfo->type);
char socket_id_esc[MAX_NAME * 2];
@ -668,7 +668,7 @@ static void draw_property_for_socket(const bNodeTree &node_tree,
const bNodeTreeInterfaceSocket &socket,
const int socket_index)
{
bNodeSocketType *typeinfo = nodeSocketTypeFind(socket.socket_type);
bke::bNodeSocketType *typeinfo = bke::nodeSocketTypeFind(socket.socket_type);
const eNodeSocketDatatype socket_type = eNodeSocketDatatype(typeinfo->type);
/* The property should be created in #MOD_nodes_update_interface with the correct type. */

14
source/blender/editors/include/ED_node_c.hh
View file

@ -17,10 +17,12 @@ struct Tex;
struct View2D;
struct bContext;
struct bNode;
struct bNodeSocketType;
struct bNodeTree;
namespace blender::bke {
struct bNodeTreeType;
struct bNodeType;
struct bNodeSocketType;
} // namespace blender::bke
enum NodeBorder {
NODE_TOP = 1,
@ -64,10 +66,10 @@ void ED_node_set_active_viewer_key(SpaceNode *snode);
/* `drawnode.cc` */
void ED_node_init_butfuncs();
void ED_init_custom_node_type(bNodeType *ntype);
void ED_init_custom_node_socket_type(bNodeSocketType *stype);
void ED_init_standard_node_socket_type(bNodeSocketType *stype);
void ED_init_node_socket_type_virtual(bNodeSocketType *stype);
void ED_init_custom_node_type(blender::bke::bNodeType *ntype);
void ED_init_custom_node_socket_type(blender::bke::bNodeSocketType *stype);
void ED_init_standard_node_socket_type(blender::bke::bNodeSocketType *stype);
void ED_init_node_socket_type_virtual(blender::bke::bNodeSocketType *stype);
void ED_node_sample_set(const float col[4]);
void ED_node_draw_snap(
View2D *v2d, const float cent[2], float size, NodeBorder border, unsigned int pos);
@ -82,7 +84,7 @@ float ED_node_grid_size();
/* `node_edit.cc` */
void ED_node_set_tree_type(SpaceNode *snode, bNodeTreeType *typeinfo);
void ED_node_set_tree_type(SpaceNode *snode, blender::bke::bNodeTreeType *typeinfo);
bool ED_node_is_compositor(SpaceNode *snode);
bool ED_node_is_shader(SpaceNode *snode);
bool ED_node_is_texture(SpaceNode *snode);

2
source/blender/editors/interface/interface_ops.cc
View file

@ -1222,7 +1222,7 @@ bool UI_context_copy_to_selected_list(bContext *C,
if (RNA_struct_is_a(ptr->type, &RNA_NodeSocket)) {
bNodeTree *ntree = (bNodeTree *)ptr->owner_id;
bNodeSocket *sock = static_cast<bNodeSocket *>(ptr->data);
if (nodeFindNodeTry(ntree, sock, &node, nullptr)) {
if (blender::bke::nodeFindNodeTry(ntree, sock, &node, nullptr)) {
path = RNA_path_resolve_from_type_to_property(ptr, prop, &RNA_Node);
if (path) {
/* we're good! */

2
source/blender/editors/object/object_relations.cc
View file

@ -3007,7 +3007,7 @@ static bool check_geometry_node_group_sockets(wmOperator *op, const bNodeTree *t
BKE_report(op->reports, RPT_ERROR, "The node group must have a geometry output socket");
return false;
}
const bNodeSocketType *typeinfo = first_output->socket_typeinfo();
const bke::bNodeSocketType *typeinfo = first_output->socket_typeinfo();
const eNodeSocketDatatype type = typeinfo ? eNodeSocketDatatype(typeinfo->type) : SOCK_CUSTOM;
if (type != SOCK_GEOMETRY) {
BKE_report(op->reports, RPT_ERROR, "The first output must be a geometry socket");

2
source/blender/editors/render/render_shading.cc
View file

@ -2959,7 +2959,7 @@ static int paste_material_exec(bContext *C, wmOperator *op)
BKE_library_foreach_ID_link(
bmain, &nodetree->id, paste_material_nodetree_ids_decref, nullptr, IDWALK_NOP);
ntreeFreeEmbeddedTree(nodetree);
blender::bke::ntreeFreeEmbeddedTree(nodetree);
MEM_freeN(nodetree);
ma->nodetree = nullptr;
}

2
source/blender/editors/scene/scene_edit.cc
View file

@ -192,7 +192,7 @@ static void view_layer_remove_unset_nodetrees(const Main *bmain, Scene *scene, V
sce = static_cast<Scene *>(sce->id.next))
{
if (sce->nodetree) {
BKE_nodetree_remove_layer_n(sce->nodetree, scene, act_layer_index);
blender::bke::BKE_nodetree_remove_layer_n(sce->nodetree, scene, act_layer_index);
}
}
}

40
source/blender/editors/sculpt_paint/paint_image_proj.cc
View file

@ -6600,10 +6600,10 @@ static void default_paint_slot_color_get(int layer_type, Material *ma, float col
if (!in_node) {
/* An existing material or Principled BSDF node could not be found.
* Copy default color values from a default Principled BSDF instead. */
ntree = ntreeAddTree(nullptr, "Temporary Shader Nodetree", ntreeType_Shader->idname);
in_node = nodeAddStaticNode(nullptr, ntree, SH_NODE_BSDF_PRINCIPLED);
ntree = blender::bke::ntreeAddTree(nullptr, "Temporary Shader Nodetree", ntreeType_Shader->idname);
in_node = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_BSDF_PRINCIPLED);
}
bNodeSocket *in_sock = nodeFindSocket(in_node, SOCK_IN, layer_type_items[layer_type].name);
bNodeSocket *in_sock = blender::bke::nodeFindSocket(in_node, SOCK_IN, layer_type_items[layer_type].name);
switch (in_sock->type) {
case SOCK_FLOAT: {
bNodeSocketValueFloat *socket_data = static_cast<bNodeSocketValueFloat *>(
@ -6681,13 +6681,13 @@ static bool proj_paint_add_slot(bContext *C, wmOperator *op)
/* Create a new node. */
switch (slot_type) {
case PAINT_CANVAS_SOURCE_IMAGE: {
new_node = nodeAddStaticNode(C, ntree, SH_NODE_TEX_IMAGE);
new_node = blender::bke::nodeAddStaticNode(C, ntree, SH_NODE_TEX_IMAGE);
ima = proj_paint_image_create(op, bmain, is_data);
new_node->id = &ima->id;
break;
}
case PAINT_CANVAS_SOURCE_COLOR_ATTRIBUTE: {
new_node = nodeAddStaticNode(C, ntree, SH_NODE_ATTRIBUTE);
new_node = blender::bke::nodeAddStaticNode(C, ntree, SH_NODE_ATTRIBUTE);
if (const char *name = proj_paint_color_attribute_create(op, ob)) {
STRNCPY_UTF8(((NodeShaderAttribute *)new_node->storage)->name, name);
}
@ -6697,7 +6697,7 @@ static bool proj_paint_add_slot(bContext *C, wmOperator *op)
BLI_assert_unreachable();
return false;
}
nodeSetActive(ntree, new_node);
blender::bke::nodeSetActive(ntree, new_node);
/* Connect to first available principled BSDF node. */
ntree->ensure_topology_cache();
@ -6706,33 +6706,33 @@ static bool proj_paint_add_slot(bContext *C, wmOperator *op)
bNode *out_node = new_node;
if (in_node != nullptr) {
bNodeSocket *out_sock = nodeFindSocket(out_node, SOCK_OUT, "Color");
bNodeSocket *out_sock = blender::bke::nodeFindSocket(out_node, SOCK_OUT, "Color");
bNodeSocket *in_sock = nullptr;
if (type >= LAYER_BASE_COLOR && type < LAYER_NORMAL) {
in_sock = nodeFindSocket(in_node, SOCK_IN, layer_type_items[type].name);
in_sock = blender::bke::nodeFindSocket(in_node, SOCK_IN, layer_type_items[type].name);
}
else if (type == LAYER_NORMAL) {
bNode *nor_node;
nor_node = nodeAddStaticNode(C, ntree, SH_NODE_NORMAL_MAP);
nor_node = blender::bke::nodeAddStaticNode(C, ntree, SH_NODE_NORMAL_MAP);
in_sock = nodeFindSocket(nor_node, SOCK_IN, "Color");
nodeAddLink(ntree, out_node, out_sock, nor_node, in_sock);
in_sock = blender::bke::nodeFindSocket(nor_node, SOCK_IN, "Color");
blender::bke::nodeAddLink(ntree, out_node, out_sock, nor_node, in_sock);
in_sock = nodeFindSocket(in_node, SOCK_IN, "Normal");
out_sock = nodeFindSocket(nor_node, SOCK_OUT, "Normal");
in_sock = blender::bke::nodeFindSocket(in_node, SOCK_IN, "Normal");
out_sock = blender::bke::nodeFindSocket(nor_node, SOCK_OUT, "Normal");
out_node = nor_node;
}
else if (type == LAYER_BUMP) {
bNode *bump_node;
bump_node = nodeAddStaticNode(C, ntree, SH_NODE_BUMP);
bump_node = blender::bke::nodeAddStaticNode(C, ntree, SH_NODE_BUMP);
in_sock = nodeFindSocket(bump_node, SOCK_IN, "Height");
nodeAddLink(ntree, out_node, out_sock, bump_node, in_sock);
in_sock = blender::bke::nodeFindSocket(bump_node, SOCK_IN, "Height");
blender::bke::nodeAddLink(ntree, out_node, out_sock, bump_node, in_sock);
in_sock = nodeFindSocket(in_node, SOCK_IN, "Normal");
out_sock = nodeFindSocket(bump_node, SOCK_OUT, "Normal");
in_sock = blender::bke::nodeFindSocket(in_node, SOCK_IN, "Normal");
out_sock = blender::bke::nodeFindSocket(bump_node, SOCK_OUT, "Normal");
out_node = bump_node;
}
@ -6743,7 +6743,7 @@ static bool proj_paint_add_slot(bContext *C, wmOperator *op)
in_node = output_nodes.is_empty() ? nullptr : output_nodes.first();
if (in_node != nullptr) {
in_sock = nodeFindSocket(in_node, SOCK_IN, layer_type_items[type].name);
in_sock = blender::bke::nodeFindSocket(in_node, SOCK_IN, layer_type_items[type].name);
}
else {
in_sock = nullptr;
@ -6753,7 +6753,7 @@ static bool proj_paint_add_slot(bContext *C, wmOperator *op)
/* Check if the socket in already connected to something */
bNodeLink *link = in_sock ? in_sock->link : nullptr;
if (in_sock != nullptr && link == nullptr) {
nodeAddLink(ntree, out_node, out_sock, in_node, in_sock);
blender::bke::nodeAddLink(ntree, out_node, out_sock, in_node, in_sock);
blender::bke::nodePositionRelative(out_node, in_node, out_sock, in_sock);
}

4
source/blender/editors/space_buttons/buttons_texture.cc
View file

@ -438,9 +438,9 @@ static void template_texture_select(bContext *C, void *user_p, void * /*arg*/)
/* Not totally sure if we should also change selection? */
for (bNode *node : user->ntree->all_nodes()) {
nodeSetSelected(node, false);
blender::bke::nodeSetSelected(node, false);
}
nodeSetSelected(user->node, true);
blender::bke::nodeSetSelected(user->node, true);
WM_event_add_notifier(C, NC_NODE | NA_SELECTED, nullptr);
}
if (user->ptr.data) {

6
source/blender/editors/space_node/clipboard.cc
View file

@ -291,7 +291,7 @@ static int node_clipboard_copy_exec(bContext *C, wmOperator * /*op*/)
new_node->parent = node_map.lookup(new_node->parent);
}
else {
nodeDetachNode(&tree, new_node);
bke::nodeDetachNode(&tree, new_node);
}
}
}
@ -399,7 +399,7 @@ static int node_clipboard_paste_exec(bContext *C, wmOperator *op)
}
for (bNode *new_node : node_map.values()) {
nodeSetSelected(new_node, true);
bke::nodeSetSelected(new_node, true);
new_node->flag &= ~NODE_ACTIVE;
@ -439,7 +439,7 @@ static int node_clipboard_paste_exec(bContext *C, wmOperator *op)
const bNode *fromnode = link.fromnode;
const bNode *tonode = link.tonode;
if (node_map.lookup_key_ptr(fromnode) && node_map.lookup_key_ptr(tonode)) {
bNodeLink *new_link = nodeAddLink(&tree,
bNodeLink *new_link = bke::nodeAddLink(&tree,
node_map.lookup(fromnode),
socket_map.lookup(link.fromsock),
node_map.lookup(tonode),

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

@ -294,7 +294,7 @@ static void node_buts_frame_ex(uiLayout *layout, bContext * /*C*/, PointerRNA *p
uiItemR(layout, ptr, "text", DEFAULT_FLAGS, nullptr, ICON_NONE);
}
static void node_common_set_butfunc(bNodeType *ntype)
static void node_common_set_butfunc(blender::bke::bNodeType *ntype)
{
switch (ntype->type) {
case NODE_GROUP:
@ -462,7 +462,7 @@ static void node_buts_output_shader(uiLayout *layout, bContext * /*C*/, PointerR
}
/* only once called */
static void node_shader_set_butfunc(bNodeType *ntype)
static void node_shader_set_butfunc(blender::bke::bNodeType *ntype)
{
switch (ntype->type) {
case SH_NODE_NORMAL:
@ -807,7 +807,7 @@ static void node_composit_buts_cryptomatte(uiLayout *layout, bContext *C, Pointe
}
/* only once called */
static void node_composit_set_butfunc(bNodeType *ntype)
static void node_composit_set_butfunc(blender::bke::bNodeType *ntype)
{
switch (ntype->type) {
case CMP_NODE_IMAGE:
@ -1005,7 +1005,7 @@ static void node_texture_buts_combsep_color(uiLayout *layout, bContext * /*C*/,
}
/* only once called */
static void node_texture_set_butfunc(bNodeType *ntype)
static void node_texture_set_butfunc(blender::bke::bNodeType *ntype)
{
if (ntype->type >= TEX_NODE_PROC && ntype->type < TEX_NODE_PROC_MAX) {
ntype->draw_buttons = node_texture_buts_proc;
@ -1072,7 +1072,8 @@ static void node_property_update_default(Main *bmain, Scene * /*scene*/, Pointer
ED_node_tree_propagate_change(nullptr, bmain, ntree);
}
static void node_socket_template_properties_update(bNodeType *ntype, bNodeSocketTemplate *stemp)
static void node_socket_template_properties_update(blender::bke::bNodeType *ntype,
blender::bke::bNodeSocketTemplate *stemp)
{
StructRNA *srna = ntype->rna_ext.srna;
PropertyRNA *prop = RNA_struct_type_find_property(srna, stemp->identifier);
@ -1082,9 +1083,9 @@ static void node_socket_template_properties_update(bNodeType *ntype, bNodeSocket
}
}
static void node_template_properties_update(bNodeType *ntype)
static void node_template_properties_update(blender::bke::bNodeType *ntype)
{
bNodeSocketTemplate *stemp;
blender::bke::bNodeSocketTemplate *stemp;
if (ntype->inputs) {
for (stemp = ntype->inputs; stemp->type >= 0; stemp++) {
@ -1118,7 +1119,7 @@ static void node_socket_undefined_draw_color(bContext * /*C*/,
r_color[3] = 1.0f;
}
static void node_socket_undefined_draw_color_simple(const bNodeSocketType * /*type*/,
static void node_socket_undefined_draw_color_simple(const bke::bNodeSocketType * /*type*/,
float *r_color)
{
r_color[0] = 1.0f;
@ -1172,9 +1173,9 @@ void ED_node_init_butfuncs()
NODE_TYPES_END;
}
void ED_init_custom_node_type(bNodeType * /*ntype*/) {}
void ED_init_custom_node_type(blender::bke::bNodeType * /*ntype*/) {}
void ED_init_custom_node_socket_type(bNodeSocketType *stype)
void ED_init_custom_node_socket_type(blender::bke::bNodeSocketType *stype)
{
stype->draw = blender::ed::space_node::node_socket_button_label;
}
@ -1213,7 +1214,7 @@ void std_node_socket_color_fn(bContext * /*C*/,
{
copy_v4_v4(r_color, std_node_socket_colors[socket_type]);
};
static void std_node_socket_color_simple_fn(const bNodeSocketType *type, float *r_color)
static void std_node_socket_color_simple_fn(const bke::bNodeSocketType *type, float *r_color)
{
copy_v4_v4(r_color, std_node_socket_colors[type->type]);
};
@ -1485,7 +1486,7 @@ static void std_node_socket_interface_draw(ID *id,
{
PointerRNA ptr = RNA_pointer_create(id, &RNA_NodeTreeInterfaceSocket, interface_socket);
const bNodeSocketType *typeinfo = interface_socket->socket_typeinfo();
const bke::bNodeSocketType *typeinfo = interface_socket->socket_typeinfo();
BLI_assert(typeinfo != nullptr);
eNodeSocketDatatype type = eNodeSocketDatatype(typeinfo->type);
@ -1584,14 +1585,15 @@ static void node_socket_virtual_draw_color(bContext * /*C*/,
copy_v4_v4(r_color, virtual_node_socket_color);
}
static void node_socket_virtual_draw_color_simple(const bNodeSocketType * /*type*/, float *r_color)
static void node_socket_virtual_draw_color_simple(const bke::bNodeSocketType * /*type*/,
float *r_color)
{
copy_v4_v4(r_color, virtual_node_socket_color);
}
} // namespace blender::ed::space_node
void ED_init_standard_node_socket_type(bNodeSocketType *stype)
void ED_init_standard_node_socket_type(blender::bke::bNodeSocketType *stype)
{
using namespace blender::ed::space_node;
stype->draw = std_node_socket_draw;
@ -1600,7 +1602,7 @@ void ED_init_standard_node_socket_type(bNodeSocketType *stype)
stype->interface_draw = std_node_socket_interface_draw;
}
void ED_init_node_socket_type_virtual(bNodeSocketType *stype)
void ED_init_node_socket_type_virtual(blender::bke::bNodeSocketType *stype)
{
using namespace blender::ed::space_node;
stype->draw = node_socket_button_label;
@ -1612,7 +1614,7 @@ void ED_node_type_draw_color(const char *idname, float *r_color)
{
using namespace blender::ed::space_node;
const bNodeSocketType *typeinfo = nodeSocketTypeFind(idname);
const blender::bke::bNodeSocketType *typeinfo = blender::bke::nodeSocketTypeFind(idname);
if (!typeinfo || typeinfo->type == SOCK_CUSTOM) {
r_color[0] = 0.0f;
r_color[1] = 0.0f;
@ -1636,7 +1638,7 @@ void draw_nodespace_back_pix(const bContext &C,
{
Main *bmain = CTX_data_main(&C);
bNodeInstanceKey active_viewer_key = (snode.nodetree ? snode.nodetree->active_viewer_key :
NODE_INSTANCE_KEY_NONE);
bke::NODE_INSTANCE_KEY_NONE);
GPU_matrix_push_projection();
GPU_matrix_push();
wmOrtho2_region_pixelspace(&region);

44
source/blender/editors/space_node/link_drag_search.cc
View file

@ -69,18 +69,18 @@ static void add_reroute_node_fn(nodes::LinkSearchOpParams &params)
{
bNode &reroute = params.add_node("NodeReroute");
if (params.socket.in_out == SOCK_IN) {
nodeAddLink(&params.node_tree,
&reroute,
static_cast<bNodeSocket *>(reroute.outputs.first),
&params.node,
&params.socket);
bke::nodeAddLink(&params.node_tree,
&reroute,
static_cast<bNodeSocket *>(reroute.outputs.first),
&params.node,
&params.socket);
}
else {
nodeAddLink(&params.node_tree,
&params.node,
&params.socket,
&reroute,
static_cast<bNodeSocket *>(reroute.inputs.first));
bke::nodeAddLink(&params.node_tree,
&params.node,
&params.socket,
&reroute,
static_cast<bNodeSocket *>(reroute.inputs.first));
}
}
@ -104,7 +104,7 @@ static void add_group_input_node_fn(nodes::LinkSearchOpParams &params)
/* Hide the new input in all other group input nodes, to avoid making them taller. */
for (bNode *node : params.node_tree.all_nodes()) {
if (node->type == NODE_GROUP_INPUT) {
bNodeSocket *new_group_input_socket = nodeFindSocket(
bNodeSocket *new_group_input_socket = bke::nodeFindSocket(
node, SOCK_OUT, socket_iface->identifier);
if (new_group_input_socket) {
new_group_input_socket->flag |= SOCK_HIDDEN;
@ -117,11 +117,11 @@ static void add_group_input_node_fn(nodes::LinkSearchOpParams &params)
socket->flag |= SOCK_HIDDEN;
}
bNodeSocket *socket = nodeFindSocket(&group_input, SOCK_OUT, socket_iface->identifier);
bNodeSocket *socket = bke::nodeFindSocket(&group_input, SOCK_OUT, socket_iface->identifier);
if (socket) {
/* Unhide the socket for the new input in the new node and make a connection to it. */
socket->flag &= ~SOCK_HIDDEN;
nodeAddLink(&params.node_tree, &group_input, socket, &params.node, &params.socket);
bke::nodeAddLink(&params.node_tree, &group_input, socket, &params.node, &params.socket);
bke::node_socket_move_default_value(
*CTX_data_main(&params.C), params.node_tree, params.socket, *socket);
@ -142,10 +142,10 @@ static void add_existing_group_input_fn(nodes::LinkSearchOpParams &params,
socket->flag |= SOCK_HIDDEN;
}
bNodeSocket *socket = nodeFindSocket(&group_input, SOCK_OUT, interface_socket.identifier);
bNodeSocket *socket = bke::nodeFindSocket(&group_input, SOCK_OUT, interface_socket.identifier);
if (socket != nullptr) {
socket->flag &= ~SOCK_HIDDEN;
nodeAddLink(&params.node_tree, &group_input, socket, &params.node, &params.socket);
bke::nodeAddLink(&params.node_tree, &group_input, socket, &params.node, &params.socket);
}
}
@ -165,7 +165,7 @@ static void search_link_ops_for_asset_metadata(const bNodeTree &node_tree,
return;
}
const bNodeTreeType &node_tree_type = *node_tree.typeinfo;
const bke::bNodeTreeType &node_tree_type = *node_tree.typeinfo;
const eNodeSocketInOut in_out = socket.in_out == SOCK_OUT ? SOCK_IN : SOCK_OUT;
const IDProperty *sockets = BKE_asset_metadata_idprop_find(
@ -178,7 +178,7 @@ static void search_link_ops_for_asset_metadata(const bNodeTree &node_tree,
continue;
}
const char *socket_idname = IDP_String(socket_property);
const bNodeSocketType *socket_type = nodeSocketTypeFind(socket_idname);
const bke::bNodeSocketType *socket_type = bke::nodeSocketTypeFind(socket_idname);
if (socket_type == nullptr) {
continue;
}
@ -218,7 +218,8 @@ static void search_link_ops_for_asset_metadata(const bNodeTree &node_tree,
node, in_out, socket_property->name);
if (new_node_socket != nullptr) {
/* Rely on the way #nodeAddLink switches in/out if necessary. */
nodeAddLink(&params.node_tree, &params.node, &params.socket, &node, new_node_socket);
bke::nodeAddLink(
&params.node_tree, &params.node, &params.socket, &node, new_node_socket);
}
},
weight});
@ -291,7 +292,8 @@ static void gather_socket_link_operations(const bContext &C,
const bNodeTreeInterfaceSocket &interface_socket =
reinterpret_cast<const bNodeTreeInterfaceSocket &>(item);
{
const bNodeSocketType *from_typeinfo = nodeSocketTypeFind(interface_socket.socket_type);
const bke::bNodeSocketType *from_typeinfo = bke::nodeSocketTypeFind(
interface_socket.socket_type);
const eNodeSocketDatatype from = from_typeinfo ? eNodeSocketDatatype(from_typeinfo->type) :
SOCK_CUSTOM;
const eNodeSocketDatatype to = eNodeSocketDatatype(socket.typeinfo->type);
@ -374,8 +376,8 @@ static void link_drag_search_exec_fn(bContext *C, void *arg1, void *arg2)
new_node->locx -= new_node->width;
}
nodeSetSelected(new_node, true);
nodeSetActive(&node_tree, new_node);
bke::nodeSetSelected(new_node, true);
bke::nodeSetActive(&node_tree, new_node);
/* Ideally it would be possible to tag the node tree in some way so it updates only after the
* translate operation is finished, but normally moving nodes around doesn't cause updates. */

46
source/blender/editors/space_node/node_add.cc
View file

@ -78,12 +78,12 @@ bNode *add_node(const bContext &C, const StringRef idname, const float2 &locatio
const std::string idname_str = idname;
bNode *node = nodeAddNode(&C, &node_tree, idname_str.c_str());
bNode *node = bke::nodeAddNode(&C, &node_tree, idname_str.c_str());
BLI_assert(node && node->typeinfo);
position_node_based_on_mouse(*node, location);
nodeSetSelected(node, true);
bke::nodeSetSelected(node, true);
ED_node_set_active(&bmain, &snode, &node_tree, node, nullptr);
ED_node_tree_propagate_change(&C, &bmain, &node_tree);
@ -98,12 +98,12 @@ bNode *add_static_node(const bContext &C, int type, const float2 &location)
node_deselect_all(node_tree);
bNode *node = nodeAddStaticNode(&C, &node_tree, type);
bNode *node = bke::nodeAddStaticNode(&C, &node_tree, type);
BLI_assert(node && node->typeinfo);
position_node_based_on_mouse(*node, location);
nodeSetSelected(node, true);
bke::nodeSetSelected(node, true);
ED_node_set_active(&bmain, &snode, &node_tree, node, nullptr);
ED_node_tree_propagate_change(&C, &bmain, &node_tree);
@ -191,13 +191,13 @@ static int add_reroute_exec(bContext *C, wmOperator *op)
for (const auto item : cuts_per_socket.items()) {
const Map<bNodeLink *, float2> &cuts = item.value.links;
bNode *reroute = nodeAddStaticNode(C, &ntree, NODE_REROUTE);
bNode *reroute = bke::nodeAddStaticNode(C, &ntree, NODE_REROUTE);
nodeAddLink(&ntree,
item.value.from_node,
item.key,
reroute,
static_cast<bNodeSocket *>(reroute->inputs.first));
bke::nodeAddLink(&ntree,
item.value.from_node,
item.key,
reroute,
static_cast<bNodeSocket *>(reroute->inputs.first));
/* Reconnect links from the original output socket to the new reroute. */
for (bNodeLink *link : cuts.keys()) {
@ -217,7 +217,7 @@ static int add_reroute_exec(bContext *C, wmOperator *op)
for (const int i : frame_nodes.index_range()) {
bNode *frame_node = frame_nodes.last(i);
if (BLI_rctf_isect_pt_v(&frame_node->runtime->totr, insert_point)) {
nodeAttachNode(&ntree, reroute, frame_node);
bke::nodeAttachNode(&ntree, reroute, frame_node);
break;
}
}
@ -266,7 +266,7 @@ static bool node_group_add_poll(const bNodeTree &node_tree,
}
const char *disabled_hint = nullptr;
if (!nodeGroupPoll(&node_tree, &node_group, &disabled_hint)) {
if (!bke::nodeGroupPoll(&node_tree, &node_group, &disabled_hint)) {
if (disabled_hint) {
BKE_reportf(&reports,
RPT_ERROR,
@ -327,7 +327,7 @@ static int node_add_group_exec(bContext *C, wmOperator *op)
id_us_plus(group_node->id);
BKE_ntree_update_tag_node_property(snode->edittree, group_node);
nodeSetActive(ntree, group_node);
bke::nodeSetActive(ntree, group_node);
ED_node_tree_propagate_change(C, bmain, nullptr);
WM_event_add_notifier(C, NC_NODE | NA_ADDED, nullptr);
DEG_relations_tag_update(bmain);
@ -417,7 +417,7 @@ static bool add_node_group_asset(const bContext &C,
ED_preview_kill_jobs(CTX_wm_manager(&C), CTX_data_main(&C));
bNode *group_node = add_node(
C, ntreeTypeFind(node_group->idname)->group_idname, snode.runtime->cursor);
C, bke::ntreeTypeFind(node_group->idname)->group_idname, snode.runtime->cursor);
if (!group_node) {
BKE_report(&reports, RPT_WARNING, "Could not add node group");
return false;
@ -429,7 +429,7 @@ static bool add_node_group_asset(const bContext &C,
id_us_plus(group_node->id);
BKE_ntree_update_tag_node_property(&edit_tree, group_node);
nodeSetActive(&edit_tree, group_node);
bke::nodeSetActive(&edit_tree, group_node);
ED_node_tree_propagate_change(&C, &bmain, nullptr);
WM_event_add_notifier(&C, NC_NODE | NA_ADDED, nullptr);
DEG_relations_tag_update(&bmain);
@ -529,7 +529,7 @@ static int node_add_object_exec(bContext *C, wmOperator *op)
return OPERATOR_CANCELLED;
}
bNodeSocket *sock = nodeFindSocket(object_node, SOCK_IN, "Object");
bNodeSocket *sock = bke::nodeFindSocket(object_node, SOCK_IN, "Object");
if (!sock) {
BLI_assert_unreachable();
return OPERATOR_CANCELLED;
@ -539,7 +539,7 @@ static int node_add_object_exec(bContext *C, wmOperator *op)
socket_data->value = object;
id_us_plus(&object->id);
nodeSetActive(ntree, object_node);
bke::nodeSetActive(ntree, object_node);
ED_node_tree_propagate_change(C, bmain, ntree);
DEG_relations_tag_update(bmain);
@ -615,7 +615,7 @@ static int node_add_collection_exec(bContext *C, wmOperator *op)
return OPERATOR_CANCELLED;
}
bNodeSocket *sock = nodeFindSocket(collection_node, SOCK_IN, "Collection");
bNodeSocket *sock = bke::nodeFindSocket(collection_node, SOCK_IN, "Collection");
if (!sock) {
BKE_report(op->reports, RPT_WARNING, "Could not find node collection socket");
return OPERATOR_CANCELLED;
@ -625,7 +625,7 @@ static int node_add_collection_exec(bContext *C, wmOperator *op)
socket_data->value = collection;
id_us_plus(&collection->id);
nodeSetActive(&ntree, collection_node);
bke::nodeSetActive(&ntree, collection_node);
ED_node_tree_propagate_change(C, bmain, &ntree);
DEG_relations_tag_update(bmain);
@ -810,7 +810,7 @@ static int node_add_file_exec(bContext *C, wmOperator *op)
bNodeTree &node_tree = *snode.edittree;
node_deselect_all(node_tree);
for (bNode *node : nodes) {
nodeSetSelected(node, true);
bke::nodeSetSelected(node, true);
}
ED_node_set_active(bmain, &snode, &node_tree, nodes[0], nullptr);
@ -1047,7 +1047,7 @@ static int new_node_tree_exec(bContext *C, wmOperator *op)
return OPERATOR_CANCELLED;
}
if (!ntreeTypeFind(idname)) {
if (!bke::ntreeTypeFind(idname)) {
BKE_reportf(op->reports, RPT_ERROR, "Node tree type %s undefined", idname);
return OPERATOR_CANCELLED;
}
@ -1057,11 +1057,11 @@ static int new_node_tree_exec(bContext *C, wmOperator *op)
treename = treename_buf;
}
else {
const bNodeTreeType *type = ntreeTypeFind(idname);
const bke::bNodeTreeType *type = bke::ntreeTypeFind(idname);
treename = type->ui_name;
}
ntree = ntreeAddTree(bmain, treename, idname);
ntree = bke::ntreeAddTree(bmain, treename, idname);
/* Hook into UI. */
UI_context_active_but_prop_get_templateID(C, &ptr, &prop);

20
source/blender/editors/space_node/node_draw.cc
View file

@ -161,7 +161,7 @@ static bNodeTree *node_tree_from_ID(ID *id)
if (GS(id->name) == ID_NT) {
return (bNodeTree *)id;
}
return ntreeFromID(id);
return blender::bke::ntreeFromID(id);
}
return nullptr;
@ -1129,7 +1129,7 @@ static void node_draw_mute_line(const bContext &C,
GPU_blend(GPU_BLEND_ALPHA);
for (const bNodeLink &link : node.internal_links()) {
if (!nodeLinkIsHidden(&link)) {
if (!bke::nodeLinkIsHidden(&link)) {
node_draw_link_bezier(C, v2d, snode, link, TH_WIRE_INNER, TH_WIRE_INNER, TH_WIRE, false);
}
}
@ -2747,7 +2747,7 @@ static bNodeInstanceKey current_node_instance_key(const SpaceNode &snode, const
/* Assume that the currently editing tree is the last in the path. */
BLI_assert(snode.edittree == path->nodetree);
return BKE_node_instance_key(path->parent_key, snode.edittree, &node);
return bke::BKE_node_instance_key(path->parent_key, snode.edittree, &node);
}
static std::optional<std::chrono::nanoseconds> compositor_accumulate_frame_node_execution_time(
@ -3261,7 +3261,7 @@ static void node_draw_basis(const bContext &C,
bool drawn_with_previews = false;
if (show_preview) {
bNodeInstanceHash *previews_compo = static_cast<bNodeInstanceHash *>(
bke::bNodeInstanceHash *previews_compo = static_cast<bke::bNodeInstanceHash *>(
CTX_data_pointer_get(&C, "node_previews").data);
NestedTreePreviews *previews_shader = tree_draw_ctx.nested_group_infos;
@ -3273,7 +3273,7 @@ static void node_draw_basis(const bContext &C,
}
else if (previews_compo) {
bNodePreview *preview_compositor = static_cast<bNodePreview *>(
BKE_node_instance_hash_lookup(previews_compo, key));
bke::BKE_node_instance_hash_lookup(previews_compo, key));
if (preview_compositor) {
node_draw_extra_info_panel(
C, tree_draw_ctx, snode, node, preview_compositor->ibuf, block);
@ -4373,7 +4373,7 @@ static void node_draw_nodetree(const bContext &C,
continue;
}
const bNodeInstanceKey key = BKE_node_instance_key(parent_key, &ntree, nodes[i]);
const bNodeInstanceKey key = bke::BKE_node_instance_key(parent_key, &ntree, nodes[i]);
node_draw(C, tree_draw_ctx, region, snode, ntree, *nodes[i], *blocks[i], key);
}
@ -4382,14 +4382,14 @@ static void node_draw_nodetree(const bContext &C,
nodelink_batch_start(snode);
for (const bNodeLink *link : ntree.all_links()) {
if (!nodeLinkIsHidden(link) && !bke::nodeLinkIsSelected(link)) {
if (!bke::nodeLinkIsHidden(link) && !bke::nodeLinkIsSelected(link)) {
node_draw_link(C, region.v2d, snode, *link, false);
}
}
/* Draw selected node links after the unselected ones, so they are shown on top. */
for (const bNodeLink *link : ntree.all_links()) {
if (!nodeLinkIsHidden(link) && bke::nodeLinkIsSelected(link)) {
if (!bke::nodeLinkIsHidden(link) && bke::nodeLinkIsSelected(link)) {
node_draw_link(C, region.v2d, snode, *link, true);
}
}
@ -4403,7 +4403,7 @@ static void node_draw_nodetree(const bContext &C,
continue;
}
const bNodeInstanceKey key = BKE_node_instance_key(parent_key, &ntree, nodes[i]);
const bNodeInstanceKey key = bke::BKE_node_instance_key(parent_key, &ntree, nodes[i]);
node_draw(C, tree_draw_ctx, region, snode, ntree, *nodes[i], *blocks[i], key);
}
}
@ -4658,7 +4658,7 @@ void node_draw_space(const bContext &C, ARegion &region)
else {
/* Backdrop. */
draw_nodespace_back_pix(C, region, snode, NODE_INSTANCE_KEY_NONE);
draw_nodespace_back_pix(C, region, snode, bke::NODE_INSTANCE_KEY_NONE);
}
ED_region_draw_cb_draw(&C, &region, REGION_DRAW_POST_VIEW);

100
source/blender/editors/space_node/node_edit.cc
View file

@ -246,7 +246,7 @@ static void compo_initjob(void *cjv)
bNodeTree *ntree_eval = (bNodeTree *)DEG_get_evaluated_id(cj->compositor_depsgraph,
&cj->ntree->id);
cj->localtree = ntreeLocalize(ntree_eval, nullptr);
cj->localtree = bke::ntreeLocalize(ntree_eval, nullptr);
if (cj->recalc_flags) {
compo_tag_output_nodes(cj->localtree, cj->recalc_flags);
@ -507,7 +507,7 @@ void ED_node_tree_propagate_change(const bContext *C, Main *bmain, bNodeTree *ro
BKE_ntree_update_main_tree(bmain, root_ntree, &params);
}
void ED_node_set_tree_type(SpaceNode *snode, bNodeTreeType *typeinfo)
void ED_node_set_tree_type(SpaceNode *snode, blender::bke::bNodeTreeType *typeinfo)
{
if (typeinfo) {
STRNCPY(snode->tree_idname, typeinfo->idname);
@ -564,7 +564,7 @@ void ED_node_shader_default(const bContext *C, ID *id)
ma->nodetree->owner_id = &ma->id;
for (bNode *node_iter : ma->nodetree->all_nodes()) {
STRNCPY_UTF8(node_iter->name, DATA_(node_iter->name));
nodeUniqueName(ma->nodetree, node_iter);
blender::bke::nodeUniqueName(ma->nodetree, node_iter);
}
BKE_ntree_update_main_tree(bmain, ma->nodetree, nullptr);
@ -578,32 +578,32 @@ void ED_node_shader_default(const bContext *C, ID *id)
if (GS(id->name) == ID_WO) {
World *world = (World *)id;
shader = nodeAddStaticNode(nullptr, ntree, SH_NODE_BACKGROUND);
output = nodeAddStaticNode(nullptr, ntree, SH_NODE_OUTPUT_WORLD);
nodeAddLink(ntree,
shader,
nodeFindSocket(shader, SOCK_OUT, "Background"),
output,
nodeFindSocket(output, SOCK_IN, "Surface"));
shader = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_BACKGROUND);
output = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_OUTPUT_WORLD);
blender::bke::nodeAddLink(ntree,
shader,
blender::bke::nodeFindSocket(shader, SOCK_OUT, "Background"),
output,
blender::bke::nodeFindSocket(output, SOCK_IN, "Surface"));
bNodeSocket *color_sock = nodeFindSocket(shader, SOCK_IN, "Color");
bNodeSocket *color_sock = blender::bke::nodeFindSocket(shader, SOCK_IN, "Color");
copy_v3_v3(((bNodeSocketValueRGBA *)color_sock->default_value)->value, &world->horr);
}
else {
shader = nodeAddStaticNode(nullptr, ntree, SH_NODE_EMISSION);
output = nodeAddStaticNode(nullptr, ntree, SH_NODE_OUTPUT_LIGHT);
nodeAddLink(ntree,
shader,
nodeFindSocket(shader, SOCK_OUT, "Emission"),
output,
nodeFindSocket(output, SOCK_IN, "Surface"));
shader = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_EMISSION);
output = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_OUTPUT_LIGHT);
blender::bke::nodeAddLink(ntree,
shader,
blender::bke::nodeFindSocket(shader, SOCK_OUT, "Emission"),
output,
blender::bke::nodeFindSocket(output, SOCK_IN, "Surface"));
}
shader->locx = 10.0f;
shader->locy = 300.0f;
output->locx = 300.0f;
output->locy = 300.0f;
nodeSetActive(ntree, output);
blender::bke::nodeSetActive(ntree, output);
BKE_ntree_update_main_tree(bmain, ntree, nullptr);
}
else {
@ -625,19 +625,19 @@ void ED_node_composit_default(const bContext *C, Scene *sce)
sce->nodetree = blender::bke::ntreeAddTreeEmbedded(
nullptr, &sce->id, "Compositing Nodetree", ntreeType_Composite->idname);
bNode *out = nodeAddStaticNode(C, sce->nodetree, CMP_NODE_COMPOSITE);
bNode *out = blender::bke::nodeAddStaticNode(C, sce->nodetree, CMP_NODE_COMPOSITE);
out->locx = 200.0f;
out->locy = 200.0f;
bNode *in = nodeAddStaticNode(C, sce->nodetree, CMP_NODE_R_LAYERS);
bNode *in = blender::bke::nodeAddStaticNode(C, sce->nodetree, CMP_NODE_R_LAYERS);
in->locx = -200.0f;
in->locy = 200.0f;
nodeSetActive(sce->nodetree, in);
blender::bke::nodeSetActive(sce->nodetree, in);
/* Links from color to color. */
bNodeSocket *fromsock = (bNodeSocket *)in->outputs.first;
bNodeSocket *tosock = (bNodeSocket *)out->inputs.first;
nodeAddLink(sce->nodetree, in, fromsock, out, tosock);
blender::bke::nodeAddLink(sce->nodetree, in, fromsock, out, tosock);
BKE_ntree_update_main_tree(CTX_data_main(C), sce->nodetree, nullptr);
}
@ -654,18 +654,18 @@ void ED_node_texture_default(const bContext *C, Tex *tex)
tex->nodetree = blender::bke::ntreeAddTreeEmbedded(
nullptr, &tex->id, "Texture Nodetree", ntreeType_Texture->idname);
bNode *out = nodeAddStaticNode(C, tex->nodetree, TEX_NODE_OUTPUT);
bNode *out = blender::bke::nodeAddStaticNode(C, tex->nodetree, TEX_NODE_OUTPUT);
out->locx = 300.0f;
out->locy = 300.0f;
bNode *in = nodeAddStaticNode(C, tex->nodetree, TEX_NODE_CHECKER);
bNode *in = blender::bke::nodeAddStaticNode(C, tex->nodetree, TEX_NODE_CHECKER);
in->locx = 10.0f;
in->locy = 300.0f;
nodeSetActive(tex->nodetree, in);
blender::bke::nodeSetActive(tex->nodetree, in);
bNodeSocket *fromsock = (bNodeSocket *)in->outputs.first;
bNodeSocket *tosock = (bNodeSocket *)out->inputs.first;
nodeAddLink(tex->nodetree, in, fromsock, out, tosock);
blender::bke::nodeAddLink(tex->nodetree, in, fromsock, out, tosock);
BKE_ntree_update_main_tree(CTX_data_main(C), tex->nodetree, nullptr);
}
@ -678,7 +678,7 @@ namespace blender::ed::space_node {
void snode_set_context(const bContext &C)
{
SpaceNode *snode = CTX_wm_space_node(&C);
bNodeTreeType *treetype = ntreeTypeFind(snode->tree_idname);
bke::bNodeTreeType *treetype = bke::ntreeTypeFind(snode->tree_idname);
bNodeTree *ntree = snode->nodetree;
ID *id = snode->id, *from = snode->from;
@ -725,7 +725,7 @@ void ED_node_set_active(
*r_active_texture_changed = false;
}
nodeSetActive(ntree, node);
blender::bke::nodeSetActive(ntree, node);
if (node->type == NODE_GROUP) {
return;
}
@ -771,7 +771,8 @@ void ED_node_set_active(
if ((node->flag & NODE_ACTIVE_TEXTURE) && !was_active_texture) {
/* If active texture changed, free GLSL materials. */
LISTBASE_FOREACH (Material *, ma, &bmain->materials) {
if (ma->nodetree && ma->use_nodes && ntreeContainsTree(ma->nodetree, ntree)) {
if (ma->nodetree && ma->use_nodes && blender::bke::ntreeContainsTree(ma->nodetree, ntree))
{
GPU_material_free(&ma->gpumaterial);
/* Sync to active texpaint slot, otherwise we can end up painting on a different slot
@ -790,7 +791,8 @@ void ED_node_set_active(
}
LISTBASE_FOREACH (World *, wo, &bmain->worlds) {
if (wo->nodetree && wo->use_nodes && ntreeContainsTree(wo->nodetree, ntree)) {
if (wo->nodetree && wo->use_nodes && blender::bke::ntreeContainsTree(wo->nodetree, ntree))
{
GPU_material_free(&wo->gpumaterial);
}
}
@ -944,7 +946,7 @@ static void node_resize_exit(bContext *C, wmOperator *op, bool cancel)
/* Restore old data on cancel. */
if (cancel) {
SpaceNode *snode = CTX_wm_space_node(C);
bNode *node = nodeGetActive(snode->edittree);
bNode *node = bke::nodeGetActive(snode->edittree);
NodeSizeWidget *nsw = (NodeSizeWidget *)op->customdata;
node->locx = nsw->oldlocx;
@ -963,7 +965,7 @@ static int node_resize_modal(bContext *C, wmOperator *op, const wmEvent *event)
{
SpaceNode *snode = CTX_wm_space_node(C);
ARegion *region = CTX_wm_region(C);
bNode *node = nodeGetActive(snode->edittree);
bNode *node = bke::nodeGetActive(snode->edittree);
NodeSizeWidget *nsw = (NodeSizeWidget *)op->customdata;
switch (event->type) {
@ -1067,7 +1069,7 @@ static int node_resize_invoke(bContext *C, wmOperator *op, const wmEvent *event)
{
SpaceNode *snode = CTX_wm_space_node(C);
ARegion *region = CTX_wm_region(C);
const bNode *node = nodeGetActive(snode->edittree);
const bNode *node = bke::nodeGetActive(snode->edittree);
if (node == nullptr) {
return OPERATOR_CANCELLED | OPERATOR_PASS_THROUGH;
@ -1300,7 +1302,7 @@ float node_link_dim_factor(const View2D &v2d, const bNodeLink &link)
bool node_link_is_hidden_or_dimmed(const View2D &v2d, const bNodeLink &link)
{
return nodeLinkIsHidden(&link) || node_link_dim_factor(v2d, link) < 0.5f;
return bke::nodeLinkIsHidden(&link) || node_link_dim_factor(v2d, link) < 0.5f;
}
/** \} */
@ -1328,8 +1330,8 @@ static void node_duplicate_reparent_recursive(bNodeTree *ntree,
}
/* Reparent node copy to parent copy. */
if (parent) {
nodeDetachNode(ntree, node_map.lookup(node));
nodeAttachNode(ntree, node_map.lookup(node), node_map.lookup(parent));
bke::nodeDetachNode(ntree, node_map.lookup(node));
bke::nodeAttachNode(ntree, node_map.lookup(node), node_map.lookup(parent));
}
}
@ -1461,9 +1463,9 @@ static int node_duplicate_exec(bContext *C, wmOperator *op)
bNode *src_node = item.key;
bNode *dst_node = item.value;
nodeSetSelected(src_node, false);
bke::nodeSetSelected(src_node, false);
src_node->flag &= ~(NODE_ACTIVE | NODE_ACTIVE_TEXTURE);
nodeSetSelected(dst_node, true);
bke::nodeSetSelected(dst_node, true);
}
tree_draw_order_update(*snode->edittree);
@ -1907,7 +1909,7 @@ static int node_delete_exec(bContext *C, wmOperator * /*op*/)
LISTBASE_FOREACH_MUTABLE (bNode *, node, &snode->edittree->nodes) {
if (node->flag & SELECT) {
nodeRemoveNode(bmain, snode->edittree, node, true);
bke::nodeRemoveNode(bmain, snode->edittree, node, true);
}
}
@ -1998,7 +2000,7 @@ static int node_delete_reconnect_exec(bContext *C, wmOperator * /*op*/)
LISTBASE_FOREACH_MUTABLE (bNode *, node, &snode->edittree->nodes) {
if (node->flag & SELECT) {
blender::bke::nodeInternalRelink(snode->edittree, node);
nodeRemoveNode(bmain, snode->edittree, node, true);
bke::nodeRemoveNode(bmain, snode->edittree, node, true);
}
}
@ -2043,7 +2045,7 @@ static int node_output_file_add_socket_exec(bContext *C, wmOperator *op)
}
else if (snode && snode->edittree) {
ntree = snode->edittree;
node = nodeGetActive(snode->edittree);
node = bke::nodeGetActive(snode->edittree);
}
if (!node || node->type != CMP_NODE_OUTPUT_FILE) {
@ -2095,7 +2097,7 @@ static int node_output_file_remove_active_socket_exec(bContext *C, wmOperator *
}
else if (snode && snode->edittree) {
ntree = snode->edittree;
node = nodeGetActive(snode->edittree);
node = bke::nodeGetActive(snode->edittree);
}
if (!node || node->type != CMP_NODE_OUTPUT_FILE) {
@ -2142,7 +2144,7 @@ static int node_output_file_move_active_socket_exec(bContext *C, wmOperator *op)
node = (bNode *)ptr.data;
}
else if (snode && snode->edittree) {
node = nodeGetActive(snode->edittree);
node = bke::nodeGetActive(snode->edittree);
}
if (!node || node->type != CMP_NODE_OUTPUT_FILE) {
@ -2214,7 +2216,7 @@ static int node_copy_color_exec(bContext *C, wmOperator * /*op*/)
SpaceNode &snode = *CTX_wm_space_node(C);
bNodeTree &ntree = *snode.edittree;
bNode *active_node = nodeGetActive(&ntree);
bNode *active_node = bke::nodeGetActive(&ntree);
if (!active_node) {
return OPERATOR_CANCELLED;
}
@ -2272,7 +2274,7 @@ static bool node_shader_script_update_poll(bContext *C)
bNode *node = (bNode *)CTX_data_pointer_get_type(C, "node", &RNA_ShaderNodeScript).data;
if (!node && snode && snode->edittree) {
node = nodeGetActive(snode->edittree);
node = bke::nodeGetActive(snode->edittree);
}
if (node && node->type == SH_NODE_SCRIPT) {
@ -2343,7 +2345,7 @@ static int node_shader_script_update_exec(bContext *C, wmOperator *op)
}
else if (snode && snode->edittree) {
ntree_base = snode->edittree;
node = nodeGetActive(snode->edittree);
node = bke::nodeGetActive(snode->edittree);
}
if (node) {
@ -2541,7 +2543,7 @@ static int node_cryptomatte_add_socket_exec(bContext *C, wmOperator * /*op*/)
}
else if (snode && snode->edittree) {
ntree = snode->edittree;
node = nodeGetActive(snode->edittree);
node = bke::nodeGetActive(snode->edittree);
}
if (!node || node->type != CMP_NODE_CRYPTOMATTE_LEGACY) {
@ -2589,7 +2591,7 @@ static int node_cryptomatte_remove_socket_exec(bContext *C, wmOperator * /*op*/)
}
else if (snode && snode->edittree) {
ntree = snode->edittree;
node = nodeGetActive(snode->edittree);
node = bke::nodeGetActive(snode->edittree);
}
if (!node || node->type != CMP_NODE_CRYPTOMATTE_LEGACY) {

14
source/blender/editors/space_node/node_gizmo.cc
View file

@ -102,7 +102,7 @@ static bool WIDGETGROUP_node_transform_poll(const bContext *C, wmGizmoGroupType
}
if (snode && snode->edittree && snode->edittree->type == NTREE_COMPOSIT) {
bNode *node = nodeGetActive(snode->edittree);
bNode *node = bke::nodeGetActive(snode->edittree);
if (node && ELEM(node->type, CMP_NODE_VIEWER)) {
return true;
@ -305,7 +305,7 @@ static bool WIDGETGROUP_node_crop_poll(const bContext *C, wmGizmoGroupType * /*g
}
if (snode && snode->edittree && snode->edittree->type == NTREE_COMPOSIT) {
bNode *node = nodeGetActive(snode->edittree);
bNode *node = bke::nodeGetActive(snode->edittree);
if (node && ELEM(node->type, CMP_NODE_CROP)) {
/* ignore 'use_crop_size', we can't usefully edit the crop in this case. */
@ -358,7 +358,7 @@ static void WIDGETGROUP_node_crop_refresh(const bContext *C, wmGizmoGroup *gzgro
WM_gizmo_set_flag(gz, WM_GIZMO_HIDDEN, false);
SpaceNode *snode = CTX_wm_space_node(C);
bNode *node = nodeGetActive(snode->edittree);
bNode *node = bke::nodeGetActive(snode->edittree);
crop_group->update_data.context = (bContext *)C;
crop_group->update_data.ptr = RNA_pointer_create(
@ -418,7 +418,7 @@ static bool WIDGETGROUP_node_sbeam_poll(const bContext *C, wmGizmoGroupType * /*
}
if (snode && snode->edittree && snode->edittree->type == NTREE_COMPOSIT) {
bNode *node = nodeGetActive(snode->edittree);
bNode *node = bke::nodeGetActive(snode->edittree);
if (node && ELEM(node->type, CMP_NODE_SUNBEAMS)) {
return true;
@ -471,7 +471,7 @@ static void WIDGETGROUP_node_sbeam_refresh(const bContext *C, wmGizmoGroup *gzgr
copy_v2_v2(sbeam_group->state.offset, ima->runtime.backdrop_offset);
SpaceNode *snode = CTX_wm_space_node(C);
bNode *node = nodeGetActive(snode->edittree);
bNode *node = bke::nodeGetActive(snode->edittree);
/* Need to set property here for undo. TODO: would prefer to do this in _init. */
PointerRNA nodeptr = RNA_pointer_create(
@ -525,7 +525,7 @@ static bool WIDGETGROUP_node_corner_pin_poll(const bContext *C, wmGizmoGroupType
}
if (snode && snode->edittree && snode->edittree->type == NTREE_COMPOSIT) {
bNode *node = nodeGetActive(snode->edittree);
bNode *node = bke::nodeGetActive(snode->edittree);
if (node && ELEM(node->type, CMP_NODE_CORNERPIN)) {
return true;
@ -585,7 +585,7 @@ static void WIDGETGROUP_node_corner_pin_refresh(const bContext *C, wmGizmoGroup
copy_v2_v2(cpin_group->state.offset, ima->runtime.backdrop_offset);
SpaceNode *snode = CTX_wm_space_node(C);
bNode *node = nodeGetActive(snode->edittree);
bNode *node = bke::nodeGetActive(snode->edittree);
/* need to set property here for undo. TODO: would prefer to do this in _init. */
int i = 0;

71
source/blender/editors/space_node/node_group.cc
View file

@ -132,7 +132,7 @@ const char *node_group_idname(bContext *C)
static bNode *node_group_get_active(bContext *C, const char *node_idname)
{
SpaceNode *snode = CTX_wm_space_node(C);
bNode *node = nodeGetActive(snode->edittree);
bNode *node = bke::nodeGetActive(snode->edittree);
if (node && STREQ(node->idname, node_idname)) {
return node;
@ -305,8 +305,8 @@ static void node_group_ungroup(Main *bmain, bNodeTree *ntree, bNode *gnode)
BLI_remlink(&wgroup->nodes, node);
BLI_addtail(&ntree->nodes, node);
const int32_t old_identifier = node->identifier;
nodeUniqueID(ntree, node);
nodeUniqueName(ntree, node);
bke::nodeUniqueID(ntree, node);
bke::nodeUniqueName(ntree, node);
node_identifier_map.add(old_identifier, node->identifier);
BKE_ntree_update_tag_node_new(ntree, node);
@ -381,7 +381,7 @@ static void node_group_ungroup(Main *bmain, bNodeTree *ntree, bNode *gnode)
tlink = tlink->next)
{
if (tlink->tonode == gnode && STREQ(tlink->tosock->identifier, identifier)) {
nodeAddLink(ntree, tlink->fromnode, tlink->fromsock, link->tonode, link->tosock);
bke::nodeAddLink(ntree, tlink->fromnode, tlink->fromsock, link->tonode, link->tosock);
num_external_links++;
}
}
@ -419,7 +419,8 @@ static void node_group_ungroup(Main *bmain, bNodeTree *ntree, bNode *gnode)
/* only use active output node */
if (tlink->tonode->type == NODE_GROUP_OUTPUT && (tlink->tonode->flag & NODE_DO_OUTPUT)) {
if (STREQ(tlink->tosock->identifier, identifier)) {
nodeAddLink(ntree, tlink->fromnode, tlink->fromsock, link->tonode, link->tosock);
bke::nodeAddLink(
ntree, tlink->fromnode, tlink->fromsock, link->tonode, link->tosock);
num_internal_links++;
}
}
@ -441,13 +442,13 @@ static void node_group_ungroup(Main *bmain, bNodeTree *ntree, bNode *gnode)
}
for (bNode *node : nodes_delayed_free) {
nodeRemoveNode(bmain, ntree, node, false);
bke::nodeRemoveNode(bmain, ntree, node, false);
}
update_nested_node_refs_after_ungroup(*ntree, *ngroup, *gnode, node_identifier_map);
/* delete the group instance and dereference group tree */
nodeRemoveNode(bmain, ntree, gnode, true);
bke::nodeRemoveNode(bmain, ntree, gnode, true);
}
static int node_group_ungroup_exec(bContext *C, wmOperator * /*op*/)
@ -529,8 +530,8 @@ static bool node_group_separate_selected(
BLI_remlink(&ngroup.nodes, newnode);
BLI_addtail(&ntree.nodes, newnode);
const int32_t old_identifier = node->identifier;
nodeUniqueID(&ntree, newnode);
nodeUniqueName(&ntree, newnode);
bke::nodeUniqueID(&ntree, newnode);
bke::nodeUniqueName(&ntree, newnode);
node_identifier_map.add(old_identifier, newnode->identifier);
}
node_map.add_new(node, newnode);
@ -546,7 +547,7 @@ static bool node_group_separate_selected(
/* ensure valid parent pointers, detach if parent stays inside the group */
if (newnode->parent && !(newnode->parent->flag & NODE_SELECT)) {
nodeDetachNode(&ngroup, newnode);
bke::nodeDetachNode(&ngroup, newnode);
}
if (!newnode->parent) {
@ -566,11 +567,11 @@ static bool node_group_separate_selected(
if (make_copy) {
/* make a copy of internal links */
if (fromselect && toselect) {
nodeAddLink(&ntree,
node_map.lookup(link->fromnode),
socket_map.lookup(link->fromsock),
node_map.lookup(link->tonode),
socket_map.lookup(link->tosock));
bke::nodeAddLink(&ntree,
node_map.lookup(link->fromnode),
socket_map.lookup(link->fromsock),
node_map.lookup(link->tonode),
socket_map.lookup(link->tosock));
}
}
else {
@ -580,7 +581,7 @@ static bool node_group_separate_selected(
BLI_addtail(&ntree.links, link);
}
else if (fromselect || toselect) {
nodeRemLink(&ngroup, link);
bke::nodeRemLink(&ngroup, link);
}
}
}
@ -722,7 +723,7 @@ static bool node_group_make_test_selected(bNodeTree &ntree,
return false;
}
/* make a local pseudo node tree to pass to the node poll functions */
bNodeTree *ngroup = ntreeAddTree(nullptr, "Pseudo Node Group", ntree_idname);
bNodeTree *ngroup = bke::ntreeAddTree(nullptr, "Pseudo Node Group", ntree_idname);
BLI_SCOPED_DEFER([&]() {
bke::ntreeFreeTree(ngroup);
MEM_freeN(ngroup);
@ -948,13 +949,13 @@ static void node_group_make_insert_selected(const bContext &C,
if (bNode *node = group.group_output_node()) {
return node;
}
bNode *output_node = nodeAddStaticNode(&C, &group, NODE_GROUP_OUTPUT);
bNode *output_node = bke::nodeAddStaticNode(&C, &group, NODE_GROUP_OUTPUT);
output_node->locx = real_max[0] - center[0] + 50.0f;
return output_node;
}();
/* Create new group input node for easier organization of the new nodes inside the group. */
bNode *input_node = nodeAddStaticNode(&C, &group, NODE_GROUP_INPUT);
bNode *input_node = bke::nodeAddStaticNode(&C, &group, NODE_GROUP_INPUT);
input_node->locx = real_min[0] - center[0] - 200.0f;
struct InputSocketInfo {
@ -997,7 +998,7 @@ static void node_group_make_insert_selected(const bContext &C,
}
for (bNodeLink *link : output_socket->directly_linked_links()) {
if (nodeLinkIsHidden(link)) {
if (bke::nodeLinkIsHidden(link)) {
links_to_remove.add(link);
continue;
}
@ -1038,7 +1039,7 @@ static void node_group_make_insert_selected(const bContext &C,
}
for (bNodeLink *link : input_socket->directly_linked_links()) {
if (nodeLinkIsHidden(link)) {
if (bke::nodeLinkIsHidden(link)) {
links_to_remove.add(link);
continue;
}
@ -1070,12 +1071,12 @@ static void node_group_make_insert_selected(const bContext &C,
/* Un-parent nodes when only the parent or child moves into the group. */
for (bNode *node : ntree.all_nodes()) {
if (node->parent && nodes_to_move.contains(node->parent) && !nodes_to_move.contains(node)) {
nodeDetachNode(&ntree, node);
bke::nodeDetachNode(&ntree, node);
}
}
for (bNode *node : nodes_to_move) {
if (node->parent && !nodes_to_move.contains(node->parent)) {
nodeDetachNode(&ntree, node);
bke::nodeDetachNode(&ntree, node);
}
}
@ -1101,8 +1102,8 @@ static void node_group_make_insert_selected(const bContext &C,
BLI_remlink(&ntree.nodes, node);
BLI_addtail(&group.nodes, node);
nodeUniqueID(&group, node);
nodeUniqueName(&group, node);
bke::nodeUniqueID(&group, node);
bke::nodeUniqueName(&group, node);
node_identifier_map.add(old_identifier, node->identifier);
@ -1131,7 +1132,7 @@ static void node_group_make_insert_selected(const bContext &C,
}
for (bNodeLink *link : links_to_remove) {
nodeRemLink(&ntree, link);
bke::nodeRemLink(&ntree, link);
}
/* Handle links to the new group inputs. */
@ -1156,7 +1157,7 @@ static void node_group_make_insert_selected(const bContext &C,
/* Create a new link inside of the group. */
const StringRefNull io_identifier = info.interface_socket->identifier;
bNodeSocket *output_sock = node_group_output_find_socket(output_node, io_identifier.c_str());
nodeAddLink(&group, info.link->fromnode, info.link->fromsock, output_node, output_sock);
bke::nodeAddLink(&group, info.link->fromnode, info.link->fromsock, output_node, output_sock);
}
/* Handle new links inside the group. */
@ -1164,12 +1165,12 @@ static void node_group_make_insert_selected(const bContext &C,
const StringRefNull io_identifier = info.interface_socket->identifier;
if (info.socket->in_out == SOCK_IN) {
bNodeSocket *input_socket = node_group_input_find_socket(input_node, io_identifier.c_str());
nodeAddLink(&group, input_node, input_socket, info.node, info.socket);
bke::nodeAddLink(&group, input_node, input_socket, info.node, info.socket);
}
else {
bNodeSocket *output_socket = node_group_output_find_socket(output_node,
io_identifier.c_str());
nodeAddLink(&group, info.node, info.socket, output_node, output_socket);
bke::nodeAddLink(&group, info.node, info.socket, output_node, output_socket);
}
}
@ -1185,7 +1186,7 @@ static void node_group_make_insert_selected(const bContext &C,
const StringRefNull interface_identifier = item.value.interface_socket->identifier;
bNodeSocket *group_node_socket = node_group_find_input_socket(gnode,
interface_identifier.c_str());
nodeAddLink(&ntree, item.value.from_node, item.key, gnode, group_node_socket);
bke::nodeAddLink(&ntree, item.value.from_node, item.key, gnode, group_node_socket);
}
/* Add new links to outputs outside the group. */
@ -1212,10 +1213,10 @@ static bNode *node_group_make_from_nodes(const bContext &C,
get_min_max_of_nodes(nodes_to_group, false, min, max);
/* New node-tree. */
bNodeTree *ngroup = ntreeAddTree(bmain, "NodeGroup", ntreetype);
bNodeTree *ngroup = bke::ntreeAddTree(bmain, "NodeGroup", ntreetype);
/* make group node */
bNode *gnode = nodeAddNode(&C, &ntree, ntype);
bNode *gnode = bke::nodeAddNode(&C, &ntree, ntype);
gnode->id = (ID *)ngroup;
gnode->locx = 0.5f * (min[0] + max[0]);
@ -1247,7 +1248,7 @@ static int node_group_make_exec(bContext *C, wmOperator *op)
if (gnode) {
bNodeTree *ngroup = (bNodeTree *)gnode->id;
nodeSetActive(&ntree, gnode);
bke::nodeSetActive(&ntree, gnode);
if (ngroup) {
ED_node_tree_push(&snode, ngroup, gnode);
}
@ -1304,7 +1305,7 @@ static int node_group_insert_exec(bContext *C, wmOperator *op)
if (!group->is_group() || group->id == nullptr) {
continue;
}
if (ntreeContainsTree(reinterpret_cast<bNodeTree *>(group->id), ngroup)) {
if (bke::ntreeContainsTree(reinterpret_cast<bNodeTree *>(group->id), ngroup)) {
BKE_reportf(
op->reports, RPT_WARNING, "Cannot insert group '%s' in '%s'", group->name, gnode->name);
return OPERATOR_CANCELLED;
@ -1317,7 +1318,7 @@ static int node_group_insert_exec(bContext *C, wmOperator *op)
node_group_make_insert_selected(*C, *ntree, gnode, nodes_to_group);
nodeSetActive(ntree, gnode);
bke::nodeSetActive(ntree, gnode);
ED_node_tree_push(snode, ngroup, gnode);
return OPERATOR_FINISHED;

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

@ -93,7 +93,7 @@ static void pick_link(bNodeLinkDrag &nldrag,
bNodeLink link = create_drag_link(*link_to_pick.fromnode, *link_to_pick.fromsock);
nldrag.links.append(link);
nodeRemLink(snode.edittree, &link_to_pick);
bke::nodeRemLink(snode.edittree, &link_to_pick);
snode.edittree->ensure_topology_cache();
BLI_assert(nldrag.last_node_hovered_while_dragging_a_link != nullptr);
update_multi_input_indices_for_removed_links(*nldrag.last_node_hovered_while_dragging_a_link);
@ -267,10 +267,10 @@ static bool snode_autoconnect_input(SpaceNode &snode,
bNodeTree *ntree = snode.edittree;
if (replace) {
nodeRemSocketLinks(ntree, sock_to);
bke::nodeRemSocketLinks(ntree, sock_to);
}
nodeAddLink(ntree, node_fr, sock_fr, node_to, sock_to);
bke::nodeAddLink(ntree, node_fr, sock_fr, node_to, sock_to);
return true;
}
@ -492,7 +492,7 @@ static void remove_links_to_unavailable_viewer_sockets(bNodeTree &btree, bNode &
LISTBASE_FOREACH_MUTABLE (bNodeLink *, link, &btree.links) {
if (link->tonode == &viewer_node) {
if (link->tosock->flag & SOCK_UNAVAIL) {
nodeRemLink(&btree, link);
bke::nodeRemLink(&btree, link);
}
}
}
@ -642,7 +642,7 @@ static int view_socket(const bContext &C,
}
}
if (viewer_link == nullptr) {
viewer_link = nodeAddLink(
viewer_link = bke::nodeAddLink(
&btree, &bnode_to_view, &bsocket_to_view, viewer_node, viewer_bsocket);
}
else {
@ -682,7 +682,7 @@ static int node_link_viewer(const bContext &C, bNode &bnode_to_view, bNodeSocket
static int node_active_link_viewer_exec(bContext *C, wmOperator * /*op*/)
{
SpaceNode &snode = *CTX_wm_space_node(C);
bNode *node = nodeGetActive(snode.edittree);
bNode *node = bke::nodeGetActive(snode.edittree);
if (!node) {
return OPERATOR_CANCELLED;
@ -863,7 +863,7 @@ static bNodeSocket *node_find_linkable_socket(const bNodeTree &ntree,
const bool sockets_are_compatible = socket->typeinfo == socket_to_match->typeinfo;
if (sockets_are_compatible) {
const int link_count = node_socket_count_links(ntree, *socket);
const bool socket_has_capacity = link_count < nodeSocketLinkLimit(socket);
const bool socket_has_capacity = link_count < bke::nodeSocketLinkLimit(socket);
if (socket_has_capacity) {
/* Found a valid free socket we can swap to. */
return socket;
@ -893,7 +893,7 @@ static void displace_links(bNodeTree *ntree, const bNode *node, bNodeLink *inser
bNodeLink *displaced_link = linked_socket->directly_linked_links().first();
if (!replacement_socket) {
nodeRemLink(ntree, displaced_link);
bke::nodeRemLink(ntree, displaced_link);
return;
}
@ -903,7 +903,7 @@ static void displace_links(bNodeTree *ntree, const bNode *node, bNodeLink *inser
/* Check for duplicate links when linking to multi input sockets. */
for (bNodeLink *existing_link : replacement_socket->runtime->directly_linked_links) {
if (existing_link->fromsock == displaced_link->fromsock) {
nodeRemLink(ntree, displaced_link);
bke::nodeRemLink(ntree, displaced_link);
return;
}
}
@ -922,7 +922,7 @@ static void displace_links(bNodeTree *ntree, const bNode *node, bNodeLink *inser
BKE_ntree_update_tag_link_changed(ntree);
}
else {
nodeRemLink(ntree, link);
bke::nodeRemLink(ntree, link);
BKE_ntree_update_tag_link_removed(ntree);
}
}
@ -953,7 +953,7 @@ static void node_swap_links(bNodeLinkDrag &nldrag, bNodeTree &ntree)
}
if (link->fromnode == start_node) {
/* Don't link a node to itself. */
nodeRemLink(&ntree, link);
bke::nodeRemLink(&ntree, link);
continue;
}
@ -968,7 +968,7 @@ static void node_swap_links(bNodeLinkDrag &nldrag, bNodeTree &ntree)
}
if (link->tonode == start_node) {
/* Don't link a node to itself. */
nodeRemLink(&ntree, link);
bke::nodeRemLink(&ntree, link);
continue;
}
link->fromsock = start_socket;
@ -984,7 +984,7 @@ static void node_remove_existing_links_if_needed(bNodeLinkDrag &nldrag, bNodeTre
bNodeSocket &linked_socket = *nldrag.hovered_socket;
int link_count = node_socket_count_links(ntree, linked_socket);
const int link_limit = nodeSocketLinkLimit(&linked_socket);
const int link_limit = bke::nodeSocketLinkLimit(&linked_socket);
Set<bNodeLink *> links_to_remove;
ntree.ensure_topology_cache();
@ -1021,7 +1021,7 @@ static void node_remove_existing_links_if_needed(bNodeLinkDrag &nldrag, bNodeTre
}
for (bNodeLink *link : links_to_remove) {
nodeRemLink(&ntree, link);
bke::nodeRemLink(&ntree, link);
}
}
@ -1284,8 +1284,8 @@ static std::unique_ptr<bNodeLinkDrag> node_link_init(ARegion &region,
std::unique_ptr<bNodeLinkDrag> nldrag = std::make_unique<bNodeLinkDrag>();
nldrag->start_node = &node;
nldrag->start_socket = sock;
nldrag->start_link_count = nodeCountSocketLinks(snode.edittree, sock);
int link_limit = nodeSocketLinkLimit(sock);
nldrag->start_link_count = bke::nodeCountSocketLinks(snode.edittree, sock);
int link_limit = bke::nodeSocketLinkLimit(sock);
if (nldrag->start_link_count > 0 && (nldrag->start_link_count >= link_limit || detach)) {
/* Dragged links are fixed on input side. */
nldrag->in_out = SOCK_IN;
@ -1297,7 +1297,7 @@ static std::unique_ptr<bNodeLinkDrag> node_link_init(ARegion &region,
oplink.flag |= NODE_LINK_VALID;
nldrag->links.append(oplink);
nodeRemLink(snode.edittree, link);
bke::nodeRemLink(snode.edittree, link);
}
}
}
@ -1316,7 +1316,7 @@ static std::unique_ptr<bNodeLinkDrag> node_link_init(ARegion &region,
nldrag->start_node = &node;
nldrag->start_socket = sock;
nldrag->start_link_count = nodeCountSocketLinks(snode.edittree, sock);
nldrag->start_link_count = bke::nodeCountSocketLinks(snode.edittree, sock);
if (nldrag->start_link_count > 0) {
/* Dragged links are fixed on output side. */
nldrag->in_out = SOCK_OUT;
@ -1334,7 +1334,7 @@ static std::unique_ptr<bNodeLinkDrag> node_link_init(ARegion &region,
oplink.flag |= NODE_LINK_VALID;
nldrag->links.append(oplink);
nodeRemLink(snode.edittree, link_to_pick);
bke::nodeRemLink(snode.edittree, link_to_pick);
/* Send changed event to original link->tonode. */
BKE_ntree_update_tag_node_property(snode.edittree, &node);
@ -1526,7 +1526,7 @@ static int cut_links_exec(bContext *C, wmOperator *op)
Set<bNode *> affected_nodes;
for (bNodeLink *link : links_to_remove) {
bNode *to_node = link->tonode;
nodeRemLink(snode.edittree, link);
bke::nodeRemLink(snode.edittree, link);
affected_nodes.add(to_node);
}
@ -1741,7 +1741,7 @@ static int node_parent_set_exec(bContext *C, wmOperator * /*op*/)
{
SpaceNode &snode = *CTX_wm_space_node(C);
bNodeTree &ntree = *snode.edittree;
bNode *frame = nodeGetActive(&ntree);
bNode *frame = bke::nodeGetActive(&ntree);
if (!frame || frame->type != NODE_FRAME) {
return OPERATOR_CANCELLED;
}
@ -1751,8 +1751,8 @@ static int node_parent_set_exec(bContext *C, wmOperator * /*op*/)
continue;
}
if (node->flag & NODE_SELECT) {
nodeDetachNode(&ntree, node);
nodeAttachNode(&ntree, node, frame);
bke::nodeDetachNode(&ntree, node);
bke::nodeAttachNode(&ntree, node, frame);
}
}
@ -1811,13 +1811,13 @@ static void node_join_attach_recursive(bNodeTree &ntree,
}
else if (selected_nodes.contains(node)) {
/* if parent is not an descendant of the frame, reattach the node */
nodeDetachNode(&ntree, node);
nodeAttachNode(&ntree, node, frame);
bke::nodeDetachNode(&ntree, node);
bke::nodeAttachNode(&ntree, node, frame);
join_states[node->index()].descendent = true;
}
}
else if (selected_nodes.contains(node)) {
nodeAttachNode(&ntree, node, frame);
bke::nodeAttachNode(&ntree, node, frame);
join_states[node->index()].descendent = true;
}
}
@ -1830,8 +1830,8 @@ static int node_join_exec(bContext *C, wmOperator * /*op*/)
const VectorSet<bNode *> selected_nodes = get_selected_nodes(ntree);
bNode *frame_node = nodeAddStaticNode(C, &ntree, NODE_FRAME);
nodeSetActive(&ntree, frame_node);
bNode *frame_node = bke::nodeAddStaticNode(C, &ntree, NODE_FRAME);
bke::nodeSetActive(&ntree, frame_node);
ntree.ensure_topology_cache();
@ -1909,12 +1909,12 @@ static int node_attach_invoke(bContext *C, wmOperator * /*op*/, const wmEvent *e
}
/* Disallow moving a parent into its child. */
if (node->is_frame() && nodeIsParentAndChild(node, frame)) {
if (node->is_frame() && bke::nodeIsParentAndChild(node, frame)) {
continue;
}
if (node->parent == nullptr) {
nodeAttachNode(&ntree, node, frame);
bke::nodeAttachNode(&ntree, node, frame);
changed = true;
continue;
}
@ -1924,13 +1924,13 @@ static int node_attach_invoke(bContext *C, wmOperator * /*op*/, const wmEvent *e
}
/* Attach nodes which share parent with the frame. */
const bool share_parent = nodeIsParentAndChild(node->parent, frame);
const bool share_parent = bke::nodeIsParentAndChild(node->parent, frame);
if (!share_parent) {
continue;
}
nodeDetachNode(&ntree, node);
nodeAttachNode(&ntree, node, frame);
bke::nodeDetachNode(&ntree, node);
bke::nodeAttachNode(&ntree, node, frame);
changed = true;
}
@ -1983,7 +1983,7 @@ static void node_detach_recursive(bNodeTree &ntree,
}
else if (node->flag & NODE_SELECT) {
/* If parent is not a descendant of a selected node, detach. */
nodeDetachNode(&ntree, node);
bke::nodeDetachNode(&ntree, node);
detach_states[node->index()].descendent = true;
}
}
@ -2180,12 +2180,12 @@ void node_insert_on_link_flags(Main &bmain, SpaceNode &snode)
BKE_ntree_update_tag_link_changed(&ntree);
}
else {
nodeRemLink(&ntree, old_link);
bke::nodeRemLink(&ntree, old_link);
}
if (best_input != nullptr) {
/* Add a new link that connects the node on the left to the newly inserted node. */
nodeAddLink(&ntree, from_node, from_socket, node_to_insert, best_input);
bke::nodeAddLink(&ntree, from_node, from_socket, node_to_insert, best_input);
}
/* Set up insert offset data, it needs stuff from here. */
@ -2321,7 +2321,7 @@ static void node_parent_offset_apply(NodeInsertOfsData *data, bNode *parent, con
/* Flag all children as offset to prevent them from being offset
* separately (they've already moved with the parent). */
for (bNode *node : data->ntree->all_nodes()) {
if (nodeIsParentAndChild(parent, node)) {
if (bke::nodeIsParentAndChild(parent, node)) {
/* NODE_TEST is used to flag nodes that shouldn't be offset (again) */
node->flag |= NODE_TEST;
}
@ -2361,7 +2361,7 @@ static void node_link_insert_offset_frame_chains(bNodeTree *ntree,
const bool reversed)
{
for (bNode *node : ntree->all_nodes()) {
if (nodeIsParentAndChild(parent, node)) {
if (bke::nodeIsParentAndChild(parent, node)) {
bke::nodeChainIter(ntree, node, node_link_insert_offset_frame_chain_cb, data, reversed);
}
}
@ -2388,7 +2388,7 @@ static bool node_link_insert_offset_chain_cb(bNode *fromnode,
node_offset_apply(*ofs_node, data->offset_x);
}
if (!nodeIsParentAndChild(data->insert_parent, ofs_node)) {
if (!bke::nodeIsParentAndChild(data->insert_parent, ofs_node)) {
data->insert_parent = nullptr;
}
}
@ -2490,7 +2490,7 @@ static void node_link_insert_offset_ntree(NodeInsertOfsData *iofsd,
if (needs_alignment) {
bNode *offs_node = right_alignment ? next : prev;
if (!offs_node->parent || offs_node->parent == insert.parent ||
nodeIsParentAndChild(offs_node->parent, &insert))
bke::nodeIsParentAndChild(offs_node->parent, &insert))
{
node_offset_apply(*offs_node, addval);
}

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

@ -249,7 +249,7 @@ bool node_deselect_all(bNodeTree &node_tree)
{
bool changed = false;
for (bNode *node : node_tree.all_nodes()) {
changed |= nodeSetSelected(node, false);
changed |= bke::nodeSetSelected(node, false);
}
return changed;
}
@ -355,7 +355,7 @@ static bool node_select_grouped_type(bNodeTree &node_tree, bNode &node_act)
for (bNode *node : node_tree.all_nodes()) {
if ((node->flag & SELECT) == 0) {
if (node->type == node_act.type) {
nodeSetSelected(node, true);
bke::nodeSetSelected(node, true);
changed = true;
}
}
@ -369,7 +369,7 @@ static bool node_select_grouped_color(bNodeTree &node_tree, bNode &node_act)
for (bNode *node : node_tree.all_nodes()) {
if ((node->flag & SELECT) == 0) {
if (compare_v3v3(node->color, node_act.color, 0.005f)) {
nodeSetSelected(node, true);
bke::nodeSetSelected(node, true);
changed = true;
}
}
@ -410,7 +410,7 @@ static bool node_select_grouped_name(bNodeTree &node_tree, bNode &node_act, cons
(!from_right && (pref_len_act == pref_len_curr) &&
STREQLEN(node_act.name, node->name, pref_len_act)))
{
nodeSetSelected(node, true);
bke::nodeSetSelected(node, true);
changed = true;
}
}
@ -429,7 +429,7 @@ static int node_select_grouped_exec(bContext *C, wmOperator *op)
{
SpaceNode &snode = *CTX_wm_space_node(C);
bNodeTree &node_tree = *snode.edittree;
bNode *node_act = nodeGetActive(snode.edittree);
bNode *node_act = bke::nodeGetActive(snode.edittree);
if (node_act == nullptr) {
return OPERATOR_CANCELLED;
@ -442,7 +442,7 @@ static int node_select_grouped_exec(bContext *C, wmOperator *op)
if (!extend) {
node_deselect_all(node_tree);
}
nodeSetSelected(node_act, true);
bke::nodeSetSelected(node_act, true);
switch (type) {
case NODE_SELECT_GROUPED_TYPE:
@ -522,10 +522,10 @@ void node_select_single(bContext &C, bNode &node)
for (bNode *node_iter : node_tree.all_nodes()) {
if (node_iter != &node) {
nodeSetSelected(node_iter, false);
bke::nodeSetSelected(node_iter, false);
}
}
nodeSetSelected(&node, true);
bke::nodeSetSelected(&node, true);
ED_node_set_active(bmain, &snode, &node_tree, &node, &active_texture_changed);
ED_node_set_active_viewer_key(&snode);
@ -640,19 +640,19 @@ static bool node_mouse_select(bContext *C,
if (found) {
switch (params->sel_op) {
case SEL_OP_ADD:
nodeSetSelected(node, true);
bke::nodeSetSelected(node, true);
break;
case SEL_OP_SUB:
nodeSetSelected(node, false);
bke::nodeSetSelected(node, false);
break;
case SEL_OP_XOR: {
/* Check active so clicking on an inactive node activates it. */
bool is_selected = (node->flag & NODE_SELECT) && (node->flag & NODE_ACTIVE);
nodeSetSelected(node, !is_selected);
bke::nodeSetSelected(node, !is_selected);
break;
}
case SEL_OP_SET:
nodeSetSelected(node, true);
bke::nodeSetSelected(node, true);
break;
case SEL_OP_AND:
/* Doesn't make sense for picking. */
@ -802,7 +802,7 @@ static int node_box_select_exec(bContext *C, wmOperator *op)
if (BLI_rctf_isect(&rectf, &node->runtime->totr, nullptr) &&
!BLI_rctf_inside_rctf(&frame_inside, &rectf))
{
nodeSetSelected(node, select);
bke::nodeSetSelected(node, select);
is_inside = true;
}
break;
@ -814,7 +814,7 @@ static int node_box_select_exec(bContext *C, wmOperator *op)
}
if (is_inside) {
nodeSetSelected(node, select);
bke::nodeSetSelected(node, select);
}
}
@ -908,13 +908,13 @@ static int node_circleselect_exec(bContext *C, wmOperator *op)
if (BLI_rctf_isect_circle(&node->runtime->totr, offset, radius_adjusted) &&
!BLI_rctf_isect_circle(&frame_inside, offset, radius_adjusted))
{
nodeSetSelected(node, select);
bke::nodeSetSelected(node, select);
}
break;
}
default: {
if (BLI_rctf_isect_circle(&node->runtime->totr, offset, radius / zoom)) {
nodeSetSelected(node, select);
bke::nodeSetSelected(node, select);
}
break;
}
@ -1000,7 +1000,7 @@ static bool do_lasso_select_node(bContext *C, const Span<int2> mcoords, eSelectO
if (BLI_rctf_isect(&rectf, &node->runtime->totr, nullptr) &&
!BLI_rctf_inside_rctf(&frame_inside, &rectf))
{
nodeSetSelected(node, select);
bke::nodeSetSelected(node, select);
changed = true;
}
break;
@ -1016,7 +1016,7 @@ static bool do_lasso_select_node(bContext *C, const Span<int2> mcoords, eSelectO
BLI_rcti_isect_pt(&rect, screen_co.x, screen_co.y) &&
BLI_lasso_is_point_inside(mcoords, screen_co.x, screen_co.y, INT_MAX))
{
nodeSetSelected(node, select);
bke::nodeSetSelected(node, select);
changed = true;
}
break;
@ -1110,7 +1110,7 @@ static int node_select_all_exec(bContext *C, wmOperator *op)
switch (action) {
case SEL_SELECT:
for (bNode *node : node_tree.all_nodes()) {
nodeSetSelected(node, true);
bke::nodeSetSelected(node, true);
}
break;
case SEL_DESELECT:
@ -1118,7 +1118,7 @@ static int node_select_all_exec(bContext *C, wmOperator *op)
break;
case SEL_INVERT:
for (bNode *node : node_tree.all_nodes()) {
nodeSetSelected(node, !(node->flag & SELECT));
bke::nodeSetSelected(node, !(node->flag & SELECT));
}
break;
}
@ -1170,7 +1170,7 @@ static int node_select_linked_to_exec(bContext *C, wmOperator * /*op*/)
if (!input_socket->is_available()) {
continue;
}
nodeSetSelected(&input_socket->owner_node(), true);
bke::nodeSetSelected(&input_socket->owner_node(), true);
}
}
}
@ -1220,7 +1220,7 @@ static int node_select_linked_from_exec(bContext *C, wmOperator * /*op*/)
if (!output_socket->is_available()) {
continue;
}
nodeSetSelected(&output_socket->owner_node(), true);
bke::nodeSetSelected(&output_socket->owner_node(), true);
}
}
}
@ -1262,7 +1262,7 @@ static int node_select_same_type_step_exec(bContext *C, wmOperator *op)
SpaceNode *snode = CTX_wm_space_node(C);
ARegion *region = CTX_wm_region(C);
const bool prev = RNA_boolean_get(op->ptr, "prev");
bNode *active_node = nodeGetActive(snode->edittree);
bNode *active_node = bke::nodeGetActive(snode->edittree);
if (active_node == nullptr) {
return OPERATOR_CANCELLED;

46
source/blender/editors/space_node/node_shader_preview.cc
View file

@ -119,7 +119,7 @@ static std::optional<ComputeContextHash> get_compute_context_hash_for_node_edito
for (const int i : treepath.index_range().drop_back(1)) {
/* The tree path contains the name of the node but not its ID. */
bNodeTree *tree = treepath[i]->nodetree;
const bNode *node = nodeFindNodebyName(tree, treepath[i + 1]->node_name);
const bNode *node = bke::nodeFindNodebyName(tree, treepath[i + 1]->node_name);
if (node == nullptr) {
/* The current tree path is invalid, probably because some parent group node has been
* deleted. */
@ -377,7 +377,7 @@ static void connect_nested_node_to_node(const Span<bNodeTreePath *> treepath,
}
}
if (output_node == nullptr) {
output_node = nodeAddStaticNode(nullptr, nested_nt, NODE_GROUP_OUTPUT);
output_node = bke::nodeAddStaticNode(nullptr, nested_nt, NODE_GROUP_OUTPUT);
output_node->flag |= NODE_DO_OUTPUT;
}
@ -387,12 +387,12 @@ static void connect_nested_node_to_node(const Span<bNodeTreePath *> treepath,
bNodeSocket *out_socket = blender::bke::node_find_enabled_input_socket(*output_node,
route_name);
nodeAddLink(nested_nt, nested_node_iter, nested_socket_iter, output_node, out_socket);
bke::nodeAddLink(nested_nt, nested_node_iter, nested_socket_iter, output_node, out_socket);
BKE_ntree_update_main_tree(G.pr_main, nested_nt, nullptr);
/* Change the `nested_node` pointer to the nested node-group instance node. The tree path
* contains the name of the instance node but not its ID. */
nested_node_iter = nodeFindNodebyName(path_prev->nodetree, path->node_name);
nested_node_iter = bke::nodeFindNodebyName(path_prev->nodetree, path->node_name);
/* Update the sockets of the node because we added a new interface. */
BKE_ntree_update_tag_node_property(path_prev->nodetree, nested_node_iter);
@ -404,11 +404,11 @@ static void connect_nested_node_to_node(const Span<bNodeTreePath *> treepath,
route_name);
}
nodeAddLink(treepath.first()->nodetree,
nested_node_iter,
nested_socket_iter,
&final_node,
&final_socket);
bke::nodeAddLink(treepath.first()->nodetree,
nested_node_iter,
nested_socket_iter,
&final_node,
&final_socket);
}
/* Connect the node to the output of the first nodetree from `treepath`. Last element of `treepath`
@ -430,10 +430,10 @@ static void connect_node_to_surface_output(const Span<bNodeTreePath *> treepath,
socket_preview = socket_preview->link->fromsock;
}
/* Ensure output is usable. */
out_surface_socket = nodeFindSocket(&output_node, SOCK_IN, "Surface");
out_surface_socket = bke::nodeFindSocket(&output_node, SOCK_IN, "Surface");
if (out_surface_socket->link) {
/* Make sure no node is already wired to the output before wiring. */
nodeRemLink(main_nt, out_surface_socket->link);
bke::nodeRemLink(main_nt, out_surface_socket->link);
}
connect_nested_node_to_node(treepath,
@ -459,13 +459,13 @@ static void connect_nodes_to_aovs(const Span<bNodeTreePath *> treepath,
bNode *node_preview = nodesocket.first;
bNodeSocket *socket_preview = nodesocket.second;
bNode *aov_node = nodeAddStaticNode(nullptr, main_nt, SH_NODE_OUTPUT_AOV);
bNode *aov_node = bke::nodeAddStaticNode(nullptr, main_nt, SH_NODE_OUTPUT_AOV);
STRNCPY(reinterpret_cast<NodeShaderOutputAOV *>(aov_node->storage)->name,
nodesocket.first->name);
if (socket_preview == nullptr) {
continue;
}
bNodeSocket *aov_socket = nodeFindSocket(aov_node, SOCK_IN, "Color");
bNodeSocket *aov_socket = bke::nodeFindSocket(aov_node, SOCK_IN, "Color");
if (socket_preview->in_out == SOCK_IN) {
if (socket_preview->link == nullptr) {
/* Copy the custom value of the socket directly to the AOV node.
@ -527,14 +527,14 @@ static bool prepare_viewlayer_update(void *pvl_data, ViewLayer *vl, Depsgraph *d
return job_data->AOV_nodes.size() > 0 && !vl->prev;
}
bNodeSocket *displacement_socket = nodeFindSocket(
bNodeSocket *displacement_socket = bke::nodeFindSocket(
job_data->mat_output_copy, SOCK_IN, "Displacement");
if (job_data->mat_displacement_copy.first != nullptr && displacement_socket->link == nullptr) {
nodeAddLink(job_data->treepath_copy.first()->nodetree,
job_data->mat_displacement_copy.first,
job_data->mat_displacement_copy.second,
job_data->mat_output_copy,
displacement_socket);
bke::nodeAddLink(job_data->treepath_copy.first()->nodetree,
job_data->mat_displacement_copy.first,
job_data->mat_displacement_copy.second,
job_data->mat_output_copy,
displacement_socket);
}
connect_node_to_surface_output(job_data->treepath_copy, nodesocket, *job_data->mat_output_copy);
@ -703,7 +703,7 @@ static void shader_preview_startjob(void *customdata, wmJobWorkerStatus *worker_
for (bNode *node_iter : job_data->mat_copy->nodetree->all_nodes()) {
if (node_iter->flag & NODE_DO_OUTPUT) {
node_iter->flag &= ~NODE_DO_OUTPUT;
bNodeSocket *disp_socket = nodeFindSocket(node_iter, SOCK_IN, "Displacement");
bNodeSocket *disp_socket = bke::nodeFindSocket(node_iter, SOCK_IN, "Displacement");
if (disp_socket != nullptr && disp_socket->link != nullptr) {
job_data->mat_displacement_copy = std::make_pair(disp_socket->link->fromnode,
disp_socket->link->fromsock);
@ -714,7 +714,7 @@ static void shader_preview_startjob(void *customdata, wmJobWorkerStatus *worker_
/* Add a new output node used only for the previews. This is useful to keep the previously
* connected links (for previewing the output nodes for example). */
job_data->mat_output_copy = nodeAddStaticNode(
job_data->mat_output_copy = bke::nodeAddStaticNode(
nullptr, job_data->mat_copy->nodetree, SH_NODE_OUTPUT_MATERIAL);
job_data->mat_output_copy->flag |= NODE_DO_OUTPUT;
@ -819,8 +819,8 @@ static void ensure_nodetree_previews(const bContext &C,
{
bNodeTreePath *new_path = MEM_cnew<bNodeTreePath>(__func__);
memcpy(new_path, original_path, sizeof(bNodeTreePath));
bNode *parent = nodeFindNodebyName(job_data->treepath_copy.last()->nodetree,
original_path->node_name);
bNode *parent = bke::nodeFindNodebyName(job_data->treepath_copy.last()->nodetree,
original_path->node_name);
new_path->nodetree = reinterpret_cast<bNodeTree *>(parent->id);
job_data->treepath_copy.append(new_path);
}

52
source/blender/editors/space_node/node_templates.cc
View file

@ -151,7 +151,7 @@ static void node_remove_linked(Main *bmain, bNodeTree *ntree, bNode *rem_node)
next = node->next;
if (node->flag & NODE_TEST) {
nodeRemoveNode(bmain, ntree, node, true);
bke::nodeRemoveNode(bmain, ntree, node, true);
}
}
}
@ -166,7 +166,7 @@ static void node_socket_disconnect(Main *bmain,
return;
}
nodeRemLink(ntree, sock_to->link);
bke::nodeRemLink(ntree, sock_to->link);
sock_to->flag |= SOCK_COLLAPSED;
BKE_ntree_update_tag_node_property(ntree, node_to);
@ -203,7 +203,7 @@ static void node_socket_add_replace(const bContext *C,
/* unlink existing node */
if (sock_to->link) {
node_prev = sock_to->link->fromnode;
nodeRemLink(ntree, sock_to->link);
bke::nodeRemLink(ntree, sock_to->link);
}
/* find existing node that we can use */
@ -226,7 +226,7 @@ static void node_socket_add_replace(const bContext *C,
node_from = node_prev;
}
else if (!node_from) {
node_from = nodeAddStaticNode(C, ntree, type);
node_from = bke::nodeAddStaticNode(C, ntree, type);
if (node_prev != nullptr) {
/* If we're replacing existing node, use its location. */
node_from->locx = node_prev->locx;
@ -243,18 +243,18 @@ static void node_socket_add_replace(const bContext *C,
ED_node_tree_propagate_change(C, bmain, ntree);
}
nodeSetActive(ntree, node_from);
bke::nodeSetActive(ntree, node_from);
/* add link */
sock_from_tmp = (bNodeSocket *)BLI_findlink(&node_from->outputs, item->socket_index);
nodeAddLink(ntree, node_from, sock_from_tmp, node_to, sock_to);
bke::nodeAddLink(ntree, node_from, sock_from_tmp, node_to, sock_to);
sock_to->flag &= ~SOCK_COLLAPSED;
/* copy input sockets from previous node */
if (node_prev && node_from != node_prev) {
LISTBASE_FOREACH (bNodeSocket *, sock_prev, &node_prev->inputs) {
LISTBASE_FOREACH (bNodeSocket *, sock_from, &node_from->inputs) {
if (nodeCountSocketLinks(ntree, sock_from) >= nodeSocketLinkLimit(sock_from)) {
if (bke::nodeCountSocketLinks(ntree, sock_from) >= bke::nodeSocketLinkLimit(sock_from)) {
continue;
}
@ -264,8 +264,8 @@ static void node_socket_add_replace(const bContext *C,
bNodeLink *link = sock_prev->link;
if (link && link->fromnode) {
nodeAddLink(ntree, link->fromnode, link->fromsock, node_from, sock_from);
nodeRemLink(ntree, link);
bke::nodeAddLink(ntree, link->fromnode, link->fromsock, node_from, sock_from);
bke::nodeRemLink(ntree, link);
}
node_socket_copy_default_value(sock_from, sock_prev);
@ -304,7 +304,7 @@ struct NodeLinkArg {
bNode *node;
bNodeSocket *sock;
bNodeType *node_type;
bke::bNodeType *node_type;
NodeLinkItem item;
uiLayout *layout;
@ -324,7 +324,8 @@ static Vector<NodeLinkItem> ui_node_link_items(NodeLinkArg *arg,
ngroup = (bNodeTree *)ngroup->id.next)
{
const char *disabled_hint;
if ((ngroup->type != arg->ntree->type) || !nodeGroupPoll(arg->ntree, ngroup, &disabled_hint))
if ((ngroup->type != arg->ntree->type) ||
!bke::nodeGroupPoll(arg->ntree, ngroup, &disabled_hint))
{
continue;
}
@ -334,7 +335,8 @@ static Vector<NodeLinkItem> ui_node_link_items(NodeLinkArg *arg,
ngroup = (bNodeTree *)ngroup->id.next)
{
const char *disabled_hint;
if ((ngroup->type != arg->ntree->type) || !nodeGroupPoll(arg->ntree, ngroup, &disabled_hint))
if ((ngroup->type != arg->ntree->type) ||
!bke::nodeGroupPoll(arg->ntree, ngroup, &disabled_hint))
{
continue;
}
@ -350,7 +352,7 @@ static Vector<NodeLinkItem> ui_node_link_items(NodeLinkArg *arg,
/* NOTE: int stemp->type is not fully reliable, not used for node group
* interface sockets. use the typeinfo->type instead.
*/
const bNodeSocketType *typeinfo = iosock->socket_typeinfo();
const bke::bNodeSocketType *typeinfo = iosock->socket_typeinfo();
item.socket_type = typeinfo->type;
item.socket_name = iosock->name;
item.node_name = ngroup->id.name + 2;
@ -380,9 +382,9 @@ static Vector<NodeLinkItem> ui_node_link_items(NodeLinkArg *arg,
}
}
else {
bNodeSocketTemplate *socket_templates = (in_out == SOCK_IN ? arg->node_type->inputs :
arg->node_type->outputs);
bNodeSocketTemplate *stemp;
bke::bNodeSocketTemplate *socket_templates = (in_out == SOCK_IN ? arg->node_type->inputs :
arg->node_type->outputs);
bke::bNodeSocketTemplate *stemp;
int i;
i = 0;
@ -454,12 +456,12 @@ static int ui_compatible_sockets(int typeA, int typeB)
static int ui_node_item_name_compare(const void *a, const void *b)
{
const bNodeType *type_a = *(const bNodeType **)a;
const bNodeType *type_b = *(const bNodeType **)b;
const bke::bNodeType *type_a = *(const bke::bNodeType **)a;
const bke::bNodeType *type_b = *(const bke::bNodeType **)b;
return BLI_strcasecmp_natural(type_a->ui_name, type_b->ui_name);
}
static bool ui_node_item_special_poll(const bNodeTree * /*ntree*/, const bNodeType *ntype)
static bool ui_node_item_special_poll(const bNodeTree * /*ntree*/, const bke::bNodeType *ntype)
{
if (STREQ(ntype->idname, "ShaderNodeUVAlongStroke")) {
/* TODO(sergey): Currently we don't have Freestyle nodes edited from
@ -484,7 +486,7 @@ static void ui_node_menu_column(NodeLinkArg *arg, int nclass, const char *cname)
int first = 1;
/* generate array of node types sorted by UI name */
blender::Vector<bNodeType *> sorted_ntypes;
blender::Vector<bke::bNodeType *> sorted_ntypes;
NODE_TYPES_BEGIN (ntype) {
const char *disabled_hint;
@ -504,12 +506,14 @@ static void ui_node_menu_column(NodeLinkArg *arg, int nclass, const char *cname)
}
NODE_TYPES_END;
qsort(
sorted_ntypes.data(), sorted_ntypes.size(), sizeof(bNodeType *), ui_node_item_name_compare);
qsort(sorted_ntypes.data(),
sorted_ntypes.size(),
sizeof(bke::bNodeType *),
ui_node_item_name_compare);
/* generate UI */
for (int j = 0; j < sorted_ntypes.size(); j++) {
bNodeType *ntype = sorted_ntypes[j];
bke::bNodeType *ntype = sorted_ntypes[j];
char name[UI_MAX_NAME_STR];
const char *cur_node_name = nullptr;
int num = 0;
@ -607,7 +611,7 @@ static void ui_template_node_link_menu(bContext *C, uiLayout *layout, void *but_
uiLayout *split, *column;
NodeLinkArg *arg = (NodeLinkArg *)but->func_argN;
bNodeSocket *sock = arg->sock;
bNodeTreeType *ntreetype = arg->ntree->typeinfo;
bke::bNodeTreeType *ntreetype = arg->ntree->typeinfo;
UI_block_layout_set_current(block, layout);
split = uiLayoutSplit(layout, 0.0f, false);

26
source/blender/editors/space_node/space_node.cc
View file

@ -73,7 +73,7 @@ void ED_node_tree_start(SpaceNode *snode, bNodeTree *ntree, ID *id, ID *from)
if (ntree) {
bNodeTreePath *path = MEM_cnew<bNodeTreePath>("node tree path");
path->nodetree = ntree;
path->parent_key = NODE_INSTANCE_KEY_BASE;
path->parent_key = blender::bke::NODE_INSTANCE_KEY_BASE;
/* copy initial offset from bNodeTree */
copy_v2_v2(path->view_center, ntree->view_center);
@ -109,17 +109,17 @@ void ED_node_tree_push(SpaceNode *snode, bNodeTree *ntree, bNode *gnode)
path->nodetree = ntree;
if (gnode) {
if (prev_path) {
path->parent_key = BKE_node_instance_key(prev_path->parent_key, prev_path->nodetree, gnode);
path->parent_key = blender::bke::BKE_node_instance_key(prev_path->parent_key, prev_path->nodetree, gnode);
}
else {
path->parent_key = NODE_INSTANCE_KEY_BASE;
path->parent_key = blender::bke::NODE_INSTANCE_KEY_BASE;
}
STRNCPY(path->node_name, gnode->name);
STRNCPY(path->display_name, gnode->name);
}
else {
path->parent_key = NODE_INSTANCE_KEY_BASE;
path->parent_key = blender::bke::NODE_INSTANCE_KEY_BASE;
}
/* copy initial offset from bNodeTree */
@ -348,17 +348,17 @@ bool push_compute_context_for_tree_path(const SpaceNode &snode,
for (const int i : tree_path.index_range().drop_back(1)) {
bNodeTree *tree = tree_path[i]->nodetree;
const char *group_node_name = tree_path[i + 1]->node_name;
const bNode *group_node = nodeFindNodebyName(tree, group_node_name);
const bNode *group_node = blender::bke::nodeFindNodebyName(tree, group_node_name);
if (group_node == nullptr) {
return false;
}
const bke::bNodeTreeZones *tree_zones = tree->zones();
const blender::bke::bNodeTreeZones *tree_zones = tree->zones();
if (tree_zones == nullptr) {
return false;
}
const Vector<const bke::bNodeTreeZone *> zone_stack = tree_zones->get_zone_stack_for_node(
const Vector<const blender::bke::bNodeTreeZone *> zone_stack = tree_zones->get_zone_stack_for_node(
group_node->identifier);
for (const bke::bNodeTreeZone *zone : zone_stack) {
for (const blender::bke::bNodeTreeZone *zone : zone_stack) {
switch (zone->output_node->type) {
case GEO_NODE_SIMULATION_OUTPUT: {
compute_context_builder.push<bke::SimulationZoneComputeContext>(*zone->output_node);
@ -1089,7 +1089,7 @@ static int /*eContextResult*/ node_context(const bContext *C,
}
if (CTX_data_equals(member, "active_node")) {
if (snode->edittree) {
bNode *node = nodeGetActive(snode->edittree);
bNode *node = bke::nodeGetActive(snode->edittree);
CTX_data_pointer_set(result, &snode->edittree->id, &RNA_Node, node);
}
@ -1238,7 +1238,7 @@ static void node_foreach_id(SpaceLink *space_link, LibraryForeachIDData *data)
const bool is_readonly = (data_flags & IDWALK_READONLY) != 0;
const bool allow_pointer_access = (data_flags & IDWALK_NO_ORIG_POINTERS_ACCESS) == 0;
bool is_embedded_nodetree = snode->id != nullptr && allow_pointer_access &&
ntreeFromID(snode->id) == snode->nodetree;
bke::ntreeFromID(snode->id) == snode->nodetree;
BKE_LIB_FOREACHID_PROCESS_ID(data, snode->id, IDWALK_CB_NOP);
BKE_LIB_FOREACHID_PROCESS_ID(data, snode->from, IDWALK_CB_NOP);
@ -1256,7 +1256,7 @@ static void node_foreach_id(SpaceLink *space_link, LibraryForeachIDData *data)
* actual data. Note that `snode->id` was already processed (and therefore potentially
* remapped) above. */
if (!is_readonly) {
snode->nodetree = (snode->id == nullptr) ? nullptr : ntreeFromID(snode->id);
snode->nodetree = (snode->id == nullptr) ? nullptr : bke::ntreeFromID(snode->id);
if (path != nullptr) {
path->nodetree = snode->nodetree;
}
@ -1275,14 +1275,14 @@ static void node_foreach_id(SpaceLink *space_link, LibraryForeachIDData *data)
* accessed. */
BLI_assert(snode->id == nullptr || snode->nodetree == nullptr ||
(snode->nodetree->id.flag & LIB_EMBEDDED_DATA) == 0 ||
snode->nodetree == ntreeFromID(snode->id));
snode->nodetree == bke::ntreeFromID(snode->id));
/* This is mainly here for readfile case ('lib_link' process), as in such case there is no access
* to original data allowed, so no way to know whether the SpaceNode nodetree pointer is an
* embedded one or not. */
if (!is_readonly && snode->id && !snode->nodetree) {
is_embedded_nodetree = true;
snode->nodetree = ntreeFromID(snode->id);
snode->nodetree = bke::ntreeFromID(snode->id);
if (path != nullptr) {
path->nodetree = snode->nodetree;
}

2
source/blender/editors/space_outliner/outliner_draw.cc
View file

@ -2540,7 +2540,7 @@ static BIFIconID tree_element_get_icon_from_id(const ID *id)
return ICON_MOD_MASK;
case ID_NT: {
const bNodeTree *ntree = (bNodeTree *)id;
const bNodeTreeType *ntreetype = ntree->typeinfo;
const bke::bNodeTreeType *ntreetype = ntree->typeinfo;
return ntreetype->ui_icon;
}
case ID_MC:

2
source/blender/editors/transform/transform_convert_node.cc
View file

@ -272,7 +272,7 @@ static void special_aftertrans_update__node(bContext *C, TransInfo *t)
if (ntree) {
LISTBASE_FOREACH_MUTABLE (bNode *, node, &ntree->nodes) {
if (node->flag & NODE_SELECT) {
nodeRemoveNode(bmain, ntree, node, true);
bke::nodeRemoveNode(bmain, ntree, node, true);
}
}
ED_node_tree_propagate_change(C, bmain, ntree);

4
source/blender/editors/undo/memfile_undo.cc
View file

@ -248,7 +248,7 @@ static void memfile_undosys_step_decode(
DEG_id_tag_update_ex(bmain, id, recalc_flags);
}
bNodeTree *nodetree = ntreeFromID(id);
bNodeTree *nodetree = blender::bke::ntreeFromID(id);
if (nodetree != nullptr) {
recalc_flags = nodetree->id.recalc;
if (id->tag & LIB_TAG_UNDO_OLD_ID_REREAD_IN_PLACE) {
@ -285,7 +285,7 @@ static void memfile_undosys_step_decode(
* are already part of the current undo state. This is done in a second
* loop because DEG_id_tag_update may set tags on other datablocks. */
id->recalc_after_undo_push = 0;
bNodeTree *nodetree = ntreeFromID(id);
bNodeTree *nodetree = blender::bke::ntreeFromID(id);
if (nodetree != nullptr) {
nodetree->id.recalc_after_undo_push = 0;
}

2
source/blender/editors/util/ed_viewer_path.cc
View file

@ -98,7 +98,7 @@ static void viewer_path_for_geometry_node(const SpaceNode &snode,
bNodeTree *tree = tree_path[i]->nodetree;
/* The tree path contains the name of the node but not its ID. */
const char *node_name = tree_path[i + 1]->node_name;
const bNode *node = nodeFindNodebyName(tree, node_name);
const bNode *node = bke::nodeFindNodebyName(tree, node_name);
/* The name in the tree path should match a group node in the tree. Sometimes, the tree-path is
* out of date though. */
if (node == nullptr) {

4
source/blender/editors/uvedit/uvedit_ops.cc
View file

@ -119,7 +119,7 @@ bool ED_object_get_active_image(Object *ob,
Material *ma = DEG_is_evaluated_object(ob) ? BKE_object_material_get_eval(ob, mat_nr) :
BKE_object_material_get(ob, mat_nr);
bNodeTree *ntree = (ma && ma->use_nodes) ? ma->nodetree : nullptr;
bNode *node = (ntree) ? nodeGetActiveTexture(ntree) : nullptr;
bNode *node = (ntree) ? bke::nodeGetActiveTexture(ntree) : nullptr;
if (node && is_image_texture_node(node)) {
if (r_ima) {
@ -164,7 +164,7 @@ bool ED_object_get_active_image(Object *ob,
void ED_object_assign_active_image(Main *bmain, Object *ob, int mat_nr, Image *ima)
{
Material *ma = BKE_object_material_get(ob, mat_nr);
bNode *node = (ma && ma->use_nodes) ? nodeGetActiveTexture(ma->nodetree) : nullptr;
bNode *node = (ma && ma->use_nodes) ? bke::nodeGetActiveTexture(ma->nodetree) : nullptr;
if (node && is_image_texture_node(node)) {
node->id = &ima->id;

56
source/blender/freestyle/intern/blender_interface/BlenderStrokeRenderer.cpp
View file

@ -234,13 +234,13 @@ Material *BlenderStrokeRenderer::GetStrokeShader(Main *bmain,
ma->use_nodes = true;
ma->blend_method = MA_BM_HASHED;
bNode *input_attr_color = nodeAddStaticNode(nullptr, ntree, SH_NODE_ATTRIBUTE);
bNode *input_attr_color = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_ATTRIBUTE);
input_attr_color->locx = 0.0f;
input_attr_color->locy = -200.0f;
storage = (NodeShaderAttribute *)input_attr_color->storage;
STRNCPY(storage->name, "Color");
bNode *mix_rgb_color = nodeAddStaticNode(nullptr, ntree, SH_NODE_MIX_RGB_LEGACY);
bNode *mix_rgb_color = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_MIX_RGB_LEGACY);
mix_rgb_color->custom1 = MA_RAMP_BLEND; // Mix
mix_rgb_color->locx = 200.0f;
mix_rgb_color->locy = -200.0f;
@ -248,13 +248,13 @@ Material *BlenderStrokeRenderer::GetStrokeShader(Main *bmain,
toptr = RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, tosock);
RNA_float_set(&toptr, "default_value", 0.0f);
bNode *input_attr_alpha = nodeAddStaticNode(nullptr, ntree, SH_NODE_ATTRIBUTE);
bNode *input_attr_alpha = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_ATTRIBUTE);
input_attr_alpha->locx = 400.0f;
input_attr_alpha->locy = 300.0f;
storage = (NodeShaderAttribute *)input_attr_alpha->storage;
STRNCPY(storage->name, "Alpha");
bNode *mix_rgb_alpha = nodeAddStaticNode(nullptr, ntree, SH_NODE_MIX_RGB_LEGACY);
bNode *mix_rgb_alpha = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_MIX_RGB_LEGACY);
mix_rgb_alpha->custom1 = MA_RAMP_BLEND; // Mix
mix_rgb_alpha->locx = 600.0f;
mix_rgb_alpha->locy = 300.0f;
@ -262,65 +262,67 @@ Material *BlenderStrokeRenderer::GetStrokeShader(Main *bmain,
toptr = RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, tosock);
RNA_float_set(&toptr, "default_value", 0.0f);
bNode *shader_emission = nodeAddStaticNode(nullptr, ntree, SH_NODE_EMISSION);
bNode *shader_emission = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_EMISSION);
shader_emission->locx = 400.0f;
shader_emission->locy = -200.0f;
bNode *input_light_path = nodeAddStaticNode(nullptr, ntree, SH_NODE_LIGHT_PATH);
bNode *input_light_path = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_LIGHT_PATH);
input_light_path->locx = 400.0f;
input_light_path->locy = 100.0f;
bNode *mix_shader_color = nodeAddStaticNode(nullptr, ntree, SH_NODE_MIX_SHADER);
bNode *mix_shader_color = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_MIX_SHADER);
mix_shader_color->locx = 600.0f;
mix_shader_color->locy = -100.0f;
bNode *shader_transparent = nodeAddStaticNode(nullptr, ntree, SH_NODE_BSDF_TRANSPARENT);
bNode *shader_transparent = blender::bke::nodeAddStaticNode(
nullptr, ntree, SH_NODE_BSDF_TRANSPARENT);
shader_transparent->locx = 600.0f;
shader_transparent->locy = 100.0f;
bNode *mix_shader_alpha = nodeAddStaticNode(nullptr, ntree, SH_NODE_MIX_SHADER);
bNode *mix_shader_alpha = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_MIX_SHADER);
mix_shader_alpha->locx = 800.0f;
mix_shader_alpha->locy = 100.0f;
bNode *output_material = nodeAddStaticNode(nullptr, ntree, SH_NODE_OUTPUT_MATERIAL);
bNode *output_material = blender::bke::nodeAddStaticNode(
nullptr, ntree, SH_NODE_OUTPUT_MATERIAL);
output_material->locx = 1000.0f;
output_material->locy = 100.0f;
fromsock = (bNodeSocket *)BLI_findlink(&input_attr_color->outputs, 0); // Color
tosock = (bNodeSocket *)BLI_findlink(&mix_rgb_color->inputs, 1); // Color1
nodeAddLink(ntree, input_attr_color, fromsock, mix_rgb_color, tosock);
blender::bke::nodeAddLink(ntree, input_attr_color, fromsock, mix_rgb_color, tosock);
fromsock = (bNodeSocket *)BLI_findlink(&mix_rgb_color->outputs, 0); // Color
tosock = (bNodeSocket *)BLI_findlink(&shader_emission->inputs, 0); // Color
nodeAddLink(ntree, mix_rgb_color, fromsock, shader_emission, tosock);
blender::bke::nodeAddLink(ntree, mix_rgb_color, fromsock, shader_emission, tosock);
fromsock = (bNodeSocket *)BLI_findlink(&shader_emission->outputs, 0); // Emission
tosock = (bNodeSocket *)BLI_findlink(&mix_shader_color->inputs, 2); // Shader (second)
nodeAddLink(ntree, shader_emission, fromsock, mix_shader_color, tosock);
blender::bke::nodeAddLink(ntree, shader_emission, fromsock, mix_shader_color, tosock);
fromsock = (bNodeSocket *)BLI_findlink(&input_light_path->outputs, 0); // In Camera Ray
tosock = (bNodeSocket *)BLI_findlink(&mix_shader_color->inputs, 0); // Fac
nodeAddLink(ntree, input_light_path, fromsock, mix_shader_color, tosock);
blender::bke::nodeAddLink(ntree, input_light_path, fromsock, mix_shader_color, tosock);
fromsock = (bNodeSocket *)BLI_findlink(&mix_rgb_alpha->outputs, 0); // Color
tosock = (bNodeSocket *)BLI_findlink(&mix_shader_alpha->inputs, 0); // Fac
nodeAddLink(ntree, mix_rgb_alpha, fromsock, mix_shader_alpha, tosock);
blender::bke::nodeAddLink(ntree, mix_rgb_alpha, fromsock, mix_shader_alpha, tosock);
fromsock = (bNodeSocket *)BLI_findlink(&input_attr_alpha->outputs, 0); // Color
tosock = (bNodeSocket *)BLI_findlink(&mix_rgb_alpha->inputs, 1); // Color1
nodeAddLink(ntree, input_attr_alpha, fromsock, mix_rgb_alpha, tosock);
blender::bke::nodeAddLink(ntree, input_attr_alpha, fromsock, mix_rgb_alpha, tosock);
fromsock = (bNodeSocket *)BLI_findlink(&shader_transparent->outputs, 0); // BSDF
tosock = (bNodeSocket *)BLI_findlink(&mix_shader_alpha->inputs, 1); // Shader (first)
nodeAddLink(ntree, shader_transparent, fromsock, mix_shader_alpha, tosock);
blender::bke::nodeAddLink(ntree, shader_transparent, fromsock, mix_shader_alpha, tosock);
fromsock = (bNodeSocket *)BLI_findlink(&mix_shader_color->outputs, 0); // Shader
tosock = (bNodeSocket *)BLI_findlink(&mix_shader_alpha->inputs, 2); // Shader (second)
nodeAddLink(ntree, mix_shader_color, fromsock, mix_shader_alpha, tosock);
blender::bke::nodeAddLink(ntree, mix_shader_color, fromsock, mix_shader_alpha, tosock);
fromsock = (bNodeSocket *)BLI_findlink(&mix_shader_alpha->outputs, 0); // Shader
tosock = (bNodeSocket *)BLI_findlink(&output_material->inputs, 0); // Surface
nodeAddLink(ntree, mix_shader_alpha, fromsock, output_material, tosock);
blender::bke::nodeAddLink(ntree, mix_shader_alpha, fromsock, output_material, tosock);
if (output_linestyle) {
bNodeSocket *outsock;
@ -333,7 +335,7 @@ Material *BlenderStrokeRenderer::GetStrokeShader(Main *bmain,
tosock = (bNodeSocket *)BLI_findlink(&mix_rgb_color->inputs, 2); // Color2
link = (bNodeLink *)BLI_findptr(&ntree->links, outsock, offsetof(bNodeLink, tosock));
if (link) {
nodeAddLink(ntree, link->fromnode, link->fromsock, mix_rgb_color, tosock);
blender::bke::nodeAddLink(ntree, link->fromnode, link->fromsock, mix_rgb_color, tosock);
}
else {
float color[4];
@ -347,7 +349,7 @@ Material *BlenderStrokeRenderer::GetStrokeShader(Main *bmain,
tosock = (bNodeSocket *)BLI_findlink(&mix_rgb_color->inputs, 0); // Fac
link = (bNodeLink *)BLI_findptr(&ntree->links, outsock, offsetof(bNodeLink, tosock));
if (link) {
nodeAddLink(ntree, link->fromnode, link->fromsock, mix_rgb_color, tosock);
blender::bke::nodeAddLink(ntree, link->fromnode, link->fromsock, mix_rgb_color, tosock);
}
else {
fromptr = RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, outsock);
@ -359,7 +361,7 @@ Material *BlenderStrokeRenderer::GetStrokeShader(Main *bmain,
tosock = (bNodeSocket *)BLI_findlink(&mix_rgb_alpha->inputs, 2); // Color2
link = (bNodeLink *)BLI_findptr(&ntree->links, outsock, offsetof(bNodeLink, tosock));
if (link) {
nodeAddLink(ntree, link->fromnode, link->fromsock, mix_rgb_alpha, tosock);
blender::bke::nodeAddLink(ntree, link->fromnode, link->fromsock, mix_rgb_alpha, tosock);
}
else {
float color[4];
@ -374,7 +376,7 @@ Material *BlenderStrokeRenderer::GetStrokeShader(Main *bmain,
tosock = (bNodeSocket *)BLI_findlink(&mix_rgb_alpha->inputs, 0); // Fac
link = (bNodeLink *)BLI_findptr(&ntree->links, outsock, offsetof(bNodeLink, tosock));
if (link) {
nodeAddLink(ntree, link->fromnode, link->fromsock, mix_rgb_alpha, tosock);
blender::bke::nodeAddLink(ntree, link->fromnode, link->fromsock, mix_rgb_alpha, tosock);
}
else {
fromptr = RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, outsock);
@ -388,7 +390,7 @@ Material *BlenderStrokeRenderer::GetStrokeShader(Main *bmain,
bNodeSocket *sock = (bNodeSocket *)BLI_findlink(&node->outputs, 0);
// add new UV Map node
bNode *input_uvmap = nodeAddStaticNode(nullptr, ntree, SH_NODE_UVMAP);
bNode *input_uvmap = blender::bke::nodeAddStaticNode(nullptr, ntree, SH_NODE_UVMAP);
input_uvmap->locx = node->locx - 200.0f;
input_uvmap->locy = node->locy;
NodeShaderUVMap *storage = (NodeShaderUVMap *)input_uvmap->storage;
@ -403,15 +405,15 @@ Material *BlenderStrokeRenderer::GetStrokeShader(Main *bmain,
// replace links from the UV Along Stroke node by links from the UV Map node
LISTBASE_FOREACH (bNodeLink *, link, &ntree->links) {
if (link->fromnode == node && link->fromsock == sock) {
nodeAddLink(ntree, input_uvmap, fromsock, link->tonode, link->tosock);
blender::bke::nodeAddLink(ntree, input_uvmap, fromsock, link->tonode, link->tosock);
}
}
nodeRemSocketLinks(ntree, sock);
blender::bke::nodeRemSocketLinks(ntree, sock);
}
}
}
nodeSetActive(ntree, output_material);
blender::bke::nodeSetActive(ntree, output_material);
BKE_ntree_update_main_tree(bmain, ntree, nullptr);
return ma;

4
source/blender/gpu/intern/gpu_material.cc
View file

@ -863,7 +863,7 @@ GPUMaterial *GPU_material_from_nodetree(Scene *scene,
}
/* Localize tree to create links for reroute and mute. */
bNodeTree *localtree = ntreeLocalize(ntree, nullptr);
bNodeTree *localtree = blender::bke::ntreeLocalize(ntree, nullptr);
ntreeGPUMaterialNodes(localtree, mat);
if (can_use_default_cb && can_use_default_cb(mat)) {
@ -925,7 +925,7 @@ GPUMaterial *GPU_material_from_nodetree(Scene *scene,
}
/* Only free after GPU_pass_shader_get where GPUUniformBuf read data from the local tree. */
ntreeFreeLocalTree(localtree);
blender::bke::ntreeFreeLocalTree(localtree);
BLI_assert(!localtree->id.py_instance); /* Or call #BKE_libblock_free_data_py. */
MEM_freeN(localtree);

4
source/blender/gpu/intern/gpu_shader_builder_stubs.cc
View file

@ -178,13 +178,13 @@ extern "C" void ntreeGPUMaterialNodes(struct bNodeTree * /*localtree*/,
BLI_assert_unreachable();
}
struct bNodeTree *ntreeLocalize(struct bNodeTree * /*ntree*/, ID * /*new_owner_id*/)
struct bNodeTree *blender::bke::ntreeLocalize(struct bNodeTree * /*ntree*/, ID * /*new_owner_id*/)
{
BLI_assert_unreachable();
return nullptr;
}
void ntreeFreeLocalTree(struct bNodeTree * /*ntree*/)
void blender::bke::ntreeFreeLocalTree(struct bNodeTree * /*ntree*/)
{
BLI_assert_unreachable();
}

30
source/blender/io/collada/Materials.cpp
View file

@ -104,7 +104,7 @@ void MaterialNode::update_material_nodetree()
bNode *MaterialNode::add_node(int node_type, int locx, int locy, std::string label)
{
bNode *node = nodeAddStaticNode(mContext, ntree, node_type);
bNode *node = blender::bke::nodeAddStaticNode(mContext, ntree, node_type);
if (node) {
if (label.length() > 0) {
STRNCPY(node->label, label.c_str());
@ -122,7 +122,7 @@ void MaterialNode::add_link(bNode *from_node, int from_index, bNode *to_node, in
bNodeSocket *from_socket = (bNodeSocket *)BLI_findlink(&from_node->outputs, from_index);
bNodeSocket *to_socket = (bNodeSocket *)BLI_findlink(&to_node->inputs, to_index);
nodeAddLink(ntree, from_node, from_socket, to_node, to_socket);
blender::bke::nodeAddLink(ntree, from_node, from_socket, to_node, to_socket);
}
void MaterialNode::add_link(bNode *from_node,
@ -130,11 +130,11 @@ void MaterialNode::add_link(bNode *from_node,
bNode *to_node,
const char *to_label)
{
bNodeSocket *from_socket = nodeFindSocket(from_node, SOCK_OUT, from_label);
bNodeSocket *to_socket = nodeFindSocket(to_node, SOCK_IN, to_label);
bNodeSocket *from_socket = blender::bke::nodeFindSocket(from_node, SOCK_OUT, from_label);
bNodeSocket *to_socket = blender::bke::nodeFindSocket(to_node, SOCK_IN, to_label);
if (from_socket && to_socket) {
nodeAddLink(ntree, from_node, from_socket, to_node, to_socket);
blender::bke::nodeAddLink(ntree, from_node, from_socket, to_node, to_socket);
}
}
@ -142,7 +142,7 @@ void MaterialNode::set_reflectivity(COLLADAFW::FloatOrParam &val)
{
float reflectivity = val.getFloatValue();
if (reflectivity >= 0) {
bNodeSocket *socket = nodeFindSocket(shader_node, SOCK_IN, "Metallic");
bNodeSocket *socket = blender::bke::nodeFindSocket(shader_node, SOCK_IN, "Metallic");
((bNodeSocketValueFloat *)socket->default_value)->value = reflectivity;
material->metallic = reflectivity;
}
@ -154,7 +154,7 @@ void MaterialNode::set_shininess(COLLADAFW::FloatOrParam &val)
{
float roughness = val.getFloatValue();
if (roughness >= 0) {
bNodeSocket *socket = nodeFindSocket(shader_node, SOCK_IN, "Roughness");
bNodeSocket *socket = blender::bke::nodeFindSocket(shader_node, SOCK_IN, "Roughness");
((bNodeSocketValueFloat *)socket->default_value)->value = roughness;
}
}
@ -170,7 +170,7 @@ void MaterialNode::set_ior(COLLADAFW::FloatOrParam &val)
return;
}
bNodeSocket *socket = nodeFindSocket(shader_node, SOCK_IN, "IOR");
bNodeSocket *socket = blender::bke::nodeFindSocket(shader_node, SOCK_IN, "IOR");
((bNodeSocketValueFloat *)socket->default_value)->value = ior;
}
@ -209,7 +209,7 @@ void MaterialNode::set_alpha(COLLADAFW::EffectCommon::OpaqueMode mode,
alpha = 1 - alpha;
}
bNodeSocket *socket = nodeFindSocket(shader_node, SOCK_IN, "Alpha");
bNodeSocket *socket = blender::bke::nodeFindSocket(shader_node, SOCK_IN, "Alpha");
((bNodeSocketValueFloat *)socket->default_value)->value = alpha;
material->a = alpha;
}
@ -230,7 +230,7 @@ void MaterialNode::set_diffuse(COLLADAFW::ColorOrTexture &cot)
}
}
else {
bNodeSocket *socket = nodeFindSocket(shader_node, SOCK_IN, "Base Color");
bNodeSocket *socket = blender::bke::nodeFindSocket(shader_node, SOCK_IN, "Base Color");
float *fcol = (float *)socket->default_value;
if (cot.isColor()) {
@ -259,7 +259,7 @@ Image *MaterialNode::get_diffuse_image()
}
const bNode *shader = nodes.first();
const bNodeSocket *in_socket = nodeFindSocket(shader, SOCK_IN, "Base Color");
const bNodeSocket *in_socket = blender::bke::nodeFindSocket(shader, SOCK_IN, "Base Color");
if (in_socket == nullptr) {
return nullptr;
}
@ -330,7 +330,7 @@ void MaterialNode::set_emission(COLLADAFW::ColorOrTexture &cot)
int locy = -300 * (node_map.size() - 2);
if (cot.isColor()) {
COLLADAFW::Color col = cot.getColor();
bNodeSocket *socket = nodeFindSocket(shader_node, SOCK_IN, "Emission Color");
bNodeSocket *socket = blender::bke::nodeFindSocket(shader_node, SOCK_IN, "Emission Color");
float *fcol = (float *)socket->default_value;
fcol[0] = col.getRed();
@ -346,7 +346,7 @@ void MaterialNode::set_emission(COLLADAFW::ColorOrTexture &cot)
}
}
bNodeSocket *socket = nodeFindSocket(shader_node, SOCK_IN, "Emission Strength");
bNodeSocket *socket = blender::bke::nodeFindSocket(shader_node, SOCK_IN, "Emission Strength");
if (socket) {
*(float *)socket->default_value = 1.0f;
}
@ -367,7 +367,7 @@ void MaterialNode::set_opacity(COLLADAFW::ColorOrTexture &cot)
alpha *= col.getAlpha(); /* Assuming A_ONE opaque mode */
}
bNodeSocket *socket = nodeFindSocket(shader_node, SOCK_IN, "Alpha");
bNodeSocket *socket = blender::bke::nodeFindSocket(shader_node, SOCK_IN, "Alpha");
((bNodeSocketValueFloat *)socket->default_value)->value = alpha;
}
/* texture */
@ -407,7 +407,7 @@ void MaterialNode::set_specular(COLLADAFW::ColorOrTexture &cot)
* TODO: This is a solution only for a corner case. We must find a better
* way to handle specularity in general. Also note that currently we
* do not export specularity values, see EffectExporter::operator() */
bNodeSocket *socket = nodeFindSocket(shader_node, SOCK_IN, "Specular IOR Level");
bNodeSocket *socket = blender::bke::nodeFindSocket(shader_node, SOCK_IN, "Specular IOR Level");
((bNodeSocketValueFloat *)socket->default_value)->value = 0.0f;
}
}

8
source/blender/io/collada/collada_utils.cpp
View file

@ -1107,7 +1107,7 @@ static bNodeTree *prepare_material_nodetree(Material *ma)
static bNode *bc_add_node(
bContext *C, bNodeTree *ntree, int node_type, int locx, int locy, std::string label)
{
bNode *node = nodeAddStaticNode(C, ntree, node_type);
bNode *node = blender::bke::nodeAddStaticNode(C, ntree, node_type);
if (node) {
if (label.length() > 0) {
STRNCPY(node->label, label.c_str());
@ -1130,7 +1130,7 @@ static void bc_node_add_link(
bNodeSocket *from_socket = (bNodeSocket *)BLI_findlink(&from_node->outputs, from_index);
bNodeSocket *to_socket = (bNodeSocket *)BLI_findlink(&to_node->inputs, to_index);
nodeAddLink(ntree, from_node, from_socket, to_node, to_socket);
blender::bke::nodeAddLink(ntree, from_node, from_socket, to_node, to_socket);
}
void bc_add_default_shader(bContext *C, Material *ma)
@ -1265,7 +1265,7 @@ double bc_get_reflectivity(Material *ma)
bool bc_get_float_from_shader(bNode *shader, double &val, std::string nodeid)
{
bNodeSocket *socket = nodeFindSocket(shader, SOCK_IN, nodeid.c_str());
bNodeSocket *socket = blender::bke::nodeFindSocket(shader, SOCK_IN, nodeid.c_str());
if (socket) {
bNodeSocketValueFloat *ref = (bNodeSocketValueFloat *)socket->default_value;
val = double(ref->value);
@ -1279,7 +1279,7 @@ COLLADASW::ColorOrTexture bc_get_cot_from_shader(bNode *shader,
Color &default_color,
bool with_alpha)
{
bNodeSocket *socket = nodeFindSocket(shader, SOCK_IN, nodeid.c_str());
bNodeSocket *socket = blender::bke::nodeFindSocket(shader, SOCK_IN, nodeid.c_str());
if (socket) {
bNodeSocketValueRGBA *dcol = (bNodeSocketValueRGBA *)socket->default_value;
float *col = dcol->value;

25
source/blender/io/usd/intern/usd_reader_material.cc
View file

@ -148,7 +148,7 @@ static void cache_node(ShaderToNodeMap &node_cache,
static bNode *add_node(
const bContext *C, bNodeTree *ntree, const int type, const float locx, const float locy)
{
bNode *new_node = nodeAddStaticNode(C, ntree, type);
bNode *new_node = blender::bke::nodeAddStaticNode(C, ntree, type);
if (new_node) {
new_node->locx = locx;
@ -162,21 +162,21 @@ static bNode *add_node(
static void link_nodes(
bNodeTree *ntree, bNode *source, const char *sock_out, bNode *dest, const char *sock_in)
{
bNodeSocket *source_socket = nodeFindSocket(source, SOCK_OUT, sock_out);
bNodeSocket *source_socket = blender::bke::nodeFindSocket(source, SOCK_OUT, sock_out);
if (!source_socket) {
CLOG_ERROR(&LOG, "Couldn't find output socket %s", sock_out);
return;
}
bNodeSocket *dest_socket = nodeFindSocket(dest, SOCK_IN, sock_in);
bNodeSocket *dest_socket = blender::bke::nodeFindSocket(dest, SOCK_IN, sock_in);
if (!dest_socket) {
CLOG_ERROR(&LOG, "Couldn't find input socket %s", sock_in);
return;
}
nodeAddLink(ntree, source, source_socket, dest, dest_socket);
blender::bke::nodeAddLink(ntree, source, source_socket, dest, dest_socket);
}
/* Returns a layer handle retrieved from the given attribute's property specs.
@ -423,7 +423,7 @@ static pxr::UsdShadeInput get_input(const pxr::UsdShadeShader &usd_shader,
static bNodeSocket *get_input_socket(bNode *node, const char *identifier, ReportList *reports)
{
bNodeSocket *sock = nodeFindSocket(node, SOCK_IN, identifier);
bNodeSocket *sock = blender::bke::nodeFindSocket(node, SOCK_IN, identifier);
if (!sock) {
BKE_reportf(reports,
RPT_ERROR,
@ -541,7 +541,7 @@ void USDMaterialReader::import_usd_preview(Material *mtl,
/* Recursively create the principled shader input networks. */
set_principled_node_inputs(principled, ntree, usd_shader);
nodeSetActive(ntree, output);
blender::bke::nodeSetActive(ntree, output);
BKE_ntree_update_main_tree(bmain_, ntree, nullptr);
@ -588,7 +588,8 @@ void USDMaterialReader::set_principled_node_inputs(bNode *principled,
}
}
bNodeSocket *emission_strength_sock = nodeFindSocket(principled, SOCK_IN, "Emission Strength");
bNodeSocket *emission_strength_sock = blender::bke::nodeFindSocket(
principled, SOCK_IN, "Emission Strength");
((bNodeSocketValueFloat *)emission_strength_sock->default_value)->value = emission_strength;
if (pxr::UsdShadeInput specular_input = usd_shader.GetInput(usdtokens::specularColor)) {
@ -647,7 +648,7 @@ bool USDMaterialReader::set_node_input(const pxr::UsdShadeInput &usd_input,
else {
/* Set the destination node socket value from the USD shader input value. */
bNodeSocket *sock = nodeFindSocket(dest_node, SOCK_IN, dest_socket_name);
bNodeSocket *sock = blender::bke::nodeFindSocket(dest_node, SOCK_IN, dest_socket_name);
if (!sock) {
CLOG_ERROR(&LOG, "Couldn't get destination node socket %s", dest_socket_name);
return false;
@ -782,8 +783,8 @@ static IntermediateNode add_scale_bias(const pxr::UsdShadeShader &usd_shader,
scale_bias.sock_input_name = "Vector";
scale_bias.sock_output_name = "Vector";
bNodeSocket *sock_scale = nodeFindSocket(scale_bias.node, SOCK_IN, "Vector_001");
bNodeSocket *sock_bias = nodeFindSocket(scale_bias.node, SOCK_IN, "Vector_002");
bNodeSocket *sock_scale = blender::bke::nodeFindSocket(scale_bias.node, SOCK_IN, "Vector_001");
bNodeSocket *sock_bias = blender::bke::nodeFindSocket(scale_bias.node, SOCK_IN, "Vector_002");
copy_v3_v3(((bNodeSocketValueVector *)sock_scale->default_value)->value, scale.data());
copy_v3_v3(((bNodeSocketValueVector *)sock_bias->default_value)->value, bias.data());
@ -804,8 +805,8 @@ static IntermediateNode add_scale_bias_adjust(bNodeTree *ntree,
adjust.sock_input_name = "Vector";
adjust.sock_output_name = "Vector";
bNodeSocket *sock_scale = nodeFindSocket(adjust.node, SOCK_IN, "Vector_001");
bNodeSocket *sock_bias = nodeFindSocket(adjust.node, SOCK_IN, "Vector_002");
bNodeSocket *sock_scale = blender::bke::nodeFindSocket(adjust.node, SOCK_IN, "Vector_001");
bNodeSocket *sock_bias = blender::bke::nodeFindSocket(adjust.node, SOCK_IN, "Vector_002");
copy_v3_fl3(((bNodeSocketValueVector *)sock_scale->default_value)->value, 0.5f, 0.5f, 0.5f);
copy_v3_fl3(((bNodeSocketValueVector *)sock_bias->default_value)->value, 0.5f, 0.5f, 0.5f);

93
source/blender/io/usd/intern/usd_reader_pointinstancer.cc
View file

@ -26,11 +26,11 @@ namespace blender::io::usd {
*/
static bNode *add_input_named_attrib_node(bNodeTree *ntree, const char *name, int8_t prop_type)
{
bNode *node = nodeAddStaticNode(nullptr, ntree, GEO_NODE_INPUT_NAMED_ATTRIBUTE);
bNode *node = bke::nodeAddStaticNode(nullptr, ntree, GEO_NODE_INPUT_NAMED_ATTRIBUTE);
auto *storage = reinterpret_cast<NodeGeometryInputNamedAttribute *>(node->storage);
storage->data_type = prop_type;
bNodeSocket *socket = nodeFindSocket(node, SOCK_IN, "Name");
bNodeSocket *socket = bke::nodeFindSocket(node, SOCK_IN, "Name");
bNodeSocketValueString *str_value = static_cast<bNodeSocketValueString *>(socket->default_value);
BLI_strncpy(str_value->value, name, MAX_NAME);
return node;
@ -161,7 +161,7 @@ void USDPointInstancerReader::read_object_data(Main *bmain, const double motionS
BKE_modifiers_persistent_uid_init(*object_, *md);
NodesModifierData &nmd = *reinterpret_cast<NodesModifierData *>(md);
nmd.node_group = ntreeAddTree(bmain, "Instances", "GeometryNodeTree");
nmd.node_group = bke::ntreeAddTree(bmain, "Instances", "GeometryNodeTree");
bNodeTree *ntree = nmd.node_group;
@ -169,25 +169,26 @@ void USDPointInstancerReader::read_object_data(Main *bmain, const double motionS
"Geometry", "", "NodeSocketGeometry", NODE_INTERFACE_SOCKET_OUTPUT, nullptr);
ntree->tree_interface.add_socket(
"Geometry", "", "NodeSocketGeometry", NODE_INTERFACE_SOCKET_INPUT, nullptr);
bNode *group_input = nodeAddStaticNode(nullptr, ntree, NODE_GROUP_INPUT);
bNode *group_input = bke::nodeAddStaticNode(nullptr, ntree, NODE_GROUP_INPUT);
group_input->locx = -400.0f;
bNode *group_output = nodeAddStaticNode(nullptr, ntree, NODE_GROUP_OUTPUT);
bNode *group_output = bke::nodeAddStaticNode(nullptr, ntree, NODE_GROUP_OUTPUT);
group_output->locx = 500.0f;
group_output->flag |= NODE_DO_OUTPUT;
bNode *instance_on_points_node = nodeAddStaticNode(nullptr, ntree, GEO_NODE_INSTANCE_ON_POINTS);
bNode *instance_on_points_node = bke::nodeAddStaticNode(
nullptr, ntree, GEO_NODE_INSTANCE_ON_POINTS);
instance_on_points_node->locx = 300.0f;
bNodeSocket *socket = nodeFindSocket(instance_on_points_node, SOCK_IN, "Pick Instance");
bNodeSocket *socket = bke::nodeFindSocket(instance_on_points_node, SOCK_IN, "Pick Instance");
socket->default_value_typed<bNodeSocketValueBoolean>()->value = true;
bNode *mask_attrib_node = add_input_named_attrib_node(ntree, "mask", CD_PROP_BOOL);
mask_attrib_node->locx = 100.0f;
mask_attrib_node->locy = -100.0f;
bNode *collection_info_node = nodeAddStaticNode(nullptr, ntree, GEO_NODE_COLLECTION_INFO);
bNode *collection_info_node = bke::nodeAddStaticNode(nullptr, ntree, GEO_NODE_COLLECTION_INFO);
collection_info_node->locx = 100.0f;
collection_info_node->locy = -300.0f;
socket = nodeFindSocket(collection_info_node, SOCK_IN, "Separate Children");
socket = bke::nodeFindSocket(collection_info_node, SOCK_IN, "Separate Children");
socket->default_value_typed<bNodeSocketValueBoolean>()->value = true;
bNode *indices_attrib_node = add_input_named_attrib_node(ntree, "proto_index", CD_PROP_INT32);
@ -203,47 +204,47 @@ void USDPointInstancerReader::read_object_data(Main *bmain, const double motionS
scale_attrib_node->locx = 100.0f;
scale_attrib_node->locy = -900.0f;
nodeAddLink(ntree,
group_input,
static_cast<bNodeSocket *>(group_input->outputs.first),
instance_on_points_node,
nodeFindSocket(instance_on_points_node, SOCK_IN, "Points"));
bke::nodeAddLink(ntree,
group_input,
static_cast<bNodeSocket *>(group_input->outputs.first),
instance_on_points_node,
bke::nodeFindSocket(instance_on_points_node, SOCK_IN, "Points"));
nodeAddLink(ntree,
mask_attrib_node,
nodeFindSocket(mask_attrib_node, SOCK_OUT, "Attribute"),
instance_on_points_node,
nodeFindSocket(instance_on_points_node, SOCK_IN, "Selection"));
bke::nodeAddLink(ntree,
mask_attrib_node,
bke::nodeFindSocket(mask_attrib_node, SOCK_OUT, "Attribute"),
instance_on_points_node,
bke::nodeFindSocket(instance_on_points_node, SOCK_IN, "Selection"));
nodeAddLink(ntree,
indices_attrib_node,
nodeFindSocket(indices_attrib_node, SOCK_OUT, "Attribute"),
instance_on_points_node,
nodeFindSocket(instance_on_points_node, SOCK_IN, "Instance Index"));
bke::nodeAddLink(ntree,
indices_attrib_node,
bke::nodeFindSocket(indices_attrib_node, SOCK_OUT, "Attribute"),
instance_on_points_node,
bke::nodeFindSocket(instance_on_points_node, SOCK_IN, "Instance Index"));
nodeAddLink(ntree,
scale_attrib_node,
nodeFindSocket(scale_attrib_node, SOCK_OUT, "Attribute"),
instance_on_points_node,
nodeFindSocket(instance_on_points_node, SOCK_IN, "Scale"));
bke::nodeAddLink(ntree,
scale_attrib_node,
bke::nodeFindSocket(scale_attrib_node, SOCK_OUT, "Attribute"),
instance_on_points_node,
bke::nodeFindSocket(instance_on_points_node, SOCK_IN, "Scale"));
nodeAddLink(ntree,
rotation_attrib_node,
nodeFindSocket(rotation_attrib_node, SOCK_OUT, "Attribute"),
instance_on_points_node,
nodeFindSocket(instance_on_points_node, SOCK_IN, "Rotation"));
bke::nodeAddLink(ntree,
rotation_attrib_node,
bke::nodeFindSocket(rotation_attrib_node, SOCK_OUT, "Attribute"),
instance_on_points_node,
bke::nodeFindSocket(instance_on_points_node, SOCK_IN, "Rotation"));
nodeAddLink(ntree,
collection_info_node,
nodeFindSocket(collection_info_node, SOCK_OUT, "Instances"),
instance_on_points_node,
nodeFindSocket(instance_on_points_node, SOCK_IN, "Instance"));
bke::nodeAddLink(ntree,
collection_info_node,
bke::nodeFindSocket(collection_info_node, SOCK_OUT, "Instances"),
instance_on_points_node,
bke::nodeFindSocket(instance_on_points_node, SOCK_IN, "Instance"));
nodeAddLink(ntree,
instance_on_points_node,
nodeFindSocket(instance_on_points_node, SOCK_OUT, "Instances"),
group_output,
static_cast<bNodeSocket *>(group_output->inputs.first));
bke::nodeAddLink(ntree,
instance_on_points_node,
bke::nodeFindSocket(instance_on_points_node, SOCK_OUT, "Instances"),
group_output,
static_cast<bNodeSocket *>(group_output->inputs.first));
BKE_ntree_update_main_tree(bmain, ntree, nullptr);
@ -286,13 +287,13 @@ void USDPointInstancerReader::set_collection(Main *bmain, Collection &coll)
return;
}
bNode *collection_node = nodeFindNodebyName(ntree, "Collection Info");
bNode *collection_node = bke::nodeFindNodebyName(ntree, "Collection Info");
if (!collection_node) {
BLI_assert_unreachable();
return;
}
bNodeSocket *sock = nodeFindSocket(collection_node, SOCK_IN, "Collection");
bNodeSocket *sock = bke::nodeFindSocket(collection_node, SOCK_IN, "Collection");
if (!sock) {
BLI_assert_unreachable();
return;

21
source/blender/io/usd/intern/usd_writer_material.cc
View file

@ -187,7 +187,8 @@ static void create_usd_preview_surface_material(const USDExporterContext &usd_ex
if (input_spec.input_name == usdtokens::emissive_color) {
/* Don't export emission color if strength is zero. */
bNodeSocket *emission_strength_sock = nodeFindSocket(node, SOCK_IN, "Emission Strength");
bNodeSocket *emission_strength_sock = bke::nodeFindSocket(
node, SOCK_IN, "Emission Strength");
if (!emission_strength_sock) {
continue;
@ -257,14 +258,14 @@ static void create_usd_preview_surface_material(const USDExporterContext &usd_ex
if (vector_math_node->custom1 == NODE_VECTOR_MATH_MULTIPLY_ADD) {
/* Attempt one more traversal in case the current node is not not the
* correct NODE_VECTOR_MATH_MULTIPLY_ADD (see code in usd_reader_material). */
bNodeSocket *sock_current = nodeFindSocket(vector_math_node, SOCK_IN, "Vector");
bNodeSocket *sock_current = bke::nodeFindSocket(vector_math_node, SOCK_IN, "Vector");
bNodeLink *temp_link = traverse_channel(sock_current, SH_NODE_VECTOR_MATH);
if (temp_link && temp_link->fromnode->custom1 == NODE_VECTOR_MATH_MULTIPLY_ADD) {
vector_math_node = temp_link->fromnode;
}
bNodeSocket *sock_scale = nodeFindSocket(vector_math_node, SOCK_IN, "Vector_001");
bNodeSocket *sock_bias = nodeFindSocket(vector_math_node, SOCK_IN, "Vector_002");
bNodeSocket *sock_scale = bke::nodeFindSocket(vector_math_node, SOCK_IN, "Vector_001");
bNodeSocket *sock_bias = bke::nodeFindSocket(vector_math_node, SOCK_IN, "Vector_002");
const float *scale_value =
static_cast<bNodeSocketValueVector *>(sock_scale->default_value)->value;
const float *bias_value =
@ -288,7 +289,7 @@ static void create_usd_preview_surface_material(const USDExporterContext &usd_ex
}
/* Look for a connected uvmap node. */
if (bNodeSocket *socket = nodeFindSocket(input_node, SOCK_IN, "Vector")) {
if (bNodeSocket *socket = bke::nodeFindSocket(input_node, SOCK_IN, "Vector")) {
if (pxr::UsdShadeInput st_input = usd_shader.CreateInput(usdtokens::st,
pxr::SdfValueTypeNames->Float2))
{
@ -467,7 +468,7 @@ static void create_transform2d_shader(const USDExporterContext &usd_export_conte
}
if (mapping_node->custom1 != TEXMAP_TYPE_POINT) {
if (bNodeSocket *socket = nodeFindSocket(mapping_node, SOCK_IN, "Vector")) {
if (bNodeSocket *socket = bke::nodeFindSocket(mapping_node, SOCK_IN, "Vector")) {
create_uv_input(usd_export_context, socket, usd_material, usd_input, default_uv, reports);
}
return;
@ -487,19 +488,19 @@ static void create_transform2d_shader(const USDExporterContext &usd_export_conte
float loc[3] = {0.0f, 0.0f, 0.0f};
float rot[3] = {0.0f, 0.0f, 0.0f};
if (bNodeSocket *scale_socket = nodeFindSocket(mapping_node, SOCK_IN, "Scale")) {
if (bNodeSocket *scale_socket = bke::nodeFindSocket(mapping_node, SOCK_IN, "Scale")) {
copy_v3_v3(scale, ((bNodeSocketValueVector *)scale_socket->default_value)->value);
/* Ignore the Z scale. */
scale[2] = 1.0f;
}
if (bNodeSocket *loc_socket = nodeFindSocket(mapping_node, SOCK_IN, "Location")) {
if (bNodeSocket *loc_socket = bke::nodeFindSocket(mapping_node, SOCK_IN, "Location")) {
copy_v3_v3(loc, ((bNodeSocketValueVector *)loc_socket->default_value)->value);
/* Ignore the Z translation. */
loc[2] = 0.0f;
}
if (bNodeSocket *rot_socket = nodeFindSocket(mapping_node, SOCK_IN, "Rotation")) {
if (bNodeSocket *rot_socket = bke::nodeFindSocket(mapping_node, SOCK_IN, "Rotation")) {
copy_v3_v3(rot, ((bNodeSocketValueVector *)rot_socket->default_value)->value);
/* Ignore the X and Y rotations. */
rot[0] = 0.0f;
@ -528,7 +529,7 @@ static void create_transform2d_shader(const USDExporterContext &usd_export_conte
rot_input.Set(rot_val);
}
if (bNodeSocket *socket = nodeFindSocket(mapping_node, SOCK_IN, "Vector")) {
if (bNodeSocket *socket = bke::nodeFindSocket(mapping_node, SOCK_IN, "Vector")) {
if (pxr::UsdShadeInput in_input = transform2d_shader.CreateInput(
usdtokens::in, pxr::SdfValueTypeNames->Float2))
{

2
source/blender/io/wavefront_obj/exporter/obj_export_mtl.cc
View file

@ -50,7 +50,7 @@ static void copy_property_from_node(const eNodeSocketDatatype property_type,
if (!node) {
return;
}
const bNodeSocket *socket = nodeFindSocket(const_cast<bNode *>(node), SOCK_IN, identifier);
const bNodeSocket *socket = bke::nodeFindSocket(const_cast<bNode *>(node), SOCK_IN, identifier);
BLI_assert(socket && socket->type == property_type);
if (!socket) {
return;

12
source/blender/io/wavefront_obj/importer/obj_import_mtl.cc
View file

@ -36,7 +36,7 @@ static void set_property_of_socket(eNodeSocketDatatype property_type,
bNode *r_node)
{
BLI_assert(r_node);
bNodeSocket *socket{nodeFindSocket(r_node, SOCK_IN, socket_id)};
bNodeSocket *socket{bke::nodeFindSocket(r_node, SOCK_IN, socket_id)};
BLI_assert(socket && socket->type == property_type);
switch (property_type) {
case SOCK_FLOAT: {
@ -155,7 +155,7 @@ const float node_locy_step = 300.0f;
/* Add a node of the given type at the given location. */
static bNode *add_node(bNodeTree *ntree, int type, float x, float y)
{
bNode *node = nodeAddStaticNode(nullptr, ntree, type);
bNode *node = bke::nodeAddStaticNode(nullptr, ntree, type);
node->locx = x;
node->locy = y;
return node;
@ -167,10 +167,10 @@ static void link_sockets(bNodeTree *ntree,
bNode *to_node,
const char *to_node_id)
{
bNodeSocket *from_sock{nodeFindSocket(from_node, SOCK_OUT, from_node_id)};
bNodeSocket *to_sock{nodeFindSocket(to_node, SOCK_IN, to_node_id)};
bNodeSocket *from_sock{bke::nodeFindSocket(from_node, SOCK_OUT, from_node_id)};
bNodeSocket *to_sock{bke::nodeFindSocket(to_node, SOCK_IN, to_node_id)};
BLI_assert(from_sock && to_sock);
nodeAddLink(ntree, from_node, from_sock, to_node, to_sock);
bke::nodeAddLink(ntree, from_node, from_sock, to_node, to_sock);
}
static void set_bsdf_socket_values(bNode *bsdf, Material *mat, const MTLMaterial &mtl_mat)
@ -424,7 +424,7 @@ bNodeTree *create_mtl_node_tree(Main *bmain,
set_bsdf_socket_values(bsdf, mat, mtl);
add_image_textures(bmain, ntree, bsdf, mat, mtl, relative_paths);
link_sockets(ntree, bsdf, "BSDF", output, "Surface");
nodeSetActive(ntree, output);
bke::nodeSetActive(ntree, output);
return ntree;
}

6
source/blender/makesdna/DNA_node_tree_interface_types.h
View file

@ -22,15 +22,17 @@
#ifdef __cplusplus
namespace blender::bke {
class bNodeTreeInterfaceRuntime;
struct bNodeSocketType;
}
using bNodeTreeInterfaceRuntimeHandle = blender::bke::bNodeTreeInterfaceRuntime;
using bNodeSocketTypeHandle = blender::bke::bNodeSocketType;
#else
typedef struct bNodeTreeInterfaceRuntimeHandle bNodeTreeInterfaceRuntimeHandle;
typedef struct bNodeSocketTypeHandle bNodeSocketTypeHandle;
#endif
struct bContext;
struct bNodeSocket;
struct bNodeSocketType;
struct bNodeTreeInterfaceItem;
struct bNodeTreeInterfacePanel;
struct bNodeTreeInterfaceSocket;
@ -93,7 +95,7 @@ typedef struct bNodeTreeInterfaceSocket {
IDProperty *properties;
#ifdef __cplusplus
bNodeSocketType *socket_typeinfo() const;
bNodeSocketTypeHandle *socket_typeinfo() const;
blender::ColorGeometry4f socket_color() const;
/**

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

@ -39,6 +39,10 @@ struct bNodeTreeInterfaceCache;
namespace blender::bke {
class bNodeTreeZones;
class bNodeTreeZone;
struct bNodeInstanceHash;
struct bNodeTreeType;
struct bNodeType;
struct bNodeSocketType;
} // namespace blender::bke
namespace blender::bke {
struct RuntimeNodeEnumItems;
@ -47,11 +51,19 @@ using bNodeTreeRuntimeHandle = blender::bke::bNodeTreeRuntime;
using bNodeRuntimeHandle = blender::bke::bNodeRuntime;
using bNodeSocketRuntimeHandle = blender::bke::bNodeSocketRuntime;
using RuntimeNodeEnumItemsHandle = blender::bke::RuntimeNodeEnumItems;
using NodeInstanceHashHandle = blender::bke::bNodeInstanceHash;
using bNodeTreeTypeHandle = blender::bke::bNodeTreeType;
using bNodeTypeHandle = blender::bke::bNodeType;
using bNodeSocketTypeHandle = blender::bke::bNodeSocketType;
#else
typedef struct bNodeTreeRuntimeHandle bNodeTreeRuntimeHandle;
typedef struct bNodeRuntimeHandle bNodeRuntimeHandle;
typedef struct bNodeSocketRuntimeHandle bNodeSocketRuntimeHandle;
typedef struct RuntimeNodeEnumItemsHandle RuntimeNodeEnumItemsHandle;
typedef struct NodeInstanceHashHandle NodeInstanceHashHandle;
typedef struct bNodeTreeTypeHandle bNodeTreeTypeHandle;
typedef struct bNodeTypeHandle bNodeTypeHandle;
typedef struct bNodeSocketTypeHandle bNodeSocketTypeHandle;
#endif
struct AnimData;
@ -65,10 +77,8 @@ struct Material;
struct PreviewImage;
struct Tex;
struct bGPdata;
struct bNodeInstanceHash;
struct bNodeLink;
struct bNodePreview;
struct bNodeType;
struct bNode;
struct NodeEnumDefinition;
@ -140,7 +150,7 @@ typedef struct bNodeSocket {
/** Input/output type. */
short in_out;
/** Runtime type information. */
struct bNodeSocketType *typeinfo;
bNodeSocketTypeHandle *typeinfo;
/** Runtime type identifier. */
char idname[64];
@ -365,7 +375,7 @@ typedef struct bNode {
char idname[64];
/** Type information retrieved from the #idname. TODO: Move to runtime data. */
struct bNodeType *typeinfo;
bNodeTypeHandle *typeinfo;
/**
* Integer type used for builtin nodes, allowing cheaper lookup and changing ID names with
@ -653,7 +663,7 @@ typedef struct bNodeTree {
ID *owner_id;
/** Runtime type information. */
struct bNodeTreeType *typeinfo;
bNodeTreeTypeHandle *typeinfo;
/** Runtime type identifier. */
char idname[64];
/** User-defined description of the node tree. */
@ -682,7 +692,7 @@ typedef struct bNodeTree {
/** Precision used by the GPU execution of the compositor tree. */
int precision DNA_DEPRECATED;
/** #NodeGroupColorTag. */
/** #blender::bke::NodeGroupColorTag. */
int color_tag;
char _pad[4];
@ -701,7 +711,7 @@ typedef struct bNodeTree {
* Node preview hash table.
* Only available in base node trees (e.g. scene->node_tree).
*/
struct bNodeInstanceHash *previews;
NodeInstanceHashHandle *previews;
/**
* Defines the node tree instance to use for the "active" context,
* in case multiple different editors are used and make context ambiguous.

14
source/blender/makesrna/RNA_enum_types.hh
View file

@ -11,13 +11,13 @@
#include "RNA_types.hh"
struct ID;
struct bNodeSocketType;
struct bNodeTreeType;
struct bNodeType;
struct PointerRNA;
struct PropertyRNA;
struct bContext;
namespace blender::bke {
struct bNodeTreeType;
struct bNodeType;
struct bNodeSocketType;
struct RuntimeNodeEnumItems;
}
@ -47,15 +47,15 @@ extern const IDFilterEnumPropertyItem rna_enum_id_type_filter_items[];
/* API calls */
int rna_node_tree_idname_to_enum(const char *idname);
bNodeTreeType *rna_node_tree_type_from_enum(int value);
blender::bke::bNodeTreeType *rna_node_tree_type_from_enum(int value);
const EnumPropertyItem *rna_node_tree_type_itemf(void *data,
bool (*poll)(void *data, bNodeTreeType *),
bool (*poll)(void *data, blender::bke::bNodeTreeType *),
bool *r_free);
int rna_node_socket_idname_to_enum(const char *idname);
bNodeSocketType *rna_node_socket_type_from_enum(int value);
blender::bke::bNodeSocketType *rna_node_socket_type_from_enum(int value);
const EnumPropertyItem *rna_node_socket_type_itemf(void *data,
bool (*poll)(void *data, bNodeSocketType *),
bool (*poll)(void *data, blender::bke::bNodeSocketType *),
bool *r_free);
const EnumPropertyItem *rna_TransformOrientation_itemf(bContext *C,

4
source/blender/makesrna/intern/rna_main_api.cc
View file

@ -290,9 +290,9 @@ static bNodeTree *rna_Main_nodetree_new(Main *bmain, const char *name, int type)
char safe_name[MAX_ID_NAME - 2];
rna_idname_validate(name, safe_name);
bNodeTreeType *typeinfo = rna_node_tree_type_from_enum(type);
blender::bke::bNodeTreeType *typeinfo = rna_node_tree_type_from_enum(type);
if (typeinfo) {
bNodeTree *ntree = ntreeAddTree(bmain, safe_name, typeinfo->idname);
bNodeTree *ntree = blender::bke::ntreeAddTree(bmain, safe_name, typeinfo->idname);
ED_node_tree_propagate_change(nullptr, bmain, ntree);
id_us_min(&ntree->id);

2
source/blender/makesrna/intern/rna_material.cc
View file

@ -160,7 +160,7 @@ static void rna_Material_active_paint_texture_index_update(bContext *C, PointerR
bNode *node = BKE_texpaint_slot_material_find_node(ma, ma->paint_active_slot);
if (node) {
nodeSetActive(ma->nodetree, node);
blender::bke::nodeSetActive(ma->nodetree, node);
}
}

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

@ -102,7 +102,7 @@ static void rna_NodeSocket_draw_color(bContext *C,
RNA_parameter_list_free(&list);
}
static void rna_NodeSocket_draw_color_simple(const bNodeSocketType *socket_type, float *r_color)
static void rna_NodeSocket_draw_color_simple(const blender::bke::bNodeSocketType *socket_type, float *r_color)
{
ParameterList list;
FunctionRNA *func;
@ -124,7 +124,7 @@ static void rna_NodeSocket_draw_color_simple(const bNodeSocketType *socket_type,
static bool rna_NodeSocket_unregister(Main * /*bmain*/, StructRNA *type)
{
bNodeSocketType *st = static_cast<bNodeSocketType *>(RNA_struct_blender_type_get(type));
blender::bke::bNodeSocketType *st = static_cast<blender::bke::bNodeSocketType *>(RNA_struct_blender_type_get(type));
if (!st) {
return false;
}
@ -132,7 +132,7 @@ static bool rna_NodeSocket_unregister(Main * /*bmain*/, StructRNA *type)
RNA_struct_free_extension(type, &st->ext_socket);
RNA_struct_free(&BLENDER_RNA, type);
nodeUnregisterSocketType(st);
blender::bke::nodeUnregisterSocketType(st);
/* update while blender is running */
WM_main_add_notifier(NC_NODE | NA_EDITED, nullptr);
@ -147,12 +147,12 @@ static StructRNA *rna_NodeSocket_register(Main * /*bmain*/,
StructCallbackFunc call,
StructFreeFunc free)
{
bNodeSocketType *st, dummy_st;
blender::bke::bNodeSocketType *st, dummy_st;
bNodeSocket dummy_sock;
bool have_function[3];
/* setup dummy socket & socket type to store static properties in */
memset(&dummy_st, 0, sizeof(bNodeSocketType));
memset(&dummy_st, 0, sizeof(blender::bke::bNodeSocketType));
dummy_st.type = SOCK_CUSTOM;
memset(&dummy_sock, 0, sizeof(bNodeSocket));
@ -174,16 +174,16 @@ static StructRNA *rna_NodeSocket_register(Main * /*bmain*/,
}
/* check if we have registered this socket type before */
st = nodeSocketTypeFind(dummy_st.idname);
st = blender::bke::nodeSocketTypeFind(dummy_st.idname);
if (!st) {
/* create a new node socket type */
st = static_cast<bNodeSocketType *>(MEM_mallocN(sizeof(bNodeSocketType), "node socket type"));
st = static_cast<blender::bke::bNodeSocketType *>(MEM_mallocN(sizeof(blender::bke::bNodeSocketType), "node socket type"));
memcpy(st, &dummy_st, sizeof(dummy_st));
nodeRegisterSocketType(st);
blender::bke::nodeRegisterSocketType(st);
}
st->free_self = (void (*)(bNodeSocketType *stype))MEM_freeN;
st->free_self = (void (*)(blender::bke::bNodeSocketType *stype))MEM_freeN;
/* if RNA type is already registered, unregister first */
if (st->ext_socket.srna) {
@ -230,7 +230,7 @@ static std::optional<std::string> rna_NodeSocket_path(const PointerRNA *ptr)
int socketindex;
char name_esc[sizeof(node->name) * 2];
nodeFindNode(ntree, sock, &node, &socketindex);
blender::bke::nodeFindNode(ntree, sock, &node, &socketindex);
BLI_str_escape(name_esc, node->name, sizeof(name_esc));
@ -252,7 +252,7 @@ static PointerRNA rna_NodeSocket_node_get(PointerRNA *ptr)
bNodeSocket *sock = static_cast<bNodeSocket *>(ptr->data);
bNode *node;
nodeFindNode(ntree, sock, &node, nullptr);
blender::bke::nodeFindNode(ntree, sock, &node, nullptr);
PointerRNA r_ptr = RNA_pointer_create(&ntree->id, &RNA_Node, node);
return r_ptr;
@ -263,12 +263,12 @@ static void rna_NodeSocket_type_set(PointerRNA *ptr, int value)
bNodeTree *ntree = reinterpret_cast<bNodeTree *>(ptr->owner_id);
bNodeSocket *sock = static_cast<bNodeSocket *>(ptr->data);
bNode *node;
nodeFindNode(ntree, sock, &node, nullptr);
blender::bke::nodeFindNode(ntree, sock, &node, nullptr);
if (node->type != NODE_CUSTOM) {
/* Can't change the socket type on built-in nodes like this. */
return;
}
nodeModifySocketTypeStatic(ntree, node, sock, value, 0);
blender::bke::nodeModifySocketTypeStatic(ntree, node, sock, value, 0);
}
static void rna_NodeSocket_update(Main *bmain, Scene * /*scene*/, PointerRNA *ptr)
@ -303,7 +303,7 @@ static void rna_NodeSocket_hide_set(PointerRNA *ptr, bool value)
bNodeTree *ntree = reinterpret_cast<bNodeTree *>(ptr->owner_id);
bNode *node;
nodeFindNode(ntree, sock, &node, nullptr);
blender::bke::nodeFindNode(ntree, sock, &node, nullptr);
/* The Reroute node is the socket itself, do not hide this. */
if (node->is_reroute()) {
@ -340,7 +340,7 @@ static void rna_NodeSocketStandard_draw_color(
static void rna_NodeSocketStandard_draw_color_simple(StructRNA *type, float r_color[4])
{
const bNodeSocketType *typeinfo = static_cast<const bNodeSocketType *>(
const blender::bke::bNodeSocketType *typeinfo = static_cast<const blender::bke::bNodeSocketType *>(
RNA_struct_blender_type_get(type));
typeinfo->draw_color_simple(typeinfo, r_color);
}

Some files were not shown because too many files have changed in this diff Show more