source: GTP/trunk/App/Demos/Vis/CHC_revisited/chcdemo.cpp @ 2773

// occquery.cpp : Defines the entry point for the console application.
//
#include <math.h>
#include <time.h>
#include "common.h"
#include "glInterface.h"
#include "RenderTraverser.h"
#include "SceneEntity.h"
#include "Vector3.h"
#include "Matrix4x4.h"
#include "BinaryLoader.h"
#include "Bvh.h"
#include "Camera.h"
#include "Geometry.h"
#include "BvhLoader.h"
#include "FrustumCullingTraverser.h"
#include "StopAndWaitTraverser.h"
#include "CHCTraverser.h"
#include "CHCPlusPlusTraverser.h"
#include "Visualization.h"
#include "RenderState.h"


using namespace std;
using namespace CHCDemo;



/// the renderable scene geometry
SceneEntityContainer sceneEntities;
// traverses and renders the hierarchy
RenderTraverser *traverser = NULL;
/// the hierarchy
Bvh *bvh = NULL;
/// the scene camera
Camera *camera = NULL;
/// the visualization
Visualization *visualization = NULL;
/// the current render state
RenderState state;
/// the rendering algorithm
int renderMode = RenderTraverser::CULL_FRUSTUM;
// eye near plane distance
float nearDist = 0.1f; 
/// the pixel threshold where a node is still considered invisible
int threshold;


const float keyForwardMotion = 1.0f;
const float keyRotation = 0.2f;

bool useRenderQueue = false;

int winWidth = 1024;
int winHeight = 768;
float winAspectRatio = 1.0f;

float visZoomFactor = 1.5f;

long accumulatedTime = 1000;
float fps = 1e3f;

int renderedObjects = 0;
int renderedNodes = 0;
int renderedTriangles = 0;

int issuedQueries = 0;
int traversedNodes = 0;
int frustumCulledNodes = 0;
int queryCulledNodes = 0;
int stateChanges = 0;

bool showHelp = false;
bool showStatistics = true;
bool showBoundingVolumes = false;
bool visMode = false;

//mouse navigation state
int xEyeBegin, yEyeBegin, yMotionBegin, verticalMotionBegin, horizontalMotionBegin = 0;

bool useOptimization = false;


void InitExtensions();
void DisplayVisualization();
void InitGLstate();
void CleanUp();
void SetupEyeView();
void UpdateEyeMtx();
void SetupLighting();
void DisplayStats();
void Output(int x, int y, const char *string);

void begin2D();
void end2D();
void keyboard(unsigned char c, int x, int y);
void drawHelpMessage();
void drawStatistics();
void display(void);
void special(int c, int x, int y);
void reshape(int w, int h);
void mouse(int button, int state, int x, int y);
void leftMotion(int x, int y);
void rightMotion(int x, int y);
void middleMotion(int x, int y);
void drawEyeView(void);
void setupVisView(void);
long calcRenderTime(void);
void CalcDecimalPoint(std::string &str, int d);
void ResetTraverser();



int main(int argc, char* argv[])
{
        camera = new Camera(winWidth, winHeight);
        camera->SetNear(nearDist);

        glutInitWindowSize(winWidth, winHeight);
        glutInit(&argc, argv);
        glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);

        glutCreateWindow("Coherent Hierarchical Culling");

        glutDisplayFunc(display);
        glutKeyboardFunc(keyboard);
        glutSpecialFunc(special);
        glutReshapeFunc(reshape);
        glutMouseFunc(mouse);
        glutIdleFunc(display);
        
        InitExtensions();
        InitGLstate();

        leftMotion(0, 0);
        middleMotion(0, 0);

        BinaryLoader loader;

        //const string filename("house_test.dem");
        //const string filename("city_demo.dem");
        const string filename("city.dem");
        //const string filename("roofs.dem");

        if (loader.Load(filename, sceneEntities))
                cout << "scene " << filename << " loaded" << endl;
        else
                cerr << "loading scene " << filename << " failed" << endl;

        BvhLoader bvhLoader;
        //bvh = bvhLoader.Load("roofs.bvh", sceneEntities);
        bvh = bvhLoader.Load("city.bvh", sceneEntities);
        //bvh = bvhLoader.Load("city_demo.bvh", sceneEntities);
        //bvh = bvhLoader.Load("house_test.bvh", sceneEntities);

        bvh->SetCamera(camera);
        ResetTraverser();

        //camera->LookAtBox(sceneBox);
        //camera->LookInBox(bvh->GetBox());

        camera->SetDirection(Vector3(0.961829f, 0.273652f, 0.0f));
        camera->SetPosition(Vector3(483.398f, 242.364f, 186.078f));

        glutMainLoop();

        // clean up
        CleanUp();

        return 0;
}


