The GEAR Engine

Gear is an extendable cross platform game engine. The core technology of Gear is written in portable C++ code where each subsystem is resting on a thin layer to the OS. There are no mandatory dependencies of third party libaries and the rest of the functionality is abstraced away for high portability and ease of use. Components like sounds, graphics and threading are all exposed on this abstracted level for API independece and you only work directly against these interfaces. Gear is a good match for building games and game like applications, e.g., for data visualisation or building advanced 3D graphical interfaces. The applications are written in C++ with optionally scripting in Lua. The content is managed in the Gear editor which in itself is written in the Gear engine with the built in GUI components.

The workflow with Gear is largely effected by the Gear editor. The Gear editor is a What You See Is What You Get (WYSIWYG) content editor that manages resources for Gear applications. Some resource types have inline editors for them, e.g., particles. Some content is created in the editor and some are created in external tools and imported into the editor. Game interfaces can be built directly in the editor by using the built in widget library. Other resource types for example 3D meshes does not have an inline editor, there is no 3D modeling tool in Gear. 3D meshes are created in an external modeling package, like Maya, and then imported into to the editor. The fineshed resources are then exported and built in Gears internal format. These resources can then be imported into a Gear application which is written in C++ with gameplay code can be shared between C++ and Lua. Before deployment all resources are packaged and compressed for distribution and this is also done from the Gear content editor.

Gear can be licensed under four different licenses.
Both source code license and customer based enchancements are also available with the Gear engine.
* User license - where you get the latest precompiled version of the Gear engine and the Gear tools.
* Source code - A source code license where you can extend all part of the engine yourself.
* Extension for the engine - We also can customise the engine as a service a long side a user license.
* Application development with Gear as a base - If you see the potential of Gear but do not have the inhouse expertise to develop this application yourself.

Extends the system
The Gear source base is built up to be as extendable as possible. Everything is built upon interfaces where it is simple to add another back end implementation for an interface, for example adding support for a new sound renderer.

Project types
Gear is intended for but not limited to games, multi platform visualisations or as a base for 3D interfaces. Gear is suitable for both snappy 2D games targeting a majority of all phones and tablet. Or for building the next popular MMO with a larger user base and low hardware requirement targeting both the desktop and the browser. It can also be seen as a base for interaction research where it is easy to deploy and test the software on a wide range of platforms without having to rewrite the application.

Hardware requirements
Gear runs on a large number of hardware configurations on the targetet platforms. It runs on all 2.3+ Android devices. The same Gear application can also easly be cross compiled for the iPhone and iPad. Desktop requirements are set low, OpenGL 2.0 or DirectX10, but the engine does expose more advanced features.

The Gear engine and editor is fully documented with the Doxygen document system.

Gear has been used for building numerous 2D games targeting modern handheld devices with high productivity rate thanks to the editor and easy to use base classes. The Gear engine was also used for 3D interface prototyping for innovative interfaces for high end phone prototypes. It has also been the base for a casual Massive Multiplayer Online Roleplaying Game (MMORPG) and also for inhouse research for augmented reality applications.

Gear architecture

Core subsystem
* Windows, Mac OSX, Linux, Browser (plugin based), iOS and Android support
* Threading abstraction
* Event processing framework
* Blowfish encryption
* Containers (vector, queue, hashmap, ..)
* Smart pointers, memory manager
* String (UTF-8, UTF-16, UTF-32) and localization manager

File and I/O
* File system abstraction
* Archive/Package manager

* Keyboard, mouse, gamepad, touchscreen, accelerometer, etc.
* I18N text input

* Vector/Quaternions/Matrix math library
* Abstracted floating point (16/32/64 precision)

* Lua scripting engine
* Scripting support on event basis in all subsystems

* OpenGL(2.0+), OpenGLES(2.0) backends fully abstracted
* Shader parameter abstraction and management
* Built-in shader library
* Render states

* OpenAL / OpenSLES backend
* Ogg vorbis support

Scene graph
* Adaptive Binary Tree (ABT)
* Customizable render loop
* Particle effects

* Intersection queries for polygon soup and bounding volumes
* Raycasting
* Box2D integration for 2D games
* Plugin structure for integration of 3rd party libraries

* Skeletal animation
* Animation blending

* UI element abstraction for custom widgets
* Standard widget implementation
* Scriptable events

* TCP and UDP
* Blowfish encryption

* Complete platform abstraction
* Entity framework with state based logic
* Special 2D game application helper classes

Tools and integration
* Custom WYSIWYG Editor for all content
* Maya plugin
* Expandable game specific data