CISS 380 - Computer Graphics - Test 1 Study Guide

  1. Vector Display
    • CRT beam moved randomly over the screen to draw the lines.
    • Usually line drawing, no texture, no filled in areas.
    • Exact -- CRT beam can be positioned exactly where you want it on the screen (within the limits of the technology of the day).
    • Object-based -- each edge in each object in the picture is drawn.
    • The more complex the image, the longer it takes to draw.
    • If it takes over about 1/20 second, human eye begins to see "flicker".
    • May draw same point twice, so it will appear brighter.
    • The cube vertices are each shared by 3 edges.
  2. Raster Display
    • Approximation -- Points along a line can be specified to the nearest pixel.
    • Causes "jaggies" (aliasing problems).
    • Image based -- what's drawn is not based on the (3D) objects, but on the image in the framebuffer.
    • Lines, shaded areas, etc.
    • Store EVERY pixel in framebuffer.
    • This was made feasible by dropping memory prices in the early 1980s.
    • Draw every point once.
    • General-purpose.
    • Allows filled areas, not just line drawings.
    • Constant refresh rate (no flicker on complex images).
    • Inexpensive "TV-like" hardware.
  3. OpenGL Primative GL_POINTS
    Treats each vertex as a single point. Vertex n defines point n. N points are drawn.
  4. OpenGL Primative GL_LINES
    Treats each pair of vertices as an independent line segment. Vertices 2n - 1 and 2n define line n. N 2 lines are drawn.
  5. OpenGL Primative GL_LINE_STRIP
    Draws a connected group of line segments from the first vertex to the last. Vertices n and n + 1 define line n. N - 1 lines are drawn.
  6. OpenGL Primative GL_LINE_LOOP
    Draws a connected group of line segments from the first vertex to the last, then back to the first. Vertices n and n + 1 define line n. The last line, however, is defined by vertices N and 1 . N lines are drawn.
  7. OpenGL Primative GL_TRIANGLES
    Treats each triplet of vertices as an independent triangle. Vertices 3n - 2 , 3n - 1 , and 3n define triangle n. N 3 triangles are drawn.
  8. OpenGL Primative GL_TRIANGLE_STRIP
    Draws a connected group of triangles. One triangle is defined for each vertex presented after the first two vertices. For odd n, vertices n, n + 1 , and n + 2 define triangle n. For even n, vertices n + 1 , n, and n + 2 define triangle n. N - 2 triangles are drawn.
  9. OpenGL Primative GL_TRIANGLE_FAN
    Draws a connected group of triangles. One triangle is defined for each vertex presented after the first two vertices. Vertices 1 , n + 1 , and n + 2 define triangle n. N - 2 triangles are drawn.
  10. OpenGL Primative GL_QUADS
    Treats each group of four vertices as an independent quadrilateral. Vertices 4n - 3 , 4n - 2 , 4n - 1 , and 4n define quadrilateral n. N 4 quadrilaterals are drawn.
  11. OpenGL Primative GL_QUAD_STRIP
    Draws a connected group of quadrilaterals. One quadrilateral is defined for each pair of vertices presented after the first pair. Vertices 2n - 1 , 2n , 2n +2 , and 2n + 1 define quadrilateral n. N 2 - 1 quadrilaterals are drawn. Note that the order in which vertices are used to construct a quadrilateral from strip data is different from that used with independent data.
  12. OpenGL Primative GL_POLYGON
    Draws a single, convex polygon. Vertices 1 through N define this polygon.
  13. glutDisplayFunc
    Whenever the system determines that a screen window should be redrawn it issues a redraw event. This occurs when the window is first opened, and when the window is exposed by moving another window off of it.
  14. glutReshapeFunc
    Screen windows can be reshaped by the user, usually by dragging a corner of the window to a new position with the mouse. (Simply moving the window does not produce a reshape event.) The reshape function is automatically passed arguments that report the new width and height of the reshaped window.
  15. glutKeyboardFunc
    This registers the keyboard function with the event of pressing and releasing some key on the keyboard. The keyboard function is automatically passed arguments that tell which key was pressed. Conveniently, this function also makes available to the system the x- and y-coordinates (relative to the screen window) of the mouse at the time a key was pressed.
  16. glutIdleFunc
    When nothing is occuring this function is used to determine how much time has passed since the previous idle function call. Typically an action is performed after a given time has elapsed.
  17. glutMouseFunc
    When one of the mouse buttons is pressed and released, a mouse event is issued. The mouse function is registered as the callback function a mouse event occurs. The mouse function is automatically passed arguments that describe the mouse location and the nature of the button action.
  18. glutMotionFunc
    This function generates an event when the mouse is moved with one or more mouse buttons pressed. Notice that the mouse button need not be released for the event to be generated. The motion function is automatically passed arguments that describe the mouse location.
  19. glutPassiveMotionFunc
    This function generates an event when the mouse moves into the window with "no" buttons pressed. The passive motion function is automatically passed arguments that describe the mouse location.
  20. glColor
    • The GL stores both a current single-valued color index and a current four-valued RGBA color. glColor sets a new four-valued RGBA color. glColor has two major variants: glColor3 and glColor4. glColor3 variants specify new red, green, and blue values explicitly and set the current alpha value to 1.0 (full intensity) implicitly.glColor4 variants specify all four color components explicitly.
    • glColor3b, glColor4b, glColor3s, glColor4s, glColor3i, and glColor4i take three or four signed byte, short, or long integers as arguments. When v is appended to the name, the color commands can take a pointer to an array of such values.
    • Current color values are stored in floating-point format, with unspecified mantissa and exponent sizes. Unsigned integer color components, when specified, are linearly mapped to floating-point values such that the largest representable value maps to 1.0 (full intensity), and 0 maps to 0.0 (zero intensity). Signed integer color components, when specified, are linearly mapped to floating-point values such that the most positive representable value maps to 1.0, and the most negative representable value maps to -1.0 . (Note that this mapping does not convert 0 precisely to 0.0.) Floating-point values are mapped directly.
    • Neither floating-point nor signed integer values are clamped to the range 0 1 before the current color is updated. However, color components are clamped to this range before they are interpolated or written into a color buffer.
  21. glBegin and glEnd
    glBegin and delimit the vertices that define a primitive or a group of like primitives. glBegin accepts a single argument that specifies in which of ten ways (primatives) the vertices are interpreted. glEnd completes the drawing of the primative.
  22. glVertex
    • glVertex commands are used within glBegin/glEnd pairs to specify point, line, and polygon vertices. The current color, normal, texture coordinates, and fog coordinate are associated with the vertex when glVertex is called.
    • When only x and y are specified, z defaults to 0 and w defaults to 1. When x, y, and z are specified, w defaults to 1.
  23. glutSwapBuffers
    • Performs a buffer swap on the layer in use for the current window. Specifically, glutSwapBuffers promotes the contents of the back buffer of the layer in use of the current window to become the contents of the front buffer. The contents of the back buffer then become undefined. The update typically takes place during the vertical retrace of the monitor, rather than immediately after glutSwapBuffers is called.
    • An implicit glFlush is done by glutSwapBuffers before it returns. Subsequent OpenGL commands can be issued immediately after calling glutSwapBuffers, but are not executed until the buffer exchange is completed.
    • If the layer in use is not double buffered, glutSwapBuffers has no effect.
  24. glutPostRedisplay
    • Mark the normal plane of current window as needing to be redisplayed. The next iteration through glutMainLoop, the window's display callback will be called to redisplay the window's normal plane. Multiple calls to glutPostRedisplay before the next display callback opportunity generates only a single redisplay callback. glutPostRedisplay may be called within a window's display or overlay display callback to re-mark that window for redisplay.
    • Logically, normal plane damage notification for a window is treated as a glutPostRedisplay on the damaged window. Unlike damage reported by the window system,glutPostRedisplay will not set to true the normal plane's damaged status (returned by glutLayerGet(GLUT_NORMAL_DAMAGED).
  25. glutInit
    • Initializes the GLUT library and negotiates a session with the window system. During this process, glutInit may cause the termination of the GLUT program with an error message to the user if GLUT cannot be properly initialized. Examples of this situation include the failure to connect to the window system, the lack of window system support for OpenGL, and invalid command line options.
    • glutInit also processes command line options, but the specific options parse are window system dependent.
  26. glutInitDisplayMode
    • The initial display mode is used when creating top-level windows, subwindows, and overlays to determine the OpenGL display mode for the to-be-created window or overlay.
    • Note that GLUT_RGBA selects the RGBA color model, but it does not request any bits of alpha (sometimes called an alpha buffer or destination alpha) be allocated. To request alpha, specify GLUT_ALPHA. The same applies to GLUT_LUMINANCE.
  27. glutInitWindowSize and glutInitWindowPosition
    • Windows created by glutCreateWindow will be requested to be created with the current initial window position and size.
    • The initial value of the initial window position GLUT state is -1 and -1. If either the X or Y component to the initial window position is negative, the actual window position is left to the window system to determine. The initial value of the initial window size GLUT state is 300 by 300. The initial window size components must be greater than zero.
    • The intent of the initial window position and size values is to provide a suggestion to the window system for a window's initial size and position. The window system is not obligated to use this information. Therefore, GLUT programs should not assume the window was created at the specified size or position. A GLUT program should use the window's reshape callback to determine the true size of the window.
  28. glutCreateWindow
    • Creates a top-level window. The name will be provided to the window system as the window's name. The intent is that the window system will label the window with the name.
    • Implicitly, the current window is set to the newly created window.
    • Each created window has a unique associated OpenGL context. State changes to a window's associated OpenGL context can be done immediately after the window is created.
    • The display state of a window is initially for the window to be shown. But the window's display state is not actually acted upon until glutMainLoop is entered. This means untilglutMainLoop is called, rendering to a created window is ineffective because the window can not yet be displayed.
    • The value returned is a unique small integer identifier for the window. The range of allocated identifiers starts at one. This window identifier can be used when calling glutSetWindow.
  29. glOrtho(left, right, bottom, top, nearVal, farVal)
    • Describes a transformation that produces a parallel projection. 
    • Typically, the matrix mode is GL_PROJECTION, and left bottom - nearVal and right top - nearVal specify the points on the near clipping plane that are mapped to the lower left and upper right corners of the window, respectively, assuming that the eye is located at (0, 0, 0). - farVal specifies the location of the far clipping plane. Both nearVal and farVal can be either positive or negative.
  30. glViewport
    • Specifies the affine transformation of x and y from normalized device coordinates to window coordinates.
    • Viewport width and height are silently clamped to a range that depends on the implementation.
  31. glutCreateMenu
    • Creates a new pop-up menu and returns a unique small integer identifier. The range of allocated identifiers starts at one. The menu identifier range is separate from the window identifier range. Implicitly, the current menu is set to the newly created menu. This menu identifier can be used when calling glutSetMenu.
    • When the menu callback is called because a menu entry is selected for the menu, the current menu will be implicitly set to the menu with the selected entry before the callback is made.
  32. glutAddMenuEntry
    Adds a menu entry to the bottom of the current menu. The string name will be displayed for the newly added menu entry. If the menu entry is selected by the user, the menu's callback will be called passing value as the callback's parameter.
  33. glutAttachMenu and glutDetachMenu
    • glutAttachMenu attaches a mouse button for the current window to the identifier of the current menu.
    • glutDetachMenu detaches an attached mouse button from the current window.
    • By attaching a menu identifier to a button, the named menu will be popped up when the user presses the specified button.
    • button should be one of GLUT_LEFT_BUTTON, GLUT_MIDDLE_BUTTON, and GLUT_RIGHT_BUTTON.
    • Note that the menu is attached to the button by identifier, not by reference.
  34. glutAddSubMenu
    Adds a sub-menu trigger to the bottom of the current menu. The string name will be displayed for the newly added sub-menu trigger. If the sub-menu trigger is entered, the sub-menu numbered menu will be cascaded, allowing sub-menu menu items to be selected.
  35. Drawing Parametric Curves
    Recall from analytic geometry the PARAMETRIC equations for an ellipse:

    • x=W*cos(θ)
    • y=H*sin(θ)
    • θ (theta) is the angle, measured in radians, between the x-axis and any point (x,y) on the ellipse.

    Recall there are 2*π radians in a circle (2*π=6.2832).

    θ is the PARAMETER.

    To obtain many points around the ellipse we plug-in to the equations many values of θ between 0 and 2*π and calculate the (x,y) coordinates of successive points on the ellipse.

    If we set θ to various values between 0 and 2*π we can use the parametric equations to calculate the (x,y) coordinates of points on the ellipse.

    Our "display" function looks like this:

    • const float PI=3.14159;
    • const float W=5.;
    • const float H=3.;
    • float theta.; // angle between x axis and a point on ellipse
    • float dt=2*PI/36.; // how much to change theta for each line segment.
    • float x, y; // a point on ellipse.
    • glBegin(GL_LINE_LOOP);
    • for (theta=0.; theta<2.*PI; theta=theta+dt) { // loop thru 36 vertices
    • x=W*cos(theta); // calc x,y coordinates of this vertex
    • y=H*sin(theta);
    • glVertex3f(x,y,0.); // tell OpenGL this vertex
    • }
    • glEnd(); // cause OpenGL to draw the LINE_LOOP with 36 vertices

    By convention we like the PARAMETER to vary between 0. and 1. (instead of 0. and 2*π).

    We can easily "scale" the parameter so as to arrange this. In the above example we make the following changes:

    Change parametric equations to:

    • x=W*cos(θ*2π)
    • y=H*sin(θ*2π)

    Change the code loop to:

    • float dt=1./36.;
    • for (theta=0.; theta<1.; theta=theta+dt) {
    • x=W*cos(2*PI*theta);
    • y=H*sin(2*PI*theta);
    • glVertex3f(x,y,0.); // tell OpenGL this vertex
    • }
    • glEnd();
  36. Vector Addition
    Place vectors to be added "head to tail" one after the other. Sum is vector from head of 1st to tail of last.

    [x1,y1,z1] + [x2,y2,z2] = [x1+x2,y1+y2,z1+z2]

    Image Upload 1
  37. Vector Subtraction
    a-c is equivalent to adding a and (-1)c

    Image Upload 2
  38. Vector Multiplication
    s[x,y,z]=[sx,sy,sz]. Where 's' is a scalar. Produces a vector in the same direction, but 's' times as long. If 's' is negative, the resulting vector is in the opposite direction.
  39. Dot Product of 2 Vectors
    A scalar proportional to the cosine of the angle, α, between the 2 vectors, and their magnitudes:

    • V1=(x1,y1,z1)
    • V2=(x2,y2,z2)
    • V1.V2 = x1x2 + y1y2 + z1z2 = |V1||V2|cos(α)
    • where α is the angle between the 2 vectors.

    Image Upload 3
  40. Cross Product of 2 3D Vectors
    A vector that is orthogonal (perpendicular) to both vectors.

    V1xV2 = [-z1y2+y1z2, z1x2-x1z2, -y1x2+x1y2]

    Right hand rule.

    Image Upload 4
  41. Normal to a Plane
    A vector perpendicular to the plane. The normal vector is the cross product of any 2 vectors lying on the plane. 

    EXAMPLE: If P1,P2 and P3 are non-collinear points in a plane, the normal vector, n, is:

    • let vector a = P2 - P1
    • let vector b = P3 - P1
    • let vector n = a x b

    -n is the normal on the other side of the plane.

    Image Upload 5
Card Set
CISS 380 - Computer Graphics - Test 1 Study Guide
CISS 380 - Computer Graphics - Test 1 Study Guide