defines.h

Go to the documentation of this file.

 
#pragma once
 
#define KNULL 0
 
// Unsigned int types.
 
typedef unsigned char u8;
 
typedef unsigned short u16;
 
typedef unsigned int u32;
 
typedef unsigned long long u64;
 
// Signed int types.
 
typedef signed char i8;
 
typedef signed short i16;
 
typedef signed int i32;
 
typedef signed long long i64;
 
// Floating point types
 
typedef float f32;
 
typedef double f64;
 
// Boolean types
 
typedef int b32;
 
typedef _Bool b8;
 
typedef struct krange {
    u64 offset;
    u64 size;
} krange;
 
typedef struct range32 {
    i32 offset;
    i32 size;
} range32;
// Properly define static assertions.
#if defined(__clang__) || defined(__GNUC__)
#   define STATIC_ASSERT _Static_assert
#else
 
#   define STATIC_ASSERT static_assert
#endif
 
// Ensure all types are of the correct size.
 
STATIC_ASSERT(sizeof(u8) == 1, "Expected u8 to be 1 byte.");
 
STATIC_ASSERT(sizeof(u16) == 2, "Expected u16 to be 2 bytes.");
 
STATIC_ASSERT(sizeof(u32) == 4, "Expected u32 to be 4 bytes.");
 
STATIC_ASSERT(sizeof(u64) == 8, "Expected u64 to be 8 bytes.");
 
STATIC_ASSERT(sizeof(i8) == 1, "Expected i8 to be 1 byte.");
 
STATIC_ASSERT(sizeof(i16) == 2, "Expected i16 to be 2 bytes.");
 
STATIC_ASSERT(sizeof(i32) == 4, "Expected i32 to be 4 bytes.");
 
STATIC_ASSERT(sizeof(i64) == 8, "Expected i64 to be 8 bytes.");
 
STATIC_ASSERT(sizeof(f32) == 4, "Expected f32 to be 4 bytes.");
 
STATIC_ASSERT(sizeof(f64) == 8, "Expected f64 to be 8 bytes.");
 
#define true 1
 
#define false 0
 
#define U64_MAX 18446744073709551615UL
#define U32_MAX 4294967295U
#define U16_MAX 65535U
#define U8_MAX 255U
#define U64_MIN 0UL
#define U32_MIN 0U
#define U16_MIN 0U
#define U8_MIN 0U
 
#define I8_MAX 127
#define I16_MAX 32767
#define I32_MAX 2147483647
#define I64_MAX 9223372036854775807L
#define I8_MIN (-I8_MAX - 1)
#define I16_MIN (-I16_MAX - 1)
#define I32_MIN (-I32_MAX - 1)
#define I64_MIN (-I64_MAX - 1)
 
#define KWHOLE_SIZE U64_MAX
 
#define INVALID_ID_U64 U64_MAX
#define INVALID_ID_U32 U32_MAX
#define INVALID_ID_U16 U16_MAX
#define INVALID_ID_U8 U8_MAX
#define INVALID_ID INVALID_ID_U32
 
// Platform detection
#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
#   define KPLATFORM_WINDOWS 1
#   ifndef _WIN64
#       error "64-bit is required on Windows!"
#   endif
#elif defined(__linux__) || defined(__gnu_linux__)
// Linux OS
#   define KPLATFORM_LINUX 1
#   if defined(__ANDROID__)
#       define KPLATFORM_ANDROID 1
#   endif
#elif defined(__unix__)
// Catch anything not caught by the above.
#   define KPLATFORM_UNIX 1
#elif defined(_POSIX_VERSION)
// Posix
#   define KPLATFORM_POSIX 1
#elif __APPLE__
// Apple platforms
#   define KPLATFORM_APPLE 1
#   include <TargetConditionals.h>
#   if TARGET_IPHONE_SIMULATOR
// iOS Simulator
#       define KPLATFORM_IOS 1
#       define KPLATFORM_IOS_SIMULATOR 1
#   elif TARGET_OS_IPHONE
#       define KPLATFORM_IOS 1
// iOS device
#   elif TARGET_OS_MAC
// HACK: Should probably be in the Vulkan Renderer lib, not here.
#       define VK_USE_PLATFORM_MACOS_MVK
// Other kinds of Mac OS
#   else
#       error "Unknown Apple platform"
#   endif
#else
#   error "Unknown platform!"
#endif
 
#ifdef KEXPORT
// Exports
#   ifdef _MSC_VER
#       define KAPI __declspec(dllexport)
#   else
#       define KAPI __attribute__((visibility("default")))
#   endif
#else
// Imports
#   ifdef _MSC_VER
#       define KAPI __declspec(dllimport)
#   else
#       define KAPI
#   endif
#endif
 
