void profiler_initialize(void) {
profile_total = profiler_create("total");
profile_render = profiler_create("render");
profile_present = profiler_create("present");
profile_cairo = profiler_create("cairo");
profile_loop = profiler_create("loop");
}
DWORD game_loop_main(LPVOID thread_input) {
struct common_vars common_vars = *(struct common_vars *)thread_input;
profiler profiler = {};
profiler_create(&profiler);
LARGE_INTEGER performance_frequency = {};
QueryPerformanceFrequency(&performance_frequency);
memory_arena memory_arena = {};
if (!virtual_alloc_memory_arena(m_megabytes(16), common_vars.system_info.dwPageSize, &memory_arena)) {
m_die("call to \"virtual_alloc_memory_arena\" failed(event_render_loop_thread memory arena)");
}
vulkan vulkan = {};
{
m_memory_arena_undo_allocations_at_scope_exit(&memory_arena);
string info_string = { memory_arena_allocate<char>(&memory_arena, m_kilobytes(4)), 0, m_kilobytes(2) };
string err_string = { memory_arena_allocate<char>(&memory_arena, m_kilobytes(1)), 0, m_kilobytes(1) };
vulkan_create_info vulkan_create_info = {};
vulkan_create_info.win32_instance = common_vars.instance;
vulkan_create_info.win32_window = common_vars.window;
const char *shader_file_paths[] = { "shaders\\swap_chain_pipeline_image.vert.spv", "shaders\\swap_chain_pipeline_image.frag.spv" };
if (!read_file_into_memory_arena(shader_file_paths[0], &memory_arena, &vulkan_create_info.swap_chain_pipeline_image_code[0], &vulkan_create_info.swap_chain_pipeline_image_code_sizes[0]) ||
!read_file_into_memory_arena(shader_file_paths[1], &memory_arena, &vulkan_create_info.swap_chain_pipeline_image_code[1], &vulkan_create_info.swap_chain_pipeline_image_code_sizes[1])) {
m_die("call to \"read_file_into_memory_arena\" failed(swap_chain_pipeline_image shaders)");
}
if (!vulkan_create(vulkan_create_info, &memory_arena, &info_string, &err_string, &vulkan)) {
m_die("%s", err_string.buf);
}
else {
m_printf("%s", info_string.buf);
}
}
game_buffer game_buffer = {};
vec4 game_buffer_viewport = {};
HANDLE game_buffer_gpk_file_handle = nullptr;
HANDLE game_buffer_gpk_file_mapping = nullptr;
void *game_buffer_gpk_file_mapping_ptr = nullptr;
HANDLE game_buffer_mpk_import_shared_memory_mapping = nullptr;
void *game_buffer_mpk_import_shared_memory_mapping_ptr = nullptr;
HANDLE game_buffer_mpk_import_shared_memory_semaphore = nullptr;
{
game_buffer_create_info game_buffer_create_info = {};
if (!virtual_alloc_memory_arena(m_megabytes(512), common_vars.system_info.dwPageSize, &game_buffer_create_info.memory_arena)) {
m_die("call to \"virtual_alloc_memory_arena\" failed(game buffer memory arena)");
}
game_buffer_create_info.vulkan = &vulkan;
game_buffer_create_info.vulkan_framebuffer_width = 1920;
game_buffer_create_info.vulkan_framebuffer_height = 1080;
if (!game_buffer_create(game_buffer_create_info, &game_buffer)) {
m_die("call to \"game_buffer_create\" failed");
}
#ifdef EDITOR_ENABLE
game_buffer_editor_create_info game_buffer_editor_create_info = {};
game_buffer_editor_create_info.game_buffer = &game_buffer;
game_buffer_editor_create_info.vulkan = &vulkan;
game_buffer_editor_create_info.imgui_init_file = "assets\\gpks\\example.gpk.imgui.ini";
game_buffer_editor_create_info.imgui_font_file = "assets\\fonts\\OpenSans-Regular.ttf";
game_buffer_editor_create_info.imgui_font_size = GetSystemMetrics(SM_CXSCREEN) / 150;
game_buffer_editor_create_info.set_imgui_keymap = [] (ImGuiIO *imgui_io) {
imgui_io->KeyMap[ImGuiKey_Tab] = VK_TAB;
imgui_io->KeyMap[ImGuiKey_LeftArrow] = VK_LEFT;
imgui_io->KeyMap[ImGuiKey_RightArrow] = VK_RIGHT;
imgui_io->KeyMap[ImGuiKey_UpArrow] = VK_UP;
imgui_io->KeyMap[ImGuiKey_DownArrow] = VK_DOWN;
imgui_io->KeyMap[ImGuiKey_PageUp] = VK_PRIOR;
imgui_io->KeyMap[ImGuiKey_PageDown] = VK_NEXT;
imgui_io->KeyMap[ImGuiKey_Home] = VK_HOME;
imgui_io->KeyMap[ImGuiKey_End] = VK_END;
imgui_io->KeyMap[ImGuiKey_Backspace] = VK_BACK;
imgui_io->KeyMap[ImGuiKey_Enter] = VK_RETURN;
imgui_io->KeyMap[ImGuiKey_Escape] = VK_ESCAPE;
imgui_io->KeyMap[ImGuiKey_A] = 'A';
imgui_io->KeyMap[ImGuiKey_C] = 'C';
imgui_io->KeyMap[ImGuiKey_V] = 'V';
imgui_io->KeyMap[ImGuiKey_X] = 'X';
imgui_io->KeyMap[ImGuiKey_Y] = 'Y';
imgui_io->KeyMap[ImGuiKey_Z] = 'Z';
};
{
m_memory_arena_undo_allocations_at_scope_exit(&memory_arena);
const char *file_paths[] = { "shaders\\imgui.vert.spv", "shaders\\imgui.frag.spv" };
VkShaderModule shader_modules[m_countof(file_paths)] = {};
for (uint i = 0; i < m_countof(file_paths); i += 1) {
void *file_data;
uint file_size;
if (!read_file_into_memory_arena(file_paths[i], &memory_arena, &file_data, &file_size)) {
m_die("call to \"read_file_into_memory_arena\" failed(game buffer shader files)");
}
VkShaderModuleCreateInfo shader_module_info = { VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO };
shader_module_info.codeSize = file_size;
shader_module_info.pCode = (const uint32_t *)file_data;
if(vkCreateShaderModule(vulkan.device, &shader_module_info, nullptr, &shader_modules[i]) != VK_SUCCESS) {
m_die("game buffer creation failed\ncall to \"vkCreateShaderModule\" failed for shader file %s", file_paths[i]);
}
}
game_buffer_editor_create_info.imgui_vulkan_shaders[0] = shader_modules[0];
game_buffer_editor_create_info.imgui_vulkan_shaders[1] = shader_modules[1];
}
game_buffer.editor = memory_arena_allocate<game_buffer_editor>(&game_buffer.memory_arena, 1);
*game_buffer.editor = {};
if (!game_buffer_editor_create(&game_buffer_editor_create_info, game_buffer.editor)) {
m_die("call to \"game_buffer_editor_create\" failed");
}
{
uint shared_memory_size = m_megabytes(32);
HANDLE shared_memory_mapping = CreateFileMappingA(INVALID_HANDLE_VALUE, nullptr, PAGE_READWRITE | SEC_COMMIT, 0, shared_memory_size, m_mpk_import_shared_memory_name);
if (!shared_memory_mapping) {
m_last_error_str(err_str);
m_die("call to \"CreateFileMappingA\" failed\nfile: %s\nerr: %s", m_mpk_import_shared_memory_name, err_str);
}
void *shared_memory_mapping_ptr = MapViewOfFile(shared_memory_mapping, FILE_MAP_WRITE, 0, 0, shared_memory_size);
if (!shared_memory_mapping_ptr) {
m_last_error_str(err_str);
m_die("call to \"MapViewOfFile\" failed\nfile: %s\nerr: %s", m_mpk_import_shared_memory_name, err_str);
}
((mpk_import_shared_memory_header *)shared_memory_mapping_ptr)->total_size = shared_memory_size;
((mpk_import_shared_memory_header *)shared_memory_mapping_ptr)->mpk_size = shared_memory_size - sizeof(struct mpk_import_shared_memory_header);
SetLastError(ERROR_SUCCESS);
HANDLE shared_memory_semaphore = CreateSemaphore(nullptr, 1, 1, m_mpk_import_shared_memory_semaphore_name);
if (!shared_memory_semaphore) {
m_last_error_str(err_str);
m_die("call to \"CreateSemaphore\" failed\nsemaphore: %s\nerr: %s", m_mpk_import_shared_memory_semaphore_name, err_str);
}
if (GetLastError() == ERROR_ALREADY_EXISTS) {
m_die("call to \"CreateSemaphore\" failed\nsemaphore: %s\nerr: %s", m_mpk_import_shared_memory_semaphore_name, "named semaphore already exist");
}
game_buffer_mpk_import_shared_memory_mapping = shared_memory_mapping;
game_buffer_mpk_import_shared_memory_mapping_ptr = shared_memory_mapping_ptr;
game_buffer_mpk_import_shared_memory_semaphore = shared_memory_semaphore;
}
{
game_buffer_editor_job *new_job = nullptr;
if (game_buffer_editor_add_mpk_job(&game_buffer, &new_job)) {
mpk_import_command_line cmdl = m_mpk_import_command_line_default;
cmdl.job_id = new_job->id;
cmdl.import_type = mpk_import_type_fbx;
strcpy(cmdl.fbx_file_path, "assets\\models\\simple_man\\simple_man.fbx");
mpk_import_create_process(&cmdl, common_vars.process_group, &memory_arena);
}
}
#endif // EDITOR_ENABLE
{
char gpk_file_name[] = "assets\\gpks\\example.gpk";
HANDLE gpk_file_handle = CreateFileA(gpk_file_name, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
if (gpk_file_handle == INVALID_HANDLE_VALUE) {
m_last_error_str(err_str);
m_die("call to \"CreateFile\" failed\nfile: %s\nerr: %s", gpk_file_name, err_str);
}
uint file_size = m_megabytes(32);
SetFilePointer(gpk_file_handle, file_size, nullptr, FILE_BEGIN);
if (!SetEndOfFile(gpk_file_handle)) {
m_last_error_str(err_str);
m_die("call to \"SetEndOfFile\" failed\nfile: %s\nsize: %d\nerr: %s", gpk_file_name, file_size, err_str);
}
HANDLE gpk_file_mapping = CreateFileMappingA(gpk_file_handle, nullptr, PAGE_READWRITE, 0, 0, nullptr);
if (!gpk_file_mapping) {
m_last_error_str(err_str);
m_die("call to \"CreateFileMappingA\" failed\nfile: %s\nerr: %s", gpk_file_name, err_str);
}
void *gpk_file_mapping_ptr = MapViewOfFile(gpk_file_mapping, FILE_MAP_WRITE, 0, 0, file_size);
if (!gpk_file_mapping_ptr) {
m_last_error_str(err_str);
m_die("call to \"MapViewOfFile\" failed\nfile: %s\nerr: %s", gpk_file_name, err_str);
}
uint gpk_file_initial_state_size = 0;
if (!gpk_write_initial_state(gpk_file_mapping_ptr, file_size, &gpk_file_initial_state_size)) {
m_die("call to \"gpk_write_initial_state\" failed");
}
if (!FlushViewOfFile(gpk_file_mapping_ptr, gpk_file_initial_state_size)) {
m_last_error_str(err_str);
m_die("call to \"FlushViewOfFile\" failed\nfile: %s\nerr: %s", gpk_file_name, err_str);
}
game_buffer_gpk_file_handle = gpk_file_handle;
game_buffer_gpk_file_mapping = gpk_file_mapping;
game_buffer_gpk_file_mapping_ptr = gpk_file_mapping_ptr;
}
{
game_buffer_update_vulkan_swap_chain_image(&game_buffer, &vulkan);
game_buffer_viewport = rectangle_fit_into_viewport((float)vulkan.swap_chain_info.imageExtent.width, (float)vulkan.swap_chain_info.imageExtent.height, (float)game_buffer.vulkan_framebuffer_image_width, (float)game_buffer.vulkan_framebuffer_image_height);
}
}
uint64 last_frame_time_microsecs = 0;
bool mouse_down_up_same_frame[3] = {};
for (;;) {
LARGE_INTEGER frame_begin_performance_count;
QueryPerformanceCounter(&frame_begin_performance_count);
m_scope_exit(
LARGE_INTEGER frame_end_performance_count;
QueryPerformanceCounter(&frame_end_performance_count);
last_frame_time_microsecs = (frame_end_performance_count.QuadPart - frame_begin_performance_count.QuadPart) * 1000000 / performance_frequency.QuadPart;
);
{
bool mouse_down_this_frame[3] = {};
for (uint i = 0; i < 3; i += 1) {
if (mouse_down_up_same_frame[i]) {
mouse_down_up_same_frame[i] = false;
#ifdef EDITOR_ENABLE
game_buffer_editor_handle_mouse_up(&game_buffer, i);
#endif
}
}
HANDLE iocp = common_vars.io_completion_port;
DWORD iocp_num_bytes = 0;
ULONG_PTR iocp_completion_key = 0;
LPOVERLAPPED iocp_overlapped = nullptr;
DWORD iocp_time_out = 0;
while (GetQueuedCompletionStatus(iocp, &iocp_num_bytes, &iocp_completion_key, &iocp_overlapped, iocp_time_out) == TRUE) {
switch (iocp_completion_key) {
case quit_win_main_event : {
#ifdef EDITOR_ENABLE
ImGui::Shutdown();
#endif
ExitThread(0);
} break;
case window_resize_event : {
uint32 new_width = LOWORD((LPARAM)iocp_overlapped);
uint32 new_height = HIWORD((LPARAM)iocp_overlapped);
if (vulkan.swap_chain_info.imageExtent.width != new_width || vulkan.swap_chain_info.imageExtent.height != new_height) {
if (!vulkan_resize_swap_chain_images(&vulkan, new_width, new_height)) {
m_die("call to \"vulkan_resize_swap_chain_images\" failed");
}
game_buffer_viewport = rectangle_fit_into_viewport((float)vulkan.swap_chain_info.imageExtent.width, (float)vulkan.swap_chain_info.imageExtent.height, (float)game_buffer.vulkan_framebuffer_image_width, (float)game_buffer.vulkan_framebuffer_image_height);
}
} break;
case key_down_event : {
} break;
case key_up_event : {
} break;
case mouse_move_event : {
#ifdef EDITOR_ENABLE
game_buffer_editor_handle_mouse_move(&game_buffer, game_buffer_viewport, LOWORD((LPARAM)iocp_overlapped), HIWORD((LPARAM)iocp_overlapped));
#endif
} break;
case mouse_lbutton_down_event : {
mouse_down_this_frame[0] = true;
#ifdef EDITOR_ENABLE
game_buffer_editor_handle_mouse_down(&game_buffer, 0);
#endif
} break;
case mouse_lbutton_up_event : {
if (mouse_down_this_frame[0]) {
mouse_down_up_same_frame[0] = true;
}
else {
#ifdef EDITOR_ENABLE
game_buffer_editor_handle_mouse_up(&game_buffer, 0);
#endif
}
} break;
case mouse_rbutton_down_event : {
mouse_down_this_frame[1] = true;
#ifdef EDITOR_ENABLE
game_buffer_editor_handle_mouse_down(&game_buffer, 1);
#endif
} break;
case mouse_rbutton_up_event : {
if (mouse_down_this_frame[1]) {
mouse_down_up_same_frame[1] = true;
}
else {
#ifdef EDITOR_ENABLE
game_buffer_editor_handle_mouse_up(&game_buffer, 1);
#endif
}
} break;
case mpk_import_named_pipe_event : {
#ifdef EDITOR_ENABLE
mpk_import_named_pipe_instance *named_pipe_instance = (mpk_import_named_pipe_instance *)iocp_overlapped;
if (named_pipe_instance->connected) {
m_printf("got message %d bytes: %s\n", iocp_num_bytes, named_pipe_instance->message.msg);
game_buffer_editor_handle_mpk_import_message(&game_buffer, &named_pipe_instance->message);
if (named_pipe_instance->message.type == mpk_import_named_pipe_message_type_done) {
void *mpk_ptr = ((struct mpk_import_shared_memory_header *)game_buffer_mpk_import_shared_memory_mapping_ptr) + 1;
struct mpk_header *mpk_header_ptr = (struct mpk_header *)mpk_ptr;
ReleaseSemaphore(game_buffer_mpk_import_shared_memory_semaphore, 1, nullptr);
}
ReadFile(named_pipe_instance->handle, &named_pipe_instance->message, sizeof(named_pipe_instance->message), nullptr, &named_pipe_instance->overlapped);
}
else {
m_printf("new named pipe instance connected\n");
named_pipe_instance->connected = true;
ReadFile(named_pipe_instance->handle, &named_pipe_instance->message, sizeof(named_pipe_instance->message), nullptr, &named_pipe_instance->overlapped);
mpk_import_add_named_pipe_instance(&common_vars);
}
#else
m_die("game loop main: received event \"mpk_import_named_pipe_event\", but editor is not enabled");
#endif
} break;
default : {
m_die("game loop main: call to \"GetQueuedCompletionStatus\" returned an invalid event");
} break;
}
}
}
#ifdef EDITOR_ENABLE
game_buffer.editor->imgui_io->DeltaTime = (float)(last_frame_time_microsecs / 1000000.0);
ImGui::NewFrame();
game_buffer_editor_imgui_new_frame(&game_buffer, &vulkan);
#endif
{
VkResult vk_result = {};
vkWaitForFences(vulkan.device, 1, &vulkan.swap_chain_fence, VK_TRUE, UINT64_MAX);
vkResetFences(vulkan.device, 1, &vulkan.swap_chain_fence);
uint swap_chain_image_index = 0;
if ((vk_result = vkAcquireNextImageKHR(vulkan.device, vulkan.swap_chain, UINT64_MAX, vulkan.swap_chain_image_semaphore, VK_NULL_HANDLE, &swap_chain_image_index)) != VK_SUCCESS) {
m_die("call to \"vkAcquireNextImageKHR\" failed");
}
VkCommandBufferBeginInfo cmd_buffer_begin_info = { VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO };
cmd_buffer_begin_info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
vkBeginCommandBuffer(vulkan.swap_chain_cmd_buffer, &cmd_buffer_begin_info);
game_buffer_record_vulkan_commands(&game_buffer, &vulkan);
vulkan_record_swap_chain_commands(&vulkan, swap_chain_image_index, game_buffer_viewport);
vkEndCommandBuffer(vulkan.swap_chain_cmd_buffer);
VkSubmitInfo queue_submit_info = { VK_STRUCTURE_TYPE_SUBMIT_INFO };
queue_submit_info.waitSemaphoreCount = 1;
queue_submit_info.pWaitSemaphores = &vulkan.swap_chain_image_semaphore;
VkPipelineStageFlags wait_dst_stage_mask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
queue_submit_info.pWaitDstStageMask = &wait_dst_stage_mask;
queue_submit_info.commandBufferCount = 1;
queue_submit_info.pCommandBuffers = &vulkan.swap_chain_cmd_buffer;
queue_submit_info.signalSemaphoreCount = 1;
queue_submit_info.pSignalSemaphores = &vulkan.swap_chain_queue_semaphore;
if ((vk_result = vkQueueSubmit(vulkan.device_queue, 1, &queue_submit_info, vulkan.swap_chain_fence)) != VK_SUCCESS) {
m_die("call to \"vkQueueSubmit\" failed");
}
VkPresentInfoKHR device_queue_present_info = { VK_STRUCTURE_TYPE_PRESENT_INFO_KHR };
device_queue_present_info.waitSemaphoreCount = 1;
device_queue_present_info.pWaitSemaphores = &vulkan.swap_chain_queue_semaphore;
device_queue_present_info.swapchainCount = 1;
device_queue_present_info.pSwapchains = &vulkan.swap_chain;
device_queue_present_info.pImageIndices = &swap_chain_image_index;
if ((vk_result = vkQueuePresentKHR(vulkan.device_queue, &device_queue_present_info)) != VK_SUCCESS) {
m_die("call to \"vkQueuePresentKHR\" failed");
}
}
}
