add a few vector converters

src/external/NodeEditor/src/NodeGeometry.cpp

@@ -256,7 +256,7 @@ widgetPosition() const
     if (w->sizePolicy().verticalPolicy() & QSizePolicy::ExpandFlag)
     {
       // If the widget wants to use as much vertical space as possible, place it immediately after the caption.
-      return QPointF(_spacing + portWidth(PortType::In), captionHeight());
+      return QPointF(_spacing + portWidth(PortType::In), captionHeight() + 5.0);
     }
     else
     {

src/noggit/Red/NodeEditor/NodeRegistry.hpp

@@ -12,11 +12,20 @@
 #include <noggit/Red/NodeEditor/Nodes/MathNode.hpp>
 #include <noggit/Red/NodeEditor/Nodes/MathUnaryNode.hpp>
 #include <noggit/Red/NodeEditor/Nodes/ColorMathNode.hpp>
+
 #include <noggit/Red/NodeEditor/Nodes/VectorMathNode.hpp>
 #include <noggit/Red/NodeEditor/Nodes/VectorScalarMathNode.hpp>
+#include <noggit/Red/NodeEditor/Nodes/Vector2DToXYNode.hpp>
+#include <noggit/Red/NodeEditor/Nodes/Vector3DToXYZNode.hpp>
+#include <noggit/Red/NodeEditor/Nodes/Vector4DToXYZWNode.hpp>
+#include <noggit/Red/NodeEditor/Nodes/XYtoVector2D.hpp>
+#include <noggit/Red/NodeEditor/Nodes/XYZtoVector3DNode.hpp>
+#include <noggit/Red/NodeEditor/Nodes/XYZWtoVector4DNode.hpp>
+
 #include <noggit/Red/NodeEditor/Nodes/MatrixMathNode.hpp>
 #include <noggit/Red/NodeEditor/Nodes/MatrixDecomposeNode.hpp>
 #include <noggit/Red/NodeEditor/Nodes/MatrixUnaryMathNode.hpp>
+#include <noggit/Red/NodeEditor/Nodes/MatrixRotateEulerNode.hpp>
 
 #include <noggit/Red/NodeEditor/Nodes/ConditionNode.hpp>
 #include <noggit/Red/NodeEditor/Nodes/LogicIfNode.hpp>
@@ -44,6 +53,7 @@
 #include <noggit/Red/NodeEditor/Nodes/GetVariableNode.hpp>
 #include <noggit/Red/NodeEditor/Nodes/SetVariableNode.hpp>
 #include <noggit/Red/NodeEditor/Nodes/DeleteVariableNode.hpp>
+#include <noggit/Red/NodeEditor/Nodes/MatrixNode.hpp>
 
 #include <noggit/Red/NodeEditor/Nodes/BaseNode.hpp>
 #include <noggit/Red/NodeEditor/Nodes/Data/GenericTypeConverter.hpp>
@@ -73,15 +83,24 @@ namespace noggit
           ret->registerModel<MathNode>("Math");
           ret->registerModel<MathUnaryNode>("Math");
           ret->registerModel<ColorMathNode>("Math");
+
           ret->registerModel<Vector2DMathNode>("Math//Vector");
           ret->registerModel<Vector3DMathNode>("Math//Vector");
           ret->registerModel<Vector4DMathNode>("Math//Vector");
           ret->registerModel<Vector2DScalarMathNode>("Math//Vector");
           ret->registerModel<Vector3DScalarMathNode>("Math//Vector");
           ret->registerModel<Vector4DScalarMathNode>("Math//Vector");
+          ret->registerModel<XYtoVector2DNode>("Math//Vector");
+          ret->registerModel<XYZtoVector3DNode>("Math//Vector");
+          ret->registerModel<XYZWtoVector4DNode>("Math//Vector");
+          ret->registerModel<Vector2DToXYNode>("Math//Vector");
+          ret->registerModel<Vector3DToXYZNode>("Math//Vector");
+          ret->registerModel<Vector4DToXYZWNode>("Math//Vector");
+
           ret->registerModel<MatrixMathNode>("Math//Matrix");
           ret->registerModel<MatrixDecomposeNode>("Math//Matrix");
           ret->registerModel<MatrixUnaryMathNode>("Math//Matrix");
+          ret->registerModel<MatrixRotateEulerNode>("Math//Matrix");
 
           ret->registerModel<DataConstantNode>("Data");
           ret->registerModel<GetVariableNode>("Data");
@@ -90,6 +109,7 @@ namespace noggit
           ret->registerModel<SetContextVariableNode>("Data");
           ret->registerModel<DeleteVariableNode>("Data");
           ret->registerModel<DeleteContextVariableNode>("Data");
+          ret->registerModel<MatrixNode>("Data");
 
           ret->registerModel<ConditionNode>("Logic");
           ret->registerModel<LogicBeginNode>("Logic//Flow");

src/noggit/Red/NodeEditor/Nodes/ColorMathNode.cpp

@@ -18,6 +18,8 @@ ColorMathNode::ColorMathNode()
   _operation = new QComboBox(&_embedded_widget);
   _operation->addItems({"Mix", "Add", "Subtract", "Multiply", "Divide"});
 
+  addWidgetTop(_operation);
+
   addPort<DecimalData>(PortType::In, "Factor<Decimal>", true);
   addDefaultWidget(_in_ports[0].data_type->default_widget(&_embedded_widget), PortType::In, 0);
   static_cast<QDoubleSpinBox*>(_in_ports[0].default_widget)->setRange(0.0, 1.0);

src/noggit/Red/NodeEditor/Nodes/MathUnaryNode.cpp

@@ -19,6 +19,8 @@ MathUnaryNode::MathUnaryNode()
   _operation = new QComboBox(&_embedded_widget);
   _operation->addItems({"Sin", "Cos", "Tan", "Asin", "Acos", "Atan", "Floor", "Ceil", "Log"});
 
+  addWidgetTop(_operation);
+
   QComboBox::connect(_operation, qOverload<int>(&QComboBox::currentIndexChanged)
       ,[this](int index)
      {

src/noggit/Red/NodeEditor/Nodes/MatrixMathNode.cpp

@@ -24,6 +24,7 @@ MatrixMathNode::MatrixMathNode()
      }
   );
 
+  addWidgetTop(_operation);
   addPort<Matrix4x4Data>(PortType::In, "Matrix4x4", true);
   addPort<Matrix4x4Data>(PortType::In, "Matrix4x4", true);
   addPort<Matrix4x4Data>(PortType::Out, "Matrix4x4", true);

src/noggit/Red/NodeEditor/Nodes/MatrixNode.cpp

@@ -0,0 +1,44 @@
+// This file is part of Noggit3, licensed under GNU General Public License (version 3).
+
+#include "MatrixNode.hpp"
+
+#include "BaseNode.inl"
+#include "Data/GenericData.hpp"
+
+using namespace noggit::Red::NodeEditor::Nodes;
+
+MatrixNode::MatrixNode()
+: BaseNode()
+{
+  setName("MatrixNode");
+  setCaption("Matrix");
+  _validation_state = NodeValidationState::Valid;
+
+  _operation = new QComboBox(&_embedded_widget);
+  _operation->addItems({"Identity", "Zero"});
+
+  addWidgetTop(_operation);
+  addPort<Matrix4x4Data>(PortType::Out, "Matrix4x4", true);
+}
+
+void MatrixNode::compute()
+{
+  _out_ports[0].out_value = std::make_shared<Matrix4x4Data>(_operation->currentIndex() ? glm::mat4(0.0) : glm::mat4(1.0));
+  Q_EMIT dataUpdated(0);
+}
+
+QJsonObject MatrixNode::save() const
+{
+  QJsonObject json_obj = BaseNode::save();
+
+  json_obj["operation"] = _operation->currentIndex();
+
+  return json_obj;
+}
+
+void MatrixNode::restore(const QJsonObject& json_obj)
+{
+  _operation->setCurrentIndex(json_obj["operation"].toInt());
+  BaseNode::restore(json_obj);
+}
+

src/noggit/Red/NodeEditor/Nodes/MatrixNode.hpp

@@ -0,0 +1,40 @@
+// This file is part of Noggit3, licensed under GNU General Public License (version 3).
+
+#ifndef NOGGIT_MATRIXNODE_HPP
+#define NOGGIT_MATRIXNODE_HPP
+
+#include "BaseNode.hpp"
+#include <QComboBox>
+
+using QtNodes::PortType;
+using QtNodes::PortIndex;
+using QtNodes::NodeData;
+using QtNodes::NodeDataType;
+using QtNodes::NodeDataModel;
+using QtNodes::NodeValidationState;
+
+
+namespace noggit
+{
+    namespace Red::NodeEditor::Nodes
+    {
+        class MatrixNode : public BaseNode
+        {
+        Q_OBJECT
+
+        public:
+            MatrixNode();
+            void compute() override;
+            QJsonObject save() const override;
+            void restore(QJsonObject const& json_obj) override;
+
+        private:
+            QComboBox* _operation;
+
+        };
+
+    }
+
+}
+
+#endif //NOGGIT_MATRIXNODE_HPP

src/noggit/Red/NodeEditor/Nodes/MatrixRotateEulerNode.cpp

@@ -0,0 +1,62 @@
+// This file is part of Noggit3, licensed under GNU General Public License (version 3).
+
+#include "MatrixRotateEulerNode.hpp"
+
+#include "BaseNode.inl"
+#include "Data/GenericData.hpp"
+#include <external/glm/gtx/transform.hpp>
+
+using namespace noggit::Red::NodeEditor::Nodes;
+
+MatrixRotateEulerNode::MatrixRotateEulerNode()
+: BaseNode()
+{
+  setName("MatrixRotateEulerNode");
+  setCaption("Matrix Rotate Euler");
+  _validation_state = NodeValidationState::Valid;
+
+  addPort<Matrix4x4Data>(PortType::In, "Matrix4x4", true);
+  addDefaultWidget(new QLabel(&_embedded_widget), PortType::In, 0);
+  addPort<Vector3DData>(PortType::In, "Vector3D", true);
+  addDefaultWidget(_in_ports[1].data_type->default_widget(&_embedded_widget), PortType::In, 0);
+  addPort<Matrix4x4Data>(PortType::Out, "Matrix4x4", true);
+}
+
+void MatrixRotateEulerNode::compute()
+{
+  glm::mat4 matrix = static_cast<Matrix4x4Data*>(_in_ports[0].in_value.lock().get())->value();
+  glm::vec3 rot_vector = static_cast<Vector3DData*>(_in_ports[1].in_value.lock().get())->value();
+
+  matrix = glm::rotate(matrix, glm::radians(rot_vector[0]), glm::vec3(1.0, 0.0, 0.0));
+  matrix = glm::rotate(matrix, glm::radians(rot_vector[1]), glm::vec3(0.0, 1.0, 0.0));
+  matrix = glm::rotate(matrix, glm::radians(rot_vector[2]), glm::vec3(0.0, 0.0, 1.0));
+
+  _out_ports[0].out_value = std::make_shared<Matrix4x4Data>(matrix);
+  Q_EMIT dataUpdated(0);
+}
+
+QJsonObject MatrixRotateEulerNode::save() const
+{
+  QJsonObject json_obj = BaseNode::save();
+  _in_ports[1].data_type->to_json(_in_ports[1].default_widget, json_obj, "rotation_vector");
+  return json_obj;
+}
+
+void MatrixRotateEulerNode::restore(const QJsonObject& json_obj)
+{
+  BaseNode::restore(json_obj);
+  _in_ports[1].data_type->from_json(_in_ports[1].default_widget, json_obj, "rotation_vector");
+}
+
+NodeValidationState MatrixRotateEulerNode::validate()
+{
+  if (!_in_ports[0].in_value.lock() || !_in_ports[1].in_value.lock())
+  {
+    setValidationState(NodeValidationState::Error);
+    setValidationMessage("Error: failed to evaluate input.");
+    return _validation_state;
+  }
+
+  return _validation_state;
+}
+

src/noggit/Red/NodeEditor/Nodes/MatrixRotateEulerNode.hpp

@@ -0,0 +1,39 @@
+// This file is part of Noggit3, licensed under GNU General Public License (version 3).
+
+#ifndef NOGGIT_MATRIXROTATEEULERNODE_HPP
+#define NOGGIT_MATRIXROTATEEULERNODE_HPP
+
+#include "BaseNode.hpp"
+
+using QtNodes::PortType;
+using QtNodes::PortIndex;
+using QtNodes::NodeData;
+using QtNodes::NodeDataType;
+using QtNodes::NodeDataModel;
+using QtNodes::NodeValidationState;
+
+
+namespace noggit
+{
+    namespace Red::NodeEditor::Nodes
+    {
+        class MatrixRotateEulerNode : public BaseNode
+        {
+        Q_OBJECT
+
+        public:
+            MatrixRotateEulerNode();
+            NodeValidationState validate() override;
+            void compute() override;
+            QJsonObject save() const override;
+            void restore(QJsonObject const& json_obj) override;
+
+        private:
+
+        };
+
+    }
+
+}
+
+#endif //NOGGIT_MATRIXROTATEEULERNODE_HPP

src/noggit/Red/NodeEditor/Nodes/MatrixUnaryMathNode.cpp

@@ -24,6 +24,7 @@ MatrixUnaryMathNode::MatrixUnaryMathNode()
      }
   );
 
