defines.h File Reference

This file contains global type definitions which are used throughout the entire engine and applications referencing it. Numeric types are asserted statically to gurantee expected size. More...

Go to the source code of this file.

Data Structures
struct	krange
	A range, typically of memory. More...
struct	range32
	A range, typically of memory. More...

Macros
#define	KNULL   0
#define	STATIC_ASSERT   static_assert
	Static assertion. More...
#define	true   1
	True. More...
#define	false   0
	False. More...
#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
	Any id set to this should be considered invalid, and not actually pointing to a real object. More...
#define	INVALID_ID_U32   U32_MAX
#define	INVALID_ID_U16   U16_MAX
#define	INVALID_ID_U8   U8_MAX
#define	INVALID_ID   INVALID_ID_U32
#define	KAPI
	Import/export qualifier. More...
#define	KOHI_RELEASE   1
#define	KOHI_DEBUG   0
#define	KOHI_HOT_RELOAD   0
#define	KCLAMP(value, min, max)
	Clamps value to a range of min and max (inclusive). More...
#define	KINLINE   static inline
	Inline qualifier. More...
#define	KNOINLINE
	No-inline qualifier. More...
#define	GIBIBYTES(amount)   ((amount) * 1024ULL * 1024ULL * 1024ULL)
	Gets the number of bytes from amount of gibibytes (GiB) (1024*1024*1024) More...
#define	MEBIBYTES(amount)   ((amount) * 1024ULL * 1024ULL)
	Gets the number of bytes from amount of mebibytes (MiB) (1024*1024) More...
#define	KIBIBYTES(amount)   ((amount) * 1024ULL)
	Gets the number of bytes from amount of kibibytes (KiB) (1024) More...
#define	GIGABYTES(amount)   ((amount) * 1000ULL * 1000ULL * 1000ULL)
	Gets the number of bytes from amount of gigabytes (GB) (1000*1000*1000) More...
#define	MEGABYTES(amount)   ((amount) * 1000ULL * 1000ULL)
	Gets the number of bytes from amount of megabytes (MB) (1000*1000) More...
#define	KILOBYTES(amount)   ((amount) * 1000ULL)
	Gets the number of bytes from amount of kilobytes (KB) (1000) More...
#define	KSWAP(type, a, b)
#define	KMIN(x, y)   (x < y ? x : y)
#define	KMAX(x, y)   (x > y ? x : y)
#define	FLAG_GET(flags, flag)   ((flags & flag) == flag)
	Indicates if the provided flag is set in the given flags int. More...
#define	FLAG_SET(flags, flag, enabled)   (flags = (enabled ? (flags | flag) : (flags & ~flag)))
	Sets a flag within the flags int to enabled/disabled. More...
#define	UNPACK_U64_U16S(packed, a, b, c, d)
#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))
	Packs 4 u16s into a single u64. More...
#define	PACK_U64_U16_AT(target, n, index)   (target = (target | ((u64)n << ((3 - index) * 16))))
	Packs n into target. Target can be an already-packed u64. More...
#define	UNPACK_U64_U32S(packed, a, b)
#define	UNPACK_U64_U32_AT(packed, index)   ((u32)(packed >> ((1 - index) * 32)))
#define	PACK_U64_U32S(a, b)   (((u64)a << 32) | ((u64)b))
	Packs 2 u32s into a single u64. More...
#define	PACK_U64_U32_AT(target, n, index)   (target = (target | ((u64)n << ((1 - index) * 32))))
	Packs n into target. Target can be an already-packed u64. More...
#define	UNPACK_U32_U16S(packed, a, b)
#define	UNPACK_U32_U16_AT(packed, index)   ((u16)(packed >> ((1 - index) * 16)))
#define	PACK_U32_U16S(a, b)   (((u32)a << 16) | ((u32)b))
	Packs 2 u16s into a single u32. More...
#define	PACK_U32_U16_AT(target, n, index)   (target = (target | ((u32)n << ((1 - index) * 16))))
	Packs n into target. Target can be an already-packed u32. More...
#define	IS_IN_RANGE(val, from, to)   ((from < to) ? (val >= from && val <= to) : (val <= from && val >= to))

Typedefs
typedef unsigned char	u8
	Unsigned 8-bit integer. More...
typedef unsigned short	u16
	Unsigned 16-bit integer. More...
typedef unsigned int	u32
	Unsigned 32-bit integer. More...
typedef unsigned long long	u64
	Unsigned 64-bit integer. More...
typedef signed char	i8
	Signed 8-bit integer. More...
typedef signed short	i16
	Signed 16-bit integer. More...
typedef signed int	i32
	Signed 32-bit integer. More...
