Further improved code style consistency; Added extensive additional checks in NodeArea::LoadFromJson, which now returns a bool indicating success; Added GetConnectionCount() and GetRerouteConnectionCount() functions to NodeArea; Fixed an issue where NodeArea::TryToConnect could incorrectly connect two output sockets; Introduces a mechanism to validate the structure of nodes loaded from JSON against their current C++ class definition, specifically checking for mismatches in the number of input and output sockets, incorrect nodes will now be omitted; BREAKING The signature of Node::FromJson has changed from virtual void FromJson(Json::Value Json) to virtual bool FromJson(Json::Value Json), any classes inheriting from Node and overriding FromJson must update their signature and return true on success or false on failure (e.g., validation failure).

Author: Azzinoth

SubSystems/VisualNodeArea/VisualNodeArea.cpp

@@ -359,27 +359,37 @@ void NodeArea::CopyNodesTo(NodeArea* SourceNodeArea, NodeArea* TargetNodeArea)
 	}
 }
 
-void NodeArea::LoadFromJson(std::string JsonText)
+bool NodeArea::LoadFromJson(std::string JsonText)
 {
 	if (JsonText.find("{") == std::string::npos || JsonText.find("}") == std::string::npos || JsonText.find(":") == std::string::npos)
-		return;
+		return false;
 
-	Json::Value root;
-	JSONCPP_STRING err;
-	Json::CharReaderBuilder builder;
+	Json::Value Root;
+	JSONCPP_STRING Error;
+	Json::CharReaderBuilder Builder;
 
-	const std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
-	if (!reader->parse(JsonText.c_str(), JsonText.c_str() + JsonText.size(), &root, &err))
-		return;
+	const std::unique_ptr<Json::CharReader> Reader(Builder.newCharReader());
+	if (!Reader->parse(JsonText.c_str(), JsonText.c_str() + JsonText.size(), &Root, &Error))
+		return false;
 
-	if (!root.isMember("nodes"))
-		return;
+	if (!Root.isMember("nodes"))
+		return false;
+
+	if (!Root["nodes"].isObject())
+		return false;
 
 	std::unordered_map<std::string, Node*> LoadedNodes;
-	std::vector<Json::String> NodesList = root["nodes"].getMemberNames();
+	std::vector<Json::String> NodesList = Root["nodes"].getMemberNames();
 	for (size_t i = 0; i < NodesList.size(); i++)
 	{
-		std::string NodeType = root["nodes"][std::to_string(i)]["nodeType"].asCString();
+		std::string NodeKey = std::to_string(i);
+		if (!Root["nodes"][NodeKey].isMember("nodeType"))
+			continue;
+
+		if (!Root["nodes"][NodeKey]["nodeType"].isString())
+			continue;
+
+		std::string NodeType = Root["nodes"][NodeKey]["nodeType"].asCString();
 		Node* NewNode = NODE_FACTORY.CreateNode(NodeType);
 		if (NewNode == nullptr)
 		{
@@ -393,7 +403,14 @@ void NodeArea::LoadFromJson(std::string JsonText)
 			}
 		}
 
-		NewNode->FromJson(root["nodes"][std::to_string(i)]);
+		bool bResult = NewNode->FromJson(Root["nodes"][NodeKey]);
+		if (!bResult)
+		{
+			// TO-DO: Implement a more robust user notification system (e.g., logging, UI warning).
+			delete NewNode;
+			NewNode = nullptr;
+			continue;
+		}
 
 		if (NewNode != nullptr)
 		{
@@ -402,102 +419,173 @@ void NodeArea::LoadFromJson(std::string JsonText)
 		}
 	}
 
