Merge branch 'hlsl' into compiler_cleanup

# Conflicts:
#	examples_tests
#	include/nbl/video/IPhysicalDevice.h
#	src/nbl/video/COpenGL_LogicalDevice.h
#	src/nbl/video/CVulkanConnection.cpp
#	src/nbl/video/CVulkanLogicalDevice.h
#	src/nbl/video/CVulkanPhysicalDevice.h
#	src/nbl/video/IOpenGL_PhysicalDeviceBase.h
#	src/nbl/video/IPhysicalDevice.cpp

Author: Erfan-Ahmadi

include/nbl/asset/ECommonEnums.h

@@ -1,5 +1,5 @@
-#ifndef __NBL_E_COMMON_ENUMS_H_INCLUDED__
-#define __NBL_E_COMMON_ENUMS_H_INCLUDED__
+#ifndef __NBL_ASSET_E_COMMON_ENUMS_H_INCLUDED__
+#define __NBL_ASSET_E_COMMON_ENUMS_H_INCLUDED__
 
 #include "nbl/core/declarations.h"
 
@@ -66,6 +66,7 @@ enum E_PIPELINE_STAGE_FLAGS : uint32_t
 
 enum E_ACCESS_FLAGS : uint32_t
 {
+    EAF_NONE = 0,
     EAF_INDIRECT_COMMAND_READ_BIT = 0x00000001,
     EAF_INDEX_READ_BIT = 0x00000002,
     EAF_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004,

include/nbl/asset/ICPUBuffer.h

@@ -19,10 +19,10 @@ namespace nbl::asset
 
 //! One of CPU class-object representing an Asset
 /**
-	One of Assets used for storage of large arrays, so that storage can be decoupled
-	from other objects such as meshbuffers, images, animations and shader source/bytecode.
+    One of Assets used for storage of large arrays, so that storage can be decoupled
+    from other objects such as meshbuffers, images, animations and shader source/bytecode.
 
-	@see IAsset
+    @see IAsset
 */
 class NBL_API ICPUBuffer : public asset::IBuffer, public asset::IAsset
 {
@@ -35,12 +35,12 @@ class NBL_API ICPUBuffer : public asset::IBuffer, public asset::IAsset
         //! Non-allocating constructor for CCustormAllocatorCPUBuffer derivative
         ICPUBuffer(size_t sizeInBytes, void* dat) : asset::IBuffer({dat ? sizeInBytes:0,EUF_TRANSFER_DST_BIT}), data(dat) {}
     public:
-		//! Constructor. TODO: remove, alloc can fail, should be a static create method instead!
-		/** @param sizeInBytes Size in bytes. If `dat` argument is present, it denotes size of data pointed by `dat`, otherwise - size of data to be allocated.
-		*/
+        //! Constructor. TODO: remove, alloc can fail, should be a static create method instead!
+        /** @param sizeInBytes Size in bytes. If `dat` argument is present, it denotes size of data pointed by `dat`, otherwise - size of data to be allocated.
+        */
         ICPUBuffer(size_t sizeInBytes) : asset::IBuffer({0,EUF_TRANSFER_DST_BIT})
         {
-			data = _NBL_ALIGNED_MALLOC(sizeInBytes,_NBL_SIMD_ALIGNMENT);
+            data = _NBL_ALIGNED_MALLOC(sizeInBytes,_NBL_SIMD_ALIGNMENT);
             if (!data)
                 return;
 
@@ -74,7 +74,7 @@ class NBL_API ICPUBuffer : public asset::IBuffer, public asset::IAsset
 
         virtual size_t conservativeSizeEstimate() const override { return getSize(); }
 
-		//! Returns pointer to data.
+        //! Returns pointer to data.
         virtual const void* getPointer() const {return data;}
         virtual void* getPointer() 
         { 
@@ -90,22 +90,22 @@ class NBL_API ICPUBuffer : public asset::IBuffer, public asset::IAsset
             return true;
         }
 
-		inline core::bitflag<E_USAGE_FLAGS> getUsageFlags() const
-		{
-			return m_creationParams.usage;
-		}
-		inline bool setUsageFlags(core::bitflag<E_USAGE_FLAGS> _usage)
-		{
-			assert(!isImmutable_debug());
+        inline core::bitflag<E_USAGE_FLAGS> getUsageFlags() const
+        {
+            return m_creationParams.usage;
+        }
+        inline bool setUsageFlags(core::bitflag<E_USAGE_FLAGS> _usage)
+        {
+            assert(!isImmutable_debug());
             m_creationParams.usage = _usage;
-			return true;
-		}
-		inline bool addUsageFlags(core::bitflag<E_USAGE_FLAGS> _usage)
-		{
-			assert(!isImmutable_debug());
+            return true;
+        }
+        inline bool addUsageFlags(core::bitflag<E_USAGE_FLAGS> _usage)
+        {
+            assert(!isImmutable_debug());
             m_creationParams.usage |= _usage;
-			return true;
-		}
+            return true;
+        }
 
     protected:
         void restoreFromDummy_impl(IAsset* _other, uint32_t _levelsBelow) override
@@ -140,51 +140,51 @@ class NBL_API CCustomAllocatorCPUBuffer;
 template<typename Allocator>
 class NBL_API CCustomAllocatorCPUBuffer<Allocator, true> : public ICPUBuffer
 {
-		static_assert(sizeof(typename Allocator::value_type) == 1u, "Allocator::value_type must be of size 1");
-	protected:
-		Allocator m_allocator;
+        static_assert(sizeof(typename Allocator::value_type) == 1u, "Allocator::value_type must be of size 1");
+    protected:
+        Allocator m_allocator;
 
         virtual ~CCustomAllocatorCPUBuffer()
         {
             this->convertToDummyObject();
         }
 
-	public:
-		CCustomAllocatorCPUBuffer(size_t sizeInBytes, void* dat, core::adopt_memory_t, Allocator&& alctr = Allocator()) : ICPUBuffer(sizeInBytes, dat), m_allocator(std::move(alctr))
-		{
-		}
+    public:
+        CCustomAllocatorCPUBuffer(size_t sizeInBytes, void* dat, core::adopt_memory_t, Allocator&& alctr = Allocator()) : ICPUBuffer(sizeInBytes, dat), m_allocator(std::move(alctr))
+        {
+        }
 
-		virtual void convertToDummyObject(uint32_t referenceLevelsBelowToConvert = 0u) override
-		{
+        virtual void convertToDummyObject(uint32_t referenceLevelsBelowToConvert = 0u) override
+        {
             if (isDummyObjectForCacheAliasing)
                 return;
             convertToDummyObject_common(referenceLevelsBelowToConvert);
             if (!canBeConvertedToDummy())
                 return;
 
-			if (ICPUBuffer::data)
-				m_allocator.deallocate(reinterpret_cast<typename Allocator::pointer>(ICPUBuffer::data), ICPUBuffer::size);
-			ICPUBuffer::data = nullptr; // so that ICPUBuffer won't try deallocating
-		}
+            if (ICPUBuffer::data)
+                m_allocator.deallocate(reinterpret_cast<typename Allocator::pointer>(ICPUBuffer::data), ICPUBuffer::m_creationParams.size);
+            ICPUBuffer::data = nullptr; // so that ICPUBuffer won't try deallocating
+        }
 };
 
 template<typename Allocator>
 class NBL_API CCustomAllocatorCPUBuffer<Allocator, false> : public CCustomAllocatorCPUBuffer<Allocator, true>
 {
-		using Base = CCustomAllocatorCPUBuffer<Allocator, true>;
-	protected:
-		virtual ~CCustomAllocatorCPUBuffer() = default;
+        using Base = CCustomAllocatorCPUBuffer<Allocator, true>;
+    protected:
+        virtual ~CCustomAllocatorCPUBuffer() = default;
 
-	public:
-		using Base::Base;
+    public:
+        using Base::Base;
 
         // TODO: remove, alloc can fail, should be a static create method instead!
-		CCustomAllocatorCPUBuffer(size_t sizeInBytes, const void* dat, Allocator&& alctr = Allocator()) : Base(sizeInBytes, alctr.allocate(sizeInBytes), core::adopt_memory, std::move(alctr))
-		{
-			memcpy(Base::data,dat,sizeInBytes);
-		}
+        CCustomAllocatorCPUBuffer(size_t sizeInBytes, const void* dat, Allocator&& alctr = Allocator()) : Base(sizeInBytes, alctr.allocate(sizeInBytes), core::adopt_memory, std::move(alctr))
+        {
+            memcpy(Base::data,dat,sizeInBytes);
+        }
 };
 
 } // end namespace nbl::asset
 
-#endif
+#endif

include/nbl/asset/ICPUImage.h

@@ -176,7 +176,10 @@ class NBL_API ICPUImage final : public IImage, public IAsset
 			assert(!isImmutable_debug());
 
 			if (!IImage::validateCopies(_regions->begin(),_regions->end(),_buffer.get()))
+			{
+				assert(false);
 				return false;
+			}
 
 			buffer = std::move(_buffer);
 			regions = _regions;

include/nbl/asset/ICommandBuffer.h

@@ -46,8 +46,8 @@ struct NBL_API SImageResolve
 
 struct NBL_API SMemoryBarrier
 {
-    core::bitflag<asset::E_ACCESS_FLAGS> srcAccessMask = static_cast<asset::E_ACCESS_FLAGS>(0u);
-    core::bitflag<asset::E_ACCESS_FLAGS> dstAccessMask = static_cast<asset::E_ACCESS_FLAGS>(0u);
+    core::bitflag<asset::E_ACCESS_FLAGS> srcAccessMask = asset::EAF_NONE;
+    core::bitflag<asset::E_ACCESS_FLAGS> dstAccessMask = asset::EAF_NONE;
 };
 
 union SClearColorValue
@@ -352,9 +352,6 @@ class NBL_API ICommandBuffer
         return true;
     }
 
-    virtual bool regenerateMipmaps(image_t* imgview, uint32_t lastReadyMip, asset::IImage::E_ASPECT_FLAGS aspect) = 0;
-
-
 
 protected:
     ICommandBuffer(E_LEVEL lvl) : m_level(lvl) {}

include/nbl/asset/IImage.h

@@ -62,6 +62,7 @@ class NBL_API IImage : public IDescriptor
 	public:
 		enum E_ASPECT_FLAGS : uint16_t
 		{
+			EAF_NONE				= 0u,
 			EAF_COLOR_BIT			= 0x1u << 0u,
 			EAF_DEPTH_BIT			= 0x1u << 1u,
 			EAF_STENCIL_BIT			= 0x1u << 2u,
@@ -122,7 +123,7 @@ class NBL_API IImage : public IDescriptor
 		};
 		enum E_USAGE_FLAGS : uint16_t
 		{
-            EUF_NONE = 0x00000000,
+			EUF_NONE = 0x00000000,
 			EUF_TRANSFER_SRC_BIT = 0x00000001,
 			EUF_TRANSFER_DST_BIT = 0x00000002,
 			EUF_SAMPLED_BIT = 0x00000004,
@@ -136,15 +137,15 @@ class NBL_API IImage : public IDescriptor
 		};
 		struct SSubresourceRange
 		{
-			E_ASPECT_FLAGS	aspectMask = static_cast<E_ASPECT_FLAGS>(0u); // waits for vulkan
+			E_ASPECT_FLAGS	aspectMask = E_ASPECT_FLAGS::EAF_NONE;
 			uint32_t		baseMipLevel = 0u;
 			uint32_t		levelCount = 0u;
 			uint32_t		baseArrayLayer = 0u;
 			uint32_t		layerCount = 0u;
 		};
 		struct SSubresourceLayers
 		{
-			E_ASPECT_FLAGS	aspectMask = static_cast<E_ASPECT_FLAGS>(0u); // waits for vulkan
+			E_ASPECT_FLAGS	aspectMask = E_ASPECT_FLAGS::EAF_NONE;
 			uint32_t		mipLevel = 0u;
 			uint32_t		baseArrayLayer = 0u;
 			uint32_t		layerCount = 0u;
@@ -157,7 +158,7 @@ class NBL_API IImage : public IDescriptor
 			{
 				// TODO: more complex check of compatible aspects
 				// Image Extent must be a mutiple of texel block dims OR offset + extent = image subresourceDims
- 				// bufferOffset must be multiple of the compressed texel block size in bytes (matters in IGPU?)
+				// bufferOffset must be multiple of the compressed texel block size in bytes (matters in IGPU?)
 				// If planar subresource aspectMask should be PLANE_{0,1,2}
 				if (false)
 					return false;
@@ -189,7 +190,7 @@ class NBL_API IImage : public IDescriptor
 			{
 				return info.convert3DTexelStridesTo1DByteStrides(getTexelStrides());
 			}
-			static inline uint64_t				getLocalByteOffset(const core::vector3du32_SIMD& localXYZLayerOffset, const core::vector3du32_SIMD& byteStrides)
+			static inline uint64_t		getLocalByteOffset(const core::vector3du32_SIMD& localXYZLayerOffset, const core::vector3du32_SIMD& byteStrides)
 			{
 				return core::dot(localXYZLayerOffset,byteStrides)[0];
 			}
@@ -198,7 +199,6 @@ class NBL_API IImage : public IDescriptor
 				return bufferOffset+getLocalByteOffset(localXYZLayerOffset,byteStrides);
 			}
 
-
 			size_t				bufferOffset = 0ull;
 			// setting this to different from 0 can fail an image copy on OpenGL
 			uint32_t			bufferRowLength = 0u;
@@ -242,7 +242,7 @@ class NBL_API IImage : public IDescriptor
 			VkExtent3D									extent;
 			uint32_t									mipLevels;
 			uint32_t									arrayLayers;
-			E_CREATE_FLAGS								flags = ECF_NONE;
+			core::bitflag<E_CREATE_FLAGS>				flags = ECF_NONE;
 			core::bitflag<E_USAGE_FLAGS>				usage = EUF_NONE;
 
 			inline bool operator==(const SCreationParams& rhs) const
@@ -257,7 +257,7 @@ class NBL_API IImage : public IDescriptor
 					extent!=rhs.extent ||
 					mipLevels!=rhs.mipLevels ||
 					arrayLayers!=rhs.arrayLayers ||
-					flags!=rhs.flags ||
+					flags.value!=rhs.flags.value ||
 					usage.value!=rhs.usage.value;
 			}
 		};
