inksoul
/
plumageRender
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity

添加创建帧缓存区的colorAttachment

ink-soul 2024-04-12 09:54:52 +08:00
parent 9858f7fa56
commit e9ed42bfeb
2 changed files with 289 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

373
base/vulkanexamplebase.cpp
View File

@ -1821,28 +1821,117 @@ void VulkanExampleBase::setupFrameBuffer()
/* /*
MSAA MSAA
*/ */
if (settings.multiSampling) { VkFormat colorAttachmentFormat = VK_FORMAT_R8G8B8A8_UNORM;
// Check if device supports requested sample count for color and depth frame buffer VkFormat depthFormat = findDepthFormat();
//assert((deviceProperties.limits.framebufferColorSampleCounts >= sampleCount) && (deviceProperties.limits.framebufferDepthSampleCounts >= sampleCount)); if (settings.headless)
{
if (settings.multiSampling)
{
VkImageCreateInfo imageCI{};
imageCI.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
imageCI.imageType = VK_IMAGE_TYPE_2D;
imageCI.format = colorAttachmentFormat;
imageCI.extent.width = settings.width;
imageCI.extent.height = settings.height;
imageCI.extent.depth = 1;
imageCI.mipLevels = 1;
imageCI.arrayLayers = 1;
imageCI.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
imageCI.tiling = VK_IMAGE_TILING_OPTIMAL;
imageCI.samples = settings.sampleCount;
imageCI.usage = VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
imageCI.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
VK_CHECK_RESULT(vkCreateImage(device, &imageCI, nullptr, &multisampleTarget.color.image));
VkMemoryRequirements memReqs;
vkGetImageMemoryRequirements(device, multisampleTarget.color.image, &memReqs);
VkMemoryAllocateInfo memAllocInfo{};
memAllocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
memAllocInfo.allocationSize = memReqs.size;
VkBool32 lazyMemTypePresent;
memAllocInfo.memoryTypeIndex = vulkanDevice->getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT, &lazyMemTypePresent);
if (!lazyMemTypePresent) {
memAllocInfo.memoryTypeIndex = vulkanDevice->getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
}
VK_CHECK_RESULT(vkAllocateMemory(device, &memAllocInfo, nullptr, &multisampleTarget.color.memory));
vkBindImageMemory(device, multisampleTarget.color.image, multisampleTarget.color.memory, 0);
// Create image view for the MSAA color image target
VkImageViewCreateInfo imageViewCI{};
imageViewCI.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
imageViewCI.image = multisampleTarget.color.image;
imageViewCI.viewType = VK_IMAGE_VIEW_TYPE_2D;
imageViewCI.format = colorAttachmentFormat;
imageViewCI.components.r = VK_COMPONENT_SWIZZLE_R;
imageViewCI.components.g = VK_COMPONENT_SWIZZLE_G;
imageViewCI.components.b = VK_COMPONENT_SWIZZLE_B;
imageViewCI.components.a = VK_COMPONENT_SWIZZLE_A;
imageViewCI.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
imageViewCI.subresourceRange.levelCount = 1;
imageViewCI.subresourceRange.layerCount = 1;
VK_CHECK_RESULT(vkCreateImageView(device, &imageViewCI, nullptr, &multisampleTarget.color.view));
// Depth target
imageCI.imageType = VK_IMAGE_TYPE_2D;
imageCI.format = depthFormat;
imageCI.extent.width = settings.width;
imageCI.extent.height = settings.height;
imageCI.extent.depth = 1;
imageCI.mipLevels = 1;
imageCI.arrayLayers = 1;
imageCI.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
imageCI.tiling = VK_IMAGE_TILING_OPTIMAL;
imageCI.samples = settings.sampleCount;
imageCI.usage = VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
imageCI.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
VK_CHECK_RESULT(vkCreateImage(device, &imageCI, nullptr, &multisampleTarget.depth.image));
vkGetImageMemoryRequirements(device, multisampleTarget.depth.image, &memReqs);
memAllocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
memAllocInfo.allocationSize = memReqs.size;
memAllocInfo.memoryTypeIndex = vulkanDevice->getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT, &lazyMemTypePresent);
if (!lazyMemTypePresent) {
memAllocInfo.memoryTypeIndex = vulkanDevice->getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
}
VK_CHECK_RESULT(vkAllocateMemory(device, &memAllocInfo, nullptr, &multisampleTarget.depth.memory));
vkBindImageMemory(device, multisampleTarget.depth.image, multisampleTarget.depth.memory, 0);
// Create image view for the MSAA target
imageViewCI.image = multisampleTarget.depth.image;
imageViewCI.viewType = VK_IMAGE_VIEW_TYPE_2D;
imageViewCI.format = depthFormat;
imageViewCI.components.r = VK_COMPONENT_SWIZZLE_R;
imageViewCI.components.g = VK_COMPONENT_SWIZZLE_G;
imageViewCI.components.b = VK_COMPONENT_SWIZZLE_B;
imageViewCI.components.a = VK_COMPONENT_SWIZZLE_A;
imageViewCI.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
imageViewCI.subresourceRange.levelCount = 1;
imageViewCI.subresourceRange.layerCount = 1;
VK_CHECK_RESULT(vkCreateImageView(device, &imageViewCI, nullptr, &multisampleTarget.depth.view));
}
// creat color image
VkImageCreateInfo imageCI{}; VkImageCreateInfo imageCI{};
imageCI.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; imageCI.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
imageCI.imageType = VK_IMAGE_TYPE_2D; imageCI.imageType = VK_IMAGE_TYPE_2D;
imageCI.format = swapChain.colorFormat; imageCI.format = colorAttachmentFormat;
imageCI.extent.width = width; imageCI.extent.width = settings.width;
imageCI.extent.height = height; imageCI.extent.height = settings.height;
imageCI.extent.depth = 1; imageCI.extent.depth = 1;
imageCI.mipLevels = 1; imageCI.mipLevels = 1;
imageCI.arrayLayers = 1; imageCI.arrayLayers = 1;
imageCI.sharingMode = VK_SHARING_MODE_EXCLUSIVE; imageCI.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
imageCI.tiling = VK_IMAGE_TILING_OPTIMAL; imageCI.tiling = VK_IMAGE_TILING_OPTIMAL;
imageCI.samples = settings.sampleCount; imageCI.samples = VK_SAMPLE_COUNT_1_BIT;
imageCI.usage = VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; imageCI.usage = VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
imageCI.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; imageCI.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
VK_CHECK_RESULT(vkCreateImage(device, &imageCI, nullptr, &multisampleTarget.color.image));
VK_CHECK_RESULT(vkCreateImage(device, &imageCI, nullptr, &colorAttachment.image));
VkMemoryRequirements memReqs; VkMemoryRequirements memReqs;
vkGetImageMemoryRequirements(device, multisampleTarget.color.image, &memReqs); vkGetImageMemoryRequirements(device, colorAttachment.image, &memReqs);
VkMemoryAllocateInfo memAllocInfo{}; VkMemoryAllocateInfo memAllocInfo{};
memAllocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; memAllocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
memAllocInfo.allocationSize = memReqs.size; memAllocInfo.allocationSize = memReqs.size;
@ -1851,15 +1940,16 @@ void VulkanExampleBase::setupFrameBuffer()
if (!lazyMemTypePresent) { if (!lazyMemTypePresent) {
memAllocInfo.memoryTypeIndex = vulkanDevice->getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT); memAllocInfo.memoryTypeIndex = vulkanDevice->getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
} }
VK_CHECK_RESULT(vkAllocateMemory(device, &memAllocInfo, nullptr, &multisampleTarget.color.memory)); VK_CHECK_RESULT(vkAllocateMemory(device, &memAllocInfo, nullptr, &colorAttachment.memory));
vkBindImageMemory(device, multisampleTarget.color.image, multisampleTarget.color.memory, 0);
// Create image view for the MSAA target vkBindImageMemory(device, colorAttachment.image, colorAttachment.memory, 0);
// Create image view for the color image
VkImageViewCreateInfo imageViewCI{}; VkImageViewCreateInfo imageViewCI{};
imageViewCI.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; imageViewCI.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
imageViewCI.image = multisampleTarget.color.image; imageViewCI.image = colorAttachment.image;
imageViewCI.viewType = VK_IMAGE_VIEW_TYPE_2D; imageViewCI.viewType = VK_IMAGE_VIEW_TYPE_2D;
imageViewCI.format = swapChain.colorFormat; imageViewCI.format = colorAttachmentFormat;
imageViewCI.components.r = VK_COMPONENT_SWIZZLE_R; imageViewCI.components.r = VK_COMPONENT_SWIZZLE_R;
imageViewCI.components.g = VK_COMPONENT_SWIZZLE_G; imageViewCI.components.g = VK_COMPONENT_SWIZZLE_G;
imageViewCI.components.b = VK_COMPONENT_SWIZZLE_B; imageViewCI.components.b = VK_COMPONENT_SWIZZLE_B;
@ -1867,103 +1957,158 @@ void VulkanExampleBase::setupFrameBuffer()
imageViewCI.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; imageViewCI.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
imageViewCI.subresourceRange.levelCount = 1; imageViewCI.subresourceRange.levelCount = 1;
imageViewCI.subresourceRange.layerCount = 1; imageViewCI.subresourceRange.layerCount = 1;
VK_CHECK_RESULT(vkCreateImageView(device, &imageViewCI, nullptr, &multisampleTarget.color.view)); VK_CHECK_RESULT(vkCreateImageView(device, &imageViewCI, nullptr, &colorAttachment.view));
// Depth target // create image for the depth image
imageCI.imageType = VK_IMAGE_TYPE_2D; VkImageCreateInfo image = {};
imageCI.format = depthFormat; image.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
imageCI.extent.width = width; image.pNext = NULL;
imageCI.extent.height = height; image.imageType = VK_IMAGE_TYPE_2D;
imageCI.extent.depth = 1; image.format = depthFormat;
imageCI.mipLevels = 1; image.extent.width = settings.width;
imageCI.arrayLayers = 1; image.extent.height = settings.height;
imageCI.sharingMode = VK_SHARING_MODE_EXCLUSIVE; image.extent.depth = 1;
imageCI.tiling = VK_IMAGE_TILING_OPTIMAL; image.mipLevels = 1;
imageCI.samples = settings.sampleCount; image.arrayLayers = 1;
imageCI.usage = VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT; image.samples = VK_SAMPLE_COUNT_1_BIT;
imageCI.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; image.tiling = VK_IMAGE_TILING_OPTIMAL;
VK_CHECK_RESULT(vkCreateImage(device, &imageCI, nullptr, &multisampleTarget.depth.image)); image.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
image.flags = 0;
vkGetImageMemoryRequirements(device, multisampleTarget.depth.image, &memReqs); VK_CHECK_RESULT(vkCreateImage(device, &image, nullptr, &depthStencil.image));
memAllocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
memAllocInfo.allocationSize = memReqs.size; VkMemoryAllocateInfo memAlloc = {};
memAllocInfo.memoryTypeIndex = vulkanDevice->getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT, &lazyMemTypePresent); memAlloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
if (!lazyMemTypePresent) { memAlloc.pNext = NULL;
memAllocInfo.memoryTypeIndex = vulkanDevice->getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT); memAlloc.allocationSize = 0;
memAlloc.memoryTypeIndex = 0;
VkMemoryRequirements depthAttachmentMemReqs;
vkGetImageMemoryRequirements(device, depthStencil.image, &memReqs);
memAlloc.allocationSize = depthAttachmentMemReqs.size;
memAlloc.memoryTypeIndex = vulkanDevice->getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
VK_CHECK_RESULT(vkAllocateMemory(device, &memAlloc, nullptr, &depthStencil.mem));
VK_CHECK_RESULT(vkBindImageMemory(device, depthStencil.image, depthStencil.mem, 0));
// create image view for depth image
VkImageViewCreateInfo depthStencilView = {};
depthStencilView.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
depthStencilView.pNext = NULL;
depthStencilView.viewType = VK_IMAGE_VIEW_TYPE_2D;
depthStencilView.format = depthFormat;
depthStencilView.image = depthStencil.image;
depthStencilView.flags = 0;
depthStencilView.subresourceRange = {};
depthStencilView.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
if (depthFormat >= VK_FORMAT_D16_UNORM_S8_UINT)
{
depthStencilView.subresourceRange.aspectMask |= VK_IMAGE_ASPECT_STENCIL_BIT;
} }
VK_CHECK_RESULT(vkAllocateMemory(device, &memAllocInfo, nullptr, &multisampleTarget.depth.memory)); depthStencilView.subresourceRange.baseMipLevel = 0;
vkBindImageMemory(device, multisampleTarget.depth.image, multisampleTarget.depth.memory, 0); depthStencilView.subresourceRange.levelCount = 1;
depthStencilView.subresourceRange.baseArrayLayer = 0;
depthStencilView.subresourceRange.layerCount = 1;
VK_CHECK_RESULT(vkCreateImageView(device, &depthStencilView, nullptr, &depthStencil.view));
// Create image view for the MSAA target }
imageViewCI.image = multisampleTarget.depth.image; else
imageViewCI.viewType = VK_IMAGE_VIEW_TYPE_2D; {
imageViewCI.format = depthFormat;
imageViewCI.components.r = VK_COMPONENT_SWIZZLE_R; swapChainImageViews.resize(swapChain.imageCount);
imageViewCI.components.g = VK_COMPONENT_SWIZZLE_G; for (size_t i = 0; i < swapChain.imageCount; i++)
imageViewCI.components.b = VK_COMPONENT_SWIZZLE_B; {
imageViewCI.components.a = VK_COMPONENT_SWIZZLE_A; VkImageViewCreateInfo creatInfo{};
imageViewCI.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT; creatInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
imageViewCI.subresourceRange.levelCount = 1; creatInfo.image = swapChain.images[i];
imageViewCI.subresourceRange.layerCount = 1; creatInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
VK_CHECK_RESULT(vkCreateImageView(device, &imageViewCI, nullptr, &multisampleTarget.depth.view)); creatInfo.format = swapChain.colorFormat;
creatInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
creatInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
creatInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
creatInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
creatInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
creatInfo.subresourceRange.baseMipLevel = 0;
creatInfo.subresourceRange.levelCount = 1;
creatInfo.subresourceRange.baseArrayLayer = 0;
creatInfo.subresourceRange.layerCount = 1;
if (vkCreateImageView(device, &creatInfo, nullptr, &swapChainImageViews[i]) != VK_SUCCESS)
{
throw std::runtime_error("failed to creat image view");
}
}
} }
if (settings.headless)
{
auto frameRange = settings.endFrameIndex - settings.startFrameCount;
if (settings.multiSampling)
{
// Depth/Stencil attachment is the same for all frame buffers for (int i = 0; i < frameRange; i++)
{
VkImageView attachments[4];
attachments[0] = multisampleTarget.color.view;
attachments[1] = multisampleTarget.depth.view;
attachments[2] = depthStencil.view;
attachments[3] = colorAttachment.view;
VkImageCreateInfo image = {}; VkFramebufferCreateInfo framebufferCreateInfo = vks::initializers::framebufferCreateInfo();
image.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; framebufferCreateInfo.renderPass = renderPass;
image.pNext = NULL; framebufferCreateInfo.attachmentCount = 4;
image.imageType = VK_IMAGE_TYPE_2D; framebufferCreateInfo.pAttachments = attachments;
image.format = depthFormat; framebufferCreateInfo.width = settings.width;
image.extent = { width, height, 1 }; framebufferCreateInfo.height = settings.height;
image.mipLevels = 1; framebufferCreateInfo.layers = 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 = {}; VK_CHECK_RESULT(vkCreateFramebuffer(device, &framebufferCreateInfo, nullptr, &frameBuffers[i]));
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; else
depthStencilView.pNext = NULL; {
depthStencilView.viewType = VK_IMAGE_VIEW_TYPE_2D; for (int i = 0; i < frameRange; i++)
depthStencilView.format = depthFormat; {
depthStencilView.flags = 0; VkImageView attachments[2];
depthStencilView.subresourceRange = {}; attachments[0] = colorAttachment.view;
depthStencilView.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT; attachments[1] = depthStencil.view;
depthStencilView.subresourceRange.baseMipLevel = 0;
depthStencilView.subresourceRange.levelCount = 1;
depthStencilView.subresourceRange.baseArrayLayer = 0;
depthStencilView.subresourceRange.layerCount = 1;
VkMemoryRequirements memReqs; VkFramebufferCreateInfo framebufferCreateInfo = vks::initializers::framebufferCreateInfo();
VK_CHECK_RESULT(vkCreateImage(device, &image, nullptr, &depthStencil.image)); framebufferCreateInfo.renderPass = renderPass;
vkGetImageMemoryRequirements(device, depthStencil.image, &memReqs); framebufferCreateInfo.attachmentCount = 2;
mem_alloc.allocationSize = memReqs.size; framebufferCreateInfo.pAttachments = attachments;
mem_alloc.memoryTypeIndex = vulkanDevice->getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT); framebufferCreateInfo.width = settings.width;
VK_CHECK_RESULT(vkAllocateMemory(device, &mem_alloc, nullptr, &depthStencil.mem)); framebufferCreateInfo.height = settings.height;
VK_CHECK_RESULT(vkBindImageMemory(device, depthStencil.image, depthStencil.mem, 0)); framebufferCreateInfo.layers = 1;
VK_CHECK_RESULT(vkCreateFramebuffer(device, &framebufferCreateInfo, nullptr, &frameBuffers[i]));
depthStencilView.image = depthStencil.image; }
VK_CHECK_RESULT(vkCreateImageView(device, &depthStencilView, nullptr, &depthStencil.view)); }
//
VkImageView attachments[4]; }
else
{
createSwapChainFramebuffer();
}
}
void VulkanExampleBase::createSwapChainFramebuffer()
{
uint32_t attachmentCount;
VkImageView attachments[attachmentCount];
if (settings.multiSampling) { if (settings.multiSampling) {
attachmentCount = 4;
attachments[0] = multisampleTarget.color.view; attachments[0] = multisampleTarget.color.view;
attachments[2] = multisampleTarget.depth.view; attachments[1] = multisampleTarget.depth.view;
attachments[3] = depthStencil.view; attachments[2] = depthStencil.view;
} }
else { else {
attachmentCount = 2;
attachments[1] = depthStencil.view; attachments[1] = depthStencil.view;
} }
@ -1971,20 +2116,22 @@ void VulkanExampleBase::setupFrameBuffer()
frameBufferCI.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; frameBufferCI.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
frameBufferCI.pNext = NULL; frameBufferCI.pNext = NULL;
frameBufferCI.renderPass = renderPass; frameBufferCI.renderPass = renderPass;
frameBufferCI.attachmentCount = settings.multiSampling ? 4 :2; frameBufferCI.attachmentCount = attachmentCount;
frameBufferCI.pAttachments = attachments; frameBufferCI.pAttachments = attachments;
frameBufferCI.width = width; frameBufferCI.width = settings.width;
frameBufferCI.height = height; frameBufferCI.height = settings.height;
frameBufferCI.layers = 1; frameBufferCI.layers = 1;
// Create frame buffers for every swap chain image // Create frame buffers for every swap chain image
frameBuffers.resize(swapChain.imageCount); frameBuffers.resize(swapChainImageViews.size());
for (uint32_t i = 0; i < frameBuffers.size(); i++) { for (uint32_t i = 0; i < swapChainImageViews.size(); i++) {
if (settings.multiSampling) { if (settings.multiSampling) {
attachments[1] = swapChain.buffers[i].view; attachments[3] = swapChainImageViews[i];
} }
else { else {
attachments[0] = swapChain.buffers[i].view; attachments[0] = swapChainImageViews[i];
} }
VK_CHECK_RESULT(vkCreateFramebuffer(device, &frameBufferCI, nullptr, &frameBuffers[i])); VK_CHECK_RESULT(vkCreateFramebuffer(device, &frameBufferCI, nullptr, &frameBuffers[i]));
} }
@ -2075,3 +2222,31 @@ void VulkanExampleBase::setupSwapChain()
{ {
swapChain.create(&width, &height, settings.vsync); swapChain.create(&width, &height, settings.vsync);
} }
VkFormat VulkanExampleBase::findDepthFormat()
{
return 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
);
}
VkFormat VulkanExampleBase::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");
}

