Shader: Add support for numerical fors

include/Nazara/Shader/Ast/AstCloner.hpp

@@ -64,6 +64,7 @@ namespace Nz::ShaderAst
 			virtual StatementPtr Clone(DeclareVariableStatement& node);
 			virtual StatementPtr Clone(DiscardStatement& node);
 			virtual StatementPtr Clone(ExpressionStatement& node);
+			virtual StatementPtr Clone(ForStatement& node);
 			virtual StatementPtr Clone(ForEachStatement& node);
 			virtual StatementPtr Clone(MultiStatement& node);
 			virtual StatementPtr Clone(NoOpStatement& node);

include/Nazara/Shader/Ast/AstCompare.hpp

@@ -54,6 +54,7 @@ namespace Nz::ShaderAst
 	inline bool Compare(const DeclareVariableStatement& lhs, const DeclareVariableStatement& rhs);
 	inline bool Compare(const DiscardStatement& lhs, const DiscardStatement& rhs);
 	inline bool Compare(const ExpressionStatement& lhs, const ExpressionStatement& rhs);
+	inline bool Compare(const ForStatement& lhs, const ForStatement& rhs);
 	inline bool Compare(const ForEachStatement& lhs, const ForEachStatement& rhs);
 	inline bool Compare(const MultiStatement& lhs, const MultiStatement& rhs);
 	inline bool Compare(const NoOpStatement& lhs, const NoOpStatement& rhs);

include/Nazara/Shader/Ast/AstCompare.inl

@@ -458,6 +458,29 @@ namespace Nz::ShaderAst
 		return true;
 	}
 
+	bool Compare(const ForStatement& lhs, const ForStatement& rhs)
+	{
+		if (!Compare(lhs.varName, rhs.varName))
+			return false;
+
+		if (!Compare(lhs.unroll, rhs.unroll))
+			return false;
+
+		if (!Compare(lhs.fromExpr, rhs.fromExpr))
+			return false;
+
+		if (!Compare(lhs.toExpr, rhs.toExpr))
+			return false;
+
+		if (!Compare(lhs.stepExpr, rhs.stepExpr))
+			return false;
+
+		if (!Compare(lhs.statement, rhs.statement))
+			return false;
+
+		return true;
+	}
+
 	bool Compare(const ForEachStatement& lhs, const ForEachStatement& rhs)
 	{
 		if (!Compare(lhs.varName, rhs.varName))

include/Nazara/Shader/Ast/AstNodeList.hpp

@@ -52,6 +52,7 @@ NAZARA_SHADERAST_STATEMENT(DeclareOptionStatement)
 NAZARA_SHADERAST_STATEMENT(DeclareStructStatement)
 NAZARA_SHADERAST_STATEMENT(DeclareVariableStatement)
 NAZARA_SHADERAST_STATEMENT(DiscardStatement)
+NAZARA_SHADERAST_STATEMENT(ForStatement)
 NAZARA_SHADERAST_STATEMENT(ForEachStatement)
 NAZARA_SHADERAST_STATEMENT(ExpressionStatement)
 NAZARA_SHADERAST_STATEMENT(MultiStatement)

include/Nazara/Shader/Ast/AstRecursiveVisitor.hpp

@@ -46,6 +46,7 @@ namespace Nz::ShaderAst
 			void Visit(DeclareVariableStatement& node) override;
 			void Visit(DiscardStatement& node) override;
 			void Visit(ExpressionStatement& node) override;
+			void Visit(ForStatement& node) override;
 			void Visit(ForEachStatement& node) override;
 			void Visit(MultiStatement& node) override;
 			void Visit(NoOpStatement& node) override;

include/Nazara/Shader/Ast/AstSerializer.hpp

@@ -49,6 +49,7 @@ namespace Nz::ShaderAst
 			void Serialize(DeclareVariableStatement& node);
 			void Serialize(DiscardStatement& node);
 			void Serialize(ExpressionStatement& node);
+			void Serialize(ForStatement& node);
 			void Serialize(ForEachStatement& node);
 			void Serialize(MultiStatement& node);
 			void Serialize(NoOpStatement& node);

include/Nazara/Shader/Ast/Nodes.hpp

@@ -340,6 +340,20 @@ namespace Nz::ShaderAst
 		ExpressionPtr expression;
 	};
 
+	struct NAZARA_SHADER_API ForStatement : Statement
+	{
+		NodeType GetType() const override;
+		void Visit(AstStatementVisitor& visitor) override;
+
+		AttributeValue<LoopUnroll> unroll;
+		std::optional<std::size_t> varIndex;
+		std::string varName;
+		ExpressionPtr fromExpr;
+		ExpressionPtr stepExpr;
+		ExpressionPtr toExpr;
+		StatementPtr statement;
+	};
+
 	struct NAZARA_SHADER_API ForEachStatement : Statement
 	{
 		NodeType GetType() const override;

include/Nazara/Shader/Ast/SanitizeVisitor.hpp

@@ -45,6 +45,7 @@ namespace Nz::ShaderAst
 				bool removeOptionDeclaration = false;
 				bool removeScalarSwizzling = false;
 				bool splitMultipleBranches = false;
+				bool useIdentifierAccessesForStructs = true;
 			};
 
 		private:
@@ -78,6 +79,7 @@ namespace Nz::ShaderAst
 			StatementPtr Clone(DeclareVariableStatement& node) override;
 			StatementPtr Clone(DiscardStatement& node) override;
 			StatementPtr Clone(ExpressionStatement& node) override;
+			StatementPtr Clone(ForStatement& node) override;
 			StatementPtr Clone(ForEachStatement& node) override;
 			StatementPtr Clone(MultiStatement& node) override;
 			StatementPtr Clone(WhileStatement& node) override;

include/Nazara/Shader/GlslWriter.hpp

@@ -66,7 +66,6 @@ namespace Nz
 			template<typename T1, typename T2, typename... Args> void Append(const T1& firstParam, const T2& secondParam, Args&&... params);
 			void AppendCommentSection(const std::string& section);
 			void AppendFunctionDeclaration(const ShaderAst::DeclareFunctionStatement& node, bool forward = false);
