Function PrepareTextureForUploading

engine/graphics/src/vulkan/graphics_vulkan.cpp:5177–5260

    }

    static void PrepareTextureForUploading(VulkanContext* context, VulkanTexture* texture, const TextureParams& params)
    {
        VkFormat vk_format = GetVulkanFormatFromTextureFormat(params.m_Format);
        if (!params.m_SubUpdate && params.m_MipMap == 0)
        {
            if (texture->m_Format != vk_format ||
                texture->m_Base.m_Width != params.m_Width ||
                texture->m_Base.m_Height != params.m_Height ||
                (IsTextureType3D(texture->m_Base.m_Type) && (texture->m_Base.m_Depth != params.m_Depth)))
            {
                DestroyResourceDeferred(context, texture);
                texture->m_Format = vk_format;
                texture->m_Base.m_Width  = params.m_Width;
                texture->m_Base.m_Height = params.m_Height;
                texture->m_Base.m_Depth  = params.m_Depth;

                // Note:
                // If the texture has requested mipmaps and we need to recreate the texture, make sure to allocate enough mipmaps.
                // For vulkan this means that we can't cap a texture to a specific mipmap count since the engine expects
                // that setting texture data works like the OpenGL backend where we set the mipmap count to zero and then
                // update the mipmap count based on the params. If we recreate the texture when that is detected (i.e we have too few mipmaps in the texture)
                // we will lose all the data that was previously uploaded. We could copy that data, but for now this is the easiest way of dealing with this..

                if (texture->m_Base.m_MipMapCount > 1)
                {
                    texture->m_Base.m_MipMapCount = (uint8_t) GetMipmapCount(dmMath::Max(texture->m_Base.m_Width, texture->m_Base.m_Height));
                }
            }
        }
        // If texture hasn't been used yet or if it has been changed
        if (texture->m_Destroyed || texture->m_Handle.m_Image == VK_NULL_HANDLE)
        {
            VkImageTiling vk_image_tiling           = VK_IMAGE_TILING_OPTIMAL;
            VkImageUsageFlags vk_usage_flags        = VK_IMAGE_USAGE_TRANSFER_DST_BIT;
            VkFormatFeatureFlags vk_format_features = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT;
            VkMemoryPropertyFlags vk_memory_type    = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
            uint16_t tex_depth                      = dmMath::Max(texture->m_Base.m_Depth, params.m_Depth);
            uint8_t tex_layer_count                 = dmMath::Max(texture->m_LayerCount, params.m_LayerCount);
            TextureFormat format_orig               = params.m_Format;
            if (format_orig == TEXTURE_FORMAT_RGB)
            {
                vk_format = VK_FORMAT_R8G8B8A8_UNORM;
            }

            vk_usage_flags |= texture->m_UsageFlags;

            if (IsTextureMemoryless(texture))
            {
                vk_memory_type |= VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT;
            }

            // Check this format for optimal layout support
            if (GetSupportedTilingFormat(context->m_PhysicalDevice.m_Device, &vk_format, 1, vk_image_tiling, vk_format_features) == VK_FORMAT_UNDEFINED)
            {
                // Linear doesn't support mipmapping (for MoltenVK only?)
                vk_image_tiling        = VK_IMAGE_TILING_LINEAR;
                texture->m_Base.m_MipMapCount = 1;
            }