+  addWidgetTop(_operation);
   addPort<Matrix4x4Data>(PortType::In, "Matrix4x4", true);
   addPort<Matrix4x4Data>(PortType::Out, "Matrix4x4", true);
 }

src/noggit/Red/NodeEditor/Nodes/Vector2DToXYNode.cpp

@@ -0,0 +1,46 @@
+// This file is part of Noggit3, licensed under GNU General Public License (version 3).
+
+#include "Vector2DToXYNode.hpp"
+
+
+#include "BaseNode.inl"
+#include "Data/GenericData.hpp"
+
+using namespace noggit::Red::NodeEditor::Nodes;
+
+Vector2DToXYNode::Vector2DToXYNode()
+    : BaseNode()
+{
+  setName("Vector2DToXYNode");
+  setCaption("Vector2D To XY");
+  _validation_state = NodeValidationState::Valid;
+
+  addPort<Vector2DData>(PortType::In, "Vector2D", true);
+
+  addPort<DecimalData>(PortType::Out, "X<Decimal>", true);
+  addPort<DecimalData>(PortType::Out, "Y<Decimal>", true);
+}
+
+void Vector2DToXYNode::compute()
+{
+  glm::vec2 vector = static_cast<Vector2DData*>(_in_ports[0].in_value.lock().get())->value();
+  _out_ports[0].out_value = std::make_shared<DecimalData>(vector.x);
+  _out_ports[1].out_value = std::make_shared<DecimalData>(vector.y);
+
+  Q_EMIT dataUpdated(0);
+  Q_EMIT dataUpdated(1);
+}
+
+NodeValidationState Vector2DToXYNode::validate()
+{
+
+  if (!static_cast<Vector2DData*>(_in_ports[0].in_value.lock().get()))
+  {
+    setValidationState(NodeValidationState::Error);
+    setValidationMessage("Error: failed to evaluate vector input.");
+    return _validation_state;
+  }
+
+  return _validation_state;
+}
+