-			void AppendField(std::size_t structIndex, const ShaderAst::ExpressionPtr* memberIndices, std::size_t remainingMembers);
 			void AppendHeader();
 			void AppendLine(const std::string& txt = {});
 			template<typename... Args> void AppendLine(Args&&... params);
@@ -84,6 +83,7 @@ namespace Nz
 
 			void Visit(ShaderAst::ExpressionPtr& expr, bool encloseIfRequired = false);
 
+			void Visit(ShaderAst::AccessIdentifierExpression& node) override;
 			void Visit(ShaderAst::AccessIndexExpression& node) override;
 			void Visit(ShaderAst::AssignExpression& node) override;
 			void Visit(ShaderAst::BinaryExpression& node) override;

include/Nazara/Shader/LangWriter.hpp

@@ -45,6 +45,7 @@ namespace Nz
 			struct LayoutAttribute;
 			struct LocationAttribute;
 			struct SetAttribute;
+			struct UnrollAttribute;
 
 			void Append(const ShaderAst::ArrayType& type);
 			void Append(const ShaderAst::ExpressionType& type);
@@ -68,9 +69,9 @@ namespace Nz
 			void AppendAttribute(EntryAttribute entry);
 			void AppendAttribute(LayoutAttribute layout);
 			void AppendAttribute(LocationAttribute location);
-			void AppendAttribute(SetAttribute location);
+			void AppendAttribute(SetAttribute set);
+			void AppendAttribute(UnrollAttribute unroll);
 			void AppendCommentSection(const std::string& section);
-			void AppendField(std::size_t structIndex, const ShaderAst::ExpressionPtr* memberIndices, std::size_t remainingMembers);
 			void AppendHeader();
 			void AppendLine(const std::string& txt = {});
 			template<typename... Args> void AppendLine(Args&&... params);
@@ -85,6 +86,7 @@ namespace Nz
 
 			void Visit(ShaderAst::ExpressionPtr& expr, bool encloseIfRequired = false);
 
+			void Visit(ShaderAst::AccessIdentifierExpression& node) override;
 			void Visit(ShaderAst::AccessIndexExpression& node) override;
 			void Visit(ShaderAst::AssignExpression& node) override;
 			void Visit(ShaderAst::BinaryExpression& node) override;
@@ -107,6 +109,7 @@ namespace Nz
 			void Visit(ShaderAst::DeclareVariableStatement& node) override;
 			void Visit(ShaderAst::DiscardStatement& node) override;
 			void Visit(ShaderAst::ExpressionStatement& node) override;
+			void Visit(ShaderAst::ForStatement& node) override;
 			void Visit(ShaderAst::ForEachStatement& node) override;
 			void Visit(ShaderAst::MultiStatement& node) override;
 			void Visit(ShaderAst::NoOpStatement& node) override;

include/Nazara/Shader/ShaderBuilder.hpp

@@ -108,6 +108,12 @@ namespace Nz::ShaderBuilder
 			inline std::unique_ptr<ShaderAst::ExpressionStatement> operator()(ShaderAst::ExpressionPtr expression) const;
 		};
 
+		struct For
+		{
+			inline std::unique_ptr<ShaderAst::ForStatement> operator()(std::string varName, ShaderAst::ExpressionPtr fromExpression, ShaderAst::ExpressionPtr toExpression, ShaderAst::StatementPtr statement) const;
+			inline std::unique_ptr<ShaderAst::ForStatement> operator()(std::string varName, ShaderAst::ExpressionPtr fromExpression, ShaderAst::ExpressionPtr toExpression, ShaderAst::ExpressionPtr stepExpression, ShaderAst::StatementPtr statement) const;
+		};
+
 		struct ForEach
 		{
 			inline std::unique_ptr<ShaderAst::ForEachStatement> operator()(std::string varName, ShaderAst::ExpressionPtr expression, ShaderAst::StatementPtr statement) const;
@@ -179,6 +185,7 @@ namespace Nz::ShaderBuilder
 	constexpr Impl::DeclareVariable DeclareVariable;
 	constexpr Impl::ExpressionStatement ExpressionStatement;
 	constexpr Impl::NoParam<ShaderAst::DiscardStatement> Discard;
+	constexpr Impl::For For;
 	constexpr Impl::ForEach ForEach;
 	constexpr Impl::Identifier Identifier;
 	constexpr Impl::Intrinsic Intrinsic;

include/Nazara/Shader/ShaderBuilder.inl

@@ -269,6 +269,29 @@ namespace Nz::ShaderBuilder
 		return expressionStatementNode;
 	}
 
