BSP_GhostTest3D.cpp

Go to the documentation of this file.

#if defined(WIN32) || defined(__APPLE__)
#       ifdef WIN32
#               include <windows.h>
#               include <GL/gl.h>
#               include <GL/glu.h>
#       else // WIN32
#               include <AGL/gl.h>
#       endif // WIN32
#else // defined(WIN32) || defined(__APPLE__)
#       include <GL/gl.h>
#       include <GL/glu.h>
#endif // defined(WIN32) || defined(__APPLE__)


#include "BSP_GhostTest3D.h"
#include "BSP_MeshDrawer.h"

#include "GHOST_ISystem.h"
#include "GHOST_IWindow.h"

#include "MT_Quaternion.h"
#include "MT_Transform.h"
#include "CSG_BooleanOps.h"

#include <iostream>

        int 
EmptyInterpFunc(
        void *d1, 
        void * d2, 
        void *dnew, 
        float epsilon
){
        return 0;
}



using namespace std;


BSP_GhostTestApp3D::
BSP_GhostTestApp3D(
) :
        m_window(NULL),
        m_system(NULL),
        m_finish_me_off(false),
        m_current_object(0)
{
        //nothing to do;
}

        void
BSP_GhostTestApp3D::
SetMesh(
        MEM_SmartPtr<BSP_TMesh> mesh
){
        m_meshes.push_back(mesh);

        BSP_RotationSetting rotation_setting;
        BSP_TranslationSetting translation_setting;

        rotation_setting.m_angle_x = MT_Scalar(0);
        rotation_setting.m_angle_y = MT_Scalar(0);
        rotation_setting.m_moving = false;
        rotation_setting.x_old = 0;
        rotation_setting.y_old = 0;

        translation_setting.m_t_x = MT_Scalar(0);
        translation_setting.m_t_y = MT_Scalar(0);
        translation_setting.m_t_z = MT_Scalar(0);
        translation_setting.m_moving = false;
        translation_setting.x_old = 0;
        translation_setting.y_old = 0;

        m_rotation_settings.push_back(rotation_setting);
        m_translation_settings.push_back(translation_setting);
        m_render_modes.push_back(e_wireframe_shaded);
        m_scale_settings.push_back(MT_Scalar(1));

}

        void
BSP_GhostTestApp3D::
Swap(
        int i
){

        if (!m_rotation_settings[i].m_moving && !m_translation_settings[i].m_moving) {
                swap(m_meshes[i],m_meshes.back());
                swap(m_rotation_settings[i],m_rotation_settings.back());
                swap(m_translation_settings[i],m_translation_settings.back());
                swap(m_scale_settings[i],m_scale_settings.back());
                swap(m_render_modes[i],m_render_modes.back());
        }
}


        MT_Transform
BSP_GhostTestApp3D::
GetTransform(
        int i
){

        MT_Quaternion q_ax(MT_Vector3(0,1,0),m_rotation_settings[i].m_angle_x);
        MT_Quaternion q_ay(MT_Vector3(1,0,0),m_rotation_settings[i].m_angle_y);

        MT_Point3 tr(
                m_translation_settings[i].m_t_x,
                m_translation_settings[i].m_t_y,
                m_translation_settings[i].m_t_z
        );
        

        MT_Matrix3x3 rotx(q_ax);
        MT_Matrix3x3 roty(q_ay);

        MT_Matrix3x3 rot = rotx * roty;

        MT_Transform trans(tr,rot);

        MT_Transform scalet;
        scalet.setIdentity();
        scalet.scale(m_scale_settings[i],m_scale_settings[i],m_scale_settings[i]);

        return trans * scalet;
}

        void
