Fix HLSL conversion warnings and integer conversion correctness

include/nbl/builtin/hlsl/algorithm.hlsl

@@ -135,9 +135,9 @@ struct bound_t
     bool compare(const typename Accessor::value_type lhs, const typename Accessor::value_type rhs)
     {
         if (IsUpper)
-            return !comp(rhs,lhs);
+            return !_static_cast<bool>(comp(rhs,lhs));
         else
-            return comp(lhs,rhs);
+            return _static_cast<bool>(comp(lhs,rhs));
     }
 
     void comp_step(NBL_REF_ARG(Accessor) accessor, const uint32_t testPoint, const uint32_t rightBegin)

include/nbl/builtin/hlsl/bda/__ptr.hlsl

@@ -68,12 +68,12 @@ struct __ptr
     __ptr operator+(int64_t i)
     {
         i *= sizeof(T);
-        return __ptr::create(spirv::bitcast<uint64_t>(addr)+i);
+        return __ptr::create(spirv::bitcast<uint64_t>(addr)+_static_cast<uint64_t>(i));
     }
     __ptr operator-(int64_t i)
     {
         i *= sizeof(T);
-        return __ptr::create(spirv::bitcast<uint64_t>(addr)-i);
+        return __ptr::create(spirv::bitcast<uint64_t>(addr)-_static_cast<uint64_t>(i));
     }
 };
 

include/nbl/builtin/hlsl/bda/bda_accessor.hlsl

@@ -45,35 +45,35 @@ struct BdaAccessor : impl::BdaAccessorBase
 
     T get(const uint64_t index)
     {
-        bda::__ptr<T> target = ptr + index;
+        bda::__ptr<T> target = ptr + _static_cast<int64_t>(index);
         return target.template deref().load();
     }
 
     void get(const uint64_t index, NBL_REF_ARG(T) value)
     {
-        bda::__ptr<T> target = ptr + index;
+        bda::__ptr<T> target = ptr + _static_cast<int64_t>(index);
         value = target.template deref().load();
     }
 
     void set(const uint64_t index, const T value)
     {
-        bda::__ptr<T> target = ptr + index;
+        bda::__ptr<T> target = ptr + _static_cast<int64_t>(index);
         return target.template deref().store(value);
     }
 
     template<typename S = T>
     enable_if_t<is_same_v<S,T> && is_integral<T>::value && (sizeof(T) == 4 || sizeof(T) == 8), T>
     atomicAdd(const uint64_t index, const T value)
     {
-        bda::__ptr<T> target = ptr + index;
+        bda::__ptr<T> target = ptr + _static_cast<int64_t>(index);
         return glsl::atomicAdd(target.template deref().ptr.value, value);
     }
 
     template<typename S = T>
     enable_if_t<is_same_v<S,T> && is_integral<T>::value && (sizeof(T) == 4 || sizeof(T) == 8), T>
     atomicSub(const uint64_t index, const T value)
     {
-        bda::__ptr<T> target = ptr + index;
+        bda::__ptr<T> target = ptr + _static_cast<int64_t>(index);
         return glsl::atomicSub(target.template deref().ptr.value, value);
     }
 
@@ -94,19 +94,19 @@ struct DoubleBdaAccessor : impl::BdaAccessorBase
 
     T get(const uint64_t index)
     {
-        bda::__ptr<T> target = inputPtr + index;
+        bda::__ptr<T> target = inputPtr + _static_cast<int64_t>(index);
         return target.template deref().load();
     }
 
     void get(const uint64_t index, NBL_REF_ARG(T) value)
     {
-        bda::__ptr<T> target = inputPtr + index;
+        bda::__ptr<T> target = inputPtr + _static_cast<int64_t>(index);
         value = target.template deref().load();
     }
 
     void set(const uint64_t index, const T value)
     {
-        bda::__ptr<T> target = outputPtr + index;
+        bda::__ptr<T> target = outputPtr + _static_cast<int64_t>(index);
         return target.template deref().store(value);
     }
 

include/nbl/builtin/hlsl/bxdf/base/cook_torrance_base.hlsl

