Sign in to follow this  
walle

OpenGL Is this a good start?

Recommended Posts

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
#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;
}


Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

Sign in to follow this