#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <math.h>

#include "SDL.h"

#ifdef __MACOS__

#define HAVE_OPENGL

#endif

#ifdef HAVE_OPENGL

#include "SDL_opengl.h"

/* Undefine this if you want a flat cube instead of a rainbow cube */

#define SHADED_CUBE

/* Define this to be the name of the logo image to use with -logo */

#define LOGO_FILE	"icon.bmp"

static SDL_Surface *global_image = NULL;

static GLuint global_texture = 0;

static GLuint cursor_texture = 0;

/**********************************************************************/

void

HotKey_ToggleFullScreen(void)

{

    SDL_Surface *screen;

    screen = SDL_GetVideoSurface();

    if (SDL_WM_ToggleFullScreen(screen)) {

        printf("Toggled fullscreen mode - now %s\n",

               (screen->flags & SDL_FULLSCREEN) ? "fullscreen" : "windowed");

    } else {

        printf("Unable to toggle fullscreen mode\n");

    }

}

void

HotKey_ToggleGrab(void)

{

    SDL_GrabMode mode;

    printf("Ctrl-G: toggling input grab!\n");

    mode = SDL_WM_GrabInput(SDL_GRAB_QUERY);

    if (mode == SDL_GRAB_ON) {

        printf("Grab was on\n");

    } else {

        printf("Grab was off\n");

    }

    mode = SDL_WM_GrabInput(!mode);

    if (mode == SDL_GRAB_ON) {

        printf("Grab is now on\n");

    } else {

        printf("Grab is now off\n");

    }

}

void

HotKey_Iconify(void)

{

    printf("Ctrl-Z: iconifying window!\n");

    SDL_WM_IconifyWindow();

}

int

HandleEvent(SDL_Event * event)

{

    int done;

    done = 0;

    switch (event->type) {

    case SDL_ACTIVEEVENT:

        /* See what happened */

        printf("app %s ", event->active.gain ? "gained" : "lost");

        if (event->active.state & SDL_APPACTIVE) {

            printf("active ");

        } else if (event->active.state & SDL_APPMOUSEFOCUS) {

            printf("mouse ");

        } else if (event->active.state & SDL_APPINPUTFOCUS) {

            printf("input ");

        }

        printf("focus\n");

        break;

    case SDL_KEYDOWN:

        if (event->key.keysym.sym == SDLK_ESCAPE) {

            done = 1;

        }

        if ((event->key.keysym.sym == SDLK_g) &&

            (event->key.keysym.mod & KMOD_CTRL)) {

            HotKey_ToggleGrab();

        }

        if ((event->key.keysym.sym == SDLK_z) &&

            (event->key.keysym.mod & KMOD_CTRL)) {

            HotKey_Iconify();

        }

        if ((event->key.keysym.sym == SDLK_RETURN) &&

            (event->key.keysym.mod & KMOD_ALT)) {

            HotKey_ToggleFullScreen();

        }

        printf("key '%s' pressed\n", SDL_GetKeyName(event->key.keysym.sym));

        break;

    case SDL_QUIT:

        done = 1;

        break;

    }

    return (done);

}

void

SDL_GL_Enter2DMode()

{

    SDL_Surface *screen = SDL_GetVideoSurface();

    /* Note, there may be other things you need to change,

       depending on how you have your OpenGL state set up.

     */

    glPushAttrib(GL_ENABLE_BIT);

    glDisable(GL_DEPTH_TEST);

    glDisable(GL_CULL_FACE);

    glEnable(GL_TEXTURE_2D);

    /* This allows alpha blending of 2D textures with the scene */

    glEnable(GL_BLEND);

    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

    glViewport(0, 0, screen->w, screen->h);

    glMatrixMode(GL_PROJECTION);

    glPushMatrix();

    glLoadIdentity();

    glOrtho(0.0, (GLdouble) screen->w, (GLdouble) screen->h, 0.0, 0.0, 1.0);

    glMatrixMode(GL_MODELVIEW);

    glPushMatrix();

    glLoadIdentity();

    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);

}

void

SDL_GL_Leave2DMode()

{

    glMatrixMode(GL_MODELVIEW);

    glPopMatrix();

    glMatrixMode(GL_PROJECTION);

    glPopMatrix();

    glPopAttrib();

}

