source: GTP/trunk/App/Demos/Vis/FriendlyCulling/src/chcdemo.cpp @ 2850

// occquery.cpp : Defines the entry point for the console application.
//
#include "glInterface.h"
#include <math.h>
#include <time.h>
#include "common.h"
#include "RenderTraverser.h"
#include "SceneEntity.h"
#include "Vector3.h"
#include "Matrix4x4.h"
#include "ResourceManager.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"
#include "Timer/PerfTimer.h"
#include "SceneQuery.h"
#include "RenderQueue.h"
#include "Material.h"
#include <Cg/cg.h>
#include <Cg/cgGL.h>
#include "glfont2.h"
#include "PerformanceGraph.h"
#include "Environment.h"
#include "Halton.h"
#include "Transform3.h"


using namespace std;
using namespace CHCDemoEngine;


static Environment env;


/////////////
//-- fbos

GLuint fbo;
GLuint fbo1;
GLuint fbo2;

bool isFirstTexture = true;

/////////////
//-- renderbuffers


GLuint depthBuffer;

GLuint positionsBuffer;
GLuint colorsBuffer;
GLuint colorsBuffer1;
GLuint colorsBuffer2;
GLuint normalsBuffer;


/////////////
//-- textures


GLuint positionsTex;
GLuint colorsTex;
GLuint colorsTex1;
GLuint colorsTex2;

GLuint normalsTex;

GLuint noiseTex;

GLuint fontTex;

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

float fov = 50.0f;

int assumedVisibleFrames = 10;
int maxBatchSize = 50;

int trianglesPerVirtualLeaf = INITIAL_TRIANGLES_PER_VIRTUAL_LEAVES;

SceneQuery *sceneQuery = NULL;
RenderQueue *renderQueue = NULL;

/// these values get scaled with the frame rate
static float keyForwardMotion = 30.0f;
static float keyRotation = 1.5f;

/// elapsed time in milliseconds
double elapsedTime = 1000.0f;
double algTime = 1000.0f;

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

double accumulatedTime = 1000;
float fps = 1e3f;

float myfar = 0;

glfont::GLFont myfont;

// rendertexture
static int texWidth = 1024;
static int texHeight = 768;
//static int texWidth = 2048;
//static int texHeight = 2048;

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

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

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

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

bool useOptimization = false;
bool useTightBounds = true;
bool useRenderQueue = true;
bool useMultiQueries = true;
bool flyMode = true;

SceneEntityContainer skyGeometry;

bool leftKeyPressed = false;
bool rightKeyPressed = false;
bool upKeyPressed = false;
bool downKeyPressed = false;
bool descendKeyPressed = false;
bool ascendKeyPressed = false;

bool useSsao = false;

bool showAlgorithmTime = false;

GLubyte *randomNormals = NULL;

PerfTimer frameTimer, algTimer;

int renderType = RenderState::FIXED;

PerformanceGraph *perfGraph = NULL;

bool useFullScreen = false;

float expFactor = 0.1f;

// ssao number of samples
//#define NUM_SAMPLES 8
#define NUM_SAMPLES 16

// ssao random spherical samples
static float samples[NUM_SAMPLES * 2];

static Matrix4x4 matProjectionView = IdentityMatrix();


// function forward declarations
void InitExtensions();
void DisplayVisualization();
void InitGLstate();
void InitRenderTexture();
void InitCg();
void CleanUp();
void SetupEyeView();
void UpdateEyeMtx();
void SetupLighting();
void DisplayStats();
void Output(int x, int y, const char *string);
void DrawHelpMessage();
void RenderSky();
void RenderVisibleObjects();

