This lab is an introduction to Fundamental OpenGL Functions

• Overview of Device Contexts (DC), Rendering Contexts (RC) and Pixel Formats
• Basic OpenGL rendering primitives

    After the lab lecture, you have approximately two weeks of time to:

• Add some objects into Lab1 program
• Print out and hand in two documents:
• "COpenGLView.h"
• "COpenGLView.cpp"
• Demo schedule: TBA.
Online OpenGL Manual


---


A. What is OpenGL?
• OpenGL is an operating system and hardware platform independent graphics library designed to be easily portable yet rapidly executable.


B. Why is OpenGL used?

• OpenGL is originally developed by SGI for its its workstations running under X-Windows. It is rapidly becoming the industrial standard for high-quality 3D graphics applications.
• It is available on a variety of hardware platforms and operating systems, including X-Windows, Microsoft's Windows 95, 98, 2000, and NT.

C. What are the basic steps to use OpenGL in a Windows Program?

• Getting a Device Context (DC) for the rendering location
• Selecting and setting a pixel format for the Device Context
• Creating a Rendering Context (RC) associated with the Device Context
• Drawing using OpenGL commands
• Releasing the rendering context
• Release the device context

D. What is a DC?
• A DC is simply a data structure that keeps the state of the current settings and route calls to the appropriate device.

E. What is an RC?
• An RC is also a data structure that keeps the state variables for OpenGL. It is also a portal through which OpenGL calls are rendered to the device.
• You can think of both DC and RC as a data structure that keeps the state of the current settings and routes calls to the proper device.


F. Brief Introduction to Pixel Format Data Structure

