cogl-gles2-context: Keep some extra data for shaders and programs

All of the functions that create and destroy shaders are now wrapped
in the CoglGLES2Context so that we can track some extra data for them.
There are hash tables mapping object IDs to the corresponding data.
The data is currently not used for anything but will be in later
patches.

The glUseProgram, glAttachShader and glDetachShader functions
additionally need to be wrapped because GL does not delete shader
objects that are in use. Therefore we need to have a reference count
on the data so we can recognise when the last use has been removed.

The IDs are assumed to be specific to an individual CoglGLES2Context.
This is technically not the case because all of the CoglGLES2Contexts
are in the same share list. However we don't really want this to be
the case so currently we will assume sharing the object IDs between
contexts is undefined behaviour. Eventually we may want to actually
enforce this.

Reviewed-by: Robert Bragg <robert@linux.intel.com>

(cherry picked from commit 05dc1e34785ae5f5484cd398ecc5464bd8bd3dcd)

1 files changed, 61 insertions, 0 deletions

diff --git a/cogl/cogl-gles2-context-private.h b/cogl/cogl-gles2-context-private.h
index 7902c941..a45214ac 100644
--- a/cogl/cogl-gles2-context-private.h
+++ b/cogl/cogl-gles2-context-private.h
@@ -46,6 +46,52 @@ struct _CoglGLES2Offscreen
   CoglGLFramebuffer gl_framebuffer;
 };
 
+typedef struct
+{
+  /* GL's ID for the shader */
+  GLuint object_id;
+  /* Shader type */
+  GLenum type;
+
+  /* Number of references to this shader. The shader will have one
+   * reference when it is created. This reference will be removed when
+   * glDeleteShader is called. An additional reference will be taken
+   * whenever the shader is attached to a program. This is necessary
+   * to correctly detect when a shader is destroyed because
+   * glDeleteShader doesn't actually delete the object if it is
+   * attached to a program */
+  int ref_count;
+
+  /* Set once this object has had glDeleteShader called on it. We need
+   * to keep track of this so we don't deref the data twice if the
+   * application calls glDeleteShader multiple times */
+  CoglBool deleted;
+} CoglGLES2ShaderData;
+
+typedef struct
+{
+  /* GL's ID for the program */
+  GLuint object_id;
+
+  /* List of shaders attached to this program */
+  GList *attached_shaders;
+
+  /* Reference count. There can be up to two references. One of these
+   * will exist between glCreateProgram and glDeleteShader, the other
+   * will exist while the program is made current. This is necessary
+   * to correctly detect when the program is deleted because
+   * glDeleteShader will delay the deletion if the program is
+   * current */
+  int ref_count;
+
+  /* Set once this object has had glDeleteProgram called on it. We need
+   * to keep track of this so we don't deref the data twice if the
+   * application calls glDeleteProgram multiple times */
+  CoglBool deleted;
+
+  CoglGLES2Context *context;
+} CoglGLES2ProgramData;
+
 struct _CoglGLES2Context
 {
   CoglObject _parent;
@@ -68,6 +114,21 @@ struct _CoglGLES2Context
 
   CoglGLES2Vtable *vtable;
 
+  /* Hash table mapping GL's IDs for shaders and objects to ShaderData
+   * and ProgramData so that we can maintain extra data for these
+   * objects. Although technically the IDs will end up global across
+   * all GLES2 contexts because they will all be in the same share
+   * list, we don't really want to expose this outside of the Cogl API
+   * so we will assume it is undefined behaviour if an application
+   * relies on this. */
+  GHashTable *shader_map;
+  GHashTable *program_map;
+
+  /* Currently in use program. We need to keep track of this so that
+   * we can keep a reference to the data for the program while it is
+   * current */
+  CoglGLES2ProgramData *current_program;
+
   void *winsys;
 };