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

Shader: Rename ConstantExpression to ConstantValueExpression

This commit is contained in:
Jérôme Leclercq 2021-07-08 15:22:08 +02:00
parent a895e553d4
commit 3a31c77524
23 changed files with 77 additions and 77 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/Nazara/Shader/Ast/AstCloner.hpp
View File

@ -47,7 +47,7 @@ namespace Nz::ShaderAst
virtual ExpressionPtr Clone(CastExpression& node);
virtual ExpressionPtr Clone(ConditionalExpression& node);
virtual ExpressionPtr Clone(ConstantIndexExpression& node);
virtual ExpressionPtr Clone(ConstantExpression& node);
virtual ExpressionPtr Clone(ConstantValueExpression& node);
virtual ExpressionPtr Clone(IdentifierExpression& node);
virtual ExpressionPtr Clone(IntrinsicExpression& node);
virtual ExpressionPtr Clone(SwizzleExpression& node);

2
include/Nazara/Shader/Ast/AstNodeList.hpp
View File

@ -34,7 +34,7 @@ NAZARA_SHADERAST_EXPRESSION(CallFunctionExpression)
NAZARA_SHADERAST_EXPRESSION(CallMethodExpression)
NAZARA_SHADERAST_EXPRESSION(CastExpression)
NAZARA_SHADERAST_EXPRESSION(ConditionalExpression)
NAZARA_SHADERAST_EXPRESSION(ConstantExpression)
NAZARA_SHADERAST_EXPRESSION(ConstantValueExpression)
NAZARA_SHADERAST_EXPRESSION(ConstantIndexExpression)
NAZARA_SHADERAST_EXPRESSION(IdentifierExpression)
NAZARA_SHADERAST_EXPRESSION(IntrinsicExpression)

6
include/Nazara/Shader/Ast/AstOptimizer.hpp
View File

@ -48,9 +48,9 @@ namespace Nz::ShaderAst
StatementPtr Clone(BranchStatement& node) override;
StatementPtr Clone(ConditionalStatement& node) override;
template<BinaryType Type> ExpressionPtr PropagateBinaryConstant(std::unique_ptr<ConstantExpression>&& lhs, std::unique_ptr<ConstantExpression>&& rhs);
template<typename TargetType> ExpressionPtr PropagateSingleValueCast(std::unique_ptr<ConstantExpression>&& operand);
template<UnaryType Type> ExpressionPtr PropagateUnaryConstant(std::unique_ptr<ConstantExpression>&& operand);
template<BinaryType Type> ExpressionPtr PropagateBinaryConstant(std::unique_ptr<ConstantValueExpression>&& lhs, std::unique_ptr<ConstantValueExpression>&& rhs);
template<typename TargetType> ExpressionPtr PropagateSingleValueCast(std::unique_ptr<ConstantValueExpression>&& operand);
template<UnaryType Type> ExpressionPtr PropagateUnaryConstant(std::unique_ptr<ConstantValueExpression>&& operand);
template<typename TargetType> ExpressionPtr PropagateVec2Cast(TargetType v1, TargetType v2);
template<typename TargetType> ExpressionPtr PropagateVec3Cast(TargetType v1, TargetType v2, TargetType v3);
template<typename TargetType> ExpressionPtr PropagateVec4Cast(TargetType v1, TargetType v2, TargetType v3, TargetType v4);

2
include/Nazara/Shader/Ast/AstRecursiveVisitor.hpp
View File

@ -28,7 +28,7 @@ namespace Nz::ShaderAst
void Visit(CallMethodExpression& node) override;
void Visit(CastExpression& node) override;
void Visit(ConditionalExpression& node) override;
void Visit(ConstantExpression& node) override;
void Visit(ConstantValueExpression& node) override;
void Visit(ConstantIndexExpression& node) override;
void Visit(IdentifierExpression& node) override;
void Visit(IntrinsicExpression& node) override;

2
include/Nazara/Shader/Ast/AstSerializer.hpp
View File

@ -32,7 +32,7 @@ namespace Nz::ShaderAst
void Serialize(CastExpression& node);
void Serialize(ConstantIndexExpression& node);
void Serialize(ConditionalExpression& node);
void Serialize(ConstantExpression& node);
void Serialize(ConstantValueExpression& node);
void Serialize(IdentifierExpression& node);
void Serialize(IntrinsicExpression& node);
void Serialize(SwizzleExpression& node);

