2d: add documentation for 2D Affine Transforms

mat3_mulv: function behaviour to match with mat4

.gitignore

@@ -73,3 +73,5 @@ cglm-test-ios*
 test-driver
 Default-568h@2x.png
 build/
+conftest.dir/*
+confdefs.h

.travis.yml

@@ -4,6 +4,12 @@ os:
   - linux
   - osx
 
+arch:
+  - amd64
+  - ppc64le
+  - s390x
+  - arm64
+
 sudo: required
 dist: trusty
 

.vscode/settings.json

@@ -0,0 +1,4 @@
+{
+  "C_Cpp.default.configurationProvider": "vector-of-bool.cmake-tools",
+  "restructuredtext.confPath": "${workspaceFolder}/docs/source"
+}

CMakeLists.txt

@@ -1,8 +1,9 @@
 cmake_minimum_required(VERSION 3.8.2)
-project(cglm LANGUAGES C)
+project(cglm VERSION 0.7.7 LANGUAGES C)
 
-set(C_STANDARD 11)
+set(CMAKE_C_STANDARD 11)
-set(C_STANDARD_REQUIRED YES)
+set(CMAKE_C_STANDARD_REQUIRED YES)
+set(DEFAULT_BUILD_TYPE "Release")
 
 set(CGLM_BUILD)
 option(CGLM_SHARED "Shared build" ON)
@@ -21,125 +22,35 @@ if(CGLM_USE_C99)
 endif()
 
 if(MSVC)
-	add_definitions(-DNDEBUG -D_WINDOWS -D_USRDLL -DCGLM_EXPORTS -DCGLM_DLL)
+  add_definitions(-DNDEBUG -D_WINDOWS -D_USRDLL -DCGLM_EXPORTS -DCGLM_DLL)
-	add_compile_options("/W3" "/Ox" "/Gy" "/Oi" "/TC" "/analyze")
+  add_compile_options(/W3 /Ox /Gy /Oi /TC)
+  
+  # Ref: https://skia.googlesource.com/third_party/sdl/+/refs/heads/master/CMakeLists.txt#225
+  # Make sure /RTC1 is disabled, otherwise it will use functions from the CRT
+  foreach(flag_var
+      CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE
+      CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO)
+    string(REGEX REPLACE "/RTC(su|[1su])" "" ${flag_var} "${${flag_var}}")
+  endforeach(flag_var)
 else()
-    add_compile_options("-Wall" "-Werror" "-std=gnu11" "-O3")
+  add_compile_options(-Wall -Werror -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
+if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
-  include/cglm/version.h
+  message(STATUS "Setting build type to '${DEFAULT_BUILD_TYPE}' as none was specified.")
-  include/cglm/common.h
+  set(CMAKE_BUILD_TYPE "${DEFAULT_BUILD_TYPE}" CACHE STRING "Choose the type of build." FORCE)
-  include/cglm/types.h
+  # Set the possible values of build type for cmake-gui
-  include/cglm/types-struct.h
+  set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
-  include/cglm/cglm.h
+endif()
-  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(GNUInstallDirs)
-  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
+set(CPACK_PROJECT_NAME ${PROJECT_NAME})
-  include/cglm/simd/intrin.h
+set(CPACK_PROJECT_VERSION ${PROJECT_VERSION})
-  include/cglm/simd/x86.h
+include(CPack)
-  include/cglm/simd/arm.h
-  )
 
-set(HEADERS_SIMD_SSE2
+# Target Start
-  include/cglm/simd/sse2/affine.h
+add_library(${PROJECT_NAME}
-  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
@@ -161,32 +72,45 @@ add_library(cglm
   src/curve.c
   src/bezier.c
   src/ray.c
+  src/affine2d.c
   )
 
-target_include_directories(cglm PUBLIC
+set_target_properties(${PROJECT_NAME} PROPERTIES
-  ${CMAKE_CURRENT_SOURCE_DIR}/include
+                              VERSION ${PROJECT_VERSION} 
+                            SOVERSION ${PROJECT_VERSION_MAJOR})
+
+target_include_directories(${PROJECT_NAME}
+    PUBLIC 
+        $<INSTALL_INTERFACE:include>    
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+    PRIVATE
+        ${CMAKE_CURRENT_SOURCE_DIR}/src
 )
 
-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)
+  include(CTest)
   enable_testing()
   add_subdirectory(test)
 endif()
+
+# Install 
+install(TARGETS ${PROJECT_NAME}
+        EXPORT  ${PROJECT_NAME}
+        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+        RUNTIME DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+install(DIRECTORY include/${PROJECT_NAME} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+        PATTERN ".*" EXCLUDE)
+
+# Config
+export(TARGETS ${PROJECT_NAME}
+       NAMESPACE ${PROJECT_NAME}::
+       FILE "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake"
+)
+
+install(EXPORT      ${PROJECT_NAME}
+        NAMESPACE   ${PROJECT_NAME}::
+        DESTINATION ${CMAKE_INSTALL_LIBDIR}/${PROJECT_NAME}/cmake)
+

Makefile.am

@@ -12,7 +12,6 @@ AM_CFLAGS = -Wall \
             -O3 \
             -Wstrict-aliasing=2 \
             -fstrict-aliasing \
-            -pedantic \
             -Werror=strict-prototypes
 
 lib_LTLIBRARIES = libcglm.la
@@ -22,7 +21,10 @@ checkLDFLAGS = -L./.libs \
                -lm \
                -lcglm
 checkCFLAGS = $(AM_CFLAGS) \
-              -I./include
+               -std=gnu11 \
+               -O3 \
+               -DCGLM_DEFINE_PRINTS \
+               -I./include
 
 check_PROGRAMS = test/tests
 TESTS = $(check_PROGRAMS)
@@ -64,7 +66,8 @@ cglm_HEADERS = include/cglm/version.h \
                include/cglm/curve.h \
                include/cglm/bezier.h \
                include/cglm/applesimd.h \
-               include/cglm/ray.h
+               include/cglm/ray.h \
+               include/cglm/affine2d.h
 
 cglm_calldir=$(includedir)/cglm/call
 cglm_call_HEADERS = include/cglm/call/mat4.h \
@@ -86,7 +89,8 @@ cglm_call_HEADERS = include/cglm/call/mat4.h \
                     include/cglm/call/ease.h \
                     include/cglm/call/curve.h \
                     include/cglm/call/bezier.h \
-                    include/cglm/call/ray.h
+                    include/cglm/call/ray.h \
+                    include/cglm/call/affine2d.h
 
 cglm_simddir=$(includedir)/cglm/simd
 cglm_simd_HEADERS = include/cglm/simd/intrin.h \
@@ -150,7 +154,8 @@ libcglm_la_SOURCES=\
     src/ease.c \
     src/curve.c \
     src/bezier.c \
-    src/ray.c
+    src/ray.c \
+    src/affine2d.c
 
 test_tests_SOURCES=\
     test/runner.c \

README.md

@@ -179,6 +179,8 @@ target_link_libraries(${LIBRARY_NAME} PRIVATE
   cglm)
 
 add_subdirectory(external/cglm/)
+
+# or you can use find_package to configure cglm
 ```
 
 ### Unix (Autotools)

cglm.podspec

@@ -2,7 +2,7 @@ Pod::Spec.new do |s|
 
   # Description
   s.name         = "cglm"
-  s.version      = "0.6.1"
+  s.version      = "0.7.2"
   s.summary      = "📽 Optimized OpenGL/Graphics Math (glm) for C"
   s.description  = <<-DESC
 cglm is math library for graphics programming for C. It is similar to original glm but it is written for C instead of C++ (you can use here too). See the documentation or README for all features.

configure.ac

@@ -7,7 +7,7 @@
 #*****************************************************************************
 
 AC_PREREQ([2.69])
-AC_INIT([cglm], [0.7.2], [info@recp.me])
+AC_INIT([cglm], [0.7.7], [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/affine-mat.rst

@@ -1,6 +1,6 @@
 .. default-domain:: C
 
-affine transform matrix (specialized functions)
+3D Affine Transform Matrix (specialized functions)
 ================================================================================
 
 Header: cglm/affine-mat.h

docs/source/affine.rst

@@ -1,6 +1,6 @@
 .. default-domain:: C
 
-affine transforms
+3D Affine Transforms
 ================================================================================
 
 Header: cglm/affine.h
@@ -45,6 +45,8 @@ The implementation would be:
   glm_rotate(m, angle, axis);
   glm_translate(m, pivotInv); /* pivotInv = -pivot */
 
+.. _TransformsOrder:
+
 Transforms Order
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

docs/source/affine2d.rst

