anaglyph.cpp

Go to the documentation of this file.

/*
 * This work is licensed under a Creative Commons 
 * Attribution-Noncommercial-Share Alike 3.0 United States License.
 * 
 *    http://creativecommons.org/licenses/by-nc-sa/3.0/us/
 * 
 * You are free:
 * 
 *    to Share - to copy, distribute, display, and perform the work
 *    to Remix - to make derivative works
 * 
 * Under the following conditions:
 * 
 *    Attribution. You must attribute the work in the manner specified by the
 *    author or licensor (but not in any way that suggests that they endorse you
 *    or your use of the work).
 * 
 *    Noncommercial. You may not use this work for commercial purposes.
 * 
 *    Share Alike. If you alter, transform, or build upon this work, you may
 *    distribute the resulting work only under the same or similar license to
 *    this one.
 * 
 * For any reuse or distribution, you must make clear to others the license
 * terms of this work. The best way to do this is by including this header.
 * 
 * Any of the above conditions can be waived if you get permission from the
 * copyright holder.
 * 
 * Apart from the remix rights granted under this license, nothing in this
 * license impairs or restricts the author's moral rights.
 */


#include <config.h>

#include <cstdlib>
#include <cstdio>
#include <cassert>
#include <cmath>
#include <cstring>

#include <inttypes.h>

#if defined ANAGLYPH_HAVE_OPENGL
#include <GL/gl.h>
#include <GL/glu.h>
#endif

#if defined ANAGLYPH_HAVE_GLUT_FRAMEWORK
#include <GLUT/glut.h>
#elif defined ANAGLYPH_HAVE_GLUT
#include <GL/glut.h>
#endif

#include <jwsc/math/constants.h>
#include <jwsc/vector/vector.h>
#include <jwsc/vector/vector_math.h>
#include <jwsc/matrix/matrix.h>
#include <jwsc/matrix/matrix_math.h>
#include <jwsc/image/image.h>
#include <jwsc/image/image_io.h>

#include <jwsc++/base/option.h>
#include <jwsc++/base/exception.h>
#include <jwsc++/graphics/camera.h>

#ifdef ANAGLYPH_HAVE_DMALLOC
#include <dmalloc.h>
#endif


/* Anaglyph glasses filter types. */
#define REDBLUE  1
#define REDGREEN 2
#define REDCYAN  3
#define BLUERED  4
#define GREENRED 5
#define CYANRED  6

/* Program defaults. */
#define  DEFAULT_VIEW_WIDTH      400
#define  DEFAULT_VIEW_HEIGHT     400
#define  DEFAULT_APERTURE        60.0f
#define  DEFAULT_CLIP_NEAR       10.0f
#define  DEFAULT_CLIP_FAR        3000.0f
#define  DEFAULT_GLASSES_TYPE    REDCYAN
#define  DEFAULT_SCALE           1.0
#define  DEFAULT_SEED            2537984
#define  DEFAULT_CAPTURE_NAME    "capture.tiff"


using std::cout;
using std::cerr;
using std::sscanf;
using std::sprintf;
using namespace jwsc;
using namespace jwscxx::base;
using namespace jwscxx::graphics;


Options* opts = 0;

uint32_t view_width = DEFAULT_VIEW_WIDTH;

uint32_t view_height = DEFAULT_VIEW_HEIGHT;

float aperture = DEFAULT_APERTURE;

float clip_near = DEFAULT_CLIP_NEAR;

float clip_far = DEFAULT_CLIP_FAR;

int glasses_type = DEFAULT_GLASSES_TYPE;

float scale = DEFAULT_SCALE;

uint32_t seed = DEFAULT_SEED;

const char* capture_fname = DEFAULT_CAPTURE_NAME;

Stereo_camera_f* camera = 0;

GLUquadric* quad_fill = 0;

GLUquadric* quad_wire = 0;

enum Object_type
{
    SOLID_SPHERE, SOLID_CUBE, SOLID_TORUS, SOLID_TEAPOT,
    WIRE_SPHERE, WIRE_CUBE, WIRE_TORUS, WIRE_TEAPOT
};


