main.cpp

Go to the documentation of this file.

#include <Windows.h>
#include "../resource.h"
#include <tchar.h>

#include <iostream>
#include <glew.h>
#include <GL/glfw.h>
#include <glext.h>
#include <glm/glm.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <DevIL/IL/il.h>

#include "utils/DebugFunctions.h"
#include "geometry/SpinningCube.h"
#include "visualisation/Shader.h"
#include "LoaderScene.h"

#define WINDOW_WIDTH  1000
#define WINDOW_HEIGHT  750

// ----------------- VARIABLES IN DATA SEGMENT -----------------  //

double d_DELTA_TIME; 

// -------------------- user input and camera -------------------- //

glm::vec4 mouse_data = glm::vec4(0.0f); 
glm::vec2 mouse_data_prev = glm::vec2(0.0f); 

int mouse_wheel_pos = 0; 
int mouse_wheel_pos_prev = 0; 
float zoom_dist_total = 0.0f; 
glm::vec2 zoom_limits;

bool mouse_right_click = false; 

unsigned int nr_steps = 16; 
float delta_rotX, delta_rotY; 
float step_rotX, step_rotY; 
float delta_panX, delta_panY; 
float step_panX, step_panY; 

glm::vec4 axis_X; 
glm::vec4 axis_Y; 
glm::vec4 axis_Z; 

glm::mat4 transformAccum; 

// ----------------------  scene loader -------------------------- //

char* scene_path; 
vis2::LoaderScene* loader_scene_Ptr; 

// ------------- additional objects in the scene ----------------- //

// world axes
vis2::Shader* shader_axes_Ptr; 

glm::mat4 mM_VP; 
glm::mat4 mM_VD; 

vis2::SpinningCube* cube_VP; 
vis2::SpinningCube* cube_VD; 

// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //
// %% ---------------------------- SETUP DIALOG ---------------------------- %% //
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //

HWND FindConsoleHandle()
{
   static LPCTSTR temptitle = _T("{ddaba162-3aae-41f1-9980-f6a9efcd14dd}");
   TCHAR title[512];
   if(GetConsoleTitle(title, sizeof(title)/sizeof(TCHAR)) == 0)
      return NULL;
   SetConsoleTitle(temptitle);
   HWND wnd = FindWindow(NULL, temptitle);
   SetConsoleTitle(title);
   return wnd;
}


LRESULT CALLBACK DlgProc(HWND hWndDlg, UINT Msg, WPARAM wParam, LPARAM lParam)
{
    switch(Msg)
    {
    case WM_INITDIALOG:
        return TRUE;
    case WM_COMMAND:
        switch(wParam)
        {
        case IDC_BUTTON1:
            scene_path = "_resources/Levels/level.txt";
            EndDialog(hWndDlg, 0);
            return TRUE;
        case IDC_BUTTON2:
            scene_path =  "_resources/Levels/levelB.txt";
            EndDialog(hWndDlg, 0);
            return TRUE;
        case IDCANCEL:
            EndDialog(hWndDlg, 0);
            system("EXIT");
            exit(0);
        }
        break;
    }

    return FALSE;
}

// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //
// %% ----------------------------- USER INPUT ----------------------------- %% //
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //

// ------------------------------- MOUSE POSITION ----------------------------- //


void GLFWCALL myMousePosCallBack(int _x, int _y)
{
    mouse_data.x = float(_x) / float(WINDOW_WIDTH);
    mouse_data.y = 1.0f - float(_y) / float(WINDOW_HEIGHT);
    mouse_data.z = mouse_data.x - mouse_data_prev.x;
    mouse_data.w = mouse_data.y - mouse_data_prev.y;
}

// --------------------------- MOUSE ROTATE AND PAN --------------------------- //


