fix aabb-sphere test (#179 )

Merge pull request #178 from gaurapanasenko/master
Fixed cmake config install path
2026-02-17 03:39:05 +00:00 · 2021-02-28 23:12:06 +03:00 · 2021-02-22 10:31:06 +03:00 · 2021-02-22 04:46:22 +02:00 · 2021-01-25 20:05:58 +03:00 · 2021-01-25 15:50:18 +03:00
63 changed files with 1890 additions and 272 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -75,3 +75,4 @@ Default-568h@2x.png
 build/
 conftest.dir/*
 confdefs.h
+*.xcuserdatad
--- a/.travis.yml
+++ b/.travis.yml
@@ -4,6 +4,12 @@ os:
  - linux
  - osx

+arch:
+  - amd64
+  - ppc64le
+  - s390x
+  - arm64
+
 sudo: required
 dist: trusty

--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,13 +1,9 @@
 cmake_minimum_required(VERSION 3.8.2)
-project(cglm LANGUAGES C)
+project(cglm VERSION 0.8.0 LANGUAGES C)

-set(CGLM_VERSION_MAJOR 0)
-set(CGLM_VERSION_MINOR 7)
-set(CGLM_VERSION_PATCH 3)
-set(CGLM_VERSION ${CGLM_VERSION_MAJOR}.${CGLM_VERSION_MINOR}.${CGLM_VERSION_PATCH})
-
-set(C_STANDARD 11)
-set(C_STANDARD_REQUIRED YES)
+set(CMAKE_C_STANDARD 11)
+set(CMAKE_C_STANDARD_REQUIRED YES)
+set(DEFAULT_BUILD_TYPE "Release")

 set(CGLM_BUILD)
 option(CGLM_SHARED "Shared build" ON)
@@ -22,129 +18,39 @@ else(CGLM_STATIC)
 endif()

 if(CGLM_USE_C99)
-  set(C_STANDARD 99)
+  set(CMAKE_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")
+  add_definitions(-DNDEBUG -D_WINDOWS -D_USRDLL)
+  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")
-    if ("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang")
-		  # Currently, nothing special to be seen here.
-    else()
-		  add_compile_options("-Werror=strict-prototypes")
-    endif()
+  add_compile_options(-Wall -Werror -O3)
 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
-  )
+if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+  message(STATUS "Setting build type to '${DEFAULT_BUILD_TYPE}' as none was specified.")
+  set(CMAKE_BUILD_TYPE "${DEFAULT_BUILD_TYPE}" CACHE STRING "Choose the type of build." FORCE)
+  # Set the possible values of build type for cmake-gui
+  set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
+endif()

-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
-  )
+include(GNUInstallDirs)

-set(HEADERS_SIMD
-  include/cglm/simd/intrin.h
-  include/cglm/simd/x86.h
-  include/cglm/simd/arm.h
-  )
+set(CPACK_PROJECT_NAME ${PROJECT_NAME})
+set(CPACK_PROJECT_VERSION ${PROJECT_VERSION})
+include(CPack)

-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
+# Target Start
+add_library(${PROJECT_NAME}
  ${CGLM_BUILD}
  src/euler.c
  src/affine.c
@@ -166,35 +72,52 @@ add_library(cglm
  src/curve.c
  src/bezier.c
  src/ray.c
-  )
-
-set_target_properties(cglm PROPERTIES VERSION ${CGLM_VERSION} 
-                                    SOVERSION ${CGLM_VERSION_MAJOR})
-
-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
+  src/affine2d.c
  )

 if(CGLM_SHARED)
-	install(
-		TARGETS	cglm
-		EXPORT cglm
-		LIBRARY DESTINATION include/ COMPONENT development NAMELINK_ONLY
-	)
+  add_definitions(-DCGLM_EXPORTS)
+else()
+  target_compile_definitions(${PROJECT_NAME} PUBLIC -DCGLM_STATIC)
 endif()

-INSTALL(DIRECTORY include/ DESTINATION include)
+set_target_properties(${PROJECT_NAME} PROPERTIES
+                              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
+)

 # 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}
+        FILE        "${PROJECT_NAME}Config.cmake"
+        NAMESPACE   ${PROJECT_NAME}::
+        DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME})
+
--- a/3
+++ b/3
@@ -71,3 +71,6 @@ 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
+
+14. ARM NEON: Matrix Vector Multiplication
+https://stackoverflow.com/a/57793352/2676533
--- a/Makefile.am
+++ b/Makefile.am
@@ -12,7 +12,6 @@ AM_CFLAGS = -Wall \
            -O3 \
            -Wstrict-aliasing=2 \
            -fstrict-aliasing \
-            -pedantic \
            -Werror=strict-prototypes

 lib_LTLIBRARIES = libcglm.la
@@ -22,6 +21,9 @@ checkLDFLAGS = -L./.libs \
               -lm \
               -lcglm
 checkCFLAGS = $(AM_CFLAGS) \
+               -std=gnu11 \
+               -O3 \
+               -DCGLM_DEFINE_PRINTS \
               -I./include

 check_PROGRAMS = test/tests
@@ -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 \
@@ -128,7 +132,8 @@ cglm_struct_HEADERS = include/cglm/struct/mat4.h \
                      include/cglm/struct/project.h \
                      include/cglm/struct/sphere.h \
                      include/cglm/struct/color.h \
-                      include/cglm/struct/curve.h
+                      include/cglm/struct/curve.h \
+                      include/cglm/struct/affine2d.h
                      
 libcglm_la_SOURCES=\
    src/euler.c \
@@ -150,7 +155,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 \
--- a/Package.swift
+++ b/Package.swift
@@ -0,0 +1,44 @@
+// swift-tools-version:5.2
+
+import PackageDescription
+
+let package = Package(
+    name: "cglm",
+    products: [
+        .library(name: "cglm", type: .static, targets: ["cglmHeader"]),
+        .library(name: "cglmc", targets: ["cglmCompiled"]),
+    ],
+    dependencies: [],
+    targets: [
+        .target(
+            name: "cglmCompiled",
+            path: "./",
+            exclude: [
+                "./docs",
+                "./src/swift",
+                "./include",
+                "./test",
+                "./win",
+            ],
+            sources: [
+                "./src",
+            ],
+            publicHeadersPath: "./include"
+        ),
+        .target(
+            name: "cglmHeader",
+            path: "./",
+            exclude: [
+                "./docs",
+                "./include",
+                "./test",
+                "./win",
+            ],
+            sources: [
+                "./src/swift",
+            ],
+            publicHeadersPath: "./include"
+        ),
+    ],
+    cLanguageStandard: .c11
+)
--- a/README.md
+++ b/README.md
@@ -25,6 +25,7 @@ you have the latest version
 - **[new option]** by starting v0.4.5, you can disable alignment requirement, check options in docs.  
 - **[major change]** by starting v0.5.0, vec3 functions use **glm_vec3_** namespace, it was **glm_vec_** until v0.5.0
 - **[major change]** by starting v0.5.1, built-in alignment is removed from **vec3** and **mat3** types
+- **[major change]** by starting v0.7.3, inline print functions are disabled in release/production mode to eliminate print costs (see options in documentation). Print output also improved. You can disable colors if you need  (see documentation)

 #### Note for C++ developers:
 If you are not aware of the original GLM library yet, you may also want to look at:
@@ -179,6 +180,69 @@ target_link_libraries(${LIBRARY_NAME} PRIVATE
  cglm)

 add_subdirectory(external/cglm/)
+
+# or you can use find_package to configure cglm
+```
+
+### Meson (All platforms)
+
+```bash
+$ meson build # [Optional] --default-library=static
+$ cd build
+$ ninja
+$ sudo ninja install # [Optional]
+```
+
+##### Meson options with Defaults:
+
+```meson
+c_std=c11
+buildtype=release
+default_library=shared
+enable_tests=false # to run tests: ninja test
+```
+#### Use with your Meson project
+* Example:
+```meson
+# Clone cglm or create a cglm.wrap under <source_root>/subprojects
+project('name', 'c')
+
+cglm_dep = dependency('cglm', fallback : 'cglm', 'cglm_dep')
+
+executable('exe', 'src/main.c', dependencies : cglm_dep)
+```
+
+### Swift (Swift Package Manager)
+
+Currently only default build options are supported. Add **cglm** dependency to your project:
+
+```swift
+...
+Package( 
+  ...
+  dependencies: [
+    ...
+    .package(url: "https://github.com/recp/cglm", .branch("master")),
+  ]
+  ...
+)
+```
+
+Now add **cgml** as a dependency to your target. Product choices are:
+- **cglm** for inlined version of the library which can be linked only statically
+- **cglmc** for a compiled version of the library with no linking limitation
+
+```swift
+...
+.target(
+  ...
+  dependencies: [
+    ...
+    .product(name: "cglm", package: "cglm"),
+  ]
+  ...
+)
+...
 ```

 ### Unix (Autotools)
--- a/cglm.podspec
+++ b/cglm.podspec
@@ -2,10 +2,10 @@ Pod::Spec.new do |s|

  # Description
  s.name         = "cglm"
-  s.version      = "0.7.2"
-  s.summary      = "📽 Optimized OpenGL/Graphics Math (glm) for C"
+  s.version      = "0.7.9"
+  s.summary      = "📽 Highly Optimized 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.
+cglm is math library for graphics programming for C. See the documentation or README for all features.
                   DESC

  s.documentation_url = "http://cglm.readthedocs.io"
@@ -25,4 +25,13 @@ cglm is math library for graphics programming for C. It is similar to original g

  # Linking
  s.library = "m"
+
+  # Configuration
+  s.pod_target_xcconfig = {
+    'CLANG_ENABLE_MODULES' => 'NO',
+    'CLANG_ALLOW_NON_MODULAR_INCLUDES_IN_FRAMEWORK_MODULES' => 'YES',
+    'CLANG_WARN_DOCUMENTATION_COMMENTS' => 'NO',
+    'GCC_C_LANGUAGE_STANDARD' => 'gnu11',
+    'GCC_PREPROCESSOR_DEFINITIONS' => '$(inherited) GLM_TESTS_NO_COLORFUL_OUTPUT'
+  }
 end
--- a/configure.ac
+++ b/configure.ac
@@ -7,7 +7,7 @@
 #*****************************************************************************

 AC_PREREQ([2.69])
-AC_INIT([cglm], [0.7.3], [info@recp.me])
+AC_INIT([cglm], [0.8.0], [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.
--- a/docs/source/affine-mat.rst
+++ b/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
--- a/docs/source/affine.rst
+++ b/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
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

--- a/docs/source/affine2d.rst
+++ b/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
--- a/docs/source/api.rst
+++ b/docs/source/api.rst
@@ -28,6 +28,7 @@ Follow the :doc:`build` documentation for this

   affine
   affine-mat
+   affine2d
   cam
   frustum
   box
--- a/docs/source/build.rst
+++ b/docs/source/build.rst
@@ -47,6 +47,41 @@ If you don't want to install **cglm** to your system's folder you can get static
  
  add_subdirectory(external/cglm/)

+Meson (All platforms):
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. code-block::
+  :linenos:
+
+  $ meson build # [Optional] --default-library=static
+  $ cd build
+  $ ninja
+  $ sudo ninja install # [Optional]
+
+**Meson Options:**
+
+.. code-block:: 
+  :linenos:
+
+  c_std=c11
+  buildtype=release
+  default_library=shared
+  enable_tests=false # to run tests: ninja test
+
+
+**Use with your Meson project**
+
+.. code-block::
+  :linenos:
+
+  # Clone cglm or create a cglm.wrap under <source_root>/subprojects
+  project('name', 'c')
+  
+  cglm_dep = dependency('cglm', fallback : 'cglm', 'cglm_dep')
+  
+  executable('exe', 'src/main.c', dependencies : cglm_dep)
+
+
 Unix (Autotools):
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

--- a/docs/source/conf.py
+++ b/docs/source/conf.py
@@ -25,7 +25,7 @@

 # If your documentation needs a minimal Sphinx version, state it here.
 #
-# needs_sphinx = '1.0'
+# needs_sphinx = '3.0'

 # Add any Sphinx extension module names here, as strings. They can be
 # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
@@ -62,9 +62,9 @@ author = u'Recep Aslantas'
 # built documents.
 #
 # The short X.Y version.
-version = u'0.7.3'
+version = u'0.8.0'
 # The full version, including alpha/beta/rc tags.
-release = u'0.7.3'
+release = u'0.8.0'

 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
@@ -197,3 +197,7 @@ epub_exclude_files = ['search.html']

 # If true, `todo` and `todoList` produce output, else they produce nothing.
 todo_include_todos = True
+
+# -- Options for the C domain ------------------------------------------------
+
+c_id_attributes = ['__restrict']
--- a/docs/source/mat4.rst
+++ b/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]*  **v**     vec3 (right, column vector)
-    | *[out]* **dest**  vec3 (result, column vector)
+      | *[in]*  **m**     mat4(affine transform)
+      | *[in]*  **v**     vec3
+      | *[in]*  **last**  4th item to make it vec4
+      | *[out]* **dest**  result vector (vec3)

 .. c:function:: void  glm_mat4_trace(mat4 m)

--- a/docs/source/opt.rst
+++ b/docs/source/opt.rst
@@ -18,7 +18,7 @@ versor: 16 byte
 By starting **v0.4.5** cglm provides an option to disable alignment requirement.
 To enable this option define **CGLM_ALL_UNALIGNED** macro before all headers.
 You can define it in Xcode, Visual Studio (or other IDEs) or you can also prefer
-to define it in build system. If you use pre-compiled verisons then you
+to define it in build system. If you use pre-compiled versions then you
 have to compile cglm with **CGLM_ALL_UNALIGNED** macro.

 **VERY VERY IMPORTANT:** If you use cglm in multiple projects and
@@ -55,11 +55,20 @@ Print Options
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 1. **CGLM_DEFINE_PRINTS**
-2. **CGLM_NO_PRINTS_NOOP**
+2. **CGLM_NO_PRINTS_NOOP** (use CGLM_DEFINE_PRINTS)

-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.
+Inline prints are only enabled in **DEBUG** mode or if **CGLM_DEFINE_PRINTS** is defined.
+**glmc_** versions will always print too.
+
+Because **cglm** tried to enable print functions in debug mode and disable them in
+release/production mode to eliminate printing costs when we do not need them.
+
+**cglm** checks **DEBUG** or **_DEBUG** macros to test debug mode, if these are not working for you then you can use 
+**CGLM_DEFINE_PRINTS** to force enable, or create a PR to introduce new macro to test against debugging mode.
+
+If DEBUG mode is not enabled then print functions will be emptied to eliminate print function calls.
+You can disable this feature too by defining **CGLM_DEFINE_PRINTS** macro top of cglm header 
+or in project/build settings...

 3. **CGLM_PRINT_PRECISION**    5

@@ -71,3 +80,6 @@ if a number is greater than this value then %g will be used, since this is short

 5. **CGLM_PRINT_COLOR**        "\033[36m"
 6. **CGLM_PRINT_COLOR_RESET**  "\033[0m"
+
+You can disable colorful print output by defining **CGLM_PRINT_COLOR** and **CGLM_PRINT_COLOR_RESET** as empty macro.
+Because some terminals may not support colors.
--- a/docs/source/quat.rst
+++ b/docs/source/quat.rst
@@ -374,7 +374,7 @@ Functions documentation
      | *[in]*       **q**      quaternion
      | *[in]*       **pivot**  pivot

-.. c:function:: void glm_quat_rotate(mat4 m, versor q, mat4 dest)
+.. c:function:: void glm_quat_rotate_atm(mat4 m, versor q, vec3 pivot)

    | rotate NEW transform matrix using quaternion at pivot point
    | this creates rotation matrix, it assumes you don't have a matrix
--- a/docs/source/troubleshooting.rst
+++ b/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?
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

--- a/docs/source/vec2.rst
+++ b/docs/source/vec2.rst
@@ -55,12 +55,12 @@ Functions:
 Functions documentation
 ~~~~~~~~~~~~~~~~~~~~~~~

-.. c:function:: void glm_vec2(vec4 v4, vec2 dest)
+.. c:function:: void glm_vec2(float * v, vec2 dest)

-    init vec2 using vec3
+    init vec2 using vec3 or vec4

    Parameters:
-      | *[in]*  **v3**    vector3
+      | *[in]*  **v**     vector
      | *[out]* **dest**  destination

 .. c:function:: void glm_vec2_copy(vec2 a, vec2 dest)
--- a/include/cglm/affine.h
+++ b/include/cglm/affine.h
@@ -455,7 +455,7 @@ glm_decompose_rs(mat4 m, mat4 r, vec3 s) {
  glm_vec4_scale(r[1], 1.0f/s[1], r[1]);
  glm_vec4_scale(r[2], 1.0f/s[2], r[2]);

-  /* Note from Apple Open Source (asume that the matrix is orthonormal):
+  /* Note from Apple Open Source (assume that the matrix is orthonormal):
     check for a coordinate system flip.  If the determinant
     is -1, then negate the matrix and the scaling factors. */
  glm_vec3_cross(m[0], m[1], v);
--- a/include/cglm/affine2d.h
+++ b/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 */
--- a/include/cglm/box.h
+++ b/include/cglm/box.h
@@ -228,6 +228,8 @@ glm_aabb_aabb(vec3 box[2], vec3 other[2]) {
 * https://github.com/erich666/GraphicsGems/blob/master/gems/BoxSphere.c
 * Solid Box - Solid Sphere test.
 *
+ * Sphere Representation in cglm: [center.x, center.y, center.z, radii]
+ *
 * @param[in]   box    solid bounding box
 * @param[in]   s      solid sphere
 */
@@ -237,13 +239,13 @@ glm_aabb_sphere(vec3 box[2], vec4 s) {
  float dmin;
  int   a, b, c;

-  a = s[0] >= box[0][0];
-  b = s[1] >= box[0][1];
-  c = s[2] >= box[0][2];
+  a = (s[0] < box[0][0]) + (s[0] > box[1][0]);
+  b = (s[1] < box[0][1]) + (s[1] > box[1][1]);
+  c = (s[2] < box[0][2]) + (s[2] > box[1][2]);

-  dmin  = glm_pow2(s[0] - box[a][0])
-        + glm_pow2(s[1] - box[b][1])
-        + glm_pow2(s[2] - box[c][2]);
+  dmin  = glm_pow2((s[0] - box[!(a - 1)][0]) * (a != 0))
+        + glm_pow2((s[1] - box[!(b - 1)][1]) * (b != 0))
+        + glm_pow2((s[2] - box[!(c - 1)][2]) * (c != 0));

  return dmin <= glm_pow2(s[3]);
 }
--- a/include/cglm/call.h
+++ b/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
 }
--- a/include/cglm/call/affine2d.h
+++ b/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 */
--- a/include/cglm/cglm.h
+++ b/include/cglm/cglm.h
@@ -31,5 +31,6 @@
 #include "curve.h"
 #include "bezier.h"
 #include "ray.h"
+#include "affine2d.h"

 #endif /* cglm_h */
--- a/include/cglm/common.h
+++ b/include/cglm/common.h
@@ -8,8 +8,13 @@
 #ifndef cglm_common_h
 #define cglm_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 <stdint.h>
 #include <stddef.h>
@@ -18,7 +23,9 @@
 #include <stdbool.h>

 #if defined(_MSC_VER)
-#  ifdef CGLM_DLL
+#  ifdef CGLM_STATIC
+#    define CGLM_EXPORT
+#  elif defined(CGLM_EXPORTS)
 #    define CGLM_EXPORT __declspec(dllexport)
 #  else
 #    define CGLM_EXPORT __declspec(dllimport)
@@ -35,4 +42,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 */
--- a/include/cglm/io.h
+++ b/include/cglm/io.h
@@ -15,20 +15,49 @@
   CGLM_INLINE void glm_versor_print(versor vec, FILE *ostream);
 */

+/*
+ cglm tried to enable print functions in debug mode and disable them in
+ release/production mode to eliminate printing costs.
+ 
+ if you need to force enable then define CGLM_DEFINE_PRINTS macro not DEBUG one
+ 
+ Print functions are enabled if:
+ 
+ - DEBUG or _DEBUG macro is defined (mostly defined automatically in debugging)
+ - CGLM_DEFINE_PRINTS macro is defined including release/production
+   which makes enabled printing always
+ - glmc_ calls for io are always prints
+
+ */
+
+/* DEPRECATED: CGLM_NO_PRINTS_NOOP (use CGLM_DEFINE_PRINTS) */
+
 #ifndef cglm_io_h
 #define cglm_io_h
 #if defined(DEBUG) || defined(_DEBUG) \
-   || defined(CGLM_DEFINE_PRINTS) || defined(CGLM_LIB_SRC)
+   || defined(CGLM_DEFINE_PRINTS) || defined(CGLM_LIB_SRC) \
+   || defined(CGLM_NO_PRINTS_NOOP)

 #include "common.h"

 #include <stdio.h>
 #include <stdlib.h>

+#ifndef CGLM_PRINT_PRECISION
 #  define CGLM_PRINT_PRECISION    5
+#endif
+
+#ifndef CGLM_PRINT_MAX_TO_SHORT
 #  define CGLM_PRINT_MAX_TO_SHORT 1e5
+#endif
+
+#ifndef CGLM_PRINT_COLOR
 #  define CGLM_PRINT_COLOR        "\033[36m"
+#endif
+
+#ifndef CGLM_PRINT_COLOR_RESET
 #  define CGLM_PRINT_COLOR_RESET  "\033[0m"
+#endif

 CGLM_INLINE
 void
@@ -293,7 +322,7 @@ glm_aabb_print(vec3                    bbox[2],
 #undef m
 }

-#elif !defined(CGLM_NO_PRINTS_NOOP)
+#else

 #include "common.h"

@@ -301,14 +330,15 @@ glm_aabb_print(vec3                    bbox[2],
 #include <stdlib.h>

 /* NOOP: Remove print from DEBUG */
-CGLM_INLINE void glm_mat4_print(mat4 matrix, FILE *o) { }
-CGLM_INLINE void glm_mat3_print(mat3 matrix, FILE *o) { }
-CGLM_INLINE void glm_mat2_print(mat2 matrix, FILE *o) { }
-CGLM_INLINE void glm_vec4_print(vec4 vec, FILE *o) { }
-CGLM_INLINE void glm_vec3_print(vec3 vec, FILE *o) { }
-CGLM_INLINE void glm_ivec3_print(ivec3 vec, FILE *o) { }
-CGLM_INLINE void glm_vec2_print(vec2 vec, FILE *o) { }
-CGLM_INLINE void glm_versor_print(versor vec, FILE *o) { }
-CGLM_INLINE void glm_aabb_print(vec3 bbox[2], const char *t, FILE *o) { }
+#define glm_mat4_print(v, s) (void)v; (void)s;
+#define glm_mat3_print(v, s) (void)v; (void)s;
+#define glm_mat2_print(v, s) (void)v; (void)s;
+#define glm_vec4_print(v, s) (void)v; (void)s;
+#define glm_vec3_print(v, s) (void)v; (void)s;
+#define glm_ivec3_print(v, s) (void)v; (void)s;
+#define glm_vec2_print(v, s) (void)v; (void)s;
+#define glm_versor_print(v, s) (void)v; (void)s;
+#define glm_aabb_print(v, t, s) (void)v; (void)t; (void)s;
+
 #endif
 #endif /* cglm_io_h */
--- a/include/cglm/mat2.h
+++ b/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
 }

 /*!
--- a/include/cglm/mat3.h
+++ b/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];
-  dest[1] = m[0][1] * v[0] + m[1][1] * v[1] + m[2][1] * v[2];
-  dest[2] = m[0][2] * v[0] + m[1][2] * v[1] + m[2][2] * v[2];
+  vec3 res;
+  res[0] = m[0][0] * v[0] + m[1][0] * v[1] + m[2][0] * 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);
 }

 /*!
--- a/include/cglm/mat4.h
+++ b/include/cglm/mat4.h
@@ -358,6 +358,8 @@ void
 glm_mat4_mulv(mat4 m, vec4 v, vec4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
  glm_mat4_mulv_sse2(m, v, dest);
+#elif defined(CGLM_NEON_FP)
+  glm_mat4_mulv_neon(m, v, dest);
 #else
  vec4 res;
  res[0] = m[0][0] * v[0] + m[1][0] * v[1] + m[2][0] * v[2] + m[3][0] * v[3];
@@ -476,6 +478,8 @@ void
 glm_mat4_transpose_to(mat4 m, mat4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
  glm_mat4_transp_sse2(m, dest);
+#elif defined(CGLM_NEON_FP)
+  glm_mat4_transp_neon(m, dest);
 #else
  dest[0][0] = m[0][0]; dest[1][0] = m[0][1];
  dest[0][1] = m[1][0]; dest[1][1] = m[1][1];
@@ -498,6 +502,8 @@ void
 glm_mat4_transpose(mat4 m) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
  glm_mat4_transp_sse2(m, m);
+#elif defined(CGLM_NEON_FP)
+  glm_mat4_transp_neon(m, m);
 #else
  mat4 d;
  glm_mat4_transpose_to(m, d);
@@ -536,12 +542,7 @@ glm_mat4_scale(mat4 m, float s) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
  glm_mat4_scale_sse2(m, s);
 #elif defined(CGLM_NEON_FP)
-  float32x4_t v0;
-  v0 = vdupq_n_f32(s);
-  vst1q_f32(m[0], vmulq_f32(vld1q_f32(m[0]), v0));
-  vst1q_f32(m[1], vmulq_f32(vld1q_f32(m[1]), v0));
-  vst1q_f32(m[2], vmulq_f32(vld1q_f32(m[2]), v0));
-  vst1q_f32(m[3], vmulq_f32(vld1q_f32(m[3]), v0));
+  glm_mat4_scale_neon(m, s);
 #else
  glm_mat4_scale_p(m, s);
 #endif
--- a/include/cglm/simd/neon/mat4.h
+++ b/include/cglm/simd/neon/mat4.h
@@ -12,6 +12,32 @@
 #include "../../common.h"
 #include "../intrin.h"

+CGLM_INLINE
+void
+glm_mat4_scale_neon(mat4 m, float s) {
+  float32x4_t v0;
+  
+  v0 = vdupq_n_f32(s);
+
+  vst1q_f32(m[0], vmulq_f32(vld1q_f32(m[0]), v0));
+  vst1q_f32(m[1], vmulq_f32(vld1q_f32(m[1]), v0));
+  vst1q_f32(m[2], vmulq_f32(vld1q_f32(m[2]), v0));
+  vst1q_f32(m[3], vmulq_f32(vld1q_f32(m[3]), v0));
+}
+
+CGLM_INLINE
+void
+glm_mat4_transp_neon(mat4 m, mat4 dest) {
+  float32x4x4_t vmat;
+  
+  vmat = vld4q_f32(m[0]);
+
+  vst1q_f32(dest[0], vmat.val[0]);
+  vst1q_f32(dest[1], vmat.val[1]);
+  vst1q_f32(dest[2], vmat.val[2]);
+  vst1q_f32(dest[3], vmat.val[3]);
+}
+
 CGLM_INLINE
 void
 glm_mat4_mul_neon(mat4 m1, mat4 m2, mat4 dest) {
@@ -53,5 +79,27 @@ glm_mat4_mul_neon(mat4 m1, mat4 m2, mat4 dest) {
  vst1q_f32(dest[3], d3);
 }

+CGLM_INLINE
+void
+glm_mat4_mulv_neon(mat4 m, vec4 v, vec4 dest) {
+  float32x4_t l0, l1, l2, l3;
+  float32x2_t vlo, vhi;
+  
+  l0  = vld1q_f32(m[0]);
+  l1  = vld1q_f32(m[1]);
+  l2  = vld1q_f32(m[2]);
+  l3  = vld1q_f32(m[3]);
+
+  vlo = vld1_f32(&v[0]);
+  vhi = vld1_f32(&v[2]);
+
+  l0  = vmulq_lane_f32(l0, vlo, 0);
+  l0  = vmlaq_lane_f32(l0, l1, vlo, 1);
+  l0  = vmlaq_lane_f32(l0, l2, vhi, 0);
+  l0  = vmlaq_lane_f32(l0, l3, vhi, 1);
+
+  vst1q_f32(dest, l0);
+}
+
 #endif
 #endif /* cglm_mat4_neon_h */
--- a/include/cglm/simd/x86.h
+++ b/include/cglm/simd/x86.h
@@ -175,7 +175,7 @@ glmm_load3(float v[3]) {
  __m128i xy;
  __m128  z;

-  xy = _mm_loadl_epi64((const __m128i *)v);
+  xy = _mm_loadl_epi64(CGLM_CASTPTR_ASSUME_ALIGNED(v, const __m128i));
  z  = _mm_load_ss(&v[2]);

  return _mm_movelh_ps(_mm_castsi128_ps(xy), z);
@@ -184,7 +184,7 @@ glmm_load3(float v[3]) {
 static inline
 void
 glmm_store3(float v[3], __m128 vx) {
-  _mm_storel_pi((__m64 *)&v[0], vx);
+  _mm_storel_pi(CGLM_CASTPTR_ASSUME_ALIGNED(v, __m64), vx);
  _mm_store_ss(&v[2], glmm_shuff1(vx, 2, 2, 2, 2));
 }

--- a/include/cglm/struct.h
+++ b/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
 }
--- a/include/cglm/struct/affine2d.h
+++ b/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 */
--- a/include/cglm/struct/mat2.h
+++ b/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_ZERO_INIT     {0.0f, 0.0f, 0.0f, 0.0f}
+#define GLMS_MAT2_IDENTITY_INIT {GLM_MAT2_IDENTITY_INIT}
+#define GLMS_MAT2_ZERO_INIT     {GLM_MAT2_ZERO_INIT}

 /* for C only */
 #define GLMS_MAT2_IDENTITY ((mat3s)GLMS_MAT2_IDENTITY_INIT)
--- a/include/cglm/types.h
+++ b/include/cglm/types.h
@@ -32,6 +32,16 @@
 #  define CGLM_ALIGN_MAT CGLM_ALIGN(16)
 #endif

+#ifdef __GNUC__
+#  define CGLM_ASSUME_ALIGNED(expr, alignment) \
+  __builtin_assume_aligned((expr), (alignment))
+#else
+#  define CGLM_ASSUME_ALIGNED(expr, alignment) (expr)
+#endif
+
+#define CGLM_CASTPTR_ASSUME_ALIGNED(expr, type) \
+  ((type*)CGLM_ASSUME_ALIGNED((expr), __alignof__(type)))
+
 typedef float                   vec2[2];
 typedef float                   vec3[3];
 typedef int                    ivec3[3];
--- a/include/cglm/util.h
+++ b/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;
 }

 /*!
--- a/include/cglm/vec2-ext.h
+++ b/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
-         && fabsf(v[1] - val) <= FLT_EPSILON;
+  return fabsf(v[0] - val) <= GLM_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
-         && fabsf(a[1] - b[1]) <= FLT_EPSILON;
+  return fabsf(a[0] - b[0]) <= GLM_FLT_EPSILON
+         && fabsf(a[1] - b[1]) <= GLM_FLT_EPSILON;
 }

 /*!
--- a/include/cglm/vec3-ext.h
+++ b/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
-         && fabsf(v[1] - val) <= FLT_EPSILON
-         && fabsf(v[2] - val) <= FLT_EPSILON;
+  return fabsf(v[0] - val) <= GLM_FLT_EPSILON
+         && fabsf(v[1] - val) <= GLM_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
-         && fabsf(a[1] - b[1]) <= FLT_EPSILON
-         && fabsf(a[2] - b[2]) <= FLT_EPSILON;
+  return fabsf(a[0] - b[0]) <= GLM_FLT_EPSILON
+         && fabsf(a[1] - b[1]) <= GLM_FLT_EPSILON
+         && fabsf(a[2] - b[2]) <= GLM_FLT_EPSILON;
 }

 /*!
@@ -237,9 +237,9 @@ glm_vec3_abs(vec3 v, vec3 dest) {
 CGLM_INLINE
 void
 glm_vec3_fract(vec3 v, vec3 dest) {
-  dest[0] = fminf(v[0] - floorf(v[0]), 0x1.fffffep-1f);
-  dest[1] = fminf(v[1] - floorf(v[1]), 0x1.fffffep-1f);
-  dest[2] = fminf(v[2] - floorf(v[2]), 0x1.fffffep-1f);
+  dest[0] = fminf(v[0] - floorf(v[0]), 0.999999940395355224609375f);
+  dest[1] = fminf(v[1] - floorf(v[1]), 0.999999940395355224609375f);
+  dest[2] = fminf(v[2] - floorf(v[2]), 0.999999940395355224609375f);
 }

 /*!
--- a/include/cglm/vec4-ext.h
+++ b/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
-         && fabsf(v[1] - val) <= FLT_EPSILON
-         && fabsf(v[2] - val) <= FLT_EPSILON
-         && fabsf(v[3] - val) <= FLT_EPSILON;
+  return fabsf(v[0] - val) <= GLM_FLT_EPSILON
+         && fabsf(v[1] - val) <= GLM_FLT_EPSILON
+         && fabsf(v[2] - val) <= GLM_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]
-         && v[0] == v[2]
-         && v[0] == v[3];
+  return glm_vec4_eq_eps(v, v[0]);
 }

 /*!
@@ -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
-         && fabsf(a[1] - b[1]) <= FLT_EPSILON
-         && fabsf(a[2] - b[2]) <= FLT_EPSILON
-         && fabsf(a[3] - b[3]) <= FLT_EPSILON;
+  return fabsf(a[0] - b[0]) <= GLM_FLT_EPSILON
+         && fabsf(a[1] - b[1]) <= GLM_FLT_EPSILON
+         && fabsf(a[2] - b[2]) <= GLM_FLT_EPSILON
+         && fabsf(a[3] - b[3]) <= GLM_FLT_EPSILON;
 }

 /*!
@@ -270,10 +268,10 @@ glm_vec4_abs(vec4 v, vec4 dest) {
 CGLM_INLINE
 void
 glm_vec4_fract(vec4 v, vec4 dest) {
-  dest[0] = fminf(v[0] - floorf(v[0]), 0x1.fffffep-1f);
-  dest[1] = fminf(v[1] - floorf(v[1]), 0x1.fffffep-1f);
-  dest[2] = fminf(v[2] - floorf(v[2]), 0x1.fffffep-1f);
-  dest[3] = fminf(v[3] - floorf(v[3]), 0x1.fffffep-1f);
+  dest[0] = fminf(v[0] - floorf(v[0]), 0.999999940395355224609375f);
+  dest[1] = fminf(v[1] - floorf(v[1]), 0.999999940395355224609375f);
+  dest[2] = fminf(v[2] - floorf(v[2]), 0.999999940395355224609375f);
+  dest[3] = fminf(v[3] - floorf(v[3]), 0.999999940395355224609375f);
 }

 /*!
--- a/include/cglm/vec4.h
+++ b/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];
--- a/include/cglm/version.h
+++ b/include/cglm/version.h
@@ -9,7 +9,7 @@
 #define cglm_version_h

 #define CGLM_VERSION_MAJOR 0
-#define CGLM_VERSION_MINOR 7
-#define CGLM_VERSION_PATCH 3
+#define CGLM_VERSION_MINOR 8
+#define CGLM_VERSION_PATCH 0

 #endif /* cglm_version_h */
--- a/include/module.modulemap
+++ b/include/module.modulemap
@@ -0,0 +1,14 @@
+module cglm {
+    header "cglm/cglm.h"
+    header "cglm/struct.h"
+    
+    export *
+}
+
+module cglmc {
+    header "cglm/cglm.h"
+    header "cglm/struct.h"
+    header "cglm/call.h"
+    
+    export *
+}
--- a/meson.build
+++ b/meson.build
@@ -0,0 +1,108 @@
+project('cglm', 'c',
+    version : '0.8.0', 
+    license : 'mit',
+    default_options : [
+        'c_std=c11',
+        'werror=true',
+        'warning_level=2',
+        'buildtype=release'
+    ]
+)
+
+cc = meson.get_compiler('c')
+
+cglm_install = get_option('install')
+cglm_deps = cc.find_library('m', required : false)
+
+cglm_args = []
+build_args = []
+
+if get_option('default_library') == 'static'
+    cglm_args = '-DCGLM_STATIC'
+endif
+
+if host_machine.system() == 'windows'
+    build_args = '-DCGLM_EXPORTS'
+endif
+
+cglm_inc = include_directories('include')
+
+cglm_src = files(
+    'src/affine.c',
+    'src/affine2d.c',
+    'src/bezier.c',
+    'src/box.c',
+    'src/cam.c',
+    'src/curve.c',
+    'src/ease.c',
+    'src/euler.c',
+    'src/frustum.c',
+    'src/io.c',
+    'src/mat2.c',
+    'src/mat3.c',
+    'src/mat4.c',
+    'src/plane.c',
+    'src/project.c',
+    'src/quat.c',
+    'src/ray.c',
+    'src/sphere.c',
+    'src/vec2.c',
+    'src/vec3.c',
+    'src/vec4.c'
+)
+
+cglm_lib = library('cglm',
+    cglm_src,
+    install : cglm_install,
+    dependencies : cglm_deps,
+    c_args : [ build_args, cglm_args ]
+)
+
+cglm_dep = declare_dependency(
+    link_with : cglm_lib,
+    dependencies : cglm_deps,
+    compile_args : cglm_args,
+    include_directories : cglm_inc,
+    version : meson.project_version()
+)
+
+if meson.version().version_compare('>= 0.54.0')
+    meson.override_dependency('cglm', cglm_dep)
+endif
+
+if cglm_install
+    install_subdir('include/cglm', install_dir : get_option('includedir'))
+
+    pkg = import('pkgconfig')
+    pkg.generate(
+        name : 'cglm',
+        libraries : cglm_lib,
+        extra_cflags : cglm_args,
+        version : meson.project_version(),
+        url : 'https://github.com/recp/cglm',
+        description : 'OpenGL Mathematics (glm) for C'
+    )
+endif
+
+if get_option('build_tests') == true
+
+test_src = files(
+    'test/runner.c',
+    'test/src/test_euler.c',
+    'test/src/test_bezier.c',
+    'test/src/test_cam.c',
+    'test/src/test_struct.c',
+    'test/src/test_clamp.c',
+    'test/src/test_common.c',
+    'test/src/tests.c'
+)
+
+test_exe = executable('tests', 
+    test_src, 
+    dependencies : cglm_dep,
+    c_args : '-DGLM_TESTS_NO_COLORFUL_OUTPUT'
+)
+
+test('cglm.tests', test_exe)
+
+endif
--- a/meson_options.txt
+++ b/meson_options.txt
@@ -0,0 +1,2 @@
+option('build_tests', type : 'boolean', value : false, description : 'Build tests')
+option('install', type : 'boolean', value : true, description : 'Include the library, headers, and pkg-config file in the install target')
--- a/src/affine2d.c
+++ b/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);
+}
--- a/src/swift/empty.c
+++ b/src/swift/empty.c
@@ -0,0 +1 @@
+// This empty file is needed to trick swiftpm to build the header-only version of cglm as swiftpm itself does not support C targets that have no source code files
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -16,8 +16,13 @@ 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)
+if(NOT MSVC)
+  target_link_libraries(${TEST_MAIN} PRIVATE m)
+endif()
+
+target_link_libraries(${TEST_MAIN} PRIVATE cglm)
 target_include_directories(${TEST_MAIN} PRIVATE
  ${CMAKE_CURRENT_LIST_DIR}/include
  ${CMAKE_CURRENT_LIST_DIR}/src
--- a/test/include/common.h
+++ b/test/include/common.h
@@ -8,8 +8,17 @@
 #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
+
+#ifndef _GNU_SOURCE
+#  define _GNU_SOURCE /* for drand48() */
+#endif

 #include <stdlib.h>
 #include <stdio.h>
@@ -33,6 +42,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 */
@@ -51,6 +62,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[] = 
--- a/test/runner.c
+++ b/test/runner.c
@@ -18,6 +18,8 @@ main(int argc, const char * argv[]) {
  test_status_t st;
  int32_t       i, count, passed, failed, maxlen;
  double        start, end, elapsed, total;
+  (void)argc;
+  (void)argv;

  passed = failed = maxlen  = 0;
  total  = 0.0;
--- a/test/src/test_affine2d.h
+++ b/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
+}
--- a/test/src/test_cam.c
+++ b/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(fovy    - glm_persp_fovy(proj))   < FLT_EPSILON)
-  ASSERT(fabsf(49.984f - glm_deg(glm_persp_fovy(proj))) < FLT_EPSILON)
+  ASSERT(fabsf(aspect  - glm_persp_aspect(proj)) < GLM_FLT_EPSILON)
+  ASSERT(fabsf(fovy    - glm_persp_fovy(proj))   < GLM_FLT_EPSILON)
+  ASSERT(fabsf(49.984f - glm_deg(glm_persp_fovy(proj))) < GLM_FLT_EPSILON)

  glm_persp_sizes(proj, fovy, sizes);

--- a/test/src/test_camera.h
+++ b/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
+}
--- a/test/src/test_common.h
+++ b/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
--- a/test/src/tests.c
+++ b/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
--- a/test/tests.h
+++ b/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)
--- a/win/cglm-test.vcxproj
+++ b/win/cglm-test.vcxproj
@@ -31,7 +31,9 @@
  <ItemGroup>
    <ClInclude Include="..\test\include\common.h" />
    <ClInclude Include="..\test\src\test_affine.h" />
+    <ClInclude Include="..\test\src\test_affine2d.h" />
    <ClInclude Include="..\test\src\test_affine_mat.h" />
+    <ClInclude Include="..\test\src\test_camera.h" />
    <ClInclude Include="..\test\src\test_common.h" />
    <ClInclude Include="..\test\src\test_mat2.h" />
    <ClInclude Include="..\test\src\test_mat3.h" />
@@ -145,6 +147,7 @@
      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <ConformanceMode>true</ConformanceMode>
      <AdditionalIncludeDirectories>../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <BasicRuntimeChecks>Default</BasicRuntimeChecks>
    </ClCompile>
    <Link>
      <SubSystem>Console</SubSystem>
@@ -162,6 +165,7 @@
      <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <ConformanceMode>true</ConformanceMode>
      <AdditionalIncludeDirectories>../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <BasicRuntimeChecks>Default</BasicRuntimeChecks>
    </ClCompile>
    <Link>
      <SubSystem>Console</SubSystem>
