Pomme - Please comment on it :D

Cross-post from my website - Electronic-Mind.org :). Here you go Kilin, a bit longer than I expected haha :D.

But before I start, I just wanted to say that I've updated my website to a new, much nicer design. It'd be great if you could check it out :).

And so, the comparison post!

I figured it would be fun to compare the three major game creation tools tools I've used over my several years of game making: Unity, Gamemaker and Blender. I just want to quickly say, when I mention "games" I've made, I mean more like 20min long short games. And so, my comparison!

First off, I'll quickly cover my experience in these tools:

Gamemaker:

Gamemaker was my first love, what got me into game creation. I've been using it for over 6 years now. Gamemaker's primarily a 2D game creation program unlike the other two, although it has limited 3D functionality. I've created a range of things in Gamemaker. I've created platformers, top-down shooters and a pretty rubbish fps. I've also created several programs such as an After Effects remake, a dialogueue editor and a really, really bad game creator. Admittedly none of those programs were particularly great, so I may be a bit inaccurate there. Finally I also made a few extensions, an easier 3D tool, dialogue boxes, a dead simple physics engine, and a delta timing auto enabler.

Blender:

Blender was a somewhat shorter use, I moved pretty quickly to Unity. However, I still made two and a half games, one of which seems to be my most enjoyed. I've made a 2D platformer, a 3D tower defence fps, and a 3rd person sword fighting game with a branching story and dialogueue options. I've met many of the ups and downs of Blender, however I very quickly switched to Unity, my favourite engine!

Unity:

I've used Unity for about half a year, same length as Blender. Unity is by far my favourite engine due to many aspects, and as such I've made some of my best games in it. I've made a Top-Down/Fps game with some of my best looking aesthetics, like seriously, it was a really great looking game. It's called Sleepy Robbers, go play it! I've also made a 2Dish sidescroller. I've also made a few extensions, such as a dialogue editor, several different game modes such as an fps, sidescroller ect, and a layer based shader editor called Shader Sandwich which you should also check out ;).

Comparatives:

I'll be comparing them against a few different parameters:

Language(s) - What language(s) does the program use, and how good is it/well suited for game design. This ones a little less objective than the others as I prefer non-important whitespace, with strong Object Oriented design, so keep that in mind.

Documentation - How well the game engine is documented. If it's a great engine but I can't work out how to draw a square, something is seriously wrong!

API - How consistent is the API, does it utilise OO well, etc.

Interface - How easy is the interface to use, is it simple to put the game together without the engine getting in the way. Good interfaces are ones that can be navigated quickly, provide all the tools you need, or allow you to extend them.

Workflow - Once again, a little subjective. The workflow is how the game gets created. This includes how all the images, sounds, gameplay ect work together, how levels are designed, whether things are re-usable or not etc.

Platforms/Exporting - I'm grouping together the ability to export to different platforms and the ease of doing so. This ones pretty simple. Being able to export to many platforms is a pretty good thing in most cases, but if it's nearly impossible to do so due to hundreds of dependencies or what-not, it's not so great.

Capabilities - This one is what the engine can do without any extensions (Extensions are counted later). I've split this up into a few subcategories:

Gameplay - Simple things like easy delta time access, the ability to save, things like that count here.

Physics - Does the engine have in-built physics, and how good is it.

Graphics - How the engine performs and looks graphically. This includes 2D and 3D support.

Aesthetics - How many different aesthetics can the engine do, how limited are they by the graphics.

Sound - What the engine supports sound-wise, such as file formats, 3D positions, and sound effects.

Story - I know this ones a bit weird, but it's mostly just to future proof this in case I decide to add more engines to it. This is how easily stories can be implemented in case the engine was designed for it.

Extensions - How well can the engine be extended. Are there any things it just cannot do based on the design, or is it free for all.

I think that should cover pretty much all the engines aspects, time to actually get to reviewing the engines themselves. I'll start with my least favourite, Blender.

Blender:

It surprises many people that Blender has an in-built game engine, and that's because, well, it sucks and no-one uses it. It suckers people in with it's ease of use and simplicity but then screws you over with distribution issues, documentation problems, terrible capabilities and just an overall shakiness that rings throughout the entire thing.

Language(s):

First off, Blender uses the language Python. It's not a terrible language although it's all important white-space is a bit annoying. Overall it's a fairly good language, but due to it being interpreted it can be surprisingly slow sometimes. Python supports most OO design ideas so it works well in the context of a game, and overall isn't a particularly large problem, especially if you like it's syntax.

Documentation:

Not much to say here. Its documentation is some of the worst I've ever seen. First of all, it is expertly hidden on a website separate to Blender. That's right, there pretty much isn't any official documentation, just another website that tries to pick up the slack. It does an ok job, but covers a limited amount of it so in other situations you may just have to look for undocumented features, which can be listed thanks to Pythons "dir" function.