void GLFWCALL myMouseButtonCallBack(int _button, int _action)
{
    switch (_button)
    {
        case GLFW_MOUSE_BUTTON_LEFT:
            if (_action == GLFW_PRESS)
            {
                // reset velocity calculations
                mouse_data_prev.x = mouse_data.x;
                mouse_data_prev.y = mouse_data.y;
                mouse_data.z = 0.0f;
                mouse_data.w = 0.0f;
                // std::cout << "Left mouse button pressed at (" << mouse_data.x << ", " << mouse_data.y << ")." << std::endl;
            }
            else if (_action == GLFW_RELEASE)
            {
                // std::cout << "Left mouse button released at (" << mouse_data.x << ", " << mouse_data.y << ")." << std::endl;
                // std::cout << "velocity (" << mouse_data.z << ", " << mouse_data.w << ")." << std::endl;
                // calculate rotation
                delta_rotX = 0.0f;
                delta_rotY = 0.0f;
                if (abs(mouse_data.z) > 0.01)
                    delta_rotY = - 50.0f * mouse_data.z;
                if (abs(mouse_data.w) > 0.01)
                    delta_rotX = 50.0f * mouse_data.w;

                step_rotY = delta_rotY * float(d_DELTA_TIME * 100)/float(nr_steps);
                step_rotX = delta_rotX * float(d_DELTA_TIME * 100)/float(nr_steps);
            }
            break;
        case GLFW_MOUSE_BUTTON_RIGHT:
            if (_action == GLFW_PRESS)
            {
                mouse_right_click = true;
                // std::cout << "Right mouse button." << std::endl;
            }
            break;
        case GLFW_MOUSE_BUTTON_MIDDLE:
            if (_action == GLFW_PRESS)
            {
                // reset velocity calculations
                mouse_data_prev.x = mouse_data.x;
                mouse_data_prev.y = mouse_data.y;
                mouse_data.z = 0.0f;
                mouse_data.w = 0.0f;
                // std::cout << "Middle mouse button pressed at (" << mouse_data.x << ", " << mouse_data.y << ")." << std::endl;
            }
            else if (_action == GLFW_RELEASE)
            {
                // std::cout << "Middle mouse button released." << std::endl;
                // calculate pan
                delta_panX = 0.0f;
                delta_panY = 0.0f;
                if (abs(mouse_data.z) > 0.01)
                    delta_panX = mouse_data.z;
                if (abs(mouse_data.w) > 0.01)
                    delta_panY = mouse_data.w;

                step_panX = delta_panX * float(d_DELTA_TIME * 100)/float(nr_steps);
                step_panY = delta_panY * float(d_DELTA_TIME * 100)/float(nr_steps);
            }
            break;
        default:
            break;
    }
}

// ------------------------------- MOUSE ZOOM --------------------------------- //


void GLFWCALL myMouseWheelCallBack(int _pos)
{
    mouse_wheel_pos_prev = mouse_wheel_pos;
    mouse_wheel_pos = _pos;
    // std::cout << "wheel scroll strength: " << (mouse_wheel_pos_prev - mouse_wheel_pos) << " ... " << std::endl;
    // TRANSLATION - ZOOM
    float delta_transl = -5.0f * float(d_DELTA_TIME) * (mouse_wheel_pos_prev - mouse_wheel_pos);
    
    // check if we are within the zoom limits   
    if (zoom_dist_total + delta_transl > zoom_limits.x)
        delta_transl = zoom_limits.x - zoom_dist_total; 
    else if (zoom_dist_total + delta_transl < zoom_limits.y)
        delta_transl = zoom_limits.y - zoom_dist_total; 

    zoom_dist_total += delta_transl;
    mouse_wheel_pos_prev = mouse_wheel_pos;

    transformAccum = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, delta_transl)) * transformAccum;
}

// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //
// %% ------------------------ INITIALIZE OPENGL --------------------------- %% //
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //


void vis2_opengl_window_Init()
{
    
    // initialise GLFW
    if(!glfwInit())
    {
        std::cout << "glfwInit failed!" << std::endl;
        system("PAUSE");
        exit(-1);
    }

    // setup opengl context
#if _DEBUG
    // Create a debug OpenGL context or tell your OpenGL library (GLFW, SDL) to do so.
    glfwOpenWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GL_TRUE);
