void Copy_To_Swapchain::destroy() {
vkDestroyDescriptorSetLayout(vk.device, set_layout, nullptr);
vkDestroyPipelineLayout(vk.device, pipeline_layout, nullptr);
vkDestroyPipeline(vk.device, pipeline, nullptr);
vkDestroySampler(vk.device, point_sampler, nullptr);
sets.clear();
}
void VulkanTexturedQuad::ShutdownImpl()
{
vkDestroyPipeline(device_, pipeline_, nullptr);
vkDestroyPipelineLayout(device_, pipelineLayout_, nullptr);
vkDestroyBuffer(device_, vertexBuffer_, nullptr);
vkDestroyBuffer(device_, indexBuffer_, nullptr);
vkFreeMemory(device_, deviceBufferMemory_, nullptr);
vkDestroyImageView (device_, rubyImageView_, nullptr);
vkDestroyImage (device_, rubyImage_, nullptr);
vkFreeMemory (device_, deviceImageMemory_, nullptr);
vkDestroyBuffer (device_, uploadImageBuffer_, nullptr);
vkFreeMemory (device_, uploadImageMemory_, nullptr);
vkDestroyBuffer (device_, uploadBufferBuffer_, nullptr);
vkFreeMemory (device_, uploadBufferMemory_, nullptr);
vkDestroyDescriptorSetLayout (device_, descriptorSetLayout_, nullptr);
vkDestroyDescriptorPool (device_, descriptorPool_, nullptr);
vkDestroySampler (device_, sampler_, nullptr);
vkDestroyShaderModule(device_, vertexShader_, nullptr);
vkDestroyShaderModule(device_, fragmentShader_, nullptr);
VulkanSample::ShutdownImpl();
}
void ObjectCache::DestroySamplers()
{
ClearSamplerCache();
if (m_point_sampler != VK_NULL_HANDLE)
{
vkDestroySampler(g_vulkan_context->GetDevice(), m_point_sampler, nullptr);
m_point_sampler = VK_NULL_HANDLE;
}
if (m_linear_sampler != VK_NULL_HANDLE)
{
vkDestroySampler(g_vulkan_context->GetDevice(), m_linear_sampler, nullptr);
m_linear_sampler = VK_NULL_HANDLE;
}
}
void loadAssets()
{
// Models
models.skybox.loadFromFile(vulkanDevice, getAssetPath() + "models/cube.obj", vertexLayout, 0.05f, queue);
std::vector<std::string> filenames = {"sphere.obj", "teapot.dae", "torusknot.obj"};
for (auto file : filenames) {
vks::Model model;
model.loadFromFile(vulkanDevice, getAssetPath() + "models/" + file, vertexLayout, 0.05f, queue);
models.objects.push_back(model);
}
// Load HDR texture (equirectangular projected)
// VK_FORMAT_BC6H_UFLOAT_BLOCK is a compressed 16 bit unsigned floating point format for storing HDR content
textures.envmap.loadFromFile(getAssetPath() + "textures/hdr_uffizi_bc6uf.DDS", VK_FORMAT_BC6H_UFLOAT_BLOCK, vulkanDevice, queue);
// Custom sampler with clamping adress mode
vkDestroySampler(device, textures.envmap.sampler, nullptr);
VkSamplerCreateInfo sampler{};
sampler.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
sampler.magFilter = VK_FILTER_LINEAR;
sampler.minFilter = VK_FILTER_LINEAR;
sampler.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
sampler.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
sampler.addressModeV = sampler.addressModeU;
sampler.addressModeW = sampler.addressModeU;
sampler.maxLod = (float)textures.envmap.mipLevels;
sampler.maxLod = 1.0f;
sampler.anisotropyEnable = VK_TRUE;
sampler.maxAnisotropy = vulkanDevice->properties.limits.maxSamplerAnisotropy;
sampler.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
VK_CHECK_RESULT(vkCreateSampler(vulkanDevice->logicalDevice, &sampler, nullptr, &textures.envmap.sampler));
textures.envmap.descriptor.sampler = textures.envmap.sampler;
}
~VulkanExample()
{
// Clean up used Vulkan resources
// Note : Inherited destructor cleans up resources stored in base class
// Clean up texture resources
vkDestroyImageView(device, cubeMap.view, nullptr);
vkDestroyImage(device, cubeMap.image, nullptr);
vkDestroySampler(device, cubeMap.sampler, nullptr);
vkFreeMemory(device, cubeMap.deviceMemory, nullptr);
vkDestroyPipeline(device, pipelines.skybox, nullptr);
vkDestroyPipeline(device, pipelines.reflect, nullptr);
vkDestroyPipelineLayout(device, pipelineLayout, nullptr);
vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr);
for (auto& model : models.objects) {
model.destroy();
}
models.skybox.destroy();
uniformBuffers.object.destroy();
uniformBuffers.skybox.destroy();
}
SamplerImpl::~SamplerImpl()
{
if(m_handle)
{
vkDestroySampler(getDevice(), m_handle, nullptr);
}
}
void ImGui_ImplGlfwVulkan_InvalidateDeviceObjects()
{
ImGui_ImplGlfwVulkan_InvalidateFontUploadObjects();
for (int i=0; i<IMGUI_VK_QUEUED_FRAMES; i++)
{
if (g_VertexBuffer[i])
vkDestroyBuffer(g_Device, g_VertexBuffer[i], g_Allocator);
if (g_VertexBufferMemory[i])
vkFreeMemory(g_Device, g_VertexBufferMemory[i], g_Allocator);
if (g_IndexBuffer[i])
vkDestroyBuffer(g_Device, g_IndexBuffer[i], g_Allocator);
if (g_IndexBufferMemory[i])
vkFreeMemory(g_Device, g_IndexBufferMemory[i], g_Allocator);
}
if (g_FontView)
vkDestroyImageView(g_Device, g_FontView, g_Allocator);
if (g_FontImage)
vkDestroyImage(g_Device, g_FontImage, g_Allocator);
if (g_FontMemory)
vkFreeMemory(g_Device, g_FontMemory, g_Allocator);
if (g_FontSampler)
vkDestroySampler(g_Device, g_FontSampler, g_Allocator);
if (g_DescriptorSetLayout)
vkDestroyDescriptorSetLayout(g_Device, g_DescriptorSetLayout, g_Allocator);
if (g_PipelineLayout)
vkDestroyPipelineLayout(g_Device, g_PipelineLayout, g_Allocator);
if (g_Pipeline)
vkDestroyPipeline(g_Device, g_Pipeline, g_Allocator);
}
void ObjectCache::ClearSamplerCache()
{
for (const auto& it : m_sampler_cache)
{
if (it.second != VK_NULL_HANDLE)
vkDestroySampler(g_vulkan_context->GetDevice(), it.second, nullptr);
}
m_sampler_cache.clear();
}
void destroy_global_resources()
{
g_null_texture.reset();
g_null_image_view .reset();
if (g_null_sampler)
vkDestroySampler(g_current_renderer, g_null_sampler, nullptr);
g_null_sampler = nullptr;
}
// Free all Vulkan resources used a texture object
void destroyTextureImage(Texture texture)
{
if (texture.view != VK_NULL_HANDLE)
vkDestroyImageView(device, texture.view, nullptr);
if (texture.image != VK_NULL_HANDLE)
vkDestroyImage(device, texture.image, nullptr);
if (texture.sampler != VK_NULL_HANDLE)
vkDestroySampler(device, texture.sampler, nullptr);
if (texture.deviceMemory != VK_NULL_HANDLE)
vkFreeMemory(device, texture.deviceMemory, nullptr);
}
~VulkanExample()
{
vkDestroyPipeline(device, pipelines.skybox, nullptr);
vkDestroyPipeline(device, pipelines.reflect, nullptr);
vkDestroyPipeline(device, pipelines.composition, nullptr);
vkDestroyPipeline(device, pipelines.bloom[0], nullptr);
vkDestroyPipeline(device, pipelines.bloom[1], nullptr);
vkDestroyPipelineLayout(device, pipelineLayouts.models, nullptr);
vkDestroyPipelineLayout(device, pipelineLayouts.composition, nullptr);
vkDestroyPipelineLayout(device, pipelineLayouts.bloomFilter, nullptr);
vkDestroyDescriptorSetLayout(device, descriptorSetLayouts.models, nullptr);
vkDestroyDescriptorSetLayout(device, descriptorSetLayouts.composition, nullptr);
vkDestroyDescriptorSetLayout(device, descriptorSetLayouts.bloomFilter, nullptr);
vkDestroySemaphore(device, offscreen.semaphore, nullptr);
vkDestroyRenderPass(device, offscreen.renderPass, nullptr);
vkDestroyRenderPass(device, filterPass.renderPass, nullptr);
vkDestroyFramebuffer(device, offscreen.frameBuffer, nullptr);
vkDestroyFramebuffer(device, filterPass.frameBuffer, nullptr);
vkDestroySampler(device, offscreen.sampler, nullptr);
vkDestroySampler(device, filterPass.sampler, nullptr);
offscreen.depth.destroy(device);
offscreen.color[0].destroy(device);
offscreen.color[1].destroy(device);
filterPass.color[0].destroy(device);
for (auto& model : models.objects) {
model.destroy();
}
models.skybox.destroy();
uniformBuffers.matrices.destroy();
uniformBuffers.params.destroy();
textures.envmap.destroy();
}
~VulkanExample()
{
destroyTextureImage(texture);
vkDestroyPipeline(device, pipelines.solid, nullptr);
vkDestroyPipelineLayout(device, pipelineLayout, nullptr);
vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr);
uniformBufferVS.destroy();
for (auto sampler : samplers)
{
vkDestroySampler(device, sampler, nullptr);
}
vkMeshLoader::freeMeshBufferResources(device, &meshes.tunnel);
}
void destroy_vulkan_texture(vulkan_texture& texture) {
if (texture.sampler != VK_NULL_HANDLE) {
vkDestroySampler(_vulkan_device, texture.sampler, NULL);
}
if (texture.image != VK_NULL_HANDLE) {
vkDestroyImage(_vulkan_device, texture.image, NULL);
}
if (texture.view != VK_NULL_HANDLE) {
vkDestroyImageView(_vulkan_device, texture.view, NULL);
}
if (texture.device_memory != VK_NULL_HANDLE) {
vkFreeMemory(_vulkan_device, texture.device_memory, NULL);
}
}
/**
* Default destructor, frees up all Vulkan resources acquired by the text overlay
*/
~VulkanTextOverlay()
{
// Free up all Vulkan resources requested by the text overlay
vertexBuffer.destroy();
vkDestroySampler(vulkanDevice->logicalDevice, sampler, nullptr);
vkDestroyImage(vulkanDevice->logicalDevice, image, nullptr);
vkDestroyImageView(vulkanDevice->logicalDevice, view, nullptr);
vkFreeMemory(vulkanDevice->logicalDevice, imageMemory, nullptr);
vkDestroyDescriptorSetLayout(vulkanDevice->logicalDevice, descriptorSetLayout, nullptr);
vkDestroyDescriptorPool(vulkanDevice->logicalDevice, descriptorPool, nullptr);
vkDestroyPipelineLayout(vulkanDevice->logicalDevice, pipelineLayout, nullptr);
vkDestroyPipelineCache(vulkanDevice->logicalDevice, pipelineCache, nullptr);
vkDestroyPipeline(vulkanDevice->logicalDevice, pipeline, nullptr);
vkDestroyRenderPass(vulkanDevice->logicalDevice, renderPass, nullptr);
vkFreeCommandBuffers(vulkanDevice->logicalDevice, commandPool, static_cast<uint32_t>(cmdBuffers.size()), cmdBuffers.data());
vkDestroyCommandPool(vulkanDevice->logicalDevice, commandPool, nullptr);
vkDestroyFence(vulkanDevice->logicalDevice, fence, nullptr);
}
void destroy_global_resources()
{
g_null_texture.reset();
g_null_image_view.reset();
g_scratch_buffer.reset();
g_typeless_textures.clear();
g_deleted_typeless_textures.clear();
if (g_null_sampler)
vkDestroySampler(*g_current_renderer, g_null_sampler, nullptr);
g_null_sampler = nullptr;
for (const auto& p : g_compute_tasks)
{
p.second->destroy();
}
g_compute_tasks.clear();
}
void ModelLoader::CleanupModels(VkDevice device)
{
for (auto& model : mModelMap)
{
// Free vertex and index buffers
vkDestroyBuffer(device, model.second->vertices.buffer, nullptr);
vkFreeMemory(device, model.second->vertices.memory, nullptr);
vkDestroyBuffer(device, model.second->indices.buffer, nullptr);
vkFreeMemory(device, model.second->indices.memory, nullptr);
// Free the texture (NOTE: not sure if this is the right place to delete them, texture loader maybe?)
if (model.second->texture != nullptr)
{
vkDestroyImageView(device, model.second->texture->view, nullptr); // NOTE: Ugly
vkDestroyImage(device, model.second->texture->image, nullptr);
vkDestroySampler(device, model.second->texture->sampler, nullptr);
vkFreeMemory(device, model.second->texture->deviceMemory, nullptr);
}
delete model.second;
}
}
~VulkanExample()
{
// Clean up used Vulkan resources
// Note : Inherited destructor cleans up resources stored in base class
// Frame buffer
// Color attachment
vkDestroyImageView(device, offscreenPass.color.view, nullptr);
vkDestroyImage(device, offscreenPass.color.image, nullptr);
vkFreeMemory(device, offscreenPass.color.mem, nullptr);
// Depth attachment
vkDestroyImageView(device, offscreenPass.depth.view, nullptr);
vkDestroyImage(device, offscreenPass.depth.image, nullptr);
vkFreeMemory(device, offscreenPass.depth.mem, nullptr);
vkDestroyRenderPass(device, offscreenPass.renderPass, nullptr);
vkDestroySampler(device, offscreenPass.sampler, nullptr);
vkDestroyFramebuffer(device, offscreenPass.frameBuffer, nullptr);
vkDestroyPipeline(device, pipelines.radialBlur, nullptr);
vkDestroyPipeline(device, pipelines.phongPass, nullptr);
vkDestroyPipeline(device, pipelines.colorPass, nullptr);
vkDestroyPipeline(device, pipelines.offscreenDisplay, nullptr);
vkDestroyPipelineLayout(device, pipelineLayouts.radialBlur, nullptr);
vkDestroyPipelineLayout(device, pipelineLayouts.scene, nullptr);
vkDestroyDescriptorSetLayout(device, descriptorSetLayouts.scene, nullptr);
vkDestroyDescriptorSetLayout(device, descriptorSetLayouts.radialBlur, nullptr);
models.example.destroy();
uniformBuffers.scene.destroy();
uniformBuffers.blurParams.destroy();
textures.gradient.destroy();
}
~VulkanExample()
{
// Clean up used Vulkan resources
// Note : Inherited destructor cleans up resources stored in base class
// Clean up texture resources
vkDestroyImageView(device, textureArray.view, nullptr);
vkDestroyImage(device, textureArray.image, nullptr);
vkDestroySampler(device, textureArray.sampler, nullptr);
vkFreeMemory(device, textureArray.deviceMemory, nullptr);
vkDestroyPipeline(device, pipelines.solid, nullptr);
vkDestroyPipelineLayout(device, pipelineLayout, nullptr);
vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr);
vkMeshLoader::freeMeshBufferResources(device, &meshes.quad);
vkTools::destroyUniformData(device, &uniformData.vertexShader);
delete[] uboVS.instance;
}
~VulkanExample()
{
// Clean up used Vulkan resources
// Note : Inherited destructor cleans up resources stored in base class
// Clean up texture resources
vkDestroyImageView(device, cubeMap.view, nullptr);
vkDestroyImage(device, cubeMap.image, nullptr);
vkDestroySampler(device, cubeMap.sampler, nullptr);
vkFreeMemory(device, cubeMap.deviceMemory, nullptr);
vkDestroyPipeline(device, pipelines.skybox, nullptr);
vkDestroyPipeline(device, pipelines.reflect, nullptr);
vkDestroyPipelineLayout(device, pipelineLayout, nullptr);
vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr);
vkMeshLoader::freeMeshBufferResources(device, &meshes.object);
vkMeshLoader::freeMeshBufferResources(device, &meshes.skybox);
vkTools::destroyUniformData(device, &uniformData.objectVS);
vkTools::destroyUniformData(device, &uniformData.skyboxVS);
}
void BaseImage::ValidateContent(RandomNumberGenerator& rand)
{
/*
dstBuf has following layout:
For each of texels to be sampled, [0..valueCount):
struct {
in uint32_t pixelX;
in uint32_t pixelY;
out uint32_t pixelColor;
}
*/
const uint32_t valueCount = 128;
VkBufferCreateInfo dstBufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
dstBufCreateInfo.usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
dstBufCreateInfo.size = valueCount * sizeof(uint32_t) * 3;
VmaAllocationCreateInfo dstBufAllocCreateInfo = {};
dstBufAllocCreateInfo.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT;
dstBufAllocCreateInfo.usage = VMA_MEMORY_USAGE_GPU_TO_CPU;
VkBuffer dstBuf = nullptr;
VmaAllocation dstBufAlloc = nullptr;
VmaAllocationInfo dstBufAllocInfo = {};
TEST( vmaCreateBuffer(g_hAllocator, &dstBufCreateInfo, &dstBufAllocCreateInfo, &dstBuf, &dstBufAlloc, &dstBufAllocInfo) == VK_SUCCESS );
// Fill dstBuf input data.
{
uint32_t* dstBufContent = (uint32_t*)dstBufAllocInfo.pMappedData;
for(uint32_t i = 0; i < valueCount; ++i)
{
const uint32_t x = rand.Generate() % m_CreateInfo.extent.width;
const uint32_t y = rand.Generate() % m_CreateInfo.extent.height;
dstBufContent[i * 3 ] = x;
dstBufContent[i * 3 + 1] = y;
dstBufContent[i * 3 + 2] = 0;
}
}
VkSamplerCreateInfo samplerCreateInfo = { VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO };
samplerCreateInfo.magFilter = VK_FILTER_NEAREST;
samplerCreateInfo.minFilter = VK_FILTER_NEAREST;
samplerCreateInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
samplerCreateInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
samplerCreateInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
samplerCreateInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
samplerCreateInfo.unnormalizedCoordinates = VK_TRUE;
VkSampler sampler = nullptr;
TEST( vkCreateSampler( g_hDevice, &samplerCreateInfo, nullptr, &sampler) == VK_SUCCESS );
VkDescriptorSetLayoutBinding bindings[2] = {};
bindings[0].binding = 0;
bindings[0].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
bindings[0].descriptorCount = 1;
bindings[0].stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
bindings[0].pImmutableSamplers = &sampler;
bindings[1].binding = 1;
bindings[1].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
bindings[1].descriptorCount = 1;
bindings[1].stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
VkDescriptorSetLayoutCreateInfo descSetLayoutCreateInfo = { VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO };
descSetLayoutCreateInfo.bindingCount = 2;
descSetLayoutCreateInfo.pBindings = bindings;
VkDescriptorSetLayout descSetLayout = nullptr;
TEST( vkCreateDescriptorSetLayout(g_hDevice, &descSetLayoutCreateInfo, nullptr, &descSetLayout) == VK_SUCCESS );
VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = { VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO };
pipelineLayoutCreateInfo.setLayoutCount = 1;
pipelineLayoutCreateInfo.pSetLayouts = &descSetLayout;
VkPipelineLayout pipelineLayout = nullptr;
TEST( vkCreatePipelineLayout(g_hDevice, &pipelineLayoutCreateInfo, nullptr, &pipelineLayout) == VK_SUCCESS );
std::vector<char> shaderCode;
LoadShader(shaderCode, "SparseBindingTest.comp.spv");
VkShaderModuleCreateInfo shaderModuleCreateInfo = { VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO };
shaderModuleCreateInfo.codeSize = shaderCode.size();
shaderModuleCreateInfo.pCode = (const uint32_t*)shaderCode.data();
VkShaderModule shaderModule = nullptr;
TEST( vkCreateShaderModule(g_hDevice, &shaderModuleCreateInfo, nullptr, &shaderModule) == VK_SUCCESS );
VkComputePipelineCreateInfo pipelineCreateInfo = { VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO };
pipelineCreateInfo.stage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
pipelineCreateInfo.stage.stage = VK_SHADER_STAGE_COMPUTE_BIT;
pipelineCreateInfo.stage.module = shaderModule;
pipelineCreateInfo.stage.pName = "main";
pipelineCreateInfo.layout = pipelineLayout;
VkPipeline pipeline = nullptr;
TEST( vkCreateComputePipelines(g_hDevice, nullptr, 1, &pipelineCreateInfo, nullptr, &pipeline) == VK_SUCCESS );
VkDescriptorPoolSize poolSizes[2] = {};
poolSizes[0].type = bindings[0].descriptorType;
poolSizes[0].descriptorCount = bindings[0].descriptorCount;
poolSizes[1].type = bindings[1].descriptorType;
poolSizes[1].descriptorCount = bindings[1].descriptorCount;
VkDescriptorPoolCreateInfo descPoolCreateInfo = { VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO };
descPoolCreateInfo.maxSets = 1;
descPoolCreateInfo.poolSizeCount = 2;
descPoolCreateInfo.pPoolSizes = poolSizes;
VkDescriptorPool descPool = nullptr;
TEST( vkCreateDescriptorPool(g_hDevice, &descPoolCreateInfo, nullptr, &descPool) == VK_SUCCESS );
VkDescriptorSetAllocateInfo descSetAllocInfo = { VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO };
descSetAllocInfo.descriptorPool = descPool;
descSetAllocInfo.descriptorSetCount = 1;
descSetAllocInfo.pSetLayouts = &descSetLayout;
VkDescriptorSet descSet = nullptr;
TEST( vkAllocateDescriptorSets(g_hDevice, &descSetAllocInfo, &descSet) == VK_SUCCESS );
VkImageViewCreateInfo imageViewCreateInfo = { VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
imageViewCreateInfo.image = m_Image;
imageViewCreateInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
imageViewCreateInfo.format = m_CreateInfo.format;
imageViewCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
imageViewCreateInfo.subresourceRange.layerCount = 1;
imageViewCreateInfo.subresourceRange.levelCount = 1;
VkImageView imageView = nullptr;
TEST( vkCreateImageView(g_hDevice, &imageViewCreateInfo, nullptr, &imageView) == VK_SUCCESS );
VkDescriptorImageInfo descImageInfo = {};
descImageInfo.imageView = imageView;
descImageInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
VkDescriptorBufferInfo descBufferInfo = {};
descBufferInfo.buffer = dstBuf;
descBufferInfo.offset = 0;
descBufferInfo.range = VK_WHOLE_SIZE;
VkWriteDescriptorSet descWrites[2] = {};
descWrites[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
descWrites[0].dstSet = descSet;
descWrites[0].dstBinding = bindings[0].binding;
descWrites[0].dstArrayElement = 0;
descWrites[0].descriptorCount = 1;
descWrites[0].descriptorType = bindings[0].descriptorType;
descWrites[0].pImageInfo = &descImageInfo;
descWrites[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
descWrites[1].dstSet = descSet;
descWrites[1].dstBinding = bindings[1].binding;
descWrites[1].dstArrayElement = 0;
descWrites[1].descriptorCount = 1;
descWrites[1].descriptorType = bindings[1].descriptorType;
descWrites[1].pBufferInfo = &descBufferInfo;
vkUpdateDescriptorSets(g_hDevice, 2, descWrites, 0, nullptr);
BeginSingleTimeCommands();
vkCmdBindPipeline(g_hTemporaryCommandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, pipeline);
vkCmdBindDescriptorSets(g_hTemporaryCommandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, pipelineLayout, 0, 1, &descSet, 0, nullptr);
vkCmdDispatch(g_hTemporaryCommandBuffer, valueCount, 1, 1);
EndSingleTimeCommands();
// Validate dstBuf output data.
{
const uint32_t* dstBufContent = (const uint32_t*)dstBufAllocInfo.pMappedData;
for(uint32_t i = 0; i < valueCount; ++i)
{
const uint32_t x = dstBufContent[i * 3 ];
const uint32_t y = dstBufContent[i * 3 + 1];
const uint32_t color = dstBufContent[i * 3 + 2];
const uint8_t a = (uint8_t)(color >> 24);
const uint8_t b = (uint8_t)(color >> 16);
const uint8_t g = (uint8_t)(color >> 8);
const uint8_t r = (uint8_t)color;
TEST(r == (uint8_t)x && g == (uint8_t)y && b == 13 && a == 25);
}
}
vkDestroyImageView(g_hDevice, imageView, nullptr);
vkDestroyDescriptorPool(g_hDevice, descPool, nullptr);
vmaDestroyBuffer(g_hAllocator, dstBuf, dstBufAlloc);
vkDestroyPipeline(g_hDevice, pipeline, nullptr);
vkDestroyShaderModule(g_hDevice, shaderModule, nullptr);
vkDestroyPipelineLayout(g_hDevice, pipelineLayout, nullptr);
vkDestroyDescriptorSetLayout(g_hDevice, descSetLayout, nullptr);
vkDestroySampler(g_hDevice, sampler, nullptr);
}
void loadAssets()
{
models.skysphere.loadFromFile(getAssetPath() + "models/geosphere.obj", vertexLayout, 1.0f, vulkanDevice, queue);
// Textures
std::string texFormatSuffix;
VkFormat texFormat;
// Get supported compressed texture format
if (vulkanDevice->features.textureCompressionBC) {
texFormatSuffix = "_bc3_unorm";
texFormat = VK_FORMAT_BC3_UNORM_BLOCK;
}
else if (vulkanDevice->features.textureCompressionASTC_LDR) {
texFormatSuffix = "_astc_8x8_unorm";
texFormat = VK_FORMAT_ASTC_8x8_UNORM_BLOCK;
}
else if (vulkanDevice->features.textureCompressionETC2) {
texFormatSuffix = "_etc2_unorm";
texFormat = VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK;
}
else {
vks::tools::exitFatal("Device does not support any compressed texture format!", VK_ERROR_FEATURE_NOT_PRESENT);
}
textures.skySphere.loadFromFile(getAssetPath() + "textures/skysphere" + texFormatSuffix + ".ktx", texFormat, vulkanDevice, queue);
// Terrain textures are stored in a texture array with layers corresponding to terrain height
textures.terrainArray.loadFromFile(getAssetPath() + "textures/terrain_texturearray" + texFormatSuffix + ".ktx", texFormat, vulkanDevice, queue);
// Height data is stored in a one-channel texture
textures.heightMap.loadFromFile(getAssetPath() + "textures/terrain_heightmap_r16.ktx", VK_FORMAT_R16_UNORM, vulkanDevice, queue);
VkSamplerCreateInfo samplerInfo = vks::initializers::samplerCreateInfo();
// Setup a mirroring sampler for the height map
vkDestroySampler(device, textures.heightMap.sampler, nullptr);
samplerInfo.magFilter = VK_FILTER_LINEAR;
samplerInfo.minFilter = VK_FILTER_LINEAR;
samplerInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT;
samplerInfo.addressModeV = samplerInfo.addressModeU;
samplerInfo.addressModeW = samplerInfo.addressModeU;
samplerInfo.compareOp = VK_COMPARE_OP_NEVER;
samplerInfo.minLod = 0.0f;
samplerInfo.maxLod = (float)textures.heightMap.mipLevels;
samplerInfo.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
VK_CHECK_RESULT(vkCreateSampler(device, &samplerInfo, nullptr, &textures.heightMap.sampler));
textures.heightMap.descriptor.sampler = textures.heightMap.sampler;
// Setup a repeating sampler for the terrain texture layers
vkDestroySampler(device, textures.terrainArray.sampler, nullptr);
samplerInfo = vks::initializers::samplerCreateInfo();
samplerInfo.magFilter = VK_FILTER_LINEAR;
samplerInfo.minFilter = VK_FILTER_LINEAR;
samplerInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT;
samplerInfo.addressModeV = samplerInfo.addressModeU;
samplerInfo.addressModeW = samplerInfo.addressModeU;
samplerInfo.compareOp = VK_COMPARE_OP_NEVER;
samplerInfo.minLod = 0.0f;
samplerInfo.maxLod = (float)textures.terrainArray.mipLevels;
samplerInfo.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
if (deviceFeatures.samplerAnisotropy)
{
samplerInfo.maxAnisotropy = 4.0f;
samplerInfo.anisotropyEnable = VK_TRUE;
}
VK_CHECK_RESULT(vkCreateSampler(device, &samplerInfo, nullptr, &textures.terrainArray.sampler));
textures.terrainArray.descriptor.sampler = textures.terrainArray.sampler;
}
void VulkanDeleteList::PerformDeletes(VkDevice device) {
for (auto &cmdPool : cmdPools_) {
vkDestroyCommandPool(device, cmdPool, nullptr);
}
cmdPools_.clear();
for (auto &descPool : descPools_) {
vkDestroyDescriptorPool(device, descPool, nullptr);
}
descPools_.clear();
for (auto &module : modules_) {
vkDestroyShaderModule(device, module, nullptr);
}
modules_.clear();
for (auto &buf : buffers_) {
vkDestroyBuffer(device, buf, nullptr);
}
buffers_.clear();
for (auto &bufView : bufferViews_) {
vkDestroyBufferView(device, bufView, nullptr);
}
bufferViews_.clear();
for (auto &image : images_) {
vkDestroyImage(device, image, nullptr);
}
images_.clear();
for (auto &imageView : imageViews_) {
vkDestroyImageView(device, imageView, nullptr);
}
imageViews_.clear();
for (auto &mem : deviceMemory_) {
vkFreeMemory(device, mem, nullptr);
}
deviceMemory_.clear();
for (auto &sampler : samplers_) {
vkDestroySampler(device, sampler, nullptr);
}
samplers_.clear();
for (auto &pipeline : pipelines_) {
vkDestroyPipeline(device, pipeline, nullptr);
}
pipelines_.clear();
for (auto &pcache : pipelineCaches_) {
vkDestroyPipelineCache(device, pcache, nullptr);
}
pipelineCaches_.clear();
for (auto &renderPass : renderPasses_) {
vkDestroyRenderPass(device, renderPass, nullptr);
}
renderPasses_.clear();
for (auto &framebuffer : framebuffers_) {
vkDestroyFramebuffer(device, framebuffer, nullptr);
}
framebuffers_.clear();
for (auto &pipeLayout : pipelineLayouts_) {
vkDestroyPipelineLayout(device, pipeLayout, nullptr);
}
pipelineLayouts_.clear();
for (auto &descSetLayout : descSetLayouts_) {
vkDestroyDescriptorSetLayout(device, descSetLayout, nullptr);
}
descSetLayouts_.clear();
for (auto &callback : callbacks_) {
callback.func(callback.userdata);
}
callbacks_.clear();
}
int sample_main(int argc, char *argv[]) {
VkResult U_ASSERT_ONLY res;
struct sample_info info = {};
char sample_title[] = "Separate Image Sampler";
const bool depthPresent = true;
process_command_line_args(info, argc, argv);
init_global_layer_properties(info);
init_instance_extension_names(info);
init_device_extension_names(info);
init_instance(info, sample_title);
init_enumerate_device(info);
init_window_size(info, 500, 500);
init_connection(info);
init_window(info);
init_swapchain_extension(info);
init_device(info);
init_command_pool(info);
init_command_buffer(info);
execute_begin_command_buffer(info);
init_device_queue(info);
init_swap_chain(info);
init_depth_buffer(info);
init_uniform_buffer(info);
init_renderpass(info, depthPresent);
init_shaders(info, vertShaderText, fragShaderText);
init_framebuffers(info, depthPresent);
init_vertex_buffer(info, g_vb_texture_Data, sizeof(g_vb_texture_Data), sizeof(g_vb_texture_Data[0]), true);
/* VULKAN_KEY_START */
// Sample from a green texture to easily see that we've pulled correct texel
// value
// Create our separate image
struct texture_object texObj;
const char *textureName = "green.ppm";
init_image(info, texObj, textureName);
info.textures.push_back(texObj);
info.texture_data.image_info.sampler = 0;
info.texture_data.image_info.imageView = info.textures[0].view;
info.texture_data.image_info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
// Create our separate sampler
VkSampler separateSampler = {};
init_sampler(info, separateSampler);
VkDescriptorImageInfo samplerInfo = {};
samplerInfo.sampler = separateSampler;
// Set up one descriptor set
static const unsigned descriptor_set_count = 1;
static const unsigned resource_count = 3;
static const unsigned resource_type_count = 3;
// Create binding and layout for the following, matching contents of shader
// binding 0 = uniform buffer (MVP)
// binding 1 = texture2D
// binding 2 = sampler
VkDescriptorSetLayoutBinding resource_binding[resource_count] = {};
resource_binding[0].binding = 0;
resource_binding[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
resource_binding[0].descriptorCount = 1;
resource_binding[0].stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
resource_binding[0].pImmutableSamplers = NULL;
resource_binding[1].binding = 1;
resource_binding[1].descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
resource_binding[1].descriptorCount = 1;
resource_binding[1].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
resource_binding[1].pImmutableSamplers = NULL;
resource_binding[2].binding = 2;
resource_binding[2].descriptorType = VK_DESCRIPTOR_TYPE_SAMPLER;
resource_binding[2].descriptorCount = 1;
resource_binding[2].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
resource_binding[2].pImmutableSamplers = NULL;
VkDescriptorSetLayoutCreateInfo resource_layout_info[1] = {};
resource_layout_info[0].sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
resource_layout_info[0].pNext = NULL;
resource_layout_info[0].bindingCount = resource_count;
resource_layout_info[0].pBindings = resource_binding;
VkDescriptorSetLayout descriptor_layouts[1] = {};
res = vkCreateDescriptorSetLayout(info.device, resource_layout_info, NULL, &descriptor_layouts[0]);
assert(res == VK_SUCCESS);
// Create pipeline layout
VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo[1] = {};
pipelineLayoutCreateInfo[0].sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
pipelineLayoutCreateInfo[0].pNext = NULL;
pipelineLayoutCreateInfo[0].pushConstantRangeCount = 0;
pipelineLayoutCreateInfo[0].pPushConstantRanges = NULL;
pipelineLayoutCreateInfo[0].setLayoutCount = descriptor_set_count;
pipelineLayoutCreateInfo[0].pSetLayouts = descriptor_layouts;
res = vkCreatePipelineLayout(info.device, pipelineLayoutCreateInfo, NULL, &info.pipeline_layout);
assert(res == VK_SUCCESS);
// Create a single pool to contain data for our descriptor set
VkDescriptorPoolSize pool_sizes[resource_type_count] = {};
pool_sizes[0].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
pool_sizes[0].descriptorCount = 1;
pool_sizes[1].type = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
pool_sizes[1].descriptorCount = 1;
pool_sizes[2].type = VK_DESCRIPTOR_TYPE_SAMPLER;
pool_sizes[2].descriptorCount = 1;
VkDescriptorPoolCreateInfo pool_info[1] = {};
pool_info[0].sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
pool_info[0].pNext = NULL;
pool_info[0].maxSets = descriptor_set_count;
pool_info[0].poolSizeCount = resource_type_count;
pool_info[0].pPoolSizes = pool_sizes;
VkDescriptorPool descriptor_pool[1] = {};
res = vkCreateDescriptorPool(info.device, pool_info, NULL, descriptor_pool);
assert(res == VK_SUCCESS);
VkDescriptorSetAllocateInfo alloc_info[1];
alloc_info[0].sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
alloc_info[0].pNext = NULL;
alloc_info[0].descriptorPool = descriptor_pool[0];
alloc_info[0].descriptorSetCount = descriptor_set_count;
alloc_info[0].pSetLayouts = descriptor_layouts;
// Populate descriptor sets
VkDescriptorSet descriptor_sets[descriptor_set_count] = {};
res = vkAllocateDescriptorSets(info.device, alloc_info, descriptor_sets);
assert(res == VK_SUCCESS);
VkWriteDescriptorSet descriptor_writes[resource_count];
// Populate with info about our uniform buffer for MVP
descriptor_writes[0] = {};
descriptor_writes[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
descriptor_writes[0].pNext = NULL;
descriptor_writes[0].dstSet = descriptor_sets[0];
descriptor_writes[0].descriptorCount = 1;
descriptor_writes[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
descriptor_writes[0].pBufferInfo = &info.uniform_data.buffer_info; // populated by init_uniform_buffer()
descriptor_writes[0].dstArrayElement = 0;
descriptor_writes[0].dstBinding = 0;
// Populate with info about our image
descriptor_writes[1] = {};
descriptor_writes[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
descriptor_writes[1].pNext = NULL;
descriptor_writes[1].dstSet = descriptor_sets[0];
descriptor_writes[1].descriptorCount = 1;
descriptor_writes[1].descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
descriptor_writes[1].pImageInfo = &info.texture_data.image_info; // populated by init_texture()
descriptor_writes[1].dstArrayElement = 0;
descriptor_writes[1].dstBinding = 1;
// Populate with info about our sampler
descriptor_writes[2] = {};
descriptor_writes[2].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
descriptor_writes[2].pNext = NULL;
descriptor_writes[2].dstSet = descriptor_sets[0];
descriptor_writes[2].descriptorCount = 1;
descriptor_writes[2].descriptorType = VK_DESCRIPTOR_TYPE_SAMPLER;
descriptor_writes[2].pImageInfo = &samplerInfo;
descriptor_writes[2].dstArrayElement = 0;
descriptor_writes[2].dstBinding = 2;
vkUpdateDescriptorSets(info.device, resource_count, descriptor_writes, 0, NULL);
/* VULKAN_KEY_END */
init_pipeline_cache(info);
init_pipeline(info, depthPresent);
init_presentable_image(info);
VkClearValue clear_values[2];
init_clear_color_and_depth(info, clear_values);
VkRenderPassBeginInfo rp_begin;
init_render_pass_begin_info(info, rp_begin);
rp_begin.clearValueCount = 2;
rp_begin.pClearValues = clear_values;
vkCmdBeginRenderPass(info.cmd, &rp_begin, VK_SUBPASS_CONTENTS_INLINE);
vkCmdBindPipeline(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, info.pipeline);
vkCmdBindDescriptorSets(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, info.pipeline_layout, 0, NUM_DESCRIPTOR_SETS,
descriptor_sets, 0, NULL);
const VkDeviceSize offsets[1] = {0};
vkCmdBindVertexBuffers(info.cmd, 0, 1, &info.vertex_buffer.buf, offsets);
init_viewports(info);
init_scissors(info);
vkCmdDraw(info.cmd, 12 * 3, 1, 0, 0);
vkCmdEndRenderPass(info.cmd);
res = vkEndCommandBuffer(info.cmd);
assert(res == VK_SUCCESS);
VkFence drawFence = {};
init_fence(info, drawFence);
VkPipelineStageFlags pipe_stage_flags = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
VkSubmitInfo submit_info = {};
init_submit_info(info, submit_info, pipe_stage_flags);
/* Queue the command buffer for execution */
res = vkQueueSubmit(info.graphics_queue, 1, &submit_info, drawFence);
assert(res == VK_SUCCESS);
/* Now present the image in the window */
VkPresentInfoKHR present = {};
init_present_info(info, present);
/* Make sure command buffer is finished before presenting */
do {
res = vkWaitForFences(info.device, 1, &drawFence, VK_TRUE, FENCE_TIMEOUT);
} while (res == VK_TIMEOUT);
assert(res == VK_SUCCESS);
res = vkQueuePresentKHR(info.present_queue, &present);
assert(res == VK_SUCCESS);
wait_seconds(1);
if (info.save_images) write_ppm(info, "separate_image_sampler");
vkDestroyFence(info.device, drawFence, NULL);
vkDestroySemaphore(info.device, info.imageAcquiredSemaphore, NULL);
destroy_pipeline(info);
destroy_pipeline_cache(info);
vkDestroySampler(info.device, separateSampler, NULL);
vkDestroyImageView(info.device, info.textures[0].view, NULL);
vkDestroyImage(info.device, info.textures[0].image, NULL);
vkFreeMemory(info.device, info.textures[0].mem, NULL);
// instead of destroy_descriptor_pool(info);
vkDestroyDescriptorPool(info.device, descriptor_pool[0], NULL);
destroy_vertex_buffer(info);
destroy_framebuffers(info);
destroy_shaders(info);
destroy_renderpass(info);
// instead of destroy_descriptor_and_pipeline_layouts(info);
for (int i = 0; i < descriptor_set_count; i++) vkDestroyDescriptorSetLayout(info.device, descriptor_layouts[i], NULL);
vkDestroyPipelineLayout(info.device, info.pipeline_layout, NULL);
destroy_uniform_buffer(info);
destroy_depth_buffer(info);
destroy_swap_chain(info);
destroy_command_buffer(info);
destroy_command_pool(info);
destroy_device(info);
destroy_window(info);
destroy_instance(info);
return 0;
}
int sample_main(int argc, char *argv[]) {
VkResult U_ASSERT_ONLY res;
bool U_ASSERT_ONLY pass;
struct sample_info info = {};
char sample_title[] = "Texture Initialization Sample";
init_global_layer_properties(info);
init_instance_extension_names(info);
init_device_extension_names(info);
init_instance(info, sample_title);
init_enumerate_device(info);
init_connection(info);
init_window_size(info, 50, 50);
init_window(info);
init_swapchain_extension(info);
init_device(info);
init_command_pool(info);
init_command_buffer(info);
execute_begin_command_buffer(info);
init_device_queue(info);
/* VULKAN_KEY_START */
/*
* Set up textures:
* - Create a linear tiled image
* - Map it and write the texture data into it
* - If linear images cannot be used as textures, create an optimally
* tiled image and blit from the linearly tiled image to the optimally
* tiled image
* -
* -
* -
*/
struct texture_object texObj;
std::string filename = get_base_data_dir();
filename.append("lunarg.ppm");
if (!read_ppm(filename.c_str(), texObj.tex_width, texObj.tex_height, 0,
NULL)) {
std::cout << "Could not read texture file lunarg.ppm\n";
exit(-1);
}
VkFormatProperties formatProps;
vkGetPhysicalDeviceFormatProperties(info.gpus[0], VK_FORMAT_R8G8B8A8_UNORM,
&formatProps);
/* See if we can use a linear tiled image for a texture, if not, we will
* need a staging image for the texture data */
bool needStaging = (!(formatProps.linearTilingFeatures &
VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT))
? true
: false;
VkImageCreateInfo image_create_info = {};
image_create_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
image_create_info.pNext = NULL;
image_create_info.imageType = VK_IMAGE_TYPE_2D;
image_create_info.format = VK_FORMAT_R8G8B8A8_UNORM;
image_create_info.extent.width = texObj.tex_width;
image_create_info.extent.height = texObj.tex_height;
image_create_info.extent.depth = 1;
image_create_info.mipLevels = 1;
image_create_info.arrayLayers = 1;
image_create_info.samples = NUM_SAMPLES;
image_create_info.tiling = VK_IMAGE_TILING_LINEAR;
image_create_info.initialLayout = VK_IMAGE_LAYOUT_PREINITIALIZED;
image_create_info.usage = needStaging ? VK_IMAGE_USAGE_TRANSFER_SRC_BIT
: VK_IMAGE_USAGE_SAMPLED_BIT;
image_create_info.queueFamilyIndexCount = 0;
image_create_info.pQueueFamilyIndices = NULL;
image_create_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
image_create_info.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;
VkImage mappableImage;
VkDeviceMemory mappableMemory;
VkMemoryRequirements mem_reqs;
/* Create a mappable image. It will be the texture if linear images are ok
* to be textures or it will be the staging image if they are not.
*/
res = vkCreateImage(info.device, &image_create_info, NULL, &mappableImage);
assert(res == VK_SUCCESS);
vkGetImageMemoryRequirements(info.device, mappableImage, &mem_reqs);
mem_alloc.allocationSize = mem_reqs.size;
/* Find the memory type that is host mappable */
pass = memory_type_from_properties(info, mem_reqs.memoryTypeBits,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
&mem_alloc.memoryTypeIndex);
assert(pass);
/* allocate memory */
res = vkAllocateMemory(info.device, &mem_alloc, NULL, &(mappableMemory));
assert(res == VK_SUCCESS);
/* bind memory */
res = vkBindImageMemory(info.device, mappableImage, mappableMemory, 0);
assert(res == VK_SUCCESS);
VkImageSubresource subres = {};
subres.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
subres.mipLevel = 0;
subres.arrayLayer = 0;
VkSubresourceLayout layout;
void *data;
/* Get the subresource layout so we know what the row pitch is */
vkGetImageSubresourceLayout(info.device, mappableImage, &subres, &layout);
res = vkMapMemory(info.device, mappableMemory, 0, mem_reqs.size, 0, &data);
assert(res == VK_SUCCESS);
/* Read the ppm file into the mappable image's memory */
if (!read_ppm(filename.c_str(), texObj.tex_width, texObj.tex_height,
layout.rowPitch, (unsigned char *)data)) {
std::cout << "Could not load texture file lunarg.ppm\n";
exit(-1);
}
vkUnmapMemory(info.device, mappableMemory);
if (!needStaging) {
/* If we can use the linear tiled image as a texture, just do it */
texObj.image = mappableImage;
texObj.mem = mappableMemory;
texObj.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
set_image_layout(info, texObj.image, VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_PREINITIALIZED, texObj.imageLayout);
} else {
/* The mappable image cannot be our texture, so create an optimally
* tiled image and blit to it */
image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL;
image_create_info.usage =
VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
image_create_info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
res =
vkCreateImage(info.device, &image_create_info, NULL, &texObj.image);
assert(res == VK_SUCCESS);
vkGetImageMemoryRequirements(info.device, texObj.image, &mem_reqs);
mem_alloc.allocationSize = mem_reqs.size;
/* Find memory type - don't specify any mapping requirements */
pass = memory_type_from_properties(info, mem_reqs.memoryTypeBits, 0,
&mem_alloc.memoryTypeIndex);
assert(pass);
/* allocate memory */
res = vkAllocateMemory(info.device, &mem_alloc, NULL, &texObj.mem);
assert(res == VK_SUCCESS);
/* bind memory */
res = vkBindImageMemory(info.device, texObj.image, texObj.mem, 0);
assert(res == VK_SUCCESS);
/* Since we're going to blit from the mappable image, set its layout to
* SOURCE_OPTIMAL */
/* Side effect is that this will create info.cmd */
set_image_layout(info, mappableImage, VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_PREINITIALIZED,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
/* Since we're going to blit to the texture image, set its layout to
* DESTINATION_OPTIMAL */
set_image_layout(info, texObj.image, VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_UNDEFINED,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
VkImageCopy copy_region;
copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
copy_region.srcSubresource.mipLevel = 0;
copy_region.srcSubresource.baseArrayLayer = 0;
copy_region.srcSubresource.layerCount = 1;
copy_region.srcOffset.x = 0;
copy_region.srcOffset.y = 0;
copy_region.srcOffset.z = 0;
copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
copy_region.dstSubresource.mipLevel = 0;
copy_region.dstSubresource.baseArrayLayer = 0;
copy_region.dstSubresource.layerCount = 1;
copy_region.dstOffset.x = 0;
copy_region.dstOffset.y = 0;
copy_region.dstOffset.z = 0;
copy_region.extent.width = texObj.tex_width;
copy_region.extent.height = texObj.tex_height;
copy_region.extent.depth = 1;
/* Put the copy command into the command buffer */
vkCmdCopyImage(info.cmd, mappableImage,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, texObj.image,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ©_region);
/* Set the layout for the texture image from DESTINATION_OPTIMAL to
* SHADER_READ_ONLY */
texObj.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
set_image_layout(info, texObj.image, VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
texObj.imageLayout);
}
execute_end_command_buffer(info);
execute_queue_command_buffer(info);
VkSamplerCreateInfo samplerCreateInfo = {};
samplerCreateInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
samplerCreateInfo.magFilter = VK_FILTER_NEAREST;
samplerCreateInfo.minFilter = VK_FILTER_NEAREST;
samplerCreateInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
samplerCreateInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
samplerCreateInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
samplerCreateInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
samplerCreateInfo.mipLodBias = 0.0;
samplerCreateInfo.anisotropyEnable = VK_FALSE,
samplerCreateInfo.maxAnisotropy = 0;
samplerCreateInfo.compareEnable = VK_FALSE;
samplerCreateInfo.compareOp = VK_COMPARE_OP_NEVER;
samplerCreateInfo.minLod = 0.0;
samplerCreateInfo.maxLod = 0.0;
samplerCreateInfo.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
/* create sampler */
res =
vkCreateSampler(info.device, &samplerCreateInfo, NULL, &texObj.sampler);
assert(res == VK_SUCCESS);
VkImageViewCreateInfo view_info = {};
view_info.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
view_info.pNext = NULL;
view_info.image = VK_NULL_HANDLE;
view_info.viewType = VK_IMAGE_VIEW_TYPE_2D;
view_info.format = VK_FORMAT_R8G8B8A8_UNORM;
view_info.components.r = VK_COMPONENT_SWIZZLE_R;
view_info.components.g = VK_COMPONENT_SWIZZLE_G;
view_info.components.b = VK_COMPONENT_SWIZZLE_B;
view_info.components.a = VK_COMPONENT_SWIZZLE_A;
view_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
view_info.subresourceRange.baseMipLevel = 0;
view_info.subresourceRange.levelCount = 1;
view_info.subresourceRange.baseArrayLayer = 0;
view_info.subresourceRange.layerCount = 1;
/* create image view */
view_info.image = texObj.image;
res = vkCreateImageView(info.device, &view_info, NULL, &texObj.view);
assert(res == VK_SUCCESS);
info.textures.push_back(texObj);
/* VULKAN_KEY_END */
/* Clean Up */
vkDestroySampler(info.device, texObj.sampler, NULL);
vkDestroyImageView(info.device, texObj.view, NULL);
vkDestroyImage(info.device, texObj.image, NULL);
vkFreeMemory(info.device, texObj.mem, NULL);
if (needStaging) {
/* Release the resources for the staging image */
vkFreeMemory(info.device, mappableMemory, NULL);
vkDestroyImage(info.device, mappableImage, NULL);
}
destroy_command_buffer(info);
destroy_command_pool(info);
destroy_device(info);
destroy_window(info);
destroy_instance(info);
return 0;
}
