fl_renderer.cc File Reference

#include "fl_renderer.h"
#include <epoxy/egl.h>
#include <epoxy/gl.h>
#include "flutter/common/constants.h"
#include "flutter/shell/platform/embedder/embedder.h"
#include "flutter/shell/platform/linux/fl_engine_private.h"
#include "flutter/shell/platform/linux/fl_framebuffer.h"

Go to the source code of this file.

Classes
struct	FlRendererPrivate

Functions
static void	free_weak_ref (gpointer value)
static gboolean	is_nvidia ()
static gboolean	is_vivante ()
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	initialize (FlRenderer *self)
static void	fl_renderer_unblock_main_thread (FlRenderer *self)
static void	setup_shader (FlRenderer *self)
static void	render_with_blit (FlRenderer *self, GPtrArray *framebuffers)
static void	render_with_textures (FlRenderer *self, GPtrArray *framebuffers, int width, int height)
static void	render (FlRenderer *self, GPtrArray *framebuffers, int width, int height)
static void	fl_renderer_dispose (GObject *object)
static void	fl_renderer_class_init (FlRendererClass *klass)
static void	fl_renderer_init (FlRenderer *self)
void	fl_renderer_set_engine (FlRenderer *self, FlEngine *engine)
void	fl_renderer_add_renderable (FlRenderer *self, FlutterViewId view_id, FlRenderable *renderable)
void	fl_renderer_remove_view (FlRenderer *self, FlutterViewId view_id)
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 *self, 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, FlutterViewId view_id, const FlutterLayer **layers, size_t layers_count)
void	fl_renderer_setup (FlRenderer *self)
void	fl_renderer_render (FlRenderer *self, FlutterViewId view_id, int width, int height, const GdkRGBA *background_color)
void	fl_renderer_cleanup (FlRenderer *self)

Variables
static const char *	vertex_shader_src
static const char *	fragment_shader_src

Function Documentation

fl_renderer_add_renderable()

void fl_renderer_add_renderable	(	FlRenderer *	renderer,
		FlutterViewId	view_id,
		FlRenderable *	renderable
	)

fl_renderer_add_renderable: @renderer: an #FlRenderer. @view_id: the ID of the view. @renderable: object that is to be rendered on.

Add a view to render on.

Definition at line 341 of file fl_renderer.cc.

                                                          {
  FlRendererPrivate* priv = reinterpret_cast<FlRendererPrivate*>(
      fl_renderer_get_instance_private(self));
 
  g_return_if_fail(FL_IS_RENDERER(self));
 
  GWeakRef* ref = g_new(GWeakRef, 1);
  g_weak_ref_init(ref, G_OBJECT(renderable));
  g_hash_table_insert(priv->views, GINT_TO_POINTER(view_id), ref);
}

References priv.

Referenced by fl_view_new_for_engine(), realize_cb(), and TEST().

fl_renderer_class_init()

static void fl_renderer_class_init ( FlRendererClass *  klass )

static