--- a/win/cglm-test.vcxproj.filters
+++ b/win/cglm-test.vcxproj.filters
@@ -82,5 +82,11 @@
    <ClInclude Include="..\test\src\test_ray.h">
      <Filter>src</Filter>
    </ClInclude>
+    <ClInclude Include="..\test\src\test_affine2d.h">
+      <Filter>src</Filter>
+    </ClInclude>
+    <ClInclude Include="..\test\src\test_camera.h">
+      <Filter>src</Filter>
+    </ClInclude>
  </ItemGroup>
 </Project>
--- a/win/cglm.vcxproj
+++ b/win/cglm.vcxproj
@@ -20,6 +20,7 @@
  </ItemGroup>
  <ItemGroup>
    <ClCompile Include="..\src\affine.c" />
+    <ClCompile Include="..\src\affine2d.c" />
    <ClCompile Include="..\src\bezier.c" />
    <ClCompile Include="..\src\box.c" />
    <ClCompile Include="..\src\cam.c" />
@@ -43,11 +44,13 @@
  <ItemGroup>
    <ClInclude Include="..\include\cglm\affine-mat.h" />
    <ClInclude Include="..\include\cglm\affine.h" />
+    <ClInclude Include="..\include\cglm\affine2d.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" />
    <ClInclude Include="..\include\cglm\call\affine.h" />
