@babylonjs/react-native 2.0.0 → 2.0.1

package/shared/BabylonNative/deps/bgfx.cmake-src/bx/src/string.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2025 Branimir Karadzic. All rights reserved.
+ * Copyright 2010-2026 Branimir Karadzic. All rights reserved.
  * License: https://github.com/bkaradzic/bx/blob/master/LICENSE
  */
 
@@ -165,7 +165,7 @@ namespace bx
 
 	typedef char (*CharFn)(char _ch);
 
-	inline char toNoop(char _ch)
+	inline constexpr char toNoop(char _ch)
 	{
 		return _ch;
 	}
@@ -290,18 +290,6 @@ namespace bx
 			);
 	}
 
-	int32_t strLen(const char* _str, int32_t _max)
-	{
-		if (NULL == _str)
-		{
-			return 0;
-		}
-
-		const char* ptr = _str;
-		for (; 0 < _max && *ptr != '\0'; ++ptr, --_max) {};
-		return int32_t(ptr - _str);
-	}
-
 	inline int32_t strCopy(char* _dst, int32_t _dstSize, const char* _src, int32_t _num)
 	{
 		BX_ASSERT(NULL != _dst, "_dst can't be NULL!");
@@ -734,11 +722,13 @@ namespace bx
 				, base(10)
 				, prec(INT32_MAX)
 				, fill(' ')
+				, fmt('f')
 				, bits(0)
 				, left(false)
 				, upper(false)
 				, spec(false)
 				, sign(false)
+				, space(false)
 			{
 			}
 
@@ -746,11 +736,13 @@ namespace bx
 			int32_t base;
 			int32_t prec;
 			char    fill;
+			char    fmt;
 			uint8_t bits;
 			bool    left;
 			bool    upper;
 			bool    spec;
 			bool    sign;
+			bool    space;
 		};
 
 		static int32_t write(WriterI* _writer, const char* _str, int32_t _len, const Param& _param, Error* _err)
@@ -758,14 +750,12 @@ namespace bx
 			int32_t size = 0;
 			int32_t len = (int32_t)strLen(_str, _len);
 
-			if (_param.width > 0)
-			{
-				len = min(_param.width, len);
-			}
-
 			const bool hasMinus = (NULL != _str && '-' == _str[0]);
-			const bool hasSign = _param.sign || hasMinus;
-			char sign = hasSign ? hasMinus ? '-' : '+' : '\0';
+			const bool hasSign = _param.sign || _param.space || hasMinus;
+			char sign = '\0';
+			if      (hasMinus)     { sign = '-'; }
+			else if (_param.sign)  { sign = '+'; }
+			else if (_param.space) { sign = ' '; }
 
 			const char* str = _str;
 			if (hasMinus)
@@ -849,6 +839,64 @@ namespace bx
 			return write(_writer, _str.getPtr(), min(_param.prec, _str.getLength() ), _param, _err);
 		}
 
+		static int32_t writeInteger(WriterI* _writer, const char* _str, int32_t _len, const Param& _param, Error* _err)
+		{
+			Param param = _param;
+
+			char str[64];
+			memCopy(str, _str, _len + 1);
+
+			int32_t len = _len;
+
+			if (param.prec != INT32_MAX)
+			{
+				param.fill = ' ';
+
+				const int32_t signLen = (len > 0 && '-' == str[0]) ? 1 : 0;
+				const int32_t digitLen = len - signLen;
+
+				if (param.prec > digitLen)
+				{
+					const int32_t zeros = min(param.prec - digitLen, int32_t(sizeof(str)) - len - 1);
+					memMove(&str[signLen + zeros], &str[signLen], digitLen + 1);
+
+					for (int32_t ii = 0; ii < zeros; ++ii)
+					{
+						str[signLen + ii] = '0';
+					}
+
+					len += zeros;
+				}
+
+				param.prec = INT32_MAX;
+			}
+
+			if (param.spec
+			&&  0 < len)
+			{
+				if (8 == param.base)
+				{
+					if (str[0] != '0')
+					{
+						memMove(&str[1], &str[0], len + 1);
+						str[0] = '0';
+						len++;
+					}
+				}
+				else if (16 == param.base)
+				{
+					memMove(&str[2], &str[0], len + 1);
+					str[0] = '0';
+					str[1] = param.upper ? 'X' : 'x';
+					len += 2;
+				}
+
+				param.spec = false;
+			}
+
+			return write(_writer, str, len, param, _err);
+		}
+
 		static int32_t write(WriterI* _writer, int32_t _i, const Param& _param, Error* _err)
 		{
 			char str[33];
@@ -859,7 +907,14 @@ namespace bx
 				return 0;
 			}
 
