SISD:

regular serial uniprocessor computing

SIMD:

multiple processors each doing the same task, but on different parts of the data. Vector processing.

MISD:

the same data being run through different operations in parallel. Certain kinds of image processing, perhaps encryption breaking. Rarely used.

MIMD:

multiple processors doing different tasks on different data. Most general form of parallel computing; also most common nowadays.

Shared:

All processors share same address space for main memory. The assumption is that memory access times are the same for all processors. Easier to program: threads communicate simply by sharing data structures directly. For small numbers of processors, often faster due to less overhead. Does not scale well.

Distributed:

Each processor has its own address space. No data structures can be shared with other processors. All communication must be explicit via networking, which makes programming more complicated due to synchronization and latency issues. Scales to hundreds of thousands of processors.

Hybrid:

Each node has a few (often 4-8) processors which share that node's memory. Nodes cannot directly see the memory of other nodes.

Point:

has a location and RGBA colours (ambient, diffuse, specular). Similar to a candle.

Directional:

has a direction and colours, but no location. Similar to the sun. Specified in OpenGL the same way as point lights, but using homogeneous coordinates to specify a vector instead of a point.

Spot:

has a location, direction, cutoff depth, falloff exponent, and colours. Similar to a theatre spotlight.

Global ambient:

We can specify an ambient light that uniformly illuminates the whole scene. Similar to a very evenly lit scene like an open field on a cloudy day.

(Area light):

(not offered by OpenGL, but we can model it using global illumination techniques like radiosity.)

(Emissive):

(Emissive OpenGL objects don't count as lights because they don't cast light on other objects.)

void getAxisAngle(float x0, float y0, float x1, float y1, float& axis, float& ang) {
	float vec0[3], vec1[3], xprod[3];
	vec0[0] = x0; vec0[1] = y0;
	vec1[0] = x1; vec1[1] = y1;
	vec0[2] = sqrt(1 - x0*x0 + y0*y0);
	vec1[2] = sqrt(1 - x1*x1 + y1*y1);
	xprod = crossproduct(vec0, vec1);
	axis = normalize(xprod);
	ang = arcsin(magnitude(xprod));
}

C⁰:

Curve segments touch; basic continuity.

C¹:

Curves touch and velocity vectors also match at the joins

C²:

Curves touch, velocity vectors match, and even the curvatures match at the joins

G¹:

Curves touch, and velocity vectors point in the same direction (but might not be the same magnitude). In between C⁰ and C¹.

NU (non-uniform):

the knots (joins between Bezier segments) need not be uniformly spaced in u (the parameter space). For instance, this can be used to make the NURBS interpolate its endpoints, by repeating knots four times at the start (u=0) and end (u=1).

R (rational):

Each control point has a relative weighting associated with it which biases its influence on the curve.

BS (B-spline, Bezier spline):

A B-spline is a spline made up of cubic Bezier segments, joined in a particular way so as to get C² continuity.

Grids:

subdivide space into equal voxels, regularly spaced

Octrees:

Adaptive subdivision: where needed, each cell is subdivided into eight equal subcells along the coordinate axes.

k-d trees:

Also adaptive like octrees, but cells are subdivided along one axis at a time. Cells need not be split into equal-size subcells.

BSP trees:

Even more flexible than k-d trees: each time a cell is split using a (k-1)-dimensional hyperplane (a regular plane in 3D), oriented in any way (need not be along a coordinate axis).