Fixed function pipeline.

Had to set and reset lot of states.

No control over the vertices once it enters into the pipeline.

The TnL could do all the transformation and lighting by itself (without any CPU interaction), and we had no control over it.

Had to get the job done through DirectX API calls (by calling SetRenderState and SetTransform etc)

You have complete control over the transformation and lighting part of the pipeline.

Do your own lighting using your own custom lighting model.

Freedom to choose between fixed function and Programmable function pipeline.

No need to set most of the states if programmable shaders are used.

Transformations.

Lighting model.

Geometry skinning.

Generate texture co-ordinates on the fly.

Cannot create new vertex.

Cannot do any polygon level calculations, since we are unaware of the other vertices.

Backface culling.

Cannot modify any vertex data other than itself.

Constant: C0 to C95.

Input: V0 to V15.

Output:

oPos = Position in clip space
oD0 = Color 1 (Diffuse color r,g,b,a in the range of 0.0f to 1.0f)
oD1 = Color 2 (Specular color r,g,b,a in the range of 0.0f to 1.0f)
oFog = Fog
oPts = Point size
oT0 to oT3 = Upto 4 texture co-ordinates. One for each hardware texture unit.

Temporary: R0 to R11

Address: A0. Only x component can be used.

• First sentence expands the instruction in English.
• Second sentence is the instruction format (in bold and italic).
• Instruction format is OpCode followed by Operands.

  Like Intel format, destination (register) is always preceded by the Opcode.

• Any sentence after this explains the instruction in more detail.
• All opcodes and operands are in italic.
• “n” in an operand means any one of x, y, z, and w.

• nop: No operation
nop

Used as a place holder.

• mov: Move
mov dest, src

• mul: Multiply
mul dest, src1, src2

Multiply the contents of src1 and src2 and put the result into dest.

src1and src2 can also be dest.

• mad: Multiply and add.
mad dest, src1, src2, src3

dest = (src1 * src2) + src3

• add: Add
add dest, src1, src2

dest = src1 + src2

• rsq: Reciprocal of square root. (1/sqrt(num))
rsq dest, src.n

“n” has to be one of x, y, z, and w. if n is not specified, then, it is assumed to be w. Calculates the reciprocal of square root of a number. Used extensively in calculating distance, normalizing vectors, etc.

• dp3: Computes the dotproduct with 3 components.
dp3 dest, src1, src2

dest.x = dest.y = dest.z = dest.w =
(src1.x*src2.x) +
(src1.y*src2.y) +
(src1.z*src2.z)

• dp4: Computes the dotproduct with 4 components.
dp4 dest, src1, src2

dest.x = dest.y = dest.z = dest.w =
(src1.x*src2.x) +
(src1.y*src2.y) +
(src1.z*src2.z) +
(src1.w*src2.w)

Since dotproducts return scalar value, you would normally use something like this: dp4 dest.n, src1, src2

• dst: Distance attenuation.
dst dest, src1.n, src2.n

This sets dest to (1.0f, d, d*d, 1/d). Does this look like what is required for the distance attenuation calculation. Well, exactly.

• lit: Computes lighting coefficients from two dot products and power.
lit dest, src
src.x= n dot l
src.y= n dot h
src.zis unused
src.w= p

where,

l= light normal.
h= half angle vector.
n= normal.

P= Power (range +128 to –128)

dest is filled with (1.0f, src. x, L, 1.0f)

• min: Minimum
min dest, src1, src2

Sets the destination to the lower of the values in the two source registers.
Ex. min r1, r10, c2 sets the x,y,z, and w components of r1 with the component-wise minimum values from r10 and c2. This is similar to writing min r1.xyzw, r10.xyzw, c2.xyzw

• max: Maximum
max dest, src1, src2

Sets the destination to the higher of the values in the two source registers.

(This instruction operates componentwise.)

• slt: Set if less than (component-wise).
slt dest, src1, src2

This translates to dest = (src1
• sge: Set if greater than or equal to (component-wise).
slt dest, src1, src2

This translates to dest= (src1 >= src2) ? 1 : 0 in C.

• expp: Exponential 10-bit precision
expp dest, src. W

The components of the destination register is filled in this manner :

dest.x = 2 ** (int) src. w

dest. y = fractional part (src. w)

dest. z = 2 ** src. w

dest. w = 1.0

• log: Logarithm 10-bit precision
log dest, src. W

The components of the destination register is filled in this manner :

dest.x = exponent((int) src. w)

dest.y = mantissa(src. w)

dest.z = log2(src. w)

dest.w = 1.0

• rcp: Reciprocal of a number.
rcp dest, src

Allows us to do division.

1) Ambient light: As the name suggests, this light is present everywhere. This light is a result of light rays being reflected multiple numbers of times by many objects in the ambience. We can never determine the exact source of light. Since this light is present everywhere, it affects all the surfaces with the same intensity.

2) Directional light: This light has only direction (orientation) and color. A very good example of directional light is sun light. The source of a directional light is assumed to be at infinite distance from the object / surface.

3) Point light: This light has position and color. A good example of point light is your light bulb. Rays from the point light eject uniformly in all directions from its origin.

Depending on the distance and direction to the light source, the object's brightness changes.

4) Spotlight: A light source that emits a cone of light. Only objects within the cone are illuminated. The cone produces light of two degrees of intensity, with a central brightly lit section that acts as a point source, and a surrounding dimly lit section

	     1
