[sdl_omap.git] / docs / html / guidevideoopengl.html

<HTML
><HEAD
><TITLE
>Using OpenGL With SDL</TITLE
><META
NAME="GENERATOR"
CONTENT="Modular DocBook HTML Stylesheet Version 1.76b+
"><LINK
REL="HOME"
TITLE="SDL Library Documentation"
HREF="index.html"><LINK
REL="UP"
TITLE="Graphics and Video"
HREF="guidevideo.html"><LINK
REL="PREVIOUS"
TITLE="Graphics and Video"
HREF="guidevideo.html"><LINK
REL="NEXT"
TITLE="Input handling"
HREF="guideinput.html"></HEAD
><BODY
CLASS="SECT1"
BGCOLOR="#FFF8DC"
TEXT="#000000"
LINK="#0000ee"
VLINK="#551a8b"
ALINK="#ff0000"
><DIV
CLASS="NAVHEADER"
><TABLE
SUMMARY="Header navigation table"
WIDTH="100%"
BORDER="0"
CELLPADDING="0"
CELLSPACING="0"
><TR
><TH
COLSPAN="3"
ALIGN="center"
>SDL Library Documentation</TH
></TR
><TR
><TD
WIDTH="10%"
ALIGN="left"
VALIGN="bottom"
><A
HREF="guidevideo.html"
ACCESSKEY="P"
>Prev</A
></TD
><TD
WIDTH="80%"
ALIGN="center"
VALIGN="bottom"
>Chapter 2. Graphics and Video</TD
><TD
WIDTH="10%"
ALIGN="right"
VALIGN="bottom"
><A
HREF="guideinput.html"
ACCESSKEY="N"
>Next</A
></TD
></TR
></TABLE
><HR
ALIGN="LEFT"
WIDTH="100%"></DIV
><DIV
CLASS="SECT1"
><H1
CLASS="SECT1"
><A
NAME="GUIDEVIDEOOPENGL"
></A
>Using OpenGL With SDL</H1
><P
>SDL has the ability to create and use OpenGL contexts on several platforms(Linux/X11, Win32, BeOS, MacOS Classic/Toolbox, Mac OS X, FreeBSD/X11 and Solaris/X11). This allows you to use SDL's audio, event handling, threads and times in your OpenGL applications (a function often performed by GLUT).</P
><DIV
CLASS="SECT2"
><H2
CLASS="SECT2"
><A
NAME="AEN103"
></A
>Initialisation</H2
><P
>Initialising SDL to use OpenGL is not very different to initialising SDL normally. There are three differences; you must pass <TT
CLASS="LITERAL"
>SDL_OPENGL</TT
> to <A
HREF="sdlsetvideomode.html"
><TT
CLASS="FUNCTION"
>SDL_SetVideoMode</TT
></A
>, you must specify several GL attributes (depth buffer size, framebuffer sizes) using <A
HREF="sdlglsetattribute.html"
><TT
CLASS="FUNCTION"
>SDL_GL_SetAttribute</TT
></A
> and finally, if you wish to use double buffering you must specify it as a GL attribute, <SPAN
CLASS="emphasis"
><I
CLASS="EMPHASIS"
>not</I
></SPAN
> by passing the <TT
CLASS="LITERAL"
>SDL_DOUBLEBUF</TT
> flag to <TT
CLASS="FUNCTION"
>SDL_SetVideoMode</TT
>.</P
><DIV
CLASS="EXAMPLE"
><A
NAME="AEN114"
></A
><P
><B
>Example 2-7. Initializing SDL with OpenGL</B
></P
><PRE
CLASS="PROGRAMLISTING"
>    /* Information about the current video settings. */
    const SDL_VideoInfo* info = NULL;
    /* Dimensions of our window. */
    int width = 0;
    int height = 0;
    /* Color depth in bits of our window. */
    int bpp = 0;
    /* Flags we will pass into SDL_SetVideoMode. */
    int flags = 0;

    /* First, initialize SDL's video subsystem. */
    if( SDL_Init( SDL_INIT_VIDEO ) &#60; 0 ) {
        /* Failed, exit. */
        fprintf( stderr, "Video initialization failed: %s\n",
             SDL_GetError( ) );
        quit_tutorial( 1 );
    }

    /* Let's get some video information. */
    info = SDL_GetVideoInfo( );

    if( !info ) {
        /* This should probably never happen. */
        fprintf( stderr, "Video query failed: %s\n",
             SDL_GetError( ) );
        quit_tutorial( 1 );
    }

    /*
     * Set our width/height to 640/480 (you would
     * of course let the user decide this in a normal
     * app). We get the bpp we will request from
     * the display. On X11, VidMode can't change
     * resolution, so this is probably being overly
     * safe. Under Win32, ChangeDisplaySettings
     * can change the bpp.
     */
    width = 640;
    height = 480;
    bpp = info-&#62;vfmt-&#62;BitsPerPixel;

    /*
     * Now, we want to setup our requested
     * window attributes for our OpenGL window.
     * We want *at least* 5 bits of red, green
     * and blue. We also want at least a 16-bit
     * depth buffer.
     *
     * The last thing we do is request a double
     * buffered window. '1' turns on double
     * buffering, '0' turns it off.
     *
     * Note that we do not use SDL_DOUBLEBUF in
     * the flags to SDL_SetVideoMode. That does
     * not affect the GL attribute state, only
     * the standard 2D blitting setup.
     */
    SDL_GL_SetAttribute( SDL_GL_RED_SIZE, 5 );
    SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, 5 );
    SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, 5 );
    SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, 16 );
    SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );

    /*
     * We want to request that SDL provide us
     * with an OpenGL window, in a fullscreen
     * video mode.
     *
     * EXERCISE:
     * Make starting windowed an option, and
     * handle the resize events properly with
     * glViewport.
     */
    flags = SDL_OPENGL | SDL_FULLSCREEN;

    /*
     * Set the video mode
     */
    if( SDL_SetVideoMode( width, height, bpp, flags ) == 0 ) {
        /* 
         * This could happen for a variety of reasons,
         * including DISPLAY not being set, the specified
         * resolution not being available, etc.
         */
        fprintf( stderr, "Video mode set failed: %s\n",
             SDL_GetError( ) );
        quit_tutorial( 1 );
    }</PRE
