brl/mutter
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
87c990a29c
mutter/cogl/cogl-matrix-stack.c

551 lines
14 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 18:51:25 +00: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 14:48:12 +00: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 18:51:25 +00: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 14:48:12 +00: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 18:51:25 +00: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 11:34:02 +00: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 18:51:25 +00:00
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
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 12:56:10 +00: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 14:48:12 +00: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 15:13:01 +00: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 18:51:25 +00:00
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "cogl.h"
#include "cogl-context.h"
#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 19:06:35 +00: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 16:06:16 +00:00
#include "cogl-object-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 18:51:25 +00: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 11:36:32 +00: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 18:51:25 +00: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 16:06:16 +00: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 22:07:11 +00: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 18:51:25 +00:00
/* which state does GL have, NULL if unknown */
CoglMatrixState *flushed_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 11:36:32 +00:00
gboolean flushed_identity;
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 11:13:09 +00: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 18:51:25 +00: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 16:06:16 +00: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 09:52:07 +00: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 22:07:11 +00: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 18:51:25 +00: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 09:52:07 +00: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 11:36:32 +00: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 18:51:25 +00: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 22:07:11 +00: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 18:51:25 +00: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 22:07:11 +00: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 18:51:25 +00: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 11:36:32 +00: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 09:52:07 +00: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 18:51:25 +00: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 11:36:32 +00: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 18:51:25 +00: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 22:07:11 +00: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 18:51:25 +00: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 09:52:07 +00: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 18:51:25 +00: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 11:36:32 +00:00
if (state->is_identity)
cogl_matrix_init_identity (&new_top->matrix);
else
new_top->matrix = state->matrix;
[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 09:52:07 +00:00
if (stack->flushed_state == state)
stack->flushed_state = 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 18:51:25 +00: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 09:52:07 +00: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 22:07:11 +00: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 11:36:32 +00: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 09:52:07 +00: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 11:13:09 +00: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 16:06:16 +00: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 18:51:25 +00: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 16:06:16 +00: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 18:51:25 +00: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 22:07:11 +00: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 18:51:25 +00: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 22:07:11 +00: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 18:51:25 +00:00
{
g_warning ("Too many matrix pops");
return;
}
if (stack->flushed_state == state)
{
stack->flushed_state = NULL;
}
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 11:13:09 +00: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 22:07:11 +00: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 18:51:25 +00: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 09:52:07 +00: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 18:51:25 +00: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 11:36:32 +00: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;
/* mark dirty */
stack->flushed_state = NULL;
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 11:13:09 +00: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 11:36:32 +00: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 18:51:25 +00: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 09:52:07 +00: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 18:51:25 +00:00
cogl_matrix_scale (&state->matrix, x, y, z);
/* mark dirty */
stack->flushed_state = NULL;
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 11:36:32 +00: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 11:13:09 +00: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 18:51:25 +00: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 09:52:07 +00: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 18:51:25 +00:00
cogl_matrix_translate (&state->matrix, x, y, z);
/* mark dirty */
stack->flushed_state = NULL;
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 11:36:32 +00: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 11:13:09 +00: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 18:51:25 +00: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 09:52:07 +00: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 18:51:25 +00:00
cogl_matrix_rotate (&state->matrix, angle, x, y, z);
/* mark dirty */
stack->flushed_state = NULL;
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 11:36:32 +00: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 11:13:09 +00: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 18:51:25 +00: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 09:52:07 +00: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 18:51:25 +00:00
cogl_matrix_multiply (&state->matrix, &state->matrix, matrix);
/* mark dirty */
stack->flushed_state = NULL;
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 11:36:32 +00: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 11:13:09 +00: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 18:51:25 +00: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 10:33:54 +00: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 18:51:25 +00: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 09:52:07 +00: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 10:33:54 +00:00
cogl_matrix_frustum (&state->matrix,
left, right, bottom, top,
z_near, z_far);
/* mark dirty */
stack->flushed_state = NULL;
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 11:36:32 +00: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 11:13:09 +00: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 10:33:54 +00: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 18:51:25 +00: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 10:33:54 +00: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 09:52:07 +00: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 10:33:54 +00:00
cogl_matrix_perspective (&state->matrix,
fov_y, aspect, z_near, z_far);
/* mark dirty */
stack->flushed_state = NULL;
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 11:36:32 +00: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 11:13:09 +00: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 18:51:25 +00: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 10:33:54 +00: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 18:51:25 +00: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 09:52:07 +00: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 10:33:54 +00:00
cogl_matrix_ortho (&state->matrix,
left, right, bottom, top, z_near, 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 18:51:25 +00:00
/* mark dirty */
stack->flushed_state = NULL;
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 11:36:32 +00: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 11:13:09 +00: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 18:51:25 +00: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 17:51:34 +00: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 18:51:25 +00: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 10:33:54 +00: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 11:36:32 +00: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 10:33:54 +00: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 18:51:25 +00: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 11:36:32 +00: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 10:33:54 +00:00
state->matrix = *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 18:51:25 +00:00
/* mark dirty */
stack->flushed_state = NULL;
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 11:36:32 +00: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 12:31:51 +00:00
stack->age++;
}
#ifndef HAVE_COGL_GLES2
static void
flush_to_fixed_api_gl (gboolean is_identity,
const CoglMatrix *matrix,
void *user_data)
{
CoglMatrixStack *stack = user_data;
if (is_identity)
{
if (!stack->flushed_identity)
GE (glLoadIdentity ());
stack->flushed_identity = TRUE;
}
else
{
GE (glLoadMatrixf (cogl_matrix_get_array (matrix)) );
stack->flushed_identity = FALSE;
}
}
#endif /* HAVE_COGL_GLES2 */
void
_cogl_matrix_stack_prepare_for_flush (CoglMatrixStack *stack,
CoglMatrixMode mode,
CoglMatrixStackFlushFunc callback,
void *user_data)
{
CoglMatrixState *state;
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
state = _cogl_matrix_stack_top (stack);
/* 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.
*/
if (mode == COGL_MATRIX_PROJECTION &&
cogl_is_offscreen (_cogl_get_framebuffer ()))
{
CoglMatrix flipped_projection;
CoglMatrix *projection =
state->is_identity ? &ctx->identity_matrix : &state->matrix;
cogl_matrix_multiply (&flipped_projection,
&ctx->y_flip_matrix, projection);
callback (FALSE, &flipped_projection, user_data);
}
else
callback (state->is_identity,
state->is_identity ? &ctx->identity_matrix : &state->matrix,
user_data);
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 18:51:25 +00:00
}
void
_cogl_matrix_stack_flush_to_gl (CoglMatrixStack *stack,
[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-29 01:58:27 +00:00
CoglMatrixMode mode)
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 18:51:25 +00:00
{
CoglMatrixState *state;
[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 09:53:48 +00:00
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
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 18:51:25 +00:00
state = _cogl_matrix_stack_top (stack);
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 12:31:51 +00:00
#ifdef HAVE_COGL_GLES2
/* Under GLES2 we need to flush the matrices differently because
they are stored in uniforms attached to the program instead of
the global GL context state. At this point we can't be sure that
the right program will be generated so instead we'll just store a
reference to the matrix stack that is intended to be flushed and
update the uniform once the program is ready. */
switch (mode)
{
case COGL_MATRIX_MODELVIEW:
cogl_object_ref (stack);
if (ctx->flushed_modelview_stack)
cogl_object_unref (ctx->flushed_modelview_stack);
ctx->flushed_modelview_stack = stack;
break;
case COGL_MATRIX_PROJECTION:
cogl_object_ref (stack);
if (ctx->flushed_projection_stack)
cogl_object_unref (ctx->flushed_projection_stack);
ctx->flushed_projection_stack = stack;
break;
case COGL_MATRIX_TEXTURE:
/* This shouldn't happen because the texture matrices are
handled by the GLSL pipeline backend */
g_assert_not_reached ();
break;
}
#else /* HAVE_COGL_GLES2 */
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 18:51:25 +00:00
if (stack->flushed_state == state)
return;
[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 09:53:48 +00:00
if (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-29 01:58:27 +00:00
{
Fix some compiler warnings GCC complains that some variable might be used uninitialized.
2010-02-09 16:57:14 +00:00
GLenum gl_mode = 0;
[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 09:53:48 +00:00
switch (mode)
{
case COGL_MATRIX_MODELVIEW:
gl_mode = GL_MODELVIEW;
break;
Fix some compiler warnings GCC complains that some variable might be used uninitialized.
2010-02-09 16:57:14 +00: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 09:53:48 +00:00
case COGL_MATRIX_PROJECTION:
gl_mode = GL_PROJECTION;
break;
Fix some compiler warnings GCC complains that some variable might be used uninitialized.
2010-02-09 16:57:14 +00: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 09:53:48 +00:00
case COGL_MATRIX_TEXTURE:
gl_mode = GL_TEXTURE;
break;
}
Fix some compiler warnings GCC complains that some variable might be used uninitialized.
2010-02-09 16:57:14 +00: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 09:53:48 +00:00
GE (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-29 01:58:27 +00: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 18:51:25 +00:00
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 12:31:51 +00:00
_cogl_matrix_stack_prepare_for_flush (stack,
mode,
flush_to_fixed_api_gl,
stack);
#endif /* HAVE_COGL_GLES2 */
[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 15:13:01 +00: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 18:51:25 +00:00
stack->flushed_state = state;
}
[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-17 01:08:31 +00:00
void
_cogl_matrix_stack_dirty (CoglMatrixStack *stack)
{
stack->flushed_state = NULL;
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 11:36:32 +00:00
stack->flushed_identity = FALSE;
[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-17 01:08:31 +00: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 11:13:09 +00: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 17:42:39 +00:00
gboolean
_cogl_matrix_stack_has_identity_flag (CoglMatrixStack *stack)
{
return _cogl_matrix_stack_top (stack)->is_identity;
}
Reference in New Issue Copy Permalink