71498a6376
The CoglTexture constructors expose the "max-waste" argument for controlling the maximum amount of wasted areas for slicing or, if set to -1, disables slicing. Slicing is really relevant only for large images that are never repeated, so it's a useful feature only in controlled use cases. Specifying the amount of wasted area is, on the other hand, just a way to mess up this feature; 99% the times, you either pull this number out of thin air, hoping it's right, or you try to do the right thing and you choose the wrong number anyway. Instead, we can use the CoglTextureFlags to control whether the texture should not be sliced (useful for Clutter-GST and for the texture-from-pixmap actors) and provide a reasonable value for enabling the slicing ourself. At some point, we might even provide a way to change the default at compile time or at run time, for particular platforms. Since max_waste is gone, the :tile-waste property of ClutterTexture becomes read-only, and it proxies the cogl_texture_get_max_waste() function. Inside Clutter, the only cases where the max_waste argument was not set to -1 are in the Pango glyph cache (which is a POT texture anyway) and inside the test cases where we want to force slicing; for the latter we can create larger textures that will be bigger than the threshold we set. Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com> Signed-off-by: Robert Bragg <robert@linux.intel.com> Signed-off-by: Neil Roberts <neil@linux.intel.com>
209 lines
6.4 KiB
C
209 lines
6.4 KiB
C
/*
|
|
* Cogl
|
|
*
|
|
* An object oriented GL/GLES Abstraction/Utility Layer
|
|
*
|
|
* Copyright (C) 2007,2008,2009 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, write to the
|
|
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
* Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include "cogl.h"
|
|
#include "cogl-internal.h"
|
|
#include "cogl-util.h"
|
|
#include "cogl-context.h"
|
|
#include "cogl-texture-private.h"
|
|
#include "cogl-material-private.h"
|
|
|
|
#include "cogl-gles2-wrapper.h"
|
|
|
|
#include <string.h>
|
|
|
|
static CoglContext *_context = NULL;
|
|
static gboolean gl_is_indirect = FALSE;
|
|
|
|
gboolean
|
|
cogl_create_context ()
|
|
{
|
|
GLubyte default_texture_data[] = { 0xff, 0xff, 0xff, 0x0 };
|
|
gulong enable_flags = 0;
|
|
CoglDrawBufferState *draw_buffer;
|
|
|
|
if (_context != NULL)
|
|
return FALSE;
|
|
|
|
/* Allocate context memory */
|
|
_context = (CoglContext*) g_malloc (sizeof (CoglContext));
|
|
|
|
/* Init default values */
|
|
_context->feature_flags = 0;
|
|
_context->features_cached = FALSE;
|
|
|
|
_context->enable_flags = 0;
|
|
_context->color_alpha = 0;
|
|
|
|
_context->enable_backface_culling = FALSE;
|
|
|
|
_context->indirect = gl_is_indirect;
|
|
|
|
_context->default_material = cogl_material_new ();
|
|
_context->source_material = NULL;
|
|
|
|
_context->default_gl_texture_2d_tex = COGL_INVALID_HANDLE;
|
|
_context->default_gl_texture_rect_tex = COGL_INVALID_HANDLE;
|
|
_context->texture_download_material = COGL_INVALID_HANDLE;
|
|
|
|
_context->journal = g_array_new (FALSE, FALSE, sizeof (CoglJournalEntry));
|
|
_context->logged_vertices = g_array_new (FALSE, FALSE, sizeof (GLfloat));
|
|
_context->static_indices = g_array_new (FALSE, FALSE, sizeof (GLushort));
|
|
_context->polygon_vertices = g_array_new (FALSE, FALSE,
|
|
sizeof (CoglTextureGLVertex));
|
|
|
|
_context->current_material = NULL;
|
|
_context->current_material_flags = 0;
|
|
_context->current_layers = g_array_new (FALSE, FALSE,
|
|
sizeof (CoglLayerInfo));
|
|
_context->n_texcoord_arrays_enabled = 0;
|
|
|
|
draw_buffer = g_slice_new0 (CoglDrawBufferState);
|
|
draw_buffer->target = COGL_WINDOW_BUFFER;
|
|
draw_buffer->offscreen = COGL_INVALID_HANDLE;
|
|
_context->draw_buffer_stack =
|
|
g_slist_prepend (NULL, draw_buffer);
|
|
|
|
_context->path_nodes = g_array_new (FALSE, FALSE, sizeof (CoglPathNode));
|
|
_context->last_path = 0;
|
|
_context->stencil_material = cogl_material_new ();
|
|
|
|
/* Init the GLES2 wrapper */
|
|
#ifdef HAVE_COGL_GLES2
|
|
cogl_gles2_wrapper_init (&_context->gles2);
|
|
#endif
|
|
|
|
/* Initialise the clip stack */
|
|
_cogl_clip_stack_state_init ();
|
|
|
|
/* Initialise matrix stack */
|
|
_cogl_current_matrix_state_init ();
|
|
|
|
/* Create default textures used for fall backs */
|
|
_context->default_gl_texture_2d_tex =
|
|
cogl_texture_new_from_data (1, /* width */
|
|
1, /* height */
|
|
COGL_TEXTURE_NO_SLICING, /* flags */
|
|
COGL_PIXEL_FORMAT_RGBA_8888, /* data format */
|
|
/* internal format */
|
|
COGL_PIXEL_FORMAT_RGBA_8888,
|
|
0, /* auto calc row stride */
|
|
default_texture_data);
|
|
_context->default_gl_texture_rect_tex =
|
|
cogl_texture_new_from_data (1, /* width */
|
|
1, /* height */
|
|
COGL_TEXTURE_NO_SLICING, /* flags */
|
|
COGL_PIXEL_FORMAT_RGBA_8888, /* data format */
|
|
/* internal format */
|
|
COGL_PIXEL_FORMAT_RGBA_8888,
|
|
0, /* auto calc row stride */
|
|
default_texture_data);
|
|
|
|
cogl_set_source (_context->default_material);
|
|
cogl_material_flush_gl_state (_context->source_material, NULL);
|
|
enable_flags =
|
|
cogl_material_get_cogl_enable_flags (_context->source_material);
|
|
cogl_enable (enable_flags);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void
|
|
cogl_destroy_context ()
|
|
{
|
|
if (_context == NULL)
|
|
return;
|
|
|
|
_cogl_clip_stack_state_destroy ();
|
|
|
|
_cogl_current_matrix_state_destroy ();
|
|
|
|
if (_context->path_nodes)
|
|
g_array_free (_context->path_nodes, TRUE);
|
|
|
|
if (_context->default_gl_texture_2d_tex)
|
|
cogl_handle_unref (_context->default_gl_texture_2d_tex);
|
|
if (_context->default_gl_texture_rect_tex)
|
|
cogl_handle_unref (_context->default_gl_texture_rect_tex);
|
|
|
|
if (_context->default_material)
|
|
cogl_handle_unref (_context->default_material);
|
|
|
|
if (_context->journal)
|
|
g_array_free (_context->journal, TRUE);
|
|
if (_context->logged_vertices)
|
|
g_array_free (_context->logged_vertices, TRUE);
|
|
|
|
if (_context->static_indices)
|
|
g_array_free (_context->static_indices, TRUE);
|
|
if (_context->polygon_vertices)
|
|
g_array_free (_context->polygon_vertices, TRUE);
|
|
if (_context->current_layers)
|
|
g_array_free (_context->current_layers, TRUE);
|
|
|
|
g_free (_context);
|
|
}
|
|
|
|
CoglContext *
|
|
_cogl_context_get_default ()
|
|
{
|
|
/* Create if doesn't exist yet */
|
|
if (_context == NULL)
|
|
cogl_create_context ();
|
|
|
|
return _context;
|
|
}
|
|
|
|
/**
|
|
* _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;
|
|
}
|