render.c

Go to the documentation of this file.

#include "render.h"
#include <string.h>
#include <stdlib.h>
#include <assert.h>

// An early test of the restrict keyword that doesn't compile on MSVC v7.1.
// Tried to make it conditional based on the version, but the preprocessor
// acted like (1300 > 1300) should evaluate to true.
#if !defined(_MSC_VER) && !defined(DOXYGEN)
#define _restrict_  __restrict
#else
#define _restrict_  
#endif

// externally accesible global data
struct DisplayInfo_t  dInfo;
Layer layers[MAX_LAYERS];

static struct UpdateList_t {
    SDL_Rect *rects[BACK_STATES];
    Uint32    area[BACK_STATES];
    Uint16    numRects[BACK_STATES];
    Uint16    length;
    Sint8 dirty;
    Uint8     currState;
    Uint8     nextState;
    Uint8     totalStates;
    Bool renderAll;
} updateList;

Bool RenderInit(Uint16 numRects, Uint8 numStates) {
    // debug check for bad input
    assert((numRects > 0) && (numStates > 0) && (numStates <= BACK_STATES));
    // runtime check for bad input
    if ((numRects == 0) || (numStates == 0) || (numStates > BACK_STATES)) {
        // the renderer cannot initalize to the requested setup without causing
        // a segfault
        return FALSE;
    }
    // clear out the update list
    memset(&updateList, 0, sizeof(updateList));
    // clear out the contents of all the layers
    memset(layers, 0 , sizeof(layers));
    // store the number of states
    updateList.dirty = updateList.totalStates = numStates;
    updateList.nextState = 1;
    // force everything to be drawn for the next frame; skip all that logic
    // to draw just what changed for the first frame.
    updateList.renderAll = TRUE;
    // allocate space for the update lists
    do {
        // adjust state counter
        numStates--;
        // allocate memory
        if ((updateList.rects[numStates] = malloc(sizeof(SDL_Rect) * numRects))
        == NULL) {
            // allocation failed
            return FALSE;
        }
    } while (numStates > 0);
    // success!
    return TRUE;
}

void RenderClearStates(Uint8 numStates) {
    assert(FALSE);
}

void RenderUninit() {
    // loop through all the supported states
    do {
        // adjust the value to be the next/valid index
        updateList.totalStates--;
        // deallocate the rectangle list for this state
        free(updateList.rects[updateList.totalStates]);
        // no rects in it now
        updateList.numRects[updateList.totalStates] = 0;
    } while (updateList.totalStates > 0);
    // no rects in any list
    updateList.length = 0;
}

void ForceRenderAll() {
    updateList.renderAll = TRUE;
    updateList.dirty = updateList.totalStates;
}

Bool RenderWillRenderAll() {
    return updateList.renderAll;
}

void ForceDirtyFrame() {
    updateList.dirty = updateList.totalStates;
}

void AddRenderItem(RenderItem *item, int layer) {
    assert((layer >= 0) && (layer < MAX_LAYERS));
    assert(item->parent == NULL);
    assert(item->renderer != NULL);
    // check for an empty world list
    if (layers[layer].worldListLast == NULL) {
        // the wold list is empty, so add the new item as the first
        layers[layer].worldListLast = layers[layer].worldListFirst = item;
        // fix up the item's list pointers
        item->next = item->prev = NULL;
    }
    else {
        // set the mext & last list pointers of the new item
        item->next = NULL;
        item->prev = layers[layer].worldListLast;
        // fix the previous last item's next pointer
        layers[layer].worldListLast->next = item;
        // add the item to the end of the list
        layers[layer].worldListLast = item;
    }
    // set the item's parent pointer to the owning layer
    item->parent = &layers[layer];
    // prevent the item from being drawn
    item->enableDraw = FALSE;
    // initalize the source rect such that the whole item requires an update
    item->src.x = item->src.y = 0;
    item->src.w = item->loc.w;
    item->src.h = item->loc.h;
}

void RemoveRenderItem(RenderItem *item) {
    // check for first or only item in the list
    if (item->prev == NULL) {
        // replace the first item in the list with the second & check for
        // removing the last item
        if ((item->parent->worldListFirst = item->parent->worldListFirst->next)
        == NULL) {
            // clear the last item pointer
            item->parent->worldListLast = NULL;
        }
        else {
            // fix the previous pointer of the new first item
            item->parent->worldListFirst->prev = NULL;
        }
    }
    // check for last item in the list
    else if (item->next == NULL) {
        // replace the last item in the list with the one before the last and
        // fix the next pointer of the new last item
        (item->parent->worldListLast = item->parent->worldListLast->prev)->next
        = NULL;
    }
    // remove some item between the first and last in the list
    else {
        item->prev->next = item->next;
        item->next->prev = item->prev;
    }
    //#ifndef NDEBUG
    // clear the item's pointers
    item->parent = (Layer*)(item->next = item->prev = (RenderItem*)NULL);
    //#endif
}