+	inline std::unique_ptr<ShaderAst::ForStatement> Nz::ShaderBuilder::Impl::For::operator()(std::string varName, ShaderAst::ExpressionPtr fromExpression, ShaderAst::ExpressionPtr toExpression, ShaderAst::StatementPtr statement) const
+	{
+		auto forNode = std::make_unique<ShaderAst::ForStatement>();
+		forNode->fromExpr = std::move(fromExpression);
+		forNode->statement = std::move(statement);
+		forNode->toExpr = std::move(toExpression);
+		forNode->varName = std::move(varName);
+
+		return forNode;
+	}
+
+	inline std::unique_ptr<ShaderAst::ForStatement> Nz::ShaderBuilder::Impl::For::operator()(std::string varName, ShaderAst::ExpressionPtr fromExpression, ShaderAst::ExpressionPtr toExpression, ShaderAst::ExpressionPtr stepExpression, ShaderAst::StatementPtr statement) const
+	{
+		auto forNode = std::make_unique<ShaderAst::ForStatement>();
+		forNode->fromExpr = std::move(fromExpression);
+		forNode->statement = std::move(statement);
+		forNode->stepExpr = std::move(stepExpression);
+		forNode->toExpr = std::move(toExpression);
+		forNode->varName = std::move(varName);
+
+		return forNode;
+	}
+
 	std::unique_ptr<ShaderAst::ForEachStatement> Impl::ForEach::operator()(std::string varName, ShaderAst::ExpressionPtr expression, ShaderAst::StatementPtr statement) const
 	{
 		auto forEachNode = std::make_unique<ShaderAst::ForEachStatement>();

include/Nazara/Shader/ShaderLangTokenList.hpp

@@ -12,6 +12,7 @@
 #define NAZARA_SHADERLANG_TOKEN_LAST(X) NAZARA_SHADERLANG_TOKEN(X)
 #endif
 
+NAZARA_SHADERLANG_TOKEN(Arrow)
 NAZARA_SHADERLANG_TOKEN(Assign)
 NAZARA_SHADERLANG_TOKEN(BoolFalse)
 NAZARA_SHADERLANG_TOKEN(BoolTrue)
@@ -33,7 +34,6 @@ NAZARA_SHADERLANG_TOKEN(External)
 NAZARA_SHADERLANG_TOKEN(FloatingPointValue)
 NAZARA_SHADERLANG_TOKEN(For)
 NAZARA_SHADERLANG_TOKEN(FunctionDeclaration)
-NAZARA_SHADERLANG_TOKEN(FunctionReturn)
 NAZARA_SHADERLANG_TOKEN(GreaterThan)
 NAZARA_SHADERLANG_TOKEN(GreaterThanEqual)
 NAZARA_SHADERLANG_TOKEN(IntegerValue)
@@ -59,8 +59,8 @@ NAZARA_SHADERLANG_TOKEN(OpenCurlyBracket)
 NAZARA_SHADERLANG_TOKEN(OpenSquareBracket)
 NAZARA_SHADERLANG_TOKEN(OpenParenthesis)
 NAZARA_SHADERLANG_TOKEN(Option)
-NAZARA_SHADERLANG_TOKEN(Semicolon)
 NAZARA_SHADERLANG_TOKEN(Return)
+NAZARA_SHADERLANG_TOKEN(Semicolon)
 NAZARA_SHADERLANG_TOKEN(Struct)
 NAZARA_SHADERLANG_TOKEN(While)
 

src/Nazara/Shader/Ast/AstCloner.cpp

@@ -170,12 +170,26 @@ namespace Nz::ShaderAst
 		return clone;
 	}
 
+	StatementPtr AstCloner::Clone(ForStatement& node)
+	{
+		auto clone = std::make_unique<ForStatement>();
+		clone->fromExpr = CloneExpression(node.fromExpr);
+		clone->stepExpr = CloneExpression(node.stepExpr);
+		clone->toExpr = CloneExpression(node.toExpr);
+		clone->statement = CloneStatement(node.statement);
+		clone->unroll = Clone(node.unroll);
+		clone->varName = node.varName;
+
+		return clone;
+	}
+
 	StatementPtr AstCloner::Clone(ForEachStatement& node)
 	{
 		auto clone = std::make_unique<ForEachStatement>();
 		clone->expression = CloneExpression(node.expression);
 		clone->statement = CloneStatement(node.statement);
 		clone->unroll = Clone(node.unroll);
+		clone->varName = node.varName;
 
 		return clone;
 	}

src/Nazara/Shader/Ast/AstRecursiveVisitor.cpp

@@ -161,6 +161,21 @@ namespace Nz::ShaderAst
 		node.expression->Visit(*this);
 	}
 
+	void AstRecursiveVisitor::Visit(ForStatement& node)
+	{
+		if (node.fromExpr)
+			node.fromExpr->Visit(*this);
+
+		if (node.toExpr)
+			node.toExpr->Visit(*this);
+
+		if (node.stepExpr)
+			node.stepExpr->Visit(*this);
+
+		if (node.statement)
+			node.statement->Visit(*this);
+	}
+
 	void AstRecursiveVisitor::Visit(ForEachStatement& node)
 	{
 		if (node.expression)

src/Nazara/Shader/Ast/AstSerializer.cpp

@@ -301,6 +301,16 @@ namespace Nz::ShaderAst
 		Node(node.expression);
 	}
 
+	void AstSerializerBase::Serialize(ForStatement& node)
+	{
+		Attribute(node.unroll);
+		Value(node.varName);
+		Node(node.fromExpr);
+		Node(node.toExpr);
+		Node(node.stepExpr);
+		Node(node.statement);
+	}
+
 	void AstSerializerBase::Serialize(ForEachStatement& node)
 	{
 		Attribute(node.unroll);

src/Nazara/Shader/Ast/SanitizeVisitor.cpp

@@ -163,19 +163,6 @@ namespace Nz::ShaderAst
 			const ExpressionType& exprType = GetExpressionType(*indexedExpr);
 			if (IsStructType(exprType))
 			{
-				// Transform to AccessIndexExpression
-				AccessIndexExpression* accessIndexPtr;
-				if (indexedExpr->GetType() != NodeType::AccessIndexExpression)
-				{
-					std::unique_ptr<AccessIndexExpression> accessIndex = std::make_unique<AccessIndexExpression>();
-					accessIndex->expr = std::move(indexedExpr);
-
-					accessIndexPtr = accessIndex.get();
-					indexedExpr = std::move(accessIndex);
-				}
-				else
-					accessIndexPtr = static_cast<AccessIndexExpression*>(indexedExpr.get());
-
 				std::size_t structIndex = ResolveStruct(exprType);
 				assert(structIndex < m_context->structs.size());
 				const StructDescription* s = m_context->structs[structIndex];
@@ -200,9 +187,43 @@ namespace Nz::ShaderAst
 				if (!fieldPtr)
 					throw AstError{ "unknown field " + identifier };
 
+				if (m_context->options.useIdentifierAccessesForStructs)
+				{
+					// Use a AccessIdentifierExpression
+					AccessIdentifierExpression* accessIdentifierPtr;
+					if (indexedExpr->GetType() != NodeType::AccessIdentifierExpression)
+					{
+						std::unique_ptr<AccessIdentifierExpression> accessIndex = std::make_unique<AccessIdentifierExpression>();
+						accessIndex->expr = std::move(indexedExpr);
+
+						accessIdentifierPtr = accessIndex.get();
+						indexedExpr = std::move(accessIndex);
+					}
+					else
+						accessIdentifierPtr = static_cast<AccessIdentifierExpression*>(indexedExpr.get());
+
+					accessIdentifierPtr->identifiers.push_back(s->members[fieldIndex].name);
+					accessIdentifierPtr->cachedExpressionType = ResolveType(fieldPtr->type);
+				}
+				else
+				{
+					// Transform to AccessIndexExpression
+					AccessIndexExpression* accessIndexPtr;
+					if (indexedExpr->GetType() != NodeType::AccessIndexExpression)
+					{
+						std::unique_ptr<AccessIndexExpression> accessIndex = std::make_unique<AccessIndexExpression>();
+						accessIndex->expr = std::move(indexedExpr);
+
+						accessIndexPtr = accessIndex.get();
+						indexedExpr = std::move(accessIndex);
+					}
+					else
+						accessIndexPtr = static_cast<AccessIndexExpression*>(indexedExpr.get());
+
 					accessIndexPtr->indices.push_back(ShaderBuilder::Constant(fieldIndex));
 					accessIndexPtr->cachedExpressionType = ResolveType(fieldPtr->type);
 				}
+			}
 			else if (IsPrimitiveType(exprType) || IsVectorType(exprType))
 			{
 				// Swizzle expression
@@ -269,6 +290,8 @@ namespace Nz::ShaderAst
 		auto clone = static_unique_pointer_cast<AccessIndexExpression>(AstCloner::Clone(node));
 		Validate(*clone);
 
+		// TODO: Handle AccessIndex on structs with m_context->options.useIdentifierAccessesForStructs
+
 		return clone;
 	}
 
@@ -829,9 +852,180 @@ namespace Nz::ShaderAst
 		return AstCloner::Clone(node);
 	}
 
