Print Version

Effective: Winter 2014

Advisory: Advisory: One of the following: C S 1B, 2B, 20A, 23A.
Grade Type: Letter Grade, the student may select Pass/No Pass
Not Repeatable.
FHGE: Non-GE Transferable: CSU
4 hours lecture, 3 hours laboratory. (84 hours total per quarter)

Student Learning Outcomes -
  • A successful student will be able to write code using a specific 3D API such as OpenGL that generates 3-D images and motion. Aspects of the API that will be mastered include setting up the configuration space, specifying the projection, camera positions and lighting parameters, and attaching material properties to the scene members.
  • A successful student will apply the mathematical tools of matrices, normal vectors and linear transformations to the design of graphics programs.
Description -
Introduction to 3-D graphics programming using OpenGL, intended for anyone interested in gaining 3-D expertise for games, scientific visualization, desktop and mobile apps. Coding topics include a systematic study of the OpenGL API in conjunction with any of these programming languages: Java, C++, C# or Objective C (student's choice). Concept topics include viewports, graphics primitives, 3-D motion matrices, normal vectors, shaders, fragment and pixel buffers, light simulation, polygons, virtual cameras, image pipelines, texture mapping and alpha blending.

Course Objectives -
The student will be able to:
  1. Install and access the OpenGL API in an integrated development environment (IDE).
  2. Create an OpenGL graphics context within an operating system's native user interface (UI).
  3. Describe distinct roles of the graphics initialization and drawing operations.
  4. Define the meaning of glBegin()/glEnd() and how they are used to define points, lines and polygons.
  5. Write programs that use normal vectors and orthographic projections to simulate naturally lit 3-D scenes.
  6. Use frame buffers to effect real-time 3-D animation.
  7. Incorporate vertex arrays into programs.
  8. Define buffer objects and give examples of their use.
  9. Explain the difference between viewing, modeling and motion transformations.
  10. Produce programs that use matrix stacks to control complex, hierarchical motion.
  11. Incorporate color and alpha blending into programs to generate transparency effects.
  12. Control scene lighting through camera position, material parameters, spotlights, and ambient parameters.
  13. Use OOP and class inheritance to design flexible objects, materials, lighting and animation structures.
  14. Write programs that incorporate texture mapping to simulate complex surfaces.
  15. Describe the OpenGL shading language and shaders.
  16. Download and install 3rd party font libraries for OpenGL.

Special Facilities and/or Equipment -
  1. access to a computer laboratory with language compilers, and OpenGL API plugins.
  2. a website or course management system with an assignment posting component (through which all lab assignments are to be submitted) and a forum component (where students can discuss course material and receive help from the instructor). This applies to all sections, including on-campus (i.e., face-to-face) offerings.
  3. When taught via Foothill Global Access on the Internet, the college will provide a fully functional and maintained course management system through which the instructor and students can interact.
  4. When taught via Foothill Global Access on the Internet, students must have currently existing e-mail accounts and ongoing access to computers with internet capabilities.

Course Content (Body of knowledge) -
  1. The OpenGL Development Platform
    1. OpenGL and C++
    2. OpenGL and C#
    3. OpenGL and Java
    4. OpenGL and Objective C
  2. OpenGL Windows
    1. The OpengGL graphics context
    2. Opening and closing graphics windows
    3. Threads and the graphics context
  3. The Rendering Lifecycle
    1. Initializing the pixel formats, clear colors and depth buffers
    2. Making the graphics context current
    3. Drawing preparation by loading identity matrices, positioning the camera and drawing simple polygons.
    4. Deleting the graphics context
  4. Graphics Primitives
    1. glBegin()/glEnd()
    2. Point and line commands
    3. Triangle commands
    4. Quad commands
    5. Polygon commands
  5. 3-D Scene Building
    1. glVertex()
    2. glNormal()
    3. Computing normal vectors
    4. Camera placement
    5. Orthographic vs. normal projections
    6. Local vs. non-local cameras
  6. Animation
    1. Defining framebuffers
    2. glSwapBuffers()
    3. making the graphics context current in buffer swapping
  7. Vertex Arrays
    1. VAOs (vertex array objects)
    2. Using buffers to store vertex data
    3. Speed considerations
  8. Frame Buffer Objects (FBOs)
    1. Creating and filling buffers
    2. Texture buffer objects
    3. Rendererbuffer objects
  9. Transformations
    1. Eye coordinates
    2. Projection transformations
    3. Viewport transformations
    4. The Modelview Matrix
    5. Rotation, Scaling and Translation
  10. Complex motion
    1. 4x4 Matrix stacks
    2. Pushing and popping matrices
    3. Data structures for hierarchical motion
    4. Designing class inheritance for
  11. Color
    1. RGBA color values
    2. Alpha blending
    3. glBlendFunc() and its parameters
    4. Enabling and disabling blending
  12. Lighting
    1. Camera Position
    2. Diffuse lighting
    3. Specular lighting
    4. Ambient lighting
    5. Spots
    6. Materials
  13. OOP in Graphics Programming
    1. Defining material and scene-object classes
    2. Defining classes for categories of scene objects
    3. Expressing hierarchy through object-members
    4. Expressing variations of scene objects through inheritance
  14. Texture Mapping
    1. Using GL_TEXTURE
    2. Loading Textures
    3. Enabling and disabling textures
    4. Interaction of textures and lighting models
  15. Shaders
    1. The graphics pipeline
    2. Vertex Shaders
    3. Graphics Shaders
    4. Stock shaders
    5. Geometry shaders
    6. Fragment shaders
    7. Uniform Buffer Objects
  16. Fonts
    1. 3rd Party Font Libraries
    2. Configuring and using Fonts

