src/engine/engine.cc

@@ -37,14 +37,20 @@ Engine* Engine::singleton = nullptr;
 
 Engine::Engine(Platform* platform)
     : platform_(platform),
+#if (USE_VULKAN_RENDERER == 1)
+      renderer_{std::make_unique<RendererVulkan>()},
+#else
+      renderer_{std::make_unique<RendererOpenGL>()},
+#endif
       audio_mixer_{std::make_unique<AudioMixer>()},
-      quad_{std::make_unique<Geometry>(nullptr)},
+      quad_{CreateRenderResource<Geometry>()},
-      pass_through_shader_{std::make_unique<Shader>(nullptr)},
+      pass_through_shader_{CreateRenderResource<Shader>()},
-      solid_shader_{std::make_unique<Shader>(nullptr)} {
+      solid_shader_{CreateRenderResource<Shader>()} {
   DCHECK(!singleton);
   singleton = this;
 
   platform_->SetObserver(this);
+  renderer_->SetContextLostCB(std::bind(&Engine::ContextLost, this));
 
   stats_ = std::make_unique<ImageQuad>();
 }
@@ -68,7 +74,7 @@ Engine& Engine::Get() {
 }
 
 void Engine::Run() {
-  Initialize();
+  CHECK(Initialize()) << "Failed to initialize the engine.";
 
   timer_.Reset();
   float accumulator = 0.0;
@@ -84,12 +90,14 @@ void Engine::Run() {
     // Subdivide the frame time using fixed time steps.
     while (accumulator >= time_step_) {
       TaskRunner::GetThreadLocalTaskRunner()->SingleConsumerRun();
+
       platform_->Update();
       Update(time_step_);
-      accumulator -= time_step_;
 
-      if (platform_->should_exit())
+      if (platform_->should_exit()) {
         return;
+      }
+      accumulator -= time_step_;
     };
 
     // Calculate frame fraction from remainder of the frame time.
@@ -97,12 +105,10 @@ void Engine::Run() {
   }
 }
 
-void Engine::Initialize() {
+bool Engine::Initialize() {
-  LOG << "Initializing engine.";
-
   thread_pool_.Initialize();
 
-  CreateRenderer(true);
+  InitializeRenderer();
 
   // Normalize viewport.
   if (GetScreenWidth() > GetScreenHeight()) {
@@ -119,16 +125,29 @@ void Engine::Initialize() {
 
   LOG << "image scale factor: " << GetImageScaleFactor();
 
+  CreateTextureCompressors();
+
   system_font_ = std::make_unique<Font>();
   system_font_->Load("engine/RobotoMono-Regular.ttf");
 
+  if (!CreateRenderResources())
+    return false;
+
   SetImageSource("stats_tex", std::bind(&Engine::PrintStats, this));
   stats_->SetZOrder(std::numeric_limits<int>::max());
 
   game_ = GameFactoryBase::CreateGame("");
-  CHECK(game_) << "No game found to run.";
+  if (!game_) {
+    LOG << "No game found to run.";
+    return false;
+  }
 
-  CHECK(game_->Initialize()) << "Failed to initialize the game.";
+  if (!game_->Initialize()) {
+    LOG << "Failed to initialize the game.";
+    return false;
+  }
+
+  return true;
 }
 
 void Engine::Update(float delta_time) {
@@ -197,30 +216,26 @@ void Engine::RemoveAnimator(Animator* animator) {
   }
 }
 
-void Engine::CreateRenderer(bool vulkan) {
+void Engine::SwitchRenderer(bool vulkan) {
-  if ((dynamic_cast<RendererVulkan*>(renderer_.get()) && vulkan) ||
+  // Renderer* new_renderer = platform_->SwitchRenderer(vulkan);
-      (dynamic_cast<RendererOpenGL*>(renderer_.get()) && !vulkan))
+  // if (new_renderer == renderer_)
-    return;
+  //   return;
 
-  if (vulkan)
+  // renderer_ = new_renderer;
-    renderer_ =
+  // renderer_->SetContextLostCB(std::bind(&Engine::ContextLost, this));
-        std::make_unique<RendererVulkan>(std::bind(&Engine::ContextLost, this));
+  // CreateTextureCompressors();
-  else
-    renderer_ =
-        std::make_unique<RendererOpenGL>(std::bind(&Engine::ContextLost, this));
 
-  bool result = renderer_->Initialize(platform_);
+  // for (auto& t : textures_)
-  if (!result && vulkan) {
+  //   t.second.texture->SetRenderer(renderer_);
-    LOG << "Failed to initialize " << renderer_->GetDebugName() << " renderer.";
-    LOG << "Fallback to OpenGL renderer.";
-    CreateRenderer(false);
-    return;
-  }
-  CHECK(result) << "Failed to initialize " << renderer_->GetDebugName()
-                << " renderer.";
 
-  CreateTextureCompressors();
+  // for (auto& s : shaders_)
-  ContextLost();
+  //   s.second.shader->SetRenderer(renderer_);
+
+  // quad_->SetRenderer(renderer_);
+  // pass_through_shader_->SetRenderer(renderer_);
+  // solid_shader_->SetRenderer(renderer_);
+
+  // ContextLost();
 }
 
 void Engine::Exit() {
@@ -479,7 +494,7 @@ bool Engine::IsMobile() const {
 }
 
 void Engine::OnWindowCreated() {
-  renderer_->Initialize(platform_);
+  InitializeRenderer();
 }
 
 void Engine::OnWindowDestroyed() {
@@ -490,7 +505,7 @@ void Engine::OnWindowResized(int width, int height) {
   if (width != renderer_->screen_width() ||
       height != renderer_->screen_height()) {
     renderer_->Shutdown();
-    renderer_->Initialize(platform_);
+    InitializeRenderer();
   }
 }
 
@@ -545,6 +560,17 @@ void Engine::AddInputEvent(std::unique_ptr<InputEvent> event) {
   input_queue_.push_back(std::move(event));
 }
 
+void Engine::InitializeRenderer() {
+  bool res;
+#if defined(__ANDROID__)
+  res = renderer_->Initialize(platform_->GetWindow());
+#elif defined(__linux__)
+  res = renderer_->Initialize(platform_->GetDisplay(), platform_->GetWindow());
+#endif
+  CHECK(res) << "Failed to initialize " << renderer_->GetDebugName()
+             << " renderer.";
+}
+
 void Engine::CreateTextureCompressors() {
   tex_comp_alpha_.reset();
   tex_comp_opaque_.reset();
@@ -568,10 +594,24 @@ void Engine::CreateTextureCompressors() {
 }
 
 void Engine::ContextLost() {
-  quad_->SetRenderer(renderer_.get());
+  CreateRenderResources();
-  pass_through_shader_->SetRenderer(renderer_.get());
-  solid_shader_->SetRenderer(renderer_.get());
 
+  for (auto& t : textures_) {
+    t.second.texture->Destroy();
+    RefreshImage(t.first);
+  }
+
+  for (auto& s : shaders_) {
+    auto source = std::make_unique<ShaderSource>();
+    if (source->Load(s.second.file_name))
+      s.second.shader->Create(std::move(source), quad_->vertex_description(),
+                              quad_->primitive(), false);
+  }
+
+  game_->ContextLost();
+}
+
+bool Engine::CreateRenderResources() {
   // This creates a normalized unit sized quad.
   static const char vertex_description[] = "p2f;t2f";
   static const float vertices[] = {
@@ -586,37 +626,23 @@ void Engine::ContextLost() {
 
   // Create the shader we can reuse for texture rendering.
   auto source = std::make_unique<ShaderSource>();
-  if (source->Load("engine/pass_through.glsl")) {
+  if (!source->Load("engine/pass_through.glsl")) {
+    LOG << "Could not create pass through shader.";
+    return false;
+  }
   pass_through_shader_->Create(std::move(source), quad_->vertex_description(),
                                quad_->primitive(), false);
-  } else {
-    LOG << "Could not create pass through shader.";
-  }
 
   // Create the shader we can reuse for solid rendering.
   source = std::make_unique<ShaderSource>();
-  if (source->Load("engine/solid.glsl")) {
+  if (!source->Load("engine/solid.glsl")) {
+    LOG << "Could not create solid shader.";
+    return false;
+  }
   solid_shader_->Create(std::move(source), quad_->vertex_description(),
                         quad_->primitive(), false);
-  } else {
-    LOG << "Could not create solid shader.";
-  }
 
-  for (auto& t : textures_) {
+  return true;
-    t.second.texture->SetRenderer(renderer_.get());
-    RefreshImage(t.first);
-  }
-
-  for (auto& s : shaders_) {
-    s.second.shader->SetRenderer(renderer_.get());
-    auto source = std::make_unique<ShaderSource>();
-    if (source->Load(s.second.file_name))
-      s.second.shader->Create(std::move(source), quad_->vertex_description(),
-                              quad_->primitive(), false);
-  }
-
-  if (game_)
-    game_->ContextLost();
 }
 
 void Engine::SetSatsVisible(bool visible) {

src/engine/engine.h

@@ -49,7 +49,7 @@ class Engine : public PlatformObserver {
   void AddAnimator(Animator* animator);
   void RemoveAnimator(Animator* animator);
 
-  void CreateRenderer(bool vulkan);
+  void SwitchRenderer(bool vulkan);
 
   void Exit();
 
@@ -218,7 +218,7 @@ class Engine : public PlatformObserver {
   base::Timer timer_;
   base::Randomf random_;
 
-  void Initialize();
+  bool Initialize();
 
   void Update(float delta_time);
   void Draw(float frame_frac);
@@ -231,10 +231,14 @@ class Engine : public PlatformObserver {
   void GainedFocus(bool from_interstitial_ad) final;
   void AddInputEvent(std::unique_ptr<InputEvent> event) final;
 
+  void InitializeRenderer();
+
   void CreateTextureCompressors();
 
   void ContextLost();
 
+  bool CreateRenderResources();
+
   void SetSatsVisible(bool visible);
   std::unique_ptr<Image> PrintStats();
 

src/engine/platform/platform_android.cc

@@ -338,8 +338,6 @@ void Platform::HandleCmd(android_app* app, int32_t cmd) {
 }
 
 Platform::Platform(android_app* app) {
-  LOG << "Initializing platform.";
-
   app_ = app;
   mobile_device_ = true;
 

src/engine/platform/platform_linux.cc

@@ -14,8 +14,6 @@ namespace eng {
 void KaliberMain(Platform* platform);
 
 Platform::Platform() {
-  LOG << "Initializing platform.";
-
   root_path_ = "../../";
   LOG << "Root path: " << root_path_.c_str();
 

src/engine/renderer/opengl/renderer_opengl.cc

@@ -40,9 +40,8 @@ const std::string kAttributeNames[eng::kAttribType_Max] = {
 namespace eng {
 
 #ifdef THREADED_RENDERING
-RendererOpenGL::RendererOpenGL(base::Closure context_lost_cb)
+RendererOpenGL::RendererOpenGL()
-    : Renderer(context_lost_cb),
+    : main_thread_task_runner_(TaskRunner::GetThreadLocalTaskRunner()) {}
-      main_thread_task_runner_(TaskRunner::GetThreadLocalTaskRunner()) {}
 #else
 RendererOpenGL::RendererOpenGL() = default;
 #endif  // THREADED_RENDERING

src/engine/renderer/opengl/renderer_opengl.h

@@ -37,10 +37,15 @@ struct RenderCommand;
 
 class RendererOpenGL final : public Renderer {
  public:
-  RendererOpenGL(base::Closure context_lost_cb);
+  RendererOpenGL();
   ~RendererOpenGL() final;
 
-  virtual bool Initialize(Platform* platform) final;
+#if defined(__ANDROID__)
+  bool Initialize(ANativeWindow* window) final;
+#elif defined(__linux__)
+  bool Initialize(Display* display, Window window) final;
+#endif
+
   void Shutdown() final;
 
   uint64_t CreateGeometry(std::unique_ptr<Mesh> mesh) final;

src/engine/renderer/opengl/renderer_opengl_android.cc

@@ -3,15 +3,14 @@
 #include <android/native_window.h>
 
 #include "base/log.h"
-#include "engine/platform/platform.h"
 #include "third_party/android/GLContext.h"
 
 namespace eng {
 
-bool RendererOpenGL::Initialize(Platform* platform) {
+bool RendererOpenGL::Initialize(ANativeWindow* window) {
   LOG << "Initializing renderer.";
 
-  window_ = platform->GetWindow();
+  window_ = window;
   return StartRenderThread();
 }
 

src/engine/renderer/opengl/renderer_opengl_linux.cc

@@ -1,15 +1,14 @@
 #include "engine/renderer/opengl/renderer_opengl.h"
 
 #include "base/log.h"
-#include "engine/platform/platform.h"
 
 namespace eng {
 
-bool RendererOpenGL::Initialize(Platform* platform) {
+bool RendererOpenGL::Initialize(Display* display, Window window) {
   LOG << "Initializing renderer.";
 
-  display_ = platform->GetDisplay();
+  display_ = display;
-  window_ = platform->GetWindow();
+  window_ = window;
 
   XWindowAttributes xwa;
   XGetWindowAttributes(display_, window_, &xwa);
@@ -25,7 +24,8 @@ bool RendererOpenGL::InitInternal() {
   GLint glx_attributes[] = {GLX_RGBA, GLX_DEPTH_SIZE, 24, GLX_DOUBLEBUFFER,
                             None};
   XVisualInfo* visual_info = glXChooseVisual(display_, 0, glx_attributes);
-  glx_context_ = glXCreateContext(display_, visual_info, NULL, GL_TRUE);
+  glx_context_ =
+      glXCreateContext(display_, visual_info, NULL, GL_TRUE);
   if (!glx_context_) {
     LOG << "Couldn't create the glx context.";
     return false;

src/engine/renderer/renderer.h

@@ -4,26 +4,40 @@
 #include <memory>
 #include <string>
 
+#if defined(__linux__) && !defined(__ANDROID__)
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#endif
+
 #include "base/closure.h"
 #include "base/vecmath.h"
 #include "engine/renderer/renderer_types.h"
 
+#if defined(__ANDROID__)
+struct ANativeWindow;
+#endif
+
 namespace eng {
 
 class Image;
 class ShaderSource;
 class Mesh;
-class Platform;
 
 class Renderer {
  public:
   const unsigned kInvalidId = 0;
 
-  Renderer(base::Closure context_lost_cb)
+  Renderer() = default;
-      : context_lost_cb_{std::move(context_lost_cb)} {}
   virtual ~Renderer() = default;
 
-  virtual bool Initialize(Platform* platform) = 0;
+  void SetContextLostCB(base::Closure cb) { context_lost_cb_ = std::move(cb); }
+
+#if defined(__ANDROID__)
+  virtual bool Initialize(ANativeWindow* window) = 0;
+#elif defined(__linux__)
+  virtual bool Initialize(Display* display, Window window) = 0;
+#endif
+
   virtual void Shutdown() = 0;
 
   virtual uint64_t CreateGeometry(std::unique_ptr<Mesh> mesh) = 0;

src/engine/renderer/vulkan/renderer_vulkan.cc

@@ -370,8 +370,7 @@ std::pair<int, int> GetNumBlocksForImageFormat(VkFormat format,
 
 namespace eng {
 
-RendererVulkan::RendererVulkan(base::Closure context_lost_cb)
+RendererVulkan::RendererVulkan() = default;
-    : Renderer(context_lost_cb) {}
 
 RendererVulkan::~RendererVulkan() {
   Shutdown();

src/engine/renderer/vulkan/renderer_vulkan.h

@@ -18,12 +18,19 @@
 
 namespace eng {
 
+class Image;
+
 class RendererVulkan final : public Renderer {
  public:
-  RendererVulkan(base::Closure context_lost_cb);
+  RendererVulkan();
   ~RendererVulkan() final;
 
-  virtual bool Initialize(Platform* platform) final;
+#if defined(__ANDROID__)
+  bool Initialize(ANativeWindow* window) final;
+#elif defined(__linux__)
+  bool Initialize(Display* display, Window window) final;
+#endif
+
   void Shutdown() final;
 
   uint64_t CreateGeometry(std::unique_ptr<Mesh> mesh) final;

src/engine/renderer/vulkan/renderer_vulkan_android.cc

@@ -3,22 +3,20 @@
 #include <android/native_window.h>
 
 #include "base/log.h"
-#include "engine/platform/platform.h"
 
 namespace eng {
 
-bool RendererVulkan::Initialize(Platform* platform) {
+bool RendererVulkan::Initialize(ANativeWindow* window) {
   LOG << "Initializing renderer.";
 
-  screen_width_ = ANativeWindow_getWidth(platform->GetWindow());
+  screen_width_ = ANativeWindow_getWidth(window);
-  screen_height_ = ANativeWindow_getHeight(platform->GetWindow());
+  screen_height_ = ANativeWindow_getHeight(window);
 
   if (!context_.Initialize()) {
     LOG << "Failed to initialize Vulkan context.";
     return false;
   }
-  if (!context_.CreateWindow(platform->GetWindow(), screen_width_,
+  if (!context_.CreateWindow(window, screen_width_, screen_height_)) {
-                             screen_height_)) {
     LOG << "Vulkan context failed to create window.";
     return false;
   }

src/engine/renderer/vulkan/renderer_vulkan_linux.cc

@@ -1,15 +1,14 @@
 #include "engine/renderer/vulkan/renderer_vulkan.h"
 
 #include "base/log.h"
-#include "engine/platform/platform.h"
 
 namespace eng {
 
-bool RendererVulkan::Initialize(Platform* platform) {
+bool RendererVulkan::Initialize(Display* display, Window window) {
   LOG << "Initializing renderer.";
 
   XWindowAttributes xwa;
-  XGetWindowAttributes(platform->GetDisplay(), platform->GetWindow(), &xwa);
+  XGetWindowAttributes(display, window, &xwa);
   screen_width_ = xwa.width;
   screen_height_ = xwa.height;
 
@@ -17,8 +16,7 @@ bool RendererVulkan::Initialize(Platform* platform) {
     LOG << "Failed to initialize Vulkan context.";
     return false;
   }
-  if (!context_.CreateWindow(platform->GetDisplay(), platform->GetWindow(),
+  if (!context_.CreateWindow(display, window, screen_width_, screen_height_)) {
-                             screen_width_, screen_height_)) {
     LOG << "Vulkan context failed to create window.";
     return false;
   }