Commit current work
This commit is contained in:
Lynix
parent
46d021c29c
commit
5c6df52fbf
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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>
|
||||
|
|
@ -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
|
||||
|
|
@ -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>
|
||||
|
|
@ -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
|
||||
|
|
@ -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("}");
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -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;
|
||||
}
|
||||
Loading…
Reference in New Issue