ShaderGraph: Improve GLSL generation by introducing DeclareVariable statement

include/Nazara/Renderer/GlslWriter.hpp

@@ -37,6 +37,7 @@ namespace Nz
 			void Write(const ShaderAst::BuiltinVariable& node) override;
 			void Write(const ShaderAst::Cast& node) override;
 			void Write(const ShaderAst::Constant& node) override;
+			void Write(const ShaderAst::DeclareVariable& node) override;
 			void Write(const ShaderAst::ExpressionStatement& node) override;
 			void Write(const ShaderAst::NamedVariable& node) override;
 			void Write(const ShaderAst::NodePtr& node) override;
@@ -63,7 +64,6 @@ namespace Nz
 
 			struct Function
 			{
-				VariableContainer variables;
 				std::vector<ShaderAst::NamedVariablePtr> parameters;
 				ShaderAst::ExpressionType retType;
 				ShaderAst::StatementPtr node;

include/Nazara/Renderer/ShaderAst.hpp

@@ -193,6 +193,18 @@ namespace Nz
 
 				Nz::String name;
 		};
+		
+		class NAZARA_RENDERER_API DeclareVariable : public Statement
+		{
+			public:
+				inline DeclareVariable(NamedVariablePtr Variable, ExpressionPtr Expression = nullptr);
+
+				void Register(ShaderWriter& visitor) override;
+				void Visit(ShaderWriter& visitor) override;
+
+				NamedVariablePtr variable;
+				ExpressionPtr expression;
+		};
 
 		//////////////////////////////////////////////////////////////////////////
 

include/Nazara/Renderer/ShaderAst.inl

@@ -82,6 +82,12 @@ namespace Nz
 		{
 		}
 
+		inline DeclareVariable::DeclareVariable(NamedVariablePtr Variable, ExpressionPtr Expression) :
+		expression(std::move(Expression)),
+		variable(std::move(Variable))
+		{
+		}
+
 		inline AssignOp::AssignOp(AssignType Op, ExpressionPtr Left, ExpressionPtr Right) :
 		op(Op),
 		left(std::move(Left)),

include/Nazara/Renderer/ShaderBuilder.hpp

@@ -11,7 +11,7 @@
 #include <Nazara/Renderer/ShaderAst.hpp>
 #include <memory>
 
-namespace Nz { namespace ShaderBuilder
+namespace Nz::ShaderBuilder
 {
 	template<ShaderAst::AssignType op>
 	struct AssignOpBuilder
@@ -49,7 +49,7 @@ namespace Nz { namespace ShaderBuilder
 	{
 		constexpr VarBuilder() {}
 
-		template<typename... Args> std::shared_ptr<ShaderAst::Variable> operator()(Args&&... args) const;
+		template<typename... Args> ShaderAst::NamedVariablePtr operator()(Args&&... args) const;
 	};
 
 	constexpr BinOpBuilder<ShaderAst::BinaryType::Add> Add;
@@ -59,6 +59,7 @@ namespace Nz { namespace ShaderBuilder
 	constexpr GenBuilder<ShaderAst::Branch> Branch;
 	constexpr GenBuilder<ShaderAst::ConditionalStatement> ConditionalStatement;
 	constexpr GenBuilder<ShaderAst::Constant> Constant;
+	constexpr GenBuilder<ShaderAst::DeclareVariable> DeclareVariable;
 	constexpr BinOpBuilder<ShaderAst::BinaryType::Divide> Divide;
 	constexpr BinOpBuilder<ShaderAst::BinaryType::Equality> Equal;
 	constexpr GenBuilder<ShaderAst::ExpressionStatement> ExprStatement;
@@ -73,7 +74,7 @@ namespace Nz { namespace ShaderBuilder
 	constexpr VarBuilder<ShaderAst::VariableType::Variable> Variable;
 
 	template<ShaderAst::ExpressionType Type, typename... Args> std::shared_ptr<ShaderAst::Cast> Cast(Args&&... args);
-} }
+}
 
 #include <Nazara/Renderer/ShaderBuilder.inl>
 

include/Nazara/Renderer/ShaderBuilder.inl

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

include/Nazara/Renderer/ShaderWriter.hpp

@@ -38,6 +38,7 @@ namespace Nz
 			virtual void Write(const ShaderAst::BuiltinVariable& node) = 0;
 			virtual void Write(const ShaderAst::Cast& node) = 0;
 			virtual void Write(const ShaderAst::Constant& node) = 0;
+			virtual void Write(const ShaderAst::DeclareVariable& 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;

src/Nazara/Renderer/GlslWriter.cpp

@@ -66,6 +66,7 @@ namespace Nz
 		switch (kind)
 		{
 			case ShaderAst::VariableType::Builtin: //< Only there to make compiler happy
+			case ShaderAst::VariableType::Variable:
 				break;
 
 			case ShaderAst::VariableType::Input:
@@ -107,14 +108,6 @@ namespace Nz
 			case ShaderAst::VariableType::Uniform:
 				m_currentState->uniforms.emplace(type, name);
 				break;
-
-			case ShaderAst::VariableType::Variable:
-			{
-				if (m_currentFunction)
-					m_currentFunction->variables.emplace(type, name);
-
-				break;
-			}
 		}
 	}
 
@@ -262,6 +255,22 @@ namespace Nz
 		}
 	}
 