@@ -0,0 +1,140 @@
+.. default-domain:: C
+
+2D Affine Transforms
+================================================================================
+
+Header: cglm/affine2d.h
+
+2D Transforms uses `2d` suffix for naming. If there is no 2D suffix it is 3D function.
+
+Initialize Transform Matrices
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Functions with **_make** prefix expect you don't have a matrix and they create
+a matrix for you. You don't need to pass identity matrix.
+
+But other functions expect you have a matrix and you want to transform them. If
+you didn't have any existing matrix you have to initialize matrix to identity
+before sending to transfrom functions.
+
+Transforms Order
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+See :ref:`TransformsOrder` to read similar section.
+
+
+Table of contents (click to go):
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Functions:
+
+1. :c:func:`glm_translate2d`
+#. :c:func:`glm_translate2d_to`
+#. :c:func:`glm_translate2d_x`
+#. :c:func:`glm_translate2d_y`
+#. :c:func:`glm_translate2d_make`
+#. :c:func:`glm_scale2d_to`
+#. :c:func:`glm_scale2d_make`
+#. :c:func:`glm_scale2d`
+#. :c:func:`glm_scale2d_uni`
+#. :c:func:`glm_rotate2d_make`
+#. :c:func:`glm_rotate2d`
+#. :c:func:`glm_rotate2d_to`
+
+.. c:function:: void glm_translate2d(mat3 m, vec2 v)
+
+    translate existing 2d transform matrix by *v* vector and stores result in same matrix
+
+    Parameters:
+      | *[in, out]*  **m**    2d affine transfrom
+      | *[in]*       **v**    translate vector [x, y]
+
+.. c:function:: void glm_translate2d_to(mat3 m, vec2 v, mat3 dest)
+
+    translate existing 2d transform matrix by *v* vector and store result in dest
+
+    Parameters:
+      | *[in]*  **m**    2d affine transfrom
+      | *[in]*  **v**    translate vector [x, y]
+      | *[out]* **dest** translated matrix
+
+.. c:function:: void glm_translate2d_x(mat3 m, float x)
+
+    translate existing 2d transform matrix by x factor
+
+    Parameters:
+      | *[in, out]*  **m**    2d affine transfrom
+      | *[in]*       **x**    x factor
+
+.. c:function:: void glm_translate2d_y(mat3 m, float y)
+
+    translate existing 2d transform matrix by y factor
+
+    Parameters:
+      | *[in, out]*  **m**    2d affine transfrom
+      | *[in]*       **y**    y factor
+
+.. c:function:: void glm_translate2d_make(mat3 m, vec2 v)
+
+    creates NEW translate 2d transform matrix by *v* vector
+
+    Parameters:
+      | *[in, out]*  **m**    affine transfrom
+      | *[in]*       **v**    translate vector [x, y]
+
+.. c:function:: void glm_scale2d_to(mat3 m, vec2 v, mat3 dest)
+
+    scale existing 2d transform matrix by *v* vector and store result in dest
+
+    Parameters:
+      | *[in]*  **m**    affine transfrom
+      | *[in]*  **v**    scale vector [x, y]
+      | *[out]* **dest** scaled matrix
+
+.. c:function:: void glm_scale2d_make(mat3 m, vec2 v)
+
+    creates NEW 2d scale matrix by *v* vector
+
+    Parameters:
+      | *[in, out]*  **m**    affine transfrom
+      | *[in]*       **v**    scale vector [x, y]
+
+.. c:function:: void glm_scale2d(mat3 m, vec2 v)
+
+    scales existing 2d transform matrix by *v* vector and stores result in same matrix
+
+    Parameters:
+      | *[in, out]*  **m**    affine transfrom
+      | *[in]*       **v**    translate vector [x, y]
+
+.. c:function:: void glm_scale2d_uni(mat3 m, float s)
+
+    applies uniform scale to existing 2d transform matrix v = [s, s] and stores result in same matrix
+
+    Parameters:
+      | *[in, out]*  **m**  affine transfrom
+      | *[in]*       **s**  scale factor
+
+.. c:function:: void glm_rotate2d_make(mat3 m, float angle)
+
+    creates NEW rotation matrix by angle around *Z* axis
+
+    Parameters:
+      | *[in, out]*  **m**      affine transfrom
+      | *[in]*       **angle**  angle (radians)
+
+.. c:function:: void glm_rotate2d(mat3 m, float angle)
+
+    rotate existing 2d transform matrix around *Z* axis by angle and store result in same matrix
+
+    Parameters:
+      | *[in, out]*  **m**      affine transfrom
+      | *[in]*       **angle**  angle (radians)
+
+.. c:function:: void glm_rotate2d_to(mat3 m, float angle, mat3 dest)
+
+    rotate existing 2d transform matrix around *Z* axis by angle and store result in dest
+
+    Parameters:
+      | *[in]*  **m**      affine transfrom
+      | *[in]*  **angle**  angle (radians)
+      | *[out]* **dest**   rotated matrix

docs/source/api.rst

@@ -28,6 +28,7 @@ Follow the :doc:`build` documentation for this
 
    affine
    affine-mat
+   affine2d
    cam
    frustum
    box

docs/source/build.rst

@@ -7,6 +7,46 @@ Build cglm
 If you only need to inline versions, you don't need to build **cglm**, you don't need to link it to your program.
 Just import cglm to your project as dependency / external lib by copy-paste then use it as usual
 
+CMake (All platforms):
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. code-block:: bash
+  :linenos:
+
+  $ mkdir build
+  $ cd build
+  $ cmake .. # [Optional] -DCGLM_SHARED=ON
+  $ make
+  $ sudo make install # [Optional]
+
+**make** will build cglm to **build** folder.
+If you don't want to install **cglm** to your system's folder you can get static and dynamic libs in this folder.
+
+**CMake Options:**
+
+.. code-block:: CMake
+  :linenos:
+
+  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**
+
+.. code-block:: CMake
+  :linenos:
+
+  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):
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

docs/source/conf.py

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

docs/source/features.rst

@@ -1,10 +1,11 @@
 Features
 ================================================================================
 
+* array api and struct api, you can use arrays or structs.
 * general purpose matrix operations (mat4, mat3)
 * chain matrix multiplication (square only)
 * general purpose vector operations (cross, dot, rotate, proj, angle...)
-* affine transforms
+* affine transformations
 * matrix decomposition (extract rotation, scaling factor)
 * optimized affine transform matrices (mul, rigid-body inverse)
 * camera (lookat)
@@ -20,4 +21,6 @@ Features
 * easing functions
 * curves
 * curve interpolation helpers (SMC, deCasteljau...)
-* and other...
+* 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...

docs/source/io.rst

@@ -28,6 +28,23 @@ Example to print mat4 matrix:
 (you probably will in some cases), you can change it temporary.
 cglm may provide precision parameter in the future
 
+Changes since **v0.7.3**:
+* Now mis-alignment of columns are fixed: larger numbers are printed via %g and others are printed via %f. Column withs are calculated before print.
+* Now values are colorful ;)
+* Some print improvements
+* New options with default values:
+
+.. code-block:: c
+
+    #define CGLM_PRINT_PRECISION    5
+    #define CGLM_PRINT_MAX_TO_SHORT 1e5
+    #define CGLM_PRINT_COLOR        "\033[36m"
+    #define CGLM_PRINT_COLOR_RESET  "\033[0m"
+
+* Inline prints are only enabled in DEBUG mode and if **CGLM_DEFINE_PRINTS** is defined.
+
+Check options page.
+
 Table of contents (click to go):
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

docs/source/mat4.rst

@@ -156,16 +156,22 @@ Functions documentation
     Parameters:
       | *[in]*  **m**     mat4 (left)
       | *[in]*  **v**     vec4 (right, column vector)
+      | *[in]*  **last**  4th item to make it vec4
       | *[out]* **dest**  vec4 (result, column vector)
 
-.. c:function:: void  glm_mat4_mulv3(mat4 m, vec3 v, vec3 dest)
+.. c:function:: void  glm_mat4_mulv3(mat4 m, vec3 v, float last, vec3 dest)
 
-    multiply vector with mat4's mat3 part(rotation)
+    | multiply **vec3** with **mat4** and get **vec3** as result
+    |
+    | actually the result is **vec4**, after multiplication, 
+      the last component is trimmed, if you need the result's last component 
+      then don't use this function and consider to use **glm_mat4_mulv()**
 
     Parameters:
-    | *[in]*  **m**     mat4 (left)
+      | *[in]*  **m**     mat4(affine transform)
-    | *[in]*  **v**     vec3 (right, column vector)
+      | *[in]*  **v**     vec3
-    | *[out]* **dest**  vec3 (result, column vector)
+      | *[in]*  **last**  4th item to make it vec4
+      | *[out]* **dest**  result vector (vec3)
 
 .. c:function:: void  glm_mat4_trace(mat4 m)
 

docs/source/opt.rst

@@ -50,3 +50,24 @@ You have to extra options for dot product: **CGLM_SSE4_DOT** and **CGLM_SSE3_DOT
 - If **SSE3** is enabled then you can define **CGLM_SSE3_DOT** to force cglm to use **_mm_hadd_ps** instructions.
 
 otherwise cglm will use custom cglm's hadd functions which are optimized too.
+
+Print Options
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+1. **CGLM_DEFINE_PRINTS**
+2. **CGLM_NO_PRINTS_NOOP**
+
+Inline prints are only enabled in DEBUG mode and if **CGLM_DEFINE_PRINTS** is defined.
+If DEBUG is not enabled then print function bodies will be emptied to eliminate print function calls.
+You can disable this feature too by defining **CGLM_NO_PRINTS_NOOP** macro top of cglm headers.
+
+3. **CGLM_PRINT_PRECISION**    5
+
+precision.
+
+4. **CGLM_PRINT_MAX_TO_SHORT** 1e5
+
+if a number is greater than this value then %g will be used, since this is shorten print you won't be able to see high precision.
+
+5. **CGLM_PRINT_COLOR**        "\033[36m"
+6. **CGLM_PRINT_COLOR_RESET**  "\033[0m"

docs/source/troubleshooting.rst

@@ -80,6 +80,19 @@ So be carefull, when your IDE (Xcode, Visual Studio ...) tried to autocomplete f
 
 **Also implementation may be wrong please let us know by creating an issue on Github.**
 
+BAD_ACCESS : Thread 1: EXC_BAD_ACCESS (code=EXC_I386_GPFLT) or Similar Errors/Crashes
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+This is similar issue with alignment. For instance if you compiled **cglm** with 
+AVX (**-mavx**, intentionally or not) and if you use **cglm** in an environment that doesn't 
+support AVX (or if AVX is disabled intentionally) e.g. environment that max support SSE2/3/4, 
+then you probably get **BAD ACCESS** or similar...
+
+Because if you compile **cglm** with AVX it aligns **mat4** with 32 byte boundary, 
+and your project aligns that as 16 byte boundary...
+
+Check alignment, supported vector extension or simd in **cglm** and linked projects...
+
 Other Issues?
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

include/cglm/affine2d.h

