LoadBin()

bool Spices::TextureLoader::LoadBin ( const std::string & fileName, const std::string & it, Texture2D * outTexture )

staticprivate

Function of load a ktx file.

Parameters

[in]	fileName	ktx file name.
[in]	it	file direct folder.
[in]	outTexture	Pointer of texture.

Returns

Returns true if load file succeed.

Instance the VulkanImage as Texture2D Resource.

Instance the Resource.

Transform Image Layout from undefined to transfer_dst.

Copy Memory to Image.

Instance a staginBuffer.

Copy the data from texture bytes to staginBuffer.

Transform Image Layout from undefined to transfer_dst.

Copy the data from staginBuffer to Image.

Transform Image Layout from transfer_dst to shaderread.

Create Image View.

Create Image Sampler.

Release ktx image data.

Instance the VulkanImage as Texture2D Resource.

Instance the Resource.

Transform Image Layout from undefined to transfer_dst.

Copy Memory to Image.

Instance a staginBuffer.

Copy the data from texture bytes to staginBuffer.

Transform Image Layout from undefined to transfer_dst.

Copy the data from staginBuffer to Image.

Transform Image Layout from transfer_dst to shaderread.

Create Image View.

Create Image Sampler.

Release ktx image data.

Definition at line 105 of file TextureLoader.cpp.

    {
        SPICES_PROFILE_ZONE;
 
        std::string binPath;
        if (it == "")
        {
            binPath = fileName;
        }
        else
        {
            std::vector<std::string> splitString = StringLibrary::SplitString(fileName, '.');
            binPath = it + binTexturePath + splitString[0] + ".ktx";
        }
 
        ktxTexture2* texture = nullptr;
        Transcoder::LoadFromKTX(binPath, texture);
 
        outTexture->m_Resource = std::make_shared<VulkanImage>(VulkanRenderBackend::GetState());
        auto resourceptr = outTexture->GetResource<VulkanImage>();
 
        VkImageUsageFlags usage = VK_IMAGE_USAGE_SAMPLED_BIT;  // Can be Used for Sample
        bool hostCopy = VulkanImage::IsHostCopyable(resourceptr->m_VulkanState, static_cast<VkFormat>(texture->vkFormat));
        usage |= hostCopy ? VK_IMAGE_USAGE_HOST_TRANSFER_BIT_EXT : VK_IMAGE_USAGE_TRANSFER_DST_BIT;
 
        resourceptr->CreateImage(
            resourceptr->m_VulkanState                          ,
            fileName                                            ,
            static_cast<VkImageType>(texture->numDimensions - 1),
            texture->baseWidth                                  ,
            texture->baseHeight                                 ,
            texture->baseDepth                                  ,  // 1 layers.
            VK_SAMPLE_COUNT_1_BIT                               ,  // No MASS.
            static_cast<VkFormat>(texture->vkFormat)            ,  // Compress Format.
            VK_IMAGE_TILING_OPTIMAL                             ,  // Tiling Optimal.
            usage                                               ,
            0                                                   ,
            VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT                 ,
            texture->numLevels
        );
 
        if (hostCopy)
        {
            resourceptr->TransitionImageLayout(
                resourceptr->m_Format,
                VK_IMAGE_LAYOUT_UNDEFINED,
                VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
            );
 
            std::vector<VkMemoryToImageCopyEXT> copies;
            for (uint32_t mip_level = 0; mip_level < texture->numLevels; mip_level++)
            {
                VkMemoryToImageCopyEXT                       memoryCopy{};
                memoryCopy.sType                           = VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY_EXT;
                memoryCopy.imageSubresource.aspectMask     = VK_IMAGE_ASPECT_COLOR_BIT;
                memoryCopy.imageSubresource.mipLevel       = mip_level;
                memoryCopy.imageSubresource.baseArrayLayer = 0;
                memoryCopy.imageSubresource.layerCount     = 1;
                memoryCopy.imageExtent.width               = std::max((uint32_t)1, texture->baseWidth >> mip_level);
                memoryCopy.imageExtent.height              = std::max((uint32_t)1, texture->baseHeight >> mip_level);
                memoryCopy.imageExtent.depth               = 1;
                memoryCopy.pHostPointer                    = texture->pData + Transcoder::GetMipmapOffset(texture, mip_level);
 
                copies.push_back(memoryCopy);
            }
 
            resourceptr->CopyMemoryToImageHost(copies);
        }
        else
        {
            VulkanBuffer stagingBuffer(
                resourceptr->m_VulkanState,
                "StagingBuffer"                     ,
                texture->dataSize                   ,
                VK_BUFFER_USAGE_TRANSFER_SRC_BIT    ,
                VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
                VK_MEMORY_PROPERTY_HOST_COHERENT_BIT
            );
 
            stagingBuffer.WriteToBuffer(texture->pData);
 
            resourceptr->TransitionImageLayout(
                resourceptr->m_Format               ,
                VK_IMAGE_LAYOUT_UNDEFINED           ,
                VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
            );
 
            std::vector<VkBufferImageCopy> regions;
            for (uint32_t mip_level = 0; mip_level < texture->numLevels; mip_level++)
            {
                VkBufferImageCopy                        region {};
                region.imageSubresource.aspectMask     = VK_IMAGE_ASPECT_COLOR_BIT;
                region.imageSubresource.mipLevel       = mip_level;
                region.imageSubresource.baseArrayLayer = 0;
                region.imageSubresource.layerCount     = 1;
                region.imageExtent.width               = std::max((uint32_t)1, texture->baseWidth  >> mip_level);
                region.imageExtent.height              = std::max((uint32_t)1, texture->baseHeight >> mip_level);
                region.imageExtent.depth               = 1;
                region.bufferOffset                    = Transcoder::GetMipmapOffset(texture, mip_level);
 
                regions.push_back(region);
            }
 
            resourceptr->CopyBufferToImage(
                stagingBuffer.Get()                         ,
                resourceptr->m_Image                        ,
                static_cast<uint32_t>(resourceptr->m_Width) ,
                static_cast<uint32_t>(resourceptr->m_Height),
                regions
            );
        
            resourceptr->TransitionImageLayout(
                resourceptr->m_Format                   ,
                VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL    ,
                VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
            );
        }
 
        resourceptr->CreateImageView(
            resourceptr->m_Format    ,
            VK_IMAGE_VIEW_TYPE_2D    ,
            VK_IMAGE_ASPECT_COLOR_BIT
        );
 
        resourceptr->CreateSampler();
 
        Transcoder::DestroyktxTexture2(texture);
 
        return true;
    }

References Spices::VulkanRenderBackend::GetState().

Referenced by Load().