gintonic

Welcome to gintonic! This is a personal render engine of me. The current render
strategy is deferred rendering.

Before Building

OSX

Install the latest version of Xcode and brew. Then install boost and CMake
with brew:

$ brew install boost
$ brew install cmake

Ubuntu (possibly also other Linux flavors)

Make sure have a modern compiler (modern GCC or modern clang). Install boost,
cmake and git with your package manager.

Windows

Install the latest version of Visual Studio C++. Install the latest version
of CMake. Install a fairly recent version of boost. Make sure you have a git
client.

Cloning

Clone this repository recursively in order to clone all the submodules too:

$ git clone --recursive https://github.com/rwols/gintonic.git

Building

We use CMake in the most standard way possible, no surprises. That means that
you should execute the following commands on the command line in order to build
the project:

$ cd path/to/gintonic
$ mkdir build
$ cd build
$ cmake ..
$ cmake --build .

It’s recommended to build with Ninja:

$ cmake .. -G "Ninja"

On Windows, the freetype library cannot be built as a shared library, so use
the following command line invocation for CMake:

$ cmake .. -DBUILD_SHARED_LIBS=OFF

You can optionally build release versions (the default is Debug):

$ cmake .. -DBUILD_SHARED_LIBS=OFF -DCMAKE_BUILD_TYPE=Release

Structure of This Project

In graphical form, the directory structure looks like this:

gintonic:
  - assets:
    - CMakeLists.txt
    - <more directories>
  - examples:
    - CMakeLists.txt
    - <cpp files, each of which is a separate example executable>
  - include:
    - CMakeLists.txt
    - cmake:
      - <Doxygen related files>
    - Foundation:
      - <header files>
    - Graphics:
      - GUI:
        - <header files, deprecated>
      - OpenGL:
        - <header files>
      - Shaders:
        - <glsl shader files>
      - <header files>
    - Math:
      - <header files>
    - <header files>
  - lib:
    - <third party git submodules live here>
    - CMakeLists.txt
    - <implementation files, mirrors the include directory structure>
  - test:
    - CMakeLists.txt
    - <various unit test cpp files>
  - tools:
    - <various subprojects for tools development>
  - CMakeLists.txt # The root cmake file.
  - README.md # <-- You are here.

Example Executables

The example executables are located in examples. Each .cpp file is a single
example. When building has finished, and assuming the project was built in the
build folder, the example executables are located in build/examples.

Roadmap

I’m currently in the process of refactoring a lot of code. Most notably, the
Renderer object (located in include/Graphics/Renderer.hpp and
lib/Graphics/Renderer.cpp) has become so large that it has become infeasible
to move the project forward. Moreover, Entities are in the process of getting a
facelift. The current implementation has a bunch of hard-coded pointers to
component objects; this should just be a vector. Dynamic casting will then be
handled via dynCast in include/Casting.hpp. Next, a general Asset system is
needed to make this engine data-driven. Take a look at the issues page to see
what is being worked on.