Renderer/ShaderAst: Add serialization

include/Nazara/Renderer/ShaderNodes.hpp

@@ -34,6 +34,7 @@ namespace Nz
 				virtual ~Node();
 
 				inline NodeType GetType() const;
+				inline bool IsStatement() const;
 
 				virtual void Visit(ShaderVisitor& visitor) = 0;
 
@@ -41,10 +42,24 @@ namespace Nz
 				static inline ExpressionType GetComponentType(ExpressionType type);
 
 			protected:
-				inline Node(NodeType type);
+				inline Node(NodeType type, bool isStatement);
 
 			private:
 				NodeType m_type;
+				bool m_isStatement;
+		};
+		
+		class Expression;
+
+		using ExpressionPtr = std::shared_ptr<Expression>;
+
+		class NAZARA_RENDERER_API Expression : public Node
+		{
+			public:
+				inline Expression(NodeType type);
+
+				virtual ExpressionCategory GetExpressionCategory() const;
+				virtual ExpressionType GetExpressionType() const = 0;
 		};
 
 		class Statement;
@@ -54,20 +69,7 @@ namespace Nz
 		class NAZARA_RENDERER_API Statement : public Node
 		{
 			public:
-				using Node::Node;
-		};
-
-		class Expression;
-
-		using ExpressionPtr = std::shared_ptr<Expression>;
-
-		class NAZARA_RENDERER_API Expression : public Node
-		{
-			public:
-				using Node::Node;
-
-				virtual ExpressionCategory GetExpressionCategory() const;
-				virtual ExpressionType GetExpressionType() const = 0;
+				inline Statement(NodeType type);
 		};
 
 		struct NAZARA_RENDERER_API ExpressionStatement : public Statement

include/Nazara/Renderer/ShaderNodes.inl

@@ -7,8 +7,9 @@
 
 namespace Nz::ShaderNodes
 {
-	inline Node::Node(NodeType type) :
-	m_type(type)
+	inline Node::Node(NodeType type, bool isStatement) :
+	m_type(type),
+	m_isStatement(isStatement)
 	{
 	}
 
@@ -17,6 +18,11 @@ namespace Nz::ShaderNodes
 		return m_type;
 	}
 
+	inline bool Node::IsStatement() const
+	{
+		return m_isStatement;
+	}
+
 	inline unsigned int Node::GetComponentCount(ExpressionType type)
 	{
 		switch (type)
@@ -55,6 +61,19 @@ namespace Nz::ShaderNodes
 		}
 	}
 
