#if !defined(DN_BASE_H) #define DN_BASE_H #if defined(_CLANGD) #include "../dn.h" #endif // NOTE: Compiler identification // Warning! Order is important here, clang-cl on Windows defines _MSC_VER #if defined(_MSC_VER) #if defined(__clang__) #define DN_COMPILER_CLANG_CL #define DN_COMPILER_CLANG #else #define DN_COMPILER_MSVC #endif #elif defined(__clang__) #define DN_COMPILER_CLANG #elif defined(__GNUC__) #define DN_COMPILER_GCC #endif // NOTE: __has_feature // MSVC for example does not support the feature detection macro for instance so we compile it out #if defined(__has_feature) #define DN_HAS_FEATURE(expr) __has_feature(expr) #else #define DN_HAS_FEATURE(expr) 0 #endif // NOTE: __has_builtin // MSVC for example does not support the feature detection macro for instance so we compile it out #if defined(__has_builtin) #define DN_HAS_BUILTIN(expr) __has_builtin(expr) #else #define DN_HAS_BUILTIN(expr) 0 #endif // NOTE: Warning suppression macros #if defined(DN_COMPILER_MSVC) #define DN_MSVC_WARNING_PUSH __pragma(warning(push)) #define DN_MSVC_WARNING_DISABLE(...) __pragma(warning(disable :##__VA_ARGS__)) #define DN_MSVC_WARNING_POP __pragma(warning(pop)) #else #define DN_MSVC_WARNING_PUSH #define DN_MSVC_WARNING_DISABLE(...) #define DN_MSVC_WARNING_POP #endif #if defined(DN_COMPILER_CLANG) || defined(DN_COMPILER_GCC) || defined(DN_COMPILER_CLANG_CL) #define DN_GCC_WARNING_PUSH _Pragma("GCC diagnostic push") #define DN_GCC_WARNING_DISABLE_HELPER_0(x) #x #define DN_GCC_WARNING_DISABLE_HELPER_1(y) DN_GCC_WARNING_DISABLE_HELPER_0(GCC diagnostic ignored #y) #define DN_GCC_WARNING_DISABLE(warning) _Pragma(DN_GCC_WARNING_DISABLE_HELPER_1(warning)) #define DN_GCC_WARNING_POP _Pragma("GCC diagnostic pop") #else #define DN_GCC_WARNING_PUSH #define DN_GCC_WARNING_DISABLE(...) #define DN_GCC_WARNING_POP #endif // NOTE: Host OS identification #if defined(_WIN32) #define DN_OS_WIN32 #elif defined(__gnu_linux__) || defined(__linux__) #define DN_OS_UNIX #endif // NOTE: Platform identification #if !defined(DN_PLATFORM_EMSCRIPTEN) && \ !defined(DN_PLATFORM_POSIX) && \ !defined(DN_PLATFORM_WIN32) #if defined(__aarch64__) || defined(_M_ARM64) #define DN_PLATFORM_ARM64 #elif defined(__EMSCRIPTEN__) #define DN_PLATFORM_EMSCRIPTEN #elif defined(DN_OS_WIN32) #define DN_PLATFORM_WIN32 #else #define DN_PLATFORM_POSIX #endif #endif // NOTE: Windows crap #if defined(DN_COMPILER_MSVC) || defined(DN_COMPILER_CLANG_CL) #if defined(_CRT_SECURE_NO_WARNINGS) #define DN_CRT_SECURE_NO_WARNINGS_PREVIOUSLY_DEFINED #else #define _CRT_SECURE_NO_WARNINGS #endif #endif // NOTE: Force Inline #if defined(DN_COMPILER_MSVC) || defined(DN_COMPILER_CLANG_CL) #define DN_FORCE_INLINE __forceinline #else #define DN_FORCE_INLINE inline __attribute__((always_inline)) #endif // NOTE: Function/Variable Annotations #if defined(DN_STATIC_API) #define DN_API static #else #define DN_API #endif // NOTE: C/CPP Literals // Declare struct literals that work in both C and C++ because the syntax is different between // languages. #if 0 struct Foo { int a; } struct Foo foo = DN_LITERAL(Foo){32}; // Works on both C and C++ #endif #if defined(__cplusplus) #define DN_Literal(T) T #else #define DN_Literal(T) (T) #endif // NOTE: Thread Locals #if defined(__cplusplus) #define DN_THREAD_LOCAL thread_local #else #define DN_THREAD_LOCAL _Thread_local #endif // NOTE: C variadic argument annotations // TODO: Other compilers #if defined(DN_COMPILER_MSVC) #define DN_FMT_ATTRIB _Printf_format_string_ #else #define DN_FMT_ATTRIB #endif // NOTE: Type Cast #define DN_Cast(val) (val) // NOTE: Zero initialisation macro #if defined(__cplusplus) #define DN_ZeroInit {} #else #define DN_ZeroInit {0} #endif // NOTE: Address sanitizer #if !defined(DN_ASAN_POISON) #define DN_ASAN_POISON 0 #endif #if !defined(DN_ASAN_VET_POISON) #define DN_ASAN_VET_POISON 0 #endif #define DN_ASAN_POISON_ALIGNMENT 8 #if !defined(DN_ASAN_POISON_GUARD_SIZE) #define DN_ASAN_POISON_GUARD_SIZE 128 #endif #if DN_HAS_FEATURE(address_sanitizer) || defined(__SANITIZE_ADDRESS__) #include #endif // NOTE: Macros #define DN_Stringify(x) #x #define DN_TokenCombine2(x, y) x ## y #define DN_TokenCombine(x, y) DN_TokenCombine2(x, y) #if defined(__aarch64__) || defined(_M_X64) || defined(__x86_64__) || defined(__x86_64) #define DN_64_BIT #else #define DN_32_BIT #endif #include // va_list #include #include #include #include // PRIu64... #if !defined(DN_OS_WIN32) #include // exit() #endif #define DN_ForIndexU(index, size) DN_USize index = 0; index < size; index++ #define DN_ForIndexI(index, size) DN_ISize index = 0; index < size; index++ #define DN_ForItSize(it, T, array, size) struct { DN_USize index; T *data; } it = {0, &(array)[0]}; it.index < (size); it.index++, it.data = (array) + it.index #define DN_ForItSizeReverse(it, T, array, size) struct { DN_USize index; T *data; } it = {(size) - 1, &(array)[size - 1]}; it.index < (size); it.index--, it.data = (array) + it.index #define DN_ForIt(it, T, array) struct { DN_USize index; T *data; } it = {0, &(array)->data[0]}; it.index < (array)->size; it.index++, it.data = ((array)->data) + it.index #define DN_ForLinkedListIt(it, T, list) struct { DN_USize index; T *data; } it = {0, list}; it.data; it.index++, it.data = ((it).data->next) #define DN_ForItCArray(it, T, array) struct { DN_USize index; T *data; } it = {0, &(array)[0]}; it.index < DN_ArrayCountU(array); it.index++, it.data = (array) + it.index #define DN_AlignUpPowerOfTwo(value, pot) (((uintptr_t)(value) + ((uintptr_t)(pot) - 1)) & ~((uintptr_t)(pot) - 1)) #define DN_AlignDownPowerOfTwo(value, pot) ((uintptr_t)(value) & ~((uintptr_t)(pot) - 1)) #define DN_IsPowerOfTwo(value) ((((uintptr_t)(value)) & (((uintptr_t)(value)) - 1)) == 0) #define DN_IsPowerOfTwoAligned(value, pot) ((((uintptr_t)value) & (((uintptr_t)pot) - 1)) == 0) // NOTE: String.h Dependencies #if !defined(DN_Memcpy) || !defined(DN_Memset) || !defined(DN_Memcmp) || !defined(DN_Memmove) #include #if !defined(DN_Memcpy) #define DN_Memcpy(dest, src, count) memcpy((dest), (src), (count)) #endif #if !defined(DN_Memset) #define DN_Memset(dest, value, count) memset((dest), (value), (count)) #endif #if !defined(DN_Memcmp) #define DN_Memcmp(lhs, rhs, count) memcmp((lhs), (rhs), (count)) #endif #if !defined(DN_Memmove) #define DN_Memmove(dest, src, count) memmove((dest), (src), (count)) #endif #endif // NOTE: Math.h Dependencies #if !defined(DN_SqrtF32) || !defined(DN_SinF32) || !defined(DN_CosF32) || !defined(DN_TanF32) #include #if !defined(DN_SqrtF32) #define DN_SqrtF32(val) sqrtf(val) #endif #if !defined(DN_SinF32) #define DN_SinF32(val) sinf(val) #endif #if !defined(DN_CosF32) #define DN_CosF32(val) cosf(val) #endif #if !defined(DN_TanF32) #define DN_TanF32(val) tanf(val) #endif #endif // NOTE: Math #define DN_PiF32 3.14159265359f #define DN_DegreesToRadsF32(degrees) ((degrees) * (DN_PiF32 / 180.0f)) #define DN_RadsToDegreesF32(radians) ((radians) * (180.f * DN_PiF32)) #define DN_Abs(val) (((val) < 0) ? (-(val)) : (val)) #define DN_Max(a, b) (((a) > (b)) ? (a) : (b)) #define DN_Min(a, b) (((a) < (b)) ? (a) : (b)) #define DN_Clamp(val, lo, hi) DN_Max(DN_Min(val, hi), lo) #define DN_Squared(val) ((val) * (val)) #define DN_Swap(a, b) \ do { \ auto temp = a; \ a = b; \ b = temp; \ } while (0) // NOTE: Size #define DN_SizeOfI(val) DN_Cast(ptrdiff_t)sizeof(val) #define DN_ArrayCountU(array) (sizeof(array)/(sizeof((array)[0]))) #define DN_ArrayCountI(array) (DN_ISize)DN_ArrayCountU(array) #define DN_CharCountU(string) (sizeof(string) - 1) // NOTE: SI Byte #define DN_Bytes(val) ((DN_U64)val) #define DN_Kilobytes(val) ((DN_U64)1024 * DN_Bytes(val)) #define DN_Megabytes(val) ((DN_U64)1024 * DN_Kilobytes(val)) #define DN_Gigabytes(val) ((DN_U64)1024 * DN_Megabytes(val)) // NOTE: Time #define DN_MsFromSec(val) ((val) * 1000ULL) #define DN_SecFromMins(val) ((val) * 60ULL) #define DN_SecFromHours(val) (DN_SecFromMins(val) * 60ULL) #define DN_SecFromDays(val) (DN_SecFromHours(val) * 24ULL) #define DN_SecFromWeeks(val) (DN_SecFromDays(val) * 7ULL) #define DN_SecFromYears(val) (DN_SecFromWeeks(val) * 52ULL) // NOTE: Debug Break #if !defined(DN_DebugBreak) #if defined(NDEBUG) #define DN_DebugBreak #else #if defined(DN_COMPILER_MSVC) || defined(DN_COMPILER_CLANG_CL) #define DN_DebugBreak __debugbreak() #elif DN_HAS_BUILTIN(__builtin_debugtrap) #define DN_DebugBreak __builtin_debugtrap() #elif DN_HAS_BUILTIN(__builtin_trap) || defined(DN_COMPILER_GCC) #define DN_DebugBreak __builtin_trap() #else #include #if defined(SIGTRAP) #define DN_DebugBreak raise(SIGTRAP) #else #define DN_DebugBreak raise(SIGABRT) #endif #endif #endif #endif // NOTE: Helper macros to declare an array data structure for a given `Type` #define DN_DArrayStructDecl(Type) \ struct Type##Array \ { \ Type* data; \ DN_USize count; \ DN_USize max; \ } #define DN_FixedArrayStructDecl(Type, capacity) \ struct Type##x##capacity##Array \ { \ Type data[capacity]; \ DN_USize count; \ DN_USize max; \ } // NOTE: Types typedef intptr_t DN_ISize; typedef uintptr_t DN_USize; typedef int8_t DN_I8; typedef int16_t DN_I16; typedef int32_t DN_I32; typedef int64_t DN_I64; typedef uint8_t DN_U8; typedef uint16_t DN_U16; typedef uint32_t DN_U32; typedef uint64_t DN_U64; typedef uintptr_t DN_UPtr; typedef float DN_F32; typedef double DN_F64; typedef unsigned int DN_UInt; typedef DN_I32 DN_B32; #define DN_F32_MAX 3.402823466e+38F #define DN_F32_MIN 1.175494351e-38F #define DN_F64_MAX 1.7976931348623158e+308 #define DN_F64_MIN 2.2250738585072014e-308 #define DN_USIZE_MAX UINTPTR_MAX #define DN_ISIZE_MAX INTPTR_MAX #define DN_ISIZE_MIN INTPTR_MIN // NOTE: Intrinsics // NOTE: DN_AtomicAdd/Exchange return the previous value store in the target #if defined(DN_COMPILER_MSVC) || defined(DN_COMPILER_CLANG_CL) #include #define DN_AtomicCompareExchange64(dest, desired_val, prev_val) _InterlockedCompareExchange64((__int64 volatile *)dest, desired_val, prev_val) #define DN_AtomicCompareExchange32(dest, desired_val, prev_val) _InterlockedCompareExchange((long volatile *)dest, desired_val, prev_val) #define DN_AtomicLoadU64(target) *(target) #define DN_AtomicLoadU32(target) *(target) #define DN_AtomicAddU32(target, value) _InterlockedExchangeAdd((long volatile *)target, value) #define DN_AtomicAddU64(target, value) _InterlockedExchangeAdd64((__int64 volatile *)target, value) #define DN_AtomicSubU32(target, value) DN_AtomicAddU32(DN_Cast(long volatile *) target, (long)-value) #define DN_AtomicSubU64(target, value) DN_AtomicAddU64(target, (DN_U64) - value) #define DN_CountLeadingZerosU64(value) __lzcnt64(value) #define DN_CountLeadingZerosU32(value) __lzcnt(value) #define DN_CPUGetTSC() __rdtsc() #define DN_CompilerReadBarrierAndCPUReadFence _ReadBarrier(); _mm_lfence() #define DN_CompilerWriteBarrierAndCPUWriteFence _WriteBarrier(); _mm_sfence() #elif defined(DN_COMPILER_GCC) || defined(DN_COMPILER_CLANG) #if defined(__ANDROID__) #elif defined(DN_PLATFORM_EMSCRIPTEN) #if !defined(__wasm_simd128__) #error DN_Base requires -msse2 to be passed to Emscripten #endif #include #else #include #endif #define DN_AtomicLoadU64(target) __atomic_load_n(x, __ATOMIC_SEQ_CST) #define DN_AtomicLoadU32(target) __atomic_load_n(x, __ATOMIC_SEQ_CST) #define DN_AtomicAddU32(target, value) __atomic_fetch_add(target, value, __ATOMIC_ACQ_REL) #define DN_AtomicAddU64(target, value) __atomic_fetch_add(target, value, __ATOMIC_ACQ_REL) #define DN_AtomicSubU32(target, value) __atomic_fetch_sub(target, value, __ATOMIC_ACQ_REL) #define DN_AtomicSubU64(target, value) __atomic_fetch_sub(target, value, __ATOMIC_ACQ_REL) #define DN_CountLeadingZerosU64(value) __builtin_clzll(value) #define DN_CountLeadingZerosU32(value) __builtin_clzl(value) #if defined(DN_COMPILER_GCC) #define DN_CPUGetTSC() __rdtsc() #else #define DN_CPUGetTSC() __builtin_readcyclecounter() #endif #if defined(DN_PLATFORM_EMSCRIPTEN) #define DN_CompilerReadBarrierAndCPUReadFence #define DN_CompilerWriteBarrierAndCPUWriteFence #else #define DN_CompilerReadBarrierAndCPUReadFence asm volatile("lfence" ::: "memory") #define DN_CompilerWriteBarrierAndCPUWriteFence asm volatile("sfence" ::: "memory") #endif #else #error "Compiler not supported" #endif #if defined(DN_64_BIT) #define DN_CountLeadingZerosUSize(value) DN_CountLeadingZerosU64(value) #else #define DN_CountLeadingZerosUSize(value) DN_CountLeadingZerosU32(value) #endif enum DN_ZMem { DN_ZMem_No, // Memory can be handed out without zero-ing it out DN_ZMem_Yes, // Memory should be zero-ed out before giving to the callee }; struct DN_Str8 { char *data; // The bytes of the string DN_USize size; // The number of bytes in the string }; struct DN_Str8Slice { DN_Str8 *data; DN_USize count; }; struct DN_Str8x16 { char data[16]; DN_USize size; }; struct DN_Str8x32 { char data[32]; DN_USize size; }; struct DN_Str8x64 { char data[64]; DN_USize size; }; struct DN_Str8x128 { char data[128]; DN_USize size; }; struct DN_Str8x256 { char data[256]; DN_USize size; }; struct DN_Str16 // A pointer and length style string that holds slices to UTF16 bytes. { wchar_t *data; // The UTF16 bytes of the string DN_USize size; // The number of characters in the string }; struct DN_Str16Slice { DN_Str16 *data; DN_USize count; }; struct DN_CPURegisters { int eax; int ebx; int ecx; int edx; }; union DN_CPUIDResult { DN_CPURegisters reg; int values[4]; }; struct DN_CPUIDArgs { int eax; int ecx; }; #define DN_CPU_FEAT_XMACRO \ DN_CPU_FEAT_XENTRY(3DNow) \ DN_CPU_FEAT_XENTRY(3DNowExt) \ DN_CPU_FEAT_XENTRY(ABM) \ DN_CPU_FEAT_XENTRY(AES) \ DN_CPU_FEAT_XENTRY(AVX) \ DN_CPU_FEAT_XENTRY(AVX2) \ DN_CPU_FEAT_XENTRY(AVX512F) \ DN_CPU_FEAT_XENTRY(AVX512DQ) \ DN_CPU_FEAT_XENTRY(AVX512IFMA) \ DN_CPU_FEAT_XENTRY(AVX512PF) \ DN_CPU_FEAT_XENTRY(AVX512ER) \ DN_CPU_FEAT_XENTRY(AVX512CD) \ DN_CPU_FEAT_XENTRY(AVX512BW) \ DN_CPU_FEAT_XENTRY(AVX512VL) \ DN_CPU_FEAT_XENTRY(AVX512VBMI) \ DN_CPU_FEAT_XENTRY(AVX512VBMI2) \ DN_CPU_FEAT_XENTRY(AVX512VNNI) \ DN_CPU_FEAT_XENTRY(AVX512BITALG) \ DN_CPU_FEAT_XENTRY(AVX512VPOPCNTDQ) \ DN_CPU_FEAT_XENTRY(AVX5124VNNIW) \ DN_CPU_FEAT_XENTRY(AVX5124FMAPS) \ DN_CPU_FEAT_XENTRY(AVX512VP2INTERSECT) \ DN_CPU_FEAT_XENTRY(AVX512FP16) \ DN_CPU_FEAT_XENTRY(CLZERO) \ DN_CPU_FEAT_XENTRY(CMPXCHG8B) \ DN_CPU_FEAT_XENTRY(CMPXCHG16B) \ DN_CPU_FEAT_XENTRY(F16C) \ DN_CPU_FEAT_XENTRY(FMA) \ DN_CPU_FEAT_XENTRY(FMA4) \ DN_CPU_FEAT_XENTRY(FP128) \ DN_CPU_FEAT_XENTRY(FP256) \ DN_CPU_FEAT_XENTRY(FPU) \ DN_CPU_FEAT_XENTRY(MMX) \ DN_CPU_FEAT_XENTRY(MONITOR) \ DN_CPU_FEAT_XENTRY(MOVBE) \ DN_CPU_FEAT_XENTRY(MOVU) \ DN_CPU_FEAT_XENTRY(MmxExt) \ DN_CPU_FEAT_XENTRY(PCLMULQDQ) \ DN_CPU_FEAT_XENTRY(POPCNT) \ DN_CPU_FEAT_XENTRY(RDRAND) \ DN_CPU_FEAT_XENTRY(RDSEED) \ DN_CPU_FEAT_XENTRY(RDTSCP) \ DN_CPU_FEAT_XENTRY(SHA) \ DN_CPU_FEAT_XENTRY(SSE) \ DN_CPU_FEAT_XENTRY(SSE2) \ DN_CPU_FEAT_XENTRY(SSE3) \ DN_CPU_FEAT_XENTRY(SSE41) \ DN_CPU_FEAT_XENTRY(SSE42) \ DN_CPU_FEAT_XENTRY(SSE4A) \ DN_CPU_FEAT_XENTRY(SSSE3) \ DN_CPU_FEAT_XENTRY(TSC) \ DN_CPU_FEAT_XENTRY(TscInvariant) \ DN_CPU_FEAT_XENTRY(VAES) \ DN_CPU_FEAT_XENTRY(VPCMULQDQ) enum DN_CPUFeature { #define DN_CPU_FEAT_XENTRY(label) DN_CPUFeature_##label, DN_CPU_FEAT_XMACRO #undef DN_CPU_FEAT_XENTRY DN_CPUFeature_Count, }; struct DN_CPUFeatureDecl { DN_CPUFeature value; DN_Str8 label; }; struct DN_CPUFeatureQuery { DN_CPUFeature feature; bool available; }; struct DN_CPUReport { char vendor[4 /*bytes*/ * 3 /*EDX, ECX, EBX*/ + 1 /*null*/]; char brand[48]; DN_U64 features[(DN_CPUFeature_Count / (sizeof(DN_U64) * 8)) + 1]; }; struct DN_TicketMutex { unsigned int volatile ticket; // The next ticket to give out to the thread taking the mutex unsigned int volatile serving; // The ticket ID to block the mutex on until it is returned }; struct DN_Hex32 { char data[32]; }; struct DN_Hex64 { char data[64]; }; struct DN_Hex128 { char data[128]; }; struct DN_HexU64Str8 { char data[(sizeof(DN_U64) * 2) + 1 /*null-terminator*/]; DN_U8 size; }; enum DN_HexFromU64Type { DN_HexFromU64Type_Nil, DN_HexFromU64Type_Uppercase, }; struct DN_U8x16 { DN_U8 data[16]; }; struct DN_U8x32 { DN_U8 data[32]; }; struct DN_U8x64 { DN_U8 data[64]; }; DN_MSVC_WARNING_PUSH DN_MSVC_WARNING_DISABLE(4201) // warning C4201: nonstandard extension used: nameless struct/union union DN_V2USize { struct { DN_USize x, y; }; struct { DN_USize w, h; }; struct { DN_USize min, max; }; struct { DN_USize begin, end; }; DN_USize data[2]; }; union DN_V2U64 { struct { DN_U64 x, y; }; struct { DN_U64 w, h; }; struct { DN_U64 min, max; }; struct { DN_U64 begin, end; }; DN_U64 data[2]; }; DN_MSVC_WARNING_POP struct DN_CallSite { DN_Str8 file; DN_Str8 function; DN_U32 line; }; #define DN_CALL_SITE DN_CallSite { DN_Str8Lit(__FILE__), DN_Str8Lit(__func__), __LINE__ } #if defined(__cplusplus) template struct DN_Defer { Procedure proc; DN_Defer(Procedure p) : proc(p) {} ~DN_Defer() { proc(); } }; struct DN_DeferHelper { template DN_Defer operator+(Lambda lambda) { return DN_Defer(lambda); }; }; #define DN_UniqueName(prefix) DN_TokenCombine(prefix, __LINE__) #define DN_DEFER const auto DN_UniqueName(defer_lambda_) = DN_DeferHelper() + [&]() #endif // defined(__cplusplus) #define DN_DeferLoop(begin, end) \ bool DN_UniqueName(once) = (begin, true); \ DN_UniqueName(once); \ end, DN_UniqueName(once) = false struct DN_U64FromResult { bool success; DN_U64 value; }; struct DN_I64FromResult { bool success; DN_I64 value; }; enum DN_MemCommit { DN_MemCommit_No, DN_MemCommit_Yes, }; typedef DN_U32 DN_MemPage; enum DN_MemPage_ { // Exception on read/write with a page. This flag overrides the read/write // access. DN_MemPage_NoAccess = 1 << 0, DN_MemPage_Read = 1 << 1, // Only read permitted on the page. // Only write permitted on the page. On Windows this is not supported and // will be promoted to read+write permissions. DN_MemPage_Write = 1 << 2, DN_MemPage_ReadWrite = DN_MemPage_Read | DN_MemPage_Write, // Modifier used in conjunction with previous flags. Raises exception on // first access to the page, then, the underlying protection flags are // active. This is supported on Windows, on other OS's using this flag will // set the OS equivalent of DN_MemPage_NoAccess. // This flag must only be used in DN_Mem_Protect DN_MemPage_Guard = 1 << 3, // If leak tracing is enabled, this flag will allow the allocation recorded // from the reserve call to be leaked, e.g. not printed when leaks are // dumped to the console. DN_MemPage_AllocRecordLeakPermitted = 1 << 4, // If leak tracing is enabled this flag will prevent any allocation record // from being created in the allocation table at all. If this flag is // enabled, 'OSMemPage_AllocRecordLeakPermitted' has no effect since the // record will never be created. DN_MemPage_NoAllocRecordEntry = 1 << 5, // [INTERNAL] Do not use. All flags together do not constitute a correct // configuration of pages. DN_MemPage_All = DN_MemPage_NoAccess | DN_MemPage_ReadWrite | DN_MemPage_Guard | DN_MemPage_AllocRecordLeakPermitted | DN_MemPage_NoAllocRecordEntry, }; #if !defined(DN_ARENA_RESERVE_SIZE) #define DN_ARENA_RESERVE_SIZE DN_Megabytes(64) #endif #if !defined(DN_ARENA_COMMIT_SIZE) #define DN_ARENA_COMMIT_SIZE DN_Kilobytes(64) #endif enum DN_Allocator { DN_Allocator_Arena, DN_Allocator_Pool, }; struct DN_ArenaBlock { DN_ArenaBlock *prev; DN_U64 used; DN_U64 commit; DN_U64 reserve; DN_U64 reserve_sum; }; typedef DN_U32 DN_ArenaFlags; enum DN_ArenaFlags_ { DN_ArenaFlags_Nil = 0, DN_ArenaFlags_NoGrow = 1 << 0, DN_ArenaFlags_NoPoison = 1 << 1, DN_ArenaFlags_NoAllocTrack = 1 << 2, DN_ArenaFlags_AllocCanLeak = 1 << 3, DN_ArenaFlags_SimAlloc = 1 << 4, // NOTE: Internal flags. Do not use DN_ArenaFlags_UserBuffer = 1 << 4, DN_ArenaFlags_MemFuncs = 1 << 5, }; struct DN_ArenaInfo { DN_U64 used; DN_U64 commit; DN_U64 reserve; DN_U64 blocks; }; struct DN_ArenaStats { DN_ArenaInfo info; DN_ArenaInfo hwm; }; struct DN_ArenaStatsStr8x64 { DN_Str8x64 info; DN_Str8x64 hwm; }; enum DN_ArenaMemFuncType { DN_ArenaMemFuncType_Nil, DN_ArenaMemFuncType_Basic, DN_ArenaMemFuncType_VMem, }; typedef void *(DN_ArenaMemBasicAllocFunc)(DN_USize size); typedef void (DN_ArenaMemBasicDeallocFunc)(void *ptr); typedef void *(DN_ArenaMemVMemReserveFunc)(DN_USize size, DN_MemCommit commit, DN_MemPage page_flags); typedef bool (DN_ArenaMemVMemCommitFunc)(void *ptr, DN_USize size, DN_U32 page_flags); typedef void (DN_ArenaMemVMemReleaseFunc)(void *ptr, DN_USize size); struct DN_ArenaMemFuncs { DN_ArenaMemFuncType type; DN_ArenaMemBasicAllocFunc *basic_alloc; DN_ArenaMemBasicDeallocFunc *basic_dealloc; DN_U32 vmem_page_size; DN_ArenaMemVMemReserveFunc *vmem_reserve; DN_ArenaMemVMemCommitFunc *vmem_commit; DN_ArenaMemVMemReleaseFunc *vmem_release; }; struct DN_Arena { DN_ArenaMemFuncs mem_funcs; DN_ArenaBlock *curr; DN_ArenaStats stats; DN_ArenaFlags flags; DN_Str8 label; DN_Arena *prev, *next; }; struct DN_ArenaTempMem { DN_Arena *arena; DN_U64 used_sum; }; struct DN_ArenaTempMemScope { DN_ArenaTempMemScope(DN_Arena *arena); ~DN_ArenaTempMemScope(); DN_ArenaTempMem mem; }; DN_USize const DN_ARENA_HEADER_SIZE = DN_AlignUpPowerOfTwo(sizeof(DN_Arena), 64); #if !defined(DN_POOL_DEFAULT_ALIGN) #define DN_POOL_DEFAULT_ALIGN 16 #endif struct DN_PoolSlot { void *data; DN_PoolSlot *next; }; enum DN_PoolSlotSize { DN_PoolSlotSize_32B, DN_PoolSlotSize_64B, DN_PoolSlotSize_128B, DN_PoolSlotSize_256B, DN_PoolSlotSize_512B, DN_PoolSlotSize_1KiB, DN_PoolSlotSize_2KiB, DN_PoolSlotSize_4KiB, DN_PoolSlotSize_8KiB, DN_PoolSlotSize_16KiB, DN_PoolSlotSize_32KiB, DN_PoolSlotSize_64KiB, DN_PoolSlotSize_128KiB, DN_PoolSlotSize_256KiB, DN_PoolSlotSize_512KiB, DN_PoolSlotSize_1MiB, DN_PoolSlotSize_2MiB, DN_PoolSlotSize_4MiB, DN_PoolSlotSize_8MiB, DN_PoolSlotSize_16MiB, DN_PoolSlotSize_32MiB, DN_PoolSlotSize_64MiB, DN_PoolSlotSize_128MiB, DN_PoolSlotSize_256MiB, DN_PoolSlotSize_512MiB, DN_PoolSlotSize_1GiB, DN_PoolSlotSize_2GiB, DN_PoolSlotSize_4GiB, DN_PoolSlotSize_8GiB, DN_PoolSlotSize_16GiB, DN_PoolSlotSize_32GiB, DN_PoolSlotSize_Count, }; struct DN_Pool { DN_Arena *arena; DN_PoolSlot *slots[DN_PoolSlotSize_Count]; DN_U8 align; }; struct DN_NibbleFromU8Result { char nibble0; char nibble1; }; enum DN_Str8EqCase { DN_Str8EqCase_Sensitive, DN_Str8EqCase_Insensitive, }; enum DN_Str8IsAllType { DN_Str8IsAllType_Digits, DN_Str8IsAllType_Hex, }; struct DN_Str8BSplitResult { DN_Str8 lhs; DN_Str8 rhs; }; struct DN_Str8FindResult { bool found; // True if string was found. If false, the subsequent fields below are not set. DN_USize index; // Index in the buffer where the found string starts DN_Str8 match; // Matching string in the buffer that was searched DN_Str8 match_to_end_of_buffer; // Substring containing the found string to the end of the buffer DN_Str8 after_match_to_end_of_buffer; // Substring starting after the found string to the end of the buffer DN_Str8 start_to_before_match; // Substring from the start of the buffer up until the found string, not including it }; typedef DN_USize DN_Str8FindFlag; enum DN_Str8FindFlag_ { DN_Str8FindFlag_Digit = 1 << 0, // 0-9 DN_Str8FindFlag_Whitespace = 1 << 1, // '\r', '\t', '\n', ' ' DN_Str8FindFlag_Alphabet = 1 << 2, // A-Z, a-z DN_Str8FindFlag_Plus = 1 << 3, // + DN_Str8FindFlag_Minus = 1 << 4, // - DN_Str8FindFlag_AlphaNum = DN_Str8FindFlag_Alphabet | DN_Str8FindFlag_Digit, }; enum DN_Str8SplitIncludeEmptyStrings { DN_Str8SplitIncludeEmptyStrings_No, DN_Str8SplitIncludeEmptyStrings_Yes, }; struct DN_Str8TruncateResult { bool truncated; DN_Str8 str8; }; struct DN_Str8SplitResult { DN_Str8 *data; DN_USize count; }; struct DN_Str8Link { DN_Str8 string; // The string DN_Str8Link *next; // The next string in the linked list DN_Str8Link *prev; // The prev string in the linked list }; struct DN_Str8Builder { DN_Arena *arena; // Allocator to use to back the string list DN_Str8Link *head; // First string in the linked list of strings DN_Str8Link *tail; // Last string in the linked list of strings DN_USize string_size; // The size in bytes necessary to construct the current string DN_USize count; // The number of links in the linked list of strings }; enum DN_Str8BuilderAdd { DN_Str8BuilderAdd_Append, DN_Str8BuilderAdd_Prepend, }; typedef DN_U32 DN_AgeUnit; enum DN_AgeUnit_ { DN_AgeUnit_Ms = 1 << 0, DN_AgeUnit_Sec = 1 << 1, DN_AgeUnit_Min = 1 << 2, DN_AgeUnit_Hr = 1 << 3, DN_AgeUnit_Day = 1 << 4, DN_AgeUnit_Week = 1 << 5, DN_AgeUnit_Year = 1 << 6, DN_AgeUnit_FractionalSec = 1 << 7, DN_AgeUnit_HMS = DN_AgeUnit_Sec | DN_AgeUnit_Min | DN_AgeUnit_Hr, DN_AgeUnit_All = DN_AgeUnit_Ms | DN_AgeUnit_HMS | DN_AgeUnit_Day | DN_AgeUnit_Week | DN_AgeUnit_Year, }; enum DN_ByteCountType { DN_ByteCountType_B, DN_ByteCountType_KiB, DN_ByteCountType_MiB, DN_ByteCountType_GiB, DN_ByteCountType_TiB, DN_ByteCountType_Count, DN_ByteCountType_Auto, }; struct DN_ByteCountResult { DN_ByteCountType type; DN_Str8 suffix; // "KiB", "MiB", "GiB" .. e.t.c DN_F64 bytes; }; struct DN_Date { DN_U8 day; DN_U8 month; DN_U16 year; DN_U8 hour; DN_U8 minutes; DN_U8 seconds; DN_U16 milliseconds; }; struct DN_FmtAppendResult { DN_USize size_req; DN_Str8 str8; bool truncated; }; struct DN_ProfilerAnchor { // Inclusive refers to the time spent to complete the function call // including all children functions. // // Exclusive refers to the time spent in the function, not including any // time spent in children functions that we call that are also being // profiled. If we recursively call into ourselves, the time we spent in // our function is accumulated. DN_U64 tsc_inclusive; DN_U64 tsc_exclusive; DN_U16 hit_count; DN_Str8 name; }; struct DN_ProfilerZone { DN_U16 anchor_index; DN_U64 begin_tsc; DN_U16 parent_zone; DN_U64 elapsed_tsc_at_zone_start; }; struct DN_ProfilerAnchorArray { DN_ProfilerAnchor *data; DN_USize count; }; typedef DN_U64 (DN_ProfilerTSCNowFunc)(); struct DN_Profiler { DN_USize frame_index; DN_ProfilerAnchor *anchors; DN_USize anchors_count; DN_USize anchors_per_frame; DN_U16 parent_zone; bool paused; DN_ProfilerTSCNowFunc *tsc_now; DN_U64 tsc_frequency; DN_ProfilerZone frame_zone; DN_F64 frame_avg_tsc; }; enum DN_ErrSinkMode { DN_ErrSinkMode_Nil, // Default behaviour to accumulate errors into the sink DN_ErrSinkMode_DebugBreakOnErrorLog, // Debug break (int3) when error is encountered and the sink is ended by the 'end and log' functions. DN_ErrSinkMode_ExitOnError, // When an error is encountered, exit the program with the error code of the error that was caught. }; struct DN_ErrSinkMsg { DN_I32 error_code; DN_Str8 msg; DN_CallSite call_site; DN_ErrSinkMsg *next; DN_ErrSinkMsg *prev; }; struct DN_ErrSinkNode { DN_CallSite call_site; // Call site that the node was created DN_ErrSinkMode mode; // Controls how the sink behaves when an error is registered onto the sink. DN_ErrSinkMsg *msg_sentinel; // List of error messages accumulated for the current scope DN_U64 arena_pos; // Position to reset the arena when the scope is ended }; struct DN_ErrSink { DN_Arena* arena; // Dedicated allocator from the thread's local storage DN_ErrSinkNode stack[128]; // Each entry contains errors accumulated between a [begin, end] region of the active sink. DN_USize stack_size; }; struct DN_TCScratch { DN_Arena* arena; DN_ArenaTempMem temp_mem; DN_B32 destructed; }; #if defined(__cplusplus) struct DN_TCScratchCpp { DN_TCScratchCpp(DN_Arena **conflicts, DN_USize count); ~DN_TCScratchCpp(); DN_TCScratch data; }; #endif struct DN_TCInitArgs { DN_U64 main_reserve; DN_U64 main_commit; DN_U64 temp_reserve; DN_U64 temp_commit; DN_U64 err_sink_reserve; DN_U64 err_sink_commit; }; struct DN_TCCore // (T)hread (C)ontext sitting in thread-local storage { DN_Str8x64 name; DN_U64 thread_id; DN_CallSite call_site; char lane_opaque[sizeof(DN_U64) * 4]; DN_Arena main_arena_; DN_Arena temp_a_arena_; DN_Arena temp_b_arena_; DN_Arena err_sink_arena_; DN_Arena* main_arena; DN_Arena* temp_a_arena; DN_Arena* temp_b_arena; DN_ErrSink err_sink; DN_Arena* frame_arena; }; struct DN_PCG32 { DN_U64 state; }; struct DN_MurmurHash3 { DN_U64 e[2]; }; enum DN_LogType { DN_LogType_Debug, DN_LogType_Info, DN_LogType_Warning, DN_LogType_Error, DN_LogType_Count, }; enum DN_LogBold { DN_LogBold_No, DN_LogBold_Yes, }; struct DN_LogStyle { DN_LogBold bold; bool colour; DN_U8 r, g, b; }; struct DN_LogTypeParam { bool is_u32_enum; DN_U32 u32; DN_Str8 str8; }; enum DN_LogColourType { DN_LogColourType_Fg, DN_LogColourType_Bg, }; struct DN_LogDate { DN_U16 year; DN_U8 month; DN_U8 day; DN_U8 hour; DN_U8 minute; DN_U8 second; }; struct DN_LogPrefixSize { DN_USize size; DN_USize padding; }; struct DN_StackTraceFrame { DN_U64 address; DN_U64 line_number; DN_Str8 file_name; DN_Str8 function_name; }; struct DN_StackTraceFrameSlice { DN_StackTraceFrame *data; DN_USize count; }; struct DN_StackTraceRawFrame { void *process; DN_U64 base_addr; }; struct DN_StackTraceWalkResult { void *process; // [Internal] Windows handle to the process DN_U64 *base_addr; // The addresses of the functions in the stack trace DN_U16 size; // The number of `base_addr`'s stored from the walk }; struct DN_StackTraceWalkResultIterator { DN_StackTraceRawFrame raw_frame; DN_U16 index; }; typedef void DN_LogPrintFunc(DN_LogTypeParam type, void *user_data, DN_CallSite call_site, DN_FMT_ATTRIB char const *fmt, va_list args); DN_MSVC_WARNING_PUSH DN_MSVC_WARNING_DISABLE(4201) // warning C4201: nonstandard extension used: nameless struct/union union DN_V2I32 { struct { DN_I32 x, y; }; struct { DN_I32 w, h; }; DN_I32 data[2]; }; union DN_V2U16 { struct { DN_U16 x, y; }; struct { DN_U16 w, h; }; DN_U16 data[2]; }; union DN_V2U32 { struct { DN_U32 x, y; }; struct { DN_U32 w, h; }; struct { DN_U32 min, max; }; DN_U32 data[2]; }; union DN_V2F32 { struct { DN_F32 x, y; }; struct { DN_F32 w, h; }; DN_F32 data[2]; }; DN_DArrayStructDecl(DN_V2F32); union DN_V3F32 { struct { DN_F32 x, y, z; }; struct { DN_F32 r, g, b; }; DN_V2F32 xy; DN_F32 data[3]; }; union DN_V4F32 { struct { DN_F32 x, y, z, w; }; struct { DN_F32 r, g, b, a; }; DN_V3F32 rgb; DN_V3F32 xyz; DN_F32 data[4]; }; DN_DArrayStructDecl(DN_V4F32); DN_MSVC_WARNING_POP struct DN_M4 { DN_F32 columns[4][4]; // Column major matrix }; union DN_M2x3 { DN_F32 e[6]; DN_F32 row[2][3]; }; struct DN_Rect { DN_V2F32 pos, size; }; struct DN_RectMinMax { DN_V2F32 min, max; }; enum DN_RectCutClip { DN_RectCutClip_No, DN_RectCutClip_Yes, }; enum DN_RectCutSide { DN_RectCutSide_Left, DN_RectCutSide_Right, DN_RectCutSide_Top, DN_RectCutSide_Bottom, }; struct DN_RectCut { DN_Rect* rect; DN_RectCutSide side; }; struct DN_RaycastV2 { bool hit; // True if there was an intersection, false if the lines are parallel DN_F32 t_a; // Distance along `dir_a` that the intersection occurred, e.g. `origin_a + (dir_a * t_a)` DN_F32 t_b; // Distance along `dir_b` that the intersection occurred, e.g. `origin_b + (dir_b * t_b)` }; #if !defined(DN_STB_SPRINTF_HEADER_ONLY) #define STB_SPRINTF_IMPLEMENTATION #define STB_SPRINTF_STATIC #endif DN_MSVC_WARNING_PUSH DN_MSVC_WARNING_DISABLE(4505) // Unused function warning DN_GCC_WARNING_PUSH DN_GCC_WARNING_DISABLE(-Wunused-function) #include "../External/stb_sprintf.h" DN_GCC_WARNING_POP DN_MSVC_WARNING_POP #define DN_SPrintF(...) STB_SPRINTF_DECORATE(sprintf)(__VA_ARGS__) #define DN_SNPrintF(...) STB_SPRINTF_DECORATE(snprintf)(__VA_ARGS__) #define DN_VSPrintF(...) STB_SPRINTF_DECORATE(vsprintf)(__VA_ARGS__) #define DN_VSNPrintF(...) STB_SPRINTF_DECORATE(vsnprintf)(__VA_ARGS__) DN_API bool DN_MemEq (void const *lhs, DN_USize lhs_size, void const *rhs, DN_USize rhs_size); DN_API DN_U64 DN_AtomicSetValue64 (DN_U64 volatile *target, DN_U64 value); DN_API DN_U32 DN_AtomicSetValue32 (DN_U32 volatile *target, DN_U32 value); DN_API DN_USize DN_AlignUpPowerOfTwoUSize (DN_USize val); DN_API DN_U64 DN_AlignUpPowerOfTwoU64 (DN_U64 val); DN_API DN_U32 DN_AlignUpPowerOfTwoU32 (DN_U32 val); DN_API void DN_ByteSwapU64Ptr (DN_U8* dest, DN_U64 src); #define DN_ByteSwap64(u64) ( \ (((((DN_U64)(u64)) >> 56) & 0xFF) << 0) | \ (((((DN_U64)(u64)) >> 48) & 0xFF) << 8) | \ (((((DN_U64)(u64)) >> 40) & 0xFF) << 16) | \ (((((DN_U64)(u64)) >> 32) & 0xFF) << 24) | \ (((((DN_U64)(u64)) >> 24) & 0xFF) << 32) | \ (((((DN_U64)(u64)) >> 16) & 0xFF) << 40) | \ (((((DN_U64)(u64)) >> 8) & 0xFF) << 48) | \ (((((DN_U64)(u64)) >> 0) & 0xFF) << 56) \ ) DN_API DN_CPUIDResult DN_CPUID (DN_CPUIDArgs args); DN_API DN_USize DN_CPUHasFeatureArray (DN_CPUReport const *report, DN_CPUFeatureQuery *features, DN_USize features_size); DN_API bool DN_CPUHasFeature (DN_CPUReport const *report, DN_CPUFeature feature); DN_API bool DN_CPUHasAllFeatures (DN_CPUReport const *report, DN_CPUFeature const *features, DN_USize features_size); DN_API void DN_CPUSetFeature (DN_CPUReport *report, DN_CPUFeature feature); DN_API DN_CPUReport DN_CPUGetReport (); DN_API void DN_TicketMutex_Begin (DN_TicketMutex *mutex); DN_API void DN_TicketMutex_End (DN_TicketMutex *mutex); DN_API DN_UInt DN_TicketMutex_MakeTicket (DN_TicketMutex *mutex); DN_API void DN_TicketMutex_BeginTicket (DN_TicketMutex const *mutex, DN_UInt ticket); DN_API bool DN_TicketMutex_CanLock (DN_TicketMutex const *mutex, DN_UInt ticket); DN_API void DN_BitUnsetInplace (DN_USize *flags, DN_USize bitfield); DN_API void DN_BitSetInplace (DN_USize *flags, DN_USize bitfield); DN_API bool DN_BitIsSet (DN_USize bits, DN_USize bits_to_set); DN_API bool DN_BitIsNotSet (DN_USize bits, DN_USize bits_to_check); #define DN_BitClearNextLSB(value) (value) & ((value) - 1) DN_API DN_I64 DN_SafeAddI64 (DN_I64 a, DN_I64 b); DN_API DN_I64 DN_SafeMulI64 (DN_I64 a, DN_I64 b); DN_API DN_U64 DN_SafeAddU64 (DN_U64 a, DN_U64 b); DN_API DN_U64 DN_SafeMulU64 (DN_U64 a, DN_U64 b); DN_API DN_U64 DN_SafeSubU64 (DN_U64 a, DN_U64 b); DN_API DN_U32 DN_SafeSubU32 (DN_U32 a, DN_U32 b); DN_API int DN_SaturateCastUSizeToInt (DN_USize val); DN_API DN_I8 DN_SaturateCastUSizeToI8 (DN_USize val); DN_API DN_I16 DN_SaturateCastUSizeToI16 (DN_USize val); DN_API DN_I32 DN_SaturateCastUSizeToI32 (DN_USize val); DN_API DN_I64 DN_SaturateCastUSizeToI64 (DN_USize val); DN_API int DN_SaturateCastU64ToInt (DN_U64 val); DN_API DN_I8 DN_SaturateCastU8ToI8 (DN_U64 val); DN_API DN_I16 DN_SaturateCastU16ToI16 (DN_U64 val); DN_API DN_I32 DN_SaturateCastU32ToI32 (DN_U64 val); DN_API DN_I64 DN_SaturateCastU64ToI64 (DN_U64 val); DN_API DN_UInt DN_SaturateCastU64ToUInt (DN_U64 val); DN_API DN_U8 DN_SaturateCastU64ToU8 (DN_U64 val); DN_API DN_U16 DN_SaturateCastU64ToU16 (DN_U64 val); DN_API DN_U32 DN_SaturateCastU64ToU32 (DN_U64 val); DN_API DN_U8 DN_SaturateCastUSizeToU8 (DN_USize val); DN_API DN_U16 DN_SaturateCastUSizeToU16 (DN_USize val); DN_API DN_U32 DN_SaturateCastUSizeToU32 (DN_USize val); DN_API DN_U64 DN_SaturateCastUSizeToU64 (DN_USize val); DN_API int DN_SaturateCastISizeToInt (DN_ISize val); DN_API DN_I8 DN_SaturateCastISizeToI8 (DN_ISize val); DN_API DN_I16 DN_SaturateCastISizeToI16 (DN_ISize val); DN_API DN_I32 DN_SaturateCastISizeToI32 (DN_ISize val); DN_API DN_I64 DN_SaturateCastISizeToI64 (DN_ISize val); DN_API DN_UInt DN_SaturateCastISizeToUInt (DN_ISize val); DN_API DN_U8 DN_SaturateCastISizeToU8 (DN_ISize val); DN_API DN_U16 DN_SaturateCastISizeToU16 (DN_ISize val); DN_API DN_U32 DN_SaturateCastISizeToU32 (DN_ISize val); DN_API DN_U64 DN_SaturateCastISizeToU64 (DN_ISize val); DN_API DN_ISize DN_SaturateCastI64ToISize (DN_I64 val); DN_API DN_I8 DN_SaturateCastI64ToI8 (DN_I64 val); DN_API DN_I16 DN_SaturateCastI64ToI16 (DN_I64 val); DN_API DN_I32 DN_SaturateCastI64ToI32 (DN_I64 val); DN_API DN_UInt DN_SaturateCastI64ToUInt (DN_I64 val); DN_API DN_ISize DN_SaturateCastI64ToUSize (DN_I64 val); DN_API DN_U8 DN_SaturateCastI64ToU8 (DN_I64 val); DN_API DN_U16 DN_SaturateCastI64ToU16 (DN_I64 val); DN_API DN_U32 DN_SaturateCastI64ToU32 (DN_I64 val); DN_API DN_U64 DN_SaturateCastI64ToU64 (DN_I64 val); DN_API DN_I8 DN_SaturateCastIntToI8 (int val); DN_API DN_I16 DN_SaturateCastIntToI16 (int val); DN_API DN_U8 DN_SaturateCastIntToU8 (int val); DN_API DN_U16 DN_SaturateCastIntToU16 (int val); DN_API DN_U32 DN_SaturateCastIntToU32 (int val); DN_API DN_U64 DN_SaturateCastIntToU64 (int val); DN_API void DN_ASanPoisonMemoryRegion (void const volatile *ptr, DN_USize size); DN_API void DN_ASanUnpoisonMemoryRegion (void const volatile *ptr, DN_USize size); DN_API DN_F32 DN_EpsilonClampF32 (DN_F32 value, DN_F32 target, DN_F32 epsilon); DN_API DN_Arena DN_ArenaFromBuffer (void *buffer, DN_USize size, DN_ArenaFlags flags); DN_API DN_Arena DN_ArenaFromMemFuncs (DN_U64 reserve, DN_U64 commit, DN_ArenaFlags flags, DN_ArenaMemFuncs mem_funcs); DN_API void DN_ArenaDeinit (DN_Arena *arena); DN_API bool DN_ArenaCommit (DN_Arena *arena, DN_U64 size); DN_API bool DN_ArenaCommitTo (DN_Arena *arena, DN_U64 pos); DN_API bool DN_ArenaGrow (DN_Arena *arena, DN_U64 reserve, DN_U64 commit); DN_API void * DN_ArenaAlloc (DN_Arena *arena, DN_U64 size, uint8_t align, DN_ZMem zmem); DN_API void * DN_ArenaAllocContiguous (DN_Arena *arena, DN_U64 size, uint8_t align, DN_ZMem zmem); DN_API void * DN_ArenaCopy (DN_Arena *arena, void const *data, DN_U64 size, uint8_t align); DN_API void DN_ArenaPopTo (DN_Arena *arena, DN_U64 init_used); DN_API void DN_ArenaPop (DN_Arena *arena, DN_U64 amount); DN_API DN_U64 DN_ArenaPos (DN_Arena const *arena); DN_API void DN_ArenaClear (DN_Arena *arena); DN_API bool DN_ArenaOwnsPtr (DN_Arena const *arena, void *ptr); DN_API DN_Str8x64 DN_ArenaInfoStr8x64 (DN_ArenaInfo info); DN_API DN_ArenaStats DN_ArenaSumStatsArray (DN_ArenaStats const *array, DN_USize size); DN_API DN_ArenaStats DN_ArenaSumStats (DN_ArenaStats lhs, DN_ArenaStats rhs); DN_API DN_ArenaStats DN_ArenaSumArenaArrayToStats (DN_Arena const *array, DN_USize size); DN_API DN_ArenaTempMem DN_ArenaTempMemBegin (DN_Arena *arena); DN_API void DN_ArenaTempMemEnd (DN_ArenaTempMem mem); #define DN_ArenaNew(arena, T, zmem) (T *)DN_ArenaAlloc(arena, sizeof(T), alignof(T), zmem) #define DN_ArenaNewZ(arena, T) (T *)DN_ArenaAlloc(arena, sizeof(T), alignof(T), DN_ZMem_Yes) #define DN_ArenaNewContiguous(arena, T, zmem) (T *)DN_ArenaAllocContiguous(arena, sizeof(T), alignof(T), zmem) #define DN_ArenaNewContiguousZ(arena, T) (T *)DN_ArenaAllocContiguous(arena, sizeof(T), alignof(T), DN_ZMem_Yes) #define DN_ArenaNewArray(arena, T, count, zmem) (T *)DN_ArenaAlloc(arena, sizeof(T) * (count), alignof(T), zmem) #define DN_ArenaNewArrayZ(arena, T, count) (T *)DN_ArenaAlloc(arena, sizeof(T) * (count), alignof(T), DN_ZMem_Yes) #define DN_ArenaNewCopy(arena, T, src) (T *)DN_ArenaCopy(arena, (src), sizeof(T), alignof(T)) #define DN_ArenaNewArrayCopy(arena, T, src, count) (T *)DN_ArenaCopy(arena, (src), sizeof(T) * (count), alignof(T)) DN_API DN_Pool DN_PoolFromArena (DN_Arena *arena, DN_U8 align); DN_API bool DN_PoolIsValid (DN_Pool const *pool); DN_API void * DN_PoolAlloc (DN_Pool *pool, DN_USize size); DN_API void DN_PoolDealloc (DN_Pool *pool, void *ptr); DN_API void * DN_PoolCopy (DN_Pool *pool, void const *data, DN_U64 size, uint8_t align); #define DN_PoolNew(pool, T) (T *)DN_PoolAlloc(pool, sizeof(T)) #define DN_PoolNewArray(pool, T, count) (T *)DN_PoolAlloc(pool, count * sizeof(T)) #define DN_PoolNewCopy(pool, T, src) (T *)DN_PoolCopy (pool, (src), sizeof(T), alignof(T)) #define DN_PoolNewArrayCopy(pool, T, src, count) (T *)DN_PoolCopy (pool, (src), sizeof(T) * (count), alignof(T)) DN_API DN_ErrSink* DN_ErrSinkBegin_ (DN_ErrSink *err, DN_ErrSinkMode mode, DN_CallSite call_site); #define DN_ErrSinkBegin(err, mode) DN_ErrSinkBegin_(err, mode, DN_CALL_SITE) #define DN_ErrSinkBeginDefault(err) DN_ErrSinkBegin(err, DN_ErrSinkMode_Nil) DN_API bool DN_ErrSinkHasError (DN_ErrSink *err); DN_API DN_ErrSinkMsg* DN_ErrSinkEnd (DN_Arena *arena, DN_ErrSink *err); DN_API DN_Str8 DN_ErrSinkEndStr8 (DN_Arena *arena, DN_ErrSink *err); DN_API void DN_ErrSinkEndIgnore (DN_ErrSink *err); DN_API bool DN_ErrSinkEndLogError_ (DN_ErrSink *err, DN_CallSite call_site, DN_Str8 msg); #define DN_ErrSinkEndLogError(err, err_msg) DN_ErrSinkEndLogError_(err, DN_CALL_SITE, err_msg) DN_API bool DN_ErrSinkEndLogErrorFV_ (DN_ErrSink *err, DN_CallSite call_site, DN_FMT_ATTRIB char const *fmt, va_list args); #define DN_ErrSinkEndLogErrorFV(err, fmt, args) DN_ErrSinkEndLogErrorFV_(err, DN_CALL_SITE, fmt, args) DN_API bool DN_ErrSinkEndLogErrorF_ (DN_ErrSink *err, DN_CallSite call_site, DN_FMT_ATTRIB char const *fmt, ...); #define DN_ErrSinkEndLogErrorF(err, fmt, ...) DN_ErrSinkEndLogErrorF_(err, DN_CALL_SITE, fmt, ##__VA_ARGS__) DN_API void DN_ErrSinkEndExitIfErrorF_ (DN_ErrSink *err, DN_CallSite call_site, DN_U32 exit_val, DN_FMT_ATTRIB char const *fmt, ...); #define DN_ErrSinkEndExitIfErrorF(err, exit_val, fmt, ...) DN_ErrSinkEndExitIfErrorF_(err, DN_CALL_SITE, exit_val, fmt, ##__VA_ARGS__) DN_API void DN_ErrSinkEndExitIfErrorFV_ (DN_ErrSink *err, DN_CallSite call_site, DN_U32 exit_val, DN_FMT_ATTRIB char const *fmt, va_list args); #define DN_ErrSinkEndExitIfErrorFV(err, exit_val, fmt, args) DN_ErrSinkEndExitIfErrorFV_(err, DN_CALL_SITE, exit_val, fmt, args) DN_API void DN_ErrSinkAppendFV_ (DN_ErrSink *err, DN_U32 error_code, DN_CallSite call_site, DN_FMT_ATTRIB char const *fmt, va_list args); #define DN_ErrSinkAppendFV(error, error_code, fmt, args) DN_ErrSinkAppendFV_(error, error_code, DN_CALL_SITE, fmt, args) DN_API void DN_ErrSinkAppendF_ (DN_ErrSink *err, DN_U32 error_code, DN_CallSite call_site, DN_FMT_ATTRIB char const *fmt, ...); #define DN_ErrSinkAppendF(error, error_code, fmt, ...) DN_ErrSinkAppendF_(error, error_code, DN_CALL_SITE, fmt, ##__VA_ARGS__) DN_API void DN_TCInit (DN_TCCore *tc, DN_U64 thread_id, DN_Arena *main_arena, DN_Arena *temp_a_arena, DN_Arena *temp_b_arena, DN_Arena *err_sink_arena); DN_API void DN_TCInitFromMemFuncs (DN_TCCore *tc, DN_U64 thread_id, DN_TCInitArgs *args, DN_ArenaMemFuncs mem_funcs); DN_API void DN_TCDeinit (DN_TCCore *tc); DN_API void DN_TCEquip (DN_TCCore *tc); DN_API DN_TCCore* DN_TCGet (); DN_API DN_Arena* DN_TCMainArena (); DN_API DN_Arena* DN_TCTempArena (DN_Arena **conflicts, DN_USize count); DN_API DN_TCScratch DN_TCScratchBegin (DN_Arena **conflicts, DN_USize count); DN_API void DN_TCScratchEnd (DN_TCScratch *scratch); DN_API void DN_TCSetFrameArena (DN_Arena *arena); DN_API DN_Arena* DN_TCFrameArena (); DN_API DN_ErrSink* DN_TCErrSink (); #define DN_TCErrSinkBegin(mode) DN_ErrSinkBegin(DN_TCErrSink(), mode) #define DN_TCErrSinkBeginDefault() DN_ErrSinkBeginDefault(DN_TCErrSink()) DN_API bool DN_CharIsAlphabet (char ch); DN_API bool DN_CharIsDigit (char ch); DN_API bool DN_CharIsAlphaNum (char ch); DN_API bool DN_CharIsWhitespace (char ch); DN_API bool DN_CharIsHex (char ch); DN_API char DN_CharToLower (char ch); DN_API char DN_CharToUpper (char ch); DN_API DN_U64FromResult DN_U64FromStr8 (DN_Str8 string, char separator); DN_API DN_U64FromResult DN_U64FromPtr (void const *data, DN_USize size, char separator); DN_API DN_U64 DN_U64FromPtrUnsafe (void const *data, DN_USize size, char separator); DN_API DN_U64FromResult DN_U64FromHexPtr (void const *hex, DN_USize hex_count); DN_API DN_U64 DN_U64FromHexPtrUnsafe (void const *hex, DN_USize hex_count); DN_API DN_U64FromResult DN_U64FromHexStr8 (DN_Str8 hex); DN_API DN_U64 DN_U64FromHexStr8Unsafe (DN_Str8 hex); DN_API DN_I64FromResult DN_I64FromStr8 (DN_Str8 string, char separator); DN_API DN_I64FromResult DN_I64FromPtr (void const *data, DN_USize size, char separator); DN_API DN_I64 DN_I64FromPtrUnsafe (void const *data, DN_USize size, char separator); DN_API DN_USize DN_FmtVSize (DN_FMT_ATTRIB char const *fmt, va_list args); DN_API DN_USize DN_FmtSize (DN_FMT_ATTRIB char const *fmt, ...); DN_API DN_FmtAppendResult DN_FmtVAppend (char *buf, DN_USize *buf_size, DN_USize buf_max, char const *fmt, va_list args); DN_API DN_FmtAppendResult DN_FmtAppend (char *buf, DN_USize *buf_size, DN_USize buf_max, char const *fmt, ...); DN_API DN_FmtAppendResult DN_FmtAppendTruncate (char *buf, DN_USize *buf_size, DN_USize buf_max, DN_Str8 truncator, char const *fmt, ...); DN_API DN_USize DN_CStr8Size (char const *src); DN_API DN_USize DN_CStr16Size (wchar_t const *src); #define DN_Str16Lit(string) DN_Str16{(wchar_t *)(string), sizeof(string)/sizeof(string[0]) - 1} #define DN_Str16FromPtr(data, size) DN_Literal(DN_Str16){(wchar_t *)(data), (DN_USize)(size)} #define DN_Str8Lit(c_str) DN_Literal(DN_Str8){(char *)(c_str), sizeof(c_str) - 1} #define DN_Str8PrintFmt(string) (int)((string).size), (string).data #define DN_Str8FromPtr(data, size) DN_Literal(DN_Str8){(char *)(data), (DN_USize)(size)} #define DN_Str8FromStruct(ptr) DN_Str8FromPtr((ptr)->data, (ptr)->size) DN_API DN_Str8 DN_Str8AllocArena (DN_Arena *arena, DN_USize size, DN_ZMem z_mem); DN_API DN_Str8 DN_Str8AllocPool (DN_Pool *pool, DN_USize size); DN_API DN_Str8 DN_Str8FromCStr8 (char const *src); DN_API DN_Str8 DN_Str8FromPtrArena (DN_Arena *arena, void const *data, DN_USize size); DN_API DN_Str8 DN_Str8FromPtrPool (DN_Pool *pool, void const *data, DN_USize size); DN_API DN_Str8 DN_Str8FromStr8Arena (DN_Arena *arena, DN_Str8 string); DN_API DN_Str8 DN_Str8FromStr8Pool (DN_Pool *pool, DN_Str8 string); DN_API DN_Str8 DN_Str8FromFmtArena (DN_Arena *arena, DN_FMT_ATTRIB char const *fmt, ...); DN_API DN_Str8 DN_Str8FromFmtVArena (DN_Arena *arena, DN_FMT_ATTRIB char const *fmt, va_list args); DN_API DN_Str8 DN_Str8FromFmtPool (DN_Pool *pool, DN_FMT_ATTRIB char const *fmt, ...); DN_API DN_Str8 DN_Str8FromByteCountType (DN_ByteCountType type); DN_API DN_Str8x16 DN_Str8x16FromFmt (DN_FMT_ATTRIB char const *fmt, ...); DN_API DN_Str8x16 DN_Str8x16FromFmtV (DN_FMT_ATTRIB char const *fmt, va_list args); DN_API DN_Str8x32 DN_Str8x32FromFmt (DN_FMT_ATTRIB char const *fmt, ...); DN_API DN_Str8x32 DN_Str8x32FromFmtV (DN_FMT_ATTRIB char const *fmt, va_list args); DN_API DN_Str8x64 DN_Str8x64FromFmt (DN_FMT_ATTRIB char const *fmt, ...); DN_API DN_Str8x64 DN_Str8x64FromFmtV (DN_FMT_ATTRIB char const *fmt, va_list args); DN_API DN_Str8x128 DN_Str8x128FromFmt (DN_FMT_ATTRIB char const *fmt, ...); DN_API DN_Str8x256 DN_Str8x256FromFmtV (DN_FMT_ATTRIB char const *fmt, va_list args); DN_API DN_Str8x256 DN_Str8x256FromFmt (DN_FMT_ATTRIB char const *fmt, ...); DN_API DN_Str8x256 DN_Str8x256FromFmtV (DN_FMT_ATTRIB char const *fmt, va_list args); DN_API void DN_Str8x16AppendFmt (DN_Str8x16 *str, DN_FMT_ATTRIB char const *fmt, ...); DN_API void DN_Str8x16AppendFmtV (DN_Str8x16 *str, DN_FMT_ATTRIB char const *fmt, va_list args); DN_API void DN_Str8x32AppendFmt (DN_Str8x32 *str, DN_FMT_ATTRIB char const *fmt, ...); DN_API void DN_Str8x32AppendFmtV (DN_Str8x32 *str, DN_FMT_ATTRIB char const *fmt, va_list args); DN_API void DN_Str8x64AppendFmt (DN_Str8x64 *str, DN_FMT_ATTRIB char const *fmt, ...); DN_API void DN_Str8x64AppendFmtV (DN_Str8x64 *str, DN_FMT_ATTRIB char const *fmt, va_list args); DN_API void DN_Str8x128AppendFmt (DN_Str8x128 *str, DN_FMT_ATTRIB char const *fmt, ...); DN_API void DN_Str8x128AppendFmtV (DN_Str8x128 *str, DN_FMT_ATTRIB char const *fmt, va_list args); DN_API void DN_Str8x256AppendFmt (DN_Str8x256 *str, DN_FMT_ATTRIB char const *fmt, ...); DN_API void DN_Str8x256AppendFmtV (DN_Str8x256 *str, DN_FMT_ATTRIB char const *fmt, va_list args); DN_API DN_Str8x32 DN_Str8x32FromU64 (DN_U64 val, char separator); DN_API bool DN_Str8IsAll (DN_Str8 string, DN_Str8IsAllType is_all); DN_API char * DN_Str8End (DN_Str8 string); DN_API DN_Str8 DN_Str8Subset (DN_Str8 string, DN_USize offset, DN_USize size); DN_API DN_Str8 DN_Str8Advance (DN_Str8 string, DN_USize amount); DN_API DN_Str8 DN_Str8NextLine (DN_Str8 string); DN_API DN_Str8BSplitResult DN_Str8BSplitArray (DN_Str8 string, DN_Str8 const *find, DN_USize find_size); DN_API DN_Str8BSplitResult DN_Str8BSplit (DN_Str8 string, DN_Str8 find); DN_API DN_Str8BSplitResult DN_Str8BSplitLastArray (DN_Str8 string, DN_Str8 const *find, DN_USize find_size); DN_API DN_Str8BSplitResult DN_Str8BSplitLast (DN_Str8 string, DN_Str8 find); DN_API DN_USize DN_Str8Split (DN_Str8 string, DN_Str8 delimiter, DN_Str8 *splits, DN_USize splits_count, DN_Str8SplitIncludeEmptyStrings mode); DN_API DN_Str8SplitResult DN_Str8SplitArena (DN_Arena *arena, DN_Str8 string, DN_Str8 delimiter, DN_Str8SplitIncludeEmptyStrings mode); DN_API DN_Str8FindResult DN_Str8FindStr8Array (DN_Str8 string, DN_Str8 const *find, DN_USize find_size, DN_Str8EqCase eq_case); DN_API DN_Str8FindResult DN_Str8FindStr8 (DN_Str8 string, DN_Str8 find, DN_Str8EqCase eq_case); DN_API DN_Str8FindResult DN_Str8Find (DN_Str8 string, DN_Str8FindFlag flags); DN_API DN_Str8 DN_Str8Segment (DN_Arena *arena, DN_Str8 src, DN_USize segment_size, char segment_char); DN_API DN_Str8 DN_Str8ReverseSegment (DN_Arena *arena, DN_Str8 src, DN_USize segment_size, char segment_char); DN_API bool DN_Str8Eq (DN_Str8 lhs, DN_Str8 rhs, DN_Str8EqCase eq_case = DN_Str8EqCase_Sensitive); DN_API bool DN_Str8EqInsensitive (DN_Str8 lhs, DN_Str8 rhs); DN_API bool DN_Str8StartsWith (DN_Str8 string, DN_Str8 prefix, DN_Str8EqCase eq_case = DN_Str8EqCase_Sensitive); DN_API bool DN_Str8StartsWithInsensitive (DN_Str8 string, DN_Str8 prefix); DN_API bool DN_Str8EndsWith (DN_Str8 string, DN_Str8 prefix, DN_Str8EqCase eq_case = DN_Str8EqCase_Sensitive); DN_API bool DN_Str8EndsWithInsensitive (DN_Str8 string, DN_Str8 prefix); DN_API bool DN_Str8HasChar (DN_Str8 string, char ch); DN_API DN_Str8 DN_Str8TrimPrefix (DN_Str8 string, DN_Str8 prefix, DN_Str8EqCase eq_case = DN_Str8EqCase_Sensitive); DN_API DN_Str8 DN_Str8TrimHexPrefix (DN_Str8 string); DN_API DN_Str8 DN_Str8TrimSuffix (DN_Str8 string, DN_Str8 suffix, DN_Str8EqCase eq_case = DN_Str8EqCase_Sensitive); DN_API DN_Str8 DN_Str8TrimAround (DN_Str8 string, DN_Str8 trim_string); DN_API DN_Str8 DN_Str8TrimHeadWhitespace (DN_Str8 string); DN_API DN_Str8 DN_Str8TrimTailWhitespace (DN_Str8 string); DN_API DN_Str8 DN_Str8TrimWhitespaceAround (DN_Str8 string); DN_API DN_Str8 DN_Str8TrimByteOrderMark (DN_Str8 string); DN_API DN_Str8 DN_Str8FileNameFromPath (DN_Str8 path); DN_API DN_Str8 DN_Str8FileNameNoExtension (DN_Str8 path); DN_API DN_Str8 DN_Str8FilePathNoExtension (DN_Str8 path); DN_API DN_Str8 DN_Str8FileExtension (DN_Str8 path); DN_API DN_Str8 DN_Str8FileDirectoryFromPath (DN_Str8 path); DN_API DN_Str8 DN_Str8AppendF (DN_Arena *arena, DN_Str8 string, char const *fmt, ...); DN_API DN_Str8 DN_Str8AppendFV (DN_Arena *arena, DN_Str8 string, char const *fmt, va_list args); DN_API DN_Str8 DN_Str8FillF (DN_Arena *arena, DN_USize count, char const *fmt, ...); DN_API DN_Str8 DN_Str8FillFV (DN_Arena *arena, DN_USize count, char const *fmt, va_list args); DN_API void DN_Str8Remove (DN_Str8 *string, DN_USize offset, DN_USize size); DN_API DN_Str8TruncateResult DN_Str8TruncateMiddle (DN_Arena *arena, DN_Str8 str8, DN_U32 side_size, DN_Str8 truncator); DN_API DN_Str8 DN_Str8Lower (DN_Arena *arena, DN_Str8 string); DN_API DN_Str8 DN_Str8Upper (DN_Arena *arena, DN_Str8 string); DN_API DN_Str8 DN_Str8PadNewLines (DN_Arena *arena, DN_Str8 src, DN_Str8 pad); DN_API DN_Str8 DN_Str8Replace (DN_Str8 string, DN_Str8 find, DN_Str8 replace, DN_USize start_index, DN_Arena *arena, DN_Str8EqCase eq_case); DN_API DN_Str8 DN_Str8ReplaceSensitive (DN_Str8 string, DN_Str8 find, DN_Str8 replace, DN_USize start_index, DN_Arena *arena); DN_API DN_Str8 DN_Str8ReplaceInsensitive (DN_Str8 string, DN_Str8 find, DN_Str8 replace, DN_USize start_index, DN_Arena *arena); DN_API DN_Str8 DN_Str8SliceRender (DN_Str8Slice array, DN_Str8 separator, DN_Arena *arena); DN_API DN_Str8 DN_Str8RenderSpaceSep (DN_Str8Slice array, DN_Arena *arena); DN_API DN_Str16 DN_Str16SliceRender (DN_Str16Slice array, DN_Str16 separator, DN_Arena *arena); DN_API DN_Str16 DN_Str16RenderSpaceSep (DN_Str16Slice array, DN_Arena *arena); DN_API DN_Str8Builder DN_Str8BuilderFromArena (DN_Arena *arena); DN_API DN_Str8Builder DN_Str8BuilderFromStr8PtrRef (DN_Arena *arena, DN_Str8 const *strings, DN_USize size); DN_API DN_Str8Builder DN_Str8BuilderFromStr8PtrCopy (DN_Arena *arena, DN_Str8 const *strings, DN_USize size); DN_API DN_Str8Builder DN_Str8BuilderFromBuilder (DN_Arena *arena, DN_Str8Builder const *builder); DN_API bool DN_Str8BuilderAddArrayRef (DN_Str8Builder *builder, DN_Str8 const *strings, DN_USize size, DN_Str8BuilderAdd add); DN_API bool DN_Str8BuilderAddArrayCopy (DN_Str8Builder *builder, DN_Str8 const *strings, DN_USize size, DN_Str8BuilderAdd add); DN_API bool DN_Str8BuilderAddFV (DN_Str8Builder *builder, DN_Str8BuilderAdd add, DN_FMT_ATTRIB char const *fmt, va_list args); #define DN_Str8BuilderAppendArrayRef(builder, strings, size) DN_Str8BuilderAddArrayRef(builder, strings, size, DN_Str8BuilderAdd_Append) #define DN_Str8BuilderAppendArrayCopy(builder, strings, size) DN_Str8BuilderAddArrayCopy(builder, strings, size, DN_Str8BuilderAdd_Append) #define DN_Str8BuilderAppendSliceRef(builder, slice) DN_Str8BuilderAddArrayRef(builder, slice.data, slice.size, DN_Str8BuilderAdd_Append) #define DN_Str8BuilderAppendSliceCopy(builder, slice) DN_Str8BuilderAddArrayCopy(builder, slice.data, slice.size, DN_Str8BuilderAdd_Append) DN_API bool DN_Str8BuilderAppendRef (DN_Str8Builder *builder, DN_Str8 string); DN_API bool DN_Str8BuilderAppendCopy (DN_Str8Builder *builder, DN_Str8 string); #define DN_Str8BuilderAppendFV(builder, fmt, args) DN_Str8BuilderAddFV(builder, DN_Str8BuilderAdd_Append, fmt, args) DN_API bool DN_Str8BuilderAppendF (DN_Str8Builder *builder, DN_FMT_ATTRIB char const *fmt, ...); DN_API bool DN_Str8BuilderAppendBytesRef (DN_Str8Builder *builder, void const *ptr, DN_USize size); DN_API bool DN_Str8BuilderAppendBytesCopy (DN_Str8Builder *builder, void const *ptr, DN_USize size); DN_API bool DN_Str8BuilderAppendBuilderRef (DN_Str8Builder *dest, DN_Str8Builder const *src); DN_API bool DN_Str8BuilderAppendBuilderCopy (DN_Str8Builder *dest, DN_Str8Builder const *src); #define DN_Str8BuilderPrependArrayRef(builder, strings, size) DN_Str8BuilderAddArrayRef(builder, strings, size, DN_Str8BuilderAdd_Prepend) #define DN_Str8BuilderPrependArrayCopy(builder, strings, size) DN_Str8BuilderAddArrayCopy(builder, strings, size, DN_Str8BuilderAdd_Prepend) #define DN_Str8BuilderPrependSliceRef(builder, slice) DN_Str8BuilderAddArrayRef(builder, slice.data, slice.size, DN_Str8BuilderAdd_Prepend) #define DN_Str8BuilderPrependSliceCopy(builder, slice) DN_Str8BuilderAddArrayCopy(builder, slice.data, slice.size, DN_Str8BuilderAdd_Prepend) DN_API bool DN_Str8BuilderPrependRef (DN_Str8Builder *builder, DN_Str8 string); DN_API bool DN_Str8BuilderPrependCopy (DN_Str8Builder *builder, DN_Str8 string); #define DN_Str8BuilderPrependFV(builder, fmt, args) DN_Str8BuilderAddFV(builder, DN_Str8BuilderAdd_Prepend, fmt, args) DN_API bool DN_Str8BuilderPrependF (DN_Str8Builder *builder, DN_FMT_ATTRIB char const *fmt, ...); DN_API bool DN_Str8BuilderErase (DN_Str8Builder *builder, DN_Str8 string); DN_API DN_Str8 DN_Str8BuilderBuild (DN_Str8Builder const *builder, DN_Arena *arena); DN_API DN_Str8 DN_Str8BuilderBuildDelimited (DN_Str8Builder const *builder, DN_Str8 delimiter, DN_Arena *arena); DN_API DN_Str8Slice DN_Str8BuilderBuildSlice (DN_Str8Builder const *builder, DN_Arena *arena); DN_API int DN_EncodeUTF8Codepoint (DN_U8 utf8[4], DN_U32 codepoint); DN_API int DN_EncodeUTF16Codepoint (DN_U16 utf16[2], DN_U32 codepoint); DN_API DN_U8 DN_U8FromHexNibble (char hex); DN_API DN_NibbleFromU8Result DN_NibbleFromU8 (DN_U8 u8); DN_API DN_USize DN_BytesFromHexPtr (void const *hex, DN_USize hex_count, void *dest, DN_USize dest_count); DN_API DN_Str8 DN_BytesFromHexPtrArena (void const *hex, DN_USize hex_count, DN_Arena *arena); DN_API DN_USize DN_BytesFromHexStr8 (DN_Str8 hex, void *dest, DN_USize dest_count); DN_API DN_Str8 DN_BytesFromHexStr8Arena (DN_Str8 hex, DN_Arena *arena); DN_API DN_U8x16 DN_BytesFromHex32Ptr (void const *hex, DN_USize hex_count); DN_API DN_U8x32 DN_BytesFromHex64Ptr (void const *hex, DN_USize hex_count); DN_API DN_HexU64Str8 DN_HexFromU64 (DN_U64 value, DN_HexFromU64Type type); DN_API DN_USize DN_HexFromBytesPtr (void const *bytes, DN_USize bytes_count, void *hex, DN_USize hex_count); DN_API DN_Str8 DN_HexFromBytesPtrArena (void const *bytes, DN_USize bytes_count, DN_Arena *arena); DN_API DN_Hex32 DN_HexFromBytes16Ptr (void const *bytes, DN_USize bytes_count); DN_API DN_Hex64 DN_HexFromBytes32Ptr (void const *bytes, DN_USize bytes_count); DN_API DN_Hex128 DN_HexFromBytes64Ptr (void const *bytes, DN_USize bytes_count); DN_API DN_Str8x128 DN_AgeStr8FromMsU64 (DN_U64 duration_ms, DN_AgeUnit units); DN_API DN_Str8x128 DN_AgeStr8FromSecU64 (DN_U64 duration_ms, DN_AgeUnit units); DN_API DN_Str8x128 DN_AgeStr8FromSecF64 (DN_F64 sec, DN_AgeUnit units); DN_API int DN_IsLeapYear (int year); DN_API bool DN_DateIsValid (DN_Date date); DN_API DN_Date DN_DateFromUnixTimeMs (DN_USize unix_ts_ms); DN_API DN_U64 DN_UnixTimeMsFromDate (DN_Date date); DN_API DN_ByteCountResult DN_ByteCountFromType (DN_U64 bytes, DN_ByteCountType type); #define DN_ByteCount(bytes) DN_ByteCountFromType(bytes, DN_ByteCountType_Auto) DN_API DN_Str8x32 DN_ByteCountStr8x32FromType (DN_U64 bytes, DN_ByteCountType type); #define DN_ByteCountStr8x32(bytes) DN_ByteCountStr8x32FromType(bytes, DN_ByteCountType_Auto) #define DN_ProfilerZoneLoop(prof, name, index) \ DN_ProfilerZone DN_UniqueName(zone_) = DN_ProfilerBeginZone(prof, DN_Str8Lit(name), index), DN_UniqueName(dummy_) = {}; \ DN_UniqueName(dummy_).begin_tsc == 0; \ DN_ProfilerEndZone(prof, DN_UniqueName(zone_)), DN_UniqueName(dummy_).begin_tsc = 1 #define DN_ProfilerZoneLoopAuto(prof, name) DN_ProfilerZoneLoop(prof, name, __COUNTER__ + 1) DN_API DN_Profiler DN_ProfilerInit (DN_ProfilerAnchor *anchors, DN_USize count, DN_USize anchors_per_frame, DN_ProfilerTSCNowFunc *tsc_now, DN_U64 tsc_frequency); DN_API DN_ProfilerZone DN_ProfilerBeginZone (DN_Profiler *profiler, DN_Str8 name, DN_U16 anchor_index); #define DN_ProfilerBeginZoneAuto(prof, name) DN_ProfilerBeginZone(prof, DN_Str8Lit(name), __COUNTER__ + 1) DN_API void DN_ProfilerEndZone (DN_Profiler *profiler, DN_ProfilerZone zone); DN_API DN_USize DN_ProfilerFrameCount (DN_Profiler const *profiler); DN_API DN_ProfilerAnchorArray DN_ProfilerFrameAnchorsFromIndex (DN_Profiler *profiler, DN_USize frame_index); DN_API DN_ProfilerAnchorArray DN_ProfilerFrameAnchors (DN_Profiler *profiler); DN_API void DN_ProfilerNewFrame (DN_Profiler *profiler); DN_API void DN_ProfilerDump (DN_Profiler *profiler); DN_API DN_F64 DN_ProfilerSecFromTSC (DN_Profiler *profiler, DN_U64 duration_tsc); DN_API DN_F64 DN_ProfilerMsFromTSC (DN_Profiler *profiler, DN_U64 duration_tsc); DN_API DN_PCG32 DN_PCG32Init (DN_U64 seed); DN_API DN_U32 DN_PCG32Next (DN_PCG32 *rng); DN_API DN_U64 DN_PCG32Next64 (DN_PCG32 *rng); DN_API DN_U32 DN_PCG32Range (DN_PCG32 *rng, DN_U32 low, DN_U32 high); DN_API DN_F32 DN_PCG32NextF32 (DN_PCG32 *rng); DN_API DN_F64 DN_PCG32NextF64 (DN_PCG32 *rng); DN_API void DN_PCG32Advance (DN_PCG32 *rng, DN_U64 delta); #if !defined(DN_FNV1A32_SEED) #define DN_FNV1A32_SEED 2166136261U #endif #if !defined(DN_FNV1A64_SEED) #define DN_FNV1A64_SEED 14695981039346656037ULL #endif DN_API DN_U32 DN_FNV1AHashU32FromBytes (void const *bytes, DN_USize size, DN_U32 seed); DN_API DN_U64 DN_FNV1AHashU64FromBytes (void const *bytes, DN_USize size, DN_U64 seed); DN_API DN_U32 DN_MurmurHash3HashU32FromBytesX86 (void const *bytes, int len, DN_U32 seed); DN_API DN_MurmurHash3 DN_MurmurHash3HashU128FromBytesX64 (void const *bytes, int len, DN_U32 seed); DN_API DN_U64 DN_MurmurHash3HashU64FromBytesX64 (void const *bytes, int len, DN_U32 seed); DN_API DN_U32 DN_MurmurHash3HashU32FromBytesX64 (void const *bytes, int len, DN_U32 seed); #if defined(DN_64_BIT) #define DN_MurmurHash3HashU32FromBytes(bytes, len, seed) DN_MurmurHash3HashU32FromBytesX64(bytes, len, seed) #else #define DN_MurmurHash3HashU32FromBytes(bytes, len, seed) DN_MurmurHash3HashU32FromBytesX86(bytes, len, seed) #endif #define DN_LogResetEscapeCode "\x1b[0m" #define DN_LogBoldEscapeCode "\x1b[1m" DN_API DN_Str8 DN_LogColourEscapeCodeStr8FromRGB (DN_LogColourType colour, DN_U8 r, DN_U8 g, DN_U8 b); DN_API DN_Str8 DN_LogColourEscapeCodeStr8FromU32 (DN_LogColourType colour, DN_U32 value); DN_API DN_LogPrefixSize DN_LogMakePrefix (DN_LogStyle style, DN_LogTypeParam type, DN_CallSite call_site, DN_LogDate date, char *dest, DN_USize dest_size); DN_API void DN_LogSetPrintFunc (DN_LogPrintFunc *print_func, void *user_data); DN_API void DN_LogPrint (DN_LogTypeParam type, DN_CallSite call_site, DN_FMT_ATTRIB char const *fmt, ...); DN_API DN_LogTypeParam DN_LogTypeParamFromType (DN_LogType type); #define DN_LogDebugF(fmt, ...) DN_LogPrint(DN_LogTypeParamFromType(DN_LogType_Debug), DN_CALL_SITE, fmt, ##__VA_ARGS__) #define DN_LogInfoF(fmt, ...) DN_LogPrint(DN_LogTypeParamFromType(DN_LogType_Info), DN_CALL_SITE, fmt, ##__VA_ARGS__) #define DN_LogWarningF(fmt, ...) DN_LogPrint(DN_LogTypeParamFromType(DN_LogType_Warning), DN_CALL_SITE, fmt, ##__VA_ARGS__) #define DN_LogErrorF(fmt, ...) DN_LogPrint(DN_LogTypeParamFromType(DN_LogType_Error), DN_CALL_SITE, fmt, ##__VA_ARGS__) // NOTE: OS primitives that the OS layer can provide for the base layer but is optional. #if defined(DN_FREESTANDING) #define DN_StackTraceWalk(...) #define DN_StackTraceWalkResultIterate(...) #define DN_StackTraceWalkResultToStr8(...) DN_Str8Lit("N/A") #define DN_StackTraceWalkStr8(...) DN_Str8Lit("N/A") #define DN_StackTraceWalkStr8FromHeap(...) DN_Str8Lit("N/A") #define DN_StackTraceGetFrames(...) #define DN_StackTraceRawFrameToFrame(...) #define DN_StackTracePrint(...) #define DN_StackTraceReloadSymbols(...) #else DN_API DN_StackTraceWalkResult DN_StackTraceWalk (DN_Arena *arena, DN_U16 limit); DN_API bool DN_StackTraceWalkResultIterate (DN_StackTraceWalkResultIterator *it, DN_StackTraceWalkResult const *walk); DN_API DN_Str8 DN_StackTraceWalkResultToStr8 (DN_Arena *arena, DN_StackTraceWalkResult const *walk, DN_U16 skip); DN_API DN_Str8 DN_StackTraceWalkStr8 (DN_Arena *arena, DN_U16 limit, DN_U16 skip); DN_API DN_Str8 DN_StackTraceWalkStr8FromHeap (DN_U16 limit, DN_U16 skip); DN_API DN_StackTraceFrameSlice DN_StackTraceGetFrames (DN_Arena *arena, DN_U16 limit); DN_API DN_StackTraceFrame DN_StackTraceRawFrameToFrame (DN_Arena *arena, DN_StackTraceRawFrame raw_frame); DN_API void DN_StackTracePrint (DN_U16 limit); DN_API void DN_StackTraceReloadSymbols (); #endif #define DN_V2I32Zero DN_Literal(DN_V2I32){{(DN_I32)(0), (DN_I32)(0)}} #define DN_V2I32One DN_Literal(DN_V2I32){{(DN_I32)(1), (DN_I32)(1)}} #define DN_V2I32From1N(x) DN_Literal(DN_V2I32){{(DN_I32)(x), (DN_I32)(x)}} #define DN_V2I32From2N(x, y) DN_Literal(DN_V2I32){{(DN_I32)(x), (DN_I32)(y)}} #define DN_V2I32InitV2(xy) DN_Literal(DN_V2I32){{(DN_I32)(xy).x, (DN_I32)(xy).y}} DN_API bool operator!= (DN_V2I32 lhs, DN_V2I32 rhs); DN_API bool operator== (DN_V2I32 lhs, DN_V2I32 rhs); DN_API bool operator>= (DN_V2I32 lhs, DN_V2I32 rhs); DN_API bool operator<= (DN_V2I32 lhs, DN_V2I32 rhs); DN_API bool operator< (DN_V2I32 lhs, DN_V2I32 rhs); DN_API bool operator> (DN_V2I32 lhs, DN_V2I32 rhs); DN_API DN_V2I32 operator- (DN_V2I32 lhs, DN_V2I32 rhs); DN_API DN_V2I32 operator- (DN_V2I32 lhs); DN_API DN_V2I32 operator+ (DN_V2I32 lhs, DN_V2I32 rhs); DN_API DN_V2I32 operator* (DN_V2I32 lhs, DN_V2I32 rhs); DN_API DN_V2I32 operator* (DN_V2I32 lhs, DN_F32 rhs); DN_API DN_V2I32 operator* (DN_V2I32 lhs, DN_I32 rhs); DN_API DN_V2I32 operator/ (DN_V2I32 lhs, DN_V2I32 rhs); DN_API DN_V2I32 operator/ (DN_V2I32 lhs, DN_F32 rhs); DN_API DN_V2I32 operator/ (DN_V2I32 lhs, DN_I32 rhs); DN_API DN_V2I32& operator*= (DN_V2I32& lhs, DN_V2I32 rhs); DN_API DN_V2I32& operator*= (DN_V2I32& lhs, DN_F32 rhs); DN_API DN_V2I32& operator*= (DN_V2I32& lhs, DN_I32 rhs); DN_API DN_V2I32& operator/= (DN_V2I32& lhs, DN_V2I32 rhs); DN_API DN_V2I32& operator/= (DN_V2I32& lhs, DN_F32 rhs); DN_API DN_V2I32& operator/= (DN_V2I32& lhs, DN_I32 rhs); DN_API DN_V2I32& operator-= (DN_V2I32& lhs, DN_V2I32 rhs); DN_API DN_V2I32& operator+= (DN_V2I32& lhs, DN_V2I32 rhs); DN_API DN_V2I32 DN_V2I32Min (DN_V2I32 a, DN_V2I32 b); DN_API DN_V2I32 DN_V2I32Max (DN_V2I32 a, DN_V2I32 b); DN_API DN_V2I32 DN_V2I32Abs (DN_V2I32 a); #define DN_V2U16Zero DN_Literal(DN_V2U16){{(DN_U16)(0), (DN_U16)(0)}} #define DN_V2U16One DN_Literal(DN_V2U16){{(DN_U16)(1), (DN_U16)(1)}} #define DN_V2U16From1N(x) DN_Literal(DN_V2U16){{(DN_U16)(x), (DN_U16)(x)}} #define DN_V2U16From2N(x, y) DN_Literal(DN_V2U16){{(DN_U16)(x), (DN_U16)(y)}} DN_API bool operator!= (DN_V2U16 lhs, DN_V2U16 rhs); DN_API bool operator== (DN_V2U16 lhs, DN_V2U16 rhs); DN_API bool operator>= (DN_V2U16 lhs, DN_V2U16 rhs); DN_API bool operator<= (DN_V2U16 lhs, DN_V2U16 rhs); DN_API bool operator< (DN_V2U16 lhs, DN_V2U16 rhs); DN_API bool operator> (DN_V2U16 lhs, DN_V2U16 rhs); DN_API DN_V2U16 operator- (DN_V2U16 lhs, DN_V2U16 rhs); DN_API DN_V2U16 operator+ (DN_V2U16 lhs, DN_V2U16 rhs); DN_API DN_V2U16 operator* (DN_V2U16 lhs, DN_V2U16 rhs); DN_API DN_V2U16 operator* (DN_V2U16 lhs, DN_F32 rhs); DN_API DN_V2U16 operator* (DN_V2U16 lhs, DN_I32 rhs); DN_API DN_V2U16 operator/ (DN_V2U16 lhs, DN_V2U16 rhs); DN_API DN_V2U16 operator/ (DN_V2U16 lhs, DN_F32 rhs); DN_API DN_V2U16 operator/ (DN_V2U16 lhs, DN_I32 rhs); DN_API DN_V2U16& operator*= (DN_V2U16& lhs, DN_V2U16 rhs); DN_API DN_V2U16& operator*= (DN_V2U16& lhs, DN_F32 rhs); DN_API DN_V2U16& operator*= (DN_V2U16& lhs, DN_I32 rhs); DN_API DN_V2U16& operator/= (DN_V2U16& lhs, DN_V2U16 rhs); DN_API DN_V2U16& operator/= (DN_V2U16& lhs, DN_F32 rhs); DN_API DN_V2U16& operator/= (DN_V2U16& lhs, DN_I32 rhs); DN_API DN_V2U16& operator-= (DN_V2U16& lhs, DN_V2U16 rhs); DN_API DN_V2U16& operator+= (DN_V2U16& lhs, DN_V2U16 rhs); #define DN_V2U32Zero DN_Literal(DN_V2U32){{(DN_U32)(0), (DN_U32)(0)}} #define DN_V2U32One DN_Literal(DN_V2U32){{(DN_U32)(1), (DN_U32)(1)}} #define DN_V2U32From1N(x) DN_Literal(DN_V2U32){{(DN_U32)(x), (DN_U32)(x)}} #define DN_V2U32From2N(x, y) DN_Literal(DN_V2U32){{(DN_U32)(x), (DN_U32)(y)}} #define DN_V2F32Zero DN_Literal(DN_V2F32){{(DN_F32)(0), (DN_F32)(0)}} #define DN_V2F32One DN_Literal(DN_V2F32){{(DN_F32)(1), (DN_F32)(1)}} #define DN_V2F32From1N(x) DN_Literal(DN_V2F32){{(DN_F32)(x), (DN_F32)(x)}} #define DN_V2F32From2N(x, y) DN_Literal(DN_V2F32){{(DN_F32)(x), (DN_F32)(y)}} #define DN_V2F32FromV2I32(xy) DN_Literal(DN_V2F32){{(DN_F32)(xy).x, (DN_F32)(xy).y}} #define DN_V2F32FromV2U32(xy) DN_Literal(DN_V2F32){{(DN_F32)(xy).x, (DN_F32)(xy).y}} DN_API bool operator!= (DN_V2F32 lhs, DN_V2F32 rhs); DN_API bool operator== (DN_V2F32 lhs, DN_V2F32 rhs); DN_API bool operator>= (DN_V2F32 lhs, DN_V2F32 rhs); DN_API bool operator<= (DN_V2F32 lhs, DN_V2F32 rhs); DN_API bool operator< (DN_V2F32 lhs, DN_V2F32 rhs); DN_API bool operator> (DN_V2F32 lhs, DN_V2F32 rhs); DN_API DN_V2F32 operator- (DN_V2F32 lhs); DN_API DN_V2F32 operator- (DN_V2F32 lhs, DN_V2F32 rhs); DN_API DN_V2F32 operator- (DN_V2F32 lhs, DN_V2I32 rhs); DN_API DN_V2F32 operator- (DN_V2F32 lhs, DN_F32 rhs); DN_API DN_V2F32 operator- (DN_V2F32 lhs, DN_I32 rhs); DN_API DN_V2F32 operator+ (DN_V2F32 lhs, DN_V2F32 rhs); DN_API DN_V2F32 operator+ (DN_V2F32 lhs, DN_V2I32 rhs); DN_API DN_V2F32 operator+ (DN_V2F32 lhs, DN_F32 rhs); DN_API DN_V2F32 operator+ (DN_V2F32 lhs, DN_I32 rhs); DN_API DN_V2F32 operator* (DN_V2F32 lhs, DN_V2F32 rhs); DN_API DN_V2F32 operator* (DN_V2F32 lhs, DN_V2I32 rhs); DN_API DN_V2F32 operator* (DN_V2F32 lhs, DN_F32 rhs); DN_API DN_V2F32 operator* (DN_V2F32 lhs, DN_I32 rhs); DN_API DN_V2F32 operator/ (DN_V2F32 lhs, DN_V2F32 rhs); DN_API DN_V2F32 operator/ (DN_V2F32 lhs, DN_V2I32 rhs); DN_API DN_V2F32 operator/ (DN_V2F32 lhs, DN_F32 rhs); DN_API DN_V2F32 operator/ (DN_V2F32 lhs, DN_I32 rhs); DN_API DN_V2F32& operator*= (DN_V2F32& lhs, DN_V2F32 rhs); DN_API DN_V2F32& operator*= (DN_V2F32& lhs, DN_V2I32 rhs); DN_API DN_V2F32& operator*= (DN_V2F32& lhs, DN_F32 rhs); DN_API DN_V2F32& operator*= (DN_V2F32& lhs, DN_I32 rhs); DN_API DN_V2F32& operator/= (DN_V2F32& lhs, DN_V2F32 rhs); DN_API DN_V2F32& operator/= (DN_V2F32& lhs, DN_V2I32 rhs); DN_API DN_V2F32& operator/= (DN_V2F32& lhs, DN_F32 rhs); DN_API DN_V2F32& operator/= (DN_V2F32& lhs, DN_I32 rhs); DN_API DN_V2F32& operator-= (DN_V2F32& lhs, DN_V2F32 rhs); DN_API DN_V2F32& operator-= (DN_V2F32& lhs, DN_V2I32 rhs); DN_API DN_V2F32& operator-= (DN_V2F32& lhs, DN_F32 rhs); DN_API DN_V2F32& operator-= (DN_V2F32& lhs, DN_I32 rhs); DN_API DN_V2F32& operator+= (DN_V2F32& lhs, DN_V2F32 rhs); DN_API DN_V2F32& operator+= (DN_V2F32& lhs, DN_V2I32 rhs); DN_API DN_V2F32& operator+= (DN_V2F32& lhs, DN_F32 rhs); DN_API DN_V2F32& operator+= (DN_V2F32& lhs, DN_I32 rhs); DN_API DN_V2F32 DN_V2F32Min (DN_V2F32 a, DN_V2F32 b); DN_API DN_V2F32 DN_V2F32Max (DN_V2F32 a, DN_V2F32 b); DN_API DN_V2F32 DN_V2F32Abs (DN_V2F32 a); DN_API DN_F32 DN_V2F32Dot (DN_V2F32 a, DN_V2F32 b); DN_API DN_F32 DN_V2F32LengthSq2V2 (DN_V2F32 lhs, DN_V2F32 rhs); DN_API bool DN_V2F32LengthSqIsWithin2V2 (DN_V2F32 lhs, DN_V2F32 rhs, DN_F32 within_amount_sq); DN_API DN_F32 DN_V2F32Length2V2 (DN_V2F32 lhs, DN_V2F32 rhs); DN_API DN_F32 DN_V2F32LengthSq (DN_V2F32 lhs); DN_API DN_F32 DN_V2F32Length (DN_V2F32 lhs); DN_API DN_V2F32 DN_V2F32Normalise (DN_V2F32 a); DN_API DN_V2F32 DN_V2F32Perpendicular (DN_V2F32 a); DN_API DN_V2F32 DN_V2F32Reflect (DN_V2F32 in, DN_V2F32 surface); DN_API DN_F32 DN_V2F32Area (DN_V2F32 a); #define DN_V3F32From1N(x) DN_Literal(DN_V3F32){{(DN_F32)(x), (DN_F32)(x), (DN_F32)(x)}} #define DN_V3F32From3N(x, y, z) DN_Literal(DN_V3F32){{(DN_F32)(x), (DN_F32)(y), (DN_F32)(z)}} #define DN_V3F32FromV2F32And1N(xy, z) DN_Literal(DN_V3F32){{(DN_F32)(xy.x), (DN_F32)(xy.y), (DN_F32)(z)}} DN_API bool operator== (DN_V3F32 lhs, DN_V3F32 rhs); DN_API bool operator!= (DN_V3F32 lhs, DN_V3F32 rhs); DN_API bool operator>= (DN_V3F32 lhs, DN_V3F32 rhs); DN_API bool operator<= (DN_V3F32 lhs, DN_V3F32 rhs); DN_API bool operator< (DN_V3F32 lhs, DN_V3F32 rhs); DN_API bool operator> (DN_V3F32 lhs, DN_V3F32 rhs); DN_API DN_V3F32 operator- (DN_V3F32 lhs, DN_V3F32 rhs); DN_API DN_V3F32 operator- (DN_V3F32 lhs); DN_API DN_V3F32 operator+ (DN_V3F32 lhs, DN_V3F32 rhs); DN_API DN_V3F32 operator* (DN_V3F32 lhs, DN_V3F32 rhs); DN_API DN_V3F32 operator* (DN_V3F32 lhs, DN_F32 rhs); DN_API DN_V3F32 operator* (DN_V3F32 lhs, DN_I32 rhs); DN_API DN_V3F32 operator/ (DN_V3F32 lhs, DN_V3F32 rhs); DN_API DN_V3F32 operator/ (DN_V3F32 lhs, DN_F32 rhs); DN_API DN_V3F32 operator/ (DN_V3F32 lhs, DN_I32 rhs); DN_API DN_V3F32& operator*= (DN_V3F32 &lhs, DN_V3F32 rhs); DN_API DN_V3F32& operator*= (DN_V3F32 &lhs, DN_F32 rhs); DN_API DN_V3F32& operator*= (DN_V3F32 &lhs, DN_I32 rhs); DN_API DN_V3F32& operator/= (DN_V3F32 &lhs, DN_V3F32 rhs); DN_API DN_V3F32& operator/= (DN_V3F32 &lhs, DN_F32 rhs); DN_API DN_V3F32& operator/= (DN_V3F32 &lhs, DN_I32 rhs); DN_API DN_V3F32& operator-= (DN_V3F32 &lhs, DN_V3F32 rhs); DN_API DN_V3F32& operator+= (DN_V3F32 &lhs, DN_V3F32 rhs); DN_API DN_F32 DN_V3F32LengthSq (DN_V3F32 a); DN_API DN_F32 DN_V3F32Length (DN_V3F32 a); DN_API DN_V3F32 DN_V3F32Normalise (DN_V3F32 a); #define DN_V4F32From1N(x) DN_Literal(DN_V4F32){{(DN_F32)(x), (DN_F32)(x), (DN_F32)(x), (DN_F32)(x)}} #define DN_V4F32From4N(x, y, z, w) DN_Literal(DN_V4F32){{(DN_F32)(x), (DN_F32)(y), (DN_F32)(z), (DN_F32)(w)}} #define DN_V4F32FromV3And1N(xyz, w) DN_Literal(DN_V4F32){{xyz.x, xyz.y, xyz.z, w}} #define DN_V4F32FromRGBAU8(r, g, b, a) DN_Literal(DN_V4F32){{r / 255.f, g / 255.f, b / 255.f, a / 255.f}} #define DN_V4F32FromRGBU8(r, g, b) DN_Literal(DN_V4F32){{r / 255.f, g / 255.f, b / 255.f, 1.f}} DN_API DN_V4F32 DN_V4F32FromRGBU32 (DN_U32 u32); DN_API DN_V4F32 DN_V4F32FromRGBAU32 (DN_U32 u32); #define DN_V4F32FromV4Alpha(v4, alpha) DN_V4F32FromV3And1N(v4.xyz, alpha) DN_API bool operator== (DN_V4F32 lhs, DN_V4F32 rhs); DN_API bool operator!= (DN_V4F32 lhs, DN_V4F32 rhs); DN_API bool operator<= (DN_V4F32 lhs, DN_V4F32 rhs); DN_API bool operator< (DN_V4F32 lhs, DN_V4F32 rhs); DN_API bool operator> (DN_V4F32 lhs, DN_V4F32 rhs); DN_API DN_V4F32 operator- (DN_V4F32 lhs, DN_V4F32 rhs); DN_API DN_V4F32 operator- (DN_V4F32 lhs); DN_API DN_V4F32 operator+ (DN_V4F32 lhs, DN_V4F32 rhs); DN_API DN_V4F32 operator* (DN_V4F32 lhs, DN_V4F32 rhs); DN_API DN_V4F32 operator* (DN_V4F32 lhs, DN_F32 rhs); DN_API DN_V4F32 operator* (DN_V4F32 lhs, DN_I32 rhs); DN_API DN_V4F32 operator/ (DN_V4F32 lhs, DN_F32 rhs); DN_API DN_V4F32& operator*= (DN_V4F32 &lhs, DN_V4F32 rhs); DN_API DN_V4F32& operator*= (DN_V4F32 &lhs, DN_F32 rhs); DN_API DN_V4F32& operator*= (DN_V4F32 &lhs, DN_I32 rhs); DN_API DN_V4F32& operator-= (DN_V4F32 &lhs, DN_V4F32 rhs); DN_API DN_V4F32& operator+= (DN_V4F32 &lhs, DN_V4F32 rhs); DN_API DN_F32 DN_V4F32Dot (DN_V4F32 a, DN_V4F32 b); DN_API DN_M4 DN_M4Identity (); DN_API DN_M4 DN_M4ScaleF (DN_F32 x, DN_F32 y, DN_F32 z); DN_API DN_M4 DN_M4Scale (DN_V3F32 xyz); DN_API DN_M4 DN_M4TranslateF (DN_F32 x, DN_F32 y, DN_F32 z); DN_API DN_M4 DN_M4Translate (DN_V3F32 xyz); DN_API DN_M4 DN_M4Transpose (DN_M4 mat); DN_API DN_M4 DN_M4Rotate (DN_V3F32 axis, DN_F32 radians); DN_API DN_M4 DN_M4Orthographic (DN_F32 left, DN_F32 right, DN_F32 bottom, DN_F32 top, DN_F32 z_near, DN_F32 z_far); DN_API DN_M4 DN_M4Perspective (DN_F32 fov /*radians*/, DN_F32 aspect, DN_F32 z_near, DN_F32 z_far); DN_API DN_M4 DN_M4Add (DN_M4 lhs, DN_M4 rhs); DN_API DN_M4 DN_M4Sub (DN_M4 lhs, DN_M4 rhs); DN_API DN_M4 DN_M4Mul (DN_M4 lhs, DN_M4 rhs); DN_API DN_M4 DN_M4Div (DN_M4 lhs, DN_M4 rhs); DN_API DN_M4 DN_M4AddF (DN_M4 lhs, DN_F32 rhs); DN_API DN_M4 DN_M4SubF (DN_M4 lhs, DN_F32 rhs); DN_API DN_M4 DN_M4MulF (DN_M4 lhs, DN_F32 rhs); DN_API DN_M4 DN_M4DivF (DN_M4 lhs, DN_F32 rhs); DN_API DN_Str8x256 DN_M4ColumnMajorString (DN_M4 mat); DN_API bool operator== (DN_M2x3 const &lhs, DN_M2x3 const &rhs); DN_API bool operator!= (DN_M2x3 const &lhs, DN_M2x3 const &rhs); DN_API DN_M2x3 DN_M2x3Identity (); DN_API DN_M2x3 DN_M2x3Translate (DN_V2F32 offset); DN_API DN_V2F32 DN_M2x3ScaleGet (DN_M2x3 m2x3); DN_API DN_M2x3 DN_M2x3Scale (DN_V2F32 scale); DN_API DN_M2x3 DN_M2x3Rotate (DN_F32 radians); DN_API DN_M2x3 DN_M2x3Mul (DN_M2x3 m1, DN_M2x3 m2); DN_API DN_V2F32 DN_M2x3Mul2F32 (DN_M2x3 m1, DN_F32 x, DN_F32 y); DN_API DN_V2F32 DN_M2x3MulV2F32 (DN_M2x3 m1, DN_V2F32 v2); #define DN_RectFrom2V2(pos, size) DN_Literal(DN_Rect){(pos), (size)} #define DN_RectFrom4N(x, y, w, h) DN_Literal(DN_Rect){DN_Literal(DN_V2F32){{x, y}}, DN_Literal(DN_V2F32){{w, h}}} #define DN_RectZero DN_RectFrom4N(0, 0, 0, 0) DN_API bool operator== (const DN_Rect& lhs, const DN_Rect& rhs); DN_API DN_V2F32 DN_RectCenter (DN_Rect rect); DN_API bool DN_RectContainsPoint (DN_Rect rect, DN_V2F32 p); DN_API bool DN_RectContainsRect (DN_Rect a, DN_Rect b); DN_API DN_Rect DN_RectExpand (DN_Rect a, DN_F32 amount); DN_API DN_Rect DN_RectExpandV2 (DN_Rect a, DN_V2F32 amount); DN_API bool DN_RectIntersects (DN_Rect a, DN_Rect b); DN_API DN_Rect DN_RectIntersection (DN_Rect a, DN_Rect b); DN_API DN_Rect DN_RectUnion (DN_Rect a, DN_Rect b); DN_API DN_RectMinMax DN_RectGetMinMax (DN_Rect a); DN_API DN_F32 DN_RectArea (DN_Rect a); DN_API DN_V2F32 DN_RectInterpV2F32 (DN_Rect rect, DN_V2F32 t01); DN_API DN_V2F32 DN_RectTopLeft (DN_Rect rect); DN_API DN_V2F32 DN_RectTopRight (DN_Rect rect); DN_API DN_V2F32 DN_RectBottomLeft (DN_Rect rect); DN_API DN_V2F32 DN_RectBottomRight (DN_Rect rect); DN_API DN_Rect DN_RectCutLeftClip (DN_Rect *rect, DN_F32 amount, DN_RectCutClip clip); DN_API DN_Rect DN_RectCutRightClip (DN_Rect *rect, DN_F32 amount, DN_RectCutClip clip); DN_API DN_Rect DN_RectCutTopClip (DN_Rect *rect, DN_F32 amount, DN_RectCutClip clip); DN_API DN_Rect DN_RectCutBottomClip (DN_Rect *rect, DN_F32 amount, DN_RectCutClip clip); #define DN_RectCutLeft(rect, amount) DN_RectCutLeftClip(rect, amount, DN_RectCutClip_Yes) #define DN_RectCutRight(rect, amount) DN_RectCutRightClip(rect, amount, DN_RectCutClip_Yes) #define DN_RectCutTop(rect, amount) DN_RectCutTopClip(rect, amount, DN_RectCutClip_Yes) #define DN_RectCutBottom(rect, amount) DN_RectCutBottomClip(rect, amount, DN_RectCutClip_Yes) #define DN_RectCutLeftNoClip(rect, amount) DN_RectCutLeftClip(rect, amount, DN_RectCutClip_No) #define DN_RectCutRightNoClip(rect, amount) DN_RectCutRightClip(rect, amount, DN_RectCutClip_No) #define DN_RectCutTopNoClip(rect, amount) DN_RectCutTopClip(rect, amount, DN_RectCutClip_No) #define DN_RectCutBottomNoClip(rect, amount) DN_RectCutBottomClip(rect, amount, DN_RectCutClip_No) DN_API DN_Rect DN_RectCutCut (DN_RectCut rect_cut, DN_V2F32 size, DN_RectCutClip clip); #define DN_RectCutInit(rect, side) DN_Literal(DN_RectCut){rect, side} DN_API DN_RaycastV2 DN_RaycastLineIntersectV2 (DN_V2F32 origin_a, DN_V2F32 dir_a, DN_V2F32 origin_b, DN_V2F32 dir_b); DN_API DN_V2F32 DN_LerpV2F32 (DN_V2F32 a, DN_F32 t, DN_V2F32 b); DN_API DN_F32 DN_LerpF32 (DN_F32 a, DN_F32 t, DN_F32 b); #endif // !defined(DN_BASE_H)