Introduction to OpenGL

COS 350 - Computer Graphics

Overview

• Industry standard 3D API
• Device independent — Graphics card drivers
  • Originally all software
• No direct window control
• OS Independent
• OpenGL ARB
• Originated with Silicon Graphics

Overview

• Texture mapping
• Z-buffering
• Double buffering
• Smooth shading — Gourard only
• Material properties
• Transformations, Projections

Extras, Add-on Libraries

• GLU
• GLAux
• GLUT
• GLUI

Traditional OpenGL

• Fixed pipeline
  • version 2.0 introduced GLSL
• OpenGL ES (embedded systems)
  • 1.1 — Stripped down OpenGL — fixed pipeline
  • 2.0 — No default pipeline

Traditional OpenGL

• State variables
  • traditional OpenGL is very state-driven
  • set state
  • send vertices to system — default pipeline
  • There are many ways to send vertices to pipeline

Traditional OpenGL

State

• Color
• Texture
• Transformation
  • translation
  • rotation
  • scale

State Machine

To create an image

• set variables in state machine
• send geometry to state machine

Default values makes starting easy

• inefficient on modern graphics hardware

Programmable Pipeline

Much more flexibility

New model — dataflow architecture

• Application specifies vertices that flow through sequence of stages

Traditional OpenGL

Immediate mode graphics

Can be very inefficient, for real objects geometry and state change mix together

glBegin()
    glColor()
    glTexCoord()
    glNormal()
    glVertex()
    // ...
glEnd()

Traditional OpenGL

As hardware progressed, more of the functionality was performed on the video card.

Eventually, video cards added support for replacing default functionality with programmed shaders.

Efficiency

"Traditional" state-driven OpenGL

Loop over all triangles:
    vertex 1
        set color state
        set position state
    vertex 2
        set color state
        set position state
    vertex 3
        set color state
        set position state
    draw triangle

Efficiency

Shader program

Loop over all triangles
    vertex 1
        transfer position to video card
        transfer color to video card
    vertex 2
        transfer position to video card
        transfer color to video card
    vertex 3
        transfer position to video card
        transfer color to video card
    draw triangle

Efficiency

Small improvement

Use TRIANGLE_STRIP

transfer large data structure
draw triangle strip

Not real "mesh", but fewer vertices transfered

Efficiency

Use Buffer Object

Transfer all data to buffer
Draw all triangles (object or entire scene)

Can leave in video card memory to draw again

OR

Draw second object in different position

Programming Shaders

C like languages with support for vectors, matrices, etc.

GLSL (GL Shading Language) works with OpenGL

• OpenGL system compiles code

Cg (C for graphics)

• Also supports DirectX — nearly identical to Microsoft High Level Shading Language (HLSL)
• interface with OpenGL is more difficult

Advantages

Traditional OpenGL

• fairly simple "shading"

Sidenote:

• images are constructed from triangles, triangle mesh

Advantages

Colors are assigned to vertices

Hardware "shades" by interpolating color, even with shader program

Why?

• speed, processing power
• calculate proper color at vertices
• fill-in pixels inside by "shading"

Gourard Shading

Simple computation

• Specify color at each vertex
• Compute reflectance at each vertex
• Interpolate reflectance across triangle

Calculate color at each vertex

light-object interaction

depends on light source, including location

should be calculated at each pixel

• too expensive

Phong Shading

More accurate

• Supply surface normal and color at each vertex
• Interpolate surface normal across triangle
• Apply color calculation at each pixel

Phong Shading

How can this be? Triangles are flat!

Approximation to surface

Phong Shading

Gourard shading: per-vertex phong shading

Phong shading: per-fragment phong shading

Terminology

Vertex shader

Fragment shader

• Fragment == potential pixel ??

Terminology

Traditional Pipeline (each section uses state values)

Vertex Shader (retains some state variables)

Rasterizer?

Rasterizer?

Traditional Pipeline (each section uses state values)

Fragment Shader (some state variables retained)