use iota_view

Author: tad1

src/nbl/asset/ICPUImage.cpp

@@ -3,6 +3,8 @@
 #include "nbl/asset/filters/CMatchedSizeInOutImageFilterCommon.h"
 #include "nbl/asset/filters/CFlattenRegionsImageFilter.h"
 
+#include <ranges>
+
 using namespace nbl;
 using namespace asset;
 
@@ -81,56 +83,6 @@ class CFlattenRegionsStreamHashImageFilter : public CMatchedSizeInOutImageFilter
 
 	using state_type = CState;
 
-	// A wrapper for an additive, in[de]crementable value, so you can use values as iterators
-	template <typename Type, typename DiffType = std::ptrdiff_t>
-	struct ValueIterator {
-
-		// Iterator type traits
-		using iterator_category = std::random_access_iterator_tag;
-		using difference_type = DiffType; //must be a signed integer-like type
-		using value_type = Type;
-		using reference = Type;
-		using pointer = Type;
-
-		inline explicit ValueIterator(value_type value) : m_value(value) {};
-		inline ValueIterator() : m_value{} {};
-		ValueIterator(const ValueIterator& other) = default;
-		ValueIterator(ValueIterator&& other) = default;
-
-		ValueIterator& operator=(const ValueIterator& other) = default;
-		ValueIterator& operator=(ValueIterator&& other) = default;
-
-		// Iterator traits
-		inline reference operator*() const { return m_value; }
-		inline ValueIterator& operator++() { m_value++; return *this; }
-		inline ValueIterator operator++(int) { ValueIterator tmp = *this; ++(*this); return tmp; }
-
-		// InputIterator traits
-		inline bool operator==(const ValueIterator& other) const { return m_value == other.operator*(); }
-		inline bool operator!=(const ValueIterator& other) const { return !operator==(other); }
-		inline pointer operator->() const { return m_value; }
-
-		// BidirectionalIterator traits
-		inline ValueIterator& operator--() { m_value--; return *this; }
-		inline ValueIterator operator--(int) { ValueIterator tmp = *this; --(*this); return tmp; }
-
-		//RandomAccessIterator traits
-		inline ValueIterator& operator+=(difference_type advance) { m_value += advance; return *this; }
-		inline ValueIterator operator+(difference_type advance) const { return ValueIterator(m_value + advance); }
-		friend inline ValueIterator operator+(difference_type advance, const ValueIterator& other) { return valueIterator(advance + *other); }
-		inline ValueIterator& operator-=(difference_type advance) { m_value -= advance; return *this; }
-		inline ValueIterator operator-(difference_type advance) const { return ValueIterator(m_value - advance); }
-		inline value_type operator[] (int index) const { return m_value + index; }
-		inline difference_type operator-(const ValueIterator& other) const { return m_value - *other; }
-		inline bool operator< (const ValueIterator& other) const { return m_value < *other; }
-		inline bool operator> (const ValueIterator& other) const { return m_value > *other; }
-		inline bool operator>= (const ValueIterator& other) const { return m_value >= *other; }
-		inline bool operator<= (const ValueIterator& other) const { return m_value <= *other; }
-
-	private:
-		value_type m_value;
-	};
-
 	static inline bool validate(state_type* state)
 	{
 		if (!state)
@@ -253,13 +205,8 @@ class CFlattenRegionsStreamHashImageFilter : public CMatchedSizeInOutImageFilter
 		const auto texelOrBlockByteSize = asset::getTexelOrBlockBytesize(parameters.format);
 		const uint8_t* inData = reinterpret_cast<const uint8_t*>(image->getBuffer()->getPointer());
 
-		struct range {
-			ValueIterator<uint32_t> begin;
-			ValueIterator<uint32_t> end;
-		};
-
-		range layers = { .begin{0}, .end{parameters.arrayLayers} };
-		range levels = { .begin{0}, .end{parameters.mipLevels} };
+		auto layers = std::views::iota(0u, parameters.arrayLayers);
+		auto levels = std::views::iota(0u, parameters.mipLevels);
 
 		/*
 			we stream-hash texels per given mip level & layer
@@ -298,10 +245,10 @@ class CFlattenRegionsStreamHashImageFilter : public CMatchedSizeInOutImageFilter
 				blake3_hasher_finalize(hasher, reinterpret_cast<uint8_t*>(hash), sizeof(CState::hash_t)); // finalize hash for layer + put it to heap for given mip level	
 			};
 
-			std::for_each(policy, layers.begin, layers.end, executePerLayer); // fire per layer for given given mip level with specified execution policy, yes you can use parallel policy here if you want at it will work
+			std::for_each(policy, layers.begin(), layers.end(), executePerLayer); // fire per layer for given given mip level with specified execution policy, yes you can use parallel policy here if you want at it will work
 		};
 
-		std::for_each(policy, levels.begin, levels.end, executePerMipLevel); // fire per block of layers for given mip level with specified execution policy, yes you can use parallel policy here if you want at it will work
+		std::for_each(policy, levels.begin(), levels.end(), executePerMipLevel); // fire per block of layers for given mip level with specified execution policy, yes you can use parallel policy here if you want at it will work
 
 		/*
 			scratch's heap is filled with all hashes,