sirbob01 / dynamo-engine

A C++ game engine powered by Vulkan

---

Dynamo is a C++ game engine powered by Vulkan.

Features

• Native support for an optimized ECS architecture in designing game objects
• A simplified Scene management system
• Rendering engine powered by the Vulkan API
• An audio engine that supports multiple playback tracks and raw PCM data manipulation
• ... and more!

These features allow it to be used as a framework for general multimedia applications.

For a more in-depth look at the engine's components, visit the wiki.

Rationale

I built this because I've always wanted to understand how game engines worked under the hood. This is mostly a learning exercise, but I also use it for my personal projects because of its flexibility and reusability.

Dependencies

To use Dynamo, the compiler must support at least C++17.

Dynamo uses a number of submodules that can be installed by running git submodule update --init

Running Demos

The engine comes with demo programs to test core features of the engine. To compile them, cmake must be installed. Go to the /demos/build directory, then run:

• cmake .. -G BUILD_GENERATOR
• make

Replace BUILD_GENERATOR with the generator applicable to your development environment. This assumes that all the dependency requirements are satisfied.

Running Tests

Similar to the demos, the tests need to be built. Go to the /tests/build/ directory then run:

• cmake .. -G BUILD_GENERATOR
• make
• ctest --verbose

Contributing

Anyone is welcome to open a pull request! State the issue being solved and explain the solution precisely. Just ensure that the new code adheres to the style of the codebase.

For high-level suggestions on improving the engine, open an issue so we can have a discussion.

License

Code and documentation Copyright (c) 2019-2022 Keith Leonardo

Code released under the MIT License.

dynamo-engine's Issues

Jukebox - Partitioned IR convolution

Implement a partitioned (uniform or non-uniform) convolution algorithm for long impulse repsonses.

This will allow the real-time playback of sounds convolved with a filter that simulates environments (e.g., echo and reverb).

Create sample game

Improve documentation by creating a demo game using the engine.

Jukebox - Device selection

Jukebox currently uses the PortAudio library as a cross-platform sound API. Unfortunately, it does not have the functionality to receive device count change events. This leads to stuttering if the new default device has different stream parameters to the old one.

Until the PortAudio team decides to release this feature, I'll be thinking of migrating to libsoundio. Again though, libsoundio is build failing on MacOS because it is using a deprecated API, so can't use that yet either.

Ugh.

Jukebox - Doppler effect Filter

Implement a filter for Doppler effect. This may necessitate a change in the Filter API depending on how I choose to implement this:

1. Resampling procedure
2. Pitch shifting, time constant

If I choose to take 1, the filters will need to account for the length of the output signal, since resampling can lengthen or shorten it.
If I choose to take 2, the algorithm will be more difficult to implement lol (+ might have more computational overhead?)

Add networking module

Implement a client-server model for multiplayer games.

Jukebox - Multichannel support (e.g., quad, 5.1, 7.1 surround)

Refactor internal API (e.g., Filters) to handle Sound input and output with different numbers of channels

Implement ThreadPool

Implement a ThreadPool utility class to encapsulate enqueueing concurrent processes to be assigned to available threads

Create AI module

Add generic routines for pathfinding (i.e. A*) and simple finite-state machines.

Create module for dynamic lighting

The module should allow the placement of dynamic 2D light sources. These should cast shadows around the world given a list of polygons. The light sources can also be adjusted for luminosity, color, and may even have special image textures.

Migrate to Vulkan

Use Vulkan as the API handling low-level rendering

Jukebox - Optimize FFT algorithm

Implement the N/2 real-to-complex FFT optimization algorithm described here:

• https://www.ti.com/lit/an/spra291/spra291.pdf
• https://cse.hkust.edu.hk/mjg_lib/bibs/DPSu/DPSu.Files/Ga95.PDF (Appendix 1)

This will half the time it takes to compute FFTs of some signal.

Integrate Dear ImGui

Use the Dear ImGui library to create a user interface for the editor, built on top of the engine's runtime.

Renderer - Support multiple backends

For future versions, implement an abstract Renderer interface to support multiple API backends

• Vulkan
• Direct3D
• Metal
• OpenGL (??)