This extremely useful tool allows you to search masses of open source code. It’s nothing new, but I only stumbled upon it the other week and have been using it ever since.

http://www.google.com/codesearch

One of the many cases I find it handy is when I’d like to know how a function is used. For example, search “wxtoolbar(” including quotes to instantly find out how to add a toolbar with wxWidgets. It saves wading through documentation (or lack of it) to learn how to perform simple tasks. You can also enter a string of text describing what you are looking for. Or, if you’re familiar with regular expressions, you can find some very specific code examples.

It’s a must for programmers looking to improve productivity.

I have already written my Christmas list for the jolly man himself, and on that list is the iPod Touch. I’ve been meaning to get my hands on one for a while, in fact, ever since the second generation version was launched back in September.

A few of the new features it boasts is 3D graphics acceleration, built-in speaker, accelerometer, and the App Store through which you can download thousands of games. As a game developer, I’m not going to miss out on an opportunity like this! Ever since I bought my PDA six years ago, I have always loved creating small-screen applications (obviously it was far more primitive than what you can achieve with the iPod). There’s a certain satisfaction to carrying around your own software on the move.

In the meantime I’ll be doing some research. Cross fingers I’ll be able to port TIDE. Because I’ve abstracted OpenGL, it might indeed be possible to create an OpenGL ES wrapper. I’ll just have to wait until the big day to find out.

It’s a known fact that when engaged in activity, time seems to pass quickly. Programming is no exception, as I’m finding out. The days are flickering away, and I rarely feel satisfied about what I have achieved. In a day I can usually rattle off a few bug fixes, start a new feature, extend an existing feature, and by the end I feel I could have done so much more. That’s the curse of programming; it’s hard graft and seemingly endless. Don’t get me wrong, I enjoy it immensely, but once I’m ‘in the flow’, the day is gone in a finger snap.

For an interesting read on what causes such a sensation, take a look at the following article:

http://news.bbc.co.uk/1/hi/health/3532195.stm

Slowly but surely I am hacking away at a 3D engine for TidalWare. I started it just under a year ago as a personal project, originally named OGLE (OpenGL Engine). Recently I’ve been working non-stop, trying to bring it to a useable state. I heavily underestimated the difficulty of writing a well designed, sustainable engine.

I had a browse around the web to see if I could find any inspiration; after all, there are 3D OpenGL engines all over the place. I came across a few very nice engines, from personal projects to student finals. The features and visuals of these engines seemed astounding – XML shader system, dynamic water, static geometry, vertex buffers. Great. But, take a look at the source code and ouch. Hacky and GL-specific code everywhere. It’s as if they continued to add bits here and there without any particular structure.

Bad design is easy to implement in the short-term, but as for extending it in the long-term, well, it could turn into a bit of a nightmare. On the other hand, good design is painful at first, but once you’ve got the ball rolling you soon realise that it was the best decision you could have possibly made. I’ve opted for the latter.

Unfortunately that means I can’t add any juicy features until a solid framework is implemented.

Here is a lowdown of the current features:

• Window creation, management and events
• Camera with frustum
• Viewport
• Scene components
• Abstracted OpenGL 2 with version 3 placeholder
• Math functions: Vector4, Vector3, Vector2, Matrix4, Matrix3, Quaternion, Sphere, Plane, Ray, Colour, Box
• Utilities: Logger, Exceptions, Timer
• Occlusion query
• Temporary fixed-function lighting and fog

Screenshot of TIDE in its infancy.

Pretty basic stuff, and I know you’re thinking “what has taken him so long?” Well, apart from the fact that I’m the only one working on it, you’d be suprised at just how complicated it is to implement the core functionality. The engine is already beastly with over 30k lines of code. However, now that the basics are in, it is now very simple to add new features. It’s component-based design means that I can drop in a new class without changing much at all.

There is still a huge amount of work to do, however. It has no texture support, no materials, no model loading, no scene graph, no resource management and no shaders. Admittedly, some of those features will mean a number of framework changes. The first three especially will be a bumpy ride. But nevertheless, my good design decision will help immensely.

We haven’t yet explained what we are doing behind the scenes, so here’s a summary of what we have in the works. Basically, we’re building the stuff that makes games tick. As an example, many of the larger companies use in-house technology to develop multiple games. The cost to develop the first game is significantly more than the second. Why is this? The answer is re-usability. Unfortunately, because TidalWare is a latecomer, we have to start from scratch. That means we need to develop the technology that mainstream development studios have worked on for the past decade.

The good news is that today, there exists more resources, software and knowledge than ever before. We are taking full advantage of this. Now, instead of reinventing the wheel, we can use existing open source libraries such as Ogre 3D. In doing so, we have saved a tremendous amount of time and cost, which means we can concentrate on developing what is important: games.

At the same time, however, we are also developing our own in-house technology from the ground-up, advancing as we grow. TIDE (TidalEngine) is our game engine in development. TIDE is currently a wrapper for multiple libraries (graphics, audio, physics, networking etc.). However, over time we plan to remove each library consecutively and replace it with our own implementations. Tide::Graphics is our first hurdle, and will eventually replace Ogre.

Tide::Graphics is a pure OpenGL engine. We plan to have no (or few) fixed-functions, making it entirely shader-based. We have abstracted OpenGL 2.0 in preparation for a version 3.0 replacement. Our ultimate aim is to develop a cross-platform equivalent to DirectX 10 ‘power-engines’ (e.g. CryEngine – yeah, in our dreams), and show off the real power of OpenGL 3.0. More info on this to follow.

Other projects include a game editor (TidalEd). This allows us to easily build levels, modify object properties with our component-based system, edit materials, create animations, paint terrain, design game logic and so on. This will also be cross-platform.

We are still a long way off from achieving our goals, but as long as we work hard and keep at it, we could indeed catch up with the current game industry in a fraction of the time and cost.

Welcome to the new TidalWare blog! This is our informal part of the site; I, Daniel, will be speaking for myself, along with colleagues who will blog here in the future. It should be fun, and hopefully interesting for our readers. In this space we will post sneak previews of what we have in the mixer, articles related to game development, and keep you up to date with the latest happenings at TidalWare.