FlutterEmbedderGLFW.cc File Reference

#include <cassert>
#include <chrono>
#include <iostream>
#include <EGL/egl.h>
#include <EGL/eglext.h>
#include <array>
#include <cstring>
#include <list>
#include <unordered_map>
#include "GLFW/glfw3.h"
#include "GLFW/glfw3native.h"
#include "embedder.h"

Go to the source code of this file.

Macros
#define	GLFW_EXPOSE_NATIVE_EGL
#define	GLFW_INCLUDE_GLEXT

Functions
void	GLFWcursorPositionCallbackAtPhase (GLFWwindow *window, FlutterPointerPhase phase, double x, double y)
void	GLFWcursorPositionCallback (GLFWwindow *window, double x, double y)
void	GLFWmouseButtonCallback (GLFWwindow *window, int key, int action, int mods)
static void	GLFWKeyCallback (GLFWwindow *window, int key, int scancode, int action, int mods)
void	GLFWwindowSizeCallback (GLFWwindow *window, int width, int height)
static std::array< EGLint, 4 >	RectToInts (const FlutterRect rect)
static void	JoinFlutterRect (FlutterRect *rect, FlutterRect additional_rect)
static bool	HasExtension (const char *extensions, const char *name)
bool	RunFlutter (GLFWwindow *window, const std::string &project_path, const std::string &icudtl_path)
void	printUsage ()
void	GLFW_ErrorCallback (int error, const char *description)
int	main (int argc, const char *argv[])

Variables
static double	g_pixelRatio = 1.0
static const size_t	kInitialWindowWidth = 800
static const size_t	kInitialWindowHeight = 600
static const int	kMaxHistorySize = 10
static constexpr FlutterViewId	kImplicitViewId = 0
std::list< FlutterRect >	damage_history_
std::unordered_map< intptr_t, FlutterRect * >	existing_damage_map_
EGLDisplay	display_
EGLSurface	surface_

Macro Definition Documentation

GLFW_EXPOSE_NATIVE_EGL

#define GLFW_EXPOSE_NATIVE_EGL

Definition at line 9 of file FlutterEmbedderGLFW.cc.

GLFW_INCLUDE_GLEXT

#define GLFW_INCLUDE_GLEXT

Definition at line 10 of file FlutterEmbedderGLFW.cc.

Function Documentation

GLFW_ErrorCallback()

void GLFW_ErrorCallback	(	int	error,
		const char *	description
	)

Definition at line 286 of file FlutterEmbedderGLFW.cc.

                                                            {
  std::cout << "GLFW Error: (" << error << ") " << description << std::endl;
}

GLFWcursorPositionCallback()

void GLFWcursorPositionCallback	(	GLFWwindow *	window,
		double	x,
		double	y
	)

Definition at line 68 of file FlutterEmbedderGLFW.cc.

                                                                        {
  GLFWcursorPositionCallbackAtPhase(window, FlutterPointerPhase::kMove, x, y);
}

GLFWcursorPositionCallbackAtPhase()

void GLFWcursorPositionCallbackAtPhase	(	GLFWwindow *	window,
		FlutterPointerPhase	phase,
		double	x,
		double	y
	)

Definition at line 47 of file FlutterEmbedderGLFW.cc.

                                                 {
  FlutterPointerEvent event = {};
  event.struct_size = sizeof(event);
  event.phase = phase;
  event.x = x * g_pixelRatio;
  event.y = y * g_pixelRatio;
  event.timestamp =
      std::chrono::duration_cast<std::chrono::microseconds>(
          std::chrono::high_resolution_clock::now().time_since_epoch())
          .count();
  // This example only supports a single window, therefore we assume the pointer
  // event occurred in the only view, the implicit view.
  event.view_id = kImplicitViewId;
  FlutterEngineSendPointerEvent(
      reinterpret_cast<FlutterEngine>(glfwGetWindowUserPointer(window)), &event,
      1);
}

GLFWKeyCallback()

static void GLFWKeyCallback ( GLFWwindow *  window, int  key, int  scancode, int  action, int  mods  )

static

Definition at line 91 of file FlutterEmbedderGLFW.cc.

                                      {
  if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS) {
    glfwSetWindowShouldClose(window, GLFW_TRUE);
  }
}