/* Quick utility function for texture creation */

static int

power_of_two(int input)

{

    int value = 1;

    while (value < input) {

        value <<= 1;

    }

    return value;

}

GLuint

SDL_GL_LoadTexture(SDL_Surface * surface, GLfloat * texcoord)

{

    GLuint texture;

    int w, h;

    SDL_Surface *image;

    SDL_Rect area;

    Uint32 saved_flags;

    Uint8 saved_alpha;

    /* Use the surface width and height expanded to powers of 2 */

    w = power_of_two(surface->w);

    h = power_of_two(surface->h);

    texcoord[0] = 0.0f;         /* Min X */

    texcoord[1] = 0.0f;         /* Min Y */

    texcoord[2] = (GLfloat) surface->w / w;     /* Max X */

    texcoord[3] = (GLfloat) surface->h / h;     /* Max Y */

    image = SDL_CreateRGBSurface(SDL_SWSURFACE, w, h, 32,

#if SDL_BYTEORDER == SDL_LIL_ENDIAN     /* OpenGL RGBA masks */

                                 0x000000FF,

                                 0x0000FF00, 0x00FF0000, 0xFF000000

#else

                                 0xFF000000,

                                 0x00FF0000, 0x0000FF00, 0x000000FF

#endif

        );

    if (image == NULL) {

        return 0;

    }

    /* Save the alpha blending attributes */

    saved_flags = surface->flags & (SDL_SRCALPHA | SDL_RLEACCELOK);

    saved_alpha = surface->format->alpha;

    if ((saved_flags & SDL_SRCALPHA) == SDL_SRCALPHA) {

        SDL_SetAlpha(surface, 0, 0);

    }

    /* Copy the surface into the GL texture image */

    area.x = 0;

    area.y = 0;

    area.w = surface->w;

    area.h = surface->h;

    SDL_BlitSurface(surface, &area, image, &area);

    /* Restore the alpha blending attributes */

    if ((saved_flags & SDL_SRCALPHA) == SDL_SRCALPHA) {

        SDL_SetAlpha(surface, saved_flags, saved_alpha);

    }

    /* Create an OpenGL texture for the image */

    glGenTextures(1, &texture);

    glBindTexture(GL_TEXTURE_2D, texture);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

    glTexImage2D(GL_TEXTURE_2D,

                 0,

                 GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, image->pixels);

    SDL_FreeSurface(image);     /* No longer needed */

    return texture;

}

void

DrawLogoCursor(void)

{

    static GLfloat texMinX, texMinY;

    static GLfloat texMaxX, texMaxY;

    static int w, h;

    int x, y;

    if (!cursor_texture) {

        SDL_Surface *image;

        GLfloat texcoord[4];

        /* Load the image (could use SDL_image library here) */

        image = SDL_LoadBMP(LOGO_FILE);

        if (image == NULL) {

            return;

        }

        w = image->w;

        h = image->h;

        /* Convert the image into an OpenGL texture */

        cursor_texture = SDL_GL_LoadTexture(image, texcoord);

        /* Make texture coordinates easy to understand */

        texMinX = texcoord[0];

        texMinY = texcoord[1];

        texMaxX = texcoord[2];

        texMaxY = texcoord[3];

        /* We don't need the original image anymore */

        SDL_FreeSurface(image);

        /* Make sure that the texture conversion is okay */

        if (!cursor_texture) {

            return;

        }

    }

    /* Move the image around */

    SDL_GetMouseState(&x, &y);

    x -= w / 2;

    y -= h / 2;

    /* Show the image on the screen */

    SDL_GL_Enter2DMode();

    glBindTexture(GL_TEXTURE_2D, cursor_texture);

    glBegin(GL_TRIANGLE_STRIP);

    glTexCoord2f(texMinX, texMinY);

    glVertex2i(x, y);

    glTexCoord2f(texMaxX, texMinY);

    glVertex2i(x + w, y);

    glTexCoord2f(texMinX, texMaxY);

    glVertex2i(x, y + h);

    glTexCoord2f(texMaxX, texMaxY);

    glVertex2i(x + w, y + h);

    glEnd();

    SDL_GL_Leave2DMode();

}

