Projects - Any work that Tom's done, right here. Resources - Anything useful, it might be made for Tom, but you might like them too! Home - Back to where you started About Me - All about Tom Hill, CV, Personal Statement, Other Interesting things... Contact - Speak to the man himself!

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 Year Project Report, PDF (1,643 KB)

'Proof of Concept' Application (1,578 KB )
Controls: WSAD for camera control, left click to move viewpoint, QE for up/down.


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.

ogp_Asteroids (1,167 KB)

Please unzip and run the game executable. This will begin an instance of the game. If there are no games to connect to, the game will automatically host a session. To connect another player, just open another instance on the same network. WAD keys for movement, and the Space key for shooting.

ogp_HiLow (293 KB)

Please unzip and run the card game executable by running the 'rungame' batch file. This will begin one instance of the game. Follow the on screen instructions to start a game. Another instance of the game may be started, and then connected to the other's hosted game.


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.
 (833 KB)

Please unzip and run the gamesai executable file. Once running, you control the blue 'trespasser' agent. Pressing the C key displays the red guard's vision.

Controls: WSAD for user agent movement.


Games AI
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.


Gen Lib
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

Name: Programming for Visual Simulation
Description: A 3D engine, with animation and simulation components.
Language: C
Tools: GLUT (GLUT Homepage)

Development time: March - May 2004 (8 Weeks)

Executable: (577 KB)
With the Executable, please take the glut32.dll file included with each, and copy it to your Windows/System directory, for the program to work correctly.

Controls: WSAD for camera control, left click to move viewpoint, right for zoom. Other controls are specified by buttons on the HUD.


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.



Name: 2D Graphical Programming
Description: An application showcasing 2D graphical techniques.
Language: C
Tools: GLUT (GLUT Homepage)

Development time: November - December 2003 (2 months)

Grade: A+

Executable: (144 KB)
With the Executable, please take the glut32.dll file included with each, and copy it to your Windows/System directory, for the program to work correctly.

Controls: Left Click - define vertex, Right Click - cancel polygon, Return - define polygon, N - clear all polygons, < and > - darken/lighten current colour, Numbers - select a pre-defined colour.


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 coordinates.

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.

Name: 3D Graphical Programming
Description: A full on 3D scene renderer, completely programmed by myself.
Language: C
Tools: GLUT (GLUT Homepage)

Development time: March - May 2004 (8 Weeks)

Executable: (813 KB)
With the Executable, please take the glut32.dll file included with each, and copy it to your Windows/System directory, for the program to work correctly.

Controls: All controls detailed in the console that accompanies the main window.


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.





Name: C++ DirectX Game
Description: A test of C++ and DirectX, mixed into a game.
Language: C++
Tools: DirectX

Development time: March - May 2004 (8 Weeks)

Executable: (1.46 MB)
With the Executable, please make sure you have the latest (9.0b) version of Microsoft's DirectX installed on your machine.

Controls: Click and Move mouse to control plane direction, W/S increase/decrease plane thrust.


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 a course.

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.

Name: Game Software Design
Description: An analysis and design of the Game Rules in F-Zero X.
Language: UML

Grade: A
Tools: MS Visio

Visio's HTML output: f-zero.htm (N/A KB)


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 the game.

Name: Pigeons Vs. Seagulls
Description: A Game Design Brief for a Module as part of my Degree. Contains, a game brief, supporting descriptions, and rationale.

Grade: A

Document: GDE_pigeonsvsgulls.doc (2.48 MB)


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 before production.

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

Name: Pong Demo
Description: A very simple pong demo using my 2D Graphical Programming rasterising technology.
Language: C
Tools: GLUT (GLUT Homepage)

Development time: January 2004 (1 Week)

Executable: (68 KB)
With the Executable, please take the glut32.dll file included with each, and copy it to your Windows/System directory, for the program to work correctly.

Controls: W and S - Up and Down for Left paddle, P and L - Up and Down for Right paddle, B - when ball not in play, begins play.


Pong Demo
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.

Name: Ark Raider
Description: GBA game
Language: C
Tools: HAM Dev kit (

Development time: May - August 2003 (3 months + 1/2 month preperation and research)

Executable: arkraider.gba (411 KB)
Emulator: Visual Boy Advance (

GBA Controls: A - shoot, B - jump, D-pad - move.

Emulator (VBA) Controls: Z - shoot, X - jump, Arrow Keys - move.

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 (, 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.

Contact About Me Resources Projects Home