/* Simple program:  Fill a colormap with gray and stripe it down the screen,

		    Then move an alpha valued sprite around the screen.

 */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <math.h>

#include "SDL.h"

#define FRAME_TICKS	(1000/30)       /* 30 frames/second */

/* Call this instead of exit(), so we can clean up SDL: atexit() is evil. */

static void

{

}

/* Fill the screen with a gradient */

static void

{

    Uint8 *buffer;

    Uint16 *buffer16;

    Uint16 color;

    Uint8 gradient;

    int i, k;

    /* Set the surface pixels and refresh! */

    }

    buffer = (Uint8 *) screen->pixels;

    if (screen->format->BytesPerPixel != 2) {

        for (i = 0; i < screen->h; ++i) {

            buffer += screen->pitch;

        }

    } else {

        for (i = 0; i < screen->h; ++i) {

            gradient = ((i * 255) / screen->h);

            color =

            buffer16 = (Uint16 *) buffer;

            for (k = 0; k < screen->w; k++) {

                *(buffer16 + k) = color;

            }

            buffer += screen->pitch;

        }

    }

}

/* Create a "light" -- a yellowish surface with variable alpha */

SDL_Surface *

{

    Uint8 trans, alphamask;

    int range, addition;

    int xdist, ydist;

    Uint16 x, y;

    Uint16 skip;

    Uint32 pixel;

    SDL_Surface *light;

#ifdef LIGHT_16BIT

    Uint16 *buf;

    /* Create a 16 (4/4/4/4) bpp square with a full 4-bit alpha channel */

    /* Note: this isn't any faster than a 32 bit alpha surface */

    alphamask = 0x0000000F;

#else

    Uint32 *buf;

    /* Create a 32 (8/8/8/8) bpp square with a full 8-bit alpha channel */

    alphamask = 0x000000FF;

    if (light == NULL) {

        return (NULL);

    }

#endif

    /* Fill with a light yellow-orange color */

    skip = light->pitch - (light->w * light->format->BytesPerPixel);

#ifdef LIGHT_16BIT

    buf = (Uint16 *) light->pixels;

#else

    buf = (Uint32 *) light->pixels;

#endif

    /* Get a tranparent pixel value - we'll add alpha later */

    for (y = 0; y < light->h; ++y) {

        for (x = 0; x < light->w; ++x) {

            *buf++ = pixel;

        }

        buf += skip;            /* Almost always 0, but just in case... */

    }

    /* Calculate alpha values for the surface. */

#ifdef LIGHT_16BIT

    buf = (Uint16 *) light->pixels;

#else

    buf = (Uint32 *) light->pixels;

#endif

    for (y = 0; y < light->h; ++y) {

        for (x = 0; x < light->w; ++x) {

            /* Slow distance formula (from center of light) */

            xdist = x - (light->w / 2);

            ydist = y - (light->h / 2);

            /* Scale distance to range of transparency (0-255) */

            if (range > radius) {

                trans = alphamask;

            } else {

                /* Increasing transparency with distance */

                trans = (Uint8) ((range * alphamask) / radius);

                /* Lights are very transparent */

                addition = (alphamask + 1) / 8;

                if ((int) trans + addition > alphamask) {

                    trans = alphamask;

                } else {

                    trans += addition;

                }

            }

            /* We set the alpha component as the right N bits */

            *buf++ |= (255 - trans);

        }

        buf += skip;            /* Almost always 0, but just in case... */

    }

    /* Enable RLE acceleration of this alpha surface */

    /* We're done! */

    return (light);

}

static Uint32 flashes = 0;

static Uint32 flashtime = 0;

void

{

    SDL_Rect position;

    Uint32 ticks1;

    Uint32 ticks2;

    /* Easy, center light */

    position.x = x - (light->w / 2);

    position.y = y - (light->h / 2);

    position.w = light->w;

    position.h = light->h;

    ++flashes;

    /* Update time spend doing alpha blitting */

    flashtime += (ticks2 - ticks1);

}

static int sprite_visible = 0;

static SDL_Surface *sprite;

static SDL_Surface *backing;

static SDL_Rect position;

static int x_vel, y_vel;

static int alpha_vel;

int

{

    SDL_Surface *converted;

    /* Load the sprite image */

    if (sprite == NULL) {

        return (-1);

    }

    /* Set transparent pixel as the pixel at (0,0) */

    if (sprite->format->palette) {

    }

    /* Convert sprite to video format */

    if (converted == NULL) {

        return (-1);

    }

    sprite = converted;

    /* Create the background */

    if (backing == NULL) {

        return (-1);

    }

    /* Convert background to video format */

    if (converted == NULL) {

        return (-1);

    }

    backing = converted;

    /* Set the initial position of the sprite */

    position.x = (screen->w - sprite->w) / 2;

    position.y = (screen->h - sprite->h) / 2;

    position.w = sprite->w;

    position.h = sprite->h;

    x_vel = 0;

    y_vel = 0;

    alpha_vel = 1;

    /* We're ready to roll. :) */

    return (0);

}

