Renderer/ShaderAst: Add NamedVariable and BuiltinVariable classes

include/Nazara/Renderer/GlslWriter.hpp

@@ -27,7 +27,7 @@ namespace Nz
 
 			Nz::String Generate(const ShaderAst::StatementPtr& node) override;
 
-			void RegisterFunction(const String& name, ShaderAst::StatementPtr statement, std::initializer_list<ShaderAst::VariablePtr> parameters, ShaderAst::ExpressionType ret) override;
+			void RegisterFunction(const String& name, ShaderAst::StatementPtr statement, std::initializer_list<ShaderAst::NamedVariablePtr> parameters, ShaderAst::ExpressionType ret) override;
 			void RegisterVariable(ShaderAst::VariableType kind, const String& name, ShaderAst::ExpressionType type) override;
 
 			void SetGlslVersion(unsigned int version);
@@ -35,15 +35,17 @@ namespace Nz
 			void Write(const ShaderAst::AssignOp& node) override;
 			void Write(const ShaderAst::Branch& node) override;
 			void Write(const ShaderAst::BinaryOp& node) override;
+			void Write(const ShaderAst::BuiltinVariable& node) override;
 			void Write(const ShaderAst::Constant& node) override;
 			void Write(const ShaderAst::ExpressionStatement& node) override;
+			void Write(const ShaderAst::NamedVariable& node) override;
 			void Write(const ShaderAst::NodePtr& node) override;
 			void Write(const ShaderAst::StatementBlock& node) override;
-			void Write(const ShaderAst::Variable& node) override;
 
 		private:
 			struct Function;
 
+			void Append(ShaderAst::Builtin builtin);
 			void Append(ShaderAst::ExpressionType type);
 			void Append(const String& txt);
 			void AppendCommentSection(const String& section);
@@ -56,7 +58,7 @@ namespace Nz
 			struct Function
 			{
 				std::set<std::pair<ShaderAst::ExpressionType, String>> variables;
-				std::vector<ShaderAst::VariablePtr> parameters;
+				std::vector<ShaderAst::NamedVariablePtr> parameters;
 				ShaderAst::ExpressionType retType;
 				ShaderAst::StatementPtr node;
 				String name;

include/Nazara/Renderer/ShaderAst.hpp

@@ -36,18 +36,25 @@ namespace Nz
 			Equality   //< ==
 		};
 
+		enum class Builtin
+		{
+			VertexPosition, // gl_Position
+		};
+
 		enum class ExpressionType
 		{
 			Float1, // float
 			Float2, // vec2
 			Float3, // vec3
 			Float4, // vec4
+			Mat4x4, // mat4
 
 			None    // void
 		};
 
 		enum class VariableType
 		{
+			Builtin,
 			Parameter,
 			Variable,
 			Uniform
@@ -115,14 +122,36 @@ namespace Nz
 		class NAZARA_RENDERER_API Variable : public Expression
 		{
 			public:
-				inline Variable(VariableType varKind, const Nz::String& varName, ExpressionType varType);
+				inline Variable(VariableType varKind, ExpressionType varType);
+
+				ExpressionType type;
+				VariableType   kind;
+		};
+
+		class NamedVariable;
+
+		using NamedVariablePtr = std::shared_ptr<NamedVariable>;
+
+		class NAZARA_RENDERER_API NamedVariable : public Variable
+		{
+			public:
+				inline NamedVariable(VariableType varKind, const Nz::String& varName, ExpressionType varType);
 
 				void Register(ShaderWriter& visitor) override;
 				void Visit(ShaderWriter& visitor) override;
 
-				ExpressionType type;
+				Nz::String name;
-				VariableType   kind;
+		};
-				Nz::String     name;
+
+		class NAZARA_RENDERER_API BuiltinVariable : public Variable
+		{
+			public:
+				inline BuiltinVariable(Builtin variable, ExpressionType varType);
+
+				void Register(ShaderWriter& visitor) override;
+				void Visit(ShaderWriter& visitor) override;
+
+				Builtin var;
 		};
 
 		//////////////////////////////////////////////////////////////////////////

include/Nazara/Renderer/ShaderAst.inl

@@ -20,13 +20,24 @@ namespace Nz
 		{
 		}
 
-		inline Variable::Variable(VariableType varKind, const Nz::String& varName, ExpressionType varType) :
+		inline Variable::Variable(VariableType varKind, ExpressionType varType) :
 		kind(varKind),
-		name(varName),
 		type(varType)
 		{
 		}
 
+		inline NamedVariable::NamedVariable(VariableType varKind, const Nz::String& varName, ExpressionType varType) :
+		Variable(varKind, varType),
+		name(varName)
+		{
+		}
+
+		inline BuiltinVariable::BuiltinVariable(Builtin variable, ExpressionType varType) :
+		Variable(VariableType::Builtin, varType),
+		var(variable)
+		{
+		}
+
 		inline AssignOp::AssignOp(AssignType Op, VariablePtr Var, ExpressionPtr Right) :
 		op(Op),
 		variable(std::move(Var)),

include/Nazara/Renderer/ShaderBuilder.hpp

@@ -51,7 +51,7 @@ namespace Nz { namespace ShaderBuilder
 			template<typename... Args>
 			std::shared_ptr<Nz::ShaderAst::Variable> operator()(Args&&... args) const
 			{
-				return std::make_shared<Nz::ShaderAst::Variable>(type, std::forward<Args>(args)...);
+				return std::make_shared<Nz::ShaderAst::NamedVariable>(type, std::forward<Args>(args)...);
 			}
 	};
 

include/Nazara/Renderer/ShaderWriter.hpp

@@ -23,17 +23,18 @@ namespace Nz
 
 			virtual Nz::String Generate(const ShaderAst::StatementPtr& node) = 0;
 
-			virtual void RegisterFunction(const String& name, ShaderAst::StatementPtr node, std::initializer_list<ShaderAst::VariablePtr> parameters, ShaderAst::ExpressionType ret) = 0;
+			virtual void RegisterFunction(const String& name, ShaderAst::StatementPtr node, std::initializer_list<ShaderAst::NamedVariablePtr> parameters, ShaderAst::ExpressionType ret) = 0;
 			virtual void RegisterVariable(ShaderAst::VariableType kind, const String& name, ShaderAst::ExpressionType type) = 0;
 
 			virtual void Write(const ShaderAst::AssignOp& node) = 0;
 			virtual void Write(const ShaderAst::Branch& node) = 0;
 			virtual void Write(const ShaderAst::BinaryOp& node) = 0;
+			virtual void Write(const ShaderAst::BuiltinVariable& node) = 0;
 			virtual void Write(const ShaderAst::Constant& node) = 0;
 			virtual void Write(const ShaderAst::ExpressionStatement& node) = 0;
+			virtual void Write(const ShaderAst::NamedVariable& node) = 0;
 			virtual void Write(const ShaderAst::NodePtr& node) = 0;
 			virtual void Write(const ShaderAst::StatementBlock& node) = 0;
-			virtual void Write(const ShaderAst::Variable& node) = 0;
 	};
 }
 

