Gdiplus::Image * cgGdiplusRender::LoadImageFromFile( LPCTSTR lpctPath )
{
HANDLE hFile = CreateFile(lpctPath, GENERIC_READ, 0, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
if (hFile == INVALID_HANDLE_VALUE)
return NULL;
BYTE * pBuff = NULL;
Gdiplus::Image * pkImage = NULL;
do
{
DWORD dwLen = GetFileSize(hFile, NULL);
if (dwLen <= 0)
break;
pBuff = new BYTE[dwLen];
DWORD dwReadLen = 0;
BOOL bRet = ReadFile(hFile, pBuff, dwLen, &dwReadLen, NULL);
if (!bRet || dwReadLen <= 0)
break;
pkImage = LoadImageFromMemory(pBuff, dwReadLen);
} while (false);
if (pBuff)
delete[] pBuff;
CloseHandle(hFile);
return pkImage;
}
Gdiplus::Image * cgGdiplusRender::LoadImageFromResource( UINT nID, LPCTSTR sTR )
{
HINSTANCE hInst = GetModuleHandle( NULL);;
HRSRC hRsrc = ::FindResource (hInst,MAKEINTRESOURCE(nID),sTR); // type
if (!hRsrc)
return NULL;
// load resource into memory
DWORD len = SizeofResource(hInst, hRsrc);
BYTE* lpRsrc = (BYTE*)LoadResource(hInst, hRsrc);
if (!lpRsrc)
return NULL;
Gdiplus::Image * pkImage = LoadImageFromMemory(lpRsrc, len);
FreeResource(lpRsrc);
return pkImage;
}
void VulkanTexturedQuad::CreateTexture (VkCommandBuffer uploadCommandList)
{
int width, height;
auto image = LoadImageFromMemory (RubyTexture, sizeof (RubyTexture),
1, &width, &height);
VkImageCreateInfo imageCreateInfo = {};
imageCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
imageCreateInfo.pNext = nullptr;
imageCreateInfo.queueFamilyIndexCount = 1;
uint32_t queueFamilyIndex = static_cast<uint32_t> (queueFamilyIndex_);
imageCreateInfo.pQueueFamilyIndices = &queueFamilyIndex;
imageCreateInfo.mipLevels = 1;
imageCreateInfo.format = VK_FORMAT_R8G8B8A8_UNORM;
imageCreateInfo.arrayLayers = 1;
imageCreateInfo.extent.depth = 1;
imageCreateInfo.extent.height = height;
imageCreateInfo.extent.width = width;
imageCreateInfo.usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
imageCreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;
imageCreateInfo.imageType = VK_IMAGE_TYPE_2D;
imageCreateInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
imageCreateInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
vkCreateImage (device_, &imageCreateInfo, nullptr, &rubyImage_);
VkMemoryRequirements requirements = {};
vkGetImageMemoryRequirements (device_, rubyImage_,
&requirements);
VkDeviceSize requiredSizeForImage = requirements.size;
auto memoryHeaps = EnumerateHeaps (physicalDevice_);
deviceImageMemory_ = AllocateMemory (memoryHeaps, device_, static_cast<int> (requiredSizeForImage),
requirements.memoryTypeBits,
MT_DeviceLocal);
vkBindImageMemory (device_, rubyImage_, deviceImageMemory_, 0);
VkBufferCreateInfo bufferCreateInfo = {};
bufferCreateInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
bufferCreateInfo.pNext = nullptr;
bufferCreateInfo.queueFamilyIndexCount = 1;
bufferCreateInfo.pQueueFamilyIndices = &queueFamilyIndex;
bufferCreateInfo.size = requiredSizeForImage;
bufferCreateInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
vkCreateBuffer (device_, &bufferCreateInfo, nullptr, &uploadImageBuffer_);
vkGetBufferMemoryRequirements (device_, uploadImageBuffer_, &requirements);
VkDeviceSize requiredSizeForBuffer = requirements.size;
bool memoryIsHostCoherent = false;
uploadImageMemory_ = AllocateMemory (memoryHeaps, device_,
static_cast<int> (requiredSizeForBuffer), requirements.memoryTypeBits,
MT_HostVisible, &memoryIsHostCoherent);
vkBindBufferMemory (device_, uploadImageBuffer_, uploadImageMemory_, 0);
void* data = nullptr;
vkMapMemory (device_, uploadImageMemory_, 0, VK_WHOLE_SIZE,
0, &data);
::memcpy (data, image.data (), image.size ());
if (!memoryIsHostCoherent)
{
VkMappedMemoryRange mappedMemoryRange = {};
mappedMemoryRange.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
mappedMemoryRange.memory = uploadImageMemory_;
mappedMemoryRange.offset = 0;
mappedMemoryRange.size = VK_WHOLE_SIZE;
vkFlushMappedMemoryRanges (device_, 1, &mappedMemoryRange);
}
vkUnmapMemory (device_, uploadImageMemory_);
VkBufferImageCopy bufferImageCopy = {};
bufferImageCopy.imageExtent.width = width;
bufferImageCopy.imageExtent.height = height;
bufferImageCopy.imageExtent.depth = 1;
bufferImageCopy.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
bufferImageCopy.imageSubresource.mipLevel = 0;
bufferImageCopy.imageSubresource.layerCount = 1;
VkImageMemoryBarrier imageBarrier = {};
imageBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
imageBarrier.pNext = nullptr;
imageBarrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;
imageBarrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
imageBarrier.srcAccessMask = 0;
imageBarrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
imageBarrier.image = rubyImage_;
imageBarrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
imageBarrier.subresourceRange.layerCount = 1;
imageBarrier.subresourceRange.levelCount = 1;
vkCmdPipelineBarrier (uploadCommandList,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_PIPELINE_STAGE_TRANSFER_BIT,
0, 0, nullptr, 0, nullptr,
1, &imageBarrier);
vkCmdCopyBufferToImage (uploadCommandList, uploadImageBuffer_,
rubyImage_, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
1, &bufferImageCopy);
imageBarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
imageBarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
imageBarrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
imageBarrier.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
vkCmdPipelineBarrier (uploadCommandList,
VK_PIPELINE_STAGE_TRANSFER_BIT,
VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
0, 0, nullptr, 0, nullptr,
1, &imageBarrier);
VkImageViewCreateInfo imageViewCreateInfo = {};
imageViewCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
imageViewCreateInfo.format = imageCreateInfo.format;
imageViewCreateInfo.image = rubyImage_;
imageViewCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
imageViewCreateInfo.subresourceRange.levelCount = 1;
imageViewCreateInfo.subresourceRange.layerCount = 1;
imageViewCreateInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
vkCreateImageView (device_, &imageViewCreateInfo, nullptr, &rubyImageView_);
}