struct Modes
{
    bool translate_camera;

    bool rotate_camera;

    bool capture_view;

    bool anaglyph;

    bool render_focal_plane;

    bool render_world_axis;

    bool focal_prp;

    bool focal_vrp;

    enum Object_type object;
}
modes;


void init_modes()
{
    modes.translate_camera   = false;
    modes.rotate_camera      = true;
    modes.capture_view       = false;
    modes.anaglyph           = false;
    modes.render_focal_plane = true;
    modes.render_world_axis  = true;
    modes.focal_prp          = false;
    modes.focal_vrp          = true;
    modes.object             = SOLID_TEAPOT;
}


void init_camera() throw (Arg_error)
{
    delete camera;

    camera = new Stereo_camera_f(0, 0, 1000, 0, 0, 0, 0, 1, 0, aperture, 
            clip_near, clip_far);
}


void clean_up()
{
    delete camera;
    delete opts;
    gluDeleteQuadric(quad_fill);
    gluDeleteQuadric(quad_wire);
}


void reset()
{
    scale    = DEFAULT_SCALE;
    aperture = DEFAULT_APERTURE;
    init_camera();
    init_modes();
}


void capture_view()
{
    static uint32_t capture_num = 1;

    char  fname_buf       [ 256 ] = { 0 };
    char  fname_suffix_buf[ 256 ] = { 0 };
    char* fname_suffix;

    strncpy(fname_buf, capture_fname, 250);

    if ((fname_suffix = strstr(fname_buf, ".")) != NULL)
    {
        strncpy(fname_suffix_buf, fname_suffix, 250);
    }
    else
    {
        fname_suffix = fname_buf + strlen(fname_buf);
    }

    sprintf(fname_suffix, "-%04d%s", capture_num, fname_suffix_buf);

    camera->capture_gl_view(fname_buf, capture_num);

    capture_num++;
}


void render_world_axis()
{
    static GLfloat amb_dif[4] = {0, 0, 0, 1.0f};

    glMatrixMode(GL_MODELVIEW);

    glPushMatrix();

    float axis_length  = 100.0f;
    float arrow_radius = axis_length / 10.0f;
    float arrow_height = axis_length / 5.0f;

    /* X */
    amb_dif[0] = 0.9f;  amb_dif[1] = 1.0f;  amb_dif[2] = 0.3f;
    glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, amb_dif);
    glPushMatrix();
      glRotatef(90, 0, 1.0f, 0);
      gluCylinder(quad_fill, 1, 1, axis_length - 0.5f*arrow_height, 8, 1);
    glPopMatrix();
    glPushMatrix();
      glTranslatef(axis_length - arrow_height, 0, 0);
      glRotatef(90, 0, 1.0f, 0);
      gluCylinder(quad_fill, arrow_radius, 0, arrow_height, 16, 8);
    glPopMatrix();

    /* Y */
    amb_dif[0] = 0.9f;  amb_dif[1] = 1.0f;  amb_dif[2] = 0.3f;
    glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, amb_dif);
    glPushMatrix();
      glRotatef(-90, 1.0f, 0, 0);
      gluCylinder(quad_fill, 1, 1, axis_length - 0.5f*arrow_height, 8, 1);
    glPopMatrix();
    glPushMatrix();
      glTranslatef(0, axis_length - arrow_height, 0);
      glRotatef(-90, 1.0f, 0, 0);
      gluCylinder(quad_fill, arrow_radius, 0, arrow_height, 16, 8);
    glPopMatrix();

    /* Z */
    amb_dif[0] = 0.9f;  amb_dif[1] = 1.0f;  amb_dif[2] = 0.3f;
    glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, amb_dif);
    gluCylinder(quad_fill, 1, 1, axis_length - 0.5f*arrow_height, 8, 1);
    glPushMatrix();
      glTranslatef(0, 0, axis_length - arrow_height);
      gluCylinder(quad_fill, arrow_radius, 0, arrow_height, 16, 8);
    glPopMatrix();

    glPopMatrix();
}


