Shader: Replace select_opt by const_select

bin/resources/deferred_frag.nzsl

@@ -56,15 +56,23 @@ struct OutputData
 [entry(frag)]
 fn main(input: InputData) -> OutputData
 {
-	let textureColor = select_opt(HAS_DIFFUSE_TEXTURE, MaterialDiffuseMap.Sample(input.vertUV) * settings.DiffuseColor, settings.DiffuseColor);
+	let diffuseColor = settings.DiffuseColor;
-	let alpha = select_opt(HAS_ALPHA_TEXTURE, MaterialAlphaMap.Sample(input.vertUV).x * textureColor.w, 1.0);
+	const if (HAS_DIFFUSE_TEXTURE)
-	/*if ((select_opt(ALPHA_TEST, var0.w < settings.AlphaThreshold, false)) == (true))
+		// TODO: diffuseColor *= MaterialDiffuseMap.Sample(input.uv)
+		diffuseColor = diffuseColor * MaterialDiffuseMap.Sample(input.uv);
+
+	const if (HAS_ALPHA_TEXTURE)
+		// TODO: diffuseColor.w *= MaterialAlphaMap.Sample(input.uv)).x
+		diffuseColor = vec4<f32>(diffuseColor.x, diffuseColor.y, diffuseColor.z, (MaterialAlphaMap.Sample(input.uv)).x * diffuseColor.w);
+
+	const if (ALPHA_TEST)
 	{
+		if (diffuseColor.w < settings.AlphaThreshold)
 			discard;
-	}*/
+	}
 
 	let output: OutputData;
-	output.diffuseMap = textureColor;
+	output.diffuseMap = diffuseColor;
 	output.normalMap = vec4<f32>((vec3<f32>(1.0, 1.0, 1.0) + input.vertNormal) * 0.5, 1.0);
 	output.positionMap = vec4<f32>(input.vertPos, 1.0);
 	return output;

examples/RenderTest/main.cpp

@@ -58,7 +58,7 @@ fn main(fragIn: VertOut) -> FragOut
 	let lightFactor = dot(fragIn.normal, lightDir);
 
 	let fragOut: FragOut;
-	fragOut.color = lightFactor * tex.Sample(fragIn.uv) * select_opt(red, vec4<f32>(1.0, 0.0, 0.0, 1.0), vec4<f32>(1.0, 1.0, 1.0, 1.0));
+	fragOut.color = lightFactor * tex.Sample(fragIn.uv) * const_select(red, vec4<f32>(1.0, 0.0, 0.0, 1.0), vec4<f32>(1.0, 1.0, 1.0, 1.0));
 
 	return fragOut;
 }

include/Nazara/Shader/Ast/AstCloner.hpp

@@ -50,7 +50,6 @@ namespace Nz::ShaderAst
 			virtual ExpressionPtr Clone(ConstantExpression& node);
 			virtual ExpressionPtr Clone(IdentifierExpression& node);
 			virtual ExpressionPtr Clone(IntrinsicExpression& node);
-			virtual ExpressionPtr Clone(SelectOptionExpression& node);
 			virtual ExpressionPtr Clone(SwizzleExpression& node);
 			virtual ExpressionPtr Clone(VariableExpression& node);
 			virtual ExpressionPtr Clone(UnaryExpression& node);

include/Nazara/Shader/Ast/AstNodeList.hpp

@@ -38,7 +38,6 @@ NAZARA_SHADERAST_EXPRESSION(ConstantExpression)
 NAZARA_SHADERAST_EXPRESSION(ConstantIndexExpression)
 NAZARA_SHADERAST_EXPRESSION(IdentifierExpression)
 NAZARA_SHADERAST_EXPRESSION(IntrinsicExpression)
-NAZARA_SHADERAST_EXPRESSION(SelectOptionExpression)
 NAZARA_SHADERAST_EXPRESSION(SwizzleExpression)
 NAZARA_SHADERAST_EXPRESSION(VariableExpression)
 NAZARA_SHADERAST_EXPRESSION(UnaryExpression)

include/Nazara/Shader/Ast/AstRecursiveVisitor.hpp

