Update README.md

* Fix CMake compiler args.

- Replace -stdlib=libc++ with -std=gnu11 & apply it to clang too.
- Remove redundant -fstrict-aliasing.
- Remove warned and redundant -Weverything

.gitattributes

@@ -0,0 +1 @@
+*.h linguist-language=C

.gitignore

@@ -72,3 +72,4 @@ cglm-test-ios*
 /cglm.pc
 test-driver
 Default-568h@2x.png
+build/

CMakeLists.txt

@@ -0,0 +1,192 @@
+cmake_minimum_required(VERSION 3.8.2)
+project(cglm LANGUAGES C)
+
+set(C_STANDARD 11)
+set(C_STANDARD_REQUIRED YES)
+
+set(CGLM_BUILD)
+option(CGLM_SHARED "Shared build" ON)
+option(CGLM_STATIC "Static build" OFF)
+option(CGLM_USE_C99 "" OFF)
+option(CGLM_USE_TEST "Enable Tests" OFF)
+
+if(NOT CGLM_STATIC AND CGLM_SHARED)
+  set(CGLM_BUILD SHARED)
+else(CGLM_STATIC)
+  set(CGLM_BUILD STATIC)
+endif()
+
+if(CGLM_USE_C99)
+  set(C_STANDARD 99)
+endif()
+
+if(MSVC)
+	add_definitions(-DNDEBUG -D_WINDOWS -D_USRDLL -DCGLM_EXPORTS -DCGLM_DLL)
+	add_compile_options("/W3" "/Ox" "/Gy" "/Oi" "/TC" "/analyze")
+else()
+    add_compile_options("-Wall" "-Werror" "-std=gnu11" "-O3")
+    if ("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang")
+		  # Currently, nothing special to be seen here.
+    else()
+		  add_compile_options("-Werror=strict-prototypes")
+    endif()
+endif()
+
+set(HEADERS
+  include/cglm/version.h
+  include/cglm/common.h
+  include/cglm/types.h
+  include/cglm/types-struct.h
+  include/cglm/cglm.h
+  include/cglm/call.h
+  include/cglm/struct.h
+  include/cglm/cam.h
+  include/cglm/io.h
+  include/cglm/mat4.h
+  include/cglm/mat3.h
+  include/cglm/mat2.h
+  include/cglm/affine.h
+  include/cglm/vec2.h
+  include/cglm/vec2-ext.h
+  include/cglm/vec3.h
+  include/cglm/vec3-ext.h
+  include/cglm/vec4.h
+  include/cglm/vec4-ext.h
+  include/cglm/euler.h
+  include/cglm/util.h
+  include/cglm/quat.h
+  include/cglm/affine-mat.h
+  include/cglm/plane.h
+  include/cglm/frustum.h
+  include/cglm/box.h
+  include/cglm/color.h
+  include/cglm/project.h
+  include/cglm/sphere.h
+  include/cglm/ease.h
+  include/cglm/curve.h
+  include/cglm/bezier.h
+  include/cglm/applesimd.h
+  include/cglm/ray.h
+  )
+
+set(HEADERS_CALL
+  include/cglm/call/mat4.h
+  include/cglm/call/mat3.h
+  include/cglm/call/mat2.h
+  include/cglm/call/vec2.h
+  include/cglm/call/vec3.h
+  include/cglm/call/vec4.h
+  include/cglm/call/affine.h
+  include/cglm/call/io.h
+  include/cglm/call/cam.h
+  include/cglm/call/quat.h
+  include/cglm/call/euler.h
+  include/cglm/call/plane.h
+  include/cglm/call/frustum.h
+  include/cglm/call/box.h
+  include/cglm/call/project.h
+  include/cglm/call/sphere.h
+  include/cglm/call/ease.h
+  include/cglm/call/curve.h
+  include/cglm/call/bezier.h
+  include/cglm/call/ray.h
+  )
+
+set(HEADERS_SIMD
+  include/cglm/simd/intrin.h
+  include/cglm/simd/x86.h
+  include/cglm/simd/arm.h
+  )
+
+set(HEADERS_SIMD_SSE2
+  include/cglm/simd/sse2/affine.h
+  include/cglm/simd/sse2/mat4.h
+  include/cglm/simd/sse2/mat3.h
+  include/cglm/simd/sse2/mat2.h
+  include/cglm/simd/sse2/quat.h
+  )
+
+set(HEADERS_SIMD_AVX
+   include/cglm/simd/avx/mat4.h
+   include/cglm/simd/avx/affine.h
+   )
+
+set(HEADERS_SIMD_NEON
+   include/cglm/simd/neon/mat4.h
+   )
+
+set(HEADERS_STRUCT
+  include/cglm/struct/mat4.h
+  include/cglm/struct/mat3.h
+  include/cglm/struct/mat2.h
+  include/cglm/struct/vec2.h
+  include/cglm/struct/vec2-ext.h
+  include/cglm/struct/vec3.h
+  include/cglm/struct/vec3-ext.h
+  include/cglm/struct/vec4.h
+  include/cglm/struct/vec4-ext.h
+  include/cglm/struct/affine.h
+  include/cglm/struct/io.h
+  include/cglm/struct/cam.h
+  include/cglm/struct/quat.h
+  include/cglm/struct/euler.h
+  include/cglm/struct/plane.h
+  include/cglm/struct/frustum.h
+  include/cglm/struct/box.h
+  include/cglm/struct/project.h
+  include/cglm/struct/sphere.h
+  include/cglm/struct/color.h
+  include/cglm/struct/curve.h
+  )
+
+add_library(cglm
+  ${CGLM_BUILD}
+  src/euler.c
+  src/affine.c
+  src/io.c
+  src/quat.c
+  src/cam.c
+  src/vec2.c
+  src/vec3.c
+  src/vec4.c
+  src/mat2.c
+  src/mat3.c
+  src/mat4.c
+  src/plane.c
+  src/frustum.c
+  src/box.c
+  src/project.c
+  src/sphere.c
+  src/ease.c
+  src/curve.c
+  src/bezier.c
+  src/ray.c
+  )
+
+target_include_directories(cglm PUBLIC
+  ${CMAKE_CURRENT_SOURCE_DIR}/include
+)
+
+install(
+	TARGETS	cglm
+	EXPORT cglm
+	ARCHIVE DESTINATION lib/ COMPONENT development
+	LIBRARY DESTINATION lib/ COMPONENT runtime NAMELINK_SKIP
+	RUNTIME DESTINATION ${CMAKE_INSTALL_NAME_DIR} COMPONENT runtime
+)
+
+if(CGLM_SHARED)
+	install(
+		TARGETS	cglm
+		EXPORT cglm
+		LIBRARY DESTINATION include/ COMPONENT development NAMELINK_ONLY
+	)
+endif()
+
+INSTALL(DIRECTORY include/ DESTINATION include)
+
+# Test Configuration
+if(CGLM_USE_TEST)
+  enable_testing()
+  add_subdirectory(test)
+endif()

CREDITS

@@ -61,3 +61,13 @@ https://forums.khronos.org/showthread.php/10264-Animations-in-1-4-1-release-note
 https://forums.khronos.org/showthread.php/10644-Animation-Bezier-interpolation
 https://forums.khronos.org/showthread.php/10387-2D-Tangents-in-Bezier-Splines?p=34164&viewfull=1#post34164
 https://forums.khronos.org/showthread.php/10651-Animation-TCB-Spline-Interpolation-in-COLLADA?highlight=bezier
+
+12. vec2 cross product
+http://allenchou.net/2013/07/cross-product-of-2d-vectors/
+
+13. Ray triangle intersect
+Möller–Trumbore ray-triangle intersection algorithm, from "Fast, Minimum Storage Ray/Triangle Intersection"
+Authors:
+  Thomas Möller (tompa@clarus.se)
+  Ben Trumbore (wbt@graphics.cornell.edu)
+Link to paper: http://webserver2.tecgraf.puc-rio.br/~mgattass/cg/trbRR/Fast%20MinimumStorage%20RayTriangle%20Intersection.pdf

Makefile.am

@@ -42,7 +42,10 @@ cglm_HEADERS = include/cglm/version.h \
                include/cglm/io.h \
                include/cglm/mat4.h \
                include/cglm/mat3.h \
+               include/cglm/mat2.h \
                include/cglm/affine.h \
+               include/cglm/vec2.h \
+               include/cglm/vec2-ext.h \
                include/cglm/vec3.h \
                include/cglm/vec3-ext.h \
                include/cglm/vec4.h \
@@ -60,11 +63,14 @@ cglm_HEADERS = include/cglm/version.h \
                include/cglm/ease.h \
                include/cglm/curve.h \
                include/cglm/bezier.h \
-               include/cglm/applesimd.h
+               include/cglm/applesimd.h \
-               
+               include/cglm/ray.h
+
 cglm_calldir=$(includedir)/cglm/call
 cglm_call_HEADERS = include/cglm/call/mat4.h \
                     include/cglm/call/mat3.h \
+                    include/cglm/call/mat2.h \
+                    include/cglm/call/vec2.h \
                     include/cglm/call/vec3.h \
                     include/cglm/call/vec4.h \
                     include/cglm/call/affine.h \
@@ -79,7 +85,8 @@ cglm_call_HEADERS = include/cglm/call/mat4.h \
                     include/cglm/call/sphere.h \
                     include/cglm/call/ease.h \
                     include/cglm/call/curve.h \
-                    include/cglm/call/bezier.h
+                    include/cglm/call/bezier.h \
+                    include/cglm/call/ray.h
 
 cglm_simddir=$(includedir)/cglm/simd
 cglm_simd_HEADERS = include/cglm/simd/intrin.h \
@@ -90,6 +97,7 @@ cglm_simd_sse2dir=$(includedir)/cglm/simd/sse2
 cglm_simd_sse2_HEADERS = include/cglm/simd/sse2/affine.h \
                          include/cglm/simd/sse2/mat4.h \
                          include/cglm/simd/sse2/mat3.h \
+                         include/cglm/simd/sse2/mat2.h \
                          include/cglm/simd/sse2/quat.h
 
 cglm_simd_avxdir=$(includedir)/cglm/simd/avx
@@ -102,6 +110,9 @@ cglm_simd_neon_HEADERS = include/cglm/simd/neon/mat4.h
 cglm_structdir=$(includedir)/cglm/struct
 cglm_struct_HEADERS = include/cglm/struct/mat4.h \
                       include/cglm/struct/mat3.h \
+                      include/cglm/struct/mat2.h \
+                      include/cglm/struct/vec2.h \
+                      include/cglm/struct/vec2-ext.h \
                       include/cglm/struct/vec3.h \
                       include/cglm/struct/vec3-ext.h \
                       include/cglm/struct/vec4.h \
@@ -125,8 +136,10 @@ libcglm_la_SOURCES=\
     src/io.c \
     src/quat.c \
     src/cam.c \
+    src/vec2.c \
     src/vec3.c \
     src/vec4.c \
+    src/mat2.c \
     src/mat3.c \
     src/mat4.c \
     src/plane.c \
@@ -136,21 +149,16 @@ libcglm_la_SOURCES=\
     src/sphere.c \
     src/ease.c \
     src/curve.c \
-    src/bezier.c
+    src/bezier.c \
+    src/ray.c
 
 test_tests_SOURCES=\
     test/runner.c \
     test/src/test_common.c \
-    test/src/test_mat4.c \
+    test/src/tests.c \
     test/src/test_cam.c \
-    test/src/test_project.c \
     test/src/test_clamp.c \
     test/src/test_euler.c \
-    test/src/test_quat.c \
-    test/src/test_vec4.c \
-    test/src/test_vec3.c \
-    test/src/test_mat3.c \
-    test/src/test_affine.c \
     test/src/test_bezier.c \
     test/src/test_struct.c
 

README.md

@@ -89,6 +89,7 @@ Currently *cglm* uses default clip space configuration (-1, 1) for camera functi
 - curves
 - curve interpolation helpers (S*M*C, deCasteljau...)
 - helpers to convert cglm types to Apple's simd library to pass cglm types to Metal GL without packing them on both sides
+- ray intersection helpers
 - and others...
 
 <hr />
@@ -148,6 +149,38 @@ The types used are actually unions that allow access to the same data multiple w
 
 ## Build
 