src/noggit/Red/NodeEditor/Nodes/Vector2DToXYNode.hpp

@@ -0,0 +1,34 @@
+// This file is part of Noggit3, licensed under GNU General Public License (version 3).
+
+#ifndef NOGGIT_VECTOR2DTOXYNODE_HPP
+#define NOGGIT_VECTOR2DTOXYNODE_HPP
+
+#include "BaseNode.hpp"
+
+using QtNodes::PortType;
+using QtNodes::PortIndex;
+using QtNodes::NodeData;
+using QtNodes::NodeDataType;
+using QtNodes::NodeDataModel;
+using QtNodes::NodeValidationState;
+
+
+namespace noggit
+{
+    namespace Red::NodeEditor::Nodes
+    {
+        class Vector2DToXYNode : public BaseNode
+        {
+        Q_OBJECT
+
+        public:
+            Vector2DToXYNode();
+            NodeValidationState validate() override;
+            void compute() override;
+        };
+
+    }
+
+}
+
+#endif //NOGGIT_VECTOR2DTOXYNODE_HPP

src/noggit/Red/NodeEditor/Nodes/Vector3DToXYZNode.cpp

@@ -0,0 +1,48 @@
+// This file is part of Noggit3, licensed under GNU General Public License (version 3).
+
+#include "Vector3DToXYZNode.hpp"
+
+#include "BaseNode.inl"
+#include "Data/GenericData.hpp"
+
+using namespace noggit::Red::NodeEditor::Nodes;
+
+Vector3DToXYZNode::Vector3DToXYZNode()
+: BaseNode()
+{
+  setName("Vector3DToXYZNode");
+  setCaption("Vector3D To XYZ");
+  _validation_state = NodeValidationState::Valid;
+
+  addPort<Vector3DData>(PortType::In, "Vector3D", true);
+
+  addPort<DecimalData>(PortType::Out, "X<Decimal>", true);
+  addPort<DecimalData>(PortType::Out, "Y<Decimal>", true);
+  addPort<DecimalData>(PortType::Out, "Z<Decimal>", true);
+}
+
+void Vector3DToXYZNode::compute()
+{
+  glm::vec3 vector = static_cast<Vector3DData*>(_in_ports[0].in_value.lock().get())->value();
+  _out_ports[0].out_value = std::make_shared<DecimalData>(vector.x);
+  _out_ports[1].out_value = std::make_shared<DecimalData>(vector.y);
+  _out_ports[2].out_value = std::make_shared<DecimalData>(vector.z);
+
+  Q_EMIT dataUpdated(0);
+  Q_EMIT dataUpdated(1);
+  Q_EMIT dataUpdated(3);
+}
+
+NodeValidationState Vector3DToXYZNode::validate()
+{
+
+  if (!static_cast<Vector3DData*>(_in_ports[0].in_value.lock().get()))
+  {
+    setValidationState(NodeValidationState::Error);
+    setValidationMessage("Error: failed to evaluate vector input.");
+    return _validation_state;
+  }
+
+  return _validation_state;
+}
+

