Perlin Noise: Homebrew Video

Tada!

Perlin Noise: Project Video

Here’s a video peeky at my finnished console devlopment assignment. Sorry about the quallity. Enjoy!

Perlin Noise: On Homebrew

Just testing the homebrew PSPSDK. I’ve ported code from my Console Development assignment to the system. The result is not identical to my assignment but has proved the tool set. Here’s a little piccy…

The SDK is fairly easy to develp with. There is enough documentation to be getting on with and some good tutorials in the making.

Homebrew: Hello World

I know its not much to have written a ‘hello world’ program but this marks the start of my homebrew development on the PSP and NDS. As proof…

PSP

NDS

De Blob: University Deadline

Sadly I didnt get all the features in that I had hoped for but considering the time constraint and the amount I have learnt over that past two and half weeks I’d say that this project has been a success. I’m sure the blob will continue. It would be nice after the amount of time already invested to have a really solid demo from it all.

There are currently a few bugs but with a little extra time they should be fairly straight forward to iron out.

De Blob: Is Alive

Blob in game with “True Axis” physics integrated and a niffty chase camera. The blob can move using the mouse, the calculations of which are done in camera space. The blob can jump when on the floor and has differnt physical properties applyed when in the air.

Getting quite good at programming camera controls now. Hopefully the quaternion camera I have planned for the map camera wont be too hard.

Next is culling and shaders, then as many game mechanics as possible before the deadline.

:)

De Blob: Scene Loader

Just a sneek peek. This is using my new scene loader, mesh loader and texture loader. Both the textures and meshes are resource managed, and the scene is stored in a graph heirachy. You can see that the positions are not quite right yet, but the correct textures are there and alpha is working.

Update Aug 10, 2009

The positions have now been sorted as have most the texture issues. Next task is to add support for other object types, and integrate the physics engine.

De Blob: Mesh Loader

After allot of work on my own engine of which I had no visible results, my first displayable output is proof that my mesh loader is working. The loader is not actually designed to be part of the engine but was required for a university project. These screen shots show the loader working.

The meshes are from the DeBlob game and my current project is to remake certain features of the game using the DirectX graphics API. The mesh format is part of the OGRE API. Eventually the engine will contain its own mesh format but for this project OGRE’s format will do fine.

As you can see there are still some errors on the blob mesh. This is due to material settings and shader programs not being implemented yet. The geometry is all correct as is the texturing on the cathedral mesh.

Terrain

This is a very simple program. The idea was to get used to working with DirectX. This particular instance is a terrain with the lighting baked into a light map. Currently the engine supports two different types of terrain generation and five lighting modes. There is also terrain/camera collision and movement.

Space Invaders – Bluetooth Network Play

This project was my first experience using Java. I was required to create an application which utilised some ‘connectivity’ in its functionality. I decided to recreate a classic with a bit of a twist. The game is space invaders but played with two players. If either player dies the game is over and the other player wins. However, each player can effect the others screen by attacking the coloured invaders. This will perform an action depending on the colour of the alien. For instance, the red alien causes the invaders to go into berserk mode and the yellow increases their speed.

This was an ‘A’ standard piece of work, and a first experience using Java, Net-beans and any sort of Network programming.

Final Software Renderer

My renderer running at full wack. Some of the features were simplified in an attempt to raise the frame rate to its highest possible. This is something I would like to revisit in the future.

Famous Five – Unreal – Gameplay Video

This is a video of the final game running. This was an ‘A’ standard piece of work. Unfortunately the video quality is quite poor and the screen recording software messed up some of the graphics. For example the large control pad button images were not actually present on the final game.

Primitive Editor – Features – Version 0.0.0.1

Screenshot of version 0.0.0.1. This is the version being used for development at the moment. There are no plans for it to be released as Middleware as of yet.

API Feature List:

• Draw circles, Rectangles and Vectors using the Primitive Batch object
• Draw custom objects created in the Primitive Editor and add rotation and colour
• Batching of Line Lists

