fl_renderer.cc File Reference

#include "fl_renderer.h"
#include <epoxy/egl.h>
#include <epoxy/gl.h>
#include "flutter/shell/platform/embedder/embedder.h"
#include "flutter/shell/platform/linux/fl_backing_store_provider.h"
#include "flutter/shell/platform/linux/fl_engine_private.h"
#include "flutter/shell/platform/linux/fl_view_private.h"

Go to the source code of this file.

Classes
struct	FlRendererPrivate

Functions
static gchar *	get_shader_log (GLuint shader)
static gchar *	get_program_log (GLuint program)
static GLfloat	pixels_to_gl_coords (GLfloat position, GLfloat pixels)
	Converts a pixel co-ordinate from 0..pixels to OpenGL -1..1. More...
static void	fl_renderer_unblock_main_thread (FlRenderer *self)
static void	fl_renderer_dispose (GObject *object)
static void	fl_renderer_class_init (FlRendererClass *klass)
static void	fl_renderer_init (FlRenderer *self)
gboolean	fl_renderer_start (FlRenderer *self, FlView *view)
void *	fl_renderer_get_proc_address (FlRenderer *self, const char *name)
void	fl_renderer_make_current (FlRenderer *self)
void	fl_renderer_make_resource_current (FlRenderer *self)
void	fl_renderer_clear_current (FlRenderer *self)
guint32	fl_renderer_get_fbo (FlRenderer *self)
gboolean	fl_renderer_create_backing_store (FlRenderer *renderer, const FlutterBackingStoreConfig *config, FlutterBackingStore *backing_store_out)
gboolean	fl_renderer_collect_backing_store (FlRenderer *self, const FlutterBackingStore *backing_store)
void	fl_renderer_wait_for_frame (FlRenderer *self, int target_width, int target_height)
gboolean	fl_renderer_present_layers (FlRenderer *self, const FlutterLayer **layers, size_t layers_count)
void	fl_renderer_setup (FlRenderer *self)
void	fl_renderer_render (FlRenderer *self, int width, int height)
void	fl_renderer_cleanup (FlRenderer *self)

Variables
static const char *	vertex_shader_src
static const char *	fragment_shader_src

Function Documentation

fl_renderer_class_init()

static void fl_renderer_class_init ( FlRendererClass *  klass )

static

Definition at line 115 of file fl_renderer.cc.

                                                           {
  G_OBJECT_CLASS(klass)->dispose = fl_renderer_dispose;
}

References fl_renderer_dispose().

fl_renderer_cleanup()

void fl_renderer_cleanup

(

FlRenderer *

renderer

)

fl_renderer_cleanup:

Removes OpenGL resources used for rendering. Requires an active OpenGL context.

Definition at line 369 of file fl_renderer.cc.

                                           {
  FlRendererPrivate* priv = reinterpret_cast<FlRendererPrivate*>(
      fl_renderer_get_instance_private(self));
 
  g_return_if_fail(FL_IS_RENDERER(self));
 
  glDeleteProgram(priv->program);
}

References priv.

Referenced by unrealize_cb().

fl_renderer_clear_current()

void fl_renderer_clear_current

(

FlRenderer *

renderer

)

fl_renderer_clear_current: @renderer: an #FlRenderer.

Clears the current rendering context.

Definition at line 151 of file fl_renderer.cc.

                                                 {
  g_return_if_fail(FL_IS_RENDERER(self));
  FL_RENDERER_GET_CLASS(self)->clear_current(self);
}

Referenced by fl_engine_gl_clear_current().

fl_renderer_collect_backing_store()

gboolean fl_renderer_collect_backing_store	(	FlRenderer *	renderer,
		const FlutterBackingStore *	backing_store
	)

fl_renderer_collect_backing_store: @renderer: an #FlRenderer. @backing_store: backing store to be released.

A callback invoked by the engine to release the backing store. The embedder may collect any resources associated with the backing store.

Returns TRUE if successful.

Definition at line 192 of file fl_renderer.cc.

                                              {
  fl_renderer_make_current(self);
 
  // OpenGL context is required when destroying #FlBackingStoreProvider.
  g_object_unref(backing_store->open_gl.framebuffer.user_data);
  return TRUE;
}

References fl_renderer_make_current(), and TRUE.

Referenced by compositor_collect_backing_store_callback().

fl_renderer_create_backing_store()

