Differential D10290 Diff 33467 source/blender/blenkernel/intern/node.cc

Changeset View

Standalone View

source/blender/blenkernel/intern/node.cc

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Lines
#include "DNA_node_types.h"		#include "DNA_node_types.h"
#include "DNA_scene_types.h"		#include "DNA_scene_types.h"
#include "DNA_simulation_types.h"		#include "DNA_simulation_types.h"
#include "DNA_texture_types.h"		#include "DNA_texture_types.h"
#include "DNA_world_types.h"		#include "DNA_world_types.h"

#include "BLI_ghash.h"		#include "BLI_ghash.h"
#include "BLI_listbase.h"		#include "BLI_listbase.h"
		#include "BLI_map.hh"
#include "BLI_math.h"		#include "BLI_math.h"
#include "BLI_path_util.h"		#include "BLI_path_util.h"
#include "BLI_string.h"		#include "BLI_string.h"
#include "BLI_string_utils.h"		#include "BLI_string_utils.h"
#include "BLI_utildefines.h"		#include "BLI_utildefines.h"

#include "BLT_translation.h"		#include "BLT_translation.h"

Show All 33 Lines

/* Fallback types for undefined tree, nodes, sockets */		/* Fallback types for undefined tree, nodes, sockets */
static bNodeTreeType NodeTreeTypeUndefined;		static bNodeTreeType NodeTreeTypeUndefined;
bNodeType NodeTypeUndefined;		bNodeType NodeTypeUndefined;
bNodeSocketType NodeSocketTypeUndefined;		bNodeSocketType NodeSocketTypeUndefined;

static CLG_LogRef LOG = {"bke.node"};		static CLG_LogRef LOG = {"bke.node"};

		/* -------------------------------------------------------------------- */
		/** \name Runtime (Error Messages)
		* \{ */

		class bNodeTreeRuntime {
		public:
		blender::Map<const std::string, NodeWarning> error_messages;
		};

		static void nodetree_runtime_ensure(bNodeTree *ntree)
		{
		if (ntree->runtime == nullptr) {
		ntree->runtime = new bNodeTreeRuntime();
		}
		}

		void BKE_nodetree_error_message_add(bNodeTree *ntree,
		const Object *object,
		const char *modifier_name,
		const bNode *node,
		const eNodeWarningType type,
		const char *message)
		{
		nodetree_runtime_ensure(ntree);
		bNodeTreeRuntime *runtime = ntree->runtime;

		NodeWarning warning = {type, BLI_strdup(message), object, modifier_name};

		switch (type) {
		case NODE_WARNING_ERROR:
		CLOG_ERROR(
		&LOG, "Node Tree: \"%s\", Node: \"%s\", %s", ntree->id.name + 2, node->name, message);
		break;
		case NODE_WARNING_INFO:
		CLOG_INFO(
		&LOG, 2, "Node Tree: \"%s\", Node: \"%s\", %s", ntree->id.name + 2, node->name, message);
		break;
		}

		runtime->error_messages.add(node->name, warning);
		}

		void BKE_nodetree_error_messages_clear(bNodeTree *ntree)
		{
		bNodeTreeRuntime *runtime = ntree->runtime;
		if (runtime != nullptr) {
		runtime->error_messages.clear();
		runtime->error_messages.foreach_item([](const std::string UNUSED(node_name),
		NodeWarning warning) { MEM_freeN(warning.message); });
		}
		}

		const NodeWarning BKE_nodetree_error_message_get(const bNodeTree ntree, const bNode *node)
		{
		bNodeTreeRuntime *runtime = ntree->runtime;
		if (runtime == nullptr) {
		return nullptr;
		}

		const std::string node_name = std::string(node->name);
		if (runtime->error_messages.contains(node_name)) {
		return &runtime->error_messages.lookup(node_name);
		}

		return nullptr;
		}

		/** \} */

static void ntree_set_typeinfo(bNodeTree ntree, bNodeTreeType typeinfo);		static void ntree_set_typeinfo(bNodeTree ntree, bNodeTreeType typeinfo);
static void node_socket_copy(bNodeSocket sock_dst, const bNodeSocket sock_src, const int flag);		static void node_socket_copy(bNodeSocket sock_dst, const bNodeSocket sock_src, const int flag);
static void free_localized_node_groups(bNodeTree *ntree);		static void free_localized_node_groups(bNodeTree *ntree);
static void node_free_node(bNodeTree ntree, bNode node);		static void node_free_node(bNodeTree ntree, bNode node);
static void node_socket_interface_free(bNodeTree *UNUSED(ntree),		static void node_socket_interface_free(bNodeTree *UNUSED(ntree),
bNodeSocket *sock,		bNodeSocket *sock,
const bool do_id_user);		const bool do_id_user);

▲ Show 20 Lines • Show All 101 Lines • ▼ Show 20 Lines	if (node_dst->parent) {
new_pointers, node_dst->parent, nullptr);		new_pointers, node_dst->parent, nullptr);
}		}
}		}

