Introduction to HactEngine, Part 1: The Present

HactEngine's development started in early 2012. Since then we've learned a lot, mostly through mistakes we've made. The entire engine has been rewritten a few times and parts of it many more times. All of this has taken a lot of time, but release is closer than ever.

This blog post is part of an "introductory" series about HactEngine. This first issue tells you where HactEngine is now and what our short term goals are. In other words, the present and the near future.

The release of HactEngine's alpha version is planned for late 2014. This version will be very rough around the edges and won't be ready for full-scale game development. However, it will be a nice look into what HactEngine will become in the future.

Without further ado, let's take a look inside HactEngine. The best way to do that is to split it into 3 parts, which we'll go over below:


The game engine

The core of HactEngine is written in C++. The games themselves are scripted in Lua, which is the most used scripting language in the game industry. Lua is fast, easy to learn and enormously flexible.

C++ provides HactEngine with the performance a game engine needs, whereas Lua is much simpler and easier to use. Because the game logic is written in Lua, you can edit your game scripts while the engine is running, which makes prototype development and iterations much faster.

If you're developing games with HactEngine, you will only have to write Lua code. However, since HactEngine will be released as open source, you can tinker with the C++ code as well.

The main libraries HactEngine is built with are:

  • Qt application framework: used for windowing, input detection and managing OpenGL. HactEngine also uses QtQuick/QML for its editors.
  • OpenGL: used for graphics rendering. The shaders are written in GLSL. Currently we only have support for vertex and fragment shaders, but we plan on expanding further.
  • Bullet: used for physics and collision detection, although we’re still in the middle of integrating it. Bullet is fast and quite widely used.
  • OpenGL Mathematics (GLM): used for vector and matrix math. It lets you easily create projection and transformation matrices, as well as do other vector and matrix calculations.
  • SWIG: used to generate wrapper code, so that the engine can be used from scripting languages. We're focusing on Lua, but SWIG supports a lot of other languages as well.

All of the libraries mentioned above are cross platform and open source, both of which have been very important design goals for HactEngine.

We're also looking into using SDL 2.0, which would provide a much smaller footprint than Qt. HactEngine would still be using Qt for the editors, but SDL may be a better choice for "release" versions of the games.

The game editors

HactEngine has editors which speed up game development a lot and reduce the amount of dull, repetitive tasks. The editor interfaces are written using QML and they use Lua for most of their functionality.

This makes it quite easy to write your own editors and you don't need to compile anything. Just edit the QML and Lua source files and reload the editors. In fact, the editors can be reloaded while the engine is running, which makes their development quite fast.

In a released game, the editors are not needed and can be removed completely.

The game logic

The engine itself is quite dumb (in a good way). It runs scripts, manages threads, renders graphics and detects input.

In other words, it does all of the hard work and the game developer only has to write the game's logic in Lua. This also means that you can use HactEngine for many different types of games, since the engine doesn't know anything about the game logic.

The biggest advantage of all this, is that all scripts can be edited and reloaded while the game is running. All of the game logic is handled in Lua, which is compiled on the fly.

Roadmap to the alpha version

There are still big parts in HactEngine that we need to get working. This is why we don't want to release HactEngine just yet.

For example, we're still integrating the Bullet physics library into HactEngine. We also currently don't have any kind of support for animation. We're constantly adding functionality, but it takes a lot of time.

HactEngine's alpha release is planned for late 2014. We still want to add a physics engine, basic animation support and improve the engine's default shaders. We also want to add some basic editors to speed up game development. And most importantly, we need to write a lot of documentation.

Even after all of this, HactEngine is only at an alpha release state and probably won't be stable enough for full-scale game development. However, if you've ever wanted to write your own game engine or if you're just interested in how they work, HactEngine is worth taking a look at.

In the second part of this series, you can read about HactEngine's past and why we started building it.

Share this:
Category: Programming   

comments powered by Disqus