API:

The API isn't the best, but it's not terrible either. It supplies most of what you'll need when working with it, although some of it is strange. It changes between frames and seconds at the drop of a hat, and the naming conventions change sometimes as well.

Interface:

The game portion of Blender isn't very fun to work with either. You are pretty much forced to use the rubbish Drag and Drop features to start the scripts and get most necessary inputs like mouse position and keyboard movement. The text editor isn't very good either, and feels incredibly clunky. Luckily you can use external files, so that can be solved by just using Notepad++ or some other text editor.

Workflow:

Ok, have to hand it to blender, it wins this one pretty much straight out. Having an inbuilt modeller, texturer, tester etc all in built is a wonderful experience and makes rapid prototyping extremely easy. They are all getting continuous upgrades despite the lack of game-centric additions.

Platforms/Exporting:

Ok, this one really cripples Blender sadly. First off, you can't ever not release your source code thanks to Blenders viral licence, the evil GPL. This really stuffs up any commercial game, although it isn't too big a deal since most games get cracked and pirated anyway. This just makes it a ton easier and is less appealing for most backers or investors. Exporting is a fairly flimsy process as all it does is pack the main .blend file into the exe then chuck everything else in. From there you have to manually copy any dependencies yourself. You also have to remember to always use relative file paths or your a bit stuffed there as well. I suffered from this problem a ton in my game Santas' Gift, probably my worst game even though it had the most content (Thanks to the great work flow). Finally, you can only export to Mac, Linux and Windows so no mobile or anything, and to release to them you have to have the OS itself installed. Then, if you can get it to install you have a snowballs chance in hell of getting it to run on another computer. Out of the 4 computers we have, my games run on three(barely), and can only run well on one of them.

Capabilities:

Gameplay - There really aren't any limitations here. I think you can achieve most game types with this, although you pretty much always need to use the physics engine as collision checking can't be done without it.

Graphics - In blender you can actually do a ton more graphical enhancements that Gamemaker and Unity, however the engine is badly optimised you wont want to without the game slowing to a halt. You have no lighting limitations, and shadow support for most light types. You can bake the lighting with a thousand work arounds, and use many of different material combinations. There are also tons of 2D filters available, and more can be added such as SSAO and bloom. However getting the game to run with these is pretty hard though, so it's best to stick with simple graphics.

Aesthetics - You can achieve some pretty great looking games in blender, even without high quality graphics. Simple by using great lighting choices, baked ao and other tools they can look quite nice. However, due to the slowness of 2D screen filters, some things are out of reach.

Physics - Well, there are physics, and they aren't too bad. However, there are many badly supported features such as joints, and the API for it is pretty awful as well. It is also slowly than whatever physics engine Unity.

Sound - Sound support is pretty good actually, with ogg being supported along with 3D sound. There is also support for audio effects such as echoes, low pass filters etc.

Story - There's some unintentional support here thanks to Blender being primarily a render tool. You can do all sorts of animations and effects thanks to these being inbuilt. Sadly Blenders animation playing features are surprisingly slow, although there are some efforts to fix this.

Extensions:

On the extensions front Blender isn't looking too bad. Seeing as you have the entire source code you can do whatever you want with it. However, there is no easy inbuilt functions for lots of Blenders interfaces, and the source code is a mess. Other than that, you can do non graphical(no windows, dialogue boxes etc) extensions with Python for all sorts of level editing additions, modelling fixes etc.

Overall, Blender is a great engine if you want to start a game and never finish, because the closer you get, the more you realise what a mess Blender is. That, coupled with the many API problems, the viral GPL and the overall lacklustre everything makes Blender my least favourite game engine.

On the other hand, Blender is a fantastic prototyping engine. Due to the extremely fast workflow, games can be whipped out quickly as long as they don't need any advanced features.

Scores:

Language(s) - 8/10

Documentation - 3/10

API - 3/10

Interface - 5/10

Workflow - 10/10

Platforms/Exporting - 4/10

Capabilities

Gameplay - 7/10

Physics - 5/10

Graphics - 5/10

Aesthetics - 7/10

Sound - 8/10

Story - 6/10

Extensions - 6/10

Final Verdict: 6/10;

Gamemaker:

//I just want to put a disclaimer here first. Admittedly I've only used up to GM8.0 so some of my information is out of date. However I have watched over lots of the new features put into GM Studio so I'll try and put as much up-to-date information as possible.

