sid
/
NazaraEngine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

ShaderGraph: Improve GLSL generation by introducing DeclareVariable statement

This commit is contained in:
Lynix 2020-05-27 20:08:41 +02:00
parent e4348349da
commit 3fc4de26e3
9 changed files with 59 additions and 18 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/Nazara/Renderer/GlslWriter.hpp
View File

@ -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;

12
include/Nazara/Renderer/ShaderAst.hpp
View File

@ -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;
};
//////////////////////////////////////////////////////////////////////////

6
include/Nazara/Renderer/ShaderAst.inl
View File

@ -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)),

7
include/Nazara/Renderer/ShaderBuilder.hpp
View File

@ -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>

2
include/Nazara/Renderer/ShaderBuilder.inl
View File

@ -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)...);
}

1
include/Nazara/Renderer/ShaderWriter.hpp
View File

@ -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;

27
src/Nazara/Renderer/GlslWriter.cpp
View File

@ -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();

13
src/Nazara/Renderer/ShaderAst.cpp
View File

@ -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*/)
{
}

7
src/ShaderNode/ShaderGraph.cpp
View File

@ -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());
statements.emplace_back(Nz::ShaderBuilder::ExprStatement(Nz::ShaderBuilder::Assign(varExpression, expression)));
auto variable = Nz::ShaderBuilder::Variable("var" + std::to_string(varCount++), expression->GetExpressionType());
statements.emplace_back(Nz::ShaderBuilder::DeclareVariable(variable, expression));
varExpression = variable;
}
else
varExpression = expression;