src/opengl/glut_util.cc

#if __linux
#include <GL/gl.h>
#include <GL/glut.h>
#else
#include <opengl/gl.h>
#include <glut/glut.h>
#endif

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>


#include "glut_util.h"

typedef float vec3_t[3];

drawing_function user_draw_function;
input_function user_input_function;
selection_function user_select_function;

int clickdown_select;


void glutDisplay(void);


void my_glut_set_selectfunc(selection_function sel_func) {
        user_select_function = sel_func;        
        clickdown_select = -1;
}


void clamp(vec3_t v)
{
    int i;
    
    for (i = 0; i < 3; i ++)
        if (v[i] > 360 || v[i] < -360)
            v[i] = 0;
}

//Generic GLUT functions


enum {
    LEFT = 0, 
    RIGHT,
};


int mButton = -1;
int mOldY, mOldX; 

vec3_t eye = {0.0f, 0.0f, 140.0f};
vec3_t rot = {45.0f, 45.0f, 0.0f};


void glutResize(int width, int height)
{   
        glViewport(0, 0, width, height);
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluPerspective(55.0, (float)width/(float)height, 1.0, 3000.0);
        glMatrixMode(GL_MODELVIEW);
}


void glutKeyboard(unsigned char key, int x, int y)
{
        switch (key) {
                case 27:
                        exit(0);
                break;
        }
        user_input_function(key);
        
}


void glutMotion(int x, int y) 
{
    if (mButton == LEFT) 
    {
        rot[0] -= ((mOldY - y) * 180.0f) / 200.0f;
        rot[1] -= ((mOldX - x) * 180.0f) / 200.0f;
        clamp (rot);
                clickdown_select = -1;
    }
        else if (mButton == RIGHT) 
    {
        eye[2] -= ((mOldY - y) * 180.0f) / 200.0f;
        clamp (rot);
    } 

    mOldX = x; 
    mOldY = y;
}

void glutMouse(int button, int state, int x, int y) 
{
  int num_pickable_objects = 1000;
  
  if(state == GLUT_DOWN) {
    mOldX = x;
    mOldY = y;
    switch(button) {
    case GLUT_LEFT_BUTTON: {
      mButton = LEFT;
      
      
      //Hold the ID of the objects clicked. Each object takes 4 places in the array.
      GLuint *selectBuffer = new GLuint[ num_pickable_objects*4 ];
      //Register our buffer to write in it.
      glSelectBuffer(num_pickable_objects * 4, selectBuffer);
      
      glRenderMode( GL_SELECT );
      glMatrixMode( GL_PROJECTION );
      //Restrict region to pick object only in this region
      
      GLint viewport[4];                                        // Where The Viewport Values Will Be Stored
      glGetIntegerv(GL_VIEWPORT, viewport);                     // Retrieves The Viewport Values (X, Y, Width, Height)
      
      glLoadIdentity();
      gluPickMatrix(x, viewport[3]-y, 2, 2, viewport);    //viewport[3]-y because 0 is at top for the mouse
      gluPerspective(55.0, (float)viewport[2]/(float)viewport[3], 1.0, 3000.0);
      
      glPushMatrix();
      
      glTranslatef (-eye[0], -eye[1], -eye[2]);   
      
      glRotatef(rot[0], 1.0f, 0.0f, 0.0f);
      glRotatef(rot[1], 0.0f, 1.0f, 0.0f);
      glRotatef(rot[2], 0.0f, 0.0f, 1.0f);
      (*user_draw_function)();
      glPopMatrix();
      
      int num_objects_picked = glRenderMode( GL_RENDER );                               
      if ( num_objects_picked > 0 ) {
        
        GLuint hit_dist = selectBuffer[1];
        GLuint hit_name = selectBuffer[3];
        int offset = 0;
        
        for (int i = 0; i < num_objects_picked; i++) {  // for each hit 
          if ( hit_dist >= selectBuffer[ offset + 1 ] ) {
            hit_dist = selectBuffer[ offset + 1 ];
            hit_name = selectBuffer[ offset + 3 ];
          }
          offset += 3 + selectBuffer[ offset ];
        }
        clickdown_select = hit_name;
      } else {
        clickdown_select = -1;
      }
      
      glMatrixMode(GL_PROJECTION);
      glLoadIdentity();
      gluPerspective(55.0, (float)viewport[2]/(float)viewport[3], 1.0, 3000.0);
      glMatrixMode(GL_MODELVIEW);
      
      
      break;
    }
    case GLUT_RIGHT_BUTTON:
      mButton = RIGHT;
      break;
    }
  } else if (state == GLUT_UP) {
    mButton = -1;
    if ( user_select_function != NULL && clickdown_select != -1 ) {
      user_select_function( clickdown_select );
      glutDisplay();
    }
  }
}

void glutMenu(int value)
{
        switch (value)
        {
                case 1:
                        glutFullScreen();
                        return;
                
                case 2:
                        exit(0);
        }
}


void glutDisplay(void) {
        long i,j,res_start,res_end;   
        bool draw;
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        float alpha;

    glPushMatrix();

                glTranslatef (-eye[0], -eye[1], -eye[2]);         

                glRotatef(rot[0], 1.0f, 0.0f, 0.0f);
            glRotatef(rot[1], 0.0f, 1.0f, 0.0f);
            glRotatef(rot[2], 0.0f, 0.0f, 1.0f);
            
                glBindTexture(GL_TEXTURE_2D, 1);
                
                
                (*user_draw_function)();
                
        glPopMatrix();

        glFlush();
        glutSwapBuffers();
}

                

void my_glut_init(int argc, char **argv, drawing_function draw, input_function input) {
        GLfloat ambient[] = {.3,.3,.3,.3};
        GLfloat specular[]  = {1,1,1,1};
        
        glutInit(&argc, argv);
        glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
        glutInitWindowSize(400, 300);
        glutInitWindowPosition(100, 100);
        
        glutCreateWindow("local align");
        glutReshapeFunc(glutResize);
        glutDisplayFunc(glutDisplay);
        glutIdleFunc(glutDisplay);
    glutKeyboardFunc(glutKeyboard);
        glutMouseFunc(glutMouse);
    glutMotionFunc(glutMotion);

        glEnable(GL_TEXTURE_2D);
        glEnable(GL_BLEND);
//      glEnable(GL_LIGHTING);
//      glLightfv(GL_LIGHT0, GL_AMBIENT, ambient );
//      glLightfv(GL_LIGHT0, GL_SPECULAR, specular );
//      glEnable(GL_LIGHT0);
        glEnable(GL_COLOR_MATERIAL);
        glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
    glEnable(GL_DEPTH_TEST);

        glutCreateMenu(glutMenu);
        glutAttachMenu(GLUT_MIDDLE_BUTTON);
        glutAddMenuEntry("Full Screen", 1);
        glutAddMenuEntry("Exit", 2);

        user_draw_function = draw;
        user_input_function = input;
}



void my_glut_main_loop(void) {
        glutMainLoop();
}

---