Shader: Add module statement

src/Nazara/Shader/Ast/AstConstantPropagationVisitor.cpp

@@ -834,6 +834,7 @@ namespace Nz::ShaderAst
 					case PrimitiveType::Float32: optimized = PropagateSingleValueCast<float>(constantExpr); break;
 					case PrimitiveType::Int32:   optimized = PropagateSingleValueCast<Int32>(constantExpr); break;
 					case PrimitiveType::UInt32:  optimized = PropagateSingleValueCast<UInt32>(constantExpr); break;
+					case PrimitiveType::String: break;
 				}
 			}
 		}
@@ -866,7 +867,7 @@ namespace Nz::ShaderAst
 
 					if constexpr (std::is_same_v<T, NoValue>)
 						throw std::runtime_error("invalid type (value expected)");
-					else if constexpr (std::is_same_v<T, bool> || std::is_same_v<T, float> || std::is_same_v<T, Int32> || std::is_same_v<T, UInt32>)
+					else if constexpr (std::is_same_v<T, bool> || std::is_same_v<T, float> || std::is_same_v<T, Int32> || std::is_same_v<T, UInt32> || std::is_same_v<T, std::string>)
 						constantValues.push_back(arg);
 					else if constexpr (std::is_same_v<T, Vector2f> || std::is_same_v<T, Vector2i32>)
 					{

src/Nazara/Shader/Ast/AstSerializer.cpp

@@ -5,6 +5,7 @@
 #include <Nazara/Shader/Ast/AstSerializer.hpp>
 #include <Nazara/Shader/Ast/AstExpressionVisitor.hpp>
 #include <Nazara/Shader/Ast/AstStatementVisitor.hpp>
+#include <Nazara/Shader/ShaderBuilder.hpp>
 #include <Nazara/Shader/Debug.hpp>
 
 namespace Nz::ShaderAst
@@ -120,7 +121,7 @@ namespace Nz::ShaderAst
 			Value(value);
 		};
 
-		static_assert(std::variant_size_v<decltype(node.value)> == 11);
+		static_assert(std::variant_size_v<decltype(node.value)> == 12);
 		switch (typeIndex)
 		{
 			case 0:  break;
@@ -134,6 +135,7 @@ namespace Nz::ShaderAst
 			case 8:  SerializeValue(Vector2i32()); break;
 			case 9:  SerializeValue(Vector3i32()); break;
 			case 10: SerializeValue(Vector4i32()); break;
+			case 11: SerializeValue(std::string()); break;
 			default: throw std::runtime_error("unexpected data type");
 		}
 	}
@@ -327,11 +329,12 @@ namespace Nz::ShaderAst
 		Node(node.body);
 	}
 
-	void ShaderAstSerializer::Serialize(StatementPtr& shader)
+	void ShaderAstSerializer::Serialize(Module& module)
 	{
 		m_stream << s_magicNumber << s_currentVersion;
 
-		Node(shader);
+		m_stream << module.shaderLangVersion;
+		Serialize(*module.rootNode);
 
 		m_stream.FlushBits();
 	}
@@ -514,7 +517,7 @@ namespace Nz::ShaderAst
 		m_stream << val;
 	}
 
-	StatementPtr ShaderAstUnserializer::Unserialize()
+	ModulePtr ShaderAstUnserializer::Unserialize()
 	{
 		UInt32 magicNumber;
 		UInt32 version;
@@ -526,13 +529,15 @@ namespace Nz::ShaderAst
 		if (version > s_currentVersion)
 			throw std::runtime_error("unsupported version");
 
-		StatementPtr node;
+		ModulePtr module = std::make_shared<Module>();
 
-		Node(node);
-		if (!node)
-			throw std::runtime_error("functions can only have statements");
+		m_stream >> module->shaderLangVersion;
 
-		return node;
+		module->rootNode = ShaderBuilder::MultiStatement();
+		ShaderSerializerVisitor visitor(*this);
+		module->rootNode->Visit(visitor);
+
+		return module;
 	}
 
 	bool ShaderAstUnserializer::IsWriting() const
@@ -827,18 +832,18 @@ namespace Nz::ShaderAst
 	}
 	
 
-	ByteArray SerializeShader(StatementPtr& shader)
+	ByteArray SerializeShader(Module& module)
 	{
 		ByteArray byteArray;
 		ByteStream stream(&byteArray, OpenModeFlags(OpenMode::WriteOnly));
 
 		ShaderAstSerializer serializer(stream);
-		serializer.Serialize(shader);
+		serializer.Serialize(module);
 
 		return byteArray;
 	}
 
-	StatementPtr UnserializeShader(ByteStream& stream)
+	ModulePtr UnserializeShader(ByteStream& stream)
 	{
 		ShaderAstUnserializer unserializer(stream);
 		return unserializer.Unserialize();

src/Nazara/Shader/Ast/ConstantValue.cpp

@@ -24,6 +24,8 @@ namespace Nz::ShaderAst
 				return PrimitiveType::Int32;
 			else if constexpr (std::is_same_v<T, UInt32>)
 				return PrimitiveType::UInt32;
+			else if constexpr (std::is_same_v<T, std::string>)
+				return PrimitiveType::String;
 			else if constexpr (std::is_same_v<T, Vector2f>)
 				return VectorType{ 2, PrimitiveType::Float32 };
 			else if constexpr (std::is_same_v<T, Vector3f>)

src/Nazara/Shader/Ast/SanitizeVisitor.cpp

@@ -112,9 +112,10 @@ namespace Nz::ShaderAst
 		std::vector<StatementPtr>* currentStatementList = nullptr;
 	};
 
-	StatementPtr SanitizeVisitor::Sanitize(Statement& statement, const Options& options, std::string* error)
+	ModulePtr SanitizeVisitor::Sanitize(Module& module, const Options& options, std::string* error)
 	{
-		StatementPtr clone;
+		ModulePtr clone = std::make_shared<Module>();
+		clone->shaderLangVersion = module.shaderLangVersion;
 
 		Context currentContext;
 		currentContext.options = options;
@@ -129,7 +130,7 @@ namespace Nz::ShaderAst
 			// First pass, evaluate everything except function code
 			try
 			{
-				clone = AstCloner::Clone(statement);
+				clone->rootNode = static_unique_pointer_cast<MultiStatement>(AstCloner::Clone(*module.rootNode));
 			}
 			catch (const AstError& err)
 			{