Shader/ShaderAst: Rename AccessMember* to Access*

include/Nazara/Shader/Ast/AstCloner.hpp

@@ -36,8 +36,8 @@ namespace Nz::ShaderAst
 			virtual ExpressionPtr CloneExpression(Expression& expr);
 			virtual StatementPtr CloneStatement(Statement& statement);
 
-			virtual ExpressionPtr Clone(AccessMemberIdentifierExpression& node);
+			virtual ExpressionPtr Clone(AccessIdentifierExpression& node);
-			virtual ExpressionPtr Clone(AccessMemberIndexExpression& node);
+			virtual ExpressionPtr Clone(AccessIndexExpression& node);
 			virtual ExpressionPtr Clone(AssignExpression& node);
 			virtual ExpressionPtr Clone(BinaryExpression& node);
 			virtual ExpressionPtr Clone(CallFunctionExpression& node);

include/Nazara/Shader/Ast/AstNodeList.hpp

@@ -26,8 +26,8 @@
 #define NAZARA_SHADERAST_STATEMENT_LAST(X) NAZARA_SHADERAST_STATEMENT(X)
 #endif
 
-NAZARA_SHADERAST_EXPRESSION(AccessMemberIdentifierExpression)
+NAZARA_SHADERAST_EXPRESSION(AccessIdentifierExpression)
-NAZARA_SHADERAST_EXPRESSION(AccessMemberIndexExpression)
+NAZARA_SHADERAST_EXPRESSION(AccessIndexExpression)
 NAZARA_SHADERAST_EXPRESSION(AssignExpression)
 NAZARA_SHADERAST_EXPRESSION(BinaryExpression)
 NAZARA_SHADERAST_EXPRESSION(CallFunctionExpression)

include/Nazara/Shader/Ast/AstRecursiveVisitor.hpp

@@ -20,8 +20,8 @@ namespace Nz::ShaderAst
 			AstRecursiveVisitor() = default;
 			~AstRecursiveVisitor() = default;
 
-			void Visit(AccessMemberIdentifierExpression& node) override;
+			void Visit(AccessIdentifierExpression& node) override;
-			void Visit(AccessMemberIndexExpression& node) override;
+			void Visit(AccessIndexExpression& node) override;
 			void Visit(AssignExpression& node) override;
 			void Visit(BinaryExpression& node) override;
 			void Visit(CallFunctionExpression& node) override;

include/Nazara/Shader/Ast/AstSerializer.hpp

@@ -23,8 +23,8 @@ namespace Nz::ShaderAst
 			AstSerializerBase(AstSerializerBase&&) = delete;
 			~AstSerializerBase() = default;
 
-			void Serialize(AccessMemberIdentifierExpression& node);
+			void Serialize(AccessIdentifierExpression& node);
-			void Serialize(AccessMemberIndexExpression& node);
+			void Serialize(AccessIndexExpression& node);
 			void Serialize(AssignExpression& node);
 			void Serialize(BinaryExpression& node);
 			void Serialize(CallFunctionExpression& node);

include/Nazara/Shader/Ast/AstUtils.hpp

@@ -31,8 +31,8 @@ namespace Nz::ShaderAst
 		private:
 			using AstExpressionVisitor::Visit;
 
-			void Visit(AccessMemberIdentifierExpression& node) override;
+			void Visit(AccessIdentifierExpression& node) override;
-			void Visit(AccessMemberIndexExpression& node) override;
+			void Visit(AccessIndexExpression& node) override;
 			void Visit(AssignExpression& node) override;
 			void Visit(BinaryExpression& node) override;
 			void Visit(CallFunctionExpression& node) override;

include/Nazara/Shader/Ast/Nodes.hpp

@@ -64,21 +64,21 @@ namespace Nz::ShaderAst
 		std::optional<ExpressionType> cachedExpressionType;
 	};
 
-	struct NAZARA_SHADER_API AccessMemberIdentifierExpression : public Expression
+	struct NAZARA_SHADER_API AccessIdentifierExpression : public Expression
 	{
 		NodeType GetType() const override;
 		void Visit(AstExpressionVisitor& visitor) override;
 
-		ExpressionPtr structExpr;
+		ExpressionPtr expr;
 		std::vector<std::string> memberIdentifiers;
 	};
 
