Demo.cpp

#include "Demo.h"
#include "Textures.h"

Demo::Demo ()
{
        // initialize default state
        fullscreen_enabled = false;
        culling_mode = C_NONE;
        level_of_detail_enabled = false;
        is_initialized = false;
        demo_time = DEMO_NOT_YET_STARTED;

        // frame rate
        frame_rate = 0;
        incremental_rate = 0;
        last_frame_rate_time = 0;

        // initialize scene list
        first_scene = NULL;
        current_scene = NULL;

        // set default size
        window_width = 640;
        window_height = 480;

        // create camera to monitor scenes
        monitor_camera = new Camera ();
}

Demo::~Demo ()
{
        // release textures
        Textures::Release ();

        // delete all scenes
        SceneListElem * current_scene;
        SceneListElem * scene_to_be_deleted;

        current_scene = first_scene;
        while (current_scene != NULL)
        {
                scene_to_be_deleted = current_scene;
                current_scene = current_scene->next;
                delete scene_to_be_deleted;
        }
}

void Demo::Init (int argc, char * argv [])
{
        PrintUsage ();

        // activate this demo
        Demo::current_demo = this;

        // init display mode and window or fullscreen
        glutInitDisplayMode(GLUT_DEPTH | GLUT_RGBA | GLUT_DOUBLE | GLUT_ACCUM);

        if (argc == 3)
        {
                int size_x, size_y;
                size_x = atoi (argv[1]);
                size_y = atoi (argv[2]);

                if (size_x > 0 && size_y > 0)
                {
                        window_width = size_x;
                        window_height = size_y;
                }
        }
        if (argc == 2)
        {
                glutGameModeString (argv[1]);
                if (glutGameModeGet (GLUT_GAME_MODE_POSSIBLE ))
                {
                        fullscreen_enabled = true;
                        glutEnterGameMode ();
                }
        }

        if (!fullscreen_enabled)
        {
                glutInitWindowSize (window_width, window_height);
                glutCreateWindow("Demo");
        }

        // Register functions
        glutDisplayFunc (Demo::static_display);
        glutIdleFunc (Demo::static_idle);
        glutReshapeFunc (Demo::static_reshape);
        glutKeyboardFunc (Demo::static_keyboard);
        glutSpecialFunc (Demo::static_keyboard_special);

        // Init OpenGL states
        glClearColor (0.0f, 0.0f, 0.0f, 0.0f);
        glEnable (GL_DEPTH_TEST);
        glDepthFunc (GL_LEQUAL);
        glShadeModel (GL_SMOOTH);
        glEnable (GL_COLOR_MATERIAL);
        glEnable (GL_LIGHTING);

        // set default values for ambient light and specular behaviour
        SetGlobalAmbientPlayback (0.0f, 0.0f, 0.0f, 0.0f);
        SetGlobalAmbientMonitor (0.4f, 0.4f, 0.4f, 1.0f);
        SetGlobalSpecularReflection (1.0f, 1.0f, 1.0f, 1.0f);
        SetGlobalShininess (64);

        glMaterialfv (GL_FRONT, GL_SPECULAR, global_specular_reflection);
        glMateriali(GL_FRONT, GL_SHININESS, global_shininess);

        glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);

        // Load textures
        Textures::Load ();

        // Init all scenes
        SceneListElem * current_scene;
        current_scene = first_scene;
        while (current_scene != NULL)
        {
                if (current_scene->scene != NULL)
                {current_scene->scene->Init ();}
                current_scene = current_scene->next;
        }

        // Init random number generator
        srand (timeGetTime ());

        // set up modes
        level_of_detail_enabled = true;
        culling_mode = C_BOUNDING_BOX;

        is_initialized = true;
}

void Demo::Play ()
{
        if (!is_initialized)
        {printf ("Demo has to be initialized first\n"); return;}

        if (first_scene == NULL)
        {printf ("Demo contains no scenes\n");}

        demo_time = 0;
        last_measure_time = (int)glutGet (GLUT_ELAPSED_TIME);
        monitoring_mode = false;
        demo_playing = true;
        current_scene = first_scene;

        glLightModelfv (GL_LIGHT_MODEL_AMBIENT, global_ambient_playback);

        glutShowWindow ();
        glutMainLoop ();
}