BSP_GhostTestApp3D::
Operate(
        int type
){

        CSG_VertexIteratorDescriptor * vA = VertexIt_Construct(m_meshes[0],GetTransform(0));
        CSG_FaceIteratorDescriptor * fA = FaceIt_Construct(m_meshes[0]);
                                                
        CSG_VertexIteratorDescriptor * vB = VertexIt_Construct(m_meshes[1],GetTransform(1));
        CSG_FaceIteratorDescriptor * fB = FaceIt_Construct(m_meshes[1]);

        // describe properties.

        CSG_MeshPropertyDescriptor props;
        props.user_face_vertex_data_size = 0;
        props.user_data_size = 0;

        CSG_BooleanOperation * op =  CSG_NewBooleanFunction();
        props = CSG_DescibeOperands(op,props,props);

        CSG_PerformBooleanOperation(
                op,CSG_OperationType(type),
                *fA,*vA,*fB,*vB,EmptyInterpFunc
        );

        CSG_FaceIteratorDescriptor out_f;
        CSG_OutputFaceDescriptor(op,&out_f);

        CSG_VertexIteratorDescriptor out_v;
        CSG_OutputVertexDescriptor(op,&out_v);

        MEM_SmartPtr<BSP_TMesh> new_mesh (BuildMesh(props,out_f,out_v));

        // free stuff

        CSG_FreeVertexDescriptor(&out_v);
        CSG_FreeFaceDescriptor(&out_f);
        CSG_FreeBooleanOperation(op);

        op = NULL;
        SetMesh(new_mesh);
}


        void 
BSP_GhostTestApp3D::
UpdateFrame(
){
if (m_window) {

        GHOST_Rect v_rect;
        m_window->getClientBounds(v_rect);
        
        glViewport(0,0,v_rect.getWidth(),v_rect.getHeight());
        
}
}


MT_Vector3
BSP_GhostTestApp3D::
UnProject(
        const MT_Vector3 & vec
) {

        GLint viewport[4];
        GLdouble mvmatrix[16],projmatrix[16];

        glGetIntegerv(GL_VIEWPORT,viewport);
        glGetDoublev(GL_MODELVIEW_MATRIX,mvmatrix);
        glGetDoublev(GL_PROJECTION_MATRIX,projmatrix);
        
        GLdouble realy = viewport[3] - vec.y() - 1;
        GLdouble outx,outy,outz;

        gluUnProject(vec.x(),realy,vec.z(),mvmatrix,projmatrix,viewport,&outx,&outy,&outz);

        return MT_Vector3(outx,outy,outz);
}


        bool
BSP_GhostTestApp3D::
InitApp(
){

        // create a system and window with opengl
        // rendering context.

        GHOST_TSuccess success = GHOST_ISystem::createSystem();
        if (success == GHOST_kFailure) return false;

        m_system = GHOST_ISystem::getSystem();
        if (m_system == NULL) return false;

        m_system->addEventConsumer(this);
        
        m_window = m_system->createWindow(
                "GHOST crud3D!",
                100,100,512,512,GHOST_kWindowStateNormal,
                GHOST_kDrawingContextTypeOpenGL,false
        );

        if (
                m_window == NULL
        ) {
                m_system = NULL;
                GHOST_ISystem::disposeSystem();
                return false;
        }

        // make an opengl frustum for this wind

        MT_Vector3 min,max;

        min = m_meshes[0]->m_min;
        max = m_meshes[0]->m_max;
        InitOpenGl(min,max);

        return true;
}

        void
BSP_GhostTestApp3D::
Run(
){
        if (m_system == NULL) {
                return;
        }

        while (!m_finish_me_off) {
                m_system->processEvents(true);
                m_system->dispatchEvents();
        };
}

        bool 