Editor Feature List:

• XNA running in a windows form
• Display grid
• Lock to grid
• Grid resolution control
• Loading and Saving objects.
• Adding lines using the mouse
• Hold shift to add multiple lines

Pink Dawg – Competition Winner

Competition Winner – X48D – University of Derby – Summer 2009

Role: Team Leader, Programmer, Designer

This is the entry to the X24D competition held at University of Derby, summer 2009. I was part of a team of four which was randomly selected moments before the starting. The competition ran for 24 hours, without a break. Our team consisted of two second year programmers and two first year programmers, whereas other teams were made entirely of graduates. In spite of some tough competition this entry placed 1st and won each member in the team £60 of Amazon vouchers. For a playable version please ask via a message.

Responsibilities:

• Contribute games design idea’s
• Sehedule and Manage tasks through out the project lifetime
  
• Communicate with the rest of the team to ensure maximum potentual is reached
  

Technical Contributions:

• Draft out the systems and achitect the code from a high level
  
• A.I flocking, seeking and state machine
• Contributed to the game play programming, debugging and balancing.

My role in the team was to manage the production process from design to prototype, to final application. For this I used the time/project management skills I have developed over the last year at university. I was also heavily involved in delegating tasks and directing the team.

My technical contribution came from my knowledge of OOP and AI. A core mechanic in the game is created in the behaviour of the virus objects. The A.I for these is a combination of flocking and seeking algorithms mixed with state machine. I hope to experiment with A.I. programming more later this summer.

Our success was down to good ideas early on, and brutal decisiveness, pushing the team to achieve the most in the limited time frame. We could have achieved more if we had been blessed with an artist. As it was we had to take some time to produce our own art.

This is the entry to the X24D competition held at University of Derby, summer 2009. I was part of a team of four which was randomly selected moments before the starting. The competition ran for 24 hours, without a break. Our team consisted of two second year programmers and two first year programmers, whereas other teams were made entirely of graduates. In spite of some tough competition this entry placed 1st and won each member in the team £60 of Amazon vouchers. For a playable version please ask via a message.

My role in the team was to manage the production process from design to prototype, to final application. For this I used the time/project management skills I have developed over the last year at university. I was also heavily involved in delegating tasks and directing the team.

My technical contribution came from my knowledge of OOP and AI. A core mechanic in the game is created in the behaviour of the virus objects. The A.I for these is a combination of flocking and seeking algorithms mixed with state machine. I hope to experiment with A.I. programming more later this summer.

Our success was down to good ideas early on, and brutal decisiveness, pushing the team to achieve the most in the limited time frame. We could have achieved more if we had been blessed with an artist. As it was we had to take some time to produce our own art.

Breakout

Ok… so… I felt that I cheated a little with the pong game so I took a few hours to write a Breakout clone. Problems started to arise when trying to write a collision response as computation required is quite large for a small device. For this reason i started to thing of games which wouldn’t rely on collision detection on a higher complexity than what the Game API gives for free.

Pong

As a simple warm up to using Java I decided to follow a quick game tutorial on the net for developing a game. The one I found was for a pong game and covered the basics of the Game API.

Title Screen – Main Menu

Just adding the finnishing touches. This title screen has been composed from a shot from ingame and a bit of photoshop wizardry. I think it make the game feel allot more complete.

Features

Here are some of my latest features. I’ve made use of the emitters to highlight when a character is interactive. This is done witht he arrow, and i think it achives the effect well. The arrow is triggered by script when the character is close enough. The same technique has been used to get the smoke on chimneys, however there is no need for script in that case.

I’ve also reimplamented the dog. The behavious are not fully integrated yet so whatch this space.

Triggers

Another feature for my game that the unreal engine provides is the abillity to trigger objects through user input. The picture displays my avatar triggering a door to open. This feature could be used in quite a few places in the final game.

Another interesting possibility is a UI that displays the command options available to the player.

Modelling

