179 lines
4 KiB
C
179 lines
4 KiB
C
|
|
/* 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;
|
|
}
|