Computer Graphics Chapter 4 Geometric Objects and Transformations

Computer Graphics - Chapter 4 Geometric Objects and Transformations Objectives are to learn to: • represent the basic geometric types • learn to convert between various representations • learn to establish a method for dealing with geometric problems that are independent of coordinate systems. Much of what we present in this chapter is an application of vector spaces, geometry, and linear algebra. Chapter (4) 1

The Geometric View We can define most geometric objects using a limited set of simple entities. Three basic types are needed: 1) scalars, 2) points, and 3) vectors. These entities can be defined in at least three different ways: 1) from a mathematical perspective, 2) from a programming perspective, or 3) from a geometric perspective. The fundamental geometric object is a point. In 3 -D a point is a location in the space. The only attribute a point assumes is its location. Scalars do not have geometric properties and are used as units of measurement. In computer graphics, we connect points with directed line segments, vectors. A vector does not have a fixed position. Chapter (4) 2

The Geometric View – cont. Mathematician like to see things as points, scalars, and vectors. Computer scientists like to see them as abstract data types (ADTs). An ADT is a set of operations on data. These operations are defined independently of how the data are represented internally or of how the operations are implemented. Chapter (4) 3

Geometric ADTs Subtraction of two points will result in a vector: v=P–Q This also can be written as: P=Q+v Some other possibilities are shown below. Head_to_tail rule for vectors Head_to_tail rule for points P-R P-Q Q-R Chapter (4) 4

Lines A line can be represented as: Where P 0 is an arbitrary point, d is an arbitrary vector, and is a scalar. You have seen a similar thing for line before as: y = b + mx. Affine Sums In an affine space, the addition of two vectors the multiplication of a vector by a scalar, and the addition of a vector and a point are defined. the addition of two arbitrary points multiplication of a point by a scalar are not defined. Chapter (4) Find a point such that: Thus, This looks like addition of 2 points, where 5

Convexity A convex object is one for which any point lying on the line segment connecting any two points in the object is also in the object. For , the affine sum defines the line segment connecting R and Q, as shown in this figure. This line is convex object. We can extend the affine sum to include objects defined by n points P 1, P 2, …, Pn. Something like this: We can use induction to show that this line is defined if and only if (iff): A set of points formed by the affine sum of n points, under the restriction: is called the convex hull of the set of points. It is the smallest convex object that includes the set of points. Chapter (4) The convex hull includes all line segments connecting pairs of points in {P 1, P 2, …, Pn}. 6

Dot (. ) and Cross (x) Products The dot or inner product is an operation between two vectors but will result into a scalar: u. v = |u||v|cos( ) i. e. , cos( ) = u. v / |u||v|. u. u = |u| 2 From this, one find that u and v are orthogonal. The cross product is an operation between two vectors and will result into a vector: u v = |u||v|sin( ) i. e. , sin( ) = u v / |u||v|. u u=0 Chapter (4) thump u v Right-hand rule 7

Planes A plane in an affine space and can be defined as a direct extension of the parametric line. From geometry, any three points that are not on one line will make a unique plane. Let’s do some math here. We want to prove that we need a point and two vectors to make a plane. Chapter (4) 8

Three-Dimensional Primitives In the 3 -D space, there are many varieties for geometric objects. There are two problems when we expand our graphics system to incorporate all the possibilities: First, the mathematical definition of 3 -d objects may be very complex, Second, we are interested in only those objects that lead to efficient implementations in graphics systems. Three features characterized 3 -D objects: 1)The objects are described by their surfaces and can be thought of as being hallow, 2)The objects can be specified through a set of vertices in 3 -D, and 3)The objects either are composed of or can be approximated by flat convex polygons. Chapter (4) Curves in 3 -D Surfaces in 3 -D Volumes in 3 -D 9

Coordinate Systems and Frames In the 3 -D space, any vector w can be represented uniquely in terms of any three linearly independent vectors, v 1, v 2, and v 3. This can be written in matrix form: The T in a. T, denotes the transpose of a. A good example for v 1, v 2, and v 3 can be the Cartesian axes, x, y, and z. Chapter (4) 10

