there was a bug in decode_before_scramble_helper

fix make `OwenSampler` be able to generate dimensions in parallel

Author: devshgraphicsprogramming

include/nbl/builtin/hlsl/sampling/quantized_sequence.hlsl

@@ -79,7 +79,7 @@ struct decode_before_scramble_helper
     {
         uvec_type seqVal;
         NBL_UNROLL for(uint16_t i = 0; i < Dim; i++)
-            seqVal[i] = val.get(i);
+            seqVal[i] = val.get(i) << Q::DiscardBits; // restore high bits
         seqVal ^= scrambleKey;
         return return_type(seqVal) * bit_cast<float_of_size_t<sizeof(storage_scalar_type)> >(UNormConstant);
     }
@@ -122,6 +122,7 @@ struct QuantizedSequence<T, 1 NBL_PARTIAL_REQ_BOT(impl::SequenceSpecialization<T
     using store_type = T;
     using scalar_type = typename vector_traits<T>::scalar_type;
     NBL_CONSTEXPR_STATIC_INLINE uint16_t BitsPerComponent = 8u*size_of_v<store_type>;
+    NBL_CONSTEXPR_STATIC_INLINE uint16_t DiscardBits = uint16_t(0u);
     NBL_CONSTEXPR_STATIC_INLINE uint16_t Dimension = uint16_t(1u);
 
     static this_t create(const store_type value)
@@ -223,6 +224,7 @@ struct QuantizedSequence<T, Dim NBL_PARTIAL_REQ_BOT(impl::SequenceSpecialization
     using store_type = T;
     using scalar_type = typename vector_traits<T>::scalar_type;
     NBL_CONSTEXPR_STATIC_INLINE uint16_t BitsPerComponent = 8u*size_of_v<scalar_type>;
+    NBL_CONSTEXPR_STATIC_INLINE uint16_t DiscardBits = uint16_t(0u);
     NBL_CONSTEXPR_STATIC_INLINE uint16_t Dimension = Dim;
 
     static this_t create(const store_type value)
@@ -288,11 +290,11 @@ struct QuantizedSequence<T, Dim NBL_PARTIAL_REQ_BOT(is_same_v<T,uint32_t2> && Di
         else if (idx == 1)  // y
         {
             scalar_type y = glsl::bitfieldExtract(data[0], BitsPerComponent, DiscardBits);
-            y |= glsl::bitfieldExtract(data[1], 0u, DiscardBits - 1u) << DiscardBits;
+            y |= glsl::bitfieldExtract(data[1], 0u, BitsPerComponent - DiscardBits) << DiscardBits;
             return y;
         }
         else    // z
-            return glsl::bitfieldExtract(data[1], DiscardBits - 1u, BitsPerComponent);
+            return glsl::bitfieldExtract(data[1], BitsPerComponent - DiscardBits, BitsPerComponent);
     }
 
     void set(const uint16_t idx, const scalar_type value)
@@ -304,10 +306,10 @@ struct QuantizedSequence<T, Dim NBL_PARTIAL_REQ_BOT(is_same_v<T,uint32_t2> && Di
         else if (idx == 1)  // y
         {
             data[0] = glsl::bitfieldInsert(data[0], trunc_val, BitsPerComponent, DiscardBits);
-            data[1] = glsl::bitfieldInsert(data[1], trunc_val >> DiscardBits, 0u, DiscardBits - 1u);
+            data[1] = glsl::bitfieldInsert(data[1], trunc_val >> DiscardBits, 0u, BitsPerComponent - DiscardBits);
         }
         else    // z
-            data[1] = glsl::bitfieldInsert(data[1], trunc_val, DiscardBits - 1u, BitsPerComponent);
+            data[1] = glsl::bitfieldInsert(data[1], trunc_val, BitsPerComponent - DiscardBits, BitsPerComponent);
     }
 
     template<typename F, bool FullWidth>
@@ -317,14 +319,14 @@ struct QuantizedSequence<T, Dim NBL_PARTIAL_REQ_BOT(is_same_v<T,uint32_t2> && Di
     }
 
     template<typename F>
-    vector<F,Dimension> decode(const vector<unsigned_integer_of_size_t<sizeof(F)>,Dimension> scrambleKey)
+    vector<F,Dimension> decode(const vector<unsigned_integer_of_size_t<sizeof(F)>,Dimension> scrambleKey) NBL_CONST_MEMBER_FUNC
     {
         impl::decode_before_scramble_helper<this_t,F> helper;
         helper.val.data = data;
         return helper(scrambleKey);
     }
     template<typename F>
-    vector<F,Dimension> decode(NBL_CONST_REF_ARG(this_t) scrambleKey)
+    vector<F,Dimension> decode(NBL_CONST_REF_ARG(this_t) scrambleKey) NBL_CONST_MEMBER_FUNC
     {
         impl::decode_after_scramble_helper<this_t,F> helper;
         helper.val.data = data;

include/nbl/core/sampling/OwenSampler.h

@@ -12,92 +12,90 @@ namespace nbl::core
 
 //! TODO: make the tree sampler/generator configurable and let RandomSampler be default
 template<class SequenceSampler=SobolSampler>
-class OwenSampler : protected SequenceSampler
+class OwenSampler final : protected SequenceSampler
 {
+		// if we don't limit the sample count, then due to IEEE754 precision, we'll get duplicate sample coordinate values, ruining the net property
+		constexpr static inline uint32_t OUT_BITS = sizeof(uint32_t)*8u;
+		constexpr static inline uint32_t MAX_SAMPLES_LOG2 = 24u;
+		constexpr static inline uint32_t MAX_SAMPLES = 0x1u<<MAX_SAMPLES_LOG2;
+
 	public:
-		OwenSampler(uint32_t _dimensions, uint32_t _seed) : SequenceSampler(_dimensions)
-		{
-			mersenneTwister.seed(_seed);
-			cachedFlip.resize(MAX_SAMPLES-1u);
-			resetDimensionCounter(0u);
-		}
-		~OwenSampler()
-		{
-		}
+		inline OwenSampler(uint32_t _dimensions, uint32_t _seed) : SequenceSampler(_dimensions), seed(_seed) {}
+		inline ~OwenSampler() = default;
 
-		// 
-		inline uint32_t sample(uint32_t dim, uint32_t sampleNum)
+		struct SDimensionSampler final : public core::Unmovable
 		{
-			if (dim>lastDim)
-				resetDimensionCounter(dim);
-			else if (dim<lastDim)
-				assert(false);
-
-			uint32_t oldsample = SequenceSampler::sample(dim,sampleNum);
-			#ifdef _NBL_DEBUG
-				assert(sampleNum<MAX_SAMPLES);
-				if (sampleNum)
-					assert((oldsample&(0x7fffffffu>>hlsl::findMSB(sampleNum))) == 0u);
-				else
-					assert(oldsample == 0u);
-			#endif
-			constexpr uint32_t lastLevelStart = MAX_SAMPLES/2u-1u;
-			uint32_t index = oldsample>>(OUT_BITS+1u - MAX_SAMPLES_LOG2);
-			index += lastLevelStart;
+				inline uint32_t sample(uint32_t sampleNum) const
+				{
+					const uint32_t oldsample = sampler.sample(dimension,sampleNum);
+					#ifdef _NBL_DEBUG
+						assert(sampleNum<MAX_SAMPLES);
+						if (sampleNum)
+							assert((oldsample&(0x7fffffffu>>hlsl::findMSB(sampleNum))) == 0u);
+						else
+							assert(oldsample == 0u);
+					#endif
+					constexpr uint32_t lastLevelStart = MAX_SAMPLES/2u-1u;
+					uint32_t index = oldsample>>(OUT_BITS+1u - MAX_SAMPLES_LOG2);
+					index += lastLevelStart;
 
-			return oldsample^cachedFlip[index];
-		}
+					return oldsample^cachedFlip[index];
+				}
 
-		//!
-		inline void resetDimensionCounter(uint32_t dimension)
-		{
-			/** NOTES:
-			- For 64k samples, we can store their positions in uint16_t
-			- The last leves of Owen Tree can be collapsed to a single node (because trailing bits are always 00000.....)
-			- The above can be stored in 1x array of sample count uint16_t/uint32_t per Dimension
-			- We should store samples as uint32_t always because the total amount of memory to fetch is always the same
-			**/
-			for (uint32_t i=0u; i<MAX_SAMPLES-1u; i++) 
-			{
-				uint32_t randMask = (i<(MAX_SAMPLES/2u-1u)) ? 0x80000000u:0xffffffffu;
-				cachedFlip[i] = mersenneTwister()&(randMask>>getTreeDepth(i));
-			}
-			for (uint32_t i=1u; i<MAX_SAMPLES_LOG2; i++)
-			{
-				uint32_t previousLevelStart = (0x1u<<(i-1u))-1u;
-				uint32_t currentLevelStart = (0x1u<<i)-1u;
-				uint32_t currentLevelSize = 0x1u<<i;
-				for (uint32_t j=0u; j<currentLevelSize; j++)
-					cachedFlip[currentLevelStart+j] |= cachedFlip[previousLevelStart+(j>>1u)];
-				#ifdef _NBL_DEBUG
-				for (uint32_t j=0u; j<currentLevelSize; j+=2)
+			private:
+				friend class OwenSampler;
+				inline SDimensionSampler(const SequenceSampler& _sampler, const uint32_t seed, const uint32_t _dimension) : sampler(_sampler), dimension(_dimension),
+					mersenneTwister(std::hash<uint64_t>()((uint64_t(_dimension)<<32)|seed))
 				{
-					const uint32_t highBitMask = 0xffffffffu<<(OUT_BITS-i);
-					uint32_t left = cachedFlip[currentLevelStart+j];
-					uint32_t right = cachedFlip[currentLevelStart+j+1];
-					assert(((left^right)&highBitMask)==0u);
-					assert((left&right&highBitMask)==cachedFlip[previousLevelStart+(j>>1u)]);
+					cachedFlip.resize(MAX_SAMPLES-1u);
+					/** NOTES:
+					- For 64k samples, we can store their positions in uint16_t
+					- The last leves of Owen Tree can be collapsed to a single node (because trailing bits are always 00000.....)
+					- The above can be stored in 1x array of sample count uint16_t/uint32_t per Dimension
+					- We should store samples as uint32_t always because the total amount of memory to fetch is always the same
+					**/
+					for (uint32_t i=0u; i<MAX_SAMPLES-1u; i++) 
+					{
+						uint32_t randMask = (i<(MAX_SAMPLES/2u-1u)) ? 0x80000000u:0xffffffffu;
+						cachedFlip[i] = mersenneTwister()&(randMask>>getTreeDepth(i));
+					}
+					for (uint32_t i=1u; i<MAX_SAMPLES_LOG2; i++)
+					{
+						uint32_t previousLevelStart = (0x1u<<(i-1u))-1u;
+						uint32_t currentLevelStart = (0x1u<<i)-1u;
+						uint32_t currentLevelSize = 0x1u<<i;
+						for (uint32_t j=0u; j<currentLevelSize; j++)
+							cachedFlip[currentLevelStart+j] |= cachedFlip[previousLevelStart+(j>>1u)];
+						#ifdef _NBL_DEBUG
+						for (uint32_t j=0u; j<currentLevelSize; j+=2)
+						{
+							const uint32_t highBitMask = 0xffffffffu<<(OUT_BITS-i);
+							uint32_t left = cachedFlip[currentLevelStart+j];
+							uint32_t right = cachedFlip[currentLevelStart+j+1];
+							assert(((left^right)&highBitMask)==0u);
+							assert((left&right&highBitMask)==cachedFlip[previousLevelStart+(j>>1u)]);
+						}
+						#endif
+					}
+				}
+				inline uint32_t getTreeDepth(uint32_t sampleNum)
+				{
+					return hlsl::findMSB(sampleNum+1u);
 				}
-				#endif
-			}
-			lastDim = dimension;
-		}
-
-	protected:
-		// if we don't limit the sample count, then due to IEEE754 precision, we'll get duplicate sample coordinate values, ruining the net property
-		_NBL_STATIC_INLINE_CONSTEXPR uint32_t OUT_BITS = sizeof(uint32_t)*8u;
-		_NBL_STATIC_INLINE_CONSTEXPR uint32_t MAX_SAMPLES_LOG2 = 24u;
-		_NBL_STATIC_INLINE_CONSTEXPR uint32_t MAX_SAMPLES = 0x1u<<MAX_SAMPLES_LOG2;
 
-		inline uint32_t getTreeDepth(uint32_t sampleNum)
+				const SequenceSampler& sampler;
+				std::mt19937 mersenneTwister;
+				core::vector<uint32_t> cachedFlip;
+				const uint32_t dimension;
+		};
+		inline SDimensionSampler prepareDimension(const uint64_t dim) const
 		{
-			return hlsl::findMSB(sampleNum+1u);
+			return SDimensionSampler(*this,seed,dim);
 		}
 
-		std::mt19937 mersenneTwister;
-		uint32_t lastDim;
-		core::vector<uint32_t> cachedFlip;
-	};
+	private:
+		uint32_t seed;
+};
 
 
 }

include/nbl/core/sampling/SobolSampler.h

@@ -77,7 +77,7 @@ class SobolSampler
 		}
 
 		// Idea for optimization, do PoT samples per pass, then can precompute most of the `retval`
-		inline uint32_t sample(uint32_t dim, uint32_t sampleNum)
+		inline uint32_t sample(uint32_t dim, uint32_t sampleNum) const
 		{
 			#ifdef _DEBUG
 				assert(dim<dimensions);