src/opengl/prospect_opengl.cc

#if __linux
#define  GL_GLEXT_PROTOTYPES
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glext.h>
#include <GL/glut.h>
#else
#if __APPLE__
#include <opengl/gl.h>
#include <opengl/glu.h>
#include <glut/glut.h>
#endif
#endif
#include <stdio.h>


#include "TargetStructGL.h"
#include "sm_matrix.h"
#include "ArcBall.h"


//GLUT interface stuff



ArcBall_t *my_arcball;
Matrix4fT Transform = { 1.0f, 0.0f, 0.0f, 0.0f,
  0.0f, 1.0f, 0.0f, 0.0f,
  0.0f, 0.0f, 1.0f, 0.0f,
  0.0f, 0.0f, 0.0f, 1.0f
};

Matrix3fT LastRot = { 1.0f, 0.0f, 0.0f, // Last Rotation
  0.0f, 1.0f, 0.0f,
  0.0f, 0.0f, 1.0f
};

Matrix3fT ThisRot = { 1.0f, 0.0f, 0.0f, // This Rotation
  0.0f, 1.0f, 0.0f,
  0.0f, 0.0f, 1.0f
};




vec3 eye = {0.0f, 0.0f, 140.0f};
vec3 rot = {45.0f, 45.0f, 0.0f};
int screenHeight, screenWidth;
int last_x, last_y;

TargetStructGL *the_target;

int modifer_keys = 0;


void my_draw_function (void) {
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  glLoadIdentity ();
  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);
  
  glMultMatrixf (Transform.M);  // Apply Dynamic Transform
  {
    the_target->DrawBackBoneLine ();
    the_target->DrawAtomSphere ();
  }
  glPopMatrix ();

  glFlush ();
  glutSwapBuffers ();
}



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);
  screenHeight = height; screenWidth = width;
  my_arcball->setBounds ((GLfloat) width, (GLfloat) height);    // Update Mouse Bounds For ArcBall
}


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




enum
{
  LEFT = 0,
  RIGHT,
};


#if !defined(GLUT_WHEEL_UP)
#  define GLUT_WHEEL_UP   3
#  define GLUT_WHEEL_DOWN 4
#endif




int clickdown_select;
int mButton = -1;

void glutMotion (int x, int y) {
        
        if ( modifer_keys & GLUT_ACTIVE_CTRL ) {
                eye[3] += last_x - x;
        } else {
                
                if (mButton == LEFT) {
                        Point2fT mouse_point;
                        mouse_point.s.X = x;
                        mouse_point.s.Y = y;
                        //mouse_point.s.X  =  ((mouse_point.s.X / (((float)screenWidth  - 1) / 2.0)) - 1);
                        //mouse_point.s.Y  = -((mouse_point.s.Y / (((float)screenHeight - 1) / 2.0)) - 1);
                        Quat4fT ThisQuat;
                        
                        my_arcball->drag (&mouse_point, &ThisQuat);     // Update End Vector And Get Rotation As Quaternion
                        Matrix3fSetRotationFromQuat4f (&ThisRot, &ThisQuat);    // Convert Quaternion Into Matrix3fT
                        Matrix3fMulMatrix3f (&ThisRot, &LastRot);       // Accumulate Last Rotation Into This One
                        Matrix4fSetRotationFromMatrix3f (&Transform, &ThisRot); // Set Our Final Transform's Rotation From This One
                        
                        
                        my_draw_function();
                        clickdown_select = -1;
                } else if (mButton == RIGHT) {
                        if ( clickdown_select != -1 ) {
                                /*
                                 //Example code to calculate the x,y,z co-ordinates of a selected point
                                GLint viewport[4];
                                GLdouble modelview[16];
                                GLdouble projection[16];
                                GLfloat winX, winY, winZ;
                                GLdouble posX, posY, posZ;
                                
                                glGetDoublev( GL_MODELVIEW_MATRIX, modelview );
                                glGetDoublev( GL_PROJECTION_MATRIX, projection );
                                glGetIntegerv( GL_VIEWPORT, viewport );
                                
                                winX = (float)x;
                                winY = (float)viewport[3] - (float)y;
                                //glReadPixels( x, int(winY), 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &winZ );
                                // calculate the Z distance as the center of the selected object
                                
                                gluUnProject( winX, winY, winZ, modelview, projection, viewport, &posX, &posY, &posZ);
                                */
                        }                       
                }
        }
        last_x = x; last_y = y;
}