Coordinate Systems and Frames – cont. Sometimes, all the vectors are not coming from the same reference point. Within a frame, we still have: But for every point we need to know where the origin is located, and should consider that. Where P 0 is the origin of the vector coordinate system. Thus, the representation of a particular vector in a frame requires three scalars. The representation of a point requires three scalars and the knowledge of where the origin is located. Chapter (4) 11

Change of Coordinate Systems Often, we are required to represent a vector when we change the basis vectors. Suppose we have {v 1, v 2, v 3} and {u 1, u 2, u 3} as the two bases. Each basis vector in the second set can be represented in terms of the first basis (and vice versa). Where a scalar components will make a 3 x 3 matrix: M contains all the information to go from one representation of a vector in one basis to its representation in the second basis. The inverse of M, i. e. , M-1 will tell us how to go from {u 1, u 2, u 3} to {v 1, v 2, v 3}. Chapter (4) 12

Change of Coordinate Systems – cont. Suppose a vector w with respect to {v 1, v 2, v 3}; Assume also that representation of w with respect to {u 1, u 2, u 3} is: We know that: We can write, w in terms of these two: w = b. Tu = b. TMv = a. T v Thus, a = MTb and b = Aa = (MT)-1 a An Example. Chapter (4) 13

Example Suppose we have, vectors v 1, v 2, and v 3. w = ? ( note: u 1 = v 1 u 2 = v 1 + v 2 u 3 = v 1 + v 2 + v 3 , and we want to make a new basis from the three = )= M= A = (MT)-1 = b = Aa w= Chapter (4) 14

Example Suppose we have, vectors v 1, v 2, and v 3. w = ? ( note: u 1 = v 1 u 2 = v 1 + v 2 u 3 = v 1 + v 2 + v 3 , and we want to make a new basis from the three = )= b u A= b= w = -1 u 1 – 1 u 2 + 3 u 3 Chapter (4) 15

Homogeneous Coordinates Usually, we represent a point P located at (x, y, z) using a 3 -D frame determined by P 0, v 1, v 2, and v 3 with a column matrix: Where, x, y, and z are the components of the basis vectors for this point, so that We can represent a point the same way: So w can be shown as: There are some problems with this procedure: 1) we prefer to distinct points from vectors 2) without distinction between the two, implementation would be very hard. Chapter (4) 16

Homogeneous Coordinates What is the difference between the vector that is drawn from {1, 1, 1} to {2, 3, 4} and the one that is drawn between {0, 0, 0} and {1, 2, 3}? We wish to maintain points and vectors as distinct geometric types. We use homogeneous coordinates to avid the problem. We agree that a point be presented as: where P 0 = 0 or P 0 = 1. We can write this as: The 4 -D matrix on the right side of this equation is called the homogenous-coordinate representation. In this frame, any vector w can be written as: Thus w can be represented by a column matrix as: Chapter (4) 17

Homogeneous Coordinates – Change of frames using the homogeneous coordinates becomes much simpler. Suppose we have the two frames (v 1, v 2, v 3, P 0) and (u 1, u 2, u 3, Q 0) and we want to express the basis vectors and reference point of the second frame in terms of the first as: These equations can be written in matrix form as: where M is the 4 x 4 matrix defined as: M is called the matrix representation of the change of frames. We can use M to compute the changes in the representations either of two points or of two vectors in the two frames. How? Chapter (4) 18

Example Suppose we have, vectors v 1, v 2, and v 3. , and we want to make a new basis from the three u 1 = v 1 u 2 = v 1 + v 2 u 3 = v 1 + v 2 + v 3 Let’s compute a and b. Suppose we have Q 0 = P 0 + v 1 + 2 v 2 + 3 v 3 M= MT = A = (MT)-1 P= P’ = Aa vector a = Chapter (4) b = Aa = 19

Example Suppose we have, vectors v 1, v 2, and v 3. , and we want to make a new basis from the three Point: Q 0 = v 1 + 2 v 2 + 3 v 3 + P 0 u 1 = v 1 u 2 = v 1 + v 2 u 3 = v 1 + v 2 + v 3 point a Chapter (4) vector a 20

