sleepy-day/Gears-C
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add codegen for asset structures for asset rework, wip rework

Browse Source
This commit is contained in:
Matthew 2025-05-25 20:44:36 +10:00
parent 31d4066acf
commit 2054fad364
23 changed files with 1348 additions and 747 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
build.sh
View File

@ -112,6 +112,9 @@ if ! [ -f libvma.a ]; then
rm vma.o rm vma.o
fi fi
# Packer Codegen
$compile $packer_source_files $compile_link $link_os_gfx $packer_flags -DBUILD_ASSET_CODEGEN $packer_include_flags $out PackerCodegen
# Packer # Packer
if [ -v packer ] || ! [ -f Packer ]; then if [ -v packer ] || ! [ -f Packer ]; then
$compile $packer_source_files $compile_link $link_os_gfx $packer_flags $packer_include_flags $out $packer_out_name $compile $packer_source_files $compile_link $link_os_gfx $packer_flags $packer_include_flags $out $packer_out_name
@ -121,5 +124,6 @@ if [ -v pack ] || ! [ -f assets.sgp ]; then
./Packer ./Packer
fi fi
$compile $source_files $compile_link $link_os_gfx $out $out_name if ! [ -v packer ]; then
$compile $source_files $compile_link $link_os_gfx $out $out_name
fi

132
src/allocators.c
View File

