Fix alignment in gb_heap_allocator_proc
This commit is contained in:
gingerBill
parent
950be6d62c
commit
09ca605931
|
|
@ -4,8 +4,8 @@ gb single-file public domain libraries for C & C++
|
|||
|
||||
library | latest version | category | languages | description
|
||||
----------------|----------------|----------|-----------|-------------
|
||||
**gb.h** | 0.07 | misc | C, C++ | A C helper library for C & C++
|
||||
**gb_math.h** | 0.06a | math | C, C++ | A C/C++ vector math library geared towards game development
|
||||
**gb.h** | 0.07a | misc | C, C++ | A C helper library for C & C++
|
||||
**gb_math.h** | 0.06b | math | C, C++ | A C/C++ vector math library geared towards game development
|
||||
**gb_gl.h** | 0.04a | graphics | C, C++ | A C/C++ OpenGL Helper Library
|
||||
**gb_string.h** | 0.95 | strings | C, C++ | A better string library for C & C++ (this is built into gb.h too with custom allocator support!)
|
||||
**gb_ini.h** | 0.93 | misc | C, C++ | A simple ini file loader library for C & C++
|
||||
|
|
|
|||
236
gb.h
236
gb.h
|
|
@ -1,4 +1,4 @@
|
|||
/* gb.h - v0.07 - Ginger Bill's C Helper Library - public domain
|
||||
/* gb.h - v0.07a - Ginger Bill's C Helper Library - public domain
|
||||
- no warranty implied; use at your own risk
|
||||
|
||||
This is a single header file with a bunch of useful stuff
|
||||
|
|
@ -26,6 +26,7 @@ Conventions used:
|
|||
|
||||
|
||||
Version History:
|
||||
0.07a - Fix alignment in gb_heap_allocator_proc
|
||||
0.07 - Hash Table and Hashing Functions
|
||||
0.06c - Better Documentation
|
||||
0.06b - OS X Support
|
||||
|
|
@ -174,8 +175,10 @@ extern "C" {
|
|||
|
||||
#include <stdarg.h>
|
||||
#include <stddef.h>
|
||||
#include <stdio.h> /* TODO(bill): Remove and replace with OS Specific stuff */
|
||||
#include <string.h> /* NOTE(bill): For memcpy, memmove, memcmp, etc. */
|
||||
#include <stdio.h> /* TODO(bill): Remove and replace with OS Specific stuff */
|
||||
#include <stdlib.h>
|
||||
#include <string.h> /* NOTE(bill): For memcpy, memmove, memcmp, etc. */
|
||||
#include <sys/stat.h> /* NOTE(bill): File info */
|
||||
|
||||
#if defined(GB_SYSTEM_WINDOWS)
|
||||
#define NOMINMAX 1
|
||||
|
|
@ -183,20 +186,19 @@ extern "C" {
|
|||
#define WIN32_MEAN_AND_LEAN 1
|
||||
#define VC_EXTRALEAN 1
|
||||
#include <windows.h>
|
||||
#include <direct.h>
|
||||
#include <process.h>
|
||||
#include <malloc.h>
|
||||
#else
|
||||
#include <pthread.h>
|
||||
#include <time.h>
|
||||
#include <mach/mach_time.h>
|
||||
#include <sys/stat.h>
|
||||
#include <dlfcn.h>
|
||||
#include <mach/mach_time.h>
|
||||
#include <pthread.h>
|
||||
#include <sys/stat.h>
|
||||
#include <time.h>
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
|
||||
|
||||
#if !defined(GB_NO_STDLIB)
|
||||
#include <stdlib.h>
|
||||
#endif
|
||||
|
||||
#ifndef gb_malloc
|
||||
#define gb_malloc(sz) malloc(sz)
|
||||
#endif
|
||||
|
|
@ -712,6 +714,7 @@ gb_init_mutex(&m);
|
|||
}
|
||||
#endif
|
||||
|
||||
/* TODO(bill): Should I create a Condition Type? */
|
||||
|
||||
|
||||
typedef struct gbSemaphore {
|
||||
|
|
@ -746,8 +749,8 @@ typedef struct gbThread {
|
|||
void *data;
|
||||
|
||||
gbSemaphore semaphore;
|
||||
isize stack_size;
|
||||
b32 is_running;
|
||||
isize stack_size;
|
||||
b32 is_running;
|
||||
} gbThread;
|
||||
|
||||
GB_DEF void gb_init_thread (gbThread *t);
|
||||
|
|
@ -757,6 +760,7 @@ GB_DEF void gb_start_thread_with_stack(gbThread *t, gbThreadProc *proc, void *da
|
|||
GB_DEF void gb_join_thread (gbThread *t);
|
||||
GB_DEF b32 gb_is_thread_running (gbThread const *t);
|
||||
GB_DEF u32 gb_current_thread_id (void);
|
||||
GB_DEF void gb_set_thread_name (gbThread *t, char const *name);
|
||||
|
||||
/***************************************************************
|
||||
*
|
||||
|
|
@ -839,7 +843,7 @@ GB_DEF void *gb_alloc_copy_align(gbAllocator a, void const *src, isize size, isi
|
|||
GB_DEF char *gb_alloc_cstring(gbAllocator a, char const *str);
|
||||
|
||||
|
||||
/* NOTE(bill): These are very useful and the type case has saved me from numerous bugs */
|
||||
/* NOTE(bill): These are very useful and the type cast has saved me from numerous bugs */
|
||||
#ifndef gb_alloc_struct
|
||||
#define gb_alloc_struct(allocator, Type) (Type *)gb_alloc_align(allocator, gb_size_of(Type))
|
||||
#define gb_alloc_array(allocator, Type, count) (Type *)gb_alloc(allocator, gb_size_of(Type) * (count))
|
||||
|
|
@ -1404,9 +1408,17 @@ GB_DEF gbHashTableEntry const *gb_find_next_hash_table_entry (gbHashTable const
|
|||
*/
|
||||
typedef u64 gbFileTime;
|
||||
|
||||
typedef enum gbFileAccess {
|
||||
GB_FILE_ACCESS_READ = 1,
|
||||
GB_FILE_ACCESS_WRITE = 2
|
||||
} gbFileAccess;
|
||||
|
||||
typedef enum gbFileType {
|
||||
GB_FILE_TYPE_READ = 1,
|
||||
GB_FILE_TYPE_WRITE = 2
|
||||
GB_FILE_TYPE_UNKNOWN,
|
||||
GB_FILE_TYPE_FILE,
|
||||
GB_FILE_TYPE_DIRECTORY,
|
||||
|
||||
GB_FILE_TYPE_COUNT
|
||||
} gbFileType;
|
||||
|
||||
typedef struct gbFile {
|
||||
|
|
@ -1414,6 +1426,7 @@ typedef struct gbFile {
|
|||
char *path;
|
||||
i64 size;
|
||||
b32 is_open;
|
||||
gbFileAccess access;
|
||||
gbFileType type;
|
||||
gbFileTime last_write_time;
|
||||
} gbFile;
|
||||
|
|
@ -1509,6 +1522,16 @@ GB_DEF void gb_get_local_date (gbDate *date);
|
|||
*
|
||||
*/
|
||||
|
||||
GB_DEF void gb_yield(void);
|
||||
GB_DEF void gb_set_env(char const *name, char const *value);
|
||||
GB_DEF void gb_unset_env(char const *name);
|
||||
GB_DEF i32 gb_chdir(char const *path);
|
||||
GB_DEF void gb_get_working_cmd(char *buffer, isize len);
|
||||
|
||||
GB_DEF u16 gb_endian_swap16(u16 i);
|
||||
GB_DEF u32 gb_endian_swap32(u32 i);
|
||||
GB_DEF u64 gb_endian_swap64(u64 i);
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
@ -2461,6 +2484,40 @@ gb_current_thread_id(void)
|
|||
|
||||
|
||||
|
||||
void
|
||||
gb_set_thread_name(gbThread *t, char const *name)
|
||||
{
|
||||
#if defined(_MSC_VER)
|
||||
/* TODO(bill): Bloody Windows!!! */
|
||||
#pragma pack(push, 8)
|
||||
struct gbprivThreadName {
|
||||
DWORD type;
|
||||
LPCSTR name;
|
||||
DWORD id;
|
||||
DWORD flags;
|
||||
};
|
||||
#pragma pack(pop)
|
||||
struct gbprivThreadName tn;
|
||||
tn.type = 0x1000;
|
||||
tn.name = name;
|
||||
tn.id = GetThreadId(t->win32_handle);
|
||||
tn.flags = 0;
|
||||
|
||||
__try {
|
||||
RaiseException(0x406d1388, 0, gb_size_of(tn)/4, cast(ULONG_PTR *)&tn);
|
||||
} __except(EXCEPTION_EXECUTE_HANDLER) {
|
||||
}
|
||||
|
||||
#elif defined(GB_SYSTEM_OSX)
|
||||
/* TODO(bill): Test if this works */
|
||||
pthread_setname_np(name);
|
||||
#else
|
||||
/* TODO(bill): Test if this works */
|
||||
pthread_setname_np(t->posix_handle, name);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
@ -2476,25 +2533,34 @@ gb_heap_allocator(void)
|
|||
|
||||
GB_ALLOCATOR_PROC(gb_heap_allocator_proc)
|
||||
{
|
||||
/* TODO(bill): Throughly test! */
|
||||
switch (type) {
|
||||
case GB_ALLOCATION_ALLOC: {
|
||||
void *ptr;
|
||||
isize actual_size = size + alignment;
|
||||
ptr = gb_align_forward(gb_malloc(actual_size), alignment);
|
||||
|
||||
return ptr;
|
||||
#if defined(_MSC_VER)
|
||||
return _aligned_malloc(size, alignment);
|
||||
#else
|
||||
return aligned_alloc(alignment, size);
|
||||
#endif
|
||||
} break;
|
||||
|
||||
case GB_ALLOCATION_FREE: {
|
||||
gb_mfree(old_memory);
|
||||
#if defined(_MSC_VER)
|
||||
_aligned_free(old_memory);
|
||||
#else
|
||||
free(old_memory);
|
||||
#endif
|
||||
} break;
|
||||
|
||||
case GB_ALLOCATION_FREE_ALL:
|
||||
break;
|
||||
|
||||
case GB_ALLOCATION_RESIZE: {
|
||||
#if defined(_MSC_VER)
|
||||
return _aligned_realloc(old_memory, size, alignment);
|
||||
#else
|
||||
gbAllocator a = gb_heap_allocator();
|
||||
return gb_default_resize_align(a, old_memory, old_size, size, alignment);
|
||||
#endif
|
||||
} break;
|
||||
}
|
||||
|
||||
|
|
@ -4337,7 +4403,7 @@ gb_create_file(gbFile *file, char const *filepath, ...)
|
|||
file->path = gb_alloc_cstring(gb_heap_allocator(), path);
|
||||
file->size = gb_file_size(file);
|
||||
file->is_open = true;
|
||||
file->type = GB_FILE_TYPE_WRITE;
|
||||
file->access = GB_FILE_ACCESS_WRITE;
|
||||
file->last_write_time = gb_file_last_write_time(file->path);
|
||||
return true;
|
||||
}
|
||||
|
|
@ -4362,7 +4428,29 @@ gb_open_file(gbFile *file, char const *filepath, ...)
|
|||
file->path = gb_alloc_cstring(gb_heap_allocator(), path);
|
||||
file->size = gb_file_size(file);
|
||||
file->is_open = true;
|
||||
file->type = GB_FILE_TYPE_READ;
|
||||
file->access = GB_FILE_ACCESS_READ;
|
||||
file->type = GB_FILE_TYPE_UNKNOWN;
|
||||
#if defined(_MSC_VER)
|
||||
{
|
||||
struct _stat64 st;
|
||||
if (_stat64(path, &st) == 0) {
|
||||
if ((st.st_mode & _S_IFREG) != 0)
|
||||
file->type = GB_FILE_TYPE_FILE;
|
||||
else if ((st.st_mode & _S_IFDIR) != 0)
|
||||
file->type = GB_FILE_TYPE_DIRECTORY;
|
||||
}
|
||||
}
|
||||
#else
|
||||
{
|
||||
struct stat64 st;
|
||||
if (stat64(path, &st) == 0) {
|
||||
if ((st.st_mode & S_IFREG) != 0)
|
||||
file->type = GB_FILE_TYPE_FILE;
|
||||
else if ((st.st_mode & S_IFDIR) != 0)
|
||||
file->type = GB_FILE_TYPE_DIRECTORY;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
file->last_write_time = gb_file_last_write_time(file->path);
|
||||
return true;
|
||||
}
|
||||
|
|
@ -4387,7 +4475,7 @@ gb_file_read_at(gbFile *file, void *buffer, isize size, i64 offset)
|
|||
{
|
||||
i64 prev_cursor_pos;
|
||||
|
||||
GB_ASSERT(file->type == GB_FILE_TYPE_READ);
|
||||
GB_ASSERT(file->access == GB_FILE_ACCESS_READ);
|
||||
|
||||
prev_cursor_pos = ftell(cast(FILE *)file->handle);
|
||||
fseek(cast(FILE *)file->handle, offset, SEEK_SET);
|
||||
|
|
@ -4402,7 +4490,7 @@ gb_file_write_at(gbFile *file, void const *buffer, isize size, i64 offset)
|
|||
isize written_size;
|
||||
i64 prev_cursor_pos;
|
||||
|
||||
GB_ASSERT(file->type == GB_FILE_TYPE_WRITE);
|
||||
GB_ASSERT(file->access == GB_FILE_ACCESS_WRITE);
|
||||
|
||||
prev_cursor_pos = ftell(cast(FILE *)file->handle);
|
||||
fseek(cast(FILE *)file->handle, offset, SEEK_SET);
|
||||
|
|
@ -4788,6 +4876,102 @@ gb_inline gbDllProc gb_dll_proc_address(gbDllHandle dll, char const *proc_name)
|
|||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
/***************************************************************
|
||||
*
|
||||
* Miscellany
|
||||
*
|
||||
*/
|
||||
|
||||
gb_inline void
|
||||
gb_yield(void)
|
||||
{
|
||||
#if defined(GB_SYSTEM_WINDOWS)
|
||||
Sleep(0);
|
||||
#else
|
||||
sched_yield();
|
||||
#endif
|
||||
}
|
||||
|
||||
gb_inline void
|
||||
gb_set_env(char const *name, char const *value)
|
||||
{
|
||||
#if defined(GB_SYSTEM_WINDOWS)
|
||||
SetEnvironmentVariableA(name, value);
|
||||
#else
|
||||
setenv(name, value, 1);
|
||||
#endif
|
||||
}
|
||||
|
||||
gb_inline void
|
||||
gb_unset_env(char const *name)
|
||||
{
|
||||
#if defined(GB_SYSTEM_WINDOWS)
|
||||
SetEnvironmentVariableA(name, NULL);
|
||||
#else
|
||||
unsetenv(name);
|
||||
#endif
|
||||
}
|
||||
|
||||
gb_inline i32
|
||||
gb_chdir(char const *path)
|
||||
{
|
||||
#if defined(_MSC_VER)
|
||||
return _chdir(path);
|
||||
#else
|
||||
return chdir(path);
|
||||
#endif
|
||||
}
|
||||
|
||||
gb_inline void
|
||||
gb_get_working_cmd(char *buffer, isize len)
|
||||
{
|
||||
#if defined(_MSC_VER)
|
||||
_getcwd(buffer, cast(int)len);
|
||||
#else
|
||||
getcwd(buffer, len);
|
||||
#endif
|
||||
}
|
||||
|
||||
gb_inline u16
|
||||
gb_endian_swap16(u16 i)
|
||||
{
|
||||
return (i>>8) | (i<<8);
|
||||
}
|
||||
|
||||
gb_inline u32
|
||||
gb_endian_swap32(u32 i)
|
||||
{
|
||||
return (i>>24) |(i<<24) |
|
||||
((i&0x00ff0000)>>8) | ((i&0x00ff0000)<<8);
|
||||
}
|
||||
|
||||
gb_inline u64
|
||||
gb_endian_swap64(u64 i)
|
||||
{
|
||||
/* TODO(bill): Do I really need the cast here? */
|
||||
return (i>>56) | (i<<56) |
|
||||
((i&cast(u64)0x00ff000000000000)>>40) | ((i&cast(u64)0x000000000000ff00)<<40) |
|
||||
((i&cast(u64)0x0000ff0000000000)>>24) | ((i&cast(u64)0x0000000000ff0000)<<24) |
|
||||
((i&cast(u64)0x000000ff00000000)>>8) | ((i&cast(u64)0x00000000ff000000)<<8);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/***************************************************************
|
||||
*
|
||||
* Colour Type
|
||||
* It's quite useful
|
||||
*/
|
||||
|
||||
|
||||
|
||||
|
||||
#if !defined(GB_NO_COLOUR_TYPE)
|
||||
gb_inline gbColour
|
||||
gb_colour(f32 r, f32 g, f32 b, f32 a)
|
||||
|
|
|
|||
161
gb_math.h
161
gb_math.h
|
|
@ -1,8 +1,9 @@
|
|||
/* gb_math.h - v0.06a - public domain C math library - no warranty implied; use at your own risk
|
||||
/* gb_math.h - v0.06b - public domain C math library - no warranty implied; use at your own risk
|
||||
A C math library geared towards game development
|
||||
use '#define GB_MATH_IMPLEMENTATION' before including to create the implementation in _ONE_ file
|
||||
|
||||
Version History:
|
||||
0.06b - Just formatting
|
||||
0.06a - Implement rough versions of mod, remainder, copy_sign
|
||||
0.06 - Windows GCC Support and C90-ish Support
|
||||
0.05 - Less/no dependencies or CRT
|
||||
|
|
@ -205,50 +206,49 @@ GB_MATH_DEF float gb_angle_diff(float radians_a, float radians_b);
|
|||
#define gb_max(a, b) ((a) > (b) ? (a) : (b))
|
||||
#endif
|
||||
|
||||
GB_MATH_DEF float gb_copy_sign(float x, float y);
|
||||
GB_MATH_DEF float gb_remainder(float x, float y);
|
||||
GB_MATH_DEF float gb_mod(float x, float y);
|
||||
GB_MATH_DEF float gb_sqrt(float a);
|
||||
GB_MATH_DEF float gb_rsqrt(float a);
|
||||
GB_MATH_DEF float gb_copy_sign (float x, float y);
|
||||
GB_MATH_DEF float gb_remainder (float x, float y);
|
||||
GB_MATH_DEF float gb_mod (float x, float y);
|
||||
GB_MATH_DEF float gb_sqrt (float a);
|
||||
GB_MATH_DEF float gb_rsqrt (float a);
|
||||
GB_MATH_DEF float gb_quake_rsqrt(float a); /* NOTE(bill): It's probably better to use 1.0f/gb_sqrt(a)
|
||||
* And for simd, there is usually isqrt functions too!
|
||||
*/
|
||||
GB_MATH_DEF float gb_sin(float radians);
|
||||
GB_MATH_DEF float gb_cos(float radians);
|
||||
GB_MATH_DEF float gb_tan(float radians);
|
||||
GB_MATH_DEF float gb_arcsin(float a);
|
||||
GB_MATH_DEF float gb_arccos(float a);
|
||||
GB_MATH_DEF float gb_arctan(float a);
|
||||
GB_MATH_DEF float gb_sin (float radians);
|
||||
GB_MATH_DEF float gb_cos (float radians);
|
||||
GB_MATH_DEF float gb_tan (float radians);
|
||||
GB_MATH_DEF float gb_arcsin (float a);
|
||||
GB_MATH_DEF float gb_arccos (float a);
|
||||
GB_MATH_DEF float gb_arctan (float a);
|
||||
GB_MATH_DEF float gb_arctan2(float y, float x);
|
||||
|
||||
|
||||
GB_MATH_DEF float gb_exp(float x);
|
||||
GB_MATH_DEF float gb_exp2(float x);
|
||||
GB_MATH_DEF float gb_log(float x);
|
||||
GB_MATH_DEF float gb_log2(float x);
|
||||
GB_MATH_DEF float gb_fast_exp(float x); /* NOTE(bill): Only valid from -1 <= x <= +1 */
|
||||
GB_MATH_DEF float gb_exp (float x);
|
||||
GB_MATH_DEF float gb_exp2 (float x);
|
||||
GB_MATH_DEF float gb_log (float x);
|
||||
GB_MATH_DEF float gb_log2 (float x);
|
||||
GB_MATH_DEF float gb_fast_exp (float x); /* NOTE(bill): Only valid from -1 <= x <= +1 */
|
||||
GB_MATH_DEF float gb_fast_exp2(float x); /* NOTE(bill): Only valid from -1 <= x <= +1 */
|
||||
GB_MATH_DEF float gb_pow(float x, float y); /* x^y */
|
||||
GB_MATH_DEF float gb_pow (float x, float y); /* x^y */
|
||||
|
||||
GB_MATH_DEF float gb_round(float x);
|
||||
GB_MATH_DEF float gb_floor(float x);
|
||||
GB_MATH_DEF float gb_ceil(float x);
|
||||
GB_MATH_DEF float gb_ceil (float x);
|
||||
|
||||
GB_MATH_DEF float gb_half_to_float(gbHalf value);
|
||||
GB_MATH_DEF gbHalf gb_float_to_half(float value);
|
||||
|
||||
|
||||
GB_MATH_DEF gbVec2 gb_vec2_zero(void);
|
||||
GB_MATH_DEF gbVec2 gb_vec2(float x, float y);
|
||||
GB_MATH_DEF gbVec2 gb_vec2v(float x[2]);
|
||||
GB_MATH_DEF gbVec2 gb_vec2 (float x, float y);
|
||||
GB_MATH_DEF gbVec2 gb_vec2v (float x[2]);
|
||||
|
||||
GB_MATH_DEF gbVec3 gb_vec3_zero(void);
|
||||
GB_MATH_DEF gbVec3 gb_vec3(float x, float y, float z);
|
||||
GB_MATH_DEF gbVec3 gb_vec3v(float x[3]);
|
||||
GB_MATH_DEF gbVec3 gb_vec3 (float x, float y, float z);
|
||||
GB_MATH_DEF gbVec3 gb_vec3v (float x[3]);
|
||||
|
||||
GB_MATH_DEF gbVec4 gb_vec4_zero(void);
|
||||
GB_MATH_DEF gbVec4 gb_vec4(float x, float y, float z, float w);
|
||||
GB_MATH_DEF gbVec4 gb_vec4v(float x[4]);
|
||||
GB_MATH_DEF gbVec4 gb_vec4 (float x, float y, float z, float w);
|
||||
GB_MATH_DEF gbVec4 gb_vec4v (float x[4]);
|
||||
|
||||
|
||||
GB_MATH_DEF void gb_vec2_add(gbVec2 *d, gbVec2 v0, gbVec2 v1);
|
||||
|
|
@ -312,12 +312,12 @@ GB_MATH_DEF void gb_vec3_refract(gbVec3 *d, gbVec3 i, gbVec3 n, float eta);
|
|||
GB_MATH_DEF float gb_vec2_aspect_ratio(gbVec2 v);
|
||||
|
||||
|
||||
GB_MATH_DEF void gb_mat2_identity(gbMat2 *m);
|
||||
GB_MATH_DEF void gb_mat2_identity (gbMat2 *m);
|
||||
GB_MATH_DEF void gb_float22_identity(float m[2][2]);
|
||||
|
||||
GB_MATH_DEF void gb_mat2_transpose(gbMat2 *m);
|
||||
GB_MATH_DEF void gb_mat2_mul(gbMat2 *out, gbMat2 *m1, gbMat2 *m2);
|
||||
GB_MATH_DEF void gb_mat2_mul_vec2(gbVec2 *out, gbMat2 *m, gbVec2 in);
|
||||
GB_MATH_DEF void gb_mat2_mul (gbMat2 *out, gbMat2 *m1, gbMat2 *m2);
|
||||
GB_MATH_DEF void gb_mat2_mul_vec2 (gbVec2 *out, gbMat2 *m, gbVec2 in);
|
||||
|
||||
GB_MATH_DEF gbMat2 *gb_mat2_v(gbVec2 m[2]);
|
||||
GB_MATH_DEF gbMat2 *gb_mat2_f(float m[2][2]);
|
||||
|
|
@ -326,64 +326,65 @@ GB_MATH_DEF gbFloat2 *gb_float22_v(gbVec2 m[2]);
|
|||
GB_MATH_DEF gbFloat2 *gb_float22_4(float m[4]);
|
||||
|
||||
GB_MATH_DEF void gb_float22_transpose(float (*vec)[2]);
|
||||
GB_MATH_DEF void gb_float22_mul(float (*out)[2], float (*mat1)[2], float (*mat2)[2]);
|
||||
GB_MATH_DEF void gb_float22_mul_vec2(gbVec2 *out, float m[2][2], gbVec2 in);
|
||||
GB_MATH_DEF void gb_float22_mul (float (*out)[2], float (*mat1)[2], float (*mat2)[2]);
|
||||
GB_MATH_DEF void gb_float22_mul_vec2 (gbVec2 *out, float m[2][2], gbVec2 in);
|
||||
|
||||
|
||||
GB_MATH_DEF void gb_mat3_identity(gbMat3 *m);
|
||||
GB_MATH_DEF void gb_mat3_identity (gbMat3 *m);
|
||||
GB_MATH_DEF void gb_float33_identity(float m[3][3]);
|
||||
|
||||
GB_MATH_DEF void gb_mat3_transpose(gbMat3 *m);
|
||||
GB_MATH_DEF void gb_mat3_mul(gbMat3 *out, gbMat3 *m1, gbMat3 *m2);
|
||||
GB_MATH_DEF void gb_mat3_mul_vec3(gbVec3 *out, gbMat3 *m, gbVec3 in);
|
||||
GB_MATH_DEF void gb_mat3_mul (gbMat3 *out, gbMat3 *m1, gbMat3 *m2);
|
||||
GB_MATH_DEF void gb_mat3_mul_vec3 (gbVec3 *out, gbMat3 *m, gbVec3 in);
|
||||
|
||||
GB_MATH_DEF gbMat3 *gb_mat3_v(gbVec3 m[3]);
|
||||
GB_MATH_DEF gbMat3 *gb_mat3_f(float m[3][3]);
|
||||
|
||||
GB_MATH_DEF gbFloat3 *gb_float33_m(gbMat3 *m);
|
||||
GB_MATH_DEF gbFloat3 *gb_float33_v(gbVec3 m[3]);
|
||||
GB_MATH_DEF gbFloat3 *gb_float33_9(float m[9]);
|
||||
|
||||
GB_MATH_DEF void gb_float33_transpose(float (*vec)[3]);
|
||||
GB_MATH_DEF void gb_float33_mul(float (*out)[3], float (*mat1)[3], float (*mat2)[3]);
|
||||
GB_MATH_DEF void gb_float33_mul_vec3(gbVec3 *out, float m[3][3], gbVec3 in);
|
||||
GB_MATH_DEF void gb_float33_mul (float (*out)[3], float (*mat1)[3], float (*mat2)[3]);
|
||||
GB_MATH_DEF void gb_float33_mul_vec3 (gbVec3 *out, float m[3][3], gbVec3 in);
|
||||
|
||||
|
||||
GB_MATH_DEF void gb_mat4_identity(gbMat4 *m);
|
||||
GB_MATH_DEF void gb_mat4_identity (gbMat4 *m);
|
||||
GB_MATH_DEF void gb_float44_identity(float m[4][4]);
|
||||
|
||||
GB_MATH_DEF void gb_mat4_transpose(gbMat4 *m);
|
||||
GB_MATH_DEF void gb_mat4_mul(gbMat4 *out, gbMat4 *m1, gbMat4 *m2);
|
||||
GB_MATH_DEF void gb_mat4_mul_vec4(gbVec4 *out, gbMat4 *m, gbVec4 in);
|
||||
GB_MATH_DEF void gb_mat4_mul (gbMat4 *out, gbMat4 *m1, gbMat4 *m2);
|
||||
GB_MATH_DEF void gb_mat4_mul_vec4 (gbVec4 *out, gbMat4 *m, gbVec4 in);
|
||||
|
||||
GB_MATH_DEF gbMat4 *gb_mat4_v(gbVec4 m[4]);
|
||||
GB_MATH_DEF gbMat4 *gb_mat4_f(float m[4][4]);
|
||||
GB_MATH_DEF gbFloat4 *gb_float44_m(gbMat4 *m);
|
||||
GB_MATH_DEF gbFloat4 *gb_float44_v(gbVec4 m[4]);
|
||||
|
||||
GB_MATH_DEF gbFloat4 *gb_float44_m (gbMat4 *m);
|
||||
GB_MATH_DEF gbFloat4 *gb_float44_v (gbVec4 m[4]);
|
||||
GB_MATH_DEF gbFloat4 *gb_float44_16(float m[16]);
|
||||
|
||||
GB_MATH_DEF void gb_float44_transpose(float (*vec)[4]);
|
||||
GB_MATH_DEF void gb_float44_mul(float (*out)[4], float (*mat1)[4], float (*mat2)[4]);
|
||||
GB_MATH_DEF void gb_float44_mul_vec4(gbVec4 *out, float m[4][4], gbVec4 in);
|
||||
GB_MATH_DEF void gb_float44_mul (float (*out)[4], float (*mat1)[4], float (*mat2)[4]);
|
||||
GB_MATH_DEF void gb_float44_mul_vec4 (gbVec4 *out, float m[4][4], gbVec4 in);
|
||||
|
||||
|
||||
GB_MATH_DEF void gb_mat4_translate(gbMat4 *out, gbVec3 v);
|
||||
GB_MATH_DEF void gb_mat4_rotate(gbMat4 *out, gbVec3 v, float angle_radians);
|
||||
GB_MATH_DEF void gb_mat4_scale(gbMat4 *out, gbVec3 v);
|
||||
GB_MATH_DEF void gb_mat4_scalef(gbMat4 *out, float s);
|
||||
GB_MATH_DEF void gb_mat4_ortho2d(gbMat4 *out, float left, float right, float bottom, float top);
|
||||
GB_MATH_DEF void gb_mat4_ortho3d(gbMat4 *out, float left, float right, float bottom, float top, float z_near, float z_far);
|
||||
GB_MATH_DEF void gb_mat4_perspective(gbMat4 *out, float fovy, float aspect, float z_near, float z_far);
|
||||
GB_MATH_DEF void gb_mat4_translate (gbMat4 *out, gbVec3 v);
|
||||
GB_MATH_DEF void gb_mat4_rotate (gbMat4 *out, gbVec3 v, float angle_radians);
|
||||
GB_MATH_DEF void gb_mat4_scale (gbMat4 *out, gbVec3 v);
|
||||
GB_MATH_DEF void gb_mat4_scalef (gbMat4 *out, float s);
|
||||
GB_MATH_DEF void gb_mat4_ortho2d (gbMat4 *out, float left, float right, float bottom, float top);
|
||||
GB_MATH_DEF void gb_mat4_ortho3d (gbMat4 *out, float left, float right, float bottom, float top, float z_near, float z_far);
|
||||
GB_MATH_DEF void gb_mat4_perspective (gbMat4 *out, float fovy, float aspect, float z_near, float z_far);
|
||||
GB_MATH_DEF void gb_mat4_infinite_perspective(gbMat4 *out, float fovy, float aspect, float z_near);
|
||||
|
||||
GB_MATH_DEF void gb_mat4_look_at(gbMat4 *out, gbVec3 eye, gbVec3 centre, gbVec3 up);
|
||||
|
||||
|
||||
|
||||
GB_MATH_DEF gbQuat gb_quat(float x, float y, float z, float w);
|
||||
GB_MATH_DEF gbQuat gb_quatv(float e[4]);
|
||||
GB_MATH_DEF gbQuat gb_quat_axis_angle(gbVec3 axis, float angle_radians);
|
||||
GB_MATH_DEF gbQuat gb_quat (float x, float y, float z, float w);
|
||||
GB_MATH_DEF gbQuat gb_quatv (float e[4]);
|
||||
GB_MATH_DEF gbQuat gb_quat_axis_angle (gbVec3 axis, float angle_radians);
|
||||
GB_MATH_DEF gbQuat gb_quat_euler_angles(float pitch, float yaw, float roll);
|
||||
GB_MATH_DEF gbQuat gb_quat_identity(void);
|
||||
GB_MATH_DEF gbQuat gb_quat_identity (void);
|
||||
|
||||
GB_MATH_DEF void gb_quat_add(gbQuat *d, gbQuat q0, gbQuat q1);
|
||||
GB_MATH_DEF void gb_quat_sub(gbQuat *d, gbQuat q0, gbQuat q1);
|
||||
|
|
@ -409,39 +410,40 @@ GB_MATH_DEF void gb_quat_diveqf(gbQuat *d, float s);
|
|||
GB_MATH_DEF float gb_quat_dot(gbQuat q0, gbQuat q1);
|
||||
GB_MATH_DEF float gb_quat_mag(gbQuat q);
|
||||
|
||||
GB_MATH_DEF void gb_quat_norm(gbQuat *d, gbQuat q);
|
||||
GB_MATH_DEF void gb_quat_conj(gbQuat *d, gbQuat q);
|
||||
GB_MATH_DEF void gb_quat_norm (gbQuat *d, gbQuat q);
|
||||
GB_MATH_DEF void gb_quat_conj (gbQuat *d, gbQuat q);
|
||||
GB_MATH_DEF void gb_quat_inverse(gbQuat *d, gbQuat q);
|
||||
|
||||
GB_MATH_DEF void gb_quat_axis(gbVec3 *axis, gbQuat q);
|
||||
GB_MATH_DEF void gb_quat_axis (gbVec3 *axis, gbQuat q);
|
||||
GB_MATH_DEF float gb_quat_angle(gbQuat q);
|
||||
|
||||
GB_MATH_DEF float gb_quat_pitch(gbQuat q);
|
||||
GB_MATH_DEF float gb_quat_yaw(gbQuat q);
|
||||
GB_MATH_DEF float gb_quat_roll(gbQuat q);
|
||||
GB_MATH_DEF float gb_quat_yaw (gbQuat q);
|
||||
GB_MATH_DEF float gb_quat_roll (gbQuat q);
|
||||
|
||||
/* NOTE(bill): Rotate v by q */
|
||||
GB_MATH_DEF void gb_quat_rotate_vec3(gbVec3 *d, gbQuat q, gbVec3 v);
|
||||
GB_MATH_DEF void gb_mat4_from_quat(gbMat4 *out, gbQuat q);
|
||||
GB_MATH_DEF void gb_quat_from_mat4(gbQuat *out, gbMat4 *m);
|
||||
GB_MATH_DEF void gb_mat4_from_quat (gbMat4 *out, gbQuat q);
|
||||
GB_MATH_DEF void gb_quat_from_mat4 (gbQuat *out, gbMat4 *m);
|
||||
|
||||
|
||||
|
||||
/* Interpolations */
|
||||
GB_MATH_DEF float gb_lerp(float a, float b, float t);
|
||||
GB_MATH_DEF float gb_smooth_step(float a, float b, float t);
|
||||
GB_MATH_DEF float gb_lerp (float a, float b, float t);
|
||||
GB_MATH_DEF float gb_unlerp (float t, float a, float b);
|
||||
GB_MATH_DEF float gb_smooth_step (float a, float b, float t);
|
||||
GB_MATH_DEF float gb_smoother_step(float a, float b, float t);
|
||||
|
||||
GB_MATH_DEF void gb_vec2_lerp(gbVec2 *d, gbVec2 a, gbVec2 b, float t);
|
||||
GB_MATH_DEF void gb_vec3_lerp(gbVec3 *d, gbVec3 a, gbVec3 b, float t);
|
||||
GB_MATH_DEF void gb_vec4_lerp(gbVec4 *d, gbVec4 a, gbVec4 b, float t);
|
||||
|
||||
GB_MATH_DEF void gb_quat_lerp(gbQuat *d, gbQuat a, gbQuat b, float t);
|
||||
GB_MATH_DEF void gb_quat_lerp (gbQuat *d, gbQuat a, gbQuat b, float t);
|
||||
GB_MATH_DEF void gb_quat_nlerp(gbQuat *d, gbQuat a, gbQuat b, float t);
|
||||
GB_MATH_DEF void gb_quat_slerp(gbQuat *d, gbQuat a, gbQuat b, float t);
|
||||
GB_MATH_DEF void gb_quat_slerp_approx(gbQuat *d, gbQuat a, gbQuat b, float t);
|
||||
GB_MATH_DEF void gb_quat_nquad(gbQuat *d, gbQuat p, gbQuat a, gbQuat b, gbQuat q, float t);
|
||||
GB_MATH_DEF void gb_quat_squad(gbQuat *d, gbQuat p, gbQuat a, gbQuat b, gbQuat q, float t);
|
||||
GB_MATH_DEF void gb_quat_slerp_approx(gbQuat *d, gbQuat a, gbQuat b, float t);
|
||||
GB_MATH_DEF void gb_quat_squad_approx(gbQuat *d, gbQuat p, gbQuat a, gbQuat b, gbQuat q, float t);
|
||||
|
||||
|
||||
|
|
@ -449,9 +451,9 @@ GB_MATH_DEF void gb_quat_squad_approx(gbQuat *d, gbQuat p, gbQuat a, gbQuat b, g
|
|||
GB_MATH_DEF gbRect2 gb_rect2(gbVec2 pos, gbVec2 dim);
|
||||
GB_MATH_DEF gbRect3 gb_rect3(gbVec3 pos, gbVec3 dim);
|
||||
|
||||
GB_MATH_DEF int gb_rect2_contains(gbRect2 a, float x, float y);
|
||||
GB_MATH_DEF int gb_rect2_contains_vec2(gbRect2 a, gbVec2 p);
|
||||
GB_MATH_DEF int gb_rect2_intersects(gbRect2 a, gbRect2 b);
|
||||
GB_MATH_DEF int gb_rect2_contains (gbRect2 a, float x, float y);
|
||||
GB_MATH_DEF int gb_rect2_contains_vec2 (gbRect2 a, gbVec2 p);
|
||||
GB_MATH_DEF int gb_rect2_intersects (gbRect2 a, gbRect2 b);
|
||||
GB_MATH_DEF int gb_rect2_intersection_result(gbRect2 a, gbRect2 b, gbRect2 *intersection);
|
||||
|
||||
|
||||
|
|
@ -464,7 +466,7 @@ GB_MATH_DEF gb_math_u64 gb_hash_murmur64(void const *key, size_t num_bytes, gb_m
|
|||
/* Random */
|
||||
/* TODO(bill): Use a generator for the random numbers */
|
||||
GB_MATH_DEF float gb_random_range_float(float min_inc, float max_inc);
|
||||
GB_MATH_DEF int gb_random_range_int(int min_inc, int max_inc);
|
||||
GB_MATH_DEF int gb_random_range_int (int min_inc, int max_inc);
|
||||
|
||||
|
||||
#if defined(__cplusplus)
|
||||
|
|
@ -473,6 +475,8 @@ GB_MATH_DEF int gb_random_range_int(int min_inc, int max_inc);
|
|||
|
||||
#if defined(__cplusplus) && defined(GB_MATH_USE_OPERATOR_OVERLOADS)
|
||||
|
||||
/* TODO(bill): How should I apply GB_MATH_DEF to these operator overloads? */
|
||||
|
||||
bool operator==(gbVec2 a, gbVec2 b) { return (a.x == b.x) && (a.y == b.y); }
|
||||
bool operator!=(gbVec2 a, gbVec2 b) { return !operator==(a, b); }
|
||||
|
||||
|
|
@ -738,6 +742,7 @@ gbVec3 operator*(gbQuat q, gbVec3 v) { gbVec3 r; gb_quat_rotate_vec3(&r, q, v);
|
|||
#define GB_MATH_IMPLEMENTATION_DONE
|
||||
|
||||
|
||||
/* NOTE(bill): To remove the need for memcpy */
|
||||
static void
|
||||
gb__memcpy_4byte(void *dest, void const *src, size_t size)
|
||||
{
|
||||
|
|
@ -750,6 +755,7 @@ gb__memcpy_4byte(void *dest, void const *src, size_t size)
|
|||
}
|
||||
}
|
||||
|
||||
/* NOTE(bill): To remove the need for memset */
|
||||
static void
|
||||
gb__memzero_byte4(void *dest, size_t size)
|
||||
{
|
||||
|
|
@ -1007,16 +1013,10 @@ float gb_ceil(float x) { return (x < 0) ? (int)x : ((int)x)+1; }
|
|||
|
||||
|
||||
|
||||
|
||||
typedef union {
|
||||
unsigned int i;
|
||||
float f;
|
||||
} gb_uif32;
|
||||
|
||||
float
|
||||
gb_half_to_float(gbHalf value)
|
||||
{
|
||||
gb_uif32 result;
|
||||
union { unsigned int i; float f; } result;
|
||||
int s = (value >> 15) & 0x001;
|
||||
int e = (value >> 10) & 0x01f;
|
||||
int m = value & 0x3ff;
|
||||
|
|
@ -1058,7 +1058,7 @@ gb_half_to_float(gbHalf value)
|
|||
gbHalf
|
||||
gb_float_to_half(float value)
|
||||
{
|
||||
gb_uif32 v;
|
||||
union { unsigned int i; float f; } v;
|
||||
int i, s, e, m;
|
||||
|
||||
v.f = value;
|
||||
|
|
@ -1888,8 +1888,9 @@ gb_quat_from_mat4(gbQuat *out, gbMat4 *mat)
|
|||
|
||||
|
||||
|
||||
float gb_lerp(float a, float b, float t) { return a*(1.0f-t) + b*t; }
|
||||
float gb_smooth_step(float a, float b, float t) { float x = (t - a)/(b - a); return x*x*(3.0f - 2.0f*x); }
|
||||
float gb_lerp (float a, float b, float t) { return a*(1.0f-t) + b*t; }
|
||||
float gb_unlerp (float t, float a, float b) { return (t-a)/(b-a); }
|
||||
float gb_smooth_step (float a, float b, float t) { float x = (t - a)/(b - a); return x*x*(3.0f - 2.0f*x); }
|
||||
float gb_smoother_step(float a, float b, float t) { float x = (t - a)/(b - a); return x*x*x*(x*(6.0f*x - 15.0f) + 10.0f); }
|
||||
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue