claude_code/procedural-3d-engine
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Textureloader : Use fences instead of queue wait idle for command buffer submissions, replaced asserts with checkResult from vkTools namespace

Browse source
This commit is contained in:
saschawillems 2016-03-19 16:30:39 +01:00
parent 51e840416d
commit 403e6f33cb
2 changed files with 71 additions and 118 deletions
Download patch file Download diff file Expand all files Collapse all files

187
base/vulkanTextureLoader.hpp
View file

@ -74,8 +74,6 @@ namespace vkTools
texture->height = (uint32_t)tex2D[0].dimensions().y; texture->height = (uint32_t)tex2D[0].dimensions().y;
texture->mipLevels = tex2D.levels(); texture->mipLevels = tex2D.levels();
VkResult err;
// Get device properites for the requested texture format // Get device properites for the requested texture format
VkFormatProperties formatProperties; VkFormatProperties formatProperties;
vkGetPhysicalDeviceFormatProperties(physicalDevice, format, &formatProperties); vkGetPhysicalDeviceFormatProperties(physicalDevice, format, &formatProperties);
@ -104,8 +102,7 @@ namespace vkTools
// Use a separate command buffer for texture loading // Use a separate command buffer for texture loading
VkCommandBufferBeginInfo cmdBufInfo = vkTools::initializers::commandBufferBeginInfo(); VkCommandBufferBeginInfo cmdBufInfo = vkTools::initializers::commandBufferBeginInfo();
err = vkBeginCommandBuffer(cmdBuffer, &cmdBufInfo); vkTools::checkResult(vkBeginCommandBuffer(cmdBuffer, &cmdBufInfo));
assert(!err);
if (useStaging) if (useStaging)
{ {
@ -125,16 +122,13 @@ namespace vkTools
imageCreateInfo.extent.height = tex2D[level].dimensions().y; imageCreateInfo.extent.height = tex2D[level].dimensions().y;
imageCreateInfo.extent.depth = 1; imageCreateInfo.extent.depth = 1;
err = vkCreateImage(device, &imageCreateInfo, nullptr, &mipLevels[level].image); vkTools::checkResult(vkCreateImage(device, &imageCreateInfo, nullptr, &mipLevels[level].image));
assert(!err);
vkGetImageMemoryRequirements(device, mipLevels[level].image, &memReqs); vkGetImageMemoryRequirements(device, mipLevels[level].image, &memReqs);
memAllocInfo.allocationSize = memReqs.size; memAllocInfo.allocationSize = memReqs.size;
getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, &memAllocInfo.memoryTypeIndex); getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, &memAllocInfo.memoryTypeIndex);
err = vkAllocateMemory(device, &memAllocInfo, nullptr, &mipLevels[level].memory); vkTools::checkResult(vkAllocateMemory(device, &memAllocInfo, nullptr, &mipLevels[level].memory));
assert(!err); vkTools::checkResult(vkBindImageMemory(device, mipLevels[level].image, mipLevels[level].memory, 0));
err = vkBindImageMemory(device, mipLevels[level].image, mipLevels[level].memory, 0);
assert(!err);
VkImageSubresource subRes = {}; VkImageSubresource subRes = {};
subRes.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; subRes.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
@ -143,9 +137,7 @@ namespace vkTools
void *data; void *data;
vkGetImageSubresourceLayout(device, mipLevels[level].image, &subRes, &subResLayout); vkGetImageSubresourceLayout(device, mipLevels[level].image, &subRes, &subResLayout);
assert(!err); vkTools::checkResult(vkMapMemory(device, mipLevels[level].memory, 0, memReqs.size, 0, &data));
err = vkMapMemory(device, mipLevels[level].memory, 0, memReqs.size, 0, &data);
assert(!err);
memcpy(data, tex2D[level].data(), tex2D[level].size()); memcpy(data, tex2D[level].data(), tex2D[level].size());
vkUnmapMemory(device, mipLevels[level].memory); vkUnmapMemory(device, mipLevels[level].memory);
@ -165,18 +157,15 @@ namespace vkTools
imageCreateInfo.mipLevels = texture->mipLevels; imageCreateInfo.mipLevels = texture->mipLevels;
imageCreateInfo.extent = { texture->width, texture->height, 1 }; imageCreateInfo.extent = { texture->width, texture->height, 1 };
err = vkCreateImage(device, &imageCreateInfo, nullptr, &texture->image); vkTools::checkResult(vkCreateImage(device, &imageCreateInfo, nullptr, &texture->image));
assert(!err);
vkGetImageMemoryRequirements(device, texture->image, &memReqs); vkGetImageMemoryRequirements(device, texture->image, &memReqs);
memAllocInfo.allocationSize = memReqs.size; memAllocInfo.allocationSize = memReqs.size;
getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, &memAllocInfo.memoryTypeIndex); getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, &memAllocInfo.memoryTypeIndex);
err = vkAllocateMemory(device, &memAllocInfo, nullptr, &texture->deviceMemory); vkTools::checkResult(vkAllocateMemory(device, &memAllocInfo, nullptr, &texture->deviceMemory));
assert(!err); vkTools::checkResult(vkBindImageMemory(device, texture->image, texture->deviceMemory, 0));
err = vkBindImageMemory(device, texture->image, texture->deviceMemory, 0);
assert(!err);
VkImageSubresourceRange subresourceRange = {}; VkImageSubresourceRange subresourceRange = {};
subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
@ -239,25 +228,24 @@ namespace vkTools
subresourceRange); subresourceRange);
// Submit command buffer containing copy and image layout commands // Submit command buffer containing copy and image layout commands
err = vkEndCommandBuffer(cmdBuffer); vkTools::checkResult(vkEndCommandBuffer(cmdBuffer));
assert(!err);
VkFence nullFence = { VK_NULL_HANDLE }; // Create a fence to make sure that the copies have finished before continuing
VkFence copyFence;
VkFenceCreateInfo fenceCreateInfo = vkTools::initializers::fenceCreateInfo(VK_FLAGS_NONE);
vkTools::checkResult(vkCreateFence(device, &fenceCreateInfo, nullptr, &copyFence));
VkSubmitInfo submitInfo = vkTools::initializers::submitInfo(); VkSubmitInfo submitInfo = vkTools::initializers::submitInfo();
submitInfo.waitSemaphoreCount = 0;
submitInfo.commandBufferCount = 1; submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &cmdBuffer; submitInfo.pCommandBuffers = &cmdBuffer;
err = vkQueueSubmit(queue, 1, &submitInfo, nullFence); vkTools::checkResult(vkQueueSubmit(queue, 1, &submitInfo, copyFence));
assert(!err);
err = vkQueueWaitIdle(queue); vkWaitForFences(device, 1, &copyFence, VK_TRUE, DEFAULT_FENCE_TIMEOUT);
assert(!err);
// Clean up linear images vkDestroyFence(device, copyFence, nullptr);
// No longer required after mip levels
// have been transformed over to optimal tiling // Destroy linear images used as staging buffers after copies have been finished
for (auto& level : mipLevels) for (auto& level : mipLevels)
{ {
vkDestroyImage(device, level.image, nullptr); vkDestroyImage(device, level.image, nullptr);
@ -277,8 +265,7 @@ namespace vkTools
VkDeviceMemory mappableMemory; VkDeviceMemory mappableMemory;
// Load mip map level 0 to linear tiling image // Load mip map level 0 to linear tiling image
err = vkCreateImage(device, &imageCreateInfo, nullptr, &mappableImage); vkTools::checkResult(vkCreateImage(device, &imageCreateInfo, nullptr, &mappableImage));
assert(!err);
// Get memory requirements for this image // Get memory requirements for this image
// like size and alignment // like size and alignment
@ -290,12 +277,10 @@ namespace vkTools
getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, &memAllocInfo.memoryTypeIndex); getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, &memAllocInfo.memoryTypeIndex);
// Allocate host memory // Allocate host memory
err = vkAllocateMemory(device, &memAllocInfo, nullptr, &mappableMemory); vkTools::checkResult(vkAllocateMemory(device, &memAllocInfo, nullptr, &mappableMemory));
assert(!err);
// Bind allocated image for use // Bind allocated image for use
err = vkBindImageMemory(device, mappableImage, mappableMemory, 0); vkTools::checkResult(vkBindImageMemory(device, mappableImage, mappableMemory, 0));
assert(!err);
// Get sub resource layout // Get sub resource layout
// Mip map count, array layer, etc. // Mip map count, array layer, etc.
@ -309,11 +294,9 @@ namespace vkTools
// Get sub resources layout // Get sub resources layout
// Includes row pitch, size offsets, etc. // Includes row pitch, size offsets, etc.
vkGetImageSubresourceLayout(device, mappableImage, &subRes, &subResLayout); vkGetImageSubresourceLayout(device, mappableImage, &subRes, &subResLayout);
assert(!err);
// Map image memory // Map image memory
err = vkMapMemory(device, mappableMemory, 0, memReqs.size, 0, &data); vkTools::checkResult(vkMapMemory(device, mappableMemory, 0, memReqs.size, 0, &data));
assert(!err);
// Copy image data into memory // Copy image data into memory
memcpy(data, tex2D[subRes.mipLevel].data(), tex2D[subRes.mipLevel].size()); memcpy(data, tex2D[subRes.mipLevel].data(), tex2D[subRes.mipLevel].size());
@ -335,8 +318,7 @@ namespace vkTools
texture->imageLayout); texture->imageLayout);
// Submit command buffer containing copy and image layout commands // Submit command buffer containing copy and image layout commands
err = vkEndCommandBuffer(cmdBuffer); vkTools::checkResult(vkEndCommandBuffer(cmdBuffer));
assert(!err);
VkFence nullFence = { VK_NULL_HANDLE }; VkFence nullFence = { VK_NULL_HANDLE };
@ -345,11 +327,8 @@ namespace vkTools
submitInfo.commandBufferCount = 1; submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &cmdBuffer; submitInfo.pCommandBuffers = &cmdBuffer;
err = vkQueueSubmit(queue, 1, &submitInfo, nullFence); vkTools::checkResult(vkQueueSubmit(queue, 1, &submitInfo, nullFence));
assert(!err); vkTools::checkResult(vkQueueWaitIdle(queue));
err = vkQueueWaitIdle(queue);
assert(!err);
} }
// Create sampler // Create sampler
@ -370,9 +349,8 @@ namespace vkTools
sampler.maxAnisotropy = 8; sampler.maxAnisotropy = 8;
sampler.anisotropyEnable = VK_TRUE; sampler.anisotropyEnable = VK_TRUE;
sampler.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE; sampler.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
err = vkCreateSampler(device, &sampler, nullptr, &texture->sampler); vkTools::checkResult(vkCreateSampler(device, &sampler, nullptr, &texture->sampler));
assert(!err);
// Create image view // Create image view
// Textures are not directly accessed by the shaders and // Textures are not directly accessed by the shaders and
// are abstracted by image views containing additional // are abstracted by image views containing additional
@ -389,8 +367,7 @@ namespace vkTools
// Only set mip map count if optimal tiling is used // Only set mip map count if optimal tiling is used
view.subresourceRange.levelCount = (useStaging) ? texture->mipLevels : 1; view.subresourceRange.levelCount = (useStaging) ? texture->mipLevels : 1;
view.image = texture->image; view.image = texture->image;
err = vkCreateImageView(device, &view, nullptr, &texture->view); vkTools::checkResult(vkCreateImageView(device, &view, nullptr, &texture->view));
assert(!err);
} }
// Clean up vulkan resources used by a texture object // Clean up vulkan resources used by a texture object
@ -418,8 +395,7 @@ namespace vkTools
cmdBufInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; cmdBufInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
cmdBufInfo.commandBufferCount = 1; cmdBufInfo.commandBufferCount = 1;
VkResult vkRes = vkAllocateCommandBuffers(device, &cmdBufInfo, &cmdBuffer); vkTools:checkResult(vkAllocateCommandBuffers(device, &cmdBufInfo, &cmdBuffer));
assert(vkRes == VK_SUCCESS);
} }
~VulkanTextureLoader() ~VulkanTextureLoader()
@ -431,7 +407,6 @@ namespace vkTools
void loadCubemap(const char* filename, VkFormat format, VulkanTexture *texture) void loadCubemap(const char* filename, VkFormat format, VulkanTexture *texture)
{ {
VkFormatProperties formatProperties; VkFormatProperties formatProperties;
VkResult err;
gli::textureCube texCube(gli::load(filename)); gli::textureCube texCube(gli::load(filename));
assert(!texCube.empty()); assert(!texCube.empty());
@ -462,26 +437,20 @@ namespace vkTools
VkDeviceMemory memory; VkDeviceMemory memory;
} cubeFace[6]; } cubeFace[6];
VkCommandBufferBeginInfo cmdBufInfo = {}; VkCommandBufferBeginInfo cmdBufInfo = vkTools::initializers::commandBufferBeginInfo();
cmdBufInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
cmdBufInfo.pNext = NULL;
err = vkBeginCommandBuffer(cmdBuffer, &cmdBufInfo); vkTools::checkResult(vkBeginCommandBuffer(cmdBuffer, &cmdBufInfo));
assert(!err);
// Load separate cube map faces into linear tiled textures // Load separate cube map faces into linear tiled textures
for (uint32_t face = 0; face < 6; ++face) for (uint32_t face = 0; face < 6; ++face)
{ {
err = vkCreateImage(device, &imageCreateInfo, nullptr, &cubeFace[face].image); vkTools::checkResult(vkCreateImage(device, &imageCreateInfo, nullptr, &cubeFace[face].image));
assert(!err);
vkGetImageMemoryRequirements(device, cubeFace[face].image, &memReqs); vkGetImageMemoryRequirements(device, cubeFace[face].image, &memReqs);
memAllocInfo.allocationSize = memReqs.size; memAllocInfo.allocationSize = memReqs.size;
getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, &memAllocInfo.memoryTypeIndex); getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, &memAllocInfo.memoryTypeIndex);
err = vkAllocateMemory(device, &memAllocInfo, nullptr, &cubeFace[face].memory); vkTools::checkResult(vkAllocateMemory(device, &memAllocInfo, nullptr, &cubeFace[face].memory));
assert(!err); vkTools::checkResult(vkBindImageMemory(device, cubeFace[face].image, cubeFace[face].memory, 0));
err = vkBindImageMemory(device, cubeFace[face].image, cubeFace[face].memory, 0);
assert(!err);
VkImageSubresource subRes = {}; VkImageSubresource subRes = {};
subRes.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; subRes.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
@ -490,9 +459,7 @@ namespace vkTools
void *data; void *data;
vkGetImageSubresourceLayout(device, cubeFace[face].image, &subRes, &subResLayout); vkGetImageSubresourceLayout(device, cubeFace[face].image, &subRes, &subResLayout);
assert(!err); vkTools::checkResult(vkMapMemory(device, cubeFace[face].memory, 0, memReqs.size, 0, &data));
err = vkMapMemory(device, cubeFace[face].memory, 0, memReqs.size, 0, &data);
assert(!err);
memcpy(data, texCube[face][subRes.mipLevel].data(), texCube[face][subRes.mipLevel].size()); memcpy(data, texCube[face][subRes.mipLevel].data(), texCube[face][subRes.mipLevel].size());
vkUnmapMemory(device, cubeFace[face].memory); vkUnmapMemory(device, cubeFace[face].memory);
@ -514,18 +481,15 @@ namespace vkTools
imageCreateInfo.flags = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT; imageCreateInfo.flags = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
imageCreateInfo.arrayLayers = 6; imageCreateInfo.arrayLayers = 6;
err = vkCreateImage(device, &imageCreateInfo, nullptr, &texture->image); vkTools::checkResult(vkCreateImage(device, &imageCreateInfo, nullptr, &texture->image));
assert(!err);
vkGetImageMemoryRequirements(device, texture->image, &memReqs); vkGetImageMemoryRequirements(device, texture->image, &memReqs);
memAllocInfo.allocationSize = memReqs.size; memAllocInfo.allocationSize = memReqs.size;
getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, &memAllocInfo.memoryTypeIndex); getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, &memAllocInfo.memoryTypeIndex);
err = vkAllocateMemory(device, &memAllocInfo, nullptr, &texture->deviceMemory); vkTools::checkResult(vkAllocateMemory(device, &memAllocInfo, nullptr, &texture->deviceMemory));
assert(!err); vkTools::checkResult(vkBindImageMemory(device, texture->image, texture->deviceMemory, 0));
err = vkBindImageMemory(device, texture->image, texture->deviceMemory, 0);
assert(!err);
// Image barrier for optimal image (target) // Image barrier for optimal image (target)
// Optimal image will be used as destination for the copy // Optimal image will be used as destination for the copy
@ -586,21 +550,22 @@ namespace vkTools
texture->imageLayout, texture->imageLayout,
subresourceRange); subresourceRange);
err = vkEndCommandBuffer(cmdBuffer); vkTools::checkResult(vkEndCommandBuffer(cmdBuffer));
assert(!err);
VkFence nullFence = { VK_NULL_HANDLE }; // Create a fence to make sure that the copies have finished before continuing
VkFence copyFence;
VkFenceCreateInfo fenceCreateInfo = vkTools::initializers::fenceCreateInfo(VK_FLAGS_NONE);
vkTools::checkResult(vkCreateFence(device, &fenceCreateInfo, nullptr, &copyFence));
VkSubmitInfo submitInfo = vkTools::initializers::submitInfo(); VkSubmitInfo submitInfo = vkTools::initializers::submitInfo();
submitInfo.waitSemaphoreCount = 0;
submitInfo.commandBufferCount = 1; submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &cmdBuffer; submitInfo.pCommandBuffers = &cmdBuffer;
err = vkQueueSubmit(queue, 1, &submitInfo, nullFence); vkTools::checkResult(vkQueueSubmit(queue, 1, &submitInfo, copyFence));
assert(!err);
err = vkQueueWaitIdle(queue); vkWaitForFences(device, 1, &copyFence, VK_TRUE, DEFAULT_FENCE_TIMEOUT);
assert(!err);
vkDestroyFence(device, copyFence, nullptr);
// Create sampler // Create sampler
VkSamplerCreateInfo sampler = vkTools::initializers::samplerCreateInfo(); VkSamplerCreateInfo sampler = vkTools::initializers::samplerCreateInfo();
@ -616,8 +581,7 @@ namespace vkTools
sampler.minLod = 0.0f; sampler.minLod = 0.0f;
sampler.maxLod = 0.0f; sampler.maxLod = 0.0f;
sampler.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE; sampler.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
err = vkCreateSampler(device, &sampler, nullptr, &texture->sampler); vkTools::checkResult(vkCreateSampler(device, &sampler, nullptr, &texture->sampler));
assert(!err);
// Create image view // Create image view
VkImageViewCreateInfo view = vkTools::initializers::imageViewCreateInfo(); VkImageViewCreateInfo view = vkTools::initializers::imageViewCreateInfo();
@ -628,8 +592,7 @@ namespace vkTools
view.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 }; view.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
view.subresourceRange.layerCount = 6; view.subresourceRange.layerCount = 6;
view.image = texture->image; view.image = texture->image;
err = vkCreateImageView(device, &view, nullptr, &texture->view); vkTools::checkResult(vkCreateImageView(device, &view, nullptr, &texture->view));
assert(!err);
// Cleanup // Cleanup
for (auto& face : cubeFace) for (auto& face : cubeFace)
@ -643,7 +606,6 @@ namespace vkTools
void loadTextureArray(const char* filename, VkFormat format, VulkanTexture *texture) void loadTextureArray(const char* filename, VkFormat format, VulkanTexture *texture)
{ {
VkFormatProperties formatProperties; VkFormatProperties formatProperties;
VkResult err;
gli::texture2DArray tex2DArray(gli::load(filename)); gli::texture2DArray tex2DArray(gli::load(filename));
assert(!tex2DArray.empty()); assert(!tex2DArray.empty());
@ -684,28 +646,23 @@ namespace vkTools
cmdPool, cmdPool,
VK_COMMAND_BUFFER_LEVEL_PRIMARY, VK_COMMAND_BUFFER_LEVEL_PRIMARY,
1); 1);
err = vkAllocateCommandBuffers(device, &cmdBufAlllocatInfo, &cmdBuffer); vkTools::checkResult(vkAllocateCommandBuffers(device, &cmdBufAlllocatInfo, &cmdBuffer));
assert(!err);
VkCommandBufferBeginInfo cmdBufInfo = VkCommandBufferBeginInfo cmdBufInfo =
vkTools::initializers::commandBufferBeginInfo(); vkTools::initializers::commandBufferBeginInfo();
err = vkBeginCommandBuffer(cmdBuffer, &cmdBufInfo); vkTools::checkResult(vkBeginCommandBuffer(cmdBuffer, &cmdBufInfo));
assert(!err);
// Load separate cube map faces into linear tiled textures // Load separate cube map faces into linear tiled textures
for (uint32_t i = 0; i < texture->layerCount; ++i) for (uint32_t i = 0; i < texture->layerCount; ++i)
{ {
err = vkCreateImage(device, &imageCreateInfo, nullptr, &arrayLayer[i].image); vkTools::checkResult(vkCreateImage(device, &imageCreateInfo, nullptr, &arrayLayer[i].image));
assert(!err);
vkGetImageMemoryRequirements(device, arrayLayer[i].image, &memReqs); vkGetImageMemoryRequirements(device, arrayLayer[i].image, &memReqs);
memAllocInfo.allocationSize = memReqs.size; memAllocInfo.allocationSize = memReqs.size;
getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, &memAllocInfo.memoryTypeIndex); getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, &memAllocInfo.memoryTypeIndex);
err = vkAllocateMemory(device, &memAllocInfo, nullptr, &arrayLayer[i].memory); vkTools::checkResult(vkAllocateMemory(device, &memAllocInfo, nullptr, &arrayLayer[i].memory));
assert(!err); vkTools::checkResult(vkBindImageMemory(device, arrayLayer[i].image, arrayLayer[i].memory, 0));
err = vkBindImageMemory(device, arrayLayer[i].image, arrayLayer[i].memory, 0);
assert(!err);
VkImageSubresource subRes = {}; VkImageSubresource subRes = {};
subRes.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; subRes.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
@ -714,9 +671,7 @@ namespace vkTools
void *data; void *data;
vkGetImageSubresourceLayout(device, arrayLayer[i].image, &subRes, &subResLayout); vkGetImageSubresourceLayout(device, arrayLayer[i].image, &subRes, &subResLayout);
assert(!err); vkTools::checkResult(vkMapMemory(device, arrayLayer[i].memory, 0, memReqs.size, 0, &data));
err = vkMapMemory(device, arrayLayer[i].memory, 0, memReqs.size, 0, &data);
assert(!err);
memcpy(data, tex2DArray[i].data(), tex2DArray[i].size()); memcpy(data, tex2DArray[i].data(), tex2DArray[i].size());
vkUnmapMemory(device, arrayLayer[i].memory); vkUnmapMemory(device, arrayLayer[i].memory);
@ -737,18 +692,15 @@ namespace vkTools
imageCreateInfo.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT; imageCreateInfo.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
imageCreateInfo.arrayLayers = texture->layerCount; imageCreateInfo.arrayLayers = texture->layerCount;
err = vkCreateImage(device, &imageCreateInfo, nullptr, &texture->image); vkTools::checkResult(vkCreateImage(device, &imageCreateInfo, nullptr, &texture->image));
assert(!err);
vkGetImageMemoryRequirements(device, texture->image, &memReqs); vkGetImageMemoryRequirements(device, texture->image, &memReqs);
memAllocInfo.allocationSize = memReqs.size; memAllocInfo.allocationSize = memReqs.size;
getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, &memAllocInfo.memoryTypeIndex); getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, &memAllocInfo.memoryTypeIndex);
err = vkAllocateMemory(device, &memAllocInfo, nullptr, &texture->deviceMemory); vkTools::checkResult(vkAllocateMemory(device, &memAllocInfo, nullptr, &texture->deviceMemory));
assert(!err); vkTools::checkResult(vkBindImageMemory(device, texture->image, texture->deviceMemory, 0));
err = vkBindImageMemory(device, texture->image, texture->deviceMemory, 0);
assert(!err);
// Image barrier for optimal image (target) // Image barrier for optimal image (target)
// Optimal image will be used as destination for the copy // Optimal image will be used as destination for the copy
@ -808,21 +760,22 @@ namespace vkTools
texture->imageLayout, texture->imageLayout,
subresourceRange); subresourceRange);
err = vkEndCommandBuffer(cmdBuffer); vkTools::checkResult(vkEndCommandBuffer(cmdBuffer));
assert(!err);
VkFence nullFence = { VK_NULL_HANDLE }; // Create a fence to make sure that the copies have finished before continuing
VkFence copyFence;
VkFenceCreateInfo fenceCreateInfo = vkTools::initializers::fenceCreateInfo(VK_FLAGS_NONE);
vkTools::checkResult(vkCreateFence(device, &fenceCreateInfo, nullptr, &copyFence));
// Submit command buffer to graphis queue
VkSubmitInfo submitInfo = vkTools::initializers::submitInfo(); VkSubmitInfo submitInfo = vkTools::initializers::submitInfo();
submitInfo.commandBufferCount = 1; submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &cmdBuffer; submitInfo.pCommandBuffers = &cmdBuffer;
err = vkQueueSubmit(queue, 1, &submitInfo, nullFence); vkTools::checkResult(vkQueueSubmit(queue, 1, &submitInfo, copyFence));
assert(!err);
err = vkQueueWaitIdle(queue); vkWaitForFences(device, 1, &copyFence, VK_TRUE, DEFAULT_FENCE_TIMEOUT);
assert(!err);
vkDestroyFence(device, copyFence, nullptr);
// Create sampler // Create sampler
VkSamplerCreateInfo sampler = vkTools::initializers::samplerCreateInfo(); VkSamplerCreateInfo sampler = vkTools::initializers::samplerCreateInfo();
@ -838,8 +791,7 @@ namespace vkTools
sampler.minLod = 0.0f; sampler.minLod = 0.0f;
sampler.maxLod = 0.0f; sampler.maxLod = 0.0f;
sampler.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE; sampler.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
err = vkCreateSampler(device, &sampler, nullptr, &texture->sampler); vkTools::checkResult(vkCreateSampler(device, &sampler, nullptr, &texture->sampler));
assert(!err);
// Create image view // Create image view
VkImageViewCreateInfo view = vkTools::initializers::imageViewCreateInfo(); VkImageViewCreateInfo view = vkTools::initializers::imageViewCreateInfo();
@ -850,8 +802,7 @@ namespace vkTools
view.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 }; view.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
view.subresourceRange.layerCount = texture->layerCount; view.subresourceRange.layerCount = texture->layerCount;
view.image = texture->image; view.image = texture->image;
err = vkCreateImageView(device, &view, nullptr, &texture->view); vkTools::checkResult(vkCreateImageView(device, &view, nullptr, &texture->view));
assert(!err);
// Cleanup // Cleanup
for (auto& layer : arrayLayer) for (auto& layer : arrayLayer)

2
base/vulkantools.h
View file

@ -29,6 +29,8 @@
// Custom define for better code readability // Custom define for better code readability
#define VK_FLAGS_NONE 0 #define VK_FLAGS_NONE 0
// Default fence timeout in nanoseconds
#define DEFAULT_FENCE_TIMEOUT 100000000000
namespace vkTools namespace vkTools
{ {