@ -1,16 +1,23 @@
// ::Allocator::Globals:: // ::Allocator::Globals::
FLAlloc FL_ALLOC = {0}; FLAlloc
Allocator ALLOC = {0}; FL_ALLOC = {0};
read_only FLNode FL_NIL_NODE = {0}; Allocator
read_only FreeList FL_NIL_LIST = {0}; ALLOC = {0};
read_only FLNode
FL_NIL_NODE = {0};
read_only FreeList
FL_NIL_LIST = {0};
constexpr usize FL_GLOBAL_SIZE = MB(32); constexpr usize
static b32 FL_GLOBAL_INIT = false; FL_GLOBAL_SIZE = MB(32);
static b32
FL_GLOBAL_INIT = false;
// ::Allocator::Util::Header:: // ::Allocator::Util::Header::
static inline usize CalcPaddingWithHeader(uintptr ptr, uintptr alignment, usize header_size) static inline usize
CalcPaddingWithHeader(uintptr ptr, uintptr alignment, usize header_size)
{ {
Assert(IsPow2(alignment), "Alignment provided to CalcPaddingWithHeader is not a power of two"); Assert(IsPow2(alignment), "Alignment provided to CalcPaddingWithHeader is not a power of two");
@ -30,7 +37,8 @@ static inline usize CalcPaddingWithHeader(uintptr ptr, uintptr alignment, usize
return (usize)padding; return (usize)padding;
} }
static inline usize CalcPadding(uintptr ptr, uintptr alignment) static inline usize
CalcPadding(uintptr ptr, uintptr alignment)
{ {
Assert(IsPow2(alignment), "CalcPadding failure: IsPow2 failed"); Assert(IsPow2(alignment), "CalcPadding failure: IsPow2 failed");
@ -44,7 +52,8 @@ static inline usize CalcPadding(uintptr ptr, uintptr alignment)
// ::Allocator::Arena::Start:: // ::Allocator::Arena::Start::
static Arena *ArenaInit(rawptr buffer, usize size) static Arena *
ArenaInit(rawptr buffer, usize size)
{ {
Arena *arena = (Arena *)buffer; Arena *arena = (Arena *)buffer;
buffer = PtrAdd(buffer, ARENA_HEADER_SIZE); buffer = PtrAdd(buffer, ARENA_HEADER_SIZE);
@ -56,20 +65,23 @@ static Arena *ArenaInit(rawptr buffer, usize size)
return arena; return arena;
} }
static Arena *ArenaCreate(usize size) static Arena *
ArenaCreate(usize size)
{ {
u8 *mem = pMemAllocZeroed(size); u8 *mem = pMemAllocZeroed(size);
return ArenaInit(mem, size); return ArenaInit(mem, size);
} }
static Arena *ArenaCreateDebug(usize size, u32 init_line_no) static Arena *
ArenaCreateDebug(usize size, u32 init_line_no)
{ {
u8 *mem = pMemAllocZeroed(size); u8 *mem = pMemAllocZeroed(size);
return ArenaInitDebug(mem, size, init_line_no); return ArenaInitDebug(mem, size, init_line_no);
} }
// TODO: investigate overflows when out of memory because something bad is going on // TODO: investigate overflows when out of memory because something bad is going on
static rawptr ArenaAllocAlign(Arena *arena, usize size, usize align) static rawptr
ArenaAllocAlign(Arena *arena, usize size, usize align)
{ {
rawptr ptr = NULL; rawptr ptr = NULL;
@ -91,28 +103,33 @@ static rawptr ArenaAllocAlign(Arena *arena, usize size, usize align)
return ptr; return ptr;
} }
static rawptr ArenaAlloc(Arena *arena, usize size) static rawptr
ArenaAlloc(Arena *arena, usize size)
{ {
return ArenaAllocAlign(arena, size, DEFAULT_ALIGNMENT); return ArenaAllocAlign(arena, size, DEFAULT_ALIGNMENT);
} }
static void ArenaFree(Arena *arena) static void
ArenaFree(Arena *arena)
{ {
arena->pos = 0; arena->pos = 0;
} }
static void ArenaFreeZeroed(Arena *arena) static void
ArenaFreeZeroed(Arena *arena)
{ {
MemZero(arena->buffer, arena->pos); MemZero(arena->buffer, arena->pos);
ArenaFree(arena); ArenaFree(arena);
} }
static void DeallocArena(Arena *arena) static void
DeallocArena(Arena *arena)
{ {
pMemFree(arena, arena->length); pMemFree(arena, arena->length);
} }
static Arena * ArenaInitDebug(rawptr buffer, usize size, u32 init_line_no) static Arena *
ArenaInitDebug(rawptr buffer, usize size, u32 init_line_no)
{ {
Arena *arena = ArenaInit(buffer, size); Arena *arena = ArenaInit(buffer, size);
arena->init_line_no = init_line_no; arena->init_line_no = init_line_no;
@ -125,7 +142,8 @@ static Arena * ArenaInitDebug(rawptr buffer, usize size, u32 init_line_no)
// ::Allocator::GlobalAlloc::Start:: // ::Allocator::GlobalAlloc::Start::
static void InitAllocator(usize init_size) static void
InitAllocator(usize init_size)
{ {
ALLOC.grow_size = init_size; ALLOC.grow_size = init_size;
ALLOC.buffer = pMemAllocZeroed(init_size); ALLOC.buffer = pMemAllocZeroed(init_size);
@ -141,17 +159,20 @@ static void InitAllocator(usize init_size)
RBTreeInsert(ALLOC.tree, init_size, ALLOC.buffer); RBTreeInsert(ALLOC.tree, init_size, ALLOC.buffer);
} }
static void DeinitAlloc() static void
DeinitAlloc()
{ {
pMemFree(ALLOC.buffer, ALLOC.size); pMemFree(ALLOC.buffer, ALLOC.size);
} }
static rawptr Alloc(usize size) static rawptr
Alloc(usize size)
{ {
return AllocAlign(size, DEFAULT_ALIGNMENT); return AllocAlign(size, DEFAULT_ALIGNMENT);
} }
static rawptr AllocAlign(usize size, usize alignment) static rawptr
AllocAlign(usize size, usize alignment)
{ {
if (size == 0) return NULL; if (size == 0) return NULL;
@ -178,14 +199,16 @@ static rawptr AllocAlign(usize size, usize alignment)
// TODO: finish allocator // TODO: finish allocator
// need an idea // need an idea
static void Free(rawptr ptr) static void
Free(rawptr ptr)
{ {
if (ptr == NULL) return; if (ptr == NULL) return;
} }
static void AllocGrow(usize size) static void
AllocGrow(usize size)
{ {
usize grow_size = size < ALLOC.grow_size ? ALLOC.grow_size : ALLOC.grow_size + size; usize grow_size = size < ALLOC.grow_size ? ALLOC.grow_size : ALLOC.grow_size + size;
pMemRealloc(ALLOC.buffer, ALLOC.size, ALLOC.size + grow_size); pMemRealloc(ALLOC.buffer, ALLOC.size, ALLOC.size + grow_size);
@ -202,13 +225,15 @@ static void AllocGrow(usize size)
// ::Allocator::FreeList::Start:: // ::Allocator::FreeList::Start::
static void GlobalFreeListInit(usize size) static void
GlobalFreeListInit(usize size)
{ {
FreeListInit(&FL_ALLOC, size); FreeListInit(&FL_ALLOC, size);
FL_GLOBAL_INIT = true; FL_GLOBAL_INIT = true;
} }
static rawptr FLMemAlloc(usize size) static rawptr
FLMemAlloc(usize size)
{ {
if (!FL_GLOBAL_INIT) if (!FL_GLOBAL_INIT)
{ {
@ -218,14 +243,16 @@ static rawptr FLMemAlloc(usize size)
return FreeListAlloc(&FL_ALLOC, size); return FreeListAlloc(&FL_ALLOC, size);
} }
static rawptr FLMemAllocZeroed(usize size) static rawptr
FLMemAllocZeroed(usize size)
{ {
rawptr ptr = FLMemAlloc(size); rawptr ptr = FLMemAlloc(size);
MemZero(ptr, size); MemZero(ptr, size);
return ptr; return ptr;
} }
static rawptr FLMemRealloc(rawptr old_ptr, usize size) static rawptr
FLMemRealloc(rawptr old_ptr, usize size)
{ {
if (!FL_GLOBAL_INIT) if (!FL_GLOBAL_INIT)
{ {
@ -241,7 +268,8 @@ static rawptr FLMemRealloc(rawptr old_ptr, usize size)
return ptr; return ptr;
} }
static void FLMemFree(rawptr ptr) static void
FLMemFree(rawptr ptr)
{ {
if (!FL_GLOBAL_INIT) if (!FL_GLOBAL_INIT)
{ {
@ -254,7 +282,8 @@ static void FLMemFree(rawptr ptr)
/* /*
* Should be async safe given no other thread frees a pointer in the middle of a realloc * Should be async safe given no other thread frees a pointer in the middle of a realloc
*/ */
static rawptr FreeListRealloc(FLAlloc *alloc, rawptr old_ptr, usize size) static rawptr
FreeListRealloc(FLAlloc *alloc, rawptr old_ptr, usize size)
{ {
rawptr ptr = FreeListAlloc(alloc, size); rawptr ptr = FreeListAlloc(alloc, size);
usize old_size = FreeListPtrSize(alloc, old_ptr); usize old_size = FreeListPtrSize(alloc, old_ptr);
@ -266,7 +295,8 @@ static rawptr FreeListRealloc(FLAlloc *alloc, rawptr old_ptr, usize size)
return ptr; return ptr;
} }
static usize FreeListPtrSize(FLAlloc *alloc, rawptr ptr) static usize
FreeListPtrSize(FLAlloc *alloc, rawptr ptr)
{ {
if (ptr == NULL) return 0; if (ptr == NULL) return 0;
@ -286,7 +316,8 @@ static usize FreeListPtrSize(FLAlloc *alloc, rawptr ptr)
return size; return size;
} }
static void FreeListInit(FLAlloc *alloc, usize size) static void
FreeListInit(FLAlloc *alloc, usize size)
{ {
alloc->list_head = pMemAllocZeroed(sizeof(FreeList)); alloc->list_head = pMemAllocZeroed(sizeof(FreeList));
alloc->nil = &FL_NIL_NODE; alloc->nil = &FL_NIL_NODE;
@ -297,7 +328,8 @@ static void FreeListInit(FLAlloc *alloc, usize size)
FreeListFreeAll(alloc); FreeListFreeAll(alloc);
} }
static void _FreeListInit(FreeList **alloc, usize size) static void
_FreeListInit(FreeList **alloc, usize size)
{ {
*alloc = (FreeList *)pMemAllocZeroed(size); *alloc = (FreeList *)pMemAllocZeroed(size);
(*alloc)->data = (rawptr)(((uintptr)*alloc) + ((uintptr)sizeof(FreeList))); (*alloc)->data = (rawptr)(((uintptr)*alloc) + ((uintptr)sizeof(FreeList)));
@ -306,7 +338,8 @@ static void _FreeListInit(FreeList **alloc, usize size)
(*alloc)->next = &FL_NIL_LIST; (*alloc)->next = &FL_NIL_LIST;
} }
static void FreeListFreeAll(FLAlloc *alloc) static void
FreeListFreeAll(FLAlloc *alloc)
{ {
TicketMutLock(&alloc->mut); TicketMutLock(&alloc->mut);
@ -331,7 +364,8 @@ static void FreeListFreeAll(FLAlloc *alloc)
TicketMutUnlock(&alloc->mut); TicketMutUnlock(&alloc->mut);
} }
static FLNode *FreeListSearch(FreeList *alloc, usize size, usize alignment, usize *out_padding, FLNode **prev_node) static FLNode *
FreeListSearch(FreeList *alloc, usize size, usize alignment, usize *out_padding, FLNode **prev_node)
{ {
FLNode *node = alloc->head; FLNode *node = alloc->head;
FLNode *prev = &FL_NIL_NODE; FLNode *prev = &FL_NIL_NODE;
@ -361,7 +395,8 @@ static FLNode *FreeListSearch(FreeList *alloc, usize size, usize alignment, usiz
/* /*
* NOT SAFE TO CALL OUTSIDE OF FreeListAlloc * NOT SAFE TO CALL OUTSIDE OF FreeListAlloc
*/ */
static FreeList *FreeListGrow(FLAlloc *alloc, usize alloc_size) static FreeList *
FreeListGrow(FLAlloc *alloc, usize alloc_size)
{ {
usize grow_size = alloc->grow_size; usize grow_size = alloc->grow_size;
if (alloc_size > grow_size) if (alloc_size > grow_size)
@ -392,7 +427,8 @@ static FreeList *FreeListGrow(FLAlloc *alloc, usize alloc_size)
return list; return list;
} }
static rawptr _FreeListAllocAlign(FreeList *alloc, usize size, usize alignment) static rawptr
_FreeListAllocAlign(FreeList *alloc, usize size, usize alignment)
{ {
if (size == 0) return NULL; if (size == 0) return NULL;
@ -434,12 +470,14 @@ static rawptr _FreeListAllocAlign(FreeList *alloc, usize size, usize alignment)
return (rawptr)(((c8 *)header) + sizeof(FLAllocHeader)); return (rawptr)(((c8 *)header) + sizeof(FLAllocHeader));
} }
static rawptr FreeListAlloc(FLAlloc *alloc, usize size) static rawptr
FreeListAlloc(FLAlloc *alloc, usize size)
{ {
return FreeListAllocAlign(alloc, size, DEFAULT_ALIGNMENT); return FreeListAllocAlign(alloc, size, DEFAULT_ALIGNMENT);
} }
static rawptr FreeListAllocAlign(FLAlloc *alloc, usize size, usize alignment) static rawptr
FreeListAllocAlign(FLAlloc *alloc, usize size, usize alignment)
{ {
TicketMutLock(&alloc->mut); TicketMutLock(&alloc->mut);
@ -469,7 +507,8 @@ static rawptr FreeListAllocAlign(FLAlloc *alloc, usize size, usize alignment)
return ptr; return ptr;
} }
static FreeList *_FreeListFindList(FLAlloc *alloc, rawptr ptr) static FreeList *
_FreeListFindList(FLAlloc *alloc, rawptr ptr)
{ {
FreeList *list = NULL; FreeList *list = NULL;
FreeList *current = alloc->list_head; FreeList *current = alloc->list_head;
@ -488,7 +527,8 @@ static FreeList *_FreeListFindList(FLAlloc *alloc, rawptr ptr)
return list; return list;
} }
static void _FreeListFree(FreeList *alloc, rawptr ptr) static void
_FreeListFree(FreeList *alloc, rawptr ptr)
{ {
FLAllocHeader *header = cast(FLAllocHeader *, u8ptr(ptr) - sizeof(FLAllocHeader)); FLAllocHeader *header = cast(FLAllocHeader *, u8ptr(ptr) - sizeof(FLAllocHeader));
FLNode *free_node = cast(FLNode *,header); FLNode *free_node = cast(FLNode *,header);
@ -514,7 +554,8 @@ static void _FreeListFree(FreeList *alloc, rawptr ptr)
FreeListCoalescence(alloc, prev_node, free_node); FreeListCoalescence(alloc, prev_node, free_node);
} }
static void FreeListFree(FLAlloc *alloc, rawptr ptr) static void
FreeListFree(FLAlloc *alloc, rawptr ptr)
{ {
if (ptr == NULL) return; if (ptr == NULL) return;
@ -529,7 +570,8 @@ static void FreeListFree(FLAlloc *alloc, rawptr ptr)
TicketMutUnlock(&alloc->mut); TicketMutUnlock(&alloc->mut);
} }
static void FreeListCoalescence(FreeList *alloc, FLNode *prev_node, FLNode *free_node) static void
FreeListCoalescence(FreeList *alloc, FLNode *prev_node, FLNode *free_node)
{ {
if (free_node->next != &FL_NIL_NODE && (rawptr)(((c8 *)free_node) + free_node->size) == free_node->next) if (free_node->next != &FL_NIL_NODE && (rawptr)(((c8 *)free_node) + free_node->size) == free_node->next)
{ {
@ -544,7 +586,8 @@ static void FreeListCoalescence(FreeList *alloc, FLNode *prev_node, FLNode *free
} }
} }
static void FreeListRemove(FLNode **head, FLNode *prev_node, FLNode *del_node) static void
FreeListRemove(FLNode **head, FLNode *prev_node, FLNode *del_node)
{ {
if (prev_node == &FL_NIL_NODE) if (prev_node == &FL_NIL_NODE)
*head = del_node->next; *head = del_node->next;
@ -552,7 +595,8 @@ static void FreeListRemove(FLNode **head, FLNode *prev_node, FLNode *del_node)
prev_node->next = del_node->next; prev_node->next = del_node->next;
} }
static void FreeListInsert(FLNode **head, FLNode *prev_node, FLNode *new_node) static void
FreeListInsert(FLNode **head, FLNode *prev_node, FLNode *new_node)
{ {
if (prev_node == &FL_NIL_NODE) if (prev_node == &FL_NIL_NODE)
{ {

43
src/assets.c
View File

@ -80,6 +80,41 @@ static void apInit()
// ::Assets::Loading::Functions::Start:: // ::Assets::Loading::Functions::Start::
static Asset
apLoad(c8 *str)
{
Asset asset = {0};
return asset;
}
static Asset
apLoadS8(String8 str)
{
return apLoad(str.value);
}
static void
apUnload(c8 *str)
{
Asset asset = {0};
return asset;
}
static void
apUnloadS8(String8 str)
{
apUnload(str.value);
}
static u64
apAssetIndex(c8 *str)
{
return 0;
}
/*
static Asset apLoadTexture(TextureAsset asset_id) static Asset apLoadTexture(TextureAsset asset_id)
{ {
if (!ASSET_HEADER_LOADED) if (!ASSET_HEADER_LOADED)
@ -163,10 +198,8 @@ static TexMeta apGetTextureMeta(TextureAsset asset_id)
static ModelMeta apGetModelMeta(ModelAsset asset_id) static ModelMeta apGetModelMeta(ModelAsset asset_id)
{ {
/* //AssetFile *asset_file = Model_Assets + asset_id;
AssetFile *asset_file = Model_Assets + asset_id; //return asset_file->model_meta;
return asset_file->model_meta;
*/
ModelMeta meta = {0}; ModelMeta meta = {0};
Asset asset = Model_Asset_Lookup[asset_id]; Asset asset = Model_Asset_Lookup[asset_id];
@ -211,6 +244,8 @@ static void apUnloadModel(ModelAsset asset_id)
} }
} }
*/
// ::Assets::Loading::Functions::End:: // ::Assets::Loading::Functions::End::

89
src/assets.h
View File

@ -6,70 +6,13 @@
#define CreateMagicValue(a, b, c, d) ((u32)(d << 24) | (u32)(c << 16) | (u32)(b << 8) | (u32)(a)) #define CreateMagicValue(a, b, c, d) ((u32)(d << 24) | (u32)(c << 16) | (u32)(b << 8) | (u32)(a))
// ::Assets::Globals::Header::
#ifndef BUILD_ASSET_CODEGEN
# include "codegen_assets.h"
#endif
// ::Assets::Types::Header:: // ::Assets::Types::Header::
typedef enum AssetType_e : u32
{
SHADER_ASSET,
TEXTURE_ASSET,
SOUND_ASSET,
MODEL_ASSET,
ASSET_TYPE_MAX,
} AssetType;
typedef enum ShaderAsset_e : u32
{
QUAD_FRAG_SPIRV_SHADER,
QUAD_VERT_SPIRV_SHADER,
GUI_FRAG_SPIRV_SHADER,
GUI_VERT_SPIRV_SHADER,
PBR_FRAG_SPIRV_SHADER,
PBR_VERT_SPIRV_SHADER,
SHADER_ASSET_MAX,
} ShaderAsset;
typedef enum TextureAsset_e : u32
{
PATTERMON_OBESE,
PATTERMON_PURPLOID,
PATTERMON_YUKATA,
HAMSTER,
HAMSMOKER,
CHEESOID,
HOG,
TEXTURE_ASSET_MAX
} TextureAsset;
typedef enum TextureAssetTag_e : u32
{
TEXTURE_ASSET_TAG_MAX,
} TextureAssetTag;
typedef enum SoundAsset_e : u32
{
SOUND_ASSET_MAX,
} SoundAsset;
typedef enum SoundAssetTag_e : u32
{
SOUND_ASSET_TAG_MAX,
} SoundAssetTag;
typedef enum ModelAsset_e : u32
{
MODEL_YODA,
MODEL_BLOCK_CHAR,
MODEL_ASSET_MAX,
} ModelAsset;
typedef enum ModelAssetTag_e : u32
{
MODEL_ASSET_TAG_MAX,
} ModelAssetTag;
typedef struct TexMeta typedef struct TexMeta
{ {
u32 w; u32 w;
@ -100,6 +43,7 @@ typedef struct AssetTag
typedef struct AssetFile typedef struct AssetFile
{ {
u64 hash;
u64 data_offset; u64 data_offset;
u64 len; u64 len;
union union
@ -113,11 +57,7 @@ typedef struct FileHeader
{ {
u32 magic_num; u32 magic_num;
u32 version; u32 version;
u32 tag_counts[ASSET_TYPE_MAX];
u32 asset_counts[ASSET_TYPE_MAX]; u32 asset_counts[ASSET_TYPE_MAX];
u64 tag_offsets[ASSET_TYPE_MAX];
u64 asset_offsets[ASSET_TYPE_MAX]; u64 asset_offsets[ASSET_TYPE_MAX];
} FileHeader; } FileHeader;
@ -127,20 +67,17 @@ static void apInit();
// ::Assets::Loading::Functions::Header:: // ::Assets::Loading::Functions::Header::
static Asset apLoadTexture(TextureAsset asset_id); static Asset apLoad(c8 *str);
static Asset apLoadShader(ShaderAsset asset_id); static Asset apLoadS8(String8 str);
static Asset apLoadModel(ModelAsset asset_id); static void apUnload(c8 *str);
static TexMeta apGetTextureMeta(TextureAsset asset_id); static void apUnloadS8(String8 str);
static ModelMeta apGetModelMeta(ModelAsset asset_id); static u64 apAssetIndex(c8 *str);
static void apUnloadTexture(TextureAsset asset_id);
static void apUnloadShader(ShaderAsset asset_id);
static void apUnloadModel(ModelAsset asset_id);
// ::Assets::Util::Functions::Header:: // ::Assets::Util::Functions::Header::
// TODO(MA): Implement async asset handling // TODO(MA): Implement async asset handling
static inline b32 apMarkUnloaded(AssetType type, u32 index); static inline b32 apMarkUnloaded(c8 *str);
static inline void apMarkLoaded(AssetType type, u32 index); static inline void apMarkLoaded(c8 *str);
// ::Assets::Models::Functions::Header:: // ::Assets::Models::Functions::Header::

66
src/codegen_assets.h Normal file
View File

@ -0,0 +1,66 @@
static c8 *
g_Shader_Asset_Names[] =
{
"shaders/gui.frag",
"shaders/pbr.frag",
"shaders/gui.vert",
"shaders/quad.frag",
"shaders/quad.vert",
"shaders/pbr.vert",
};
static u64
g_Shader_Asset_Hashes[] =
{
4076561469468128204U,
12546533630435803654U,
17203805968697784249U,
1277283055956479971U,
12273814537638279648U,
1941995729991819811U,
};
#define SHADER_ASSET_MAX 6
static c8 *
g_Model_Asset_Names[] =
{
"models/test_char",
"models/yoda",
};
static u64
g_Model_Asset_Hashes[] =
{
17106564331948230266U,
1379945611816585992U,
};
#define MODEL_ASSET_MAX 2
static c8 *
g_Texture_Asset_Names[] =
{
"textures/ham_smoke",
"textures/cheesoid",
"textures/hog",
"textures/patamon",
"textures/pattermon",
"textures/hamster",
"textures/purplemon",
};
static u64
g_Texture_Asset_Hashes[] =
{
3672471465693847963U,
17853259469867187617U,
12925726572206082157U,
1223697967736380744U,
16704275018603890077U,
13194708417649827129U,
12400748618931758111U,
};
#define TEXTURE_ASSET_MAX 7

102
src/ds.c
View File

@ -1,13 +1,19 @@
// ::DataStructures::Globals::Start:: // ::DataStructures::Globals::Start::
RBNode RB_NIL = { .color = RB_BLACK }; RBNode
RBNode *P_RB_NIL = &RB_NIL; RB_NIL = { .color = RB_BLACK };
RBNode *
P_RB_NIL = &RB_NIL;
RBDataNode RB_DN_NIL = {0}; RBDataNode
RBDataNode *P_RB_DN_NIL = &RB_DN_NIL; RB_DN_NIL = {0};
RBDataNode *
P_RB_DN_NIL = &RB_DN_NIL;
HashNode HT_NIL = {0}; HashNode
HashNode *P_HT_NIL = &HT_NIL; HT_NIL = {0};
HashNode *
P_HT_NIL = &HT_NIL;
// ::DataStructures::Globals::End:: // ::DataStructures::Globals::End::
@ -15,7 +21,8 @@ HashNode *P_HT_NIL = &HT_NIL;
// ::DataStructures::RedBlackTree::Functions::Start:: // ::DataStructures::RedBlackTree::Functions::Start::
static void RBTreeInit(RBTree *tree) static void
RBTreeInit(RBTree *tree)
{ {
Assert(tree != NULL, "RBTree is null"); Assert(tree != NULL, "RBTree is null");
RB_NIL.right = RB_NIL.left = RB_NIL.parent = P_RB_NIL; RB_NIL.right = RB_NIL.left = RB_NIL.parent = P_RB_NIL;
@ -25,14 +32,16 @@ static void RBTreeInit(RBTree *tree)
tree->nil = P_RB_NIL; tree->nil = P_RB_NIL;
} }
static inline void RBTreePushDataNode(RBDataNode *first, RBDataNode *last, rawptr value) static inline void
RBTreePushDataNode(RBDataNode *first, RBDataNode *last, rawptr value)
{ {
RBDataNode *data_node = FLMemAllocZeroed(sizeof(RBDataNode)); RBDataNode *data_node = FLMemAllocZeroed(sizeof(RBDataNode));
data_node->data = value; data_node->data = value;
RBQueuePush(first, last, data_node); RBQueuePush(first, last, data_node);
} }
static inline RBNode *RBTreeInitNode(u64 key, rawptr value) static inline RBNode *
RBTreeInitNode(u64 key, rawptr value)
{ {
RBNode *node = FLMemAllocZeroed(sizeof(RBNode)); RBNode *node = FLMemAllocZeroed(sizeof(RBNode));
node->parent = node->left = node->right = P_RB_NIL; node->parent = node->left = node->right = P_RB_NIL;
@ -44,7 +53,8 @@ static inline RBNode *RBTreeInitNode(u64 key, rawptr value)
return node; return node;
} }
static void RBTreeInsert(RBTree *tree, u64 key, rawptr value) static void
RBTreeInsert(RBTree *tree, u64 key, rawptr value)
{ {
RBNode *node = P_RB_NIL; RBNode *node = P_RB_NIL;
@ -104,7 +114,8 @@ static void RBTreeInsert(RBTree *tree, u64 key, rawptr value)
RBTreeCorrect(tree, node); RBTreeCorrect(tree, node);
} }
static void RBTreeCorrect(RBTree *tree, RBNode *node) static void
RBTreeCorrect(RBTree *tree, RBNode *node)
{ {
RBNode *gp = node->parent->parent; RBNode *gp = node->parent->parent;
RBNode *p = node->parent; RBNode *p = node->parent;
@ -147,7 +158,8 @@ static void RBTreeCorrect(RBTree *tree, RBNode *node)
} while ((p = node->parent)); } while ((p = node->parent));
} }
static void RBTreeDelete(RBTree *tree, u64 key, rawptr value) static void
RBTreeDelete(RBTree *tree, u64 key, rawptr value)
{ {
RBNode *node = NULL; RBNode *node = NULL;
Assert(RBTreeSearch(tree, key, &node), "Unable to find node in RBTreeDelete"); Assert(RBTreeSearch(tree, key, &node), "Unable to find node in RBTreeDelete");
@ -286,7 +298,8 @@ static void RBTreeDelete(RBTree *tree, u64 key, rawptr value)
} }
} }
static b32 RBTreeSearchNearest(RBTree *tree, u64 key, RBNode **out_node) static b32
RBTreeSearchNearest(RBTree *tree, u64 key, RBNode **out_node)
{ {
if (tree->root == tree->nil) return false; if (tree->root == tree->nil) return false;
@ -325,7 +338,8 @@ static b32 RBTreeSearchNearest(RBTree *tree, u64 key, RBNode **out_node)
return *out_node != tree->nil; return *out_node != tree->nil;
} }
static b32 RBTreeSearch(RBTree *tree, u64 key, RBNode **out_node) static b32
RBTreeSearch(RBTree *tree, u64 key, RBNode **out_node)
{ {
if (tree->root == tree->nil) return false; if (tree->root == tree->nil) return false;
@ -355,7 +369,8 @@ static b32 RBTreeSearch(RBTree *tree, u64 key, RBNode **out_node)
return found; return found;
} }
static inline void RBTreeTransplant(RBTree *tree, RBNode *node, RBNode *placed_node) static inline void
RBTreeTransplant(RBTree *tree, RBNode *node, RBNode *placed_node)
{ {
if (node->parent == tree->nil) if (node->parent == tree->nil)
tree->root = placed_node; tree->root = placed_node;
@ -367,7 +382,8 @@ static inline void RBTreeTransplant(RBTree *tree, RBNode *node, RBNode *placed_n
placed_node->parent = node->parent; placed_node->parent = node->parent;
} }
static void RBTreeRotate(RBTree *tree, RBNode *node, RBNodeDir dir) static void
RBTreeRotate(RBTree *tree, RBNode *node, RBNodeDir dir)
{ {
RBNode *p = node->parent; RBNode *p = node->parent;
RBNode *root = node->child[1 - dir]; RBNode *root = node->child[1 - dir];
@ -388,7 +404,8 @@ static void RBTreeRotate(RBTree *tree, RBNode *node, RBNodeDir dir)
tree->root = root; tree->root = root;
} }
static void RBTreeLeftRotate(RBTree *tree, RBNode *node) static void
RBTreeLeftRotate(RBTree *tree, RBNode *node)
{ {
RBNode *right = node->right; RBNode *right = node->right;
if (right->left != tree->nil) if (right->left != tree->nil)
@ -406,7 +423,8 @@ static void RBTreeLeftRotate(RBTree *tree, RBNode *node)
node->parent = right; node->parent = right;
} }
static void RBTreeRightRotate(RBTree *tree, RBNode *node) static void
RBTreeRightRotate(RBTree *tree, RBNode *node)
{ {
RBNode *left = node->left; RBNode *left = node->left;
if (left->right != tree->nil) if (left->right != tree->nil)
@ -430,7 +448,8 @@ static void RBTreeRightRotate(RBTree *tree, RBNode *node)
// ::DataStructures::HashTable::Functions::Start:: // ::DataStructures::HashTable::Functions::Start::
static void HashTableInit(HashTable *table, u32 init_size) static void
HashTableInit(HashTable *table, u32 init_size)
{ {
table->cap = init_size; table->cap = init_size;
table->count = 0; table->count = 0;
@ -445,12 +464,14 @@ static void HashTableInit(HashTable *table, u32 init_size)
} }
} }
static void HashTableConcatInPlace(HashList *list, HashList *to_concat) static void
HashTableConcatInPlace(HashList *list, HashList *to_concat)
{ {
SLLConcatInPlaceNoCount(list, to_concat); SLLConcatInPlaceNoCount(list, to_concat);
} }
static void HashTableClear(HashTable *table) static void
HashTableClear(HashTable *table)
{ {
table->count = 0; table->count = 0;
for (u32 i = 0; i < table->count; i++) for (u32 i = 0; i < table->count; i++)
@ -459,14 +480,16 @@ static void HashTableClear(HashTable *table)
} }
} }
static HashNode *HashListPop(HashList *list) static HashNode *
HashListPop(HashList *list)
{ {
HashNode *result = list->first; HashNode *result = list->first;
HTQueuePop(list->first, list->last); HTQueuePop(list->first, list->last);
return result; return result;
} }
static HashNode *HashTablePush(HashTable *table, u64 hash, KeyValuePair value) static HashNode *
HashTablePush(HashTable *table, u64 hash, KeyValuePair value)
{ {
HashNode *node = NULL; HashNode *node = NULL;
if (table->free_lists.first != P_HT_NIL) if (table->free_lists.first != P_HT_NIL)
@ -484,43 +507,50 @@ static HashNode *HashTablePush(HashTable *table, u64 hash, KeyValuePair value)
return node; return node;
} }
static HashNode *HashTablePushU64U32(HashTable *table, u64 key, u32 value) static HashNode *
HashTablePushU64U32(HashTable *table, u64 key, u32 value)
{ {
u64 hash = HashFromString(String8Struct(&key)); u64 hash = HashFromString(String8Struct(&key));
return HashTablePush(table, hash, (KeyValuePair){ .key_u64 = key, .value_u32 = value }); return HashTablePush(table, hash, (KeyValuePair){ .key_u64 = key, .value_u32 = value });
} }
static HashNode *HashTablePushU64U64(HashTable *table, u64 key, u64 value) static HashNode *
HashTablePushU64U64(HashTable *table, u64 key, u64 value)
{ {
u64 hash = HashFromString(String8Struct(&key)); u64 hash = HashFromString(String8Struct(&key));
return HashTablePush(table, hash, (KeyValuePair){ .key_u64 = key, .value_u64 = value }); return HashTablePush(table, hash, (KeyValuePair){ .key_u64 = key, .value_u64 = value });
} }
static HashNode *HashTablePushU64String8(HashTable *table, u64 key, String8 value) static HashNode *
HashTablePushU64String8(HashTable *table, u64 key, String8 value)
{ {
u64 hash = HashFromString(String8Struct(&key)); u64 hash = HashFromString(String8Struct(&key));
return HashTablePush(table, hash, (KeyValuePair){ .key_u64 = key, .value_string = value }); return HashTablePush(table, hash, (KeyValuePair){ .key_u64 = key, .value_string = value });
} }
static HashNode *HashTablePushU64Rawptr(HashTable *table, u64 key, rawptr value) static HashNode *
HashTablePushU64Rawptr(HashTable *table, u64 key, rawptr value)
{ {
u64 hash = HashFromString(String8Struct(&key)); u64 hash = HashFromString(String8Struct(&key));
return HashTablePush(table, hash, (KeyValuePair){ .key_u64 = key, .value_rawptr = value }); return HashTablePush(table, hash, (KeyValuePair){ .key_u64 = key, .value_rawptr = value });
} }
static HashNode *HashTablePushU64U64Split(HashTable *table, u64 key, u32 upper, u32 lower) static HashNode *
HashTablePushU64U64Split(HashTable *table, u64 key, u32 upper, u32 lower)
{ {
u64 hash = HashFromString(String8Struct(&key)); u64 hash = HashFromString(String8Struct(&key));
return HashTablePush(table, hash, (KeyValuePair){ .key_u64 = key, .value_u64_split = { .upper = upper, .lower = lower }}); return HashTablePush(table, hash, (KeyValuePair){ .key_u64 = key, .value_u64_split = { .upper = upper, .lower = lower }});
} }
static HashNode *HashTablePushRawptrU64(HashTable *table, rawptr key, u64 value) static HashNode *
HashTablePushRawptrU64(HashTable *table, rawptr key, u64 value)
{ {
u64 hash = HashFromString(String8Struct(&key)); u64 hash = HashFromString(String8Struct(&key));
return HashTablePush(table, hash, (KeyValuePair){ .key_rawptr = key, .value_u64 = value }); return HashTablePush(table, hash, (KeyValuePair){ .key_rawptr = key, .value_u64 = value });
} }
static KeyValuePair *HashTableSearchU64(HashTable *table, u64 key) static KeyValuePair *
HashTableSearchU64(HashTable *table, u64 key)
{ {
KeyValuePair *result = NULL; KeyValuePair *result = NULL;
@ -539,7 +569,8 @@ static KeyValuePair *HashTableSearchU64(HashTable *table, u64 key)
return result; return result;
} }
static KeyValuePair *HashTableSearchRawptr(HashTable *table, rawptr key) static KeyValuePair *
HashTableSearchRawptr(HashTable *table, rawptr key)
{ {
KeyValuePair *result = NULL; KeyValuePair *result = NULL;
@ -558,7 +589,8 @@ static KeyValuePair *HashTableSearchRawptr(HashTable *table, rawptr key)
return result; return result;
} }
static void HashTableDeleteU64(HashTable *table, u64 key) static void
HashTableDeleteU64(HashTable *table, u64 key)
{ {
u64 hash = HashFromString(String8Struct(&key)); u64 hash = HashFromString(String8Struct(&key));
u64 index = hash % table->cap; u64 index = hash % table->cap;
@ -579,7 +611,8 @@ static void HashTableDeleteU64(HashTable *table, u64 key)
} }
} }
static rawptr HashTableDeleteU64Rawptr(HashTable *table, u64 key) static rawptr
HashTableDeleteU64Rawptr(HashTable *table, u64 key)
{ {
rawptr value = NULL; rawptr value = NULL;
@ -606,7 +639,8 @@ static rawptr HashTableDeleteU64Rawptr(HashTable *table, u64 key)
return value; return value;
} }
static U64Split HashTableDeleteU64U64Split(HashTable *table, u64 key) static U64Split
HashTableDeleteU64U64Split(HashTable *table, u64 key)
{ {
U64Split value = { .upper = UINT32_MAX }; U64Split value = { .upper = UINT32_MAX };

13
src/entry_linux.c
View File

@ -24,9 +24,10 @@ int PROGRAM_FAILED = false;
# include "tests.c" # include "tests.c"
#endif #endif
static_assert(__COUNTER__ < Len(GLOBAL_PROFILER.anchors)); static_assert(__COUNTER__ < Len(g_Global_Profiler.anchors));
void TraverseNode(RBTree *tree, RBNode *node, RBNodeDir *dir) void
TraverseNode(RBTree *tree, RBNode *node, RBNodeDir *dir)
{ {
char *dir_str = dir == NULL ? "Root" : *dir == RB_RIGHT ? "Right" : "Left"; char *dir_str = dir == NULL ? "Root" : *dir == RB_RIGHT ? "Right" : "Left";
Printfln("Color: %s Value: %d Dir: %s", node->color == RB_RED ? "Red" : "Black", node->key, dir_str); Printfln("Color: %s Value: %d Dir: %s", node->color == RB_RED ? "Red" : "Black", node->key, dir_str);
@ -42,12 +43,14 @@ void TraverseNode(RBTree *tree, RBNode *node, RBNodeDir *dir)
} }
} }
void Traverse(RBTree *tree) void
Traverse(RBTree *tree)
{ {
TraverseNode(tree, tree->root, NULL); TraverseNode(tree, tree->root, NULL);
} }
int main(int argc, char **argv) int
main(int argc, char **argv)
{ {
#ifdef BUILD_TEST #ifdef BUILD_TEST
{ {
@ -70,7 +73,7 @@ int main(int argc, char **argv)
gInit(&ctx); gInit(&ctx);
while (!global_quit) while (!g_Global_Quit)
{ {
pWindowEventsGet(inputs, &i_count); pWindowEventsGet(inputs, &i_count);
gRunCycle(&ctx, inputs, i_count); gRunCycle(&ctx, inputs, i_count);

7
src/entry_windows.c
View File

@ -15,9 +15,10 @@
#include "renderer.c" #include "renderer.c"
#include "game.c" #include "game.c"
int CALLBACK WinMain(HINSTANCE instance, HINSTANCE prev_instance, LPSTR cmd_line, int show_code) int CALLBACK
WinMain(HINSTANCE instance, HINSTANCE prev_instance, LPSTR cmd_line, int show_code)
{ {
win32_instance = instance; g_Win32_Instance = instance;
#ifdef BUILD_DEBUG #ifdef BUILD_DEBUG
{ {
@ -44,7 +45,7 @@ int CALLBACK WinMain(HINSTANCE instance, HINSTANCE prev_instance, LPSTR cmd_line
gInit(&ctx); gInit(&ctx);
while (!global_quit) while (!g_Global_Quit)
{ {
pWindowEventsGet(); pWindowEventsGet();
gRunCycle(&ctx, inputs, i_count); gRunCycle(&ctx, inputs, i_count);

56
src/game.c
View File

@ -2,13 +2,20 @@
// TEMP // TEMP
u32 selected_rect = 0; u32
b8 mouse_pressed = false; selected_rect = 0;
b8 mouse_clicked = false; b8
i16 mouse_prev_pos_x = 0; mouse_pressed = false;
i16 mouse_prev_pos_y = 0; b8
i16 mouse_pos_x = 0; mouse_clicked = false;
i16 mouse_pos_y = 0; i16
mouse_prev_pos_x = 0;
i16
mouse_prev_pos_y = 0;
i16
mouse_pos_x = 0;
i16
mouse_pos_y = 0;
// ::Game::Globals::End:: // ::Game::Globals::End::
@ -16,7 +23,8 @@ i16 mouse_pos_y = 0;
// ::Game::Init::Functions::Start:: // ::Game::Init::Functions::Start::
static void gInit(gGameCtx *ctx) static void
gInit(gGameCtx *ctx)
{ {
Assert(rInit(), "Failed to initialize the renderer"); Assert(rInit(), "Failed to initialize the renderer");
@ -35,7 +43,8 @@ static void gInit(gGameCtx *ctx)
ctx->btn_len = 0; ctx->btn_len = 0;
} }
static void gDestroy() static void
gDestroy()
{ {
rDestroy(); rDestroy();
} }
@ -46,12 +55,14 @@ static void gDestroy()
// ::Game::GameLoop::Functions::Start:: // ::Game::GameLoop::Functions::Start::
static void gFrameStartNew() static void
gFrameStartNew()
{ {
} }
static void gRunCycle(gGameCtx *ctx, pGameInput *inputs, u32 i_count) static void
gRunCycle(gGameCtx *ctx, pGameInput *inputs, u32 i_count)
{ {
ArenaFree(vFrameArena()); ArenaFree(vFrameArena());
@ -65,10 +76,10 @@ static void gRunCycle(gGameCtx *ctx, pGameInput *inputs, u32 i_count)
u64 index = vFrameIndex(); u64 index = vFrameIndex();
/*
rDescHandle yoder = rMeshLoad(MODEL_YODA); rDescHandle yoder = rMeshLoad(MODEL_YODA);
ctx->pc.mesh_index = yoder.desc_index; ctx->pc.mesh_index = yoder.desc_index;
*/
ModelMeta model_meta = apGetModelMeta(MODEL_YODA);
rViewportSize(&ctx->pc.res); rViewportSize(&ctx->pc.res);
ctx->pc.time = (f32)pCPUTimerRead(); ctx->pc.time = (f32)pCPUTimerRead();
@ -89,9 +100,9 @@ static void gRunCycle(gGameCtx *ctx, pGameInput *inputs, u32 i_count)
//rBufferBindGUIVertex(); //rBufferBindGUIVertex();
//rBufferBindGUIIndex(); //rBufferBindGUIIndex();
rBufferBindMesh(&ctx->pc, yoder); //rBufferBindMesh(&ctx->pc, yoder);
rDrawIndexed(model_meta.i_count, 1); //rDrawIndexed(model_meta.i_count, 1);
rFrameFinish(); rFrameFinish();
@ -107,7 +118,8 @@ static void gRunCycle(gGameCtx *ctx, pGameInput *inputs, u32 i_count)
// ::Game::Inputs::Functions::Start:: // ::Game::Inputs::Functions::Start::
static void gHandleInputs(pGameInput *inputs, u32 count) static void
gHandleInputs(pGameInput *inputs, u32 count)
{ {
mouse_clicked = false; mouse_clicked = false;
@ -161,12 +173,14 @@ static void gHandleInputs(pGameInput *inputs, u32 count)
// ::Game::GUI::Functions::Start:: // ::Game::GUI::Functions::Start::
static inline void gPrepareGUICtx(gGameCtx *ctx) static inline void
gPrepareGUICtx(gGameCtx *ctx)
{ {
ctx->gui.has_grabbed = false; ctx->gui.has_grabbed = false;
} }
static b32 gButton(gGameCtx *ctx, char *label, f32 x0, f32 y0, f32 x1, f32 y1) static b32
gButton(gGameCtx *ctx, char *label, f32 x0, f32 y0, f32 x1, f32 y1)
{ {
gButtonWidget *btn = NULL; gButtonWidget *btn = NULL;
u64 id = HashFromString(String8CStr(label)); u64 id = HashFromString(String8CStr(label));
@ -226,7 +240,8 @@ static b32 gButton(gGameCtx *ctx, char *label, f32 x0, f32 y0, f32 x1, f32 y1)
return btn->pressed; return btn->pressed;
} }
static b32 gWindow(gGameCtx *ctx, char *title, f32 x0, f32 y0, f32 x1, f32 y1, rDescHandle handle) static b32
gWindow(gGameCtx *ctx, char *title, f32 x0, f32 y0, f32 x1, f32 y1, rDescHandle handle)
{ {
gWindowWidget *win = NULL; gWindowWidget *win = NULL;
u32 id = HashFromString(String8CStr(title)); u32 id = HashFromString(String8CStr(title));
@ -307,7 +322,8 @@ static b32 gWindow(gGameCtx *ctx, char *title, f32 x0, f32 y0, f32 x1, f32 y1, r
} }
static void gRect(gUICtx *ctx, Vec2 p0, Vec2 p1, Vec4 col, rDescHandle handle) static void
gRect(gUICtx *ctx, Vec2 p0, Vec2 p1, Vec4 col, rDescHandle handle)
{ {
ctx->vertices[ctx->vertices_len].p0 = p0; ctx->vertices[ctx->vertices_len].p0 = p0;
ctx->vertices[ctx->vertices_len].p1 = p1; ctx->vertices[ctx->vertices_len].p1 = p1;

299
src/packer.c
View File

@ -17,108 +17,201 @@
# include <fcntl.h> # include <fcntl.h>
#endif #endif
// ::Packer::Includes::CFiles::End::
// ::Packer::Globals::Start::
const FileMapping g_Shader_File_Map[] = {
{ .file_name = "quad.frag.spv", .ix = QUAD_FRAG_SPIRV_SHADER },
{ .file_name = "quad.vert.spv", .ix = QUAD_VERT_SPIRV_SHADER },
{ .file_name = "gui.frag.spv", .ix = GUI_FRAG_SPIRV_SHADER },
{ .file_name = "gui.vert.spv", .ix = GUI_VERT_SPIRV_SHADER },
{ .file_name = "pbr.frag.spv", .ix = PBR_FRAG_SPIRV_SHADER },
{ .file_name = "pbr.vert.spv", .ix = PBR_VERT_SPIRV_SHADER },
};
const FileMapping g_Texture_File_Map[] = {
{ .file_name = "pattermon.png", .ix = PATTERMON_OBESE },
{ .file_name = "patamon.png", .ix = PATTERMON_YUKATA },
{ .file_name = "purplemon.png", .ix = PATTERMON_PURPLOID },
{ .file_name = "hamster.png", .ix = HAMSTER },
{ .file_name = "ham_smoke.png", .ix = HAMSMOKER },
{ .file_name = "cheesoid.png", .ix = CHEESOID },
{ .file_name = "hog.jpg", .ix = HOG },
};
const FileMapping g_Model_File_Map[] = {
{ .file_name = "yoda.m3d", .ix = MODEL_YODA },
{ .file_name = "test_char.m3d", .ix = MODEL_BLOCK_CHAR },
};
c8 *g_Shader_File_Names[SHADER_ASSET_MAX] = {0};
c8 *g_Texture_File_Names[TEXTURE_ASSET_MAX] = {0};
c8 *g_Model_File_Names[MODEL_ASSET_MAX] = {0};
// ::Packer::Globals::End::
// ::Packer::Packing::Functions::Start:: // ::Packer::Packing::Functions::Start::
void SetArrayLookups() #ifdef BUILD_ASSET_CODEGEN
u64
WriteArrayToFile(Arena *arena, pFile file, String8 array_name, rawptr elements, u32 count, String8 type, u64 offset)
{ {
for (i32 i = 0; i < Len(g_Shader_File_Map); i++) b32 is_string = StrEq(type.value, "c8 *");
c8 *decl = MakeArray(arena, c8, 2048);
i32 decl_len = SPrintf(decl, 2048, "static %s\n%s[] = \n{\n\t", type.value, array_name.value);
String8 result = {
.value = decl,
.len = u64(decl_len),
};
if (is_string)
{ {
FileMapping file_mapping = g_Shader_File_Map[i]; String8 *strs = (String8 *)elements;
g_Shader_File_Names[file_mapping.ix] = file_mapping.file_name; for (u32 i = 0; i < count; i += 1)
{
c8 *f = i == count-1 ? "\"%s\"," : "\"%s\",\n\t";
c8 buf[512];
decl_len = SPrintf(buf, 512, f, strs[i].value);
result = String8Concat(arena, result, MakeString8(buf, decl_len));
}
}
else
{
u64 *ints = (u64 *)elements;
for (u32 i = 0; i < count; i += 1)
{
c8 *f = i == count-1 ? "%lluU," : "%lluU,\n\t";
c8 buf[512];
decl_len = SPrintf(buf, 512, f, ints[i]);
result = String8Concat(arena, result, MakeString8(buf, decl_len));
}
} }
for (int i = 0; i < SHADER_ASSET_MAX; i++) result = String8Concat(arena, result, String8CStr("\n};\n\n"));
{
Assert(g_Shader_File_Names[i] != NULL, "Spirv shader file name is null");
}
for (i32 i = 0; i < Len(g_Texture_File_Map); i++) return pFileWrite(file, offset, result.value, result.len);
{
FileMapping file_mapping = g_Texture_File_Map[i];
g_Texture_File_Names[file_mapping.ix] = file_mapping.file_name;
}
for (int i = 0; i < TEXTURE_ASSET_MAX; i++)
{
Assert(g_Texture_File_Names[i] != NULL, "Texture file name is null");
}
for (i32 i = 0; i < Len(g_Model_File_Map); i++)
{
FileMapping file_mapping = g_Model_File_Map[i];
g_Model_File_Names[file_mapping.ix] = file_mapping.file_name;
}
for (int i = 0; i < MODEL_ASSET_MAX; i++)
{
Assert(g_Model_File_Names[i] != NULL, "Model file name is null");
}
} }
i32 WriteHeader(pFile file, FileHeader *header) static String8 *
ConvertCStrs(Arena *arena, c8 **strs, u32 count)
{
String8 *str8s = MakeArray(arena, String8, count);
for (u32 i = 0; i < count; i += 1)
{
str8s[i].value = strs[i];
str8s[i].len = StrLen(strs[i]);
}
return str8s;
}
void
CodeGenAssetLookups(Arena *arena)
{
pFile file = pFileOpen("../src/codegen_assets.h", pFS_WRITE | pFS_CREATE | pFS_TRUNC);
Assert(file > 0, "CodeGenAssetLookups failure: unable to open/create file");
Assert(pDirNavigate("../assets") == 0, "Unable to navigate to asset directory");
struct AssetDirInfo {
c8 *prefix, *struct_name, *hash_struct_name, *dir, *define;
};
struct AssetDirInfo dirs[] = {
{
.prefix = "shaders/",
.struct_name = "g_Shader_Asset_Names",
.hash_struct_name = "g_Shader_Asset_Hashes",
.dir = "shaders",
.define = "SHADER_ASSET",
},
{
.prefix = "models/",
.struct_name = "g_Model_Asset_Names",
.hash_struct_name = "g_Model_Asset_Hashes",
.dir = "models",
.define = "MODEL_ASSET",
},
{
.prefix = "textures/",
.struct_name = "g_Texture_Asset_Names",
.hash_struct_name = "g_Texture_Asset_Hashes",
.dir = "textures",
.define = "TEXTURE_ASSET",
},
};
u64 offset = 0;
u32 dir_count = sizeof(dirs) / sizeof(struct AssetDirInfo);
for (u32 i = 0; i < dir_count; i += 1)
{
Assert(pDirNavigate(dirs[i].dir) == 0, "Unable to navigate to asset sub directory.");
u32 count = 0;
c8 **cstrs = pDirGetFileNames(arena, &count);
u64 *hashes = MakeArray(arena, u64, count);
String8 *strs = ConvertCStrs(arena, cstrs, count);
for (u32 j = 0; j < count; j += 1)
{
strs[j] = String8Concat(arena, String8CStr(dirs[i].prefix), strs[j]);
i64 offset = String8FindLast(strs[j], '.');
hashes[j] = XXH3_64bits_withSeed(strs[j].value, strs[j].len - offset, HASH_SEED);
}
offset += WriteArrayToFile(
arena,
file,
String8CStr(dirs[i].struct_name),
strs,
count,
String8CStr("c8 *"),
offset
);
offset += WriteArrayToFile(
arena,
file,
String8CStr(dirs[i].hash_struct_name),
hashes,
count,
String8CStr("u64"),
offset
);
c8 buf[128];
i32 decl_len = SPrintf(buf, 128, "#define %s_MAX %llu\n\n#define %s %llu\n\n", dirs[i].define, count, dirs[i].define, i);
offset += pFileWrite(file, offset, buf, decl_len);
Assert(pDirNavigate("..") == 0, "CodeGenAssetLookups failure: unable to move back to build directory");
}
pFileClose(file);
}
int
main(int argc, c8 **argv)
{
#ifdef _WIN32
{
_set_fmode(_O_BINARY);
}
#endif
if (pDirIsVisible("build"))
{
Assert(pDirNavigate("./build") == 0, "Unable to change to build directory");
}
void *mem = pMemAllocZeroed(GB(1));
Arena *arena = ArenaInitDebug(mem, GB(1), __LINE__);
CodeGenAssetLookups(arena);
}
#else
i32
WriteHeader(pFile file, FileHeader *header)
{ {
i32 offset = 0; i32 offset = 0;
return offset; return offset;
} }
void MoveToShaderDir(c8 **return_dir) void
MoveToShaderDir(c8 **return_dir)
{ {
Assert(pDirNavigate("../assets/shaders") == 0, "Unable to change to shader directory"); Assert(pDirNavigate("../assets/shaders") == 0, "Unable to change to shader directory");
*return_dir = "../../build"; *return_dir = "../../build";
} }
void MoveToTextureDir(c8 **return_dir) void
MoveToTextureDir(c8 **return_dir)
{ {
Assert(pDirNavigate("../assets/textures") == 0, "Unable to change to assets directory"); Assert(pDirNavigate("../assets/textures") == 0, "Unable to change to assets directory");
*return_dir = "../../build"; *return_dir = "../../build";
} }
void MoveToModelDir(c8 **return_dir) void
MoveToModelDir(c8 **return_dir)
{ {
Assert(pDirNavigate("../assets/models") == 0, "Unable to change to assets directory"); Assert(pDirNavigate("../assets/models") == 0, "Unable to change to assets directory");
*return_dir = "../../build"; *return_dir = "../../build";
} }
void InitHeader(FileHeader *header) void
InitHeader(FileHeader *header)
{ {
Assert(header != NULL, "File header is null"); Assert(header != NULL, "File header is null");
@ -126,29 +219,14 @@ void InitHeader(FileHeader *header)
header->version = FILE_VERSION; header->version = FILE_VERSION;
header->asset_counts[SHADER_ASSET] = SHADER_ASSET_MAX; header->asset_counts[SHADER_ASSET] = SHADER_ASSET_MAX;
header->tag_counts[SHADER_ASSET] = 0;
header->asset_counts[TEXTURE_ASSET] = TEXTURE_ASSET_MAX; header->asset_counts[TEXTURE_ASSET] = TEXTURE_ASSET_MAX;
header->tag_counts[TEXTURE_ASSET] = TEXTURE_ASSET_TAG_MAX;
header->asset_counts[SOUND_ASSET] = SOUND_ASSET_MAX; header->asset_counts[SOUND_ASSET] = SOUND_ASSET_MAX;
header->tag_counts[SOUND_ASSET] = SOUND_ASSET_TAG_MAX;
header->asset_counts[MODEL_ASSET] = MODEL_ASSET_MAX; header->asset_counts[MODEL_ASSET] = MODEL_ASSET_MAX;
header->tag_counts[MODEL_ASSET] = MODEL_ASSET_TAG_MAX;
u64 offset = sizeof(FileHeader); u64 offset = sizeof(FileHeader);
for (u32 i = 0; i < ASSET_TYPE_MAX; i++) for (u32 i = 0; i < ASSET_TYPE_MAX; i++)
{ {
if (header->tag_counts[i] > 0)
{
header->tag_offsets[i] = offset;
offset += sizeof(AssetTag) * header->tag_counts[i];
}
else
header->tag_offsets[i] = 0;
if (header->asset_counts[i] > 0) if (header->asset_counts[i] > 0)
{ {
header->asset_offsets[i] = offset; header->asset_offsets[i] = offset;
@ -159,7 +237,8 @@ void InitHeader(FileHeader *header)
} }
} }
void PackFiles(Arena *arena, FileHeader *header) void
PackFiles(Arena *arena, FileHeader *header)
{ {
pFile file = pFileOpen("assets.sgp", pFS_WRITE | pFS_TRUNC); pFile file = pFileOpen("assets.sgp", pFS_WRITE | pFS_TRUNC);
@ -168,10 +247,6 @@ void PackFiles(Arena *arena, FileHeader *header)
u64 data_offset = 0; u64 data_offset = 0;
for (u32 i = 0; i < ASSET_TYPE_MAX; i++) for (u32 i = 0; i < ASSET_TYPE_MAX; i++)
{ {
u64 tag_offset = header->tag_offsets[i] + (header->tag_counts[i] * sizeof(AssetTag));
if (tag_offset > data_offset)
data_offset = tag_offset;
u64 asset_offset = header->asset_offsets[i] + (header->asset_counts[i] * sizeof(AssetFile)); u64 asset_offset = header->asset_offsets[i] + (header->asset_counts[i] * sizeof(AssetFile));
if (asset_offset > data_offset) if (asset_offset > data_offset)
data_offset = asset_offset; data_offset = asset_offset;
@ -184,7 +259,7 @@ void PackFiles(Arena *arena, FileHeader *header)
AssetFile *shader_assets = MakeArray(arena, AssetFile, SHADER_ASSET_MAX); AssetFile *shader_assets = MakeArray(arena, AssetFile, SHADER_ASSET_MAX);
for (u32 i = 0; i < SHADER_ASSET_MAX; i++) for (u32 i = 0; i < SHADER_ASSET_MAX; i++)
{ {
c8 *asset_name = g_Shader_File_Names[i]; c8 *asset_name = g_Shader_Asset_Names[i];
Printfln("Packing file: %s...", asset_name); Printfln("Packing file: %s...", asset_name);
@ -211,7 +286,7 @@ void PackFiles(Arena *arena, FileHeader *header)
AssetFile *texture_assets = MakeArray(arena, AssetFile, TEXTURE_ASSET_MAX); AssetFile *texture_assets = MakeArray(arena, AssetFile, TEXTURE_ASSET_MAX);
for (u32 i = 0; i < TEXTURE_ASSET_MAX; i++) for (u32 i = 0; i < TEXTURE_ASSET_MAX; i++)
{ {
c8 *asset_name = g_Texture_File_Names[i]; c8 *asset_name = g_Texture_Asset_Names[i];
Printfln("Packing file: %s...", asset_name); Printfln("Packing file: %s...", asset_name);
@ -254,7 +329,7 @@ void PackFiles(Arena *arena, FileHeader *header)
AssetFile *model_assets = MakeArray(arena, AssetFile, MODEL_ASSET_MAX); AssetFile *model_assets = MakeArray(arena, AssetFile, MODEL_ASSET_MAX);
for (u32 i = 0; i < MODEL_ASSET_MAX; i++) for (u32 i = 0; i < MODEL_ASSET_MAX; i++)
{ {
c8 *asset_name = g_Model_File_Names[i]; c8 *asset_name = g_Model_Asset_Names[i];
Printfln("Packing file: %s...", asset_name); Printfln("Packing file: %s...", asset_name);
@ -288,7 +363,8 @@ void PackFiles(Arena *arena, FileHeader *header)
// ::Packer::Tests::Functions::Start:: // ::Packer::Tests::Functions::Start::
static inline void TestAssetIsCorrect(Arena *arena, c8 *file_name, AssetFile *file_info, AssetType type, pFile file) static inline void
TestAssetIsCorrect(Arena *arena, c8 *file_name, AssetFile *file_info, AssetType type, pFile file)
{ {
pFile asset_file = pFileOpen(file_name, pFS_READ); pFile asset_file = pFileOpen(file_name, pFS_READ);
u64 size = pFileLength(asset_file); u64 size = pFileLength(asset_file);
@ -331,7 +407,8 @@ static inline void TestAssetIsCorrect(Arena *arena, c8 *file_name, AssetFile *fi
pFileClose(asset_file); pFileClose(asset_file);
} }
void TestAssetPack(Arena *arena) void
TestAssetPack(Arena *arena)
{ {
pFile file = pFileOpen("assets.sgp", pFS_READ); pFile file = pFileOpen("assets.sgp", pFS_READ);
@ -341,16 +418,9 @@ void TestAssetPack(Arena *arena)
Assert(header.magic_num == CreateMagicValue('s', 't', 'e', 'g'), "Magic number is incorrect"); Assert(header.magic_num == CreateMagicValue('s', 't', 'e', 'g'), "Magic number is incorrect");
Assert(header.version == FILE_VERSION, "File version is incorrect"); Assert(header.version == FILE_VERSION, "File version is incorrect");
Assert(header.tag_counts[SHADER_ASSET] == 0, "Shader tag count incorrect");
Assert(header.asset_counts[SHADER_ASSET] == SHADER_ASSET_MAX, "Shader count incorrect"); Assert(header.asset_counts[SHADER_ASSET] == SHADER_ASSET_MAX, "Shader count incorrect");
Assert(header.tag_counts[TEXTURE_ASSET] == TEXTURE_ASSET_TAG_MAX, "Texture tag count incorrect");
Assert(header.asset_counts[TEXTURE_ASSET] == TEXTURE_ASSET_MAX, "Texture count incorrect"); Assert(header.asset_counts[TEXTURE_ASSET] == TEXTURE_ASSET_MAX, "Texture count incorrect");
Assert(header.tag_counts[SOUND_ASSET] == SOUND_ASSET_TAG_MAX, "Sound tag count incorrect");
Assert(header.asset_counts[SOUND_ASSET] == SOUND_ASSET_MAX, "Sound count incorrect"); Assert(header.asset_counts[SOUND_ASSET] == SOUND_ASSET_MAX, "Sound count incorrect");
Assert(header.tag_counts[MODEL_ASSET] == MODEL_ASSET_TAG_MAX, "Model tag count incorrect");
Assert(header.asset_counts[MODEL_ASSET] == MODEL_ASSET_MAX, "Model count incorrect"); Assert(header.asset_counts[MODEL_ASSET] == MODEL_ASSET_MAX, "Model count incorrect");
AssetTag *tags[ASSET_TYPE_MAX]; AssetTag *tags[ASSET_TYPE_MAX];
@ -358,12 +428,6 @@ void TestAssetPack(Arena *arena)
for (u32 i = 0; i < ASSET_TYPE_MAX; i++) for (u32 i = 0; i < ASSET_TYPE_MAX; i++)
{ {
if (header.tag_counts[i] > 0)
{
tags[i] = MakeArray(arena, AssetTag, header.tag_counts[i]);
pFileRead(file, header.tag_offsets[i], tags[i], sizeof(AssetTag)*header.tag_counts[i]);
}
if (header.asset_counts[i] > 0) if (header.asset_counts[i] > 0)
{ {
files[i] = MakeArray(arena, AssetFile, header.asset_counts[i]); files[i] = MakeArray(arena, AssetFile, header.asset_counts[i]);
@ -376,7 +440,7 @@ void TestAssetPack(Arena *arena)
for (u32 i = 0; i < SHADER_ASSET_MAX; i++) for (u32 i = 0; i < SHADER_ASSET_MAX; i++)
{ {
TestAssetIsCorrect(arena, g_Shader_File_Names[i], &files[SHADER_ASSET][i], SHADER_ASSET, file); TestAssetIsCorrect(arena, g_Shader_Asset_Names[i], &files[SHADER_ASSET][i], SHADER_ASSET, file);
} }
pDirNavigate(return_dir); pDirNavigate(return_dir);
@ -384,7 +448,7 @@ void TestAssetPack(Arena *arena)
for (u32 i = 0; i < TEXTURE_ASSET_MAX; i++) for (u32 i = 0; i < TEXTURE_ASSET_MAX; i++)
{ {
TestAssetIsCorrect(arena, g_Texture_File_Names[i], &files[TEXTURE_ASSET][i], TEXTURE_ASSET, file); TestAssetIsCorrect(arena, g_Texture_Asset_Names[i], &files[TEXTURE_ASSET][i], TEXTURE_ASSET, file);
} }
pDirNavigate(return_dir); pDirNavigate(return_dir);
@ -392,7 +456,7 @@ void TestAssetPack(Arena *arena)
for (u32 i = 0; i < MODEL_ASSET_MAX; i++) for (u32 i = 0; i < MODEL_ASSET_MAX; i++)
{ {
TestAssetIsCorrect(arena, g_Model_File_Names[i], &files[MODEL_ASSET][i], MODEL_ASSET, file); TestAssetIsCorrect(arena, g_Model_Asset_Names[i], &files[MODEL_ASSET][i], MODEL_ASSET, file);
} }
} }
@ -402,7 +466,8 @@ void TestAssetPack(Arena *arena)
// ::Packer::Main::Functions::Start:: // ::Packer::Main::Functions::Start::
int main(int argc, c8 **argv) int
main(int argc, c8 **argv)
{ {
#ifdef _WIN32 #ifdef _WIN32
{ {
@ -415,8 +480,6 @@ int main(int argc, c8 **argv)
Assert(pDirNavigate("./build") == 0, "Unable to change to build directory"); Assert(pDirNavigate("./build") == 0, "Unable to change to build directory");
} }
SetArrayLookups();
void *mem = pMemAllocZeroed(GB(1)); void *mem = pMemAllocZeroed(GB(1));
Arena *arena = ArenaInitDebug(mem, GB(1), __LINE__); Arena *arena = ArenaInitDebug(mem, GB(1), __LINE__);
@ -433,4 +496,8 @@ int main(int argc, c8 **argv)
TestAssetPack(arena); TestAssetPack(arena);
} }
#endif // BUILD_ASSET_CODEGEN
// ::Packer::Main::Functions::End:: // ::Packer::Main::Functions::End::

1
src/packer.h
View File

@ -51,6 +51,7 @@ typedef struct FileMapping
// ::Packer::Packing::Functions::Header:: // ::Packer::Packing::Functions::Header::
void SetArrayLookups(); void SetArrayLookups();
void CodeGenAssetLookups(Arena *arena);
void InitHeader(FileHeader *header); void InitHeader(FileHeader *header);
i32 WriteHeader(pFile file, FileHeader *header); i32 WriteHeader(pFile file, FileHeader *header);
void PackFiles(Arena *arena, FileHeader *header); void PackFiles(Arena *arena, FileHeader *header);

42
src/platform/platform_linux.c
View File

@ -1,41 +1,49 @@
// ::Platform::Linux::Globals::Start:: // ::Platform::Linux::Globals::Start::
static pPlatformWindow linux_window = { static pPlatformWindow
linux_window =
{
.w = 1920, .w = 1920,
.h = 1080, .h = 1080,
}; };
b32 global_quit = false; b32
g_Global_Quit = false;
// ::Platform::Linux::Globals::End:: // ::Platform::Linux::Globals::End::
// ::Platform::Linux::Print::Functions::Start:: // ::Platform::Linux::Print::Functions::Start::
i32 pWriteStdOut(rawptr buf, i32 len) i32
pWriteStdOut(rawptr buf, i32 len)
{ {
return (i32)write(STDOUT, buf, len); return (i32)write(STDOUT, buf, len);
} }
i32 pWriteStdErr(rawptr buf, i32 len) i32
pWriteStdErr(rawptr buf, i32 len)
{ {
return (i32)write(STDERR, buf, len); return (i32)write(STDERR, buf, len);
} }
// ::Platform::Linux::Window::Functions::Start:: // ::Platform::Linux::Window::Functions::Start::
void pWindowEventsGet(pGameInput *inputs, u32 *i_count) void
pWindowEventsGet(pGameInput *inputs, u32 *i_count)
{ {
pWindowEventHandle(inputs, i_count, false); pWindowEventHandle(inputs, i_count, false);
} }
b32 pWindowEventWaitFor(pGameInput *input) b32
pWindowEventWaitFor(pGameInput *input)
{ {
u32 i_count; u32 i_count;
pWindowEventHandle(input, &i_count, true); pWindowEventHandle(input, &i_count, true);
return i_count > 0; return i_count > 0;
} }
void pWindowEventHandle(pGameInput *inputs, u32 *i_count, b32 wait_for_event) void
pWindowEventHandle(pGameInput *inputs, u32 *i_count, b32 wait_for_event)
{ {
b32 has_max_inputs = false; b32 has_max_inputs = false;
*i_count = 0; *i_count = 0;
@ -60,7 +68,7 @@ void pWindowEventHandle(pGameInput *inputs, u32 *i_count, b32 wait_for_event)
break; break;
if (msg->data.data32[0] == linux_window.close_event) if (msg->data.data32[0] == linux_window.close_event)
global_quit = true; g_Global_Quit = true;
} break; } break;
case XCB_CONFIGURE_NOTIFY: case XCB_CONFIGURE_NOTIFY:
{ {
@ -145,7 +153,8 @@ void pWindowEventHandle(pGameInput *inputs, u32 *i_count, b32 wait_for_event)
} while(!wait_for_event && !has_max_inputs); } while(!wait_for_event && !has_max_inputs);
} }
pKeyboardInput pInputEventConvert(u32 x_key) pKeyboardInput
pInputEventConvert(u32 x_key)
{ {
switch (x_key) switch (x_key)
{ {
@ -287,7 +296,8 @@ pKeyboardInput pInputEventConvert(u32 x_key)
// ::Platform::Linux::Utils::Functions::Start:: // ::Platform::Linux::Utils::Functions::Start::
b32 pSyscallErrCheck(void *ptr) b32
pSyscallErrCheck(void *ptr)
{ {
return (isize)ptr == SYS_ERR ? true : false; return (isize)ptr == SYS_ERR ? true : false;
} }
@ -298,7 +308,8 @@ b32 pSyscallErrCheck(void *ptr)
// ::Platform::Linux::Async::Start:: // ::Platform::Linux::Async::Start::
static pThread pThreadInit(rawptr proc, rawptr param) static pThread
pThreadInit(rawptr proc, rawptr param)
{ {
pThread thread = {0}; pThread thread = {0};
Assert(pthread_mutex_init(&thread.mut, NULL) == 0, "pthread_mutex_init failure"); Assert(pthread_mutex_init(&thread.mut, NULL) == 0, "pthread_mutex_init failure");
@ -308,19 +319,22 @@ static pThread pThreadInit(rawptr proc, rawptr param)
return thread; return thread;
} }
static void pThreadSuspend(pThread *thread) static void
pThreadSuspend(pThread *thread)
{ {
pthread_mutex_lock(&thread->mut); pthread_mutex_lock(&thread->mut);
pthread_cond_wait(&thread->cond, &thread->mut); pthread_cond_wait(&thread->cond, &thread->mut);
pthread_mutex_unlock(&thread->mut); pthread_mutex_unlock(&thread->mut);
} }
static void pThreadWake(pThread *thread) static void
pThreadWake(pThread *thread)
{ {
pthread_cond_signal(&thread->cond); pthread_cond_signal(&thread->cond);
} }
static void pThreadKill() static void
pThreadKill()
{ {
pthread_exit(NULL); pthread_exit(NULL);
} }

99
src/platform/platform_linux_public.c
View File

@ -1,6 +1,7 @@
// ::Platform::Functions::pLibrary::Start:: // ::Platform::Functions::pLibrary::Start::
b32 pLibraryLoad(const char *name, pLibrary *out_lib) b32
pLibraryLoad(const char *name, pLibrary *out_lib)
{ {
if (!name) { if (!name) {
return false; return false;
@ -14,7 +15,8 @@ b32 pLibraryLoad(const char *name, pLibrary *out_lib)
return true; return true;
} }
b32 pFunctionLoad(const char *name, pLibrary *lib, pFunction *out_fn) b32
pFunctionLoad(const char *name, pLibrary *lib, pFunction *out_fn)
{ {
if (!name) { if (!name) {
return false; return false;
@ -42,7 +44,8 @@ b32 pFunctionLoad(const char *name, pLibrary *lib, pFunction *out_fn)
// ::Platform::Functions::Memory::Start:: // ::Platform::Functions::Memory::Start::
rawptr pMemAlloc(usize size) rawptr
pMemAlloc(usize size)
{ {
rawptr addr = mmap( rawptr addr = mmap(
NULL, NULL,
@ -58,14 +61,16 @@ rawptr pMemAlloc(usize size)
return addr; return addr;
} }
rawptr pMemAllocZeroed(usize size) rawptr
pMemAllocZeroed(usize size)
{ {
rawptr ptr = pMemAlloc(size); rawptr ptr = pMemAlloc(size);
MemZero(ptr, size); MemZero(ptr, size);
return ptr; return ptr;
} }
rawptr pMemRealloc(rawptr ptr, usize old_size, usize new_size) rawptr
pMemRealloc(rawptr ptr, usize old_size, usize new_size)
{ {
rawptr addr = mremap( rawptr addr = mremap(
ptr, ptr,
@ -79,12 +84,14 @@ rawptr pMemRealloc(rawptr ptr, usize old_size, usize new_size)
return addr; return addr;
} }
void pMemFree(rawptr ptr, usize size) void
pMemFree(rawptr ptr, usize size)
{ {
Assert(munmap(ptr, size) == 0, "munmap failed"); Assert(munmap(ptr, size) == 0, "munmap failed");
} }
usize pPageSize() usize
pPageSize()
{ {
return (usize)sysconf(_SC_PAGESIZE); return (usize)sysconf(_SC_PAGESIZE);
} }
@ -95,7 +102,8 @@ usize pPageSize()
// ::Platform::Functions::Window::Start:: // ::Platform::Functions::Window::Start::
b32 pWindowInit(const char *window_name) b32
pWindowInit(const char *window_name)
{ {
pPlatformWindow *window = &linux_window; pPlatformWindow *window = &linux_window;
@ -203,7 +211,8 @@ b32 pWindowInit(const char *window_name)
return true; return true;
} }
pWindowSize pWindowGetSize() pWindowSize
pWindowGetSize()
{ {
return (pWindowSize) { return (pWindowSize) {
.w = linux_window.w, .w = linux_window.w,
@ -211,12 +220,14 @@ pWindowSize pWindowGetSize()
}; };
} }
pPlatformWindow *pWindowGet() pPlatformWindow
*pWindowGet()
{ {
return &linux_window; return &linux_window;
} }
b32 pWindowShouldQuit() b32
pWindowShouldQuit()
{ {
return false; return false;
} }
@ -227,12 +238,14 @@ b32 pWindowShouldQuit()
// ::Platform::FileSystem::Functions::Start:: // ::Platform::FileSystem::Functions::Start::
b32 pDirNavigate(c8 *dir) b32
pDirNavigate(c8 *dir)
{ {
return chdir(dir); return chdir(dir);
} }
static pFile pFileOpen(c8 *file_name, pFSAccess acc) static pFile
pFileOpen(c8 *file_name, pFSAccess acc)
{ {
int flags = 0; int flags = 0;
if (BitEq(acc, pFS_READ) && BitEq(acc, pFS_WRITE)) if (BitEq(acc, pFS_READ) && BitEq(acc, pFS_WRITE))
@ -255,30 +268,35 @@ static pFile pFileOpen(c8 *file_name, pFSAccess acc)
return open(file_name, flags, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP); return open(file_name, flags, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP);
} }
static void pFileClose(pFile file) static void
pFileClose(pFile file)
{ {
close(file); close(file);
} }
// TODO: make these more resilient // TODO: make these more resilient
static u64 pFileRead(pFile file, u64 offset, rawptr buf, u64 len) static u64
pFileRead(pFile file, u64 offset, rawptr buf, u64 len)
{ {
lseek(file, (isize)offset, SEEK_SET); lseek(file, (isize)offset, SEEK_SET);
return read(file, buf, (usize)len); return read(file, buf, (usize)len);
} }
static u64 pFileWrite(pFile file, u64 offset, rawptr buf, u64 len) static u64
pFileWrite(pFile file, u64 offset, rawptr buf, u64 len)
{ {
lseek(file, (isize)offset, SEEK_SET); lseek(file, (isize)offset, SEEK_SET);
return write(file, buf, (usize)len); return write(file, buf, (usize)len);
} }
static u64 pFileSeek(pFile file, u64 pos) static u64
pFileSeek(pFile file, u64 pos)
{ {
return (u64)lseek(file, (isize)pos, SEEK_SET); return (u64)lseek(file, (isize)pos, SEEK_SET);
} }
static u64 pFileLength(pFile file) static u64
pFileLength(pFile file)
{ {
isize offset = lseek(file, 0, SEEK_CUR); isize offset = lseek(file, 0, SEEK_CUR);
isize size = lseek(file, 0, SEEK_END); isize size = lseek(file, 0, SEEK_END);
@ -290,7 +308,8 @@ static u64 pFileLength(pFile file)
return (u64)size; return (u64)size;
} }
c8 **pDirGetFileNames(Arena *arena, u32 *count) c8 **
pDirGetFileNames(Arena *arena, u32 *count)
{ {
struct dirent *dir; struct dirent *dir;
@ -327,7 +346,8 @@ c8 **pDirGetFileNames(Arena *arena, u32 *count)
return (c8 **)file_names; return (c8 **)file_names;
} }
static b32 pFSIsVisible(c8 *name, b32 is_dir) static b32
pFSIsVisible(c8 *name, b32 is_dir)
{ {
b32 found = false; b32 found = false;
@ -350,17 +370,20 @@ static b32 pFSIsVisible(c8 *name, b32 is_dir)
return found; return found;
} }
static b32 pDirIsVisible(c8 *dir_name) static b32
pDirIsVisible(c8 *dir_name)
{ {
return pFSIsVisible(dir_name, true); return pFSIsVisible(dir_name, true);
} }
static b32 pFileIsVisible(c8 *file_name) static b32
pFileIsVisible(c8 *file_name)
{ {
return pFSIsVisible(file_name, false); return pFSIsVisible(file_name, false);
} }
static b32 pFileCanAccess(c8 *file_name, pFSAccess file_access) static b32
pFileCanAccess(c8 *file_name, pFSAccess file_access)
{ {
int a = 0; int a = 0;
if (BitEq(file_access, pFS_READ)) if (BitEq(file_access, pFS_READ))
@ -377,12 +400,14 @@ static b32 pFileCanAccess(c8 *file_name, pFSAccess file_access)
// ::Platform::Profiling::Functions::Start:: // ::Platform::Profiling::Functions::Start::
static u64 pOSTimerFreq() static u64
pOSTimerFreq()
{ {
return 1000000; return 1000000;
} }
static u64 pOSTimerRead() static u64
pOSTimerRead()
{ {
struct timeval value; struct timeval value;
gettimeofday(&value, 0); gettimeofday(&value, 0);
@ -390,7 +415,8 @@ static u64 pOSTimerRead()
return pOSTimerFreq() * u64(value.tv_sec) + u64(value.tv_usec); return pOSTimerFreq() * u64(value.tv_sec) + u64(value.tv_usec);
} }
static inline u64 pCPUTimerRead() static inline u64
pCPUTimerRead()
{ {
return __rdtsc(); return __rdtsc();
} }
@ -401,37 +427,44 @@ static inline u64 pCPUTimerRead()
// ::Platform::Atomics::Functions::Start:: // ::Platform::Atomics::Functions::Start::
static inline void pAtomicSignalFenceSeqCst() static inline void
pAtomicSignalFenceSeqCst()
{ {
__atomic_signal_fence(__ATOMIC_SEQ_CST); __atomic_signal_fence(__ATOMIC_SEQ_CST);
} }
static inline u32 pAtomicFetchSubU32(u32 volatile *ptr, u32 count) static inline u32
pAtomicFetchSubU32(u32 volatile *ptr, u32 count)
{ {
return __atomic_fetch_sub(ptr, count, __ATOMIC_ACQUIRE); return __atomic_fetch_sub(ptr, count, __ATOMIC_ACQUIRE);
} }
static inline u32 pAtomicFetchIncrU32(u32 volatile *ptr) static inline u32
pAtomicFetchIncrU32(u32 volatile *ptr)
{ {
return __atomic_fetch_add(ptr, (u32)1, __ATOMIC_ACQUIRE); return __atomic_fetch_add(ptr, (u32)1, __ATOMIC_ACQUIRE);
} }
static inline void pAtomicIncrU32(u32 volatile *ptr) static inline void
pAtomicIncrU32(u32 volatile *ptr)
{ {
__atomic_fetch_add(ptr, (u32)1, __ATOMIC_RELEASE); __atomic_fetch_add(ptr, (u32)1, __ATOMIC_RELEASE);
} }
static inline u32 pAtomicLoadU32(u32 volatile *ptr) static inline u32
pAtomicLoadU32(u32 volatile *ptr)
{ {
return __atomic_load_n(ptr, __ATOMIC_ACQUIRE); return __atomic_load_n(ptr, __ATOMIC_ACQUIRE);
} }
static inline void pAtomicStoreB32(b32 volatile *ptr, b32 value) static inline void
pAtomicStoreB32(b32 volatile *ptr, b32 value)
{ {
__atomic_store_n(ptr, value, __ATOMIC_RELEASE); __atomic_store_n(ptr, value, __ATOMIC_RELEASE);
} }
static inline b32 pAtomicCompareExchangeB32(b32 volatile *ptr, b32 *expected, b32 desired) static inline b32
pAtomicCompareExchangeB32(b32 volatile *ptr, b32 *expected, b32 desired)
{ {
return __atomic_compare_exchange_n(ptr, expected, desired, true, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED); return __atomic_compare_exchange_n(ptr, expected, desired, true, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED);
} }

66
src/platform/platform_windows.c
View File

@ -1,8 +1,16 @@
HINSTANCE win32_instance = {0}; // ::Platform::Windows::Globals::Start::
pPlatformWindow win32_window = {0};
b32 global_quit = false;
LRESULT CALLBACK WindowProc(HWND window, UINT message, WPARAM w_param, LPARAM l_param) HINSTANCE
g_Win32_Instance = {0};
pPlatformWindow
g_Win32_Window = {0};
b32
g_Global_Quit = false;
// ::Platform::Windows::Globals::End::
LRESULT CALLBACK
WindowProc(HWND window, UINT message, WPARAM w_param, LPARAM l_param)
{ {
LRESULT result = 0; LRESULT result = 0;
@ -11,15 +19,15 @@ LRESULT CALLBACK WindowProc(HWND window, UINT message, WPARAM w_param, LPARAM l_
case WM_SIZE: case WM_SIZE:
{ {
Printfln("Window resizing"); Printfln("Window resizing");
win32_window.w = LOWORD(l_param); g_Win32_Window.w = LOWORD(l_param);
win32_window.h = HIWORD(l_param); g_Win32_Window.h = HIWORD(l_param);
rResolutionSet(win32_window.w, win32_window.h); rResolutionSet(g_Win32_Window.w, g_Win32_Window.h);
} break; } break;
case WM_DESTROY: // TODO(MA): Probably handle these separately but for now, they're together case WM_DESTROY: // TODO(MA): Probably handle these separately but for now, they're together
case WM_CLOSE: case WM_CLOSE:
{ {
Printf("quitting"); Printf("quitting");
global_quit = true; g_Global_Quit = true;
} break; } break;
case WM_ACTIVATEAPP: case WM_ACTIVATEAPP:
{ {
@ -34,7 +42,8 @@ LRESULT CALLBACK WindowProc(HWND window, UINT message, WPARAM w_param, LPARAM l_
return result; return result;
} }
b32 pLibraryLoad(const char *name, pLibrary *out_lib) b32
pLibraryLoad(const char *name, pLibrary *out_lib)
{ {
b32 success = true; b32 success = true;
@ -45,7 +54,8 @@ b32 pLibraryLoad(const char *name, pLibrary *out_lib)
return success; return success;
} }
b32 pFunctionLoad(const char *name, pLibrary *lib, pFunction *out_fn) b32
pFunctionLoad(const char *name, pLibrary *lib, pFunction *out_fn)
{ {
b32 success = true; b32 success = true;
@ -56,26 +66,29 @@ b32 pFunctionLoad(const char *name, pLibrary *lib, pFunction *out_fn)
return success; return success;
} }
usize pPageSize() usize
pPageSize()
{ {
return 0; return 0;
} }
i32 _Write(void const *str, DWORD std_handle) i32
_Write(void const *str, DWORD std_handle)
{ {
DWORD written; DWORD written;
BOOL success = WriteFile(GetStdHandle(std_handle), str, StrLen(str), &written, NULL); BOOL success = WriteFile(GetStdHandle(std_handle), str, StrLen(str), &written, NULL);
return success ? (i32)written : -1; return success ? (i32)written : -1;
} }
b32 pWindowInit(const char *window_name) b32
pWindowInit(const char *window_name)
{ {
b32 success = true; b32 success = true;
WNDCLASS window_class = { WNDCLASS window_class = {
.style = CS_OWNDC|CS_HREDRAW|CS_VREDRAW, .style = CS_OWNDC|CS_HREDRAW|CS_VREDRAW,
.lpfnWndProc = WindowProc, .lpfnWndProc = WindowProc,
.hInstance = win32_instance, .hInstance = g_Win32_Instance,
.lpszClassName = WINDOW_CLASS_NAME, .lpszClassName = WINDOW_CLASS_NAME,
}; };
@ -96,25 +109,27 @@ b32 pWindowInit(const char *window_name)
CW_USEDEFAULT, CW_USEDEFAULT,
0, 0,
0, 0,
win32_instance, g_Win32_Instance,
0 0
); );
if (!window_handle) if (!window_handle)
success = false; success = false;
else else
win32_window.handle = window_handle; g_Win32_Window.handle = window_handle;
} }
return success; return success;
} }
pPlatformWindow *pWindowGet() pPlatformWindow *
pWindowGet()
{ {
return &win32_window; return &g_Win32_Window;
} }
void pWindowEventsGet() void
pWindowEventsGet()
{ {
BOOL has_msg = false; BOOL has_msg = false;
MSG message; MSG message;
@ -130,7 +145,8 @@ void pWindowEventsGet()
while (has_msg); while (has_msg);
} }
void pWindowEventWaitFor() void
pWindowEventWaitFor()
{ {
MSG message; MSG message;
BOOL message_result = GetMessageA(&message, 0, 0, 0); BOOL message_result = GetMessageA(&message, 0, 0, 0);
@ -141,14 +157,16 @@ void pWindowEventWaitFor()
} }
} }
b32 pWindowShouldQuit() b32
pWindowShouldQuit()
{ {
return global_quit; return g_Global_Quit;
} }
pWindowSize pWindowGetSize() pWindowSize
pWindowGetSize()
{ {
return (pWindowSize){ .w = win32_window.w, .h = win32_window.h }; return (pWindowSize){ .w = g_Win32_Window.w, .h = g_Win32_Window.h };
} }
// ::Platform::Windows::Includes::CFile:: // ::Platform::Windows::Includes::CFile::

57
src/platform/platform_windows_public.c
View File

@ -1,19 +1,22 @@
// ::Platform::Windows::Memory::Start:: // ::Platform::Windows::Memory::Start::
rawptr pMemAlloc(usize size) rawptr
pMemAlloc(usize size)
{ {
return (rawptr)VirtualAlloc(0, size, MEM_RESERVE|MEM_COMMIT, PAGE_READWRITE); return (rawptr)VirtualAlloc(0, size, MEM_RESERVE|MEM_COMMIT, PAGE_READWRITE);
} }
rawptr pMemAllocZeroed(usize size) rawptr
pMemAllocZeroed(usize size)
{ {
rawptr mem = pMemAlloc(size); rawptr mem = pMemAlloc(size);
MemZero(mem, size); MemZero(mem, size);
return mem; return mem;
} }
void pMemFree(rawptr ptr, usize size) void
pMemFree(rawptr ptr, usize size)
{ {
Assert(VirtualFree(ptr, size, MEM_RELEASE), "pMemFree failure"); Assert(VirtualFree(ptr, size, MEM_RELEASE), "pMemFree failure");
} }
@ -24,12 +27,14 @@ void pMemFree(rawptr ptr, usize size)
// ::Platform::Windows::Print::Start:: // ::Platform::Windows::Print::Start::
i32 pWriteStdOut(rawptr buf, i32 len) i32
pWriteStdOut(rawptr buf, i32 len)
{ {
return WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE), buf, len, NULL, NULL); return WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE), buf, len, NULL, NULL);
} }
i32 pWriteStdErr(rawptr buf, i32 len) i32
pWriteStdErr(rawptr buf, i32 len)
{ {
return WriteConsole(GetStdHandle(STD_ERROR_HANDLE), buf, len, NULL, NULL); return WriteConsole(GetStdHandle(STD_ERROR_HANDLE), buf, len, NULL, NULL);
} }
@ -40,7 +45,8 @@ i32 pWriteStdErr(rawptr buf, i32 len)
// ::Platform::Functions::Directory::Start:: // ::Platform::Functions::Directory::Start::
b32 pDirNavigate(c8 *dir) b32
pDirNavigate(c8 *dir)
{ {
return !(b32)SetCurrentDirectory(dir); return !(b32)SetCurrentDirectory(dir);
} }
@ -51,7 +57,8 @@ b32 pDirNavigate(c8 *dir)
// ::Platform::Windows::Profiling::Functions::Start:: // ::Platform::Windows::Profiling::Functions::Start::
static inline u64 pCPUTimerRead() static inline u64
pCPUTimerRead()
{ {
return __rdtsc(); return __rdtsc();
} }
@ -62,7 +69,8 @@ static inline u64 pCPUTimerRead()
// ::Platform::Windows::Async::Start:: // ::Platform::Windows::Async::Start::
static pThread pThreadInit(rawptr proc, rawptr param) static pThread
pThreadInit(rawptr proc, rawptr param)
{ {
pThread thread = {0}; pThread thread = {0};
CreateThread(NULL, 0, proc, param, 0, NULL); CreateThread(NULL, 0, proc, param, 0, NULL);
@ -70,17 +78,20 @@ static pThread pThreadInit(rawptr proc, rawptr param)
return thread; return thread;
} }
static void pThreadSuspend(pThread *thread) static void
pThreadSuspend(pThread *thread)
{ {
SuspendThread(thread->handle); SuspendThread(thread->handle);
} }
static void pThreadWake(pThread *thread) static void
pThreadWake(pThread *thread)
{ {
ResumeThread(thread->handle); ResumeThread(thread->handle);
} }
static void pThreadKill() static void
pThreadKill()
{ {
ExitThread(0); ExitThread(0);
} }
@ -92,38 +103,45 @@ static void pThreadKill()
// ::Platform::Windows::Atomics::Start:: // ::Platform::Windows::Atomics::Start::
static inline void pAtomicSignalFenceSeqCst() static inline void
pAtomicSignalFenceSeqCst()
{ {
_ReadWriteBarrier(); _ReadWriteBarrier();
} }
static inline u32 pAtomicFetchSubU32(u32 volatile *ptr, u32 count) static inline u32
pAtomicFetchSubU32(u32 volatile *ptr, u32 count)
{ {
LONG decrement = (LONG)count; LONG decrement = (LONG)count;
return (u32)InterlockedAddAcquire((LONG volatile *)ptr, -decrement) + decrement; return (u32)InterlockedAddAcquire((LONG volatile *)ptr, -decrement) + decrement;
} }
static inline u32 pAtomicFetchIncrU32(u32 volatile *ptr) static inline u32
pAtomicFetchIncrU32(u32 volatile *ptr)
{ {
return (u32)InterlockedIncrementAcquire((LONG volatile *)ptr) - 1; return (u32)InterlockedIncrementAcquire((LONG volatile *)ptr) - 1;
} }
static inline void pAtomicIncrU32(u32 volatile *ptr) static inline void
pAtomicIncrU32(u32 volatile *ptr)
{ {
InterlockedIncrementRelease((LONG volatile *)ptr); InterlockedIncrementRelease((LONG volatile *)ptr);
} }
static inline u32 pAtomicLoadU32(u32 volatile *ptr) static inline u32
pAtomicLoadU32(u32 volatile *ptr)
{ {
return (u32)InterlockedOrAcquire((LONG volatile *)ptr, 0); return (u32)InterlockedOrAcquire((LONG volatile *)ptr, 0);
} }
static inline void pAtomicStoreB32(b32 volatile *ptr, b32 value) static inline void
pAtomicStoreB32(b32 volatile *ptr, b32 value)
{ {
_InterlockedExchange_HLERelease((LONG volatile *)ptr, (LONG)value); _InterlockedExchange_HLERelease((LONG volatile *)ptr, (LONG)value);
} }
static inline b32 pAtomicCompareExchangeB32(b32 volatile *ptr, b32 *expect, b32 desired) static inline b32
pAtomicCompareExchangeB32(b32 volatile *ptr, b32 *expect, b32 desired)
{ {
return (b32)InterlockedCompareExchangeAcquire((LONG volatile *)ptr, (LONG)desired, (LONG)*expect); return (b32)InterlockedCompareExchangeAcquire((LONG volatile *)ptr, (LONG)desired, (LONG)*expect);
} }
@ -134,7 +152,8 @@ static inline b32 pAtomicCompareExchangeB32(b32 volatile *ptr, b32 *expect, b32
// ::Platform::Windows::Files::Start:: // ::Platform::Windows::Files::Start::
static b8 pDirIsVisible(c8 *dir_name) static b8
pDirIsVisible(c8 *dir_name)
{ {
WIN32_FIND_DATA find_data; WIN32_FIND_DATA find_data;
HANDLE handle; HANDLE handle;

423
src/renderer_vulkan.c
View File

File diff suppressed because it is too large Load Diff

12
src/renderer_vulkan.h
View File

@ -38,9 +38,9 @@ static char *vulkan_libs[] = {
#endif #endif
#define VERTEX_BUFFER_CAP MB(32) constexpr u64 VERTEX_BUFFER_CAP = MB(32);
#define INDEX_BUFFER_CAP MB(8) constexpr u64 INDEX_BUFFER_CAP = MB(8);
#define TRANSFER_BUFFER_CAP MB(64) constexpr u64 TRANSFER_BUFFER_CAP = MB(64);
// ::Vulkan::Macros::Header:: // ::Vulkan::Macros::Header::
@ -578,9 +578,9 @@ static vTransfer *vMeshTransferInit(Arena *arena, u32 asset_id, vMeshBuffer *mes
static vTransfer *vBufferTransferInit(Arena *arena, u32 asset_id, vBuffer *index, rawptr bytes, u64 size); static vTransfer *vBufferTransferInit(Arena *arena, u32 asset_id, vBuffer *index, rawptr bytes, u64 size);
static VkResult vBufferCreate(vBuffer* buf, rRenderBufferType type, u64 size); static VkResult vBufferCreate(vBuffer* buf, rRenderBufferType type, u64 size);
static rawptr vMapBuffer(VmaAllocation alloc); static rawptr vMapBuffer(VmaAllocation alloc);
static void vModelPush(ModelAsset asset_id, vModelBuffers *buffer); static void vModelPush(c8 *name, vModelBuffers *buffer);
static vModelBuffers *vModelPop(ModelAsset asset_id); static vModelBuffers *vModelPop(c8 *name);
static vModelBuffers *vModelSearch(ModelAsset asset_id); static vModelBuffers *vModelSearch(c8 *name);
// ::Vulkan::CleanUp::Functions::Header:: // ::Vulkan::CleanUp::Functions::Header::

64
src/renderer_vulkan_public.c
View File

@ -1,6 +1,7 @@
// ::Vulkan::Renderer::Initialization::Functions::Start:: // ::Vulkan::Renderer::Initialization::Functions::Start::
b32 rInit() b32
rInit()
{ {
vArenasInit(); vArenasInit();
vCustomizePipelines(); vCustomizePipelines();
@ -34,7 +35,8 @@ b32 rInit()
return true; return true;
} }
void rDestroy() void
rDestroy()
{ {
VkDevice device = v_Renderer.handles.device; VkDevice device = v_Renderer.handles.device;
VkInstance instance = v_Renderer.handles.inst; VkInstance instance = v_Renderer.handles.inst;
@ -119,7 +121,8 @@ void rDestroy()
// ::Vulkan::Renderer::Buffers::Functions::Start:: // ::Vulkan::Renderer::Buffers::Functions::Start::
static rDescHandle rTextureLoad(TextureAsset asset_id) static rDescHandle
rTextureLoad(TextureAsset asset_id)
{ {
rDescHandle handle = vDescHandleSearch(vDT_SAMPLED_IMAGE, asset_id); rDescHandle handle = vDescHandleSearch(vDT_SAMPLED_IMAGE, asset_id);
@ -152,7 +155,8 @@ static rDescHandle rTextureLoad(TextureAsset asset_id)
return handle; return handle;
} }
static rDescHandle rMeshLoad(ModelAsset asset_id) static rDescHandle
rMeshLoad(ModelAsset asset_id)
{ {
rDescHandle handle = vDescHandleSearch(vDT_MESH, asset_id); rDescHandle handle = vDescHandleSearch(vDT_MESH, asset_id);
@ -193,7 +197,8 @@ static rDescHandle rMeshLoad(ModelAsset asset_id)
return handle; return handle;
} }
static void rTextureUnload(rDescHandle current_handle) static void
rTextureUnload(rDescHandle current_handle)
{ {
rDescHandle handle = vDescHandleSearch(vDT_SAMPLED_IMAGE, current_handle.asset_id); rDescHandle handle = vDescHandleSearch(vDT_SAMPLED_IMAGE, current_handle.asset_id);
@ -205,7 +210,8 @@ static void rTextureUnload(rDescHandle current_handle)
} }
} }
static void rBufferBindVertex(rRenderBuffer *buffer) static void
rBufferBindVertex(rRenderBuffer *buffer)
{ {
Assert(buffer && buffer->type == rRBT_VERTEX, "rBufferBindVertex: invalid buffer provided"); Assert(buffer && buffer->type == rRBT_VERTEX, "rBufferBindVertex: invalid buffer provided");
@ -215,7 +221,8 @@ static void rBufferBindVertex(rRenderBuffer *buffer)
vkCmdBindVertexBuffers(cmd, 0, 1, &buffer->buffer, &offsets); vkCmdBindVertexBuffers(cmd, 0, 1, &buffer->buffer, &offsets);
} }
static void rBufferBindIndex(rRenderBuffer *buffer) static void
rBufferBindIndex(rRenderBuffer *buffer)
{ {
Assert(buffer && buffer->type == rRBT_INDEX, "rBufferBindIndex: invalid buffer provided"); Assert(buffer && buffer->type == rRBT_INDEX, "rBufferBindIndex: invalid buffer provided");
@ -224,7 +231,8 @@ static void rBufferBindIndex(rRenderBuffer *buffer)
vkCmdBindIndexBuffer(cmd, buffer->buffer, 0, VK_INDEX_TYPE_UINT32); vkCmdBindIndexBuffer(cmd, buffer->buffer, 0, VK_INDEX_TYPE_UINT32);
} }
static void vBufferQueueWait() static void
vBufferQueueWait()
{ {
while (!JobQueueCompleted(&v_Renderer.upload.job_queue)) while (!JobQueueCompleted(&v_Renderer.upload.job_queue))
{ {
@ -233,17 +241,20 @@ static void vBufferQueueWait()
} }
} }
static rawptr rBufferGUIVertMapping() static rawptr
rBufferGUIVertMapping()
{ {
return v_Renderer.buffers.gui_vert.ptr; return v_Renderer.buffers.gui_vert.ptr;
} }
static rawptr rBufferGUIIdxMapping() static rawptr
rBufferGUIIdxMapping()
{ {
return v_Renderer.buffers.gui_idx.ptr; return v_Renderer.buffers.gui_idx.ptr;
} }
static void rBufferBindGUIVertex() static void
rBufferBindGUIVertex()
{ {
VkCommandBuffer cmd = vFrameCmdBuf(); VkCommandBuffer cmd = vFrameCmdBuf();
VkDeviceSize offsets = 0; VkDeviceSize offsets = 0;
@ -252,7 +263,8 @@ static void rBufferBindGUIVertex()
vkCmdBindVertexBuffers(cmd, 0, 1, &buffer, &offsets); vkCmdBindVertexBuffers(cmd, 0, 1, &buffer, &offsets);
} }
static void rBufferBindGUIIndex() static void
rBufferBindGUIIndex()
{ {
VkCommandBuffer cmd = vFrameCmdBuf(); VkCommandBuffer cmd = vFrameCmdBuf();
VkBuffer buffer = v_Renderer.buffers.gui_idx.alloc.buffer; VkBuffer buffer = v_Renderer.buffers.gui_idx.alloc.buffer;
@ -260,12 +272,12 @@ static void rBufferBindGUIIndex()
vkCmdBindIndexBuffer(cmd, buffer, 0, VK_INDEX_TYPE_UINT32); vkCmdBindIndexBuffer(cmd, buffer, 0, VK_INDEX_TYPE_UINT32);
} }
static void rBufferBindMesh(rPushConst *pc, rDescHandle handle) static void
rBufferBindMesh(rPushConst *pc, rDescHandle handle)
{ {
vModelBuffers *buffers = vModelSearch(handle.asset_id); vModelBuffers *buffers = vModelSearch(handle.asset_id);
if (buffers != NULL) if (buffers != NULL)
{ {
Printfln("binding index buffer");
vkCmdBindIndexBuffer(vFrameCmdBuf(), buffers->index->buffer, 0, VK_INDEX_TYPE_UINT32); vkCmdBindIndexBuffer(vFrameCmdBuf(), buffers->index->buffer, 0, VK_INDEX_TYPE_UINT32);
} }
} }
@ -277,18 +289,21 @@ static void rBufferBindMesh(rPushConst *pc, rDescHandle handle)
// ::Vulkan::Renderer::Uniforms::Functions::Start:: // ::Vulkan::Renderer::Uniforms::Functions::Start::
// ::Vulkan::Renderer::PushConstants::Functions::Start:: // ::Vulkan::Renderer::PushConstants::Functions::Start::
static void rViewportSize(Vec2 *size) static void
rViewportSize(Vec2 *size)
{ {
size->x = (f32)v_Renderer.state.swapchain.extent.width; size->x = (f32)v_Renderer.state.swapchain.extent.width;
size->y = (f32)v_Renderer.state.swapchain.extent.height; size->y = (f32)v_Renderer.state.swapchain.extent.height;
} }
static void rGlobalUniformSet(rShaderGlobals *globals) static void
rGlobalUniformSet(rShaderGlobals *globals)
{ {
} }
static void rPushConstantsSet(rPushConst *pc) static void
rPushConstantsSet(rPushConst *pc)
{ {
VkCommandBuffer cmd = vFrameCmdBuf(); VkCommandBuffer cmd = vFrameCmdBuf();
@ -307,7 +322,8 @@ static void rPushConstantsSet(rPushConst *pc)
// ::Vulkan::Renderer::Config::Functions::Start:: // ::Vulkan::Renderer::Config::Functions::Start::
static void rResolutionSet(u32 x, u32 y) static void
rResolutionSet(u32 x, u32 y)
{ {
v_Renderer.state.renderer.width = x; v_Renderer.state.renderer.width = x;
v_Renderer.state.renderer.height = y; v_Renderer.state.renderer.height = y;
@ -319,7 +335,8 @@ static void rResolutionSet(u32 x, u32 y)
// ::Vulkan::Renderer::Rendering::Functions::Start:: // ::Vulkan::Renderer::Rendering::Functions::Start::
b32 rFrameBegin() b32
rFrameBegin()
{ {
b32 success = true; b32 success = true;
VkResult result; VkResult result;
@ -399,7 +416,8 @@ b32 rFrameBegin()
return success; return success;
} }
b32 rFrameFinish() b32
rFrameFinish()
{ {
b32 success = true; b32 success = true;
VkResult result; VkResult result;
@ -502,14 +520,16 @@ b32 rFrameFinish()
return success; return success;
} }
static void rDrawIndexed(u32 index_count, u32 instance_count) static void
rDrawIndexed(u32 index_count, u32 instance_count)
{ {
VkCommandBuffer cmd = vFrameCmdBuf(); VkCommandBuffer cmd = vFrameCmdBuf();
vkCmdDrawIndexed(cmd, index_count, instance_count, 0, 0, 0); vkCmdDrawIndexed(cmd, index_count, instance_count, 0, 0, 0);
} }
static void rPipelineBind(rPipelineHandle handle, rPipelineType type) static void
rPipelineBind(rPipelineHandle handle, rPipelineType type)
{ {
VkCommandBuffer cmd = vFrameCmdBuf(); VkCommandBuffer cmd = vFrameCmdBuf();

2
src/shared_types.h
View File

@ -50,7 +50,7 @@ typedef void * rawptr;
typedef struct String8 typedef struct String8
{ {
u8 *value; c8 *value;
u64 len; u64 len;
} String8; } String8;

9
src/tests.c
View File

@ -1,12 +1,14 @@
// TODO: Make the tests actually decent // TODO: Make the tests actually decent
void RunTests() void
RunTests()
{ {
TestFreeListAlloc(); TestFreeListAlloc();
TestHashTable(); TestHashTable();
} }
void TestFreeListAlloc() void
TestFreeListAlloc()
{ {
Printfln("Starting free list allocator tests..."); Printfln("Starting free list allocator tests...");
@ -51,7 +53,8 @@ void TestFreeListAlloc()
} }
} }
void TestHashTable() void
TestHashTable()
{ {
Printfln("Starting hash table tests..."); Printfln("Starting hash table tests...");
HashTable table; HashTable table;

170
src/util.c
View File

@ -1,6 +1,7 @@
// ::Util::Globals::Start:: // ::Util::Globals::Start::
static Profiler GLOBAL_PROFILER; static Profiler
g_Global_Profiler;
// ::Util::Globals::End:: // ::Util::Globals::End::
@ -8,7 +9,9 @@ static Profiler GLOBAL_PROFILER;
// ::Util::Strings::Functions::Start:: // ::Util::Strings::Functions::Start::
static void StrConcat(c8 *str, c8 *append)
static void
StrConcat(c8 *str, c8 *append)
{ {
u32 len = StrLen(str); u32 len = StrLen(str);
u32 i = 0; u32 i = 0;
@ -20,12 +23,22 @@ static void StrConcat(c8 *str, c8 *append)
str[i] = '\0'; str[i] = '\0';
} }
b32 StrEq(const char *l, const char *r) { static b32
StrEqL(const char *l, const char *r, u64 len)
{
for (u64 i = 0; *l == *r && *l && i < len; l++, r++, i++);
return *l == *r;
}
static b32
StrEq(const char *l, const char *r)
{
for (; *l == *r && *l; l++, r++); for (; *l == *r && *l; l++, r++);
return *l == '\0' && *r == '\0'; return *l == '\0' && *r == '\0';
} }
u32 StrLen(const char *str) static u32
StrLen(const char *str)
{ {
const char *start; const char *start;
@ -35,23 +48,88 @@ u32 StrLen(const char *str)
return (u32)(str - start); return (u32)(str - start);
} }
i32 SPrintf(char *buf, rawptr fmt, ...) static i32
SPrintf(char *buf, int len, rawptr fmt, ...)
{ {
va_list arg; va_list arg;
va_start(arg, fmt); va_start(arg, fmt);
int sprf_res = stbsp_vsnprintf(buf, sizeof(buf), fmt, arg); int sprf_res = stbsp_vsnprintf(buf, len, fmt, arg);
va_end(arg); va_end(arg);
return sprf_res; return sprf_res;
} }
String8 MakeString8(u8 *str, u64 len) static String8
MakeString8(c8 *str, u64 len)
{ {
return (String8){ .len = len, .value = str }; return (String8){ .len = len, .value = str };
} }
String8 PreSplitString8(String8 string, String8 delimiter) static String8
String8Concat(Arena *arena, String8 string, String8 append)
{
u64 str_len = string.len + append.len;
String8 str = {
.value = MakeArray(arena, c8, str_len),
.len = str_len,
};
MemCpy(str.value, string.value, string.len);
MemCpy(str.value+string.len, append.value, append.len);
return str;
}
static void
String8TrimSuffix(String8 *str, c8 delimiter)
{
if (!str || str->len == 0) return;
for (i64 i = i64(str->len)-1; i > 0; i -= 1)
{
if (str->value[i] == delimiter)
{
str->value[i] = '\0';
str->len = i == 0 ? 0 : u64(i - 1);
break;
}
}
}
static i64
String8FindLast(String8 str, c8 delimiter)
{
if (str.len == 0) return -1;
i64 result = 1;
for (i64 i = i64(str.len)-1; i >= 0; i -= 1)
{
if (str.value[i] == delimiter)
{
result = i;
break;
}
}
return result;
}
static b32
String8Eq(String8 l, String8 r)
{
return StrEqL(l.value, r.value, l.len);
}
static b32
String8StartsWith(String8 string, String8 cmp)
{
return StrEqL(string.value, cmp.value, cmp.len);
}
static String8
PreSplitString8(String8 string, String8 delimiter)
{ {
if (string.len == 0 || delimiter.len == 0) return string; if (string.len == 0 || delimiter.len == 0) return string;
@ -76,7 +154,8 @@ String8 PreSplitString8(String8 string, String8 delimiter)
return (String8){ .len = new_len, .value = string.value }; return (String8){ .len = new_len, .value = string.value };
} }
String8 PreSplitNewString8(Arena *arena, String8 string, String8 delimiter) static String8
PreSplitNewString8(Arena *arena, String8 string, String8 delimiter)
{ {
String8 result = PreSplitString8(string, delimiter); String8 result = PreSplitString8(string, delimiter);
@ -96,7 +175,8 @@ String8 PreSplitNewString8(Arena *arena, String8 string, String8 delimiter)
// ::Util::Memory::Functions::Start:: // ::Util::Memory::Functions::Start::
void MemZero(void *ptr, isize size) void
MemZero(void *ptr, isize size)
{ {
if (!size || !ptr) return; if (!size || !ptr) return;
@ -129,7 +209,8 @@ void MemZero(void *ptr, isize size)
} }
} }
void MemCpy(rawptr dst, rawptr src, usize size) void
MemCpy(rawptr dst, rawptr src, usize size)
{ {
if (size == 0) return; if (size == 0) return;
@ -189,9 +270,10 @@ DefMathImpl(Abs);
// ::Util::Hashing::Functions::Start:: // ::Util::Hashing::Functions::Start::
u64 static inline HashFromString(String8 string) u64 static inline
HashFromString(String8 string)
{ {
return XXH3_64bits(string.value, string.len); return XXH3_64bits_withSeed(string.value, string.len, HASH_SEED);
} }
// ::Util::Hashing::Functions::End:: // ::Util::Hashing::Functions::End::
@ -200,7 +282,8 @@ u64 static inline HashFromString(String8 string)
// ::Util::Print::Functions::Start:: // ::Util::Print::Functions::Start::
i32 Printf(char *fmt, ...) i32
Printf(char *fmt, ...)
{ {
va_list arg; va_list arg;
@ -211,7 +294,8 @@ i32 Printf(char *fmt, ...)
return result; return result;
} }
i32 Printfln(char *fmt, ...) i32
Printfln(char *fmt, ...)
{ {
va_list arg; va_list arg;
@ -222,7 +306,8 @@ i32 Printfln(char *fmt, ...)
return result; return result;
} }
i32 EPrintf(char *fmt, ...) i32
EPrintf(char *fmt, ...)
{ {
va_list arg; va_list arg;
@ -233,12 +318,14 @@ i32 EPrintf(char *fmt, ...)
return result; return result;
} }
i32 EPrint(void *str) i32
EPrint(void *str)
{ {
return pWriteStdErr(str, (isize)StrLen(str)); return pWriteStdErr(str, (isize)StrLen(str));
} }
i32 _EPrintf(char *fmt, va_list arg) i32
_EPrintf(char *fmt, va_list arg)
{ {
char buffer[1024]; char buffer[1024];
@ -249,7 +336,8 @@ i32 _EPrintf(char *fmt, va_list arg)
return EPrint(&buffer); return EPrint(&buffer);
} }
i32 _Printf(char *fmt, va_list arg) i32
_Printf(char *fmt, va_list arg)
{ {
char buffer[1024]; char buffer[1024];
@ -264,7 +352,8 @@ i32 _Printf(char *fmt, va_list arg)
return pr_res; return pr_res;
} }
i32 _Printfln(char *fmt, va_list arg) i32
_Printfln(char *fmt, va_list arg)
{ {
char buffer[1024]; char buffer[1024];
@ -291,18 +380,20 @@ i32 _Printfln(char *fmt, va_list arg)
// ::Util::Profiling::Functions::Start:: // ::Util::Profiling::Functions::Start::
static inline void StartProfileBlock(ProfileBlock *block, c8 *label, u32 anchor_index) static inline void
StartProfileBlock(ProfileBlock *block, c8 *label, u32 anchor_index)
{ {
block->anchor_index = anchor_index; block->anchor_index = anchor_index;
block->label = label; block->label = label;
block->start_tsc = pCPUTimerRead(); block->start_tsc = pCPUTimerRead();
} }
static inline void EndProfileBlock(ProfileBlock *block) static inline void
EndProfileBlock(ProfileBlock *block)
{ {
u64 elapsed = pCPUTimerRead() - block->start_tsc; u64 elapsed = pCPUTimerRead() - block->start_tsc;
ProfileAnchor *anchor = GLOBAL_PROFILER.anchors + block->anchor_index; ProfileAnchor *anchor = g_Global_Profiler.anchors + block->anchor_index;
anchor->tsc_elapsed += elapsed; anchor->tsc_elapsed += elapsed;
anchor->hit_count += 1; anchor->hit_count += 1;
anchor->label = block->label; anchor->label = block->label;
@ -314,35 +405,41 @@ static inline void EndProfileBlock(ProfileBlock *block)
// ::Util::Async::Functions::Start:: // ::Util::Async::Functions::Start::
static inline b32 MutTryLock(Mut *mut) static inline b32
MutTryLock(Mut *mut)
{ {
b32 lock = false; b32 lock = false;
return pAtomicCompareExchangeB32(&mut->lock, &lock, 1); return pAtomicCompareExchangeB32(&mut->lock, &lock, 1);
} }
static inline void MutUnlock(Mut *mut) static inline void
MutUnlock(Mut *mut)
{ {
pAtomicStoreB32(&mut->lock, 0); pAtomicStoreB32(&mut->lock, 0);
} }
static inline void TicketMutInit(TicketMut *mut) static inline void
TicketMutInit(TicketMut *mut)
{ {
mut->ticket = 0; mut->ticket = 0;
mut->next_ticket = 1; mut->next_ticket = 1;
} }
static inline void TicketMutLock(TicketMut *mut) static inline void
TicketMutLock(TicketMut *mut)
{ {
u32 ticket = pAtomicFetchIncrU32(&mut->ticket); u32 ticket = pAtomicFetchIncrU32(&mut->ticket);
while (ticket != mut->next_ticket); while (ticket != mut->next_ticket);
} }
static inline void TicketMutUnlock(TicketMut *mut) static inline void
TicketMutUnlock(TicketMut *mut)
{ {
pAtomicIncrU32(&mut->next_ticket); pAtomicIncrU32(&mut->next_ticket);
} }
static inline u32 JobQueueAdd(JobQueue *queue, u32 count) static inline u32
JobQueueAdd(JobQueue *queue, u32 count)
{ {
u32 job_idx = pAtomicFetchIncrU32(&queue->queued); u32 job_idx = pAtomicFetchIncrU32(&queue->queued);
pAtomicFetchIncrU32(&queue->remaining); pAtomicFetchIncrU32(&queue->remaining);
@ -350,30 +447,35 @@ static inline u32 JobQueueAdd(JobQueue *queue, u32 count)
return job_idx; return job_idx;
} }
static inline u32 JobQueueGetCount(JobQueue *queue) static inline u32
JobQueueGetCount(JobQueue *queue)
{ {
return pAtomicLoadU32(&queue->queued); return pAtomicLoadU32(&queue->queued);
} }
static inline void JobQueueMarkUnqueued(JobQueue *queue, u32 count) static inline void
JobQueueMarkUnqueued(JobQueue *queue, u32 count)
{ {
Assert(queue->queued != 0, "queue queued is 0 before trying to mark dequeued"); Assert(queue->queued != 0, "queue queued is 0 before trying to mark dequeued");
pAtomicFetchSubU32(&queue->queued, count); pAtomicFetchSubU32(&queue->queued, count);
} }
static inline void JobQueueMarkCompleted(JobQueue *queue, u32 count) static inline void
JobQueueMarkCompleted(JobQueue *queue, u32 count)
{ {
Assert(queue->remaining != 0, "queue remaining is 0 before trying to mark completed"); Assert(queue->remaining != 0, "queue remaining is 0 before trying to mark completed");
pAtomicFetchSubU32(&queue->remaining, count); pAtomicFetchSubU32(&queue->remaining, count);
} }
static inline void JobQueueReset(JobQueue *queue) static inline void
JobQueueReset(JobQueue *queue)
{ {
pAtomicFetchSubU32(&queue->queued, queue->queued); pAtomicFetchSubU32(&queue->queued, queue->queued);
pAtomicFetchSubU32(&queue->remaining, queue->remaining); pAtomicFetchSubU32(&queue->remaining, queue->remaining);
} }
static inline b32 JobQueueCompleted(JobQueue *queue) static inline b32
JobQueueCompleted(JobQueue *queue)
{ {
u32 remaining = pAtomicLoadU32(&queue->remaining); u32 remaining = pAtomicLoadU32(&queue->remaining);
return remaining == 0; return remaining == 0;

29
src/util.h
View File

@ -136,25 +136,30 @@ arr.cap = len
// ::Util::String8::Macros:: // ::Util::String8::Macros::
#define String8Array(v, c) MakeString8((u8 *)(v), sizeof(*(v))*(c)) #define String8Array(v, c) MakeString8((c8 *)(v), sizeof(*(v))*(c))
#define String8Struct(v) MakeString8((u8 *)(v), sizeof(*(v))) #define String8Struct(v) MakeString8((c8 *)(v), sizeof(*(v)))
#define String8CStr(v) MakeString8((u8 *)v, StrLen(v)) #define String8CStr(v) MakeString8((c8 *)v, StrLen(v))
// ::Util::Defines::Header:: // ::Util::Defines::Header::
#define HM_MAX_SYMBOLS 256 constexpr u32 HM_MAX_SYMBOLS = 256;
#define DEFAULT_ALIGNMENT (2*sizeof(rawptr)) constexpr usize DEFAULT_ALIGNMENT = (2*sizeof(rawptr));
#define HASH_SEED 5995 constexpr u64 HASH_SEED = 5995;
// ::Util::Strings::Functions::Header:: // ::Util::Strings::Functions::Header::
String8 MakeString8(u8 *str, u64 len); static b32 String8Eq(String8 l, String8 r);
u32 StrLen(const char *str); static u32 StrLen(const char *str);
b32 StrEq(const char *l, const char *r); static b32 StrEqL(const char *l, const char *r, u64 len);
i32 SPrintf(char *buf, rawptr fmt, ...); static b32 StrEq(const char *l, const char *r);
String8 PreSplitString8(String8 string, String8 delimiter); static i32 SPrintf(char *buf, int len, rawptr fmt, ...);
String8 PreSplitNewString8(Arena *arena, String8 string, String8 delimiter);
static void StrConcat(c8 *str, c8 *append); static void StrConcat(c8 *str, c8 *append);
static String8 MakeString8(c8 *str, u64 len);
static String8 String8Concat(Arena *arena, String8 string, String8 append);
static void String8TrimSuffix(String8 *str, c8 delimiter);
static i64 String8FindLast(String8 str, c8 delimiter);
static String8 PreSplitString8(String8 string, String8 delimiter);
static String8 PreSplitNewString8(Arena *arena, String8 string, String8 delimiter);
// ::Util::Memory::Functions::Header:: // ::Util::Memory::Functions::Header::

306
src/vulkan_config.c
View File

@ -1,12 +1,14 @@
// VULKAN CONFIG // VULKAN CONFIG
static const VkFormat VK_IMAGE_FORMATS[] = { static const VkFormat
VK_IMAGE_FORMATS[] = {
VK_FORMAT_R16G16B16A16_UNORM, VK_FORMAT_R16G16B16A16_UNORM,
VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_R8G8B8A8_UNORM,
}; };
static VkApplicationInfo app_info = { static VkApplicationInfo
g_App_Info = {
.sType = STYPE(APPLICATION_INFO), .sType = STYPE(APPLICATION_INFO),
.pApplicationName = "Video Game", .pApplicationName = "Video Game",
.applicationVersion = VK_MAKE_API_VERSION(0, 0, 0, 1), .applicationVersion = VK_MAKE_API_VERSION(0, 0, 0, 1),
@ -15,14 +17,18 @@ static VkApplicationInfo app_info = {
.apiVersion = VK_API_VERSION_1_3, .apiVersion = VK_API_VERSION_1_3,
}; };
static const char *instance_layers[] = { static const char *
instance_layers[] =
{
#ifdef BUILD_DEBUG #ifdef BUILD_DEBUG
"VK_LAYER_KHRONOS_validation" "VK_LAYER_KHRONOS_validation"
#endif #endif
}; };
static const char *instance_extensions[] = { static const char *
g_Instance_Extensions[] =
{
VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_SURFACE_EXTENSION_NAME,
#ifdef __linux__ #ifdef __linux__
@ -36,25 +42,30 @@ static const char *instance_extensions[] = {
#ifdef BUILD_DEBUG #ifdef BUILD_DEBUG
VK_EXT_DEBUG_UTILS_EXTENSION_NAME, VK_EXT_DEBUG_UTILS_EXTENSION_NAME,
#endif #endif
}; };
static VkInstanceCreateInfo inst_info = { static VkInstanceCreateInfo
g_Instance_Info =
{
.sType = STYPE(INSTANCE_CREATE_INFO), .sType = STYPE(INSTANCE_CREATE_INFO),
.pApplicationInfo = &app_info, .pApplicationInfo = &g_App_Info,
.enabledLayerCount = sizeof(instance_layers) / sizeof(char *), .enabledLayerCount = sizeof(instance_layers) / sizeof(char *),
.ppEnabledLayerNames = instance_layers, .ppEnabledLayerNames = instance_layers,
.enabledExtensionCount = sizeof(instance_extensions) / sizeof(char *), .enabledExtensionCount = sizeof(g_Instance_Extensions) / sizeof(char *),
.ppEnabledExtensionNames = instance_extensions, .ppEnabledExtensionNames = g_Instance_Extensions,
}; };
const char *device_extensions[] = { const char *
g_Device_Extensions[] =
{
VK_KHR_SWAPCHAIN_EXTENSION_NAME, VK_KHR_SWAPCHAIN_EXTENSION_NAME,
VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME, VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME,
}; };
#ifdef BUILD_DEBUG #ifdef BUILD_DEBUG
static VkDebugUtilsMessengerCreateInfoEXT debug_msg_info = { static VkDebugUtilsMessengerCreateInfoEXT
g_Debug_Message_Info =
{
.sType = STYPE(DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT), .sType = STYPE(DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT),
.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT | .messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT |
VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT, VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT,
@ -65,15 +76,19 @@ static VkDebugUtilsMessengerCreateInfoEXT debug_msg_info = {
}; };
#endif #endif
static VkPhysicalDeviceVulkan13Features vk_13_features = { static VkPhysicalDeviceVulkan13Features
g_Vk_13_Features =
{
.sType = STYPE(PHYSICAL_DEVICE_VULKAN_1_3_FEATURES), .sType = STYPE(PHYSICAL_DEVICE_VULKAN_1_3_FEATURES),
.synchronization2 = VK_TRUE, .synchronization2 = VK_TRUE,
.dynamicRendering = VK_TRUE .dynamicRendering = VK_TRUE
}; };
static VkPhysicalDeviceVulkan12Features vk_12_features = { static VkPhysicalDeviceVulkan12Features
g_Vk_12_Features =
{
.sType = STYPE(PHYSICAL_DEVICE_VULKAN_1_2_FEATURES), .sType = STYPE(PHYSICAL_DEVICE_VULKAN_1_2_FEATURES),
.pNext = &vk_13_features, .pNext = &g_Vk_13_Features,
.descriptorIndexing = VK_TRUE, .descriptorIndexing = VK_TRUE,
.bufferDeviceAddress = VK_TRUE, .bufferDeviceAddress = VK_TRUE,
.descriptorBindingUniformBufferUpdateAfterBind = VK_TRUE, .descriptorBindingUniformBufferUpdateAfterBind = VK_TRUE,
@ -86,14 +101,18 @@ static VkPhysicalDeviceVulkan12Features vk_12_features = {
.runtimeDescriptorArray = VK_TRUE, .runtimeDescriptorArray = VK_TRUE,
}; };
static VkPhysicalDeviceVulkan11Features vk_11_features = { static VkPhysicalDeviceVulkan11Features
g_Vk_11_Features =
{
.sType = STYPE(PHYSICAL_DEVICE_VULKAN_1_1_FEATURES), .sType = STYPE(PHYSICAL_DEVICE_VULKAN_1_1_FEATURES),
.pNext = &vk_12_features .pNext = &g_Vk_12_Features
}; };
static const VkPhysicalDeviceFeatures2 vk_features_2 = { static const VkPhysicalDeviceFeatures2
g_Vk_Features_2 =
{
.sType = STYPE(PHYSICAL_DEVICE_FEATURES_2), .sType = STYPE(PHYSICAL_DEVICE_FEATURES_2),
.pNext = &vk_11_features, .pNext = &g_Vk_11_Features,
.features = { .features = {
.shaderUniformBufferArrayDynamicIndexing = VK_TRUE, .shaderUniformBufferArrayDynamicIndexing = VK_TRUE,
.shaderSampledImageArrayDynamicIndexing = VK_TRUE, .shaderSampledImageArrayDynamicIndexing = VK_TRUE,
@ -103,40 +122,54 @@ static const VkPhysicalDeviceFeatures2 vk_features_2 = {
}, },
}; };
static VkDeviceCreateInfo device_info = { static VkDeviceCreateInfo
g_Device_Info =
{
.sType = STYPE(DEVICE_CREATE_INFO), .sType = STYPE(DEVICE_CREATE_INFO),
.pNext = &vk_features_2, .pNext = &g_Vk_Features_2,
.ppEnabledExtensionNames = device_extensions, .ppEnabledExtensionNames = g_Device_Extensions,
.enabledExtensionCount = Len(device_extensions), .enabledExtensionCount = Len(g_Device_Extensions),
.pEnabledFeatures = NULL, .pEnabledFeatures = NULL,
}; };
static VmaAllocatorCreateInfo vma_create_info = { static VmaAllocatorCreateInfo
g_VMA_Create_Info =
{
.flags = VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT, .flags = VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT,
.vulkanApiVersion = VK_API_VERSION_1_3, .vulkanApiVersion = VK_API_VERSION_1_3,
}; };
static VkCommandPoolCreateInfo pool_create_info = { static VkCommandPoolCreateInfo
g_Pool_Create_Info =
{
.sType = STYPE(COMMAND_POOL_CREATE_INFO), .sType = STYPE(COMMAND_POOL_CREATE_INFO),
.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, .flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
}; };
static VkFenceCreateInfo fence_create_info = { static VkFenceCreateInfo
g_Fence_Create_Info =
{
.sType = STYPE(FENCE_CREATE_INFO), .sType = STYPE(FENCE_CREATE_INFO),
.flags = VK_FENCE_CREATE_SIGNALED_BIT, .flags = VK_FENCE_CREATE_SIGNALED_BIT,
}; };
static VkSemaphoreCreateInfo semaphore_create_info = { static VkSemaphoreCreateInfo
g_Semaphore_Create_info =
{
.sType = STYPE(SEMAPHORE_CREATE_INFO), .sType = STYPE(SEMAPHORE_CREATE_INFO),
}; };
static VkCommandBufferAllocateInfo cmd_buf_info = { static VkCommandBufferAllocateInfo
g_Command_Buffer_Info =
{
.sType = STYPE(COMMAND_BUFFER_ALLOCATE_INFO), .sType = STYPE(COMMAND_BUFFER_ALLOCATE_INFO),
.commandBufferCount = 1, .commandBufferCount = 1,
.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY, .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
}; };
static VkSwapchainCreateInfoKHR swapchain_create_info = { static VkSwapchainCreateInfoKHR
g_Swap_Info =
{
.sType = STYPE(SWAPCHAIN_CREATE_INFO_KHR), .sType = STYPE(SWAPCHAIN_CREATE_INFO_KHR),
.imageArrayLayers = 1, .imageArrayLayers = 1,
.imageUsage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, .imageUsage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
@ -145,7 +178,9 @@ static VkSwapchainCreateInfoKHR swapchain_create_info = {
.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE, .imageSharingMode = VK_SHARING_MODE_EXCLUSIVE,
}; };
static VkImageViewCreateInfo sc_image_view_create_info = { static VkImageViewCreateInfo
g_Swap_View_Info =
{
.sType = STYPE(IMAGE_VIEW_CREATE_INFO), .sType = STYPE(IMAGE_VIEW_CREATE_INFO),
.viewType = VK_IMAGE_VIEW_TYPE_2D, .viewType = VK_IMAGE_VIEW_TYPE_2D,
.components = { .components = {
@ -163,7 +198,9 @@ static VkImageViewCreateInfo sc_image_view_create_info = {
}, },
}; };
static VkImageCreateInfo draw_image_create_info = { static VkImageCreateInfo
g_Draw_Image_Info =
{
.sType = STYPE(IMAGE_CREATE_INFO), .sType = STYPE(IMAGE_CREATE_INFO),
.imageType = VK_IMAGE_TYPE_2D, .imageType = VK_IMAGE_TYPE_2D,
.mipLevels = 1, .mipLevels = 1,
@ -173,7 +210,9 @@ static VkImageCreateInfo draw_image_create_info = {
.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, .usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
}; };
static VkImageViewCreateInfo draw_image_view_create_info = { static VkImageViewCreateInfo
g_Draw_View_Info =
{
.sType = STYPE(IMAGE_VIEW_CREATE_INFO), .sType = STYPE(IMAGE_VIEW_CREATE_INFO),
.viewType = VK_IMAGE_VIEW_TYPE_2D, .viewType = VK_IMAGE_VIEW_TYPE_2D,
.subresourceRange = { .subresourceRange = {
@ -185,7 +224,9 @@ static VkImageViewCreateInfo draw_image_view_create_info = {
}, },
}; };
static VkImageCreateInfo depth_image_create_info = { static VkImageCreateInfo
g_Depth_Image_Info =
{
.sType = STYPE(IMAGE_CREATE_INFO), .sType = STYPE(IMAGE_CREATE_INFO),
.imageType = VK_IMAGE_TYPE_2D, .imageType = VK_IMAGE_TYPE_2D,
.mipLevels = 1, .mipLevels = 1,
@ -196,7 +237,9 @@ static VkImageCreateInfo depth_image_create_info = {
.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, .usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
}; };
static VkImageViewCreateInfo depth_image_view_create_info = { static VkImageViewCreateInfo
g_Depth_View_Info =
{
.sType = STYPE(IMAGE_VIEW_CREATE_INFO), .sType = STYPE(IMAGE_VIEW_CREATE_INFO),
.viewType = VK_IMAGE_VIEW_TYPE_2D, .viewType = VK_IMAGE_VIEW_TYPE_2D,
.format = VK_FORMAT_D32_SFLOAT, .format = VK_FORMAT_D32_SFLOAT,
@ -213,93 +256,120 @@ static VkImageViewCreateInfo depth_image_view_create_info = {
// PIPELINES & DESCRIPTORS // PIPELINES & DESCRIPTORS
// //
static VkDescriptorPoolSize descriptor_pool_sizes[] = { static VkDescriptorPoolSize
g_Desc_Pool_Sizes[] =
{
{ .type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, .descriptorCount = 4096 }, { .type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, .descriptorCount = 4096 },
{ .type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, .descriptorCount = 4096}, { .type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, .descriptorCount = 4096},
{ .type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, .descriptorCount = 4096}, { .type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, .descriptorCount = 4096},
{ .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, .descriptorCount = 4096}, { .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, .descriptorCount = 4096},
}; };
static VkDescriptorPoolCreateInfo desc_pool_info = { static VkDescriptorPoolCreateInfo
g_Desc_Pool_Info =
{
.sType = STYPE(DESCRIPTOR_POOL_CREATE_INFO), .sType = STYPE(DESCRIPTOR_POOL_CREATE_INFO),
.poolSizeCount = Len(descriptor_pool_sizes), .poolSizeCount = Len(g_Desc_Pool_Sizes),
.pPoolSizes = descriptor_pool_sizes, .pPoolSizes = g_Desc_Pool_Sizes,
.maxSets = 12, // Not sure if this is correct .maxSets = 12, // Not sure if this is correct
.flags = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT, .flags = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT,
}; };
static VkDescriptorBindingFlags shared_desc_binding_flags[] = { static VkDescriptorBindingFlags
g_Shared_Binding_Flags[] =
{
VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT, VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT,
VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT, VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT,
VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT, VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT,
VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT, VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT,
}; };
static VkDescriptorSetLayoutBindingFlagsCreateInfo shared_layout_binding_flags_info = { static VkDescriptorSetLayoutBindingFlagsCreateInfo
g_Shared_Desc_Flag_Info =
{
.sType = STYPE(DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO), .sType = STYPE(DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO),
.bindingCount = Len(shared_desc_binding_flags), .bindingCount = Len(g_Shared_Binding_Flags),
.pBindingFlags = shared_desc_binding_flags, .pBindingFlags = g_Shared_Binding_Flags,
}; };
static VkDescriptorSetLayoutBinding shared_layout_bindings[] = { static VkDescriptorSetLayoutBinding
g_Shared_Desc_Bindings[] =
{
{ .binding = 0, .descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, .descriptorCount = 1, .stageFlags = VK_SHADER_STAGE_ALL }, { .binding = 0, .descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, .descriptorCount = 1, .stageFlags = VK_SHADER_STAGE_ALL },
{ .binding = 1, .descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, .descriptorCount = 1, .stageFlags = VK_SHADER_STAGE_ALL }, { .binding = 1, .descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, .descriptorCount = 1, .stageFlags = VK_SHADER_STAGE_ALL },
{ .binding = 2, .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, .descriptorCount = 1, .stageFlags = VK_SHADER_STAGE_ALL }, { .binding = 2, .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, .descriptorCount = 1, .stageFlags = VK_SHADER_STAGE_ALL },
{ .binding = 3, .descriptorType = VK_DESCRIPTOR_TYPE_SAMPLER, .descriptorCount = 1, .stageFlags = VK_SHADER_STAGE_ALL }, { .binding = 3, .descriptorType = VK_DESCRIPTOR_TYPE_SAMPLER, .descriptorCount = 1, .stageFlags = VK_SHADER_STAGE_ALL },
}; };
static VkDescriptorSetLayoutCreateInfo shared_layout_create_info = { static VkDescriptorSetLayoutCreateInfo
g_Shared_Desc_Layout_Info =
{
.sType = STYPE(DESCRIPTOR_SET_LAYOUT_CREATE_INFO), .sType = STYPE(DESCRIPTOR_SET_LAYOUT_CREATE_INFO),
.pNext = &shared_layout_binding_flags_info, .pNext = &g_Shared_Desc_Flag_Info,
.bindingCount = Len(shared_layout_bindings), .bindingCount = Len(g_Shared_Desc_Bindings),
.pBindings = shared_layout_bindings, .pBindings = g_Shared_Desc_Bindings,
.flags = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT, .flags = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT,
}; };
static VkDescriptorType desc_type_map[vDT_MAX] = { static VkDescriptorType
g_Desc_Type_Map[vDT_MAX] =
{
[vDT_SAMPLED_IMAGE] = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, [vDT_SAMPLED_IMAGE] = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
[vDT_MATERIAL] = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, [vDT_MATERIAL] = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
[vDT_MESH] = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, [vDT_MESH] = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
}; };
static VkDescriptorBindingFlags bindless_desc_binding_flags = VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT | VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT; static VkDescriptorBindingFlags
g_Bindless_Binding_Flags = VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT | VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT;
static VkDescriptorSetLayoutBindingFlagsCreateInfo bindless_layout_flag_create_info = { static VkDescriptorSetLayoutBindingFlagsCreateInfo
g_Bindless_Desc_Flag_Info =
{
.sType = STYPE(DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO), .sType = STYPE(DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO),
.bindingCount = 1, .bindingCount = 1,
.pBindingFlags = &bindless_desc_binding_flags, .pBindingFlags = &g_Bindless_Binding_Flags,
}; };
static VkDescriptorSetLayoutBinding bindless_layout_binding = { static VkDescriptorSetLayoutBinding
g_Bindless_Desc_Binding =
{
.binding = 0, .binding = 0,
.descriptorCount = 1024, .descriptorCount = 1024,
.stageFlags = VK_SHADER_STAGE_ALL, .stageFlags = VK_SHADER_STAGE_ALL,
}; };
static VkDescriptorSetLayoutCreateInfo bindless_layout_create_info = { static VkDescriptorSetLayoutCreateInfo
g_Bindless_Desc_Info =
{
.sType = STYPE(DESCRIPTOR_SET_LAYOUT_CREATE_INFO), .sType = STYPE(DESCRIPTOR_SET_LAYOUT_CREATE_INFO),
.pNext = &bindless_layout_flag_create_info, .pNext = &g_Bindless_Desc_Flag_Info,
.bindingCount = 1, .bindingCount = 1,
.pBindings = &bindless_layout_binding, .pBindings = &g_Bindless_Desc_Binding,
.flags = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT, .flags = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT,
}; };
static VkDescriptorSetAllocateInfo set_allocate_info = { static VkDescriptorSetAllocateInfo
g_Descriptor_Alloc_Info =
{
.sType = STYPE(DESCRIPTOR_SET_ALLOCATE_INFO), .sType = STYPE(DESCRIPTOR_SET_ALLOCATE_INFO),
.descriptorSetCount = vDT_MAX, .descriptorSetCount = vDT_MAX,
}; };
static VkPushConstantRange push_const_range = { static VkPushConstantRange
g_Push_Const_Range =
{
.offset = 0, .offset = 0,
.size = sizeof(rPushConst), .size = sizeof(rPushConst),
.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT | VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_VERTEX_BIT, .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT | VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_VERTEX_BIT,
}; };
static VkPipelineLayoutCreateInfo pipeline_layout_create_info = { static VkPipelineLayoutCreateInfo
g_Pipeline_Layout_Info =
{
.sType = STYPE(PIPELINE_LAYOUT_CREATE_INFO), .sType = STYPE(PIPELINE_LAYOUT_CREATE_INFO),
.setLayoutCount = vDT_MAX, .setLayoutCount = vDT_MAX,
.pushConstantRangeCount = 1, .pushConstantRangeCount = 1,
.pPushConstantRanges = &push_const_range, .pPushConstantRanges = &g_Push_Const_Range,
}; };
// //
@ -309,15 +379,17 @@ static VkPipelineLayoutCreateInfo pipeline_layout_create_info = {
#define PIPELINE_DYNAMIC_STATE { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR } #define PIPELINE_DYNAMIC_STATE { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR }
static VkDynamicState pipeline_dynamic_state[] = PIPELINE_DYNAMIC_STATE; static VkDynamicState
g_Pipeline_Dynamic_State[] = PIPELINE_DYNAMIC_STATE;
#define PIPELINE_DEFAULT_DYN_STATE_INFO { \ #define PIPELINE_DEFAULT_DYN_STATE_INFO { \
.sType = STYPE(PIPELINE_DYNAMIC_STATE_CREATE_INFO), \ .sType = STYPE(PIPELINE_DYNAMIC_STATE_CREATE_INFO), \
.pDynamicStates = pipeline_dynamic_state, \ .pDynamicStates = g_Pipeline_Dynamic_State, \
.dynamicStateCount = Len(pipeline_dynamic_state), \ .dynamicStateCount = Len(g_Pipeline_Dynamic_State), \
} }
static VkPipelineDynamicStateCreateInfo pipeline_default_dyn_state_info = PIPELINE_DEFAULT_DYN_STATE_INFO; static VkPipelineDynamicStateCreateInfo
g_Pipeline_Default_Dynamic_Info = PIPELINE_DEFAULT_DYN_STATE_INFO;
#define PIPELINE_DEFAULT_ASSEMBLY_INFO { \ #define PIPELINE_DEFAULT_ASSEMBLY_INFO { \
.sType = STYPE(PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO), \ .sType = STYPE(PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO), \
@ -325,7 +397,8 @@ static VkPipelineDynamicStateCreateInfo pipeline_default_dyn_state_info = PIPELI
.primitiveRestartEnable = VK_FALSE, \ .primitiveRestartEnable = VK_FALSE, \
} }
static VkPipelineInputAssemblyStateCreateInfo pipeline_default_assembly_info = PIPELINE_DEFAULT_ASSEMBLY_INFO; static VkPipelineInputAssemblyStateCreateInfo
g_Pipeline_Default_Assembly_Info = PIPELINE_DEFAULT_ASSEMBLY_INFO;
#define PIPELINE_DEFAULT_RASTERIZATION_INFO { \ #define PIPELINE_DEFAULT_RASTERIZATION_INFO { \
.sType = STYPE(PIPELINE_RASTERIZATION_STATE_CREATE_INFO), \ .sType = STYPE(PIPELINE_RASTERIZATION_STATE_CREATE_INFO), \
@ -334,7 +407,8 @@ static VkPipelineInputAssemblyStateCreateInfo pipeline_default_assembly_info = P
.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE, \ .frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE, \
} }
static VkPipelineRasterizationStateCreateInfo pipeline_default_rasterization_info = PIPELINE_DEFAULT_RASTERIZATION_INFO; static VkPipelineRasterizationStateCreateInfo
g_Pipeline_Default_Rasterization_Info = PIPELINE_DEFAULT_RASTERIZATION_INFO;
#define PIPELINE_DEFAULT_MULTISAMPLE_INFO { \ #define PIPELINE_DEFAULT_MULTISAMPLE_INFO { \
.sType = STYPE(PIPELINE_MULTISAMPLE_STATE_CREATE_INFO), \ .sType = STYPE(PIPELINE_MULTISAMPLE_STATE_CREATE_INFO), \
@ -344,7 +418,8 @@ static VkPipelineRasterizationStateCreateInfo pipeline_default_rasterization_inf
.alphaToOneEnable = VK_FALSE, \ .alphaToOneEnable = VK_FALSE, \
} }
static VkPipelineMultisampleStateCreateInfo pipeline_default_multisample_info = PIPELINE_DEFAULT_MULTISAMPLE_INFO; static VkPipelineMultisampleStateCreateInfo
g_Pipeline_Default_Multisample_Info = PIPELINE_DEFAULT_MULTISAMPLE_INFO;
#define PIPELINE_DEFAULT_DEPTH_INFO { \ #define PIPELINE_DEFAULT_DEPTH_INFO { \
.sType = STYPE(PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO), \ .sType = STYPE(PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO), \
@ -357,37 +432,42 @@ static VkPipelineMultisampleStateCreateInfo pipeline_default_multisample_info =
.maxDepthBounds = 1.0, \ .maxDepthBounds = 1.0, \
} }
static VkPipelineDepthStencilStateCreateInfo pipeline_default_depth_info = PIPELINE_DEFAULT_DEPTH_INFO; static VkPipelineDepthStencilStateCreateInfo
g_Pipeline_Default_Depth_Info = PIPELINE_DEFAULT_DEPTH_INFO;
#define PIPELINE_DEFAULT_RENDERING_INFO { \ #define PIPELINE_DEFAULT_RENDERING_INFO { \
.sType = STYPE(PIPELINE_RENDERING_CREATE_INFO), \ .sType = STYPE(PIPELINE_RENDERING_CREATE_INFO), \
.colorAttachmentCount = 1, \ .colorAttachmentCount = 1, \
} }
static VkPipelineRenderingCreateInfo pipeline_default_rendering_info = PIPELINE_DEFAULT_RENDERING_INFO; static VkPipelineRenderingCreateInfo
g_Pipeline_Default_Rendering_Info = PIPELINE_DEFAULT_RENDERING_INFO;
#define PIPELINE_DEFAULT_BLEND_ATTACH_STATE { \ #define PIPELINE_DEFAULT_BLEND_ATTACH_STATE { \
.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT, \ .colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT, \
.blendEnable = VK_FALSE, \ .blendEnable = VK_FALSE, \
} }
static VkPipelineColorBlendAttachmentState pipeline_default_blend_attach_state = PIPELINE_DEFAULT_BLEND_ATTACH_STATE; static VkPipelineColorBlendAttachmentState
g_Pipeline_Default_Blend_State = PIPELINE_DEFAULT_BLEND_ATTACH_STATE;
#define PIPELINE_DEFAULT_BLEND_INFO { \ #define PIPELINE_DEFAULT_BLEND_INFO { \
.sType = STYPE(PIPELINE_COLOR_BLEND_STATE_CREATE_INFO), \ .sType = STYPE(PIPELINE_COLOR_BLEND_STATE_CREATE_INFO), \
.logicOpEnable = VK_FALSE, \ .logicOpEnable = VK_FALSE, \
.logicOp = VK_LOGIC_OP_COPY, \ .logicOp = VK_LOGIC_OP_COPY, \
.attachmentCount = 1, \ .attachmentCount = 1, \
.pAttachments = &pipeline_default_blend_attach_state, \ .pAttachments = &g_Pipeline_Default_Blend_State, \
} }
static VkPipelineColorBlendStateCreateInfo pipeline_default_blend_info = PIPELINE_DEFAULT_BLEND_INFO; static VkPipelineColorBlendStateCreateInfo
g_Pipeline_Default_Blend_Info = PIPELINE_DEFAULT_BLEND_INFO;
#define PIPELINE_DEFAULT_VERTEX_INFO { \ #define PIPELINE_DEFAULT_VERTEX_INFO { \
.sType = STYPE(PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO), \ .sType = STYPE(PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO), \
} }
static VkPipelineVertexInputStateCreateInfo pipeline_default_vertex_info = PIPELINE_DEFAULT_VERTEX_INFO; static VkPipelineVertexInputStateCreateInfo
g_Pipeline_Default_Vertex_Info = PIPELINE_DEFAULT_VERTEX_INFO;
#define PIPELINE_DEFAULT_VIEWPORT_INFO { \ #define PIPELINE_DEFAULT_VIEWPORT_INFO { \
.sType = STYPE(PIPELINE_VIEWPORT_STATE_CREATE_INFO), \ .sType = STYPE(PIPELINE_VIEWPORT_STATE_CREATE_INFO), \
@ -395,51 +475,56 @@ static VkPipelineVertexInputStateCreateInfo pipeline_default_vertex_info = PIPEL
.scissorCount = 1, \ .scissorCount = 1, \
} }
const static VkPipelineViewportStateCreateInfo pipeline_default_viewport_info = PIPELINE_DEFAULT_VIEWPORT_INFO; const static VkPipelineViewportStateCreateInfo
g_Pipeline_Default_Viewport_Info = PIPELINE_DEFAULT_VIEWPORT_INFO;
#define INIT_PIPELINE_DEFAULTS(pipeline) \ #define INIT_PIPELINE_DEFAULTS(pipeline) \
VkPipelineDynamicStateCreateInfo pipeline##_default_dynamic_info = PIPELINE_DEFAULT_DYN_STATE_INFO; \ VkPipelineDynamicStateCreateInfo g_##pipeline##_Default_Dynamic_Info = PIPELINE_DEFAULT_DYN_STATE_INFO; \
VkPipelineInputAssemblyStateCreateInfo pipeline##_default_assembly_info = PIPELINE_DEFAULT_ASSEMBLY_INFO; \ VkPipelineInputAssemblyStateCreateInfo g_##pipeline##_Default_Assembly_Info = PIPELINE_DEFAULT_ASSEMBLY_INFO; \
VkPipelineRasterizationStateCreateInfo pipeline##_default_rasterization_info = PIPELINE_DEFAULT_RASTERIZATION_INFO; \ VkPipelineRasterizationStateCreateInfo g_##pipeline##_Default_Rasterization_Info = PIPELINE_DEFAULT_RASTERIZATION_INFO; \
VkPipelineMultisampleStateCreateInfo pipeline##_default_multisample_info = PIPELINE_DEFAULT_MULTISAMPLE_INFO; \ VkPipelineMultisampleStateCreateInfo g_##pipeline##_Default_Multisample_Info = PIPELINE_DEFAULT_MULTISAMPLE_INFO; \
VkPipelineDepthStencilStateCreateInfo pipeline##_default_depth_info = PIPELINE_DEFAULT_DEPTH_INFO; \ VkPipelineDepthStencilStateCreateInfo g_##pipeline##_Default_Depth_Info = PIPELINE_DEFAULT_DEPTH_INFO; \
VkPipelineRenderingCreateInfo pipeline##_default_rendering_info = PIPELINE_DEFAULT_RENDERING_INFO; \ VkPipelineRenderingCreateInfo g_##pipeline##_Default_Rendering_Info = PIPELINE_DEFAULT_RENDERING_INFO; \
VkPipelineColorBlendStateCreateInfo pipeline##_default_blend_info = PIPELINE_DEFAULT_BLEND_INFO; \ VkPipelineColorBlendStateCreateInfo g_##pipeline##_Default_Blend_Info = PIPELINE_DEFAULT_BLEND_INFO; \
VkPipelineVertexInputStateCreateInfo pipeline##_default_vertex_info = PIPELINE_DEFAULT_VERTEX_INFO; \ VkPipelineVertexInputStateCreateInfo g_##pipeline##_Default_Vertex_Info = PIPELINE_DEFAULT_VERTEX_INFO; \
VkPipelineViewportStateCreateInfo pipeline##_default_viewport_info = PIPELINE_DEFAULT_VIEWPORT_INFO; \ VkPipelineViewportStateCreateInfo g_##pipeline##_Default_Viewport_Info = PIPELINE_DEFAULT_VIEWPORT_INFO; \
VkGraphicsPipelineCreateInfo pipeline##_create_info = { \ VkGraphicsPipelineCreateInfo g_##pipeline##_Create_Info = { \
.sType = STYPE(GRAPHICS_PIPELINE_CREATE_INFO), \ .sType = STYPE(GRAPHICS_PIPELINE_CREATE_INFO), \
.pNext = &pipeline##_default_rendering_info, \ .pNext = &g_##pipeline##_Default_Rendering_Info, \
.pVertexInputState = &pipeline##_default_vertex_info, \ .pVertexInputState = &g_##pipeline##_Default_Vertex_Info, \
.pInputAssemblyState = &pipeline##_default_assembly_info, \ .pInputAssemblyState = &g_##pipeline##_Default_Assembly_Info, \
.pViewportState = &pipeline##_default_viewport_info, \ .pViewportState = &g_##pipeline##_Default_Viewport_Info, \
.pRasterizationState = &pipeline##_default_rasterization_info,\ .pRasterizationState = &g_##pipeline##_Default_Rasterization_Info,\
.pMultisampleState = &pipeline##_default_multisample_info, \ .pMultisampleState = &g_##pipeline##_Default_Multisample_Info, \
.pColorBlendState = &pipeline##_default_blend_info, \ .pColorBlendState = &g_##pipeline##_Default_Blend_Info, \
.pDepthStencilState = &pipeline##_default_depth_info, \ .pDepthStencilState = &g_##pipeline##_Default_Depth_Info, \
.pDynamicState = &pipeline##_default_dynamic_info, \ .pDynamicState = &g_##pipeline##_Default_Dynamic_Info, \
}; };
INIT_PIPELINE_DEFAULTS(cube); INIT_PIPELINE_DEFAULTS(CUBE);
// GUI Pipeline // GUI Pipeline
INIT_PIPELINE_DEFAULTS(gui); INIT_PIPELINE_DEFAULTS(GUI);
VkVertexInputBindingDescription gui_input_bind_desc = { VkVertexInputBindingDescription
gui_input_bind_desc = {
.binding = 0, .binding = 0,
.stride = sizeof(rUIVertex), .stride = sizeof(rUIVertex),
.inputRate = VK_VERTEX_INPUT_RATE_INSTANCE, .inputRate = VK_VERTEX_INPUT_RATE_INSTANCE,
}; };
VkVertexInputAttributeDescription gui_input_descriptions[] = { VkVertexInputAttributeDescription
gui_input_descriptions[] = {
{ .binding = 0, .location = 0, .format = VK_FORMAT_R32G32_SFLOAT, .offset = 0 }, { .binding = 0, .location = 0, .format = VK_FORMAT_R32G32_SFLOAT, .offset = 0 },
{ .binding = 0, .location = 1, .format = VK_FORMAT_R32G32_SFLOAT, .offset = offsetof(rUIVertex, p1) }, { .binding = 0, .location = 1, .format = VK_FORMAT_R32G32_SFLOAT, .offset = offsetof(rUIVertex, p1) },
{ .binding = 0, .location = 2, .format = VK_FORMAT_R32G32B32A32_SFLOAT, .offset = offsetof(rUIVertex, col) }, { .binding = 0, .location = 2, .format = VK_FORMAT_R32G32B32A32_SFLOAT, .offset = offsetof(rUIVertex, col) },
{ .binding = 0, .location = 3, .format = VK_FORMAT_R32_UINT, .offset = offsetof(rUIVertex, tex_idx) }, { .binding = 0, .location = 3, .format = VK_FORMAT_R32_UINT, .offset = offsetof(rUIVertex, tex_idx) },
}; };
VkPipelineVertexInputStateCreateInfo gui_vertex_input_info = { VkPipelineVertexInputStateCreateInfo
gui_vertex_input_info =
{
.sType = STYPE(PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO), .sType = STYPE(PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO),
.vertexBindingDescriptionCount = 1, .vertexBindingDescriptionCount = 1,
.pVertexBindingDescriptions = &gui_input_bind_desc, .pVertexBindingDescriptions = &gui_input_bind_desc,
@ -447,40 +532,49 @@ VkPipelineVertexInputStateCreateInfo gui_vertex_input_info = {
.pVertexAttributeDescriptions = gui_input_descriptions, .pVertexAttributeDescriptions = gui_input_descriptions,
}; };
VkPipelineInputAssemblyStateCreateInfo gui_assembly_info = { VkPipelineInputAssemblyStateCreateInfo
gui_assembly_info =
{
.sType = STYPE(PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO), .sType = STYPE(PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO),
.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, .topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
.primitiveRestartEnable = VK_FALSE, .primitiveRestartEnable = VK_FALSE,
}; };
// PBR Pipeline // PBR Pipeline
INIT_PIPELINE_DEFAULTS(pbr); INIT_PIPELINE_DEFAULTS(PBR);
VkVertexInputBindingDescription pbr_input_bind_desc = { VkVertexInputBindingDescription
pbr_input_bind_desc =
{
.binding = 0, .binding = 0,
.stride = sizeof(rPBRVertex), .stride = sizeof(rPBRVertex),
.inputRate = VK_VERTEX_INPUT_RATE_VERTEX, .inputRate = VK_VERTEX_INPUT_RATE_VERTEX,
}; };
VkPipelineVertexInputStateCreateInfo pbr_vertex_input_info = { VkPipelineVertexInputStateCreateInfo
pbr_vertex_input_info =
{
.sType = STYPE(PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO), .sType = STYPE(PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO),
.vertexBindingDescriptionCount = 1, .vertexBindingDescriptionCount = 1,
.pVertexBindingDescriptions = &pbr_input_bind_desc, .pVertexBindingDescriptions = &pbr_input_bind_desc,
}; };
VkPipelineInputAssemblyStateCreateInfo pbr_assembly_info = { VkPipelineInputAssemblyStateCreateInfo
pbr_assembly_info =
{
.sType = STYPE(PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO), .sType = STYPE(PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO),
.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, .topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
.primitiveRestartEnable = VK_FALSE, .primitiveRestartEnable = VK_FALSE,
}; };
static void vCustomizePipelines() static void
vCustomizePipelines()
{ {
// GUI // GUI
gui_create_info.pVertexInputState = &gui_vertex_input_info; g_GUI_Create_Info.pVertexInputState = &gui_vertex_input_info;
gui_create_info.pInputAssemblyState = &gui_assembly_info; g_GUI_Create_Info.pInputAssemblyState = &gui_assembly_info;
// PBR // PBR
pbr_create_info.pVertexInputState = &pbr_vertex_input_info; g_PBR_Create_Info.pVertexInputState = &pbr_vertex_input_info;
pbr_create_info.pInputAssemblyState = &pbr_assembly_info; g_PBR_Create_Info.pInputAssemblyState = &pbr_assembly_info;
} }