void

DrawLogoTexture(void)

{

    static GLfloat texMinX, texMinY;

    static GLfloat texMaxX, texMaxY;

    static int x = 0;

    static int y = 0;

    static int w, h;

    static int delta_x = 1;

    static int delta_y = 1;

    SDL_Surface *screen = SDL_GetVideoSurface();

    if (!global_texture) {

        SDL_Surface *image;

        GLfloat texcoord[4];

        /* Load the image (could use SDL_image library here) */

        image = SDL_LoadBMP(LOGO_FILE);

        if (image == NULL) {

            return;

        }

        w = image->w;

        h = image->h;

        /* Convert the image into an OpenGL texture */

        global_texture = SDL_GL_LoadTexture(image, texcoord);

        /* Make texture coordinates easy to understand */

        texMinX = texcoord[0];

        texMinY = texcoord[1];

        texMaxX = texcoord[2];

        texMaxY = texcoord[3];

        /* We don't need the original image anymore */

        SDL_FreeSurface(image);

        /* Make sure that the texture conversion is okay */

        if (!global_texture) {

            return;

        }

    }

    /* Move the image around */

    x += delta_x;

    if (x < 0) {

        x = 0;

        delta_x = -delta_x;

    } else if ((x + w) > screen->w) {

        x = screen->w - w;

        delta_x = -delta_x;

    }

    y += delta_y;

    if (y < 0) {

        y = 0;

        delta_y = -delta_y;

    } else if ((y + h) > screen->h) {

        y = screen->h - h;

        delta_y = -delta_y;

    }

    /* Show the image on the screen */

    SDL_GL_Enter2DMode();

    glBindTexture(GL_TEXTURE_2D, global_texture);

    glBegin(GL_TRIANGLE_STRIP);

    glTexCoord2f(texMinX, texMinY);

    glVertex2i(x, y);

    glTexCoord2f(texMaxX, texMinY);

    glVertex2i(x + w, y);

    glTexCoord2f(texMinX, texMaxY);

    glVertex2i(x, y + h);

    glTexCoord2f(texMaxX, texMaxY);

    glVertex2i(x + w, y + h);

    glEnd();

    SDL_GL_Leave2DMode();

}

int

RunGLTest(int argc, char *argv[],

          int logo, int logocursor, int slowly, int bpp, float gamma,

          int noframe, int fsaa, int sync, int accel)

