LoadSrc()

bool Spices::TextureLoader::LoadSrc ( const std::string & fileName, const std::string & it, Texture2D * outTexture, bool isCreateCompressTexture = true )

staticprivate

Function of load a src file.

Parameters

[in]	fileName	src file name.
[in]	it	file direct folder.
[in]	outTexture	Pointer of texture.
[in]	isCreateCompressTexture	Create Ktx texture in disk if true.

Returns

Returns true if load file succeed.

Load Texture data.

Instance the VulkanImage as Texture2D Resource.

Set resource values.

Instance the Resource.

Transform Image Layout from undefined to transfer_dst.

Get Texture bytes.

Note

4 means 4 channels per texel, 1 means 1 bytes per texel channel.(RGBA8 Format support only)

Instance a staginBuffer.

Copy the data from texture bytes to staginBuffer.

Copy the data from staginBuffer to Image.

Release texture bytes.

Generate Image Mipmaps.

Create Image View.

Create Image Sampler.

Instance a VkBufferImageCopy.

The temp buffer image date copy to.

Instance a VkImageToMemoryCopyEXT.

Write mipmap data to ktxTexture.

Save to disk.

Load Texture data.

Instance the VulkanImage as Texture2D Resource.

Set resource values.

Instance the Resource.

Transform Image Layout from undefined to transfer_dst.

Get Texture bytes.

Note

4 means 4 channels per texel, 1 means 1 bytes per texel channel.(RGBA8 Format support only)

Instance a staginBuffer.

Copy the data from texture bytes to staginBuffer.

Copy the data from staginBuffer to Image.

Release texture bytes.

Generate Image Mipmaps.

Create Image View.

Create Image Sampler.

Instance a VkBufferImageCopy.

The temp buffer image date copy to.

Instance a VkImageToMemoryCopyEXT.

Write mipmap data to ktxTexture.

Save to disk.