Definition at line 318 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 608 of file fl_renderer.cc.

                                           {
  FlRendererPrivate* priv = reinterpret_cast<FlRendererPrivate*>(
      fl_renderer_get_instance_private(self));
 
  g_return_if_fail(FL_IS_RENDERER(self));
 
  if (priv->program != 0) {
    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 379 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 423 of file fl_renderer.cc.

                                              {
  fl_renderer_make_current(self);
 
  // OpenGL context is required when destroying #FlFramebuffer.
  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 391 of file fl_renderer.cc.

                                            {
  FlRendererPrivate* priv = reinterpret_cast<FlRendererPrivate*>(
      fl_renderer_get_instance_private(self));
 
  fl_renderer_make_current(self);
 
  initialize(self);
 
  FlFramebuffer* framebuffer = fl_framebuffer_new(
      priv->general_format, config->size.width, config->size.height);
  if (!framebuffer) {
    g_warning("Failed to create backing store");
    return FALSE;
  }
 
  backing_store_out->type = kFlutterBackingStoreTypeOpenGL;
  backing_store_out->open_gl.type = kFlutterOpenGLTargetTypeFramebuffer;
  backing_store_out->open_gl.framebuffer.user_data = framebuffer;
  backing_store_out->open_gl.framebuffer.name =
      fl_framebuffer_get_id(framebuffer);
  backing_store_out->open_gl.framebuffer.target = priv->sized_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_framebuffer_get_id(), fl_framebuffer_new(), fl_renderer_make_current(), initialize(), priv, and TRUE.

Referenced by compositor_create_backing_store_callback(), and TEST().

fl_renderer_dispose()

static void fl_renderer_dispose ( GObject *  object )

static

Definition at line 304 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_weak_ref_clear(&priv->engine);
  g_clear_pointer(&priv->views, g_hash_table_unref);
  g_clear_pointer(&priv->framebuffers_by_view_id, g_hash_table_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 384 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 363 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 322 of file fl_renderer.cc.

                                               {
  FlRendererPrivate* priv = reinterpret_cast<FlRendererPrivate*>(
      fl_renderer_get_instance_private(self));
  priv->views = g_hash_table_new_full(g_direct_hash, g_direct_equal, nullptr,
                                      free_weak_ref);
  priv->framebuffers_by_view_id = g_hash_table_new_full(
      g_direct_hash, g_direct_equal, nullptr,
      reinterpret_cast<GDestroyNotify>(g_ptr_array_unref));
}

References free_weak_ref(), and 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 369 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 374 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,
		FlutterViewId	view_id,
		const FlutterLayer **	layers,
		size_t	layers_count
	)

fl_renderer_present_layers: @renderer: an #FlRenderer. @view_id: view to present. @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 453 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);
 
  g_autoptr(GPtrArray) framebuffers =
      g_ptr_array_new_with_free_func(g_object_unref);
  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;
        FlFramebuffer* framebuffer =
            FL_FRAMEBUFFER(backing_store->open_gl.framebuffer.user_data);
        g_ptr_array_add(framebuffers, g_object_ref(framebuffer));
      } break;
      case kFlutterLayerContentTypePlatformView: {
        // TODO(robert-ancell) Not implemented -
        // https://github.com/flutter/flutter/issues/41724
      } break;
    }
  }
 
  GWeakRef* ref = static_cast<GWeakRef*>(
      g_hash_table_lookup(priv->views, GINT_TO_POINTER(view_id)));
  g_autoptr(FlRenderable) renderable =
      ref != nullptr ? FL_RENDERABLE(g_weak_ref_get(ref)) : nullptr;
  if (renderable == nullptr) {
    return TRUE;
  }
 
  if (view_id == flutter::kFlutterImplicitViewId) {
    // Store for rendering later
    g_hash_table_insert(priv->framebuffers_by_view_id, GINT_TO_POINTER(view_id),
                        g_ptr_array_ref(framebuffers));
  } else {
    // Composite into a single framebuffer.
    if (framebuffers->len > 1) {
      size_t width = 0, height = 0;
 
      for (guint i = 0; i < framebuffers->len; i++) {
        FlFramebuffer* framebuffer =
            FL_FRAMEBUFFER(g_ptr_array_index(framebuffers, i));
 
        size_t w = fl_framebuffer_get_width(framebuffer);
        size_t h = fl_framebuffer_get_height(framebuffer);
        if (w > width) {
          width = w;
        }
        if (h > height) {
          height = h;
        }
      }
 
      FlFramebuffer* view_framebuffer =
          fl_framebuffer_new(priv->general_format, width, height);
      glBindFramebuffer(GL_DRAW_FRAMEBUFFER,
                        fl_framebuffer_get_id(view_framebuffer));
      render(self, framebuffers, width, height);
      g_ptr_array_set_size(framebuffers, 0);
      g_ptr_array_add(framebuffers, view_framebuffer);
    }
 
    // Read back pixel values.
    FlFramebuffer* framebuffer =
        FL_FRAMEBUFFER(g_ptr_array_index(framebuffers, 0));
    size_t width = fl_framebuffer_get_width(framebuffer);
    size_t height = fl_framebuffer_get_height(framebuffer);
    size_t data_length = width * height * 4;
    g_autofree uint8_t* data = static_cast<uint8_t*>(malloc(data_length));
    glBindFramebuffer(GL_READ_FRAMEBUFFER, fl_framebuffer_get_id(framebuffer));
    glReadPixels(0, 0, width, height, priv->general_format, GL_UNSIGNED_BYTE,
                 data);
 
    // Write into a texture in the views context.
    fl_renderable_make_current(renderable);
    FlFramebuffer* view_framebuffer =
        fl_framebuffer_new(priv->general_format, width, height);
    glBindFramebuffer(GL_DRAW_FRAMEBUFFER,
                      fl_framebuffer_get_id(view_framebuffer));
    glBindTexture(GL_TEXTURE_2D,
                  fl_framebuffer_get_texture_id(view_framebuffer));
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA,
                 GL_UNSIGNED_BYTE, data);
 
    g_autoptr(GPtrArray) secondary_framebuffers =
        g_ptr_array_new_with_free_func(g_object_unref);
    g_ptr_array_add(secondary_framebuffers, g_object_ref(view_framebuffer));
    g_hash_table_insert(priv->framebuffers_by_view_id, GINT_TO_POINTER(view_id),
                        g_ptr_array_ref(secondary_framebuffers));
  }
 
  fl_renderable_redraw(renderable);
 
  return TRUE;
}