void glutMouse (int button, int state, int x, int y) {
        int num_pickable_objects = 1000;
        
        if (state == GLUT_DOWN) {
                printf("x: %d y%d\n", x, y);
                Point2fT  mouse_point;
                mouse_point.s.X = x;
                mouse_point.s.Y = y;
                //mouse_point.s.X  =  ((mouse_point.s.X / (((float)screenWidth  - 1) / 2)) - 1);
                //mouse_point.s.Y  = -((mouse_point.s.Y / (((float)screenHeight - 1) / 2)) - 1);
                my_arcball->click (&mouse_point);
                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 ();
                                
                                
                                my_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;
                        case GLUT_WHEEL_UP:
                                eye[2]+=5;
                                break;
                        case GLUT_WHEEL_DOWN:
                                eye[2]-=5;
                                break;
                }
        } else if (state == GLUT_UP) {
                mButton = -1;
                if (clickdown_select != -1) {
                        printf ("Selection %d\n", clickdown_select);
                        the_target->SetColor (clickdown_select, 0.4, 1.0, 0.4);
                        the_target->SphereList_Init ();
                        
                }
        }
        last_x = x; last_y = y;
        my_draw_function();
}



void glutMenu (int value) {
  switch (value) {
    case 1:
      glutFullScreen ();
      return;

    case 2:
      exit (0);
    }
}

void my_glut_init (int argc, char **argv) {
  GLfloat ambient[] = { .3, .3, .3, .3 };
  GLfloat specular[] = { 1, 1, 1, 1 };

  my_arcball = new ArcBall_t (400, 300);
  // Reset Rotation
  Matrix3fSetIdentity (&LastRot);
  // Reset Rotation
  Matrix3fSetIdentity (&ThisRot);
  // Reset Rotation
  Matrix4fSetRotationFromMatrix3f (&Transform, &ThisRot);

  screenHeight = 300; screenWidth = 400;

  glutInit (&argc, argv);
  glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  glutInitWindowSize ( screenWidth, screenHeight );
  glutInitWindowPosition (100, 100);

  glutCreateWindow ("local align");
  glutReshapeFunc (glutResize);
  glutDisplayFunc (my_draw_function);
  //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);


}



int
main (int argc, char **argv)
{
  my_glut_init (argc, argv);

  TargetStructGL target;
  target.LoadPDB (argv[1]);
  the_target = &target;
  the_target->MoveMeanToOrigin ();

  glEnableClientState (GL_VERTEX_ARRAY);

  glShadeModel (GL_SMOOTH);     // Enable Smooth Shading
  glClearColor (0.2f, 0.5f, 1.0f, 1.0f);        // Background
  glClearDepth (1.0f);          // Depth Buffer Setup
  glClearStencil (0);           // Clear The Stencil Buffer To 0
  glEnable (GL_DEPTH_TEST);     // Enables Depth Testing
  glDepthFunc (GL_LEQUAL);      // The Type Of Depth Testing To Do
  glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);   // Really Nice Perspective Calculations
  glEnable (GL_TEXTURE_2D);     // Enable 2D Texture Mapping
  glEnable (GL_COLOR_MATERIAL);


  // Light Parameters
  static GLfloat LightAmb[] = { 0.4f, 0.4f, 0.4f, 1.0f };       // Ambient Light
  static GLfloat LightDif[] = { 0.7f, 0.7f, 0.7f, 1.0f };       // Diffuse Light
  static GLfloat LightSpc[] = { 1.0f, 1.0f, 1.0f, 1.0f };       // Diffuse Light
  static GLfloat LightPos[] = { 4.0f, 4.0f, 6.0f, 1.0f };       // Light Position

  {
    double max_dist = 0;
    for (int i = 0; i < the_target->len; i++)
      {
        ResidueAtoms *the_res = &the_target->structure[i];
        for (int j = 0; j < the_res->atom_count; j++)
          {
            double dist = smNorm (the_res->atom[j]);
            if (dist > max_dist)
              max_dist = dist;
          }
      }
    double ratio = max_dist / smNorm (LightPos);
    LightPos[0] *= ratio;
    LightPos[1] *= ratio;
    LightPos[2] *= ratio;
  }


  glLightfv (GL_LIGHT0, GL_AMBIENT, LightAmb);  // Set The Ambient Lighting For Light0
  glLightfv (GL_LIGHT0, GL_DIFFUSE, LightDif);  // Set The Diffuse Lighting For Light0
  glLightfv (GL_LIGHT0, GL_SPECULAR, LightSpc); // Set The Diffuse Lighting For Light0
  glLightfv (GL_LIGHT0, GL_POSITION, LightPos); // Set The Position For Light0

  glEnable (GL_LIGHT0);         // Enable Light 0
  glEnable (GL_LIGHTING);       // Enable Lighting

  the_target->SphereList_Init ();
  the_target->VOB_Init ();

  glutMainLoop ();

  return 0;
}

---