void render_focal_plane()
{
    static GLfloat amb_dif[4] = {0.7f, 0.6f, 0.5f, 0.2f};
    GLboolean prev_blend;
    GLint     prev_blend_src;
    GLint     prev_blend_dst;

    if ((prev_blend = glIsEnabled(GL_BLEND)))
    {
        glGetIntegerv(GL_BLEND_SRC, &prev_blend_src);
        glGetIntegerv(GL_BLEND_DST, &prev_blend_dst);
    }
    else
    {
        glEnable(GL_BLEND);
    }
    glBlendFunc(GL_SRC_ALPHA, GL_SRC_ALPHA);

    glMatrixMode(GL_MODELVIEW);

    glPushMatrix();
    glLoadIdentity();

    glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, amb_dif);

    float x = 200.0f;
    float y = 200.0f;
    float z = -camera->get_focal_length();

    glBegin(GL_POLYGON);
    glNormal3f( 0,  0, 1);
    glVertex3f( x,  y, z);
    glVertex3f(-x,  y, z);
    glVertex3f(-x, -y, z);
    glVertex3f( x, -y, z);
    glEnd();

    glPopMatrix();

    if (prev_blend)
    {
        glBlendFunc(prev_blend_src, prev_blend_dst);
    }
    else
    {
        glDisable(GL_BLEND);
    }
}


void render_scene()
{
    static GLfloat M_scale[16]  = {0};
    static GLfloat amb_dif[4]   = {0, 0, 0, 1.0f};
    static GLfloat shininess[1] = {0};

    glMatrixMode(GL_MODELVIEW);

    glPushMatrix();

    M_scale[0] = M_scale[5] = M_scale[10] = scale;
    M_scale[15] = 1.0f;
    glMultMatrixf(M_scale);

    amb_dif[0] = 0.8f;  amb_dif[1] = 0.7f;  amb_dif[2] = 0.4f;
    glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, amb_dif);
    glMaterialfv(GL_FRONT, GL_SPECULAR, amb_dif);
    shininess[0] = 120;
    glMaterialfv(GL_FRONT, GL_SHININESS, shininess);

    switch (modes.object)
    {
        case SOLID_SPHERE:
            glutSolidSphere(100, 30, 30);
            break;
        case WIRE_SPHERE:
            glutWireSphere(100, 30, 30);
            break;
        case SOLID_CUBE:
            glutSolidCube(150);
            break;
        case WIRE_CUBE:
            glutWireCube(150);
            break;
        case SOLID_TORUS:
            glutSolidTorus(25, 100, 25, 50);
            break;
        case WIRE_TORUS:
            glutWireTorus(25, 100, 25, 50);
            break;
        case SOLID_TEAPOT:
            glutSolidTeapot(100);
            break;
        case WIRE_TEAPOT:
            glutWireTeapot(100);
            break;
    }

    glPopMatrix();
}