+
+	inline Expression::Expression(NodeType type) :
+	Node(type, false)
+	{
+	}
+
+	inline Statement::Statement(NodeType type) :
+	Node(type, true)
+	{
+	}
+
+
+
 	inline ExpressionStatement::ExpressionStatement() :
 	Statement(NodeType::ExpressionStatement)
 	{

include/Nazara/Renderer/ShaderSerializer.hpp

@@ -14,8 +14,10 @@
 #include <Nazara/Renderer/ShaderNodes.hpp>
 #include <Nazara/Renderer/ShaderVariables.hpp>
 
-namespace Nz::ShaderNodes
+namespace Nz
 {
+	class ShaderAst;
+
 	class NAZARA_RENDERER_API ShaderSerializerBase
 	{
 		public:
@@ -24,28 +26,29 @@ namespace Nz::ShaderNodes
 			ShaderSerializerBase(ShaderSerializerBase&&) = delete;
 			~ShaderSerializerBase() = default;
 
-			void Serialize(AssignOp& node);
-			void Serialize(BinaryOp& node);
-			void Serialize(BuiltinVariable& var);
-			void Serialize(Branch& node);
-			void Serialize(Cast& node);
-			void Serialize(Constant& node);
-			void Serialize(DeclareVariable& node);
-			void Serialize(ExpressionStatement& node);
-			void Serialize(Identifier& node);
-			void Serialize(IntrinsicCall& node);
-			void Serialize(NamedVariable& var);
-			void Serialize(Sample2D& node);
-			void Serialize(StatementBlock& node);
-			void Serialize(SwizzleOp& node);
+			void Serialize(ShaderNodes::AssignOp& node);
+			void Serialize(ShaderNodes::BinaryOp& node);
+			void Serialize(ShaderNodes::BuiltinVariable& var);
+			void Serialize(ShaderNodes::Branch& node);
+			void Serialize(ShaderNodes::Cast& node);
+			void Serialize(ShaderNodes::Constant& node);
+			void Serialize(ShaderNodes::DeclareVariable& node);
+			void Serialize(ShaderNodes::ExpressionStatement& node);
+			void Serialize(ShaderNodes::Identifier& node);
+			void Serialize(ShaderNodes::IntrinsicCall& node);
+			void Serialize(ShaderNodes::NamedVariable& var);
+			void Serialize(ShaderNodes::Sample2D& node);
+			void Serialize(ShaderNodes::StatementBlock& node);
+			void Serialize(ShaderNodes::SwizzleOp& node);
 
 		protected:
 			template<typename T> void Container(T& container);
 			template<typename T> void Enum(T& enumVal);
+			template<typename T> void OptVal(std::optional<T>& optVal);
 
 			virtual bool IsWriting() const = 0;
 
-			virtual void Node(NodePtr& node) = 0;
+			virtual void Node(ShaderNodes::NodePtr& node) = 0;
 			template<typename T> void Node(std::shared_ptr<T>& node);
 
 			virtual void Value(bool& val) = 0;
@@ -57,7 +60,7 @@ namespace Nz::ShaderNodes
 			virtual void Value(UInt32& val) = 0;
 			inline void Value(std::size_t& val);
 
-			virtual void Variable(VariablePtr& var) = 0;
+			virtual void Variable(ShaderNodes::VariablePtr& var) = 0;
 			template<typename T> void Variable(std::shared_ptr<T>& var);
 	};
 
@@ -67,11 +70,12 @@ namespace Nz::ShaderNodes
 			inline ShaderSerializer(ByteArray& byteArray);
 			~ShaderSerializer() = default;
 
-			void Serialize(const StatementPtr& shader);
+			void Serialize(const ShaderAst& shader);
 
 		private:
 			bool IsWriting() const override;
-			void Node(NodePtr& node) override;
+			void Node(const ShaderNodes::NodePtr& node);
+			void Node(ShaderNodes::NodePtr& node) override;
 			void Value(bool& val) override;
 			void Value(float& val) override;
 			void Value(std::string& val) override;
@@ -79,7 +83,7 @@ namespace Nz::ShaderNodes
 			void Value(Vector3f& val) override;
 			void Value(Vector4f& val) override;
 			void Value(UInt32& val) override;
-			void Variable(VariablePtr& var) override;
+			void Variable(ShaderNodes::VariablePtr& var) override;
 
 			ByteArray& m_byteArray;
 			ByteStream m_stream;
@@ -91,11 +95,11 @@ namespace Nz::ShaderNodes
 			ShaderUnserializer(const ByteArray& byteArray);
 			~ShaderUnserializer() = default;
 
-			StatementPtr Unserialize();
+			ShaderAst Unserialize();
 
 		private:
 			bool IsWriting() const override;
-			void Node(NodePtr& node) override;
+			void Node(ShaderNodes::NodePtr& node) override;
 			void Value(bool& val) override;
 			void Value(float& val) override;
 			void Value(std::string& val) override;
@@ -103,14 +107,14 @@ namespace Nz::ShaderNodes
 			void Value(Vector3f& val) override;
 			void Value(Vector4f& val) override;
 			void Value(UInt32& val) override;
-			void Variable(VariablePtr& var) override;
+			void Variable(ShaderNodes::VariablePtr& var) override;
 
 			const ByteArray& m_byteArray;
 			ByteStream m_stream;
 	};
 	
-	NAZARA_RENDERER_API ByteArray Serialize(const StatementPtr& shader);
-	NAZARA_RENDERER_API StatementPtr Unserialize(const ByteArray& data);
+	NAZARA_RENDERER_API ByteArray SerializeShader(const ShaderAst& shader);
+	NAZARA_RENDERER_API ShaderAst UnserializeShader(const ByteArray& data);
 }
 
 #include <Nazara/Renderer/ShaderSerializer.inl>

include/Nazara/Renderer/ShaderSerializer.inl

@@ -5,7 +5,7 @@
 #include <Nazara/Renderer/ShaderSerializer.hpp>
 #include <Nazara/Renderer/Debug.hpp>
 
-namespace Nz::ShaderNodes
+namespace Nz
 {
 	template<typename T>
 	void ShaderSerializerBase::Container(T& container)
@@ -36,12 +36,30 @@ namespace Nz::ShaderNodes
 			enumVal = static_cast<T>(value);
 	}
 
+	template<typename T>
+	void ShaderSerializerBase::OptVal(std::optional<T>& optVal)
+	{
+		bool isWriting = IsWriting();
+
+		bool hasValue;
+		if (isWriting)
+			hasValue = optVal.has_value();
+
+		Value(hasValue);
+
+		if (!isWriting && hasValue)
+			optVal.emplace();
+
+		if (optVal.has_value())
+			Value(optVal.value());
+	}
+
 	template<typename T>
 	void ShaderSerializerBase::Node(std::shared_ptr<T>& node)
 	{
 		bool isWriting = IsWriting();
 
-		NodePtr value;
+		ShaderNodes::NodePtr value;
 		if (isWriting)
 			value = node;
 
@@ -55,7 +73,7 @@ namespace Nz::ShaderNodes
 	{
 		bool isWriting = IsWriting();
 
-		VariablePtr value;
+		ShaderNodes::VariablePtr value;
 		if (isWriting)
 			value = var;