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

Shader: Remove ShaderNode::GetExpressionType (replaced by visitor) and minor stuff

This commit is contained in:
Jérôme Leclercq 2021-01-14 22:01:53 +01:00
parent 00ac6e8a0a
commit a037eef4c9
9 changed files with 157 additions and 32 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
include/Nazara/Shader/ShaderAstUtils.hpp Normal file
View File

@ -0,0 +1,54 @@
// Copyright (C) 2020 Jérôme Leclercq
// This file is part of the "Nazara Engine - Shader generator"
// For conditions of distribution and use, see copyright notice in Config.hpp
#pragma once
#ifndef NAZARA_SHADERASTUTILS_HPP
#define NAZARA_SHADERASTUTILS_HPP
#include <Nazara/Prerequisites.hpp>
#include <Nazara/Shader/Config.hpp>
#include <Nazara/Shader/ShaderEnums.hpp>
#include <Nazara/Shader/ShaderAstVisitorExcept.hpp>
#include <vector>
namespace Nz
{
class ShaderAst;
class NAZARA_SHADER_API ShaderAstValueCategory final : public ShaderAstVisitorExcept
{
public:
ShaderAstValueCategory() = default;
ShaderAstValueCategory(const ShaderAstValueCategory&) = delete;
ShaderAstValueCategory(ShaderAstValueCategory&&) = delete;
~ShaderAstValueCategory() = default;
ShaderNodes::ExpressionCategory GetExpressionCategory(const ShaderNodes::ExpressionPtr& expression);
ShaderAstValueCategory& operator=(const ShaderAstValueCategory&) = delete;
ShaderAstValueCategory& operator=(ShaderAstValueCategory&&) = delete;
private:
using ShaderAstVisitorExcept::Visit;
void Visit(ShaderNodes::AccessMember& node) override;
void Visit(ShaderNodes::AssignOp& node) override;
void Visit(ShaderNodes::BinaryOp& node) override;
void Visit(ShaderNodes::Cast& node) override;
void Visit(ShaderNodes::ConditionalExpression& node) override;
void Visit(ShaderNodes::Constant& node) override;
void Visit(ShaderNodes::Identifier& node) override;
void Visit(ShaderNodes::IntrinsicCall& node) override;
void Visit(ShaderNodes::Sample2D& node) override;
void Visit(ShaderNodes::SwizzleOp& node) override;
ShaderNodes::ExpressionCategory m_expressionCategory;
};
inline ShaderNodes::ExpressionCategory GetExpressionCategory(const ShaderNodes::ExpressionPtr& expression);
}
#include <Nazara/Shader/ShaderAstUtils.inl>
#endif

17
include/Nazara/Shader/ShaderAstUtils.inl Normal file
View File

@ -0,0 +1,17 @@
// Copyright (C) 2020 Jérôme Leclercq
// This file is part of the "Nazara Engine - Shader generator"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Shader/ShaderAstUtils.hpp>
#include <Nazara/Shader/Debug.hpp>
namespace Nz
{
ShaderNodes::ExpressionCategory GetExpressionCategory(const ShaderNodes::ExpressionPtr& expression)
{
ShaderAstValueCategory visitor;
return visitor.GetExpressionCategory(expression);
}
}
#include <Nazara/Shader/DebugOff.hpp>

9
include/Nazara/Shader/ShaderNodes.hpp
View File

