Wire up the OpenGL renderer.

Author: chinmaygarde

src/flutter_application.cc

@@ -58,23 +58,35 @@ static std::string GetICUDataPath() {
   return icu_path;
 }
 
-FlutterApplication::FlutterApplication() {
+FlutterApplication::FlutterApplication(
+    const std::vector<std::string>& command_line_args,
+    RenderDelegate& render_delegate)
+    : render_delegate_(render_delegate) {
   FlutterRendererConfig config = {};
-  config.type = kSoftware;
-  config.software.struct_size = sizeof(FlutterSoftwareRendererConfig);
-  config.software.surface_present_callback =
-      &FlutterApplication::PresentSurface;
+  config.type = kOpenGL;
+  config.open_gl.struct_size = sizeof(config.open_gl);
+  config.open_gl.make_current = [](void* userdata) -> bool {
+    return reinterpret_cast<FlutterApplication*>(userdata)
+        ->render_delegate_.OnApplicationContextMakeCurrent();
+  };
+  config.open_gl.clear_current = [](void* userdata) -> bool {
+    return reinterpret_cast<FlutterApplication*>(userdata)
+        ->render_delegate_.OnApplicationContextClearCurrent();
+  };
+  config.open_gl.present = [](void* userdata) -> bool {
+    return reinterpret_cast<FlutterApplication*>(userdata)
+        ->render_delegate_.OnApplicationPresent();
+  };
+  config.open_gl.fbo_callback = [](void* userdata) -> uint32_t {
+    return reinterpret_cast<FlutterApplication*>(userdata)
+        ->render_delegate_.OnApplicationGetOnscreenFBO();
+  };
 
 // TODO: Pipe this in through command line args.
 #define MY_PROJECT                                                          \
   "/usr/local/google/home/chinmaygarde/VersionControlled/flutter/examples/" \
   "flutter_gallery/build/flutter_assets"
 
-  std::vector<const char*> engine_command_line_args = {
-      "--disable-observatory",    //
-      "--dart-non-checked-mode",  //
-  };
-
   auto icu_data_path = GetICUDataPath();
 
   if (icu_data_path == "") {
@@ -84,19 +96,25 @@ FlutterApplication::FlutterApplication() {
     return;
   }
 
+  std::vector<const char*> command_line_args_c;
+
+  for (const auto& arg : command_line_args) {
+    command_line_args_c.push_back(arg.c_str());
+  }
+
   FlutterProjectArgs args = {
       .struct_size = sizeof(FlutterProjectArgs),
-      .assets_path = MY_PROJECT "/build/flutter_assets",
+      .assets_path = MY_PROJECT,
       .main_path = "",
       .packages_path = "",
       .icu_data_path = icu_data_path.c_str(),
-      .command_line_argc = static_cast<int>(engine_command_line_args.size()),
-      .command_line_argv = engine_command_line_args.data(),
+      .command_line_argc = static_cast<int>(command_line_args_c.size()),
+      .command_line_argv = command_line_args_c.data(),
   };
 
   FlutterEngine engine = nullptr;
-  auto result = FlutterEngineRun(FLUTTER_ENGINE_VERSION, &config,  // renderer
-                                 &args, this, &engine_);
+  auto result = FlutterEngineRun(FLUTTER_ENGINE_VERSION, &config, &args,
+                                 this /* userdata */, &engine_);
 
   if (result != kSuccess) {
     FLWAY_ERROR << "Could not run the Flutter engine" << std::endl;
@@ -135,31 +153,6 @@ void FlutterApplication::ProcessEvents() {
   __FlutterEngineFlushPendingTasksNow();
 }
 
-bool FlutterApplication::PresentSurface(void* user_data,
-                                        const void* allocation,
-                                        size_t row_bytes,
-                                        size_t height) {
-  return reinterpret_cast<FlutterApplication*>(user_data)->PresentSurface(
-      allocation, row_bytes, height);
-}
-
-void FlutterApplication::SetOnPresentCallback(PresentCallback callback) {
-  std::lock_guard<std::mutex> lock(mutex_);
-  present_callback_ = callback;
-}
-
-bool FlutterApplication::PresentSurface(const void* allocation,
-                                        size_t row_bytes,
-                                        size_t height) {
-  std::lock_guard<std::mutex> lock(mutex_);
-  if (!present_callback_) {
-    FLWAY_ERROR << "Present callback was not set." << std::endl;
-    return false;
-  }
-  present_callback_(allocation, row_bytes, height);
-  return true;
-}
-
 bool FlutterApplication::SendPointerEvent(int button, int x, int y) {
   if (!valid_) {
     FLWAY_ERROR << "Pointer events on an invalid application." << std::endl;

src/flutter_application.h

@@ -7,16 +7,27 @@
 #include <flutter_embedder.h>
 
 #include <functional>
-#include <map>
-#include <mutex>
+#include <vector>
 
 #include "macros.h"
 
 namespace flutter {
 
 class FlutterApplication {
  public:
-  FlutterApplication();
+  class RenderDelegate {
+   public:
+    virtual bool OnApplicationContextMakeCurrent() = 0;
+
+    virtual bool OnApplicationContextClearCurrent() = 0;
+
+    virtual bool OnApplicationPresent() = 0;
+
+    virtual uint32_t OnApplicationGetOnscreenFBO() = 0;
+  };
+
+  FlutterApplication(const std::vector<std::string>& args,
+                     RenderDelegate& render_delegate);
 
   ~FlutterApplication();
 
@@ -28,24 +39,12 @@ class FlutterApplication {
 
   bool SendPointerEvent(int button, int x, int y);
 
-  using PresentCallback = std::function<
-      void(const void* allocation, size_t row_bytes, size_t height)>;
-  void SetOnPresentCallback(PresentCallback callback);
-
  private:
   bool valid_;
+  RenderDelegate& render_delegate_;
   FlutterEngine engine_ = nullptr;
-  std::mutex mutex_;
-  PresentCallback present_callback_;
   int last_button_ = 0;
 
-  static bool PresentSurface(void* user_data,
-                             const void* allocation,
-                             size_t row_bytes,
-                             size_t height);
-
-  bool PresentSurface(const void* allocation, size_t row_bytes, size_t height);
-
   bool SendFlutterPointerEvent(FlutterPointerPhase phase, double x, double y);
 
   FLWAY_DISALLOW_COPY_AND_ASSIGN(FlutterApplication);

src/main.cc

@@ -4,27 +4,47 @@
 
 #include <stdlib.h>
 
+#include <string>
+#include <vector>
+
 #include "flutter_application.h"
 #include "wayland_display.h"
 
-int main(int argc, char* argv[]) {
-  auto application = std::make_unique<flutter::FlutterApplication>();
+namespace flutter {
 
-  if (!application->IsValid()) {
-    FLWAY_ERROR << "Could not run the Flutter application." << std::endl;
-    return EXIT_FAILURE;
-  }
+bool Main(std::vector<std::string> args) {
+  const size_t kWidth = 800;
+  const size_t kHeight = 600;
 
-  flutter::WaylandDisplay display(std::move(application),  //
-                                  "Flutter Gallery",       //
-                                  800, 600);
+  WaylandDisplay display(kWidth, kHeight);
 
   if (!display.IsValid()) {
-    FLWAY_ERROR << "Could not create the wayland display." << std::endl;
-    return EXIT_FAILURE;
+    FLWAY_ERROR << "Wayland display was not valid." << std::endl;
+    return false;
+  }
+
+  FlutterApplication application(args, display);
+  if (!application.IsValid()) {
+    FLWAY_ERROR << "Flutter application was not valid." << std::endl;
+    return false;
+  }
+
+  if (!application.SetWindowSize(kWidth, kHeight)) {
+    FLWAY_ERROR << "Could not update Flutter application size." << std::endl;
+    return false;
   }
 
   display.Run();
 
-  return EXIT_SUCCESS;
+  return true;
+}
+
+}  // namespace flutter
+
+int main(int argc, char* argv[]) {
+  std::vector<std::string> args;
+  for (int i = 0; i < argc; ++i) {
+    args.push_back(argv[i]);
+  }
+  return flutter::Main(std::move(args)) ? EXIT_SUCCESS : EXIT_FAILURE;
 }

src/wayland_display.cc

@@ -30,19 +30,8 @@ const wl_registry_listener WaylandDisplay::kRegistryListener = {
     },
 };
 
-WaylandDisplay::WaylandDisplay(std::unique_ptr<FlutterApplication> application,
-                               std::string name,
-                               size_t width,
-                               size_t height)
-    : application_(std::move(application)),
-      screen_name_(std::move(name)),
-      screen_width_(width),
-      screen_height_(height) {
-  if (!application_ || !application_->IsValid()) {
-    FLWAY_ERROR << "Invalid application to run." << std::endl;
-    return;
-  }
-
+WaylandDisplay::WaylandDisplay(size_t width, size_t height)
+    : screen_width_(width), screen_height_(height) {
   if (screen_width_ == 0 || screen_height_ == 0) {
     FLWAY_ERROR << "Invalid screen dimensions." << std::endl;
     return;
@@ -70,11 +59,6 @@ WaylandDisplay::WaylandDisplay(std::unique_ptr<FlutterApplication> application,
     return;
   }
 
-  if (!application_->SetWindowSize(width, height)) {
-    FLWAY_ERROR << "Could not set the application window size." << std::endl;
-    return;
-  }
-
   valid_ = true;
 }
 
@@ -300,4 +284,64 @@ void WaylandDisplay::UnannounceRegistryInterface(
     struct wl_registry* wl_registry,
     uint32_t name) {}
 
+// |flutter::FlutterApplication::RenderDelegate|
+bool WaylandDisplay::OnApplicationContextMakeCurrent() {
+  if (!valid_) {
+    FLWAY_ERROR << "Invalid display." << std::endl;
+    return false;
+  }
+
+  if (eglMakeCurrent(egl_display_, egl_surface_, egl_surface_, egl_context_) !=
+      EGL_TRUE) {
+    LogLastEGLError();
+    FLWAY_ERROR << "Could not make the onscreen context current" << std::endl;
+    return false;
+  }
+
+  return true;
+}
+
+// |flutter::FlutterApplication::RenderDelegate|
+bool WaylandDisplay::OnApplicationContextClearCurrent() {
+  if (!valid_) {
+    FLWAY_ERROR << "Invalid display." << std::endl;
+    return false;
+  }
+
+  if (eglMakeCurrent(egl_display_, EGL_NO_SURFACE, EGL_NO_SURFACE,
+                     EGL_NO_CONTEXT) != EGL_TRUE) {
+    LogLastEGLError();
+    FLWAY_ERROR << "Could not clear the context." << std::endl;
+    return false;
+  }
+
+  return true;
+}
+
+// |flutter::FlutterApplication::RenderDelegate|
+bool WaylandDisplay::OnApplicationPresent() {
+  if (!valid_) {
+    FLWAY_ERROR << "Invalid display." << std::endl;
+    return false;
+  }
+
+  if (eglSwapBuffers(egl_display_, surface_) != EGL_TRUE) {
+    LogLastEGLError();
+    FLWAY_ERROR << "Could not swap the EGL buffer." << std::endl;
+    return false;
+  }
+
+  return true;
+}
+
+// |flutter::FlutterApplication::RenderDelegate|
+uint32_t WaylandDisplay::OnApplicationGetOnscreenFBO() {
+  if (!valid_) {
+    FLWAY_ERROR << "Invalid display." << std::endl;
+    return 999;
+  }
+
+  return 0;  // FBO0
+}
+
 }  // namespace flutter

src/wayland_display.h

@@ -16,12 +16,9 @@
 
 namespace flutter {
 
-class WaylandDisplay {
+class WaylandDisplay : public FlutterApplication::RenderDelegate {
  public:
-  WaylandDisplay(std::unique_ptr<FlutterApplication> application,
-                 std::string name,
-                 size_t width,
-                 size_t height);
+  WaylandDisplay(size_t width, size_t height);
 
   ~WaylandDisplay();
 
@@ -32,8 +29,6 @@ class WaylandDisplay {
  private:
   static const wl_registry_listener kRegistryListener;
   bool valid_ = false;
-  std::unique_ptr<FlutterApplication> application_;
-  std::string screen_name_;
   const int screen_width_;
   const int screen_height_;
   wl_display* display_ = nullptr;
@@ -57,6 +52,18 @@ class WaylandDisplay {
 
   bool StopRunning();
 
+  // |flutter::FlutterApplication::RenderDelegate|
+  bool OnApplicationContextMakeCurrent() override;
+
+  // |flutter::FlutterApplication::RenderDelegate|
+  bool OnApplicationContextClearCurrent() override;
+
+  // |flutter::FlutterApplication::RenderDelegate|
+  bool OnApplicationPresent() override;
+
+  // |flutter::FlutterApplication::RenderDelegate|
+  uint32_t OnApplicationGetOnscreenFBO() override;
+
   FLWAY_DISALLOW_COPY_AND_ASSIGN(WaylandDisplay);
 };