Function VulkanSetTextureInternal

engine/graphics/src/vulkan/graphics_vulkan.cpp:4777–4949

    }

    static void VulkanSetTextureInternal(VulkanContext* context, VulkanTexture* texture, const TextureParams& params)
    {
        // Same as graphics_opengl.cpp
        switch (params.m_Format)
        {
            case TEXTURE_FORMAT_DEPTH:
            case TEXTURE_FORMAT_STENCIL:
                dmLogError("Unable to upload texture data, unsupported type (%s).", GetTextureFormatLiteral(params.m_Format));
                return;
            default:break;
        }

        assert(params.m_Width  <= context->m_PhysicalDevice.m_Properties.limits.maxImageDimension2D);
        assert(params.m_Height <= context->m_PhysicalDevice.m_Properties.limits.maxImageDimension2D);

        if (texture->m_Base.m_MipMapCount == 1 && params.m_MipMap > 0)
        {
            return;
        }

        TextureFormat format_orig   = params.m_Format;
        uint8_t tex_layer_count     = dmMath::Max(texture->m_LayerCount, params.m_LayerCount);
        uint16_t tex_depth          = dmMath::Max(texture->m_Base.m_Depth, params.m_Depth);
        uint8_t tex_bpp             = GetTextureFormatBitsPerPixel(params.m_Format);
        size_t tex_data_size_bpp    = params.m_DataSize * tex_layer_count * 8; // Convert into bits
        void*  tex_data_ptr         = (void*)params.m_Data;
        VkFormat vk_format          = GetVulkanFormatFromTextureFormat(params.m_Format);

        if (vk_format == VK_FORMAT_UNDEFINED)
        {
            dmLogError("Unable to upload texture data, unsupported type (%s).", GetTextureFormatLiteral(format_orig));
            return;
        }

        // For future reference, we could validate ASTC buffer sizes by using these calculations:
        // https://registry.khronos.org/webgl/extensions/WEBGL_compressed_texture_astc/

        LogicalDevice& logical_device       = context->m_LogicalDevice;
        VkPhysicalDevice vk_physical_device = context->m_PhysicalDevice.m_Device;

        // Note: There's no RGB support in Vulkan. We have to expand this to four channels
        // TODO: Can we use R11G11B10 somehow?
        uint8_t* temp_data = 0;
        if (format_orig == TEXTURE_FORMAT_RGB)
        {
            uint32_t data_pixel_count = params.m_Width * params.m_Height * tex_layer_count;
            temp_data                 = new uint8_t[data_pixel_count * 4]; // RGBA => 4 bytes per pixel

            RepackRGBToRGBA(data_pixel_count, (uint8_t*) tex_data_ptr, temp_data);
            vk_format     = VK_FORMAT_R8G8B8A8_UNORM;
            tex_data_ptr  = temp_data;
            tex_bpp       = 32;
        }

        // In cases where we just want to clear the texture we don't have a valid data or datasize, so we need to infer it.
        // This will NOT work for clearing compressed texture formats, but I don't think that is a case we can support anyway.
        tex_data_size_bpp         = tex_bpp * params.m_Width * params.m_Height * tex_depth * tex_layer_count;
        texture->m_Base.m_Format = params.m_Format;