#endif

    glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);
    glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 3);
    glfwOpenWindowHint(GLFW_OPENGL_PROFILE,GLFW_OPENGL_CORE_PROFILE);

    // open window
    if (!glfwOpenWindow(WINDOW_WIDTH, WINDOW_HEIGHT,16,16,16,16,32,0,GLFW_WINDOW))
    {
        glfwTerminate();
        std::cout << "glfwOpenWindow failed!" << std::endl;
        system("PAUSE");
        exit(-1);
    }
    glfwSetWindowTitle("VIS 2 DEMO");

    //check if the just opened window causes GLEW erorrs
    // GLEW_OK is interpreted as FALSE by the  C++ compiler
    if(glewInit() != GLEW_OK)
    {
        std::cout << "Failed to initialise GLEW!" << std::endl;
        system("PAUSE");
        exit(-1);
    }
    // glew Bugfixes -> adapt function names
    __glewGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC)glfwGetProcAddress("glGenVertexArrays");
    __glewBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)glfwGetProcAddress("glBindVertexArray");
    __glewDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)glfwGetProcAddress("glDeleteVertexArrays");
    __glewGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)glfwGetProcAddress("glGenerateMipmap");
    __glewBindFragDataLocation = (PFNGLBINDFRAGDATALOCATIONPROC)glfwGetProcAddress("glBindFragDataLocation");

    __glewGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC)glfwGetProcAddress("glGenFramebuffers");
    __glewBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC)glfwGetProcAddress("glBindFramebuffer");
    __glewGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC)glfwGetProcAddress("glGenRenderbuffers");
    __glewBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC)glfwGetProcAddress("glBindRenderbuffer");
    __glewRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC)glfwGetProcAddress("glRenderbufferStorage");
    __glewFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)glfwGetProcAddress("glFramebufferRenderbuffer");
    __glewFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)glfwGetProcAddress("glFramebufferTexture2D");
    __glewCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC)glfwGetProcAddress("glCheckFramebufferStatus");
    __glewDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC)glfwGetProcAddress("glDeleteFramebuffers");
    __glewDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC)glfwGetProcAddress("glDeleteRenderbuffers");


#if _DEBUG
    // register the callback function
    DebugFunctions::registerCallBackFunction();
#endif
    //provoke error///////////////
    //glTranslatef(0.0, 2.0, 5.0);//

    // set clear color and viewport 
    glClearColor(0.9f, 0.9f, 0.9f, 0.0f);
    glViewport(0,0,WINDOW_WIDTH,WINDOW_HEIGHT);

    // activate the depth buffering -> may need adjustment later
    glEnable(GL_DEPTH_TEST);
    // activate the back face culling -> may need adjustment later
    glEnable(GL_CULL_FACE);
    // glCullFace(GL_FRONT);

    //initilize DevIL
    if (ilGetInteger(IL_VERSION_NUM) < IL_VERSION)
    {
        std::cout << "Wrong DevIL version!" << std::endl;
        system("PAUSE");
        exit(-1);
    }
    ilInit();

    // set theGLFW CALLBACK functions
    glfwSetMousePosCallback(myMousePosCallBack);
    glfwSetMouseButtonCallback(myMouseButtonCallBack);
    glfwSetMouseWheelCallback(myMouseWheelCallBack);
}

// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //
// %% ------------------------- INITIALIZE SCENE --------------------------- %% //
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //


void vis2_Init()
{   
    
    // scene loader 
    loader_scene_Ptr = new vis2::LoaderScene(scene_path, WINDOW_WIDTH, WINDOW_HEIGHT);
    loader_scene_Ptr->loadScene();
    zoom_limits = loader_scene_Ptr->getZoomLimits();
    
    // axes visualizers
    shader_axes_Ptr = new vis2::Shader("_resources/Shader/basic_vert.glsl", "_resources/Shader/basic_frag.glsl");
    mM_VP = glm::scale(glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, 3.5f)), glm::vec3(0.2f, 0.2f, 0.2f));
    mM_VD = glm::scale(glm::mat4(1.0f), glm::vec3(0.1f, 0.1f, 0.1f));
    cube_VP = new vis2::SpinningCube(mM_VP, shader_axes_Ptr);
    cube_VD = new vis2::SpinningCube(mM_VD, shader_axes_Ptr);

    // define transformations for all
    axis_X = glm::vec4(1.0f, 0.0f, 0.0f, 0.0f);
    axis_Y = glm::vec4(0.0f, 1.0f, 0.0f, 0.0f);
    axis_Z = glm::vec4(0.0f, 0.0f, 1.0f, 0.0f);

    transformAccum = glm::mat4(1.0f);

}

// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //
// %% -------------------------------- UPDATE ------------------------------ %% //
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //

// ------------------------- UPDATE ROTATION AND PAN -------------------------- //

void adjustCamera()
{
    bool b_rotation = false;
    // apply rotation
    if (abs(delta_rotX) > abs(step_rotX))
    {
        transformAccum = glm::rotate(transformAccum, -step_rotX, glm::vec3(axis_X.x, axis_X.y, axis_X.z));
        delta_rotX -= step_rotX;
        b_rotation = true;
    }
    else if (abs(delta_rotX) > 0 && abs(delta_rotX) <= abs(step_rotX))
    {
        transformAccum = glm::rotate(transformAccum, -delta_rotX, glm::vec3(axis_X.x, axis_X.y, axis_X.z));
        delta_rotX = 0.0f;
        b_rotation = true;
    }
    if (abs(delta_rotY) > abs(step_rotY))
    {
        transformAccum = glm::rotate(transformAccum, -step_rotY, glm::vec3(axis_Y.x, axis_Y.y, axis_Y.z));
        delta_rotY -= step_rotY;
        b_rotation = true;
    }
    else if (abs(delta_rotY) > 0 && abs(delta_rotY) <= abs(step_rotY))
    {
        transformAccum = glm::rotate(transformAccum, -delta_rotY, glm::vec3(axis_Y.x, axis_Y.y, axis_Y.z));
        delta_rotY = 0.0f;
        b_rotation = true;
    }

    if (b_rotation)
    {
        axis_X = glm::vec4(1.0f, 0.0f, 0.0f, 0.0f) * transformAccum;
        axis_Y = glm::vec4(0.0f, 1.0f, 0.0f, 0.0f) * transformAccum;
        axis_Z = glm::vec4(0.0f, 0.0f, 1.0f, 0.0f) * transformAccum;
        // std::cout << "axis_X: " << axis_X.x << " " << axis_X.y << " " << axis_X.z << std::endl;
        // std::cout << "axis_Y: " << axis_Y.x << " " << axis_Y.y << " " << axis_Y.z << std::endl;
        // std::cout << "view vec: " << axis_Z.x << " " << axis_Z.y << " " << axis_Z.z << std::endl;
    }

    bool b_pan = false;
    // apply pan
    if (abs(delta_panX) > abs(step_panX))
    {
        transformAccum = glm::translate(glm::mat4(1.0f), glm::vec3(step_panX, 0.0f, 0.0f)) * transformAccum;
        delta_panX -= step_panX;
        b_pan = true;
    }
    else if (abs(delta_panX) > 0 && abs(delta_panX) <= abs(step_panX))
    {
        transformAccum = glm::translate(glm::mat4(1.0f), glm::vec3(delta_panX, 0.0f, 0.0f)) * transformAccum;
        delta_panX = 0.0f;
        b_pan = true;
    }
    if (abs(delta_panY) > abs(step_panY))
    {
        transformAccum = glm::translate(glm::mat4(1.0f), glm::vec3(0.0, step_panY, 0.0f)) * transformAccum;
        delta_panY -= step_panY;
        b_pan = true;
    }
    else if (abs(delta_panY) > 0 && abs(delta_panY) <= abs(step_panY))
    {
        transformAccum = glm::translate(glm::mat4(1.0f), glm::vec3(0.0, delta_panY, 0.0f)) * transformAccum;
        delta_panY = 0.0f;
        b_pan = true;
    }
    
    if (b_pan)
    {
        axis_X = glm::vec4(1.0f, 0.0f, 0.0f, 0.0f) * transformAccum;
        axis_Y = glm::vec4(0.0f, 1.0f, 0.0f, 0.0f) * transformAccum;
        axis_Z = glm::vec4(0.0f, 0.0f, 1.0f, 0.0f) * transformAccum;
        // std::cout << "axis_X: " << axis_X.x << " " << axis_X.y << " " << axis_X.z << std::endl;
        // std::cout << "axis_Y: " << axis_Y.x << " " << axis_Y.y << " " << axis_Y.z << std::endl;
        // std::cout << "view vec: " << axis_Z.x << " " << axis_Z.y << " " << axis_Z.z << std::endl;
    }
    
}

