cliprect.h File Reference

Rectangle clipping/dirty list. More...

#include "rect.h"

Include dependency graph for cliprect.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	ClipRect
	Accumulate dirty rectangles or do window clipping Provides an instruction set for rendering/blitting dirty rectangle regions and skipping over rectangular window contents. More...
Defines
#define	ClipRect_foreach(instance, iterator)   pointer_foreach_const( Rect, (instance)->dirty, (instance)->cDirty, iterator )
	Iterate cliprects.
#define	ClipRect_foreach_mutable(instance, iterator)
	Iterate cliprects; count can change while we do it.
Functions
void	ClipRect_init (ClipRect *self, Rect *dirty, size_t cDirty, const Rect *bounds)
	Initialize a dirty clipping list.
void	ClipRect_add (ClipRect *self, const Rect *r)
	Add a dirty rectangle to dirty list Overlapped and redundant rectangles are merged. If list is filled, merges all rectangles to make more room.
void	ClipRect_remove (ClipRect *self, const Rect *r)
	Remove a rectangle from dirty list to reserve a window.
Rect	ClipRect_union (const ClipRect *self)
	Get union of all rectangles.
void	ClipRect_merge (ClipRect *self, const ClipRect *other)
	Add all the clipped quantities from another ClipRect to this one.
void	ClipRect_copy (ClipRect *self, const ClipRect *other)
	Copy all the clipped quantities from another ClipRect to this one.

---

Detailed Description

Rectangle clipping/dirty list.

Author:

David Mace

Definition in file cliprect.h.

---

Define Documentation

#define ClipRect_foreach	(	instance,
		iterator		)	pointer_foreach_const( Rect, (instance)->dirty, (instance)->cDirty, iterator )

Iterate cliprects.

Parameters:

	instance	Instance of ClipRect we're initializing
	iterator	Name of variable to iterate with

Definition at line 49 of file cliprect.h.

#define ClipRect_foreach_mutable	(	instance,
		iterator		)

Value:

Rect* iterator = (instance)->dirty;\
    size_t iterator##_curr;\
    for( iterator##_curr = 0; iterator##_curr < (instance)->cDirty; ++iterator##_curr, ++iterator )

Iterate cliprects; count can change while we do it.

Parameters:

	instance	Instance of ClipRect we're initializing
	iterator	Name of variable to iterate with

Definition at line 57 of file cliprect.h.

---

Function Documentation

void ClipRect_add	(	ClipRect *	self,
		const Rect *	rect
	)

Add a dirty rectangle to dirty list Overlapped and redundant rectangles are merged. If list is filled, merges all rectangles to make more room.

Parameters:

	self	Pointer to clip accumulator
	rect	New rectangle to add

Definition at line 34 of file cliprect.c.

References ClipRect_add(), RectContainsRect, RectEmpty, RectInRect, RectIntRect, and RectUnionRect.

Referenced by _GUI_Dirty_Rect(), ClipRect_add(), and ClipRect_merge().

{
    Rect newRect = *rect;
    RectIntRect( newRect, self->bounds );
    if( !RectEmpty(newRect) )
    {
        Rect* curr = self->dirty;
        Rect* end = self->dirty + self->cDirty;
        while( curr < end )
        {
            /* Look for rectangles already containing newRect */
            if( RectContainsRect( *curr, newRect ) )
                return;
            /* Look for rectangles to combine with newRect */
            if( RectInRect(*curr, newRect) )
            {
                if( self->cDirty > 1 )
                {
                    RectUnionRect( newRect, *curr );
                    self->cDirty--;
                    if( --end > curr )
                        *curr = *end;
                    curr = self->dirty;
                }
                else
                {
                    RectUnionRect( *self->dirty, newRect );
                    return;
                }
                continue;
            }
            curr++;
        }
        if( self->cDirty < self->maxDirty )
        {
            /* Add new rectangle */
            self->dirty[self->cDirty++] = newRect;
        }
        else
        {
            /* If we run out of clipping rectangles, eat the last and try again */
            --self->cDirty;
            RectUnionRect( newRect, self->dirty[self->cDirty] );
            ClipRect_add( self, &newRect );
        }
    }
}

Here is the call graph for this function:

void ClipRect_copy	(	ClipRect *	self,
		const ClipRect *	other
	)

Copy all the clipped quantities from another ClipRect to this one.

Parameters:

	self	Pointer to clip accumulator
	other	ClipRect to collect rectangles from

Definition at line 267 of file cliprect.c.

References ClipRect::cDirty, ClipRect_merge(), and ClipRect::dirty.

{
    if( other->cDirty <= self->maxDirty )
    {
        memcpy( self->dirty, other->dirty, sizeof(Rect)*other->cDirty );
        self->cDirty = other->cDirty;
    }
    else
    {
        self->cDirty = 0;
        ClipRect_merge( self, other );
    }
}

Here is the call graph for this function:

void ClipRect_init	(	ClipRect *	self,
		Rect *	dirty,
		size_t	cDirty,
		const Rect *	bounds
	)

Initialize a dirty clipping list.

Parameters:

	self	Instance of list to initialize
	dirty	An array of Rects for it to manage
	cDirty	Count of Rects in dirty.
	bounds	Bounding box for accumulation

Definition at line 19 of file cliprect.c.

{
    self->cDirty = 0;
    self->dirty = dirty;
    self->maxDirty = cDirty;
    self->bounds = *bounds;
}

void ClipRect_merge	(	ClipRect *	self,
		const ClipRect *	other
	)

Add all the clipped quantities from another ClipRect to this one.

Parameters:

	self	Pointer to clip accumulator
	other	ClipRect to collect rectangles from

Definition at line 256 of file cliprect.c.

References ClipRect::cDirty, ClipRect_add(), ClipRect::dirty, and pointer_foreach_const.

Referenced by ClipRect_copy().

{
    pointer_foreach_const( Rect, other->dirty, other->cDirty, curr )
        ClipRect_add( self, curr );
}

Here is the call graph for this function:

void ClipRect_remove	(	ClipRect *	self,
		const Rect *	rect
	)

Remove a rectangle from dirty list to reserve a window.

Parameters:

	self	Pointer to clip accumulator
	rect	rectangle to remove (deliberately passed by value) Useful *after* ClipRect_add functions are finished at a given stage of rendering ClipRect_add_nomerge is safe to use with this. Generally, if you use this, use more rectangles than you otherwise would.

Definition at line 90 of file cliprect.c.

References Rect::bottom, Rect::left, RectContainsRect, RectOutside, RectPtInRect, Rect::right, and Rect::top.

{
    /* Local function: Add a rectangle to 'self' */\
#define ClipRect_remove_AddRect( l,t,r,b )\
    if( self->cDirty < self->maxDirty ) \
    {\
        Rect* nr = self->dirty + self->cDirty++;\
        nr->left = (l); \
        nr->top = (t); \
        nr->right = (r); \
        nr->bottom = (b); \
    }\
    else\
    {\
        /* Running out of our fixed pool of rectangles is definitely an error */\
        throwassert( "Ran out of dirty rectangles." );\
        break;\
    }
    Rect* curr = self->dirty;
    Rect* end = self->dirty + self->cDirty;
    while( curr < end )
    {
        /* If rects don't touch, don't touch them */
        if( RectOutside( *rect, *curr ) )
        {
            curr++;
            continue;
        }
        /* If rect contains curr, eat curr */
        else if( RectContainsRect( *rect, *curr ) )
        {
            *curr = *--end;
            continue;
        }
        /* If curr contains rect, pop a hole in the middle */
        else if( RectContainsRect( *curr, *rect ) )
        {
            ClipRect_remove_AddRect( curr->left,curr->top,curr->right,rect->top );  /* Top box */
            ClipRect_remove_AddRect( curr->left,rect->top,rect->left,rect->bottom );    /* Left box */
            ClipRect_remove_AddRect( rect->right,rect->top,curr->right,rect->bottom );  /* Right box */
            curr->top = rect->bottom; /* Bottom box */
        }
        /* Check for simple clip off the left or right */
        else if( (curr->top >= rect->top) && (curr->bottom <= rect->bottom) ) 
        {
            if( curr->left >= rect->left )
            {
                curr->left = rect->right;
            }
            else 
            {
                /* Check bisecting, make rects left & right, as applicable */
                if( curr->right <= rect->right )
                {
                    curr->right = rect->left;
                }
                else 
                {
                    ClipRect_remove_AddRect( curr->left,curr->top,rect->left,curr->bottom );
                    curr->left = rect->right;
                }
            }
        }
        /* Check for simple clip off the top or bottom */
        else if( (curr->left >= rect->left) && (curr->right <= rect->right) ) 
        {
            if(curr->top >= rect->top)
            {
                curr->top = rect->bottom;
            }
            else 
            {
                /* Check bisecting, make rects above & below, as applicable */
                if(curr->bottom <= rect->bottom)
                {
                    curr->bottom = rect->top;
                }
                else 
                {
                    ClipRect_remove_AddRect( curr->left,curr->top,curr->right,rect->top);
                    curr->top = rect->bottom;
                }
            }
        }
        /* See if we need to make an 'L', left and above */
        else if( RectPtInRect(*rect, curr->right-1, curr->bottom-1 ) )
        {
            ClipRect_remove_AddRect( curr->left, rect->top, rect->left, curr->bottom );
            curr->bottom = rect->top;
        }
        /* See if we need to make an 'L', right and above */
        else if( RectPtInRect(*rect, curr->left, curr->bottom-1 ) )
        {
            ClipRect_remove_AddRect( rect->right, rect->top, curr->right, curr->bottom );
            curr->bottom = rect->top;
        }
        /* See if we need to make an 'L', left and below */
        else if( RectPtInRect(*rect, curr->right-1, curr->top ) )
        {
            ClipRect_remove_AddRect( curr->left, curr->top, rect->left, rect->bottom );
            curr->top = rect->bottom;
        }
        /* See if we need to make an 'L', right and below */
        else if( RectPtInRect(*rect, curr->left, curr->top ) )
        {
            ClipRect_remove_AddRect( rect->right, curr->top, curr->right, rect->bottom );
            curr->top = rect->bottom;
        }
        /* 
         * We now know the clipping rectangle is making a 'U' shape
         * Just work out which edge to lop clipping box out of
         */
        /* Make a 'C' out of three rectangles */
        else if( curr->right >= rect->left && curr->right <= rect->right) 
        {
            ClipRect_remove_AddRect(curr->left, curr->top, curr->right, rect->top);     /* Top of C */
            ClipRect_remove_AddRect(curr->left, rect->top, rect->left, rect->bottom);       /* Left edge of C */
            curr->top = rect->bottom;                                   /* Bottom of C */
        }
        /* Make a 'U' out of three rectangles */
        else if( curr->top >= rect->top && curr->top <= rect->bottom) 
        {
            ClipRect_remove_AddRect(curr->left, curr->top, rect->left, rect->bottom);       /* Left edge of U */
            ClipRect_remove_AddRect(rect->right, curr->top, curr->right, rect->bottom); /* Right edge of U */
            curr->top = rect->bottom;                                   /* Bottom edge of U */
        }
        /* Make an upside-down 'U' out of three rectangles */
        else if( curr->bottom >= rect->top && curr->bottom <= rect->bottom )
        {
            ClipRect_remove_AddRect(curr->left, rect->top, rect->left, curr->bottom);       /* Left edge of U */
            ClipRect_remove_AddRect(rect->right, rect->top, curr->right, curr->bottom); /* Right edge of U */
            curr->bottom = rect->top;                                   /* Top edge of U */
        }
        /* Make a backwards 'C' out of three rectangles */
        else if( curr->left >= rect->left && curr->left <= rect->right ) 
        {
            ClipRect_remove_AddRect(curr->left, curr->top, curr->right, rect->top );        /* Top of C */
            ClipRect_remove_AddRect(rect->right, rect->top, curr->right, rect->bottom); /* Right edge of C */
            curr->top = rect->bottom;                                   /* Bottom edge of C */
        }
        curr++;
    }
#undef ClipRect_remove_AddRect
}

Rect ClipRect_union

(

const ClipRect *

self

)

Get union of all rectangles.

Parameters:

self

Pointer to clip accumulator

Returns:

Rectangle union of all rectangles

Definition at line 240 of file cliprect.c.

References pointer_foreach_const, RectClear, and RectUnionRect.

{
    Rect ret;
    RectClear(ret);
    {
        pointer_foreach_const( Rect, self->dirty, self->cDirty, curr )
            RectUnionRect( ret, *curr );
    }
    return ret;
}