Created template findMSB and findLSB template specialization for every integer type

Author: Przemog1

include/nbl/asset/ICPUGraphicsPipeline.h

@@ -93,7 +93,7 @@ class ICPUGraphicsPipeline final : public ICPUPipeline<IGraphicsPipeline<ICPUPip
 
 		inline int8_t stageToIndex(const ICPUShader::E_SHADER_STAGE stage) const override
 		{
-			const auto stageIx = hlsl::findLSB(stage);
+			const auto stageIx = hlsl::findLSB(static_cast<std::underlying_type_t<ICPUShader::E_SHADER_STAGE>>(stage));
 			if (stageIx<0 || stageIx>=GRAPHICS_SHADER_STAGE_COUNT || hlsl::bitCount(stage)!=1)
 				return -1;
 			return stageIx;

include/nbl/asset/ICPURenderpassIndependentPipeline.h

@@ -91,14 +91,14 @@ class ICPURenderpassIndependentPipeline : public IRenderpassIndependentPipeline<
 		inline IShader::SSpecInfo<ICPUShader> getSpecInfo(const ICPUShader::E_SHADER_STAGE stage)
 		{
 			assert(isMutable());
-			const auto stageIx = hlsl::findLSB(stage);
+			const auto stageIx = hlsl::findLSB(static_cast<std::underlying_type_t<ICPUShader::E_SHADER_STAGE>>(stage));
 			if (stageIx<0 || stageIx>=GRAPHICS_SHADER_STAGE_COUNT || hlsl::bitCount(stage)!=1)
 				return {};
 			return m_infos[stageIx];
 		}
 		inline IShader::SSpecInfo<const ICPUShader> getSpecInfo(const ICPUShader::E_SHADER_STAGE stage) const
 		{
-			const auto stageIx = hlsl::findLSB(stage);
+			const auto stageIx = hlsl::findLSB(static_cast<std::underlying_type_t<ICPUShader::E_SHADER_STAGE>>(stage));
 			if (stageIx<0 || stageIx>=GRAPHICS_SHADER_STAGE_COUNT || hlsl::bitCount(stage)!=1)
 				return {};
 			return m_infos[stageIx];
@@ -110,7 +110,7 @@ class ICPURenderpassIndependentPipeline : public IRenderpassIndependentPipeline<
             if (specSize<0)
                 return false;
 			const auto stage = info.shader->getStage();
-			const auto stageIx = hlsl::findLSB(stage);
+			const auto stageIx = hlsl::findLSB(static_cast<std::underlying_type_t<ICPUShader::E_SHADER_STAGE>>(stage));
 			if (stageIx<0 || stageIx>=GRAPHICS_SHADER_STAGE_COUNT || hlsl::bitCount(stage)!=1)
 				return false;
 			m_infos[stageIx] = info;

include/nbl/builtin/hlsl/cpp_compat/impl/intrinsics_impl.hlsl

@@ -54,33 +54,8 @@ DEFINE_BUILTIN_VECTOR_SPECIALIZATION(float64_t, BUILTIN_VECTOR_SPECIALIZATION_RE
 #undef BUILTIN_VECTOR_SPECIALIZATION_RET_VAL
 #undef DEFINE_BUILTIN_VECTOR_SPECIALIZATION
 
-#ifdef __HLSL_VERSION
 template<typename Integer>
 struct find_msb_helper;
-#else
-// legacy code wouldn't work without it
-template<typename Integer>
-struct find_msb_helper
-{
-	static int findMSB(NBL_CONST_REF_ARG(Integer) val)
-	{
-		if (is_signed_v<Integer>)
-		{
-			// GLM accepts only integer types, so idea is to cast input to integer type
-			using as_int = typename integer_of_size<sizeof(Integer)>::type;
-			const as_int valAsInt = reinterpret_cast<const as_int&>(val);
-			return glm::findMSB(valAsInt);
-		}
-		else
-		{
-			// GLM accepts only integer types, so idea is to cast input to integer type
-			using as_uint = typename unsigned_integer_of_size<sizeof(Integer)>::type;
-			const as_uint valAsUnsignedInt = reinterpret_cast<const as_uint&>(val);
-			return glm::findMSB(valAsUnsignedInt);
-		}
-	}
-};
-#endif
 
 template<>
 struct find_msb_helper<uint32_t>
@@ -108,6 +83,50 @@ struct find_msb_helper<int32_t>
 	}
 };
 
+#define DEFINE_FIND_MSB_COMMON_SPECIALIZATION(INPUT_INTEGER_TYPE, INTEGER_TYPE)\
+template<>\
+struct find_msb_helper<INPUT_INTEGER_TYPE>\
+{\
+	static int32_t findMSB(NBL_CONST_REF_ARG(INPUT_INTEGER_TYPE) val)\
+	{\
+		return find_msb_helper<INTEGER_TYPE>::findMSB(val);\
+	}\
+};\
+
+DEFINE_FIND_MSB_COMMON_SPECIALIZATION(int16_t, int32_t)
+DEFINE_FIND_MSB_COMMON_SPECIALIZATION(uint16_t, uint32_t)
+#ifndef __HLSL_VERSION
+DEFINE_FIND_MSB_COMMON_SPECIALIZATION(int8_t, int32_t)
+DEFINE_FIND_MSB_COMMON_SPECIALIZATION(uint8_t, uint32_t)
+#endif
+
+template<>
+struct find_msb_helper<uint64_t>
+{
+	static int32_t findMSB(NBL_CONST_REF_ARG(uint64_t) val)
+	{
+#ifdef __HLSL_VERSION
+		const uint64_t lowBits = uint32_t(val);
+		const uint64_t highBits = uint32_t(val >> 32);
+
+		const int32_t lowMsb = findMSB(lowBits);
+		if (lowMsb == -1)
+		{
+			const uint64_t highBits = uint32_t(val >> 32);
+			const int32_t highMsb = findMSB(highBits);
+			if (highBits == -1)
+				return -1;
+			else
+				return 32 + highMsb;
+		}
+
+		return lowMsb;
+#else
+		return glm::findMSB(val);
+#endif
+	}
+};
+
 template<int N>
 struct find_msb_helper<vector<uint32_t, N> >
 {
@@ -134,42 +153,26 @@ struct find_msb_helper<vector<int32_t, N> >
 	}
 };
 