BSP_GhostTestApp3D::
processEvent(
        GHOST_IEvent* event
){

        bool handled = false;

        switch(event->getType()) {
                case GHOST_kEventWindowSize:
                case GHOST_kEventWindowActivate:
                        UpdateFrame();
                case GHOST_kEventWindowUpdate:
                        DrawPolies();
                        handled = true;
                        break;
                case GHOST_kEventButtonDown:
                {
                        int x,y;
                        m_system->getCursorPosition(x,y);


                        int wx,wy;
                        m_window->screenToClient(x,y,wx,wy);

                        GHOST_TButtonMask button = 
                                static_cast<GHOST_TEventButtonData *>(event->getData())->button;
                        
                        if (button == GHOST_kButtonMaskLeft) {
                                m_rotation_settings[m_current_object].m_moving = true;
                                m_rotation_settings[m_current_object].x_old = x;
                                m_rotation_settings[m_current_object].y_old = y;        
                        } else 
                        if (button == GHOST_kButtonMaskRight) {
                                m_translation_settings[m_current_object].m_moving = true;
                                m_translation_settings[m_current_object].x_old = x;
                                m_translation_settings[m_current_object].y_old = y;     
                        } else 
                
                        m_window->invalidate();
                        handled = true;
                        break;

                }

                case GHOST_kEventButtonUp:
                {

                        GHOST_TButtonMask button = 
                                static_cast<GHOST_TEventButtonData *>(event->getData())->button;
                        
                        if (button == GHOST_kButtonMaskLeft) {
                                m_rotation_settings[m_current_object].m_moving = false;
                                m_rotation_settings[m_current_object].x_old = 0;
                                m_rotation_settings[m_current_object].y_old = 0;

                } else 
                        if (button == GHOST_kButtonMaskRight) {
                                m_translation_settings[m_current_object].m_moving = false;
                                m_translation_settings[m_current_object].x_old;
                                m_translation_settings[m_current_object].y_old;

                        }
                        m_window->invalidate();
                        handled = true;
                        break;

                }

                case GHOST_kEventCursorMove:
                {               
                        int x,y;
                        m_system->getCursorPosition(x,y);       
                        int wx,wy;
                        m_window->screenToClient(x,y,wx,wy);

                        if (m_rotation_settings[m_current_object].m_moving) {
                                m_rotation_settings[m_current_object].m_angle_x = MT_Scalar(wx)/20;
                                m_rotation_settings[m_current_object].x_old = wx;
                                m_rotation_settings[m_current_object].m_angle_y = MT_Scalar(wy)/20;
                                m_rotation_settings[m_current_object].y_old = wy;

                                m_window->invalidate();
                        }
                        if (m_translation_settings[m_current_object].m_moving) {

                                // project current objects bounding box center into screen space.
                                // unproject mouse point into object space using z-value from 
                                // projected bounding box center.

                                GHOST_Rect bounds;
                                m_window->getClientBounds(bounds);

                                int w_h = bounds.getHeight();

                                y = w_h - wy;
                                x = wx;

                                double mvmatrix[16];
                                double projmatrix[16];
                                GLint viewport[4];

                                double px, py, pz,sz;

                                /* Get the matrices needed for gluUnProject */
                                glGetIntegerv(GL_VIEWPORT, viewport);
                                glGetDoublev(GL_MODELVIEW_MATRIX, mvmatrix);
                                glGetDoublev(GL_PROJECTION_MATRIX, projmatrix);

                                // work out the position of the end effector in screen space

                                GLdouble ex,ey,ez;

                                ex = m_translation_settings[m_current_object].m_t_x;
                                ey = m_translation_settings[m_current_object].m_t_y;
                                ez = m_translation_settings[m_current_object].m_t_z;

                                gluProject(ex, ey, ez, mvmatrix, projmatrix, viewport, &px, &py, &sz);
                                gluUnProject((GLdouble) x, (GLdouble) y, sz, mvmatrix, projmatrix, viewport, &px, &py, &pz);

                                m_translation_settings[m_current_object].m_t_x = px;
                                m_translation_settings[m_current_object].m_t_y = py;
                                m_translation_settings[m_current_object].m_t_z = pz;
                                m_window->invalidate();

                        }               
        
                        handled = true;
                        break;
                }

                case GHOST_kEventKeyDown :
                {
                        GHOST_TEventKeyData *kd = 
                                static_cast<GHOST_TEventKeyData *>(event->getData());


                        switch(kd->key) {
                                case GHOST_kKeyI:
                                {               
                                        // now intersect meshes.
                                        Operate(e_csg_intersection);
                                        handled = true;
                                        m_window->invalidate();
                                        break;                                  
                                }
                                case GHOST_kKeyU:       
                                {               
                                        Operate(e_csg_union);
                                        handled = true;
                                        m_window->invalidate();
                                        break;                                  
                                }
                                case GHOST_kKeyD:       
                                {               
                                        Operate(e_csg_difference);
                                        handled = true;
                                        m_window->invalidate();
                                        break;                                  
                                }

                                case GHOST_kKeyA:
                                {

                                        m_scale_settings[m_current_object] *= 1.1;
                                        handled = true;
                                        m_window->invalidate();
                                        break;                                  
                                }
                                case GHOST_kKeyZ:
                                {
                                        m_scale_settings[m_current_object] *= 0.8;

                                        handled = true;
                                        m_window->invalidate();
                                        break;                                  
                                }

                                case GHOST_kKeyR:
                                        m_render_modes[m_current_object]++;
                                        if (m_render_modes[m_current_object] > e_last_render_mode) {
                                                m_render_modes[m_current_object] = e_first_render_mode;
                                        }
                                        handled = true;
                                        m_window->invalidate();
                                        break;                                  

                                case GHOST_kKeyB:
                                        handled = true;
                                        m_window->invalidate();
                                        break;                                  

                                case GHOST_kKeyQ:
                                        m_finish_me_off = true;
                                        handled = true;
                                        break;

                                case GHOST_kKeyS:
                                        Swap(m_current_object);
                                        m_window->invalidate();
                                        handled = true;
                                        break;

                                case GHOST_kKeySpace:

                                        // increment the current object only if the object is not being
                                        // manipulated.
                                        if (! (m_rotation_settings[m_current_object].m_moving || m_translation_settings[m_current_object].m_moving)) {
                                                m_current_object ++;
                                                if (m_current_object >= m_meshes.size()) {
                                                        m_current_object = 0;

                                                }
                                        }
                                        m_window->invalidate();
                                        handled = true;
                                        break;
                                default :
                                        break;
                        }
                }                       

                default :
                        break;
        }
        return handled;
};

