Outline

• Handling Interaction in GLUT
• Some comments on a second project
• Geometric Data Types
• Vectors, Coordinate Vectors, Bases
• Linear Transformations

Introduction

• Last Day, we described how to write a simple OpenGL program that made use of a shader.
• Today, we begin by briefly looking at how to handle events from the mouse and keyboard using GLUT.
• Then I'll show a minor enhancement to the original program jsut to demonstrate the code is changeable and you can get things to work.
• Finally, we'll start talking about vector geometry which will lay the foundations for writing more sophisticated programs.

Handling interaction

• Recall that in the main() of our program last day we called several functions to set up OpenGL and get it processing.
• One of these functions was: initGlutState.
• This function set up the initial window and then registered a bunch of callbacks functions:

    glutDisplayFunc(display);                   // display rendering callback
    glutReshapeFunc(reshape);                   // window reshape callback
    glutMotionFunc(motion);                     // mouse movement callback
    glutMouseFunc(mouse);                       // mouse click callback
    glutKeyboardFunc(keyboard);
  

• The last three say what function to can in the case the window is moved, a mouse event happens, and if the keyboard is pressed.
• Let's look at these callback each in turn.

Mouse

static void mouse(int button, int state, int x, int y) {
  if (button == GLUT_LEFT_BUTTON) {
    if (state == GLUT_DOWN) {
      // right mouse button has been clicked
      g_leftClicked = true;
      g_leftClickX = x;
      g_leftClickY = g_height - y - 1;
    }
    else {
      // right mouse button has been released
      g_leftClicked = false;
    }
  }
  if (button == GLUT_RIGHT_BUTTON) {
    if (state == GLUT_DOWN) {
      // right mouse button has been clicked
      g_rightClicked = true;
      g_rightClickX = x;
      g_rightClickY = g_height - y - 1;
    }
    else {
      // right mouse button has been released
      g_rightClicked = false;
    }
  }
}

• Notice the inputs to mouse are all int's.
• The first two: button and state range over only a couple of fixed values each of which has a GLUT constant associated with it.
• For example, GLUT_RIGHT_BUTTON, GLUT_MIDDLE_BUTTON, and GLUT_LEFT_BUTTON for button; GLUT_DOWN and GLUT_UP for state
• In the above, we are just recording the new position in OpenGL rather than GLUT coordinates into global variables: g_rightClickX, g_rightClickY, g_leftClickX, g_leftClickY
• We all record the state of whether the button is pressed in g_rightClicked and g_leftClicked.

Motion

static void motion(int x, int y) {
  const int newx = x;
  const int newy = g_height - y - 1;
  if (g_leftClicked) {
    g_leftClickX = newx;
    g_leftClickY = newy;
  }
  if (g_rightClicked) {
    float deltax = (newx - g_rightClickX) * 0.02;
    g_objScale += deltax;

    g_rightClickX = newx;
    g_rightClickY = newy;
  }
  glutPostRedisplay();
}

• The mouse method we just had recorded when the mouse was initially clicked.
• In motion above, we check if the mouse is still clicked, and if so calculate a delta between the current position and the initial click.
• We use that delat to affect the g_objScale variable which eventually maps to our shaders uniform variable that affects scale when drawing.
• Finally, we redraw the screen.

Keyboard

void keyboard(unsigned char key, int x, int y) {
  switch (key) {
  case 'h':
    cout << " ============== H E L P ==============\n\n"
    << "h\t\thelp menu\n"
    <<  "s\t\tsave screenshot\n"
    <<  "drag right mouse to change square size\n";
    break;
  case 'q':
    exit(0);
  case 's':
    glFinish();
    writePpmScreenshot(g_width, g_height, "out.ppm");
    break;
  }
}

• This callback is generated for ASCII character keyboard events.
• glutSpecialFunc can be used for non-ASCII events.
• glutGetModifiers can be used to detect things like the SHIFT key.
• The above handle the three keys: 'h', 'q', and 's' and ignores any other keys.