void Demo::AddScene (Scene * scene, int duration, int blend_in)
{
        SceneListElem * current_scene;

        // Add dummy scene if the first scene has to be blended in
        if (blend_in > 0 && first_scene == NULL)
        {
                first_scene = new SceneList;
                first_scene->next = NULL;
                first_scene->scene = NULL;
                first_scene->start_time = 0;
                first_scene->blend = duration;
                first_scene->end_time = blend_in;
        }

        if (first_scene == NULL)
        {
                first_scene = new SceneList;
                first_scene->next = NULL;
                first_scene->blend = duration;
                first_scene->start_time = 0;
                first_scene->end_time = duration;
                first_scene->scene = scene;
        }
        else
        {
                current_scene = first_scene;
                while (current_scene->next != NULL) current_scene = current_scene->next;

                current_scene->next = new SceneListElem;
                current_scene->next->next = NULL;
                current_scene->next->blend = current_scene->end_time + duration - blend_in;
                current_scene->next->start_time = current_scene->end_time - blend_in;
                current_scene->next->end_time = current_scene->next->start_time + duration;
                current_scene->blend = current_scene->next->start_time;
                current_scene->next->scene = scene;
        }
}

void Demo::SwitchMonitor ()
{
        monitoring_mode = !monitoring_mode;
        if (!monitoring_mode)
        {
                // exit mode
                last_measure_time = (int)glutGet (GLUT_ELAPSED_TIME);
                glLightModelfv (GL_LIGHT_MODEL_AMBIENT, global_ambient_playback);
                demo_playing = true;    
        }
        else
        {
                // enter mode, set up the camera
                current_scene->scene->CopyPosition (demo_time - current_scene->start_time, monitor_camera);
                glLightModelfv (GL_LIGHT_MODEL_AMBIENT, global_ambient_monitor);
                demo_playing = false;
        }
}

void Demo::SwitchPlayback ()
{
        demo_playing = !demo_playing;
        if (demo_playing)
        {
                last_measure_time = (int)glutGet (GLUT_ELAPSED_TIME);
        }
}

void Demo::UpdateTime ()
{
        int current_measure_time;

        current_measure_time = (int)glutGet (GLUT_ELAPSED_TIME);

        // update demo time only if playback is on
        if (demo_playing)
        {
                demo_time += current_measure_time - last_measure_time;
                last_measure_time = current_measure_time;
        }

        // always update frame rate
        if (current_measure_time - last_frame_rate_time > 1000)
        {
                frame_rate = incremental_rate;
                incremental_rate = 0;
                last_frame_rate_time += 1000;

                if (!monitoring_mode)
                {
                        sprintf (buffer, "%03d s, fps: %d", demo_time / 1000, frame_rate);
                        glutSetWindowTitle (buffer);
                }
        }
        else incremental_rate ++;

        // update window title
        if (monitoring_mode)
        {
                Position mon = monitor_camera->position->GetPosition (0);
                sprintf (buffer, "time: %d, fps: %d, pos: {%g, %g, %g, %g, %g, %g}", demo_time, frame_rate, mon.x, mon.y, mon.z, mon.roll, mon.pitch, mon.yaw);
                glutSetWindowTitle (buffer);
        }
}

void Demo::DisplayLoop ()
{
        float ratio;

        UpdateTime ();

        glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        if (current_scene != NULL)
        {
                if (current_scene->end_time <= demo_time)
                {current_scene = current_scene->next;}

                if (current_scene != NULL)
                {
                        if (current_scene->blend > demo_time)
                        {ratio = 1.0f;}
                        else
                        {ratio = 1 - (((float)(demo_time - current_scene->blend)) / ((float)(current_scene->end_time - current_scene->blend)));}

                        // if the ratio equals 1.0, we just have to render the current scene
                        if (ratio == 1.0f)
                        {
                                if (current_scene->scene != NULL)
                                {
                                        if (!monitoring_mode )
                                        {current_scene->scene->Render (demo_time - current_scene->start_time, culling_mode, level_of_detail_enabled);}
                                        else
                                        {current_scene->scene->Monitor (demo_time - current_scene->start_time, monitor_camera, culling_mode, level_of_detail_enabled);}
                                }
                        }
                        else
                        {
                                // if the ratio is below 1.0, we have to render this and the next scene.
                                // We'll do this using the accumulation buffer.
                                if (current_scene->scene != NULL)
                                {
                                        if (!monitoring_mode)
                                        {current_scene->scene->Render (demo_time - current_scene->start_time, culling_mode, level_of_detail_enabled);}
                                        else
                                        {current_scene->scene->Monitor (demo_time - current_scene->start_time, monitor_camera, culling_mode, level_of_detail_enabled);}
                                }
                                glAccum (GL_LOAD, ratio);
                                glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

                                if (current_scene->next != NULL && current_scene->next->scene != NULL)
                                {
                                        if (!monitoring_mode)
                                        {current_scene->next->scene->Render (demo_time - current_scene->next->start_time, culling_mode, level_of_detail_enabled);}
                                        else
                                        {current_scene->next->scene->Monitor (demo_time - current_scene->next->start_time, monitor_camera, culling_mode, level_of_detail_enabled);}
                                }

                                glAccum (GL_ACCUM, 1 - ratio);
                                glAccum (GL_RETURN, 1.0f);
                        }
                }
                else
                {
                        // demo is over, stop playback
                        demo_time = DEMO_NOT_YET_STARTED;
                        demo_playing = false;
                        if (fullscreen_enabled) 
                        {
                                glutLeaveGameMode ();
                                exit (0);
                        }
                }
        }

        glutSwapBuffers ();
}

