main.cpp

Go to the documentation of this file.

/*
    Sheep - A Rigid Body Dynamics Engine
    Copyright (C) 2001-2004 Francois Beaune
    Contact: http://toxicengine.sourceforge.net/

    This file is part of Sheep.

    Sheep is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    Sheep is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Sheep; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include "common/math/real.h"
#include "common/math/vector3.h"
#include "iframeworkapp.h"
#include "sceneorbiter.h"

#include <cassert>
#include <cstdlib>
#include <GL/glut.h>
#include <IL/il.h>
#include <IL/ilu.h>
#include <IL/ilut.h>

using namespace sheep;
using namespace std;

const Real TUMBLING_SPEED = 3.0;
const Real TRACKING_SPEED = 10.0;
const Real DOLLYING_SPEED = 8.0;

IFrameworkApp *g_app;

int g_argc;
char **g_argv;

GLuint g_grid_list;

int g_width, g_height;
int g_old_width, g_old_height;

bool g_is_fullscreen = false;
bool g_display_grid = true;
bool g_use_freelook = false;
bool g_in_step_mode = true;
bool g_take_step = false;

void reset();
void print_help();

void reshape(int width, int height) {
    g_width = width;
    g_height = height;

    g_app->Reshape(width, height);
}

void keyboard(unsigned char key, int x, int y) {
    switch(key) {
    // f: toggle full screen mode.
    case 'f':
        if(g_is_fullscreen) {
            glutReshapeWindow(g_old_width, g_old_height);
            glutPositionWindow(50, 50);
            g_is_fullscreen = false;
        } else {
            g_old_width = g_width;
            g_old_height = g_height;
            glutFullScreen();
            g_is_fullscreen = true;
        }
        break;

    // g: toggle grid display.
    case 'g':
        g_display_grid ^= true;
        break;

    // h: help.
    case 'h':
        print_help();
        break;

    // l: toggle free look mode.
    case 'l':
        g_use_freelook ^= true;
        break;

    // q: quit.
    case 'q':
        exit(0);    // GLUT programs should use exit() routine to quit
        break;

    // r: reset.
    case 'r':
        reset();
        break;

    // s: toggle 'step by step' mode.
    case 's':
        g_in_step_mode ^= true;
        if(g_in_step_mode)
            g_take_step = false;
        break;

    // v: reset the view.
    case 'v':
        if(!g_app->m_orbiter.IsDragging()) {
            g_app->m_orbiter.Configure(
                Vector3(0.0),
                DEFAULT_AZIMUTH,
                DEFAULT_ELEVATION,
                DEFAULT_DISTANCE);
        }
        break;

    // SPACE: take a step (only available in 'step by step' mode).
    case ' ':
        if(g_in_step_mode)
            g_take_step = true;
        break;

    // ESCAPE: cancel drag movement.
    case 27:
        if(g_app->m_orbiter.IsDragging())
            g_app->m_orbiter.CancelDrag();
        break;

    // Let the application handle any other key.
    default:
        g_app->KeyPressed(key);
    }
}

void special(int key, int x, int y) {
    switch(key) {
    case GLUT_KEY_UP:
        if(g_use_freelook) {
            g_app->m_orbiter.SetCenter(g_app->m_orbiter.GetCenter()
                + (g_app->m_orbiter.GetCenter() - g_app->m_orbiter.GetEyePosition()).Normalized());
        }
        break;
    case GLUT_KEY_DOWN:
        if(g_use_freelook) {
            g_app->m_orbiter.SetCenter(g_app->m_orbiter.GetCenter()
                - (g_app->m_orbiter.GetCenter() - g_app->m_orbiter.GetEyePosition()).Normalized());
        }
        break;
    }
}

Vector2 convert_mouse_to_ndc(int x, int y) {
    Vector2 ndc;

    // Mouse coordinates are upside down.
    ndc.m_x = 2.0 * static_cast<Real>(x) / (g_width - 1) - 1.0;
    ndc.m_y = 1.0 - 2.0 * static_cast<Real>(y) / (g_height - 1);

    ndc.m_y *= static_cast<Real>(g_height) / g_width;

    return ndc;
}

void mouse(int button, int state, int x, int y) {
    if(state == GLUT_UP) {
        if(g_app->m_orbiter.IsDragging())
            g_app->m_orbiter.EndDrag();
        return;
    }

    assert(state == GLUT_DOWN);

    // Already dragging.
    if(g_app->m_orbiter.IsDragging())
        return;

    if(g_use_freelook) {
        if(button == GLUT_LEFT_BUTTON) {
            g_app->m_orbiter.BeginDrag(
                SceneOrbiter::Movement::TUMBLE,
                convert_mouse_to_ndc(x, y) * TUMBLING_SPEED);
        }
    } else {
        const int modifiers = glutGetModifiers();
        const Vector2 mp = convert_mouse_to_ndc(x, y);

        switch(button) {

        // Left button with CTRL only: tumble.
        // Left button with ALT only: track.
        case GLUT_LEFT_BUTTON:
            if(modifiers == GLUT_ACTIVE_CTRL)
                g_app->m_orbiter.BeginDrag(SceneOrbiter::Movement::TUMBLE, mp * TUMBLING_SPEED);
            else if(modifiers == GLUT_ACTIVE_ALT)
                g_app->m_orbiter.BeginDrag(SceneOrbiter::Movement::TRACK, mp * TRACKING_SPEED);
            break;

        // Middle button with CTRL only: track.
        case GLUT_MIDDLE_BUTTON:
            if(modifiers == GLUT_ACTIVE_CTRL)
                g_app->m_orbiter.BeginDrag(SceneOrbiter::Movement::TRACK, mp * TRACKING_SPEED);
            break;

        // Right button with CTRL only: dolly.
        case GLUT_RIGHT_BUTTON:
            if(modifiers == GLUT_ACTIVE_CTRL)
                g_app->m_orbiter.BeginDrag(SceneOrbiter::Movement::DOLLY, mp * DOLLYING_SPEED);
            break;

        }
    }
}

void motion(int x, int y) {
    if(g_app->m_orbiter.IsDragging()) {
        Vector2 mp = convert_mouse_to_ndc(x, y);

        if(g_app->m_orbiter.IsTumbling())
            mp *= TUMBLING_SPEED;
        else if(g_app->m_orbiter.IsTracking())
            mp *= TRACKING_SPEED;
        else if(g_app->m_orbiter.IsDollying())
            mp *= DOLLYING_SPEED;

        g_app->m_orbiter.UpdateDrag(mp);
    }
}

void think(int /*value*/) {
    glutTimerFunc((unsigned int)(1000.0 / THINK_RATE), think, 0);

    if(g_in_step_mode) {
        if(g_take_step) {
            g_app->Think();
            g_take_step = false;
        }
    } else g_app->Think();
}

