Home > Articles > Programming > Graphic Programming

📄 Contents

  1. Overview
  2. Configuration and Setup
  3. Summary
  • Print
  • + Share This
This chapter is from the book

Configuration and Setup

Configuring and using GLUT is pretty straightforward, and given what we've covered in prior chapters, it should all feel somewhat familiar. We'll waste no time in this section; we'll just jump right into a code example and cover the only Mac-specific change you'll need to be aware of for GLUT applications on the Mac.

Begin by going to XCode and creating a new project, of type C++ tool, as seen in Figure 9-2. We're choosing a C++ project just because we feel like it and prefer some C++ idioms, rather than because GLUT requires C++. In fact, as mentioned earlier, GLUT is a C-API.

Figure 9-2

Figure 9-2 New Project Creation for GLUT Application

In Figure 9-2, we create a new project; in Figure 9-3, we add the GLUT framework; and in Figure 9-4, we see what the resultant framework should look like. Specifically, in Figure 9-3, navigate to /System/Library/Frameworks/ and select GLUT.framework to add to the project.

Figure 9-3

Figure 9-3 Adding a Framework to This Project

Figure 9-4

Figure 9-4 Resultant GLUT Project Showing Framework and Sample Code

Now that we've got a project, we must address the first Mac-specific element—linking against the library. We do that as seen in Figure 9-3, with the result shown in Figure 9-4. This specifies that we will use the GLUT framework to resolve include files and link libraries. The only other Mac-specific element is the way in which we include the headers, as seen in Figure 9-3. On other platforms, the GLUT headers may live in different directories (in fact, they usually live in the GL directory), so some wrangling is necessary to ensure that your compiler can find the header file. The code in Example 9-1 performs this operation to include the glut.h header using a preprocessor check to determine whether we're building on the Mac and, if so, to adjust where we find GLUT to use the framework-resolved path. Those are really the only two unique elements to using GLUT on the Mac.

Simple enough. Now let's look at fleshing out this code.

Example 9-1. GLUT Header Inclusion on the Mac

#if defined( __APPLE__ )
#include <GLUT/glut.h>
#include <GL/glut.h>

Pixel Format

We'll now look at a complete application, from window creation to GL initialization through swap buffers. This code is presented here for your edification, but not because we plan to explain it in painstaking detail. As we've said before, GLUT is GLUT is GLUT. You'll find that the code we write here will function on many platforms, and the GLUT examples on the Mac are a great way to learn more about how to use the API. In fact, Apple ships a complete set of GLUT examples with its developer tools; you'll find them in /Developer/Examples/OpenGL/GLUT/. Now, let's move on to our code. It renders a simple animated shape, but doesn't do much else. The results of Example 9-2 are seen in Figure 9-5.

Example 9-2. Basic GLUT Sample Application

void prepareOpenGL()
    myAngle = 0;
    myTime = 0;

void draw()
    glClearColor( 0, .5, .8, 1 );

    glMatrixMode( GL_MODELVIEW );
    glRotatef( myAngle, 0, 0, 1 );

    glTranslatef( 0, 0, 1 );
    glColor3f( 0, 1, 0 );
    glBegin( GL_QUADS );
    float ww = .9;
    float hh = .9;
    glTexCoord2f( 0, 0 );
    glVertex3f( -ww, -hh, 0 );
    glTexCoord2f( 1, 0 );
    glVertex3f( ww, -hh, 0 );
    glTexCoord2f( 1, 1 );
    glVertex3f( ww, hh, 0 );
    glTexCoord2f( 0, 1 );
    glVertex3f( -ww, hh, 0 );


void angleUpdate( int delay )
    float twopi = 2*M_PI;
    myTime = (myTime>twopi)?0:myTime+.03;
    myAngle = sinf(twopi*myTime);
    glutTimerFunc( delay, angleUpdate, delay );

int main ( int argc, char * argv[] )
    glutInit( &argc, argv );

    // choose a visual and create a window
    glutInitDisplayString( "stencil>=2 rgb8 double depth>=16" );
    // this is comparable to glutInitDisplayMode with the
    // tokens below, and achieves a similar effect
    // glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH );

    glutInitWindowSize( 450, 300 );
    glutCreateWindow( "GLUT Configuration Example" );

    // initialize our opengl (context is now valid)

    // register callback functions
    int delay = 50;
    glutTimerFunc( delay, angleUpdate, delay );
    glutDisplayFunc( draw );