Modifying the Original Program

• OpenGL programs can be large and intimidating; however, you typically start with the boiler plate code largely written for you.
• The changes you have left to make are then relatively small.
• For example, suppose we wanted to modify the original program to draw a 2 x 2 checkerboard pattern rather than a single big square.
• Since we set up the vertices of the square and also had the draw method for it in SquareGeometry, this suggests it is a good struct to try to modify.
• We change it is follows. Notice we now have made sqPos, sqTex, and sqCol into an array of two squares.
• Then in draw(), we cycle over drawing each.
• If we wanted more squares we might even have used a short function to calculate the correct coordinates for each in the constructor, rather than hard-coding as we have done.
• This would be okay as although draw() might be called often, the constructor is not, so it would still be fast.

struct SquareGeometry {
  GlBufferObject posVbo[2], texVbo, colVbo;

  SquareGeometry() {
      static GLfloat sqPos[2][12] = {
        {
            -.5, -.5,
            0.,  0.,
            0,  -.5,

            -.5, -.5,
            -.5, .0,
            0,  .0
        },
        {
            0.,  0.,
            .5,  .5,
            .5,  0,
            
            0., 0.,
            0., .5,
            .5,  .5
        }
      };

    static GLfloat sqTex[12] = {
      0, 0,
      1, 1,
      1, 0,

      0, 0,
      0, 1,
      1, 1
    };

    static GLfloat sqCol[18] =  {
      1, 0, 0,
      0, 1, 1,
      0, 0, 1,

      1, 0, 0,
      0, 1, 0,
      0, 1, 1
    };

    for (int i = 0; i < 2; i++) {
        glBindBuffer(GL_ARRAY_BUFFER, posVbo[i]);
        glBufferData(
          GL_ARRAY_BUFFER,
          12*sizeof(GLfloat),
          sqPos[i],
          GL_STATIC_DRAW);
        checkGlErrors();
    }

    glBindBuffer(GL_ARRAY_BUFFER, texVbo);
    glBufferData(
      GL_ARRAY_BUFFER,
      12*sizeof(GLfloat),
      sqTex,
      GL_STATIC_DRAW);
    checkGlErrors();

    glBindBuffer(GL_ARRAY_BUFFER, colVbo);
    glBufferData(
      GL_ARRAY_BUFFER,
      18*sizeof(GLfloat),
      sqCol,
      GL_STATIC_DRAW);
    checkGlErrors();
  }

  void draw(const ShaderState& curSS) {
      int numverts=6;
      safe_glEnableVertexAttribArray(curSS.h_aPosition);
      safe_glEnableVertexAttribArray(curSS.h_aTexCoord0);
      safe_glEnableVertexAttribArray(curSS.h_aTexCoord1);
      safe_glEnableVertexAttribArray(curSS.h_aColor);
      for (int i = 0; i < 2; i++) {

          
        glBindBuffer(GL_ARRAY_BUFFER, posVbo[i]);
        safe_glVertexAttribPointer(curSS.h_aPosition,
                                   2, GL_FLOAT, GL_FALSE, 0, 0);

        glBindBuffer(GL_ARRAY_BUFFER, texVbo);
        safe_glVertexAttribPointer(curSS.h_aTexCoord0,
                                   2, GL_FLOAT, GL_FALSE, 0, 0);

        glBindBuffer(GL_ARRAY_BUFFER, texVbo);
        safe_glVertexAttribPointer(curSS.h_aTexCoord1,
                                   2, GL_FLOAT, GL_FALSE, 0, 0);

        glBindBuffer(GL_ARRAY_BUFFER, colVbo);
        safe_glVertexAttribPointer(curSS.h_aColor,
                                   3, GL_FLOAT, GL_FALSE, 0, 0);

        glDrawArrays(GL_TRIANGLES, 0, numverts);


      }
      safe_glDisableVertexAttribArray(curSS.h_aPosition);
      safe_glDisableVertexAttribArray(curSS.h_aColor);
      safe_glDisableVertexAttribArray(curSS.h_aTexCoord0);
      safe_glDisableVertexAttribArray(curSS.h_aTexCoord1);
  }
};