+	StatementPtr SanitizeVisitor::Clone(ForStatement& node)
+	{
+		if (node.varName.empty())
+			throw AstError{ "numerical for variable name cannot be empty" };
+
+		auto fromExpr = CloneExpression(MandatoryExpr(node.fromExpr));
+		auto stepExpr = CloneExpression(node.stepExpr);
+		auto toExpr = CloneExpression(MandatoryExpr(node.toExpr));
+
+		MandatoryStatement(node.statement);
+
+		const ExpressionType& fromExprType = GetExpressionType(*fromExpr);
+		if (!IsPrimitiveType(fromExprType))
+			throw AstError{ "numerical for from expression must be an integer or unsigned integer" };
+
+		PrimitiveType fromType = std::get<PrimitiveType>(fromExprType);
+		if (fromType != PrimitiveType::Int32 && fromType != PrimitiveType::UInt32)
+			throw AstError{ "numerical for from expression must be an integer or unsigned integer" };
+
+		const ExpressionType& toExprType = GetExpressionType(*fromExpr);
+		if (toExprType != fromExprType)
+			throw AstError{ "numerical for to expression type must match from expression type" };
+
+		if (stepExpr)
+		{
+			const ExpressionType& stepExprType = GetExpressionType(*fromExpr);
+			if (stepExprType != fromExprType)
+				throw AstError{ "numerical for step expression type must match from expression type" };
+		}
+
+
+		AttributeValue<LoopUnroll> unrollValue;
+		if (node.unroll.HasValue())
+		{
+			unrollValue = ComputeAttributeValue(node.unroll);
+			if (unrollValue.GetResultingValue() == LoopUnroll::Always)
+			{
+				PushScope();
+
+				auto multi = std::make_unique<MultiStatement>();
+
+				auto Unroll = [&](auto dummy)
+				{
+					using T = std::decay_t<decltype(dummy)>;
+
+					T counter = std::get<T>(ComputeConstantValue(*fromExpr));
+					T to = std::get<T>(ComputeConstantValue(*toExpr));
+					T step = (stepExpr) ? std::get<T>(ComputeConstantValue(*stepExpr)) : T(1);
+
+					for (; counter < to; counter += step)
+					{
+						auto var = ShaderBuilder::DeclareVariable(node.varName, ShaderBuilder::Constant(counter));
+						Validate(*var);
+						multi->statements.emplace_back(std::move(var));
+
+						multi->statements.emplace_back(CloneStatement(node.statement));
+					}
+				};
+
+				switch (fromType)
+				{
+					case PrimitiveType::Int32:
+						Unroll(Int32{});
+						break;
+
+					case PrimitiveType::UInt32:
+						Unroll(UInt32{});
+						break;
+
+					default:
+						throw AstError{ "internal error" };
+				}
+
+				PopScope();
+
+				return multi;
+			}
+		}
+
+		if (m_context->options.reduceLoopsToWhile)
+		{
+			PushScope();
+
+			auto multi = std::make_unique<MultiStatement>();
+
+			// Counter variable
+			auto counterVariable = ShaderBuilder::DeclareVariable(node.varName, std::move(fromExpr));
+			Validate(*counterVariable);
+
+			std::size_t counterVarIndex = counterVariable->varIndex.value();
+			multi->statements.emplace_back(std::move(counterVariable));
+
+			// Target variable
+			auto targetVariable = ShaderBuilder::DeclareVariable("to", std::move(toExpr));
+			Validate(*targetVariable);
+
+			std::size_t targetVarIndex = targetVariable->varIndex.value();
+			multi->statements.emplace_back(std::move(targetVariable));
+
+			// Step variable
+			std::optional<std::size_t> stepVarIndex;
+
+			if (stepExpr)
+			{
+				auto stepVariable = ShaderBuilder::DeclareVariable("step", std::move(stepExpr));
+				Validate(*stepVariable);
+
+				stepVarIndex = stepVariable->varIndex;
+				multi->statements.emplace_back(std::move(stepVariable));
+			}
+
+			// While
+			auto whileStatement = std::make_unique<WhileStatement>();
+			whileStatement->unroll = std::move(unrollValue);
+
+			// While condition
+			auto condition = ShaderBuilder::Binary(BinaryType::CompLt, ShaderBuilder::Variable(counterVarIndex, fromType), ShaderBuilder::Variable(targetVarIndex, fromType));
+			Validate(*condition);
+
+			whileStatement->condition = std::move(condition);
+
+			// While body
+			auto body = std::make_unique<MultiStatement>();
+			body->statements.reserve(2);
+
+			body->statements.emplace_back(CloneStatement(node.statement));
+
+			ExpressionPtr incrExpr;
+			if (stepVarIndex)
+				incrExpr = ShaderBuilder::Variable(*stepVarIndex, fromType);
+			else
+				incrExpr = (fromType == PrimitiveType::Int32) ? ShaderBuilder::Constant(1) : ShaderBuilder::Constant(1u);
+
+			auto incrCounter = ShaderBuilder::Assign(AssignType::CompoundAdd, ShaderBuilder::Variable(counterVarIndex, fromType), std::move(incrExpr));
+			Validate(*incrCounter);
+
+			body->statements.emplace_back(ShaderBuilder::ExpressionStatement(std::move(incrCounter)));
+
+			whileStatement->body = std::move(body);
+
+			multi->statements.emplace_back(std::move(whileStatement));
+
+			PopScope();
+
+			return multi;
+		}
+		else
+		{
+			auto clone = std::make_unique<ForStatement>();
+			clone->fromExpr = std::move(fromExpr);
+			clone->stepExpr = std::move(stepExpr);
+			clone->toExpr = std::move(toExpr);
+			clone->varName = node.varName;
+			clone->unroll = std::move(unrollValue);
+
+			PushScope();
+			{
+				clone->varIndex = RegisterVariable(node.varName, fromExprType);
+				clone->statement = CloneStatement(node.statement);
+			}
+			PopScope();
+
+			SanitizeIdentifier(clone->varName);
+
+			return clone;
+		}
+	}
+
 	StatementPtr SanitizeVisitor::Clone(ForEachStatement& node)
 	{
-		auto expr = CloneExpression(node.expression);
+		auto expr = CloneExpression(MandatoryExpr(node.expression));
+
+		if (node.varName.empty())
+			throw AstError{ "for-each variable name cannot be empty"};
 
 		const ExpressionType& exprType = GetExpressionType(*expr);
 		ExpressionType innerType;
@@ -849,6 +1043,8 @@ namespace Nz::ShaderAst
 			unrollValue = ComputeAttributeValue(node.unroll);
 			if (unrollValue.GetResultingValue() == LoopUnroll::Always)
 			{
+				PushScope();
+
 				// Repeat code
 				auto multi = std::make_unique<MultiStatement>();
 				if (IsArrayType(exprType))
@@ -869,6 +1065,8 @@ namespace Nz::ShaderAst
 					}
 				}
 