void InitGLstate(void) 
{
        glClearColor(0.5f, 0.5f, 0.8f, 0.0f);
        
        glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
        glPixelStorei(GL_PACK_ALIGNMENT,1); 
        
        glDepthFunc(GL_LESS);
        glEnable(GL_DEPTH_TEST);

        SetupLighting();

        glColor3f(1.0f, 1.0f, 1.0f);
        glShadeModel(GL_SMOOTH);
        
        glMaterialf(GL_FRONT, GL_SHININESS, 64);
        glEnable(GL_NORMALIZE);
                
        //glEnable(GL_ALPHA_TEST);
        glDisable(GL_ALPHA_TEST);
        glAlphaFunc(GL_GEQUAL, 0.1f);

        glFrontFace(GL_CCW);
        glCullFace(GL_BACK);
        glEnable(GL_CULL_FACE);
        //glDisable(GL_CULL_FACE);
        

        GLfloat ambientColor[] = {0.5, 0.5, 0.5, 1.0};
        GLfloat diffuseColor[] = {1.0, 0.0, 0.0, 1.0};
        GLfloat specularColor[] = {0.0, 0.0, 0.0, 1.0};

        glMaterialfv(GL_FRONT, GL_AMBIENT, ambientColor);
        glMaterialfv(GL_FRONT, GL_DIFFUSE, diffuseColor);
        glMaterialfv(GL_FRONT, GL_SPECULAR, specularColor);
        //setupVisView();
}


void drawHelpMessage(void) 
{
        const char *message[] = 
        {
                "Help information",
                "",
                "'F1'           - shows/dismisses this message",
                "'F2'           - decreases number of objects (valid after scene recreation)",
                "'F3'           - increases number of objects (valid after scene recreation)",
                "'F4'           - decreases box length in z direction (valid after scene recreation)",
                "'F5'           - increases box length in z direction (valid after scene recreation)",
                "'F6'           - decreases object size (valid after scene recreation)",
                "'F7'           - increases object size (valid after scene recreation)",
                "'F8'           - cycles through object types (teapot, ...) (valid after scene recreation)",
                "",
                "'MOUSE-LEFT'   - turn left/right, move forward/backward",
                "'MOUSE-RIGHT'  - turn left/right, move forward/backward",
                "'MOUSE-MIDDLE' - move up/down, left/right",
                "'CURSOR UP'    - move forward",
                "'CURSOR BACK'  - move backward",
                "'CURSOR RIGHT' - turn right",
                "'CURSOR LEFT'  - turn left",
                "",
                "'SPACE'        - cycles through occlusion culling algorithms",
                "'-'            - decreases visibility threshold",
                "'+'            - increases visibility threshold",
                "'C'            - recreates the scene hierarchy",
                "'G'            - enables/disables optimization to take geometry as occluder",
                "'N'            - triggers NV / ARB queries",
                "",
                "'R'            - shows/hides recreation parameters",
                "'S'            - shows/hides statistics",
                "'V'            - shows/hides bounding volumes",
                "",
                "'1'            - shows/hides visualization",
                "'2'            - zooms out visualization",
                "'3'            - zooms in visualization",
                0,
        };
        
        
        int x = 40, y = 42;

        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        glEnable(GL_BLEND);
        glColor4f(0.0f, 1.0f , 0.0f, 0.2f);  // 20% green. 

        // Drawn clockwise because the flipped Y axis flips CCW and CW. 
        glRecti(winWidth - 30, 30, 30, winHeight - 30);
        
        glDisable(GL_BLEND);
        
        glColor3f(1.0f, 1.0f, 1.0f);
        
        for(int i = 0; message[i] != 0; i++) 
        {
                if(message[i][0] == '\0') 
                {
                        y += 7;
                } 
                else 
                {
                        Output(x, y, message[i]);
                        y += 14;
                }
        }

}