void display_glut_anaglyph()
{
    /* Set the buffer for reading and writing. Using double buffering. */
    glDrawBuffer(GL_BACK);
    glReadBuffer(GL_BACK);

    /* Clear things */
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_ACCUM_BUFFER_BIT);

    /* Left camera filter. */
    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
    switch (glasses_type) 
    {
        case REDBLUE:
        case REDGREEN:
        case REDCYAN:
            glColorMask(GL_TRUE, GL_FALSE, GL_FALSE, GL_TRUE);
            break;
        case BLUERED:
            glColorMask(GL_FALSE, GL_FALSE, GL_TRUE, GL_TRUE);
            break;
        case GREENRED:
            glColorMask(GL_FALSE, GL_TRUE, GL_FALSE, GL_TRUE);
            break;
        case CYANRED:
            glColorMask(GL_FALSE, GL_TRUE, GL_TRUE, GL_TRUE);
            break;
    } 

    /* Set the left camera projection. */
    camera->set_left_gl_projection();

    /* Set the camera model view. */
    camera->set_left_gl_modelview();

    /* Render the world axis. */
    if (modes.render_world_axis)
    {
        render_world_axis();
    }

    render_scene();

    /* Render the focal plane if in that mode. */
    if (modes.render_focal_plane)
    {
        render_focal_plane();
    }

    glFlush();

    glAccum(GL_LOAD, 0.5f);
    glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);

    /* Right camera filter. */
    switch (glasses_type) 
    {
        case REDBLUE:
            glColorMask(GL_FALSE, GL_FALSE, GL_TRUE, GL_TRUE);
            break;
        case REDGREEN:
            glColorMask(GL_FALSE, GL_TRUE, GL_FALSE, GL_TRUE);
            break;
        case REDCYAN:
            glColorMask(GL_FALSE, GL_TRUE, GL_TRUE, GL_TRUE);
            break;
        case BLUERED:
        case GREENRED:
        case CYANRED:
            glColorMask(GL_TRUE, GL_FALSE, GL_FALSE, GL_TRUE);
            break;
    } 

    /* Set the right camera projection. */
    camera->set_right_gl_projection();

    /* Set the camera model view. */
    camera->set_right_gl_modelview();

    /* Render the world axis. */
    if (modes.render_world_axis)
    {
        render_world_axis();
    }

    render_scene();

    /* Render the focal plane if in that mode. */
    if (modes.render_focal_plane)
    {
        render_focal_plane();
    }

    glFlush();

    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);

    glAccum(GL_ACCUM, 0.5f);
    glAccum(GL_RETURN, 2.0f);
}


void display_glut_regular()
{
    /* Set the buffer for writing. Using double buffering. */
    glDrawBuffer(GL_BACK);
    glReadBuffer(GL_BACK);

    /* Clear things */
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    /* Set the camera projection. */
    camera->set_gl_projection();

    /* Set the camera model view. */
    camera->set_gl_modelview();

    /* Render the world axis. */
    if (modes.render_world_axis)
    {
        render_world_axis();
    }

    render_scene();

    /* Render the focal plane if in that mode. */
    if (modes.render_focal_plane)
    {
        render_focal_plane();
    }

    glFlush();
}


void display_glut()
{
    if (modes.anaglyph)
    {
        display_glut_anaglyph();
    }
    else
    {
        display_glut_regular();
    }

    glutSwapBuffers();

    if (modes.capture_view)
    {
        capture_view();
        modes.capture_view = 0;
    }
}


void reshape_glut(int w, int h)
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glViewport(0, 0, (GLsizei)w, (GLsizei)h); 
    view_width = w;
    view_height = h;
}