BLI_ghash_free(new_pointers, nullptr, nullptr);		BLI_ghash_free(new_pointers, nullptr, nullptr);

/* node tree will generate its own interface type */		/* node tree will generate its own interface type */
ntree_dst->interface_type = nullptr;		ntree_dst->interface_type = nullptr;

		/* Don't copy error messages in the runtime struct.
		* They should be filled during execution anyway. */
		ntree_dst->runtime = nullptr;
}		}

static void ntree_free_data(ID *id)		static void ntree_free_data(ID *id)
{		{
bNodeTree ntree = (bNodeTree )id;		bNodeTree ntree = (bNodeTree )id;

/* XXX hack! node trees should not store execution graphs at all.		/* XXX hack! node trees should not store execution graphs at all.
* This should be removed when old tree types no longer require it.		* This should be removed when old tree types no longer require it.
Show All 37 Lines	static void ntree_free_data(ID *id)
/* free preview hash */		/* free preview hash */
if (ntree->previews) {		if (ntree->previews) {
BKE_node_instance_hash_free(ntree->previews, (bNodeInstanceValueFP)BKE_node_preview_free);		BKE_node_instance_hash_free(ntree->previews, (bNodeInstanceValueFP)BKE_node_preview_free);
}		}

if (ntree->id.tag & LIB_TAG_LOCALIZED) {		if (ntree->id.tag & LIB_TAG_LOCALIZED) {
BKE_libblock_free_data(&ntree->id, true);		BKE_libblock_free_data(&ntree->id, true);
}		}

		delete ntree->runtime;
		ntree->runtime = nullptr;
}		}

static void library_foreach_node_socket(LibraryForeachIDData data, bNodeSocket sock)		static void library_foreach_node_socket(LibraryForeachIDData data, bNodeSocket sock)
{		{
IDP_foreach_property(		IDP_foreach_property(
sock->prop, IDP_TYPE_FILTER_ID, BKE_lib_query_idpropertiesForeachIDLink_callback, data);		sock->prop, IDP_TYPE_FILTER_ID, BKE_lib_query_idpropertiesForeachIDLink_callback, data);

switch ((eNodeSocketDatatype)sock->type) {		switch ((eNodeSocketDatatype)sock->type) {
▲ Show 20 Lines • Show All 273 Lines • ▼ Show 20 Lines	static void ntree_blend_write(BlendWriter writer, ID id, const void *id_address)
if (ntree->id.us > 0 \|\| BLO_write_is_undo(writer)) {		if (ntree->id.us > 0 \|\| BLO_write_is_undo(writer)) {
/* Clean up, important in undo case to reduce false detection of changed datablocks. */		/* Clean up, important in undo case to reduce false detection of changed datablocks. */
ntree->init = 0; /* to set callbacks and force setting types */		ntree->init = 0; /* to set callbacks and force setting types */
ntree->is_updating = false;		ntree->is_updating = false;
ntree->typeinfo = nullptr;		ntree->typeinfo = nullptr;
ntree->interface_type = nullptr;		ntree->interface_type = nullptr;
ntree->progress = nullptr;		ntree->progress = nullptr;
ntree->execdata = nullptr;		ntree->execdata = nullptr;
		ntree->runtime = nullptr;

BLO_write_id_struct(writer, bNodeTree, id_address, &ntree->id);		BLO_write_id_struct(writer, bNodeTree, id_address, &ntree->id);

ntreeBlendWrite(writer, ntree);		ntreeBlendWrite(writer, ntree);
}		}
}		}

static void direct_link_node_socket(BlendDataReader reader, bNodeSocket sock)		static void direct_link_node_socket(BlendDataReader reader, bNodeSocket sock)
Show All 14 Lines	void ntreeBlendReadData(BlendDataReader reader, bNodeTree ntree)
/* note: writing and reading goes in sync, for speed */		/* note: writing and reading goes in sync, for speed */
ntree->init = 0; /* to set callbacks and force setting types */		ntree->init = 0; /* to set callbacks and force setting types */
ntree->is_updating = false;		ntree->is_updating = false;
ntree->typeinfo = nullptr;		ntree->typeinfo = nullptr;
ntree->interface_type = nullptr;		ntree->interface_type = nullptr;

ntree->progress = nullptr;		ntree->progress = nullptr;
ntree->execdata = nullptr;		ntree->execdata = nullptr;
		ntree->runtime = nullptr;

BLO_read_data_address(reader, &ntree->adt);		BLO_read_data_address(reader, &ntree->adt);
BKE_animdata_blend_read_data(reader, ntree->adt);		BKE_animdata_blend_read_data(reader, ntree->adt);

BLO_read_list(reader, &ntree->nodes);		BLO_read_list(reader, &ntree->nodes);
LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {		LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
node->typeinfo = nullptr;		node->typeinfo = nullptr;

▲ Show 20 Lines • Show All 4,347 Lines • Show Last 20 Lines