#if _DEBUG
#   define KOHI_DEBUG 1
#   define KOHI_RELEASE 0
#else
#   define KOHI_RELEASE 1
#   define KOHI_DEBUG 0
#endif
 
// Feature build flags.
 
#if KOHI_DEBUG
#   define KOHI_HOT_RELOAD 1
#else
#   define KOHI_HOT_RELOAD 0
#endif
 
#define KCLAMP(value, min, max) ((value <= min) ? min : (value >= max) ? max \
                                                                       : value)
 
// Inlining
#if defined(__clang__) || defined(__gcc__)
#   define KINLINE __attribute__((always_inline)) inline
 
#   define KNOINLINE __attribute__((noinline))
#elif defined(_MSC_VER)
 
#   define KINLINE __forceinline
 
#   define KNOINLINE __declspec(noinline)
#else
 
#   define KINLINE static inline
 
#   define KNOINLINE
#endif
 
// Deprecation
#if defined(__clang__) || defined(__gcc__)
#   define KDEPRECATED(message) __attribute__((deprecated(message)))
#elif defined(_MSC_VER)
#   define KDEPRECATED(message) __declspec(deprecated(message))
#else
#   error "Unsupported compiler - don't know how to define deprecations!"
#endif
 
#define GIBIBYTES(amount) ((amount) * 1024ULL * 1024ULL * 1024ULL)
#define MEBIBYTES(amount) ((amount) * 1024ULL * 1024ULL)
#define KIBIBYTES(amount) ((amount) * 1024ULL)
 
#define GIGABYTES(amount) ((amount) * 1000ULL * 1000ULL * 1000ULL)
#define MEGABYTES(amount) ((amount) * 1000ULL * 1000ULL)
#define KILOBYTES(amount) ((amount) * 1000ULL)
 
KINLINE u64 get_aligned(u64 operand, u64 granularity) {
    return ((operand + (granularity - 1)) & ~(granularity - 1));
}
 
KINLINE krange get_aligned_range(u64 offset, u64 size, u64 granularity) {
    return (krange){get_aligned(offset, granularity), get_aligned(size, granularity)};
}
 
#define KSWAP(type, a, b) \
    {                     \
        type temp = a;    \
        a = b;            \
        b = temp;         \
    }
 
#define KMIN(x, y) (x < y ? x : y)
#define KMAX(x, y) (x > y ? x : y)
 
#define FLAG_GET(flags, flag) ((flags & flag) == flag)
 
#define FLAG_SET(flags, flag, enabled) (flags = (enabled ? (flags | flag) : (flags & ~flag)))
 
#define UNPACK_U64_U16S(packed, a, b, c, d) \
    {                                       \
        a = (u16)(packed >> 48);            \
        b = (u16)(packed >> 32);            \
        c = (u16)(packed >> 16);            \
        d = (u16)(packed >> 0);             \
    }
 
#define UNPACK_U64_U16_AT(packed, index) ((u16)(packed >> ((3 - index) * 16)))
 
#define PACK_U64_U16S(a, b, c, d) (((u64)a << 48) | ((u64)b << 32) | ((u64)c << 16) | ((u64)d))
 
#define PACK_U64_U16_AT(target, n, index) (target = (target | ((u64)n << ((3 - index) * 16))))
 
#define UNPACK_U64_U32S(packed, a, b) \
    {                                 \
        a = (u32)(packed >> 32);      \
        b = (u32)(packed >> 0);       \
    }
 
#define UNPACK_U64_U32_AT(packed, index) ((u32)(packed >> ((1 - index) * 32)))
 
#define PACK_U64_U32S(a, b) (((u64)a << 32) | ((u64)b))
 
#define PACK_U64_U32_AT(target, n, index) (target = (target | ((u64)n << ((1 - index) * 32))))
 
#define UNPACK_U32_U16S(packed, a, b) \
    {                                 \
        a = (u16)(packed >> 16);      \
        b = (u16)(packed >> 0);       \
    }
 
#define UNPACK_U32_U16_AT(packed, index) ((u16)(packed >> ((1 - index) * 16)))
 
#define PACK_U32_U16S(a, b) (((u32)a << 16) | ((u32)b))
 
#define PACK_U32_U16_AT(target, n, index) (target = (target | ((u32)n << ((1 - index) * 16))))
 
#define IS_IN_RANGE(val, from, to) ((from < to) ? (val >= from && val <= to) : (val <= from && val >= to))