-#ifdef __HLSL_VERSION
 template<typename Integer>
 struct find_lsb_helper;
-#else
-// legacy code wouldn't work without it
-template<typename Integer>
-struct find_lsb_helper
+
+template<>
+struct find_lsb_helper<int32_t>
 {
-	static int32_t findLSB(NBL_CONST_REF_ARG(Integer) val)
+	static int32_t findLSB(NBL_CONST_REF_ARG(int32_t) val)
 	{
 #ifdef __HLSL_VERSION
 		return spirv::findILsb(val);
 #else
-		if (is_signed_v<Integer>)
-		{
-			// GLM accepts only integer types, so idea is to cast input to integer type
-			using as_int = typename integer_of_size<sizeof(Integer)>::type;
-			const as_int valAsInt = reinterpret_cast<const as_int&>(val);
-			return glm::findLSB(valAsInt);
-		}
-		else
-		{
-			// GLM accepts only integer types, so idea is to cast input to integer type
-			using as_uint = typename unsigned_integer_of_size<sizeof(Integer)>::type;
-			const as_uint valAsUnsignedInt = reinterpret_cast<const as_uint&>(val);
-			return glm::findLSB(valAsUnsignedInt);
-		}
+		return glm::findLSB(val);
 #endif
 	}
 };
-#endif
 
 template<>
-struct find_lsb_helper<int32_t>
+struct find_lsb_helper<uint32_t>
 {
-	static int32_t findLSB(NBL_CONST_REF_ARG(int32_t) val)
+	static int32_t findLSB(NBL_CONST_REF_ARG(uint32_t) val)
 	{
 #ifdef __HLSL_VERSION
 		return spirv::findILsb(val);
@@ -179,13 +182,44 @@ struct find_lsb_helper<int32_t>
 	}
 };
 
+#define DEFINE_FIND_LSB_COMMON_SPECIALIZATION(INPUT_INTEGER_TYPE, INTEGER_TYPE)\
+template<>\
+struct find_lsb_helper<INPUT_INTEGER_TYPE>\
+{\
+	static int32_t findLSB(NBL_CONST_REF_ARG(INPUT_INTEGER_TYPE) val)\
+	{\
+		return find_lsb_helper<INTEGER_TYPE>::findLSB(val);\
+	}\
+};\
+
+DEFINE_FIND_LSB_COMMON_SPECIALIZATION(int16_t, int32_t)
+DEFINE_FIND_LSB_COMMON_SPECIALIZATION(uint16_t, uint32_t)
+#ifndef __HLSL_VERSION
+DEFINE_FIND_LSB_COMMON_SPECIALIZATION(int8_t, int32_t)
+DEFINE_FIND_LSB_COMMON_SPECIALIZATION(uint8_t, uint32_t)
+#endif
+
 template<>