BSP_GhostTestApp3D::
~BSP_GhostTestApp3D(
){

        if (m_window) {
                m_system->disposeWindow(m_window);
                m_window = NULL;
                GHOST_ISystem::disposeSystem();
                m_system = NULL;
        }
};

        

        void
BSP_GhostTestApp3D::
DrawPolies(
){

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        for (int i = 0; i < m_meshes.size(); ++i) {
                MT_Transform trans = GetTransform(i);

                float opengl_mat[16];
                trans.getValue(opengl_mat);

                glPushMatrix();
                glMultMatrixf(opengl_mat);
                MT_Vector3 color(1.0,1.0,1.0);
                if (i == m_current_object) {
                        color = MT_Vector3(1.0,0,0);
                }
                BSP_MeshDrawer::DrawMesh(m_meshes[i].Ref(),m_render_modes[i]);

                glPopMatrix();  
        }

        m_window->swapBuffers();

}

        void
BSP_GhostTestApp3D::
InitOpenGl(
        const MT_Vector3 &min,
        const MT_Vector3 &max
){

        GLfloat light_diffuse0[] = {1.0, 0.0, 0.0, 0.5};  /* Red diffuse light. */
        GLfloat light_position0[] = {1.0, 1.0, 1.0, 0.0};  /* Infinite light location. */

        GLfloat light_diffuse1[] = {1.0, 1.0, 1.0, 0.5};  /* Red diffuse light. */
        GLfloat light_position1[] = {1.0, 0, 0, 0.0};  /* Infinite light location. */

        /* Enable a single OpenGL light. */

        glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse0);
        glLightfv(GL_LIGHT0, GL_POSITION, light_position0);

        glLightfv(GL_LIGHT1, GL_DIFFUSE, light_diffuse1);
        glLightfv(GL_LIGHT1, GL_POSITION, light_position1);


        glEnable(GL_LIGHT0);
        glEnable(GL_LIGHT1);
        glEnable(GL_LIGHTING);

        // make sure there is no back face culling.
        //      glDisable(GL_CULL_FACE);

        // use two sided lighting model
        glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,GL_TRUE);

        /* Use depth buffering for hidden surface elimination. */

        glEnable(GL_DEPTH_TEST);

        /* Setup the view of the cube. */

        glMatrixMode(GL_PROJECTION);

        // center of the box + 3* depth of box

        MT_Vector3 center = (min + max) * 0.5;
        MT_Vector3 diag = max - min;

        float depth = diag.length();
        float distance = 5;

        gluPerspective( 
        /* field of view in degree */ 40.0,
        /* aspect ratio */ 1.0,
        /* Z near */ 1.0, 
        /* Z far */ distance * depth * 2
        );
        glMatrixMode(GL_MODELVIEW);     

        gluLookAt(
                center.x(), center.y(), center.z() + distance*depth, //eye  
                center.x(), center.y(), center.z(), //center      
                0.0, 1.0, 0.
        );      /* up is in positive Y direction */

}