From df162a8beafb54654423b5e83acdf47bad9989ff Mon Sep 17 00:00:00 2001 From: Lynix Date: Tue, 3 Jan 2017 14:40:49 +0100 Subject: [PATCH 01/30] Commit current work --- include/Nazara/Renderer/GlslWriter.hpp | 73 +++++++ include/Nazara/Renderer/ShaderAst.hpp | 197 +++++++++++++++++ include/Nazara/Renderer/ShaderAst.inl | 58 +++++ include/Nazara/Renderer/ShaderBuilder.hpp | 70 ++++++ include/Nazara/Renderer/ShaderBuilder.inl | 15 ++ include/Nazara/Renderer/ShaderWriter.hpp | 40 ++++ src/Nazara/Renderer/GlslWriter.cpp | 253 ++++++++++++++++++++++ src/Nazara/Renderer/ShaderAst.cpp | 96 ++++++++ src/Nazara/Renderer/ShaderWriter.cpp | 11 + 9 files changed, 813 insertions(+) create mode 100644 include/Nazara/Renderer/GlslWriter.hpp create mode 100644 include/Nazara/Renderer/ShaderAst.hpp create mode 100644 include/Nazara/Renderer/ShaderAst.inl create mode 100644 include/Nazara/Renderer/ShaderBuilder.hpp create mode 100644 include/Nazara/Renderer/ShaderBuilder.inl create mode 100644 include/Nazara/Renderer/ShaderWriter.hpp create mode 100644 src/Nazara/Renderer/GlslWriter.cpp create mode 100644 src/Nazara/Renderer/ShaderAst.cpp create mode 100644 src/Nazara/Renderer/ShaderWriter.cpp diff --git a/include/Nazara/Renderer/GlslWriter.hpp b/include/Nazara/Renderer/GlslWriter.hpp new file mode 100644 index 000000000..121f50ab7 --- /dev/null +++ b/include/Nazara/Renderer/GlslWriter.hpp @@ -0,0 +1,73 @@ +// Copyright (C) 2016 Jérôme Leclercq +// This file is part of the "Nazara Engine - Renderer module" +// For conditions of distribution and use, see copyright notice in Config.hpp + +#pragma once + +#ifndef NAZARA_GLSLWRITER_HPP +#define NAZARA_GLSLWRITER_HPP + +#include +#include +#include +#include +#include +#include +#include + +namespace Nz +{ + class NAZARA_RENDERER_API GlslWriter : public ShaderWriter + { + public: + GlslWriter(); + GlslWriter(const GlslWriter&) = delete; + GlslWriter(GlslWriter&&) = delete; + ~GlslWriter() = default; + + Nz::String Generate(const ShaderAst::StatementPtr& node) override; + + void RegisterFunction(const String& name, ShaderAst::StatementPtr statement, std::initializer_list parameters, ShaderAst::ExpressionType ret) override; + void RegisterVariable(const String& name, ShaderAst::ExpressionType type) override; + + 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::Constant& node) override; + void Write(const ShaderAst::ExpressionStatement& 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::ExpressionType type); + void Append(const String& txt); + void AppendFunction(const Function& func); + void AppendLine(const Nz::String& txt = Nz::String()); + + void EnterScope(); + void LeaveScope(); + + struct Function + { + std::vector parameters; + ShaderAst::ExpressionType retType; + ShaderAst::StatementPtr node; + String name; + }; + + struct State + { + std::set> m_variables; + StringStream stream; + unsigned int indentLevel = 0; + }; + + std::unordered_map m_functions; + State* m_currentState; + }; +} + +#endif // NAZARA_GLSLWRITER_HPP diff --git a/include/Nazara/Renderer/ShaderAst.hpp b/include/Nazara/Renderer/ShaderAst.hpp new file mode 100644 index 000000000..be6ac2c29 --- /dev/null +++ b/include/Nazara/Renderer/ShaderAst.hpp @@ -0,0 +1,197 @@ +// Copyright (C) 2016 Jérôme Leclercq +// This file is part of the "Nazara Engine - Renderer module" +// For conditions of distribution and use, see copyright notice in Config.hpp + +#pragma once + +#ifndef NAZARA_SHADER_AST_HPP +#define NAZARA_SHADER_AST_HPP + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace Nz +{ + class ShaderWriter; + + namespace ShaderAst + { + enum class AssignType + { + Simple //< = + }; + + enum class BinaryType + { + Add, //< + + Substract, //< - + Multiply, //< * + Divide, //< / + Equality //< == + }; + + enum class ExpressionType + { + Float1, // float + Float2, // vec2 + Float3, // vec3 + Float4, // vec4 + + None // void + }; + + enum class VariableType + { + Parameter, + Variable, + Uniform + }; + + ////////////////////////////////////////////////////////////////////////// + + class Node; + + using NodePtr = std::shared_ptr; + + class NAZARA_RENDERER_API Node + { + public: + virtual ~Node() = default; + + virtual void Register(ShaderWriter& visitor) = 0; + virtual void Visit(ShaderWriter& visitor) = 0; + }; + + class Statement; + + using StatementPtr = std::shared_ptr; + + class NAZARA_RENDERER_API Statement : public Node + { + }; + + class Expression; + + using ExpressionPtr = std::shared_ptr; + + class NAZARA_RENDERER_API Expression : public Node + { + }; + + class NAZARA_RENDERER_API ExpressionStatement : public Statement + { + public: + inline explicit ExpressionStatement(ExpressionPtr expr); + + void Register(ShaderWriter& visitor) override; + void Visit(ShaderWriter& visitor) override; + + ExpressionPtr expression; + }; + + ////////////////////////////////////////////////////////////////////////// + + class NAZARA_RENDERER_API StatementBlock : public Statement + { + public: + template explicit StatementBlock(Args&&... args); + + void Register(ShaderWriter& visitor) override; + void Visit(ShaderWriter& visitor) override; + + std::vector statements; + }; + + class Variable; + + using VariablePtr = std::shared_ptr; + + class NAZARA_RENDERER_API Variable : public Expression + { + public: + inline Variable(VariableType varKind, const Nz::String& varName, ExpressionType varType); + + void Register(ShaderWriter& visitor) override; + void Visit(ShaderWriter& visitor) override; + + ExpressionType type; + VariableType kind; + Nz::String name; + }; + + ////////////////////////////////////////////////////////////////////////// + + class NAZARA_RENDERER_API AssignOp : public Expression + { + public: + inline AssignOp(AssignType Op, VariablePtr Var, ExpressionPtr Right); + + void Register(ShaderWriter& visitor) override; + void Visit(ShaderWriter& visitor) override; + + AssignType op; + VariablePtr variable; + ExpressionPtr right; + }; + + class NAZARA_RENDERER_API BinaryOp : public Expression + { + public: + inline BinaryOp(BinaryType Op, ExpressionPtr Left, ExpressionPtr Right); + + void Register(ShaderWriter& visitor) override; + void Visit(ShaderWriter& visitor) override; + + BinaryType op; + ExpressionPtr left; + ExpressionPtr right; + }; + + class NAZARA_RENDERER_API Branch : public Statement + { + public: + inline Branch(ExpressionPtr condition, StatementPtr trueStatement, StatementPtr falseStatement = nullptr); + + void Register(ShaderWriter& visitor) override; + void Visit(ShaderWriter& visitor) override; + + struct ConditionalStatement + { + ExpressionPtr condition; + StatementPtr statement; + }; + + std::vector condStatements; + StatementPtr elseStatement; + }; + + class NAZARA_RENDERER_API Constant : public Expression + { + public: + inline explicit Constant(float value); + + void Register(ShaderWriter& visitor) override; + void Visit(ShaderWriter& visitor) override; + + ExpressionType exprType; + + union + { + float vec1; + Nz::Vector2f vec2; + Nz::Vector3f vec3; + Nz::Vector4f vec4; + } values; + }; + } +} + +#include + +#endif // NAZARA_SHADER_AST_HPP diff --git a/include/Nazara/Renderer/ShaderAst.inl b/include/Nazara/Renderer/ShaderAst.inl new file mode 100644 index 000000000..cb98bbdac --- /dev/null +++ b/include/Nazara/Renderer/ShaderAst.inl @@ -0,0 +1,58 @@ +// Copyright (C) 2016 Jérôme Leclercq +// This file is part of the "Nazara Engine - Renderer module" +// For conditions of distribution and use, see copyright notice in Config.hpp + +#include +#include + +namespace Nz +{ + namespace ShaderAst + { + inline ExpressionStatement::ExpressionStatement(ExpressionPtr expr) : + expression(std::move(expr)) + { + } + + template + StatementBlock::StatementBlock(Args&& ...args) : + statements({std::forward(args)...}) + { + } + + inline Variable::Variable(VariableType varKind, const Nz::String& varName, ExpressionType varType) : + kind(varKind), + name(varName), + type(varType) + { + } + + inline AssignOp::AssignOp(AssignType Op, VariablePtr Var, ExpressionPtr Right) : + op(Op), + variable(std::move(Var)), + right(std::move(Right)) + { + } + + inline BinaryOp::BinaryOp(BinaryType Op, ExpressionPtr Left, ExpressionPtr Right) : + op(Op), + left(std::move(Left)), + right(std::move(Right)) + { + } + + inline Branch::Branch(ExpressionPtr condition, StatementPtr trueStatement, StatementPtr falseStatement) + { + condStatements.emplace_back(ConditionalStatement{ std::move(condition), std::move(trueStatement) }); + elseStatement = std::move(falseStatement); + } + + inline Constant::Constant(float value) : + exprType(ExpressionType::Float1) + { + values.vec1 = value; + } + } +} + +#include diff --git a/include/Nazara/Renderer/ShaderBuilder.hpp b/include/Nazara/Renderer/ShaderBuilder.hpp new file mode 100644 index 000000000..75d43ae8b --- /dev/null +++ b/include/Nazara/Renderer/ShaderBuilder.hpp @@ -0,0 +1,70 @@ +// Copyright (C) 2016 Jérôme Leclercq +// This file is part of the "Nazara Engine - Renderer module" +// For conditions of distribution and use, see copyright notice in Config.hpp + +#pragma once + +#ifndef NAZARA_SHADER_BUILDER_HPP +#define NAZARA_SHADER_BUILDER_HPP + +#include +#include +#include + +namespace Nz { namespace ShaderBuilder +{ + template + class GenBuilder + { + public: + template + std::shared_ptr operator()(Args&&... args) const + { + return std::make_shared(std::forward(args)...); + } + }; + + template + class AssignOpBuilder + { + public: + std::shared_ptr operator()(const Nz::ShaderAst::VariablePtr& left, const Nz::ShaderAst::ExpressionPtr& right) const + { + return std::make_shared(op, left, right); + } + }; + + template + class BinOpBuilder + { + public: + std::shared_ptr operator()(const Nz::ShaderAst::ExpressionPtr& left, const Nz::ShaderAst::ExpressionPtr& right) const + { + return std::make_shared(op, left, right); + } + }; + + template + class VarBuilder + { + public: + template + std::shared_ptr operator()(Args&&... args) const + { + return std::make_shared(type, std::forward(args)...); + } + }; + + constexpr BinOpBuilder Add; + constexpr AssignOpBuilder Assign; + constexpr BinOpBuilder Equal; + constexpr GenBuilder Block; + constexpr GenBuilder Branch; + constexpr GenBuilder Constant; + constexpr GenBuilder ExprStatement; + constexpr VarBuilder Variable; +} } + +#include + +#endif // NAZARA_SHADER_BUILDER_HPP diff --git a/include/Nazara/Renderer/ShaderBuilder.inl b/include/Nazara/Renderer/ShaderBuilder.inl new file mode 100644 index 000000000..94ab292ec --- /dev/null +++ b/include/Nazara/Renderer/ShaderBuilder.inl @@ -0,0 +1,15 @@ +// Copyright (C) 2016 Jérôme Leclercq +// This file is part of the "Nazara Engine - Renderer module" +// For conditions of distribution and use, see copyright notice in Config.hpp + +#include +#include + +namespace Nz +{ + namespace ShaderAst + { + } +} + +#include diff --git a/include/Nazara/Renderer/ShaderWriter.hpp b/include/Nazara/Renderer/ShaderWriter.hpp new file mode 100644 index 000000000..4e006ffb4 --- /dev/null +++ b/include/Nazara/Renderer/ShaderWriter.hpp @@ -0,0 +1,40 @@ +// Copyright (C) 2015 Jérôme Leclercq +// This file is part of the "Nazara Engine - Renderer module" +// For conditions of distribution and use, see copyright notice in Config.hpp + +#pragma once + +#ifndef NAZARA_SHADERWRITER_HPP +#define NAZARA_SHADERWRITER_HPP + +#include +#include +#include + +namespace Nz +{ + class NAZARA_RENDERER_API ShaderWriter + { + public: + ShaderWriter() = default; + ShaderWriter(const ShaderWriter&) = delete; + ShaderWriter(ShaderWriter&&) = delete; + virtual ~ShaderWriter(); + + virtual Nz::String Generate(const ShaderAst::StatementPtr& node) = 0; + + virtual void RegisterFunction(const String& name, ShaderAst::StatementPtr node, std::initializer_list parameters, ShaderAst::ExpressionType ret) = 0; + virtual void RegisterVariable(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::Constant& node) = 0; + virtual void Write(const ShaderAst::ExpressionStatement& 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; + }; +} + +#endif // NAZARA_SHADERWRITER_HPP diff --git a/src/Nazara/Renderer/GlslWriter.cpp b/src/Nazara/Renderer/GlslWriter.cpp new file mode 100644 index 000000000..bbb542e21 --- /dev/null +++ b/src/Nazara/Renderer/GlslWriter.cpp @@ -0,0 +1,253 @@ +// Copyright (C) 2015 Jérôme Leclercq +// This file is part of the "Nazara Engine - Renderer module" +// For conditions of distribution and use, see copyright notice in Config.hpp + +#include +#include +#include + +namespace Nz +{ + GlslWriter::GlslWriter() : + m_currentState(nullptr) + { + } + + String GlslWriter::Generate(const ShaderAst::StatementPtr& node) + { + State state; + m_currentState = &state; + CallOnExit onExit([this]() + { + m_currentState = nullptr; + }); + + node->Register(*this); + + for (const auto& pair : state.m_variables) + { + Append(pair.first); + Append(" "); + Append(pair.second); + AppendLine(";"); + } + + AppendLine(); + + Function entryPoint; + entryPoint.name = "main"; //< GLSL has only one entry point name possible + entryPoint.node = node; + entryPoint.retType = ShaderAst::ExpressionType::None; + + AppendFunction(entryPoint); + + return state.stream; + } + + void GlslWriter::RegisterFunction(const String& name, ShaderAst::StatementPtr statement, std::initializer_list parameters, ShaderAst::ExpressionType retType) + { + Function func; + func.retType = retType; + func.name = name; + func.node = std::move(statement); + func.parameters.assign(parameters); + + m_functions[name] = std::move(func); + } + + void GlslWriter::RegisterVariable(const String& name, ShaderAst::ExpressionType type) + { + NazaraAssert(m_currentState, "This function should only be called while processing an AST"); + + m_currentState->m_variables.insert(std::make_pair(type, name)); + } + + void GlslWriter::Write(const ShaderAst::NodePtr& node) + { + node->Visit(*this); + } + + void GlslWriter::Write(const ShaderAst::AssignOp& node) + { + Write(node.variable); + + switch (node.op) + { + case ShaderAst::AssignType::Simple: + Append(" = "); + break; + } + + Write(node.right); + } + + void GlslWriter::Write(const ShaderAst::Branch& node) + { + bool first = true; + for (const auto& statement : node.condStatements) + { + if (!first) + Append("else "); + + Append("if ("); + Write(statement.condition); + AppendLine(")"); + + EnterScope(); + Write(statement.statement); + LeaveScope(); + + first = false; + } + + if (node.elseStatement) + { + AppendLine("else"); + + EnterScope(); + Write(node.elseStatement); + LeaveScope(); + } + } + + void GlslWriter::Write(const ShaderAst::BinaryOp& node) + { + Write(node.left); + + switch (node.op) + { + case ShaderAst::BinaryType::Add: + Append(" + "); + break; + case ShaderAst::BinaryType::Substract: + Append(" - "); + break; + case ShaderAst::BinaryType::Multiply: + Append(" * "); + break; + case ShaderAst::BinaryType::Divide: + Append(" / "); + break; + case ShaderAst::BinaryType::Equality: + Append(" == "); + break; + } + + Write(node.right); + } + + void GlslWriter::Write(const ShaderAst::Constant& node) + { + switch (node.exprType) + { + case ShaderAst::ExpressionType::Float1: + Append(String::Format("%F", node.values.vec1)); + break; + } + } + + void GlslWriter::Write(const ShaderAst::ExpressionStatement& node) + { + Write(node.expression); + Append(";"); + } + + void GlslWriter::Write(const ShaderAst::StatementBlock& node) + { + bool first = true; + for (const ShaderAst::StatementPtr& statement : node.statements) + { + if (!first) + AppendLine(); + + Write(statement); + + first = false; + } + } + + void GlslWriter::Write(const ShaderAst::Variable& node) + { + Append(node.name); + } + + void GlslWriter::Append(ShaderAst::ExpressionType type) + { + switch (type) + { + case ShaderAst::ExpressionType::Float1: + Append("float"); + break; + case ShaderAst::ExpressionType::Float2: + Append("vec2"); + break; + case ShaderAst::ExpressionType::Float3: + Append("vec3"); + break; + case ShaderAst::ExpressionType::Float4: + Append("vec4"); + break; + case ShaderAst::ExpressionType::None: + Append("void"); + break; + } + } + + void GlslWriter::Append(const String& txt) + { + NazaraAssert(m_currentState, "This function should only be called while processing an AST"); + + m_currentState->stream << txt; + } + + void GlslWriter::AppendFunction(const Function& func) + { + NazaraAssert(m_currentState, "This function should only be called while processing an AST"); + + Append(func.retType); + + m_currentState->stream << ' '; + Append(func.name); + + m_currentState->stream << '('; + for (std::size_t i = 0; i < func.parameters.size(); ++i) + { + if (i != 0) + m_currentState->stream << ", "; + + Append(func.parameters[i]->type); + m_currentState->stream << ' '; + Append(func.parameters[i]->name); + } + m_currentState->stream << ")\n"; + + EnterScope(); + Write(func.node); + LeaveScope(); + } + + void GlslWriter::AppendLine(const String& txt) + { + NazaraAssert(m_currentState, "This function should only be called while processing an AST"); + + m_currentState->stream << txt << '\n' << String(m_currentState->indentLevel, '\t'); + } + + void GlslWriter::EnterScope() + { + NazaraAssert(m_currentState, "This function should only be called while processing an AST"); + + m_currentState->indentLevel++; + AppendLine("{"); + } + + void GlslWriter::LeaveScope() + { + NazaraAssert(m_currentState, "This function should only be called while processing an AST"); + + m_currentState->indentLevel--; + AppendLine(); + AppendLine("}"); + } + +} diff --git a/src/Nazara/Renderer/ShaderAst.cpp b/src/Nazara/Renderer/ShaderAst.cpp new file mode 100644 index 000000000..3402eb987 --- /dev/null +++ b/src/Nazara/Renderer/ShaderAst.cpp @@ -0,0 +1,96 @@ +// Copyright (C) 2016 Jérôme Leclercq +// This file is part of the "Nazara Engine - Renderer module" +// For conditions of distribution and use, see copyright notice in Config.hpp + +#include +#include +#include + +namespace Nz { namespace ShaderAst +{ + void ExpressionStatement::Register(ShaderWriter& visitor) + { + expression->Register(visitor); + } + + void ExpressionStatement::Visit(ShaderWriter& visitor) + { + visitor.Write(*this); + } + + + void StatementBlock::Register(ShaderWriter& visitor) + { + for (auto& statementPtr : statements) + statementPtr->Register(visitor); + } + + void StatementBlock::Visit(ShaderWriter& visitor) + { + visitor.Write(*this); + } + + + void Variable::Register(ShaderWriter& visitor) + { + visitor.RegisterVariable(name, type); + } + + void Variable::Visit(ShaderWriter& visitor) + { + visitor.Write(*this); + } + + + void AssignOp::Register(ShaderWriter& visitor) + { + variable->Register(visitor); + right->Register(visitor); + } + + void AssignOp::Visit(ShaderWriter& visitor) + { + visitor.Write(*this); + } + + + void BinaryOp::Register(ShaderWriter& visitor) + { + left->Register(visitor); + right->Register(visitor); + } + + void BinaryOp::Visit(ShaderWriter& visitor) + { + visitor.Write(*this); + } + + + void Branch::Register(ShaderWriter& visitor) + { + for (ConditionalStatement& statement : condStatements) + { + statement.condition->Register(visitor); + statement.statement->Register(visitor); + } + + if (elseStatement) + elseStatement->Register(visitor); + } + + void Branch::Visit(ShaderWriter& visitor) + { + visitor.Write(*this); + } + + + void Constant::Register(ShaderWriter&) + { + } + + void Constant::Visit(ShaderWriter& visitor) + { + visitor.Write(*this); + } +} +} diff --git a/src/Nazara/Renderer/ShaderWriter.cpp b/src/Nazara/Renderer/ShaderWriter.cpp new file mode 100644 index 000000000..8ca48da3e --- /dev/null +++ b/src/Nazara/Renderer/ShaderWriter.cpp @@ -0,0 +1,11 @@ +// Copyright (C) 2015 Jérôme Leclercq +// This file is part of the "Nazara Engine - Renderer module" +// For conditions of distribution and use, see copyright notice in Config.hpp + +#include +#include + +namespace Nz +{ + ShaderWriter::~ShaderWriter() = default; +} From bfff04a936f2299a7a3afcd538fdbfd9a879bab4 Mon Sep 17 00:00:00 2001 From: Lynix Date: Wed, 4 Jan 2017 11:39:57 +0100 Subject: [PATCH 02/30] Renderer/GlslWriter: Move variables to the function scope --- include/Nazara/Renderer/GlslWriter.hpp | 6 ++++-- src/Nazara/Renderer/GlslWriter.cpp | 29 +++++++++++++++++++++++--- 2 files changed, 30 insertions(+), 5 deletions(-) diff --git a/include/Nazara/Renderer/GlslWriter.hpp b/include/Nazara/Renderer/GlslWriter.hpp index 121f50ab7..bd1ab781b 100644 --- a/include/Nazara/Renderer/GlslWriter.hpp +++ b/include/Nazara/Renderer/GlslWriter.hpp @@ -44,7 +44,7 @@ namespace Nz void Append(ShaderAst::ExpressionType type); void Append(const String& txt); - void AppendFunction(const Function& func); + void AppendFunction(Function& func); void AppendLine(const Nz::String& txt = Nz::String()); void EnterScope(); @@ -52,6 +52,7 @@ namespace Nz struct Function { + std::set> variables; std::vector parameters; ShaderAst::ExpressionType retType; ShaderAst::StatementPtr node; @@ -60,12 +61,13 @@ namespace Nz struct State { - std::set> m_variables; + std::set> m_uniforms; StringStream stream; unsigned int indentLevel = 0; }; std::unordered_map m_functions; + Function* m_currentFunction; State* m_currentState; }; } diff --git a/src/Nazara/Renderer/GlslWriter.cpp b/src/Nazara/Renderer/GlslWriter.cpp index bbb542e21..588f0c886 100644 --- a/src/Nazara/Renderer/GlslWriter.cpp +++ b/src/Nazara/Renderer/GlslWriter.cpp @@ -9,6 +9,7 @@ namespace Nz { GlslWriter::GlslWriter() : + m_currentFunction(nullptr), m_currentState(nullptr) { } @@ -24,7 +25,7 @@ namespace Nz node->Register(*this); - for (const auto& pair : state.m_variables) + for (const auto& pair : state.m_uniforms) { Append(pair.first); Append(" "); @@ -59,7 +60,8 @@ namespace Nz { NazaraAssert(m_currentState, "This function should only be called while processing an AST"); - m_currentState->m_variables.insert(std::make_pair(type, name)); + if (m_currentFunction) + m_currentFunction->variables.insert(std::make_pair(type, name)); } void GlslWriter::Write(const ShaderAst::NodePtr& node) @@ -200,10 +202,19 @@ namespace Nz m_currentState->stream << txt; } - void GlslWriter::AppendFunction(const Function& func) + void GlslWriter::AppendFunction(Function& func) { + NazaraAssert(!m_currentFunction, "A function is already being processed"); NazaraAssert(m_currentState, "This function should only be called while processing an AST"); + m_currentFunction = &func; + CallOnExit onExit([this] () + { + m_currentFunction = nullptr; + }); + + func.node->Register(*this); + Append(func.retType); m_currentState->stream << ' '; @@ -222,7 +233,19 @@ namespace Nz m_currentState->stream << ")\n"; EnterScope(); + { + for (const auto& pair : func.variables) + { + Append(pair.first); + Append(" "); + Append(pair.second); + AppendLine(";"); + } + + AppendLine(); + Write(func.node); + } LeaveScope(); } From 487ada825edadc73d0411978455b4e14a3fe529f Mon Sep 17 00:00:00 2001 From: Lynix Date: Wed, 4 Jan 2017 12:34:47 +0100 Subject: [PATCH 03/30] Renderer/GlslWriter: Add support for Uniform and Parameters variables --- include/Nazara/Renderer/GlslWriter.hpp | 2 +- include/Nazara/Renderer/ShaderBuilder.hpp | 2 + include/Nazara/Renderer/ShaderWriter.hpp | 2 +- src/Nazara/Renderer/GlslWriter.cpp | 65 +++++++++++++++++++---- src/Nazara/Renderer/ShaderAst.cpp | 2 +- 5 files changed, 60 insertions(+), 13 deletions(-) diff --git a/include/Nazara/Renderer/GlslWriter.hpp b/include/Nazara/Renderer/GlslWriter.hpp index bd1ab781b..20e4cacc7 100644 --- a/include/Nazara/Renderer/GlslWriter.hpp +++ b/include/Nazara/Renderer/GlslWriter.hpp @@ -28,7 +28,7 @@ namespace Nz Nz::String Generate(const ShaderAst::StatementPtr& node) override; void RegisterFunction(const String& name, ShaderAst::StatementPtr statement, std::initializer_list parameters, ShaderAst::ExpressionType ret) override; - void RegisterVariable(const String& name, ShaderAst::ExpressionType type) override; + void RegisterVariable(ShaderAst::VariableType kind, const String& name, ShaderAst::ExpressionType type) override; void Write(const ShaderAst::AssignOp& node) override; void Write(const ShaderAst::Branch& node) override; diff --git a/include/Nazara/Renderer/ShaderBuilder.hpp b/include/Nazara/Renderer/ShaderBuilder.hpp index 75d43ae8b..9f9d5f820 100644 --- a/include/Nazara/Renderer/ShaderBuilder.hpp +++ b/include/Nazara/Renderer/ShaderBuilder.hpp @@ -62,6 +62,8 @@ namespace Nz { namespace ShaderBuilder constexpr GenBuilder Branch; constexpr GenBuilder Constant; constexpr GenBuilder ExprStatement; + constexpr VarBuilder Parameter; + constexpr VarBuilder Uniform; constexpr VarBuilder Variable; } } diff --git a/include/Nazara/Renderer/ShaderWriter.hpp b/include/Nazara/Renderer/ShaderWriter.hpp index 4e006ffb4..9b87ca5f7 100644 --- a/include/Nazara/Renderer/ShaderWriter.hpp +++ b/include/Nazara/Renderer/ShaderWriter.hpp @@ -24,7 +24,7 @@ namespace Nz virtual Nz::String Generate(const ShaderAst::StatementPtr& node) = 0; virtual void RegisterFunction(const String& name, ShaderAst::StatementPtr node, std::initializer_list parameters, ShaderAst::ExpressionType ret) = 0; - virtual void RegisterVariable(const String& name, ShaderAst::ExpressionType type) = 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; diff --git a/src/Nazara/Renderer/GlslWriter.cpp b/src/Nazara/Renderer/GlslWriter.cpp index 588f0c886..b1d4dc32a 100644 --- a/src/Nazara/Renderer/GlslWriter.cpp +++ b/src/Nazara/Renderer/GlslWriter.cpp @@ -25,15 +25,20 @@ namespace Nz node->Register(*this); - for (const auto& pair : state.m_uniforms) + // Uniforms + if (state.m_uniforms.empty()) { - Append(pair.first); - Append(" "); - Append(pair.second); - AppendLine(";"); - } + for (const auto& pair : state.m_uniforms) + { + Append("uniform "); + Append(pair.first); + Append(" "); + Append(pair.second); + AppendLine(";"); + } - AppendLine(); + AppendLine(); + } Function entryPoint; entryPoint.name = "main"; //< GLSL has only one entry point name possible @@ -56,12 +61,52 @@ namespace Nz m_functions[name] = std::move(func); } - void GlslWriter::RegisterVariable(const String& name, ShaderAst::ExpressionType type) + void GlslWriter::RegisterVariable(ShaderAst::VariableType kind, const String& name, ShaderAst::ExpressionType type) { NazaraAssert(m_currentState, "This function should only be called while processing an AST"); - if (m_currentFunction) - m_currentFunction->variables.insert(std::make_pair(type, name)); + switch (kind) + { + case ShaderAst::VariableType::Parameter: + { + if (m_currentFunction) + { + bool found = false; + for (const auto& varPtr : m_currentFunction->parameters) + { + if (varPtr->name == name) + { + found = true; + if (varPtr->type != type) + { + //TODO: AstParseError + throw std::runtime_error("Function uses parameter \"" + name + "\" with a different type than specified in the function arguments"); + } + + break; + } + } + + if (!found) + //TODO: AstParseError + throw std::runtime_error("Function has no parameter \"" + name + "\""); + } + + break; + } + + case ShaderAst::VariableType::Uniform: + m_currentState->m_uniforms.insert(std::make_pair(type, name)); + break; + + case ShaderAst::VariableType::Variable: + { + if (m_currentFunction) + m_currentFunction->variables.insert(std::make_pair(type, name)); + + break; + } + } } void GlslWriter::Write(const ShaderAst::NodePtr& node) diff --git a/src/Nazara/Renderer/ShaderAst.cpp b/src/Nazara/Renderer/ShaderAst.cpp index 3402eb987..7de149699 100644 --- a/src/Nazara/Renderer/ShaderAst.cpp +++ b/src/Nazara/Renderer/ShaderAst.cpp @@ -33,7 +33,7 @@ namespace Nz { namespace ShaderAst void Variable::Register(ShaderWriter& visitor) { - visitor.RegisterVariable(name, type); + visitor.RegisterVariable(kind, name, type); } void Variable::Visit(ShaderWriter& visitor) From 4b0b45300175d298e7dbdb997e411e6b51872775 Mon Sep 17 00:00:00 2001 From: Lynix Date: Wed, 4 Jan 2017 12:35:27 +0100 Subject: [PATCH 04/30] Renderer/GlslWriter: Add #version directive --- include/Nazara/Renderer/GlslWriter.hpp | 3 +++ src/Nazara/Renderer/GlslWriter.cpp | 13 ++++++++++++- 2 files changed, 15 insertions(+), 1 deletion(-) diff --git a/include/Nazara/Renderer/GlslWriter.hpp b/include/Nazara/Renderer/GlslWriter.hpp index 20e4cacc7..59bfd11e5 100644 --- a/include/Nazara/Renderer/GlslWriter.hpp +++ b/include/Nazara/Renderer/GlslWriter.hpp @@ -30,6 +30,8 @@ namespace Nz void RegisterFunction(const String& name, ShaderAst::StatementPtr statement, std::initializer_list parameters, ShaderAst::ExpressionType ret) override; void RegisterVariable(ShaderAst::VariableType kind, const String& name, ShaderAst::ExpressionType type) override; + void SetGlslVersion(unsigned int version); + void Write(const ShaderAst::AssignOp& node) override; void Write(const ShaderAst::Branch& node) override; void Write(const ShaderAst::BinaryOp& node) override; @@ -69,6 +71,7 @@ namespace Nz std::unordered_map m_functions; Function* m_currentFunction; State* m_currentState; + unsigned int m_glslVersion; }; } diff --git a/src/Nazara/Renderer/GlslWriter.cpp b/src/Nazara/Renderer/GlslWriter.cpp index b1d4dc32a..2cada3704 100644 --- a/src/Nazara/Renderer/GlslWriter.cpp +++ b/src/Nazara/Renderer/GlslWriter.cpp @@ -10,7 +10,8 @@ namespace Nz { GlslWriter::GlslWriter() : m_currentFunction(nullptr), - m_currentState(nullptr) + m_currentState(nullptr), + m_glslVersion(110) { } @@ -25,6 +26,11 @@ namespace Nz node->Register(*this); + // Header + Append("#version "); + AppendLine(String::Number(m_glslVersion)); + AppendLine(); + // Uniforms if (state.m_uniforms.empty()) { @@ -109,6 +115,11 @@ namespace Nz } } + void GlslWriter::SetGlslVersion(unsigned int version) + { + m_glslVersion = version; + } + void GlslWriter::Write(const ShaderAst::NodePtr& node) { node->Visit(*this); From 65fd942dff290bd0ce1c331a7668a13aa1d5577a Mon Sep 17 00:00:00 2001 From: Lynix Date: Wed, 4 Jan 2017 14:00:46 +0100 Subject: [PATCH 05/30] Renderer/GlslWriter: Fix typo --- src/Nazara/Renderer/GlslWriter.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Nazara/Renderer/GlslWriter.cpp b/src/Nazara/Renderer/GlslWriter.cpp index 2cada3704..69e76422a 100644 --- a/src/Nazara/Renderer/GlslWriter.cpp +++ b/src/Nazara/Renderer/GlslWriter.cpp @@ -32,7 +32,7 @@ namespace Nz AppendLine(); // Uniforms - if (state.m_uniforms.empty()) + if (!state.m_uniforms.empty()) { for (const auto& pair : state.m_uniforms) { From ba4ce41d41fd6d6708a4016af2789dd7ad2f47a9 Mon Sep 17 00:00:00 2001 From: Lynix Date: Wed, 4 Jan 2017 14:00:58 +0100 Subject: [PATCH 06/30] Renderer/GlslWriter: Add comment sections --- include/Nazara/Renderer/GlslWriter.hpp | 1 + src/Nazara/Renderer/GlslWriter.cpp | 12 ++++++++++++ 2 files changed, 13 insertions(+) diff --git a/include/Nazara/Renderer/GlslWriter.hpp b/include/Nazara/Renderer/GlslWriter.hpp index 59bfd11e5..0258d0c57 100644 --- a/include/Nazara/Renderer/GlslWriter.hpp +++ b/include/Nazara/Renderer/GlslWriter.hpp @@ -46,6 +46,7 @@ namespace Nz void Append(ShaderAst::ExpressionType type); void Append(const String& txt); + void AppendCommentSection(const String& section); void AppendFunction(Function& func); void AppendLine(const Nz::String& txt = Nz::String()); diff --git a/src/Nazara/Renderer/GlslWriter.cpp b/src/Nazara/Renderer/GlslWriter.cpp index 69e76422a..94349fec0 100644 --- a/src/Nazara/Renderer/GlslWriter.cpp +++ b/src/Nazara/Renderer/GlslWriter.cpp @@ -34,6 +34,9 @@ namespace Nz // Uniforms if (!state.m_uniforms.empty()) { + AppendCommentSection("Uniforms"); + AppendLine(); + for (const auto& pair : state.m_uniforms) { Append("uniform "); @@ -258,6 +261,15 @@ namespace Nz m_currentState->stream << txt; } + void GlslWriter::AppendCommentSection(const String& section) + { + NazaraAssert(m_currentState, "This function should only be called while processing an AST"); + + String stars((section.GetSize() < 33) ? (36 - section.GetSize()) / 2 : 3, '*'); + m_currentState->stream << "/*" << stars << ' ' << section << ' ' << stars << "*/"; + AppendLine(); + } + void GlslWriter::AppendFunction(Function& func) { NazaraAssert(!m_currentFunction, "A function is already being processed"); From 553616fa33cb1a1354b2012e05e5739f0814f887 Mon Sep 17 00:00:00 2001 From: Lynix Date: Thu, 5 Jan 2017 13:56:01 +0100 Subject: [PATCH 07/30] Renderer/ShaderAst: Add NamedVariable and BuiltinVariable classes --- include/Nazara/Renderer/GlslWriter.hpp | 8 +++-- include/Nazara/Renderer/ShaderAst.hpp | 37 ++++++++++++++++++++--- include/Nazara/Renderer/ShaderAst.inl | 15 +++++++-- include/Nazara/Renderer/ShaderBuilder.hpp | 2 +- include/Nazara/Renderer/ShaderWriter.hpp | 5 +-- src/Nazara/Renderer/GlslWriter.cpp | 24 +++++++++++++-- src/Nazara/Renderer/ShaderAst.cpp | 14 +++++++-- 7 files changed, 88 insertions(+), 17 deletions(-) diff --git a/include/Nazara/Renderer/GlslWriter.hpp b/include/Nazara/Renderer/GlslWriter.hpp index 0258d0c57..39a557040 100644 --- a/include/Nazara/Renderer/GlslWriter.hpp +++ b/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 parameters, ShaderAst::ExpressionType ret) override; + void RegisterFunction(const String& name, ShaderAst::StatementPtr statement, std::initializer_list 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> variables; - std::vector parameters; + std::vector parameters; ShaderAst::ExpressionType retType; ShaderAst::StatementPtr node; String name; diff --git a/include/Nazara/Renderer/ShaderAst.hpp b/include/Nazara/Renderer/ShaderAst.hpp index be6ac2c29..c32d3af9f 100644 --- a/include/Nazara/Renderer/ShaderAst.hpp +++ b/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; + + 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; - VariableType kind; - Nz::String name; + 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; }; ////////////////////////////////////////////////////////////////////////// diff --git a/include/Nazara/Renderer/ShaderAst.inl b/include/Nazara/Renderer/ShaderAst.inl index cb98bbdac..b2b5a1f56 100644 --- a/include/Nazara/Renderer/ShaderAst.inl +++ b/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)), diff --git a/include/Nazara/Renderer/ShaderBuilder.hpp b/include/Nazara/Renderer/ShaderBuilder.hpp index 9f9d5f820..edcda745a 100644 --- a/include/Nazara/Renderer/ShaderBuilder.hpp +++ b/include/Nazara/Renderer/ShaderBuilder.hpp @@ -51,7 +51,7 @@ namespace Nz { namespace ShaderBuilder template std::shared_ptr operator()(Args&&... args) const { - return std::make_shared(type, std::forward(args)...); + return std::make_shared(type, std::forward(args)...); } }; diff --git a/include/Nazara/Renderer/ShaderWriter.hpp b/include/Nazara/Renderer/ShaderWriter.hpp index 9b87ca5f7..aec80855f 100644 --- a/include/Nazara/Renderer/ShaderWriter.hpp +++ b/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 parameters, ShaderAst::ExpressionType ret) = 0; + virtual void RegisterFunction(const String& name, ShaderAst::StatementPtr node, std::initializer_list 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; }; } diff --git a/src/Nazara/Renderer/GlslWriter.cpp b/src/Nazara/Renderer/GlslWriter.cpp index 94349fec0..63a1ad488 100644 --- a/src/Nazara/Renderer/GlslWriter.cpp +++ b/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 parameters, ShaderAst::ExpressionType retType) + void GlslWriter::RegisterFunction(const String& name, ShaderAst::StatementPtr statement, std::initializer_list 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; diff --git a/src/Nazara/Renderer/ShaderAst.cpp b/src/Nazara/Renderer/ShaderAst.cpp index 7de149699..8fc554623 100644 --- a/src/Nazara/Renderer/ShaderAst.cpp +++ b/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); } From 6ebaf510dbcfff991d37e2a6044855a453798f77 Mon Sep 17 00:00:00 2001 From: Lynix Date: Thu, 5 Jan 2017 14:04:29 +0100 Subject: [PATCH 08/30] Renderer/ShaderBuilder: Add builder for builtins --- include/Nazara/Renderer/ShaderBuilder.hpp | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/include/Nazara/Renderer/ShaderBuilder.hpp b/include/Nazara/Renderer/ShaderBuilder.hpp index edcda745a..18bb3244e 100644 --- a/include/Nazara/Renderer/ShaderBuilder.hpp +++ b/include/Nazara/Renderer/ShaderBuilder.hpp @@ -44,6 +44,26 @@ namespace Nz { namespace ShaderBuilder } }; + class BuiltinBuilder + { + public: + std::shared_ptr operator()(Nz::ShaderAst::Builtin builtin) const + { + ShaderAst::ExpressionType exprType = ShaderAst::ExpressionType::None; + + switch (builtin) + { + case ShaderAst::Builtin::VertexPosition: + exprType = ShaderAst::ExpressionType::Float4; + break; + } + + NazaraAssert(exprType != ShaderAst::ExpressionType::None, "Unhandled builtin"); + + return std::make_shared(builtin, exprType); + } + }; + template class VarBuilder { @@ -57,6 +77,7 @@ namespace Nz { namespace ShaderBuilder constexpr BinOpBuilder Add; constexpr AssignOpBuilder Assign; + constexpr BuiltinBuilder Builtin; constexpr BinOpBuilder Equal; constexpr GenBuilder Block; constexpr GenBuilder Branch; From d1c44cc1ffd84097712f3445de0ee9d27b517b70 Mon Sep 17 00:00:00 2001 From: Lynix Date: Thu, 5 Jan 2017 14:11:41 +0100 Subject: [PATCH 09/30] Renderer/ShaderBuilder: Cleanup --- include/Nazara/Renderer/ShaderBuilder.hpp | 97 ++++++++--------------- include/Nazara/Renderer/ShaderBuilder.inl | 44 +++++++++- 2 files changed, 73 insertions(+), 68 deletions(-) diff --git a/include/Nazara/Renderer/ShaderBuilder.hpp b/include/Nazara/Renderer/ShaderBuilder.hpp index 18bb3244e..5bf2dcaff 100644 --- a/include/Nazara/Renderer/ShaderBuilder.hpp +++ b/include/Nazara/Renderer/ShaderBuilder.hpp @@ -13,79 +13,46 @@ namespace Nz { namespace ShaderBuilder { + template + struct AssignOpBuilder + { + std::shared_ptr operator()(const ShaderAst::VariablePtr& left, const ShaderAst::ExpressionPtr& right) const; + }; + + template + struct BinOpBuilder + { + std::shared_ptr operator()(const ShaderAst::ExpressionPtr& left, const ShaderAst::ExpressionPtr& right) const; + }; + + struct BuiltinBuilder + { + std::shared_ptr operator()(ShaderAst::Builtin builtin) const; + }; + template - class GenBuilder + struct GenBuilder { - public: - template - std::shared_ptr operator()(Args&&... args) const - { - return std::make_shared(std::forward(args)...); - } + template std::shared_ptr operator()(Args&&... args) const; }; - template - class AssignOpBuilder + template + struct VarBuilder { - public: - std::shared_ptr operator()(const Nz::ShaderAst::VariablePtr& left, const Nz::ShaderAst::ExpressionPtr& right) const - { - return std::make_shared(op, left, right); - } + template std::shared_ptr operator()(Args&&... args) const; }; - template - class BinOpBuilder - { - public: - std::shared_ptr operator()(const Nz::ShaderAst::ExpressionPtr& left, const Nz::ShaderAst::ExpressionPtr& right) const - { - return std::make_shared(op, left, right); - } - }; - - class BuiltinBuilder - { - public: - std::shared_ptr operator()(Nz::ShaderAst::Builtin builtin) const - { - ShaderAst::ExpressionType exprType = ShaderAst::ExpressionType::None; - - switch (builtin) - { - case ShaderAst::Builtin::VertexPosition: - exprType = ShaderAst::ExpressionType::Float4; - break; - } - - NazaraAssert(exprType != ShaderAst::ExpressionType::None, "Unhandled builtin"); - - return std::make_shared(builtin, exprType); - } - }; - - template - class VarBuilder - { - public: - template - std::shared_ptr operator()(Args&&... args) const - { - return std::make_shared(type, std::forward(args)...); - } - }; - - constexpr BinOpBuilder Add; - constexpr AssignOpBuilder Assign; + constexpr BinOpBuilder Add; + constexpr AssignOpBuilder Assign; constexpr BuiltinBuilder Builtin; - constexpr BinOpBuilder Equal; - constexpr GenBuilder Block; - constexpr GenBuilder Branch; - constexpr GenBuilder Constant; - constexpr GenBuilder ExprStatement; - constexpr VarBuilder Parameter; - constexpr VarBuilder Uniform; - constexpr VarBuilder Variable; + constexpr BinOpBuilder Equal; + constexpr GenBuilder Block; + constexpr GenBuilder Branch; + constexpr GenBuilder Constant; + constexpr GenBuilder ExprStatement; + constexpr VarBuilder Parameter; + constexpr VarBuilder Uniform; + constexpr VarBuilder Variable; } } #include diff --git a/include/Nazara/Renderer/ShaderBuilder.inl b/include/Nazara/Renderer/ShaderBuilder.inl index 94ab292ec..c64da3a82 100644 --- a/include/Nazara/Renderer/ShaderBuilder.inl +++ b/include/Nazara/Renderer/ShaderBuilder.inl @@ -5,11 +5,49 @@ #include #include -namespace Nz +namespace Nz { namespace ShaderBuilder { - namespace ShaderAst + template + template + std::shared_ptr GenBuilder::operator()(Args&&... args) const { + return std::make_shared(std::forward(args)...); } -} + + template + std::shared_ptr AssignOpBuilder::operator()(const ShaderAst::VariablePtr& left, const ShaderAst::ExpressionPtr& right) const + { + return std::make_shared(op, left, right); + } + + template + std::shared_ptr BinOpBuilder::operator()(const ShaderAst::ExpressionPtr& left, const ShaderAst::ExpressionPtr& right) const + { + return std::make_shared(op, left, right); + } + + std::shared_ptr BuiltinBuilder::operator()(ShaderAst::Builtin builtin) const + { + ShaderAst::ExpressionType exprType = ShaderAst::ExpressionType::None; + + switch (builtin) + { + case ShaderAst::Builtin::VertexPosition: + exprType = ShaderAst::ExpressionType::Float4; + break; + } + + NazaraAssert(exprType != ShaderAst::ExpressionType::None, "Unhandled builtin"); + + return std::make_shared(builtin, exprType); + } + + template + template + std::shared_ptr VarBuilder::operator()(Args&&... args) const + { + return std::make_shared(type, std::forward(args)...); + } +} } #include From 206576ec9d90c1307a233fda6959d6099fc4b288 Mon Sep 17 00:00:00 2001 From: Lynix Date: Thu, 5 Jan 2017 15:17:34 +0100 Subject: [PATCH 10/30] Renderer/ShaderAst: Add input and outputs variables --- include/Nazara/Renderer/GlslWriter.hpp | 12 +++- include/Nazara/Renderer/ShaderAst.hpp | 6 +- include/Nazara/Renderer/ShaderBuilder.hpp | 2 + src/Nazara/Renderer/GlslWriter.cpp | 70 ++++++++++++++--------- 4 files changed, 58 insertions(+), 32 deletions(-) diff --git a/include/Nazara/Renderer/GlslWriter.hpp b/include/Nazara/Renderer/GlslWriter.hpp index 39a557040..bbd485dc1 100644 --- a/include/Nazara/Renderer/GlslWriter.hpp +++ b/include/Nazara/Renderer/GlslWriter.hpp @@ -44,20 +44,24 @@ namespace Nz private: struct Function; + using VariableContainer = std::set>; void Append(ShaderAst::Builtin builtin); void Append(ShaderAst::ExpressionType type); void Append(const String& txt); void AppendCommentSection(const String& section); void AppendFunction(Function& func); - void AppendLine(const Nz::String& txt = Nz::String()); + void AppendLine(const String& txt = String()); + + void DeclareVariables(const VariableContainer& variables, const String& keyword = String(), const String& section = String()); void EnterScope(); void LeaveScope(); + struct Function { - std::set> variables; + VariableContainer variables; std::vector parameters; ShaderAst::ExpressionType retType; ShaderAst::StatementPtr node; @@ -66,7 +70,9 @@ namespace Nz struct State { - std::set> m_uniforms; + VariableContainer inputs; + VariableContainer outputs; + VariableContainer uniforms; StringStream stream; unsigned int indentLevel = 0; }; diff --git a/include/Nazara/Renderer/ShaderAst.hpp b/include/Nazara/Renderer/ShaderAst.hpp index c32d3af9f..87c00548e 100644 --- a/include/Nazara/Renderer/ShaderAst.hpp +++ b/include/Nazara/Renderer/ShaderAst.hpp @@ -55,9 +55,11 @@ namespace Nz enum class VariableType { Builtin, + Input, + Output, Parameter, - Variable, - Uniform + Uniform, + Variable }; ////////////////////////////////////////////////////////////////////////// diff --git a/include/Nazara/Renderer/ShaderBuilder.hpp b/include/Nazara/Renderer/ShaderBuilder.hpp index 5bf2dcaff..04394328e 100644 --- a/include/Nazara/Renderer/ShaderBuilder.hpp +++ b/include/Nazara/Renderer/ShaderBuilder.hpp @@ -50,6 +50,8 @@ namespace Nz { namespace ShaderBuilder constexpr GenBuilder Branch; constexpr GenBuilder Constant; constexpr GenBuilder ExprStatement; + constexpr VarBuilder Input; + constexpr VarBuilder Output; constexpr VarBuilder Parameter; constexpr VarBuilder Uniform; constexpr VarBuilder Variable; diff --git a/src/Nazara/Renderer/GlslWriter.cpp b/src/Nazara/Renderer/GlslWriter.cpp index 63a1ad488..34a8cb867 100644 --- a/src/Nazara/Renderer/GlslWriter.cpp +++ b/src/Nazara/Renderer/GlslWriter.cpp @@ -31,23 +31,10 @@ namespace Nz AppendLine(String::Number(m_glslVersion)); AppendLine(); - // Uniforms - if (!state.m_uniforms.empty()) - { - AppendCommentSection("Uniforms"); - AppendLine(); - - for (const auto& pair : state.m_uniforms) - { - Append("uniform "); - Append(pair.first); - Append(" "); - Append(pair.second); - AppendLine(";"); - } - - AppendLine(); - } + // Global variables (uniforms, input and outputs) + DeclareVariables(state.uniforms, "uniform", "Uniforms"); + DeclareVariables(state.inputs, "in", "Inputs"); + DeclareVariables(state.outputs, "out", "Outputs"); Function entryPoint; entryPoint.name = "main"; //< GLSL has only one entry point name possible @@ -73,9 +60,18 @@ namespace Nz void GlslWriter::RegisterVariable(ShaderAst::VariableType kind, const String& name, ShaderAst::ExpressionType type) { NazaraAssert(m_currentState, "This function should only be called while processing an AST"); + NazaraAssert(kind != ShaderAst::VariableType::Builtin, "Builtin variables should not be registered"); switch (kind) { + case ShaderAst::VariableType::Input: + m_currentState->inputs.insert(std::make_pair(type, name)); + break; + + case ShaderAst::VariableType::Output: + m_currentState->outputs.insert(std::make_pair(type, name)); + break; + case ShaderAst::VariableType::Parameter: { if (m_currentFunction) @@ -105,7 +101,7 @@ namespace Nz } case ShaderAst::VariableType::Uniform: - m_currentState->m_uniforms.insert(std::make_pair(type, name)); + m_currentState->uniforms.insert(std::make_pair(type, name)); break; case ShaderAst::VariableType::Variable: @@ -320,15 +316,7 @@ namespace Nz EnterScope(); { - for (const auto& pair : func.variables) - { - Append(pair.first); - Append(" "); - Append(pair.second); - AppendLine(";"); - } - - AppendLine(); + DeclareVariables(func.variables); Write(func.node); } @@ -342,6 +330,34 @@ namespace Nz m_currentState->stream << txt << '\n' << String(m_currentState->indentLevel, '\t'); } + void GlslWriter::DeclareVariables(const VariableContainer& variables, const String& keyword, const String& section) + { + if (!variables.empty()) + { + if (!section.IsEmpty()) + { + AppendCommentSection("Uniforms"); + AppendLine(); + } + + for (const auto& pair : variables) + { + if (!keyword.IsEmpty()) + { + Append(keyword); + Append(" "); + } + + Append(pair.first); + Append(" "); + Append(pair.second); + AppendLine(";"); + } + + AppendLine(); + } + } + void GlslWriter::EnterScope() { NazaraAssert(m_currentState, "This function should only be called while processing an AST"); From 79caa74db70cedf204205068d687fa79b92fc9cf Mon Sep 17 00:00:00 2001 From: Lynix Date: Thu, 5 Jan 2017 15:28:52 +0100 Subject: [PATCH 11/30] Renderer/GlslWriter: Fix comment sections being "Uniforms" no matter the section value --- src/Nazara/Renderer/GlslWriter.cpp | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/src/Nazara/Renderer/GlslWriter.cpp b/src/Nazara/Renderer/GlslWriter.cpp index 34a8cb867..ebafb2d7b 100644 --- a/src/Nazara/Renderer/GlslWriter.cpp +++ b/src/Nazara/Renderer/GlslWriter.cpp @@ -335,10 +335,7 @@ namespace Nz if (!variables.empty()) { if (!section.IsEmpty()) - { - AppendCommentSection("Uniforms"); - AppendLine(); - } + AppendCommentSection(section); for (const auto& pair : variables) { From 44942b299780c590d5b2b466365c8ed669cfc130 Mon Sep 17 00:00:00 2001 From: Lynix Date: Thu, 5 Jan 2017 15:29:07 +0100 Subject: [PATCH 12/30] Renderer/ShaderBuilder: Add builder for remaining binary operations --- include/Nazara/Renderer/ShaderBuilder.hpp | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/include/Nazara/Renderer/ShaderBuilder.hpp b/include/Nazara/Renderer/ShaderBuilder.hpp index 04394328e..631083fab 100644 --- a/include/Nazara/Renderer/ShaderBuilder.hpp +++ b/include/Nazara/Renderer/ShaderBuilder.hpp @@ -45,14 +45,17 @@ namespace Nz { namespace ShaderBuilder constexpr BinOpBuilder Add; constexpr AssignOpBuilder Assign; constexpr BuiltinBuilder Builtin; - constexpr BinOpBuilder Equal; constexpr GenBuilder Block; constexpr GenBuilder Branch; constexpr GenBuilder Constant; + constexpr BinOpBuilder Divide; + constexpr BinOpBuilder Equal; constexpr GenBuilder ExprStatement; constexpr VarBuilder Input; + constexpr BinOpBuilder Multiply; constexpr VarBuilder Output; constexpr VarBuilder Parameter; + constexpr BinOpBuilder Substract; constexpr VarBuilder Uniform; constexpr VarBuilder Variable; } } From 40d612dbc46ef7b9747421e7fcb8b03bb500f02e Mon Sep 17 00:00:00 2001 From: Lynix Date: Thu, 5 Jan 2017 16:41:48 +0100 Subject: [PATCH 13/30] Renderer/ShaderAst: Add support for expression type --- include/Nazara/Renderer/ShaderAst.hpp | 20 ++++++++++----- include/Nazara/Renderer/ShaderAst.inl | 4 +++ src/Nazara/Renderer/ShaderAst.cpp | 37 +++++++++++++++++++++++++++ 3 files changed, 55 insertions(+), 6 deletions(-) diff --git a/include/Nazara/Renderer/ShaderAst.hpp b/include/Nazara/Renderer/ShaderAst.hpp index 87c00548e..d0d502959 100644 --- a/include/Nazara/Renderer/ShaderAst.hpp +++ b/include/Nazara/Renderer/ShaderAst.hpp @@ -43,13 +43,14 @@ namespace Nz enum class ExpressionType { - Float1, // float - Float2, // vec2 - Float3, // vec3 - Float4, // vec4 - Mat4x4, // mat4 + Boolean, // bool + Float1, // float + Float2, // vec2 + Float3, // vec3 + Float4, // vec4 + Mat4x4, // mat4 - None // void + None // void }; enum class VariableType @@ -91,6 +92,8 @@ namespace Nz class NAZARA_RENDERER_API Expression : public Node { + public: + virtual ExpressionType GetExpressionType() const = 0; }; class NAZARA_RENDERER_API ExpressionStatement : public Statement @@ -126,6 +129,8 @@ namespace Nz public: inline Variable(VariableType varKind, ExpressionType varType); + ExpressionType GetExpressionType() const override; + ExpressionType type; VariableType kind; }; @@ -163,6 +168,7 @@ namespace Nz public: inline AssignOp(AssignType Op, VariablePtr Var, ExpressionPtr Right); + ExpressionType GetExpressionType() const override; void Register(ShaderWriter& visitor) override; void Visit(ShaderWriter& visitor) override; @@ -176,6 +182,7 @@ namespace Nz public: inline BinaryOp(BinaryType Op, ExpressionPtr Left, ExpressionPtr Right); + ExpressionType GetExpressionType() const override; void Register(ShaderWriter& visitor) override; void Visit(ShaderWriter& visitor) override; @@ -207,6 +214,7 @@ namespace Nz public: inline explicit Constant(float value); + ExpressionType GetExpressionType() const override; void Register(ShaderWriter& visitor) override; void Visit(ShaderWriter& visitor) override; diff --git a/include/Nazara/Renderer/ShaderAst.inl b/include/Nazara/Renderer/ShaderAst.inl index b2b5a1f56..3fe505726 100644 --- a/include/Nazara/Renderer/ShaderAst.inl +++ b/include/Nazara/Renderer/ShaderAst.inl @@ -3,6 +3,7 @@ // For conditions of distribution and use, see copyright notice in Config.hpp #include +#include #include namespace Nz @@ -50,6 +51,9 @@ namespace Nz left(std::move(Left)), right(std::move(Right)) { + //TODO: AstParseError + if (left->GetExpressionType() != right->GetExpressionType()) + throw std::runtime_error("Left expression type must match right expression type"); } inline Branch::Branch(ExpressionPtr condition, StatementPtr trueStatement, StatementPtr falseStatement) diff --git a/src/Nazara/Renderer/ShaderAst.cpp b/src/Nazara/Renderer/ShaderAst.cpp index 8fc554623..7cc3b6313 100644 --- a/src/Nazara/Renderer/ShaderAst.cpp +++ b/src/Nazara/Renderer/ShaderAst.cpp @@ -31,6 +31,11 @@ namespace Nz { namespace ShaderAst } + ExpressionType Variable::GetExpressionType() const + { + return type; + } + void NamedVariable::Register(ShaderWriter& visitor) { visitor.RegisterVariable(kind, name, type); @@ -52,6 +57,11 @@ namespace Nz { namespace ShaderAst } + ExpressionType AssignOp::GetExpressionType() const + { + return variable->GetExpressionType(); + } + void AssignOp::Register(ShaderWriter& visitor) { variable->Register(visitor); @@ -64,6 +74,28 @@ namespace Nz { namespace ShaderAst } + ExpressionType BinaryOp::GetExpressionType() const + { + ShaderAst::ExpressionType exprType = ShaderAst::ExpressionType::None; + + switch (op) + { + case ShaderAst::BinaryType::Add: + case ShaderAst::BinaryType::Divide: + case ShaderAst::BinaryType::Multiply: + case ShaderAst::BinaryType::Substract: + exprType = left->GetExpressionType(); + break; + + case ShaderAst::BinaryType::Equality: + exprType = ExpressionType::Boolean; + } + + NazaraAssert(exprType != ShaderAst::ExpressionType::None, "Unhandled builtin"); + + return exprType; + } + void BinaryOp::Register(ShaderWriter& visitor) { left->Register(visitor); @@ -94,6 +126,11 @@ namespace Nz { namespace ShaderAst } + ExpressionType Constant::GetExpressionType() const + { + return exprType; + } + void Constant::Register(ShaderWriter&) { } From 831175f466da5a8f06a37518bcf714ceea4ce7a5 Mon Sep 17 00:00:00 2001 From: Lynix Date: Fri, 6 Jan 2017 00:49:24 +0100 Subject: [PATCH 14/30] Renderer/ShaderAst: Add Cast node --- include/Nazara/Renderer/GlslWriter.hpp | 1 + include/Nazara/Renderer/ShaderAst.hpp | 17 ++++++++ include/Nazara/Renderer/ShaderAst.inl | 51 +++++++++++++++++++++++ include/Nazara/Renderer/ShaderBuilder.hpp | 2 + include/Nazara/Renderer/ShaderBuilder.inl | 6 +++ include/Nazara/Renderer/ShaderWriter.hpp | 1 + src/Nazara/Renderer/GlslWriter.cpp | 22 ++++++++++ src/Nazara/Renderer/ShaderAst.cpp | 24 +++++++++++ 8 files changed, 124 insertions(+) diff --git a/include/Nazara/Renderer/GlslWriter.hpp b/include/Nazara/Renderer/GlslWriter.hpp index bbd485dc1..b17e4aab2 100644 --- a/include/Nazara/Renderer/GlslWriter.hpp +++ b/include/Nazara/Renderer/GlslWriter.hpp @@ -36,6 +36,7 @@ namespace Nz 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::Cast& node) override; void Write(const ShaderAst::Constant& node) override; void Write(const ShaderAst::ExpressionStatement& node) override; void Write(const ShaderAst::NamedVariable& node) override; diff --git a/include/Nazara/Renderer/ShaderAst.hpp b/include/Nazara/Renderer/ShaderAst.hpp index d0d502959..eb556ab55 100644 --- a/include/Nazara/Renderer/ShaderAst.hpp +++ b/include/Nazara/Renderer/ShaderAst.hpp @@ -14,6 +14,7 @@ #include #include #include +#include #include namespace Nz @@ -76,6 +77,9 @@ namespace Nz virtual void Register(ShaderWriter& visitor) = 0; virtual void Visit(ShaderWriter& visitor) = 0; + + static inline unsigned int GetComponentCount(ExpressionType type); + static inline ExpressionType GetComponentType(ExpressionType type); }; class Statement; @@ -209,6 +213,19 @@ namespace Nz StatementPtr elseStatement; }; + class NAZARA_RENDERER_API Cast : public Expression + { + public: + inline Cast(ExpressionType castTo, ExpressionPtr first, ExpressionPtr second = nullptr, ExpressionPtr third = nullptr, ExpressionPtr fourth = nullptr); + + ExpressionType GetExpressionType() const override; + void Register(ShaderWriter& visitor) override; + void Visit(ShaderWriter& visitor) override; + + ExpressionType exprType; + std::array expressions; + }; + class NAZARA_RENDERER_API Constant : public Expression { public: diff --git a/include/Nazara/Renderer/ShaderAst.inl b/include/Nazara/Renderer/ShaderAst.inl index 3fe505726..4565cfc3d 100644 --- a/include/Nazara/Renderer/ShaderAst.inl +++ b/include/Nazara/Renderer/ShaderAst.inl @@ -10,6 +10,38 @@ namespace Nz { namespace ShaderAst { + inline unsigned int Node::GetComponentCount(ExpressionType type) + { + switch (type) + { + case ExpressionType::Float2: + return 2; + + case ExpressionType::Float3: + return 3; + + case ExpressionType::Float4: + return 4; + + default: + return 1; + } + } + + inline ExpressionType Node::GetComponentType(ExpressionType type) + { + switch (type) + { + case ExpressionType::Float2: + case ExpressionType::Float3: + case ExpressionType::Float4: + return ExpressionType::Float1; + + default: + return type; + } + } + inline ExpressionStatement::ExpressionStatement(ExpressionPtr expr) : expression(std::move(expr)) { @@ -62,6 +94,25 @@ namespace Nz elseStatement = std::move(falseStatement); } + inline Cast::Cast(ExpressionType castTo, ExpressionPtr first, ExpressionPtr second, ExpressionPtr third, ExpressionPtr fourth) : + exprType(castTo), + expressions({first, second, third, fourth}) + { + unsigned int componentCount = 0; + unsigned int requiredComponents = GetComponentCount(exprType); + for (const auto& exprPtr : expressions) + { + if (!exprPtr) + break; + + componentCount += GetComponentCount(exprPtr->GetExpressionType()); + } + + //TODO: AstParseError + if (componentCount != requiredComponents) + throw std::runtime_error("Component count doesn't match required component count"); + } + inline Constant::Constant(float value) : exprType(ExpressionType::Float1) { diff --git a/include/Nazara/Renderer/ShaderBuilder.hpp b/include/Nazara/Renderer/ShaderBuilder.hpp index 631083fab..b92ad78cb 100644 --- a/include/Nazara/Renderer/ShaderBuilder.hpp +++ b/include/Nazara/Renderer/ShaderBuilder.hpp @@ -58,6 +58,8 @@ namespace Nz { namespace ShaderBuilder constexpr BinOpBuilder Substract; constexpr VarBuilder Uniform; constexpr VarBuilder Variable; + + template std::shared_ptr Cast(Args&&... args); } } #include diff --git a/include/Nazara/Renderer/ShaderBuilder.inl b/include/Nazara/Renderer/ShaderBuilder.inl index c64da3a82..4b62b5483 100644 --- a/include/Nazara/Renderer/ShaderBuilder.inl +++ b/include/Nazara/Renderer/ShaderBuilder.inl @@ -48,6 +48,12 @@ namespace Nz { namespace ShaderBuilder { return std::make_shared(type, std::forward(args)...); } + + template + std::shared_ptr Cast(Args&&... args) + { + return std::make_shared(Type, std::forward(args)...); + } } } #include diff --git a/include/Nazara/Renderer/ShaderWriter.hpp b/include/Nazara/Renderer/ShaderWriter.hpp index aec80855f..3c17bf936 100644 --- a/include/Nazara/Renderer/ShaderWriter.hpp +++ b/include/Nazara/Renderer/ShaderWriter.hpp @@ -30,6 +30,7 @@ namespace Nz 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::Cast& 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; diff --git a/src/Nazara/Renderer/GlslWriter.cpp b/src/Nazara/Renderer/GlslWriter.cpp index ebafb2d7b..9edaeeb0d 100644 --- a/src/Nazara/Renderer/GlslWriter.cpp +++ b/src/Nazara/Renderer/GlslWriter.cpp @@ -198,6 +198,28 @@ namespace Nz Append(node.var); } + void GlslWriter::Write(const ShaderAst::Cast& node) + { + Append(node.exprType); + Append("("); + + unsigned int i = 0; + unsigned int requiredComponents = ShaderAst::Node::GetComponentCount(node.exprType); + while (requiredComponents > 0) + { + if (i != 0) + m_currentState->stream << ", "; + + const auto& exprPtr = node.expressions[i++]; + NazaraAssert(exprPtr, "Invalid expression"); + + Write(exprPtr); + requiredComponents -= ShaderAst::Node::GetComponentCount(exprPtr->GetExpressionType()); + } + + Append(")"); + } + void GlslWriter::Write(const ShaderAst::Constant& node) { switch (node.exprType) diff --git a/src/Nazara/Renderer/ShaderAst.cpp b/src/Nazara/Renderer/ShaderAst.cpp index 7cc3b6313..a1612ebf9 100644 --- a/src/Nazara/Renderer/ShaderAst.cpp +++ b/src/Nazara/Renderer/ShaderAst.cpp @@ -139,5 +139,29 @@ namespace Nz { namespace ShaderAst { visitor.Write(*this); } + + ExpressionType Cast::GetExpressionType() const + { + return exprType; + } + + void Cast::Register(ShaderWriter& visitor) + { + auto it = expressions.begin(); + (*it)->Register(visitor); + + for (; it != expressions.end(); ++it) + { + if (!*it) + break; + + (*it)->Register(visitor); + } + } + + void Cast::Visit(ShaderWriter& visitor) + { + visitor.Write(*this); + } } } From 913bc1ce504ba02ca76a4aae24d6022e902bb19e Mon Sep 17 00:00:00 2001 From: Lynix Date: Fri, 6 Jan 2017 00:51:05 +0100 Subject: [PATCH 15/30] Renderer/ShaderAst: Fix support for matrix4 type --- include/Nazara/Renderer/ShaderAst.inl | 2 ++ 1 file changed, 2 insertions(+) diff --git a/include/Nazara/Renderer/ShaderAst.inl b/include/Nazara/Renderer/ShaderAst.inl index 4565cfc3d..9bde01926 100644 --- a/include/Nazara/Renderer/ShaderAst.inl +++ b/include/Nazara/Renderer/ShaderAst.inl @@ -21,6 +21,7 @@ namespace Nz return 3; case ExpressionType::Float4: + case ExpressionType::Mat4x4: return 4; default: @@ -35,6 +36,7 @@ namespace Nz case ExpressionType::Float2: case ExpressionType::Float3: case ExpressionType::Float4: + case ExpressionType::Mat4x4: return ExpressionType::Float1; default: From 7b77f010bb12c1fab44df0c667fd12fbeaa51350 Mon Sep 17 00:00:00 2001 From: Lynix Date: Fri, 6 Jan 2017 01:06:49 +0100 Subject: [PATCH 16/30] Renderer/ShaderAst: Fix Mat4x4 handling --- include/Nazara/Renderer/ShaderAst.inl | 50 ++++++++++++++++++++++++--- 1 file changed, 46 insertions(+), 4 deletions(-) diff --git a/include/Nazara/Renderer/ShaderAst.inl b/include/Nazara/Renderer/ShaderAst.inl index 9bde01926..398956187 100644 --- a/include/Nazara/Renderer/ShaderAst.inl +++ b/include/Nazara/Renderer/ShaderAst.inl @@ -21,9 +21,11 @@ namespace Nz return 3; case ExpressionType::Float4: - case ExpressionType::Mat4x4: return 4; + case ExpressionType::Mat4x4: + return 16; + default: return 1; } @@ -85,9 +87,49 @@ namespace Nz left(std::move(Left)), right(std::move(Right)) { - //TODO: AstParseError - if (left->GetExpressionType() != right->GetExpressionType()) - throw std::runtime_error("Left expression type must match right expression type"); + ExpressionType leftType = left->GetExpressionType(); + ExpressionType rightType = right->GetExpressionType(); + + if (leftType != rightType) + { + switch (op) + { + case BinaryType::Add: + case BinaryType::Divide: + case BinaryType::Equality: + case BinaryType::Substract: + { + //TODO: AstParseError + throw std::runtime_error("Left expression type must match right expression type"); + } + + case BinaryType::Multiply: + { + switch (leftType) + { + case ExpressionType::Mat4x4: + { + switch (rightType) + { + case ExpressionType::Float4: + case ExpressionType::Mat4x4: + break; + + //TODO: AstParseError + default: + throw std::runtime_error("Left expression type is not compatible with right expression type"); + } + + break; + } + + default: + //TODO: AstParseError + throw std::runtime_error("Left expression type must match right expression type"); + } + } + } + } } inline Branch::Branch(ExpressionPtr condition, StatementPtr trueStatement, StatementPtr falseStatement) From 1ad8316d5369604fc8002682f5961ab09f9557a6 Mon Sep 17 00:00:00 2001 From: Lynix Date: Fri, 6 Jan 2017 01:16:03 +0100 Subject: [PATCH 17/30] Renderer/ShaderAst: Add Constant overloads --- include/Nazara/Renderer/ShaderAst.hpp | 11 ++++++++--- include/Nazara/Renderer/ShaderAst.inl | 24 ++++++++++++++++++++++++ src/Nazara/Renderer/GlslWriter.cpp | 18 ++++++++++++++++++ 3 files changed, 50 insertions(+), 3 deletions(-) diff --git a/include/Nazara/Renderer/ShaderAst.hpp b/include/Nazara/Renderer/ShaderAst.hpp index eb556ab55..52ad7eb5d 100644 --- a/include/Nazara/Renderer/ShaderAst.hpp +++ b/include/Nazara/Renderer/ShaderAst.hpp @@ -229,7 +229,11 @@ namespace Nz class NAZARA_RENDERER_API Constant : public Expression { public: + inline explicit Constant(bool value); inline explicit Constant(float value); + inline explicit Constant(const Vector2f& value); + inline explicit Constant(const Vector3f& value); + inline explicit Constant(const Vector4f& value); ExpressionType GetExpressionType() const override; void Register(ShaderWriter& visitor) override; @@ -239,10 +243,11 @@ namespace Nz union { + bool bool1; float vec1; - Nz::Vector2f vec2; - Nz::Vector3f vec3; - Nz::Vector4f vec4; + Vector2f vec2; + Vector3f vec3; + Vector4f vec4; } values; }; } diff --git a/include/Nazara/Renderer/ShaderAst.inl b/include/Nazara/Renderer/ShaderAst.inl index 398956187..a334a1bd1 100644 --- a/include/Nazara/Renderer/ShaderAst.inl +++ b/include/Nazara/Renderer/ShaderAst.inl @@ -157,11 +157,35 @@ namespace Nz throw std::runtime_error("Component count doesn't match required component count"); } + inline Constant::Constant(bool value) : + exprType(ExpressionType::Boolean) + { + values.bool1 = value; + } + inline Constant::Constant(float value) : exprType(ExpressionType::Float1) { values.vec1 = value; } + + inline Constant::Constant(const Vector2f& value) : + exprType(ExpressionType::Float2) + { + values.vec2 = value; + } + + inline Constant::Constant(const Vector3f& value) : + exprType(ExpressionType::Float3) + { + values.vec3 = value; + } + + inline Constant::Constant(const Vector4f& value) : + exprType(ExpressionType::Float4) + { + values.vec4 = value; + } } } diff --git a/src/Nazara/Renderer/GlslWriter.cpp b/src/Nazara/Renderer/GlslWriter.cpp index 9edaeeb0d..74ccd7728 100644 --- a/src/Nazara/Renderer/GlslWriter.cpp +++ b/src/Nazara/Renderer/GlslWriter.cpp @@ -224,10 +224,28 @@ namespace Nz { switch (node.exprType) { + case ShaderAst::ExpressionType::Boolean: + Append((node.values.bool1) ? "true" : "false"); + break; + case ShaderAst::ExpressionType::Float1: Append(String::Format("%F", node.values.vec1)); break; + + case ShaderAst::ExpressionType::Float2: + Append(String::Format("vec2(%F, %F)", node.values.vec2.x, node.values.vec2.y)); + break; + + case ShaderAst::ExpressionType::Float3: + Append(String::Format("vec3(%F, %F, %F)", node.values.vec3.x, node.values.vec3.y, node.values.vec3.z)); + break; + + case ShaderAst::ExpressionType::Float4: + Append(String::Format("vec4(%F, %F, %F, %F)", node.values.vec4.x, node.values.vec4.y, node.values.vec4.z, node.values.vec4.w)); + break; } + + throw std::runtime_error("Unhandled expression type"); } void GlslWriter::Write(const ShaderAst::ExpressionStatement& node) From 193c0d4a92da784c8e74ca4f46726a0e016729f5 Mon Sep 17 00:00:00 2001 From: Lynix Date: Fri, 6 Jan 2017 02:06:14 +0100 Subject: [PATCH 18/30] Renderer/ShaderBuilder: Rename Builtin to BuiltinVariable --- include/Nazara/Renderer/ShaderBuilder.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/Nazara/Renderer/ShaderBuilder.hpp b/include/Nazara/Renderer/ShaderBuilder.hpp index b92ad78cb..c106e11a1 100644 --- a/include/Nazara/Renderer/ShaderBuilder.hpp +++ b/include/Nazara/Renderer/ShaderBuilder.hpp @@ -44,7 +44,7 @@ namespace Nz { namespace ShaderBuilder constexpr BinOpBuilder Add; constexpr AssignOpBuilder Assign; - constexpr BuiltinBuilder Builtin; + constexpr BuiltinBuilder BuiltinVariable; constexpr GenBuilder Block; constexpr GenBuilder Branch; constexpr GenBuilder Constant; From 9ba8e48813c98d52fbfa726d3a66d7791a46a348 Mon Sep 17 00:00:00 2001 From: Lynix Date: Fri, 6 Jan 2017 02:06:29 +0100 Subject: [PATCH 19/30] Renderer/GlslWriter: Fix exception --- src/Nazara/Renderer/GlslWriter.cpp | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/Nazara/Renderer/GlslWriter.cpp b/src/Nazara/Renderer/GlslWriter.cpp index 74ccd7728..28dac120c 100644 --- a/src/Nazara/Renderer/GlslWriter.cpp +++ b/src/Nazara/Renderer/GlslWriter.cpp @@ -243,9 +243,10 @@ namespace Nz case ShaderAst::ExpressionType::Float4: Append(String::Format("vec4(%F, %F, %F, %F)", node.values.vec4.x, node.values.vec4.y, node.values.vec4.z, node.values.vec4.w)); break; - } - throw std::runtime_error("Unhandled expression type"); + default: + throw std::runtime_error("Unhandled expression type"); + } } void GlslWriter::Write(const ShaderAst::ExpressionStatement& node) From b4ff55c50c2af834fe52cd0bd81377e233de67e3 Mon Sep 17 00:00:00 2001 From: Lynix Date: Fri, 6 Jan 2017 13:18:05 +0100 Subject: [PATCH 20/30] Revert "Renderer/ShaderBuilder: Rename Builtin to BuiltinVariable" This reverts commit 193c0d4a92da784c8e74ca4f46726a0e016729f5. --- include/Nazara/Renderer/ShaderBuilder.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/Nazara/Renderer/ShaderBuilder.hpp b/include/Nazara/Renderer/ShaderBuilder.hpp index c106e11a1..b92ad78cb 100644 --- a/include/Nazara/Renderer/ShaderBuilder.hpp +++ b/include/Nazara/Renderer/ShaderBuilder.hpp @@ -44,7 +44,7 @@ namespace Nz { namespace ShaderBuilder constexpr BinOpBuilder Add; constexpr AssignOpBuilder Assign; - constexpr BuiltinBuilder BuiltinVariable; + constexpr BuiltinBuilder Builtin; constexpr GenBuilder Block; constexpr GenBuilder Branch; constexpr GenBuilder Constant; From 8fcd2f18864fd2233d2eea23476f4c88899d6d59 Mon Sep 17 00:00:00 2001 From: Lynix Date: Fri, 6 Jan 2017 13:47:05 +0100 Subject: [PATCH 21/30] Renderer/ShaderAst: Rename Builtin enum to BuiltinEntry --- include/Nazara/Renderer/GlslWriter.hpp | 2 +- include/Nazara/Renderer/ShaderAst.hpp | 6 +++--- include/Nazara/Renderer/ShaderAst.inl | 2 +- include/Nazara/Renderer/ShaderBuilder.hpp | 2 +- include/Nazara/Renderer/ShaderBuilder.inl | 4 ++-- src/Nazara/Renderer/GlslWriter.cpp | 4 ++-- 6 files changed, 10 insertions(+), 10 deletions(-) diff --git a/include/Nazara/Renderer/GlslWriter.hpp b/include/Nazara/Renderer/GlslWriter.hpp index b17e4aab2..ce9d46420 100644 --- a/include/Nazara/Renderer/GlslWriter.hpp +++ b/include/Nazara/Renderer/GlslWriter.hpp @@ -47,7 +47,7 @@ namespace Nz struct Function; using VariableContainer = std::set>; - void Append(ShaderAst::Builtin builtin); + void Append(ShaderAst::BuiltinEntry builtin); void Append(ShaderAst::ExpressionType type); void Append(const String& txt); void AppendCommentSection(const String& section); diff --git a/include/Nazara/Renderer/ShaderAst.hpp b/include/Nazara/Renderer/ShaderAst.hpp index 52ad7eb5d..831241853 100644 --- a/include/Nazara/Renderer/ShaderAst.hpp +++ b/include/Nazara/Renderer/ShaderAst.hpp @@ -37,7 +37,7 @@ namespace Nz Equality //< == }; - enum class Builtin + enum class BuiltinEntry { VertexPosition, // gl_Position }; @@ -157,12 +157,12 @@ namespace Nz class NAZARA_RENDERER_API BuiltinVariable : public Variable { public: - inline BuiltinVariable(Builtin variable, ExpressionType varType); + inline BuiltinVariable(BuiltinEntry variable, ExpressionType varType); void Register(ShaderWriter& visitor) override; void Visit(ShaderWriter& visitor) override; - Builtin var; + BuiltinEntry var; }; ////////////////////////////////////////////////////////////////////////// diff --git a/include/Nazara/Renderer/ShaderAst.inl b/include/Nazara/Renderer/ShaderAst.inl index a334a1bd1..f59c9f972 100644 --- a/include/Nazara/Renderer/ShaderAst.inl +++ b/include/Nazara/Renderer/ShaderAst.inl @@ -69,7 +69,7 @@ namespace Nz { } - inline BuiltinVariable::BuiltinVariable(Builtin variable, ExpressionType varType) : + inline BuiltinVariable::BuiltinVariable(BuiltinEntry variable, ExpressionType varType) : Variable(VariableType::Builtin, varType), var(variable) { diff --git a/include/Nazara/Renderer/ShaderBuilder.hpp b/include/Nazara/Renderer/ShaderBuilder.hpp index b92ad78cb..4f9c6a1fe 100644 --- a/include/Nazara/Renderer/ShaderBuilder.hpp +++ b/include/Nazara/Renderer/ShaderBuilder.hpp @@ -27,7 +27,7 @@ namespace Nz { namespace ShaderBuilder struct BuiltinBuilder { - std::shared_ptr operator()(ShaderAst::Builtin builtin) const; + std::shared_ptr operator()(ShaderAst::BuiltinEntry builtin) const; }; template diff --git a/include/Nazara/Renderer/ShaderBuilder.inl b/include/Nazara/Renderer/ShaderBuilder.inl index 4b62b5483..6778eb615 100644 --- a/include/Nazara/Renderer/ShaderBuilder.inl +++ b/include/Nazara/Renderer/ShaderBuilder.inl @@ -26,13 +26,13 @@ namespace Nz { namespace ShaderBuilder return std::make_shared(op, left, right); } - std::shared_ptr BuiltinBuilder::operator()(ShaderAst::Builtin builtin) const + std::shared_ptr BuiltinBuilder::operator()(ShaderAst::BuiltinEntry builtin) const { ShaderAst::ExpressionType exprType = ShaderAst::ExpressionType::None; switch (builtin) { - case ShaderAst::Builtin::VertexPosition: + case ShaderAst::BuiltinEntry::VertexPosition: exprType = ShaderAst::ExpressionType::Float4; break; } diff --git a/src/Nazara/Renderer/GlslWriter.cpp b/src/Nazara/Renderer/GlslWriter.cpp index 28dac120c..b910e2519 100644 --- a/src/Nazara/Renderer/GlslWriter.cpp +++ b/src/Nazara/Renderer/GlslWriter.cpp @@ -274,11 +274,11 @@ namespace Nz } } - void GlslWriter::Append(ShaderAst::Builtin builtin) + void GlslWriter::Append(ShaderAst::BuiltinEntry builtin) { switch (builtin) { - case ShaderAst::Builtin::VertexPosition: + case ShaderAst::BuiltinEntry::VertexPosition: Append("gl_Position"); break; } From cb566b14d4c809d706a6de5fd944b627fa7634f5 Mon Sep 17 00:00:00 2001 From: Lynix Date: Fri, 6 Jan 2017 16:21:38 +0100 Subject: [PATCH 22/30] Renderer: Replace shaders files by runtime-generated GLSL --- include/Nazara/Renderer/Renderer.hpp | 1 + src/Nazara/Renderer/Renderer.cpp | 104 ++++++++++++------ .../Resources/Shaders/Debug/core.frag | 13 --- .../Resources/Shaders/Debug/core.frag.h | 1 - .../Resources/Shaders/Debug/core.vert | 13 --- .../Resources/Shaders/Debug/core.vert.h | 1 - 6 files changed, 73 insertions(+), 60 deletions(-) delete mode 100644 src/Nazara/Renderer/Resources/Shaders/Debug/core.frag delete mode 100644 src/Nazara/Renderer/Resources/Shaders/Debug/core.frag.h delete mode 100644 src/Nazara/Renderer/Resources/Shaders/Debug/core.vert delete mode 100644 src/Nazara/Renderer/Resources/Shaders/Debug/core.vert.h diff --git a/include/Nazara/Renderer/Renderer.hpp b/include/Nazara/Renderer/Renderer.hpp index db85c4d62..e1c442a02 100644 --- a/include/Nazara/Renderer/Renderer.hpp +++ b/include/Nazara/Renderer/Renderer.hpp @@ -112,6 +112,7 @@ namespace Nz private: static void EnableInstancing(bool instancing); static bool EnsureStateUpdate(); + static bool GenerateDebugShader(); static void OnContextRelease(const Context* context); static void OnIndexBufferRelease(const IndexBuffer* indexBuffer); static void OnShaderReleased(const Shader* shader); diff --git a/src/Nazara/Renderer/Renderer.cpp b/src/Nazara/Renderer/Renderer.cpp index a5140c7ec..70251bf9c 100644 --- a/src/Nazara/Renderer/Renderer.cpp +++ b/src/Nazara/Renderer/Renderer.cpp @@ -13,11 +13,13 @@ #include #include #include +#include #include #include #include #include #include +#include #include #include #include @@ -40,14 +42,6 @@ namespace Nz { namespace { - const UInt8 r_coreFragmentShader[] = { - #include - }; - - const UInt8 r_coreVertexShader[] = { - #include - }; - enum ObjectType { ObjectType_Context, @@ -719,34 +713,12 @@ namespace Nz return false; } - // Création du shader de Debug - ShaderRef debugShader = Shader::New(); - if (!debugShader->Create()) + if (!GenerateDebugShader()) { - NazaraError("Failed to create debug shader"); + NazaraError("Failed to generate debug shader"); return false; } - if (!debugShader->AttachStageFromSource(ShaderStageType_Fragment, reinterpret_cast(r_coreFragmentShader), sizeof(r_coreFragmentShader))) - { - NazaraError("Failed to attach fragment stage"); - return false; - } - - if (!debugShader->AttachStageFromSource(ShaderStageType_Vertex, reinterpret_cast(r_coreVertexShader), sizeof(r_coreVertexShader))) - { - NazaraError("Failed to attach vertex stage"); - return false; - } - - if (!debugShader->Link()) - { - NazaraError("Failed to link shader"); - return false; - } - - ShaderLibrary::Register("DebugSimple", debugShader); - onExit.Reset(); NazaraNotice("Initialized: Renderer module"); @@ -1869,6 +1841,74 @@ namespace Nz return true; } + bool Renderer::GenerateDebugShader() + { + Nz::GlslWriter writer; + writer.SetGlslVersion(140); + + Nz::String fragmentShader; + Nz::String vertexShader; + + try + { + using namespace ShaderBuilder; + using ShaderAst::BuiltinEntry; + using ShaderAst::ExpressionType; + + // Fragment shader + { + auto rt0 = Output("RenderTarget0", ExpressionType::Float4); + auto color = Uniform("Color", ExpressionType::Float4); + + fragmentShader = writer.Generate(ExprStatement(Assign(rt0, color))); + } + + // Vertex shader + { + auto vertexPosition = Input("VertexPosition", ExpressionType::Float3); + auto wvpMatrix = Uniform("WorldViewProjMatrix", ExpressionType::Mat4x4); + auto builtinPos = Builtin(BuiltinEntry::VertexPosition); + + vertexShader = writer.Generate(ExprStatement(Assign(builtinPos, Multiply(wvpMatrix, Cast(vertexPosition, Constant(1.f)))))); + } + } + catch (const std::exception& e) + { + NazaraError("Failed to generate shader code: " + String(e.what())); + return false; + } + + + ShaderRef debugShader = Shader::New(); + if (!debugShader->Create()) + { + NazaraError("Failed to create debug shader"); + return false; + } + + if (!debugShader->AttachStageFromSource(ShaderStageType_Fragment, fragmentShader)) + { + NazaraError("Failed to attach fragment stage"); + return false; + } + + if (!debugShader->AttachStageFromSource(ShaderStageType_Vertex, vertexShader)) + { + NazaraError("Failed to attach vertex stage"); + return false; + } + + if (!debugShader->Link()) + { + NazaraError("Failed to link shader"); + return false; + } + + ShaderLibrary::Register("DebugSimple", debugShader); + + return true; + } + void Renderer::OnContextRelease(const Context* context) { s_vaos.erase(context); diff --git a/src/Nazara/Renderer/Resources/Shaders/Debug/core.frag b/src/Nazara/Renderer/Resources/Shaders/Debug/core.frag deleted file mode 100644 index 4bb28b00c..000000000 --- a/src/Nazara/Renderer/Resources/Shaders/Debug/core.frag +++ /dev/null @@ -1,13 +0,0 @@ -#version 140 - -/********************Sortant********************/ -out vec4 RenderTarget0; - -/********************Uniformes********************/ -uniform vec4 Color; - -/********************Fonctions********************/ -void main() -{ - RenderTarget0 = Color; -} \ No newline at end of file diff --git a/src/Nazara/Renderer/Resources/Shaders/Debug/core.frag.h b/src/Nazara/Renderer/Resources/Shaders/Debug/core.frag.h deleted file mode 100644 index bbb324c3c..000000000 --- a/src/Nazara/Renderer/Resources/Shaders/Debug/core.frag.h +++ /dev/null @@ -1 +0,0 @@ -35,118,101,114,115,105,111,110,32,49,52,48,13,10,13,10,47,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,83,111,114,116,97,110,116,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,47,13,10,111,117,116,32,118,101,99,52,32,82,101,110,100,101,114,84,97,114,103,101,116,48,59,13,10,13,10,47,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,85,110,105,102,111,114,109,101,115,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,47,13,10,117,110,105,102,111,114,109,32,118,101,99,52,32,67,111,108,111,114,59,13,10,13,10,47,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,70,111,110,99,116,105,111,110,115,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,47,13,10,118,111,105,100,32,109,97,105,110,40,41,13,10,123,13,10,9,82,101,110,100,101,114,84,97,114,103,101,116,48,32,61,32,67,111,108,111,114,59,13,10,125, \ No newline at end of file diff --git a/src/Nazara/Renderer/Resources/Shaders/Debug/core.vert b/src/Nazara/Renderer/Resources/Shaders/Debug/core.vert deleted file mode 100644 index e7806ffdf..000000000 --- a/src/Nazara/Renderer/Resources/Shaders/Debug/core.vert +++ /dev/null @@ -1,13 +0,0 @@ -#version 140 - -/********************Entrant********************/ -in vec3 VertexPosition; - -/********************Uniformes********************/ -uniform mat4 WorldViewProjMatrix; - -/********************Fonctions********************/ -void main() -{ - gl_Position = WorldViewProjMatrix * vec4(VertexPosition, 1.0); -} diff --git a/src/Nazara/Renderer/Resources/Shaders/Debug/core.vert.h b/src/Nazara/Renderer/Resources/Shaders/Debug/core.vert.h deleted file mode 100644 index 48c552e2d..000000000 --- a/src/Nazara/Renderer/Resources/Shaders/Debug/core.vert.h +++ /dev/null @@ -1 +0,0 @@ -35,118,101,114,115,105,111,110,32,49,52,48,13,10,13,10,47,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,69,110,116,114,97,110,116,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,47,13,10,105,110,32,118,101,99,51,32,86,101,114,116,101,120,80,111,115,105,116,105,111,110,59,13,10,13,10,47,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,85,110,105,102,111,114,109,101,115,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,47,13,10,117,110,105,102,111,114,109,32,109,97,116,52,32,87,111,114,108,100,86,105,101,119,80,114,111,106,77,97,116,114,105,120,59,13,10,13,10,47,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,70,111,110,99,116,105,111,110,115,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,47,13,10,118,111,105,100,32,109,97,105,110,40,41,13,10,123,13,10,9,103,108,95,80,111,115,105,116,105,111,110,32,61,32,87,111,114,108,100,86,105,101,119,80,114,111,106,77,97,116,114,105,120,32,42,32,118,101,99,52,40,86,101,114,116,101,120,80,111,115,105,116,105,111,110,44,32,49,46,48,41,59,13,10,125,13,10, \ No newline at end of file From 607bb9d3a042dd647e6f980c1c0027d65bf34ebf Mon Sep 17 00:00:00 2001 From: Lynix Date: Fri, 6 Jan 2017 16:34:04 +0100 Subject: [PATCH 23/30] Renderer/ShaderAst: Fix compilation errors on Linux --- include/Nazara/Renderer/ShaderAst.hpp | 2 +- include/Nazara/Renderer/ShaderAst.inl | 4 ++-- include/Nazara/Renderer/ShaderBuilder.hpp | 10 ++++++++++ src/Nazara/Renderer/GlslWriter.cpp | 6 ++++++ 4 files changed, 19 insertions(+), 3 deletions(-) diff --git a/include/Nazara/Renderer/ShaderAst.hpp b/include/Nazara/Renderer/ShaderAst.hpp index 831241853..c88fc10df 100644 --- a/include/Nazara/Renderer/ShaderAst.hpp +++ b/include/Nazara/Renderer/ShaderAst.hpp @@ -51,7 +51,7 @@ namespace Nz Float4, // vec4 Mat4x4, // mat4 - None // void + Void // void }; enum class VariableType diff --git a/include/Nazara/Renderer/ShaderAst.inl b/include/Nazara/Renderer/ShaderAst.inl index f59c9f972..9f268a09a 100644 --- a/include/Nazara/Renderer/ShaderAst.inl +++ b/include/Nazara/Renderer/ShaderAst.inl @@ -58,8 +58,8 @@ namespace Nz } inline Variable::Variable(VariableType varKind, ExpressionType varType) : - kind(varKind), - type(varType) + type(varType), + kind(varKind) { } diff --git a/include/Nazara/Renderer/ShaderBuilder.hpp b/include/Nazara/Renderer/ShaderBuilder.hpp index 4f9c6a1fe..d65d9ff41 100644 --- a/include/Nazara/Renderer/ShaderBuilder.hpp +++ b/include/Nazara/Renderer/ShaderBuilder.hpp @@ -16,29 +16,39 @@ namespace Nz { namespace ShaderBuilder template struct AssignOpBuilder { + constexpr AssignOpBuilder() = default; + std::shared_ptr operator()(const ShaderAst::VariablePtr& left, const ShaderAst::ExpressionPtr& right) const; }; template struct BinOpBuilder { + constexpr BinOpBuilder() = default; + std::shared_ptr operator()(const ShaderAst::ExpressionPtr& left, const ShaderAst::ExpressionPtr& right) const; }; struct BuiltinBuilder { + constexpr BuiltinBuilder() = default; + std::shared_ptr operator()(ShaderAst::BuiltinEntry builtin) const; }; template struct GenBuilder { + constexpr GenBuilder() = default; + template std::shared_ptr operator()(Args&&... args) const; }; template struct VarBuilder { + constexpr VarBuilder() = default; + template std::shared_ptr operator()(Args&&... args) const; }; diff --git a/src/Nazara/Renderer/GlslWriter.cpp b/src/Nazara/Renderer/GlslWriter.cpp index b910e2519..3da5b011d 100644 --- a/src/Nazara/Renderer/GlslWriter.cpp +++ b/src/Nazara/Renderer/GlslWriter.cpp @@ -64,6 +64,9 @@ namespace Nz switch (kind) { + case ShaderAst::VariableType::Builtin: //< Only there to make compiler happy + break; + case ShaderAst::VariableType::Input: m_currentState->inputs.insert(std::make_pair(type, name)); break; @@ -288,6 +291,9 @@ namespace Nz { switch (type) { + case ShaderAst::ExpressionType::Boolean: + Append("bool"); + break; case ShaderAst::ExpressionType::Float1: Append("float"); break; From 3557d0c9a8306a83787057110986f79310dab0f6 Mon Sep 17 00:00:00 2001 From: Lynix Date: Fri, 6 Jan 2017 16:38:52 +0100 Subject: [PATCH 24/30] Forgot to save all files.. --- include/Nazara/Renderer/ShaderBuilder.inl | 4 ++-- src/Nazara/Renderer/GlslWriter.cpp | 4 ++-- src/Nazara/Renderer/ShaderAst.cpp | 4 ++-- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/include/Nazara/Renderer/ShaderBuilder.inl b/include/Nazara/Renderer/ShaderBuilder.inl index 6778eb615..05e01ed40 100644 --- a/include/Nazara/Renderer/ShaderBuilder.inl +++ b/include/Nazara/Renderer/ShaderBuilder.inl @@ -28,7 +28,7 @@ namespace Nz { namespace ShaderBuilder std::shared_ptr BuiltinBuilder::operator()(ShaderAst::BuiltinEntry builtin) const { - ShaderAst::ExpressionType exprType = ShaderAst::ExpressionType::None; + ShaderAst::ExpressionType exprType = ShaderAst::ExpressionType::Void; switch (builtin) { @@ -37,7 +37,7 @@ namespace Nz { namespace ShaderBuilder break; } - NazaraAssert(exprType != ShaderAst::ExpressionType::None, "Unhandled builtin"); + NazaraAssert(exprType != ShaderAst::ExpressionType::Void, "Unhandled builtin"); return std::make_shared(builtin, exprType); } diff --git a/src/Nazara/Renderer/GlslWriter.cpp b/src/Nazara/Renderer/GlslWriter.cpp index 3da5b011d..aea4b5667 100644 --- a/src/Nazara/Renderer/GlslWriter.cpp +++ b/src/Nazara/Renderer/GlslWriter.cpp @@ -39,7 +39,7 @@ namespace Nz Function entryPoint; entryPoint.name = "main"; //< GLSL has only one entry point name possible entryPoint.node = node; - entryPoint.retType = ShaderAst::ExpressionType::None; + entryPoint.retType = ShaderAst::ExpressionType::Void; AppendFunction(entryPoint); @@ -309,7 +309,7 @@ namespace Nz case ShaderAst::ExpressionType::Mat4x4: Append("mat4"); break; - case ShaderAst::ExpressionType::None: + case ShaderAst::ExpressionType::Void: Append("void"); break; } diff --git a/src/Nazara/Renderer/ShaderAst.cpp b/src/Nazara/Renderer/ShaderAst.cpp index a1612ebf9..08e2189f1 100644 --- a/src/Nazara/Renderer/ShaderAst.cpp +++ b/src/Nazara/Renderer/ShaderAst.cpp @@ -76,7 +76,7 @@ namespace Nz { namespace ShaderAst ExpressionType BinaryOp::GetExpressionType() const { - ShaderAst::ExpressionType exprType = ShaderAst::ExpressionType::None; + ShaderAst::ExpressionType exprType = ShaderAst::ExpressionType::Void; switch (op) { @@ -91,7 +91,7 @@ namespace Nz { namespace ShaderAst exprType = ExpressionType::Boolean; } - NazaraAssert(exprType != ShaderAst::ExpressionType::None, "Unhandled builtin"); + NazaraAssert(exprType != ShaderAst::ExpressionType::Void, "Unhandled builtin"); return exprType; } From 27fcfe2fb19268f167fb3ef0c7fd250cbf2fdb48 Mon Sep 17 00:00:00 2001 From: Lynix Date: Fri, 6 Jan 2017 16:43:31 +0100 Subject: [PATCH 25/30] Renderer/ShaderBuild: Fix build? --- include/Nazara/Renderer/ShaderBuilder.hpp | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/include/Nazara/Renderer/ShaderBuilder.hpp b/include/Nazara/Renderer/ShaderBuilder.hpp index d65d9ff41..feca4b72b 100644 --- a/include/Nazara/Renderer/ShaderBuilder.hpp +++ b/include/Nazara/Renderer/ShaderBuilder.hpp @@ -16,7 +16,7 @@ namespace Nz { namespace ShaderBuilder template struct AssignOpBuilder { - constexpr AssignOpBuilder() = default; + constexpr AssignOpBuilder() {} std::shared_ptr operator()(const ShaderAst::VariablePtr& left, const ShaderAst::ExpressionPtr& right) const; }; @@ -24,14 +24,14 @@ namespace Nz { namespace ShaderBuilder template struct BinOpBuilder { - constexpr BinOpBuilder() = default; + constexpr BinOpBuilder() {} std::shared_ptr operator()(const ShaderAst::ExpressionPtr& left, const ShaderAst::ExpressionPtr& right) const; }; struct BuiltinBuilder { - constexpr BuiltinBuilder() = default; + constexpr BuiltinBuilder() {} std::shared_ptr operator()(ShaderAst::BuiltinEntry builtin) const; }; @@ -39,7 +39,7 @@ namespace Nz { namespace ShaderBuilder template struct GenBuilder { - constexpr GenBuilder() = default; + constexpr GenBuilder() {} template std::shared_ptr operator()(Args&&... args) const; }; @@ -47,7 +47,7 @@ namespace Nz { namespace ShaderBuilder template struct VarBuilder { - constexpr VarBuilder() = default; + constexpr VarBuilder() {} template std::shared_ptr operator()(Args&&... args) const; }; From b756a5b288d19cf951c014c35f299d032112c2b5 Mon Sep 17 00:00:00 2001 From: Lynix Date: Sun, 15 Jan 2017 15:07:12 +0100 Subject: [PATCH 26/30] Renderer/ShaderAst: Fix a few multiply/divide cases --- include/Nazara/Renderer/ShaderAst.inl | 13 ++++++++++++- src/Nazara/Renderer/GlslWriter.cpp | 1 + 2 files changed, 13 insertions(+), 1 deletion(-) diff --git a/include/Nazara/Renderer/ShaderAst.inl b/include/Nazara/Renderer/ShaderAst.inl index 9f268a09a..4587ca87c 100644 --- a/include/Nazara/Renderer/ShaderAst.inl +++ b/include/Nazara/Renderer/ShaderAst.inl @@ -95,7 +95,6 @@ namespace Nz switch (op) { case BinaryType::Add: - case BinaryType::Divide: case BinaryType::Equality: case BinaryType::Substract: { @@ -104,13 +103,25 @@ namespace Nz } case BinaryType::Multiply: + case BinaryType::Divide: { switch (leftType) { + case ExpressionType::Float2: + case ExpressionType::Float3: + case ExpressionType::Float4: + { + if (rightType != ExpressionType::Float1) + throw std::runtime_error("Left expression type is not compatible with right expression type"); + + break; + } + case ExpressionType::Mat4x4: { switch (rightType) { + case ExpressionType::Float1: case ExpressionType::Float4: case ExpressionType::Mat4x4: break; diff --git a/src/Nazara/Renderer/GlslWriter.cpp b/src/Nazara/Renderer/GlslWriter.cpp index aea4b5667..1c856f8eb 100644 --- a/src/Nazara/Renderer/GlslWriter.cpp +++ b/src/Nazara/Renderer/GlslWriter.cpp @@ -24,6 +24,7 @@ namespace Nz m_currentState = nullptr; }); + // Register global variables (uniforms, varying, ..) node->Register(*this); // Header From af766019ad8ee5740ae9b5a12f26b9ca009246ec Mon Sep 17 00:00:00 2001 From: Lynix Date: Sun, 15 Jan 2017 22:04:51 +0100 Subject: [PATCH 27/30] Renderer/ShaderAst: Add Swizzle --- include/Nazara/Renderer/GlslWriter.hpp | 1 + include/Nazara/Renderer/ShaderAst.hpp | 46 +++++++++++++++++------ include/Nazara/Renderer/ShaderAst.inl | 40 ++++++++++++++++---- include/Nazara/Renderer/ShaderBuilder.hpp | 1 + include/Nazara/Renderer/ShaderWriter.hpp | 1 + src/Nazara/Renderer/GlslWriter.cpp | 28 ++++++++++++++ src/Nazara/Renderer/ShaderAst.cpp | 16 ++++++++ 7 files changed, 114 insertions(+), 19 deletions(-) diff --git a/include/Nazara/Renderer/GlslWriter.hpp b/include/Nazara/Renderer/GlslWriter.hpp index ce9d46420..21153c6be 100644 --- a/include/Nazara/Renderer/GlslWriter.hpp +++ b/include/Nazara/Renderer/GlslWriter.hpp @@ -42,6 +42,7 @@ namespace Nz 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::SwizzleOp& node) override; private: struct Function; diff --git a/include/Nazara/Renderer/ShaderAst.hpp b/include/Nazara/Renderer/ShaderAst.hpp index c88fc10df..0435c32ee 100644 --- a/include/Nazara/Renderer/ShaderAst.hpp +++ b/include/Nazara/Renderer/ShaderAst.hpp @@ -54,6 +54,14 @@ namespace Nz Void // void }; + enum class SwizzleComponent + { + First, + Second, + Third, + Fourth + }; + enum class VariableType { Builtin, @@ -139,6 +147,19 @@ namespace Nz VariableType kind; }; + + class NAZARA_RENDERER_API BuiltinVariable : public Variable + { + public: + inline BuiltinVariable(BuiltinEntry variable, ExpressionType varType); + + void Register(ShaderWriter& visitor) override; + void Visit(ShaderWriter& visitor) override; + + BuiltinEntry var; + }; + + class NamedVariable; using NamedVariablePtr = std::shared_ptr; @@ -154,17 +175,6 @@ namespace Nz Nz::String name; }; - class NAZARA_RENDERER_API BuiltinVariable : public Variable - { - public: - inline BuiltinVariable(BuiltinEntry variable, ExpressionType varType); - - void Register(ShaderWriter& visitor) override; - void Visit(ShaderWriter& visitor) override; - - BuiltinEntry var; - }; - ////////////////////////////////////////////////////////////////////////// class NAZARA_RENDERER_API AssignOp : public Expression @@ -250,6 +260,20 @@ namespace Nz Vector4f vec4; } values; }; + + class NAZARA_RENDERER_API SwizzleOp : public Expression + { + public: + inline SwizzleOp(ExpressionPtr expressionPtr, std::initializer_list swizzleComponents); + + ExpressionType GetExpressionType() const override; + void Register(ShaderWriter& visitor) override; + void Visit(ShaderWriter& visitor) override; + + std::array components; + std::size_t componentCount; + ExpressionPtr expression; + }; } } diff --git a/include/Nazara/Renderer/ShaderAst.inl b/include/Nazara/Renderer/ShaderAst.inl index 4587ca87c..b23078f0a 100644 --- a/include/Nazara/Renderer/ShaderAst.inl +++ b/include/Nazara/Renderer/ShaderAst.inl @@ -24,7 +24,7 @@ namespace Nz return 4; case ExpressionType::Mat4x4: - return 16; + return 4; default: return 1; @@ -38,9 +38,11 @@ namespace Nz case ExpressionType::Float2: case ExpressionType::Float3: case ExpressionType::Float4: - case ExpressionType::Mat4x4: return ExpressionType::Float1; + case ExpressionType::Mat4x4: + return ExpressionType::Float4; + default: return type; } @@ -63,18 +65,18 @@ namespace Nz { } - inline NamedVariable::NamedVariable(VariableType varKind, const Nz::String& varName, ExpressionType varType) : - Variable(varKind, varType), - name(varName) - { - } - inline BuiltinVariable::BuiltinVariable(BuiltinEntry variable, ExpressionType varType) : Variable(VariableType::Builtin, varType), var(variable) { } + inline NamedVariable::NamedVariable(VariableType varKind, const Nz::String& varName, ExpressionType varType) : + Variable(varKind, varType), + name(varName) + { + } + inline AssignOp::AssignOp(AssignType Op, VariablePtr Var, ExpressionPtr Right) : op(Op), variable(std::move(Var)), @@ -197,6 +199,28 @@ namespace Nz { values.vec4 = value; } + + inline SwizzleOp::SwizzleOp(ExpressionPtr expressionPtr, std::initializer_list swizzleComponents) : + componentCount(swizzleComponents.size()), + expression(expressionPtr) + { + if (componentCount > 4) + throw std::runtime_error("Cannot swizzle more than four elements"); + + switch (expressionPtr->GetExpressionType()) + { + case ExpressionType::Float1: + case ExpressionType::Float2: + case ExpressionType::Float3: + case ExpressionType::Float4: + break; + + default: + throw std::runtime_error("Cannot swizzle this type"); + } + + std::copy(swizzleComponents.begin(), swizzleComponents.end(), components.begin()); + } } } diff --git a/include/Nazara/Renderer/ShaderBuilder.hpp b/include/Nazara/Renderer/ShaderBuilder.hpp index feca4b72b..0cfefca7e 100644 --- a/include/Nazara/Renderer/ShaderBuilder.hpp +++ b/include/Nazara/Renderer/ShaderBuilder.hpp @@ -65,6 +65,7 @@ namespace Nz { namespace ShaderBuilder constexpr BinOpBuilder Multiply; constexpr VarBuilder Output; constexpr VarBuilder Parameter; + constexpr GenBuilder Swizzle; constexpr BinOpBuilder Substract; constexpr VarBuilder Uniform; constexpr VarBuilder Variable; diff --git a/include/Nazara/Renderer/ShaderWriter.hpp b/include/Nazara/Renderer/ShaderWriter.hpp index 3c17bf936..35baf3959 100644 --- a/include/Nazara/Renderer/ShaderWriter.hpp +++ b/include/Nazara/Renderer/ShaderWriter.hpp @@ -36,6 +36,7 @@ namespace Nz 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::SwizzleOp& node) = 0; }; } diff --git a/src/Nazara/Renderer/GlslWriter.cpp b/src/Nazara/Renderer/GlslWriter.cpp index 1c856f8eb..074082165 100644 --- a/src/Nazara/Renderer/GlslWriter.cpp +++ b/src/Nazara/Renderer/GlslWriter.cpp @@ -278,6 +278,34 @@ namespace Nz } } + void GlslWriter::Write(const ShaderAst::SwizzleOp& node) + { + Write(node.expression); + Append("."); + + for (std::size_t i = 0; i < node.componentCount; ++i) + { + switch (node.components[i]) + { + case ShaderAst::SwizzleComponent::First: + Append("x"); + break; + + case ShaderAst::SwizzleComponent::Second: + Append("y"); + break; + + case ShaderAst::SwizzleComponent::Third: + Append("z"); + break; + + case ShaderAst::SwizzleComponent::Fourth: + Append("w"); + break; + } + } + } + void GlslWriter::Append(ShaderAst::BuiltinEntry builtin) { switch (builtin) diff --git a/src/Nazara/Renderer/ShaderAst.cpp b/src/Nazara/Renderer/ShaderAst.cpp index 08e2189f1..71b4b27cf 100644 --- a/src/Nazara/Renderer/ShaderAst.cpp +++ b/src/Nazara/Renderer/ShaderAst.cpp @@ -163,5 +163,21 @@ namespace Nz { namespace ShaderAst { visitor.Write(*this); } + + + ExpressionType ShaderAst::SwizzleOp::GetExpressionType() const + { + return GetComponentType(expression->GetExpressionType()); + } + + void SwizzleOp::Register(ShaderWriter& visitor) + { + expression->Register(visitor); + } + + void SwizzleOp::Visit(ShaderWriter& visitor) + { + visitor.Write(*this); + } } } From 29a0ee773bd2b2d7ad1951f81906a9638d34db71 Mon Sep 17 00:00:00 2001 From: Lynix Date: Sat, 21 Jan 2017 15:53:18 +0100 Subject: [PATCH 28/30] Renderer/ShaderAst: Add ConditionalStatement --- include/Nazara/Renderer/ShaderAst.inl | 6 ++++++ include/Nazara/Renderer/ShaderBuilder.hpp | 1 + include/Nazara/Renderer/ShaderWriter.hpp | 9 +++++++++ src/Nazara/Renderer/ShaderAst.cpp | 13 +++++++++++++ src/Nazara/Renderer/ShaderWriter.cpp | 13 +++++++++++++ 5 files changed, 42 insertions(+) diff --git a/include/Nazara/Renderer/ShaderAst.inl b/include/Nazara/Renderer/ShaderAst.inl index b23078f0a..b03045386 100644 --- a/include/Nazara/Renderer/ShaderAst.inl +++ b/include/Nazara/Renderer/ShaderAst.inl @@ -53,6 +53,12 @@ namespace Nz { } + inline ConditionalStatement::ConditionalStatement(const String& condition, StatementPtr statementPtr) : + conditionName(condition), + statement(std::move(statementPtr)) + { + } + template StatementBlock::StatementBlock(Args&& ...args) : statements({std::forward(args)...}) diff --git a/include/Nazara/Renderer/ShaderBuilder.hpp b/include/Nazara/Renderer/ShaderBuilder.hpp index 0cfefca7e..e642ea8d3 100644 --- a/include/Nazara/Renderer/ShaderBuilder.hpp +++ b/include/Nazara/Renderer/ShaderBuilder.hpp @@ -57,6 +57,7 @@ namespace Nz { namespace ShaderBuilder constexpr BuiltinBuilder Builtin; constexpr GenBuilder Block; constexpr GenBuilder Branch; + constexpr GenBuilder ConditionalStatement; constexpr GenBuilder Constant; constexpr BinOpBuilder Divide; constexpr BinOpBuilder Equal; diff --git a/include/Nazara/Renderer/ShaderWriter.hpp b/include/Nazara/Renderer/ShaderWriter.hpp index 35baf3959..13ef6e367 100644 --- a/include/Nazara/Renderer/ShaderWriter.hpp +++ b/include/Nazara/Renderer/ShaderWriter.hpp @@ -8,8 +8,10 @@ #define NAZARA_SHADERWRITER_HPP #include +#include #include #include +#include namespace Nz { @@ -21,6 +23,10 @@ namespace Nz ShaderWriter(ShaderWriter&&) = delete; virtual ~ShaderWriter(); + void EnableCondition(const String& name, bool cond); + + bool IsConditionEnabled(const String& name) const; + virtual Nz::String Generate(const ShaderAst::StatementPtr& node) = 0; virtual void RegisterFunction(const String& name, ShaderAst::StatementPtr node, std::initializer_list parameters, ShaderAst::ExpressionType ret) = 0; @@ -37,6 +43,9 @@ namespace Nz virtual void Write(const ShaderAst::NodePtr& node) = 0; virtual void Write(const ShaderAst::StatementBlock& node) = 0; virtual void Write(const ShaderAst::SwizzleOp& node) = 0; + + private: + std::unordered_set m_conditions; }; } diff --git a/src/Nazara/Renderer/ShaderAst.cpp b/src/Nazara/Renderer/ShaderAst.cpp index 71b4b27cf..ef6860d68 100644 --- a/src/Nazara/Renderer/ShaderAst.cpp +++ b/src/Nazara/Renderer/ShaderAst.cpp @@ -19,6 +19,19 @@ namespace Nz { namespace ShaderAst } + void ConditionalStatement::Register(ShaderWriter& visitor) + { + if (visitor.IsConditionEnabled(conditionName)) + statement->Register(visitor); + } + + void ConditionalStatement::Visit(ShaderWriter& visitor) + { + if (visitor.IsConditionEnabled(conditionName)) + statement->Visit(visitor); + } + + void StatementBlock::Register(ShaderWriter& visitor) { for (auto& statementPtr : statements) diff --git a/src/Nazara/Renderer/ShaderWriter.cpp b/src/Nazara/Renderer/ShaderWriter.cpp index 8ca48da3e..c862572ab 100644 --- a/src/Nazara/Renderer/ShaderWriter.cpp +++ b/src/Nazara/Renderer/ShaderWriter.cpp @@ -8,4 +8,17 @@ namespace Nz { ShaderWriter::~ShaderWriter() = default; + + void ShaderWriter::EnableCondition(const String& name, bool cond) + { + if (cond) + m_conditions.insert(name); + else + m_conditions.erase(name); + } + + bool ShaderWriter::IsConditionEnabled(const String & name) const + { + return m_conditions.count(name) != 0; + } } From de3ff89cf21aadd95974f3689dd1c7278d1152fd Mon Sep 17 00:00:00 2001 From: Lynix Date: Sat, 21 Jan 2017 15:54:16 +0100 Subject: [PATCH 29/30] Renderer/ShaderAst: Fix missing file from previous commit --- include/Nazara/Renderer/ShaderAst.hpp | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/include/Nazara/Renderer/ShaderAst.hpp b/include/Nazara/Renderer/ShaderAst.hpp index 0435c32ee..9409e3d0d 100644 --- a/include/Nazara/Renderer/ShaderAst.hpp +++ b/include/Nazara/Renderer/ShaderAst.hpp @@ -121,6 +121,18 @@ namespace Nz ////////////////////////////////////////////////////////////////////////// + class NAZARA_RENDERER_API ConditionalStatement : public Statement + { + public: + inline ConditionalStatement(const String& condition, StatementPtr statementPtr); + + void Register(ShaderWriter& visitor) override; + void Visit(ShaderWriter& visitor) override; + + String conditionName; + StatementPtr statement; + }; + class NAZARA_RENDERER_API StatementBlock : public Statement { public: From ef1d9dac3d8ab450970255e0b846606a5af62504 Mon Sep 17 00:00:00 2001 From: Lynix Date: Wed, 15 Feb 2017 07:52:02 +0100 Subject: [PATCH 30/30] Renderer/Renderer: Default to current GLSL version for AST generation --- src/Nazara/Renderer/Renderer.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/Nazara/Renderer/Renderer.cpp b/src/Nazara/Renderer/Renderer.cpp index 223f06537..72bbfdaaa 100644 --- a/src/Nazara/Renderer/Renderer.cpp +++ b/src/Nazara/Renderer/Renderer.cpp @@ -1843,11 +1843,11 @@ namespace Nz bool Renderer::GenerateDebugShader() { - Nz::GlslWriter writer; - writer.SetGlslVersion(140); + GlslWriter writer; + writer.SetGlslVersion(OpenGL::GetGLSLVersion()); - Nz::String fragmentShader; - Nz::String vertexShader; + String fragmentShader; + String vertexShader; try {