-			return write(_writer, str, len, _param, _err);
+			if (0 == _param.prec
+			&&  0 == _i)
+			{
+				str[0] = '\0';
+				len = 0;
+			}
+
+			return writeInteger(_writer, str, len, _param, _err);
 		}
 
 		static int32_t write(WriterI* _writer, int64_t _i, const Param& _param, Error* _err)
@@ -872,7 +927,14 @@ namespace bx
 				return 0;
 			}
 
-			return write(_writer, str, len, _param, _err);
+			if (0 == _param.prec
+			&&  0 == _i)
+			{
+				str[0] = '\0';
+				len = 0;
+			}
+
+			return writeInteger(_writer, str, len, _param, _err);
 		}
 
 		static int32_t write(WriterI* _writer, uint32_t _u, const Param& _param, Error* _err)
@@ -885,7 +947,14 @@ namespace bx
 				return 0;
 			}
 
-			return write(_writer, str, len, _param, _err);
+			if (0 == _param.prec
+			&&  0 == _u)
+			{
+				str[0] = '\0';
+				len = 0;
+			}
+
+			return writeInteger(_writer, str, len, _param, _err);
 		}
 
 		static int32_t write(WriterI* _writer, uint64_t _u, const Param& _param, Error* _err)
@@ -898,7 +967,14 @@ namespace bx
 				return 0;
 			}
 
-			return write(_writer, str, len, _param, _err);
+			if (0 == _param.prec
+			&&  0 == _u)
+			{
+				str[0] = '\0';
+				len = 0;
+			}
+
+			return writeInteger(_writer, str, len, _param, _err);
 		}
 
 		static int32_t write(WriterI* _writer, double _d, const Param& _param, Error* _err)
@@ -914,7 +990,9 @@ namespace bx
 			const char* dot = strFind(str, INT32_MAX, '.');
 			if (NULL != dot)
 			{
-				const int32_t prec   = INT32_MAX == _param.prec ? 6 : _param.prec;
+				const int32_t defaultPrec = ('g' == _param.fmt) ? 6 : 6;
+				int32_t prec = INT32_MAX == _param.prec ? defaultPrec : _param.prec;
+
 				const char* strEnd   = str + len;
 				const char* exponent = strFind(str, INT32_MAX, 'e');
 				const char* fracEnd  = NULL != exponent ? exponent : strEnd;
@@ -1004,11 +1082,11 @@ namespace bx
 					switch (ch)
 					{
 						default:
-						case ' ': param.fill = ' ';  break;
-						case '-': param.left = true; break;
-						case '+': param.sign = true; break;
-						case '0': param.fill = '0';  break;
-						case '#': param.spec = true; break;
+						case ' ': param.space = true; break;
+						case '-': param.left  = true; break;
+						case '+': param.sign  = true; break;
+						case '0': param.fill  = '0';  break;
+						case '#': param.spec  = true; break;
 					}
 
 					read(&reader, ch, &err);
@@ -1055,7 +1133,8 @@ namespace bx
 					if ('*' == ch)
 					{
 						read(&reader, ch, &err);
-						param.prec = va_arg(_argList, int32_t);
+						int32_t prec = va_arg(_argList, int32_t);
+						param.prec = prec >= 0 ? prec : INT32_MAX;
 					}
 					else
 					{
@@ -1162,10 +1241,11 @@ namespace bx
 						};
 						break;
 
-					case 'e': case 'E':
+						case 'e': case 'E':
 					case 'f': case 'F':
 					case 'g': case 'G':
 						param.upper = isUpper(ch);
+						param.fmt = toLower(ch);
 						size += write(_writer, va_arg(_argList, double), param, _err);
 						break;
 
@@ -1292,36 +1372,113 @@ namespace bx
 		return total;
 	}
 