void Begin2D();
void End2D();
void KeyBoard(unsigned char c, int x, int y);
void DrawStatistics();
void Display();
void Special(int c, int x, int y);
void KeyUp(unsigned char c, int x, int y);
void SpecialKeyUp(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 CalcDecimalPoint(string &str, int d);
void ResetTraverser();

void KeyHorizontalMotion(float shift);
void KeyVerticalMotion(float shift);

void PlaceViewer(const Vector3 &oldPos);
void DisplayRenderTexture();


inline float KeyRotationAngle() { return keyRotation * elapsedTime * 1e-3f; }
inline float KeyShift() { return keyForwardMotion * elapsedTime * 1e-3f; }

void InitFBO();

void CreateNoiseTex2D();

void ComputeViewVectors(Vector3 &tl, Vector3 &tr, Vector3 &bl, Vector3 &br);

void GenerateSamples();


GLenum mrt[] = {GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT, GL_COLOR_ATTACHMENT2_EXT};


/////////
//-- cg stuff

static CGcontext sCgContext = NULL;
static CGprogram sCgMrtVertexProgram = NULL;
static CGprogram sCgSsaoProgram = NULL;
static CGprogram sCgDeferredProgram = NULL;

static CGparameter sColorsTexParam;
static CGparameter sPositionsTexParam;
static CGparameter sNormalsTexParam;

static CGparameter sColorsTexParamSsao;
static CGparameter sPositionsTexParamSsao;
static CGparameter sNormalsTexParamSsao;
static CGparameter sNoiseTexParamSsao;

static CGparameter sModelViewProjMatrixParam;
static CGparameter sOldModelViewProjMatrixParam;
static CGparameter sMaxDepthParam;
static CGparameter sMaxDepthParamSsao;
static CGparameter sMaxDepthParamTex;

static CGparameter sSamplesParamSsao; 
static CGparameter sOldTexParamSsao;
static CGparameter sNoiseMultiplierParam;
static CGparameter sExpFactorParamSsao;


static void cgErrorCallback()
{
        CGerror lastError = cgGetError();

        if(lastError)
        {
                printf("%s\n\n", cgGetErrorString(lastError));
                printf("%s\n", cgGetLastListing(sCgContext));
                printf("Cg error, exiting...\n");

                exit(0);
        }
}


static void PrintGLerror(char *msg)
{
        GLenum errCode;
        const GLubyte *errStr;
        
        if ((errCode = glGetError()) != GL_NO_ERROR) 
        {
                errStr = gluErrorString(errCode);
                fprintf(stderr,"OpenGL ERROR: %s: %s\n", errStr, msg);
        }
}


int main(int argc, char* argv[])
{
        int returnCode = 0;

        Vector3 camPos(.0f, .0f, .0f);
        Vector3 camDir(.0f, 1.0f, .0f);

        cout << "=== reading environment file === " << endl;

        string envFileName = "default.env";
        if (!env.Read(envFileName))
        {
                cerr << "loading environment " << envFileName << " failed!" << endl;
        }
        else
        {
                env.GetIntParam(string("assumedVisibleFrames"), assumedVisibleFrames);
                env.GetIntParam(string("maxBatchSize"), maxBatchSize);
                env.GetIntParam(string("trianglesPerVirtualLeaf"), trianglesPerVirtualLeaf);

                env.GetFloatParam(string("keyForwardMotion"), keyForwardMotion);
                env.GetFloatParam(string("keyRotation"), keyRotation);

                env.GetIntParam(string("winWidth"), winWidth);
                env.GetIntParam(string("winHeight"), winHeight);

                env.GetBoolParam(string("useFullScreen"), useFullScreen);
                env.GetFloatParam(string("expFactor"), expFactor);
                env.GetVectorParam(string("camPosition"), camPos);
                env.GetVectorParam(string("camDirection"), camDir);

                //env.GetStringParam(string("modelPath"), model_path);
                //env.GetIntParam(string("numSssaoSamples"), numSsaoSamples);

                cout << "assumedVisibleFrames: " << assumedVisibleFrames << endl; 
                cout << "maxBatchSize: " << maxBatchSize << endl;
                cout << "trianglesPerVirtualLeaf: " << trianglesPerVirtualLeaf << endl;

                cout << "keyForwardMotion: " << keyForwardMotion << endl;
                cout << "keyRotation: " << keyRotation << endl;
                cout << "winWidth: " << winWidth << endl;
                cout << "winHeight: " << winHeight << endl;
                cout << "useFullScreen: " << useFullScreen << endl;
                cout << "camPosition: " << camPos << endl;
                cout << "expFactor: " << expFactor << endl;
                //cout << "model path: " << model_path << endl;
        }

        ///////////////////////////

        camera = new Camera(winWidth, winHeight, fov);
        camera->SetNear(nearDist);
        
        camera->SetDirection(camDir);
        camera->SetPosition(camPos);

        visCamera = new Camera(winWidth, winHeight, fov);

        visCamera->SetNear(0.0f);
        visCamera->Yaw(.5 * M_PI);

        renderQueue = new RenderQueue(&state, camera);

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

        //glutInitDisplayString("samples=2");

        if (!useFullScreen)
                glutCreateWindow("FriendlyCulling");
        else
        {
                glutGameModeString( "1024x768:32@75" ); 
                glutEnterGameMode(); 
        }

        glutDisplayFunc(Display);
        glutKeyboardFunc(KeyBoard);
        glutSpecialFunc(Special);
        glutReshapeFunc(Reshape);
        glutMouseFunc(Mouse);
        glutIdleFunc(Display);
        glutKeyboardUpFunc(KeyUp);
        glutSpecialUpFunc(SpecialKeyUp);
        glutIgnoreKeyRepeat(true);

        // initialise gl graphics
        InitExtensions();
        InitGLstate();

        glEnable(GL_MULTISAMPLE_ARB);
        glEnable(GL_SAMPLE_ALPHA_TO_COVERAGE_ARB);
        glHint(GL_MULTISAMPLE_FILTER_HINT_NV, GL_NICEST);

        InitFBO();
        
        LeftMotion(0, 0);
        MiddleMotion(0, 0);

        perfGraph = new PerformanceGraph(1000);

        loader = new ResourceManager();

        //const string filename("data/city/model/city.dem");
        const string filename = string(model_path + "city.dem");

        if (loader->Load(filename, sceneEntities))
                cout << "scene " << filename << " loaded" << endl;
        else
        {
                cerr << "loading scene " << filename << " failed" << endl;
                CleanUp();
                exit(0);
        }

        SceneEntityContainer dummy;

        const string envname = string(model_path + "env.dem");

        if (loader->Load(envname, skyGeometry))
                cout << "sky box " << filename << " loaded" << endl;
        else
        {
                cerr << "loading sky box " << filename << " failed" << endl;
                CleanUp();
                exit(0);
        }

        const string bvh_filename = string(model_path + "city.bvh");
        BvhLoader bvhLoader;
        bvh = bvhLoader.Load(bvh_filename, sceneEntities);

        if (!bvh)
        {
                cerr << "loading bvh " << bvh_filename << " failed" << endl;
                CleanUp();
                exit(0);
        }

        // set far plane based on scene extent
        myfar = 10.0f * Magnitude(bvh->GetBox().Diagonal());
        bvh->SetVirtualLeaves(trianglesPerVirtualLeaf);

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

        // create noise texture for ssao
        CreateNoiseTex2D();

        // init render traverser
        ResetTraverser();

        visualization = new Visualization(bvh, camera, NULL, &state);

        sceneQuery = new SceneQuery(bvh->GetBox(), traverser);

        // frame time is restarted every frame
        frameTimer.Start();


        glutMainLoop();

        // clean up
        CleanUp();

        return 0;
}


void InitCg(void) 
{
        // Setup Cg
        cgSetErrorCallback(cgErrorCallback);

        // Create cgContext.
        sCgContext = cgCreateContext();

        // get the best profile for this hardware
        RenderState::sCgFragmentProfile = cgGLGetLatestProfile(CG_GL_FRAGMENT);
        //assert(sCgFragmentProfile != CG_PROFILE_UNKNOWN);
        cgGLSetOptimalOptions(RenderState::sCgFragmentProfile);

        RenderState::sCgVertexProfile = cgGLGetLatestProfile(CG_GL_VERTEX);
        cgGLSetOptimalOptions(RenderState::sCgVertexProfile);

        sCgMrtVertexProgram = 
                cgCreateProgramFromFile(sCgContext, 
                                                                CG_SOURCE,
                                                                "src/shaders/mrt.cg", 
                                                                RenderState::sCgVertexProfile,
                                                                "vtx",
                                                                NULL);

        if (sCgMrtVertexProgram != NULL)
        {
                cgGLLoadProgram(sCgMrtVertexProgram);

                Transform3::sModelMatrixParam = cgGetNamedParameter(sCgMrtVertexProgram, "ModelMatrix");
                sModelViewProjMatrixParam = cgGetNamedParameter(sCgMrtVertexProgram, "ModelViewProj");
        }

        RenderState::sCgMrtFragmentTexProgram = 
                cgCreateProgramFromFile(sCgContext, 
                                                                CG_SOURCE,
                                                                "src/shaders/mrt.cg", 
                                                                RenderState::sCgFragmentProfile,
                                                                "fragtex",
                                                                NULL);

        if (RenderState::sCgMrtFragmentTexProgram != NULL)
        {
                cgGLLoadProgram(RenderState::sCgMrtFragmentTexProgram);

                sMaxDepthParamTex = cgGetNamedParameter(RenderState::sCgMrtFragmentTexProgram, "maxDepth");
                Material::sDiffuseTexParam = cgGetNamedParameter(RenderState::sCgMrtFragmentTexProgram, "diffuse");
                Material::sAmbientTexParam = cgGetNamedParameter(RenderState::sCgMrtFragmentTexProgram, "ambient");

                cgGLSetParameter1f(sMaxDepthParamTex, 10.0f / myfar);
                Debug << "maxdepth: " << 10.0f / myfar << endl;
        }
        else
                cerr << "fragment tex program failed to load" << endl;

        RenderState::sCgMrtFragmentProgram = 
                cgCreateProgramFromFile(sCgContext, 
                                                                CG_SOURCE,
                                                                "src/shaders/mrt.cg", 
                                                                RenderState::sCgFragmentProfile,
                                                                "frag",
                                                                NULL);

        if (RenderState::sCgMrtFragmentProgram != NULL)
        {
                cgGLLoadProgram(RenderState::sCgMrtFragmentProgram);

                sMaxDepthParam = cgGetNamedParameter(RenderState::sCgMrtFragmentProgram, "maxDepth");
                Material::sDiffuseParam = cgGetNamedParameter(RenderState::sCgMrtFragmentProgram, "diffuse");
                Material::sAmbientParam = cgGetNamedParameter(RenderState::sCgMrtFragmentProgram, "ambient");

                cgGLSetParameter1f(sMaxDepthParam, 10.0f / myfar);
        }
        else
                cerr << "fragment program failed to load" << endl;

        PrintGLerror("test");


        ///////////////

        sCgSsaoProgram = 
                cgCreateProgramFromFile(sCgContext, 
                                                                CG_SOURCE,
                                                                "src/shaders/deferred.cg", 
                                                                RenderState::sCgFragmentProfile,
                                                                "main_ssao",
                                                                NULL);

        if (sCgSsaoProgram != NULL)
        {
                cgGLLoadProgram(sCgSsaoProgram);

                // we need size of texture for scaling
                sPositionsTexParamSsao = cgGetNamedParameter(sCgSsaoProgram, "positions");  
                sColorsTexParamSsao = cgGetNamedParameter(sCgSsaoProgram, "colors");  
                sNormalsTexParamSsao = cgGetNamedParameter(sCgSsaoProgram, "normals");  
                sNoiseTexParamSsao = cgGetNamedParameter(sCgSsaoProgram, "noiseTexture");
                sNoiseMultiplierParam = cgGetNamedParameter(sCgSsaoProgram, "noiseMultiplier");
                sOldModelViewProjMatrixParam = cgGetNamedParameter(sCgSsaoProgram, "oldModelViewProj");
                sMaxDepthParamSsao = cgGetNamedParameter(sCgSsaoProgram, "maxDepth");
                sExpFactorParamSsao = cgGetNamedParameter(sCgSsaoProgram, "expFactor");

                cgGLSetParameter1f(sMaxDepthParamSsao, myfar / 10.0f);
                cgGLSetParameter1f(sExpFactorParamSsao, expFactor);

                sSamplesParamSsao = cgGetNamedParameter(sCgSsaoProgram, "samples");
                sOldTexParamSsao = cgGetNamedParameter(sCgSsaoProgram, "oldTex");  

                GenerateSamples(); cgGLSetParameterArray2f(sSamplesParamSsao, 0, NUM_SAMPLES, (const float *)samples);
        }
        else
                cerr << "ssao program failed to load" << endl;

        
        sCgDeferredProgram = 
                cgCreateProgramFromFile(sCgContext, 
                                                                CG_SOURCE,
                                                                "src/shaders/deferred.cg", 
                                                                RenderState::sCgFragmentProfile,
                                                                "main",
                                                                NULL);

        if (sCgDeferredProgram != NULL)
        {
                cgGLLoadProgram(sCgDeferredProgram);

                // we need size of texture for scaling
                sPositionsTexParam = cgGetNamedParameter(sCgDeferredProgram, "positions");  
                sColorsTexParam = cgGetNamedParameter(sCgDeferredProgram, "colors");  
                sNormalsTexParam = cgGetNamedParameter(sCgDeferredProgram, "normals"); 
        }
        else
                cerr << "deferred program failed to load" << endl;


        PrintGLerror("init");

        cout << "cg initialization successful" << endl;
}


void PrintFBOStatus(GLenum status)
{
        switch(status)
        {
        case GL_FRAMEBUFFER_COMPLETE_EXT:
                cout << "frame buffer object created successfully" << endl;
                break;
        case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT:
                cerr << "incomplete attachment" << endl;
                break;
        case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT:
                cerr << "missing attachment" << endl;
                break;
        case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT:
                cerr << "incomplete dimensions" << endl;
                break;
        case GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT:
                cerr << "incomplete formats" << endl;
                break;
        case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT:
                cerr << "incomplete draw buffer" << endl;
                break;
        case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT:
                cerr << "incomplete read buffer" << endl;
                break;
        case GL_FRAMEBUFFER_UNSUPPORTED_EXT:
                cerr << "framebuffer unsupported" << endl;
                break;
        default:
                cerr << "unknown status code " << status << endl;
        }
}


void InitFBO()
{
        glGenFramebuffersEXT(1, &fbo);
        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);

        
        ////////////
        //-- colors buffer

        glGenRenderbuffersEXT(1, &colorsBuffer);
        glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, colorsBuffer);
        
        glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGBA32F_ARB, texWidth, texHeight);

        int samples = 8;
        //glEnable(GL_MULTISAMPLE_ARB);
        //glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, samples, GL_RGBA8, texWidth, texHeight);
        glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, colorsBuffer);
        
        glGenTextures(1, &colorsTex);
        glBindTexture(GL_TEXTURE_2D, colorsTex);

        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F_ARB, texWidth, texHeight, 0, GL_RGBA, GL_FLOAT, NULL);
        //glGenerateMipmapEXT(GL_TEXTURE_2D);
        glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, colorsTex, 0);

        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);


        //////////
        //-- positions buffer

        PrintFBOStatus(glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT));
        glGenRenderbuffersEXT(1, &positionsBuffer);
        glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, positionsBuffer);
        glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGBA32F_ARB, texWidth, texHeight);

        glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT1_EXT, GL_RENDERBUFFER_EXT, positionsBuffer);

        glGenTextures(1, &positionsTex);
        glBindTexture(GL_TEXTURE_2D, positionsTex);
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F_ARB, texWidth, texHeight, 0, GL_RGBA, GL_FLOAT, NULL);
        //glGenerateMipmapEXT(GL_TEXTURE_2D);
        glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT1_EXT, GL_TEXTURE_2D, positionsTex, 0);

        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

        PrintFBOStatus(glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT));
        
        
        ////////
        //-- normals buffer

        glGenRenderbuffersEXT(1, &normalsBuffer);
        glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, normalsBuffer);
        glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGBA8, texWidth, texHeight);
        
        glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT2_EXT, GL_RENDERBUFFER_EXT, normalsBuffer);

        glGenTextures(1, &normalsTex);
        glBindTexture(GL_TEXTURE_2D, normalsTex);
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, texWidth, texHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
        glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT2_EXT, GL_TEXTURE_2D, normalsTex, 0);

        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

        PrintFBOStatus(glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT));


        ///////////
        //-- create depth buffer

        glGenRenderbuffersEXT(1, &depthBuffer); 
        glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depthBuffer);
        glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, texWidth, texHeight);
        glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depthBuffer);

        
        PrintFBOStatus(glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT));
        
        

        //////////////////////////////////



        glGenFramebuffersEXT(1, &fbo1);
        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo1);

        
        ////////////
        //-- colors buffer

        glGenRenderbuffersEXT(1, &colorsBuffer1);
        glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, colorsBuffer1);
        
        glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGBA32F_ARB, texWidth, texHeight);
        glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, colorsBuffer1);
        
        glGenTextures(1, &colorsTex1);
        glBindTexture(GL_TEXTURE_2D, colorsTex1);

        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F_ARB, texWidth, texHeight, 0, GL_RGBA, GL_FLOAT, NULL);
        //glGenerateMipmapEXT(GL_TEXTURE_2D);
        glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, colorsTex1, 0);

        //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);

        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

        PrintFBOStatus(glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT));



        /////////////////////////

        glGenFramebuffersEXT(1, &fbo2);
        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo2);

        
        ////////////
        //-- colors buffer

        glGenRenderbuffersEXT(1, &colorsBuffer2);
        glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, colorsBuffer2);
        
        glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGBA32F_ARB, texWidth, texHeight);
        glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, colorsBuffer2);
        
        glGenTextures(1, &colorsTex2);
        glBindTexture(GL_TEXTURE_2D, colorsTex2);

        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F_ARB, texWidth, texHeight, 0, GL_RGBA, GL_FLOAT, NULL);
        //glGenerateMipmapEXT(GL_TEXTURE_2D);
        glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, colorsTex2, 0);

        //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);

        //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
        //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

        PrintFBOStatus(glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT));

        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);

        PrintGLerror("fbo");
}