fatt = ---------
	     dL

	     1
fatt = ---------
	  dL . dL

	  
	             1

fatt = --------------------------
      A0 + A1.dL + A2.dL.dL

Radial distance falloff: A1 = 0 and A2 > 0

Linear falloff: A1 > 0 and A2 = 0

Vertex based animation:

---

This is the most primitive of the animation systems. Vertex positions (may include normals also) for all the vertices in the mesh for all the animation frames are stored in memory.

This is the fastest way of animating, but its memory bandwidth is too high.

It is also visually not appealing, since animation frames are jumped integrally. The intermediate positions in between animation frames are skipped totally.

Also, it needs extra transition animations to switch between animations.

Ex. Visualize that a character is doing a walk animation. Say, its animation is changed to sit. It would look too shabby if the animation was switched abruptly to sit from walk.

So, first, an intermediate animation has to be played, and then, from intermediate to the target animation.

Memory requirement of the mesh multiplies with each added animation.

Ex.: Current animation Intermediate Target animation Walk (loop) -> Stand -> Sit

Vertex based key-frame animation:

---

This is a slight improvement over the vertex based animation. The only difference is that, the vertex positions are stored only for key-frames. The intermediate vertex positions are computed dynamically using interpolation schemes such as linear, Hermite curve, etc.

And also, the number of key frames can be slightly lesser than what it would have been with pure vertex based animation.

Visually, it is slightly more appealing than pure vertex based animation, since the intermediate frames are filled in dynamically at run-time.

Transition frames are not needed. Even transition is achieved by interpolation.

Skeletal animation system:

---

3D game developers are realizing that skeletal animation system is very versatile for both programmers as well as artists (actually more for the artists).

Skeletal animation system consists of a series of bones which are hierarchical in nature.

Mesh (vertices) or skin is attached to the bones. Hence, when the bones move/rotate, the vertices attached to the bone also move/rotate.

Only the bone data needs to be stored for every frame of the animation. Usually, the bone data is represented by quaternions.

This eliminates the need to store vertex positions for all the vertices for every frame of the animation, as in the vertex based animation.

Smooth animation. We can derive intermediate frames by using spherical interpolation.

Smooth transition while changing from one animation to the other.

Memory bandwidth is very small.

Any number of animations can be added whereas the mesh remains constant.

V' = Final blended position.
V = VertexPosition
M1 = WorldMatrix 1
M2 = WorldMatrix 2
M3 = WorldMatrix 3
W1 = Weight1, W2 = Weight2
V' = (W1)( V * M1 ) + (W2)( V * M2 ) + (1- W2 - W1)(V*M3)

Let's see how we can do vertex blending for two weights.
for (every vertex of the mesh) do
{
	V = current vertex.
	M [] = array of bone matrices.
	id0 = First index in to the bone matrix array.
	id1 = Second index in to the bone matrix array.
	W0 = Weight corresponding to index id0.
	W1 = Weight corresponding to index id1.
	W0 and W1 are normalized. i.e.  W0+W1 = 1
	V' = ( ( V x M[id0] ) x W0 ) + ( ( V x M[id1] ) x W1 )
}
 

#define MAX_PLANE_TESS_LEVEL_HORZ	3	// horizontal tesselation level
#define MAX_PLANE_TESS_LEVEL_VERT	3	// vertical tesselation level
 

#define PLANE_WIDTH	40				// physical width of the plane
#define PLANE_HEIGHT	30				// physical height of the plane
 

a. CLIP Position = (Vertex) x (World Matrix) x (View x projection)

b. Set all color components to 1(i.e full intensity).

c. Copy the texture co-ordinates.

a.World Vertex Position = (Vertex) x (World Matrix)

b.Position in CLIP space for the vertex = World Vertex Position x (View x projection)

c.Transform the normal into world co-ordinates.

d.Calculate the intensity at the vertex for all the given lights. Here I'm using only two point lights.

e.Calculate the final intensity as a result of all the lights affecting this vertex.

f.Copy texture co-ordinates.

dp3	r6.x,		r11, r0		; N.L 

dst	r4,		r10.w, r11.w	; (1, d, d*d, 1/d) 

dp3	r5.x,	r4, c[CV_LIGHT0_ATT]	; (a0 + a1*d + a2*d*d)
rcp	r5.x,	r5.x			; 1 / (a0 + a1*d + a2*d*d)
 

max r6.xy,	 r6.xy, CV_ZERO	; max(N.L, 0.0f)
mul r7,	 r6.xy, r5.xy			; factor = max(N.L, 0.0f) * attenuation
mul r8.xyz,	 c[CV_LIGHT0_COLOR].xyz, r7.x	  ; vertex_color = light_color * factor
mad oD0.xyz,	c[CV_LIGHT1_COLOR].xyz, r7.y, r8.xyz ; add other lights
 

add 	r0, 	V_INDICES, -CV_BONE_OFFSET
mad	r0, 	r0, CV_EACH_BONEMAT_HEIGHT, V_BONE_MAT_START_INDEX
max	r0,	r0, CV_ZERO
 

dx8shaders_planeblend.zip (935k)

dx8shaders_sources.zip (16k)

Geometry Skinning / Blending and Vertex Lighting - Using Programmable Vertex Shaders and DirectX 8.0