From 9158648261ad09da88058d91b4af904a34d31a09 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=91=D1=80=D0=B0=D0=BD=D0=B8=D0=BC=D0=B8=D1=80=20=D0=9A?=
 =?UTF-8?q?=D0=B0=D1=80=D0=B0=D1=9F=D0=B8=D1=9B?=
 <branimirkaradzic@gmail.com>
Date: Thu, 22 Sep 2022 20:32:24 -0700
Subject: [PATCH] Cleanup.

---
 include/bx/allocator.h         |  3 ---
 include/bx/inline/uint32_t.inl | 39 +++++++++++++++++-----------------
 include/bx/uint32_t.h          | 36 +++++++++++++++----------------
 3 files changed, 38 insertions(+), 40 deletions(-)

diff --git a/include/bx/allocator.h b/include/bx/allocator.h
index c5555ea..925441e 100644
--- a/include/bx/allocator.h
+++ b/include/bx/allocator.h
@@ -95,9 +95,6 @@ namespace bx
 			) override;
 	};
 
-	/// Check if pointer is aligned. _align must be power of two.
-	bool isAligned(const void* _ptr, size_t _align);
-
 	/// Aligns pointer to nearest next aligned address. _align must be power of two.
 	void* alignPtr(
 		  void* _ptr
diff --git a/include/bx/inline/uint32_t.inl b/include/bx/inline/uint32_t.inl
index f01ebf6..f2a6bc1 100644
--- a/include/bx/inline/uint32_t.inl
+++ b/include/bx/inline/uint32_t.inl
@@ -687,66 +687,67 @@ namespace bx
 		return result;
 	}
 
-	template <typename Ty>
-	inline bool isAligned(Ty _a, int32_t _align)
+	template<typename Ty>
+	inline BX_CONSTEXPR_FUNC bool isAligned(Ty _a, int32_t _align)
 	{
 		const Ty mask = Ty(_align - 1);
 		return 0 == (_a & mask);
 	}
 
-	template <typename Ty>
-	inline bool isAligned(const Ty* _ptr, int32_t _align)
+	template<typename Ty>
+	inline BX_CONSTEXPR_FUNC bool isAligned(Ty* _ptr, int32_t _align)
 	{
 		union { const void* ptr; uintptr_t addr; } un = { _ptr };
 		return isAligned(un.addr, _align);
 	}
 
-	template <typename Ty>
-	inline bool isAligned(Ty* _ptr, int32_t _align)
+	template<typename Ty>
+	inline BX_CONSTEXPR_FUNC bool isAligned(const Ty* _ptr, int32_t _align)
 	{
-		return isAligned( (const void*)_ptr, _align);
+		union { const void* ptr; uintptr_t addr; } un = { _ptr };
+		return isAligned(un.addr, _align);
 	}
 
-	template <typename Ty>
-	inline Ty alignDown(Ty _a, int32_t _align)
+	template<typename Ty>
+	inline BX_CONSTEXPR_FUNC  Ty alignDown(Ty _a, int32_t _align)
 	{
 		const Ty mask = Ty(_align - 1);
 		return Ty(_a & ~mask);
 	}
 
-	template <typename Ty>
-	inline Ty* alignDown(Ty* _ptr, int32_t _align)
+	template<typename Ty>
+	inline BX_CONSTEXPR_FUNC Ty* alignDown(Ty* _ptr, int32_t _align)
 	{
 		union { Ty* ptr; uintptr_t addr; } un = { _ptr };
 		un.addr = alignDown(un.addr, _align);
 		return un.ptr;
 	}
 
-	template <typename Ty>
-	inline const Ty* alignDown(const Ty* _ptr, int32_t _align)
+	template<typename Ty>
+	inline BX_CONSTEXPR_FUNC const Ty* alignDown(const Ty* _ptr, int32_t _align)
 	{
 		union { const Ty* ptr; uintptr_t addr; } un = { _ptr };
 		un.addr = alignDown(un.addr, _align);
 		return un.ptr;
 	}
 