2
include/Nazara/Shader/Ast/AstUtils.hpp
View File

@ -39,7 +39,7 @@ namespace Nz::ShaderAst
void Visit(CallMethodExpression& node) override;
void Visit(CastExpression& node) override;
void Visit(ConditionalExpression& node) override;
void Visit(ConstantExpression& node) override;
void Visit(ConstantValueExpression& node) override;
void Visit(ConstantIndexExpression& node) override;
void Visit(IdentifierExpression& node) override;
void Visit(IntrinsicExpression& node) override;

2
include/Nazara/Shader/Ast/Nodes.hpp
View File

@ -140,7 +140,7 @@ namespace Nz::ShaderAst
ExpressionPtr truePath;
};
struct NAZARA_SHADER_API ConstantExpression : Expression
struct NAZARA_SHADER_API ConstantValueExpression : Expression
{
NodeType GetType() const override;
void Visit(AstExpressionVisitor& visitor) override;

2
include/Nazara/Shader/Ast/SanitizeVisitor.hpp
View File

@ -54,7 +54,7 @@ namespace Nz::ShaderAst
ExpressionPtr Clone(CallFunctionExpression& node) override;
ExpressionPtr Clone(CastExpression& node) override;
ExpressionPtr Clone(ConditionalExpression& node) override;
ExpressionPtr Clone(ConstantExpression& node) override;
ExpressionPtr Clone(ConstantValueExpression& node) override;
ExpressionPtr Clone(ConstantIndexExpression& node) override;
ExpressionPtr Clone(IdentifierExpression& node) override;
ExpressionPtr Clone(IntrinsicExpression& node) override;

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

@ -86,7 +86,7 @@ namespace Nz
void Visit(ShaderAst::BinaryExpression& node) override;
void Visit(ShaderAst::CallFunctionExpression& node) override;
void Visit(ShaderAst::CastExpression& node) override;
void Visit(ShaderAst::ConstantExpression& node) override;
void Visit(ShaderAst::ConstantValueExpression& node) override;
void Visit(ShaderAst::IntrinsicExpression& node) override;
void Visit(ShaderAst::SwizzleExpression& node) override;
void Visit(ShaderAst::VariableExpression& node) override;

2
include/Nazara/Shader/LangWriter.hpp
View File

@ -89,7 +89,7 @@ namespace Nz
void Visit(ShaderAst::BinaryExpression& node) override;
void Visit(ShaderAst::CastExpression& node) override;
void Visit(ShaderAst::ConditionalExpression& node) override;
void Visit(ShaderAst::ConstantExpression& node) override;
void Visit(ShaderAst::ConstantValueExpression& node) override;
void Visit(ShaderAst::ConstantIndexExpression& node) override;
void Visit(ShaderAst::IntrinsicExpression& node) override;
void Visit(ShaderAst::SwizzleExpression& node) override;

2
include/Nazara/Shader/ShaderBuilder.hpp
View File

@ -68,7 +68,7 @@ namespace Nz::ShaderBuilder
struct Constant
{
inline std::unique_ptr<ShaderAst::ConstantExpression> operator()(ShaderAst::ConstantValue value) const;
inline std::unique_ptr<ShaderAst::ConstantValueExpression> operator()(ShaderAst::ConstantValue value) const;
};
struct DeclareConst

4
include/Nazara/Shader/ShaderBuilder.inl
View File

@ -132,9 +132,9 @@ namespace Nz::ShaderBuilder
return condStatementNode;
}
inline std::unique_ptr<ShaderAst::ConstantExpression> Impl::Constant::operator()(ShaderAst::ConstantValue value) const
inline std::unique_ptr<ShaderAst::ConstantValueExpression> Impl::Constant::operator()(ShaderAst::ConstantValue value) const
{
auto constantNode = std::make_unique<ShaderAst::ConstantExpression>();
auto constantNode = std::make_unique<ShaderAst::ConstantValueExpression>();
constantNode->value = std::move(value);
return constantNode;

2
include/Nazara/Shader/SpirvAstVisitor.hpp
View File

@ -47,7 +47,7 @@ namespace Nz
void Visit(ShaderAst::BranchStatement& node) override;
void Visit(ShaderAst::CallFunctionExpression& node) override;
void Visit(ShaderAst::CastExpression& node) override;
void Visit(ShaderAst::ConstantExpression& node) override;
void Visit(ShaderAst::ConstantValueExpression& node) override;
void Visit(ShaderAst::DeclareConstStatement& node) override;
void Visit(ShaderAst::DeclareExternalStatement& node) override;
void Visit(ShaderAst::DeclareFunctionStatement& node) override;

4
src/Nazara/Shader/Ast/AstCloner.cpp
View File

@ -313,9 +313,9 @@ namespace Nz::ShaderAst
return clone;
}
ExpressionPtr AstCloner::Clone(ConstantExpression& node)
ExpressionPtr AstCloner::Clone(ConstantValueExpression& node)
{
auto clone = std::make_unique<ConstantExpression>();
auto clone = std::make_unique<ConstantValueExpression>();
clone->value = node.value;
clone->cachedExpressionType = node.cachedExpressionType;

80
src/Nazara/Shader/Ast/AstOptimizer.cpp
View File

@ -42,7 +42,7 @@ namespace Nz::ShaderAst
template<typename T1, typename T2>
struct BinaryCompEqBase
{
std::unique_ptr<ConstantExpression> operator()(const T1& lhs, const T2& rhs)
std::unique_ptr<ConstantValueExpression> operator()(const T1& lhs, const T2& rhs)
{
return ShaderBuilder::Constant(lhs == rhs);
}
@ -61,7 +61,7 @@ namespace Nz::ShaderAst
template<typename T1, typename T2>
struct BinaryCompGeBase
{
std::unique_ptr<ConstantExpression> operator()(const T1& lhs, const T2& rhs)
std::unique_ptr<ConstantValueExpression> operator()(const T1& lhs, const T2& rhs)
{
return ShaderBuilder::Constant(lhs >= rhs);
}
@ -80,7 +80,7 @@ namespace Nz::ShaderAst
template<typename T1, typename T2>
struct BinaryCompGtBase
{
std::unique_ptr<ConstantExpression> operator()(const T1& lhs, const T2& rhs)
std::unique_ptr<ConstantValueExpression> operator()(const T1& lhs, const T2& rhs)
{
return ShaderBuilder::Constant(lhs > rhs);
}
@ -99,7 +99,7 @@ namespace Nz::ShaderAst
template<typename T1, typename T2>
struct BinaryCompLeBase
{
std::unique_ptr<ConstantExpression> operator()(const T1& lhs, const T2& rhs)
std::unique_ptr<ConstantValueExpression> operator()(const T1& lhs, const T2& rhs)
{
return ShaderBuilder::Constant(lhs <= rhs);
}
@ -118,7 +118,7 @@ namespace Nz::ShaderAst
template<typename T1, typename T2>
struct BinaryCompLtBase
{
std::unique_ptr<ConstantExpression> operator()(const T1& lhs, const T2& rhs)
std::unique_ptr<ConstantValueExpression> operator()(const T1& lhs, const T2& rhs)
{
return ShaderBuilder::Constant(lhs < rhs);
}
@ -137,7 +137,7 @@ namespace Nz::ShaderAst
template<typename T1, typename T2>
struct BinaryCompNeBase
{
std::unique_ptr<ConstantExpression> operator()(const T1& lhs, const T2& rhs)
std::unique_ptr<ConstantValueExpression> operator()(const T1& lhs, const T2& rhs)
{
return ShaderBuilder::Constant(lhs != rhs);
}
@ -156,7 +156,7 @@ namespace Nz::ShaderAst
template<typename T1, typename T2>
struct BinaryLogicalAndBase
{
std::unique_ptr<ConstantExpression> operator()(const T1& lhs, const T2& rhs)
std::unique_ptr<ConstantValueExpression> operator()(const T1& lhs, const T2& rhs)
{
return ShaderBuilder::Constant(lhs && rhs);
}
@ -175,7 +175,7 @@ namespace Nz::ShaderAst
template<typename T1, typename T2>
struct BinaryLogicalOrBase
{
std::unique_ptr<ConstantExpression> operator()(const T1& lhs, const T2& rhs)
std::unique_ptr<ConstantValueExpression> operator()(const T1& lhs, const T2& rhs)
{
return ShaderBuilder::Constant(lhs || rhs);
}
@ -194,7 +194,7 @@ namespace Nz::ShaderAst
template<typename T1, typename T2>
struct BinaryAdditionBase
{
std::unique_ptr<ConstantExpression> operator()(const T1& lhs, const T2& rhs)
std::unique_ptr<ConstantValueExpression> operator()(const T1& lhs, const T2& rhs)
{
return ShaderBuilder::Constant(lhs + rhs);
}
@ -213,7 +213,7 @@ namespace Nz::ShaderAst
template<typename T1, typename T2>
struct BinaryDivisionBase
{
std::unique_ptr<ConstantExpression> operator()(const T1& lhs, const T2& rhs)
std::unique_ptr<ConstantValueExpression> operator()(const T1& lhs, const T2& rhs)
{
return ShaderBuilder::Constant(lhs / rhs);
}
@ -232,7 +232,7 @@ namespace Nz::ShaderAst
template<typename T1, typename T2>
struct BinaryMultiplicationBase
{
std::unique_ptr<ConstantExpression> operator()(const T1& lhs, const T2& rhs)
std::unique_ptr<ConstantValueExpression> operator()(const T1& lhs, const T2& rhs)
{
return ShaderBuilder::Constant(lhs * rhs);
}
@ -251,7 +251,7 @@ namespace Nz::ShaderAst
template<typename T1, typename T2>
struct BinarySubtractionBase
{
std::unique_ptr<ConstantExpression> operator()(const T1& lhs, const T2& rhs)
std::unique_ptr<ConstantValueExpression> operator()(const T1& lhs, const T2& rhs)
{
return ShaderBuilder::Constant(lhs - rhs);
}
@ -271,7 +271,7 @@ namespace Nz::ShaderAst
template<typename T, typename... Args>
struct CastConstantBase
{
std::unique_ptr<ConstantExpression> operator()(const Args&... args)
std::unique_ptr<ConstantValueExpression> operator()(const Args&... args)
{
return ShaderBuilder::Constant(T(args...));
}
@ -295,7 +295,7 @@ namespace Nz::ShaderAst
template<typename T>
struct UnaryLogicalNotBase
{
std::unique_ptr<ConstantExpression> operator()(const T& arg)
std::unique_ptr<ConstantValueExpression> operator()(const T& arg)
{
return ShaderBuilder::Constant(!arg);
}
@ -314,7 +314,7 @@ namespace Nz::ShaderAst
template<typename T>
struct UnaryMinusBase
{
std::unique_ptr<ConstantExpression> operator()(const T& arg)
std::unique_ptr<ConstantValueExpression> operator()(const T& arg)
{
return ShaderBuilder::Constant(-arg);
}
@ -333,7 +333,7 @@ namespace Nz::ShaderAst
template<typename T>
struct UnaryPlusBase
{
std::unique_ptr<ConstantExpression> operator()(const T& arg)
std::unique_ptr<ConstantValueExpression> operator()(const T& arg)
{
return ShaderBuilder::Constant(arg);
}
@ -573,10 +573,10 @@ namespace Nz::ShaderAst
auto lhs = CloneExpression(node.left);
auto rhs = CloneExpression(node.right);
if (lhs->GetType() == NodeType::ConstantExpression && rhs->GetType() == NodeType::ConstantExpression)
if (lhs->GetType() == NodeType::ConstantValueExpression && rhs->GetType() == NodeType::ConstantValueExpression)
{
auto lhsConstant = static_unique_pointer_cast<ConstantExpression>(std::move(lhs));
auto rhsConstant = static_unique_pointer_cast<ConstantExpression>(std::move(rhs));
auto lhsConstant = static_unique_pointer_cast<ConstantValueExpression>(std::move(lhs));
auto rhsConstant = static_unique_pointer_cast<ConstantValueExpression>(std::move(rhs));
ExpressionPtr optimized;
switch (node.op)
@ -657,9 +657,9 @@ namespace Nz::ShaderAst
ExpressionPtr optimized;
if (IsPrimitiveType(node.targetType))
{
if (expressionCount == 1 && expressions.front()->GetType() == NodeType::ConstantExpression)
if (expressionCount == 1 && expressions.front()->GetType() == NodeType::ConstantValueExpression)
{
auto constantExpr = static_unique_pointer_cast<ConstantExpression>(std::move(expressions.front()));
auto constantExpr = static_unique_pointer_cast<ConstantValueExpression>(std::move(expressions.front()));
switch (std::get<PrimitiveType>(node.targetType))
{
@ -678,13 +678,13 @@ namespace Nz::ShaderAst
std::vector<ConstantValue> constantValues;
for (std::size_t i = 0; i < expressionCount; ++i)
{
if (expressions[i]->GetType() != NodeType::ConstantExpression)
if (expressions[i]->GetType() != NodeType::ConstantValueExpression)
{
constantValues.clear();
break;
}
const auto& constantExpr = static_cast<ConstantExpression&>(*expressions[i]);
const auto& constantExpr = static_cast<ConstantValueExpression&>(*expressions[i]);
if (!constantValues.empty() && GetExpressionType(constantValues.front()) != GetExpressionType(constantExpr.value))
{
@ -766,9 +766,9 @@ namespace Nz::ShaderAst
{
auto cond = CloneExpression(condStatement.condition);
if (cond->GetType() == NodeType::ConstantExpression)
if (cond->GetType() == NodeType::ConstantValueExpression)
{
auto& constant = static_cast<ConstantExpression&>(*cond);
auto& constant = static_cast<ConstantValueExpression&>(*cond);
assert(constant.cachedExpressionType);
const ExpressionType& constantType = constant.cachedExpressionType.value();
@ -821,10 +821,10 @@ namespace Nz::ShaderAst
return AstCloner::Clone(node);
auto cond = CloneExpression(node.condition);
if (cond->GetType() != NodeType::ConstantExpression)
if (cond->GetType() != NodeType::ConstantValueExpression)
throw std::runtime_error("conditional expression condition must be a constant expression");
auto& constant = static_cast<ConstantExpression&>(*cond);
auto& constant = static_cast<ConstantValueExpression&>(*cond);
assert(constant.cachedExpressionType);
const ExpressionType& constantType = constant.cachedExpressionType.value();
@ -854,9 +854,9 @@ namespace Nz::ShaderAst
{
auto expr = CloneExpression(node.expression);
if (expr->GetType() == NodeType::ConstantExpression)
if (expr->GetType() == NodeType::ConstantValueExpression)
{
auto constantExpr = static_unique_pointer_cast<ConstantExpression>(std::move(expr));
auto constantExpr = static_unique_pointer_cast<ConstantValueExpression>(std::move(expr));
ExpressionPtr optimized;
switch (node.op)
@ -890,10 +890,10 @@ namespace Nz::ShaderAst
return AstCloner::Clone(node);
auto cond = CloneExpression(node.condition);
if (cond->GetType() != NodeType::ConstantExpression)
if (cond->GetType() != NodeType::ConstantValueExpression)
throw std::runtime_error("conditional expression condition must be a constant expression");
auto& constant = static_cast<ConstantExpression&>(*cond);
auto& constant = static_cast<ConstantValueExpression&>(*cond);
assert(constant.cachedExpressionType);
const ExpressionType& constantType = constant.cachedExpressionType.value();
@ -909,9 +909,9 @@ namespace Nz::ShaderAst
}
template<BinaryType Type>
ExpressionPtr AstOptimizer::PropagateBinaryConstant(std::unique_ptr<ConstantExpression>&& lhs, std::unique_ptr<ConstantExpression>&& rhs)
ExpressionPtr AstOptimizer::PropagateBinaryConstant(std::unique_ptr<ConstantValueExpression>&& lhs, std::unique_ptr<ConstantValueExpression>&& rhs)
{
std::unique_ptr<ConstantExpression> optimized;
std::unique_ptr<ConstantValueExpression> optimized;
std::visit([&](auto&& arg1)
{
using T1 = std::decay_t<decltype(arg1)>;
@ -938,9 +938,9 @@ namespace Nz::ShaderAst
}
template<typename TargetType>
ExpressionPtr AstOptimizer::PropagateSingleValueCast(std::unique_ptr<ConstantExpression>&& operand)
ExpressionPtr AstOptimizer::PropagateSingleValueCast(std::unique_ptr<ConstantValueExpression>&& operand)
{
std::unique_ptr<ConstantExpression> optimized;
std::unique_ptr<ConstantValueExpression> optimized;
std::visit([&](auto&& arg)
{
@ -959,9 +959,9 @@ namespace Nz::ShaderAst
}
template<UnaryType Type>
ExpressionPtr AstOptimizer::PropagateUnaryConstant(std::unique_ptr<ConstantExpression>&& operand)
ExpressionPtr AstOptimizer::PropagateUnaryConstant(std::unique_ptr<ConstantValueExpression>&& operand)
{
std::unique_ptr<ConstantExpression> optimized;
std::unique_ptr<ConstantValueExpression> optimized;
std::visit([&](auto&& arg)
{
using T = std::decay_t<decltype(arg)>;
@ -984,7 +984,7 @@ namespace Nz::ShaderAst
template<typename TargetType>
ExpressionPtr AstOptimizer::PropagateVec2Cast(TargetType v1, TargetType v2)
{
std::unique_ptr<ConstantExpression> optimized;
std::unique_ptr<ConstantValueExpression> optimized;
using CCType = CastConstantPropagation<Vector2<TargetType>, TargetType, TargetType>;
@ -1001,7 +1001,7 @@ namespace Nz::ShaderAst
template<typename TargetType>
ExpressionPtr AstOptimizer::PropagateVec3Cast(TargetType v1, TargetType v2, TargetType v3)
{
std::unique_ptr<ConstantExpression> optimized;
std::unique_ptr<ConstantValueExpression> optimized;
using CCType = CastConstantPropagation<Vector3<TargetType>, TargetType, TargetType, TargetType>;
@ -1018,7 +1018,7 @@ namespace Nz::ShaderAst
template<typename TargetType>
ExpressionPtr AstOptimizer::PropagateVec4Cast(TargetType v1, TargetType v2, TargetType v3, TargetType v4)
{
std::unique_ptr<ConstantExpression> optimized;
std::unique_ptr<ConstantValueExpression> optimized;
using CCType = CastConstantPropagation<Vector3<TargetType>, TargetType, TargetType, TargetType, TargetType>;

2
src/Nazara/Shader/Ast/AstRecursiveVisitor.cpp
View File

@ -62,7 +62,7 @@ namespace Nz::ShaderAst
node.falsePath->Visit(*this);
}
void AstRecursiveVisitor::Visit(ConstantExpression& /*node*/)
void AstRecursiveVisitor::Visit(ConstantValueExpression& /*node*/)
{
/* Nothing to do */
}

2
src/Nazara/Shader/Ast/AstSerializer.cpp
View File

@ -123,7 +123,7 @@ namespace Nz::ShaderAst
Node(node.falsePath);
}
void AstSerializerBase::Serialize(ConstantExpression& node)
void AstSerializerBase::Serialize(ConstantValueExpression& node)
{
UInt32 typeIndex;
if (IsWriting())

2
src/Nazara/Shader/Ast/AstUtils.cpp
View File

@ -62,7 +62,7 @@ namespace Nz::ShaderAst
m_expressionCategory = ExpressionCategory::LValue;
}
void ShaderAstValueCategory::Visit(ConstantExpression& /*node*/)
void ShaderAstValueCategory::Visit(ConstantValueExpression& /*node*/)
{
m_expressionCategory = ExpressionCategory::RValue;
}

16
src/Nazara/Shader/Ast/SanitizeVisitor.cpp
View File

@ -569,9 +569,9 @@ namespace Nz::ShaderAst
return AstCloner::Clone(*node.falsePath);
}
ExpressionPtr SanitizeVisitor::Clone(ConstantExpression& node)
ExpressionPtr SanitizeVisitor::Clone(ConstantValueExpression& node)
{
auto clone = static_unique_pointer_cast<ConstantExpression>(AstCloner::Clone(node));
auto clone = static_unique_pointer_cast<ConstantValueExpression>(AstCloner::Clone(node));
clone->cachedExpressionType = GetExpressionType(clone->value);
return clone;
@ -792,10 +792,10 @@ namespace Nz::ShaderAst
throw AstError{ "const variables must have an expression" };
clone->expression = Optimize(*clone->expression);
if (clone->expression->GetType() != NodeType::ConstantExpression)
if (clone->expression->GetType() != NodeType::ConstantValueExpression)
throw AstError{ "const variable must have constant expressions " };
const ConstantValue& value = static_cast<ConstantExpression&>(*clone->expression).value;
const ConstantValue& value = static_cast<ConstantValueExpression&>(*clone->expression).value;
ExpressionType expressionType = ResolveType(GetExpressionType(value));
@ -1158,10 +1158,10 @@ namespace Nz::ShaderAst
{
// Run optimizer on constant value to hopefully retrieve a single constant value
ExpressionPtr optimizedExpr = Optimize(expr);
if (optimizedExpr->GetType() != NodeType::ConstantExpression)
if (optimizedExpr->GetType() != NodeType::ConstantValueExpression)
throw AstError{"expected a constant expression"};
return static_cast<ConstantExpression&>(*optimizedExpr).value;
return static_cast<ConstantValueExpression&>(*optimizedExpr).value;
}
template<typename T>
@ -1447,10 +1447,10 @@ namespace Nz::ShaderAst
auto& indexExpr = node.indices[i];
const ShaderAst::ExpressionType& indexType = GetExpressionType(*indexExpr);
if (indexExpr->GetType() != NodeType::ConstantExpression || indexType != ExpressionType{ PrimitiveType::Int32 })
if (indexExpr->GetType() != NodeType::ConstantValueExpression || indexType != ExpressionType{ PrimitiveType::Int32 })
throw AstError{ "struct can only be accessed with constant i32 indices" };
ConstantExpression& constantExpr = static_cast<ConstantExpression&>(*indexExpr);
ConstantValueExpression& constantExpr = static_cast<ConstantValueExpression&>(*indexExpr);
Int32 index = std::get<Int32>(constantExpr.value);

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

@ -387,8 +387,8 @@ namespace Nz
{
ShaderAst::StructDescription* structDesc = Retrieve(m_currentState->structs, structIndex);
assert((*memberIndices)->GetType() == ShaderAst::NodeType::ConstantExpression);
auto& constantValue = static_cast<ShaderAst::ConstantExpression&>(**memberIndices);
assert((*memberIndices)->GetType() == ShaderAst::NodeType::ConstantValueExpression);
auto& constantValue = static_cast<ShaderAst::ConstantValueExpression&>(**memberIndices);
Int32 index = std::get<Int32>(constantValue.value);
assert(index >= 0);
@ -828,7 +828,7 @@ namespace Nz
Append(")");
}
void GlslWriter::Visit(ShaderAst::ConstantExpression& node)
void GlslWriter::Visit(ShaderAst::ConstantValueExpression& node)
{
std::visit([&](auto&& arg)
{

6
src/Nazara/Shader/LangWriter.cpp
View File

@ -418,8 +418,8 @@ namespace Nz
{
ShaderAst::StructDescription* structDesc = Retrieve(m_currentState->structs, structIndex);
assert((*memberIndices)->GetType() == ShaderAst::NodeType::ConstantExpression);
auto& constantValue = static_cast<ShaderAst::ConstantExpression&>(**memberIndices);
assert((*memberIndices)->GetType() == ShaderAst::NodeType::ConstantValueExpression);
auto& constantValue = static_cast<ShaderAst::ConstantValueExpression&>(**memberIndices);
Int32 index = std::get<Int32>(constantValue.value);
const auto& member = structDesc->members[index];
@ -637,7 +637,7 @@ namespace Nz
node.statement->Visit(*this);
}
void LangWriter::Visit(ShaderAst::ConstantExpression& node)
void LangWriter::Visit(ShaderAst::ConstantValueExpression& node)
{
std::visit([&](auto&& arg)
{

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

@ -576,7 +576,7 @@ namespace Nz
}
}
void SpirvAstVisitor::Visit(ShaderAst::ConstantExpression& node)
void SpirvAstVisitor::Visit(ShaderAst::ConstantValueExpression& node)
{
std::visit([&] (const auto& value)
{

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

@ -113,7 +113,7 @@ namespace Nz
throw std::runtime_error("unexpected conditional expression, did you forget to sanitize the shader?");
}
void Visit(ShaderAst::ConstantExpression& node) override
void Visit(ShaderAst::ConstantValueExpression& node) override
{
std::visit([&](auto&& arg)
{