Frames and ADTs So far we have learned to define some primitive objects such as points, lines, and planes. We want to write computer code such as: point 3 p, q; or vector 3 v, u; Then, we want to write programs in terms of these types. In C++ that supports overloading we can write the operators as: q = q+v; or u = p – q; But we cannot write: q = v; or u = p + q; In C, we can define the point 3 data type as: typedef float point 3[4]; Then a homogeneous coordinate representation can be written: typedef float point 2[4]; In C we use something like; point 3 p = {1. 0, 2. 0, 3. 0}; There are two problems with this: 1) we have mixed the implementation with the data type, and 2) we cannot determine the coordinate system that is used. How do we solve these problems? Chapter (4) 21

Frames in Open. GL The are two frames in Open. GL, 1) the camera frame, and 2) the world frame. The model-view matrix positions the world frame relative to the camera frame. Thus, the model-view matrix converts the homogeneous-coordinate representations of points and vectors to their representations in the camera frame. There are three basic vectors: 1) up direction of the camera, y direction 2) the direction where camera is pointing, negative z direction 3) the direction to make the x, y, and z right-handed coordinate, x. Chapter (4) 22

Frames in Open. GL-cont. If we regard the camera frame as fixed and the model-view matrix as positioning the world frame relative to the camera frame, then the model-view matrix, Moves a point (x, y, z) in the world frame to the point (x, y, z, -d) in the camera frame. By making d a suitably large positive number, we “move” the objects in front of the camera by moving the world frame relative to the camera frame. Chapter (4) 23

Modeling a Colored Cube • Modeling • Converting to the camera frame • Clipping • Projecting • Removing hidden surface • Rasterizing GLfloat vertices[8][3] = {{-1. 0, -1. 0}, {1. 0, -1. 0}, {-1. 0, 1. 0}, {1. 0, 1. 0}, {-1. 0, 1. 0}}; If we use a more object-oriented approach: typedef GLfloat point 3[3]; point 3 vertices[8] = {{-1. 0, -1. 0}, {1. 0, -1. 0}, {-1. 0, 1. 0}, {1. 0, 1. 0}, {-1. 0, 1. 0}}; Open. GL implements all vertices in 4 -D homogeneous coordinates. Function calls such gl. Vertex 3 fv, have the values placed into 4 dimensional form within the graphics system. Chapter (4) 24

Modeling a Colored Cube – cont. We can use the list of points to define the faces of the cube. One of the faces is: gl. Begin(GL_POLYGON); gl. Color 3 fv(vertices[0]); gl. Normal 3 fv(vertices[3]); gl. Vertex 3 fv (vertices[2]); gl. Color 3 fv (vertices[1]); gl. End(); Note that the face is outward when the vertices are Inward-and Outward-Pointing Faces are met in a counterclockwise order. Chapter (4) 25

Modeling a Colored Cube – cont. We can use the vertex list to define a color cube: typdef GLfloat point 3[3]; point 3 vertices[8] = {{-1. 0, -1. 0}, {1. 0, -1. 0}, {-1. 0, 1. 0}, {1. 0, 1. 0}, {-1. 0, 1. 0}}; GLfloat colors[8][3] = {{0. 0, 0. 0}, {1. 0, 0. 0}, {0. 0, 1. 0}, {1. 0, 1. 0}, {0. 0, 1. 0}}; void quad(int a, int b, int c, int d) { gl. Begin(GL_QUADS); gl. Color 3 fv(colors[a]); gl. Vertex 3 fv(vertices[a]); gl. Colors 3 fv(colors[b]); gl. Vertex 3 fv(vertices[b]); gl. Color 3 fv(colors[c]); gl. Vertex 3 fv(vertices[c]); gl. Colors 3 fv(colors[d]); gl. Vertex 3 fv(vertices[d]); gl. End(); Chapter (4) } void colorcube() { quad(0, 3, 2, 1); quad(2, 3, 7, 6); quad(0, 4, 7, 3); quad(1, 2, 6, 5); quad(4, 5, 6, 7); quad(0, 1, 5, 4); } 26

Bilinear Interpolation We can define the color of each vertex in the cube, but how do we color the faces, i. e. , color the points inside the polygon. Let’s start with a simple example to understand the interpolation. Suppose the value of y at x=100 is 600 and its value at x = 500 is 100. How can we find y at x = 150 and x = 200 and x = 250 using the given data at x = 100 and x = 500. The process can be formulated as: 600 100 200 500 Can you expand this definition to a more Complicated case like the one given in this Figure? Chapter (4) 27