typedef signed long long	i64
	Signed 64-bit integer. More...
typedef float	f32
	32-bit floating point number More...
typedef double	f64
	64-bit floating point number More...
typedef int	b32
	32-bit boolean type, used for APIs which require it More...
typedef _Bool	b8
	8-bit boolean type More...
typedef struct krange	krange
	A range, typically of memory. More...
typedef struct range32	range32
	A range, typically of memory. More...

Functions
	STATIC_ASSERT (sizeof(u8)==1, "Expected u8 to be 1 byte.")
	Assert u8 to be 1 byte. More...
	STATIC_ASSERT (sizeof(u16)==2, "Expected u16 to be 2 bytes.")
	Assert u16 to be 2 bytes. More...
	STATIC_ASSERT (sizeof(u32)==4, "Expected u32 to be 4 bytes.")
	Assert u32 to be 4 bytes. More...
	STATIC_ASSERT (sizeof(u64)==8, "Expected u64 to be 8 bytes.")
	Assert u64 to be 8 bytes. More...
	STATIC_ASSERT (sizeof(i8)==1, "Expected i8 to be 1 byte.")
	Assert i8 to be 1 byte. More...
	STATIC_ASSERT (sizeof(i16)==2, "Expected i16 to be 2 bytes.")
	Assert i16 to be 2 bytes. More...
	STATIC_ASSERT (sizeof(i32)==4, "Expected i32 to be 4 bytes.")
	Assert i32 to be 4 bytes. More...
	STATIC_ASSERT (sizeof(i64)==8, "Expected i64 to be 8 bytes.")
	Assert i64 to be 8 bytes. More...
	STATIC_ASSERT (sizeof(f32)==4, "Expected f32 to be 4 bytes.")
	Assert f32 to be 4 bytes. More...
	STATIC_ASSERT (sizeof(f64)==8, "Expected f64 to be 8 bytes.")
	Assert f64 to be 8 bytes. More...
KINLINE u64	get_aligned (u64 operand, u64 granularity)
KINLINE krange	get_aligned_range (u64 offset, u64 size, u64 granularity)

Detailed Description

This file contains global type definitions which are used throughout the entire engine and applications referencing it. Numeric types are asserted statically to gurantee expected size.

Author

Travis Vroman (travi.nosp@m.s@ko.nosp@m.hieng.nosp@m.ine..nosp@m.com)

Version

2.0

Date

2024-04-03

Copyright

Kohi Game Engine is Copyright (c) Travis Vroman 2021-2024

Macro Definition Documentation

false

#define false   0

False.

FLAG_GET

#define FLAG_GET	(		flags,
			flag
	)		((flags & flag) == flag)

Indicates if the provided flag is set in the given flags int.

FLAG_SET

#define FLAG_SET	(		flags,
			flag,
			enabled
	)		(flags = (enabled ? (flags | flag) : (flags & ~flag)))

Sets a flag within the flags int to enabled/disabled.

Parameters

flags	The flags int to write to.
flag	The flag to set.
enabled	Indicates if the flag is enabled or not.

GIBIBYTES

#define GIBIBYTES

(

amount

)

((amount) * 1024ULL * 1024ULL * 1024ULL)

Gets the number of bytes from amount of gibibytes (GiB) (1024*1024*1024)

GIGABYTES

#define GIGABYTES

(

amount

)

((amount) * 1000ULL * 1000ULL * 1000ULL)

Gets the number of bytes from amount of gigabytes (GB) (1000*1000*1000)

I16_MAX

#define I16_MAX   32767

I16_MIN

#define I16_MIN   (-I16_MAX - 1)

I32_MAX

#define I32_MAX   2147483647

I32_MIN

#define I32_MIN   (-I32_MAX - 1)

I64_MAX

#define I64_MAX   9223372036854775807L

I64_MIN

#define I64_MIN   (-I64_MAX - 1)

I8_MAX

#define I8_MAX   127

I8_MIN

#define I8_MIN   (-I8_MAX - 1)

INVALID_ID

#define INVALID_ID   INVALID_ID_U32

INVALID_ID_U16

#define INVALID_ID_U16   U16_MAX

INVALID_ID_U32

#define INVALID_ID_U32   U32_MAX

INVALID_ID_U64

#define INVALID_ID_U64   U64_MAX

Any id set to this should be considered invalid, and not actually pointing to a real object.

INVALID_ID_U8

#define INVALID_ID_U8   U8_MAX

IS_IN_RANGE

#define IS_IN_RANGE	(		val,
			from,
			to
	)		((from < to) ? (val >= from && val <= to) : (val <= from && val >= to))

KAPI

#define KAPI

Import/export qualifier.