-	static const char s_units[] = { 'B', 'k', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y' };
+	int32_t formatHumanNumber(char* _out, uint32_t _count, double _value, uint8_t _numFrac, const StringView& _unit, char _prefix)
+	{
+		char temp[64];
+		int32_t len = snprintf(temp, sizeof(temp), "%.*f", _numFrac, _value);
+		int32_t intPartLen = len;
+
+		if (len >= _numFrac+1
+		&&  '.' == temp[len-_numFrac-1])
+		{
+			intPartLen = len-_numFrac-1;
+
+			bool zero = true;
+
+			for (int32_t ii = _numFrac; 0 < ii && zero; --ii)
+			{
+				zero &= temp[len-ii] == '0';
+			}
+
+			if (zero)
+			{
+				temp[len-_numFrac-1] = '\0';
+				len = intPartLen;
+			}
+		}
+
+		const int32_t fracPartLen = len - intPartLen;
+		const int32_t commas      = (intPartLen > 3) ? (intPartLen - 1) / 3 : 0;
+		const int32_t total       = intPartLen + fracPartLen + commas;
+
+		if (_count < uint32_t(total) )
+		{
+			if (0 < _count)
+			{
+				_out[0] = '\0';
+			}
+
+			return 0;
+		}
 
-	template<uint32_t Kilo, char KiloCh0, char KiloCh1, CharFn fn>
-	inline int32_t prettify(char* _out, int32_t _count, uint64_t _value)
+		char* out = _out + total;
+		if (_unit.isEmpty()
+		&&  ' ' == _prefix)
+		{
+			*out = '\0';
+		}
+		else
+		{
+			snprintf(out, _count - total, " %c%S", _prefix, &_unit);
+		}
+
+		if (0 != fracPartLen)
+		{
+			out -= fracPartLen;
+			memCopy(out, &temp[intPartLen], fracPartLen);
+		}
+
+		int32_t group = 0;
+		for (int32_t ii = intPartLen - 1; ii >= 0; --ii)
+		{
+			*--out = temp[ii];
+
+			if (3 == ++group
+			&&  0  < ii)
+			{
+				*--out = ',';
+				group = 0;
+			}
+		}
+
+		return total;
+	}
+
+	int32_t formatHumanNumber(char* _out, uint32_t _count, double _value, uint8_t _numFrac, double _unitStep, const StringView& _unit, const StringView& _prefix, uint8_t _basePrefix)
 	{
-		uint8_t idx = 0;
+		uint8_t idx = _basePrefix;
 		double value = double(_value);
-		while (_value != (_value&0x7ff)
-		&&     idx < BX_COUNTOF(s_units) )
+		const double invUnitStep = 1.0/double(_unitStep);
+		const uint8_t numPrefixes = narrowCast<uint8_t>(_prefix.getLength() );
+
+		if (0.0 != _value)
 		{
-			_value /= Kilo;
-			value  *= 1.0/double(Kilo);
-			++idx;
+			while (value >= _unitStep
+				&& idx < numPrefixes)
+			{
+				value *= invUnitStep;
+				++idx;
+			}
+
+			while (value < 1.0
+				&& idx > 0)
+			{
+				value *= _unitStep;
+				--idx;
+			}
 		}
 
-		return snprintf(_out, _count, "%0.2f %c%c%c", value
-			, fn(s_units[idx])
-			, idx > 0 ? KiloCh0 : '\0'
-			, KiloCh1
-			);
+		return formatHumanNumber(_out, _count, value, _numFrac, 0 == idx ? "" : _unit, _prefix.getPtr()[idx]);
 	}
 
 	int32_t prettify(char* _out, int32_t _count, uint64_t _value, Units::Enum _units)
 	{
 		if (Units::Kilo == _units)
 		{
-			return prettify<1000, 'B', '\0', toNoop>(_out, _count, _value);
+			return formatHumanNumber(_out, _count, double(_value), 0, 1000.0, "B", "BkMGTPEZY");
 		}
 
-		return prettify<1024, 'i', 'B', toUpper>(_out, _count, _value);
+		return formatHumanNumber(_out, _count, double(_value), 0, 1024.0, "iB", "BKMGTPEZY");
 	}
 
 } // namespace bx

package/shared/BabylonNative/deps/bgfx.cmake-src/bx/src/thread.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2025 Branimir Karadzic. All rights reserved.
+ * Copyright 2010-2026 Branimir Karadzic. All rights reserved.
  * License: https://github.com/bkaradzic/bx/blob/master/LICENSE
  */
 