void Demo::IdleLoop ()
{
        // Just post a redisplay
        glutPostRedisplay ();
}

void Demo::Reshape (int w, int h)
{
        glViewport (0, 0, w, h);
}

void Demo::Keyboard (unsigned char key, int x, int y)
{
        switch (key)
        {
                // switch monitoring mode
                case 'm':               if (demo_time != DEMO_NOT_YET_STARTED)
                                                {SwitchMonitor ();}
                                                printf ("Switched Monitor Mode\n");
                                                break;
                // switch playback on/off
                case 'p':               if (demo_time != DEMO_NOT_YET_STARTED)
                                                {SwitchPlayback ();}
                                                printf ("Switched Playback Mode\n");
                                                break;
                // change view frustum culling mode
                case 'c':               switch (culling_mode)
                                                {
                                                        case C_BOUNDING_BOX:    culling_mode = C_SPHERE;
                                                                                                        printf ("View frustum culling mode set to: sphere\n");
                                                                                                        break;
                                                        case C_SPHERE:                  culling_mode = C_MIXED;
                                                                                                        printf ("View frustum culling mode set to: mixed\n");
                                                                                                        break;  
                                                        case C_MIXED:                   culling_mode = C_NONE;
                                                                                                        printf ("View frustum culling disabled\n");
                                                                                                        break;
                                                        case C_NONE:                    culling_mode = C_BOUNDING_BOX;
                                                                                                        printf ("View frustum culling mode set to: bounding box\n");
                                                                                                        break;
                                                }
                                                break;
                // switch level of detail on/off
                case 'l':               level_of_detail_enabled = !level_of_detail_enabled;
                                                if (level_of_detail_enabled)
                                                {printf ("Level of detail is now ENABLED\n");}
                                                else
                                                {printf ("Level of detail is now DISABLED\n");}
                                                break;
                // DELETE shifts the camera to the left
                case 127:               if (monitoring_mode)
                                                {monitor_camera->MoveRight (DELTA_Y);}
                                                break;
                // ESC key leaves fullscreen mode
                case 27:                if (fullscreen_enabled)
                                                {
                                                        glutLeaveGameMode ();
                                                        exit (0);
                                                }
                                                break;
                // default behaviour
                default:        printf ("key does nothing\n");
        }
}

void Demo::KeyboardSpecial (int key, int x, int y)
{
        Position p;

        switch (key)
        {
                // HOME moves the camera forward
                case GLUT_KEY_HOME:                     if (monitoring_mode)
                                                                        {monitor_camera->MoveForward (DELTA_X);}
                                                                        break;
                // END moves the camera backward
                case GLUT_KEY_END:                      if (monitoring_mode)
                                                                        {monitor_camera->MoveForward (-DELTA_X);}
                                                                        break;
                // PAGE DOWN shifts the camera to the right
                case GLUT_KEY_PAGE_DOWN:        if (monitoring_mode)
                                                                        {monitor_camera->MoveRight (-DELTA_Y);}
                                                                        break;
                // INSERT moves the camera up
                case GLUT_KEY_INSERT:           if (monitoring_mode)
                                                                        {monitor_camera->MoveUp (DELTA_Z);}
                                                                        break;
                // PAGE UP moves the camera down
                case GLUT_KEY_PAGE_UP:          if (monitoring_mode)
                                                                        {monitor_camera->MoveUp (-DELTA_Z);}
                                                                        break;
                // up increases pitch
                case GLUT_KEY_UP:                       if (monitoring_mode)
                                                                        {
                                                                                p = monitor_camera->position->GetPosition (0);
                                                                                monitor_camera->position->SetConstantPosition (p.x, p.y, p.z, p.roll, p.pitch + DELTA_PITCH, p.yaw);
                                                                        }
                                                                        break;
                // down decreases pitch
                case GLUT_KEY_DOWN:                     if (monitoring_mode)
                                                                        {
                                                                                p = monitor_camera->position->GetPosition (0);
                                                                                monitor_camera->position->SetConstantPosition (p.x, p.y, p.z, p.roll, p.pitch - DELTA_PITCH, p.yaw);
                                                                        }
                                                                        break;
                // left increases yaw
                case GLUT_KEY_LEFT:                     if (monitoring_mode)
                                                                        {
                                                                                p = monitor_camera->position->GetPosition (0);
                                                                                monitor_camera->position->SetConstantPosition (p.x, p.y, p.z, p.roll, p.pitch, p.yaw + DELTA_YAW);
                                                                        }
                                                                        break;
                // right decreases yaw
                case GLUT_KEY_RIGHT:            if (monitoring_mode)
                                                                        {
                                                                                p = monitor_camera->position->GetPosition (0);
                                                                                monitor_camera->position->SetConstantPosition (p.x, p.y, p.z, p.roll, p.pitch, p.yaw - DELTA_YAW);
                                                                        }
                                                                        break;
                // default behaviour
                default:                                        printf ("special key does nothing\n");
        }
}

