Introduction

In order to quickly test out OpenGL code it is useful to be able to easily embed it in a windowing application.
Mark J. Kilgard's GLUT framework is what we have been using to do this (Later ported to MS Windows by Nate Robins).
Most of the development of GLUT occurred before 1996 and totally ceased after 2001.
GLUT had two notable successors: FreeGLUT (Olszta/Baker/Fay) and OpenGLUT. The aim of the former was to keep the old style GLUT working as hardware platforms changed. The goal of the latter was to add useful new features more in line with windowing, inputting, etc is done on modern hardware.
Development on OpenGLUT has ceased since 2005.
The GLUT code still works, and is used in the book's code, but I think it would be cool to explore a more recent framework -- SDL.

SDL

SDL (Simple Direct Media Layer) is a C library that provides interfaces to the graphics, sound, and input devices of your computer.
Recall GLUT only handled graphics and older style input devices so was less useful for games. Also, GLUT doesn't support reading in image files but SDL does.
It works on Android, iOS, Linux, Mac OSX, and Windows.
It has been used in over 700 games (BTW, this fact sheet is largely courtesy of our friend Wikipedia).
The most recent stable release is 2.01 which came out in October, 2013.
The library itself dates back to 1998 and was initially written by Sam Lantinga at Loki Software who used it to port Doom to BeOS.

Setting up an SDL Environment