src/noggit/Red/NodeEditor/Nodes/Vector3DToXYZNode.hpp

@@ -0,0 +1,34 @@
+// This file is part of Noggit3, licensed under GNU General Public License (version 3).
+
+#ifndef NOGGIT_VECTOR3DTOXYZNODE_HPP
+#define NOGGIT_VECTOR3DTOXYZNODE_HPP
+
+#include "BaseNode.hpp"
+
+using QtNodes::PortType;
+using QtNodes::PortIndex;
+using QtNodes::NodeData;
+using QtNodes::NodeDataType;
+using QtNodes::NodeDataModel;
+using QtNodes::NodeValidationState;
+
+
+namespace noggit
+{
+    namespace Red::NodeEditor::Nodes
+    {
+        class Vector3DToXYZNode : public BaseNode
+        {
+        Q_OBJECT
+
+        public:
+            Vector3DToXYZNode();
+            NodeValidationState validate() override;
+            void compute() override;
+        };
+
+    }
+
+}
+
+#endif //NOGGIT_VECTOR3DTOXYZNODE_HPP

src/noggit/Red/NodeEditor/Nodes/Vector4DToXYZWNode.cpp

@@ -0,0 +1,51 @@
+// This file is part of Noggit3, licensed under GNU General Public License (version 3).
+
+#include "Vector4DToXYZWNode.hpp"
+
+#include "BaseNode.inl"
+#include "Data/GenericData.hpp"
+
+using namespace noggit::Red::NodeEditor::Nodes;
+
+Vector4DToXYZWNode::Vector4DToXYZWNode()
+    : BaseNode()
+{
+  setName("Vector4DToXYZWNode");
+  setCaption("Vector4D To XYZW");
+  _validation_state = NodeValidationState::Valid;
+
+  addPort<Vector4DData>(PortType::In, "Vector4D", true);
+
+  addPort<DecimalData>(PortType::Out, "X<Decimal>", true);
+  addPort<DecimalData>(PortType::Out, "Y<Decimal>", true);
+  addPort<DecimalData>(PortType::Out, "Z<Decimal>", true);
+  addPort<DecimalData>(PortType::Out, "W<Decimal>", true);
+}
+
+void Vector4DToXYZWNode::compute()
+{
+  glm::vec4 vector = static_cast<Vector4DData*>(_in_ports[0].in_value.lock().get())->value();
+  _out_ports[0].out_value = std::make_shared<DecimalData>(vector.x);
+  _out_ports[1].out_value = std::make_shared<DecimalData>(vector.y);
+  _out_ports[2].out_value = std::make_shared<DecimalData>(vector.z);
+  _out_ports[3].out_value = std::make_shared<DecimalData>(vector.w);
+
+  Q_EMIT dataUpdated(0);
+  Q_EMIT dataUpdated(1);
+  Q_EMIT dataUpdated(2);
+  Q_EMIT dataUpdated(3);
+}
+
+NodeValidationState Vector4DToXYZWNode::validate()
+{
+
+  if (!static_cast<Vector4DData*>(_in_ports[0].in_value.lock().get()))
+  {
+    setValidationState(NodeValidationState::Error);
+    setValidationMessage("Error: failed to evaluate vector input.");
+    return _validation_state;
+  }
+
+  return _validation_state;
+}
+