+				PopScope();
+
 				return multi;
 			}
 		}
@@ -943,7 +1141,7 @@ namespace Nz::ShaderAst
 			}
 			PopScope();
 
-			SanitizeIdentifier(node.varName);
+			SanitizeIdentifier(clone->varName);
 
 			return clone;
 		}

src/Nazara/Shader/GlslWriter.cpp

@@ -390,41 +390,6 @@ namespace Nz
 		AppendLine((forward) ? ");" : ")");
 	}
 
-	void GlslWriter::AppendField(std::size_t structIndex, const ShaderAst::ExpressionPtr* memberIndices, std::size_t remainingMembers)
-	{
-		ShaderAst::StructDescription* structDesc = Retrieve(m_currentState->structs, structIndex);
-
-		assert((*memberIndices)->GetType() == ShaderAst::NodeType::ConstantValueExpression);
-		auto& constantValue = static_cast<ShaderAst::ConstantValueExpression&>(**memberIndices);
-		Int32 index = std::get<Int32>(constantValue.value);
-		assert(index >= 0);
-
-		auto it = structDesc->members.begin();
-		for (; it != structDesc->members.end(); ++it)
-		{
-			const auto& member = *it;
-			if (member.cond.HasValue() && !member.cond.GetResultingValue())
-				continue;
-
-			if (index == 0)
-				break;
-
-			index--;
-		}
-
-		assert(it != structDesc->members.end());
-		const auto& member = *it;
-
-		Append(".");
-		Append(member.name);
-
-		if (remainingMembers > 1)
-		{
-			assert(IsStructType(member.type));
-			AppendField(std::get<ShaderAst::StructType>(member.type).structIndex, memberIndices + 1, remainingMembers - 1);
-		}
-	}
-	
 	void GlslWriter::AppendHeader()
 	{
 		unsigned int glslVersion;
@@ -734,17 +699,24 @@ namespace Nz
 			Append(")");
 	}
 
+	void GlslWriter::Visit(ShaderAst::AccessIdentifierExpression& node)
+	{
+		Visit(node.expr, true);
+
+		const ShaderAst::ExpressionType& exprType = GetExpressionType(*node.expr);
+		assert(IsStructType(exprType));
+
+		for (const std::string& identifier : node.identifiers)
+			Append(".", identifier);
+	}
+
 	void GlslWriter::Visit(ShaderAst::AccessIndexExpression& node)
 	{
 		Visit(node.expr, true);
 
 		const ShaderAst::ExpressionType& exprType = GetExpressionType(*node.expr);
+		assert(!IsStructType(exprType));
 
-		// For structs, convert indices to field names
-		if (IsStructType(exprType))
-			AppendField(std::get<ShaderAst::StructType>(exprType).structIndex, node.indices.data(), node.indices.size());
-		else
-		{
 		// Array access
 		for (ShaderAst::ExpressionPtr& expr : node.indices)
 		{
@@ -753,7 +725,6 @@ namespace Nz
 			Append("]");
 		}
 	}
-	}
 
 	void GlslWriter::Visit(ShaderAst::AssignExpression& node)
 	{

src/Nazara/Shader/LangWriter.cpp

@@ -83,6 +83,13 @@ namespace Nz
 		inline bool HasValue() const { return setIndex.HasValue(); }
 	};
 
+	struct LangWriter::UnrollAttribute
+	{
+		const ShaderAst::AttributeValue<ShaderAst::LoopUnroll>& unroll;
+
+		inline bool HasValue() const { return unroll.HasValue(); }
+	};
+
 	struct LangWriter::State
 	{
 		const States* states = nullptr;
@@ -103,10 +110,7 @@ namespace Nz
 			m_currentState = nullptr;
 		});
 