@@ -32,7 +32,6 @@ namespace Nz::ShaderAst
 			void Visit(ConstantIndexExpression& node) override;
 			void Visit(IdentifierExpression& node) override;
 			void Visit(IntrinsicExpression& node) override;
-			void Visit(SelectOptionExpression& node) override;
 			void Visit(SwizzleExpression& node) override;
 			void Visit(VariableExpression& node) override;
 			void Visit(UnaryExpression& node) override;

include/Nazara/Shader/Ast/AstSerializer.hpp

@@ -35,7 +35,6 @@ namespace Nz::ShaderAst
 			void Serialize(ConstantExpression& node);
 			void Serialize(IdentifierExpression& node);
 			void Serialize(IntrinsicExpression& node);
-			void Serialize(SelectOptionExpression& node);
 			void Serialize(SwizzleExpression& node);
 			void Serialize(VariableExpression& node);
 			void Serialize(UnaryExpression& node);

include/Nazara/Shader/Ast/AstUtils.hpp

@@ -43,7 +43,6 @@ namespace Nz::ShaderAst
 			void Visit(ConstantIndexExpression& node) override;
 			void Visit(IdentifierExpression& node) override;
 			void Visit(IntrinsicExpression& node) override;
-			void Visit(SelectOptionExpression& node) override;
 			void Visit(SwizzleExpression& node) override;
 			void Visit(VariableExpression& node) override;
 			void Visit(UnaryExpression& node) override;

include/Nazara/Shader/Ast/Nodes.hpp

@@ -173,16 +173,6 @@ namespace Nz::ShaderAst
 		std::vector<ExpressionPtr> parameters;
 	};
 
-	struct NAZARA_SHADER_API SelectOptionExpression : Expression
-	{
-		NodeType GetType() const override;
-		void Visit(AstExpressionVisitor& visitor) override;
-
-		std::string optionName;
-		ExpressionPtr falsePath;
-		ExpressionPtr truePath;
-	};
-
 	struct NAZARA_SHADER_API SwizzleExpression : Expression
 	{
 		NodeType GetType() const override;

include/Nazara/Shader/Ast/SanitizeVisitor.hpp

@@ -58,7 +58,6 @@ namespace Nz::ShaderAst
 			ExpressionPtr Clone(ConstantIndexExpression& node) override;
 			ExpressionPtr Clone(IdentifierExpression& node) override;
 			ExpressionPtr Clone(IntrinsicExpression& node) override;
-			ExpressionPtr Clone(SelectOptionExpression& node) override;
 			ExpressionPtr Clone(SwizzleExpression& node) override;
 			ExpressionPtr Clone(UnaryExpression& node) override;
 			ExpressionPtr Clone(VariableExpression& node) override;

include/Nazara/Shader/ShaderBuilder.hpp

@@ -131,11 +131,6 @@ namespace Nz::ShaderBuilder
 			inline std::unique_ptr<ShaderAst::ReturnStatement> operator()(ShaderAst::ExpressionPtr expr = nullptr) const;
 		};
 
-		struct SelectOption
-		{
-			inline std::unique_ptr<ShaderAst::SelectOptionExpression> operator()(std::string optionName, ShaderAst::ExpressionPtr truePath, ShaderAst::ExpressionPtr falsePath) const;
-		};
-
 		struct Swizzle
 		{
 			inline std::unique_ptr<ShaderAst::SwizzleExpression> operator()(ShaderAst::ExpressionPtr expression, std::vector<ShaderAst::SwizzleComponent> swizzleComponents) const;
@@ -170,7 +165,6 @@ namespace Nz::ShaderBuilder
 	constexpr Impl::Multi MultiStatement;
 	constexpr Impl::NoParam<ShaderAst::NoOpStatement> NoOp;
 	constexpr Impl::Return Return;
-	constexpr Impl::SelectOption SelectOption;
 	constexpr Impl::Swizzle Swizzle;
 	constexpr Impl::Unary Unary;
 }

include/Nazara/Shader/ShaderBuilder.inl

@@ -277,16 +277,6 @@ namespace Nz::ShaderBuilder
 		return returnNode;
 	}
 