src/noggit/Red/NodeEditor/Nodes/Vector4DToXYZWNode.hpp

@@ -0,0 +1,34 @@
+// This file is part of Noggit3, licensed under GNU General Public License (version 3).
+
+#ifndef NOGGIT_VECTOR4DTOXYZWNODE_HPP
+#define NOGGIT_VECTOR4DTOXYZWNODE_HPP
+
+#include "BaseNode.hpp"
+
+using QtNodes::PortType;
+using QtNodes::PortIndex;
+using QtNodes::NodeData;
+using QtNodes::NodeDataType;
+using QtNodes::NodeDataModel;
+using QtNodes::NodeValidationState;
+
+
+namespace noggit
+{
+    namespace Red::NodeEditor::Nodes
+    {
+        class Vector4DToXYZWNode : public BaseNode
+        {
+        Q_OBJECT
+
+        public:
+            Vector4DToXYZWNode();
+            NodeValidationState validate() override;
+            void compute() override;
+        };
+
+    }
+
+}
+
+#endif //NOGGIT_VECTOR4DTOXYZWNODE_HPP

src/noggit/Red/NodeEditor/Nodes/VectorMathNode.cpp

@@ -47,6 +47,8 @@ VectorMathNodeBase<T, T1>::VectorMathNodeBase()
     type_name = "Vector2D";
   }
 
