1577 lines
71 KiB
C++
1577 lines
71 KiB
C++
#include <render.hpp>
|
|
#include <camera.hpp>
|
|
|
|
#define GLFW_INCLUDE_VULKAN
|
|
#include <GLFW/glfw3.h>
|
|
|
|
#include <algorithm>
|
|
#include <array>
|
|
#include <cmath>
|
|
#include <cstdint>
|
|
#include <cstdio>
|
|
#include <cstring>
|
|
#include <fstream>
|
|
#include <png.h>
|
|
#include <stdexcept>
|
|
#include <unordered_map>
|
|
#include <vector>
|
|
|
|
namespace boundard::render {
|
|
namespace {
|
|
|
|
|
|
constexpr std::array<uint32_t, 377> kQuadVertShader = {
|
|
0x07230203,0x00010000,0x000d000b,0x0000002e,0x00000000,0x00020011,0x00000001,0x0006000b,0x00000001,0x4c534c47,0x6474732e,0x3035342e,
|
|
0x00000000,0x0003000e,0x00000000,0x00000001,0x0009000f,0x00000000,0x00000004,0x6e69616d,0x00000000,0x0000000d,0x00000019,0x00000023,
|
|
0x00000025,0x00030003,0x00000002,0x000001c2,0x000a0004,0x475f4c47,0x4c474f4f,0x70635f45,0x74735f70,0x5f656c79,0x656e696c,0x7269645f,
|
|
0x69746365,0x00006576,0x00080004,0x475f4c47,0x4c474f4f,0x6e695f45,0x64756c63,0x69645f65,0x74636572,0x00657669,0x00040005,0x00000004,
|
|
0x6e69616d,0x00000000,0x00060005,0x0000000b,0x505f6c67,0x65567265,0x78657472,0x00000000,0x00060006,0x0000000b,0x00000000,0x505f6c67,
|
|
0x7469736f,0x006e6f69,0x00070006,0x0000000b,0x00000001,0x505f6c67,0x746e696f,0x657a6953,0x00000000,0x00070006,0x0000000b,0x00000002,
|
|
0x435f6c67,0x4470696c,0x61747369,0x0065636e,0x00070006,0x0000000b,0x00000003,0x435f6c67,0x446c6c75,0x61747369,0x0065636e,0x00030005,
|
|
0x0000000d,0x00000000,0x00030005,0x00000011,0x004f4255,0x00050006,0x00000011,0x00000000,0x65646f6d,0x0000006c,0x00030005,0x00000013,
|
|
0x006f6275,0x00040005,0x00000019,0x736f5061,0x00000000,0x00040005,0x00000023,0x6c6f4376,0x0000726f,0x00040005,0x00000025,0x6c6f4361,
|
|
0x0000726f,0x00030005,0x00000027,0x00004350,0x00050006,0x00000027,0x00000000,0x6f6c6f63,0x00000072,0x00030005,0x00000029,0x00006370,
|
|
0x00030047,0x0000000b,0x00000002,0x00050048,0x0000000b,0x00000000,0x0000000b,0x00000000,0x00050048,0x0000000b,0x00000001,0x0000000b,
|
|
0x00000001,0x00050048,0x0000000b,0x00000002,0x0000000b,0x00000003,0x00050048,0x0000000b,0x00000003,0x0000000b,0x00000004,0x00030047,
|
|
0x00000011,0x00000002,0x00040048,0x00000011,0x00000000,0x00000005,0x00050048,0x00000011,0x00000000,0x00000007,0x00000010,0x00050048,
|
|
0x00000011,0x00000000,0x00000023,0x00000000,0x00040047,0x00000013,0x00000021,0x00000000,0x00040047,0x00000013,0x00000022,0x00000000,
|
|
0x00040047,0x00000019,0x0000001e,0x00000000,0x00040047,0x00000023,0x0000001e,0x00000000,0x00040047,0x00000025,0x0000001e,0x00000001,
|
|
0x00030047,0x00000027,0x00000002,0x00050048,0x00000027,0x00000000,0x00000023,0x00000000,0x00020013,0x00000002,0x00030021,0x00000003,
|
|
0x00000002,0x00030016,0x00000006,0x00000020,0x00040017,0x00000007,0x00000006,0x00000004,0x00040015,0x00000008,0x00000020,0x00000000,
|
|
0x0004002b,0x00000008,0x00000009,0x00000001,0x0004001c,0x0000000a,0x00000006,0x00000009,0x0006001e,0x0000000b,0x00000007,0x00000006,
|
|
0x0000000a,0x0000000a,0x00040020,0x0000000c,0x00000003,0x0000000b,0x0004003b,0x0000000c,0x0000000d,0x00000003,0x00040015,0x0000000e,
|
|
0x00000020,0x00000001,0x0004002b,0x0000000e,0x0000000f,0x00000000,0x00040018,0x00000010,0x00000007,0x00000004,0x0003001e,0x00000011,
|
|
0x00000010,0x00040020,0x00000012,0x00000002,0x00000011,0x0004003b,0x00000012,0x00000013,0x00000002,0x00040020,0x00000014,0x00000002,
|
|
0x00000010,0x00040017,0x00000017,0x00000006,0x00000002,0x00040020,0x00000018,0x00000001,0x00000017,0x0004003b,0x00000018,0x00000019,
|
|
0x00000001,0x0004002b,0x00000006,0x0000001b,0x00000000,0x0004002b,0x00000006,0x0000001c,0x3f800000,0x00040020,0x00000021,0x00000003,
|
|
0x00000007,0x0004003b,0x00000021,0x00000023,0x00000003,0x00040020,0x00000024,0x00000001,0x00000007,0x0004003b,0x00000024,0x00000025,
|
|
0x00000001,0x0003001e,0x00000027,0x00000007,0x00040020,0x00000028,0x00000009,0x00000027,0x0004003b,0x00000028,0x00000029,0x00000009,
|
|
0x00040020,0x0000002a,0x00000009,0x00000007,0x00050036,0x00000002,0x00000004,0x00000000,0x00000003,0x000200f8,0x00000005,0x00050041,
|
|
0x00000014,0x00000015,0x00000013,0x0000000f,0x0004003d,0x00000010,0x00000016,0x00000015,0x0004003d,0x00000017,0x0000001a,0x00000019,
|
|
0x00050051,0x00000006,0x0000001d,0x0000001a,0x00000000,0x00050051,0x00000006,0x0000001e,0x0000001a,0x00000001,0x00070050,0x00000007,
|
|
0x0000001f,0x0000001d,0x0000001e,0x0000001b,0x0000001c,0x00050091,0x00000007,0x00000020,0x00000016,0x0000001f,0x00050041,0x00000021,
|
|
0x00000022,0x0000000d,0x0000000f,0x0003003e,0x00000022,0x00000020,0x0004003d,0x00000007,0x00000026,0x00000025,0x00050041,0x0000002a,
|
|
0x0000002b,0x00000029,0x0000000f,0x0004003d,0x00000007,0x0000002c,0x0000002b,0x00050085,0x00000007,0x0000002d,0x00000026,0x0000002c,
|
|
0x0003003e,0x00000023,0x0000002d,0x000100fd,0x00010038,
|
|
};
|
|
|
|
constexpr std::array<uint32_t, 112> kQuadFragShader = {
|
|
0x07230203,0x00010000,0x000d000b,0x0000000d,0x00000000,0x00020011,0x00000001,0x0006000b,0x00000001,0x4c534c47,0x6474732e,0x3035342e,
|
|
0x00000000,0x0003000e,0x00000000,0x00000001,0x0007000f,0x00000004,0x00000004,0x6e69616d,0x00000000,0x00000009,0x0000000b,0x00030010,
|
|
0x00000004,0x00000007,0x00030003,0x00000002,0x000001c2,0x000a0004,0x475f4c47,0x4c474f4f,0x70635f45,0x74735f70,0x5f656c79,0x656e696c,
|
|
0x7269645f,0x69746365,0x00006576,0x00080004,0x475f4c47,0x4c474f4f,0x6e695f45,0x64756c63,0x69645f65,0x74636572,0x00657669,0x00040005,
|
|
0x00000004,0x6e69616d,0x00000000,0x00050005,0x00000009,0x4374756f,0x726f6c6f,0x00000000,0x00040005,0x0000000b,0x6c6f4376,0x0000726f,
|
|
0x00040047,0x00000009,0x0000001e,0x00000000,0x00040047,0x0000000b,0x0000001e,0x00000000,0x00020013,0x00000002,0x00030021,0x00000003,
|
|
0x00000002,0x00030016,0x00000006,0x00000020,0x00040017,0x00000007,0x00000006,0x00000004,0x00040020,0x00000008,0x00000003,0x00000007,
|
|
0x0004003b,0x00000008,0x00000009,0x00000003,0x00040020,0x0000000a,0x00000001,0x00000007,0x0004003b,0x0000000a,0x0000000b,0x00000001,
|
|
0x00050036,0x00000002,0x00000004,0x00000000,0x00000003,0x000200f8,0x00000005,0x0004003d,0x00000007,0x0000000c,0x0000000b,0x0003003e,
|
|
0x00000009,0x0000000c,0x000100fd,0x00010038,
|
|
};
|
|
|
|
struct FrameData {
|
|
VkFence in_flight = VK_NULL_HANDLE;
|
|
VkSemaphore image_available = VK_NULL_HANDLE;
|
|
VkSemaphore render_finished = VK_NULL_HANDLE;
|
|
VkCommandBuffer command_buffer = VK_NULL_HANDLE;
|
|
};
|
|
|
|
void check(VkResult result, const char* what) {
|
|
if (result != VK_SUCCESS) {
|
|
throw std::runtime_error(what);
|
|
}
|
|
}
|
|
|
|
#ifdef VK_EXT_debug_utils
|
|
VKAPI_ATTR VkBool32 VKAPI_CALL debug_callback(
|
|
VkDebugUtilsMessageSeverityFlagBitsEXT severity, VkDebugUtilsMessageTypeFlagsEXT type,
|
|
const VkDebugUtilsMessengerCallbackDataEXT* callback_data, void*) {
|
|
if (severity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) {
|
|
std::fprintf(stderr, "VK ERROR: %s\n", callback_data->pMessage);
|
|
}
|
|
return VK_FALSE;
|
|
}
|
|
#endif
|
|
|
|
uint32_t find_memory_type(VkPhysicalDevice physical_device, uint32_t type_filter,
|
|
VkMemoryPropertyFlags properties) {
|
|
VkPhysicalDeviceMemoryProperties memory_properties{};
|
|
vkGetPhysicalDeviceMemoryProperties(physical_device, &memory_properties);
|
|
for (uint32_t i = 0; i < memory_properties.memoryTypeCount; ++i) {
|
|
if ((type_filter & (1u << i)) &&
|
|
(memory_properties.memoryTypes[i].propertyFlags & properties) == properties) {
|
|
return i;
|
|
}
|
|
}
|
|
throw std::runtime_error("failed to find suitable Vulkan memory type");
|
|
}
|
|
|
|
void create_buffer(VkPhysicalDevice physical_device, VkDevice device, VkDeviceSize size,
|
|
VkBufferUsageFlags usage, VkMemoryPropertyFlags properties, VkBuffer& buffer,
|
|
VkDeviceMemory& memory) {
|
|
VkBufferCreateInfo buffer_info{};
|
|
buffer_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
|
|
buffer_info.size = size;
|
|
buffer_info.usage = usage;
|
|
buffer_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
|
check(vkCreateBuffer(device, &buffer_info, nullptr, &buffer), "vkCreateBuffer");
|
|
|
|
VkMemoryRequirements requirements{};
|
|
vkGetBufferMemoryRequirements(device, buffer, &requirements);
|
|
|
|
VkMemoryAllocateInfo alloc_info{};
|
|
alloc_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
|
|
alloc_info.allocationSize = requirements.size;
|
|
alloc_info.memoryTypeIndex =
|
|
find_memory_type(physical_device, requirements.memoryTypeBits, properties);
|
|
check(vkAllocateMemory(device, &alloc_info, nullptr, &memory), "vkAllocateMemory");
|
|
check(vkBindBufferMemory(device, buffer, memory, 0), "vkBindBufferMemory");
|
|
}
|
|
|
|
VkShaderModule create_shader_module(VkDevice device, const uint32_t* code, size_t size) {
|
|
VkShaderModuleCreateInfo create_info{};
|
|
create_info.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
|
|
create_info.codeSize = size;
|
|
create_info.pCode = code;
|
|
VkShaderModule module = VK_NULL_HANDLE;
|
|
check(vkCreateShaderModule(device, &create_info, nullptr, &module), "vkCreateShaderModule");
|
|
return module;
|
|
}
|
|
|
|
std::vector<uint32_t> load_shader(const char* name) {
|
|
const std::string path = std::string(BOUNDARD_SHADER_DIR) + "/" + name;
|
|
std::ifstream file(path, std::ios::binary | std::ios::ate);
|
|
if (!file.is_open()) {
|
|
throw std::runtime_error("failed to open shader: " + path);
|
|
}
|
|
const std::streamsize size = file.tellg();
|
|
if (size <= 0 || size % static_cast<std::streamsize>(sizeof(uint32_t)) != 0) {
|
|
throw std::runtime_error("invalid SPIR-V shader: " + path);
|
|
}
|
|
std::vector<uint32_t> code(static_cast<size_t>(size) / sizeof(uint32_t));
|
|
file.seekg(0);
|
|
file.read(reinterpret_cast<char*>(code.data()), size);
|
|
if (!file) {
|
|
throw std::runtime_error("failed to read shader: " + path);
|
|
}
|
|
return code;
|
|
}
|
|
|
|
bool load_png_rgba(const std::string& path, uint32_t& width, uint32_t& height,
|
|
std::vector<unsigned char>& pixels) {
|
|
png_image image{};
|
|
image.version = PNG_IMAGE_VERSION;
|
|
if (!png_image_begin_read_from_file(&image, path.c_str())) {
|
|
return false;
|
|
}
|
|
image.format = PNG_FORMAT_RGBA;
|
|
width = image.width;
|
|
height = image.height;
|
|
pixels.resize(PNG_IMAGE_SIZE(image));
|
|
const bool loaded = png_image_finish_read(&image, nullptr, pixels.data(), 0, nullptr) != 0;
|
|
png_image_free(&image);
|
|
return loaded;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
struct Renderer::Impl {
|
|
GLFWwindow* window = nullptr;
|
|
VkInstance instance = VK_NULL_HANDLE;
|
|
VkDebugUtilsMessengerEXT debug_messenger = VK_NULL_HANDLE;
|
|
VkSurfaceKHR surface = VK_NULL_HANDLE;
|
|
VkPhysicalDevice physical_device = VK_NULL_HANDLE;
|
|
VkDevice device = VK_NULL_HANDLE;
|
|
VkQueue graphics_queue = VK_NULL_HANDLE;
|
|
VkQueue present_queue = VK_NULL_HANDLE;
|
|
uint32_t graphics_family = 0;
|
|
uint32_t present_family = 0;
|
|
|
|
VkSwapchainKHR swapchain = VK_NULL_HANDLE;
|
|
VkFormat swapchain_format = VK_FORMAT_UNDEFINED;
|
|
VkExtent2D swapchain_extent{};
|
|
std::vector<VkImage> swapchain_images;
|
|
std::vector<VkImageView> swapchain_image_views;
|
|
std::vector<VkFramebuffer> framebuffers;
|
|
|
|
VkRenderPass render_pass = VK_NULL_HANDLE;
|
|
VkDescriptorSetLayout descriptor_set_layout = VK_NULL_HANDLE;
|
|
VkDescriptorPool descriptor_pool = VK_NULL_HANDLE;
|
|
VkPipelineLayout pipeline_layout = VK_NULL_HANDLE;
|
|
VkPipeline pipeline = VK_NULL_HANDLE;
|
|
std::atomic<bool> framebuffer_resized{false};
|
|
|
|
VkCommandPool command_pool = VK_NULL_HANDLE;
|
|
std::vector<FrameData> frames;
|
|
std::vector<VkFence> images_in_flight;
|
|
|
|
struct MeshResource {
|
|
VkBuffer vertex_buffer = VK_NULL_HANDLE;
|
|
VkDeviceMemory vertex_buffer_memory = VK_NULL_HANDLE;
|
|
VkBuffer index_buffer = VK_NULL_HANDLE;
|
|
VkDeviceMemory index_buffer_memory = VK_NULL_HANDLE;
|
|
uint32_t index_count = 0;
|
|
VkImage image = VK_NULL_HANDLE;
|
|
VkDeviceMemory image_memory = VK_NULL_HANDLE;
|
|
VkImageView image_view = VK_NULL_HANDLE;
|
|
VkSampler sampler = VK_NULL_HANDLE;
|
|
VkDescriptorSet descriptor_set = VK_NULL_HANDLE;
|
|
};
|
|
std::unordered_map<const Mesh*, MeshResource> mesh_resources;
|
|
|
|
size_t current_frame = 0;
|
|
bool initialized = false;
|
|
Renderer::InputCallback input_callback;
|
|
|
|
void init(int width, int height, const char* title);
|
|
void draw(const Actor* const* actors, size_t actor_count, const Camera* camera);
|
|
void upload_mesh(const Mesh& mesh);
|
|
void create_texture(MeshResource& resource, const std::string& path);
|
|
VkCommandBuffer begin_transfer();
|
|
void end_transfer(VkCommandBuffer command_buffer);
|
|
void recreate_swapchain();
|
|
void destroy();
|
|
};
|
|
|
|
Renderer::Renderer() : impl_(new Impl()) {}
|
|
Renderer::~Renderer() {
|
|
destroy();
|
|
delete impl_;
|
|
}
|
|
|
|
void Renderer::init(int width, int height, const char* title) {
|
|
impl_->init(width, height, title);
|
|
}
|
|
|
|
void Renderer::draw(const Actor* const* actors, size_t actor_count) {
|
|
impl_->draw(actors, actor_count, nullptr);
|
|
}
|
|
|
|
void Renderer::draw(const Actor* const* actors, size_t actor_count, const Camera* camera) {
|
|
impl_->draw(actors, actor_count, camera);
|
|
}
|
|
|
|
bool Renderer::should_close() const {
|
|
return impl_->window != nullptr && glfwWindowShouldClose(impl_->window);
|
|
}
|
|
|
|
void Renderer::poll_events() const {
|
|
glfwPollEvents();
|
|
}
|
|
|
|
void Renderer::set_input_callback(InputCallback callback) {
|
|
impl_->input_callback = std::move(callback);
|
|
}
|
|
|
|
bool Renderer::is_key_down(int key) const {
|
|
return impl_->window != nullptr && glfwGetKey(impl_->window, key) == GLFW_PRESS;
|
|
}
|
|
|
|
bool Renderer::is_mouse_button_down(int button) const {
|
|
return impl_->window != nullptr && glfwGetMouseButton(impl_->window, button) == GLFW_PRESS;
|
|
}
|
|
|
|
std::array<double, 2> Renderer::cursor_position() const {
|
|
if (impl_->window == nullptr) {
|
|
return {0.0, 0.0};
|
|
}
|
|
double x = 0.0;
|
|
double y = 0.0;
|
|
glfwGetCursorPos(impl_->window, &x, &y);
|
|
return {x, y};
|
|
}
|
|
|
|
void Renderer::destroy() {
|
|
impl_->destroy();
|
|
}
|
|
|
|
#if 0 // InputMap implementation moved to input.cpp.
|
|
void InputMap::add_action(const std::string& action) {
|
|
std::lock_guard<std::mutex> lock(mutex_);
|
|
actions_.try_emplace(action);
|
|
}
|
|
|
|
void InputMap::bind_key(const std::string& action, int key) {
|
|
std::lock_guard<std::mutex> lock(mutex_);
|
|
ActionState& state = actions_[action];
|
|
state.keys.insert(key);
|
|
state.held_keys.try_emplace(key, false);
|
|
}
|
|
|
|
void InputMap::unbind_key(const std::string& action, int key) {
|
|
std::lock_guard<std::mutex> lock(mutex_);
|
|
auto action_it = actions_.find(action);
|
|
if (action_it == actions_.end()) {
|
|
return;
|
|
}
|
|
ActionState& state = action_it->second;
|
|
state.keys.erase(key);
|
|
auto held_it = state.held_keys.find(key);
|
|
if (held_it != state.held_keys.end() && held_it->second) {
|
|
held_it->second = false;
|
|
if (state.held_key_count > 0) {
|
|
--state.held_key_count;
|
|
}
|
|
if (state.held_key_count + state.held_button_count == 0) {
|
|
state.pressed = false;
|
|
state.just_released = true;
|
|
}
|
|
}
|
|
state.held_keys.erase(key);
|
|
}
|
|
|
|
void InputMap::bind_mouse_button(const std::string& action, int button) {
|
|
std::lock_guard<std::mutex> lock(mutex_);
|
|
ActionState& state = actions_[action];
|
|
state.mouse_buttons.insert(button);
|
|
state.held_buttons.try_emplace(button, false);
|
|
}
|
|
|
|
void InputMap::unbind_mouse_button(const std::string& action, int button) {
|
|
std::lock_guard<std::mutex> lock(mutex_);
|
|
auto action_it = actions_.find(action);
|
|
if (action_it == actions_.end()) {
|
|
return;
|
|
}
|
|
ActionState& state = action_it->second;
|
|
state.mouse_buttons.erase(button);
|
|
auto held_it = state.held_buttons.find(button);
|
|
if (held_it != state.held_buttons.end() && held_it->second) {
|
|
held_it->second = false;
|
|
if (state.held_button_count > 0) {
|
|
--state.held_button_count;
|
|
}
|
|
if (state.held_key_count + state.held_button_count == 0) {
|
|
state.pressed = false;
|
|
state.just_released = true;
|
|
}
|
|
}
|
|
state.held_buttons.erase(button);
|
|
}
|
|
|
|
void InputMap::handle_event(const InputEvent& event) {
|
|
std::lock_guard<std::mutex> lock(mutex_);
|
|
|
|
for (auto& [action, state] : actions_) {
|
|
std::unordered_set<int>* bindings = nullptr;
|
|
std::unordered_map<int, bool>* held_map = nullptr;
|
|
size_t* held_count = nullptr;
|
|
|
|
if (event.type == InputEvent::Type::Key) {
|
|
bindings = &state.keys;
|
|
held_map = &state.held_keys;
|
|
held_count = &state.held_key_count;
|
|
} else if (event.type == InputEvent::Type::MouseButton) {
|
|
bindings = &state.mouse_buttons;
|
|
held_map = &state.held_buttons;
|
|
held_count = &state.held_button_count;
|
|
} else {
|
|
continue;
|
|
}
|
|
|
|
const int input_id = event.type == InputEvent::Type::Key ? event.key : event.button;
|
|
if (bindings->find(input_id) == bindings->end()) {
|
|
continue;
|
|
}
|
|
|
|
if (event.action == InputEvent::Action::Press) {
|
|
bool& held = (*held_map)[input_id];
|
|
if (!held) {
|
|
held = true;
|
|
++(*held_count);
|
|
if (state.held_key_count + state.held_button_count == 1) {
|
|
state.pressed = true;
|
|
state.just_pressed = true;
|
|
}
|
|
}
|
|
} else if (event.action == InputEvent::Action::Release) {
|
|
auto held_it = held_map->find(input_id);
|
|
if (held_it == held_map->end() || !held_it->second) {
|
|
continue;
|
|
}
|
|
held_it->second = false;
|
|
if (*held_count > 0) {
|
|
--(*held_count);
|
|
}
|
|
if (state.held_key_count + state.held_button_count == 0) {
|
|
state.pressed = false;
|
|
state.just_released = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void InputMap::end_frame() {
|
|
std::lock_guard<std::mutex> lock(mutex_);
|
|
for (auto& [action, state] : actions_) {
|
|
state.just_pressed = false;
|
|
state.just_released = false;
|
|
}
|
|
}
|
|
|
|
bool InputMap::is_action_pressed(const std::string& action) const {
|
|
std::lock_guard<std::mutex> lock(mutex_);
|
|
auto it = actions_.find(action);
|
|
return it != actions_.end() && it->second.pressed;
|
|
}
|
|
|
|
bool InputMap::is_action_just_pressed(const std::string& action) const {
|
|
std::lock_guard<std::mutex> lock(mutex_);
|
|
auto it = actions_.find(action);
|
|
return it != actions_.end() && it->second.just_pressed;
|
|
}
|
|
|
|
bool InputMap::is_action_just_released(const std::string& action) const {
|
|
std::lock_guard<std::mutex> lock(mutex_);
|
|
auto it = actions_.find(action);
|
|
return it != actions_.end() && it->second.just_released;
|
|
}
|
|
|
|
float InputMap::get_action_strength(const std::string& action) const {
|
|
std::lock_guard<std::mutex> lock(mutex_);
|
|
auto it = actions_.find(action);
|
|
return it != actions_.end() && it->second.pressed ? 1.0F : 0.0F;
|
|
}
|
|
|
|
float InputMap::get_axis(const std::string& negative_action,
|
|
const std::string& positive_action) const {
|
|
return get_action_strength(positive_action) - get_action_strength(negative_action);
|
|
}
|
|
#endif
|
|
|
|
void Renderer::Impl::init(int width, int height, const char* title) {
|
|
if (initialized) {
|
|
return;
|
|
}
|
|
|
|
if (!glfwInit()) {
|
|
throw std::runtime_error("failed to initialize GLFW");
|
|
}
|
|
glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
|
|
glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE);
|
|
window = glfwCreateWindow(width, height, title, nullptr, nullptr);
|
|
if (window == nullptr) {
|
|
throw std::runtime_error("failed to create GLFW window");
|
|
}
|
|
glfwSetWindowUserPointer(window, this);
|
|
glfwSetFramebufferSizeCallback(window, [](GLFWwindow* target, int, int) {
|
|
auto* impl = static_cast<Renderer::Impl*>(glfwGetWindowUserPointer(target));
|
|
if (impl != nullptr) impl->framebuffer_resized = true;
|
|
});
|
|
glfwSetKeyCallback(window, [](GLFWwindow* target, int key, int scancode, int action,
|
|
int mods) {
|
|
auto* impl = static_cast<Renderer::Impl*>(glfwGetWindowUserPointer(target));
|
|
if (impl == nullptr || !impl->input_callback) {
|
|
return;
|
|
}
|
|
InputEvent event;
|
|
event.type = InputEvent::Type::Key;
|
|
event.action = static_cast<InputEvent::Action>(action);
|
|
event.key = key;
|
|
event.scancode = scancode;
|
|
event.mods = mods;
|
|
impl->input_callback(event);
|
|
});
|
|
glfwSetMouseButtonCallback(window, [](GLFWwindow* target, int button, int action,
|
|
int mods) {
|
|
auto* impl = static_cast<Renderer::Impl*>(glfwGetWindowUserPointer(target));
|
|
if (impl == nullptr || !impl->input_callback) {
|
|
return;
|
|
}
|
|
InputEvent event;
|
|
event.type = InputEvent::Type::MouseButton;
|
|
event.action = static_cast<InputEvent::Action>(action);
|
|
event.button = button;
|
|
event.mods = mods;
|
|
impl->input_callback(event);
|
|
});
|
|
glfwSetCursorPosCallback(window, [](GLFWwindow* target, double x, double y) {
|
|
auto* impl = static_cast<Renderer::Impl*>(glfwGetWindowUserPointer(target));
|
|
if (impl == nullptr || !impl->input_callback) {
|
|
return;
|
|
}
|
|
InputEvent event;
|
|
event.type = InputEvent::Type::CursorMove;
|
|
event.x = x;
|
|
event.y = y;
|
|
impl->input_callback(event);
|
|
});
|
|
glfwSetScrollCallback(window, [](GLFWwindow* target, double x, double y) {
|
|
auto* impl = static_cast<Renderer::Impl*>(glfwGetWindowUserPointer(target));
|
|
if (impl == nullptr || !impl->input_callback) {
|
|
return;
|
|
}
|
|
InputEvent event;
|
|
event.type = InputEvent::Type::Scroll;
|
|
event.x = x;
|
|
event.y = y;
|
|
impl->input_callback(event);
|
|
});
|
|
|
|
// 让窗口管理器完成首次表面配置，避免交换链尺寸在首帧后才变化。
|
|
glfwPollEvents();
|
|
|
|
uint32_t glfw_extension_count = 0;
|
|
const char** glfw_extensions = glfwGetRequiredInstanceExtensions(&glfw_extension_count);
|
|
std::vector<const char*> instance_extensions(glfw_extensions,
|
|
glfw_extensions + glfw_extension_count);
|
|
instance_extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
|
|
|
|
const char* validation_layer = "VK_LAYER_KHRONOS_validation";
|
|
bool use_validation = false;
|
|
uint32_t layer_count = 0;
|
|
vkEnumerateInstanceLayerProperties(&layer_count, nullptr);
|
|
std::vector<VkLayerProperties> available_layers(layer_count);
|
|
vkEnumerateInstanceLayerProperties(&layer_count, available_layers.data());
|
|
for (const auto& layer : available_layers) {
|
|
if (std::strcmp(layer.layerName, validation_layer) == 0) {
|
|
use_validation = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
VkApplicationInfo app_info{};
|
|
app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
|
|
app_info.pApplicationName = title;
|
|
app_info.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
|
|
app_info.pEngineName = "OpenCGE";
|
|
app_info.engineVersion = VK_MAKE_VERSION(1, 0, 0);
|
|
app_info.apiVersion = VK_API_VERSION_1_0;
|
|
|
|
VkInstanceCreateInfo instance_info{};
|
|
instance_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
|
|
instance_info.pApplicationInfo = &app_info;
|
|
instance_info.enabledExtensionCount = static_cast<uint32_t>(instance_extensions.size());
|
|
instance_info.ppEnabledExtensionNames = instance_extensions.data();
|
|
if (use_validation) {
|
|
instance_info.enabledLayerCount = 1;
|
|
instance_info.ppEnabledLayerNames = &validation_layer;
|
|
}
|
|
check(vkCreateInstance(&instance_info, nullptr, &instance), "vkCreateInstance");
|
|
|
|
if (use_validation) {
|
|
auto create_messenger = reinterpret_cast<PFN_vkCreateDebugUtilsMessengerEXT>(
|
|
vkGetInstanceProcAddr(instance, "vkCreateDebugUtilsMessengerEXT"));
|
|
if (create_messenger != nullptr) {
|
|
VkDebugUtilsMessengerCreateInfoEXT messenger_info{};
|
|
messenger_info.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
|
|
messenger_info.messageSeverity =
|
|
VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT |
|
|
VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT |
|
|
VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT |
|
|
VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
|
|
messenger_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;
|
|
messenger_info.pfnUserCallback = debug_callback;
|
|
create_messenger(instance, &messenger_info, nullptr, &debug_messenger);
|
|
}
|
|
}
|
|
|
|
check(glfwCreateWindowSurface(instance, window, nullptr, &surface), "glfwCreateWindowSurface");
|
|
|
|
uint32_t physical_device_count = 0;
|
|
check(vkEnumeratePhysicalDevices(instance, &physical_device_count, nullptr),
|
|
"vkEnumeratePhysicalDevices");
|
|
if (physical_device_count == 0) {
|
|
throw std::runtime_error("no Vulkan physical device");
|
|
}
|
|
std::vector<VkPhysicalDevice> physical_devices(physical_device_count);
|
|
check(vkEnumeratePhysicalDevices(instance, &physical_device_count, physical_devices.data()),
|
|
"vkEnumeratePhysicalDevices");
|
|
|
|
int best_score = -1;
|
|
for (VkPhysicalDevice candidate : physical_devices) {
|
|
uint32_t family_count = 0;
|
|
vkGetPhysicalDeviceQueueFamilyProperties(candidate, &family_count, nullptr);
|
|
std::vector<VkQueueFamilyProperties> families(family_count);
|
|
vkGetPhysicalDeviceQueueFamilyProperties(candidate, &family_count, families.data());
|
|
|
|
int graphics_index = -1;
|
|
int present_index = -1;
|
|
bool swapchain_supported = false;
|
|
|
|
uint32_t extension_count = 0;
|
|
vkEnumerateDeviceExtensionProperties(candidate, nullptr, &extension_count, nullptr);
|
|
std::vector<VkExtensionProperties> extensions(extension_count);
|
|
vkEnumerateDeviceExtensionProperties(candidate, nullptr, &extension_count,
|
|
extensions.data());
|
|
for (const auto& extension : extensions) {
|
|
if (std::strcmp(extension.extensionName, VK_KHR_SWAPCHAIN_EXTENSION_NAME) == 0) {
|
|
swapchain_supported = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
for (uint32_t i = 0; i < family_count; ++i) {
|
|
if (families[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
|
|
graphics_index = static_cast<int>(i);
|
|
}
|
|
VkBool32 supports_present = VK_FALSE;
|
|
vkGetPhysicalDeviceSurfaceSupportKHR(candidate, i, surface, &supports_present);
|
|
if (supports_present) {
|
|
present_index = static_cast<int>(i);
|
|
}
|
|
if (graphics_index >= 0 && present_index >= 0) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
VkPhysicalDeviceProperties properties{};
|
|
vkGetPhysicalDeviceProperties(candidate, &properties);
|
|
|
|
int score = 0;
|
|
if (graphics_index >= 0 && present_index >= 0 && swapchain_supported) {
|
|
score += 1000;
|
|
}
|
|
if (properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU) {
|
|
score += 100;
|
|
}
|
|
if (score > best_score) {
|
|
best_score = score;
|
|
physical_device = candidate;
|
|
graphics_family = static_cast<uint32_t>(graphics_index);
|
|
present_family = static_cast<uint32_t>(present_index);
|
|
}
|
|
}
|
|
|
|
if (best_score < 1000) {
|
|
throw std::runtime_error("no suitable Vulkan device (graphics + present + swapchain)");
|
|
}
|
|
|
|
std::vector<VkDeviceQueueCreateInfo> queue_infos;
|
|
std::array<uint32_t, 2> unique_families = {graphics_family, present_family};
|
|
float queue_priority = 1.0F;
|
|
for (uint32_t family : unique_families) {
|
|
VkDeviceQueueCreateInfo queue_info{};
|
|
queue_info.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
|
|
queue_info.queueFamilyIndex = family;
|
|
queue_info.queueCount = 1;
|
|
queue_info.pQueuePriorities = &queue_priority;
|
|
queue_infos.push_back(queue_info);
|
|
}
|
|
if (queue_infos.size() == 2 && graphics_family == present_family) {
|
|
queue_infos.resize(1);
|
|
}
|
|
|
|
VkDeviceCreateInfo device_info{};
|
|
device_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
|
|
device_info.queueCreateInfoCount = static_cast<uint32_t>(queue_infos.size());
|
|
device_info.pQueueCreateInfos = queue_infos.data();
|
|
const char* device_extension = VK_KHR_SWAPCHAIN_EXTENSION_NAME;
|
|
device_info.enabledExtensionCount = 1;
|
|
device_info.ppEnabledExtensionNames = &device_extension;
|
|
check(vkCreateDevice(physical_device, &device_info, nullptr, &device), "vkCreateDevice");
|
|
vkGetDeviceQueue(device, graphics_family, 0, &graphics_queue);
|
|
vkGetDeviceQueue(device, present_family, 0, &present_queue);
|
|
|
|
VkSurfaceCapabilitiesKHR capabilities{};
|
|
check(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physical_device, surface, &capabilities),
|
|
"vkGetPhysicalDeviceSurfaceCapabilitiesKHR");
|
|
|
|
uint32_t format_count = 0;
|
|
check(vkGetPhysicalDeviceSurfaceFormatsKHR(physical_device, surface, &format_count, nullptr),
|
|
"vkGetPhysicalDeviceSurfaceFormatsKHR");
|
|
std::vector<VkSurfaceFormatKHR> formats(format_count);
|
|
check(vkGetPhysicalDeviceSurfaceFormatsKHR(physical_device, surface, &format_count,
|
|
formats.data()),
|
|
"vkGetPhysicalDeviceSurfaceFormatsKHR");
|
|
VkSurfaceFormatKHR surface_format = formats[0];
|
|
for (const auto& format : formats) {
|
|
if (format.format == VK_FORMAT_B8G8R8A8_SRGB &&
|
|
format.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) {
|
|
surface_format = format;
|
|
break;
|
|
}
|
|
}
|
|
|
|
uint32_t present_mode_count = 0;
|
|
check(vkGetPhysicalDeviceSurfacePresentModesKHR(physical_device, surface, &present_mode_count,
|
|
nullptr),
|
|
"vkGetPhysicalDeviceSurfacePresentModesKHR");
|
|
std::vector<VkPresentModeKHR> present_modes(present_mode_count);
|
|
check(vkGetPhysicalDeviceSurfacePresentModesKHR(physical_device, surface, &present_mode_count,
|
|
present_modes.data()),
|
|
"vkGetPhysicalDeviceSurfacePresentModesKHR");
|
|
VkPresentModeKHR present_mode = VK_PRESENT_MODE_FIFO_KHR;
|
|
for (VkPresentModeKHR mode : present_modes) {
|
|
if (mode == VK_PRESENT_MODE_MAILBOX_KHR) {
|
|
present_mode = mode;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (capabilities.currentExtent.width != UINT32_MAX) {
|
|
swapchain_extent = capabilities.currentExtent;
|
|
} else {
|
|
int fb_width = 0;
|
|
int fb_height = 0;
|
|
glfwGetFramebufferSize(window, &fb_width, &fb_height);
|
|
swapchain_extent.width =
|
|
std::clamp(static_cast<uint32_t>(fb_width), capabilities.minImageExtent.width,
|
|
capabilities.maxImageExtent.width);
|
|
swapchain_extent.height =
|
|
std::clamp(static_cast<uint32_t>(fb_height), capabilities.minImageExtent.height,
|
|
capabilities.maxImageExtent.height);
|
|
}
|
|
|
|
uint32_t image_count = capabilities.minImageCount + 1;
|
|
if (capabilities.maxImageCount > 0 && image_count > capabilities.maxImageCount) {
|
|
image_count = capabilities.maxImageCount;
|
|
}
|
|
|
|
VkSwapchainCreateInfoKHR swapchain_info{};
|
|
swapchain_info.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
|
|
swapchain_info.surface = surface;
|
|
swapchain_info.minImageCount = image_count;
|
|
swapchain_info.imageFormat = surface_format.format;
|
|
swapchain_info.imageColorSpace = surface_format.colorSpace;
|
|
swapchain_info.imageExtent = swapchain_extent;
|
|
swapchain_info.imageArrayLayers = 1;
|
|
swapchain_info.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
|
|
swapchain_info.imageSharingMode =
|
|
graphics_family == present_family ? VK_SHARING_MODE_EXCLUSIVE : VK_SHARING_MODE_CONCURRENT;
|
|
swapchain_info.queueFamilyIndexCount = graphics_family == present_family ? 0 : 2;
|
|
std::array<uint32_t, 2> families = {graphics_family, present_family};
|
|
swapchain_info.pQueueFamilyIndices = families.data();
|
|
swapchain_info.preTransform = capabilities.currentTransform;
|
|
swapchain_info.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
|
|
swapchain_info.presentMode = present_mode;
|
|
swapchain_info.clipped = VK_TRUE;
|
|
swapchain_info.oldSwapchain = VK_NULL_HANDLE;
|
|
|
|
swapchain_format = surface_format.format;
|
|
check(vkCreateSwapchainKHR(device, &swapchain_info, nullptr, &swapchain),
|
|
"vkCreateSwapchainKHR");
|
|
|
|
uint32_t actual_image_count = 0;
|
|
check(vkGetSwapchainImagesKHR(device, swapchain, &actual_image_count, nullptr),
|
|
"vkGetSwapchainImagesKHR");
|
|
swapchain_images.resize(actual_image_count);
|
|
check(vkGetSwapchainImagesKHR(device, swapchain, &actual_image_count, swapchain_images.data()),
|
|
"vkGetSwapchainImagesKHR");
|
|
swapchain_image_views.resize(actual_image_count);
|
|
for (uint32_t i = 0; i < actual_image_count; ++i) {
|
|
VkImageViewCreateInfo view_info{};
|
|
view_info.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
|
|
view_info.image = swapchain_images[i];
|
|
view_info.viewType = VK_IMAGE_VIEW_TYPE_2D;
|
|
view_info.format = swapchain_format;
|
|
view_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
view_info.subresourceRange.baseMipLevel = 0;
|
|
view_info.subresourceRange.levelCount = 1;
|
|
view_info.subresourceRange.baseArrayLayer = 0;
|
|
view_info.subresourceRange.layerCount = 1;
|
|
check(vkCreateImageView(device, &view_info, nullptr, &swapchain_image_views[i]),
|
|
"vkCreateImageView");
|
|
}
|
|
|
|
VkAttachmentDescription color_attachment{};
|
|
color_attachment.format = swapchain_format;
|
|
color_attachment.samples = VK_SAMPLE_COUNT_1_BIT;
|
|
color_attachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
|
|
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_UNDEFINED;
|
|
color_attachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
|
|
|
|
VkAttachmentReference color_reference{};
|
|
color_reference.attachment = 0;
|
|
color_reference.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
|
|
|
|
VkSubpassDescription subpass{};
|
|
subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
|
|
subpass.colorAttachmentCount = 1;
|
|
subpass.pColorAttachments = &color_reference;
|
|
|
|
VkRenderPassCreateInfo render_pass_info{};
|
|
render_pass_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
|
|
render_pass_info.attachmentCount = 1;
|
|
render_pass_info.pAttachments = &color_attachment;
|
|
render_pass_info.subpassCount = 1;
|
|
render_pass_info.pSubpasses = &subpass;
|
|
check(vkCreateRenderPass(device, &render_pass_info, nullptr, &render_pass),
|
|
"vkCreateRenderPass");
|
|
|
|
framebuffers.resize(actual_image_count);
|
|
for (uint32_t i = 0; i < actual_image_count; ++i) {
|
|
VkFramebufferCreateInfo framebuffer_info{};
|
|
framebuffer_info.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
|
|
framebuffer_info.renderPass = render_pass;
|
|
framebuffer_info.attachmentCount = 1;
|
|
framebuffer_info.pAttachments = &swapchain_image_views[i];
|
|
framebuffer_info.width = swapchain_extent.width;
|
|
framebuffer_info.height = swapchain_extent.height;
|
|
framebuffer_info.layers = 1;
|
|
check(vkCreateFramebuffer(device, &framebuffer_info, nullptr, &framebuffers[i]),
|
|
"vkCreateFramebuffer");
|
|
}
|
|
|
|
VkCommandPoolCreateInfo command_pool_info{};
|
|
command_pool_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
|
|
command_pool_info.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
|
|
command_pool_info.queueFamilyIndex = graphics_family;
|
|
check(vkCreateCommandPool(device, &command_pool_info, nullptr, &command_pool),
|
|
"vkCreateCommandPool");
|
|
|
|
const uint32_t frame_count = actual_image_count;
|
|
|
|
VkSemaphoreCreateInfo semaphore_info{};
|
|
semaphore_info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
|
|
|
|
frames.resize(frame_count);
|
|
images_in_flight.resize(actual_image_count, VK_NULL_HANDLE);
|
|
for (FrameData& frame : frames) {
|
|
check(vkCreateSemaphore(device, &semaphore_info, nullptr, &frame.image_available),
|
|
"vkCreateSemaphore");
|
|
check(vkCreateSemaphore(device, &semaphore_info, nullptr, &frame.render_finished),
|
|
"vkCreateSemaphore");
|
|
|
|
VkFenceCreateInfo fence_info{};
|
|
fence_info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
|
|
fence_info.flags = VK_FENCE_CREATE_SIGNALED_BIT;
|
|
check(vkCreateFence(device, &fence_info, nullptr, &frame.in_flight), "vkCreateFence");
|
|
|
|
VkCommandBufferAllocateInfo allocate_info{};
|
|
allocate_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
|
|
allocate_info.commandPool = command_pool;
|
|
allocate_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
|
|
allocate_info.commandBufferCount = 1;
|
|
check(vkAllocateCommandBuffers(device, &allocate_info, &frame.command_buffer),
|
|
"vkAllocateCommandBuffers");
|
|
}
|
|
|
|
VkDescriptorSetLayoutBinding layout_binding{};
|
|
layout_binding.binding = 0;
|
|
layout_binding.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
|
|
layout_binding.descriptorCount = 1;
|
|
layout_binding.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
|
|
|
|
VkDescriptorSetLayoutCreateInfo descriptor_layout_info{};
|
|
descriptor_layout_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
|
|
descriptor_layout_info.bindingCount = 1;
|
|
descriptor_layout_info.pBindings = &layout_binding;
|
|
check(vkCreateDescriptorSetLayout(device, &descriptor_layout_info, nullptr,
|
|
&descriptor_set_layout),
|
|
"vkCreateDescriptorSetLayout");
|
|
|
|
VkPushConstantRange push_constant_range{};
|
|
push_constant_range.stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
|
|
push_constant_range.offset = 0;
|
|
push_constant_range.size = sizeof(float) * 20;
|
|
|
|
VkPipelineLayoutCreateInfo pipeline_layout_info{};
|
|
pipeline_layout_info.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
|
|
pipeline_layout_info.setLayoutCount = 1;
|
|
pipeline_layout_info.pSetLayouts = &descriptor_set_layout;
|
|
pipeline_layout_info.pushConstantRangeCount = 1;
|
|
pipeline_layout_info.pPushConstantRanges = &push_constant_range;
|
|
check(vkCreatePipelineLayout(device, &pipeline_layout_info, nullptr, &pipeline_layout),
|
|
"vkCreatePipelineLayout");
|
|
|
|
VkDescriptorPoolSize pool_size{};
|
|
pool_size.type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
|
|
pool_size.descriptorCount = 1024;
|
|
|
|
VkDescriptorPoolCreateInfo pool_info{};
|
|
pool_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
|
|
pool_info.maxSets = 1024;
|
|
pool_info.poolSizeCount = 1;
|
|
pool_info.pPoolSizes = &pool_size;
|
|
check(vkCreateDescriptorPool(device, &pool_info, nullptr, &descriptor_pool),
|
|
"vkCreateDescriptorPool");
|
|
|
|
const std::vector<uint32_t> vertex_shader = load_shader("textured_quad.vert.spv");
|
|
const std::vector<uint32_t> fragment_shader = load_shader("textured_quad.frag.spv");
|
|
VkShaderModule vertex_module = create_shader_module(
|
|
device, vertex_shader.data(), vertex_shader.size() * sizeof(uint32_t));
|
|
VkShaderModule fragment_module = create_shader_module(
|
|
device, fragment_shader.data(), fragment_shader.size() * sizeof(uint32_t));
|
|
|
|
VkPipelineShaderStageCreateInfo vertex_stage{};
|
|
vertex_stage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
|
|
vertex_stage.stage = VK_SHADER_STAGE_VERTEX_BIT;
|
|
vertex_stage.module = vertex_module;
|
|
vertex_stage.pName = "main";
|
|
|
|
VkPipelineShaderStageCreateInfo fragment_stage{};
|
|
fragment_stage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
|
|
fragment_stage.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
|
|
fragment_stage.module = fragment_module;
|
|
fragment_stage.pName = "main";
|
|
|
|
std::array<VkPipelineShaderStageCreateInfo, 2> stages = {vertex_stage, fragment_stage};
|
|
|
|
VkVertexInputBindingDescription vertex_binding{};
|
|
vertex_binding.binding = 0;
|
|
vertex_binding.stride = sizeof(Mesh::Vertex);
|
|
vertex_binding.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
|
|
|
|
std::array<VkVertexInputAttributeDescription, 3> vertex_attributes{};
|
|
vertex_attributes[0].binding = 0;
|
|
vertex_attributes[0].location = 0;
|
|
vertex_attributes[0].format = VK_FORMAT_R32G32_SFLOAT;
|
|
vertex_attributes[0].offset = offsetof(Mesh::Vertex, position);
|
|
vertex_attributes[1].binding = 0;
|
|
vertex_attributes[1].location = 1;
|
|
vertex_attributes[1].format = VK_FORMAT_R32G32B32A32_SFLOAT;
|
|
vertex_attributes[1].offset = offsetof(Mesh::Vertex, color);
|
|
vertex_attributes[2].binding = 0;
|
|
vertex_attributes[2].location = 2;
|
|
vertex_attributes[2].format = VK_FORMAT_R32G32_SFLOAT;
|
|
vertex_attributes[2].offset = offsetof(Mesh::Vertex, uv);
|
|
|
|
VkPipelineVertexInputStateCreateInfo vertex_input{};
|
|
vertex_input.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
|
|
vertex_input.vertexBindingDescriptionCount = 1;
|
|
vertex_input.pVertexBindingDescriptions = &vertex_binding;
|
|
vertex_input.vertexAttributeDescriptionCount =
|
|
static_cast<uint32_t>(vertex_attributes.size());
|
|
vertex_input.pVertexAttributeDescriptions = vertex_attributes.data();
|
|
|
|
VkPipelineInputAssemblyStateCreateInfo input_assembly{};
|
|
input_assembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
|
|
input_assembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
|
|
input_assembly.primitiveRestartEnable = VK_FALSE;
|
|
|
|
VkViewport viewport{};
|
|
viewport.x = 0.0F;
|
|
viewport.y = 0.0F;
|
|
viewport.width = static_cast<float>(swapchain_extent.width);
|
|
viewport.height = static_cast<float>(swapchain_extent.height);
|
|
viewport.minDepth = 0.0F;
|
|
viewport.maxDepth = 1.0F;
|
|
|
|
VkRect2D scissor{};
|
|
scissor.offset = {0, 0};
|
|
scissor.extent = swapchain_extent;
|
|
|
|
VkPipelineViewportStateCreateInfo viewport_state{};
|
|
viewport_state.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
|
|
viewport_state.viewportCount = 1;
|
|
viewport_state.pViewports = &viewport;
|
|
viewport_state.scissorCount = 1;
|
|
viewport_state.pScissors = &scissor;
|
|
|
|
VkPipelineRasterizationStateCreateInfo rasterizer{};
|
|
rasterizer.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
|
|
rasterizer.depthClampEnable = VK_FALSE;
|
|
rasterizer.rasterizerDiscardEnable = VK_FALSE;
|
|
rasterizer.polygonMode = VK_POLYGON_MODE_FILL;
|
|
rasterizer.cullMode = VK_CULL_MODE_NONE;
|
|
rasterizer.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
|
|
rasterizer.depthBiasEnable = VK_FALSE;
|
|
rasterizer.lineWidth = 1.0F;
|
|
|
|
VkPipelineMultisampleStateCreateInfo multisampling{};
|
|
multisampling.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
|
|
multisampling.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
|
|
multisampling.sampleShadingEnable = VK_FALSE;
|
|
|
|
VkPipelineColorBlendAttachmentState color_blend_attachment{};
|
|
color_blend_attachment.blendEnable = VK_TRUE;
|
|
color_blend_attachment.srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
|
|
color_blend_attachment.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
|
|
color_blend_attachment.colorBlendOp = VK_BLEND_OP_ADD;
|
|
color_blend_attachment.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
|
|
color_blend_attachment.dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
|
|
color_blend_attachment.alphaBlendOp = VK_BLEND_OP_ADD;
|
|
color_blend_attachment.colorWriteMask =
|
|
VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT |
|
|
VK_COLOR_COMPONENT_A_BIT;
|
|
|
|
VkPipelineColorBlendStateCreateInfo color_blending{};
|
|
color_blending.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
|
|
color_blending.logicOpEnable = VK_FALSE;
|
|
color_blending.attachmentCount = 1;
|
|
color_blending.pAttachments = &color_blend_attachment;
|
|
|
|
VkGraphicsPipelineCreateInfo pipeline_info{};
|
|
pipeline_info.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
|
|
pipeline_info.stageCount = static_cast<uint32_t>(stages.size());
|
|
pipeline_info.pStages = stages.data();
|
|
pipeline_info.pVertexInputState = &vertex_input;
|
|
pipeline_info.pInputAssemblyState = &input_assembly;
|
|
pipeline_info.pViewportState = &viewport_state;
|
|
pipeline_info.pRasterizationState = &rasterizer;
|
|
pipeline_info.pMultisampleState = &multisampling;
|
|
pipeline_info.pDepthStencilState = nullptr;
|
|
pipeline_info.pColorBlendState = &color_blending;
|
|
const std::array<VkDynamicState, 2> dynamic_states = {
|
|
VK_DYNAMIC_STATE_VIEWPORT,
|
|
VK_DYNAMIC_STATE_SCISSOR,
|
|
};
|
|
VkPipelineDynamicStateCreateInfo dynamic_state{};
|
|
dynamic_state.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
|
|
dynamic_state.dynamicStateCount = static_cast<uint32_t>(dynamic_states.size());
|
|
dynamic_state.pDynamicStates = dynamic_states.data();
|
|
pipeline_info.pDynamicState = &dynamic_state;
|
|
pipeline_info.layout = pipeline_layout;
|
|
pipeline_info.renderPass = render_pass;
|
|
pipeline_info.subpass = 0;
|
|
check(vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &pipeline_info, nullptr, &pipeline),
|
|
"vkCreateGraphicsPipelines");
|
|
|
|
vkDestroyShaderModule(device, vertex_module, nullptr);
|
|
vkDestroyShaderModule(device, fragment_module, nullptr);
|
|
|
|
initialized = true;
|
|
}
|
|
|
|
VkCommandBuffer Renderer::Impl::begin_transfer() {
|
|
VkCommandBufferAllocateInfo allocate_info{};
|
|
allocate_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
|
|
allocate_info.commandPool = command_pool;
|
|
allocate_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
|
|
allocate_info.commandBufferCount = 1;
|
|
VkCommandBuffer command_buffer = VK_NULL_HANDLE;
|
|
check(vkAllocateCommandBuffers(device, &allocate_info, &command_buffer), "vkAllocateCommandBuffers");
|
|
VkCommandBufferBeginInfo begin_info{};
|
|
begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
|
|
begin_info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
|
|
check(vkBeginCommandBuffer(command_buffer, &begin_info), "vkBeginCommandBuffer");
|
|
return command_buffer;
|
|
}
|
|
|
|
void Renderer::Impl::end_transfer(VkCommandBuffer command_buffer) {
|
|
check(vkEndCommandBuffer(command_buffer), "vkEndCommandBuffer");
|
|
VkSubmitInfo submit_info{};
|
|
submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
|
|
submit_info.commandBufferCount = 1;
|
|
submit_info.pCommandBuffers = &command_buffer;
|
|
check(vkQueueSubmit(graphics_queue, 1, &submit_info, VK_NULL_HANDLE), "vkQueueSubmit");
|
|
check(vkQueueWaitIdle(graphics_queue), "vkQueueWaitIdle");
|
|
vkFreeCommandBuffers(device, command_pool, 1, &command_buffer);
|
|
}
|
|
|
|
void Renderer::Impl::create_texture(MeshResource& resource, const std::string& path) {
|
|
uint32_t width = 1;
|
|
uint32_t height = 1;
|
|
std::vector<unsigned char> pixels = {255, 255, 255, 255};
|
|
if (!path.empty() && !load_png_rgba(path, width, height, pixels)) {
|
|
std::fprintf(stderr, "无法加载 PNG 纹理 %s，已使用白色纹理\n", path.c_str());
|
|
width = 1;
|
|
height = 1;
|
|
pixels = {255, 255, 255, 255};
|
|
}
|
|
|
|
VkBuffer staging_buffer = VK_NULL_HANDLE;
|
|
VkDeviceMemory staging_memory = VK_NULL_HANDLE;
|
|
const VkDeviceSize size = static_cast<VkDeviceSize>(pixels.size());
|
|
create_buffer(physical_device, device, size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
|
|
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
|
|
staging_buffer, staging_memory);
|
|
void* mapped = nullptr;
|
|
check(vkMapMemory(device, staging_memory, 0, size, 0, &mapped), "vkMapMemory");
|
|
std::memcpy(mapped, pixels.data(), pixels.size());
|
|
vkUnmapMemory(device, staging_memory);
|
|
|
|
VkImageCreateInfo image_info{};
|
|
image_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
|
|
image_info.imageType = VK_IMAGE_TYPE_2D;
|
|
image_info.extent = {width, height, 1};
|
|
image_info.mipLevels = 1;
|
|
image_info.arrayLayers = 1;
|
|
image_info.format = VK_FORMAT_R8G8B8A8_UNORM;
|
|
image_info.tiling = VK_IMAGE_TILING_OPTIMAL;
|
|
image_info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
|
image_info.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
|
|
image_info.samples = VK_SAMPLE_COUNT_1_BIT;
|
|
image_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
|
check(vkCreateImage(device, &image_info, nullptr, &resource.image), "vkCreateImage");
|
|
VkMemoryRequirements requirements{};
|
|
vkGetImageMemoryRequirements(device, resource.image, &requirements);
|
|
VkMemoryAllocateInfo alloc_info{};
|
|
alloc_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
|
|
alloc_info.allocationSize = requirements.size;
|
|
alloc_info.memoryTypeIndex = find_memory_type(physical_device, requirements.memoryTypeBits,
|
|
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
|
|
check(vkAllocateMemory(device, &alloc_info, nullptr, &resource.image_memory), "vkAllocateMemory");
|
|
check(vkBindImageMemory(device, resource.image, resource.image_memory, 0), "vkBindImageMemory");
|
|
|
|
VkCommandBuffer command_buffer = begin_transfer();
|
|
VkImageMemoryBarrier barrier{};
|
|
barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
|
|
barrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
|
barrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
|
|
barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
|
|
barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
|
|
barrier.image = resource.image;
|
|
barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
barrier.subresourceRange.levelCount = 1;
|
|
barrier.subresourceRange.layerCount = 1;
|
|
barrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
|
|
vkCmdPipelineBarrier(command_buffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
|
|
VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrier);
|
|
VkBufferImageCopy region{};
|
|
region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
region.imageSubresource.layerCount = 1;
|
|
region.imageExtent = {width, height, 1};
|
|
vkCmdCopyBufferToImage(command_buffer, staging_buffer, resource.image,
|
|
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ®ion);
|
|
barrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
|
|
barrier.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
|
|
barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
|
|
barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
|
|
vkCmdPipelineBarrier(command_buffer, VK_PIPELINE_STAGE_TRANSFER_BIT,
|
|
VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrier);
|
|
end_transfer(command_buffer);
|
|
vkDestroyBuffer(device, staging_buffer, nullptr);
|
|
vkFreeMemory(device, staging_memory, nullptr);
|
|
|
|
VkImageViewCreateInfo view_info{};
|
|
view_info.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
|
|
view_info.image = resource.image;
|
|
view_info.viewType = VK_IMAGE_VIEW_TYPE_2D;
|
|
view_info.format = VK_FORMAT_R8G8B8A8_UNORM;
|
|
view_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
view_info.subresourceRange.levelCount = 1;
|
|
view_info.subresourceRange.layerCount = 1;
|
|
check(vkCreateImageView(device, &view_info, nullptr, &resource.image_view), "vkCreateImageView");
|
|
VkSamplerCreateInfo sampler_info{};
|
|
sampler_info.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
|
|
sampler_info.magFilter = VK_FILTER_LINEAR;
|
|
sampler_info.minFilter = VK_FILTER_LINEAR;
|
|
sampler_info.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT;
|
|
sampler_info.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT;
|
|
sampler_info.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT;
|
|
sampler_info.maxLod = 0.0F;
|
|
check(vkCreateSampler(device, &sampler_info, nullptr, &resource.sampler), "vkCreateSampler");
|
|
|
|
VkDescriptorSetAllocateInfo set_info{};
|
|
set_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
|
|
set_info.descriptorPool = descriptor_pool;
|
|
set_info.descriptorSetCount = 1;
|
|
set_info.pSetLayouts = &descriptor_set_layout;
|
|
check(vkAllocateDescriptorSets(device, &set_info, &resource.descriptor_set), "vkAllocateDescriptorSets");
|
|
VkDescriptorImageInfo image_descriptor{};
|
|
image_descriptor.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
|
|
image_descriptor.imageView = resource.image_view;
|
|
image_descriptor.sampler = resource.sampler;
|
|
VkWriteDescriptorSet write{};
|
|
write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
|
|
write.dstSet = resource.descriptor_set;
|
|
write.dstBinding = 0;
|
|
write.descriptorCount = 1;
|
|
write.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
|
|
write.pImageInfo = &image_descriptor;
|
|
vkUpdateDescriptorSets(device, 1, &write, 0, nullptr);
|
|
}
|
|
|
|
void Renderer::Impl::upload_mesh(const Mesh& mesh) {
|
|
if (mesh_resources.find(&mesh) != mesh_resources.end()) return;
|
|
MeshResource& resource = mesh_resources[&mesh];
|
|
resource.index_count = static_cast<uint32_t>(mesh.indices.size());
|
|
if (mesh.vertices.empty() || resource.index_count == 0) return;
|
|
|
|
const VkDeviceSize vertex_size = sizeof(Mesh::Vertex) * mesh.vertices.size();
|
|
create_buffer(physical_device, device, vertex_size, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
|
|
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
|
|
resource.vertex_buffer, resource.vertex_buffer_memory);
|
|
void* vertex_mapped = nullptr;
|
|
check(vkMapMemory(device, resource.vertex_buffer_memory, 0, vertex_size, 0, &vertex_mapped),
|
|
"vkMapMemory");
|
|
std::memcpy(vertex_mapped, mesh.vertices.data(), vertex_size);
|
|
vkUnmapMemory(device, resource.vertex_buffer_memory);
|
|
|
|
const VkDeviceSize index_size = sizeof(uint32_t) * resource.index_count;
|
|
create_buffer(physical_device, device, index_size, VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
|
|
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
|
|
resource.index_buffer, resource.index_buffer_memory);
|
|
void* index_mapped = nullptr;
|
|
check(vkMapMemory(device, resource.index_buffer_memory, 0, index_size, 0, &index_mapped),
|
|
"vkMapMemory");
|
|
std::memcpy(index_mapped, mesh.indices.data(), index_size);
|
|
vkUnmapMemory(device, resource.index_buffer_memory);
|
|
create_texture(resource, mesh.texture);
|
|
}
|
|
|
|
void Renderer::Impl::recreate_swapchain() {
|
|
int width = 0;
|
|
int height = 0;
|
|
glfwGetFramebufferSize(window, &width, &height);
|
|
if (width == 0 || height == 0) return;
|
|
check(vkDeviceWaitIdle(device), "vkDeviceWaitIdle");
|
|
|
|
VkSurfaceCapabilitiesKHR capabilities{};
|
|
check(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physical_device, surface, &capabilities),
|
|
"vkGetPhysicalDeviceSurfaceCapabilitiesKHR");
|
|
uint32_t format_count = 0;
|
|
check(vkGetPhysicalDeviceSurfaceFormatsKHR(physical_device, surface, &format_count, nullptr),
|
|
"vkGetPhysicalDeviceSurfaceFormatsKHR");
|
|
std::vector<VkSurfaceFormatKHR> formats(format_count);
|
|
check(vkGetPhysicalDeviceSurfaceFormatsKHR(physical_device, surface, &format_count, formats.data()),
|
|
"vkGetPhysicalDeviceSurfaceFormatsKHR");
|
|
VkSurfaceFormatKHR surface_format = formats.front();
|
|
for (const VkSurfaceFormatKHR& format : formats) {
|
|
if (format.format == VK_FORMAT_B8G8R8A8_SRGB &&
|
|
format.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) {
|
|
surface_format = format;
|
|
break;
|
|
}
|
|
}
|
|
if (surface_format.format != swapchain_format) {
|
|
throw std::runtime_error("swapchain format changed; renderer recreation is required");
|
|
}
|
|
uint32_t present_mode_count = 0;
|
|
check(vkGetPhysicalDeviceSurfacePresentModesKHR(physical_device, surface, &present_mode_count,
|
|
nullptr),
|
|
"vkGetPhysicalDeviceSurfacePresentModesKHR");
|
|
std::vector<VkPresentModeKHR> present_modes(present_mode_count);
|
|
check(vkGetPhysicalDeviceSurfacePresentModesKHR(physical_device, surface, &present_mode_count,
|
|
present_modes.data()),
|
|
"vkGetPhysicalDeviceSurfacePresentModesKHR");
|
|
VkPresentModeKHR present_mode = VK_PRESENT_MODE_FIFO_KHR;
|
|
for (VkPresentModeKHR mode : present_modes) {
|
|
if (mode == VK_PRESENT_MODE_MAILBOX_KHR) {
|
|
present_mode = mode;
|
|
break;
|
|
}
|
|
}
|
|
VkExtent2D extent{};
|
|
if (capabilities.currentExtent.width != UINT32_MAX) {
|
|
extent = capabilities.currentExtent;
|
|
} else {
|
|
extent.width = std::clamp(static_cast<uint32_t>(width), capabilities.minImageExtent.width,
|
|
capabilities.maxImageExtent.width);
|
|
extent.height = std::clamp(static_cast<uint32_t>(height), capabilities.minImageExtent.height,
|
|
capabilities.maxImageExtent.height);
|
|
}
|
|
uint32_t image_count = capabilities.minImageCount + 1;
|
|
if (capabilities.maxImageCount > 0 && image_count > capabilities.maxImageCount) {
|
|
image_count = capabilities.maxImageCount;
|
|
}
|
|
|
|
for (VkFramebuffer framebuffer : framebuffers) {
|
|
vkDestroyFramebuffer(device, framebuffer, nullptr);
|
|
}
|
|
framebuffers.clear();
|
|
for (VkImageView view : swapchain_image_views) {
|
|
vkDestroyImageView(device, view, nullptr);
|
|
}
|
|
swapchain_image_views.clear();
|
|
const VkSwapchainKHR old_swapchain = swapchain;
|
|
if (old_swapchain != VK_NULL_HANDLE) {
|
|
vkDestroySwapchainKHR(device, old_swapchain, nullptr);
|
|
swapchain = VK_NULL_HANDLE;
|
|
}
|
|
|
|
VkSwapchainCreateInfoKHR create_info{};
|
|
create_info.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
|
|
create_info.surface = 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_COLOR_ATTACHMENT_BIT;
|
|
std::array<uint32_t, 2> families = {graphics_family, present_family};
|
|
create_info.imageSharingMode = graphics_family == present_family
|
|
? VK_SHARING_MODE_EXCLUSIVE
|
|
: VK_SHARING_MODE_CONCURRENT;
|
|
create_info.queueFamilyIndexCount = graphics_family == present_family ? 0 : 2;
|
|
create_info.pQueueFamilyIndices = families.data();
|
|
create_info.preTransform = capabilities.currentTransform;
|
|
create_info.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
|
|
create_info.presentMode = present_mode;
|
|
create_info.clipped = VK_TRUE;
|
|
create_info.oldSwapchain = VK_NULL_HANDLE;
|
|
check(vkCreateSwapchainKHR(device, &create_info, nullptr, &swapchain), "vkCreateSwapchainKHR");
|
|
|
|
swapchain_extent = extent;
|
|
uint32_t actual_image_count = 0;
|
|
check(vkGetSwapchainImagesKHR(device, swapchain, &actual_image_count, nullptr),
|
|
"vkGetSwapchainImagesKHR");
|
|
if (actual_image_count > frames.size()) {
|
|
throw std::runtime_error("resized swapchain needs more frame resources");
|
|
}
|
|
swapchain_images.resize(actual_image_count);
|
|
check(vkGetSwapchainImagesKHR(device, swapchain, &actual_image_count, swapchain_images.data()),
|
|
"vkGetSwapchainImagesKHR");
|
|
swapchain_image_views.resize(actual_image_count);
|
|
for (uint32_t i = 0; i < actual_image_count; ++i) {
|
|
VkImageViewCreateInfo view_info{};
|
|
view_info.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
|
|
view_info.image = swapchain_images[i];
|
|
view_info.viewType = VK_IMAGE_VIEW_TYPE_2D;
|
|
view_info.format = swapchain_format;
|
|
view_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
view_info.subresourceRange.levelCount = 1;
|
|
view_info.subresourceRange.layerCount = 1;
|
|
check(vkCreateImageView(device, &view_info, nullptr, &swapchain_image_views[i]),
|
|
"vkCreateImageView");
|
|
}
|
|
framebuffers.resize(actual_image_count);
|
|
for (uint32_t i = 0; i < actual_image_count; ++i) {
|
|
VkFramebufferCreateInfo framebuffer_info{};
|
|
framebuffer_info.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
|
|
framebuffer_info.renderPass = render_pass;
|
|
framebuffer_info.attachmentCount = 1;
|
|
framebuffer_info.pAttachments = &swapchain_image_views[i];
|
|
framebuffer_info.width = swapchain_extent.width;
|
|
framebuffer_info.height = swapchain_extent.height;
|
|
framebuffer_info.layers = 1;
|
|
check(vkCreateFramebuffer(device, &framebuffer_info, nullptr, &framebuffers[i]),
|
|
"vkCreateFramebuffer");
|
|
}
|
|
images_in_flight.assign(actual_image_count, VK_NULL_HANDLE);
|
|
framebuffer_resized = false;
|
|
}
|
|
|
|
void Renderer::Impl::draw(const Actor* const* actors, size_t actor_count, const Camera* camera) {
|
|
if (!initialized || actor_count == 0) {
|
|
return;
|
|
}
|
|
|
|
FrameData& frame = frames[current_frame % frames.size()];
|
|
check(vkWaitForFences(device, 1, &frame.in_flight, VK_TRUE, UINT64_MAX), "vkWaitForFences");
|
|
|
|
uint32_t image_index = 0;
|
|
VkResult acquire_result = vkAcquireNextImageKHR(device, swapchain, UINT64_MAX,
|
|
frame.image_available,
|
|
VK_NULL_HANDLE, &image_index);
|
|
if (acquire_result == VK_ERROR_OUT_OF_DATE_KHR) {
|
|
recreate_swapchain();
|
|
return;
|
|
}
|
|
if (acquire_result != VK_SUCCESS && acquire_result != VK_SUBOPTIMAL_KHR) {
|
|
check(acquire_result, "vkAcquireNextImageKHR");
|
|
}
|
|
|
|
if (images_in_flight[image_index] != VK_NULL_HANDLE) {
|
|
check(vkWaitForFences(device, 1, &images_in_flight[image_index], VK_TRUE, UINT64_MAX),
|
|
"vkWaitForFences(image)");
|
|
}
|
|
images_in_flight[image_index] = frame.in_flight;
|
|
check(vkResetFences(device, 1, &frame.in_flight), "vkResetFences");
|
|
|
|
for (size_t i = 0; i < actor_count; ++i) {
|
|
const Actor& actor = *actors[i];
|
|
const auto& mesh = actor.mesh();
|
|
if (mesh != nullptr) {
|
|
upload_mesh(*mesh);
|
|
}
|
|
}
|
|
|
|
check(vkResetCommandBuffer(frame.command_buffer, 0), "vkResetCommandBuffer");
|
|
|
|
VkCommandBufferBeginInfo begin_info{};
|
|
begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
|
|
check(vkBeginCommandBuffer(frame.command_buffer, &begin_info), "vkBeginCommandBuffer");
|
|
|
|
VkClearValue clear_value{};
|
|
clear_value.color = {{0.03F, 0.03F, 0.06F, 1.0F}};
|
|
|
|
VkRenderPassBeginInfo render_pass_begin{};
|
|
render_pass_begin.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
|
|
render_pass_begin.renderPass = render_pass;
|
|
render_pass_begin.framebuffer = framebuffers[image_index];
|
|
render_pass_begin.renderArea.offset = {0, 0};
|
|
render_pass_begin.renderArea.extent = swapchain_extent;
|
|
render_pass_begin.clearValueCount = 1;
|
|
render_pass_begin.pClearValues = &clear_value;
|
|
|
|
vkCmdBeginRenderPass(frame.command_buffer, &render_pass_begin, VK_SUBPASS_CONTENTS_INLINE);
|
|
vkCmdBindPipeline(frame.command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
|
|
VkViewport viewport{};
|
|
viewport.width = static_cast<float>(swapchain_extent.width);
|
|
viewport.height = static_cast<float>(swapchain_extent.height);
|
|
viewport.minDepth = 0.0F;
|
|
viewport.maxDepth = 1.0F;
|
|
VkRect2D scissor{};
|
|
scissor.extent = swapchain_extent;
|
|
vkCmdSetViewport(frame.command_buffer, 0, 1, &viewport);
|
|
vkCmdSetScissor(frame.command_buffer, 0, 1, &scissor);
|
|
for (size_t i = 0; i < actor_count; ++i) {
|
|
const Actor& actor = *actors[i];
|
|
if (actor.mesh() == nullptr) continue;
|
|
const auto resource_it = mesh_resources.find(actor.mesh().get());
|
|
if (resource_it == mesh_resources.end()) continue;
|
|
const MeshResource& resource = resource_it->second;
|
|
if (resource.vertex_buffer == VK_NULL_HANDLE || resource.index_buffer == VK_NULL_HANDLE ||
|
|
resource.descriptor_set == VK_NULL_HANDLE || resource.index_count == 0) continue;
|
|
|
|
VkDeviceSize offset = 0;
|
|
vkCmdBindVertexBuffers(frame.command_buffer, 0, 1, &resource.vertex_buffer, &offset);
|
|
vkCmdBindIndexBuffer(frame.command_buffer, resource.index_buffer, 0, VK_INDEX_TYPE_UINT32);
|
|
vkCmdBindDescriptorSets(frame.command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout,
|
|
0, 1, &resource.descriptor_set, 0, nullptr);
|
|
|
|
auto position = actor.global_position();
|
|
auto facing = actor.global_facing();
|
|
float camera_zoom = 1.0F;
|
|
if (camera != nullptr) {
|
|
const auto camera_position = camera->global_position();
|
|
const auto camera_facing = camera->global_facing();
|
|
const float camera_length = std::sqrt(camera_facing[0] * camera_facing[0] +
|
|
camera_facing[1] * camera_facing[1]);
|
|
const float camera_x = camera_length > 0.0001F ? camera_facing[0] / camera_length : 1.0F;
|
|
const float camera_y = camera_length > 0.0001F ? camera_facing[1] / camera_length : 0.0F;
|
|
const float dx = position[0] - camera_position[0];
|
|
const float dy = position[1] - camera_position[1];
|
|
position = {camera_x * dx + camera_y * dy, -camera_y * dx + camera_x * dy};
|
|
facing = {camera_x * facing[0] + camera_y * facing[1],
|
|
-camera_y * facing[0] + camera_x * facing[1]};
|
|
camera_zoom = camera->zoom();
|
|
}
|
|
const float scale = 0.35F * camera_zoom;
|
|
const float horizontal_projection =
|
|
static_cast<float>(swapchain_extent.height) / static_cast<float>(swapchain_extent.width);
|
|
float facing_x = facing[0];
|
|
float facing_y = facing[1];
|
|
const float facing_length = std::sqrt(facing_x * facing_x + facing_y * facing_y);
|
|
if (facing_length > 0.0001F) {
|
|
facing_x /= facing_length;
|
|
facing_y /= facing_length;
|
|
} else {
|
|
facing_x = 1.0F;
|
|
facing_y = 0.0F;
|
|
}
|
|
|
|
std::array<float, 20> constants = {{
|
|
scale * facing_x * horizontal_projection, scale * facing_y, 0.0F, 0.0F,
|
|
-scale * facing_y * horizontal_projection, scale * facing_x, 0.0F, 0.0F,
|
|
0.0F, 0.0F, 1.0F, 0.0F,
|
|
position[0] * horizontal_projection, position[1], 0.0F, 1.0F,
|
|
0.0F, 0.0F, 0.0F, 0.0F,
|
|
}};
|
|
const std::array<float, 4> color = actor.mesh()->color();
|
|
std::copy(color.begin(), color.end(), constants.begin() + 16);
|
|
vkCmdPushConstants(frame.command_buffer, pipeline_layout, VK_SHADER_STAGE_VERTEX_BIT, 0,
|
|
sizeof(constants), constants.data());
|
|
vkCmdDrawIndexed(frame.command_buffer, resource.index_count, 1, 0, 0, 0);
|
|
}
|
|
|
|
vkCmdEndRenderPass(frame.command_buffer);
|
|
check(vkEndCommandBuffer(frame.command_buffer), "vkEndCommandBuffer");
|
|
|
|
VkPipelineStageFlags wait_stage = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
|
|
VkSubmitInfo submit_info{};
|
|
submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
|
|
submit_info.waitSemaphoreCount = 1;
|
|
submit_info.pWaitSemaphores = &frame.image_available;
|
|
submit_info.pWaitDstStageMask = &wait_stage;
|
|
submit_info.commandBufferCount = 1;
|
|
submit_info.pCommandBuffers = &frame.command_buffer;
|
|
// Present 不提供 fence；同一交换链图像再次被获取前，不能重用其等待的信号量。
|
|
FrameData& image_frame = frames[image_index];
|
|
submit_info.signalSemaphoreCount = 1;
|
|
submit_info.pSignalSemaphores = &image_frame.render_finished;
|
|
check(vkQueueSubmit(graphics_queue, 1, &submit_info, frame.in_flight), "vkQueueSubmit");
|
|
|
|
VkPresentInfoKHR present_info{};
|
|
present_info.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
|
|
present_info.waitSemaphoreCount = 1;
|
|
present_info.pWaitSemaphores = &image_frame.render_finished;
|
|
present_info.swapchainCount = 1;
|
|
present_info.pSwapchains = &swapchain;
|
|
present_info.pImageIndices = &image_index;
|
|
VkResult present_result = vkQueuePresentKHR(present_queue, &present_info);
|
|
if (present_result == VK_ERROR_OUT_OF_DATE_KHR || present_result == VK_SUBOPTIMAL_KHR ||
|
|
framebuffer_resized) {
|
|
recreate_swapchain();
|
|
} else if (present_result != VK_SUCCESS) {
|
|
check(present_result, "vkQueuePresentKHR");
|
|
}
|
|
(void)present_result;
|
|
|
|
current_frame++;
|
|
}
|
|
|
|
void Renderer::Impl::destroy() {
|
|
if (!initialized) {
|
|
return;
|
|
}
|
|
if (device != VK_NULL_HANDLE) {
|
|
vkDeviceWaitIdle(device);
|
|
}
|
|
|
|
for (FrameData& frame : frames) {
|
|
if (frame.in_flight != VK_NULL_HANDLE) {
|
|
vkDestroyFence(device, frame.in_flight, nullptr);
|
|
}
|
|
if (frame.image_available != VK_NULL_HANDLE) {
|
|
vkDestroySemaphore(device, frame.image_available, nullptr);
|
|
}
|
|
if (frame.render_finished != VK_NULL_HANDLE) {
|
|
vkDestroySemaphore(device, frame.render_finished, nullptr);
|
|
}
|
|
if (frame.command_buffer != VK_NULL_HANDLE) {
|
|
vkFreeCommandBuffers(device, command_pool, 1, &frame.command_buffer);
|
|
}
|
|
}
|
|
|
|
for (auto& [mesh, resource] : mesh_resources) {
|
|
if (resource.sampler != VK_NULL_HANDLE) vkDestroySampler(device, resource.sampler, nullptr);
|
|
if (resource.image_view != VK_NULL_HANDLE) vkDestroyImageView(device, resource.image_view, nullptr);
|
|
if (resource.image != VK_NULL_HANDLE) vkDestroyImage(device, resource.image, nullptr);
|
|
if (resource.image_memory != VK_NULL_HANDLE) vkFreeMemory(device, resource.image_memory, nullptr);
|
|
if (resource.vertex_buffer != VK_NULL_HANDLE) vkDestroyBuffer(device, resource.vertex_buffer, nullptr);
|
|
if (resource.vertex_buffer_memory != VK_NULL_HANDLE) vkFreeMemory(device, resource.vertex_buffer_memory, nullptr);
|
|
if (resource.index_buffer != VK_NULL_HANDLE) vkDestroyBuffer(device, resource.index_buffer, nullptr);
|
|
if (resource.index_buffer_memory != VK_NULL_HANDLE) vkFreeMemory(device, resource.index_buffer_memory, nullptr);
|
|
}
|
|
mesh_resources.clear();
|
|
|
|
if (descriptor_pool != VK_NULL_HANDLE) {
|
|
vkDestroyDescriptorPool(device, descriptor_pool, nullptr);
|
|
}
|
|
if (descriptor_set_layout != VK_NULL_HANDLE) {
|
|
vkDestroyDescriptorSetLayout(device, descriptor_set_layout, nullptr);
|
|
}
|
|
if (pipeline != VK_NULL_HANDLE) {
|
|
vkDestroyPipeline(device, pipeline, nullptr);
|
|
}
|
|
if (pipeline_layout != VK_NULL_HANDLE) {
|
|
vkDestroyPipelineLayout(device, pipeline_layout, nullptr);
|
|
}
|
|
if (command_pool != VK_NULL_HANDLE) {
|
|
vkDestroyCommandPool(device, command_pool, nullptr);
|
|
}
|
|
for (VkFramebuffer framebuffer : framebuffers) {
|
|
if (framebuffer != VK_NULL_HANDLE) {
|
|
vkDestroyFramebuffer(device, framebuffer, nullptr);
|
|
}
|
|
}
|
|
if (render_pass != VK_NULL_HANDLE) {
|
|
vkDestroyRenderPass(device, render_pass, nullptr);
|
|
}
|
|
for (VkImageView view : swapchain_image_views) {
|
|
if (view != VK_NULL_HANDLE) {
|
|
vkDestroyImageView(device, view, nullptr);
|
|
}
|
|
}
|
|
if (swapchain != VK_NULL_HANDLE) {
|
|
vkDestroySwapchainKHR(device, swapchain, nullptr);
|
|
}
|
|
if (device != VK_NULL_HANDLE) {
|
|
vkDestroyDevice(device, nullptr);
|
|
}
|
|
if (surface != VK_NULL_HANDLE && instance != VK_NULL_HANDLE) {
|
|
vkDestroySurfaceKHR(instance, surface, nullptr);
|
|
}
|
|
if (debug_messenger != VK_NULL_HANDLE && instance != VK_NULL_HANDLE) {
|
|
auto destroy_messenger = reinterpret_cast<PFN_vkDestroyDebugUtilsMessengerEXT>(
|
|
vkGetInstanceProcAddr(instance, "vkDestroyDebugUtilsMessengerEXT"));
|
|
if (destroy_messenger != nullptr) {
|
|
destroy_messenger(instance, debug_messenger, nullptr);
|
|
}
|
|
debug_messenger = VK_NULL_HANDLE;
|
|
}
|
|
if (instance != VK_NULL_HANDLE) {
|
|
vkDestroyInstance(instance, nullptr);
|
|
}
|
|
if (window != nullptr) {
|
|
glfwDestroyWindow(window);
|
|
glfwTerminate();
|
|
}
|
|
|
|
swapchain_images.clear();
|
|
swapchain_image_views.clear();
|
|
framebuffers.clear();
|
|
frames.clear();
|
|
initialized = false;
|
|
}
|
|
|
|
} // namespace boundard::render
|