Function AsyncProcessCallback

engine/graphics/src/vulkan/graphics_vulkan.cpp:5058–5160

    }

    static int AsyncProcessCallback(HJobContext, HJob job, void* _context, void* data)
    {
        VulkanContext* context     = (VulkanContext*) _context;
        uint16_t param_array_index = (uint16_t) (size_t) data;
        SetTextureAsyncParams ap   = GetSetTextureAsyncParams(context->m_SetTextureAsyncState, param_array_index);

        if (dmAtomicGet32(&context->m_DeleteContextRequested))
        {
            return 0;
        }

        VulkanTexture* tex;
        {
            DM_MUTEX_SCOPED_LOCK(context->m_BaseContext.m_AssetHandleContainerMutex);
            tex = GetAssetFromContainer<VulkanTexture>(context->m_BaseContext.m_AssetHandleContainer, ap.m_Texture);
        }

        // Texture might have been deleted before the job thread has started processing this job.
        if (tex == NULL)
        {
            return 0;
        }

        // Async texture uploading
        {
            VkCommandBuffer cmd_buffer = BeginSingleTimeCommands(context->m_LogicalDevice.m_Device, context->m_LogicalDevice.m_CommandPoolWorker);

            uint8_t tex_layer_count   = dmMath::Max(tex->m_LayerCount, ap.m_Params.m_LayerCount);
            uint16_t tex_depth        = dmMath::Max((uint16_t) 1, dmMath::Max(tex->m_Base.m_Depth, ap.m_Params.m_Depth));
            TextureFormat format_orig = ap.m_Params.m_Format;
            void*  tex_data_ptr       = (void*) ap.m_Params.m_Data;
            uint8_t* temp_data        = 0;
            bool is_memoryless        = IsTextureMemoryless(tex);

            uint32_t tex_data_size;
            if (IsTextureFormatASTC(ap.m_Params.m_Format))
            {
                tex_data_size = ap.m_Params.m_DataSize * tex_layer_count;
            }
            else
            {
                uint32_t tex_bpp           = GetTextureFormatBitsPerPixel(ap.m_Params.m_Format);
                uint32_t tex_data_size_bpp = tex_bpp * ap.m_Params.m_Width * ap.m_Params.m_Height * tex_depth * tex_layer_count;
                tex_data_size = (uint32_t) ceil((float) tex_data_size_bpp / 8.0f);
            }

            DeviceBuffer stage_buffer(VK_BUFFER_USAGE_TRANSFER_SRC_BIT);

            if (!is_memoryless)
            {
                // Note: There's no RGB support in Vulkan. We have to expand this to four channels
                // TODO: Can we use R11G11B10 somehow?
                if (format_orig == TEXTURE_FORMAT_RGB)
                {
                    uint32_t data_pixel_count = ap.m_Params.m_Width * ap.m_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);