gboolean fl_renderer_create_backing_store	(	FlRenderer *	renderer,
		const FlutterBackingStoreConfig *	config,
		FlutterBackingStore *	backing_store_out
	)

fl_renderer_create_backing_store: @renderer: an #FlRenderer. @config: backing store config. @backing_store_out: saves created backing store.

Obtain a backing store for a specific #FlutterLayer.

Returns TRUE if successful.

Definition at line 163 of file fl_renderer.cc.

                                            {
  fl_renderer_make_current(renderer);
 
  FlBackingStoreProvider* provider =
      fl_backing_store_provider_new(config->size.width, config->size.height);
  if (!provider) {
    g_warning("Failed to create backing store");
    return FALSE;
  }
 
  uint32_t name = fl_backing_store_provider_get_gl_framebuffer_id(provider);
  uint32_t format = fl_backing_store_provider_get_gl_format(provider);
 
  backing_store_out->type = kFlutterBackingStoreTypeOpenGL;
  backing_store_out->open_gl.type = kFlutterOpenGLTargetTypeFramebuffer;
  backing_store_out->open_gl.framebuffer.user_data = provider;
  backing_store_out->open_gl.framebuffer.name = name;
  backing_store_out->open_gl.framebuffer.target = format;
  backing_store_out->open_gl.framebuffer.destruction_callback = [](void* p) {
    // Backing store destroyed in fl_renderer_collect_backing_store(), set
    // on FlutterCompositor.collect_backing_store_callback during engine start.
  };
 
  return TRUE;
}

References fl_backing_store_provider_get_gl_format(), fl_backing_store_provider_get_gl_framebuffer_id(), fl_backing_store_provider_new(), fl_renderer_make_current(), format, and TRUE.

Referenced by compositor_create_backing_store_callback().

fl_renderer_dispose()

static void fl_renderer_dispose ( GObject *  object )

static

Definition at line 103 of file fl_renderer.cc.

                                                 {
  FlRenderer* self = FL_RENDERER(object);
  FlRendererPrivate* priv = reinterpret_cast<FlRendererPrivate*>(
      fl_renderer_get_instance_private(self));
 
  fl_renderer_unblock_main_thread(self);
 
  g_clear_pointer(&priv->textures, g_ptr_array_unref);
 
  G_OBJECT_CLASS(fl_renderer_parent_class)->dispose(object);
}

References fl_renderer_unblock_main_thread(), and priv.

Referenced by fl_renderer_class_init().

fl_renderer_get_fbo()

guint32 fl_renderer_get_fbo

(

FlRenderer *

renderer

)

fl_renderer_get_fbo: @renderer: an #FlRenderer.

Gets the frame buffer object to render to.

Returns: a frame buffer object index.

Definition at line 156 of file fl_renderer.cc.

                                              {
  g_return_val_if_fail(FL_IS_RENDERER(self), 0);
 
  // There is only one frame buffer object - always return that.
  return 0;
}

Referenced by fl_engine_gl_get_fbo().

fl_renderer_get_proc_address()

void* fl_renderer_get_proc_address	(	FlRenderer *	self,
		const char *	name
	)

Definition at line 135 of file fl_renderer.cc.

                                                                       {
  g_return_val_if_fail(FL_IS_RENDERER(self), NULL);
 
  return reinterpret_cast<void*>(eglGetProcAddress(name));
}

Referenced by fl_engine_gl_proc_resolver().

fl_renderer_init()

static void fl_renderer_init ( FlRenderer *  self )

static

Definition at line 119 of file fl_renderer.cc.

                                               {
  FlRendererPrivate* priv = reinterpret_cast<FlRendererPrivate*>(
      fl_renderer_get_instance_private(self));
  priv->textures = g_ptr_array_new_with_free_func(g_object_unref);
}

References priv.

fl_renderer_make_current()

void fl_renderer_make_current

(

FlRenderer *

renderer

)

fl_renderer_make_current: @renderer: an #FlRenderer.

Makes the rendering context current.

Definition at line 141 of file fl_renderer.cc.

                                                {
  g_return_if_fail(FL_IS_RENDERER(self));
  FL_RENDERER_GET_CLASS(self)->make_current(self);
}

Referenced by fl_engine_gl_make_current(), fl_renderer_collect_backing_store(), fl_renderer_create_backing_store(), realize_cb(), and unrealize_cb().