-	template <typename Ty>
-	inline Ty alignUp(Ty _a, int32_t _align)
+	template<typename Ty>
+	inline BX_CONSTEXPR_FUNC Ty alignUp(Ty _a, int32_t _align)
 	{
 		const Ty mask = Ty(_align - 1);
 		return Ty( (_a + mask) & ~mask);
 	}
 
-	template <typename Ty>
-	inline Ty* alignUp(Ty* _ptr, int32_t _align)
+	template<typename Ty>
+	inline BX_CONSTEXPR_FUNC Ty* alignUp(Ty* _ptr, int32_t _align)
 	{
 		union { Ty* ptr; uintptr_t addr; } un = { _ptr };
 		un.addr = alignUp(un.addr, _align);
 		return un.ptr;
 	}
 
-	template <typename Ty>
-	inline const Ty* alignUp(const Ty* _ptr, int32_t _align)
+	template<typename Ty>
+	inline BX_CONSTEXPR_FUNC const Ty* alignUp(const Ty* _ptr, int32_t _align)
 	{
 		union { const Ty* ptr; uintptr_t addr; } un = { _ptr };
 		un.addr = alignUp(un.addr, _align);
diff --git a/include/bx/uint32_t.h b/include/bx/uint32_t.h
index cafd89b..cff793e 100644
--- a/include/bx/uint32_t.h
+++ b/include/bx/uint32_t.h
@@ -252,40 +252,40 @@ namespace bx
 	BX_CONSTEXPR_FUNC uint32_t strideAlign(uint32_t _offset, uint32_t _stride);
 
 	///
-	template <typename Ty>
-	bool isAligned(Ty _a, int32_t _align);
+	template<typename Ty>
+	BX_CONSTEXPR_FUNC bool isAligned(Ty _a, int32_t _align);
 
 	///
-	template <typename Ty>
-	bool isAligned(void* _ptr, int32_t _align);
+	template<typename Ty>
+	BX_CONSTEXPR_FUNC bool isAligned(Ty* _ptr, int32_t _align);
 
 	///
-	template <typename Ty>
-	bool isAligned(const void* _ptr, int32_t _align);
+	template<typename Ty>
+	BX_CONSTEXPR_FUNC bool isAligned(const Ty* _ptr, int32_t _align);
 
 	///
-	template <typename Ty>
-	Ty alignDown(Ty _a, int32_t _align);
+	template<typename Ty>
+	BX_CONSTEXPR_FUNC Ty alignDown(Ty _a, int32_t _align);
 
 	///
-	template <typename Ty>
-	Ty* alignDown(Ty* _ptr, int32_t _align);
+	template<typename Ty>
+	BX_CONSTEXPR_FUNC Ty* alignDown(Ty* _ptr, int32_t _align);
 
 	///
-	template <typename Ty>
-	const Ty* alignDown(const Ty* _ptr, int32_t _align);
+	template<typename Ty>
+	BX_CONSTEXPR_FUNC const Ty* alignDown(const Ty* _ptr, int32_t _align);
 
 	///
-	template <typename Ty>
-	Ty alignUp(Ty _a, int32_t _align);
+	template<typename Ty>
+	BX_CONSTEXPR_FUNC Ty alignUp(Ty _a, int32_t _align);
 
 	///
-	template <typename Ty>
-	Ty* alignUp(Ty* _ptr, int32_t _align);
+	template<typename Ty>
+	BX_CONSTEXPR_FUNC Ty* alignUp(Ty* _ptr, int32_t _align);
 
 	///
-	template <typename Ty>
-	const Ty* alignUp(const Ty* _ptr, int32_t _align);
+	template<typename Ty>
+	BX_CONSTEXPR_FUNC const Ty* alignUp(const Ty* _ptr, int32_t _align);
 
 	/// Convert float to half-float.
 	///