From 08c58e719c622565e1ac6a554b478aa1c84a476a Mon Sep 17 00:00:00 2001 From: FroggyGreen Date: Mon, 1 Jul 2024 15:06:24 -0500 Subject: [PATCH] Autism License text changes, adding const and restrict keywords, freetype git submodule --- .gitmodules | 3 + external/freetype | 1 + renderer/CMakeLists.txt | 10 +- renderer/src/containers/darray.c | 62 ++++++----- renderer/src/containers/darray.h | 14 +-- renderer/src/containers/dblist.c | 32 +++--- renderer/src/containers/dblist.h | 12 +-- renderer/src/containers/hashtable.c | 34 +++--- renderer/src/containers/hashtable.h | 14 +-- renderer/src/containers/ringqueue.c | 28 +++-- renderer/src/containers/ringqueue.h | 14 +-- renderer/src/logger.c | 18 ++-- renderer/src/renderer.c | 205 +++++++++++++++++++----------------- renderer/src/renderer.h | 28 ++--- 14 files changed, 260 insertions(+), 215 deletions(-) create mode 160000 external/freetype diff --git a/.gitmodules b/.gitmodules index 4200723..4a7f458 100644 --- a/.gitmodules +++ b/.gitmodules @@ -4,3 +4,6 @@ [submodule "external/stb"] path = external/stb url = https://github.com/nothings/stb +[submodule "external/freetype"] + path = external/freetype + url = https://gitlab.freedesktop.org/freetype/freetype.git diff --git a/external/freetype b/external/freetype new file mode 160000 index 0000000..37cefe3 --- /dev/null +++ b/external/freetype @@ -0,0 +1 @@ +Subproject commit 37cefe33b284d0bad4ec52bcccc1a8c2d8704340 diff --git a/renderer/CMakeLists.txt b/renderer/CMakeLists.txt index 1f64441..bfb1f31 100644 --- a/renderer/CMakeLists.txt +++ b/renderer/CMakeLists.txt @@ -22,7 +22,7 @@ foreach(SHADER_FILE ${SHADER_FILES}) endforeach() add_custom_target(shaders ALL DEPENDS ${SHADER_SPIRV_BINARIES}) -set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall") +set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -O3") add_library(sofrenderer SHARED "src/logger.c" "src/renderer.c" @@ -36,9 +36,7 @@ set_target_properties(sofrenderer PROPERTIES LIBRARY_OUTPUT_DIRECTORY "${PROJECT_SOURCE_DIR}/lib") # GLFW -add_subdirectory(../external/glfw build) -target_include_directories(sofrenderer PRIVATE "${PROJECT_SOURCE_DIR}/../external/glfw/include") -target_link_directories(sofrenderer PRIVATE "${PROJECT_SOURCE_DIR}/../external/glfw") +add_subdirectory(../external/glfw glfw) target_link_libraries(sofrenderer PRIVATE glfw) # Vulkan @@ -47,3 +45,7 @@ target_link_libraries(sofrenderer PRIVATE ${Vulkan_LIBRARIES}) # stb target_include_directories(sofrenderer PRIVATE "${PROJECT_SOURCE_DIR}/../external/stb") + +# freetype +add_subdirectory(../external/freetype freetype) +target_link_libraries(sofrenderer PRIVATE freetype) diff --git a/renderer/src/containers/darray.c b/renderer/src/containers/darray.c index 96c600e..9fa4834 100644 --- a/renderer/src/containers/darray.c +++ b/renderer/src/containers/darray.c @@ -1,14 +1,20 @@ /* -Copyright (C) 2024 Frosch - This file is part of Shape of Fantasy. +Copyright (C) 2024 Frosch -Shape of Fantasy is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. -Shape of Fantasy is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. -You should have received a copy of the GNU General Public License along with Shape of Fantasy. If not, see . +You should have received a copy of the GNU General Public License +along with this program. If not, see . */ @@ -18,7 +24,7 @@ You should have received a copy of the GNU General Public License along with Sha #include #include -void* create_darray(u64 capacity, u64 stride) +void* create_darray(const u64 capacity, const u64 stride) { if (!capacity) { @@ -31,7 +37,7 @@ void* create_darray(u64 capacity, u64 stride) return NULL; } - u64 byte_size = DARRAY_TOT_FIELDS * sizeof(u64) + capacity * stride; + const u64 byte_size = DARRAY_TOT_FIELDS * sizeof(u64) + capacity * stride; u64* header = (u64*)malloc(byte_size); header[DARRAY_CAPACITY] = capacity; header[DARRAY_SIZE] = 0; @@ -48,7 +54,7 @@ void destroy_darray(void* arr) free(header); } -static void* change_darray_capacity(void* arr, u64 capacity) +static void* change_darray_capacity(void* arr, const u64 capacity) { if (!capacity) { @@ -57,9 +63,9 @@ static void* change_darray_capacity(void* arr, u64 capacity) } // get pointer to the first field - u64* header = (u64*)arr - DARRAY_TOT_FIELDS; + const u64* header = (u64*)arr - DARRAY_TOT_FIELDS; - u64 stride = header[DARRAY_STRIDE]; + const u64 stride = header[DARRAY_STRIDE]; void* result = create_darray(capacity, stride); memcpy(result, arr, header[DARRAY_CAPACITY] * stride); destroy_darray(arr); @@ -67,7 +73,7 @@ static void* change_darray_capacity(void* arr, u64 capacity) return result; } -void set_darray_field(void* arr, u64 field, u64 value) +void set_darray_field(void* arr, const u64 field, const u64 value) { // get pointer to the first field u64* header = (u64*)arr - DARRAY_TOT_FIELDS; @@ -75,7 +81,7 @@ void set_darray_field(void* arr, u64 field, u64 value) header[field] = value; } -u64 get_darray_field(const void* arr, u8 field) +u64 get_darray_field(const void* arr, const u8 field) { if (field >= DARRAY_TOT_FIELDS) { @@ -89,7 +95,7 @@ u64 get_darray_field(const void* arr, u8 field) return header[field]; } -void* darray_pushback(void* arr, const void* src, u64 src_size) +void* darray_pushback(void* arr, const void* src, const u64 src_size) { if (!src_size) { @@ -100,8 +106,8 @@ void* darray_pushback(void* arr, const void* src, u64 src_size) // get pointer to the first field u64* header = (u64*)arr - DARRAY_TOT_FIELDS; - u64 size = header[DARRAY_SIZE]; - u64 stride = header[DARRAY_STRIDE]; + const u64 size = header[DARRAY_SIZE]; + const u64 stride = header[DARRAY_STRIDE]; // if the size is about to become larger than the capacity, increase the capacity if ((size + src_size) > header[DARRAY_CAPACITY]) @@ -112,7 +118,7 @@ void* darray_pushback(void* arr, const void* src, u64 src_size) header = (u64*)arr - DARRAY_TOT_FIELDS; } - u64 address = (u64)arr; + const u64 address = (u64)arr; void* dst = (void*)(address + size * stride); memcpy(dst, src, stride * src_size); header[DARRAY_SIZE] = size + src_size; @@ -120,7 +126,7 @@ void* darray_pushback(void* arr, const void* src, u64 src_size) return arr; } -void* darray_insert(void* arr, u64 index, const void* src, u64 src_size) +void* darray_insert(void* arr, const u64 index, const void* src, const u64 src_size) { if (!src_size) { @@ -131,13 +137,13 @@ void* darray_insert(void* arr, u64 index, const void* src, u64 src_size) // get pointer to the first field u64* header = (u64*)arr - DARRAY_TOT_FIELDS; - u64 size = header[DARRAY_SIZE]; + const u64 size = header[DARRAY_SIZE]; if (index >= size) { trace_log(LOG_ERROR, "Darray data insertion failed; index '%d' out of bounds.", index); return NULL; } - u64 stride = header[DARRAY_STRIDE]; + const u64 stride = header[DARRAY_STRIDE]; // if the size is about to become larger than the capacity, increase the capacity if ((size + src_size) > header[DARRAY_CAPACITY]) @@ -146,7 +152,7 @@ void* darray_insert(void* arr, u64 index, const void* src, u64 src_size) header = (u64*)arr - DARRAY_TOT_FIELDS; //recalc header, changing capacity changes arr } - u64 address = (u64)arr; + const u64 address = (u64)arr; { void* dst = (void*)(address + (index + src_size) * stride); void* shift_from = (void*)(address + index * stride); @@ -162,20 +168,20 @@ void* darray_insert(void* arr, u64 index, const void* src, u64 src_size) return arr; } -u8 darray_pop(void* arr, void* dst, u64 dst_size) +u8 darray_pop(void* arr, void* dst, const u64 dst_size) { - u64 address = (u64)arr; + const u64 address = (u64)arr; // get pointer to the first field u64* header = (u64*)arr - DARRAY_TOT_FIELDS; - u64 size = header[DARRAY_SIZE]; + const u64 size = header[DARRAY_SIZE]; if (!dst_size || !(size - dst_size)) { trace_log(LOG_ERROR, "Darray pop failed; destination size '%d' must be nonzero and smaller than the darray size '%d'.", dst_size, size); return 0; } - u64 stride = header[DARRAY_STRIDE]; + const u64 stride = header[DARRAY_STRIDE]; if (dst != NULL) { @@ -187,14 +193,14 @@ u8 darray_pop(void* arr, void* dst, u64 dst_size) return 1; } -u8 darray_remove(void* arr, u64 index, void* dst, u64 dst_size) +u8 darray_remove(void* arr, const u64 index, void* dst, const u64 dst_size) { - u64 address = (u64)arr; + const u64 address = (u64)arr; // get pointer to the first field u64* header = (u64*)arr - DARRAY_TOT_FIELDS; - u64 size = header[DARRAY_SIZE]; + const u64 size = header[DARRAY_SIZE]; if (!dst_size && !(size - dst_size)) { trace_log(LOG_ERROR, "Darray data removal failed; destination size '%d' must be nonzero and smaller than the darray size '%d'.", dst_size, size); @@ -205,7 +211,7 @@ u8 darray_remove(void* arr, u64 index, void* dst, u64 dst_size) trace_log(LOG_ERROR, "Darray data removal failed; index '%d' out of bounds with darray size '%d' and removal size '%d'.", index, dst_size, size); return 0; } - u64 stride = header[DARRAY_STRIDE]; + const u64 stride = header[DARRAY_STRIDE]; if (dst != NULL) { diff --git a/renderer/src/containers/darray.h b/renderer/src/containers/darray.h index b687a59..7ee9165 100644 --- a/renderer/src/containers/darray.h +++ b/renderer/src/containers/darray.h @@ -23,17 +23,17 @@ enum DARRAY_TOT_FIELDS }; -void* create_darray(u64 capacity, u64 stride); +void* create_darray(const u64 capacity, const u64 stride); void destroy_darray(void* arr); -void set_darray_field(void* arr, u64 field, u64 value); -u64 get_darray_field(const void* arr, u8 field); +void set_darray_field(void* arr, const u64 field, const u64 value); +u64 get_darray_field(const void* arr, const u8 field); static inline u64 get_darray_capacity(const void* arr) { return get_darray_field(arr, DARRAY_CAPACITY); } static inline u64 get_darray_size(const void* arr) { return get_darray_field(arr, DARRAY_SIZE); } static inline u64 get_darray_stride(const void* arr) { return get_darray_field(arr, DARRAY_STRIDE); } -void* darray_pushback(void* arr, const void* src, u64 src_size); -void* darray_insert(void* arr, u64 index, const void* src, u64 src_size); -u8 darray_pop(void* arr, void* dst, u64 dst_size); -u8 darray_remove(void* arr, u64 index, void* kdst, u64 dst_size); +void* darray_pushback(void* arr, const void* src, const u64 src_size); +void* darray_insert(void* arr, const u64 index, const void* src, const u64 src_size); +u8 darray_pop(void* arr, void* dst, const u64 dst_size); +u8 darray_remove(void* arr, const u64 index, void* dst, const u64 dst_size); void clear_darray(void* arr); diff --git a/renderer/src/containers/dblist.c b/renderer/src/containers/dblist.c index b1c0c3c..5888cb4 100644 --- a/renderer/src/containers/dblist.c +++ b/renderer/src/containers/dblist.c @@ -1,14 +1,20 @@ /* -Copyright (C) 2024 Frosch - This file is part of Shape of Fantasy. +Copyright (C) 2024 Frosch -Shape of Fantasy is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. -Shape of Fantasy is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. -You should have received a copy of the GNU General Public License along with Shape of Fantasy. If not, see . +You should have received a copy of the GNU General Public License +along with this program. If not, see . */ @@ -17,7 +23,7 @@ You should have received a copy of the GNU General Public License along with Sha #include #include -static db_item* create_db_item(db_list* lst, db_item* prev, void* data) +static db_item* create_db_item(db_list* restrict lst, db_item* restrict prev, void* restrict data) { db_item* itm = (db_item*)malloc(sizeof(db_item)); @@ -34,20 +40,20 @@ static db_item* create_db_item(db_list* lst, db_item* prev, void* data) return itm; } -static void destroy_db_item(db_list* lst, db_item* itm) +static void destroy_db_item(const db_list* restrict lst, db_item* restrict itm) { if (lst->data_byte_size) free(itm->data); free(itm); } -void init_db_list(db_list* lst, u64 data_byte_size) +void init_db_list(db_list* restrict lst, const u64 data_byte_size) { lst->head = NULL; lst->tail = NULL; lst->data_byte_size = data_byte_size; } -void shutdown_db_list(db_list* lst) +void shutdown_db_list(db_list* restrict lst) { db_item* next; for (db_item* current = lst->head; current != NULL; current = next) @@ -57,7 +63,7 @@ void shutdown_db_list(db_list* lst) } } -void db_list_pushfront(db_list* lst, void* data) +void db_list_pushfront(db_list* restrict lst, void* restrict data) { db_item* itm = create_db_item(lst, lst->tail, data); @@ -67,7 +73,7 @@ void db_list_pushfront(db_list* lst, void* data) lst->head = itm; } -void db_list_popfront(db_list* lst, void** dst) +void db_list_popfront(db_list* restrict lst, void** restrict dst) { if (lst->head == NULL) { @@ -88,7 +94,7 @@ void db_list_popfront(db_list* lst, void** dst) else lst->head->prev = NULL; } -void db_list_pushback(db_list* lst, void* data) +void db_list_pushback(db_list* restrict lst, void* restrict data) { db_item* itm = create_db_item(lst, lst->tail, data); @@ -98,7 +104,7 @@ void db_list_pushback(db_list* lst, void* data) lst->tail = itm; } -void db_list_popback(db_list* lst, void** dst) +void db_list_popback(db_list* restrict lst, void** restrict dst) { if (lst->head == NULL) { diff --git a/renderer/src/containers/dblist.h b/renderer/src/containers/dblist.h index 665817d..02bae2e 100644 --- a/renderer/src/containers/dblist.h +++ b/renderer/src/containers/dblist.h @@ -50,9 +50,9 @@ typedef struct db_list } db_list; -void init_db_list(db_list* lst, u64 data_byte_size); -void shutdown_db_list(db_list* lst); -void db_list_pushfront(db_list* lst, void* data); -void db_list_popfront(db_list* lst, void** dst); -void db_list_pushback(db_list* lst, void* data); -void db_list_popback(db_list* lst, void** dst); +void init_db_list(db_list* restrict lst, const u64 data_byte_size); +void shutdown_db_list(db_list* restrict lst); +void db_list_pushfront(db_list* restrict lst, void* restrict data); +void db_list_popfront(db_list* restrict lst, void** restrict dst); +void db_list_pushback(db_list* restrict lst, void* restrict data); +void db_list_popback(db_list* restrict lst, void** restrict dst); diff --git a/renderer/src/containers/hashtable.c b/renderer/src/containers/hashtable.c index 34605a5..81a4c88 100644 --- a/renderer/src/containers/hashtable.c +++ b/renderer/src/containers/hashtable.c @@ -1,14 +1,20 @@ /* -Copyright (C) 2024 Frosch - This file is part of Shape of Fantasy. +Copyright (C) 2024 Frosch -Shape of Fantasy is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. -Shape of Fantasy is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. -You should have received a copy of the GNU General Public License along with Shape of Fantasy. If not, see . +You should have received a copy of the GNU General Public License +along with this program. If not, see . */ @@ -27,7 +33,7 @@ u32 basic_hash(const hash_table* ht, const char* key) return hashval & (ht->slot_count - 1); // slot count must be a power of 2 } -static hash_table_entry* create_hash_table_entry(hash_table* ht, const char* key, void* data) +static hash_table_entry* create_hash_table_entry(hash_table* restrict ht, const char* restrict key, void* restrict data) { hash_table_entry* entry = (hash_table_entry*)malloc(sizeof(hash_table_entry)); @@ -44,14 +50,14 @@ static hash_table_entry* create_hash_table_entry(hash_table* ht, const char* key return entry; } -static void destroy_hash_table_entry(hash_table* ht, hash_table_entry* entry) +static void destroy_hash_table_entry(hash_table* restrict ht, hash_table_entry* restrict entry) { if (ht->data_byte_size) free(entry->data); free(entry); entry = NULL; } -void init_hash_table(hash_table* ht, u64 slot_count, u64 data_byte_size, hash_fn hash) +void init_hash_table(hash_table* restrict ht, const u64 slot_count, const u64 data_byte_size, hash_fn hash) { if (!slot_count || (slot_count & (slot_count - 1))) { @@ -66,7 +72,7 @@ void init_hash_table(hash_table* ht, u64 slot_count, u64 data_byte_size, hash_fn for (u32 i = 0; i < slot_count; i++) ht->entries[i] = NULL; } -void shutdown_hash_table(hash_table* ht) +void shutdown_hash_table(hash_table* restrict ht) { hash_table_entry* next; for (u32 i = 0; i < ht->slot_count; i++) @@ -79,7 +85,7 @@ void shutdown_hash_table(hash_table* ht) free(ht->entries); } -void* hash_table_lookup(const hash_table* ht, const char* key) +void* hash_table_lookup(const hash_table* restrict ht, const char* restrict key) { if (key == NULL || (strlen(key) > HASH_TABLE_KEY_LEN - 1)) return NULL; @@ -91,7 +97,7 @@ void* hash_table_lookup(const hash_table* ht, const char* key) return NULL; } -void* hash_table_insert(hash_table* ht, const char* key, void* data) +void* hash_table_insert(hash_table* restrict ht, const char* restrict key, void* restrict data) { if (strlen(key) > HASH_TABLE_KEY_LEN - 1) { @@ -125,7 +131,7 @@ void* hash_table_insert(hash_table* ht, const char* key, void* data) return prev->next->data; } -void* hash_table_insert_or_replace(hash_table* ht, const char* key, void* data) +void* hash_table_insert_or_replace(hash_table* restrict ht, const char* restrict key, void* restrict data) { if (strlen(key) > HASH_TABLE_KEY_LEN - 1) { @@ -160,7 +166,7 @@ void* hash_table_insert_or_replace(hash_table* ht, const char* key, void* data) return prev->next->data; } -u8 hash_table_remove(hash_table* ht, const char* key, void** dst) +u8 hash_table_remove(hash_table* restrict ht, const char* restrict key, void** restrict dst) { if (strlen(key) > HASH_TABLE_KEY_LEN - 1) { @@ -197,7 +203,7 @@ u8 hash_table_remove(hash_table* ht, const char* key, void** dst) return 0; } -u32 get_hash_table_entry_count(const hash_table* ht) +u32 get_hash_table_entry_count(const hash_table* restrict ht) { u32 count = 0; for (u32 i = 0; i < ht->slot_count; i++) diff --git a/renderer/src/containers/hashtable.h b/renderer/src/containers/hashtable.h index 24a8d9a..d04a8e1 100644 --- a/renderer/src/containers/hashtable.h +++ b/renderer/src/containers/hashtable.h @@ -60,12 +60,12 @@ typedef struct hash_table u32 basic_hash(const hash_table* ht, const char* key); // The data_byte_size is the size of the data you pass in via the insert function. -void init_hash_table(hash_table* ht, u64 slot_count, u64 data_byte_size, hash_fn hash); +void init_hash_table(hash_table* restrict ht, const u64 slot_count, const u64 data_byte_size, hash_fn hash); // If the hash table is externally handling memory and the pointer is not stored somewhere else, you should never call this before deallocating those entries. -void shutdown_hash_table(hash_table* ht); +void shutdown_hash_table(hash_table* restrict ht); -void* hash_table_lookup(const hash_table* ht, const char* key); -void* hash_table_insert(hash_table* ht, const char* key, void* data); -void* hash_table_insert_or_replace(hash_table* ht, const char* key, void* data); -u8 hash_table_remove(hash_table* ht, const char* key, void** dst); // passing NULL to dst is allowed -u32 get_hash_table_entry_count(const hash_table* ht); +void* hash_table_lookup(const hash_table* restrict ht, const char* restrict key); +void* hash_table_insert(hash_table* restrict ht, const char* restrict key, void* restrict data); +void* hash_table_insert_or_replace(hash_table* restrict ht, const char* restrict key, void* restrict data); +u8 hash_table_remove(hash_table* restrict ht, const char* restrict key, void** restrict dst); // passing NULL to dst is allowed +u32 get_hash_table_entry_count(const hash_table* restrict ht); diff --git a/renderer/src/containers/ringqueue.c b/renderer/src/containers/ringqueue.c index 5e57ae6..728328e 100644 --- a/renderer/src/containers/ringqueue.c +++ b/renderer/src/containers/ringqueue.c @@ -1,14 +1,20 @@ /* -Copyright (C) 2024 Frosch - This file is part of Shape of Fantasy. +Copyright (C) 2024 Frosch -Shape of Fantasy is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. -Shape of Fantasy is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. -You should have received a copy of the GNU General Public License along with Shape of Fantasy. If not, see . +You should have received a copy of the GNU General Public License +along with this program. If not, see . */ @@ -16,7 +22,7 @@ You should have received a copy of the GNU General Public License along with Sha #include "logger.h" #include -u8 init_ring_queue(ring_queue* q, void* buffer, u64 capacity, u64 stride) +u8 init_ring_queue(ring_queue* restrict q, void* restrict buffer, u64 capacity, u64 stride) { if (!stride) { @@ -37,7 +43,7 @@ u8 init_ring_queue(ring_queue* q, void* buffer, u64 capacity, u64 stride) return 1; } -void shutdown_ring_queue(ring_queue* q) +void shutdown_ring_queue(ring_queue* restrict q) { q->buffer = NULL; q->in = 0; @@ -46,7 +52,7 @@ void shutdown_ring_queue(ring_queue* q) q->stride = 0; } -u8 ring_queue_pushback(ring_queue* q, const void* src) +u8 ring_queue_pushback(ring_queue* restrict q, const void* restrict src) { if (is_ring_queue_full(q)) { @@ -54,7 +60,7 @@ u8 ring_queue_pushback(ring_queue* q, const void* src) return 0; } - u64 address = (u64)q->buffer; + const u64 address = (u64)q->buffer; void* dst = (void*)(address + q->in * q->stride); memcpy(dst, src, q->stride); @@ -62,7 +68,7 @@ u8 ring_queue_pushback(ring_queue* q, const void* src) return 1; } -u8 ring_queue_popfront(ring_queue* q, void** dst) +u8 ring_queue_popfront(ring_queue* restrict q, void** restrict dst) { if (is_ring_queue_empty(q)) { @@ -72,7 +78,7 @@ u8 ring_queue_popfront(ring_queue* q, void** dst) if (dst != NULL) { - u64 address = (u64)q->buffer; + const u64 address = (u64)q->buffer; void* src = (void*)(address + q->out * q->stride); *dst = src; } diff --git a/renderer/src/containers/ringqueue.h b/renderer/src/containers/ringqueue.h index f0e4ee8..9f746aa 100644 --- a/renderer/src/containers/ringqueue.h +++ b/renderer/src/containers/ringqueue.h @@ -23,10 +23,10 @@ typedef struct ring_queue } ring_queue; -u8 init_ring_queue(ring_queue* q, void* buffer, u64 capacity, u64 stride); -void shutdown_ring_queue(ring_queue* q); -u8 ring_queue_pushback(ring_queue* q, const void* src); -u8 ring_queue_popfront(ring_queue* q, void** dst); -static inline u8 is_ring_queue_full(const ring_queue* q) { return q->in == ((q->out + q->capacity) & q->capacity); } -static inline u8 is_ring_queue_empty(const ring_queue* q) { return q->in == q->out; } -static inline void* ring_queue_peak(ring_queue* q) { return is_ring_queue_empty(q) ? NULL : (void*)((u64)q->buffer + q->out * q->stride); } +u8 init_ring_queue(ring_queue* restrict q, void* restrict buffer, u64 capacity, u64 stride); +void shutdown_ring_queue(ring_queue* restrict q); +u8 ring_queue_pushback(ring_queue* restrict q, const void* restrict src); +u8 ring_queue_popfront(ring_queue* restrict q, void** restrict dst); +static inline u8 is_ring_queue_full(const ring_queue* restrict q) { return q->in == ((q->out + q->capacity) & q->capacity); } +static inline u8 is_ring_queue_empty(const ring_queue* restrict q) { return q->in == q->out; } +static inline void* ring_queue_peak(ring_queue* restrict q) { return is_ring_queue_empty(q) ? NULL : (void*)((u64)q->buffer + q->out * q->stride); } diff --git a/renderer/src/logger.c b/renderer/src/logger.c index 43a12e6..6fa7d1a 100644 --- a/renderer/src/logger.c +++ b/renderer/src/logger.c @@ -1,15 +1,21 @@ /* -Copyright (C) 2024 Frosch - This file is part of Shape of Fantasy. +Copyright (C) 2024 Frosch -Shape of Fantasy is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. -Shape of Fantasy is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. - -You should have received a copy of the GNU General Public License along with Shape of Fantasy. If not, see . +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. +You should have received a copy of the GNU General Public License +along with this program. If not, see . + */ #include "logger.h" diff --git a/renderer/src/renderer.c b/renderer/src/renderer.c index 085f214..20f2f5b 100644 --- a/renderer/src/renderer.c +++ b/renderer/src/renderer.c @@ -1,14 +1,20 @@ /* -Copyright (C) 2024 Frosch - This file is part of Shape of Fantasy. +Copyright (C) 2024 Frosch -Shape of Fantasy is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. -Shape of Fantasy is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. -You should have received a copy of the GNU General Public License along with Shape of Fantasy. If not, see . +You should have received a copy of the GNU General Public License +along with this program. If not, see . */ @@ -28,7 +34,10 @@ You should have received a copy of the GNU General Public License along with Sha #include #define STB_IMAGE_IMPLEMENTATION -#include +#include + +#include +#include FT_FREETYPE_H #define MAX_FRAMES_IN_FLIGHT 2 // must be a power of two! #define MAX_TEXTURES 256 @@ -221,7 +230,7 @@ u8 can_pop_window_event() return !is_ring_queue_empty(&window_event_queue); } -void pop_window_event(window_event* event) +void pop_window_event(window_event* restrict event) { void* ptr; ring_queue_popfront(&window_event_queue, &ptr); @@ -266,7 +275,7 @@ static void window_key_callback(GLFWwindow* window, int key, int scancode, int a ring_queue_pushback(&window_event_queue, &event); } -u8 init_window(const char* name, int width, int height) +u8 init_window(const char* restrict name, const int width, const int height) { init_ring_queue(&window_event_queue, window_event_buffer, MAX_WINDOW_EVENTS_QUEUE_CAPACITY, sizeof(window_event)); @@ -304,7 +313,7 @@ void poll_window_input() // Vulkan // -static VkDeviceSize aligned_size(VkDeviceSize old_size, VkDeviceSize alignment) +static VkDeviceSize aligned_size(const VkDeviceSize old_size, const VkDeviceSize alignment) { return (old_size + alignment - 1) & ~(alignment - 1); } @@ -541,7 +550,7 @@ static u8 init_surface() } // return queue family indices of a physical device; prefer graphics and presentation in the same queue -static queue_family_indices find_queue_families(VkPhysicalDevice physical_device) +static queue_family_indices find_queue_families(const VkPhysicalDevice physical_device) { queue_family_indices indices = {.is_graphics = 0, .is_present = 0}; u32 queue_family_count = 0; @@ -596,7 +605,7 @@ static queue_family_indices find_queue_families(VkPhysicalDevice physical_device return indices; } -static u8 check_physical_device_extension_support(VkPhysicalDevice physical_device) +static u8 check_physical_device_extension_support(const VkPhysicalDevice physical_device) { u32 available_extension_size = 0; if (vkEnumerateDeviceExtensionProperties(physical_device, NULL, &available_extension_size, NULL) != VK_SUCCESS) @@ -633,7 +642,7 @@ static u8 check_physical_device_extension_support(VkPhysicalDevice physical_devi return 1; } -static u8 init_swap_chain_support_details(swap_chain_support_details* support_details, VkPhysicalDevice physical_device) +static u8 init_swap_chain_support_details(swap_chain_support_details* restrict support_details, const VkPhysicalDevice physical_device) { support_details->formats = NULL; support_details->format_size = 0; @@ -679,7 +688,7 @@ static u8 init_swap_chain_support_details(swap_chain_support_details* support_de return 1; } -static void shutdown_swap_chain_support_details(swap_chain_support_details* support_details) +static void shutdown_swap_chain_support_details(swap_chain_support_details* restrict support_details) { free(support_details->formats); free(support_details->present_modes); @@ -807,9 +816,9 @@ static u8 init_logical_device() } VkDeviceQueueCreateInfo queue_infos[2]; - f32 priority = 1.0f; + const f32 priority = 1.0f; for (u32 i = 0; i < unique_queue_family_size; i++) - queue_infos[i] =(VkDeviceQueueCreateInfo) + queue_infos[i] = (VkDeviceQueueCreateInfo) { .sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, .queueFamilyIndex = unique_queue_families[i], @@ -860,7 +869,7 @@ static u8 init_logical_device() return 1; } -static u8 allocate_command_buffers(VkCommandPool command_pool, VkCommandBuffer* command_buffers, u32 command_buffer_count) +static u8 allocate_command_buffers(const VkCommandPool command_pool, VkCommandBuffer* restrict command_buffers, const u32 command_buffer_count) { const VkCommandBufferAllocateInfo alloc_info = { @@ -880,7 +889,7 @@ static u8 allocate_command_buffers(VkCommandPool command_pool, VkCommandBuffer* return 1; } -static u8 begin_command_recording(VkCommandBuffer command_buffer, VkCommandBufferUsageFlags flags) +static u8 begin_command_recording(const VkCommandBuffer command_buffer, const VkCommandBufferUsageFlags flags) { const VkCommandBufferBeginInfo info = { @@ -897,7 +906,7 @@ static u8 begin_command_recording(VkCommandBuffer command_buffer, VkCommandBuffe return 1; } -static u8 end_command_recording(VkCommandBuffer command_buffer) +static u8 end_command_recording(const VkCommandBuffer command_buffer) { if (vkEndCommandBuffer(command_buffer) != VK_SUCCESS) { @@ -916,7 +925,7 @@ void shutdown_single_submit_context() u8 init_single_submit_context() { - queue_family_indices family_indices = find_queue_families(context.device.physical); + const queue_family_indices family_indices = find_queue_families(context.device.physical); const VkCommandPoolCreateInfo create_info = { .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, @@ -948,12 +957,12 @@ u8 init_single_submit_context() return 1; } -static u8 begin_single_submit_command_recording(VkCommandBuffer command_buffer) +static u8 begin_single_submit_command_recording(const VkCommandBuffer command_buffer) { return begin_command_recording(command_buffer, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT); } -static u8 end_single_submit_command_recording(VkCommandBuffer command_buffer) +static u8 end_single_submit_command_recording(const VkCommandBuffer command_buffer) { end_command_recording(command_buffer); @@ -982,7 +991,7 @@ static u8 end_single_submit_command_recording(VkCommandBuffer command_buffer) return 1; } -static u32 buffer_find_memory_type(VkPhysicalDevice physical_device, u32 type_filter, VkMemoryPropertyFlags properties) +static u32 buffer_find_memory_type(const VkPhysicalDevice physical_device, const u32 type_filter, const VkMemoryPropertyFlags properties) { VkPhysicalDeviceMemoryProperties device_mem_properties; vkGetPhysicalDeviceMemoryProperties(physical_device, &device_mem_properties); @@ -997,9 +1006,9 @@ static u32 buffer_find_memory_type(VkPhysicalDevice physical_device, u32 type_fi return 0; } -static u8 init_vulkan_buffer(vulkan_buffer* buffer, VkDeviceSize byte_size, VkBufferUsageFlags usage, VkMemoryPropertyFlags properties) +static u8 init_vulkan_buffer(vulkan_buffer* restrict buffer, const VkDeviceSize byte_size, const VkBufferUsageFlags usage, const VkMemoryPropertyFlags properties) { - VkBufferCreateInfo buffer_info = + const VkBufferCreateInfo buffer_info = { .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, .size = byte_size, @@ -1018,7 +1027,7 @@ static u8 init_vulkan_buffer(vulkan_buffer* buffer, VkDeviceSize byte_size, VkBu VkMemoryRequirements mem_reqs; vkGetBufferMemoryRequirements(context.device.logical, buffer->handle, &mem_reqs); - VkMemoryAllocateInfo mem_alloc_info = + const VkMemoryAllocateInfo mem_alloc_info = { .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, .allocationSize = mem_reqs.size, @@ -1042,36 +1051,36 @@ static u8 init_vulkan_buffer(vulkan_buffer* buffer, VkDeviceSize byte_size, VkBu } // staging buffer, CPU accessible memory -static u8 init_vulkan_staging_buffer(vulkan_buffer* buffer, VkDeviceSize byte_size) +static u8 init_vulkan_staging_buffer(vulkan_buffer* restrict buffer, const VkDeviceSize byte_size) { return init_vulkan_buffer(buffer, byte_size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT); } // uniform buffer, CPU accessible memory -static u8 init_vulkan_uniform_buffer(vulkan_buffer* buffer, VkDeviceSize byte_size) +static u8 init_vulkan_uniform_buffer(vulkan_buffer* restrict buffer, const VkDeviceSize byte_size) { return init_vulkan_buffer(buffer, byte_size, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT); } // vertex buffer, device memory -static u8 init_vulkan_vertex_buffer(vulkan_buffer* buffer, VkDeviceSize byte_size) +static u8 init_vulkan_vertex_buffer(vulkan_buffer* restrict buffer, const VkDeviceSize byte_size) { return init_vulkan_buffer(buffer, byte_size, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT); } // index buffer, device memory -static u8 init_vulkan_index_buffer(vulkan_buffer* buffer, VkDeviceSize byte_size) +static u8 init_vulkan_index_buffer(vulkan_buffer* restrict buffer, const VkDeviceSize byte_size) { return init_vulkan_buffer(buffer, byte_size, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT); } -static void shutdown_vulkan_buffer(vulkan_buffer* buffer) +static void shutdown_vulkan_buffer(const vulkan_buffer* restrict buffer) { vkFreeMemory(context.device.logical, buffer->memory, context.allocator); vkDestroyBuffer(context.device.logical, buffer->handle, context.allocator); } -static u8 map_vulkan_buffer(vulkan_buffer* buffer, VkDeviceSize offset, VkDeviceSize byte_size, VkMemoryMapFlags flags) +static u8 map_vulkan_buffer(vulkan_buffer* restrict buffer, const VkDeviceSize offset, const VkDeviceSize byte_size, const VkMemoryMapFlags flags) { if (vkMapMemory(context.device.logical, buffer->memory, offset, byte_size, flags, &buffer->mapped) != VK_SUCCESS) { @@ -1081,12 +1090,12 @@ static u8 map_vulkan_buffer(vulkan_buffer* buffer, VkDeviceSize offset, VkDevice return 1; } -static void unmap_vulkan_buffer(vulkan_buffer* buffer) +static void unmap_vulkan_buffer(const vulkan_buffer* restrict buffer) { vkUnmapMemory(context.device.logical, buffer->memory); } -static u8 load_vulkan_buffer(vulkan_buffer* buffer, VkDeviceSize offset, VkDeviceSize byte_size, VkMemoryMapFlags flags, const void* data) +static u8 load_vulkan_buffer(vulkan_buffer* restrict buffer, const VkDeviceSize offset, const VkDeviceSize byte_size, const VkMemoryMapFlags flags, const void* restrict data) { if (!map_vulkan_buffer(buffer, offset, byte_size, flags)) { @@ -1099,14 +1108,14 @@ static u8 load_vulkan_buffer(vulkan_buffer* buffer, VkDeviceSize offset, VkDevic return 1; } -static u8 copy_vulkan_buffer(vulkan_buffer* dst, vulkan_buffer* src, VkDeviceSize dst_offset, VkDeviceSize src_offset, VkDeviceSize byte_size) +static u8 copy_vulkan_buffer(const vulkan_buffer* restrict dst, const vulkan_buffer* restrict src, const VkDeviceSize dst_offset, const VkDeviceSize src_offset, const VkDeviceSize byte_size) { VkCommandBuffer command_buffer; if (!allocate_command_buffers(context.single_submit_context.command_pool, &command_buffer, 1)) return 0; if (!begin_single_submit_command_recording(command_buffer)) return 0; - VkBufferCopy copy_region = + const VkBufferCopy copy_region = { .dstOffset = dst_offset, .srcOffset = src_offset, @@ -1120,7 +1129,7 @@ static u8 copy_vulkan_buffer(vulkan_buffer* dst, vulkan_buffer* src, VkDeviceSiz return 1; } -static u8 upload_vulkan_gpu_buffer(vulkan_buffer* buffer, const void* data, const VkDeviceSize byte_size) +static u8 upload_vulkan_gpu_buffer(const vulkan_buffer* restrict buffer, const void* restrict data, const VkDeviceSize byte_size) { vulkan_buffer staging_buffer; if (!init_vulkan_staging_buffer(&staging_buffer, byte_size)) return 0; @@ -1130,7 +1139,7 @@ static u8 upload_vulkan_gpu_buffer(vulkan_buffer* buffer, const void* data, cons return 1; } -static u8 find_vulkan_memory_type(u32* type_index, u32 type_filter, VkMemoryPropertyFlags properties) +static u8 find_vulkan_memory_type(u32* restrict type_index, const u32 type_filter, const VkMemoryPropertyFlags properties) { VkPhysicalDeviceMemoryProperties physical_properties; vkGetPhysicalDeviceMemoryProperties(context.device.physical, &physical_properties); @@ -1145,7 +1154,7 @@ static u8 find_vulkan_memory_type(u32* type_index, u32 type_filter, VkMemoryProp return 0; } -static u8 init_image_view(VkImageView* view, VkImage image, VkImageViewType type, VkFormat format, VkImageAspectFlags flags, u32 layer_count) +static u8 init_image_view(VkImageView* restrict view, const VkImage image, const VkImageViewType type, const VkFormat format, const VkImageAspectFlags flags, const u32 layer_count) { const VkImageSubresourceRange subresource_range = { @@ -1175,14 +1184,14 @@ static u8 init_image_view(VkImageView* view, VkImage image, VkImageViewType type return 1; } -static void shutdown_image_view(VkImageView view) +static void shutdown_image_view(const VkImageView view) { vkDestroyImageView(context.device.logical, view, context.allocator); } -static u8 init_vulkan_image(vulkan_image* image, u32 width, u32 height, u32 layer_count, VkFormat format, - VkImageTiling tiling, VkImageUsageFlags usage, VkMemoryPropertyFlags properties, - VkImageViewType view_type, VkImageAspectFlags aspect_flags) +static u8 init_vulkan_image(vulkan_image* restrict image, const u32 width, const u32 height, const u32 layer_count, const VkFormat format, + const VkImageTiling tiling, const VkImageUsageFlags usage, const VkMemoryPropertyFlags properties, + const VkImageViewType view_type, const VkImageAspectFlags aspect_flags) { image->width = width; image->height = height; @@ -1224,7 +1233,7 @@ static u8 init_vulkan_image(vulkan_image* image, u32 width, u32 height, u32 laye trace_log(LOG_ERROR, "Failed to create Vulkan image; failed to find a suitable memory type."); return 0; } - VkMemoryAllocateInfo mem_alloc_info = + const VkMemoryAllocateInfo mem_alloc_info = { .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, .allocationSize = mem_reqs.size, @@ -1246,14 +1255,14 @@ static u8 init_vulkan_image(vulkan_image* image, u32 width, u32 height, u32 laye return init_image_view(&image->view_handle, image->handle, view_type, format, aspect_flags, layer_count); } -static void shutdown_vulkan_image(vulkan_image* image) +static void shutdown_vulkan_image(const vulkan_image* restrict image) { shutdown_image_view(image->view_handle); vkFreeMemory(context.device.logical, image->memory, context.allocator); vkDestroyImage(context.device.logical, image->handle, context.allocator); } -static u8 transition_image_layout(vulkan_image* image, VkImageLayout old_layout, VkImageLayout new_layout) +static u8 transition_image_layout(const vulkan_image* restrict image, const VkImageLayout old_layout, const VkImageLayout new_layout) { VkCommandBuffer command_buffer; if (!allocate_command_buffers(context.single_submit_context.command_pool, &command_buffer, 1)) return 0; @@ -1313,7 +1322,7 @@ static u8 transition_image_layout(vulkan_image* image, VkImageLayout old_layout, return 1; } -static u8 load_image_2D(vulkan_image* image, u32 offset_x, u32 offset_y, u32 size_x, u32 size_y, const void* pixels, u64 byte_size) +static u8 load_image_2D(const vulkan_image* restrict image, const u32 offset_x, const u32 offset_y, const u32 size_x, const u32 size_y, const void* restrict pixels, const u64 byte_size) { vulkan_buffer staging_buffer; if (!init_vulkan_staging_buffer(&staging_buffer, byte_size)) return 0; @@ -1355,7 +1364,7 @@ static u8 load_image_2D(vulkan_image* image, u32 offset_x, u32 offset_y, u32 siz return 1; } -static u8 load_image_2D_array(vulkan_image* image, u32 size_x, u32 size_y, const void* pixels, u64 byte_size) +static u8 load_image_2D_array(const vulkan_image* restrict image, const u32 size_x, const u32 size_y, const void* restrict pixels, const u64 byte_size) { vulkan_buffer staging_buffer; if (!init_vulkan_staging_buffer(&staging_buffer, byte_size)) return 0; @@ -1402,7 +1411,7 @@ static u8 load_image_2D_array(vulkan_image* image, u32 size_x, u32 size_y, const return 1; } -static VkSurfaceFormatKHR choose_surface_format(const VkSurfaceFormatKHR* available_formats, u32 available_format_size) +static VkSurfaceFormatKHR choose_surface_format(const VkSurfaceFormatKHR* restrict available_formats, const u32 available_format_size) { for (u32 i = 0; i < available_format_size; i++) if (available_formats[i].format == VK_FORMAT_B8G8R8A8_SRGB && available_formats[i].colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) @@ -1411,7 +1420,7 @@ static VkSurfaceFormatKHR choose_surface_format(const VkSurfaceFormatKHR* availa return available_formats[0]; } -static VkPresentModeKHR choose_present_mode(const VkPresentModeKHR* available_present_modes, u32 available_present_mode_size) +static VkPresentModeKHR choose_present_mode(const VkPresentModeKHR* restrict available_present_modes, const u32 available_present_mode_size) { for (u32 i = 0; i < available_present_mode_size; i++) if (available_present_modes[i] == VK_PRESENT_MODE_MAILBOX_KHR) @@ -1420,7 +1429,7 @@ static VkPresentModeKHR choose_present_mode(const VkPresentModeKHR* available_pr return VK_PRESENT_MODE_FIFO_KHR; } -static VkExtent2D choose_extent(const VkSurfaceCapabilitiesKHR* capabilities) +static VkExtent2D choose_extent(const VkSurfaceCapabilitiesKHR* restrict capabilities) { if (capabilities->currentExtent.width != UINT32_MAX) return capabilities->currentExtent; @@ -1449,7 +1458,7 @@ static void shutdown_swap_chain() trace_log(LOG_DEBUG, "Vulkan swap chain successfully destroyed."); } -static u8 init_swap_chain(u8 do_signal_shutdown) +static u8 init_swap_chain(const u8 do_signal_shutdown) { swap_chain_support_details support_details; init_swap_chain_support_details(&support_details, context.device.physical); @@ -1563,9 +1572,9 @@ void shutdown_depth() trace_log(LOG_DEBUG, "Depth image successfully destroyed."); } -static u8 init_depth(u8 do_signal_shutdown) +static u8 init_depth(const u8 do_signal_shutdown) { - VkFormat format = find_depth_format(); + const VkFormat format = find_depth_format(); if (format == VK_FORMAT_UNDEFINED) { trace_log(LOG_ERROR, "Failed to create depth image; failed to find a supported format."); @@ -1667,7 +1676,7 @@ static u8 init_render_pass() return 1; } -static void begin_render_pass(VkCommandBuffer command_buffer, u32 image_index) +static void begin_render_pass(const VkCommandBuffer command_buffer, const u32 image_index) { const VkRect2D render_area = { @@ -1692,7 +1701,7 @@ static void begin_render_pass(VkCommandBuffer command_buffer, u32 image_index) vkCmdBeginRenderPass(command_buffer, &info, VK_SUBPASS_CONTENTS_INLINE); } -static void end_render_pass(VkCommandBuffer command_buffer) +static void end_render_pass(const VkCommandBuffer command_buffer) { vkCmdEndRenderPass(command_buffer); } @@ -1705,7 +1714,7 @@ static void shutdown_swap_chain_framebuffers() trace_log(LOG_DEBUG, "Swap chain framebuffers successfully destroyed."); } -static u8 init_swap_chain_framebuffers(u8 do_signal_shutdown) +static u8 init_swap_chain_framebuffers(const u8 do_signal_shutdown) { context.swap_chain_framebuffers = malloc(context.swap_chain.image_count * sizeof(VkFramebuffer)); for (u32 i = 0; i < context.swap_chain.image_count; i++) @@ -1743,7 +1752,7 @@ static void shutdown_command_pool() static u8 init_command_pool() { - queue_family_indices family_indices = find_queue_families(context.device.physical); + const queue_family_indices family_indices = find_queue_families(context.device.physical); const VkCommandPoolCreateInfo create_info = { .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, @@ -1912,11 +1921,11 @@ static u8 init_camera() }; const VkWriteDescriptorSet write = { - .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, + .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, .dstSet = context.camera_descriptor_sets[i], .dstBinding = 0, .dstArrayElement = 0, - .descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, + .descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, .descriptorCount = 1, .pBufferInfo = &buffer_info, .pImageInfo = NULL, @@ -1933,25 +1942,25 @@ static u8 init_camera() return 1; } -void set_camera_view(const f32* view) +void set_camera_view(const f32* restrict view) { memcpy(context.camera.view, view, sizeof(f32) * 16); context.update_camera_uniform_counter= MAX_FRAMES_IN_FLIGHT; } -void set_camera_perspective_projection(const f32* perspective) +void set_camera_perspective_projection(const f32* restrict perspective) { memcpy(context.camera.perspective, perspective, sizeof(f32) * 16); context.update_camera_uniform_counter = MAX_FRAMES_IN_FLIGHT; } -void set_camera_orthographic_projection(const f32* orthographic) +void set_camera_orthographic_projection(const f32* restrict orthographic) { memcpy(context.camera.orthographic, orthographic, sizeof(f32) * 16); context.update_camera_uniform_counter = MAX_FRAMES_IN_FLIGHT; } -static u8 init_texture(texture* t, u32 width, u32 height, VkImageViewType view_type, VkFormat format, u32 layer_count) +static u8 init_texture(texture* restrict t, const u32 width, const u32 height, const VkImageViewType view_type, const VkFormat format, const u32 layer_count) { if (!init_vulkan_image(&t->image, width, height, layer_count, format, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT, @@ -2011,7 +2020,7 @@ static u8 init_texture(texture* t, u32 width, u32 height, VkImageViewType view_t return 1; } -static void shutdown_texture(texture* t) +static void shutdown_texture(const texture* restrict t) { vkFreeDescriptorSets(context.device.logical, context.texture_descriptor_pool, MAX_FRAMES_IN_FLIGHT, t->descriptor_sets); shutdown_vulkan_image(&t->image); @@ -2041,7 +2050,7 @@ static u8 init_textures() VkPhysicalDeviceProperties properties; vkGetPhysicalDeviceProperties(context.device.physical, &properties); - VkSamplerCreateInfo sampler_info = + const VkSamplerCreateInfo sampler_info = { .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, .magFilter = VK_FILTER_LINEAR, @@ -2118,7 +2127,7 @@ static u8 init_textures() return 1; } -u8 insert_image_2d_texture_from_file(const char* name) +u8 insert_image_2d_texture_from_file(const char* restrict name) { char path[512]; snprintf(path, 512, "resources/textures/%s.png", name); @@ -2142,7 +2151,7 @@ u8 insert_image_2d_texture_from_file(const char* name) return (hash_table_insert(&context.textures, name, &t) != NULL); } -u8 remove_texture(const char* name) +u8 remove_texture(const char* restrict name) { texture t; void* ptexture = &t; @@ -2168,7 +2177,7 @@ static VkDeviceSize get_vertex_input_byte_size(const vertex_input_type t, const } } -static u8 init_mesh(mesh* msh, const mesh_geometry* geometry, vertex_input_type geometry_type, u64 max_instances, vertex_input_type instance_type) +static u8 init_mesh(mesh* restrict msh, const mesh_geometry* restrict geometry, const vertex_input_type geometry_type, const u64 max_instances, const vertex_input_type instance_type) { if (!geometry) return 0; @@ -2183,22 +2192,22 @@ static u8 init_mesh(mesh* msh, const mesh_geometry* geometry, vertex_input_type if (!max_instances) return 0; - const VkDeviceSize byte_size = get_vertex_input_byte_size(instance_type, max_instances); - if (!init_vulkan_vertex_buffer(&msh->instance_buffer, byte_size)) return 0; + const VkDeviceSize instance_byte_size = get_vertex_input_byte_size(instance_type, max_instances); + if (!init_vulkan_vertex_buffer(&msh->instance_buffer, instance_byte_size)) return 0; msh->max_instances = max_instances; msh->instance_count = 0; return 1; } -static void shutdown_mesh(mesh* msh) +static void shutdown_mesh(const mesh* restrict msh) { shutdown_vulkan_buffer(&msh->index_buffer); shutdown_vulkan_buffer(&msh->instance_buffer); shutdown_vulkan_buffer(&msh->vertex_buffer); } -static u8 init_shader_module(VkShaderModule* module, const char* path) +static u8 init_shader_module(VkShaderModule* restrict module, const char* restrict path) { *module = VK_NULL_HANDLE; @@ -2209,7 +2218,7 @@ static u8 init_shader_module(VkShaderModule* module, const char* path) return 0; } fseek(file, 0L, SEEK_END); - long int size = ftell(file); + const long int size = ftell(file); rewind(file); char* byte_code = (char*)malloc(size + 1); fread(byte_code, size, 1, file); @@ -2233,12 +2242,12 @@ static u8 init_shader_module(VkShaderModule* module, const char* path) return 1; } -static void shutdown_shader_module(VkShaderModule module) +static void shutdown_shader_module(const VkShaderModule module) { vkDestroyShaderModule(context.device.logical, module, context.allocator); } -static u8 init_mesh_pipeline(mesh_pipeline* pipeline, const mesh_pipeline_template* template) +static u8 init_mesh_pipeline(mesh_pipeline* restrict pipeline, const mesh_pipeline_template* restrict template) { // device features VkPhysicalDeviceFeatures device_features; @@ -2410,7 +2419,7 @@ static u8 init_mesh_pipeline(mesh_pipeline* pipeline, const mesh_pipeline_templa }; // depth and stencil; reverse z convention means higher depth brings you closer - VkPipelineDepthStencilStateCreateInfo depth_stencil = + const VkPipelineDepthStencilStateCreateInfo depth_stencil = { .sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, .depthTestEnable = VK_TRUE, @@ -2535,7 +2544,7 @@ static u8 init_mesh_pipeline(mesh_pipeline* pipeline, const mesh_pipeline_templa destroy_darray(stage_infos); for (u8 i = 0; i < 2; i++) shutdown_shader_module(modules[i]); - // meshes + // prep for meshes pipeline->geometry_type = template->geometry_type; pipeline->instance_type = template->instance_type; init_hash_table(&pipeline->meshes, 8, sizeof(mesh), basic_hash); @@ -2547,7 +2556,7 @@ static u8 init_mesh_pipeline(mesh_pipeline* pipeline, const mesh_pipeline_templa return 1; } -static void shutdown_mesh_pipeline(mesh_pipeline* pipeline) +static void shutdown_mesh_pipeline(mesh_pipeline* restrict pipeline) { // clean up meshes for (u32 i = 0; i < pipeline->meshes.slot_count; i++) @@ -2563,11 +2572,11 @@ static void shutdown_mesh_pipeline(mesh_pipeline* pipeline) vkDestroyPipelineLayout(context.device.logical, pipeline->layout, context.allocator); } -u8 draw_mesh_pipeline(const char* name) +u8 draw_mesh_pipeline(const char* restrict name) { // bind pipeline - VkCommandBuffer command_buffer = context.frames[context.current_frame].command_buffer; - mesh_pipeline* pipeline = hash_table_lookup(&context.mesh_pipelines, name); + const VkCommandBuffer command_buffer = context.frames[context.current_frame].command_buffer; + const mesh_pipeline* pipeline = hash_table_lookup(&context.mesh_pipelines, name); if (!pipeline) { trace_log(LOG_ERROR, "Failed to draw mesh pipeline '%s'; pipeline lookup failed." , name); @@ -2581,7 +2590,7 @@ u8 draw_mesh_pipeline(const char* name) // bind texture descriptor set (set 1) if (pipeline->texture_name[0] != '\0') { - texture* t = hash_table_lookup(&context.textures, pipeline->texture_name); + const texture* t = hash_table_lookup(&context.textures, pipeline->texture_name); if (!t) { trace_log(LOG_ERROR, "Failed to draw mesh pipeline '%s'; texture '%s' lookup failed.", name, pipeline->texture_name); @@ -2593,7 +2602,7 @@ u8 draw_mesh_pipeline(const char* name) for (u32 i = 0; i < pipeline->meshes.slot_count; i++) for (hash_table_entry* entry = pipeline->meshes.entries[i]; entry != NULL; entry = entry->next) { - mesh* msh = entry->data; + const mesh* msh = entry->data; // bind vertex, instance, and index buffers const VkDeviceSize offsets[] = { 0 }; @@ -2610,9 +2619,9 @@ u8 draw_mesh_pipeline(const char* name) return 1; } -u8 insert_mesh_pipeline(const char* name, vertex_input_type geometry_type, vertex_input_type instance_type, const char* texture_name) +u8 insert_mesh_pipeline(const char* restrict name, const vertex_input_type geometry_type, const vertex_input_type instance_type, const char* restrict texture_name) { - mesh_pipeline_template template = + const mesh_pipeline_template template = { .name = name, .geometry_type = geometry_type, @@ -2630,7 +2639,7 @@ u8 insert_mesh_pipeline(const char* name, vertex_input_type geometry_type, verte return 1; } -u8 remove_mesh_pipeline(const char* name) +u8 remove_mesh_pipeline(const char* restrict name) { mesh_pipeline* pipeline = hash_table_lookup(&context.mesh_pipelines, name); if (!pipeline) @@ -2643,7 +2652,7 @@ u8 remove_mesh_pipeline(const char* name) return hash_table_remove(&context.mesh_pipelines, name, NULL); } -u8 change_mesh_pipeline_mode(const char* name, mesh_pipeline_mode mode) +u8 change_mesh_pipeline_mode(const char* restrict name, const mesh_pipeline_mode mode) { mesh_pipeline* pipeline = hash_table_lookup(&context.mesh_pipelines, name); if (!pipeline) @@ -2672,7 +2681,7 @@ u8 change_mesh_pipeline_mode(const char* name, mesh_pipeline_mode mode) } } -u8 insert_mesh(const char* pipeline_name, const char* mesh_name, const mesh_geometry* geometry, const u64 max_instances) +u8 insert_mesh(const char* restrict pipeline_name, const char* restrict mesh_name, const mesh_geometry* restrict geometry, const u64 max_instances) { mesh_pipeline* pipeline = hash_table_lookup(&context.mesh_pipelines, pipeline_name); if (!pipeline) @@ -2692,7 +2701,7 @@ u8 insert_mesh(const char* pipeline_name, const char* mesh_name, const mesh_geom return 1; } -u8 remove_mesh(const char* pipeline_name, const char* mesh_name) +u8 remove_mesh(const char* restrict pipeline_name, const char* restrict mesh_name) { mesh_pipeline* pipeline = hash_table_lookup(&context.mesh_pipelines, pipeline_name); if (!pipeline) @@ -2712,7 +2721,7 @@ u8 remove_mesh(const char* pipeline_name, const char* mesh_name) return hash_table_remove(&pipeline->meshes, mesh_name, NULL); } -u8 load_mesh_instance_data(const char* pipeline_name, const char* mesh_name, const mesh_instance_data* instance_data) +u8 load_mesh_instance_data(const char* restrict pipeline_name, const char* restrict mesh_name, const mesh_instance_data* restrict instance_data) { mesh_pipeline* pipeline = hash_table_lookup(&context.mesh_pipelines, pipeline_name); if (!pipeline) @@ -2734,8 +2743,8 @@ u8 load_mesh_instance_data(const char* pipeline_name, const char* mesh_name, con return 0; } - const VkDeviceSize byte_size = get_vertex_input_byte_size(pipeline->instance_type, instance_data->instance_count); - if (!upload_vulkan_gpu_buffer(&msh->instance_buffer, instance_data->instances, byte_size)) return 0; + const VkDeviceSize instance_byte_size = get_vertex_input_byte_size(pipeline->instance_type, instance_data->instance_count); + if (!upload_vulkan_gpu_buffer(&msh->instance_buffer, instance_data->instances, instance_byte_size)) return 0; msh->instance_count = instance_data->instance_count; return 1; @@ -2819,7 +2828,7 @@ static u8 recreate_swap_chain() u8 begin_render_frame() { - vulkan_frame_data* frame = context.frames + context.current_frame; + const vulkan_frame_data* frame = context.frames + context.current_frame; vkWaitForFences(context.device.logical, 1, &frame->in_flight_fence, VK_TRUE, UINT64_MAX); @@ -2844,11 +2853,11 @@ u8 begin_render_frame() vkResetFences(context.device.logical, 1, &frame->in_flight_fence); - VkCommandBuffer command_buffer = frame->command_buffer; + const VkCommandBuffer command_buffer = frame->command_buffer; vkResetCommandBuffer(command_buffer, 0); begin_command_recording(command_buffer, 0); - VkViewport viewport = + const VkViewport viewport = { .x = 0.0f, .y = 0.0f, @@ -2859,7 +2868,7 @@ u8 begin_render_frame() }; vkCmdSetViewport(command_buffer, 0, 1, &viewport); - VkRect2D scissor = + const VkRect2D scissor = { .offset = {0, 0}, .extent = context.swap_chain.extent @@ -2873,8 +2882,8 @@ u8 begin_render_frame() u8 end_render_frame() { - vulkan_frame_data* frame = context.frames + context.current_frame; - VkCommandBuffer command_buffer = frame->command_buffer; + const vulkan_frame_data* frame = context.frames + context.current_frame; + const VkCommandBuffer command_buffer = frame->command_buffer; end_render_pass(command_buffer); end_command_recording(command_buffer); diff --git a/renderer/src/renderer.h b/renderer/src/renderer.h index fa57010..f716739 100644 --- a/renderer/src/renderer.h +++ b/renderer/src/renderer.h @@ -116,26 +116,26 @@ typedef enum // u8 can_pop_window_event(); -void pop_window_event(window_event* event); -u8 init_window(const char* name, int width, int height); +void pop_window_event(window_event* restrict event); +u8 init_window(const char* restrict name, const int width, const int height); void shutdown_window(); u8 is_window_open(); void poll_window_input(); -void set_camera_view(const f32* view); -void set_camera_perspective_projection(const f32* perspective); -void set_camera_orthographic_projection(const f32* orthographic); +void set_camera_view(const f32* restrict view); +void set_camera_perspective_projection(const f32* restrict perspective); +void set_camera_orthographic_projection(const f32* restrict orthographic); -u8 insert_image_2d_texture_from_file(const char* name); -u8 remove_texture(const char* name); +u8 insert_image_2d_texture_from_file(const char* restrict name); +u8 remove_texture(const char* restrict name); -u8 draw_mesh_pipeline(const char* name); -u8 insert_mesh_pipeline(const char* name, vertex_input_type geometry_type, vertex_input_type instance_type, const char* texture_name); -u8 remove_mesh_pipeline(const char* name); -u8 change_mesh_pipeline_mode(const char* name, mesh_pipeline_mode mode); -u8 insert_mesh(const char* pipeline_name, const char* mesh_name, const mesh_geometry* geometry, const u64 max_instances); -u8 remove_mesh(const char* pipeline_name, const char* mesh_name); -u8 load_mesh_instance_data(const char* pipeline_name, const char* mesh_name, const mesh_instance_data* instance_data); +u8 draw_mesh_pipeline(const char* restrict name); +u8 insert_mesh_pipeline(const char* restrict name, const vertex_input_type geometry_type, const vertex_input_type instance_type, const char* restrict texture_name); +u8 remove_mesh_pipeline(const char* restrict name); +u8 change_mesh_pipeline_mode(const char* restrict name, const mesh_pipeline_mode mode); +u8 insert_mesh(const char* restrict pipeline_name, const char* restrict mesh_name, const mesh_geometry* restrict geometry, const u64 max_instances); +u8 remove_mesh(const char* restrict pipeline_name, const char* restrict mesh_name); +u8 load_mesh_instance_data(const char* restrict pipeline_name, const char* restrict mesh_name, const mesh_instance_data* restrict instance_data); u8 init_vulkan(); void shutdown_vulkan();