static void AddToUpdateLists(RenderItem * _restrict_ item,
SDL_Rect * _restrict_ rect) {
    int loop,     // loop counter
    state,        // update list state value; different than index
    stateInd,     // update list state index; 0 is the next state index to draw
    delta,        // used in collision detect & overlap code 
    area,         // temp area
    overlapArea,  // area of the overlap of two rects
    proposedArea, // area of the least enlarged rect in the update list
    proposedIndex = -1; // the index of the least enlarged rect
    SDL_Rect * _restrict_ updateRect, overlap, proposed;
    // loop through all the update lists for each display state
    #if (BACK_STATES > 2)
    #error This loop will fail with more than two display states
    #endif
    for (stateInd = 0, state = updateList.currState;
    stateInd < updateList.totalStates;
    stateInd++, state = *(((Uint8*)&(updateList.currState)) + stateInd)) {
        // find the first rectangle in the update list
        updateRect = updateList.rects[state];
        // check for collisions with rects already in the update list
        for (loop = 0; loop < updateList.numRects[state];
        loop++, updateRect++) {
            // -----------------------------------------------------------------
            // Check for a collision & find overlap.
            // find the delta between the Y coords and see if updateRect is lower
            if ((delta = updateRect->y - rect->y) > 0) {
                // check for no vertical overlap and set overlap height
                if ((delta > rect->h) || !(overlap.h =
                (rect->h - delta) > updateRect->h ? updateRect->h :
                rect->h - delta))
                    continue;
                // set y starting position
                overlap.y = updateRect->y;
            }
            else {
                // check for no vertical overlap (rect is lower) and set height
                if ((-delta > updateRect->h) || !(overlap.h =
                (updateRect->h + delta) > rect->h ? rect->h :
                updateRect->h + delta))
                    continue;
                // set y starting position
                overlap.y = rect->y;
            }
            // see if rect is further left
            if ((delta = updateRect->x - rect->x) > 0) {
                // check for no horizontal overlap and set overlap width
                if ((delta > rect->w) || !(overlap.w =
                (rect->w - delta) > updateRect->w ? updateRect->w :
                rect->w - delta))
                    continue;
                // set x starting position
                overlap.x = updateRect->x;
            }
            else {
                // check for no horizontal overlap and set overlap width
                if ((-delta > updateRect->w) || !(overlap.w =
                (updateRect->w + delta) > rect->w ? rect->w :
                updateRect->w + delta))
                    continue;
                // set x starting position
                overlap.x = rect->x;
            }
            // -----------------------------------------------------------------
            // if contained entirely, use this rect
            if ((overlap.x == rect->x) && (overlap.y == rect->y) &&
                (overlap.w == rect->w) && (overlap.h == rect->h)) {
                // use this rect
                item->rectIndex[stateInd] = loop;
                // quit searching
                goto AddToUpdateLists_nextState;
            }
            // compute the area of the overlap
            overlapArea = overlap.h * overlap.w;
            // find the smallest rect that includes both the one in the update
            // list and the region that this item needs to updae
            if (rect->x < updateRect->x) { // x coordinate
                overlap.x = rect->x;
            }
            else {
                overlap.x = updateRect->x;
            }
            if ((rect->x + rect->w) >  // width
            (updateRect->x + updateRect->w)) {
                overlap.w = rect->x + rect->w - overlap.x;
            }
            else {
                overlap.w = updateRect->x + updateRect->w - overlap.x;
            }
            if (rect->y < updateRect->y) { // y coordinate
                overlap.y = rect->y;
            }
            else {
                overlap.y = updateRect->y;
            }
            if ((rect->y + rect->h) >  // height
            (updateRect->y + updateRect->h)) {
                overlap.h = rect->y + rect->h - overlap.y;
            }
            else {
                overlap.h = updateRect->y + updateRect->h - overlap.y;
            }
            // if overlap area is greater than growing this update rect . . .
            if ((overlapArea > (area = overlap.w * overlap.h - overlapArea)) &&
                // previous found? Compare with this one
                (((proposedIndex > -1) && (proposedArea > area)) || 
                (proposedIndex == -1 ))) {
                    // remember this one and continue
                    proposedIndex = loop;
                    proposedArea = area;
                    proposed = overlap;
            }
        }
        // if too small overlap found or no collision . . .
        if (proposedIndex == -1) {
            // add a new rect to the update list
            *updateRect = *rect;     // updateRect already advanced to the
                                     // next rect
            item->rectIndex[stateInd] = updateList.numRects[state]++;
        }
        else {
            // store the index of the rect to use and enlarge
            item->rectIndex[stateInd] = proposedIndex;
            // modify the rect
            updateList.rects[state][proposedIndex] = proposed;
        }
        AddToUpdateLists_nextState: ;
        // The above label exists to break out of the inner for loop and
        // continue in the outer loop, skipping the above if-else statement.
        // It just speeds things up without the extra if check that would be
        // needed without a goto.
    }
}