void ResetTraverser()
{
        DEL_PTR(traverser);

        bvh->ResetNodeClassifications();

        switch (renderMode)
        {
        case RenderTraverser::CULL_FRUSTUM:
                traverser = new FrustumCullingTraverser();
                break;
        case RenderTraverser::STOP_AND_WAIT:
                traverser = new StopAndWaitTraverser();
                break;
        case RenderTraverser::CHC:
                traverser = new CHCTraverser();
                break;
        case RenderTraverser::CHCPLUSPLUS:
                traverser = new CHCPlusPlusTraverser();
                break;
        
        default:
                traverser = new FrustumCullingTraverser();
        }

        traverser->SetCamera(camera);
        traverser->SetHierarchy(bvh);
        traverser->SetRenderState(&state);
        traverser->SetUseOptimization(useOptimization);
        traverser->SetUseRenderQueue(useRenderQueue);
        traverser->SetVisibilityThreshold(threshold);
}


void SetupLighting()
{
        glEnable(GL_LIGHTING);
        glEnable(GL_LIGHT0);
        glEnable(GL_LIGHT1);

        //glDisable(GL_LIGHT1);
        //glDisable(GL_LIGHTING);

        //GLfloat ambient[] = {0.5, 0.5, 0.5, 1.0};
        GLfloat ambient[] = {0.2, 0.2, 0.2, 1.0};
        GLfloat diffuse[] = {1.0, 1.0, 1.0, 1.0};
        GLfloat specular[] = {1.0, 1.0, 1.0, 1.0};
            
        GLfloat lmodel_ambient[] = {0.5f, 0.5f, 0.5f, 1.0f};
        //GLfloat lmodel_ambient[] = {0.2f, 0.2f, 0.2f, 1.0f};

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

        GLfloat position[] = {1.0, 1.0, 1.0, 0.0};
        glLightfv(GL_LIGHT0, GL_POSITION, position);


        ////////////
        //-- second light

        GLfloat ambient1[] = {0.5, 0.5, 0.5, 1.0};
        //GLfloat diffuse1[] = {1.0, 1.0, 1.0, 1.0};
        GLfloat diffuse1[] = {0.5, 0.5, 0.5, 1.0};
        GLfloat specular1[] = {0.5, 0.5, 0.5, 1.0};

        glLightfv(GL_LIGHT1, GL_AMBIENT, ambient1);
        glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuse1);
        glLightfv(GL_LIGHT1, GL_SPECULAR, specular1);
        
        GLfloat position1[] = {0.0, 1.0, 0.0, 1.0};
        glLightfv(GL_LIGHT1, GL_POSITION, position1);

        glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
        glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
        //glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_FALSE);
        //glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL_EXT, GL_SEPARATE_SPECULAR_COLOR_EXT);
        glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL_EXT, GL_SINGLE_COLOR_EXT);

}

void SetupEyeView(void)
{
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();

        gluPerspective(60.0f, 1.0f / winAspectRatio, nearDist, 2.0f * Magnitude(bvh->GetBox().Diagonal()));

        glMatrixMode(GL_MODELVIEW);
        camera->SetupCameraView();

        GLfloat position[] = {0.8f, 1.0f, 1.5f, 0.0f};
        glLightfv(GL_LIGHT0, GL_POSITION, position);

        GLfloat position1[] = {bvh->GetBox().Center().x, bvh->GetBox().Max().y, bvh->GetBox().Center().z, 1.0f};
        glLightfv(GL_LIGHT1, GL_POSITION, position1);
}


void display(void) 
{
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        // bring eye modelview matrix up-to-date
        SetupEyeView();

        //cout << camera->GetDirection() << " " << camera->GetPosition() << endl;
        // actually render the scene geometry using one of the specified algorithms
        traverser->RenderScene();
        
        //if(visMode) displayVisualization();
        
        DisplayStats();

        glutSwapBuffers();
}