Figure 9-5

Figure 9-5 GLUT Project Results Showing Visual Selection and Rendered Object

GLUT is a good way to bring up a rendering window quickly and efficiently. It also provides a fair degree of specificity for window management. You can use the glutInitDisplayMode, as shown in Example 9-2, to specify a variety of flags to set the visual that is used. For example, you can use any combination of the bit flags as described in Table 9-2 to customize which visual you use. These bit fields are described in complete detail in the glutInitDisplayMode manual page, and we present only a few in Table 9-2. A simplified version of the use of this visual specification was presented in Example 9-2. This function, along with its bit field settings, allows you a coarse degree of control in the visual qualities of your application.

Table 9-2. glutInitDisplayMode Bit Field Tokens




Synonymous tokens to select a visual with RGBA pixel formats. The default if no other format is specified.


Single-buffered visual token. The default if neither GLUT_DOUBLE nor GLUT_SINGLE is present.


Double-buffered visual token. Has priority if GLUT_SINGLE is also present.


Token for accumulation buffer visuals.


Token to choose alpha channel visuals.


Token to select a depth-buffered visual.


Token to select a stencil-buffered visual.


Token to select a multisample visual. Automatically degrades to another visual if multisampling is not available.


Token to select a visual with stereo abilities.

As we've seen in other chapters, selecting a visual can be a very detailed process, and one that your application needs to specify fully. GLUT provides a limited form of this capability through a complementary function called glutInitDisplayString. In no way is the GLUT process nearly as complete as the CGL, AGL, or Cocoa methods, but it does allow you to exert a fair degree of control. Among the capabilities exposed through this method, a caller can specify the number of bits in various color or depth channels, the number of samples in multisample visuals, and the policy regarding how to select which visual matches. We present a selection of states that can be specified through such a call in Table 9-3, and a complete description of these flags and their defaults can be found at the manual page: man glutInitDisplayString.

Table 9-3. glutInitDisplayString Policy and Capability Strings




Bits of alpha channel color buffer precision


Bits of red channel color buffer precision


Bits of green channel color buffer precision


Bits of blue channel color buffer precision


Bits of red, green, blue, and alpha channels color buffer precision


Bits of RGBA channels accumulation buffer precision


Bits of depth channel buffer precision


Bits of depth channel buffer precision


Boolean enabling single buffer mode


Boolean enabling double buffer mode


Boolean enabling quad buffer stereo mode


Number of multisamples to use

So how are these flags used to specify a visual? The tokens in Table 9-3 specify the individual visual elements to be specified. With each, we can also attach an optional policy. The code for doing so requires the use of a standard set of operators with meanings equivalent to those operators' meanings in C code. For example, to specify a visual with all buffer bits, including alpha, of depth 8 or greater, we would write rgba>=8 as part of our overall string. For other specifications, such as to consider visuals of other constraints, we would use any one of <,>,<=,>=,=, or !=. A final syntax element, the character, is used to specify a match that is greater than or equal to the number specified, but preferring fewer bits rather than more. This is a good way of getting close to your literal specification, but with some fail-over capability, preferring visuals of better quality.

For a complete example of how this specification works, we'll examine a replacement for the call glutInitDisplayString in our previous example but now modify it to use this form of visual selection instead. Example 9-3 is set up to try to find a visual with at least 2 bits of stencil precision, double buffered, with an RGBA visual of 8 or greater bits, as closely matching 8 as possible, a 16-bit or greater depth, and multisample anti-aliasing. The results of this change to Example 9-2 are subtle, because the only differences involve the addition of the stencil and anti-aliasing. The results of the anti-aliasing are visible in Figure 9-6.

Figure 9-6

Figure 9-6 GLUT Project Results Showing Visual Selection and Rendered Object for Anti-Aliased Pixel Format

For a much more verbose description of these flags, ways to use this initialization call, and more, check the manual page for this call using man glutInitDisplayString.

Example 9-3. Initializing a GLUT Visual Using a String

glutInitDisplayString("stencil>=2 rgb~8 double depth>=16 samples");
  • + Share This
  • 🔖 Save To Your Account