Example Suppose the following two vertices are given with two distinct colors. What is the color of the vertices at Blue (0, 0, 1) Midway between the two vertices? Red (1, 0, 0) Quarter distance from the red vertex? Quarter distance from the blue vertex? Chapter (4) 28

Example Suppose the following three vertices are on an isosceles triangle. What is the color at the center of the triangle? Blue (0, 0, 1) Red (1, 0, 0) Chapter (4) 29

Scan-line Interpolation – cont. This method works fine for a flat quadrilateral. Each color generated by this method corresponds to a point on the polygon. If the four vertices are not in the same plane, then, although a color is generated, its location on a surface is not clearly defined. A new method can be used for this purpose. In this case, a polygon is filled only when it is displayed. If we wait until rasterization, the polygon is first projected onto the 2 -D plane. We can use this to fill a quadrilateral scan line by scan line. Then colors are assigned scan line by scan line on the basis of only two edges. Open. GL provides this method for colors as well as for other values. Projection of a plane Scan-line interpolation Chapter (4) 30

Vertex Arrays We used vertex lists to model the cube. When we draw the cube this way, we are making many calls to Open. GL functions. If we assign a color to each vertex, we make 50 Open. GL calls: 6 faces (each with gl. Begin and gl. End), 4 to gl. Color, and 4 to gl. Vertex arrays provide a method for encapsulating the information in our data structure such that we can draw polydehral objects with only a few function calls. There are three steps in using vertex arrays: 1) we enable the functionality of vertex arrays, 2) we tell Open. GL, where and in what format the arrays are, and 3) we render the object. Open. GL allows 6 different types of arrays (vertex, color index, normal, texture coordinate, and edge flag). The items can be place in between the gl. Begin and gl. End. For the rotating cube, we need only colors and vertices. We enable these two by: gl. Enable. Client. State(GL_COLOR_ARRAY); gl. Enable. Client. State(GL_VERTEX_ARRAY); Chapter (4) 31

Vertex Arrays – cont. The arrays are the same as before: GLfloat vertices[] = {{-1. 0, -1. 0}, {1. 0, -1. 0}, {-1. 0, 1. 0}, {1. 0, 1. 0}, {-1. 0, 1. 0}}; GLfloat colors[] = {{0. 0, 0. 0}, {1. 0, 0. 0}, {0. 0, 1. 0}, {1. 0, 1. 0}, {0. 0, 1. 0}}; We next identify where the arrays are: gl. Vertex. Pointer(3, GL_FLOAT, 0, vertices); //The first three are: 3 -D colors and vertices gl. Color. Pointer(3, GL_FLOAT, 0, colors); //stored as floats and elements are contiguous // in the arrays. The fourth argument is a pointer to the actual array. What is the relationship between the vertices and the faces of the cube? GLubyte cube. Indices[24] = [0, 3, 2, 1, 2, 3, 7, 6, 0, 4, 7, 3, 1, 2 , 6, 5, 4, 5, 6, 7, 0, 1, 5, 4}; The next thing is to render the cube. Chapter (4) 32

Vertex Arrays – cont. We have few options regarding how to draw the arrays: gl. Draw. Elements(type, n, format, pointer); Here type is the type of elements, such as line or polygon, that the arrays define. n is the number of elements that we wish to draw, format describes the form of the data in the index array, and pointer points to the first index to use. For our cube we can make six calls: for(I = 0; I < 6; I++) gl. Draw. Elements(GL_POLYGON, 4, GL_UNSIGNED_BYTE, &cube. Indices[4*I]); Thus, once we set up and initialized the arrays, to draw the cube, we have only 6 function calls. Even better, we can draw with one call: gl. Draw. Elements(GL_QUADS, 24, GL_UNSIGNED_BYTE, cube. Indices); Chapter (4) 33