></DIV
></DIV
><DIV
CLASS="SECT2"
><H2
CLASS="SECT2"
><A
NAME="AEN117"
></A
>Drawing</H2
><P
>Apart from initialisation, using OpenGL within SDL is the same as using OpenGL
with any other API, e.g. GLUT. You still use all the same function calls and
data types. However if you are using a double-buffered display, then you must
use
<A
HREF="sdlglswapbuffers.html"
><TT
CLASS="FUNCTION"
>SDL_GL_SwapBuffers()</TT
></A
>
to swap the buffers and update the display. To request double-buffering
with OpenGL, use
<A
HREF="sdlglsetattribute.html"
><TT
CLASS="FUNCTION"
>SDL_GL_SetAttribute</TT
></A
>
with <TT
CLASS="LITERAL"
>SDL_GL_DOUBLEBUFFER</TT
>, and use
<A
HREF="sdlglgetattribute.html"
><TT
CLASS="FUNCTION"
>SDL_GL_GetAttribute</TT
></A
>
to see if you actually got it.</P
><P
>A full example code listing is now presented below.</P
><DIV
CLASS="EXAMPLE"
><A
NAME="AEN128"
></A
><P
><B
>Example 2-8. SDL and OpenGL</B
></P
><PRE
CLASS="PROGRAMLISTING"
>/*
 * SDL OpenGL Tutorial.
 * (c) Michael Vance, 2000
 * briareos@lokigames.com
 *
 * Distributed under terms of the LGPL. 
 */

#include &#60;SDL/SDL.h&#62;
#include &#60;GL/gl.h&#62;
#include &#60;GL/glu.h&#62;

#include &#60;stdio.h&#62;
#include &#60;stdlib.h&#62;

static GLboolean should_rotate = GL_TRUE;

static void quit_tutorial( int code )
{
    /*
     * Quit SDL so we can release the fullscreen
     * mode and restore the previous video settings,
     * etc.
     */
    SDL_Quit( );

    /* Exit program. */
    exit( code );
}

static void handle_key_down( SDL_keysym* keysym )
{

    /* 
     * We're only interested if 'Esc' has
     * been presssed.
     *
     * EXERCISE: 
     * Handle the arrow keys and have that change the
     * viewing position/angle.
     */
    switch( keysym-&#62;sym ) {
    case SDLK_ESCAPE:
        quit_tutorial( 0 );
        break;
    case SDLK_SPACE:
        should_rotate = !should_rotate;
        break;
    default:
        break;
    }

}