fl_renderer_make_resource_current()

void fl_renderer_make_resource_current

(

FlRenderer *

renderer

)

fl_renderer_make_resource_current: @renderer: an #FlRenderer.

Makes the resource rendering context current.

Definition at line 146 of file fl_renderer.cc.

                                                         {
  g_return_if_fail(FL_IS_RENDERER(self));
  FL_RENDERER_GET_CLASS(self)->make_resource_current(self);
}

Referenced by fl_engine_gl_make_resource_current().

fl_renderer_present_layers()

gboolean fl_renderer_present_layers	(	FlRenderer *	renderer,
		const FlutterLayer **	layers,
		size_t	layers_count
	)

fl_renderer_present_layers: @renderer: an #FlRenderer. @layers: layers to be composited. @layers_count: number of layers.

Callback invoked by the engine to composite the contents of each layer onto the screen.

Returns TRUE if successful.

Definition at line 221 of file fl_renderer.cc.

                                                         {
  FlRendererPrivate* priv = reinterpret_cast<FlRendererPrivate*>(
      fl_renderer_get_instance_private(self));
 
  g_return_val_if_fail(FL_IS_RENDERER(self), FALSE);
 
  // ignore incoming frame with wrong dimensions in trivial case with just one
  // layer
  if (priv->blocking_main_thread && layers_count == 1 &&
      layers[0]->offset.x == 0 && layers[0]->offset.y == 0 &&
      (layers[0]->size.width != priv->target_width ||
       layers[0]->size.height != priv->target_height)) {
    return true;
  }
 
  priv->had_first_frame = true;
 
  fl_renderer_unblock_main_thread(self);
 
  if (!priv->view) {
    return FALSE;
  }
 
  g_ptr_array_set_size(priv->textures, 0);
  for (size_t i = 0; i < layers_count; ++i) {
    const FlutterLayer* layer = layers[i];
    switch (layer->type) {
      case kFlutterLayerContentTypeBackingStore: {
        const FlutterBackingStore* backing_store = layer->backing_store;
        auto framebuffer = &backing_store->open_gl.framebuffer;
        FlBackingStoreProvider* provider =
            FL_BACKING_STORE_PROVIDER(framebuffer->user_data);
        g_ptr_array_add(priv->textures, g_object_ref(provider));
      } break;
      case kFlutterLayerContentTypePlatformView: {
        // TODO(robert-ancell) Not implemented -
        // https://github.com/flutter/flutter/issues/41724
      } break;
    }
  }
 
  fl_view_redraw(priv->view);
 
  return TRUE;
}

References fl_renderer_unblock_main_thread(), fl_view_redraw(), priv, and TRUE.

Referenced by compositor_present_layers_callback().

fl_renderer_render()

void fl_renderer_render	(	FlRenderer *	renderer,
		int	width,
		int	height
	)

fl_renderer_render: @renderer: an #FlRenderer. @width: width of the window in pixels. @height: height of the window in pixels.

Performs OpenGL commands to render current Flutter view.