+### CMake (All platforms)
+```bash
+$ mkdir build
+$ cd build
+$ cmake .. # [Optional] -DCGLM_SHARED=ON
+$ make
+$ sudo make install # [Optional]
+```
+
+##### Cmake options with Defaults:
+
+```CMake
+option(CGLM_SHARED "Shared build" ON)
+option(CGLM_STATIC "Static build" OFF)
+option(CGLM_USE_C99 "" OFF) # C11 
+option(CGLM_USE_TEST "Enable Tests" OFF) # for make check - make test
+```
+
+#### Use with your CMake project
+* Example:
+```cmake
+cmake_minimum_required(VERSION 3.8.2)
+
+project(<Your Project Name>)
+
+add_executable(${PROJECT_NAME} src/main.c)
+target_link_libraries(${LIBRARY_NAME} PRIVATE
+  cglm)
+
+add_subdirectory(external/cglm/)
+```
+
 ### Unix (Autotools)
 
 ```bash
@@ -291,7 +324,7 @@ You can pass matrices the same way to other APIs e.g. Vulkan, DX...
 ## Contributors
 
 This project exists thanks to all the people who contribute. [[Contribute](CONTRIBUTING.md)].
-<a href="graphs/contributors"><img src="https://opencollective.com/cglm/contributors.svg?width=890&button=false" /></a>
+<a href="https://github.com/recp/cglm/graphs/contributors"><img src="https://opencollective.com/cglm/contributors.svg?width=890&button=false" /></a>
 
 
 ## Backers

configure.ac

@@ -7,7 +7,7 @@
 #*****************************************************************************
 
 AC_PREREQ([2.69])
-AC_INIT([cglm], [0.6.2], [info@recp.me])
+AC_INIT([cglm], [0.7.2], [info@recp.me])
 AM_INIT_AUTOMAKE([-Wall -Werror foreign subdir-objects serial-tests])
 
 # Don't use the default cflags (-O2 -g), we set ours manually in Makefile.am.

docs/source/api.rst

@@ -35,10 +35,13 @@ Follow the :doc:`build` documentation for this
    euler
    mat4
    mat3
+   mat2
    vec3
    vec3-ext
    vec4
    vec4-ext
+   vec2
+   vec2-ext
    color
    plane
    project
@@ -48,3 +51,5 @@ Follow the :doc:`build` documentation for this
    sphere
    curve
    bezier
+   version
+   ray

docs/source/cam.rst

@@ -198,7 +198,7 @@ Functions documentation
 
     Parameters:
       | *[in]*  **eye**     eye vector
-      | *[in]*  **center**  direction vector
+      | *[in]*  **dir**     direction vector
       | *[in]*  **up**      up vector
       | *[out]* **dest**    result matrix
 
@@ -212,7 +212,7 @@ Functions documentation
 
     Parameters:
       | *[in]*  **eye**     eye vector
-      | *[in]*  **center**  direction vector
+      | *[in]*  **dir**     direction vector
       | *[out]* **dest**    result matrix
 
 .. c:function:: void  glm_persp_decomp(mat4 proj, float *nearVal, float *farVal, float *top, float *bottom, float *left, float *right)

docs/source/conf.py

@@ -62,9 +62,9 @@ author = u'Recep Aslantas'
 # built documents.
 #
 # The short X.Y version.
-version = u'0.6.2'
+version = u'0.7.2'
 # The full version, including alpha/beta/rc tags.
-release = u'0.6.2'
+release = u'0.7.2'
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.

docs/source/mat2.rst

@@ -0,0 +1,179 @@
+.. default-domain:: C
+
+mat2
+====
+
+Header: cglm/mat2.h
+
+Table of contents (click to go):
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Macros:
+
+1. GLM_mat2_IDENTITY_INIT
+#. GLM_mat2_ZERO_INIT
+#. GLM_mat2_IDENTITY
+#. GLM_mat2_ZERO
+
+Functions:
+
+1. :c:func:`glm_mat2_copy`
+#. :c:func:`glm_mat2_identity`
+#. :c:func:`glm_mat2_identity_array`
+#. :c:func:`glm_mat2_zero`
+#. :c:func:`glm_mat2_mul`
+#. :c:func:`glm_mat2_transpose_to`
+#. :c:func:`glm_mat2_transpose`
+#. :c:func:`glm_mat2_mulv`
+#. :c:func:`glm_mat2_scale`
+#. :c:func:`glm_mat2_det`
+#. :c:func:`glm_mat2_inv`
+#. :c:func:`glm_mat2_trace`
+#. :c:func:`glm_mat2_swap_col`
+#. :c:func:`glm_mat2_swap_row`
+#. :c:func:`glm_mat2_rmc`
+
+Functions documentation
+~~~~~~~~~~~~~~~~~~~~~~~
+
+.. c:function:: void glm_mat2_copy(mat2 mat, mat2 dest)
+
+    copy mat2 to another one (dest).
+
+    Parameters:
+      | *[in]*  **mat**   source
+      | *[out]* **dest**  destination
+
+.. c:function:: void glm_mat2_identity(mat2 mat)
+
+    copy identity mat2 to mat, or makes mat to identiy
+
+    Parameters:
+      | *[out]* **mat**  matrix
+
+.. c:function:: void glm_mat2_identity_array(mat2 * __restrict mat, size_t count)
+
+    make given matrix array's each element identity matrix
+
+    Parameters:
+      | *[in,out]* **mat**  matrix array (must be aligned (16/32) if alignment is not disabled)
+      | *[in]* **count**  count of matrices
+
+.. c:function:: void glm_mat2_zero(mat2 mat)
+
+    make given matrix zero
+
+    Parameters:
+      | *[in,out]* **mat**  matrix to
+
+.. c:function:: void glm_mat2_mul(mat2 m1, mat2 m2, mat2 dest)
+
+    multiply m1 and m2 to dest
+    m1, m2 and dest matrices can be same matrix, it is possible to write this:
+
+    .. code-block:: c
+
+       mat2 m = GLM_mat2_IDENTITY_INIT;
+       glm_mat2_mul(m, m, m);
+
+    Parameters:
+      | *[in]*  **m1**    left matrix
+      | *[in]*  **m2**    right matrix
+      | *[out]* **dest**  destination matrix
+
+.. c:function:: void glm_mat2_transpose_to(mat2 m, mat2 dest)
+
+    transpose mat4 and store in dest
+    source matrix will not be transposed unless dest is m
+
+    Parameters:
+      | *[in]*  **mat**   source
+      | *[out]* **dest**  destination
+
+.. c:function:: void glm_mat2_transpose(mat2 m)
+
+    tranpose mat2 and store result in same matrix
+
+    Parameters:
+      | *[in]*  **mat**   source
+      | *[out]* **dest**  destination
+
+.. c:function:: void glm_mat2_mulv(mat2 m, vec2 v, vec2 dest)
+
+    multiply mat4 with vec4 (column vector) and store in dest vector
+
+    Parameters:
+      | *[in]*  **mat**   mat2 (left)
+      | *[in]*  **v**     vec2 (right, column vector)
+      | *[out]* **dest**  destination (result, column vector)
+
+.. c:function:: void  glm_mat2_scale(mat2 m, float s)
+
+    multiply matrix with scalar
+
+    Parameters:
+      | *[in, out]* **mat**   matrix
+      | *[in]*      **dest**  scalar
+
+.. c:function:: float  glm_mat2_det(mat2 mat)
+
+    returns mat2 determinant
+
+    Parameters:
+      | *[in]*  **mat**   matrix
+
+    Returns:
+        mat2 determinant
+
+.. c:function:: void glm_mat2_inv(mat2 mat, mat2 dest)
+
+    inverse mat2 and store in dest
+
+    Parameters:
+      | *[in]*  **mat**  matrix
+      | *[out]* **dest** destination (inverse matrix)
+
+.. c:function:: void glm_mat2_trace(mat2 m)
+
+    | sum of the elements on the main diagonal from upper left to the lower right
+
+    Parameters:
+      | *[in]*  **m**  matrix
+
+    Returns:
+        trace of matrix
+
+.. c:function:: void glm_mat2_swap_col(mat2 mat, int col1, int col2)
+
+    swap two matrix columns
+
+    Parameters:
+      | *[in, out]*  **mat**   matrix
+      | *[in]*       **col1**  col1
+      | *[in]*       **col2**  col2
+
+.. c:function:: void glm_mat2_swap_row(mat2 mat, int row1, int row2)
+
+    swap two matrix rows
+
+    Parameters:
+      | *[in, out]*  **mat**   matrix
+      | *[in]*       **row1**  row1
+      | *[in]*       **row2**  row2
+
+.. c:function:: float glm_mat2_rmc(vec2 r, mat2 m, vec2 c)
+
+    | **rmc** stands for **Row** * **Matrix** * **Column**
+
+    | helper for  R (row vector) * M (matrix) * C (column vector)
+
+    | the result is scalar because R * M = Matrix1x2 (row vector),
+    | then Matrix1x2 * Vec2 (column vector) = Matrix1x1 (Scalar)
+
+    Parameters:
+      | *[in]*  **r**  row vector or matrix1x2
+      | *[in]*  **m**  matrix2x2
+      | *[in]*  **c**  column vector or matrix2x1
+
+    Returns:
+        scalar value e.g. Matrix1x1

docs/source/quat.rst

@@ -324,26 +324,24 @@ Functions documentation
       | *[in]*  **ori**   orientation in world space as quaternion
       | *[out]* **dest**  result matrix
 
-.. c:function:: void  glm_quat_for(vec3 dir, vec3 fwd, vec3 up, versor dest)
+.. c:function:: void  glm_quat_for(vec3 dir, vec3 up, versor dest)
 
     | creates look rotation quaternion
 
     Parameters:
       | *[in]*  **dir**   direction to look
-      | *[in]*  **fwd**   forward vector
       | *[in]*  **up**    up vector
       | *[out]* **dest**  result matrix
 
-.. c:function:: void  glm_quat_forp(vec3 from, vec3 to, vec3 fwd, vec3 up, versor dest)
+.. c:function:: void  glm_quat_forp(vec3 from, vec3 to, vec3 up, versor dest)
 
-    | creates look rotation quaternion using source and  destination positions p suffix stands for position
+    | creates look rotation quaternion using source and destination positions p suffix stands for position
 
     | this is similar to glm_quat_for except this computes direction for glm_quat_for for you.
 
     Parameters:
       | *[in]*  **from**  source point
       | *[in]*  **to**    destination point
-      | *[in]*  **fwd**   forward vector
       | *[in]*  **up**    up vector
       | *[out]* **dest**  result matrix
 

docs/source/ray.rst

@@ -0,0 +1,31 @@
+.. default-domain:: C
+
+ray
+====
+
+Header: cglm/ray.h
+
+This is for collision-checks used by ray-tracers and the like.
+
+Table of contents (click to go):
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Functions:
+
+1. :c:func:`glm_ray_triangle`
+
+Functions documentation
+~~~~~~~~~~~~~~~~~~~~~~~
+
+.. c:function:: bool  glm_ray_triangle(vec3 origin, vec3 direction, vec3 v0, vec3 v1, vec3 v2, float *d)
+
+    Möller–Trumbore ray-triangle intersection algorithm
+
+    Parameters:
+      | *[in]*       **origin**        origin of ray
+      | *[in]*       **direction**     direction of ray
+      | *[in]*       **v0**            first vertex of triangle
+      | *[in]*       **v1**            second vertex of triangle
+      | *[in]*       **v2**            third vertex of triangle
+      | *[in, out]*  **d**             float pointer to save distance to intersection
+      | *[out]*      **intersection**  whether there is intersection

docs/source/util.rst

@@ -23,6 +23,7 @@ Functions:
 #. :c:func:`glm_max`
 #. :c:func:`glm_clamp`
 #. :c:func:`glm_lerp`
+#. :c:func:`glm_swapf`
 
 Functions documentation
 ~~~~~~~~~~~~~~~~~~~~~~~
@@ -146,7 +147,7 @@ Functions documentation
       | *[in]*  **b**   b
 
     Returns:
-       true if a and b equals
+       true if a and b are equal
 
 .. c:function:: float glm_percent(float from, float to, float current)
 
@@ -158,7 +159,7 @@ Functions documentation
       | *[in]*  **current**   value between from and to values
 
     Returns:
-       clamped normalized percent (0-100 in 0-1)
+       percentage of current value
 
 .. c:function:: float glm_percentc(float from, float to, float current)
 
@@ -171,3 +172,11 @@ Functions documentation
 
     Returns:
        clamped normalized percent (0-100 in 0-1)
+
+.. c:function:: void glm_swapf(float *a, float *b) 
+
+    swap two float values
+
+    Parameters:
+      | *[in]*  **a**      float 1
+      | *[in]*  **b**      float 2

docs/source/vec2-ext.rst

@@ -0,0 +1,134 @@
+.. default-domain:: C
+
+vec2 extra
+==========
+
+Header: cglm/vec2-ext.h
+
+There are some functions are in called in extra header. These are called extra
+because they are not used like other functions in vec2.h in the future some of
+these functions ma be moved to vec2 header.
+
+Table of contents (click to go):
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Functions:
+
+1. :c:func:`glm_vec2_fill`
+#. :c:func:`glm_vec2_eq`
+#. :c:func:`glm_vec2_eq_eps`
+#. :c:func:`glm_vec2_eq_all`
+#. :c:func:`glm_vec2_eqv`
+#. :c:func:`glm_vec2_eqv_eps`
+#. :c:func:`glm_vec2_max`
+#. :c:func:`glm_vec2_min`
+#. :c:func:`glm_vec2_isnan`
+#. :c:func:`glm_vec2_isinf`
+#. :c:func:`glm_vec2_isvalid`
+#. :c:func:`glm_vec2_sign`
+#. :c:func:`glm_vec2_sqrt`
+
+Functions documentation
+~~~~~~~~~~~~~~~~~~~~~~~
+
+.. c:function:: void glm_vec2_fill(vec2 v, float val)
+
+    fill a vector with specified value
+
+    Parameters:
+      | *[in,out]* **dest**  destination
+      | *[in]*     **val**   value
+      
+
+.. c:function:: bool glm_vec2_eq(vec2 v, float val)
+
+    check if vector is equal to value (without epsilon)
+
+    Parameters:
+      | *[in]*  **v**    vector
+      | *[in]*  **val**  value
+
+.. c:function:: bool glm_vec2_eq_eps(vec2 v, float val)
+
+    check if vector is equal to value (with epsilon)
+
+    Parameters:
+      | *[in]*  **v**    vector
+      | *[in]*  **val**  value
+
+.. c:function:: bool glm_vec2_eq_all(vec2 v)
+
+    check if vectors members are equal (without epsilon)
+
+    Parameters:
+      | *[in]*  **v**   vector
+
+.. c:function:: bool glm_vec2_eqv(vec2 v1, vec2 v2)
+
+    check if vector is equal to another (without epsilon) vector
+
+    Parameters:
+      | *[in]*  **vec**   vector 1
+      | *[in]*  **vec**   vector 2
+
+.. c:function:: bool glm_vec2_eqv_eps(vec2 v1, vec2 v2)
+
+    check if vector is equal to another (with epsilon)
+
+    Parameters:
+      | *[in]*  **v1**    vector1
+      | *[in]*  **v2**    vector2
+
+.. c:function:: float glm_vec2_max(vec2 v)
+
+    max value of vector
+
+    Parameters:
+      | *[in]*  **v**    vector
+
+.. c:function:: float glm_vec2_min(vec2 v)
+
+     min value of vector
+
+    Parameters:
+      | *[in]*  **v**  vector
+
+.. c:function:: bool glm_vec2_isnan(vec2 v)
+
+    | check if one of items is NaN (not a number)
+    | you should only use this in DEBUG mode or very critical asserts
+
+    Parameters:
+      | *[in]*  **v**  vector
+
+.. c:function:: bool glm_vec2_isinf(vec2 v)
+
+    | check if one of items is INFINITY
+    | you should only use this in DEBUG mode or very critical asserts
+
+    Parameters:
+      | *[in]*  **v**  vector
+
+.. c:function:: bool glm_vec2_isvalid(vec2 v)
+
+    | check if all items are valid number
+    | you should only use this in DEBUG mode or very critical asserts
+
+    Parameters:
+      | *[in]*  **v**  vector
+
+.. c:function:: void glm_vec2_sign(vec2 v, vec2 dest)
+
+    get sign of 32 bit float as +1, -1, 0
+
+    Parameters:
+      | *[in]*   **v**     vector
+      | *[out]*  **dest**  sign vector (only keeps signs as -1, 0, -1)
+
+.. c:function:: void glm_vec2_sqrt(vec2 v, vec2 dest)
+
+    square root of each vector item
+
+    Parameters:
+      | *[in]*   **v**     vector
+      | *[out]*  **dest**  destination vector (sqrt(v))

docs/source/vec2.rst

@@ -0,0 +1,375 @@
+.. default-domain:: C
+
+vec2
+====
+
+Header: cglm/vec2.h
+
+Table of contents (click to go):
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Macros:
+
+1. GLM_vec2_ONE_INIT
+#. GLM_vec2_ZERO_INIT
+#. GLM_vec2_ONE
+#. GLM_vec2_ZERO
+
+Functions:
+
+1. :c:func:`glm_vec2`
+#. :c:func:`glm_vec2_copy`
+#. :c:func:`glm_vec2_zero`
+#. :c:func:`glm_vec2_one`
+#. :c:func:`glm_vec2_dot`
+#. :c:func:`glm_vec2_cross`
+#. :c:func:`glm_vec2_norm2`
+#. :c:func:`glm_vec2_norm`
+#. :c:func:`glm_vec2_add`
+#. :c:func:`glm_vec2_adds`
+#. :c:func:`glm_vec2_sub`
+#. :c:func:`glm_vec2_subs`
+#. :c:func:`glm_vec2_mul`
+#. :c:func:`glm_vec2_scale`
+#. :c:func:`glm_vec2_scale_as`
+#. :c:func:`glm_vec2_div`
+#. :c:func:`glm_vec2_divs`
+#. :c:func:`glm_vec2_addadd`
+#. :c:func:`glm_vec2_subadd`
+#. :c:func:`glm_vec2_muladd`
+#. :c:func:`glm_vec2_muladds`
+#. :c:func:`glm_vec2_maxadd`
+#. :c:func:`glm_vec2_minadd`
+#. :c:func:`glm_vec2_negate`
+#. :c:func:`glm_vec2_negate_to`
+#. :c:func:`glm_vec2_normalize`
+#. :c:func:`glm_vec2_normalize_to`
+#. :c:func:`glm_vec2_rotate`
+#. :c:func:`glm_vec2_distance2`
+#. :c:func:`glm_vec2_distance`
+#. :c:func:`glm_vec2_maxv`
+#. :c:func:`glm_vec2_minv`
+#. :c:func:`glm_vec2_clamp`
+#. :c:func:`glm_vec2_lerp`
+
+Functions documentation
+~~~~~~~~~~~~~~~~~~~~~~~
+
+.. c:function:: void glm_vec2(vec4 v4, vec2 dest)
+
+    init vec2 using vec3
+
+    Parameters:
+      | *[in]*  **v3**    vector3
+      | *[out]* **dest**  destination
+
+.. c:function:: void glm_vec2_copy(vec2 a, vec2 dest)
+
+    copy all members of [a] to [dest]
+
+    Parameters:
+      | *[in]*  **a**     source
+      | *[out]* **dest**  destination
+
+.. c:function:: void glm_vec2_zero(vec2 v)
+
+    makes all members 0.0f (zero)
+
+    Parameters:
+      | *[in, out]*  **v**     vector
+
+.. c:function:: void  glm_vec2_one(vec2 v)
+
+    makes all members 1.0f (one)
+
+    Parameters:
+      | *[in, out]*  **v**     vector
+
+.. c:function:: float glm_vec2_dot(vec2 a, vec2 b)
+
+    dot product of vec2
+
+    Parameters:
+      | *[in]*  **a**  vector1
+      | *[in]*  **b**  vector2
+
+    Returns:
+      dot product
+
+.. c:function:: void glm_vec2_cross(vec2 a, vec2 b, vec2 d)
+
+    cross product of two vector (RH)
+
+    | ref: http://allenchou.net/2013/07/cross-product-of-2d-vectors/
+
+    Parameters:
+      | *[in]*  **a**     vector 1
+      | *[in]*  **b**     vector 2
+      | *[out]* **dest**  destination
+
+    Returns:
+      Z component of cross product
+
+.. c:function:: float glm_vec2_norm2(vec2 v)
+
+    norm * norm (magnitude) of vector
+
+    we can use this func instead of calling norm * norm, because it would call
+    sqrtf fuction twice but with this func we can avoid func call, maybe this is
+    not good name for this func
+
+    Parameters:
+      | *[in]*  **v**   vector
+
+    Returns:
+      square of norm / magnitude
+
+.. c:function:: float glm_vec2_norm(vec2 vec)
+
+    | euclidean norm (magnitude), also called L2 norm
+    | this will give magnitude of vector in euclidean space
+
+    Parameters:
+      | *[in]*  **vec**   vector
+
+.. c:function:: void glm_vec2_add(vec2 a, vec2 b, vec2 dest)
+
+    add a vector to b vector store result in dest
+
+    Parameters:
+      | *[in]*  **a**     vector1
+      | *[in]*  **b**     vector2
+      | *[out]* **dest**  destination vector
+
+.. c:function:: void glm_vec2_adds(vec2 a, float s, vec2 dest)
+
+    add scalar to v vector store result in dest (d = v + vec(s))
+
+    Parameters:
+      | *[in]*  **v**     vector
+      | *[in]*  **s**     scalar
+      | *[out]* **dest**  destination vector
+
+.. c:function:: void glm_vec2_sub(vec2 v1, vec2 v2, vec2 dest)
+
+    subtract b vector from a vector store result in dest (d = v1 - v2)
+
+    Parameters:
+      | *[in]*  **a**     vector1
+      | *[in]*  **b**     vector2
+      | *[out]* **dest**  destination vector
+
+.. c:function:: void glm_vec2_subs(vec2 v, float s, vec2 dest)
+
+    subtract scalar from v vector store result in dest (d = v - vec(s))
+
+    Parameters:
+      | *[in]*  **v**     vector
+      | *[in]*  **s**     scalar
+      | *[out]* **dest**  destination vector
+
+.. c:function:: void glm_vec2_mul(vec2 a, vec2 b, vec2 d)
+
+    multiply two vector (component-wise multiplication)
+
+    Parameters:
+      | *[in]*  **a**     vector
+      | *[in]*  **b**     scalar
+      | *[out]* **d**     result = (a[0] * b[0], a[1] * b[1], a[2] * b[2])
+
+.. c:function:: void glm_vec2_scale(vec2 v, float s, vec2 dest)
+
+     multiply/scale vec2 vector with scalar: result = v * s
+
+
+    Parameters:
+      | *[in]*  **v**     vector
+      | *[in]*  **s**     scalar
+      | *[out]* **dest**  destination vector
+
+.. c:function:: void glm_vec2_scale_as(vec2 v, float s, vec2 dest)
+
+    make vec2 vector scale as specified: result = unit(v) * s
+
+    Parameters:
+      | *[in]*  **v**     vector
+      | *[in]*  **s**     scalar
+      | *[out]* **dest**  destination vector
+
+.. c:function:: void glm_vec2_div(vec2 a, vec2 b, vec2 dest)
+
+    div vector with another component-wise division: d = a / b
+
+    Parameters:
+      | *[in]*  **a**     vector 1
+      | *[in]*  **b**     vector 2
+      | *[out]* **dest**  result = (a[0] / b[0], a[1] / b[1], a[2] / b[2])
+
+.. c:function:: void glm_vec2_divs(vec2 v, float s, vec2 dest)
+
+    div vector with scalar: d = v / s
+
+    Parameters:
+      | *[in]*  **v**     vector
+      | *[in]*  **s**     scalar
+      | *[out]* **dest**  result = (a[0] / s, a[1] / s, a[2] / s])
+
+.. c:function:: void glm_vec2_addadd(vec2 a, vec2 b, vec2 dest)
+
+    | add two vectors and add result to sum
+    | it applies += operator so dest must be initialized
+
+    Parameters:
+      | *[in]*  **a**     vector 1
+      | *[in]*  **b**     vector 2
+      | *[out]* **dest**  dest += (a + b)
+
+.. c:function:: void glm_vec2_subadd(vec2 a, vec2 b, vec2 dest)
+
+    | sub two vectors and add result to sum
+    | it applies += operator so dest must be initialized
+
+    Parameters:
+      | *[in]*  **a**     vector 1
+      | *[in]*  **b**     vector 2
+      | *[out]* **dest**  dest += (a - b)
+
+.. c:function:: void glm_vec2_muladd(vec2 a, vec2 b, vec2 dest)
+
+    | mul two vectors and add result to sum
+    | it applies += operator so dest must be initialized
+
+    Parameters:
+      | *[in]*  **a**     vector 1
+      | *[in]*  **b**     vector 2
+      | *[out]* **dest**  dest += (a * b)
+
+.. c:function:: void glm_vec2_muladds(vec2 a, float s, vec2 dest)
+
+    | mul vector with scalar and add result to sum
+    | it applies += operator so dest must be initialized
+
+    Parameters:
+      | *[in]*  **a**     vector
+      | *[in]*  **s**     scalar
+      | *[out]* **dest**  dest += (a * b)
+
+.. c:function:: void glm_vec2_maxadd(vec2 a, vec2 b, vec2 dest)
+
+    | add max of two vector to result/dest
+    | it applies += operator so dest must be initialized
+
+    Parameters:
+      | *[in]*  **a**     vector 1
+      | *[in]*  **b**     vector 2
+      | *[out]* **dest**  dest += (a * b)
+
+.. c:function:: void glm_vec2_minadd(vec2 a, vec2 b, vec2 dest)
+
+    | add min of two vector to result/dest
+    | it applies += operator so dest must be initialized
+
+    Parameters:
+      | *[in]*  **a**     vector 1
+      | *[in]*  **b**     vector 2
+      | *[out]* **dest**  dest += (a * b)
+
+.. c:function:: void glm_vec2_negate(vec2 v)
+
+    negate vector components
+
+    Parameters:
+      | *[in, out]*  **v**    vector
+
+.. c:function:: void glm_vec2_negate_to(vec2 v, vec2 dest)
+
+    negate vector components and store result in dest
+
+    Parameters:
+      | *[in]*  **v**       vector
+      | *[out]* **dest**    negated vector
+
+.. c:function:: void glm_vec2_normalize(vec2 v)
+
+    normalize vec2 and store result in same vec
+
+    Parameters:
+      | *[in, out]*  **v**    vector
+
+.. c:function:: void glm_vec2_normalize_to(vec2 vec, vec2 dest)
+
+     normalize vec2 to dest
+
+    Parameters:
+      | *[in]*   **vec**   source
+      | *[out]*  **dest**  destination
+
+.. c:function:: void glm_vec2_rotate(vec2 v, float angle, vec2 dest)
+
+     rotate vec2 around axis by angle using Rodrigues' rotation formula
+
+    Parameters:
+      | *[in]*  **v**      vector
+      | *[in]*  **axis**   axis vector
+      | *[out]* **dest**   destination
+
+.. c:function:: float glm_vec2_distance2(vec2 v1, vec2 v2)
+
+    squared distance between two vectors
+
+    Parameters:
+      | *[in]*  **mat**   vector1
+      | *[in]*  **row1**  vector2
+
+    Returns:
+      | squared distance (distance * distance)
+
+.. c:function:: float glm_vec2_distance(vec2 v1, vec2 v2)
+
+    distance between two vectors
+
+    Parameters:
+      | *[in]*  **mat**   vector1
+      | *[in]*  **row1**  vector2
+
+    Returns:
+      | distance
+
+.. c:function:: void glm_vec2_maxv(vec2 v1, vec2 v2, vec2 dest)
+
+    max values of vectors
+
+    Parameters:
+      | *[in]*  **v1**    vector1
+      | *[in]*  **v2**    vector2
+      | *[out]* **dest**  destination
+
+.. c:function:: void glm_vec2_minv(vec2 v1, vec2 v2, vec2 dest)
+
+    min values of vectors
+
+    Parameters:
+      | *[in]*  **v1**    vector1
+      | *[in]*  **v2**    vector2
+      | *[out]* **dest**  destination
+
+.. c:function:: void glm_vec2_clamp(vec2 v, float minVal, float maxVal)
+
+    constrain a value to lie between two further values
+
+    Parameters:
+      | *[in, out]*  **v**       vector
+      | *[in]*       **minVal**  minimum value
+      | *[in]*       **maxVal**  maximum value
+
+.. c:function:: void glm_vec2_lerp(vec2 from, vec2 to, float t, vec2 dest)
+
+    linear interpolation between two vector
+
+    | formula:  from + s * (to - from)
+
+    Parameters:
+      | *[in]*  **from**   from value
+      | *[in]*  **to**     to value
+      | *[in]*  **t**      interpolant (amount) clamped between 0 and 1
+      | *[out]* **dest**   destination

docs/source/vec3.rst

@@ -392,7 +392,7 @@ Functions documentation
     Parameters:
       | *[in, out]*  **v**      vector
       | *[in]*       **axis**   axis vector (will be normalized)
-      | *[out]*      **angle**  angle (radians)
+      | *[in]*       **angle**  angle (radians)
 
 .. c:function:: void  glm_vec3_rotate_m4(mat4 m, vec3 v, vec3 dest)
 
@@ -435,8 +435,8 @@ Functions documentation
     squared distance between two vectors
 
     Parameters:
-      | *[in]*  **mat**   vector1
+      | *[in]*  **v1**  vector1
-      | *[in]*  **row1**  vector2
+      | *[in]*  **v2**  vector2
 
     Returns:
       | squared distance (distance * distance)
@@ -446,8 +446,8 @@ Functions documentation
     distance between two vectors
 
     Parameters:
-      | *[in]*  **mat**   vector1
+      | *[in]*  **v1**  vector1
-      | *[in]*  **row1**  vector2
+      | *[in]*  **v2**  vector2
 
     Returns:
       | distance
@@ -475,7 +475,7 @@ Functions documentation
     possible orthogonal/perpendicular vector
 
     Parameters:
-      | *[in]*  **mat**   vector
+      | *[in]*  **v**     vector
       | *[out]* **dest**  orthogonal/perpendicular vector
 
 .. c:function:: void  glm_vec3_clamp(vec3 v, float minVal, float maxVal)

docs/source/version.rst

@@ -0,0 +1,15 @@
+.. default-domain:: C
+
+version
+================================================================================
+
+Header: cglm/version.h
+
+**cglm** uses semantic versioning (http://semver.org) which is MAJOR.MINOR.PATCH 
+
+| **CGLM_VERSION_MAJOR** is major number of the version.
+| **CGLM_VERSION_MINOR** is minor number of the version.
+| **CGLM_VERSION_PATCH** is patch number of the version.
+
+every release increases these numbers. You can check existing version by 
+including `cglm/version.h`

include/cglm/affine.h

@@ -40,10 +40,6 @@
 #include "mat4.h"
 #include "affine-mat.h"
 
-CGLM_INLINE
-void
-glm_mat4_mul(mat4 m1, mat4 m2, mat4 dest);
-
 /*!
  * @brief translate existing transform matrix by v vector
  *        and stores result in same matrix

include/cglm/call.h

@@ -12,10 +12,12 @@ extern "C" {
 #endif
 
 #include "cglm.h"
+#include "call/vec2.h"
 #include "call/vec3.h"
 #include "call/vec4.h"
-#include "call/mat4.h"
+#include "call/mat2.h"
 #include "call/mat3.h"
+#include "call/mat4.h"
 #include "call/affine.h"
 #include "call/cam.h"
 #include "call/quat.h"
@@ -29,6 +31,7 @@ extern "C" {
 #include "call/ease.h"
 #include "call/curve.h"
 #include "call/bezier.h"
+#include "call/ray.h"
 
 #ifdef __cplusplus
 }

include/cglm/call/mat2.h

@@ -0,0 +1,79 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglmc_mat2_h
+#define cglmc_mat2_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../cglm.h"
+
+CGLM_EXPORT
+void
+glmc_mat2_copy(mat2 mat, mat2 dest);
+
+CGLM_EXPORT
+void
+glmc_mat2_identity(mat2 mat);
+
+CGLM_EXPORT
+void
+glmc_mat2_identity_array(mat2 * __restrict mat, size_t count);
+
+CGLM_EXPORT
+void
+glmc_mat2_zero(mat2 mat);
+
+CGLM_EXPORT
+void
+glmc_mat2_mul(mat2 m1, mat2 m2, mat2 dest);
+
+CGLM_EXPORT
+void
+glmc_mat2_transpose_to(mat2 m, mat2 dest);
+
+CGLM_EXPORT
+void
+glmc_mat2_transpose(mat2 m);
+
+CGLM_EXPORT
+void
+glmc_mat2_mulv(mat2 m, vec2 v, vec2 dest);
+
+CGLM_EXPORT
+float
+glmc_mat2_trace(mat2 m);
+
+CGLM_EXPORT
+void
+glmc_mat2_scale(mat2 m, float s);
+
+CGLM_EXPORT
+float
+glmc_mat2_det(mat2 mat);
+
+CGLM_EXPORT
+void
+glmc_mat2_inv(mat2 mat, mat2 dest);
+
+CGLM_EXPORT
+void
+glmc_mat2_swap_col(mat2 mat, int col1, int col2);
+
+CGLM_EXPORT
+void
+glmc_mat2_swap_row(mat2 mat, int row1, int row2);
+
+CGLM_EXPORT
+float
+glmc_mat2_rmc(vec2 r, mat2 m, vec2 c);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* cglmc_mat2_h */

include/cglm/call/quat.h

@@ -131,11 +131,11 @@ glmc_quat_look(vec3 eye, versor ori, mat4 dest);
 
 CGLM_EXPORT
 void
-glmc_quat_for(vec3 dir, vec3 fwd, vec3 up, versor dest);
+glmc_quat_for(vec3 dir, vec3 up, versor dest);
 
 CGLM_EXPORT
 void
-glmc_quat_forp(vec3 from, vec3 to, vec3 fwd, vec3 up, versor dest);
+glmc_quat_forp(vec3 from, vec3 to, vec3 up, versor dest);
 
 CGLM_EXPORT
 void

include/cglm/call/ray.h

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglmc_ray_h
+#define cglmc_ray_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include "../cglm.h"
+
+CGLM_EXPORT
+bool
+glmc_ray_triangle(vec3   origin,
+                  vec3   direction,
+                  vec3   v0,
+                  vec3   v1,
+                  vec3   v2,
+                  float *d);
+    
+#ifdef __cplusplus
+}
+#endif
+#endif /* cglmc_ray_h */

include/cglm/call/vec2.h

@@ -0,0 +1,155 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglmc_vec2_h
+#define cglmc_vec2_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../cglm.h"
+
+CGLM_EXPORT
+void
+glmc_vec2(float * __restrict v, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_copy(vec2 a, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_zero(vec2 v);
+
+CGLM_EXPORT
+void
+glmc_vec2_one(vec2 v);
+
+CGLM_EXPORT
+float
+glmc_vec2_dot(vec2 a, vec2 b);
+
+CGLM_EXPORT
+float
+glmc_vec2_cross(vec2 a, vec2 b);
+
+CGLM_EXPORT
+float
+glmc_vec2_norm2(vec2 v);
+
+CGLM_EXPORT
+float
+glmc_vec2_norm(vec2 v);
+
+CGLM_EXPORT
+void
+glmc_vec2_add(vec2 a, vec2 b, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_adds(vec2 v, float s, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_sub(vec2 a, vec2 b, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_subs(vec2 v, float s, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_mul(vec2 a, vec2 b, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_scale(vec2 v, float s, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_scale_as(vec2 v, float s, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_div(vec2 a, vec2 b, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_divs(vec2 v, float s, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_addadd(vec2 a, vec2 b, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_subadd(vec2 a, vec2 b, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_muladd(vec2 a, vec2 b, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_muladds(vec2 a, float s, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_maxadd(vec2 a, vec2 b, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_minadd(vec2 a, vec2 b, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_negate_to(vec2 v, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_negate(vec2 v);
+
+CGLM_EXPORT
+void
+glmc_vec2_normalize(vec2 v);
+
+CGLM_EXPORT
+void
+glmc_vec2_normalize_to(vec2 v, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_rotate(vec2 v, float angle, vec2 dest);
+
+CGLM_EXPORT
+float
+glmc_vec2_distance2(vec2 a, vec2 b);
+
+CGLM_EXPORT
+float
+glmc_vec2_distance(vec2 a, vec2 b);
+
+CGLM_EXPORT
+void
+glmc_vec2_maxv(vec2 a, vec2 b, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_minv(vec2 a, vec2 b, vec2 dest);
+
+CGLM_EXPORT
+void
+glmc_vec2_clamp(vec2 v, float minval, float maxval);
+
+CGLM_EXPORT
+void
+glmc_vec2_lerp(vec2 from, vec2 to, float t, vec2 dest);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* cglmc_vec2_h */

include/cglm/cam.h

@@ -319,10 +319,7 @@ glm_perspective_resize(float aspect, mat4 proj) {
  */
 CGLM_INLINE
 void
-glm_lookat(vec3 eye,
+glm_lookat(vec3 eye, vec3 center, vec3 up, mat4 dest) {
-           vec3 center,
-           vec3 up,
-           mat4 dest) {
   CGLM_ALIGN(8) vec3 f, u, s;
 
   glm_vec3_sub(center, eye, f);

include/cglm/cglm.h

@@ -9,10 +9,12 @@
 #define cglm_h
 
 #include "common.h"
+#include "vec2.h"
 #include "vec3.h"
 #include "vec4.h"
 #include "mat4.h"
 #include "mat3.h"
+#include "mat2.h"
 #include "affine.h"
 #include "cam.h"
 #include "frustum.h"
@@ -28,5 +30,6 @@
 #include "ease.h"
 #include "curve.h"
 #include "bezier.h"
+#include "ray.h"
 
 #endif /* cglm_h */

include/cglm/io.h

@@ -83,6 +83,36 @@ glm_mat3_print(mat3              matrix,
 #undef n
 }
 
+CGLM_INLINE
+void
+glm_mat2_print(mat2              matrix,
+               FILE * __restrict ostream) {
+  int i;
+  int j;
+
+#define m 2
+#define n 2
+
+  fprintf(ostream, "Matrix (float%dx%d):\n", m, n);
+
+  for (i = 0; i < m; i++) {
+    fprintf(ostream, "\t|");
+    for (j = 0; j < n; j++) {
+      fprintf(ostream, "%0.4f", matrix[j][i]);;
+
+      if (j != n - 1)
+        fprintf(ostream, "\t");
+    }
+
+    fprintf(ostream, "|\n");
+  }
+
+  fprintf(ostream, "\n");
+
+#undef m
+#undef n
+}
+
 CGLM_INLINE
 void
 glm_vec4_print(vec4              vec,
@@ -149,6 +179,28 @@ glm_ivec3_print(ivec3             vec,
 #undef m
 }
 
+CGLM_INLINE
+void
+glm_vec2_print(vec2              vec,
+               FILE * __restrict ostream) {
+  int i;
+
+#define m 2
+
+  fprintf(ostream, "Vector (float%d):\n\t|", m);
+
+  for (i = 0; i < m; i++) {
+    fprintf(ostream, "%0.4f", vec[i]);
+
+    if (i != m - 1)
+      fprintf(ostream, "\t");
+  }
+
+  fprintf(ostream, "|\n\n");
+
+#undef m
+}
+
 CGLM_INLINE
 void
 glm_versor_print(versor            vec,

include/cglm/mat2.h

@@ -0,0 +1,322 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Macros:
+   GLM_MAT2_IDENTITY_INIT
+   GLM_MAT2_ZERO_INIT
+   GLM_MAT2_IDENTITY
+   GLM_MAT2_ZERO
+
+ Functions:
+   CGLM_INLINE void  glm_mat2_copy(mat2 mat, mat2 dest)
+   CGLM_INLINE void  glm_mat2_identity(mat2 mat)
+   CGLM_INLINE void  glm_mat2_identity_array(mat2 * restrict mat, size_t count)
+   CGLM_INLINE void  glm_mat2_zero(mat2 mat)
+   CGLM_INLINE void  glm_mat2_mul(mat2 m1, mat2 m2, mat2 dest)
+   CGLM_INLINE void  glm_mat2_transpose_to(mat2 m, mat2 dest)
+   CGLM_INLINE void  glm_mat2_transpose(mat2 m)
+   CGLM_INLINE void  glm_mat2_mulv(mat2 m, vec2 v, vec2 dest)
+   CGLM_INLINE float glm_mat2_trace(mat2 m)
+   CGLM_INLINE void  glm_mat2_scale(mat2 m, float s)
+   CGLM_INLINE float glm_mat2_det(mat2 mat)
+   CGLM_INLINE void  glm_mat2_inv(mat2 mat, mat2 dest)
+   CGLM_INLINE void  glm_mat2_swap_col(mat2 mat, int col1, int col2)
+   CGLM_INLINE void  glm_mat2_swap_row(mat2 mat, int row1, int row2)
+   CGLM_INLINE float glm_mat2_rmc(vec2 r, mat2 m, vec2 c)
+ */
+
+#ifndef cglm_mat2_h
+#define cglm_mat2_h
+
+#include "common.h"
+#include "vec2.h"
+
+#ifdef CGLM_SSE_FP
+#  include "simd/sse2/mat2.h"
+#endif
+
+#define GLM_MAT2_IDENTITY_INIT  {{1.0f, 0.0f}, {0.0f, 1.0f}}
+#define GLM_MAT2_ZERO_INIT      {{0.0f, 0.0f}, {0.0f, 0.0f}}
+
+/* for C only */
+#define GLM_MAT2_IDENTITY ((mat2)GLM_MAT2_IDENTITY_INIT)
+#define GLM_MAT2_ZERO     ((mat2)GLM_MAT2_ZERO_INIT)
+
+/*!
+ * @brief copy all members of [mat] to [dest]
+ *
+ * @param[in]  mat  source
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_mat2_copy(mat2 mat, mat2 dest) {
+  glm_vec4_copy(mat[0], dest[0]);
+}
+
+/*!
+ * @brief make given matrix identity. It is identical with below,
+ *        but it is more easy to do that with this func especially for members
+ *        e.g. glm_mat2_identity(aStruct->aMatrix);
+ *
+ * @code
+ * glm_mat2_copy(GLM_MAT2_IDENTITY, mat); // C only
+ *
+ * // or
+ * mat2 mat = GLM_MAT2_IDENTITY_INIT;
+ * @endcode
+ *
+ * @param[in, out]  mat  destination
+ */
+CGLM_INLINE
+void
+glm_mat2_identity(mat2 mat) {
+  CGLM_ALIGN_MAT mat2 t = GLM_MAT2_IDENTITY_INIT;
+  glm_mat2_copy(t, mat);
+}
+
+/*!
+ * @brief make given matrix array's each element identity matrix
+ *
+ * @param[in, out]  mat   matrix array (must be aligned (16)
+ *                        if alignment is not disabled)
+ *
+ * @param[in]       count count of matrices
+ */
+CGLM_INLINE
+void
+glm_mat2_identity_array(mat2 * __restrict mat, size_t count) {
+  CGLM_ALIGN_MAT mat2 t = GLM_MAT2_IDENTITY_INIT;
+  size_t i;
+
+  for (i = 0; i < count; i++) {
+    glm_mat2_copy(t, mat[i]);
+  }
+}
+
+/*!
+ * @brief make given matrix zero.
+ *
+ * @param[in, out]  mat  matrix
+ */
+CGLM_INLINE
+void
+glm_mat2_zero(mat2 mat) {
+  CGLM_ALIGN_MAT mat2 t = GLM_MAT2_ZERO_INIT;
+  glm_mat2_copy(t, mat);
+}
+
+/*!
+ * @brief multiply m1 and m2 to dest
+ *
+ * m1, m2 and dest matrices can be same matrix, it is possible to write this:
+ *
+ * @code
+ * mat2 m = GLM_MAT2_IDENTITY_INIT;
+ * glm_mat2_mul(m, m, m);
+ * @endcode
+ *
+ * @param[in]  m1   left matrix
+ * @param[in]  m2   right matrix
+ * @param[out] dest destination matrix
+ */
+CGLM_INLINE
+void
+glm_mat2_mul(mat2 m1, mat2 m2, mat2 dest) {
+#if defined( __SSE__ ) || defined( __SSE2__ )
+  glm_mat2_mul_sse2(m1, m2, dest);
+#else
+  float a00 = m1[0][0], a01 = m1[0][1],
+        a10 = m1[1][0], a11 = m1[1][1],
+        b00 = m2[0][0], b01 = m2[0][1],
+        b10 = m2[1][0], b11 = m2[1][1];
+
+  dest[0][0] = a00 * b00 + a10 * b01;
+  dest[0][1] = a01 * b00 + a11 * b01;
+  dest[1][0] = a00 * b10 + a10 * b11;
+  dest[1][1] = a01 * b10 + a11 * b11;
+#endif
+}
+
+/*!
+ * @brief transpose mat2 and store in dest
+ *
+ * source matrix will not be transposed unless dest is m
+ *
+ * @param[in]  m     matrix
+ * @param[out] dest  result
+ */
+CGLM_INLINE
+void
+glm_mat2_transpose_to(mat2 m, mat2 dest) {
+#if defined( __SSE__ ) || defined( __SSE2__ )
+  glm_mat2_transp_sse2(m, dest);
+#else
+  dest[0][0] = m[0][0];
+  dest[0][1] = m[1][0];
+  dest[1][0] = m[0][1];
+  dest[1][1] = m[1][1];
+#endif
+}
+
+/*!
+ * @brief tranpose mat2 and store result in same matrix
+ *
+ * @param[in, out] m source and dest
+ */
+CGLM_INLINE
+void
+glm_mat2_transpose(mat2 m) {
+  float tmp;
+  tmp     = m[0][1];
+  m[0][1] = m[1][0];
+  m[1][0] = tmp;
+}
+
+/*!
+ * @brief multiply mat2 with vec2 (column vector) and store in dest vector
+ *
+ * @param[in]  m    mat2 (left)
+ * @param[in]  v    vec2 (right, column vector)
+ * @param[out] dest vec2 (result, column vector)
+ */
+CGLM_INLINE
+void
+glm_mat2_mulv(mat2 m, vec2 v, vec2 dest) {
+  dest[0] = m[0][0] * v[0] + m[1][0] * v[1];
+  dest[1] = m[0][1] * v[0] + m[1][1] * v[1];
+}
+
+/*!
+ * @brief trace of matrix
+ *
+ * sum of the elements on the main diagonal from upper left to the lower right
+ *
+ * @param[in]  m matrix
+ */
+CGLM_INLINE
+float
+glm_mat2_trace(mat2 m) {
+  return m[0][0] + m[1][1];
+}
+
+/*!
+ * @brief scale (multiply with scalar) matrix
+ *
+ * multiply matrix with scalar
+ *
+ * @param[in, out] m matrix
+ * @param[in]      s scalar
+ */
+CGLM_INLINE
+void
+glm_mat2_scale(mat2 m, float s) {
+  glm_vec4_scale(m[0], s, m[0]);
+}
+
+/*!
+ * @brief mat2 determinant
+ *
+ * @param[in] mat matrix
+ *
+ * @return determinant
+ */
+CGLM_INLINE
+float
+glm_mat2_det(mat2 mat) {
+  return mat[0][0] * mat[1][1] - mat[1][0] * mat[0][1];
+}
+
+/*!
+ * @brief inverse mat2 and store in dest
+ *
+ * @param[in]  mat  matrix
+ * @param[out] dest inverse matrix
+ */
+CGLM_INLINE
+void
+glm_mat2_inv(mat2 mat, mat2 dest) {
+  float det;
+  float a = mat[0][0], b = mat[0][1],
+        c = mat[1][0], d = mat[1][1];
+
+  det = 1.0f / (a * d - b * c);
+
+  dest[0][0] =  d * det;
+  dest[0][1] = -b * det;
+  dest[1][0] = -c * det;
+  dest[1][1] =  a * det;
+}
+
+/*!
+ * @brief swap two matrix columns
+ *
+ * @param[in,out] mat  matrix
+ * @param[in]     col1 col1
+ * @param[in]     col2 col2
+ */
+CGLM_INLINE
+void
+glm_mat2_swap_col(mat2 mat, int col1, int col2) {
+  float a, b;
+
+  a = mat[col1][0];
+  b = mat[col1][1];
+
+  mat[col1][0] = mat[col2][0];
+  mat[col1][1] = mat[col2][1];
+
+  mat[col2][0] = a;
+  mat[col2][1] = b;
+}
+
+/*!
+ * @brief swap two matrix rows
+ *
+ * @param[in,out] mat  matrix
+ * @param[in]     row1 row1
+ * @param[in]     row2 row2
+ */
+CGLM_INLINE
+void
+glm_mat2_swap_row(mat2 mat, int row1, int row2) {
+  float a, b;
+
+  a = mat[0][row1];
+  b = mat[1][row1];
+
+  mat[0][row1] = mat[0][row2];
+  mat[1][row1] = mat[1][row2];
+
+  mat[0][row2] = a;
+  mat[1][row2] = b;
+}
+
+/*!
+ * @brief helper for  R (row vector) * M (matrix) * C (column vector)
+ *
+ * rmc stands for Row * Matrix * Column
+ *
+ * the result is scalar because R * M = Matrix1x2 (row vector),
+ * then Matrix1x2 * Vec2 (column vector) = Matrix1x1 (Scalar)
+ *
+ * @param[in]  r   row vector or matrix1x2
+ * @param[in]  m   matrix2x2
+ * @param[in]  c   column vector or matrix2x1
+ *
+ * @return scalar value e.g. Matrix1x1
+ */
+CGLM_INLINE
+float
+glm_mat2_rmc(vec2 r, mat2 m, vec2 c) {
+  vec2 tmp;
+  glm_mat2_mulv(m, c, tmp);
+  return glm_vec2_dot(r, tmp);
+}
+
+#endif /* cglm_mat2_h */

include/cglm/plane.h

@@ -30,7 +30,14 @@
 CGLM_INLINE
 void
 glm_plane_normalize(vec4 plane) {
-  glm_vec4_scale(plane, 1.0f / glm_vec3_norm(plane), plane);
+  float norm;
+  
+  if ((norm = glm_vec3_norm(plane)) == 0.0f) {
+    glm_vec4_zero(plane);
+    return;
+  }
+  
+  glm_vec4_scale(plane, 1.0f / norm, plane);
 }
 
 #endif /* cglm_plane_h */

include/cglm/quat.h

@@ -63,10 +63,6 @@
 #  include "simd/sse2/quat.h"
 #endif
 
-CGLM_INLINE
-void
-glm_mat4_identity(mat4 mat);
-
 CGLM_INLINE
 void
 glm_mat4_mulv(mat4 m, vec4 v, vec4 dest);
@@ -693,32 +689,23 @@ glm_quat_look(vec3 eye, versor ori, mat4 dest) {
  * @brief creates look rotation quaternion
  *
  * @param[in]   dir   direction to look
- * @param[in]   fwd   forward vector
  * @param[in]   up    up vector
  * @param[out]  dest  destination quaternion
  */
 CGLM_INLINE
 void
-glm_quat_for(vec3 dir, vec3 fwd, vec3 up, versor dest) {
+glm_quat_for(vec3 dir, vec3 up, versor dest) {
-  CGLM_ALIGN(8) vec3 axis;
+  CGLM_ALIGN_MAT mat3 m;
-  float dot, angle;
 
-  dot = glm_vec3_dot(dir, fwd);
+  glm_vec3_normalize_to(dir, m[2]); 
-  if (fabsf(dot + 1.0f)  < 0.000001f) {
-    glm_quat_init(dest, up[0], up[1], up[2], GLM_PIf);
-    return;
-  }
 
-  if (fabsf(dot - 1.0f) < 0.000001f) {
+  /* No need to negate in LH, but we use RH here */
-    glm_quat_identity(dest);
+  glm_vec3_negate(m[2]);
-    return;
+  
-  }
+  glm_vec3_crossn(up, m[2], m[0]);
+  glm_vec3_cross(m[2], m[0], m[1]);
 
-  angle = acosf(dot);
+  glm_mat3_quat(m, dest);
-  glm_cross(fwd, dir, axis);
-  glm_normalize(axis);
-
-  glm_quatv(dest, angle, axis);
 }
 
 /*!
@@ -727,16 +714,15 @@ glm_quat_for(vec3 dir, vec3 fwd, vec3 up, versor dest) {
  *
  * @param[in]   from  source point
  * @param[in]   to    destination point
- * @param[in]   fwd   forward vector
  * @param[in]   up    up vector
  * @param[out]  dest  destination quaternion
  */
 CGLM_INLINE
 void
-glm_quat_forp(vec3 from, vec3 to, vec3 fwd, vec3 up, versor dest) {
+glm_quat_forp(vec3 from, vec3 to, vec3 up, versor dest) {
   CGLM_ALIGN(8) vec3 dir;
   glm_vec3_sub(to, from, dir);
-  glm_quat_for(dir, fwd, up, dest);
+  glm_quat_for(dir, up, dest);
 }
 
 /*!

include/cglm/ray.h

@@ -0,0 +1,81 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE bool glm_line_triangle_intersect(vec3   origin,
+                                                vec3   direction,
+                                                vec3   v0,
+                                                vec3   v1,
+                                                vec3   v2,
+                                                float *d);
+*/
+
+#ifndef cglm_ray_h
+#define cglm_ray_h
+
+#include "vec3.h"
+
+/*!
+ * @brief Möller–Trumbore ray-triangle intersection algorithm
+ * 
+ * @param[in] origin         origin of ray
+ * @param[in] direction      direction of ray
+ * @param[in] v0             first vertex of triangle
+ * @param[in] v1             second vertex of triangle
+ * @param[in] v2             third vertex of triangle
+ * @param[in, out] d         distance to intersection
+ * @param[out] intersection  whether there is intersection
+ */
+
+CGLM_INLINE
+bool
+glm_ray_triangle(vec3   origin,
+                 vec3   direction,
+                 vec3   v0,
+                 vec3   v1,
+                 vec3   v2,
+                 float *d) {
+  vec3        edge1, edge2, p, t, q;
+  float       det, inv_det, u, v, dist;
+  const float epsilon = 0.000001f;
+
+  glm_vec3_sub(v1, v0, edge1);
+  glm_vec3_sub(v2, v0, edge2);
+
+  glm_vec3_cross(direction, edge2, p);
+
+  det = glm_vec3_dot(edge1, p);
+
+  if (det > -epsilon && det < epsilon)
+    return 0;
+
+  inv_det = 1.0f / det;
+
+  glm_vec3_sub(origin, v0, t);
+
+  u = inv_det * glm_vec3_dot(t, p);
+
+  if (u < 0.0f || u > 1.0f)
+    return 0;
+
+  glm_vec3_cross(t, edge1, q);
+
+  v = inv_det * glm_vec3_dot(direction, q);
+
+  if (v < 0.0f || u + v > 1.0f)
+    return 0;
+
+  dist = inv_det * glm_vec3_dot(edge2, q);
+
+  if (d)
+      *d = dist;
+
+  return dist > epsilon;
+}
+
+#endif

include/cglm/simd/sse2/mat2.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglm_mat2_sse_h
+#define cglm_mat2_sse_h
+#if defined( __SSE__ ) || defined( __SSE2__ )
+
+#include "../../common.h"
+#include "../intrin.h"
+
+CGLM_INLINE
+void
+glm_mat2_mul_sse2(mat2 m1, mat2 m2, mat2 dest) {
+  __m128 x0, x1, x2;
+
+  x1 = glmm_load(m1[0]); /* d c b a */
+  x2 = glmm_load(m2[0]); /* h g f e */
+
+  /*
+   dest[0][0] = a * e + c * f;
+   dest[0][1] = b * e + d * f;
+   dest[1][0] = a * g + c * h;
+   dest[1][1] = b * g + d * h;
+   */
+  x0 = _mm_mul_ps(_mm_movelh_ps(x1, x1), glmm_shuff1(x2, 2, 2, 0, 0));
+  x1 = _mm_mul_ps(_mm_movehl_ps(x1, x1), glmm_shuff1(x2, 3, 3, 1, 1));
+  x1 = _mm_add_ps(x0, x1);
+
+  glmm_store(dest[0], x1);
+}
+
+CGLM_INLINE
+void
+glm_mat2_transp_sse2(mat2 m, mat2 dest) {
+  /* d c b a */
+  /* d b c a */
+  glmm_store(dest[0], glmm_shuff1(glmm_load(m[0]), 3, 1, 2, 0));
+}
+
+#endif
+#endif /* cglm_mat2_sse_h */

include/cglm/struct.h

@@ -13,8 +13,10 @@ extern "C" {
 
 #include "cglm.h"
 #include "types-struct.h"
+#include "struct/vec2.h"
 #include "struct/vec3.h"
 #include "struct/vec4.h"
+#include "struct/mat2.h"
 #include "struct/mat3.h"
 #include "struct/mat4.h"
 #include "struct/affine.h"

include/cglm/struct/affine.h

@@ -39,10 +39,6 @@
 #include "vec4.h"
 #include "mat4.h"
 
-CGLM_INLINE
-mat4s
-glms_mat4_mul(mat4s m1, mat4s m2);
-
 /*!
  * @brief translate existing transform matrix by v vector
  *        and stores result in same matrix

include/cglm/struct/mat2.h

@@ -0,0 +1,258 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Macros:
+   GLM_MAT2_IDENTITY_INIT
+   GLM_MAT2_ZERO_INIT
+   GLM_MAT2_IDENTITY
+   GLM_MAT2_ZERO
+
+ Functions:
+   CGLM_INLINE void  glms_mat2_identity(mat2 mat)
+   CGLM_INLINE void  glms_mat2_identity_array(mat2 * restrict mat, size_t count)
+   CGLM_INLINE void  glms_mat2_zero(mat2 mat)
+   CGLM_INLINE void  glms_mat2_mul(mat2 m1, mat2 m2, mat2 dest)
+   CGLM_INLINE void  glms_mat2_transpose_to(mat2 m, mat2 dest)
+   CGLM_INLINE void  glms_mat2_transpose(mat2 m)
+   CGLM_INLINE void  glms_mat2_mulv(mat2 m, vec2 v, vec2 dest)
+   CGLM_INLINE float glms_mat2_trace(mat2 m)
+   CGLM_INLINE void  glms_mat2_scale(mat2 m, float s)
+   CGLM_INLINE float glms_mat2_det(mat2 mat)
+   CGLM_INLINE void  glms_mat2_inv(mat2 mat, mat2 dest)
+   CGLM_INLINE void  glms_mat2_swap_col(mat2 mat, int col1, int col2)
+   CGLM_INLINE void  glms_mat2_swap_row(mat2 mat, int row1, int row2)
+   CGLM_INLINE float glms_mat2_rmc(vec2 r, mat2 m, vec2 c)
+ */
+
+#ifndef cglms_mat2_h
+#define cglms_mat2_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../mat2.h"
+
+#define GLMS_MAT2_IDENTITY_INIT {1.0f, 0.0f, 0.0f, 1.0f}
+#define GLMS_MAT2_ZERO_INIT     {0.0f, 0.0f, 0.0f, 0.0f}
+
+/* for C only */
+#define GLMS_MAT2_IDENTITY ((mat3s)GLMS_MAT2_IDENTITY_INIT)
+#define GLMS_MAT2_ZERO     ((mat3s)GLMS_MAT2_ZERO_INIT)
+
+/*!
+ * @brief make given matrix identity. It is identical with below,
+ *        but it is more easy to do that with this func especially for members
+ *        e.g. glm_mat2_identity(aStruct->aMatrix);
+ *
+ * @code
+ * glm_mat2_copy(GLM_MAT2_IDENTITY, mat); // C only
+ *
+ * // or
+ * mat2 mat = GLM_MAT2_IDENTITY_INIT;
+ * @endcode
+ *
+ * @returns identity matrix
+ */
+CGLM_INLINE
+mat2s
+glms_mat2_identity(void) {
+  mat2s r;
+  glm_mat2_identity(r.raw);
+  return r;
+}
+
+/*!
+ * @brief make given matrix array's each element identity matrix
+ *
+ * @param[in, out]  mat   matrix array (must be aligned (16)
+ *                        if alignment is not disabled)
+ *
+ * @param[in]       count count of matrices
+ */
+CGLM_INLINE
+void
+glms_mat2_identity_array(mat2s * __restrict mat, size_t count) {
+  CGLM_ALIGN_MAT mat2s t = GLMS_MAT2_IDENTITY_INIT;
+  size_t i;
+
+  for (i = 0; i < count; i++) {
+    glm_mat2_copy(t.raw, mat[i].raw);
+  }
+}
+
+/*!
+ * @brief make given matrix zero.
+ *
+ * @returns  matrix
+ */
+CGLM_INLINE
+mat2s
+glms_mat2_zero(void) {
+  mat2s r;
+  glm_mat2_zero(r.raw);
+  return r;
+}
+
+/*!
+ * @brief multiply m1 and m2 to dest
+ *
+ * m1, m2 and dest matrices can be same matrix, it is possible to write this:
+ *
+ * @code
+ * mat2 m = GLM_MAT2_IDENTITY_INIT;
+ * glm_mat2_mul(m, m, m);
+ * @endcode
+ *
+ * @param[in]  m1   left matrix
+ * @param[in]  m2   right matrix
+ *
+ * @returns matrix
+ */
+CGLM_INLINE
+mat2s
+glms_mat2_mul(mat2s m1, mat2s m2) {
+  mat2s r;
+  glm_mat2_mul(m1.raw, m2.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief transpose mat2
+ *
+ * @param[in] m matrix to transpose
+ *
+ * @returns transposed matrix
+ */
+CGLM_INLINE
+mat2s
+glms_mat2_transpose(mat2s m) {
+  glm_mat2_transpose(m.raw);
+  return m;
+}
+
+/*!
+ * @brief multiply mat2 with vec2 (column vector) and store in dest vector
+ *
+ * @param[in]  m    mat2 (left)
+ * @param[in]  v    vec2 (right, column vector)
+ * @returns         vec2 (result, column vector)
+ */
+CGLM_INLINE
+vec2s
+glms_mat2_mulv(mat2s m, vec2s v) {
+  vec2s r;
+  glm_mat2_mulv(m.raw, v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief trace of matrix
+ *
+ * sum of the elements on the main diagonal from upper left to the lower right
+ *
+ * @param[in]  m matrix
+ */
+CGLM_INLINE
+float
+glms_mat2_trace(mat2s m) {
+  return glm_mat2_trace(m.raw);
+}
+
+/*!
+ * @brief scale (multiply with scalar) matrix
+ *
+ * multiply matrix with scalar
+ *
+ * @param[in, out] m matrix
+ * @param[in]      s scalar
+ * @returns matrix
+ */
+CGLM_INLINE
+mat2s
+glms_mat2_scale(mat2s m, float s) {
+  glm_mat2_scale(m.raw, s);
+  return m;
+}
+
+/*!
+ * @brief mat2 determinant
+ *
+ * @param[in] mat matrix
+ *
+ * @return determinant
+ */
+CGLM_INLINE
+float
+glms_mat2_det(mat2s mat) {
+  return glm_mat2_det(mat.raw);
+}
+
+/*!
+ * @brief inverse mat2 and store in dest
+ *
+ * @param[in]  mat  matrix
+ * @returns matrix
+ */
+CGLM_INLINE
+mat2s
+glms_mat2_inv(mat2s mat) {
+  mat2s r;
+  glm_mat2_inv(mat.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief swap two matrix columns
+ *
+ * @param[in] mat  matrix
+ * @param[in] col1 col1
+ * @param[in] col2 col2
+ * @returns matrix
+ */
+CGLM_INLINE
+mat2s
+glms_mat2_swap_col(mat2s mat, int col1, int col2) {
+  glm_mat2_swap_col(mat.raw, col1, col2);
+  return mat;
+}
+
+/*!
+ * @brief swap two matrix rows
+ *
+ * @param[in] mat  matrix
+ * @param[in] row1 row1
+ * @param[in] row2 row2
+ * @returns matrix
+ */
+CGLM_INLINE
+mat2s
+glms_mat2_swap_row(mat2s mat, int row1, int row2) {
+  glm_mat2_swap_row(mat.raw, row1, row2);
+  return mat;
+}
+
+/*!
+ * @brief helper for  R (row vector) * M (matrix) * C (column vector)
+ *
+ * rmc stands for Row * Matrix * Column
+ *
+ * the result is scalar because R * M = Matrix1x2 (row vector),
+ * then Matrix1x2 * Vec2 (column vector) = Matrix1x1 (Scalar)
+ *
+ * @param[in]  r   row vector or matrix1x2
+ * @param[in]  m   matrix2x2
+ * @param[in]  c   column vector or matrix2x1
+ *
+ * @return scalar value e.g. Matrix1x1
+ */
+CGLM_INLINE
+float
+glms_mat2_rmc(vec2s r, mat2s m, vec2s c) {
+  return glm_mat2_rmc(r.raw, m.raw, c.raw);
+}
+
+#endif /* cglms_mat2_h */

include/cglm/struct/quat.h

@@ -437,15 +437,14 @@ glms_quat_look(vec3s eye, versors ori) {
  * @brief creates look rotation quaternion
  *
  * @param[in]   dir   direction to look
- * @param[in]   fwd   forward vector
  * @param[in]   up    up vector
  * @returns  destination quaternion
  */
 CGLM_INLINE
 versors
-glms_quat_for(vec3s dir, vec3s fwd, vec3s up) {
+glms_quat_for(vec3s dir, vec3s up) {
   versors dest;
-  glm_quat_for(dir.raw, fwd.raw, up.raw, dest.raw);
+  glm_quat_for(dir.raw, up.raw, dest.raw);
   return dest;
 }
 
@@ -455,15 +454,14 @@ glms_quat_for(vec3s dir, vec3s fwd, vec3s up) {
  *
  * @param[in]   from  source point
  * @param[in]   to    destination point
- * @param[in]   fwd   forward vector
  * @param[in]   up    up vector
  * @returns  destination quaternion
  */
 CGLM_INLINE
 versors
-glms_quat_forp(vec3s from, vec3s to, vec3s fwd, vec3s up) {
+glms_quat_forp(vec3s from, vec3s to, vec3s up) {
   versors dest;
-  glm_quat_forp(from.raw, to.raw, fwd.raw, up.raw, dest.raw);
+  glm_quat_forp(from.raw, to.raw, up.raw, dest.raw);
   return dest;
 }
 

include/cglm/struct/sphere.h

@@ -42,9 +42,9 @@ glms_sphere_radii(vec4s s) {
  */
 CGLM_INLINE
 vec4s
-glms_sphere_transform(vec4s s, mat4 m) {
+glms_sphere_transform(vec4s s, mat4s m) {
   vec4s r;
-  glm_sphere_transform(s.raw, m, r.raw);
+  glm_sphere_transform(s.raw, m.raw, r.raw);
   return r;
 }
 

include/cglm/struct/vec2-ext.h

@@ -0,0 +1,198 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*!
+ * @brief SIMD like functions
+ */
+
+/*
+ Functions:
+   CGLM_INLINE vec2s glms_vec2_fill(float val)
+   CGLM_INLINE bool  glms_vec2_eq(vec2s v, float val)
+   CGLM_INLINE bool  glms_vec2_eq_eps(vec2s v, float val)
+   CGLM_INLINE bool  glms_vec2_eq_all(vec2s v)
+   CGLM_INLINE bool  glms_vec2_eqv(vec2s a, vec2s b)
+   CGLM_INLINE bool  glms_vec2_eqv_eps(vec2s a, vec2s b)
+   CGLM_INLINE float glms_vec2_max(vec2s v)
+   CGLM_INLINE float glms_vec2_min(vec2s v)
+   CGLM_INLINE bool  glms_vec2_isnan(vec2s v)
+   CGLM_INLINE bool  glms_vec2_isinf(vec2s v)
+   CGLM_INLINE bool  glms_vec2_isvalid(vec2s v)
+   CGLM_INLINE vec2s glms_vec2_sign(vec2s v)
+   CGLM_INLINE vec2s glms_vec2_sqrt(vec2s v)
+ */
+
+#ifndef cglms_vec2s_ext_h
+#define cglms_vec2s_ext_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../util.h"
+#include "../vec2-ext.h"
+
+/*!
+ * @brief fill a vector with specified value
+ *
+ * @param[in]  val  value
+ * @returns         dest
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_fill(float val) {
+  vec2s r;
+  glm_vec2_fill(r.raw, val);
+  return r;
+}
+
+/*!
+ * @brief check if vector is equal to value (without epsilon)
+ *
+ * @param[in] v   vector
+ * @param[in] val value
+ */
+CGLM_INLINE
+bool
+glms_vec2_eq(vec2s v, float val) {
+  return glm_vec2_eq(v.raw, val);
+}
+
+/*!
+ * @brief check if vector is equal to value (with epsilon)
+ *
+ * @param[in] v   vector
+ * @param[in] val value
+ */
+CGLM_INLINE
+bool
+glms_vec2_eq_eps(vec2s v, float val) {
+  return glm_vec2_eq_eps(v.raw, val);
+}
+
+/*!
+ * @brief check if vectors members are equal (without epsilon)
+ *
+ * @param[in] v   vector
+ */
+CGLM_INLINE
+bool
+glms_vec2_eq_all(vec2s v) {
+  return glm_vec2_eq_all(v.raw);
+}
+
+/*!
+ * @brief check if vector is equal to another (without epsilon)
+ *
+ * @param[in] a vector
+ * @param[in] b vector
+ */
+CGLM_INLINE
+bool
+glms_vec2_eqv(vec2s a, vec2s b) {
+  return glm_vec2_eqv(a.raw, b.raw);
+}
+
+/*!
+ * @brief check if vector is equal to another (with epsilon)
+ *
+ * @param[in] a vector
+ * @param[in] b vector
+ */
+CGLM_INLINE
+bool
+glms_vec2_eqv_eps(vec2s a, vec2s b) {
+  return glm_vec2_eqv_eps(a.raw, b.raw);
+}
+
+/*!
+ * @brief max value of vector
+ *
+ * @param[in] v vector
+ */
+CGLM_INLINE
+float
+glms_vec2_max(vec2s v) {
+  return glm_vec2_max(v.raw);
+}
+
+/*!
+ * @brief min value of vector
+ *
+ * @param[in] v vector
+ */
+CGLM_INLINE
+float
+glms_vec2_min(vec2s v) {
+  return glm_vec2_min(v.raw);
+}
+
+/*!
+ * @brief check if all items are NaN (not a number)
+ *        you should only use this in DEBUG mode or very critical asserts
+ *
+ * @param[in] v vector
+ */
+CGLM_INLINE
+bool
+glms_vec2_isnan(vec2s v) {
+  return glm_vec2_isnan(v.raw);
+}
+
+/*!
+ * @brief check if all items are INFINITY
+ *        you should only use this in DEBUG mode or very critical asserts
+ *
+ * @param[in] v vector
+ */
+CGLM_INLINE
+bool
+glms_vec2_isinf(vec2s v) {
+  return glm_vec2_isinf(v.raw);
+}
+
+/*!
+ * @brief check if all items are valid number
+ *        you should only use this in DEBUG mode or very critical asserts
+ *
+ * @param[in] v vector
+ */
+CGLM_INLINE
+bool
+glms_vec2_isvalid(vec2s v) {
+  return glm_vec2_isvalid(v.raw);
+}
+
+/*!
+ * @brief get sign of 32 bit float as +1, -1, 0
+ *
+ * Important: It returns 0 for zero/NaN input
+ *
+ * @param   v   vector
+ * @returns     sign vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_sign(vec2s v) {
+  vec2s r;
+  glm_vec2_sign(v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief square root of each vector item
+ *
+ * @param[in]  v    vector
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_sqrt(vec2s v) {
+  vec2s r;
+  glm_vec2_sqrt(v.raw, r.raw);
+  return r;
+}
+
+#endif /* cglms_vec2s_ext_h */

include/cglm/struct/vec2.h

@@ -0,0 +1,561 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Macros:
+   GLMS_VEC2_ONE_INIT
+   GLMS_VEC2_ZERO_INIT
+   GLMS_VEC2_ONE
+   GLMS_VEC2_ZERO
+
+ Functions:
+   CGLM_INLINE vec2s glms_vec2(vec3s v3)
+   CGLM_INLINE void  glms_vec2_pack(vec2s dst[], vec2 src[], size_t len)
+   CGLM_INLINE void  glms_vec2_unpack(vec2 dst[], vec2s src[], size_t len)
+   CGLM_INLINE vec2s glms_vec2_zero(void)
+   CGLM_INLINE vec2s glms_vec2_one(void)
+   CGLM_INLINE float glms_vec2_dot(vec2s a, vec2s b)
+   CGLM_INLINE float glms_vec2_cross(vec2s a, vec2s b)
+   CGLM_INLINE float glms_vec2_norm2(vec2s v)
+   CGLM_INLINE float glms_vec2_norm(vec2s v)
+   CGLM_INLINE vec2s glms_vec2_add(vec2s a, vec2s b)
+   CGLM_INLINE vec2s glms_vec2_adds(vec2s a, float s)
+   CGLM_INLINE vec2s glms_vec2_sub(vec2s a, vec2s b)
+   CGLM_INLINE vec2s glms_vec2_subs(vec2s a, float s)
+   CGLM_INLINE vec2s glms_vec2_mul(vec2s a, vec2s b)
+   CGLM_INLINE vec2s glms_vec2_scale(vec2s v, float s)
+   CGLM_INLINE vec2s glms_vec2_scale_as(vec2s v, float s)
+   CGLM_INLINE vec2s glms_vec2_div(vec2s a, vec2s b)
+   CGLM_INLINE vec2s glms_vec2_divs(vec2s a, float s)
+   CGLM_INLINE vec2s glms_vec2_addadd(vec2s a, vec2s b, vec2s dest)
+   CGLM_INLINE vec2s glms_vec2_subadd(vec2s a, vec2s b, vec2s dest)
+   CGLM_INLINE vec2s glms_vec2_muladd(vec2s a, vec2s b, vec2s dest)
+   CGLM_INLINE vec2s glms_vec2_muladds(vec2s a, float s, vec2s dest)
+   CGLM_INLINE vec2s glms_vec2_maxadd(vec2s a, vec2s b, vec2s dest)
+   CGLM_INLINE vec2s glms_vec2_minadd(vec2s a, vec2s b, vec2s dest)
+   CGLM_INLINE vec2s glms_vec2_negate(vec2s v)
+   CGLM_INLINE vec2s glms_vec2_normalize(vec2s v)
+   CGLM_INLINE vec2s glms_vec2_rotate(vec2s v, float angle, vec2s axis)
+   CGLM_INLINE float glms_vec2_distance(vec2s a, vec2s b)
+   CGLM_INLINE float glms_vec2_distance2(vec2s a, vec2s b)
+   CGLM_INLINE vec2s glms_vec2_maxv(vec2s a, vec2s b)
+   CGLM_INLINE vec2s glms_vec2_minv(vec2s a, vec2s b)
+   CGLM_INLINE vec2s glms_vec2_clamp(vec2s v, float minVal, float maxVal)
+   CGLM_INLINE vec2s glms_vec2_lerp(vec2s from, vec2s to, float t)
+ */
+
+#ifndef cglms_vec2s_h
+#define cglms_vec2s_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../util.h"
+#include "../vec2.h"
+#include "vec2-ext.h"
+
+#define GLMS_VEC2_ONE_INIT   {GLM_VEC2_ONE_INIT}
+#define GLMS_VEC2_ZERO_INIT  {GLM_VEC2_ZERO_INIT}
+
+#define GLMS_VEC2_ONE  ((vec2s)GLMS_VEC2_ONE_INIT)
+#define GLMS_VEC2_ZERO ((vec2s)GLMS_VEC2_ZERO_INIT)
+
+/*!
+ * @brief init vec2 using vec2
+ *
+ * @param[in]  v3   vector3
+ * @returns         destination
+ */
+CGLM_INLINE
+vec2s
+glms_vec2(vec3s v3) {
+  vec2s r;
+  glm_vec2(v3.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief pack an array of vec2 into an array of vec2s
+ *
+ * @param[out] dst array of vec2
+ * @param[in]  src array of vec2s
+ * @param[in]  len number of elements
+ */
+CGLM_INLINE
+void
+glms_vec2_pack(vec2s dst[], vec2 src[], size_t len) {
+  size_t i;
+
+  for (i = 0; i < len; i++) {
+    glm_vec2_copy(src[i], dst[i].raw);
+  }
+}
+
+/*!
+ * @brief unpack an array of vec2s into an array of vec2
+ *
+ * @param[out] dst array of vec2s
+ * @param[in]  src array of vec2
+ * @param[in]  len number of elements
+ */
+CGLM_INLINE
+void
+glms_vec2_unpack(vec2 dst[], vec2s src[], size_t len) {
+  size_t i;
+
+  for (i = 0; i < len; i++) {
+    glm_vec2_copy(src[i].raw, dst[i]);
+  }
+}
+
+/*!
+ * @brief make vector zero
+ *
+ * @returns zero vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_zero(void) {
+  vec2s r;
+  glm_vec2_zero(r.raw);
+  return r;
+}
+
+/*!
+ * @brief make vector one
+ *
+ * @returns one vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_one(void) {
+  vec2s r;
+  glm_vec2_one(r.raw);
+  return r;
+}
+
+/*!
+ * @brief vec2 dot product
+ *
+ * @param[in] a vector1
+ * @param[in] b vector2
+ *
+ * @return dot product
+ */
+CGLM_INLINE
+float
+glms_vec2_dot(vec2s a, vec2s b) {
+  return glm_vec2_dot(a.raw, b.raw);
+}
+
+/*!
+ * @brief vec2 cross product
+ *
+ * REF: http://allenchou.net/2013/07/cross-product-of-2d-vectors/
+ *
+ * @param[in]  a vector1
+ * @param[in]  b vector2
+ *
+ * @return Z component of cross product
+ */
+CGLM_INLINE
+float
+glms_vec2_cross(vec2s a, vec2s b) {
+  return glm_vec2_cross(a.raw, b.raw);
+}
+
+/*!
+ * @brief norm * norm (magnitude) of vec
+ *
+ * we can use this func instead of calling norm * norm, because it would call
+ * sqrtf fuction twice but with this func we can avoid func call, maybe this is
+ * not good name for this func
+ *
+ * @param[in] v vector
+ *
+ * @return norm * norm
+ */
+CGLM_INLINE
+float
+glms_vec2_norm2(vec2s v) {
+  return glm_vec2_norm2(v.raw);
+}
+
+/*!
+ * @brief norm (magnitude) of vec2
+ *
+ * @param[in] v vector
+ *
+ * @return norm
+ */
+CGLM_INLINE
+float
+glms_vec2_norm(vec2s v) {
+  return glm_vec2_norm(v.raw);
+}
+
+/*!
+ * @brief add a vector to b vector store result in dest
+ *
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_add(vec2s a, vec2s b) {
+  vec2s r;
+  glm_vec2_add(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief add scalar to v vector store result in dest (d = v + s)
+ *
+ * @param[in]  a    vector
+ * @param[in]  s    scalar
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_adds(vec2s a, float s) {
+  vec2s r;
+  glm_vec2_adds(a.raw, s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief subtract b vector from a vector store result in dest
+ *
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_sub(vec2s a, vec2s b) {
+  vec2s r;
+  glm_vec2_sub(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief subtract scalar from v vector store result in dest (d = v - s)
+ *
+ * @param[in]  a    vector
+ * @param[in]  s    scalar
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_subs(vec2s a, float s) {
+  vec2s r;
+  glm_vec2_subs(a.raw, s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief multiply two vector (component-wise multiplication)
+ *
+ * @param     a     vector1
+ * @param     b     vector2
+ * @returns         v3 = (a[0] * b[0], a[1] * b[1], a[2] * b[2])
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_mul(vec2s a, vec2s b) {
+  vec2s r;
+  glm_vec2_mul(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief multiply/scale vec2 vector with scalar: result = v * s
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_scale(vec2s v, float s) {
+  vec2s r;
+  glm_vec2_scale(v.raw, s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief make vec2 vector scale as specified: result = unit(v) * s
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_scale_as(vec2s v, float s) {
+  vec2s r;
+  glm_vec2_scale_as(v.raw, s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief div vector with another component-wise division: d = a / b
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @returns         result = (a[0]/b[0], a[1]/b[1], a[2]/b[2])
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_div(vec2s a, vec2s b) {
+  vec2s r;
+  glm_vec2_div(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief div vector with scalar: d = v / s
+ *
+ * @param[in]  a    vector
+ * @param[in]  s    scalar
+ * @returns         result = (a[0]/s, a[1]/s, a[2]/s)
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_divs(vec2s a, float s) {
+  vec2s r;
+  glm_vec2_divs(a.raw, s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief add two vectors and add result to sum
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @returns         dest += (a + b)
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_addadd(vec2s a, vec2s b, vec2s dest) {
+  glm_vec2_addadd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief sub two vectors and add result to dest
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @returns         dest += (a + b)
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_subadd(vec2s a, vec2s b, vec2s dest) {
+  glm_vec2_subadd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief mul two vectors and add result to dest
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @returns         dest += (a * b)
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_muladd(vec2s a, vec2s b, vec2s dest) {
+  glm_vec2_muladd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief mul vector with scalar and add result to sum
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector
+ * @param[in]  s    scalar
+ * @returns         dest += (a * b)
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_muladds(vec2s a, float s, vec2s dest) {
+  glm_vec2_muladds(a.raw, s, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief add max of two vector to result/dest
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @returns         dest += max(a, b)
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_maxadd(vec2s a, vec2s b, vec2s dest) {
+  glm_vec2_maxadd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief add min of two vector to result/dest
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @returns         dest += min(a, b)
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_minadd(vec2s a, vec2s b, vec2s dest) {
+  glm_vec2_minadd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief negate vector components
+ *
+ * @param[in]  v  vector
+ * @returns       negated vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_negate(vec2s v) {
+  glm_vec2_negate(v.raw);
+  return v;
+}
+
+/*!
+ * @brief normalize vec2 and store result in same vec
+ *
+ * @param[in] v vector
+ * @returns     normalized vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_normalize(vec2s v) {
+  glm_vec2_normalize(v.raw);
+  return v;
+}
+
+/*!
+ * @brief rotate vec2 by angle using Rodrigues' rotation formula
+ *
+ * @param[in]     v     vector
+ * @param[in]     angle angle by radians
+ * @returns             rotated vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_rotate(vec2s v, float angle) {
+  vec2s r;
+  glm_vec2_rotate(v.raw, angle, r.raw);
+  return r;
+}
+
+/**
+ * @brief distance between two vectors
+ *
+ * @param[in] a vector1
+ * @param[in] b vector2
+ * @return      distance
+ */
+CGLM_INLINE
+float
+glms_vec2_distance(vec2s a, vec2s b) {
+  return glm_vec2_distance(a.raw, b.raw);
+}
+
+/**
+ * @brief squared distance between two vectors
+ *
+ * @param[in] a vector1
+ * @param[in] b vector2
+ * @return      squared distance (distance * distance)
+ */
+CGLM_INLINE
+float
+glms_vec2_distance2(vec2s a, vec2s b) {
+  return glm_vec2_distance2(a.raw, b.raw);
+}
+
+/*!
+ * @brief max values of vectors
+ *
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
+ * @returns         destination
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_maxv(vec2s a, vec2s b) {
+  vec2s r;
+  glm_vec2_maxv(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief min values of vectors
+ *
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
+ * @returns         destination
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_minv(vec2s a, vec2s b) {
+  vec2s r;
+  glm_vec2_minv(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief clamp vector's individual members between min and max values
+ *
+ * @param[in]       v       vector
+ * @param[in]       minVal  minimum value
+ * @param[in]       maxVal  maximum value
+ * @returns                 clamped vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_clamp(vec2s v, float minVal, float maxVal) {
+  glm_vec2_clamp(v.raw, minVal, maxVal);
+  return v;
+}
+
+/*!
+ * @brief linear interpolation between two vectors
+ *
+ * formula:  from + s * (to - from)
+ *
+ * @param[in]   from  from value
+ * @param[in]   to    to value
+ * @param[in]   t     interpolant (amount)
+ * @returns           destination
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_lerp(vec2s from, vec2s to, float t) {
+  vec2s r;
+  glm_vec2_lerp(from.raw, to.raw, t, r.raw);
+  return r;
+}
+
+#endif /* cglms_vec2s_h */

include/cglm/types-struct.h

@@ -101,8 +101,19 @@ typedef union CGLM_ALIGN_IF(16) versors {
 #endif
 } versors;
 
+typedef union mat2s {
+  mat2  raw;
+  vec2s col[2];
+#if CGLM_USE_ANONYMOUS_STRUCT
+  struct {
+    float m00, m01;
+    float m10, m11;
+  };
+#endif
+} mat2s;
+
 typedef union mat3s {
-  mat3 raw;
+  mat3  raw;
   vec3s col[3];
 #if CGLM_USE_ANONYMOUS_STRUCT
   struct {
@@ -114,7 +125,7 @@ typedef union mat3s {
 } mat3s;
 
 typedef union CGLM_ALIGN_MAT mat4s {
-  mat4 raw;
+  mat4  raw;
   vec4s col[4];
 #if CGLM_USE_ANONYMOUS_STRUCT
   struct {

include/cglm/types.h

@@ -36,9 +36,15 @@ typedef float                   vec2[2];
 typedef float                   vec3[3];
 typedef int                    ivec3[3];
 typedef CGLM_ALIGN_IF(16) float vec4[4];
-typedef vec4                    versor;
+typedef vec4                    versor;     /* |x, y, z, w| -> w is the last */
 typedef vec3                    mat3[3];
-typedef CGLM_ALIGN_MAT vec4     mat4[4];
+typedef CGLM_ALIGN_IF(16) vec2  mat2[2];
+typedef CGLM_ALIGN_MAT    vec4  mat4[4];
+
+/*
+  Important: cglm stores quaternion as [x, y, z, w] in memory since v0.4.0 
+  it was [w, x, y, z] before v0.4.0 ( v0.3.5 and earlier ). w is real part.
+*/
 
 #define GLM_E         2.71828182845904523536028747135266250   /* e           */
 #define GLM_LOG2E     1.44269504088896340735992468100189214   /* log2(e)     */

include/cglm/util.h

@@ -322,7 +322,22 @@ glm_percent(float from, float to, float current) {
 CGLM_INLINE
 float
 glm_percentc(float from, float to, float current) {
-  return glm_clamp(glm_percent(from, to, current), 0.0f, 1.0f);
+  return glm_clamp_zo(glm_percent(from, to, current));
+}
+
+/*!
+* @brief swap two float values
+*
+* @param[in]   a float value 1 (pointer)
+* @param[in]   b float value 2 (pointer)
+*/
+CGLM_INLINE
+void
+glm_swapf(float * __restrict a, float * __restrict b) {
+  float t;
+  t  = *a;
+  *a = *b;
+  *b = t;
 }
 
 #endif /* cglm_util_h */

include/cglm/vec2-ext.h

@@ -0,0 +1,189 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE void  glm_vec2_fill(vec2 v, float val)
+   CGLM_INLINE bool  glm_vec2_eq(vec2 v, float val);
+   CGLM_INLINE bool  glm_vec2_eq_eps(vec2 v, float val);
+   CGLM_INLINE bool  glm_vec2_eq_all(vec2 v);
+   CGLM_INLINE bool  glm_vec2_eqv(vec2 a, vec2 b);
+   CGLM_INLINE bool  glm_vec2_eqv_eps(vec2 a, vec2 b);
+   CGLM_INLINE float glm_vec2_max(vec2 v);
+   CGLM_INLINE float glm_vec2_min(vec2 v);
+   CGLM_INLINE bool  glm_vec2_isnan(vec2 v);
+   CGLM_INLINE bool  glm_vec2_isinf(vec2 v);
+   CGLM_INLINE bool  glm_vec2_isvalid(vec2 v);
+   CGLM_INLINE void  glm_vec2_sign(vec2 v, vec2 dest);
+   CGLM_INLINE void  glm_vec2_sqrt(vec2 v, vec2 dest);
+ */
+
+#ifndef cglm_vec2_ext_h
+#define cglm_vec2_ext_h
+
+#include "common.h"
+#include "util.h"
+
+/*!
+ * @brief fill a vector with specified value
+ *
+ * @param[out] v   dest
+ * @param[in]  val value
+ */
+CGLM_INLINE
+void
+glm_vec2_fill(vec2 v, float val) {
+  v[0] = v[1] = val;
+}
+
+/*!
+ * @brief check if vector is equal to value (without epsilon)
+ *
+ * @param[in] v   vector
+ * @param[in] val value
+ */
+CGLM_INLINE
+bool
+glm_vec2_eq(vec2 v, float val) {
+  return v[0] == val && v[0] == v[1];
+}
+
+/*!
+ * @brief check if vector is equal to value (with epsilon)
+ *
+ * @param[in] v   vector
+ * @param[in] val value
+ */
+CGLM_INLINE
+bool
+glm_vec2_eq_eps(vec2 v, float val) {
+  return fabsf(v[0] - val) <= FLT_EPSILON
+         && fabsf(v[1] - val) <= FLT_EPSILON;
+}
+
+/*!
+ * @brief check if vectors members are equal (without epsilon)
+ *
+ * @param[in] v   vector
+ */
+CGLM_INLINE
+bool
+glm_vec2_eq_all(vec2 v) {
+  return v[0] == v[1];
+}
+
+/*!
+ * @brief check if vector is equal to another (without epsilon)
+ *
+ * @param[in] a vector
+ * @param[in] b vector
+ */
+CGLM_INLINE
+bool
+glm_vec2_eqv(vec2 a, vec2 b) {
+  return a[0] == b[0] && a[1] == b[1];
+}
+
+/*!
+ * @brief check if vector is equal to another (with epsilon)
+ *
+ * @param[in] a vector
+ * @param[in] b vector
+ */
+CGLM_INLINE
+bool
+glm_vec2_eqv_eps(vec2 a, vec2 b) {
+  return fabsf(a[0] - b[0]) <= FLT_EPSILON
+         && fabsf(a[1] - b[1]) <= FLT_EPSILON;
+}
+
+/*!
+ * @brief max value of vector
+ *
+ * @param[in] v vector
+ */
+CGLM_INLINE
+float
+glm_vec2_max(vec2 v) {
+  return glm_max(v[0], v[1]);
+}
+
+/*!
+ * @brief min value of vector
+ *
+ * @param[in] v vector
+ */
+CGLM_INLINE
+float
+glm_vec2_min(vec2 v) {
+  return glm_min(v[0], v[1]);
+}
+
+/*!
+ * @brief check if all items are NaN (not a number)
+ *        you should only use this in DEBUG mode or very critical asserts
+ *
+ * @param[in] v vector
+ */
+CGLM_INLINE
+bool
+glm_vec2_isnan(vec2 v) {
+  return isnan(v[0]) || isnan(v[1]);
+}
+
+/*!
+ * @brief check if all items are INFINITY
+ *        you should only use this in DEBUG mode or very critical asserts
+ *
+ * @param[in] v vector
+ */
+CGLM_INLINE
+bool
+glm_vec2_isinf(vec2 v) {
+  return isinf(v[0]) || isinf(v[1]);
+}
+
+/*!
+ * @brief check if all items are valid number
+ *        you should only use this in DEBUG mode or very critical asserts
+ *
+ * @param[in] v vector
+ */
+CGLM_INLINE
+bool
+glm_vec2_isvalid(vec2 v) {
+  return !glm_vec2_isnan(v) && !glm_vec2_isinf(v);
+}
+
+/*!
+ * @brief get sign of 32 bit float as +1, -1, 0
+ *
+ * Important: It returns 0 for zero/NaN input
+ *
+ * @param v vector
+ */
+CGLM_INLINE
+void
+glm_vec2_sign(vec2 v, vec2 dest) {
+  dest[0] = glm_signf(v[0]);
+  dest[1] = glm_signf(v[1]);
+}
+
+/*!
+ * @brief square root of each vector item
+ *
+ * @param[in]  v    vector
+ * @param[out] dest destination vector
+ */
+CGLM_INLINE
+void
+glm_vec2_sqrt(vec2 v, vec2 dest) {
+  dest[0] = sqrtf(v[0]);
+  dest[1] = sqrtf(v[1]);
+}
+
+#endif /* cglm_vec2_ext_h */

include/cglm/vec2.h

@@ -0,0 +1,585 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Macros:
+   GLM_VEC2_ONE_INIT
+   GLM_VEC2_ZERO_INIT
+   GLM_VEC2_ONE
+   GLM_VEC2_ZERO
+
+ Functions:
+   CGLM_INLINE void  glm_vec2(float * __restrict v, vec2 dest)
+   CGLM_INLINE void  glm_vec2_copy(vec2 a, vec2 dest)
+   CGLM_INLINE void  glm_vec2_zero(vec2 v)
+   CGLM_INLINE void  glm_vec2_one(vec2 v)
+   CGLM_INLINE float glm_vec2_dot(vec2 a, vec2 b)
+   CGLM_INLINE float glm_vec2_cross(vec2 a, vec2 b)
+   CGLM_INLINE float glm_vec2_norm2(vec2 v)
+   CGLM_INLINE float glm_vec2_norm(vec2 vec)
+   CGLM_INLINE void  glm_vec2_add(vec2 a, vec2 b, vec2 dest)
+   CGLM_INLINE void  glm_vec2_adds(vec2 v, float s, vec2 dest)
+   CGLM_INLINE void  glm_vec2_sub(vec2 a, vec2 b, vec2 dest)
+   CGLM_INLINE void  glm_vec2_subs(vec2 v, float s, vec2 dest)
+   CGLM_INLINE void  glm_vec2_mul(vec2 a, vec2 b, vec2 d)
+   CGLM_INLINE void  glm_vec2_scale(vec2 v, float s, vec2 dest)
+   CGLM_INLINE void  glm_vec2_scale_as(vec2 v, float s, vec2 dest)
+   CGLM_INLINE void  glm_vec2_div(vec2 a, vec2 b, vec2 dest)
+   CGLM_INLINE void  glm_vec2_divs(vec2 v, float s, vec2 dest)
+   CGLM_INLINE void  glm_vec2_addadd(vec2 a, vec2 b, vec2 dest)
+   CGLM_INLINE void  glm_vec2_subadd(vec2 a, vec2 b, vec2 dest)
+   CGLM_INLINE void  glm_vec2_muladd(vec2 a, vec2 b, vec2 dest)
+   CGLM_INLINE void  glm_vec2_muladds(vec2 a, float s, vec2 dest)
+   CGLM_INLINE void  glm_vec2_maxadd(vec2 a, vec2 b, vec2 dest)
+   CGLM_INLINE void  glm_vec2_minadd(vec2 a, vec2 b, vec2 dest)
+   CGLM_INLINE void  glm_vec2_negate_to(vec2 v, vec2 dest)
+   CGLM_INLINE void  glm_vec2_negate(vec2 v)
+   CGLM_INLINE void  glm_vec2_normalize(vec2 v)
+   CGLM_INLINE void  glm_vec2_normalize_to(vec2 vec, vec2 dest)
+   CGLM_INLINE void  glm_vec2_rotate(vec2 v, float angle, vec2 dest)
+   CGLM_INLINE float glm_vec2_distance2(vec2 a, vec2 b)
+   CGLM_INLINE float glm_vec2_distance(vec2 a, vec2 b)
+   CGLM_INLINE void  glm_vec2_maxv(vec2 v1, vec2 v2, vec2 dest)
+   CGLM_INLINE void  glm_vec2_minv(vec2 v1, vec2 v2, vec2 dest)
+   CGLM_INLINE void  glm_vec2_clamp(vec2 v, float minVal, float maxVal)
+   CGLM_INLINE void  glm_vec2_lerp(vec2 from, vec2 to, float t, vec2 dest)
+
+ */
+
+#ifndef cglm_vec2_h
+#define cglm_vec2_h
+
+#include "common.h"
+#include "util.h"
+#include "vec2-ext.h"
+
+#define GLM_VEC2_ONE_INIT   {1.0f, 1.0f}
+#define GLM_VEC2_ZERO_INIT  {0.0f, 0.0f}
+
+#define GLM_VEC2_ONE  ((vec2)GLM_VEC2_ONE_INIT)
+#define GLM_VEC2_ZERO ((vec2)GLM_VEC2_ZERO_INIT)
+
+/*!
+ * @brief init vec2 using another vector
+ *
+ * @param[in]  v    a vector
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_vec2(float * __restrict v, vec2 dest) {
+  dest[0] = v[0];
+  dest[1] = v[1];
+}
+
+/*!
+ * @brief copy all members of [a] to [dest]
+ *
+ * @param[in]  a    source
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_vec2_copy(vec2 a, vec2 dest) {
+  dest[0] = a[0];
+  dest[1] = a[1];
+}
+
+/*!
+ * @brief make vector zero
+ *
+ * @param[in, out]  v vector
+ */
+CGLM_INLINE
+void
+glm_vec2_zero(vec2 v) {
+  v[0] = v[1] = 0.0f;
+}
+
+/*!
+ * @brief make vector one
+ *
+ * @param[in, out]  v vector
+ */
+CGLM_INLINE
+void
+glm_vec2_one(vec2 v) {
+  v[0] = v[1] = 1.0f;
+}
+
+/*!
+ * @brief vec2 dot product
+ *
+ * @param[in] a vector1
+ * @param[in] b vector2
+ *
+ * @return dot product
+ */
+CGLM_INLINE
+float
+glm_vec2_dot(vec2 a, vec2 b) {
+  return a[0] * b[0] + a[1] * b[1];
+}
+
+/*!
+ * @brief vec2 cross product
+ *
+ * REF: http://allenchou.net/2013/07/cross-product-of-2d-vectors/
+ *
+ * @param[in]  a vector1
+ * @param[in]  b vector2
+ *
+ * @return Z component of cross product
+ */
+CGLM_INLINE
+float
+glm_vec2_cross(vec2 a, vec2 b) {
+  /* just calculate the z-component */
+  return a[0] * b[1] - a[1] * b[0];
+}
+
+/*!
+ * @brief norm * norm (magnitude) of vec
+ *
+ * we can use this func instead of calling norm * norm, because it would call
+ * sqrtf fuction twice but with this func we can avoid func call, maybe this is
+ * not good name for this func
+ *
+ * @param[in] v vector
+ *
+ * @return norm * norm
+ */
+CGLM_INLINE
+float
+glm_vec2_norm2(vec2 v) {
+  return glm_vec2_dot(v, v);
+}
+
+/*!
+ * @brief norm (magnitude) of vec2
+ *
+ * @param[in] vec vector
+ *
+ * @return norm
+ */
+CGLM_INLINE
+float
+glm_vec2_norm(vec2 vec) {
+  return sqrtf(glm_vec2_norm2(vec));
+}
+
+/*!
+ * @brief add a vector to b vector store result in dest
+ *
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
+ * @param[out] dest destination vector
+ */
+CGLM_INLINE
+void
+glm_vec2_add(vec2 a, vec2 b, vec2 dest) {
+  dest[0] = a[0] + b[0];
+  dest[1] = a[1] + b[1];
+}
+
+/*!
+ * @brief add scalar to v vector store result in dest (d = v + s)
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @param[out] dest destination vector
+ */
+CGLM_INLINE
+void
+glm_vec2_adds(vec2 v, float s, vec2 dest) {
+  dest[0] = v[0] + s;
+  dest[1] = v[1] + s;
+}
+
+/*!
+ * @brief subtract b vector from a vector store result in dest
+ *
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
+ * @param[out] dest destination vector
+ */
+CGLM_INLINE
+void
+glm_vec2_sub(vec2 a, vec2 b, vec2 dest) {
+  dest[0] = a[0] - b[0];
+  dest[1] = a[1] - b[1];
+}
+
+/*!
+ * @brief subtract scalar from v vector store result in dest (d = v - s)
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @param[out] dest destination vector
+ */
+CGLM_INLINE
+void
+glm_vec2_subs(vec2 v, float s, vec2 dest) {
+  dest[0] = v[0] - s;
+  dest[1] = v[1] - s;
+}
+
+/*!
+ * @brief multiply two vector (component-wise multiplication)
+ *
+ * @param a    v1
+ * @param b    v2
+ * @param dest v3 = (a[0] * b[0], a[1] * b[1])
+ */
+CGLM_INLINE
+void
+glm_vec2_mul(vec2 a, vec2 b, vec2 dest) {
+  dest[0] = a[0] * b[0];
+  dest[1] = a[1] * b[1];
+}
+
+/*!
+ * @brief multiply/scale vector with scalar: result = v * s
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @param[out] dest destination vector
+ */
+CGLM_INLINE
+void
+glm_vec2_scale(vec2 v, float s, vec2 dest) {
+  dest[0] = v[0] * s;
+  dest[1] = v[1] * s;
+}
+
+/*!
+ * @brief scale as vector specified: result = unit(v) * s
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @param[out] dest destination vector
+ */
+CGLM_INLINE
+void
+glm_vec2_scale_as(vec2 v, float s, vec2 dest) {
+  float norm;
+  norm = glm_vec2_norm(v);
+
+  if (norm == 0.0f) {
+    glm_vec2_zero(dest);
+    return;
+  }
+
+  glm_vec2_scale(v, s / norm, dest);
+}
+
+/*!
+ * @brief div vector with another component-wise division: d = a / b
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @param[out] dest result = (a[0]/b[0], a[1]/b[1])
+ */
+CGLM_INLINE
+void
+glm_vec2_div(vec2 a, vec2 b, vec2 dest) {
+  dest[0] = a[0] / b[0];
+  dest[1] = a[1] / b[1];
+}
+
+/*!
+ * @brief div vector with scalar: d = v / s
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @param[out] dest result = (a[0]/s, a[1]/s)
+ */
+CGLM_INLINE
+void
+glm_vec2_divs(vec2 v, float s, vec2 dest) {
+  dest[0] = v[0] / s;
+  dest[1] = v[1] / s;
+}
+
+/*!
+ * @brief add two vectors and add result to sum
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @param[out] dest dest += (a + b)
+ */
+CGLM_INLINE
+void
+glm_vec2_addadd(vec2 a, vec2 b, vec2 dest) {
+  dest[0] += a[0] + b[0];
+  dest[1] += a[1] + b[1];
+}
+
+/*!
+ * @brief sub two vectors and add result to dest
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @param[out] dest dest += (a + b)
+ */
+CGLM_INLINE
+void
+glm_vec2_subadd(vec2 a, vec2 b, vec2 dest) {
+  dest[0] += a[0] - b[0];
+  dest[1] += a[1] - b[1];
+}
+
+/*!
+ * @brief mul two vectors and add result to dest
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @param[out] dest dest += (a * b)
+ */
+CGLM_INLINE
+void
+glm_vec2_muladd(vec2 a, vec2 b, vec2 dest) {
+  dest[0] += a[0] * b[0];
+  dest[1] += a[1] * b[1];
+}
+
+/*!
+ * @brief mul vector with scalar and add result to sum
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector
+ * @param[in]  s    scalar
+ * @param[out] dest dest += (a * b)
+ */
+CGLM_INLINE
+void
+glm_vec2_muladds(vec2 a, float s, vec2 dest) {
+  dest[0] += a[0] * s;
+  dest[1] += a[1] * s;
+}
+
+/*!
+ * @brief add max of two vector to result/dest
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @param[out] dest dest += max(a, b)
+ */
+CGLM_INLINE
+void
+glm_vec2_maxadd(vec2 a, vec2 b, vec2 dest) {
+  dest[0] += glm_max(a[0], b[0]);
+  dest[1] += glm_max(a[1], b[1]);
+}
+
+/*!
+ * @brief add min of two vector to result/dest
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @param[out] dest dest += min(a, b)
+ */
+CGLM_INLINE
+void
+glm_vec2_minadd(vec2 a, vec2 b, vec2 dest) {
+  dest[0] += glm_min(a[0], b[0]);
+  dest[1] += glm_min(a[1], b[1]);
+}
+
+/*!
+ * @brief negate vector components and store result in dest
+ *
+ * @param[in]   v     vector
+ * @param[out]  dest  result vector
+ */
+CGLM_INLINE
+void
+glm_vec2_negate_to(vec2 v, vec2 dest) {
+  dest[0] = -v[0];
+  dest[1] = -v[1];
+}
+
+/*!
+ * @brief negate vector components
+ *
+ * @param[in, out]  v  vector
+ */
+CGLM_INLINE
+void
+glm_vec2_negate(vec2 v) {
+  glm_vec2_negate_to(v, v);
+}
+
+/*!
+ * @brief normalize vector and store result in same vec
+ *
+ * @param[in, out] v vector
+ */
+CGLM_INLINE
+void
+glm_vec2_normalize(vec2 v) {
+  float norm;
+
+  norm = glm_vec2_norm(v);
+
+  if (norm == 0.0f) {
+    v[0] = v[1] = 0.0f;
+    return;
+  }
+
+  glm_vec2_scale(v, 1.0f / norm, v);
+}
+
+/*!
+ * @brief normalize vector to dest
+ *
+ * @param[in]  v    source
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_vec2_normalize_to(vec2 v, vec2 dest) {
+  float norm;
+
+  norm = glm_vec2_norm(v);
+
+  if (norm == 0.0f) {
+    glm_vec2_zero(dest);
+    return;
+  }
+
+  glm_vec2_scale(v, 1.0f / norm, dest);
+}
+
+/*!
+ * @brief rotate vec2 around origin by angle (CCW: counterclockwise)
+ *
+ * Formula:
+ *   𝑥2 = cos(a)𝑥1 − sin(a)𝑦1
+ *   𝑦2 = sin(a)𝑥1 + cos(a)𝑦1
+ *
+ * @param[in]  v     vector to rotate
+ * @param[in]  angle angle by radians
+ * @param[out] dest  destination vector
+ */
+CGLM_INLINE
+void
+glm_vec2_rotate(vec2 v, float angle, vec2 dest) {
+  float c, s, x1, y1;
+
+  c  = cosf(angle);
+  s  = sinf(angle);
+
+  x1 = v[0];
+  y1 = v[1];
+
+  dest[0] = c * x1 - s * y1;
+  dest[1] = s * x1 + c * y1;
+}
+
+/**
+ * @brief squared distance between two vectors
+ *
+ * @param[in] a vector1
+ * @param[in] b vector2
+ * @return returns squared distance (distance * distance)
+ */
+CGLM_INLINE
+float
+glm_vec2_distance2(vec2 a, vec2 b) {
+  return glm_pow2(b[0] - a[0]) + glm_pow2(b[1] - a[1]);
+}
+
+/**
+ * @brief distance between two vectors
+ *
+ * @param[in] a vector1
+ * @param[in] b vector2
+ * @return returns distance
+ */
+CGLM_INLINE
+float
+glm_vec2_distance(vec2 a, vec2 b) {
+  return sqrtf(glm_vec2_distance2(a, b));
+}
+
+/*!
+ * @brief max values of vectors
+ *
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_vec2_maxv(vec2 a, vec2 b, vec2 dest) {
+  dest[0] = glm_max(a[0], b[0]);
+  dest[1] = glm_max(a[1], b[1]);
+}
+
+/*!
+ * @brief min values of vectors
+ *
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
+ * @param[out] dest destination
+ */
+CGLM_INLINE
+void
+glm_vec2_minv(vec2 a, vec2 b, vec2 dest) {
+  dest[0] = glm_min(a[0], b[0]);
+  dest[1] = glm_min(a[1], b[1]);
+}
+
+/*!
+ * @brief clamp vector's individual members between min and max values
+ *
+ * @param[in, out]  v      vector
+ * @param[in]       minval minimum value
+ * @param[in]       maxval maximum value
+ */
+CGLM_INLINE
+void
+glm_vec2_clamp(vec2 v, float minval, float maxval) {
+  v[0] = glm_clamp(v[0], minval, maxval);
+  v[1] = glm_clamp(v[1], minval, maxval);
+}
+
+/*!
+ * @brief linear interpolation between two vector
+ *
+ * formula:  from + s * (to - from)
+ *
+ * @param[in]   from from value
+ * @param[in]   to   to value
+ * @param[in]   t    interpolant (amount) clamped between 0 and 1
+ * @param[out]  dest destination
+ */
+CGLM_INLINE
+void
+glm_vec2_lerp(vec2 from, vec2 to, float t, vec2 dest) {
+  vec2 s, v;
+
+  /* from + s * (to - from) */
+  glm_vec2_fill(s, glm_clamp_zo(t));
+  glm_vec2_sub(to, from, v);
+  glm_vec2_mul(s, v, v);
+  glm_vec2_add(from, v, dest);
+}
+
+#endif /* cglm_vec2_h */

include/cglm/vec3.h

@@ -111,9 +111,10 @@
 #define GLM_VEC3_ONE  ((vec3)GLM_VEC3_ONE_INIT)
 #define GLM_VEC3_ZERO ((vec3)GLM_VEC3_ZERO_INIT)
 
-#define GLM_YUP  ((vec3){0.0f, 1.0f, 0.0f})
+#define GLM_YUP       ((vec3){0.0f,  1.0f,  0.0f})
-#define GLM_ZUP  ((vec3){0.0f, 0.0f, 1.0f})
+#define GLM_ZUP       ((vec3){0.0f,  0.0f,  1.0f})
-#define GLM_XUP  ((vec3){1.0f, 0.0f, 0.0f})
+#define GLM_XUP       ((vec3){1.0f,  0.0f,  0.0f})
+#define GLM_FORWARD   ((vec3){0.0f,  0.0f, -1.0f})
 
 #define GLM_XXX GLM_SHUFFLE3(0, 0, 0)
 #define GLM_YYY GLM_SHUFFLE3(1, 1, 1)

include/cglm/version.h

@@ -9,7 +9,7 @@
 #define cglm_version_h
 
 #define CGLM_VERSION_MAJOR 0
-#define CGLM_VERSION_MINOR 6
+#define CGLM_VERSION_MINOR 7
 #define CGLM_VERSION_PATCH 2
 
 #endif /* cglm_version_h */

src/mat2.c

@@ -0,0 +1,99 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "../include/cglm/cglm.h"
+#include "../include/cglm/call.h"
+
+CGLM_EXPORT
+void
+glmc_mat2_copy(mat2 mat, mat2 dest) {
+  glm_mat2_copy(mat, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat2_identity(mat2 mat) {
+  glm_mat2_identity(mat);
+}
+
+CGLM_EXPORT
+void
+glmc_mat2_identity_array(mat2 * __restrict mat, size_t count) {
+  glm_mat2_identity_array(mat, count);
+}
+
+CGLM_EXPORT
+void
+glmc_mat2_zero(mat2 mat) {
+  glm_mat2_zero(mat);
+}
+
+CGLM_EXPORT
+void
+glmc_mat2_mul(mat2 m1, mat2 m2, mat2 dest) {
+  glm_mat2_mul(m1, m2, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat2_transpose_to(mat2 m, mat2 dest) {
+  glm_mat2_transpose_to(m, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat2_transpose(mat2 m) {
+  glm_mat2_transpose(m);
+}
+
+CGLM_EXPORT
+void
+glmc_mat2_mulv(mat2 m, vec2 v, vec2 dest) {
+  glm_mat2_mulv(m, v, dest);
+}
+
+CGLM_EXPORT
+float
+glmc_mat2_trace(mat2 m) {
+  return glm_mat2_trace(m);
+}
+
+CGLM_EXPORT
+void
+glmc_mat2_scale(mat2 m, float s) {
+  glm_mat2_scale(m, s);
+}
+
+CGLM_EXPORT
+float
+glmc_mat2_det(mat2 mat) {
+  return glm_mat2_det(mat);
+}
+
+CGLM_EXPORT
+void
+glmc_mat2_inv(mat2 mat, mat2 dest) {
+  glm_mat2_inv(mat, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_mat2_swap_col(mat2 mat, int col1, int col2) {
+  glm_mat2_swap_col(mat, col1, col2);
+}
+
+CGLM_EXPORT
+void
+glmc_mat2_swap_row(mat2 mat, int row1, int row2) {
+  glm_mat2_swap_row(mat, row1, row2);
+}
+
+CGLM_EXPORT
+float
+glmc_mat2_rmc(vec2 r, mat2 m, vec2 c) {
+  return glm_mat2_rmc(r, m, c);
+}

src/quat.c

@@ -184,14 +184,14 @@ glmc_quat_look(vec3 eye, versor ori, mat4 dest) {
 
 CGLM_EXPORT
 void
-glmc_quat_for(vec3 dir, vec3 fwd, vec3 up, versor dest) {
+glmc_quat_for(vec3 dir, vec3 up, versor dest) {
-  glm_quat_for(dir, fwd, up, dest);
+  glm_quat_for(dir, up, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_quat_forp(vec3 from, vec3 to, vec3 fwd, vec3 up, versor dest) {
+glmc_quat_forp(vec3 from, vec3 to, vec3 up, versor dest) {
-  glm_quat_forp(from, to, fwd, up, dest);
+  glm_quat_forp(from, to, up, dest);
 }
 
 CGLM_EXPORT

src/ray.c

@@ -0,0 +1,13 @@
+#include "../include/cglm/cglm.h"
+#include "../include/cglm/call.h"
+
+CGLM_EXPORT
+bool
+glmc_ray_triangle(vec3   origin,
+                  vec3   direction,
+                  vec3   v0,
+                  vec3   v1,
+                  vec3   v2,
+                  float *d) {
+    return glm_ray_triangle(origin, direction, v0, v1, v2, d);
+}

src/vec2.c

@@ -0,0 +1,213 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "../include/cglm/cglm.h"
+#include "../include/cglm/call.h"
+
+CGLM_EXPORT
+void
+glmc_vec2(float * __restrict v, vec2 dest) {
+  glm_vec2(v, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_copy(vec2 a, vec2 dest) {
+  glm_vec2_copy(a, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_zero(vec2 v) {
+  glm_vec2_zero(v);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_one(vec2 v) {
+  glm_vec2_one(v);
+}
+
+CGLM_EXPORT
+float
+glmc_vec2_dot(vec2 a, vec2 b) {
+  return glm_vec2_dot(a, b);
+}
+
+CGLM_EXPORT
+float
+glmc_vec2_cross(vec2 a, vec2 b) {
+  return glm_vec2_cross(a, b);
+}
+
+CGLM_EXPORT
+float
+glmc_vec2_norm2(vec2 v) {
+  return glm_vec2_norm2(v);
+}
+
+CGLM_EXPORT
+float
+glmc_vec2_norm(vec2 v) {
+  return glm_vec2_norm(v);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_add(vec2 a, vec2 b, vec2 dest) {
+  glm_vec2_add(a, b, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_adds(vec2 v, float s, vec2 dest) {
+  glm_vec2_adds(v, s, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_sub(vec2 a, vec2 b, vec2 dest) {
+  glm_vec2_sub(a, b, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_subs(vec2 v, float s, vec2 dest) {
+  glm_vec2_subs(v, s, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_mul(vec2 a, vec2 b, vec2 dest) {
+  glm_vec2_mul(a, b, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_scale(vec2 v, float s, vec2 dest) {
+  glm_vec2_scale(v, s, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_scale_as(vec2 v, float s, vec2 dest) {
+  glm_vec2_scale_as(v, s, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_div(vec2 a, vec2 b, vec2 dest) {
+  glm_vec2_div(a, b, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_divs(vec2 v, float s, vec2 dest) {
+  glm_vec2_divs(v, s, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_addadd(vec2 a, vec2 b, vec2 dest) {
+  glm_vec2_addadd(a, b, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_subadd(vec2 a, vec2 b, vec2 dest) {
+  glm_vec2_subadd(a, b, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_muladd(vec2 a, vec2 b, vec2 dest) {
+  glm_vec2_muladd(a, b, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_muladds(vec2 a, float s, vec2 dest) {
+  glm_vec2_muladds(a, s, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_maxadd(vec2 a, vec2 b, vec2 dest) {
+  glm_vec2_maxadd(a, b, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_minadd(vec2 a, vec2 b, vec2 dest) {
+  glm_vec2_minadd(a, b, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_negate_to(vec2 v, vec2 dest) {
+  glm_vec2_negate_to(v, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_negate(vec2 v) {
+  glm_vec2_negate(v);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_normalize(vec2 v) {
+  glm_vec2_normalize(v);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_normalize_to(vec2 v, vec2 dest) {
+  glm_vec2_normalize_to(v, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_rotate(vec2 v, float angle, vec2 dest) {
+  glm_vec2_rotate(v, angle, dest);
+}
+
+CGLM_EXPORT
+float
+glmc_vec2_distance2(vec2 a, vec2 b) {
+  return glm_vec2_distance2(a, b);
+}
+
+CGLM_EXPORT
+float
+glmc_vec2_distance(vec2 a, vec2 b) {
+  return glm_vec2_distance(a, b);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_maxv(vec2 a, vec2 b, vec2 dest) {
+  glm_vec2_maxv(a, b, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_minv(vec2 a, vec2 b, vec2 dest) {
+  glm_vec2_minv(a, b, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_clamp(vec2 v, float minval, float maxval) {
+  glm_vec2_clamp(v, minval, maxval);
+}
+
+CGLM_EXPORT
+void
+glmc_vec2_lerp(vec2 from, vec2 to, float t, vec2 dest) {
+  glm_vec2_lerp(from, to, t, dest);
+}

test/CMakeLists.txt

@@ -0,0 +1,39 @@
+cmake_minimum_required(VERSION 3.8.2)
+
+# List all files containing tests. (Change as needed)
+set(TESTFILES
+  runner.c
+  src/test_euler.c
+  src/test_bezier.c
+  src/test_cam.c
+  src/test_struct.c
+  src/test_clamp.c
+  src/test_common.c
+  src/tests.c
+  )
+
+set(TEST_MAIN tests)
+set(TEST_RUNNER_PARAMS "")
+
+add_executable(${TEST_MAIN} ${TESTFILES})
+
+target_link_libraries(${TEST_MAIN} PRIVATE cglm m)
+target_include_directories(${TEST_MAIN} PRIVATE
+  ${CMAKE_CURRENT_LIST_DIR}/include
+  ${CMAKE_CURRENT_LIST_DIR}/src
+  )
+
+set_target_properties(${TEST_MAIN} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR})
+
+if(LDFLAGS)
+  target_compile_options(${TEST_MAIN} PRIVATE ${LDFLAGS})
+endif()
+
+add_test(
+    NAME cglm.${TEST_MAIN}
+    COMMAND ${TEST_MAIN} ${TEST_RUNNER_PARAMS})
+
+add_custom_target(check
+  make
+  COMMAND ${CMAKE_CTEST_COMMAND} -V
+  DEPENDS cglm)

test/src/test_affine.c

@@ -1,114 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#include "test_common.h"
-
-TEST_IMPL(affine) {
-  mat4 t1, t2, t3, t4, t5;
-
-  /* test translate is postmultiplied */
-  glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP);
-  glm_translate_make(t2, (vec3){34, 57, 36});
-
-  glmc_mat4_mul(t1, t2, t3); /* R * T */
-
-  glm_translate(t1, (vec3){34, 57, 36});
-  ASSERTIFY(test_assert_mat4_eq(t1, t3))
-
-  /* test rotate is postmultiplied */
-  glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP);
-  glm_translate_make(t2, (vec3){34, 57, 36});
-
-  glmc_mat4_mul(t2, t1, t3); /* T * R */
-
-  glm_rotate(t2, GLM_PI_4f, GLM_YUP);
-  ASSERTIFY(test_assert_mat4_eq(t2, t3))
-
-  /* test scale is postmultiplied */
-  glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP);
-  glm_translate_make(t2, (vec3){34, 57, 36});
-  glm_scale_make(t4, (vec3){3, 5, 6});
-
-  glmc_mat4_mul(t2, t1, t3); /* T * R */
-  glmc_mat4_mul(t3, t4, t5); /* T * R * S */
-
-  glm_scale(t3, (vec3){3, 5, 6});
-  ASSERTIFY(test_assert_mat4_eq(t3, t5))
-
-  /* test translate_x */
-  glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP);
-  glm_translate_make(t2, (vec3){34, 0, 0});
-
-  glmc_mat4_mul(t1, t2, t3); /* R * T */
-  glm_translate_x(t1, 34);
-  ASSERTIFY(test_assert_mat4_eq(t1, t3))
-
-  /* test translate_y */
-  glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP);
-  glm_translate_make(t2, (vec3){0, 57, 0});
-
-  glmc_mat4_mul(t1, t2, t3); /* R * T */
-  glm_translate_y(t1, 57);
-  ASSERTIFY(test_assert_mat4_eq(t1, t3))
-
-  /* test translate_z */
-  glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP);
-  glm_translate_make(t2, (vec3){0, 0, 36});
-
-  glmc_mat4_mul(t1, t2, t3); /* R * T */
-  glm_translate_z(t1, 36);
-  ASSERTIFY(test_assert_mat4_eq(t1, t3))
-
-  /* test rotate_x */
-  glmc_rotate_make(t1, GLM_PI_4f, (vec3){1, 0, 0});
-  glm_translate_make(t2, (vec3){34, 57, 36});
-
-  glmc_mat4_mul(t2, t1, t3); /* T * R */
-
-  glm_rotate_x(t2, GLM_PI_4f, t2);
-  ASSERTIFY(test_assert_mat4_eq(t2, t3))
-
-  /* test rotate_y */
-  glmc_rotate_make(t1, GLM_PI_4f, (vec3){0, 1, 0});
-  glm_translate_make(t2, (vec3){34, 57, 36});
-
-  glmc_mat4_mul(t2, t1, t3); /* T * R */
-
-  glm_rotate_y(t2, GLM_PI_4f, t2);
-  ASSERTIFY(test_assert_mat4_eq(t2, t3))
-
-  /* test rotate_z */
-  glmc_rotate_make(t1, GLM_PI_4f, (vec3){0, 0, 1});
-  glm_translate_make(t2, (vec3){34, 57, 36});
-
-  glmc_mat4_mul(t2, t1, t3); /* T * R */
-
-  glm_rotate_z(t2, GLM_PI_4f, t2);
-  ASSERTIFY(test_assert_mat4_eq(t2, t3))
-
-  /* test rotate */
-  glmc_rotate_make(t1, GLM_PI_4f, (vec3){0, 0, 1});
-  glm_translate_make(t2, (vec3){34, 57, 36});
-
-  glmc_mat4_mul(t2, t1, t3); /* T * R */
-  glmc_rotate(t2, GLM_PI_4f, (vec3){0, 0, 1});
-
-  ASSERTIFY(test_assert_mat4_eq(t3, t2))
-
-  /* test scale_uni */
-  glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP);
-  glm_translate_make(t2, (vec3){34, 57, 36});
-  glm_scale_make(t4, (vec3){3, 3, 3});
-
-  glmc_mat4_mul(t2, t1, t3); /* T * R */
-  glmc_mat4_mul(t3, t4, t5); /* T * R * S */
-
-  glm_scale_uni(t3, 3);
-  ASSERTIFY(test_assert_mat4_eq(t3, t5))
-
-  TEST_SUCCESS
-}

test/src/test_affine.h

@@ -0,0 +1,634 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "test_common.h"
+
+TEST_IMPL(GLM_PREFIX, translate) {
+  mat4 m1;
+  vec4 v1 = {1.0f, 2.0f, 3.0f, 1.0f}, v2;
+
+  glm_mat4_identity(m1);
+  GLM(translate)(m1, (vec3){13.0f, 11.0f, 7.0f});
+  glm_mat4_mulv(m1, v1, v2);
+
+  ASSERT(test_eq(v2[0], 14.0f))
+  ASSERT(test_eq(v2[1], 13.0f))
+  ASSERT(test_eq(v2[2], 10.0f))
+  ASSERT(test_eq(v2[3], 1.0f))
+
+  glm_mat4_identity(m1);
+  GLM(translate)(m1, (vec3){1.0f, -1.0f, -5.0f});
+  glm_mat4_mulv(m1, v2, v2);
+
+  ASSERT(test_eq(v2[0], 15.0f))
+  ASSERT(test_eq(v2[1], 12.0f))
+  ASSERT(test_eq(v2[2], 5.0f))
+  ASSERT(test_eq(v2[3], 1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, translate_to) {
+  mat4 m1, m2;
+  vec4 v1 = {1.0f, 2.0f, 3.0f, 1.0f}, v2;
+
+  glm_mat4_identity(m1);
+  GLM(translate_to)(m1, (vec3){13.0f, 11.0f, 7.0f}, m2);
+  glm_mat4_mulv(m2, v1, v2);
+
+  ASSERT(test_eq(v2[0], 14.0f))
+  ASSERT(test_eq(v2[1], 13.0f))
+  ASSERT(test_eq(v2[2], 10.0f))
+  ASSERT(test_eq(v2[3], 1.0f))
+
+  glm_mat4_identity(m1);
+  GLM(translate_to)(m1, (vec3){1.0f, -1.0f, -5.0f}, m2);
+  glm_mat4_mulv(m2, v2, v2);
+
+  ASSERT(test_eq(v2[0], 15.0f))
+  ASSERT(test_eq(v2[1], 12.0f))
+  ASSERT(test_eq(v2[2], 5.0f))
+  ASSERT(test_eq(v2[3], 1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, translate_x) {
+  mat4 m1;
+  vec4 v1 = {1.0f, 2.0f, 3.0f, 1.0f}, v2;
+
+  glm_mat4_identity(m1);
+  GLM(translate_x)(m1, 13.0f);
+  glm_mat4_mulv(m1, v1, v2);
+
+  ASSERT(test_eq(v2[0], 14.0f))
+  ASSERT(test_eq(v2[1], 2.0f))
+  ASSERT(test_eq(v2[2], 3.0f))
+  ASSERT(test_eq(v2[3], 1.0f))
+
+  glm_mat4_identity(m1);
+  GLM(translate_x)(m1, -1.0f);
+  glm_mat4_mulv(m1, v2, v2);
+
+  ASSERT(test_eq(v2[0], 13.0f))
+  ASSERT(test_eq(v2[1], 2.0f))
+  ASSERT(test_eq(v2[2], 3.0f))
+  ASSERT(test_eq(v2[3], 1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, translate_y) {
+  mat4 m1;
+  vec4 v1 = {1.0f, 2.0f, 3.0f, 1.0f}, v2;
+
+  glm_mat4_identity(m1);
+  GLM(translate_y)(m1, 11.0f);
+  glm_mat4_mulv(m1, v1, v2);
+
+  ASSERT(test_eq(v2[0], 1.0f))
+  ASSERT(test_eq(v2[1], 13.0f))
+  ASSERT(test_eq(v2[2], 3.0f))
+  ASSERT(test_eq(v2[3], 1.0f))
+
+  glm_mat4_identity(m1);
+  GLM(translate_y)(m1, -1.0f);
+  glm_mat4_mulv(m1, v2, v2);
+
+  ASSERT(test_eq(v2[0], 1.0f))
+  ASSERT(test_eq(v2[1], 12.0f))
+  ASSERT(test_eq(v2[2], 3.0f))
+  ASSERT(test_eq(v2[3], 1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, translate_z) {
+  mat4 m1;
+  vec4 v1 = {1.0f, 2.0f, 3.0f, 1.0f}, v2;
+
+  glm_mat4_identity(m1);
+  GLM(translate_z)(m1, 7.0f);
+  glm_mat4_mulv(m1, v1, v2);
+
+  ASSERT(test_eq(v2[0], 1.0f))
+  ASSERT(test_eq(v2[1], 2.0f))
+  ASSERT(test_eq(v2[2], 10.0f))
+  ASSERT(test_eq(v2[3], 1.0f))
+
+  glm_mat4_identity(m1);
+  GLM(translate_z)(m1, -5.0f);
+  glm_mat4_mulv(m1, v2, v2);
+
+  ASSERT(test_eq(v2[0], 1.0f))
+  ASSERT(test_eq(v2[1], 2.0f))
+  ASSERT(test_eq(v2[2], 5.0f))
+  ASSERT(test_eq(v2[3], 1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, translate_make) {
+  mat4 m1;
+  vec4 v1 = {1.0f, 2.0f, 3.0f, 1.0f}, v2;
+
+  glm_mat4_identity(m1);
+  GLM(translate_make)(m1, (vec3){13.0f, 11.0f, 7.0f});
+  glm_mat4_mulv(m1, v1, v2);
+
+  ASSERT(test_eq(v2[0], 14.0f))
+  ASSERT(test_eq(v2[1], 13.0f))
+  ASSERT(test_eq(v2[2], 10.0f))
+  ASSERT(test_eq(v2[3], 1.0f))
+
+  glm_mat4_identity(m1);
+  GLM(translate_make)(m1, (vec3){1.0f, -1.0f, -5.0f});
+  glm_mat4_mulv(m1, v2, v2);
+
+  ASSERT(test_eq(v2[0], 15.0f))
+  ASSERT(test_eq(v2[1], 12.0f))
+  ASSERT(test_eq(v2[2], 5.0f))
+  ASSERT(test_eq(v2[3], 1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, scale_to) {
+  mat4 m1, m2;
+  vec4 v1 = {1.0f, 2.0f, 3.0f, 1.0f}, v2;
+
+  glm_mat4_identity(m1);
+  GLM(scale_to)(m1, (vec3){13.0f, 11.0f, 7.0f}, m2);
+  glm_mat4_mulv(m2, v1, v2);
+
+  ASSERT(test_eq(v2[0], 13.0f))
+  ASSERT(test_eq(v2[1], 22.0f))
+  ASSERT(test_eq(v2[2], 21.0f))
+  ASSERT(test_eq(v2[3], 1.0f))
+
+  glm_mat4_identity(m1);
+  GLM(scale_to)(m1, (vec3){1.0f, -1.0f, -5.0f}, m2);
+  glm_mat4_mulv(m2, v2, v2);
+
+  ASSERT(test_eq(v2[0],  13.0f))
+  ASSERT(test_eq(v2[1], -22.0f))
+  ASSERT(test_eq(v2[2], -105.0f))
+  ASSERT(test_eq(v2[3],  1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, scale_make) {
+  mat4 m1;
+  vec4 v1 = {1.0f, 2.0f, 3.0f, 1.0f}, v2;
+
+  GLM(scale_make)(m1, (vec3){13.0f, 11.0f, 7.0f});
+  glm_mat4_mulv(m1, v1, v2);
+
+  ASSERT(test_eq(v2[0], 13.0f))
+  ASSERT(test_eq(v2[1], 22.0f))
+  ASSERT(test_eq(v2[2], 21.0f))
+  ASSERT(test_eq(v2[3], 1.0f))
+
+  GLM(scale_make)(m1, (vec3){1.0f, -1.0f, -5.0f});
+  glm_mat4_mulv(m1, v2, v2);
+
+  ASSERT(test_eq(v2[0],  13.0f))
+  ASSERT(test_eq(v2[1], -22.0f))
+  ASSERT(test_eq(v2[2], -105.0f))
+  ASSERT(test_eq(v2[3],  1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, scale) {
+  mat4 m1;
+  vec4 v1 = {1.0f, 2.0f, 3.0f, 1.0f}, v2;
+
+  glm_mat4_identity(m1);
+  GLM(scale)(m1, (vec3){13.0f, 11.0f, 7.0f});
+  glm_mat4_mulv(m1, v1, v2);
+
+  ASSERT(test_eq(v2[0], 13.0f))
+  ASSERT(test_eq(v2[1], 22.0f))
+  ASSERT(test_eq(v2[2], 21.0f))
+  ASSERT(test_eq(v2[3], 1.0f))
+
+  glm_mat4_identity(m1);
+  GLM(scale)(m1, (vec3){1.0f, -1.0f, -5.0f});
+  glm_mat4_mulv(m1, v2, v2);
+
+  ASSERT(test_eq(v2[0],  13.0f))
+  ASSERT(test_eq(v2[1], -22.0f))
+  ASSERT(test_eq(v2[2], -105.0f))
+  ASSERT(test_eq(v2[3],  1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, scale_uni) {
+  mat4 m1;
+  vec4 v1 = {1.0f, 2.0f, 3.0f, 1.0f}, v2;
+
+  glm_mat4_identity(m1);
+  GLM(scale_uni)(m1, 13.0f);
+  glm_mat4_mulv(m1, v1, v2);
+
+  ASSERT(test_eq(v2[0], 13.0f))
+  ASSERT(test_eq(v2[1], 26.0f))
+  ASSERT(test_eq(v2[2], 39.0f))
+  ASSERT(test_eq(v2[3], 1.0f))
+
+  glm_mat4_identity(m1);
+  GLM(scale_uni)(m1, -5.0f);
+  glm_mat4_mulv(m1, v2, v2);
+
+  ASSERT(test_eq(v2[0], -65.0f))
+  ASSERT(test_eq(v2[1], -130.0f))
+  ASSERT(test_eq(v2[2], -195.0f))
+  ASSERT(test_eq(v2[3],  1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, rotate_x) {
+  mat4   m1 = GLM_MAT4_IDENTITY_INIT;
+  vec4   v1 = {0.0f, 1.0f, 0.0f, 1.0f}, v2 = {0.0f, 1.0f, 0.0f, 1.0f};
+
+  GLM(rotate_x)(m1, GLM_PI_2f, m1);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0], 0.0f))
+  ASSERT(test_eq(v1[1], 0.0f))
+  ASSERT(test_eq(v1[2], 1.0f))
+
+  glm_vec3_copy(v2, v1);
+
+  GLM(rotate_x)(m1, GLM_PI_2f, m1);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.0f))
+  ASSERT(test_eq(v1[1], -1.0f))
+  ASSERT(test_eq(v1[2],  0.0f))
+
+  glm_vec3_copy(v2, v1);
+
+  GLM(rotate_x)(m1, GLM_PI_2f, m1);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.0f))
+  ASSERT(test_eq(v1[1],  0.0f))
+  ASSERT(test_eq(v1[2], -1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, rotate_y) {
+  mat4   m1 = GLM_MAT4_IDENTITY_INIT;
+  vec4   v1 = {1.0f, 0.0f, 0.0f, 1.0f}, v2 = {1.0f, 0.0f, 0.0f, 1.0f};
+
+  GLM(rotate_y)(m1, GLM_PI_2f, m1);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.0f))
+  ASSERT(test_eq(v1[1],  0.0f))
+  ASSERT(test_eq(v1[2], -1.0f))
+
+  glm_vec3_copy(v2, v1);
+
+  GLM(rotate_y)(m1, GLM_PI_2f, m1);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0], -1.0f))
+  ASSERT(test_eq(v1[1],  0.0f))
+  ASSERT(test_eq(v1[2],  0.0f))
+
+  glm_vec3_copy(v2, v1);
+
+  GLM(rotate_y)(m1, GLM_PI_2f, m1);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0], 0.0f))
+  ASSERT(test_eq(v1[1], 0.0f))
+  ASSERT(test_eq(v1[2], 1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, rotate_z) {
+  mat4   m1 = GLM_MAT4_IDENTITY_INIT;
+  vec4   v1 = {0.0f, 1.0f, 0.0f, 1.0f}, v2 = {0.0f, 1.0f, 0.0f, 1.0f};
+
+  GLM(rotate_z)(m1, GLM_PI_2f, m1);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0], -1.0f))
+  ASSERT(test_eq(v1[1],  0.0f))
+  ASSERT(test_eq(v1[2],  0.0f))
+
+  glm_vec3_copy(v2, v1);
+
+  GLM(rotate_z)(m1, GLM_PI_2f, m1);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.0f))
+  ASSERT(test_eq(v1[1], -1.0f))
+  ASSERT(test_eq(v1[2],  0.0f))
+
+  glm_vec3_copy(v2, v1);
+
+  GLM(rotate_z)(m1, GLM_PI_2f, m1);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0], 1.0f))
+  ASSERT(test_eq(v1[1], 0.0f))
+  ASSERT(test_eq(v1[2], 0.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, rotate_make) {
+  mat4   m1 = GLM_MAT4_IDENTITY_INIT;
+  vec4   v1 = {1.0f, 0.0f, 0.0f, 1.0f};
+
+  /* rotate X around Y = -Z */
+  GLM(rotate_make)(m1, GLM_PI_2f, GLM_YUP);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.0f))
+  ASSERT(test_eq(v1[1],  0.0f))
+  ASSERT(test_eq(v1[2], -1.0f))
+
+  /* rotate -Z around X = Y */
+  GLM(rotate_make)(m1, GLM_PI_2f, GLM_XUP);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.0f))
+  ASSERT(test_eq(v1[1],  1.0f))
+  ASSERT(test_eq(v1[2],  0.0f))
+
+  /* rotate Y around X = +Z */
+  GLM(rotate_make)(m1, GLM_PI_2f, GLM_XUP);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.0f))
+  ASSERT(test_eq(v1[1],  0.0f))
+  ASSERT(test_eq(v1[2],  1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, rotate) {
+  mat4 m1 = GLM_MAT4_IDENTITY_INIT, m2 = GLM_MAT4_IDENTITY_INIT;
+  vec4 v1 = {1.0f, 0.0f, 0.0f, 1.0f};
+
+  /* 360 deg */
+  glm_rotate(m1, GLM_PI_2f, GLM_YUP);
+  glm_rotate(m1, GLM_PI_2f, GLM_YUP);
+  glm_rotate(m1, GLM_PI_2f, GLM_YUP);
+  glm_rotate(m1, GLM_PI_2f, GLM_YUP);
+  ASSERTIFY(test_assert_mat4_eq(m1, m2))
+
+  /* rotate X around Y = -Z */
+  GLM(rotate)(m1, GLM_PI_2f, GLM_YUP);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.0f))
+  ASSERT(test_eq(v1[1],  0.0f))
+  ASSERT(test_eq(v1[2], -1.0f))
+
+  glm_mat4_identity(m1);
+
+  /* rotate -Z around X = Y */
+  GLM(rotate)(m1, GLM_PI_2f, GLM_XUP);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.0f))
+  ASSERT(test_eq(v1[1],  1.0f))
+  ASSERT(test_eq(v1[2],  0.0f))
+
+  glm_mat4_identity(m1);
+
+  /* rotate Y around X = +Z */
+  GLM(rotate)(m1, GLM_PI_2f, GLM_XUP);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.0f))
+  ASSERT(test_eq(v1[1],  0.0f))
+  ASSERT(test_eq(v1[2],  1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, rotate_at) {
+  mat4 m1 = GLM_MAT4_IDENTITY_INIT;
+  vec4 v1 = {1.0f, 0.0f, 0.0f, 1.0f};
+
+  GLM(rotate_at)(m1, (vec3){0.5f, 0.0f, 0.0f}, GLM_PI_2f, GLM_YUP);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.5f))
+  ASSERT(test_eq(v1[1],  0.0f))
+  ASSERT(test_eq(v1[2], -0.5f))
+
+  glm_mat4_identity(m1);
+
+  GLM(rotate_at)(m1, GLM_VEC3_ZERO, GLM_PI_2f, GLM_ZUP);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.0f))
+  ASSERT(test_eq(v1[1],  0.5f))
+  ASSERT(test_eq(v1[2], -0.5f))
+
+  glm_mat4_identity(m1);
+
+  v1[0] = 1.0f;
+  v1[1] = 1.0f;
+  v1[2] = 1.0f;
+
+  GLM(rotate_at)(m1, GLM_VEC3_ZERO, GLM_PI_2f, GLM_XUP);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  1.0f))
+  ASSERT(test_eq(v1[1], -1.0f))
+  ASSERT(test_eq(v1[2],  1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, rotate_atm) {
+  mat4 m1 = GLM_MAT4_IDENTITY_INIT;
+  vec4 v1 = {1.0f, 0.0f, 0.0f, 1.0f};
+
+  GLM(rotate_atm)(m1, (vec3){0.5f, 0.0f, 0.0f}, GLM_PI_2f, GLM_YUP);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.5f))
+  ASSERT(test_eq(v1[1],  0.0f))
+  ASSERT(test_eq(v1[2], -0.5f))
+
+  GLM(rotate_atm)(m1, GLM_VEC3_ZERO, GLM_PI_2f, GLM_ZUP);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.0f))
+  ASSERT(test_eq(v1[1],  0.5f))
+  ASSERT(test_eq(v1[2], -0.5f))
+
+  v1[0] = 1.0f;
+  v1[1] = 1.0f;
+  v1[2] = 1.0f;
+
+  GLM(rotate_atm)(m1, GLM_VEC3_ZERO, GLM_PI_2f, GLM_XUP);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  1.0f))
+  ASSERT(test_eq(v1[1], -1.0f))
+  ASSERT(test_eq(v1[2],  1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, decompose_scalev) {
+  mat4 m1;
+  vec3 s1;
+
+  GLM(scale_make)(m1, (vec3){7.0f, 8.0f, 9.0f});
+  GLM(decompose_scalev)(m1, s1);
+
+  ASSERT(test_eq(s1[0], 7.0f))
+  ASSERT(test_eq(s1[1], 8.0f))
+  ASSERT(test_eq(s1[2], 9.0f))
+
+  GLM(scale)(m1, (vec3){7.0f, 8.0f, 9.0f});
+  GLM(decompose_scalev)(m1, s1);
+
+  ASSERT(test_eq(s1[0], 49.0f))
+  ASSERT(test_eq(s1[1], 64.0f))
+  ASSERT(test_eq(s1[2], 81.0f))
+
+  glm_rotate(m1, GLM_PI_4f, (vec3){23.0f, 45.0f, 66.0f});
+  ASSERT(test_eq(s1[0], 49.0f))
+  ASSERT(test_eq(s1[1], 64.0f))
+  ASSERT(test_eq(s1[2], 81.0f))
+
+  glm_translate(m1, (vec3){4.0f, 5.0f, 6.0f});
+  ASSERT(test_eq(s1[0], 49.0f))
+  ASSERT(test_eq(s1[1], 64.0f))
+  ASSERT(test_eq(s1[2], 81.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, uniscaled) {
+  mat4 m1;
+
+  GLM(scale_make)(m1, (vec3){7.0f, 8.0f, 9.0f});
+  ASSERT(!GLM(uniscaled)(m1))
+
+  GLM(scale_make)(m1, (vec3){7.0f, 7.0f, 7.0f});
+  ASSERT(GLM(uniscaled)(m1))
+
+  glm_rotate(m1, GLM_PI_4f, (vec3){23.0f, 45.0f, 66.0f});
+  ASSERT(GLM(uniscaled)(m1))
+
+  glm_translate(m1, (vec3){4.0f, 5.0f, 6.0f});
+  ASSERT(GLM(uniscaled)(m1))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, decompose_rs) {
+  mat4 m1, m2, r;
+  vec3 s1;
+
+  GLM(scale_make)(m1, (vec3){7.0f, 8.0f, 9.0f});
+  GLM(decompose_rs)(m1, r, s1);
+
+  ASSERT(test_eq(s1[0], 7.0f))
+  ASSERT(test_eq(s1[1], 8.0f))
+  ASSERT(test_eq(s1[2], 9.0f))
+  ASSERTIFY(test_assert_mat4_eq_identity(r));
+
+  GLM(scale)(m1, (vec3){7.0f, 8.0f, 9.0f});
+  GLM(decompose_rs)(m1, r, s1);
+
+  ASSERT(test_eq(s1[0], 49.0f))
+  ASSERT(test_eq(s1[1], 64.0f))
+  ASSERT(test_eq(s1[2], 81.0f))
+  ASSERTIFY(test_assert_mat4_eq_identity(r));
+
+  glm_rotate(m1, GLM_PI_4f, (vec3){23.0f, 45.0f, 66.0f});
+  ASSERT(test_eq(s1[0], 49.0f))
+  ASSERT(test_eq(s1[1], 64.0f))
+  ASSERT(test_eq(s1[2], 81.0f))
+  GLM(decompose_rs)(m1, r, s1);
+
+  glm_mat4_identity(m2);
+  glm_mat4_mul(m2, r, m2);
+  glm_scale(m2, s1);
+
+  ASSERTIFY(test_assert_mat4_eq2(m1, m2, 0.00001f));
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, decompose) {
+  mat4 m1, m2, r;
+  vec4 t;
+  vec3 s;
+
+  GLM(scale_make)(m1, (vec3){7.0f, 8.0f, 9.0f});
+  GLM(decompose)(m1, t, r, s);
+
+  ASSERT(test_eq(s[0], 7.0f))
+  ASSERT(test_eq(s[1], 8.0f))
+  ASSERT(test_eq(s[2], 9.0f))
+  ASSERTIFY(test_assert_mat4_eq_identity(r));
+
+  GLM(scale)(m1, (vec3){7.0f, 8.0f, 9.0f});
+  GLM(decompose)(m1, t, r, s);
+
+  ASSERT(test_eq(s[0], 49.0f))
+  ASSERT(test_eq(s[1], 64.0f))
+  ASSERT(test_eq(s[2], 81.0f))
+  ASSERTIFY(test_assert_mat4_eq_identity(r));
+
+  glm_rotate(m1, GLM_PI_4f, (vec3){23.0f, 45.0f, 66.0f});
+  ASSERT(test_eq(s[0], 49.0f))
+  ASSERT(test_eq(s[1], 64.0f))
+  ASSERT(test_eq(s[2], 81.0f))
+  GLM(decompose)(m1, t, r, s);
+
+  glm_mat4_identity(m2);
+  glm_mat4_mul(m2, r, m2);
+  glm_scale(m2, s);
+
+  ASSERTIFY(test_assert_mat4_eq2(m1, m2, 0.00001f));
+
+  glm_mat4_identity(m1);
+  glm_translate(m1, (vec3){56.0f, 13.0f, 90.0f});
+  glm_rotate(m1, GLM_PI_4f, (vec3){23.0f, 45.0f, 66.0f});
+  glm_scale(m1, (vec3){12.0f, 34.0f, 23.0f});
+
+  GLM(decompose)(m1, t, r, s);
+
+  ASSERT(test_eq(t[0], 56.0f))
+  ASSERT(test_eq(t[1], 13.0f))
+  ASSERT(test_eq(t[2], 90.0f))
+
+  ASSERT(test_eq(s[0], 12.0f))
+  ASSERT(test_eq(s[1], 34.0f))
+  ASSERT(test_eq(s[2], 23.0f))
+
+  glm_mat4_identity(m2);
+  glm_translate(m2, t);
+  glm_mat4_mul(m2, r, m2);
+  glm_scale(m2, s);
+  ASSERTIFY(test_assert_mat4_eq2(m1, m2, 0.00001f));
+
+  TEST_SUCCESS
+}

test/src/test_affine_mat.h

@@ -0,0 +1,87 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "test_common.h"
+
+TEST_IMPL(GLM_PREFIX, mul) {
+  mat4 m1 = GLM_MAT4_IDENTITY_INIT;
+  mat4 m2 = GLM_MAT4_IDENTITY_INIT;
+  mat4 m3;
+  mat4 m4 = GLM_MAT4_ZERO_INIT;
+  int  i, j, k;
+
+  test_rand_mat4(m1);
+  test_rand_mat4(m2);
+
+  GLM(mul)(m1, m2, m3);
+  for (i = 0; i < 4; i++) {
+    for (j = 0; j < 4; j++) {
+      for (k = 0; k < 4; k++)
+        /* column-major */
+        m4[i][j] += m1[k][j] * m2[i][k];
+    }
+  }
+
+  ASSERTIFY(test_assert_mat4_eq(m3, m4))
+
+  /* test pre compiled */
+  GLM(mul)(m1, m2, m3);
+  ASSERTIFY(test_assert_mat4_eq(m3, m4))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mul_rot) {
+  mat4 m1 = GLM_MAT4_IDENTITY_INIT;
+  mat4 m2 = GLM_MAT4_IDENTITY_INIT;
+  mat4 m3;
+  mat4 m4 = GLM_MAT4_ZERO_INIT;
+  int  i, j, k;
+
+  glm_rotate(m1, drand48(), (vec3){drand48(), drand48(), drand48()});
+  glm_rotate(m2, drand48(), (vec3){drand48(), drand48(), drand48()});
+
+  GLM(mul_rot)(m1, m2, m3);
+  for (i = 0; i < 4; i++) {
+    for (j = 0; j < 4; j++) {
+      for (k = 0; k < 4; k++)
+        /* column-major */
+        m4[i][j] += m1[k][j] * m2[i][k];
+    }
+  }
+
+  ASSERTIFY(test_assert_mat4_eq(m3, m4))
+
+  /* test pre compiled */
+  GLM(mul_rot)(m1, m2, m3);
+  ASSERTIFY(test_assert_mat4_eq(m3, m4))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, inv_tr) {
+  mat4 m1, m2;
+  int  i;
+
+  for (i = 0; i < 10000; i++) {
+    test_rand_mat4(m1);
+
+    glm_mat4_copy(m1, m2);
+
+    /* test inverse precise */
+    GLM(inv_tr)(m1);
+    GLM(inv_tr)(m1);
+    ASSERTIFY(test_assert_mat4_eq(m1, m2))
+
+    /* test inverse precise */
+    GLM(mat4_inv)(m1, m2);
+    GLM(inv_tr)(m2);
+    ASSERTIFY(test_assert_mat4_eq(m1, m2))
+  }
+
+  TEST_SUCCESS
+}

test/src/test_common.c

@@ -14,10 +14,10 @@ test_rand_mat4(mat4 dest) {
   dest[3][0] = drand48();
   dest[3][1] = drand48();
   dest[3][2] = drand48();
-  
+
   /* random rotatation around random axis with random angle */
   glm_rotate(dest, drand48(), (vec3){drand48(), drand48(), drand48()});
-  
+
   /* random scale */
   /* glm_scale(dest, (vec3){drand48(), drand48(), drand48()}); */
 }
@@ -31,6 +31,14 @@ test_rand_mat3(mat3 dest) {
   glm_mat4_pick3(m4, dest);
 }
 
+void
+test_rand_mat2(mat2 dest) {
+  dest[0][0] = drand48();
+  dest[0][1] = drand48();
+  dest[1][0] = drand48();
+  dest[1][1] = drand48();
+}
+
 void
 test_rand_vec3(vec3 dest) {
   dest[0] = drand48();
@@ -39,7 +47,7 @@ test_rand_vec3(vec3 dest) {
 }
 
 vec3s
-test_rand_vec3s() {
+test_rand_vec3s(void) {
   vec3s r;
   test_rand_vec3(r.raw);
   return r;
@@ -54,7 +62,7 @@ test_rand_vec4(vec4 dest) {
 }
 
 vec4s
-test_rand_vec4s() {
+test_rand_vec4s(void) {
   vec4s r;
   test_rand_vec4(r.raw);
   return r;
@@ -73,68 +81,119 @@ test_rand_quat(versor q) {
 
 test_status_t
 test_assert_mat4_eq(mat4 m1, mat4 m2) {
-  int i, j, k;
+  int i, j;
 
   for (i = 0; i < 4; i++) {
     for (j = 0; j < 4; j++) {
-      for (k = 0; k < 4; k++)
+      ASSERT(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009)
-        ASSERT(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009)
     }
   }
-  
+
   TEST_SUCCESS
 }
 
 test_status_t
 test_assert_mat4_eqt(mat4 m1, mat4 m2) {
-  int i, j, k;
+  int i, j;
 
   for (i = 0; i < 4; i++) {
     for (j = 0; j < 4; j++) {
-      for (k = 0; k < 4; k++)
+      ASSERT(fabsf(m1[j][i] - m2[i][j]) <= 0.0000009)
-        ASSERT(fabsf(m1[j][i] - m2[i][j]) <= 0.0000009)
     }
   }
-  
+
   TEST_SUCCESS
 }
 
 test_status_t
 test_assert_mat4_eq2(mat4 m1, mat4 m2, float eps) {
-  int i, j, k;
+  int i, j;
-  
+
   for (i = 0; i < 4; i++) {
     for (j = 0; j < 4; j++) {
-      for (k = 0; k < 4; k++)
+      ASSERT(fabsf(m1[i][j] - m2[i][j]) <= eps);
-        ASSERT(fabsf(m1[i][j] - m2[i][j]) <= eps);
     }
   }
-  
+
+  TEST_SUCCESS
+}
+
+test_status_t
+test_assert_mat2_eqt(mat2 m1, mat2 m2) {
+  int i, j;
+
+  for (i = 0; i < 2; i++) {
+    for (j = 0; j < 2; j++) {
+      ASSERT(fabsf(m1[j][i] - m2[i][j]) <= 0.0000009);
+    }
+  }
+
+  TEST_SUCCESS
+}
+
+test_status_t
+test_assert_mat2_eq(mat2 m1, mat2 m2) {
+  int i, j;
+
+  for (i = 0; i < 2; i++) {
+    for (j = 0; j < 2; j++) {
+      ASSERT(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009);
+    }
+  }
+
+  TEST_SUCCESS
+}
+
+test_status_t
+test_assert_mat2_eq_identity(mat2 m2) {
+  int i, j;
+
+  for (i = 0; i < 2; i++) {
+    for (j = 0; j < 2; j++) {
+      if (i == j) {
+        ASSERT(test_eq(m2[i][j], 1.0f))
+      } else {
+        ASSERT(test_eq(m2[i][j], 0.0f))
+      }
+    }
+  }
+
+  TEST_SUCCESS
+}
+
+test_status_t
+test_assert_mat2_eq_zero(mat2 m2) {
+  int i, j;
+
+  for (i = 0; i < 2; i++) {
+    for (j = 0; j < 2; j++) {
+      ASSERT(test_eq(m2[i][j], 0.0f))
+    }
+  }
+
   TEST_SUCCESS
 }
 
 test_status_t
 test_assert_mat3_eq(mat3 m1, mat3 m2) {
-  int i, j, k;
+  int i, j;
 
   for (i = 0; i < 3; i++) {
     for (j = 0; j < 3; j++) {
-      for (k = 0; k < 3; k++)
+      ASSERT(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009);
-        ASSERT(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009);
     }
   }
-  
+
   TEST_SUCCESS
 }
 
 test_status_t
 test_assert_mat3_eqt(mat3 m1, mat3 m2) {
-  int i, j, k;
+  int i, j;
 
   for (i = 0; i < 3; i++) {
     for (j = 0; j < 3; j++) {
-      for (k = 0; k < 3; k++)
+      ASSERT(fabsf(m1[j][i] - m2[i][j]) <= 0.0000009);
-        ASSERT(fabsf(m1[j][i] - m2[i][j]) <= 0.0000009);
     }
   }
 
@@ -204,7 +263,15 @@ test_assert_mat4_eq_zero(mat4 m4) {
 test_status_t
 test_assert_eqf(float a, float b) {
   ASSERT(fabsf(a - b) <= 0.000009); /* rounding errors */
-  
+
+  TEST_SUCCESS
+}
+
+test_status_t
+test_assert_vec2_eq(vec2 v1, vec2 v2) {
+  ASSERT(fabsf(v1[0] - v2[0]) <= 0.000009); /* rounding errors */
+  ASSERT(fabsf(v1[1] - v2[1]) <= 0.000009);
+
   TEST_SUCCESS
 }
 
@@ -213,14 +280,14 @@ test_assert_vec3_eq(vec3 v1, vec3 v2) {
   ASSERT(fabsf(v1[0] - v2[0]) <= 0.000009); /* rounding errors */
   ASSERT(fabsf(v1[1] - v2[1]) <= 0.000009);
   ASSERT(fabsf(v1[2] - v2[2]) <= 0.000009);
-  
+
   TEST_SUCCESS
 }
 
 test_status_t
 test_assert_vec3s_eq(vec3s v1, vec3s v2) {
   test_assert_vec3_eq(v1.raw, v2.raw);
-  
+
   TEST_SUCCESS
 }
 
@@ -230,14 +297,14 @@ test_assert_vec4_eq(vec4 v1, vec4 v2) {
   ASSERT(fabsf(v1[1] - v2[1]) <= 0.000009);
   ASSERT(fabsf(v1[2] - v2[2]) <= 0.000009);
   ASSERT(fabsf(v1[3] - v2[3]) <= 0.000009);
-  
+
   TEST_SUCCESS
 }
 
 test_status_t
 test_assert_vec4s_eq(vec4s v1, vec4s v2) {
   test_assert_vec4_eq(v1.raw, v2.raw);
-  
+
   TEST_SUCCESS
 }
 
@@ -247,7 +314,7 @@ test_assert_quat_eq_abs(versor v1, versor v2) {
   ASSERT(fabsf(fabsf(v1[1]) - fabsf(v2[1])) <= 0.0009);
   ASSERT(fabsf(fabsf(v1[2]) - fabsf(v2[2])) <= 0.0009);
   ASSERT(fabsf(fabsf(v1[3]) - fabsf(v2[3])) <= 0.0009);
-  
+
   TEST_SUCCESS
 }
 
@@ -257,7 +324,7 @@ test_assert_quat_eq(versor v1, versor v2) {
   ASSERT(fabsf(v1[1] - v2[1]) <= 0.000009);
   ASSERT(fabsf(v1[2] - v2[2]) <= 0.000009);
   ASSERT(fabsf(v1[3] - v2[3]) <= 0.000009);
-  
+
   TEST_SUCCESS
 }
 

test/src/test_common.h

@@ -16,6 +16,9 @@ test_rand_mat4(mat4 dest);
 void
 test_rand_mat3(mat3 dest);
 
+void
+test_rand_mat2(mat2 dest);
+
 test_status_t
 test_assert_eqf(float a, float b);
 
@@ -34,9 +37,24 @@ test_assert_mat4_eq_identity(mat4 m4);
 test_status_t
 test_assert_mat4_eq_zero(mat4 m4);
 
+test_status_t
+test_assert_mat2_eqt(mat2 m1, mat2 m2);
+
+test_status_t
+test_assert_mat2_eq(mat2 m1, mat2 m2);
+
+test_status_t
+test_assert_mat2_eq_identity(mat2 m2);
+
+test_status_t
+test_assert_mat2_eq_zero(mat2 m2);
+
 test_status_t
 test_assert_mat3_eq(mat3 m1, mat3 m2);
 
+test_status_t
+test_assert_vec2_eq(vec2 v1, vec2 v2);
+
 test_status_t
 test_assert_mat3_eqt(mat3 m1, mat3 m2);
 

test/src/test_mat2.h

@@ -0,0 +1,286 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "test_common.h"
+
+#define A_MATRIX2x2 {{1,2},{5,6}}
+
+#ifndef CGLM_TEST_MAT2_ONCE
+#define CGLM_TEST_MAT2_ONCE
+
+TEST_IMPL(MACRO_GLM_MAT2_IDENTITY_INIT) {
+  mat2 m = GLM_MAT2_IDENTITY_INIT;
+  
+  ASSERT(test_eq(m[0][0], 1.0f))
+  ASSERT(test_eq(m[0][1], 0.0f))
+  ASSERT(test_eq(m[1][0], 0.0f))
+  ASSERT(test_eq(m[1][1], 1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(MACRO_GLM_MAT2_ZERO_INIT) {  
+  mat2 m = GLM_MAT2_ZERO_INIT;
+  
+  ASSERT(test_eq(m[0][0], 0.0f))
+  ASSERT(test_eq(m[0][1], 0.0f))
+  ASSERT(test_eq(m[1][0], 0.0f))
+  ASSERT(test_eq(m[1][1], 0.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(MACRO_GLM_MAT2_IDENTITY) {
+  ASSERT(test_eq(GLM_MAT2_IDENTITY[0][0], 1.0f))
+  ASSERT(test_eq(GLM_MAT2_IDENTITY[0][1], 0.0f))
+  ASSERT(test_eq(GLM_MAT2_IDENTITY[1][0], 0.0f))
+  ASSERT(test_eq(GLM_MAT2_IDENTITY[1][1], 1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(MACRO_GLM_MAT2_ZERO) {
+  ASSERT(test_eq(GLM_MAT2_ZERO[0][0], 0.0f))
+  ASSERT(test_eq(GLM_MAT2_ZERO[0][1], 0.0f))
+  ASSERT(test_eq(GLM_MAT2_ZERO[1][0], 0.0f))
+  ASSERT(test_eq(GLM_MAT2_ZERO[1][1], 0.0f))
+
+  TEST_SUCCESS
+}
+
+#endif /* CGLM_TEST_MAT2_ONCE */
+
+TEST_IMPL(GLM_PREFIX, mat2_copy) {
+  mat2 m1 = A_MATRIX2x2;
+  mat2 m2 = GLM_MAT2_IDENTITY_INIT;
+
+  GLM(mat2_copy)(m1, m2);
+
+  test_assert_mat2_eq(m1, m2);
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_identity) {
+  mat2 m1 = GLM_MAT2_IDENTITY_INIT;
+  mat2 m2 = GLM_MAT2_IDENTITY_INIT;
+  mat2 m3;
+
+  GLM(mat2_identity)(m3);
+
+  ASSERTIFY(test_assert_mat2_eq_identity(m1))
+  ASSERTIFY(test_assert_mat2_eq_identity(m2))
+  ASSERTIFY(test_assert_mat2_eq_identity(m3))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_identity_array) {
+  int i, count;
+  mat2 matrices[4] = {
+    A_MATRIX2x2,
+    A_MATRIX2x2,
+    A_MATRIX2x2,
+    A_MATRIX2x2
+  };
+
+  count = 4;
+
+  GLM(mat2_identity_array)(matrices, count);
+
+  for (i = 0; i < count; i++) {
+    ASSERTIFY(test_assert_mat2_eq_identity(matrices[i]))
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_zero) {
+  mat2 m1 = GLM_MAT2_ZERO_INIT;
+  mat2 m2 = GLM_MAT2_ZERO_INIT;
+  mat2 m3;
+
+  GLM(mat2_zero)(m3);
+
+  ASSERTIFY(test_assert_mat2_eq_zero(m1))
+  ASSERTIFY(test_assert_mat2_eq_zero(m2))
+  ASSERTIFY(test_assert_mat2_eq_zero(m3))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_mul) {
+  mat2 m1 = GLM_MAT2_IDENTITY_INIT;
+  mat2 m2 = GLM_MAT2_IDENTITY_INIT;
+  mat2 m3;
+  mat2 m4 = GLM_MAT2_ZERO_INIT;
+  int  i, j, k;
+
+  /* test random matrices */
+  /* random matrices */
+  test_rand_mat2(m1);
+  test_rand_mat2(m2);
+
+  GLM(mat2_mul)(m1, m2, m3);
+  for (i = 0; i < 2; i++) {
+    for (j = 0; j < 2; j++) {
+      for (k = 0; k < 2; k++)
+        /* column-major */
+        m4[i][j] += m1[k][j] * m2[i][k];
+    }
+  }
+
+  ASSERTIFY(test_assert_mat2_eq(m3, m4))
+
+  /* test pre compiled */
+  GLM(mat2_mul)(m1, m2, m3);
+  ASSERTIFY(test_assert_mat2_eq(m3, m4))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_transpose_to) {
+  mat2 mat = A_MATRIX2x2;
+  mat2 m1;
+
+  GLM(mat2_transpose_to)(mat, m1);
+
+  ASSERTIFY(test_assert_mat2_eqt(mat, m1))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_transpose) {
+  mat2 mat = A_MATRIX2x2;
+  mat2 m1;
+
+  GLM(mat2_copy)(mat, m1);
+  GLM(mat2_transpose)(m1);
+
+  ASSERTIFY(test_assert_mat2_eqt(mat, m1))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_mulv) {
+  vec2 res;
+  mat2 mat = A_MATRIX2x2;
+  vec2 v = {11.0f, 21.0f};
+  int  i;
+
+  GLM(mat2_mulv)(mat, v, res);
+
+  for (i = 0; i < 2; i++) {
+    ASSERT(test_eq(res[i], v[0] * mat[0][i] + v[1] * mat[1][i]))
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_trace) {
+  mat2  mat = A_MATRIX2x2;
+  float trace;
+
+  trace = GLM(mat2_trace)(mat);
+
+  ASSERT(test_eq(trace, mat[0][0] + mat[1][1]))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_scale) {
+  mat2 m1 = A_MATRIX2x2;
+  mat2 m2 = A_MATRIX2x2;
+  int i, j, scale;
+
+  scale = rand() % 100;
+
+  GLM(mat2_scale)(m1, (float)scale);
+
+  for (i = 0; i < 2; i++) {
+    for (j = 0; j < 2; j++) {
+      ASSERT(test_eq(m1[i][j], m2[i][j] * scale))
+    }
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_det) {
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_inv) {
+  mat2 m1 = GLM_MAT2_IDENTITY_INIT;
+  mat2 m2 = GLM_MAT2_IDENTITY_INIT;
+  mat2 m3;
+  int  i;
+
+  m1[0][0] = 41.0f;
+  m1[0][1] = 0.0f;
+  m1[1][0] = 0.0f;
+  m1[1][1] = 70.0f;
+
+  for (i = 0; i < 10000; i++) {
+    /* test inverse precise */
+    GLM(mat2_inv)(m1, m2);
+    GLM(mat2_inv)(m2, m3);
+    
+    ASSERTIFY(test_assert_mat2_eq(m1, m3))
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_swap_col) {
+  mat2 m1 = A_MATRIX2x2;
+  mat2 m2 = A_MATRIX2x2;
+
+  GLM(mat2_swap_col)(m1, 0, 1);
+
+  ASSERTIFY(test_assert_vec2_eq(m1[0], m2[1]))
+  ASSERTIFY(test_assert_vec2_eq(m1[1], m2[0]))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_swap_row) {
+  mat2 m1 = A_MATRIX2x2;
+  mat2 m2 = A_MATRIX2x2;
+
+  GLM(mat2_swap_row)(m1, 0, 1);
+
+  ASSERT(test_eq(m1[0][0], m2[0][1]))
+  ASSERT(test_eq(m1[0][1], m2[0][0]))
+
+  ASSERT(test_eq(m1[1][0], m2[1][1]))
+  ASSERT(test_eq(m1[1][1], m2[1][0]))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_rmc) {
+  mat2  mat = A_MATRIX2x2;
+  vec2  v   = {11.0f, 12.0f};
+  vec2  v1;
+  float r1, r2;
+  int   i;
+
+  r1 = GLM(mat2_rmc)(v, mat, v);
+
+  for (i = 0; i < 2; i++) {
+    v1[i] = v[0] * mat[i][0] + v[1] * mat[i][1];
+  }
+
+  r2 = v[0] * v1[0] + v[1] * v1[1];
+
+  ASSERT(test_eq(r1, r2))
+
+  TEST_SUCCESS
+}
+
+#undef A_MATRIX2x2

test/src/test_mat3.c

@@ -1,26 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-/* test inline mat3 */
-
-#define GLM_PREFIX glm_
-#define GLM(X) (glm_ ## X)
-
-#include "test_mat3.h"
-
-#undef GLM
-#undef GLM_PREFIX
-
-/* test pre-compiled mat3 */
-
-#define GLM_PREFIX glmc_
-#define GLM(X) (glmc_ ## X)
-
-#include "test_mat3.h"
-
-#undef GLM
-#undef GLM_PREFIX

test/src/test_mat3.h

@@ -307,3 +307,5 @@ TEST_IMPL(GLM_PREFIX, mat3_rmc) {
 
   TEST_SUCCESS
 }
+
+#undef A_MATRIX

test/src/test_mat4.c

@@ -1,26 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-/* test inline mat4 */
-
-#define GLM_PREFIX glm_
-#define GLM(X) (glm_ ## X)
-
-#include "test_mat4.h"
-
-#undef GLM
-#undef GLM_PREFIX
-
-/* test pre-compiled mat4 */
-
-#define GLM_PREFIX glmc_
-#define GLM(X) (glmc_ ## X)
-
-#include "test_mat4.h"
-
-#undef GLM
-#undef GLM_PREFIX

test/src/test_mat4.h

@@ -483,3 +483,6 @@ TEST_IMPL(GLM_PREFIX, mat4_rmc) {
 
   TEST_SUCCESS
 }
+
+#undef A_MATRIX
+#undef A_MATRIX3

test/src/test_plane.h

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "test_common.h"
+
+TEST_IMPL(GLM_PREFIX, plane_normalize) {
+  vec4  p1 = {2.0f, -3.0f, 4.0f, 5.0f}, p2 = {2.0f, -3.0f, 4.0f, 5.0f};
+  float s  = 1.0f;
+  float norm;
+
+  GLM(plane_normalize)(p2);
+
+  norm = sqrtf(p1[0] * p1[0] + p1[1] * p1[1] + p1[2] * p1[2]);
+  if (norm == 0.0f) {
+    ASSERT(test_eq(p1[0], 0.0f))
+    ASSERT(test_eq(p1[1], 0.0f))
+    ASSERT(test_eq(p1[2], 0.0f))
+    ASSERT(test_eq(p1[3], 0.0f))
+
+    TEST_SUCCESS
+  }
+  
+  norm = s / norm;
+  
+  ASSERT(test_eq(p1[0] * norm, p2[0]))
+  ASSERT(test_eq(p1[1] * norm, p2[1]))
+  ASSERT(test_eq(p1[2] * norm, p2[2]))
+  ASSERT(test_eq(p1[3] * norm, p2[3]))
+
+  glm_vec4_zero(p1);
+  GLM(plane_normalize)(p1);
+  ASSERTIFY(test_assert_vec4_eq(p1, GLM_VEC4_ZERO))
+
+  TEST_SUCCESS
+}

test/src/test_project.c

@@ -1,26 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-/* test inline project */
-
-#define GLM_PREFIX glm_
-#define GLM(X) (glm_ ## X)
-
-#include "test_project.h"
-
-#undef GLM
-#undef GLM_PREFIX
-
-/* test pre-compiled project */
-
-#define GLM_PREFIX glmc_
-#define GLM(X) (glmc_ ## X)
-
-#include "test_project.h"
-
-#undef GLM
-#undef GLM_PREFIX

test/src/test_quat.c

@@ -1,224 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-#include "test_common.h"
-
-/* test inline quat */
-
-#define GLM_PREFIX glm_
-#define GLM(X) (glm_ ## X)
-
-#include "test_quat.h"
-
-#undef GLM
-#undef GLM_PREFIX
-
-/* test pre-compiled quat */
-
-#define GLM_PREFIX glmc_
-#define GLM(X) (glmc_ ## X)
-
-#include "test_quat.h"
-
-#undef GLM
-#undef GLM_PREFIX
-
-CGLM_INLINE
-void
-test_quat_mul_raw(versor p, versor q, versor dest) {
-  dest[0] = p[3] * q[0] + p[0] * q[3] + p[1] * q[2] - p[2] * q[1];
-  dest[1] = p[3] * q[1] - p[0] * q[2] + p[1] * q[3] + p[2] * q[0];
-  dest[2] = p[3] * q[2] + p[0] * q[1] - p[1] * q[0] + p[2] * q[3];
-  dest[3] = p[3] * q[3] - p[0] * q[0] - p[1] * q[1] - p[2] * q[2];
-}
-
-TEST_IMPL(quat) {
-  mat4   inRot, outRot, view1, view2, rot1, rot2;
-  versor inQuat, outQuat, q3, q4, q5;
-  vec3   eye, axis, imag, v1, v2;
-  int    i;
-
-  /* 0. test identiy quat */
-  glm_quat_identity(q4);
-  ASSERT(test_eq(glm_quat_real(q4), cosf(glm_rad(0.0f) * 0.5f)))
-
-  glm_quat_mat4(q4, rot1);
-  ASSERTIFY(test_assert_mat4_eq2(rot1, GLM_MAT4_IDENTITY, 0.000009f))
-
-  /* 1. test quat to mat and mat to quat */
-  for (i = 0; i < 1000; i++) {
-    test_rand_quat(inQuat);
-
-    glmc_quat_mat4(inQuat, inRot);
-    glmc_mat4_quat(inRot, outQuat);
-    glmc_quat_mat4(outQuat, outRot);
-
-    /* 2. test first quat and generated one equality */
-    ASSERTIFY(test_assert_quat_eq_abs(inQuat, outQuat));
-
-    /* 3. test first rot and second rotation */
-    /* almost equal */
-    ASSERTIFY(test_assert_mat4_eq2(inRot, outRot, 0.000009f));
-
-    /* 4. test SSE mul and raw mul */
-#if defined( __SSE__ ) || defined( __SSE2__ )
-    test_quat_mul_raw(inQuat, outQuat, q3);
-    glm_quat_mul_sse2(inQuat, outQuat, q4);
-    ASSERTIFY(test_assert_quat_eq(q3, q4));
-#endif
-  }
-
-  /* 5. test lookat */
-  test_rand_vec3(eye);
-  glm_quatv(q3, glm_rad(-90.0f), GLM_YUP);
-
-  /* now X axis must be forward axis, Z must be right axis */
-  glm_look(eye, GLM_XUP, GLM_YUP, view1);
-
-  /* create view matrix with quaternion */
-  glm_quat_look(eye, q3, view2);
-
-  ASSERTIFY(test_assert_mat4_eq2(view1, view2, 0.000009f));
-
-  /* 6. test quaternion rotation matrix result */
-  test_rand_quat(q3);
-  glm_quat_mat4(q3, rot1);
-
-  /* 6.1 test axis and angle of quat */
-  glm_quat_axis(q3, axis);
-  glm_rotate_make(rot2, glm_quat_angle(q3), axis);
-
-  ASSERTIFY(test_assert_mat4_eq2(rot1, rot2, 0.000009f));
-
-  /* 7. test quaternion multiplication (hamilton product),
-        final rotation = first rotation + second = quat1 * quat2
-   */
-  test_rand_quat(q3);
-  test_rand_quat(q4);
-
-  glm_quat_mul(q3, q4, q5);
-
-  glm_quat_axis(q3, axis);
-  glm_rotate_make(rot1, glm_quat_angle(q3), axis);
-
-  glm_quat_axis(q4, axis);
-  glm_rotate(rot1, glm_quat_angle(q4), axis);
-
-  /* rot2 is combine of two rotation now test with quaternion result */
-  glm_quat_mat4(q5, rot2);
-
-  /* result must be same (almost) */
-  ASSERTIFY(test_assert_mat4_eq2(rot1, rot2, 0.000009f))
-
-  /* 8. test quaternion for look rotation */
-
-  /* 8.1 same direction */
-  /* look at from 0, 0, 1 to zero, direction = 0, 0, -1 */
-  glm_quat_for((vec3){0, 0, -1}, (vec3){0, 0, -1}, GLM_YUP, q3);
-
-  /* result must be identity */
-  glm_quat_identity(q4);
-  ASSERTIFY(test_assert_quat_eq(q3, q4))
-
-  /* look at from 0, 0, 1 to zero, direction = 0, 0, -1 */
-  glm_quat_forp(GLM_ZUP, GLM_VEC3_ZERO, (vec3){0, 0, -1}, GLM_YUP, q3);
-
-  /* result must be identity */
-  glm_quat_identity(q4);
-  ASSERTIFY(test_assert_quat_eq(q3, q4))
-
-  /* 8.2 perpendicular */
-  glm_quat_for(GLM_XUP, (vec3){0, 0, -1}, GLM_YUP, q3);
-
-  /* result must be -90 */
-  glm_quatv(q4, glm_rad(-90.0f), GLM_YUP);
-  ASSERTIFY(test_assert_quat_eq(q3, q4))
-
-  /* 9. test imag, real */
-
-  /* 9.1 real */
-  ASSERT(test_eq(glm_quat_real(q4), cosf(glm_rad(-90.0f) * 0.5f)))
-
-  /* 9.1 imag */
-  glm_quat_imag(q4, imag);
-
-  /* axis = Y_UP * sinf(angle * 0.5), YUP = 0, 1, 0 */
-  axis[0] = 0.0f;
-  axis[1] = sinf(glm_rad(-90.0f) * 0.5f) * 1.0f;
-  axis[2] = 0.0f;
-
-  ASSERT(glm_vec3_eqv_eps(imag, axis));
-
-  /* 9.2 axis */
-  glm_quat_axis(q4, axis);
-  imag[0] =  0.0f;
-  imag[1] = -1.0f;
-  imag[2] =  0.0f;
-
-  ASSERTIFY(test_assert_vec3_eq(imag, axis));
-
-  /* 10. test rotate vector using quat */
-  /* (0,0,-1) around (1,0,0) must give (0,1,0) */
-  v1[0] = 0.0f; v1[1] = 0.0f; v1[2] = -1.0f;
-  v2[0] = 0.0f; v2[1] = 0.0f; v2[2] = -1.0f;
-
-  glm_vec3_rotate(v1, glm_rad(90.0f), (vec3){1.0f, 0.0f, 0.0f});
-  glm_quatv(q3, glm_rad(90.0f), (vec3){1.0f, 0.0f, 0.0f});
-
-  glm_vec4_scale(q3, 1.5, q3);
-  glm_quat_rotatev(q3, v2, v2);
-
-  /* result must be : (0,1,0) */
-  ASSERT(fabsf(v1[0]) <= 0.00009f
-          && fabsf(v1[1] - 1.0f) <= 0.00009f
-          && fabsf(v1[2]) <= 0.00009f)
-
-  ASSERTIFY(test_assert_vec3_eq(v1, v2))
-
-  /* 11. test rotate transform */
-  glm_translate_make(rot1, (vec3){-10.0, 45.0f, 8.0f});
-  glm_rotate(rot1, glm_rad(-90), GLM_ZUP);
-
-  glm_quatv(q3, glm_rad(-90.0f), GLM_ZUP);
-  glm_translate_make(rot2, (vec3){-10.0, 45.0f, 8.0f});
-  glm_quat_rotate(rot2, q3, rot2);
-
-  /* result must be same (almost) */
-  ASSERTIFY(test_assert_mat4_eq2(rot1, rot2, 0.000009f))
-
-  glm_rotate_make(rot1, glm_rad(-90), GLM_ZUP);
-  glm_translate(rot1, (vec3){-10.0, 45.0f, 8.0f});
-
-  glm_quatv(q3, glm_rad(-90.0f), GLM_ZUP);
-  glm_mat4_identity(rot2);
-  glm_quat_rotate(rot2, q3, rot2);
-  glm_translate(rot2, (vec3){-10.0, 45.0f, 8.0f});
-
-  /* result must be same (almost) */
-  ASSERTIFY(test_assert_mat4_eq2(rot1, rot2, 0.000009f))
-
-  /* reverse */
-  glm_rotate_make(rot1, glm_rad(-90), GLM_ZUP);
-  glm_quatv(q3, glm_rad(90.0f), GLM_ZUP);
-  glm_quat_rotate(rot1, q3, rot1);
-
-  /* result must be identity */
-  ASSERTIFY(test_assert_mat4_eq2(rot1, GLM_MAT4_IDENTITY, 0.000009f))
-
-  test_rand_quat(q3);
-
-  /* 12. inverse of quat, multiplication must be IDENTITY */
-  glm_quat_inv(q3, q4);
-  glm_quat_mul(q3, q4, q5);
-
-  glm_quat_identity(q3);
-  ASSERTIFY(test_assert_quat_eq(q3, q5))
-
-  /* TODO: add tests for slerp, lerp */
-
-  TEST_SUCCESS
-}

test/src/test_quat.h

@@ -760,3 +760,242 @@ TEST_IMPL(GLM_PREFIX, quat_look) {
 
   TEST_SUCCESS
 }
+
+TEST_IMPL(GLM_PREFIX, quat_for) {
+  versor q1, q2;
+
+  glm_quat(q1, glm_rad(90.0f), 0.0f, 1.0f, 0.0f);
+  GLM(quat_for)((vec3){-1.0f, 0.0f, 0.0f}, (vec3){0.0f, 1.0f, 0.0f}, q2);
+  ASSERTIFY(test_assert_quat_eq(q1, q2));
+
+  glm_quat(q2, glm_rad(90.0f), 1.0f, 0.0f, 0.0f);
+  GLM(quat_for)((vec3){0.0f, 1.0f, 0.0f}, (vec3){0.0f, 0.0f, 1.0f}, q1);
+  ASSERTIFY(test_assert_quat_eq(q1, q2));
+
+  glm_quat(q2, glm_rad(180.0f), 1.0f, 0.0f, 0.0f);
+  GLM(quat_for)((vec3){0.0f, 0.0f, 1.0f}, (vec3){0.0f, -1.0f, 0.0f}, q1);
+  ASSERTIFY(test_assert_quat_eq(q1, q2));
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quat_forp) {
+  versor q1, q2;
+
+  glm_quat(q1, glm_rad(90.0f), 0.0f, 1.0f, 0.0f);
+  GLM(quat_forp)((vec3){2.0f, 0.0f, 0.0f},
+                 (vec3){1.0f, 0.0f, 0.0f}, 
+                 (vec3){0.0f, 1.0f, 0.0f}, 
+                 q2);
+  ASSERTIFY(test_assert_quat_eq(q1, q2));
+
+  glm_quat(q2, glm_rad(90.0f), 1.0f, 0.0f, 0.0f);
+  GLM(quat_forp)((vec3){0.0f, 1.0f, 0.0f}, 
+                 (vec3){0.0f, 2.0f, 0.0f},
+                 (vec3){0.0f, 0.0f, 1.0f},
+                 q1);
+  ASSERTIFY(test_assert_quat_eq(q1, q2));
+
+  glm_quat(q2, glm_rad(180.0f), 1.0f, 0.0f, 0.0f);
+  GLM(quat_forp)((vec3){0.0f, 1.0f, 1.0f}, 
+                 (vec3){0.0f, 1.0f, 2.0f},
+                 (vec3){0.0f, -1.0f, 0.0f},
+                 q1);
+  ASSERTIFY(test_assert_quat_eq(q1, q2));
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quat_rotatev) {
+  vec3   v1 = {1.0f, 0.0f, 0.0f}, v2 = {1.0f, 1.0f, 1.0f};
+  versor q;
+
+  /* rotate X around Y = -Z */
+  glm_quatv(q, GLM_PI_2f, GLM_YUP);
+  GLM(quat_rotatev)(q, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.0f))
+  ASSERT(test_eq(v1[1],  0.0f))
+  ASSERT(test_eq(v1[2], -1.0f))
+
+  /* rotate -Z around X = Y */
+  glm_quatv(q, GLM_PI_2f, GLM_XUP);
+  GLM(quat_rotatev)(q, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.0f))
+  ASSERT(test_eq(v1[1],  1.0f))
+  ASSERT(test_eq(v1[2],  0.0f))
+
+  /* rotate Y around Z = -X */
+  glm_quatv(q, GLM_PI_2f, GLM_ZUP);
+  GLM(quat_rotatev)(q, v1, v1);
+
+  ASSERT(test_eq(v1[0], -1.0f))
+  ASSERT(test_eq(v1[1],  0.0f))
+  ASSERT(test_eq(v1[2],  0.0f))
+
+  /* rotate v2 around Y by 90deg */
+  glm_quatv(q, GLM_PI_2f, GLM_YUP);
+  GLM(quat_rotatev)(q, v2, v2);
+
+  ASSERT(test_eq(v2[0],  1.0f))
+  ASSERT(test_eq(v2[1],  1.0f))
+  ASSERT(test_eq(v2[2], -1.0f))
+
+  /* rotate v2 around Y by 90deg */
+  glm_quatv(q, GLM_PI_2f, GLM_YUP);
+  GLM(quat_rotatev)(q, v2, v2);
+
+  ASSERT(test_eq(v2[0], -1.0f))
+  ASSERT(test_eq(v2[1],  1.0f))
+  ASSERT(test_eq(v2[2], -1.0f))
+
+  /* rotate v2 around Y by 90deg */
+  glm_quatv(q, GLM_PI_2f, GLM_YUP);
+  GLM(quat_rotatev)(q, v2, v2);
+
+  ASSERT(test_eq(v2[0], -1.0f))
+  ASSERT(test_eq(v2[1],  1.0f))
+  ASSERT(test_eq(v2[2],  1.0f))
+
+  /* rotate v2 around X by 90deg */
+  glm_quatv(q, GLM_PI_2f, GLM_XUP);
+  GLM(quat_rotatev)(q, v2, v2);
+
+  ASSERT(test_eq(v2[0], -1.0f))
+  ASSERT(test_eq(v2[1], -1.0f))
+  ASSERT(test_eq(v2[2],  1.0f))
+
+  /* rotate v2 around Z by 90deg */
+  glm_quatv(q, GLM_PI_2f, GLM_ZUP);
+  GLM(quat_rotatev)(q, v2, v2);
+
+  ASSERT(test_eq(v2[0],  1.0f))
+  ASSERT(test_eq(v2[1], -1.0f))
+  ASSERT(test_eq(v2[2],  1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quat_rotate) {
+  mat4   m1 = GLM_MAT4_IDENTITY_INIT, m2;
+  versor q1;
+  vec4   v1 = {1.0f, 0.0f, 0.0f, 1.0f};
+
+  /* rotate X around Y = -Z */
+  glm_quatv(q1, GLM_PI_2f, GLM_YUP);
+  GLM(quat_rotate)(m1, q1, m1);
+  glm_rotate_make(m2, GLM_PI_2f, GLM_YUP);
+  ASSERTIFY(test_assert_mat4_eq(m1, m2))
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.0f))
+  ASSERT(test_eq(v1[1],  0.0f))
+  ASSERT(test_eq(v1[2], -1.0f))
+
+  glm_mat4_identity(m1);
+  glm_mat4_identity(m2);
+  
+  /* rotate -Z around X = Y */
+  glm_quatv(q1, GLM_PI_2f, GLM_XUP);
+  GLM(quat_rotate)(m1, q1, m1);
+  glm_rotate(m2, GLM_PI_2f, GLM_XUP);
+  ASSERTIFY(test_assert_mat4_eq(m1, m2))
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.0f))
+  ASSERT(test_eq(v1[1],  1.0f))
+  ASSERT(test_eq(v1[2],  0.0f))
+
+  glm_mat4_identity(m1);
+  glm_mat4_identity(m2);
+
+  /* rotate Y around X = +Z */
+  glm_quatv(q1, GLM_PI_2f, GLM_XUP);
+  GLM(quat_rotate)(m1, q1, m1);
+  glm_rotate(m2, GLM_PI_2f, GLM_XUP);
+  ASSERTIFY(test_assert_mat4_eq(m1, m2))
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.0f))
+  ASSERT(test_eq(v1[1],  0.0f))
+  ASSERT(test_eq(v1[2],  1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quat_rotate_at) {
+  mat4   m1 = GLM_MAT4_IDENTITY_INIT;
+  versor q1;
+  vec4   v1 = {1.0f, 0.0f, 0.0f, 1.0f};
+
+  glm_quatv(q1, GLM_PI_2f, GLM_YUP);
+  GLM(quat_rotate_at)(m1, q1, (vec3){0.5f, 0.0f, 0.0f});
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.5f))
+  ASSERT(test_eq(v1[1],  0.0f))
+  ASSERT(test_eq(v1[2], -0.5f))
+
+  glm_mat4_identity(m1);
+
+  glm_quatv(q1, GLM_PI_2f, GLM_ZUP);
+  GLM(quat_rotate_at)(m1, q1, (vec3){0.0f, 0.0f, 0.0f});
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.0f))
+  ASSERT(test_eq(v1[1],  0.5f))
+  ASSERT(test_eq(v1[2], -0.5f))
+
+  glm_mat4_identity(m1);
+
+  v1[0] = 1.0f;
+  v1[1] = 1.0f;
+  v1[2] = 1.0f;
+
+  glm_quatv(q1, GLM_PI_2f, GLM_XUP);
+  GLM(quat_rotate_at)(m1, q1, GLM_VEC3_ZERO);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  1.0f))
+  ASSERT(test_eq(v1[1], -1.0f))
+  ASSERT(test_eq(v1[2],  1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quat_rotate_atm) {
+  mat4   m1 = GLM_MAT4_IDENTITY_INIT;
+  versor q1;
+  vec4   v1 = {1.0f, 0.0f, 0.0f, 1.0f};
+
+  glm_quatv(q1, GLM_PI_2f, GLM_YUP);
+  GLM(quat_rotate_atm)(m1, q1, (vec3){0.5f, 0.0f, 0.0f});
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.5f))
+  ASSERT(test_eq(v1[1],  0.0f))
+  ASSERT(test_eq(v1[2], -0.5f))
+
+  glm_quatv(q1, GLM_PI_2f, GLM_ZUP);
+  GLM(quat_rotate_atm)(m1, q1, (vec3){0.0f, 0.0f, 0.0f});
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.0f))
+  ASSERT(test_eq(v1[1],  0.5f))
+  ASSERT(test_eq(v1[2], -0.5f))
+
+  v1[0] = 1.0f;
+  v1[1] = 1.0f;
+  v1[2] = 1.0f;
+
+  glm_quatv(q1, GLM_PI_2f, GLM_XUP);
+  GLM(quat_rotate_atm)(m1, q1, GLM_VEC3_ZERO);
+  glm_mat4_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  1.0f))
+  ASSERT(test_eq(v1[1], -1.0f))
+  ASSERT(test_eq(v1[2],  1.0f))
+
+  TEST_SUCCESS
+}

test/src/test_ray.h

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "test_common.h"
+
+TEST_IMPL(GLM_PREFIX, ray_triangle) {
+  /* Check whether a simple hit is recognized with the right distance */
+  vec3  origin    = { 0.0f,  0.0f,  0.0f};
+  vec3  direction = { 1.0f,  0.0f,  0.0f};
+  vec3  opposite  = {-1.0f,  0.0f,  0.0f};
+  vec3  v0        = { 5.0f, -1.0f,  1.0f};
+  vec3  v1        = { 5.0f, -1.0f, -1.0f};
+  vec3  v2        = { 5.0f,  1.0f,  0.0f};
+  float d;
+  bool  hit;
+
+  hit = GLM(ray_triangle)(origin, direction, v0, v1, v2, &d);
+  ASSERT(hit);
+  ASSERT(fabsf(d - 5.0f) <= 0.0000009);
+
+  /* Check whether a simple miss works */
+  hit = GLM(ray_triangle)(origin, opposite, v0, v1, v2, &d);
+  ASSERT(!hit);
+
+  /* Check that we can disregard distance and pass NULL pointer instead */
+  hit = GLM(ray_triangle)(origin, direction, v0, v1, v2, NULL);
+  ASSERT(hit);
+
+  TEST_SUCCESS
+}

test/src/test_vec2.h

@@ -0,0 +1,596 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "test_common.h"
+
+#ifndef CGLM_TEST_VEC2_ONCE
+#define CGLM_TEST_VEC2_ONCE
+
+/* Macros */
+
+TEST_IMPL(MACRO_GLM_VEC2_ONE_INIT) {
+  vec2 v = GLM_VEC2_ONE_INIT;
+  
+  ASSERT(test_eq(v[0], 1.0f))
+  ASSERT(test_eq(v[1], 1.0f))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(MACRO_GLM_VEC2_ZERO_INIT) {
+  vec2 v = GLM_VEC2_ZERO_INIT;
+  
+  ASSERT(test_eq(v[0], 0.0f))
+  ASSERT(test_eq(v[1], 0.0f))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(MACRO_GLM_VEC2_ONE) {
+  ASSERT(test_eq(GLM_VEC2_ONE[0], 1.0f))
+  ASSERT(test_eq(GLM_VEC2_ONE[1], 1.0f))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(MACRO_GLM_VEC2_ZERO) {
+  ASSERT(test_eq(GLM_VEC2_ZERO[0], 0.0f))
+  ASSERT(test_eq(GLM_VEC2_ZERO[0], 0.0f))
+  
+  TEST_SUCCESS
+}
+
+#endif /* CGLM_TEST_VEC2_ONCE */
+
+TEST_IMPL(GLM_PREFIX, vec2) {
+  vec4 v4 = {10.0f, 9.0f, 8.0f, 7.0f};
+  vec3 v3 = {11.0f, 12.0f, 13.0f};
+  vec2 v2;
+  
+  GLM(vec2)(v4, v2);
+  ASSERT(test_eq(v2[0], v4[0]))
+  ASSERT(test_eq(v2[1], v4[1]))
+  
+  GLM(vec2)(v3, v2);
+  ASSERT(test_eq(v2[0], v3[0]))
+  ASSERT(test_eq(v2[1], v3[1]))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_copy) {
+  vec2 v1 = {10.0f, 9.0f};
+  vec2 v2 = {1.0f, 2.0f};
+  
+  GLM(vec2_copy)(v1, v2);
+  
+  ASSERTIFY(test_assert_vec2_eq(v1, v2))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_zero) {
+  vec2 v1 = {10.0f, 9.0f};
+  vec2 v2 = {1.0f, 2.0f};
+  
+  GLM(vec2_zero)(v1);
+  GLM(vec2_zero)(v2);
+  
+  ASSERTIFY(test_assert_vec2_eq(v1, GLM_VEC2_ZERO))
+  ASSERTIFY(test_assert_vec2_eq(v2, GLM_VEC2_ZERO))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_one) {
+  vec2 v1 = {10.0f, 9.0f};
+  vec2 v2 = {1.0f, 2.0f};
+  
+  GLM(vec2_one)(v1);
+  GLM(vec2_one)(v2);
+  
+  ASSERTIFY(test_assert_vec2_eq(v1, GLM_VEC2_ONE))
+  ASSERTIFY(test_assert_vec2_eq(v2, GLM_VEC2_ONE))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_dot) {
+  vec2  a = {10.0f, 9.0f};
+  vec2  b = {1.0f, 2.0f};
+  float dot1, dot2;
+  
+  dot1 = GLM(vec2_dot)(a, b);
+  dot2 = a[0] * b[0] + a[1] * b[1];
+  
+  ASSERT(test_eq(dot1, dot2))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_cross) {
+  vec2  a = {10.0f, 9.0f};
+  vec2  b = {1.0f, 2.0f};
+  float cprod;
+
+  cprod = a[0] * b[1] - a[1] * b[0];
+
+  ASSERT(test_eq(glm_vec2_cross(a, b), cprod))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_norm2) {
+  vec2 a = {10.0f, 9.0f};
+  float n1, n2;
+  
+  n1 = GLM(vec2_norm2)(a);
+  n2 = a[0] * a[0] + a[1] * a[1];
+
+  ASSERT(test_eq(n1, n2))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_norm) {
+  vec2  a = {10.0f, 9.0f};
+  float n1, n2;
+  
+  n1 = GLM(vec2_norm)(a);
+  n2 = sqrtf(a[0] * a[0] + a[1] * a[1]);
+
+  ASSERT(test_eq(n1, n2))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_add) {
+  vec2 a = {-10.0f, 9.0f};
+  vec2 b = {12.0f, 19.0f};
+  vec2 c, d;
+  
+  c[0] = a[0] + b[0];
+  c[1] = a[1] + b[1];
+  
+  GLM(vec2_add)(a, b, d);
+  
+  ASSERTIFY(test_assert_vec2_eq(c, d))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_adds) {
+  vec4  a = {-10.0f, 9.0f};
+  vec4  c, d;
+  float s = 7.0f;
+  
+  c[0] = a[0] + s;
+  c[1] = a[1] + s;
+  
+  GLM(vec2_adds)(a, s, d);
+  
+  ASSERTIFY(test_assert_vec2_eq(c, d))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_sub) {
+  vec2 a = {-10.0f, 9.0f};
+  vec2 b = {12.0f, 19.0f};
+  vec2 c, d;
+  
+  c[0] = a[0] - b[0];
+  c[1] = a[1] - b[1];
+  
+  GLM(vec2_sub)(a, b, d);
+  
+  ASSERTIFY(test_assert_vec2_eq(c, d))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_subs) {
+  vec2  a = {-10.0f, 9.0f};
+  vec2  c, d;
+  float s = 7.0f;
+  
+  c[0] = a[0] - s;
+  c[1] = a[1] - s;
+  
+  GLM(vec2_subs)(a, s, d);
+  
+  ASSERTIFY(test_assert_vec2_eq(c, d))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_mul) {
+  vec2 v1 = {2.0f, -3.0f},
+       v2 = {-3.0f, 4.0f},
+       v3;
+  
+  GLM(vec2_mul)(v1, v2, v3);
+
+  ASSERT(test_eq(v1[0] * v2[0], v3[0]))
+  ASSERT(test_eq(v1[1] * v2[1], v3[1]))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_scale) {
+  vec2  v1 = {2.0f, -3.0f}, v2;
+  float s  = 7.0f;
+  
+  GLM(vec2_scale)(v1, s, v2);
+
+  ASSERT(test_eq(v1[0] * s, v2[0]))
+  ASSERT(test_eq(v1[1] * s, v2[1]))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_scale_as) {
+  vec2  v1 = {2.0f, -3.0f}, v2;
+  float s  = 7.0f;
+  float norm;
+
+  GLM(vec2_scale_as)(v1, s, v2);
+
+  norm = sqrtf(v1[0] * v1[0] + v1[1] * v1[1]);
+  if (norm == 0.0f) {
+    ASSERT(test_eq(v1[0], 0.0f))
+    ASSERT(test_eq(v1[1], 0.0f))
+
+    TEST_SUCCESS
+  }
+  
+  norm = s / norm;
+  
+  ASSERT(test_eq(v1[0] * norm, v2[0]))
+  ASSERT(test_eq(v1[1] * norm, v2[1]))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_div) {
+  vec2 v1 = {2.0f, -3.0f},
+       v2 = {-3.0f, 4.0f},
+       v3;
+  
+  GLM(vec2_div)(v1, v2, v3);
+
+  ASSERT(test_eq(v1[0] / v2[0], v3[0]))
+  ASSERT(test_eq(v1[1] / v2[1], v3[1]))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_divs) {
+  vec2  v1 = {2.0f, -3.0f}, v2;
+  float s  = 7.0f;
+  
+  GLM(vec2_divs)(v1, s, v2);
+
+  ASSERT(test_eq(v1[0] / s, v2[0]))
+  ASSERT(test_eq(v1[1] / s, v2[1]))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_addadd) {
+  vec2 v1 = {2.0f, -3.0f},
+       v2 = {-3.0f, 4.0f},
+       v3 = {1.0f, 2.0f},
+       v4 = {1.0f, 2.0f};
+  
+  GLM(vec2_addadd)(v1, v2, v4);
+
+  ASSERT(test_eq(v3[0] + v1[0] + v2[0], v4[0]))
+  ASSERT(test_eq(v3[1] + v1[1] + v2[1], v4[1]))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_subadd) {
+  vec2 v1 = {2.0f, -3.0f},
+       v2 = {-3.0f, 4.0f},
+       v3 = {1.0f, 2.0f},
+       v4 = {1.0f, 2.0f};
+  
+  GLM(vec2_subadd)(v1, v2, v4);
+
+  ASSERT(test_eq(v3[0] + v1[0] - v2[0], v4[0]))
+  ASSERT(test_eq(v3[1] + v1[1] - v2[1], v4[1]))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_muladd) {
+  vec2 v1 = {2.0f, -3.0f},
+       v2 = {-3.0f, 4.0f},
+       v3 = {1.0f, 2.0f},
+       v4 = {1.0f, 2.0f};
+  
+  GLM(vec2_muladd)(v1, v2, v4);
+
+  ASSERT(test_eq(v3[0] + v1[0] * v2[0], v4[0]))
+  ASSERT(test_eq(v3[1] + v1[1] * v2[1], v4[1]))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_muladds) {
+  vec2 v1 = {2.0f, -3.0f},
+       v2 = {1.0f, 2.0f},
+       v3 = {1.0f, 2.0f};
+  float s = 9.0f;
+  
+  GLM(vec2_muladds)(v1, s, v3);
+
+  ASSERT(test_eq(v2[0] + v1[0] * s, v3[0]))
+  ASSERT(test_eq(v2[1] + v1[1] * s, v3[1]))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_maxadd) {
+  vec2 v1 = {2.0f, -3.0f},
+       v2 = {-3.0f, 4.0f},
+       v3 = {1.0f, 2.0f},
+       v4 = {1.0f, 2.0f};
+  
+  GLM(vec2_maxadd)(v1, v2, v4);
+
+  ASSERT(test_eq(v3[0] + glm_max(v1[0], v2[0]), v4[0]))
+  ASSERT(test_eq(v3[1] + glm_max(v1[1], v2[1]), v4[1]))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_minadd) {
+  vec2 v1 = {2.0f, -3.0f},
+       v2 = {-3.0f, 4.0f},
+       v3 = {1.0f, 2.0f},
+       v4 = {1.0f, 2.0f};
+  
+  GLM(vec2_minadd)(v1, v2, v4);
+
+  ASSERT(test_eq(v3[0] + glm_min(v1[0], v2[0]), v4[0]))
+  ASSERT(test_eq(v3[1] + glm_min(v1[1], v2[1]), v4[1]))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_negate_to) {
+  vec2 v1 = {2.0f, -3.0f},
+       v2 = {-3.0f, 4.0f},
+       v3, v4;
+  
+  GLM(vec2_negate_to)(v1, v3);
+  GLM(vec2_negate_to)(v2, v4);
+
+  ASSERT(test_eq(-v1[0], v3[0]))
+  ASSERT(test_eq(-v1[1], v3[1]))
+  
+  ASSERT(test_eq(-v2[0], v4[0]))
+  ASSERT(test_eq(-v2[1], v4[1]))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_negate) {
+  vec2 v1 = {2.0f, -3.0f},
+       v2 = {-3.0f, 4.0f},
+       v3 = {2.0f, -3.0f},
+       v4 = {-3.0f, 4.0f};
+  
+  GLM(vec2_negate)(v1);
+  GLM(vec2_negate)(v2);
+
+  ASSERT(test_eq(-v1[0], v3[0]))
+  ASSERT(test_eq(-v1[1], v3[1]))
+  
+  ASSERT(test_eq(-v2[0], v4[0]))
+  ASSERT(test_eq(-v2[1], v4[1]))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_normalize) {
+  vec2  v1 = {2.0f, -3.0f}, v2 = {2.0f, -3.0f};
+  float s  = 1.0f;
+  float norm;
+
+  GLM(vec2_normalize)(v2);
+
+  norm = sqrtf(v1[0] * v1[0] + v1[1] * v1[1]);
+  if (norm == 0.0f) {
+    ASSERT(test_eq(v1[0], 0.0f))
+    ASSERT(test_eq(v1[1], 0.0f))
+
+    TEST_SUCCESS
+  }
+  
+  norm = s / norm;
+  
+  ASSERT(test_eq(v1[0] * norm, v2[0]))
+  ASSERT(test_eq(v1[1] * norm, v2[1]))
+
+  glm_vec2_zero(v1);
+  GLM(vec2_normalize)(v1);
+  ASSERTIFY(test_assert_vec2_eq(v1, GLM_VEC2_ZERO))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_normalize_to) {
+  vec2 v1 = {2.0f, -3.0f}, v2;
+  float s  = 1.0f;
+  float norm;
+
+  GLM(vec2_normalize_to)(v1, v2);
+
+  norm = sqrtf(v1[0] * v1[0] + v1[1] * v1[1]);
+  if (norm == 0.0f) {
+    ASSERT(test_eq(v1[0], 0.0f))
+    ASSERT(test_eq(v1[1], 0.0f))
+
+    TEST_SUCCESS
+  }
+  
+  norm = s / norm;
+  
+  ASSERT(test_eq(v1[0] * norm, v2[0]))
+  ASSERT(test_eq(v1[1] * norm, v2[1]))
+
+  glm_vec2_zero(v1);
+  GLM(vec2_normalize_to)(v1, v2);
+  ASSERTIFY(test_assert_vec2_eq(v2, GLM_VEC2_ZERO))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_rotate) {
+  vec2 v1 = {1.0f, 0.0f};
+
+  GLM(vec2_rotate)(v1, GLM_PI_2f, v1);
+
+  ASSERT(test_eq(v1[0], 0.0f))
+  ASSERT(test_eq(v1[1], 1.0f))
+
+  GLM(vec2_rotate)(v1, GLM_PI_2f, v1);
+
+  ASSERT(test_eq(v1[0], -1.0f))
+  ASSERT(test_eq(v1[1],  0.0f))
+
+  GLM(vec2_rotate)(v1, GLM_PI_2f, v1);
+
+  ASSERT(test_eq(v1[0],  0.0f))
+  ASSERT(test_eq(v1[1], -1.0f))
+
+  GLM(vec2_rotate)(v1, GLM_PI_2f, v1);
+
+  ASSERT(test_eq(v1[0], 1.0f))
+  ASSERT(test_eq(v1[1], 0.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_distance2) {
+  vec2 v1 = {30.0f, 0.0f},
+       v2 = {0.0f, 0.0f},
+       v3 = {3.0f, 10.0f},
+       v4 = {0.46f, 4.0f};
+  float d;
+
+  d = GLM(vec2_distance2)(v1, v2);
+  ASSERT(test_eq(d, 30.0f * 30.0f))
+
+  d = GLM(vec2_distance2)(v3, v4);
+  ASSERT(test_eq(powf(v3[0] - v4[0], 2.0f)
+               + powf(v3[1] - v4[1], 2.0f), d))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_distance) {
+  vec2 v1 = {30.0f, 0.0f},
+       v2 = {0.0f, 0.0f},
+       v3 = {3.0f, 10.0f},
+       v4 = {0.46f, 4.0f};
+  float d;
+
+  d = GLM(vec2_distance)(v1, v2);
+  ASSERT(test_eq(d, 30.0f))
+
+  d = GLM(vec2_distance)(v3, v4);
+  ASSERT(test_eq(sqrtf(powf(v3[0] - v4[0], 2.0f)
+                     + powf(v3[1] - v4[1], 2.0f)), d))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_maxv) {
+  vec2 v1, v2, v3;
+  vec2 v5 = {-1.456f, -1.456f};
+  vec2 v6 = {11.0f, 11.0f};
+  vec2 v7 = {78.0f, -78.0f};
+
+  GLM(vec2_maxv)(v5, v6, v1);
+  GLM(vec2_maxv)(v5, v7, v2);
+  GLM(vec2_maxv)(v6, v7, v3);
+
+  ASSERT(test_eq(v1[0], 11.0f))
+  ASSERT(test_eq(v1[1], 11.0f))
+
+  ASSERT(test_eq(v2[0], 78.0f))
+  ASSERT(test_eq(v2[1], -1.456f))
+
+  ASSERT(test_eq(v3[0], 78.0f))
+  ASSERT(test_eq(v3[1], 11.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_minv) {
+  vec2 v1, v2, v3;
+  vec2 v5 = {-1.456f, -1.456f};
+  vec2 v6 = {11.0f, 11.0f};
+  vec2 v7 = {78.0f, -78.0f};
+
+  GLM(vec2_minv)(v5, v6, v1);
+  GLM(vec2_minv)(v5, v7, v2);
+  GLM(vec2_minv)(v6, v7, v3);
+
+  ASSERT(test_eq(v1[0], -1.456f))
+  ASSERT(test_eq(v1[1], -1.456f))
+
+  ASSERT(test_eq(v2[0], -1.456f))
+  ASSERT(test_eq(v2[1], -78.0f))
+
+  ASSERT(test_eq(v3[0], 11.0f))
+  ASSERT(test_eq(v3[1], -78.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_clamp) {
+  vec2 v1 = {-1.456f, -11.456f};
+  vec2 v2 = {0.110f, 111.0f};
+  vec2 v3 = {78.0f, 32.0f};
+
+  GLM(vec2_clamp)(v1, -1.03f, 30.0f);
+  GLM(vec2_clamp)(v2,  0.11f, 111.0f);
+  GLM(vec2_clamp)(v3, -88.0f, 70.0f);
+
+  ASSERT(test_eq(v1[0], -1.03f))
+  ASSERT(test_eq(v1[1], -1.03f))
+  
+  ASSERT(test_eq(v2[0],  0.11f))
+  ASSERT(test_eq(v2[1],  111.0f))
+  
+  ASSERT(test_eq(v3[0],  70.0f))
+  ASSERT(test_eq(v3[1],  32.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_lerp) {
+  vec2 v1 = {-100.0f, -200.0f};
+  vec2 v2 = {100.0f, 200.0f};
+  vec2 v3;
+
+  GLM(vec2_lerp)(v1, v2, 0.5f, v3);
+  ASSERT(test_eq(v3[0], 0.0f))
+  ASSERT(test_eq(v3[1], 0.0f))
+  
+  GLM(vec2_lerp)(v1, v2, 0.75f, v3);
+  ASSERT(test_eq(v3[0], 50.0f))
+  ASSERT(test_eq(v3[1], 100.0f))
+
+  TEST_SUCCESS
+}

test/src/test_vec3.c

@@ -1,26 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-/* test inline mat3 */
-
-#define GLM_PREFIX glm_
-#define GLM(X) (glm_ ## X)
-
-#include "test_vec3.h"
-
-#undef GLM
-#undef GLM_PREFIX
-
-/* test pre-compiled mat3 */
-
-#define GLM_PREFIX glmc_
-#define GLM(X) (glmc_ ## X)
-
-#include "test_vec3.h"
-
-#undef GLM
-#undef GLM_PREFIX

test/src/test_vec3.h

@@ -74,6 +74,14 @@ TEST_IMPL(MACRO_GLM_XUP) {
   TEST_SUCCESS
 }
 
+TEST_IMPL(MACRO_GLM_FORWARD_RH) {
+  ASSERT(test_eq(GLM_FORWARD[0],  0.0f))
+  ASSERT(test_eq(GLM_FORWARD[1],  0.0f))
+  ASSERT(test_eq(GLM_FORWARD[2], -1.0f))
+  
+  TEST_SUCCESS
+}
+
 TEST_IMPL(MACRO_GLM_SHUFFLE3) {
   ASSERT(TEST_GLM_SHUFFLE3(1, 0, 0) == GLM_SHUFFLE3(1, 0, 0))
   ASSERT(TEST_GLM_SHUFFLE3(0, 1, 0) == GLM_SHUFFLE3(0, 1, 0))
@@ -225,7 +233,7 @@ TEST_IMPL(GLM_PREFIX, vec3_zero) {
   GLM(vec3_zero)(v2);
   
   ASSERTIFY(test_assert_vec3_eq(v1, GLM_VEC3_ZERO))
-  ASSERTIFY(test_assert_vec3_eq(v1, GLM_VEC3_ZERO))
+  ASSERTIFY(test_assert_vec3_eq(v2, GLM_VEC3_ZERO))
   
   TEST_SUCCESS
 }
@@ -327,9 +335,9 @@ TEST_IMPL(GLM_PREFIX, vec3_norm_inf) {
 }
 
 TEST_IMPL(GLM_PREFIX, vec3_add) {
-  vec4 a = {-10.0f, 9.0f, -8.0f};
+  vec3 a = {-10.0f, 9.0f, -8.0f};
-  vec4 b = {12.0f, 19.0f, -18.0f};
+  vec3 b = {12.0f, 19.0f, -18.0f};
-  vec4 c, d;
+  vec3 c, d;
   
   c[0] = a[0] + b[0];
   c[1] = a[1] + b[1];
@@ -343,8 +351,8 @@ TEST_IMPL(GLM_PREFIX, vec3_add) {
 }
 
 TEST_IMPL(GLM_PREFIX, vec3_adds) {
-  vec4  a = {-10.0f, 9.0f, -8.0f};
+  vec3  a = {-10.0f, 9.0f, -8.0f};
-  vec4  c, d;
+  vec3  c, d;
   float s = 7.0f;
   
   c[0] = a[0] + s;
@@ -359,9 +367,9 @@ TEST_IMPL(GLM_PREFIX, vec3_adds) {
 }
 
 TEST_IMPL(GLM_PREFIX, vec3_sub) {
-  vec4 a = {-10.0f, 9.0f, -8.0f};
+  vec3 a = {-10.0f, 9.0f, -8.0f};
-  vec4 b = {12.0f, 19.0f, -18.0f};
+  vec3 b = {12.0f, 19.0f, -18.0f};
-  vec4 c, d;
+  vec3 c, d;
   
   c[0] = a[0] - b[0];
   c[1] = a[1] - b[1];
@@ -375,8 +383,8 @@ TEST_IMPL(GLM_PREFIX, vec3_sub) {
 }
 
 TEST_IMPL(GLM_PREFIX, vec3_subs) {
-  vec4  a = {-10.0f, 9.0f, -8.0f};
+  vec3  a = {-10.0f, 9.0f, -8.0f};
-  vec4  c, d;
+  vec3  c, d;
   float s = 7.0f;
   
   c[0] = a[0] - s;
@@ -920,7 +928,6 @@ TEST_IMPL(GLM_PREFIX, vec3_rotate_m4) {
   TEST_SUCCESS
 }
 
-
 TEST_IMPL(GLM_PREFIX, vec3_rotate_m3) {
   vec3 v1 = {1.0f, 0.0f, 0.0f}, v2 = {1.0f, 1.0f, 1.0f};
   mat4 x0, y0, z0;

test/src/test_vec4.c

@@ -1,26 +0,0 @@
-/*
- * Copyright (c), Recep Aslantas.
- *
- * MIT License (MIT), http://opensource.org/licenses/MIT
- * Full license can be found in the LICENSE file
- */
-
-/* test inline mat3 */
-
-#define GLM_PREFIX glm_
-#define GLM(X) (glm_ ## X)
-
-#include "test_vec4.h"
-
-#undef GLM
-#undef GLM_PREFIX
-
-/* test pre-compiled mat3 */
-
-#define GLM_PREFIX glmc_
-#define GLM(X) (glmc_ ## X)
-
-#include "test_vec4.h"
-
-#undef GLM
-#undef GLM_PREFIX

test/src/test_vec4.h

@@ -217,7 +217,7 @@ TEST_IMPL(GLM_PREFIX, vec4_zero) {
   GLM(vec4_zero)(v2);
   
   ASSERTIFY(test_assert_vec4_eq(v1, GLM_VEC4_ZERO))
-  ASSERTIFY(test_assert_vec4_eq(v1, GLM_VEC4_ZERO))
+  ASSERTIFY(test_assert_vec4_eq(v2, GLM_VEC4_ZERO))
   
   TEST_SUCCESS
 }
@@ -230,7 +230,7 @@ TEST_IMPL(GLM_PREFIX, vec4_one) {
   GLM(vec4_one)(v2);
   
   ASSERTIFY(test_assert_vec4_eq(v1, GLM_VEC4_ONE))
-  ASSERTIFY(test_assert_vec4_eq(v1, GLM_VEC4_ONE))
+  ASSERTIFY(test_assert_vec4_eq(v2, GLM_VEC4_ONE))
   
   TEST_SUCCESS
 }

test/src/tests.c

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/* test inline  */
+/*---------------------------------------------------------------------------*/
+
+
+#define GLM_PREFIX glm_
+#define GLM(X) (glm_ ## X)
+
+#include "test_vec2.h"
+#include "test_vec3.h"
+#include "test_vec4.h"
+#include "test_mat2.h"
+#include "test_mat3.h"
+#include "test_mat4.h"
+#include "test_quat.h"
+#include "test_project.h"
+#include "test_plane.h"
+#include "test_affine.h"
+#include "test_affine_mat.h"
+#include "test_ray.h"
+
+#undef GLM
+#undef GLM_PREFIX
+
+/* test pre-compiled  */
+/*---------------------------------------------------------------------------*/
+
+#define GLM_PREFIX glmc_
+#define GLM(X) (glmc_ ## X)
+
+#include "test_vec2.h"
+#include "test_vec3.h"
+#include "test_vec4.h"
+#include "test_mat2.h"
+#include "test_mat3.h"
+#include "test_mat4.h"
+#include "test_quat.h"
+#include "test_project.h"
+#include "test_plane.h"
+#include "test_affine.h"
+#include "test_affine_mat.h"
+#include "test_ray.h"
+
+#undef GLM
+#undef GLM_PREFIX
+
+/*---------------------------------------------------------------------------*/

test/tests.h

@@ -16,6 +16,60 @@
  *   2. use TEST_ENTRY() to add test to list
  */
 
+/* affine mat */
+TEST_DECLARE(glm_mul)
+TEST_DECLARE(glm_mul)
+TEST_DECLARE(glm_inv_tr)
+
+TEST_DECLARE(glmc_mul)
+TEST_DECLARE(glmc_mul_rot)
+TEST_DECLARE(glmc_inv_tr)
+
+/* affine */
+TEST_DECLARE(glm_translate)
+TEST_DECLARE(glm_translate_to)
+TEST_DECLARE(glm_translate_x)
+TEST_DECLARE(glm_translate_y)
+TEST_DECLARE(glm_translate_z)
+TEST_DECLARE(glm_translate_make)
+TEST_DECLARE(glm_scale_to)
+TEST_DECLARE(glm_scale_make)
+TEST_DECLARE(glm_scale)
+TEST_DECLARE(glm_scale_uni)
+TEST_DECLARE(glm_rotate_x)
+TEST_DECLARE(glm_rotate_y)
+TEST_DECLARE(glm_rotate_z)
+TEST_DECLARE(glm_rotate_make)
+TEST_DECLARE(glm_rotate)
+TEST_DECLARE(glm_rotate_at)
+TEST_DECLARE(glm_rotate_atm)
+TEST_DECLARE(glm_decompose_scalev)
+TEST_DECLARE(glm_uniscaled)
+TEST_DECLARE(glm_decompose_rs)
+TEST_DECLARE(glm_decompose)
+
+TEST_DECLARE(glmc_translate)
+TEST_DECLARE(glmc_translate_to)
+TEST_DECLARE(glmc_translate_x)
+TEST_DECLARE(glmc_translate_y)
+TEST_DECLARE(glmc_translate_z)
+TEST_DECLARE(glmc_translate_make)
+TEST_DECLARE(glmc_scale_to)
+TEST_DECLARE(glmc_scale_make)
+TEST_DECLARE(glmc_scale)
+TEST_DECLARE(glmc_scale_uni)
+TEST_DECLARE(glmc_rotate_x)
+TEST_DECLARE(glmc_rotate_y)
+TEST_DECLARE(glmc_rotate_z)
+TEST_DECLARE(glmc_rotate_make)
+TEST_DECLARE(glmc_rotate)
+TEST_DECLARE(glmc_rotate_at)
+TEST_DECLARE(glmc_rotate_atm)
+TEST_DECLARE(glmc_decompose_scalev)
+TEST_DECLARE(glmc_uniscaled)
+TEST_DECLARE(glmc_decompose_rs)
+TEST_DECLARE(glmc_decompose)
+
 /* mat4 */
 TEST_DECLARE(glm_mat4_ucopy)
 TEST_DECLARE(glm_mat4_copy)
@@ -70,8 +124,6 @@ TEST_DECLARE(glmc_mat4_swap_col)
 TEST_DECLARE(glmc_mat4_swap_row)
 TEST_DECLARE(glmc_mat4_rmc)
 
-TEST_DECLARE(affine)
-
 /* mat3 */
 TEST_DECLARE(glm_mat3_copy)
 TEST_DECLARE(glm_mat3_identity)
@@ -107,6 +159,42 @@ TEST_DECLARE(glmc_mat3_swap_col)
 TEST_DECLARE(glmc_mat3_swap_row)
 TEST_DECLARE(glmc_mat3_rmc)
 
+TEST_DECLARE(MACRO_GLM_MAT2_IDENTITY_INIT)
+TEST_DECLARE(MACRO_GLM_MAT2_ZERO_INIT)
+TEST_DECLARE(MACRO_GLM_MAT2_IDENTITY)
+TEST_DECLARE(MACRO_GLM_MAT2_ZERO)
+TEST_DECLARE(glm_mat2_copy)
+TEST_DECLARE(glm_mat2_identity)
+TEST_DECLARE(glm_mat2_identity_array)
+TEST_DECLARE(glm_mat2_zero)
+TEST_DECLARE(glm_mat2_mul)
+TEST_DECLARE(glm_mat2_transpose_to)
+TEST_DECLARE(glm_mat2_transpose)
+TEST_DECLARE(glm_mat2_mulv)
+TEST_DECLARE(glm_mat2_trace)
+TEST_DECLARE(glm_mat2_scale)
+TEST_DECLARE(glm_mat2_det)
+TEST_DECLARE(glm_mat2_inv)
+TEST_DECLARE(glm_mat2_swap_col)
+TEST_DECLARE(glm_mat2_swap_row)
+TEST_DECLARE(glm_mat2_rmc)
+
+TEST_DECLARE(glmc_mat2_copy)
+TEST_DECLARE(glmc_mat2_identity)
+TEST_DECLARE(glmc_mat2_identity_array)
+TEST_DECLARE(glmc_mat2_zero)
+TEST_DECLARE(glmc_mat2_mul)
+TEST_DECLARE(glmc_mat2_transpose_to)
+TEST_DECLARE(glmc_mat2_transpose)
+TEST_DECLARE(glmc_mat2_mulv)
+TEST_DECLARE(glmc_mat2_trace)
+TEST_DECLARE(glmc_mat2_scale)
+TEST_DECLARE(glmc_mat2_det)
+TEST_DECLARE(glmc_mat2_inv)
+TEST_DECLARE(glmc_mat2_swap_col)
+TEST_DECLARE(glmc_mat2_swap_row)
+TEST_DECLARE(glmc_mat2_rmc)
+
 /* camera */
 TEST_DECLARE(camera_lookat)
 TEST_DECLARE(camera_decomp)
@@ -120,14 +208,21 @@ TEST_DECLARE(glmc_unprojecti)
 TEST_DECLARE(glmc_unproject)
 TEST_DECLARE(glmc_project)
 
+/* plane */
+TEST_DECLARE(glm_plane_normalize)
+TEST_DECLARE(glmc_plane_normalize)
+
 /* utils */
 TEST_DECLARE(clamp)
 
 /* euler */
 TEST_DECLARE(euler)
 
+/* ray */
+TEST_DECLARE(glm_ray_triangle)
+TEST_DECLARE(glmc_ray_triangle)
+
 /* quat */
-TEST_DECLARE(quat)
 TEST_DECLARE(MACRO_GLM_QUAT_IDENTITY_INIT)
 TEST_DECLARE(MACRO_GLM_QUAT_IDENTITY)
 
@@ -160,6 +255,12 @@ TEST_DECLARE(glm_quat_lerp)
 TEST_DECLARE(glm_quat_lerpc)
 TEST_DECLARE(glm_quat_slerp)
 TEST_DECLARE(glm_quat_look)
+TEST_DECLARE(glm_quat_for)
+TEST_DECLARE(glm_quat_forp)
+TEST_DECLARE(glm_quat_rotatev)
+TEST_DECLARE(glm_quat_rotate)
+TEST_DECLARE(glm_quat_rotate_at)
+TEST_DECLARE(glm_quat_rotate_atm)
 
 TEST_DECLARE(glmc_quat_identity)
 TEST_DECLARE(glmc_quat_identity_array)
@@ -190,10 +291,95 @@ TEST_DECLARE(glmc_quat_lerp)
 TEST_DECLARE(glmc_quat_lerpc)
 TEST_DECLARE(glmc_quat_slerp)
 TEST_DECLARE(glmc_quat_look)
+TEST_DECLARE(glmc_quat_for)
+TEST_DECLARE(glmc_quat_forp)
+TEST_DECLARE(glmc_quat_rotatev)
+TEST_DECLARE(glmc_quat_rotate)
+TEST_DECLARE(glmc_quat_rotate_at)
+TEST_DECLARE(glmc_quat_rotate_atm)
 
 /* bezier */
 TEST_DECLARE(bezier)
 
+
+/* Macros */
+
+TEST_DECLARE(MACRO_GLM_VEC2_ONE_INIT)
+TEST_DECLARE(MACRO_GLM_VEC2_ZERO_INIT)
+TEST_DECLARE(MACRO_GLM_VEC2_ONE)
+TEST_DECLARE(MACRO_GLM_VEC2_ZERO)
+
+TEST_DECLARE(glm_vec2)
+TEST_DECLARE(glm_vec2_copy)
+TEST_DECLARE(glm_vec2_zero)
+TEST_DECLARE(glm_vec2_one)
+TEST_DECLARE(glm_vec2_dot)
+TEST_DECLARE(glm_vec2_cross)
+TEST_DECLARE(glm_vec2_norm2)
+TEST_DECLARE(glm_vec2_norm)
+TEST_DECLARE(glm_vec2_add)
+TEST_DECLARE(glm_vec2_adds)
+TEST_DECLARE(glm_vec2_sub)
+TEST_DECLARE(glm_vec2_subs)
+TEST_DECLARE(glm_vec2_mul)
+TEST_DECLARE(glm_vec2_scale)
+TEST_DECLARE(glm_vec2_scale_as)
+TEST_DECLARE(glm_vec2_div)
+TEST_DECLARE(glm_vec2_divs)
+TEST_DECLARE(glm_vec2_addadd)
+TEST_DECLARE(glm_vec2_subadd)
+TEST_DECLARE(glm_vec2_muladd)
+TEST_DECLARE(glm_vec2_muladds)
+TEST_DECLARE(glm_vec2_maxadd)
+TEST_DECLARE(glm_vec2_minadd)
+TEST_DECLARE(glm_vec2_negate_to)
+TEST_DECLARE(glm_vec2_negate)
+TEST_DECLARE(glm_vec2_normalize)
+TEST_DECLARE(glm_vec2_normalize_to)
+TEST_DECLARE(glm_vec2_rotate)
+TEST_DECLARE(glm_vec2_distance2)
+TEST_DECLARE(glm_vec2_distance)
+TEST_DECLARE(glm_vec2_maxv)
+TEST_DECLARE(glm_vec2_minv)
+TEST_DECLARE(glm_vec2_clamp)
+TEST_DECLARE(glm_vec2_lerp)
+
+
+TEST_DECLARE(glmc_vec2)
+TEST_DECLARE(glmc_vec2_copy)
+TEST_DECLARE(glmc_vec2_zero)
+TEST_DECLARE(glmc_vec2_one)
+TEST_DECLARE(glmc_vec2_dot)
+TEST_DECLARE(glmc_vec2_cross)
+TEST_DECLARE(glmc_vec2_norm2)
+TEST_DECLARE(glmc_vec2_norm)
+TEST_DECLARE(glmc_vec2_add)
+TEST_DECLARE(glmc_vec2_adds)
+TEST_DECLARE(glmc_vec2_sub)
+TEST_DECLARE(glmc_vec2_subs)
+TEST_DECLARE(glmc_vec2_mul)
+TEST_DECLARE(glmc_vec2_scale)
+TEST_DECLARE(glmc_vec2_scale_as)
+TEST_DECLARE(glmc_vec2_div)
+TEST_DECLARE(glmc_vec2_divs)
+TEST_DECLARE(glmc_vec2_addadd)
+TEST_DECLARE(glmc_vec2_subadd)
+TEST_DECLARE(glmc_vec2_muladd)
+TEST_DECLARE(glmc_vec2_muladds)
+TEST_DECLARE(glmc_vec2_maxadd)
+TEST_DECLARE(glmc_vec2_minadd)
+TEST_DECLARE(glmc_vec2_negate_to)
+TEST_DECLARE(glmc_vec2_negate)
+TEST_DECLARE(glmc_vec2_normalize)
+TEST_DECLARE(glmc_vec2_normalize_to)
+TEST_DECLARE(glmc_vec2_rotate)
+TEST_DECLARE(glmc_vec2_distance2)
+TEST_DECLARE(glmc_vec2_distance)
+TEST_DECLARE(glmc_vec2_maxv)
+TEST_DECLARE(glmc_vec2_minv)
+TEST_DECLARE(glmc_vec2_clamp)
+TEST_DECLARE(glmc_vec2_lerp)
+
 /* vec3 */
 TEST_DECLARE(MACRO_GLM_VEC3_ONE_INIT)
 TEST_DECLARE(MACRO_GLM_VEC3_ZERO_INIT)
@@ -202,6 +388,7 @@ TEST_DECLARE(MACRO_GLM_VEC3_ZERO)
 TEST_DECLARE(MACRO_GLM_YUP)
 TEST_DECLARE(MACRO_GLM_ZUP)
 TEST_DECLARE(MACRO_GLM_XUP)
+TEST_DECLARE(MACRO_GLM_FORWARD_RH)
 TEST_DECLARE(MACRO_GLM_SHUFFLE3)
 TEST_DECLARE(MACRO_GLM_XXX)
 TEST_DECLARE(MACRO_GLM_YYY)
@@ -520,6 +707,60 @@ TEST_DECLARE(vec4s_zero_init)
 /*****************************************************************************/
 
 TEST_LIST {
+  /* affine mat */
+  TEST_ENTRY(glm_mul)
+  TEST_ENTRY(glm_mul)
+  TEST_ENTRY(glm_inv_tr)
+
+  TEST_ENTRY(glmc_mul)
+  TEST_ENTRY(glmc_mul_rot)
+  TEST_ENTRY(glmc_inv_tr)
+
+  /* affine */
+  TEST_ENTRY(glm_translate)
+  TEST_ENTRY(glm_translate_to)
+  TEST_ENTRY(glm_translate_x)
+  TEST_ENTRY(glm_translate_y)
+  TEST_ENTRY(glm_translate_z)
+  TEST_ENTRY(glm_translate_make)
+  TEST_ENTRY(glm_scale_to)
+  TEST_ENTRY(glm_scale_make)
+  TEST_ENTRY(glm_scale)
+  TEST_ENTRY(glm_scale_uni)
+  TEST_ENTRY(glm_rotate_x)
+  TEST_ENTRY(glm_rotate_y)
+  TEST_ENTRY(glm_rotate_z)
+  TEST_ENTRY(glm_rotate_make)
+  TEST_ENTRY(glm_rotate)
+  TEST_ENTRY(glm_rotate_at)
+  TEST_ENTRY(glm_rotate_atm)
+  TEST_ENTRY(glm_decompose_scalev)
+  TEST_ENTRY(glm_uniscaled)
+  TEST_ENTRY(glm_decompose_rs)
+  TEST_ENTRY(glm_decompose)
+
+  TEST_ENTRY(glmc_translate)
+  TEST_ENTRY(glmc_translate_to)
+  TEST_ENTRY(glmc_translate_x)
+  TEST_ENTRY(glmc_translate_y)
+  TEST_ENTRY(glmc_translate_z)
+  TEST_ENTRY(glmc_translate_make)
+  TEST_ENTRY(glmc_scale_to)
+  TEST_ENTRY(glmc_scale_make)
+  TEST_ENTRY(glmc_scale)
+  TEST_ENTRY(glmc_scale_uni)
+  TEST_ENTRY(glmc_rotate_x)
+  TEST_ENTRY(glmc_rotate_y)
+  TEST_ENTRY(glmc_rotate_z)
+  TEST_ENTRY(glmc_rotate_make)
+  TEST_ENTRY(glmc_rotate)
+  TEST_ENTRY(glmc_rotate_at)
+  TEST_ENTRY(glmc_rotate_atm)
+  TEST_ENTRY(glmc_decompose_scalev)
+  TEST_ENTRY(glmc_uniscaled)
+  TEST_ENTRY(glmc_decompose_rs)
+  TEST_ENTRY(glmc_decompose)
+
   /* mat4 */
   TEST_ENTRY(glm_mat4_ucopy)
   TEST_ENTRY(glm_mat4_copy)
@@ -574,8 +815,6 @@ TEST_LIST {
   TEST_ENTRY(glmc_mat4_swap_row)
   TEST_ENTRY(glmc_mat4_rmc)
   
-  TEST_ENTRY(affine)
-  
   /* mat3 */
   TEST_ENTRY(glm_mat3_copy)
   TEST_ENTRY(glm_mat3_identity)
@@ -611,6 +850,42 @@ TEST_LIST {
   TEST_ENTRY(glmc_mat3_swap_row)
   TEST_ENTRY(glmc_mat3_rmc)
   
+  TEST_ENTRY(MACRO_GLM_MAT2_IDENTITY_INIT)
+  TEST_ENTRY(MACRO_GLM_MAT2_ZERO_INIT)
+  TEST_ENTRY(MACRO_GLM_MAT2_IDENTITY)
+  TEST_ENTRY(MACRO_GLM_MAT2_ZERO)
+  TEST_ENTRY(glm_mat2_copy)
+  TEST_ENTRY(glm_mat2_identity)
+  TEST_ENTRY(glm_mat2_identity_array)
+  TEST_ENTRY(glm_mat2_zero)
+  TEST_ENTRY(glm_mat2_mul)
+  TEST_ENTRY(glm_mat2_transpose_to)
+  TEST_ENTRY(glm_mat2_transpose)
+  TEST_ENTRY(glm_mat2_mulv)
+  TEST_ENTRY(glm_mat2_trace)
+  TEST_ENTRY(glm_mat2_scale)
+  TEST_ENTRY(glm_mat2_det)
+  TEST_ENTRY(glm_mat2_inv)
+  TEST_ENTRY(glm_mat2_swap_col)
+  TEST_ENTRY(glm_mat2_swap_row)
+  TEST_ENTRY(glm_mat2_rmc)
+
+  TEST_ENTRY(glmc_mat2_copy)
+  TEST_ENTRY(glmc_mat2_identity)
+  TEST_ENTRY(glmc_mat2_identity_array)
+  TEST_ENTRY(glmc_mat2_zero)
+  TEST_ENTRY(glmc_mat2_mul)
+  TEST_ENTRY(glmc_mat2_transpose_to)
+  TEST_ENTRY(glmc_mat2_transpose)
+  TEST_ENTRY(glmc_mat2_mulv)
+  TEST_ENTRY(glmc_mat2_trace)
+  TEST_ENTRY(glmc_mat2_scale)
+  TEST_ENTRY(glmc_mat2_det)
+  TEST_ENTRY(glmc_mat2_inv)
+  TEST_ENTRY(glmc_mat2_swap_col)
+  TEST_ENTRY(glmc_mat2_swap_row)
+  TEST_ENTRY(glmc_mat2_rmc)
+
   /* camera */
   TEST_ENTRY(camera_lookat)
   TEST_ENTRY(camera_decomp)
@@ -624,14 +899,21 @@ TEST_LIST {
   TEST_ENTRY(glmc_unproject)
   TEST_ENTRY(glmc_project)
   
+  /* plane */
+  TEST_ENTRY(glm_plane_normalize)
+  TEST_ENTRY(glmc_plane_normalize)
+  
   /* utils */
   TEST_ENTRY(clamp)
   
   /* euler */
   TEST_ENTRY(euler)
   
+  /* ray */
+  TEST_ENTRY(glm_ray_triangle)
+  TEST_ENTRY(glmc_ray_triangle)
+
   /* quat */
-  TEST_ENTRY(quat)
   TEST_ENTRY(MACRO_GLM_QUAT_IDENTITY_INIT)
   TEST_ENTRY(MACRO_GLM_QUAT_IDENTITY)
 
@@ -664,6 +946,12 @@ TEST_LIST {
   TEST_ENTRY(glm_quat_lerpc)
   TEST_ENTRY(glm_quat_slerp)
   TEST_ENTRY(glm_quat_look)
+  TEST_ENTRY(glm_quat_for)
+  TEST_ENTRY(glm_quat_forp)
+  TEST_ENTRY(glm_quat_rotatev)
+  TEST_ENTRY(glm_quat_rotate)
+  TEST_ENTRY(glm_quat_rotate_at)
+  TEST_ENTRY(glm_quat_rotate_atm)
 
   TEST_ENTRY(glmc_quat_identity)
   TEST_ENTRY(glmc_quat_identity_array)
@@ -694,10 +982,93 @@ TEST_LIST {
   TEST_ENTRY(glmc_quat_lerpc)
   TEST_ENTRY(glmc_quat_slerp)
   TEST_ENTRY(glmc_quat_look)
+  TEST_ENTRY(glmc_quat_for)
+  TEST_ENTRY(glmc_quat_forp)
+  TEST_ENTRY(glmc_quat_rotatev)
+  TEST_ENTRY(glmc_quat_rotate)
+  TEST_ENTRY(glmc_quat_rotate_at)
+  TEST_ENTRY(glmc_quat_rotate_atm)
 
   /* bezier */
   TEST_ENTRY(bezier)
 
+  /* Macros */
+
+  TEST_ENTRY(MACRO_GLM_VEC2_ONE_INIT)
+  TEST_ENTRY(MACRO_GLM_VEC2_ZERO_INIT)
+  TEST_ENTRY(MACRO_GLM_VEC2_ONE)
+  TEST_ENTRY(MACRO_GLM_VEC2_ZERO)
+  
+  TEST_ENTRY(glm_vec2)
+  TEST_ENTRY(glm_vec2_copy)
+  TEST_ENTRY(glm_vec2_zero)
+  TEST_ENTRY(glm_vec2_one)
+  TEST_ENTRY(glm_vec2_dot)
+  TEST_ENTRY(glm_vec2_cross)
+  TEST_ENTRY(glm_vec2_norm2)
+  TEST_ENTRY(glm_vec2_norm)
+  TEST_ENTRY(glm_vec2_add)
+  TEST_ENTRY(glm_vec2_adds)
+  TEST_ENTRY(glm_vec2_sub)
+  TEST_ENTRY(glm_vec2_subs)
+  TEST_ENTRY(glm_vec2_mul)
+  TEST_ENTRY(glm_vec2_scale)
+  TEST_ENTRY(glm_vec2_scale_as)
+  TEST_ENTRY(glm_vec2_div)
+  TEST_ENTRY(glm_vec2_divs)
+  TEST_ENTRY(glm_vec2_addadd)
+  TEST_ENTRY(glm_vec2_subadd)
+  TEST_ENTRY(glm_vec2_muladd)
+  TEST_ENTRY(glm_vec2_muladds)
+  TEST_ENTRY(glm_vec2_maxadd)
+  TEST_ENTRY(glm_vec2_minadd)
+  TEST_ENTRY(glm_vec2_negate_to)
+  TEST_ENTRY(glm_vec2_negate)
+  TEST_ENTRY(glm_vec2_normalize)
+  TEST_ENTRY(glm_vec2_normalize_to)
+  TEST_ENTRY(glm_vec2_rotate)
+  TEST_ENTRY(glm_vec2_distance2)
+  TEST_ENTRY(glm_vec2_distance)
+  TEST_ENTRY(glm_vec2_maxv)
+  TEST_ENTRY(glm_vec2_minv)
+  TEST_ENTRY(glm_vec2_clamp)
+  TEST_ENTRY(glm_vec2_lerp)
+
+  TEST_ENTRY(glmc_vec2)
+  TEST_ENTRY(glmc_vec2_copy)
+  TEST_ENTRY(glmc_vec2_zero)
+  TEST_ENTRY(glmc_vec2_one)
+  TEST_ENTRY(glmc_vec2_dot)
+  TEST_ENTRY(glmc_vec2_cross)
+  TEST_ENTRY(glmc_vec2_norm2)
+  TEST_ENTRY(glmc_vec2_norm)
+  TEST_ENTRY(glmc_vec2_add)
+  TEST_ENTRY(glmc_vec2_adds)
+  TEST_ENTRY(glmc_vec2_sub)
+  TEST_ENTRY(glmc_vec2_subs)
+  TEST_ENTRY(glmc_vec2_mul)
+  TEST_ENTRY(glmc_vec2_scale)
+  TEST_ENTRY(glmc_vec2_scale_as)
+  TEST_ENTRY(glmc_vec2_div)
+  TEST_ENTRY(glmc_vec2_divs)
+  TEST_ENTRY(glmc_vec2_addadd)
+  TEST_ENTRY(glmc_vec2_subadd)
+  TEST_ENTRY(glmc_vec2_muladd)
+  TEST_ENTRY(glmc_vec2_muladds)
+  TEST_ENTRY(glmc_vec2_maxadd)
+  TEST_ENTRY(glmc_vec2_minadd)
+  TEST_ENTRY(glmc_vec2_negate_to)
+  TEST_ENTRY(glmc_vec2_negate)
+  TEST_ENTRY(glmc_vec2_normalize)
+  TEST_ENTRY(glmc_vec2_normalize_to)
+  TEST_ENTRY(glmc_vec2_rotate)
+  TEST_ENTRY(glmc_vec2_distance2)
+  TEST_ENTRY(glmc_vec2_distance)
+  TEST_ENTRY(glmc_vec2_maxv)
+  TEST_ENTRY(glmc_vec2_minv)
+  TEST_ENTRY(glmc_vec2_clamp)
+  TEST_ENTRY(glmc_vec2_lerp)
+
   /* vec3 */
 
   /* Macros */
@@ -709,6 +1080,7 @@ TEST_LIST {
   TEST_ENTRY(MACRO_GLM_YUP)
   TEST_ENTRY(MACRO_GLM_ZUP)
   TEST_ENTRY(MACRO_GLM_XUP)
+  TEST_ENTRY(MACRO_GLM_FORWARD_RH)
   TEST_ENTRY(MACRO_GLM_SHUFFLE3)
   TEST_ENTRY(MACRO_GLM_XXX)
   TEST_ENTRY(MACRO_GLM_YYY)

win/cglm-test.vcxproj

@@ -20,29 +20,29 @@
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="..\test\runner.c" />
-    <ClCompile Include="..\test\src\test_affine.c" />
+    <ClCompile Include="..\test\src\tests.c" />
     <ClCompile Include="..\test\src\test_bezier.c" />
     <ClCompile Include="..\test\src\test_cam.c" />
     <ClCompile Include="..\test\src\test_clamp.c" />
     <ClCompile Include="..\test\src\test_common.c" />
     <ClCompile Include="..\test\src\test_euler.c" />
-    <ClCompile Include="..\test\src\test_mat3.c" />
-    <ClCompile Include="..\test\src\test_mat4.c" />
-    <ClCompile Include="..\test\src\test_project.c" />
-    <ClCompile Include="..\test\src\test_quat.c" />
     <ClCompile Include="..\test\src\test_struct.c" />
-    <ClCompile Include="..\test\src\test_vec3.c" />
-    <ClCompile Include="..\test\src\test_vec4.c" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\test\include\common.h" />
+    <ClInclude Include="..\test\src\test_affine.h" />
+    <ClInclude Include="..\test\src\test_affine_mat.h" />
     <ClInclude Include="..\test\src\test_common.h" />
+    <ClInclude Include="..\test\src\test_mat2.h" />
     <ClInclude Include="..\test\src\test_mat3.h" />
     <ClInclude Include="..\test\src\test_mat4.h" />
+    <ClInclude Include="..\test\src\test_plane.h" />
     <ClInclude Include="..\test\src\test_project.h" />
     <ClInclude Include="..\test\src\test_quat.h" />
+    <ClInclude Include="..\test\src\test_vec2.h" />
     <ClInclude Include="..\test\src\test_vec3.h" />
     <ClInclude Include="..\test\src\test_vec4.h" />
+    <ClInclude Include="..\test\src\test_ray.h" />
     <ClInclude Include="..\test\tests.h" />
   </ItemGroup>
   <ItemGroup>

win/cglm-test.vcxproj.filters

@@ -14,9 +14,6 @@
     <ClCompile Include="..\test\runner.c">
       <Filter>src</Filter>
     </ClCompile>
-    <ClCompile Include="..\test\src\test_affine.c">
-      <Filter>src</Filter>
-    </ClCompile>
     <ClCompile Include="..\test\src\test_bezier.c">
       <Filter>src</Filter>
     </ClCompile>
@@ -32,27 +29,12 @@
     <ClCompile Include="..\test\src\test_euler.c">
       <Filter>src</Filter>
     </ClCompile>
-    <ClCompile Include="..\test\src\test_mat3.c">
-      <Filter>src</Filter>
-    </ClCompile>
-    <ClCompile Include="..\test\src\test_mat4.c">
-      <Filter>src</Filter>
-    </ClCompile>
-    <ClCompile Include="..\test\src\test_project.c">
-      <Filter>src</Filter>
-    </ClCompile>
-    <ClCompile Include="..\test\src\test_quat.c">
-      <Filter>src</Filter>
-    </ClCompile>
-    <ClCompile Include="..\test\src\test_vec3.c">
-      <Filter>src</Filter>
-    </ClCompile>
-    <ClCompile Include="..\test\src\test_vec4.c">
-      <Filter>src</Filter>
-    </ClCompile>
     <ClCompile Include="..\test\src\test_struct.c">
       <Filter>src</Filter>
     </ClCompile>
+    <ClCompile Include="..\test\src\tests.c">
+      <Filter>src</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\test\tests.h">
@@ -82,5 +64,23 @@
     <ClInclude Include="..\test\src\test_vec4.h">
       <Filter>src</Filter>
     </ClInclude>
+    <ClInclude Include="..\test\src\test_affine.h">
+      <Filter>src</Filter>
+    </ClInclude>
+    <ClInclude Include="..\test\src\test_affine_mat.h">
+      <Filter>src</Filter>
+    </ClInclude>
+    <ClInclude Include="..\test\src\test_mat2.h">
+      <Filter>src</Filter>
+    </ClInclude>
+    <ClInclude Include="..\test\src\test_plane.h">
+      <Filter>src</Filter>
+    </ClInclude>
+    <ClInclude Include="..\test\src\test_vec2.h">
+      <Filter>src</Filter>
+    </ClInclude>
+    <ClInclude Include="..\test\src\test_ray.h">
+      <Filter>src</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>

win/cglm.vcxproj

@@ -28,18 +28,22 @@
     <ClCompile Include="..\src\euler.c" />
     <ClCompile Include="..\src\frustum.c" />
     <ClCompile Include="..\src\io.c" />
+    <ClCompile Include="..\src\mat2.c" />
     <ClCompile Include="..\src\mat3.c" />
     <ClCompile Include="..\src\mat4.c" />
     <ClCompile Include="..\src\plane.c" />
     <ClCompile Include="..\src\project.c" />
     <ClCompile Include="..\src\quat.c" />
+    <ClCompile Include="..\src\ray.c" />
     <ClCompile Include="..\src\sphere.c" />
+    <ClCompile Include="..\src\vec2.c" />
     <ClCompile Include="..\src\vec3.c" />
     <ClCompile Include="..\src\vec4.c" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\include\cglm\affine-mat.h" />
     <ClInclude Include="..\include\cglm\affine.h" />
+    <ClInclude Include="..\include\cglm\applesimd.h" />
     <ClInclude Include="..\include\cglm\bezier.h" />
     <ClInclude Include="..\include\cglm\box.h" />
     <ClInclude Include="..\include\cglm\call.h" />
@@ -52,12 +56,15 @@
     <ClInclude Include="..\include\cglm\call\euler.h" />
     <ClInclude Include="..\include\cglm\call\frustum.h" />
     <ClInclude Include="..\include\cglm\call\io.h" />
+    <ClInclude Include="..\include\cglm\call\mat2.h" />
     <ClInclude Include="..\include\cglm\call\mat3.h" />
     <ClInclude Include="..\include\cglm\call\mat4.h" />
     <ClInclude Include="..\include\cglm\call\plane.h" />
     <ClInclude Include="..\include\cglm\call\project.h" />
     <ClInclude Include="..\include\cglm\call\quat.h" />
+    <ClInclude Include="..\include\cglm\call\ray.h" />
     <ClInclude Include="..\include\cglm\call\sphere.h" />
+    <ClInclude Include="..\include\cglm\call\vec2.h" />
     <ClInclude Include="..\include\cglm\call\vec3.h" />
     <ClInclude Include="..\include\cglm\call\vec4.h" />
     <ClInclude Include="..\include\cglm\cam.h" />
@@ -69,17 +76,20 @@
     <ClInclude Include="..\include\cglm\euler.h" />
     <ClInclude Include="..\include\cglm\frustum.h" />
     <ClInclude Include="..\include\cglm\io.h" />
+    <ClInclude Include="..\include\cglm\mat2.h" />
     <ClInclude Include="..\include\cglm\mat3.h" />
     <ClInclude Include="..\include\cglm\mat4.h" />
     <ClInclude Include="..\include\cglm\plane.h" />
     <ClInclude Include="..\include\cglm\project.h" />
     <ClInclude Include="..\include\cglm\quat.h" />
+    <ClInclude Include="..\include\cglm\ray.h" />
     <ClInclude Include="..\include\cglm\simd\arm.h" />
     <ClInclude Include="..\include\cglm\simd\avx\affine.h" />
     <ClInclude Include="..\include\cglm\simd\avx\mat4.h" />
     <ClInclude Include="..\include\cglm\simd\intrin.h" />
     <ClInclude Include="..\include\cglm\simd\neon\mat4.h" />
     <ClInclude Include="..\include\cglm\simd\sse2\affine.h" />
+    <ClInclude Include="..\include\cglm\simd\sse2\mat2.h" />
     <ClInclude Include="..\include\cglm\simd\sse2\mat3.h" />
     <ClInclude Include="..\include\cglm\simd\sse2\mat4.h" />
     <ClInclude Include="..\include\cglm\simd\sse2\quat.h" />
@@ -94,12 +104,15 @@
     <ClInclude Include="..\include\cglm\struct\euler.h" />
     <ClInclude Include="..\include\cglm\struct\frustum.h" />
     <ClInclude Include="..\include\cglm\struct\io.h" />
+    <ClInclude Include="..\include\cglm\struct\mat2.h" />
     <ClInclude Include="..\include\cglm\struct\mat3.h" />
     <ClInclude Include="..\include\cglm\struct\mat4.h" />
     <ClInclude Include="..\include\cglm\struct\plane.h" />
     <ClInclude Include="..\include\cglm\struct\project.h" />
     <ClInclude Include="..\include\cglm\struct\quat.h" />
     <ClInclude Include="..\include\cglm\struct\sphere.h" />
+    <ClInclude Include="..\include\cglm\struct\vec2-ext.h" />
+    <ClInclude Include="..\include\cglm\struct\vec2.h" />
     <ClInclude Include="..\include\cglm\struct\vec3-ext.h" />
     <ClInclude Include="..\include\cglm\struct\vec3.h" />
     <ClInclude Include="..\include\cglm\struct\vec4-ext.h" />
@@ -107,6 +120,8 @@
     <ClInclude Include="..\include\cglm\types-struct.h" />
     <ClInclude Include="..\include\cglm\types.h" />
     <ClInclude Include="..\include\cglm\util.h" />
+    <ClInclude Include="..\include\cglm\vec2-ext.h" />
+    <ClInclude Include="..\include\cglm\vec2.h" />
     <ClInclude Include="..\include\cglm\vec3-ext.h" />
     <ClInclude Include="..\include\cglm\vec3.h" />
     <ClInclude Include="..\include\cglm\vec4-ext.h" />

win/cglm.vcxproj.filters

@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup>
     <Filter Include="Header Files">
@@ -86,6 +86,15 @@
     <ClCompile Include="..\src\bezier.c">
       <Filter>src</Filter>
     </ClCompile>
+    <ClCompile Include="..\src\mat2.c">
+      <Filter>src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\vec2.c">
+      <Filter>src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\ray.c">
+      <Filter>src</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\src\config.h">
@@ -118,6 +127,9 @@
     <ClInclude Include="..\include\cglm\call\vec4.h">
       <Filter>include\cglm\call</Filter>
     </ClInclude>
+    <ClInclude Include="..\include\cglm\call\ray.h">
+      <Filter>include\cglm\call</Filter>
+    </ClInclude>
     <ClInclude Include="..\include\cglm\simd\avx\affine.h">
       <Filter>include\cglm\simd\avx</Filter>
     </ClInclude>
@@ -235,6 +247,9 @@
     <ClInclude Include="..\include\cglm\ease.h">
       <Filter>include\cglm</Filter>
     </ClInclude>
+    <ClInclude Include="..\include\cglm\ray.h">
+      <Filter>include\cglm</Filter>
+    </ClInclude>
     <ClInclude Include="..\include\cglm\simd\arm.h">
       <Filter>include\cglm\simd</Filter>
     </ClInclude>
@@ -253,6 +268,9 @@
     <ClInclude Include="..\include\cglm\call\bezier.h">
       <Filter>include\cglm\call</Filter>
     </ClInclude>
+    <ClInclude Include="..\include\cglm\vec2.h">
+      <Filter>include\cglm</Filter>
+    </ClInclude>
     <ClInclude Include="..\include\cglm\struct\affine.h">
       <Filter>include\cglm\struct</Filter>
     </ClInclude>
@@ -313,5 +331,32 @@
     <ClInclude Include="..\include\cglm\types-struct.h">
       <Filter>include\cglm</Filter>
     </ClInclude>
+    <ClInclude Include="..\include\cglm\call\mat2.h">
+      <Filter>include\cglm\call</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\call\vec2.h">
+      <Filter>include\cglm\call</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\struct\mat2.h">
+      <Filter>include\cglm\struct</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\applesimd.h">
+      <Filter>include\cglm</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\mat2.h">
+      <Filter>include\cglm</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\vec2-ext.h">
+      <Filter>include\cglm</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\struct\vec2.h">
+      <Filter>include\cglm\struct</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\struct\vec2-ext.h">
+      <Filter>include\cglm\struct</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\simd\sse2\mat2.h">
+      <Filter>include\cglm\simd\sse2</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>