+  addWidgetTop(_operation);
+
   addPort<T>(PortType::In, type_name.c_str(), true);
   addDefaultWidget(_in_ports[0].data_type->default_widget(&_embedded_widget), PortType::In, 0);
 

src/noggit/Red/NodeEditor/Nodes/VectorScalarMathNode.cpp

@@ -38,6 +38,8 @@ VectorScalarMathNodeBase<T, T1>::VectorScalarMathNodeBase()
     type_name = "Vector2D";
   }
 
+  addWidgetTop(_operation);
+
   addPort<T>(PortType::In, type_name.c_str(), true);
   addDefaultWidget(_in_ports[0].data_type->default_widget(&_embedded_widget), PortType::In, 0);
   addPort<T>(PortType::In, type_name.c_str(), true);

src/noggit/Red/NodeEditor/Nodes/XYZWtoVector4DNode.cpp

@@ -0,0 +1,50 @@
+// This file is part of Noggit3, licensed under GNU General Public License (version 3).
+
+#include "XYZWtoVector4DNode.hpp"
+
+#include "BaseNode.inl"
+#include "Data/GenericData.hpp"
+
+using namespace noggit::Red::NodeEditor::Nodes;
+
+XYZWtoVector4DNode::XYZWtoVector4DNode()
+: BaseNode()
+{
+  setName("XYZWtoVector4DNode");
+  setCaption("XYZW To Vector4D");
+  _validation_state = NodeValidationState::Valid;
+
+  addPort<DecimalData>(PortType::In, "X<Decimal>", true);
+  addPort<DecimalData>(PortType::In, "Y<Decimal>", true);
+  addPort<DecimalData>(PortType::In, "Z<Decimal>", true);
+  addPort<DecimalData>(PortType::In, "W<Decimal>", true);
+
+  addPort<Vector4DData>(PortType::Out, "Vector4D", true);
+}
+
+void XYZWtoVector4DNode::compute()
+{
+  double x = static_cast<DecimalData*>(_in_ports[0].in_value.lock().get())->value();
+  double y = static_cast<DecimalData*>(_in_ports[1].in_value.lock().get())->value();
+  double z = static_cast<DecimalData*>(_in_ports[2].in_value.lock().get())->value();
+  double w = static_cast<DecimalData*>(_in_ports[3].in_value.lock().get())->value();
+
+  _out_ports[0].out_value = std::make_shared<Vector4DData>(glm::vec4(x, y, z, w));
+  Q_EMIT dataUpdated(0);
+}
+
+NodeValidationState XYZWtoVector4DNode::validate()
+{
+
+  if (!static_cast<DecimalData*>(_in_ports[0].in_value.lock().get())
+    || !static_cast<DecimalData*>(_in_ports[1].in_value.lock().get())
+    || !static_cast<DecimalData*>(_in_ports[2].in_value.lock().get())
+    || !static_cast<DecimalData*>(_in_ports[3].in_value.lock().get()))
+  {
+    setValidationState(NodeValidationState::Error);
+    setValidationMessage("Error: failed to evaluate decimal input.");
+    return _validation_state;
+  }
+
+  return _validation_state;
+}

