Attention: For most of these projects I have used DirectX 9.0c (Dec 2005), if you do not have this installed, please install it from this update installer.
Final Year Projects
Final Project: Automated Creation of Assets from Map Data
Originally conceived as a project to accurately take a map of a town and fully produce it as a virtual world, this proved a rather ambitious goal for the scope of the University's project criteria. So, it was refined down into two simpler investigations; the first of which would be the requirements of a framework designed to give developer's an easy way to incorporate map data into their products, while the second was how to ease that incorporation by providing methods to produce assets from the features of the map pragmatically.
The produced application was more of a proof of concept, separating buildings into generic 'pieces' which then using properties specified by the map, could be joined together creating a unique building. These 'zones' could then be decorated with features such as windows and doors. The result is a complete mesh, with differing surfaces, allowing for different materials to be used, which follows not only the plan-view shape of the building, but also fits within extra parameters such as height, roof type, and building construction type.
All of this functionality fits into the framework whilst still allowing the developer to produce asset data by using these methods, or to override and provide their own at any step of the process. Overall I felt the project set a firm academic basis for a very varied and wide ranging subject area, and if only it took place over a longer amount of time, the final proof of concept application could have shown much more depth in its supported map feature types.
Advanced Graphical Algorithyms
This assignment concerned the production of a high end prerender graphics system. Taking part in it, meant that I created my own renderer, using Whitted ray tracing as its basis.
Personally I followed a very design orientated methology with the production of this application. There were two rules I followed very strictly; every component must be modular, allowing it to be replaced very easily, and everything must be done as much as possible to decrease render times. The second aim had a very real reason - I didn't fancy waiting around for days to see results.
The final application featured an Octree system based upon Revelles et al. "An Efficient Parametric Algorithm for Octree Traversal", which divided triangle intersection calculation time by more than a factor of 8. Whilst it relied upon a triangle intersection event tree to collate ray-triangle intersections, abstracting objects such as lights and materials down to their basics, allowing for cleaner addition of differing behaviour, and more maintainable code.
Whitted raytracing is present, as are shadows, refraction and reflection. Texturing and normal mapping has also been implemented, complete with tone mapping and attempts were made to allow photon mapping to be easily slotted into the renderer.
The sample images I provide here originally took between 20 minutes and 6 hours to produce at 3500 x 2000 resolution.
It's also worth mentioning that the fantastically cheeky piggies (and other models) were loaned to me by Martin Bell.
Online Games Programming
The module consisted of two assignments; the first to create a turn based Card game in Java, and the second to create a real time networked version of Asteroids using C++ and Microsoft's Direct Play.
The turn based card game, was a simple version of 'higher or lower', of which each player took a turn at guessing the next card. A theme that I tried to follow for both games' implementation was ease of play. I didn't want to show any sort of IP Address details to the player, they either should connect automatically to a game, or be able to pick from a readable list.
From a coding point of view, the networking functionality was encapsulated on its own, with the view of applications' netcode to be able to be used again at a later date,whilst also hiding it away from the game code itself to make that easier to read and maintain.
This module focused on covering a wide range of Artificial Intelligence techniques within games. This example application shows a mixture of finite state machines and A* path planning to represent the scenario of a burgular, entering a restricted area. As the user (blue), it is up to you to evade the guards patrolling. If seen, the guards will audably warn you. If you comply and stop where you are, you will then be escorted off site, but if you run then the guard will give chase.
Not exactly a singular module completed at University, but actually a collection of libraries that I created to contain generic functionality that could be applied within any of my projects. Things like vector mathematics, font rendering, timers, or collision code, all could be shared easily between my projects making the work less tedious overall.
Second Year Projects
Programming for Visual Simulation
My favourite module of my forth semester at University,
this assignment had the brief of creating an interactive animation/simulation
program. I decided to make my 'engine', as much as physically possible
completely user defined. This meant that a single scene file would
define everything the a user of the engine could interact with.
How the scene hierarchy worked, what HUD buttons did, particle system
parameters, animations, meshes; all of these were stored within
a single scene file.
Noteworthy aspects of the engine were the complete
scene graph, and 'plugable' design of the engine. Components could
be pluged in easily (e.g. the animation and simulation systems),
and HUD buttons with 'standard' actions, that could have values
specified for their actions etc.
2D Graphical Programming
Now this module is why I came to University to do
programming. At last a module where we actually get to display things
on screen. I cannot emphasise enough how much I enjoyed creating
this assignment. The basic idea of the end program was to provide
a way to show off how our technology for rasterising polygons, lines,
etc. worked in a more interesting way than 'here are some shapes
I drew on-screen'. By far the most memorable part in development
was when I managed to code a line that was then displayed on-screen
for the first time. I think my mood could have been described as
more than ecstatic! Even though the line wasn't drawn at the right
I have plans to take my underlying code and apply
it to a game, seeing as I now have no excuse in the form of 'I can't
get anything to display on screen', so hopefully development on
that would be quick.
3D Graphical Programming
Following on from the '2D Graphical Programming', the aim of this project was to take the rasterisation
functions we'd spent the first semester perfecting, into 3D, by
creating a full transformation pipeline. This involved taking a
mesh through every stage of the process, from using model, view,
and perspective matrices, 4D geometric clipping, phong (and gouraud)
shading of all shapes.
Advanced features included the shading section of the assignment.
With texturing, perspective correct interpolation, and normal mapping
all included in the final product. An assignment I had enjoyment
creating from start to finish, which has nutured an interest in
graphics in my skillset.
C++ DirectX Game
As part of a university module, the task was to create
a basic game, to the design specified by the assignment. Essentially,
it's a very basic 'collect and dodge' game. Where the player must
collect crystals, and dodge enemies and scenery. Once all the crystals
have been collected, the game is complete.
Whereas the original brief was to create a completely
first person game, where everything was played on a 2D plane. I
however decided to make the project slightly different, and original.
I decided to make a 3D flying game, where the aim was to fly through
The main point of the module was to test our C++
skills, from the original semester of the double module, while also
learning how a basic game engine would be constructed. The production
of the game focused on creating a Visualisation module (which could
be replaced by an OpenGL equivalent if needed), and a main 'game
world' module, which was responsible for all of the game code.
Game Software Design
An entire module all concerned with how to design
programmes. I found this an enjoyable and interesting module on
the whole, learning the skills needed to have a 'standard' way of
presenting my ideas.
The assignment was clear: Choose a game, then choose
a system of it (be that graphics, user interface, game rules etc.)
and then analyse and design it using Unified Modelling Language.
Designing software before production is very much
a skill any programmer should have, even more so where programmers
will very rarely be working on their own, but within a team where
communication between team members is vital.
Working on this assignment, was enjoyable because
of two things, firstly I got to take a deeper look into one of my
faviourite games of the last generation, and secondly I got a glimpse
of exactly what the original team had to get through while making
Game Design: ICA - Create a Game Brief
Being a programmer, you don't often get a chance
to flesh out ideas about a whole game, so it was very refreshing
to get to do it in this module of my course. The basic ideal for
this module was to think up of an idea, then create the initial
pitch document that you'd show to people to get them interested
I'm not too sure whether the game would be considered
weird or 'too out there', as tutorial feedback gave me this suggestion,
but I'm happy with the concept as a whole, and allowing people to
read through it, backs up my opinion, as all the feedback I've had
is very positive.
Spare Time Projects
After deciding on Pong as a game to test my rasterising
technology while on a University break, I firstly updated it to
just iron out a few niggles I had first time round. The major addition
here was the option to rasterise by texturing.
Overall, the majority of development time was taken
up by this improving process, and of course adding new functionality
in the form of new matrix and 'game' modules. Transformations within
the program could finally be carried out, meaning I could have a
ball and paddle that move!
My collision system is very crude, and although
at the time of writing being less than a week into my new semester
I already know of a far better way to have carried it out. Development
notes would have to include how much my respect has grown for languages
such as OpenGL and DirectX, because my 2D rasteriser makes the game
go slow on anything bigger than a 300 x 300 pixel window. Also,
I'd like to thank Marque
Pierre Sondergaard's contributions for textures for the ball,
paddles and walls. He also did some background pictures, but texturing
an area that big brought the game down to unplayable levels, so
unfortunately they couldn't be used.
Ark Raider: A GBA Demo
Serving as my first game demo of anytype
ever, and a test of programming skills after my first year in University,
Ark Raider is a very simple overhead view 'Zelda inspired' maze game.
Built in stages, and scheduled to be completed in my spare time while
working an unpredictable shift pattern in my summer job, I'm quite
impressed with myself how I managed to complete it in such little
time and get a complete package together.
Programmed with the aid of the invaluable HAM GBA
development kit (www.ngine.de),
and in C, I'm quite embarrased at the state of the final source
code as I ran away with myself many a time and it's very unreadable
I will admit, even moreso now while in the second year of my course
where neat code is a very large priority, and something I now instinctively
look for. However it's a mistake I'll never make again, and just
one of the many things I learnt throughout the project.
Other things that need commenting are Nkem
Joseph Oyem's work on the main character, for first time sprite
work on his part, I was very impressed. While I also have to congratulate
myself on creating a collision detection system that works on a
per pixel basis, and one which is exactly the same as what was commonly
used in 16bit games, but I only found that out after creating it
for my demo.
To sum up, I'd like to add that when people say
you learn more from trying to make a game, than from just talking
about it, I for one agree with them totally now.