void PlaceRenderItem(RenderItem * _restrict_ item) {
    SDL_Rect * _restrict_ prev;
    int loop;
    // flag the item as placed
    item->placed = item->enableDraw = TRUE;
    // compute the physical location of the portion of the item that needs to
    // be updated
    item->physLocX = item->loc.x + item->parent->offX;
    item->physLocY = item->loc.y + item->parent->offY;
    // see if the item's location is not in the viewable area
    if ((item->physLocX <= -item->loc.w) || (item->physLocX >= dInfo.pw)
    || (item->physLocY <= -item->loc.h) || (item->physLocY >= dInfo.ph)) {
        // mark the item as not visible
        item->visible = FALSE;
        // may have to update the old location if not everything is being drawn
        if (!updateList.renderAll) {
            // add the old location to the update list if it was visible
            #if (BACK_STATES > 2)
            #error This will fail with more than two display states
            #endif
            // loop from the last state
            for (prev = &(item->prevStates[updateList.totalStates - 1]),
            loop = updateList.totalStates; loop > 0; prev--, loop--) {
                // check for invisibility
                if ((prev->w == 0) || (prev->h == 0))
                    // no need to update something that isn't on the display
                    continue;
                // redraw the location where the item was last seen
                AddToUpdateLists(item, prev);
                // flag the owning layer as dirty
                item->parent->dirty = TRUE;
                // flag the screen as dirty
                updateList.dirty = updateList.totalStates;
            }
        }
        // all done!
        return;
    }
    // check for a request/need to draw everything
    if (updateList.renderAll) {
        // all done!
        return;
    }
    // check for bad width
    if (item->src.w == 0) {
        assert(item->loc.w > item->src.x);
        // set the width
        item->src.w = item->loc.w - item->src.x;
    }
    // check for bad height
    if (item->src.h == 0) {
        assert(item->loc.h > item->src.y);
        // set the width
        item->src.h = item->loc.h - item->src.y;
    }
    // compute the physical destination for the region marked as dirty
    item->physDest.x = item->physLocX + item->src.x;
    item->physDest.w = item->src.w;
    item->physDest.y = item->physLocY + item->src.y;
    item->physDest.h = item->src.h;
    // clip the physical destination to the display
    ClipRectToWH(&(item->physDest), dInfo.pw, dInfo.ph);
    // set the new source rect that accounts for clipping
    item->src.x = item->physDest.x - item->physLocX;
    item->src.y = item->physDest.y - item->physLocY;
    item->src.w = item->physDest.w;
    item->src.h = item->physDest.h;
    // check for an item with nothing to draw
    if ((item->physDest.w == 0) || (item->physDest.h == 0)) {
        // all done!
        return;
    }
    // this item may need to be drawn, so set the dirty flag
    item->dirty = TRUE;
    // the item is visible, so set that flag, too
    item->visible = TRUE;
    // flag the owning layer as dirty
    item->parent->dirty = TRUE;
    // flag the screen as dirty
    updateList.dirty = updateList.totalStates;
    // add the old location to the update list if it was visible
    #if (BACK_STATES > 2)
    #error This will fail with more than two display states
    #endif
    // loop from the last state to the current (physDest) state
    for (prev = &(item->prevStates[updateList.totalStates - 1]),
    loop = updateList.totalStates + 1; loop > 0; prev--, loop--) {
        // check for invisibility
        if ((prev->w == 0) || (prev->h == 0))
            // no need to update something that isn't on the display
            continue;
        // update the rect
        AddToUpdateLists(item, prev);
    }
    // add the new location to the update list
    //AddToUpdateLists(item, &(item->physDest));
}

