Ketschak

Members
  • Content count

    8
  • Joined

  • Last visited

Community Reputation

134 Neutral

About Ketschak

  • Rank
    Newbie
  1. You can probably use every mobile cross platform solution out there like Unity3d, Corona, libgdx, Marmalade, Mul Engine etc. If you want to give Murl Engine a try here is the link to the sound tutorial: http://murlengine.com/tutorials/en/_tutorial_chapter01_t04.php
  2. Finally we added a Feature List to the Murl Engine website: http://murlengine.com/?murlpage=features
  3. Yes, you can develop a game for Windows 7, Windows 8 and Mac OSX with our engine. Please note that at the moment we only support Win32 (in regard to Windows). This mean you can build a Win32 Application/Game which will run on Windows XP and on Windows 7 and on Windows 8. In the future our framework will also be able to build WinRT Applications. Support for WinRT is scheduled for Q4-2013. Further information regarding WinRT can be found here: http://en.wikipedia.org/wiki/Windows_Runtime
  4.   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:     At the moment of first pressing the key down, WasRawKeyPressed() returns true for exactly one logic tick     As long as the key is down, IsRawKeyPressed() returns true in every logic tick.     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");       The mechanism for game controller input is similar to keyboard input or touch input. If it is not adequate for you, what is missing?      We will support USB game controllers which are HID compliant. We don’t support USB game controllers which are not HID compliant.
  5. 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.
  6. Thanks for you input. We will add this information to our website.
  7. 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.
  8.   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.