• Pixel formats are the translation between OpenGL calls (such as an OpenGL call to draw a pixel with an RGB triad value of [128,120,135] and the rendering operation that Windows performs (the pixel might be drawn with a translated RGB value of [128,128,128]). The selected pixel format describes such things as how colors are displayed, the depth of field resolution, and what additional capabilities are supported by the rendering context you have created. The Windows OpenGL has four functions that handle the pixel format.

  ---

   
   Pixel Format Function       Description 
  ------------------------------------------------------------------
  ChoosePixelFormat()      Obtains a DC's pixel format that's the
                           closet match to a pixel format you've
  	    	         provided.
  
  SetPixelFormat()         Sets a DC's current pixel format to the
      	                 pixel format index specified.
  
  GetPixelFormat()         Returns the pixel format index of a DC's
      	                 current pixel format.
  
  DescribePixelFormat()    Given a DC and a pixel format index, fills
  			 a PIXELFORMATDESCRIPTOR data structure with
  			 the pixel format's properties.
  
  

  ---

  The main properties of pixel format include:

  • Single or double buffering: Mainly for smooth animation.
  • RGBA or color indexing: A color can be directly specified by Red, Green, and Blue values. Some video display controllers have limited frame buffer memory. For example, EGA supports 16 colors. Therefore, only 4 bits is used to represent a pixel. This pixel value is used as the index into a color map to find the associated RGB values for display.
  • Drawing to a window or bitmap: When drawing is sent to window, it will be displayed in real-time on the screen. A bitmap is a canvas in the main memory. The content in a bitmap may be displayed later by being copied into a window.
  • Support of GDI (Window's Graphics Device Interface) or OpenGL calls.
  • Color depth: The number of bits per pixel in the frame buffer.
  • Z-axis depth: The number of bits per pixel in Z-buffer that is used for hidden surface removal.

  The following structure can be found in the Windows include file WINGDI.H

  typedef struct tagPIXELFORMATDISCRIPTOR
  {
     WORD    nsize;
     WORD    nVersion;
     BYTE    dwFlags;
     BYTE    iPixelType;
     BYTE    cColoerBits;
     BYTE    cRedBits;
     BYTE    cRedShift;
     BYTE    cGreenBits;
     BYTE    cGreenShift;
     BYTE    cBlueBits;
     BYTE    cBlueShift;
     BYTE    cAlphaBits;
     BYTE    cAlphaShift;
     BYTE    cAccumBits;
     BYTE    cAccumRedBits;
     BYTE    cAccumBlueBits;
     BYTE    cAccumAlphaBits;
     BYTE    cDepthBits;
     BYTE    cStencilBits;
     BYTE    cAuxBuffers;
     BYTE    iLayerType;
     BYTE    bReserved;
     DWORD   dwLayerMask;
     DWORD   dwVisisbleMask;
     DWORD   dwDamageMask;
  } PIXELFORMATDISCRIPTOR,
  *PPIXELFORMATDISCRIPTOR,
  FAR *LPPIXELFORMATDISCRIPTOR;
  

• You may refer to Chapter 2 of the reference book by Fosner for detailed description, and view lab 1's function BOOL COpenGLView::SetupPixelFormat( ) in the file OpenGLView.cpp.

G. Basic rendering primitives
• OpenGL points

     glBegin(GL_POINTS)
         glVertex2f(0.0f, 2.0f); //note 2D form	
         glVertex2f(1.0f, 2.0f);
         glVertex2f(0.0f, -2.0f);
         glVertex2f(-1.0f, 0.0f);
     glEnd();
  
     There are also other types of points. 3D vertex can be
     similarly drawn. They are listed below:
  
  	glVertex2d,  glVertex2f,  glVertex2i,  glVertex2s,
          glVertex3d,  glVertex3f,  glVertex3i,  glVertex3s,
          glVertex4d,  glVertex4f,  glVertex4i,  glVertex4s,
          glVertex2dv, glVertex2fv, glVertex2iv, glVertex2sv,
          glVertex3dv, glVertex3fv, glVertex3iv, glVertex3sv,
          glVertex4dv, glVertex4fv, glVertex4iv, glVertex4sv
  
     The postfix specifies the format of parameters used by each function:
  
     - 2 means a 2D point x, y.
     - 3 means a 3D point x, y, and z.
     - 4 means a 3D point in homogeneous coordinates x, y, z, and w.
       [The homoheneous coordinates will be discussed in the lecture on Chapter 5.]
  
     - d means double type.
     - f means float type.
     - i means integer type.
     - s means short type.
     - v means vector type.
  
     Example: using vector type parameter.
  
  	double P1[2], P2[2], P[3];
  
  	/* set values to P1, P2, P3. */
  	P1[0] = 1.5;	P1[1] = -0.3;
  	......
  
  	glBegin(GL_POINTS)
  	    glVertex2dv(P1);
  	    glVertex2dv(P2);
  	    glVertex2dv(&P3[0]);	/* This is equivalent. */
  	glEND();
  
     Refer to online manual for details.
  

• OpenGL lines

  Three different line primitives can be created:

  • GL_LINES

       draws a line segment for each pair of vertices.
  

  • GL_LINES_STRIP

       draws a connected group of line segments from vertex v0
       to vn connecting a line between each vertex and the
       next in the order given.
  

  • GL_LINES_LOOPS

       similar to GL_LINES_STRIP, except it closes the line from
       vn to v0, defining a loop.
  
       glBegin(GL_LINES_LOOPS)  //make it a connected close line segment
           glVertex2f(0.0f, 2.0f); //note 2D form
           glVertex2f(1.0f, 2.0f);
           glVertex2f(0.0f, -2.0f);
           glVertex2f(-1.0f, 0.0f);
       glEnd();
       
  


• OpenGL polygons

  1. Front faces, back faces and rendering modes

  • glCullFace( ) -- specify whether front- or back-facing facets can be culled
  • glFrontFace( ) -- define front- and back-facing polygons
  • glPolygonMode( ) -- select a polygon rasterization mode

  2. Polygon Types

  • GL_POLYGON -- draws a polygon from vertex v0 to vn-1
  • GL_QUADS -- draws a series of separate four-sided polygons
  • GL_TRIANGLES -- draws a series of separate three-sided polygons
  • GL_QUAD_STRIP -- draws a strip of connected quadrilaterals
  • GL_TRIANGLES_STRIP -- draws a strip of connected triangles
  • GL_TRIANGLES_FAN -- draws a strip of triangles connected about a common origin

      You may refer to Page 59 of the reference book
      to view the ten OpenGL primitive types
  

      The following code constructs a filled in parallelogram on the x-y plane:

     glBegin(GL_POLYGON)
         glVertex2f(0.0f, 2.0f); //note 2D form
         glVertex2f(1.0f, 2.0f);
         glVertex2f(0.0f, -2.0f);
         glVertex2f(-1.0f, 0.0f);
     glEnd();
  

      There are also other types of points. 3D vertex can be similarly drawn.

      Refer to online manual.

      The following draws a rectangle:

     glRectf(0f, 0f, 1f, 1f);	// x0, y0, x1, y1: two opposite corners
  				// of the rectangle.
  

      it is the same as:

     glBegin(GL_QUADS);
         glVertex2f(0.0f, 0.0f); //note 2D form
         glVertex2f(1.0f, 0.0f);
         glVertex2f(1.0f, 1.0f);
         glVertex2f(0.0f, 1.0f);
     glEnd();
  
  

  3. Specifying a color

     glcolor*( ). For example, glcolor3f() function takes three
     floating-point values for the red, green and blue color to
     select. A value of 0 means zero intensity; a value of 1.0
     is full intensity, and any value in between is a partial
     intensity.
  

  4. Calculating normal vectors

     // pass in three points, and a vector to be filled
     void NormalVector(GLdouble p1[3], GLdouble p2[3],
  		     GLdouble p3[3], GLdouble n[3])
     {
       GLdouble v1[3], v2[3], d;
       // calculate two vectors, using the middle point
       // as the common origin
       v1[0] = p2[0] - p1[0];
       v1[1] = p2[1] - p1[1];
       v1[2] = p2[2] - p1[2];
       v2[0] = p2[0] - p3[0];
       v2[1] = p2[1] - p3[1];
       v2[2] = p2[2] - p3[2];
  
       // calculate the cross-product of the two vectors
       n[0] = v1[1]*v2[2] - v2[1]*v1[2];
       n[1] = v1[2]*v2[0] - v2[2]*v1[0];
       n[2] = v1[0]*v2[1] - v2[0]*v1[1];
  
       // normalize the vector
       d = sqrt(n[0]*n[0] + n[1]*n[1] + n[2]n[2]);
       n[0] /= d;
       n[1] /= d;
       n[2] /= d;
     } // end of NormalVector
  
  

  5. Clearing the rendering window

     glClearColor(0.0f, 0.0f, 0.0f);
     glClearDepth(1.0f);
  
     // once the clear color and clear depth values have been
     // set, both buffers can be cleared, the following command
     // is usually issued just before you begin to render a
     // scene, usually as the first rendering step to a
     // WM_PAINT message
     // clear both buffers in the mean time
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  
  


H. Assignment

• This assignment is based on lab 1 assignment, and the main purpose is to render some primitives.
  • draw inscribed circles on the checkboard plane: for each black square, draw a inscribed circle filled with a specified color: RGB[50, 100, 200]; for white square, draw a inscribed circle filled with a specified color: RGB[100, 50, 100];
  • replace the wire sphere with a red solid sphere, their size and position are the same;
  • draw a local coordinate frame composed of 3 axes: x, y, z, the coordinate of the the three axes' intersection point is (1,2,3), and each axis's length is 3; x points to the left, y points to the top, z points to the front. You can specify the axis color yourself;

    	        |y
               	|
    	   	|
    	   	|
               	|
    	x_______|
    	       /
    	      /
    	     /
    	    /
    	   z
    
    

  • draw a enclosed and solid cylinder on the plane, the bottom base's center point's coordinate is (-2.5, -2.5, 0), the height of the cylinder is 3, and the radius is 1. The color is (100, 100, 100). Note: the top base, bottom base and side part of the cylinder should all be drawn;
  • hint: you may refer to the following functions:

    
      glPushMatrix( ), glPopMatrix, gluQuadricDrawstyle( ),
      glTranslated( ), glRotated( ), gluDisk( ), gluCylinder( ),
      gluDisk( ), auxSolidSphere( )