-	struct NAZARA_SHADER_API AccessMemberIndexExpression : public Expression
+	struct NAZARA_SHADER_API AccessIndexExpression : public Expression
 	{
 		NodeType GetType() const override;
 		void Visit(AstExpressionVisitor& visitor) override;
 
-		ExpressionPtr structExpr;
+		ExpressionPtr expr;
 		std::vector<std::size_t> memberIndices;
 	};
 

include/Nazara/Shader/Ast/SanitizeVisitor.hpp

@@ -47,7 +47,7 @@ namespace Nz::ShaderAst
 
 			using AstCloner::CloneExpression;
 
-			ExpressionPtr Clone(AccessMemberIdentifierExpression& node) override;
+			ExpressionPtr Clone(AccessIdentifierExpression& node) override;
 			ExpressionPtr Clone(AssignExpression& node) override;
 			ExpressionPtr Clone(BinaryExpression& node) override;
 			ExpressionPtr Clone(CallFunctionExpression& node) override;

include/Nazara/Shader/GlslWriter.hpp

@@ -79,7 +79,7 @@ namespace Nz
 
 			void Visit(ShaderAst::ExpressionPtr& expr, bool encloseIfRequired = false);
 
-			void Visit(ShaderAst::AccessMemberIndexExpression& node) override;
+			void Visit(ShaderAst::AccessIndexExpression& node) override;
 			void Visit(ShaderAst::AssignExpression& node) override;
 			void Visit(ShaderAst::BinaryExpression& node) override;
 			void Visit(ShaderAst::CallFunctionExpression& node) override;

include/Nazara/Shader/LangWriter.hpp

@@ -80,7 +80,7 @@ namespace Nz
 
 			void Visit(ShaderAst::ExpressionPtr& expr, bool encloseIfRequired = false);
 
-			void Visit(ShaderAst::AccessMemberIndexExpression& node) override;
+			void Visit(ShaderAst::AccessIndexExpression& node) override;
 			void Visit(ShaderAst::AssignExpression& node) override;
 			void Visit(ShaderAst::BinaryExpression& node) override;
 			void Visit(ShaderAst::CastExpression& node) override;

include/Nazara/Shader/ShaderBuilder.hpp

