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

Shader: Rename ConstantExpression to ConstantValueExpression

Browse Source
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
Download Patch File Download Diff File Expand all files Collapse all files

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);