This week I created a Penknife in Maya as it was a requirment for the assignment deliverable. After this experience I’m gald to say that I’m a programmer and not an artist.

Player Feedback

Already during the development of my game features I have been trying to embrace the idea of giving the player allot of feedback. My main concern up until now has been to utilise an inventory system that keeps the player informed by what inventory item is currently selected. I’m still very keen to put allot more information on the screen regarding elements such as story and player controls. This is important as it provides enough feedback that the player can use to complete current objectives and move on in the game.

Depth Sorting

Another little trick I have used is to sort my polygons via depth. In order to make the flat shaded version display (semi) correctly I want the front most polygons to be drawn last (on top). This process is useful for now but I think it will become redundant once I have a depth buffer working. I’m using a standard STL quicksort function to sort my polygons based on the distance from the camera. As you can see by the comparison many of the errors have been resolved by using this technique.

Object Material

One of my additions to the tutorial work set this semester is my material properties. Each object contains a material which defines the reflectance co-efficient of each component. The components are Ambient, Diffuse, Specular and Specular Attenuation Modifier. The first two are pretty straight forward they are set to whatever you want the materials reflectance to be modulated by. The same goes for the specular, however there is an additional component for specular which defines the size of the shine on the object. This is the attenuation modifier. Using different combinations of these values can lead to a large number of possibilities when defining an objects look.

Basic Lighting

First thing I did with lighting was to implement directional lighting. I used the dot product of the normal with the inverted light source direction to get the attenuation of light. Assuming for now that the all the reflectance co-efficient for the object are 1, we can use the properties of the light to provide the polygon with its colour.



For example using two directional lights (one blue and one red), you can achieve a doubly lit object. Adding ambient light is a simple extension as it doesn’t actually require any calculation of direction. The colour is simply modulated by the current colour. This won’t be particularly useful until I have my object material set up. The spot lights are also easily implemented. Instead of using the direction of the light, you calculate the direction using vector subtract of the poly and light positions. You can then also modulate the amount of light hitting the object depending by how close the light is to the object.



This is a point light. The bonuses of having a point light might not be apparent in the picture, but the light can now be moved all around the scene to get some interesting dynamic lighting effects.

Flat Shading

Getting flat shading to work in my application was a few very simple steps using the GDI functions. Instead of drawing individual lines using DrawLine(), I upgraded my code to use FillPolygon() which drew the entire polygon to the screen by taking the three vertex points which make up the polygon.

Blackface Culling

In order to implement blackface culling, I simply took two vectors from a single polygon by subtracting the vertex positions from each other. I then performed a cross product to gain the surface normal. Using a dot product between the surface normal and object to camera vector you can deduce whether a polygon is front facing or back facing. I simply mark a bool in the polygon to say that it should or should not be drawn.

I can think of an optimization here which is to remove the back facing poly from the pipeline completely at this stage. Once I am ready to begin optimisation of the algorithmic level, I will take a closer look at this idea.



The results are very clear when working on a cube. More complicated models have quite as great benefit looks wise but it defiantly improved my frame rate a little.

Software Renderer: Rendering Pipeline

I have a 3D wire frame render on the screen. With a little more time I was able to get him spinning on the screen. I also ported a timer class from a previous project into this one so I was able to monitor the FPS for my app.

Perlin Noise: Project Development

By investigating the architecture of console platforms I have developed an understanding of low level system processes. After taking part in detailed exercises I can now program in MIPS assembly and use my knowledge to optimise code for the PSP. Using the PSP development kit I have deepened my understanding by observing the compiler output and debugging tools.

Project Feature List:

• Texture generation using ‘Perlin Noise’
• Textured geometry
• Gravity simulation on multiple textured particles
• Random colour generation for background, fog and ambient light
• A loading screen
• User input for camera control, gravity properties, particles positioning and texture
• generation
• Use of the FPU/VFPU

By recompiling with #define _DEBUG there are additional features available:

• FPS counter
• Number of objects display

