Shader: Add import statement (not doing anything for now)

include/Nazara/Shader/Ast/AstCloner.hpp

@@ -68,6 +68,7 @@ namespace Nz::ShaderAst
 			virtual StatementPtr Clone(ExpressionStatement& node);
 			virtual StatementPtr Clone(ForStatement& node);
 			virtual StatementPtr Clone(ForEachStatement& node);
+			virtual StatementPtr Clone(ImportStatement& node);
 			virtual StatementPtr Clone(MultiStatement& node);
 			virtual StatementPtr Clone(NoOpStatement& node);
 			virtual StatementPtr Clone(ReturnStatement& node);

include/Nazara/Shader/Ast/AstCompare.hpp

@@ -56,6 +56,7 @@ namespace Nz::ShaderAst
 	inline bool Compare(const ExpressionStatement& lhs, const ExpressionStatement& rhs);
 	inline bool Compare(const ForStatement& lhs, const ForStatement& rhs);
 	inline bool Compare(const ForEachStatement& lhs, const ForEachStatement& rhs);
+	inline bool Compare(const ImportStatement& lhs, const ImportStatement& rhs);
 	inline bool Compare(const MultiStatement& lhs, const MultiStatement& rhs);
 	inline bool Compare(const NoOpStatement& lhs, const NoOpStatement& rhs);
 	inline bool Compare(const ReturnStatement& lhs, const ReturnStatement& rhs);

include/Nazara/Shader/Ast/AstCompare.inl

@@ -509,6 +509,14 @@ namespace Nz::ShaderAst
 		return true;
 	}
 
+	bool Compare(const ImportStatement& lhs, const ImportStatement& rhs)
+	{
+		if (!Compare(lhs.modulePath, rhs.modulePath))
+			return false;
+
+		return true;
+	}
+
 	inline bool Compare(const MultiStatement& lhs, const MultiStatement& rhs)
 	{
 		if (!Compare(lhs.statements, rhs.statements))

include/Nazara/Shader/Ast/AstNodeList.hpp

@@ -55,6 +55,7 @@ NAZARA_SHADERAST_STATEMENT(DiscardStatement)
 NAZARA_SHADERAST_STATEMENT(ForStatement)
 NAZARA_SHADERAST_STATEMENT(ForEachStatement)
 NAZARA_SHADERAST_STATEMENT(ExpressionStatement)
+NAZARA_SHADERAST_STATEMENT(ImportStatement)
 NAZARA_SHADERAST_STATEMENT(MultiStatement)
 NAZARA_SHADERAST_STATEMENT(NoOpStatement)
 NAZARA_SHADERAST_STATEMENT(ReturnStatement)

include/Nazara/Shader/Ast/AstRecursiveVisitor.hpp

@@ -48,6 +48,7 @@ namespace Nz::ShaderAst
 			void Visit(ExpressionStatement& node) override;
 			void Visit(ForStatement& node) override;
 			void Visit(ForEachStatement& node) override;
+			void Visit(ImportStatement& node) override;
 			void Visit(MultiStatement& node) override;
 			void Visit(NoOpStatement& node) override;
 			void Visit(ReturnStatement& node) override;

include/Nazara/Shader/Ast/AstSerializer.hpp

@@ -51,6 +51,7 @@ namespace Nz::ShaderAst
 			void Serialize(ExpressionStatement& node);
 			void Serialize(ForStatement& node);
 			void Serialize(ForEachStatement& node);
+			void Serialize(ImportStatement& node);
 			void Serialize(MultiStatement& node);
 			void Serialize(NoOpStatement& node);
 			void Serialize(ReturnStatement& node);

include/Nazara/Shader/Ast/Nodes.hpp

@@ -367,6 +367,14 @@ namespace Nz::ShaderAst
 		StatementPtr statement;
 	};
 