-		ShaderAst::SanitizeVisitor::Options options;
+		ShaderAst::StatementPtr sanitizedAst = ShaderAst::Sanitize(shader);
-		options.removeOptionDeclaration = false;
-
-		ShaderAst::StatementPtr sanitizedAst = ShaderAst::Sanitize(shader, options);
 
 		AppendHeader();
 
@@ -277,10 +281,14 @@ namespace Nz
 		if (!binding.HasValue())
 			return;
 
+		Append("binding(");
+
 		if (binding.bindingIndex.IsResultingValue())
-			Append("binding(", binding.bindingIndex.GetResultingValue(), ")");
+			Append(binding.bindingIndex.GetResultingValue());
 		else
 			binding.bindingIndex.GetExpression()->Visit(*this);
+
+		Append(")");
 	}
 
 	void LangWriter::AppendAttribute(BuiltinAttribute builtin)
@@ -288,25 +296,29 @@ namespace Nz
 		if (!builtin.HasValue())
 			return;
 
+		Append("builtin(");
+
 		if (builtin.builtin.IsResultingValue())
 		{
 			switch (builtin.builtin.GetResultingValue())
 			{
 				case ShaderAst::BuiltinEntry::FragCoord:
-					Append("builtin(fragcoord)");
+					Append("fragcoord");
 					break;
 
 				case ShaderAst::BuiltinEntry::FragDepth:
-					Append("builtin(fragdepth)");
+					Append("fragdepth");
 					break;
 
 				case ShaderAst::BuiltinEntry::VertexPosition:
-					Append("builtin(position)");
+					Append("position");
 					break;
 			}
 		}
 		else
 			builtin.builtin.GetExpression()->Visit(*this);
+
+		Append(")");
 	}
 	
 	void LangWriter::AppendAttribute(DepthWriteAttribute depthWrite)
@@ -314,29 +326,33 @@ namespace Nz
 		if (!depthWrite.HasValue())
 			return;
 
+		Append("depth_write(");
+
 		if (depthWrite.writeMode.IsResultingValue())
 		{
 			switch (depthWrite.writeMode.GetResultingValue())
 			{
 				case ShaderAst::DepthWriteMode::Greater:
-					Append("depth_write(greater)");
+					Append("greater");
 					break;
 
 				case ShaderAst::DepthWriteMode::Less:
-					Append("depth_write(less)");
+					Append("less");
 					break;
 
 				case ShaderAst::DepthWriteMode::Replace:
-					Append("depth_write(replace)");
+					Append("replace");
 					break;
 
 				case ShaderAst::DepthWriteMode::Unchanged:
-					Append("depth_write(unchanged)");
+					Append("unchanged");
 					break;
 			}
 		}
 		else
 			depthWrite.writeMode.GetExpression()->Visit(*this);
+
+		Append(")");
 	}
 
 	void LangWriter::AppendAttribute(EarlyFragmentTestsAttribute earlyFragmentTests)
@@ -344,15 +360,19 @@ namespace Nz
 		if (!earlyFragmentTests.HasValue())
 			return;
 
+		Append("early_fragment_tests(");
+
 		if (earlyFragmentTests.earlyFragmentTests.IsResultingValue())
 		{
 			if (earlyFragmentTests.earlyFragmentTests.GetResultingValue())
-				Append("early_fragment_tests(true)");
+				Append("true");
 			else
-				Append("early_fragment_tests(false)");
+				Append("false");
 		}
 		else
 			earlyFragmentTests.earlyFragmentTests.GetExpression()->Visit(*this);
+
+		Append(")");
 	}
 
 	void LangWriter::AppendAttribute(EntryAttribute entry)
@@ -360,21 +380,25 @@ namespace Nz
 		if (!entry.HasValue())
 			return;
 
+		Append("entry(");
+
 		if (entry.stageType.IsResultingValue())
 		{
 			switch (entry.stageType.GetResultingValue())
 			{
 				case ShaderStageType::Fragment:
-					Append("entry(frag)");
+					Append("frag");
 					break;
 
 				case ShaderStageType::Vertex:
-					Append("entry(vert)");
+					Append("vert");
 					break;
 			}
 		}
 		else
 			entry.stageType.GetExpression()->Visit(*this);
+
+		Append(")");
 	}
 
 	void LangWriter::AppendAttribute(LayoutAttribute entry)
@@ -382,17 +406,19 @@ namespace Nz
 		if (!entry.HasValue())
 			return;
 
+		Append("layout(");
 		if (entry.layout.IsResultingValue())
 		{
 			switch (entry.layout.GetResultingValue())
 			{
 				case StructLayout::Std140:
-					Append("layout(std140)");
+					Append("std140");
 					break;
 			}
 		}
 		else
 			entry.layout.GetExpression()->Visit(*this);
+		Append(")");
 	}
 
 	void LangWriter::AppendAttribute(LocationAttribute location)
@@ -400,10 +426,14 @@ namespace Nz
 		if (!location.HasValue())
 			return;
 
+		Append("location(");
+
 		if (location.locationIndex.IsResultingValue())
-			Append("location(", location.locationIndex.GetResultingValue(), ")");
+			Append(location.locationIndex.GetResultingValue());
 		else
 			location.locationIndex.GetExpression()->Visit(*this);
+
+		Append(")");
 	}
 
 	void LangWriter::AppendAttribute(SetAttribute set)
@@ -411,10 +441,45 @@ namespace Nz
 		if (!set.HasValue())
 			return;
 
+		Append("set(");
+
 		if (set.setIndex.IsResultingValue())
-			Append("set(", set.setIndex.GetResultingValue(), ")");
+			Append(set.setIndex.GetResultingValue());
 		else
 			set.setIndex.GetExpression()->Visit(*this);