References fl_framebuffer_get_height(), fl_framebuffer_get_id(), fl_framebuffer_get_texture_id(), fl_framebuffer_get_width(), fl_framebuffer_new(), fl_renderable_make_current(), fl_renderable_redraw(), fl_renderer_unblock_main_thread(), height, i, priv, render(), TRUE, and width.

Referenced by compositor_present_view_callback(), and TEST().

fl_renderer_remove_view()

void fl_renderer_remove_view	(	FlRenderer *	renderer,
		FlutterViewId	view_id
	)

fl_renderer_remove_view: @renderer: an #FlRenderer. @view_id: the ID of the view.

Remove a view from the renderer.

Definition at line 354 of file fl_renderer.cc.

                                                                      {
  FlRendererPrivate* priv = reinterpret_cast<FlRendererPrivate*>(
      fl_renderer_get_instance_private(self));
 
  g_return_if_fail(FL_IS_RENDERER(self));
 
  g_hash_table_remove(priv->views, GINT_TO_POINTER(view_id));
}

References priv.

Referenced by fl_view_dispose().

fl_renderer_render()

void fl_renderer_render	(	FlRenderer *	renderer,
		FlutterViewId	view_id,
		int	width,
		int	height,
		const GdkRGBA *	background_color
	)

fl_renderer_render: @renderer: an #FlRenderer. @view_id: view to render. @width: width of the window in pixels. @height: height of the window in pixels. @background_color: color to use for background.

Performs OpenGL commands to render current Flutter view.

Definition at line 585 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(background_color->red, background_color->green,
               background_color->blue, background_color->alpha);
  glClear(GL_COLOR_BUFFER_BIT);
 
  GPtrArray* framebuffers = reinterpret_cast<GPtrArray*>((g_hash_table_lookup(
      priv->framebuffers_by_view_id, GINT_TO_POINTER(view_id))));
  if (framebuffers != nullptr) {
    render(self, framebuffers, width, height);
  }
 
  glFlush();
}

References height, priv, render(), and width.

Referenced by render_cb(), and TEST().

fl_renderer_set_engine()

void fl_renderer_set_engine	(	FlRenderer *	renderer,
		FlEngine *	engine
	)

fl_renderer_set_engine: @renderer: an #FlRenderer. @engine: an #FlEngine.

Called when the renderer is connected to an engine.

Definition at line 332 of file fl_renderer.cc.

                                                                {
  FlRendererPrivate* priv = reinterpret_cast<FlRendererPrivate*>(
      fl_renderer_get_instance_private(self));
 
  g_return_if_fail(FL_IS_RENDERER(self));
 
  g_weak_ref_init(&priv->engine, engine);
}

References priv.