+	struct NAZARA_SHADER_API ImportStatement : Statement
+	{
+		NodeType GetType() const override;
+		void Visit(AstStatementVisitor& visitor) override;
+
+		std::vector<std::string> modulePath;
+	};
+
 	struct NAZARA_SHADER_API MultiStatement : Statement
 	{
 		NodeType GetType() const override;

include/Nazara/Shader/Ast/SanitizeVisitor.hpp

@@ -88,6 +88,7 @@ namespace Nz::ShaderAst
 			StatementPtr Clone(ExpressionStatement& node) override;
 			StatementPtr Clone(ForStatement& node) override;
 			StatementPtr Clone(ForEachStatement& node) override;
+			StatementPtr Clone(ImportStatement& node) override;
 			StatementPtr Clone(MultiStatement& node) override;
 			StatementPtr Clone(ScopedStatement& node) override;
 			StatementPtr Clone(WhileStatement& node) override;

include/Nazara/Shader/GlslWriter.hpp

@@ -112,6 +112,7 @@ namespace Nz
 			void Visit(ShaderAst::DeclareVariableStatement& node) override;
 			void Visit(ShaderAst::DiscardStatement& node) override;
 			void Visit(ShaderAst::ExpressionStatement& node) override;
+			void Visit(ShaderAst::ImportStatement& node) override;
 			void Visit(ShaderAst::MultiStatement& node) override;
 			void Visit(ShaderAst::NoOpStatement& node) override;
 			void Visit(ShaderAst::ReturnStatement& node) override;

include/Nazara/Shader/LangWriter.hpp

@@ -119,6 +119,7 @@ namespace Nz
 			void Visit(ShaderAst::ExpressionStatement& node) override;
 			void Visit(ShaderAst::ForStatement& node) override;
 			void Visit(ShaderAst::ForEachStatement& node) override;
+			void Visit(ShaderAst::ImportStatement& node) override;
 			void Visit(ShaderAst::MultiStatement& node) override;
 			void Visit(ShaderAst::NoOpStatement& node) override;
 			void Visit(ShaderAst::ReturnStatement& node) override;

include/Nazara/Shader/ShaderBuilder.hpp

@@ -127,6 +127,11 @@ namespace Nz::ShaderBuilder
 			inline std::unique_ptr<ShaderAst::IdentifierExpression> operator()(std::string name) const;
 		};
 
+		struct Import
+		{
+			inline std::unique_ptr<ShaderAst::ImportStatement> operator()(std::vector<std::string> modulePath) const;
+		};
+
 		struct Intrinsic
 		{
 			inline std::unique_ptr<ShaderAst::IntrinsicExpression> operator()(ShaderAst::IntrinsicType intrinsicType, std::vector<ShaderAst::ExpressionPtr> parameters) const;
@@ -196,6 +201,7 @@ namespace Nz::ShaderBuilder
 	constexpr Impl::For For;
 	constexpr Impl::ForEach ForEach;
 	constexpr Impl::Identifier Identifier;
+	constexpr Impl::Import Import;
 	constexpr Impl::Intrinsic Intrinsic;
 	constexpr Impl::Multi MultiStatement;
 	constexpr Impl::NoParam<ShaderAst::NoOpStatement> NoOp;

include/Nazara/Shader/ShaderBuilder.inl

@@ -347,6 +347,14 @@ namespace Nz::ShaderBuilder
 		return identifierNode;
 	}
 
+	inline std::unique_ptr<ShaderAst::ImportStatement> Impl::Import::operator()(std::vector<std::string> modulePath) const
+	{
+		auto importNode = std::make_unique<ShaderAst::ImportStatement>();
+		importNode->modulePath = std::move(modulePath);
+
+		return importNode;
+	}
+
 	inline std::unique_ptr<ShaderAst::IntrinsicExpression> Impl::Intrinsic::operator()(ShaderAst::IntrinsicType intrinsicType, std::vector<ShaderAst::ExpressionPtr> parameters) const
 	{
 		auto intrinsicExpression = std::make_unique<ShaderAst::IntrinsicExpression>();

include/Nazara/Shader/ShaderLangParser.hpp

@@ -94,6 +94,7 @@ namespace Nz::ShaderLang
 			std::vector<ShaderAst::StatementPtr> ParseFunctionBody();
 			ShaderAst::StatementPtr ParseFunctionDeclaration(std::vector<ShaderAst::ExprValue> attributes = {});
 			ShaderAst::DeclareFunctionStatement::Parameter ParseFunctionParameter();
+			ShaderAst::StatementPtr ParseImportStatement();
 			ShaderAst::StatementPtr ParseOptionDeclaration();
 			ShaderAst::StatementPtr ParseReturnStatement();
 			ShaderAst::StatementPtr ParseRootStatement(std::vector<ShaderAst::ExprValue> attributes = {});

include/Nazara/Shader/ShaderLangTokenList.hpp

@@ -39,6 +39,7 @@ NAZARA_SHADERLANG_TOKEN(GreaterThanEqual)
 NAZARA_SHADERLANG_TOKEN(IntegerValue)
 NAZARA_SHADERLANG_TOKEN(Identifier)
 NAZARA_SHADERLANG_TOKEN(If)
+NAZARA_SHADERLANG_TOKEN(Import)
 NAZARA_SHADERLANG_TOKEN(In)
 NAZARA_SHADERLANG_TOKEN(LessThan)
 NAZARA_SHADERLANG_TOKEN(LessThanEqual)

include/Nazara/Shader/SpirvAstVisitor.hpp

@@ -56,6 +56,7 @@ namespace Nz
 			void Visit(ShaderAst::DeclareVariableStatement& node) override;
 			void Visit(ShaderAst::DiscardStatement& node) override;
 			void Visit(ShaderAst::ExpressionStatement& node) override;
+			void Visit(ShaderAst::ImportStatement& node) override;
 			void Visit(ShaderAst::IntrinsicExpression& node) override;
 			void Visit(ShaderAst::MultiStatement& node) override;
 			void Visit(ShaderAst::NoOpStatement& node) override;

src/Nazara/Shader/Ast/AstCloner.cpp

@@ -215,6 +215,14 @@ namespace Nz::ShaderAst
 		return clone;
 	}
 
