isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-23 08:30:42 -05:00
Code Issues Packages Projects Releases Wiki Activity
c4130ba3ea
mutter/cogl/cogl-matrix-stack.c

554 lines
15 KiB
C
Raw Normal View History

Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05:00
/*
[cogl] Updates all file headers and removes lots of trailing white space Adds missing notices, and ensures all the notices are consistent. The Cogl blurb also now reads: * Cogl * * An object oriented GL/GLES Abstraction/Utility Layer
2009-04-27 10:48:12 -04:00
* Cogl
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05:00
*
[cogl] Updates all file headers and removes lots of trailing white space Adds missing notices, and ensures all the notices are consistent. The Cogl blurb also now reads: * Cogl * * An object oriented GL/GLES Abstraction/Utility Layer
2009-04-27 10:48:12 -04:00
* An object oriented GL/GLES Abstraction/Utility Layer
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05:00
*
matrix-stack: Make header style consistent Cogl doesn't follow the Clutter/GTK+ columnized function prototype style so this updates cogl-matrix-stack.h to match the other Cogl headers.
2010-12-10 06:34:02 -05:00
* Copyright (C) 2009,2010 Intel Corporation.
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05: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
Remove mentions of the FSF address Since using addresses that might change is something that finally the FSF acknowledge as a plausible scenario (after changing address twice), the license blurb in the source files should use the URI for getting the license in case the library did not come with it. Not that URIs cannot possibly change, but at least it's easier to set up a redirection at the same place. As a side note: this commit closes the oldes bug in Clutter's bug report tool. http://bugzilla.openedhand.com/show_bug.cgi?id=521
2010-03-01 07:56:10 -05:00
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
*
[cogl] Updates all file headers and removes lots of trailing white space Adds missing notices, and ensures all the notices are consistent. The Cogl blurb also now reads: * Cogl * * An object oriented GL/GLES Abstraction/Utility Layer
2009-04-27 10:48:12 -04:00
*
* Authors:
* Havoc Pennington <hp@pobox.com> for litl
[cogl] Make sure we draw upside down to offscreen draw buffers First a few notes about Cogl coordinate systems: - Cogl defines the window origin, viewport origin and texture coordinates origin to be top left unlike OpenGL which defines them as bottom left. - Cogl defines the modelview and projection identity matrices in exactly the same way as OpenGL. - I.e. we believe that for 2D centric constructs: windows/framebuffers, viewports and textures developers are more used to dealing with a top left origin, but when modeling objects in 3D; an origin at the center with y going up is quite natural. The way Cogl handles textures is by uploading data upside down in OpenGL terms so that bottom left becomes top left. (Note: This also has the benefit that we don't need to flip the data we get from image decoding libraries since they typically also consider top left to be the image origin.) The viewport and window coords are mostly handled with various y = height - y tweaks before we pass y coordinates to OpenGL. Generally speaking though the handling of coordinate spaces in Cogl is a bit fragile. I guess partly because none of it was design to be, it just evolved from how Clutter defines its coordinates without much consideration or testing. I hope to improve this over a number of commits; starting here. This commit deals with the fact that offscreen draw buffers may be bound to textures but we don't "upload" the texture data upside down, and so if you texture from an offscreen draw buffer you need to manually flip the texture coordinates to get it the right way around. We now force offscreen rendering to be flipped upside down by tweaking the projection matrix right before we submit it to OpenGL to scale y by -1. The tweak is entirely hidden from the user such that if you call cogl_get_projection you will not see this scale.
2009-10-22 11:13:01 -04:00
* Robert Bragg <robert@linux.intel.com>
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05:00
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
cogl: rename cogl-context.h cogl-context-private.h Since we plan to add public cogl_context_* API we need to rename the current cogl-context.h which contains private member details.
2010-11-04 18:25:52 -04:00
#include "cogl-context-private.h"
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05:00
#include "cogl-internal.h"
#include "cogl-matrix-stack.h"
cogl: deprecate cogl_draw_buffer API and replace with a cogl_framebuffer API cogl_push_draw_buffer, cogl_set_draw_buffer and cogl_pop_draw_buffer are now deprecated and new code should use the new cogl_framebuffer_* API instead. Code that previously did: cogl_push_draw_buffer (); cogl_set_draw_buffer (COGL_OFFSCREEN_BUFFER, buffer); /* draw */ cogl_pop_draw_buffer (); should now be re-written as: cogl_push_framebuffer (buffer); /* draw */ cogl_pop_framebuffer (); As can be seen from the example above the rename has been used as an opportunity to remove the redundant target argument from cogl_set_draw_buffer; it now only takes one call to redirect to an offscreen buffer, and finally the term framebuffer may be a bit more familiar to anyone coming from an OpenGL background.
2009-11-26 14:06:35 -05:00
#include "cogl-framebuffer-private.h"
cogl-matrix-stack: Convert to be a CoglObject We will want to use ref-counting on the CoglMatrixStack so it might as well be a CoglObject.
2010-12-10 11:06:16 -05:00
#include "cogl-object-private.h"
Remove all internal includes of cogl.h The cogl.h header is meant to be the public header for including the 1.x api used by Clutter so we should stop using that as a convenient way to include all likely prototypes and typedefs. Actually we already do a good job of listing the specific headers we depend on in each of the .c files we have so mostly this patch just strip out the redundant includes for cogl.h with a few fixups where that broke the build. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-17 20:19:17 -05:00
#include "cogl-offscreen.h"
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05:00
typedef struct {
CoglMatrix matrix;
matrix-stack: more optimization for load_identity case This goes a bit further than the previous patch, and as a special case we now simply represent identity matrices using a boolean, and only lazily initialize them when they need to be modified.
2009-10-06 07:36:32 -04:00
gboolean is_identity;
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05:00
/* count of pushes with no changes; when a change is
* requested, we create a new state and decrement this
*/
int push_count;
} CoglMatrixState;
/**
* CoglMatrixStack:
*
* Stores a cogl-side matrix stack, which we use as a cache
* so we can get the matrix efficiently when using indirect
* rendering.
*/
struct _CoglMatrixStack
{
cogl-matrix-stack: Convert to be a CoglObject We will want to use ref-counting on the CoglMatrixStack so it might as well be a CoglObject.
2010-12-10 11:06:16 -05:00
CoglObject _parent;
matrix-stack: use GArray instead of GSList for stack In some micro-benchmarks testing journal throughput the list manipulation jumps pretty high in the profile. This replaces the GSList usage with a GArray instead which is effectively a grow only allocation that means we avoid ongoing allocations while manipulating the stack mid-scene.
2010-11-01 18:07:11 -04:00
GArray *stack;
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05:00
matrix-stack: Adds a stack age counter Sometimes it would be useful if we could efficiently track when a matrix stack has been modified. For example on GLES2 we have to upload the modelview as a uniform to our glsl programs but because the modelview state is part of the framebuffer state it becomes a bit more tricky to know when to re-sync the value of the uniform with the framebuffer state. This adds an "age" counter to CoglMatrixStack which is incremented for any operation that effectively modifies the top of the stack so now we can save the age of the stack inside the pipeline whenever we update modelview uniform and later compare that with the stack to determine if it has changed.
2010-12-10 06:13:09 -05:00
unsigned int age;
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05:00
};
cogl-matrix-stack: Convert to be a CoglObject We will want to use ref-counting on the CoglMatrixStack so it might as well be a CoglObject.
2010-12-10 11:06:16 -05:00
static void _cogl_matrix_stack_free (CoglMatrixStack *stack);
COGL_OBJECT_INTERNAL_DEFINE (MatrixStack, matrix_stack);
[matrix-stack] avoid redundant clearing of matrix when using load_identity The journal always uses an identity matrix since it uses software transformation. Currently it manually uses glLoadMatrix since previous experimentation showed that the cogl-matrix-stack gave bad performance, but it would be nice to fix performance so we only have to care about one path for loading matrices. For the common case where we do: cogl_matrix_stack_push() cogl_matrix_stack_load_identity() we were effectively initializing the matrix 3 times. Once due to use of g_slice_new0, then we had a cogl_matrix_init_identity in _cogl_matrix_state_new for good measure, and then finally in cogl_matrix_stack_load_identity we did another cogl_matrix_init_identity. We don't use g_slice_new0 anymore, _cogl_matrix_state_new is documented as not initializing the matrix (instead _cogl_matrix_stack_top_mutable now takes a boolean to choose if new stack entries should be initialised) and so we now only initialize once in cogl_matrix_stack_load_identity.
2009-10-06 05:52:07 -04:00
/* XXX: this doesn't initialize the matrix! */
matrix-stack: use GArray instead of GSList for stack In some micro-benchmarks testing journal throughput the list manipulation jumps pretty high in the profile. This replaces the GSList usage with a GArray instead which is effectively a grow only allocation that means we avoid ongoing allocations while manipulating the stack mid-scene.
2010-11-01 18:07:11 -04:00
static void
_cogl_matrix_state_init (CoglMatrixState *state)
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05:00
{
[matrix-stack] avoid redundant clearing of matrix when using load_identity The journal always uses an identity matrix since it uses software transformation. Currently it manually uses glLoadMatrix since previous experimentation showed that the cogl-matrix-stack gave bad performance, but it would be nice to fix performance so we only have to care about one path for loading matrices. For the common case where we do: cogl_matrix_stack_push() cogl_matrix_stack_load_identity() we were effectively initializing the matrix 3 times. Once due to use of g_slice_new0, then we had a cogl_matrix_init_identity in _cogl_matrix_state_new for good measure, and then finally in cogl_matrix_stack_load_identity we did another cogl_matrix_init_identity. We don't use g_slice_new0 anymore, _cogl_matrix_state_new is documented as not initializing the matrix (instead _cogl_matrix_stack_top_mutable now takes a boolean to choose if new stack entries should be initialised) and so we now only initialize once in cogl_matrix_stack_load_identity.
2009-10-06 05:52:07 -04:00
state->push_count = 0;
matrix-stack: more optimization for load_identity case This goes a bit further than the previous patch, and as a special case we now simply represent identity matrices using a boolean, and only lazily initialize them when they need to be modified.
2009-10-06 07:36:32 -04:00
state->is_identity = FALSE;
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05:00
}
matrix-stack: use GArray instead of GSList for stack In some micro-benchmarks testing journal throughput the list manipulation jumps pretty high in the profile. This replaces the GSList usage with a GArray instead which is effectively a grow only allocation that means we avoid ongoing allocations while manipulating the stack mid-scene.
2010-11-01 18:07:11 -04:00
static CoglMatrixState *
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05:00
_cogl_matrix_stack_top (CoglMatrixStack *stack)
{
matrix-stack: use GArray instead of GSList for stack In some micro-benchmarks testing journal throughput the list manipulation jumps pretty high in the profile. This replaces the GSList usage with a GArray instead which is effectively a grow only allocation that means we avoid ongoing allocations while manipulating the stack mid-scene.
2010-11-01 18:07:11 -04:00
return &g_array_index (stack->stack, CoglMatrixState, stack->stack->len - 1);
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05:00
}
matrix-stack: more optimization for load_identity case This goes a bit further than the previous patch, and as a special case we now simply represent identity matrices using a boolean, and only lazily initialize them when they need to be modified.
2009-10-06 07:36:32 -04:00
/* XXX:
* Operations like scale, translate, rotate etc need to have an
* initialized state->matrix to work with, so they will pass
* initialize = TRUE.
*
* _cogl_matrix_stack_load_identity and _cogl_matrix_stack_set on the
* other hand don't so they will pass initialize = FALSE
*
* NB: Identity matrices are represented by setting
* state->is_identity=TRUE in which case state->matrix will be
* uninitialized.
*/
[matrix-stack] avoid redundant clearing of matrix when using load_identity The journal always uses an identity matrix since it uses software transformation. Currently it manually uses glLoadMatrix since previous experimentation showed that the cogl-matrix-stack gave bad performance, but it would be nice to fix performance so we only have to care about one path for loading matrices. For the common case where we do: cogl_matrix_stack_push() cogl_matrix_stack_load_identity() we were effectively initializing the matrix 3 times. Once due to use of g_slice_new0, then we had a cogl_matrix_init_identity in _cogl_matrix_state_new for good measure, and then finally in cogl_matrix_stack_load_identity we did another cogl_matrix_init_identity. We don't use g_slice_new0 anymore, _cogl_matrix_state_new is documented as not initializing the matrix (instead _cogl_matrix_stack_top_mutable now takes a boolean to choose if new stack entries should be initialised) and so we now only initialize once in cogl_matrix_stack_load_identity.
2009-10-06 05:52:07 -04:00
static CoglMatrixState *
_cogl_matrix_stack_top_mutable (CoglMatrixStack *stack,
gboolean initialize)
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05:00
{
CoglMatrixState *state;
CoglMatrixState *new_top;
state = _cogl_matrix_stack_top (stack);
if (state->push_count == 0)
matrix-stack: more optimization for load_identity case This goes a bit further than the previous patch, and as a special case we now simply represent identity matrices using a boolean, and only lazily initialize them when they need to be modified.
2009-10-06 07:36:32 -04:00
{
if (state->is_identity && initialize)
cogl_matrix_init_identity (&state->matrix);
return state;
}
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05:00
state->push_count -= 1;
matrix-stack: use GArray instead of GSList for stack In some micro-benchmarks testing journal throughput the list manipulation jumps pretty high in the profile. This replaces the GSList usage with a GArray instead which is effectively a grow only allocation that means we avoid ongoing allocations while manipulating the stack mid-scene.
2010-11-01 18:07:11 -04:00
g_array_set_size (stack->stack, stack->stack->len + 1);
new_top = &g_array_index (stack->stack, CoglMatrixState,
stack->stack->len - 1);
_cogl_matrix_state_init (new_top);
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05:00
[matrix-stack] avoid redundant clearing of matrix when using load_identity The journal always uses an identity matrix since it uses software transformation. Currently it manually uses glLoadMatrix since previous experimentation showed that the cogl-matrix-stack gave bad performance, but it would be nice to fix performance so we only have to care about one path for loading matrices. For the common case where we do: cogl_matrix_stack_push() cogl_matrix_stack_load_identity() we were effectively initializing the matrix 3 times. Once due to use of g_slice_new0, then we had a cogl_matrix_init_identity in _cogl_matrix_state_new for good measure, and then finally in cogl_matrix_stack_load_identity we did another cogl_matrix_init_identity. We don't use g_slice_new0 anymore, _cogl_matrix_state_new is documented as not initializing the matrix (instead _cogl_matrix_stack_top_mutable now takes a boolean to choose if new stack entries should be initialised) and so we now only initialize once in cogl_matrix_stack_load_identity.
2009-10-06 05:52:07 -04:00
if (initialize)
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05:00
{
matrix-stack: more optimization for load_identity case This goes a bit further than the previous patch, and as a special case we now simply represent identity matrices using a boolean, and only lazily initialize them when they need to be modified.
2009-10-06 07:36:32 -04:00
if (state->is_identity)
cogl_matrix_init_identity (&new_top->matrix);
else
new_top->matrix = state->matrix;
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05:00
}
return new_top;
}
CoglMatrixStack*
_cogl_matrix_stack_new (void)
{
CoglMatrixStack *stack;
CoglMatrixState *state;
stack = g_slice_new0 (CoglMatrixStack);
[matrix-stack] avoid redundant clearing of matrix when using load_identity The journal always uses an identity matrix since it uses software transformation. Currently it manually uses glLoadMatrix since previous experimentation showed that the cogl-matrix-stack gave bad performance, but it would be nice to fix performance so we only have to care about one path for loading matrices. For the common case where we do: cogl_matrix_stack_push() cogl_matrix_stack_load_identity() we were effectively initializing the matrix 3 times. Once due to use of g_slice_new0, then we had a cogl_matrix_init_identity in _cogl_matrix_state_new for good measure, and then finally in cogl_matrix_stack_load_identity we did another cogl_matrix_init_identity. We don't use g_slice_new0 anymore, _cogl_matrix_state_new is documented as not initializing the matrix (instead _cogl_matrix_stack_top_mutable now takes a boolean to choose if new stack entries should be initialised) and so we now only initialize once in cogl_matrix_stack_load_identity.
2009-10-06 05:52:07 -04:00
matrix-stack: use GArray instead of GSList for stack In some micro-benchmarks testing journal throughput the list manipulation jumps pretty high in the profile. This replaces the GSList usage with a GArray instead which is effectively a grow only allocation that means we avoid ongoing allocations while manipulating the stack mid-scene.
2010-11-01 18:07:11 -04:00
stack->stack = g_array_sized_new (FALSE, FALSE,
sizeof (CoglMatrixState), 10);
g_array_set_size (stack->stack, 1);
state = &g_array_index (stack->stack, CoglMatrixState, 0);
_cogl_matrix_state_init (state);
matrix-stack: more optimization for load_identity case This goes a bit further than the previous patch, and as a special case we now simply represent identity matrices using a boolean, and only lazily initialize them when they need to be modified.
2009-10-06 07:36:32 -04:00
state->is_identity = TRUE;
[matrix-stack] avoid redundant clearing of matrix when using load_identity The journal always uses an identity matrix since it uses software transformation. Currently it manually uses glLoadMatrix since previous experimentation showed that the cogl-matrix-stack gave bad performance, but it would be nice to fix performance so we only have to care about one path for loading matrices. For the common case where we do: cogl_matrix_stack_push() cogl_matrix_stack_load_identity() we were effectively initializing the matrix 3 times. Once due to use of g_slice_new0, then we had a cogl_matrix_init_identity in _cogl_matrix_state_new for good measure, and then finally in cogl_matrix_stack_load_identity we did another cogl_matrix_init_identity. We don't use g_slice_new0 anymore, _cogl_matrix_state_new is documented as not initializing the matrix (instead _cogl_matrix_stack_top_mutable now takes a boolean to choose if new stack entries should be initialised) and so we now only initialize once in cogl_matrix_stack_load_identity.
2009-10-06 05:52:07 -04:00
matrix-stack: Adds a stack age counter Sometimes it would be useful if we could efficiently track when a matrix stack has been modified. For example on GLES2 we have to upload the modelview as a uniform to our glsl programs but because the modelview state is part of the framebuffer state it becomes a bit more tricky to know when to re-sync the value of the uniform with the framebuffer state. This adds an "age" counter to CoglMatrixStack which is incremented for any operation that effectively modifies the top of the stack so now we can save the age of the stack inside the pipeline whenever we update modelview uniform and later compare that with the stack to determine if it has changed.
2010-12-10 06:13:09 -05:00
stack->age = 0;
cogl-matrix-stack: Convert to be a CoglObject We will want to use ref-counting on the CoglMatrixStack so it might as well be a CoglObject.
2010-12-10 11:06:16 -05:00
return _cogl_matrix_stack_object_new (stack);
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05:00
}
cogl-matrix-stack: Convert to be a CoglObject We will want to use ref-counting on the CoglMatrixStack so it might as well be a CoglObject.
2010-12-10 11:06:16 -05:00
static void
_cogl_matrix_stack_free (CoglMatrixStack *stack)
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05:00
{
matrix-stack: use GArray instead of GSList for stack In some micro-benchmarks testing journal throughput the list manipulation jumps pretty high in the profile. This replaces the GSList usage with a GArray instead which is effectively a grow only allocation that means we avoid ongoing allocations while manipulating the stack mid-scene.
2010-11-01 18:07:11 -04:00
g_array_free (stack->stack, TRUE);
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05:00
g_slice_free (CoglMatrixStack, stack);
}
void
_cogl_matrix_stack_push (CoglMatrixStack *stack)
{
CoglMatrixState *state;
state = _cogl_matrix_stack_top (stack);
/* we lazily create a new stack top if someone changes the matrix
* while push_count > 0
*/
state->push_count += 1;
}
void
_cogl_matrix_stack_pop (CoglMatrixStack *stack)
{
CoglMatrixState *state;
state = _cogl_matrix_stack_top (stack);
if (state->push_count > 0)
{
state->push_count -= 1;
}
else
{
matrix-stack: use GArray instead of GSList for stack In some micro-benchmarks testing journal throughput the list manipulation jumps pretty high in the profile. This replaces the GSList usage with a GArray instead which is effectively a grow only allocation that means we avoid ongoing allocations while manipulating the stack mid-scene.
2010-11-01 18:07:11 -04:00
if (stack->stack->len == 1)
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05:00
{
g_warning ("Too many matrix pops");
return;
}
matrix-stack: Adds a stack age counter Sometimes it would be useful if we could efficiently track when a matrix stack has been modified. For example on GLES2 we have to upload the modelview as a uniform to our glsl programs but because the modelview state is part of the framebuffer state it becomes a bit more tricky to know when to re-sync the value of the uniform with the framebuffer state. This adds an "age" counter to CoglMatrixStack which is incremented for any operation that effectively modifies the top of the stack so now we can save the age of the stack inside the pipeline whenever we update modelview uniform and later compare that with the stack to determine if it has changed.
2010-12-10 06:13:09 -05:00
stack->age++;
matrix-stack: use GArray instead of GSList for stack In some micro-benchmarks testing journal throughput the list manipulation jumps pretty high in the profile. This replaces the GSList usage with a GArray instead which is effectively a grow only allocation that means we avoid ongoing allocations while manipulating the stack mid-scene.
2010-11-01 18:07:11 -04:00
g_array_set_size (stack->stack, stack->stack->len - 1);
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05:00
}
}
void
_cogl_matrix_stack_load_identity (CoglMatrixStack *stack)
{
CoglMatrixState *state;
[matrix-stack] avoid redundant clearing of matrix when using load_identity The journal always uses an identity matrix since it uses software transformation. Currently it manually uses glLoadMatrix since previous experimentation showed that the cogl-matrix-stack gave bad performance, but it would be nice to fix performance so we only have to care about one path for loading matrices. For the common case where we do: cogl_matrix_stack_push() cogl_matrix_stack_load_identity() we were effectively initializing the matrix 3 times. Once due to use of g_slice_new0, then we had a cogl_matrix_init_identity in _cogl_matrix_state_new for good measure, and then finally in cogl_matrix_stack_load_identity we did another cogl_matrix_init_identity. We don't use g_slice_new0 anymore, _cogl_matrix_state_new is documented as not initializing the matrix (instead _cogl_matrix_stack_top_mutable now takes a boolean to choose if new stack entries should be initialised) and so we now only initialize once in cogl_matrix_stack_load_identity.
2009-10-06 05:52:07 -04:00
state = _cogl_matrix_stack_top_mutable (stack, FALSE);
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05:00
matrix-stack: more optimization for load_identity case This goes a bit further than the previous patch, and as a special case we now simply represent identity matrices using a boolean, and only lazily initialize them when they need to be modified.
2009-10-06 07:36:32 -04:00
/* NB: Identity matrices are represented by setting
* state->is_identity = TRUE and leaving state->matrix
* uninitialized.
*
* This is done to optimize the heavy usage of
* _cogl_matrix_stack_load_identity by the Cogl Journal.
*/
if (!state->is_identity)
{
state->is_identity = TRUE;
matrix-stack: Adds a stack age counter Sometimes it would be useful if we could efficiently track when a matrix stack has been modified. For example on GLES2 we have to upload the modelview as a uniform to our glsl programs but because the modelview state is part of the framebuffer state it becomes a bit more tricky to know when to re-sync the value of the uniform with the framebuffer state. This adds an "age" counter to CoglMatrixStack which is incremented for any operation that effectively modifies the top of the stack so now we can save the age of the stack inside the pipeline whenever we update modelview uniform and later compare that with the stack to determine if it has changed.
2010-12-10 06:13:09 -05:00
stack->age++;
matrix-stack: more optimization for load_identity case This goes a bit further than the previous patch, and as a special case we now simply represent identity matrices using a boolean, and only lazily initialize them when they need to be modified.
2009-10-06 07:36:32 -04:00
}
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05:00
}
void
_cogl_matrix_stack_scale (CoglMatrixStack *stack,
float x,
float y,
float z)
{
CoglMatrixState *state;
[matrix-stack] avoid redundant clearing of matrix when using load_identity The journal always uses an identity matrix since it uses software transformation. Currently it manually uses glLoadMatrix since previous experimentation showed that the cogl-matrix-stack gave bad performance, but it would be nice to fix performance so we only have to care about one path for loading matrices. For the common case where we do: cogl_matrix_stack_push() cogl_matrix_stack_load_identity() we were effectively initializing the matrix 3 times. Once due to use of g_slice_new0, then we had a cogl_matrix_init_identity in _cogl_matrix_state_new for good measure, and then finally in cogl_matrix_stack_load_identity we did another cogl_matrix_init_identity. We don't use g_slice_new0 anymore, _cogl_matrix_state_new is documented as not initializing the matrix (instead _cogl_matrix_stack_top_mutable now takes a boolean to choose if new stack entries should be initialised) and so we now only initialize once in cogl_matrix_stack_load_identity.
2009-10-06 05:52:07 -04:00
state = _cogl_matrix_stack_top_mutable (stack, TRUE);
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05:00
cogl_matrix_scale (&state->matrix, x, y, z);
matrix-stack: more optimization for load_identity case This goes a bit further than the previous patch, and as a special case we now simply represent identity matrices using a boolean, and only lazily initialize them when they need to be modified.
2009-10-06 07:36:32 -04:00
state->is_identity = FALSE;
matrix-stack: Adds a stack age counter Sometimes it would be useful if we could efficiently track when a matrix stack has been modified. For example on GLES2 we have to upload the modelview as a uniform to our glsl programs but because the modelview state is part of the framebuffer state it becomes a bit more tricky to know when to re-sync the value of the uniform with the framebuffer state. This adds an "age" counter to CoglMatrixStack which is incremented for any operation that effectively modifies the top of the stack so now we can save the age of the stack inside the pipeline whenever we update modelview uniform and later compare that with the stack to determine if it has changed.
2010-12-10 06:13:09 -05:00
stack->age++;
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05:00
}
void
_cogl_matrix_stack_translate (CoglMatrixStack *stack,
float x,
float y,
float z)
{
CoglMatrixState *state;
[matrix-stack] avoid redundant clearing of matrix when using load_identity The journal always uses an identity matrix since it uses software transformation. Currently it manually uses glLoadMatrix since previous experimentation showed that the cogl-matrix-stack gave bad performance, but it would be nice to fix performance so we only have to care about one path for loading matrices. For the common case where we do: cogl_matrix_stack_push() cogl_matrix_stack_load_identity() we were effectively initializing the matrix 3 times. Once due to use of g_slice_new0, then we had a cogl_matrix_init_identity in _cogl_matrix_state_new for good measure, and then finally in cogl_matrix_stack_load_identity we did another cogl_matrix_init_identity. We don't use g_slice_new0 anymore, _cogl_matrix_state_new is documented as not initializing the matrix (instead _cogl_matrix_stack_top_mutable now takes a boolean to choose if new stack entries should be initialised) and so we now only initialize once in cogl_matrix_stack_load_identity.
2009-10-06 05:52:07 -04:00
state = _cogl_matrix_stack_top_mutable (stack, TRUE);
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05:00
cogl_matrix_translate (&state->matrix, x, y, z);
matrix-stack: more optimization for load_identity case This goes a bit further than the previous patch, and as a special case we now simply represent identity matrices using a boolean, and only lazily initialize them when they need to be modified.
2009-10-06 07:36:32 -04:00
state->is_identity = FALSE;
matrix-stack: Adds a stack age counter Sometimes it would be useful if we could efficiently track when a matrix stack has been modified. For example on GLES2 we have to upload the modelview as a uniform to our glsl programs but because the modelview state is part of the framebuffer state it becomes a bit more tricky to know when to re-sync the value of the uniform with the framebuffer state. This adds an "age" counter to CoglMatrixStack which is incremented for any operation that effectively modifies the top of the stack so now we can save the age of the stack inside the pipeline whenever we update modelview uniform and later compare that with the stack to determine if it has changed.
2010-12-10 06:13:09 -05:00
stack->age++;
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05:00
}
void
_cogl_matrix_stack_rotate (CoglMatrixStack *stack,
float angle,
float x,
float y,
float z)
{
CoglMatrixState *state;
[matrix-stack] avoid redundant clearing of matrix when using load_identity The journal always uses an identity matrix since it uses software transformation. Currently it manually uses glLoadMatrix since previous experimentation showed that the cogl-matrix-stack gave bad performance, but it would be nice to fix performance so we only have to care about one path for loading matrices. For the common case where we do: cogl_matrix_stack_push() cogl_matrix_stack_load_identity() we were effectively initializing the matrix 3 times. Once due to use of g_slice_new0, then we had a cogl_matrix_init_identity in _cogl_matrix_state_new for good measure, and then finally in cogl_matrix_stack_load_identity we did another cogl_matrix_init_identity. We don't use g_slice_new0 anymore, _cogl_matrix_state_new is documented as not initializing the matrix (instead _cogl_matrix_stack_top_mutable now takes a boolean to choose if new stack entries should be initialised) and so we now only initialize once in cogl_matrix_stack_load_identity.
2009-10-06 05:52:07 -04:00
state = _cogl_matrix_stack_top_mutable (stack, TRUE);
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05:00
cogl_matrix_rotate (&state->matrix, angle, x, y, z);
matrix-stack: more optimization for load_identity case This goes a bit further than the previous patch, and as a special case we now simply represent identity matrices using a boolean, and only lazily initialize them when they need to be modified.
2009-10-06 07:36:32 -04:00
state->is_identity = FALSE;
matrix-stack: Adds a stack age counter Sometimes it would be useful if we could efficiently track when a matrix stack has been modified. For example on GLES2 we have to upload the modelview as a uniform to our glsl programs but because the modelview state is part of the framebuffer state it becomes a bit more tricky to know when to re-sync the value of the uniform with the framebuffer state. This adds an "age" counter to CoglMatrixStack which is incremented for any operation that effectively modifies the top of the stack so now we can save the age of the stack inside the pipeline whenever we update modelview uniform and later compare that with the stack to determine if it has changed.
2010-12-10 06:13:09 -05:00
stack->age++;
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05:00
}
void
_cogl_matrix_stack_multiply (CoglMatrixStack *stack,
const CoglMatrix *matrix)
{
CoglMatrixState *state;
[matrix-stack] avoid redundant clearing of matrix when using load_identity The journal always uses an identity matrix since it uses software transformation. Currently it manually uses glLoadMatrix since previous experimentation showed that the cogl-matrix-stack gave bad performance, but it would be nice to fix performance so we only have to care about one path for loading matrices. For the common case where we do: cogl_matrix_stack_push() cogl_matrix_stack_load_identity() we were effectively initializing the matrix 3 times. Once due to use of g_slice_new0, then we had a cogl_matrix_init_identity in _cogl_matrix_state_new for good measure, and then finally in cogl_matrix_stack_load_identity we did another cogl_matrix_init_identity. We don't use g_slice_new0 anymore, _cogl_matrix_state_new is documented as not initializing the matrix (instead _cogl_matrix_stack_top_mutable now takes a boolean to choose if new stack entries should be initialised) and so we now only initialize once in cogl_matrix_stack_load_identity.
2009-10-06 05:52:07 -04:00
state = _cogl_matrix_stack_top_mutable (stack, TRUE);
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05:00
cogl_matrix_multiply (&state->matrix, &state->matrix, matrix);
matrix-stack: more optimization for load_identity case This goes a bit further than the previous patch, and as a special case we now simply represent identity matrices using a boolean, and only lazily initialize them when they need to be modified.
2009-10-06 07:36:32 -04:00
state->is_identity = FALSE;
matrix-stack: Adds a stack age counter Sometimes it would be useful if we could efficiently track when a matrix stack has been modified. For example on GLES2 we have to upload the modelview as a uniform to our glsl programs but because the modelview state is part of the framebuffer state it becomes a bit more tricky to know when to re-sync the value of the uniform with the framebuffer state. This adds an "age" counter to CoglMatrixStack which is incremented for any operation that effectively modifies the top of the stack so now we can save the age of the stack inside the pipeline whenever we update modelview uniform and later compare that with the stack to determine if it has changed.
2010-12-10 06:13:09 -05:00
stack->age++;
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05:00
}
void
[cogl matrix] Support ortho and perspective projections. This adds cogl_matrix api for multiplying matrices either by a perspective or ortho projective transform. The internal matrix stack and current-matrix APIs also have corresponding support added. New public API: cogl_matrix_perspective cogl_matrix_ortho cogl_ortho cogl_set_modelview_matrix cogl_set_projection_matrix
2009-05-26 06:33:54 -04:00
_cogl_matrix_stack_frustum (CoglMatrixStack *stack,
float left,
float right,
float bottom,
float top,
float z_near,
float z_far)
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05:00
{
CoglMatrixState *state;
[matrix-stack] avoid redundant clearing of matrix when using load_identity The journal always uses an identity matrix since it uses software transformation. Currently it manually uses glLoadMatrix since previous experimentation showed that the cogl-matrix-stack gave bad performance, but it would be nice to fix performance so we only have to care about one path for loading matrices. For the common case where we do: cogl_matrix_stack_push() cogl_matrix_stack_load_identity() we were effectively initializing the matrix 3 times. Once due to use of g_slice_new0, then we had a cogl_matrix_init_identity in _cogl_matrix_state_new for good measure, and then finally in cogl_matrix_stack_load_identity we did another cogl_matrix_init_identity. We don't use g_slice_new0 anymore, _cogl_matrix_state_new is documented as not initializing the matrix (instead _cogl_matrix_stack_top_mutable now takes a boolean to choose if new stack entries should be initialised) and so we now only initialize once in cogl_matrix_stack_load_identity.
2009-10-06 05:52:07 -04:00
state = _cogl_matrix_stack_top_mutable (stack, TRUE);
[cogl matrix] Support ortho and perspective projections. This adds cogl_matrix api for multiplying matrices either by a perspective or ortho projective transform. The internal matrix stack and current-matrix APIs also have corresponding support added. New public API: cogl_matrix_perspective cogl_matrix_ortho cogl_ortho cogl_set_modelview_matrix cogl_set_projection_matrix
2009-05-26 06:33:54 -04:00
cogl_matrix_frustum (&state->matrix,
left, right, bottom, top,
z_near, z_far);
matrix-stack: more optimization for load_identity case This goes a bit further than the previous patch, and as a special case we now simply represent identity matrices using a boolean, and only lazily initialize them when they need to be modified.
2009-10-06 07:36:32 -04:00
state->is_identity = FALSE;
matrix-stack: Adds a stack age counter Sometimes it would be useful if we could efficiently track when a matrix stack has been modified. For example on GLES2 we have to upload the modelview as a uniform to our glsl programs but because the modelview state is part of the framebuffer state it becomes a bit more tricky to know when to re-sync the value of the uniform with the framebuffer state. This adds an "age" counter to CoglMatrixStack which is incremented for any operation that effectively modifies the top of the stack so now we can save the age of the stack inside the pipeline whenever we update modelview uniform and later compare that with the stack to determine if it has changed.
2010-12-10 06:13:09 -05:00
stack->age++;
[cogl matrix] Support ortho and perspective projections. This adds cogl_matrix api for multiplying matrices either by a perspective or ortho projective transform. The internal matrix stack and current-matrix APIs also have corresponding support added. New public API: cogl_matrix_perspective cogl_matrix_ortho cogl_ortho cogl_set_modelview_matrix cogl_set_projection_matrix
2009-05-26 06:33:54 -04:00
}
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05:00
[cogl matrix] Support ortho and perspective projections. This adds cogl_matrix api for multiplying matrices either by a perspective or ortho projective transform. The internal matrix stack and current-matrix APIs also have corresponding support added. New public API: cogl_matrix_perspective cogl_matrix_ortho cogl_ortho cogl_set_modelview_matrix cogl_set_projection_matrix
2009-05-26 06:33:54 -04:00
void
_cogl_matrix_stack_perspective (CoglMatrixStack *stack,
float fov_y,
float aspect,
float z_near,
float z_far)
{
CoglMatrixState *state;
[matrix-stack] avoid redundant clearing of matrix when using load_identity The journal always uses an identity matrix since it uses software transformation. Currently it manually uses glLoadMatrix since previous experimentation showed that the cogl-matrix-stack gave bad performance, but it would be nice to fix performance so we only have to care about one path for loading matrices. For the common case where we do: cogl_matrix_stack_push() cogl_matrix_stack_load_identity() we were effectively initializing the matrix 3 times. Once due to use of g_slice_new0, then we had a cogl_matrix_init_identity in _cogl_matrix_state_new for good measure, and then finally in cogl_matrix_stack_load_identity we did another cogl_matrix_init_identity. We don't use g_slice_new0 anymore, _cogl_matrix_state_new is documented as not initializing the matrix (instead _cogl_matrix_stack_top_mutable now takes a boolean to choose if new stack entries should be initialised) and so we now only initialize once in cogl_matrix_stack_load_identity.
2009-10-06 05:52:07 -04:00
state = _cogl_matrix_stack_top_mutable (stack, TRUE);
[cogl matrix] Support ortho and perspective projections. This adds cogl_matrix api for multiplying matrices either by a perspective or ortho projective transform. The internal matrix stack and current-matrix APIs also have corresponding support added. New public API: cogl_matrix_perspective cogl_matrix_ortho cogl_ortho cogl_set_modelview_matrix cogl_set_projection_matrix
2009-05-26 06:33:54 -04:00
cogl_matrix_perspective (&state->matrix,
fov_y, aspect, z_near, z_far);
matrix-stack: more optimization for load_identity case This goes a bit further than the previous patch, and as a special case we now simply represent identity matrices using a boolean, and only lazily initialize them when they need to be modified.
2009-10-06 07:36:32 -04:00
state->is_identity = FALSE;
matrix-stack: Adds a stack age counter Sometimes it would be useful if we could efficiently track when a matrix stack has been modified. For example on GLES2 we have to upload the modelview as a uniform to our glsl programs but because the modelview state is part of the framebuffer state it becomes a bit more tricky to know when to re-sync the value of the uniform with the framebuffer state. This adds an "age" counter to CoglMatrixStack which is incremented for any operation that effectively modifies the top of the stack so now we can save the age of the stack inside the pipeline whenever we update modelview uniform and later compare that with the stack to determine if it has changed.
2010-12-10 06:13:09 -05:00
stack->age++;
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05:00
}
void
[cogl matrix] Support ortho and perspective projections. This adds cogl_matrix api for multiplying matrices either by a perspective or ortho projective transform. The internal matrix stack and current-matrix APIs also have corresponding support added. New public API: cogl_matrix_perspective cogl_matrix_ortho cogl_ortho cogl_set_modelview_matrix cogl_set_projection_matrix
2009-05-26 06:33:54 -04:00
_cogl_matrix_stack_ortho (CoglMatrixStack *stack,
float left,
float right,
float bottom,
float top,
float z_near,
float z_far)
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05:00
{
CoglMatrixState *state;
[matrix-stack] avoid redundant clearing of matrix when using load_identity The journal always uses an identity matrix since it uses software transformation. Currently it manually uses glLoadMatrix since previous experimentation showed that the cogl-matrix-stack gave bad performance, but it would be nice to fix performance so we only have to care about one path for loading matrices. For the common case where we do: cogl_matrix_stack_push() cogl_matrix_stack_load_identity() we were effectively initializing the matrix 3 times. Once due to use of g_slice_new0, then we had a cogl_matrix_init_identity in _cogl_matrix_state_new for good measure, and then finally in cogl_matrix_stack_load_identity we did another cogl_matrix_init_identity. We don't use g_slice_new0 anymore, _cogl_matrix_state_new is documented as not initializing the matrix (instead _cogl_matrix_stack_top_mutable now takes a boolean to choose if new stack entries should be initialised) and so we now only initialize once in cogl_matrix_stack_load_identity.
2009-10-06 05:52:07 -04:00
state = _cogl_matrix_stack_top_mutable (stack, TRUE);
[cogl matrix] Support ortho and perspective projections. This adds cogl_matrix api for multiplying matrices either by a perspective or ortho projective transform. The internal matrix stack and current-matrix APIs also have corresponding support added. New public API: cogl_matrix_perspective cogl_matrix_ortho cogl_ortho cogl_set_modelview_matrix cogl_set_projection_matrix
2009-05-26 06:33:54 -04:00
cogl_matrix_ortho (&state->matrix,
left, right, bottom, top, z_near, z_far);
matrix-stack: more optimization for load_identity case This goes a bit further than the previous patch, and as a special case we now simply represent identity matrices using a boolean, and only lazily initialize them when they need to be modified.
2009-10-06 07:36:32 -04:00
state->is_identity = FALSE;
matrix-stack: Adds a stack age counter Sometimes it would be useful if we could efficiently track when a matrix stack has been modified. For example on GLES2 we have to upload the modelview as a uniform to our glsl programs but because the modelview state is part of the framebuffer state it becomes a bit more tricky to know when to re-sync the value of the uniform with the framebuffer state. This adds an "age" counter to CoglMatrixStack which is incremented for any operation that effectively modifies the top of the stack so now we can save the age of the stack inside the pipeline whenever we update modelview uniform and later compare that with the stack to determine if it has changed.
2010-12-10 06:13:09 -05:00
stack->age++;
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05:00
}
[matrix] Adds cogl_matrix_get_inverse API This new API takes advantage of the recently imported Mesa code to support inverse matrix calculation. The matrix code keeps track (via internal flags) of the transformations a matrix represents so that it can select an optimized inversion function. Note: although other aspects of the Cogl matrix API have followed a similar style to Cairo's matrix API we haven't added a cogl_matrix_invert API because the inverse of a CoglMatrix is actually cached as part of the CoglMatrix structure meaning a destructive API like cogl_matrix_invert doesn't let users take advantage of this caching design.
2009-10-26 13:51:34 -04:00
gboolean
_cogl_matrix_stack_get_inverse (CoglMatrixStack *stack,
CoglMatrix *inverse)
{
CoglMatrixState *state;
state = _cogl_matrix_stack_top_mutable (stack, TRUE);
return cogl_matrix_get_inverse (&state->matrix, inverse);
}
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05:00
void
[cogl matrix] Support ortho and perspective projections. This adds cogl_matrix api for multiplying matrices either by a perspective or ortho projective transform. The internal matrix stack and current-matrix APIs also have corresponding support added. New public API: cogl_matrix_perspective cogl_matrix_ortho cogl_ortho cogl_set_modelview_matrix cogl_set_projection_matrix
2009-05-26 06:33:54 -04:00
_cogl_matrix_stack_get (CoglMatrixStack *stack,
CoglMatrix *matrix)
{
CoglMatrixState *state;
state = _cogl_matrix_stack_top (stack);
matrix-stack: more optimization for load_identity case This goes a bit further than the previous patch, and as a special case we now simply represent identity matrices using a boolean, and only lazily initialize them when they need to be modified.
2009-10-06 07:36:32 -04:00
/* NB: identity matrices are lazily initialized because we can often avoid
* initializing them at all if nothing is pushed on top of them since we
* load them using glLoadIdentity()
*
* The Cogl journal typically loads an identiy matrix because it performs
* software transformations, which is why we have optimized this case.
*/
if (state->is_identity)
cogl_matrix_init_identity (matrix);
else
*matrix = state->matrix;
[cogl matrix] Support ortho and perspective projections. This adds cogl_matrix api for multiplying matrices either by a perspective or ortho projective transform. The internal matrix stack and current-matrix APIs also have corresponding support added. New public API: cogl_matrix_perspective cogl_matrix_ortho cogl_ortho cogl_set_modelview_matrix cogl_set_projection_matrix
2009-05-26 06:33:54 -04:00
}
void
_cogl_matrix_stack_set (CoglMatrixStack *stack,
const CoglMatrix *matrix)
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05:00
{
CoglMatrixState *state;
matrix-stack: more optimization for load_identity case This goes a bit further than the previous patch, and as a special case we now simply represent identity matrices using a boolean, and only lazily initialize them when they need to be modified.
2009-10-06 07:36:32 -04:00
state = _cogl_matrix_stack_top_mutable (stack, FALSE);
[cogl matrix] Support ortho and perspective projections. This adds cogl_matrix api for multiplying matrices either by a perspective or ortho projective transform. The internal matrix stack and current-matrix APIs also have corresponding support added. New public API: cogl_matrix_perspective cogl_matrix_ortho cogl_ortho cogl_set_modelview_matrix cogl_set_projection_matrix
2009-05-26 06:33:54 -04:00
state->matrix = *matrix;
matrix-stack: more optimization for load_identity case This goes a bit further than the previous patch, and as a special case we now simply represent identity matrices using a boolean, and only lazily initialize them when they need to be modified.
2009-10-06 07:36:32 -04:00
state->is_identity = FALSE;
cogl: upload matrices with uniforms on GLES2 Once the GLES2 wrapper is removed we won't be able to upload the matrices with the fixed function API any more. The fixed function API gives a global state for setting the matrix but if a custom shader uniform is used for the matrices then the state is per program. _cogl_matrix_stack_flush_to_gl is called in a few places and it is assumed the current pipeline doesn't need to be flushed before it is called. To allow these semantics to continue to work, on GLES2 the matrix flush now just stores a reference to the matrix stack in the CoglContext. A pre_paint virtual is added to the progend which is called whenever a pipeline is flushed, even if the same pipeline was flushed already. This gives the GLSL progend a chance to upload the matrices to the uniforms. The combined modelview/projection matrix is only calculated if it is used. The generated programs end up never using the modelview or projection matrix so it usually only has to upload the combined matrix. When a matrix stack is flushed a reference is taked to it by the pipeline progend and the age is stored so that if the same state is used with the same program again then we don't need to reupload the uniform.
2010-12-06 07:31:51 -05:00
stack->age++;
}
static void
Flush matrices in the progend and flip with a vector Previously flushing the matrices was performed as part of the framebuffer state. When on GLES2 this matrix flushing is actually diverted so that it only keeps a reference to the intended matrix stack. This is necessary because on GLES2 there are no builtin uniforms so it can't actually flush the matrices until the program for the pipeline is generated. When the matrices are flushed it would store the age of modifications on the matrix stack so that it could detect when the matrix hasn't changed and avoid flushing it. This patch changes it so that the pipeline is responsible for flushing the matrices even when we are using the GL builtins. The same mechanism for detecting unmodified matrix stacks is used in all cases. There is a new CoglMatrixStackCache type which is used to store a reference to the intended matrix stack along with its last flushed age. There are now two of these attached to the CoglContext to track the flushed state for the global matrix builtins and also two for each glsl progend program state to track the flushed state for a program. The framebuffer matrix flush now just updates the intended matrix stacks without actually trying to flush. When a vertex snippet is attached to the pipeline, the GLSL vertend will now avoid using the projection matrix to flip the rendering. This is necessary because any vertex snippet may cause the projection matrix not to be used. Instead the flip is done as a forced final step by multiplying cogl_position_out by a vec4 uniform. This uniform is updated as part of the progend pre_paint depending on whether the framebuffer is offscreen or not. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-11-29 09:21:07 -05:00
_cogl_matrix_stack_flush_matrix_to_gl_builtin (CoglContext *ctx,
gboolean is_identity,
CoglMatrix *matrix,
CoglMatrixMode mode)
cogl: upload matrices with uniforms on GLES2 Once the GLES2 wrapper is removed we won't be able to upload the matrices with the fixed function API any more. The fixed function API gives a global state for setting the matrix but if a custom shader uniform is used for the matrices then the state is per program. _cogl_matrix_stack_flush_to_gl is called in a few places and it is assumed the current pipeline doesn't need to be flushed before it is called. To allow these semantics to continue to work, on GLES2 the matrix flush now just stores a reference to the matrix stack in the CoglContext. A pre_paint virtual is added to the progend which is called whenever a pipeline is flushed, even if the same pipeline was flushed already. This gives the GLSL progend a chance to upload the matrices to the uniforms. The combined modelview/projection matrix is only calculated if it is used. The generated programs end up never using the modelview or projection matrix so it usually only has to upload the combined matrix. When a matrix stack is flushed a reference is taked to it by the pipeline progend and the age is stored so that if the same state is used with the same program again then we don't need to reupload the uniform.
2010-12-06 07:31:51 -05:00
{
Flush matrices in the progend and flip with a vector Previously flushing the matrices was performed as part of the framebuffer state. When on GLES2 this matrix flushing is actually diverted so that it only keeps a reference to the intended matrix stack. This is necessary because on GLES2 there are no builtin uniforms so it can't actually flush the matrices until the program for the pipeline is generated. When the matrices are flushed it would store the age of modifications on the matrix stack so that it could detect when the matrix hasn't changed and avoid flushing it. This patch changes it so that the pipeline is responsible for flushing the matrices even when we are using the GL builtins. The same mechanism for detecting unmodified matrix stacks is used in all cases. There is a new CoglMatrixStackCache type which is used to store a reference to the intended matrix stack along with its last flushed age. There are now two of these attached to the CoglContext to track the flushed state for the global matrix builtins and also two for each glsl progend program state to track the flushed state for a program. The framebuffer matrix flush now just updates the intended matrix stacks without actually trying to flush. When a vertex snippet is attached to the pipeline, the GLSL vertend will now avoid using the projection matrix to flip the rendering. This is necessary because any vertex snippet may cause the projection matrix not to be used. Instead the flip is done as a forced final step by multiplying cogl_position_out by a vec4 uniform. This uniform is updated as part of the progend pre_paint depending on whether the framebuffer is offscreen or not. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-11-29 09:21:07 -05:00
g_assert (ctx->driver == COGL_DRIVER_GL ||
ctx->driver == COGL_DRIVER_GLES1);
cogl: upload matrices with uniforms on GLES2 Once the GLES2 wrapper is removed we won't be able to upload the matrices with the fixed function API any more. The fixed function API gives a global state for setting the matrix but if a custom shader uniform is used for the matrices then the state is per program. _cogl_matrix_stack_flush_to_gl is called in a few places and it is assumed the current pipeline doesn't need to be flushed before it is called. To allow these semantics to continue to work, on GLES2 the matrix flush now just stores a reference to the matrix stack in the CoglContext. A pre_paint virtual is added to the progend which is called whenever a pipeline is flushed, even if the same pipeline was flushed already. This gives the GLSL progend a chance to upload the matrices to the uniforms. The combined modelview/projection matrix is only calculated if it is used. The generated programs end up never using the modelview or projection matrix so it usually only has to upload the combined matrix. When a matrix stack is flushed a reference is taked to it by the pipeline progend and the age is stored so that if the same state is used with the same program again then we don't need to reupload the uniform.
2010-12-06 07:31:51 -05:00
Flush matrices in the progend and flip with a vector Previously flushing the matrices was performed as part of the framebuffer state. When on GLES2 this matrix flushing is actually diverted so that it only keeps a reference to the intended matrix stack. This is necessary because on GLES2 there are no builtin uniforms so it can't actually flush the matrices until the program for the pipeline is generated. When the matrices are flushed it would store the age of modifications on the matrix stack so that it could detect when the matrix hasn't changed and avoid flushing it. This patch changes it so that the pipeline is responsible for flushing the matrices even when we are using the GL builtins. The same mechanism for detecting unmodified matrix stacks is used in all cases. There is a new CoglMatrixStackCache type which is used to store a reference to the intended matrix stack along with its last flushed age. There are now two of these attached to the CoglContext to track the flushed state for the global matrix builtins and also two for each glsl progend program state to track the flushed state for a program. The framebuffer matrix flush now just updates the intended matrix stacks without actually trying to flush. When a vertex snippet is attached to the pipeline, the GLSL vertend will now avoid using the projection matrix to flip the rendering. This is necessary because any vertex snippet may cause the projection matrix not to be used. Instead the flip is done as a forced final step by multiplying cogl_position_out by a vec4 uniform. This uniform is updated as part of the progend pre_paint depending on whether the framebuffer is offscreen or not. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-11-29 09:21:07 -05:00
#if defined (HAVE_COGL_GL) || defined (HAVE_COGL_GLES)
if (ctx->flushed_matrix_mode != mode)
cogl: upload matrices with uniforms on GLES2 Once the GLES2 wrapper is removed we won't be able to upload the matrices with the fixed function API any more. The fixed function API gives a global state for setting the matrix but if a custom shader uniform is used for the matrices then the state is per program. _cogl_matrix_stack_flush_to_gl is called in a few places and it is assumed the current pipeline doesn't need to be flushed before it is called. To allow these semantics to continue to work, on GLES2 the matrix flush now just stores a reference to the matrix stack in the CoglContext. A pre_paint virtual is added to the progend which is called whenever a pipeline is flushed, even if the same pipeline was flushed already. This gives the GLSL progend a chance to upload the matrices to the uniforms. The combined modelview/projection matrix is only calculated if it is used. The generated programs end up never using the modelview or projection matrix so it usually only has to upload the combined matrix. When a matrix stack is flushed a reference is taked to it by the pipeline progend and the age is stored so that if the same state is used with the same program again then we don't need to reupload the uniform.
2010-12-06 07:31:51 -05:00
{
Flush matrices in the progend and flip with a vector Previously flushing the matrices was performed as part of the framebuffer state. When on GLES2 this matrix flushing is actually diverted so that it only keeps a reference to the intended matrix stack. This is necessary because on GLES2 there are no builtin uniforms so it can't actually flush the matrices until the program for the pipeline is generated. When the matrices are flushed it would store the age of modifications on the matrix stack so that it could detect when the matrix hasn't changed and avoid flushing it. This patch changes it so that the pipeline is responsible for flushing the matrices even when we are using the GL builtins. The same mechanism for detecting unmodified matrix stacks is used in all cases. There is a new CoglMatrixStackCache type which is used to store a reference to the intended matrix stack along with its last flushed age. There are now two of these attached to the CoglContext to track the flushed state for the global matrix builtins and also two for each glsl progend program state to track the flushed state for a program. The framebuffer matrix flush now just updates the intended matrix stacks without actually trying to flush. When a vertex snippet is attached to the pipeline, the GLSL vertend will now avoid using the projection matrix to flip the rendering. This is necessary because any vertex snippet may cause the projection matrix not to be used. Instead the flip is done as a forced final step by multiplying cogl_position_out by a vec4 uniform. This uniform is updated as part of the progend pre_paint depending on whether the framebuffer is offscreen or not. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-11-29 09:21:07 -05:00
GLenum gl_mode = 0;
Fix some compiler warnings GCC complains that some variable might be used uninitialized.
2010-02-09 11:57:14 -05:00
[matrix-stack] Adds ctx->flushed_matrix_mode to cache the gl matrix mode This cache of the gl matrix mode lets us avoid repeat calls to glMatrixMode in _cogl_matrix_stack_flush_to_gl when we have lots of sequential modelview matrix modifications.
2009-10-14 05:53:48 -04:00
switch (mode)
{
case COGL_MATRIX_MODELVIEW:
Flush matrices in the progend and flip with a vector Previously flushing the matrices was performed as part of the framebuffer state. When on GLES2 this matrix flushing is actually diverted so that it only keeps a reference to the intended matrix stack. This is necessary because on GLES2 there are no builtin uniforms so it can't actually flush the matrices until the program for the pipeline is generated. When the matrices are flushed it would store the age of modifications on the matrix stack so that it could detect when the matrix hasn't changed and avoid flushing it. This patch changes it so that the pipeline is responsible for flushing the matrices even when we are using the GL builtins. The same mechanism for detecting unmodified matrix stacks is used in all cases. There is a new CoglMatrixStackCache type which is used to store a reference to the intended matrix stack along with its last flushed age. There are now two of these attached to the CoglContext to track the flushed state for the global matrix builtins and also two for each glsl progend program state to track the flushed state for a program. The framebuffer matrix flush now just updates the intended matrix stacks without actually trying to flush. When a vertex snippet is attached to the pipeline, the GLSL vertend will now avoid using the projection matrix to flip the rendering. This is necessary because any vertex snippet may cause the projection matrix not to be used. Instead the flip is done as a forced final step by multiplying cogl_position_out by a vec4 uniform. This uniform is updated as part of the progend pre_paint depending on whether the framebuffer is offscreen or not. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-11-29 09:21:07 -05:00
gl_mode = GL_MODELVIEW;
[matrix-stack] Adds ctx->flushed_matrix_mode to cache the gl matrix mode This cache of the gl matrix mode lets us avoid repeat calls to glMatrixMode in _cogl_matrix_stack_flush_to_gl when we have lots of sequential modelview matrix modifications.
2009-10-14 05:53:48 -04:00
break;
Fix some compiler warnings GCC complains that some variable might be used uninitialized.
2010-02-09 11:57:14 -05:00
[matrix-stack] Adds ctx->flushed_matrix_mode to cache the gl matrix mode This cache of the gl matrix mode lets us avoid repeat calls to glMatrixMode in _cogl_matrix_stack_flush_to_gl when we have lots of sequential modelview matrix modifications.
2009-10-14 05:53:48 -04:00
case COGL_MATRIX_PROJECTION:
Flush matrices in the progend and flip with a vector Previously flushing the matrices was performed as part of the framebuffer state. When on GLES2 this matrix flushing is actually diverted so that it only keeps a reference to the intended matrix stack. This is necessary because on GLES2 there are no builtin uniforms so it can't actually flush the matrices until the program for the pipeline is generated. When the matrices are flushed it would store the age of modifications on the matrix stack so that it could detect when the matrix hasn't changed and avoid flushing it. This patch changes it so that the pipeline is responsible for flushing the matrices even when we are using the GL builtins. The same mechanism for detecting unmodified matrix stacks is used in all cases. There is a new CoglMatrixStackCache type which is used to store a reference to the intended matrix stack along with its last flushed age. There are now two of these attached to the CoglContext to track the flushed state for the global matrix builtins and also two for each glsl progend program state to track the flushed state for a program. The framebuffer matrix flush now just updates the intended matrix stacks without actually trying to flush. When a vertex snippet is attached to the pipeline, the GLSL vertend will now avoid using the projection matrix to flip the rendering. This is necessary because any vertex snippet may cause the projection matrix not to be used. Instead the flip is done as a forced final step by multiplying cogl_position_out by a vec4 uniform. This uniform is updated as part of the progend pre_paint depending on whether the framebuffer is offscreen or not. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-11-29 09:21:07 -05:00
gl_mode = GL_PROJECTION;
[matrix-stack] Adds ctx->flushed_matrix_mode to cache the gl matrix mode This cache of the gl matrix mode lets us avoid repeat calls to glMatrixMode in _cogl_matrix_stack_flush_to_gl when we have lots of sequential modelview matrix modifications.
2009-10-14 05:53:48 -04:00
break;
Fix some compiler warnings GCC complains that some variable might be used uninitialized.
2010-02-09 11:57:14 -05:00
[matrix-stack] Adds ctx->flushed_matrix_mode to cache the gl matrix mode This cache of the gl matrix mode lets us avoid repeat calls to glMatrixMode in _cogl_matrix_stack_flush_to_gl when we have lots of sequential modelview matrix modifications.
2009-10-14 05:53:48 -04:00
case COGL_MATRIX_TEXTURE:
Flush matrices in the progend and flip with a vector Previously flushing the matrices was performed as part of the framebuffer state. When on GLES2 this matrix flushing is actually diverted so that it only keeps a reference to the intended matrix stack. This is necessary because on GLES2 there are no builtin uniforms so it can't actually flush the matrices until the program for the pipeline is generated. When the matrices are flushed it would store the age of modifications on the matrix stack so that it could detect when the matrix hasn't changed and avoid flushing it. This patch changes it so that the pipeline is responsible for flushing the matrices even when we are using the GL builtins. The same mechanism for detecting unmodified matrix stacks is used in all cases. There is a new CoglMatrixStackCache type which is used to store a reference to the intended matrix stack along with its last flushed age. There are now two of these attached to the CoglContext to track the flushed state for the global matrix builtins and also two for each glsl progend program state to track the flushed state for a program. The framebuffer matrix flush now just updates the intended matrix stacks without actually trying to flush. When a vertex snippet is attached to the pipeline, the GLSL vertend will now avoid using the projection matrix to flip the rendering. This is necessary because any vertex snippet may cause the projection matrix not to be used. Instead the flip is done as a forced final step by multiplying cogl_position_out by a vec4 uniform. This uniform is updated as part of the progend pre_paint depending on whether the framebuffer is offscreen or not. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-11-29 09:21:07 -05:00
gl_mode = GL_TEXTURE;
[matrix-stack] Adds ctx->flushed_matrix_mode to cache the gl matrix mode This cache of the gl matrix mode lets us avoid repeat calls to glMatrixMode in _cogl_matrix_stack_flush_to_gl when we have lots of sequential modelview matrix modifications.
2009-10-14 05:53:48 -04:00
break;
}
Flush matrices in the progend and flip with a vector Previously flushing the matrices was performed as part of the framebuffer state. When on GLES2 this matrix flushing is actually diverted so that it only keeps a reference to the intended matrix stack. This is necessary because on GLES2 there are no builtin uniforms so it can't actually flush the matrices until the program for the pipeline is generated. When the matrices are flushed it would store the age of modifications on the matrix stack so that it could detect when the matrix hasn't changed and avoid flushing it. This patch changes it so that the pipeline is responsible for flushing the matrices even when we are using the GL builtins. The same mechanism for detecting unmodified matrix stacks is used in all cases. There is a new CoglMatrixStackCache type which is used to store a reference to the intended matrix stack along with its last flushed age. There are now two of these attached to the CoglContext to track the flushed state for the global matrix builtins and also two for each glsl progend program state to track the flushed state for a program. The framebuffer matrix flush now just updates the intended matrix stacks without actually trying to flush. When a vertex snippet is attached to the pipeline, the GLSL vertend will now avoid using the projection matrix to flip the rendering. This is necessary because any vertex snippet may cause the projection matrix not to be used. Instead the flip is done as a forced final step by multiplying cogl_position_out by a vec4 uniform. This uniform is updated as part of the progend pre_paint depending on whether the framebuffer is offscreen or not. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-11-29 09:21:07 -05:00
GE (ctx, glMatrixMode (gl_mode));
ctx->flushed_matrix_mode = mode;
[current-matrix] Adds texture matrix stacks + removes GL matrix API usage This relates back to an earlier commitment to stop using the OpenGL matrix API which is considered deprecated. (ref 54159f5a1d029db) The new texture matrix stacks are hung from a list of (internal only) CoglTextureUnit structures which the CoglMaterial code internally references via _cogl_get_texure_unit (). So we would be left with only the cogl-matrix-stack code being responsible for glMatrixMode, glLoadMatrix and glLoadIdentity this commit updates the journal code so it now uses the matrix-stack API instead of GL directly.
2009-09-28 21:58:27 -04:00
}
Virtualize GL matrix operations and use a client-side matrix when GL is indirect This is useful because sometimes we need to get the current matrix, which is too expensive when indirect rendering. In addition, this virtualization makes it easier to clean up the API in the future.
2009-02-24 13:51:25 -05:00
Flush matrices in the progend and flip with a vector Previously flushing the matrices was performed as part of the framebuffer state. When on GLES2 this matrix flushing is actually diverted so that it only keeps a reference to the intended matrix stack. This is necessary because on GLES2 there are no builtin uniforms so it can't actually flush the matrices until the program for the pipeline is generated. When the matrices are flushed it would store the age of modifications on the matrix stack so that it could detect when the matrix hasn't changed and avoid flushing it. This patch changes it so that the pipeline is responsible for flushing the matrices even when we are using the GL builtins. The same mechanism for detecting unmodified matrix stacks is used in all cases. There is a new CoglMatrixStackCache type which is used to store a reference to the intended matrix stack along with its last flushed age. There are now two of these attached to the CoglContext to track the flushed state for the global matrix builtins and also two for each glsl progend program state to track the flushed state for a program. The framebuffer matrix flush now just updates the intended matrix stacks without actually trying to flush. When a vertex snippet is attached to the pipeline, the GLSL vertend will now avoid using the projection matrix to flip the rendering. This is necessary because any vertex snippet may cause the projection matrix not to be used. Instead the flip is done as a forced final step by multiplying cogl_position_out by a vec4 uniform. This uniform is updated as part of the progend pre_paint depending on whether the framebuffer is offscreen or not. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-11-29 09:21:07 -05:00
if (is_identity)
GE (ctx, glLoadIdentity ());
Dynamically load the GL or GLES library The GL or GLES library is now dynamically loaded by the CoglRenderer so that it can choose between GL, GLES1 and GLES2 at runtime. The library is loaded by the renderer because it needs to be done before calling eglInitialize. There is a new environment variable called COGL_DRIVER to choose between gl, gles1 or gles2. The #ifdefs for HAVE_COGL_GL, HAVE_COGL_GLES and HAVE_COGL_GLES2 have been changed so that they don't assume the ifdefs are mutually exclusive. They haven't been removed entirely so that it's possible to compile the GLES backends without the the enums from the GL headers. When using GLX the winsys additionally dynamically loads libGL because that also contains the GLX API. It can't be linked in directly because that would probably conflict with the GLES API if the EGL is selected. When compiling with EGL support the library links directly to libEGL because it doesn't contain any GL API so it shouldn't have any conflicts. When building for WGL or OSX Cogl still directly links against the GL API so there is a #define in config.h so that Cogl won't try to dlopen the library. Cogl-pango previously had a #ifdef to detect when the GL backend is used so that it can sneakily pass GL_QUADS to cogl_vertex_buffer_draw. This is now changed so that it queries the CoglContext for the backend. However to get this to work Cogl now needs to export the _cogl_context_get_default symbol and cogl-pango needs some extra -I flags to so that it can include cogl-context-private.h
2011-07-07 15:44:56 -04:00
else
Flush matrices in the progend and flip with a vector Previously flushing the matrices was performed as part of the framebuffer state. When on GLES2 this matrix flushing is actually diverted so that it only keeps a reference to the intended matrix stack. This is necessary because on GLES2 there are no builtin uniforms so it can't actually flush the matrices until the program for the pipeline is generated. When the matrices are flushed it would store the age of modifications on the matrix stack so that it could detect when the matrix hasn't changed and avoid flushing it. This patch changes it so that the pipeline is responsible for flushing the matrices even when we are using the GL builtins. The same mechanism for detecting unmodified matrix stacks is used in all cases. There is a new CoglMatrixStackCache type which is used to store a reference to the intended matrix stack along with its last flushed age. There are now two of these attached to the CoglContext to track the flushed state for the global matrix builtins and also two for each glsl progend program state to track the flushed state for a program. The framebuffer matrix flush now just updates the intended matrix stacks without actually trying to flush. When a vertex snippet is attached to the pipeline, the GLSL vertend will now avoid using the projection matrix to flip the rendering. This is necessary because any vertex snippet may cause the projection matrix not to be used. Instead the flip is done as a forced final step by multiplying cogl_position_out by a vec4 uniform. This uniform is updated as part of the progend pre_paint depending on whether the framebuffer is offscreen or not. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-11-29 09:21:07 -05:00
GE (ctx, glLoadMatrixf (cogl_matrix_get_array (matrix)));
#endif
}
Dynamically load the GL or GLES library The GL or GLES library is now dynamically loaded by the CoglRenderer so that it can choose between GL, GLES1 and GLES2 at runtime. The library is loaded by the renderer because it needs to be done before calling eglInitialize. There is a new environment variable called COGL_DRIVER to choose between gl, gles1 or gles2. The #ifdefs for HAVE_COGL_GL, HAVE_COGL_GLES and HAVE_COGL_GLES2 have been changed so that they don't assume the ifdefs are mutually exclusive. They haven't been removed entirely so that it's possible to compile the GLES backends without the the enums from the GL headers. When using GLX the winsys additionally dynamically loads libGL because that also contains the GLX API. It can't be linked in directly because that would probably conflict with the GLES API if the EGL is selected. When compiling with EGL support the library links directly to libEGL because it doesn't contain any GL API so it shouldn't have any conflicts. When building for WGL or OSX Cogl still directly links against the GL API so there is a #define in config.h so that Cogl won't try to dlopen the library. Cogl-pango previously had a #ifdef to detect when the GL backend is used so that it can sneakily pass GL_QUADS to cogl_vertex_buffer_draw. This is now changed so that it queries the CoglContext for the backend. However to get this to work Cogl now needs to export the _cogl_context_get_default symbol and cogl-pango needs some extra -I flags to so that it can include cogl-context-private.h
2011-07-07 15:44:56 -04:00
Flush matrices in the progend and flip with a vector Previously flushing the matrices was performed as part of the framebuffer state. When on GLES2 this matrix flushing is actually diverted so that it only keeps a reference to the intended matrix stack. This is necessary because on GLES2 there are no builtin uniforms so it can't actually flush the matrices until the program for the pipeline is generated. When the matrices are flushed it would store the age of modifications on the matrix stack so that it could detect when the matrix hasn't changed and avoid flushing it. This patch changes it so that the pipeline is responsible for flushing the matrices even when we are using the GL builtins. The same mechanism for detecting unmodified matrix stacks is used in all cases. There is a new CoglMatrixStackCache type which is used to store a reference to the intended matrix stack along with its last flushed age. There are now two of these attached to the CoglContext to track the flushed state for the global matrix builtins and also two for each glsl progend program state to track the flushed state for a program. The framebuffer matrix flush now just updates the intended matrix stacks without actually trying to flush. When a vertex snippet is attached to the pipeline, the GLSL vertend will now avoid using the projection matrix to flip the rendering. This is necessary because any vertex snippet may cause the projection matrix not to be used. Instead the flip is done as a forced final step by multiplying cogl_position_out by a vec4 uniform. This uniform is updated as part of the progend pre_paint depending on whether the framebuffer is offscreen or not. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-11-29 09:21:07 -05:00
void
_cogl_matrix_stack_flush_to_gl_builtins (CoglContext *ctx,
CoglMatrixStack *stack,
CoglMatrixMode mode,
gboolean disable_flip)
{
g_assert (ctx->driver == COGL_DRIVER_GL ||
ctx->driver == COGL_DRIVER_GLES1);
Dynamically load the GL or GLES library The GL or GLES library is now dynamically loaded by the CoglRenderer so that it can choose between GL, GLES1 and GLES2 at runtime. The library is loaded by the renderer because it needs to be done before calling eglInitialize. There is a new environment variable called COGL_DRIVER to choose between gl, gles1 or gles2. The #ifdefs for HAVE_COGL_GL, HAVE_COGL_GLES and HAVE_COGL_GLES2 have been changed so that they don't assume the ifdefs are mutually exclusive. They haven't been removed entirely so that it's possible to compile the GLES backends without the the enums from the GL headers. When using GLX the winsys additionally dynamically loads libGL because that also contains the GLX API. It can't be linked in directly because that would probably conflict with the GLES API if the EGL is selected. When compiling with EGL support the library links directly to libEGL because it doesn't contain any GL API so it shouldn't have any conflicts. When building for WGL or OSX Cogl still directly links against the GL API so there is a #define in config.h so that Cogl won't try to dlopen the library. Cogl-pango previously had a #ifdef to detect when the GL backend is used so that it can sneakily pass GL_QUADS to cogl_vertex_buffer_draw. This is now changed so that it queries the CoglContext for the backend. However to get this to work Cogl now needs to export the _cogl_context_get_default symbol and cogl-pango needs some extra -I flags to so that it can include cogl-context-private.h
2011-07-07 15:44:56 -04:00
Flush matrices in the progend and flip with a vector Previously flushing the matrices was performed as part of the framebuffer state. When on GLES2 this matrix flushing is actually diverted so that it only keeps a reference to the intended matrix stack. This is necessary because on GLES2 there are no builtin uniforms so it can't actually flush the matrices until the program for the pipeline is generated. When the matrices are flushed it would store the age of modifications on the matrix stack so that it could detect when the matrix hasn't changed and avoid flushing it. This patch changes it so that the pipeline is responsible for flushing the matrices even when we are using the GL builtins. The same mechanism for detecting unmodified matrix stacks is used in all cases. There is a new CoglMatrixStackCache type which is used to store a reference to the intended matrix stack along with its last flushed age. There are now two of these attached to the CoglContext to track the flushed state for the global matrix builtins and also two for each glsl progend program state to track the flushed state for a program. The framebuffer matrix flush now just updates the intended matrix stacks without actually trying to flush. When a vertex snippet is attached to the pipeline, the GLSL vertend will now avoid using the projection matrix to flip the rendering. This is necessary because any vertex snippet may cause the projection matrix not to be used. Instead the flip is done as a forced final step by multiplying cogl_position_out by a vec4 uniform. This uniform is updated as part of the progend pre_paint depending on whether the framebuffer is offscreen or not. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-11-29 09:21:07 -05:00
#if defined (HAVE_COGL_GL) || defined (HAVE_COGL_GLES)
{
gboolean needs_flip;
CoglMatrixState *state;
CoglMatrixStackCache *cache;
state = _cogl_matrix_stack_top (stack);
if (mode == COGL_MATRIX_PROJECTION)
{
/* Because Cogl defines texture coordinates to have a top left
* origin and because offscreen framebuffers may be used for
* rendering to textures we always render upside down to
* offscreen buffers. Also for some backends we need to render
* onscreen buffers upside-down too.
*/
if (disable_flip)
needs_flip = FALSE;
else
needs_flip = cogl_is_offscreen (cogl_get_draw_framebuffer ());
cache = &ctx->builtin_flushed_projection;
}
else
{
needs_flip = FALSE;
if (mode == COGL_MATRIX_MODELVIEW)
cache = &ctx->builtin_flushed_modelview;
else
cache = NULL;
}
/* We don't need to do anything if the state is the same */
if (!cache ||
_cogl_matrix_stack_check_and_update_cache (stack, cache, needs_flip))
{
gboolean is_identity = state->is_identity && !needs_flip;
if (needs_flip)
{
CoglMatrix flipped_matrix;
cogl_matrix_multiply (&flipped_matrix,
&ctx->y_flip_matrix,
state->is_identity ?
&ctx->identity_matrix :
&state->matrix);
_cogl_matrix_stack_flush_matrix_to_gl_builtin (ctx,
/* not identity */
FALSE,
&flipped_matrix,
mode);
}
else
_cogl_matrix_stack_flush_matrix_to_gl_builtin (ctx,
is_identity,
&state->matrix,
mode);
}
}
Dynamically load the GL or GLES library The GL or GLES library is now dynamically loaded by the CoglRenderer so that it can choose between GL, GLES1 and GLES2 at runtime. The library is loaded by the renderer because it needs to be done before calling eglInitialize. There is a new environment variable called COGL_DRIVER to choose between gl, gles1 or gles2. The #ifdefs for HAVE_COGL_GL, HAVE_COGL_GLES and HAVE_COGL_GLES2 have been changed so that they don't assume the ifdefs are mutually exclusive. They haven't been removed entirely so that it's possible to compile the GLES backends without the the enums from the GL headers. When using GLX the winsys additionally dynamically loads libGL because that also contains the GLX API. It can't be linked in directly because that would probably conflict with the GLES API if the EGL is selected. When compiling with EGL support the library links directly to libEGL because it doesn't contain any GL API so it shouldn't have any conflicts. When building for WGL or OSX Cogl still directly links against the GL API so there is a #define in config.h so that Cogl won't try to dlopen the library. Cogl-pango previously had a #ifdef to detect when the GL backend is used so that it can sneakily pass GL_QUADS to cogl_vertex_buffer_draw. This is now changed so that it queries the CoglContext for the backend. However to get this to work Cogl now needs to export the _cogl_context_get_default symbol and cogl-pango needs some extra -I flags to so that it can include cogl-context-private.h
2011-07-07 15:44:56 -04:00
#endif
[cogl matrix] Adds ability to dirty state cached by the client matrix apis To be able to load matrices to GL manually within Cogl we need a way to dirty the state cached by the client matrix stack API.
2009-06-16 21:08:31 -04:00
}
matrix-stack: Adds a stack age counter Sometimes it would be useful if we could efficiently track when a matrix stack has been modified. For example on GLES2 we have to upload the modelview as a uniform to our glsl programs but because the modelview state is part of the framebuffer state it becomes a bit more tricky to know when to re-sync the value of the uniform with the framebuffer state. This adds an "age" counter to CoglMatrixStack which is incremented for any operation that effectively modifies the top of the stack so now we can save the age of the stack inside the pipeline whenever we update modelview uniform and later compare that with the stack to determine if it has changed.
2010-12-10 06:13:09 -05:00
unsigned int
_cogl_matrix_stack_get_age (CoglMatrixStack *stack)
{
return stack->age;
}
cogl-matrix-stack: Add _cogl_matrix_stack_has_identity_flag This adds an internal function to quickly determine whether the top of the matrix stack is known to be the identity matrix.
2010-12-10 12:42:39 -05:00
gboolean
_cogl_matrix_stack_has_identity_flag (CoglMatrixStack *stack)
{
return _cogl_matrix_stack_top (stack)->is_identity;
}
cogl-matrix-stack: Adds _cogl_matrix_stack_equal Adds a function for comparing the top matrix entries of two matrix stacks. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-11-21 10:49:58 -05:00
gboolean
_cogl_matrix_stack_equal (CoglMatrixStack *stack0,
CoglMatrixStack *stack1)
{
CoglMatrixState *state0 = _cogl_matrix_stack_top (stack0);
CoglMatrixState *state1 = _cogl_matrix_stack_top (stack1);
if (state0->is_identity != state1->is_identity)
return FALSE;
if (state0->is_identity)
return TRUE;
else
return cogl_matrix_equal (&state0->matrix, &state1->matrix);
}
Flush matrices in the progend and flip with a vector Previously flushing the matrices was performed as part of the framebuffer state. When on GLES2 this matrix flushing is actually diverted so that it only keeps a reference to the intended matrix stack. This is necessary because on GLES2 there are no builtin uniforms so it can't actually flush the matrices until the program for the pipeline is generated. When the matrices are flushed it would store the age of modifications on the matrix stack so that it could detect when the matrix hasn't changed and avoid flushing it. This patch changes it so that the pipeline is responsible for flushing the matrices even when we are using the GL builtins. The same mechanism for detecting unmodified matrix stacks is used in all cases. There is a new CoglMatrixStackCache type which is used to store a reference to the intended matrix stack along with its last flushed age. There are now two of these attached to the CoglContext to track the flushed state for the global matrix builtins and also two for each glsl progend program state to track the flushed state for a program. The framebuffer matrix flush now just updates the intended matrix stacks without actually trying to flush. When a vertex snippet is attached to the pipeline, the GLSL vertend will now avoid using the projection matrix to flip the rendering. This is necessary because any vertex snippet may cause the projection matrix not to be used. Instead the flip is done as a forced final step by multiplying cogl_position_out by a vec4 uniform. This uniform is updated as part of the progend pre_paint depending on whether the framebuffer is offscreen or not. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-11-29 09:21:07 -05:00
gboolean
_cogl_matrix_stack_check_and_update_cache (CoglMatrixStack *stack,
CoglMatrixStackCache *cache,
gboolean flip)
{
gboolean is_identity =
_cogl_matrix_stack_has_identity_flag (stack) && !flip;
gboolean is_dirty;
if (is_identity && cache->flushed_identity)
is_dirty = FALSE;
else if (cache->stack == NULL ||
cache->stack->age != cache->age ||
flip != cache->flipped)
is_dirty = TRUE;
else
is_dirty = (cache->stack != stack &&
!_cogl_matrix_stack_equal (cache->stack, stack));
/* We'll update the cache values even if the stack isn't dirty in
case the reason it wasn't dirty is because we compared the
matrices and found them to be the same. In that case updating the
cache values will avoid the comparison next time */
cache->age = stack->age;
cogl_object_ref (stack);
if (cache->stack)
cogl_object_unref (cache->stack);
cache->stack = stack;
cache->flushed_identity = is_identity;
cache->flipped = flip;
return is_dirty;
}
void
_cogl_matrix_stack_init_cache (CoglMatrixStackCache *cache)
{
cache->stack = NULL;
cache->flushed_identity = FALSE;
}
void
_cogl_matrix_stack_destroy_cache (CoglMatrixStackCache *cache)
{
if (cache->stack)
cogl_object_unref (cache->stack);
}
Reference in New Issue Copy Permalink