1483 lines
47 KiB
C++
1483 lines
47 KiB
C++
// VulkanTutorial.cpp: 定义应用程序的入口点。
|
||
//
|
||
|
||
#include "VulkanTutorial.h"
|
||
|
||
const int Width = 800;
|
||
const int Height = 600;
|
||
|
||
const std::vector<const char*> validationLayers = {
|
||
"VK_LAYER_KHRONOS_validation"
|
||
|
||
};
|
||
|
||
const std::vector<const char*> swapchainExtensions = {
|
||
VK_KHR_SWAPCHAIN_EXTENSION_NAME
|
||
};
|
||
|
||
#ifdef NDEBUG
|
||
const bool enableValidationLayers = false;
|
||
#else
|
||
const bool enableValidationLayers = true;
|
||
#endif // NDEBUG
|
||
|
||
//window init
|
||
void HelloTriangleApplication::initWindow(int Width, int Height) {
|
||
glfwInit();
|
||
glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
|
||
glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE);
|
||
window = glfwCreateWindow(Width, Height, "vulkan", nullptr, nullptr);
|
||
glfwSetWindowUserPointer(window, this);
|
||
glfwSetFramebufferSizeCallback(window, framebufferResizeCallback);
|
||
|
||
}
|
||
// vulkan instace create
|
||
void HelloTriangleApplication::createInstance() {
|
||
|
||
// check validation layers
|
||
if (enableValidationLayers && ! checkValidationLayerSupport())
|
||
{
|
||
throw std::runtime_error("validation layers requsted,but not available");
|
||
}
|
||
|
||
//setup appliaction info
|
||
VkApplicationInfo appInfo{};
|
||
|
||
appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
|
||
appInfo.pApplicationName = "Hello Triangle";
|
||
appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
|
||
appInfo.pEngineName = "No_Engine";
|
||
appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0);
|
||
appInfo.apiVersion = VK_API_VERSION_1_0;
|
||
|
||
// setup createInfo
|
||
VkInstanceCreateInfo createInfo{};
|
||
createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
|
||
createInfo.pApplicationInfo = &appInfo;
|
||
|
||
auto requiredExtensions = getRequiredExtensions();
|
||
createInfo.enabledExtensionCount = static_cast<uint32_t>(requiredExtensions.size());
|
||
createInfo.ppEnabledExtensionNames = requiredExtensions.data();
|
||
|
||
|
||
/* enable glfw extension in creatInfo
|
||
uint32_t glfwExtentionCount = 0;
|
||
const char** glfwExtensions;
|
||
glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtentionCount);
|
||
createInfo.enabledExtensionCount = glfwExtentionCount;
|
||
createInfo.ppEnabledExtensionNames = glfwExtensions;
|
||
*/
|
||
|
||
// enable validation layer if available in createInfo
|
||
VkDebugUtilsMessengerCreateInfoEXT debugCreateInfo{};
|
||
if (enableValidationLayers)
|
||
{
|
||
createInfo.enabledLayerCount = static_cast<uint32_t>(validationLayers.size());
|
||
createInfo.ppEnabledLayerNames = validationLayers.data();
|
||
|
||
populateDebugMessengerCreateInfo(debugCreateInfo);
|
||
createInfo.pNext = (VkDebugUtilsMessengerCreateInfoEXT*) &debugCreateInfo;
|
||
}
|
||
else
|
||
{
|
||
createInfo.enabledLayerCount = 0;
|
||
|
||
createInfo.pNext = nullptr;
|
||
}
|
||
|
||
// throw error in creating instance
|
||
if (vkCreateInstance(&createInfo, nullptr, &instance)!=VK_SUCCESS)
|
||
{
|
||
throw std::runtime_error("failed to create instance");
|
||
}
|
||
|
||
|
||
|
||
}
|
||
|
||
|
||
|
||
void HelloTriangleApplication::initVulkan() {
|
||
|
||
createInstance();
|
||
|
||
//showAvailableExtension();
|
||
|
||
setupDebugMessenger();
|
||
|
||
createSurface();
|
||
|
||
pickPhysicalDevice();
|
||
|
||
createLogicalDevice();
|
||
|
||
createSwapChain();
|
||
|
||
createImageView();
|
||
|
||
createRenderPass();
|
||
createDescriptorSetLayout();
|
||
createGraphicPipeline();
|
||
|
||
creatFramebuffers();
|
||
|
||
createCommandPool();
|
||
|
||
createVertexBuffer();
|
||
createIndexBuffer();
|
||
createUniformBuffers();
|
||
|
||
createDescriptorPool();
|
||
createDescriptorSets();
|
||
|
||
createCommandBuffer();
|
||
|
||
createSyncObjects();
|
||
|
||
}
|
||
|
||
|
||
|
||
void HelloTriangleApplication::mainLoop(GLFWwindow* window){
|
||
|
||
while (!glfwWindowShouldClose(window))
|
||
{
|
||
glfwPollEvents();
|
||
drawFrame();
|
||
}
|
||
|
||
vkDeviceWaitIdle(device);
|
||
|
||
}
|
||
|
||
|
||
|
||
void HelloTriangleApplication::cleanup(GLFWwindow* window) {
|
||
|
||
std::cout << "\n======== start to destroy resource ========\n" << std::endl;
|
||
|
||
cleanupSwapChain();
|
||
|
||
for (size_t i = 0; i < MAX_FRAME_IN_FLIGHT; i++)
|
||
{
|
||
vkDestroyBuffer(device, uniformBuffers[i], nullptr);
|
||
vkFreeMemory(device, uniformBuffersMemory[i], nullptr);
|
||
}
|
||
vkDestroyDescriptorPool(device, descriptorPool, nullptr);
|
||
vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr);
|
||
|
||
vkDestroyBuffer(device, indexBuffer, nullptr);
|
||
vkFreeMemory(device, indexBufferMemory, nullptr);
|
||
vkDestroyBuffer(device, vertexBuffer, nullptr);
|
||
vkFreeMemory(device, vertexBufferMemory, nullptr);
|
||
|
||
vkDestroyPipeline(device, graphicsPipeline, nullptr);
|
||
vkDestroyPipelineLayout(device, pipelineLayout, nullptr);
|
||
vkDestroyRenderPass(device, renderPass, nullptr);
|
||
|
||
for (size_t i = 0; i < MAX_FRAME_IN_FLIGHT; i++)
|
||
{
|
||
vkDestroySemaphore(device, imageAvailableSemaphores[i], nullptr);
|
||
vkDestroySemaphore(device, renderFinishedSemaphores[i], nullptr);
|
||
vkDestroyFence(device, inFlightFences[i], nullptr);
|
||
}
|
||
|
||
|
||
vkDestroyCommandPool(device, commandPool, nullptr);
|
||
|
||
vkDestroyDevice(device, nullptr);
|
||
|
||
if (enableValidationLayers)
|
||
{
|
||
DestroyDebugUtilsMessengerEXT(instance, debugMessenger, nullptr);
|
||
}
|
||
|
||
vkDestroySurfaceKHR(instance, surface, nullptr);
|
||
|
||
vkDestroyInstance(instance, nullptr);
|
||
|
||
glfwDestroyWindow(window);
|
||
|
||
glfwTerminate();
|
||
|
||
|
||
}
|
||
|
||
std::vector<const char*> HelloTriangleApplication::getRequiredExtensions() {
|
||
uint32_t glfwExtensionCount = 0;
|
||
const char** glfwExtensions;
|
||
glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
|
||
|
||
std::vector<const char*> extensions(glfwExtensions, glfwExtensions + glfwExtensionCount);
|
||
|
||
if (enableValidationLayers)
|
||
{
|
||
extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
|
||
|
||
}
|
||
|
||
return extensions;
|
||
|
||
}
|
||
|
||
void HelloTriangleApplication::showAvailableExtension()
|
||
{
|
||
// show available extensions
|
||
uint32_t availableExtensionCount = 0;
|
||
vkEnumerateInstanceExtensionProperties(nullptr, &availableExtensionCount, nullptr);
|
||
std::vector<VkExtensionProperties> availableExtensions(availableExtensionCount);
|
||
vkEnumerateInstanceExtensionProperties(nullptr, &availableExtensionCount, availableExtensions.data());
|
||
std::cout << "available extensions :" << std::endl;
|
||
for (const auto& extension : availableExtensions)
|
||
{
|
||
std::cout << "\t" << extension.extensionName << " ver:" << extension.specVersion << std::endl;
|
||
}
|
||
}
|
||
|
||
VKAPI_ATTR VkBool32 VKAPI_CALL HelloTriangleApplication::debugCallback(
|
||
VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
|
||
VkDebugUtilsMessageTypeFlagsEXT messageTypes,
|
||
const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
|
||
void* pUserData)
|
||
{
|
||
std::cerr << "validation layer: " << pCallbackData->pMessage << std::endl;
|
||
|
||
return VK_FALSE;
|
||
}
|
||
|
||
void HelloTriangleApplication::setupDebugMessenger()
|
||
{
|
||
if (! enableValidationLayers)
|
||
{
|
||
return;
|
||
}
|
||
|
||
VkDebugUtilsMessengerCreateInfoEXT createInfo{};
|
||
populateDebugMessengerCreateInfo(createInfo);
|
||
|
||
|
||
if (CreateDebugUtilsMessengerEXT(instance,&createInfo,nullptr,&debugMessenger)!= VK_SUCCESS)
|
||
{
|
||
throw std::runtime_error("failed to set up debug messenger in setupDebugMessenger");
|
||
}
|
||
|
||
}
|
||
|
||
void HelloTriangleApplication::populateDebugMessengerCreateInfo(VkDebugUtilsMessengerCreateInfoEXT& createInfo)
|
||
{
|
||
|
||
createInfo.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
|
||
createInfo.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT |
|
||
VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT |
|
||
VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
|
||
createInfo.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;
|
||
createInfo.pfnUserCallback = &debugCallback;
|
||
createInfo.pUserData = nullptr;
|
||
|
||
}
|
||
|
||
void HelloTriangleApplication::createSurface()
|
||
{
|
||
if (glfwCreateWindowSurface(instance,window,nullptr,&surface) != VK_SUCCESS)
|
||
{
|
||
throw std::runtime_error("failed to create window surface in createSurface()");
|
||
}
|
||
}
|
||
|
||
bool HelloTriangleApplication::checkDeviceExtensionSupport(VkPhysicalDevice device)
|
||
{
|
||
uint32_t extensionCount;
|
||
vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, nullptr);
|
||
|
||
std::vector<VkExtensionProperties> availableExtensions(extensionCount);
|
||
vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, availableExtensions.data());
|
||
|
||
std::set<std::string> requiredExtensions(swapchainExtensions.begin(), swapchainExtensions.end());
|
||
|
||
for (const auto& extension : availableExtensions)
|
||
{
|
||
requiredExtensions.erase(extension.extensionName);
|
||
}
|
||
|
||
return requiredExtensions.empty();
|
||
|
||
}
|
||
|
||
void HelloTriangleApplication::pickPhysicalDevice()
|
||
{
|
||
uint32_t deviceCount = 0;
|
||
vkEnumeratePhysicalDevices(instance, &deviceCount, nullptr);
|
||
if (deviceCount==0)
|
||
{
|
||
throw std::runtime_error("failed to find GPUs with Vulkan support");
|
||
|
||
}
|
||
|
||
std::vector<VkPhysicalDevice> devices(deviceCount);
|
||
vkEnumeratePhysicalDevices(instance, &deviceCount, devices.data());
|
||
|
||
for (const auto& device : devices)
|
||
{
|
||
if (isDeviceSuitable(device))
|
||
{
|
||
physicalDevice = device;
|
||
break;
|
||
}
|
||
|
||
}
|
||
if (physicalDevice == VK_NULL_HANDLE)
|
||
{
|
||
throw std::runtime_error("failed to find a suitable GPU");
|
||
}
|
||
|
||
}
|
||
|
||
bool HelloTriangleApplication::isDeviceSuitable(VkPhysicalDevice device)
|
||
{
|
||
QueueFamilyIndices indices = findQueueFamilies(device);
|
||
|
||
bool extensionsSupported = checkDeviceExtensionSupport(device);
|
||
|
||
bool swapChainAdequate = false;
|
||
if (extensionsSupported)
|
||
{
|
||
SwapChainSupportDetails swapChainSupport = querySwapChainSupport(device);
|
||
swapChainAdequate = !swapChainSupport.formats.empty() && !swapChainSupport.presentModes.empty();
|
||
}
|
||
|
||
return indices.isComplete() && extensionsSupported && swapChainAdequate;
|
||
}
|
||
|
||
HelloTriangleApplication::QueueFamilyIndices HelloTriangleApplication::findQueueFamilies(VkPhysicalDevice device)
|
||
{
|
||
QueueFamilyIndices indices;
|
||
|
||
uint32_t queueFamilyCount = 0;
|
||
vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, nullptr);
|
||
|
||
std::vector<VkQueueFamilyProperties> queueFamilies(queueFamilyCount);
|
||
vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, queueFamilies.data());
|
||
|
||
VkBool32 presentSupport = false;
|
||
|
||
|
||
int i = 0;
|
||
vkGetPhysicalDeviceSurfaceSupportKHR(device, i, surface, &presentSupport);
|
||
for (const auto& queueFamily : queueFamilies)
|
||
{
|
||
if (queueFamily.queueFlags & VK_QUEUE_GRAPHICS_BIT) {
|
||
indices.graphicsFamily = i;
|
||
}
|
||
if (indices.isComplete())
|
||
{
|
||
break;
|
||
}
|
||
if (presentSupport)
|
||
{
|
||
indices.presentFamily = i;
|
||
}
|
||
|
||
i++;
|
||
|
||
}
|
||
|
||
return indices;
|
||
|
||
}
|
||
|
||
void HelloTriangleApplication::createLogicalDevice()
|
||
{
|
||
QueueFamilyIndices indices = findQueueFamilies(physicalDevice);
|
||
|
||
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);
|
||
|
||
}
|
||
/*
|
||
VkDeviceQueueCreateInfo queueCreateInfo{};
|
||
queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
|
||
queueCreateInfo.queueFamilyIndex = indices.graphicsFamily.value();
|
||
queueCreateInfo.queueCount = 1;
|
||
float queuePriority = 1.0f;
|
||
queueCreateInfo.pQueuePriorities = &queuePriority;
|
||
*/
|
||
VkPhysicalDeviceFeatures deviceFeatures{};
|
||
VkDeviceCreateInfo deviceCreateInfo{};
|
||
deviceCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
|
||
deviceCreateInfo.queueCreateInfoCount = static_cast<uint32_t>(queueCreateInfos.size());
|
||
deviceCreateInfo.pQueueCreateInfos = queueCreateInfos.data();
|
||
deviceCreateInfo.pEnabledFeatures = &deviceFeatures;
|
||
deviceCreateInfo.enabledExtensionCount = static_cast<uint32_t>(swapchainExtensions.size());
|
||
deviceCreateInfo.ppEnabledExtensionNames = swapchainExtensions.data();
|
||
//新版本vulkan已不对实例和设备特定验证层做区分，此处保证兼容性
|
||
|
||
if (enableValidationLayers)
|
||
{
|
||
deviceCreateInfo.enabledLayerCount = static_cast<uint32_t>(validationLayers.size());
|
||
deviceCreateInfo.ppEnabledLayerNames = validationLayers.data();
|
||
}
|
||
else
|
||
{
|
||
deviceCreateInfo.enabledLayerCount = 0;
|
||
}
|
||
|
||
if (vkCreateDevice(physicalDevice,&deviceCreateInfo,nullptr,&device) != VK_SUCCESS)
|
||
{
|
||
throw std::runtime_error("failed to create logical device");
|
||
}
|
||
|
||
vkGetDeviceQueue(device, indices.graphicsFamily.value(), 0, &graphicQueue);
|
||
vkGetDeviceQueue(device, indices.presentFamily.value(), 0, &presentQueue);
|
||
}
|
||
|
||
HelloTriangleApplication::SwapChainSupportDetails HelloTriangleApplication::querySwapChainSupport(VkPhysicalDevice device)
|
||
{
|
||
SwapChainSupportDetails details;
|
||
|
||
vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, surface, &details.capabilities);
|
||
|
||
uint32_t formatCount;
|
||
vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, nullptr);
|
||
|
||
if (formatCount !=0)
|
||
{
|
||
details.formats.resize(formatCount);
|
||
vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, details.formats.data());
|
||
}
|
||
|
||
uint32_t presentModeCount;
|
||
vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, nullptr);
|
||
|
||
if (presentModeCount != 0)
|
||
{
|
||
details.presentModes.resize(presentModeCount);
|
||
vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, details.presentModes.data());
|
||
}
|
||
|
||
return details;
|
||
}
|
||
|
||
VkSurfaceFormatKHR HelloTriangleApplication::chooseSwapSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& availableFormats)
|
||
{
|
||
for (const auto& availableFormat : availableFormats) {
|
||
if (availableFormat.format == VK_FORMAT_B8G8R8_SRGB && availableFormat.colorSpace == VK_COLORSPACE_SRGB_NONLINEAR_KHR)
|
||
{
|
||
return availableFormat;
|
||
}
|
||
}
|
||
|
||
return availableFormats[0];
|
||
}
|
||
|
||
VkPresentModeKHR HelloTriangleApplication::chooseSwapPresentMode(const std::vector<VkPresentModeKHR>& availablePresentModes)
|
||
{
|
||
for (const auto& availablePresentMode : availablePresentModes) {
|
||
if (availablePresentMode == VK_PRESENT_MODE_MAILBOX_KHR)
|
||
{
|
||
return availablePresentMode;
|
||
}
|
||
}
|
||
|
||
return VK_PRESENT_MODE_FIFO_KHR;
|
||
}
|
||
|
||
VkExtent2D HelloTriangleApplication::chooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities)
|
||
{
|
||
if (capabilities.currentExtent.width != std::numeric_limits<uint32_t>::max())
|
||
{
|
||
return capabilities.currentExtent;
|
||
}
|
||
else
|
||
{
|
||
int width, height;
|
||
glfwGetFramebufferSize(window, &width, &height);
|
||
|
||
VkExtent2D actualExtent = {
|
||
static_cast<uint32_t>(width),
|
||
static_cast<uint32_t>(height)
|
||
};
|
||
|
||
actualExtent.width = std::clamp(actualExtent.width, capabilities.minImageExtent.width, capabilities.maxImageExtent.width);
|
||
actualExtent.height = std::clamp(actualExtent.height, capabilities.minImageExtent.height, capabilities.maxImageExtent.height);
|
||
|
||
return actualExtent;
|
||
}
|
||
}
|
||
|
||
void HelloTriangleApplication::createSwapChain()
|
||
{
|
||
SwapChainSupportDetails swapChainSupport = querySwapChainSupport(physicalDevice);
|
||
|
||
VkSurfaceFormatKHR surfaceFormat = chooseSwapSurfaceFormat(swapChainSupport.formats);
|
||
VkPresentModeKHR presentMode = chooseSwapPresentMode(swapChainSupport.presentModes);
|
||
VkExtent2D extent = chooseSwapExtent(swapChainSupport.capabilities);
|
||
|
||
uint32_t imageCount = swapChainSupport.capabilities.minImageCount + 1;
|
||
|
||
if (swapChainSupport.capabilities.maxImageCount > 0 && imageCount > swapChainSupport.capabilities.maxImageCount)
|
||
{
|
||
imageCount = swapChainSupport.capabilities.maxImageCount;
|
||
}
|
||
|
||
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);
|
||
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;
|
||
createInfo.pQueueFamilyIndices = nullptr;
|
||
}
|
||
|
||
createInfo.preTransform = swapChainSupport.capabilities.currentTransform;
|
||
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());
|
||
// store swap format and swap extent to member variable
|
||
swapChainImageFormat = surfaceFormat.format;
|
||
swapChainExtent = extent;
|
||
|
||
}
|
||
|
||
void HelloTriangleApplication::cleanupSwapChain()
|
||
{
|
||
for (auto framebuffer : swapChainFramebuffers)
|
||
{
|
||
vkDestroyFramebuffer(device, framebuffer, nullptr);
|
||
}
|
||
|
||
for (auto imageView : swapChainImageViews)
|
||
{
|
||
vkDestroyImageView(device, imageView, nullptr);
|
||
}
|
||
|
||
vkDestroySwapchainKHR(device, swapChain, nullptr);
|
||
|
||
}
|
||
|
||
void HelloTriangleApplication::recreateSwapChain()
|
||
{
|
||
|
||
int width = 0, height = 0;
|
||
glfwGetFramebufferSize(window, &width, &height);
|
||
while (width == 0 || height == 0)
|
||
{
|
||
if (glfwWindowShouldClose(window))
|
||
{
|
||
return;
|
||
}
|
||
glfwGetFramebufferSize(window, &width, &height);
|
||
glfwWaitEvents();
|
||
}
|
||
|
||
vkDeviceWaitIdle(device);
|
||
|
||
cleanupSwapChain();
|
||
|
||
createSwapChain();
|
||
createImageView();
|
||
creatFramebuffers();
|
||
}
|
||
|
||
void HelloTriangleApplication::createImageView()
|
||
{
|
||
swapChainImageViews.resize(swapChainImages.size());
|
||
|
||
for (size_t i = 0; i < swapChainImages.size(); i++)
|
||
{
|
||
VkImageViewCreateInfo creatInfo{};
|
||
creatInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
|
||
creatInfo.image = swapChainImages[i];
|
||
creatInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
|
||
creatInfo.format = swapChainImageFormat;
|
||
|
||
creatInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
|
||
creatInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
|
||
creatInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
|
||
creatInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
|
||
|
||
creatInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
||
creatInfo.subresourceRange.baseMipLevel = 0;
|
||
creatInfo.subresourceRange.levelCount = 1;
|
||
creatInfo.subresourceRange.baseArrayLayer = 0;
|
||
creatInfo.subresourceRange.layerCount = 1;
|
||
|
||
if (vkCreateImageView(device,&creatInfo,nullptr,&swapChainImageViews[i]) != VK_SUCCESS)
|
||
{
|
||
throw std::runtime_error("failed to creat image view");
|
||
}
|
||
|
||
|
||
}
|
||
}
|
||
std::vector<char> HelloTriangleApplication::readFile(const std::string& filename)
|
||
{
|
||
std::ifstream file(filename, std::ios::ate | std::ios::binary);
|
||
|
||
if (!file.is_open())
|
||
{
|
||
throw std::runtime_error("failed to open file!");
|
||
}
|
||
|
||
rsize_t fileSize = (rsize_t)file.tellg();
|
||
std::vector<char> buffer(fileSize);
|
||
|
||
file.seekg(0);
|
||
file.read(buffer.data(), fileSize);
|
||
file.close();
|
||
return buffer;
|
||
|
||
}
|
||
|
||
VkShaderModule HelloTriangleApplication::createShaderModule(const std::vector<char> code)
|
||
{
|
||
VkShaderModuleCreateInfo createInfo{};
|
||
createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
|
||
createInfo.codeSize = code.size();
|
||
createInfo.pCode = reinterpret_cast<const uint32_t*>(code.data());
|
||
|
||
VkShaderModule shaderModeul;
|
||
if (vkCreateShaderModule(device,&createInfo,nullptr,&shaderModeul) != VK_SUCCESS)
|
||
{
|
||
throw std::runtime_error("failed to create shader module!");
|
||
}
|
||
|
||
return shaderModeul;
|
||
|
||
}
|
||
|
||
void HelloTriangleApplication::creatFramebuffers()
|
||
{
|
||
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 in createFramebuffer");
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
void HelloTriangleApplication::createCommandPool()
|
||
{
|
||
QueueFamilyIndices queueFamilyIndices = findQueueFamilies(physicalDevice);
|
||
|
||
VkCommandPoolCreateInfo poolInfo{};
|
||
poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
|
||
poolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
|
||
poolInfo.queueFamilyIndex = queueFamilyIndices.graphicsFamily.value();
|
||
|
||
if (vkCreateCommandPool(device,&poolInfo,nullptr,&commandPool) != VK_SUCCESS)
|
||
{
|
||
throw std::runtime_error("failed to create command pool in createCommandpool");
|
||
}
|
||
|
||
}
|
||
|
||
void HelloTriangleApplication::createVertexBuffer()
|
||
{
|
||
VkDeviceSize bufferSize = sizeof(vertices[0]) * vertices.size();
|
||
VkBuffer stagingBuffer;
|
||
VkDeviceMemory stagingBufferMemory;
|
||
createBuffer(bufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, stagingBuffer ,stagingBufferMemory);
|
||
|
||
void* data;
|
||
vkMapMemory(device, stagingBufferMemory, 0, bufferSize, 0, &data);
|
||
memcpy(data, vertices.data(), (size_t)bufferSize);
|
||
vkUnmapMemory(device, stagingBufferMemory);
|
||
|
||
// host visible buffer as temp buffer
|
||
createBuffer(bufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT , VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, vertexBuffer, vertexBufferMemory);
|
||
|
||
// move the vertex data to the device local buffer
|
||
copyBuffer(stagingBuffer, vertexBuffer, bufferSize);
|
||
|
||
vkDestroyBuffer(device, stagingBuffer, nullptr);
|
||
vkFreeMemory(device, stagingBufferMemory, nullptr);
|
||
|
||
}
|
||
|
||
void HelloTriangleApplication::createIndexBuffer()
|
||
{
|
||
VkDeviceSize bufferSize = sizeof(indices[0]) * indices.size();
|
||
VkBuffer stagingBuffer;
|
||
VkDeviceMemory stagingBufferMemory;
|
||
createBuffer(bufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, stagingBuffer, stagingBufferMemory);
|
||
|
||
void* data;
|
||
vkMapMemory(device, stagingBufferMemory, 0, bufferSize, 0, &data);
|
||
memcpy(data, indices.data(), (size_t)bufferSize);
|
||
vkUnmapMemory(device, stagingBufferMemory);
|
||
|
||
// host visible buffer as temp buffer
|
||
createBuffer(bufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, indexBuffer, indexBufferMemory);
|
||
|
||
// move the vertex data to the device local buffer
|
||
copyBuffer(stagingBuffer, indexBuffer, bufferSize);
|
||
|
||
vkDestroyBuffer(device, stagingBuffer, nullptr);
|
||
vkFreeMemory(device, stagingBufferMemory, nullptr);
|
||
}
|
||
|
||
void HelloTriangleApplication::createUniformBuffers()
|
||
{
|
||
VkDeviceSize bufferSize = sizeof(UniformBufferObject);
|
||
|
||
uniformBuffers.resize(MAX_FRAME_IN_FLIGHT);
|
||
uniformBuffersMemory.resize(MAX_FRAME_IN_FLIGHT);
|
||
uniformBuffersMapped.resize(MAX_FRAME_IN_FLIGHT);
|
||
|
||
for (size_t i = 0; i < MAX_FRAME_IN_FLIGHT; i++)
|
||
{
|
||
createBuffer(bufferSize, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, uniformBuffers[i], uniformBuffersMemory[i]);
|
||
vkMapMemory(device, uniformBuffersMemory[i], 0, bufferSize, 0, &uniformBuffersMapped[i]);
|
||
}
|
||
|
||
}
|
||
|
||
void HelloTriangleApplication::createDescriptorPool()
|
||
{
|
||
VkDescriptorPoolSize poolSize{};
|
||
poolSize.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
|
||
poolSize.descriptorCount = static_cast<uint32_t>(MAX_FRAME_IN_FLIGHT);
|
||
|
||
VkDescriptorPoolCreateInfo poolInfo{};
|
||
poolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
|
||
poolInfo.poolSizeCount = 1;
|
||
poolInfo.pPoolSizes = &poolSize;
|
||
poolInfo.maxSets = static_cast<uint32_t>(MAX_FRAME_IN_FLIGHT);
|
||
|
||
if (vkCreateDescriptorPool(device,&poolInfo,nullptr,&descriptorPool) != VK_SUCCESS)
|
||
{
|
||
throw std::runtime_error("failed to create descriptor pool");
|
||
}
|
||
|
||
}
|
||
|
||
void HelloTriangleApplication::createDescriptorSets()
|
||
{
|
||
std::vector<VkDescriptorSetLayout> layouts(MAX_FRAME_IN_FLIGHT,descriptorSetLayout);
|
||
VkDescriptorSetAllocateInfo allocInfo{};
|
||
allocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
|
||
allocInfo.descriptorPool = descriptorPool;
|
||
allocInfo.descriptorSetCount = static_cast<uint32_t>(MAX_FRAME_IN_FLIGHT);
|
||
allocInfo.pSetLayouts = layouts.data();
|
||
|
||
descriptorSets.resize(MAX_FRAME_IN_FLIGHT);
|
||
if (vkAllocateDescriptorSets(device,&allocInfo,descriptorSets.data()) != VK_SUCCESS)
|
||
{
|
||
throw std::runtime_error("failed to allocate descriptor sets in createDescriptoSets");
|
||
}
|
||
|
||
for (size_t i = 0; i < MAX_FRAME_IN_FLIGHT; i++)
|
||
{
|
||
VkDescriptorBufferInfo bufferInfo{};
|
||
bufferInfo.buffer = uniformBuffers[i];
|
||
bufferInfo.offset = 0;
|
||
bufferInfo.range = sizeof(UniformBufferObject);
|
||
VkWriteDescriptorSet descriptorWrite{};
|
||
descriptorWrite.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
|
||
descriptorWrite.dstSet = descriptorSets[i];
|
||
descriptorWrite.dstBinding = 0;
|
||
descriptorWrite.dstArrayElement = 0;
|
||
descriptorWrite.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
|
||
descriptorWrite.descriptorCount = 1;
|
||
descriptorWrite.pBufferInfo = &bufferInfo;
|
||
descriptorWrite.pImageInfo = nullptr;
|
||
descriptorWrite.pTexelBufferView = nullptr;
|
||
|
||
vkUpdateDescriptorSets(device, 1, &descriptorWrite, 0, nullptr);
|
||
}
|
||
|
||
|
||
}
|
||
|
||
void HelloTriangleApplication::updateUniformBuffer(uint32_t currentImage)
|
||
{
|
||
static auto startTime = std::chrono::high_resolution_clock::now();
|
||
|
||
auto currentTime = std::chrono::high_resolution_clock::now();
|
||
float time = std::chrono::duration<float, std::chrono::seconds::period>(currentTime - startTime).count();
|
||
|
||
UniformBufferObject ubo{};
|
||
ubo.model = glm::rotate(glm::mat4(1.0f), time * glm::radians(90.0f), glm::vec3(0.0f, 0.0f, 1.0f));
|
||
ubo.view = glm::lookAt(glm::vec3(2.0f, 2.0f, 2.0f), glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f,0.0f,0.1f));
|
||
ubo.proj = glm::perspective(glm::radians(45.0f), swapChainExtent.width / (float)swapChainExtent.height, 0.1f, 10.0f);
|
||
ubo.proj[1][1] *= -1;
|
||
|
||
memcpy(uniformBuffersMapped[currentImage], &ubo, sizeof(ubo));
|
||
}
|
||
|
||
void HelloTriangleApplication::createBuffer(VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags properties, VkBuffer& buffer, VkDeviceMemory& bufferMemory)
|
||
{
|
||
VkBufferCreateInfo bufferInfo{};
|
||
bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
|
||
bufferInfo.size = size;
|
||
bufferInfo.usage = usage;
|
||
bufferInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
||
|
||
if (vkCreateBuffer(device, &bufferInfo, nullptr, &buffer) != VK_SUCCESS)
|
||
{
|
||
throw std::runtime_error("failed to create vertex buffer in createVertexBuffer");
|
||
}
|
||
|
||
VkMemoryRequirements memRequirements;
|
||
vkGetBufferMemoryRequirements(device, buffer, &memRequirements);
|
||
|
||
VkMemoryAllocateInfo allocInfo{};
|
||
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
|
||
allocInfo.allocationSize = memRequirements.size;
|
||
allocInfo.memoryTypeIndex = findMemoryType(memRequirements.memoryTypeBits, properties);
|
||
|
||
if (vkAllocateMemory(device, &allocInfo, nullptr, &bufferMemory) != VK_SUCCESS)
|
||
{
|
||
throw std::runtime_error("failed to allocate vertex buffer memory!");
|
||
}
|
||
|
||
vkBindBufferMemory(device, buffer, bufferMemory, 0);
|
||
|
||
}
|
||
|
||
void HelloTriangleApplication::copyBuffer(VkBuffer srcBuffer, VkBuffer dstBuffer, VkDeviceSize size)
|
||
{
|
||
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);
|
||
|
||
VkBufferCopy copyRegin{};
|
||
copyRegin.srcOffset = 0;
|
||
copyRegin.dstOffset = 0;
|
||
copyRegin.size = size;
|
||
vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, 1, ©Regin);
|
||
|
||
vkEndCommandBuffer(commandBuffer);
|
||
|
||
VkSubmitInfo submitInfo{};
|
||
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
|
||
submitInfo.commandBufferCount = 1;
|
||
submitInfo.pCommandBuffers = &commandBuffer;
|
||
|
||
vkQueueSubmit(graphicQueue, 1, &submitInfo, VK_NULL_HANDLE);
|
||
vkQueueWaitIdle(graphicQueue);
|
||
|
||
vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer);
|
||
|
||
|
||
|
||
}
|
||
|
||
|
||
|
||
uint32_t HelloTriangleApplication::findMemoryType(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 HelloTriangleApplication::createCommandBuffer()
|
||
{
|
||
commandBuffers.resize(MAX_FRAME_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) commandBuffers.size();
|
||
|
||
if (vkAllocateCommandBuffers(device,&allocInfo,commandBuffers.data()) != VK_SUCCESS)
|
||
{
|
||
throw std::runtime_error("failed to allocate command buffers in createCommandBuffer");
|
||
}
|
||
}
|
||
|
||
void HelloTriangleApplication::recordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t imageIndex,uint32_t currentFrame)
|
||
{
|
||
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 in recordCommandBuffer");
|
||
}
|
||
|
||
VkRenderPassBeginInfo renderPassBeginInfo{};
|
||
renderPassBeginInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
|
||
renderPassBeginInfo.renderPass = renderPass;
|
||
renderPassBeginInfo.framebuffer = swapChainFramebuffers[imageIndex];
|
||
renderPassBeginInfo.renderArea.extent = swapChainExtent;
|
||
VkClearValue clearColor = { {{0.0f,0.0f,0.0f,1.0f}} };
|
||
renderPassBeginInfo.clearValueCount = 1;
|
||
renderPassBeginInfo.pClearValues = &clearColor;
|
||
|
||
vkCmdBeginRenderPass(commandBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
|
||
|
||
vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, graphicsPipeline);
|
||
|
||
VkViewport viewport{};
|
||
viewport.x = 0.0f;
|
||
viewport.y = 0.0f;
|
||
viewport.width = static_cast<float>(swapChainExtent.width);
|
||
viewport.height = static_cast<float>(swapChainExtent.height);
|
||
viewport.minDepth = 0.0f;
|
||
viewport.maxDepth = 1.0f;
|
||
vkCmdSetViewport(commandBuffer, 0, 1, &viewport);
|
||
|
||
VkRect2D scissor{};
|
||
scissor.offset = { 0,0 };
|
||
scissor.extent = swapChainExtent;
|
||
vkCmdSetScissor(commandBuffer, 0, 1, &scissor);
|
||
// bindVertexBuffer
|
||
VkBuffer vertexBuffers[] = { vertexBuffer };
|
||
VkDeviceSize offsets[] = { 0 };
|
||
vkCmdBindVertexBuffers(commandBuffer, 0, 1, vertexBuffers, offsets);
|
||
// bind indexBuffer
|
||
vkCmdBindIndexBuffer(commandBuffer, indexBuffer, 0, VK_INDEX_TYPE_UINT16);
|
||
|
||
vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSets[currentFrame], 0, nullptr);
|
||
|
||
vkCmdDrawIndexed(commandBuffer, static_cast<uint32_t>(indices.size()), 1, 0, 0, 0);
|
||
|
||
vkCmdEndRenderPass(commandBuffer);
|
||
|
||
if (vkEndCommandBuffer(commandBuffer) != VK_SUCCESS)
|
||
{
|
||
throw std::runtime_error("failed to record command buffer in recordCommandBuffer");
|
||
}
|
||
|
||
}
|
||
|
||
void HelloTriangleApplication::drawFrame()
|
||
{
|
||
uint32_t currentFrame = 0;
|
||
uint32_t imageIndex;
|
||
//等待所有fence收到信号后返回，uint64_max禁用超时
|
||
vkWaitForFences(device, 1, &inFlightFences[currentFrame], VK_TRUE, UINT64_MAX);
|
||
|
||
VkResult result = vkAcquireNextImageKHR(device, swapChain, UINT64_MAX, imageAvailableSemaphores[currentFrame], VK_NULL_HANDLE, &imageIndex);
|
||
|
||
if (result == VK_ERROR_OUT_OF_DATE_KHR)
|
||
{
|
||
recreateSwapChain();
|
||
return;
|
||
}
|
||
else if (result != VK_SUCCESS && result != VK_SUBOPTIMAL_KHR)
|
||
{
|
||
throw std::runtime_error("failed to acquire swap chain image in drawFrame");
|
||
}
|
||
|
||
vkResetFences(device, 1, &inFlightFences[currentFrame]);
|
||
|
||
//vkAcquireNextImageKHR(device, swapChain, UINT64_MAX, imageAvailableSemaphores[currentFrame], VK_NULL_HANDLE, &imageIndex);
|
||
|
||
vkResetCommandBuffer(commandBuffers[currentFrame], 0);
|
||
recordCommandBuffer(commandBuffers[currentFrame], imageIndex,currentFrame);
|
||
|
||
updateUniformBuffer(currentFrame);
|
||
|
||
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[currentFrame]};
|
||
submitInfo.signalSemaphoreCount = 1;
|
||
submitInfo.pSignalSemaphores = signalSemaphores;
|
||
|
||
if (vkQueueSubmit(graphicQueue,1,&submitInfo,inFlightFences[currentFrame]) != VK_SUCCESS)
|
||
{
|
||
throw std::runtime_error("failed to submit draw command buffer in drawFrame");
|
||
}
|
||
|
||
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;
|
||
presentInfo.pResults = nullptr;
|
||
//vkQueuePresentKHR(presentQueue, &presentInfo);
|
||
|
||
result = vkQueuePresentKHR(presentQueue, &presentInfo);
|
||
if (result == VK_ERROR_OUT_OF_DATE_KHR || result == VK_SUBOPTIMAL_KHR)
|
||
{
|
||
framebufferResized = false;
|
||
recreateSwapChain();
|
||
}
|
||
else if (result != VK_SUCCESS)
|
||
{
|
||
throw std::runtime_error("failed to present swap chain image in drawFrame");
|
||
}
|
||
|
||
currentFrame = (currentFrame + 1) % MAX_FRAME_IN_FLIGHT;//前进下一帧
|
||
|
||
}
|
||
|
||
void HelloTriangleApplication::createSyncObjects()
|
||
{
|
||
imageAvailableSemaphores.resize(MAX_FRAME_IN_FLIGHT);
|
||
renderFinishedSemaphores.resize(MAX_FRAME_IN_FLIGHT);
|
||
inFlightFences.resize(MAX_FRAME_IN_FLIGHT);
|
||
|
||
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;//防止vkWaitForFences在第一帧无限期阻塞
|
||
|
||
if (vkCreateSemaphore(device,&semaphoreInfo,nullptr,imageAvailableSemaphores.data()) != VK_SUCCESS ||
|
||
vkCreateSemaphore(device, &semaphoreInfo, nullptr, renderFinishedSemaphores.data()) != VK_SUCCESS ||
|
||
vkCreateFence(device,&fenceInfo,nullptr,inFlightFences.data()) != VK_SUCCESS)
|
||
{
|
||
throw std::runtime_error("failed to create semaphores in creatSyncObjects");
|
||
}
|
||
|
||
}
|
||
|
||
void HelloTriangleApplication::framebufferResizeCallback(GLFWwindow* window, int width, int height)
|
||
{
|
||
auto app = reinterpret_cast<HelloTriangleApplication*>(glfwGetWindowUserPointer(window));
|
||
app->framebufferResized = true;
|
||
|
||
}
|
||
|
||
|
||
void HelloTriangleApplication::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;// 存储渲染内容到内存
|
||
//stencil数据
|
||
colorAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;// just dont care
|
||
colorAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
|
||
|
||
colorAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;// render pass 开始前图形具有的布局
|
||
colorAttachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;// render pass 完成时自动转换到的布局，此处为准备用交换链进行呈现
|
||
|
||
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;
|
||
|
||
VkSubpassDependency dependency{};
|
||
dependency.srcSubpass = VK_SUBPASS_EXTERNAL;
|
||
dependency.dstSubpass = 0;
|
||
dependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
|
||
dependency.srcAccessMask = 0;
|
||
dependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
|
||
dependency.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
|
||
|
||
VkRenderPassCreateInfo renderPassInfo{};
|
||
renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
|
||
renderPassInfo.attachmentCount = 1;
|
||
renderPassInfo.pAttachments = &colorAttachment;
|
||
renderPassInfo.subpassCount = 1;
|
||
renderPassInfo.pSubpasses = &subpass;
|
||
|
||
renderPassInfo.dependencyCount = 1;
|
||
renderPassInfo.pDependencies = &dependency;
|
||
|
||
if (vkCreateRenderPass(device,&renderPassInfo,nullptr,&renderPass) != VK_SUCCESS)
|
||
{
|
||
throw std::runtime_error("failed to create render pass in createRenderPass");
|
||
}
|
||
|
||
}
|
||
|
||
void HelloTriangleApplication::createDescriptorSetLayout()
|
||
{
|
||
VkDescriptorSetLayoutBinding uboLayoutBinding{};
|
||
uboLayoutBinding.binding = 0;
|
||
uboLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
|
||
uboLayoutBinding.descriptorCount = 1;
|
||
uboLayoutBinding.stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
|
||
uboLayoutBinding.pImmutableSamplers = nullptr;
|
||
|
||
VkDescriptorSetLayoutCreateInfo layoutInfo{};
|
||
layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
|
||
layoutInfo.bindingCount = 1;
|
||
layoutInfo.pBindings = &uboLayoutBinding;
|
||
|
||
if (vkCreateDescriptorSetLayout(device,&layoutInfo,nullptr,&descriptorSetLayout) != VK_SUCCESS)
|
||
{
|
||
throw std::runtime_error("failed to create descriptor set layout");
|
||
}
|
||
|
||
|
||
|
||
}
|
||
|
||
void HelloTriangleApplication::createGraphicPipeline()
|
||
{
|
||
auto vertShaderCode = readFile("../../../shaders/triangleVert.spv");
|
||
auto fragShaderCode = readFile("../../..//shaders/triangleFrag.spv");
|
||
|
||
|
||
//std::cout << "vertShader size:" << vertShaderCode.size() << "\nfragShader size:" << fragShaderCode.size() << std::endl;
|
||
|
||
VkShaderModule vertShaderModule = createShaderModule(vertShaderCode);
|
||
VkShaderModule fragShaderModule = createShaderModule(fragShaderCode);
|
||
|
||
//指定管线vertex阶段
|
||
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";
|
||
//指定管线fragment阶段
|
||
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 };
|
||
|
||
//顶点输入
|
||
|
||
auto bindingDescription = Vertex::getBindingDescription();
|
||
auto attributeDescriptions = Vertex::getAttributeDescriptions();
|
||
|
||
VkPipelineVertexInputStateCreateInfo vertexInputInfo{};
|
||
vertexInputInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
|
||
vertexInputInfo.vertexBindingDescriptionCount = 1;
|
||
vertexInputInfo.pVertexBindingDescriptions = &bindingDescription;
|
||
vertexInputInfo.vertexAttributeDescriptionCount = static_cast<uint32_t>(attributeDescriptions.size());
|
||
vertexInputInfo.pVertexAttributeDescriptions = attributeDescriptions.data();
|
||
|
||
|
||
//使用动态状态并保留视口和剪刀裁剪状态
|
||
std::vector<VkDynamicState> dynamicStates = {
|
||
VK_DYNAMIC_STATE_VIEWPORT,
|
||
VK_DYNAMIC_STATE_SCISSOR
|
||
};
|
||
|
||
VkPipelineDynamicStateCreateInfo dynamicState{};
|
||
dynamicState.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
|
||
dynamicState.dynamicStateCount = static_cast<uint32_t>(dynamicStates.size());
|
||
dynamicState.pDynamicStates = dynamicStates.data();
|
||
|
||
//描述从顶点绘制哪种几何图形及是否启用primitive restart
|
||
VkPipelineInputAssemblyStateCreateInfo inputAsseblyState{};
|
||
inputAsseblyState.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
|
||
inputAsseblyState.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
|
||
inputAsseblyState.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;
|
||
// 创建viewport
|
||
VkPipelineViewportStateCreateInfo viewportState{};
|
||
viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
|
||
viewportState.viewportCount = 1;
|
||
viewportState.scissorCount = 1;
|
||
|
||
// 光栅化
|
||
VkPipelineRasterizationStateCreateInfo rasterizer{};
|
||
rasterizer.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
|
||
rasterizer.depthClampEnable = VK_FALSE;// 不丢弃超出近平面和远平面的fragment
|
||
rasterizer.rasterizerDiscardEnable = VK_FALSE;// 启用则几何图形不会通过光栅化，禁用framebuffer的所有输出
|
||
rasterizer.polygonMode = VK_POLYGON_MODE_FILL;// fragment填充多边形区域
|
||
rasterizer.lineWidth = 1.0f;
|
||
|
||
rasterizer.cullMode = VK_CULL_MODE_BACK_BIT;// 背面剔除
|
||
rasterizer.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
|
||
|
||
// 根据fragment的斜率偏置深度值
|
||
rasterizer.depthBiasEnable = VK_FALSE;
|
||
rasterizer.depthBiasConstantFactor = 0.0f;
|
||
rasterizer.depthBiasClamp = 0.0f;
|
||
rasterizer.depthBiasSlopeFactor = 0.0f;
|
||
|
||
// 多重采样（禁用）
|
||
VkPipelineMultisampleStateCreateInfo multisampling{};
|
||
multisampling.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
|
||
multisampling.sampleShadingEnable = VK_FALSE;
|
||
multisampling.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
|
||
multisampling.minSampleShading = 1.0f;
|
||
multisampling.pSampleMask = nullptr;
|
||
multisampling.alphaToCoverageEnable = VK_FALSE;
|
||
multisampling.alphaToOneEnable = VK_FALSE;
|
||
|
||
// 深度或模版缓冲区（暂留）
|
||
|
||
// 颜色混合 color blending
|
||
//每个附加帧缓冲区的配置
|
||
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;
|
||
colorBlendAttachment.srcColorBlendFactor = VK_BLEND_FACTOR_ONE;
|
||
colorBlendAttachment.dstColorBlendFactor = VK_BLEND_FACTOR_ZERO;
|
||
colorBlendAttachment.colorBlendOp = VK_BLEND_OP_ADD;
|
||
colorBlendAttachment.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
|
||
colorBlendAttachment.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
|
||
colorBlendAttachment.alphaBlendOp = VK_BLEND_OP_ADD;
|
||
|
||
/*
|
||
alpha混合
|
||
colorBlendAttachment.blendEnable = VK_TRUE;
|
||
colorBlendAttachment.srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
|
||
colorBlendAttachment.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
|
||
colorBlendAttachment.colorBlendOp = VK_BLEND_OP_ADD;
|
||
colorBlendAttachment.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
|
||
colorBlendAttachment.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
|
||
colorBlendAttachment.alphaBlendOp = VK_BLEND_OP_ADD;
|
||
*/
|
||
|
||
//全局颜色混合配置,按位运算
|
||
VkPipelineColorBlendStateCreateInfo colorBlendState{};
|
||
colorBlendState.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
|
||
colorBlendState.logicOpEnable = VK_FALSE;
|
||
colorBlendState.logicOp = VK_LOGIC_OP_COPY;
|
||
colorBlendState.attachmentCount = 1;
|
||
colorBlendState.pAttachments = &colorBlendAttachment;
|
||
colorBlendState.blendConstants[0] = 0.0f;
|
||
colorBlendState.blendConstants[1] = 0.0f;
|
||
colorBlendState.blendConstants[2] = 0.0f;
|
||
colorBlendState.blendConstants[3] = 0.0f;
|
||
|
||
VkPipelineLayoutCreateInfo pipelineLayoutInfo{};
|
||
pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
|
||
pipelineLayoutInfo.setLayoutCount = 1;
|
||
pipelineLayoutInfo.pSetLayouts = &descriptorSetLayout;
|
||
pipelineLayoutInfo.pushConstantRangeCount = 0;
|
||
pipelineLayoutInfo.pPushConstantRanges = nullptr;
|
||
|
||
if (vkCreatePipelineLayout(device,&pipelineLayoutInfo,nullptr,&pipelineLayout) != VK_SUCCESS)
|
||
{
|
||
throw std::runtime_error("failed to create pipeline Layout in createGraphicPipeline");
|
||
}
|
||
|
||
VkGraphicsPipelineCreateInfo pipelineInfo{};
|
||
pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
|
||
pipelineInfo.stageCount = 2;
|
||
pipelineInfo.pStages = shaderStages;
|
||
|
||
pipelineInfo.pVertexInputState = &vertexInputInfo;
|
||
pipelineInfo.pInputAssemblyState = &inputAsseblyState;
|
||
pipelineInfo.pViewportState = &viewportState;
|
||
pipelineInfo.pRasterizationState = &rasterizer;
|
||
pipelineInfo.pMultisampleState = &multisampling;
|
||
pipelineInfo.pDepthStencilState = nullptr;
|
||
pipelineInfo.pColorBlendState = &colorBlendState;
|
||
pipelineInfo.pDynamicState = &dynamicState;
|
||
//
|
||
pipelineInfo.layout = pipelineLayout;
|
||
pipelineInfo.renderPass = renderPass;
|
||
pipelineInfo.subpass = 0;
|
||
|
||
pipelineInfo.basePipelineHandle = VK_NULL_HANDLE;
|
||
pipelineInfo.basePipelineIndex = -1;
|
||
|
||
|
||
if (vkCreateGraphicsPipelines(device,VK_NULL_HANDLE,1,&pipelineInfo,nullptr,&graphicsPipeline) != VK_SUCCESS)
|
||
{
|
||
throw std::runtime_error("failed to create graphics pipeline in createGraphicPipeline");
|
||
}
|
||
|
||
// 管道创建完成后销毁着色器模块
|
||
vkDestroyShaderModule(device, fragShaderModule, nullptr);
|
||
vkDestroyShaderModule(device, vertShaderModule, nullptr);
|
||
}
|
||
|
||
|
||
bool HelloTriangleApplication::checkValidationLayerSupport() {
|
||
uint32_t layerCount;
|
||
vkEnumerateInstanceLayerProperties(&layerCount, nullptr);
|
||
|
||
std::vector<VkLayerProperties> availableLayers(layerCount);
|
||
vkEnumerateInstanceLayerProperties(&layerCount, availableLayers.data());
|
||
|
||
// check if validationLayers can be found in availableLayers
|
||
for (const char* layerName: validationLayers)
|
||
{
|
||
bool layerFound = false;
|
||
for (const auto& layerProperties : availableLayers) {
|
||
if (strcmp(layerName,layerProperties.layerName)==0)
|
||
{
|
||
layerFound = true;
|
||
break;
|
||
}
|
||
}
|
||
if (!layerFound)
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
|
||
VkResult CreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pDebugMessenger)
|
||
{
|
||
auto func = (PFN_vkCreateDebugUtilsMessengerEXT) vkGetInstanceProcAddr(instance, "vkCreateDebugUtilsMessengerEXT");
|
||
|
||
if (func != nullptr)
|
||
{
|
||
return func(instance, pCreateInfo, pAllocator, pDebugMessenger);
|
||
|
||
}
|
||
else
|
||
{
|
||
return VK_ERROR_EXTENSION_NOT_PRESENT;
|
||
}
|
||
|
||
}
|
||
|
||
void DestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT debugMessenger, const VkAllocationCallbacks* pAllocator)
|
||
{
|
||
auto func = (PFN_vkDestroyDebugUtilsMessengerEXT)vkGetInstanceProcAddr(instance, "vkDestroyDebugUtilsMessengerEXT");
|
||
|
||
if (func!=nullptr)
|
||
{
|
||
func(instance, debugMessenger, pAllocator);
|
||
}
|
||
}
|
||
|
||
|
||
int main()
|
||
{
|
||
HelloTriangleApplication app;
|
||
|
||
try
|
||
{
|
||
app.run(Width,Height);
|
||
}
|
||
catch (const std::exception& e)
|
||
{
|
||
std::cerr << e.what() << std::endl;
|
||
return EXIT_FAILURE;
|
||
}
|
||
return EXIT_SUCCESS;
|
||
}
|
||
|
||
VkVertexInputBindingDescription HelloTriangleApplication::Vertex::getBindingDescription()
|
||
{
|
||
VkVertexInputBindingDescription bindingDescription{};
|
||
bindingDescription.binding = 0;
|
||
bindingDescription.stride = sizeof(Vertex);
|
||
bindingDescription.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
|
||
|
||
return bindingDescription;
|
||
}
|
||
|
||
std::array<VkVertexInputAttributeDescription,2> HelloTriangleApplication::Vertex::getAttributeDescriptions()
|
||
{
|
||
std::array<VkVertexInputAttributeDescription,2> attributeDescriptions{};
|
||
attributeDescriptions[0].binding = 0;
|
||
attributeDescriptions[0].location = 0;
|
||
attributeDescriptions[0].format = VK_FORMAT_R32G32_SFLOAT;
|
||
attributeDescriptions[0].offset = offsetof(Vertex, pos);
|
||
attributeDescriptions[1].binding = 0;
|
||
attributeDescriptions[1].location = 1;
|
||
attributeDescriptions[1].format = VK_FORMAT_R32G32B32_SFLOAT;
|
||
attributeDescriptions[1].offset = offsetof(Vertex, color);
|
||
|
||
return attributeDescriptions;
|
||
}
|