KCLAMP

#define KCLAMP	(		value,
			min,
			max
	)

Value:

                                                                       ((value <= min) ? min : (value >= max) ? max \
                                                                       : value)

Clamps value to a range of min and max (inclusive).

Parameters

value	The value to be clamped.
min	The minimum value of the range.
max	The maximum value of the range.

Returns

The clamped value.

KIBIBYTES

#define KIBIBYTES

(

amount

)

((amount) * 1024ULL)

Gets the number of bytes from amount of kibibytes (KiB) (1024)

KILOBYTES

#define KILOBYTES

(

amount

)

((amount) * 1000ULL)

Gets the number of bytes from amount of kilobytes (KB) (1000)

KINLINE

#define KINLINE   static inline

Inline qualifier.

KMAX

#define KMAX	(		x,
			y
	)		(x > y ? x : y)

KMIN

#define KMIN	(		x,
			y
	)		(x < y ? x : y)

KNOINLINE

#define KNOINLINE

No-inline qualifier.

KNULL

#define KNULL   0

KOHI_DEBUG

#define KOHI_DEBUG   0

KOHI_HOT_RELOAD

#define KOHI_HOT_RELOAD   0

KOHI_RELEASE

#define KOHI_RELEASE   1

KSWAP

#define KSWAP	(		type,
			a,
			b
	)

Value:

    {                     \
        type temp = a;    \
        a = b;            \
        b = temp;         \
    }

KWHOLE_SIZE

#define KWHOLE_SIZE   U64_MAX

MEBIBYTES

#define MEBIBYTES

(

amount

)

((amount) * 1024ULL * 1024ULL)

Gets the number of bytes from amount of mebibytes (MiB) (1024*1024)

MEGABYTES

#define MEGABYTES

(

amount

)

((amount) * 1000ULL * 1000ULL)

Gets the number of bytes from amount of megabytes (MB) (1000*1000)

PACK_U32_U16_AT

#define PACK_U32_U16_AT	(		target,
			n,
			index
	)		(target = (target | ((u32)n << ((1 - index) * 16))))

Packs n into target. Target can be an already-packed u32.

Parameters

target	The u32 to be packed into.
n	The u16 to be packed.
index	The index to pack at (0-1).

PACK_U32_U16S

#define PACK_U32_U16S	(		a,
			b
	)		(((u32)a << 16) | ((u32)b))

Packs 2 u16s into a single u32.

PACK_U64_U16_AT

#define PACK_U64_U16_AT	(		target,
			n,
			index
	)		(target = (target | ((u64)n << ((3 - index) * 16))))

Packs n into target. Target can be an already-packed u64.

Parameters

target	The u64 to be packed into.
n	The u16 to be packed.
index	The index to pack at (0-3).

PACK_U64_U16S

#define PACK_U64_U16S	(		a,
			b,
			c,
			d
	)		(((u64)a << 48) | ((u64)b << 32) | ((u64)c << 16) | ((u64)d))

Packs 4 u16s into a single u64.

PACK_U64_U32_AT

#define PACK_U64_U32_AT	(		target,
			n,
			index
	)		(target = (target | ((u64)n << ((1 - index) * 32))))

Packs n into target. Target can be an already-packed u64.

Parameters

target	The u64 to be packed into.
n	The u32 to be packed.
index	The index to pack at (0-1).

PACK_U64_U32S

#define PACK_U64_U32S	(		a,
			b
	)		(((u64)a << 32) | ((u64)b))

Packs 2 u32s into a single u64.

STATIC_ASSERT

#define STATIC_ASSERT   static_assert

Static assertion.

true

#define true   1

True.

U16_MAX

#define U16_MAX   65535U

U16_MIN

#define U16_MIN   0U

U32_MAX

#define U32_MAX   4294967295U

U32_MIN

#define U32_MIN   0U

U64_MAX

#define U64_MAX   18446744073709551615UL

U64_MIN

#define U64_MIN   0UL

U8_MAX

#define U8_MAX   255U

U8_MIN

#define U8_MIN   0U

UNPACK_U32_U16_AT

#define UNPACK_U32_U16_AT	(		packed,
			index
	)		((u16)(packed >> ((1 - index) * 16)))

Unpacks a single u16 at the given index (0-1).

UNPACK_U32_U16S

#define UNPACK_U32_U16S	(		packed,
			a,
			b
	)

Value:

    {                                 \
        a = (u16)(packed >> 16);      \
        b = (u16)(packed >> 0);       \
    }

Unpacks 2 u16s from a single u32.

Parameters

packed	The packed u32.
a	A pointer to a u16 to hold the first value.
b	A pointer to a u16 to hold the second value.