{

    int i;

    int rgb_size[3];

    int w = 640;

    int h = 480;

    int done = 0;

    int frames;

    Uint32 start_time, this_time;

    float color[8][3] = { {1.0, 1.0, 0.0},

    {1.0, 0.0, 0.0},

    {0.0, 0.0, 0.0},

    {0.0, 1.0, 0.0},

    {0.0, 1.0, 1.0},

    {1.0, 1.0, 1.0},

    {1.0, 0.0, 1.0},

    {0.0, 0.0, 1.0}

    };

    float cube[8][3] = { {0.5, 0.5, -0.5},

    {0.5, -0.5, -0.5},

    {-0.5, -0.5, -0.5},

    {-0.5, 0.5, -0.5},

    {-0.5, 0.5, 0.5},

    {0.5, 0.5, 0.5},

    {0.5, -0.5, 0.5},

    {-0.5, -0.5, 0.5}

    };

    Uint32 video_flags;

    int value;

    if (SDL_Init(SDL_INIT_VIDEO) < 0) {

        fprintf(stderr, "Couldn't initialize SDL: %s\n", SDL_GetError());

        exit(1);

    }

    /* See if we should detect the display depth */

    if (bpp == 0) {

        if (SDL_GetVideoInfo()->vfmt->BitsPerPixel <= 8) {

            bpp = 8;

        } else {

            bpp = 16;           /* More doesn't seem to work */

        }

    }

    /* Set the flags we want to use for setting the video mode */

    video_flags = SDL_OPENGL;

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

        if (strcmp(argv[i], "-fullscreen") == 0) {

            video_flags |= SDL_FULLSCREEN;

        }

    }

    if (noframe) {

        video_flags |= SDL_NOFRAME;

    }

    /* Initialize the display */

    switch (bpp) {

    case 8:

        rgb_size[0] = 3;

        rgb_size[1] = 3;

        rgb_size[2] = 2;

        break;

    case 15:

    case 16:

        rgb_size[0] = 5;

        rgb_size[1] = 5;

        rgb_size[2] = 5;

        break;

    default:

        rgb_size[0] = 8;

        rgb_size[1] = 8;

        rgb_size[2] = 8;

        break;

    }

    SDL_GL_SetAttribute(SDL_GL_RED_SIZE, rgb_size[0]);

    SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, rgb_size[1]);

    SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, rgb_size[2]);

    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);

    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);

    if (fsaa) {

        SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);

        SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, fsaa);

    }

    if (accel) {

        SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL, 1);

    }

    if (SDL_SetVideoMode(w, h, bpp, video_flags) == NULL) {

        fprintf(stderr, "Couldn't set GL mode: %s\n", SDL_GetError());

        SDL_Quit();

        exit(1);

    }

    if (sync) {

        SDL_GL_SetSwapInterval(1);

    } else {

        SDL_GL_SetSwapInterval(0);

    }

    printf("Screen BPP: %d\n", SDL_GetVideoSurface()->format->BitsPerPixel);

    printf("\n");

    printf("Vendor     : %s\n", glGetString(GL_VENDOR));

    printf("Renderer   : %s\n", glGetString(GL_RENDERER));

    printf("Version    : %s\n", glGetString(GL_VERSION));

    printf("Extensions : %s\n", glGetString(GL_EXTENSIONS));

    printf("\n");

    SDL_GL_GetAttribute(SDL_GL_RED_SIZE, &value);

    printf("SDL_GL_RED_SIZE: requested %d, got %d\n", rgb_size[0], value);

    SDL_GL_GetAttribute(SDL_GL_GREEN_SIZE, &value);

    printf("SDL_GL_GREEN_SIZE: requested %d, got %d\n", rgb_size[1], value);

    SDL_GL_GetAttribute(SDL_GL_BLUE_SIZE, &value);

    printf("SDL_GL_BLUE_SIZE: requested %d, got %d\n", rgb_size[2], value);

    SDL_GL_GetAttribute(SDL_GL_DEPTH_SIZE, &value);

    printf("SDL_GL_DEPTH_SIZE: requested %d, got %d\n", bpp, value);

    SDL_GL_GetAttribute(SDL_GL_DOUBLEBUFFER, &value);

    printf("SDL_GL_DOUBLEBUFFER: requested 1, got %d\n", value);

    if (fsaa) {

        SDL_GL_GetAttribute(SDL_GL_MULTISAMPLEBUFFERS, &value);

        printf("SDL_GL_MULTISAMPLEBUFFERS: requested 1, got %d\n", value);

        SDL_GL_GetAttribute(SDL_GL_MULTISAMPLESAMPLES, &value);

        printf("SDL_GL_MULTISAMPLESAMPLES: requested %d, got %d\n", fsaa,

               value);

    }

    if (accel) {

        SDL_GL_GetAttribute(SDL_GL_ACCELERATED_VISUAL, &value);

        printf("SDL_GL_ACCELERATED_VISUAL: requested 1, got %d\n", value);

    }

    if (sync) {

        printf("Buffer swap interval: requested 1, got %d\n",

               SDL_GL_GetSwapInterval());

    }

    /* Set the window manager title bar */

    SDL_WM_SetCaption("SDL GL test", "testgl");

    /* Set the gamma for the window */

    if (gamma != 0.0) {

        SDL_SetGamma(gamma, gamma, gamma);

    }

    glViewport(0, 0, w, h);

    glMatrixMode(GL_PROJECTION);

    glLoadIdentity();

    glOrtho(-2.0, 2.0, -2.0, 2.0, -20.0, 20.0);

    glMatrixMode(GL_MODELVIEW);

    glLoadIdentity();

    glEnable(GL_DEPTH_TEST);

    glDepthFunc(GL_LESS);

    glShadeModel(GL_SMOOTH);

    /* Loop until done. */

    start_time = SDL_GetTicks();