init
This commit is contained in:
commit
dad6ce7a21
|
|
@ -0,0 +1,17 @@
|
||||||
|
{
|
||||||
|
"configurations": [
|
||||||
|
{
|
||||||
|
"name": "Linux",
|
||||||
|
"includePath": [
|
||||||
|
"${workspaceFolder}/**"
|
||||||
|
],
|
||||||
|
"defines": [],
|
||||||
|
"compilerPath": "/usr/bin/gcc",
|
||||||
|
"cStandard": "c17",
|
||||||
|
"cppStandard": "gnu++17",
|
||||||
|
"intelliSenseMode": "linux-gcc-x64",
|
||||||
|
"configurationProvider": "ms-vscode.makefile-tools"
|
||||||
|
}
|
||||||
|
],
|
||||||
|
"version": 4
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,53 @@
|
||||||
|
{
|
||||||
|
"files.associations": {
|
||||||
|
"array": "cpp",
|
||||||
|
"atomic": "cpp",
|
||||||
|
"bit": "cpp",
|
||||||
|
"*.tcc": "cpp",
|
||||||
|
"cctype": "cpp",
|
||||||
|
"clocale": "cpp",
|
||||||
|
"cmath": "cpp",
|
||||||
|
"compare": "cpp",
|
||||||
|
"concepts": "cpp",
|
||||||
|
"cstdarg": "cpp",
|
||||||
|
"cstddef": "cpp",
|
||||||
|
"cstdint": "cpp",
|
||||||
|
"cstdio": "cpp",
|
||||||
|
"cstdlib": "cpp",
|
||||||
|
"cstring": "cpp",
|
||||||
|
"cwchar": "cpp",
|
||||||
|
"cwctype": "cpp",
|
||||||
|
"deque": "cpp",
|
||||||
|
"string": "cpp",
|
||||||
|
"unordered_map": "cpp",
|
||||||
|
"vector": "cpp",
|
||||||
|
"exception": "cpp",
|
||||||
|
"algorithm": "cpp",
|
||||||
|
"functional": "cpp",
|
||||||
|
"iterator": "cpp",
|
||||||
|
"memory": "cpp",
|
||||||
|
"memory_resource": "cpp",
|
||||||
|
"numeric": "cpp",
|
||||||
|
"random": "cpp",
|
||||||
|
"string_view": "cpp",
|
||||||
|
"system_error": "cpp",
|
||||||
|
"tuple": "cpp",
|
||||||
|
"type_traits": "cpp",
|
||||||
|
"utility": "cpp",
|
||||||
|
"initializer_list": "cpp",
|
||||||
|
"iosfwd": "cpp",
|
||||||
|
"iostream": "cpp",
|
||||||
|
"istream": "cpp",
|
||||||
|
"limits": "cpp",
|
||||||
|
"new": "cpp",
|
||||||
|
"numbers": "cpp",
|
||||||
|
"ostream": "cpp",
|
||||||
|
"stdexcept": "cpp",
|
||||||
|
"streambuf": "cpp",
|
||||||
|
"cinttypes": "cpp",
|
||||||
|
"typeinfo": "cpp",
|
||||||
|
"fstream": "cpp",
|
||||||
|
"set": "cpp",
|
||||||
|
"unordered_set": "cpp"
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,26 @@
|
||||||
|
CFLAGS = -std=c++17 -o2 -I. -I$(VULKAN_SDK_PATH)/include
|
||||||
|
LDFLAGS = -L$(VULKAN_SDK_PATH)/lib `pkg-config --static --libs glfw3` -lvulkan -ldl -lpthread -lX11 -lXrandr -lXi
|
||||||
|
|
||||||
|
# create list of all spv files and set as dependency
|
||||||
|
vertSources = $(shell find ./shaders -type f -name "*.vert")
|
||||||
|
vertSpvs = $(patsubst %.vert, %.vert.spv, $(vertSources))
|
||||||
|
fragSources = $(shell find ./shaders -type f -name "*.frag")
|
||||||
|
fragSpvs = $(patsubst %.frag, %.frag.spv, $(fragSources))
|
||||||
|
|
||||||
|
TARGET = VulkanTest
|
||||||
|
$(TARGET): $(vertSpvs) $(fragSpvs)
|
||||||
|
$(TARGET): *.cpp *.hpp
|
||||||
|
g++ $(CFLAGS) -o $(TARGET) *.cpp $(LDFLAGS)
|
||||||
|
|
||||||
|
# make shader targets
|
||||||
|
%.spv: %
|
||||||
|
${GLSLC} $< -o $@
|
||||||
|
|
||||||
|
.PHONY: test clean
|
||||||
|
|
||||||
|
test: VulkanTest
|
||||||
|
./VulkanTest
|
||||||
|
|
||||||
|
clean:
|
||||||
|
rm -f VulkanTest
|
||||||
|
rm -f *.spv
|
||||||
Binary file not shown.
|
|
@ -0,0 +1,2 @@
|
||||||
|
/usr/local/bin/glslc shaders/simple_shader.vert -o shaders/simple_shader.vert.spv
|
||||||
|
/usr/local/bin/glslc shaders/simple_shader.frag -o shaders/simple_shader.frag.spv
|
||||||
|
|
@ -0,0 +1,140 @@
|
||||||
|
#include "first_app.hpp"
|
||||||
|
|
||||||
|
// std
|
||||||
|
#include <stdexcept>
|
||||||
|
#include <array>
|
||||||
|
|
||||||
|
namespace hk
|
||||||
|
{
|
||||||
|
FirstApp::FirstApp()
|
||||||
|
{
|
||||||
|
loadModels();
|
||||||
|
createPipelineLayout();
|
||||||
|
createPipeline();
|
||||||
|
createCommandBuffers();
|
||||||
|
}
|
||||||
|
|
||||||
|
FirstApp::~FirstApp()
|
||||||
|
{
|
||||||
|
vkDestroyPipelineLayout(device.device(), pipelineLayout, nullptr);
|
||||||
|
}
|
||||||
|
|
||||||
|
void FirstApp::run()
|
||||||
|
{
|
||||||
|
while (!window.shouldClose())
|
||||||
|
{
|
||||||
|
glfwPollEvents();
|
||||||
|
drawFrame();
|
||||||
|
}
|
||||||
|
|
||||||
|
vkDeviceWaitIdle(device.device());
|
||||||
|
}
|
||||||
|
|
||||||
|
void FirstApp::loadModels()
|
||||||
|
{
|
||||||
|
std::vector<Model::Vertex> vertices{
|
||||||
|
{{0.0f, -0.5f}, {1.0f, 0.0f, 0.0f}},
|
||||||
|
{{0.5f, 0.5f}, {0.0f, 1.0f, 0.0f}},
|
||||||
|
{{-0.5f, 0.5f}, {0.0f, 0.0f, 1.0f}}
|
||||||
|
};
|
||||||
|
model = std::make_unique<Model>(device, vertices);
|
||||||
|
}
|
||||||
|
|
||||||
|
void FirstApp::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.device(), &pipelineLayoutInfo, nullptr, &pipelineLayout) !=
|
||||||
|
VK_SUCCESS)
|
||||||
|
{
|
||||||
|
throw std::runtime_error("failed to create pipeline layout!");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void FirstApp::createPipeline()
|
||||||
|
{
|
||||||
|
auto pipelineConfig =
|
||||||
|
Pipeline::defaultPipelineConfigInfo(swapChain.width(), swapChain.height());
|
||||||
|
|
||||||
|
pipelineConfig.renderPass = swapChain.getRenderPass();
|
||||||
|
pipelineConfig.pipelineLayout = pipelineLayout;
|
||||||
|
pipeline = std::make_unique<Pipeline>(
|
||||||
|
device,
|
||||||
|
"shaders/simple_shader.vert.spv",
|
||||||
|
"shaders/simple_shader.frag.spv",
|
||||||
|
pipelineConfig);
|
||||||
|
}
|
||||||
|
|
||||||
|
void FirstApp::createCommandBuffers()
|
||||||
|
{
|
||||||
|
commandBuffers.resize(swapChain.imageCount());
|
||||||
|
|
||||||
|
VkCommandBufferAllocateInfo allocInfo{};
|
||||||
|
allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
|
||||||
|
allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
|
||||||
|
allocInfo.commandPool = device.getCommandPool();
|
||||||
|
allocInfo.commandBufferCount = static_cast<uint32_t>(commandBuffers.size());
|
||||||
|
|
||||||
|
if (vkAllocateCommandBuffers(device.device(), &allocInfo, commandBuffers.data()) !=
|
||||||
|
VK_SUCCESS)
|
||||||
|
{
|
||||||
|
throw std::runtime_error("failed to allocate command buffers!");
|
||||||
|
}
|
||||||
|
for (int i = 0; i < commandBuffers.size(); i++)
|
||||||
|
{
|
||||||
|
VkCommandBufferBeginInfo beginInfo{};
|
||||||
|
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
|
||||||
|
if (vkBeginCommandBuffer(commandBuffers[i], &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 = swapChain.getRenderPass();
|
||||||
|
renderPassInfo.framebuffer = swapChain.getFrameBuffer(i);
|
||||||
|
|
||||||
|
renderPassInfo.renderArea.offset = {0, 0};
|
||||||
|
renderPassInfo.renderArea.extent = swapChain.getSwapChainExtent();
|
||||||
|
|
||||||
|
std::array<VkClearValue, 2> clearValues{};
|
||||||
|
clearValues[0].color = {0.1f, 0.1f, 0.1f, 1.0f};
|
||||||
|
clearValues[1].depthStencil = {1.0f, 0};
|
||||||
|
renderPassInfo.clearValueCount = static_cast<uint32_t>(clearValues.size());
|
||||||
|
renderPassInfo.pClearValues = clearValues.data();
|
||||||
|
|
||||||
|
vkCmdBeginRenderPass(commandBuffers[i], &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);
|
||||||
|
|
||||||
|
pipeline->bind(commandBuffers[i]);
|
||||||
|
model->bind(commandBuffers[i]);
|
||||||
|
model->draw(commandBuffers[i]);
|
||||||
|
|
||||||
|
vkCmdEndRenderPass(commandBuffers[i]);
|
||||||
|
if (vkEndCommandBuffer(commandBuffers[i]) != VK_SUCCESS)
|
||||||
|
{
|
||||||
|
throw std::runtime_error("failed to record command buffer!");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void FirstApp::drawFrame()
|
||||||
|
{
|
||||||
|
uint32_t imageIndex;
|
||||||
|
auto result = swapChain.acquireNextImage(&imageIndex);
|
||||||
|
if (result != VK_SUCCESS && result != VK_SUBOPTIMAL_KHR)
|
||||||
|
{
|
||||||
|
throw std::runtime_error("failed to acquire swap chain image!");
|
||||||
|
}
|
||||||
|
|
||||||
|
result = swapChain.submitCommandBuffers(&commandBuffers[imageIndex], &imageIndex);
|
||||||
|
if (result != VK_SUCCESS)
|
||||||
|
{
|
||||||
|
throw std::runtime_error("failed to present swap chain image!");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,44 @@
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include "hk_device.hpp"
|
||||||
|
#include "hk_pipeline.hpp"
|
||||||
|
#include "hk_swap_chain.hpp"
|
||||||
|
#include "hk_window.hpp"
|
||||||
|
#include "hk_model.hpp"
|
||||||
|
|
||||||
|
// std
|
||||||
|
#include <memory>
|
||||||
|
#include <vector>
|
||||||
|
|
||||||
|
namespace hk
|
||||||
|
{
|
||||||
|
class FirstApp
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
static constexpr int WIDTH = 800;
|
||||||
|
static constexpr int HEIGHT = 600;
|
||||||
|
|
||||||
|
FirstApp();
|
||||||
|
~FirstApp();
|
||||||
|
|
||||||
|
FirstApp(const FirstApp &) = delete;
|
||||||
|
FirstApp &operator=(const FirstApp &) = delete;
|
||||||
|
|
||||||
|
void run();
|
||||||
|
|
||||||
|
private:
|
||||||
|
void loadModels();
|
||||||
|
void createPipelineLayout();
|
||||||
|
void createPipeline();
|
||||||
|
void createCommandBuffers();
|
||||||
|
void drawFrame();
|
||||||
|
|
||||||
|
Window window{WIDTH, HEIGHT, "Hello Vulkan!"};
|
||||||
|
Device device{window};
|
||||||
|
SwapChain swapChain{device, window.getExtend()};
|
||||||
|
std::unique_ptr<Pipeline> pipeline;
|
||||||
|
VkPipelineLayout pipelineLayout;
|
||||||
|
std::vector<VkCommandBuffer> commandBuffers;
|
||||||
|
std::unique_ptr<Model> model;
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,610 @@
|
||||||
|
#include "hk_device.hpp"
|
||||||
|
|
||||||
|
// std headers
|
||||||
|
#include <cstring>
|
||||||
|
#include <iostream>
|
||||||
|
#include <set>
|
||||||
|
#include <unordered_set>
|
||||||
|
|
||||||
|
namespace hk
|
||||||
|
{
|
||||||
|
|
||||||
|
// local callback functions
|
||||||
|
static VKAPI_ATTR VkBool32 VKAPI_CALL debugCallback(
|
||||||
|
VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
|
||||||
|
VkDebugUtilsMessageTypeFlagsEXT messageType,
|
||||||
|
const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData,
|
||||||
|
void *pUserData)
|
||||||
|
{
|
||||||
|
std::cerr << "validation layer: " << pCallbackData->pMessage << std::endl;
|
||||||
|
|
||||||
|
return VK_FALSE;
|
||||||
|
}
|
||||||
|
|
||||||
|
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);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// class member functions
|
||||||
|
Device::Device(Window &window) : window{window}
|
||||||
|
{
|
||||||
|
createInstance();
|
||||||
|
setupDebugMessenger();
|
||||||
|
createSurface();
|
||||||
|
pickPhysicalDevice();
|
||||||
|
createLogicalDevice();
|
||||||
|
createCommandPool();
|
||||||
|
}
|
||||||
|
|
||||||
|
Device::~Device()
|
||||||
|
{
|
||||||
|
vkDestroyCommandPool(device_, commandPool, nullptr);
|
||||||
|
vkDestroyDevice(device_, nullptr);
|
||||||
|
|
||||||
|
if (enableValidationLayers)
|
||||||
|
{
|
||||||
|
DestroyDebugUtilsMessengerEXT(instance, debugMessenger, nullptr);
|
||||||
|
}
|
||||||
|
|
||||||
|
vkDestroySurfaceKHR(instance, surface_, nullptr);
|
||||||
|
vkDestroyInstance(instance, nullptr);
|
||||||
|
}
|
||||||
|
|
||||||
|
void Device::createInstance()
|
||||||
|
{
|
||||||
|
if (enableValidationLayers && !checkValidationLayerSupport())
|
||||||
|
{
|
||||||
|
throw std::runtime_error("validation layers requested, but not available!");
|
||||||
|
}
|
||||||
|
|
||||||
|
VkApplicationInfo appInfo = {};
|
||||||
|
appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
|
||||||
|
appInfo.pApplicationName = "LittleVulkanEngine App";
|
||||||
|
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;
|
||||||
|
|
||||||
|
VkInstanceCreateInfo createInfo = {};
|
||||||
|
createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
|
||||||
|
createInfo.pApplicationInfo = &appInfo;
|
||||||
|
|
||||||
|
auto extensions = getRequiredExtensions();
|
||||||
|
createInfo.enabledExtensionCount = static_cast<uint32_t>(extensions.size());
|
||||||
|
createInfo.ppEnabledExtensionNames = extensions.data();
|
||||||
|
|
||||||
|
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;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (vkCreateInstance(&createInfo, nullptr, &instance) != VK_SUCCESS)
|
||||||
|
{
|
||||||
|
throw std::runtime_error("failed to create instance!");
|
||||||
|
}
|
||||||
|
|
||||||
|
hasGflwRequiredInstanceExtensions();
|
||||||
|
}
|
||||||
|
|
||||||
|
void Device::pickPhysicalDevice()
|
||||||
|
{
|
||||||
|
uint32_t deviceCount = 0;
|
||||||
|
vkEnumeratePhysicalDevices(instance, &deviceCount, nullptr);
|
||||||
|
if (deviceCount == 0)
|
||||||
|
{
|
||||||
|
throw std::runtime_error("failed to find GPUs with Vulkan support!");
|
||||||
|
}
|
||||||
|
std::cout << "Device count: " << deviceCount << std::endl;
|
||||||
|
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!");
|
||||||
|
}
|
||||||
|
|
||||||
|
vkGetPhysicalDeviceProperties(physicalDevice, &properties);
|
||||||
|
std::cout << "physical device: " << properties.deviceName << std::endl;
|
||||||
|
}
|
||||||
|
|
||||||
|
void Device::createLogicalDevice()
|
||||||
|
{
|
||||||
|
QueueFamilyIndices indices = findQueueFamilies(physicalDevice);
|
||||||
|
|
||||||
|
std::vector<VkDeviceQueueCreateInfo> queueCreateInfos;
|
||||||
|
std::set<uint32_t> uniqueQueueFamilies = {indices.graphicsFamily, indices.presentFamily};
|
||||||
|
|
||||||
|
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 = {};
|
||||||
|
deviceFeatures.samplerAnisotropy = VK_TRUE;
|
||||||
|
|
||||||
|
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;
|
||||||
|
createInfo.enabledExtensionCount = static_cast<uint32_t>(deviceExtensions.size());
|
||||||
|
createInfo.ppEnabledExtensionNames = deviceExtensions.data();
|
||||||
|
|
||||||
|
// might not really be necessary anymore because device specific validation layers
|
||||||
|
// have been deprecated
|
||||||
|
if (enableValidationLayers)
|
||||||
|
{
|
||||||
|
createInfo.enabledLayerCount = static_cast<uint32_t>(validationLayers.size());
|
||||||
|
createInfo.ppEnabledLayerNames = validationLayers.data();
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
createInfo.enabledLayerCount = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (vkCreateDevice(physicalDevice, &createInfo, nullptr, &device_) != VK_SUCCESS)
|
||||||
|
{
|
||||||
|
throw std::runtime_error("failed to create logical device!");
|
||||||
|
}
|
||||||
|
|
||||||
|
vkGetDeviceQueue(device_, indices.graphicsFamily, 0, &graphicsQueue_);
|
||||||
|
vkGetDeviceQueue(device_, indices.presentFamily, 0, &presentQueue_);
|
||||||
|
}
|
||||||
|
|
||||||
|
void Device::createCommandPool()
|
||||||
|
{
|
||||||
|
QueueFamilyIndices queueFamilyIndices = findPhysicalQueueFamilies();
|
||||||
|
|
||||||
|
VkCommandPoolCreateInfo poolInfo = {};
|
||||||
|
poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
|
||||||
|
poolInfo.queueFamilyIndex = queueFamilyIndices.graphicsFamily;
|
||||||
|
poolInfo.flags =
|
||||||
|
VK_COMMAND_POOL_CREATE_TRANSIENT_BIT | 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!");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void Device::createSurface() { window.createWindowSurface(instance, &surface_); }
|
||||||
|
|
||||||
|
bool Device::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();
|
||||||
|
}
|
||||||
|
|
||||||
|
VkPhysicalDeviceFeatures supportedFeatures;
|
||||||
|
vkGetPhysicalDeviceFeatures(device, &supportedFeatures);
|
||||||
|
|
||||||
|
return indices.isComplete() && extensionsSupported && swapChainAdequate &&
|
||||||
|
supportedFeatures.samplerAnisotropy;
|
||||||
|
}
|
||||||
|
|
||||||
|
void Device::populateDebugMessengerCreateInfo(
|
||||||
|
VkDebugUtilsMessengerCreateInfoEXT &createInfo)
|
||||||
|
{
|
||||||
|
createInfo = {};
|
||||||
|
createInfo.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
|
||||||
|
createInfo.messageSeverity = 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; // Optional
|
||||||
|
}
|
||||||
|
|
||||||
|
void Device::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!");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
bool Device::checkValidationLayerSupport()
|
||||||
|
{
|
||||||
|
uint32_t layerCount;
|
||||||
|
vkEnumerateInstanceLayerProperties(&layerCount, nullptr);
|
||||||
|
|
||||||
|
std::vector<VkLayerProperties> availableLayers(layerCount);
|
||||||
|
vkEnumerateInstanceLayerProperties(&layerCount, availableLayers.data());
|
||||||
|
|
||||||
|
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;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::vector<const char *> Device::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 Device::hasGflwRequiredInstanceExtensions()
|
||||||
|
{
|
||||||
|
uint32_t extensionCount = 0;
|
||||||
|
vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, nullptr);
|
||||||
|
std::vector<VkExtensionProperties> extensions(extensionCount);
|
||||||
|
vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, extensions.data());
|
||||||
|
|
||||||
|
std::cout << "available extensions:" << std::endl;
|
||||||
|
std::unordered_set<std::string> available;
|
||||||
|
for (const auto &extension : extensions)
|
||||||
|
{
|
||||||
|
std::cout << "\t" << extension.extensionName << std::endl;
|
||||||
|
available.insert(extension.extensionName);
|
||||||
|
}
|
||||||
|
|
||||||
|
std::cout << "required extensions:" << std::endl;
|
||||||
|
auto requiredExtensions = getRequiredExtensions();
|
||||||
|
for (const auto &required : requiredExtensions)
|
||||||
|
{
|
||||||
|
std::cout << "\t" << required << std::endl;
|
||||||
|
if (available.find(required) == available.end())
|
||||||
|
{
|
||||||
|
throw std::runtime_error("Missing required glfw extension");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
bool Device::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(deviceExtensions.begin(), deviceExtensions.end());
|
||||||
|
|
||||||
|
for (const auto &extension : availableExtensions)
|
||||||
|
{
|
||||||
|
requiredExtensions.erase(extension.extensionName);
|
||||||
|
}
|
||||||
|
|
||||||
|
return requiredExtensions.empty();
|
||||||
|
}
|
||||||
|
|
||||||
|
QueueFamilyIndices Device::findQueueFamilies(VkPhysicalDevice device)
|
||||||
|
{
|
||||||
|
QueueFamilyIndices indices;
|
||||||
|
|
||||||
|
uint32_t queueFamilyCount = 0;
|
||||||
|
vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, nullptr);
|
||||||
|
|
||||||
|
std::vector<VkQueueFamilyProperties> queueFamilies(queueFamilyCount);
|
||||||
|
vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, queueFamilies.data());
|
||||||
|
|
||||||
|
int i = 0;
|
||||||
|
for (const auto &queueFamily : queueFamilies)
|
||||||
|
{
|
||||||
|
if (queueFamily.queueCount > 0 && queueFamily.queueFlags & VK_QUEUE_GRAPHICS_BIT)
|
||||||
|
{
|
||||||
|
indices.graphicsFamily = i;
|
||||||
|
indices.graphicsFamilyHasValue = true;
|
||||||
|
}
|
||||||
|
VkBool32 presentSupport = false;
|
||||||
|
vkGetPhysicalDeviceSurfaceSupportKHR(device, i, surface_, &presentSupport);
|
||||||
|
if (queueFamily.queueCount > 0 && presentSupport)
|
||||||
|
{
|
||||||
|
indices.presentFamily = i;
|
||||||
|
indices.presentFamilyHasValue = true;
|
||||||
|
}
|
||||||
|
if (indices.isComplete())
|
||||||
|
{
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
i++;
|
||||||
|
}
|
||||||
|
|
||||||
|
return indices;
|
||||||
|
}
|
||||||
|
|
||||||
|
SwapChainSupportDetails Device::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;
|
||||||
|
}
|
||||||
|
|
||||||
|
VkFormat Device::findSupportedFormat(
|
||||||
|
const std::vector<VkFormat> &candidates, VkImageTiling tiling, VkFormatFeatureFlags features)
|
||||||
|
{
|
||||||
|
for (VkFormat format : candidates)
|
||||||
|
{
|
||||||
|
VkFormatProperties props;
|
||||||
|
vkGetPhysicalDeviceFormatProperties(physicalDevice, format, &props);
|
||||||
|
|
||||||
|
if (tiling == VK_IMAGE_TILING_LINEAR && (props.linearTilingFeatures & features) == features)
|
||||||
|
{
|
||||||
|
return format;
|
||||||
|
}
|
||||||
|
else if (
|
||||||
|
tiling == VK_IMAGE_TILING_OPTIMAL && (props.optimalTilingFeatures & features) == features)
|
||||||
|
{
|
||||||
|
return format;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
throw std::runtime_error("failed to find supported format!");
|
||||||
|
}
|
||||||
|
|
||||||
|
uint32_t Device::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 Device::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!");
|
||||||
|
}
|
||||||
|
|
||||||
|
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);
|
||||||
|
}
|
||||||
|
|
||||||
|
VkCommandBuffer Device::beginSingleTimeCommands()
|
||||||
|
{
|
||||||
|
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 Device::endSingleTimeCommands(VkCommandBuffer commandBuffer)
|
||||||
|
{
|
||||||
|
vkEndCommandBuffer(commandBuffer);
|
||||||
|
|
||||||
|
VkSubmitInfo submitInfo{};
|
||||||
|
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
|
||||||
|
submitInfo.commandBufferCount = 1;
|
||||||
|
submitInfo.pCommandBuffers = &commandBuffer;
|
||||||
|
|
||||||
|
vkQueueSubmit(graphicsQueue_, 1, &submitInfo, VK_NULL_HANDLE);
|
||||||
|
vkQueueWaitIdle(graphicsQueue_);
|
||||||
|
|
||||||
|
vkFreeCommandBuffers(device_, commandPool, 1, &commandBuffer);
|
||||||
|
}
|
||||||
|
|
||||||
|
void Device::copyBuffer(VkBuffer srcBuffer, VkBuffer dstBuffer, VkDeviceSize size)
|
||||||
|
{
|
||||||
|
VkCommandBuffer commandBuffer = beginSingleTimeCommands();
|
||||||
|
|
||||||
|
VkBufferCopy copyRegion{};
|
||||||
|
copyRegion.srcOffset = 0; // Optional
|
||||||
|
copyRegion.dstOffset = 0; // Optional
|
||||||
|
copyRegion.size = size;
|
||||||
|
vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, 1, ©Region);
|
||||||
|
|
||||||
|
endSingleTimeCommands(commandBuffer);
|
||||||
|
}
|
||||||
|
|
||||||
|
void Device::copyBufferToImage(
|
||||||
|
VkBuffer buffer, VkImage image, uint32_t width, uint32_t height, uint32_t layerCount)
|
||||||
|
{
|
||||||
|
VkCommandBuffer commandBuffer = beginSingleTimeCommands();
|
||||||
|
|
||||||
|
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 = layerCount;
|
||||||
|
|
||||||
|
region.imageOffset = {0, 0, 0};
|
||||||
|
region.imageExtent = {width, height, 1};
|
||||||
|
|
||||||
|
vkCmdCopyBufferToImage(
|
||||||
|
commandBuffer,
|
||||||
|
buffer,
|
||||||
|
image,
|
||||||
|
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
|
||||||
|
1,
|
||||||
|
®ion);
|
||||||
|
endSingleTimeCommands(commandBuffer);
|
||||||
|
}
|
||||||
|
|
||||||
|
void Device::createImageWithInfo(
|
||||||
|
const VkImageCreateInfo &imageInfo,
|
||||||
|
VkMemoryPropertyFlags properties,
|
||||||
|
VkImage &image,
|
||||||
|
VkDeviceMemory &imageMemory)
|
||||||
|
{
|
||||||
|
if (vkCreateImage(device_, &imageInfo, nullptr, &image) != VK_SUCCESS)
|
||||||
|
{
|
||||||
|
throw std::runtime_error("failed to create image!");
|
||||||
|
}
|
||||||
|
|
||||||
|
VkMemoryRequirements memRequirements;
|
||||||
|
vkGetImageMemoryRequirements(device_, image, &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, &imageMemory) != VK_SUCCESS)
|
||||||
|
{
|
||||||
|
throw std::runtime_error("failed to allocate image memory!");
|
||||||
|
}
|
||||||
|
|
||||||
|
if (vkBindImageMemory(device_, image, imageMemory, 0) != VK_SUCCESS)
|
||||||
|
{
|
||||||
|
throw std::runtime_error("failed to bind image memory!");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace hk
|
||||||
|
|
@ -0,0 +1,112 @@
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include "hk_window.hpp"
|
||||||
|
|
||||||
|
// std lib headers
|
||||||
|
#include <string>
|
||||||
|
#include <vector>
|
||||||
|
|
||||||
|
namespace hk
|
||||||
|
{
|
||||||
|
|
||||||
|
struct SwapChainSupportDetails
|
||||||
|
{
|
||||||
|
VkSurfaceCapabilitiesKHR capabilities;
|
||||||
|
std::vector<VkSurfaceFormatKHR> formats;
|
||||||
|
std::vector<VkPresentModeKHR> presentModes;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct QueueFamilyIndices
|
||||||
|
{
|
||||||
|
uint32_t graphicsFamily;
|
||||||
|
uint32_t presentFamily;
|
||||||
|
bool graphicsFamilyHasValue = false;
|
||||||
|
bool presentFamilyHasValue = false;
|
||||||
|
bool isComplete() { return graphicsFamilyHasValue && presentFamilyHasValue; }
|
||||||
|
};
|
||||||
|
|
||||||
|
class Device
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
#ifdef NDEBUG
|
||||||
|
const bool enableValidationLayers = false;
|
||||||
|
#else
|
||||||
|
const bool enableValidationLayers = true;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
Device(Window &window);
|
||||||
|
~Device();
|
||||||
|
|
||||||
|
// Not copyable or movable
|
||||||
|
Device(const Device &) = delete;
|
||||||
|
void operator=(const Device &) = delete;
|
||||||
|
Device(Device &&) = delete;
|
||||||
|
Device &operator=(Device &&) = delete;
|
||||||
|
|
||||||
|
VkCommandPool getCommandPool() { return commandPool; }
|
||||||
|
VkDevice device() { return device_; }
|
||||||
|
VkSurfaceKHR surface() { return surface_; }
|
||||||
|
VkQueue graphicsQueue() { return graphicsQueue_; }
|
||||||
|
VkQueue presentQueue() { return presentQueue_; }
|
||||||
|
|
||||||
|
SwapChainSupportDetails getSwapChainSupport() { return querySwapChainSupport(physicalDevice); }
|
||||||
|
uint32_t findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags properties);
|
||||||
|
QueueFamilyIndices findPhysicalQueueFamilies() { return findQueueFamilies(physicalDevice); }
|
||||||
|
VkFormat findSupportedFormat(
|
||||||
|
const std::vector<VkFormat> &candidates, VkImageTiling tiling, VkFormatFeatureFlags features);
|
||||||
|
|
||||||
|
// Buffer Helper Functions
|
||||||
|
void createBuffer(
|
||||||
|
VkDeviceSize size,
|
||||||
|
VkBufferUsageFlags usage,
|
||||||
|
VkMemoryPropertyFlags properties,
|
||||||
|
VkBuffer &buffer,
|
||||||
|
VkDeviceMemory &bufferMemory);
|
||||||
|
VkCommandBuffer beginSingleTimeCommands();
|
||||||
|
void endSingleTimeCommands(VkCommandBuffer commandBuffer);
|
||||||
|
void copyBuffer(VkBuffer srcBuffer, VkBuffer dstBuffer, VkDeviceSize size);
|
||||||
|
void copyBufferToImage(
|
||||||
|
VkBuffer buffer, VkImage image, uint32_t width, uint32_t height, uint32_t layerCount);
|
||||||
|
|
||||||
|
void createImageWithInfo(
|
||||||
|
const VkImageCreateInfo &imageInfo,
|
||||||
|
VkMemoryPropertyFlags properties,
|
||||||
|
VkImage &image,
|
||||||
|
VkDeviceMemory &imageMemory);
|
||||||
|
|
||||||
|
VkPhysicalDeviceProperties properties;
|
||||||
|
|
||||||
|
private:
|
||||||
|
void createInstance();
|
||||||
|
void setupDebugMessenger();
|
||||||
|
void createSurface();
|
||||||
|
void pickPhysicalDevice();
|
||||||
|
void createLogicalDevice();
|
||||||
|
void createCommandPool();
|
||||||
|
|
||||||
|
// helper functions
|
||||||
|
bool isDeviceSuitable(VkPhysicalDevice device);
|
||||||
|
std::vector<const char *> getRequiredExtensions();
|
||||||
|
bool checkValidationLayerSupport();
|
||||||
|
QueueFamilyIndices findQueueFamilies(VkPhysicalDevice device);
|
||||||
|
void populateDebugMessengerCreateInfo(VkDebugUtilsMessengerCreateInfoEXT &createInfo);
|
||||||
|
void hasGflwRequiredInstanceExtensions();
|
||||||
|
bool checkDeviceExtensionSupport(VkPhysicalDevice device);
|
||||||
|
SwapChainSupportDetails querySwapChainSupport(VkPhysicalDevice device);
|
||||||
|
|
||||||
|
VkInstance instance;
|
||||||
|
VkDebugUtilsMessengerEXT debugMessenger;
|
||||||
|
VkPhysicalDevice physicalDevice = VK_NULL_HANDLE;
|
||||||
|
Window &window;
|
||||||
|
VkCommandPool commandPool;
|
||||||
|
|
||||||
|
VkDevice device_;
|
||||||
|
VkSurfaceKHR surface_;
|
||||||
|
VkQueue graphicsQueue_;
|
||||||
|
VkQueue presentQueue_;
|
||||||
|
|
||||||
|
const std::vector<const char *> validationLayers = {"VK_LAYER_KHRONOS_validation"};
|
||||||
|
const std::vector<const char *> deviceExtensions = {VK_KHR_SWAPCHAIN_EXTENSION_NAME};
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace hk
|
||||||
|
|
@ -0,0 +1,71 @@
|
||||||
|
#include "hk_model.hpp"
|
||||||
|
|
||||||
|
#include <cassert>
|
||||||
|
#include <cstring>
|
||||||
|
|
||||||
|
namespace hk{
|
||||||
|
Model::Model(Device &device, const std::vector<Vertex> &vertices)
|
||||||
|
: device{device}
|
||||||
|
{
|
||||||
|
createVertexBuffers(vertices);
|
||||||
|
}
|
||||||
|
|
||||||
|
Model::~Model()
|
||||||
|
{
|
||||||
|
vkDestroyBuffer(device.device(), vertexBuffer, nullptr);
|
||||||
|
vkFreeMemory(device.device(), vertexBufferMemory, nullptr);
|
||||||
|
}
|
||||||
|
|
||||||
|
void Model::createVertexBuffers(const std::vector<Vertex> &vertices)
|
||||||
|
{
|
||||||
|
vertexCount = static_cast<uint32_t>(vertices.size());
|
||||||
|
assert(vertexCount >= 3 && "Vertex count must be at least 3");
|
||||||
|
VkDeviceSize bufferSize = sizeof(vertices[0]) * vertexCount;
|
||||||
|
device.createBuffer(
|
||||||
|
bufferSize,
|
||||||
|
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
|
||||||
|
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
|
||||||
|
vertexBuffer,
|
||||||
|
vertexBufferMemory
|
||||||
|
);
|
||||||
|
void *data;
|
||||||
|
vkMapMemory(device.device(), vertexBufferMemory, 0, bufferSize, 0, &data);
|
||||||
|
memcpy(data, vertices.data(), static_cast<size_t>(bufferSize));
|
||||||
|
vkUnmapMemory(device.device(), vertexBufferMemory);
|
||||||
|
}
|
||||||
|
|
||||||
|
void Model::bind(VkCommandBuffer commandBuffer)
|
||||||
|
{
|
||||||
|
VkBuffer buffers[] = {vertexBuffer};
|
||||||
|
VkDeviceSize offsets[] = {0};
|
||||||
|
vkCmdBindVertexBuffers(commandBuffer, 0, 1, buffers, offsets);
|
||||||
|
}
|
||||||
|
void Model::draw(VkCommandBuffer commandBuffer)
|
||||||
|
{
|
||||||
|
vkCmdDraw(commandBuffer, vertexCount, 1, 0, 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
std::vector<VkVertexInputBindingDescription> Model::Vertex::getBindingDescriptions()
|
||||||
|
{
|
||||||
|
std::vector<VkVertexInputBindingDescription> bindingDescriptions(1);
|
||||||
|
bindingDescriptions[0].binding = 0;
|
||||||
|
bindingDescriptions[0].stride = sizeof(Vertex);
|
||||||
|
bindingDescriptions[0].inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
|
||||||
|
return bindingDescriptions;
|
||||||
|
}
|
||||||
|
std::vector<VkVertexInputAttributeDescription> Model::Vertex::getAttributeDescriptions()
|
||||||
|
{
|
||||||
|
std::vector<VkVertexInputAttributeDescription> attributeDescriptions(2);
|
||||||
|
attributeDescriptions[0].binding = 0;
|
||||||
|
attributeDescriptions[0].location = 0;
|
||||||
|
attributeDescriptions[0].format = VK_FORMAT_R32G32_SFLOAT;
|
||||||
|
attributeDescriptions[0].offset = offsetof(Vertex, posision);
|
||||||
|
|
||||||
|
attributeDescriptions[1].binding = 0;
|
||||||
|
attributeDescriptions[1].location = 1;
|
||||||
|
attributeDescriptions[1].format = VK_FORMAT_R32G32B32_SFLOAT;
|
||||||
|
attributeDescriptions[1].offset = offsetof(Vertex, color);
|
||||||
|
|
||||||
|
return attributeDescriptions;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,39 @@
|
||||||
|
#pragma once
|
||||||
|
#include "hk_device.hpp"
|
||||||
|
|
||||||
|
// libs
|
||||||
|
#define GLM_FORCE_RADIANS
|
||||||
|
#define GLM_FORCE_DEPTH_ZERO_TO_ONE
|
||||||
|
#include <glm/glm.hpp>
|
||||||
|
|
||||||
|
#include <vector>
|
||||||
|
|
||||||
|
namespace hk{
|
||||||
|
class Model
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
struct Vertex {
|
||||||
|
glm::vec2 posision;
|
||||||
|
glm::vec3 color;
|
||||||
|
|
||||||
|
static std::vector<VkVertexInputBindingDescription> getBindingDescriptions();
|
||||||
|
static std::vector<VkVertexInputAttributeDescription> getAttributeDescriptions();
|
||||||
|
};
|
||||||
|
|
||||||
|
Model(Device &device, const std::vector<Vertex> &vertices);
|
||||||
|
~Model();
|
||||||
|
|
||||||
|
Model(const Model &) = delete;
|
||||||
|
Model &operator=(const Model &) = delete;
|
||||||
|
|
||||||
|
void bind(VkCommandBuffer commandBuffer);
|
||||||
|
void draw(VkCommandBuffer commandBuffer);
|
||||||
|
private:
|
||||||
|
void createVertexBuffers(const std::vector<Vertex> &vertices);
|
||||||
|
|
||||||
|
Device &device;
|
||||||
|
VkBuffer vertexBuffer;
|
||||||
|
VkDeviceMemory vertexBufferMemory;
|
||||||
|
uint32_t vertexCount;
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,214 @@
|
||||||
|
#include "hk_pipeline.hpp"
|
||||||
|
|
||||||
|
#include "hk_model.hpp"
|
||||||
|
|
||||||
|
// std
|
||||||
|
#include <fstream>
|
||||||
|
#include <stdexcept>
|
||||||
|
#include <iostream>
|
||||||
|
#include <cassert>
|
||||||
|
|
||||||
|
namespace hk
|
||||||
|
{
|
||||||
|
Pipeline::Pipeline(
|
||||||
|
Device& device,
|
||||||
|
const std::string &vertFilePath,
|
||||||
|
const std::string &fragFilePath,
|
||||||
|
const PipelineConfigInfo& configInfo) : device(device)
|
||||||
|
{
|
||||||
|
createGraphicPipeline(vertFilePath, fragFilePath, configInfo);
|
||||||
|
}
|
||||||
|
|
||||||
|
Pipeline::~Pipeline()
|
||||||
|
{
|
||||||
|
vkDestroyShaderModule(device.device(), vertShaderModule, nullptr);
|
||||||
|
vkDestroyShaderModule(device.device(), fragShaderModule, nullptr);
|
||||||
|
vkDestroyPipeline(device.device(), graphicPipeline, nullptr);
|
||||||
|
}
|
||||||
|
|
||||||
|
void Pipeline::bind(VkCommandBuffer commandBuffer)
|
||||||
|
{
|
||||||
|
vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, graphicPipeline);
|
||||||
|
}
|
||||||
|
|
||||||
|
PipelineConfigInfo Pipeline::defaultPipelineConfigInfo(uint32_t width, uint32_t height)
|
||||||
|
{
|
||||||
|
PipelineConfigInfo configInfo{};
|
||||||
|
configInfo.inputAssemblyInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
|
||||||
|
configInfo.inputAssemblyInfo.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
|
||||||
|
configInfo.inputAssemblyInfo.primitiveRestartEnable = VK_FALSE;
|
||||||
|
|
||||||
|
configInfo.viewport.x = 0.0f;
|
||||||
|
configInfo.viewport.y = 0.0f;
|
||||||
|
configInfo.viewport.width = static_cast<float>(width);
|
||||||
|
configInfo.viewport.height = static_cast<float>(height);
|
||||||
|
configInfo.viewport.minDepth = 0.0f;
|
||||||
|
configInfo.viewport.maxDepth = 1.0f;
|
||||||
|
|
||||||
|
configInfo.scissor.offset = {0, 0};
|
||||||
|
configInfo.scissor.extent = {width, height};
|
||||||
|
|
||||||
|
configInfo.rasterizationInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
|
||||||
|
configInfo.rasterizationInfo.depthClampEnable = VK_FALSE;
|
||||||
|
configInfo.rasterizationInfo.rasterizerDiscardEnable = VK_FALSE;
|
||||||
|
configInfo.rasterizationInfo.polygonMode = VK_POLYGON_MODE_FILL;
|
||||||
|
configInfo.rasterizationInfo.lineWidth = 1.0f;
|
||||||
|
configInfo.rasterizationInfo.cullMode = VK_CULL_MODE_NONE;
|
||||||
|
configInfo.rasterizationInfo.frontFace = VK_FRONT_FACE_CLOCKWISE;
|
||||||
|
configInfo.rasterizationInfo.depthBiasEnable = VK_FALSE;
|
||||||
|
configInfo.rasterizationInfo.depthBiasConstantFactor = 0.0f; // Optional
|
||||||
|
configInfo.rasterizationInfo.depthBiasClamp = 0.0f; // Optional
|
||||||
|
configInfo.rasterizationInfo.depthBiasSlopeFactor = 0.0f; // Optional
|
||||||
|
|
||||||
|
configInfo.multisampleInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
|
||||||
|
configInfo.multisampleInfo.sampleShadingEnable = VK_FALSE;
|
||||||
|
configInfo.multisampleInfo.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
|
||||||
|
configInfo.multisampleInfo.minSampleShading = 1.0f; // Optional
|
||||||
|
configInfo.multisampleInfo.pSampleMask = nullptr; // Optional
|
||||||
|
configInfo.multisampleInfo.alphaToCoverageEnable = VK_FALSE; // Optional
|
||||||
|
configInfo.multisampleInfo.alphaToOneEnable = VK_FALSE; // Optional
|
||||||
|
|
||||||
|
configInfo.colorBlendAttachment.colorWriteMask =
|
||||||
|
VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT |
|
||||||
|
VK_COLOR_COMPONENT_A_BIT;
|
||||||
|
configInfo.colorBlendAttachment.blendEnable = VK_FALSE;
|
||||||
|
configInfo.colorBlendAttachment.srcColorBlendFactor = VK_BLEND_FACTOR_ONE; // Optional
|
||||||
|
configInfo.colorBlendAttachment.dstColorBlendFactor = VK_BLEND_FACTOR_ZERO; // Optional
|
||||||
|
configInfo.colorBlendAttachment.colorBlendOp = VK_BLEND_OP_ADD; // Optional
|
||||||
|
configInfo.colorBlendAttachment.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE; // Optional
|
||||||
|
configInfo.colorBlendAttachment.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO; // Optional
|
||||||
|
configInfo.colorBlendAttachment.alphaBlendOp = VK_BLEND_OP_ADD; // Optional
|
||||||
|
|
||||||
|
configInfo.colorBlendInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
|
||||||
|
configInfo.colorBlendInfo.logicOpEnable = VK_FALSE;
|
||||||
|
configInfo.colorBlendInfo.logicOp = VK_LOGIC_OP_COPY; // Optional
|
||||||
|
configInfo.colorBlendInfo.attachmentCount = 1;
|
||||||
|
configInfo.colorBlendInfo.pAttachments = &configInfo.colorBlendAttachment;
|
||||||
|
configInfo.colorBlendInfo.blendConstants[0] = 0.0f; // Optional
|
||||||
|
configInfo.colorBlendInfo.blendConstants[1] = 0.0f; // Optional
|
||||||
|
configInfo.colorBlendInfo.blendConstants[2] = 0.0f; // Optional
|
||||||
|
configInfo.colorBlendInfo.blendConstants[3] = 0.0f; // Optional
|
||||||
|
|
||||||
|
configInfo.depthStencilInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
|
||||||
|
configInfo.depthStencilInfo.depthTestEnable = VK_TRUE;
|
||||||
|
configInfo.depthStencilInfo.depthWriteEnable = VK_TRUE;
|
||||||
|
configInfo.depthStencilInfo.depthCompareOp = VK_COMPARE_OP_LESS;
|
||||||
|
configInfo.depthStencilInfo.depthBoundsTestEnable = VK_FALSE;
|
||||||
|
configInfo.depthStencilInfo.minDepthBounds = 0.0f; // Optional
|
||||||
|
configInfo.depthStencilInfo.maxDepthBounds = 1.0f; // Optional
|
||||||
|
configInfo.depthStencilInfo.stencilTestEnable = VK_FALSE;
|
||||||
|
configInfo.depthStencilInfo.front = {}; // Optional
|
||||||
|
configInfo.depthStencilInfo.back = {}; // Optional
|
||||||
|
|
||||||
|
return configInfo;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::vector<char> Pipeline::readFile(const std::string &filePath)
|
||||||
|
{
|
||||||
|
std::ifstream file(filePath, std::ios::ate | std::ios::binary);
|
||||||
|
|
||||||
|
if (!file.is_open())
|
||||||
|
{
|
||||||
|
throw std::runtime_error("failed to open file: " + filePath);
|
||||||
|
}
|
||||||
|
size_t fileSize = static_cast<size_t>(file.tellg());
|
||||||
|
std::vector<char> buffer(fileSize);
|
||||||
|
|
||||||
|
file.seekg(0);
|
||||||
|
file.read(buffer.data(), fileSize);
|
||||||
|
|
||||||
|
file.close();
|
||||||
|
|
||||||
|
return buffer;
|
||||||
|
}
|
||||||
|
|
||||||
|
void Pipeline::createGraphicPipeline(
|
||||||
|
const std::string& vertFilePath,
|
||||||
|
const std::string& fragFilePath,
|
||||||
|
const PipelineConfigInfo& configInfo)
|
||||||
|
{
|
||||||
|
|
||||||
|
assert(configInfo.pipelineLayout != VK_NULL_HANDLE && "Cannot create graphics pipeline: no pipelineLayout provided in configInfo");
|
||||||
|
assert(configInfo.renderPass != VK_NULL_HANDLE && "Cannot create graphics pipeline: no renderPass provided in configInfo");
|
||||||
|
|
||||||
|
|
||||||
|
std::vector<char> vertCode = readFile(vertFilePath);
|
||||||
|
std::vector<char> fragCode = readFile(fragFilePath);
|
||||||
|
|
||||||
|
createShaderModule(vertCode, &vertShaderModule);
|
||||||
|
createShaderModule(fragCode, &fragShaderModule);
|
||||||
|
|
||||||
|
VkPipelineShaderStageCreateInfo shaderStages[2];
|
||||||
|
shaderStages[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
|
||||||
|
shaderStages[0].stage = VK_SHADER_STAGE_VERTEX_BIT;
|
||||||
|
shaderStages[0].module = vertShaderModule;
|
||||||
|
shaderStages[0].pName = "main";
|
||||||
|
shaderStages[0].flags = 0;
|
||||||
|
shaderStages[0].pNext = nullptr;
|
||||||
|
shaderStages[0].pSpecializationInfo = nullptr;
|
||||||
|
|
||||||
|
shaderStages[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
|
||||||
|
shaderStages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT;
|
||||||
|
shaderStages[1].module = fragShaderModule;
|
||||||
|
shaderStages[1].pName = "main";
|
||||||
|
shaderStages[1].flags = 0;
|
||||||
|
shaderStages[1].pNext = nullptr;
|
||||||
|
shaderStages[1].pSpecializationInfo = nullptr;
|
||||||
|
|
||||||
|
auto bindingDescriptions = Model::Vertex::getBindingDescriptions();
|
||||||
|
auto attributeDescriptions = Model::Vertex::getAttributeDescriptions();
|
||||||
|
|
||||||
|
VkPipelineVertexInputStateCreateInfo vertexInputInfo{};
|
||||||
|
vertexInputInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
|
||||||
|
vertexInputInfo.vertexAttributeDescriptionCount = static_cast<uint32_t>(attributeDescriptions.size());
|
||||||
|
vertexInputInfo.vertexBindingDescriptionCount = static_cast<uint32_t>(bindingDescriptions.size());
|
||||||
|
vertexInputInfo.pVertexAttributeDescriptions = attributeDescriptions.data();
|
||||||
|
vertexInputInfo.pVertexBindingDescriptions = bindingDescriptions.data();
|
||||||
|
|
||||||
|
VkPipelineViewportStateCreateInfo viewportInfo{};
|
||||||
|
viewportInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
|
||||||
|
viewportInfo.viewportCount = 1;
|
||||||
|
viewportInfo.pViewports = &configInfo.viewport;
|
||||||
|
viewportInfo.scissorCount = 1;
|
||||||
|
viewportInfo.pScissors = &configInfo.scissor;
|
||||||
|
|
||||||
|
VkGraphicsPipelineCreateInfo pipelineInfo{};
|
||||||
|
pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
|
||||||
|
pipelineInfo.stageCount = 2;
|
||||||
|
pipelineInfo.pStages = shaderStages;
|
||||||
|
pipelineInfo.pVertexInputState = &vertexInputInfo;
|
||||||
|
pipelineInfo.pInputAssemblyState = &configInfo.inputAssemblyInfo;
|
||||||
|
pipelineInfo.pViewportState = &viewportInfo;
|
||||||
|
pipelineInfo.pRasterizationState = &configInfo.rasterizationInfo;
|
||||||
|
pipelineInfo.pMultisampleState = &configInfo.multisampleInfo;
|
||||||
|
pipelineInfo.pColorBlendState = &configInfo.colorBlendInfo;
|
||||||
|
pipelineInfo.pDepthStencilState = &configInfo.depthStencilInfo;
|
||||||
|
pipelineInfo.pDynamicState = nullptr;
|
||||||
|
|
||||||
|
pipelineInfo.layout = configInfo.pipelineLayout;
|
||||||
|
pipelineInfo.renderPass = configInfo.renderPass;
|
||||||
|
pipelineInfo.subpass = configInfo.subpass;
|
||||||
|
|
||||||
|
pipelineInfo.basePipelineIndex = -1;
|
||||||
|
pipelineInfo.basePipelineHandle = VK_NULL_HANDLE;
|
||||||
|
|
||||||
|
if (vkCreateGraphicsPipelines(device.device(), VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &graphicPipeline) != VK_SUCCESS)
|
||||||
|
{
|
||||||
|
throw std::runtime_error("failed to create graphics pipeline!");
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
void Pipeline::createShaderModule(const std::vector<char> &code, VkShaderModule *shaderModule)
|
||||||
|
{
|
||||||
|
VkShaderModuleCreateInfo createInfo{};
|
||||||
|
createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
|
||||||
|
createInfo.codeSize = code.size();
|
||||||
|
createInfo.pCode = reinterpret_cast<const uint32_t*>(code.data());
|
||||||
|
|
||||||
|
if (vkCreateShaderModule(device.device(), &createInfo, nullptr, shaderModule) != VK_SUCCESS)
|
||||||
|
{
|
||||||
|
throw std::runtime_error("failed to create shader module!");
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,57 @@
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include "hk_device.hpp"
|
||||||
|
|
||||||
|
// std
|
||||||
|
#include <string>
|
||||||
|
#include <vector>
|
||||||
|
|
||||||
|
namespace hk
|
||||||
|
{
|
||||||
|
struct PipelineConfigInfo
|
||||||
|
{
|
||||||
|
VkViewport viewport;
|
||||||
|
VkRect2D scissor;
|
||||||
|
VkPipelineInputAssemblyStateCreateInfo inputAssemblyInfo;
|
||||||
|
VkPipelineRasterizationStateCreateInfo rasterizationInfo;
|
||||||
|
VkPipelineMultisampleStateCreateInfo multisampleInfo;
|
||||||
|
VkPipelineColorBlendAttachmentState colorBlendAttachment;
|
||||||
|
VkPipelineColorBlendStateCreateInfo colorBlendInfo;
|
||||||
|
VkPipelineDepthStencilStateCreateInfo depthStencilInfo;
|
||||||
|
VkPipelineLayout pipelineLayout = nullptr;
|
||||||
|
VkRenderPass renderPass = nullptr;
|
||||||
|
uint32_t subpass = 0;
|
||||||
|
};
|
||||||
|
class Pipeline
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
Pipeline(
|
||||||
|
Device& device,
|
||||||
|
const std::string &vertFilePath,
|
||||||
|
const std::string &fragFilePath,
|
||||||
|
const PipelineConfigInfo& configInfo);
|
||||||
|
|
||||||
|
~Pipeline();
|
||||||
|
|
||||||
|
Pipeline(const Pipeline&) = delete;
|
||||||
|
Pipeline &operator=(const Pipeline&) = delete;
|
||||||
|
|
||||||
|
void bind(VkCommandBuffer commandBuffer);
|
||||||
|
|
||||||
|
static PipelineConfigInfo defaultPipelineConfigInfo(uint32_t width, uint32_t height);
|
||||||
|
|
||||||
|
private:
|
||||||
|
static std::vector<char> readFile(const std::string &filePath);
|
||||||
|
void createGraphicPipeline(
|
||||||
|
const std::string &vertFilePath,
|
||||||
|
const std::string &fragFilePath,
|
||||||
|
const PipelineConfigInfo& configInfo);
|
||||||
|
|
||||||
|
void createShaderModule(const std::vector<char>& code, VkShaderModule* shaderModule);
|
||||||
|
|
||||||
|
Device& device;
|
||||||
|
VkPipeline graphicPipeline;
|
||||||
|
VkShaderModule vertShaderModule;
|
||||||
|
VkShaderModule fragShaderModule;
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,460 @@
|
||||||
|
#include "hk_swap_chain.hpp"
|
||||||
|
|
||||||
|
// std
|
||||||
|
#include <array>
|
||||||
|
#include <cstdlib>
|
||||||
|
#include <cstring>
|
||||||
|
#include <iostream>
|
||||||
|
#include <limits>
|
||||||
|
#include <set>
|
||||||
|
#include <stdexcept>
|
||||||
|
|
||||||
|
namespace hk
|
||||||
|
{
|
||||||
|
|
||||||
|
SwapChain::SwapChain(Device &deviceRef, VkExtent2D extent)
|
||||||
|
: device{deviceRef}, windowExtent{extent}
|
||||||
|
{
|
||||||
|
createSwapChain();
|
||||||
|
createImageViews();
|
||||||
|
createRenderPass();
|
||||||
|
createDepthResources();
|
||||||
|
createFramebuffers();
|
||||||
|
createSyncObjects();
|
||||||
|
}
|
||||||
|
|
||||||
|
SwapChain::~SwapChain()
|
||||||
|
{
|
||||||
|
for (auto imageView : swapChainImageViews)
|
||||||
|
{
|
||||||
|
vkDestroyImageView(device.device(), imageView, nullptr);
|
||||||
|
}
|
||||||
|
swapChainImageViews.clear();
|
||||||
|
|
||||||
|
if (swapChain != nullptr)
|
||||||
|
{
|
||||||
|
vkDestroySwapchainKHR(device.device(), swapChain, nullptr);
|
||||||
|
swapChain = nullptr;
|
||||||
|
}
|
||||||
|
|
||||||
|
for (int i = 0; i < depthImages.size(); i++)
|
||||||
|
{
|
||||||
|
vkDestroyImageView(device.device(), depthImageViews[i], nullptr);
|
||||||
|
vkDestroyImage(device.device(), depthImages[i], nullptr);
|
||||||
|
vkFreeMemory(device.device(), depthImageMemorys[i], nullptr);
|
||||||
|
}
|
||||||
|
|
||||||
|
for (auto framebuffer : swapChainFramebuffers)
|
||||||
|
{
|
||||||
|
vkDestroyFramebuffer(device.device(), framebuffer, nullptr);
|
||||||
|
}
|
||||||
|
|
||||||
|
vkDestroyRenderPass(device.device(), renderPass, nullptr);
|
||||||
|
|
||||||
|
// cleanup synchronization objects
|
||||||
|
for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++)
|
||||||
|
{
|
||||||
|
vkDestroySemaphore(device.device(), renderFinishedSemaphores[i], nullptr);
|
||||||
|
vkDestroySemaphore(device.device(), imageAvailableSemaphores[i], nullptr);
|
||||||
|
vkDestroyFence(device.device(), inFlightFences[i], nullptr);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
VkResult SwapChain::acquireNextImage(uint32_t *imageIndex)
|
||||||
|
{
|
||||||
|
vkWaitForFences(
|
||||||
|
device.device(),
|
||||||
|
1,
|
||||||
|
&inFlightFences[currentFrame],
|
||||||
|
VK_TRUE,
|
||||||
|
std::numeric_limits<uint64_t>::max());
|
||||||
|
|
||||||
|
VkResult result = vkAcquireNextImageKHR(
|
||||||
|
device.device(),
|
||||||
|
swapChain,
|
||||||
|
std::numeric_limits<uint64_t>::max(),
|
||||||
|
imageAvailableSemaphores[currentFrame], // must be a not signaled semaphore
|
||||||
|
VK_NULL_HANDLE,
|
||||||
|
imageIndex);
|
||||||
|
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
VkResult SwapChain::submitCommandBuffers(
|
||||||
|
const VkCommandBuffer *buffers, uint32_t *imageIndex)
|
||||||
|
{
|
||||||
|
if (imagesInFlight[*imageIndex] != VK_NULL_HANDLE)
|
||||||
|
{
|
||||||
|
vkWaitForFences(device.device(), 1, &imagesInFlight[*imageIndex], VK_TRUE, UINT64_MAX);
|
||||||
|
}
|
||||||
|
imagesInFlight[*imageIndex] = inFlightFences[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 = buffers;
|
||||||
|
|
||||||
|
VkSemaphore signalSemaphores[] = {renderFinishedSemaphores[currentFrame]};
|
||||||
|
submitInfo.signalSemaphoreCount = 1;
|
||||||
|
submitInfo.pSignalSemaphores = signalSemaphores;
|
||||||
|
|
||||||
|
vkResetFences(device.device(), 1, &inFlightFences[currentFrame]);
|
||||||
|
if (vkQueueSubmit(device.graphicsQueue(), 1, &submitInfo, inFlightFences[currentFrame]) !=
|
||||||
|
VK_SUCCESS)
|
||||||
|
{
|
||||||
|
throw std::runtime_error("failed to submit draw command buffer!");
|
||||||
|
}
|
||||||
|
|
||||||
|
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;
|
||||||
|
|
||||||
|
auto result = vkQueuePresentKHR(device.presentQueue(), &presentInfo);
|
||||||
|
|
||||||
|
currentFrame = (currentFrame + 1) % MAX_FRAMES_IN_FLIGHT;
|
||||||
|
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
void SwapChain::createSwapChain()
|
||||||
|
{
|
||||||
|
SwapChainSupportDetails swapChainSupport = device.getSwapChainSupport();
|
||||||
|
|
||||||
|
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 = device.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 = device.findPhysicalQueueFamilies();
|
||||||
|
uint32_t queueFamilyIndices[] = {indices.graphicsFamily, indices.presentFamily};
|
||||||
|
|
||||||
|
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 = 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.device(), &createInfo, nullptr, &swapChain) != VK_SUCCESS)
|
||||||
|
{
|
||||||
|
throw std::runtime_error("failed to create swap chain!");
|
||||||
|
}
|
||||||
|
|
||||||
|
// we only specified a minimum number of images in the swap chain, so the implementation is
|
||||||
|
// allowed to create a swap chain with more. That's why we'll first query the final number of
|
||||||
|
// images with vkGetSwapchainImagesKHR, then resize the container and finally call it again to
|
||||||
|
// retrieve the handles.
|
||||||
|
vkGetSwapchainImagesKHR(device.device(), swapChain, &imageCount, nullptr);
|
||||||
|
swapChainImages.resize(imageCount);
|
||||||
|
vkGetSwapchainImagesKHR(device.device(), swapChain, &imageCount, swapChainImages.data());
|
||||||
|
|
||||||
|
swapChainImageFormat = surfaceFormat.format;
|
||||||
|
swapChainExtent = extent;
|
||||||
|
}
|
||||||
|
|
||||||
|
void SwapChain::createImageViews()
|
||||||
|
{
|
||||||
|
swapChainImageViews.resize(swapChainImages.size());
|
||||||
|
for (size_t i = 0; i < swapChainImages.size(); i++)
|
||||||
|
{
|
||||||
|
VkImageViewCreateInfo viewInfo{};
|
||||||
|
viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
|
||||||
|
viewInfo.image = swapChainImages[i];
|
||||||
|
viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
|
||||||
|
viewInfo.format = swapChainImageFormat;
|
||||||
|
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.device(), &viewInfo, nullptr, &swapChainImageViews[i]) !=
|
||||||
|
VK_SUCCESS)
|
||||||
|
{
|
||||||
|
throw std::runtime_error("failed to create texture image view!");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void SwapChain::createRenderPass()
|
||||||
|
{
|
||||||
|
VkAttachmentDescription depthAttachment{};
|
||||||
|
depthAttachment.format = findDepthFormat();
|
||||||
|
depthAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
|
||||||
|
depthAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
|
||||||
|
depthAttachment.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
|
||||||
|
depthAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
|
||||||
|
depthAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
|
||||||
|
depthAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
||||||
|
depthAttachment.finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
|
||||||
|
|
||||||
|
VkAttachmentReference depthAttachmentRef{};
|
||||||
|
depthAttachmentRef.attachment = 1;
|
||||||
|
depthAttachmentRef.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
|
||||||
|
|
||||||
|
VkAttachmentDescription colorAttachment = {};
|
||||||
|
colorAttachment.format = getSwapChainImageFormat();
|
||||||
|
colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
|
||||||
|
colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
|
||||||
|
colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
|
||||||
|
colorAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
|
||||||
|
colorAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_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;
|
||||||
|
subpass.pDepthStencilAttachment = &depthAttachmentRef;
|
||||||
|
|
||||||
|
VkSubpassDependency dependency = {};
|
||||||
|
dependency.srcSubpass = VK_SUBPASS_EXTERNAL;
|
||||||
|
dependency.srcAccessMask = 0;
|
||||||
|
dependency.srcStageMask =
|
||||||
|
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
|
||||||
|
dependency.dstSubpass = 0;
|
||||||
|
dependency.dstStageMask =
|
||||||
|
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
|
||||||
|
dependency.dstAccessMask =
|
||||||
|
VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
|
||||||
|
|
||||||
|
std::array<VkAttachmentDescription, 2> attachments = {colorAttachment, depthAttachment};
|
||||||
|
VkRenderPassCreateInfo renderPassInfo = {};
|
||||||
|
renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
|
||||||
|
renderPassInfo.attachmentCount = static_cast<uint32_t>(attachments.size());
|
||||||
|
renderPassInfo.pAttachments = attachments.data();
|
||||||
|
renderPassInfo.subpassCount = 1;
|
||||||
|
renderPassInfo.pSubpasses = &subpass;
|
||||||
|
renderPassInfo.dependencyCount = 1;
|
||||||
|
renderPassInfo.pDependencies = &dependency;
|
||||||
|
|
||||||
|
if (vkCreateRenderPass(device.device(), &renderPassInfo, nullptr, &renderPass) != VK_SUCCESS)
|
||||||
|
{
|
||||||
|
throw std::runtime_error("failed to create render pass!");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void SwapChain::createFramebuffers()
|
||||||
|
{
|
||||||
|
swapChainFramebuffers.resize(imageCount());
|
||||||
|
for (size_t i = 0; i < imageCount(); i++)
|
||||||
|
{
|
||||||
|
std::array<VkImageView, 2> attachments = {swapChainImageViews[i], depthImageViews[i]};
|
||||||
|
|
||||||
|
VkExtent2D swapChainExtent = getSwapChainExtent();
|
||||||
|
VkFramebufferCreateInfo framebufferInfo = {};
|
||||||
|
framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
|
||||||
|
framebufferInfo.renderPass = renderPass;
|
||||||
|
framebufferInfo.attachmentCount = static_cast<uint32_t>(attachments.size());
|
||||||
|
framebufferInfo.pAttachments = attachments.data();
|
||||||
|
framebufferInfo.width = swapChainExtent.width;
|
||||||
|
framebufferInfo.height = swapChainExtent.height;
|
||||||
|
framebufferInfo.layers = 1;
|
||||||
|
|
||||||
|
if (vkCreateFramebuffer(
|
||||||
|
device.device(),
|
||||||
|
&framebufferInfo,
|
||||||
|
nullptr,
|
||||||
|
&swapChainFramebuffers[i]) != VK_SUCCESS)
|
||||||
|
{
|
||||||
|
throw std::runtime_error("failed to create framebuffer!");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void SwapChain::createDepthResources()
|
||||||
|
{
|
||||||
|
VkFormat depthFormat = findDepthFormat();
|
||||||
|
VkExtent2D swapChainExtent = getSwapChainExtent();
|
||||||
|
|
||||||
|
depthImages.resize(imageCount());
|
||||||
|
depthImageMemorys.resize(imageCount());
|
||||||
|
depthImageViews.resize(imageCount());
|
||||||
|
|
||||||
|
for (int i = 0; i < depthImages.size(); i++)
|
||||||
|
{
|
||||||
|
VkImageCreateInfo imageInfo{};
|
||||||
|
imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
|
||||||
|
imageInfo.imageType = VK_IMAGE_TYPE_2D;
|
||||||
|
imageInfo.extent.width = swapChainExtent.width;
|
||||||
|
imageInfo.extent.height = swapChainExtent.height;
|
||||||
|
imageInfo.extent.depth = 1;
|
||||||
|
imageInfo.mipLevels = 1;
|
||||||
|
imageInfo.arrayLayers = 1;
|
||||||
|
imageInfo.format = depthFormat;
|
||||||
|
imageInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
|
||||||
|
imageInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
||||||
|
imageInfo.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
|
||||||
|
imageInfo.samples = VK_SAMPLE_COUNT_1_BIT;
|
||||||
|
imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
||||||
|
imageInfo.flags = 0;
|
||||||
|
|
||||||
|
device.createImageWithInfo(
|
||||||
|
imageInfo,
|
||||||
|
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
|
||||||
|
depthImages[i],
|
||||||
|
depthImageMemorys[i]);
|
||||||
|
|
||||||
|
VkImageViewCreateInfo viewInfo{};
|
||||||
|
viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
|
||||||
|
viewInfo.image = depthImages[i];
|
||||||
|
viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
|
||||||
|
viewInfo.format = depthFormat;
|
||||||
|
viewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
|
||||||
|
viewInfo.subresourceRange.baseMipLevel = 0;
|
||||||
|
viewInfo.subresourceRange.levelCount = 1;
|
||||||
|
viewInfo.subresourceRange.baseArrayLayer = 0;
|
||||||
|
viewInfo.subresourceRange.layerCount = 1;
|
||||||
|
|
||||||
|
if (vkCreateImageView(device.device(), &viewInfo, nullptr, &depthImageViews[i]) != VK_SUCCESS)
|
||||||
|
{
|
||||||
|
throw std::runtime_error("failed to create texture image view!");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void SwapChain::createSyncObjects()
|
||||||
|
{
|
||||||
|
imageAvailableSemaphores.resize(MAX_FRAMES_IN_FLIGHT);
|
||||||
|
renderFinishedSemaphores.resize(MAX_FRAMES_IN_FLIGHT);
|
||||||
|
inFlightFences.resize(MAX_FRAMES_IN_FLIGHT);
|
||||||
|
imagesInFlight.resize(imageCount(), 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.device(), &semaphoreInfo, nullptr, &imageAvailableSemaphores[i]) !=
|
||||||
|
VK_SUCCESS ||
|
||||||
|
vkCreateSemaphore(device.device(), &semaphoreInfo, nullptr, &renderFinishedSemaphores[i]) !=
|
||||||
|
VK_SUCCESS ||
|
||||||
|
vkCreateFence(device.device(), &fenceInfo, nullptr, &inFlightFences[i]) != VK_SUCCESS)
|
||||||
|
{
|
||||||
|
throw std::runtime_error("failed to create synchronization objects for a frame!");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
VkSurfaceFormatKHR SwapChain::chooseSwapSurfaceFormat(
|
||||||
|
const std::vector<VkSurfaceFormatKHR> &availableFormats)
|
||||||
|
{
|
||||||
|
for (const auto &availableFormat : availableFormats)
|
||||||
|
{
|
||||||
|
if (availableFormat.format == VK_FORMAT_B8G8R8A8_SRGB &&
|
||||||
|
availableFormat.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR)
|
||||||
|
{
|
||||||
|
return availableFormat;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return availableFormats[0];
|
||||||
|
}
|
||||||
|
|
||||||
|
VkPresentModeKHR SwapChain::chooseSwapPresentMode(
|
||||||
|
const std::vector<VkPresentModeKHR> &availablePresentModes)
|
||||||
|
{
|
||||||
|
for (const auto &availablePresentMode : availablePresentModes)
|
||||||
|
{
|
||||||
|
if (availablePresentMode == VK_PRESENT_MODE_MAILBOX_KHR)
|
||||||
|
{
|
||||||
|
std::cout << "Present mode: Mailbox" << std::endl;
|
||||||
|
return availablePresentMode;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// for (const auto &availablePresentMode : availablePresentModes) {
|
||||||
|
// if (availablePresentMode == VK_PRESENT_MODE_IMMEDIATE_KHR) {
|
||||||
|
// std::cout << "Present mode: Immediate" << std::endl;
|
||||||
|
// return availablePresentMode;
|
||||||
|
// }
|
||||||
|
// }
|
||||||
|
|
||||||
|
std::cout << "Present mode: V-Sync" << std::endl;
|
||||||
|
return VK_PRESENT_MODE_FIFO_KHR;
|
||||||
|
}
|
||||||
|
|
||||||
|
VkExtent2D SwapChain::chooseSwapExtent(const VkSurfaceCapabilitiesKHR &capabilities)
|
||||||
|
{
|
||||||
|
if (capabilities.currentExtent.width != std::numeric_limits<uint32_t>::max())
|
||||||
|
{
|
||||||
|
return capabilities.currentExtent;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
VkExtent2D actualExtent = windowExtent;
|
||||||
|
actualExtent.width = std::max(
|
||||||
|
capabilities.minImageExtent.width,
|
||||||
|
std::min(capabilities.maxImageExtent.width, actualExtent.width));
|
||||||
|
actualExtent.height = std::max(
|
||||||
|
capabilities.minImageExtent.height,
|
||||||
|
std::min(capabilities.maxImageExtent.height, actualExtent.height));
|
||||||
|
|
||||||
|
return actualExtent;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
VkFormat SwapChain::findDepthFormat()
|
||||||
|
{
|
||||||
|
return device.findSupportedFormat(
|
||||||
|
{VK_FORMAT_D32_SFLOAT, VK_FORMAT_D32_SFLOAT_S8_UINT, VK_FORMAT_D24_UNORM_S8_UINT},
|
||||||
|
VK_IMAGE_TILING_OPTIMAL,
|
||||||
|
VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT);
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace hk
|
||||||
|
|
@ -0,0 +1,83 @@
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include "hk_device.hpp"
|
||||||
|
|
||||||
|
// vulkan headers
|
||||||
|
#include <vulkan/vulkan.h>
|
||||||
|
|
||||||
|
// std lib headers
|
||||||
|
#include <string>
|
||||||
|
#include <vector>
|
||||||
|
|
||||||
|
namespace hk
|
||||||
|
{
|
||||||
|
|
||||||
|
class SwapChain
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
static constexpr int MAX_FRAMES_IN_FLIGHT = 2;
|
||||||
|
|
||||||
|
SwapChain(Device &deviceRef, VkExtent2D windowExtent);
|
||||||
|
~SwapChain();
|
||||||
|
|
||||||
|
SwapChain(const SwapChain &) = delete;
|
||||||
|
SwapChain &operator=(const SwapChain &) = delete;
|
||||||
|
|
||||||
|
VkFramebuffer getFrameBuffer(int index) { return swapChainFramebuffers[index]; }
|
||||||
|
VkRenderPass getRenderPass() { return renderPass; }
|
||||||
|
VkImageView getImageView(int index) { return swapChainImageViews[index]; }
|
||||||
|
size_t imageCount() { return swapChainImages.size(); }
|
||||||
|
VkFormat getSwapChainImageFormat() { return swapChainImageFormat; }
|
||||||
|
VkExtent2D getSwapChainExtent() { return swapChainExtent; }
|
||||||
|
uint32_t width() { return swapChainExtent.width; }
|
||||||
|
uint32_t height() { return swapChainExtent.height; }
|
||||||
|
|
||||||
|
float extentAspectRatio()
|
||||||
|
{
|
||||||
|
return static_cast<float>(swapChainExtent.width) / static_cast<float>(swapChainExtent.height);
|
||||||
|
}
|
||||||
|
VkFormat findDepthFormat();
|
||||||
|
|
||||||
|
VkResult acquireNextImage(uint32_t *imageIndex);
|
||||||
|
VkResult submitCommandBuffers(const VkCommandBuffer *buffers, uint32_t *imageIndex);
|
||||||
|
|
||||||
|
private:
|
||||||
|
void createSwapChain();
|
||||||
|
void createImageViews();
|
||||||
|
void createDepthResources();
|
||||||
|
void createRenderPass();
|
||||||
|
void createFramebuffers();
|
||||||
|
void createSyncObjects();
|
||||||
|
|
||||||
|
// Helper functions
|
||||||
|
VkSurfaceFormatKHR chooseSwapSurfaceFormat(
|
||||||
|
const std::vector<VkSurfaceFormatKHR> &availableFormats);
|
||||||
|
VkPresentModeKHR chooseSwapPresentMode(
|
||||||
|
const std::vector<VkPresentModeKHR> &availablePresentModes);
|
||||||
|
VkExtent2D chooseSwapExtent(const VkSurfaceCapabilitiesKHR &capabilities);
|
||||||
|
|
||||||
|
VkFormat swapChainImageFormat;
|
||||||
|
VkExtent2D swapChainExtent;
|
||||||
|
|
||||||
|
std::vector<VkFramebuffer> swapChainFramebuffers;
|
||||||
|
VkRenderPass renderPass;
|
||||||
|
|
||||||
|
std::vector<VkImage> depthImages;
|
||||||
|
std::vector<VkDeviceMemory> depthImageMemorys;
|
||||||
|
std::vector<VkImageView> depthImageViews;
|
||||||
|
std::vector<VkImage> swapChainImages;
|
||||||
|
std::vector<VkImageView> swapChainImageViews;
|
||||||
|
|
||||||
|
Device &device;
|
||||||
|
VkExtent2D windowExtent;
|
||||||
|
|
||||||
|
VkSwapchainKHR swapChain;
|
||||||
|
|
||||||
|
std::vector<VkSemaphore> imageAvailableSemaphores;
|
||||||
|
std::vector<VkSemaphore> renderFinishedSemaphores;
|
||||||
|
std::vector<VkFence> inFlightFences;
|
||||||
|
std::vector<VkFence> imagesInFlight;
|
||||||
|
size_t currentFrame = 0;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace hk
|
||||||
|
|
@ -0,0 +1,37 @@
|
||||||
|
#include "hk_window.hpp"
|
||||||
|
|
||||||
|
// std
|
||||||
|
#include <stdexcept>
|
||||||
|
|
||||||
|
namespace hk
|
||||||
|
{
|
||||||
|
Window::Window(int w, int h, const std::string& name)
|
||||||
|
: m_width(w), m_height(h), m_windowName(name)
|
||||||
|
{
|
||||||
|
initWindow();
|
||||||
|
}
|
||||||
|
|
||||||
|
Window::~Window()
|
||||||
|
{
|
||||||
|
glfwDestroyWindow(m_window);
|
||||||
|
glfwTerminate();
|
||||||
|
}
|
||||||
|
|
||||||
|
void Window::createWindowSurface(VkInstance instance, VkSurfaceKHR *surface)
|
||||||
|
{
|
||||||
|
if (glfwCreateWindowSurface(instance, m_window, nullptr, surface) != VK_SUCCESS)
|
||||||
|
{
|
||||||
|
throw std::runtime_error("failed to create window surface!");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void Window::initWindow()
|
||||||
|
{
|
||||||
|
glfwInit();
|
||||||
|
glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
|
||||||
|
glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE);
|
||||||
|
|
||||||
|
m_window = glfwCreateWindow(m_width, m_height, m_windowName.c_str(), nullptr, nullptr);
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,34 @@
|
||||||
|
#pragma once
|
||||||
|
#include <string>
|
||||||
|
|
||||||
|
#define GLFW_INCLUDE_VULKAN
|
||||||
|
#include <GLFW/glfw3.h>
|
||||||
|
|
||||||
|
namespace hk
|
||||||
|
{
|
||||||
|
class Window
|
||||||
|
{
|
||||||
|
|
||||||
|
public:
|
||||||
|
Window(int w, int h, const std::string& name);
|
||||||
|
~Window();
|
||||||
|
|
||||||
|
Window(const Window&) = delete;
|
||||||
|
Window &operator=(const Window&) = delete;
|
||||||
|
|
||||||
|
bool shouldClose() { return glfwWindowShouldClose(m_window); }
|
||||||
|
VkExtent2D getExtend() { return {static_cast<uint32_t>(m_width), static_cast<uint32_t>(m_height)}; }
|
||||||
|
|
||||||
|
void createWindowSurface(VkInstance instance, VkSurfaceKHR *surface);
|
||||||
|
|
||||||
|
private:
|
||||||
|
void initWindow();
|
||||||
|
|
||||||
|
const int m_width;
|
||||||
|
const int m_height;
|
||||||
|
|
||||||
|
std::string m_windowName;
|
||||||
|
GLFWwindow *m_window;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace lve
|
||||||
|
|
@ -0,0 +1,21 @@
|
||||||
|
#include "first_app.hpp"
|
||||||
|
|
||||||
|
// std
|
||||||
|
#include <cstdlib>
|
||||||
|
#include <iostream>
|
||||||
|
#include <stdexcept>
|
||||||
|
|
||||||
|
int main()
|
||||||
|
{
|
||||||
|
hk::FirstApp app{};
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
app.run();
|
||||||
|
}
|
||||||
|
catch(const std::exception& e)
|
||||||
|
{
|
||||||
|
std::cerr << e.what() << '\n';
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,8 @@
|
||||||
|
#version 450
|
||||||
|
|
||||||
|
layout (location = 0) in vec3 fragColor;
|
||||||
|
layout (location = 0) out vec4 outColor;
|
||||||
|
|
||||||
|
void main(){
|
||||||
|
outColor = vec4(fragColor, 1.0);
|
||||||
|
}
|
||||||
Binary file not shown.
|
|
@ -0,0 +1,11 @@
|
||||||
|
#version 450
|
||||||
|
|
||||||
|
layout(location = 0) in vec2 position;
|
||||||
|
layout(location = 1) in vec3 color;
|
||||||
|
|
||||||
|
layout(location = 0) out vec3 fragColor;
|
||||||
|
|
||||||
|
void main(){
|
||||||
|
gl_Position = vec4(position, 0.0, 1.0);
|
||||||
|
fragColor = color;
|
||||||
|
}
|
||||||
Binary file not shown.
Loading…
Reference in New Issue