GLFWmouseButtonCallback()

void GLFWmouseButtonCallback	(	GLFWwindow *	window,
		int	key,
		int	action,
		int	mods
	)

Definition at line 72 of file FlutterEmbedderGLFW.cc.

                                       {
  if (key == GLFW_MOUSE_BUTTON_1 && action == GLFW_PRESS) {
    double x, y;
    glfwGetCursorPos(window, &x, &y);
    GLFWcursorPositionCallbackAtPhase(window, FlutterPointerPhase::kDown, x, y);
    glfwSetCursorPosCallback(window, GLFWcursorPositionCallback);
  }
 
  if (key == GLFW_MOUSE_BUTTON_1 && action == GLFW_RELEASE) {
    double x, y;
    glfwGetCursorPos(window, &x, &y);
    GLFWcursorPositionCallbackAtPhase(window, FlutterPointerPhase::kUp, x, y);
    glfwSetCursorPosCallback(window, nullptr);
  }
}

GLFWwindowSizeCallback()

void GLFWwindowSizeCallback	(	GLFWwindow *	window,
		int	width,
		int	height
	)

Definition at line 101 of file FlutterEmbedderGLFW.cc.

                                                                       {
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = width * g_pixelRatio;
  event.height = height * g_pixelRatio;
  event.pixel_ratio = g_pixelRatio;
  // This example only supports a single window, therefore we assume the event
  // occurred in the only view, the implicit view.
  event.view_id = kImplicitViewId;
  FlutterEngineSendWindowMetricsEvent(
      reinterpret_cast<FlutterEngine>(glfwGetWindowUserPointer(window)),
      &event);
}

HasExtension()

static bool HasExtension ( const char *  extensions, const char *  name  )

static

Definition at line 139 of file FlutterEmbedderGLFW.cc.

                                                                   {
  const char* r = strstr(extensions, name);
  auto len = strlen(name);
  // check that the extension name is terminated by space or null terminator
  return r != nullptr && (r[len] == ' ' || r[len] == 0);
}

JoinFlutterRect()

static void JoinFlutterRect ( FlutterRect *  rect, FlutterRect  additional_rect  )

static

Definition at line 130 of file FlutterEmbedderGLFW.cc.

                                                                            {
  rect->left = std::min(rect->left, additional_rect.left);
  rect->top = std::min(rect->top, additional_rect.top);
  rect->right = std::max(rect->right, additional_rect.right);
  rect->bottom = std::max(rect->bottom, additional_rect.bottom);
}

main()

int main	(	int	argc,
		const char *	argv[]
	)

Definition at line 290 of file FlutterEmbedderGLFW.cc.

                                       {
  if (argc != 3) {
    printUsage();
    return 1;
  }
 
  std::string project_path = argv[1];
  std::string icudtl_path = argv[2];
 
  glfwSetErrorCallback(GLFW_ErrorCallback);
 
  int result = glfwInit();
  if (result != GLFW_TRUE) {
    std::cout << "Could not initialize GLFW." << std::endl;
    return EXIT_FAILURE;
  }
 
#if defined(__linux__)
  glfwWindowHint(GLFW_CONTEXT_CREATION_API, GLFW_EGL_CONTEXT_API);
#endif
 
  GLFWwindow* window = glfwCreateWindow(
      kInitialWindowWidth, kInitialWindowHeight, "Flutter", NULL, NULL);
  if (window == nullptr) {
    std::cout << "Could not create GLFW window." << std::endl;
    return EXIT_FAILURE;
  }
 
  int framebuffer_width, framebuffer_height;
  glfwGetFramebufferSize(window, &framebuffer_width, &framebuffer_height);
  g_pixelRatio = framebuffer_width / kInitialWindowWidth;
 
  // Get the display and surface variables.
  display_ = glfwGetEGLDisplay();
  surface_ = glfwGetEGLSurface(window);
 
  bool run_result = RunFlutter(window, project_path, icudtl_path);
  if (!run_result) {
    std::cout << "Could not run the Flutter engine." << std::endl;
    return EXIT_FAILURE;
  }
 
  glfwSetKeyCallback(window, GLFWKeyCallback);
  glfwSetWindowSizeCallback(window, GLFWwindowSizeCallback);
  glfwSetMouseButtonCallback(window, GLFWmouseButtonCallback);
 
  while (!glfwWindowShouldClose(window)) {
    glfwWaitEvents();
  }
 
  glfwDestroyWindow(window);
  glfwTerminate();
 
  return EXIT_SUCCESS;
}

