1240 lines
45 KiB
C++
1240 lines
45 KiB
C++
#include "Application.h"
|
|
#include "lodepng.h"
|
|
#include <string>
|
|
|
|
#ifdef _WIN32
|
|
#include <codecvt>
|
|
#else
|
|
#include <game-activity/native_app_glue/android_native_app_glue.h>
|
|
#include <game-activity/GameActivity.h>
|
|
#include <vulkan/vulkan_android.h>
|
|
#include "../app/src/main/cpp/AndroidOut.h"
|
|
#include "../app/src/main/cpp/DebugLog.h"
|
|
#endif
|
|
|
|
#ifdef _WIN32
|
|
#define FACE_DBG_LOG(...) ((void)0)
|
|
#else
|
|
#define FACE_DBG_LOG(...) DebugLog::log(__VA_ARGS__)
|
|
#endif
|
|
|
|
static const char* VkResultStr(VkResult r) {
|
|
switch (r) {
|
|
case VK_SUCCESS: return "VK_SUCCESS";
|
|
case VK_NOT_READY: return "VK_NOT_READY";
|
|
case VK_TIMEOUT: return "VK_TIMEOUT";
|
|
case VK_EVENT_SET: return "VK_EVENT_SET";
|
|
case VK_EVENT_RESET: return "VK_EVENT_RESET";
|
|
case VK_INCOMPLETE: return "VK_INCOMPLETE";
|
|
case VK_SUBOPTIMAL_KHR: return "VK_SUBOPTIMAL_KHR";
|
|
case VK_ERROR_OUT_OF_HOST_MEMORY: return "VK_ERROR_OUT_OF_HOST_MEMORY";
|
|
case VK_ERROR_OUT_OF_DEVICE_MEMORY: return "VK_ERROR_OUT_OF_DEVICE_MEMORY";
|
|
case VK_ERROR_INITIALIZATION_FAILED: return "VK_ERROR_INITIALIZATION_FAILED";
|
|
case VK_ERROR_DEVICE_LOST: return "VK_ERROR_DEVICE_LOST";
|
|
case VK_ERROR_MEMORY_MAP_FAILED: return "VK_ERROR_MEMORY_MAP_FAILED";
|
|
case VK_ERROR_LAYER_NOT_PRESENT: return "VK_ERROR_LAYER_NOT_PRESENT";
|
|
case VK_ERROR_EXTENSION_NOT_PRESENT: return "VK_ERROR_EXTENSION_NOT_PRESENT";
|
|
case VK_ERROR_FEATURE_NOT_PRESENT: return "VK_ERROR_FEATURE_NOT_PRESENT";
|
|
case VK_ERROR_INCOMPATIBLE_DRIVER: return "VK_ERROR_INCOMPATIBLE_DRIVER";
|
|
case VK_ERROR_TOO_MANY_OBJECTS: return "VK_ERROR_TOO_MANY_OBJECTS";
|
|
case VK_ERROR_FORMAT_NOT_SUPPORTED: return "VK_ERROR_FORMAT_NOT_SUPPORTED";
|
|
case VK_ERROR_FRAGMENTED_POOL: return "VK_ERROR_FRAGMENTED_POOL";
|
|
case VK_ERROR_OUT_OF_DATE_KHR: return "VK_ERROR_OUT_OF_DATE_KHR";
|
|
case VK_ERROR_SURFACE_LOST_KHR: return "VK_ERROR_SURFACE_LOST_KHR";
|
|
case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR: return "VK_ERROR_NATIVE_WINDOW_IN_USE_KHR";
|
|
case VK_ERROR_OUT_OF_POOL_MEMORY: return "VK_ERROR_OUT_OF_POOL_MEMORY";
|
|
case VK_ERROR_INVALID_EXTERNAL_HANDLE: return "VK_ERROR_INVALID_EXTERNAL_HANDLE";
|
|
case VK_ERROR_FRAGMENTATION: return "VK_ERROR_FRAGMENTATION";
|
|
case VK_ERROR_UNKNOWN: return "VK_ERROR_UNKNOWN";
|
|
default: return "VK_UNMAPPED_VALUE";
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void Application::initWindow()
|
|
{
|
|
#ifdef _WIN32
|
|
glfwInit();
|
|
|
|
glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
|
|
glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE);
|
|
|
|
window = glfwCreateWindow(480, 480, "Vulkan", nullptr, nullptr);
|
|
#else
|
|
|
|
#endif
|
|
}
|
|
|
|
|
|
#ifdef _WIN32
|
|
#else
|
|
extern android_app* g_android_app;
|
|
#endif
|
|
|
|
void Application::createSurface() {
|
|
#ifdef _WIN32
|
|
if (glfwCreateWindowSurface(instance, window, nullptr, &surface) != VK_SUCCESS) {
|
|
throw std::runtime_error("failed to create window surface!");
|
|
}
|
|
#else
|
|
|
|
//VkSurfaceKHR surface{};
|
|
|
|
VkAndroidSurfaceCreateInfoKHR info{VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR};
|
|
|
|
info.window = g_android_app->window;
|
|
|
|
VK_CHECK(vkCreateAndroidSurfaceKHR(instance, &info, nullptr, &surface));
|
|
#endif
|
|
}
|
|
|
|
|
|
|
|
void Application::initVulkan()
|
|
{
|
|
if (!_applicationInited)
|
|
{
|
|
initWindow();
|
|
createInstance(); // 创建 Vulkan 实例
|
|
setupDebugMessenger(); // 在这里调用
|
|
createSurface(); // 创建窗口表面
|
|
pickPhysicalDevice(physicalDevice, surface); // 选择物理设备
|
|
createLogicalDevice(); // 创建逻辑设备
|
|
createSwapChain(); // 创建交换链
|
|
createImageViews(); // 创建交换链图像视图
|
|
createRenderPass(); // 创建渲染流程
|
|
createPipelineLayout(); // 在这里调用
|
|
createGraphicsPipeline(); // 创建图形管线
|
|
createFramebuffers(); // 创建帧缓冲区
|
|
createCommandPool(); // 创建命令池
|
|
createCommandBuffer(); // 创建命令缓冲区
|
|
createSyncObjects(); // 创建同步对象
|
|
_lastDrawFrameTime = getCurrentTimeMillis();
|
|
_applicationInited = true;
|
|
// The first branch above already built all of the window-dependent
|
|
// objects. Mark _sceondInited so we don't fall into the recovery
|
|
// branch below and leak a second copy of surface/swapChain/etc.
|
|
_sceondInited = true;
|
|
}
|
|
else if (!_sceondInited) {
|
|
createSurface();
|
|
createSwapChain();
|
|
createImageViews();
|
|
createRenderPass();
|
|
createPipelineLayout();
|
|
createGraphicsPipeline();
|
|
createFramebuffers();
|
|
_sceondInited = true;
|
|
}
|
|
}
|
|
|
|
void Application::cleanupSecondInit()
|
|
{
|
|
vkDestroySwapchainKHR(device, swapChain, nullptr);
|
|
vkDestroySurfaceKHR(instance, surface, nullptr);
|
|
vkDestroyPipeline(device, graphicsPipeline, nullptr);
|
|
vkDestroyPipelineLayout(device, pipelineLayout, nullptr);
|
|
vkDestroyRenderPass(device, renderPass, nullptr);
|
|
for (auto imageView : swapChainImageViews) {
|
|
vkDestroyImageView(device, imageView, nullptr);
|
|
}
|
|
for (auto framebuffer : swapChainFramebuffers)
|
|
{
|
|
if (framebuffer != VK_NULL_HANDLE)
|
|
{
|
|
vkDestroyFramebuffer(device, framebuffer, nullptr);
|
|
}
|
|
}
|
|
swapChainFramebuffers.clear();
|
|
|
|
_sceondInited = false;
|
|
}
|
|
|
|
void Application::cleanupForWindowLost()
|
|
{
|
|
if (!_applicationInited || !_sceondInited) {
|
|
FACE_DBG_LOG("cleanupForWindowLost: skip (_applicationInited=%d _sceondInited=%d)",
|
|
(int)_applicationInited, (int)_sceondInited);
|
|
return;
|
|
}
|
|
FACE_DBG_LOG("cleanupForWindowLost: begin (imageCount=%zu MAX_FRAMES_IN_FLIGHT=%d extent=%ux%u format=%d)",
|
|
swapChainImages.size(), MAX_FRAMES_IN_FLIGHT,
|
|
swapChainExtent.width, swapChainExtent.height, (int)swapChainImageFormat);
|
|
|
|
// Snapshot before we destroy the swapchain so reinitForNewWindow() can
|
|
// decide whether the new swapchain needs renderPass / pipelines rebuilt.
|
|
_prevSwapChainExtent = swapChainExtent;
|
|
_prevSwapChainImageFormat = swapChainImageFormat;
|
|
|
|
// Block until GPU is no longer using any of the resources we are about
|
|
// to destroy. Anything weaker than this risks hitting VK_ERROR_DEVICE_LOST
|
|
// on drivers that don't tolerate destroying in-flight resources.
|
|
vkDeviceWaitIdle(device);
|
|
|
|
for (auto framebuffer : swapChainFramebuffers) {
|
|
if (framebuffer != VK_NULL_HANDLE) {
|
|
vkDestroyFramebuffer(device, framebuffer, nullptr);
|
|
}
|
|
}
|
|
swapChainFramebuffers.clear();
|
|
|
|
for (auto imageView : swapChainImageViews) {
|
|
if (imageView != VK_NULL_HANDLE) {
|
|
vkDestroyImageView(device, imageView, nullptr);
|
|
}
|
|
}
|
|
swapChainImageViews.clear();
|
|
|
|
// Free the command buffers allocated from commandPool. The pool itself is
|
|
// kept alive so textures/staging uploads that run concurrently off the
|
|
// render thread (via commandPool_ex) aren't disrupted.
|
|
if (!commandBuffers.empty()) {
|
|
vkFreeCommandBuffers(device, commandPool,
|
|
(uint32_t)commandBuffers.size(), commandBuffers.data());
|
|
commandBuffers.clear();
|
|
}
|
|
|
|
for (size_t i = 0; i < imageAvailableSemaphores.size(); ++i) {
|
|
if (imageAvailableSemaphores[i] != VK_NULL_HANDLE) {
|
|
vkDestroySemaphore(device, imageAvailableSemaphores[i], nullptr);
|
|
}
|
|
}
|
|
imageAvailableSemaphores.clear();
|
|
for (size_t i = 0; i < renderFinishedSemaphores.size(); ++i) {
|
|
if (renderFinishedSemaphores[i] != VK_NULL_HANDLE) {
|
|
vkDestroySemaphore(device, renderFinishedSemaphores[i], nullptr);
|
|
}
|
|
}
|
|
renderFinishedSemaphores.clear();
|
|
for (size_t i = 0; i < inFlightFences.size(); ++i) {
|
|
if (inFlightFences[i] != VK_NULL_HANDLE) {
|
|
vkDestroyFence(device, inFlightFences[i], nullptr);
|
|
}
|
|
}
|
|
inFlightFences.clear();
|
|
imagesInFlight.clear();
|
|
|
|
if (swapChain != VK_NULL_HANDLE) {
|
|
vkDestroySwapchainKHR(device, swapChain, nullptr);
|
|
swapChain = VK_NULL_HANDLE;
|
|
}
|
|
swapChainImages.clear();
|
|
|
|
if (surface != VK_NULL_HANDLE) {
|
|
vkDestroySurfaceKHR(instance, surface, nullptr);
|
|
surface = VK_NULL_HANDLE;
|
|
}
|
|
|
|
currentFrame = 0;
|
|
_sceondInited = false;
|
|
FACE_DBG_LOG("cleanupForWindowLost: done");
|
|
}
|
|
|
|
bool Application::reinitForNewWindow()
|
|
{
|
|
if (!_applicationInited) {
|
|
FACE_DBG_LOG("reinitForNewWindow: skip, _applicationInited=0 (must go through initVulkan first)");
|
|
return false;
|
|
}
|
|
if (_sceondInited) {
|
|
FACE_DBG_LOG("reinitForNewWindow: skip, already _sceondInited=1");
|
|
return false;
|
|
}
|
|
FACE_DBG_LOG("reinitForNewWindow: begin (prev extent=%ux%u format=%d)",
|
|
_prevSwapChainExtent.width, _prevSwapChainExtent.height,
|
|
(int)_prevSwapChainImageFormat);
|
|
|
|
createSurface();
|
|
createSwapChain();
|
|
|
|
const bool extentChanged = (swapChainExtent.width != _prevSwapChainExtent.width) ||
|
|
(swapChainExtent.height != _prevSwapChainExtent.height);
|
|
const bool formatChanged = (swapChainImageFormat != _prevSwapChainImageFormat);
|
|
const bool swapchainIncompatible = extentChanged || formatChanged;
|
|
|
|
if (formatChanged) {
|
|
// renderPass bakes in swapChainImageFormat, so it must be rebuilt
|
|
// when the surface chose a different format. The old Application
|
|
// graphicsPipeline is tied to the old renderPass, so destroy it
|
|
// first to make the handle invalidation explicit.
|
|
FACE_DBG_LOG("reinitForNewWindow: format changed (%d -> %d), rebuilding renderPass",
|
|
(int)_prevSwapChainImageFormat, (int)swapChainImageFormat);
|
|
if (graphicsPipeline != VK_NULL_HANDLE) {
|
|
vkDestroyPipeline(device, graphicsPipeline, nullptr);
|
|
graphicsPipeline = VK_NULL_HANDLE;
|
|
}
|
|
if (pipelineLayout != VK_NULL_HANDLE) {
|
|
vkDestroyPipelineLayout(device, pipelineLayout, nullptr);
|
|
pipelineLayout = VK_NULL_HANDLE;
|
|
}
|
|
if (renderPass != VK_NULL_HANDLE) {
|
|
vkDestroyRenderPass(device, renderPass, nullptr);
|
|
renderPass = VK_NULL_HANDLE;
|
|
}
|
|
createRenderPass();
|
|
createPipelineLayout();
|
|
createGraphicsPipeline();
|
|
} else if (extentChanged) {
|
|
// renderPass is still fine, but the Application pipeline has a static
|
|
// viewport baked to the old extent and must be rebuilt.
|
|
FACE_DBG_LOG("reinitForNewWindow: extent changed (%ux%u -> %ux%u), rebuilding graphicsPipeline",
|
|
_prevSwapChainExtent.width, _prevSwapChainExtent.height,
|
|
swapChainExtent.width, swapChainExtent.height);
|
|
if (graphicsPipeline != VK_NULL_HANDLE) {
|
|
vkDestroyPipeline(device, graphicsPipeline, nullptr);
|
|
graphicsPipeline = VK_NULL_HANDLE;
|
|
}
|
|
createGraphicsPipeline();
|
|
}
|
|
|
|
createImageViews();
|
|
createFramebuffers();
|
|
createCommandBuffer();
|
|
createSyncObjects();
|
|
|
|
_sceondInited = true;
|
|
FACE_DBG_LOG("reinitForNewWindow: done (imageCount=%zu extent=%ux%u format=%d MAX_FRAMES_IN_FLIGHT=%d swapchainIncompatible=%d)",
|
|
swapChainImages.size(), swapChainExtent.width, swapChainExtent.height,
|
|
(int)swapChainImageFormat, MAX_FRAMES_IN_FLIGHT, (int)swapchainIncompatible);
|
|
return swapchainIncompatible;
|
|
}
|
|
|
|
|
|
|
|
void Application::createImageViews() {
|
|
swapChainImageViews.resize(swapChainImages.size());
|
|
|
|
for (size_t i = 0; i < swapChainImages.size(); i++) {
|
|
VkImageViewCreateInfo createInfo{};
|
|
createInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
|
|
createInfo.image = swapChainImages[i];
|
|
createInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
|
|
createInfo.format = swapChainImageFormat;
|
|
createInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
|
|
createInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
|
|
createInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
|
|
createInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
|
|
createInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
createInfo.subresourceRange.baseMipLevel = 0;
|
|
createInfo.subresourceRange.levelCount = 1;
|
|
createInfo.subresourceRange.baseArrayLayer = 0;
|
|
createInfo.subresourceRange.layerCount = 1;
|
|
|
|
if (vkCreateImageView(device, &createInfo, nullptr, &swapChainImageViews[i]) != VK_SUCCESS) {
|
|
throw std::runtime_error("failed to create image views!");
|
|
}
|
|
}
|
|
}
|
|
|
|
void Application::createFramebuffers() {
|
|
swapChainFramebuffers.resize(swapChainImageViews.size());
|
|
|
|
for (size_t i = 0; i < swapChainImageViews.size(); i++) {
|
|
VkImageView attachments[] = {
|
|
swapChainImageViews[i]
|
|
};
|
|
|
|
VkFramebufferCreateInfo framebufferInfo{};
|
|
framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
|
|
framebufferInfo.renderPass = renderPass;
|
|
framebufferInfo.attachmentCount = 1;
|
|
framebufferInfo.pAttachments = attachments;
|
|
framebufferInfo.width = swapChainExtent.width;
|
|
framebufferInfo.height = swapChainExtent.height;
|
|
framebufferInfo.layers = 1;
|
|
|
|
if (vkCreateFramebuffer(device, &framebufferInfo, nullptr, &swapChainFramebuffers[i]) != VK_SUCCESS) {
|
|
throw std::runtime_error("failed to create framebuffer!");
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void Application::mainLoop()
|
|
{
|
|
#ifdef _WIN32
|
|
static int testFrame = 0;
|
|
while (!glfwWindowShouldClose(window))
|
|
{
|
|
auto cur_time = getCurrentTimeMillis();
|
|
glfwPollEvents();
|
|
auto functionTime = (cur_time - _lastDrawFrameTime);
|
|
_lastDrawFrameTime = getCurrentTimeMillis();
|
|
drawFrame(functionTime); // 在这里调用
|
|
if (testFrame++ == 300) {
|
|
break;
|
|
}
|
|
}
|
|
#else
|
|
|
|
#endif
|
|
vkDeviceWaitIdle(device); // 等待设备空闲
|
|
}
|
|
|
|
|
|
|
|
void Application::createLogicalDevice() {
|
|
QueueFamilyIndices indices = findQueueFamilies(physicalDevice, surface);
|
|
|
|
std::vector<VkDeviceQueueCreateInfo> queueCreateInfos;
|
|
std::set<uint32_t> uniqueQueueFamilies = { indices.graphicsFamily.value(), indices.presentFamily.value() };
|
|
|
|
float queuePriority = 1.0f;
|
|
for (uint32_t queueFamily : uniqueQueueFamilies) {
|
|
VkDeviceQueueCreateInfo queueCreateInfo{};
|
|
queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
|
|
queueCreateInfo.queueFamilyIndex = queueFamily;
|
|
queueCreateInfo.queueCount = 1;
|
|
queueCreateInfo.pQueuePriorities = &queuePriority;
|
|
queueCreateInfos.push_back(queueCreateInfo);
|
|
}
|
|
|
|
VkPhysicalDeviceFeatures deviceFeatures{};
|
|
|
|
VkDeviceCreateInfo createInfo{};
|
|
createInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
|
|
createInfo.queueCreateInfoCount = static_cast<uint32_t>(queueCreateInfos.size());
|
|
createInfo.pQueueCreateInfos = queueCreateInfos.data();
|
|
createInfo.pEnabledFeatures = &deviceFeatures;
|
|
|
|
// 启用交换链扩展
|
|
const std::vector<const char*> deviceExtensions = {
|
|
VK_KHR_SWAPCHAIN_EXTENSION_NAME
|
|
};
|
|
createInfo.enabledExtensionCount = static_cast<uint32_t>(deviceExtensions.size());
|
|
createInfo.ppEnabledExtensionNames = deviceExtensions.data();
|
|
|
|
if (vkCreateDevice(physicalDevice, &createInfo, nullptr, &device) != VK_SUCCESS) {
|
|
throw std::runtime_error("failed to create logical device!");
|
|
}
|
|
|
|
vkGetDeviceQueue(device, indices.graphicsFamily.value(), 0, &graphicsQueue);
|
|
vkGetDeviceQueue(device, indices.presentFamily.value(), 0, &presentQueue);
|
|
}
|
|
|
|
|
|
void Application::createSwapChain() {
|
|
// 选择交换链格式、颜色空间和分辨率
|
|
VkSurfaceFormatKHR surfaceFormat = { VK_FORMAT_R8G8B8A8_SRGB, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR };
|
|
VkPresentModeKHR presentMode = VK_PRESENT_MODE_FIFO_KHR;
|
|
VkSurfaceCapabilitiesKHR surface_capabilities{};
|
|
vkGetPhysicalDeviceSurfaceCapabilitiesKHR(this->physicalDevice, this->surface, &surface_capabilities);
|
|
|
|
VkExtent2D extent = surface_capabilities.currentExtent;
|
|
|
|
uint32_t imageCount = 2;
|
|
// 创建交换链
|
|
VkSwapchainCreateInfoKHR createInfo{};
|
|
createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
|
|
createInfo.surface = surface;
|
|
createInfo.minImageCount = imageCount; // 双缓冲
|
|
createInfo.imageFormat = surfaceFormat.format;
|
|
createInfo.imageColorSpace = surfaceFormat.colorSpace;
|
|
createInfo.imageExtent = extent;
|
|
createInfo.imageArrayLayers = 1;
|
|
createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
|
|
|
|
QueueFamilyIndices indices = findQueueFamilies(physicalDevice, surface);
|
|
uint32_t queueFamilyIndices[] = { indices.graphicsFamily.value(), indices.presentFamily.value() };
|
|
|
|
if (indices.graphicsFamily != indices.presentFamily) {
|
|
createInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
|
|
createInfo.queueFamilyIndexCount = 2;
|
|
createInfo.pQueueFamilyIndices = queueFamilyIndices;
|
|
}
|
|
else {
|
|
createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
|
createInfo.queueFamilyIndexCount = 0; // Optional
|
|
createInfo.pQueueFamilyIndices = nullptr; // Optional
|
|
}
|
|
|
|
createInfo.preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
|
|
createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
|
|
createInfo.presentMode = presentMode;
|
|
createInfo.clipped = VK_TRUE;
|
|
createInfo.oldSwapchain = VK_NULL_HANDLE;
|
|
|
|
if (vkCreateSwapchainKHR(device, &createInfo, nullptr, &swapChain) != VK_SUCCESS) {
|
|
throw std::runtime_error("failed to create swap chain!");
|
|
}
|
|
|
|
|
|
vkGetSwapchainImagesKHR(device, swapChain, &imageCount, nullptr);
|
|
swapChainImages.resize(imageCount);
|
|
vkGetSwapchainImagesKHR(device, swapChain, &imageCount, swapChainImages.data());
|
|
|
|
swapChainImageFormat = surfaceFormat.format;
|
|
swapChainExtent = extent;
|
|
MAX_FRAMES_IN_FLIGHT = imageCount;
|
|
}
|
|
|
|
void Application::createPipelineLayout() {
|
|
VkPipelineLayoutCreateInfo pipelineLayoutInfo{};
|
|
pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
|
|
pipelineLayoutInfo.setLayoutCount = 0; // 可选：描述符集布局
|
|
pipelineLayoutInfo.pSetLayouts = nullptr; // 可选：描述符集布局
|
|
pipelineLayoutInfo.pushConstantRangeCount = 0; // 可选：推送常量范围
|
|
pipelineLayoutInfo.pPushConstantRanges = nullptr; // 可选：推送常量范围
|
|
|
|
if (vkCreatePipelineLayout(device, &pipelineLayoutInfo, nullptr, &pipelineLayout) != VK_SUCCESS) {
|
|
throw std::runtime_error("failed to create pipeline layout!");
|
|
}
|
|
}
|
|
|
|
void Application::createGraphicsPipeline() {
|
|
// 顶点着色器和片段着色器
|
|
auto vertShaderCode = readFile("shaders/simple_shader.vert.spv");
|
|
auto fragShaderCode = readFile("shaders/simple_shader.frag.spv");
|
|
|
|
// 创建着色器模块
|
|
VkShaderModule vertShaderModule = createShaderModule(this->device, vertShaderCode);
|
|
VkShaderModule fragShaderModule = createShaderModule(this->device, fragShaderCode);
|
|
|
|
// 定义着色器阶段
|
|
VkPipelineShaderStageCreateInfo vertShaderStageInfo{};
|
|
vertShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
|
|
vertShaderStageInfo.stage = VK_SHADER_STAGE_VERTEX_BIT;
|
|
vertShaderStageInfo.module = vertShaderModule;
|
|
vertShaderStageInfo.pName = "main";
|
|
|
|
VkPipelineShaderStageCreateInfo fragShaderStageInfo{};
|
|
fragShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
|
|
fragShaderStageInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
|
|
fragShaderStageInfo.module = fragShaderModule;
|
|
fragShaderStageInfo.pName = "main";
|
|
|
|
VkPipelineShaderStageCreateInfo shaderStages[] = { vertShaderStageInfo, fragShaderStageInfo };
|
|
|
|
// 顶点输入状态
|
|
VkPipelineVertexInputStateCreateInfo vertexInputInfo{};
|
|
vertexInputInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
|
|
vertexInputInfo.vertexBindingDescriptionCount = 0;
|
|
vertexInputInfo.pVertexBindingDescriptions = nullptr;
|
|
vertexInputInfo.vertexAttributeDescriptionCount = 0;
|
|
vertexInputInfo.pVertexAttributeDescriptions = nullptr;
|
|
|
|
// 输入组装状态
|
|
VkPipelineInputAssemblyStateCreateInfo inputAssembly{};
|
|
inputAssembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
|
|
inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
|
|
inputAssembly.primitiveRestartEnable = VK_FALSE;
|
|
|
|
// 视口状态
|
|
VkViewport viewport{};
|
|
viewport.x = 0.0f;
|
|
viewport.y = 0.0f;
|
|
viewport.width = (float)swapChainExtent.width;
|
|
viewport.height = (float)swapChainExtent.height;
|
|
viewport.minDepth = 0.0f;
|
|
viewport.maxDepth = 1.0f;
|
|
|
|
VkRect2D scissor{};
|
|
scissor.offset = { 0, 0 };
|
|
scissor.extent = swapChainExtent;
|
|
|
|
VkPipelineViewportStateCreateInfo viewportState{};
|
|
viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
|
|
viewportState.viewportCount = 1;
|
|
viewportState.pViewports = &viewport;
|
|
viewportState.scissorCount = 1;
|
|
viewportState.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.lineWidth = 1.0f;
|
|
rasterizer.cullMode = VK_CULL_MODE_BACK_BIT;
|
|
rasterizer.frontFace = VK_FRONT_FACE_CLOCKWISE;
|
|
rasterizer.depthBiasEnable = VK_FALSE;
|
|
|
|
// 多重采样状态
|
|
VkPipelineMultisampleStateCreateInfo multisampling{};
|
|
multisampling.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
|
|
multisampling.sampleShadingEnable = VK_FALSE;
|
|
multisampling.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
|
|
|
|
// 颜色混合状态
|
|
VkPipelineColorBlendAttachmentState colorBlendAttachment{};
|
|
colorBlendAttachment.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
|
|
colorBlendAttachment.blendEnable = VK_FALSE;
|
|
|
|
VkPipelineColorBlendStateCreateInfo colorBlending{};
|
|
colorBlending.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
|
|
colorBlending.logicOpEnable = VK_FALSE;
|
|
colorBlending.attachmentCount = 1;
|
|
colorBlending.pAttachments = &colorBlendAttachment;
|
|
|
|
// 创建图形管线
|
|
VkGraphicsPipelineCreateInfo pipelineInfo{};
|
|
pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
|
|
pipelineInfo.stageCount = 2;
|
|
pipelineInfo.pStages = shaderStages;
|
|
pipelineInfo.pVertexInputState = &vertexInputInfo;
|
|
pipelineInfo.pInputAssemblyState = &inputAssembly;
|
|
pipelineInfo.pViewportState = &viewportState;
|
|
pipelineInfo.pRasterizationState = &rasterizer;
|
|
pipelineInfo.pMultisampleState = &multisampling;
|
|
pipelineInfo.pColorBlendState = &colorBlending;
|
|
pipelineInfo.layout = pipelineLayout;
|
|
pipelineInfo.renderPass = renderPass;
|
|
pipelineInfo.subpass = 0;
|
|
|
|
if (vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &graphicsPipeline) != VK_SUCCESS) {
|
|
throw std::runtime_error("failed to create graphics pipeline!");
|
|
}
|
|
|
|
// 销毁着色器模块
|
|
vkDestroyShaderModule(device, fragShaderModule, nullptr);
|
|
vkDestroyShaderModule(device, vertShaderModule, nullptr);
|
|
}
|
|
|
|
void Application::createRenderPass() {
|
|
VkAttachmentDescription colorAttachment{};
|
|
colorAttachment.format = swapChainImageFormat;
|
|
colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
|
|
colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
|
|
colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
|
|
colorAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
|
|
colorAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
|
|
colorAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
|
colorAttachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
|
|
|
|
VkAttachmentReference colorAttachmentRef{};
|
|
colorAttachmentRef.attachment = 0;
|
|
colorAttachmentRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
|
|
|
|
VkSubpassDescription subpass{};
|
|
subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
|
|
subpass.colorAttachmentCount = 1;
|
|
subpass.pColorAttachments = &colorAttachmentRef;
|
|
|
|
VkRenderPassCreateInfo renderPassInfo{};
|
|
renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
|
|
renderPassInfo.attachmentCount = 1;
|
|
renderPassInfo.pAttachments = &colorAttachment;
|
|
renderPassInfo.subpassCount = 1;
|
|
renderPassInfo.pSubpasses = &subpass;
|
|
|
|
if (vkCreateRenderPass(device, &renderPassInfo, nullptr, &renderPass) != VK_SUCCESS) {
|
|
throw std::runtime_error("failed to create render pass!");
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void Application::createCommandPool() {
|
|
QueueFamilyIndices queueFamilyIndices = findQueueFamilies(physicalDevice, surface);
|
|
|
|
VkCommandPoolCreateInfo poolInfo{};
|
|
poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
|
|
poolInfo.queueFamilyIndex = queueFamilyIndices.graphicsFamily.value();
|
|
poolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT; // 添加标志
|
|
|
|
if (vkCreateCommandPool(device, &poolInfo, nullptr, &commandPool) != VK_SUCCESS) {
|
|
throw std::runtime_error("failed to create command pool!");
|
|
}
|
|
|
|
queueFamilyIndices = findQueueFamilies(physicalDevice, surface);
|
|
|
|
VkCommandPoolCreateInfo poolInfo_ex{};
|
|
poolInfo_ex.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
|
|
poolInfo_ex.queueFamilyIndex = queueFamilyIndices.graphicsFamily.value();
|
|
poolInfo_ex.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT; // 添加标志
|
|
|
|
if (vkCreateCommandPool(device, &poolInfo_ex, nullptr, &commandPool_ex) != VK_SUCCESS) {
|
|
throw std::runtime_error("failed to create command pool!");
|
|
}
|
|
}
|
|
|
|
void Application::createCommandBuffer()
|
|
{
|
|
commandBuffers.resize(MAX_FRAMES_IN_FLIGHT);
|
|
VkCommandBufferAllocateInfo allocInfo{};
|
|
allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
|
|
allocInfo.commandPool = commandPool;
|
|
allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
|
|
allocInfo.commandBufferCount = (uint32_t)MAX_FRAMES_IN_FLIGHT;
|
|
|
|
if (vkAllocateCommandBuffers(device, &allocInfo, commandBuffers.data()) != VK_SUCCESS) {
|
|
throw std::runtime_error("failed to allocate command buffers!");
|
|
}
|
|
}
|
|
|
|
void Application::createSyncObjects()
|
|
{
|
|
imageAvailableSemaphores.resize(MAX_FRAMES_IN_FLIGHT);
|
|
renderFinishedSemaphores.resize(MAX_FRAMES_IN_FLIGHT);
|
|
inFlightFences.resize(MAX_FRAMES_IN_FLIGHT);
|
|
imagesInFlight.resize(MAX_FRAMES_IN_FLIGHT, VK_NULL_HANDLE);
|
|
|
|
VkSemaphoreCreateInfo semaphoreInfo{};
|
|
semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
|
|
|
|
VkFenceCreateInfo fenceInfo{};
|
|
fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
|
|
fenceInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
|
|
|
|
for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
|
|
if (vkCreateSemaphore(device, &semaphoreInfo, nullptr, &imageAvailableSemaphores[i]) != VK_SUCCESS ||
|
|
vkCreateSemaphore(device, &semaphoreInfo, nullptr, &renderFinishedSemaphores[i]) != VK_SUCCESS) {
|
|
throw std::runtime_error("failed to create synchronization objects!");
|
|
}
|
|
if (vkCreateFence(device, &fenceInfo, nullptr, &inFlightFences[i]) != VK_SUCCESS) {
|
|
throw std::runtime_error("failed to create synchronization objects!");
|
|
}
|
|
}
|
|
}
|
|
|
|
void Application::recordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t imageIndex, long long frameTime)
|
|
{
|
|
VkCommandBufferBeginInfo beginInfo{};
|
|
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
|
|
beginInfo.flags = 0; // 可选标志
|
|
beginInfo.pInheritanceInfo = nullptr; // 仅用于次级命令缓冲区
|
|
|
|
if (vkBeginCommandBuffer(commandBuffer, &beginInfo) != VK_SUCCESS) {
|
|
throw std::runtime_error("failed to begin recording command buffer!");
|
|
}
|
|
|
|
// 开始渲染流程
|
|
VkRenderPassBeginInfo renderPassInfo{};
|
|
renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
|
|
renderPassInfo.renderPass = renderPass;
|
|
renderPassInfo.framebuffer = swapChainFramebuffers[imageIndex]; // 使用正确的imageIndex
|
|
renderPassInfo.renderArea.offset = { 0, 0 };
|
|
renderPassInfo.renderArea.extent = swapChainExtent;
|
|
|
|
VkClearValue clearColor = { {{0.0f, 0.0f, 0.0f, 1.0f}} };
|
|
renderPassInfo.clearValueCount = 1;
|
|
renderPassInfo.pClearValues = &clearColor;
|
|
|
|
vkCmdBeginRenderPass(commandBuffer, &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);
|
|
|
|
render(commandBuffer, frameTime);
|
|
|
|
// 结束渲染流程
|
|
vkCmdEndRenderPass(commandBuffer);
|
|
|
|
if (vkEndCommandBuffer(commandBuffer) != VK_SUCCESS) {
|
|
throw std::runtime_error("failed to record command buffer!");
|
|
}
|
|
}
|
|
|
|
void Application::render(VkCommandBuffer commandBuffer, long long frameTime)
|
|
{
|
|
// 绑定图形管线
|
|
vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, graphicsPipeline);
|
|
|
|
// 绘制三角形
|
|
vkCmdDraw(commandBuffer, 3, 1, 0, 0);
|
|
}
|
|
|
|
void Application::drawFrame(long long frameTime)
|
|
{
|
|
static uint64_t s_drawFrameCount = 0;
|
|
++s_drawFrameCount;
|
|
|
|
// 1. 等待前一帧完成
|
|
VkResult waitRes = vkWaitForFences(device, 1, &inFlightFences[currentFrame], VK_TRUE, UINT64_MAX);
|
|
if (waitRes != VK_SUCCESS) {
|
|
#ifndef _WIN32
|
|
DebugLog::log_throttled("drawFrame.waitFences",
|
|
"drawFrame[%llu] vkWaitForFences -> %d (%s) currentFrame=%u",
|
|
(unsigned long long)s_drawFrameCount,
|
|
(int)waitRes, VkResultStr(waitRes), currentFrame);
|
|
#endif
|
|
}
|
|
|
|
// 2. 获取交换链图像
|
|
uint32_t imageIndex;
|
|
VkResult result = vkAcquireNextImageKHR(device, swapChain, UINT64_MAX, imageAvailableSemaphores[currentFrame], VK_NULL_HANDLE, &imageIndex);
|
|
if (result != VK_SUCCESS) {
|
|
#ifndef _WIN32
|
|
DebugLog::log_throttled("drawFrame.acquire",
|
|
"drawFrame[%llu] vkAcquireNextImageKHR -> %d (%s) currentFrame=%u",
|
|
(unsigned long long)s_drawFrameCount,
|
|
(int)result, VkResultStr(result), currentFrame);
|
|
#endif
|
|
throw std::runtime_error("failed to acquire swap chain image!");
|
|
}
|
|
|
|
// 3. 检查该图像是否正在被之前的帧使用
|
|
if (imagesInFlight[imageIndex] != VK_NULL_HANDLE) {
|
|
vkWaitForFences(device, 1, &imagesInFlight[imageIndex], VK_TRUE, UINT64_MAX);
|
|
}
|
|
imagesInFlight[imageIndex] = inFlightFences[currentFrame];
|
|
|
|
// 4. 重置栅栏
|
|
vkResetFences(device, 1, &inFlightFences[currentFrame]);
|
|
|
|
// 5. 记录命令缓冲区
|
|
vkResetCommandBuffer(commandBuffers[currentFrame], 0);
|
|
recordCommandBuffer(commandBuffers[currentFrame], imageIndex, frameTime);
|
|
|
|
// 6. 提交命令缓冲区
|
|
VkSubmitInfo submitInfo{};
|
|
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
|
|
VkSemaphore waitSemaphores[] = { imageAvailableSemaphores[currentFrame] };
|
|
VkPipelineStageFlags waitStages[] = { VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT };
|
|
submitInfo.waitSemaphoreCount = 1;
|
|
submitInfo.pWaitSemaphores = waitSemaphores;
|
|
submitInfo.pWaitDstStageMask = waitStages;
|
|
submitInfo.commandBufferCount = 1;
|
|
submitInfo.pCommandBuffers = &commandBuffers[currentFrame];
|
|
VkSemaphore signalSemaphores[] = { renderFinishedSemaphores[imageIndex] };
|
|
submitInfo.signalSemaphoreCount = 1;
|
|
submitInfo.pSignalSemaphores = signalSemaphores;
|
|
|
|
VkResult submitRes = vkQueueSubmit(graphicsQueue, 1, &submitInfo, inFlightFences[currentFrame]);
|
|
if (submitRes != VK_SUCCESS) {
|
|
#ifndef _WIN32
|
|
DebugLog::log_throttled("drawFrame.submit",
|
|
"drawFrame[%llu] vkQueueSubmit -> %d (%s) currentFrame=%u imageIndex=%u",
|
|
(unsigned long long)s_drawFrameCount,
|
|
(int)submitRes, VkResultStr(submitRes),
|
|
currentFrame, imageIndex);
|
|
#endif
|
|
throw std::runtime_error("failed to submit draw command buffer!");
|
|
}
|
|
// 7. 呈现图像
|
|
VkPresentInfoKHR presentInfo{};
|
|
presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
|
|
presentInfo.waitSemaphoreCount = 1;
|
|
presentInfo.pWaitSemaphores = signalSemaphores;
|
|
VkSwapchainKHR swapChains[] = { swapChain };
|
|
presentInfo.swapchainCount = 1;
|
|
presentInfo.pSwapchains = swapChains;
|
|
presentInfo.pImageIndices = &imageIndex;
|
|
result = vkQueuePresentKHR(presentQueue, &presentInfo);
|
|
|
|
if (result != VK_SUCCESS) {
|
|
#ifndef _WIN32
|
|
DebugLog::log_throttled("drawFrame.present",
|
|
"drawFrame[%llu] vkQueuePresentKHR -> %d (%s) currentFrame=%u imageIndex=%u",
|
|
(unsigned long long)s_drawFrameCount,
|
|
(int)result, VkResultStr(result),
|
|
currentFrame, imageIndex);
|
|
#endif
|
|
throw std::runtime_error("failed to present swap chain image!");
|
|
}
|
|
|
|
// 8. 前进到下一帧
|
|
currentFrame = (currentFrame + 1) % MAX_FRAMES_IN_FLIGHT;
|
|
}
|
|
|
|
void DestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT debugMessenger, const VkAllocationCallbacks* pAllocator) {
|
|
auto func = (PFN_vkDestroyDebugUtilsMessengerEXT)vkGetInstanceProcAddr(instance, "vkDestroyDebugUtilsMessengerEXT");
|
|
if (func != nullptr) {
|
|
func(instance, debugMessenger, pAllocator);
|
|
}
|
|
}
|
|
|
|
void Application::cleanup() {
|
|
if (enableValidationLayers) {
|
|
DestroyDebugUtilsMessengerEXT(instance, debugMessenger, nullptr);
|
|
}
|
|
|
|
|
|
vkDeviceWaitIdle(device);
|
|
|
|
for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
|
|
vkDestroySemaphore(device, imageAvailableSemaphores[i], nullptr);
|
|
vkDestroySemaphore(device, renderFinishedSemaphores[i], nullptr);
|
|
vkDestroyFence(device, inFlightFences[i], nullptr);
|
|
}
|
|
|
|
|
|
|
|
vkDestroyPipeline(device, graphicsPipeline, nullptr);
|
|
|
|
vkDestroyPipelineLayout(device, pipelineLayout, nullptr);
|
|
|
|
vkDestroyRenderPass(device, renderPass, nullptr);
|
|
for (auto imageView : swapChainImageViews) {
|
|
vkDestroyImageView(device, imageView, nullptr);
|
|
}
|
|
|
|
for (auto framebuffer : swapChainFramebuffers)
|
|
{
|
|
if (framebuffer != VK_NULL_HANDLE)
|
|
{
|
|
vkDestroyFramebuffer(device, framebuffer, nullptr);
|
|
}
|
|
}
|
|
swapChainFramebuffers.clear();
|
|
|
|
vkDestroySwapchainKHR(device, swapChain, nullptr);
|
|
|
|
vkDestroyDevice(device, nullptr);
|
|
vkDestroySurfaceKHR(instance, surface, nullptr);
|
|
vkDestroyInstance(instance, nullptr);
|
|
|
|
|
|
|
|
#ifdef _WIN32
|
|
glfwDestroyWindow(window);
|
|
glfwTerminate();
|
|
#endif
|
|
}
|
|
|
|
|
|
uint32_t Application::findMemoryType(VkPhysicalDevice physicalDevice, uint32_t typeFilter,
|
|
VkMemoryPropertyFlags properties)
|
|
{
|
|
VkPhysicalDeviceMemoryProperties memProperties;
|
|
vkGetPhysicalDeviceMemoryProperties(physicalDevice, &memProperties);
|
|
|
|
for (uint32_t i = 0; i < memProperties.memoryTypeCount; i++)
|
|
{
|
|
if ((typeFilter & (1 << i)) &&
|
|
(memProperties.memoryTypes[i].propertyFlags & properties) == properties)
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
|
|
throw std::runtime_error("Failed to find suitable memory type!");
|
|
}
|
|
|
|
void Application::loadTexture(std::string path, Texture& tex, bool srgb, VkCommandPool pool)
|
|
{
|
|
std::vector<unsigned char> data = readFileUnsignedChar(path, false);
|
|
std::vector<unsigned char> image;
|
|
unsigned w, h;
|
|
unsigned error = lodepng::decode(image, w, h, data, LCT_RGBA, 8);
|
|
processWithVulkan(image.data(), w, h, w * 4, image.size(), tex, srgb, pool, path);
|
|
//return tex;
|
|
}
|
|
|
|
void Application::loadTexture(std::vector<unsigned char>& image_data, size_t image_size, int w, int h, Texture& tex, bool srgb, VkCommandPool pool, std::string path)
|
|
{
|
|
processWithVulkan(image_data.data(), w, h, w * 4, image_size, tex, srgb, pool, path);
|
|
//return tex;
|
|
}
|
|
|
|
#ifdef _WIN32
|
|
void Application::loadTextureExample(std::wstring path, Texture& tex, bool srgb, VkCommandPool pool)
|
|
{
|
|
std::vector<unsigned char> data = readFileUnsignedCharWin32(path, true);
|
|
std::vector<unsigned char> image;
|
|
unsigned w, h;
|
|
unsigned error = lodepng::decode(image, w, h, data, LCT_RGBA, 8);
|
|
std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
|
|
std::string str = converter.to_bytes(path);
|
|
processWithVulkan(image.data(), w, h, w * 4, image.size(), tex, srgb, pool, str);
|
|
//return tex;
|
|
}
|
|
|
|
#endif // _WIN32
|
|
|
|
|
|
|
|
|
|
void Application::createTexture(VkDevice device, VkPhysicalDevice physicalDevice, int width, int height, Texture& texture, bool srgb, std::string tex_path, size_t dataSize)
|
|
{
|
|
texture.width = width;
|
|
texture.height = height;
|
|
texture.mip_levels = 1;
|
|
|
|
VkImageCreateInfo imageInfo = {};
|
|
imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
|
|
imageInfo.imageType = VK_IMAGE_TYPE_2D;
|
|
if (srgb)
|
|
{
|
|
imageInfo.format = VK_FORMAT_R8G8B8A8_SRGB;
|
|
}
|
|
else
|
|
{
|
|
imageInfo.format = VK_FORMAT_R8G8B8A8_UNORM;// VK_FORMAT_R8G8B8A8_SRGB; //VK_FORMAT_R8G8B8A8_UNORM;
|
|
}
|
|
imageInfo.extent.width = width;
|
|
imageInfo.extent.height = height;
|
|
imageInfo.extent.depth = 1;
|
|
imageInfo.mipLevels = 1;
|
|
imageInfo.arrayLayers = 1;
|
|
imageInfo.samples = VK_SAMPLE_COUNT_1_BIT;
|
|
imageInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
|
|
imageInfo.usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
|
|
imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
|
imageInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
|
|
|
if (vkCreateImage(device, &imageInfo, nullptr, &texture.image) != VK_SUCCESS)
|
|
{
|
|
throw std::runtime_error("Failed to create image!");
|
|
}
|
|
|
|
VkMemoryRequirements memRequirements;
|
|
vkGetImageMemoryRequirements(device, texture.image, &memRequirements);
|
|
|
|
VkMemoryAllocateInfo allocInfo = {};
|
|
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
|
|
allocInfo.allocationSize = memRequirements.size;
|
|
allocInfo.memoryTypeIndex = findMemoryType(physicalDevice,
|
|
memRequirements.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
|
|
|
|
if (vkAllocateMemory(device, &allocInfo, nullptr, &texture.device_memory) != VK_SUCCESS)
|
|
{
|
|
throw std::runtime_error("Failed to allocate image memory!");
|
|
}
|
|
|
|
std::cout << "vkAllocateMemory device_memory " << tex_path << ": " << texture.device_memory << std::endl;
|
|
|
|
vkBindImageMemory(device, texture.image, texture.device_memory, 0);
|
|
|
|
VkImageViewCreateInfo viewInfo = {};
|
|
viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
|
|
viewInfo.image = texture.image;
|
|
viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
|
|
if (srgb)
|
|
{
|
|
viewInfo.format = VK_FORMAT_R8G8B8A8_SRGB;
|
|
}
|
|
else
|
|
{
|
|
viewInfo.format = VK_FORMAT_R8G8B8A8_UNORM;// VK_FORMAT_R8G8B8A8_SRGB; // VK_FORMAT_R8G8B8A8_UNORM;
|
|
}
|
|
viewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
viewInfo.subresourceRange.baseMipLevel = 0;
|
|
viewInfo.subresourceRange.levelCount = 1;
|
|
viewInfo.subresourceRange.baseArrayLayer = 0;
|
|
viewInfo.subresourceRange.layerCount = 1;
|
|
|
|
if (vkCreateImageView(device, &viewInfo, nullptr, &texture.view) != VK_SUCCESS)
|
|
{
|
|
throw std::runtime_error("Failed to create texture image view!");
|
|
}
|
|
|
|
VkSamplerCreateInfo samplerInfo = {};
|
|
samplerInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
|
|
samplerInfo.magFilter = VK_FILTER_LINEAR;
|
|
samplerInfo.minFilter = VK_FILTER_LINEAR;
|
|
samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
|
|
samplerInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
|
|
samplerInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
|
|
samplerInfo.anisotropyEnable = VK_FALSE;
|
|
samplerInfo.maxAnisotropy = 1.0f;
|
|
samplerInfo.borderColor = VK_BORDER_COLOR_INT_OPAQUE_BLACK;
|
|
samplerInfo.unnormalizedCoordinates = VK_FALSE;
|
|
samplerInfo.compareEnable = VK_FALSE;
|
|
samplerInfo.compareOp = VK_COMPARE_OP_ALWAYS;
|
|
samplerInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
|
|
samplerInfo.mipLodBias = 0.0f;
|
|
samplerInfo.minLod = 0.0f;
|
|
samplerInfo.maxLod = 0.0f;
|
|
|
|
if (vkCreateSampler(device, &samplerInfo, nullptr, &texture.sampler) != VK_SUCCESS)
|
|
{
|
|
throw std::runtime_error("Failed to create texture sampler!");
|
|
}
|
|
|
|
if (texture.stagingBuffer == nullptr)
|
|
{
|
|
VkBufferCreateInfo bufferInfo = {};
|
|
bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
|
|
bufferInfo.size = dataSize;
|
|
bufferInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
|
|
bufferInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
|
|
|
if (vkCreateBuffer(device, &bufferInfo, nullptr, &texture.stagingBuffer) != VK_SUCCESS)
|
|
{
|
|
throw std::runtime_error("Failed to create staging buffer!");
|
|
}
|
|
}
|
|
|
|
if (texture.stagingBufferMemory == nullptr)
|
|
{
|
|
VkMemoryRequirements memRequirements;
|
|
vkGetBufferMemoryRequirements(device, texture.stagingBuffer, &memRequirements);
|
|
|
|
VkMemoryAllocateInfo allocInfo = {};
|
|
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
|
|
allocInfo.allocationSize = memRequirements.size;
|
|
allocInfo.memoryTypeIndex = findMemoryType(physicalDevice,
|
|
memRequirements.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
|
|
|
|
if (vkAllocateMemory(device, &allocInfo, nullptr, &texture.stagingBufferMemory) != VK_SUCCESS)
|
|
{
|
|
throw std::runtime_error("Failed to allocate staging buffer memory!");
|
|
}
|
|
|
|
std::cout << "vkAllocateMemory stagingBufferMemory " << tex_path << ": " << texture.stagingBufferMemory << std::endl;
|
|
|
|
vkBindBufferMemory(device, texture.stagingBuffer, texture.stagingBufferMemory, 0);
|
|
}
|
|
|
|
texture.image_layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
|
|
texture.device = device;
|
|
texture.texture_path = tex_path;
|
|
}
|
|
|
|
void Application::processWithVulkan(uint8_t* data, int width, int height, int rowStride, size_t dataSize, Texture& texture, bool srgb, VkCommandPool pool, std::string tex_path)
|
|
{
|
|
std::unique_lock<std::mutex> lock(createTextureMtx);
|
|
if (texture.image == VK_NULL_HANDLE)
|
|
{
|
|
createTexture(device, physicalDevice, width, height, texture, srgb, tex_path, dataSize);
|
|
}
|
|
|
|
updateTexture(device, physicalDevice, pool, graphicsQueue, data, width, height,
|
|
rowStride, dataSize, texture);
|
|
}
|
|
|
|
|
|
VkCommandBuffer Application::beginSingleTimeCommands(VkDevice device, VkCommandPool commandPool)
|
|
{
|
|
VkCommandBufferAllocateInfo allocInfo = {};
|
|
allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
|
|
allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
|
|
allocInfo.commandPool = commandPool;
|
|
allocInfo.commandBufferCount = 1;
|
|
|
|
VkCommandBuffer commandBuffer;
|
|
vkAllocateCommandBuffers(device, &allocInfo, &commandBuffer);
|
|
|
|
VkCommandBufferBeginInfo beginInfo = {};
|
|
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
|
|
beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
|
|
|
|
vkBeginCommandBuffer(commandBuffer, &beginInfo);
|
|
|
|
return commandBuffer;
|
|
}
|
|
|
|
void Application::endSingleTimeCommands(VkDevice device, VkCommandPool commandPool,
|
|
VkQueue queue, VkCommandBuffer commandBuffer)
|
|
{
|
|
vkEndCommandBuffer(commandBuffer);
|
|
|
|
VkSubmitInfo submitInfo = {};
|
|
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
|
|
submitInfo.commandBufferCount = 1;
|
|
submitInfo.pCommandBuffers = &commandBuffer;
|
|
|
|
vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE);
|
|
vkQueueWaitIdle(queue);
|
|
|
|
vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer);
|
|
}
|
|
|
|
|
|
void Application::updateTexture(VkDevice device, VkPhysicalDevice physicalDevice,
|
|
VkCommandPool commandPool, VkQueue queue,
|
|
uint8_t* data, int width, int height,
|
|
int rowStride, size_t dataSize, Texture& texture)
|
|
{
|
|
//VkBuffer stagingBuffer;
|
|
//VkDeviceMemory stagingBufferMemory;
|
|
|
|
void* mappedData;
|
|
vkMapMemory(device, texture.stagingBufferMemory, 0, dataSize, 0, &mappedData);
|
|
|
|
if (rowStride == width * 4)
|
|
{
|
|
memcpy(mappedData, data, dataSize);
|
|
}
|
|
else
|
|
{
|
|
uint8_t* dst = static_cast<uint8_t*>(mappedData);
|
|
const uint8_t* src = data;
|
|
size_t dstRowStride = width * 4;
|
|
|
|
for (int y = 0; y < height; y++)
|
|
{
|
|
memcpy(dst, src, dstRowStride);
|
|
dst += dstRowStride;
|
|
src += rowStride;
|
|
}
|
|
}
|
|
|
|
vkUnmapMemory(device, texture.stagingBufferMemory);
|
|
|
|
VkCommandBuffer commandBuffer = beginSingleTimeCommands(device, commandPool);
|
|
|
|
transitionImageLayout(commandBuffer, texture.image,
|
|
VK_IMAGE_LAYOUT_UNDEFINED,
|
|
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
|
|
|
|
VkBufferImageCopy region = {};
|
|
region.bufferOffset = 0;
|
|
region.bufferRowLength = 0;
|
|
region.bufferImageHeight = 0;
|
|
region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
region.imageSubresource.mipLevel = 0;
|
|
region.imageSubresource.baseArrayLayer = 0;
|
|
region.imageSubresource.layerCount = 1;
|
|
region.imageOffset = { 0, 0, 0 };
|
|
region.imageExtent = { static_cast<uint32_t>(width),
|
|
static_cast<uint32_t>(height), 1 };
|
|
|
|
vkCmdCopyBufferToImage(commandBuffer, texture.stagingBuffer, texture.image,
|
|
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ®ion);
|
|
|
|
transitionImageLayout(commandBuffer, texture.image,
|
|
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
|
|
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
|
|
|
|
endSingleTimeCommands(device, commandPool, queue, commandBuffer);
|
|
|
|
|
|
texture.image_layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
|
|
}
|
|
|
|
|
|
void Application::transitionImageLayout(VkCommandBuffer commandBuffer, VkImage image,
|
|
VkImageLayout oldLayout, VkImageLayout newLayout)
|
|
{
|
|
VkImageMemoryBarrier barrier = {};
|
|
barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
|
|
barrier.oldLayout = oldLayout;
|
|
barrier.newLayout = newLayout;
|
|
barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
|
|
barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
|
|
barrier.image = image;
|
|
barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
barrier.subresourceRange.baseMipLevel = 0;
|
|
barrier.subresourceRange.levelCount = 1;
|
|
barrier.subresourceRange.baseArrayLayer = 0;
|
|
barrier.subresourceRange.layerCount = 1;
|
|
|
|
VkPipelineStageFlags sourceStage;
|
|
VkPipelineStageFlags destinationStage;
|
|
|
|
if (oldLayout == VK_IMAGE_LAYOUT_UNDEFINED &&
|
|
newLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL)
|
|
{
|
|
barrier.srcAccessMask = 0;
|
|
barrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
|
|
|
|
sourceStage = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
|
|
destinationStage = VK_PIPELINE_STAGE_TRANSFER_BIT;
|
|
}
|
|
else if (oldLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL &&
|
|
newLayout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL)
|
|
{
|
|
barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
|
|
barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
|
|
|
|
sourceStage = VK_PIPELINE_STAGE_TRANSFER_BIT;
|
|
destinationStage = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
|
|
}
|
|
else
|
|
{
|
|
throw std::invalid_argument("Unsupported layout transition!");
|
|
}
|
|
|
|
vkCmdPipelineBarrier(commandBuffer, sourceStage, destinationStage, 0,
|
|
0, nullptr, 0, nullptr, 1, &barrier);
|
|
}
|
|
|
|
void Application::destroy_texture(Texture texture)
|
|
{
|
|
vkDestroyImageView(device, texture.view, nullptr);
|
|
vkDestroyImage(device, texture.image, nullptr);
|
|
vkDestroySampler(device, texture.sampler, nullptr);
|
|
vkFreeMemory(device, texture.device_memory, nullptr);
|
|
} |