mirror of
https://github.com/Ed94/metadesk.git
synced 2026-08-06 07:38:45 +00:00
WIP: corrections/formatting post prefix addition
This commit is contained in:
@@ -1,17 +1,13 @@
|
|||||||
# Metadesk Library: RAD Debugger's Standalone Fork
|
# Metadesk Library: RAD Debugger's Standalone Fork
|
||||||
|
|
||||||
**Note: This repo is under heavy WIP. Currently getting the code from RAD's (Epic Games) Debugger over to a standalone state while at the same time studying it.**
|
|
||||||
|
|
||||||
**Update:**
|
|
||||||
This will contain just the minimal lib. Extra additions or the ability to generate variants will be in another repo (Currently removing [excess](https://github.com/Ed94/metadesk_lib_gen)).
|
|
||||||
|
|
||||||
This is a fork that aims to make the latest version of metadesk available from the [RAD Debugger](https://github.com/EpicGamesExt/raddebugger) accessible as a library.
|
This is a fork that aims to make the latest version of metadesk available from the [RAD Debugger](https://github.com/EpicGamesExt/raddebugger) accessible as a library.
|
||||||
|
|
||||||
|
**Note: This repo is under heavy WIP. Currently getting the code from RAD's (Epic Games) Debugger over to a standalone state while at the same time studying it.**
|
||||||
|
**Update:** This will contain just the minimal lib. Extra additions or the ability to generate variants are available at: [metadesk_libgen](https://github.com/Ed94/metadesk_libgen)
|
||||||
|
|
||||||
docs will be updated referencing content procued by Ryan Fleury and content based on studying or resolving this library for this repo.
|
docs will be updated referencing content procued by Ryan Fleury and content based on studying or resolving this library for this repo.
|
||||||
|
|
||||||
## Documentation
|
## Documentation
|
||||||
|
|
||||||
* [docs](./docs/Readme.md)
|
* [docs](./docs/Readme.md)
|
||||||
* [examples](./examples/Readme.md)
|
* [examples](./examples/Readme.md)
|
||||||
* [gen_c11](./gen_c11/Readme.md) (Remvoing to another repo)
|
|
||||||
* [gen_cpp17](./gen_cpp17/Readme.md) (Removing to another repo)
|
|
||||||
|
|||||||
+3
-3
@@ -68,12 +68,12 @@ md_arena_push(MD_Arena* arena, MD_SSIZE size, MD_SSIZE align)
|
|||||||
|
|
||||||
MD_B32 vmem_chain = is_virtual && (arena->flags & MD_ArenaFlag_NoChainVirtual);
|
MD_B32 vmem_chain = is_virtual && (arena->flags & MD_ArenaFlag_NoChainVirtual);
|
||||||
if (vmem_chain) {
|
if (vmem_chain) {
|
||||||
MD_SPTR const varena_header_size = md_align_pow2(size_of(MD_VArena), MD_DEFAULT_MEMORY_ALIGNMENT);
|
MD_SPTR const varena_header_size = md_align_pow2(size_of(MD_VArena), MD_DEFAULT_MEMORY_ALIGNMENT);
|
||||||
MD_SPTR const md_arena_block_size = MD_VARENA_DEFAULT_RESERVE - varena_header_size;
|
MD_SPTR const md_arena_block_size = MD_VARENA_DEFAULT_RESERVE - varena_header_size;
|
||||||
|
|
||||||
MD_VArena* vcurrent = md_rcast(MD_VArena*, arena->backing.data);
|
MD_VArena* vcurrent = md_rcast(MD_VArena*, arena->backing.data);
|
||||||
|
|
||||||
MD_VArena* new_vm = md_varena_alloc(.reserve_size = vcurrent->reserve, .commit_size = vcurrent->commit_size);
|
MD_VArena* new_vm = md_varena_alloc(.reserve_size = vcurrent->reserve, .commit_size = vcurrent->commit_size);
|
||||||
new_block = md_arena_alloc(.backing = md_varena_allocator(new_vm), .block_size = md_arena_block_size);
|
new_block = md_arena_alloc(.backing = md_varena_allocator(new_vm), .block_size = md_arena_block_size);
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
|
|||||||
+6
-6
@@ -84,15 +84,15 @@ md_extract_arena(MD_AllocatorInfo ainfo) {
|
|||||||
//- rjf: arena creation/destruction
|
//- rjf: arena creation/destruction
|
||||||
|
|
||||||
MD_API MD_Arena* md_arena__alloc(MD_ArenaParams* params);
|
MD_API MD_Arena* md_arena__alloc(MD_ArenaParams* params);
|
||||||
#define md_arena_alloc(...) md_arena__alloc( &(MD_ArenaParams){ __VA_ARGS__ } )
|
#define md_arena_alloc(...) md_arena__alloc( &(MD_ArenaParams){ __VA_ARGS__ } )
|
||||||
|
|
||||||
void md_arena_release(MD_Arena *arena);
|
void md_arena_release(MD_Arena *arena);
|
||||||
|
|
||||||
//- rjf: arena push/pop/pos core functions
|
//- rjf: arena push/pop/pos core functions
|
||||||
|
|
||||||
MD_API void* md_arena_push (MD_Arena* arena, MD_SSIZE size, MD_SSIZE align);
|
MD_API void* md_arena_push (MD_Arena* arena, MD_SSIZE size, MD_SSIZE align);
|
||||||
MD_U64 md_arena_pos (MD_Arena* arena);
|
MD_U64 md_arena_pos (MD_Arena* arena);
|
||||||
MD_API void md_arena_pop_to(MD_Arena* arena, MD_SSIZE pos);
|
MD_API void md_arena_pop_to(MD_Arena* arena, MD_SSIZE pos);
|
||||||
|
|
||||||
//- rjf: arena push/pop helpers
|
//- rjf: arena push/pop helpers
|
||||||
|
|
||||||
@@ -102,7 +102,7 @@ void md_arena_pop (MD_Arena* arena, MD_SSIZE amt);
|
|||||||
//- rjf: temporary arena scopes
|
//- rjf: temporary arena scopes
|
||||||
|
|
||||||
MD_TempArena temp_arena_begin(MD_Arena* arena);
|
MD_TempArena temp_arena_begin(MD_Arena* arena);
|
||||||
void temp_arena_end(MD_TempArena temp);
|
void temp_arena_end(MD_TempArena temp);
|
||||||
|
|
||||||
//- rjf: push helper macros
|
//- rjf: push helper macros
|
||||||
|
|
||||||
@@ -167,7 +167,7 @@ md_default_allocator()
|
|||||||
md_local_persist md_thread_local MD_Arena* arena = md_nullptr;
|
md_local_persist md_thread_local MD_Arena* arena = md_nullptr;
|
||||||
if (arena == md_nullptr) {
|
if (arena == md_nullptr) {
|
||||||
MD_VArena* backing_vmem = md_varena_alloc(.flags = 0, .base_addr = 0x0, .reserve_size = MD_VARENA_DEFAULT_RESERVE, .commit_size = MD_VARENA_DEFAULT_COMMIT);
|
MD_VArena* backing_vmem = md_varena_alloc(.flags = 0, .base_addr = 0x0, .reserve_size = MD_VARENA_DEFAULT_RESERVE, .commit_size = MD_VARENA_DEFAULT_COMMIT);
|
||||||
arena = md_arena_alloc(.backing = md_varena_allocator(backing_vmem), .block_size = MD_VARENA_DEFAULT_RESERVE);
|
arena = md_arena_alloc(.backing = md_varena_allocator(backing_vmem), .block_size = MD_VARENA_DEFAULT_RESERVE);
|
||||||
}
|
}
|
||||||
MD_AllocatorInfo info = { md_arena_allocator_proc, arena };
|
MD_AllocatorInfo info = { md_arena_allocator_proc, arena };
|
||||||
return info;
|
return info;
|
||||||
|
|||||||
@@ -36,9 +36,9 @@ md_cmd_line_opt_from_slot(MD_CmdLineOpt** slot, MD_String8 string) {
|
|||||||
MD_CmdLineOpt*
|
MD_CmdLineOpt*
|
||||||
md_cmd_line_insert_opt__ainfo(MD_AllocatorInfo ainfo, MD_CmdLine* cmd_line, MD_String8 string, MD_String8List values)
|
md_cmd_line_insert_opt__ainfo(MD_AllocatorInfo ainfo, MD_CmdLine* cmd_line, MD_String8 string, MD_String8List values)
|
||||||
{
|
{
|
||||||
MD_CmdLineOpt *var = 0;
|
MD_CmdLineOpt* var = 0;
|
||||||
MD_CmdLineOpt **slot = md_cmd_line_slot_from_string(cmd_line, string);
|
MD_CmdLineOpt** slot = md_cmd_line_slot_from_string(cmd_line, string);
|
||||||
MD_CmdLineOpt *existing_var = md_cmd_line_opt_from_slot(slot, string);
|
MD_CmdLineOpt* existing_var = md_cmd_line_opt_from_slot(slot, string);
|
||||||
if(existing_var != 0)
|
if(existing_var != 0)
|
||||||
{
|
{
|
||||||
var = existing_var;
|
var = existing_var;
|
||||||
@@ -63,8 +63,6 @@ md_cmd_line_insert_opt__ainfo(MD_AllocatorInfo ainfo, MD_CmdLine* cmd_line, MD_S
|
|||||||
return var;
|
return var;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
MD_CmdLine
|
MD_CmdLine
|
||||||
md_cmd_line_from_string_list__ainfo(MD_AllocatorInfo ainfo, MD_String8List command_line)
|
md_cmd_line_from_string_list__ainfo(MD_AllocatorInfo ainfo, MD_String8List command_line)
|
||||||
{
|
{
|
||||||
@@ -89,7 +87,7 @@ md_cmd_line_from_string_list__ainfo(MD_AllocatorInfo ainfo, MD_String8List comma
|
|||||||
// a flag option. All arguments after a single "--" (with no trailing string
|
// a flag option. All arguments after a single "--" (with no trailing string
|
||||||
// on the command line will be considered as input files.
|
// on the command line will be considered as input files.
|
||||||
MD_B32 is_option = 1;
|
MD_B32 is_option = 1;
|
||||||
if(after_passthrough_option == 0)
|
if (after_passthrough_option == 0)
|
||||||
{
|
{
|
||||||
if (md_str8_match(node->string, md_str8_lit("--"), 0)) {
|
if (md_str8_match(node->string, md_str8_lit("--"), 0)) {
|
||||||
after_passthrough_option = 1;
|
after_passthrough_option = 1;
|
||||||
@@ -111,7 +109,7 @@ md_cmd_line_from_string_list__ainfo(MD_AllocatorInfo ainfo, MD_String8List comma
|
|||||||
}
|
}
|
||||||
|
|
||||||
// NOTE(rjf): This string is an option.
|
// NOTE(rjf): This string is an option.
|
||||||
if(is_option)
|
if (is_option)
|
||||||
{
|
{
|
||||||
MD_B32 has_arguments = 0;
|
MD_B32 has_arguments = 0;
|
||||||
MD_U64 arg_signifier_position1 = md_str8_find_needle(option_name, 0, md_str8_lit(":"), 0);
|
MD_U64 arg_signifier_position1 = md_str8_find_needle(option_name, 0, md_str8_lit(":"), 0);
|
||||||
|
|||||||
@@ -44,7 +44,7 @@ struct MD_CmdLine
|
|||||||
MD_U64 md_cmd_line_hash_from_string(MD_String8 string);
|
MD_U64 md_cmd_line_hash_from_string(MD_String8 string);
|
||||||
MD_API MD_CmdLineOpt** md_cmd_line_slot_from_string(MD_CmdLine* cmd_line, MD_String8 string);
|
MD_API MD_CmdLineOpt** md_cmd_line_slot_from_string(MD_CmdLine* cmd_line, MD_String8 string);
|
||||||
MD_API MD_CmdLineOpt* md_cmd_line_opt_from_slot (MD_CmdLineOpt** slot, MD_String8 string);
|
MD_API MD_CmdLineOpt* md_cmd_line_opt_from_slot (MD_CmdLineOpt** slot, MD_String8 string);
|
||||||
void md_cmd_line_push_opt (MD_CmdLineOptList* list, MD_CmdLineOpt* var);
|
void md_cmd_line_push_opt (MD_CmdLineOptList* list, MD_CmdLineOpt* var);
|
||||||
|
|
||||||
MD_CmdLineOpt* md_cmd_line_opt_from_string (MD_CmdLine* cmd_line, MD_String8 name);
|
MD_CmdLineOpt* md_cmd_line_opt_from_string (MD_CmdLine* cmd_line, MD_String8 name);
|
||||||
MD_String8List md_cmd_line_strings (MD_CmdLine* cmd_line, MD_String8 name);
|
MD_String8List md_cmd_line_strings (MD_CmdLine* cmd_line, MD_String8 name);
|
||||||
@@ -58,16 +58,16 @@ inline MD_CmdLine md_cmd_line_from_string_list__arena(MD_Arena* aren
|
|||||||
MD_API MD_CmdLine md_cmd_line_from_string_list__ainfo(MD_AllocatorInfo ainfo, MD_String8List arguments);
|
MD_API MD_CmdLine md_cmd_line_from_string_list__ainfo(MD_AllocatorInfo ainfo, MD_String8List arguments);
|
||||||
|
|
||||||
#define md_cmd_line_insert_opt(allocator, cmd_line, string, values) \
|
#define md_cmd_line_insert_opt(allocator, cmd_line, string, values) \
|
||||||
_Generic(allocator, \
|
_Generic(allocator, \
|
||||||
MD_Arena*: md_cmd_line_insert_opt__arena, \
|
MD_Arena*: md_cmd_line_insert_opt__arena, \
|
||||||
MD_AllocatorInfo: md_cmd_line_insert_opt__ainfo, \
|
MD_AllocatorInfo: md_cmd_line_insert_opt__ainfo, \
|
||||||
default: md_assert_generic_sel_fail \
|
default: md_assert_generic_sel_fail \
|
||||||
) md_generic_call(allocator, cmd_line, string, values)
|
) md_generic_call(allocator, cmd_line, string, values)
|
||||||
|
|
||||||
#define md_cmd_line_from_string_list(allocator, arguments) \
|
#define md_cmd_line_from_string_list(allocator, arguments) \
|
||||||
_Generic(allocator, \
|
_Generic(allocator, \
|
||||||
MD_Arena*: md_cmd_line_from_string_list__arena, \
|
MD_Arena*: md_cmd_line_from_string_list__arena, \
|
||||||
MD_AllocatorInfo: md_cmd_line_from_string_list__ainfo, \
|
MD_AllocatorInfo: md_cmd_line_from_string_list__ainfo, \
|
||||||
default: md_assert_generic_sel_fail \
|
default: md_assert_generic_sel_fail \
|
||||||
) md_generic_call(allocator, arguments)
|
) md_generic_call(allocator, arguments)
|
||||||
|
|
||||||
@@ -81,7 +81,7 @@ md_cmd_line_hash_from_string(MD_String8 string) {
|
|||||||
}
|
}
|
||||||
|
|
||||||
md_force_inline MD_CmdLineOpt* md_cmd_line_insert_opt__arena (MD_Arena* arena, MD_CmdLine* cmd_line, MD_String8 string, MD_String8List values) { return md_cmd_line_insert_opt__ainfo (md_arena_allocator(arena), cmd_line, string, values); }
|
md_force_inline MD_CmdLineOpt* md_cmd_line_insert_opt__arena (MD_Arena* arena, MD_CmdLine* cmd_line, MD_String8 string, MD_String8List values) { return md_cmd_line_insert_opt__ainfo (md_arena_allocator(arena), cmd_line, string, values); }
|
||||||
md_force_inline MD_CmdLine md_cmd_line_from_string_list__arena(MD_Arena* arena, MD_String8List command_line) { return md_cmd_line_from_string_list__ainfo(md_arena_allocator(arena), command_line); }
|
md_force_inline MD_CmdLine md_cmd_line_from_string_list__arena(MD_Arena* arena, MD_String8List command_line) { return md_cmd_line_from_string_list__ainfo(md_arena_allocator(arena), command_line); }
|
||||||
|
|
||||||
inline MD_CmdLineOpt* md_cmd_line_opt_from_string(MD_CmdLine *cmd_line, MD_String8 name) { return md_cmd_line_opt_from_slot(md_cmd_line_slot_from_string(cmd_line, name), name); }
|
inline MD_CmdLineOpt* md_cmd_line_opt_from_string(MD_CmdLine *cmd_line, MD_String8 name) { return md_cmd_line_opt_from_slot(md_cmd_line_slot_from_string(cmd_line, name), name); }
|
||||||
inline MD_B32 md_cmd_line_has_flag (MD_CmdLine *cmd_line, MD_String8 name) { MD_CmdLineOpt *var = md_cmd_line_opt_from_string(cmd_line, name); return(var != 0); }
|
inline MD_B32 md_cmd_line_has_flag (MD_CmdLine *cmd_line, MD_String8 name) { MD_CmdLineOpt *var = md_cmd_line_opt_from_string(cmd_line, name); return(var != 0); }
|
||||||
|
|||||||
@@ -6,8 +6,6 @@
|
|||||||
# include "base_types.h"
|
# include "base_types.h"
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
// TODO(Ed): Review this
|
|
||||||
|
|
||||||
////////////////////////////////
|
////////////////////////////////
|
||||||
//~ rjf: Asserts
|
//~ rjf: Asserts
|
||||||
|
|
||||||
|
|||||||
@@ -43,7 +43,7 @@
|
|||||||
// Expands to ',' if it can find (type): (function) <comma_operator: ',' >
|
// Expands to ',' if it can find (type): (function) <comma_operator: ',' >
|
||||||
// Where md_generic_sel_entry_comma_delimiter is specifically looking for that <comma> ,
|
// Where md_generic_sel_entry_comma_delimiter is specifically looking for that <comma> ,
|
||||||
#define md_if_generic_selector_defined_include_slot( slot_exp ) md_generic_sel_entry_comma_delimiter( slot_exp, md_generic_sel_entry_type( slot_exp, ): md_generic_sel_entry_function( slot_exp, ) MD_COMMA_OPERATOR, , )
|
#define md_if_generic_selector_defined_include_slot( slot_exp ) md_generic_sel_entry_comma_delimiter( slot_exp, md_generic_sel_entry_type( slot_exp, ): md_generic_sel_entry_function( slot_exp, ) MD_COMMA_OPERATOR, , )
|
||||||
// ^ Selects the comma ^ is the type ^ is the function ^ Insert a comma
|
// ^ Selects the comma ^ is the type ^ is the function ^ Insert a comma
|
||||||
// The slot won't exist if that comma is not found.
|
// The slot won't exist if that comma is not found.
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
@@ -58,12 +58,12 @@ MD_UNRESOLVED_GENERIC_SELECTION const md_assert_generic_sel_fail = {0};
|
|||||||
|
|
||||||
// Below are generated on demand for an overlaod depdendent on a type:
|
// Below are generated on demand for an overlaod depdendent on a type:
|
||||||
// ----------------------------------------------------------------------------------------------------------------------------------
|
// ----------------------------------------------------------------------------------------------------------------------------------
|
||||||
#define function_generic_example( selector_arg ) _Generic( \
|
#define function_generic_example( selector_arg ) _Generic( \
|
||||||
(selector_arg), /* Select Via Expression*/ \
|
(selector_arg), /* Select Via Expression*/ \
|
||||||
/* Extendibility slots: */ \
|
/* Extendibility slots: */ \
|
||||||
md_if_generic_selector_defined_include_slot( MD_GENERIC_SLOT_1__function_sig ) \
|
md_if_generic_selector_defined_include_slot( MD_GENERIC_SLOT_1__function_sig ) \
|
||||||
md_if_generic_selector_defined_include_slot( GENERIC_SLOT_2__function_sig ) \
|
md_if_generic_selector_defined_include_slot( GENERIC_SLOT_2__function_sig ) \
|
||||||
default: md_assert_generic_sel_fail \
|
default: md_assert_generic_sel_fail \
|
||||||
) md_generic_call( selector_arg )
|
) md_generic_call( selector_arg )
|
||||||
// ----------------------------------------------------------------------------------------------------------------------------------
|
// ----------------------------------------------------------------------------------------------------------------------------------
|
||||||
|
|
||||||
@@ -80,46 +80,46 @@ MD_UNRESOLVED_GENERIC_SELECTION const md_assert_generic_sel_fail = {0};
|
|||||||
size_t md_generic_example_hash__P_long( long val ) { return val * 2654435761ull; }
|
size_t md_generic_example_hash__P_long( long val ) { return val * 2654435761ull; }
|
||||||
|
|
||||||
// To add support for long long:
|
// To add support for long long:
|
||||||
#define GENERIC_SLOT_2__example_hash long long, md_generic_example_hash__P_long_long
|
#define MD_GENERIC_SLOT_2__example_hash long long, md_generic_example_hash__P_long_long
|
||||||
size_t md_generic_example_hash__P_long_long( long long val ) { return val * 2654435761ull; }
|
size_t md_generic_example_hash__P_long_long( long long val ) { return val * 2654435761ull; }
|
||||||
|
|
||||||
// If using an Editor with support for syntax hightlighting macros:
|
// If using an Editor with support for syntax hightlighting macros:
|
||||||
// MD_GENERIC_SLOT_1__example_hash and GENERIC_SLOT_2__example_hash should show color highlighting indicating the slot is enabled,
|
// MD_GENERIC_SLOT_1__example_hash and GENERIC_SLOT_2__example_hash should show color highlighting indicating the slot is enabled,
|
||||||
// or, "defined" for usage during the compilation pass that handles the _Generic instrinsic.
|
// or, "defined" for usage during the compilation pass that handles the _Generic instrinsic.
|
||||||
#define generic_example_hash( function_arguments ) _Generic( \
|
#define generic_example_hash( function_arguments ) _Generic( \
|
||||||
(function_arguments), /* Select Via Expression*/ \
|
(function_arguments), /* Select Via Expression*/ \
|
||||||
/* Extendibility slots: */ \
|
/* Extendibility slots: */ \
|
||||||
md_if_generic_selector_defined_include_slot( MD_GENERIC_SLOT_1__example_hash ) \
|
md_if_generic_selector_defined_include_slot( MD_GENERIC_SLOT_1__example_hash ) \
|
||||||
md_if_generic_selector_defined_include_slot( GENERIC_SLOT_2__example_hash ) \
|
md_if_generic_selector_defined_include_slot( MD_GENERIC_SLOT_2__example_hash ) \
|
||||||
md_if_generic_selector_defined_include_slot( GENERIC_SLOT_3__example_hash ) \
|
md_if_generic_selector_defined_include_slot( MD_GENERIC_SLOT_3__example_hash ) \
|
||||||
md_if_generic_selector_defined_include_slot( GENERIC_SLOT_4__example_hash ) \
|
md_if_generic_selector_defined_include_slot( MD_GENERIC_SLOT_4__example_hash ) \
|
||||||
md_if_generic_selector_defined_include_slot( GENERIC_SLOT_5__example_hash ) \
|
md_if_generic_selector_defined_include_slot( MD_GENERIC_SLOT_5__example_hash ) \
|
||||||
md_if_generic_selector_defined_include_slot( GENERIC_SLOT_6__example_hash ) \
|
md_if_generic_selector_defined_include_slot( MD_GENERIC_SLOT_6__example_hash ) \
|
||||||
md_if_generic_selector_defined_include_slot( GENERIC_SLOT_7__example_hash ) \
|
md_if_generic_selector_defined_include_slot( MD_GENERIC_SLOT_7__example_hash ) \
|
||||||
md_if_generic_selector_defined_include_slot( GENERIC_SLOT_8__example_hash ) \
|
md_if_generic_selector_defined_include_slot( MD_GENERIC_SLOT_8__example_hash ) \
|
||||||
default: md_assert_generic_sel_fail \
|
default: md_assert_generic_sel_fail \
|
||||||
) md_generic_call( function_arguments )
|
) md_generic_call( function_arguments )
|
||||||
|
|
||||||
// Additional Variations:
|
// Additional Variations:
|
||||||
|
|
||||||
// If the function takes more than one argument the following is used:
|
// If the function takes more than one argument the following is used:
|
||||||
#define md_function_generic_example_varadic( selector_arg, ... ) _Generic( \
|
#define md_function_generic_example_varadic( selector_arg, ... ) _Generic( \
|
||||||
(selector_arg), \
|
(selector_arg), \
|
||||||
md_if_generic_selector_defined_include_slot( MD_GENERIC_SLOT_1__function_sig ) \
|
md_if_generic_selector_defined_include_slot( MD_GENERIC_SLOT_1__function_sig ) \
|
||||||
md_if_generic_selector_defined_include_slot( GENERIC_SLOT_2__function_sig ) \
|
md_if_generic_selector_defined_include_slot( GENERIC_SLOT_2__function_sig ) \
|
||||||
/* ... */ \
|
/* ... */ \
|
||||||
md_if_generic_selector_defined_include_slot(GENERIC_SLOT_N__function_sig ) \
|
md_if_generic_selector_defined_include_slot(GENERIC_SLOT_N__function_sig ) \
|
||||||
default: md_assert_generic_sel_fail \
|
default: md_assert_generic_sel_fail \
|
||||||
) md_generic_call( selector_arg, __VA_ARG__ )
|
) md_generic_call( selector_arg, __VA_ARG__ )
|
||||||
|
|
||||||
// If the function does not take the arugment as a parameter:
|
// If the function does not take the arugment as a parameter:
|
||||||
#define md_function_generic_example_direct_type( selector_arg ) _Generic( \
|
#define md_function_generic_example_direct_type( selector_arg ) _Generic( \
|
||||||
( md_type_to_expression(selector_arg) ), \
|
( md_type_to_expression(selector_arg) ), \
|
||||||
md_if_generic_selector_defined_include_slot( MD_GENERIC_SLOT_1__function_sig ) \
|
md_if_generic_selector_defined_include_slot( MD_GENERIC_SLOT_1__function_sig ) \
|
||||||
md_if_generic_selector_defined_include_slot( GENERIC_SLOT_2__function_sig ) \
|
md_if_generic_selector_defined_include_slot( GENERIC_SLOT_2__function_sig ) \
|
||||||
/* ... */ \
|
/* ... */ \
|
||||||
md_if_generic_selector_defined_include_slot(GENERIC_SLOT_N__function_sig ) \
|
md_if_generic_selector_defined_include_slot(GENERIC_SLOT_N__function_sig ) \
|
||||||
default: md_assert_generic_sel_fail \
|
default: md_assert_generic_sel_fail \
|
||||||
) md_generic_call(selector_arg)
|
) md_generic_call(selector_arg)
|
||||||
|
|
||||||
|
|
||||||
@@ -134,12 +134,12 @@ size_t md_generic_example_hash__P_long_long( long long val ) { return val * 2654
|
|||||||
|
|
||||||
#define example_with__l2(expr) _Generic( \
|
#define example_with__l2(expr) _Generic( \
|
||||||
(expr), \
|
(expr), \
|
||||||
MD_S64 : example_with_s64, \
|
MD_S64 : example_with_s64, \
|
||||||
default: md_assert_generic_sel_fail \
|
default: md_assert_generic_sel_fail \
|
||||||
)
|
)
|
||||||
#define example_with(expr) \
|
#define example_with(expr) \
|
||||||
_Generic((expr), \
|
_Generic((expr), \
|
||||||
MD_SSIZE : example_with_SSIZEZ \
|
MD_SSIZE : example_with_SSIZEZ \
|
||||||
default : example_with_not_SSIZE(allocator, in) \
|
default : example_with_not_SSIZE(allocator, in) \
|
||||||
) md_generic_call(allocator, in)
|
) md_generic_call(allocator, in)
|
||||||
|
|
||||||
@@ -150,10 +150,10 @@ _Generic((expr), \
|
|||||||
|
|
||||||
#define example_with_generic_layers(expr) \
|
#define example_with_generic_layers(expr) \
|
||||||
_Generic( (expr), \
|
_Generic( (expr), \
|
||||||
MD_S64 : example_with_s64, \
|
MD_S64 : example_with_s64, \
|
||||||
_Generic_L2((expr), \
|
_Generic_L2((expr), \
|
||||||
MD_SSIZE: example_with_SSIZZE \
|
MD_SSIZE: example_with_SSIZZE \
|
||||||
default: md_assert_generic_sel_fail \
|
default: md_assert_generic_sel_fail \
|
||||||
), \
|
), \
|
||||||
) md_generic_call(expr)
|
) md_generic_call(expr)
|
||||||
|
|
||||||
@@ -163,7 +163,7 @@ _Generic_L2((expr), \
|
|||||||
#undef example_with_generic_layers
|
#undef example_with_generic_layers
|
||||||
#undef function_generic_example
|
#undef function_generic_example
|
||||||
#undef MD_GENERIC_SLOT_1__example_hash
|
#undef MD_GENERIC_SLOT_1__example_hash
|
||||||
#undef GENERIC_SLOT_2__example_hash
|
#undef MD_GENERIC_SLOT_2__example_hash
|
||||||
#undef generic_example_hash
|
#undef generic_example_hash
|
||||||
#undef md_function_generic_example_varadic
|
#undef md_function_generic_example_varadic
|
||||||
#undef md_function_generic_example_direct_type
|
#undef md_function_generic_example_direct_type
|
||||||
|
|||||||
@@ -48,9 +48,9 @@ struct MD_Log
|
|||||||
////////////////////////////////
|
////////////////////////////////
|
||||||
//~ rjf: MD_Log Creation/Selection
|
//~ rjf: MD_Log Creation/Selection
|
||||||
|
|
||||||
MD_Log* md_log_alloc(MD_AllocatorInfo ainfo, MD_U64 md_arena_block_size);
|
MD_Log* md_log_alloc(MD_AllocatorInfo ainfo, MD_U64 md_arena_block_size);
|
||||||
void md_log_release(MD_Log* log);
|
void md_log_release(MD_Log* log);
|
||||||
MD_API void md_log_select (MD_Log* log);
|
MD_API void md_log_select (MD_Log* log);
|
||||||
|
|
||||||
inline MD_Log*
|
inline MD_Log*
|
||||||
md_log_alloc(MD_AllocatorInfo ainfo, MD_U64 md_arena_block_size) {
|
md_log_alloc(MD_AllocatorInfo ainfo, MD_U64 md_arena_block_size) {
|
||||||
|
|||||||
@@ -158,30 +158,30 @@
|
|||||||
#define md_src_line_str md_stringify(__LINE__)
|
#define md_src_line_str md_stringify(__LINE__)
|
||||||
|
|
||||||
#ifndef md_do_once
|
#ifndef md_do_once
|
||||||
#define md_do_once() \
|
#define md_do_once() \
|
||||||
md_local_persist int __do_once_counter_##md_src_line_str = 0; \
|
md_local_persist int __do_once_counter_##md_src_line_str = 0; \
|
||||||
for(; __do_once_counter_##md_src_line_str != 1; __do_once_counter_##md_src_line_str = 1 ) \
|
for(; __do_once_counter_##md_src_line_str != 1; __do_once_counter_##md_src_line_str = 1 ) \
|
||||||
|
|
||||||
#define md_do_once_defer( expression ) \
|
#define md_do_once_defer( expression ) \
|
||||||
md_local_persist int __do_once_counter_##md_src_line_str = 0; \
|
md_local_persist int __do_once_counter_##md_src_line_str = 0; \
|
||||||
for(;__do_once_counter_##md_src_line_str != 1; __do_once_counter_##md_src_line_str = 1, (expression)) \
|
for(;__do_once_counter_##md_src_line_str != 1; __do_once_counter_##md_src_line_str = 1, (expression)) \
|
||||||
|
|
||||||
#define md_do_once_start \
|
#define md_do_once_start \
|
||||||
do \
|
do \
|
||||||
{ \
|
{ \
|
||||||
md_local_persist \
|
md_local_persist \
|
||||||
bool done = false; \
|
bool done = false; \
|
||||||
if ( done ) \
|
if ( done ) \
|
||||||
break; \
|
break; \
|
||||||
done = true;
|
done = true;
|
||||||
|
|
||||||
#define md_do_once_end \
|
#define md_do_once_end \
|
||||||
} \
|
} \
|
||||||
while(0);
|
while(0);
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#define ct_if(expr, then, else) _Generic( \
|
#define ct_if(expr, then, else) _Generic( \
|
||||||
(&(char[1 + !!(EXPR)]){0}), \
|
(&(char[1 + !!(expr)]){0}), \
|
||||||
char (*)[2]: (THEN), \
|
char (*)[2]: (then), \
|
||||||
char (*)[1]: (ELSE) \
|
char (*)[1]: (else) \
|
||||||
)
|
)
|
||||||
|
|||||||
+173
-173
@@ -432,55 +432,55 @@ inline MD_F64 md_mix_1f64(MD_F64 a, MD_F64 b, MD_F64 t) { MD_F64 c = (a + (b - a
|
|||||||
// ==================== 2D Vectors ====================
|
// ==================== 2D Vectors ====================
|
||||||
|
|
||||||
#define md_v2f32(x, y) md_vec_2f32((x), (y))
|
#define md_v2f32(x, y) md_vec_2f32((x), (y))
|
||||||
inline MD_Vec2F32 md_vec_2f32 (MD_F32 x, MD_F32 y) { MD_Vec2F32 v = { x, y }; return v; }
|
inline MD_Vec2F32 md_vec_2f32 (MD_F32 x, MD_F32 y) { MD_Vec2F32 v = { x, y }; return v; }
|
||||||
inline MD_Vec2F32 md_add_2f32 (MD_Vec2F32 a, MD_Vec2F32 b) { MD_Vec2F32 c = {a.x + b.x, a.y + b.y}; return c; }
|
inline MD_Vec2F32 md_add_2f32 (MD_Vec2F32 a, MD_Vec2F32 b) { MD_Vec2F32 c = {a.x + b.x, a.y + b.y}; return c; }
|
||||||
inline MD_Vec2F32 md_sub_2f32 (MD_Vec2F32 a, MD_Vec2F32 b) { MD_Vec2F32 c = {a.x - b.x, a.y - b.y}; return c; }
|
inline MD_Vec2F32 md_sub_2f32 (MD_Vec2F32 a, MD_Vec2F32 b) { MD_Vec2F32 c = {a.x - b.x, a.y - b.y}; return c; }
|
||||||
inline MD_Vec2F32 md_mul_2f32 (MD_Vec2F32 a, MD_Vec2F32 b) { MD_Vec2F32 c = {a.x * b.x, a.y * b.y}; return c; }
|
inline MD_Vec2F32 md_mul_2f32 (MD_Vec2F32 a, MD_Vec2F32 b) { MD_Vec2F32 c = {a.x * b.x, a.y * b.y}; return c; }
|
||||||
inline MD_Vec2F32 md_div_2f32 (MD_Vec2F32 a, MD_Vec2F32 b) { MD_Vec2F32 c = {a.x / b.x, a.y / b.y}; return c; }
|
inline MD_Vec2F32 md_div_2f32 (MD_Vec2F32 a, MD_Vec2F32 b) { MD_Vec2F32 c = {a.x / b.x, a.y / b.y}; return c; }
|
||||||
inline MD_Vec2F32 md_scale_2f32 (MD_Vec2F32 v, MD_F32 s) { MD_Vec2F32 c = {v.x * s, v.y * s }; return c; }
|
inline MD_Vec2F32 md_scale_2f32 (MD_Vec2F32 v, MD_F32 s) { MD_Vec2F32 c = {v.x * s, v.y * s }; return c; }
|
||||||
inline MD_F32 md_dot_2f32 (MD_Vec2F32 a, MD_Vec2F32 b) { MD_F32 c = a.x * b.x + a.y * b.y; return c; }
|
inline MD_F32 md_dot_2f32 (MD_Vec2F32 a, MD_Vec2F32 b) { MD_F32 c = a.x * b.x + a.y * b.y; return c; }
|
||||||
inline MD_F32 md_length_squared_2f32(MD_Vec2F32 v) { MD_F32 c = v.x * v.x + v.y * v.y; return c; }
|
inline MD_F32 md_length_squared_2f32(MD_Vec2F32 v) { MD_F32 c = v.x * v.x + v.y * v.y; return c; }
|
||||||
inline MD_F32 md_length_2f32 (MD_Vec2F32 v) { MD_F32 c = md_sqrt_f32(v.x*v.x + v.y*v.y); return c; }
|
inline MD_F32 md_length_2f32 (MD_Vec2F32 v) { MD_F32 c = md_sqrt_f32(v.x*v.x + v.y*v.y); return c; }
|
||||||
inline MD_Vec2F32 md_normalize_2f32 (MD_Vec2F32 v) { v = md_scale_2f32(v, 1.f / md_length_2f32(v)); return v; }
|
inline MD_Vec2F32 md_normalize_2f32 (MD_Vec2F32 v) { v = md_scale_2f32(v, 1.f / md_length_2f32(v)); return v; }
|
||||||
inline MD_Vec2F32 md_mix_2f32 (MD_Vec2F32 a, MD_Vec2F32 b, MD_F32 t) { MD_Vec2F32 c = {md_mix_1f32(a.x, b.x, t), md_mix_1f32(a.y, b.y, t)}; return c; }
|
inline MD_Vec2F32 md_mix_2f32 (MD_Vec2F32 a, MD_Vec2F32 b, MD_F32 t) { MD_Vec2F32 c = {md_mix_1f32(a.x, b.x, t), md_mix_1f32(a.y, b.y, t)}; return c; }
|
||||||
|
|
||||||
#define md_v2s64(x, y) md_vec_2s64((x), (y))
|
#define md_v2s64(x, y) md_vec_2s64((x), (y))
|
||||||
inline MD_Vec2S64 md_vec_2s64 (MD_S64 x, MD_S64 y) { MD_Vec2S64 v = { x, y }; return v; }
|
inline MD_Vec2S64 md_vec_2s64 (MD_S64 x, MD_S64 y) { MD_Vec2S64 v = { x, y }; return v; }
|
||||||
inline MD_Vec2S64 md_add_2s64 (MD_Vec2S64 a, MD_Vec2S64 b) { MD_Vec2S64 c = {a.x + b.x, a.y + b.y}; return c; }
|
inline MD_Vec2S64 md_add_2s64 (MD_Vec2S64 a, MD_Vec2S64 b) { MD_Vec2S64 c = {a.x + b.x, a.y + b.y}; return c; }
|
||||||
inline MD_Vec2S64 md_sub_2s64 (MD_Vec2S64 a, MD_Vec2S64 b) { MD_Vec2S64 c = {a.x - b.x, a.y - b.y}; return c; }
|
inline MD_Vec2S64 md_sub_2s64 (MD_Vec2S64 a, MD_Vec2S64 b) { MD_Vec2S64 c = {a.x - b.x, a.y - b.y}; return c; }
|
||||||
inline MD_Vec2S64 md_mul_2s64 (MD_Vec2S64 a, MD_Vec2S64 b) { MD_Vec2S64 c = {a.x * b.x, a.y * b.y}; return c; }
|
inline MD_Vec2S64 md_mul_2s64 (MD_Vec2S64 a, MD_Vec2S64 b) { MD_Vec2S64 c = {a.x * b.x, a.y * b.y}; return c; }
|
||||||
inline MD_Vec2S64 md_div_2s64 (MD_Vec2S64 a, MD_Vec2S64 b) { MD_Vec2S64 c = {a.x / b.x, a.y / b.y}; return c; }
|
inline MD_Vec2S64 md_div_2s64 (MD_Vec2S64 a, MD_Vec2S64 b) { MD_Vec2S64 c = {a.x / b.x, a.y / b.y}; return c; }
|
||||||
inline MD_Vec2S64 md_scale_2s64 (MD_Vec2S64 v, MD_S64 s) { MD_Vec2S64 c = {v.x * s, v.y * s }; return c; }
|
inline MD_Vec2S64 md_scale_2s64 (MD_Vec2S64 v, MD_S64 s) { MD_Vec2S64 c = {v.x * s, v.y * s }; return c; }
|
||||||
inline MD_S64 md_dot_2s64 (MD_Vec2S64 a, MD_Vec2S64 b) { MD_S64 c = a.x * b.x + a.y * b.y; return c; }
|
inline MD_S64 md_dot_2s64 (MD_Vec2S64 a, MD_Vec2S64 b) { MD_S64 c = a.x * b.x + a.y * b.y; return c; }
|
||||||
inline MD_S64 md_length_squared_2s64(MD_Vec2S64 v) { MD_S64 c = v.x * v.x + v.y * v.y; return c; }
|
inline MD_S64 md_length_squared_2s64(MD_Vec2S64 v) { MD_S64 c = v.x * v.x + v.y * v.y; return c; }
|
||||||
inline MD_S64 md_length_2s64 (MD_Vec2S64 v) { MD_S64 c = (MD_S64)md_sqrt_f64((MD_F64)(v.x*v.x + v.y*v.y)); return c; }
|
inline MD_S64 md_length_2s64 (MD_Vec2S64 v) { MD_S64 c = (MD_S64)md_sqrt_f64((MD_F64)(v.x*v.x + v.y*v.y)); return c; }
|
||||||
inline MD_Vec2S64 md_normalize_2s64 (MD_Vec2S64 v) { v = md_scale_2s64(v, (MD_S64)(1.f / md_length_2s64(v))); return v; }
|
inline MD_Vec2S64 md_normalize_2s64 (MD_Vec2S64 v) { v = md_scale_2s64(v, (MD_S64)(1.f / md_length_2s64(v))); return v; }
|
||||||
inline MD_Vec2S64 md_mix_2s64 (MD_Vec2S64 a, MD_Vec2S64 b, MD_F32 t) { MD_Vec2S64 c = {(MD_S64)md_mix_1f32((MD_F32)a.x, (MD_F32)b.x, t), (MD_S64)md_mix_1f32((MD_F32)a.y, (MD_F32)b.y, t)}; return c; }
|
inline MD_Vec2S64 md_mix_2s64 (MD_Vec2S64 a, MD_Vec2S64 b, MD_F32 t) { MD_Vec2S64 c = {(MD_S64)md_mix_1f32((MD_F32)a.x, (MD_F32)b.x, t), (MD_S64)md_mix_1f32((MD_F32)a.y, (MD_F32)b.y, t)}; return c; }
|
||||||
|
|
||||||
#define md_v2s32(x, y) md_vec_2s32((x), (y))
|
#define md_v2s32(x, y) md_vec_2s32((x), (y))
|
||||||
inline MD_Vec2S32 md_vec_2s32 (MD_S32 x, MD_S32 y) { MD_Vec2S32 v = { x, y }; return v; }
|
inline MD_Vec2S32 md_vec_2s32 (MD_S32 x, MD_S32 y) { MD_Vec2S32 v = { x, y }; return v; }
|
||||||
inline MD_Vec2S32 md_add_2s32 (MD_Vec2S32 a, MD_Vec2S32 b) { MD_Vec2S32 c = {a.x + b.x, a.y + b.y}; return c; }
|
inline MD_Vec2S32 md_add_2s32 (MD_Vec2S32 a, MD_Vec2S32 b) { MD_Vec2S32 c = {a.x + b.x, a.y + b.y}; return c; }
|
||||||
inline MD_Vec2S32 md_sub_2s32 (MD_Vec2S32 a, MD_Vec2S32 b) { MD_Vec2S32 c = {a.x - b.x, a.y - b.y}; return c; }
|
inline MD_Vec2S32 md_sub_2s32 (MD_Vec2S32 a, MD_Vec2S32 b) { MD_Vec2S32 c = {a.x - b.x, a.y - b.y}; return c; }
|
||||||
inline MD_Vec2S32 md_mul_2s32 (MD_Vec2S32 a, MD_Vec2S32 b) { MD_Vec2S32 c = {a.x * b.x, a.y * b.y}; return c; }
|
inline MD_Vec2S32 md_mul_2s32 (MD_Vec2S32 a, MD_Vec2S32 b) { MD_Vec2S32 c = {a.x * b.x, a.y * b.y}; return c; }
|
||||||
inline MD_Vec2S32 md_div_2s32 (MD_Vec2S32 a, MD_Vec2S32 b) { MD_Vec2S32 c = {a.x / b.x, a.y / b.y}; return c; }
|
inline MD_Vec2S32 md_div_2s32 (MD_Vec2S32 a, MD_Vec2S32 b) { MD_Vec2S32 c = {a.x / b.x, a.y / b.y}; return c; }
|
||||||
inline MD_Vec2S32 md_scale_2s32 (MD_Vec2S32 v, MD_S32 s) { MD_Vec2S32 c = {v.x * s, v.y * s }; return c; }
|
inline MD_Vec2S32 md_scale_2s32 (MD_Vec2S32 v, MD_S32 s) { MD_Vec2S32 c = {v.x * s, v.y * s }; return c; }
|
||||||
inline MD_S32 md_dot_2s32 (MD_Vec2S32 a, MD_Vec2S32 b) { MD_S32 c = a.x * b.x + a.y * b.y; return c; }
|
inline MD_S32 md_dot_2s32 (MD_Vec2S32 a, MD_Vec2S32 b) { MD_S32 c = a.x * b.x + a.y * b.y; return c; }
|
||||||
inline MD_S32 md_length_squared_2s32(MD_Vec2S32 v) { MD_S32 c = v.x * v.x + v.y * v.y; return c; }
|
inline MD_S32 md_length_squared_2s32(MD_Vec2S32 v) { MD_S32 c = v.x * v.x + v.y * v.y; return c; }
|
||||||
inline MD_S32 md_length_2s32 (MD_Vec2S32 v) { MD_S32 c = (MD_S32)md_sqrt_f32((MD_F32)v.x*(MD_F32)v.x + (MD_F32)v.y*(MD_F32)v.y); return c; }
|
inline MD_S32 md_length_2s32 (MD_Vec2S32 v) { MD_S32 c = (MD_S32)md_sqrt_f32((MD_F32)v.x*(MD_F32)v.x + (MD_F32)v.y*(MD_F32)v.y); return c; }
|
||||||
inline MD_Vec2S32 md_normalize_2s32 (MD_Vec2S32 v) { v = md_scale_2s32(v, (MD_S32)(1.f / md_length_2s32(v))); return v; }
|
inline MD_Vec2S32 md_normalize_2s32 (MD_Vec2S32 v) { v = md_scale_2s32(v, (MD_S32)(1.f / md_length_2s32(v))); return v; }
|
||||||
inline MD_Vec2S32 md_mix_2s32 (MD_Vec2S32 a, MD_Vec2S32 b, MD_F32 t) { MD_Vec2S32 c = {(MD_S32)md_mix_1f32((MD_F32)a.x, (MD_F32)b.x, t), (MD_S32)md_mix_1f32((MD_F32)a.y, (MD_F32)b.y, t)}; return c; }
|
inline MD_Vec2S32 md_mix_2s32 (MD_Vec2S32 a, MD_Vec2S32 b, MD_F32 t) { MD_Vec2S32 c = {(MD_S32)md_mix_1f32((MD_F32)a.x, (MD_F32)b.x, t), (MD_S32)md_mix_1f32((MD_F32)a.y, (MD_F32)b.y, t)}; return c; }
|
||||||
|
|
||||||
#define md_v2s16(x, y) md_vec_2s16((x), (y))
|
#define md_v2s16(x, y) md_vec_2s16((x), (y))
|
||||||
inline MD_Vec2S16 md_vec_2s16 (MD_S16 x, MD_S16 y) { MD_Vec2S16 v = { x, y }; return v; }
|
inline MD_Vec2S16 md_vec_2s16 (MD_S16 x, MD_S16 y) { MD_Vec2S16 v = { x, y }; return v; }
|
||||||
inline MD_Vec2S16 md_add_2s16 (MD_Vec2S16 a, MD_Vec2S16 b) { MD_Vec2S16 c = {(MD_S16)(a.x + b.x), (MD_S16)(a.y + b.y)}; return c; }
|
inline MD_Vec2S16 md_add_2s16 (MD_Vec2S16 a, MD_Vec2S16 b) { MD_Vec2S16 c = {(MD_S16)(a.x + b.x), (MD_S16)(a.y + b.y)}; return c; }
|
||||||
inline MD_Vec2S16 md_sub_2s16 (MD_Vec2S16 a, MD_Vec2S16 b) { MD_Vec2S16 c = {(MD_S16)(a.x - b.x), (MD_S16)(a.y - b.y)}; return c; }
|
inline MD_Vec2S16 md_sub_2s16 (MD_Vec2S16 a, MD_Vec2S16 b) { MD_Vec2S16 c = {(MD_S16)(a.x - b.x), (MD_S16)(a.y - b.y)}; return c; }
|
||||||
inline MD_Vec2S16 md_mul_2s16 (MD_Vec2S16 a, MD_Vec2S16 b) { MD_Vec2S16 c = {(MD_S16)(a.x * b.x), (MD_S16)(a.y * b.y)}; return c; }
|
inline MD_Vec2S16 md_mul_2s16 (MD_Vec2S16 a, MD_Vec2S16 b) { MD_Vec2S16 c = {(MD_S16)(a.x * b.x), (MD_S16)(a.y * b.y)}; return c; }
|
||||||
inline MD_Vec2S16 md_div_2s16 (MD_Vec2S16 a, MD_Vec2S16 b) { MD_Vec2S16 c = {(MD_S16)(a.x / b.x), (MD_S16)(a.y / b.y)}; return c; }
|
inline MD_Vec2S16 md_div_2s16 (MD_Vec2S16 a, MD_Vec2S16 b) { MD_Vec2S16 c = {(MD_S16)(a.x / b.x), (MD_S16)(a.y / b.y)}; return c; }
|
||||||
inline MD_Vec2S16 md_scale_2s16 (MD_Vec2S16 v, MD_S16 s) { MD_Vec2S16 c = {(MD_S16)(v.x * s ), (MD_S16)(v.y * s )}; return c; }
|
inline MD_Vec2S16 md_scale_2s16 (MD_Vec2S16 v, MD_S16 s) { MD_Vec2S16 c = {(MD_S16)(v.x * s ), (MD_S16)(v.y * s )}; return c; }
|
||||||
inline MD_S16 md_dot_2s16 (MD_Vec2S16 a, MD_Vec2S16 b) { MD_S16 c = a.x * b.x + a.y * b.y; return c; }
|
inline MD_S16 md_dot_2s16 (MD_Vec2S16 a, MD_Vec2S16 b) { MD_S16 c = a.x * b.x + a.y * b.y; return c; }
|
||||||
inline MD_S16 md_length_squared_2s16(MD_Vec2S16 v) { MD_S16 c = v.x * v.x + v.y * v.y; return c; }
|
inline MD_S16 md_length_squared_2s16(MD_Vec2S16 v) { MD_S16 c = v.x * v.x + v.y * v.y; return c; }
|
||||||
inline MD_S16 md_length_2s16 (MD_Vec2S16 v) { MD_S16 c = (MD_S16)md_sqrt_f32((MD_F32)(v.x*v.x + v.y*v.y)); return c; }
|
inline MD_S16 md_length_2s16 (MD_Vec2S16 v) { MD_S16 c = (MD_S16)md_sqrt_f32((MD_F32)(v.x*v.x + v.y*v.y)); return c; }
|
||||||
inline MD_Vec2S16 md_normalize_2s16 (MD_Vec2S16 v) { v = md_scale_2s16(v, (MD_S16)(1.f / md_length_2s16(v))); return v; }
|
inline MD_Vec2S16 md_normalize_2s16 (MD_Vec2S16 v) { v = md_scale_2s16(v, (MD_S16)(1.f / md_length_2s16(v))); return v; }
|
||||||
inline MD_Vec2S16 md_mix_2s16 (MD_Vec2S16 a, MD_Vec2S16 b, MD_F32 t) { MD_Vec2S16 c = {(MD_S16)md_mix_1f32((MD_F32)a.x, (MD_F32)b.x, t), (MD_S16)md_mix_1f32((MD_F32)a.y, (MD_F32)b.y, t)}; return c; }
|
inline MD_Vec2S16 md_mix_2s16 (MD_Vec2S16 a, MD_Vec2S16 b, MD_F32 t) { MD_Vec2S16 c = {(MD_S16)md_mix_1f32((MD_F32)a.x, (MD_F32)b.x, t), (MD_S16)md_mix_1f32((MD_F32)a.y, (MD_F32)b.y, t)}; return c; }
|
||||||
|
|
||||||
#define md_vec2(a, b) _Generic(a, MD_S16: md_vec_2s16, MD_S32: md_vec_2s32, MD_S64: md_vec_2s64, MD_F32: md_vec_2f32 )((a), (b))
|
#define md_vec2(a, b) _Generic(a, MD_S16: md_vec_2s16, MD_S32: md_vec_2s32, MD_S64: md_vec_2s64, MD_F32: md_vec_2f32 )((a), (b))
|
||||||
@@ -499,31 +499,31 @@ inline MD_Vec2S16 md_mix_2s16 (MD_Vec2S16 a, MD_Vec2S16 b, MD_F32 t) {
|
|||||||
|
|
||||||
#define md_v3f32(x, y, z) md_vec_3f32((x), (y), (z))
|
#define md_v3f32(x, y, z) md_vec_3f32((x), (y), (z))
|
||||||
inline MD_Vec3F32 md_vec_3f32 (MD_F32 x, MD_F32 y, MD_F32 z) { MD_Vec3F32 v = {x, y, z}; return v; }
|
inline MD_Vec3F32 md_vec_3f32 (MD_F32 x, MD_F32 y, MD_F32 z) { MD_Vec3F32 v = {x, y, z}; return v; }
|
||||||
inline MD_Vec3F32 md_add_3f32 (MD_Vec3F32 a, MD_Vec3F32 b) { MD_Vec3F32 c = {a.x + b.x, a.y + b.y, a.z + b.z}; return c; }
|
inline MD_Vec3F32 md_add_3f32 (MD_Vec3F32 a, MD_Vec3F32 b) { MD_Vec3F32 c = {a.x + b.x, a.y + b.y, a.z + b.z}; return c; }
|
||||||
inline MD_Vec3F32 md_sub_3f32 (MD_Vec3F32 a, MD_Vec3F32 b) { MD_Vec3F32 c = {a.x - b.x, a.y - b.y, a.z - b.z}; return c; }
|
inline MD_Vec3F32 md_sub_3f32 (MD_Vec3F32 a, MD_Vec3F32 b) { MD_Vec3F32 c = {a.x - b.x, a.y - b.y, a.z - b.z}; return c; }
|
||||||
inline MD_Vec3F32 md_mul_3f32 (MD_Vec3F32 a, MD_Vec3F32 b) { MD_Vec3F32 c = {a.x * b.x, a.y * b.y, a.z * b.z}; return c; }
|
inline MD_Vec3F32 md_mul_3f32 (MD_Vec3F32 a, MD_Vec3F32 b) { MD_Vec3F32 c = {a.x * b.x, a.y * b.y, a.z * b.z}; return c; }
|
||||||
inline MD_Vec3F32 md_div_3f32 (MD_Vec3F32 a, MD_Vec3F32 b) { MD_Vec3F32 c = {a.x / b.x, a.y / b.y, a.z / b.z}; return c; }
|
inline MD_Vec3F32 md_div_3f32 (MD_Vec3F32 a, MD_Vec3F32 b) { MD_Vec3F32 c = {a.x / b.x, a.y / b.y, a.z / b.z}; return c; }
|
||||||
inline MD_Vec3F32 md_scale_3f32 (MD_Vec3F32 v, MD_F32 s) { MD_Vec3F32 c = {v.x * s, v.y * s, v.z * s}; return c; }
|
inline MD_Vec3F32 md_scale_3f32 (MD_Vec3F32 v, MD_F32 s) { MD_Vec3F32 c = {v.x * s, v.y * s, v.z * s}; return c; }
|
||||||
inline MD_F32 md_dot_3f32 (MD_Vec3F32 a, MD_Vec3F32 b) { MD_F32 c = a.x * b.x + a.y * b.y + a.z * b.z; return c; }
|
inline MD_F32 md_dot_3f32 (MD_Vec3F32 a, MD_Vec3F32 b) { MD_F32 c = a.x * b.x + a.y * b.y + a.z * b.z; return c; }
|
||||||
inline MD_F32 md_length_squared_3f32(MD_Vec3F32 v) { MD_F32 c = v.x * v.x + v.y * v.y + v.z * v.z; return c; }
|
inline MD_F32 md_length_squared_3f32(MD_Vec3F32 v) { MD_F32 c = v.x * v.x + v.y * v.y + v.z * v.z; return c; }
|
||||||
inline MD_F32 md_length_3f32 (MD_Vec3F32 v) { MD_F32 c = md_sqrt_f32(v.x * v.x + v.y * v.y + v.z * v.z); return c; }
|
inline MD_F32 md_length_3f32 (MD_Vec3F32 v) { MD_F32 c = md_sqrt_f32(v.x * v.x + v.y * v.y + v.z * v.z); return c; }
|
||||||
inline MD_Vec3F32 md_normalize_3f32 (MD_Vec3F32 v) { v = md_scale_3f32(v, 1.f / md_length_3f32(v)); return v; }
|
inline MD_Vec3F32 md_normalize_3f32 (MD_Vec3F32 v) { v = md_scale_3f32(v, 1.f / md_length_3f32(v)); return v; }
|
||||||
inline MD_Vec3F32 md_mix_3f32 (MD_Vec3F32 a, MD_Vec3F32 b, MD_F32 t) { MD_Vec3F32 c = {md_mix_1f32(a.x, b.x, t), md_mix_1f32(a.y, b.y, t), md_mix_1f32(a.z, b.z, t)}; return c; }
|
inline MD_Vec3F32 md_mix_3f32 (MD_Vec3F32 a, MD_Vec3F32 b, MD_F32 t) { MD_Vec3F32 c = {md_mix_1f32(a.x, b.x, t), md_mix_1f32(a.y, b.y, t), md_mix_1f32(a.z, b.z, t)}; return c; }
|
||||||
inline MD_Vec3F32 md_cross_3f32 (MD_Vec3F32 a, MD_Vec3F32 b) { MD_Vec3F32 c = {a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x}; return c; }
|
inline MD_Vec3F32 md_cross_3f32 (MD_Vec3F32 a, MD_Vec3F32 b) { MD_Vec3F32 c = {a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x}; return c; }
|
||||||
|
|
||||||
#define md_v3s32(x, y, z) md_vec_3s32((x), (y), (z))
|
#define md_v3s32(x, y, z) md_vec_3s32((x), (y), (z))
|
||||||
inline MD_Vec3S32 md_vec_3s32 (MD_S32 x, MD_S32 y, MD_S32 z) { MD_Vec3S32 v = {x, y, z}; return v; }
|
inline MD_Vec3S32 md_vec_3s32 (MD_S32 x, MD_S32 y, MD_S32 z) { MD_Vec3S32 v = {x, y, z}; return v; }
|
||||||
inline MD_Vec3S32 md_add_3s32 (MD_Vec3S32 a, MD_Vec3S32 b) { MD_Vec3S32 c = {a.x + b.x, a.y + b.y, a.z + b.z}; return c; }
|
inline MD_Vec3S32 md_add_3s32 (MD_Vec3S32 a, MD_Vec3S32 b) { MD_Vec3S32 c = {a.x + b.x, a.y + b.y, a.z + b.z}; return c; }
|
||||||
inline MD_Vec3S32 md_sub_3s32 (MD_Vec3S32 a, MD_Vec3S32 b) { MD_Vec3S32 c = {a.x - b.x, a.y - b.y, a.z - b.z}; return c; }
|
inline MD_Vec3S32 md_sub_3s32 (MD_Vec3S32 a, MD_Vec3S32 b) { MD_Vec3S32 c = {a.x - b.x, a.y - b.y, a.z - b.z}; return c; }
|
||||||
inline MD_Vec3S32 md_mul_3s32 (MD_Vec3S32 a, MD_Vec3S32 b) { MD_Vec3S32 c = {a.x * b.x, a.y * b.y, a.z * b.z}; return c; }
|
inline MD_Vec3S32 md_mul_3s32 (MD_Vec3S32 a, MD_Vec3S32 b) { MD_Vec3S32 c = {a.x * b.x, a.y * b.y, a.z * b.z}; return c; }
|
||||||
inline MD_Vec3S32 md_div_3s32 (MD_Vec3S32 a, MD_Vec3S32 b) { MD_Vec3S32 c = {a.x / b.x, a.y / b.y, a.z / b.z}; return c; }
|
inline MD_Vec3S32 md_div_3s32 (MD_Vec3S32 a, MD_Vec3S32 b) { MD_Vec3S32 c = {a.x / b.x, a.y / b.y, a.z / b.z}; return c; }
|
||||||
inline MD_Vec3S32 md_scale_3s32 (MD_Vec3S32 v, MD_S32 s) { MD_Vec3S32 c = {v.x * s, v.y * s, v.z * s }; return c; }
|
inline MD_Vec3S32 md_scale_3s32 (MD_Vec3S32 v, MD_S32 s) { MD_Vec3S32 c = {v.x * s, v.y * s, v.z * s }; return c; }
|
||||||
inline MD_S32 md_dot_3s32 (MD_Vec3S32 a, MD_Vec3S32 b) { MD_S32 c = a.x * b.x + a.y * b.y + a.z * b.z; return c; }
|
inline MD_S32 md_dot_3s32 (MD_Vec3S32 a, MD_Vec3S32 b) { MD_S32 c = a.x * b.x + a.y * b.y + a.z * b.z; return c; }
|
||||||
inline MD_S32 md_length_squared_3s32(MD_Vec3S32 v) { MD_S32 c = v.x * v.x + v.y * v.y + v.z * v.z; return c; }
|
inline MD_S32 md_length_squared_3s32(MD_Vec3S32 v) { MD_S32 c = v.x * v.x + v.y * v.y + v.z * v.z; return c; }
|
||||||
inline MD_S32 md_length_3s32 (MD_Vec3S32 v) { MD_S32 c = (MD_S32)md_sqrt_f32((MD_F32)(v.x * v.x + v.y * v.y + v.z * v.z)); return c; }
|
inline MD_S32 md_length_3s32 (MD_Vec3S32 v) { MD_S32 c = (MD_S32)md_sqrt_f32((MD_F32)(v.x * v.x + v.y * v.y + v.z * v.z)); return c; }
|
||||||
inline MD_Vec3S32 md_normalize_3s32 (MD_Vec3S32 v) { v = md_scale_3s32(v, (MD_S32)(1.f / md_length_3s32(v))); return v; }
|
inline MD_Vec3S32 md_normalize_3s32 (MD_Vec3S32 v) { v = md_scale_3s32(v, (MD_S32)(1.f / md_length_3s32(v))); return v; }
|
||||||
inline MD_Vec3S32 md_mix_3s32 (MD_Vec3S32 a, MD_Vec3S32 b, MD_F32 t) { MD_Vec3S32 c = {(MD_S32)md_mix_1f32((MD_F32)a.x, (MD_F32)b.x, t), (MD_S32)md_mix_1f32((MD_F32)a.y, (MD_F32)b.y, t), (MD_S32)md_mix_1f32((MD_F32)a.z, (MD_F32)b.z, t)}; return c; }
|
inline MD_Vec3S32 md_mix_3s32 (MD_Vec3S32 a, MD_Vec3S32 b, MD_F32 t) { MD_Vec3S32 c = {(MD_S32)md_mix_1f32((MD_F32)a.x, (MD_F32)b.x, t), (MD_S32)md_mix_1f32((MD_F32)a.y, (MD_F32)b.y, t), (MD_S32)md_mix_1f32((MD_F32)a.z, (MD_F32)b.z, t)}; return c; }
|
||||||
inline MD_Vec3S32 md_cross_3s32 (MD_Vec3S32 a, MD_Vec3S32 b) { MD_Vec3S32 c = {a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x}; return c; }
|
inline MD_Vec3S32 md_cross_3s32 (MD_Vec3S32 a, MD_Vec3S32 b) { MD_Vec3S32 c = {a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x}; return c; }
|
||||||
|
|
||||||
#define md_vec3(a, b, c) _Generic(a, MD_S32: md_vec_3s32, MD_F32: md_vec_3f32 )((a), (b), (c))
|
#define md_vec3(a, b, c) _Generic(a, MD_S32: md_vec_3s32, MD_F32: md_vec_3f32 )((a), (b), (c))
|
||||||
#define md_add_vec3(a, b) _Generic(a, MD_S32: md_add_3s32, MD_F32: md_add_3f32 )((a), (b))
|
#define md_add_vec3(a, b) _Generic(a, MD_S32: md_add_3s32, MD_F32: md_add_3f32 )((a), (b))
|
||||||
@@ -541,30 +541,30 @@ inline MD_Vec3S32 md_cross_3s32 (MD_Vec3S32 a, MD_Vec3S32 b) { MD
|
|||||||
// ==================== 4D Vectors ====================
|
// ==================== 4D Vectors ====================
|
||||||
|
|
||||||
#define md_v4f32(x, y, z, w) md_vec_4f32((x), (y), (z), (w))
|
#define md_v4f32(x, y, z, w) md_vec_4f32((x), (y), (z), (w))
|
||||||
inline MD_Vec4F32 md_vec_4f32 (MD_F32 x, MD_F32 y, MD_F32 z, MD_F32 w) { MD_Vec4F32 v = {x, y, z, w}; return v; }
|
inline MD_Vec4F32 md_vec_4f32 (MD_F32 x, MD_F32 y, MD_F32 z, MD_F32 w) { MD_Vec4F32 v = {x, y, z, w}; return v; }
|
||||||
inline MD_Vec4F32 md_add_4f32 (MD_Vec4F32 a, MD_Vec4F32 b) { MD_Vec4F32 c = {a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w}; return c; }
|
inline MD_Vec4F32 md_add_4f32 (MD_Vec4F32 a, MD_Vec4F32 b) { MD_Vec4F32 c = {a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w}; return c; }
|
||||||
inline MD_Vec4F32 md_sub_4f32 (MD_Vec4F32 a, MD_Vec4F32 b) { MD_Vec4F32 c = {a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w}; return c; }
|
inline MD_Vec4F32 md_sub_4f32 (MD_Vec4F32 a, MD_Vec4F32 b) { MD_Vec4F32 c = {a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w}; return c; }
|
||||||
inline MD_Vec4F32 md_mul_4f32 (MD_Vec4F32 a, MD_Vec4F32 b) { MD_Vec4F32 c = {a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w}; return c; }
|
inline MD_Vec4F32 md_mul_4f32 (MD_Vec4F32 a, MD_Vec4F32 b) { MD_Vec4F32 c = {a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w}; return c; }
|
||||||
inline MD_Vec4F32 md_div_4f32 (MD_Vec4F32 a, MD_Vec4F32 b) { MD_Vec4F32 c = {a.x / b.x, a.y / b.y, a.z / b.z, a.w / b.w}; return c; }
|
inline MD_Vec4F32 md_div_4f32 (MD_Vec4F32 a, MD_Vec4F32 b) { MD_Vec4F32 c = {a.x / b.x, a.y / b.y, a.z / b.z, a.w / b.w}; return c; }
|
||||||
inline MD_Vec4F32 md_scale_4f32 (MD_Vec4F32 v, MD_F32 s) { MD_Vec4F32 c = {v.x * s, v.y * s, v.z * s, v.w * s }; return c; }
|
inline MD_Vec4F32 md_scale_4f32 (MD_Vec4F32 v, MD_F32 s) { MD_Vec4F32 c = {v.x * s, v.y * s, v.z * s, v.w * s }; return c; }
|
||||||
inline MD_F32 md_dot_4f32 (MD_Vec4F32 a, MD_Vec4F32 b) { MD_F32 c = a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w; return c; }
|
inline MD_F32 md_dot_4f32 (MD_Vec4F32 a, MD_Vec4F32 b) { MD_F32 c = a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w; return c; }
|
||||||
inline MD_F32 md_length_squared_4f32(MD_Vec4F32 v) { MD_F32 c = v.x * v.x + v.y * v.y + v.z * v.z + v.w * v.w; return c; }
|
inline MD_F32 md_length_squared_4f32(MD_Vec4F32 v) { MD_F32 c = v.x * v.x + v.y * v.y + v.z * v.z + v.w * v.w; return c; }
|
||||||
inline MD_F32 md_length_4f32 (MD_Vec4F32 v) { MD_F32 c = md_sqrt_f32(v.x * v.x + v.y * v.y + v.z * v.z + v.w * v.w); return c; }
|
inline MD_F32 md_length_4f32 (MD_Vec4F32 v) { MD_F32 c = md_sqrt_f32(v.x * v.x + v.y * v.y + v.z * v.z + v.w * v.w); return c; }
|
||||||
inline MD_Vec4F32 md_normalize_4f32 (MD_Vec4F32 v) { v = md_scale_4f32(v, 1.f / md_length_4f32(v)); return v; }
|
inline MD_Vec4F32 md_normalize_4f32 (MD_Vec4F32 v) { v = md_scale_4f32(v, 1.f / md_length_4f32(v)); return v; }
|
||||||
inline MD_Vec4F32 md_mix_4f32 (MD_Vec4F32 a, MD_Vec4F32 b, MD_F32 t) { MD_Vec4F32 c = {md_mix_1f32(a.x, b.x, t), md_mix_1f32(a.y, b.y, t), md_mix_1f32(a.z, b.z, t), md_mix_1f32(a.w, b.w, t)}; return c; }
|
inline MD_Vec4F32 md_mix_4f32 (MD_Vec4F32 a, MD_Vec4F32 b, MD_F32 t) { MD_Vec4F32 c = {md_mix_1f32(a.x, b.x, t), md_mix_1f32(a.y, b.y, t), md_mix_1f32(a.z, b.z, t), md_mix_1f32(a.w, b.w, t)}; return c; }
|
||||||
|
|
||||||
#define v4s32(x, y, z, w) md_vec_4s32((x), (y), (z), (w))
|
#define v4s32(x, y, z, w) md_vec_4s32((x), (y), (z), (w))
|
||||||
inline MD_Vec4S32 md_vec_4s32 (MD_S32 x, MD_S32 y, MD_S32 z, MD_S32 w) { MD_Vec4S32 v = {x, y, z, w}; return v; }
|
inline MD_Vec4S32 md_vec_4s32 (MD_S32 x, MD_S32 y, MD_S32 z, MD_S32 w) { MD_Vec4S32 v = {x, y, z, w}; return v; }
|
||||||
inline MD_Vec4S32 md_add_4s32 (MD_Vec4S32 a, MD_Vec4S32 b) { MD_Vec4S32 c = {a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w}; return c; }
|
inline MD_Vec4S32 md_add_4s32 (MD_Vec4S32 a, MD_Vec4S32 b) { MD_Vec4S32 c = {a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w}; return c; }
|
||||||
inline MD_Vec4S32 md_sub_4s32 (MD_Vec4S32 a, MD_Vec4S32 b) { MD_Vec4S32 c = {a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w}; return c; }
|
inline MD_Vec4S32 md_sub_4s32 (MD_Vec4S32 a, MD_Vec4S32 b) { MD_Vec4S32 c = {a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w}; return c; }
|
||||||
inline MD_Vec4S32 md_mul_4s32 (MD_Vec4S32 a, MD_Vec4S32 b) { MD_Vec4S32 c = {a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w}; return c; }
|
inline MD_Vec4S32 md_mul_4s32 (MD_Vec4S32 a, MD_Vec4S32 b) { MD_Vec4S32 c = {a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w}; return c; }
|
||||||
inline MD_Vec4S32 md_div_4s32 (MD_Vec4S32 a, MD_Vec4S32 b) { MD_Vec4S32 c = {a.x / b.x, a.y / b.y, a.z / b.z, a.w / b.w}; return c; }
|
inline MD_Vec4S32 md_div_4s32 (MD_Vec4S32 a, MD_Vec4S32 b) { MD_Vec4S32 c = {a.x / b.x, a.y / b.y, a.z / b.z, a.w / b.w}; return c; }
|
||||||
inline MD_Vec4S32 md_scale_4s32 (MD_Vec4S32 v, MD_S32 s) { MD_Vec4S32 c = {v.x * s, v.y * s, v.z * s, v.w * s }; return c; }
|
inline MD_Vec4S32 md_scale_4s32 (MD_Vec4S32 v, MD_S32 s) { MD_Vec4S32 c = {v.x * s, v.y * s, v.z * s, v.w * s }; return c; }
|
||||||
inline MD_S32 md_dot_4s32 (MD_Vec4S32 a, MD_Vec4S32 b) { MD_S32 c = a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w; return c; }
|
inline MD_S32 md_dot_4s32 (MD_Vec4S32 a, MD_Vec4S32 b) { MD_S32 c = a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w; return c; }
|
||||||
inline MD_S32 md_length_squared_4s32(MD_Vec4S32 v) { MD_S32 c = v.x * v.x + v.y * v.y + v.z * v.z + v.w * v.w; return c; }
|
inline MD_S32 md_length_squared_4s32(MD_Vec4S32 v) { MD_S32 c = v.x * v.x + v.y * v.y + v.z * v.z + v.w * v.w; return c; }
|
||||||
inline MD_S32 md_length_4s32 (MD_Vec4S32 v) { MD_S32 c = (MD_S32)md_sqrt_f32((MD_F32)(v.x * v.x + v.y * v.y + v.z * v.z + v.w * v.w)); return c; }
|
inline MD_S32 md_length_4s32 (MD_Vec4S32 v) { MD_S32 c = (MD_S32)md_sqrt_f32((MD_F32)(v.x * v.x + v.y * v.y + v.z * v.z + v.w * v.w)); return c; }
|
||||||
inline MD_Vec4S32 md_normalize_4s32 (MD_Vec4S32 v) { v = md_scale_4s32(v, (MD_S32)(1.f / md_length_4s32(v))); return v; }
|
inline MD_Vec4S32 md_normalize_4s32 (MD_Vec4S32 v) { v = md_scale_4s32(v, (MD_S32)(1.f / md_length_4s32(v))); return v; }
|
||||||
inline MD_Vec4S32 md_mix_4s32 (MD_Vec4S32 a, MD_Vec4S32 b, MD_F32 t) { MD_Vec4S32 c = {(MD_S32)md_mix_1f32((MD_F32)a.x, (MD_F32)b.x, t), (MD_S32)md_mix_1f32((MD_F32)a.y, (MD_F32)b.y, t), (MD_S32)md_mix_1f32((MD_F32)a.z, (MD_F32)b.z, t), (MD_S32)md_mix_1f32((MD_F32)a.w, (MD_F32)b.w, t)}; return c; }
|
inline MD_Vec4S32 md_mix_4s32 (MD_Vec4S32 a, MD_Vec4S32 b, MD_F32 t) { MD_Vec4S32 c = {(MD_S32)md_mix_1f32((MD_F32)a.x, (MD_F32)b.x, t), (MD_S32)md_mix_1f32((MD_F32)a.y, (MD_F32)b.y, t), (MD_S32)md_mix_1f32((MD_F32)a.z, (MD_F32)b.z, t), (MD_S32)md_mix_1f32((MD_F32)a.w, (MD_F32)b.w, t)}; return c; }
|
||||||
|
|
||||||
#define md_vec4(a, b, c, d) _Generic(a, MD_S32: md_vec_4s32, MD_F32: md_vec_4f32 )((a), (b), (c), (d))
|
#define md_vec4(a, b, c, d) _Generic(a, MD_S32: md_vec_4s32, MD_F32: md_vec_4f32 )((a), (b), (c), (d))
|
||||||
#define md_add_vec4(a, b) _Generic(a, MD_S32: md_add_4s32, MD_F32: md_add_4f32 )((a), (b))
|
#define md_add_vec4(a, b) _Generic(a, MD_S32: md_add_4s32, MD_F32: md_add_4f32 )((a), (b))
|
||||||
@@ -583,18 +583,18 @@ inline MD_Vec4S32 md_mix_4s32 (MD_Vec4S32 a, MD_Vec4S32 b, MD_F32 t) {
|
|||||||
|
|
||||||
// ==================== 3x3 Matrix ====================
|
// ==================== 3x3 Matrix ====================
|
||||||
|
|
||||||
inline MD_Mat3x3F32 md_mat_3x3f32 (MD_F32 diag) { MD_Mat3x3F32 res = {0}; res.v[0][0] = diag; res.v[1][1] = diag; res.v[2][2] = diag; return res; }
|
inline MD_Mat3x3F32 md_mat_3x3f32 (MD_F32 diag) { MD_Mat3x3F32 res = {0}; res.v[0][0] = diag; res.v[1][1] = diag; res.v[2][2] = diag; return res; }
|
||||||
inline MD_Mat3x3F32 md_make_translate_3x3f32(MD_Vec2F32 delta) { MD_Mat3x3F32 mat = md_mat_3x3f32(1.f); mat.v[2][0] = delta.x; mat.v[2][1] = delta.y; return mat; }
|
inline MD_Mat3x3F32 md_make_translate_3x3f32(MD_Vec2F32 delta) { MD_Mat3x3F32 mat = md_mat_3x3f32(1.f); mat.v[2][0] = delta.x; mat.v[2][1] = delta.y; return mat; }
|
||||||
inline MD_Mat3x3F32 md_make_scale_3x3f32 (MD_Vec2F32 scale) { MD_Mat3x3F32 mat = md_mat_3x3f32(1.f); mat.v[0][0] = scale.x; mat.v[1][1] = scale.y; return mat; }
|
inline MD_Mat3x3F32 md_make_scale_3x3f32 (MD_Vec2F32 scale) { MD_Mat3x3F32 mat = md_mat_3x3f32(1.f); mat.v[0][0] = scale.x; mat.v[1][1] = scale.y; return mat; }
|
||||||
inline MD_Mat3x3F32 md_mul_3x3f32 (MD_Mat3x3F32 a, MD_Mat3x3F32 b) { MD_Mat3x3F32 c = {0}; for(int j = 0; j < 3; j += 1) for(int i = 0; i < 3; i += 1) { c.v[i][j] = (a.v[0][j]*b.v[i][0] + a.v[1][j] * b.v[i][1] + a.v[2][j] * b.v[i][2]); } return c; }
|
inline MD_Mat3x3F32 md_mul_3x3f32 (MD_Mat3x3F32 a, MD_Mat3x3F32 b) { MD_Mat3x3F32 c = {0}; for(int j = 0; j < 3; j += 1) for(int i = 0; i < 3; i += 1) { c.v[i][j] = (a.v[0][j]*b.v[i][0] + a.v[1][j] * b.v[i][1] + a.v[2][j] * b.v[i][2]); } return c; }
|
||||||
|
|
||||||
inline MD_Mat4x4F32 md_mat_4x4f32 (MD_F32 diag) { MD_Mat4x4F32 res = {0}; res.v[0][0] = diag; res.v[1][1] = diag; res.v[2][2] = diag; res.v[3][3] = diag; return res; }
|
inline MD_Mat4x4F32 md_mat_4x4f32 (MD_F32 diag) { MD_Mat4x4F32 res = {0}; res.v[0][0] = diag; res.v[1][1] = diag; res.v[2][2] = diag; res.v[3][3] = diag; return res; }
|
||||||
inline MD_Mat4x4F32 md_make_translate_4x4f32(MD_Vec3F32 delta) { MD_Mat4x4F32 res = md_mat_4x4f32(1.f); res.v[3][0] = delta.x; res.v[3][1] = delta.y; res.v[3][2] = delta.z; return res; }
|
inline MD_Mat4x4F32 md_make_translate_4x4f32(MD_Vec3F32 delta) { MD_Mat4x4F32 res = md_mat_4x4f32(1.f); res.v[3][0] = delta.x; res.v[3][1] = delta.y; res.v[3][2] = delta.z; return res; }
|
||||||
inline MD_Mat4x4F32 md_make_scale_4x4f32 (MD_Vec3F32 scale) { MD_Mat4x4F32 res = md_mat_4x4f32(1.f); res.v[0][0] = scale.x; res.v[1][1] = scale.y; res.v[2][2] = scale.z; return res; }
|
inline MD_Mat4x4F32 md_make_scale_4x4f32 (MD_Vec3F32 scale) { MD_Mat4x4F32 res = md_mat_4x4f32(1.f); res.v[0][0] = scale.x; res.v[1][1] = scale.y; res.v[2][2] = scale.z; return res; }
|
||||||
|
|
||||||
// ==================== 4x4 Matrix ====================
|
// ==================== 4x4 Matrix ====================
|
||||||
|
|
||||||
MD_Mat4x4F32 md_make_perspective_4x4f32 (MD_F32 fov, MD_F32 aspect_ratio, MD_F32 near_z, MD_F32 far_z);
|
MD_Mat4x4F32 md_make_perspective_4x4f32 (MD_F32 fov, MD_F32 aspect_ratio, MD_F32 near_z, MD_F32 far_z);
|
||||||
MD_Mat4x4F32 md_make_orthographic_4x4f32(MD_F32 left, MD_F32 right, MD_F32 bottom, MD_F32 top, MD_F32 near_z, MD_F32 far_z);
|
MD_Mat4x4F32 md_make_orthographic_4x4f32(MD_F32 left, MD_F32 right, MD_F32 bottom, MD_F32 top, MD_F32 near_z, MD_F32 far_z);
|
||||||
MD_Mat4x4F32 md_make_look_at_4x4f32 (MD_Vec3F32 eye, MD_Vec3F32 center, MD_Vec3F32 up);
|
MD_Mat4x4F32 md_make_look_at_4x4f32 (MD_Vec3F32 eye, MD_Vec3F32 center, MD_Vec3F32 up);
|
||||||
MD_Mat4x4F32 md_make_rotate_4x4f32 (MD_Vec3F32 axis, MD_F32 turns);
|
MD_Mat4x4F32 md_make_rotate_4x4f32 (MD_Vec3F32 axis, MD_F32 turns);
|
||||||
@@ -642,16 +642,16 @@ md_make_look_at_4x4f32(MD_Vec3F32 eye, MD_Vec3F32 center, MD_Vec3F32 up) {
|
|||||||
MD_Vec3F32 f = md_normalize_3f32(md_sub_3f32(eye, center));
|
MD_Vec3F32 f = md_normalize_3f32(md_sub_3f32(eye, center));
|
||||||
MD_Vec3F32 s = md_normalize_3f32(md_cross_3f32(f, up));
|
MD_Vec3F32 s = md_normalize_3f32(md_cross_3f32(f, up));
|
||||||
MD_Vec3F32 u = md_cross_3f32(s, f);
|
MD_Vec3F32 u = md_cross_3f32(s, f);
|
||||||
result.v[0][0] = s.x; result.v[0][1] = u.x; result.v[0][2] = -f.x; result.v[0][3] = 0.0f;
|
result.v[0][0] = s.x; result.v[0][1] = u.x; result.v[0][2] = -f.x; result.v[0][3] = 0.0f;
|
||||||
result.v[1][0] = s.y; result.v[1][1] = u.y; result.v[1][2] = -f.y; result.v[1][3] = 0.0f;
|
result.v[1][0] = s.y; result.v[1][1] = u.y; result.v[1][2] = -f.y; result.v[1][3] = 0.0f;
|
||||||
result.v[2][0] = s.z; result.v[2][1] = u.z; result.v[2][2] = -f.z; result.v[2][3] = 0.0f;
|
result.v[2][0] = s.z; result.v[2][1] = u.z; result.v[2][2] = -f.z; result.v[2][3] = 0.0f;
|
||||||
result.v[3][0] = -md_dot_3f32(s, eye); result.v[3][1] = -md_dot_3f32(u, eye); result.v[3][2] = md_dot_3f32(f, eye); result.v[3][3] = 1.0f;
|
result.v[3][0] = -md_dot_3f32(s, eye); result.v[3][1] = -md_dot_3f32(u, eye); result.v[3][2] = md_dot_3f32(f, eye); result.v[3][3] = 1.0f;
|
||||||
return result;
|
return result;
|
||||||
}
|
}
|
||||||
|
|
||||||
inline MD_Mat4x4F32
|
inline MD_Mat4x4F32
|
||||||
md_make_rotate_4x4f32(MD_Vec3F32 axis, MD_F32 turns) {
|
md_make_rotate_4x4f32(MD_Vec3F32 axis, MD_F32 turns) {
|
||||||
axis = md_normalize_3f32(axis);
|
axis = md_normalize_3f32(axis);
|
||||||
MD_F32 sin_theta = md_sin_f32(turns);
|
MD_F32 sin_theta = md_sin_f32(turns);
|
||||||
MD_F32 cos_theta = md_cos_f32(turns);
|
MD_F32 cos_theta = md_cos_f32(turns);
|
||||||
MD_F32 cos_value = 1.f - cos_theta;
|
MD_F32 cos_value = 1.f - cos_theta;
|
||||||
@@ -725,8 +725,8 @@ md_inverse_4x4f32(MD_Mat4x4F32 m) {
|
|||||||
MD_Vec4F32 fac4 = { coef16, coef16, coef18, coef19 };
|
MD_Vec4F32 fac4 = { coef16, coef16, coef18, coef19 };
|
||||||
MD_Vec4F32 fac5 = { coef20, coef20, coef22, coef23 };
|
MD_Vec4F32 fac5 = { coef20, coef20, coef22, coef23 };
|
||||||
|
|
||||||
MD_Vec4F32 vec0 = { m.v[1][0], m.v[0][0], m.v[0][0], m.v[0][0] };
|
MD_Vec4F32 vec0 = { m.v[1][0], m.v[0][0], m.v[0][0], m.v[0][0] };
|
||||||
MD_Vec4F32 vec1 = { m.v[1][1], m.v[0][1], m.v[0][1], m.v[0][1] };
|
MD_Vec4F32 vec1 = { m.v[1][1], m.v[0][1], m.v[0][1], m.v[0][1] };
|
||||||
MD_Vec4F32 md_vec2 = { m.v[1][2], m.v[0][2], m.v[0][2], m.v[0][2] };
|
MD_Vec4F32 md_vec2 = { m.v[1][2], m.v[0][2], m.v[0][2], m.v[0][2] };
|
||||||
MD_Vec4F32 md_vec3 = { m.v[1][3], m.v[0][3], m.v[0][3], m.v[0][3] };
|
MD_Vec4F32 md_vec3 = { m.v[1][3], m.v[0][3], m.v[0][3], m.v[0][3] };
|
||||||
|
|
||||||
@@ -774,97 +774,97 @@ md_derotate_4x4f32(MD_Mat4x4F32 mat) {
|
|||||||
// ==================== 1D Ranges ====================
|
// ==================== 1D Ranges ====================
|
||||||
|
|
||||||
#define md_r1u32(md_min, md_max) md_rng_1u32((md_min), (md_max))
|
#define md_r1u32(md_min, md_max) md_rng_1u32((md_min), (md_max))
|
||||||
inline MD_Rng1U32 md_rng_1u32 (MD_U32 md_min, MD_U32 md_max) { MD_Rng1U32 r = {md_min, md_max}; if(r.md_min > r.md_max) { md_swap(MD_U32, r.md_min, r.md_max); } return r; }
|
inline MD_Rng1U32 md_rng_1u32 (MD_U32 md_min, MD_U32 md_max) { MD_Rng1U32 r = {md_min, md_max}; if(r.md_min > r.md_max) { md_swap(MD_U32, r.md_min, r.md_max); } return r; }
|
||||||
inline MD_Rng1U32 md_shift_1u32 (MD_Rng1U32 r, MD_U32 x) { r.md_min += x; r.md_max += x; return r; }
|
inline MD_Rng1U32 md_shift_1u32 (MD_Rng1U32 r, MD_U32 x) { r.md_min += x; r.md_max += x; return r; }
|
||||||
inline MD_Rng1U32 md_pad_1u32 (MD_Rng1U32 r, MD_U32 x) { r.md_min -= x; r.md_max += x; return r; }
|
inline MD_Rng1U32 md_pad_1u32 (MD_Rng1U32 r, MD_U32 x) { r.md_min -= x; r.md_max += x; return r; }
|
||||||
inline MD_U32 md_center_1u32 (MD_Rng1U32 r) { MD_U32 c = (r.md_min + r.md_max) / 2; return c; }
|
inline MD_U32 md_center_1u32 (MD_Rng1U32 r) { MD_U32 c = (r.md_min + r.md_max) / 2; return c; }
|
||||||
inline MD_B32 md_contains_1u32 (MD_Rng1U32 r, MD_U32 x) { MD_B32 c = (r.md_min <= x && x < r.md_max); return c; }
|
inline MD_B32 md_contains_1u32 (MD_Rng1U32 r, MD_U32 x) { MD_B32 c = (r.md_min <= x && x < r.md_max); return c; }
|
||||||
inline MD_U32 md_dim_1u32 (MD_Rng1U32 r) { MD_U32 c = r.md_max - r.md_min; return c; }
|
inline MD_U32 md_dim_1u32 (MD_Rng1U32 r) { MD_U32 c = r.md_max - r.md_min; return c; }
|
||||||
inline MD_Rng1U32 md_union_1u32 (MD_Rng1U32 a, MD_Rng1U32 b) { MD_Rng1U32 c = {md_min(a.md_min, b.md_min), md_min(a.md_max, b.md_max)}; return c; }
|
inline MD_Rng1U32 md_union_1u32 (MD_Rng1U32 a, MD_Rng1U32 b) { MD_Rng1U32 c = {md_min(a.md_min, b.md_min), md_min(a.md_max, b.md_max)}; return c; }
|
||||||
inline MD_Rng1U32 md_intersect_1u32(MD_Rng1U32 a, MD_Rng1U32 b) { MD_Rng1U32 c = {md_max(a.md_min, b.md_min), md_min(a.md_max, b.md_max)}; return c; }
|
inline MD_Rng1U32 md_intersect_1u32(MD_Rng1U32 a, MD_Rng1U32 b) { MD_Rng1U32 c = {md_max(a.md_min, b.md_min), md_min(a.md_max, b.md_max)}; return c; }
|
||||||
inline MD_U32 md_clamp_1u32 (MD_Rng1U32 r, MD_U32 v) { v = md_clamp(r.md_min, v, r.md_max); return v; }
|
inline MD_U32 md_clamp_1u32 (MD_Rng1U32 r, MD_U32 v) { v = md_clamp(r.md_min, v, r.md_max); return v; }
|
||||||
|
|
||||||
#define md_r1s32(md_min, md_max) md_rng_1s32((md_min), (md_max))
|
#define md_r1s32(md_min, md_max) md_rng_1s32((md_min), (md_max))
|
||||||
inline MD_Rng1S32 md_rng_1s32 (MD_S32 md_min, MD_S32 md_max) { MD_Rng1S32 r = {md_min, md_max}; if(r.md_min > r.md_max) { md_swap(MD_S32, r.md_min, r.md_max); } return r; }
|
inline MD_Rng1S32 md_rng_1s32 (MD_S32 md_min, MD_S32 md_max) { MD_Rng1S32 r = {md_min, md_max}; if(r.md_min > r.md_max) { md_swap(MD_S32, r.md_min, r.md_max); } return r; }
|
||||||
inline MD_Rng1S32 md_shift_1s32 (MD_Rng1S32 r, MD_S32 x) { r.md_min += x; r.md_max += x; return r; }
|
inline MD_Rng1S32 md_shift_1s32 (MD_Rng1S32 r, MD_S32 x) { r.md_min += x; r.md_max += x; return r; }
|
||||||
inline MD_Rng1S32 md_pad_1s32 (MD_Rng1S32 r, MD_S32 x) { r.md_min -= x; r.md_max += x; return r; }
|
inline MD_Rng1S32 md_pad_1s32 (MD_Rng1S32 r, MD_S32 x) { r.md_min -= x; r.md_max += x; return r; }
|
||||||
inline MD_S32 md_center_1s32 (MD_Rng1S32 r) { MD_S32 c = (r.md_min+r.md_max) / 2; return c; }
|
inline MD_S32 md_center_1s32 (MD_Rng1S32 r) { MD_S32 c = (r.md_min+r.md_max) / 2; return c; }
|
||||||
inline MD_B32 md_contains_1s32 (MD_Rng1S32 r, MD_S32 x) { MD_B32 c = (r.md_min <= x && x < r.md_max); return c; }
|
inline MD_B32 md_contains_1s32 (MD_Rng1S32 r, MD_S32 x) { MD_B32 c = (r.md_min <= x && x < r.md_max); return c; }
|
||||||
inline MD_S32 md_dim_1s32 (MD_Rng1S32 r) { MD_S32 c = r.md_max-r.md_min; return c; }
|
inline MD_S32 md_dim_1s32 (MD_Rng1S32 r) { MD_S32 c = r.md_max-r.md_min; return c; }
|
||||||
inline MD_Rng1S32 md_union_1s32 (MD_Rng1S32 a, MD_Rng1S32 b) { MD_Rng1S32 c = {md_min(a.md_min, b.md_min), md_max(a.md_max, b.md_max)}; return c; }
|
inline MD_Rng1S32 md_union_1s32 (MD_Rng1S32 a, MD_Rng1S32 b) { MD_Rng1S32 c = {md_min(a.md_min, b.md_min), md_max(a.md_max, b.md_max)}; return c; }
|
||||||
inline MD_Rng1S32 md_intersect_1s32(MD_Rng1S32 a, MD_Rng1S32 b) { MD_Rng1S32 c = {md_max(a.md_min, b.md_min), md_min(a.md_max, b.md_max)}; return c; }
|
inline MD_Rng1S32 md_intersect_1s32(MD_Rng1S32 a, MD_Rng1S32 b) { MD_Rng1S32 c = {md_max(a.md_min, b.md_min), md_min(a.md_max, b.md_max)}; return c; }
|
||||||
inline MD_S32 md_clamp_1s32 (MD_Rng1S32 r, MD_S32 v) { v = md_clamp(r.md_min, v, r.md_max); return v; }
|
inline MD_S32 md_clamp_1s32 (MD_Rng1S32 r, MD_S32 v) { v = md_clamp(r.md_min, v, r.md_max); return v; }
|
||||||
|
|
||||||
#define md_r1u64(md_min, md_max) md_rng_1u64((md_min), (md_max))
|
#define md_r1u64(md_min, md_max) md_rng_1u64((md_min), (md_max))
|
||||||
inline MD_Rng1U64 md_rng_1u64 (MD_U64 md_min, MD_U64 md_max) { MD_Rng1U64 r = {md_min, md_max}; if(r.md_min > r.md_max) { md_swap(MD_U64, r.md_min, r.md_max); } return r; }
|
inline MD_Rng1U64 md_rng_1u64 (MD_U64 md_min, MD_U64 md_max) { MD_Rng1U64 r = {md_min, md_max}; if(r.md_min > r.md_max) { md_swap(MD_U64, r.md_min, r.md_max); } return r; }
|
||||||
inline MD_Rng1U64 md_shift_1u64 (MD_Rng1U64 r, MD_U64 x) { r.md_min += x; r.md_max += x; return r; }
|
inline MD_Rng1U64 md_shift_1u64 (MD_Rng1U64 r, MD_U64 x) { r.md_min += x; r.md_max += x; return r; }
|
||||||
inline MD_Rng1U64 md_pad_1u64 (MD_Rng1U64 r, MD_U64 x) { r.md_min -= x; r.md_max += x; return r; }
|
inline MD_Rng1U64 md_pad_1u64 (MD_Rng1U64 r, MD_U64 x) { r.md_min -= x; r.md_max += x; return r; }
|
||||||
inline MD_U64 md_center_1u64 (MD_Rng1U64 r) { MD_U64 c = (r.md_min + r.md_max)/2; return c; }
|
inline MD_U64 md_center_1u64 (MD_Rng1U64 r) { MD_U64 c = (r.md_min + r.md_max)/2; return c; }
|
||||||
inline MD_B32 md_contains_1u64 (MD_Rng1U64 r, MD_U64 x) { MD_B32 c = (r.md_min <= x && x < r.md_max); return c; }
|
inline MD_B32 md_contains_1u64 (MD_Rng1U64 r, MD_U64 x) { MD_B32 c = (r.md_min <= x && x < r.md_max); return c; }
|
||||||
inline MD_U64 md_dim_1u64 (MD_Rng1U64 r) { MD_U64 c = r.md_max-r.md_min; return c; }
|
inline MD_U64 md_dim_1u64 (MD_Rng1U64 r) { MD_U64 c = r.md_max-r.md_min; return c; }
|
||||||
inline MD_Rng1U64 md_union_1u64 (MD_Rng1U64 a, MD_Rng1U64 b) { MD_Rng1U64 c = {md_min(a.md_min, b.md_min), md_max(a.md_max, b.md_max)}; return c; }
|
inline MD_Rng1U64 md_union_1u64 (MD_Rng1U64 a, MD_Rng1U64 b) { MD_Rng1U64 c = {md_min(a.md_min, b.md_min), md_max(a.md_max, b.md_max)}; return c; }
|
||||||
inline MD_Rng1U64 md_intersect_1u64(MD_Rng1U64 a, MD_Rng1U64 b) { MD_Rng1U64 c = {md_max(a.md_min, b.md_min), md_min(a.md_max, b.md_max)}; return c; }
|
inline MD_Rng1U64 md_intersect_1u64(MD_Rng1U64 a, MD_Rng1U64 b) { MD_Rng1U64 c = {md_max(a.md_min, b.md_min), md_min(a.md_max, b.md_max)}; return c; }
|
||||||
inline MD_U64 md_clamp_1u64 (MD_Rng1U64 r, MD_U64 v) { v = md_clamp(r.md_min, v, r.md_max); return v; }
|
inline MD_U64 md_clamp_1u64 (MD_Rng1U64 r, MD_U64 v) { v = md_clamp(r.md_min, v, r.md_max); return v; }
|
||||||
|
|
||||||
#define md_r1s64(md_min, md_max) md_rng_1s64((md_min), (md_max))
|
#define md_r1s64(md_min, md_max) md_rng_1s64((md_min), (md_max))
|
||||||
inline Rng1S64 md_rng_1s64 (MD_S64 md_min, MD_S64 md_max) { Rng1S64 r = {md_min, md_max}; if(r.md_min > r.md_max) { md_swap(MD_S64, r.md_min, r.md_max); } return r; }
|
inline Rng1S64 md_rng_1s64 (MD_S64 md_min, MD_S64 md_max) { Rng1S64 r = {md_min, md_max}; if(r.md_min > r.md_max) { md_swap(MD_S64, r.md_min, r.md_max); } return r; }
|
||||||
inline Rng1S64 md_shift_1s64 (Rng1S64 r, MD_S64 x) { r.md_min += x; r.md_max += x; return r; }
|
inline Rng1S64 md_shift_1s64 (Rng1S64 r, MD_S64 x) { r.md_min += x; r.md_max += x; return r; }
|
||||||
inline Rng1S64 md_pad_1s64 (Rng1S64 r, MD_S64 x) { r.md_min -= x; r.md_max += x; return r; }
|
inline Rng1S64 md_pad_1s64 (Rng1S64 r, MD_S64 x) { r.md_min -= x; r.md_max += x; return r; }
|
||||||
inline MD_S64 md_center_1s64 (Rng1S64 r) { MD_S64 c = (r.md_min + r.md_max) / 2; return c; }
|
inline MD_S64 md_center_1s64 (Rng1S64 r) { MD_S64 c = (r.md_min + r.md_max) / 2; return c; }
|
||||||
inline MD_B32 md_contains_1s64 (Rng1S64 r, MD_S64 x) { MD_B32 c = (r.md_min <= x && x < r.md_max); return c; }
|
inline MD_B32 md_contains_1s64 (Rng1S64 r, MD_S64 x) { MD_B32 c = (r.md_min <= x && x < r.md_max); return c; }
|
||||||
inline MD_S64 md_dim_1s64 (Rng1S64 r) { MD_S64 c = r.md_max - r.md_min; return c; }
|
inline MD_S64 md_dim_1s64 (Rng1S64 r) { MD_S64 c = r.md_max - r.md_min; return c; }
|
||||||
inline Rng1S64 md_union_1s64 (Rng1S64 a, Rng1S64 b) { Rng1S64 c = {md_min(a.md_min, b.md_min), md_max(a.md_max, b.md_max)}; return c; }
|
inline Rng1S64 md_union_1s64 (Rng1S64 a, Rng1S64 b) { Rng1S64 c = {md_min(a.md_min, b.md_min), md_max(a.md_max, b.md_max)}; return c; }
|
||||||
inline Rng1S64 md_intersect_1s64(Rng1S64 a, Rng1S64 b) { Rng1S64 c = {md_max(a.md_min, b.md_min), md_min(a.md_max, b.md_max)}; return c; }
|
inline Rng1S64 md_intersect_1s64(Rng1S64 a, Rng1S64 b) { Rng1S64 c = {md_max(a.md_min, b.md_min), md_min(a.md_max, b.md_max)}; return c; }
|
||||||
inline MD_S64 md_clamp_1s64 (Rng1S64 r, MD_S64 v) { v = md_clamp(r.md_min, v, r.md_max); return v;}
|
inline MD_S64 md_clamp_1s64 (Rng1S64 r, MD_S64 v) { v = md_clamp(r.md_min, v, r.md_max); return v;}
|
||||||
|
|
||||||
#define md_r1f32(md_min, md_max) md_rng_1f32((md_min), (md_max))
|
#define md_r1f32(md_min, md_max) md_rng_1f32((md_min), (md_max))
|
||||||
inline Rng1F32 md_rng_1f32 (MD_F32 md_min, MD_F32 md_max) { Rng1F32 r = {md_min, md_max}; if(r.md_min > r.md_max) { md_swap(MD_F32, r.md_min, r.md_max); } return r; }
|
inline Rng1F32 md_rng_1f32 (MD_F32 md_min, MD_F32 md_max) { Rng1F32 r = {md_min, md_max}; if(r.md_min > r.md_max) { md_swap(MD_F32, r.md_min, r.md_max); } return r; }
|
||||||
inline Rng1F32 md_shift_1f32 (Rng1F32 r, MD_F32 x) { r.md_min += x; r.md_max += x; return r; }
|
inline Rng1F32 md_shift_1f32 (Rng1F32 r, MD_F32 x) { r.md_min += x; r.md_max += x; return r; }
|
||||||
inline Rng1F32 md_pad_1f32 (Rng1F32 r, MD_F32 x) { r.md_min -= x; r.md_max += x; return r; }
|
inline Rng1F32 md_pad_1f32 (Rng1F32 r, MD_F32 x) { r.md_min -= x; r.md_max += x; return r; }
|
||||||
inline MD_F32 md_center_1f32 (Rng1F32 r) { MD_F32 c = (r.md_min + r.md_max) / 2; return c; }
|
inline MD_F32 md_center_1f32 (Rng1F32 r) { MD_F32 c = (r.md_min + r.md_max) / 2; return c; }
|
||||||
inline MD_B32 md_contains_1f32 (Rng1F32 r, MD_F32 x) { MD_B32 c = (r.md_min <= x && x < r.md_max); return c; }
|
inline MD_B32 md_contains_1f32 (Rng1F32 r, MD_F32 x) { MD_B32 c = (r.md_min <= x && x < r.md_max); return c; }
|
||||||
inline MD_F32 md_dim_1f32 (Rng1F32 r) { MD_F32 c = r.md_max - r.md_min; return c; }
|
inline MD_F32 md_dim_1f32 (Rng1F32 r) { MD_F32 c = r.md_max - r.md_min; return c; }
|
||||||
inline Rng1F32 md_union_1f32 (Rng1F32 a, Rng1F32 b) { Rng1F32 c = {md_min(a.md_min, b.md_min), md_max(a.md_max, b.md_max)}; return c; }
|
inline Rng1F32 md_union_1f32 (Rng1F32 a, Rng1F32 b) { Rng1F32 c = {md_min(a.md_min, b.md_min), md_max(a.md_max, b.md_max)}; return c; }
|
||||||
inline Rng1F32 md_intersect_1f32(Rng1F32 a, Rng1F32 b) { Rng1F32 c = {md_max(a.md_min, b.md_min), md_min(a.md_max, b.md_max)}; return c; }
|
inline Rng1F32 md_intersect_1f32(Rng1F32 a, Rng1F32 b) { Rng1F32 c = {md_max(a.md_min, b.md_min), md_min(a.md_max, b.md_max)}; return c; }
|
||||||
inline MD_F32 md_clamp_1f32 (Rng1F32 r, MD_F32 v) { v = md_clamp(r.md_min, v, r.md_max); return v; }
|
inline MD_F32 md_clamp_1f32 (Rng1F32 r, MD_F32 v) { v = md_clamp(r.md_min, v, r.md_max); return v; }
|
||||||
|
|
||||||
// ==================== 2D Ranges ====================
|
// ==================== 2D Ranges ====================
|
||||||
|
|
||||||
#define md_r2s16(md_min, md_max) md_rng_2s16((md_min), (md_max))
|
#define md_r2s16(md_min, md_max) md_rng_2s16((md_min), (md_max))
|
||||||
#define md_r2s16p(x, y, z, w) md_r2s16(md_v2s16((x), (y)), md_v2s16((z), (w)))
|
#define md_r2s16p(x, y, z, w) md_r2s16(md_v2s16((x), (y)), md_v2s16((z), (w)))
|
||||||
inline MD_Rng2S16 md_rng_2s16 (MD_Vec2S16 md_min, MD_Vec2S16 md_max) { MD_Rng2S16 r = {md_min, md_max}; return r; }
|
inline MD_Rng2S16 md_rng_2s16 (MD_Vec2S16 md_min, MD_Vec2S16 md_max) { MD_Rng2S16 r = {md_min, md_max}; return r; }
|
||||||
inline MD_Rng2S16 md_shift_2s16 (MD_Rng2S16 r, MD_Vec2S16 x) { r.md_min = md_add_2s16(r.md_min, x); r.md_max = md_add_2s16(r.md_max, x); return r; }
|
inline MD_Rng2S16 md_shift_2s16 (MD_Rng2S16 r, MD_Vec2S16 x) { r.md_min = md_add_2s16(r.md_min, x); r.md_max = md_add_2s16(r.md_max, x); return r; }
|
||||||
inline MD_Rng2S16 md_pad_2s16 (MD_Rng2S16 r, MD_S16 x) { MD_Vec2S16 xv = {x, x}; r.md_min = md_sub_2s16(r.md_min, xv); r.md_max = md_add_2s16(r.md_max, xv); return r; }
|
inline MD_Rng2S16 md_pad_2s16 (MD_Rng2S16 r, MD_S16 x) { MD_Vec2S16 xv = {x, x}; r.md_min = md_sub_2s16(r.md_min, xv); r.md_max = md_add_2s16(r.md_max, xv); return r; }
|
||||||
inline MD_Vec2S16 md_center_2s16 (MD_Rng2S16 r) { MD_Vec2S16 c = {(MD_S16)((r.md_min.x + r.md_max.x) / 2), (MD_S16)((r.md_min.y + r.md_max.y) / 2)}; return c; }
|
inline MD_Vec2S16 md_center_2s16 (MD_Rng2S16 r) { MD_Vec2S16 c = {(MD_S16)((r.md_min.x + r.md_max.x) / 2), (MD_S16)((r.md_min.y + r.md_max.y) / 2)}; return c; }
|
||||||
inline MD_B32 md_contains_2s16 (MD_Rng2S16 r, MD_Vec2S16 x) { MD_B32 c = (r.md_min.x <= x.x && x.x < r.md_max.x && r.md_min.y <= x.y && x.y < r.md_max.y); return c; }
|
inline MD_B32 md_contains_2s16 (MD_Rng2S16 r, MD_Vec2S16 x) { MD_B32 c = (r.md_min.x <= x.x && x.x < r.md_max.x && r.md_min.y <= x.y && x.y < r.md_max.y); return c; }
|
||||||
inline MD_Vec2S16 md_dim_2s16 (MD_Rng2S16 r) { MD_Vec2S16 dim = {(MD_S16)(r.md_max.x - r.md_min.x), (MD_S16)(r.md_max.y - r.md_min.y)}; return dim; }
|
inline MD_Vec2S16 md_dim_2s16 (MD_Rng2S16 r) { MD_Vec2S16 dim = {(MD_S16)(r.md_max.x - r.md_min.x), (MD_S16)(r.md_max.y - r.md_min.y)}; return dim; }
|
||||||
inline MD_Rng2S16 md_union_2s16 (MD_Rng2S16 a, MD_Rng2S16 b) { MD_Rng2S16 c; c.p0.x = md_min(a.md_min.x, b.md_min.x); c.p0.y = md_min(a.md_min.y, b.md_min.y); c.p1.x = md_max(a.md_max.x, b.md_max.x); c.p1.y = md_max(a.md_max.y, b.md_max.y); return c; }
|
inline MD_Rng2S16 md_union_2s16 (MD_Rng2S16 a, MD_Rng2S16 b) { MD_Rng2S16 c; c.p0.x = md_min(a.md_min.x, b.md_min.x); c.p0.y = md_min(a.md_min.y, b.md_min.y); c.p1.x = md_max(a.md_max.x, b.md_max.x); c.p1.y = md_max(a.md_max.y, b.md_max.y); return c; }
|
||||||
inline MD_Rng2S16 md_intersect_2s16(MD_Rng2S16 a, MD_Rng2S16 b) { MD_Rng2S16 c; c.p0.x = md_max(a.md_min.x, b.md_min.x); c.p0.y = md_max(a.md_min.y, b.md_min.y); c.p1.x = md_min(a.md_max.x, b.md_max.x); c.p1.y = md_min(a.md_max.y, b.md_max.y); return c; }
|
inline MD_Rng2S16 md_intersect_2s16(MD_Rng2S16 a, MD_Rng2S16 b) { MD_Rng2S16 c; c.p0.x = md_max(a.md_min.x, b.md_min.x); c.p0.y = md_max(a.md_min.y, b.md_min.y); c.p1.x = md_min(a.md_max.x, b.md_max.x); c.p1.y = md_min(a.md_max.y, b.md_max.y); return c; }
|
||||||
inline MD_Vec2S16 md_clamp_2s16 (MD_Rng2S16 r, MD_Vec2S16 v) { v.x = md_clamp(r.md_min.x, v.x, r.md_max.x); v.y = md_clamp(r.md_min.y, v.y, r.md_max.y); return v; }
|
inline MD_Vec2S16 md_clamp_2s16 (MD_Rng2S16 r, MD_Vec2S16 v) { v.x = md_clamp(r.md_min.x, v.x, r.md_max.x); v.y = md_clamp(r.md_min.y, v.y, r.md_max.y); return v; }
|
||||||
|
|
||||||
#define md_r2s32(md_min, md_max) md_rng_2s32((md_min), (md_max))
|
#define md_r2s32(md_min, md_max) md_rng_2s32((md_min), (md_max))
|
||||||
#define md_r2s32p(x, y, z, w) md_r2s32(md_v2s32((x), (y)), md_v2s32((z), (w)))
|
#define md_r2s32p(x, y, z, w) md_r2s32(md_v2s32((x), (y)), md_v2s32((z), (w)))
|
||||||
inline MD_Rng2S32 md_rng_2s32 (MD_Vec2S32 md_min, MD_Vec2S32 md_max) { MD_Rng2S32 r = {md_min, md_max}; return r; }
|
inline MD_Rng2S32 md_rng_2s32 (MD_Vec2S32 md_min, MD_Vec2S32 md_max) { MD_Rng2S32 r = {md_min, md_max}; return r; }
|
||||||
inline MD_Rng2S32 md_shift_2s32 (MD_Rng2S32 r, MD_Vec2S32 x) { r.md_min = md_add_2s32(r.md_min, x); r.md_max = md_add_2s32(r.md_max, x); return r; }
|
inline MD_Rng2S32 md_shift_2s32 (MD_Rng2S32 r, MD_Vec2S32 x) { r.md_min = md_add_2s32(r.md_min, x); r.md_max = md_add_2s32(r.md_max, x); return r; }
|
||||||
inline MD_Rng2S32 md_pad_2s32 (MD_Rng2S32 r, MD_S32 x) { MD_Vec2S32 xv = {x, x}; r.md_min = md_sub_2s32(r.md_min, xv); r.md_max = md_add_2s32(r.md_max, xv); return r; }
|
inline MD_Rng2S32 md_pad_2s32 (MD_Rng2S32 r, MD_S32 x) { MD_Vec2S32 xv = {x, x}; r.md_min = md_sub_2s32(r.md_min, xv); r.md_max = md_add_2s32(r.md_max, xv); return r; }
|
||||||
inline MD_Vec2S32 md_center_2s32 (MD_Rng2S32 r) { MD_Vec2S32 c = {(r.md_min.x + r.md_max.x) / 2, (r.md_min.y + r.md_max.y) / 2}; return c; }
|
inline MD_Vec2S32 md_center_2s32 (MD_Rng2S32 r) { MD_Vec2S32 c = {(r.md_min.x + r.md_max.x) / 2, (r.md_min.y + r.md_max.y) / 2}; return c; }
|
||||||
inline MD_B32 md_contains_2s32 (MD_Rng2S32 r, MD_Vec2S32 x) { MD_B32 c = (r.md_min.x <= x.x && x.x < r.md_max.x && r.md_min.y <= x.y && x.y < r.md_max.y); return c; }
|
inline MD_B32 md_contains_2s32 (MD_Rng2S32 r, MD_Vec2S32 x) { MD_B32 c = (r.md_min.x <= x.x && x.x < r.md_max.x && r.md_min.y <= x.y && x.y < r.md_max.y); return c; }
|
||||||
inline MD_Vec2S32 md_dim_2s32 (MD_Rng2S32 r) { MD_Vec2S32 dim = {r.md_max.x - r.md_min.x, r.md_max.y - r.md_min.y}; return dim; }
|
inline MD_Vec2S32 md_dim_2s32 (MD_Rng2S32 r) { MD_Vec2S32 dim = {r.md_max.x - r.md_min.x, r.md_max.y - r.md_min.y}; return dim; }
|
||||||
inline MD_Rng2S32 md_union_2s32 (MD_Rng2S32 a, MD_Rng2S32 b) { MD_Rng2S32 c; c.p0.x = md_min(a.md_min.x, b.md_min.x); c.p0.y = md_min(a.md_min.y, b.md_min.y); c.p1.x = md_max(a.md_max.x, b.md_max.x); c.p1.y = md_max(a.md_max.y, b.md_max.y); return c; }
|
inline MD_Rng2S32 md_union_2s32 (MD_Rng2S32 a, MD_Rng2S32 b) { MD_Rng2S32 c; c.p0.x = md_min(a.md_min.x, b.md_min.x); c.p0.y = md_min(a.md_min.y, b.md_min.y); c.p1.x = md_max(a.md_max.x, b.md_max.x); c.p1.y = md_max(a.md_max.y, b.md_max.y); return c; }
|
||||||
inline MD_Rng2S32 md_intersect_2s32(MD_Rng2S32 a, MD_Rng2S32 b) { MD_Rng2S32 c; c.p0.x = md_max(a.md_min.x, b.md_min.x); c.p0.y = md_max(a.md_min.y, b.md_min.y); c.p1.x = md_min(a.md_max.x, b.md_max.x); c.p1.y = md_min(a.md_max.y, b.md_max.y); return c; }
|
inline MD_Rng2S32 md_intersect_2s32(MD_Rng2S32 a, MD_Rng2S32 b) { MD_Rng2S32 c; c.p0.x = md_max(a.md_min.x, b.md_min.x); c.p0.y = md_max(a.md_min.y, b.md_min.y); c.p1.x = md_min(a.md_max.x, b.md_max.x); c.p1.y = md_min(a.md_max.y, b.md_max.y); return c; }
|
||||||
inline MD_Vec2S32 md_clamp_2s32 (MD_Rng2S32 r, MD_Vec2S32 v) { v.x = md_clamp(r.md_min.x, v.x, r.md_max.x); v.y = md_clamp(r.md_min.y, v.y, r.md_max.y); return v; }
|
inline MD_Vec2S32 md_clamp_2s32 (MD_Rng2S32 r, MD_Vec2S32 v) { v.x = md_clamp(r.md_min.x, v.x, r.md_max.x); v.y = md_clamp(r.md_min.y, v.y, r.md_max.y); return v; }
|
||||||
|
|
||||||
#define md_r2s64(md_min, md_max) md_rng_2s64((md_min), (md_max))
|
#define md_r2s64(md_min, md_max) md_rng_2s64((md_min), (md_max))
|
||||||
#define md_r2s64p(x, y, z, w) md_r2s64(md_v2s64((x), (y)), md_v2s64((z), (w)))
|
#define md_r2s64p(x, y, z, w) md_r2s64(md_v2s64((x), (y)), md_v2s64((z), (w)))
|
||||||
inline MD_Rng2S64 md_rng_2s64 (MD_Vec2S64 md_min, MD_Vec2S64 md_max) { MD_Rng2S64 r = {md_min, md_max}; return r; }
|
inline MD_Rng2S64 md_rng_2s64 (MD_Vec2S64 md_min, MD_Vec2S64 md_max) { MD_Rng2S64 r = {md_min, md_max}; return r; }
|
||||||
inline MD_Rng2S64 md_shift_2s64 (MD_Rng2S64 r, MD_Vec2S64 x) { r.md_min = md_add_2s64(r.md_min, x); r.md_max = md_add_2s64(r.md_max, x); return r; }
|
inline MD_Rng2S64 md_shift_2s64 (MD_Rng2S64 r, MD_Vec2S64 x) { r.md_min = md_add_2s64(r.md_min, x); r.md_max = md_add_2s64(r.md_max, x); return r; }
|
||||||
inline MD_Rng2S64 md_pad_2s64 (MD_Rng2S64 r, MD_S64 x) { MD_Vec2S64 xv = {x, x}; r.md_min = md_sub_2s64(r.md_min, xv); r.md_max = md_add_2s64(r.md_max, xv); return r; }
|
inline MD_Rng2S64 md_pad_2s64 (MD_Rng2S64 r, MD_S64 x) { MD_Vec2S64 xv = {x, x}; r.md_min = md_sub_2s64(r.md_min, xv); r.md_max = md_add_2s64(r.md_max, xv); return r; }
|
||||||
inline MD_Vec2S64 md_center_2s64 (MD_Rng2S64 r) { MD_Vec2S64 c = {(r.md_min.x + r.md_max.x) / 2, (r.md_min.y + r.md_max.y) / 2}; return c; }
|
inline MD_Vec2S64 md_center_2s64 (MD_Rng2S64 r) { MD_Vec2S64 c = {(r.md_min.x + r.md_max.x) / 2, (r.md_min.y + r.md_max.y) / 2}; return c; }
|
||||||
inline MD_B32 md_contains_2s64 (MD_Rng2S64 r, MD_Vec2S64 x) { MD_B32 c = (r.md_min.x <= x.x && x.x < r.md_max.x && r.md_min.y <= x.y && x.y < r.md_max.y); return c; }
|
inline MD_B32 md_contains_2s64 (MD_Rng2S64 r, MD_Vec2S64 x) { MD_B32 c = (r.md_min.x <= x.x && x.x < r.md_max.x && r.md_min.y <= x.y && x.y < r.md_max.y); return c; }
|
||||||
inline MD_Vec2S64 md_dim_2s64 (MD_Rng2S64 r) { MD_Vec2S64 dim = {r.md_max.x - r.md_min.x, r.md_max.y - r.md_min.y}; return dim; }
|
inline MD_Vec2S64 md_dim_2s64 (MD_Rng2S64 r) { MD_Vec2S64 dim = {r.md_max.x - r.md_min.x, r.md_max.y - r.md_min.y}; return dim; }
|
||||||
inline MD_Rng2S64 md_union_2s64 (MD_Rng2S64 a, MD_Rng2S64 b) { MD_Rng2S64 c; c.p0.x = md_min(a.md_min.x, b.md_min.x); c.p0.y = md_min(a.md_min.y, b.md_min.y); c.p1.x = md_max(a.md_max.x, b.md_max.x); c.p1.y = md_max(a.md_max.y, b.md_max.y); return c; }
|
inline MD_Rng2S64 md_union_2s64 (MD_Rng2S64 a, MD_Rng2S64 b) { MD_Rng2S64 c; c.p0.x = md_min(a.md_min.x, b.md_min.x); c.p0.y = md_min(a.md_min.y, b.md_min.y); c.p1.x = md_max(a.md_max.x, b.md_max.x); c.p1.y = md_max(a.md_max.y, b.md_max.y); return c; }
|
||||||
inline MD_Rng2S64 md_intersect_2s64(MD_Rng2S64 a, MD_Rng2S64 b) { MD_Rng2S64 c; c.p0.x = md_max(a.md_min.x, b.md_min.x); c.p0.y = md_max(a.md_min.y, b.md_min.y); c.p1.x = md_min(a.md_max.x, b.md_max.x); c.p1.y = md_min(a.md_max.y, b.md_max.y); return c; }
|
inline MD_Rng2S64 md_intersect_2s64(MD_Rng2S64 a, MD_Rng2S64 b) { MD_Rng2S64 c; c.p0.x = md_max(a.md_min.x, b.md_min.x); c.p0.y = md_max(a.md_min.y, b.md_min.y); c.p1.x = md_min(a.md_max.x, b.md_max.x); c.p1.y = md_min(a.md_max.y, b.md_max.y); return c; }
|
||||||
inline MD_Vec2S64 md_clamp_2s64 (MD_Rng2S64 r, MD_Vec2S64 v) { v.x = md_clamp(r.md_min.x, v.x, r.md_max.x); v.y = md_clamp(r.md_min.y, v.y, r.md_max.y); return v; }
|
inline MD_Vec2S64 md_clamp_2s64 (MD_Rng2S64 r, MD_Vec2S64 v) { v.x = md_clamp(r.md_min.x, v.x, r.md_max.x); v.y = md_clamp(r.md_min.y, v.y, r.md_max.y); return v; }
|
||||||
|
|
||||||
////////////////////////////////
|
////////////////////////////////
|
||||||
//~ rjf: Miscellaneous Ops
|
//~ rjf: Miscellaneous Ops
|
||||||
@@ -967,15 +967,15 @@ md_u32_from_rgba(MD_Vec4F32 rgba)
|
|||||||
////////////////////////////////
|
////////////////////////////////
|
||||||
//~ rjf: List Type Functions
|
//~ rjf: List Type Functions
|
||||||
|
|
||||||
void md_rng1s64_list_push__arena (MD_Arena* arena, MD_Rng1S64List* list, Rng1S64 rng);
|
void md_rng1s64_list_push__arena (MD_Arena* arena, MD_Rng1S64List* list, Rng1S64 rng);
|
||||||
void md_rng1s64_list_push__ainfo (MD_AllocatorInfo ainfo, MD_Rng1S64List* list, Rng1S64 rng);
|
void md_rng1s64_list_push__ainfo (MD_AllocatorInfo ainfo, MD_Rng1S64List* list, Rng1S64 rng);
|
||||||
MD_Rng1S64Array md_rng1s64_array_from_list_push__arena(MD_Arena* arena, MD_Rng1S64List* list);
|
MD_Rng1S64Array md_rng1s64_array_from_list_push__arena(MD_Arena* arena, MD_Rng1S64List* list);
|
||||||
MD_Rng1S64Array md_rng1s64_array_from_list_push__ainfo(MD_AllocatorInfo ainfo, MD_Rng1S64List* list);
|
MD_Rng1S64Array md_rng1s64_array_from_list_push__ainfo(MD_AllocatorInfo ainfo, MD_Rng1S64List* list);
|
||||||
|
|
||||||
#define rng1s64_list_push(allocator, list, rng) _Generic(allocator, MD_Arena*: md_rng1s64_list_push__arena, MD_AllocatorInfo: md_rng1s64_list_push__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, list, rng)
|
#define rng1s64_list_push(allocator, list, rng) _Generic(allocator, MD_Arena*: md_rng1s64_list_push__arena, MD_AllocatorInfo: md_rng1s64_list_push__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, list, rng)
|
||||||
#define md_rng1s64_array_from_list_push(allocator, list) _Generic(allocator, MD_Arena*: md_rng1s64_array_from_list_push__arena, MD_AllocatorInfo: md_rng1s64_array_from_list_push__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, list)
|
#define md_rng1s64_array_from_list_push(allocator, list) _Generic(allocator, MD_Arena*: md_rng1s64_array_from_list_push__arena, MD_AllocatorInfo: md_rng1s64_array_from_list_push__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, list)
|
||||||
|
|
||||||
md_force_inline void md_rng1s64_list_push__arena (MD_Arena* arena, MD_Rng1S64List* list, Rng1S64 rng) { md_rng1s64_list_push__ainfo (md_arena_allocator(arena), list, rng); }
|
md_force_inline void md_rng1s64_list_push__arena (MD_Arena* arena, MD_Rng1S64List* list, Rng1S64 rng) { md_rng1s64_list_push__ainfo (md_arena_allocator(arena), list, rng); }
|
||||||
md_force_inline MD_Rng1S64Array md_rng1s64_array_from_list_push__arena(MD_Arena* arena, MD_Rng1S64List* list) { return md_rng1s64_array_from_list_push__ainfo(md_arena_allocator(arena), list); }
|
md_force_inline MD_Rng1S64Array md_rng1s64_array_from_list_push__arena(MD_Arena* arena, MD_Rng1S64List* list) { return md_rng1s64_array_from_list_push__ainfo(md_arena_allocator(arena), list); }
|
||||||
|
|
||||||
inline void
|
inline void
|
||||||
@@ -989,10 +989,10 @@ md_rng1s64_list_alloc(MD_AllocatorInfo ainfo, MD_Rng1S64List* list, Rng1S64 rng)
|
|||||||
inline MD_Rng1S64Array
|
inline MD_Rng1S64Array
|
||||||
md_rng1s64_array_from_list_alloc(MD_AllocatorInfo ainfo, MD_Rng1S64List* list) {
|
md_rng1s64_array_from_list_alloc(MD_AllocatorInfo ainfo, MD_Rng1S64List* list) {
|
||||||
MD_Rng1S64Array
|
MD_Rng1S64Array
|
||||||
arr = {0};
|
arr = {0};
|
||||||
arr.count = list->count;
|
arr.count = list->count;
|
||||||
arr.v = md_alloc_array_no_zero(ainfo, Rng1S64, arr.count);
|
arr.v = md_alloc_array_no_zero(ainfo, Rng1S64, arr.count);
|
||||||
MD_U64 idx = 0;
|
MD_U64 idx = 0;
|
||||||
for (MD_Rng1S64Node* n = list->first; n != 0; n = n->next) {
|
for (MD_Rng1S64Node* n = list->first; n != 0; n = n->next) {
|
||||||
arr.v[idx] = n->v;
|
arr.v[idx] = n->v;
|
||||||
idx += 1;
|
idx += 1;
|
||||||
|
|||||||
+74
-74
@@ -93,16 +93,16 @@
|
|||||||
__movsb((unsigned char*)dest, (const unsigned char*)src, count);
|
__movsb((unsigned char*)dest, (const unsigned char*)src, count);
|
||||||
return dest;
|
return dest;
|
||||||
}
|
}
|
||||||
# define md_memory_copy(dst, src, size) memcpy_intrinsic((dst), (src), (size))
|
# define md_memory_copy(dst, src, size) memcpy_intrinsic((dst), (src), (size))
|
||||||
# else
|
# else
|
||||||
# define md_memory_copy(dst, src, size) memmove((dst), (src), (size))
|
# define md_memory_copy(dst, src, size) memmove((dst), (src), (size))
|
||||||
# endif
|
# endif
|
||||||
#endif
|
#endif
|
||||||
#ifndef md_memory_set
|
#ifndef md_memory_set
|
||||||
# if USE_VENDOR_MEMORY_OPS
|
# if USE_VENDOR_MEMORY_OPS
|
||||||
# define md_memory_set(dst, byte, size) memset((dst), (byte), (size))
|
# define md_memory_set(dst, byte, size) memset((dst), (byte), (size))
|
||||||
# else
|
# else
|
||||||
# define md_memory_set(dst, byte, size) md_mem_set((dst), (byte), (size))
|
# define md_memory_set(dst, byte, size) md_mem_set((dst), (byte), (size))
|
||||||
# endif
|
# endif
|
||||||
#endif
|
#endif
|
||||||
#ifndef md_memory_compare
|
#ifndef md_memory_compare
|
||||||
@@ -431,25 +431,25 @@ md_dll__insert_npz(
|
|||||||
#define md_dll_insert_npz(nil, f, l, p, n, next, prev) md_dll__insert_npz(nil, &f, &f->prev, &l, &l->next, p, &p->next, &p->next->prev, n, &n->prev, &n->next)
|
#define md_dll_insert_npz(nil, f, l, p, n, next, prev) md_dll__insert_npz(nil, &f, &f->prev, &l, &l->next, p, &p->next, &p->next->prev, n, &n->prev, &n->next)
|
||||||
#else
|
#else
|
||||||
// insert next-previous with nil
|
// insert next-previous with nil
|
||||||
#define md_dll_insert_npz(nil, f, l, p, n, next, prev) \
|
#define md_dll_insert_npz(nil, f, l, p, n, next, prev) \
|
||||||
( \
|
( \
|
||||||
md_check_nil(nil, f) ? ( \
|
md_check_nil(nil, f) ? ( \
|
||||||
(f) = (l) = (n), \
|
(f) = (l) = (n), \
|
||||||
md_set_nil(nil, (n)->next), \
|
md_set_nil(nil, (n)->next), \
|
||||||
md_set_nil(nil, (n)->prev) \
|
md_set_nil(nil, (n)->prev) \
|
||||||
) \
|
) \
|
||||||
: ( \
|
: ( \
|
||||||
md_check_nil(nil, p) ? ( \
|
md_check_nil(nil, p) ? ( \
|
||||||
(n)->next = (f), \
|
(n)->next = (f), \
|
||||||
(f)->prev = (n), \
|
(f)->prev = (n), \
|
||||||
(f) = (n), \
|
(f) = (n), \
|
||||||
md_set_nil(nil,(n)->prev) \
|
md_set_nil(nil,(n)->prev) \
|
||||||
) \
|
) \
|
||||||
: ((p) == (l)) ? ( \
|
: ((p) == (l)) ? ( \
|
||||||
(l)->next = (n), \
|
(l)->next = (n), \
|
||||||
(n)->prev = (l), \
|
(n)->prev = (l), \
|
||||||
(l) = (n), \
|
(l) = (n), \
|
||||||
md_set_nil(nil, (n)->next) \
|
md_set_nil(nil, (n)->next) \
|
||||||
) \
|
) \
|
||||||
: ( \
|
: ( \
|
||||||
( \
|
( \
|
||||||
@@ -508,27 +508,27 @@ md_dll__remove_npz(
|
|||||||
#else
|
#else
|
||||||
// remove next-previous with nil
|
// remove next-previous with nil
|
||||||
#define md_dll_remove_npz(nil, f, l, n, next, prev) \
|
#define md_dll_remove_npz(nil, f, l, n, next, prev) \
|
||||||
( \
|
( \
|
||||||
( \
|
( \
|
||||||
(n) == (f) ? \
|
(n) == (f) ? \
|
||||||
(f) = (n)->next \
|
(f) = (n)->next \
|
||||||
: (0) \
|
: (0) \
|
||||||
), \
|
), \
|
||||||
( \
|
( \
|
||||||
(n) == (l) ? \
|
(n) == (l) ? \
|
||||||
(l) = (l)->prev \
|
(l) = (l)->prev \
|
||||||
: (0) \
|
: (0) \
|
||||||
), \
|
), \
|
||||||
( \
|
( \
|
||||||
md_check_nil(nil,(n)->prev) ? \
|
md_check_nil(nil,(n)->prev) ? \
|
||||||
(0) \
|
(0) \
|
||||||
: ((n)->prev->next = (n)->next) \
|
: ((n)->prev->next = (n)->next) \
|
||||||
), \
|
), \
|
||||||
( \
|
( \
|
||||||
md_check_nil(nil,(n)->next) ? \
|
md_check_nil(nil,(n)->next) ? \
|
||||||
(0) \
|
(0) \
|
||||||
: ((n)->next->prev = (n)->prev) \
|
: ((n)->next->prev = (n)->prev) \
|
||||||
) \
|
) \
|
||||||
)
|
)
|
||||||
// ! MD_LINKED_LIST_PURE_MACRO
|
// ! MD_LINKED_LIST_PURE_MACRO
|
||||||
#endif
|
#endif
|
||||||
@@ -563,16 +563,16 @@ md_sll__queue_push_nz(
|
|||||||
#define md_sll_queue_push_nz(nil, f, l, n, next) md_sll__queue_push_nz(nil, &f, &l, &l->next, n, &n->next)
|
#define md_sll_queue_push_nz(nil, f, l, n, next) md_sll__queue_push_nz(nil, &f, &l, &l->next, n, &n->next)
|
||||||
#else
|
#else
|
||||||
#define md_sll_queue_push_nz(nil, f, l, n, next) \
|
#define md_sll_queue_push_nz(nil, f, l, n, next) \
|
||||||
( \
|
( \
|
||||||
md_check_nil(nil, f) ? ( \
|
md_check_nil(nil, f) ? ( \
|
||||||
(f) = (l) = (n), \
|
(f) = (l) = (n), \
|
||||||
md_set_nil(nil, (n)->next) \
|
md_set_nil(nil, (n)->next) \
|
||||||
) \
|
) \
|
||||||
: ( \
|
: ( \
|
||||||
(l)->next=(n), \
|
(l)->next=(n), \
|
||||||
(l) = (n), \
|
(l) = (n), \
|
||||||
md_set_nil(nil,(n)->next) \
|
md_set_nil(nil,(n)->next) \
|
||||||
) \
|
) \
|
||||||
)
|
)
|
||||||
// ! MD_LINKED_LIST_PURE_MACRO
|
// ! MD_LINKED_LIST_PURE_MACRO
|
||||||
#endif
|
#endif
|
||||||
@@ -598,15 +598,15 @@ md_sll__queue_push_front_nz(void* nil, void** f, void** l, void* n, void** n_nex
|
|||||||
#define md_sll_queue_push_front_nz(nil, f, l, n, next) md_sll__queue_push_front_nz(nil, &f, &l, n, &n->next)
|
#define md_sll_queue_push_front_nz(nil, f, l, n, next) md_sll__queue_push_front_nz(nil, &f, &l, n, &n->next)
|
||||||
#else
|
#else
|
||||||
#define md_sll_queue_push_front_nz(nil, f, l, n, next) \
|
#define md_sll_queue_push_front_nz(nil, f, l, n, next) \
|
||||||
( \
|
( \
|
||||||
md_check_nil(nil, f) ? ( \
|
md_check_nil(nil, f) ? ( \
|
||||||
(f) = (l) = (n), \
|
(f) = (l) = (n), \
|
||||||
md_set_nil(nil,(n)->next) \
|
md_set_nil(nil,(n)->next) \
|
||||||
) \
|
) \
|
||||||
: ( \
|
: ( \
|
||||||
(n)->next = (f), \
|
(n)->next = (f), \
|
||||||
(f) = (n) \
|
(f) = (n) \
|
||||||
) \
|
) \
|
||||||
)
|
)
|
||||||
// ! MD_LINKED_LIST_PURE_MACRO
|
// ! MD_LINKED_LIST_PURE_MACRO
|
||||||
#endif
|
#endif
|
||||||
@@ -630,14 +630,14 @@ md_sll__queue_pop_nz(void* nil, void** f, void* f_next, void** l)
|
|||||||
#define md_sll_queue_pop_nz(nil, f, l, next) md_sll__queue_pop_nz(nil, &f, f->next, &l)
|
#define md_sll_queue_pop_nz(nil, f, l, next) md_sll__queue_pop_nz(nil, &f, f->next, &l)
|
||||||
#else
|
#else
|
||||||
#define md_sll_queue_pop_nz(nil, f, l, next) \
|
#define md_sll_queue_pop_nz(nil, f, l, next) \
|
||||||
( \
|
( \
|
||||||
(f) == (l) ? ( \
|
(f) == (l) ? ( \
|
||||||
md_set_nil(nil,f), \
|
md_set_nil(nil,f), \
|
||||||
md_set_nil(nil,l) \
|
md_set_nil(nil,l) \
|
||||||
) \
|
) \
|
||||||
: ( \
|
: ( \
|
||||||
(f)=(f)->next \
|
(f)=(f)->next \
|
||||||
) \
|
) \
|
||||||
)
|
)
|
||||||
// ! MD_LINKED_LIST_PURE_MACRO
|
// ! MD_LINKED_LIST_PURE_MACRO
|
||||||
#endif
|
#endif
|
||||||
@@ -777,7 +777,7 @@ md_sll__queue_pop_nz(void* nil, void** f, void* f_next, void** l)
|
|||||||
#endif
|
#endif
|
||||||
|
|
||||||
#ifndef md_compose_64bit
|
#ifndef md_compose_64bit
|
||||||
#define md_compose_64bit(a,b) ((((MD_U64)a) << 32) | ((MD_U64)b));
|
#define md_compose_64bit(a,b) ((((MD_U64)a) << 32) | ((MD_U64)b));
|
||||||
#endif
|
#endif
|
||||||
#ifndef md_align_pow2
|
#ifndef md_align_pow2
|
||||||
#define md_align_pow2(x,b) (((x) + (b) - 1) & ( ~((b) - 1)))
|
#define md_align_pow2(x,b) (((x) + (b) - 1) & ( ~((b) - 1)))
|
||||||
@@ -910,18 +910,18 @@ md_u64_up_to_pow2(MD_U64 x) {
|
|||||||
|
|
||||||
inline MD_S32
|
inline MD_S32
|
||||||
md_extend_sign32(MD_U32 x, MD_U32 size) {
|
md_extend_sign32(MD_U32 x, MD_U32 size) {
|
||||||
MD_U32 high_bit = size * 8;
|
MD_U32 high_bit = size * 8;
|
||||||
MD_U32 shift = 32 - high_bit;
|
MD_U32 shift = 32 - high_bit;
|
||||||
MD_S32 result = ((MD_S32)x << shift) >> shift;
|
MD_S32 result = ((MD_S32)x << shift) >> shift;
|
||||||
return result;
|
return result;
|
||||||
}
|
}
|
||||||
|
|
||||||
inline MD_S64
|
inline MD_S64
|
||||||
md_extend_sign64(MD_U64 x, MD_U64 size) {
|
md_extend_sign64(MD_U64 x, MD_U64 size) {
|
||||||
MD_U64 high_bit = size * 8;
|
MD_U64 high_bit = size * 8;
|
||||||
MD_U64 shift = 64 - high_bit;
|
MD_U64 shift = 64 - high_bit;
|
||||||
MD_S64 result = ((MD_S64)x << shift) >> shift;
|
MD_S64 result = ((MD_S64)x << shift) >> shift;
|
||||||
return result;
|
return result;
|
||||||
}
|
}
|
||||||
|
|
||||||
inline MD_F32 md_inf32 (void) { union { MD_U32 u; MD_F32 f; } x; x.u = MD_EXPONENT32; return(x.f); }
|
inline MD_F32 md_inf32 (void) { union { MD_U32 u; MD_F32 f; } x; x.u = MD_EXPONENT32; return(x.f); }
|
||||||
@@ -930,19 +930,19 @@ inline MD_F32 md_neg_inf32(void) { union { MD_U32 u; MD_F32 f; } x; x.u = MD_SIG
|
|||||||
inline MD_U16
|
inline MD_U16
|
||||||
md_bswap_u16(MD_U16 x)
|
md_bswap_u16(MD_U16 x)
|
||||||
{
|
{
|
||||||
MD_U16 result = (((x & 0xFF00) >> 8) |
|
MD_U16 result = (((x & 0xFF00) >> 8) |
|
||||||
((x & 0x00FF) << 8));
|
((x & 0x00FF) << 8));
|
||||||
return result;
|
return result;
|
||||||
}
|
}
|
||||||
|
|
||||||
inline MD_U32
|
inline MD_U32
|
||||||
md_bswap_u32(MD_U32 x)
|
md_bswap_u32(MD_U32 x)
|
||||||
{
|
{
|
||||||
MD_U32 result = (((x & 0xFF000000) >> 24) |
|
MD_U32 result = (((x & 0xFF000000) >> 24) |
|
||||||
((x & 0x00FF0000) >> 8) |
|
((x & 0x00FF0000) >> 8) |
|
||||||
((x & 0x0000FF00) << 8) |
|
((x & 0x0000FF00) << 8) |
|
||||||
((x & 0x000000FF) << 24));
|
((x & 0x000000FF) << 24));
|
||||||
return result;
|
return result;
|
||||||
}
|
}
|
||||||
|
|
||||||
inline MD_U64
|
inline MD_U64
|
||||||
@@ -950,13 +950,13 @@ md_bswap_u64(MD_U64 x)
|
|||||||
{
|
{
|
||||||
// TODO(nick): naive bswap, replace with something that is faster like an intrinsic
|
// TODO(nick): naive bswap, replace with something that is faster like an intrinsic
|
||||||
MD_U64 result = (((x & 0xFF00000000000000ULL) >> 56) |
|
MD_U64 result = (((x & 0xFF00000000000000ULL) >> 56) |
|
||||||
((x & 0x00FF000000000000ULL) >> 40) |
|
((x & 0x00FF000000000000ULL) >> 40) |
|
||||||
((x & 0x0000FF0000000000ULL) >> 24) |
|
((x & 0x0000FF0000000000ULL) >> 24) |
|
||||||
((x & 0x000000FF00000000ULL) >> 8) |
|
((x & 0x000000FF00000000ULL) >> 8) |
|
||||||
((x & 0x00000000FF000000ULL) << 8) |
|
((x & 0x00000000FF000000ULL) << 8) |
|
||||||
((x & 0x0000000000FF0000ULL) << 24) |
|
((x & 0x0000000000FF0000ULL) << 24) |
|
||||||
((x & 0x000000000000FF00ULL) << 40) |
|
((x & 0x000000000000FF00ULL) << 40) |
|
||||||
((x & 0x00000000000000FFULL) << 56));
|
((x & 0x00000000000000FFULL) << 56));
|
||||||
return result;
|
return result;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
@@ -138,7 +138,7 @@ md_heap_allocator_proc( void* allocator_data, MD_AllocatorMode mode, MD_SSIZE si
|
|||||||
case MD_AllocatorMode_Resize:
|
case MD_AllocatorMode_Resize:
|
||||||
{
|
{
|
||||||
MD_AllocatorInfo a = md_heap();
|
MD_AllocatorInfo a = md_heap();
|
||||||
ptr = md_default_resize_align( a, old_memory, old_size, size, alignment );
|
ptr = md_default_resize_align( a, old_memory, old_size, size, alignment );
|
||||||
}
|
}
|
||||||
break;
|
break;
|
||||||
|
|
||||||
@@ -267,7 +267,7 @@ md_varena__alloc(MD_VArenaParams params)
|
|||||||
MD_SPTR header_size = md_align_pow2(size_of(MD_VArena), MD_DEFAULT_MEMORY_ALIGNMENT);
|
MD_SPTR header_size = md_align_pow2(size_of(MD_VArena), MD_DEFAULT_MEMORY_ALIGNMENT);
|
||||||
md_asan_unpoison_memory_region(base, header_size);
|
md_asan_unpoison_memory_region(base, header_size);
|
||||||
|
|
||||||
MD_VArena* vm = md_rcast(MD_VArena*, base);
|
MD_VArena* vm = md_rcast(MD_VArena*, base);
|
||||||
vm->reserve_start = md_rcast(MD_SPTR, base) + header_size;
|
vm->reserve_start = md_rcast(MD_SPTR, base) + header_size;
|
||||||
vm->reserve = reserve_size;
|
vm->reserve = reserve_size;
|
||||||
vm->commit_size = params.commit_size;
|
vm->commit_size = params.commit_size;
|
||||||
@@ -321,7 +321,7 @@ md_varena_allocator_proc(void* allocator_data, MD_AllocatorMode mode, MD_SSIZE r
|
|||||||
}
|
}
|
||||||
if (next_commit_size) {
|
if (next_commit_size) {
|
||||||
void* next_commit_start = md_rcast(void*, md_rcast(MD_UPTR, vm) + vm->committed);
|
void* next_commit_start = md_rcast(void*, md_rcast(MD_UPTR, vm) + vm->committed);
|
||||||
MD_B32 commit_result = md_os_commit(next_commit_start, next_commit_size);
|
MD_B32 commit_result = md_os_commit(next_commit_start, next_commit_size);
|
||||||
if (commit_result == false) {
|
if (commit_result == false) {
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
@@ -373,7 +373,7 @@ md_varena_allocator_proc(void* allocator_data, MD_AllocatorMode mode, MD_SSIZE r
|
|||||||
MD_B32 needs_more_commited = commit_left < size_to_allocate;
|
MD_B32 needs_more_commited = commit_left < size_to_allocate;
|
||||||
if (needs_more_commited)
|
if (needs_more_commited)
|
||||||
{
|
{
|
||||||
MD_SPTR reserve_left = vm->reserve - vm->committed;
|
MD_SPTR reserve_left = vm->reserve - vm->committed;
|
||||||
MD_UPTR next_commit_size;
|
MD_UPTR next_commit_size;
|
||||||
if (vm->flags & MD_VArenaFlag_LargePages) {
|
if (vm->flags & MD_VArenaFlag_LargePages) {
|
||||||
next_commit_size = reserve_left > 0 ? vm->commit_size : md_scast(MD_UPTR, md_align_pow2( -reserve_left, md_os_get_system_info()->large_page_size));
|
next_commit_size = reserve_left > 0 ? vm->commit_size : md_scast(MD_UPTR, md_align_pow2( -reserve_left, md_os_get_system_info()->large_page_size));
|
||||||
@@ -430,7 +430,7 @@ farena_allocator_proc(void* allocator_data, MD_AllocatorMode mode, MD_SSIZE size
|
|||||||
}
|
}
|
||||||
|
|
||||||
allocated_mem = md_scast(void*, end);
|
allocated_mem = md_scast(void*, end);
|
||||||
arena->used += total_size;
|
arena->used += total_size;
|
||||||
}
|
}
|
||||||
break;
|
break;
|
||||||
|
|
||||||
@@ -462,8 +462,8 @@ farena_allocator_proc(void* allocator_data, MD_AllocatorMode mode, MD_SSIZE size
|
|||||||
MD_B32 requested_shrink = size >= old_size;
|
MD_B32 requested_shrink = size >= old_size;
|
||||||
if (requested_shrink) {
|
if (requested_shrink) {
|
||||||
|
|
||||||
arena->used -= size;
|
arena->used -= size;
|
||||||
allocated_mem = old_memory;
|
allocated_mem = old_memory;
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
@@ -102,14 +102,14 @@ void* md_resize_align( MD_AllocatorInfo a, void* ptr, MD_SSIZE old_size, MD_SSIZ
|
|||||||
// Allocate memory for an item.
|
// Allocate memory for an item.
|
||||||
#define md_alloc_item(allocator, Type) (Type*)md_memory_zero(md_alloc(allocator, size_of(Type)), size_of(Type))
|
#define md_alloc_item(allocator, Type) (Type*)md_memory_zero(md_alloc(allocator, size_of(Type)), size_of(Type))
|
||||||
// Allocate memory for an item.
|
// Allocate memory for an item.
|
||||||
#define md_alloc_item_no_zero( allocator, Type ) (Type*) md_alloc(allocator, size_of(Type))
|
#define md_alloc_item_no_zero( allocator, Type ) (Type*) md_alloc(allocator, size_of(Type))
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#ifndef md_alloc_array
|
#ifndef md_alloc_array
|
||||||
// Allocate memory for an array of items.
|
// Allocate memory for an array of items.
|
||||||
#define md_alloc_array( allocator_, Type, count ) (Type*)md_memory_zero(md_alloc( allocator_, size_of(Type) * (count) ), size_of(Type) * (count))
|
#define md_alloc_array( allocator_, Type, count ) (Type*)md_memory_zero(md_alloc( allocator_, size_of(Type) * (count) ), size_of(Type) * (count))
|
||||||
// Allocate memory for an array of items. (Don't zero initialize)
|
// Allocate memory for an array of items. (Don't zero initialize)
|
||||||
#define md_alloc_array_no_zero( allocator_, Type, count ) (Type*) md_alloc( allocator_, size_of(Type) * (count) )
|
#define md_alloc_array_no_zero( allocator_, Type, count ) (Type*) md_alloc( allocator_, size_of(Type) * (count) )
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
// Allocate/Resize memory using default options.
|
// Allocate/Resize memory using default options.
|
||||||
|
|||||||
+4
-4
@@ -19,12 +19,12 @@ inline MD_U64
|
|||||||
md_ring_write(MD_U8* md_ring_base, MD_U64 md_ring_size, MD_U64 md_ring_pos, void* src_data, MD_U64 src_data_size) {
|
md_ring_write(MD_U8* md_ring_base, MD_U64 md_ring_size, MD_U64 md_ring_pos, void* src_data, MD_U64 src_data_size) {
|
||||||
md_assert(src_data_size <= md_ring_size);
|
md_assert(src_data_size <= md_ring_size);
|
||||||
{
|
{
|
||||||
MD_U64 md_ring_off = md_ring_pos % md_ring_size;
|
MD_U64 md_ring_off = md_ring_pos % md_ring_size;
|
||||||
MD_U64 bytes_before_split = md_ring_size - md_ring_off;
|
MD_U64 bytes_before_split = md_ring_size - md_ring_off;
|
||||||
MD_U64 pre_split_bytes = md_min(bytes_before_split, src_data_size);
|
MD_U64 pre_split_bytes = md_min(bytes_before_split, src_data_size);
|
||||||
MD_U64 pst_split_bytes = src_data_size - pre_split_bytes;
|
MD_U64 pst_split_bytes = src_data_size - pre_split_bytes;
|
||||||
void* pre_split_data = src_data;
|
void* pre_split_data = src_data;
|
||||||
void* pst_split_data = ((MD_U8*)src_data + pre_split_bytes);
|
void* pst_split_data = ((MD_U8*)src_data + pre_split_bytes);
|
||||||
md_memory_copy(md_ring_base + md_ring_off, pre_split_data, pre_split_bytes);
|
md_memory_copy(md_ring_base + md_ring_off, pre_split_data, pre_split_bytes);
|
||||||
md_memory_copy(md_ring_base + 0, pst_split_data, pst_split_bytes);
|
md_memory_copy(md_ring_base + 0, pst_split_data, pst_split_bytes);
|
||||||
}
|
}
|
||||||
@@ -35,7 +35,7 @@ inline MD_U64
|
|||||||
md_ring_read(MD_U8* md_ring_base, MD_U64 md_ring_size, MD_U64 md_ring_pos, void* dst_data, MD_U64 read_size) {
|
md_ring_read(MD_U8* md_ring_base, MD_U64 md_ring_size, MD_U64 md_ring_pos, void* dst_data, MD_U64 read_size) {
|
||||||
md_assert(read_size <= md_ring_size);
|
md_assert(read_size <= md_ring_size);
|
||||||
{
|
{
|
||||||
MD_U64 md_ring_off = md_ring_pos % md_ring_size;
|
MD_U64 md_ring_off = md_ring_pos % md_ring_size;
|
||||||
MD_U64 bytes_before_split = md_ring_size-md_ring_off;
|
MD_U64 bytes_before_split = md_ring_size-md_ring_off;
|
||||||
MD_U64 pre_split_bytes = md_min(bytes_before_split, read_size);
|
MD_U64 pre_split_bytes = md_min(bytes_before_split, read_size);
|
||||||
MD_U64 pst_split_bytes = read_size - pre_split_bytes;
|
MD_U64 pst_split_bytes = read_size - pre_split_bytes;
|
||||||
|
|||||||
+1
-1
@@ -57,7 +57,7 @@ enum MD_Dir2
|
|||||||
MD_Dir2_COUNT
|
MD_Dir2_COUNT
|
||||||
};
|
};
|
||||||
|
|
||||||
#define md_axis2_from_dir2(d) (((d) & 1) ? MD_Axis2_Y : MD_Axis2_X)
|
#define md_axis2_from_dir2(d) (((d) & 1) ? MD_Axis2_Y : MD_Axis2_X)
|
||||||
#define md_side_from_dir2(d) (((d) < MD_Dir2_Right) ? MD_Side_Min : MD_Side_Max)
|
#define md_side_from_dir2(d) (((d) < MD_Dir2_Right) ? MD_Side_Min : MD_Side_Max)
|
||||||
|
|
||||||
////////////////////////////////
|
////////////////////////////////
|
||||||
|
|||||||
+14
-14
@@ -54,7 +54,7 @@ md_str8_find_needle(MD_String8 string, MD_U64 start_pos, MD_String8 needle, MD_S
|
|||||||
MD_U8* stop_p = string.str + stop_offset;
|
MD_U8* stop_p = string.str + stop_offset;
|
||||||
if (needle.size > 0)
|
if (needle.size > 0)
|
||||||
{
|
{
|
||||||
MD_U8* md_string_opl = string.str + string.size;
|
MD_U8* md_string_opl = string.str + string.size;
|
||||||
MD_String8 needle_tail = md_str8_skip(needle, 1);
|
MD_String8 needle_tail = md_str8_skip(needle, 1);
|
||||||
MD_StringMatchFlags adjusted_flags = flags | MD_StringMatchFlag_RightSideSloppy;
|
MD_StringMatchFlags adjusted_flags = flags | MD_StringMatchFlag_RightSideSloppy;
|
||||||
MD_U8 needle_first_char_adjusted = needle.str[0];
|
MD_U8 needle_first_char_adjusted = needle.str[0];
|
||||||
@@ -292,7 +292,7 @@ md_str8_from_u64__ainfo(MD_AllocatorInfo ainfo, MD_U64 u64, MD_U32 radix, MD_U8
|
|||||||
needed_digits += 1;
|
needed_digits += 1;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
needed_leading_0s = (min_digits > needed_digits) ? min_digits - needed_digits : 0;
|
needed_leading_0s = (min_digits > needed_digits) ? min_digits - needed_digits : 0;
|
||||||
MD_U64 needed_separators = 0;
|
MD_U64 needed_separators = 0;
|
||||||
if (digit_group_separator != 0)
|
if (digit_group_separator != 0)
|
||||||
{
|
{
|
||||||
@@ -407,10 +407,10 @@ md_f64_from_str8(MD_String8 string)
|
|||||||
|
|
||||||
void
|
void
|
||||||
md_str8_list_concat_in_place(MD_String8List* list, MD_String8List* to_push) {
|
md_str8_list_concat_in_place(MD_String8List* list, MD_String8List* to_push) {
|
||||||
if(to_push->md_node_count != 0)
|
if(to_push->node_count != 0)
|
||||||
{
|
{
|
||||||
if (list->last) {
|
if (list->last) {
|
||||||
list->md_node_count += to_push->md_node_count;
|
list->node_count += to_push->node_count;
|
||||||
list->total_size += to_push->total_size;
|
list->total_size += to_push->total_size;
|
||||||
list->last->next = to_push->first;
|
list->last->next = to_push->first;
|
||||||
list->last = to_push->last;
|
list->last = to_push->last;
|
||||||
@@ -441,7 +441,7 @@ md_str8_list_aligner__ainfo(MD_AllocatorInfo ainfo, MD_String8List* list, MD_U64
|
|||||||
md_assert(increase_size <= md_array_count(zeroes_buffer));
|
md_assert(increase_size <= md_array_count(zeroes_buffer));
|
||||||
|
|
||||||
md_sll_queue_push(list->first, list->last, node);
|
md_sll_queue_push(list->first, list->last, node);
|
||||||
list->md_node_count += 1;
|
list->node_count += 1;
|
||||||
list->total_size = new_size;
|
list->total_size = new_size;
|
||||||
node->string.str = (MD_U8*)zeroes_buffer;
|
node->string.str = (MD_U8*)zeroes_buffer;
|
||||||
node->string.size = increase_size;
|
node->string.size = increase_size;
|
||||||
@@ -506,8 +506,8 @@ md_str8_list_join__ainfo(MD_AllocatorInfo ainfo, MD_String8List* list, MD_String
|
|||||||
md_memory_copy_struct(&join, optional_params);
|
md_memory_copy_struct(&join, optional_params);
|
||||||
}
|
}
|
||||||
MD_U64 sep_count = 0;
|
MD_U64 sep_count = 0;
|
||||||
if (list->md_node_count > 0){
|
if (list->node_count > 0){
|
||||||
sep_count = list->md_node_count - 1;
|
sep_count = list->node_count - 1;
|
||||||
}
|
}
|
||||||
|
|
||||||
MD_String8 result;
|
MD_String8 result;
|
||||||
@@ -1079,7 +1079,7 @@ md_try_guid_from_string(MD_String8 string, MD_Guid* md_guid_out)
|
|||||||
MD_B32 is_parsed = 0;
|
MD_B32 is_parsed = 0;
|
||||||
|
|
||||||
MD_String8List list = md_str8_split_by_string_chars(scratch.arena, string, md_str8_lit("-"), MD_StringSplitFlag_KeepEmpties);
|
MD_String8List list = md_str8_split_by_string_chars(scratch.arena, string, md_str8_lit("-"), MD_StringSplitFlag_KeepEmpties);
|
||||||
if(list.md_node_count == 5)
|
if(list.node_count == 5)
|
||||||
{
|
{
|
||||||
MD_String8 data1_str = list.first->string;
|
MD_String8 data1_str = list.first->string;
|
||||||
MD_String8 data2_str = list.first->next->string;
|
MD_String8 data2_str = list.first->next->string;
|
||||||
@@ -1294,7 +1294,7 @@ md_wrapped_lines_from_string__ainfo(MD_AllocatorInfo ainfo, MD_String8 string, M
|
|||||||
MD_String8 substr = md_str8_substr(string, candidate_line_range);
|
MD_String8 substr = md_str8_substr(string, candidate_line_range);
|
||||||
MD_U64 width_this_line = max_width-wrapped_indent_level;
|
MD_U64 width_this_line = max_width-wrapped_indent_level;
|
||||||
|
|
||||||
if (list.md_node_count == 0) {
|
if (list.node_count == 0) {
|
||||||
width_this_line = first_line_max_width;
|
width_this_line = first_line_max_width;
|
||||||
}
|
}
|
||||||
if (substr.size > width_this_line)
|
if (substr.size > width_this_line)
|
||||||
@@ -1355,7 +1355,7 @@ md_fuzzy_match_find__ainfo(MD_AllocatorInfo ainfo, MD_String8 needle, MD_String8
|
|||||||
MD_String8List needles = md_str8_split(scratch.arena, needle, (MD_U8*)" ", 1, 0);
|
MD_String8List needles = md_str8_split(scratch.arena, needle, (MD_U8*)" ", 1, 0);
|
||||||
MD_FuzzyMatchRangeList
|
MD_FuzzyMatchRangeList
|
||||||
result = {0};
|
result = {0};
|
||||||
result.needle_part_count = needles.md_node_count;
|
result.needle_part_count = needles.node_count;
|
||||||
for(MD_String8Node* needle_n = needles.first; needle_n != 0; needle_n = needle_n->next)
|
for(MD_String8Node* needle_n = needles.first; needle_n != 0; needle_n = needle_n->next)
|
||||||
{
|
{
|
||||||
MD_U64 find_pos = 0;
|
MD_U64 find_pos = 0;
|
||||||
@@ -1511,10 +1511,10 @@ MD_U64
|
|||||||
md_str8_deserial_read_cstr(MD_String8 string, MD_U64 off, MD_String8* cstr_out) {
|
md_str8_deserial_read_cstr(MD_String8 string, MD_U64 off, MD_String8* cstr_out) {
|
||||||
MD_U64 cstr_size = 0;
|
MD_U64 cstr_size = 0;
|
||||||
if (off < string.size) {
|
if (off < string.size) {
|
||||||
MD_U8* ptr = string.str + off;
|
MD_U8* ptr = string.str + off;
|
||||||
MD_U8* cap = string.str + string.size;
|
MD_U8* cap = string.str + string.size;
|
||||||
*cstr_out = md_str8_cstring_capped(ptr, cap);
|
*cstr_out = md_str8_cstring_capped(ptr, cap);
|
||||||
cstr_size = (cstr_out->size + 1);
|
cstr_size = (cstr_out->size + 1);
|
||||||
}
|
}
|
||||||
return cstr_size;
|
return cstr_size;
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -66,7 +66,7 @@ struct MD_String8List
|
|||||||
{
|
{
|
||||||
MD_String8Node* first;
|
MD_String8Node* first;
|
||||||
MD_String8Node* last;
|
MD_String8Node* last;
|
||||||
MD_U64 md_node_count;
|
MD_U64 node_count;
|
||||||
MD_U64 total_size;
|
MD_U64 total_size;
|
||||||
};
|
};
|
||||||
|
|
||||||
|
|||||||
Reference in New Issue
Block a user