bool InitFont(void)
{
        glEnable(GL_TEXTURE_2D);

        glGenTextures(1, &fontTex);
        glBindTexture(GL_TEXTURE_2D, fontTex);
        if (!myfont.Create("data/fonts/verdana.glf", fontTex))
                return false;

        glDisable(GL_TEXTURE_2D);
        
        return true;
}


void InitGLstate() 
{
        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.8f);

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

        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);

        glDepthFunc(GL_LESS);

        if (!InitFont())
                cerr << "font creation failed" << endl;
        else
                cout << "successfully created font" << endl;
}


void DrawHelpMessage() 
{
        const char *message[] = 
        {
                "Help information",
                "",
                "'F1'           - shows/dismisses this message",
                "'F2'           - shows/hides bird eye view",
                "'F3'           - shows/hides bounds (boxes or tight bounds)",
                "'F4',          - shows/hides parameters",
                "'F5'           - shows/hides statistics",
                "'F6',          - toggles between fly/walkmode",
                "'F7',          - cycles throw render modes",
                "'F8',          - enables/disables ambient occlusion (only deferred)",
                "'F9',          - shows pure algorithm render time (using glFinish)",
                "'SPACE'        - cycles through occlusion culling algorithms",
                "",
                "'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/DOWN'    - move forward/backward",
                "'CURSOR LEFT/RIGHT' - turn left/right",
                "",
                "'-'/'+'        - decreases/increases max batch size",
                "'1'/'2'        - downward/upward motion",
                "'3'/'4'        - decreases/increases triangles per virtual bvh leaf (sets bvh depth)",
                "'5'/'6'        - decreases/increases assumed visible frames",
                "",
                "'R'            - use render queue",
                "'B'            - use tight bounds",
                "'M'            - use multiqueries",
                "'O'            - use CHC optimization (geometry queries for leaves)",
                0,
        };
        
        
        glColor4f(0.0f, 1.0f , 0.0f, 0.2f); // 20% green. 

        glRecti(30, 30, winWidth - 30, winHeight - 30);

        glEnd();

        glColor3f(1.0f, 1.0f, 1.0f);
        
        glEnable(GL_TEXTURE_2D);
        myfont.Begin();

        int x = 40, y = 30;

        for(int i = 0; message[i] != 0; ++ i) 
        {
                if(message[i][0] == '\0') 
                {
                        y += 15;
                } 
                else 
                {
                        myfont.DrawString(message[i], x, winHeight - y);
                        y += 25;
                }
        }
        glDisable(GL_TEXTURE_2D);
}


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->SetRenderQueue(renderQueue);
        traverser->SetRenderState(&state);
        traverser->SetUseOptimization(useOptimization);
        traverser->SetUseRenderQueue(useRenderQueue);
        traverser->SetVisibilityThreshold(threshold);
        traverser->SetAssumedVisibleFrames(assumedVisibleFrames);
        traverser->SetMaxBatchSize(maxBatchSize);
        traverser->SetUseMultiQueries(useMultiQueries);
        traverser->SetUseTightBounds(useTightBounds);
        traverser->SetUseDepthPass(renderType == RenderState::DEPTH_PASS);
        traverser->SetRenderQueue(renderQueue);
}