@@ -19,12 +19,12 @@ namespace Nz::ShaderBuilder
 	{
 		struct AccessIndex
 		{
-			inline std::unique_ptr<ShaderAst::AccessMemberIndexExpression> operator()(ShaderAst::ExpressionPtr structExpr, std::vector<std::size_t> memberIndices) const;
+			inline std::unique_ptr<ShaderAst::AccessIndexExpression> operator()(ShaderAst::ExpressionPtr expr, std::vector<std::size_t> memberIndices) const;
 		};
 
 		struct AccessMember
 		{
-			inline std::unique_ptr<ShaderAst::AccessMemberIdentifierExpression> operator()(ShaderAst::ExpressionPtr structExpr, std::vector<std::string> memberIdentifiers) const;
+			inline std::unique_ptr<ShaderAst::AccessIdentifierExpression> operator()(ShaderAst::ExpressionPtr expr, std::vector<std::string> memberIdentifiers) const;
 		};
 
 		struct Assign

include/Nazara/Shader/ShaderBuilder.inl

@@ -7,19 +7,19 @@
 
 namespace Nz::ShaderBuilder
 {
-	inline std::unique_ptr<ShaderAst::AccessMemberIdentifierExpression> Impl::AccessMember::operator()(ShaderAst::ExpressionPtr structExpr, std::vector<std::string> memberIdentifiers) const
+	inline std::unique_ptr<ShaderAst::AccessIdentifierExpression> Impl::AccessMember::operator()(ShaderAst::ExpressionPtr expr, std::vector<std::string> memberIdentifiers) const
 	{
-		auto accessMemberNode = std::make_unique<ShaderAst::AccessMemberIdentifierExpression>();
+		auto accessMemberNode = std::make_unique<ShaderAst::AccessIdentifierExpression>();
-		accessMemberNode->structExpr = std::move(structExpr);
+		accessMemberNode->expr = std::move(expr);
 		accessMemberNode->memberIdentifiers = std::move(memberIdentifiers);
 
 		return accessMemberNode;
 	}
 
-	inline std::unique_ptr<ShaderAst::AccessMemberIndexExpression> Impl::AccessIndex::operator()(ShaderAst::ExpressionPtr structExpr, std::vector<std::size_t> memberIndices) const
+	inline std::unique_ptr<ShaderAst::AccessIndexExpression> Impl::AccessIndex::operator()(ShaderAst::ExpressionPtr expr, std::vector<std::size_t> memberIndices) const
 	{
-		auto accessMemberNode = std::make_unique<ShaderAst::AccessMemberIndexExpression>();
+		auto accessMemberNode = std::make_unique<ShaderAst::AccessIndexExpression>();
-		accessMemberNode->structExpr = std::move(structExpr);
+		accessMemberNode->expr = std::move(expr);
 		accessMemberNode->memberIndices = std::move(memberIndices);
 
 		return accessMemberNode;

include/Nazara/Shader/SpirvAstVisitor.hpp

@@ -41,7 +41,7 @@ namespace Nz
 			using ExpressionVisitorExcept::Visit;
 			using StatementVisitorExcept::Visit;
 
-			void Visit(ShaderAst::AccessMemberIndexExpression& node) override;
+			void Visit(ShaderAst::AccessIndexExpression& node) override;
 			void Visit(ShaderAst::AssignExpression& node) override;
 			void Visit(ShaderAst::BinaryExpression& node) override;
 			void Visit(ShaderAst::BranchStatement& node) override;

include/Nazara/Shader/SpirvExpressionLoad.hpp

@@ -30,7 +30,7 @@ namespace Nz
 			UInt32 Evaluate(ShaderAst::Expression& node);
 
 			using ExpressionVisitorExcept::Visit;
-			void Visit(ShaderAst::AccessMemberIndexExpression& node) override;
+			void Visit(ShaderAst::AccessIndexExpression& node) override;
 			void Visit(ShaderAst::VariableExpression& node) override;
 
 			SpirvExpressionLoad& operator=(const SpirvExpressionLoad&) = delete;

include/Nazara/Shader/SpirvExpressionStore.hpp

@@ -29,7 +29,7 @@ namespace Nz
 			void Store(ShaderAst::ExpressionPtr& node, UInt32 resultId);
 
 			using ExpressionVisitorExcept::Visit;
-			void Visit(ShaderAst::AccessMemberIndexExpression& node) override;
+			void Visit(ShaderAst::AccessIndexExpression& node) override;
 			void Visit(ShaderAst::SwizzleExpression& node) override;
 			void Visit(ShaderAst::VariableExpression& node) override;
 

src/Nazara/Shader/Ast/AstCloner.cpp

@@ -158,22 +158,22 @@ namespace Nz::ShaderAst
 		return clone;
 	}
 
-	ExpressionPtr AstCloner::Clone(AccessMemberIdentifierExpression& node)
+	ExpressionPtr AstCloner::Clone(AccessIdentifierExpression& node)
 	{
-		auto clone = std::make_unique<AccessMemberIdentifierExpression>();
+		auto clone = std::make_unique<AccessIdentifierExpression>();
 		clone->memberIdentifiers = node.memberIdentifiers;
-		clone->structExpr = CloneExpression(node.structExpr);
+		clone->expr = CloneExpression(node.expr);
 
 		clone->cachedExpressionType = node.cachedExpressionType;
 
 		return clone;
 	}
 
-	ExpressionPtr AstCloner::Clone(AccessMemberIndexExpression& node)
+	ExpressionPtr AstCloner::Clone(AccessIndexExpression& node)
 	{
-		auto clone = std::make_unique<AccessMemberIndexExpression>();
+		auto clone = std::make_unique<AccessIndexExpression>();
 		clone->memberIndices = node.memberIndices;
-		clone->structExpr = CloneExpression(node.structExpr);
+		clone->expr = CloneExpression(node.expr);
 
 		clone->cachedExpressionType = node.cachedExpressionType;
 

src/Nazara/Shader/Ast/AstRecursiveVisitor.cpp

@@ -7,14 +7,14 @@
 
 namespace Nz::ShaderAst
 {
-	void AstRecursiveVisitor::Visit(AccessMemberIdentifierExpression& node)
+	void AstRecursiveVisitor::Visit(AccessIdentifierExpression& node)
 	{
-		node.structExpr->Visit(*this);
+		node.expr->Visit(*this);
 	}
 
-	void AstRecursiveVisitor::Visit(AccessMemberIndexExpression& node)
+	void AstRecursiveVisitor::Visit(AccessIndexExpression& node)
 	{
-		node.structExpr->Visit(*this);
+		node.expr->Visit(*this);
 	}
 
 	void AstRecursiveVisitor::Visit(AssignExpression& node)

src/Nazara/Shader/Ast/AstSerializer.cpp

@@ -33,18 +33,18 @@ namespace Nz::ShaderAst
 		};
 	}
 
-	void AstSerializerBase::Serialize(AccessMemberIdentifierExpression& node)
+	void AstSerializerBase::Serialize(AccessIdentifierExpression& node)
 	{
-		Node(node.structExpr);
+		Node(node.expr);
 
 		Container(node.memberIdentifiers);
 		for (std::string& identifier : node.memberIdentifiers)
 			Value(identifier);
 	}
 
-	void AstSerializerBase::Serialize(AccessMemberIndexExpression& node)
+	void AstSerializerBase::Serialize(AccessIndexExpression& node)
 	{
-		Node(node.structExpr);
+		Node(node.expr);
 
 		Container(node.memberIndices);
 		for (std::size_t& identifier : node.memberIndices)

src/Nazara/Shader/Ast/AstUtils.cpp

@@ -13,14 +13,14 @@ namespace Nz::ShaderAst
 		return m_expressionCategory;
 	}
 
-	void ShaderAstValueCategory::Visit(AccessMemberIdentifierExpression& node)
+	void ShaderAstValueCategory::Visit(AccessIdentifierExpression& node)
 	{
-		node.structExpr->Visit(*this);
+		node.expr->Visit(*this);
 	}
 
-	void ShaderAstValueCategory::Visit(AccessMemberIndexExpression& node)
+	void ShaderAstValueCategory::Visit(AccessIndexExpression& node)
 	{
-		node.structExpr->Visit(*this);
+		node.expr->Visit(*this);
 	}
 
 	void ShaderAstValueCategory::Visit(AssignExpression& /*node*/)

src/Nazara/Shader/Ast/SanitizeVisitor.cpp

@@ -116,9 +116,9 @@ namespace Nz::ShaderAst
 			return member.type;
 	}
 
-	ExpressionPtr SanitizeVisitor::Clone(AccessMemberIdentifierExpression& node)
+	ExpressionPtr SanitizeVisitor::Clone(AccessIdentifierExpression& node)
 	{
-		auto structExpr = CloneExpression(MandatoryExpr(node.structExpr));
+		auto structExpr = CloneExpression(MandatoryExpr(node.expr));
 
 		const ExpressionType& exprType = GetExpressionType(*structExpr);
 		if (IsVectorType(exprType))
@@ -177,9 +177,9 @@ namespace Nz::ShaderAst
 			return swizzle;
 		}
 
-		// Transform to AccessMemberIndexExpression
+		// Transform to AccessIndexExpression
-		auto accessMemberIndex = std::make_unique<AccessMemberIndexExpression>();
+		auto accessMemberIndex = std::make_unique<AccessIndexExpression>();
-		accessMemberIndex->structExpr = std::move(structExpr);
+		accessMemberIndex->expr = std::move(structExpr);
 
 		StackArray<std::size_t> structIndices = NazaraStackArrayNoInit(std::size_t, node.memberIdentifiers.size());
 

src/Nazara/Shader/GlslWriter.cpp

@@ -650,11 +650,11 @@ namespace Nz
 			Append(")");
 	}
 