void ClearRenderItem(RenderItem *item) {
    int loop, state;
    // flag the item as not visible
    item->dirty = item->visible = item->enableDraw = FALSE;
    // see if the item's location is not in the viewable area
    if ((item->physDest.x <= -item->loc.w) || (item->physDest.x >= dInfo.pw)
    || (item->physDest.y <= -item->loc.h) || (item->physDest.y >= dInfo.ph)) {
        // all done!
        return;
    }
    // flag the screen as dirty
    updateList.dirty = updateList.totalStates;
    // loop through the previous states
    #if (BACK_STATES > 2)
    #error This loop will fail with more than two display states
    #endif
    for (loop = 0, state = updateList.currState; loop < updateList.totalStates;
    loop++, state = *(((Uint8*)&(updateList.currState)) + loop)) {
        // check for visibility in a previous state
        if (item->prevStates[loop].w > 0) {
            // add this rect to the list
            updateList.rects[state][updateList.numRects[state]++] =
            item->prevStates[updateList.totalStates - loop - 1];
            // adding without checking what is already in the update list
            // can cause an inefficent draw, but so can spending time
            // figuring out the overlaps, and I'm finised worrying about it.
        }
    }
}

void SetLayerOffset(Layer * _restrict_ layer, Sint16 x, Sint16 y) {
    RenderItem * _restrict_ item;
    // first, record the new offsets
    layer->offX = x;
    layer->offY = y;
    // No need to set dirty flags -- that will happen as items are placed.
    // Loop through the layer's items
    for (item = layer->worldListFirst; item != NULL; item = item->next) {
        // check for a drawable item
        if (item->enableDraw) {
            // place the item
            PlaceRenderItem(item);
        }
    }
}

static Bool FindNextCollision(RenderItem * _restrict_ item) {
    int loop, delta;
    SDL_Rect * _restrict_ rect;
    // loop through the remaining rects in the update list
    for (rect = &(updateList.rects[updateList.currState][(loop = item->rectIndex[0] + 1)]);
    loop < updateList.numRects[updateList.currState]; loop++, rect++) {
        // Check for a collision while computing the overlap.
        // find the delta between the Y coords and see if rect is lower
        if ((delta = rect->y - item->physLocY) > 0) {
            // check for no vertical overlap and set the overlap height
            if ((delta > item->loc.h) || !(item->physDest.h =
            (item->loc.h - delta) > rect->h ? rect->h :
            item->loc.h - delta))
                continue;
            // set y starting position
            item->physDest.y = rect->y;
        }
        else {
            // check for no vertical overlap (rect is higher) and set height
            if ((-delta > rect->h) || !(item->physDest.h =
            (rect->h + delta) > item->loc.h ? item->loc.h :
            rect->h + delta))
                continue;
            // set y starting position
            item->physDest.y = item->physLocY;
        }
        // see if rect is further right
        if ((delta = rect->x - item->physLocX) > 0) {
            // check for no horizontal overlap and set overlap width
            if ((delta > item->loc.w) || !(item->physDest.w =
            (item->loc.w - delta) > rect->w ? rect->w :
            item->loc.w - delta))
                continue;
            // set x starting position
            item->physDest.x = rect->x;
        }
        else {
            // check for no horizontal overlap and set overlap width
            if ((-delta > rect->w) || !(item->physDest.w =
            (rect->w + delta) > item->loc.w ? item->loc.w :
            rect->w + delta))
                continue;
            // set x starting position
            item->physDest.x = item->physLocX;
        }
        // Collision!
        // set the rectangle index for future reference
        item->rectIndex[0] = loop;
        // set the source rect
        item->src.x = item->physDest.x - item->physLocX;
        item->src.y = item->physDest.y - item->physLocY;
        item->src.w = item->physDest.w;
        item->src.h = item->physDest.h;
        return TRUE;
    }
    // no collision
    return FALSE;
}