-	inline std::unique_ptr<ShaderAst::SelectOptionExpression> Impl::SelectOption::operator()(std::string optionName, ShaderAst::ExpressionPtr truePath, ShaderAst::ExpressionPtr falsePath) const
-	{
-		auto selectOptNode = std::make_unique<ShaderAst::SelectOptionExpression>();
-		selectOptNode->optionName = std::move(optionName);
-		selectOptNode->falsePath = std::move(falsePath);
-		selectOptNode->truePath = std::move(truePath);
-
-		return selectOptNode;
-	}
-
 	inline std::unique_ptr<ShaderAst::SwizzleExpression> Impl::Swizzle::operator()(ShaderAst::ExpressionPtr expression, std::vector<ShaderAst::SwizzleComponent> swizzleComponents) const
 	{
 		auto swizzleNode = std::make_unique<ShaderAst::SwizzleExpression>();

include/Nazara/Shader/ShaderLangParser.hpp

@@ -101,6 +101,7 @@ namespace Nz::ShaderLang
 
 			// Expressions
 			ShaderAst::ExpressionPtr ParseBinOpRhs(int exprPrecedence, ShaderAst::ExpressionPtr lhs);
+			ShaderAst::ExpressionPtr ParseConstSelectExpression();
 			ShaderAst::ExpressionPtr ParseExpression();
 			ShaderAst::ExpressionPtr ParseFloatingPointExpression();
 			ShaderAst::ExpressionPtr ParseIdentifier();
@@ -108,7 +109,6 @@ namespace Nz::ShaderLang
 			std::vector<ShaderAst::ExpressionPtr> ParseParameters();
 			ShaderAst::ExpressionPtr ParseParenthesisExpression();
 			ShaderAst::ExpressionPtr ParsePrimaryExpression();
-			ShaderAst::ExpressionPtr ParseSelectOptExpression();
 			ShaderAst::ExpressionPtr ParseVariableAssignation();
 
 			ShaderAst::AttributeType ParseIdentifierAsAttributeType();

include/Nazara/Shader/ShaderLangTokenList.hpp

@@ -19,6 +19,7 @@ NAZARA_SHADERLANG_TOKEN(ClosingSquareBracket)
 NAZARA_SHADERLANG_TOKEN(Colon)
 NAZARA_SHADERLANG_TOKEN(Comma)
 NAZARA_SHADERLANG_TOKEN(Const)
+NAZARA_SHADERLANG_TOKEN(ConstSelect)
 NAZARA_SHADERLANG_TOKEN(Discard)
 NAZARA_SHADERLANG_TOKEN(Divide)
 NAZARA_SHADERLANG_TOKEN(Dot)
@@ -49,7 +50,6 @@ NAZARA_SHADERLANG_TOKEN(OpenParenthesis)
 NAZARA_SHADERLANG_TOKEN(Option)
 NAZARA_SHADERLANG_TOKEN(Semicolon)
 NAZARA_SHADERLANG_TOKEN(Return)
-NAZARA_SHADERLANG_TOKEN(SelectOpt)
 NAZARA_SHADERLANG_TOKEN(Struct)
 
 #undef NAZARA_SHADERLANG_TOKEN

src/Nazara/Graphics/Resources/Shaders/basicmaterial.nzsl

@@ -55,13 +55,22 @@ struct FragOut
 [entry(frag)]
 fn main(input: FragIn) -> FragOut
 {
-	let output: FragOut;
+	let diffuseColor = settings.DiffuseColor;
-	let diffuseColor = select_opt(HAS_DIFFUSE_TEXTURE, MaterialDiffuseMap.Sample(input.uv) * settings.DiffuseColor, settings.DiffuseColor);
+	const if (HAS_DIFFUSE_TEXTURE)
-	let diffuseColor = select_opt(HAS_ALPHA_TEXTURE, vec4<f32>(diffuseColor.x, diffuseColor.y, diffuseColor.z, ((MaterialAlphaMap.Sample(input.uv)).x) * diffuseColor.w), diffuseColor);
+		// TODO: diffuseColor *= MaterialDiffuseMap.Sample(input.uv)
+		diffuseColor = diffuseColor * MaterialDiffuseMap.Sample(input.uv);
 
-	if (select_opt(ALPHA_TEST, diffuseColor.w < settings.AlphaThreshold, false))
+	const if (HAS_ALPHA_TEXTURE)
+		// TODO: diffuseColor.w *= MaterialAlphaMap.Sample(input.uv)).x
+		diffuseColor = vec4<f32>(diffuseColor.x, diffuseColor.y, diffuseColor.z, ((MaterialAlphaMap.Sample(input.uv)).x) * diffuseColor.w);
+
+	const if (ALPHA_TEST)
+	{
+		if (diffuseColor.w < settings.AlphaThreshold)
 			discard;
+	}
 
+	let output: FragOut;
 	output.RenderTarget0 = diffuseColor;
 	return output;
 }

src/Nazara/Shader/Ast/AstCloner.cpp

@@ -347,18 +347,6 @@ namespace Nz::ShaderAst
 		return clone;
 	}
 