@@ -283,7 +283,12 @@ class NBL_API IImage : public IDescriptor
 				default:
 					break;
 			}
-			return 1u + uint32_t(floorf(log2(float(maxSideLen))));
+			const uint32_t round = core::roundUpToPoT<uint32_t>(maxSideLen);
+			return core::findLSB(round);
+		}
+		inline static uint32_t calculateFullMipPyramidLevelCount(const VkExtent3D& extent, E_TYPE type)
+		{
+			return calculateMaxMipLevel(extent,type)+1u;
 		}
 
 		//!
@@ -319,7 +324,7 @@ class NBL_API IImage : public IDescriptor
 			if (core::bitCount(static_cast<uint32_t>(_params.samples))!=1u)
 				return false;
 
-			if (_params.flags & ECF_CUBE_COMPATIBLE_BIT)
+			if (_params.flags.hasFlags(ECF_CUBE_COMPATIBLE_BIT))
 			{
 				if (_params.type != ET_2D)
 					return false;
@@ -330,28 +335,28 @@ class NBL_API IImage : public IDescriptor
 				if (_params.samples != ESCF_1_BIT)
 					return false;
 			}
-			if ((_params.flags & ECF_2D_ARRAY_COMPATIBLE_BIT) && _params.type != ET_3D)
+			if (_params.flags.hasFlags(ECF_2D_ARRAY_COMPATIBLE_BIT) && _params.type != ET_3D)
 				return false;
