Game Development Reference
Event management was later implemented though not as a central part of the core.
Events were used within the transform aspect to correctly propagate updates of
node positions to their children, then used in relation to collision events between
physics objects, and finally were implemented within the scene graph to facilitate
asynchronous operations on the structure of the scene graph, processing insertions
and removals. In hindsight it would have been more ecient to implement event
handling from the outset even if it meant proceeding with a less ecient design.
Development of the aspects progressively added functionality to this core.
The first usable build of the engine simply consisted of the render aspect and a
simple file loading module that could parse Collada data and push it into the core
(later formalized as the Collada factory used by the file aspect). This allowed
assets to be exported from model-editing software and imported directly into the
engine. Shortly after this the first pass of the physics aspect allowed the objects
exported with additional data to be updated by a physics simulation. This was
followed by a scripting aspect that updated objects with associated Lua scripts
to perform game logic.
Within a relatively short period of time, project teams were able to start
building games on a simple but functional data-driven engine that grew in func-
tionality as it was required.
As with all designs, there are benefits and limitations to building an engine based
upon aspects. The characteristics of the aspect-based architecture predominantly
benefit the development process through modularity and flexibility of data, but
the rigid structure and indirection create limits on eciency.
Benefits. The benefits of building an engine based upon aspects include the fol-
Promoting a data-driven development philosophy helps to engage asset cre-
ators and designers.
The highly modular drop in/drop out architecture allows quick changes to
The modular nature allows quicker tracking and debugging of errors.
Encapsulation accelerates the integration of third-party APIs.
The direct connection of shader and script inputs makes developing new
graphics techniques and prototype game features easier and quicker.
Decentralizing the knowledge and management of functionality increases
the autonomy of the programmers of different aspects.