| |
| /* Simple program: Create a blank window, wait for keypress, quit. |
| |
| Please see the SDL documentation for details on using the SDL API: |
| /Developer/Documentation/SDL/docs.html |
| */ |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <math.h> |
| |
| #include "SDL.h" |
| |
| extern void Atlantis_Init (); |
| extern void Atlantis_Reshape (int w, int h); |
| extern void Atlantis_Animate (); |
| extern void Atlantis_Display (); |
| |
| static SDL_Surface *gScreen; |
| |
| static void initAttributes () |
| { |
| // Setup attributes we want for the OpenGL context |
| |
| int value; |
| |
| // Don't set color bit sizes (SDL_GL_RED_SIZE, etc) |
| // Mac OS X will always use 8-8-8-8 ARGB for 32-bit screens and |
| // 5-5-5 RGB for 16-bit screens |
| |
| // Request a 16-bit depth buffer (without this, there is no depth buffer) |
| value = 16; |
| SDL_GL_SetAttribute (SDL_GL_DEPTH_SIZE, value); |
| |
| |
| // Request double-buffered OpenGL |
| // The fact that windows are double-buffered on Mac OS X has no effect |
| // on OpenGL double buffering. |
| value = 1; |
| SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, value); |
| } |
| |
| static void printAttributes () |
| { |
| // Print out attributes of the context we created |
| int nAttr; |
| int i; |
| |
| int attr[] = { SDL_GL_RED_SIZE, SDL_GL_BLUE_SIZE, SDL_GL_GREEN_SIZE, |
| SDL_GL_ALPHA_SIZE, SDL_GL_BUFFER_SIZE, SDL_GL_DEPTH_SIZE }; |
| |
| char *desc[] = { "Red size: %d bits\n", "Blue size: %d bits\n", "Green size: %d bits\n", |
| "Alpha size: %d bits\n", "Color buffer size: %d bits\n", |
| "Depth bufer size: %d bits\n" }; |
| |
| nAttr = sizeof(attr) / sizeof(int); |
| |
| for (i = 0; i < nAttr; i++) { |
| |
| int value; |
| SDL_GL_GetAttribute (attr[i], &value); |
| printf (desc[i], value); |
| } |
| } |
| |
| static void createSurface (int fullscreen) |
| { |
| Uint32 flags = 0; |
| |
| flags = SDL_OPENGL; |
| if (fullscreen) |
| flags |= SDL_FULLSCREEN; |
| |
| // Create window |
| gScreen = SDL_SetVideoMode (640, 480, 0, flags); |
| if (gScreen == NULL) { |
| |
| fprintf (stderr, "Couldn't set 640x480 OpenGL video mode: %s\n", |
| SDL_GetError()); |
| SDL_Quit(); |
| exit(2); |
| } |
| } |
| |
| static void initGL () |
| { |
| Atlantis_Init (); |
| Atlantis_Reshape (gScreen->w, gScreen->h); |
| } |
| |
| static void drawGL () |
| { |
| Atlantis_Animate (); |
| Atlantis_Display (); |
| } |
| |
| static void mainLoop () |
| { |
| SDL_Event event; |
| int done = 0; |
| int fps = 24; |
| int delay = 1000/fps; |
| int thenTicks = -1; |
| int nowTicks; |
| |
| while ( !done ) { |
| |
| /* Check for events */ |
| while ( SDL_PollEvent (&event) ) { |
| switch (event.type) { |
| |
| case SDL_MOUSEMOTION: |
| break; |
| case SDL_MOUSEBUTTONDOWN: |
| break; |
| case SDL_KEYDOWN: |
| /* Any keypress quits the app... */ |
| case SDL_QUIT: |
| done = 1; |
| break; |
| default: |
| break; |
| } |
| } |
| |
| // Draw at 24 hz |
| // This approach is not normally recommended - it is better to |
| // use time-based animation and run as fast as possible |
| drawGL (); |
| SDL_GL_SwapBuffers (); |
| |
| // Time how long each draw-swap-delay cycle takes |
| // and adjust delay to get closer to target framerate |
| if (thenTicks > 0) { |
| nowTicks = SDL_GetTicks (); |
| delay += (1000/fps - (nowTicks-thenTicks)); |
| thenTicks = nowTicks; |
| if (delay < 0) |
| delay = 1000/fps; |
| } |
| else { |
| thenTicks = SDL_GetTicks (); |
| } |
| |
| SDL_Delay (delay); |
| } |
| } |
| |
| int main(int argc, char *argv[]) |
| { |
| // Init SDL video subsystem |
| if ( SDL_Init (SDL_INIT_VIDEO) < 0 ) { |
| |
| fprintf(stderr, "Couldn't initialize SDL: %s\n", |
| SDL_GetError()); |
| exit(1); |
| } |
| |
| // Set GL context attributes |
| initAttributes (); |
| |
| // Create GL context |
| createSurface (0); |
| |
| // Get GL context attributes |
| printAttributes (); |
| |
| // Init GL state |
| initGL (); |
| |
| // Draw, get events... |
| mainLoop (); |
| |
| // Cleanup |
| SDL_Quit(); |
| |
| return 0; |
| } |