@@ -0,0 +1,268 @@
+/*
+ * 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_translate2d(mat3 m, vec2 v)
+   CGLM_INLINE void glm_translate2d_to(mat3 m, vec2 v, mat3 dest)
+   CGLM_INLINE void glm_translate2d_x(mat3 m, float x)
+   CGLM_INLINE void glm_translate2d_y(mat3 m, float y)
+   CGLM_INLINE void glm_translate2d_make(mat3 m, vec2 v)
+   CGLM_INLINE void glm_scale2d_to(mat3 m, vec2 v, mat3 dest)
+   CGLM_INLINE void glm_scale2d_make(mat3 m, vec2 v)
+   CGLM_INLINE void glm_scale2d(mat3 m, vec2 v)
+   CGLM_INLINE void glm_scale2d_uni(mat3 m, float s)
+   CGLM_INLINE void glm_rotate2d_make(mat3 m, float angle)
+   CGLM_INLINE void glm_rotate2d(mat3 m, float angle)
+   CGLM_INLINE void glm_rotate2d_to(mat3 m, float angle, mat3 dest)
+ */
+
+#ifndef cglm_affine2d_h
+#define cglm_affine2d_h
+
+#include "common.h"
+#include "util.h"
+#include "vec2.h"
+#include "mat3.h"
+
+/*!
+ * @brief translate existing 2d transform matrix by v vector
+ *        and stores result in same matrix
+ *
+ * @param[in, out]  m  affine transfrom
+ * @param[in]       v  translate vector [x, y]
+ */
+CGLM_INLINE
+void
+glm_translate2d(mat3 m, vec2 v) {
+  m[2][0] = m[0][0] * v[0] + m[1][0] * v[1] + m[2][0];
+  m[2][1] = m[0][1] * v[0] + m[1][1] * v[1] + m[2][1];
+  m[2][2] = m[0][2] * v[0] + m[1][2] * v[1] + m[2][2];
+}
+
+/*!
+ * @brief translate existing 2d transform matrix by v vector
+ *        and store result in dest
+ *
+ * source matrix will remain same
+ *
+ * @param[in]  m    affine transfrom
+ * @param[in]  v    translate vector [x, y]
+ * @param[out] dest translated matrix
+ */
+CGLM_INLINE
+void
+glm_translate2d_to(mat3 m, vec2 v, mat3 dest) {
+  glm_mat3_copy(m, dest);
+  glm_translate2d(dest, v);
+}
+
+/*!
+ * @brief translate existing 2d transform matrix by x factor
+ *
+ * @param[in, out]  m  affine transfrom
+ * @param[in]       x  x factor
+ */
+CGLM_INLINE
+void
+glm_translate2d_x(mat3 m, float x) {
+  m[2][0] = m[0][0] * x + m[2][0];
+  m[2][1] = m[0][1] * x + m[2][1];
+  m[2][2] = m[0][2] * x + m[2][2];
+}
+
+/*!
+ * @brief translate existing 2d transform matrix by y factor
+ *
+ * @param[in, out]  m  affine transfrom
+ * @param[in]       y  y factor
+ */
+CGLM_INLINE
+void
+glm_translate2d_y(mat3 m, float y) {
+  m[2][0] = m[1][0] * y + m[2][0];
+  m[2][1] = m[1][1] * y + m[2][1];
+  m[2][2] = m[1][2] * y + m[2][2];
+}
+
+/*!
+ * @brief creates NEW translate 2d transform matrix by v vector
+ *
+ * @param[out]  m  affine transfrom
+ * @param[in]   v  translate vector [x, y]
+ */
+CGLM_INLINE
+void
+glm_translate2d_make(mat3 m, vec2 v) {
+  glm_mat3_identity(m);
+  m[2][0] = v[0];
+  m[2][1] = v[1];
+}
+
+/*!
+ * @brief scale existing 2d transform matrix by v vector
+ *        and store result in dest
+ *
+ * @param[in]  m    affine transfrom
+ * @param[in]  v    scale vector [x, y]
+ * @param[out] dest scaled matrix
+ */
+CGLM_INLINE
+void
+glm_scale2d_to(mat3 m, vec2 v, mat3 dest) {
+  dest[0][0] = m[0][0] * v[0];
+  dest[0][1] = m[0][1] * v[0];
+  dest[0][2] = m[0][2] * v[0];
+  
+  dest[1][0] = m[1][0] * v[1];
+  dest[1][1] = m[1][1] * v[1];
+  dest[1][2] = m[1][2] * v[1];
+  
+  dest[2][0] = m[2][0];
+  dest[2][1] = m[2][1];
+  dest[2][2] = m[2][2];
+}
+
+/*!
+ * @brief creates NEW 2d scale matrix by v vector
+ *
+ * @param[out]  m  affine transfrom
+ * @param[in]   v  scale vector [x, y]
+ */
+CGLM_INLINE
+void
+glm_scale2d_make(mat3 m, vec2 v) {
+  glm_mat3_identity(m);
+  m[0][0] = v[0];
+  m[1][1] = v[1];
+}
+
+/*!
+ * @brief scales existing 2d transform matrix by v vector
+ *        and stores result in same matrix
+ *
+ * @param[in, out]  m  affine transfrom
+ * @param[in]       v  scale vector [x, y]
+ */
+CGLM_INLINE
+void
+glm_scale2d(mat3 m, vec2 v) {
+  m[0][0] = m[0][0] * v[0];
+  m[0][1] = m[0][1] * v[0];
+  m[0][2] = m[0][2] * v[0];
+
+  m[1][0] = m[1][0] * v[1];
+  m[1][1] = m[1][1] * v[1];
+  m[1][2] = m[1][2] * v[1];
+}
+
+/*!
+ * @brief applies uniform scale to existing 2d transform matrix v = [s, s]
+ *        and stores result in same matrix
+ *
+ * @param[in, out]  m  affine transfrom
+ * @param[in]       s  scale factor
+ */
+CGLM_INLINE
+void
+glm_scale2d_uni(mat3 m, float s) {
+  m[0][0] = m[0][0] * s;
+  m[0][1] = m[0][1] * s;
+  m[0][2] = m[0][2] * s;
+
+  m[1][0] = m[1][0] * s;
+  m[1][1] = m[1][1] * s;
+  m[1][2] = m[1][2] * s;
+}
+
+/*!
+ * @brief creates NEW rotation matrix by angle around Z axis
+ *
+ * @param[out] m     affine transfrom
+ * @param[in]  angle angle (radians)
+ */
+CGLM_INLINE
+void
+glm_rotate2d_make(mat3 m, float angle) {
+  float c, s;
+
+  s = sinf(angle);
+  c = cosf(angle);
+  
+  m[0][0] = c;
+  m[0][1] = s;
+  m[0][2] = 0;
+
+  m[1][0] = -s;
+  m[1][1] = c;
+  m[1][2] = 0;
+  
+  m[2][0] = 0.0f;
+  m[2][1] = 0.0f;
+  m[2][2] = 1.0f;
+}
+
+/*!
+ * @brief rotate existing 2d transform matrix around Z axis by angle
+ *         and store result in same matrix
+ *
+ * @param[in, out]  m      affine transfrom
+ * @param[in]       angle  angle (radians)
+ */
+CGLM_INLINE
+void
+glm_rotate2d(mat3 m, float angle) {
+  float m00 = m[0][0],  m10 = m[1][0],
+        m01 = m[0][1],  m11 = m[1][1],
+        m02 = m[0][2],  m12 = m[1][2];
+  float c, s;
+
+  s = sinf(angle);
+  c = cosf(angle);
+  
+  m[0][0] = m00 * c + m10 * s;
+  m[0][1] = m01 * c + m11 * s;
+  m[0][2] = m02 * c + m12 * s;
+
+  m[1][0] = m00 * -s + m10 * c;
+  m[1][1] = m01 * -s + m11 * c;
+  m[1][2] = m02 * -s + m12 * c;
+}
+
+/*!
+ * @brief rotate existing 2d transform matrix around Z axis by angle
+ *        and store result in dest
+ *
+ * @param[in]  m      affine transfrom
+ * @param[in]  angle  angle (radians)
+ * @param[out] dest   destination
+ */
+CGLM_INLINE
+void
+glm_rotate2d_to(mat3 m, float angle, mat3 dest) {
+  float m00 = m[0][0],  m10 = m[1][0],
+        m01 = m[0][1],  m11 = m[1][1],
+        m02 = m[0][2],  m12 = m[1][2];
+  float c, s;
+
+  s = sinf(angle);
+  c = cosf(angle);
+  
+  dest[0][0] = m00 * c + m10 * s;
+  dest[0][1] = m01 * c + m11 * s;
+  dest[0][2] = m02 * c + m12 * s;
+
+  dest[1][0] = m00 * -s + m10 * c;
+  dest[1][1] = m01 * -s + m11 * c;
+  dest[1][2] = m02 * -s + m12 * c;
+  
+  dest[2][0] = m[2][0];
+  dest[2][1] = m[2][1];
+  dest[2][2] = m[2][2];
+}
+
+#endif /* cglm_affine2d_h */

include/cglm/call.h

@@ -32,6 +32,7 @@ extern "C" {
 #include "call/curve.h"
 #include "call/bezier.h"
 #include "call/ray.h"
+#include "call/affine2d.h"
 
 #ifdef __cplusplus
 }

include/cglm/call/affine2d.h

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglmc_affine2d_h
+#define cglmc_affine2d_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../cglm.h"
+
+CGLM_EXPORT
+void
+glmc_translate2d_make(mat3 m, vec2 v);
+
+CGLM_EXPORT
+void
+glmc_translate2d_to(mat3 m, vec2 v, mat3 dest);
+
+CGLM_EXPORT
+void
+glmc_translate2d(mat3 m, vec2 v);
+
+CGLM_EXPORT
+void
+glmc_translate2d_x(mat3 m, float to);
+
+CGLM_EXPORT
+void
+glmc_translate2d_y(mat3 m, float to);
+
+CGLM_EXPORT
+void
+glmc_scale2d_to(mat3 m, vec2 v, mat3 dest);
+
+CGLM_EXPORT
+void
+glmc_scale2d_make(mat3 m, vec2 v);
+
+CGLM_EXPORT
+void
+glmc_scale2d(mat3 m, vec2 v);
+
+CGLM_EXPORT
+void
+glmc_scale2d_uni(mat3 m, float s);
+
+CGLM_EXPORT
+void
+glmc_rotate2d_make(mat3 m, float angle);
+
+CGLM_EXPORT
+void
+glmc_rotate2d(mat3 m, float angle);
+
+CGLM_EXPORT
+void
+glmc_rotate2d_to(mat3 m, float angle, mat3 dest);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* cglmc_affine2d_h */

include/cglm/call/io.h

@@ -7,6 +7,7 @@
 
 #ifndef cglmc_io_h
 #define cglmc_io_h
