#include <iostream>
#include <GL/gl.h>
#include <GL/glu.h>
#include <SDL/SDL.h>
#include "framerate.h"
/* screen width, height, and bit depth */
const int SCREEN_WIDTH = 800;
const int SCREEN_HEIGHT = 600;
const int SCREEN_BPP = 32;
/* flags to pass to sdl_setvideomode */
int videoFlags;
/* main loop variable */
bool done = false;
/* this holds some info about our display */
const SDL_VideoInfo *videoInfo;
/* whether or not the window is active */
bool isActive = true;
/* This is our SDL surface */
SDL_Surface *surface;
SDL_Event event;
char fps[50];
framerate fps_manager;
/* function to release/destroy our resources and restoring the old desktop */
void Quit(int returnCode)
{
/* clean up the window */
SDL_Quit();
/* and exit appropriately */
exit(returnCode);
}
/* function to reset our viewport after a window resize */
bool resizeWindow(int width, int height)
{
/* Height / width ration */
GLfloat ratio;
/* Protect against a divide by zero */
if (height == 0) { height = 1; }
ratio = (GLfloat)width / (GLfloat)height;
/* Setup our viewport. */
glViewport(0, 0, (GLint)width, (GLint)height);
/*
* change to the projection matrix and set
* our viewing volume.
*/
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
/* Set our perspective */
gluPerspective(45.0f, ratio, 0.1f, 100.0f);
/* Make sure we're chaning the model view and not the projection */
glMatrixMode(GL_MODELVIEW);
/* Reset The View */
glLoadIdentity();
return true;
}
/* function to handle key press events */
void handleKeyPress(SDL_keysym *keysym)
{
switch (keysym->sym)
{
case SDLK_ESCAPE:
Quit(0);
break;
case SDLK_F1:
SDL_WM_ToggleFullScreen(surface);
break;
default:
break;
}
return;
}
/* general OpenGL initialization function */
bool initGL(GLvoid)
{
/* Enable smooth shading */
glShadeModel(GL_SMOOTH);
/* Set the background black */
glClearColor(0.0f, 0.0f, 0.0f, 0.5f);
/* Depth buffer setup */
glClearDepth(1.0f);
/* Enables Depth Testing */
glEnable(GL_DEPTH_TEST);
/* The Type Of Depth Test To Do */
glDepthFunc(GL_LEQUAL);
/* Really Nice Perspective Calculations */
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
/* Fetch the video info */
videoInfo = SDL_GetVideoInfo( );
if ( !videoInfo )
{
std::cerr<<"Unable to get video info. Reason: "<<SDL_GetError()<<std::endl;
Quit(1);
}
/* the flags to pass to SDL_SetVideoMode */
videoFlags = SDL_OPENGL; /* Enable OpenGL in SDL */
videoFlags |= SDL_GL_DOUBLEBUFFER; /* Enable double buffering */
videoFlags |= SDL_HWPALETTE; /* Store the palette in hardware */
videoFlags |= SDL_RESIZABLE; /* Enable window resizing */
/* This checks to see if surfaces can be stored in memory */
if ( videoInfo->hw_available )
videoFlags |= SDL_HWSURFACE;
else
videoFlags |= SDL_SWSURFACE;
/* This checks if hardware blits can be done */
if ( videoInfo->blit_hw )
videoFlags |= SDL_HWACCEL;
SDL_GL_SetAttribute(SDL_GL_RED_SIZE,8-videoInfo->vfmt->Rloss);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE,8-videoInfo->vfmt->Gloss);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE,8-videoInfo->vfmt->Bloss);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
/* get a SDL surface */
surface = SDL_SetVideoMode(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP, videoFlags);
/* Verify there is a surface */
if (surface==NULL)
{
std::cerr<<"Video mode set failed. Reason: "<<SDL_GetError()<<std::endl;
Quit(1);
}
return true;
}
/* Here goes our drawing code */
bool drawGLScene( GLvoid )
{
fps_manager.process();
sprintf(fps, "Current Frames Per Second: %d", int(fps_manager.fps()));
SDL_WM_SetCaption(fps,fps);
/* Draw it to the screen */
SDL_GL_SwapBuffers( );
return true;
}
int main( int argc, char **argv )
{
/* initialize SDL */
if (SDL_Init(SDL_INIT_VIDEO) < 0)
{
std::cerr<<"Video initialization failed. Reason: "<<SDL_GetError()<<std::endl;
Quit(1);
}
/* initialize OpenGL */
initGL();
/* resize the initial window */
resizeWindow(SCREEN_WIDTH, SCREEN_HEIGHT);
/* wait for events */
while (!done)
{
/* handle the events in the queue */
while (SDL_PollEvent(&event))
{
switch(event.type)
{
case SDL_ACTIVEEVENT:
/* Something's happend with our focus
* If we lost focus or we are iconified, we
* shouldn't draw the screen
*/
if (event.active.gain == 0)
isActive = true;
else
isActive = true;
break;
case SDL_VIDEORESIZE:
/* handle resize event */
surface = SDL_SetVideoMode(event.resize.w, event.resize.h, 16, videoFlags);
if (surface==NULL)
{
std::cerr<<"Could not get a surface after resize. Reason: "<<SDL_GetError()<<std::endl;
Quit(1);
}
resizeWindow(event.resize.w, event.resize.h);
break;
case SDL_KEYDOWN:
/* handle key presses */
handleKeyPress( &event.key.keysym );
break;
case SDL_QUIT:
/* handle quit requests */
done = true;
break;
default:
break;
}
}
/* draw the scene */
if (isActive)
drawGLScene();
}
/* clean ourselves up and exit */
Quit(0);
/* Should never get here */
return 0;
}
Is this a good start?
Well I just started looking at opengl yesterday...Iv'e played around a little with SDL and so...
But now I wonder if I have a good base to start coding from...if someone of you experienced guys could take a look at it I would appreciate it very much
This topic is closed to new replies.
Advertisement
Popular Topics
Advertisement