void SetupLighting()
{
        glEnable(GL_LIGHTING);
        glEnable(GL_LIGHT0);
        glEnable(GL_LIGHT1);
        
        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.3f, 0.3f, 0.3f, 1.0f};

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


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

        GLfloat ambient1[] = {0.2, 0.2, 0.2, 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.0, 0.0, 0.0, 1.0};

        glLightfv(GL_LIGHT1, GL_AMBIENT, ambient1);
        glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuse1);
        glLightfv(GL_LIGHT1, GL_SPECULAR, specular1);

        
        //////////////////////////////

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

        GLfloat position1[] = {-0.5f, 0.5f, 0.4f, 0.0f};
        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_COLOR_CONTROL_EXT, GL_SINGLE_COLOR_EXT);
}


void SetupEyeView()
{
        Matrix4x4 matViewing, matProjection;

        if (renderType == RenderState::DEFERRED)
        {
                cgGLSetMatrixParameterfc(sOldModelViewProjMatrixParam, (const float *)matProjectionView.x);
        }

        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();

        gluPerspective(fov, winAspectRatio, nearDist, myfar);

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

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

        GLfloat position1[] = {-0.5f, 0.5f, 0.4f, 0.0f};
        glLightfv(GL_LIGHT1, GL_POSITION, position1);

        
        camera->GetModelViewMatrix(matViewing);
        camera->GetProjectionMatrix(matProjection);

        matProjectionView = matViewing * matProjection;
        
        if (renderType == RenderState::DEFERRED)
        {
                // set modelview matrix for shaders
                cgGLSetStateMatrixParameter(sModelViewProjMatrixParam, 
                                                                        CG_GL_MODELVIEW_PROJECTION_MATRIX, 
                                                                        CG_GL_MATRIX_IDENTITY);

                static Matrix4x4 identity = IdentityMatrix();
                cgGLSetMatrixParameterfc(Transform3::sModelMatrixParam, (const float *)identity.x);
        }               
}


void KeyHorizontalMotion(float shift)
{
        Vector3 hvec = camera->GetDirection();
        hvec.z = 0;

        Vector3 pos = camera->GetPosition();
        pos += hvec * shift;
        
        camera->SetPosition(pos);
}


void KeyVerticalMotion(float shift)
{
        Vector3 uvec = Vector3(0, 0, shift);

        Vector3 pos = camera->GetPosition();
        pos += uvec;
        
        camera->SetPosition(pos);
}


void Display() 
{       
        Vector3 oldPos = camera->GetPosition();

        if (leftKeyPressed)
                camera->Pitch(KeyRotationAngle());
        if (rightKeyPressed)
                camera->Pitch(-KeyRotationAngle());
        if (upKeyPressed)
                KeyHorizontalMotion(KeyShift());
        if (downKeyPressed)
                KeyHorizontalMotion(-KeyShift());
        if (ascendKeyPressed)
                KeyVerticalMotion(KeyShift());
        if (descendKeyPressed)
                KeyVerticalMotion(-KeyShift());

        // place view on ground
        if (!flyMode) PlaceViewer(oldPos);

        if (showAlgorithmTime)
        {
                glFinish();
                algTimer.Start();
        }
        
        // render without shading
        switch (renderType)
        {
        case RenderState::FIXED:
        
                glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);

                state.SetRenderType(RenderState::FIXED);
                glEnable(GL_LIGHTING);

                cgGLDisableProfile(RenderState::sCgFragmentProfile);
                cgGLDisableProfile(RenderState::sCgVertexProfile);

                glDrawBuffers(1, mrt);

                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

                break;

        case RenderState::DEPTH_PASS:
                glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);

                state.SetRenderType(RenderState::DEPTH_PASS);
                glDisable(GL_LIGHTING);

                cgGLDisableProfile(RenderState::sCgFragmentProfile);
                cgGLDisableProfile(RenderState::sCgVertexProfile);
        
                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

                glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);

                glDrawBuffers(1, mrt);

                break;
        
        case RenderState::DEFERRED:
                state.SetRenderType(RenderState::DEFERRED);

                glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
        
                glPushAttrib(GL_VIEWPORT_BIT);
                glViewport(0, 0, texWidth, texHeight);

                cgGLEnableProfile(RenderState::sCgFragmentProfile);
                cgGLBindProgram(RenderState::sCgMrtFragmentProgram);

                cgGLEnableProfile(RenderState::sCgVertexProfile);
                cgGLBindProgram(sCgMrtVertexProgram);

                glDrawBuffers(3, mrt);

                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

                break;
        }


        glDepthFunc(GL_LESS);

        glDisable(GL_TEXTURE_2D);
        glDisableClientState(GL_TEXTURE_COORD_ARRAY);
                

        LODLevel::InitFrame(camera->GetPosition());


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


        /*state.Reset();
        state.SetState(RenderState::RENDER);
        
        glEnableClientState(GL_VERTEX_ARRAY);
        glEnableClientState(GL_NORMAL_ARRAY);

        for (int i = 0; i < loader->mSceneEntities.size(); ++ i)
        {
                SceneEntity *ent = loader->mSceneEntities[i];

                ent->UpdateLODs(camera);
                ent->Render(&state);
        }*/

        // actually render the scene geometry using one of the specified algorithms
        traverser->RenderScene();



        /////////
        //-- do the rest of the rendering

        glEnableClientState(GL_VERTEX_ARRAY);
        glEnableClientState(GL_NORMAL_ARRAY);


        // reset depth pass and render visible objects
        if (renderType == RenderState::DEPTH_PASS) 
        {
                glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
                RenderVisibleObjects();
        }
        

        ///////////////
        //-- render sky

        RenderSky();

        state.Reset();

        glDisableClientState(GL_VERTEX_ARRAY);
        glDisableClientState(GL_NORMAL_ARRAY);

        if (renderType == RenderState::DEFERRED) 
        {
                glPopAttrib();
                glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);

                cgGLDisableProfile(RenderState::sCgVertexProfile);
                cgGLDisableProfile(RenderState::sCgFragmentProfile);

                glDrawBuffers(1, mrt);

                DisplayRenderTexture();
        }

        
        ///////////

        state.SetRenderType(RenderState::FIXED);

        if (showAlgorithmTime)
        {
                glFinish();

                algTime = algTimer.Elapsedms();
                perfGraph->AddData(algTime);

                perfGraph->Draw();
        }
        else
        {
                if (visMode) DisplayVisualization();
        }

        glFlush();

        const bool restart = true;
        elapsedTime = frameTimer.Elapsedms(restart);

        DisplayStats();

        isFirstTexture = !isFirstTexture;

        glutSwapBuffers();
}


