2008-04-25 13:37:36 +00:00
|
|
|
/*
|
2009-04-27 14:48:12 +00:00
|
|
|
* Cogl
|
2008-04-25 13:37:36 +00:00
|
|
|
*
|
2009-04-27 14:48:12 +00:00
|
|
|
* An object oriented GL/GLES Abstraction/Utility Layer
|
2008-04-25 13:37:36 +00:00
|
|
|
*
|
2009-04-27 14:48:12 +00:00
|
|
|
* Copyright (C) 2007,2008,2009 Intel Corporation.
|
2008-04-25 13:37:36 +00:00
|
|
|
*
|
|
|
|
* 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
|
2010-03-01 12:56:10 +00:00
|
|
|
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*
|
|
|
|
*
|
2008-04-25 13:37:36 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
#include "config.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include "cogl.h"
|
|
|
|
#include "cogl-internal.h"
|
2010-08-16 20:11:42 +00:00
|
|
|
#include "cogl-profile.h"
|
2008-04-25 13:37:36 +00:00
|
|
|
#include "cogl-util.h"
|
|
|
|
#include "cogl-context.h"
|
2009-09-16 13:01:57 +00:00
|
|
|
#include "cogl-journal-private.h"
|
2009-01-26 11:07:35 +00:00
|
|
|
#include "cogl-texture-private.h"
|
2010-10-27 17:54:57 +00:00
|
|
|
#include "cogl-pipeline-private.h"
|
|
|
|
#include "cogl-pipeline-opengl-private.h"
|
2009-11-26 19:06:35 +00:00
|
|
|
#include "cogl-framebuffer-private.h"
|
2010-11-04 00:27:47 +00:00
|
|
|
#include "cogl2-path.h"
|
2008-04-25 13:37:36 +00:00
|
|
|
|
2009-01-26 11:07:35 +00:00
|
|
|
#include <string.h>
|
|
|
|
|
2010-06-18 14:25:51 +00:00
|
|
|
#ifdef HAVE_COGL_GL
|
2010-11-29 16:56:41 +00:00
|
|
|
#include "cogl-pipeline-fragend-arbfp-private.h"
|
2010-06-18 14:25:51 +00:00
|
|
|
#define glActiveTexture _context->drv.pf_glActiveTexture
|
|
|
|
#endif
|
|
|
|
|
2010-03-22 13:33:55 +00:00
|
|
|
/* This isn't defined in the GLES headers */
|
|
|
|
#ifndef GL_POINT_SPRITE
|
|
|
|
#define GL_POINT_SPRITE 0x8861
|
|
|
|
#endif
|
|
|
|
|
2009-07-28 00:34:33 +00:00
|
|
|
extern void
|
|
|
|
_cogl_create_context_driver (CoglContext *context);
|
2010-06-02 14:16:14 +00:00
|
|
|
extern void
|
|
|
|
_cogl_create_context_winsys (CoglContext *context);
|
|
|
|
extern void
|
|
|
|
_cogl_destroy_context_winsys (CoglContext *context);
|
2009-07-28 00:34:33 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
static CoglContext *_context = NULL;
|
2009-02-24 18:51:25 +00:00
|
|
|
static gboolean gl_is_indirect = FALSE;
|
2008-04-25 13:37:36 +00:00
|
|
|
|
2010-11-24 18:37:47 +00:00
|
|
|
static void
|
|
|
|
_cogl_init_feature_overrides (CoglContext *ctx)
|
|
|
|
{
|
|
|
|
if (G_UNLIKELY (cogl_debug_flags & COGL_DEBUG_DISABLE_VBOS))
|
|
|
|
ctx->feature_flags &= ~COGL_FEATURE_VBOS;
|
|
|
|
|
|
|
|
if (G_UNLIKELY (cogl_debug_flags & COGL_DEBUG_DISABLE_PBOS))
|
|
|
|
ctx->feature_flags &= ~COGL_FEATURE_PBOS;
|
|
|
|
|
|
|
|
if (G_UNLIKELY (cogl_debug_flags & COGL_DEBUG_DISABLE_ARBFP))
|
|
|
|
ctx->feature_flags &= ~COGL_FEATURE_SHADERS_ARBFP;
|
|
|
|
|
|
|
|
if (G_UNLIKELY (cogl_debug_flags & COGL_DEBUG_DISABLE_GLSL))
|
|
|
|
ctx->feature_flags &= ~COGL_FEATURE_SHADERS_GLSL;
|
|
|
|
|
|
|
|
if (G_UNLIKELY (cogl_debug_flags & COGL_DEBUG_DISABLE_NPOT_TEXTURES))
|
|
|
|
ctx->feature_flags &= ~(COGL_FEATURE_TEXTURE_NPOT |
|
|
|
|
COGL_FEATURE_TEXTURE_NPOT_BASIC |
|
|
|
|
COGL_FEATURE_TEXTURE_NPOT_MIPMAP |
|
|
|
|
COGL_FEATURE_TEXTURE_NPOT_REPEAT);
|
|
|
|
}
|
|
|
|
|
2009-05-26 14:41:53 +00:00
|
|
|
static gboolean
|
2009-07-28 00:34:33 +00:00
|
|
|
cogl_create_context (void)
|
2008-04-25 13:37:36 +00:00
|
|
|
{
|
2009-01-26 11:07:35 +00:00
|
|
|
GLubyte default_texture_data[] = { 0xff, 0xff, 0xff, 0x0 };
|
cogl: improves header and coding style consistency
We've had complaints that our Cogl code/headers are a bit "special" so
this is a first pass at tidying things up by giving them some
consistency. These changes are all consistent with how new code in Cogl
is being written, but the style isn't consistently applied across all
code yet.
There are two parts to this patch; but since each one required a large
amount of effort to maintain tidy indenting it made sense to combine the
changes to reduce the time spent re indenting the same lines.
The first change is to use a consistent style for declaring function
prototypes in headers. Cogl headers now consistently use this style for
prototypes:
return_type
cogl_function_name (CoglType arg0,
CoglType arg1);
Not everyone likes this style, but it seems that most of the currently
active Cogl developers agree on it.
The second change is to constrain the use of redundant glib data types
in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all
been replaced with int, unsigned int, float, long, unsigned long and char
respectively. When talking about pixel data; use of guchar has been
replaced with guint8, otherwise unsigned char can be used.
The glib types that we continue to use for portability are gboolean,
gint{8,16,32,64}, guint{8,16,32,64} and gsize.
The general intention is that Cogl should look palatable to the widest
range of C programmers including those outside the Gnome community so
- especially for the public API - we want to minimize the number of
foreign looking typedefs.
2010-02-10 01:57:32 +00:00
|
|
|
unsigned long enable_flags = 0;
|
2009-09-25 13:34:34 +00:00
|
|
|
CoglHandle window_buffer;
|
2010-07-05 22:24:34 +00:00
|
|
|
int i;
|
2009-01-26 11:07:35 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
if (_context != NULL)
|
|
|
|
return FALSE;
|
2009-01-26 11:07:35 +00:00
|
|
|
|
2010-08-16 20:11:42 +00:00
|
|
|
#ifdef CLUTTER_ENABLE_PROFILE
|
|
|
|
/* We need to be absolutely sure that uprof has been initialized
|
|
|
|
* before calling _cogl_uprof_init. uprof_init (NULL, NULL)
|
|
|
|
* will be a NOP if it has been initialized but it will also
|
|
|
|
* mean subsequent parsing of the UProf GOptionGroup will have no
|
|
|
|
* affect.
|
|
|
|
*
|
|
|
|
* Sadly GOptionGroup based library initialization is extremely
|
|
|
|
* fragile by design because GOptionGroups have no notion of
|
|
|
|
* dependencies and so the order things are initialized isn't
|
|
|
|
* currently under tight control.
|
|
|
|
*/
|
|
|
|
uprof_init (NULL, NULL);
|
|
|
|
_cogl_uprof_init ();
|
|
|
|
#endif
|
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
/* Allocate context memory */
|
|
|
|
_context = (CoglContext*) g_malloc (sizeof (CoglContext));
|
2009-01-26 11:07:35 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
/* Init default values */
|
|
|
|
_context->feature_flags = 0;
|
2009-11-14 14:59:59 +00:00
|
|
|
_context->feature_flags_private = 0;
|
2009-01-26 11:07:35 +00:00
|
|
|
|
2010-06-11 12:50:36 +00:00
|
|
|
_context->texture_types = NULL;
|
2010-07-03 22:56:44 +00:00
|
|
|
_context->buffer_types = NULL;
|
2010-06-11 12:50:36 +00:00
|
|
|
|
2009-10-22 11:35:33 +00:00
|
|
|
/* Initialise the driver specific state */
|
|
|
|
/* TODO: combine these two into one function */
|
|
|
|
_cogl_create_context_driver (_context);
|
|
|
|
_cogl_features_init ();
|
2010-11-24 18:37:47 +00:00
|
|
|
_cogl_init_feature_overrides (_context);
|
2009-10-22 11:35:33 +00:00
|
|
|
|
2010-06-02 14:16:14 +00:00
|
|
|
_cogl_create_context_winsys (_context);
|
|
|
|
|
2010-10-27 17:54:57 +00:00
|
|
|
_cogl_pipeline_init_default_pipeline ();
|
|
|
|
_cogl_pipeline_init_default_layers ();
|
2010-11-04 13:57:36 +00:00
|
|
|
_cogl_pipeline_init_state_hash_functions ();
|
|
|
|
_cogl_pipeline_init_layer_state_hash_functions ();
|
2009-11-11 12:50:48 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
_context->enable_flags = 0;
|
2009-01-26 11:07:35 +00:00
|
|
|
|
2009-03-10 17:53:51 +00:00
|
|
|
_context->enable_backface_culling = FALSE;
|
2009-10-22 18:01:52 +00:00
|
|
|
_context->flushed_front_winding = COGL_FRONT_WINDING_COUNTER_CLOCKWISE;
|
2009-03-10 17:53:51 +00:00
|
|
|
|
2009-02-24 18:51:25 +00:00
|
|
|
_context->indirect = gl_is_indirect;
|
|
|
|
|
2009-10-22 15:13:01 +00:00
|
|
|
cogl_matrix_init_identity (&_context->identity_matrix);
|
|
|
|
cogl_matrix_init_identity (&_context->y_flip_matrix);
|
|
|
|
cogl_matrix_scale (&_context->y_flip_matrix, 1, -1, 1);
|
|
|
|
|
2009-10-14 09:53:48 +00:00
|
|
|
_context->flushed_matrix_mode = COGL_MATRIX_MODELVIEW;
|
2010-04-26 09:01:43 +00:00
|
|
|
|
|
|
|
_context->texture_units =
|
|
|
|
g_array_new (FALSE, FALSE, sizeof (CoglTextureUnit));
|
|
|
|
|
2010-10-27 17:54:57 +00:00
|
|
|
/* See cogl-pipeline.c for more details about why we leave texture unit 1
|
2010-04-26 09:01:43 +00:00
|
|
|
* active by default... */
|
|
|
|
_context->active_texture_unit = 1;
|
|
|
|
GE (glActiveTexture (GL_TEXTURE1));
|
2009-09-29 01:58:27 +00:00
|
|
|
|
2010-07-06 19:18:26 +00:00
|
|
|
_context->legacy_fog_state.enabled = FALSE;
|
|
|
|
|
2010-11-01 20:27:32 +00:00
|
|
|
_context->opaque_color_pipeline = cogl_pipeline_new ();
|
|
|
|
_context->blended_color_pipeline = cogl_pipeline_new ();
|
2010-10-27 17:54:57 +00:00
|
|
|
_context->texture_pipeline = cogl_pipeline_new ();
|
2010-12-02 18:05:22 +00:00
|
|
|
_context->codegen_header_buffer = g_string_new ("");
|
|
|
|
_context->codegen_source_buffer = g_string_new ("");
|
2010-10-25 12:25:21 +00:00
|
|
|
_context->source_stack = NULL;
|
2010-04-26 09:01:43 +00:00
|
|
|
|
|
|
|
_context->legacy_state_set = 0;
|
2008-12-04 13:45:09 +00:00
|
|
|
|
2009-01-26 11:07:35 +00:00
|
|
|
_context->default_gl_texture_2d_tex = COGL_INVALID_HANDLE;
|
|
|
|
_context->default_gl_texture_rect_tex = COGL_INVALID_HANDLE;
|
|
|
|
|
|
|
|
_context->journal = g_array_new (FALSE, FALSE, sizeof (CoglJournalEntry));
|
|
|
|
_context->logged_vertices = g_array_new (FALSE, FALSE, sizeof (GLfloat));
|
2010-10-26 18:22:57 +00:00
|
|
|
_context->journal_flush_attributes_array =
|
|
|
|
g_array_new (TRUE, FALSE, sizeof (CoglVertexAttribute *));
|
2010-11-09 19:18:37 +00:00
|
|
|
_context->journal_clip_bounds = NULL;
|
2008-12-09 15:10:33 +00:00
|
|
|
|
2010-10-18 16:17:22 +00:00
|
|
|
_context->polygon_vertices = g_array_new (FALSE, FALSE, sizeof (float));
|
|
|
|
|
2010-10-27 17:54:57 +00:00
|
|
|
_context->current_pipeline = NULL;
|
|
|
|
_context->current_pipeline_changes_since_flush = 0;
|
|
|
|
_context->current_pipeline_skip_gl_color = FALSE;
|
2010-04-26 09:01:43 +00:00
|
|
|
|
2010-10-27 17:54:57 +00:00
|
|
|
_context->pipeline0_nodes =
|
2010-04-08 11:21:04 +00:00
|
|
|
g_array_sized_new (FALSE, FALSE, sizeof (CoglHandle), 20);
|
2010-10-27 17:54:57 +00:00
|
|
|
_context->pipeline1_nodes =
|
2010-04-08 11:21:04 +00:00
|
|
|
g_array_sized_new (FALSE, FALSE, sizeof (CoglHandle), 20);
|
|
|
|
|
2010-05-24 11:40:11 +00:00
|
|
|
_cogl_bitmask_init (&_context->texcoord_arrays_enabled);
|
|
|
|
_cogl_bitmask_init (&_context->temp_bitmask);
|
|
|
|
_cogl_bitmask_init (&_context->texcoord_arrays_to_disable);
|
2008-12-11 15:33:38 +00:00
|
|
|
|
2010-04-26 09:01:43 +00:00
|
|
|
_context->max_texture_units = -1;
|
|
|
|
_context->max_texture_image_units = -1;
|
|
|
|
_context->max_activateable_texture_units = -1;
|
|
|
|
|
|
|
|
_context->current_program = COGL_INVALID_HANDLE;
|
|
|
|
|
2010-10-27 17:54:57 +00:00
|
|
|
_context->current_use_program_type = COGL_PIPELINE_PROGRAM_TYPE_FIXED;
|
2010-04-26 09:01:43 +00:00
|
|
|
_context->current_gl_program = 0;
|
|
|
|
|
2010-04-08 11:21:04 +00:00
|
|
|
_context->gl_blend_enable_cache = FALSE;
|
|
|
|
|
2010-05-26 10:33:32 +00:00
|
|
|
_context->depth_test_enabled_cache = FALSE;
|
|
|
|
_context->depth_test_function_cache = COGL_DEPTH_TEST_FUNCTION_LESS;
|
|
|
|
_context->depth_writing_enabled_cache = TRUE;
|
|
|
|
_context->depth_range_near_cache = 0;
|
|
|
|
_context->depth_range_far_cache = 1;
|
|
|
|
|
2010-03-22 09:32:17 +00:00
|
|
|
_context->point_size_cache = 1.0f;
|
|
|
|
|
2010-05-26 10:33:32 +00:00
|
|
|
_context->legacy_depth_test_enabled = FALSE;
|
|
|
|
|
2010-12-07 16:44:36 +00:00
|
|
|
#ifdef HAVE_COGL_GL
|
2010-11-29 16:56:41 +00:00
|
|
|
_context->arbfp_cache = g_hash_table_new (_cogl_pipeline_fragend_arbfp_hash,
|
|
|
|
_cogl_pipeline_fragend_arbfp_equal);
|
2010-12-07 16:44:36 +00:00
|
|
|
#endif
|
2010-12-03 12:01:18 +00:00
|
|
|
|
2010-07-05 22:24:34 +00:00
|
|
|
for (i = 0; i < COGL_BUFFER_BIND_TARGET_COUNT; i++)
|
|
|
|
_context->current_buffer[i] = NULL;
|
|
|
|
|
2009-11-26 19:06:35 +00:00
|
|
|
_context->framebuffer_stack = _cogl_create_framebuffer_stack ();
|
2010-04-26 17:08:45 +00:00
|
|
|
|
2010-11-05 17:20:14 +00:00
|
|
|
_context->current_clip_stack_valid = FALSE;
|
|
|
|
|
2009-09-25 13:34:34 +00:00
|
|
|
window_buffer = _cogl_onscreen_new ();
|
2009-11-26 19:06:35 +00:00
|
|
|
cogl_set_framebuffer (window_buffer);
|
|
|
|
/* XXX: the deprecated _cogl_set_draw_buffer API expects to
|
|
|
|
* find the window buffer here... */
|
2009-09-25 13:34:34 +00:00
|
|
|
_context->window_buffer = window_buffer;
|
2009-11-26 19:06:35 +00:00
|
|
|
|
2009-09-25 13:34:34 +00:00
|
|
|
_context->dirty_bound_framebuffer = TRUE;
|
2009-10-21 22:24:49 +00:00
|
|
|
_context->dirty_gl_viewport = TRUE;
|
2008-11-10 18:53:14 +00:00
|
|
|
|
2010-11-04 00:27:47 +00:00
|
|
|
_context->current_path = cogl2_path_new ();
|
2010-10-27 17:54:57 +00:00
|
|
|
_context->stencil_pipeline = cogl_pipeline_new ();
|
2008-05-27 17:42:50 +00:00
|
|
|
|
2009-07-28 00:34:33 +00:00
|
|
|
_context->in_begin_gl_block = FALSE;
|
|
|
|
|
2010-10-12 11:48:58 +00:00
|
|
|
_context->quad_buffer_indices_byte = COGL_INVALID_HANDLE;
|
|
|
|
_context->quad_buffer_indices = COGL_INVALID_HANDLE;
|
|
|
|
_context->quad_buffer_indices_len = 0;
|
|
|
|
|
|
|
|
_context->rectangle_byte_indices = NULL;
|
|
|
|
_context->rectangle_short_indices = NULL;
|
|
|
|
_context->rectangle_short_indices_len = 0;
|
|
|
|
|
2010-10-27 17:54:57 +00:00
|
|
|
_context->texture_download_pipeline = COGL_INVALID_HANDLE;
|
2009-08-30 10:36:11 +00:00
|
|
|
|
2009-09-25 18:04:13 +00:00
|
|
|
/* The default for GL_ALPHA_TEST is to always pass which is equivalent to
|
|
|
|
* the test being disabled therefore we assume that for all drivers there
|
|
|
|
* will be no performance impact if we always leave the test enabled which
|
|
|
|
* makes things a bit simpler for us. */
|
|
|
|
GE (glEnable (GL_ALPHA_TEST));
|
|
|
|
|
2009-01-26 11:07:35 +00:00
|
|
|
/* Create default textures used for fall backs */
|
|
|
|
_context->default_gl_texture_2d_tex =
|
|
|
|
cogl_texture_new_from_data (1, /* width */
|
|
|
|
1, /* height */
|
2009-07-28 00:34:33 +00:00
|
|
|
COGL_TEXTURE_NO_SLICING,
|
|
|
|
COGL_PIXEL_FORMAT_RGBA_8888_PRE, /* data format */
|
2009-01-26 11:07:35 +00:00
|
|
|
/* internal format */
|
2009-07-28 00:34:33 +00:00
|
|
|
COGL_PIXEL_FORMAT_RGBA_8888_PRE,
|
2009-01-26 11:07:35 +00:00
|
|
|
0, /* auto calc row stride */
|
2009-01-28 14:09:51 +00:00
|
|
|
default_texture_data);
|
2009-01-26 11:07:35 +00:00
|
|
|
_context->default_gl_texture_rect_tex =
|
|
|
|
cogl_texture_new_from_data (1, /* width */
|
|
|
|
1, /* height */
|
2009-07-28 00:34:33 +00:00
|
|
|
COGL_TEXTURE_NO_SLICING,
|
|
|
|
COGL_PIXEL_FORMAT_RGBA_8888_PRE, /* data format */
|
2009-01-26 11:07:35 +00:00
|
|
|
/* internal format */
|
2009-07-28 00:34:33 +00:00
|
|
|
COGL_PIXEL_FORMAT_RGBA_8888_PRE,
|
2009-01-26 11:07:35 +00:00
|
|
|
0, /* auto calc row stride */
|
2009-01-28 14:09:51 +00:00
|
|
|
default_texture_data);
|
2009-01-26 11:07:35 +00:00
|
|
|
|
2010-11-01 20:27:32 +00:00
|
|
|
cogl_push_source (_context->opaque_color_pipeline);
|
2010-12-02 21:08:30 +00:00
|
|
|
_cogl_pipeline_flush_gl_state (_context->opaque_color_pipeline, FALSE, 0);
|
2010-03-19 09:16:08 +00:00
|
|
|
_cogl_enable (enable_flags);
|
2009-10-22 18:01:52 +00:00
|
|
|
_cogl_flush_face_winding ();
|
2009-01-26 11:07:35 +00:00
|
|
|
|
2010-08-02 15:29:10 +00:00
|
|
|
_context->atlas = NULL;
|
2009-12-04 13:06:32 +00:00
|
|
|
|
2010-03-22 13:33:55 +00:00
|
|
|
/* As far as I can tell, GL_POINT_SPRITE doesn't have any effect
|
|
|
|
unless GL_COORD_REPLACE is enabled for an individual
|
|
|
|
layer. Therefore it seems like it should be ok to just leave it
|
|
|
|
enabled all the time instead of having to have a set property on
|
2010-10-27 17:54:57 +00:00
|
|
|
each pipeline to track whether any layers have point sprite
|
2010-03-22 13:33:55 +00:00
|
|
|
coords enabled */
|
|
|
|
if (cogl_features_available (COGL_FEATURE_POINT_SPRITE))
|
|
|
|
GE (glEnable (GL_POINT_SPRITE));
|
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2010-05-27 11:18:29 +00:00
|
|
|
_cogl_destroy_context (void)
|
2008-04-25 13:37:36 +00:00
|
|
|
{
|
2009-09-25 13:34:34 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
if (_context == NULL)
|
|
|
|
return;
|
|
|
|
|
2010-06-02 14:16:14 +00:00
|
|
|
_cogl_destroy_context_winsys (_context);
|
|
|
|
|
2009-09-29 01:58:27 +00:00
|
|
|
_cogl_destroy_texture_units ();
|
|
|
|
|
2009-11-26 19:06:35 +00:00
|
|
|
_cogl_free_framebuffer_stack (_context->framebuffer_stack);
|
2009-09-25 13:34:34 +00:00
|
|
|
|
2010-04-08 16:43:27 +00:00
|
|
|
if (_context->current_path)
|
|
|
|
cogl_handle_unref (_context->current_path);
|
2008-12-04 13:45:09 +00:00
|
|
|
|
2009-01-26 11:07:35 +00:00
|
|
|
if (_context->default_gl_texture_2d_tex)
|
2009-04-01 16:16:44 +00:00
|
|
|
cogl_handle_unref (_context->default_gl_texture_2d_tex);
|
2009-01-26 11:07:35 +00:00
|
|
|
if (_context->default_gl_texture_rect_tex)
|
2009-04-01 16:16:44 +00:00
|
|
|
cogl_handle_unref (_context->default_gl_texture_rect_tex);
|
2009-01-26 11:07:35 +00:00
|
|
|
|
2010-11-01 20:27:32 +00:00
|
|
|
if (_context->opaque_color_pipeline)
|
|
|
|
cogl_handle_unref (_context->opaque_color_pipeline);
|
|
|
|
if (_context->blended_color_pipeline)
|
|
|
|
cogl_handle_unref (_context->blended_color_pipeline);
|
2010-10-27 17:54:57 +00:00
|
|
|
if (_context->texture_pipeline)
|
|
|
|
cogl_handle_unref (_context->texture_pipeline);
|
2009-01-26 11:07:35 +00:00
|
|
|
|
|
|
|
if (_context->journal)
|
|
|
|
g_array_free (_context->journal, TRUE);
|
|
|
|
if (_context->logged_vertices)
|
|
|
|
g_array_free (_context->logged_vertices, TRUE);
|
2010-10-26 18:22:57 +00:00
|
|
|
if (_context->journal_flush_attributes_array)
|
|
|
|
g_array_free (_context->journal_flush_attributes_array, TRUE);
|
2010-11-09 19:18:37 +00:00
|
|
|
if (_context->journal_clip_bounds)
|
|
|
|
g_array_free (_context->journal_clip_bounds, TRUE);
|
2009-01-26 11:07:35 +00:00
|
|
|
|
2010-10-18 16:17:22 +00:00
|
|
|
if (_context->polygon_vertices)
|
|
|
|
g_array_free (_context->polygon_vertices, TRUE);
|
|
|
|
|
2010-10-12 11:48:58 +00:00
|
|
|
if (_context->quad_buffer_indices_byte)
|
|
|
|
cogl_handle_unref (_context->quad_buffer_indices_byte);
|
|
|
|
if (_context->quad_buffer_indices)
|
|
|
|
cogl_handle_unref (_context->quad_buffer_indices);
|
|
|
|
|
|
|
|
if (_context->rectangle_byte_indices)
|
|
|
|
cogl_object_unref (_context->rectangle_byte_indices);
|
|
|
|
if (_context->rectangle_short_indices)
|
|
|
|
cogl_object_unref (_context->rectangle_short_indices);
|
|
|
|
|
2010-10-27 17:54:57 +00:00
|
|
|
if (_context->default_pipeline)
|
|
|
|
cogl_handle_unref (_context->default_pipeline);
|
2009-11-11 12:50:48 +00:00
|
|
|
|
2010-04-08 11:21:04 +00:00
|
|
|
if (_context->dummy_layer_dependant)
|
|
|
|
cogl_handle_unref (_context->dummy_layer_dependant);
|
|
|
|
if (_context->default_layer_n)
|
|
|
|
cogl_handle_unref (_context->default_layer_n);
|
|
|
|
if (_context->default_layer_0)
|
|
|
|
cogl_handle_unref (_context->default_layer_0);
|
|
|
|
|
2010-11-02 14:28:12 +00:00
|
|
|
if (_context->current_clip_stack_valid)
|
|
|
|
_cogl_clip_stack_unref (_context->current_clip_stack);
|
|
|
|
|
2010-08-02 15:29:10 +00:00
|
|
|
if (_context->atlas)
|
|
|
|
_cogl_atlas_free (_context->atlas);
|
2009-12-04 13:06:32 +00:00
|
|
|
|
2010-05-24 11:40:11 +00:00
|
|
|
_cogl_bitmask_destroy (&_context->texcoord_arrays_enabled);
|
|
|
|
_cogl_bitmask_destroy (&_context->temp_bitmask);
|
|
|
|
_cogl_bitmask_destroy (&_context->texcoord_arrays_to_disable);
|
|
|
|
|
2010-06-11 12:50:36 +00:00
|
|
|
g_slist_free (_context->texture_types);
|
2010-07-03 22:56:44 +00:00
|
|
|
g_slist_free (_context->buffer_types);
|
2010-06-11 12:50:36 +00:00
|
|
|
|
2010-12-07 16:44:36 +00:00
|
|
|
#ifdef HAVE_COGL_GL
|
2010-12-03 12:01:18 +00:00
|
|
|
g_hash_table_unref (_context->arbfp_cache);
|
2010-12-07 16:44:36 +00:00
|
|
|
#endif
|
2010-12-03 12:01:18 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
g_free (_context);
|
|
|
|
}
|
|
|
|
|
|
|
|
CoglContext *
|
2010-05-27 11:18:29 +00:00
|
|
|
_cogl_context_get_default (void)
|
2008-04-25 13:37:36 +00:00
|
|
|
{
|
2009-01-26 11:07:35 +00:00
|
|
|
/* Create if doesn't exist yet */
|
2008-04-25 13:37:36 +00:00
|
|
|
if (_context == NULL)
|
|
|
|
cogl_create_context ();
|
2009-01-26 11:07:35 +00:00
|
|
|
|
2008-04-25 13:37:36 +00:00
|
|
|
return _context;
|
|
|
|
}
|
2009-02-24 18:51:25 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* _cogl_set_indirect_context:
|
|
|
|
* @indirect: TRUE if GL context is indirect
|
|
|
|
*
|
|
|
|
* Advises COGL that the GL context is indirect (commands are sent
|
|
|
|
* over a socket). COGL uses this information to try to avoid
|
|
|
|
* round-trips in its use of GL, for example.
|
|
|
|
*
|
|
|
|
* This function cannot be called "on the fly," only before COGL
|
|
|
|
* initializes.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
_cogl_set_indirect_context (gboolean indirect)
|
|
|
|
{
|
|
|
|
/* we get called multiple times if someone creates
|
|
|
|
* more than the default stage
|
|
|
|
*/
|
|
|
|
if (_context != NULL)
|
|
|
|
{
|
|
|
|
if (indirect != _context->indirect)
|
|
|
|
g_warning ("Right now all stages will be treated as "
|
|
|
|
"either direct or indirect, ignoring attempt "
|
|
|
|
"to change to indirect=%d", indirect);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
gl_is_indirect = indirect;
|
|
|
|
}
|