src/noggit/Red/NodeEditor/Nodes/XYZWtoVector4DNode.hpp

@@ -0,0 +1,34 @@
+// This file is part of Noggit3, licensed under GNU General Public License (version 3).
+
+#ifndef NOGGIT_XYZWTOVECTOR4DNODE_HPP
+#define NOGGIT_XYZWTOVECTOR4DNODE_HPP
+
+#include "BaseNode.hpp"
+
+using QtNodes::PortType;
+using QtNodes::PortIndex;
+using QtNodes::NodeData;
+using QtNodes::NodeDataType;
+using QtNodes::NodeDataModel;
+using QtNodes::NodeValidationState;
+
+
+namespace noggit
+{
+    namespace Red::NodeEditor::Nodes
+    {
+        class XYZWtoVector4DNode : public BaseNode
+        {
+        Q_OBJECT
+
+        public:
+            XYZWtoVector4DNode();
+            void compute() override;
+            NodeValidationState validate() override;
+        };
+
+    }
+
+}
+
+#endif //NOGGIT_XYZWTOVECTOR4DNODE_HPP

src/noggit/Red/NodeEditor/Nodes/XYZtoVector3DNode.cpp

@@ -0,0 +1,48 @@
+// This file is part of Noggit3, licensed under GNU General Public License (version 3).
+
+#include "XYZtoVector3DNode.hpp"
+
+
+#include "BaseNode.inl"
+#include "Data/GenericData.hpp"
+
+using namespace noggit::Red::NodeEditor::Nodes;
+
+XYZtoVector3DNode::XYZtoVector3DNode()
+    : BaseNode()
+{
+  setName("XYZtoVector3DNode");
+  setCaption("XYZ To Vector3D");
+  _validation_state = NodeValidationState::Valid;
+
+  addPort<DecimalData>(PortType::In, "X<Decimal>", true);
+  addPort<DecimalData>(PortType::In, "Y<Decimal>", true);
+  addPort<DecimalData>(PortType::In, "Z<Decimal>", true);
+
+  addPort<Vector3DData>(PortType::Out, "Vector3D", true);
+}
+
+void XYZtoVector3DNode::compute()
+{
+  double x = static_cast<DecimalData*>(_in_ports[0].in_value.lock().get())->value();
+  double y = static_cast<DecimalData*>(_in_ports[1].in_value.lock().get())->value();
+  double z = static_cast<DecimalData*>(_in_ports[2].in_value.lock().get())->value();
+
+  _out_ports[0].out_value = std::make_shared<Vector3DData>(glm::vec3(x, y, z));
+  Q_EMIT dataUpdated(0);
+}
+
+NodeValidationState XYZtoVector3DNode::validate()
+{
+
+  if (!static_cast<DecimalData*>(_in_ports[0].in_value.lock().get())
+    || !static_cast<DecimalData*>(_in_ports[1].in_value.lock().get())
+    || !static_cast<DecimalData*>(_in_ports[2].in_value.lock().get()))
+  {
+    setValidationState(NodeValidationState::Error);
+    setValidationMessage("Error: failed to evaluate decimal input.");
+    return _validation_state;
+  }
+
+  return _validation_state;
+}