#pragma warning( disable : 4100 )
void KeyBoard(unsigned char c, int x, int y) 
{
        switch(c) 
        {
        case 27:
                CleanUp();
                exit(0);
                break;
        case 32: //space
                renderMode = (renderMode + 1) % RenderTraverser::NUM_TRAVERSAL_TYPES;
                ResetTraverser();
                break;
        case 'h':
        case 'H':
                showHelp = !showHelp;
                break;
        case '+':
                maxBatchSize += 10;
                traverser->SetMaxBatchSize(maxBatchSize);
                break;
        case '-':
                maxBatchSize -= 10;
                if (maxBatchSize < 0) maxBatchSize = 1;
                traverser->SetMaxBatchSize(maxBatchSize);               
                break;
        case 'M':
        case 'm':
                useMultiQueries = !useMultiQueries;
                traverser->SetUseMultiQueries(useMultiQueries);
                break;
        case '1':
                descendKeyPressed = true;
                break;
        case '2':
                ascendKeyPressed = true;
                break;
        case '3':
                if (trianglesPerVirtualLeaf >= 100)
                        trianglesPerVirtualLeaf -= 100;
                bvh->SetVirtualLeaves(trianglesPerVirtualLeaf);
                break;
        case '4':
                trianglesPerVirtualLeaf += 100;
                bvh->SetVirtualLeaves(trianglesPerVirtualLeaf);
                break;
        case '5':
                assumedVisibleFrames -= 1;
                if (assumedVisibleFrames < 1) assumedVisibleFrames = 1;
                traverser->SetAssumedVisibleFrames(assumedVisibleFrames);
                break;
        case '6':
                assumedVisibleFrames += 1;
                traverser->SetAssumedVisibleFrames(assumedVisibleFrames);               
                break;
        case '7':
                expFactor *= 0.5f;
                break;
        case '8':
                expFactor *= 2.0f;
                if (expFactor > 1.0f) expFactor = 1.0f;
                break;
        case 'o':
        case 'O':
                useOptimization = !useOptimization;
                traverser->SetUseOptimization(useOptimization);
                break;
        case 'a':
        case 'A':
                        leftKeyPressed = true;
                break;
        case 'd':
        case 'D':
                        rightKeyPressed = true;
                break;
        case 'w':
        case 'W':
                        upKeyPressed = true;
                break;
        case 's':
        case 'S':
                        downKeyPressed = true;
                break;
        case 'r':
        case 'R':
                {
                        useRenderQueue = !useRenderQueue;
                        traverser->SetUseRenderQueue(useRenderQueue);
                }
                break;
        case 'b':
        case 'B':
                {
                        useTightBounds = !useTightBounds;
                        traverser->SetUseTightBounds(useTightBounds);
                }
                break;
        default:
                return;
        }

        glutPostRedisplay();
}


void SpecialKeyUp(int c, int x, int y) 
{
        switch (c) 
        {
        case GLUT_KEY_LEFT:
                leftKeyPressed = false;
                break;
        case GLUT_KEY_RIGHT:
                rightKeyPressed = false;
                break;
        case GLUT_KEY_UP:
                upKeyPressed = false;
                break;
        case GLUT_KEY_DOWN:
                downKeyPressed = false;
                break;
        default:
                return;
        }
        //glutPostRedisplay();
}


void KeyUp(unsigned char c, int x, int y) 
{
        switch (c) 
        {
        case 'A':
        case 'a':
                leftKeyPressed = false;
                break;
        case 'D':
        case 'd':
                rightKeyPressed = false;
                break;
        case 'W':
        case 'w':
                upKeyPressed = false;
                break;
        case 'S':
        case 's':
                downKeyPressed = false;
                break;
        case '1':
                descendKeyPressed = false;
                break;
        case '2':
                ascendKeyPressed = false;
                break;
        
        default:
                return;
        }
        //glutPostRedisplay();
}


void Special(int c, int x, int y) 
{
        switch(c) 
        {
        case GLUT_KEY_F1:
                showHelp = !showHelp;
                break;
        case GLUT_KEY_F2:
                visMode = !visMode;
                break;
        case GLUT_KEY_F3:
                showBoundingVolumes = !showBoundingVolumes;
                traverser->SetShowBounds(showBoundingVolumes);
                break;
        case GLUT_KEY_F4:
                showOptions = !showOptions;
                break;
        case GLUT_KEY_F5:
                showStatistics = !showStatistics;
                break;
        case GLUT_KEY_F6:
                flyMode = !flyMode;
                break;
        case GLUT_KEY_F7:

                renderType = (renderType + 1) % 3;
                traverser->SetUseDepthPass(renderType == RenderState::DEPTH_PASS);
                
                break;
        case GLUT_KEY_F8:
                useSsao = !useSsao;
                break;
        case GLUT_KEY_F9:
                showAlgorithmTime = !showAlgorithmTime;
                break;

        case GLUT_KEY_LEFT:
                {
                        leftKeyPressed = true;
                        camera->Pitch(KeyRotationAngle());
                }
                break;
        case GLUT_KEY_RIGHT:
                {
                        rightKeyPressed = true;
                        camera->Pitch(-KeyRotationAngle());
                }
                break;
        case GLUT_KEY_UP:
                {
                        upKeyPressed = true;
                        KeyHorizontalMotion(KeyShift());
                }
                break;
        case GLUT_KEY_DOWN:
                {
                        downKeyPressed = true;
                        KeyHorizontalMotion(-KeyShift());
                }
                break;
        default:
                return;

        }

        glutPostRedisplay();
}