void

{

    x_vel = ((int) x - position.x) / 10;

    y_vel = ((int) y - position.y) / 10;

}

void

{

    SDL_Rect updates[2];

    int alpha;

    /* Erase the sprite if it was visible */

    if (sprite_visible) {

        updates[0] = position;

    } else {

        updates[0].x = 0;

        updates[0].y = 0;

        updates[0].w = 0;

        updates[0].h = 0;

        sprite_visible = 1;

    }

    /* Since the sprite is off the screen, we can do other drawing

       without being overwritten by the saved area behind the sprite.

     */

    if (light != NULL) {

        int x, y;

    }

    /* Move the sprite, bounce at the wall */

    position.x += x_vel;

    if ((position.x < 0) || (position.x >= screen->w)) {

        x_vel = -x_vel;

        position.x += x_vel;

    }

    position.y += y_vel;

    if ((position.y < 0) || (position.y >= screen->h)) {

        y_vel = -y_vel;

        position.y += y_vel;

    }

    /* Update transparency (fade in and out) */

    alpha = sprite->format->alpha;

    if ((alpha + alpha_vel) < 0) {

        alpha_vel = -alpha_vel;

    } else if ((alpha + alpha_vel) > 255) {

        alpha_vel = -alpha_vel;

    }

    /* Save the area behind the sprite */

    updates[1] = position;

    /* Blit the sprite onto the screen */

    updates[1] = position;

    /* Make it so! */

}

void

{

    SDL_Rect updates[2];

    /* Erase, move, Draw, update */

    updates[0] = position;

    position.x = x - sprite->w / 2;     /* Center about X */

    position.y = y - sprite->h / 2;     /* Center about Y */

    updates[1] = position;

    updates[1] = position;

}

int

{

    const SDL_VideoInfo *info;

    SDL_Surface *screen;

    int w, h;

    Uint8 video_bpp;

    Uint32 videoflags;

    int i, done;

    SDL_Event event;

    SDL_Surface *light;

    int mouse_pressed;

    Uint32 ticks, lastticks;

    /* Initialize SDL */

        return (1);

    }

    /* Alpha blending doesn't work well at 8-bit color */

#ifdef _WIN32_WCE

    /* Pocket PC */

    w = 240;

    h = 320;

#else

    w = 640;

    h = 480;

#endif

    if (info->vfmt->BitsPerPixel > 8) {

        video_bpp = info->vfmt->BitsPerPixel;

    } else {

        video_bpp = 16;

    }

    videoflags = SDL_SWSURFACE;

    for (i = 1; argv[i]; ++i) {

            if (video_bpp <= 8) {

                video_bpp = 16;

            }

            videoflags |= SDL_HWSURFACE;

            videoflags |= SDL_HWPALETTE;

            videoflags |= SDL_RESIZABLE;

            videoflags |= SDL_NOFRAME;

            videoflags |= SDL_FULLSCREEN;

        } else {

        }

    }

    /* Set video mode */

    }

    /* Create the light */

    if (light == NULL) {

    }

    /* Load the sprite */

    }

    /* Print out information about our surfaces */

    if ((screen->flags & SDL_HWSURFACE) == SDL_HWSURFACE) {

    } else {

    }

    if ((screen->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF) {

    }

    if ((sprite->flags & SDL_HWSURFACE) == SDL_HWSURFACE) {

    } else {

    }

    /* Run a sample blit to trigger blit acceleration */

    if ((sprite->flags & SDL_HWACCEL) == SDL_HWACCEL) {

    } else {

    }

    /* Set a clipping rectangle to clip the outside edge of the screen */

    {

        SDL_Rect clip;

        clip.x = 32;

        clip.y = 32;

        clip.w = screen->w - (2 * 32);

        clip.h = screen->h - (2 * 32);

    }

    /* Wait for a keystroke */

    done = 0;

    mouse_pressed = 0;

    while (!done) {

        /* Update the frame -- move the sprite */

        if (mouse_pressed) {

            mouse_pressed = 0;

        } else {

        }

        /* Slow down the loop to 30 frames/second */

        if ((ticks - lastticks) < FRAME_TICKS) {

#ifdef CHECK_SLEEP_GRANULARITY

#endif

#ifdef CHECK_SLEEP_GRANULARITY

#endif

        }

        lastticks = ticks;

        /* Check for events */

            switch (event.type) {

            case SDL_VIDEORESIZE:

                screen =