docs/html/guidevideoopengl.html

   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 ) &#60; 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-&#62;vfmt-&#62;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 &#60;SDL/SDL.h&#62;
 282 #include &#60;GL/gl.h&#62;
 283 #include &#60;GL/glu.h&#62;
 284
 285 #include &#60;stdio.h&#62;
 286 #include &#60;stdlib.h&#62;
 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-&#62;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( &#38;event ) ) {
 334
 335         switch( event.type ) {
 336         case SDL_KEYDOWN:
 337             /* Handle key presses. */
 338             handle_key_down( &#38;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 &#62; 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 ) &#60; 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-&#62;vfmt-&#62;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 >