Maratis features

I’ve been playing around with Maratis for the best part of a year
now. It’s been a great engine to work with, but I’m missing a couple
of features that I really want to have to use for She Wore White which
just weren’t possible with the engine in it’s current state. So for
the last few months, I’ve been attempting to extend what is there and
make a system that my team, and I, am happy to work with.

Maratis is a particularly lightweight engine. It doesn’t have a good
deal of the features that something like Unity, or UDK might have, but
at the same time, that makes it quite lean to work with, and no overly
huge codebase to get familiar with.

That’s not to say that it’s particularly lacking, using the included
features, it’s quite possible to create possible to do pretty much
anything you wanted and make a nice little game. Some of the things
that it includes are:

  • Abstract renderer to support fixed function and programmable graphics pipelines
  • Game plugin functionality to provide native code functionality
  • Lua script API
  • Physics simulation (via Bullet)
  • GUI level editor

Overview of plan

There have been a lot of things going through my mind in terms of
ideas for what I can add to Maratis. A good deal of these are, for the
time being, outside the reasonable scope for She Wore White. I am,
however, going to be spending a good deal of time extending the tool
set to make work easier for content creators to work with the game.

As there is currently no deadline for She Wore White, I could
theoretically allocate a near infinite amount of time to implement all
the features I would want. I would like the game to be finished at
some point in the not overly distant future, so trying to balance what
is useful, and how long they will take is an important thing to decide

One thing that I’ve decided on is that I want to start working on a
new editor for the game, I might use code from the current editor
source, but the current design, I don’t feel best suits what I want

I’ve used a sort of MoSCoW style listing to try and document what
features I am currently considering.

Must have

The first step to my plan is to create a more flexible editor
framework. I want this to be easily extensible using an extension of
the editor plugin system to allow for more features to be added
outside of the editor.

Using a ‘god view’ editor such as the current Maratis editor to edit
interior scenes is not a simple task. There are modifications that can
be made to improve the interface for these sorts of scenes, but I feel
it’s usually easier to have a form of in game editor, similar to the
Sauerbraten FPS engine. The reason being is that the designer can get
a much better feel of how thing work if they’re using the same sort of
camera/controls to navigate the scene. Of course there are a lot of
things to take into consideration here, but I will cover these in
another post.

As She Wore White will hopefully be an atmospheric game, set in a Film
Noir style world, there are a lot of things which will needed to be
added, in particularly visually, in order allow for this. The first
thing that comes to mind is that the lighting solution in Maratis,
which allows for 4 dynamic lights, is a little more limited than I
would like. To fix this, I’m going to attempt to customise the
lighting, and potentially get it to automatically bake a lightmap for
lower spec computers.

Keeping with the atmosphere theme, I want to be able to give my audio
engineer as much flexibility as is possible. Unfortunately there isn’t
the budget to license a full audio engine, but I’ve been offered use
of YSE so I will be attempting to integrate that with Maratis, and
adding interface features such as curve parameters.

Using lua is nice. It’s relatively fast to run, it’s pretty fast to
develop in. There is currently a lua API for Maratis that does a lot
of the things required, but if I’m going to be doing a reasonable
amount in lua, as is the plan, then I want to extend this. The first
thing would be to make a more object-oriented lua API for the standard
Maratis system. The main method to extend the MIngEd system will be to
interface with the existing lua state. This will mean that editor plugins
don’t have to share headers or anything and the things should “just
work”. This will need a reasonable amount of architecting to get
working right though.

Could have

As well as the fancy lua API for everything, I really like the idea of
having a Quake-style drop down console in the game being an actual lua
interpreter and acting on the currently running lua state. In theory,
this isn’t an awful lot of work to do, as lua already exists, but to
get the console input working correctly, I expect this will cause a
couple of headaches. With this, it should be possible to do things
such as trial ideas in lua script without having to restart the game,
and also have full access to the game lua API, even when it’s not
exposed as en editor widget. Of course, this should be only available
in editor mode.

I wasn’t sure whether to put this in this section, or the one above. I
figure that particles are very helpful for the whole atmosphere thing,
but at the same time, it’s possible to fake most things without an
actual particle system. As She Wore White will be set in a Film Noir
world, smoke is likely to be a very useful atmospheric device (if you
don’t believe me, Google image search for Film Noir brings up an image
from The Big Combo trailer. Very smokey. Particles are a generally
useful thing, but also can be reasonably expensive in terms of
performance and development time. They will probably happen though.

Would be nice

The current method for getting 3D models from an editor, into Maratis,
is to export them, from either Blender or 3D Studio Max, as a Maratis
Mesh file. One issue I’ve been having is that this process is
relatively buggy due to the fact that these programs update relatively
frequently, which means the exporters need to be updated. Occasionally
they will be forward- or backward-compatible, but not always. Getting
the correct combination of editor and exporter always seems like a bit
of a gamble. If Maratis would use an existing standard, such as
collada, for it’s input format, then this issue would be alleviated as
the editor community would have already created a workflow for this, if it’s not in the editor itself.


There are a great many things that I have thought would be great ideas for integration into Maratis. However, I think that there is a lot that is way out of scope of what I currently want to do. I will try and list a couple, if anyone wants to pick any of these up, I would love to hear about it.

Verse integration. Having seen what can be done with verse in Eskil Steenberg’s MMO Love, it’s quite easy to imagine the usefulness of having the assets stored and streamed to the game/editor. There’s a lot to do with this one, the verse integration itself is just the start, there’s also the fact that for a single player game, you would probably wouldn’t want to have to host the assets for anything outside of development, so it would have to be tied into the publishing system.

Git integration. On a similar theme as the verse integration, another asset store solution would be to add version control support, for example with git. This would have to be able to handle standard workflow such as merging, pulling and pushing. Apart from the issues mentioned in the verse integration, there is the added complexity associated with merging. Ideally this would have some sort of context aware diff utility, but that would take a lot of work to work properly. On the other hand, it would allow a git assert server backend, which is far more likely to be useful than using verse, with cheap/free git hosting at sites such as github.


I have a lot of work to do. I’m currently looking into ready made
solutions for various things, and trying to get into contact with the
relevant people, but I’m also wary that I can spend a lot of time
trying to shoehorn an existing solution into something it’s not really
meant to do. I had a similar experience previously when attempting to
integrate GUI libraries into Maratis.

The above list is by no means complete. There’s still a lot of other
features planned but I will update the list when I think of them. For
now, what do you think? Anything I’m overlooking?

Leave a Reply

Your email address will not be published. Required fields are marked *