@@ -109,23 +109,14 @@ namespace bx
 		}
 	}
 
-	bool Thread::init(ThreadFn _fn, void* _userData, uint32_t _stackSize, const char* _name)
+	bool Thread::init(ThreadFn _fn, void* _userData, uint32_t _stackSize, const StringView& _name)
 	{
 		BX_ASSERT(!m_running, "Already running!");
 
-		m_fn = _fn;
-		m_userData = _userData;
+		m_fn        = _fn;
+		m_userData  = _userData;
 		m_stackSize = _stackSize;
-
-		if (NULL != _name)
-		{
-			BX_WARN(strLen(_name) < int32_t(BX_COUNTOF(m_name) )-1, "Truncating thread name.");
-			strCopy(m_name, BX_COUNTOF(m_name), _name);
-		}
-		else
-		{
-			m_name[0] = '\0';
-		}
+		m_name      = _name;
 
 		ThreadInternal* ti = (ThreadInternal*)m_internal;
 #if BX_CRT_NONE
@@ -223,33 +214,40 @@ namespace bx
 		return m_exitCode;
 	}
 
-	void Thread::setThreadName(const char* _name)
+	void Thread::setThreadName(const StringView& _name)
 	{
+		if (_name.isEmpty() )
+		{
+			return;
+		}
+
+		m_name = _name;
+
 		ThreadInternal* ti = (ThreadInternal*)m_internal;
 		BX_UNUSED(ti);
-#if BX_CRT_NONE
-		BX_UNUSED(_name);
-#elif  BX_PLATFORM_OSX \
-	|| BX_PLATFORM_IOS   \
+#if  BX_PLATFORM_OSX   \
+	|| BX_PLATFORM_IOS \
 	|| BX_PLATFORM_VISIONOS
-		pthread_setname_np(_name);
+		pthread_setname_np(m_name.getCPtr() );
 #elif BX_CRT_GLIBC
-		pthread_setname_np(ti->m_handle, _name);
+		pthread_setname_np(ti->m_handle, m_name.getCPtr() );
 #elif BX_PLATFORM_LINUX
-		prctl(PR_SET_NAME,_name, 0, 0, 0);
+		prctl(PR_SET_NAME, m_name.getCPtr(), 0, 0, 0);
 #elif BX_PLATFORM_WINDOWS
-		// Try to use the new thread naming API from Win10 Creators update onwards if we have it
-		typedef HRESULT (WINAPI *SetThreadDescriptionProc)(HANDLE, PCWSTR);
-		SetThreadDescriptionProc SetThreadDescription = dlsym<SetThreadDescriptionProc>((void*)GetModuleHandleA("Kernel32.dll"), "SetThreadDescription");
+		typedef HRESULT (WINAPI *SetThreadDescriptionFn)(HANDLE, PCWSTR);
+		SetThreadDescriptionFn setThreadDescription = dlsym<SetThreadDescriptionFn>( (void*)GetModuleHandleA("kernel32.dll"), "SetThreadDescription");
 
-		if (NULL != SetThreadDescription)
+		if (NULL != setThreadDescription)
 		{
-			uint32_t length = (uint32_t)strLen(_name)+1;
-			uint32_t size = length*sizeof(wchar_t);
-			wchar_t* name = (wchar_t*)BX_STACK_ALLOC(size);
-			mbstowcs(name, _name, size-2);
-			SetThreadDescription(ti->m_handle, name);
+			const uint32_t length = m_name.getLength();
+			const uint32_t max    = (length+1)*sizeof(wchar_t);
+			wchar_t* name = (wchar_t*)BX_STACK_ALLOC(max);
+			mbstowcs(name, m_name.getCPtr(), length);
+			name[length] = 0;
+			setThreadDescription(ti->m_handle, name);
 		}
+		else
+		{
 #	if BX_COMPILER_MSVC
 #		pragma pack(push, 8)
 			struct ThreadName
@@ -262,24 +260,23 @@ namespace bx
 #		pragma pack(pop)
 			ThreadName tn;
 			tn.type  = 0x1000;
-			tn.name  = _name;
+			tn.name  = m_name.getCPtr();
 			tn.id    = ti->m_threadId;
 			tn.flags = 0;
 
 			__try
 			{
 				RaiseException(0x406d1388
-						, 0
-						, sizeof(tn)/4
-						, reinterpret_cast<ULONG_PTR*>(&tn)
-						);
+					, 0
+					, sizeof(tn)/4
+					, reinterpret_cast<ULONG_PTR*>(&tn)
+					);
 			}
 			__except(EXCEPTION_EXECUTE_HANDLER)
 			{
 			}
 #	endif // BX_COMPILER_MSVC
-#else
-		BX_UNUSED(_name);
+		}
 #endif // BX_PLATFORM_
 	}
 