+    <ClInclude Include="..\include\cglm\call\affine2d.h" />
    <ClInclude Include="..\include\cglm\call\bezier.h" />
    <ClInclude Include="..\include\cglm\call\box.h" />
    <ClInclude Include="..\include\cglm\call\cam.h" />
@@ -97,6 +100,7 @@
    <ClInclude Include="..\include\cglm\sphere.h" />
    <ClInclude Include="..\include\cglm\struct.h" />
    <ClInclude Include="..\include\cglm\struct\affine.h" />
+    <ClInclude Include="..\include\cglm\struct\affine2d.h" />
    <ClInclude Include="..\include\cglm\struct\box.h" />
    <ClInclude Include="..\include\cglm\struct\cam.h" />
    <ClInclude Include="..\include\cglm\struct\color.h" />
@@ -205,7 +209,7 @@
      <PrecompiledHeader>NotUsing</PrecompiledHeader>
      <WarningLevel>Level3</WarningLevel>
      <Optimization>MaxSpeed</Optimization>
-      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;CGLM_EXPORTS;CGLM_DLL;%(PreprocessorDefinitions);CGLM_DLL</PreprocessorDefinitions>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;CGLM_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <DebugInformationFormat>None</DebugInformationFormat>
      <BasicRuntimeChecks>Default</BasicRuntimeChecks>
      <PrecompiledHeaderFile />
