void Image::copyImage(const VkCommandBuffer cmdBuffer, IImageSP& targetImage, const VkImageCopy& imageCopy)
{
if (!targetImage.get())
{
return;
}
VkImageLayout sourceImageLayout = getImageLayout(imageCopy.srcSubresource.mipLevel, imageCopy.srcSubresource.baseArrayLayer);
VkAccessFlags sourceAccessMask = getAccessMask(imageCopy.srcSubresource.mipLevel, imageCopy.srcSubresource.baseArrayLayer);
VkImageLayout targetImageLayout = targetImage->getImageLayout(imageCopy.dstSubresource.mipLevel, imageCopy.dstSubresource.baseArrayLayer);
VkAccessFlags targetAccessMask = targetImage->getAccessMask(imageCopy.dstSubresource.mipLevel, imageCopy.dstSubresource.baseArrayLayer);
// Prepare source image for copy.
VkImageSubresourceRange srcImageSubresourceRange = {imageCopy.srcSubresource.aspectMask, imageCopy.srcSubresource.mipLevel, 1, imageCopy.srcSubresource.baseArrayLayer, imageCopy.srcSubresource.layerCount};
cmdPipelineBarrier(cmdBuffer, VK_ACCESS_TRANSFER_READ_BIT, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, srcImageSubresourceRange);
// Prepare target image for copy.
VkImageSubresourceRange dstImageSubresourceRange = {imageCopy.dstSubresource.aspectMask, imageCopy.dstSubresource.mipLevel, 1, imageCopy.dstSubresource.baseArrayLayer, imageCopy.dstSubresource.layerCount};
targetImage->cmdPipelineBarrier(cmdBuffer, VK_ACCESS_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, dstImageSubresourceRange);
// Copy image by command.
vkCmdCopyImage(cmdBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, targetImage->getImage(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &imageCopy);
// Revert back.
targetImage->cmdPipelineBarrier(cmdBuffer, targetAccessMask, targetImageLayout, dstImageSubresourceRange);
// Revert back.
cmdPipelineBarrier(cmdBuffer, sourceAccessMask, sourceImageLayout, srcImageSubresourceRange);
}
IMemoryImageSP VKTS_APIENTRY memoryImageCreate(IImageSP& stageImage, IBufferSP& stageBuffer, IDeviceMemorySP& stageDeviceMemory, const IInitialResourcesSP& initialResources, const ICommandBuffersSP& cmdBuffer, const std::string& name, const IImageDataSP& imageData, const VkImageCreateInfo& imageCreateInfo, const VkAccessFlags srcAccessMask, const VkAccessFlags dstAccessMask, const VkImageLayout newLayout, const VkImageSubresourceRange& subresourceRange, const VkMemoryPropertyFlags memoryPropertyFlags)
{
if (!cmdBuffer || !imageData.get())
{
return IMemoryImageSP();
}
VkResult result;
//
IImageSP image;
IDeviceMemorySP deviceMemory;
//
if (!memoryImagePrepare(image, deviceMemory, initialResources, cmdBuffer, imageCreateInfo, srcAccessMask, dstAccessMask, newLayout, subresourceRange, memoryPropertyFlags))
{
return IMemoryImageSP();
}
//
if (memoryPropertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)
{
for (uint32_t i = 0; i < imageData->getMipLevels(); i++)
{
VkImageSubresource imageSubresource;
imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
imageSubresource.mipLevel = i;
imageSubresource.arrayLayer = 0;
VkSubresourceLayout subresourceLayout;
image->getImageSubresourceLayout(subresourceLayout, imageSubresource);
if (!memoryImageUpload(deviceMemory, imageData, i, subresourceLayout))
{
logPrint(VKTS_LOG_ERROR, "MemoryImage: Could not upload image data.");
return IMemoryImageSP();
}
}
}
else
{
if (initialResources->getPhysicalDevice()->isImageTilingAvailable(VK_IMAGE_TILING_LINEAR, imageData->getFormat(), imageData->getImageType(), 0, imageData->getExtent3D(), imageData->getMipLevels(), 1, VK_SAMPLE_COUNT_1_BIT, imageData->getSize()))
{
VkImageCreateInfo stageImageCreateInfo;
memcpy(&stageImageCreateInfo, &imageCreateInfo, sizeof(VkImageCreateInfo));
stageImageCreateInfo.tiling = VK_IMAGE_TILING_LINEAR;
stageImageCreateInfo.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
stageImageCreateInfo.initialLayout = VK_IMAGE_LAYOUT_PREINITIALIZED;
if (!memoryImagePrepare(stageImage, stageDeviceMemory, initialResources, cmdBuffer, stageImageCreateInfo, VK_ACCESS_HOST_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, subresourceRange, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT))
{
logPrint(VKTS_LOG_ERROR, "MemoryImage: Could not prepare staging image.");
return IMemoryImageSP();
}
for (uint32_t i = 0; i < imageData->getMipLevels(); i++)
{
VkImageSubresource imageSubresource;
imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
imageSubresource.mipLevel = i;
imageSubresource.arrayLayer = 0;
VkSubresourceLayout subresourceLayout;
stageImage->getImageSubresourceLayout(subresourceLayout, imageSubresource);
if (!memoryImageUpload(stageDeviceMemory, imageData, i, subresourceLayout))
{
logPrint(VKTS_LOG_ERROR, "MemoryImage: Could not upload image data.");
return IMemoryImageSP();
}
VkImageCopy imageCopy;
imageCopy.srcSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, i, 0, 1};
imageCopy.srcOffset = {0, 0, 0};
imageCopy.dstSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, i, 0, 1};
imageCopy.dstOffset = {0, 0, 0};
imageCopy.extent = {glm::max(imageData->getWidth() >> i, 1u), glm::max(imageData->getHeight() >> i, 1u), glm::max(imageData->getDepth() >> i, 1u)};
stageImage->copyImage(cmdBuffer->getCommandBuffer(), image, imageCopy);
}
}
FontCacheEntry* FreeTypeFont::getGlyph(const ICommandBuffersSP& cmdBuffer, const char32_t character, const size_t size)
{
if (!face || !cmdBuffer.get())
{
return nullptr;
}
//
FontCacheEntry* fontCacheEntry = getGlyph(character, size);
// Error case.
if (!fontCacheEntry)
{
return nullptr;
}
// Character has no data e.g. space.
if (!fontCacheEntry->glyphImageData.get())
{
return fontCacheEntry;
}
// Character already created.
if (fontCacheEntry->texture.get())
{
return fontCacheEntry;
}
//
VkImageTiling imageTiling;
VkMemoryPropertyFlags memoryPropertyFlags;
if (!initialResources->getPhysicalDevice()->getGetImageTilingAndMemoryProperty(imageTiling, memoryPropertyFlags, fontCacheEntry->glyphImageData->getFormat(), fontCacheEntry->glyphImageData->getImageType(), 0, fontCacheEntry->glyphImageData->getExtent3D(), fontCacheEntry->glyphImageData->getMipLevels(), 1, VK_SAMPLE_COUNT_1_BIT, fontCacheEntry->glyphImageData->getSize()))
{
return nullptr;
}
//
VkImageCreateInfo imageCreateInfo;
memset(&imageCreateInfo, 0, sizeof(VkImageCreateInfo));
imageCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
imageCreateInfo.flags = 0;
imageCreateInfo.imageType = fontCacheEntry->glyphImageData->getImageType();
imageCreateInfo.format = fontCacheEntry->glyphImageData->getFormat();
imageCreateInfo.extent = fontCacheEntry->glyphImageData->getExtent3D();
imageCreateInfo.mipLevels = fontCacheEntry->glyphImageData->getMipLevels();
imageCreateInfo.arrayLayers = 1;
imageCreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;
imageCreateInfo.tiling = imageTiling;
imageCreateInfo.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
imageCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
imageCreateInfo.queueFamilyIndexCount = 0;
imageCreateInfo.pQueueFamilyIndices = nullptr;
imageCreateInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
VkImageSubresourceRange subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
VkSamplerCreateInfo samplerCreateInfo;
memset(&samplerCreateInfo, 0, sizeof(VkSamplerCreateInfo));
samplerCreateInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
samplerCreateInfo.flags = 0;
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.0f;
samplerCreateInfo.anisotropyEnable = VK_FALSE;
samplerCreateInfo.maxAnisotropy = 1.0f;
samplerCreateInfo.compareEnable = VK_FALSE;
samplerCreateInfo.compareOp = VK_COMPARE_OP_NEVER;
samplerCreateInfo.minLod = 0.0f;
samplerCreateInfo.maxLod = 0.0f;
samplerCreateInfo.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
samplerCreateInfo.unnormalizedCoordinates = VK_FALSE;
VkImageViewCreateInfo imageViewCreateInfo;
memset(&imageViewCreateInfo, 0, sizeof(VkImageViewCreateInfo));
imageViewCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
imageViewCreateInfo.flags = 0;
imageViewCreateInfo.image = VK_NULL_HANDLE; // Defined later.
imageViewCreateInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
imageViewCreateInfo.format = fontCacheEntry->glyphImageData->getFormat();
imageViewCreateInfo.components = {VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A};
imageViewCreateInfo.subresourceRange = subresourceRange;
IImageSP stageImage;
IBufferSP stageBuffer;
IDeviceMemorySP stageDeviceMemory;
fontCacheEntry->texture = textureCreate(stageImage, stageBuffer, stageDeviceMemory, initialResources, cmdBuffer, "FontCharacterTexture", fontCacheEntry->glyphImageData, imageCreateInfo, VK_ACCESS_INPUT_ATTACHMENT_READ_BIT | VK_ACCESS_SHADER_READ_BIT, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, subresourceRange, memoryPropertyFlags, samplerCreateInfo, imageViewCreateInfo);
if (!fontCacheEntry->texture.get())
{
return nullptr;
}
if (stageImage.get())
{
allStageImages.append(stageImage);
}
if (stageBuffer.get())
{
allStageBuffers.append(stageBuffer);
}
if (stageDeviceMemory.get())
{
allStageDeviceMemories.append(stageDeviceMemory);
}
return fontCacheEntry;
}