Definition at line 311 of file fl_renderer.cc.

                                                                 {
  FlRendererPrivate* priv = reinterpret_cast<FlRendererPrivate*>(
      fl_renderer_get_instance_private(self));
 
  g_return_if_fail(FL_IS_RENDERER(self));
 
  glClearColor(0.0, 0.0, 0.0, 1.0);
  glClear(GL_COLOR_BUFFER_BIT);
 
  glUseProgram(priv->program);
 
  for (guint i = 0; i < priv->textures->len; i++) {
    FlBackingStoreProvider* texture =
        FL_BACKING_STORE_PROVIDER(g_ptr_array_index(priv->textures, i));
 
    uint32_t texture_id = fl_backing_store_provider_get_gl_texture_id(texture);
    glBindTexture(GL_TEXTURE_2D, texture_id);
 
    // Translate into OpenGL co-ordinates
    GdkRectangle texture_geometry =
        fl_backing_store_provider_get_geometry(texture);
    GLfloat texture_x = texture_geometry.x;
    GLfloat texture_y = texture_geometry.y;
    GLfloat texture_width = texture_geometry.width;
    GLfloat texture_height = texture_geometry.height;
    GLfloat x0 = pixels_to_gl_coords(texture_x, width);
    GLfloat y0 =
        pixels_to_gl_coords(height - (texture_y + texture_height), height);
    GLfloat x1 = pixels_to_gl_coords(texture_x + texture_width, width);
    GLfloat y1 = pixels_to_gl_coords(height - texture_y, height);
    GLfloat vertex_data[] = {x0, y0, 0, 0, x1, y1, 1, 1, x0, y1, 0, 1,
                             x0, y0, 0, 0, x1, y0, 1, 0, x1, y1, 1, 1};
 
    GLuint vao, vertex_buffer;
    glGenVertexArrays(1, &vao);
    glBindVertexArray(vao);
    glGenBuffers(1, &vertex_buffer);
    glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertex_data), vertex_data,
                 GL_STATIC_DRAW);
    GLint position_index = glGetAttribLocation(priv->program, "position");
    glEnableVertexAttribArray(position_index);
    glVertexAttribPointer(position_index, 2, GL_FLOAT, GL_FALSE,
                          sizeof(GLfloat) * 4, 0);
    GLint texcoord_index = glGetAttribLocation(priv->program, "in_texcoord");
    glEnableVertexAttribArray(texcoord_index);
    glVertexAttribPointer(texcoord_index, 2, GL_FLOAT, GL_FALSE,
                          sizeof(GLfloat) * 4, (void*)(sizeof(GLfloat) * 2));
 
    glDrawArrays(GL_TRIANGLES, 0, 6);
 
    glDeleteVertexArrays(1, &vao);
    glDeleteBuffers(1, &vertex_buffer);
  }
 
  glFlush();
}

References fl_backing_store_provider_get_geometry(), fl_backing_store_provider_get_gl_texture_id(), height, pixels_to_gl_coords(), priv, texture_id, and width.

Referenced by render_cb().

fl_renderer_setup()

void fl_renderer_setup

(

FlRenderer *

renderer

)

fl_renderer_setup: @renderer: an #FlRenderer.

Creates OpenGL resources required before rendering. Requires an active OpenGL context.

Definition at line 269 of file fl_renderer.cc.

                                         {
  FlRendererPrivate* priv = reinterpret_cast<FlRendererPrivate*>(
      fl_renderer_get_instance_private(self));
 
  g_return_if_fail(FL_IS_RENDERER(self));
 
  GLuint vertex_shader = glCreateShader(GL_VERTEX_SHADER);
  glShaderSource(vertex_shader, 1, &vertex_shader_src, nullptr);
  glCompileShader(vertex_shader);
  int vertex_compile_status;
  glGetShaderiv(vertex_shader, GL_COMPILE_STATUS, &vertex_compile_status);
  if (vertex_compile_status == GL_FALSE) {
    g_autofree gchar* shader_log = get_shader_log(vertex_shader);
    g_warning("Failed to compile vertex shader: %s", shader_log);
  }
 
  GLuint fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
  glShaderSource(fragment_shader, 1, &fragment_shader_src, nullptr);
  glCompileShader(fragment_shader);
  int fragment_compile_status;
  glGetShaderiv(fragment_shader, GL_COMPILE_STATUS, &fragment_compile_status);
  if (fragment_compile_status == GL_FALSE) {
    g_autofree gchar* shader_log = get_shader_log(fragment_shader);
    g_warning("Failed to compile fragment shader: %s", shader_log);
  }
 
  priv->program = glCreateProgram();
  glAttachShader(priv->program, vertex_shader);
  glAttachShader(priv->program, fragment_shader);
  glLinkProgram(priv->program);
 
  int link_status;
  glGetProgramiv(priv->program, GL_LINK_STATUS, &link_status);
  if (link_status == GL_FALSE) {
    g_autofree gchar* program_log = get_program_log(priv->program);
    g_warning("Failed to link program: %s", program_log);
  }
 
  glDeleteShader(vertex_shader);
  glDeleteShader(fragment_shader);
}

References fragment_shader_src, get_program_log(), get_shader_log(), priv, and vertex_shader_src.

Referenced by realize_cb().

fl_renderer_start()

gboolean fl_renderer_start	(	FlRenderer *	renderer,
		FlView *	view
	)

fl_renderer_start: @renderer: an #FlRenderer. @view: the view Flutter is renderering to.

Start the renderer.

Returns: TRUE if successfully started.

Definition at line 125 of file fl_renderer.cc.

                                                           {
  FlRendererPrivate* priv = reinterpret_cast<FlRendererPrivate*>(
      fl_renderer_get_instance_private(self));
 
  g_return_val_if_fail(FL_IS_RENDERER(self), FALSE);
 
  priv->view = view;
  return TRUE;
}

