cogl-gles2-context: Flip the rendering when framebuffer is offscreen

Cogl has a different origin for texture coordinates than OpenGL so
that the results of rendering to a texture should leave the top of the
image at the texture coordinate 0,0 rather than the bottom. When a
GLES2 context is used to render to a Cogl texture via a CoglOffscreen
we don't really want the application to have to be aware of the
mismatch and flip the texture coordinates. To get that to work, this
patch now tracks all of the programs that the application generates
using the context and sneaks in an extra vertex shader with an
alternative main function. This main function multiplies the final
calculated gl_Position by a vector uniform which we can use to flip
the image. When the application uploads the source code for a vertex
shader we now replace any occurrences of the token 'main' with '_c31'
and this renamed function gets called from the replacement main
function. The token has a weird name so that it will be unlikely to
conflict with a variable name in the application's source but it also
needs to have the same number of characters as the original token so
that it won't affect column numbers in the error reporting.

We are also wrapping glGetShaderSource so that we can try to revert
the token name. The same goes for the error logs just in case the
error report mentions function names.

Both places that cause drawing to occur (glDrawElements and
glDrawArrays) are now also wrapped so that we can update the uniform
value whenever the program is used with a different type of
framebuffer from last time.

We additionally need to manually track the state for the viewport, the
stencil box and the front face because all of these will be affected
by whether we are flipping the image or not. Any attempts to change
these states will be queued and instead flushed at the last minute
before drawing.

There are still some known issues with this patch:

• glCopyTexImage2D and glCopyTexSubImage2D will do the wrong thing
  when copying data from a CoglOffscreen. This could be quite fiddly
  to solve.

• Point sprites won't flip correctly. To make this work we would need
  to flip the gl_PointSprite builtin variable somehow. This is done in
  the fragment shader not the vertex shader so flipping the calculated
  gl_Position doesn't help here.

• The patch doesn't attempt to flip rendering to framebuffers for
  textures created within the GLES2 context. This probably makes sense
  because those textures are likely to be used within the GLES2
  context in which case we want to leave the texture coordinates as
  they are. However, if the texture is shared back out to Cogl with
  cogl_gles2_texture_2d_new_from_handle then the texture will be
  upside-down.

• The application can discover our secret uniform that we added via
  glGetActiveUniform. It might be worth trying to disguise this by
  wrapping that function although that could be quite fiddly.

Reviewed-by: Robert Bragg <robert@linux.intel.com>
(cherry picked from commit d589bf19e51f22c3241b2a18db10f22131ac126a)

1 files changed, 36 insertions, 0 deletions

diff --git a/cogl/cogl-gles2-context-private.h b/cogl/cogl-gles2-context-private.h
index a45214ac..1325ad45 100644
--- a/cogl/cogl-gles2-context-private.h
+++ b/cogl/cogl-gles2-context-private.h
@@ -68,6 +68,13 @@ typedef struct
   CoglBool deleted;
 } CoglGLES2ShaderData;
 
+typedef enum
+{
+  COGL_GLES2_FLIP_STATE_UNKNOWN,
+  COGL_GLES2_FLIP_STATE_NORMAL,
+  COGL_GLES2_FLIP_STATE_FLIPPED
+} CoglGLES2FlipState;
+
 typedef struct
 {
   /* GL's ID for the program */
@@ -89,6 +96,12 @@ typedef struct
    * application calls glDeleteProgram multiple times */
   CoglBool deleted;
 
+  GLuint flip_vector_location;
+
+  /* A cache of what value we've put in the flip vector uniform so
+   * that we don't flush unless it's changed */
+  CoglGLES2FlipState flip_vector_state;
+
   CoglGLES2Context *context;
 } CoglGLES2ProgramData;
 
@@ -129,6 +142,29 @@ struct _CoglGLES2Context
    * current */
   CoglGLES2ProgramData *current_program;
 
+  /* A shader to provide a wrapper 'main' function. A single shader is
+   * used for all programs */
+  GLuint wrapper_shader;
+
+  /* Whether the currently bound framebuffer needs flipping. This is
+   * used to check for changes so that we can dirty the following
+   * state flags */
+  CoglGLES2FlipState current_flip_state;
+
+  /* The following state is tracked separately from the GL context
+   * because we need to modify it depending on whether we are flipping
+   * the geometry. */
+  CoglBool viewport_dirty;
+  int viewport[4];
+  CoglBool scissor_dirty;
+  int scissor[4];
+  CoglBool front_face_dirty;
+  GLenum front_face;
+
+  /* We need to keep track of the pack alignment so we can flip the
+   * results of glReadPixels read from a CoglOffscreen */
+  int pack_alignment;
+
   void *winsys;
 };