glutapp.cpp

#include <iostream>
#include <algorithm>
#include <iterator>
#include <stdexcept>
#include <assert.h>
#include <math.h>

#include <boost/bind.hpp>
#include <boost/thread.hpp>
#include <boost/signal.hpp>

#include "logger/logger.h"
#include "render/drawable.h"
#include "render/glutapp.h"


namespace fdl {
        
static GlutApp* self;

GlutApp::GlutApp(std::string title, int width, int height) : m_windowTitle(title), m_width(width), m_height(height)
{
        die = 0;
        m_button1Down = false;
        m_button2Down = false;
        m_lastX = 0;
        m_lastY = 0;
        m_running = false;
        
        m_camEye = new cg::vecmath::Vector3f(5.0, 3.0, -3.0);
        m_camTarget = new cg::vecmath::Vector3f(5.0, 3.0, -3.0);
        cg::vecmath::Vector3f up(0.0, 1.0, 0.0);
        m_camera = new Camera(*m_camEye, *m_camTarget, up, 30, 0.1, 1000.0);
        
        m_lastMousePt = new cg::vecmath::Point2f();
        m_currMousePt = new cg::vecmath::Point2f();

        m_currentFrame = 0;
        
        self = this;
        
        marcher = new fdl::CubeMarcher();
        
        headsUpDisplay = new fdl::HUD();
        
        //m.run(m.parseRawFile("aneurism.raw", 256, 256, 256), 256, 256, 256, 1, 1, 1, 37.0);
}

GlutApp::~GlutApp()
{
        m_running = false;
}

int GlutApp::run()
{
        if(!m_running){
                //t1 = new boost::thread(boost::bind(&GlutApp::start,this));
                //t1->join();
                m_running = true;
                this->init();
        }
        
        return 0;
}


void GlutApp::setGrid(fdl::Drawable* grid)
{
        m_grid = grid;
}

void GlutApp::setSolver(fdl::Drawable* solver)
{
        m_solver = solver;
}

int GlutApp::render()
{
        m_currentFrame++;
        
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
        
        renderCamera();
        
        headsUpDisplay->draw();
        
        int limit = 1000;
        //glutSolidTeapot(1.0); // test
        //if(m_currentFrame < limit) 
        
        if(m_grid!=NULL) m_grid->draw();
        if(m_solver!=NULL) m_solver->draw();
        
        /*
        fdl::CubeMarcher m;
        m.run(*(fdl::Grid*)m_grid, 0.5);
        m.draw();
        */
        /*
        if(m_currentFrame == limit){
                marcher->run(*(fdl::Grid*)m_grid, 0.5);
        }
        
        marcher->draw();
        */
        /*
        glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glPushMatrix();
    glScalef(0.1f, 0.1f, 0.1f);
        m.draw();
    glPopMatrix();
        */

        // swap drawing buffers
        glutSwapBuffers();
        
        return 0;
}

void GlutApp::windowToViewport(cg::vecmath::Point2f& p) const
{
        p.set((2.0f * p.x - m_width) / m_width, (2.0f * (m_height - p.y - 1.0) - m_height) / m_height);
}

void GlutApp::renderCamera()
{
        // DEBUG() << "m_camera.eye = " << m_camera->getEye();
        // DEBUG() << "m_camera.target = " << m_camera->getTarget();
        m_camera->updateMatrices();
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        float proj[16];
        float view[16];
        m_camera->getProjectionMatrix().toArray(proj);
        m_camera->getViewMatrix().toArray(view);
        glMultMatrixf(proj);
        glMultMatrixf(view);
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
//      rotationGizmo.setCamera(mainCamera);
}

int GlutApp::resize(int width, int height)
{
        m_width = width;
        m_height = height;

        glLoadIdentity();
        float aspect = m_width / m_height;
        glViewport(0, 0, m_width, m_height);
        m_camera->setAspect(aspect);

        // glMatrixMode(GL_PROJECTION);
        // glLoadIdentity();
        // float aspect = 1.0;//m_width / m_height;
        // gluPerspective(60, aspect, 1.0, 100.0);
        // glOrtho(0, m_width, m_height, 0, -1.0f, 1.0f);
        // glMatrixMode(GL_MODELVIEW);
        // m_camera->setAspect(aspect);
        
        return 0;
}

int GlutApp::keyPressed(unsigned char key)
{
        // for escape key ...
        if (key == 27) {
                die = 1;
                glutDestroyWindow(window);
        }else{
                std::cout << "key pressed: " << key << std::endl;
        }
        
        return 0;
}

int GlutApp::keyReleased(unsigned char key)
{       
        return 0;
}

int GlutApp::mousePressed(int button, int x, int y)
{
        // std::cout << "mouse pressed: " << x << ", " << y << std::endl;
        m_lastMousePt->set(x, y);
        windowToViewport(*m_lastMousePt);
        m_button1Down = true;
        
        return 0;
}

int GlutApp::mouseReleased(int button, int x, int y)
{
        // std::cout << "mouse released: " << x << ", " << y << std::endl;
        m_button1Down = false;
        
        return 0;
}

int GlutApp::mouseMoved(int x, int y)
{
        // std::cout << "mouse moved: " << x << ", " << y << std::endl;
        m_currMousePt->set(x, y);
        windowToViewport(*m_currMousePt);
        m_camera->orbit(*m_lastMousePt, *m_currMousePt);
        *m_lastMousePt = *m_currMousePt;
        
        return 0;
}

void GlutApp::render_cb()
{       
        self->render();
}


void GlutApp::resize_cb(int width, int height)
{
        self->resize(width,height);
}

void GlutApp::keyPressed_cb(unsigned char key, int x, int y)
{       
        self->keyPressed(key);
}


void GlutApp::mouse_cb(int button, int state, int x, int y)
{
        if (state == GLUT_DOWN && button == GLUT_LEFT_BUTTON) {
                self->m_button1Down = true;
                self->m_lastX = x;
                self->m_lastY = y;
                self->mousePressed(button, x, y);
        }
        else if (state == GLUT_UP && button == GLUT_LEFT_BUTTON) {
                self->m_button1Down = false;
                self->mouseReleased(button, x, y);
        }
        else if (state == GLUT_DOWN && button == GLUT_RIGHT_BUTTON) {
                self->m_button2Down = true;
                self->m_lastX = x;
                self->m_lastY = y;
                self->mousePressed(button, x, y);
        }
        else if (state == GLUT_UP && button == GLUT_RIGHT_BUTTON) {
                self->m_button2Down = false;
                self->mouseReleased(button, x, y);
        }
}


void GlutApp::motion_cb(int x, int y)
{
        if (self->m_button1Down) {
                double dx = (x - self->m_lastX)/2.0f;
                double dy = (y - self->m_lastY)/2.0f;
                self->m_lastX = x;
                self->m_lastY = y;
                glutPostRedisplay();
        }
        else if (self->m_button2Down) {
                // double dy = (y - lastY)/10.0f;
                // m_distZ -= dy;
                // m_lastY = y;
                // glutPostRedisplay();
        }
        
        self->mouseMoved(x, y);
}


void GlutApp::init()
{       
        m_mutex.lock();
        
        int argc = 1;
        char* argv = (char*) m_windowTitle.c_str();
        
        glutInit(&argc, &argv);
        glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_ALPHA | GLUT_DEPTH);
        glutInitWindowSize(self->m_width, self->m_height);
        glutInitWindowPosition(0, 0);

        // create X11 window
        window = glutCreateWindow(m_windowTitle.c_str());

        // pass callback handler function pointers to GLUT
        glutDisplayFunc(&render_cb);
        glutIdleFunc(&render_cb);
        glutReshapeFunc(&resize_cb);
        glutKeyboardFunc(&keyPressed_cb);
        glutMouseFunc(&mouse_cb);
        glutMotionFunc(&motion_cb);

        // init GL
        glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
        glClearDepth(1.0);
    
    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);
        glDepthFunc(GL_LESS);
        glEnable(GL_DEPTH_TEST);
        glEnable(GL_BLEND);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        glShadeModel(GL_SMOOTH);

        // begin loop
        glutMainLoop();
        
        m_running = false;

        m_mutex.unlock();
}

void GlutApp::setEye(float x, float y, float z)
{
        m_camEye->set(x,y,z);
        m_camera->setEye(*m_camEye);
        m_camera->updateMatrices();
}

void GlutApp::setTarget(float x, float y, float z)
{
        m_camTarget->set(x,y,z);
        m_camera->setTarget(*m_camTarget);
        m_camera->updateMatrices();
}

}