Geometric Data Types

• In order to draw stuff we need a way to represents points in space.
• We also need a way to describe translations and rotations for moving these points as well as our viewpoint of these points in space.
• A typical point in the real world (no Einstein relativity please) can be represented with three real numbers, `((x), (y), (z))`, which we call a coordinate vector.
• The numbers specify the position of the point with respect to some agreed upon coordinate system.
• This system has a fixed origin and three agreed upon directions: x, y, z.
• If we change the coordinate system we would get a different coordinate vector to describe the same point.
• So to accurately capture the situation we need to distinguish between: coordinate systems, coordinate vectors. and geometric points

Definitions

• A point will be denoted `tilde(p)`. A point is a geometric object, not a numerical one. Roughly, it represents a place in the world
• A vector will be denoted `vec(v)`. A vector also is a non numeric object. Roughly, it represents a motion required to go between two points.
• A coordinate vector will be denoted `bb(c)` is a numeric object made up of real numbers.
• A coordinate system will be denoted `vec(bb(f))^t`. It is bold to signify a vertical collection, the superscript `t` indicates transpose to make it a horizontal collection, the arrow tells us it is a collection of vectors not numbers. There are two kinds of coordinate systems:
  1. A basis which is used to describe vectors.
  2. A frame which is used to describe points.

Vectors, Coordinate Vectors, and Bases

• As we said on the last slide, a vector will be an abstract entity to represent motions between two points in the world. An example might be the phrase "one mile east".
• A coordinate vector is a set of real numbers used to specify a vector, once we have agreed upon a coordinate system.
• A (real) vector space V is some set of elements `vec(v)` that satisfies the rules:
  • If `alpha in RR` and `vec(v), vec(w) in V` then `alpha vec(v) in V` and `vec(v) + vec(w) in V`.
  • `vec(0) + vec(v) = vec(v) + vec(0) = vec(v)`
  • `0vec(v) = vec(0)`
  • `1vec(v) = vec(v)`
  • `-vec(v) = (-1)vec(v)`
  • `(alpha cdot beta) vec(v) = alpha ( beta vec(v))`
  • `(alpha + beta)vec(v) = alpha vec(v) + beta vec(v)` (Scalar Distributivity)
  • `alpha(vec(v) +vec(w)) = alpha vec(v) + vec(w)` (Distributivity)
  • `vec(v) + vec(w) = vec(w) + vec(v)` (Commutivity)
  • `(alpha cdot beta) vec(v) = alpha ( beta vec(v))` (Scalar Associativity)
  • `(vec(u) + vec(v)) + vec(w) = vec(u) + (vec(w) + vec(v))` (Associativity)
• Many families of objects satisfy the structure of a vector space not just odered tuples of three numbers.
• In this class, we will be interested in vector spaces of actual motions between geometric points.

Basis

• A coordinate system or basis is a small set of vectors that can be used to produce the entire set of vectors in a vector space `V` using just vector operations.
• Formally, a set of vectors `vec(b_1), ... vec(b_n)` are linearly dependent if there are scalars `alpha_i`, not all zero, such that `alpha_1 vec(b_1) + cdots + alpha _n vec(b_n) = 0`. If not, a set of vectors is called linearly independent.
• Given a set of vectors `B = \{vec(b_1), ... vec(b_n)\}`, `span(B)`, the span of `B`, is the smallest set of vectors which contain `B` and which is closed under + and scalar multiplication.
• A basis for a vector space `V` is a set of linearly independent vectors whose span is `V`.
• It turns out all bases for the same vector space have the same number of vectors. We can this number the dimension of the vector space.
• For free motions in space, the dimension is 3.
• We refer to each of the basis vector as an axis. We refer to the first axis as the x axis, the second as the y axis, and the third as the z axis.

