fl_renderer.h File Reference

#include <gtk/gtk.h>
#include "flutter/shell/platform/linux/public/flutter_linux/fl_dart_project.h"
#include "flutter/shell/platform/linux/public/flutter_linux/fl_view.h"
#include "flutter/shell/platform/embedder/embedder.h"

Go to the source code of this file.

Classes
struct	_FlRendererClass

Enumerations
enum	FlRendererError { FL_RENDERER_ERROR_FAILED }

Functions
GQuark	fl_renderer_error_quark (void) G_GNUC_CONST
gboolean	fl_renderer_start (FlRenderer *renderer, FlView *view)
: a function name.
fl_renderer_get_proc_address: @renderer: an #FlRenderer. Gets the rendering API function that matches the given name. Returns: a function pointer.
void *	fl_renderer_get_proc_address (FlRenderer *renderer, const char *name)
void	fl_renderer_make_current (FlRenderer *renderer)
void	fl_renderer_make_resource_current (FlRenderer *renderer)
void	fl_renderer_clear_current (FlRenderer *renderer)
guint32	fl_renderer_get_fbo (FlRenderer *renderer)
gboolean	fl_renderer_create_backing_store (FlRenderer *renderer, const FlutterBackingStoreConfig *config, FlutterBackingStore *backing_store_out)
gboolean	fl_renderer_collect_backing_store (FlRenderer *renderer, const FlutterBackingStore *backing_store)
gboolean	fl_renderer_present_layers (FlRenderer *renderer, const FlutterLayer **layers, size_t layers_count)
void	fl_renderer_wait_for_frame (FlRenderer *renderer, int target_width, int target_height)
void	fl_renderer_setup (FlRenderer *renderer)
void	fl_renderer_render (FlRenderer *renderer, int width, int height)
void	fl_renderer_cleanup (FlRenderer *renderer)
gdouble	fl_renderer_get_refresh_rate (FlRenderer *renderer)

Enumeration Type Documentation

FlRendererError

enum FlRendererError

FlRendererError: Errors for #FlRenderer objects to set on failures.

Enumerator
FL_RENDERER_ERROR_FAILED

Definition at line 22 of file fl_renderer.h.

             {
  // NOLINTBEGIN(readability-identifier-naming)
  FL_RENDERER_ERROR_FAILED,
  // NOLINTEND(readability-identifier-naming)
} FlRendererError;

Function Documentation

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 388 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);
}

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);
}

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 197 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;
}

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 168 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;
}

fl_renderer_error_quark()

GQuark fl_renderer_error_quark

(

void

)

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 161 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;
}

fl_renderer_get_proc_address()

void * fl_renderer_get_proc_address	(	FlRenderer *	renderer,
		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));
}

fl_renderer_get_refresh_rate()

gdouble fl_renderer_get_refresh_rate

(

FlRenderer *

renderer

)

fl_renderer_get_refresh_rate: @renderer: an #FlRenderer.

Returns: The refresh rate of the display in Hz. If the refresh rate is not available, returns -1.0.

Definition at line 156 of file fl_renderer.cc.

                                                       {
  g_return_val_if_fail(FL_IS_RENDERER(self), -1.0);
  return FL_RENDERER_GET_CLASS(self)->get_refresh_rate(self);
}

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);
}

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);
}

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 226 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;
}

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 316 of file fl_renderer.cc.

                                                                 {
  FlRendererPrivate* priv = reinterpret_cast<FlRendererPrivate*>(
      fl_renderer_get_instance_private(self));
 
  g_return_if_fail(FL_IS_RENDERER(self));
 
  // Save bindings that are set by this function.  All bindings must be restored
  // to their original values because Skia expects that its bindings have not
  // been altered.
  GLint saved_texture_binding;
  glGetIntegerv(GL_TEXTURE_BINDING_2D, &saved_texture_binding);
  GLint saved_vao_binding;
  glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &saved_vao_binding);
  GLint saved_array_buffer_binding;
  glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &saved_array_buffer_binding);
 
  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();
 
  glBindTexture(GL_TEXTURE_2D, saved_texture_binding);
  glBindVertexArray(saved_vao_binding);
  glBindBuffer(GL_ARRAY_BUFFER, saved_array_buffer_binding);
}

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 274 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);
}

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;
}

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 207 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);
  }
}