void update_screen(int /*value*/) {
    glutTimerFunc((unsigned int)(1000.0 / FRAME_RATE), update_screen, 0);

    // Force screen update.
    glutPostRedisplay();
}

void draw_grid() {
    const int GRID_HALF_SIZE = 12;  // half the number of cells in each direction
    const Real GRID_SPACING = 1.0;

    glEnable(GL_DEPTH_TEST);

    glLineWidth(1.0f);
    glColor3f(0.5f, 0.5f, 0.5f);

    glBegin(GL_LINES);

    for(int i = 0; i < GRID_HALF_SIZE; ++i) {
        Real k = (i + 1) * GRID_SPACING;

        glVertex3f(-GRID_HALF_SIZE * GRID_SPACING, 0.0f, k);
        glVertex3f(GRID_HALF_SIZE * GRID_SPACING, 0.0f, k);

        glVertex3f(-GRID_HALF_SIZE * GRID_SPACING, 0.0f, -k);
        glVertex3f(GRID_HALF_SIZE * GRID_SPACING, 0.0f, -k);

        glVertex3f(k, 0.0f, -GRID_HALF_SIZE * GRID_SPACING);
        glVertex3f(k, 0.0f, GRID_HALF_SIZE * GRID_SPACING);

        glVertex3f(-k, 0.0f, -GRID_HALF_SIZE * GRID_SPACING);
        glVertex3f(-k, 0.0f, GRID_HALF_SIZE * GRID_SPACING);
    }

    glEnd();

    // Main axes.

    glLineWidth(2.0f);
    glColor3f(0.0f, 0.0f, 0.0f);

    glBegin(GL_LINES);
        glVertex3f(-GRID_HALF_SIZE * GRID_SPACING, 0.0f, 0.0f);
        glVertex3f(GRID_HALF_SIZE * GRID_SPACING, 0.0f, 0.0f);

        glVertex3f(0.0f, 0.0f, -GRID_HALF_SIZE * GRID_SPACING);
        glVertex3f(0.0f, 0.0f, GRID_HALF_SIZE * GRID_SPACING);
    glEnd();
}

void draw_axis() {
    const GLfloat TOLERANCE = g_app->m_orbiter.GetDistance() / 1000.0f;
    const GLfloat LENGTH = g_app->m_orbiter.GetDistance() / 20.0f;

    glLineWidth(2.0f);

    glBegin(GL_LINES);
        // X axis in red.
        glColor3f(1.0f, 0.0f, 0.0f);
        glVertex3f(0.0f, TOLERANCE, TOLERANCE);
        glVertex3f(LENGTH, TOLERANCE, TOLERANCE);

        // Y axis in green.
        glColor3f(0.0f, 1.0f, 0.0f);
        glVertex3f(TOLERANCE, 0.0f, TOLERANCE);
        glVertex3f(TOLERANCE, LENGTH, TOLERANCE);

        // Z axis in blue.
        glColor3f(0.0f, 0.0f, 1.0f);
        glVertex3f(TOLERANCE, TOLERANCE, 0.0f);
        glVertex3f(TOLERANCE, TOLERANCE, LENGTH);
    glEnd();
}