Affine Transformations A transformation is a function that takes a point (or vector) and maps that point (or vector) into another point (or vector). For a point: Q = T(P) and for a vector: v = R(u) In a homogeneous coordinate, we can represent both vectors and points as fourdimensional column matrices and can define the transformation with a single function: q = f(p) and v = f(u). This transforms the representations of both points and vectors in a given frame. Problems: This formulation is very general to be useful In an affine space, any vector is represented as: Any point, p, can be written as: If we apply an arbitrary A to a vector, v = Au, only 9 of the elements of A affect u (9 degrees of freedom in the transformation matrix). On the other hand, the affine transformation of points have the full 12 degrees of freedom. For a line , where P 0 is a point and d is a vector. In any frame, the line can be expressed as: , where p 0 and d are the representations of P 0 and d in the frame. How about transformation of the line by a transformation matrix A? Chapter (4) 34

Rotation, Translation, and Scaling Translation is an operation that displaces points by fixed distance in a given direction. To specify a transformation, we need only to specify a displacement vector d, because the transformed points are given by P’ = P + d. Translation has 3 degrees of freedom, why? Chapter (4) 35

Rotation, Translation, and Scaling Rotation is more difficult to specify than translation, because more parameters are involved. Simple example: Rotate a point (x, y) about its origin by u. x = r cos(f), y = r sin(f) (x’, y’) x’ = r cos(u + f) y’ = r sin(u + f) cos(u + f) = cos(u) cos(f) - sin(u) sin(f) AND sin(u+f) = sin(u) cos(f) + cos(u) sin(f) x’ = r cos(f) cos(u) – r sin(f) sin(u) = x cos(u) – y sin(u) y’ = r cos(f) sin (u) + r sin(f) cos(u) = x sin(u) + y cos(u) In matrix form: Note three things: 1) rotation is around a fixed point, 2) A positive rotation in x-y plane is the rotation counterclockwise around z. 3) 2 -D rotation is 3 -D rotation around z. Chapter (4) 36

Rotation, Translation, and Scaling A general 3 -D rotation that is independent of the frame can be formalized when the following three entities are defined: 1) A fixed point (Pf) 2) A rotation angle 3) A line or vector about which to rotate. The 3 degrees of freedom are: The two angles necessary to specify the orientation of vector and the angle that specifies the amount of rotation about the vector. Note: no combination of rotation and translation can alter the shape of the object. They can alter the object location and orientation. Chapter (4) 37

Rotation, Translation, and Scaling is an affine non-rigid body transformation. We can combine a properly chosen sequence of scalings, translations, and rotations to form any affine transformation. Chapter (4) 38

Translation in Homogeneous Coordinates Within a frame, each affine transformation is represented by a 4 x 4 matrix of the form: A point p will be moved to point p’ by a displacement distance d: p’ = p + d. The translation matrix is defined as T (dx , dy, , dz): The inverse of a translation matrix is obtained by applying an inversion algorithm or by noting that, if we displace a vector by d we can return it to its original position by Displacing it by –d: T-1(dx, dy, dz)= T(-dx , -dy, , -dz) Chapter (4) 39

Scaling in Homogeneous Coordinates For both scaling and rotation, there is a fixed point that is unchanged by the transformation. These three can be combined as: p’ = Sp The inverse of scaling matrix is: Chapter (4) 40

Rotation in Homogeneous Coordinates We can have rotation around three axes, As an example rotation around z axis is: This can be written I matrix form as: P’ = Rzp where Rz is defined as: Rotation around z axis: Rotation around x axis: The rotation can be reversed for all of them using the following procedure: Chapter (4) 41

Shear in Homogeneous Coordinates We can construct any affine transformation from a sequence of rotations, translations, and scalings. Since shear is very important, we rather define it directly. Shear in x direction (x’, y’) The inverse can be computed as: Chapter (4) 42

Open. GL Transformation Matrices In Open. GL, there are three matrices that are part of the state. We will use the model-view matrix in this chapter. All three types are manipulated by a common set of functions, and we use the gl. Matrix. Mode function to select the matrix to which the operations apply. The generalization common to most graphics systems is the current transformation matrix (CTM). Suppose C denotes the CTM. C I (initialize C to unit matrix) The functions that alter C are of two forms: 1) Those that reset it to some matrix 2) Those that modify it by pre-multiplication or post-multiplication by a matrix. Three transformation are supported by most systems: translation, scaling with a fix point at the origin, and rotation with a fixed point of the origin. These can be written as: C CT C CS C CR With an arbitrary matrix, M, this can be written as: C CM. Chapter (4) 43