-	ExpressionPtr AstCloner::Clone(SelectOptionExpression& node)
-	{
-		auto clone = std::make_unique<SelectOptionExpression>();
-		clone->optionName = node.optionName;
-		clone->falsePath = CloneExpression(node.falsePath);
-		clone->truePath = CloneExpression(node.truePath);
-
-		clone->cachedExpressionType = node.cachedExpressionType;
-
-		return clone;
-	}
-
 	ExpressionPtr AstCloner::Clone(SwizzleExpression& node)
 	{
 		auto clone = std::make_unique<SwizzleExpression>();

src/Nazara/Shader/Ast/AstRecursiveVisitor.cpp

@@ -83,12 +83,6 @@ namespace Nz::ShaderAst
 			param->Visit(*this);
 	}
 
-	void AstRecursiveVisitor::Visit(SelectOptionExpression& node)
-	{
-		node.truePath->Visit(*this);
-		node.falsePath->Visit(*this);
-	}
-
 	void AstRecursiveVisitor::Visit(SwizzleExpression& node)
 	{
 		node.expression->Visit(*this);

src/Nazara/Shader/Ast/AstSerializer.cpp

@@ -170,13 +170,6 @@ namespace Nz::ShaderAst
 			Node(param);
 	}
 
-	void AstSerializerBase::Serialize(SelectOptionExpression& node)
-	{
-		Value(node.optionName);
-		Node(node.truePath);
-		Node(node.falsePath);
-	}
-
 	void AstSerializerBase::Serialize(SwizzleExpression& node)
 	{
 		SizeT(node.componentCount);

src/Nazara/Shader/Ast/AstUtils.cpp

@@ -82,20 +82,6 @@ namespace Nz::ShaderAst
 		m_expressionCategory = ExpressionCategory::RValue;
 	}
 
-	void ShaderAstValueCategory::Visit(SelectOptionExpression& node)
-	{
-		node.truePath->Visit(*this);
-		ExpressionCategory trueExprCategory = m_expressionCategory;
-
-		node.falsePath->Visit(*this);
-		ExpressionCategory falseExprCategory = m_expressionCategory;
-
-		if (trueExprCategory == ExpressionCategory::RValue || falseExprCategory == ExpressionCategory::RValue)
-			m_expressionCategory = ExpressionCategory::RValue;
-		else
-			m_expressionCategory = ExpressionCategory::LValue;
-	}
-
 	void ShaderAstValueCategory::Visit(SwizzleExpression& node)
 	{
 		node.expression->Visit(*this);

src/Nazara/Shader/Ast/SanitizeVisitor.cpp

@@ -632,27 +632,6 @@ namespace Nz::ShaderAst
 		return clone;
 	}
 