@@ -221,7 +225,7 @@
    <ClCompile>
      <WarningLevel>Level3</WarningLevel>
      <Optimization>MaxSpeed</Optimization>
-      <PreprocessorDefinitions>_DEBUG;_WINDOWS;_USRDLL;CGLM_EXPORTS;CGLM_DLL;%(PreprocessorDefinitions);CGLM_DLL</PreprocessorDefinitions>
+      <PreprocessorDefinitions>_DEBUG;_WINDOWS;_USRDLL;CGLM_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
      <IntrinsicFunctions>true</IntrinsicFunctions>
      <WholeProgramOptimization>true</WholeProgramOptimization>
@@ -242,11 +246,12 @@
      <Optimization>MaxSpeed</Optimization>
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_USRDLL;CGLM_EXPORTS;CGLM_DLL;%(PreprocessorDefinitions);CGLM_DLL</PreprocessorDefinitions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_USRDLL;CGLM_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <DebugInformationFormat>None</DebugInformationFormat>
      <PrecompiledHeaderFile />
      <CompileAs>CompileAsC</CompileAs>
      <EnablePREfast>true</EnablePREfast>
+      <BasicRuntimeChecks>Default</BasicRuntimeChecks>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
@@ -261,11 +266,12 @@
      <Optimization>MaxSpeed</Optimization>
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <PreprocessorDefinitions>NDEBUG;_WINDOWS;_USRDLL;CGLM_EXPORTS;CGLM_DLL;%(PreprocessorDefinitions);CGLM_DLL</PreprocessorDefinitions>
+      <PreprocessorDefinitions>NDEBUG;_WINDOWS;_USRDLL;CGLM_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <DebugInformationFormat>None</DebugInformationFormat>
      <PrecompiledHeaderFile />
      <CompileAs>CompileAsC</CompileAs>
      <EnablePREfast>true</EnablePREfast>
