First, let's start with some definitions.
Frames
A frame is a single picture that is displayed on the monitor.
fps
Frames Per Second, the amount of frames you can generate in a second. Not FPS, which stands for First-Person Shooter!
Graphics rendering
That is the process in which you generate the frames.
OpenGL
This is the "Open" variant of the SGI (a pioneering company in 3D graphics) Graphics Language. It describes all the steps a graphics rendering engine has to take to produce nice 3D graphics, and a computer language to make them happen. The "open" part implies that the standard is open for anybody to implement.
DirectX
Actually Direct3D for 3D graphics, this is what Microsoft designed to make nice graphics on chips that use the SGI GL method. And as it is the most used graphics model, it is used to class graphics hardware as well.
IHV
Independent Hardware Vendor, generally the companies that make the chips, and to a lesser extend the boards.
Pipelines
A pipeline is like a factory: it performs a sequence of actions on something to create a product.
Pixel pipelines
A pixel pipeline is a pipeline that calculates the color (value) of a pixel. Most (all?) pixel pipelines nowadays are combined to the size of a quad: a rectangle of 2x2 pixels. Better graphic chips have up to 16 of them (or four quads), so they can calculate 4*4=16 pixels at the same time.
Shaders
Shaders are the programs that run on small processors in a pipeline to calculate special effects, but it is used to describe those processors as well. It would be better to talk of shader programs versus processing elements or ALUs for the processors themselves.
Pixel shaders
Pixel shaders are the processors in pixel pipelines and/or the programs that are executed by them. They enable the programmer to calculate special effects for each pixel.
A wire frame
That is a set of points, connected by triangles or polygons, that make up the outside of an object you want to display in 3D.
Geometry
The shapes that are made out of the wire frames.
A vertex
That is a point that is used in a wire frame. Multiples are called vertices.
Skinning
To be able to display solid-looking objects from wire frames, you need to pull something around them. That is called skinning.
Textures
They started with being the pictures you use to skin a wire frame. But they are used for a lot of other purposes nowadays, as they represent one of the few ways to store data in a graphic chip.
A scene
That is the collection of all elements (vertices, textures and shader programs) that is needed to render a 3D frame.
Avatar
The virtual 3D representation of a person.
Transform and lighting
If you have your 3D objects, you need to put them in the scene. That requires that you rotate, scale and place them. But you might want to animate things as well, like move the limbs and facial expressions of your avatars. And when that is done, you want to calculate the light values of the triangels that make up your 3D objects to represent the lighting of the scene.
Vertex shaders
They allow the programmers to manipulate the geometry according to a set of rules. While this offers many interesting possibilities, as long as there is no good way to use textures and create new geometry (like smoothing an object by creating much more and smaller triangles that follow the outline), they are of limited use.
Shader model
The shader model (SM) describes the programmability of the hardware. The more programmability you have, the more life-like the graphics can look. It is the combination of the Vertex Shaders (VS) and Pixel Shaders (PS). This is mostly a Microsoft invention, as OpenGL doesn't make this distinction and only talks about functions.
In sequence:
DX 6 and lower
All these graphic chips are only able to generate pixels according to triangles, skinned with textures. Looks pretty bland and is not supported anymore. While it could do some nice tricks (dependent texture lookups, so you could use textures as general data storage), they weren't used at that time.
DX 7: Includes transform and lighting, the first model that allows any special effects. This is the bottom baseline nowadays.
DX 8.0: This includes a Hardware Abstraction Layer, so it was the first model that made it easy to program 3D graphics, and it introduced PS 1.1, which together with the ease of use made much better effects possible. But the programs were very tiny and had only a small range of possible values to work with, so the calculated colors tended to "jump" from one value to the next.
DX 8.1: The real start of programmable graphics hardware. PS 1.2 to 1.4 are introduced, which make those nice effects really possible.
PS 1.0: the first programmable pixel pipeline, never used in actual hardware.
PS 1.1: The DX 8.0 implementation from nVidia. It allows the developers some basic calculations in 8-bit integer values (+ 1 sign bit), which offers possibilities, but is too coarse (pixels "jump" from color to color) to make interesting effects possible.
PS 1.4: The DX 8.1 implementation form ATi. It allows a much finer granularity, and so is the first programmable model that is actually useful to create nice special effects.
PS 2.0+: This is the Good Stuff! Fully programmable, this allows just about any calculation. It makes truly superb life-like graphics possible. The only catch would be, that you really want at least 30 fps for a game, which makes it impractical to generate beautiful scenes that would take minutes to generate a single frame.
SM 2.0: This is the combination of VS 2.0 and PS 2.0+.
SM 3.0: At the moment, there doen't seem to be much difference between the SM 2.0+ and 3.0 implementations, except that the SM 3.0 implementations allow longer shader programs. It theoretically allows for conditional jumps, but the current implementation limits that to batches of 1024 pixels, of which both (all?) paths are calculated if they use more than one, so it isn't used in practice.
