The Yake Engine is a component-based, object-oriented engine written in C++ and primarily designed for VR applications and games. It abstracts typical low-level and middleware APIs and provides various low, mid and application level functionality as well as tools to create and import content.

Yake is a small, flexible, cross-platform game engine / application framework multi licensed under the LGPL and custom licenses. (It’s not targetted to compete with the well-known high-end engines.)

Yake is young. Nevertheless, it is used in several game and non-game projects. Parts of Yake are experimental and may become subject to refactoring.

The goal is, to provide an genre-independent engine which can be used for a variety of VR applications and to provide essential tools to import/edit/create content (to give an example: in-application editors allowing remote object inspection through runtime reflection).

Yake provides various core functionality, an API abstraction layer for typically used middleware and similar functionality (from audio, graphics, physics to network replication, pathfinding, persistance etc) and high-level implementations for ready-to-use application-level objects (complex models which combine physical, graphical/visual and audible aspects as well as the interaction between sub-components).

Yake’s design is very generic, with a lot of flexibility. We reach this goal by using plugins and an open data-driven approach as well as generic and meta-programming techniques.

Default implementations for various pluggable systems and factories are provided.

Furthermore Yake and Yapp provide infrastructure for math, serialization and persistance, events, resource management, state machines, affectors, listeners etc.


Features:

- cross-platform
- many ready-to-use components
- entity system, with pluggable scripting modules for scripting entities’ state machines, dynamic events and more
- abstraction components with pluggable backends for physics, graphics, input, audio and scripting
- at least one plugin for each component, sometimes more
- loaders for scenes, and complex models
- scene exporters for 3dsmax (Octopus)
- flexible design, genre-independent
- rendering plugin: OGRE
- physics plugins: ODE and Novodex
- scripting plugin: Lua
- audio plugin: OpenAL


Components:

yake::base

- cross-platform
- meta programming tools
- container wrappers & helpers
- OS independent dynamic library mchanisms
- templated id-based pluggable registries/factories
- various common functionality

yake::math

- cross-platform
- curves: line, polyline, spline
- random number generator
- vectors, quaternions, matrices ...

yake::physics

- cross-platform
- API independent
- shapes: trimeshes, planes, boxes, spheres, capsules (+ API dependent)
- joints: fixed, hinge, ball, slider ...
- breakable joints
- body based motors: thrusters and more
- materials (per-shape)
- feedback via signals and/or event handlers for collisions, joint-breaking and stepping
- loading of XODE XML files
- XODE exporter for 3dsmax (included in Octopus for 3dsmax)
- plugins: Novodex, ODE

yake::graphics

- cross-platform
- API independent
- node based scene graphs
- provides objects like entities, lights, cameras etc
- serialization via dotScene and related file formats
- dotScene exporter for 3dsmax (included in Octopus for 3dsmax)
- plugins: OGRE

yake::scripting

- cross-platform
- API independent
- virtual machine (VM) and script interfaces
- abstract binder mechanism
- plugins: Lua

yake::scriptingBindings

- cross-platform
- provides common scripting binders for Yake
- plugins: Lua

yake::input

- cross-platform
- API independent
- provides management of devices (keyboard,mouse,joystick)
- freely configurable action maps
- plugins: OGRE

yake::audio

- cross-platform
- API independent
- provides audio worlds with sources and listeners etc
- plugins: OpenAL based

yake::reflection

- experimental C++ reflection, more information to come

yake::file

- information to come

yake::msg

- cross-platform
- messaging, listeners, handlers, managers, queues

yake::fsm

- cross-platform
- experimental templated finite state machine
- templated states and transitions

yake::model

- cross-platform
- work-in-progress high-level model system
- manages graphical, physical, audible and other kinds of submodels
- pluggable inter-model relationships and interactions
- data-driven design
- serialization via dotLink, dotModel and dependent file formats (e.g. dotScene)
- dotLink export for 3dsmax (included in Octopus for 3dsmax)

yake::raf

- cross-platform
- flexible application framework
- easy configuration
- predefined application states for common use cases
- extensible

yake::ent

- cross-platform
- high-level entity based simulations
- feedback & scripting hooks
- static & dynamic entity events
- dynamic entity state management
- any number of scripting / virtual machines per entity
- flexible defintion of behaviour using native C++ and/or any number of scripts per entity
- client/server states, events and properties (work-in-progress!)

yake::entLua

- cross-platform
- binds yake::ent to Lua for easy scripting

yake::entCommon

- cross-platform
- implementation of entities commonly used in applications (lights, pawns, etc)

yake::gui (aka yapp::gui) (WIP)

- cross-platform
- flexible gui wrapper
- makes heavy use of meta programming techniques and reflection
- very dynamic, with serialization using Lua
- editor
- plugins: CEGUI