OpenGL ES Bootcamp

As problem sets explode in complexity, radical gains in performance have resulted from moving traditional graphics processing from the CPU to GPU. If you are doing any work concerning graphics, then you must know OpenGL and this class is the fastest way to master the ideas and techniques of OpenGL programming.

By taking full advantage of hardware acceleration, shaders, blending, textures and video we'll help you get the most out of your data. Learn how OpenGL works, what functionality it does and does not provide, how to profile your code to reach peak performance and much more.

The course will provide libraries and frameworks for abstracting the operating system and allowing the student to focus solely on learning OpenGL. Concepts and exercises which are tangentially related to OpenGL and depend on interaction with the OS will be taught using Mac OS X technologies (such as multiple rendering contexts or multithreaded OpenGL applications).

What You'll Learn

  • Specify 3D geometry for OpenGL
  • Write vertex and fragment shaders for full control over 3D rendering
  • Understand how to use transformation matrices to position objects in a 3D scene
  • Create perspective and orthogonal views
  • Texture 3D objects with images
  • Control lighting in a 3D scene
  • Control the camera in both first- and third-person views
  • Add special effects like bump mapping and shadow mapping
  • Render point clouds and make animated particle systems
  • Select 3D objects in a rendered scene
  • Create higher level scene graphs powered by OpenGL rendering
  • Use OpenGL ES on iOS, Android and WebGL
  • Understand the differences between the fixed function and programmable pipelines
  • Understand performance bottlenecks by interpreting GPU profiling data
  • Overview of next-gen graphics APIs Vulkan and Metal
  • Syllabus

    Section

    Content

      • Hello, Triangle
      • Introduction to OpenGL going through everything needed to draw a triangle
      • Vertex Shaders
      • Introduction to vertex shaders; uniforms; translate, scale and rotation
      • Geometry
      • Points, lines, triangle strips
      • Hierarchical Modeling
      • Matrix stacks
      • Fragment Shaders
      • Introduction to Fragment shaders and textures
      • Projection Transforms
      • Introduction to orthogonal and perspective transforms
      • 3D Viewing I
      • Polarview style 3D viewing (elevation and azimuth); practice composing transforms
      • 3D Viewing II
      • Flight simulator style viewing transforms
      • Geometry II
      • Loading objects; common data formats
      • Surface Normals and Lighting
      • How to calculate surface normals and implement basic directional lighting
      • Lighting and Materials
      • How to specify material properties for effects like plastic and metal rendering
      • Image Textures
      • How to load image textures in OpenGL and apply them to 3D objects
      • Procedural Textures
      • How to create textures from mathematical functions
      • Noise
      • How to generate natural materials such as wood and marble from Perlin noise functions
      • Transformation Matrices
      • 2D transformation matrices for translate, rotate, scale; composing transformations
      • Cube Maps and Reflection Mapping
      • How to render immersive backgrounds using cube maps or skyboxes and reflect them on internal objects
      • Bump Maps
      • How to displace normals on 3D objects for bumpy effects
      • Cartoon Rendering
      • How to render something as if it were a cartoon
      • Point Rendering
      • Point clouds, point sprites, billboards and particle systems
      • Shadow Mapping
      • Using depth maps for creating real time shadows
      • Anti-Aliasing
      • Understand how and when to use hardware anti-aliasing to smooth rough edges.
      • Geometry Shaders
      • Tessellating objects using OpenGL geometry shaders
      • Scene Graphs
      • Building higher level data structures for 3D rendering and learning how popular 3D scene graphs work

Our Nerds, Your Place

No matter where you are, our instructors can come to you. Need to take your team to the next level?

Learn More

Requirements

For best results, students should have a good knowledge of C and a firm grasp of trigonometry and vector algebra. Familiarity with GPU architecture is helpful for understanding discussions of program performance.

How to prepare your device for our class

WHAT YOU'LL NEED

The most important thing is that your graphics card can run a relatively recent version of OpenGL. The class will be taught with OpenGL 3.2 for desktop, OpenGL ES 2.0 for mobile and WebGL 1.0 for browsers.

Bring a laptop you can develop desktop and mobile software on. If you have a choice between a Mac and PC, a Mac is preferred.

Having a provisioned iOS or Android device to run code on is great if possible. If you don't have a provisioned device, you will be able to complete the class but you will not be able to do live video processing. (We have provided an alternate lesson so you will have something else cool to do.)

Please make sure you can run code on your device before getting to class so you can spend your time learning about OpenGL instead of installing software.

Students using a Mac should have the following software:

  • Yosemite or Mavericks
  • Xcode


Students using a PC should have the following software:

  • Windows 8 or Windows 7
  • Visual Studio
  • Most recent graphics drivers for your video card


To run OpenGL ES on iOS, you will need:

  • Provisioned iOS device that supports OpenGL ES 2.0 or higher
  • Xcode


To run OpoenGL ES code on Android, you will need:

  • Android device that supports OpenGL ES 2.0 or higher
  • Eclipse or Android Studio

Command line development is also fine, though the lessons are tailored towards students using IDEs.


PRE-READING

Vectors and matrices are basic primitives in GLSL, the OpenGL shader language. Read through a few tutorials and make sure to understand the dot product and the cross product, which are the two ways we multiply vectors:

http://lazyfoo.net/articles/article10/index.php http://chortle.ccsu.edu/vectorlessons/vectorIndex.html#03

A basic understanding of how a GPU works from the programmer's point of view will explain a lot of the otherwise idiosyncratic countours of the OpenGL API. This article from the ACM is a basic overview, while Fabian Giesen's article goes into more details than we will cover in class.

Upcoming Classes

This class is not on our schedule at this time. Please fill out the form below and we'll be in touch.

We can also teach this course at your office through our Corporate Training program.