Methods of Evaluation -
  1. Tests and quizzes
  2. Written laboratory assignments which include source code, sample runs and documentation.
  3. Final examination

Representative Text(s) -
Richard Wright, Jr., et. al., OpenGL SuperBible, 5th Ed., Addison Wesley, 2011.
Dave Shreiner, OpenGL Programming Guide, 7th Ed., Addison Wesley, 2009.

Disciplines -
Computer Science
Method of Instruction -
  1. Lectures which include motivation for syntax and use of OpenGL API.
  2. On-line labs (for all sections, including those meeting face-to-face/on campus) consisting of
    1. A programming assignment web-page located on a college-hosted course management system or other department-approved Internet environment. Here, the students will review the specification of each programming assignment and submit their completed lab work.
    2. A discussion web-page located on a college hosted course management system or other department-approved Internet environment. Here, students can request assistance from the instructor and interact publically with other class members.
  3. Detailed review of programming assignments which includes model solutions and specific comments on the student submissions.
  4. In person or on-line discussion which engages students and instructor in an ongoing dialog pertaining to all aspects of designing, implementing and analyzing programs.
  5. When course is taught fully on-line:
    1. Instructor-authored lecture materials, handouts, syllabus, assignments, tests, and other relevant course material will be delivered through a college hosted course management system or other department-approved Internet environment.
    2. Additional instructional guidelines for this course are listed in the attached addendum of CS department on-line practices.

Lab Content -
  1. Configuring an OpenGL Development Platform
    1. Download the OpenGL libraries if they are not built-into your platform's IDE.
    2. Download any support GUI toolkits required for a GUI-based OpenLG program.
    3. Write and debug a a modular 2-D shape program that lives within your platform's native UI using a module init() and draw() paradigm.
  2. Exploring Graphics Primitives
    1. Write a program that demonstrates at least six of the graphics primitives managed by glBegin() and glEnd().
    2. Make the program interactive, using a simple menu with drop-downs, sliders, buttons, etc.
  3. Creating a Simple 3-D Scene
    1. Use the glVertex() and glNormal() to produce some simple objects (cube, polyhedron, etc.) that have fixed color or material-based surfaces.
    2. Experiment with camera position to get differing views.
    3. Use your platform's UI model to create an interactive program.
    4. Use glSwapbuffers() to make motion appear smooth and free of flicker artifacts.
  4. Using Vertex Arrays and Frame Buffer Objects
    1. Build object data using vertex arrays and/or FBOs
    2. Demonstrate the data structure by a program that allows the user to manipulate the objects within the scene
  5. Controlling Camera Position and Complex Object Motion
    1. Create classes that reflect hierarchical objects with multiple joints and appendages.
    2. Use the modelview stack to control the various parts of the object, independently, without losing the integrity of the object as a whole.
    3. Let the user control motion and also demonstrate various speeds.
    4. Separate camera and object motion in your program, so that the user can control each one, separately.
  6. Controlling Color and Lighting
    1. Use OOP to create material classes and assign materials to the players in your scene.
    2. Assign different characteristics to your scene's lights and ambient illumination.
    3. Let the user control the lighting characteristics while the objects are in motion.
  7. Incorporating Texture Mapping
    1. Load two or more textures into memory, and assign them to some of your objects.
    2. Display the scene with animation to view the textures at all angles as they are rotated.
    3. Incorporate transparency and alpha blending.
  8. Using Shaders in Your Program
    1. Define shaders in your program.
    2. Make use of at least two of the following: fragment shaders, vertex shaders, geometry shaders, or uniform buffer objects.
  9. Adding Fonts to your Display
    1. Download and install some 3rd party font utility for OpenGL.
    2. Create a scene which incorporates fonts.
    3. Let some fonts be 2-D labels for the window, and others be 3-D objects that are lit by the scene and move as the camera moves.

Types and/or Examples of Required Reading, Writing and Outside of Class Assignments -
  1. Reading
    1. Textbook assigned reading averaging 30 pages per week.
    2. Reading the supplied handouts and modules averaging 10 pages per week.
    3. Reading on-line resources as directed by instructor though links pertinent to programming.
    4. Reading library and reference material directed by instructor through course handouts.
  2. Writing
    1. Writing technical prose documentation that supports and describes the programs that are submitted for grades.