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

Commit current work

This commit is contained in:
Lynix 2017-01-03 14:40:49 +01:00
parent 46d021c29c
commit 5c6df52fbf
9 changed files with 813 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

73
include/Nazara/Renderer/GlslWriter.hpp Normal file
View File

@ -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 <Nazara/Prerequesites.hpp>
#include <Nazara/Core/StringStream.hpp>
#include <Nazara/Renderer/Config.hpp>
#include <Nazara/Renderer/ShaderWriter.hpp>
#include <map>
#include <set>
#include <unordered_map>
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<ShaderAst::VariablePtr> 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<ShaderAst::VariablePtr> parameters;
ShaderAst::ExpressionType retType;
ShaderAst::StatementPtr node;
String name;
};
struct State
{
std::set<std::pair<ShaderAst::ExpressionType, String>> m_variables;
StringStream stream;
unsigned int indentLevel = 0;
};
std::unordered_map<String, Function> m_functions;
State* m_currentState;
};
}
#endif // NAZARA_GLSLWRITER_HPP

197
include/Nazara/Renderer/ShaderAst.hpp Normal file
View File

@ -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 <Nazara/Prerequesites.hpp>
#include <Nazara/Core/String.hpp>
#include <Nazara/Math/Vector2.hpp>
#include <Nazara/Math/Vector3.hpp>
#include <Nazara/Math/Vector4.hpp>
#include <Nazara/Renderer/Config.hpp>
#include <Nazara/Renderer/Enums.hpp>
#include <memory>
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<Node>;
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<Statement>;
class NAZARA_RENDERER_API Statement : public Node
{
};
class Expression;
using ExpressionPtr = std::shared_ptr<Expression>;
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<typename... Args> explicit StatementBlock(Args&&... args);
void Register(ShaderWriter& visitor) override;
void Visit(ShaderWriter& visitor) override;
std::vector<StatementPtr> statements;
};
class Variable;
using VariablePtr = std::shared_ptr<Variable>;
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<ConditionalStatement> 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 <Nazara/Renderer/ShaderAst.inl>
#endif // NAZARA_SHADER_AST_HPP

58
include/Nazara/Renderer/ShaderAst.inl Normal file
View File

@ -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 <Nazara/Renderer/ShaderAst.hpp>
#include <Nazara/Renderer/Debug.hpp>
namespace Nz
{
namespace ShaderAst
{
inline ExpressionStatement::ExpressionStatement(ExpressionPtr expr) :
expression(std::move(expr))
{
}
template<typename... Args>
StatementBlock::StatementBlock(Args&& ...args) :
statements({std::forward<Args>(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 <Nazara/Renderer/DebugOff.hpp>

70
include/Nazara/Renderer/ShaderBuilder.hpp Normal file
View File

@ -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 <Nazara/Prerequesites.hpp>
#include <Nazara/Renderer/ShaderAst.hpp>
#include <memory>
namespace Nz { namespace ShaderBuilder
{
template<typename T>
class GenBuilder
{
public:
template<typename... Args>
std::shared_ptr<T> operator()(Args&&... args) const
{
return std::make_shared<T>(std::forward<Args>(args)...);
}
};
template<Nz::ShaderAst::AssignType op>
class AssignOpBuilder
{
public:
std::shared_ptr<Nz::ShaderAst::AssignOp> operator()(const Nz::ShaderAst::VariablePtr& left, const Nz::ShaderAst::ExpressionPtr& right) const
{
return std::make_shared<Nz::ShaderAst::AssignOp>(op, left, right);
}
};
template<Nz::ShaderAst::BinaryType op>
class BinOpBuilder
{
public:
std::shared_ptr<Nz::ShaderAst::BinaryOp> operator()(const Nz::ShaderAst::ExpressionPtr& left, const Nz::ShaderAst::ExpressionPtr& right) const
{
return std::make_shared<Nz::ShaderAst::BinaryOp>(op, left, right);
}
};
template<Nz::ShaderAst::VariableType type>
class VarBuilder
{
public:
template<typename... Args>
std::shared_ptr<Nz::ShaderAst::Variable> operator()(Args&&... args) const
{
return std::make_shared<Nz::ShaderAst::Variable>(type, std::forward<Args>(args)...);
}
};
constexpr BinOpBuilder<Nz::ShaderAst::BinaryType::Add> Add;
constexpr AssignOpBuilder<Nz::ShaderAst::AssignType::Simple> Assign;
constexpr BinOpBuilder<Nz::ShaderAst::BinaryType::Equality> Equal;
constexpr GenBuilder<Nz::ShaderAst::StatementBlock> Block;
constexpr GenBuilder<Nz::ShaderAst::Branch> Branch;
constexpr GenBuilder<Nz::ShaderAst::Constant> Constant;
constexpr GenBuilder<Nz::ShaderAst::ExpressionStatement> ExprStatement;
constexpr VarBuilder<Nz::ShaderAst::VariableType::Variable> Variable;
} }
#include <Nazara/Renderer/ShaderBuilder.inl>
#endif // NAZARA_SHADER_BUILDER_HPP

15
include/Nazara/Renderer/ShaderBuilder.inl Normal file
View File

@ -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 <Nazara/Renderer/ShaderBuilder.hpp>
#include <Nazara/Renderer/Debug.hpp>
namespace Nz
{
namespace ShaderAst
{
}
}
#include <Nazara/Renderer/DebugOff.hpp>

40
include/Nazara/Renderer/ShaderWriter.hpp Normal file
View File

@ -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 <Nazara/Prerequesites.hpp>
#include <Nazara/Renderer/Config.hpp>
#include <Nazara/Renderer/ShaderAst.hpp>
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<ShaderAst::VariablePtr> 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

253
src/Nazara/Renderer/GlslWriter.cpp Normal file
View File

@ -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 <Nazara/Renderer/GlslWriter.hpp>
#include <Nazara/Core/CallOnExit.hpp>
#include <Nazara/Renderer/Debug.hpp>
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<ShaderAst::VariablePtr> 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("}");
}
}

96
src/Nazara/Renderer/ShaderAst.cpp Normal file
View File

@ -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 <Nazara/Renderer/ShaderAst.hpp>
#include <Nazara/Renderer/ShaderWriter.hpp>
#include <Nazara/Renderer/Debug.hpp>
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);
}
}
}

11
src/Nazara/Renderer/ShaderWriter.cpp Normal file
View File

@ -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 <Nazara/Renderer/ShaderWriter.hpp>
#include <Nazara/Renderer/Debug.hpp>
namespace Nz
{
ShaderWriter::~ShaderWriter() = default;
}