Here’s screenshot of the work I’ve done so far on creating a world editing tool. It’s written in C# using the excellent OpenTK library. With this utility I will be able to create sections of the world from tiles stitched together at any of their anchor points.

You may remember previously I talked about using generated terrain with realtime level-of-detail. That was when I had decided to create a more ‘open’ world to explore and when the game was going to be a vehicle based strategy game.

All change!

Well, that was then and this is now as they say. Now I have settled on the idea of an RPG with some design features which have interesting and beneficial side-effects.

Camera

How it will work

The camera will be third person and always looking down at the character. This will be true even though the camera can be moved up and down. When it is in the furthest up position it will be almost overhead and when it is in the furthest down position it will be almost level with the character’s head. The camera will be able to rotate through the full 360° and be able to zoom in and out by a set amount.

Benefits

The obvious benefit is the restricted field of view and therefore the finite amount of game world in the viewing volume at any one time. Firstly, the lowest position the camera can be means it will never quite get the horizon in view. Secondly, as the distance you can zoom out is limited, the camera will never have a massive field of view.

The Well-trodden Path

How it will work

The world will not be free-roaming. It will appear to be free-roaming in as much as the real world is free-roaming. For example, you could climb up that sheer cliff face with the right equipment but it’s far simpler to find another way up. Therefore the landscape will be designed in such a way as to keep your character to the defined paths and corridors. This makes the game become more ‘on the rails’ without feeling like it has been forced upon the player.

Benefits

Doing this means the world can be defined more rigidly and therefore there are less game engine rules to write. If you can’t fall down that well then I don’t have to write the falling routine. Much simpler to put a wall around it.

Blocks and Sections

I’ve been thinking of how to create the world and there are a list of game features I want to implement.

1. A seamless world. No loading screens whilst in play.
2. Re-use of meshes.
3. Least complex editing tools.

The solution I’ve come up with to address all of these features is to build the world out of 3D ’tiles’ which are linked together. Tiles will be linked into sections and sections linked together to form the world.

Seamless World

As the character and the viewing volume moves through the world so the ’tiles’ just outside the view can be loaded up ready. As they move out of view and then a distance away they can be discarded. All this means that the parts of the world which are in memory at once is kept to a minimum. Moving through a very large world should be possible with this method.

Mesh Re-use

Tiles which are the same geometrically such as the section of a wall or ground would only need to be loaded once but could be referenced by the world definition multiple times. This has the advantage of low memory usage and the fact I won’t have to create so many meshes. Imagine a courtyard with a fountain in the middle and a wall surrounding it. With this method I would only have to load possibly 4 meshes and their textures. They would be the floor, the fountain, wall sides and corners. The wall sides and corners would have the relevant rotation applied. In many ways this is much easier than 2D tiles.

Editing Tools

As I want to spend as much time programming the actual game code and the least amount of time possible coding supporting tools, I want to make it as easy as possible to edit the game world. Using the tiling method and only editing once section at a time means the tool can be less complex.

Next Steps

Now I am at the point where I have to define the world data format, the file and data structure which will define the world. I’m also looking at mesh formats and object description files. The next milestone will be to get a prototype of a world section up and running.

To tie all this together needs at least a file to describe all the relationships and other things such as lighting, effects etc. So it seems logical to turn objects created in a modelling utility into an internal format packed together to form a game level. To be honest I have a lot of it mapped in my head and it’s way too much to write here at present. I’ll serialise it as I start to implement it.

To work on the level files I’m going to need a utility which I had thought of doing as a GTK# app in Monodevelop but my work machine is running Centos and it’s just been a total pain trying to build all the dependencies. I’d still like to. Maybe I need a laptop I can bring to work

I’ve coded up a loader for the .obj format http://en.wikipedia.org/wiki/Wavefront_.obj_file
It loads in the geometry for the vertices, normals and texture coords along with the materials and the lighting model. I started with rendering a flat shaded model followed by getting the texturing working. For some reason the .tga files seem to have some of the wrong colours. Also some of the texture coords seem to be off but not that many. I wonder if it’s an error in the file.

Anyway, here’s another screenshot:

The latest things I’ve added are, landscape rendering, texture loading, MD2 model loading & rendering and font rendering.

Landscape

