We just released the beta version of our cross platform multimedia framework Murl Engine and we are looking for some
developers who want to give it a try - its free.

The Murl Engine is a lightweight C++ multimedia framework for cross platform development of games and multimedia related apps.
The public beta version is now online and can be downloaded for free from our website http://murlengine.com.

Technically, the Murl Framework is a time-based scene graph framework. It supports the target platforms Android, iOS (iPhone/iPad/iPod),
Windows and Mac OSX. Later this year we will add support for Linux and Windows RT. The main focus during development was openness
and flexibility. The existing monolithic black-box game engines were – for our taste – too cumbersome, too inflexible and too much restrictive.
Therefore we started to develop a lightweight and flexible solution, which we can fast and easily try ideas with and which is also suitable
for productive use.

A large part of the framework is delivered with source code, making customization and enhancements easy. The framework can be used
completely for free – even for commercial development. The only restriction is a short notification overlay showing a short

“powered by Murl-Engine” notification on application start. Optionally other licenses without the notification are available for a fee.

To start the development only the Multimedia Framework and an IDE like Visual Studio for Windows Computers or Xcode for OSX Computers is necessary.

The screenshots above are all taken from demos created with the Murl Engine.

An early version of the Murl Engine has been used to develop the game “Crazy Rings” together with Cervo Media.
The game is available in all major app stores, won the Best App Ever Award in the category Best Family Game 2011
and has been nominated by the German Developer Award 2011 in the categories "Best Mobile Game" and "Best Handheld Game".
A free version of the game is available on every platform.

The Murl Engine is not only a Renderer but offers also a lot of other features e.g.

• OpenAL based 3D Audio System
• Input Handling incl. typical mobile input devices like location service, multi touch, gyro, accelerators etc.
• Rigid-Body Physics Engine
• Networking Support
• In-App Purchase Support
• Logic Processing Framework on top of the SceneGraph Framework
• Support for OpenGL, OpenGL ES and DirectX
• Resource Management incl. Multi-Language Support
• Clean and transparent abstraction layer for all supported platforms

I don't think that you can get this with an open source scene graph library.

Not the entire framework is closed source. The whole platform code is open source and can be easily extended. Only the scene-graph core is closed source but even here we provide a mechanism to add customized nodes and objects.

I agree with you that we should better showcase the individual features and flexibility of our Murl and promise that we will improve this direction.

I agree with colossal, I had difficulty enumerating exactly what's on offer. The information that you presented in your response to him should be made available on your website in a place that's hard to miss. It has piqued my interest, however.

Thanks for you input. We will add this information to our website.

In regard to keyboards we support both raw keys and mapped vanilla keys.

For internationalization we generally support all Unicode characters.

Actually we created for South Korea a special version of the Game Crazy Rings with Korean characters.

The framework provides a nice abstraction layer for game controller support. The framework will support standard

USB game controllers and the XBox game controller. Other non standard game controller can easily be added to

the platform code if required.

keyboards do not have "raw" and "vanilla" keys.

According to our definition raw keys are the actual physical keys on the keyboard.

The definition for raw key codes can be found in the file murl_raw_key_codes.h:

enum RawKeyCode
    {
        RAWKEY_NONE             = 0x00,
       
        RAWKEY_ESCAPE           = 0x01,
        RAWKEY_1                = 0x02,
        RAWKEY_2                = 0x03,
        …
 

There should exist a RAWKEY definition for every possible physical key. The list includes e.g. RAWKEY_0, RAWKEY_KEYPAD_0, RAWKEY_KEYPAD_NUMLOCK, RAWKEY_VOLUME_UP, RAWKEY_KANJI etc.

If you press on an English keyboard the key Y you will get events for RAWKEY_Y.

The same key is labeled with Z on a German keyboard. Nevertheless if you press the

key Z on a German keyboard you will get events for RAWKEY_Y because it is the

same physical button with the same key code.

If you press the two keys left SHIFT and Y you will get events for both keys RAWKEY_Y

and RAWKEY_LEFT_SHIFT.

To check for physical keyboard input, you can use the device handler's WasRawKeyPressed()method.

Logic::IDeviceHandler* deviceHandler = state->GetDeviceHandler();
if (deviceHandler->WasRawKeyPressed(RAWKEY_Y))
  do whatever is to do

In addition to WasRawKeyPressed(), physical keyboard input is also reflected by the IsRawKeyPressed() and WasRawKeyReleased() methods. During a regular keystroke, these methods return true in the following sequence:

1. At the moment of first pressing the key down, WasRawKeyPressed() returns true for exactly one logic tick
2. As long as the key is down, IsRawKeyPressed() returns true in every logic tick.
3. When the key is released, WasRawKeyReleased() returns true for exacly one logic tick.

This behavior is detailed described in chapter 01/tutorial 02/version 04:

http://murlengine.com/tutorials/en/_tutorial_chapter01_t02.php

RawKeys are typically used for control inputs in games.

Vanilla keys according to our definition are keystroke results after the operating system processed the key codes.

The result depends for example on your language settings. If you press the key Y you will get

lowercase y if the language is set to English. If you press the two keys SHIFT and Y you will get

uppercase Y.

If the language is set to German you will get z or Z.

You can use the methods GetNumberOfKeys, GetKey and GetKeys to get the UTF8 character representation

of the keys pressed in the most recent tick.

Vanilla keys are typically used if you want to enter text into an input field.

Simple Example:

 Logic::IDeviceHandler* deviceHandler = state->GetDeviceHandler();
    UInt32 numKeys = deviceHandler->GetNumberOfKeys();
    for (UInt32 i = 0; i < numKeys; i++)
        Debug::Trace(deviceHandler->GetKey(i));
    if (deviceHandler->WasRawKeyPressed(RAWKEY_Y))
        Debug::Trace("RAW Y PRESSED");
    if (deviceHandler->WasRawKeyReleased(RAWKEY_Y))
        Debug::Trace("RAW Y RELEASED");

It provides a straightforward simplified interface to the XBox game controller, which isn't adequate.

The mechanism for game controller input is similar to keyboard input or touch input. If it is not adequate for you, what is missing?

USB defines a standard, what nonstandard controllers are you talking about?

We will support USB game controllers which are HID compliant. We don’t support USB game controllers which are not HID compliant.

Keys do not have "UTF8 strings", and keyboards do not have "raw" and "vanilla" keys.

The question is what is reported by the framework, not what does a keyboard have.

A keyboard has physical keys, the framework reports key pressed/released state by so called raw keys via the Murl::Input::IRawKeyboardDevice interface.

You are right, the RawKey enumeration is missing on the Web-Site (we are still in open beta phase), but the enumeration can be found in the corresponding header file which is typically used during development.

On the other side every operating system does some kind of mapping a physical key to a localized character. Such a mapped character can be called vanilla key.

The Murl::Input::IKeyboardDevice interface reports these characters and yes of course, these characters are UTF8 encoded, think about e.g. a korean keyboard.

The framework do not report raw keys for non-physical keyboards e.g. touch screen keyboards on mobile devices.

If it isn't documented, your keyboard support doesn't exist.

The methods are documented and the keyboard support does work on all supported platforms.

For example, in which order does Murl::Input::IKeyboardDevice::GetKeys() return its undefined strings?

In the order the keys are reported by the operating system (probably the order the keys are pressed).

The strings are defined by the corresponding pressed key.

I'd like to see comprehensive code examples: configuring arbitrary keys, text entry, modifier keys, etc.

The framework simply provides exactly the same information on all supported platforms.

Configuring arbitrary keys and other features are not supported by the framework.

A sample code for using the IKeyboardDevice is available in the Tutorial section in Chapter02 Tutorial01.

No. It provides a straightforward simplified interface to the XBox game controller, which isn't adequate.