Matrices added

-Added GSmath that implements Vector classes and Matrix4f class for
graphics. It has members for initializing specific matrices (like
scaling, translation or projection) as well as overloads for matrix
math.
-GL1 matrices replaced with the ones implemented now. They also renamed
as they didn't make sense (wtf is transformation? GL has only model,
view and projection matrices).
-If using extern math functions (like random) they should probably work
using ma_scalar. So fixed that in move_functions.cpp. Doesn't change
anything as now ma_scalar == cs_scalar == double.
-All parameters in d3d_ functions are now gs_scalar - even angle and
aspect ratio. This is done for consistency as well as the fact that they
are used in matrices which are also gs_scalar (so no benefit and only
requires as cast).
-Started porting GL3 d3d_ functions. Right now segfaults.
-Added an extension for general purpose matrices. It implements
templated matrices as well most used matrix functions (like inversion).
Works on any size matrix.
Also easy to use - "matrix<int> a(3,3,5), b(3,3,2); matrix<int> c =
a*b;"
Or "matrix<char> c(5,5,'a'); draw_text(10,10,a.print());"

Doesn't work now because EDL doesn't allow classes. Should work with new
parser.
Fixes segfault and GL1 fixes

-Fixed segfault that was caused by copy() inside matrix members.
-It now sends matrices to GL correctly (in both GL1 and GL3). Turns out
I have to transpose them when loading, because GL is column-major while
C++ is row-major.
-Fixes orthographic projection and GL3 renders now.

Lots of debug printf's in there as well for now.
Fixes GL1 batcher and GL3 matrices

-Added the same check in GL1 batcher as in the others, that would stop
the game from breaking when _end() is called after _begin() without any
vertices.
-Fixed GL3 transformations and made projection functions flush the
batcher. This fixes segfaults in minecraft example (because without
flushing it the GL3 batcher broke).
-Fixed draw_getpixel() functions in GL3 (again). They didn't flush the
batcher (again). This was also seen as a bug in minecraft example.
Fixes for Minecraft and Mario

-Fixed more matrix math functions.
-Fixed model draw function which was still using glTranslate.
-Removed all the debug printing.
-Final matrix multiplication is done just before drawing and loading
matrices are also done just before that. On one side this reduces the
useless calls in d3d_ functions. On the other, sometimes a hundred draw
calls are made before a transformation. So there will have to be a check
here to know when to update and when not to update.

In my benchmarks the current GL3 with matrices are 70FPS faster in
Minecraft example (920FPS vs 850FPS), but is slower in Mario examples
because it updates on every draw call. Will add a check and see where it
gets us.
Implement window_set_alpha
Miscellaneous function just for funsies.
Implement window_get_alpha
Implements Base64 string encryption.
Cleanup
Add -fexceptions to JSON extension makefile so it builds for Windows.
Fixing JDI error
Rename thread_finished to thread_get_finished
Backup JoshDreamlands ENIGMA icons.
Fix: saved them as XML by mistake.
Scoped matrices and remade GL1 to use them

-Now all matrices are in enigma:: namespace, so that it doesn't clutter
the global one (or the user one).
-Added a "transformation_update" bool which tells when to update
matrices. This gives about 50FPS in Mario example. This is needed
because the update happens before the drawing and the drawing usually
happens a lot between transformation functions.
-GL1 is also using the custom matrices now. But the speedup here is a
lot less inconsistent. With the glFunctions Mario goes up to 1100FPS,
while with these changes it goes to 970FPS. So I am not sure if these
changes should be kept. In example like Minecraft, there is a speed
boost though. Additional tests should be conducted.

Maybe the math functions can be faster? We could implement them using
SSE and that shouldn't break compatiblity as everyone since Pentium3 has
them. But doesn't the compiler already does that? Should probably check.
Boosted matrix functions

-Added specific matrix functions, so things like rotateX/Y/Z which makes
a specific matrix taking into account that other axis are zero.
-Translate and Scale are now using expanded form taking into account
that they are very specific. This greatly reduces the multiplication
overhead.

These two optimizations boosted Mario example in GL3 from 800 to 990FPS
(a 190FPS increase!). I will do the same for GL1 now.
Boosted GL1

-Remade GL1 transformation functions to use the new optimized matrix
functions.

This increases Mario example FPS from 940 to 1190 - thats 20% boost. The
current method in Master (using only GL matrix functions) give 1140FPS,
so the overall boost is much smaller, only about 4%. In examples like
Minecraft, there is no real difference between the old GL1 and this one.
So it's guranteed to be at least as fast, but often times faster (if
using a lot of transformation functions).
Fix up thread code to Josh spec. and fix XLIB compile error.
Fix line ending.
Fixes ASYNC extension for other platforms.
Fix indentation.