-	void GlslWriter::Visit(ShaderAst::AccessMemberIndexExpression& node)
+	void GlslWriter::Visit(ShaderAst::AccessIndexExpression& node)
 	{
-		Visit(node.structExpr, true);
+		Visit(node.expr, true);
 
-		const ShaderAst::ExpressionType& exprType = GetExpressionType(*node.structExpr);
+		const ShaderAst::ExpressionType& exprType = GetExpressionType(*node.expr);
 		assert(IsStructType(exprType));
 
 		AppendField(std::get<ShaderAst::StructType>(exprType).structIndex, node.memberIndices.data(), node.memberIndices.size());

src/Nazara/Shader/LangWriter.cpp

@@ -438,11 +438,11 @@ namespace Nz
 			Append(")");
 	}
 
-	void LangWriter::Visit(ShaderAst::AccessMemberIndexExpression& node)
+	void LangWriter::Visit(ShaderAst::AccessIndexExpression& node)
 	{
-		Visit(node.structExpr, true);
+		Visit(node.expr, true);
 
-		const ShaderAst::ExpressionType& exprType = GetExpressionType(*node.structExpr);
+		const ShaderAst::ExpressionType& exprType = GetExpressionType(*node.expr);
 		assert(IsStructType(exprType));
 
 		AppendField(std::get<ShaderAst::StructType>(exprType).structIndex, node.memberIndices.data(), node.memberIndices.size());

src/Nazara/Shader/ShaderLangParser.cpp

@@ -816,8 +816,8 @@ namespace Nz::ShaderLang
 
 			if (currentOp.type == TokenType::Dot)
 			{
-				std::unique_ptr<ShaderAst::AccessMemberIdentifierExpression> accessMemberNode = std::make_unique<ShaderAst::AccessMemberIdentifierExpression>();
+				std::unique_ptr<ShaderAst::AccessIdentifierExpression> accessMemberNode = std::make_unique<ShaderAst::AccessIdentifierExpression>();
-				accessMemberNode->structExpr = std::move(lhs);
+				accessMemberNode->expr = std::move(lhs);
 
 				do
 				{
@@ -833,7 +833,7 @@ namespace Nz::ShaderLang
 					if (Peek().type == TokenType::OpenParenthesis)
 					{
 						auto parameters = ParseParameters();
-						parameters.insert(parameters.begin(), std::move(accessMemberNode->structExpr));
+						parameters.insert(parameters.begin(), std::move(accessMemberNode->expr));
 
 						lhs = ShaderBuilder::Intrinsic(ShaderAst::IntrinsicType::SampleTexture, std::move(parameters));
 						continue;

src/Nazara/Shader/SpirvAstVisitor.cpp

@@ -35,7 +35,7 @@ namespace Nz
 		return *m_variables[varIndex];
 	}
 
-	void SpirvAstVisitor::Visit(ShaderAst::AccessMemberIndexExpression& node)
+	void SpirvAstVisitor::Visit(ShaderAst::AccessIndexExpression& node)
 	{
 		SpirvExpressionLoad accessMemberVisitor(m_writer, *this, *m_currentBlock);
 		PushResultId(accessMemberVisitor.Evaluate(node));

src/Nazara/Shader/SpirvExpressionLoad.cpp

@@ -40,9 +40,9 @@ namespace Nz
 		}, m_value);
 	}
 
-	void SpirvExpressionLoad::Visit(ShaderAst::AccessMemberIndexExpression& node)
+	void SpirvExpressionLoad::Visit(ShaderAst::AccessIndexExpression& node)
 	{
-		node.structExpr->Visit(*this);
+		node.expr->Visit(*this);
 
 		const ShaderAst::ExpressionType& exprType = GetExpressionType(node);
 

src/Nazara/Shader/SpirvExpressionStore.cpp

@@ -37,9 +37,9 @@ namespace Nz
 		}, m_value);
 	}
 
-	void SpirvExpressionStore::Visit(ShaderAst::AccessMemberIndexExpression& node)
+	void SpirvExpressionStore::Visit(ShaderAst::AccessIndexExpression& node)
 	{
-		node.structExpr->Visit(*this);
+		node.expr->Visit(*this);
 
 		const ShaderAst::ExpressionType& exprType = GetExpressionType(node);
 

src/Nazara/Shader/SpirvWriter.cpp

@@ -71,7 +71,7 @@ namespace Nz
 					});
 				}
 
-				void Visit(ShaderAst::AccessMemberIndexExpression& node) override
+				void Visit(ShaderAst::AccessIndexExpression& node) override
 				{
 					AstRecursiveVisitor::Visit(node);