void draw_dragging_axis() {
    const GLfloat LENGTH = g_app->m_orbiter.GetDistance() / 30.0f;

    glLineWidth(2.0f);
    glColor3f(0.3f, 0.3f, 0.3f);

    glBegin(GL_LINES);
        glVertex3f(0.0f, 0.0f, 0.0f);
        glVertex3f(LENGTH, 0.0f, 0.0f);

        glVertex3f(0.0f, 0.0f, 0.0f);
        glVertex3f(0.0f, LENGTH, 0.0f);

        glVertex3f(0.0f, 0.0f, 0.0f);
        glVertex3f(0.0f, 0.0f, LENGTH);
    glEnd();
}

void display() {
    glClearColor(0.63f, 0.63f, 0.63f, 0.0f);
    glClearDepth(1.0);

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    glTranslatef(0.0f, 0.0f, -g_app->m_orbiter.GetDistance());
    glRotatef(rtod(g_app->m_orbiter.GetElevation()), 1.0f, 0.0f, 0.0f);
    glRotatef(rtod(g_app->m_orbiter.GetAzimuth() - PI / 2.0), 0.0f, 1.0f, 0.0f);

    glPushMatrix();

    const Point3 center = g_app->m_orbiter.GetCenter();
    glTranslatef(-center.m_x, -center.m_y, -center.m_z);

    glDisable(GL_LIGHTING);
    glDisable(GL_TEXTURE_2D);
    glEnable(GL_DEPTH_TEST);

    // Draw the grid.
    if(g_display_grid)
        glCallList(g_grid_list);

    // Draw the X, Y and Z axis.
    draw_axis();

    // Let the application do some rendering.
    g_app->Render();

    glPopMatrix();

    // Draw the dragging axis if dragging.
    if(g_app->m_orbiter.IsDragging()) {
        glDisable(GL_LIGHTING);
        glDisable(GL_TEXTURE_2D);
        glDisable(GL_DEPTH_TEST);
        draw_dragging_axis();
    }

    glutSwapBuffers();
}

void shutdown() {
    delete g_app;
}

void reset() {
    delete g_app;

    g_app = new_frameworkapp(g_argc, g_argv);

    assert(g_app);
}

void print_disclaimer() {
    cout << "Sheep - A Rigid Body Dynamics Engine" << endl;
    cout << "Copyright (C) 2001-2004 Francois Beaune" << endl << endl;
    cout << "Visit http://sheepengine.sourceforge.net/ for more information." << endl;
    cout << endl;
}

void print_help() {
    cout << endl;
    cout << "Hold the CTRL key and use your mouse to manipulate the scene:" << endl;
    cout << "  CTRL + left button: tumble" << endl;
    cout << "  CTRL + middle button: track" << endl;
    cout << "  CTRL + right button: dolly" << endl;
    cout << endl;

    cout << "You can also use the ALT + left button combination to tumble." << endl;
    cout << endl;

    cout << "Available keys:" << endl;
    cout << "  f: toggle full screen mode" << endl;
    cout << "  g: toggle grid display" << endl;
    cout << "  h: display this help" << endl;
    cout << "  l: toggle free look mode" << endl;
    cout << "  q: quit" << endl;
    cout << "  r: reset" << endl;
    cout << "  s: toogle 'step by step' mode" << endl;
    cout << "  v: reset the view" << endl;
    cout << "  SPACE: take a step (only in 'step by step' mode)" << endl;
    cout << "  ESCAPE: cancel drag movement" << endl;
    cout << endl;

    cout << "Application-specific keys:" << endl;

    g_app->PrintHelp();

    cout << endl;
}

int main(int argc, char **argv) {
    print_disclaimer();

    g_argc = argc;
    g_argv = argv;

    // Initialize GLUT.
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);

    // Create and configure the display window.
    glutInitWindowPosition(50, 50);
    glutInitWindowSize(640, 480);
    glutCreateWindow(argv[0]);
    glutDisplayFunc(display);
    glutReshapeFunc(reshape);
    glutKeyboardFunc(keyboard);
    glutSpecialFunc(special);
    glutMouseFunc(mouse);
    glutMotionFunc(motion);

    // Initialize DevIL.
    ilInit();
    iluInit();
    ilutRenderer(ILUT_OPENGL);

    // Create the grid display list.
    g_grid_list = glGenLists(1);
    glNewList(g_grid_list, GL_COMPILE);
    draw_grid();
    glEndList();

    // Create the client application.
    g_app = 0;
    reset();
    print_help();

    // Register an exit callback.
    atexit(shutdown);

    // Start the timers.
    glutTimerFunc((unsigned int)(1000.0 / FRAME_RATE), update_screen, 0);
    glutTimerFunc((unsigned int)(1000.0 / THINK_RATE), think, 0);

    glutMainLoop(); // never returns

    return 0;
}

---