#pragma warning( default : 4100 )


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

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

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

        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();

        gluPerspective(fov, winAspectRatio, nearDist, myfar);

        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))
        {
                xEyeBegin = x;
                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) 
{
        Vector3 viewDir = camera->GetDirection();
        Vector3 pos = camera->GetPosition();

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

        camera->Pitch(eyeXAngle);

        pos += horView * (yMotionBegin - y) * 0.2f;
        
        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) 
{
        float eyeXAngle = 0.2f *  M_PI * (xEyeBegin - x) / 180.0;
        float eyeYAngle = -0.2f *  M_PI * (yEyeBegin - y) / 180.0;

        camera->Yaw(eyeYAngle);
        camera->Pitch(eyeXAngle);

        xEyeBegin = x;
        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], viewDir[1], 0);
        
        Matrix4x4 rot = RotationZMatrix(M_PI * 0.5f);
        rVec = rot * rVec;
        
        pos -= rVec * (x - horizontalMotionBegin) * 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() 
{
        glDisable(GL_LIGHTING);
        glDisable(GL_DEPTH_TEST);

        glMatrixMode(GL_PROJECTION);
        glPushMatrix();
        glLoadIdentity();

        gluOrtho2D(0, winWidth, 0, winHeight);

        glMatrixMode(GL_MODELVIEW);
        glPushMatrix();
        glLoadIdentity();
}


void End2D() 
{
        glMatrixMode(GL_PROJECTION);
        glPopMatrix();

        glMatrixMode(GL_MODELVIEW);
        glPopMatrix();

        glEnable(GL_LIGHTING);
        glEnable(GL_DEPTH_TEST);
}


// displays the visualisation of culling algorithm
void DisplayVisualization()
{
        visualization->SetFrameId(traverser->GetCurrentFrameId());
        
        Begin2D();
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        glEnable(GL_BLEND);
        glColor4f(0.0f ,0.0f, 0.0f, 0.5f); 

        glRecti(winWidth - winWidth / 3, winHeight - winHeight / 3, winWidth, winHeight);
        glDisable(GL_BLEND);
        End2D();
        
        
        AxisAlignedBox3 box = bvh->GetBox();

        // hack: set far plane for viz
        camera->SetFar(0.35f * Magnitude(box.Diagonal()));

        const float offs = box.Size().x * 0.3f;
        
        //Vector3 vizpos = Vector3(box.Min().x, box.Min().y + box.Size().y * 0.5f, box.Min().z + box.Size().z * 50);
        Vector3 vizpos = Vector3(box.Min().x, box.Min().y  - box.Size().y * 0.35f, box.Min().z + box.Size().z * 50);
        
        visCamera->SetPosition(vizpos);
        visCamera->ResetPitchAndYaw();
        //visCamera->Pitch(M_PI);

        glPushAttrib(GL_VIEWPORT_BIT);
        glViewport(winWidth - winWidth / 3, winHeight - winHeight / 3, winWidth / 3, winHeight / 3);

        glMatrixMode(GL_PROJECTION);
        glPushMatrix();

        glLoadIdentity();
        
        glOrtho(-offs, offs, -offs, offs, 0.0f, box.Size().z * 100.0f); 

        glMatrixMode(GL_MODELVIEW);
        glPushMatrix();

        visCamera->SetupCameraView();

        //Matrix4x4 rotX = RotationXMatrix(camera->GetYaw());
        //glMultMatrixf((float *)rotX.x);
        Matrix4x4 rotZ = RotationZMatrix(-camera->GetPitch());
        glMultMatrixf((float *)rotZ.x);

        Vector3 pos = camera->GetPosition();
        glTranslatef(-pos.x, -pos.y, -pos.z);


        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);

        glClear(GL_DEPTH_BUFFER_BIT);


        ////////////
        //-- visualization of the occlusion culling

        visualization->Render();
        
        
        // reset previous settings
        glPopAttrib();

        glMatrixMode(GL_PROJECTION);
        glPopMatrix();
        glMatrixMode(GL_MODELVIEW);
        glPopMatrix();
}


// cleanup routine after the main loop
void CleanUp()
{
        DEL_PTR(traverser);
        DEL_PTR(sceneQuery);
        DEL_PTR(bvh);
        DEL_PTR(visualization);
        DEL_PTR(camera);
        DEL_PTR(loader);
        DEL_PTR(renderQueue);
        DEL_PTR(perfGraph);

        if (sCgMrtVertexProgram)
                cgDestroyProgram(sCgMrtVertexProgram);
        if (RenderState::sCgMrtFragmentProgram)
                cgDestroyProgram(RenderState::sCgMrtFragmentProgram);
        if (RenderState::sCgMrtFragmentTexProgram)
                cgDestroyProgram(RenderState::sCgMrtFragmentTexProgram);
        if (sCgSsaoProgram)
                cgDestroyProgram(sCgSsaoProgram);
        if (sCgDeferredProgram)
                cgDestroyProgram(sCgDeferredProgram);
        if (sCgContext)
                cgDestroyContext(sCgContext);

        glDeleteFramebuffersEXT(1, &fbo);
        glDeleteRenderbuffersEXT(1, &depthBuffer);
        glDeleteRenderbuffersEXT(1, &colorsBuffer);
        glDeleteRenderbuffersEXT(1, &normalsBuffer);
        glDeleteRenderbuffersEXT(1, &positionsBuffer);

        glDeleteTextures(1, &colorsTex);
        glDeleteTextures(1, &normalsTex);
        glDeleteTextures(1, &positionsTex);
        glDeleteTextures(1, &noiseTex);
        glDeleteTextures(1, &fontTex);
}


// this function inserts a dezimal point after each 1000
void CalcDecimalPoint(string &str, int d, int len)
{
        static vector<int> numbers;
        numbers.clear();

        static string shortStr;
        shortStr.clear();

        static char hstr[100];

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

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

        int dif = len - (int)shortStr.size();

        for (int i = 0; i < dif; ++ i)
        {
                str += " ";
        }

        str.append(shortStr);
}


