cliprect.c

Go to the documentation of this file.

#include <stdlib.h>
#include <string.h>
#include "../ctl/ctldef.h"
#include "cliprect.h"

void ClipRect_init( ClipRect* self, Rect* dirty, size_t cDirty, const Rect* bounds )
{
    self->cDirty = 0;
    self->dirty = dirty;
    self->maxDirty = cDirty;
    self->bounds = *bounds;
}

void ClipRect_add( ClipRect* self, const Rect* rect )
{
    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 );
        }
    }
}

void ClipRect_remove( ClipRect* self, const Rect* rect )
{
    /* 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 )
{
    Rect ret;
    RectClear(ret);
    {
        pointer_foreach_const( Rect, self->dirty, self->cDirty, curr )
            RectUnionRect( ret, *curr );
    }
    return ret;
}

void ClipRect_merge( ClipRect* self, const ClipRect* other )
{
    pointer_foreach_const( Rect, other->dirty, other->cDirty, curr )
        ClipRect_add( self, curr );
}

void ClipRect_copy( ClipRect* self, const ClipRect* other )
{
    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 );
    }
}