OpenGL Design tradeoffs and notes (Research)

To enable the pipeline to process objects independently, various objects' lighting are not allowed to interact. Therefore OpenGL cannot directly do raytracing and radiosity, altho those are more realistic. For a nice raytracing package, see http://www.povray.org .
Separate the object definition from the viewing from the lighting.
Graphical objects are defined principally by their vertices.
1. Transform the vertices, and the object is transformed.
2. Color the vertices, and the whole object's color is defined by interpolation.
OpenGL is a state machine.
1. Some subroutines set internal variables; others use them.
2. You can examine the internal state. (This sounds obvious, and is a good design practice, but not all systems do this.)
3. Programming a state machine:
```
    set_color(red)
    set_viewpoint(roofofcii)
    start_line(p1)
    draw_to(p2)
    start_line(p3)
    draw_to(p4)
    set_color(green)
    ...
```
4. Programming a non-state machine:
```
    draw_line(red,roofofcii,p1,p2)
    draw_line(red,roofofcii,p3,p4)
    draw_line(green,...)
```
OpenGL omits some functionality.
1. ''You know you've achieved perfection in design, not when you have nothing more to add, but when you have nothing more to take away.'' - Antoine de Saint-Exupery, Wind, Sand and Stars
2. Interactive user interfacing, windowing functions are left to the individual OS.
  1. These would be hard to make portable since they are OS-specific.
  2. Nevertheless, a basic package is supplied, in GLUT, the graphics library utility toolkit.
The major portable windowing system is the X window system.
1. It complements OpenGL, which can run on top of it.
2. It runs on most platforms.
3. It runs over networks.
Other design choices are possible and have been made in other systems.
Pipeline steps. (As GPUs get more powerful, this becomes more flexible).
1. Vertex processor
  1. Transform vertices
  2. Determine their color
  3. The vertex processor is programmable.
2. Clipping and primitive assembly
  1. Remove the parts of primitives (lines, polygons, etc) that lie outside the clipping volume.
  2. This changes the vertices.
3. Rasterization
  1. Find the potential pixels, or fragments caused by each graphic primitive.
  2. Each fragment has position in frame buffer, depth, color, transparancy.
4. Fragment processing
  1. Find frontmost fragment at each location.
  2. Blend partially transparant fragments.
  3. The fragment processor is programmable.