@@ -43,7 +43,7 @@ struct quant_query_helper<N, F, false>
     template<class I, class C>
     static quant_query_type __call(NBL_CONST_REF_ARG(N) ndf, NBL_CONST_REF_ARG(F) fresnel, NBL_CONST_REF_ARG(I) interaction, NBL_CONST_REF_ARG(C) cache)
     {
-        typename N::scalar_type dummy;
+        typename N::scalar_type dummy = typename N::scalar_type(0);
         return ndf.template createQuantQuery<I,C>(interaction, cache, dummy);
     }
 };

include/nbl/builtin/hlsl/bxdf/common.hlsl

@@ -1171,11 +1171,14 @@ struct beta
 
 // currently throws a boost preprocess error, see: https://github.com/Devsh-Graphics-Programming/Nabla/issues/932
 // #ifdef __HLSL_VERSION
+        #pragma warning(suppress: 4068)
         #pragma dxc diagnostic push
+		#pragma warning(suppress: 4068)
 		#pragma dxc diagnostic ignored "-Wliteral-range"
 // #endif
 		const T thresholds[4] = { 0, 5e5, 1e6, 1e15 };	// threshold values gotten from testing when the function returns nan/inf/1
 // #ifdef __HLSL_VERSION
+        #pragma warning(suppress: 4068)
         #pragma dxc diagnostic pop
 // #endif
 		if (x+y > thresholds[mpl::find_lsb_v<sizeof(T)>])

include/nbl/builtin/hlsl/cpp_compat/truncate.hlsl

@@ -23,7 +23,7 @@ struct Truncate
 {
     NBL_CONSTEXPR_FUNC T operator()(NBL_CONST_REF_ARG(U) v)
     {
-        return T(v);
+        return _static_cast<T>(v);
     }
 };
 
@@ -36,7 +36,7 @@ struct Truncate<To, From NBL_PARTIAL_REQ_BOT(concepts::can_truncate_vector<To, F
         array_set<To, typename vector_traits<To>::scalar_type> setter;
         To output;
         [[unroll]]
-        for (int i = 0; i < vector_traits<To>::Dimension; ++i)
+        for (uint32_t i = 0; i < vector_traits<To>::Dimension; ++i)
             setter(output, i, getter(v, i));
         return output;
     }

include/nbl/builtin/hlsl/emulated/float64_t.hlsl

@@ -107,8 +107,8 @@ namespace hlsl
                         return bit_cast<this_t>(rhs.data);
                 }
 
-                const int lhsBiasedExp = ieee754::extractBiasedExponent(data);
-                const int rhsBiasedExp = ieee754::extractBiasedExponent(rhs.data);
+                const int lhsBiasedExp = _static_cast<int>(ieee754::extractBiasedExponent(data));
+                const int rhsBiasedExp = _static_cast<int>(ieee754::extractBiasedExponent(rhs.data));
 
                 uint64_t lhsSign = ieee754::extractSignPreserveBitPattern(data);
                 uint64_t rhsSign = ieee754::extractSignPreserveBitPattern(rhs.data);
@@ -138,7 +138,7 @@ namespace hlsl
                 const int expDiff = lhsBiasedExp - rhsBiasedExp;
 
                 int exp = max(lhsBiasedExp, rhsBiasedExp) - ieee754::traits<float64_t>::exponentBias;