// ---------------------------- UPDATE SCENE OBJECTS -------------------------- //


void vis2_Update()
{
    // update transformAccum acc to user input
    adjustCamera();

    // update axes followed by multipl by projectionMatrix_init ->
    // same as no update and multiplication with the projectionMatrix
    cube_VP->updateMm(transformAccum * mM_VP);
    cube_VD->updateMm(transformAccum * mM_VD);

    //update the scene
    loader_scene_Ptr->updateScene(transformAccum);

}

// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //
// %% --------------------------------- DRAW ------------------------------- %% //
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //


void vis2_Draw()
{
    
    // %%%%%%%%%%%%%%%%%%%%%%%%% SET OPENGL STATE %%%%%%%%%%%%%%%%%%%%%%%%%%%%% //
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 

    // get projection matrix from the scene
    glm::mat4 projectionMatrix  = loader_scene_Ptr->getProjectionMatrix();
    
    // draw axes
    // cube_VP->draw(projectionMatrix);
    // cube_VD->draw(projectionMatrix);

    // draw scene
    loader_scene_Ptr->drawScene(mouse_right_click, mouse_data.x, mouse_data.y, true, false, 2);
    if (mouse_right_click)
        mouse_right_click = false; 

    // %%%%%%%%%%%%%%%%%%%%%%%%%% RESET OPENGL STATE %%%%%%%%%%%%%%%%%%%%%%%%%% //
    glfwSwapBuffers();

}

// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //
// %% ------------------------------- CLEANUP ------------------------------ %% //
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //


void vis2_Cleanup()
{
    // delete scene loader 
    delete loader_scene_Ptr;

    // delete axes
    delete cube_VP;
    delete cube_VD;

    delete shader_axes_Ptr;

}

// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //
// %% --------------------------------- MAIN ------------------------------- %% //
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //


int main()
{
    // call setup dialog
    DialogBox(NULL, MAKEINTRESOURCE(IDD_DIALOG1), FindConsoleHandle(), reinterpret_cast<DLGPROC>(DlgProc));

    // initialize opengl context
    vis2_opengl_window_Init();
    // initilize shaders and geometry
    vis2_Init();

    // set up render loop
    bool b_running = true;
    d_DELTA_TIME = 0.0;
    double d_timeSinceLastFrame = 0.0;

    //int counter = 0;
    while (b_running)
    {
        //calculate time of last frame (in seconds):
        double d_time = glfwGetTime();
        d_DELTA_TIME = d_time - d_timeSinceLastFrame;
        d_timeSinceLastFrame = d_time;
        /*
        counter++;
        if (counter % 60)
        {
            std::cout << "Frame Time: " << d_DELTA_TIME * 1000 << " ms" << std::endl;
            counter = 0;
        }
        */
        // main functionality
        vis2_Update();
        vis2_Draw();

        b_running = !glfwGetKey(GLFW_KEY_ESC) && glfwGetWindowParam(GLFW_OPENED);

        // ask OPENGL if there were any errors -> was replaced by a DEBUG CALLBACK FUNCTION
        // if (glGetError() != GL_NO_ERROR)
        //  std::cout << "OPEN GL produced an error: " << glGetError() << std::endl;
    }


    // CLEAN-UP
    vis2_Cleanup();
    glfwTerminate();

    return 0;
}