-			if ((_params.flags & ECF_SPARSE_RESIDENCY_BIT) || (_params.flags & ECF_SPARSE_ALIASED_BIT))
+			if (_params.flags.hasFlags(ECF_SPARSE_RESIDENCY_BIT) || _params.flags.hasFlags(ECF_SPARSE_ALIASED_BIT))
 			{
-				if (!(_params.flags & ECF_SPARSE_BINDING_BIT))
+				if (!_params.flags.hasFlags(ECF_SPARSE_BINDING_BIT))
 					return false;
-				if (_params.flags & ECF_PROTECTED_BIT)
+				if (_params.flags.hasFlags(ECF_PROTECTED_BIT))
 					return false;
 			}
-			if ((_params.flags & ECF_SPARSE_BINDING_BIT) && (_params.flags & ECF_PROTECTED_BIT))
+			if (_params.flags.hasFlags(ECF_SPARSE_BINDING_BIT) && _params.flags.hasFlags(ECF_PROTECTED_BIT))
 				return false;
-			if (_params.flags & ECF_SPLIT_INSTANCE_BIND_REGIONS_BIT)
+			if (_params.flags.hasFlags(ECF_SPLIT_INSTANCE_BIND_REGIONS_BIT))
 			{
 				if (_params.mipLevels > 1u || _params.arrayLayers > 1u || _params.type != ET_2D)
 					return false;
 			}