-	std::vector<Json::String> ConnectionsList = root["connections"].getMemberNames();
-	for (size_t i = 0; i < ConnectionsList.size(); i++)
+	if (Root.isMember("connections"))
 	{
-		std::string InSocketID = root["connections"][ConnectionsList[i]]["in"]["socket_ID"].asCString();
-		std::string InNodeID = root["connections"][ConnectionsList[i]]["in"]["node_ID"].asCString();
+		if (!Root["connections"].isObject())
+			return false;
+
+		std::vector<Json::String> ConnectionsList = Root["connections"].getMemberNames();
+		for (size_t i = 0; i < ConnectionsList.size(); i++)
+		{
+			if (!Root["connections"][ConnectionsList[i]].isObject())
+				return false;
+			const Json::Value& ConnectionData = Root["connections"][ConnectionsList[i]];
+
+			// TO-DO: Implement a more robust user notification system (e.g., logging, UI warning).
+			if (!ConnectionData.isMember("in") || !ConnectionData.isMember("out") || !ConnectionData["in"].isObject() || !ConnectionData["out"].isObject())
+				continue;
 
-		std::string OutSocketID = root["connections"][ConnectionsList[i]]["out"]["socket_ID"].asCString();
-		std::string OutNodeID = root["connections"][ConnectionsList[i]]["out"]["node_ID"].asCString();
+			if (!ConnectionData["in"].isMember("socket_ID") || !ConnectionData["in"]["socket_ID"].isString() ||
+				!ConnectionData["in"].isMember("node_ID") || !ConnectionData["in"]["node_ID"].isString() ||
+				!ConnectionData["out"].isMember("socket_ID") || !ConnectionData["out"]["socket_ID"].isString() ||
+				!ConnectionData["out"].isMember("node_ID") || !ConnectionData["out"]["node_ID"].isString())
+			{
+				continue;
+			}
+
+			std::string InSocketID = ConnectionData["in"]["socket_ID"].asCString();
+			std::string InNodeID = ConnectionData["in"]["node_ID"].asCString();
 
-		if (LoadedNodes.find(OutNodeID) != LoadedNodes.end() && LoadedNodes.find(InNodeID) != LoadedNodes.end())
-			if (!TryToConnect(LoadedNodes[OutNodeID], OutSocketID, LoadedNodes[InNodeID], InSocketID))
+			std::string OutSocketID = ConnectionData["out"]["socket_ID"].asCString();
+			std::string OutNodeID = ConnectionData["out"]["node_ID"].asCString();
+
+			// TO-DO: Implement a more robust user notification system (e.g., logging, UI warning).
+			if (LoadedNodes.find(InNodeID) == LoadedNodes.end() || LoadedNodes.find(OutNodeID) == LoadedNodes.end())
 				continue;
 
-		Connection* NewConnection = Connections.back();
+			if (LoadedNodes.find(OutNodeID) != LoadedNodes.end() && LoadedNodes.find(InNodeID) != LoadedNodes.end())
+				if (!TryToConnect(LoadedNodes[OutNodeID], OutSocketID, LoadedNodes[InNodeID], InSocketID))
+					continue;
 
-		// First pass to fill information that does not depend on other reroutes.
-		std::vector<Json::String> RerouteList = root["connections"][ConnectionsList[i]]["reroute_connections"].getMemberNames();
-		for (size_t j = 0; j < RerouteList.size(); j++)
-		{
-			RerouteNode* NewReroute = new RerouteNode();
-			std::string ID = root["connections"][ConnectionsList[i]]["reroute_connections"][std::to_string(j)]["reroute_ID"].asCString();
-			NewReroute->ID = ID;
-			NewReroute->Parent = NewConnection;
+			Connection* NewConnection = Connections.back();
 
-			NewReroute->Position.x = root["connections"][ConnectionsList[i]]["reroute_connections"][std::to_string(j)]["position_x"].asFloat();
-			NewReroute->Position.y = root["connections"][ConnectionsList[i]]["reroute_connections"][std::to_string(j)]["position_y"].asFloat();
+			if (NewConnection == nullptr)
+				continue;
 
-			NewConnection->RerouteNodes.push_back(NewReroute);
-		}
+			if (!ConnectionData.isMember("reroute_connections"))
+				continue;
 
-		// Second pass to fill pointers.
-		for (size_t j = 0; j < RerouteList.size(); j++)
-		{
-			std::string BeginSocketID = root["connections"][ConnectionsList[i]]["reroute_connections"][std::to_string(j)]["begin_socket_ID"].asCString();
-			if (!BeginSocketID.empty())
+			// First pass to fill information that does not depend on other reroutes.
+			std::vector<Json::String> RerouteList = ConnectionData["reroute_connections"].getMemberNames();
+			for (size_t j = 0; j < RerouteList.size(); j++)
 			{
-				NodeSocket* BeginSocket = NewConnection->Out;
-				if (BeginSocketID == BeginSocket->GetID())
-					NewConnection->RerouteNodes[j]->BeginSocket = BeginSocket;
-			}
+				const Json::Value& CurrentReroute = ConnectionData["reroute_connections"][std::to_string(j)];
+				if (!CurrentReroute.isMember("reroute_ID") || !CurrentReroute.isMember("position_x") || !CurrentReroute.isMember("position_y"))
+					continue;
 
-			std::string EndSocketID = root["connections"][ConnectionsList[i]]["reroute_connections"][std::to_string(j)]["end_socket_ID"].asCString();
-			if (!EndSocketID.empty())
-			{
-				NodeSocket* EndSocket = NewConnection->In;
-				if (EndSocketID == EndSocket->GetID())
-					NewConnection->RerouteNodes[j]->EndSocket = EndSocket;
+				if (!CurrentReroute["reroute_ID"].isString() || !CurrentReroute["position_x"].isNumeric() || !CurrentReroute["position_y"].isNumeric())
+					continue;
+
+				RerouteNode* NewReroute = new RerouteNode();
+				NewReroute->ID = CurrentReroute["reroute_ID"].asCString();
+				NewReroute->Parent = NewConnection;
+
+				NewReroute->Position.x = CurrentReroute["position_x"].asFloat();
+				NewReroute->Position.y = CurrentReroute["position_y"].asFloat();
+
+				NewConnection->RerouteNodes.push_back(NewReroute);
 			}
 
-			std::string BeginRerouteID = root["connections"][ConnectionsList[i]]["reroute_connections"][std::to_string(j)]["begin_reroute_ID"].asCString();
-			if (!BeginRerouteID.empty())
+			// Second pass to fill pointers.
+			for (size_t j = 0; j < RerouteList.size(); j++)
 			{
-				RerouteNode* BeginReroute = nullptr;
-				for (size_t k = 0; k < NewConnection->RerouteNodes.size(); k++)
+				const Json::Value& CurrentReroute = ConnectionData["reroute_connections"][std::to_string(j)];
+				if (!CurrentReroute.isMember("begin_socket_ID") || !CurrentReroute.isMember("end_socket_ID") || !CurrentReroute.isMember("begin_reroute_ID") || !CurrentReroute.isMember("end_reroute_ID"))
+					continue;
+
+				if (!CurrentReroute["begin_socket_ID"].isString() || !CurrentReroute["end_socket_ID"].isString() || !CurrentReroute["begin_reroute_ID"].isString() || !CurrentReroute["end_reroute_ID"].isString())
+					continue;
+
+				std::string BeginSocketID = CurrentReroute["begin_socket_ID"].asCString();
+				if (!BeginSocketID.empty())
+				{
+					NodeSocket* BeginSocket = NewConnection->Out;
+					if (BeginSocketID == BeginSocket->GetID())
+						NewConnection->RerouteNodes[j]->BeginSocket = BeginSocket;
+				}
+
+				std::string EndSocketID = CurrentReroute["end_socket_ID"].asCString();
+				if (!EndSocketID.empty())
+				{
+					NodeSocket* EndSocket = NewConnection->In;
+					if (EndSocketID == EndSocket->GetID())
+						NewConnection->RerouteNodes[j]->EndSocket = EndSocket;
+				}
+
+				std::string BeginRerouteID = CurrentReroute["begin_reroute_ID"].asCString();
+				if (!BeginRerouteID.empty())
 				{
-					if (BeginRerouteID == NewConnection->RerouteNodes[k]->ID)
-						BeginReroute = NewConnection->RerouteNodes[k];
+					RerouteNode* BeginReroute = nullptr;
+					for (size_t k = 0; k < NewConnection->RerouteNodes.size(); k++)
+					{
+						if (BeginRerouteID == NewConnection->RerouteNodes[k]->ID)
+							BeginReroute = NewConnection->RerouteNodes[k];
+					}
+
+					if (BeginReroute != nullptr)
+						NewConnection->RerouteNodes[j]->BeginReroute = BeginReroute;
 				}
 
-				if (BeginReroute != nullptr)
-					NewConnection->RerouteNodes[j]->BeginReroute = BeginReroute;
+				std::string EndRerouteID = CurrentReroute["end_reroute_ID"].asCString();
+				if (!EndRerouteID.empty())
+				{
+					RerouteNode* EndReroute = nullptr;
+					for (size_t k = 0; k < NewConnection->RerouteNodes.size(); k++)
+					{
+						if (EndRerouteID == NewConnection->RerouteNodes[k]->ID)
+							EndReroute = NewConnection->RerouteNodes[k];
+					}
+
+					if (EndReroute != nullptr)
+						NewConnection->RerouteNodes[j]->EndReroute = EndReroute;
+				}
 			}
 
-			std::string EndRerouteID = root["connections"][ConnectionsList[i]]["reroute_connections"][std::to_string(j)]["end_reroute_ID"].asCString();
-			if (!EndRerouteID.empty())
+			for (size_t i = 0; i < NewConnection->RerouteNodes.size(); i++)
 			{
-				RerouteNode* EndReroute = nullptr;
-				for (size_t k = 0; k < NewConnection->RerouteNodes.size(); k++)
+				// If any of the reroute nodes are invalid, we need to delete all of them.
+				if (!IsRerouteNodeValid(NewConnection->RerouteNodes[i]))
 				{
-					if (EndRerouteID == NewConnection->RerouteNodes[k]->ID)
-						EndReroute = NewConnection->RerouteNodes[k];
+					for (size_t j = 0; j < NewConnection->RerouteNodes.size(); j++)
+					{
+						delete NewConnection->RerouteNodes[j];
+						NewConnection->RerouteNodes.erase(NewConnection->RerouteNodes.begin() + j, NewConnection->RerouteNodes.begin() + j + 1);
+						j--;
+					}
+					break;
 				}
-
-				if (EndReroute != nullptr)
-					NewConnection->RerouteNodes[j]->EndReroute = EndReroute;
 			}
 		}
 	}
 
-	if (root.isMember("GroupComments"))
+	if (Root.isMember("GroupComments"))
 	{
-		std::vector<Json::String> GroupCommentsList = root["GroupComments"].getMemberNames();
+		if (!Root["GroupComments"].isObject())
+			return false;
+
+		std::vector<Json::String> GroupCommentsList = Root["GroupComments"].getMemberNames();
 		for (size_t i = 0; i < GroupCommentsList.size(); i++)
 		{
+			if (!Root["GroupComments"][std::to_string(i)].isObject())
+				return false;
+
 			GroupComment* NewGroupComment = new GroupComment();
-			NewGroupComment->FromJson(root["GroupComments"][std::to_string(i)]);
+			NewGroupComment->FromJson(Root["GroupComments"][std::to_string(i)]);
 			AddGroupComment(NewGroupComment);
 		}
 	}
 
-	if (root.isMember("renderOffset"))
+	if (Root.isMember("renderOffset"))
 	{
-		float OffsetX = root["renderOffset"]["x"].asFloat();
-		float OffsetY = root["renderOffset"]["y"].asFloat();
+		if (!Root["renderOffset"].isMember("x") || !Root["renderOffset"].isMember("y"))
+			return false;
+
+		float OffsetX = Root["renderOffset"]["x"].asFloat();
+		float OffsetY = Root["renderOffset"]["y"].asFloat();
 		SetRenderOffset(ImVec2(OffsetX, OffsetY));
 	}
+
+	return true;
 }
 
 void NodeArea::LoadFromFile(const char* FileName)