+	void GlslWriter::Write(const ShaderAst::DeclareVariable& node)
+	{
+		Append(node.variable->GetExpressionType());
+		Append(" ");
+		Append(node.variable->name);
+		if (node.expression)
+		{
+			Append(" ");
+			Append("=");
+			Append(" ");
+			Write(node.expression);
+		}
+
+		AppendLine(";");
+	}
+
 	void GlslWriter::Write(const ShaderAst::ExpressionStatement& node)
 	{
 		Write(node.expression);
@@ -404,8 +413,6 @@ namespace Nz
 
 		EnterScope();
 		{
-			DeclareVariables(func.variables);
-
 			Write(func.node);
 		}
 		LeaveScope();

src/Nazara/Renderer/ShaderAst.cpp

@@ -69,6 +69,19 @@ namespace Nz::ShaderAst
 	}
 
 
+	void DeclareVariable::Register(ShaderWriter& visitor)
+	{
+		variable->Register(visitor);
+
+		if (expression)
+			expression->Register(visitor);
+	}
+
+	void DeclareVariable::Visit(ShaderWriter& visitor)
+	{
+		visitor.Write(*this);
+	}
+
 	void BuiltinVariable::Register(ShaderWriter& /*visitor*/)
 	{
 	}

src/ShaderNode/ShaderGraph.cpp

@@ -107,7 +107,6 @@ Nz::ShaderAst::StatementPtr ShaderGraph::ToAst()
 	{
 		ShaderNode* shaderNode = static_cast<ShaderNode*>(node->nodeDataModel());
 
-		qDebug() << shaderNode->name() << node->id();
 		auto it = usageCount.find(node->id());
 		if (it == usageCount.end())
 		{
@@ -166,8 +165,10 @@ Nz::ShaderAst::StatementPtr ShaderGraph::ToAst()
 			Nz::ShaderAst::ExpressionPtr varExpression;
 			if (expression->GetExpressionCategory() == Nz::ShaderAst::ExpressionCategory::RValue)
 			{
-				varExpression = Nz::ShaderBuilder::Variable("var" + std::to_string(varCount++), expression->GetExpressionType());
+				auto variable = Nz::ShaderBuilder::Variable("var" + std::to_string(varCount++), expression->GetExpressionType());
-				statements.emplace_back(Nz::ShaderBuilder::ExprStatement(Nz::ShaderBuilder::Assign(varExpression, expression)));
+				statements.emplace_back(Nz::ShaderBuilder::DeclareVariable(variable, expression));
+
+				varExpression = variable;
 			}
 			else
 				varExpression = expression;