-			if (_params.flags & ECF_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT)
+			if (_params.flags.hasFlags(ECF_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT))
 			{
-				if (!isBlockCompressionFormat(_params.format) || !(_params.flags & ECF_MUTABLE_FORMAT_BIT))
+				if (!isBlockCompressionFormat(_params.format) || !_params.flags.hasFlags(ECF_MUTABLE_FORMAT_BIT))
 					return false;
 			}
-			if ((_params.flags & ECF_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT) && (!isDepthOrStencilFormat(_params.format) || _params.format == EF_S8_UINT))
+			if (_params.flags.hasFlags(ECF_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT) && (!isDepthOrStencilFormat(_params.format) || _params.format == EF_S8_UINT))
 				return false;
 
 			if (_params.samples != ESCF_1_BIT && _params.type != ET_2D)
@@ -380,11 +385,11 @@ class NBL_API IImage : public IDescriptor
 			}
 			else
 			{
-				if (!(_params.flags & ECF_ALIAS_BIT) && (_params.flags & ECF_DISJOINT_BIT))
+				if (!_params.flags.hasFlags(ECF_ALIAS_BIT) && _params.flags.hasFlags(ECF_DISJOINT_BIT))
 					return false;
 			}
 
-			if (_params.mipLevels > calculateMaxMipLevel(_params.extent, _params.type))
+			if (_params.mipLevels > calculateFullMipPyramidLevelCount(_params.extent, _params.type))
 				return false;
 
 			return true;
@@ -538,7 +543,7 @@ class NBL_API IImage : public IDescriptor
 			EL_SHADING_RATE_OPTIMAL_NV = 1000164003,
 			EL_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT = 1000218000
 		};
-    protected:
+	protected:
 		IImage(const SCreationParams& _params) : m_creationParams(_params), info(_params.format) {}
 
 		virtual ~IImage() {}
@@ -582,6 +587,9 @@ class NBL_API IImage : public IDescriptor
 				const auto& subresource = it->getDstSubresource();
 				//if (!formatHasAspects(m_creationParams.format,subresource.aspectMask))
 					//return false;
+				// The aspectMask member of imageSubresource must only have a single bit set
+				if (!core::bitCount(static_cast<uint32_t>(subresource.aspectMask)) == 1u)
+					return false;
 				if (subresource.mipLevel >= m_creationParams.mipLevels)
 					return false;
 				if (subresource.baseArrayLayer+subresource.layerCount > m_creationParams.arrayLayers)