Some GLUT

• This is from
  • Appendix A of the book (but not much)
  • The freeglut documentation.
• Glut provides an event driven envrionment.
  • In event driven programming, the programmer regeisters a number of callback functions or callbacks.
  • These functions are called by the event loop when a given event occurs.
  • An event is something that happens, or we cause to happen.
    • keypresses, mouse movement, button clicks are all events.
    • But also the window needs to be redrawn or the canvas needs to be redrawn.
• To go along with this, glut also provides a (very primitive) user interface builder.
• Basics
  • The stuff in the main of triangles.C really doesn't need much explination

        glutInit(&argc, argv);
    
        glutInitDisplayMode(GLUT_RGBA);
        glutInitWindowSize(512, 512);
    
        glutInitContextVersion(3,0);
        glutInitContextProfile(GLUT_CORE_PROFILE);
    
        glutCreateWindow(argv[0]);
    

  • Except for:
    • glutDisplayFunc(display);
      • This registers the redraw callback.
      • In this case, display is the function to be called
      • This is called whenever the contents of the window need to be drawn.
      • Called initially when the window is created.
      • A call can be forced with glutPostRedisplay()
    • glutMainLoop();
      • This is the main event loop.

        while (1)  {
           GetEvent(E)
           if (E != NO_EVENT)  {
               DispatchEvent(E)
           } else {
               IdleEvent();
           }
        }

      • This loop never exits.
• Some modifications to triangles
  • I want to:
    • Be able to see it on the projector.
    • And be able to see points
    • And be able to see the effects of interaction
  • So I have modified the triangle code.
  • By the way, I expect you to start picking up OpenGL techniques here.
    • Point size
      • OpenGL is sometimes called a "state machine".
      • It the sense that you turn the value of something on or off.
      • Point size is one of those things.
      • First turn on point size
        • This is done with glEnable()
        • The capacity we want is GL_PROGRAM_POINT_SIZE
        • Later we can turn point size off with glDisable()
        • Notice GL_LINE_SMOOTH and other options here.
        • I added this to init().
      • Second we need to set the point size.
        • This is done by setting the shader variable gl_PointSize in a shader to be a positive value.
        • I added this to triangles.vert.

          attribute vec4 vPosition;
          
          void main() {
              gl_Position = vPosition;
              gl_PointSize = 5.0;
          }
          

    • Next I would like the background to be white
      • This is just the value the color buffer gets cleared with.
      • This is done once with glClearColor(r,g,b)
      • Takes a r,g,b, and alpha value.
      • The range is 0 to 1
      • I added this to the init() routine.
    • Finally, I didn't want the polygons to be filled.
      • glPolygonMode() accomplishes this.
      • The choices for the face are GL_FRONT, GL_BACK, or GL_FRONT_AND_BACK.
      • The choices for the mode are GL_POINT, GL_LINE, GL_FILL

      void init(void) {
      
          glClearColor(1,1,1,1);
          glEnable(GL_PROGRAM_POINT_SIZE);
          glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
      
      ...
      }
      

  • Finally, I want to be able to draw the points, lines or triangles.
    • I changed the points in init

          GLfloat vertices[NumVertices][2] = {
               { -0.90, 0.0},
               { -0.60,  0.90},
               {  0.60,   0.90},
               {  0.90,  0.00},
               {  0.60,  -0.90},
               { -0.60,   -0.90}
          };
      

    • And I modified the display routine
      • Static variable state, which is used to move to next state
      • This will change as we work our way through.
      • Added a switch statement to select a mode to draw the figure in.
      • I modified the call to glDrawArrays slightly.

        void display(void){
        
            static int state = 0;
            GLenum mode;
        
            cout << "In the display function " << endl;
            glClear(GL_COLOR_BUFFER_BIT);
            glBindVertexArray(VAOs[Triangles]);
        
            switch(state) {
                case 0: mode = GL_POINTS;
                        cout << "Drawing Points " << endl;
                        break;
                case 1: mode = GL_LINES; 
                        cout << "Drawing Lines " << endl;
                        break;
                case 2: mode = GL_LINE_STRIP; 
                        cout << "Drawing Line Strip " << endl;
                        break;
                case 3: mode = GL_LINE_LOOP;
                        cout << "Drawing Line Loop " << endl;
                        break;
                case 4: mode = GL_TRIANGLES;
                        cout << "Drawing Triangles " << endl;
                        break;
                case 5: mode = GL_TRIANGLE_STRIP;
                        cout << "Drawing Triangle Strip " << endl;
                        break;
                default:
                case 6: mode = GL_TRIANGLE_FAN;
                        cout << "Drawing Triangle Fan " << endl;
                        state = -1;
                        break;
            }
            state++;
        
            glDrawArrays(mode, 0, NumVertices);
            glFlush();
        
            return;
        }
        

• Some essentual glut functions.
  • The Keypress callback.
    • glutKeyboardFunc
    • void glutKeyboardFunc(void (*func)(unsigned char key, int x, int y));
    • This function takes a function wich is defined
      • as a void function
      • Which has trhee parameters
      • A character representing the key that was pressed.
      • Two integers, x and y which represent where (in the window) the key was pressed.

      // function prototype
      void Keypress(unsigned char key, int x, int y) ;
      
      int main() { 
      ...
          glutDisplayFunc(display);
          glutKeyboardFunc(Keypress);
      
          glutMainLoop();
      };
      
      void Keypress(unsigned char key, int x, int y) {
         cout << "The " << key << " key was pressed at (" << x << "," << y
              << ")" << endl;
      
         bool redisplay = false;
         switch (key) {
            case 'Q':
            case 'q': exit(0);
      
            case 'r':
            case 'R':   redisplay = true;
                      break;
            default:
                      cerr << "Unhandled keypress for key '" << key << "'" << endl;
         }
      
         if (redisplay) {
            glutPostRedisplay();
         }
      
         return;
      }
      
      
      

    • We can now step through the different shapes.
  • The Special key function is useful as well.
    • glutSpecialFunc()
    • Same as Keyboard
    • But for special characters (see list on man page)
    • LEFT, RIGHT, UP, DOWN are the arrow characters.
  • There are also glutKeyboardUpFunc and glutSpecialUpFunc if you want both up and down.
• Changing the display mode
  • I don't like the display mode changing every time we redraw the window.
  • This is just bad software engineering/design.
  • But you see, we can't pass parameters to anything.
  • So I will use a global variable: Line_Mode_G
    • I will try to follow the naming convention
    • We could build a singleton to store these variables.
  • Furthermore I want to break up the code.
    • A design priciple says to make the display and the UI seperate.
    • And I will probably reuse the keypress, special, ... functions over and over again.
  • So I will make a UI.h and UI.C file.
    • Place the functions and function prototypes in this file.
    • extern GLenum Line_Mode_G in UI.C
  • Modifications to the Makefile.
  • Verbose variable in UI.C
  • KeyHelp function.
• The final code for today is here