Referenced by fl_engine_new_with_renderer().

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

                                         {
  FlRendererPrivate* priv = reinterpret_cast<FlRendererPrivate*>(
      fl_renderer_get_instance_private(self));
 
  g_return_if_fail(FL_IS_RENDERER(self));
 
  // Note: NVIDIA and Vivante are temporarily disabled due to
  // https://github.com/flutter/flutter/issues/152099
  priv->has_gl_framebuffer_blit =
      !is_nvidia() && !is_vivante() &&
      (epoxy_gl_version() >= 30 ||
       epoxy_has_gl_extension("GL_EXT_framebuffer_blit"));
 
  if (!priv->has_gl_framebuffer_blit) {
    setup_shader(self);
  }
}

References is_nvidia(), is_vivante(), priv, and setup_shader().

Referenced by realize_cb(), and TEST().

fl_renderer_unblock_main_thread()

static void fl_renderer_unblock_main_thread ( FlRenderer *  self )

static

Definition at line 148 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;
 
    g_autoptr(FlEngine) engine = FL_ENGINE(g_weak_ref_get(&priv->engine));
    if (engine != nullptr) {
      fl_task_runner_release_main_thread(fl_engine_get_task_runner(engine));
    }
  }
}

References fl_engine_get_task_runner(), fl_task_runner_release_main_thread(), 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 433 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;
    g_autoptr(FlEngine) engine = FL_ENGINE(g_weak_ref_get(&priv->engine));
    if (engine != nullptr) {
      fl_task_runner_block_main_thread(fl_engine_get_task_runner(engine));
    }
  }
}

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

Referenced by handle_geometry_changed(), and TEST().

free_weak_ref()

static void free_weak_ref ( gpointer  value )

static

Definition at line 80 of file fl_renderer.cc.

                                          {
  GWeakRef* ref = static_cast<GWeakRef*>(value);
  g_weak_ref_clear(ref);
  free(ref);
}

References value.

Referenced by fl_renderer_init().

get_program_log()

static gchar* get_program_log ( GLuint  program )

static