@ -17,6 +17,7 @@
#include <Nazara/Shader/ShaderExpressionType.hpp>
#include <Nazara/Shader/ShaderVariables.hpp>
#include <array>
#include <memory>
#include <optional>
#include <string>
@ -55,12 +56,11 @@ namespace Nz
using ExpressionPtr = std::shared_ptr<Expression>;
class NAZARA_SHADER_API Expression : public Node
class NAZARA_SHADER_API Expression : public Node, public std::enable_shared_from_this<Expression>
{
public:
inline Expression(NodeType type);
virtual ExpressionCategory GetExpressionCategory() const;
virtual ShaderExpressionType GetExpressionType() const = 0;
};
@ -68,7 +68,7 @@ namespace Nz
using StatementPtr = std::shared_ptr<Statement>;
class NAZARA_SHADER_API Statement : public Node
class NAZARA_SHADER_API Statement : public Node, public std::enable_shared_from_this<Statement>
{
public:
inline Statement(NodeType type);
@ -136,7 +136,6 @@ namespace Nz
{
inline Identifier();
ExpressionCategory GetExpressionCategory() const override;
ShaderExpressionType GetExpressionType() const override;
void Visit(ShaderAstVisitor& visitor) override;
@ -149,7 +148,6 @@ namespace Nz
{
inline AccessMember();
ExpressionCategory GetExpressionCategory() const override;
ShaderExpressionType GetExpressionType() const override;
void Visit(ShaderAstVisitor& visitor) override;
@ -265,7 +263,6 @@ namespace Nz
{
inline SwizzleOp();
ExpressionCategory GetExpressionCategory() const override;
ShaderExpressionType GetExpressionType() const override;
void Visit(ShaderAstVisitor& visitor) override;

4
src/Nazara/Shader/GlslWriter.cpp
View File

@ -8,6 +8,7 @@
#include <Nazara/Math/Algorithm.hpp>
#include <Nazara/Shader/ShaderBuilder.hpp>
#include <Nazara/Shader/ShaderAstCloner.hpp>
#include <Nazara/Shader/ShaderAstUtils.hpp>
#include <Nazara/Shader/ShaderAstValidator.hpp>
#include <stdexcept>
#include <Nazara/Shader/Debug.hpp>
@ -349,7 +350,7 @@ namespace Nz
void GlslWriter::Visit(ShaderNodes::ExpressionPtr& expr, bool encloseIfRequired)
{
bool enclose = encloseIfRequired && (expr->GetExpressionCategory() != ShaderNodes::ExpressionCategory::LValue);
bool enclose = encloseIfRequired && (GetExpressionCategory(expr) != ShaderNodes::ExpressionCategory::LValue);
if (enclose)
Append("(");
@ -461,7 +462,6 @@ namespace Nz
Append(")");
}
void GlslWriter::Visit(ShaderNodes::ConditionalExpression& node)
{
std::size_t conditionIndex = m_context.shader->FindConditionByName(node.conditionName);

73
src/Nazara/Shader/ShaderAstUtils.cpp Normal file
View File

@ -0,0 +1,73 @@
// Copyright (C) 2020 Jérôme Leclercq
// This file is part of the "Nazara Engine - Shader generator"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Shader/ShaderAstUtils.hpp>
#include <Nazara/Shader/Debug.hpp>
namespace Nz
{
ShaderNodes::ExpressionCategory ShaderAstValueCategory::GetExpressionCategory(const ShaderNodes::ExpressionPtr& expression)
{
Visit(expression);
return m_expressionCategory;
}
void ShaderAstValueCategory::Visit(ShaderNodes::AccessMember& node)
{
Visit(node.structExpr);
}
void ShaderAstValueCategory::Visit(ShaderNodes::AssignOp& node)
{
m_expressionCategory = ShaderNodes::ExpressionCategory::RValue;
}
void ShaderAstValueCategory::Visit(ShaderNodes::BinaryOp& node)
{
m_expressionCategory = ShaderNodes::ExpressionCategory::RValue;
}
void ShaderAstValueCategory::Visit(ShaderNodes::Cast& node)
{
m_expressionCategory = ShaderNodes::ExpressionCategory::RValue;
}
void ShaderAstValueCategory::Visit(ShaderNodes::ConditionalExpression& node)
{
Visit(node.truePath);
ShaderNodes::ExpressionCategory trueExprCategory = m_expressionCategory;
Visit(node.falsePath);
ShaderNodes::ExpressionCategory falseExprCategory = m_expressionCategory;
if (trueExprCategory == ShaderNodes::ExpressionCategory::RValue || falseExprCategory == ShaderNodes::ExpressionCategory::RValue)
m_expressionCategory = ShaderNodes::ExpressionCategory::RValue;
else
m_expressionCategory = ShaderNodes::ExpressionCategory::LValue;
}
void ShaderAstValueCategory::Visit(ShaderNodes::Constant& node)
{
m_expressionCategory = ShaderNodes::ExpressionCategory::RValue;
}
void ShaderAstValueCategory::Visit(ShaderNodes::Identifier& node)
{
m_expressionCategory = ShaderNodes::ExpressionCategory::LValue;
}
void ShaderAstValueCategory::Visit(ShaderNodes::IntrinsicCall& node)
{
m_expressionCategory = ShaderNodes::ExpressionCategory::RValue;
}
void ShaderAstValueCategory::Visit(ShaderNodes::Sample2D& node)
{
m_expressionCategory = ShaderNodes::ExpressionCategory::RValue;
}
void ShaderAstValueCategory::Visit(ShaderNodes::SwizzleOp& node)
{
Visit(node.expression);
}
}

8
src/Nazara/Shader/ShaderAstValidator.cpp
View File

@ -5,6 +5,7 @@
#include <Nazara/Shader/ShaderAstValidator.hpp>
#include <Nazara/Core/CallOnExit.hpp>
#include <Nazara/Shader/ShaderAst.hpp>
#include <Nazara/Shader/ShaderAstUtils.hpp>
#include <Nazara/Shader/ShaderVariables.hpp>
#include <vector>
#include <Nazara/Shader/Debug.hpp>
@ -126,7 +127,7 @@ namespace Nz
MandatoryNode(node.right);
TypeMustMatch(node.left, node.right);
if (node.left->GetExpressionCategory() != ShaderNodes::ExpressionCategory::LValue)
if (GetExpressionCategory(node.left) != ShaderNodes::ExpressionCategory::LValue)
throw AstError { "Assignation is only possible with a l-value" };
ShaderAstRecursiveVisitor::Visit(node);
@ -221,7 +222,10 @@ namespace Nz
{
for (const auto& condStatement : node.condStatements)
{
MandatoryNode(condStatement.condition);
const ShaderExpressionType& condType = MandatoryExpr(condStatement.condition)->GetExpressionType();
if (!IsBasicType(condType) || std::get<ShaderNodes::BasicType>(condType) != ShaderNodes::BasicType::Boolean)
throw AstError{ "if expression must resolve to boolean type" };
MandatoryNode(condStatement.statement);
}

20
src/Nazara/Shader/ShaderNodes.cpp
View File

@ -13,11 +13,6 @@ namespace Nz::ShaderNodes
{
Node::~Node() = default;
ExpressionCategory Expression::GetExpressionCategory() const
{
return ExpressionCategory::RValue;
}
void ExpressionStatement::Visit(ShaderAstVisitor& visitor)
{
visitor.Visit(*this);
@ -48,11 +43,6 @@ namespace Nz::ShaderNodes
}
ExpressionCategory Identifier::GetExpressionCategory() const
{
return ExpressionCategory::LValue;
}
ShaderExpressionType Identifier::GetExpressionType() const
{
assert(var);
@ -64,11 +54,6 @@ namespace Nz::ShaderNodes
visitor.Visit(*this);
}
ExpressionCategory AccessMember::GetExpressionCategory() const
{
return structExpr->GetExpressionCategory();
}
ShaderExpressionType AccessMember::GetExpressionType() const
{
return exprType;
@ -231,11 +216,6 @@ namespace Nz::ShaderNodes
}
ExpressionCategory SwizzleOp::GetExpressionCategory() const
{
return expression->GetExpressionCategory();
}
ShaderExpressionType SwizzleOp::GetExpressionType() const
{
const ShaderExpressionType& exprType = expression->GetExpressionType();

2
src/Nazara/Shader/SpirvExpressionLoad.cpp
View File

@ -13,7 +13,7 @@ namespace Nz
namespace
{
template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...)->overloaded<Ts...>;
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;
}
UInt32 SpirvExpressionLoad::Evaluate(ShaderNodes::Expression& node)

2
src/ShaderNode/ShaderGraph.cpp
View File

@ -531,7 +531,7 @@ Nz::ShaderNodes::StatementPtr ShaderGraph::ToAst()
auto expression = std::static_pointer_cast<Nz::ShaderNodes::Expression>(astNode);
Nz::ShaderNodes::ExpressionPtr varExpression;
if (expression->GetExpressionCategory() == Nz::ShaderNodes::ExpressionCategory::RValue)
if (Nz::GetExpressionCategory(expression) == Nz::ShaderNodes::ExpressionCategory::RValue)
{
std::string name;
if (variableName.empty())