#pragma warning( disable : 4100 )
void keyboard(const unsigned char c, const int x, const int y) 
{
        // used to avoid vertical motion with the keys
        Vector3 hvec = Vector3(camera->GetDirection()[0], camera->GetDirection()[1], 0.0f);
        Vector3 uvec = Vector3(0, 0, 1);
        
        switch(c) 
        {
        case 27:
                exit(0);
                break;
        case 32: //space
                renderMode = (renderMode + 1) % RenderTraverser::NUM_RENDERMODES;
                ResetTraverser();
                break;
        case 'h':
        case 'H':
                showHelp = !showHelp;
                break;
        case 'v':
        case 'V':
                showBoundingVolumes = !showBoundingVolumes;
                //HierarchyNode::SetRenderBoundingVolume(showBoundingVolumes);
                break;
        case 'O':
        case 'o':
                showStatistics = !showStatistics;
                break;
        case '+':
                threshold += 10;
                traverser->SetVisibilityThreshold(threshold);
                break;
        case '-':
                threshold -= 10;
                if(threshold < 0) threshold = 0;
                traverser->SetVisibilityThreshold(threshold);           
                break;
        case '1':
                visMode = !visMode;
                break;
        case '2':
                visZoomFactor += 0.1;   
                setupVisView();
                break;
        case '3':
                visZoomFactor -= 0.1;
                if(visZoomFactor < 0.1) visZoomFactor = 0.1;
        
                setupVisView();
                break;
        case '8':
                {
                        Vector3 pos = camera->GetPosition();
                        pos += uvec * keyForwardMotion;
                        camera->SetPosition(pos);
                        break;
                }
        case '9':
                {
                        Vector3 pos = camera->GetPosition();
                        pos -= uvec * keyForwardMotion;
                        camera->SetPosition(pos);
                        break;
                }       
        case 'g':
        case 'G':
                useOptimization = !useOptimization;
                traverser->SetUseOptimization(useOptimization);
                break;
        case 'a':
        case 'A':
                {
                        Vector3 viewDir = camera->GetDirection();
                        // rotate view vector
                        Matrix4x4 rot = RotationZMatrix(keyRotation);
                        viewDir = rot * viewDir;
                        camera->SetDirection(viewDir);
                }
                break;
        case 'd':
        case 'D':
        {
                        Vector3 viewDir = camera->GetDirection();
                        // rotate view vector
                        Matrix4x4 rot = RotationZMatrix(-keyRotation);
                        viewDir = rot * viewDir;
                        camera->SetDirection(viewDir);
                }
                break;
        case 'w':
        case 'W':
                {
                        Vector3 pos = camera->GetPosition();
                        pos += hvec * keyForwardMotion;
                        camera->SetPosition(pos);
                }
                break;
        case 'x':
        case 'X':
                {
                        Vector3 pos = camera->GetPosition();
                        pos -= hvec * keyForwardMotion;
                        camera->SetPosition(pos);
                }
                break;
        case 'r':
        case 'R':
                {
                        useRenderQueue = !useRenderQueue;
                        traverser->SetUseRenderQueue(useRenderQueue);
                }
        default:
                return;
        }

        glutPostRedisplay();
}


void special(const int c, const int x, const int y) 
{
        // used to avoid vertical motion with the keys
        Vector3 hvec = Vector3(camera->GetDirection()[0], camera->GetDirection()[1], 0.0f);
        
        switch(c) 
        {
        case GLUT_KEY_F1:
                showHelp = !showHelp;
                break;
        case GLUT_KEY_LEFT:
                {
                        Vector3 viewDir = camera->GetDirection();
                        // rotate view vector
                        Matrix4x4 rot = RotationZMatrix(keyRotation);
                        viewDir = rot * viewDir;
                        camera->SetDirection(viewDir);
                }
                break;
        case GLUT_KEY_RIGHT:
                {
                        Vector3 viewDir = camera->GetDirection();
                        // rotate view vector
                        Matrix4x4 rot = RotationZMatrix(-keyRotation);
                        viewDir = rot * viewDir;
                        camera->SetDirection(viewDir);
                }
                break;
        case GLUT_KEY_UP:
                {
                        Vector3 pos = camera->GetPosition();
                        pos += hvec * 0.6f;
                        camera->SetPosition(pos);
                }
                break;
        case GLUT_KEY_DOWN:
                {
                        Vector3 pos = camera->GetPosition();
                        pos -= hvec * 0.6f;
                        camera->SetPosition(pos);
                }
                break;
        default:
                return;

        }

        glutPostRedisplay();
}

#pragma warning( default : 4100 )


void reshape(const int w, const int h) 
{
        winAspectRatio = 1.0f;

        glViewport(0, 0, w, h);
        
        winWidth = w;
        winHeight = h;

        if (w) winAspectRatio = (float) h / (float) w;

        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();

        gluPerspective(60.0f, 1.0f / winAspectRatio, nearDist, 2.0f * Magnitude(bvh->GetBox().Diagonal()));
        glMatrixMode(GL_MODELVIEW);

        glutPostRedisplay();
}