References priv, and TRUE.

Referenced by realize_cb().

fl_renderer_unblock_main_thread()

static void fl_renderer_unblock_main_thread ( FlRenderer *  self )

static

Definition at line 91 of file fl_renderer.cc.

                                                              {
  FlRendererPrivate* priv = reinterpret_cast<FlRendererPrivate*>(
      fl_renderer_get_instance_private(self));
  if (priv->blocking_main_thread) {
    priv->blocking_main_thread = false;
 
    FlTaskRunner* runner =
        fl_engine_get_task_runner(fl_view_get_engine(priv->view));
    fl_task_runner_release_main_thread(runner);
  }
}

References fl_engine_get_task_runner(), fl_task_runner_release_main_thread(), fl_view_get_engine(), and priv.

Referenced by fl_renderer_dispose(), and fl_renderer_present_layers().

fl_renderer_wait_for_frame()

void fl_renderer_wait_for_frame	(	FlRenderer *	renderer,
		int	target_width,
		int	target_height
	)

fl_renderer_wait_for_frame: @renderer: an #FlRenderer. @target_width: width of frame being waited for @target_height: height of frame being waited for

Holds the thread until frame with requested dimensions is presented. While waiting for frame Flutter platform and raster tasks are being processed.

Definition at line 202 of file fl_renderer.cc.

                                                   {
  FlRendererPrivate* priv = reinterpret_cast<FlRendererPrivate*>(
      fl_renderer_get_instance_private(self));
 
  g_return_if_fail(FL_IS_RENDERER(self));
 
  priv->target_width = target_width;
  priv->target_height = target_height;
 
  if (priv->had_first_frame && !priv->blocking_main_thread) {
    priv->blocking_main_thread = true;
    FlTaskRunner* runner =
        fl_engine_get_task_runner(fl_view_get_engine(priv->view));
    fl_task_runner_block_main_thread(runner);
  }
}

References fl_engine_get_task_runner(), fl_task_runner_block_main_thread(), fl_view_get_engine(), and priv.

Referenced by handle_geometry_changed().

get_program_log()

static gchar* get_program_log ( GLuint  program )

static

Definition at line 74 of file fl_renderer.cc.

                                              {
  int log_length;
  gchar* log;
 
  glGetProgramiv(program, GL_INFO_LOG_LENGTH, &log_length);
 
  log = static_cast<gchar*>(g_malloc(log_length + 1));
  glGetProgramInfoLog(program, log_length, nullptr, log);
 
  return log;
}

Referenced by fl_renderer_setup().

get_shader_log()

static gchar* get_shader_log ( GLuint  shader )

static

Definition at line 61 of file fl_renderer.cc.

                                            {
  int log_length;
  gchar* log;
 
  glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &log_length);
 
  log = static_cast<gchar*>(g_malloc(log_length + 1));
  glGetShaderInfoLog(shader, log_length, nullptr, log);
 
  return log;
}

Referenced by fl_renderer_setup().

pixels_to_gl_coords()

static GLfloat pixels_to_gl_coords ( GLfloat  position, GLfloat  pixels  )

static

Converts a pixel co-ordinate from 0..pixels to OpenGL -1..1.

Definition at line 87 of file fl_renderer.cc.

                                                                     {
  return (2.0 * position / pixels) - 1.0;
}

Referenced by fl_renderer_render().

Variable Documentation

fragment_shader_src

const char* fragment_shader_src

static

Initial value:

=
    "uniform sampler2D texture;\n"
    "varying vec2 texcoord;\n"
    "\n"
    "void main() {\n"
    "  gl_FragColor = texture2D(texture, texcoord);\n"
    "}\n"

Definition at line 27 of file fl_renderer.cc.

Referenced by fl_renderer_setup().

vertex_shader_src

const char* vertex_shader_src

static

Initial value:

=
    "attribute vec2 position;\n"
    "attribute vec2 in_texcoord;\n"
    "varying vec2 texcoord;\n"
    "\n"
    "void main() {\n"
    "  gl_Position = vec4(position, 0, 1);\n"
    "  texcoord = in_texcoord;\n"
    "}\n"

Definition at line 16 of file fl_renderer.cc.

Referenced by fl_renderer_setup().