theory and implementation inside XSI
Orignal author: Amaan Akram
List of translations:
Serbo-Croatian by Jovana Milutinovich
Translations to other languages by third-parties is actively encouraged
Lesson 1: Vectors
The process of rendering, or generating an image
in a 3D graphics program, involves firing out rays from a 3D camera
and then tracking what the rays hit, one ray at a time. Such rays
are fired atleast once for every pixel that is to be rendered on an
So how are these rays represented internally
in a 3D software? With Vectors. The reason for choosing vectors to
represent such rays is fairly simple. Vectors provide a convenient
way to represent direction and distance in a single form, or symbol.
So, in firing a single ray from a 3D camera in a given direction,
a software can determine if a ray has hit an object, and if it has,
then what is the distance from the camera of the object that
the ray has hit.
Some of you will remember vectors from math
classes from school. Some of you will have happy memories of vectors,
others will have nightmarish, and then there might be some who might
not have had the chance to study them at all in school. So, for the
purpose of bringing everyone at the same level, I am going to cover
some basic vector theory in this lesson.
As stated earlier, Vectors represent two quantities
with a single symbol. The graphical way of a vector is with an arrow.
The tip of the arrow shows the direction, and its length represents
the length of the vector in 3D space. This is represented in the figure
below, with a vector OQ, where O represented the origin in 3D world
space, and Q represents a point that space.
Note that vector OQ is not the same as the vector
QO. The length may be the same, but the direction has been inverted.
Also note that two vectors are equal provided
they have the same length and direction (parallel). It is not necessary
for the two to originate from the same point in 3D space.
For more information on vectors, please visit,
read and understand what's written on the following pages.
http://www.netcomuk.co.uk/~jenolive/vect1.html (Some general
http://www.netcomuk.co.uk/~jenolive/vect2.html ( Adding vectors )
http://www.netcomuk.co.uk/~jenolive/vect4.html ( Using components to describe vectors)
http://www.netcomuk.co.uk/~jenolive/trig.html (Basic trig for working out components)
http://www.netcomuk.co.uk/~jenolive/vect5.html ( Finding the magnitude or length of a vector)
Once everyone's read the above, please let me
know. We'll then move on to Lesson 2 then. Ofcourse if there is anything
that is not clear about vectors after reading the information available
on the website above, please ask.
Lesson 2: Vectors & their length
The length of a vector is calculated by using
the famous Pythagoras Theorem, which states that the square of the
length of the diagonal of a right angle triangle is the sum of the
square of the triangle's base and it's height. This I think we have
all pretty much studied in school. The only thing that we do different
is that we are looking at vectors in 3-dimensional space. So a coordinate
will have 3 components, x, y and z. In school, I don't think I went
beyond two dimensional spaces.
The above is illustrated in the beautiful diagram below.
OK so we've just looked at finding the length
of a vector, which starts at the origin (0,0,0) and ends at some point.
But what about finding the length of a vector that is not starting
at the origin? Well, that's simple.
Say the vector starts at point A with coordinates
(x1, y1, z1), and ends at point B with coordinates (x2, y2, z2). The
following picture shows how we handle such cases for calculating vector
lengths. (for the purpose of simplicity, I have chosen an example
of a vector confined to the XY plane)
as an exercise, can anyone tell me what calculations
we would have to do if the vector in the above example was NOT confined
to the XY plane, and actually had a Z component as well? Like say,
point B was at (5, 4, 8 ) in 3D space?
You must be wondering why are we going through
vectors. Well, you will find out when we all write our first Phong
shaders! But without understanding vectors, there's little point in moving
Lesson 3: Vector Dot Product
OK so far we have covered what vectors are,
and how to calculate distances between 2 points in space. Now, we
will look at dot products, and how useful they are for rendering in
The addition or subtraction of two vectors leads
to another vector. Dot products, on the other hand, lead to just a
number--a number which can be very important to shader writing, when
used in the right way. In fact, this number holds the key to how shading
is done at any given point on the surface of a 3D object. This number
is a scalar quantity, which basically means that it's just a number,
not a vector. A
dot product between two vectors A and B is denoted by:
A.B --- (read as A dot B)
So, how is the dot product calculated? It's
calculated by multiplying two parallel vectors' magnitudes. Recall
that we can calculate the magnitude of a vector A with coordinates
X, Y, Z by:
( X*X + Y*Y + Z*Z)
Also note that the symbol for representing the magnitude of
A is |A|
So the dot product of two vectors A and B is
A.B=|A| * |B|
But what happens when the vectors are not parallel?
Well, some of you may recall from college vector classes that a vector
is comprised of two components, a horizontal component, and a vertical
Have a look at the following image
The image shows two vectors, A and B. The vector
B is not parallel to A, but as said earler, every vector has two components.
In this case, B is at an angle denoted by theta (greek symbol) relative
to the vector A (which is parallel to the X axis). So, the component
of B parallel to A is denoted by BCos(theta).
So, as the image says, the dot product of two
vectors A and B becomes:
A.B=|A| * |B| Cos (theta) ----we take the magnitudes
of both vectors here because remember a Dot Product is a scalar quantity
and we were multiplying the magnitudes of both vectors to define the
Following is another example of a dot product.
To further your understanding of dot products,
have a look at the interactive Java applet at http://www.falstad.com/dotproduct/ . This
is a great example of how dot products work and the applet
is a very intuitive way of furthering your understanding about dot
Lesson 4: Unit vectors & Dot Products
So, here we go.... today we are going to look
at unit vectors and how they affect dot product calculations.
So what is a unit vector? It was stated in the
first lesson that a unit vector is a vector that has a length of
1 unit. So how do we convert any vector into a unit vector? We
take the three components --X, Y, Z -- of the vector and divide each
of them with the length of the vector. Have a look at the example
Vector A = ( X, Y, Z )
Length L = SquareRoot ( X*X + Y*Y + Z*Z)
So, Unit Vector A = ( X/L, Y/L, Z/L )
This method of converting any vector to a unit
vector is called Normalization
This unit vector has a very significant impact
on dot product calculations. Recall from the previous lesson that
a dot product can be calculated from:
A.B=|A| * |B| Cos (theta) -- where theta is
the angle between the 2 vectors A and B
But what happens when vectors A and B in the
above equation are unit vectors (of length 1)? We know that |A| and
|B | are both equal to 1. The dot product formula can be rewritten
A.B=1 * 1 Cos (theta)
simplified : A.B = Cos (theta)
This is a very important result. What it tells us is that the dot
product of two unit vectors is simply the cosine of the angle between
them. This is the key to unlocking shading calculations in rendering!
Now let's go and see how to get the value of the Cosine between two
unit vectors A and B. We can now very easily calculate the angle between
two vectors simply by calculating the dot product. Now lets reverse
the above equation.
Cos (theta) = A.B
but what is A.B? to calculate Cos (theta), we
need another way of expressing vectors A and B. This is where the
another method of calculating dot products comes in. Have a look at
Vector A = (X1, Y1, Z1)
Vector B = (X2, Y2, Z2)
A.B = (X1*X2) + (Y1*Y2) + (Z1*Z2) (this
is just a straight multiplication of each of the components of the
two vectors, and adding the result of each multiplication.
So, now we can easily use the above equation
to calculate the angle between two vectors.
Vector A = (X1, Y1, Z1)
Vector B = (X2, Y2, Z2)
Given that vectors A and B have been Normalized:
Cos (theta) = (X1*X2) + (Y1*Y2) + (Z1*Z2)
When two unit vectors are parallel, A.B
and cos(theta) will both be equal to 1. (since Cosine of 0 degrees
is 1 --see graph of cosine below)
When two unit vectors are perpendicular A.B and cos(theta) will both be equal to 0. (since Cosine of 90 degrees
is 0 --see graph of cosine below)
Following is a graphical representation of how
the value of A . B (dot product) changes when both A and B are unit
Since A.B = Cos (theta), the variation in the
value of A . B as the angle between them increases from 0 degrees
onwards is simply the cosine curve
The Y-axis represents Cos (theta), which is
the same as A . B -- the dot product. And the X-axis represents the
variation in the angle between the two vectors A and B
this is a very good way of representing how
the dot product varies between two unit vectors. This graph also shows
that the rate of change of the dot product with respect to the angle
between the vectors is a non-linear change
Once again, please visit http://www.falstad.com/dotproduct/ again and
play with the Java applet. see how the dot product values change as
u play with the magnitude of each of the vectors and the angles between
OK, I think in the next lesson we will look
at 3D graphics, and math (well, OK a bit of math)
Lesson 5: Vectors inside your 3D application, and the Lambert
OK so now that we all know what dot products
are, we can start looking at 3D applications and how they use vectors
to shade a polygon.
Each object in a 3D application consists of
polygons. Every polygon has a vector that is perpendicular to the
plane that contains the polygon. What is a plane? It's just 2D space.
One example is the XY plane in your 3D application. Similarly, the
XZ plane. Similarly, an ideal polygon is always confined to its own
So, every polygon has a vector stored in it
that is perpendicular to the plane of the polygon. This vector is
called a Surface Normal, or for simplicity, just a Normal. Have a
look at the following image
(This Surface Normal should not be confused
with the process of Normalization. The two are completely different
This Normal is a critical element in calculating
the shading on that polygon. The shading on this polygon will be the
brightest when its normal is pointing at a light source. As the polygon
turns away from the light source, the normal of the polygon will start
pointing away from the light, and the shading on the polygon will
decline in brightness. This is what shading is all about in a nutshell. Have a look at the following image.
Say we have a polygon to render. In particular,
we have to render a pixel P on that polygon. We know that that pixel
on the polygon will have a Normal, say N. The next thing we need is
a light in the scene to be able to shade the pixel. So, now assume
that there's a light in the scene as well, and there is a vector L
that extends from the pixel P out to the light source. And finally,
let's say the angle between N and L is theta. (see figure below)
(note the direction of the vectors L and N.
They are both point outwards from the pixel P. If the direction of
L was reversed, our calcuations would be wrong as the new angle theta
would become 180-theta. Check school vector books for more info. For
now just keep in mind that angle calculations are done at the tail
ends of vectors L and N)
Since we are only interested in finding out
the angle between N and L, we can use the dot product formula to calculate
the angle. Recall that the dot product is given by
L . N = |L| * |N| * Cos (theta)
Since the dot product (and the angle theta)
in the above formula is dependant on the magnitudes of the vectors
L and N, we need to remove |L| and |N| from the above equation. The
way to do that is to normalize L and N so that |L| and |N| both become
So assuming we have normalized N and L, the
normalized vectors are N' and L', respectively. Their components are:
L' = (L' x, L' y, L' z)
N' = (N' x, N' y, N' z)
So the shading at pixel P is defined by:
Cos (theta) = L' . N' -- where L' . N'
= (L' x * N' x) + (L' y * N' y) + (L' z * N' z) -- this equation is
the Lambertian Shading Model
The above equation is evaluated for every pixel
that is on the surface of a polygon to be rendered. As the angle between
L' and N' increases from zero to 90 degrees, the shading falls from
1 to 0 (same as in a cosine curve).
Lesson 6: More on vectors and other shader variables
In the last lesson we learned how the Lambert
shading model gives us diffuse shading. This shading model is at the
heart of many of todays shading algorithms, simply because it provides
a fast and easy way to approximate surface diffuse shading.
In this lesson, we will take a look at some
other variables and surface normals before we move onto some practical
Earlier I mentioned that to render each pixel,
the renderer fires atleast one ray (the camera vector) from the scene's
camera. If that ray doesn't hit anything, then no shading calculations
are done. However, if the ray does hit a polygon then the relevant
shader assigned to that polygon is looked up and shading calculations
are done for that point where the camera vector has intersected with
the surface of the polygon. This point is often referred to as the Intersection Point. For each pixel that is to be rendered on
a polygon, there is always an intersection point. On a very basic
level, the data contained within the Intersection Point data structure
is simply the X,Y, & Z coordinates of that point in 3D space.
So the camera vector V for rendering the pixel with an intersection
point P is VP.
Two types of Normals:
It is important to mention that there are two
kinds of normals on a polygon. One is the Geometry Normal, and the
other is the Interpolated Normal. The following figures show the difference
between the two normals.
A Geometry Normal is always perpendicular to
the plane defined by each polygon. This normal is dotted with the
light vector of a light in a scene to produce shading for the entire
polygon. This shading calculation is done once, and the color is applied
to the entire surface of the polygon. This kind of shading method,
with the Geometry Normal, produces what is known is Flat Shading.
A Flat Shaded object looks like:
So the single geometry normal's direction defines
the color (shading) of each polygon.
Interpolated Normals are spread out evenly across
the polygons of an object. However, their directions are smoothed
out over the surface of an object to make the object appear smoother
in shading calculations. Have a look at the following figure
The same object that was used to generate the
flat shaded version using Geometry Normals is used here again, but
the normals on the surface of the object have been smoothed out. In
the lower section of the above figure, you can see how the normals
are fanned out over the surface. This approximation is calculated
using a Normal Interpolation algorithm for Phong shading that we will
not get into during this session, as it is beyond the scope of what
we are trying to cover here. But it is important to know that when
an object is 'smoothed', the internal shading calculations switch
from using Geometry Normals to Interpolated Normals.
So, at each intersection point at a pixel that
is to be shaded, the Interpolated Normal is looked up and is dotted
with a light vector to calculated diffuse shading.
On a side (but interesting) note, bump mapping
works with interpolated normals too. All it does is that the Interpolated
normals are further perturbed according to the gray-scale intensity
of a pixel from a bump map image. Then these perturbed normals are
dotted with the camera vector to calculate diffuse shading..
Lesson 7: A video to watch - practical implemention via low-level shading nodes in Mental Ray
The file is compressed with the WinRAR v3.51.
If you are unfortunate enough to not have winrar, then you can download
it umm... for free from http://www.rarlabs.com/download.htm . It's
a small download, only 990kb. If you already have WinRar installed
and it says that the Rar file on the website is corrput,.then you
need to upgrade to the latest version of winrar.
The AVI for this lesson can be downloaded from:
You will also require the (free) Techsmith codec
to view avi. This is a small file -- just 170kb. It can be downloaded
That's all that is required to view this lesson.
I apologize for the poor quality of the audio. I kept the quality
down to keep the filesize down...
Lesson 8: Surface Illumination
In this lesson, we are just going to quickly
look at how the overall illumination on any polygon or surface is
calculated. Let's start out by breaking down the different elements
that contribute to the illumination on a surface.
Given the above elements, we can now write down
the shading on any polygon as an equation:
Shading = Ambience + Diffuse + Specular +
note: for all dot product calculations in the
above equation, clamp dot product values to above or equal to 0. Dot
products can be negative when the angle between two vectors goes higher
than 90 and less than 270 degrees Negative values of dot products
make no sense for calculating illumination. If they are not clamped
to be above 0, the final shading will look umm..strange.
Ambience is simply a user-specified
color value. This can be implemented in XSI's render tree via a Color
Share node, which can be plugged into the final Material node of an
Diffuse shading is simply added
to the Ambience shading via a Color Math Basic node, using an Additive
operator. Specular and Reflection shading is added in a similar manner.
Since Ambience is very easy to implement, and
we have already implemented Diffuse shading, let's now move on to
Specular shading. However, before we do that, I'd like to point out
that my diffuse calculations are simplified on purpose. I did not
look up the color, intensity and other properties of the light. In
a more realistic scenario, all such properties may need to be looked
up and then multiplied with the light vector.
There is no such thing in real life as
specular shading. It is just something that has been invented by computer
graphics scientists to help approximate reflection of a light source.
All it does is that it creates an illusion of a reflecton lightsource
on a surface.
So how do we calculate specular reflection?
Well, there are two methods out their. One is to use a reflection
vector, and the other is to use a what is called a Half Vector. Both
methods are outlined in the figures below.
Figure A represents a situation with a light
vector, a camera vector, and a surface normal. I have drawn the reflection
vector, which is just a reflection of the light vector about the surface
Figure B shows how I calculate the reflection
vector R (there are other ways to do this calculation--I am presenting
my own method below. Others may use another method, but the result
is the same). I write down the point H, which lies half way between
R and L, as an equation involving R and L. I used a method from trignometry
that we have all used in school. To calculate the mid point of two
points, we just add each component and divide each component by two.
The forumla, expressed in terms of R and L is
H= ((Rx+Lx)/2) + ((Ry+Ly)/2) + ((Rz+Lz)/2) --
equation 1 (trignometric form)
This can also be written in vector form
H=(R+L) / 2 -- equation 1.1
As the R is a reflection of L about N, the midpoint
H also lies on the normal vector. This comes in very handy to calculate
H in another way. Whenever we do a dot product between two normalized
vectors, the result is the length of the projection of one
vector onto another. In this case, when we do N . L, we find out the
length of the projection of L on N. This is very easy to visualize
in another way. When L and N are parallel, the angle between them
is 0, and the dot product of the two is 1. That means that the length
of the projection of L on N is 1 times N (1*N). If the angle between
the two is 45 degrees, the dot product gives us 0.707 as the result.
This means that the length of the projection of L on N is 0.707 times
N (0.707*N). If the angle was 90 degrees, the dot product would be
0 and the length of the projection of L on N would be 0 times N (0*N)--hence
So point H can simply be written as
H=N * (N . L) -- equation 1.2
When we equate the two equations 1.1 and 1.2,
R = 2N * ( N . L) - L
The specular component then is simply the dot
product between R and the camera vector C. When the two line up, the
camera sees the light's reflection perfectly. As L or C move, the
specular strength changes accordingly. The final forumla for specular
reflection via this method is:
C . (2N * ( N . L) - L)
Now let's take a look at the half vector
This is Jim Blinn's approximation of a specular
reflection. The reason this method exists, and is more commonly used,
is because it involves fewer computations that the reflection vector
method for calculating.
The image below shows two different positions
for the light vector L, but with the camera vector and the surface
In Figure A, the light is positioned in such
a way that R lines up perfectly with C. If we calculate the half vector
H between L and C, we will find out that H lines up perfectly with
the normal N.
In Figure B, I have moved L a bit up, and as
a result R has moved away from C, and H has moved away from N. So,
given this behaviour of H with N, and its relation with R, we can
say that specular reflection can be calculated by just comparing the
angle between H and N by using a dot product calculation.
That's it! We now know how to computer specular
reflection. The last remaining topic in this discussion
is that of just reflection. It's actually quite simple to calculate
reflections. We have to calculate the camera vector reflected about
the surface normal. This vector is our Reflection Vector of the camera, which we will call RC. (the Reflection Vector in the
specular calculation section is the reflection vector of the light,
not the camera). What we do with RC to calculate reflection is to
evaluate the full shading equation by temporarily assuming that our
camera vector is the same as RC. Hence, we substitute any references
to the camera vector with RC in the following equation
Reflection = Ambience + Diffuse + Specular
+ Reflection Hence,
the full equation for calculating shading isShading
=Ambience + Diffuse + Specular+ (Ambience
+ Diffuse + Specular + Reflection)
The bit in green is our reflection component
Normally, raytracers have a user-defined
limit for how many times reflection is to be evaluated. In Mental
Ray in XSI, this option is available under the Optimization tab of
This pretty much wraps up this tutorial.
Many thanks for your interest. If you have any questions, please do
not hesitate to contact me via my website at www.warpedspace.org To see a working example of how to implement
a phong shader (without reflection), please download the following
XSI 4.2 scene
The shader lets you control the following elementsColor
Diffuse (This diffuse acts like it does in Max or Lightwave, NOT like
Diffuse Spread (similar to Diffuse Sharpness in Lightwave)
Primary Specular Color
Primary Specular Intensity
Secondary Specular Color
Secondary Specular IntensityThe
controls in the flow look like: The
two speculars were just an experiment to get metallic shading into
the render tree. Below is a sample image rendered with the 2 speculars
see the full render tree, please see:
http://www.warpedspace.org/wips/My_Phong_Shader/render_tree.jpg (warning!: 2500 pixels wide!) I'd
like to urge everyone to play around with the render-tree and low-level
XSI nodes. This is a very artist-friendly way of experimenting low-level
shading without stepping into the complex world of programming. As
an example of what can be achieved with just playing around, have
a look at my 'hack-SSS' shader below. It can give visually interesting
results that may be useful, and it does it faster than the
simplest of phong shaders :)
Click for a larger version -- model courtesy of Mario
tutorial would have been impossible without the help of my friend Andy Nicholas. His lessons in shading theory and
how to implement it inside xsi's render tree got me started on this
path--for which I am grateful. Please visit his website -- www.andynicholas.com