Some tests were marked as needing to run with lower pass percentages due to imprecision issues. Now that the test suite is using jequality again, some of those pass rates can probably be raised.

This allows instances to be repositioned inside large packed ByteBuffers.

Ala https://github.com/io7m/jregions

Depends on #12

With the recent changes switching everything to operating via interfaces, it'll be possible to have a range of matrix types that share the same code. The current matrix types should therefore be renamed to indicate the fact that they're backed by direct memory (and some non-direct types should be provided).

Re-implement all of the old clamping methods.

These are vectors that implement the single precision float interface, but store data as IEEE754 binary16 values internally.

toAxisAngle :: Quaternion -> (Vector3, Double)

Re-add the missing old spherical linear interpolation method.

There's a working implementation in r2 that has no reason to be there.

These would be vector and matrix instances that contain a reference to a ByteBuffer and a byte offset. All operations would then effectively take place on a vector or matrix instance packed into the buffer.

The implementation is very easy, but the API needs to be designed and made consistent with the rest of the package.

Recent benchmarks are showing that heap-backed matrices significantly outperform direct memory backed matrices. In single threaded code, the MatrixHeapArrayM4x4F type sustains about ~18 million multiplications per second, where as the MatrixDirectM4x4F type sustains only ~5 million.

Performing the multiplication with heap-backed matrices and saving the result to a direct-memory backed matrix maintains the ~18 million operations per second, so it's not clear exactly where the bottleneck is.

http://blog.io7m.com/2017/03/22/mathematics-with-an-axe.xhtml

The advantage of using the junit functions is that they give good error messages when a test fails.

This was never implemented as it tends not to be that useful in geometric terms. It is useful, however, for working in color spaces.

Vector4D multiply(Vector4D v0, Vector4D v1)
{
  return Vector4D.of(
    v0.x() * v1.x(),
    v0.y() * v1.y(),
    v0.z() * v1.z(),
    v0.w() * v1.w(),
  );
}

May be required for io7m/jcalcium#23 (comment)

https://github.com/io7m/primogenitor

In the same manner as matrices.

Right-handed lookAt matrices.

This allows for multiple vector instances to share the same observable byte offset, and therefore allows for external code to "broadcast" offset updates.

The generated immutable types can now be records.

Add missing cross product op.

It's been at beta0011 for way too long.