void mouse(int button, int state, int x, int y) 
{
        if ((button == GLUT_LEFT_BUTTON) && (state == GLUT_DOWN))
        {
                xEyeBegin = x;
                yMotionBegin = y;

                glutMotionFunc(leftMotion);
        }
        else if ((button == GLUT_RIGHT_BUTTON) && (state == GLUT_DOWN))
        {
                yEyeBegin = y;
                yMotionBegin = y;

                glutMotionFunc(rightMotion);
        }
        else if ((button == GLUT_MIDDLE_BUTTON) && (state == GLUT_DOWN))
        {
                horizontalMotionBegin = x;
                verticalMotionBegin = y;
                glutMotionFunc(middleMotion);
        }

        glutPostRedisplay();
}


/**     rotation for left/right mouse drag
        motion for up/down mouse drag
*/
void leftMotion(int x, int y) 
{
        static float eyeXAngle = 0.0f;

        Vector3 viewDir = camera->GetDirection();
        Vector3 pos = camera->GetPosition();

        // don't move in the vertical direction
        Vector3 horView(viewDir[0], viewDir[1], 0);
        
        eyeXAngle = 0.2f *  M_PI * (xEyeBegin - x) / 180.0;

        // rotate view vector
        Matrix4x4 rot = RotationZMatrix(eyeXAngle);
        viewDir = rot * viewDir;

        pos += horView * (yMotionBegin - y) * 0.2f;

        camera->SetDirection(viewDir);
        camera->SetPosition(pos);
        
        xEyeBegin = x;
        yMotionBegin = y;

        glutPostRedisplay();
}


/**     rotation for left / right mouse drag
        motion for up / down mouse drag
*/
void rightMotion(int x, int y) 
{
        static float eyeYAngle = 0.0f;

        Vector3 viewDir = camera->GetDirection();
        Vector3 right = camera->GetRightVector();

        eyeYAngle = -0.2f *  M_PI * (yEyeBegin - y) / 180.0;

        // rotate view vector
        Matrix4x4 rot = RotationAxisMatrix(right, eyeYAngle);
        viewDir = rot * viewDir;

        camera->SetDirection(viewDir);
                
        yEyeBegin = y;
        
        glutPostRedisplay();
}


// strafe
void middleMotion(int x, int y) 
{
        Vector3 viewDir = camera->GetDirection();
        Vector3 pos = camera->GetPosition();

        // the 90 degree rotated view vector 
        // y zero so we don't move in the vertical
        //Vector3 rVec(viewDir[0], 0, viewDir[2]);
        Vector3 rVec(viewDir[0], viewDir[1], 0);
        
        //Matrix4x4 rot = RotationYMatrix(M_PI * 0.5f);
        Matrix4x4 rot = RotationZMatrix(M_PI * 0.5f);
        rVec = rot * rVec;
        
        pos -= rVec * (x - horizontalMotionBegin) * 0.1f;
        //pos[1] += (verticalMotionBegin - y) * 0.1f;
        pos[2] += (verticalMotionBegin - y) * 0.1f;

        camera->SetPosition(pos);

        horizontalMotionBegin = x;
        verticalMotionBegin = y;

        glutPostRedisplay();
}


void InitExtensions(void) 
{
        GLenum err = glewInit();

        if (GLEW_OK != err) 
        {
                // problem: glewInit failed, something is seriously wrong
                fprintf(stderr,"Error: %s\n", glewGetErrorString(err));
                exit(1);
        }
        if  (!GLEW_ARB_occlusion_query)
        {
                printf("I require the GL_ARB_occlusion_query to work.\n");
                exit(1);
        }
}


void begin2D(void) 
{
        glDisable(GL_LIGHTING);
        glDisable(GL_DEPTH_TEST);

        glPushMatrix();
        glLoadIdentity();

        glMatrixMode(GL_PROJECTION);
        glPushMatrix();
        glLoadIdentity();
        gluOrtho2D(0, winWidth, winHeight, 0);
}


void end2D(void) 
{
        glPopMatrix();
        glMatrixMode(GL_MODELVIEW);
        glPopMatrix();

        glEnable(GL_LIGHTING);
        glEnable(GL_DEPTH_TEST);
}


void Output(int x, int y, const char *string) 
{
        if (string != 0) 
        {
                size_t len, i;
                glRasterPos2f(x, y);
                len = strlen(string);
                
                for (i = 0; i < len; ++ i) 
                {
                        glutBitmapCharacter(GLUT_BITMAP_HELVETICA_18, string[i]);
                }
        }
}