I’ve started by rendering some terrain data using the Robot Frog algorithm – see http://www.stuffwithstuff.com/robot-frog/3d/hills/index.html

I’ve created a utility program which generates the heightmap data and writes it out to a custom binary format which the engine reads in. The rendering is not optimised in any way at present. My crude rendering algorithm at the moment is simply using a nested loop to iterate through the heightmap data in both dimensions and plotting the 2 triangle required to represent 1 terrain square. For each triangle vertex the y co-ordinate is the heightmap data at the corresponding location and the z co-ordinate is the outer loop’s counter. The x co-ordinate comes from the inner loop.

Obviously I need to work on several things here:

• OpenGL Triangle Strips – these will be more efficient than single polygons
• Level-Of-Detail – large terrain areas of similar height can be represented by less polygons
• View Frustum Culling – not rendering polygons outside the viewing cone

Those things are next to tackle on my list but not necessarily in that order. I can see a lot of interdependencies and chicken-egg things so not sure where to start. Probably the frustum culling.

MD2 Models

I’ve added a class which represents a Quake 2 MD2 format model. To be honest this code was mostly lifted from David Henry’s site http://tfc.duke.free.fr/old/models/md2.htm with tailoring for my purpose/code style. I’ve chosen MD2 as it seems a popular enough format, because it is documented and there is sample code around.

Currently the engine loads up 1 model and places it in the world. I need to flash out the model class to include movement, rotation, bounding tests amongst other things. I also need to create a list of objects in the engine so that it can manage many models.

Font Rendering

I’ve also added some crude font rendering which allows on-screen output rather than printing to the shell. I expect to beef this up as development continues.

Screenshot

Here is a screenshot of work so far

It gets tricky when determining the difference between a real reference and a so-called ‘borrowed’ reference. A borrowed reference is one where some code, say a method call, uses the reference already owned by the caller.

Recently I had cause to write a C extension to Python which created and returned a dictionary object. My initial code contained something like this:

my_dict = PyDict_New();
PyDict_SetItemString(my_dict, "id", Py_BuildValue("i", 1) );
return my_dict;

However, using this method of creating a PyObject and assigning it to the dict in one call caused the reference count to be 1 higher than it should be and therefore unable to be garbage collected. That as we know is a bad thing. I am still unsure as to why this should increment the reference count when Py_BuildValue is called and then increment it again when given to the dictionary.

So, a bit more code is needed in order for us to keep the reference count at the right level. Here is the equivalent code to the above done in the correct way:

my_dict = PyDict_New();
PyObject *id = Py_BuildValue("i", 1);
PyDict_SetItemString(my_dict, "id", id);
Py_DECREF(id);
return my_dict;

The obvious difference is that we create the PyObject first, assign it to the dict and then decrease the reference count as we no longer need it.

I’ve been looking at this algorithm as it looks quite simple and I’m all for keeping things simple. I’ve made a start already and hope to get it working by the end of the week!

So far I have set up my dev environment which is:

• Linux – Ubuntu 10.4
• SDL
• OpenGL
• Code::Blocks

Code::Blocks seems to be just what I need which is a no-nonsense C/C++ IDE that handles the GNU Toolchain setup for me. This means I can just get on with coding. However, I spent all of Sunday evening trying to get it working with SDL on Mac OS with no luck. I’ll be sticking to Linux for now and I’ll revisit that some other time as it isn’t a priority.

So far I have got the basics which is to say I have opened a window, got an OpenGL rendering context and drawn a colourful pyramid. Next up is the generation and rendering of some terrain data.

First up, open up your System Preferences on the Mac and under Accounts add a sharing only account with the username guest having no password. Next go to the Sharing section ensure File Sharing is enabled with Windows Sharing on. Click Options and select the guest account you just made. I would recommend you only allow the guest account read-only access by setting the share permissions on the ‘Everyone’ user.

Now follow these instructions for setting up the Ubuntu side: http://www.vurt.co.uk/2010/02/25/ubuntu-autofs-sambacifs-tweak/

Now create an autofs.smb.master file containing:

username=guest
password=

After this you can access the Mac shares under /smb/mac-hostname/

This is achieved by the following wsgi script:

import trac.web.main

_application = trac.web.main.dispatch_request

def application(environ, start_response):
  environ['trac.locale'] = 'en-GB'
  return _application(environ, start_response)