Fix for compiler warning

And make it enum class

src/engine/asset/image.cc

@@ -95,13 +95,14 @@ void Image::Copy(const Image& other) {
 }
 
 bool Image::CreateMip(const Image& other) {
-  if (other.width_ <= 1 || other.height_ <= 1 || other.GetFormat() != kRGBA32)
+  if (other.width_ <= 1 || other.height_ <= 1 ||
+      other.GetFormat() != ImageFormat::kRGBA32)
     return false;
 
   // Reduce the dimensions.
   width_ = std::max(other.width_ >> 1, 1);
   height_ = std::max(other.height_ >> 1, 1);
-  format_ = kRGBA32;
+  format_ = ImageFormat::kRGBA32;
   buffer_.reset((uint8_t*)AlignedAlloc(GetSize(), 16));
 
   // If the width isn't perfectly divisable with two, then we end up skewing
@@ -214,21 +215,12 @@ bool Image::Load(const std::string& file_name) {
   return !!buffer_;
 }
 
-size_t Image::GetSize() const {
+bool Image::IsCompressed() const {
-  switch (format_) {
+  return IsCompressedFormat(format_);
-    case kRGBA32:
-      return width_ * height_ * 4;
-    case kDXT1:
-    case kATC:
-      return ((width_ + 3) / 4) * ((height_ + 3) / 4) * 8;
-    case kDXT5:
-    case kATCIA:
-      return ((width_ + 3) / 4) * ((height_ + 3) / 4) * 16;
-    case kETC1:
-      return (width_ * height_ * 4) / 8;
-    default:
-      return 0;
 }
+
+size_t Image::GetSize() const {
+  return GetImageSize(width_, height_, format_);
 }
 
 void Image::ConvertToPow2() {
@@ -275,25 +267,25 @@ bool Image::Compress() {
 
   switch (tc->format()) {
     case TextureCompressor::kFormatATC:
-      format_ = kATC;
+      format_ = ImageFormat::kATC;
       break;
     case TextureCompressor::kFormatATCIA:
-      format_ = kATCIA;
+      format_ = ImageFormat::kATCIA;
       break;
     case TextureCompressor::kFormatDXT1:
-      format_ = kDXT1;
+      format_ = ImageFormat::kDXT1;
       break;
     case TextureCompressor::kFormatDXT5:
-      format_ = kDXT5;
+      format_ = ImageFormat::kDXT5;
       break;
     case TextureCompressor::kFormatETC1:
-      format_ = kETC1;
+      format_ = ImageFormat::kETC1;
       break;
     default:
       return false;
   }
 
-  LOG(0) << "Compressing image. Format: " << format_;
+  LOG(0) << "Compressing image. Format: " << ImageFormatToString(format_);
 
   unsigned compressedSize = GetSize();
   uint8_t* compressedBuffer =

src/engine/asset/image.h

@@ -6,13 +6,12 @@
 
 #include "base/mem.h"
 #include "base/vecmath.h"
+#include "engine/renderer/renderer_types.h"
 
 namespace eng {
 
 class Image {
  public:
-  enum Format { kRGBA32, kDXT1, kDXT5, kETC1, kATC, kATCIA };
-
   Image();
   Image(const Image& other);
   ~Image();
@@ -31,8 +30,8 @@ class Image {
   int GetWidth() const { return width_; }
   int GetHeight() const { return height_; }
 
-  Format GetFormat() const { return format_; }
+  ImageFormat GetFormat() const { return format_; }
-  bool IsCompressed() const { return format_ > kRGBA32; }
+  bool IsCompressed() const;
 
   size_t GetSize() const;
 
@@ -51,7 +50,7 @@ class Image {
   base::AlignedMemPtr<uint8_t[]> buffer_;
   int width_ = 0;
   int height_ = 0;
-  Format format_ = kRGBA32;
+  ImageFormat format_ = ImageFormat::kRGBA32;
 };
 
 }  // namespace eng

src/engine/engine.cc

@@ -102,6 +102,8 @@ void Engine::Initialize() {
 
   thread_pool_.Initialize();
 
+  imgui_backend_.Initialize(IsMobile(), GetRootPath());
+
   platform_->CreateMainWindow();
 
   CreateRendererInternal(RendererType::kVulkan);
@@ -119,8 +121,6 @@ void Engine::Initialize() {
   CreateRenderResources();
   WaitForAsyncWork();
 
-  imgui_backend_.Initialize();
-
   CHECK(game_->Initialize()) << "Failed to initialize the game.";
 }
 

src/engine/imgui_backend.cc

@@ -1,14 +1,10 @@
 #include "engine/imgui_backend.h"
 
 #include "base/log.h"
-#include "engine/asset/image.h"
 #include "engine/asset/shader_source.h"
-#include "engine/engine.h"
 #include "engine/input_event.h"
 #include "engine/platform/asset_file.h"
 #include "engine/renderer/renderer.h"
-#include "engine/renderer/shader.h"
-#include "engine/renderer/texture.h"
 #include "third_party/imgui/imgui.h"
 
 using namespace base;
@@ -19,11 +15,11 @@ namespace {
 const char vertex_description[] = "p2f;t2f;c4b";
 }  // namespace
 
-ImguiBackend::ImguiBackend() : shader_{std::make_unique<Shader>(nullptr)} {}
+ImguiBackend::ImguiBackend() = default;
 
 ImguiBackend::~ImguiBackend() = default;
 
-void ImguiBackend::Initialize() {
+void ImguiBackend::Initialize(bool is_mobile, std::string root_path) {
   IMGUI_CHECKVERSION();
   ImGui::CreateContext();
   ImGui::GetIO().IniFilename = nullptr;
@@ -33,12 +29,11 @@ void ImguiBackend::Initialize() {
 
   size_t buffer_size = 0;
   auto buffer = AssetFile::ReadWholeFile("engine/RobotoMono-Regular.ttf",
-                                         Engine::Get().GetRootPath().c_str(),
+                                         root_path.c_str(), &buffer_size);
-                                         &buffer_size);
   if (buffer) {
     ImFontConfig font_cfg = ImFontConfig();
     font_cfg.FontDataOwnedByAtlas = false;
-    float size_pixels = Engine::Get().IsMobile() ? 64 : 32;
+    float size_pixels = is_mobile ? 64 : 32;
     ImGui::GetIO().Fonts->AddFontFromMemoryTTF(buffer.get(), (int)buffer_size,
                                                size_pixels, &font_cfg);
     ImGui::GetIO().Fonts->Build();
@@ -48,54 +43,45 @@ void ImguiBackend::Initialize() {
 
   // Arbitrary scale-up for mobile devices.
   // TODO: Put some effort into DPI awareness.
-  if (Engine::Get().IsMobile())
+  if (is_mobile)
     ImGui::GetStyle().ScaleAllSizes(2.0f);
-
-  Engine::Get().SetImageSource(
-      "imgui_atlas",
-      []() -> std::unique_ptr<Image> {
-        unsigned char* pixels;
-        int width, height;
-        ImGui::GetIO().Fonts->GetTexDataAsRGBA32(&pixels, &width, &height);
-        LOG(0) << "Font atlas size: " << width << ", " << height;
-        auto image = std::make_unique<Image>();
-        image->Create(width, height);
-        memcpy(image->GetBuffer(), pixels, width * height * 4);
-        return image;
-      },
-      true);
-  Engine::Get().RefreshImage("imgui_atlas");
-  ImGui::GetIO().Fonts->SetTexID(
-      (ImTextureID)(intptr_t)Engine::Get().AcquireTexture("imgui_atlas"));
 }
 
 void ImguiBackend::Shutdown() {
+  ImGui::DestroyContext();
   for (auto& id : geometries_)
     renderer_->DestroyGeometry(id);
   geometries_.clear();
-  ImGui::DestroyContext();
+  renderer_->DestroyTexture(font_atlas_);
-  shader_.reset();
+  renderer_->DestroyShader(shader_);
 }
 
 void ImguiBackend::CreateRenderResources(Renderer* renderer) {
   renderer_ = renderer;
-  shader_->SetRenderer(renderer);
-
   geometries_.clear();
+
+  // Avoid flickering by using the geometries form the last frame if available.
   if (ImGui::GetCurrentContext() && ImGui::GetDrawData())
     Render();
 
+  // Create the shader.
   auto source = std::make_unique<ShaderSource>();
   if (source->Load("engine/imgui.glsl")) {
-    VertexDescription vd;
+    shader_ = renderer_->CreateShader(std::move(source), vertex_description_,
-    if (!ParseVertexDescription(vertex_description, vd)) {
+                                      kPrimitive_Triangles, false);
-      DLOG(0) << "Failed to parse vertex description.";
-    } else {
-      shader_->Create(std::move(source), vd, kPrimitive_Triangles, false);
-    }
   } else {
     LOG(0) << "Could not create imgui shader.";
   }
+
+  // Create a texture for the font atlas.
+  unsigned char* pixels;
+  int width, height;
+  ImGui::GetIO().Fonts->GetTexDataAsRGBA32(&pixels, &width, &height);
+  LOG(0) << "Font atlas size: " << width << ", " << height;
+  font_atlas_ = renderer_->CreateTexture();
+  renderer_->UpdateTexture(font_atlas_, width, height, ImageFormat::kRGBA32,
+                           width * height * 4, pixels);
+  ImGui::GetIO().Fonts->SetTexID((ImTextureID)(intptr_t)font_atlas_);
 }
 
 std::unique_ptr<InputEvent> ImguiBackend::OnInputEvent(
@@ -133,6 +119,7 @@ void ImguiBackend::NewFrame(float delta_time) {
 
 void ImguiBackend::Render() {
   ImGui::Render();
+  // Create a geometry for each draw list and upload the vertex data.
   ImDrawData* draw_data = ImGui::GetDrawData();
   if ((int)geometries_.size() < draw_data->CmdListsCount)
     geometries_.resize(draw_data->CmdListsCount, 0);
@@ -160,9 +147,9 @@ void ImguiBackend::Draw() {
                              draw_data->DisplayPos.x + draw_data->DisplaySize.x,
                              draw_data->DisplayPos.y + draw_data->DisplaySize.y,
                              draw_data->DisplayPos.y);
-  shader_->Activate();
+  renderer_->ActivateShader(shader_);
-  shader_->SetUniform("projection", proj);
+  renderer_->SetUniform(shader_, "projection", proj);
-  shader_->UploadUniforms();
+  renderer_->UploadUniforms(shader_);
 
   for (int n = 0; n < draw_data->CmdListsCount; n++) {
     const ImDrawList* cmd_list = draw_data->CmdLists[n];
@@ -171,7 +158,8 @@ void ImguiBackend::Draw() {
       if (pcmd->ClipRect.z <= pcmd->ClipRect.x ||
           pcmd->ClipRect.w <= pcmd->ClipRect.y)
         continue;
-      reinterpret_cast<Texture*>(pcmd->GetTexID())->Activate(0);
+      uint64_t texture_id = reinterpret_cast<uintptr_t>(pcmd->GetTexID());
+      renderer_->ActivateTexture(texture_id, 0);
       renderer_->SetScissor(int(pcmd->ClipRect.x), int(pcmd->ClipRect.y),
                             int(pcmd->ClipRect.z - pcmd->ClipRect.x),
                             int(pcmd->ClipRect.w - pcmd->ClipRect.y));

src/engine/imgui_backend.h

@@ -9,7 +9,6 @@
 namespace eng {
 
 class InputEvent;
-class Shader;
 class Renderer;
 
 class ImguiBackend {
@@ -17,7 +16,7 @@ class ImguiBackend {
   ImguiBackend();
   ~ImguiBackend();
 
-  void Initialize();
+  void Initialize(bool is_mobile, std::string root_path);
   void Shutdown();
 
   void CreateRenderResources(Renderer* renderer);
@@ -31,7 +30,8 @@ class ImguiBackend {
  private:
   VertexDescription vertex_description_;
   std::vector<uint64_t> geometries_;
-  std::unique_ptr<Shader> shader_;
+  uint64_t shader_ = 0;
+  uint64_t font_atlas_ = 0;
   Renderer* renderer_ = nullptr;
 };
 

src/engine/renderer/opengl/renderer_opengl.cc

@@ -17,6 +17,8 @@
 
 using namespace base;
 
+namespace eng {
+
 namespace {
 
 constexpr GLenum kGlPrimitive[eng::kPrimitive_Max] = {GL_TRIANGLES,
@@ -31,8 +33,6 @@ const std::string kAttributeNames[eng::kAttribType_Max] = {
 
 }  // namespace
 
-namespace eng {
-
 RendererOpenGL::RendererOpenGL(base::Closure context_lost_cb)
     : Renderer(context_lost_cb) {}
 
@@ -251,55 +251,63 @@ uint64_t RendererOpenGL::CreateTexture() {
 
 void RendererOpenGL::UpdateTexture(uint64_t resource_id,
                                    std::unique_ptr<Image> image) {
+  UpdateTexture(resource_id, image->GetWidth(), image->GetHeight(),
+                image->GetFormat(), image->GetSize(), image->GetBuffer());
+}
+
+void RendererOpenGL::UpdateTexture(uint64_t resource_id,
+                                   int width,
+                                   int height,
+                                   ImageFormat format,
+                                   size_t data_size,
+                                   uint8_t* image_data) {
   auto it = textures_.find(resource_id);
   if (it == textures_.end())
     return;
 
   glBindTexture(GL_TEXTURE_2D, it->second);
-  if (image->IsCompressed()) {
+  if (IsCompressedFormat(format)) {
-    GLenum format = 0;
+    GLenum gl_format = 0;
-    switch (image->GetFormat()) {
+    switch (format) {
-      case Image::kDXT1:
+      case ImageFormat::kDXT1:
-        format = GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
+        gl_format = GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
         break;
-      case Image::kDXT5:
+      case ImageFormat::kDXT5:
-        format = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
+        gl_format = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
         break;
-      case Image::kETC1:
+      case ImageFormat::kETC1:
-        format = GL_ETC1_RGB8_OES;
+        gl_format = GL_ETC1_RGB8_OES;
         break;
 #if defined(__ANDROID__)
-      case Image::kATC:
+      case ImageFormat::kATC:
-        format = GL_ATC_RGB_AMD;
+        gl_format = GL_ATC_RGB_AMD;
         break;
-      case Image::kATCIA:
+      case ImageFormat::kATCIA:
-        format = GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD;
+        gl_format = GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD;
         break;
 #endif
       default:
-        NOTREACHED() << "- Unhandled texure format: " << image->GetFormat();
+        NOTREACHED() << "- Unhandled texture format: "
+                     << ImageFormatToString(format);
     }
 
-    glCompressedTexImage2D(GL_TEXTURE_2D, 0, format, image->GetWidth(),
+    glCompressedTexImage2D(GL_TEXTURE_2D, 0, gl_format, width, height, 0,
-                           image->GetHeight(), 0, image->GetSize(),
+                           data_size, image_data);
-                           image->GetBuffer());
 
     // On some devices the first glCompressedTexImage2D call after context-lost
     // returns GL_INVALID_VALUE for some reason.
     GLenum err = glGetError();
     if (err == GL_INVALID_VALUE) {
-      glCompressedTexImage2D(GL_TEXTURE_2D, 0, format, image->GetWidth(),
+      glCompressedTexImage2D(GL_TEXTURE_2D, 0, gl_format, width, height, 0,
-                             image->GetHeight(), 0, image->GetSize(),
+                             data_size, image_data);
-                             image->GetBuffer());
       err = glGetError();
     }
 
     if (err != GL_NO_ERROR)
       LOG(0) << "GL ERROR after glCompressedTexImage2D: " << (int)err;
   } else {
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image->GetWidth(),
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA,
-                 image->GetHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE,
+                 GL_UNSIGNED_BYTE, image_data);
-                 image->GetBuffer());
   }
 }
 

src/engine/renderer/opengl/renderer_opengl.h

@@ -55,6 +55,12 @@ class RendererOpenGL final : public Renderer {
 
   uint64_t CreateTexture() final;
   void UpdateTexture(uint64_t resource_id, std::unique_ptr<Image> image) final;
+  void UpdateTexture(uint64_t resource_id,
+                     int width,
+                     int height,
+                     ImageFormat format,
+                     size_t data_size,
+                     uint8_t* image_data) final;
   void DestroyTexture(uint64_t resource_id) final;
   void ActivateTexture(uint64_t resource_id, uint64_t texture_unit) final;
 

src/engine/renderer/renderer.h

@@ -63,6 +63,12 @@ class Renderer {
   virtual uint64_t CreateTexture() = 0;
   virtual void UpdateTexture(uint64_t resource_id,
                              std::unique_ptr<Image> image) = 0;
+  virtual void UpdateTexture(uint64_t resource_id,
+                             int width,
+                             int height,
+                             ImageFormat format,
+                             size_t data_size,
+                             uint8_t* image_data) = 0;
   virtual void DestroyTexture(uint64_t resource_id) = 0;
   virtual void ActivateTexture(uint64_t resource_id, uint64_t texture_unit) = 0;
 

src/engine/renderer/renderer_types.cc

@@ -14,6 +14,60 @@ const char kLayoutDelimiter[] = ";/ \t";
 
 namespace eng {
 
+const char* ImageFormatToString(ImageFormat format) {
+  switch (format) {
+    case ImageFormat::kRGBA32:
+      return "RGBA32";
+    case ImageFormat::kDXT1:
+      return "DXT1";
+    case ImageFormat::kDXT5:
+      return "DXT5";
+    case ImageFormat::kETC1:
+      return "ETC1";
+    case ImageFormat::kATC:
+      return "ATC";
+    case ImageFormat::kATCIA:
+      return "ATCIA";
+    default:
+      NOTREACHED() << "Unknown image format: " << static_cast<int>(format);
+      return nullptr;
+  }
+}
+
+bool IsCompressedFormat(ImageFormat format) {
+  switch (format) {
+    case ImageFormat::kRGBA32:
+      return false;
+    case ImageFormat::kDXT1:
+    case ImageFormat::kDXT5:
+    case ImageFormat::kETC1:
+    case ImageFormat::kATC:
+    case ImageFormat::kATCIA:
+      return true;
+    default:
+      NOTREACHED() << "Unknown image format: " << static_cast<int>(format);
+      return false;
+  }
+}
+
+size_t GetImageSize(int width, int height, ImageFormat format) {
+  switch (format) {
+    case ImageFormat::kRGBA32:
+      return width * height * 4;
+    case ImageFormat::kDXT1:
+    case ImageFormat::kATC:
+      return ((width + 3) / 4) * ((height + 3) / 4) * 8;
+    case ImageFormat::kDXT5:
+    case ImageFormat::kATCIA:
+      return ((width + 3) / 4) * ((height + 3) / 4) * 16;
+    case ImageFormat::kETC1:
+      return (width * height * 4) / 8;
+    default:
+      NOTREACHED() << "Unknown image format: " << static_cast<int>(format);
+      return 0;
+  }
+}
+
 size_t GetVertexSize(const VertexDescription& vertex_description) {
   size_t size = 0;
   for (auto& attr : vertex_description) {

src/engine/renderer/renderer_types.h

@@ -7,6 +7,8 @@
 
 namespace eng {
 
+enum class ImageFormat { kRGBA32, kDXT1, kDXT5, kETC1, kATC, kATCIA };
+
 enum Primitive {
   kPrimitive_Invalid = -1,
   kPrimitive_Triangles,
@@ -41,7 +43,14 @@ using DataTypeSize = size_t;
 using VertexDescription =
     std::vector<std::tuple<AttribType, DataType, ElementCount, DataTypeSize>>;
 
+const char* ImageFormatToString(ImageFormat format);
+
+bool IsCompressedFormat(ImageFormat format);
+
+size_t GetImageSize(int width, int height, ImageFormat format);
+
 size_t GetVertexSize(const VertexDescription& vertex_description);
+
 size_t GetIndexSize(DataType index_description);
 
 bool ParseVertexDescription(const std::string& vd_str, VertexDescription& out);

src/engine/renderer/vulkan/renderer_vulkan.cc

@@ -23,6 +23,8 @@
 
 using namespace base;
 
+namespace eng {
+
 namespace {
 
 // Synchronized with glslang/StandAlone/ResourceLimits.cpp which was removed
@@ -148,12 +150,12 @@ using VertexInputDescription =
     std::pair<std::vector<VkVertexInputBindingDescription>,
               std::vector<VkVertexInputAttributeDescription>>;
 
-constexpr VkPrimitiveTopology kVkPrimitiveType[eng::kPrimitive_Max] = {
+constexpr VkPrimitiveTopology kVkPrimitiveType[kPrimitive_Max] = {
     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP,
 };
 
-constexpr VkFormat kVkDataType[eng::kDataType_Max][4] = {
+constexpr VkFormat kVkDataType[kDataType_Max][4] = {
     {
         VK_FORMAT_R8_UNORM,
         VK_FORMAT_R8G8_UNORM,
@@ -277,8 +279,7 @@ std::vector<uint8_t> CompileGlsl(EShLanguage stage,
   return ret;
 }
 
-VertexInputDescription GetVertexInputDescription(
+VertexInputDescription GetVertexInputDescription(const VertexDescription& vd) {
-    const eng::VertexDescription& vd) {
   unsigned vertex_offset = 0;
   unsigned location = 0;
 
@@ -305,13 +306,13 @@ VertexInputDescription GetVertexInputDescription(
   return std::make_pair(std::move(bindings), std::move(attributes));
 }
 
-VkIndexType GetIndexType(eng::DataType data_type) {
+VkIndexType GetIndexType(DataType data_type) {
   switch (data_type) {
-    case eng::kDataType_Invalid:
+    case kDataType_Invalid:
       return VK_INDEX_TYPE_NONE_KHR;
-    case eng::kDataType_UInt:
+    case kDataType_UInt:
       return VK_INDEX_TYPE_UINT32;
-    case eng::kDataType_UShort:
+    case kDataType_UShort:
       return VK_INDEX_TYPE_UINT16;
     default:
       break;
@@ -320,21 +321,21 @@ VkIndexType GetIndexType(eng::DataType data_type) {
   return VK_INDEX_TYPE_NONE_KHR;
 }
 
-VkFormat GetImageFormat(eng::Image::Format format) {
+VkFormat GetImageFormat(ImageFormat format) {
   switch (format) {
-    case eng::Image::kRGBA32:
+    case ImageFormat::kRGBA32:
       return VK_FORMAT_R8G8B8A8_UNORM;
-    case eng::Image::kDXT1:
+    case ImageFormat::kDXT1:
       return VK_FORMAT_BC1_RGB_UNORM_BLOCK;
-    case eng::Image::kDXT5:
+    case ImageFormat::kDXT5:
       return VK_FORMAT_BC3_UNORM_BLOCK;
-    case eng::Image::kETC1:
+    case ImageFormat::kETC1:
-    case eng::Image::kATC:
+    case ImageFormat::kATC:
-    case eng::Image::kATCIA:
+    case ImageFormat::kATCIA:
     default:
       break;
   }
-  NOTREACHED() << "Invalid format: " << format;
+  NOTREACHED() << "Invalid format: " << ImageFormatToString(format);
   return VK_FORMAT_R8G8B8A8_UNORM;
 }
 
@@ -371,8 +372,6 @@ std::pair<int, int> GetNumBlocksForImageFormat(VkFormat format,
 
 }  // namespace
 
-namespace eng {
-
 RendererVulkan::RendererVulkan(base::Closure context_lost_cb)
     : Renderer(context_lost_cb) {}
 
@@ -559,16 +558,27 @@ uint64_t RendererVulkan::CreateTexture() {
 
 void RendererVulkan::UpdateTexture(uint64_t resource_id,
                                    std::unique_ptr<Image> image) {
+  UpdateTexture(resource_id, image->GetWidth(), image->GetHeight(),
+                image->GetFormat(), image->GetSize(), image->GetBuffer());
+  task_runner_.Delete(HERE, std::move(image));
+  semaphore_.release();
+}
+
+void RendererVulkan::UpdateTexture(uint64_t resource_id,
+                                   int width,
+                                   int height,
+                                   ImageFormat format,
+                                   size_t data_size,
+                                   uint8_t* image_data) {
   auto it = textures_.find(resource_id);
   if (it == textures_.end())
     return;
 
   VkImageLayout old_layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
-  VkFormat format = GetImageFormat(image->GetFormat());
+  VkFormat vk_format = GetImageFormat(format);
 
   if (it->second.view != VK_NULL_HANDLE &&
-      (it->second.width != image->GetWidth() ||
+      (it->second.width != width || it->second.height != height)) {
-       it->second.height != image->GetHeight())) {
     // Size mismatch. Recreate the texture.
     FreeImage(std::move(it->second.image), it->second.view,
               std::move(it->second.desc_set));
@@ -577,12 +587,12 @@ void RendererVulkan::UpdateTexture(uint64_t resource_id,
 
   if (it->second.view == VK_NULL_HANDLE) {
     AllocateImage(it->second.image, it->second.view, it->second.desc_set,
-                  format, image->GetWidth(), image->GetHeight(),
+                  vk_format, width, height,
                   VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT,
                   VMA_MEMORY_USAGE_GPU_ONLY);
     old_layout = VK_IMAGE_LAYOUT_UNDEFINED;
-    it->second.width = image->GetWidth();
+    it->second.width = width;
-    it->second.height = image->GetHeight();
+    it->second.height = height;
   }
 
   task_runner_.PostTask(
@@ -592,10 +602,9 @@ void RendererVulkan::UpdateTexture(uint64_t resource_id,
                 VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
                 VK_PIPELINE_STAGE_TRANSFER_BIT, 0, VK_ACCESS_TRANSFER_WRITE_BIT,
                 old_layout, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL));
-  task_runner_.PostTask(
+  task_runner_.PostTask(HERE, std::bind(&RendererVulkan::UpdateImage, this,
-      HERE, std::bind(&RendererVulkan::UpdateImage, this,
+                                        std::get<0>(it->second.image),
-                      std::get<0>(it->second.image), format, image->GetBuffer(),
+                                        vk_format, image_data, width, height));
-                      image->GetWidth(), image->GetHeight()));
   task_runner_.PostTask(
       HERE,
       std::bind(&RendererVulkan::ImageMemoryBarrier, this,
@@ -606,7 +615,6 @@ void RendererVulkan::UpdateTexture(uint64_t resource_id,
                 0, VK_ACCESS_SHADER_READ_BIT,
                 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL));
-  task_runner_.Delete(HERE, std::move(image));
   semaphore_.release();
 }
 

src/engine/renderer/vulkan/renderer_vulkan.h

@@ -55,6 +55,12 @@ class RendererVulkan final : public Renderer {
 
   uint64_t CreateTexture() final;
   void UpdateTexture(uint64_t resource_id, std::unique_ptr<Image> image) final;
+  void UpdateTexture(uint64_t resource_id,
+                     int width,
+                     int height,
+                     ImageFormat format,
+                     size_t data_size,
+                     uint8_t* image_data) final;
   void DestroyTexture(uint64_t resource_id) final;
   void ActivateTexture(uint64_t resource_id, uint64_t texture_unit) final;