SubSystems/VisualNodeArea/VisualNodeArea.h

@@ -77,7 +77,7 @@ namespace VisNodeSys
 
 		std::string ToJson() const;
 		void SaveToFile(const char* FileName) const;
-		void LoadFromJson(std::string JsonText);
+		bool LoadFromJson(std::string JsonText);
 		void LoadFromFile(const char* FileName);
 		void SaveNodesToFile(const char* FileName, std::vector<Node*> Nodes);
 
@@ -140,6 +140,8 @@ namespace VisNodeSys
 		ImVec2 GetRenderedViewCenter() const;
 
 		// *********************** Connections ************************
+		size_t GetConnectionCount() const;
+
 		bool TryToConnect(const Node* OutNode, size_t OutNodeSocketIndex, const Node* InNode, size_t InNodeSocketIndex);
 		bool TryToConnect(const Node* OutNode, std::string OutSocketID, const Node* InNode, std::string InSocketID);
 
@@ -156,6 +158,8 @@ namespace VisNodeSys
 
 		bool GetConnectionStyle(Node* Node, bool bOutputSocket, size_t SocketIndex, ConnectionStyle& Style) const;
 		void SetConnectionStyle(Node* Node, bool bOutputSocket, size_t SocketIndex, ConnectionStyle NewStyle);