package/shared/BabylonNative/deps/bgfx.cmake-src/bx/src/timer.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2025 Branimir Karadzic. All rights reserved.
+ * Copyright 2010-2026 Branimir Karadzic. All rights reserved.
  * License: https://github.com/bkaradzic/bx/blob/master/LICENSE
  */
 
@@ -68,4 +68,8 @@ namespace bx
 #endif // BX_PLATFORM_
 	}
 
+	const Ticks  Ticks::s_kStartup = getNow();
+	const Ticks  Ticks::s_kFreq    = Ticks(getHPFrequency() );
+	const double Ticks::s_kInvFreq = 1.0/double(Ticks::s_kFreq.ticks); 
+
 } // namespace bx

package/shared/BabylonNative/deps/bgfx.cmake-src/bx/src/url.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2025 Branimir Karadzic. All rights reserved.
+ * Copyright 2011-2026 Branimir Karadzic. All rights reserved.
  * License: https://github.com/bkaradzic/bnet#license-bsd-2-clause
  */
 

package/shared/BabylonNative/deps/bgfx.cmake-src/bx/tests/allocator_test.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2025 Branimir Karadzic. All rights reserved.
+ * Copyright 2010-2026 Branimir Karadzic. All rights reserved.
  * License: https://github.com/bkaradzic/bx/blob/master/LICENSE
  */
 

package/shared/BabylonNative/deps/bgfx.cmake-src/bx/tests/atomic_test.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2025 Branimir Karadzic. All rights reserved.
+ * Copyright 2010-2026 Branimir Karadzic. All rights reserved.
  * License: https://github.com/bkaradzic/bx/blob/master/LICENSE
  */
 

package/shared/BabylonNative/deps/bgfx.cmake-src/bx/tests/cast_test.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2025 Branimir Karadzic. All rights reserved.
+ * Copyright 2010-2026 Branimir Karadzic. All rights reserved.
  * License: https://github.com/bkaradzic/bx/blob/master/LICENSE
  */
 
@@ -21,3 +21,101 @@ TEST_CASE("Narrow cast", "[cast]")
 	REQUIRE_ASSERTS(bx::narrowCast<int8_t>(uint32_t(128) ) );
 	REQUIRE(128 == bx::narrowCast<uint8_t>(int32_t(128) ) );
 }