void Render() {
    RenderItem * _restrict_ item;  // first test of restrict keyword
    Layer * _restrict_ layer;
    int loop, state;
    SDL_Rect * _restrict_ rect;
    if (updateList.renderAll) {
        // render everything
        // First, loop through the layers.
        for (layer = layers, loop = MAX_LAYERS; loop > 0; layer++, loop--) {
            // Iterate through all items within the layer.
            for (item = layer->worldListFirst; item != NULL; item = item->next) {
                // see if this item should not be drawn
                if (!item->enableDraw) continue;
                // compute the physical position
                item->physDest.x = item->physLocX = item->loc.x + layer->offX;
                item->physDest.y = item->physLocY = item->loc.y + layer->offY;
                item->physDest.w = item->loc.w;
                item->physDest.h = item->loc.h;
                // clip to the display region
                ClipRectToWH(&(item->physDest), dInfo.pw, dInfo.ph);
                // check for an invisible item
                if ((item->physDest.w == 0) || (item->physDest.h == 0)) {
                    // shortened state update for invisible items
                    for (state = updateList.totalStates - 1; state > 0; state--) {
                        // copy one state
                        item->prevStates[state] = item->prevStates[state - 1];
                    }
                    // Next, set a new state indicating the item was not drawn
                    // region of the item, not just what was redrawn.
                    item->prevStates[0].w = item->prevStates[0].h = 0;
                    // reset flags
                    item->dirty = item->visible = item->placed = FALSE;
                    // done!
                    continue;
                }
                // set the new source rect
                item->src.x = item->physDest.x - item->physLocX;
                item->src.y = item->physDest.y - item->physLocY;
                item->src.w = item->physDest.w;
                item->src.h = item->physDest.h;
                // render the item 
                (*(item->renderer))(dInfo.display, item);
                #ifdef RENDER_INDIVIDUAL_UPDATES
                SDL_UpdateRect(dInfo.display, item->physDest.x,
                item->physDest.y, item->physDest.w, item->physDest.h);
                #endif
                // Update the previous states.
                // First, move the old states to make room for the new one
                for (state = updateList.totalStates - 1; state > 0; state--) {
                    // copy one state
                    item->prevStates[state] = item->prevStates[state - 1];
                }
                // Next, add in the new state. Must include the entire region of
                // the item, not just what was redrawn.
                item->prevStates[0].x = item->physLocX;
                item->prevStates[0].y = item->physLocY;
                item->prevStates[0].w = item->loc.w;
                item->prevStates[0].h = item->loc.h;
                // clip to the display region
                ClipRectToWH(&(item->prevStates[0]), dInfo.pw, dInfo.ph);
                // Reset flags.
                item->dirty = item->visible = item->placed = FALSE;
            }
            // clear the layer's flags
            layer->flags = 0;
        }
        #ifndef RENDER_INDIVIDUAL_UPDATES
        // update the screen
        SDL_UpdateRect(dInfo.display, 0, 0, 0, 0);
        #endif
    }
    else if (updateList.dirty) {
        // First, loop through the layers.
        for (layer = layers, loop = MAX_LAYERS; loop > 0; layer++, loop--) {
            // Make the render list.
            // Iterate through all items within the layer.
            for (item = layer->worldListFirst; item != NULL; item = item->next) {
                // see if this item is already flagged as dirty
                if (item->dirty) {
                    // Update the source and dest rects to reflect any
                    // enlargement of the update region that may have occured.
                    // First, get a reference to the item's update rect.
                    rect = &(updateList.rects[updateList.currState][item->rectIndex[0]]);
                    // see if the item does not use all the space
                    if ((item->physDest.w < rect->w) ||
                    (item->physDest.h < rect->h)) {
                        // set the dest to be the entire item
                        item->physDest.x = item->physLocX;
                        item->physDest.y = item->physLocY;
                        item->physDest.w = item->loc.w;
                        item->physDest.h = item->loc.h;
                        // clip the dest to the update rect
                        ClipRectToRect(&(item->physDest), rect);
                        // set the new source rect
                        item->src.x = item->physDest.x - item->physLocX;
                        item->src.y = item->physDest.y - item->physLocY;
                        item->src.w = item->physDest.w;
                        item->src.h = item->physDest.h;
                    }
                    // render it
                    (*(item->renderer))(dInfo.display, item);
                    #ifdef RENDER_INDIVIDUAL_UPDATES
                    SDL_UpdateRect(dInfo.display, item->physDest.x,
                    item->physDest.y, item->physDest.w, item->physDest.h);
                    #endif
                    // Update the previous states.
                    Render_updateStates:
                    // First, move the old states to make room for the new one
                    for (state = updateList.totalStates - 1; state > 0; state--) {
                        // copy one state
                        item->prevStates[state] = item->prevStates[state - 1];
                    }
                    // Next, add in the new state. Must include the entire
                    // region of the item, not just what was redrawn.
                    item->prevStates[0].x = item->physLocX;
                    item->prevStates[0].y = item->physLocY;
                    item->prevStates[0].w = item->loc.w;
                    item->prevStates[0].h = item->loc.h;
                    // clip to the display region
                    ClipRectToWH(&(item->prevStates[0]), dInfo.pw, dInfo.ph);
                }
                else if ((layer->dirty || !item->placed) && item->enableDraw) {
                    // Items that are not dirty may need to be partially drawn.
                    // Set the physical location of the item.
                    item->physLocX = item->loc.x + layer->offX;
                    item->physLocY = item->loc.y + layer->offY;
                    // check for visibility and set the flag accordingly
                    if ((item->physLocX <= -item->loc.w)
                    || (item->physLocX >= dInfo.pw)
                    || (item->physLocY <= -item->loc.h)
                    || (item->physLocY >= dInfo.ph)) {
                        // the item is not visible
                        item->visible = FALSE;
                        // update its state
                        goto Render_updateStatesInvis;
                    }
                    else {
                        // the item is visible
                        item->visible = TRUE;
                        // check for a collision with an update rect
                        item->rectIndex[0] = -1;
                        // loop through all collisions
                        while (FindNextCollision(item)) {
                            // render it
                            (*(item->renderer))(dInfo.display, item);
                            #ifdef RENDER_INDIVIDUAL_UPDATES
                            SDL_UpdateRect(dInfo.display, item->physDest.x,
                            item->physDest.y, item->physDest.w,
                            item->physDest.h);
                            #endif
                        }
                    }
                    // update the item's states
                    goto Render_updateStates;
                }
                else {
                    // shortened state update for invisible items
                    Render_updateStatesInvis:
                    for (state = updateList.totalStates - 1; state > 0; state--) {
                        // copy one state
                        item->prevStates[state] = item->prevStates[state - 1];
                    }
                    // Next, set a new state indicating the item was not drawn
                    // region of the item, not just what was redrawn.
                    item->prevStates[0].w = item->prevStates[0].h = 0;
                }
                // from here to the end of Render() the RenderItem_t::placed
                // flag is irrelavent and should be cleared for all items
                // Reset flags.
                item->dirty = item->visible = item->placed = FALSE;
                // clear region to update
                item->src.x = item->src.y = item->src.w = item->src.h = 0;
            }
            // clear the layer's flags
            layer->flags = 0;
        }
        // update the screen
        #ifndef RENDER_INDIVIDUAL_UPDATES
        SDL_UpdateRects(dInfo.display,
        updateList.numRects[updateList.currState],
        updateList.rects[updateList.currState]);
        #endif
    }
    // decrement the dirty count and check for a clean display
    if (--updateList.dirty <= 0) {
        // assure the dirty count does not go below zero
        updateList.dirty = 0;
        // no need to render anything more until change; clear the flag
        updateList.renderAll = FALSE;
    }
    // remove all rects for this state
    updateList.numRects[updateList.currState] = 0;
    // advance the display state indicators
    updateList.nextState = ((updateList.currState = (updateList.currState + 1)
    % updateList.totalStates) + 1) % updateList.totalStates;
    // show the new frame
    if (dInfo.display->flags & SDL_DOUBLEBUF) {
        SDL_Flip(dInfo.display);
    }
}