+
 #ifdef __cplusplus
 extern "C" {
 #endif

include/cglm/cglm.h

@@ -31,5 +31,6 @@
 #include "curve.h"
 #include "bezier.h"
 #include "ray.h"
+#include "affine2d.h"
 
 #endif /* cglm_h */

include/cglm/common.h

@@ -8,7 +8,13 @@
 #ifndef cglm_common_h
 #define cglm_common_h
 
-#define _USE_MATH_DEFINES /* for windows */
+#ifndef _USE_MATH_DEFINES
+#  define _USE_MATH_DEFINES       /* for windows */
+#endif
+
+#ifndef _CRT_SECURE_NO_WARNINGS
+#  define _CRT_SECURE_NO_WARNINGS /* for windows */
+#endif
 
 #include <stdint.h>
 #include <stddef.h>
@@ -34,4 +40,12 @@
 #include "types.h"
 #include "simd/intrin.h"
 
+#ifndef CGLM_USE_DEFAULT_EPSILON
+#  ifndef GLM_FLT_EPSILON
+#    define GLM_FLT_EPSILON 1e-6
+#  endif
+#else
+#  define GLM_FLT_EPSILON FLT_EPSILON
+#endif
+
 #endif /* cglm_common_h */

include/cglm/euler.h

@@ -55,8 +55,6 @@ typedef enum glm_euler_seq {
   GLM_EULER_ZYX = 2 << 0 | 1 << 2 | 0 << 4
 } glm_euler_seq;
 
-typedef glm_euler_seq glm_euler_sq;
-
 CGLM_INLINE
 glm_euler_seq
 glm_euler_order(int ord[3]) {

include/cglm/io.h

@@ -17,67 +17,99 @@
 
 #ifndef cglm_io_h
 #define cglm_io_h
+#if defined(DEBUG) || defined(_DEBUG) \
+   || defined(CGLM_DEFINE_PRINTS) || defined(CGLM_LIB_SRC)
 
 #include "common.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 
+#define CGLM_PRINT_PRECISION    5
+#define CGLM_PRINT_MAX_TO_SHORT 1e5
+#define CGLM_PRINT_COLOR        "\033[36m"
+#define CGLM_PRINT_COLOR_RESET  "\033[0m"
+
 CGLM_INLINE
 void
 glm_mat4_print(mat4              matrix,
                FILE * __restrict ostream) {
-  int i;
+  char buff[16];
-  int j;
+  int  i, j, cw[4], cwi;
 
 #define m 4
 #define n 4
 
-  fprintf(ostream, "Matrix (float%dx%d):\n", m, n);
+  fprintf(ostream, "Matrix (float%dx%d): " CGLM_PRINT_COLOR "\n" , m, n);
+
+  cw[0] = cw[1] = cw[2] = cw[3] = 0;
 
   for (i = 0; i < m; i++) {
-    fprintf(ostream, "\t|");
     for (j = 0; j < n; j++) {
-      fprintf(ostream, "%0.4f", matrix[j][i]);;
+      if (matrix[i][j] < CGLM_PRINT_MAX_TO_SHORT)
-
+        cwi = sprintf(buff, "% .*f", CGLM_PRINT_PRECISION, matrix[i][j]);
-      if (j != n - 1)
+      else
-        fprintf(ostream, "\t");
+        cwi = sprintf(buff, "% g", matrix[i][j]);
+      cw[i] = GLM_MAX(cw[i], cwi);
     }
-
-    fprintf(ostream, "|\n");
   }
 
-  fprintf(ostream, "\n");
+  for (i = 0; i < m; i++) {
+    fprintf(ostream, "  |");
+
+    for (j = 0; j < n; j++)
+      if (matrix[i][j] < CGLM_PRINT_MAX_TO_SHORT)
+        fprintf(ostream, " % *.*f", cw[j], CGLM_PRINT_PRECISION, matrix[j][i]);
+      else
+        fprintf(ostream, " % *g", cw[j], matrix[j][i]);
+
+    fprintf(ostream, "  |\n");
+  }
+
+  fprintf(ostream, CGLM_PRINT_COLOR_RESET "\n");
 
 #undef m
 #undef n
 }
 
+
 CGLM_INLINE
 void
 glm_mat3_print(mat3              matrix,
                FILE * __restrict ostream) {
-  int i;
+  char buff[16];
-  int j;
+  int  i, j, cw[4], cwi;
 
 #define m 3
 #define n 3
 
-  fprintf(ostream, "Matrix (float%dx%d):\n", m, n);
+  fprintf(ostream, "Matrix (float%dx%d): " CGLM_PRINT_COLOR "\n", m, n);
+
+  cw[0] = cw[1] = cw[2] = 0;
 
   for (i = 0; i < m; i++) {
-    fprintf(ostream, "\t|");
     for (j = 0; j < n; j++) {
-      fprintf(ostream, "%0.4f", matrix[j][i]);;
+      if (matrix[i][j] < CGLM_PRINT_MAX_TO_SHORT)
-
+        cwi = sprintf(buff, "% .*f", CGLM_PRINT_PRECISION, matrix[i][j]);
-      if (j != n - 1)
+      else
-        fprintf(ostream, "\t");
+        cwi = sprintf(buff, "% g", matrix[i][j]);
+      cw[i] = GLM_MAX(cw[i], cwi);
     }
-
-    fprintf(ostream, "|\n");
   }
 
-  fprintf(ostream, "\n");
+  for (i = 0; i < m; i++) {
+    fprintf(ostream, "  |");
+    
+    for (j = 0; j < n; j++)
+      if (matrix[i][j] < CGLM_PRINT_MAX_TO_SHORT)
+        fprintf(ostream, " % *.*f", cw[j], CGLM_PRINT_PRECISION, matrix[j][i]);
+      else
+        fprintf(ostream, " % *g", cw[j], matrix[j][i]);
+    
+    fprintf(ostream, "  |\n");
+  }
+
+  fprintf(ostream, CGLM_PRINT_COLOR_RESET "\n");
 
 #undef m
 #undef n
@@ -87,27 +119,39 @@ CGLM_INLINE
 void
 glm_mat2_print(mat2              matrix,
                FILE * __restrict ostream) {
-  int i;
+  char buff[16];
-  int j;
+  int  i, j, cw[4], cwi;
 
 #define m 2
 #define n 2
 
-  fprintf(ostream, "Matrix (float%dx%d):\n", m, n);
+  fprintf(ostream, "Matrix (float%dx%d): " CGLM_PRINT_COLOR "\n", m, n);
+
+  cw[0] = cw[1] = 0;
 
   for (i = 0; i < m; i++) {
-    fprintf(ostream, "\t|");
     for (j = 0; j < n; j++) {
-      fprintf(ostream, "%0.4f", matrix[j][i]);;
+      if (matrix[i][j] < CGLM_PRINT_MAX_TO_SHORT)
-
+        cwi = sprintf(buff, "% .*f", CGLM_PRINT_PRECISION, matrix[i][j]);
-      if (j != n - 1)
+      else
-        fprintf(ostream, "\t");
+        cwi = sprintf(buff, "% g", matrix[i][j]);
+      cw[i] = GLM_MAX(cw[i], cwi);
     }
-
-    fprintf(ostream, "|\n");
   }
 
-  fprintf(ostream, "\n");
+  for (i = 0; i < m; i++) {
+    fprintf(ostream, "  |");
+    
+    for (j = 0; j < n; j++)
+      if (matrix[i][j] < CGLM_PRINT_MAX_TO_SHORT)
+        fprintf(ostream, " % *.*f", cw[j], CGLM_PRINT_PRECISION, matrix[j][i]);
+      else
+        fprintf(ostream, " % *g", cw[j], matrix[j][i]);
+    
+    fprintf(ostream, "  |\n");
+  }
+
+  fprintf(ostream, CGLM_PRINT_COLOR_RESET "\n");
 
 #undef m
 #undef n
@@ -121,16 +165,16 @@ glm_vec4_print(vec4              vec,
 
 #define m 4
 
-  fprintf(ostream, "Vector (float%d):\n\t|", m);
+  fprintf(ostream, "Vector (float%d): " CGLM_PRINT_COLOR "\n  (", m);
 
   for (i = 0; i < m; i++) {
-    fprintf(ostream, "%0.4f", vec[i]);
+    if (vec[i] < CGLM_PRINT_MAX_TO_SHORT)
-
+      fprintf(ostream, " % .*f", CGLM_PRINT_PRECISION, vec[i]);
-    if (i != m - 1)
+    else
-      fprintf(ostream, "\t");
+      fprintf(ostream, " % g", vec[i]);
   }
 
-  fprintf(ostream, "|\n\n");
+  fprintf(ostream, "  )" CGLM_PRINT_COLOR_RESET "\n\n");
 
 #undef m
 }
@@ -143,16 +187,16 @@ glm_vec3_print(vec3              vec,
 
 #define m 3
 
-  fprintf(ostream, "Vector (float%d):\n\t|", m);
+  fprintf(ostream, "Vector (float%d): " CGLM_PRINT_COLOR "\n  (", m);
 
   for (i = 0; i < m; i++) {
-    fprintf(ostream, "%0.4f", vec[i]);
+    if (vec[i] < CGLM_PRINT_MAX_TO_SHORT)
-
+      fprintf(ostream, " % .*f", CGLM_PRINT_PRECISION, vec[i]);
-    if (i != m - 1)
+    else
-      fprintf(ostream, "\t");
+      fprintf(ostream, " % g", vec[i]);
   }
 
-  fprintf(ostream, "|\n\n");
+  fprintf(ostream, "  )" CGLM_PRINT_COLOR_RESET "\n\n");
 
 #undef m
 }
@@ -165,16 +209,12 @@ glm_ivec3_print(ivec3             vec,
 
 #define m 3
 
-  fprintf(ostream, "Vector (int%d):\n\t|", m);
+  fprintf(ostream, "Vector (int%d): " CGLM_PRINT_COLOR "\n  (", m);
 
-  for (i = 0; i < m; i++) {
+  for (i = 0; i < m; i++)
-    fprintf(ostream, "%d", vec[i]);
+    fprintf(ostream, " % d", vec[i]);
 
-    if (i != m - 1)
+  fprintf(ostream, "  )" CGLM_PRINT_COLOR_RESET "\n\n");
-      fprintf(ostream, "\t");
-  }
-
-  fprintf(ostream, "|\n\n");
   
 #undef m
 }
@@ -187,16 +227,16 @@ glm_vec2_print(vec2              vec,
 
 #define m 2
 
-  fprintf(ostream, "Vector (float%d):\n\t|", m);
+  fprintf(ostream, "Vector (float%d): " CGLM_PRINT_COLOR "\n  (", m);
 
   for (i = 0; i < m; i++) {
-    fprintf(ostream, "%0.4f", vec[i]);
+    if (vec[i] < CGLM_PRINT_MAX_TO_SHORT)
-
+      fprintf(ostream, " % .*f", CGLM_PRINT_PRECISION, vec[i]);
-    if (i != m - 1)
+    else
-      fprintf(ostream, "\t");
+      fprintf(ostream, " % g", vec[i]);
   }
 
-  fprintf(ostream, "|\n\n");
+  fprintf(ostream, "  )" CGLM_PRINT_COLOR_RESET "\n\n");
 
 #undef m
 }
@@ -209,16 +249,17 @@ glm_versor_print(versor            vec,
 
 #define m 4
 
-  fprintf(ostream, "Versor (float%d):\n\t|", m);
+  fprintf(ostream, "Quaternion (float%d): " CGLM_PRINT_COLOR "\n  (", m);
 
   for (i = 0; i < m; i++) {
-    fprintf(ostream, "%0.4f", vec[i]);
+    if (vec[i] < CGLM_PRINT_MAX_TO_SHORT)
-
+      fprintf(ostream, " % .*f", CGLM_PRINT_PRECISION, vec[i]);
-    if (i != m - 1)
+    else
-      fprintf(ostream, "\t");
+      fprintf(ostream, " % g", vec[i]);
   }
 
-  fprintf(ostream, "|\n\n");
+
+  fprintf(ostream, "  )" CGLM_PRINT_COLOR_RESET "\n\n");
 
 #undef m
 }
@@ -232,24 +273,43 @@ glm_aabb_print(vec3                    bbox[2],
 
 #define m 3
 
-  fprintf(ostream, "AABB (%s):\n", tag ? tag: "float");
+  fprintf(ostream, "AABB (%s): " CGLM_PRINT_COLOR "\n", tag ? tag: "float");
 
   for (i = 0; i < 2; i++) {
-    fprintf(ostream, "\t|");
+    fprintf(ostream, "  (");
     
     for (j = 0; j < m; j++) {
-      fprintf(ostream, "%0.4f", bbox[i][j]);
+      if (bbox[i][j] < CGLM_PRINT_MAX_TO_SHORT)
-
+        fprintf(ostream, " % .*f", CGLM_PRINT_PRECISION, bbox[i][j]);
-      if (j != m - 1)
+      else
-        fprintf(ostream, "\t");
+        fprintf(ostream, " % g", bbox[i][j]);
     }
 
-    fprintf(ostream, "|\n");
+    fprintf(ostream, "  )\n");
   }
 
-  fprintf(ostream, "\n");
+  fprintf(ostream, CGLM_PRINT_COLOR_RESET "\n");
 
 #undef m
 }
 
+#elif !defined(CGLM_NO_PRINTS_NOOP)
+
+#include "common.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+/* NOOP: Remove print from DEBUG */
+#define glm_mat4_print(...)
+#define glm_mat3_print(...)
+#define glm_mat2_print(...)
+#define glm_vec4_print(...)
+#define glm_vec3_print(...)
+#define glm_ivec3_print(...)
+#define glm_vec2_print(...)
+#define glm_versor_print(...)
+#define glm_aabb_print(...)
+
+#endif
 #endif /* cglm_io_h */

include/cglm/mat2.h

@@ -56,7 +56,7 @@
 CGLM_INLINE
 void
 glm_mat2_copy(mat2 mat, mat2 dest) {
-  glm_vec4_copy(mat[0], dest[0]);
+  glm_vec4_ucopy(mat[0], dest[0]);
 }
 
 /*!
@@ -216,7 +216,16 @@ glm_mat2_trace(mat2 m) {
 CGLM_INLINE
 void
 glm_mat2_scale(mat2 m, float s) {
-  glm_vec4_scale(m[0], s, m[0]);
+#if defined( __SSE__ ) || defined( __SSE2__ )
+  glmm_store(m[0], _mm_mul_ps(_mm_loadu_ps(m[0]), _mm_set1_ps(s)));
+#elif defined(CGLM_NEON_FP)
+  vst1q_f32(m[0], vmulq_f32(vld1q_f32(m[0]), vdupq_n_f32(s)));
+#else
+  m[0][0] = m[0][0] * s;
+  m[0][1] = m[0][1] * s;
+  m[1][0] = m[1][0] * s;
+  m[1][1] = m[1][1] * s;
+#endif
 }
 
 /*!

include/cglm/mat3.h

@@ -228,9 +228,11 @@ glm_mat3_transpose(mat3 m) {
 CGLM_INLINE
 void
 glm_mat3_mulv(mat3 m, vec3 v, vec3 dest) {
-  dest[0] = m[0][0] * v[0] + m[1][0] * v[1] + m[2][0] * v[2];
+  vec3 res;
-  dest[1] = m[0][1] * v[0] + m[1][1] * v[1] + m[2][1] * v[2];
+  res[0] = m[0][0] * v[0] + m[1][0] * v[1] + m[2][0] * v[2];
-  dest[2] = m[0][2] * v[0] + m[1][2] * v[1] + m[2][2] * v[2];
+  res[1] = m[0][1] * v[0] + m[1][1] * v[1] + m[2][1] * v[2];
+  res[2] = m[0][2] * v[0] + m[1][2] * v[1] + m[2][2] * v[2];
+  glm_vec3_copy(res, dest);
 }
 
 /*!

include/cglm/ray.h

@@ -29,7 +29,7 @@
  * @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
+ * @return whether there is intersection
  */
 
 CGLM_INLINE
@@ -46,34 +46,30 @@ glm_ray_triangle(vec3   origin,
 
   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;
+    return false;
 
   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;
+    return false;
 
   glm_vec3_cross(t, edge1, q);
 
   v = inv_det * glm_vec3_dot(direction, q);
-
   if (v < 0.0f || u + v > 1.0f)
-    return 0;
+    return false;
 
   dist = inv_det * glm_vec3_dot(edge2, q);
 
   if (d)
-      *d = dist;
+    *d = dist;
 
   return dist > epsilon;
 }

include/cglm/struct.h

@@ -31,6 +31,7 @@ extern "C" {
 #include "struct/project.h"
 #include "struct/sphere.h"
 #include "struct/curve.h"
+#include "struct/affine2d.h"
 
 #ifdef __cplusplus
 }

include/cglm/struct/affine2d.h

@@ -0,0 +1,177 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE mat3s glms_translate2d(mat3 m, vec2 v)
+   CGLM_INLINE mat3s glms_translate2d_x(mat3s m, float x)
+   CGLM_INLINE mat3s glms_translate2d_y(mat3s m, float y)
+   CGLM_INLINE mat3s glms_translate2d_make(vec2s v)
+   CGLM_INLINE mat3s glms_scale2d_make(vec2s v)
+   CGLM_INLINE mat3s glms_scale2d(mat3s m, vec2s v)
+   CGLM_INLINE mat3s glms_scale2d_uni(mat3s m, float s)
+   CGLM_INLINE mat3s glms_rotate2d_make(float angle)
+   CGLM_INLINE mat3s glms_rotate2d(mat3s m, float angle)
+   CGLM_INLINE mat3s glms_rotate2d_to(mat3s m, float angle)
+ */
+
+#ifndef cglms_affine2ds_h
+#define cglms_affine2ds_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../affine2d.h"
+#include "vec3.h"
+#include "mat3.h"
+
+/*!
+ * @brief translate existing 2d transform matrix by v vector
+ *        and stores result in same matrix
+ *
+ * @param[in] m  affine transfrom
+ * @param[in] v  translate vector [x, y]
+ * @returns      affine transfrom
+ */
+CGLM_INLINE
+mat3s
+glms_translate2d(mat3s m, vec2s v) {
+  glm_translate2d(m.raw, v.raw);
+  return m;
+}
+
+/*!
+ * @brief translate existing 2d transform matrix by x factor
+ *
+ * @param[in] m  affine transfrom
+ * @param[in] x  x factor
+ * @returns      affine transfrom
+ */
+CGLM_INLINE
+mat3s
+glms_translate2d_x(mat3s m, float x) {
+  glm_translate2d_x(m.raw, x);
+  return m;
+}
+
+/*!
+ * @brief translate existing 2d transform matrix by y factor
+ *
+ * @param[in] m  affine transfrom
+ * @param[in] y  y factor
+ * @returns      affine transfrom
+ */
+CGLM_INLINE
+mat3s
+glms_translate2d_y(mat3s m, float y) {
+  glm_translate2d_y(m.raw, y);
+  return m;
+}
+
+/*!
+ * @brief creates NEW translate 2d transform matrix by v vector
+ *
+ * @param[in] v  translate vector [x, y]
+ * @returns      affine transfrom
+ */
+CGLM_INLINE
+mat3s
+glms_translate2d_make(vec2s v) {
+  mat3s m;
+  glm_translate2d_make(m.raw, v.raw);
+  return m;
+}
+
+/*!
+ * @brief creates NEW 2d scale matrix by v vector
+ *
+ * @param[in]   v  scale vector [x, y]
+ * @returns affine transfrom
+ */
+CGLM_INLINE
+mat3s
+glms_scale2d_make(vec2s v) {
+  mat3s m;
+  glm_scale2d_make(m.raw, v.raw);
+  return m;
+}
+
+/*!
+ * @brief scales existing 2d transform matrix by v vector
+ *        and stores result in same matrix
+ *
+ * @param[in]  m  affine transfrom
+ * @param[in]  v  scale vector [x, y, z]
+ * @returns       affine transfrom
+ */
+CGLM_INLINE
+mat3s
+glms_scale2d(mat3s m, vec2s v) {
+  mat3s r;
+  glm_scale2d_to(m.raw, v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief applies uniform scale to existing 2d transform matrix v = [s, s, s]
+ *        and stores result in same matrix
+ *
+ * @param[in] m  affine transfrom
+ * @param[in] s  scale factor
+ * @returns      affine transfrom
+ */
+CGLM_INLINE
+mat3s
+glms_scale2d_uni(mat3s m, float s) {
+  glm_scale2d_uni(m.raw, s);
+  return m;
+}
+
+/*!
+ * @brief creates NEW 2d rotation matrix by angle and axis
+ *
+ * axis will be normalized so you don't need to normalize it
+ *
+ * @param[in]  angle  angle (radians)
+ * @returns           affine transfrom
+ */
+CGLM_INLINE
+mat3s
+glms_rotate2d_make(float angle) {
+  mat3s m;
+  glm_rotate2d_make(m.raw, angle);
+  return m;
+}
+
+/*!
+ * @brief rotate existing 2d transform matrix around given axis by angle
+ *
+ * @param[in] m      affine transfrom
+ * @param[in] angle  angle (radians)
+ * @returns          affine transfrom
+ */
+CGLM_INLINE
+mat3s
+glms_rotate2d(mat3s m, float angle) {
+  glm_rotate2d(m.raw, angle);
+  return m;
+}
+
+/*!
+ * @brief rotate existing 2d transform matrix around given axis by angle
+ *
+ * @param[in] m      affine transfrom
+ * @param[in] angle  angle (radians)
+ * @returns          affine transfrom
+ */
+CGLM_INLINE
+mat3s
+glms_rotate2d_to(mat3s m, float angle) {
+  glm_rotate2d(m.raw, angle);
+  return m;
+}
+
+#endif /* cglms_affine2ds_h */

include/cglm/struct/mat2.h

@@ -36,8 +36,8 @@
 #include "../types-struct.h"
 #include "../mat2.h"
 
-#define GLMS_MAT2_IDENTITY_INIT {1.0f, 0.0f, 0.0f, 1.0f}
+#define GLMS_MAT2_IDENTITY_INIT {GLM_MAT2_IDENTITY_INIT}
-#define GLMS_MAT2_ZERO_INIT     {0.0f, 0.0f, 0.0f, 0.0f}
+#define GLMS_MAT2_ZERO_INIT     {GLM_MAT2_ZERO_INIT}
 
 /* for C only */
 #define GLMS_MAT2_IDENTITY ((mat3s)GLMS_MAT2_IDENTITY_INIT)

include/cglm/util.h

@@ -289,7 +289,7 @@ glm_smoothinterpc(float from, float to, float t) {
 CGLM_INLINE
 bool
 glm_eq(float a, float b) {
-  return fabsf(a - b) <= FLT_EPSILON;
+  return fabsf(a - b) <= GLM_FLT_EPSILON;
 }
 
 /*!

include/cglm/vec2-ext.h

@@ -61,8 +61,8 @@ glm_vec2_eq(vec2 v, float val) {
 CGLM_INLINE
 bool
 glm_vec2_eq_eps(vec2 v, float val) {
-  return fabsf(v[0] - val) <= FLT_EPSILON
+  return fabsf(v[0] - val) <= GLM_FLT_EPSILON
-         && fabsf(v[1] - val) <= FLT_EPSILON;
+         && fabsf(v[1] - val) <= GLM_FLT_EPSILON;
 }
 
 /*!
@@ -73,7 +73,7 @@ glm_vec2_eq_eps(vec2 v, float val) {
 CGLM_INLINE
 bool
 glm_vec2_eq_all(vec2 v) {
-  return v[0] == v[1];
+  return glm_vec2_eq_eps(v, v[0]);
 }
 
 /*!
@@ -97,8 +97,8 @@ glm_vec2_eqv(vec2 a, vec2 b) {
 CGLM_INLINE
 bool
 glm_vec2_eqv_eps(vec2 a, vec2 b) {
-  return fabsf(a[0] - b[0]) <= FLT_EPSILON
+  return fabsf(a[0] - b[0]) <= GLM_FLT_EPSILON
-         && fabsf(a[1] - b[1]) <= FLT_EPSILON;
+         && fabsf(a[1] - b[1]) <= GLM_FLT_EPSILON;
 }
 
 /*!

include/cglm/vec3-ext.h

@@ -81,9 +81,9 @@ glm_vec3_eq(vec3 v, float val) {
 CGLM_INLINE
 bool
 glm_vec3_eq_eps(vec3 v, float val) {
-  return fabsf(v[0] - val) <= FLT_EPSILON
+  return fabsf(v[0] - val) <= GLM_FLT_EPSILON
-         && fabsf(v[1] - val) <= FLT_EPSILON
+         && fabsf(v[1] - val) <= GLM_FLT_EPSILON
-         && fabsf(v[2] - val) <= FLT_EPSILON;
+         && fabsf(v[2] - val) <= GLM_FLT_EPSILON;
 }
 
 /*!
@@ -94,7 +94,7 @@ glm_vec3_eq_eps(vec3 v, float val) {
 CGLM_INLINE
 bool
 glm_vec3_eq_all(vec3 v) {
-  return v[0] == v[1] && v[0] == v[2];
+  return glm_vec3_eq_eps(v, v[0]);
 }
 
 /*!
@@ -120,9 +120,9 @@ glm_vec3_eqv(vec3 a, vec3 b) {
 CGLM_INLINE
 bool
 glm_vec3_eqv_eps(vec3 a, vec3 b) {
-  return fabsf(a[0] - b[0]) <= FLT_EPSILON
+  return fabsf(a[0] - b[0]) <= GLM_FLT_EPSILON
-         && fabsf(a[1] - b[1]) <= FLT_EPSILON
+         && fabsf(a[1] - b[1]) <= GLM_FLT_EPSILON
-         && fabsf(a[2] - b[2]) <= FLT_EPSILON;
+         && fabsf(a[2] - b[2]) <= GLM_FLT_EPSILON;
 }
 
 /*!

include/cglm/vec4-ext.h

@@ -92,10 +92,10 @@ glm_vec4_eq(vec4 v, float val) {
 CGLM_INLINE
 bool
 glm_vec4_eq_eps(vec4 v, float val) {
-  return fabsf(v[0] - val) <= FLT_EPSILON
+  return fabsf(v[0] - val) <= GLM_FLT_EPSILON
-         && fabsf(v[1] - val) <= FLT_EPSILON
+         && fabsf(v[1] - val) <= GLM_FLT_EPSILON
-         && fabsf(v[2] - val) <= FLT_EPSILON
+         && fabsf(v[2] - val) <= GLM_FLT_EPSILON
-         && fabsf(v[3] - val) <= FLT_EPSILON;
+         && fabsf(v[3] - val) <= GLM_FLT_EPSILON;
 }
 
 /*!
@@ -106,9 +106,7 @@ glm_vec4_eq_eps(vec4 v, float val) {
 CGLM_INLINE
 bool
 glm_vec4_eq_all(vec4 v) {
-  return v[0] == v[1]
+  return glm_vec4_eq_eps(v, v[0]);
-         && v[0] == v[2]
-         && v[0] == v[3];
 }
 
 /*!
@@ -135,10 +133,10 @@ glm_vec4_eqv(vec4 a, vec4 b) {
 CGLM_INLINE
 bool
 glm_vec4_eqv_eps(vec4 a, vec4 b) {
-  return fabsf(a[0] - b[0]) <= FLT_EPSILON
+  return fabsf(a[0] - b[0]) <= GLM_FLT_EPSILON
-         && fabsf(a[1] - b[1]) <= FLT_EPSILON
+         && fabsf(a[1] - b[1]) <= GLM_FLT_EPSILON
-         && fabsf(a[2] - b[2]) <= FLT_EPSILON
+         && fabsf(a[2] - b[2]) <= GLM_FLT_EPSILON
-         && fabsf(a[3] - b[3]) <= FLT_EPSILON;
+         && fabsf(a[3] - b[3]) <= GLM_FLT_EPSILON;
 }
 
 /*!

include/cglm/vec4.h

@@ -602,7 +602,7 @@ glm_vec4_muladds(vec4 a, float s, vec4 dest) {
                                          _mm_set1_ps(s))));
 #elif defined(CGLM_NEON_FP)
   vst1q_f32(dest, vaddq_f32(vld1q_f32(dest),
-                            vsubq_f32(vld1q_f32(a),
+                            vmulq_f32(vld1q_f32(a),
                                       vdupq_n_f32(s))));
 #else
   dest[0] += a[0] * s;
@@ -680,7 +680,7 @@ glm_vec4_negate_to(vec4 v, vec4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   glmm_store(dest, _mm_xor_ps(glmm_load(v), _mm_set1_ps(-0.0f)));
 #elif defined(CGLM_NEON_FP)
-  vst1q_f32(dest, veorq_s32(vld1q_f32(v), vdupq_n_f32(-0.0f)));
+  vst1q_f32(dest, vnegq_f32(vld1q_f32(v)));
 #else
   dest[0] = -v[0];
   dest[1] = -v[1];

include/cglm/version.h

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

src/affine2d.c

@@ -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
+ */
+
+#include "../include/cglm/cglm.h"
+#include "../include/cglm/call.h"
+
+CGLM_EXPORT
+void
+glmc_translate2d_make(mat3 m, vec2 v) {
+  glm_translate2d_make(m, v);
+}
+
+CGLM_EXPORT
+void
+glmc_translate2d_to(mat3 m, vec2 v, mat3 dest) {
+  glm_translate2d_to(m, v, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_translate2d(mat3 m, vec2 v) {
+  glm_translate2d(m, v);
+}
+
+CGLM_EXPORT
+void
+glmc_translate2d_x(mat3 m, float to) {
+  glm_translate2d_x(m, to);
+}
+
+CGLM_EXPORT
+void
+glmc_translate2d_y(mat3 m, float to) {
+  glm_translate2d_y(m, to);
+}
+
+CGLM_EXPORT
+void
+glmc_scale2d_to(mat3 m, vec2 v, mat3 dest) {
+  glm_scale2d_to(m, v, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_scale2d_make(mat3 m, vec2 v) {
+  glm_scale2d_make(m, v);
+}
+
+CGLM_EXPORT
+void
+glmc_scale2d(mat3 m, vec2 v) {
+  glm_scale2d(m, v);
+}
+
+CGLM_EXPORT
+void
+glmc_scale2d_uni(mat3 m, float s) {
+  glm_scale2d_uni(m, s);
+}
+
+CGLM_EXPORT
+void
+glmc_rotate2d_make(mat3 m, float angle) {
+  glm_rotate2d_make(m, angle);
+}
+
+CGLM_EXPORT
+void
+glmc_rotate2d(mat3 m, float angle) {
+  glm_rotate2d(m, angle);
+}
+
+CGLM_EXPORT
+void
+glmc_rotate2d_to(mat3 m, float angle, mat3 dest) {
+  glm_rotate2d_to(m, angle, dest);
+}

src/config.h

@@ -1,9 +1,9 @@
 /*
-* Copyright (c), Recep Aslantas.
+ * Copyright (c), Recep Aslantas.
-*
+ *
-* MIT License (MIT), http://opensource.org/licenses/MIT
+ * MIT License (MIT), http://opensource.org/licenses/MIT
-* Full license can be found in the LICENSE file
+ * Full license can be found in the LICENSE file
-*/
+ */
 
 #ifndef cglm__config__h_
 #define cglm__config__h_

src/io.c

@@ -5,6 +5,8 @@
  * Full license can be found in the LICENSE file
  */
 
+#define CGLM_LIB_SRC
+
 #include "../include/cglm/cglm.h"
 #include "../include/cglm/call.h"
 

test/CMakeLists.txt

@@ -16,6 +16,7 @@ set(TEST_MAIN tests)
 set(TEST_RUNNER_PARAMS "")
 
 add_executable(${TEST_MAIN} ${TESTFILES})
+target_compile_definitions(${TEST_MAIN} PRIVATE CGLM_DEFINE_PRINTS=1)
 
 target_link_libraries(${TEST_MAIN} PRIVATE cglm m)
 target_include_directories(${TEST_MAIN} PRIVATE

test/include/common.h

@@ -8,6 +8,14 @@
 #ifndef tests_common_h
 #define tests_common_h
 
+#ifndef _USE_MATH_DEFINES
+#  define _USE_MATH_DEFINES       /* for windows */
+#endif
+
+#ifndef _CRT_SECURE_NO_WARNINGS
+#  define _CRT_SECURE_NO_WARNINGS /* for windows */
+#endif
+
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
@@ -30,6 +38,8 @@ typedef struct test_entry_t {
   int    show_output;
 } test_entry_t;
 
+#ifndef GLM_TESTS_NO_COLORFUL_OUTPUT
+
 #define RESET       "\033[0m"
 #define BLACK       "\033[30m"             /* Black */
 #define RED         "\033[31m"             /* Red */
@@ -48,6 +58,28 @@ typedef struct test_entry_t {
 #define BOLDCYAN    "\033[1m\033[36m"      /* Bold Cyan */
 #define BOLDWHITE   "\033[1m\033[37m"      /* Bold White */
 
+#else
+
+#define RESET
+#define BLACK
+#define RED
+#define GREEN
+#define YELLOW
+#define BLUE
+#define MAGENTA
+#define CYAN
+#define WHITE
+#define BOLDBLACK
+#define BOLDRED
+#define BOLDGREEN
+#define BOLDYELLOW
+#define BOLDBLUE
+#define BOLDMAGENTA
+#define BOLDCYAN
+#define BOLDWHITE
+
+#endif
+
 #define TEST_DECLARE(FUN) test_status_t test_ ## FUN(void);
 #define TEST_ENTRY(FUN)   { #FUN, test_ ## FUN, 0, 0 },
 #define TEST_LIST         static test_entry_t tests[] = 

test/src/test_affine2d.h

@@ -0,0 +1,310 @@
+/*
+ * 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, translate2d) {
+  mat3 m1;
+  vec3 v1 = {2.0f, 3.0f, 1.0f}, v2;
+
+  glm_mat3_identity(m1);
+  GLM(translate2d)(m1, (vec2){13.0f, 11.0f});
+  glm_mat3_mulv(m1, v1, v2);
+
+  ASSERT(test_eq(v2[0], 15.0f))
+  ASSERT(test_eq(v2[1], 14.0f))
+  ASSERT(test_eq(v2[2], 1.0f))
+
+  glm_mat3_identity(m1);
+  GLM(translate2d)(m1, (vec2){1.0f, -1.0f});
+  glm_mat3_mulv(m1, v2, v2);
+
+  ASSERT(test_eq(v2[0], 16.0f))
+  ASSERT(test_eq(v2[1], 13.0f))
+  ASSERT(test_eq(v2[2], 1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, translate2d_to) {
+  mat3 m1, m2;
+  vec3 v1 = {2.0f, 3.0f, 1.0f}, v2;
+
+  glm_mat3_identity(m1);
+  GLM(translate2d_to)(m1, (vec2){13.0f, 11.0f}, m2);
+  glm_mat3_mulv(m2, v1, v2);
+
+  ASSERT(test_eq(v2[0], 15.0f))
+  ASSERT(test_eq(v2[1], 14.0f))
+  ASSERT(test_eq(v2[2], 1.0f))
+
+  glm_mat3_identity(m1);
+  GLM(translate2d_to)(m1, (vec2){1.0f, -1.0f}, m2);
+  glm_mat3_mulv(m2, v2, v2);
+
+  ASSERT(test_eq(v2[0], 16.0f))
+  ASSERT(test_eq(v2[1], 13.0f))
+  ASSERT(test_eq(v2[2], 1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, translate2d_x) {
+  mat3 m1;
+  vec3 v1 = {2.0f, 3.0f, 1.0f}, v2;
+
+  glm_mat3_identity(m1);
+  GLM(translate2d_x)(m1, 13.0f);
+  glm_mat3_mulv(m1, v1, v2);
+
+  ASSERT(test_eq(v2[0], 15.0f))
+  ASSERT(test_eq(v2[1], 3.0f))
+  ASSERT(test_eq(v2[2], 1.0f))
+
+  glm_mat3_identity(m1);
+  GLM(translate2d_x)(m1, -1.0f);
+  glm_mat3_mulv(m1, v2, v2);
+
+  ASSERT(test_eq(v2[0], 14.0f))
+  ASSERT(test_eq(v2[1], 3.0f))
+  ASSERT(test_eq(v2[2], 1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, translate2d_y) {
+  mat3 m1;
+  vec3 v1 = {2.0f, 3.0f, 1.0f}, v2;
+
+  glm_mat3_identity(m1);
+  GLM(translate2d_y)(m1, 11.0f);
+  glm_mat3_mulv(m1, v1, v2);
+  
+
+  ASSERT(test_eq(v2[0], 2.0f))
+  ASSERT(test_eq(v2[1], 14.0f))
+  ASSERT(test_eq(v2[2], 1.0f))
+
+  glm_mat3_identity(m1);
+  GLM(translate2d_y)(m1, -1.0f);
+  glm_mat3_mulv(m1, v2, v2);
+
+  ASSERT(test_eq(v2[0], 2.0f))
+  ASSERT(test_eq(v2[1], 13.0f))
+  ASSERT(test_eq(v2[2], 1.0f))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, translate2d_make) {
+  mat3 m1;
+  vec3 v1 = {2.0f, 3.0f, 1.0f}, v2;
+
+  glm_mat3_identity(m1);
+  GLM(translate2d_make)(m1, (vec2){13.0f, 11.0f});
+  glm_mat3_mulv(m1, v1, v2);
+
+  ASSERT(test_eq(v2[0], 15.0f))
+  ASSERT(test_eq(v2[1], 14.0f))
+  ASSERT(test_eq(v2[2], 1.0f))
+
+  glm_mat3_identity(m1);
+  GLM(translate2d_make)(m1, (vec2){-1.0f, -5.0f});
+  glm_mat3_mulv(m1, v2, v2);
+
+  ASSERT(test_eq(v2[0], 14.0f))
+  ASSERT(test_eq(v2[1], 9.0f))
+  ASSERT(test_eq(v2[2], 1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, scale2d_to) {
+  mat3 m1, m2;
+  vec3 v1 = {2.0f, 3.0f, 1.0f}, v2;
+
+  glm_mat3_identity(m1);
+  GLM(scale2d_to)(m1, (vec2){13.0f, 11.0f}, m2);
+  glm_mat3_mulv(m2, v1, v2);
+
+  ASSERT(test_eq(v2[0], 26.0f))
+  ASSERT(test_eq(v2[1], 33.0f))
+  ASSERT(test_eq(v2[2], 1.0f))
+
+  glm_mat3_identity(m1);
+  GLM(scale2d_to)(m1, (vec2){-1.0f, -5.0f}, m2);
+  glm_mat3_mulv(m2, v2, v2);
+
+  ASSERT(test_eq(v2[0], -26.0f))
+  ASSERT(test_eq(v2[1], -165.0f))
+  ASSERT(test_eq(v2[2],  1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, scale2d_make) {
+  mat3 m1;
+  vec3 v1 = {2.0f, 3.0f, 1.0f}, v2;
+
+  GLM(scale2d_make)(m1, (vec2){13.0f, 11.0f});
+  glm_mat3_mulv(m1, v1, v2);
+
+  ASSERT(test_eq(v2[0], 26.0f))
+  ASSERT(test_eq(v2[1], 33.0f))
+  ASSERT(test_eq(v2[2], 1.0f))
+
+  GLM(scale2d_make)(m1, (vec3){-1.0f, -5.0f});
+  glm_mat3_mulv(m1, v2, v2);
+
+  ASSERT(test_eq(v2[0], -26.0f))
+  ASSERT(test_eq(v2[1], -165.0f))
+  ASSERT(test_eq(v2[2],  1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, scale2d) {
+  mat3 m1;
+  vec3 v1 = {2.0f, 3.0f, 1.0f}, v2;
+
+  glm_mat3_identity(m1);
+  GLM(scale2d)(m1, (vec2){13.0f, 11.0f});
+  glm_mat3_mulv(m1, v1, v2);
+
+  ASSERT(test_eq(v2[0], 26.0f))
+  ASSERT(test_eq(v2[1], 33.0f))
+  ASSERT(test_eq(v2[2], 1.0f))
+
+  glm_mat3_identity(m1);
+  GLM(scale2d)(m1, (vec2){-1.0f, -5.0f});
+  glm_mat3_mulv(m1, v2, v2);
+
+  ASSERT(test_eq(v2[0], -26.0f))
+  ASSERT(test_eq(v2[1], -165.0f))
+  ASSERT(test_eq(v2[2],  1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, scale2d_uni) {
+  mat3 m1;
+  vec3 v1 = {2.0f, 3.0f, 1.0f}, v2;
+
+  glm_mat3_identity(m1);
+  GLM(scale2d_uni)(m1, 13.0f);
+  glm_mat3_mulv(m1, v1, v2);
+
+  ASSERT(test_eq(v2[0], 26.0f))
+  ASSERT(test_eq(v2[1], 39.0f))
+  ASSERT(test_eq(v2[2], 1.0f))
+
+  glm_mat3_identity(m1);
+  GLM(scale2d_uni)(m1, -5.0f);
+  glm_mat3_mulv(m1, v2, v2);
+
+  ASSERT(test_eq(v2[0], -130.0f))
+  ASSERT(test_eq(v2[1], -195.0f))
+  ASSERT(test_eq(v2[2],  1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, rotate2d_make) {
+  mat3 m1 = GLM_MAT3_IDENTITY_INIT;
+  vec3 v1 = {0.0f, 1.0f, 1.0f}, v2 = {0.0f, 1.0f, 1.0f};
+
+  GLM(rotate2d_make)(m1, GLM_PI_2f);
+  glm_mat3_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0], -1.0f))
+  ASSERT(test_eq(v1[1],  0.0f))
+  ASSERT(test_eq(v1[2],  1.0f))
+  
+  glm_vec3_copy(v2, v1);
+
+  GLM(rotate2d_make)(m1, -GLM_PI_2f);
+  glm_mat3_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  1.0f))
+  ASSERT(test_eq(v1[1],  0.0f))
+  ASSERT(test_eq(v1[2],  1.0f))
+
+  glm_vec3_copy(v2, v1);
+
+  GLM(rotate2d_make)(m1, GLM_PIf);
+  glm_mat3_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.0f))
+  ASSERT(test_eq(v1[1], -1.0f))
+  ASSERT(test_eq(v1[2],  1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, rotate2d) {
+  mat3 m1 = GLM_MAT3_IDENTITY_INIT;
+  vec3 v1 = {0.0f, 1.0f, 1.0f}, v2 = {0.0f, 1.0f, 1.0f};
+
+  GLM(rotate2d)(m1, GLM_PI_2f);
+  glm_mat3_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0], -1.0f))
+  ASSERT(test_eq(v1[1],  0.0f))
+  ASSERT(test_eq(v1[2],  1.0f))
+  
+  glm_vec3_copy(v2, v1);
+
+  GLM(rotate2d)(m1, GLM_PI_2f);
+  glm_mat3_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.0f))
+  ASSERT(test_eq(v1[1], -1.0f))
+  ASSERT(test_eq(v1[2],  1.0f))
+
+  glm_vec3_copy(v2, v1);
+
+  GLM(rotate2d)(m1, GLM_PI_2f);
+  glm_mat3_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0], 1.0f))
+  ASSERT(test_eq(v1[1], 0.0f))
+  ASSERT(test_eq(v1[2], 1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, rotate2d_to) {
+  mat3 m1 = GLM_MAT3_IDENTITY_INIT, m2;
+  vec3 v1 = {0.0f, 1.0f, 1.0f}, v2 = {0.0f, 1.0f, 1.0f};
+
+  GLM(rotate2d_to)(m1, GLM_PI_2f, m1);
+  glm_mat3_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0], -1.0f))
+  ASSERT(test_eq(v1[1],  0.0f))
+  ASSERT(test_eq(v1[2],  1.0f))
+  
+  glm_vec3_copy(v2, v1);
+
+  GLM(rotate2d_to)(m1, GLM_PI_2f, m2);
+  glm_mat3_mulv(m2, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.0f))
+  ASSERT(test_eq(v1[1], -1.0f))
+  ASSERT(test_eq(v1[2],  1.0f))
+
+  glm_vec3_copy(v2, v1);
+
+  GLM(rotate2d_to)(m2, GLM_PI_2f, m1);
+  glm_mat3_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0], 1.0f))
+  ASSERT(test_eq(v1[1], 0.0f))
+  ASSERT(test_eq(v1[2], 1.0f))
+
+  TEST_SUCCESS
+}

test/src/test_cam.c

@@ -35,9 +35,9 @@ TEST_IMPL(camera_decomp) {
   farVal  = 100.0f;
 
   glm_perspective(fovy, aspect, nearVal, farVal, proj);
-  ASSERT(fabsf(aspect  - glm_persp_aspect(proj)) < FLT_EPSILON)
+  ASSERT(fabsf(aspect  - glm_persp_aspect(proj)) < GLM_FLT_EPSILON)
-  ASSERT(fabsf(fovy    - glm_persp_fovy(proj))   < FLT_EPSILON)
+  ASSERT(fabsf(fovy    - glm_persp_fovy(proj))   < GLM_FLT_EPSILON)
-  ASSERT(fabsf(49.984f - glm_deg(glm_persp_fovy(proj))) < FLT_EPSILON)
+  ASSERT(fabsf(49.984f - glm_deg(glm_persp_fovy(proj))) < GLM_FLT_EPSILON)
 
   glm_persp_sizes(proj, fovy, sizes);
 

test/src/test_camera.h

@@ -0,0 +1,68 @@
+/*
+ * 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, frustum) {
+  mat4  proj;
+  vec4  vp = {0.0f, 0.0f, 800.0f, 600.0f};
+  float left, right, top, bottom, znear, zfar;
+  
+  znear  =  0.1f;
+  zfar   =  100.0f;
+  left   = -100.0f;
+  right  =  100.0f;
+  bottom = -100.0f;
+  top    =  100.0f;
+  
+  GLM(frustum)(left, right, bottom, top, znear, zfar, proj);
+  
+  ASSERT(test_eq(proj[0][1], 0.0f))
+  ASSERT(test_eq(proj[0][2], 0.0f))
+  ASSERT(test_eq(proj[0][3], 0.0f))
+
+  ASSERT(test_eq(proj[1][0], 0.0f))
+  ASSERT(test_eq(proj[1][2], 0.0f))
+  ASSERT(test_eq(proj[1][3], 0.0f))
+
+  ASSERT(test_eq(proj[2][3], -1.0f))
+
+  ASSERT(test_eq(proj[3][0], 0.0f))
+  ASSERT(test_eq(proj[3][1], 0.0f))
+  ASSERT(test_eq(proj[3][3], 0.0f))
+
+  vec4  v1 = {1.0f, 20.0f, znear};
+  vec4  v2 = {1.0f, 20.0f, zfar};
+  vec4  v3, v4;
+
+  /* perspective test */
+  GLM(mat4_mulv)(proj, v1, v3);
+  GLM(project)(v3, proj, vp, v3);
+  
+  ASSERT(v3[0] > v1[0])
+  ASSERT(v3[1] > v1[1])
+  
+  GLM(mat4_mulv)(proj, v2, v4);
+  GLM(project)(v4, proj, vp, v4);
+  
+  ASSERT(v4[0] < v3[0])
+  ASSERT(v4[1] < v3[1])
+  
+  /* not infinity */
+  ASSERT(!GLM(vec4_isinf)(proj[0]))
+  ASSERT(!GLM(vec4_isinf)(proj[1]))
+  ASSERT(!GLM(vec4_isinf)(proj[2]))
+  ASSERT(!GLM(vec4_isinf)(proj[3]))
+  
+  /* not NaN */
+  ASSERT(!GLM(vec4_isnan)(proj[0]))
+  ASSERT(!GLM(vec4_isnan)(proj[1]))
+  ASSERT(!GLM(vec4_isnan)(proj[2]))
+  ASSERT(!GLM(vec4_isnan)(proj[3]))
+
+  TEST_SUCCESS
+}

test/src/test_common.h

@@ -106,7 +106,7 @@ test_rand_quat(versor q);
 CGLM_INLINE
 bool
 test_eq(float a, float b) {
-  return fabsf(a - b) <= 1e-6;
+  return fabsf(a - b) <= GLM_FLT_EPSILON * 10;
 }
 
 CGLM_INLINE

test/src/test_struct.c

@@ -1,9 +1,9 @@
 /*
-* Copyright (c), Recep Aslantas.
+ * Copyright (c), Recep Aslantas.
-*
+ *
-* MIT License (MIT), http://opensource.org/licenses/MIT
+ * MIT License (MIT), http://opensource.org/licenses/MIT
-* Full license can be found in the LICENSE file
+ * Full license can be found in the LICENSE file
-*/
+ */
 
 #include "test_common.h"
 

test/src/tests.c

@@ -22,8 +22,10 @@
 #include "test_project.h"
 #include "test_plane.h"
 #include "test_affine.h"
+#include "test_affine2d.h"
 #include "test_affine_mat.h"
 #include "test_ray.h"
+#include "test_camera.h"
 
 #undef GLM
 #undef GLM_PREFIX
@@ -44,8 +46,10 @@
 #include "test_project.h"
 #include "test_plane.h"
 #include "test_affine.h"
+#include "test_affine2d.h"
 #include "test_affine_mat.h"
 #include "test_ray.h"
+#include "test_camera.h"
 
 #undef GLM
 #undef GLM_PREFIX

test/tests.h

@@ -70,6 +70,33 @@ TEST_DECLARE(glmc_uniscaled)
 TEST_DECLARE(glmc_decompose_rs)
 TEST_DECLARE(glmc_decompose)
 
+/* affine 2d */
+TEST_DECLARE(glm_translate2d)
+TEST_DECLARE(glm_translate2d_to)
+TEST_DECLARE(glm_translate2d_x)
+TEST_DECLARE(glm_translate2d_y)
+TEST_DECLARE(glm_translate2d_make)
+TEST_DECLARE(glm_scale2d_to)
+TEST_DECLARE(glm_scale2d_make)
+TEST_DECLARE(glm_scale2d)
+TEST_DECLARE(glm_scale2d_uni)
+TEST_DECLARE(glm_rotate2d_make)
+TEST_DECLARE(glm_rotate2d)
+TEST_DECLARE(glm_rotate2d_to)
+
+TEST_DECLARE(glmc_translate2d)
+TEST_DECLARE(glmc_translate2d_to)
+TEST_DECLARE(glmc_translate2d_x)
+TEST_DECLARE(glmc_translate2d_y)
+TEST_DECLARE(glmc_translate2d_make)
+TEST_DECLARE(glmc_scale2d_to)
+TEST_DECLARE(glmc_scale2d_make)
+TEST_DECLARE(glmc_scale2d)
+TEST_DECLARE(glmc_scale2d_uni)
+TEST_DECLARE(glmc_rotate2d_make)
+TEST_DECLARE(glmc_rotate2d)
+TEST_DECLARE(glmc_rotate2d_to)
+
 /* mat4 */
 TEST_DECLARE(glm_mat4_ucopy)
 TEST_DECLARE(glm_mat4_copy)
@@ -199,6 +226,10 @@ TEST_DECLARE(glmc_mat2_rmc)
 TEST_DECLARE(camera_lookat)
 TEST_DECLARE(camera_decomp)
 
+TEST_DECLARE(glm_frustum)
+
+TEST_DECLARE(glmc_frustum)
+
 /* project */
 TEST_DECLARE(glm_unprojecti)
 TEST_DECLARE(glm_unproject)
@@ -761,6 +792,33 @@ TEST_LIST {
   TEST_ENTRY(glmc_decompose_rs)
   TEST_ENTRY(glmc_decompose)
   
+  /* affine 2d */
+  TEST_ENTRY(glm_translate2d)
+  TEST_ENTRY(glm_translate2d_to)
+  TEST_ENTRY(glm_translate2d_x)
+  TEST_ENTRY(glm_translate2d_y)
+  TEST_ENTRY(glm_translate2d_make)
+  TEST_ENTRY(glm_scale2d_to)
+  TEST_ENTRY(glm_scale2d_make)
+  TEST_ENTRY(glm_scale2d)
+  TEST_ENTRY(glm_scale2d_uni)
+  TEST_ENTRY(glm_rotate2d_make)
+  TEST_ENTRY(glm_rotate2d)
+  TEST_ENTRY(glm_rotate2d_to)
+
+  TEST_ENTRY(glmc_translate2d)
+  TEST_ENTRY(glmc_translate2d_to)
+  TEST_ENTRY(glmc_translate2d_x)
+  TEST_ENTRY(glmc_translate2d_y)
+  TEST_ENTRY(glmc_translate2d_make)
+  TEST_ENTRY(glmc_scale2d_to)
+  TEST_ENTRY(glmc_scale2d_make)
+  TEST_ENTRY(glmc_scale2d)
+  TEST_ENTRY(glmc_scale2d_uni)
+  TEST_ENTRY(glmc_rotate2d_make)
+  TEST_ENTRY(glmc_rotate2d)
+  TEST_ENTRY(glmc_rotate2d_to)
+  
   /* mat4 */
   TEST_ENTRY(glm_mat4_ucopy)
   TEST_ENTRY(glm_mat4_copy)
@@ -890,6 +948,10 @@ TEST_LIST {
   TEST_ENTRY(camera_lookat)
   TEST_ENTRY(camera_decomp)
   
+  TEST_ENTRY(glm_frustum)
+  
+  TEST_ENTRY(glmc_frustum)
+  
   /* project */
   TEST_ENTRY(glm_unprojecti)
   TEST_ENTRY(glm_unproject)
@@ -992,6 +1054,7 @@ TEST_LIST {
   /* bezier */
   TEST_ENTRY(bezier)
 
+  /* vec2 */
   /* Macros */
 
   TEST_ENTRY(MACRO_GLM_VEC2_ONE_INIT)
@@ -1070,7 +1133,6 @@ TEST_LIST {
   TEST_ENTRY(glmc_vec2_lerp)
 
   /* vec3 */
-
   /* Macros */
 
   TEST_ENTRY(MACRO_GLM_VEC3_ONE_INIT)
@@ -1236,6 +1298,7 @@ TEST_LIST {
   TEST_ENTRY(glmc_vec3_sqrt)
 
   /* vec4 */
+  /* Macros */
 
   TEST_ENTRY(MACRO_GLM_VEC4_ONE_INIT)
   TEST_ENTRY(MACRO_GLM_VEC4_ZERO_INIT)

win/cglm-test.vcxproj

@@ -145,6 +145,7 @@
       <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ConformanceMode>true</ConformanceMode>
       <AdditionalIncludeDirectories>../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <BasicRuntimeChecks>Default</BasicRuntimeChecks>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
@@ -162,6 +163,7 @@
       <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ConformanceMode>true</ConformanceMode>
       <AdditionalIncludeDirectories>../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <BasicRuntimeChecks>Default</BasicRuntimeChecks>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>

win/cglm.vcxproj

@@ -247,6 +247,7 @@
       <PrecompiledHeaderFile />
       <CompileAs>CompileAsC</CompileAs>
       <EnablePREfast>true</EnablePREfast>
+      <BasicRuntimeChecks>Default</BasicRuntimeChecks>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
@@ -266,6 +267,7 @@
       <PrecompiledHeaderFile />
       <CompileAs>CompileAsC</CompileAs>
       <EnablePREfast>true</EnablePREfast>
+      <BasicRuntimeChecks>Default</BasicRuntimeChecks>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>