16
base/vulkanexamplebase.h
View File

@ -113,13 +113,16 @@ public:
uint32_t lastFPS = 0; uint32_t lastFPS = 0;
struct Settings { struct Settings {
bool validation = false; // 校验层开关 uint32_t width = 1280;
uint32_t height = 720;
bool validation = true; // 校验层开关
bool fullscreen = false; // 全屏开关 bool fullscreen = false; // 全屏开关
bool vsync = false; // 垂直同步开关 bool vsync = false; // 垂直同步开关
bool multiSampling = true; // 多重采样 bool multiSampling = true; // 多重采样
bool rotateModel = true; // 模型自旋转(暂时失效) bool rotateModel = true; // 模型自旋转(暂时失效)
bool headless = false; // 无头开关 bool headless = false; // 无头开关
bool outputPNGimage = false; bool outputPNGimage = false;
uint32_t endFrameIndex = 75;
bool enableSaveToImageSequeue = true; // 图片序列开关（暂时弃用） bool enableSaveToImageSequeue = true; // 图片序列开关（暂时弃用）
uint32_t outputFrameCount = 75; // 图片序列结束帧 uint32_t outputFrameCount = 75; // 图片序列结束帧
bool takeScreenShot = false; // 截屏（暂时弃用） bool takeScreenShot = false; // 截屏（暂时弃用）
@ -136,6 +139,14 @@ public:
VkImageView view; VkImageView view;
} depthStencil; } depthStencil;
struct ColorAttachment {
VkImage image;
VkDeviceMemory memory;
VkImageView view;
} colorAttachment;
std::vector<VkImageView> swapChainImageViews;
struct GamePadState { struct GamePadState {
glm::vec2 axisLeft = glm::vec2(0.0f); glm::vec2 axisLeft = glm::vec2(0.0f);
glm::vec2 axisRight = glm::vec2(0.0f); glm::vec2 axisRight = glm::vec2(0.0f);
@ -257,11 +268,14 @@ public:
virtual void render() = 0; virtual void render() = 0;
virtual void windowResized(); virtual void windowResized();
virtual void setupFrameBuffer(); virtual void setupFrameBuffer();
void createSwapChainFramebuffer();
virtual void prepare(); virtual void prepare();
virtual void fileDropped(std::string filename); virtual void fileDropped(std::string filename);
void initSwapchain(); void initSwapchain();
void setupSwapChain(); void setupSwapChain();
VkFormat findDepthFormat();
VkFormat findSupportedFormat(const std::vector<VkFormat>& candidates, VkImageTiling tiling, VkFormatFeatureFlags features);
void renderLoop(); void renderLoop();
void renderFrame(); void renderFrame();