Definition at line 112 of file fl_renderer.cc.

                                              {
  GLint 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 setup_shader().

get_shader_log()

static gchar* get_shader_log ( GLuint  shader )

static

Definition at line 99 of file fl_renderer.cc.

                                            {
  GLint 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 setup_shader().

initialize()

static void initialize ( FlRenderer *  self )

static

Definition at line 130 of file fl_renderer.cc.

                                         {
  FlRendererPrivate* priv = reinterpret_cast<FlRendererPrivate*>(
      fl_renderer_get_instance_private(self));
 
  if (priv->initialized) {
    return;
  }
  priv->initialized = TRUE;
 
  if (epoxy_has_gl_extension("GL_EXT_texture_format_BGRA8888")) {
    priv->sized_format = GL_BGRA8_EXT;
    priv->general_format = GL_BGRA_EXT;
  } else {
    priv->sized_format = GL_RGBA8;
    priv->general_format = GL_RGBA;
  }
}

References priv, and TRUE.

Referenced by fl_renderer_create_backing_store().

is_nvidia()

static gboolean is_nvidia ( )

static

Definition at line 87 of file fl_renderer.cc.

                            {
  const gchar* vendor = reinterpret_cast<const gchar*>(glGetString(GL_VENDOR));
  return strstr(vendor, "NVIDIA") != nullptr;
}

Referenced by fl_renderer_setup().

is_vivante()

static gboolean is_vivante ( )

static

Definition at line 93 of file fl_renderer.cc.

                             {
  const gchar* vendor = reinterpret_cast<const gchar*>(glGetString(GL_VENDOR));
  return strstr(vendor, "Vivante Corporation") != nullptr;
}

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

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

Referenced by render_with_textures().

render()

static void render ( FlRenderer *  self, GPtrArray *  framebuffers, int  width, int  height  )

static

Definition at line 290 of file fl_renderer.cc.

                               {
  FlRendererPrivate* priv = reinterpret_cast<FlRendererPrivate*>(
      fl_renderer_get_instance_private(self));
 
  if (priv->has_gl_framebuffer_blit) {
    render_with_blit(self, framebuffers);
  } else {
    render_with_textures(self, framebuffers, width, height);
  }
}

References height, priv, render_with_blit(), render_with_textures(), and width.

Referenced by fl_renderer_present_layers(), and fl_renderer_render().

render_with_blit()

static void render_with_blit ( FlRenderer *  self, GPtrArray *  framebuffers  )

static

Definition at line 201 of file fl_renderer.cc.

                                                                        {
  // Disable the scissor test as it can affect blit operations.
  // Prevents regressions like: https://github.com/flutter/flutter/issues/140828
  // See OpenGL specification version 4.6, section 18.3.1.
  glDisable(GL_SCISSOR_TEST);
 
  for (guint i = 0; i < framebuffers->len; i++) {
    FlFramebuffer* framebuffer =
        FL_FRAMEBUFFER(g_ptr_array_index(framebuffers, i));
 
    GLuint framebuffer_id = fl_framebuffer_get_id(framebuffer);
    glBindFramebuffer(GL_READ_FRAMEBUFFER, framebuffer_id);
    size_t width = fl_framebuffer_get_width(framebuffer);
    size_t height = fl_framebuffer_get_height(framebuffer);
    glBlitFramebuffer(0, 0, width, height, 0, 0, width, height,
                      GL_COLOR_BUFFER_BIT, GL_NEAREST);
  }
  glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
}

References fl_framebuffer_get_height(), fl_framebuffer_get_id(), fl_framebuffer_get_width(), height, i, and width.

Referenced by render().

render_with_textures()

static void render_with_textures ( FlRenderer *  self, GPtrArray *  framebuffers, int  width, int  height  )

static

Definition at line 221 of file fl_renderer.cc.

                                             {
  FlRendererPrivate* priv = reinterpret_cast<FlRendererPrivate*>(
      fl_renderer_get_instance_private(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);
 
  glEnable(GL_BLEND);
  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
  glUseProgram(priv->program);
 
  for (guint i = 0; i < framebuffers->len; i++) {
    FlFramebuffer* framebuffer =
        FL_FRAMEBUFFER(g_ptr_array_index(framebuffers, i));
 
    GLuint texture_id = fl_framebuffer_get_texture_id(framebuffer);
    glBindTexture(GL_TEXTURE_2D, texture_id);
 
    // Translate into OpenGL co-ordinates
    size_t texture_width = fl_framebuffer_get_width(framebuffer);
    size_t texture_height = fl_framebuffer_get_height(framebuffer);
    GLfloat x0 = pixels_to_gl_coords(0, width);
    GLfloat y0 = pixels_to_gl_coords(height - texture_height, height);
    GLfloat x1 = pixels_to_gl_coords(texture_width, width);
    GLfloat y1 = pixels_to_gl_coords(height, 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,
                          reinterpret_cast<void*>(sizeof(GLfloat) * 2));
 
    glDrawArrays(GL_TRIANGLES, 0, 6);
 
    glDeleteVertexArrays(1, &vao);
    glDeleteBuffers(1, &vertex_buffer);
  }
 
  glDisable(GL_BLEND);
 
  glBindTexture(GL_TEXTURE_2D, saved_texture_binding);
  glBindVertexArray(saved_vao_binding);
  glBindBuffer(GL_ARRAY_BUFFER, saved_array_buffer_binding);
}

References fl_framebuffer_get_height(), fl_framebuffer_get_texture_id(), fl_framebuffer_get_width(), height, i, pixels_to_gl_coords(), priv, texture_id, and width.

Referenced by render().

setup_shader()

static void setup_shader ( FlRenderer *  self )

static

Definition at line 161 of file fl_renderer.cc.

                                           {
  FlRendererPrivate* priv = reinterpret_cast<FlRendererPrivate*>(
      fl_renderer_get_instance_private(self));
 
  GLuint vertex_shader = glCreateShader(GL_VERTEX_SHADER);
  glShaderSource(vertex_shader, 1, &vertex_shader_src, nullptr);
  glCompileShader(vertex_shader);
  GLint 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);
  GLint 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);
 
  GLint 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 fl_renderer_setup().

Variable Documentation

fragment_shader_src

const char* fragment_shader_src

static

Initial value:

=
    "#ifdef GL_ES\n"
    "precision mediump float;\n"
    "#endif\n"
    "\n"
    "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 setup_shader().

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 setup_shader().