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_engine_private.h"
#include "flutter/shell/platform/linux/fl_framebuffer.h"
#include "flutter/shell/platform/linux/fl_view_private.h"

Go to the source code of this file.

Classes
struct	FlRendererPrivate

Functions
static gboolean	is_nvidia ()
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	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_view (FlRenderer *self, FlutterViewId view_id, FlView *view)
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)
gdouble	fl_renderer_get_refresh_rate (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_view()

void fl_renderer_add_view	(	FlRenderer *	renderer,
		FlutterViewId	view_id,
		FlView *	view
	)

fl_renderer_add_view: @renderer: an #FlRenderer. @view_id: the ID of the view. @view: the view Flutter is renderering to.

Add a view to render on.

Definition at line 314 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_insert(priv->views, GINT_TO_POINTER(view_id), view);
}

References priv, and view.

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 291 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 528 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 350 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 399 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 367 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 277 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 360 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 334 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_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 355 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);
}

Referenced by fl_engine_start(), and TEST().

fl_renderer_init()

static void fl_renderer_init ( FlRenderer *  self )

static

Definition at line 295 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, nullptr);
  priv->framebuffers_by_view_id =
      g_hash_table_new_full(g_direct_hash, g_direct_equal, nullptr,
                            (GDestroyNotify)g_ptr_array_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 340 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 345 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 429 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);
 
  GPtrArray* framebuffers = reinterpret_cast<GPtrArray*>((g_hash_table_lookup(
      priv->framebuffers_by_view_id, GINT_TO_POINTER(view_id))));
  if (framebuffers == nullptr) {
    framebuffers = g_ptr_array_new_with_free_func(g_object_unref);
    g_hash_table_insert(priv->framebuffers_by_view_id, GINT_TO_POINTER(view_id),
                        framebuffers);
  }
  g_ptr_array_set_size(framebuffers, 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;
        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;
    }
  }
 
  FlView* view =
      FL_VIEW(g_hash_table_lookup(priv->views, GINT_TO_POINTER(view_id)));
  if (view != nullptr) {
    fl_view_redraw(view);
  }
 
  return TRUE;
}

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

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 325 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 501 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) {
    if (priv->has_gl_framebuffer_blit) {
      render_with_blit(self, framebuffers);
    } else {
      render_with_textures(self, framebuffers, width, height);
    }
  }
 
  glFlush();
}

References height, priv, render_with_blit(), render_with_textures(), 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 305 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 484 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 is temporarily disabled due to
  // https://github.com/flutter/flutter/issues/152099
  priv->has_gl_framebuffer_blit =
      !is_nvidia() && (epoxy_gl_version() >= 30 ||
                       epoxy_has_gl_extension("GL_EXT_framebuffer_blit"));
 
  if (!priv->has_gl_framebuffer_blit) {
    setup_shader(self);
  }
}

References is_nvidia(), 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 136 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 409 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().

get_program_log()

static gchar* get_program_log ( GLuint  program )

static

Definition at line 100 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 87 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 118 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 81 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().

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

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

Referenced by render_with_textures().

render_with_blit()

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

static

Definition at line 189 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 fl_renderer_render().

render_with_textures()

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

static

Definition at line 209 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, (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 fl_renderer_render().

setup_shader()

static void setup_shader ( FlRenderer *  self )

static

Definition at line 149 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().