printUsage()

void printUsage

(

)

Definition at line 280 of file FlutterEmbedderGLFW.cc.

                  {
  std::cout
      << "usage: embedder_example_drm <path to project> <path to icudtl.dat>"
      << std::endl;
}

RectToInts()

static std::array< EGLint, 4 > RectToInts ( const FlutterRect  rect )

static

Definition at line 117 of file FlutterEmbedderGLFW.cc.

                                                              {
  EGLint height;
  eglQuerySurface(display_, surface_, EGL_HEIGHT, &height);
 
  std::array<EGLint, 4> res{
      static_cast<int>(rect.left), height - static_cast<int>(rect.bottom),
      static_cast<int>(rect.right) - static_cast<int>(rect.left),
      static_cast<int>(rect.bottom) - static_cast<int>(rect.top)};
  return res;
}

RunFlutter()

bool RunFlutter	(	GLFWwindow *	window,
		const std::string &	project_path,
		const std::string &	icudtl_path
	)

Definition at line 146 of file FlutterEmbedderGLFW.cc.

                                              {
  FlutterRendererConfig config = {};
  config.type = kOpenGL;
  config.open_gl.struct_size = sizeof(config.open_gl);
  config.open_gl.make_current = [](void* userdata) -> bool {
    glfwMakeContextCurrent(static_cast<GLFWwindow*>(userdata));
    return true;
  };
  config.open_gl.clear_current = [](void*) -> bool {
    glfwMakeContextCurrent(nullptr);  // is this even a thing?
    return true;
  };
  config.open_gl.present_with_info =
      [](void* userdata, const FlutterPresentInfo* info) -> bool {
    // Free the existing damage that was allocated to this frame.
    if (existing_damage_map_[info->fbo_id] != nullptr) {
      free(existing_damage_map_[info->fbo_id]);
      existing_damage_map_[info->fbo_id] = nullptr;
    }
 
    // Get list of extensions.
    const char* extensions = eglQueryString(display_, EGL_EXTENSIONS);
 
    // Retrieve the set damage region function.
    PFNEGLSETDAMAGEREGIONKHRPROC set_damage_region_ = nullptr;
    if (HasExtension(extensions, "EGL_KHR_partial_update")) {
      set_damage_region_ = reinterpret_cast<PFNEGLSETDAMAGEREGIONKHRPROC>(
          eglGetProcAddress("eglSetDamageRegionKHR"));
    }
 
    // Retrieve the swap buffers with damage function.
    PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC swap_buffers_with_damage_ = nullptr;
    if (HasExtension(extensions, "EGL_EXT_swap_buffers_with_damage")) {
      swap_buffers_with_damage_ =
          reinterpret_cast<PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC>(
              eglGetProcAddress("eglSwapBuffersWithDamageEXT"));
    } else if (HasExtension(extensions, "EGL_KHR_swap_buffers_with_damage")) {
      swap_buffers_with_damage_ =
          reinterpret_cast<PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC>(
              eglGetProcAddress("eglSwapBuffersWithDamageKHR"));
    }
 
    if (set_damage_region_) {
      // Set the buffer damage as the damage region.
      auto buffer_rects = RectToInts(info->buffer_damage.damage[0]);
      set_damage_region_(display_, surface_, buffer_rects.data(), 1);
    }
 
    // Add frame damage to damage history
    damage_history_.push_back(info->frame_damage.damage[0]);
    if (damage_history_.size() > kMaxHistorySize) {
      damage_history_.pop_front();
    }
 
    if (swap_buffers_with_damage_) {
      // Swap buffers with frame damage.
      auto frame_rects = RectToInts(info->frame_damage.damage[0]);
      return swap_buffers_with_damage_(display_, surface_, frame_rects.data(),
                                       1);
    } else {
      // If the required extensions for partial repaint were not provided, do
      // full repaint.
      return eglSwapBuffers(display_, surface_);
    }
  };
  config.open_gl.fbo_callback = [](void*) -> uint32_t {
    return 0;  // FBO0
  };
  config.open_gl.populate_existing_damage =
      [](void* userdata, intptr_t fbo_id,
         FlutterDamage* existing_damage) -> void {
    // Given the FBO age, create existing damage region by joining all frame
    // damages since FBO was last used
    EGLint age;
    if (glfwExtensionSupported("GL_EXT_buffer_age") == GLFW_TRUE) {
      eglQuerySurface(display_, surface_, EGL_BUFFER_AGE_EXT, &age);
    } else {
      age = 4;  // Virtually no driver should have a swapchain length > 4.
    }
 
    existing_damage->num_rects = 1;
 
    // Allocate the array of rectangles for the existing damage.
    existing_damage_map_[fbo_id] = static_cast<FlutterRect*>(
        malloc(sizeof(FlutterRect) * existing_damage->num_rects));
    existing_damage_map_[fbo_id][0] =
        FlutterRect{0, 0, kInitialWindowWidth, kInitialWindowHeight};
    existing_damage->damage = existing_damage_map_[fbo_id];
 
    if (age > 1) {
      --age;
      // join up to (age - 1) last rects from damage history
      for (auto i = damage_history_.rbegin();
           i != damage_history_.rend() && age > 0; ++i, --age) {
        if (i == damage_history_.rbegin()) {
          if (i != damage_history_.rend()) {
            existing_damage->damage[0] = {i->left, i->top, i->right, i->bottom};
          }
        } else {
          JoinFlutterRect(&(existing_damage->damage[0]), *i);
        }
      }
    }
  };
  config.open_gl.gl_proc_resolver = [](void*, const char* name) -> void* {
    return reinterpret_cast<void*>(glfwGetProcAddress(name));
  };
  config.open_gl.fbo_reset_after_present = true;
 
  // This directory is generated by `flutter build bundle`.
  std::string assets_path = project_path + "/build/flutter_assets";
  FlutterProjectArgs args = {
      .struct_size = sizeof(FlutterProjectArgs),
      .assets_path = assets_path.c_str(),
      .icu_data_path =
          icudtl_path.c_str(),  // Find this in your bin/cache directory.
  };
  FlutterEngine engine = nullptr;
  FlutterEngineResult result =
      FlutterEngineRun(FLUTTER_ENGINE_VERSION, &config,  // renderer
                       &args, window, &engine);
  if (result != kSuccess || engine == nullptr) {
    std::cout << "Could not run the Flutter Engine." << std::endl;
    return false;
  }
 
  glfwSetWindowUserPointer(window, engine);
  GLFWwindowSizeCallback(window, kInitialWindowWidth, kInitialWindowHeight);
 
  return true;
}

Variable Documentation

damage_history_

std::list<FlutterRect> damage_history_

Definition at line 33 of file FlutterEmbedderGLFW.cc.

display_

EGLDisplay display_

Definition at line 38 of file FlutterEmbedderGLFW.cc.

existing_damage_map_

std::unordered_map<intptr_t, FlutterRect*> existing_damage_map_

Definition at line 36 of file FlutterEmbedderGLFW.cc.

g_pixelRatio

double g_pixelRatio = 1.0

static

Definition at line 23 of file FlutterEmbedderGLFW.cc.

kImplicitViewId

constexpr FlutterViewId kImplicitViewId = 0

staticconstexpr

Definition at line 29 of file FlutterEmbedderGLFW.cc.

kInitialWindowHeight

const size_t kInitialWindowHeight = 600

static

Definition at line 25 of file FlutterEmbedderGLFW.cc.

kInitialWindowWidth

const size_t kInitialWindowWidth = 800

static

Definition at line 24 of file FlutterEmbedderGLFW.cc.

kMaxHistorySize

const int kMaxHistorySize = 10

static

Definition at line 28 of file FlutterEmbedderGLFW.cc.

surface_

EGLSurface surface_

Definition at line 39 of file FlutterEmbedderGLFW.cc.