void keyboard_glut(unsigned char key, int a, int b)
{
    float translate_delta = 10;
    float rotate_delta    = 10*JWSC_DEG_TO_RAD;
    float focal_length;
    float theta;

    Vector_f* v_tmp = 0;

    switch (key) {
        case 't':
            modes.translate_camera = 1;
            modes.rotate_camera = 0;
            break;
        case 'r':
            modes.rotate_camera = 1;
            modes.translate_camera = 0;
            break;
        case 'l':
            if (modes.translate_camera)
            {
                const Vector_f* right = camera->get_u();
                camera->translate(
                        translate_delta * right->elts[0],
                        translate_delta * right->elts[1],
                        translate_delta * right->elts[2]);
            }
            else if (modes.rotate_camera)
            {
                camera->rotate(-rotate_delta, 0, 1, 0);
            }
            glutPostRedisplay();
            break;
        case 'h':
            if (modes.translate_camera)
            {
                const Vector_f* right = camera->get_u();
                camera->translate(
                        -translate_delta * right->elts[0],
                        -translate_delta * right->elts[1],
                        -translate_delta * right->elts[2]);
            }
            else if (modes.rotate_camera)
            {
                camera->rotate(rotate_delta, 0, 1, 0);
            }
            glutPostRedisplay();
            break;
        case 'L':
            if (modes.translate_camera)
            {
                const Vector_f* right = camera->get_u();
                camera->translate(
                        translate_delta * right->elts[0],
                        translate_delta * right->elts[1],
                        translate_delta * right->elts[2]);
            }
            else if (modes.rotate_camera)
            {
                copy_vector_f(&v_tmp, camera->get_prp());
                multiply_vector_by_scalar_f(&v_tmp, v_tmp, -1);
                camera->translate(v_tmp);
                camera->rotate(rotate_delta, camera->get_v());
                multiply_vector_by_scalar_f(&v_tmp, v_tmp, -1);
                camera->translate(v_tmp);
            }
            glutPostRedisplay();
            break;
        case 'H':
            if (modes.translate_camera)
            {
                const Vector_f* right = camera->get_u();
                camera->translate(
                        -translate_delta * right->elts[0],
                        -translate_delta * right->elts[1],
                        -translate_delta * right->elts[2]);
            }
            else if (modes.rotate_camera)
            {
                copy_vector_f(&v_tmp, camera->get_prp());
                multiply_vector_by_scalar_f(&v_tmp, v_tmp, -1);
                camera->translate(v_tmp);
                camera->rotate(-rotate_delta, camera->get_v());
                multiply_vector_by_scalar_f(&v_tmp, v_tmp, -1);
                camera->translate(v_tmp);
            }
            glutPostRedisplay();
            break;
        case 'k':
            if (modes.translate_camera)
            {
                const Vector_f* up = camera->get_v();
                camera->translate(
                        translate_delta * up->elts[0],
                        translate_delta * up->elts[1],
                        translate_delta * up->elts[2]);
            }
            else if (modes.rotate_camera)
            {
                camera->rotate(rotate_delta, camera->get_u());
            }
            glutPostRedisplay();
            break;
        case 'j':
            if (modes.translate_camera)
            {
                const Vector_f* up = camera->get_v();
                camera->translate(
                        -translate_delta * up->elts[0],
                        -translate_delta * up->elts[1],
                        -translate_delta * up->elts[2]);
            }
            else if (modes.rotate_camera)
            {
                camera->rotate(-rotate_delta, camera->get_u());
            }
            glutPostRedisplay();
            break;
        case 'K':
            if (modes.translate_camera)
            {
                const Vector_f* view = camera->get_n();
                camera->translate(
                        -translate_delta * view->elts[0],
                        -translate_delta * view->elts[1],
                        -translate_delta * view->elts[2]);
            }
            else if (modes.rotate_camera)
            {
                copy_vector_f(&v_tmp, camera->get_prp());
                multiply_vector_by_scalar_f(&v_tmp, v_tmp, -1);
                camera->translate(v_tmp);
                camera->rotate(-rotate_delta, camera->get_u());
                multiply_vector_by_scalar_f(&v_tmp, v_tmp, -1);
                camera->translate(v_tmp);
            }
            glutPostRedisplay();
            break;
        case 'J':
            if (modes.translate_camera)
            {
                const Vector_f* view = camera->get_n();
                camera->translate(
                        translate_delta * view->elts[0],
                        translate_delta * view->elts[1],
                        translate_delta * view->elts[2]);
            }
            else if (modes.rotate_camera)
            {
                copy_vector_f(&v_tmp, camera->get_prp());
                multiply_vector_by_scalar_f(&v_tmp, v_tmp, -1);
                camera->translate(v_tmp);
                camera->rotate(rotate_delta, camera->get_u());
                multiply_vector_by_scalar_f(&v_tmp, v_tmp, -1);
                camera->translate(v_tmp);
            }
            glutPostRedisplay();
            break;
        case 'F':
            if (modes.focal_prp)
            {
                focal_length = camera->get_focal_length() + 20;
                //camera->set_f_with_same_aperture_using_prp(focal_length);
                camera->set_f_with_new_aperture_using_prp(focal_length);
            }
            else if (modes.focal_vrp)
            {
                focal_length = camera->get_focal_length() + 20;
                camera->set_f_with_same_aperture_using_vrp(focal_length);
                //camera->set_f_with_new_aperture_using_vrp(focal_length);
            }
            glutPostRedisplay();
            break;
        case 'f':
            if (modes.focal_prp)
            {
                focal_length = camera->get_focal_length();
                if (focal_length >= 22)
                {
                    focal_length -= 20;
                    //camera->set_f_with_same_aperture_using_prp(focal_length);
                    camera->set_f_with_new_aperture_using_prp(focal_length);
                }
            }
            else if (modes.focal_vrp)
            {
                focal_length = camera->get_focal_length();
                if (focal_length >= 22)
                {
                    focal_length -= 20;
                    camera->set_f_with_same_aperture_using_vrp(focal_length);
                    //camera->set_f_with_new_aperture_using_vrp(focal_length);
                }
            }
            glutPostRedisplay();
            break;
        case 'S':
            if (scale >= 2.99f)
            {
                scale = 3.0f;
            }
            else
            {
                scale += 0.01f;
            }
            glutPostRedisplay();
            break;
        case 's':
            if (scale > 0.01f)
            {
                scale -= 0.01f;
            }
            glutPostRedisplay();
            break;
        case 'A':
            aperture += JWSC_PI_8;
            camera->set_aperture(aperture);
            glutPostRedisplay();
            break;
        case 'a':
            theta = aperture - JWSC_PI_8;
            if (theta >= 0)
            {
                aperture = theta;
                camera->set_aperture(theta);
            }
            glutPostRedisplay();
            break;
        case 'c':
            modes.capture_view = 1;
            glutPostRedisplay();
            break;
        case 'o':
            reset();
            glutPostRedisplay();
            break;
        case 'q':
            free_vector_f(v_tmp);
            clean_up();
            exit(EXIT_SUCCESS);
    }

    free_vector_f(v_tmp);
}


