A big chunk of the MSc Computer Games and Entertainment course revolves around building a game engine and a first-slice game demo to show off its capabilities. This was a group excersise where we were to form two teams; the Engine Team and the Demo Team. We were free to roam and help achieve milestones on either or both as we saw fit. We each found our role; mine turned out to be script lead on the Demo Team, and later animation scripting on the Engine Team
While the Engine Team started assembling the "Gold Engine", the demo team took to Unity3D and started working on a game demo which would later be ported to the Gold Engine once it's ready. We started out with drawings and documents, and several (good) proposals for what exactly we were to develop. We ended up with a first-person "puzzler" game, like Portal without the portals and no portal gun. I believe the following has been agreed upon 100%: "You are in a place, and you're trying to get out. Go!"
We mocked up a single playable puzzle which makes use of lift-like platforms, metal crates and an electromagnet which the player can use to build a staircase up to .. the upper part .. of something.

Natural Interaction (NI) using Microsoft Kinect and the OpenFrameworks NI Libraries to sculpt a piece of terrain in 3D

Most fun project I got to work on during the M.Sc. course. I was responsible for handling and interpreting input via Kinect as well as UX/UI. I worked with Petr Tomicek and Tudor Nita who were responsible for rendering and setting up the application framework which held the whole thing together, respecitvely.

