Type constants can now be used in constant expressions

Author: SirLynix

include/NZSL/Ast/Transformations/ConstantPropagationTransformer.hpp

@@ -49,6 +49,7 @@ namespace nzsl::Ast
 			ExpressionTransformation Transform(ConstantExpression&& node) override;
 			ExpressionTransformation Transform(IntrinsicExpression&& node) override;
 			ExpressionTransformation Transform(SwizzleExpression&& node) override;
+			ExpressionTransformation Transform(TypeConstantExpression&& node) override;
 			ExpressionTransformation Transform(UnaryExpression&& node) override;
 
 			StatementTransformation Transform(BranchStatement&& node) override;

include/NZSL/Ast/Utils.hpp

@@ -63,6 +63,7 @@ namespace nzsl::Ast
 	NZSL_API std::optional<ExpressionType> ComputeExpressionType(const SwizzleExpression& swizzleExpr, const Stringifier& typeStringifier);
 	NZSL_API std::optional<ExpressionType> ComputeExpressionType(const UnaryExpression& unaryExpr, const Stringifier& typeStringifier);
 	NZSL_API ExpressionType ComputeSwizzleType(const ExpressionType& type, std::size_t componentCount, const SourceLocation& sourceLocation);
+	NZSL_API ConstantSingleValue ComputeTypeConstant(const ExpressionType& expressionType, TypeConstant typeConstant);
 
 	NZSL_API float LiteralToFloat32(FloatLiteral literal, const SourceLocation& sourceLocation);
 	NZSL_API double LiteralToFloat64(FloatLiteral literal, const SourceLocation& sourceLocation);

src/NZSL/Ast/Transformations/ConstantPropagationTransformer.cpp

@@ -704,6 +704,11 @@ namespace nzsl::Ast
 		return DontVisitChildren{};
 	}
 
+	auto ConstantPropagationTransformer::Transform(TypeConstantExpression&& node) -> ExpressionTransformation
+	{
+		return ReplaceExpression{ ShaderBuilder::ConstantValue(ComputeTypeConstant(node.type, node.typeConstant)) };
+	}
+
 	auto ConstantPropagationTransformer::Transform(UnaryExpression&& node) -> ExpressionTransformation
 	{
 		HandleExpression(node.expression);

src/NZSL/Ast/Utils.cpp

@@ -413,6 +413,56 @@ namespace nzsl::Ast
 			return baseType;
 	}
 
+	ConstantSingleValue ComputeTypeConstant(const ExpressionType& expressionType, TypeConstant typeConstant)
+	{
+		NazaraAssert(IsPrimitiveType(expressionType));
+		PrimitiveType primitiveType = std::get<PrimitiveType>(expressionType);
+
+		auto ReplaceByValue = [&](auto&& type) -> ConstantSingleValue
+		{
+			using T = std::decay_t<decltype(type)>;
+
+			if (typeConstant == TypeConstant::Max)
+				return Nz::MaxValue<T>();
+
+			if (typeConstant == TypeConstant::Min)
+				return std::numeric_limits<T>::lowest(); //< Nz::MinValue is implemented by std::numeric_limits<T>::min() which doesn't give the value we want
+
+			if constexpr (std::is_floating_point_v<T>)
+			{
+				if (typeConstant == TypeConstant::Epsilon)
+					return std::numeric_limits<T>::epsilon();
+
+				if (typeConstant == TypeConstant::Infinity)
+					return Nz::Infinity<T>();
+
+				if (typeConstant == TypeConstant::MinPositive)
+					return std::numeric_limits<T>::min();
+
+				if (typeConstant == TypeConstant::NaN)
+					return Nz::NaN<T>();
+			}
+
+			throw std::runtime_error("unexpected type constant with type");
+		};
+
+		switch (primitiveType)
+		{
+			case PrimitiveType::Float32: return ReplaceByValue(float{});
+			case PrimitiveType::Float64: return ReplaceByValue(double{});
+			case PrimitiveType::Int32:   return ReplaceByValue(std::int32_t{});
+			case PrimitiveType::UInt32:  return ReplaceByValue(std::uint32_t{});
+
+			case PrimitiveType::Boolean:
+			case PrimitiveType::FloatLiteral:
+			case PrimitiveType::IntLiteral:
+			case PrimitiveType::String:
+				break;
+		}
+
+		throw std::runtime_error("unexpected primitive type");
+	}
+
 	float LiteralToFloat32(FloatLiteral literal, const SourceLocation& /*sourceLocation*/)
 	{
 		return static_cast<float>(literal);

tests/src/Tests/ConstantTests.cpp

@@ -14,6 +14,26 @@ TEST_CASE("constant", "[Shader]")
 [feature(float64)]
 module;
 
+const f32Eps = f32.Epsilon;
+const f32Max = f32.Max;
+const f32Min = f32.Min;
+const f32MinPos = f32.MinPositive;
+const f32Inf = f32.Infinity;
+const f32NaN = f32.NaN;
+
+const f64Eps = f64.Epsilon;
+const f64Max = f64.Max;
+const f64Min = f64.Min;
+const f64MinPos = f64.MinPositive;
+const f64Inf = f64.Infinity;
+const f64NaN = f64.NaN;
+
+const i32Max = i32.Max;
+const i32Min = i32.Min;
+
+const u32Max = u32.Max;
+const u32Min = u32.Min;
+
 [entry(frag)]
 fn main()
 {
@@ -72,6 +92,38 @@ void main()
 )", {}, glslEnv);
 
 		ExpectNZSL(*shaderModule, R"(
+const f32Eps: f32 = f32.Epsilon;
+
+const f32Max: f32 = f32.Max;
+
+const f32Min: f32 = f32.Min;
+
+const f32MinPos: f32 = f32.MinPositive;
+
+const f32Inf: f32 = f32.Infinity;
+
+const f32NaN: f32 = f32.NaN;
+
+const f64Eps: f64 = f64.Epsilon;
+
+const f64Max: f64 = f64.Max;
+
+const f64Min: f64 = f64.Min;
+
+const f64MinPos: f64 = f64.MinPositive;
+
+const f64Inf: f64 = f64.Infinity;
+
+const f64NaN: f64 = f64.NaN;
+
+const i32Max: i32 = i32.Max;
+
+const i32Min: i32 = i32.Min;
+
+const u32Max: u32 = u32.Max;
+
+const u32Min: u32 = u32.Min;
+
 [entry(frag)]
 fn main()
 {