More on Bases

• We can represent any vector `vec(v)` in a vector space as a sum of scalars `c_i` times bases `b_i`. i.e., `vec(v) = sum_i c_i vec(b_i)`.
• In vector algebra notation this is:
  `vec (v) = sum_i c_i vec(b_i) = (vec(b_1)\ vec(b_2)\ vec(b_3) )((c_1), (c_2), (c_3) ) = vec(bb(b))^t bb(c)`
• Notice each `vec(b_i)` is a column vector. So we can view the above a 3x3 matrix times a column.
• So `vec(bb(b))^t` is a row of basis vectors and `bb(c)` is a coordinate vector.

Linear Transformations

• A linear transformation `mathcal(L)` is a mapping from `V` to `V` that satisfies:
  `mathcal(L)(vec(v) + vec(w)) = mathcal(L)(vec(v)) + mathcal(L)(vec(w))`
  and
  `mathcal(L)(alpha vec(v)) = alpha mathcal(L)(vec(v))`
• The class of linear transformations is exactly the class that can be expressed using matrices.
• This is because the effect of a linear transformation can be exactly specified by tellings us its effect on the basis vectors.
• To see this consider
  `vec(v) => mathcal(L)(vec v) = mathcal(L)(sum_i c_i vec(b_i)) = sum_i c_imathcal(L)(vec(b_i))`
• In vector algebra notation, we have:
  `(vec(b_1)\ vec(b_2)\ vec(b_3) )((c_1), (c_2), (c_3) ) => (mathcal(L)(vec(b_1))\ mathcal(L)(vec(b_2))\ mathcal(L)(vec(b_3)) )((c_1), (c_2), (c_3) ) `
• Each `mathcal(L)(vec(b_i))` represents an element of `V`. So it can be represented as some linear combination of the basis vectors. So we can write:
  `mathcal(L)(vec(b_i)) = (vec(b_1)\ vec(b_2)\ vec(b_3) )((M_(1,i)), (M_(2,i)), (M_(3,i)) )`

Linear transformations (cont'd)

• Hence, we have:
  `(mathcal(L)(vec(b_1))\ mathcal(L)(vec(b_2))\ mathcal(L)(vec(b_3))) = (vec(b_1)\ vec(b_2)\ vec(b_3) ) ((M_(1,1)\ M_(1,2)\ M_(1,3)), (M_(2,1)\ M_(2,2)\ M_(2,3)), (M_(3,1)\ M_(3,2)\ M_(3,3)) )`
• So the effect of the original mapping `vec(v) => mathcal(L)(v)` where `vec(v) = sum_i c_i vec(b_i)` can be written as:
  `(vec(b_1)\ vec(b_2)\ vec(b_3) )((c_1), (c_2), (c_3) ) =>(vec(b_1)\ vec(b_2)\ vec(b_3) ) ((M_(1,1)\ M_(1,2)\ M_(1,3)), (M_(2,1)\ M_(2,2)\ M_(2,3)), (M_(3,1)\ M_(3,2)\ M_(3,3)) )((c_1), (c_2), (c_3) )`.
• For short, we write `vec(bb(b))^t => vec(bb(b))^t M bb(c)`
• If we apply a the transfrormation to each of the basis vectors we get a new basis:
  `(vec(b_1)\ vec(b_2)\ vec(b_3) ) => (vec(b_1)\ vec(b_2)\ vec(b_3) ) ((M_(1,1)\ M_(1,2)\ M_(1,3)), (M_(2,1)\ M_(2,2)\ M_(2,3)), (M_(3,1)\ M_(3,2)\ M_(3,3)) )`
• A matrix can also be applied to a coordinate vector to get a new coordinate vector.
  `bb(c) => M bb(c)`.
• Next day we will discuss the main kinds of linear transformation we have in three dimensions.