The first step is of course to download SDL.
For Windows you want the development libraries not just the runtime.
The Mac OSX download is a dmg file.
For Linux and the others you should try compiling from the source file.
In setting up your project, you want to follow the basic instructions we were using earlier to make a empty console application. After downloading and unzipping the SDL2 folder, navigate to the lib subfolder. Copy the file SDL2.dll file to C:\Windows\SysWOW64. Next copy SDL2.lib, SDL2main.lib, and SDL2test.lib to
C:\Program Files(x86)\Visual Studio 12.0\VC\lib
If you have a different version of Visual Studio the above might be different. Finally, make a folder
C:\Program Files(x86)\Visual Studio 12.0\VC\include\SDL2
Navigate to the include subfolder of the SDL2 folder you downloaded and copy all the header files you find there into the folder you just made. You now have all the libraries in the correct place. When you make a new empty project, be sure to click on the project in the Solution Explorer and hit Alt-ENTER to bring up the Project Settings. Go to Configuration Properties - Linker - Input - Additional Dependencies and add glew32.lib;glu32.lib;OpenGL32.lib;SDL2.lib;SDL2_image.lib. (We'll actually say next day how to install SDL_image).
On a Mac, after opening the dmg file you get a folder with SDL2.framework in it. You want to move this /Library/Frameworks. Then create a OSX - Other - Empty project. In the top menu, click on Editor and select Add Target. Choose Application - Command Line Tool. Give your target a Name (say Hw2.cpp or CApp.cpp). This will create a folder in your Project Navigator with that name. In it will be a file main.cpp with a C++ Hello World program. You can rename this file as you like. If you rename it, click on the project in the Project Navigator then Build Phases and change the Compile Source to the new name (if it doesn't change automatically). In Build Phases, where it says Link Binaries with Libraries, click + and add the SDL2.framework. It might not show up in the initial list, so click Add other and navigate to /Library/Frameworks to find it.
For Linux people, you basically, want to add to your Makefile the appropriate path to the lib and include directories where SDL lives. (-I and -L directives)

First App -- Header File

Let's first create a simple app that does nothing, but does compile and execute. It will have the basic functions for a larger project. First, let's create the following header file MySdlApplication.h and add it to our project.

#ifndef _MYSDLAPPLICATION_H_
#define _MYSDLAPPLICATION_H_

#include <iostream>
#include <SDL2/SDL.h>
//Windows gets confused on main the entry point because of SDL, so ...
#ifdef __WIN32__
    #undef main
#endif

class MySdlApplication
{
    private:
        bool running;

    public:
        MySdlApplication();

        int onExecute();

        bool onInit();

        void onEvent(SDL_Event* event);

        void onLoop();

        void onRender();

        void onCleanup();
};

#endif

First App -- Implementation File

/**
   MySdlApplication

   Created by Chris Pollett on 2/19/14.

*/

#include "MySdlApplication.h"

MySdlApplication::MySdlApplication() {
    running = true;
}

bool MySdlApplication::onInit() {
    return true;
}

void MySdlApplication::onEvent(SDL_Event* event) {
}

void MySdlApplication::onLoop() {
}

void MySdlApplication::onRender() {
}

void MySdlApplication::onCleanup() {
}

int MySdlApplication::onExecute() {
    if(onInit() == false) {
        return -1;
    }

    SDL_Event Event;

    while(running) {
        while(SDL_PollEvent(&event)) {
            onEvent(&event);
        }

        onLoop();
        onRender();
    }

    onCleanup();

    return 0;
}

int main(int argc, const char * argv[])
{
    MySdlApplication application;
    std::cout << "Hello, World!\n";
    return application.onExecute();
}

Remarks

You can think of the MySdlApplication class as like the class JApplet, except here we are writing the code ourselves.
main calls onExcecute. This in turn calls our onInit() function where we could set up our window, OpenGL, etc.
Then we have the while loop is our basic event loop. We call SDL_PollEvent(&Event) to see if SDL has detected an Event and if so we call our onEvent function to handle it.
onLoop could be used to handle any data updates of objects in our scene.
onRender then could be used to redraw the scene.
If running becomes false, for example we set it false when someone hits a quit key, then onExecutes calls onCleanup to discard stuff nicely, and then exits.

Making a Simple Window, Responding to a Close Window Event

It's time to make a Window. To do this, we can add the variable SDL_Window* display; to our header, and we can change onInit to:

bool MySdlApplication::onInit() {
    if(SDL_Init(SDL_INIT_EVERYTHING) < 0) {
        return false;
    }

    if((display = SDL_CreateWindow("My SDL Application",
        SDL_WINDOWPOS_UNDEFINED, 
        SDL_WINDOWPOS_UNDEFINED, 640, 480,
        SDL_WINDOW_OPENGL)) == NULL) {
        return false;
    }

    return true;
}

The first argument is what should appear in the title bar of our window.
The next two arguments say where on the screen to draw it. We can give an absolute position or as above let the windowing system figure it out. Another possibility is SDL_WINDOWPOS_CENTERED.
The 640 and 480 say the width and height of the window we want to create.
Finally, SDL_WINDOW_OPENGL says we want an OpenGL window. We could have |'d this with other flags like SDL_WINDOW_FULLSCREEN, SDL_WINDOW_FULLSCREEN_DESKTOP (uses current desktop resolution).

To handle the window close Event, we change onEvent to:

void MySdlApplication::onEvent(SDL_Event* event) {
    if(event->type == SDL_QUIT) {
        running = false;
    }
}

Events

The SDL_Event union looks like:

typedef union{
  Uint8 type;
  SDL_ActiveEvent active;
  SDL_KeyboardEvent key;
  SDL_MouseMotionEvent motion;
  SDL_MouseButtonEvent button;
  SDL_JoyAxisEvent jaxis;
  SDL_JoyBallEvent jball;
  SDL_JoyHatEvent jhat;
  SDL_JoyButtonEvent jbutton;
  SDL_ResizeEvent resize;
  SDL_ExposeEvent expose;
  SDL_QuitEvent quit;
  SDL_UserEvent user;
  SDL_SysWMEvent syswm;
} SDL_Event;

type can be one of SDL_KEYDOWN, SDL_KEYUP, SDL_ACTIVEEVENT, SDL_MOUSEMOTION, SDL_MOUSEBUTTONDOWN SDL_MOUSEBUTTONUP, SDL_JOYAXISMOTION, SDL_JOYBALLMOTION, SDL_JOYHATMOTION, SDL_JOYBUTTONDOWN, SDL_JOYBUTTONUP, SDL_QUIT, SDL_SYSWMEVENT, SDL_VIDEORESIZE, SDL_VIDEOEXPOSE, SDL_USEREVENT
If the type is SDL_KEYDOWN, SDL_KEYUP, we will typically be interested in event.key to find out what key was pressed.
We can call SDL_GetKeyName(event.key) to get the actual key pressed.

SDL

Outline