void main_menu_glut(int id)
{
    switch (id)
    {
        case 0:
            modes.anaglyph = !modes.anaglyph;
            glutPostRedisplay();
            break;
        case 1:
            modes.capture_view = 1;
            glutPostRedisplay();
            break;
        case 2:
            reset();
            glutPostRedisplay();
            break;
        case 3:
            clean_up();
            exit(EXIT_SUCCESS);
    }
}


void option_menu_glut(int id)
{
    switch (id)
    {
        case 0:
            modes.render_focal_plane = !modes.render_focal_plane;
            glutPostRedisplay();
            break;
        case 1:
            modes.render_world_axis = !modes.render_world_axis;
            glutPostRedisplay();
            break;
    }
}


void navigation_menu_glut(int id)
{
    switch (id)
    {
        case 0:
            modes.rotate_camera    = true;
            modes.translate_camera = false;
            break;
        case 1:
            modes.rotate_camera    = false;
            modes.translate_camera = true;
            break;
    }
}


void solid_objects_menu_glut(int id)
{
    switch (id)
    {
        case 0:
            modes.object = SOLID_SPHERE;
            glutPostRedisplay();
            break;
        case 1:
            modes.object = SOLID_CUBE;
            glutPostRedisplay();
            break;
        case 2:
            modes.object = SOLID_TORUS;
            glutPostRedisplay();
            break;
        case 3:
            modes.object = SOLID_TEAPOT;
            glutPostRedisplay();
            break;
    }
}


void wire_objects_menu_glut(int id)
{
    switch (id)
    {
        case 0:
            modes.object = WIRE_SPHERE;
            glutPostRedisplay();
            break;
        case 1:
            modes.object = WIRE_CUBE;
            glutPostRedisplay();
            break;
        case 2:
            modes.object = WIRE_TORUS;
            glutPostRedisplay();
            break;
        case 3:
            modes.object = WIRE_TEAPOT;
            glutPostRedisplay();
            break;
    }
}


void objects_menu_glut(int id)
{
    ;
}