+
+		Append(")");
+	}
+
+	void LangWriter::AppendAttribute(UnrollAttribute unroll)
+	{
+		if (!unroll.HasValue())
+			return;
+
+		Append("unroll(");
+
+		if (unroll.unroll.IsResultingValue())
+		{
+			switch (unroll.unroll.GetResultingValue())
+			{
+				case ShaderAst::LoopUnroll::Always:
+					Append("always");
+					break;
+
+				case ShaderAst::LoopUnroll::Hint:
+					Append("hint");
+					break;
+
+				case ShaderAst::LoopUnroll::Never:
+					Append("never");
+					break;
+
+				default:
+					break;
+			}
+		}
+		else
+			unroll.unroll.GetExpression()->Visit(*this);
 	}
 
 	void LangWriter::AppendCommentSection(const std::string& section)
@@ -426,26 +491,6 @@ namespace Nz
 		AppendLine();
 	}
 
-	void LangWriter::AppendField(std::size_t structIndex, const ShaderAst::ExpressionPtr* memberIndices, std::size_t remainingMembers)
-	{
-		ShaderAst::StructDescription* structDesc = Retrieve(m_currentState->structs, structIndex);
-
-		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];
-
-		Append(".");
-		Append(member.name);
-
-		if (remainingMembers > 1)
-		{
-			assert(IsStructType(member.type));
-			AppendField(std::get<ShaderAst::StructType>(member.type).structIndex, memberIndices + 1, remainingMembers - 1);
-		}
-	}
-
 	void LangWriter::AppendLine(const std::string& txt)
 	{
 		NazaraAssert(m_currentState, "This function should only be called while processing an AST");
@@ -526,26 +571,32 @@ namespace Nz
 			Append(")");
 	}
 
+	void LangWriter::Visit(ShaderAst::AccessIdentifierExpression& node)
+	{
+		Visit(node.expr, true);
+
+		const ShaderAst::ExpressionType& exprType = GetExpressionType(*node.expr);
+		assert(IsStructType(exprType));
+
+		for (const std::string& identifier : node.identifiers)
+			Append(".", identifier);
+	}
+
 	void LangWriter::Visit(ShaderAst::AccessIndexExpression& node)
 	{
 		Visit(node.expr, true);
 
 		const ShaderAst::ExpressionType& exprType = GetExpressionType(*node.expr);
+		assert(!IsStructType(exprType));
 
-		// For structs, convert indices to field names
-		if (IsStructType(exprType))
-			AppendField(std::get<ShaderAst::StructType>(exprType).structIndex, node.indices.data(), node.indices.size());
-		else
-		{
 		// Array access
 		for (ShaderAst::ExpressionPtr& expr : node.indices)
 		{
 			Append("[");
-				Visit(expr);
+			expr->Visit(*this);
 			Append("]");
 		}
 	}
-	}
 
 	void LangWriter::Visit(ShaderAst::AssignExpression& node)
 	{
@@ -826,11 +877,36 @@ namespace Nz
 		Append(";");
 	}
 
+	void LangWriter::Visit(ShaderAst::ForStatement& node)
+	{
+		assert(node.varIndex);
+		RegisterVariable(*node.varIndex, node.varName);
+
+		AppendAttributes(true, UnrollAttribute{ node.unroll });
+		Append("for ", node.varName, " in ");
+		node.fromExpr->Visit(*this);
+		Append(" -> ");
+		node.toExpr->Visit(*this);
+
+		if (node.stepExpr)
+		{
+			Append(" : ");
+			node.stepExpr->Visit(*this);
+		}
+
+		AppendLine();
+
+		EnterScope();
+		node.statement->Visit(*this);
+		LeaveScope();
+	}
+
 	void LangWriter::Visit(ShaderAst::ForEachStatement& node)
 	{
 		assert(node.varIndex);
 		RegisterVariable(*node.varIndex, node.varName);
 
+		AppendAttributes(true, UnrollAttribute{ node.unroll });
 		Append("for ", node.varName, " in ");
 		node.expression->Visit(*this);
 		AppendLine();

src/Nazara/Shader/ShaderLangLexer.cpp

@@ -113,7 +113,7 @@ namespace Nz::ShaderLang
 					if (next == '>')
 					{
 						currentPos++;
-						tokenType = TokenType::FunctionReturn;
+						tokenType = TokenType::Arrow;
 						break;
 					}
 					else if (next == '=')

src/Nazara/Shader/ShaderLangParser.cpp

@@ -614,16 +614,54 @@ namespace Nz::ShaderLang
 
 		ShaderAst::ExpressionPtr expr = ParseExpression();
 
+		if (Peek().type == TokenType::Arrow)
+		{
+			// Numerical for
+			Consume();
+
+			ShaderAst::ExpressionPtr toExpr = ParseExpression();
+
+			ShaderAst::ExpressionPtr stepExpr;
+			if (Peek().type == TokenType::Colon)
+			{
+				Consume();
+				stepExpr = ParseExpression();
+			}
+
 			ShaderAst::StatementPtr statement = ParseStatement();
 
-		auto forEach = ShaderBuilder::ForEach(std::move(varName), std::move(expr), std::move(statement));
+			auto forNode = ShaderBuilder::For(std::move(varName), std::move(expr), std::move(toExpr), std::move(stepExpr), std::move(statement));
 
+			// TODO: Deduplicate code
 			for (auto&& [attributeType, arg] : attributes)
 			{
 				switch (attributeType)
 				{
 					case ShaderAst::AttributeType::Unroll:
-					HandleUniqueStringAttribute("unroll", s_unrollModes, forEach->unroll, std::move(arg), std::make_optional(ShaderAst::LoopUnroll::Always));
+						HandleUniqueStringAttribute("unroll", s_unrollModes, forNode->unroll, std::move(arg), std::make_optional(ShaderAst::LoopUnroll::Always));
+						break;
+
+					default:
+						throw AttributeError{ "unhandled attribute for numerical for" };
+				}
+			}
+
+			return forNode;
+		}
+		else
+		{
+			// For each
+			ShaderAst::StatementPtr statement = ParseStatement();
+
+			auto forEachNode = ShaderBuilder::ForEach(std::move(varName), std::move(expr), std::move(statement));
+
+			// TODO: Deduplicate code
+			for (auto&& [attributeType, arg] : attributes)
+			{
+				switch (attributeType)
+				{
+					case ShaderAst::AttributeType::Unroll:
+						HandleUniqueStringAttribute("unroll", s_unrollModes, forEachNode->unroll, std::move(arg), std::make_optional(ShaderAst::LoopUnroll::Always));
 						break;
 
 					default:
@@ -631,7 +669,8 @@ namespace Nz::ShaderLang
 				}
 			}
 
-		return forEach;
+			return forEachNode;
+		}
 	}
 
 	std::vector<ShaderAst::StatementPtr> Parser::ParseFunctionBody()