This does put the text size over the specification limit

Final Size:
Filename  Text  Ro   Data
Main.o  2200  604  8
Perlin.o  1356  28  0
Gravity.o  536  16  0
TOTALS  4092  648  8

As you might be able to guess from looking at the text size I’m very happy with how much ive
accomplished within the limits.

Demo Party Trial:

Above: Demo Party 1 Competition Entry

The very first thing I got presented to the screen was 5 minutes before the first demo party. The output wasn’t really more than noise on its own. I found shortly after the demo party that by changing parameters, I could change the look and got something more like

Above: Different properties and texture settings

Above: Clearly something was wrong but after some debugging I got something more like what I was looking for.

Above: I got a very nice set of effects by playing with ABS() functions taking the noise function as the input.

Above: As it was something I had received feedback on in the demo party I tried experimenting with colour. In the example below I’m actually using different functions for each colour channel.

Geometry:
I spent a long time playing with different functions and ways of manipulating the Noise output but then I began to worry that I didn’t have anything to show at runtime. All the calculations for Perlin Noise would need to be done at the beginning of execution else my frame rate would be unacceptable. I decided to start with some simple geometry and stuck my texture on it. Using the cube demo I made changes to the texture functions so that my texture could be generated and rendered on the cube. I also added support for animation of the texture on the cube. This meant that I could load a few textures at start up and then the program would animate through them, rendering each one on the cube before starting at the beginning. In an attempt to make the demo more my own I modified the Vertex format and created my own quad geometry.

Above: In this version I used the inverse ABS inside a TAN function on the Perlin Noise output to get a higher contrast and inverted colours.

BBC Blast / Pie-parazzi

Derby Games Studio – BBC Blast Project – summer 2008

Role: Programmer

The project specification was to develop two prototypes from existing game designs. Of the two prototypes the one which held the most potential would be taken forward and developed into a complete game. The game designs where provided by local secondary schools that had taken part in the BBC Blast competition and the final game was presented on the big screen in derby as part of a BBC Blast event.

Responsibilities:

• Contribute games design idea’s
• Implement design idea’s in code
• Communicate with the rest of the team to ensure deadlines are met

Technical Contributions:

• Path finding system, including flocking
• Audio programming
• Contributed to the game play programming.

Dark: Level Editor

Here’s a little video demo of the Dark Level Editor in action. By making this at the same time as the engine I could create content for the game really easily. Its the first tool I ever made and I was quite proud of it. :)

Dark: Gameplay Video

He’s a video of my Game Design assignment (2008). This project required that I develop an engine in XNA with support for 2D shadows and collision detection. I also spent a large portion of time devloping A.I. for the bad guys.

Engine Features:

• Collision Detection (Boxes/Spheres/Lines)
• Dynamic and Static Lights
• Shadows
• A.I Path Following
• A.I State Machine
• Line of Sight using Bresenham’s Algorithm
• Game State (using Microsoft State Managment Example – XNA Creative Club)
• Streaming (loading level data from a file)

Game Features:

• Player Movment
• Wandering Enemies
• Enemies Chase Player if the Player is visible to them
• Pickups/Collectables
• Dropping Flares (creates a light at position)
• Lives which reduce on collision with Enemy

Bucky O’Hare Remake: Gameplay Video

He’s a video of my Ludology assignment (2008). It’s a remake of the Bucky O’Hare computer game for the NES. During devlopment i tried to stay as true to the original game as possible. Features I’ve implemented:

• Platforms
• Weapons
• Special Abillities (and Charge Bar)
• A.I bad guys
• Animation
• 2 Playable Levels
• HUD
• Lives
• Health

Block Fall: Overview + Screen Shots

This was my first project using C++. Infact my success with this project is the reason i pursued Game Programming further. The project took 5 full days in total, however I did allot of prep work in order to figure out how to tackle particular programming problems. As well as my first C++ project, this was a first for game development theory, and the standard of code suffered for it.