-	ExpressionPtr SanitizeVisitor::Clone(SelectOptionExpression& node)
-	{
-		MandatoryExpr(node.truePath);
-		MandatoryExpr(node.falsePath);
-
-		const Identifier* identifier = FindIdentifier(node.optionName);
-		if (!identifier)
-			throw AstError{ "unknown constant " + node.optionName };
-
-		if (identifier->type != Identifier::Type::Constant)
-			throw AstError{ "expected constant identifier" };
-
-		if (GetExpressionType(m_context->constantValues[identifier->index]) != ExpressionType{ PrimitiveType::Boolean })
-			throw AstError{ "constant is not a boolean" };
-
-		if (std::get<bool>(m_context->constantValues[identifier->index]))
-			return CloneExpression(node.truePath);
-		else
-			return CloneExpression(node.falsePath);
-	}
-
 	ExpressionPtr SanitizeVisitor::Clone(SwizzleExpression& node)
 	{
 		if (node.componentCount > 4)

src/Nazara/Shader/ShaderLangLexer.cpp

@@ -36,11 +36,12 @@ namespace Nz::ShaderLang
 
 	std::vector<Token> Tokenize(const std::string_view& str)
 	{
-		// Can't use std::from_chars for double, thanks to libc++ and libstdc++ developers for being lazy
+		// Can't use std::from_chars for double, thanks to libc++ and libstdc++ developers for being lazy, so we have to force C locale
 		ForceCLocale forceCLocale;
 
 		std::unordered_map<std::string, TokenType> reservedKeywords = {
 			{ "const",        TokenType::Const },
+			{ "const_select", TokenType::ConstSelect },
 			{ "discard",      TokenType::Discard },
 			{ "else",         TokenType::Else },
 			{ "external",     TokenType::External },
@@ -50,7 +51,6 @@ namespace Nz::ShaderLang
 			{ "let",          TokenType::Let },
 			{ "option",       TokenType::Option },
 			{ "return",       TokenType::Return },
-			{ "select_opt", TokenType::SelectOpt },
 			{ "struct",       TokenType::Struct },
 			{ "true",         TokenType::BoolTrue }
 		};

src/Nazara/Shader/ShaderLangParser.cpp

@@ -986,6 +986,26 @@ namespace Nz::ShaderLang
 		}
 	}
 
+	ShaderAst::ExpressionPtr Parser::ParseConstSelectExpression()
+	{
+		Expect(Advance(), TokenType::ConstSelect);
+		Expect(Advance(), TokenType::OpenParenthesis);
+
+		ShaderAst::ExpressionPtr cond = ParseExpression();
+
+		Expect(Advance(), TokenType::Comma);
+
+		ShaderAst::ExpressionPtr trueExpr = ParseExpression();
+
+		Expect(Advance(), TokenType::Comma);
+
+		ShaderAst::ExpressionPtr falseExpr = ParseExpression();
+
+		Expect(Advance(), TokenType::ClosingParenthesis);
+
+		return ShaderBuilder::ConditionalExpression(std::move(cond), std::move(trueExpr), std::move(falseExpr));
+	}
+
 	ShaderAst::ExpressionPtr Parser::ParseExpression()
 	{
 		return ParseBinOpRhs(0, ParsePrimaryExpression());
@@ -1053,6 +1073,9 @@ namespace Nz::ShaderLang
 				Consume();
 				return ShaderBuilder::Constant(true);
 
+			case TokenType::ConstSelect:
+				return ParseConstSelectExpression();
+
 			case TokenType::FloatingPointValue:
 				return ParseFloatingPointExpression();
 
@@ -1097,34 +1120,11 @@ namespace Nz::ShaderLang
 			case TokenType::OpenParenthesis:
 				return ParseParenthesisExpression();
 
-			case TokenType::SelectOpt:
-				return ParseSelectOptExpression();
-
 			default:
 				throw UnexpectedToken{};
 		}
 	}
 
-	ShaderAst::ExpressionPtr Parser::ParseSelectOptExpression()
-	{
-		Expect(Advance(), TokenType::SelectOpt);
-		Expect(Advance(), TokenType::OpenParenthesis);
-
-		std::string optionName = ParseIdentifierAsName();
-
-		Expect(Advance(), TokenType::Comma);
-
-		ShaderAst::ExpressionPtr trueExpr = ParseExpression();
-
-		Expect(Advance(), TokenType::Comma);
-
-		ShaderAst::ExpressionPtr falseExpr = ParseExpression();
-
-		Expect(Advance(), TokenType::ClosingParenthesis);
-
-		return ShaderBuilder::SelectOption(std::move(optionName), std::move(trueExpr), std::move(falseExpr));
-	}
-
 	ShaderAst::AttributeType Parser::ParseIdentifierAsAttributeType()
 	{
 		const Token& identifierToken = Expect(Advance(), TokenType::Identifier);