+	StatementPtr AstCloner::Clone(ImportStatement& node)
+	{
+		auto clone = std::make_unique<ImportStatement>();
+		clone->modulePath = node.modulePath;
+
+		return clone;
+	}
+
 	StatementPtr AstCloner::Clone(MultiStatement& node)
 	{
 		auto clone = std::make_unique<MultiStatement>();

src/Nazara/Shader/Ast/AstRecursiveVisitor.cpp

@@ -185,6 +185,11 @@ namespace Nz::ShaderAst
 			node.statement->Visit(*this);
 	}
 
+	void AstRecursiveVisitor::Visit(ImportStatement& /*node*/)
+	{
+		/* nothing to do */
+	}
+
 	void AstRecursiveVisitor::Visit(MultiStatement& node)
 	{
 		for (auto& statement : node.statements)

src/Nazara/Shader/Ast/AstSerializer.cpp

@@ -301,6 +301,13 @@ namespace Nz::ShaderAst
 		Node(node.statement);
 	}
 
+	void AstSerializerBase::Serialize(ImportStatement& node)
+	{
+		Container(node.modulePath);
+		for (auto& path : node.modulePath)
+			Value(path);
+	}
+
 	void AstSerializerBase::Serialize(MultiStatement& node)
 	{
 		Container(node.statements);

src/Nazara/Shader/Ast/SanitizeVisitor.cpp

@@ -1308,6 +1308,11 @@ namespace Nz::ShaderAst
 		}
 	}
 
+	StatementPtr SanitizeVisitor::Clone(ImportStatement& node)
+	{
+			return static_unique_pointer_cast<ImportStatement>(AstCloner::Clone(node));
+	}
+
 	StatementPtr SanitizeVisitor::Clone(MultiStatement& node)
 	{
 		auto clone = std::make_unique<MultiStatement>();

src/Nazara/Shader/LangWriter.cpp

@@ -954,6 +954,20 @@ namespace Nz
 		ScopeVisit(*node.statement);
 	}
 
+	void LangWriter::Visit(ShaderAst::ImportStatement& node)
+	{
+		bool first = true;
+		for (const std::string& path : node.modulePath)
+		{
+			if (!first)
+				Append("/");
+
+			Append(path);
+
+			first = false;
+		}
+	}
+
 	void LangWriter::Visit(ShaderAst::IntrinsicExpression& node)
 	{
 		bool method = false;

src/Nazara/Shader/ShaderLangLexer.cpp

@@ -49,6 +49,7 @@ namespace Nz::ShaderLang
 			{ "fn",           TokenType::FunctionDeclaration },
 			{ "for",          TokenType::For },
 			{ "if",           TokenType::If },
+			{ "import",       TokenType::Import },
 			{ "in",           TokenType::In },
 			{ "let",          TokenType::Let },
 			{ "module",       TokenType::Module },

src/Nazara/Shader/ShaderLangParser.cpp

@@ -649,14 +649,23 @@ namespace Nz::ShaderLang
 		return { parameterName, std::move(parameterType) };
 	}
 
+	ShaderAst::StatementPtr Parser::ParseImportStatement()
 	{
+		Expect(Advance(), TokenType::Import);
 
+		std::vector<std::string> modulePath;
+		modulePath.push_back(ParseIdentifierAsName());
 
+		while (Peek().type == TokenType::Divide) //< /
 		{
+			Consume();
 
+			modulePath.push_back(ParseIdentifierAsName());
 		}
 
 		Expect(Advance(), TokenType::Semicolon);
+
+		return ShaderBuilder::Import(std::move(modulePath));
 	}
 
 	ShaderAst::StatementPtr Parser::ParseOptionDeclaration()
@@ -715,6 +724,12 @@ namespace Nz::ShaderLang
 			case TokenType::External:
 				return ParseExternalBlock(std::move(attributes));
 
+			case TokenType::Import:
+				if (!attributes.empty())
+					throw UnexpectedToken{};
+
+				return ParseImportStatement();
+
 			case TokenType::OpenSquareBracket:
 				assert(attributes.empty());
 				return ParseRootStatement(ParseAttributes());

src/Nazara/Shader/SpirvAstVisitor.cpp

@@ -726,6 +726,11 @@ namespace Nz
 		PopResultId();
 	}
 
+	void SpirvAstVisitor::Visit(ShaderAst::ImportStatement& node)
+	{
+		/* nothing to do */
+	}
+
 	void SpirvAstVisitor::Visit(ShaderAst::IntrinsicExpression& node)
 	{
 		switch (node.intrinsic)