[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
e14743d1	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	>