void DisplayStats()
{
        static char msg[9][300];

        static double frameTime = elapsedTime;
        static double renderTime = algTime;

        const float expFactor = 0.1f;

        // if some strange render time spike happened in this frame => don't count
        if (elapsedTime < 500) frameTime = elapsedTime * expFactor + (1.0f - expFactor) * elapsedTime;
        
        static float rTime = 1000.0f;

        if (showAlgorithmTime)
        {
                if (algTime < 500) renderTime = algTime * expFactor + (1.0f - expFactor) * renderTime;
        }

        accumulatedTime += elapsedTime;

        if (accumulatedTime > 500) // update every fraction of a second
        {       
                accumulatedTime = 0;

                if (frameTime) fps = 1e3f / (float)frameTime;

                rTime = 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;
                numBatches = traverser->GetStats().mNumBatches;
        }


        Begin2D();

        glEnable(GL_BLEND);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

        if (showHelp)
        {       
                DrawHelpMessage();
        }
        else
        {
                if (showOptions)
                {
                        glColor4f(0.0f, 0.0f, 0.0f, 0.5f);
                        glRecti(5, winHeight - 95, winWidth * 2 / 3 - 5, winHeight - 5);
                }

                if (showStatistics)
                {
                        glColor4f(0.0f, 0.0f, 0.0f, 0.5f);
                        glRecti(5, winHeight - 165, winWidth * 2 / 3 - 5, winHeight - 100);
                }

                glEnable(GL_TEXTURE_2D);

                myfont.Begin();

                if (showOptions)
                {
                        glColor3f(0.0f, 1.0f, 0.0f);

                        int i = 0;

                        static char *renderTypeStr[] = {"fixed function", "fixed function + depth pass", "deferred shading"};
        
                        sprintf(msg[i ++], "multiqueries: %d, tight bounds: %d, render queue: %d", 
                                                        useMultiQueries, useTightBounds, useRenderQueue);

                        sprintf(msg[i ++], "render technique: %s, SSAO: %d", renderTypeStr[renderType], useSsao);

                        sprintf(msg[i ++], "triangles per virtual leaf: %5d", trianglesPerVirtualLeaf);

                        sprintf(msg[i ++], "assumed visible frames: %4d, max batch size: %4d", 
                                assumedVisibleFrames, maxBatchSize);

                        for (int j = 0; j < 4; ++ j)
                                myfont.DrawString(msg[j], 10.0f, winHeight - 5 - j * 20);
                }

                if (showStatistics)
                {
                        glColor3f(1.0f, 1.0f, 0.0f);

                        string str;
                        string str2;

                        int len = 10;
                        CalcDecimalPoint(str, renderedTriangles, len);
                        CalcDecimalPoint(str2, bvh->GetBvhStats().mTriangles, len);

                        int i = 4;

                        sprintf(msg[i ++], "rendered: %6d of %6d nodes, %s of %s triangles", 
                                renderedNodes, bvh->GetNumVirtualNodes(), str.c_str(), str2.c_str()); 

                        sprintf(msg[i ++], "traversed: %5d, frustum culled: %5d, query culled: %5d",
                                traversedNodes, frustumCulledNodes, queryCulledNodes);

                        sprintf(msg[i ++], "issued queries: %5d, state changes: %5d, render batches: %5d", 
                                issuedQueries, stateChanges, numBatches);

                        for (int j = 4; j < 7; ++ j)
                                myfont.DrawString(msg[j], 10.0f, winHeight - (j + 1) * 20);
                }

                glColor3f(1.0f, 1.0f, 1.0f);
                static char *alg_str[] = {"Frustum Cull", "Stop and Wait", "CHC", "CHC ++"};
                
                if (!showAlgorithmTime)
                {
                        sprintf(msg[7], "%s:  %6.1f fps", alg_str[renderMode], fps);
                }
                else
                {
                        sprintf(msg[7], "%s:  %6.1f ms", alg_str[renderMode], rTime);
                }

                myfont.DrawString(msg[7], 1.3f, 690.0f, 760.0f);//, top_color, bottom_color);
                
                //sprintf(msg[8], "algorithm time: %6.1f ms", rTime);
                //myfont.DrawString(msg[8], 720.0f, 730.0f);            
        }

        glDisable(GL_BLEND);
        glDisable(GL_TEXTURE_2D);

        End2D();
}       


void RenderSky()
{
        SceneEntityContainer::const_iterator sit, sit_end = skyGeometry.end();

        for (sit = skyGeometry.begin(); sit != sit_end; ++ sit)
                (*sit)->Render(&state);
}


void RenderVisibleObjects()
{
        state.SetRenderType(RenderState::FIXED);
        state.Reset();

        glEnable(GL_LIGHTING);
        glDepthFunc(GL_LEQUAL);

        //cout << "visible: " << (int)traverser->GetVisibleObjects().size() << endl;

        SceneEntityContainer::const_iterator sit, 
                sit_end = traverser->GetVisibleObjects().end();

        for (sit = traverser->GetVisibleObjects().begin(); sit != sit_end; ++ sit)
                renderQueue->Enqueue(*sit);
                
        renderQueue->Apply();

        glDepthFunc(GL_LESS);
}


void PlaceViewer(const Vector3 &oldPos)
{
        Vector3 playerPos = camera->GetPosition();

        bool validIntersect = sceneQuery->CalcIntersection(playerPos);

        if (validIntersect ) 
                // && ((playerPos.z - oldPos.z) < bvh->GetBox().Size(2) * 1e-1f))
        {
                camera->SetPosition(playerPos);
        }
}


void DisplayRenderTexture3()
{
        glEnable(GL_TEXTURE_2D);

        if (isFirstTexture)
                glBindTexture(GL_TEXTURE_2D, colorsTex1);
        else
                glBindTexture(GL_TEXTURE_2D, colorsTex2);

        glDisable(GL_LIGHTING);
        
        glMatrixMode(GL_PROJECTION);
        glPushMatrix();
        glLoadIdentity();

        glMatrixMode(GL_MODELVIEW);
        glPushMatrix();
        glLoadIdentity();

        const float offs = 0.5f;
        glOrtho(-offs, offs, -offs, offs, 0, 1);
        
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
        glBegin(GL_QUADS);

        glTexCoord2f(0, 0); glVertex3f(-offs, -offs, -0.5f);
        glTexCoord2f(1, 0); glVertex3f( offs, -offs, -0.5f);
        glTexCoord2f(1, 1); glVertex3f( offs,  offs, -0.5f);
        glTexCoord2f(0, 1); glVertex3f(-offs,  offs, -0.5f);

        glEnd();

        glEnable(GL_LIGHTING);
        glDisable(GL_TEXTURE_2D);
        
        glMatrixMode(GL_PROJECTION);
        glPopMatrix();

        glMatrixMode(GL_MODELVIEW);
        glPopMatrix();

        PrintGLerror("displaytexture3");
}


void DisplayRenderTexture()
{
        GLuint oldTex;

        if (isFirstTexture)
        {
                glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo1);
                oldTex = colorsTex2;
        }
        else 
        {
                glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo2);
                oldTex = colorsTex1;
        }

        glPushAttrib(GL_VIEWPORT_BIT);
        glViewport(0, 0, texWidth, texHeight);

        glDrawBuffers(1, mrt);

        glDisable(GL_ALPHA_TEST);
        glDisable(GL_TEXTURE_2D);
        glDisable(GL_LIGHTING);
        
        glMatrixMode(GL_PROJECTION);
        glPushMatrix();
        glLoadIdentity();

        glMatrixMode(GL_MODELVIEW);
        glPushMatrix();
        glLoadIdentity();

        const float offs = 0.5f;
        
        glOrtho(-offs, offs, -offs, offs, 0, 1);
        
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        cgGLEnableProfile(RenderState::sCgFragmentProfile);

        if (useSsao)
        {
                cgGLBindProgram(sCgSsaoProgram);
                
                cgGLSetTextureParameter(sPositionsTexParamSsao, positionsTex);
                cgGLEnableTextureParameter(sPositionsTexParamSsao);

                cgGLSetTextureParameter(sColorsTexParamSsao, colorsTex);
                cgGLEnableTextureParameter(sColorsTexParamSsao);

                cgGLSetTextureParameter(sNormalsTexParamSsao, normalsTex);
                cgGLEnableTextureParameter(sNormalsTexParamSsao);

                cgGLSetTextureParameter(sNoiseTexParamSsao, noiseTex);
                cgGLEnableTextureParameter(sNoiseTexParamSsao);

                cgGLSetTextureParameter(sOldTexParamSsao, oldTex);
                cgGLEnableTextureParameter(sOldTexParamSsao);

                cgGLSetParameter1f(sNoiseMultiplierParam, RandomValue(3.0f, 17.0f));
                cgGLSetParameter1f(sExpFactorParamSsao, expFactor);

                GenerateSamples(); cgGLSetParameterArray2f(sSamplesParamSsao, 0, NUM_SAMPLES, (const float *)samples);
        }
        else
        {
                cgGLBindProgram(sCgDeferredProgram);

                cgGLSetTextureParameter(sPositionsTexParam, positionsTex);
                cgGLEnableTextureParameter(sPositionsTexParam);

                cgGLSetTextureParameter(sColorsTexParam, colorsTex);
                cgGLEnableTextureParameter(sColorsTexParam);

                cgGLSetTextureParameter(sNormalsTexParam, normalsTex);
                cgGLEnableTextureParameter(sNormalsTexParam);
        }

        Vector3 tl, tr, bl, br;
        ComputeViewVectors(tl, tr, bl, br);

        glColor3f(1.0f, 1.0f, 1.0f);

        glBegin(GL_QUADS);

        // note: slightly larger texture hides ambient occlusion error on border but costs resolution
        //float offs2 = 0.55f;
        float offs2 = 0.5f;

        glColor3f(bl.x, bl.y, bl.z); glTexCoord2f(0, 0); glVertex3f(-offs2, -offs2, -0.5f);
        glColor3f(br.x, br.y, br.z); glTexCoord2f(1, 0); glVertex3f( offs2, -offs2, -0.5f);
        glColor3f(tr.x, tr.y, tr.z); glTexCoord2f(1, 1); glVertex3f( offs2,  offs2, -0.5f);
        glColor3f(tl.x, tl.y, tl.z); glTexCoord2f(0, 1); glVertex3f(-offs2,  offs2, -0.5f);

        glEnd();

        
        if (useSsao)
        {
                cgGLDisableTextureParameter(sColorsTexParamSsao);
                cgGLDisableTextureParameter(sPositionsTexParamSsao);
                cgGLDisableTextureParameter(sNormalsTexParamSsao);
                cgGLDisableTextureParameter(sNoiseTexParamSsao);
                cgGLDisableTextureParameter(sOldTexParamSsao);
        }
        else
        {
                cgGLDisableTextureParameter(sColorsTexParam);
                cgGLDisableTextureParameter(sPositionsTexParam);
                cgGLDisableTextureParameter(sNormalsTexParam);
        }

        cgGLDisableProfile(RenderState::sCgFragmentProfile);
        
        glEnable(GL_LIGHTING);
        glDisable(GL_TEXTURE_2D);
        
        glMatrixMode(GL_PROJECTION);
        glPopMatrix();

        glMatrixMode(GL_MODELVIEW);
        glPopMatrix();

        glPopAttrib();

        PrintGLerror("displaytexture");

        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);

        DisplayRenderTexture3();
}

