756 lines
34 KiB
C++
756 lines
34 KiB
C++
/*
|
||
|
||
* vulkan 贴图基础封装类
|
||
* 普通贴图使用stbi加载
|
||
* ktx格式cubeMap贴图使用ktx库加载
|
||
|
||
*/
|
||
|
||
#ifndef VULKANTEXTURE_HPP
|
||
#define VULKANTEXTURE_HPP
|
||
|
||
#include <algorithm>
|
||
#include <corecrt.h>
|
||
#include <cstdint>
|
||
#include <fstream>
|
||
#include <stdlib.h>
|
||
#include <string>
|
||
#include <vector>
|
||
|
||
#include "VulkanDevice.hpp"
|
||
#include "VulkanTools.h"
|
||
#include "ktx.h"
|
||
#include "stb_image.h"
|
||
|
||
#define GLM_ENABLE_EXPERIMENTAL
|
||
|
||
namespace vks
|
||
{
|
||
class Texture
|
||
{
|
||
public:
|
||
vks::VulkanDevice *device;
|
||
VkImage image = VK_NULL_HANDLE;
|
||
VkImageLayout imageLayout;
|
||
VkDeviceMemory deviceMemory;
|
||
VkImageView view;
|
||
uint32_t width, height;
|
||
uint32_t mipLevels;
|
||
uint32_t layerCount;
|
||
VkDescriptorImageInfo descriptor;
|
||
VkSampler sampler;
|
||
|
||
void updateDescriptor()
|
||
{
|
||
descriptor.sampler = sampler;
|
||
descriptor.imageView = view;
|
||
descriptor.imageLayout = imageLayout;
|
||
}
|
||
|
||
void destroy()
|
||
{
|
||
vkDestroyImageView(device->logicalDevice, view, nullptr);
|
||
vkDestroyImage(device->logicalDevice, image, nullptr);
|
||
if (sampler)
|
||
{
|
||
vkDestroySampler(device->logicalDevice, sampler, nullptr);
|
||
}
|
||
vkFreeMemory(device->logicalDevice, deviceMemory, nullptr);
|
||
}
|
||
|
||
private:
|
||
};
|
||
|
||
class Texture2D : public Texture
|
||
{
|
||
public:
|
||
void loadFromFile(
|
||
std::string filename,
|
||
VkFormat format,
|
||
vks::VulkanDevice *device,
|
||
VkQueue copyQueue,
|
||
VkImageUsageFlags imageUsageFlags = VK_IMAGE_USAGE_SAMPLED_BIT,
|
||
VkImageLayout imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL)
|
||
{
|
||
int texWidth, texHeight, texChannels;
|
||
unsigned char *texImageData = stbi_load(filename.c_str(), &texWidth, &texHeight, &texChannels, 0);
|
||
|
||
assert(texImageData == nullptr);
|
||
|
||
this->device = device;
|
||
width = static_cast<uint32_t>(texWidth);
|
||
height = static_cast<uint32_t>(texHeight);
|
||
// stb image 不自动生成mipmap层级，使用公式计算
|
||
mipLevels = static_cast<uint32_t>(std::floor(std::log2(std::max(this->width, this->height)))) + 1;
|
||
size_t texImageSize = texWidth * texHeight * texChannels;
|
||
|
||
// Get device properites for the requested texture format
|
||
VkFormatProperties formatProperties;
|
||
vkGetPhysicalDeviceFormatProperties(device->physicalDevice, format, &formatProperties);
|
||
|
||
VkMemoryAllocateInfo memAllocInfo{};
|
||
memAllocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
|
||
VkMemoryRequirements memReqs;
|
||
|
||
// Use a separate command buffer for texture loading
|
||
VkCommandBuffer copyCmd = device->createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, true);
|
||
|
||
// Create a host-visible staging buffer that contains the raw image data
|
||
VkBuffer stagingBuffer;
|
||
VkDeviceMemory stagingMemory;
|
||
|
||
VkBufferCreateInfo bufferCreateInfo{};
|
||
bufferCreateInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
|
||
bufferCreateInfo.size = texImageSize;
|
||
// This buffer is used as a transfer source for the buffer copy
|
||
bufferCreateInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
|
||
bufferCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
||
|
||
VK_CHECK_RESULT(vkCreateBuffer(device->logicalDevice, &bufferCreateInfo, nullptr, &stagingBuffer));
|
||
|
||
// Get memory requirements for the staging buffer (alignment, memory type bits)
|
||
vkGetBufferMemoryRequirements(device->logicalDevice, stagingBuffer, &memReqs);
|
||
|
||
memAllocInfo.allocationSize = memReqs.size;
|
||
// Get memory type index for a host visible buffer
|
||
memAllocInfo.memoryTypeIndex = device->getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
|
||
|
||
VK_CHECK_RESULT(vkAllocateMemory(device->logicalDevice, &memAllocInfo, nullptr, &stagingMemory));
|
||
VK_CHECK_RESULT(vkBindBufferMemory(device->logicalDevice, stagingBuffer, stagingMemory, 0));
|
||
|
||
// Copy texture data into staging buffer
|
||
uint8_t *data;
|
||
VK_CHECK_RESULT(vkMapMemory(device->logicalDevice, stagingMemory, 0, memReqs.size, 0, (void **)&data));
|
||
memcpy(data, texImageData, texImageSize);
|
||
vkUnmapMemory(device->logicalDevice, stagingMemory);
|
||
|
||
// clean up image data
|
||
stbi_image_free(texImageData);
|
||
|
||
// Create optimal tiled target image
|
||
VkImageCreateInfo imageCreateInfo{};
|
||
imageCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
|
||
imageCreateInfo.imageType = VK_IMAGE_TYPE_2D;
|
||
imageCreateInfo.format = format;
|
||
imageCreateInfo.mipLevels = 1;
|
||
imageCreateInfo.arrayLayers = 1;
|
||
imageCreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;
|
||
imageCreateInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
|
||
imageCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
||
imageCreateInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
||
imageCreateInfo.extent = {width, height, 1};
|
||
imageCreateInfo.usage = imageUsageFlags;
|
||
// Ensure that the TRANSFER_DST bit is set for staging
|
||
if (!(imageCreateInfo.usage & VK_IMAGE_USAGE_TRANSFER_DST_BIT))
|
||
{
|
||
imageCreateInfo.usage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
|
||
}
|
||
VK_CHECK_RESULT(vkCreateImage(device->logicalDevice, &imageCreateInfo, nullptr, &image));
|
||
|
||
vkGetImageMemoryRequirements(device->logicalDevice, image, &memReqs);
|
||
|
||
memAllocInfo.allocationSize = memReqs.size;
|
||
|
||
memAllocInfo.memoryTypeIndex = device->getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
|
||
VK_CHECK_RESULT(vkAllocateMemory(device->logicalDevice, &memAllocInfo, nullptr, &deviceMemory));
|
||
VK_CHECK_RESULT(vkBindImageMemory(device->logicalDevice, image, deviceMemory, 0));
|
||
|
||
VkImageSubresourceRange subresourceRange = {};
|
||
subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
||
subresourceRange.baseMipLevel = 0;
|
||
subresourceRange.levelCount = 1; // 目前只处理第一级
|
||
subresourceRange.layerCount = 1;
|
||
|
||
// Image barrier for optimal image (target)
|
||
// Optimal image will be used as destination for the copy
|
||
{
|
||
VkImageMemoryBarrier imageMemoryBarrier{};
|
||
imageMemoryBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
|
||
imageMemoryBarrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
||
imageMemoryBarrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
|
||
imageMemoryBarrier.srcAccessMask = 0;
|
||
imageMemoryBarrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
|
||
imageMemoryBarrier.image = image;
|
||
imageMemoryBarrier.subresourceRange = subresourceRange;
|
||
vkCmdPipelineBarrier(copyCmd, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0, nullptr, 0, nullptr, 1, &imageMemoryBarrier);
|
||
}
|
||
|
||
VkBufferImageCopy bufferCopyRegion = {};
|
||
bufferCopyRegion.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
||
bufferCopyRegion.imageSubresource.mipLevel = 0;
|
||
bufferCopyRegion.imageSubresource.baseArrayLayer = 0;
|
||
bufferCopyRegion.imageSubresource.layerCount = 1;
|
||
bufferCopyRegion.imageExtent.width = width;
|
||
bufferCopyRegion.imageExtent.height = height;
|
||
bufferCopyRegion.imageExtent.depth = 1;
|
||
bufferCopyRegion.bufferOffset = 0;
|
||
|
||
// Copy mip levels from staging buffer
|
||
vkCmdCopyBufferToImage(
|
||
copyCmd,
|
||
stagingBuffer,
|
||
image,
|
||
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
|
||
static_cast<uint32_t>(1),
|
||
&bufferCopyRegion);
|
||
|
||
generateMipmaps(copyCmd, format);
|
||
|
||
// Change texture image layout to shader read after all mip levels have been copied
|
||
this->imageLayout = imageLayout;
|
||
{
|
||
VkImageMemoryBarrier imageMemoryBarrier{};
|
||
imageMemoryBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
|
||
imageMemoryBarrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
|
||
imageMemoryBarrier.newLayout = imageLayout;
|
||
imageMemoryBarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
|
||
imageMemoryBarrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
|
||
imageMemoryBarrier.image = image;
|
||
imageMemoryBarrier.subresourceRange = subresourceRange;
|
||
vkCmdPipelineBarrier(copyCmd, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0, nullptr, 0, nullptr, 1, &imageMemoryBarrier);
|
||
}
|
||
|
||
device->flushCommandBuffer(copyCmd, copyQueue);
|
||
|
||
// Clean up staging resources
|
||
vkFreeMemory(device->logicalDevice, stagingMemory, nullptr);
|
||
vkDestroyBuffer(device->logicalDevice, stagingBuffer, nullptr);
|
||
|
||
VkSamplerCreateInfo samplerCreateInfo{};
|
||
samplerCreateInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
|
||
samplerCreateInfo.magFilter = VK_FILTER_LINEAR;
|
||
samplerCreateInfo.minFilter = VK_FILTER_LINEAR;
|
||
samplerCreateInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
|
||
samplerCreateInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT;
|
||
samplerCreateInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT;
|
||
samplerCreateInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT;
|
||
samplerCreateInfo.mipLodBias = 0.0f;
|
||
samplerCreateInfo.compareOp = VK_COMPARE_OP_NEVER;
|
||
samplerCreateInfo.minLod = 0.0f;
|
||
samplerCreateInfo.maxLod = (float)mipLevels;
|
||
samplerCreateInfo.maxAnisotropy = device->enabledFeatures.samplerAnisotropy ? device->properties.limits.maxSamplerAnisotropy : 1.0f;
|
||
samplerCreateInfo.anisotropyEnable = device->enabledFeatures.samplerAnisotropy;
|
||
samplerCreateInfo.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
|
||
VK_CHECK_RESULT(vkCreateSampler(device->logicalDevice, &samplerCreateInfo, nullptr, &sampler));
|
||
|
||
VkImageViewCreateInfo viewCreateInfo{};
|
||
viewCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
|
||
viewCreateInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
|
||
viewCreateInfo.format = format;
|
||
viewCreateInfo.components = {VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A};
|
||
viewCreateInfo.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1};
|
||
viewCreateInfo.subresourceRange.levelCount = mipLevels;
|
||
viewCreateInfo.image = image;
|
||
VK_CHECK_RESULT(vkCreateImageView(device->logicalDevice, &viewCreateInfo, nullptr, &view));
|
||
|
||
updateDescriptor();
|
||
}
|
||
|
||
void loadFromBuffer(
|
||
void *buffer,
|
||
VkDeviceSize bufferSize,
|
||
VkFormat format,
|
||
uint32_t width,
|
||
uint32_t height,
|
||
vks::VulkanDevice *device,
|
||
VkQueue copyQueue,
|
||
VkFilter filter = VK_FILTER_LINEAR,
|
||
VkImageUsageFlags imageUsageFlags = VK_IMAGE_USAGE_SAMPLED_BIT,
|
||
VkImageLayout imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL)
|
||
{
|
||
assert(buffer);
|
||
|
||
this->device = device;
|
||
width = width;
|
||
height = height;
|
||
mipLevels = 1;
|
||
|
||
VkMemoryAllocateInfo memAllocInfo{};
|
||
memAllocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
|
||
VkMemoryRequirements memReqs;
|
||
// Use a separate command buffer for texture loading
|
||
VkCommandBuffer copyCmd = device->createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, true);
|
||
|
||
// Create a host-visible staging buffer that contains the raw image data
|
||
VkBuffer stagingBuffer;
|
||
VkDeviceMemory stagingMemory;
|
||
|
||
VkBufferCreateInfo bufferCreateInfo{};
|
||
bufferCreateInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
|
||
bufferCreateInfo.size = bufferSize;
|
||
// This buffer is used as a transfer source for the buffer copy
|
||
bufferCreateInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
|
||
bufferCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
||
|
||
VK_CHECK_RESULT(vkCreateBuffer(device->logicalDevice, &bufferCreateInfo, nullptr, &stagingBuffer));
|
||
|
||
// Get memory requirements for the staging buffer (alignment, memory type bits)
|
||
vkGetBufferMemoryRequirements(device->logicalDevice, stagingBuffer, &memReqs);
|
||
|
||
memAllocInfo.allocationSize = memReqs.size;
|
||
// Get memory type index for a host visible buffer
|
||
memAllocInfo.memoryTypeIndex = device->getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
|
||
|
||
VK_CHECK_RESULT(vkAllocateMemory(device->logicalDevice, &memAllocInfo, nullptr, &stagingMemory));
|
||
VK_CHECK_RESULT(vkBindBufferMemory(device->logicalDevice, stagingBuffer, stagingMemory, 0));
|
||
|
||
// Copy texture data into staging buffer
|
||
uint8_t *data;
|
||
VK_CHECK_RESULT(vkMapMemory(device->logicalDevice, stagingMemory, 0, memReqs.size, 0, (void **)&data));
|
||
memcpy(data, buffer, bufferSize);
|
||
vkUnmapMemory(device->logicalDevice, stagingMemory);
|
||
|
||
VkBufferImageCopy bufferCopyRegion = {};
|
||
bufferCopyRegion.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
||
bufferCopyRegion.imageSubresource.mipLevel = 0;
|
||
bufferCopyRegion.imageSubresource.baseArrayLayer = 0;
|
||
bufferCopyRegion.imageSubresource.layerCount = 1;
|
||
bufferCopyRegion.imageExtent.width = width;
|
||
bufferCopyRegion.imageExtent.height = height;
|
||
bufferCopyRegion.imageExtent.depth = 1;
|
||
bufferCopyRegion.bufferOffset = 0;
|
||
|
||
// Create optimal tiled target image
|
||
VkImageCreateInfo imageCreateInfo{};
|
||
imageCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
|
||
imageCreateInfo.imageType = VK_IMAGE_TYPE_2D;
|
||
imageCreateInfo.format = format;
|
||
imageCreateInfo.mipLevels = mipLevels;
|
||
imageCreateInfo.arrayLayers = 1;
|
||
imageCreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;
|
||
imageCreateInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
|
||
imageCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
||
imageCreateInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
||
imageCreateInfo.extent = {width, height, 1};
|
||
imageCreateInfo.usage = imageUsageFlags;
|
||
// Ensure that the TRANSFER_DST bit is set for staging
|
||
if (!(imageCreateInfo.usage & VK_IMAGE_USAGE_TRANSFER_DST_BIT))
|
||
{
|
||
imageCreateInfo.usage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
|
||
}
|
||
VK_CHECK_RESULT(vkCreateImage(device->logicalDevice, &imageCreateInfo, nullptr, &image));
|
||
|
||
vkGetImageMemoryRequirements(device->logicalDevice, image, &memReqs);
|
||
|
||
memAllocInfo.allocationSize = memReqs.size;
|
||
|
||
memAllocInfo.memoryTypeIndex = device->getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
|
||
VK_CHECK_RESULT(vkAllocateMemory(device->logicalDevice, &memAllocInfo, nullptr, &deviceMemory));
|
||
VK_CHECK_RESULT(vkBindImageMemory(device->logicalDevice, image, deviceMemory, 0));
|
||
|
||
VkImageSubresourceRange subresourceRange = {};
|
||
subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
||
subresourceRange.baseMipLevel = 0;
|
||
subresourceRange.levelCount = mipLevels;
|
||
subresourceRange.layerCount = 1;
|
||
|
||
{
|
||
VkImageMemoryBarrier imageMemoryBarrier{};
|
||
imageMemoryBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
|
||
imageMemoryBarrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
||
imageMemoryBarrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
|
||
imageMemoryBarrier.srcAccessMask = 0;
|
||
imageMemoryBarrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
|
||
imageMemoryBarrier.image = image;
|
||
imageMemoryBarrier.subresourceRange = subresourceRange;
|
||
vkCmdPipelineBarrier(copyCmd, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0, nullptr, 0, nullptr, 1, &imageMemoryBarrier);
|
||
}
|
||
|
||
vkCmdCopyBufferToImage(
|
||
copyCmd,
|
||
stagingBuffer,
|
||
image,
|
||
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
|
||
1,
|
||
&bufferCopyRegion);
|
||
|
||
this->imageLayout = imageLayout;
|
||
{
|
||
VkImageMemoryBarrier imageMemoryBarrier{};
|
||
imageMemoryBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
|
||
imageMemoryBarrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
|
||
imageMemoryBarrier.newLayout = imageLayout;
|
||
imageMemoryBarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
|
||
imageMemoryBarrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
|
||
imageMemoryBarrier.image = image;
|
||
imageMemoryBarrier.subresourceRange = subresourceRange;
|
||
vkCmdPipelineBarrier(copyCmd, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0, nullptr, 0, nullptr, 1, &imageMemoryBarrier);
|
||
}
|
||
|
||
device->flushCommandBuffer(copyCmd, copyQueue);
|
||
|
||
// Clean up staging resources
|
||
vkFreeMemory(device->logicalDevice, stagingMemory, nullptr);
|
||
vkDestroyBuffer(device->logicalDevice, stagingBuffer, nullptr);
|
||
|
||
// Create sampler
|
||
VkSamplerCreateInfo samplerCreateInfo = {};
|
||
samplerCreateInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
|
||
samplerCreateInfo.magFilter = filter;
|
||
samplerCreateInfo.minFilter = filter;
|
||
samplerCreateInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
|
||
samplerCreateInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT;
|
||
samplerCreateInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT;
|
||
samplerCreateInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT;
|
||
samplerCreateInfo.mipLodBias = 0.0f;
|
||
samplerCreateInfo.compareOp = VK_COMPARE_OP_NEVER;
|
||
samplerCreateInfo.minLod = 0.0f;
|
||
samplerCreateInfo.maxLod = 0.0f;
|
||
samplerCreateInfo.maxAnisotropy = 1.0f;
|
||
VK_CHECK_RESULT(vkCreateSampler(device->logicalDevice, &samplerCreateInfo, nullptr, &sampler));
|
||
|
||
// Create image view
|
||
VkImageViewCreateInfo viewCreateInfo = {};
|
||
viewCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
|
||
viewCreateInfo.pNext = NULL;
|
||
viewCreateInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
|
||
viewCreateInfo.format = format;
|
||
viewCreateInfo.components = {VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A};
|
||
viewCreateInfo.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1};
|
||
viewCreateInfo.subresourceRange.levelCount = 1;
|
||
viewCreateInfo.image = image;
|
||
VK_CHECK_RESULT(vkCreateImageView(device->logicalDevice, &viewCreateInfo, nullptr, &view));
|
||
|
||
// Update descriptor image info member that can be used for setting up descriptor sets
|
||
updateDescriptor();
|
||
}
|
||
|
||
private:
|
||
void generateMipmaps(VkCommandBuffer commandBuffer, VkFormat format)
|
||
{
|
||
VkFormatProperties formatProperties;
|
||
vkGetPhysicalDeviceFormatProperties(device->physicalDevice, format, &formatProperties);
|
||
|
||
if (!(formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT))
|
||
{
|
||
throw std::runtime_error("Texture image format does not support linear blitting!");
|
||
}
|
||
|
||
VkImageMemoryBarrier imageMemoryBarrier{};
|
||
imageMemoryBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
|
||
imageMemoryBarrier.image = image;
|
||
imageMemoryBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
|
||
imageMemoryBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
|
||
imageMemoryBarrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
||
imageMemoryBarrier.subresourceRange.layerCount = 1;
|
||
imageMemoryBarrier.subresourceRange.levelCount = 1;
|
||
|
||
uint32_t mipWidth = width;
|
||
uint32_t mipHeight = height;
|
||
|
||
for (uint32_t i = 1; i < mipLevels; i++)
|
||
{
|
||
imageMemoryBarrier.subresourceRange.baseMipLevel = i - 1;
|
||
imageMemoryBarrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
|
||
imageMemoryBarrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
|
||
imageMemoryBarrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
|
||
imageMemoryBarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
|
||
|
||
vkCmdPipelineBarrier(commandBuffer,
|
||
VK_PIPELINE_STAGE_TRANSFER_BIT,
|
||
VK_PIPELINE_STAGE_TRANSFER_BIT,
|
||
0,
|
||
0,
|
||
nullptr,
|
||
0,
|
||
nullptr,
|
||
1,
|
||
&imageMemoryBarrier);
|
||
|
||
VkImageBlit blit{};
|
||
blit.srcOffsets[0] = {0, 0, 0};
|
||
blit.srcOffsets[1] = {static_cast<int32_t>(mipWidth), static_cast<int32_t>(mipHeight), 1};
|
||
blit.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
||
blit.srcSubresource.mipLevel = i - 1;
|
||
blit.srcSubresource.baseArrayLayer = 0;
|
||
blit.srcSubresource.layerCount = 1;
|
||
blit.dstOffsets[0] = {0, 0, 0};
|
||
int32_t dstOffsetX = 1;
|
||
int32_t dstOffsetY = 1;
|
||
if (mipWidth > 1)
|
||
{
|
||
dstOffsetX = static_cast<int32_t>(mipWidth / 2);
|
||
}
|
||
if (mipHeight > 1)
|
||
{
|
||
dstOffsetY = static_cast<int32_t>(mipHeight / 2);
|
||
}
|
||
blit.dstOffsets[1] = {dstOffsetX, dstOffsetY, 1};
|
||
blit.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
||
blit.dstSubresource.mipLevel = i;
|
||
blit.dstSubresource.baseArrayLayer = 0;
|
||
blit.dstSubresource.layerCount = 1;
|
||
|
||
vkCmdBlitImage(commandBuffer,
|
||
image,
|
||
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
|
||
image,
|
||
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
|
||
1,
|
||
&blit, VK_FILTER_LINEAR);
|
||
|
||
imageMemoryBarrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
|
||
imageMemoryBarrier.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
|
||
imageMemoryBarrier.srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
|
||
imageMemoryBarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
|
||
|
||
vkCmdPipelineBarrier(commandBuffer,
|
||
VK_PIPELINE_STAGE_TRANSFER_BIT,
|
||
VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
|
||
0,
|
||
0,
|
||
nullptr,
|
||
0,
|
||
nullptr,
|
||
1,
|
||
&imageMemoryBarrier);
|
||
|
||
if (mipWidth > 1)
|
||
{
|
||
mipWidth = mipWidth / 2;
|
||
}
|
||
if (mipHeight > 1)
|
||
{
|
||
mipHeight = mipHeight / 2;
|
||
}
|
||
}
|
||
imageMemoryBarrier.subresourceRange.baseMipLevel = 0;
|
||
imageMemoryBarrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
|
||
imageMemoryBarrier.newLayout = imageLayout;
|
||
imageMemoryBarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
|
||
imageMemoryBarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
|
||
imageMemoryBarrier.subresourceRange.levelCount = mipLevels;
|
||
|
||
vkCmdPipelineBarrier(commandBuffer,
|
||
VK_PIPELINE_STAGE_TRANSFER_BIT,
|
||
VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
|
||
0,
|
||
0,
|
||
nullptr,
|
||
0,
|
||
nullptr,
|
||
1,
|
||
&imageMemoryBarrier);
|
||
}
|
||
};
|
||
|
||
class TextureCubeMap : public Texture
|
||
{
|
||
public:
|
||
void loadFromFile(
|
||
std::string filename,
|
||
VkFormat format,
|
||
vks::VulkanDevice *device,
|
||
VkQueue copyQueue,
|
||
VkImageUsageFlags imageUsageFlags = VK_IMAGE_USAGE_SAMPLED_BIT,
|
||
VkImageLayout imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL)
|
||
{
|
||
ktxTexture *cubeMapTexture = nullptr;
|
||
KTX_error_code ktxResult = ktxTexture_CreateFromNamedFile(filename.c_str(), KTX_TEXTURE_CREATE_LOAD_IMAGE_DATA_BIT, &cubeMapTexture);
|
||
if (ktxResult != KTX_SUCCESS)
|
||
{
|
||
throw std::runtime_error("Failed to load KTX texture");
|
||
}
|
||
|
||
this->device = device;
|
||
width = static_cast<uint32_t>(cubeMapTexture->baseWidth);
|
||
height = static_cast<uint32_t>(cubeMapTexture->baseHeight);
|
||
mipLevels = cubeMapTexture->numLevels;
|
||
layerCount = cubeMapTexture->numLayers;
|
||
|
||
VkMemoryAllocateInfo memAllocInfo{};
|
||
memAllocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
|
||
VkMemoryRequirements memReqs;
|
||
|
||
// Create a host-visible staging buffer that contains the raw image data
|
||
VkBuffer stagingBuffer;
|
||
VkDeviceMemory stagingMemory;
|
||
|
||
VkBufferCreateInfo bufferCreateInfo{};
|
||
bufferCreateInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
|
||
bufferCreateInfo.size = cubeMapTexture->dataSize;
|
||
|
||
// This buffer is used as a transfer source for the buffer copy
|
||
bufferCreateInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
|
||
bufferCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
||
|
||
VK_CHECK_RESULT(vkCreateBuffer(device->logicalDevice, &bufferCreateInfo, nullptr, &stagingBuffer));
|
||
|
||
// Get memory requirements for the staging buffer (alignment, memory type bits)
|
||
vkGetBufferMemoryRequirements(device->logicalDevice, stagingBuffer, &memReqs);
|
||
|
||
memAllocInfo.allocationSize = memReqs.size;
|
||
// Get memory type index for a host visible buffer
|
||
memAllocInfo.memoryTypeIndex = device->getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
|
||
|
||
VK_CHECK_RESULT(vkAllocateMemory(device->logicalDevice, &memAllocInfo, nullptr, &stagingMemory));
|
||
VK_CHECK_RESULT(vkBindBufferMemory(device->logicalDevice, stagingBuffer, stagingMemory, 0));
|
||
|
||
// Copy texture data into staging buffer
|
||
uint8_t *data;
|
||
VK_CHECK_RESULT(vkMapMemory(device->logicalDevice, stagingMemory, 0, memReqs.size, 0, (void **)&data));
|
||
memcpy(data, ktxTexture_GetData(cubeMapTexture), cubeMapTexture->dataSize);
|
||
vkUnmapMemory(device->logicalDevice, stagingMemory);
|
||
|
||
// Setup buffer copy regions for each face including all of it's miplevels
|
||
std::vector<VkBufferImageCopy> bufferCopyRegions;
|
||
size_t offset = 0;
|
||
|
||
for (uint32_t face = 0; face < 6; face++)
|
||
{
|
||
for (uint32_t level = 0; level < mipLevels; level++)
|
||
{
|
||
ktx_size_t offset;
|
||
KTX_error_code result = ktxTexture_GetImageOffset(
|
||
cubeMapTexture,
|
||
level, // mip level
|
||
0, // array layer
|
||
face, // face
|
||
&offset);
|
||
|
||
if (result != KTX_SUCCESS)
|
||
{
|
||
ktxTexture_Destroy(cubeMapTexture);
|
||
throw std::runtime_error("Failed to get image offset from KTX texture");
|
||
}
|
||
|
||
VkBufferImageCopy bufferCopyRegion = {};
|
||
bufferCopyRegion.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
||
bufferCopyRegion.imageSubresource.mipLevel = level;
|
||
bufferCopyRegion.imageSubresource.baseArrayLayer = face;
|
||
bufferCopyRegion.imageSubresource.layerCount = 1;
|
||
|
||
uint32_t mipWidth = std::max(1u, width >> level);
|
||
uint32_t mipHeight = std::max(1u, height >> level);
|
||
|
||
bufferCopyRegion.imageExtent.width = mipWidth;
|
||
bufferCopyRegion.imageExtent.height = mipHeight;
|
||
bufferCopyRegion.imageExtent.depth = 1;
|
||
bufferCopyRegion.bufferOffset = offset;
|
||
|
||
bufferCopyRegions.push_back(bufferCopyRegion);
|
||
}
|
||
}
|
||
|
||
// Create optimal tiled target image
|
||
VkImageCreateInfo imageCreateInfo{};
|
||
imageCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
|
||
imageCreateInfo.imageType = VK_IMAGE_TYPE_2D;
|
||
imageCreateInfo.format = format;
|
||
imageCreateInfo.mipLevels = mipLevels;
|
||
imageCreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;
|
||
imageCreateInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
|
||
imageCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
||
imageCreateInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
||
imageCreateInfo.extent = {width, height, 1};
|
||
imageCreateInfo.usage = imageUsageFlags;
|
||
// Ensure that the TRANSFER_DST bit is set for staging
|
||
if (!(imageCreateInfo.usage & VK_IMAGE_USAGE_TRANSFER_DST_BIT))
|
||
{
|
||
imageCreateInfo.usage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
|
||
}
|
||
// Cube faces count as array layers in Vulkan
|
||
imageCreateInfo.arrayLayers = 6;
|
||
// This flag is required for cube map images
|
||
imageCreateInfo.flags = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
|
||
|
||
VK_CHECK_RESULT(vkCreateImage(device->logicalDevice, &imageCreateInfo, nullptr, &image));
|
||
|
||
vkGetImageMemoryRequirements(device->logicalDevice, image, &memReqs);
|
||
|
||
memAllocInfo.allocationSize = memReqs.size;
|
||
memAllocInfo.memoryTypeIndex = device->getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
|
||
|
||
VK_CHECK_RESULT(vkAllocateMemory(device->logicalDevice, &memAllocInfo, nullptr, &deviceMemory));
|
||
VK_CHECK_RESULT(vkBindImageMemory(device->logicalDevice, image, deviceMemory, 0));
|
||
|
||
// Use a separate command buffer for texture loading
|
||
VkCommandBuffer copyCmd = device->createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, true);
|
||
|
||
// Image barrier for optimal image (target)
|
||
// Set initial layout for all array layers (faces) of the optimal (target) tiled texture
|
||
VkImageSubresourceRange subresourceRange = {};
|
||
subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
||
subresourceRange.baseMipLevel = 0;
|
||
subresourceRange.levelCount = mipLevels;
|
||
subresourceRange.layerCount = 6;
|
||
|
||
{
|
||
VkImageMemoryBarrier imageMemoryBarrier{};
|
||
imageMemoryBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
|
||
imageMemoryBarrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
||
imageMemoryBarrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
|
||
imageMemoryBarrier.srcAccessMask = 0;
|
||
imageMemoryBarrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
|
||
imageMemoryBarrier.image = image;
|
||
imageMemoryBarrier.subresourceRange = subresourceRange;
|
||
vkCmdPipelineBarrier(copyCmd, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0, nullptr, 0, nullptr, 1, &imageMemoryBarrier);
|
||
}
|
||
|
||
// Copy the cube map faces from the staging buffer to the optimal tiled image
|
||
vkCmdCopyBufferToImage(
|
||
copyCmd,
|
||
stagingBuffer,
|
||
image,
|
||
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
|
||
static_cast<uint32_t>(bufferCopyRegions.size()),
|
||
bufferCopyRegions.data());
|
||
|
||
// Change texture image layout to shader read after all faces have been copied
|
||
this->imageLayout = imageLayout;
|
||
{
|
||
VkImageMemoryBarrier imageMemoryBarrier{};
|
||
imageMemoryBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
|
||
imageMemoryBarrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
|
||
imageMemoryBarrier.newLayout = imageLayout;
|
||
imageMemoryBarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
|
||
imageMemoryBarrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
|
||
imageMemoryBarrier.image = image;
|
||
imageMemoryBarrier.subresourceRange = subresourceRange;
|
||
vkCmdPipelineBarrier(copyCmd, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0, nullptr, 0, nullptr, 1, &imageMemoryBarrier);
|
||
}
|
||
|
||
device->flushCommandBuffer(copyCmd, copyQueue);
|
||
|
||
// Create sampler
|
||
VkSamplerCreateInfo samplerCreateInfo{};
|
||
samplerCreateInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
|
||
samplerCreateInfo.magFilter = VK_FILTER_LINEAR;
|
||
samplerCreateInfo.minFilter = VK_FILTER_LINEAR;
|
||
samplerCreateInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
|
||
samplerCreateInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
|
||
samplerCreateInfo.addressModeV = samplerCreateInfo.addressModeU;
|
||
samplerCreateInfo.addressModeW = samplerCreateInfo.addressModeU;
|
||
samplerCreateInfo.mipLodBias = 0.0f;
|
||
samplerCreateInfo.maxAnisotropy = device->enabledFeatures.samplerAnisotropy ? device->properties.limits.maxSamplerAnisotropy : 1.0f;
|
||
samplerCreateInfo.anisotropyEnable = device->enabledFeatures.samplerAnisotropy;
|
||
samplerCreateInfo.compareOp = VK_COMPARE_OP_NEVER;
|
||
samplerCreateInfo.minLod = 0.0f;
|
||
samplerCreateInfo.maxLod = (float)mipLevels;
|
||
samplerCreateInfo.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
|
||
VK_CHECK_RESULT(vkCreateSampler(device->logicalDevice, &samplerCreateInfo, nullptr, &sampler));
|
||
|
||
// Create image view
|
||
VkImageViewCreateInfo viewCreateInfo{};
|
||
viewCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
|
||
viewCreateInfo.viewType = VK_IMAGE_VIEW_TYPE_CUBE;
|
||
viewCreateInfo.format = format;
|
||
viewCreateInfo.components = {VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A};
|
||
viewCreateInfo.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1};
|
||
viewCreateInfo.subresourceRange.layerCount = 6;
|
||
viewCreateInfo.subresourceRange.levelCount = mipLevels;
|
||
viewCreateInfo.image = image;
|
||
VK_CHECK_RESULT(vkCreateImageView(device->logicalDevice, &viewCreateInfo, nullptr, &view));
|
||
|
||
// Clean up staging resources
|
||
vkFreeMemory(device->logicalDevice, stagingMemory, nullptr);
|
||
vkDestroyBuffer(device->logicalDevice, stagingBuffer, nullptr);
|
||
|
||
// Update descriptor image info member that can be used for setting up descriptor sets
|
||
updateDescriptor();
|
||
}
|
||
};
|
||
|
||
} // namespace vks
|
||
|
||
#endif |