void Demo::SetGlobalAmbientPlayback (float red, float green, float blue, float alpha)
{
        global_ambient_playback[0] = red;
        global_ambient_playback[1] = green;
        global_ambient_playback[2] = blue;
        global_ambient_playback[3] = alpha;
}

void Demo::SetGlobalAmbientMonitor (float red, float green, float blue, float alpha)
{
        global_ambient_monitor[0] = red;
        global_ambient_monitor[1] = green;
        global_ambient_monitor[2] = blue;
        global_ambient_monitor[3] = alpha;
}

void Demo::SetGlobalSpecularReflection (float red, float green, float blue, float alpha)
{
        global_specular_reflection[0] = red;
        global_specular_reflection[1] = green;
        global_specular_reflection[2] = blue;
        global_specular_reflection[3] = alpha;
}

void Demo::SetGlobalShininess (int shininess_)
{
        global_shininess = shininess_;
}

Demo * Demo::current_demo = NULL;

void Demo::static_display ()
{
        if (Demo::current_demo != NULL) Demo::current_demo->DisplayLoop ();
}

void Demo::static_idle ()
{
        if (Demo::current_demo != NULL) Demo::current_demo->IdleLoop ();
}

void Demo::static_reshape (int w, int h)
{
        if (Demo::current_demo != NULL) Demo::current_demo->Reshape (w, h);
}

void Demo::static_keyboard (unsigned char key, int x, int y)
{
        if (Demo::current_demo != NULL) Demo::current_demo->Keyboard (key, x, y);
}

void Demo::static_keyboard_special (int key, int x, int y)
{
        if (Demo::current_demo != NULL) Demo::current_demo->KeyboardSpecial (key, x, y);
}

void Demo::PrintUsage ()
{
        printf ("\n");
        printf ("Usage:\n");
        printf ("\n");
        printf ("windowed   mode: demo.exe [WIDTH HEIGHT]\n");
        printf ("fullscreen mode: demo.exe WIDTHxHEIGHT:BPP@REFRESHRATE\n");
        printf ("\n");
        printf ("Keys:\n");
        printf ("\n");
        printf ("[p]:       start/stop playback of the demo.\n");
        printf ("[m]:      enter/exit monitoring mode (see explanation below).\n");
        printf ("[c]:      switch between different view frustum culling modes.\n");
        printf ("              - none: no view frustum culling applied.\n");
        printf ("              - sphere: view frustum culling using bounding spheres.\n");
        printf ("              - bounding box: view frustum culling using bounding boxes.\n");
        printf ("              - mixed: view frustum culling using both bounding spheres\n                       and bounding boxes.\n");
        printf ("[l]:      turn level of detail on/off.\n");
        printf ("[LEFT]:    turn camera to the left during monitoring mode.\n");
        printf ("[RIGHT]:   turn camera to the right during monitoring mode.\n");
        printf ("[UP]:      turn camera upwards during monitoring mode.\n");
        printf ("[DOWN]:    turn camera downwards during monitoring mode.\n");
        printf ("[HOME]:    move camera forward during monitoring mode.\n");
        printf ("[END]:     move camera backwards during monitoring mode.\n");
        printf ("[DELETE]:  move camera to the left during monitoring mode.\n");
        printf ("[PGDN]:    move camera to the right during monitoring mode.\n");
        printf ("[INSERT]:  move camera upwards during monitoring mode.\n");
        printf ("[PGUP]:    move camera downwards during monitoring mode.\n");
        printf ("[ESCAPE]:  exit if in fullscreen mode.\n");
        printf ("\n");
        printf ("Monitoring mode:\n");
        printf ("\n");
        printf ("During monitoring mode, the camera may be moved around freely. The camera\n");
        printf ("which captures the scene as well as its viewing frustum are displayed along\n");
        printf ("with the bounding volumes of the objects. These volumes are colored\n");
        printf ("differently depending on the outcome of the view frustum culling test (red:\n");
        printf ("fully outside, green: fully inside, brown: partial). Please note that you can\n");
        printf ("always pause/resume playback of the scene at your own free will without leaving\n");
        printf ("monitoring mode.\n");
        printf ("\n");
        printf ("Note:\n");
        printf ("\n");
        printf ("The keys will only work if the DISPLAY WINDOW is activate. If this CONSOLE\n");
        printf ("WINDOW is active, nothing will happen.\n");
        printf ("\n");
}

---