-                const uint32_t shiftAmount = abs(expDiff);
+                const uint32_t shiftAmount = _static_cast<uint32_t>(abs(expDiff));
 
                 if (expDiff < 0)
                 {
@@ -244,8 +244,8 @@ namespace hlsl
 
                 this_t retval = this_t::create(0ull);
 
-                int lhsBiasedExp = ieee754::extractBiasedExponent(data);
-                int rhsBiasedExp = ieee754::extractBiasedExponent(rhs.data);
+                int lhsBiasedExp = _static_cast<int>(ieee754::extractBiasedExponent(data));
+                int rhsBiasedExp = _static_cast<int>(ieee754::extractBiasedExponent(rhs.data));
 
                 int exp = int(lhsBiasedExp + rhsBiasedExp) - ieee754::traits<float64_t>::exponentBias;
 
@@ -289,8 +289,8 @@ namespace hlsl
             {
                 const uint64_t sign = (data ^ rhs.data) & ieee754::traits<float64_t>::signMask;
 
-                int lhsBiasedExp = ieee754::extractBiasedExponent(data);
-                int rhsBiasedExp = ieee754::extractBiasedExponent(rhs.data);
+                int lhsBiasedExp = _static_cast<int>(ieee754::extractBiasedExponent(data));
+                int rhsBiasedExp = _static_cast<int>(ieee754::extractBiasedExponent(rhs.data));
 
                 if(!FastMath)
                 {
@@ -324,7 +324,7 @@ namespace hlsl
                 {
                     const int shiftAmount = 52 - msb;
                     assert(shiftAmount >= 0);
-                    mantissa <<= shiftAmount;
+                    mantissa <<= _static_cast<uint64_t>(shiftAmount);
                     exp -= shiftAmount;
                 }
 
@@ -478,7 +478,7 @@ NBL_CONSTEXPR_FUNC __VA_ARGS__ replaceBiasedExponent(__VA_ARGS__ x, typename uns
 template <>\
 NBL_CONSTEXPR_FUNC __VA_ARGS__ fastMulExp2(__VA_ARGS__ x, int n)\
 {\
-    return __VA_ARGS__(replaceBiasedExponent(x.data, extractBiasedExponent(x) + uint32_t(n)));\
+    return __VA_ARGS__(replaceBiasedExponent(x.data, extractBiasedExponent(x) + _static_cast<uint32_t>(n)));\
 }\
 \
 template <>\

include/nbl/builtin/hlsl/emulated/float64_t_impl.hlsl

@@ -59,10 +59,10 @@ inline uint64_t castFloat32ToStorageType(float32_t val)
         if (hlsl::isinf(val))
             return ieee754::traits<float64_t>::inf | sign;
         uint32_t asUint = ieee754::impl::bitCastToUintType(val);
-        const int f32BiasedExp = int(ieee754::extractBiasedExponent(val));
+        const int f32BiasedExp = _static_cast<int>(ieee754::extractBiasedExponent(val));
         if (f32BiasedExp == 0)
             return sign;
-        const uint64_t biasedExp = uint64_t(f32BiasedExp - ieee754::traits<float32_t>::exponentBias + ieee754::traits<float64_t>::exponentBias) << (ieee754::traits<float64_t>::mantissaBitCnt);
+        const uint64_t biasedExp = _static_cast<uint64_t>(f32BiasedExp - ieee754::traits<float32_t>::exponentBias + ieee754::traits<float64_t>::exponentBias) << (ieee754::traits<float64_t>::mantissaBitCnt);
         const uint64_t mantissa = (uint64_t(ieee754::traits<float32_t>::mantissaMask) & asUint) << (ieee754::traits<float64_t>::mantissaBitCnt - ieee754::traits<float32_t>::mantissaBitCnt);
 
         return sign | biasedExp | mantissa;
@@ -85,55 +85,34 @@ inline uint64_t reinterpretAsFloat64BitPattern(T);
 template<>
 inline uint64_t reinterpretAsFloat64BitPattern<uint64_t>(uint64_t val)
 {
-    if (isZero(val))
+    if (val == 0ull)
         return val;
 
-    int exp = findMSB(val);
+    const int exp = findMSB(val);
     uint64_t mantissa;
 
-    int shiftCnt = 52 - exp;
+    const int shiftCnt = 52 - exp;
     if (shiftCnt >= 0)
     {
-        mantissa = val << shiftCnt;
+        mantissa = val << _static_cast<uint64_t>(shiftCnt);
     }
     else
     {
-        const int shiftCntAbs = -shiftCnt;
-        uint64_t roundingBit = 1ull << (shiftCnt - 1);
-        uint64_t stickyBitMask = roundingBit - 1;
-        uint64_t stickyBit = val & stickyBitMask;
-
-        mantissa = val >> shiftCntAbs;
-
-        if ((val & roundingBit) && (!stickyBit))
-        {
-            bool isEven = mantissa & 1;
-            if (!isEven)
-                mantissa++;
-        }
-        else if ((val & roundingBit) && (stickyBit || (mantissa & 1)))
-            val += roundingBit;
-
-        //val += (1ull << (shiftCnt)) - 1;
-        //mantissa = val >> shiftCntAbs;
-
-        if (mantissa & 1ull << 53)
-        {
-            mantissa >>= 1;
-            exp++;
-        }
+        // Integer conversions use the same round-toward-zero mode as arithmetic.
+        mantissa = val >> _static_cast<uint64_t>(-shiftCnt);
     }
     mantissa &= ieee754::traits<float64_t>::mantissaMask;
-    const uint64_t biasedExp = uint64_t(ieee754::traits<float64_t>::exponentBias + exp) << ieee754::traits<float64_t>::mantissaBitCnt;
+    const uint64_t biasedExp = _static_cast<uint64_t>(ieee754::traits<float64_t>::exponentBias + exp) << ieee754::traits<float64_t>::mantissaBitCnt;
 
     return biasedExp | mantissa;
 };
 
 template<>
 inline uint64_t reinterpretAsFloat64BitPattern<int64_t>(int64_t val)
 {
-    const uint64_t sign = val & ieee754::traits<float64_t>::signMask;
-    const uint64_t absVal = uint64_t(abs(val));
+    const uint64_t bits = _static_cast<uint64_t>(val);
+    const uint64_t sign = bits & ieee754::traits<float64_t>::signMask;
+    const uint64_t absVal = val < 0 ? 0ull - bits : bits;
     return sign | reinterpretAsFloat64BitPattern(absVal);
 };
 
@@ -297,8 +276,8 @@ inline uint64_t subMantissas128NormalizeResult(const uint64_t greaterNumberManti
     if (shiftAmount < 0)
     {
         shiftAmount = -shiftAmount;
-        diffHigh <<= shiftAmount;
-        const uint64_t shiftedOutBits = diffLow >> (64 - shiftAmount);
+        diffHigh <<= _static_cast<uint64_t>(shiftAmount);
+        const uint64_t shiftedOutBits = diffLow >> _static_cast<uint64_t>(64 - shiftAmount);
         diffHigh |= shiftedOutBits;
     }
 
@@ -308,4 +287,4 @@ inline uint64_t subMantissas128NormalizeResult(const uint64_t greaterNumberManti
 }
 }
 }
-#endif
+#endif

include/nbl/builtin/hlsl/emulated/int64_t.hlsl

@@ -259,8 +259,11 @@ struct arithmetic_right_shift_operator<emulated_int64_t>
     {
         const bool bigShift = bits >= ComponentBitWidth; // Shift that completely rewrites MSB
         const uint32_t shift = bigShift ? bits - ComponentBitWidth : ComponentBitWidth - bits;
-        const type_t shifted = type_t::create(bigShift ? vector<uint32_t, 2>(uint32_t(int32_t(operand.__getMSB()) >> shift), int32_t(operand.__getMSB()) < 0 ? ~uint32_t(0) : uint32_t(0))
-                                                                        : vector<uint32_t, 2>((operand.__getMSB() << shift) | (operand.__getLSB() >> bits), uint32_t(int32_t(operand.__getMSB()) >> bits)));
+        const int32_t msbSigned = _static_cast<int32_t>(operand.__getMSB());
+        const int32_t shiftSigned = _static_cast<int32_t>(shift);
+        const int32_t bitsSigned = _static_cast<int32_t>(bits);
+        const type_t shifted = type_t::create(bigShift ? vector<uint32_t, 2>(_static_cast<uint32_t>(msbSigned >> shiftSigned), msbSigned < 0 ? ~uint32_t(0) : uint32_t(0))
+                                                                        : vector<uint32_t, 2>((operand.__getMSB() << shift) | (operand.__getLSB() >> bits), _static_cast<uint32_t>(msbSigned >> bitsSigned)));
         return select<type_t, bool>(bool(bits), shifted, operand);
     }
 
@@ -382,27 +385,21 @@ NBL_CONSTEXPR_INLINE_NSPC_SCOPE_VAR emulated_int64_t minus_assign<emulated_int64
 } //namespace nbl
 } //namespace hlsl
 
-// Declare them as signed/unsigned versions of each other
-
-#ifndef __HLSL_VERSION
-#define NBL_ADD_STD std::
-#else 
-#define NBL_ADD_STD nbl::hlsl:: 
-#endif
+// Declare them as signed/unsigned versions of each other.
+// Specialize Nabla's traits; std::make_unsigned/make_signed do not permit
+// user specializations (N5014 [meta.rqmts]/4).
 
 template<>
-struct NBL_ADD_STD make_unsigned<nbl::hlsl::emulated_uint64_t> : type_identity<nbl::hlsl::emulated_uint64_t> {};
+struct nbl::hlsl::make_unsigned<nbl::hlsl::emulated_uint64_t> : type_identity<nbl::hlsl::emulated_uint64_t> {};
 
 template<>
-struct NBL_ADD_STD make_unsigned<nbl::hlsl::emulated_int64_t> : type_identity<nbl::hlsl::emulated_uint64_t> {};
+struct nbl::hlsl::make_unsigned<nbl::hlsl::emulated_int64_t> : type_identity<nbl::hlsl::emulated_uint64_t> {};
 
 template<>
-struct NBL_ADD_STD make_signed<nbl::hlsl::emulated_uint64_t> : type_identity<nbl::hlsl::emulated_int64_t> {};
+struct nbl::hlsl::make_signed<nbl::hlsl::emulated_uint64_t> : type_identity<nbl::hlsl::emulated_int64_t> {};
 
 template<>
-struct NBL_ADD_STD make_signed<nbl::hlsl::emulated_int64_t> : type_identity<nbl::hlsl::emulated_int64_t> {};
-
-#undef NBL_ADD_STD
+struct nbl::hlsl::make_signed<nbl::hlsl::emulated_int64_t> : type_identity<nbl::hlsl::emulated_int64_t> {};
 
 
 

include/nbl/builtin/hlsl/emulated/vector_t.hlsl

@@ -546,7 +546,7 @@ struct static_cast_helper<vector<ToComponentType, N>, emulated_vector_t<FromComp
 
         OutputVecType output;
         [[unroll]]
-        for (int i = 0; i < N; ++i)
+        for (uint32_t i = 0; i < N; ++i)
             setter(output, i, _static_cast<ToComponentType>(getter(vec, i)));
 
         return output;
@@ -564,7 +564,7 @@ struct static_cast_helper<emulated_vector_t##N <ToComponentType>, emulated_vecto
         array_set<OutputVecType, ToComponentType> setter;\
         OutputVecType output;\
         [[unroll]]\
-        for (int i = 0; i < N; ++i)\
+        for (uint32_t i = 0; i < N; ++i)\
             setter(output, i, _static_cast<ToComponentType>(getter(vec, i)));\
         return output;\
     }\

