mutter/cogl/cogl-gles2-context-private.h

200 lines
5.9 KiB
C
Raw Normal View History

/*
* Cogl
*
* An object oriented GL/GLES Abstraction/Utility Layer
*
* Copyright (C) 2011 Collabora Ltd.
* Copyright (C) 2012 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see
* <http://www.gnu.org/licenses/>.
*
* Authors:
* Tomeu Vizoso <tomeu.vizoso@collabora.com>
* Robert Bragg <robert@linux.intel.com>
*
*/
#ifndef __COGL_GLES2_CONTEXT_PRIVATE_H
#define __COGL_GLES2_CONTEXT_PRIVATE_H
#include <glib.h>
#include "cogl-object-private.h"
#include "cogl-framebuffer-private.h"
#include "cogl-queue.h"
typedef struct _CoglGLES2Offscreen CoglGLES2Offscreen;
COGL_LIST_HEAD (CoglGLES2OffscreenList, CoglGLES2Offscreen);
struct _CoglGLES2Offscreen
{
COGL_LIST_ENTRY (CoglGLES2Offscreen) list_node;
CoglOffscreen *original_offscreen;
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;
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)
2012-08-07 06:48:56 -04:00
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 */
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;
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)
2012-08-07 06:48:56 -04:00
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;
/* State tracked for each texture unit */
typedef struct
{
/* The currently bound texture for the GL_TEXTURE_2D */
GLuint current_texture_2d;
} CoglGLES2TextureUnitData;
/* State tracked for each texture object */
typedef struct
{
/* GL's ID for this object */
GLuint object_id;
GLenum target;
/* The details for texture when it has a 2D target */
int width, height;
GLenum format;
} CoglGLES2TextureObjectData;
struct _CoglGLES2Context
{
CoglObject _parent;
CoglContext *context;
/* This is set to FALSE until the first time the GLES2 context is
* bound to something. We need to keep track of this so we can set
* the viewport and scissor the first time it is bound. */
CoglBool has_been_bound;
CoglFramebuffer *read_buffer;
CoglGLES2Offscreen *gles2_read_buffer;
CoglFramebuffer *write_buffer;
CoglGLES2Offscreen *gles2_write_buffer;
GLuint current_fbo_handle;
CoglGLES2OffscreenList foreign_offscreens;
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;
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)
2012-08-07 06:48:56 -04:00
/* 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;
/* A hash table of CoglGLES2TextureObjects indexed by the texture
* object ID so that we can track some state */
GHashTable *texture_object_map;
/* Array of CoglGLES2TextureUnits to keep track of state for each
* texture unit */
GArray *texture_units;
/* The currently active texture unit indexed from 0 (not from
* GL_TEXTURE0) */
int current_texture_unit;
void *winsys;
};
#endif /* __COGL_GLES2_CONTEXT_PRIVATE_H */