src/Nazara/Renderer/GlslWriter.cpp

@@ -59,7 +59,7 @@ namespace Nz
 		return state.stream;
 	}
 
-	void GlslWriter::RegisterFunction(const String& name, ShaderAst::StatementPtr statement, std::initializer_list<ShaderAst::VariablePtr> parameters, ShaderAst::ExpressionType retType)
+	void GlslWriter::RegisterFunction(const String& name, ShaderAst::StatementPtr statement, std::initializer_list<ShaderAst::NamedVariablePtr> parameters, ShaderAst::ExpressionType retType)
 	{
 		Function func;
 		func.retType = retType;
@@ -197,6 +197,11 @@ namespace Nz
 		Write(node.right);
 	}
 
+	void GlslWriter::Write(const ShaderAst::BuiltinVariable& node)
+	{
+		Append(node.var);
+	}
+
 	void GlslWriter::Write(const ShaderAst::Constant& node)
 	{
 		switch (node.exprType)
@@ -213,6 +218,11 @@ namespace Nz
 		Append(";");
 	}
 
+	void GlslWriter::Write(const ShaderAst::NamedVariable& node)
+	{
+		Append(node.name);
+	}
+
 	void GlslWriter::Write(const ShaderAst::StatementBlock& node)
 	{
 		bool first = true;
@@ -227,9 +237,14 @@ namespace Nz
 		}
 	}
 
-	void GlslWriter::Write(const ShaderAst::Variable& node)
+	void GlslWriter::Append(ShaderAst::Builtin builtin)
 	{
-		Append(node.name);
+		switch (builtin)
+		{
+			case ShaderAst::Builtin::VertexPosition:
+				Append("gl_Position");
+				break;
+		}
 	}
 
 	void GlslWriter::Append(ShaderAst::ExpressionType type)
@@ -248,6 +263,9 @@ namespace Nz
 			case ShaderAst::ExpressionType::Float4:
 				Append("vec4");
 				break;
+			case ShaderAst::ExpressionType::Mat4x4:
+				Append("mat4");
+				break;
 			case ShaderAst::ExpressionType::None:
 				Append("void");
 				break;

src/Nazara/Renderer/ShaderAst.cpp

@@ -31,12 +31,22 @@ namespace Nz { namespace ShaderAst
 	}
 
 
-	void Variable::Register(ShaderWriter& visitor)
+	void NamedVariable::Register(ShaderWriter& visitor)
 	{
 		visitor.RegisterVariable(kind, name, type);
 	}
 
-	void Variable::Visit(ShaderWriter& visitor)
+	void NamedVariable::Visit(ShaderWriter& visitor)
+	{
+		visitor.Write(*this);
+	}
+
+
+	void BuiltinVariable::Register(ShaderWriter& visitor)
+	{
+	}
+
+	void BuiltinVariable::Visit(ShaderWriter& visitor)
 	{
 		visitor.Write(*this);
 	}