UNPACK_U64_U16_AT

#define UNPACK_U64_U16_AT	(		packed,
			index
	)		((u16)(packed >> ((3 - index) * 16)))

Unpacks a single u16 at the given index (0-3).

UNPACK_U64_U16S

#define UNPACK_U64_U16S	(		packed,
			a,
			b,
			c,
			d
	)

Value:

    {                                       \
        a = (u16)(packed >> 48);            \
        b = (u16)(packed >> 32);            \
        c = (u16)(packed >> 16);            \
        d = (u16)(packed >> 0);             \
    }

Unpacks 4 u16s from a single u64.

Parameters

packed	The packed u64.
a	A pointer to a u16 to hold the first value.
b	A pointer to a u16 to hold the second value.
c	A pointer to a u16 to hold the third value.
d	A pointer to a u16 to hold the fourth value.

UNPACK_U64_U32_AT

#define UNPACK_U64_U32_AT	(		packed,
			index
	)		((u32)(packed >> ((1 - index) * 32)))

Unpacks a single u32 at the given index (0-1).

UNPACK_U64_U32S

#define UNPACK_U64_U32S	(		packed,
			a,
			b
	)

Value:

    {                                 \
        a = (u32)(packed >> 32);      \
        b = (u32)(packed >> 0);       \
    }

Unpacks 2 u32s from a single u64.

Parameters

packed	The packed u64.
a	A pointer to a u32 to hold the first value.
b	A pointer to a u32 to hold the second value.

Typedef Documentation

b32

typedef int b32

32-bit boolean type, used for APIs which require it

b8

typedef _Bool b8

8-bit boolean type

f32

typedef float f32

32-bit floating point number

f64

typedef double f64

64-bit floating point number

i16

typedef signed short i16

Signed 16-bit integer.

i32

typedef signed int i32

Signed 32-bit integer.

i64

typedef signed long long i64

Signed 64-bit integer.

i8

typedef signed char i8

Signed 8-bit integer.

krange

typedef struct krange krange

A range, typically of memory.

range32

typedef struct range32 range32

A range, typically of memory.

u16

typedef unsigned short u16

Unsigned 16-bit integer.

u32

typedef unsigned int u32

Unsigned 32-bit integer.

u64

typedef unsigned long long u64

Unsigned 64-bit integer.

u8

typedef unsigned char u8

Unsigned 8-bit integer.

Function Documentation

get_aligned()

KINLINE u64 get_aligned	(	u64	operand,
		u64	granularity
	)

get_aligned_range()

KINLINE krange get_aligned_range	(	u64	offset,
		u64	size,
		u64	granularity
	)

STATIC_ASSERT() [1/10]

STATIC_ASSERT	(	sizeof(f32)	= =4,
		"Expected f32 to be 4 bytes."
	)

Assert f32 to be 4 bytes.

STATIC_ASSERT() [2/10]

STATIC_ASSERT	(	sizeof(f64)	= =8,
		"Expected f64 to be 8 bytes."
	)

Assert f64 to be 8 bytes.

STATIC_ASSERT() [3/10]

STATIC_ASSERT	(	sizeof(i16)	= =2,
		"Expected i16 to be 2 bytes."
	)

Assert i16 to be 2 bytes.

STATIC_ASSERT() [4/10]

STATIC_ASSERT	(	sizeof(i32)	= =4,
		"Expected i32 to be 4 bytes."
	)

Assert i32 to be 4 bytes.

STATIC_ASSERT() [5/10]

STATIC_ASSERT	(	sizeof(i64)	= =8,
		"Expected i64 to be 8 bytes."
	)

Assert i64 to be 8 bytes.

STATIC_ASSERT() [6/10]

STATIC_ASSERT	(	sizeof(i8)	= =1,
		"Expected i8 to be 1 byte."
	)

Assert i8 to be 1 byte.

STATIC_ASSERT() [7/10]

STATIC_ASSERT	(	sizeof(u16)	= =2,
		"Expected u16 to be 2 bytes."
	)

Assert u16 to be 2 bytes.

STATIC_ASSERT() [8/10]

STATIC_ASSERT	(	sizeof(u32)	= =4,
		"Expected u32 to be 4 bytes."
	)

Assert u32 to be 4 bytes.

STATIC_ASSERT() [9/10]

STATIC_ASSERT	(	sizeof(u64)	= =8,
		"Expected u64 to be 8 bytes."
	)

Assert u64 to be 8 bytes.

STATIC_ASSERT() [10/10]

STATIC_ASSERT	(	sizeof(u8)	= =1,
		"Expected u8 to be 1 byte."
	)

Assert u8 to be 1 byte.