Max/korenkonder_ReDIVA
1
0
Fork 0
mirror of https://github.com/korenkonder/ReDIVA.git synced 2026-09-30 10:47:59 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
eab35bf2c210c80d65d8bebd9f2bf96a25ca2a60
korenkonder_ReDIVA/src/ReDIVA/app.cpp
T

3062 lines
102 KiB
C++
Raw Blame History

/*
by korenkonder
GitHub/GitLab: korenkonder
*/
#define GLFW_EXPOSE_NATIVE_WIN32
#include "app.hpp"
#include "config.hpp"
#include "../CRE/GL/uniform_buffer.hpp"
#include "../CRE/Glitter/glitter.hpp"
#include "../CRE/Vulkan/gl_wrap.hpp"
#include "../CRE/Vulkan/Manager.hpp"
#include "../CRE/Vulkan/Semaphore.hpp"
#include "../CRE/rob/rob.hpp"
#include "../CRE/rob/motion.hpp"
#include "../CRE/rob/skin_param.hpp"
#include "../CRE/app_system_detail.hpp"
#include "../CRE/auth_2d.hpp"
#include "../CRE/auth_3d.hpp"
#include "../CRE/camera.hpp"
#include "../CRE/clear_color.hpp"
#include "../CRE/config.hpp"
#include "../CRE/customize_item_table.hpp"
#include "../CRE/data.hpp"
#include "../CRE/effect.hpp"
#include "../CRE/file_handler.hpp"
#include "../CRE/font.hpp"
#include "../CRE/gl_rend_state.hpp"
#include "../CRE/hand_item.hpp"
#include "../CRE/light_param.hpp"
#include "../CRE/mdata_manager.hpp"
#include "../CRE/module_table.hpp"
#include "../CRE/object.hpp"
#include "../CRE/ogg_vorbis.hpp"
#include "../CRE/pv_db.hpp"
#include "../CRE/pv_expression.hpp"
#include "../CRE/random.hpp"
#include "../CRE/render.hpp"
#include "../CRE/render_manager.hpp"
#include "../CRE/shader.hpp"
#include "../CRE/shader_dev.hpp"
#include "../CRE/shader_ft.hpp"
#include "../CRE/sprite.hpp"
#include "../CRE/stage.hpp"
#include "../CRE/stage_modern.hpp"
#include "../CRE/stage_param.hpp"
#include "../CRE/static_var.hpp"
#include "../CRE/task.hpp"
#include "../CRE/texture.hpp"
#include "../KKdLib/database/item_table.hpp"
#include "../KKdLib/io/path.hpp"
#include "../KKdLib/prj/algorithm.hpp"
#include "../KKdLib/timer.hpp"
#include "../KKdLib/sort.hpp"
#include "../KKdLib/str_utils.hpp"
#include "data_edit/glitter_editor.hpp"
#include "data_edit/rob_chara_adjust.hpp"
#include "data_edit/selector.hpp"
#include "data_test/auth_2d_test.hpp"
#include "data_test/auth_3d_test.hpp"
#include "data_test/equip_test.hpp"
#include "data_test/glitter_test.hpp"
#include "data_test/misc_test.hpp"
#include "data_test/motion_test.hpp"
#include "data_test/object_test.hpp"
#include "data_test/opd_test.hpp"
#include "data_test/rob_osage_test.hpp"
#include "data_test/selector.hpp"
#include "data_test/stage_test.hpp"
#include "information/dw_console.hpp"
#include "pv_game/pv_game.hpp"
#include "classes.hpp"
#include "game_state.hpp"
#include "font_info.hpp"
#include "imgui_helper.hpp"
#include "input.hpp"
#include "input_state.hpp"
#include "shared.hpp"
#include "task_window.hpp"
#include "x_pv_game.hpp"
#include <glad/glad_wgl.h>
#if BAKE_VIDEO
#include <d3d11.h>
#pragma comment(lib, "d3d11.lib")
#endif
#include <GLFW/glfw3.h>
#include <GLFW/glfw3native.h>
#include <imgui/imgui.h>
#include <imgui/imgui_internal.h>
#include <imgui/imgui_impl_glfw.h>
#ifdef USE_OPENGL
#include <imgui/imgui_impl_opengl3.h>
#endif
#define IMGUI_IMPL_VULKAN_USE_VOLK
#include <imgui/imgui_impl_vulkan.h>
#include <timeapi.h>
#include <shlobj_core.h>
#include <Volk/volk.h>
#ifdef DEBUG
#define RENDER_DEBUG 1
#else
#define RENDER_DEBUG 0
#endif
timer* render_timer;
struct app_render_data {
app_render_data();
~app_render_data();
bool load();
void unload();
};
struct vulkan_swapchain_support_details {
VkSurfaceCapabilitiesKHR capabilities;
std::vector<VkSurfaceFormatKHR> formats;
std::vector<VkPresentModeKHR> present_modes;
vulkan_swapchain_support_details() : capabilities() {
}
~vulkan_swapchain_support_details() {
}
};
app_render_data* render;
ImFont* imgui_font_arial;
bool draw_imgui = true;
const double_t render_scale_table[] = {
1.0 / 4.0, // 25%
2.0 / 6.0, // 33.3%
2.0 / 4.0, // 50%
4.0 / 6.0, // 66.6%
3.0 / 4.0, // 75%
5.0 / 6.0, // 83.3%
4.0 / 4.0, // 100%
7.0 / 6.0, // 116.6%
5.0 / 4.0, // 125%
8.0 / 6.0, // 133.3%
6.0 / 4.0, // 150%
10.0 / 6.0, // 166.6%
7.0 / 4.0, // 175%
11.0 / 6.0, // 183.3%
8.0 / 4.0, // 200%
};
#if defined(DEBUG)
static const char* application_name = "ReDIVA Debug";
#else
static const char* application_name = "ReDIVA";
#endif
static int32_t old_scale_index;
static int32_t scale_index;
static vec2i old_internal_2d_res;
static vec2i old_internal_3d_res;
vec2i internal_2d_res;
vec2i internal_3d_res;
static int32_t old_width;
static int32_t old_height;
int32_t width;
int32_t height;
static const double_t aspect = 16.0 / 9.0;
static const int32_t fast_loader_speed = 60;
bool light_chara_ambient;
vec4 npr_cloth_spec_color = 1.0f;
uint32_t cmn_set_id; // 2
uint32_t dbg_set_id; // 2
uint32_t aet_gam_loadsc_set_id; // 26
uint32_t spr_gam_loadsc_set_id; // 32
uint32_t aet_cmn_all_set_id; // 35
uint32_t spr_cmn_all_set_id; // 34
uint32_t aet_gam_cmn_set_id; // 3
uint32_t spr_gam_cmn_set_id; // 9
uint32_t spr_fnt_24_set_id; // 4
uint32_t spr_fnt_bold24_set_id; // 472
uint32_t spr_fnt_cmn_set_id; // 43
#if DISPLAY_IBL
struct cubemap_display_batch_shader_data {
vec4 g_vp[4];
vec4 g_texture_lod;
};
bool display_ibl = false;
int32_t ibl_index = 0;
int32_t ibl_scale = 1;
GLuint ibl_vao;
GL::ArrayBuffer ibl_vbo;
GL::UniformBuffer cubemap_display_ubo;
#endif
static bool app_init(const app_init_struct& ais);
static void app_main_loop(render_context* rctx);
static void app_free();
static render_context* render_context_load();
static void render_context_ctrl(render_context* rctx);
static void render_context_disp(render_context* rctx);
static void render_context_imgui(render_context* rctx);
static void render_context_dispose(render_context* rctx);
static void render_shaders_load();
static void render_shaders_free();
static bool app_load_ft_shaders(void* data, const char* path, const char* file, uint32_t hash);
static bool app_load_dev_shaders(void* data, const char* path, const char* file, uint32_t hash);
static void app_drop_glfw(GLFWwindow* window, int32_t count, char** paths);
static void app_resize_fb_glfw(GLFWwindow* window, int32_t w, int32_t h);
static void app_resize_fb(render_context* rctx, bool change_fb);
static void render_imgui_context_menu(classes_data* classes,
const size_t classes_count, render_context* rctx);
#if RENDER_DEBUG
static void APIENTRY render_debug_output(GLenum source, GLenum type, uint32_t id,
GLenum severity, GLsizei length, const char* message, const void* userParam);
#endif
static int32_t app_init_vulkan();
static int32_t app_begin_present_vulkan();
static int32_t app_end_present_vulkan();
static void app_recreate_swapchain();
static void app_free_vulkan();
static int32_t app_create_vulkan_instance();
#if RENDER_DEBUG
static int32_t app_setup_debug_messenger();
#endif
static int32_t app_create_surface();
static int32_t app_pick_physical_device();
static int32_t app_create_logical_device();
static int32_t app_create_allocator();
static int32_t app_create_command_pool();
static int32_t app_create_command_buffers();
static int32_t app_create_sync_objects();
static int32_t app_create_descriptor_pool();
static int32_t app_create_swapchain();
static std::pair<uint32_t, uint32_t> app_find_queue_families(VkPhysicalDevice vulkan_device);
static bool app_check_is_device_suitable(VkPhysicalDevice vulkan_device);
static std::vector<const char*> app_get_required_extensions();
static bool app_check_device_extension_support(VkPhysicalDevice vulkan_device);
#if RENDER_DEBUG
static bool app_check_validation_layer_support();
#endif
#if RENDER_DEBUG
static VKAPI_ATTR VkBool32 VKAPI_CALL app_debug_callback(
VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageType,
const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, void* pUserData);
#endif
static VkSurfaceFormatKHR app_choose_swap_surface_format(
const std::vector<VkSurfaceFormatKHR>& available_formats);
static VkPresentModeKHR app_choose_swap_present_mode(
const std::vector<VkPresentModeKHR>& available_present_modes);
static VkExtent2D app_choose_swap_extent(const VkSurfaceCapabilitiesKHR& capabilities);
static vulkan_swapchain_support_details app_query_swapchain_support(VkPhysicalDevice vulkan_device);
#if RENDER_DEBUG
static VkResult app_vkCreateDebugUtilsMessengerEXT(VkInstance instance,
const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pDebugMessenger);
static void app_vkDestroyDebugUtilsMessengerEXT(VkInstance instance,
VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator);
#endif
bool close;
bool reload_render;
HWND window_handle;
GLFWwindow* window;
ImGuiContext* imgui_context;
bool global_context_menu;
render_context* rctx_ptr;
bool task_stage_is_modern;
const uint32_t MAX_FRAMES_IN_FLIGHT = 3;
#if RENDER_DEBUG
const char* vulkan_validation_layers[] = {
"VK_LAYER_KHRONOS_validation",
};
#endif
const char* vulkan_device_extensions[] = {
VK_KHR_SWAPCHAIN_EXTENSION_NAME,
};
VkInstance vulkan_instance;
#if RENDER_DEBUG
VkDebugUtilsMessengerEXT vulkan_debug_messenger;
#endif
VkSurfaceKHR vulkan_surface;
VkPhysicalDevice vulkan_physical_device;
VkDevice vulkan_device;
std::pair<uint32_t, uint32_t> vulkan_queue_family;
VkQueue vulkan_graphics_queue;
VkQueue vulkan_present_queue;
VmaAllocator vulkan_allocator;
VkCommandPool vulkan_command_pool;
VkDescriptorPool vulkan_descriptor_pool;
std::vector<VkCommandBuffer> vulkan_command_buffers;
std::vector<Vulkan::Semaphore> vulkan_image_available_semaphores;
std::vector<Vulkan::Semaphore> vulkan_render_finished_semaphores;
std::vector<Vulkan::Fence> vulkan_in_flight_fences;
uint32_t vulkan_current_frame;
bool vulkan_framebuffer_resized = false;
VkSwapchainKHR vulkan_swapchain;
std::vector<VkImage> vulkan_swapchain_images;
std::vector<Vulkan::ImageView> vulkan_swapchain_image_views;
prj::shared_ptr<Vulkan::RenderPass> vulkan_swapchain_render_pass;
std::vector<Vulkan::Framebuffer> vulkan_swapchain_framebuffers;
VkFormat vulkan_swapchain_image_format;
VkExtent2D vulkan_swapchain_extent;
uint32_t vulkan_image_index;
VkRenderPassBeginInfo vulkan_swapchain_render_pass_info;
#if BAKE_VIDEO
ID3D11Device* d3d_device;
ID3D11DeviceContext* d3d_device_context;
HANDLE d3d_gl_handle;
#endif
int32_t app_main(const app_init_struct& ais) {
#if BAKE_FAST
render_timer = new timer(600.0);
#else
render_timer = new timer(60.0);
#endif
window_handle = 0;
if (!glfwInit())
return -1;
#ifndef USE_OPENGL
Vulkan::use = true;
#else
Vulkan::use = ais.vulkan;
#endif
if (app_init(ais)) {
window_handle = glfwGetWin32Window(window);
glfwShowWindow(window);
glfwFocusWindow(window);
glfwSetDropCallback(window, (GLFWdropfun)app_drop_glfw);
glfwSetWindowSizeCallback(window, (GLFWwindowsizefun)app_resize_fb_glfw);
glfwSetWindowSize(window, width, height);
glfwSetWindowSizeLimits(window, 896, 504, GLFW_DONT_CARE, GLFW_DONT_CARE);
#if BAKE_PNG || BAKE_VIDEO
glfwSetWindowPos(window, 0, 0);
glfwSetWindowAttrib(window, GLFW_DECORATED, GLFW_FALSE);
#else
glfwSetWindowPos(window, 8, 31);
#endif
Input::SetInputs(window);
RECT window_rect;
GetClientRect(window_handle, &window_rect);
#if !(BAKE_PNG || BAKE_VIDEO)
width = window_rect.right;
height = window_rect.bottom;
old_width = width;
old_height = height;
#endif
scale_index = ais.scale_index > 0 && ais.scale_index < RENDER_SCALE_MAX
? ais.scale_index : RENDER_SCALE_100;
old_scale_index = scale_index;
if (Vulkan::use) {
int32_t ret = app_init_vulkan();
if (ret) {
app_free_vulkan();
app_free();
glfwTerminate();
return ret;
}
VkPhysicalDeviceProperties device_properties;
vkGetPhysicalDeviceProperties(vulkan_physical_device, &device_properties);
VkPhysicalDeviceLimits& supported_limits = device_properties.limits;
sv_max_texture_size = supported_limits.maxImageDimension2D;
sv_max_texture_max_anisotropy = (int32_t)supported_limits.maxSamplerAnisotropy;
sv_max_uniform_buffer_size = (int32_t)supported_limits.maxUniformBufferRange;
sv_max_storage_buffer_size = (int32_t)supported_limits.maxStorageBufferRange;
sv_min_uniform_buffer_alignment = (int32_t)supported_limits.minUniformBufferOffsetAlignment;
sv_min_storage_buffer_alignment = (int32_t)supported_limits.minStorageBufferOffsetAlignment;
}
#ifdef USE_OPENGL
else {
#if RENDER_DEBUG
glEnable(GL_DEBUG_OUTPUT);
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
glDebugMessageCallback(render_debug_output, 0);
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, 0, GL_TRUE);
#endif
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &sv_max_texture_size);
glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &sv_max_texture_max_anisotropy);
glGetIntegerv(GL_MAX_UNIFORM_BLOCK_SIZE, &sv_max_uniform_buffer_size);
if (GLAD_GL_VERSION_4_3)
glGetIntegerv(GL_MAX_SHADER_STORAGE_BLOCK_SIZE, &sv_max_storage_buffer_size);
glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &sv_min_uniform_buffer_alignment);
if (GLAD_GL_VERSION_4_3)
glGetIntegerv(GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT, &sv_min_storage_buffer_alignment);
glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST);
glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
}
#endif
do {
close = false;
reload_render = false;
render_context* rctx = render_context_load();
#if !(BAKE_PNG || BAKE_VIDEO)
glfwGetFramebufferSize(window, &width, &height);
#endif
gl_rend_state.set_viewport(0, 0, width, height);
gl_rend_state.disable_blend();
gl_rend_state.disable_depth_test();
gl_rend_state.set_depth_mask(GL_FALSE);
gl_rend_state.disable_cull_face();
gl_rend_state.disable_stencil_test();
glfwSwapInterval(0);
app_main_loop(rctx);
render_context_dispose(rctx);
} while (reload_render);
if (Vulkan::use)
app_begin_present_vulkan();
}
if (Vulkan::use)
app_free_vulkan();
app_free();
glfwTerminate();
delete render_timer;
render_timer = 0;
return 0;
}
double_t app_get_render_scale() {
return render_scale_table[scale_index];
}
int32_t app_get_render_scale_index() {
return scale_index;
}
void app_set_render_scale_index(int32_t index) {
scale_index = index >= 0 && index < RENDER_SCALE_MAX ? index : RENDER_SCALE_100;
}
void app_swap_buffers() {
glfwSwapBuffers(window);
}
float_t rob_frame = 0.0f;
app_render_data::app_render_data() {
}
app_render_data::~app_render_data() {
}
bool app_render_data::load() {
glfwMakeContextCurrent(window);
if (Vulkan::use)
Vulkan::gl_wrap_manager_load_funcs();
#ifdef USE_OPENGL
else {
if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
return false;
}
#endif
if (!Vulkan::use && !gladLoadWGLLoader((GLADloadproc)glfwGetProcAddress, GetDC(window_handle)))
return false;
#if BAKE_VIDEO
D3D11CreateDevice(0, D3D_DRIVER_TYPE_HARDWARE, 0, 0, 0, 0,
D3D11_SDK_VERSION, &d3d_device, 0, &d3d_device_context);
if (!Vulkan::use && GLAD_WGL_NV_DX_interop2)
d3d_gl_handle = wglDXOpenDeviceNV(d3d_device);
#endif
gl_get_error_print();
gl_rend_state.set_viewport(0, 0, width, height);
#if DISPLAY_IBL
const float_t box_vertices[] = {
-1.0f, 1.0f, -1.0f,
-1.0f, -1.0f, -1.0f,
1.0f, -1.0f, -1.0f,
1.0f, -1.0f, -1.0f,
1.0f, 1.0f, -1.0f,
-1.0f, 1.0f, -1.0f,
-1.0f, -1.0f, 1.0f,
-1.0f, -1.0f, -1.0f,
-1.0f, 1.0f, -1.0f,
-1.0f, 1.0f, -1.0f,
-1.0f, 1.0f, 1.0f,
-1.0f, -1.0f, 1.0f,
1.0f, -1.0f, -1.0f,
1.0f, -1.0f, 1.0f,
1.0f, 1.0f, 1.0f,
1.0f, 1.0f, 1.0f,
1.0f, 1.0f, -1.0f,
1.0f, -1.0f, -1.0f,
-1.0f, -1.0f, 1.0f,
-1.0f, 1.0f, 1.0f,
1.0f, 1.0f, 1.0f,
1.0f, 1.0f, 1.0f,
1.0f, -1.0f, 1.0f,
-1.0f, -1.0f, 1.0f,
-1.0f, 1.0f, -1.0f,
1.0f, 1.0f, -1.0f,
1.0f, 1.0f, 1.0f,
1.0f, 1.0f, 1.0f,
-1.0f, 1.0f, 1.0f,
-1.0f, 1.0f, -1.0f,
-1.0f, -1.0f, -1.0f,
-1.0f, -1.0f, 1.0f,
1.0f, -1.0f, -1.0f,
1.0f, -1.0f, -1.0f,
-1.0f, -1.0f, 1.0f,
1.0f, -1.0f, 1.0f
};
glGenVertexArrays(1, &ibl_vao);
gl_rend_state.bind_vertex_array(ibl_vao, true);
ibl_vbo.Create(sizeof(box_vertices), box_vertices);
ibl_vbo.Bind(true);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(float_t) * 3, (void*)0);
gl_rend_state.bind_array_buffer(0);
gl_rend_state.bind_vertex_array(0);
cubemap_display_ubo.Create(sizeof(cubemap_display_batch_shader_data));
#endif
return true;
}
void app_render_data::unload() {
#if DISPLAY_IBL
cubemap_display_ubo.Destroy();
ibl_vbo.Destroy();
if (ibl_vao) {
glDeleteVertexArrays(1, &ibl_vao);
ibl_vao = 0;
}
#endif
#if BAKE_VIDEO
if (!Vulkan::use && GLAD_WGL_NV_DX_interop2)
wglDXCloseDeviceNV(d3d_device);
d3d_device_context->Release();
d3d_device_context = 0;
d3d_device->Release();
d3d_device = 0;
#endif
}
static bool app_init(const app_init_struct& ais) {
GLFWmonitor* monitor = glfwGetPrimaryMonitor();
const GLFWvidmode* mode = glfwGetVideoMode(monitor);
width = ais.res.x > 0 && ais.res.x < 8192 ? ais.res.x : mode->width;
height = ais.res.y > 0 && ais.res.y < 8192 ? ais.res.y : mode->height;
width = (int32_t)(width / 2.0f);
height = (int32_t)(height / 2.0f);
width = 1280;
height = 720;
res_window_set(RESOLUTION_MODE_HD);
#if BAKE_PNG || BAKE_VIDEO
width = BAKE_BASE_WIDTH;
height = BAKE_BASE_HEIGHT;
glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE);
#endif
if (Vulkan::use)
glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
#ifdef USE_OPENGL
else
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
#endif
glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE);
glfwWindowHint(GLFW_FOCUSED, GLFW_TRUE);
//glfwWindowHint(GLFW_TRANSPARENT_FRAMEBUFFER, GLFW_TRUE);
#if RENDER_DEBUG
glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, true);
#endif
glfwWindowHint(GLFW_RED_BITS, mode->redBits);
glfwWindowHint(GLFW_GREEN_BITS, mode->greenBits);
glfwWindowHint(GLFW_BLUE_BITS, mode->blueBits);
glfwWindowHint(GLFW_DEPTH_BITS, 0);
#if BAKE_PNG || BAKE_VIDEO
bool maximized = false;
#else
bool maximized = mode->width == width && mode->height == height;
#endif
glfwWindowHint(GLFW_MAXIMIZED, maximized ? GLFW_TRUE : GLFW_FALSE);
if (Vulkan::use)
window = glfwCreateWindow(width, height, application_name, maximized ? monitor : 0, 0);
#ifdef USE_OPENGL
else {
int32_t minor = 6;
window = 0;
while (!window || minor < 3) {
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, minor--);
window = glfwCreateWindow(width, height, application_name, maximized ? monitor : 0, 0);
}
}
#endif
if (!window)
return false;
render = new app_render_data;
if (!render->load()) {
glfwDestroyWindow(window);
return false;
}
return true;
}
static void app_main_loop(render_context* rctx) {
render_timer->reset();
while (!close && !reload_render) {
render_timer->start_of_cycle();
glfwPollEvents();
ImGui_ImplGlfw_NewFrame();
if (Vulkan::use)
ImGui_ImplVulkan_NewFrame();
#ifdef USE_OPENGL
else
ImGui_ImplOpenGL3_NewFrame();
#endif
ImGui::NewFrame();
Input::NewFrame();
render_context_ctrl(rctx);
render_context_disp(rctx);
close |= !!glfwWindowShouldClose(window);
Input::EndFrame();
app_swap_buffers();
render_timer->end_of_cycle();
}
}
static void app_free() {
render->unload();
delete render;
glfwDestroyWindow(window);
}
static render_context* render_context_load() {
Vulkan::CommandBuffer command_buffer;
if (Vulkan::use) {
command_buffer.Create(vulkan_device, vulkan_command_pool);
command_buffer.BeginOneTimeSubmit();
Vulkan::current_command_buffer = command_buffer;
}
system_work_init(13);
// Enable the dw_gui widgets
sub_140194880(1);
data_struct_init();
data_struct_load("ReDIVA_data.txt");
data_struct_load_db();
render_shaders_load();
texture_manager_init();
file_handler_storage_init();
render_context* rctx = new render_context;
rctx_ptr = rctx;
gl_rend_state.get();
data_struct* aft_data = &data_list[DATA_AFT];
aet_database* aft_aet_db = &aft_data->data_ft.aet_db;
auth_3d_database* aft_auth_3d_db = &aft_data->data_ft.auth_3d_db;
bone_database* aft_bone_data = &aft_data->data_ft.bone_data;
motion_database* aft_mot_db = &aft_data->data_ft.mot_db;
object_database* aft_obj_db = &aft_data->data_ft.obj_db;
sprite_database* aft_spr_db = &aft_data->data_ft.spr_db;
texture_database* aft_tex_db = &aft_data->data_ft.tex_db;
stage_database* aft_stage_data = &aft_data->data_ft.stage_data;
app::task_work_init();
motion_init();
skin_param_data_init();
skin_param_data_load();
input_state_init();
fontmap_data_init();
font_info_default_init();
dw_console_c_buff_array_init();
sound_init();
extern HRESULT mf_init();
mf_init();
wave_audio_storage_init();
ogg_file_handler_storage_init();
ogg_playback_data_init();
game_state_init();
render_manager_init_data(0, 0, 0, false);
/*render_manager_init_data(
stru_140EDA5B0.ssaa,
stru_140EDA5B0.hd_res,
stru_140EDA5B0.ss_alpha_mask,
stru_140EDA5B0.screen_shot_4x == 1);*/
objset_info_storage_init(aft_obj_db);
stage_param_data_init();
pv_expression_file_storage_init();
item_table_handler_array_init();
rand_state_array_init();
rob_init();
task_wind_init();
aet_manager_init();
sprite_manager_init();
auth_3d_data_init();
task_auth_3d_init();
task_stage_init();
task_stage_modern_init();
light_param_data_storage_data_init();
effect_init();
task_pv_db_init();
Glitter::glt_particle_manager_init();
dw_init();
data_edit_sel_init();
data_test_sel_init();
auth_3d_test_task_init();
dtm_aet_init();
dtm_stg_init();
motion_test_init();
object_test_init();
opd_test_init();
equip_test_init();
rob_osage_test_init();
rob_chara_adjust_init();
task_data_test_glitter_particle_init();
task_data_test_misc_init();
x_pv_game_data_init();
osage_play_database_load();
Glitter::glt_particle_manager->bone_data = aft_bone_data;
if (false) {
char buf[0x200];
std::vector<uint32_t> obj_set_ids;
std::map<uint32_t, std::string> obj_set_id_name;
for (int32_t i = 800; i <= 831; i++) {
sprintf_s(buf, sizeof(buf), i == 815 ? "EFFPV%03d" : "ITMPV%03d", i);
const object_set_info* effpv_set_info = aft_obj_db->get_object_set_info(buf);
if (effpv_set_info) {
obj_set_ids.push_back(effpv_set_info->id);
obj_set_id_name.insert({ effpv_set_info->id, buf });
}
sprintf_s(buf, sizeof(buf), "STGPV%03d", i);
const object_set_info* stgpv_set_info = aft_obj_db->get_object_set_info(buf);
if (stgpv_set_info) {
obj_set_ids.push_back(stgpv_set_info->id);
obj_set_id_name.insert({ stgpv_set_info->id, buf });
}
sprintf_s(buf, sizeof(buf), "STGPV%03dHRC", i);
const object_set_info* stgpvhrc_set_info = aft_obj_db->get_object_set_info(buf);
if (stgpvhrc_set_info) {
obj_set_ids.push_back(stgpvhrc_set_info->id);
obj_set_id_name.insert({ stgpvhrc_set_info->id, buf });
}
for (uint32_t& i : obj_set_ids) {
const object_set_info* set_info = aft_obj_db->get_object_set_info(i);
if (!set_info)
continue;
farc f;
if (!aft_data->load_file(&f, "rom/objset/", set_info->archive_file_name.c_str(), farc::load_file))
continue;
farc_file* obj_ff = f.read_file(set_info->object_file_name.c_str());
if (!obj_ff)
continue;
farc_file* tex_ff = f.read_file(set_info->texture_file_name.c_str());
if (!tex_ff)
continue;
prj::shared_ptr<prj::stack_allocator> alloc(new prj::stack_allocator);
obj_set obj_set;
obj_set.unpack_file(alloc, obj_ff->data, obj_ff->size, false);
if (!obj_set.ready)
continue;
txp_set txp_set;
if (!txp_set.unpack_file(tex_ff->data, false))
continue;
object_material_msgpack_write("patch\\AFT_orig\\objset", obj_set_id_name[i].c_str(),
i, &obj_set, &txp_set, aft_tex_db);
}
}
}
if (false) {
const std::string mmp_base_path("R:\\SteamLibrary\\steamapps\\common\\"
"Hatsune Miku Project DIVA Mega Mix Plus\\");
const std::pair<const char*, const char*> mmp_paths[] = {
{ "diva_main\\rom_steam\\", "" },
{ "diva_main\\rom_ps4_dlc\\", "mdata_" },
{ "mods\\F2nd Song Pack\\", "mod_" },
{ "mods\\X Song Pack\\", "mod_" },
};
const std::string mmp_x_pack_path = mmp_base_path + "mods\\X Song Pack\\rom\\objset\\";
object_database obj_db;
for (auto& i : mmp_paths) {
object_database_file obj_db_file;
obj_db_file.read((mmp_base_path + i.first + "rom\\objset\\" + i.second + "obj_db").c_str(), false);
obj_db.add(&obj_db_file);
}
texture_database tex_db;
for (auto& i : mmp_paths) {
texture_database_file tex_db_file;
tex_db_file.read((mmp_base_path + i.first + "rom\\objset\\" + i.second + "tex_db").c_str(), false);
tex_db.add(&tex_db_file);
}
char buf[0x200];
std::vector<uint32_t> obj_set_ids;
std::map<uint32_t, std::string> obj_set_id_name;
for (int32_t i = 800; i <= 831; i++) {
sprintf_s(buf, sizeof(buf), i == 815 ? "EFFPV%03d" : "ITMPV%03d", i);
const object_set_info* effpv_set_info = obj_db.get_object_set_info(buf);
if (effpv_set_info) {
obj_set_ids.push_back(effpv_set_info->id);
obj_set_id_name.insert({ effpv_set_info->id, buf });
}
sprintf_s(buf, sizeof(buf), "STGPV%03d", i);
const object_set_info* stgpv_set_info = obj_db.get_object_set_info(buf);
if (stgpv_set_info) {
obj_set_ids.push_back(stgpv_set_info->id);
obj_set_id_name.insert({ stgpv_set_info->id, buf });
}
sprintf_s(buf, sizeof(buf), "STGPV%03dHRC", i);
const object_set_info* stgpvhrc_set_info = obj_db.get_object_set_info(buf);
if (stgpvhrc_set_info) {
obj_set_ids.push_back(stgpvhrc_set_info->id);
obj_set_id_name.insert({ stgpvhrc_set_info->id, buf });
}
for (uint32_t& i : obj_set_ids) {
const object_set_info* set_info = obj_db.get_object_set_info(i);
if (!set_info)
continue;
farc f;
if (!farc::load_file(&f, mmp_x_pack_path.c_str(), set_info->archive_file_name.c_str(), hash_murmurhash_empty))
continue;
farc_file* obj_ff = f.read_file(set_info->object_file_name.c_str());
if (!obj_ff)
continue;
farc_file* tex_ff = f.read_file(set_info->texture_file_name.c_str());
if (!tex_ff)
continue;
prj::shared_ptr<prj::stack_allocator> alloc(new prj::stack_allocator);
obj_set obj_set;
obj_set.unpack_file(alloc, obj_ff->data, obj_ff->size, false);
if (!obj_set.ready)
continue;
txp_set txp_set;
if (!txp_set.unpack_file(tex_ff->data, false))
continue;
object_material_msgpack_write("patch\\MMp_orig\\objset", obj_set_id_name[i].c_str(),
i, &obj_set, &txp_set, &tex_db);
}
}
}
if (false) {
data_struct* x_data = &data_list[DATA_X];
char buf[0x200];
std::vector<uint32_t> obj_set_ids;
std::map<uint32_t, std::string> obj_set_id_name;
for (int32_t i = 801; i <= 832; i++) {
uint32_t effpv_hash = hash_murmurhash(buf, sprintf_s(buf, sizeof(buf), "EFFPV%03d", i));
if (x_data->check_file_exists("root+/objset", effpv_hash)) {
obj_set_ids.push_back(effpv_hash);
obj_set_id_name.insert({ effpv_hash, buf });
}
uint32_t effpvptc_hash = hash_murmurhash(buf, sprintf_s(buf, sizeof(buf), "EFFPV%03dPTC", i));
if (x_data->check_file_exists("root+/objset", effpvptc_hash)) {
obj_set_ids.push_back(effpvptc_hash);
obj_set_id_name.insert({ effpvptc_hash, buf });
}
uint32_t effstgpvptc_hash = hash_murmurhash(buf, sprintf_s(buf, sizeof(buf), "EFFSTGPV%03dPTC", i % 100));
if (x_data->check_file_exists("root+/objset", effstgpvptc_hash)) {
obj_set_ids.push_back(effstgpvptc_hash);
obj_set_id_name.insert({ effstgpvptc_hash, buf });
}
uint32_t stgpv_hash = hash_murmurhash(buf, sprintf_s(buf, sizeof(buf), "STGPV%03d", i % 100));
if (x_data->check_file_exists("root+/objset", stgpv_hash)) {
obj_set_ids.push_back(stgpv_hash);
obj_set_id_name.insert({ stgpv_hash, buf });
}
uint32_t stgpvhrc_hash = hash_murmurhash(buf, sprintf_s(buf, sizeof(buf), "STGPV%03dHRC", i % 100));
if (x_data->check_file_exists("root+/objset", stgpvhrc_hash)) {
obj_set_ids.push_back(stgpvhrc_hash);
obj_set_id_name.insert({ stgpvhrc_hash, buf });
}
for (uint32_t& i : obj_set_ids) {
farc f;
if (!x_data->load_file(&f, "root+/objset/", i, ".farc", farc::load_file))
continue;
std::string& set = obj_set_id_name[i];
size_t set_len = set.size();
if (set_len >= sizeof(buf) - 4)
continue;
const char* t = strrchr(set.c_str(), '.');
if (t)
set_len = t - set.c_str();
memcpy(buf, set.c_str(), set_len);
char* ext = buf + set_len;
size_t ext_len = sizeof(buf) - set_len;
memcpy_s(ext, ext_len, ".osd", 5);
farc_file* osd = f.read_file(buf);
if (!osd)
continue;
memcpy_s(ext, ext_len, ".txd", 5);
farc_file* txd = f.read_file(buf);
if (!txd)
continue;
memcpy_s(ext, ext_len, ".osi", 5);
farc_file* osi = f.read_file(buf);
if (!osi)
continue;
memcpy_s(ext, ext_len, ".txi", 5);
farc_file* txi = f.read_file(buf);
if (!txi)
continue;
prj::shared_ptr<prj::stack_allocator> alloc(new prj::stack_allocator);
obj_set obj_set;
obj_set.unpack_file(alloc, osd->data, osd->size, true);
if (!obj_set.ready)
continue;
txp_set txp_set;
if (!txp_set.unpack_file_modern(txd->data, txd->size, 'MTXD'))
continue;
object_database_file obj_db_file;
obj_db_file.read(osi->data, osi->size, true);
if (!obj_db_file.ready)
continue;
texture_database_file tex_db_file;
tex_db_file.read(txi->data, txi->size, true);
if (!tex_db_file.ready)
continue;
object_database obj_db;
obj_db.add(&obj_db_file);
texture_database tex_db;
tex_db.add(&tex_db_file);
object_material_msgpack_write("patch\\X_orig\\objset", obj_set_id_name[i].c_str(),
i, &obj_set, &txp_set, &tex_db);
}
}
}
if (false) {
data_struct* xhd_data = &data_list[DATA_XHD];
char buf[0x200];
std::vector<uint32_t> obj_set_ids;
std::map<uint32_t, std::string> obj_set_id_name;
for (int32_t i = 801; i <= 832; i++) {
uint32_t effpv_hash = hash_murmurhash(buf, sprintf_s(buf, sizeof(buf), "EFFPV%03d", i));
if (xhd_data->check_file_exists("root+/objset", effpv_hash)) {
obj_set_ids.push_back(effpv_hash);
obj_set_id_name.insert({ effpv_hash, buf });
}
uint32_t effpvptc_hash = hash_murmurhash(buf, sprintf_s(buf, sizeof(buf), "EFFPV%03dPTC", i));
if (xhd_data->check_file_exists("root+/objset", effpvptc_hash)) {
obj_set_ids.push_back(effpvptc_hash);
obj_set_id_name.insert({ effpvptc_hash, buf });
}
uint32_t effstgpvptc_hash = hash_murmurhash(buf, sprintf_s(buf, sizeof(buf), "EFFSTGPV%03dPTC", i % 100));
if (xhd_data->check_file_exists("root+/objset", effstgpvptc_hash)) {
obj_set_ids.push_back(effstgpvptc_hash);
obj_set_id_name.insert({ effstgpvptc_hash, buf });
}
uint32_t stgpv_hash = hash_murmurhash(buf, sprintf_s(buf, sizeof(buf), "STGPV%03d", i % 100));
if (xhd_data->check_file_exists("root+/objset", stgpv_hash)) {
obj_set_ids.push_back(stgpv_hash);
obj_set_id_name.insert({ stgpv_hash, buf });
}
uint32_t stgpvhrc_hash = hash_murmurhash(buf, sprintf_s(buf, sizeof(buf), "STGPV%03dHRC", i % 100));
if (xhd_data->check_file_exists("root+/objset", stgpvhrc_hash)) {
obj_set_ids.push_back(stgpvhrc_hash);
obj_set_id_name.insert({ stgpvhrc_hash, buf });
}
for (uint32_t& i : obj_set_ids) {
farc f;
if (!xhd_data->load_file(&f, "root+/objset/", i, ".farc", farc::load_file))
continue;
std::string& set = obj_set_id_name[i];
size_t set_len = set.size();
if (set_len >= sizeof(buf) - 4)
continue;
const char* t = strrchr(set.c_str(), '.');
if (t)
set_len = t - set.c_str();
memcpy(buf, set.c_str(), set_len);
char* ext = buf + set_len;
size_t ext_len = sizeof(buf) - set_len;
memcpy_s(ext, ext_len, ".osd", 5);
farc_file* osd = f.read_file(buf);
if (!osd)
continue;
memcpy_s(ext, ext_len, ".txd", 5);
farc_file* txd = f.read_file(buf);
if (!txd)
continue;
memcpy_s(ext, ext_len, ".osi", 5);
farc_file* osi = f.read_file(buf);
if (!osi)
continue;
memcpy_s(ext, ext_len, ".txi", 5);
farc_file* txi = f.read_file(buf);
if (!txi)
continue;
prj::shared_ptr<prj::stack_allocator> alloc(new prj::stack_allocator);
obj_set obj_set;
obj_set.unpack_file(alloc, osd->data, osd->size, true);
if (!obj_set.ready)
continue;
txp_set txp_set;
if (!txp_set.unpack_file_modern(txd->data, txd->size, 'MTXD'))
continue;
object_database_file obj_db_file;
obj_db_file.read(osi->data, osi->size, true);
if (!obj_db_file.ready)
continue;
texture_database_file tex_db_file;
tex_db_file.read(txi->data, txi->size, true);
if (!tex_db_file.ready)
continue;
object_database obj_db;
obj_db.add(&obj_db_file);
texture_database tex_db;
tex_db.add(&tex_db_file);
object_material_msgpack_write("patch\\XHD_orig\\objset", obj_set_id_name[i].c_str(),
i, &obj_set, &txp_set, &tex_db);
}
obj_set_ids.clear();
obj_set_id_name.clear();
}
}
app_resize_fb(rctx, false);
rctx->resize(internal_3d_res.x, internal_3d_res.y,
internal_2d_res.x, internal_2d_res.y, width, height);
rctx->camera->initialize(aspect);
app_resize_fb(rctx, true);
rctx->init();
Glitter::glt_particle_manager_add_task();
for (int32_t i = 0; i < ROB_CHARA_COUNT; i++)
rob_chara_array_reset_pv_data(i);
light_param_data_storage_data_load();
auth_3d_data_load_auth_3d_db(aft_auth_3d_db);
cmn_set_id = aft_mot_db->get_motion_set_id("CMN");
dbg_set_id = aft_obj_db->get_object_set_id("DBG");
aet_gam_loadsc_set_id = aft_aet_db->get_aet_set_id_by_name("AET_GAM_LOADSC");
spr_gam_loadsc_set_id = aft_spr_db->get_spr_set_id_by_name("SPR_GAM_LOADSC");
aet_cmn_all_set_id = aft_aet_db->get_aet_set_id_by_name("AET_CMN_ALL");
spr_cmn_all_set_id = aft_spr_db->get_spr_set_id_by_name("SPR_CMN_ALL");
aet_gam_cmn_set_id = aft_aet_db->get_aet_set_id_by_name("AET_GAM_CMN");
spr_gam_cmn_set_id = aft_spr_db->get_spr_set_id_by_name("SPR_GAM_CMN");
spr_fnt_24_set_id = aft_spr_db->get_spr_set_id_by_name("SPR_FNT_24");
spr_fnt_bold24_set_id = aft_spr_db->get_spr_set_id_by_name("SPR_FNT_BOLD24");
spr_fnt_cmn_set_id = aft_spr_db->get_spr_set_id_by_name("SPR_FNT_CMN");
hand_item_handler_data_init();
module_table_handler_data_init();
module_data_handler_data_init();
customize_item_table_handler_data_init();
customize_item_data_handler_data_init();
aet_manager_add_aet_sets(aft_aet_db);
sprite_manager_add_spr_sets(aft_spr_db);
render_timer->reset();
for (int32_t i = 0; i < 30; i++) {
render_timer->start_of_cycle();
game_state_ctrl();
app::TaskWork::ctrl();
sound_ctrl();
file_handler_storage_ctrl();
app::TaskWork::basic();
render_timer->end_of_cycle();
}
if (Vulkan::use) {
Vulkan::current_command_buffer = 0;
command_buffer.Sumbit(vulkan_graphics_queue);
command_buffer.Destroy();
}
camera* cam = rctx->camera;
//cam->set_position({ 1.35542f, 1.41634f, 1.27852f });
//cam->rotate({ -45.0, -32.5 });
//cam->set_position({ -6.67555f, 4.68882f, -3.67537f });
//cam->rotate({ 136.5, -20.5 });
cam->set_view_point({ 0.0f, 1.0f, 3.45f });
cam->set_interest({ 0.0f, 1.0f, 0.0f });
//cam->set_fov(70.0);
cam->set_view_point({ 0.0f, 1.4f, 1.0f });
cam->set_interest({ 0.0f, 1.4f, 0.0f });
uniform_value[U16] = 1;
imgui_context = ImGui::CreateContext();
ImGui::SetCurrentContext(imgui_context);
ImGuiIO& io = ImGui::GetIO();
io.IniFilename = 0;
io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;
io.Fonts->AddFontDefault();
const char* font_file_default_path = "rom\\ArialUni.ttf";
char* font_file = 0;
if (path_check_file_exists(font_file_default_path))
font_file = str_utils_copy(font_file_default_path);
else {
wchar_t temp_buf[MAX_PATH];
if (SUCCEEDED(SHGetFolderPathW(0, CSIDL_WINDOWS, 0, 0, temp_buf))) {
wcscat_s(temp_buf, sizeof(temp_buf) / sizeof(wchar_t), L"\\Fonts\\ArialUni.ttf");
if (path_check_file_exists(temp_buf))
font_file = utf16_to_utf8(temp_buf);
}
if (!font_file && SUCCEEDED(SHGetFolderPathW(0, CSIDL_LOCAL_APPDATA, 0, 0, temp_buf))) {
wcscat_s(temp_buf, sizeof(temp_buf) / sizeof(wchar_t), L"\\Microsoft\\Windows\\Fonts\\ArialUni.ttf");
if (path_check_file_exists(temp_buf))
font_file = utf16_to_utf8(temp_buf);
}
}
ImVector<ImWchar> ranges;
ImFontGlyphRangesBuilder builder;
builder.AddRanges(io.Fonts->GetGlyphRangesDefault());
builder.AddRanges(io.Fonts->GetGlyphRangesJapanese());
builder.AddRanges(io.Fonts->GetGlyphRangesChineseFull());
builder.AddRanges(io.Fonts->GetGlyphRangesKorean());
builder.AddRanges(io.Fonts->GetGlyphRangesCyrillic());
builder.AddRanges(io.Fonts->GetGlyphRangesGreek());
builder.AddChar((ImWchar)0x2200);
builder.BuildRanges(&ranges);
imgui_font_arial = 0;
if (font_file) {
imgui_font_arial = io.Fonts->AddFontFromFileTTF(font_file, 14.0f, 0, ranges.Data);
free(font_file);
}
io.Fonts->Build();
ImGui::StyleColorsDark();
if (Vulkan::use) {
ImGui_ImplVulkan_InitInfo init_info = {};
init_info.Instance = vulkan_instance;
init_info.PhysicalDevice = vulkan_physical_device;
init_info.Device = vulkan_device;
init_info.QueueFamily = vulkan_queue_family.first;
init_info.Queue = vulkan_graphics_queue;
init_info.DescriptorPool = vulkan_descriptor_pool;
init_info.RenderPass = *vulkan_swapchain_render_pass.get();
init_info.MinImageCount = max_def(MAX_FRAMES_IN_FLIGHT, 2u);
init_info.ImageCount = max_def(MAX_FRAMES_IN_FLIGHT, 2u);
init_info.MSAASamples = VK_SAMPLE_COUNT_1_BIT;
ImGui_ImplGlfw_InitForVulkan(window, true);
ImGui_ImplVulkan_Init(&init_info);
}
#ifdef USE_OPENGL
else {
ImGui_ImplGlfw_InitForOpenGL(window, true);
ImGui_ImplOpenGL3_Init("#version 430");
}
#endif
clear_color = 0xFF000000;
set_clear_color = true;
classes_process_init(classes, classes_count, rctx);
return rctx;
}
extern double_t input_move_x;
extern double_t input_move_y;
extern double_t input_rotate_x;
extern double_t input_rotate_y;
extern double_t input_roll;
extern bool input_reset;
#if PV_DEBUG
extern bool pv_x;
#endif
#if BAKE_X_PACK
extern bool pv_x_bake;
#endif
static void render_context_ctrl(render_context* rctx) {
if (Vulkan::use) {
app_begin_present_vulkan();
Vulkan::current_command_buffer = vulkan_command_buffers[vulkan_current_frame];
Vulkan::CommandBuffer::FreeData(Vulkan::current_command_buffer);
VkCommandBufferBeginInfo begin_info = {};
begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
if (vkBeginCommandBuffer(Vulkan::current_command_buffer, &begin_info) != VK_SUCCESS)
return;
Vulkan::manager_next_frame(vulkan_current_frame);
}
camera* cam = rctx->camera;
for (int32_t i = 0; i < 32; i++) {
if (!gl_rend_state.check_texture_binding_2d(i) && !gl_rend_state.check_texture_binding_cube_map(i))
continue;
gl_rend_state.active_bind_texture_2d(i, 0);
gl_rend_state.active_bind_texture_cube_map(i, 0);
gl_rend_state.bind_sampler(i, 0);
}
global_context_menu = true;
ImGui::SetCurrentContext(imgui_context);
app::TaskWork_window();
classes_process_imgui(classes, classes_count);
if (old_width != width || old_height != height || old_scale_index != scale_index)
app_resize_fb(rctx, true);
old_width = width;
old_height = height;
old_scale_index = scale_index;
ImGui::SetCurrentContext(imgui_context);
if (global_context_menu && ImGui::IsMouseReleased(ImGuiMouseButton_Right)
&& !ImGui::IsItemHovered(0) && imgui_context->OpenPopupStack.Size < 1)
ImGui::OpenPopup("Classes init context menu", 0);
if (ImGui::BeginPopupContextItem("Classes init context menu", 0)) {
render_imgui_context_menu(classes, classes_count, rctx);
ImGui::EndPopup();
}
if (window_handle == GetForegroundWindow()) {
if (input_reset) {
input_reset = false;
cam->reset();
//cam->set_position({ 1.35542f, 1.41634f, 1.27852f });
//cam->rotate({ -45.0, -32.5 });
//cam->set_position({ -6.67555f, 4.68882f, -3.67537f });
//cam->rotate({ 136.5, -20.5 });
cam->set_view_point({ 0.0f, 1.0f, 3.45f });
cam->set_interest({ 0.0f, 1.0f, 0.0f });
//cam->set_fov(70.0);
cam->set_fast_change_hist0(true);
cam->set_view_point({ 0.0f, 1.4f, 1.0f });
cam->set_interest({ 0.0f, 1.4f, 0.0f });
}
else {
cam->rotate((float_t)input_rotate_x, (float_t)input_rotate_y);
cam->move((float_t)input_move_x, (float_t)input_move_y);
if (input_roll != 0.0)
cam->set_roll(cam->get_roll() + (float_t)input_roll);
}
}
if (Input::IsKeyTapped(GLFW_KEY_F4))
game_state_set_game_state_next(GAME_STATE_ADVERTISE);
#if PV_DEBUG
else if (Input::IsKeyTapped(GLFW_KEY_F5, GLFW_MOD_CONTROL)) {
pv_x = false;
game_state_set_game_state_next(GAME_STATE_GAME);
}
#if BAKE_X_PACK
else if (Input::IsKeyTapped(GLFW_KEY_F5, GLFW_MOD_SHIFT)) {
pv_x = true;
pv_x_bake = true;
game_state_set_game_state_next(GAME_STATE_GAME);
}
else if (Input::IsKeyTapped(GLFW_KEY_F5)) {
pv_x = true;
pv_x_bake = false;
game_state_set_game_state_next(GAME_STATE_GAME);
}
#else
else if (Input::IsKeyTapped(GLFW_KEY_F5)) {
pv_x = true;
game_state_set_game_state_next(GAME_STATE_GAME);
}
#endif
#else
#if BAKE_X_PACK
else if (Input::IsKeyTapped(GLFW_KEY_F5, GLFW_MOD_SHIFT)) {
pv_x_bake = true;
game_state_set_game_state_next(GAME_STATE_GAME);
}
else if (Input::IsKeyTapped(GLFW_KEY_F5)) {
pv_x_bake = false;
game_state_set_game_state_next(GAME_STATE_GAME);
}
#else
else if (Input::IsKeyTapped(GLFW_KEY_F5))
game_state_set_game_state_next(GAME_STATE_GAME);
#endif
#endif
else if (Input::IsKeyTapped(GLFW_KEY_F6))
game_state_set_game_state_next(GAME_STATE_DATA_TEST);
else if (Input::IsKeyTapped(GLFW_KEY_F7))
game_state_set_game_state_next(GAME_STATE_TEST_MODE);
else if (Input::IsKeyTapped(GLFW_KEY_F8))
game_state_set_game_state_next(GAME_STATE_APP_ERROR);
else if (Input::IsKeyTapped(GLFW_KEY_F9)) // Added
game_state_set_game_state_next(GAME_STATE_DATA_EDIT); // Added
#if DISPLAY_IBL
else if (Input::IsKeyTapped(GLFW_KEY_L))
display_ibl ^= true;
else if (Input::IsKeyTapped(GLFW_KEY_1))
ibl_index = 0;
else if (Input::IsKeyTapped(GLFW_KEY_2))
ibl_index = 1;
else if (Input::IsKeyTapped(GLFW_KEY_3))
ibl_index = 2;
else if (Input::IsKeyTapped(GLFW_KEY_4))
ibl_index = 3;
else if (Input::IsKeyTapped(GLFW_KEY_5))
ibl_index = 4;
else if (Input::IsKeyTapped(GLFW_KEY_6))
ibl_index = 5;
else if (Input::IsKeyTapped(GLFW_KEY_7))
ibl_scale = max_def(ibl_scale - 1, 1);
else if (Input::IsKeyTapped(GLFW_KEY_8))
ibl_scale = min_def(ibl_scale + 1, 64);
#endif
classes_process_ctrl(classes, classes_count);
rctx_ptr = rctx;
input_state_ctrl();
if (!get_pause() || !game_state_get_pause())
game_state_ctrl();
rctx->ctrl();
if (fast_loader_speed > 1 && game_state_get_game_state() == GAME_STATE_STARTUP)
for (int32_t i = 1; i < fast_loader_speed; i++) {
rctx_ptr = rctx;
input_state_ctrl();
if (!get_pause() || !game_state_get_pause())
game_state_ctrl();
rctx->ctrl();
}
char buf[0x200];
game_state_print(buf, sizeof(buf));
glfwSetWindowTitle(window, buf);
ImGui::Render();
}
static void render_context_disp(render_context* rctx) {
static const vec4 color_clear = 0.0f;
static const GLfloat depth_clear = 1.0f;
static const GLint stencil_clear = 0;
for (int32_t i = 0; i < 32; i++) {
if (!gl_rend_state.check_texture_binding_2d(i) && !gl_rend_state.check_texture_binding_cube_map(i))
continue;
gl_rend_state.active_bind_texture_2d(i, 0);
gl_rend_state.active_bind_texture_cube_map(i, 0);
gl_rend_state.bind_sampler(i, 0);
}
gl_rend_state.bind_framebuffer(0);
gl_rend_state.set_depth_mask(GL_TRUE);
gl_rend_state.set_stencil_mask(0xFF);
glClearBufferfv(GL_COLOR, 0, (float_t*)&color_clear);
glClearDepthf(depth_clear);
gl_rend_state.set_stencil_mask(0x00);
gl_rend_state.set_depth_mask(GL_FALSE);
gl_rend_state.set_viewport(0, 0, internal_3d_res.x, internal_3d_res.y);
rctx->disp();
#if DISPLAY_IBL
if (display_ibl) {
rctx->screen_buffer.Bind();
mat4 mat;
mat4_translate_y(1.4f, &mat);
mat4_scale_rot(&mat, 1.125f, 1.125f, 1.125f, &mat);
mat4_mul(&mat, &rctx->camera->view, &mat);
//mat4_clear_trans(&mat, &mat);
mat4_mul(&mat, &rctx->camera->projection, &mat);
cubemap_display_batch_shader_data shader_data = {};
mat4_transpose(&mat, &mat);
shader_data.g_vp[0] = mat.row0;
shader_data.g_vp[1] = mat.row1;
shader_data.g_vp[2] = mat.row2;
shader_data.g_vp[3] = mat.row3;
shader_data.g_texture_lod.x = ibl_index == 1 ? 1.0f : 0.0f;
shader_data.g_texture_lod.y = 1.0f / (float_t)ibl_scale;
rctx_ptr->glitter_batch_ubo.WriteMemory(shader_data);
rctx_ptr->glitter_batch_ubo.Bind(3);
shaders_dev.set(SHADER_DEV_CUBEMAP_DISPLAY);
gl_rend_state.bind_vertex_array(ibl_vao);
gl_rend_state.active_bind_texture_cube_map(0,
light_param_data_storage_data_get_ibl_texture(max_def(ibl_index - 1, 0)));
shaders_dev.draw_arrays(GL_TRIANGLES, 0, 36);
gl_rend_state.bind_vertex_array(0);
}
#endif
if (Vulkan::use) {
Vulkan::end_render_pass(Vulkan::current_command_buffer);
#if BAKE_PNG || BAKE_VIDEO
gl_rend_state.set_viewport(0, 0, rctx->screen_width, rctx->screen_height);
#else
gl_rend_state.set_viewport(rctx->screen_x_offset, rctx->screen_y_offset,
rctx->sprite_width, rctx->sprite_height);
#endif
gl_rend_state.bind_framebuffer(0);
gl_rend_state.active_bind_texture_2d(0, rctx->screen_buffer.GetColorTex());
uniform_value[U_ALPHA_MASK] = 0;
uniform_value[U_REDUCE] = 0;
shaders_ft.set(SHADER_FT_REDUCE);
rctx->render.draw_quad(rctx->sprite_width, rctx->sprite_height,
1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f);
}
#ifdef USE_OPENGL
else {
#if BAKE_PNG || BAKE_VIDEO
fbo_blit(rctx->screen_buffer.fbos[0], 0,
0, 0, rctx->sprite_width, rctx->sprite_height,
0, 0, rctx->screen_width, rctx->screen_height, GL_COLOR_BUFFER_BIT, GL_LINEAR);
#else
fbo_blit(rctx->screen_buffer.fbos[0], 0,
0, 0, rctx->sprite_width, rctx->sprite_height,
rctx->screen_x_offset, rctx->screen_y_offset,
rctx->sprite_width, rctx->sprite_height, GL_COLOR_BUFFER_BIT, GL_LINEAR);
#endif
}
#endif
if (draw_imgui)
render_context_imgui(rctx);
if (Vulkan::use) {
Vulkan::end_render_pass(Vulkan::current_command_buffer);
Vulkan::gl_wrap_manager_update_buffers();
vkEndCommandBuffer(Vulkan::current_command_buffer);
app_end_present_vulkan();
}
}
static void render_context_imgui(render_context* rctx) {
ImGui::SetCurrentContext(imgui_context);
if (Vulkan::use)
ImGui_ImplVulkan_RenderDrawData(ImGui::GetDrawData(), Vulkan::current_command_buffer);
#ifdef USE_OPENGL
else
ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
#endif
}
static void render_context_dispose(render_context* rctx) {
if (Vulkan::use) {
vkQueueWaitIdle(vulkan_graphics_queue);
vkQueueWaitIdle(vulkan_present_queue);
}
classes_process_dispose(classes, classes_count);
if (Vulkan::use)
ImGui_ImplVulkan_Shutdown();
#ifdef USE_OPENGL
else
ImGui_ImplOpenGL3_Shutdown();
#endif
ImGui_ImplGlfw_Shutdown();
ImGui::DestroyContext(imgui_context);
Glitter::glt_particle_manager_del_task();
rctx->free();
task_auth_3d_del_task();
aet_manager_del_task();
task_pv_db_del_task();
app::TaskWork::dest();
sound_work_unload_farc("rom/sound/se.farc");
sound_work_unload_farc("rom/sound/button.farc");
sound_work_unload_farc("rom/sound/se_cmn.farc");
sound_work_unload_farc("rom/sound/se_sel.farc");
sound_work_unload_farc("rom/sound/se_aime.farc");
sound_work_unload_farc("rom/sound/pvchange.farc");
sound_work_unload_farc("rom/sound/slide_se.farc");
sound_work_unload_farc("rom/sound/slide_long.farc");
data_struct* aft_data = &data_list[DATA_AFT];
aet_database* aft_aet_db = &aft_data->data_ft.aet_db;
sprite_database* aft_spr_db = &aft_data->data_ft.spr_db;
objset_info_storage_unload_set(dbg_set_id);
aet_manager_unload_set(aet_gam_loadsc_set_id, aft_aet_db);
sprite_manager_unload_set(spr_gam_loadsc_set_id, aft_spr_db);
aet_manager_unload_set(aet_cmn_all_set_id, aft_aet_db);
sprite_manager_unload_set(spr_cmn_all_set_id, aft_spr_db);
sprite_manager_unload_set(spr_fnt_24_set_id, aft_spr_db);
sprite_manager_unload_set(spr_fnt_bold24_set_id, aft_spr_db);
sprite_manager_unload_set(spr_fnt_cmn_set_id, aft_spr_db);
sprite_manager_remove_spr_sets(aft_spr_db);
aet_manager_remove_aet_sets(aft_aet_db);
customize_item_data_handler_data_free();
customize_item_table_handler_data_free();
module_data_handler_data_free();
module_table_handler_data_free();
hand_item_handler_data_free();
if (Vulkan::use) {
vkQueueWaitIdle(vulkan_graphics_queue);
vkQueueWaitIdle(vulkan_present_queue);
}
render_timer->reset();
while (app::task_work->tasks.size()) {
render_timer->start_of_cycle();
if (Vulkan::use) {
app_begin_present_vulkan();
Vulkan::current_command_buffer = vulkan_command_buffers[vulkan_current_frame];
VkCommandBufferBeginInfo begin_info = {};
begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
if (vkBeginCommandBuffer(Vulkan::current_command_buffer, &begin_info) != VK_SUCCESS)
return;
Vulkan::manager_next_frame(vulkan_current_frame);
}
game_state_ctrl();
app::TaskWork::ctrl();
sound_ctrl();
file_handler_storage_ctrl();
app::TaskWork::basic();
if (Vulkan::use) {
Vulkan::end_render_pass(Vulkan::current_command_buffer);
Vulkan::gl_wrap_manager_update_buffers();
vkEndCommandBuffer(Vulkan::current_command_buffer);
app_end_present_vulkan();
app_swap_buffers();
}
render_timer->end_of_cycle();
}
light_param_data_storage_data_unload();
x_pv_game_data_free();
task_data_test_misc_free();
task_data_test_glitter_particle_free();
rob_chara_adjust_free();
rob_osage_test_free();
equip_test_free();
opd_test_free();
object_test_free();
motion_test_free();
dtm_stg_free();
dtm_aet_free();
auth_3d_test_task_free();
data_test_sel_free();
data_edit_sel_free();
render_manager_free_data();
dw_free();
Glitter::glt_particle_manager_free();
task_pv_db_free();
effect_free();
light_param_data_storage_data_free();
task_stage_modern_free();
task_stage_free();
task_auth_3d_free();
auth_3d_data_free();
sprite_manager_free();
aet_manager_free();
task_wind_free();
rob_free();
rand_state_array_free();
item_table_handler_array_free();
pv_expression_file_storage_free();
stage_param_data_free();
objset_info_storage_free();
ogg_playback_data_free();
ogg_file_handler_storage_free();
wave_audio_storage_free();
extern HRESULT mf_shutdown();
mf_shutdown();
sound_free();
dw_console_c_buff_array_free();
font_info_default_free();
fontmap_data_free();
input_state_free();
skin_param_data_free();
motion_free();
app::task_work_free();
delete rctx;
file_handler_storage_free();
texture_manager_free();
render_shaders_free();
data_struct_free();
}
struct shaders_load_struct {
shader_set_data* set;
const char* name;
};
static void render_shaders_load() {
shaders_load_struct load_ft = { &shaders_ft, "ft" };
data_list[DATA_AFT].load_file(&load_ft, "rom/",
Vulkan::use ? "ft_shaders_spirv.farc" : "ft_shaders.farc", app_load_ft_shaders);
shaders_load_struct load_dev = { &shaders_dev, "dev" };
data_list[DATA_AFT].load_file(&load_dev, "rom/",
Vulkan::use ? "dev_shaders_spirv.farc" : "dev_shaders.farc", app_load_dev_shaders);
}
static void render_shaders_free() {
shaders_dev.unload();
shaders_ft.unload();
}
static bool app_load_ft_shaders(void* data, const char* path, const char* file, uint32_t hash) {
shaders_load_struct* load = (shaders_load_struct*)data;
std::string s;
s.assign(path);
s.append(file);
farc f;
f.read(s.c_str(), true, false);
load->set->load(&f, false, load->name, shader_ft_table, shader_ft_table_size,
shader_ft_bind_func_table, shader_ft_bind_func_table_size,
shader_ft_get_index_by_name, shader_ft_get_name_by_index);
return true;
}
static bool app_load_dev_shaders(void* data, const char* path, const char* file, uint32_t hash) {
shaders_load_struct* load = (shaders_load_struct*)data;
std::string s;
s.assign(path);
s.append(file);
farc f;
f.read(s.c_str(), true, false);
load->set->load(&f, false, load->name, shader_dev_table, shader_dev_table_size,
0, 0, 0, 0);
return true;
}
static void app_drop_glfw(GLFWwindow* window, int32_t count, char** paths) {
if (!count || !paths)
return;
if (app::TaskWork::has_task(&glitter_editor)) {
glitter_editor.file.assign(paths[0]);
glitter_editor.load_popup = true;
}
glfwFocusWindow(window);
}
static void app_resize_fb_glfw(GLFWwindow* window, int32_t w, int32_t h) {
#if !(BAKE_PNG || BAKE_VIDEO)
width = w;
height = h;
vulkan_framebuffer_resized = true;
#endif
}
static void app_resize_fb(render_context* rctx, bool change_fb) {
internal_3d_res = vec2i::max(internal_3d_res, 20);
double_t res_width = (double_t)width;
double_t res_height = (double_t)height;
double_t view_aspect = res_width / res_height;
if (view_aspect < aspect)
res_height = round(res_width / aspect);
else if (view_aspect > aspect)
res_width = round(res_height * aspect);
#if BAKE_PNG || BAKE_VIDEO
vec2i internal_res = { (int32_t)res_width * BAKE_RES_SCALE, (int32_t)res_height * BAKE_RES_SCALE };
internal_2d_res = vec2i::clamp(internal_res, 1, sv_max_texture_size);
internal_3d_res.x = (int32_t)prj::roundf((float_t)internal_res.x);
internal_3d_res.y = (int32_t)prj::roundf((float_t)internal_res.y);
internal_3d_res = vec2i::clamp(internal_3d_res, 1, sv_max_texture_size);
#else
vec2i internal_res = { (int32_t)res_width, (int32_t)res_height };
internal_2d_res = vec2i::clamp(internal_res, 1, sv_max_texture_size);
internal_3d_res.x = (int32_t)prj::roundf((float_t)(internal_res.x * render_scale_table[scale_index]));
internal_3d_res.y = (int32_t)prj::roundf((float_t)(internal_res.y * render_scale_table[scale_index]));
internal_3d_res = vec2i::clamp(internal_3d_res, 1, sv_max_texture_size);
#endif
bool fb_changed = old_internal_2d_res.x != internal_2d_res.x
|| old_internal_2d_res.y != internal_2d_res.y
|| old_internal_3d_res.x != internal_3d_res.x
|| old_internal_3d_res.y != internal_3d_res.y
|| old_width != width || old_height != height;
old_internal_2d_res = internal_2d_res;
old_internal_3d_res = internal_3d_res;
if (fb_changed && change_fb)
rctx->resize(internal_3d_res.x, internal_3d_res.y,
internal_2d_res.x, internal_2d_res.y, width, height);
}
static void render_imgui_context_menu(classes_data* classes,
const size_t classes_count, render_context* rctx) {
#pragma warning(disable:26115)
#pragma warning(disable:26117)
for (size_t i = 0; i < classes_count; i++) {
classes_data* c = &classes[i];
if (!c->name || !(c->flags & CLASSES_IN_CONTEXT_MENU))
continue;
if (c->sub_classes && c->sub_classes_count) {
if (ImGui::BeginMenu(c->name, !(c->data.flags & CLASS_HIDDEN))) {
render_imgui_context_menu(c->sub_classes, c->sub_classes_count, rctx);
ImGui::EndMenu();
}
}
else if (c->data.flags & CLASS_DW) {
if (ImGui::MenuItem(c->name, 0))
if (c->init)
c->init(0, 0);
}
else if (!(c->data.flags & CLASS_HIDDEN))
ImGui::MenuItem(c->name, 0, false, false);
else if (ImGui::MenuItem(c->name, 0)) {
if (!(c->data.flags & CLASS_INIT)) {
if (c->init) {
if (c->init(&c->data, rctx))
c->data.flags = CLASS_INIT;
else
c->data.flags = (class_flags)(CLASS_DISPOSED | CLASS_HIDDEN);
}
}
if (c->data.flags & CLASS_INIT)
enum_and(c->data.flags, ~(CLASS_HIDE | CLASS_HIDDEN | CLASS_HIDE_WINDOW)); }
}
}
#if RENDER_DEBUG
static void APIENTRY render_debug_output(GLenum source, GLenum type, uint32_t id,
GLenum severity, GLsizei length, const char* message, const void* userParam) {
if (!id && severity == GL_DEBUG_SEVERITY_NOTIFICATION
|| id == 131169 || id == 131185 || id == 131218 || id == 131204)
return;
printf_debug("########################################\n");
switch (type) {
case GL_DEBUG_TYPE_ERROR:
printf_debug("Type: Error; ");
break;
case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR:
printf_debug("Type: Deprecated Behaviour; ");
break;
case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR:
printf_debug("Type: Undefined Behaviour; ");
break;
case GL_DEBUG_TYPE_PORTABILITY:
printf_debug("Type: Portability; ");
break;
case GL_DEBUG_TYPE_PERFORMANCE:
printf_debug("Type: Performance; ");
break;
case GL_DEBUG_TYPE_MARKER:
printf_debug("Type: Marker; ");
break;
case GL_DEBUG_TYPE_PUSH_GROUP:
printf_debug("Type: Push Group; ");
break;
case GL_DEBUG_TYPE_POP_GROUP:
printf_debug("Type: Pop Group; ");
break;
case GL_DEBUG_TYPE_OTHER:
printf_debug("Type: Other; ");
break;
}
switch (severity) {
case GL_DEBUG_SEVERITY_HIGH:
printf_debug("Severity: high; ");
break;
case GL_DEBUG_SEVERITY_MEDIUM:
printf_debug("Severity: medium; ");
break;
case GL_DEBUG_SEVERITY_LOW:
printf_debug("Severity: low; ");
break;
case GL_DEBUG_SEVERITY_NOTIFICATION:
printf_debug("Severity: notif; ");
break;
}
switch (source) {
case GL_DEBUG_SOURCE_API:
printf_debug("Source: API\n");
break;
case GL_DEBUG_SOURCE_WINDOW_SYSTEM:
printf_debug("Source: Window System\n");
break;
case GL_DEBUG_SOURCE_SHADER_COMPILER:
printf_debug("Source: Shader Compiler\n");
break;
case GL_DEBUG_SOURCE_THIRD_PARTY:
printf_debug("Source: Third Party\n");
break;
case GL_DEBUG_SOURCE_APPLICATION:
printf_debug("Source: Application\n");
break;
case GL_DEBUG_SOURCE_OTHER:
printf_debug("Source: Other\n");
break;
}
printf_debug("Debug message (%d): %s\n", id, message);
printf_debug("########################################\n\n");
}
#endif
static int32_t app_init_vulkan() {
if (volkInitialize() != VK_SUCCESS)
return -3;
int32_t ret;
ret = app_create_vulkan_instance();
if (ret)
goto vulkan_destroy_instance;
#if RENDER_DEBUG
ret = app_setup_debug_messenger();
if (ret)
goto vulkan_destroy_debug_utils_mesenger;
#endif
ret = app_create_surface();
if (ret)
goto vulkan_destroy_surface;
ret = app_pick_physical_device();
if (ret)
goto vulkan_destroy_surface;
ret = app_create_logical_device();
if (ret)
goto vulkan_destroy_device;
ret = app_create_allocator();
if (ret)
goto vulkan_destroy_allocator;
ret = app_create_command_pool();
if (ret)
goto vulkan_destroy_command_pool;
{
Vulkan::CommandBuffer init_command_buffer;
init_command_buffer.Create(vulkan_device, vulkan_command_pool);
init_command_buffer.BeginOneTimeSubmit();
Vulkan::current_command_buffer = init_command_buffer;
Vulkan::manager_init(MAX_FRAMES_IN_FLIGHT);
Vulkan::gl_wrap_manager_init(init_command_buffer);
Vulkan::current_command_buffer = 0;
init_command_buffer.Sumbit(vulkan_graphics_queue);
init_command_buffer.Destroy();
}
ret = app_create_command_buffers();
if (ret)
goto vulkan_destroy_command_buffers;
ret = app_create_sync_objects();
if (ret)
goto vulkan_destroy_sync_objects;
ret = app_create_descriptor_pool();
if (ret)
goto vulkan_destroy_descriptor_pool;
ret = app_create_swapchain();
if (ret)
goto vulkan_destroy_swapchain;
return 0;
vulkan_destroy_swapchain:
for (Vulkan::Framebuffer& i : vulkan_swapchain_framebuffers)
i.Destroy();
vulkan_swapchain_framebuffers.clear();
vulkan_swapchain_render_pass.reset();
for (Vulkan::ImageView& i : vulkan_swapchain_image_views)
i.Destroy();
vulkan_swapchain_image_views.clear();
vulkan_swapchain_images.clear();
if (vulkan_swapchain) {
vkDestroySwapchainKHR(vulkan_device, vulkan_swapchain, 0);
vulkan_swapchain = 0;
}
vulkan_destroy_descriptor_pool:
if (vulkan_descriptor_pool) {
vkDestroyDescriptorPool(vulkan_device, vulkan_descriptor_pool, 0);
vulkan_descriptor_pool = 0;
}
vulkan_destroy_sync_objects:
for (Vulkan::Semaphore& i : vulkan_render_finished_semaphores)
i.Destroy();
vulkan_render_finished_semaphores.clear();
for (Vulkan::Semaphore& i : vulkan_image_available_semaphores)
i.Destroy();
vulkan_image_available_semaphores.clear();
for (Vulkan::Fence& i : vulkan_in_flight_fences)
i.Destroy();
vulkan_in_flight_fences.clear();
vulkan_destroy_command_buffers:
if (vulkan_command_buffers.size()) {
for (VkCommandBuffer& i : vulkan_command_buffers) {
Vulkan::CommandBuffer cb(vulkan_device, vulkan_command_pool, i);
cb.Destroy();
}
vulkan_command_buffers.clear();
}
vulkan_destroy_command_pool:
if (vulkan_command_pool) {
vkDestroyCommandPool(vulkan_device, vulkan_command_pool, 0);
vulkan_command_pool = 0;
}
vulkan_destroy_allocator:
if (vulkan_allocator) {
vmaDestroyAllocator(vulkan_allocator);
vulkan_allocator = 0;
}
vulkan_destroy_device:
if (vulkan_device) {
vkDestroyDevice(vulkan_device, 0);
vulkan_device = 0;
}
vulkan_destroy_surface:
if (vulkan_surface) {
vkDestroySurfaceKHR(vulkan_instance, vulkan_surface, 0);
vulkan_surface = 0;
}
#if RENDER_DEBUG
vulkan_destroy_debug_utils_mesenger :
if (vulkan_debug_messenger) {
app_vkDestroyDebugUtilsMessengerEXT(vulkan_instance, vulkan_debug_messenger, 0);
vulkan_debug_messenger = 0;
}
#endif
vulkan_destroy_instance:
if (vulkan_instance) {
vkDestroyInstance(vulkan_instance, 0);
vulkan_instance = 0;
}
return ret;
}
static int32_t app_begin_present_vulkan() {
vulkan_in_flight_fences[vulkan_current_frame].WaitFor();
Vulkan::manager_reset_descriptor_pipelines_descriptor_set_collections();
VkResult result = vkAcquireNextImageKHR(vulkan_device, vulkan_swapchain,
UINT64_MAX, vulkan_image_available_semaphores[vulkan_current_frame], 0, &vulkan_image_index);
if (result == VK_ERROR_OUT_OF_DATE_KHR)
app_recreate_swapchain();
else if (result != VK_SUCCESS && result != VK_SUBOPTIMAL_KHR)
return -30001;
vulkan_in_flight_fences[vulkan_current_frame].Reset();
vkResetCommandBuffer(vulkan_command_buffers[vulkan_current_frame], 0);
Vulkan::current_swapchain_image = vulkan_swapchain_images[vulkan_image_index];
VkRenderPassBeginInfo& info = vulkan_swapchain_render_pass_info;
info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
info.renderPass = *vulkan_swapchain_render_pass.get();
info.framebuffer = vulkan_swapchain_framebuffers[vulkan_image_index];
info.renderArea.extent.width = vulkan_swapchain_extent.width;
info.renderArea.extent.height = vulkan_swapchain_extent.height;
info.clearValueCount = 0;
return 0;
}
static int32_t app_end_present_vulkan() {
VkSubmitInfo submit_info = {};
submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
VkPipelineStageFlags wait_stages[] = { VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT };
submit_info.waitSemaphoreCount = 1;
submit_info.pWaitSemaphores = vulkan_image_available_semaphores[vulkan_current_frame];
submit_info.pWaitDstStageMask = wait_stages;
submit_info.commandBufferCount = 1;
submit_info.pCommandBuffers = &vulkan_command_buffers[vulkan_current_frame];
submit_info.signalSemaphoreCount = 1;
submit_info.pSignalSemaphores = vulkan_render_finished_semaphores[vulkan_current_frame];
if (vkQueueSubmit(vulkan_graphics_queue, 1, &submit_info,
vulkan_in_flight_fences[vulkan_current_frame]) != VK_SUCCESS)
return -30002;
VkPresentInfoKHR present_info = {};
present_info.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
present_info.waitSemaphoreCount = 1;
present_info.pWaitSemaphores = vulkan_render_finished_semaphores[vulkan_current_frame];
present_info.swapchainCount = 1;
present_info.pSwapchains = &vulkan_swapchain;
present_info.pImageIndices = &vulkan_image_index;
VkResult result = vkQueuePresentKHR(vulkan_present_queue, &present_info);
if (result == VK_ERROR_OUT_OF_DATE_KHR || result == VK_SUBOPTIMAL_KHR || vulkan_framebuffer_resized) {
vulkan_framebuffer_resized = false;
app_recreate_swapchain();
}
else if (result != VK_SUCCESS)
return -30003;
vulkan_current_frame = (vulkan_current_frame + 1) % MAX_FRAMES_IN_FLIGHT;
return 0;
}
static void app_recreate_swapchain() {
vkDeviceWaitIdle(vulkan_device);
for (Vulkan::Framebuffer& i : vulkan_swapchain_framebuffers)
i.Destroy();
vulkan_swapchain_framebuffers.clear();
vulkan_swapchain_render_pass.reset();
for (Vulkan::ImageView& i : vulkan_swapchain_image_views)
i.Destroy();
vulkan_swapchain_image_views.clear();
vulkan_swapchain_images.clear();
if (vulkan_swapchain) {
vkDestroySwapchainKHR(vulkan_device, vulkan_swapchain, 0);
vulkan_swapchain = 0;
}
app_create_swapchain();
}
static void app_free_vulkan() {
Vulkan::CommandBuffer free_command_buffer;
free_command_buffer.Create(vulkan_device, vulkan_command_pool);
free_command_buffer.BeginOneTimeSubmit();
Vulkan::current_command_buffer = free_command_buffer;
for (Vulkan::Framebuffer& i : vulkan_swapchain_framebuffers)
i.Destroy();
vulkan_swapchain_framebuffers.clear();
vulkan_swapchain_render_pass.reset();
for (Vulkan::ImageView& i : vulkan_swapchain_image_views)
i.Destroy();
vulkan_swapchain_image_views.clear();
vulkan_swapchain_images.clear();
if (vulkan_swapchain) {
vkDestroySwapchainKHR(vulkan_device, vulkan_swapchain, 0);
vulkan_swapchain = 0;
}
Vulkan::manager_free_pipelines();
Vulkan::manager_free_descriptor_pipelines();
Vulkan::manager_free_samplers();
Vulkan::manager_free_render_passes();
if (vulkan_descriptor_pool) {
vkDestroyDescriptorPool(vulkan_device, vulkan_descriptor_pool, 0);
vulkan_descriptor_pool = 0;
}
Vulkan::gl_wrap_manager_free();
Vulkan::manager_free();
Vulkan::current_command_buffer = 0;
free_command_buffer.Sumbit(vulkan_graphics_queue);
free_command_buffer.Destroy();
vkQueueWaitIdle(vulkan_graphics_queue);
vkQueueWaitIdle(vulkan_present_queue);
for (Vulkan::Semaphore& i : vulkan_render_finished_semaphores)
i.Destroy();
vulkan_render_finished_semaphores.clear();
for (Vulkan::Semaphore& i : vulkan_image_available_semaphores)
i.Destroy();
vulkan_image_available_semaphores.clear();
for (Vulkan::Fence& i : vulkan_in_flight_fences)
i.Destroy();
vulkan_in_flight_fences.clear();
if (vulkan_command_buffers.size()) {
for (VkCommandBuffer& i : vulkan_command_buffers)
Vulkan::CommandBuffer::FreeData(i);
vkFreeCommandBuffers(vulkan_device, vulkan_command_pool,
(uint32_t)vulkan_command_buffers.size(), vulkan_command_buffers.data());
vulkan_command_buffers.clear();
}
if (vulkan_command_pool) {
vkDestroyCommandPool(vulkan_device, vulkan_command_pool, 0);
vulkan_command_pool = 0;
}
if (vulkan_allocator) {
vmaDestroyAllocator(vulkan_allocator);
vulkan_allocator = 0;
}
if (vulkan_device) {
vkDestroyDevice(vulkan_device, 0);
vulkan_device = 0;
}
if (vulkan_surface) {
vkDestroySurfaceKHR(vulkan_instance, vulkan_surface, 0);
vulkan_surface = 0;
}
#if RENDER_DEBUG
if (vulkan_debug_messenger) {
app_vkDestroyDebugUtilsMessengerEXT(vulkan_instance, vulkan_debug_messenger, 0);
vulkan_debug_messenger = 0;
}
#endif
if (vulkan_instance) {
vkDestroyInstance(vulkan_instance, 0);
vulkan_instance = 0;
}
}
static int32_t app_create_vulkan_instance() {
#if RENDER_DEBUG
if (!app_check_validation_layer_support())
return -3;
#endif
VkApplicationInfo application_info = {};
application_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
application_info.pApplicationName = "app";
application_info.applicationVersion = VK_MAKE_API_VERSION(0, 1, 1, 0);
application_info.pEngineName = "app";
application_info.engineVersion = VK_MAKE_API_VERSION(0, 1, 1, 0);
application_info.apiVersion = VK_API_VERSION_1_1;
VkInstanceCreateInfo instance_create_info = {};
instance_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instance_create_info.pApplicationInfo = &application_info;
std::vector<const char*> extensions = app_get_required_extensions();
instance_create_info.enabledExtensionCount = (uint32_t)extensions.size();
instance_create_info.ppEnabledExtensionNames = extensions.data();
#if RENDER_DEBUG
instance_create_info.enabledLayerCount = (uint32_t)sizeof(vulkan_validation_layers) / sizeof(const char*);
instance_create_info.ppEnabledLayerNames = vulkan_validation_layers;
VkDebugUtilsMessengerCreateInfoEXT debug_create_info = {};
debug_create_info.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
debug_create_info.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT
| VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT
| VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
debug_create_info.messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT
| VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT
| VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT;
debug_create_info.pfnUserCallback = app_debug_callback;
instance_create_info.pNext = &debug_create_info;
#else
instance_create_info.enabledLayerCount = 0;
instance_create_info.pNext = 0;
#endif
if (vkCreateInstance(&instance_create_info, 0, &vulkan_instance) != VK_SUCCESS)
return -4;
volkLoadInstance(vulkan_instance);
return 0;
}
#if RENDER_DEBUG
static int32_t app_setup_debug_messenger() {
VkDebugUtilsMessengerCreateInfoEXT create_info = {};
create_info.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
create_info.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT
| VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT
| VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
create_info.messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT
| VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT
| VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT;
create_info.pfnUserCallback = app_debug_callback;
if (app_vkCreateDebugUtilsMessengerEXT(vulkan_instance,
&create_info, 0, &vulkan_debug_messenger) != VK_SUCCESS)
return -5;
return 0;
}
#endif
static int32_t app_create_surface() {
if (glfwCreateWindowSurface(vulkan_instance, window, 0, &vulkan_surface) != VK_SUCCESS)
return -6;
return 0;
}
static int32_t app_pick_physical_device() {
uint32_t device_count = 0;
vkEnumeratePhysicalDevices(vulkan_instance, &device_count, 0);
if (!device_count)
return -7;
std::vector<VkPhysicalDevice> devices;
devices.resize(device_count);
vkEnumeratePhysicalDevices(vulkan_instance, &device_count, devices.data());
for (const VkPhysicalDevice& i : devices)
if (app_check_is_device_suitable(i)) {
vulkan_physical_device = i;
break;
}
if (vulkan_physical_device == 0)
return -8;
VkPhysicalDeviceMemoryProperties memory_properties;
vkGetPhysicalDeviceMemoryProperties(vulkan_physical_device, &memory_properties);
for (uint32_t i = 0; i < memory_properties.memoryTypeCount; i++) {
VkMemoryType& memory_type = memory_properties.memoryTypes[i];
if (!memory_type.propertyFlags) {
printf("Memory Index: %2d; Heap Index: %d; not DEVICE_LOCAL, not HOST_VISIBLE\n", i, memory_type.heapIndex);
continue;
}
printf("Memory Index: %2d; Heap Index: %d; ", i, memory_type.heapIndex);
bool flags_printed = false;
if (memory_type.propertyFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) {
printf(flags_printed ? ", %s" : "%s", "DEVICE_LOCAL");
flags_printed = true;
}
if (memory_type.propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) {
printf(flags_printed ? ", %s" : "%s", "HOST_VISIBLE");
flags_printed = true;
}
if (memory_type.propertyFlags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) {
printf(flags_printed ? ", %s" : "%s", "HOST_COHERENT");
flags_printed = true;
}
if (memory_type.propertyFlags & VK_MEMORY_PROPERTY_HOST_CACHED_BIT) {
printf(flags_printed ? ", %s" : "%s", "HOST_CACHED");
flags_printed = true;
}
if (memory_type.propertyFlags & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT) {
printf(flags_printed ? ", %s" : "%s", "LAZILY_ALLOCATED");
flags_printed = true;
}
if (memory_type.propertyFlags & VK_MEMORY_PROPERTY_PROTECTED_BIT) {
printf(flags_printed ? ", %s" : "%s", "PROPERTY_PROTECTED");
flags_printed = true;
}
printf("\n");
}
int32_t max_digits = 1;
int32_t max_mib_digits = 1;
for (uint32_t i = 0; i < memory_properties.memoryHeapCount; i++) {
VkDeviceSize size = memory_properties.memoryHeaps[i].size;
VkDeviceSize mib_size = ((size + 1023) / 1024 + 1023) / 1024;
int32_t digits = 1;
while (size /= 10)
digits++;
if (max_digits < digits)
max_digits = digits;
int32_t mib_digits = 1;
while (mib_size /= 10)
mib_digits++;
if (max_mib_digits < mib_digits)
max_mib_digits = mib_digits;
}
for (uint32_t i = 0; i < memory_properties.memoryHeapCount; i++) {
VkMemoryHeap& memory_heap = memory_properties.memoryHeaps[i];
VkDeviceSize mib_size = ((memory_heap.size + 1023) / 1024 + 1023) / 1024;
if (!memory_heap.flags) {
printf("Heap Index: %2d; Heap Size: %*llu bytes (~%*llu MiB); not DEVICE_LOCAL, not MULTI_INSTANCE\n",
i, max_digits, memory_heap.size, max_mib_digits, mib_size);
continue;
}
printf("Heap Index: %2d; Heap Size: %*llu bytes (~%*llu MiB); ",
i, max_digits, memory_heap.size, max_mib_digits, mib_size);
bool flags_printed = false;
if (memory_heap.flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) {
printf(flags_printed ? ", %s" : "%s", "DEVICE_LOCAL");
flags_printed = true;
}
printf("\n");
}
return 0;
}
static int32_t app_create_logical_device() {
std::pair<uint32_t, uint32_t> indices = app_find_queue_families(vulkan_physical_device);
if (indices.first == -1 || indices.second == -1)
return -9;
std::vector<uint32_t> unique_queue_families;
unique_queue_families.insert(unique_queue_families.end(), indices.first);
unique_queue_families.insert(unique_queue_families.end(), indices.second);
prj::sort_unique(unique_queue_families);
std::vector<VkDeviceQueueCreateInfo> queue_create_infos;
queue_create_infos.reserve(unique_queue_families.size());
float_t queue_priority = 1.0f;
for (uint32_t i : unique_queue_families) {
VkDeviceQueueCreateInfo queue_create_info = {};
queue_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
queue_create_info.queueFamilyIndex = i;
queue_create_info.queueCount = 1;
queue_create_info.pQueuePriorities = &queue_priority;
queue_create_infos.push_back(queue_create_info);
}
VkPhysicalDeviceFeatures device_features = {};
device_features.samplerAnisotropy = VK_TRUE;
device_features.textureCompressionBC = VK_TRUE;
device_features.shaderImageGatherExtended = VK_TRUE;
VkDeviceCreateInfo create_info = {};
create_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
create_info.queueCreateInfoCount = (uint32_t)queue_create_infos.size();
create_info.pQueueCreateInfos = queue_create_infos.data();
create_info.pEnabledFeatures = &device_features;
create_info.enabledExtensionCount = (uint32_t)sizeof(vulkan_device_extensions) / sizeof(const char*);
create_info.ppEnabledExtensionNames = vulkan_device_extensions;
#if RENDER_DEBUG
create_info.enabledLayerCount = (uint32_t)sizeof(vulkan_validation_layers) / sizeof(const char*);
create_info.ppEnabledLayerNames = vulkan_validation_layers;
#else
create_info.enabledLayerCount = 0;
#endif
if (vkCreateDevice(vulkan_physical_device, &create_info, 0, &vulkan_device) != VK_SUCCESS)
return -10;
Vulkan::current_device = vulkan_device;
vulkan_queue_family = indices;
vkGetDeviceQueue(vulkan_device, indices.first, 0, &vulkan_graphics_queue);
vkGetDeviceQueue(vulkan_device, indices.second, 0, &vulkan_present_queue);
Vulkan::current_graphics_queue = vulkan_graphics_queue;
Vulkan::current_present_queue = vulkan_present_queue;
return 0;
}
static int32_t app_create_allocator() {
VmaVulkanFunctions vma_vulkan_func = {};
vma_vulkan_func.vkGetInstanceProcAddr = vkGetInstanceProcAddr;
vma_vulkan_func.vkGetDeviceProcAddr = vkGetDeviceProcAddr;
vma_vulkan_func.vkGetPhysicalDeviceProperties = vkGetPhysicalDeviceProperties;
vma_vulkan_func.vkGetPhysicalDeviceMemoryProperties = vkGetPhysicalDeviceMemoryProperties;
vma_vulkan_func.vkAllocateMemory = vkAllocateMemory;
vma_vulkan_func.vkFreeMemory = vkFreeMemory;
vma_vulkan_func.vkMapMemory = vkMapMemory;
vma_vulkan_func.vkUnmapMemory = vkUnmapMemory;
vma_vulkan_func.vkFlushMappedMemoryRanges = vkFlushMappedMemoryRanges;
vma_vulkan_func.vkInvalidateMappedMemoryRanges = vkInvalidateMappedMemoryRanges;
vma_vulkan_func.vkBindBufferMemory = vkBindBufferMemory;
vma_vulkan_func.vkBindImageMemory = vkBindImageMemory;
vma_vulkan_func.vkGetBufferMemoryRequirements = vkGetBufferMemoryRequirements;
vma_vulkan_func.vkGetImageMemoryRequirements = vkGetImageMemoryRequirements;
vma_vulkan_func.vkCreateBuffer = vkCreateBuffer;
vma_vulkan_func.vkDestroyBuffer = vkDestroyBuffer;
vma_vulkan_func.vkCreateImage = vkCreateImage;
vma_vulkan_func.vkDestroyImage = vkDestroyImage;
vma_vulkan_func.vkCmdCopyBuffer = vkCmdCopyBuffer;
vma_vulkan_func.vkGetBufferMemoryRequirements2KHR = vkGetBufferMemoryRequirements2;
vma_vulkan_func.vkGetImageMemoryRequirements2KHR = vkGetImageMemoryRequirements2;
vma_vulkan_func.vkBindBufferMemory2KHR = vkBindBufferMemory2;
vma_vulkan_func.vkBindImageMemory2KHR = vkBindImageMemory2;
vma_vulkan_func.vkGetPhysicalDeviceMemoryProperties2KHR = vkGetPhysicalDeviceMemoryProperties2;
VmaAllocatorCreateInfo create_info = {};
create_info.vulkanApiVersion = VK_API_VERSION_1_1;
create_info.physicalDevice = vulkan_physical_device;
create_info.device = vulkan_device;
create_info.pVulkanFunctions = &vma_vulkan_func;
create_info.instance = vulkan_instance;
if (vmaCreateAllocator(&create_info, &vulkan_allocator) != VK_SUCCESS)
return -11;
Vulkan::current_allocator = vulkan_allocator;
return 0;
}
static int32_t app_create_command_pool() {
std::pair<uint32_t, uint32_t> indices = app_find_queue_families(vulkan_physical_device);
if (indices.first == -1)
return -12;
VkCommandPoolCreateInfo pool_info = {};
pool_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
pool_info.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
pool_info.queueFamilyIndex = indices.first;
if (vkCreateCommandPool(vulkan_device, &pool_info, 0, &vulkan_command_pool) != VK_SUCCESS)
return -13;
Vulkan::current_command_pool = vulkan_command_pool;
return 0;
}
static int32_t app_create_command_buffers() {
size_t command_buffer_count = MAX_FRAMES_IN_FLIGHT;
vulkan_command_buffers.resize(command_buffer_count);
VkCommandBufferAllocateInfo alloc_info = {};
alloc_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
alloc_info.commandPool = vulkan_command_pool;
alloc_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
alloc_info.commandBufferCount = (uint32_t)command_buffer_count;
if (vkAllocateCommandBuffers(vulkan_device, &alloc_info, vulkan_command_buffers.data()) != VK_SUCCESS)
return -19;
return 0;
}
static int32_t app_create_sync_objects() {
size_t in_flight_fence_count = MAX_FRAMES_IN_FLIGHT;
vulkan_image_available_semaphores.resize(in_flight_fence_count);
vulkan_render_finished_semaphores.resize(in_flight_fence_count);
vulkan_in_flight_fences.resize(in_flight_fence_count);
for (size_t i = 0; i < in_flight_fence_count; i++)
if (!vulkan_image_available_semaphores[i].Create(vulkan_device, 0)
|| !vulkan_render_finished_semaphores[i].Create(vulkan_device, 0)
|| !vulkan_in_flight_fences[i].Create(vulkan_device, VK_FENCE_CREATE_SIGNALED_BIT))
return -20;
return 0;
}
static int32_t app_create_descriptor_pool() {
VkDescriptorPoolSize pool_sizes[2] = {};
pool_sizes[0].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
pool_sizes[0].descriptorCount = 16;
pool_sizes[1].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
pool_sizes[1].descriptorCount = 4;
VkDescriptorPoolCreateInfo pool_info = {};
pool_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
pool_info.flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;
pool_info.maxSets = 2000 * MAX_FRAMES_IN_FLIGHT;
pool_info.poolSizeCount = sizeof(pool_sizes) / sizeof(VkDescriptorPoolSize);
pool_info.pPoolSizes = pool_sizes;
if (vkCreateDescriptorPool(vulkan_device, &pool_info, 0, &vulkan_descriptor_pool) != VK_SUCCESS)
return -21;
Vulkan::current_descriptor_pool = vulkan_descriptor_pool;
return 0;
}
static int32_t app_create_swapchain() {
vulkan_swapchain_support_details swapchain_support = app_query_swapchain_support(vulkan_physical_device);
VkSurfaceFormatKHR surface_format = app_choose_swap_surface_format(swapchain_support.formats);
VkPresentModeKHR present_mode = app_choose_swap_present_mode(swapchain_support.present_modes);
VkExtent2D extent = app_choose_swap_extent(swapchain_support.capabilities);
uint32_t image_count = swapchain_support.capabilities.minImageCount + 1;
if (swapchain_support.capabilities.maxImageCount > 0
&& image_count > swapchain_support.capabilities.maxImageCount)
image_count = swapchain_support.capabilities.maxImageCount;
VkSwapchainCreateInfoKHR create_info = {};
create_info.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
create_info.surface = vulkan_surface;
create_info.minImageCount = image_count;
create_info.imageFormat = surface_format.format;
create_info.imageColorSpace = surface_format.colorSpace;
create_info.imageExtent = extent;
create_info.imageArrayLayers = 1;
create_info.imageUsage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
std::pair<uint32_t, uint32_t> indices = app_find_queue_families(vulkan_physical_device);
uint32_t queue_family_indices[2];
queue_family_indices[0] = indices.first;
queue_family_indices[1] = indices.second;
if (indices.first != indices.second) {
create_info.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
create_info.queueFamilyIndexCount = sizeof(queue_family_indices) / sizeof(uint32_t);
create_info.pQueueFamilyIndices = queue_family_indices;
}
else
create_info.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
create_info.preTransform = swapchain_support.capabilities.currentTransform;
create_info.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
create_info.presentMode = present_mode;
create_info.clipped = VK_TRUE;
create_info.oldSwapchain = 0;
if (vkCreateSwapchainKHR(vulkan_device, &create_info, 0, &vulkan_swapchain) != VK_SUCCESS)
return -24;
vkGetSwapchainImagesKHR(vulkan_device, vulkan_swapchain, &image_count, 0);
vulkan_swapchain_images.resize(image_count);
vkGetSwapchainImagesKHR(vulkan_device, vulkan_swapchain, &image_count, vulkan_swapchain_images.data());
vulkan_swapchain_extent = extent;
Vulkan::Fence fence;
fence.Create(vulkan_device, 0);
Vulkan::CommandBuffer cb;
cb.Create(vulkan_device, vulkan_command_pool);
cb.BeginOneTimeSubmit();
Vulkan::current_command_buffer = cb;
for (VkImage& i : vulkan_swapchain_images)
Vulkan::Image::PipelineBarrierSingle(cb, i, VK_IMAGE_ASPECT_COLOR_BIT, 0, 0,
VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR);
Vulkan::current_command_buffer = 0;
cb.Sumbit(vulkan_graphics_queue, fence);
cb.Destroy();
fence.Destroy();
vulkan_swapchain_image_views.resize(image_count);
for (uint32_t i = 0; i < image_count; i++)
vulkan_swapchain_image_views[i].Create(vulkan_device, 0, vulkan_swapchain_images[i],
VK_IMAGE_VIEW_TYPE_2D, surface_format.format, VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1);
VkAttachmentReference color_attachment_reference;
color_attachment_reference.attachment = 0;
color_attachment_reference.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
VkSubpassDescription subpass_description = {};
subpass_description.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
subpass_description.colorAttachmentCount = 1;
subpass_description.pColorAttachments = &color_attachment_reference;
VkSubpassDependency subpass_dependency = {};
subpass_dependency.srcSubpass = VK_SUBPASS_EXTERNAL;
subpass_dependency.dstSubpass = 0;
subpass_dependency.srcStageMask = 0;
subpass_dependency.srcAccessMask = 0;
subpass_dependency.dstStageMask = 0;
subpass_dependency.dstAccessMask = 0;
subpass_dependency.srcStageMask |= VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
subpass_dependency.dstStageMask |= VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
subpass_dependency.dstAccessMask |= VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
int32_t attachment_count = 0;
VkAttachmentDescription color_attachment;
color_attachment.flags = 0;
color_attachment.format = surface_format.format;
color_attachment.samples = VK_SAMPLE_COUNT_1_BIT;
color_attachment.loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
color_attachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
color_attachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
color_attachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
color_attachment.initialLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
color_attachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
vulkan_swapchain_render_pass = prj::shared_ptr<Vulkan::RenderPass>(
new Vulkan::RenderPass(Vulkan::current_device, 0,
1, &color_attachment, 1, &subpass_description, 1, &subpass_dependency));
vulkan_swapchain_framebuffers.resize(image_count);
for (uint32_t i = 0; i < image_count; i++) {
VkImageView image_view = vulkan_swapchain_image_views[i];
vulkan_swapchain_framebuffers[i].Create(vulkan_device, 0,
*vulkan_swapchain_render_pass.get(), 1, &image_view, extent.width, extent.height);
}
return 0;
}
static std::pair<uint32_t, uint32_t> app_find_queue_families(VkPhysicalDevice vulkan_device) {
uint32_t queue_family_count = 0;
vkGetPhysicalDeviceQueueFamilyProperties(vulkan_device, &queue_family_count, 0);
std::vector<VkQueueFamilyProperties> queue_families;
queue_families.resize(queue_family_count);
vkGetPhysicalDeviceQueueFamilyProperties(vulkan_device, &queue_family_count, queue_families.data());
int32_t j = 0;
std::pair<uint32_t, uint32_t> indices = { -1, -1 };
for (const VkQueueFamilyProperties& i : queue_families) {
if (i.queueFlags & VK_QUEUE_GRAPHICS_BIT)
indices.first = j;
VkBool32 present_support = false;
vkGetPhysicalDeviceSurfaceSupportKHR(vulkan_device, j, vulkan_surface, &present_support);
if (present_support)
indices.second = j;
if (indices.first != -1 && indices.second != -1)
return indices;
j++;
}
return { -1, -1 };
}
static bool app_check_is_device_suitable(VkPhysicalDevice vulkan_device) {
std::pair<uint32_t, uint32_t> indices = app_find_queue_families(vulkan_device);
bool extensions_supported = app_check_device_extension_support(vulkan_device);
bool swapchain_adequate = false;
if (extensions_supported) {
vulkan_swapchain_support_details swapchain_support = app_query_swapchain_support(vulkan_device);
swapchain_adequate = swapchain_support.formats.size() && swapchain_support.present_modes.size();
}
VkPhysicalDeviceFeatures device_features;
vkGetPhysicalDeviceFeatures(vulkan_device, &device_features);
return indices.first != -1 && indices.second != -1 && extensions_supported
&& swapchain_adequate && device_features.samplerAnisotropy;
}
static std::vector<const char*> app_get_required_extensions() {
uint32_t glfw_extension_count = 0;
const char** glfw_extensions = glfwGetRequiredInstanceExtensions(&glfw_extension_count);
std::vector<const char*> extensions(glfw_extensions, glfw_extensions + glfw_extension_count);
extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
return extensions;
}
static bool app_check_device_extension_support(VkPhysicalDevice vulkan_device) {
uint32_t extension_count = 0;
vkEnumerateDeviceExtensionProperties(vulkan_device, 0, &extension_count, 0);
std::vector<VkExtensionProperties> available_extensions;
available_extensions.resize(extension_count);
vkEnumerateDeviceExtensionProperties(vulkan_device, 0, &extension_count, available_extensions.data());
for (const char* i : vulkan_device_extensions) {
bool found = false;
for (const VkExtensionProperties& j : available_extensions)
if (!strcmp(i, j.extensionName)) {
found = true;
break;
}
if (!found)
return false;
}
return true;
}
#if RENDER_DEBUG
static bool app_check_validation_layer_support() {
uint32_t layer_count;
vkEnumerateInstanceLayerProperties(&layer_count, 0);
std::vector<VkLayerProperties> available_layers;
available_layers.resize(layer_count);
vkEnumerateInstanceLayerProperties(&layer_count, available_layers.data());
for (const char* i : vulkan_validation_layers) {
bool found = false;
for (const VkLayerProperties& j : available_layers)
if (!strcmp(i, j.layerName)) {
found = true;
break;
}
if (!found)
return false;
}
return true;
}
#endif
#if RENDER_DEBUG
static VKAPI_ATTR VkBool32 VKAPI_CALL app_debug_callback(
VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageType,
const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, void* pUserData) {
if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) {
HANDLE console = GetStdHandle(STD_OUTPUT_HANDLE);
CONSOLE_SCREEN_BUFFER_INFO csbi;
GetConsoleScreenBufferInfo(console, &csbi);
SetConsoleTextAttribute(console, FOREGROUND_INTENSITY | FOREGROUND_RED
| FOREGROUND_GREEN | FOREGROUND_BLUE | BACKGROUND_RED);
printf_debug("validation layer error: %s\n\n", pCallbackData->pMessage);
SetConsoleTextAttribute(console, csbi.wAttributes);
}
else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) {
HANDLE console = GetStdHandle(STD_OUTPUT_HANDLE);
CONSOLE_SCREEN_BUFFER_INFO csbi;
GetConsoleScreenBufferInfo(console, &csbi);
SetConsoleTextAttribute(console, FOREGROUND_RED
| BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE);
printf_debug("validation layer warn: %s\n\n", pCallbackData->pMessage);
SetConsoleTextAttribute(console, csbi.wAttributes);
}
else if (messageType & VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT) {
HANDLE console = GetStdHandle(STD_OUTPUT_HANDLE);
CONSOLE_SCREEN_BUFFER_INFO csbi;
GetConsoleScreenBufferInfo(console, &csbi);
SetConsoleTextAttribute(console, FOREGROUND_INTENSITY | FOREGROUND_RED
| FOREGROUND_GREEN | FOREGROUND_BLUE | BACKGROUND_RED | BACKGROUND_GREEN);
printf_debug("validation layer perf: %s\n", pCallbackData->pMessage);
SetConsoleTextAttribute(console, csbi.wAttributes);
}
else
printf_debug("validation layer msg: %s\n", pCallbackData->pMessage);
return VK_FALSE;
}
#endif
static VkSurfaceFormatKHR app_choose_swap_surface_format(
const std::vector<VkSurfaceFormatKHR>& available_formats) {
for (const VkSurfaceFormatKHR& i : available_formats)
if (i.format == VK_FORMAT_B8G8R8A8_UNORM
&& i.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR)
return i;
return available_formats[0];
}
static VkPresentModeKHR app_choose_swap_present_mode(
const std::vector<VkPresentModeKHR>& available_present_modes) {
for (const VkPresentModeKHR& i : available_present_modes) // It'll uncap framerates
if (i == VK_PRESENT_MODE_MAILBOX_KHR)
return i;
return VK_PRESENT_MODE_FIFO_KHR;
}
static VkExtent2D app_choose_swap_extent(const VkSurfaceCapabilitiesKHR& capabilities) {
if (capabilities.currentExtent.width != UINT32_MAX)
return capabilities.currentExtent;
int32_t width, height;
glfwGetFramebufferSize(window, &width, &height);
VkExtent2D actual_extent{ (uint32_t)width, (uint32_t)height, };
actual_extent.width = clamp_def(actual_extent.width,
capabilities.minImageExtent.width, capabilities.maxImageExtent.width);
actual_extent.height = clamp_def(actual_extent.height,
capabilities.minImageExtent.height, capabilities.maxImageExtent.height);
return actual_extent;
}
static vulkan_swapchain_support_details app_query_swapchain_support(VkPhysicalDevice vulkan_device) {
vulkan_swapchain_support_details details;
vkGetPhysicalDeviceSurfaceCapabilitiesKHR(vulkan_device, vulkan_surface, &details.capabilities);
uint32_t format_count;
vkGetPhysicalDeviceSurfaceFormatsKHR(vulkan_device, vulkan_surface, &format_count, 0);
if (format_count) {
details.formats.resize(format_count);
vkGetPhysicalDeviceSurfaceFormatsKHR(vulkan_device, vulkan_surface, &format_count, details.formats.data());
}
uint32_t present_mode_count;
vkGetPhysicalDeviceSurfacePresentModesKHR(vulkan_device, vulkan_surface, &present_mode_count, 0);
if (present_mode_count) {
details.present_modes.resize(present_mode_count);
vkGetPhysicalDeviceSurfacePresentModesKHR(vulkan_device, vulkan_surface,
&present_mode_count, details.present_modes.data());
}
return details;
}
#if RENDER_DEBUG
static VkResult app_vkCreateDebugUtilsMessengerEXT(VkInstance instance,
const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pDebugMessenger) {
if (vkCreateDebugUtilsMessengerEXT)
return vkCreateDebugUtilsMessengerEXT(instance, pCreateInfo, pAllocator, pDebugMessenger);
return VK_ERROR_EXTENSION_NOT_PRESENT;
}
static void app_vkDestroyDebugUtilsMessengerEXT(VkInstance instance,
VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator) {
if (vkDestroyDebugUtilsMessengerEXT)
vkDestroyDebugUtilsMessengerEXT(instance, messenger, pAllocator);
}
#endif
Reference in New Issue View Git Blame Copy Permalink