include/nbl/builtin/hlsl/format/shared_exp.hlsl

@@ -184,12 +184,15 @@ struct static_cast_helper<
             mantissaShifts[i] = min(clampedSharedExponentDecBias+uint16_t(-limits_t::min_exponent)-exponentsDecBias[i],uint16_t(numeric_limits<decode_t>::digits));
 
         // finally lets re-bias our exponent (it will always be positive), note the -1 because IEEE754 floats reserve the lowest exponent values for denorm
-        const uint16_t sharedExponentEncBias = int16_t(clampedSharedExponentDecBias+int16_t(-limits_t::min_exponent))-uint16_t(1-numeric_limits<decode_t>::min_exponent);
+        const int16_t biasOffset = _static_cast<int16_t>(-limits_t::min_exponent);
+        const int16_t encBiasSigned = _static_cast<int16_t>(clampedSharedExponentDecBias) + biasOffset;
+        const int16_t finalBias = _static_cast<int16_t>(1 - numeric_limits<decode_t>::min_exponent);
+        const uint16_t sharedExponentEncBias = _static_cast<uint16_t>(encBiasSigned - finalBias);
 
         //
         T retval;
         retval.storage = storage_t(sharedExponentEncBias)<<(limits_t::digits*3);
-        const decode_bits_t dec_MantissaMask = (decode_bits_t(1)<<dec_MantissaStoredBits)-1;
+        const decode_bits_t dec_MantissaMask = (decode_bits_t(1)<<dec_MantissaStoredBits)-1u;
         for (uint16_t i=0; i<_Components; i++)
         {
             decode_bits_t origBitPattern = bit_cast<decode_bits_t>(val[i])&dec_MantissaMask;
@@ -201,7 +204,7 @@ struct static_cast_helper<
         if (limits_t::is_signed)
         {
             // doing ops on smaller integers is faster
-            decode_bits_t SignMask = 0x1<<(sizeof(decode_t)*8-1);
+            decode_bits_t SignMask = 0x1u<<(sizeof(decode_t)*8-1);
             decode_bits_t signs = bit_cast<decode_bits_t>(val[0])&SignMask;
             for (uint16_t i=1; i<_Components; i++)
                 signs |= (bit_cast<decode_bits_t>(val[i])&SignMask)>>i;