Added (temporary) vulkan android example base class
This commit is contained in:
saschawillems
parent
71cdb93234
commit
9339cba2ad
1 changed files with 545 additions and 0 deletions
545
android/base/vulkanandroidbase.hpp
Normal file
545
android/base/vulkanandroidbase.hpp
Normal file
|
|
@ -0,0 +1,545 @@
|
|||
/*
|
||||
* Shared android example base
|
||||
*
|
||||
* Will be replaced once the main examples get proper android support
|
||||
*
|
||||
* Copyright (C) 2016 by Sascha Willems - www.saschawillems.de
|
||||
*
|
||||
* This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string>
|
||||
#include <fstream>
|
||||
#include <assert.h>
|
||||
#include <stdio.h>
|
||||
#include <vector>
|
||||
|
||||
#include <vulkan/vulkan.h>
|
||||
#include "vulkanandroid.h"
|
||||
#include "vulkanswapchain.hpp"
|
||||
#include "vulkantools.h"
|
||||
|
||||
class VulkanAndroidExampleBase
|
||||
{
|
||||
private:
|
||||
VkShaderModule loadShaderModule(const char *fileName, VkShaderStageFlagBits stage)
|
||||
{
|
||||
// Load shader from compressed asset
|
||||
AAsset* asset = AAssetManager_open(app->activity->assetManager, fileName, AASSET_MODE_STREAMING);
|
||||
assert(asset);
|
||||
size_t size = AAsset_getLength(asset);
|
||||
assert(size > 0);
|
||||
|
||||
char *shaderCode = new char[size];
|
||||
AAsset_read(asset, shaderCode, size);
|
||||
AAsset_close(asset);
|
||||
|
||||
VkShaderModule shaderModule;
|
||||
VkShaderModuleCreateInfo moduleCreateInfo;
|
||||
VkResult err;
|
||||
|
||||
moduleCreateInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
|
||||
moduleCreateInfo.pNext = NULL;
|
||||
|
||||
moduleCreateInfo.codeSize = size;
|
||||
moduleCreateInfo.pCode = (uint32_t*)shaderCode;
|
||||
moduleCreateInfo.flags = 0;
|
||||
err = vkCreateShaderModule(device, &moduleCreateInfo, NULL, &shaderModule);
|
||||
assert(!err);
|
||||
|
||||
return shaderModule;
|
||||
}
|
||||
public:
|
||||
bool prepared = false;
|
||||
|
||||
struct android_app* app;
|
||||
uint32_t width;
|
||||
uint32_t height;
|
||||
|
||||
VkPhysicalDeviceMemoryProperties deviceMemoryProperties;
|
||||
VkInstance instance;
|
||||
VkPhysicalDevice physicalDevice;
|
||||
VkDevice device;
|
||||
VkQueue queue;
|
||||
VkCommandPool cmdPool;
|
||||
VkCommandBuffer setupCmdBuffer = VK_NULL_HANDLE;
|
||||
VkCommandBuffer postPresentCmdBuffer = VK_NULL_HANDLE;
|
||||
VkCommandBuffer prePresentCmdBuffer = VK_NULL_HANDLE;
|
||||
std::vector<VkCommandBuffer> drawCmdBuffers;
|
||||
VkPipelineCache pipelineCache;
|
||||
VkDescriptorPool descriptorPool;
|
||||
VulkanSwapChain swapChain;
|
||||
std::vector<VkShaderModule> shaderModules;
|
||||
|
||||
uint32_t currentBuffer = 0;
|
||||
struct
|
||||
{
|
||||
VkImage image;
|
||||
VkDeviceMemory mem;
|
||||
VkImageView view;
|
||||
} depthStencil;
|
||||
std::vector<VkFramebuffer>frameBuffers;
|
||||
VkRenderPass renderPass;
|
||||
|
||||
struct {
|
||||
VkSemaphore presentComplete;
|
||||
VkSemaphore submitSignal;
|
||||
} semaphores;
|
||||
|
||||
VkBool32 getMemoryType(uint32_t typeBits, VkFlags properties, uint32_t * typeIndex)
|
||||
{
|
||||
for (uint32_t i = 0; i < 32; i++)
|
||||
{
|
||||
if ((typeBits & 1) == 1)
|
||||
{
|
||||
if ((deviceMemoryProperties.memoryTypes[i].propertyFlags & properties) == properties)
|
||||
{
|
||||
*typeIndex = i;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
typeBits >>= 1;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void initVulkan()
|
||||
{
|
||||
bool libLoaded = loadVulkanLibrary();
|
||||
assert(libLoaded);
|
||||
|
||||
VkResult vkRes;
|
||||
|
||||
// Instance
|
||||
VkApplicationInfo appInfo = {};
|
||||
appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
|
||||
appInfo.pApplicationName = "Vulkan Android Example";
|
||||
appInfo.applicationVersion = 1;
|
||||
appInfo.pEngineName = "VulkanAndroidExample";
|
||||
appInfo.engineVersion = 1;
|
||||
// todo : Workaround to support implementations that are not using the latest SDK
|
||||
appInfo.apiVersion = VK_MAKE_VERSION(1, 0, 1);
|
||||
|
||||
VkInstanceCreateInfo instanceCreateInfo = {};
|
||||
instanceCreateInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
|
||||
instanceCreateInfo.pApplicationInfo = &appInfo;
|
||||
|
||||
vkRes = vkCreateInstance(&instanceCreateInfo, NULL, &instance);
|
||||
assert(vkRes == VK_SUCCESS);
|
||||
|
||||
loadVulkanFunctions(instance);
|
||||
|
||||
// Device
|
||||
// Always use first physical device
|
||||
uint32_t gpuCount;
|
||||
vkRes = vkEnumeratePhysicalDevices(instance, &gpuCount, &physicalDevice);
|
||||
assert(vkRes == VK_SUCCESS);
|
||||
|
||||
// Find a queue that supports graphics operations
|
||||
uint32_t graphicsQueueIndex = 0;
|
||||
uint32_t queueCount;
|
||||
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueCount, NULL);
|
||||
assert(queueCount >= 1);
|
||||
|
||||
std::vector<VkQueueFamilyProperties> queueProps;
|
||||
queueProps.resize(queueCount);
|
||||
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueCount, queueProps.data());
|
||||
|
||||
for (graphicsQueueIndex = 0; graphicsQueueIndex < queueCount; graphicsQueueIndex++)
|
||||
{
|
||||
if (queueProps[graphicsQueueIndex].queueFlags & VK_QUEUE_GRAPHICS_BIT)
|
||||
break;
|
||||
}
|
||||
assert(graphicsQueueIndex < queueCount);
|
||||
|
||||
// Request the queue
|
||||
float queuePriorities = 0.0f;
|
||||
VkDeviceQueueCreateInfo queueCreateInfo = {};
|
||||
queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
|
||||
queueCreateInfo.queueFamilyIndex = graphicsQueueIndex;
|
||||
queueCreateInfo.queueCount = 1;
|
||||
queueCreateInfo.pQueuePriorities = &queuePriorities;
|
||||
|
||||
// Create device
|
||||
VkDeviceCreateInfo deviceCreateInfo = {};
|
||||
deviceCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
|
||||
deviceCreateInfo.queueCreateInfoCount = 1;
|
||||
deviceCreateInfo.pQueueCreateInfos = &queueCreateInfo;
|
||||
|
||||
vkRes = vkCreateDevice(physicalDevice, &deviceCreateInfo, nullptr, &device);
|
||||
assert(vkRes == VK_SUCCESS);
|
||||
|
||||
// Get graphics queue
|
||||
vkGetDeviceQueue(device, graphicsQueueIndex, 0, &queue);
|
||||
|
||||
// Device memory properties (for finding appropriate memory types)
|
||||
vkGetPhysicalDeviceMemoryProperties(physicalDevice, &deviceMemoryProperties);
|
||||
|
||||
// Swap chain
|
||||
swapChain.connect(instance, physicalDevice, device);
|
||||
swapChain.initSurface(app->window);
|
||||
|
||||
// Command buffer pool
|
||||
VkCommandPoolCreateInfo cmdPoolInfo = {};
|
||||
cmdPoolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
|
||||
cmdPoolInfo.queueFamilyIndex = swapChain.queueNodeIndex;
|
||||
cmdPoolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
|
||||
vkRes = vkCreateCommandPool(device, &cmdPoolInfo, nullptr, &cmdPool);
|
||||
assert(!vkRes);
|
||||
|
||||
// Pipeline cache
|
||||
VkPipelineCacheCreateInfo pipelineCacheCreateInfo = {};
|
||||
pipelineCacheCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
|
||||
VkResult err = vkCreatePipelineCache(device, &pipelineCacheCreateInfo, nullptr, &pipelineCache);
|
||||
assert(!err);
|
||||
|
||||
// Create semaphores for synchronization
|
||||
VkSemaphoreCreateInfo semaphoreCreateInfo = vkTools::initializers::semaphoreCreateInfo();
|
||||
|
||||
err = vkCreateSemaphore(device, &semaphoreCreateInfo, nullptr, &semaphores.presentComplete);
|
||||
assert(!err);
|
||||
err = vkCreateSemaphore(device, &semaphoreCreateInfo, nullptr, &semaphores.submitSignal);
|
||||
assert(!err);
|
||||
|
||||
createSetupCommandBuffer();
|
||||
startSetupCommandBuffer();
|
||||
|
||||
swapChain.create(setupCmdBuffer, &width, &height);
|
||||
|
||||
setupDepthStencil();
|
||||
setupRenderPass();
|
||||
setupFrameBuffer();
|
||||
|
||||
flushSetupCommandBuffer();
|
||||
|
||||
createCommandBuffers();
|
||||
}
|
||||
|
||||
void cleanUpVulkan()
|
||||
{
|
||||
swapChain.cleanup();
|
||||
|
||||
vkDestroyDescriptorPool(device, descriptorPool, nullptr);
|
||||
if (setupCmdBuffer != VK_NULL_HANDLE)
|
||||
{
|
||||
vkFreeCommandBuffers(device, cmdPool, 1, &setupCmdBuffer);
|
||||
|
||||
}
|
||||
vkFreeCommandBuffers(device, cmdPool, drawCmdBuffers.size(), drawCmdBuffers.data());
|
||||
vkFreeCommandBuffers(device, cmdPool, 1, &prePresentCmdBuffer);
|
||||
vkFreeCommandBuffers(device, cmdPool, 1, &postPresentCmdBuffer);
|
||||
|
||||
vkDestroyRenderPass(device, renderPass, nullptr);
|
||||
for (uint32_t i = 0; i < frameBuffers.size(); i++)
|
||||
{
|
||||
vkDestroyFramebuffer(device, frameBuffers[i], nullptr);
|
||||
}
|
||||
|
||||
for (auto& shaderModule : shaderModules)
|
||||
{
|
||||
vkDestroyShaderModule(device, shaderModule, nullptr);
|
||||
}
|
||||
|
||||
vkDestroyImageView(device, depthStencil.view, nullptr);
|
||||
vkDestroyImage(device, depthStencil.image, nullptr);
|
||||
vkFreeMemory(device, depthStencil.mem, nullptr);
|
||||
|
||||
vkDestroySemaphore(device, semaphores.presentComplete, nullptr);
|
||||
vkDestroySemaphore(device, semaphores.submitSignal, nullptr);
|
||||
|
||||
vkDestroyPipelineCache(device, pipelineCache, nullptr);
|
||||
vkDestroyDevice(device, nullptr);
|
||||
vkDestroyInstance(instance, nullptr);
|
||||
|
||||
freeVulkanLibrary();
|
||||
}
|
||||
|
||||
VkPipelineShaderStageCreateInfo loadShader(const char * fileName, VkShaderStageFlagBits stage)
|
||||
{
|
||||
VkPipelineShaderStageCreateInfo shaderStage = {};
|
||||
shaderStage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
|
||||
shaderStage.stage = stage;
|
||||
shaderStage.module = loadShaderModule(fileName, stage);
|
||||
shaderStage.pName = "main";
|
||||
assert(shaderStage.module != NULL);
|
||||
shaderModules.push_back(shaderStage.module);
|
||||
return shaderStage;
|
||||
}
|
||||
|
||||
void createSetupCommandBuffer()
|
||||
{
|
||||
VkCommandBufferAllocateInfo cmdBufAllocateInfo =
|
||||
vkTools::initializers::commandBufferAllocateInfo(
|
||||
cmdPool,
|
||||
VK_COMMAND_BUFFER_LEVEL_PRIMARY,
|
||||
1);
|
||||
|
||||
VkResult vkRes = vkAllocateCommandBuffers(device, &cmdBufAllocateInfo, &setupCmdBuffer);
|
||||
assert(!vkRes);
|
||||
}
|
||||
|
||||
void startSetupCommandBuffer()
|
||||
{
|
||||
VkCommandBufferBeginInfo cmdBufInfo = vkTools::initializers::commandBufferBeginInfo();
|
||||
vkBeginCommandBuffer(setupCmdBuffer, &cmdBufInfo);
|
||||
}
|
||||
|
||||
void flushSetupCommandBuffer()
|
||||
{
|
||||
VkResult err;
|
||||
|
||||
if (setupCmdBuffer == VK_NULL_HANDLE)
|
||||
return;
|
||||
|
||||
err = vkEndCommandBuffer(setupCmdBuffer);
|
||||
assert(!err);
|
||||
|
||||
VkSubmitInfo submitInfo = {};
|
||||
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
|
||||
submitInfo.commandBufferCount = 1;
|
||||
submitInfo.pCommandBuffers = &setupCmdBuffer;
|
||||
|
||||
err = vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE);
|
||||
assert(!err);
|
||||
|
||||
err = vkQueueWaitIdle(queue);
|
||||
assert(!err);
|
||||
}
|
||||
|
||||
void setupDepthStencil()
|
||||
{
|
||||
VkImageCreateInfo image = {};
|
||||
image.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
|
||||
image.pNext = NULL;
|
||||
image.imageType = VK_IMAGE_TYPE_2D;
|
||||
image.format = VK_FORMAT_D24_UNORM_S8_UINT;
|
||||
image.extent = { width, height, 1 };
|
||||
image.mipLevels = 1;
|
||||
image.arrayLayers = 1;
|
||||
image.samples = VK_SAMPLE_COUNT_1_BIT;
|
||||
image.tiling = VK_IMAGE_TILING_OPTIMAL;
|
||||
image.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
|
||||
image.flags = 0;
|
||||
|
||||
VkMemoryAllocateInfo mem_alloc = {};
|
||||
mem_alloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
|
||||
mem_alloc.pNext = NULL;
|
||||
mem_alloc.allocationSize = 0;
|
||||
mem_alloc.memoryTypeIndex = 0;
|
||||
|
||||
VkImageViewCreateInfo depthStencilView = {};
|
||||
depthStencilView.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
|
||||
depthStencilView.pNext = NULL;
|
||||
depthStencilView.viewType = VK_IMAGE_VIEW_TYPE_2D;
|
||||
depthStencilView.format = VK_FORMAT_D24_UNORM_S8_UINT;
|
||||
depthStencilView.flags = 0;
|
||||
depthStencilView.subresourceRange = {};
|
||||
depthStencilView.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
|
||||
depthStencilView.subresourceRange.baseMipLevel = 0;
|
||||
depthStencilView.subresourceRange.levelCount = 1;
|
||||
depthStencilView.subresourceRange.baseArrayLayer = 0;
|
||||
depthStencilView.subresourceRange.layerCount = 1;
|
||||
|
||||
VkMemoryRequirements memReqs;
|
||||
VkResult err;
|
||||
|
||||
err = vkCreateImage(device, &image, nullptr, &depthStencil.image);
|
||||
assert(!err);
|
||||
vkGetImageMemoryRequirements(device, depthStencil.image, &memReqs);
|
||||
mem_alloc.allocationSize = memReqs.size;
|
||||
getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, &mem_alloc.memoryTypeIndex);
|
||||
err = vkAllocateMemory(device, &mem_alloc, nullptr, &depthStencil.mem);
|
||||
assert(!err);
|
||||
|
||||
err = vkBindImageMemory(device, depthStencil.image, depthStencil.mem, 0);
|
||||
assert(!err);
|
||||
vkTools::setImageLayout(setupCmdBuffer, depthStencil.image, VK_IMAGE_ASPECT_DEPTH_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
|
||||
|
||||
depthStencilView.image = depthStencil.image;
|
||||
err = vkCreateImageView(device, &depthStencilView, nullptr, &depthStencil.view);
|
||||
assert(!err);
|
||||
}
|
||||
|
||||
void setupFrameBuffer()
|
||||
{
|
||||
VkImageView attachments[2];
|
||||
|
||||
// Depth/Stencil attachment is the same for all frame buffers
|
||||
attachments[1] = depthStencil.view;
|
||||
|
||||
VkFramebufferCreateInfo frameBufferCreateInfo = {};
|
||||
frameBufferCreateInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
|
||||
frameBufferCreateInfo.pNext = NULL;
|
||||
frameBufferCreateInfo.renderPass = renderPass;
|
||||
frameBufferCreateInfo.attachmentCount = 2;
|
||||
frameBufferCreateInfo.pAttachments = attachments;
|
||||
frameBufferCreateInfo.width = width;
|
||||
frameBufferCreateInfo.height = height;
|
||||
frameBufferCreateInfo.layers = 1;
|
||||
|
||||
// Create frame buffers for every swap chain image
|
||||
frameBuffers.resize(swapChain.imageCount);
|
||||
for (uint32_t i = 0; i < frameBuffers.size(); i++)
|
||||
{
|
||||
attachments[0] = swapChain.buffers[i].view;
|
||||
VkResult err = vkCreateFramebuffer(device, &frameBufferCreateInfo, nullptr, &frameBuffers[i]);
|
||||
assert(!err);
|
||||
}
|
||||
}
|
||||
|
||||
void setupRenderPass()
|
||||
{
|
||||
VkAttachmentDescription attachments[2];
|
||||
attachments[0].format = VK_FORMAT_R8G8B8A8_UNORM;
|
||||
attachments[0].samples = VK_SAMPLE_COUNT_1_BIT;
|
||||
attachments[0].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
|
||||
attachments[0].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
|
||||
attachments[0].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
|
||||
attachments[0].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
|
||||
attachments[0].initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
|
||||
attachments[0].finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
|
||||
|
||||
attachments[1].format = VK_FORMAT_D24_UNORM_S8_UINT;
|
||||
attachments[1].samples = VK_SAMPLE_COUNT_1_BIT;
|
||||
attachments[1].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
|
||||
attachments[1].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
|
||||
attachments[1].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
|
||||
attachments[1].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
|
||||
attachments[1].initialLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
|
||||
attachments[1].finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
|
||||
|
||||
VkAttachmentReference colorReference = {};
|
||||
colorReference.attachment = 0;
|
||||
colorReference.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
|
||||
|
||||
VkAttachmentReference depthReference = {};
|
||||
depthReference.attachment = 1;
|
||||
depthReference.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
|
||||
|
||||
VkSubpassDescription subpass = {};
|
||||
subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
|
||||
subpass.flags = 0;
|
||||
subpass.inputAttachmentCount = 0;
|
||||
subpass.pInputAttachments = NULL;
|
||||
subpass.colorAttachmentCount = 1;
|
||||
subpass.pColorAttachments = &colorReference;
|
||||
subpass.pResolveAttachments = NULL;
|
||||
subpass.pDepthStencilAttachment = &depthReference;
|
||||
subpass.preserveAttachmentCount = 0;
|
||||
subpass.pPreserveAttachments = NULL;
|
||||
|
||||
VkRenderPassCreateInfo renderPassInfo = {};
|
||||
renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
|
||||
renderPassInfo.pNext = NULL;
|
||||
renderPassInfo.attachmentCount = 2;
|
||||
renderPassInfo.pAttachments = attachments;
|
||||
renderPassInfo.subpassCount = 1;
|
||||
renderPassInfo.pSubpasses = &subpass;
|
||||
renderPassInfo.dependencyCount = 0;
|
||||
renderPassInfo.pDependencies = NULL;
|
||||
|
||||
VkResult err;
|
||||
|
||||
err = vkCreateRenderPass(device, &renderPassInfo, nullptr, &renderPass);
|
||||
assert(!err);
|
||||
}
|
||||
|
||||
void createCommandBuffers()
|
||||
{
|
||||
drawCmdBuffers.resize(swapChain.imageCount);
|
||||
|
||||
VkCommandBufferAllocateInfo cmdBufAllocateInfo =
|
||||
vkTools::initializers::commandBufferAllocateInfo(
|
||||
cmdPool,
|
||||
VK_COMMAND_BUFFER_LEVEL_PRIMARY,
|
||||
drawCmdBuffers.size());
|
||||
|
||||
VkResult vkRes = vkAllocateCommandBuffers(device, &cmdBufAllocateInfo, drawCmdBuffers.data());
|
||||
assert(!vkRes);
|
||||
|
||||
cmdBufAllocateInfo.commandBufferCount = 1;
|
||||
// Pre present
|
||||
vkRes = vkAllocateCommandBuffers(device, &cmdBufAllocateInfo, &prePresentCmdBuffer);
|
||||
assert(!vkRes);
|
||||
// Post present
|
||||
vkRes = vkAllocateCommandBuffers(device, &cmdBufAllocateInfo, &postPresentCmdBuffer);
|
||||
assert(!vkRes);
|
||||
}
|
||||
|
||||
void submitPrePresentBarrier(VkImage image)
|
||||
{
|
||||
VkCommandBufferBeginInfo cmdBufInfo = vkTools::initializers::commandBufferBeginInfo();
|
||||
|
||||
VkResult vkRes = vkBeginCommandBuffer(prePresentCmdBuffer, &cmdBufInfo);
|
||||
assert(!vkRes);
|
||||
|
||||
VkImageMemoryBarrier prePresentBarrier = vkTools::initializers::imageMemoryBarrier();
|
||||
prePresentBarrier.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
|
||||
prePresentBarrier.dstAccessMask = 0;
|
||||
prePresentBarrier.oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
|
||||
prePresentBarrier.newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
|
||||
prePresentBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
|
||||
prePresentBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
|
||||
prePresentBarrier.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
|
||||
prePresentBarrier.image = image;
|
||||
|
||||
vkCmdPipelineBarrier(
|
||||
prePresentCmdBuffer,
|
||||
VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
|
||||
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
|
||||
VK_FLAGS_NONE,
|
||||
0, nullptr, // No memory barriers,
|
||||
0, nullptr, // No buffer barriers,
|
||||
1, &prePresentBarrier);
|
||||
|
||||
vkRes = vkEndCommandBuffer(prePresentCmdBuffer);
|
||||
assert(!vkRes);
|
||||
|
||||
VkSubmitInfo submitInfo = vkTools::initializers::submitInfo();
|
||||
submitInfo.commandBufferCount = 1;
|
||||
submitInfo.pCommandBuffers = &prePresentCmdBuffer;
|
||||
|
||||
vkRes = vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE);
|
||||
assert(!vkRes);
|
||||
}
|
||||
|
||||
void submitPostPresentBarrier(VkImage image)
|
||||
{
|
||||
VkCommandBufferBeginInfo cmdBufInfo = vkTools::initializers::commandBufferBeginInfo();
|
||||
|
||||
VkResult vkRes = vkBeginCommandBuffer(postPresentCmdBuffer, &cmdBufInfo);
|
||||
assert(!vkRes);
|
||||
|
||||
VkImageMemoryBarrier postPresentBarrier = vkTools::initializers::imageMemoryBarrier();
|
||||
postPresentBarrier.srcAccessMask = 0;
|
||||
postPresentBarrier.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
|
||||
postPresentBarrier.oldLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
|
||||
postPresentBarrier.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
|
||||
postPresentBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
|
||||
postPresentBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
|
||||
postPresentBarrier.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
|
||||
postPresentBarrier.image = image;
|
||||
|
||||
vkCmdPipelineBarrier(
|
||||
postPresentCmdBuffer,
|
||||
VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
|
||||
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
|
||||
0,
|
||||
0, nullptr, // No memory barriers,
|
||||
0, nullptr, // No buffer barriers,
|
||||
1, &postPresentBarrier);
|
||||
|
||||
vkRes = vkEndCommandBuffer(postPresentCmdBuffer);
|
||||
assert(!vkRes);
|
||||
|
||||
VkSubmitInfo submitInfo = vkTools::initializers::submitInfo();
|
||||
submitInfo.commandBufferCount = 1;
|
||||
submitInfo.pCommandBuffers = &postPresentCmdBuffer;
|
||||
|
||||
vkRes = vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE);
|
||||
assert(!vkRes);
|
||||
}
|
||||
};
|
||||
Loading…
Add table
Add a link
Reference in a new issue