void GenericSurfaceRenderer(SDL_Surface *dest, RenderItem *item) {
    // Both src and physLoc in RenderItem must be clipped by the render system.
    // Call SDL_LowerBlit() in the generic renderer function to draw
    // an image; this will avoid the clipping done by SDL_UpperBlit() /
    // SDL_BlitSurface() and the time taken for clipping again.
    SDL_LowerBlit(item->data, &(item->src), dest, &(item->physDest));
}

void SolidFillRenderer(SDL_Surface *dest, RenderItem *item) {
    // render a rectangle
    SDL_FillRect(dest, &(item->physDest), *(Uint32*)item->data);
}

Uint32 videoFlags = 0;

#define rounddivup(n, d)  ((((n) % (d)) > 0) ? ((int)(n) / (d) + 1) : ((int)(n) / (d)))

Bool ResizeWindow(Uint16 w, Uint16 h) {
    if ((dInfo.display = SDL_SetVideoMode(w, h, 0, videoFlags)) == NULL) {
        //fprintf(stderr, "Resize failure from SDL\n");
        return FALSE;
    }
    dInfo.pw = w;
    dInfo.lw = rounddivup(dInfo.pw, dInfo.luw);
    dInfo.ph = h;
    dInfo.lh = rounddivup(dInfo.ph, dInfo.luh);
    ForceRenderAll();
    return TRUE;
}

---