#if 0
// kustls magic sample positions
void GenerateSamples()
{
        static const float mysamples[] =
        { 
                -0.326212f, -0.405805f,
                -0.840144f, -0.07358f,
                -0.695914f, 0.457137f,
                -0.203345f, 0.620716,
                0.96234f, -0.194983f,
                0.473434f, -0.480026f,
                0.519456, 0.767022f,
                0.185461f, -0.893124f,
                0.507431f, 0.064425f,
                0.89642f, 0.412458f,
                -0.32194f, -0.932615f,
                -0.791559f, -0.597705f,
                0.326212f, 0.405805f,
                0.840144f, 0.07358f,
                0.695914f, -0.457137f,
                0.203345f, -0.620716,
                -0.96234f, 0.194983f,
                -0.473434f, 0.480026f,
                -0.519456, -0.767022f,
                -0.185461f, 0.893124f,
                -0.507431f, -0.064425f,
                -0.89642f, -0.412458f,
                0.32194f, 0.932615f,
                0.791559f, 0.597705f
        };

        for (int i = 0; i < NUM_SAMPLES; ++ i)
        {
                samples[i] = mysamples[i];
        }
}

#else


void GenerateSamples()
{
        static HaltonSequence halton;

        float r[2];

        // generates poisson distribution on disc
        float minDist = 2.0f / sqrt((float)NUM_SAMPLES);

        //cout << "minDist before= " << minDist << endl;

        for (int i = 0; i < NUM_SAMPLES * 2; i += 2)
        {
                int tries = 0, totalTries = 0;

                // repeat until valid sample was found
                while (1)
                {
                        ++ tries;
                        ++ totalTries;

                        halton.GetNext(2, r);

                        //const float rx = RandomValue(-1, 1);
                        //const float ry = RandomValue(-1, 1);

                        const float rx = r[0] * 2.0f - 1.0f;
                        const float ry = r[1] * 2.0f - 1.0f;

                        // check if in disk, else exit early
                        if (rx * rx + ry * ry > 1)
                                continue;

                        bool sampleValid = true;

                        // check poisson property
                        for (int j = 0; ((j < i) && sampleValid); j += 2)
                        {
                                const float dist = 
                                        sqrt((samples[j] - rx) * (samples[j] - rx) +
                                             (samples[j + 1] - ry) * (samples[j + 1] - ry));
                        
                                if (dist < minDist)
                                        sampleValid = false;
                        }

                        if (sampleValid)
                        {
                                samples[i] = rx;
                                samples[i + 1]= ry;
                                break;
                        }

                        if (tries > 2000)
                        {
                                minDist *= 0.9f;
                                tries = 0;
                        }
                }
                //cout << "sample: " << samples[i] << " " << i / 2 << " " << samples[i + 1] << " r: " << sqrt(samples[i] * samples[i]  + samples[i + 1] * samples[i + 1]) << " tries: " << totalTries << endl;
        }

        //cout << "minDist after= " << minDist << endl;
}


#endif


void ComputeViewVectors(Vector3 &tl, Vector3 &tr, Vector3 &bl, Vector3 &br)
{
        float myfov = fov * M_PI / 180.0f;

        const float w_far = 2.0f * tan(myfov / 2.0f);
        const float aspect = texWidth / texHeight;

        const float h_far = w_far / aspect;

        float t1 = h_far * 0.5f;
        float t2 = w_far * 0.5f;

#if 0
        bl = Normalize(-Vector3(-t1, -t2, 1.0f));
        br = Normalize(-Vector3( t1, -t2, 1.0f));
        tl = Normalize(-Vector3(-t1,  t2, 1.0f));
        tr = Normalize(-Vector3( t1,  t2, 1.0f));
#else
        bl = -Normalize(camera->GetDirection());
        br = -Normalize(camera->GetDirection());
        tl = -Normalize(camera->GetDirection());
        tr = -Normalize(camera->GetDirection());
#endif
        // normalize to 0 .. 1
        bl = bl * 0.5f + 0.5f;
        br = br * 0.5f + 0.5f;
        tl = tl * 0.5f + 0.5f;
        tr = tr * 0.5f + 0.5f;
}


void CreateNoiseTex2D()
{
        randomNormals = new GLubyte[texWidth * texHeight * 3];

        for (int i = 0; i < texWidth * texHeight * 3; i += 3)
        {
                // create random samples over sphere
                const float rx = RandomValue(0, 1);
                const float theta = 2.0f * acos(sqrt(1.0f - rx));

                randomNormals[i + 0] = (GLubyte)((cos(theta) * 0.5f + 0.5f) * 255.0f);
                randomNormals[i + 1] = (GLubyte)((sin(theta) * 0.5f + 0.5f) * 255.0f);
                randomNormals[i + 2] = 0;
        }

        glEnable(GL_TEXTURE_2D);
        glGenTextures(1, &noiseTex);
        glBindTexture(GL_TEXTURE_2D, noiseTex);
                
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, texWidth, texHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, randomNormals);
        //gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB, texWidth, texHeight, GL_RGB, GL_UNSIGNED_BYTE, randomNormals);

        glBindTexture(GL_TEXTURE_2D, 0);
        glDisable(GL_TEXTURE_2D);

        cout << "created noise texture" << endl;
        PrintGLerror("noisetexture");
}