src/noggit/Red/NodeEditor/Nodes/XYZtoVector3DNode.hpp

@@ -0,0 +1,35 @@
+// This file is part of Noggit3, licensed under GNU General Public License (version 3).
+
+#ifndef NOGGIT_XYZTOVECTOR3DNODE_HPP
+#define NOGGIT_XYZTOVECTOR3DNODE_HPP
+
+#include "BaseNode.hpp"
+
+using QtNodes::PortType;
+using QtNodes::PortIndex;
+using QtNodes::NodeData;
+using QtNodes::NodeDataType;
+using QtNodes::NodeDataModel;
+using QtNodes::NodeValidationState;
+
+
+namespace noggit
+{
+    namespace Red::NodeEditor::Nodes
+    {
+        class XYZtoVector3DNode : public BaseNode
+        {
+        Q_OBJECT
+
+        public:
+            XYZtoVector3DNode();
+            void compute() override;
+            NodeValidationState validate() override;
+
+        };
+
+    }
+
+}
+
+#endif //NOGGIT_XYZTOVECTOR3DNODE_HPP

src/noggit/Red/NodeEditor/Nodes/XYtoVector2D.cpp

@@ -0,0 +1,44 @@
+// This file is part of Noggit3, licensed under GNU General Public License (version 3).
+
+#include "XYtoVector2D.hpp"
+
+#include "BaseNode.inl"
+#include "Data/GenericData.hpp"
+
+using namespace noggit::Red::NodeEditor::Nodes;
+
+XYtoVector2DNode::XYtoVector2DNode()
+: BaseNode()
+{
+  setName("XYtoVector2DNode");
+  setCaption("XY To Vector2D");
+  _validation_state = NodeValidationState::Valid;
+
+  addPort<DecimalData>(PortType::In, "X<Decimal>", true);
+  addPort<DecimalData>(PortType::In, "Y<Decimal>", true);
+
+  addPort<Vector2DData>(PortType::Out, "Vector2D", true);
+}
+
+void XYtoVector2DNode::compute()
+{
+  double x = static_cast<DecimalData*>(_in_ports[0].in_value.lock().get())->value();
+  double y = static_cast<DecimalData*>(_in_ports[1].in_value.lock().get())->value();
+
+  _out_ports[0].out_value = std::make_shared<Vector2DData>(glm::vec2(x, y));
+  Q_EMIT dataUpdated(0);
+}
+
+NodeValidationState XYtoVector2DNode::validate()
+{
+
+  if (!static_cast<DecimalData*>(_in_ports[0].in_value.lock().get())
+    || !static_cast<DecimalData*>(_in_ports[1].in_value.lock().get()))
+  {
+    setValidationState(NodeValidationState::Error);
+    setValidationMessage("Error: failed to evaluate decimal input.");
+    return _validation_state;
+  }
+
+  return _validation_state;
+}

src/noggit/Red/NodeEditor/Nodes/XYtoVector2D.hpp

@@ -0,0 +1,34 @@
+// This file is part of Noggit3, licensed under GNU General Public License (version 3).
+
+#ifndef NOGGIT_XYTOVECTOR2D_HPP
+#define NOGGIT_XYTOVECTOR2D_HPP
+
+#include "BaseNode.hpp"
+
+using QtNodes::PortType;
+using QtNodes::PortIndex;
+using QtNodes::NodeData;
+using QtNodes::NodeDataType;
+using QtNodes::NodeDataModel;
+using QtNodes::NodeValidationState;
+
+
+namespace noggit
+{
+    namespace Red::NodeEditor::Nodes
+    {
+        class XYtoVector2DNode : public BaseNode
+        {
+        Q_OBJECT
+
+        public:
+            XYtoVector2DNode();
+            void compute() override;
+            NodeValidationState validate() override;
+        };
+
+    }
+
+}
+
+#endif //NOGGIT_XYTOVECTOR2D_HPP