static void process_events( void )
{
    /* Our SDL event placeholder. */
    SDL_Event event;

    /* Grab all the events off the queue. */
    while( SDL_PollEvent( &#38;event ) ) {

        switch( event.type ) {
        case SDL_KEYDOWN:
            /* Handle key presses. */
            handle_key_down( &#38;event.key.keysym );
            break;
        case SDL_QUIT:
            /* Handle quit requests (like Ctrl-c). */
            quit_tutorial( 0 );
            break;
        }

    }

}

static void draw_screen( void )
{
    /* Our angle of rotation. */
    static float angle = 0.0f;

    /*
     * EXERCISE:
     * Replace this awful mess with vertex
     * arrays and a call to glDrawElements.
     *
     * EXERCISE:
     * After completing the above, change
     * it to use compiled vertex arrays.
     *
     * EXERCISE:
     * Verify my windings are correct here ;).
     */
    static GLfloat v0[] = { -1.0f, -1.0f,  1.0f };
    static GLfloat v1[] = {  1.0f, -1.0f,  1.0f };
    static GLfloat v2[] = {  1.0f,  1.0f,  1.0f };
    static GLfloat v3[] = { -1.0f,  1.0f,  1.0f };
    static GLfloat v4[] = { -1.0f, -1.0f, -1.0f };
    static GLfloat v5[] = {  1.0f, -1.0f, -1.0f };
    static GLfloat v6[] = {  1.0f,  1.0f, -1.0f };
    static GLfloat v7[] = { -1.0f,  1.0f, -1.0f };
    static GLubyte red[]    = { 255,   0,   0, 255 };
    static GLubyte green[]  = {   0, 255,   0, 255 };
    static GLubyte blue[]   = {   0,   0, 255, 255 };
    static GLubyte white[]  = { 255, 255, 255, 255 };
    static GLubyte yellow[] = {   0, 255, 255, 255 };
    static GLubyte black[]  = {   0,   0,   0, 255 };
    static GLubyte orange[] = { 255, 255,   0, 255 };
    static GLubyte purple[] = { 255,   0, 255,   0 };

    /* Clear the color and depth buffers. */
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

    /* We don't want to modify the projection matrix. */
    glMatrixMode( GL_MODELVIEW );
    glLoadIdentity( );

    /* Move down the z-axis. */
    glTranslatef( 0.0, 0.0, -5.0 );

    /* Rotate. */
    glRotatef( angle, 0.0, 1.0, 0.0 );

    if( should_rotate ) {

        if( ++angle &#62; 360.0f ) {
            angle = 0.0f;
        }

    }

    /* Send our triangle data to the pipeline. */
    glBegin( GL_TRIANGLES );

    glColor4ubv( red );
    glVertex3fv( v0 );
    glColor4ubv( green );
    glVertex3fv( v1 );
    glColor4ubv( blue );
    glVertex3fv( v2 );

    glColor4ubv( red );
    glVertex3fv( v0 );
    glColor4ubv( blue );
    glVertex3fv( v2 );
    glColor4ubv( white );
    glVertex3fv( v3 );

    glColor4ubv( green );
    glVertex3fv( v1 );
    glColor4ubv( black );
    glVertex3fv( v5 );
    glColor4ubv( orange );
    glVertex3fv( v6 );

    glColor4ubv( green );
    glVertex3fv( v1 );
    glColor4ubv( orange );
    glVertex3fv( v6 );
    glColor4ubv( blue );
    glVertex3fv( v2 );

    glColor4ubv( black );
    glVertex3fv( v5 );
    glColor4ubv( yellow );
    glVertex3fv( v4 );
    glColor4ubv( purple );
    glVertex3fv( v7 );

    glColor4ubv( black );
    glVertex3fv( v5 );
    glColor4ubv( purple );
    glVertex3fv( v7 );
    glColor4ubv( orange );
    glVertex3fv( v6 );

    glColor4ubv( yellow );
    glVertex3fv( v4 );
    glColor4ubv( red );
    glVertex3fv( v0 );
    glColor4ubv( white );
    glVertex3fv( v3 );

    glColor4ubv( yellow );
    glVertex3fv( v4 );
    glColor4ubv( white );
    glVertex3fv( v3 );
    glColor4ubv( purple );
    glVertex3fv( v7 );

    glColor4ubv( white );
    glVertex3fv( v3 );
    glColor4ubv( blue );
    glVertex3fv( v2 );
    glColor4ubv( orange );
    glVertex3fv( v6 );

    glColor4ubv( white );
    glVertex3fv( v3 );
    glColor4ubv( orange );
    glVertex3fv( v6 );
    glColor4ubv( purple );
    glVertex3fv( v7 );

    glColor4ubv( green );
    glVertex3fv( v1 );
    glColor4ubv( red );
    glVertex3fv( v0 );
    glColor4ubv( yellow );
    glVertex3fv( v4 );

    glColor4ubv( green );
    glVertex3fv( v1 );
    glColor4ubv( yellow );
    glVertex3fv( v4 );
    glColor4ubv( black );
    glVertex3fv( v5 );

    glEnd( );

    /*
     * EXERCISE:
     * Draw text telling the user that 'Spc'
     * pauses the rotation and 'Esc' quits.
     * Do it using vetors and textured quads.
     */

    /*
     * Swap the buffers. This this tells the driver to
     * render the next frame from the contents of the
     * back-buffer, and to set all rendering operations
     * to occur on what was the front-buffer.
     *
     * Double buffering prevents nasty visual tearing
     * from the application drawing on areas of the
     * screen that are being updated at the same time.
     */
    SDL_GL_SwapBuffers( );
}

static void setup_opengl( int width, int height )
{
    float ratio = (float) width / (float) height;

    /* Our shading model--Gouraud (smooth). */
    glShadeModel( GL_SMOOTH );

    /* Culling. */
    glCullFace( GL_BACK );
    glFrontFace( GL_CCW );
    glEnable( GL_CULL_FACE );

    /* Set the clear color. */
    glClearColor( 0, 0, 0, 0 );

    /* Setup our viewport. */
    glViewport( 0, 0, width, height );

    /*
     * Change to the projection matrix and set
     * our viewing volume.
     */
    glMatrixMode( GL_PROJECTION );
    glLoadIdentity( );
    /*
     * EXERCISE:
     * Replace this with a call to glFrustum.
     */
    gluPerspective( 60.0, ratio, 1.0, 1024.0 );
}

int main( int argc, char* argv[] )
{
    /* Information about the current video settings. */
    const SDL_VideoInfo* info = NULL;
    /* Dimensions of our window. */
    int width = 0;
    int height = 0;
    /* Color depth in bits of our window. */
    int bpp = 0;
    /* Flags we will pass into SDL_SetVideoMode. */
    int flags = 0;

    /* First, initialize SDL's video subsystem. */
    if( SDL_Init( SDL_INIT_VIDEO ) &#60; 0 ) {
        /* Failed, exit. */
        fprintf( stderr, "Video initialization failed: %s\n",
             SDL_GetError( ) );
        quit_tutorial( 1 );
    }

    /* Let's get some video information. */
    info = SDL_GetVideoInfo( );

    if( !info ) {
        /* This should probably never happen. */
        fprintf( stderr, "Video query failed: %s\n",
             SDL_GetError( ) );
        quit_tutorial( 1 );
    }

    /*
     * Set our width/height to 640/480 (you would
     * of course let the user decide this in a normal
     * app). We get the bpp we will request from
     * the display. On X11, VidMode can't change
     * resolution, so this is probably being overly
     * safe. Under Win32, ChangeDisplaySettings
     * can change the bpp.
     */
    width = 640;
    height = 480;
    bpp = info-&#62;vfmt-&#62;BitsPerPixel;

    /*
     * Now, we want to setup our requested
     * window attributes for our OpenGL window.
     * We want *at least* 5 bits of red, green
     * and blue. We also want at least a 16-bit
     * depth buffer.
     *
     * The last thing we do is request a double
     * buffered window. '1' turns on double
     * buffering, '0' turns it off.
     *
     * Note that we do not use SDL_DOUBLEBUF in
     * the flags to SDL_SetVideoMode. That does
     * not affect the GL attribute state, only
     * the standard 2D blitting setup.
     */
    SDL_GL_SetAttribute( SDL_GL_RED_SIZE, 5 );
    SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, 5 );
    SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, 5 );
    SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, 16 );
    SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );

    /*
     * We want to request that SDL provide us
     * with an OpenGL window, in a fullscreen
     * video mode.
     *
     * EXERCISE:
     * Make starting windowed an option, and
     * handle the resize events properly with
     * glViewport.
     */
    flags = SDL_OPENGL | SDL_FULLSCREEN;

    /*
     * Set the video mode
     */
    if( SDL_SetVideoMode( width, height, bpp, flags ) == 0 ) {
        /* 
         * This could happen for a variety of reasons,
         * including DISPLAY not being set, the specified
         * resolution not being available, etc.
         */
        fprintf( stderr, "Video mode set failed: %s\n",
             SDL_GetError( ) );
        quit_tutorial( 1 );
    }

    /*
     * At this point, we should have a properly setup
     * double-buffered window for use with OpenGL.
     */
    setup_opengl( width, height );

    /*
     * Now we want to begin our normal app process--
     * an event loop with a lot of redrawing.
     */
    while( 1 ) {
        /* Process incoming events. */
        process_events( );
        /* Draw the screen. */
        draw_screen( );
    }

    /*
     * EXERCISE:
     * Record timings using SDL_GetTicks() and
     * and print out frames per second at program
     * end.
     */

    /* Never reached. */
    return 0;
}</PRE
></DIV
></DIV
></DIV
><DIV
CLASS="NAVFOOTER"
><HR
ALIGN="LEFT"
WIDTH="100%"><TABLE
SUMMARY="Footer navigation table"
WIDTH="100%"
BORDER="0"
CELLPADDING="0"
CELLSPACING="0"
><TR
><TD
WIDTH="33%"
ALIGN="left"
VALIGN="top"
><A
HREF="guidevideo.html"
ACCESSKEY="P"
>Prev</A
></TD
><TD
WIDTH="34%"
ALIGN="center"
VALIGN="top"
><A
HREF="index.html"
ACCESSKEY="H"
>Home</A
></TD
><TD
WIDTH="33%"
ALIGN="right"
VALIGN="top"
><A
HREF="guideinput.html"
ACCESSKEY="N"
>Next</A
></TD
></TR
><TR
><TD
WIDTH="33%"
ALIGN="left"
VALIGN="top"
>Graphics and Video</TD
><TD
WIDTH="34%"
ALIGN="center"
VALIGN="top"
><A
HREF="guidevideo.html"
ACCESSKEY="U"
>Up</A
></TD
><TD
WIDTH="33%"
ALIGN="right"
VALIGN="top"
>Input handling</TD
></TR
></TABLE
></DIV
></BODY
></HTML
>
Commit	Line	Data
	1	<HTML
	2	><HEAD
	3	><TITLE
	4	>Using OpenGL With SDL</TITLE
	5	><META
	6	NAME="GENERATOR"
	7	CONTENT="Modular DocBook HTML Stylesheet Version 1.76b+
	8	"><LINK
	9	REL="HOME"
	10	TITLE="SDL Library Documentation"
	11	HREF="index.html"><LINK
	12	REL="UP"
	13	TITLE="Graphics and Video"
	14	HREF="guidevideo.html"><LINK
	15	REL="PREVIOUS"
	16	TITLE="Graphics and Video"
	17	HREF="guidevideo.html"><LINK
	18	REL="NEXT"
	19	TITLE="Input handling"
	20	HREF="guideinput.html"></HEAD
	21	><BODY
	22	CLASS="SECT1"
	23	BGCOLOR="#FFF8DC"
	24	TEXT="#000000"
	25	LINK="#0000ee"
	26	VLINK="#551a8b"
	27	ALINK="#ff0000"
	28	><DIV
	29	CLASS="NAVHEADER"
	30	><TABLE
	31	SUMMARY="Header navigation table"
	32	WIDTH="100%"
	33	BORDER="0"
	34	CELLPADDING="0"
	35	CELLSPACING="0"
	36	><TR
	37	><TH
	38	COLSPAN="3"
	39	ALIGN="center"
	40	>SDL Library Documentation</TH
	41	></TR
	42	><TR
	43	><TD
	44	WIDTH="10%"
	45	ALIGN="left"
	46	VALIGN="bottom"
	47	><A
	48	HREF="guidevideo.html"
	49	ACCESSKEY="P"
	50	>Prev</A
	51	></TD
	52	><TD
	53	WIDTH="80%"
	54	ALIGN="center"
	55	VALIGN="bottom"
	56	>Chapter 2. Graphics and Video</TD
	57	><TD
	58	WIDTH="10%"
	59	ALIGN="right"
	60	VALIGN="bottom"
	61	><A
	62	HREF="guideinput.html"
	63	ACCESSKEY="N"
	64	>Next</A
	65	></TD
	66	></TR
	67	></TABLE
	68	><HR
	69	ALIGN="LEFT"
	70	WIDTH="100%"></DIV
	71	><DIV
	72	CLASS="SECT1"
	73	><H1
	74	CLASS="SECT1"
	75	><A
	76	NAME="GUIDEVIDEOOPENGL"
	77	></A
	78	>Using OpenGL With SDL</H1
	79	><P
	80	>SDL has the ability to create and use OpenGL contexts on several platforms(Linux/X11, Win32, BeOS, MacOS Classic/Toolbox, Mac OS X, FreeBSD/X11 and Solaris/X11). This allows you to use SDL's audio, event handling, threads and times in your OpenGL applications (a function often performed by GLUT).</P
	81	><DIV
	82	CLASS="SECT2"
	83	><H2
	84	CLASS="SECT2"
	85	><A
	86	NAME="AEN103"
	87	></A
	88	>Initialisation</H2
	89	><P
	90	>Initialising SDL to use OpenGL is not very different to initialising SDL normally. There are three differences; you must pass <TT
	91	CLASS="LITERAL"
	92	>SDL_OPENGL</TT
	93	> to <A
	94	HREF="sdlsetvideomode.html"
	95	><TT
	96	CLASS="FUNCTION"
	97	>SDL_SetVideoMode</TT
	98	></A
	99	>, you must specify several GL attributes (depth buffer size, framebuffer sizes) using <A
	100	HREF="sdlglsetattribute.html"
	101	><TT
	102	CLASS="FUNCTION"
	103	>SDL_GL_SetAttribute</TT
	104	></A
	105	> and finally, if you wish to use double buffering you must specify it as a GL attribute, <SPAN
	106	CLASS="emphasis"
	107	><I
	108	CLASS="EMPHASIS"
	109	>not</I
	110	></SPAN
	111	> by passing the <TT
	112	CLASS="LITERAL"
	113	>SDL_DOUBLEBUF</TT
	114	> flag to <TT
	115	CLASS="FUNCTION"
	116	>SDL_SetVideoMode</TT
	117	>.</P
	118	><DIV
	119	CLASS="EXAMPLE"
	120	><A
	121	NAME="AEN114"
	122	></A
	123	><P
	124	><B
	125	>Example 2-7. Initializing SDL with OpenGL</B
	126	></P
	127	><PRE
	128	CLASS="PROGRAMLISTING"
	129	> /* Information about the current video settings. */
	130	const SDL_VideoInfo* info = NULL;
	131	/* Dimensions of our window. */
	132	int width = 0;
	133	int height = 0;
	134	/* Color depth in bits of our window. */
	135	int bpp = 0;
	136	/* Flags we will pass into SDL_SetVideoMode. */
	137	int flags = 0;
	138
	139	/* First, initialize SDL's video subsystem. */
	140	if( SDL_Init( SDL_INIT_VIDEO ) < 0 ) {
	141	/* Failed, exit. */
	142	fprintf( stderr, "Video initialization failed: %s\n",
	143	SDL_GetError( ) );
	144	quit_tutorial( 1 );
	145	}
	146
	147	/* Let's get some video information. */
	148	info = SDL_GetVideoInfo( );
	149
	150	if( !info ) {
	151	/* This should probably never happen. */
	152	fprintf( stderr, "Video query failed: %s\n",
	153	SDL_GetError( ) );
	154	quit_tutorial( 1 );
	155	}
	156
	157	/*
	158	* Set our width/height to 640/480 (you would
	159	* of course let the user decide this in a normal
	160	* app). We get the bpp we will request from
	161	* the display. On X11, VidMode can't change
	162	* resolution, so this is probably being overly
	163	* safe. Under Win32, ChangeDisplaySettings
	164	* can change the bpp.
	165	*/
	166	width = 640;
	167	height = 480;
	168	bpp = info->vfmt->BitsPerPixel;
	169
	170	/*
	171	* Now, we want to setup our requested
	172	* window attributes for our OpenGL window.
	173	* We want at least 5 bits of red, green
	174	* and blue. We also want at least a 16-bit
	175	* depth buffer.
	176	*
	177	* The last thing we do is request a double
	178	* buffered window. '1' turns on double
	179	* buffering, '0' turns it off.
	180	*
	181	* Note that we do not use SDL_DOUBLEBUF in
	182	* the flags to SDL_SetVideoMode. That does
	183	* not affect the GL attribute state, only
	184	* the standard 2D blitting setup.
	185	*/
	186	SDL_GL_SetAttribute( SDL_GL_RED_SIZE, 5 );
	187	SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, 5 );
	188	SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, 5 );
	189	SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, 16 );
	190	SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
	191
	192	/*
	193	* We want to request that SDL provide us
	194	* with an OpenGL window, in a fullscreen
	195	* video mode.
	196	*
	197	* EXERCISE:
	198	* Make starting windowed an option, and
	199	* handle the resize events properly with
	200	* glViewport.
	201	*/
	202	flags = SDL_OPENGL \| SDL_FULLSCREEN;
	203
	204	/*
	205	* Set the video mode
	206	*/
	207	if( SDL_SetVideoMode( width, height, bpp, flags ) == 0 ) {
	208	/*
	209	* This could happen for a variety of reasons,
	210	* including DISPLAY not being set, the specified
	211	* resolution not being available, etc.
	212	*/
	213	fprintf( stderr, "Video mode set failed: %s\n",
	214	SDL_GetError( ) );
	215	quit_tutorial( 1 );
	216	}</PRE
	217	></DIV
	218	></DIV
	219	><DIV
	220	CLASS="SECT2"
	221	><H2
	222	CLASS="SECT2"
	223	><A
	224	NAME="AEN117"
	225	></A
	226	>Drawing</H2
	227	><P
	228	>Apart from initialisation, using OpenGL within SDL is the same as using OpenGL
	229	with any other API, e.g. GLUT. You still use all the same function calls and
	230	data types. However if you are using a double-buffered display, then you must
	231	use
	232	<A
	233	HREF="sdlglswapbuffers.html"
	234	><TT
	235	CLASS="FUNCTION"
	236	>SDL_GL_SwapBuffers()</TT
	237	></A
	238	>
	239	to swap the buffers and update the display. To request double-buffering
	240	with OpenGL, use
	241	<A
	242	HREF="sdlglsetattribute.html"
	243	><TT
	244	CLASS="FUNCTION"
	245	>SDL_GL_SetAttribute</TT
	246	></A
	247	>
	248	with <TT
	249	CLASS="LITERAL"
	250	>SDL_GL_DOUBLEBUFFER</TT
	251	>, and use
	252	<A
	253	HREF="sdlglgetattribute.html"
	254	><TT
	255	CLASS="FUNCTION"
	256	>SDL_GL_GetAttribute</TT
	257	></A
	258	>
	259	to see if you actually got it.</P
	260	><P
	261	>A full example code listing is now presented below.</P
	262	><DIV
	263	CLASS="EXAMPLE"
	264	><A
	265	NAME="AEN128"
	266	></A
	267	><P
	268	><B
	269	>Example 2-8. SDL and OpenGL</B
	270	></P
	271	><PRE
	272	CLASS="PROGRAMLISTING"
	273	>/*
	274	* SDL OpenGL Tutorial.
	275	* (c) Michael Vance, 2000
	276	* briareos@lokigames.com
	277	*
	278	* Distributed under terms of the LGPL.
	279	*/
	280
	281	#include <SDL/SDL.h>
	282	#include <GL/gl.h>
	283	#include <GL/glu.h>
	284
	285	#include <stdio.h>
	286	#include <stdlib.h>
	287
	288	static GLboolean should_rotate = GL_TRUE;
	289
	290	static void quit_tutorial( int code )
	291	{
	292	/*
	293	* Quit SDL so we can release the fullscreen
	294	* mode and restore the previous video settings,
	295	* etc.
	296	*/
	297	SDL_Quit( );
	298
	299	/* Exit program. */
	300	exit( code );
	301	}
	302
	303	static void handle_key_down( SDL_keysym* keysym )
	304	{
	305
	306	/*
	307	* We're only interested if 'Esc' has
	308	* been presssed.
	309	*
	310	* EXERCISE:
	311	* Handle the arrow keys and have that change the
	312	* viewing position/angle.
	313	*/
	314	switch( keysym->sym ) {
	315	case SDLK_ESCAPE:
	316	quit_tutorial( 0 );
	317	break;
	318	case SDLK_SPACE:
	319	should_rotate = !should_rotate;
	320	break;
	321	default:
	322	break;
	323	}
	324
	325	}
	326
	327	static void process_events( void )
	328	{
	329	/* Our SDL event placeholder. */
	330	SDL_Event event;
	331
	332	/* Grab all the events off the queue. */
	333	while( SDL_PollEvent( &event ) ) {
	334
	335	switch( event.type ) {
	336	case SDL_KEYDOWN:
	337	/* Handle key presses. */
	338	handle_key_down( &event.key.keysym );
	339	break;
	340	case SDL_QUIT:
	341	/* Handle quit requests (like Ctrl-c). */
	342	quit_tutorial( 0 );
	343	break;
	344	}
	345
	346	}
	347
	348	}
	349
	350	static void draw_screen( void )
	351	{
	352	/* Our angle of rotation. */
	353	static float angle = 0.0f;
	354
	355	/*
	356	* EXERCISE:
	357	* Replace this awful mess with vertex
	358	* arrays and a call to glDrawElements.
	359	*
	360	* EXERCISE:
	361	* After completing the above, change
	362	* it to use compiled vertex arrays.
	363	*
	364	* EXERCISE:
	365	* Verify my windings are correct here ;).
	366	*/
	367	static GLfloat v0[] = { -1.0f, -1.0f, 1.0f };
	368	static GLfloat v1[] = { 1.0f, -1.0f, 1.0f };
	369	static GLfloat v2[] = { 1.0f, 1.0f, 1.0f };
	370	static GLfloat v3[] = { -1.0f, 1.0f, 1.0f };
	371	static GLfloat v4[] = { -1.0f, -1.0f, -1.0f };
	372	static GLfloat v5[] = { 1.0f, -1.0f, -1.0f };
	373	static GLfloat v6[] = { 1.0f, 1.0f, -1.0f };
	374	static GLfloat v7[] = { -1.0f, 1.0f, -1.0f };
	375	static GLubyte red[] = { 255, 0, 0, 255 };
	376	static GLubyte green[] = { 0, 255, 0, 255 };
	377	static GLubyte blue[] = { 0, 0, 255, 255 };
	378	static GLubyte white[] = { 255, 255, 255, 255 };
	379	static GLubyte yellow[] = { 0, 255, 255, 255 };
	380	static GLubyte black[] = { 0, 0, 0, 255 };
	381	static GLubyte orange[] = { 255, 255, 0, 255 };
	382	static GLubyte purple[] = { 255, 0, 255, 0 };
	383
	384	/* Clear the color and depth buffers. */
	385	glClear( GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT );
	386
	387	/* We don't want to modify the projection matrix. */
	388	glMatrixMode( GL_MODELVIEW );
	389	glLoadIdentity( );
	390
	391	/* Move down the z-axis. */
	392	glTranslatef( 0.0, 0.0, -5.0 );
	393
	394	/* Rotate. */
	395	glRotatef( angle, 0.0, 1.0, 0.0 );
	396
	397	if( should_rotate ) {
	398
	399	if( ++angle > 360.0f ) {
	400	angle = 0.0f;
	401	}
	402
	403	}
	404
	405	/* Send our triangle data to the pipeline. */
	406	glBegin( GL_TRIANGLES );
	407
	408	glColor4ubv( red );
	409	glVertex3fv( v0 );
	410	glColor4ubv( green );
	411	glVertex3fv( v1 );
	412	glColor4ubv( blue );
	413	glVertex3fv( v2 );
	414
	415	glColor4ubv( red );
	416	glVertex3fv( v0 );
	417	glColor4ubv( blue );
	418	glVertex3fv( v2 );
	419	glColor4ubv( white );
	420	glVertex3fv( v3 );
	421
	422	glColor4ubv( green );
	423	glVertex3fv( v1 );
	424	glColor4ubv( black );
	425	glVertex3fv( v5 );
	426	glColor4ubv( orange );
	427	glVertex3fv( v6 );
	428
	429	glColor4ubv( green );
	430	glVertex3fv( v1 );
	431	glColor4ubv( orange );
	432	glVertex3fv( v6 );
	433	glColor4ubv( blue );
	434	glVertex3fv( v2 );
	435
	436	glColor4ubv( black );
	437	glVertex3fv( v5 );
	438	glColor4ubv( yellow );
	439	glVertex3fv( v4 );
	440	glColor4ubv( purple );
	441	glVertex3fv( v7 );
	442
	443	glColor4ubv( black );
	444	glVertex3fv( v5 );
	445	glColor4ubv( purple );
	446	glVertex3fv( v7 );
	447	glColor4ubv( orange );
	448	glVertex3fv( v6 );
	449
	450	glColor4ubv( yellow );
	451	glVertex3fv( v4 );
	452	glColor4ubv( red );
	453	glVertex3fv( v0 );
	454	glColor4ubv( white );
	455	glVertex3fv( v3 );
	456
	457	glColor4ubv( yellow );
	458	glVertex3fv( v4 );
	459	glColor4ubv( white );
	460	glVertex3fv( v3 );
	461	glColor4ubv( purple );
	462	glVertex3fv( v7 );
	463
	464	glColor4ubv( white );
	465	glVertex3fv( v3 );
	466	glColor4ubv( blue );
	467	glVertex3fv( v2 );
	468	glColor4ubv( orange );
	469	glVertex3fv( v6 );
	470
	471	glColor4ubv( white );
	472	glVertex3fv( v3 );
	473	glColor4ubv( orange );
	474	glVertex3fv( v6 );
	475	glColor4ubv( purple );
	476	glVertex3fv( v7 );
	477
	478	glColor4ubv( green );
	479	glVertex3fv( v1 );
	480	glColor4ubv( red );
	481	glVertex3fv( v0 );
	482	glColor4ubv( yellow );
	483	glVertex3fv( v4 );
	484
	485	glColor4ubv( green );
	486	glVertex3fv( v1 );
	487	glColor4ubv( yellow );
	488	glVertex3fv( v4 );
	489	glColor4ubv( black );
	490	glVertex3fv( v5 );
	491
	492	glEnd( );
	493
	494	/*
	495	* EXERCISE:
	496	* Draw text telling the user that 'Spc'
	497	* pauses the rotation and 'Esc' quits.
	498	* Do it using vetors and textured quads.
	499	*/
	500
	501	/*
	502	* Swap the buffers. This this tells the driver to
	503	* render the next frame from the contents of the
	504	* back-buffer, and to set all rendering operations
	505	* to occur on what was the front-buffer.
	506	*
	507	* Double buffering prevents nasty visual tearing
	508	* from the application drawing on areas of the
	509	* screen that are being updated at the same time.
	510	*/
	511	SDL_GL_SwapBuffers( );
	512	}
	513
	514	static void setup_opengl( int width, int height )
	515	{
	516	float ratio = (float) width / (float) height;
	517
	518	/* Our shading model--Gouraud (smooth). */
	519	glShadeModel( GL_SMOOTH );
	520
	521	/* Culling. */
	522	glCullFace( GL_BACK );
	523	glFrontFace( GL_CCW );
	524	glEnable( GL_CULL_FACE );
	525
	526	/* Set the clear color. */
	527	glClearColor( 0, 0, 0, 0 );
	528
	529	/* Setup our viewport. */
	530	glViewport( 0, 0, width, height );
	531
	532	/*
	533	* Change to the projection matrix and set
	534	* our viewing volume.
	535	*/
	536	glMatrixMode( GL_PROJECTION );
	537	glLoadIdentity( );
	538	/*
	539	* EXERCISE:
	540	* Replace this with a call to glFrustum.
	541	*/
	542	gluPerspective( 60.0, ratio, 1.0, 1024.0 );
	543	}
	544
	545	int main( int argc, char* argv[] )
	546	{
	547	/* Information about the current video settings. */
	548	const SDL_VideoInfo* info = NULL;
	549	/* Dimensions of our window. */
	550	int width = 0;
	551	int height = 0;
	552	/* Color depth in bits of our window. */
	553	int bpp = 0;
	554	/* Flags we will pass into SDL_SetVideoMode. */
	555	int flags = 0;
	556
	557	/* First, initialize SDL's video subsystem. */
	558	if( SDL_Init( SDL_INIT_VIDEO ) < 0 ) {
	559	/* Failed, exit. */
	560	fprintf( stderr, "Video initialization failed: %s\n",
	561	SDL_GetError( ) );
	562	quit_tutorial( 1 );
	563	}
	564
	565	/* Let's get some video information. */
	566	info = SDL_GetVideoInfo( );
	567
	568	if( !info ) {
	569	/* This should probably never happen. */
	570	fprintf( stderr, "Video query failed: %s\n",
	571	SDL_GetError( ) );
	572	quit_tutorial( 1 );
	573	}
	574
	575	/*
	576	* Set our width/height to 640/480 (you would
	577	* of course let the user decide this in a normal
	578	* app). We get the bpp we will request from
	579	* the display. On X11, VidMode can't change
	580	* resolution, so this is probably being overly
	581	* safe. Under Win32, ChangeDisplaySettings
	582	* can change the bpp.
	583	*/
	584	width = 640;
	585	height = 480;
	586	bpp = info->vfmt->BitsPerPixel;
	587
	588	/*
	589	* Now, we want to setup our requested
	590	* window attributes for our OpenGL window.
	591	* We want at least 5 bits of red, green
	592	* and blue. We also want at least a 16-bit
	593	* depth buffer.
	594	*
	595	* The last thing we do is request a double
	596	* buffered window. '1' turns on double
	597	* buffering, '0' turns it off.
	598	*
	599	* Note that we do not use SDL_DOUBLEBUF in
	600	* the flags to SDL_SetVideoMode. That does
	601	* not affect the GL attribute state, only
	602	* the standard 2D blitting setup.
	603	*/
	604	SDL_GL_SetAttribute( SDL_GL_RED_SIZE, 5 );
	605	SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, 5 );
	606	SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, 5 );
	607	SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, 16 );
	608	SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
	609
	610	/*
	611	* We want to request that SDL provide us
	612	* with an OpenGL window, in a fullscreen
	613	* video mode.
	614	*
	615	* EXERCISE:
	616	* Make starting windowed an option, and
	617	* handle the resize events properly with
	618	* glViewport.
	619	*/
	620	flags = SDL_OPENGL \| SDL_FULLSCREEN;
	621
	622	/*
	623	* Set the video mode
	624	*/
	625	if( SDL_SetVideoMode( width, height, bpp, flags ) == 0 ) {
	626	/*
	627	* This could happen for a variety of reasons,
	628	* including DISPLAY not being set, the specified
	629	* resolution not being available, etc.
	630	*/
	631	fprintf( stderr, "Video mode set failed: %s\n",
	632	SDL_GetError( ) );
	633	quit_tutorial( 1 );
	634	}
	635
	636	/*
	637	* At this point, we should have a properly setup
	638	* double-buffered window for use with OpenGL.
	639	*/
	640	setup_opengl( width, height );
	641
	642	/*
	643	* Now we want to begin our normal app process--
	644	* an event loop with a lot of redrawing.
	645	*/
	646	while( 1 ) {
	647	/* Process incoming events. */
	648	process_events( );
	649	/* Draw the screen. */
	650	draw_screen( );
	651	}
	652
	653	/*
	654	* EXERCISE:
	655	* Record timings using SDL_GetTicks() and
	656	* and print out frames per second at program
	657	* end.
	658	*/
	659
	660	/* Never reached. */
	661	return 0;
	662	}</PRE
	663	></DIV
	664	></DIV
	665	></DIV
	666	><DIV
	667	CLASS="NAVFOOTER"
	668	><HR
	669	ALIGN="LEFT"
	670	WIDTH="100%"><TABLE
	671	SUMMARY="Footer navigation table"
	672	WIDTH="100%"
	673	BORDER="0"
	674	CELLPADDING="0"
	675	CELLSPACING="0"
	676	><TR
	677	><TD
	678	WIDTH="33%"
	679	ALIGN="left"
	680	VALIGN="top"
	681	><A
	682	HREF="guidevideo.html"
	683	ACCESSKEY="P"
	684	>Prev</A
	685	></TD
	686	><TD
	687	WIDTH="34%"
	688	ALIGN="center"
	689	VALIGN="top"
	690	><A
	691	HREF="index.html"
	692	ACCESSKEY="H"
	693	>Home</A
	694	></TD
	695	><TD
	696	WIDTH="33%"
	697	ALIGN="right"
	698	VALIGN="top"
	699	><A
	700	HREF="guideinput.html"
	701	ACCESSKEY="N"
	702	>Next</A
	703	></TD
	704	></TR
	705	><TR
	706	><TD
	707	WIDTH="33%"
	708	ALIGN="left"
	709	VALIGN="top"
	710	>Graphics and Video</TD
	711	><TD
	712	WIDTH="34%"
	713	ALIGN="center"
	714	VALIGN="top"
	715	><A
	716	HREF="guidevideo.html"
	717	ACCESSKEY="U"
	718	>Up</A
	719	></TD
	720	><TD
	721	WIDTH="33%"
	722	ALIGN="right"
	723	VALIGN="top"
	724	>Input handling</TD
	725	></TR
	726	></TABLE
	727	></DIV
	728	></BODY
	729	></HTML
	730	>