// displays the visualisation of the kd tree node culling
void displayVisualization()
{
        begin2D();
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        glEnable(GL_BLEND);
        glColor4f(0.0,0.0,0.0,0.5); 

        glRecti(winWidth, 0, winWidth / 2, winHeight / 2);
        glDisable(GL_BLEND);
        end2D();

        glViewport(winWidth / 2, winHeight / 2, winWidth, winHeight);
        glPushMatrix();
        //glLoadMatrixf((float *)visView.x);
        
        glClear(GL_DEPTH_BUFFER_BIT);

        ////////////
        // --- visualization of the occlusion culling
        visualization->Render();
        
        glPopMatrix();
        
        glViewport(0, 0, winWidth, winHeight);
}


/** Sets up view matrix in order to get a good position 
        for viewing the kd tree node culling
*/
void setupVisView()
{
        const Vector3 up(0.0, 0.0, 1.0);
        
        Vector3 visPos(24, 23, -6);
        
        visPos[0] *= visZoomFactor; 
        visPos[1] *= visZoomFactor; 
        visPos[2] *= visZoomFactor;

        Vector3 visDir = Vector3(-1.3f, -1, -1);
}


// cleanup routine after the main loop
void CleanUp()
{
        CLEAR_CONTAINER(sceneEntities);
        DEL_PTR(traverser);

        DEL_PTR(bvh);
        DEL_PTR(visualization);
}


// this function inserts a dezimal point after each 1000
void CalcDecimalPoint(string &str, int d)
{
        vector<int> numbers;
        char hstr[100];

        while (d != 0)
        {
                numbers.push_back(d % 1000);
                d /= 1000;
        }

        // first element without leading zeros
        if (numbers.size() > 0)
        {
                sprintf_s(hstr, "%d", numbers.back());
                str.append(hstr);
        }
        
        for (int i = (int)numbers.size() - 2; i >= 0; i--)
        {
                sprintf_s(hstr, ",%03d", numbers[i]);
                str.append(hstr);
        }
}


void DisplayStats()
{
        char *msg[] = {"Frustum Culling", "Stop and Wait",
                                    "CHC", "CHC ++"};

        char msg2[200];
        char msg3[200];
        char msg4[200];
        char msg5[200];


        char *optstr[2] = {"", ", using optimization"};
        
        static long renderTime = traverser->GetStats().mRenderTime;
        const float expFactor = 0.95f;
        renderTime = traverser->GetStats().mRenderTime * expFactor + (1.0f - expFactor) * renderTime;

        accumulatedTime += renderTime;

        if (accumulatedTime > 100) // update every fraction of a second
        {       
                accumulatedTime = 0;
                if (renderTime) fps = 1e3f / (float)renderTime;

                renderedObjects = traverser->GetStats().mNumRenderedGeometry;
                renderedNodes = traverser->GetStats().mNumRenderedNodes;
                renderedTriangles = traverser->GetStats().mNumRenderedTriangles;

                traversedNodes = traverser->GetStats().mNumTraversedNodes;
                frustumCulledNodes = traverser->GetStats().mNumFrustumCulledNodes;
                queryCulledNodes = traverser->GetStats().mNumQueryCulledNodes;
                issuedQueries = traverser->GetStats().mNumIssuedQueries;
                stateChanges = traverser->GetStats().mNumStateChanges;
        }

        sprintf_s(msg2, "threshold: %4d%s", threshold, optstr[useOptimization]);

        string str;
        string str2;

        CalcDecimalPoint(str, renderedTriangles);
        CalcDecimalPoint(str2, bvh->GetBvhStats().mTriangles);

        sprintf_s(msg3, "rendered nodes: %6d (of %6d), rendered triangles: %s (of %s)", 
                          renderedNodes, bvh->GetNumVirtualNodes(), str.c_str(), str2.c_str()); 

        sprintf_s(msg4, "traversed: %5d, frustum culled: %5d, query culled: %5d, issued queries: %5d, state changes: %5d",
                          traversedNodes, frustumCulledNodes, queryCulledNodes, issuedQueries, stateChanges);

        sprintf_s(msg5, "fps: %6.1f", fps);

        //cout << "previously visible node queries: " << traverser->GetStats().mNumPreviouslyVisibleNodeQueries << endl;

        begin2D();
        
        if(showHelp)
        {       
                drawHelpMessage();
        }
        else
        {
                glColor3f(1.0f, 1.0f, 1.0f);
                
                Output(850, 30, msg[renderMode]);

                if(showStatistics)
                {
                        Output(20, 30, msg2);
                        Output(20, 60, msg3);
                        Output(20, 90, msg4);
                        Output(20, 120, msg5);
                }
        }

        end2D();
}