Gamemaker was my first game engine, so I feel kind of bad for not putting it at the top haha :D. Gamemaker was built around the idea of a simple game engine where one doesn't need to worry about the internals too much and can just make games, and for the most part it succeeds. Rapid prototype is Gamemakers major strong point as many things can be done with it at a faster rate than other engines. Gamemaker has support for pretty much any computer and mobile device you can think of and rarely has any compatibility issues. Its sound support, graphics support and its other capabilities are all top notch and overall it's a great engine. The only major faults with it are it's shaky API and a lacklustre interface. It's focus on easy game development can also sometimes get in the way. And of course its 3D is almost non-existent. Apparently Quake One graphics were too difficult for it (Ah yes, GM7 when Gamemakers documentation still had some personality).

Language(s)

Gamemaker uses a custom built language called GML, which is an amalgamation of many other ones such as C++ and Delphi. Its language is ok, and a great starting point for those just starting out due to it's forgiving syntax and simplicity. However, it does lack some important things such as classes(Yes they can be simulated using Objects however those have a massive overhead), pointers, and, well, classes! Classes are awesome and without them Gamemaker suffers a ton. I really can't praise OO enough, and Gamemaker just sort of bites half of it then throws away the rest. Who throws away half a cookie!?

Documentation

Gamemakers documentation is pretty great. It covers almost everything you'll ever need to know in an entertaining fashion. I don't know if it's changed or not, but in the GM8 manual you can just feel Mark Overmars personality shining through haha, and it makes it almost fun to go through. A little more details on the inside of the engine would have been nice, but overall it's pretty well done and is extremely useful. Gamemaker also comes with a variety of example games.

API

Gamemakers API is limited by its lack of OO, and it does have some very annoying naming convention changes. Overall it provides you with almost everything you'll ever need to make a game, so it's pretty feature complete. The main annoyance is that conventions don't really exist. You can have draw_sprite(sprite,subimg,x,y), but then have draw_text(x,y,string) which flips the inputs on their head.

Interface

Gamemakers interface is probably the only average part of it. It overall just doesn't look very good, especially with the recent skin changes (Although I believe it can be changed back but with some bugs). The interface is a bit clunky, and the editing of objects practically hasn't changed since its inception. The entire interface is based around 2D editing, so using it for 3D games isn't great either. On the other hand the room editing has apparently gotten a lot better. I personally haven't checked it out, but now you can zoom in, change object scales and many other things that you couldn't before. However, you still can't select a few objects and move them, or delete underlying objects of the same type.

Workflow

Gamemakers workflow is similar to Blenders, in that you can do almost everything within the program (Although for some things you might not want to). You simply create sprites(Images), create objects and assign them an image, create several events and reactions, then place them down in rooms. It's a pretty nice workflow that rarely comes back to bite.

Platforms/Exporting

In previous versions this was a little lacklustre with only Mac and Windows exports(From their respective OSs). However, in the new GM:Studio you can export to many mobile platforms, and I think Linux. You can do all this from Windows which is pretty helpful to most. Exporting is as simple as hitting the export button and setting up some install options.

Capabilities

Gameplay - Gamemaker really has no limits to the gameplay, and doesn't force you into doing much. 3D gameplay is a little harder, but can still be done to great results.

Physics - Gamemaker:Studio now comes with the Box2D physics engine which I've used in the past. It seems pretty well featured, although from what I've read some of the implementation is a little shaky. I'd have to use it for myself to get a more accurate analysis.

Graphics - Gamemaker can do almost any graphical style you want, except realistic 3D. Other than that you can do all sorts, be it cartoon, hand drawn, pixel art, and you can add all sorts of lighting effects with fairly little work. 2D shadows are not supported though, although they can be added with extensions.

Aesthetics - Well, in 2D at least there aren't really any limitations at all. In 3D on the other hand, pixel art seems to be the major option. It's impossible to get anywhere close to realism with it.

Sound - Gamemakers sound support is a little bad, although my experience with it is outdated. In GM8 playing too many sounds can lead to a crash, and it doesn't support any good sound file types like ogg.

Story - Gamemaker tools like timelines and paths make it pretty easy to make cut-scenes and other story things.

Extensions

Gamemaker could be extended with many things just for Windows such as proper dialogue boxes, physics, a better audio engine, text to speech, custom 3D engines, you name it, it existed. Sadly, with GM:Studio this has been removed, and instead only GML extensions are allowed. This still allows for many things, but is a little limited. These can be extra drawing functions, dialogue boxes ,game bases, a still fairly unlimited number of things. Sadly GM also has no support at all for editor extensions.

Scores:

Language(s) - 6/10

Documentation - 9/10

API - 7/10

Interface - 8/10

Workflow - 8/10

Platforms/Exporting - 8/10

Capabilities

Gameplay - 10/10

Physics - 7/10

Graphics - 8/10

Aesthetics - 6/10

Sound - 6/10