+
+template<typename Ty, typename FromT>
+inline constexpr bool saturateCastTest(Ty _expectedMin, Ty _expectedMax)
+{
+	return true
+		&& _expectedMin == bx::saturateCast<Ty>(static_cast<FromT>(_expectedMin) )
+		&& _expectedMax == bx::saturateCast<Ty>(static_cast<FromT>(_expectedMax) )
+		;
+}
+
+TEST_CASE("Saturate cast", "[cast]")
+{
+	STATIC_REQUIRE(-128 == bx::saturateCast<int8_t >( int32_t(       -255) ) );
+	STATIC_REQUIRE( 127 == bx::saturateCast<int8_t >( int32_t(        255) ) );
+	STATIC_REQUIRE( 127 == bx::saturateCast<int8_t >( int32_t(        127) ) );
+	STATIC_REQUIRE( 127 == bx::saturateCast<int8_t >( int32_t(        128) ) );
+	STATIC_REQUIRE( 127 == bx::saturateCast<int8_t >(uint32_t(        128) ) );
+	STATIC_REQUIRE(-128 == bx::saturateCast<int8_t >(   float(-1389.9831f) ) );
+	STATIC_REQUIRE( 127 == bx::saturateCast<int8_t >(   float( 1389.9831f) ) );
+	STATIC_REQUIRE(   0 == bx::saturateCast<uint8_t>( int32_t(       -128) ) );
+	STATIC_REQUIRE( 128 == bx::saturateCast<uint8_t>( int32_t(        128) ) );
+	STATIC_REQUIRE( -13 == bx::saturateCast<int8_t >(   float(    -13.89f) ) );
+	STATIC_REQUIRE(  13 == bx::saturateCast<int8_t >(   float(     13.89f) ) );
+	STATIC_REQUIRE(   0 == bx::saturateCast<uint8_t>(   float(    -13.89f) ) );
+	STATIC_REQUIRE(  13 == bx::saturateCast<uint8_t>(   float(     13.89f) ) );
+
+	STATIC_REQUIRE(saturateCastTest<int8_t,   int8_t>(-128, 127) );
+	STATIC_REQUIRE(saturateCastTest<int8_t,  uint8_t>(   0, 127) );
+	STATIC_REQUIRE(saturateCastTest<int8_t,  int16_t>(-128, 127) );
+	STATIC_REQUIRE(saturateCastTest<int8_t, uint16_t>(   0, 127) );
+	STATIC_REQUIRE(saturateCastTest<int8_t,  int32_t>(-128, 127) );
+	STATIC_REQUIRE(saturateCastTest<int8_t, uint32_t>(   0, 127) );
+	STATIC_REQUIRE(saturateCastTest<int8_t,  int64_t>(-128, 127) );
+	STATIC_REQUIRE(saturateCastTest<int8_t, uint64_t>(   0, 127) );
+
+	STATIC_REQUIRE(saturateCastTest<uint8_t,   int8_t>(  0, 127) );
+	STATIC_REQUIRE(saturateCastTest<uint8_t,  uint8_t>(  0, 255) );
+	STATIC_REQUIRE(saturateCastTest<uint8_t,  int16_t>(  0, 255) );
+	STATIC_REQUIRE(saturateCastTest<uint8_t, uint16_t>(  0, 255) );
+	STATIC_REQUIRE(saturateCastTest<uint8_t,  int32_t>(  0, 255) );
+	STATIC_REQUIRE(saturateCastTest<uint8_t, uint32_t>(  0, 255) );
+	STATIC_REQUIRE(saturateCastTest<uint8_t,  int64_t>(  0, 255) );
+	STATIC_REQUIRE(saturateCastTest<uint8_t, uint64_t>(  0, 255) );
+
+	STATIC_REQUIRE(saturateCastTest<int16_t,   int8_t>(   -128,   127) );
+	STATIC_REQUIRE(saturateCastTest<int16_t,  uint8_t>(      0,   255) );
+	STATIC_REQUIRE(saturateCastTest<int16_t,  int16_t>( -32768, 32767) );
+	STATIC_REQUIRE(saturateCastTest<int16_t, uint16_t>(      0, 32767) );
+	STATIC_REQUIRE(saturateCastTest<int16_t,  int32_t>( -32768, 32767) );
+	STATIC_REQUIRE(saturateCastTest<int16_t, uint32_t>(      0, 32767) );
+	STATIC_REQUIRE(saturateCastTest<int16_t,  int64_t>( -32768, 32767) );
+	STATIC_REQUIRE(saturateCastTest<int16_t, uint64_t>(      0, 32767) );
+
+	STATIC_REQUIRE(saturateCastTest<uint16_t,   int8_t>(     0,   127) );
+	STATIC_REQUIRE(saturateCastTest<uint16_t,  uint8_t>(     0,   255) );
+	STATIC_REQUIRE(saturateCastTest<uint16_t,  int16_t>(     0, 32767) );
+	STATIC_REQUIRE(saturateCastTest<uint16_t, uint16_t>(     0, 65535) );
+	STATIC_REQUIRE(saturateCastTest<uint16_t,  int32_t>(     0, 65535) );
+	STATIC_REQUIRE(saturateCastTest<uint16_t, uint32_t>(     0, 65535) );
+	STATIC_REQUIRE(saturateCastTest<uint16_t,  int64_t>(     0, 65535) );
+	STATIC_REQUIRE(saturateCastTest<uint16_t, uint64_t>(     0, 65535) );
+
+	STATIC_REQUIRE(saturateCastTest<int32_t,   int8_t>(        -128,        127) );
+	STATIC_REQUIRE(saturateCastTest<int32_t,  uint8_t>(           0,        255) );
+	STATIC_REQUIRE(saturateCastTest<int32_t,  int16_t>(      -32768,      32767) );
+	STATIC_REQUIRE(saturateCastTest<int32_t, uint16_t>(           0,      65535) );
+	STATIC_REQUIRE(saturateCastTest<int32_t,  int32_t>( -2147483648, 2147483647) );
+	STATIC_REQUIRE(saturateCastTest<int32_t, uint32_t>(           0, 2147483647) );
+	STATIC_REQUIRE(saturateCastTest<int32_t,  int64_t>( -2147483648, 2147483647) );
+	STATIC_REQUIRE(saturateCastTest<int32_t, uint64_t>(           0, 2147483647) );
+
+	STATIC_REQUIRE(saturateCastTest<uint32_t,   int8_t>(          0,        127) );
+	STATIC_REQUIRE(saturateCastTest<uint32_t,  uint8_t>(          0,        255) );
+	STATIC_REQUIRE(saturateCastTest<uint32_t,  int16_t>(          0,      32767) );
+	STATIC_REQUIRE(saturateCastTest<uint32_t, uint16_t>(          0,      65535) );
+	STATIC_REQUIRE(saturateCastTest<uint32_t,  int32_t>(          0, 2147483647) );
+	STATIC_REQUIRE(saturateCastTest<uint32_t, uint32_t>(          0, 4294967295) );
+	STATIC_REQUIRE(saturateCastTest<uint32_t,  int64_t>(          0, 4294967295) );
+	STATIC_REQUIRE(saturateCastTest<uint32_t, uint64_t>(          0, 4294967295) );
+
+	STATIC_REQUIRE(saturateCastTest<int64_t,   int8_t>(                   -128,                   127) );
+	STATIC_REQUIRE(saturateCastTest<int64_t,  uint8_t>(                      0,                   255) );
+	STATIC_REQUIRE(saturateCastTest<int64_t,  int16_t>(                 -32768,                 32767) );
+	STATIC_REQUIRE(saturateCastTest<int64_t, uint16_t>(                      0,                 65535) );
+	STATIC_REQUIRE(saturateCastTest<int64_t,  int32_t>(            -2147483648,            2147483647) );
+	STATIC_REQUIRE(saturateCastTest<int64_t, uint32_t>(                      0,            4294967295) );
+	STATIC_REQUIRE(saturateCastTest<int64_t,  int64_t>( -9223372036854775808ll, 9223372036854775807ll) );
+	STATIC_REQUIRE(saturateCastTest<int64_t, uint64_t>(                      0, 9223372036854775807ll) );
+
+	STATIC_REQUIRE(saturateCastTest<uint64_t,   int8_t>(                     0,              127) );
+	STATIC_REQUIRE(saturateCastTest<uint64_t,  uint8_t>(                     0,                     255) );
+	STATIC_REQUIRE(saturateCastTest<uint64_t,  int16_t>(                     0,                   32767) );
+	STATIC_REQUIRE(saturateCastTest<uint64_t, uint16_t>(                     0,                   65535) );
+	STATIC_REQUIRE(saturateCastTest<uint64_t,  int32_t>(                     0,              2147483647) );
+	STATIC_REQUIRE(saturateCastTest<uint64_t, uint32_t>(                     0,              4294967295) );
+	STATIC_REQUIRE(saturateCastTest<uint64_t,  int64_t>(                     0,  9223372036854775807ull) );
+	STATIC_REQUIRE(saturateCastTest<uint64_t, uint64_t>(                     0, 18446744073709551615ull) );
+}

package/shared/BabylonNative/deps/bgfx.cmake-src/bx/tests/crt_test.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2025 Branimir Karadzic. All rights reserved.
+ * Copyright 2010-2026 Branimir Karadzic. All rights reserved.
  * License: https://github.com/bkaradzic/bx/blob/master/LICENSE
  */
 

package/shared/BabylonNative/deps/bgfx.cmake-src/bx/tests/dbg.h

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2025 Branimir Karadzic. All rights reserved.
+ * Copyright 2011-2026 Branimir Karadzic. All rights reserved.
  * License: https://github.com/bkaradzic/bx/blob/master/LICENSE
  */
 

package/shared/BabylonNative/deps/bgfx.cmake-src/bx/tests/easing_test.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2025 Branimir Karadzic. All rights reserved.
+ * Copyright 2010-2026 Branimir Karadzic. All rights reserved.
  * License: https://github.com/bkaradzic/bx/blob/master/LICENSE
  */