v2.3.0

• Added a namespace for the C++ API, which can be enable by doing #define HLML_NAMESPACE somewhere in your build system.
  • This was added because std now has it's own lerp implementation, which collides with HLML's own lerp function.

v2.2.0

• Added more constructors for vector and matrix types.
• Rewrote the vector swizzling to support the same syntax and usage as HLSL.
  • These currently exist as templates (gasp) but when I profiled the compile times between the templated vs. non-templated versions the compile times were basically the same (as was the runtime performance), but the amount of generated code was significantly less.
  • If the compile-time or runtime performance of the templated version is ever found to be worse than the alternative then I will flip the switch to generate the non-templated version.

v2.1.2

• Fix bug in float4_quat_slerp() and double4_quat_slerp() which gave incorrect outputs.
  • Added tests to catch these.

v2.1.1

• Fix bug in inverse(), which had slipped through the cracks in testing.

v2.1.0

• *_unary has been renamed to *_not because that's what it actually does.
• Matrix header files now include the header file for their vector member type.
• Fixed bug where assert.h was not included if using default HLML_ASSERT macro.
• Fixed bug where compiler warned about using negate function/operator on unsigned types.
• Fixed missing inline specifiers on some matrix constructors.

v2.0.1

Re-added negate function and operator after it was accidentally removed during the re-write between v1 and v2 (oops).

v2.0.0

v2.0.0!

• Everything has been rewritten from scratch.
  • The old generator codebase was clearly not easy to work in at all and could be very confusing at times. The new generator codebase addresses all of those concerns.
• The C and C++ APIs have been split for better usability, but unfortunately this does mean that you can no longer use both the C and C++ APIs in your project together.
• Added any() and all() functions, which do the same thing as in HLSL.
• Added quat_to_rotation_matrix function.
• Added the rest of the missing vector swizzle functions.
  • The previous implementation was poor and did not cover all possible permutations.
• All arithmetic operator overloads now do their component-wise function.
  • Therefore, float4x4::operator* no longer performs matrix multiplication, but rather component-wise multiplication.
    • For matrix multiplication you will now have to call mul (or float4x4_mul in the C API, for example).
    • This was done for consistency across the API and to avoid a common pitfall.
• lookat has been renamed to look_at.
• Removed a bunch of maths functions that were redundant:
  • Removed component-wise functions in the C++ API when their operator counterparts existed (E.G.: caddv -> operator+). Use those instead.
  • translate(), rotate(), and scale() are now only for 4x4 matrices.
  • Matrices no longer have a constructor that takes an array of row-types.
• Removed forward declarations for all functions because they were unnecessary.
• Removed the doxygen-styling on all comments in the API because it was just ugly.
• A lot of SSE functionality has been removed.
  • The SSE abstraction types (E.G.: float2_sse_t) have been removed due to causing aliasing.
  • Removed support for all SSE register types except __m128.
    • I suspect no-one needs any of the other types, but if you were then let me know.
  • A lot of the vector functions have been removed due to performance concerns and lack of practicality.
  • ALL of the matrix functions have been removed due to performance concerns.
    • A new, better API for matrices will be implemented at some point.
  • If you need any of the old functionality that was removed then let me know.
• Removed macOS support for the generator.
  • I don't have a Mac, so I was basically writing a Mac generator only for a Travis VM. This isn't ideal.
  • If I can get access to a Mac at some point I will maybe sit down and write one then.
  • If someone else wants to go ahead and add Mac support for me (but ONLY if you have access to actual hardware!) then go ahead.
• Re-wrote the tests to use Temper 2's parametric testing functionality.
  • There are now A LOT more tests running, whereas before we had around 1,000 tests in the C++ side we now have over 5,500.

v1.1.1

• Add extern "C" { ... } wrappers for each header file in the C API.
• Remove Doxygen documentation because:
  • No-one seemed to care about it.
  • Maintaining that part of the generator was more work than it was worth. If you want Doxygen documentation you'll have to do it yourself from now on. The external-facing comments are Doxygen compliant, so all you need to do is run Doxygen.

This marks the last of the updates for release that this library will get for a while (apart from other small changes that are deemed necessary and fixing any bugs that get found). The next main release will contain changes to the SIMD API, but that's a ways off yet. Expect any other releases until then to be 1.1.N and so on (unless something major changes, but that's unlikely).

v1.1

EDIT: Re-uploaded this release with a fixed .zip file. Thanks @xwize =)

A small usage update as well just some minor fixes:

• Removed the HLML_IMPLEMENTATION define as it's simply not needed for an all-inlined library. Now you only need to simply include the main header to use HLML.
• Maths types no longer default-initialise to all zeros and will now need to be handled by the user, if desired.
• Replaced quaternion_to_matrix for quaternion_rotate_matrix.
• Other minor fixes to the documentation, tests, and quaternions.

v1.0

A whole load of new features are included in this release:

• The library is now included by including one of two headers: hlml/c/hlml.h or hlml/cpp/hlml.h. In one source file you must also define HLML_IMPLEMENTATION so that all the function bodies can be defined (this works the same as the STB libraries).
• Quaternion functions (courtesy of @Flave229).
• Better SSE support (still experimental for now but it's looking good).
• SSE constants are now #defines instead of actual constants (this is for compatibility with the C API).
• C99 functions that are completely separate from the C++ functions.
• C++ vector/matrix functions no-longer rely on operator overloads. This means that the C++ operator overloads are completely separate from functions. This means that hlml_operators_vector.h and hlml_operators_matrix.h can be removed from the codebase if desired.
• Function-counterparts for C++ overloaded operators (there's a chance we are missing some for now - these will be added, if any).

As always I will be listening to any and all feedback that comes through and if any issues come up please add them to the issue tracker and I will fix them ASAP.