-struct find_lsb_helper<uint32_t>
+struct find_lsb_helper<uint64_t>
 {
-	static int32_t findLSB(NBL_CONST_REF_ARG(uint32_t) val)
+	static int32_t findLSB(NBL_CONST_REF_ARG(uint64_t) val)
 	{
 #ifdef __HLSL_VERSION
-		return spirv::findILsb(val);
+		const uint64_t lowBits = uint32_t(val);
+		const uint64_t highBits = uint32_t(val >> 32);
+
+		const int32_t lowLsb = findLSB(lowBits);
+		if (lowLsb == -1)
+		{
+			const uint64_t highBits = uint32_t(val >> 32);
+			const int32_t highLsb = findLSB(highBits);
+			if (highBits == -1)
+				return -1;
+			else
+				return 32 + highLsb;
+		}
+
+		return lowLsb;
 #else
 		return glm::findLSB(val);
 #endif

include/nbl/core/util/bitflag.h

@@ -5,6 +5,7 @@
 #define _NBL_CORE_C_BITFLAG_H_INCLUDED_
 
 #include "BuildConfigOptions.h"
+#include <nbl/builtin/hlsl/cpp_compat/intrinsics.hlsl>
 
 namespace nbl::core
 {
@@ -50,5 +51,29 @@ struct blake3_hasher::update_impl<core::bitflag<T>,Dummy>
 
 template<typename T>
 concept Bitflag = std::is_same_v<bitflag<typename T::enum_t>, T>;
+
+}
+
+namespace nbl::hlsl::cpp_compat_intrinsics_impl
+{
+	template<typename ENUM_TYPE>
+	struct find_lsb_helper<core::bitflag<ENUM_TYPE>>
+	{
+		static int32_t findLSB(NBL_CONST_REF_ARG(core::bitflag<ENUM_TYPE>) val)
+		{
+			using underlying_t = typename core::bitflag<ENUM_TYPE>::UNDERLYING_TYPE;
+			return find_lsb_helper<underlying_t>::findLSB(static_cast<underlying_t>(val.value));
+		}
+	};
+
+	template<typename ENUM_TYPE>
+	struct find_msb_helper<core::bitflag<ENUM_TYPE>>
+	{
+		static int32_t findMSB(NBL_CONST_REF_ARG(core::bitflag<ENUM_TYPE>) val)
+		{
+			using underlying_t = typename core::bitflag<ENUM_TYPE>::UNDERLYING_TYPE;
+			return find_msb_helper<underlying_t>::findMSB(static_cast<underlying_t>(val.value));
+		}
+	};
 }
 #endif

src/nbl/video/CVulkanGraphicsPipeline.h

@@ -19,7 +19,7 @@ class CVulkanGraphicsPipeline final : public IGPUGraphicsPipeline
 			for (const auto& info : params.shaders)
 			if (info.shader)
 			{
-				const auto stageIx = hlsl::findLSB(info.shader->getStage());
+                const auto stageIx = hlsl::findLSB(static_cast<std::underlying_type_t<asset::IShader::E_SHADER_STAGE>>(info.shader->getStage()));
 				m_shaders[stageIx] = core::smart_refctd_ptr<const CVulkanShader>(static_cast<const CVulkanShader*>(info.shader));
 			}
         }

src/nbl/video/utilities/CAssetConverter.cpp

@@ -1509,7 +1509,7 @@ class GetDependantVisit<ICPUComputePipeline> : public GetDependantVisitBase<ICPU
 		inline auto& getSpecInfo(const IShader::E_SHADER_STAGE stage)
 		{
 			assert(hlsl::bitCount(stage)==1);
-			return specInfo[hlsl::findLSB(stage)];
+			return specInfo[hlsl::findLSB(static_cast<std::underlying_type_t<IShader::E_SHADER_STAGE>>(stage))];
 		}
 
 		// ok to do non owning since some cache owns anyway
@@ -1557,7 +1557,7 @@ class GetDependantVisit<ICPUGraphicsPipeline> : public GetDependantVisitBase<ICP
 		inline auto& getSpecInfo(const IShader::E_SHADER_STAGE stage)
 		{
 			assert(hlsl::bitCount(stage)==1);
-			return specInfo[hlsl::findLSB(stage)];
+			return specInfo[hlsl::findLSB(static_cast<std::underlying_type_t<IShader::E_SHADER_STAGE>>(stage))];
 		}
 
 		// ok to do non owning since some cache owns anyway