lasso

A generic game loop implementation in C++ based on
Fix Your Timestep!

lasso is at early stages of design and development and is subject to
incompatible changes. All feedback is welcome and appreciated!
Detailed documentation is being built on the
wiki.

Getting started

This project supports the Meson build system,
so you may want to install it (although it is not required). A legacy
CMakeLists.txt still exists, but is not
actively maintained.
A compiler with
Concepts TS
support (e.g. GCC 6 or above with options -std=c++2a and -fconcepts)
is required to use lasso. Then, having Meson installed,
run the following commands at the root of this project:

meson build
cd build && meson install

Alternatively, you may just put lasso.h somewhere in
the source tree of your project.

Using lasso

The meson install command above will put (install) it at /{prefix}/lasso/
(relative to the default Meson
paths).
On Linux, that is /usr/local/include/lasso/.
Then you just need to have /usr/local/include/ in your header search path
and you are ready to #include <lasso/lasso.h>.
Conversely, if you have somehow put lasso.h in your
source tree, you need to #include "lasso.h".

lasso knows how to call into your game via the C++ concept below:

template<typename T> concept bool GameLogic =
requires (T logic,
          LoopStatus const &status,
          duration const &delta) {
    { logic.init() } -> void;
    { logic.simulate(status, delta) } -> void;
    { logic.render(status, delta) } -> void;
    { logic.is_done() } -> bool;
    { logic.terminate() } -> void;
};

That means you need a class or struct that implements the
following member functions:

• void init();, which is called once right before the loop starts and you
  can use it to initialize anything you need (beyond the constructor of your
  class);
• void simulate(LoopStatus const &, duration const &);,
  which is called if delta or more nanoseconds have passed since the last
  call to advance your simulation (input, physics, AI, etc.);
• void render(LoopStatus const &, duration const &);,
  which is called once in every iteration to render what has been simulated;
• bool is_done();, which is called once in every iteration to
  determine whether the loop should terminate;
• void terminate();, which is called once right after the loop ends and you
  can use it to clean up anything you need (additionally to what will be
  done in the destructor of your class).

Additional member functions may be added to GameLogic
and its existing ones might be modified in the future.
There are no constraints on other member functions or
variables that the class may have.
Examples of classes implementing this concept can be seen in the
examples folder, especially the Game.h.
and Game.cpp blueprints.

After having implemented your class (let us call it T),
running it is as simple as:

T t;
// ...
lasso::MainLoop{}.run(t); // or pass in T{} directly

Building the examples

The Simple and Fast Multimedia Library (SFML)
must be installed to compile and run an example.
If you want to enable the compilation of the examples, you may run:

meson build -Dexamples=true
cd build && ninja

or, after having initially run Meson and while at the build/ directory:

meson configure -Dexamples=true
ninja

In order for an example to locate Roboto-Regular.ttf
and hence render text, you must run the compiled executable from either the
build or the examples/ directory (or set any of them as the
working directory in your IDE; preferably the build one).