fl_compositor_opengl_shader.cc File Reference

#include "fl_compositor_opengl_shader.h"
#include <epoxy/gl.h>

Go to the source code of this file.

Classes
struct	_FlCompositorOpenGLShader

Functions
	G_DEFINE_TYPE (FlCompositorOpenGLShader, fl_compositor_opengl_shader, G_TYPE_OBJECT) static gchar *get_shader_log(GLuint shader)
static gchar *	get_program_log (GLuint program)
static void	setup_shader (FlCompositorOpenGLShader *self)
static void	fl_compositor_opengl_shader_dispose (GObject *object)
static void	fl_compositor_opengl_shader_class_init (FlCompositorOpenGLShaderClass *klass)
static void	fl_compositor_opengl_shader_init (FlCompositorOpenGLShader *self)
FlCompositorOpenGLShader *	fl_compositor_opengl_shader_new (FlOpenGLManager *opengl_manager)
void	fl_compositor_opengl_shader_use (FlCompositorOpenGLShader *self)
void	fl_compositor_opengl_shader_set_offset (FlCompositorOpenGLShader *self, double x, double y)
void	fl_compositor_opengl_shader_set_scale (FlCompositorOpenGLShader *self, double x, double y)

Variables
static const char *	vertex_shader_src
static const char *	fragment_shader_src

Function Documentation

fl_compositor_opengl_shader_class_init()

static void fl_compositor_opengl_shader_class_init ( FlCompositorOpenGLShaderClass *  klass )

static

Definition at line 168 of file fl_compositor_opengl_shader.cc.

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

References fl_compositor_opengl_shader_dispose().

fl_compositor_opengl_shader_dispose()

static void fl_compositor_opengl_shader_dispose ( GObject *  object )

static

Definition at line 143 of file fl_compositor_opengl_shader.cc.

                                                                 {
  FlCompositorOpenGLShader* self = FL_COMPOSITOR_OPENGL_SHADER(object);
 
  if (self->opengl_manager != nullptr) {
    if (fl_opengl_manager_make_platform_current(self->opengl_manager)) {
      if (self->program != 0) {
        glDeleteProgram(self->program);
      }
      if (self->vertex_buffer != 0) {
        glDeleteBuffers(1, &self->vertex_buffer);
      }
    } else {
      g_warning(
          "Failed to cleanup compositor shaders, unable to make OpenGL context "
          "current");
    }
  }
  self->program = 0;
  self->vertex_buffer = 0;
 
  g_clear_object(&self->opengl_manager);
 
  G_OBJECT_CLASS(fl_compositor_opengl_shader_parent_class)->dispose(object);
}

References fl_opengl_manager_make_platform_current().

Referenced by fl_compositor_opengl_shader_class_init().

fl_compositor_opengl_shader_init()

static void fl_compositor_opengl_shader_init ( FlCompositorOpenGLShader *  self )

static

Definition at line 173 of file fl_compositor_opengl_shader.cc.

{}

fl_compositor_opengl_shader_new()

FlCompositorOpenGLShader* fl_compositor_opengl_shader_new

(

FlOpenGLManager *

opengl_manager

)

Definition at line 175 of file fl_compositor_opengl_shader.cc.

                                     {
  g_return_val_if_fail(FL_IS_OPENGL_MANAGER(opengl_manager), nullptr);
 
  FlCompositorOpenGLShader* self = FL_COMPOSITOR_OPENGL_SHADER(
      g_object_new(fl_compositor_opengl_shader_get_type(), nullptr));
 
  self->opengl_manager = FL_OPENGL_MANAGER(g_object_ref(opengl_manager));
 
  setup_shader(self);
 
  return self;
}

References opengl_manager, and setup_shader().

Referenced by fl_compositor_opengl_new().

fl_compositor_opengl_shader_set_offset()

void fl_compositor_opengl_shader_set_offset	(	FlCompositorOpenGLShader *	shader,
		double	x,
		double	y
	)

fl_compositor_opengl_shader_set_offset: @shader: an #FlCompositorOpenGLShader. @x: horizontal offset. @y: vertical offset.

Sets the layer offset uniform. The program must be current (see fl_compositor_opengl_shader_use).

Definition at line 206 of file fl_compositor_opengl_shader.cc.

                                                      {
  g_return_if_fail(FL_IS_COMPOSITOR_OPENGL_SHADER(self));
  glUniform2f(self->offset_location, x, y);
}

References x, and y.

fl_compositor_opengl_shader_set_scale()

void fl_compositor_opengl_shader_set_scale	(	FlCompositorOpenGLShader *	shader,
		double	x,
		double	y
	)

