Emergence

Emergence is a flexible set of libraries for gameplay development that aims to become modular game engine in the future. Currently under development.

Architecture

Emergence architecture is built upon concept of units: relatively small modular libraries that provide singular feature to the user and depend on one another in order to do it. There is 3 kinds of units:

• Interface units provide only headers.
• Concrete units provide headers and one concrete implementation for them.
• Abstract units provide headers with abstract API and several implementations for them as concrete units.

Every unit is either an object or interface library, therefore it is possible to explicitly control what goes into which output artefact (shared library or executable).

This architecture aims to:

• Make link time polymorphism easy to use through abstract units.
• Make modularization straightforward, easy to define and implement.
• Make it easy to separate modules into several shared libraries.

Features

Core

• Assertions with interactive mode in Assert unit.
• Interface for CPU profiling setup in CPUProfiler unit.
• Interface for byte sequence hashing in Hashing unit.
• Intermediate layer for input registration in InputStorage unit.
• Lightweight job dispatch implementation in JobDispatcher unit.
• Logging with multiple sinks interface in Log unit.
• Math structures for game development in Math unit.
• Memory management structures in Memory unit.
• Memory usage profiling implementation in MemoryProfiler unit.
• High level memory usage recording logic in MemoryRecording unit.
• Low level render abstraction layer in RenderBackend unit.
• Reflection-driven serialization in Serialization unit.
• Fast field-only reflection in StandardLayoutMapping unit.
• Arbitrary task graph execution implementation in TaskExecutor unit with task graph format in TaskCollection unit.
• Testing backend abstraction layer in Testing unit.
• File system virtualization with packaging support in VirtualFileSystem unit.

Resource management

• Simplistic routine for resource cooking implementation in ResourceCooking unit.
• Prefab-like resources with inheritance implementation in ResourceObject unit.
• Resource scanning and loading layer in ResourceProvider unit.

Data management and processing

• Task graph construction with race condition validation in Flow unit.
• Indexed data storage implementation in RecordCollection unit with visualization in RecordCollectionVisualization unit.
• Multi-type data storage with prepared queries support in Warehouse unit.

Celerity

Celerity is an ECS-like game world architecture solution. It provides interface for building modular worlds, that consist of multiple logical parts. For example, tools like unified editor might be modelled as a world with multiple independent sub worlds. It has lots of extensions:

• Assembly pattern implementation in CelerityAssemblyLogic and CelerityAssemblyModel units.
• Asset management routine implementation in CelerityAssetLogic and CelerityAssetModel units.
• Input abstraction layer implementation in CelerityInputLogic and CelerityInputModel units.
• Localization implementation in CelerityLocaleLogic and CelerityLocaleModel units.
• Physics 2d simulation in CelerityPhysics2dLogic and CelerityPhysics2dModel units with optional debug draw in CelerityPhysics2dLogicDebugDraw and CelerityPhysics2dModelDebugDraw units.
• Physics 3d simulation in CelerityPhysics3dLogic and CelerityPhysics3dModel units.
• Simplistic 2d rendering implementation in CelerityRender2dLogic and CelerityRender2dModel units.
• Foundation toolkit for rendering implementation in CelerityRenderFoundationLogic and CelerityRenderFoundationModel units.
• Configuration resources support in CelerityResourceConfigLogic and CelerityResourceConfigModel units.
• Prefab-like resources support in CelerityResourceObjectLogic and CelerityResourceObjectModel units.
• Transform hierarchy with logical/visual split implementation in CelerityTransformLogic and CelerityTransformModel units.
• Simplistic UI implementation in CelerityUILogic and CelerityUIModel units.

Other

• Utilities for command like tools in CommandLine unit.
• Common containers in Container unit.
• Intermediate graph format in VisualGraph unit with export to common formats in ExportGraph unit.
• Lightweight implementation of object handles in Handling unit.
• Utilities for multithreading in Threading unit.
• Utilities for working with time in Time unit.
• Utilities for working with templates and unions in Traits unit.

Executables

• MemoryRecordingClient: tool for viewing MemoryRecording serialized tracks.
• Platformer2dDemo: simple platformer game in early stage of development, used to test new Emergence features.