Story - 5/10

Extensions - 5/10

Final Verdict: 8/10;

Unity:

Unity is a pretty popular engine in the indie world due to its ease of use, free version and asset store. The engine itself is pretty fantastic, although probably doesn't hold up against the Cry engine and Unreal engine (Which I may add later).

Language(s)

Unity supports several languages: C#, Boo and Javascript. All three of them are really well implemented, and since this is the only engine out of the others without an interpreted language which gives it a nice speed boost and file size optimisation. All the languages support classes, but Boo and Javascript don't support a few of the object types.

Documentation

Unitys documentation is pretty good, they document almost everything, almost no guess work required. All the documentation provides example uses and other relevant information. It's also fairly entertaining at some points, which, like the Gamemaker one makes it more interesting to read. The documentation goes into engine specifics, like how and when different events are called, how Unity draws shadows and many other things. It's pretty helpful! However, for some odd reason there are some pages with barely any information on them, mostly around the terrain stuff.

API

Unitys api is very nice, which very little random style changes. There are some handy classes like Vecfor3 and Quaternion, and they are all used consistently throughout it. Unlike the other two engines, there are also a ton of inbuilt GUI drawing things, for in-game and for editor extensions. There are also a ton more physics options opened up.

Interface

Unitys interface is very easy to work with. All the different items you'll need are grouped nicely into a bunch of windows. These can all be arranged easily depending on what your working on. You can do a ton of stuff from the editor, such as add components to objects, block out levels, add trigger points, all without having to touch any code. This makes it pretty easy to set things up while working on the game.

Workflow

Unitys workflow is a little more complex than the others since assets must be created in a separate program, however importing is mostly a painless process. Other than that, its simply a matter of putting the objects in, attaching components then hitting play. The ability to define per object properties helps a ton in setting up extend-able systems like dialogue or sound triggers. Depending on how you set up your game, once the engine is done you'll never have to mess with it again and simply add content.

Platforms/Exporting

Like Gamemaker, you can export to pretty much every device, including consoles. The export process is simple and there's never any doubt whether something will be included or not. The game is likely to run on most computers thanks to the numerous automatic fallbacks that Unity includes for bad computers.

Capabilities

Gameplay - Unity doesn't limit gameplay much at all, and unlike blender there are some in-built collision checking abilities that don't rely much on using their physics engine. Unity also includes several pre-made controllers for 1st and 3rd person viewpoints which makes starting out easy.

Physics - Unitys physics engine is very good, supporting all the basics along with cloth physics, hinges, and others which maintaining a good speed. There are controls for changing the accuracy of the physics as well which can be a good way to speed up the game.

Graphics - Unitys graphics capabilities are very good, especially when using some custom shaders. Unitys deferred shading mode supports shadows for every light type, unlimited lights, and can easily fallback to forward mode for objects with transparency and the like. Forward mode is also pretty good, and it is possible to enable shadows for different lights with custom shaders. The entire engine runs very smoothly and can be scaled to different systems easily.

Aesthetics - Unity includes a ton of in-built shaders that make different art styles possible, like toon shading, realistic or unlit AO. It is also very easy to set up nice lighting and screen effects to really sell the look.

Sound - Unity supports ogg, 3d sound, audio effects and realtime sound generation. It also includes support for Doppler effects and a few other useful things.

Story - Unitys ability for story is more limited than the others, with almost nothing in-built to help. However, you can attach functions to frames of an animation so it's possible to call sound effects or other things easily.

Extensions

Unity is by far the most easily extendible of all three engines. While you can't have source code access (And that is changing currently), almost all of the engine can be altered anyway. Shaders can be replaced in forward and deferred mode easily thanks to their Surface Shader functionality (and Shader Sandwich ;) ). The interface can be altered, new windows added, components variables changed, it's pretty free for all while being structured in a way that makes it difficult to break things. It's also possible to run scripts in edit mode while drawing handles, so adding extensions to pre-built windows like the Scene window is also possible.

Language(s) - 9/10

Documentation - 8/10

API - 9/10

Interface - 9/10

Workflow - 9/10

Platforms/Exporting - 10/10

Capabilities

Gameplay - 10/10

Physics - 9/10

Graphics - 9/10

Aesthetics - 10/10

Sound - 10/10

Story - 2/10

Extensions - 9/10

Final Verdict: 9/10;

Well, there you have it, my mostly subjective analysis on which of these three are the best engine! If you disagree, feel free to post in the comments. Also, if I made any incorrect statements please tell me, especially around the Gamemaker section haha. Thanks if you read through all of it, and watch out cause I may add more engines! Thanks :)

tl;dr - Unity is awesome, Blender Game Engine sucks, and Gamemaker is also pretty cool :).