@@ -668,7 +707,7 @@ namespace Nz::ShaderLang
 		Expect(Advance(), TokenType::ClosingParenthesis);
 
 		ShaderAst::ExpressionType returnType;
-		if (Peek().type == TokenType::FunctionReturn)
+		if (Peek().type == TokenType::Arrow)
 		{
 			Consume();
 			returnType = ParseType();

src/Nazara/Shader/SpirvWriter.cpp

@@ -491,6 +491,7 @@ namespace Nz
 			options.removeCompoundAssignments = true;
 			options.removeOptionDeclaration = true; 
 			options.splitMultipleBranches = true;
+			options.useIdentifierAccessesForStructs = false;
 
 			sanitizedAst = ShaderAst::Sanitize(shader, options);
 			targetAst = sanitizedAst.get();

tests/Engine/Shader/Const.cpp

@@ -110,6 +110,63 @@ fn main()
 		}
 	}
 	
+	WHEN("using [unroll] attribute on numerical for")
+	{
+		std::string_view sourceCode = R"(
+const LightCount = 3;
+
+[layout(std140)]
+struct Light
+{
+	color: vec4<f32>
+}
+
+[layout(std140)]
+struct LightData
+{
+	lights: [Light; LightCount]
+}
+
+external
+{
+	[set(0), binding(0)] data: uniform<LightData>
+}
+
+[entry(frag)]
+fn main()
+{
+	let color = (0.0).xxxx;
+
+	[unroll]
+	for i in 0 -> 10 : 2
+	{
+		color += data.lights[i].color;
+	}
+}
+)";
+
+		Nz::ShaderAst::StatementPtr shader;
+		REQUIRE_NOTHROW(shader = Nz::ShaderLang::Parse(sourceCode));
+
+		ExpectOutput(*shader, {}, R"(
+[entry(frag)]
+fn main()
+{
+	let color: vec4<f32> = (0.000000).xxxx;
+	let i: i32 = 0;
+	color += data.lights[i].color;
+	let i: i32 = 2;
+	color += data.lights[i].color;
+	let i: i32 = 4;
+	color += data.lights[i].color;
+	let i: i32 = 6;
+	color += data.lights[i].color;
+	let i: i32 = 8;
+	color += data.lights[i].color;
+}
+)");
+	}
+
 	WHEN("using [unroll] attribute on for-each")
 	{
 		std::string_view sourceCode = R"(

tests/Engine/Shader/Loops.cpp

@@ -91,6 +91,160 @@ OpReturn
 OpFunctionEnd)");
 	}
 	
+	WHEN("using a for range")
+	{
+		std::string_view nzslSource = R"(
+[entry(frag)]
+fn main()
+{
+	let x = 0;
+	for v in 0 -> 10
+	{
+		x += v;
+	}
+}
+)";
+
+		Nz::ShaderAst::StatementPtr shader = Nz::ShaderLang::Parse(nzslSource);
+
+
+		ExpectGLSL(*shader, R"(
+void main()
+{
+	int x = 0;
+	int v = 0;
+	int to = 10;
+	while (v < to)
+	{
+		x += v;
+		v += 1;
+	}
+	
+}
+)");
+
+		ExpectNZSL(*shader, R"(
+[entry(frag)]
+fn main()
+{
+	let x: i32 = 0;
+	for v in 0 -> 10
+	{
+		x += v;
+	}
+	
+}
+)");
+
+		ExpectSpirV(*shader, R"(
+OpFunction
+OpLabel
+OpVariable
+OpVariable
+OpVariable
+OpStore
+OpStore
+OpStore
+OpBranch
+OpLabel
+OpLoad
+OpLoad
+OpSLessThan
+OpLoopMerge
+OpBranchConditional
+OpLabel
+OpLoad
+OpLoad
+OpIAdd
+OpStore
+OpLoad
+OpIAdd
+OpStore
+OpBranch
+OpLabel
+OpReturn
+OpFunctionEnd)");
+	}
+
+	WHEN("using a for range with step")
+	{
+		std::string_view nzslSource = R"(
+[entry(frag)]
+fn main()
+{
+	let x = 0;
+	for v in 0 -> 10 : 2
+	{
+		x += v;
+	}
+}
+)";
+
+		Nz::ShaderAst::StatementPtr shader = Nz::ShaderLang::Parse(nzslSource);
+
+
+		ExpectGLSL(*shader, R"(
+void main()
+{
+	int x = 0;
+	int v = 0;
+	int to = 10;
+	int step = 2;
+	while (v < to)
+	{
+		x += v;
+		v += step;
+	}
+	
+}
+)");
+
+		ExpectNZSL(*shader, R"(
+[entry(frag)]
+fn main()
+{
+	let x: i32 = 0;
+	for v in 0 -> 10 : 2
+	{
+		x += v;
+	}
+	
+}
+)");
+
+		ExpectSpirV(*shader, R"(
+OpFunction
+OpLabel
+OpVariable
+OpVariable
+OpVariable
+OpVariable
+OpStore
+OpStore
+OpStore
+OpStore
+OpBranch
+OpLabel
+OpLoad
+OpLoad
+OpSLessThan
+OpLoopMerge
+OpBranchConditional
+OpLabel
+OpLoad
+OpLoad
+OpIAdd
+OpStore
+OpLoad
+OpLoad
+OpIAdd
+OpStore
+OpBranch
+OpLabel
+OpReturn
+OpFunctionEnd)");
+	}
+
 	WHEN("using a for-each")
 	{
 		std::string_view nzslSource = R"(