void focal_length_menu_glut(int id)
{
    switch (id)
    {
        case 0:
            modes.focal_prp = true;
            modes.focal_vrp = false;
            break;
        case 1:
            modes.focal_prp = false;
            modes.focal_vrp = true;
            break;
    }
}


void init_glut(int argc, char** argv)
{
    glutInit(&argc, (char**)argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH | GLUT_ACCUM
                                    | GLUT_ALPHA);
    glutInitWindowSize(view_width, view_height);
    glutCreateWindow("Anaglyph");
    glutDisplayFunc(display_glut); 
    glutReshapeFunc(reshape_glut);
    glutKeyboardFunc(keyboard_glut);

    int solid = glutCreateMenu(solid_objects_menu_glut);
    glutAddMenuEntry("Sphere", 0);
    glutAddMenuEntry("Cube", 1);
    glutAddMenuEntry("Torus", 2);
    glutAddMenuEntry("Teapot", 3);

    int wire = glutCreateMenu(wire_objects_menu_glut);
    glutAddMenuEntry("Sphere", 0);
    glutAddMenuEntry("Cube", 1);
    glutAddMenuEntry("Torus", 2);
    glutAddMenuEntry("Teapot", 3);

    int objects = glutCreateMenu(objects_menu_glut);
    glutAddSubMenu("Wire", wire);
    glutAddSubMenu("Solid", solid);

    int navigation = glutCreateMenu(navigation_menu_glut);
    glutAddMenuEntry("Rotate Camera", 0);
    glutAddMenuEntry("Translate Camera", 1);

    int focal_length = glutCreateMenu(focal_length_menu_glut);
    glutAddMenuEntry("PRP", 0);
    glutAddMenuEntry("VRP", 1);

    int options = glutCreateMenu(option_menu_glut);
    glutAddMenuEntry("Focal Plane", 0);
    glutAddMenuEntry("Axis", 1);

    glutCreateMenu(main_menu_glut);
    glutAddMenuEntry("Anaglyph", 0);
    glutAddSubMenu("Objects", objects);
    glutAddSubMenu("Navigation", navigation);
    glutAddSubMenu("Focal Length", focal_length);
    glutAddSubMenu("Options", options);
    glutAddMenuEntry("Capture", 1);
    glutAddMenuEntry("Reset", 2);
    glutAddMenuEntry("Quit", 3);

    glutAttachMenu(GLUT_RIGHT_BUTTON);
}


void init_gl() 
{
    static GLfloat base_amb [] = {0.0f, 0.0f, 0.0f, 1.0f};
    static GLfloat ambient  [] = {0.1f, 0.1f, 0.1f, 1.0f};
    static GLfloat diffuse  [] = {0.9f, 0.9f, 0.9f, 1.0f};
    static GLfloat specular [] = {1.0f, 1.0f, 1.0f, 1.0f};
    static GLfloat direction[] = {1000.0f, 1000.0f, 1000.0f, 1.0f};

    glEnable(GL_DEPTH_TEST);
    glEnable(GL_NORMALIZE);
    glEnable(GL_LIGHTING);

    glLightModelfv(GL_LIGHT_MODEL_AMBIENT, base_amb);

    glEnable(GL_LIGHT0);
    glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
    glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
    glLightfv(GL_LIGHT0, GL_SPECULAR, specular);
    glLightfv(GL_LIGHT0, GL_POSITION, direction);

    if (!quad_fill)
    {
        quad_fill = gluNewQuadric();
        gluQuadricDrawStyle(quad_fill, GLU_FILL);
    }

    if (!quad_wire)
    {
        quad_wire = gluNewQuadric();
        gluQuadricDrawStyle(quad_wire, GLU_LINE);
    }

    glLineWidth(1.0);
    glPointSize(1.0);
    glClearColor(1.0, 1.0, 1.0, 0.0);
    glClearAccum(0.0, 0.0, 0.0, 0.0);

    glViewport(0, 0, view_width, view_height);
}


void print_usage(void)
{
    cerr << "usage: anaglyph OPTIONS\n";
    cerr << "where OPTIONS is one or more of the following:\n";
    opts->print();
}


