sungmg/mutter-performance-source
1
0
Fork 0
Code Activity

cogl-clip-stack: Don't allocate a separate struct for CoglClipStack

Browse source 
Instead of having a separate CoglHandle for CoglClipStack the code is
now expected to directly hold a pointer to the top entry on the
stack. The empty stack is then the NULL pointer. This saves an
allocation when we want to copy the stack because we can just take a
reference on a stack entry. The idea is that this will make it
possible to store the clip stack in the journal without any extra
allocations.

The _cogl_get_clip_stack and set functions now take a CoglClipStack
pointer instead of a handle so it would no longer make sense to make
them public. However I think the only reason we would have wanted that
in the first place would be to save the clip state between switching
FBOs and that is no longer necessary.
This commit is contained in:
Neil Roberts 2010-11-01 19:52:45 +00:00
parent af5ddb0b13
commit f15b47cc03
4 changed files with 116 additions and 190 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

193
cogl/cogl-clip-stack.c
View file

@ -41,17 +41,16 @@
#include "cogl-path-private.h" #include "cogl-path-private.h"
#include "cogl-matrix-private.h" #include "cogl-matrix-private.h"
typedef struct _CoglClipStackEntry CoglClipStackEntry; typedef struct _CoglClipStackRect CoglClipStackRect;
typedef struct _CoglClipStackEntryRect CoglClipStackEntryRect; typedef struct _CoglClipStackWindowRect CoglClipStackWindowRect;
typedef struct _CoglClipStackEntryWindowRect CoglClipStackEntryWindowRect; typedef struct _CoglClipStackPath CoglClipStackPath;
typedef struct _CoglClipStackEntryPath CoglClipStackEntryPath;
typedef enum typedef enum
{ {
COGL_CLIP_STACK_RECT, COGL_CLIP_STACK_RECT,
COGL_CLIP_STACK_WINDOW_RECT, COGL_CLIP_STACK_WINDOW_RECT,
COGL_CLIP_STACK_PATH COGL_CLIP_STACK_PATH
} CoglClipStackEntryType; } CoglClipStackType;
/* A clip stack consists a list of entries. Each entry has a reference /* A clip stack consists a list of entries. Each entry has a reference
* count and a link to its parent node. The child takes a reference on * count and a link to its parent node. The child takes a reference on
@ -63,14 +62,12 @@ typedef enum
* For example, the following sequence of operations would generate * For example, the following sequence of operations would generate
* the tree below: * the tree below:
* *
* CoglClipStack *stack_a = _cogl_clip_stack_new (); * CoglClipStack *stack_a = NULL;
* _cogl_set_clip_stack (stack_a); * stack_a = _cogl_clip_stack_push_rectangle (stack_a, ...);
* cogl_clip_stack_push_rectangle (...); * stack_a = _cogl_clip_stack_push_rectangle (stack_a, ...);
* cogl_clip_stack_push_rectangle (...); * stack_a = _cogl_clip_stack_push_from_path (stack_a, ...);
* CoglClipStack *stack_b = _cogl_clip_stack_copy (stack_a); * CoglClipStack *stack_b = NULL;
* cogl_clip_stack_push_from_path (); * stack_b = cogl_clip_stack_push_window_rectangle (stack_b, ...);
* cogl_set_clip_stack (stack_b);
* cogl_clip_stack_push_window_rectangle (...);
* *
* stack_a * stack_a
* \ holds a ref to * \ holds a ref to
@ -95,18 +92,11 @@ typedef enum
struct _CoglClipStack struct _CoglClipStack
{ {
CoglObject _parent; CoglClipStackType type;
CoglClipStackEntry *stack_top;
};
struct _CoglClipStackEntry
{
CoglClipStackEntryType type;
/* This will be null if there is no parent. If it is not null then /* This will be null if there is no parent. If it is not null then
this node must be holding a reference to the parent */ this node must be holding a reference to the parent */
CoglClipStackEntry *parent; CoglClipStack *parent;
/* All clip entries have a window-space bounding box which we can /* All clip entries have a window-space bounding box which we can
use to calculate a scissor. The scissor limits the clip so that use to calculate a scissor. The scissor limits the clip so that
@ -121,9 +111,9 @@ struct _CoglClipStackEntry
unsigned int ref_count; unsigned int ref_count;
}; };
struct _CoglClipStackEntryRect struct _CoglClipStackRect
{ {
CoglClipStackEntry _parent_data; CoglClipStack _parent_data;
/* The rectangle for this clip */ /* The rectangle for this clip */
float x0; float x0;
@ -135,17 +125,17 @@ struct _CoglClipStackEntryRect
CoglMatrix matrix; CoglMatrix matrix;
}; };
struct _CoglClipStackEntryWindowRect struct _CoglClipStackWindowRect
{ {
CoglClipStackEntry _parent_data; CoglClipStack _parent_data;
/* The window rect clip doesn't need any specific data because it /* The window rect clip doesn't need any specific data because it
just adds to the scissor clip */ just adds to the scissor clip */
}; };
struct _CoglClipStackEntryPath struct _CoglClipStackPath
{ {
CoglClipStackEntry _parent_data; CoglClipStack _parent_data;
/* The matrix that was current when the clip was set */ /* The matrix that was current when the clip was set */
CoglMatrix matrix; CoglMatrix matrix;
@ -153,12 +143,6 @@ struct _CoglClipStackEntryPath
CoglPath *path; CoglPath *path;
}; };
static void _cogl_clip_stack_free (CoglClipStack *stack);
COGL_OBJECT_INTERNAL_DEFINE (ClipStack, clip_stack);
#define COGL_CLIP_STACK(stack) ((CoglClipStack *) (stack))
static void static void
project_vertex (const CoglMatrix *modelview_matrix, project_vertex (const CoglMatrix *modelview_matrix,
const CoglMatrix *projection_matrix, const CoglMatrix *projection_matrix,
@ -398,20 +382,18 @@ disable_clip_planes (void)
static gpointer static gpointer
_cogl_clip_stack_push_entry (CoglClipStack *clip_stack, _cogl_clip_stack_push_entry (CoglClipStack *clip_stack,
size_t size, size_t size,
CoglClipStackEntryType type) CoglClipStackType type)
{ {
CoglClipStackEntry *entry = g_slice_alloc (size); CoglClipStack *entry = g_slice_alloc (size);
/* The new entry starts with a ref count of 1 because the stack /* The new entry starts with a ref count of 1 because the stack
holds a reference to it as it is the top entry */ holds a reference to it as it is the top entry */
entry->ref_count = 1; entry->ref_count = 1;
entry->type = type; entry->type = type;
entry->parent = clip_stack->stack_top; entry->parent = clip_stack;
clip_stack->stack_top = entry;
/* We don't need to take a reference to the parent from the entry /* We don't need to take a reference to the parent from the entry
because the clip_stack would have had to reference the top of because the we are stealing the ref in the new stack top */
the stack and we can just steal that */
return entry; return entry;
} }
@ -419,7 +401,7 @@ _cogl_clip_stack_push_entry (CoglClipStack *clip_stack,
/* Sets the window-space bounds of the entry based on the projected /* Sets the window-space bounds of the entry based on the projected
coordinates of the given rectangle */ coordinates of the given rectangle */
static void static void
_cogl_clip_stack_entry_set_bounds (CoglClipStackEntry *entry, _cogl_clip_stack_entry_set_bounds (CoglClipStack *entry,
float x_1, float x_1,
float y_1, float y_1,
float x_2, float x_2,
@ -459,28 +441,28 @@ _cogl_clip_stack_entry_set_bounds (CoglClipStackEntry *entry,
entry->bounds_y1 = ceilf (max_y); entry->bounds_y1 = ceilf (max_y);
} }
void CoglClipStack *
_cogl_clip_stack_push_window_rectangle (CoglClipStack *stack, _cogl_clip_stack_push_window_rectangle (CoglClipStack *stack,
int x_offset, int x_offset,
int y_offset, int y_offset,
int width, int width,
int height) int height)
{ {
CoglClipStackEntry *entry; CoglClipStack *entry;
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
entry = _cogl_clip_stack_push_entry (stack, entry = _cogl_clip_stack_push_entry (stack,
sizeof (CoglClipStackEntryWindowRect), sizeof (CoglClipStackWindowRect),
COGL_CLIP_STACK_WINDOW_RECT); COGL_CLIP_STACK_WINDOW_RECT);
entry->bounds_x0 = x_offset; entry->bounds_x0 = x_offset;
entry->bounds_x1 = x_offset + width; entry->bounds_x1 = x_offset + width;
entry->bounds_y0 = y_offset; entry->bounds_y0 = y_offset;
entry->bounds_y1 = y_offset + height; entry->bounds_y1 = y_offset + height;
return entry;
} }
void CoglClipStack *
_cogl_clip_stack_push_rectangle (CoglClipStack *stack, _cogl_clip_stack_push_rectangle (CoglClipStack *stack,
float x_1, float x_1,
float y_1, float y_1,
@ -488,11 +470,11 @@ _cogl_clip_stack_push_rectangle (CoglClipStack *stack,
float y_2, float y_2,
const CoglMatrix *modelview_matrix) const CoglMatrix *modelview_matrix)
{ {
CoglClipStackEntryRect *entry; CoglClipStackRect *entry;
/* Make a new entry */ /* Make a new entry */
entry = _cogl_clip_stack_push_entry (stack, entry = _cogl_clip_stack_push_entry (stack,
sizeof (CoglClipStackEntryRect), sizeof (CoglClipStackRect),
COGL_CLIP_STACK_RECT); COGL_CLIP_STACK_RECT);
entry->x0 = x_1; entry->x0 = x_1;
@ -502,20 +484,22 @@ _cogl_clip_stack_push_rectangle (CoglClipStack *stack,
entry->matrix = *modelview_matrix; entry->matrix = *modelview_matrix;
_cogl_clip_stack_entry_set_bounds ((CoglClipStackEntry *) entry, _cogl_clip_stack_entry_set_bounds ((CoglClipStack *) entry,
x_1, y_1, x_2, y_2, modelview_matrix); x_1, y_1, x_2, y_2, modelview_matrix);
return (CoglClipStack *) entry;
} }
void CoglClipStack *
_cogl_clip_stack_push_from_path (CoglClipStack *stack, _cogl_clip_stack_push_from_path (CoglClipStack *stack,
CoglPath *path, CoglPath *path,
const CoglMatrix *modelview_matrix) const CoglMatrix *modelview_matrix)
{ {
CoglClipStackEntryPath *entry; CoglClipStackPath *entry;
float x_1, y_1, x_2, y_2; float x_1, y_1, x_2, y_2;
entry = _cogl_clip_stack_push_entry (stack, entry = _cogl_clip_stack_push_entry (stack,
sizeof (CoglClipStackEntryPath), sizeof (CoglClipStackPath),
COGL_CLIP_STACK_PATH); COGL_CLIP_STACK_PATH);
entry->path = cogl_path_copy (path); entry->path = cogl_path_copy (path);
@ -524,32 +508,45 @@ _cogl_clip_stack_push_from_path (CoglClipStack *stack,
_cogl_path_get_bounds (path, &x_1, &y_1, &x_2, &y_2); _cogl_path_get_bounds (path, &x_1, &y_1, &x_2, &y_2);
_cogl_clip_stack_entry_set_bounds ((CoglClipStackEntry *) entry, _cogl_clip_stack_entry_set_bounds ((CoglClipStack *) entry,
x_1, y_1, x_2, y_2, modelview_matrix); x_1, y_1, x_2, y_2, modelview_matrix);
return (CoglClipStack *) entry;
} }
static void CoglClipStack *
_cogl_clip_stack_entry_unref (CoglClipStackEntry *entry) _cogl_clip_stack_ref (CoglClipStack *entry)
{
/* A NULL pointer is considered a valid stack so we should accept
that as an argument */
if (entry)
entry->ref_count++;
return entry;
}
void
_cogl_clip_stack_unref (CoglClipStack *entry)
{ {
/* Unref all of the entries until we hit the root of the list or the /* Unref all of the entries until we hit the root of the list or the
entry still has a remaining reference */ entry still has a remaining reference */
while (entry && --entry->ref_count <= 0) while (entry && --entry->ref_count <= 0)
{ {
CoglClipStackEntry *parent = entry->parent; CoglClipStack *parent = entry->parent;
switch (entry->type) switch (entry->type)
{ {
case COGL_CLIP_STACK_RECT: case COGL_CLIP_STACK_RECT:
g_slice_free1 (sizeof (CoglClipStackEntryRect), entry); g_slice_free1 (sizeof (CoglClipStackRect), entry);
break; break;
case COGL_CLIP_STACK_WINDOW_RECT: case COGL_CLIP_STACK_WINDOW_RECT:
g_slice_free1 (sizeof (CoglClipStackEntryWindowRect), entry); g_slice_free1 (sizeof (CoglClipStackWindowRect), entry);
break; break;
case COGL_CLIP_STACK_PATH: case COGL_CLIP_STACK_PATH:
cogl_object_unref (((CoglClipStackEntryPath *) entry)->path); cogl_object_unref (((CoglClipStackPath *) entry)->path);
g_slice_free1 (sizeof (CoglClipStackEntryPath), entry); g_slice_free1 (sizeof (CoglClipStackPath), entry);
break; break;
default: default:
@ -560,12 +557,12 @@ _cogl_clip_stack_entry_unref (CoglClipStackEntry *entry)
} }
} }
void CoglClipStack *
_cogl_clip_stack_pop (CoglClipStack *stack) _cogl_clip_stack_pop (CoglClipStack *stack)
{ {
CoglClipStackEntry *entry; CoglClipStack *new_top;
g_return_if_fail (stack->stack_top != NULL); g_return_val_if_fail (stack != NULL, NULL);
/* To pop we are moving the top of the stack to the old top's parent /* To pop we are moving the top of the stack to the old top's parent
node. The stack always needs to have a reference to the top entry node. The stack always needs to have a reference to the top entry
@ -575,11 +572,13 @@ _cogl_clip_stack_pop (CoglClipStack *stack)
this stack was the only thing referencing the old top. In that this stack was the only thing referencing the old top. In that
case the call to _cogl_clip_stack_entry_unref will unref the case the call to _cogl_clip_stack_entry_unref will unref the
parent. */ parent. */
entry = stack->stack_top; new_top = stack->parent;
stack->stack_top = entry->parent;
if (stack->stack_top) _cogl_clip_stack_ref (new_top);
stack->stack_top->ref_count++;
_cogl_clip_stack_entry_unref (entry); _cogl_clip_stack_unref (stack);
return new_top;
} }
void void
@ -595,7 +594,7 @@ _cogl_clip_stack_flush (CoglClipStack *stack,
int scissor_y1 = G_MAXINT; int scissor_y1 = G_MAXINT;
CoglMatrixStack *modelview_stack = CoglMatrixStack *modelview_stack =
_cogl_framebuffer_get_modelview_stack (_cogl_get_framebuffer ()); _cogl_framebuffer_get_modelview_stack (_cogl_get_framebuffer ());
CoglClipStackEntry *entry; CoglClipStack *entry;
int scissor_y_start; int scissor_y_start;
has_clip_planes = cogl_features_available (COGL_FEATURE_FOUR_CLIP_PLANES); has_clip_planes = cogl_features_available (COGL_FEATURE_FOUR_CLIP_PLANES);
@ -605,7 +604,7 @@ _cogl_clip_stack_flush (CoglClipStack *stack,
disable_stencil_buffer (); disable_stencil_buffer ();
/* If the stack is empty then there's nothing else to do */ /* If the stack is empty then there's nothing else to do */
if (stack->stack_top == NULL) if (stack == NULL)
{ {
*stencil_used_p = FALSE; *stencil_used_p = FALSE;
GE (glDisable (GL_SCISSOR_TEST)); GE (glDisable (GL_SCISSOR_TEST));
@ -616,7 +615,7 @@ _cogl_clip_stack_flush (CoglClipStack *stack,
clear the stencil buffer then the clear will be clipped to the clear the stencil buffer then the clear will be clipped to the
intersection of all of the bounding boxes. This saves having to intersection of all of the bounding boxes. This saves having to
clear the whole stencil buffer */ clear the whole stencil buffer */
for (entry = stack->stack_top; entry; entry = entry->parent) for (entry = stack; entry; entry = entry->parent)
{ {
/* Get the intersection of the current scissor and the bounding /* Get the intersection of the current scissor and the bounding
box of this clip */ box of this clip */
@ -661,11 +660,11 @@ _cogl_clip_stack_flush (CoglClipStack *stack,
reverse order that they were specified but as all of the clips reverse order that they were specified but as all of the clips
are intersecting it should work out the same regardless of the are intersecting it should work out the same regardless of the
order */ order */
for (entry = stack->stack_top; entry; entry = entry->parent) for (entry = stack; entry; entry = entry->parent)
{ {
if (entry->type == COGL_CLIP_STACK_PATH) if (entry->type == COGL_CLIP_STACK_PATH)
{ {
CoglClipStackEntryPath *path_entry = (CoglClipStackEntryPath *) entry; CoglClipStackPath *path_entry = (CoglClipStackPath *) entry;
_cogl_matrix_stack_push (modelview_stack); _cogl_matrix_stack_push (modelview_stack);
_cogl_matrix_stack_set (modelview_stack, &path_entry->matrix); _cogl_matrix_stack_set (modelview_stack, &path_entry->matrix);
@ -680,7 +679,7 @@ _cogl_clip_stack_flush (CoglClipStack *stack,
} }
else if (entry->type == COGL_CLIP_STACK_RECT) else if (entry->type == COGL_CLIP_STACK_RECT)
{ {
CoglClipStackEntryRect *rect = (CoglClipStackEntryRect *) entry; CoglClipStackRect *rect = (CoglClipStackRect *) entry;
_cogl_matrix_stack_push (modelview_stack); _cogl_matrix_stack_push (modelview_stack);
_cogl_matrix_stack_set (modelview_stack, &rect->matrix); _cogl_matrix_stack_set (modelview_stack, &rect->matrix);
@ -721,47 +720,3 @@ _cogl_clip_stack_flush (CoglClipStack *stack,
*stencil_used_p = using_stencil_buffer; *stencil_used_p = using_stencil_buffer;
} }
CoglClipStack *
_cogl_clip_stack_new (void)
{
CoglClipStack *stack;
stack = g_slice_new (CoglClipStack);
stack->stack_top = NULL;
return _cogl_clip_stack_object_new (stack);
}
void
_cogl_clip_stack_free (CoglClipStack *stack)
{
/* We only need to unref the top node and this
should end up freeing all of the parents if need be */
if (stack->stack_top)
_cogl_clip_stack_entry_unref (stack->stack_top);
g_slice_free (CoglClipStack, stack);
}
CoglClipStack *
_cogl_clip_stack_copy (CoglClipStack *old_stack)
{
CoglClipStack *new_stack;
if (!_cogl_is_clip_stack (old_stack))
return NULL;
new_stack = _cogl_clip_stack_new ();
/* We can copy the stack by just referencing the other stack's
data. There's no need to implement copy-on-write because the
entries of the stack can't be modified. If the other stack pops
some entries off they will still be kept alive because this stack
holds a reference. */
new_stack->stack_top = old_stack->stack_top;
if (new_stack->stack_top)
new_stack->stack_top->ref_count++;
return new_stack;
}

38
cogl/cogl-clip-stack.h
View file

@ -24,19 +24,24 @@
#ifndef __COGL_CLIP_STACK_H #ifndef __COGL_CLIP_STACK_H
#define __COGL_CLIP_STACK_H #define __COGL_CLIP_STACK_H
/* The clip stack works like a GSList where only a pointer to the top
of the stack is stored. The empty clip stack is represented simply
by the NULL pointer. When an entry is added to or removed from the
stack the new top of the stack is returned. When an entry is pushed
a new clip stack entry is created which effectively takes ownership
of the reference on the old entry. Therefore unrefing the top entry
effectively loses ownership of all entries in the stack */
typedef struct _CoglClipStack CoglClipStack; typedef struct _CoglClipStack CoglClipStack;
CoglClipStack * CoglClipStack *
_cogl_clip_stack_new (void);
void
_cogl_clip_stack_push_window_rectangle (CoglClipStack *stack, _cogl_clip_stack_push_window_rectangle (CoglClipStack *stack,
int x_offset, int x_offset,
int y_offset, int y_offset,
int width, int width,
int height); int height);
void CoglClipStack *
_cogl_clip_stack_push_rectangle (CoglClipStack *stack, _cogl_clip_stack_push_rectangle (CoglClipStack *stack,
float x_1, float x_1,
float y_1, float y_1,
@ -44,34 +49,21 @@ _cogl_clip_stack_push_rectangle (CoglClipStack *stack,
float y_2, float y_2,
const CoglMatrix *modelview_matrix); const CoglMatrix *modelview_matrix);
void CoglClipStack *
_cogl_clip_stack_push_from_path (CoglClipStack *stack, _cogl_clip_stack_push_from_path (CoglClipStack *stack,
CoglPath *path, CoglPath *path,
const CoglMatrix *modelview_matrix); const CoglMatrix *modelview_matrix);
void CoglClipStack *
_cogl_clip_stack_pop (CoglClipStack *stack); _cogl_clip_stack_pop (CoglClipStack *stack);
void void
_cogl_clip_stack_flush (CoglClipStack *stack, _cogl_clip_stack_flush (CoglClipStack *stack,
gboolean *stencil_used_p); gboolean *stencil_used_p);
/* TODO: we may want to make this function public because it can be
* used to implement a better API than cogl_clip_stack_save() and
* cogl_clip_stack_restore().
*/
/*
* _cogl_clip_stack_copy:
* @stack: A #CoglClipStack
*
* Creates a copy of the given clip stack and returns a new pointer to
* it. The data from the original stack is shared with the new stack
* so making copies is relatively cheap. Modifying the original stack
* does not affect the new stack.
*
* Return value: a new clip stack with the same data as @stack
*/
CoglClipStack * CoglClipStack *
_cogl_clip_stack_copy (CoglClipStack *stack); _cogl_clip_stack_ref (CoglClipStack *stack);
void
_cogl_clip_stack_unref (CoglClipStack *stack);
#endif /* __COGL_CLIP_STACK_H */ #endif /* __COGL_CLIP_STACK_H */

55
cogl/cogl-clip-state.c
View file

@ -48,7 +48,6 @@ cogl_clip_push_window_rectangle (int x_offset,
{ {
CoglFramebuffer *framebuffer; CoglFramebuffer *framebuffer;
CoglClipState *clip_state; CoglClipState *clip_state;
CoglHandle stack;
_COGL_GET_CONTEXT (ctx, NO_RETVAL); _COGL_GET_CONTEXT (ctx, NO_RETVAL);
@ -59,10 +58,10 @@ cogl_clip_push_window_rectangle (int x_offset,
framebuffer = _cogl_get_framebuffer (); framebuffer = _cogl_get_framebuffer ();
clip_state = _cogl_framebuffer_get_clip_state (framebuffer); clip_state = _cogl_framebuffer_get_clip_state (framebuffer);
stack = clip_state->stacks->data; clip_state->stacks->data =
_cogl_clip_stack_push_window_rectangle (clip_state->stacks->data,
_cogl_clip_stack_push_window_rectangle (stack, x_offset, y_offset, x_offset, y_offset,
width, height); width, height);
clip_state->stack_dirty = TRUE; clip_state->stack_dirty = TRUE;
} }
@ -135,7 +134,6 @@ cogl_clip_push_rectangle (float x_1,
{ {
CoglFramebuffer *framebuffer; CoglFramebuffer *framebuffer;
CoglClipState *clip_state; CoglClipState *clip_state;
CoglHandle stack;
CoglMatrix modelview_matrix; CoglMatrix modelview_matrix;
_COGL_GET_CONTEXT (ctx, NO_RETVAL); _COGL_GET_CONTEXT (ctx, NO_RETVAL);
@ -152,12 +150,12 @@ cogl_clip_push_rectangle (float x_1,
framebuffer = _cogl_get_framebuffer (); framebuffer = _cogl_get_framebuffer ();
clip_state = _cogl_framebuffer_get_clip_state (framebuffer); clip_state = _cogl_framebuffer_get_clip_state (framebuffer);
stack = clip_state->stacks->data;
cogl_get_modelview_matrix (&modelview_matrix); cogl_get_modelview_matrix (&modelview_matrix);
_cogl_clip_stack_push_rectangle (stack, x_1, y_1, x_2, y_2, clip_state->stacks->data =
&modelview_matrix); _cogl_clip_stack_push_rectangle (clip_state->stacks->data,
x_1, y_1, x_2, y_2,
&modelview_matrix);
clip_state->stack_dirty = TRUE; clip_state->stack_dirty = TRUE;
} }
@ -180,7 +178,6 @@ cogl_clip_push_from_path_preserve (void)
{ {
CoglFramebuffer *framebuffer; CoglFramebuffer *framebuffer;
CoglClipState *clip_state; CoglClipState *clip_state;
CoglHandle stack;
CoglMatrix modelview_matrix; CoglMatrix modelview_matrix;
_COGL_GET_CONTEXT (ctx, NO_RETVAL); _COGL_GET_CONTEXT (ctx, NO_RETVAL);
@ -192,12 +189,11 @@ cogl_clip_push_from_path_preserve (void)
framebuffer = _cogl_get_framebuffer (); framebuffer = _cogl_get_framebuffer ();
clip_state = _cogl_framebuffer_get_clip_state (framebuffer); clip_state = _cogl_framebuffer_get_clip_state (framebuffer);
stack = clip_state->stacks->data;
cogl_get_modelview_matrix (&modelview_matrix); cogl_get_modelview_matrix (&modelview_matrix);
_cogl_clip_stack_push_from_path (stack, cogl_get_path (), clip_state->stacks->data =
&modelview_matrix); _cogl_clip_stack_push_from_path (clip_state->stacks->data, cogl_get_path (),
&modelview_matrix);
clip_state->stack_dirty = TRUE; clip_state->stack_dirty = TRUE;
} }
@ -213,15 +209,11 @@ cogl_clip_push_from_path (void)
static void static void
_cogl_clip_pop_real (CoglClipState *clip_state) _cogl_clip_pop_real (CoglClipState *clip_state)
{ {
CoglHandle stack;
/* We don't log clip stack changes in the journal so we must flush /* We don't log clip stack changes in the journal so we must flush
* it before making modifications */ * it before making modifications */
_cogl_journal_flush (); _cogl_journal_flush ();
stack = clip_state->stacks->data; clip_state->stacks->data = _cogl_clip_stack_pop (clip_state->stacks->data);
_cogl_clip_stack_pop (stack);
clip_state->stack_dirty = TRUE; clip_state->stack_dirty = TRUE;
} }
@ -243,7 +235,7 @@ cogl_clip_pop (void)
void void
_cogl_clip_state_flush (CoglClipState *clip_state) _cogl_clip_state_flush (CoglClipState *clip_state)
{ {
CoglHandle stack; CoglClipStack *stack;
if (!clip_state->stack_dirty) if (!clip_state->stack_dirty)
return; return;
@ -277,15 +269,11 @@ cogl_clip_ensure (void)
static void static void
_cogl_clip_stack_save_real (CoglClipState *clip_state) _cogl_clip_stack_save_real (CoglClipState *clip_state)
{ {
CoglHandle stack;
/* We don't log clip stack changes in the journal so we must flush /* We don't log clip stack changes in the journal so we must flush
* it before making modifications */ * it before making modifications */
_cogl_journal_flush (); _cogl_journal_flush ();
stack = _cogl_clip_stack_new (); clip_state->stacks = g_slist_prepend (clip_state->stacks, NULL);
clip_state->stacks = g_slist_prepend (clip_state->stacks, stack);
clip_state->stack_dirty = TRUE; clip_state->stack_dirty = TRUE;
} }
@ -316,7 +304,7 @@ _cogl_clip_stack_restore_real (CoglClipState *clip_state)
stack = clip_state->stacks->data; stack = clip_state->stacks->data;
cogl_handle_unref (stack); _cogl_clip_stack_unref (stack);
/* Revert to an old stack */ /* Revert to an old stack */
clip_state->stacks = g_slist_delete_link (clip_state->stacks, clip_state->stacks = g_slist_delete_link (clip_state->stacks,
@ -365,7 +353,7 @@ _cogl_clip_state_dirty (CoglClipState *clip_state)
clip_state->stack_dirty = TRUE; clip_state->stack_dirty = TRUE;
} }
CoglHandle CoglClipStack *
_cogl_get_clip_stack (void) _cogl_get_clip_stack (void)
{ {
CoglFramebuffer *framebuffer; CoglFramebuffer *framebuffer;
@ -380,21 +368,18 @@ _cogl_get_clip_stack (void)
} }
void void
_cogl_set_clip_stack (CoglHandle handle) _cogl_set_clip_stack (CoglClipStack *stack)
{ {
CoglFramebuffer *framebuffer; CoglFramebuffer *framebuffer;
CoglClipState *clip_state; CoglClipState *clip_state;
_COGL_GET_CONTEXT (ctx, NO_RETVAL); _COGL_GET_CONTEXT (ctx, NO_RETVAL);
if (handle == COGL_INVALID_HANDLE)
return;
framebuffer = _cogl_get_framebuffer (); framebuffer = _cogl_get_framebuffer ();
clip_state = _cogl_framebuffer_get_clip_state (framebuffer); clip_state = _cogl_framebuffer_get_clip_state (framebuffer);
/* Replace the top of the stack of stacks */ /* Replace the top of the stack of stacks */
cogl_handle_ref (handle); _cogl_clip_stack_ref (stack);
cogl_handle_unref (clip_state->stacks->data); _cogl_clip_stack_unref (clip_state->stacks->data);
clip_state->stacks->data = handle; clip_state->stacks->data = stack;
} }

20
cogl/cogl-clip-state.h
View file

@ -47,32 +47,26 @@ _cogl_clip_state_dirty (CoglClipState *state);
void void
_cogl_clip_state_flush (CoglClipState *clip_state); _cogl_clip_state_flush (CoglClipState *clip_state);
/* TODO: we may want to make these two functions public because they
* can be used to implement a better API than cogl_clip_stack_save()
* and cogl_clip_stack_restore().
*/
/* /*
* _cogl_get_clip_stack: * _cogl_get_clip_stack:
* *
* Gets a handle to the current clip stack. This can be used to later * Gets a pointer to the current clip stack. This can be used to later
* return to the same clip stack state with _cogl_set_clip_stack(). A * return to the same clip stack state with _cogl_set_clip_stack(). A
* reference is not taken on the stack so if you want to keep it you * reference is not taken on the stack so if you want to keep it you
* should call cogl_handle_ref() or _cogl_clip_stack_copy(). * should call _cogl_clip_stack_ref().
* *
* Return value: a handle to the current clip stack. * Return value: a pointer to the current clip stack.
*/ */
CoglHandle CoglClipStack *
_cogl_get_clip_stack (void); _cogl_get_clip_stack (void);
/* /*
* _cogl_set_clip_stack: * _cogl_set_clip_stack:
* @handle: a handle to the replacement clip stack * @stack: a pointer to the replacement clip stack
* *
* Replaces the current clip stack with @handle. * Replaces the current clip stack with @stack.
*
* Return value: a handle to the current clip stack.
*/ */
void void
_cogl_set_clip_stack (CoglHandle handle); _cogl_set_clip_stack (CoglClipStack *stack);
#endif /* __COGL_CLIP_STATE_H */ #endif /* __COGL_CLIP_STATE_H */