+
+		size_t GetRerouteConnectionCount() const;
 	private:
 		struct SocketEvent
 		{
@@ -297,6 +301,7 @@ namespace VisNodeSys
 		void ConnectionsDoubleMouseClick();
 		std::vector<ConnectionSegment> GetConnectionSegments(const Connection* Connection) const;
 		bool AddRerouteNode(Connection* Connection, size_t SegmentToDivide, ImVec2 Position);
+		bool IsRerouteNodeValid(const RerouteNode* RerouteNode);
 		bool IsMouseOverConnection(Connection* Connection, const int Steps, const float MaxDistance, ImVec2* CollisionPoint = nullptr);
 		bool IsMouseOverSegment(ImVec2 Begin, ImVec2 End, const int Steps, const float MaxDistance, ImVec2* CollisionPoint = nullptr);
 		bool IsPointInRegion(const ImVec2& Point, const ImVec2& RegionMin, const ImVec2& RegionMax);

SubSystems/VisualNodeArea/VisualNodeAreaInput.cpp

@@ -672,7 +672,7 @@ void NodeArea::KeyboardInputUpdate()
 		}
 	}
 
-	static bool WasCopiedToClipboard = false;
+	static bool bWasCopiedToClipboard = false;
 	if (ImGui::IsKeyDown(ImGuiKey_LeftCtrl) || ImGui::IsKeyDown(ImGuiKey_RightCtrl))
 	{
 		if (ImGui::IsKeyDown(ImGuiKey_C))
@@ -686,18 +686,18 @@ void NodeArea::KeyboardInputUpdate()
 		}
 		else if (ImGui::IsKeyDown(ImGuiKey_V))
 		{
-			if (!WasCopiedToClipboard)
+			if (!bWasCopiedToClipboard)
 			{
-				WasCopiedToClipboard = true;
+				bWasCopiedToClipboard = true;
 
 				const std::string NodesToImport = NODE_CORE.GetClipboardText();
-				Json::Value data;
+				Json::Value Data;
 
-				JSONCPP_STRING err;
-				const Json::CharReaderBuilder builder;
+				JSONCPP_STRING Error;
+				const Json::CharReaderBuilder Builder;
 
-				const std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
-				if (!reader->parse(NodesToImport.c_str(), NodesToImport.c_str() + NodesToImport.size(), &data, &err))
+				const std::unique_ptr<Json::CharReader> Reader(Builder.newCharReader());
+				if (!Reader->parse(NodesToImport.c_str(), NodesToImport.c_str() + NodesToImport.size(), &Data, &Error))
 					return;
 
 				NodeArea* NewNodeArea = new NodeArea();
@@ -760,7 +760,7 @@ void NodeArea::KeyboardInputUpdate()
 	}
 
 	if (!ImGui::IsKeyDown(ImGuiKey_V))
-		WasCopiedToClipboard = false;
+		bWasCopiedToClipboard = false;
 }
 
 Node* NodeArea::GetHovered() const