matrix: use correct matrix multiplication functions
matrix: add print function
tests: add some matrix tests

* add delta to float comparision
tests: fix style. make delta smaller
Merge pull request #6 from lubosz/matrix+tests+review

Use the correct matrix multiplication function and add some tests.
build: Add more aggressive compiler flags

We should be building Graphene with more aggressive optimizations, and
with enough flags to let the compiler know what we want.
Drop the GRAPHENE_BENCHMARK conditional

We cannot build Graphene with a run-time selectable backend without
building a whole vtable and paying its price.
Rework the implementation of the SIMD types

The current implementation of the SIMD types is slightly less useful
than it ought to be, and we should make it better. The main goal of this
commit is to make the SIMD vector and matrix API public and usable
outside of Graphene itself, through the judicious application of
inlining and macros.

We can inline everything inside the simd4f.h and simd4x4f.h headers, and
use compiler extensions to macroize all the platform-specific API using
a trick similar to the one used by gatomic.[ch] in GLib. Currently, this
means that we support only GCC and GCC-compatible compilers, like Clang;
supporting SunCC and MSVC would be nice, but it'll require some help
from people that have access to those compiler suites.
bench: Restructure the benchmark test suite

We want to benchmark the pure, SIMD matrix API instead of the typed
wrappers around it; by doing so, we will be able to test the different
implementations in the future, since those get inlined into the test
suite, instead of being inlined into the library.
Restore the ability to override the SIMD implementation

This allows us to have a proper benchmark suite that can go through all
the implementations available at compile time, in order to measure their
relative performance.
bench: Build the SIMD matrix test case for every implementation

And run all the available implementations.
matrix: Coding style fixes for print()
tests: Use proper formatting for the fuzzy eq message

We can reuse the assertion message API from GTest.
bench: Test projection

We should benchmark the implementation of some common methods in the
graphene_matrix_t API. We start from point projection.
Remove unnecessary files

We folded every SIMD per-implementation and shared header into the main
ones, so we don't need them any more.
matrix: Use degrees in the graphene_matrix_t rotation API

We can keep using radians in the underlying SIMD implementation, but the
public-facing convenience API should use the more convenient unit
instead.

Fixes issue #4.
Merge pull request #7 from ebassi/issues/4

matrix: Use degrees in the graphene_matrix_t rotation API
Add API reference

We use gtk-doc to generate the API reference.

Still needs lots of love, but it's a starting point.
docs: Add description for graphene-gobject
Add custom allocator for SIMD-backed types

While we're guaranteed the alignment of SIMD types on the stack, the
same guarantees do not apply when allocating them on the heap. We can
assume that malloc() will align to multiples of 8 and 16 on basically
all the platforms we care about, but it's not something we can take for
granted.

Luckily, we can check if the platform we're compiling for has an
allocator function that supports alignment; with the advent of ISO C11
and its aligned_alloc() the chances that the platform has that function
or one close to it in semantics and behaviour, the check is likely to
turn out something we can use.