The Raylib C++ Starter kit is a template project that provides a simple starter template for the raylib game tools library incorporating the raylib-cpp C++ bindings and using Make for building. The starter kit can automatcially clone down raylib and the bindings, compile them, and setup the project for separate compilation using a static library.
Why static linking?
One of the most absurdly annoying things about C++ development is finding and linking dynamic libraries. The raylib project prides itself on having "NO external dependencies", and we tend to agree that portability is way cooler than saving that fraction of a second on compile-time.
Why not just use CMake?
I guess we just don't want the added headache. CMake is complex and sometimes feels like some arcane magic that we generally take for granted in build systems. If you look at the raylib library, yes it has CMake support, but it generally encourages the use of Make on all platforms because as the library reads:
raylib is a programming library to enjoy videogames programming; no fancy interface, no visual helpers, no auto-debugging... just coding in the most pure spartan-programmers way
So that being said, we hope that this repository finds you well and wholeheartedly enjoying the simple things in life (i.e. video games programming).
| OS | Default Compiler | Last Manual Build | Compile Status |
|---|---|---|---|
| macOS | Clang++ | Big Sur 11.0.1 |
 |
| Linux | G++ | Ubuntu 20.04 LTS |
 |
| Windows | MinGW (G++) | Windows 10 20348 22H1 |
 |
If you have any experience with Docker, you can try it out using a dev container. A "development container" is a container volume with all of the needed tools and dependencies already installed. Using a dev container may simplify your setup because everything comes in a single "box" without messing around your operating system.
Using a dev container requires VS Code and Docker to be installed (I have tried Podman and it has some issues, will fix later). Once they are installed, you can click the badge above or here to get started. Clicking these links will launch VS Code and install the "Remote - Containers" extension if needed, clone the source code into a container volume, and spin up a dev container for use.
Before building the project, you will need to install all relevant dependencies for your platform so that the project has access to all the tools required, and raylib can compile and link correctly. You can find intructions for installing dependencies on macOS, Linux, and Windows in the docs file on installing dependencies.
Once you have cloned this repository and installed dependencies, building the project is as simple as running two commands in a single line in its root directory:
$ make && make run> mingw32-make && mingw32-make runThe command will first clone in the lastest C++ bindings and targeted version of raylib, copy across any relevant header files into /includes, and build a static library file from them, placing it in /lib. Then it compiles your project using the source code in /src/main.cpp. Finally, the second command will try to run the compiled program, but only if the compilation is successful.
If a window pops up, congratulations, you've successfully built the project and you can now start programming your game!
Now that you have the project setup and compiling on your system, it's time to start programming! If you aren't already familliar with raylib, we recommend looking over this awesome cheatsheet which lists every function, struct and macro available in the raylib C library. If you want specifics on how to use the C++ bindings, then you should check out the raylib-cpp repo, which nicely explains how the bindings work and contains raylib's examples ported to C++.
Once you're up and running, we first of all recommend that all your code for the game should go into the /src directory, which is automatically included in the compile process when you run Make. The default entry point for the program is /src/main.cpp (which is pretty standard). If you wish to change the program entry point, add more libraries, or really anything about your project, all build instructions are specified in the Makefile - no smoke and mirrors!
When building compiled applications from scratch, each source file needs to be compiled into an object file in order for them all to be linked together as a full program. This can become rather time-consuming and inefficient as your codebase expands to use tens or even hundreds of files that recompile each time you build. Fortunately, with a few clever rules in our Makefile, we can be sure to only have to recompile files affected by our changes.
By using the following Make commands instead of the default target, we can skip the cleanup and setup step, and only recompile files that changed:
$ make build && make run> mingw32-make build && mingw32-make runUsing this method can save you a huge amount of time compiling (in reality, just a few seconds) each time you make a small change to your code! If you want to know more about how it works, you should have a read through the docs entry explaining the Makefile.
While separate compilation works quite well in most scenarios, it's not magic, and there are a few caveats to take note of here:
- Changing
.hfiles will often result in longer compile times by causing all files that include them to recompile - Constant changes to files included by many others in your program (like a base-class) will also cause all of those dependent to recompile
- Including widely-scoped files (like the whole of
raylib-cpp.hpp) will add all of its own includes as dependent and increase the build time - Placing includes in
.hfiles instead of forward-declarations will also increase recursive includes and therefore the build time
For working with some projects, you may want to pass arguments to the program once it's been built. This can be achieved by assigning values to the ARGS flag in the Makefile like below:
$ make run ARGS="--somearg"> mingw32-make run ARGS="--somearg"You may also want to pass in your own macro definitions for certain configurations (such as setting log levels). You can pass in your definitions using CXXFLAGS:
$ make CXXFLAGS=-DMY_MACRO=1> mingw32-make CXXFLAGS=-DMY_MACRO=1If you want to use a compiler for your platform that isn't the default for your system (or potentially you would like to explicitly state it), you can make use of the system-implicit CXX variable like so:
$ make CXX=g++> mingw32-make CXX=g++It's pretty simple actually:
- Fork it from here
- Create your feature branch (
git checkout -b cool-new-feature) - Commit your changes (
git commit -m "Added some feature") - Push to the branch (
git push origin cool-new-feature) - Create a new pull request for it!
- J-Mo63 Jonathan Moallem - co-creator, maintainer
- Raelr Aryeh Zinn - co-creator, maintainer
- mTvare6 mTvare6 - contributor
- rafaeldelboni Rafael Delboni - contributor
- jason-cannon Jason Cannon - contributor
- return215 Muhammad Hidayat - contributor
This project is licenced under an unmodified zlib/libpng licence, which is an OSI-certified, BSD-like licence that allows static linking with closed source software. Check LICENCE for further details.