While still progress is slow I try to tell you guys something about the editor user interface. Decisions where to make the editor in-game for easy access in full screen mode. So far it’s doing it’s job very well. I reworked the editor’s graphical user interface images to some eye-candy that looks pretty good for now.

Currently the editor and UI are able to create, delete and switch scenes, display images, browse through files, transform the camera, and see some logging, browsing and place actors (moving and selecting needs to be implemented at some time). Basically the basics. I try to keep the editor to a minimum as possible and use notepad, paint and other tools to create the game. But eventually you always need some in-game-tweaking. And that’s where our nice user interface comes in handy!!

As I’m fairly busy last few months game development has almost frozen. So to heat things up I will
make a simple post regarding the file format we use in our games and engine.

We had the following demands:

• Easy to read for a human
• Easy to read for a computer
• Easy to extend
• Nesting

So with this in mind we looked at some existing file formats:

• Ini: Easy to read for a computer and a human, but no nesting support.
• XML: Easy to read for a computer, but not for a human.
• Binary: Very easy to read for a computer, not for a human.

So we cam up with our own format: Data Files.
It’s basically a combination of an ini file with the nesting of XML defined as follows:

{Node1
    Key=Value
    {Node2
        Key=Value1
        Key=@(path)Value2
    }
}

We have nodes. Nodes can contain new nodes and key-value pairs. Key-value pairs don’t have a
primary key and can only be one liner. Basic design that’s pretty good readable for a human and a computer!
We also have a special variable defined. The “@(…)”. This defines that there’s a value that contains
a variable value. For example the “@(path)” contains the path the file is located in.
This is very useful for fetching a file in the same directory: Texture=@(path)MyTexture.jpg.

As we are curious of engine and game performance beyond the “bad” frames-per-second measurement, I started to integrate a benchmark “tool” into the engine. This “tool” only registers the start and the end of a specified function block with a small useful information description.

With a separate benchmark viewer we can analyze the engine performance per function per thread and it shows the actions on a nice time line. What we see are blocks, aligned in time per thread. A large block means something took a shitload of time, a small block means mostly a few milliseconds. Also the engine schedules some update, physics and render, content loading calls on different threads, we now can see what actually happens inside. This also gives us more power for better optimizations and debug capabilities.

As we are busy with a procedural-city-generator that we could use in future games, I created a small simple test building (prefab) to test the building-placement-code. This code is still pretty simple and only puts some buildings on a straight line along each street with a small offset. furthermore we added a sidewalk strip next to each street to give it a better look.

Here are the images created so far. Apart for some bugs it looks pretty neat.

As seen in part 1 we are building a procedural city. So far we have the generation of the street network in place. Now we where working on the generation of blocks, the places we can but building or parks or whatever on. It’s basically an open space between the streets.

Here as a screen shot of everything in “action”.

Next step: buildings!

Problem area: we want to have a city. A BIG city. I don’t have the skill or time to build a BIG city in a 3D modeling program. So what to do? Create one from code!

Why do we want to have a city?… Well probably we gonna create a race game (again) through a urban-shaped environment . How or what we don’t know yet, but we now ave another idea for yet another game…again…

Where to we start? First the streets. If we have streets, we have building blocks. On building blocks we can put building or other things like a park. Sounds easy huh.

So far I created a small test-app that defines 5 lines. Those lines are extruded and connected in a way so the look like streets. So here’s a small image of what I made so far. Red is left side of the street, blue right side (debugging purpose only…)

Left: the app as-is
Right: triangulation (draw by hand).

The triangulation in 3D space  is also in place (not shown in the picture) and apart from a crappy test-texture it does it’s job very well!

Next step is to determine (detect) the two triangles in the middle. This would be the building blocks that hold some information like big building, sky scraper or park (and maybe water and other stuff).

Stripes flow in Genetica

After a few chats with Jens we decided to migrate from Photoshop to Paint.net for 2D art. Why? Paint.net is not so f*cking complicated and expensive as Photoshop.

Also a new thing that we are doing is learning how to make textures using Genetica. We won the basic version in the previous compo, and now we trying to figure out how it works. I must say it’s simply brilliant! Just with a few random mouse-clicks and we managed to create a pretty neat looking seamless texture that we can directly use in our games!

We still have the most basic version of the program but it proves to be very powerful and not so time consuming as Photoshop. Also an other thing is that textures are generated by combining noise, color and other kind of thingies. This makes that if we want to change for example a pattern that we simply change the pattern “building block” to fit our new needs. The texture is automatically updated and seamless!

Seamless texture created with Genetica, copyright 2010 NecroSOFT

The basic version does not have support for normal maps, but we can use (or make) an Paint.net plugin that suit our needs.

Also texture synthesis is available. We didn’t check that one out, but you can make a seamless texture from any photo or image. Can be very powerful also for game designers like us .

Long time no update doesn’t mean we stalled work. We just don’t made any “visual progress”. yet. What kept us busy then?

Well here’s a short list:

• Multi-threading
  • physics and update functions are run simultaneously.
  • (Still thinking on running update/physics simultaneously with the rendering).
• Physics
  • (modified version of JigLibX for the ones who are curious).
• Hierarchical model definition (we just call it model-files)
  • This means we have a file that defines how a 3D model looks like and behaves.
• Particle engine
  • It works and can be defined in the model-file.

Next phase is “The Game”… what game? Well… we speculated a lot at this point but we don’t want to reveal anything at this time. It could be that we suddenly change our perspective to make something completely different.

GeoMipMapped 5x5km terrain without lights. Shows still some cracks, but the result is pretty good for now.

Terrain wireframe and solid

You hear more and more about 3D in movies and games. So after I saw James Cameron Avatar a second time (and still was impressed) I was wondering how it could be implement it in our 3D engine. The only solution I could came up with it using a red/cyan glass and use the Z-buffer to offset some colors – that’s the cheap solution – and also used in Trackmania Nations.

So after browsing “The Internets” I figured my GeForce 8800GTS has the ability enable NVidia’s 3D Vision. I don’t have a shutter or polarized glass, but I have a red/cyan glass (which also works) so I gave it a try. I tried it on several games and I concluded that not every game is ready for this. For example in FUR it’s just totally crap and the in-car view is horrible because you see it twice! But I also tried some other race games like Clutch (Armageddon Riders – Google/Bing for this and you know what I mean) where the effect is basically perfect!

With this game it really got me started to see the use of 3D Vision in games. Everything just flying off before your head. When I smashed into something you almost need to dive from your chair so you don’t get hit by flying debris! And this all should only be better if you *buy* the NVidia’s 3D Vision glasses together with a 22″ 120Hz monitor!

So how does it work? Well, it due to the frame drops I experienced, I guess the world is rendered twice. Once for the left eye and once for the right eye. But I’m not sure because I didn’t dive into it yet…

After all the conclusion for this 3D experience is that we will make our engine ready for supporting 3D vision.