fl_compositor_opengl_shader_set_scale: @shader: an #FlCompositorOpenGLShader. @x: horizontal scale. @y: vertical scale.

Sets the layer scale uniform. The program must be current (see fl_compositor_opengl_shader_use).

Definition at line 213 of file fl_compositor_opengl_shader.cc.

                                                     {
  g_return_if_fail(FL_IS_COMPOSITOR_OPENGL_SHADER(self));
  glUniform2f(self->scale_location, x, y);
}

References x, and y.

fl_compositor_opengl_shader_use()

void fl_compositor_opengl_shader_use

(

FlCompositorOpenGLShader *

shader

)

fl_compositor_opengl_shader_use: @shader: an #FlCompositorOpenGLShader.

Binds the shader's vertex buffer, configures the vertex attributes and makes the program current. Requires a valid OpenGL context.

Definition at line 189 of file fl_compositor_opengl_shader.cc.

                                                                     {
  g_return_if_fail(FL_IS_COMPOSITOR_OPENGL_SHADER(self));
 
  glBindBuffer(GL_ARRAY_BUFFER, self->vertex_buffer);
  GLint position_location = glGetAttribLocation(self->program, "position");
  glEnableVertexAttribArray(position_location);
  glVertexAttribPointer(position_location, 2, GL_FLOAT, GL_FALSE,
                        sizeof(GLfloat) * 4, 0);
  GLint texcoord_location = glGetAttribLocation(self->program, "in_texcoord");
  glEnableVertexAttribArray(texcoord_location);
  glVertexAttribPointer(texcoord_location, 2, GL_FLOAT, GL_FALSE,
                        sizeof(GLfloat) * 4,
                        reinterpret_cast<void*>(sizeof(GLfloat) * 2));
 
  glUseProgram(self->program);
}

Referenced by fl_compositor_opengl_present_layers().

G_DEFINE_TYPE()

G_DEFINE_TYPE	(	FlCompositorOpenGLShader	,
		fl_compositor_opengl_shader	,
		G_TYPE_OBJECT
	)

Definition at line 54 of file fl_compositor_opengl_shader.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;
}

get_program_log()

static gchar* get_program_log ( GLuint  program )

static

Definition at line 72 of file fl_compositor_opengl_shader.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().

setup_shader()

static void setup_shader ( FlCompositorOpenGLShader *  self )

static

Definition at line 84 of file fl_compositor_opengl_shader.cc.

                                                         {
  if (!fl_opengl_manager_make_platform_current(self->opengl_manager)) {
    g_warning(
        "Failed to setup compositor shaders, unable to make OpenGL context "
        "current");
    return;
  }
 
  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);
  }
 
  self->program = glCreateProgram();
  glAttachShader(self->program, vertex_shader);
  glAttachShader(self->program, fragment_shader);
  glLinkProgram(self->program);
 
  GLint link_status;
  glGetProgramiv(self->program, GL_LINK_STATUS, &link_status);
  if (link_status == GL_FALSE) {
    g_autofree gchar* program_log = get_program_log(self->program);
    g_warning("Failed to link program: %s", program_log);
  }
 
  self->offset_location = glGetUniformLocation(self->program, "offset");
  self->scale_location = glGetUniformLocation(self->program, "scale");
 
  glDeleteShader(vertex_shader);
  glDeleteShader(fragment_shader);
 
  // The uniform square abcd in two triangles cba + cdb
  // a--b
  // |  |
  // c--d
  GLfloat const vertex_data[] = {-1, -1, 0, 0, 1, 1,  1, 1, -1, 1, 0, 1,
                                 -1, -1, 0, 0, 1, -1, 1, 0, 1,  1, 1, 1};
 
  glGenBuffers(1, &self->vertex_buffer);
  glBindBuffer(GL_ARRAY_BUFFER, self->vertex_buffer);
  glBufferData(GL_ARRAY_BUFFER, sizeof(vertex_data), vertex_data,
               GL_STATIC_DRAW);
}

References fl_opengl_manager_make_platform_current(), fragment_shader_src, get_program_log(), and vertex_shader_src.

Referenced by fl_compositor_opengl_shader_new().

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 23 of file fl_compositor_opengl_shader.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"
    "uniform vec2 offset;\n"
    "uniform vec2 scale;\n"
    "varying vec2 texcoord;\n"
    "\n"
    "void main() {\n"
    "  gl_Position = vec4(offset + position * scale, 0, 1);\n"
    "  texcoord = in_texcoord;\n"
    "}\n"

Definition at line 10 of file fl_compositor_opengl_shader.cc.

Referenced by setup_shader().