Category Archives: Academic
This project was done as a part of my honours-stage research paper. The overall idea was born from realizing how little flexibility animation in real-time currently has; while animation blending, ragdoll physics, and simple IK re-targeting techniques are commonplace, virtually little else in the way of full-character motion generation existed. The benefits such a notion were enormous both from a game-design and real-time perspective. So I decided to investigate current procedural animation techniques, and developed a procedural animation system of my own, which I later named IKAS (Inverse Kinematic Animation System).
The aim for this demo was to create a 3D scene using the Direct3D API. The application design allows the user dynamic control over numerous variables, such as the wave’s height, speed, size and texture scale. The code uses the concepts talked about in Frank Luna’s book ‘Programming in DirectX 9.0c’.
The application starts with a flat vertex grid and uses displacement mapping to offset each vertex over time. Displacement mapping itself is accomplished by associating each vertex with a displacement vector, these displacement vectors specify a direction for the Vertex Shader to offset (i.e displace) the vertices based on a defined length stored in the displacement map. The result is what you see below.
My original idea behind this project was to create numerous ‘types’ of water by using different rendering methods to show various styles and levels of realism. However this was out of reach considering the time frame we had available, so I eventually settled on using displacement mapping as my method for this project. Other techniques I investigated were noise-based water simulations, and I am working on implementing these along with added reflection/distortion effects within the demo.
All source code for the project can be found here. You will need Visual Studio and DirectX installed to run the project. Most modern gaming PCs should be capable of running the application at a smooth frame rate.
As a part of our university project we were tasked by Chunk Games, a games studio based in Glasgow, to prototype a game design pitched by Chunk themselves. With a team compromised of artists, designers, programmers and sound engineers, we had 11 weeks to spend on getting our group together, research and design the game, followed by 10 weeks of development.
The game was programmed in C# using Microsofts XNA. One of the key aims of Chunk’s pitch was to make the game playable for a variety of platforms from the get-go. Chunk were interested in the growing Windows Phone 7 platform and intended to target its next few titles within this market. As development began I was tasked with handling the initial framework, entity manager, graphics and physics of the game. Nearing the end of the game’s completion, we had created from the ground-up a demo for each the PC, Xbox 360, Zune and Windows Phone platforms.
Although the original design of the game was in 3D, due to Chunk’s emphasis on being a multi-platform title, it was switched to 2D for portability reasons. While Poppet is perhaps not the most visually appealing game, it prided itself on a puzzle engine that allowed designers and level scripters easy creation of a level using a dedicated XML parser. Our XML engine allowed for easy placement of items and level tiles, and allowed the ability to create new item types and its interaction level, dimensions, and many other gameplay properties. A texture could be assigned to a corresponding item or tile definition via a simple name-match method. Soon after the prototype was completed, Chunk were not only impressed by our prototype, but also took all working assets and resources that we created and decided to carry on development of the game themselves.
Code: Iain Everret, and myslef
Art: Andrew Tait, Graham Cottingham, Sarah Shuttleworth and Robin Ward
Audio: Louis Urbanczyk, Donald Macapherson
Design: Iain Everett
You can download and find the source code for our project here. You’ll need XNA 3.1+ and Visual Studio installed to run the project.
This short demo uses Simplex Noise both on the CPU and GPU to procedurally generate terrain. Everything in the scene is created at run time – no models are loaded in at all. The scene was rendered using OpenGL, with lighting, material and multi-texturing effects applied with GLSL shaders, using a simple but flexible modular framework I built throughout the project.
Simplex Noise is Ken Perlin’s updated version of Perlin noise. While generally less well known, it has a several advantages over classic Perlin Noise, such as being visually isotropic, being faster to calculate at higher dimensions and having a lower computational complexity in general, with far fewer multiplications required. In common with Perlin Noise, Simplex noise will produce the same output given the same input values, and by considering functions, such as taking the absolute values of the noise, a range of effects can be created.
A key feature I’m currently working is to implement water similar to my DirectX demo and perhaps introduce a procedurally generated skybox.
All source code for the project can be found here. You will need Visual Studio 2008+ and the tr1 extension from Microsoft to compile the application.
This demo was created during my very first experimentation with the PS2 Development Kit. The focal gameplay concept being the player having to destroy as many enemies as possible while trying to achieve a high score, with the speed and spawning rate of enemies increasing as with the score. The game was very much a success but keeping in mind the underlying concept there wasn’t much that could be done to develop the game further.
As for programming, one of the key methods I learned here was per-pixel collision detection in 2D, which was written from the ground up for this game. It was through this project where I truly grasped the idea behind a game framework, and began playing around with the concept of classes and how they would interact at a flexible level. As such, this project plays an imperative role in my learning process as a programmer.
All the source code for the project can be found here. I should note that you will need a PS2 Dev Kit to run and compile the project.
The aim of this demo was to show how the Vector Units of the PS2 can be used to create various lighting effects. Working on top of a framework which was provided for this university project, I implemented a hierarchical system for managing entities in the scene, as well as producing a range of interesting effects.
Animated Point Lights
Animated point lights which rapidly changing colour, size and position to give a realistic effect. The intensity of these faded over distance squared, acting only on a small area.
Ambient and Directional Lights
Ambient and directional lighting was implemented on the Vector Unit, using the normals for each vertex to calculate intensity.
Texture and Alpha Blending
Using multiple layers of geometry in close proximity allowed for textures to be blended, improving the overall appearance of the models. Various alpha blending algorithms were also used to alter the values of colours within the scene to intensify and smooth the models to fit within the rest of the landscape.
This being on the PS2, there was no real way I could record footage of the demo in action, I was able to take screenshots however using an inbuilt function within the framework.
The source code for the project can be found here. You will need a PS2 development kit to compile and run the source code.