A selection of random bits and bobs that have been knocked out over the years. Not all of them are particularly good, but never mind. Some of them even contain source as well....



Animation Blending using root offsets

A little test of animation blending using the output data from XLD. Nothing too fancy here, just making sure that the animation blending is working correctly. This is a slightly revised method of handling the offset of the models root, this time using quaternion differences to track the changes. (the other blending example below simply uses a y rotation change to track the root. This can easily make adjustments to changes in incline. Evetually i hope to use this to blend several animations on different inclines, but thats a little way off yet)

Some of the theory involved is covered here



Quake 2 MD2 Loaders and Maya Exporter (+ source)

A selection of MD2 (Quake2) Model loaders and exporter for Maya. The loaders range in complexity from the very simplest upto a version that supports instances, vertex buffer objects, staggered updates etc. The result is lots and lots of models with frame-rate to spare....



Dot3 Bump Mapped Blend shapes (+ source)

A highly optimised blend shape example. The normals and tangents are dynamically calculated and Dot3 bump mapping is applied. Funny things are done with pointers to try to keep things fairly fast. (Model by Dave Hunt)



Animation Blending with offsets + Skinning

This little example is a proto-type for XLD and what much of the Maya Exporter Factfile was based on. The exe loads a number of animation files, can blend the animations using quaternions, and it also tracks the root offset to allow you to dynamically steer the character (cursor keys to steer, 1,2,3,4 etc to switch anim cycles). The only code here used to actually control the character, simply turns it left and right. All other movement is aquired from the original animation. In effect, it is the animator that decides how the model moves within the game, not the programmer. This means that things like feet slipping occurs less often. There are a few random animation controls left in the data files, sorry ;) But they do hint at the root offset that is actually occurring.

This was the prototype for XLD, and the basis for much of the Maya Exporter Factfile.... (Model, texturing and animation by Dave Hunt)



DirectX / OpenGL Dll based renderer test

This was a little test of mine of a dll based renderer to provide a mechanism to switch between directX and openGL. You might have a few problems with OpenGL if you haven't got an nvidia card since the dll is currently specialised for a GF4. It has a few more additions in the way of shader support, but the bulk of the work has been done.... (Model by Marcus Doringer)



Lua Scripted user interface for glut

One of the set projects for my MSC was a particle system. I created a scriptable node system to handle the particle systems. I then thought it would be quite cool to create a simple text input box to allow me to get and set attributes on the seperate nodes. That grew into the gui demo shown here. It uses fmod for playback of the mp3's and sound effects. Theres even a simple outliner and attribute editor you can use after creating the particle systems to edit the parameters.

This gui is written entirely in ansii C and openGL. It runs under both linux and Win32 (only the win32 demo is here). I made it look very Windows XP like to confuse people working in our linux labs...... ;)

A little word of warning though, it's a little bit buggy so it might crash (the script editor is very dodgy). There are a few notable bugs, like only being able to see the C drive; but it's quite amusing...



A simple glut based editor framework (+ source)

This is a really simple scriptable GUI and a really simple scene graph. SetAttr and GetAttr functions allow you to set individual attributes on each object (limited to numbers only). The program also features selection using the back buffer, multiple viewports, a command line, start menu bar, menus etc. It's not exactly the greatest code ever written, however it is designed to be very simple to use and understand how it works. Source code included.


Creating Simple Buttons using function pointers (+ source)

This is a step by step tutorial showing how to create basic buttons in openGL and C using linked lists and function pointers.



Portal renderer and input capture for action replays

A simple portal renderer that also captures keyboard input for playback. use the keys :

a,s,d,w to move about
q and e change the height
space will create a sphere
c will toggle the camera view

right mouse click will start playback of the captured input (you might want to move about a bit first though). Left and middle mouse buttons can be used to navigate the exterior camera view.



Dot 3 Bump mapped OBJ loader (+ source)

A series of 10 step by step tutorials on how to load an obj file. vertex arrays, tangent space and Dot3 bump mapping is also used.



Using register combiners to offload some normal calculation

A bezier patch that uses nvidia register combiners to help calculate the normals of the patch. It's a bit hacky, but should work on Geforce 1 upwards. (May 2001)



BSP Tree

BSP tree. Well, i guess we all have to do one at some point. This uses nvidia register combiners to create an appalling bad bump map effect on the walls. The collision response is pretty much non existant. (June 2001)



Stencil Shadows

Part of my third year innovations project at university. This is a stencil volume shadow example. Other parts of the project included the standard reflections, simple shadows, glu nurbs etc. (March 2001)



Skinned NURBS Surfaces

An example of a skinned Nurbs Bunny rabbit. The animation data is bvh. Switch cycles with 1,2,3 and use the GUI to change the LOD. The NURBS surfaces are calculated using a method of lazy calculation, (ie cache everything, do as little wowk as possible). If you ever wondered why Quaternions are generally good for animations, then this is a good example. The animation was done entirely using euler angles (well, I was young and naive....), this means the bones have a tendancy to do horrible rotations the long way round. Quaternions basically solve this and make it possible to blend the cycles.... (May 2001)



BVH Motion capture viewer

This is a small application written using OpenGL and MFC. It allows you to view BVH motion capture data. Thanks to Dusty for donning the mocap suit, and Adam and Andy in the mocap suite. (Access Mocap).

This was a part of my final major project on my Ba degree. (May 2001)



Shonky Space Invaders

Well, i was bored one summer and decided to knock out a quick game of space invaders. Written in OpenGL, Win32 , DirectX for joypad and sound support. It's quite nasty hacky code and has the tendancy to crash if you've not got a joypad. So, afraid it's a screen shot only.


Boona Taxi

Mike Bonnington deserves most of the credit here. He did all of the modelleing and texturing, gameplay code etc. The only bits i handled were the model loading, and the code for the gloss + environment maps and also the texture loading. It's fairly cheesy and a bit simplistic, but we kinda wanted to make boona racer look a little better to show off some of the car models. (the choice of using dxf files in the original boona racer was a truly dumb idea!) (March 2001)



Metal Squalid Gear

A four week 2nd year university project (May 2000) where we attempted to make something animate. As often happens, this is again an example of how not to do things ;)

The code is generally fairly shonky, so if it crashes, errr, sorry. I programmed the objects, texture stuff and a few other bits and bobs. Mike bonninton handled the level data and editing stuff. Martin Johnson handled the game logic code, and also created the most impressive if statement of all time.

The models and textures were handled by Martin and Mike.



Boona Racer 2000

Second year group project (March 2000) where five people, Mike Bonnington, JP, Arthur Yarwood, Eike Anderson and myself decided that programming a car game would be a good idea. This is a really good demonstration of the worst way to write a game ;) The code ran on Windows and SGI Irix.