void process_help_opt(void)
{   
    print_usage();
    clean_up();
    exit(EXIT_SUCCESS);
}


void process_version_opt(void)
{
    cout << ANAGLYPH_PACKAGE_STRING << "\n";
    clean_up();
    exit(EXIT_SUCCESS);
}

void process_window_size_opt(const char* arg) throw (Arg_error)
{
    int32_t w, h;

    if (!arg)
    {
        throw Arg_error("Option 'window-size' requires an argument");
    }
    if (sscanf(arg, "%d,%d", &w, &h) != 2)
    {
        throw Arg_error("Option 'window-size' has format width,height");
    }
    if (w <= 0 || h <= 0)
    {
        throw Arg_error("Option 'window-size' must have width,height > 0");
    }
    view_width = (uint32_t)w;
    view_height = (uint32_t)h;
}

void process_seed_opt(const char* arg) throw (Arg_error)
{
    if (!arg)
    {
        throw Arg_error("Option 'seed' requires an argument");
    }
    if (sscanf(arg, "%u", &seed) != 1)
    {
        throw Arg_error("Option 'seed' must be a non-negative integer");
    }
}

void process_capture_opt(const char* arg) throw (Arg_error)
{
    if (!arg)
    {
        throw Arg_error("Option 'capture' requires an argument");
    }
    capture_fname = arg;
}

void process_glasses_opt(const char* arg) throw (Arg_error)
{
    if (!arg)
    {
        throw Arg_error("Option 'glasses' requires an argument");
    }
    if (strcmp("red-blue", arg) == 0)
        glasses_type = REDBLUE;
    else if (strcmp("red-green", arg) == 0)
        glasses_type = REDGREEN;
    else if (strcmp("red-cyan", arg) == 0)
        glasses_type = REDCYAN;
    else if (strcmp("blue-red", arg) == 0)
        glasses_type = BLUERED;
    else if (strcmp("green-red", arg) == 0)
        glasses_type = GREENRED;
    else if (strcmp("cyan-red", arg) == 0)
        glasses_type = CYANRED;
    else
    {
        throw Arg_error("Invalid 'glasses' type");
    }

    capture_fname = arg;
}


void* operator new (size_t s) throw (std::bad_alloc)
{
    return malloc(s);
}


void operator delete (void* ptr) throw ()
{
    if (ptr)
        free(ptr);
}



int main(int argc, char** argv)
{
    using jwscxx::base::Option_no_arg;
    using jwscxx::base::Option_with_arg;

    const char* l_name;
    const char* desc;

    opts = new Options();

    l_name = "help";
    desc   = "Program usage";
    opts->add(new Option_no_arg('h', l_name, desc, process_help_opt));

    l_name = "version";
    desc   = "Program version.";
    opts->add(new Option_no_arg('v', l_name, desc, process_version_opt));

    l_name = "window-size";
    desc   = "Window size with format width,height. Default is 400,400.";
    opts->add(new Option_with_arg(0, l_name, desc, process_window_size_opt));

    l_name = "seed";
    desc   = "Random seed to use in srand(). Must be a non-negative integer.";
    opts->add(new Option_with_arg(0, l_name, desc, process_seed_opt));

    l_name = "capture";
    desc   = "View capture name.";
    opts->add(new Option_with_arg(0, l_name, desc, process_capture_opt));

    l_name = "glasses";
    desc   = "Type of colored glasses. Possible left-right filter types include include red-blue, red-green, red-cyan, blue-red, green-red, cyan-red. Default is cyan-red.";
    opts->add(new Option_with_arg(0, l_name, desc, process_capture_opt));

    try
    {
        opts->process(argc, argv);

        init_glut(argc, argv);
        init_gl();
        init_camera();
        init_modes();

        std::srand(seed);

        glutMainLoop();
    }
    catch (Arg_error e)
    {
        cerr << "anaglyph: ";
        e.print();
    }

    clean_up();

    return EXIT_SUCCESS;
}