A quick demonstration of terrain generation using an implimentation of Perlin noise. This done in collaboration with Will Masek. We were team Will (him #1, I was #0; I then I started using my real name which solved a lot of problems).
Will focussed on a DirectX framework for use in this and future projects, as well as the generation of a vertex mesh. He then exposed a function by which this mesh could be generated using an array of input values for heights, and rendered as a triangle-strip with texture(s) wrapped over the top. I, Willem, set out to develop an implimentation of the Perlin Noise algorithm to feed height values to this function in order to generate viable terrain.

A deep-ocean wave simulation using sine waves. We were to use DirectX 9, C++ and rtvs, the Mathemator, Gareth Edwards work.
A lot of the heavy lifting is done by algorithms produced by the Mathemator. The majority of the remainder is based on work by Tudor Nita I worked backwards from this, stripping it down to a point I could grasp all mechanisms involved. In some cases I found more elegant solutions to achieve the same effect, in others, either Mathemator or Tudor's (well documented) code was hard to beat in simplicity and elegance.. so it was reused.

This ws also my first integration with AntTweakBar; it will not be the last.

The simulation morphs a triangle mesh by adjusting the height values of vertices according to the average height value of 8 separate sine waves. Parameters for each wave can be adjusted (thanks, AntTweakBar) as can the colour values of the wave and speed of animation.

For each frame, normals are recalculated and averaged (thanks, Tudor) and the material recoloured to suit.

Thanks also to HipShot @ www.zfight.com for the awesome skybox texture.

"Richard-bodies" - A 2D physics engine written in JavaScript and rendered via canvas. Demo here!

Turns out it's all just maths. Haven't implemented all the features I wanted to due to time limitations. Has broad-phase and polygon collision detection. It has a rough concept of mass. No rotation of rigid bodies yet.

This was a bit of a nightmare .. I loved it.
The problem here wasn't the fluid simulation itself, but rather the limits of OpenGL ES 2.0 and GLSL v1.1 as supported by current iDevices.

The idea was to take an existing fluid dynamic simulation, and port it to run on an iPhone/iPad. For this, we found some great work here http://prideout.net/blog/?p=58 and fell down the iOS rabbit hole to start our porting adventure.

On this project, I had the opportunity to work with Per Griffiths; we spent many hours looking at a small screen displaying a blue dot, and a very static white splat near the bottom.

Even though we managed to get 99% of the code ported to GLSL v1.1, compiling and running in an OpenGL ES 2.0 render loop on an iPad, there was one single GLSL v1.5+ function we were unable to find a suitable substitute for in GLSL v1.1.
Since we spent a lot of time on this, we kept at it for some time after the project deadline (and an akward final presentation) had come and gone. In the end, due to other demands on our time, we had to put our hands up and concede defeat. We were not able to achieve a working port. We do not, however, see this project as a failure. We were both content with the outcome in terms of how much we managed to learn. We both gained much knowledge of GLSL v1.1 and its limitations; unfortunately though, knowledge is invisible and doesn't display well as HTML5 markup either.. so I hope that future work will allow us to flex our GLSL

This was a native iOS application, so UIKit was explored too, but barely used.

"Write a 2D game using OpenGL and C++"; this was fun. Having had my head re- wrapped around OpenGL and C++, I set out to make a classic, top-down, space shooter scroller game.

There isn't much to say about it, but I'm quite happy with what I was able to accomplish in a very short space of time (~1 week while working part-time and attending Uni). The code can be seen on my github account as linked to above. The name, "AltitudeZero", is a play on fact that the game is written using 3D techniques, but simply sets the depth (height from the game perspective) for all game-objects to 0.

An L-System. (If you don't already know what that is, you probably don't need to) .. that said, this program draws lines based on text in config files, by using a string to start, and doing recursive string replacement according to rules specified, and then interpreting each character in the resulting string as a "command": move and draw, rotate, start branch and end branch .. more or less. It works and the code for it can also be seen on my github account. We were asked to use C++, DirectX 9 and a library called RTVS which I re-wrote into a unity build.

We were given the assignment to produce either a demo showing integration with a middleware of our choosing (Box2D and Bullet being the most prominent options as these were covered during the course) or write a useful tool. I dug in for the latter.

During lectures there was mention of "impostors" or "sprites" as I know them. These are still used today in games as a means of saving resources when drawing distant objects (instead of 3D models) where you can get away with low detail. I remembered rotating a QuakeII quad-damage model at 30 degree angle steps and making screen-shots to assemble them into an animated windows cursor, for personal use back in school, and thought a tool do do this kind of thing for you would be useful, thus: Impostorisor was born.

The Tool takes as input a 3D model in .geom format (Andy Thomason's work) and spits out a single image with a grid of frames at stepped angle rotations of the input model against a black background. This project saw me step into the world of OpenGL (similar to DirectX, so not totally new) and re-acquainted with my good friend C++. It looked different after years of PHP and JavaScript.

This delves into the use of agents within Google’s SketchUp, an entry level CAD package. It explores the extension of SketchUp functionality via the Ruby API. It seeks to allow users to turn components into intelligent objects, capable of reflecting user-defined personalities by means of distribution. It is a step towards having tables and chairs sort themselves into appropriate layouts, taking the mundane task of spatial distribution away from the architect. No agents were harmed during the development of this software.

I hope to make the power of Agent available to the casual CAD user. The ideal outcome is to create a tool for Google SketchUp which allows the user to turn 3D components into intelligent objects with relative ease. These objects should be capable of aligning, distancing and orientating themselves in relation to their peers according to behaviour sets specified by the user. The desired result is that these components can achieve a “good” distribution on their own.-

During my first year of BSc study, I was given the opportunity to work on a small project for a company (then) based on campus at UEL. The inital project was simply a project management application, to manage files and links between them to ease the use of MicroStation, a CAD package in use by the architects in the studio. This then flowed over into development of Site Capacity, and an indefinite contract with them (which lasted 5 good years).

Site Capacity is a tool used by the practice to aid in quick generation of urban layouts. I was fortunate enough to work on this with Renee Puusepp. It involved programatic distribution of pre-created geometrical objects along user-defined paths. It also touched on Business Information Modeling (BIM), essentially just embedding meta-data into the geometry for better programatic management and evaluation of constructions.

This project introduced me to agile development methods, extreme- and pair-programming. It was the first time I got to use an API to a 3D environment , and also the first time being paid to do coding.. happy.
Much thanks to Frank Leonhardt both a consultant to Slider, and lecturer at UEL, for the introduction to Slider, and the kick-off to my career.

At the very end of a 2-year course dealing purely with syntax and usage of several programming languages along with various database connectors, we were given the opportunity to write a database system .. or a 3D game. This second option would be wholly self-taught. We had, if memory serves, 5 weeks.

The hardest part was the first two weeks' total lack of progress. It was an individual project; myself and one other candidate were the only ones to take up the challange. We combined research efforts until we found the DirectX SDK and the accompanying sample code as a starting point. He went FPS, I went flight-sim.
The end result was a 3D cube sky-box with a nice wrapping skyline and a textured floor (which tiles nicely, thanks 3D Studio Max) containing a .x model of an aircraft somewhere inside it. The craft position was fixed in x- and z- axes, but was free to move up and down on y. The illusion of movement is created by constantly adjusting the texture offset on the floor. Height is restricted by means of an engine-stall, and a crash at the bottom.

This was my first encounter with 3D graphics. It also incorporates sound and UI elements. All sprites were created by myself using MS Paint.
I remember scratching my head about why 3.14 ("wait, that's pi!") rotated the reversed model to face the right direction, and not 180; first encounter with radians.

With limited knowledge, and limited graphical capabilities, a game was written..
There was no internet access (I would only become acquainted with the WWW a year or so later); things were figured out. Knowledge of peers and teachers was drawn upon. Non-blocking key input (i.e., not readchar) was a key discovery (no pun intended). I also managed to figure out the logic of a game loop, years before I would learn the term.

This was my first exploration of 2D coordinate space and collision detection. It was also my first attempt at AI. I learnt very quickly that a "perfect" AI was boring and frustrating.. that you had to build in flaws or randomness to make the game beatable.
I also learnt a bit about game dynamic here. The player who was "it" needed some advantage. Leaving the screen at one edge, saw the player enter from the edge opposite, pacman-style. This would allow for an infinite chase across screen-space, so the "it" player was made slightly faster.
Land-mines were also added .. the running player could place a pixel of its own colour at the press of a button. If the chasing player hit it, he would be spawned again at center-screen. Mines were limited to 3.