| // Copyright 2013 The Flutter Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include <cassert> |
| #include <chrono> |
| #include <iostream> |
| |
| #define GLFW_EXPOSE_NATIVE_EGL |
| #define GLFW_INCLUDE_GLEXT |
| |
| #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" |
| |
| // This value is calculated after the window is created. |
| static double g_pixelRatio = 1.0; |
| static const size_t kInitialWindowWidth = 800; |
| static const size_t kInitialWindowHeight = 600; |
| // Maximum damage history - for triple buffering we need to store damage for |
| // last two frames; Some Android devices (Pixel 4) use quad buffering. |
| static const int kMaxHistorySize = 10; |
| |
| // Keeps track of the most recent frame damages so that existing damage can |
| // be easily computed. |
| std::list<FlutterRect> damage_history_; |
| |
| // Keeps track of the existing damage associated with each FBO ID |
| std::unordered_map<intptr_t, FlutterRect*> existing_damage_map_; |
| |
| EGLDisplay display_; |
| EGLSurface surface_; |
| |
| static_assert(FLUTTER_ENGINE_VERSION == 1, |
| "This Flutter Embedder was authored against the stable Flutter " |
| "API at version 1. There has been a serious breakage in the " |
| "API. Please read the ChangeLog and take appropriate action " |
| "before updating this assertion"); |
| |
| void GLFWcursorPositionCallbackAtPhase(GLFWwindow* window, |
| FlutterPointerPhase phase, |
| double x, |
| double y) { |
| 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(); |
| FlutterEngineSendPointerEvent( |
| reinterpret_cast<FlutterEngine>(glfwGetWindowUserPointer(window)), &event, |
| 1); |
| } |
| |
| void GLFWcursorPositionCallback(GLFWwindow* window, double x, double y) { |
| GLFWcursorPositionCallbackAtPhase(window, FlutterPointerPhase::kMove, x, y); |
| } |
| |
| void GLFWmouseButtonCallback(GLFWwindow* window, |
| int key, |
| int action, |
| int mods) { |
| 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); |
| } |
| } |
| |
| static void GLFWKeyCallback(GLFWwindow* window, |
| int key, |
| int scancode, |
| int action, |
| int mods) { |
| if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS) { |
| glfwSetWindowShouldClose(window, GLFW_TRUE); |
| } |
| } |
| |
| void GLFWwindowSizeCallback(GLFWwindow* window, int width, int height) { |
| FlutterWindowMetricsEvent event = {}; |
| event.struct_size = sizeof(event); |
| event.width = width * g_pixelRatio; |
| event.height = height * g_pixelRatio; |
| event.pixel_ratio = g_pixelRatio; |
| FlutterEngineSendWindowMetricsEvent( |
| reinterpret_cast<FlutterEngine>(glfwGetWindowUserPointer(window)), |
| &event); |
| } |
| |
| // Auxiliary function used to transform a FlutterRect into the format that is |
| // expected by the EGL functions (i.e. array of EGLint). |
| static std::array<EGLint, 4> RectToInts(const FlutterRect rect) { |
| 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; |
| } |
| |
| // Auxiliary function to union the damage regions comprised by two FlutterRect |
| // element. It saves the result of this join in the rect variable. |
| static void JoinFlutterRect(FlutterRect* rect, FlutterRect additional_rect) { |
| 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); |
| } |
| |
| // Auxiliary function used to check if the given list of extensions contains the |
| // requested extension name. |
| static bool HasExtension(const char* extensions, const char* name) { |
| 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); |
| } |
| |
| bool RunFlutter(GLFWwindow* window, |
| const std::string& project_path, |
| const std::string& icudtl_path) { |
| 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. |
| free(existing_damage_map_[info->fbo_id]); |
| |
| // 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; |
| } |
| |
| void printUsage() { |
| std::cout |
| << "usage: embedder_example_drm <path to project> <path to icudtl.dat>" |
| << std::endl; |
| } |
| |
| void GLFW_ErrorCallback(int error, const char* description) { |
| std::cout << "GLFW Error: (" << error << ") " << description << std::endl; |
| } |
| |
| int main(int argc, const char* argv[]) { |
| 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; |
| } |