Written : 20th December 2000
Contact : [Web]
Download : Graph_07.Zip
of this lesson:
2. Lighting Theory
3. Generating a normal
4. The Geometry
5. Setting up Lights
6. Ambient Lights
7. Directional Lights
8. Point Lights
9. Spot Lights
is my favourite part of designing a game. Once you've added light to a game
it adds a whole new layer to the experience - especially if you do it correctly.
Up to this point you've specified the colour of your vertices - which could
allow you to make your own lighting engine (I do have a tutorial on this in
the "General Game programming" section). As an example, go and play
your favourite full-3D game (Something like Quake, Deus Ex, Half Life and so
on are good ones) - and just spend a couple of minutes examining the lighting
used. Then try and imagine what it would be like without the lighting there
- where everything was the same brightness and there were no shadows. As mentioned
above, Deus Ex is an excellent example of lighting (and an excellent game full
stop), there are many parts of this game where you're in dark areas - with glaring
spot lights and street lights being your only illumination; and a lot of the
combat that you take part in will see you hiding in the shadows - a prime example
of how lighting can affect the way you play the game.
illustrated the way lighting can be used to create atmosphere I'd also like
to point out how lighting can also destroy the atmosphere - when used incorrectly.
Like a lot of things when developing a game, lighting can be seen as an art
- put them in the wrong places, in the wrong combination or at the wrong time
and you'll get a mess; coloured lights may look really pretty, but 100 of them
spinning round and round will look pretty silly very quickly.
order to implement lighting in your scene you'll need to understand just what
it is - and how you use it; which calls for some theory work...
is Direct3D Lighting?
Lighting is an approximation of how a light works in the real world. It is unlikely
that you'll get a computer that exactly replicates real world lighting in a
game for a good 5 years yet (500Ghz chips?). Hopefully you'll know how light
works - It always travels in straight lines, and fades out over distance (and
it goes very fast as well). Up to this point you'll have seen 3D geometry where
you specify the colour, and Direct3D blends the colour across a triangle. That
colour is light. The Direct3D lighting engine replaces your ability to set the
vertex colour by calculating the colour itself (based on what lights are available);
then as normal Direct3D will blend the colours across the triangle.
types of light are available?
are 4 main types of light that you can use; but several features allow you to
design your own lights (Pixel Shaders, and Lit vertices that you've already
seen). These lights are explained below:
Point Light: A point light is represented by a point in 3D space with
various light emiting properties - range, colour and attenuation. A point light
radiates light in all directions from itself - like a lightbulb, candle, star
(a very small one).
Spot Lights: A spot light has a position and a direction - it shines
light in this direction with characteristics similiar to that of a spot light
or a torch. You have to specify the cone angles, and range.
Directional Lights: These have no position, instead they light all vertices
as though light were coming from an angle. Directional lights are best used
for mimicking extremely large lights from a long distance - the sun for example.
Ambient Light: When you set up ambient lighting all vertices are garaunteed
to be no darker than this colour. This is what is used when games make their
scenes mid-afternoon or late-night for example - without using 100's of lights
to bring up the overall light we just define the darkest colour. It should be
farely logical that there's no point in having other lights in a scene if the
ambient lighting is full white...
most rendering devices dont have a maximum number of lights in a scene, it should
be fairly obvious that the more lights you have the more calculations Direct3D
does, the slower your scene is rendered. Having said that, most of the hardware
transform and lighting cards have a maximum number of lights - 8 for the GeForce
256 and 16 for the GeForce 2; so for full compatability either check the upper
limit or try to keep the number of lights below 8.
You should also be aware that different lights take different amounts of time
to process; in general the quickest type is ambient lighting, followed by directional
lights, then point lights and slowest of all are spotlights.
Range Matters as well - if you're light covers a huge area it's going
to influence a large number of vertices - each of these vertices adds a little
extra time to the calculations. The general rule, therefore, is to keep the
range only to the size that you need it.
Specular Lighting is a nice little feature that we'll come across later
in the series, it allows you to make shiny objects - diamonds and crystals for
example. The reason I bring this up now is that specular lights require double
the processing time - so when you do use them, use them sparingly.
Geometry Detail is also important; as already mentioned, lighting is
calculated on a per-vertex scale - the more vertices, the longer it takes to
process the lighting. Whilst there isn't really any way of getting around this,
you may well want to bare it in mind when designing levels - less lights in
complex areas. Also, basic logic really, but there's no point having an active
light somewhere the player will never go/be - you're just wasting valuable processing
Shadows dont naturally
occur - they are quite a complicated and advanced topic. As you know, light
travels in a straight line, therefore when it hits a solid (or opaque) object
it wont carry on - anything behind this will not recieve light from the current
source. Calculating if every ray casted goes through any of the triangles in
the scene takes a massive amount of processing power - so Direct3D doesn't do
it. It scales light colour based on the orientation of the triangle, so the
back side of an object (which faces away from the light) will not recieve any
light - but dont be fooled; there are no shadows.
and terminology you should know
There are a few terms that you'll need to understand before setting up your
own lights. None of them are complicated though:
Range: How far the light goes; any vertices with a distance greater than
this will not be lit by the light. If you can keep the range of the light down
so much the better.
Attenuation: This is how the light changes over distance - how it fades
out usually. It is possible to make some weird results with this one - light
that gets brighter towards the edge and so on.
Light Direction: This is a normalised vector that describes what direction
it's pointing in - a normalised vector is a vector with a length of 1. Hopefully
you have a basic knowledge of how vectors work; whilst you can use them to specify
a position, they are by default a direction/distance relative to the origin.
For example, [0,8,0] will have a length of 8 (8 units from the origin) and will
cause something to look in the +Y direction.
Position: Fairly obvious this one - but it's often something that many
people get funny results with. Direct3D shades a vertex based on it's normal
(see next item); if you have a grid of vertices in a floor like setup, and if
the light is positioned very close to the floor it'll appear to have a very
small area of influence - regardless of it's range and attenuation. The is basic
maths really - if it shades a vertex based on it's normal (a direction) then
if the angle between the light and the normal is very small (which would happen
in this instance) it'll recieve very little light.
Normal: This is a very important thing to remember, and I'll show you
how to generate a normal a little later on. For an example, take a triangle
- one that's spinning around in 3D space; how do you know what direction it's
facing? the human eye could probably tell you - but this is useless to the Direct3D
lighting engine - it needs numbers. A normal also tells direct3D which way the
triangle is NOT facing - so if the light is behind the triangle the triangle
will recieve no light. A normal must also have a length of 1 - which isn't a
great problem as there are several features around that will scale the vector
to a length of 1 for you.
Generating a normal
we go into any greater detail you'll need to know how to generate a normal for
your triangle. Once you've learnt this it isn't particularly difficult - but
if you do get it wrong it can lead to some weird and frustrating results. To
generate a normal you need to follow these steps:
Make sure the triangle is generated in a clockwise order
2. Create a vector from vertex 0 to vertex 1
3. Create a vector from vertex 0 to vertex 2
4. Get the Cross product of the two vectors we just created
5. Normalise the cross product - not entirely necessary, but garauntees there
are no errors.
now put this to use by writing a simple function for calculating the normal.
Before this you should be aware that the above code generates a normal for the
whole triangle - which is okay if that's what you want (just copy the generated
normal to all 3 vertices); but if more than one triangle shares the same vertex
you may well want a normal that represents both faces. This can easily be done
by adding the two generated vertices together; as shown in the following diagram:
the preceeding diagram we see two faces (in 2D) represented by black lines;
the big green arrows represent the normal. At the joining vertex you can imagine
a *fight* over which normal it uses - if it uses either of them the other face
will look odd. So if we try adding the two vectors together - as shown by the
2 small green arrows at the top; we get to the point shown by the blue arrow;
an average vector that doesn't really represent either face, but it's not biased
to any one side in particular. We'll need to re-normalise the new vector, as
it'll probably have a lengh of 2 (2 1 unit vectors added together). The final
thing to mention on this is that you'll end up with slightly blurry lighting
using this method - because Direct3D blends the colours across the vertices
you'll find that you cant get a sharp difference between either triangle - which
would be useful if they were the corners of two walls.
code for generating a normal goes like this:
Private Function GenerateTriangleNormals(p0 As UnlitVertex, p1 As UnlitVertex, p2 As UnlitVertex) As D3DVECTOR
'//0. Variables required
Dim v01 As D3DVECTOR 'Vector from points 0 to 1
Dim v02 As D3DVECTOR 'Vector from points 0 to 2
Dim vNorm As D3DVECTOR 'The final vector
'//1. Create the vectors from points 0 to 1 and 0 to 2
D3DXVec3Subtract v01, MakeVector(p1.X, p1.Y, p1.Z), MakeVector(p0.X, p0.Y, p0.Z)
D3DXVec3Subtract v02, MakeVector(p2.X, p2.Y, p2.Z), MakeVector(p0.X, p0.Y, p0.Z)
'//2. Get the cross product
D3DXVec3Cross vNorm, v01, v02
'//3. Normalize this vector
D3DXVec3Normalize vNorm, vNorm
'//4. Return the value
GenerateTriangleNormals.X = vNorm.X
GenerateTriangleNormals.Y = vNorm.Y
GenerateTriangleNormals.Z = vNorm.Z
greatly complicated really, we can pass 3 vertices defining a triangle to this
function and it'll return the normal for it - you then need to copy the normal
to all 3 vertices. It's a good idea to remember this code, or at least how to
write your own (I remember it as "Normalised Cross Product of the vectors
from 0 to 1 and 0 to 2"). You could adapt this code slightly so that it
fills the 3 passed vertices with the normal information, but I decided against
this so that I left room for adding normals together (as explained above).
shouldn't take very long - hopefully you're already aware of how geometry works
- so this is just a review of what has changed in order for lighting to work.
first thing to change is the vertex format - we have a new type to play with
this time. The only real change is the loss of a color variable (we cant set
the colour) and the addition of values to hold data about the vertex normal.
too difficult really.
the way we create the geometry has changed slightly. I've used the 3D cube that
we generated in an earlier lesson as a basis, but altered it so that all the
triangles are in the correct order (not all of them were CW in the other lesson);
and I've added code to generate the normals.
only one triangle out of the 12 that make up the cube, but they're all pretty
much the same. Note that in the initial creation I haven't specified a normal
- it's left as [0,0,0] - we then calculate the normal and overwrite the old
value with the new one. The "CreateVertex" function is a simple wrapper
similar to ones we've used in previous lessons - it just saves us from having
8 lines of code to create each vertex.
Setting up lights
are a couple of things that you must do in order to get a light working in your
scene; most of them can be done at the beginning and left alone for the remaining
you must apply a material to the device - if you forget to do this everything
will appear black (this is the cause of many "newbie" problems).
can change the values of the "Col" value if you want to alter the
global lighting. At the moment it's set to white - it wont interfere with anything
in the scene; if you set it to a slight tint of blue all subsequent lights would
appear slightly blue...
you must let the device know about your light:
|D3DDevice.SetLight 0, Lights(0) '//Replace Lights(0) with any valid D3DLight8 object
this line is called you can use the light, but if you change the property in
the D3DLight8 object you'll need to call this function again. The first argument
is the index, being a long datatype means that theoretically you could
have around 2 billion lights created - but it's unlikely to be needed.
you need to turn the light on; in the theory section above I mentioned about
keeping the number of lights down; well this is where it applies. You can register
as many lights as you like with the device, but you need to keep a lid on how
many of them are active. These values can be turned on and off as you please
- enabling certain lights for certain parts of geometry is another way of keeping
the processing overheads down...
|D3DDevice.LightEnable 0, 1 '1 = On 0 = Off
you need to tell Direct3D that you want it to do lighting for you - up till
this point we've told it to disable the lighting engine; so here's how to enable
|D3DDevice.SetRenderState D3DRS_LIGHTING, 1
greatly challenging in here.... Onto learning how to set up each type of light.
isn't a particularly complicated thing - one line of code is all it takes. Whilst
a light can have an ambient property if it does Direct3D will just add them
all together - for example, we could have 3 ambient values - red, green and
blue, Direct3D would just add them together as being White....
set the ambient light through a SetRenderState call, the ambient colour is a
hexidecimal RRGGBB colour (as opposed to a AARRGGBB code).
example of a directional light
are best, after ambient lights, for lifting the overall lighting level of a
scene. You can use these if you want to simulate the sun for example, and if
you get it to change directions over time it'll appear to shade things like
the sun would (only one side of a cube for example).
directional light has direction and colour but no position, no attenuation and
no range. The direction specified is normally a normalised vector (we've done
these, remember?) but it doesn't have to be - as long as it isn't [0,0,0] then
it's okay. Here's how we set up our Directional light:
you can tell, our light is pointing straight down and is white; you can mix
and match the direction vector with anything you like - so long as it has length.
example of a point light
lights are one of the easiest to set up; give them a position, colour, range
and attenuation and that's it (note that they dont have direction). Here's how
we set up a point light:
= 0.05 'Set the Linear Attenuation to 0.05
we have created a blue point light. The range is quite short - so that you can
see the basics of the attenuation factors coming in. You'll note that there
are 3 attenuation variables - Attenuation0, Attenuation1 and Attenuation2 -
these are the Constant, Linear and Quadratic values respectively. Play around
with these values to get different effects - but remember, attenuation won't
be very easy to notice if the light has a range of 100000 (or some-other suitably
example of a spot light
are very clever, yet they are quite difficult to set up (compared with the other
types) and they have quite a high processing overhead. As you should just about
be able to see on the diagram above the outside of the cone is lighter than
the inside of the cone. The following diagram illustrates this further:
should also note that there are two radii for the cone - an inner (Theta) and
outer (Phi); you can specify both of these. Note that they are both measured
in radians, not degrees - to convert from degrees to radians multiply degrees
by (Pi / 180).
following code is used by the example program to generate a spot light:
0, 0) 'Along the X axis
= 30 *
180) 'Inner Cone
= 50 *
180) 'Outer Cone
greatly complicated really; just remember that that the cone's inner and outer
angles are specified in radians not degrees.
our tour of basic lighting is complete - there's nothing greatly complicated
about the last part, but you have to remember the first part about generating
normals; get that wrong and you'll get some very strange results. You can download
the source code (I suggest you do) from the top of the page.
you've followed all of that, onto Lesson 08 : Advanced
Geometry part 1 - Loading pre-created 3D objects