Core Libraries v.3

Ok, next iteration of build environment and class hierarchies.

I haven't done this in a while. In fact, it's almost been a decade. Since the last time I attempted it I became a big fan of GNU Make and just gave up on IDE project files entirely. Honestly, vim, make, gcc, what more could you want?

Selling points: (Despite being free) It takes an absolute minimal number of lines to write a bare-bones application. Here's what the GLApp test case Makefile (found here) looks like:

1. DIST_FILENAME=test This specifies the base name of the distribution file to build. Extensions are inferred by the distribution type and by the platform.
2. DIST_TYPE=app This says what type of application we're making. Options include "app" and "lib".
3. include Path/To/Common/ This is the one file that everything needs to include. Everything under the hood is in here.
4. include Path/To/GLApp/ From here on down, just include the associated file for each dependent project. All required libs, macros, etc are added from within these files.

Now to get a window up. Here's the code for that:

1. #include <GLApp/GLApp.h> Header for our GL application base class.
2. struct Test : public GLApp::GLApp {}; Our subclass.
3. GLAPP_MAIN(Test) This line tells the GLApp framework that this is what main() should instanciate.
Done. Override init(), resize(), and update() and provide your application code. The example cpp file can be found here.

Here's the various projects (and their associated GitHub repos):

Common - The heart of it all. Not just the core classes, but also the core build script.

Tensor - Tensor math library. A disgusting mess of template metaprograms. Supports memory optimizations for symmetric and antisymmetric neighboring indices. Might also hold some metaprogram for-loops for its vector operations.

Parallel - (dependencies: Common) A first shoddy attempt at a thread pool that can be easily swapped out for std::for_each any time you want to iterate asynchronously across some large dataset. I am not ashamed to say I use this in my CPU-based Hydrodynamics and Relativity projects.

Profiler - (dependencies: Common) Profiling code that spits out some basic DAG-based call graphs and performance stats.

LuaCxx - (dependencies: Common) Some classes to wrap Lua state access. Makes for easy config file reading and writing -- of variables and functions.

Image - (dependencies: Common, Tensor) Basic image reading/writing clases.

GLApp - (dependencies: Common) Foundation for all OpenGL-based applications. Gets an OpenGL window up and running.

Shader - (dependencies: Common) Some classes for OOP-izing vertex and fragment shaders, as well as shader programs.

CLApp - (dependencies: Common, Tensor, GLApp) Foundation for all OpenCL-based applications. Shameless plug for my GPU-driven Hydrodynamics project.

There you have it.