+      <BasicRuntimeChecks>Default</BasicRuntimeChecks>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
--- a/win/cglm.vcxproj.filters
+++ b/win/cglm.vcxproj.filters
@@ -95,6 +95,9 @@
    <ClCompile Include="..\src\ray.c">
      <Filter>src</Filter>
    </ClCompile>
+    <ClCompile Include="..\src\affine2d.c">
+      <Filter>src</Filter>
+    </ClCompile>
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="..\src\config.h">
@@ -358,5 +361,14 @@
    <ClInclude Include="..\include\cglm\simd\sse2\mat2.h">
      <Filter>include\cglm\simd\sse2</Filter>
    </ClInclude>
+    <ClInclude Include="..\include\cglm\call\affine2d.h">
+      <Filter>include\cglm\call</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\affine2d.h">
+      <Filter>include\cglm</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\struct\affine2d.h">
+      <Filter>include\cglm\struct</Filter>
+    </ClInclude>
  </ItemGroup>
 </Project>
Author	SHA1	Message	Date
Recep Aslantas	4a308dcd9e	fix aabb-sphere test (#179 )	2021-02-28 23:12:06 +03:00
Recep Aslantas	fec396950b	Merge pull request #178 from gaurapanasenko/master Fixed cmake config install path	2021-02-22 10:31:06 +03:00
Yehor Panasenko	981af0565e	Fixed cmake config install path Now you can use library with ```cmake find_package(cglm REQUIRED) target_link_libraries(${PROJECT_NAME} PRIVATE ${CGLM_LIBRARY}) ```	2021-02-22 04:46:22 +02:00
Recep Aslantas	1d215ef5f3	Merge pull request #177 from Winter091/master remove wrong c standard bug	2021-01-25 20:05:58 +03:00
winter091	2b7cfde64f	remove wrong c standard bug	2021-01-25 15:50:18 +03:00
Recep Aslantas	c783c42101	Merge pull request #174 from timgates42/bugfix_typo_assume docs: fix simple typo, asume -> assume	2020-12-12 09:18:09 +03:00
Tim Gates	bddcfedead	docs: fix simple typo, asume -> assume There is a small typo in include/cglm/affine.h. Should read `assume` rather than `asume`.	2020-12-12 12:13:48 +11:00
Recep Aslantas	34e7438271	Merge pull request #172 from SanderMertens/master Replace hex floating point literals	2020-12-04 13:00:07 +03:00
Sander Mertens	485ff6bc46	Replace hex floating point literals	2020-12-01 21:49:35 -08:00
Recep Aslantas	4ab9ab4772	docs: fix/improve build documentation	2020-11-21 18:20:04 +03:00
Recep Aslantas	a5ff477fc8	doc: fix duplicate entry warning	2020-11-21 18:13:59 +03:00
Recep Aslantas	254570d006	Merge pull request #169 from podsvirov/docs-c-id-attribute-restrict Fix Documentions WARNING for __restrict attribute	2020-11-21 18:11:28 +03:00
Konstantin Podsvirov	681f20d540	Fix Documentions WARNING for __restrict attribute Add `__restrict` keyword to `c_id_attributes` added in `sphinx 3.0`. Closes #167	2020-11-21 15:34:18 +03:00
Recep Aslantas	fd87f6e2c3	Merge pull request #168 from podsvirov/fix-fix-docs-for-vec2 Fix fix docs for glm_vec2()	2020-11-21 14:32:48 +03:00
Konstantin Podsvirov	2c12c6dce5	Fix fix docs for glm_vec2() Remove extra `\` symbol.	2020-11-21 14:05:19 +03:00
Recep Aslantas	5619527fd3	Update cglm.podspec	2020-11-19 22:42:12 +03:00
Recep Aslantas	8b1c3c3fc4	now working on v0.8.0	2020-11-19 22:21:21 +03:00
Recep Aslantas	ec852c7682	Merge pull request #164 from taisei-project/fix-cast-align simd/x86: fix -Wcast-align warnings (gcc/clang)	2020-11-09 11:19:02 +03:00
Recep Aslantas	5433c9ed6c	Merge pull request #165 from taisei-project/meson-install-option meson: add 'install' option	2020-11-09 11:11:36 +03:00
Andrei Alexeyev	2a2d51624b	meson: add 'install' option This is useful for people who want to use cglm as a meson subproject without polluting the main project's install target.	2020-11-08 20:30:24 +02:00
Andrei Alexeyev	5fa908602f	simd/x86: fix -Wcast-align warnings (gcc/clang) This modifies glmm_{load,store}3 functions to make the compiler assume the v pointer is appropriately aligned for the type it is being cast to. Not tested with CGLM_ALL_UNALIGNED, but it probably doesn't matter.	2020-11-08 20:09:57 +02:00
Recep Aslantas	9da74f9654	Update CREDITS	2020-11-08 17:57:34 +03:00
Recep Aslantas	dddb077b13	ignore xcode user data	2020-11-08 17:42:55 +03:00
Recep Aslantas	6107287c9a	Merge pull request #163 from emersion/glm-vec2-doc-fix Fix docs for glm_vec2()	2020-10-17 09:19:33 +03:00
Simon Ser	7dccbef6e3	Fix docs for glm_vec2() The prototype takes a float *, which can be vec3 or vec4.	2020-10-16 22:32:24 +02:00
Recep Aslantas	d920a62be2	Merge pull request #160 from smumryak/master Added simple swiftpm package file	2020-09-08 11:55:18 +03:00
Serhii Mumriak	73f32b9ef7	Updated README.md with swift configuration information	2020-09-07 17:26:33 -07:00
Serhii Mumriak	2e5257bcc1	Updated 160 PR according review comments.	2020-09-07 17:09:37 -07:00
Serhii Mumriak	65b0b461ab	Added simple swiftpm package file with module map and empty C file to trick the compiler to build the empty C target.	2020-09-05 20:39:12 -07:00
Recep Aslantas	e34601f578	arm neon: multiply mat4 with vec4	2020-08-29 11:51:07 +03:00
Recep Aslantas	fa01a3077b	neon: support transpose mat4 with neon	2020-08-29 11:33:13 +03:00
Recep Aslantas	54f805a62d	neon: move neon-scale to simd header	2020-08-29 11:32:44 +03:00
Recep Aslantas	a05b282fad	now working on v0.7.9	2020-08-29 10:19:50 +03:00
Recep Aslantas	66f6bbde6c	io: deprecate CGLM_NO_PRINTS_NOOP	2020-08-08 10:53:35 +03:00
Recep Aslantas	4054d9a190	io: update documentation + README	2020-08-08 10:47:38 +03:00
Recep Aslantas	c1112f0063	io: make options changable by user * this will help to disable colorful output because not all terminals can print colors.	2020-08-08 10:22:16 +03:00
Recep Aslantas	b62e922f32	io: make prints noop if we can't define them	2020-08-08 10:20:44 +03:00
Recep Aslantas	3c53bed709	now working on v0.7.8	2020-08-08 10:14:41 +03:00
Recep Aslantas	a2b6d71558	Merge pull request #158 from randy408/meson Add meson build support	2020-08-06 00:55:04 +03:00
Randy	fdfceb9f5b	update build.rst	2020-08-05 23:14:05 +02:00
Randy	d273daecfe	update README	2020-08-05 23:05:11 +02:00
Randy	92b75a1345	meson: add option to build tests, default to false	2020-08-05 22:49:52 +02:00
Randy	640795a771	update README	2020-08-04 20:50:33 +02:00
Randy	cad265ebcd	add meson.build	2020-08-04 20:31:39 +02:00
Recep Aslantas	387c33fb4d	Merge pull request #154 from randy408/symbol win32: fix symbol exports	2020-08-04 21:05:28 +03:00
Randy	77585de397	remove CGLM_DLL from vs solution	2020-08-04 19:16:05 +02:00
Randy	a9b06e4b35	gcc: fix warnings (#156 )	2020-08-04 19:57:10 +03:00
Recep Aslantas	7976ac78f2	Merge pull request #155 from randy408/test test: don't link 'm' with msvc	2020-08-04 00:23:13 +03:00
Randy	208f8073ad	test: don't link 'm' with msvc	2020-08-03 22:47:23 +02:00
Randy	009fb966a6	drop CGLM_DLL, add CGLM_STATIC	2020-08-03 22:45:50 +02:00
Randy	09fd9f86b9	update CMakefile	2020-08-03 20:47:12 +02:00
Randy	2ff4ae0b4c	simplify exports check	2020-08-03 20:47:00 +02:00
Randy	aa0a195e98	win32: fix symbol exports	2020-08-03 19:34:45 +02:00
Recep Aslantas	87092e6849	build: add missing files to project files	2020-07-31 20:09:57 +03:00
Recep Aslantas	89ced4166a	Merge pull request #151 from recp/affine2d 2D Affine Transforms	2020-07-31 19:21:30 +03:00
Recep Aslantas	6080099434	2d: add documentation for 2D Affine Transforms	2020-07-31 19:19:07 +03:00
Recep Aslantas	f3735c9036	2d: struct versions of affine2d transforms	2020-07-31 18:38:32 +03:00
Recep Aslantas	2242e9a5e1	2d: add tests for rotate2d and its friends	2020-07-31 18:21:23 +03:00
Recep Aslantas	a12364d486	2d: fix rotate2d and its friends	2020-07-31 18:20:51 +03:00
Recep Aslantas	b133c2e3e3	2d: add rotate2d and its friends	2020-07-31 15:11:00 +03:00
Recep Aslantas	0127d30fa8	2d: add scale2d and its friends	2020-07-31 13:49:33 +03:00
Recep Aslantas	9b13b2f872	add tests for translate2d functions	2020-07-31 12:43:46 +03:00
Recep Aslantas	40d903c2bc	build: define CGLM_DEFINE_PRINTS to enable print functions for test results	2020-07-31 12:41:53 +03:00
Recep Aslantas	06016220c0	build: add affine2d to CMake	2020-07-31 12:41:29 +03:00
Recep Aslantas	bb751d32ca	2d: add translate2d and its friends	2020-07-31 11:40:52 +03:00
Recep Aslantas	6dc37f6cc9	build: CFLAGS for check/test target to match the main target	2020-07-31 00:25:08 +03:00
Recep Aslantas	5ff42799b2	mat2: don't use vec4 directly on mat2 becauce of alignment requirements may be different	2020-07-31 00:06:38 +03:00
Recep Aslantas	2326e627b5	now working on v0.7.7	2020-07-31 00:06:17 +03:00
Recep Aslantas	c18fe8098f	build: try to remove RTC1 from CMake build	2020-07-23 19:12:54 +03:00
Recep Aslantas	a9ed8470b4	win: try to disable /RTC flags	2020-07-20 20:41:00 +03:00
Recep Aslantas	332087da61	Update mat4.rst	2020-07-12 23:30:04 +03:00
Recep Aslantas	56c43d7a74	Update mat4.rst	2020-07-12 23:29:44 +03:00
Recep Aslantas	649f390662	Update mat4.rst	2020-07-12 23:27:15 +03:00
Recep Aslantas	0818bbdf51	Update mat4.rst	2020-07-12 23:24:41 +03:00
Recep Aslantas	edd1517f85	Update mat4.rst	2020-07-12 23:23:50 +03:00
Recep Aslantas	d0c2e8233c	Update mat4.rst	2020-07-12 23:23:06 +03:00
Recep Aslantas	87837aa074	Merge branch 'master' of https://github.com/recp/cglm	2020-07-12 23:21:16 +03:00
Recep Aslantas	62ab6c56c0	Update mat4.rst	2020-07-12 23:21:13 +03:00
Recep Aslantas	a2985aa444	Merge pull request #146 from Terri00/patch-1 mat3_mulv: function behaviour to match with mat4	2020-07-03 23:25:54 +03:00
Harry Godden	7274cee153	mat3_mulv: function behaviour to match with mat4 Using mat3_mulv with the same input/output vector creates undesired results. Respective mat4_mulv function provides temporary vec3 'res'. Updated this function to match behaviour of mat4.	2020-07-02 23:29:10 +01:00
Recep Aslantas	79c44fdbfa	drop pedantic from C Flags and allow extensions this will also suppress warnings on test target	2020-05-29 13:01:36 +03:00
Recep Aslantas	c32e986497	mat2: suppress warnings for initializing mat2 sruct	2020-05-29 12:51:45 +03:00
Recep Aslantas	b953fcf1bd	ci, travis: add multiple cpu arch	2020-05-29 00:47:18 +03:00
Recep Aslantas	c0a4c245f0	tests: add test for frustum	2020-05-28 14:19:35 +03:00
Recep Aslantas	acc0885e52	tests: add option to disable colors in test output * because some terminals may not support colors, in that case, colors can be disabled by defining `GLM_TESTS_NO_COLORFUL_OUTPUT`	2020-05-28 11:47:13 +03:00
Recep Aslantas	f49e8f9991	neon: fix vec4_muladds (critical)	2020-05-26 23:03:32 +03:00
Recep Aslantas	d2e5a3cd5b	use epsilon to compare `vec2/vec3/vec4_eq_all`	2020-05-26 23:02:58 +03:00
Recep Aslantas	a1485a14f6	option to override FLT_EPSILON with GLM_FLT_EPSILON	2020-05-26 23:00:00 +03:00
Recep Aslantas	271e3b15d6	Merge branch 'cmake'	2020-05-25 17:07:46 +03:00
Recep Aslantas	74cf89a82f	build, cmake: update cmake to export Config to use find_package()	2020-05-25 17:06:48 +03:00
Recep Aslantas	8698082411	Merge pull request #143 from recp/cmake Improve CMakeLists.txt	2020-05-22 00:01:42 +03:00
Recep Aslantas	799de548f4	Update CMakeLists.txt	2020-05-18 16:04:15 +03:00
Recep Aslantas	671dae3e22	now working on v0.7.6	2020-05-18 15:55:04 +03:00
Recep Aslantas	7e142132bf	win: suppress warning; C4005: '_CRT_SECURE_NO_WARNINGS': macro redefinition	2020-05-17 19:24:48 +03:00
Recep Aslantas	0ccd58da01	docs: add clarification/troubleshooting for a crash type	2020-05-16 22:37:16 +03:00
Recep Aslantas	4211c230cc	now working on v0.7.5	2020-05-16 22:11:54 +03:00
Recep Aslantas	269bdb3dbd	fix arm neon build	2020-05-11 20:19:05 +03:00
Recep Aslantas	b032b803ca	build, cmake: use PROJECT_VERSION_** to set so version instead of custom variables	2020-05-10 23:54:55 +03:00
Recep Aslantas	26a638e11d	io: make print functions macro to supress unused parameter warrnings	2020-05-03 14:10:24 +03:00
Recep Aslantas	099522ada3	fix LICENSE alignments	2020-05-02 22:32:57 +03:00
Recep Aslantas	4903dd62ea	now working on v0.7.4	2020-05-02 22:32:53 +03:00
				`@@ -0,0 +1 @@`
				`// This empty file is needed to trick swiftpm to build the header-only version of cglm as swiftpm itself does not support C targets that have no source code files`