Mirrors/bx
1
0
Fork 0
mirror of https://github.com/bkaradzic/bx.git synced 2026-02-17 20:52:37 +01:00
Code Issues Packages Projects Releases Wiki Activity

Cleanup.

Browse Source
This commit is contained in:
Бранимир Караџић
2021-10-12 21:04:11 -07:00
parent 44c9661169
commit 2eee001125
4 changed files with 126 additions and 36 deletions
Download Patch File Download Diff File Expand all files Collapse all files

99
include/bx/bx.h
View File

@@ -31,10 +31,13 @@
namespace bx
{
/// Used to return successful execution of a program code.
constexpr int32_t kExitSuccess = 0;
/// Used to return unsuccessful execution of a program code.
constexpr int32_t kExitFailure = 1;
///
/// Returns true if type `Ty` is trivially copyable / POD type.
template<class Ty>
constexpr bool isTriviallyCopyable();
@@ -42,6 +45,10 @@ namespace bx
template <class Ty>
Ty* addressOf(Ty& _a);
/// Find the address of an object of a class that has an overloaded unary ampersand (&) operator.
template <class Ty>
const Ty* addressOf(const Ty& _a);
/// Swap two values.
template<typename Ty>
void swap(Ty& _a, Ty& _b);
@@ -57,23 +64,23 @@ namespace bx
template<typename Ty>
constexpr Ty max(const Ty& _a, const Ty& _b);
/// Returns minimum of three values.
template<typename Ty>
constexpr Ty min(const Ty& _a, const Ty& _b, const Ty& _c);
/// Returns minimum of three or more values.
template<typename Ty, typename... Args>
constexpr Ty min(const Ty& _a, const Ty& _b, const Args&... _args);
/// Returns maximum of three values.
template<typename Ty>
constexpr Ty max(const Ty& _a, const Ty& _b, const Ty& _c);
/// Returns maximum of three or more values.
template<typename Ty, typename... Args>
constexpr Ty max(const Ty& _a, const Ty& _b, const Args&... _args);
/// Returns middle of three values.
template<typename Ty>
constexpr Ty mid(const Ty& _a, const Ty& _b, const Ty& _c);
/// Returns middle of three or more values.
template<typename Ty, typename... Args>
constexpr Ty mid(const Ty& _a, const Ty& _b, const Args&... _args);
/// Returns clamped value between min/max.
template<typename Ty>
constexpr Ty clamp(const Ty& _a, const Ty& _min, const Ty& _max);
/// Returns true if value is power of 2.
/// Returns true if value `_a` is power of 2.
template<typename Ty>
constexpr bool isPowerOf2(Ty _a);
@@ -94,7 +101,7 @@ namespace bx
/// @param _src Source pointer.
/// @param _srcStride Source stride.
/// @param _stride Number of bytes per stride to copy.
/// @param _num Number of strides.
/// @param _numStrides Number of strides.
///
/// @remark Source and destination memory blocks must not overlap.
///
@@ -104,12 +111,31 @@ namespace bx
, const void* _src
, uint32_t _srcStride
, uint32_t _stride
, uint32_t _num
, uint32_t _numStrides
);
/// Copy memory block.
///
/// @param _dst Destination pointer.
/// @param _src Source pointer.
/// @param _numBytes Number of bytes to copy.
///
/// @remark If source and destination memory blocks overlap memory will be copied in reverse
/// order.
///
void memMove(void* _dst, const void* _src, size_t _numBytes);
/// Copy strided memory block.
///
/// @param _dst Destination pointer.
/// @param _dstStride Destination stride.
/// @param _src Source pointer.
/// @param _srcStride Source stride.
/// @param _stride Number of bytes per stride to copy.
/// @param _numStrides Number of strides.
///
/// @remark If source and destination memory blocks overlap memory will be copied in reverse
/// order.
///
void memMove(
void* _dst
@@ -117,34 +143,73 @@ namespace bx
, const void* _src
, uint32_t _srcStride
, uint32_t _stride
, uint32_t _num
, uint32_t _numStrides
);
/// Fill memory block to specified value `_ch`.
///
/// @param _dst Destination pointer.
/// @param _ch Fill value.
/// @param _numBytes Number of bytes to copy.
///
void memSet(void* _dst, uint8_t _ch, size_t _numBytes);
/// Fill strided memory block to specified value `_ch`.
///
void memSet(void* _dst, uint32_t _dstStride, uint8_t _ch, uint32_t _stride, uint32_t _num);
/// @param _dst Destination pointer.
/// @param _dstStride Destination stride.
/// @param _ch Fill value.
/// @param _stride Number of bytes per stride to copy.
/// @param _numStrides Number of strides.
///
void memSet(
void* _dst
, uint32_t _dstStride
, uint8_t _ch
, uint32_t _stride
, uint32_t _numStrides
);
/// Compare two memory blocks.
///
/// @param _lhs Pointer to memory block.
/// @param _rhs Pointer to memory block.
/// @param _numBytes Number of bytes to compare.
///
/// @returns 0 if two blocks are identical, positive value if first different byte in `_lhs` is
/// greater than corresponding byte in `_rhs`.
///
int32_t memCmp(const void* _lhs, const void* _rhs, size_t _numBytes);
/// Gather data scattered throught memory into linear memory block.
///
/// @param _dst Destination pointer.
/// @param _src Source pointer.
/// @param _stride Number of bytes per stride to copy.
/// @param _numStrides Number of strides.
///
void gather(
void* _dst
, const void* _src
, uint32_t _srcStride
, uint32_t _stride
, uint32_t _num
, uint32_t _numStrides
);
/// Scatter data from linear memory block through memory.
///
/// @param _dst Destination pointer.
/// @param _dstStride Destination stride.
/// @param _src Source pointer.
/// @param _stride Number of bytes per stride to copy.
/// @param _numStrides Number of strides.
///
void scatter(
void* _dst
, uint32_t _dstStride
, const void* _src
, uint32_t _stride
, uint32_t _num
, uint32_t _numStrides
);
} // namespace bx

28
include/bx/inline/bx.inl
View File

@@ -43,6 +43,16 @@ namespace bx
);
}
template<class Ty>
inline const Ty* addressOf(const Ty& _a)
{
return reinterpret_cast<const Ty*>(
&const_cast<char&>(
reinterpret_cast<const volatile char&>(_a)
)
);
}
template<typename Ty>
inline void swap(Ty& _a, Ty& _b)
{
@@ -61,22 +71,22 @@ namespace bx
return _a > _b ? _a : _b;
}
template<typename Ty>
inline constexpr Ty min(const Ty& _a, const Ty& _b, const Ty& _c)
template<typename Ty, typename... Args>
inline constexpr Ty min(const Ty& _a, const Ty& _b, const Args&... _args)
{
return min(min(_a, _b), _c);
return min(min(_a, _b), _args...);
}
template<typename Ty>
inline constexpr Ty max(const Ty& _a, const Ty& _b, const Ty& _c)
template<typename Ty, typename... Args>
inline constexpr Ty max(const Ty& _a, const Ty& _b, const Args&... _args)
{
return max(max(_a, _b), _c);
return max(max(_a, _b), _args...);
}
template<typename Ty>
inline constexpr Ty mid(const Ty& _a, const Ty& _b, const Ty& _c)
template<typename Ty, typename... Args>
inline constexpr Ty mid(const Ty& _a, const Ty& _b, const Args&... _args)
{
return max(min(_a, _b), min(max(_a, _b), _c) );
return max(min(_a, _b), min(max(_a, _b), _args...) );
}
template<typename Ty>