Definition at line 272 of file TextureLoader.cpp.

    {
        SPICES_PROFILE_ZONE;
 
        std::string filePath;
        std::string binPath;
        if (it == "")
        {
            assert(!isCreateCompressTexture);
 
            filePath = fileName;
        }
        else
        {
            const std::vector<std::string> splitString = StringLibrary::SplitString(fileName, '.');
            filePath = it + defaultTexturePath + fileName;
            binPath  = it + binTexturePath + splitString[0] + ".ktx";
        }
 
        int width;
        int height;
        int texChannels;
        stbi_uc* pixels = stbi_load(filePath.c_str(), &width, &height, &texChannels, STBI_rgb_alpha);
        if (!pixels)
        {
            SPICES_CORE_ERROR("Failed to load texture image!")
        }
 
        outTexture->m_Resource = std::make_shared<VulkanImage>(VulkanRenderBackend::GetState());
        auto resourceptr = outTexture->GetResource<VulkanImage>();
 
        resourceptr->m_Width       = width;
        resourceptr->m_Height      = height;
        resourceptr->m_MipLevels   = static_cast<uint32_t>(std::floor(std::log2(std::max(resourceptr->m_Width, resourceptr->m_Height)))) + 1;   
        
        VkImageUsageFlags usage = VK_IMAGE_USAGE_SAMPLED_BIT;  // Can be Used for Sample
        const bool hostCopy = VulkanImage::IsHostCopyable(resourceptr->m_VulkanState, VK_FORMAT_R8G8B8A8_UNORM);
        usage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
        if (hostCopy) usage |= VK_IMAGE_USAGE_HOST_TRANSFER_BIT_EXT;
 
        resourceptr->CreateImage(
            resourceptr->m_VulkanState,
            fileName                           ,
            VK_IMAGE_TYPE_2D                   ,
            resourceptr->m_Width               ,
            resourceptr->m_Height              ,
            1                                  ,          // 1 layers.
            VK_SAMPLE_COUNT_1_BIT              ,          // No MASS.
            VK_FORMAT_R8G8B8A8_UNORM           ,          // RGBA8 Format.
            VK_IMAGE_TILING_OPTIMAL            ,          // Tiling Optimal.
            usage                              ,
            0                                  ,
            VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
            resourceptr->m_MipLevels
        );
 
        resourceptr->TransitionImageLayout(
            resourceptr->m_Format,
            VK_IMAGE_LAYOUT_UNDEFINED,
            VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
        );
 
        const VkDeviceSize imageSize = static_cast<uint64_t>(resourceptr->m_Width * resourceptr->m_Height * 4 * 1);
 
        VulkanBuffer stagingBuffer(
            resourceptr->m_VulkanState,
            "StagingBuffer",
            imageSize,
            VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
            VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
            VK_MEMORY_PROPERTY_HOST_COHERENT_BIT
        );
 
        stagingBuffer.WriteToBuffer(pixels);
 
        resourceptr->CopyBufferToImage(
            stagingBuffer.Get()                         , 
            resourceptr->m_Image                        , 
            static_cast<uint32_t>(resourceptr->m_Width) , 
            static_cast<uint32_t>(resourceptr->m_Height)
        );
 
        stbi_image_free(pixels);
 
        resourceptr->GenerateMipmaps(
            resourceptr->m_Format,
            resourceptr->m_Width,
            resourceptr->m_Height
        );
 
        resourceptr->CreateImageView(
            resourceptr->m_Format     ,
            VK_IMAGE_VIEW_TYPE_2D     ,
            VK_IMAGE_ASPECT_COLOR_BIT
        );
 
        resourceptr->CreateSampler();
 
        auto deviceCopyF = [&](uint32_t w, uint32_t h, int mip, std::vector<unsigned char>& data) {
 
            VkBufferImageCopy region{};
            region.bufferOffset                    = 0;
            region.bufferRowLength                 = 0;
            region.bufferImageHeight               = 0;
        
            region.imageSubresource.aspectMask     = VK_IMAGE_ASPECT_COLOR_BIT;
            region.imageSubresource.mipLevel       = resourceptr->m_MipLevels - 1 - mip;
            region.imageSubresource.baseArrayLayer = 0;
            region.imageSubresource.layerCount     = resourceptr->m_Layers;
        
            region.imageOffset.x                   = 0;
            region.imageOffset.y                   = 0;
            region.imageExtent                     = { w, h, 1 };
 
            const uint32_t size = w * h * 4;
        
            VulkanBuffer copyStagingBuffer(
                resourceptr->m_VulkanState,
                "StagingBuffer",
                size,
                VK_BUFFER_USAGE_TRANSFER_DST_BIT,
                VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT
            );
            
            resourceptr->CopyImageToBuffer(copyStagingBuffer.Get(), { region });
    
            copyStagingBuffer.WriteFromBuffer(reinterpret_cast<void*>(data.data()));
        };
 
        auto hostCopyF = [&](uint32_t w, uint32_t h, int mip, std::vector<unsigned char>& data) {
 
            VkImageToMemoryCopyEXT                           memoryCopy{};
            memoryCopy.sType                               = VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY_EXT;
            memoryCopy.imageSubresource.aspectMask         = VK_IMAGE_ASPECT_COLOR_BIT;
            memoryCopy.imageSubresource.mipLevel           = resourceptr->m_MipLevels - 1 - mip;
            memoryCopy.imageSubresource.baseArrayLayer     = 0;
            memoryCopy.imageSubresource.layerCount         = resourceptr->m_Layers;
            memoryCopy.imageOffset                         = { 0, 0, 0 };
            memoryCopy.imageExtent                         = { w, h, 1 };
            memoryCopy.pHostPointer                        = data.data();
 
            resourceptr->CopyImageToMemoryHost({ memoryCopy });
        };
 
        if (!isCreateCompressTexture)
        {
            return true;
        }
 
        ktxTexture2* ktxTexture = Transcoder::CreateKTX2Texture(resourceptr->m_Width, resourceptr->m_Height);
        for (uint32_t i = 0; i < resourceptr->m_MipLevels; i++)
        {
            const uint32_t w      = std::max(1, resourceptr->m_Width  >> resourceptr->m_MipLevels - 1 - i);
            const uint32_t h      = std::max(1, resourceptr->m_Height >> resourceptr->m_MipLevels - 1 - i);
            const uint32_t size   = w * h * 4;
        
            std::vector<unsigned char> data;
            data.resize(size);
        
            if (hostCopy)
            {
                hostCopyF(w, h, i, data);
            }
            else
            {
                deviceCopyF(w, h, i, data);
            }
        
            Transcoder::WriteData(ktxTexture, resourceptr->m_MipLevels - 1 - i, data.data(), size);
        }
        
        Transcoder::SaveToDisk(ktxTexture, binPath);
 
        return true;
    }

References Spices::defaultTexturePath, and Spices::VulkanRenderBackend::GetState().

Referenced by Load().