Rotation, Translation, and Scaling in Open. GL The Open. GL functions for these transformations are (e. g. ) void gl. Rotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) angle : Specifies the angle of rotation, in degrees. x, y, z : Specify the x, y, and z coordinates of a vector, respectively. gl. Rotate computes a matrix that performs a counterclockwise rotation of angle degrees about the vector from the origin through the point (x, y, z). Example: to rotate 30 degrees around the y-axis we could call gl. Rotatef(30, 0, 1, 0); void gl. Scalef(GLfloat x, GLfloat y, GLfloat z) x, y, z: Specify scale factors along the x, y, and z axes, respectively. gl. Scale produces a general scaling along the x, y, and z axes. The three arguments indicate the desired scale factors along each of the three axes. Chapter (4) 44

Rotation, Translation, and Scaling in Open. GL void gl. Translatef(GLfloat x, GLfloat y, GLfloat z) x, y, z : Specify the x, y, and z coordinates of a translation vector. gl. Translate moves the coordinate system origin to the point specified by (x, y, z). Example (A simple cube): typedef GLfloat point 3[3]; point 3 p[8]={ {0, 0, 0}, //black {0, 0, 1}, //blue {1, 0, 1}, //magenta {1, 0, 0}, //red {0, 1, 0}, //green {0, 1, 1}, //green+blue {1, 1, 1}, //white {1, 1, 0} //yellow }; Chapter (4) 45

void draw. Point(int i){ gl. Vertex 3 fv(p[i]); } void draw. Face(int i 1, int i 2, int i 3, int i 4){ gl. Begin(GL_POLYGON); gl. Color 3 fv(p[i 1]); draw. Point(i 1); draw. Point(i 2); draw. Point(i 3); draw. Point(i 4); gl. End(); } Our display function will include the code: draw. Face(0, 3, 2, 1); //bottom = black, draw. Face(1, 2, 6, 5); //front = blue draw. Face(2, 3, 7, 6); //right side = magenta draw. Face(3, 0, 4, 7); //back side = red draw. Face(4, 5, 6, 7); //top = white draw. Face(5, 4, 0, 1); //left side = yellow Chapter (4) 46

The complete program for the simple cube #include <stdlib. h>#include <GL/glut. h> void draw. Point(int i){ gl. Vertex 3 fv(p[i]); static GLint axis = 2; } const pi = 3. 14159; static GLfloat theta= pi * 90/180; void draw. Face(int i 1, int i 2, int i 3, int i 4){ typedef GLfloat point 3[3]; point 3 p[8]={ {0, 0, 0}, //black {0, 0, 1}, //blue {1, 0, 1}, //magenta {1, 0, 0}, //red {0, 1, 0}, //green {0, 1, 1}, //green+blue {1, 1, 1}, //white {1, 1, 0} //yellow }; gl. Begin(GL_POLYGON); gl. Color 3 fv(p[i 1]); draw. Point(i 1); draw. Point(i 2); draw. Point(i 3); draw. Point(i 4); gl. End(); } Chapter (4) 47

The complete program for the simple cube – cont. void display(void) {/* display callback, clear frame buffer and z buffer, rotate cube, draw, swap buffers*/ gl. Clear(GL_COLOR_BUFFER_BIT); gl. Load. Identity(); draw. Face(0, 3, 2, 1); //bottom = black, draw. Face(1, 2, 6, 5); //front = blue draw. Face(2, 3, 7, 6); //right side = magenta draw. Face(3, 0, 4, 7); //back side = red draw. Face(4, 5, 6, 7); //top = white draw. Face(5, 4, 0, 1); //left side = yellow gl. Flush(); } Chapter (4) 48

The main function for the simple cube void main(int argc, char **argv) { glut. Init(&argc, argv); glut. Init. Display. Mode (GLUT_SINGLE | GLUT_RGB); /* default, not needed */ glut. Init. Window. Size(500, 500); glut. Create. Window("colorcube"); glut. Display. Func(display); glut. Main. Loop(); } Chapter (4) 49

The Cube example with spinning and more … #include <stdlib. h> #include <GL/glut. h> GLfloat vertices[][3] = {{-1. 0, -1. 0}, {1. 0, -1. 0}, {-1. 0, 1. 0}, {1. 0, 1. 0}, {-1. 0, 1. 0}}; GLfloat normals[][3] = {{-1. 0, -1. 0}, {1. 0, -1. 0}, {-1. 0, 1. 0}, {1. 0, 1. 0}, {-1. 0, 1. 0}}; GLfloat colors[][3] = {{0. 0, 0. 0}, {1. 0, 0. 0}, {0. 0, 1. 0}, {1. 0, 1. 0}, {0. 0, 1. 0}}; Chapter (4) 50

The Cube example with spinning and more – cont. void polygon(int a, int b, int c , int d){/* draw a polygon via list of vertices */ gl. Begin(GL_POLYGON); gl. Color 3 fv(colors[a]); gl. Normal 3 fv(normals[a]); gl. Vertex 3 fv(vertices[a]); gl. Color 3 fv(colors[b]); gl. Normal 3 fv(normals[b]); gl. Vertex 3 fv(vertices[b]); gl. Color 3 fv(colors[c]); gl. Normal 3 fv(normals[c]); gl. Vertex 3 fv(vertices[c]); gl. Color 3 fv(colors[d]); gl. Normal 3 fv(normals[d]); gl. Vertex 3 fv(vertices[d]); gl. End(); Chapter (4) 51

The Cube example with spinning and more – cont. void colorcube(void) {/* map vertices to faces */ polygon(0, 3, 2, 1); polygon(2, 3, 7, 6); polygon(0, 4, 7, 3); polygon(1, 2, 6, 5); polygon(4, 5, 6, 7); polygon(0, 1, 5, 4); } static GLfloat theta[] = {0. 0, 0. 0}; static GLint axis = 2; void display(void) {/* display callback, clear frame buffer and z buffer, rotate cube and draw, swap buffers */ gl. Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); gl. Load. Identity(); gl. Rotatef(theta[0], 1. 0, 0. 0); gl. Rotatef(theta[1], 0. 0, 1. 0, 0. 0); gl. Rotatef(theta[2], 0. 0, 1. 0); colorcube(); gl. Flush(); Chapter (4) 52 glut. Swap. Buffers(); }

The Cube example with spinning and more – cont. void spin. Cube() //Idle callback, spin cube 2 degrees {// about selected axis theta[axis] += 2. 0; if( theta[axis] > 360. 0 ) theta[axis] -= 360. 0; /* display(); */ glut. Post. Redisplay(); } void mouse(int btn, int state, int x, int y) { /* mouse callback, selects an axis about which to rotate */ if(btn==GLUT_LEFT_BUTTON && state == GLUT_DOWN) axis = 0; if(btn==GLUT_MIDDLE_BUTTON && state == GLUT_DOWN) axis = 1; if(btn==GLUT_RIGHT_BUTTON && state == GLUT_DOWN) axis = 2; } void mykey(unsigned char key, int xx, int yy) { if(key == 'q' || key == 'Q') exit(1); } Chapter (4) 53

The Cube example with spinning and more – cont. void my. Reshape(int w, int h) { gl. Viewport(0, 0, w, h); gl. Matrix. Mode(GL_PROJECTION); gl. Load. Identity(); if (w <= h) gl. Ortho(-2. 0, -2. 0 * (GLfloat) h / (GLfloat) w, -10. 0, 10. 0); else gl. Ortho(-2. 0 * (GLfloat) w / (GLfloat) h, -2. 0, -10. 0, 10. 0); gl. Matrix. Mode(GL_MODELVIEW); } Chapter (4) 54

The main for the Cube example with spinning and more void main(int argc, char **argv) { glut. Init(&argc, argv); /* need both double buffering and z buffer */ glut. Init. Display. Mode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH); glut. Init. Window. Size(500, 500); glut. Create. Window("colorcube"); glut. Reshape. Func(my. Reshape); glut. Display. Func(display); glut. Idle. Func(spin. Cube); glut. Keyboard. Func(mykey); glut. Mouse. Func(mouse); gl. Enable(GL_DEPTH_TEST); /* Enable hidden--surface--removal */ glut. Main. Loop(); } Chapter (4) 55