/gou

GOU game engine

Primary LanguageShellMIT LicenseMIT

GOU

The name GOU is in honour of the Game of Ur (also known as The Royal Game of Ur), the oldest known boardgame, first played between 2600 to 2400 BC. Pronounced gah-ow like in gouge.

GOU is a game engine, with the following key features:

This is an early work-in-progress, most of the below features do not yet exist!

  1. Component Entity System based game entities with scene-tree based game logic that uses signal-slots based entity communication
  2. Multi-threaded systems
  3. Visual scripting for creating gameplay interactions by connecting signals to slots
  4. Modular engine, all game-specific logic is in modules, scripts or configuration
  5. Modules are hot-code reloadable (TODO: figure out how to reload systems)
  6. Configuration, scenes and game data described in human-readable TOML files
  7. Built-in support for intelligent AI agents and procedural content generation
  8. Focused on 2.5D or 3D Action RPG games
  9. Deferred-texturing based renderer

Dependencies

Engine dependencies:

  • C++17 and OpenGL 4.6 (4.1 on OSX)
  • BehaviorTree.CPP - Framework for creating and executing behavior trees (MIT License)
  • Bullet Physics - Physics engine (zlib License) [TODO: Replace with PhysX]
  • Catch2 - C++ testing library (Boost Software License)
  • cr.h - Module live reload library (MIT License)
  • cxxopts - Lightweight C++ command line option parser (MIT License)
  • Dear ImGui - Bloat-free graphical user interface library for C++ (MIT License)
  • easy_profiler - Function runtime profiling (choice of MIT and Apache v2)
  • EnTT - Entity Component System (MIT License)
  • FastNoiseSIMD - Library of various SIMD-optimised noise functions (MIT License, note: Simplex noise is patent-encumbered when used for texture generation)
  • fast_obj - A Wavefront OBJ loader (MIT License)
  • GLAD - OpenGL extension generator (MIT License)
  • GLM - OpenGL Mathematics library (The Happy Bunny/Modified MIT License)
  • ordered-map - Order-preserving hash map/set (MIT License)
  • vecmath - SIMD vector math HAL (BSD 3-Clause License)
  • PhysFS++ - C++ wrapper for PhysicsFS (zlib License + notes)
  • PhysicsFS - Library for filesystem abstraction (zlib License)
  • SDL2 - Windowing & Input (ZLIB License)
  • SoLoud - Portable audio engine (zlib/libpng License)
  • Sparsepp - A fast, memory efficient hash map for C++ (Custom do-almost-anything License)
  • spdlog - Fast logging library (MIT License)
  • stb_image - Image loader (Public Domain)
  • taskflow - Parallel task programming framework (MIT-like Taskflow Lisence)
  • tinygltf = gLTF loader (MIT License)
  • toml11 - TOML data file loader (MIT License)
  • tweeny - Inbetweening library (MIT License)

Editor-specific dependencies:

Building from surce:

  • tup - Tup is a file-based build system for Linux, OSX, and Windows (Dual License GPL-v2 or Commercial)

All dependencies (except SDL and the build tool, Tup) are contained in the source tree (under vendor/) as git submodules.

Building (with Tup)

Make sure you have Git, Clang, SDL2 and Tup installed.

git clone git@github.com:danielytics/gou.git
cd gou
git submodule update --init
./generate_components.sh
tup variant builds/*.config
tup

Now you can run the engine using one of:

  • ./run.sh debug to run the debug build (no optimisations, debug and development features)
  • ./run.sh dev to run the development build (optimisations, development features)
  • ./run.sh release to run the release build (optimisations, development features & debugger symbols stripped)

The development version is intended for developing games with GOU and includes access to editor tools.

The debug version is intended for developing the engine itself, or when debugging a game. May run slowly.

When developing GOU modules (or the engine itself), always building all three builds at once may be too slow. You can build each version in isolation with:

  • tup build-debug to build the debug build
  • tup build-default to build the dev build
  • tup build-release to build the release build

Components are specified in components.toml files (in engine/components.toml for core engine components, or in modules/*/components.toml for module-specific components). If these files are modified, it is necessary to rerun ./generate_components.sh to regenerate the component header and source files. The initial run also compiles the generator, but subsequent runs should be very quick.

Building (without Tup)

Alternatively, you can use the tup-generated build scripts to build the engine and modules without tup. Note that any newly added files or modules won't be built unless you update the scripts.

Make sure you have Git, Clang and SDL2 installed.

git clone git@github.com:danielytics/gou.git
cd gou
git submodule update --init
./generate_components.sh

Then, on Windows:

build.bat

And on Linux:

./build.sh

Alternatively, use build_debug.sh/build_debug.bat to build a debug build, or build_dev.sh/build_dev.bat to build a dev build.

License

GOU is released under the terms of the MIT License.